/*******************************************************************************
* Copyright (C) 2004-2006 Intel Corp. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* - Redistributions of source code must retain the above copyright notice,
* this list of conditions and the following disclaimer.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the name of Intel Corp. nor the names of its
* contributors may be used to endorse or promote products derived from this
* software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL Intel Corp. OR THE CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*******************************************************************************/
/**
* @author Anas Nashif
*/
#ifdef HAVE_CONFIG_H
#include <wsman_config.h>
#endif
#include <string.h>
#include <stdlib.h>
#include <stdio.h>
#include <ctype.h>
#include <u/libu.h>
#include "wsman-xml-api.h"
#include "wsman-client-api.h"
#include "wsman-soap.h"
#include "wsman-dispatcher.h"
#include "wsman-xml.h"
#include "wsman-xml-serializer.h"
#include "wsman-soap-envelope.h"
#include "wsman-soap-message.h"
#include "wsman-faults.h"
#define FAULT_XPATH_EXPR "/s:Envelope/s:Body/s:Fault/s:Code/s:Value"
#define FAULT_SUBCODE_VALUE_XPATH "/s:Envelope/s:Body/s:Fault/s:Code/s:Subcode/s:Value"
WsmanFaultDetailTable fault_detail_table[] =
{
{ WSMAN_DETAIL_OK, NULL },
{ WSMAN_DETAIL_ACK, "Ack" },
{ WSMAN_DETAIL_ACTION_MISMATCH, "ActionMismatch" },
{ WSMAN_DETAIL_ALREADY_EXISTS, "AlreadyExists" },
{ WSMAN_DETAIL_AMBIGUOUS_SELECTORS, "AmbigousSelectors" },
{ WSMAN_DETAIL_ASYNCHRONOUS_REQUEST, "AsynchronousRequest" },
{ WSMAN_DETAIL_ADDRESSING_MODE, "AddressingMode" },
{ WSMAN_DETAIL_AUTHERIZATION_MODE, "AutherizationMode" },
{ WSMAN_DETAIL_BOOKMARKS, "Bookmarks" },
{ WSMAN_DETAIL_CHARECHTER_SET, "CharechterSet" },
{ WSMAN_DETAIL_DELIVERY_RETRIES, "DeliveryRetries" },
{ WSMAN_DETAIL_DUPLICATE_SELECTORS, "DuplicateSelectors" },
{ WSMAN_DETAIL_ENCODING_TYPE, "EncodingType" },
{ WSMAN_DETAIL_ENUMERATION_MODE, "EnumerationMode" },
{ WSMAN_DETAIL_EXPIRATION_TIME, "ExpirationTime" },
{ WSMAN_DETAIL_EXPIRED, "Expired" },
{ WSMAN_DETAIL_FILTERING_REQUIRED, "FilteringRequired" },
{ WSMAN_DETAIL_FORMAT_MISMATCH, "FormatMismatch" },
{ WSMAN_DETAIL_FORMAT_SECURITY_TOKEN, "FormatSecurityTocken" },
{ WSMAN_DETAIL_FRAGMENT_LEVEL_ACCESS, "FragmentLevelAccess" },
{ WSMAN_DETAIL_HEARTBEATS, "Heartbeats" },
{ WSMAN_DETAIL_INSECURE_ADDRESS, "InsecureAddress" },
{ WSMAN_DETAIL_INSUFFICIENT_SELECTORS, "InsufficientSelectors" },
{ WSMAN_DETAIL_INVALID, "Invalid" },
{ WSMAN_DETAIL_INVALID_ADDRESS, "InvalidAddress" },
{ WSMAN_DETAIL_INVALID_FORMAT, "InvalidFormat" },
{ WSMAN_DETAIL_INVALID_FRAGMENT, "InvalidFragment" },
{ WSMAN_DETAIL_INVALID_NAME, "InvalidName" },
{ WSMAN_DETAIL_INVALID_NAMESPACE, "InvalidNamespace" },
{ WSMAN_DETAIL_INVALID_RESOURCEURI, "InvalidResourceURI" },
{ WSMAN_DETAIL_INVALID_SELECTOR_ASSIGNMENT, "InvalidSelectorAssignment" },
{ WSMAN_DETAIL_INVALID_SYSTEM, "InvalidSystem" },
{ WSMAN_DETAIL_INVALID_TIMEOUT, "InvalidTimeout" },
{ WSMAN_DETAIL_INVALID_VALUE, "InvalidValue" },
{ WSMAN_DETAIL_INVALID_VALUES, "InvalidValues" },
{ WSMAN_DETAIL_LOCALE, "Locale" },
{ WSMAN_DETAIL_MAX_ELEMENTS, "MaxElements" },
{ WSMAN_DETAIL_MAX_ENVELOPE_POLICY, "MaxEnvelopePolicy" },
{ WSMAN_DETAIL_MAX_ENVELOPE_SIZE, "MaxEnvelopeSize" },
{ WSMAN_DETAIL_MAX_TIME, "MaxTime" },
{ WSMAN_DETAIL_MINIMUM_ENVELOPE_LIMIT, "MinimumEnvelopeLimit" },
{ WSMAN_DETAIL_MISSING_VALUES, "MissingValues" },
{ WSMAN_DETAIL_NOT_SUPPORTED, "NotSupported" },
{ WSMAN_DETAIL_OPERATION_TIMEOUT, "OperationTimeout" },
{ WSMAN_DETAIL_OPTION_LIMIT, "OptionLimit" },
{ WSMAN_DETAIL_OPTION_SET, "OptionSet" },
{ WSMAN_DETAIL_READ_ONLY, "ReadOnly" },
{ WSMAN_DETAIL_RESOURCE_OFFLINE, "ResourceOffline" },
{ WSMAN_DETAIL_RENAME, "Rename" },
{ WSMAN_DETAIL_SELECTOR_LIMIT, "SelectorLimit" },
{ WSMAN_DETAIL_SERVICE_ENVELOPE_LIMIT, "ServiceEnvelopeLimit" },
{ WSMAN_DETAIL_TARGET_ALREADY_EXISTS, "TargetAlreadyExists" },
{ WSMAN_DETAIL_TYPE_MISMATCH, "TypeMismatch" },
{ WSMAN_DETAIL_UNEXPECTED_SELECTORS, "UnexpectedSelectors" },
{ WSMAN_DETAIL_UNREPORTABLE_SUCCESS, "UnreportableSuccess" },
{ WSMAN_DETAIL_UNUSABLE_ADDRESS, "UnusableAddress" },
{ WSMAN_DETAIL_URI_LIMIT_EXCEEDED, "UriLimitExceeded" },
{ WSMAN_DETAIL_WHITESPACE, "Whitespace" },
// WS-Addressing
{ WSA_DETAIL_DUPLICATE_MESSAGE_ID, "DuplicateMessageID" },
// SOAP
{ SOAP_DETAIL_HEADER_NOT_UNDERSTOOD, "HeaderNotUnderstood" },
// WS-Trust
{WST_DETAIL_UNSUPPORTED_TOKENTYPE, "UnsupportedTokenType"},
// OpenWSMAN
{ OWSMAN_DETAIL_ENDPOINT_ERROR, "Unknown" },
{ OWSMAN_NO_DETAILS, "Unknown" }
};
WsmanFaultCodeTable fault_code_table[] =
{
{
SOAP_FAULT_MUSTUNDERSTAND,
WSMAN_STATUS_BAD_REQUEST,
WSA_ACTION_FAULT,
XML_NS_SOAP_1_2,
FAULT_MUSTUNDERSTAND_CODE,
"",
"The WS-Management service cannot process a SOAP header in the request that " \
"is marked as mustUnderstand by the client. This could be caused by the use " \
"of a version of the protocol which is not supported, or may be an " \
"incompatibility between the client and server implementations."
},
{
WSA_ENDPOINT_UNAVAILABLE,
WSMAN_STATUS_SERVICE_UNAVAILABLE,
WSA_ACTION_FAULT,
XML_NS_ADDRESSING,
FAULT_SENDER_CODE,
"EndpointUnavailable",
""
},
{
WSMAN_ACCESS_DENIED,
WSMAN_STATUS_UNAUTHORIZED,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"AccessDenied",
"The sender was not authorized to access the resource."
},
{
WSA_ACTION_NOT_SUPPORTED,
WSMAN_STATUS_NOT_IMPLEMENTED,
WSA_ACTION_FAULT,
XML_NS_ADDRESSING,
FAULT_SENDER_CODE,
"ActionNotSupported",
"The action is not supported by the service."
},
{
WSMAN_ALREADY_EXISTS,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"AlreadyExists",
"The sender attempted to create a resource which already exists."
},
{
WSEN_CANNOT_PROCESS_FILTER,
WSMAN_STATUS_UNPROCESSABLE_ENTITY,
WSENUM_ACTION_FAULT,
XML_NS_ENUMERATION,
FAULT_SENDER_CODE,
"CannotProcessFilter",
"The requested filter could not be processed."
},
{
WSMAN_CANNOT_PROCESS_FILTER,
WSMAN_STATUS_UNPROCESSABLE_ENTITY,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"CannotProcessFilter",
"The requested filter could not be processed."
},
{
WSMAN_CONCURRENCY,
WSMAN_STATUS_CONFLICT,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"Concurrency",
"The action could not be completed due to concurrency or locking problems."
},
{
WSA_DESTINATION_UNREACHABLE,
WSMAN_STATUS_SERVICE_UNAVAILABLE,
WSA_ACTION_FAULT,
XML_NS_ADDRESSING,
FAULT_SENDER_CODE,
"DestinationUnreachable",
"No route can be determined to reach the destination role defined by the WS-Addressing To."
},
{
WSMAN_ENCODING_LIMIT,
WSMAN_STATUS_REQUEST_ENTITY_TOO_LARGE,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"EncodingLimit",
"An internal encoding limit was exceeded in a request or would be violated if the message were processed."
},
{
WSA_ENDPOINT_UNAVAILABLE,
WSMAN_STATUS_SERVICE_UNAVAILABLE,
WSA_ACTION_FAULT,
XML_NS_ADDRESSING,
FAULT_RECEIVER_CODE,
"EndpointUnavailable",
"The specified endpoint is currently unavailable."
},
{
WSEN_FILTER_DIALECT_REQUESTED_UNAVAILABLE,
WSMAN_STATUS_NOT_IMPLEMENTED,
WSENUM_ACTION_FAULT,
XML_NS_ENUMERATION,
FAULT_SENDER_CODE,
"FilterDialectRequestedUnavailable",
"The requested filtering dialect is not supported."
},
{
WSEN_FILTERING_NOT_SUPPORTED,
WSMAN_STATUS_NOT_IMPLEMENTED,
WSENUM_ACTION_FAULT,
XML_NS_ENUMERATION,
FAULT_SENDER_CODE,
"FilteringNotSupported",
"Filtered enumeration is not supported."
},
{
WSMAN_FRAGMENT_DIALECT_NOT_SUPPORTED,
WSMAN_STATUS_NOT_IMPLEMENTED,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_RECEIVER_CODE,
"FragmentDialectNotSupported",
"The requested fragment filtering dialect or language is not supported."
},
{
WSMAN_INTERNAL_ERROR,
WSMAN_STATUS_INTERNAL_SERVER_ERROR,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_RECEIVER_CODE,
"InternalError",
"The service cannot comply with the request due to internal processing errors."
},
{
WSEN_INVALID_ENUMERATION_CONTEXT,
WSMAN_STATUS_BAD_REQUEST,
WSENUM_ACTION_FAULT,
XML_NS_ENUMERATION,
FAULT_RECEIVER_CODE,
"InvalidEnumerationContext",
"The supplied enumeration context is invalid."
},
{
WSA_INVALID_MESSAGE_INFORMATION_HEADER,
WSMAN_STATUS_BAD_REQUEST,
WSA_ACTION_FAULT,
XML_NS_ADDRESSING,
FAULT_SENDER_CODE,
"InvalidMessageInformationHeader",
"A message information header is not valid and the message cannot be processed."
},
{
WSMAN_INVALID_OPTIONS,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"InvalidOptions",
"One or more options are not valid."
},
{
WSMAN_INVALID_PARAMETER,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"InvalidParameter",
"An operation parameter is not valid."
},
{
WXF_INVALID_REPRESENTATION,
WSMAN_STATUS_BAD_REQUEST,
WSXF_ACTION_FAULT,
XML_NS_TRANSFER,
FAULT_SENDER_CODE,
"InvalidRepresentation",
"The XML content is not valid."
},
{
WSMAN_INVALID_SELECTORS,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"InvalidSelectors",
"The Selectors for the resource are not valid."
},
{
WSA_MESSAGE_INFORMATION_HEADER_REQUIRED,
WSMAN_STATUS_BAD_REQUEST,
WSA_ACTION_FAULT,
XML_NS_ADDRESSING,
FAULT_SENDER_CODE,
"MessageInformationHeaderRequired",
"A required header is missing."
},
{
WSMAN_NO_ACK,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"NoAck",
"The receiver did not acknowledge the event delivery."
},
{
WSMAN_QUOTA_LIMIT,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"QuotaLimit",
"The service is busy servicing other requests."
},
{
WSMAN_SCHEMA_VALIDATION_ERROR,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"SchemaValidationError",
"The supplied SOAP violates the corresponding XML schema definition."
},
{
WSEN_TIMED_OUT,
WSMAN_STATUS_REQUEST_TIMEOUT,
WSENUM_ACTION_FAULT,
XML_NS_ENUMERATION,
FAULT_RECEIVER_CODE,
"TimedOut",
"The enumerator has timed out and is no longer valid."
},
{
WSMAN_TIMED_OUT,
WSMAN_STATUS_REQUEST_TIMEOUT,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_RECEIVER_CODE,
"TimedOut",
"The operation has timed out."
},
{
WSEN_UNSUPPORTED_EXPIRATION_TYPE,
WSMAN_STATUS_BAD_REQUEST,
WSENUM_ACTION_FAULT,
XML_NS_ENUMERATION,
FAULT_RECEIVER_CODE,
"UnsupportedExpirationType",
"The specified expiration type is not supported."
},
{
WSMAN_UNSUPPORTED_FEATURE,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_SENDER_CODE,
"UnsupportedFeature",
"The specified feature is not supported."
},
{
WSMAN_UNSUPPORTED_FEATURE,
WSMAN_STATUS_NOT_IMPLEMENTED,
WSMAN_ACTION_FAULT,
XML_NS_CIM_BINDING,
FAULT_RECEIVER_CODE,
"PolymorphismModeNotSupported",
"The specified feature is not supported."
},
{
WSMAN_EVENT_DELIVER_TO_UNUSABLE,
WSMAN_STATUS_BAD_REQUEST,
WSMAN_ACTION_FAULT,
XML_NS_CIM_BINDING,
FAULT_RECEIVER_CODE,
"DevliveryToUnusable",
"The wse:NotifyTo address is not usable because it is incorrect"
},
{
WSMB_POLYMORPHISM_MODE_NOT_SUPPORTED,
WSMAN_STATUS_NOT_IMPLEMENTED,
WSMB_ACTION_FAULT,
XML_NS_WS_MAN,
FAULT_RECEIVER_CODE,
"UnsupportedFeature",
"The specified feature is not supported."
},
{
WSE_INVALID_EXPIRATION_TIME,
WSMAN_STATUS_BAD_REQUEST,
WSEVENT_ACTION_FAULT,
XML_NS_EVENTING,
FAULT_SENDER_CODE,
"InvalidExpirationTime",
"The expiration time is invalid"
},
{
WSE_DELIVERY_MODE_REQUESTED_UNAVAILABLE,
WSMAN_STATUS_BAD_REQUEST,
WSEVENT_ACTION_FAULT,
XML_NS_EVENTING,
FAULT_SENDER_CODE,
"DeliveryModeRequestedUnavailable",
"The requested delivery mode is not supported"
},
{
WSE_FILTERING_NOT_SUPPORTED,
WSMAN_STATUS_BAD_REQUEST,
WSEVENT_ACTION_FAULT,
XML_NS_EVENTING,
FAULT_SENDER_CODE,
"FilteringNotSupported",
"Filtering over the event source is not supported"
},
{
WSE_INVALID_MESSAGE,
WSMAN_STATUS_BAD_REQUEST,
WSEVENT_ACTION_FAULT,
XML_NS_EVENTING,
FAULT_SENDER_CODE,
"InvalidMessage",
"The request message has unknown or invalid content and cannot be processed."
},
{
WSMAN_UNKNOWN,
WSMAN_STATUS_NOT_FOUND,
NULL,
NULL,
NULL,
NULL,
NULL
}
};
void
wsman_set_fault( WsmanMessage *msg,
WsmanFaultCodeType fault_code,
WsmanFaultDetailType fault_detail_code,
const char *details)
{
if (!wsman_fault_occured(msg)) {
msg->status.fault_code = fault_code;
msg->status.fault_detail_code = fault_detail_code;
if (details) msg->status.fault_msg = strdup(details);
}
return;
}
int
wsman_is_fault_envelope( WsXmlDocH doc )
{
WsXmlNodeH node = ws_xml_get_child(ws_xml_get_soap_body(doc),
0 , XML_NS_SOAP_1_2 , SOAP_FAULT);
if ( node != NULL )
return 1;
else
return 0;
}
WsmanKnownStatusCode
wsman_find_httpcode_for_value( WsXmlDocH doc )
{
WsmanKnownStatusCode httpcode = 200;
char *xp = ws_xml_get_xpath_value(doc, FAULT_XPATH_EXPR );
if (xp != NULL) {
if (strcmp(xp, FAULT_RECEIVER_CODE_NS) == 0 )
httpcode = WSMAN_STATUS_INTERNAL_SERVER_ERROR;
else if (strcmp(xp, FAULT_SENDER_CODE_NS) == 0 )
httpcode = WSMAN_STATUS_BAD_REQUEST;
}
u_free(xp);
return httpcode;
}
WsmanKnownStatusCode wsman_find_httpcode_for_fault_code( WsmanFaultCodeType faultCode )
{
int i;
WsmanKnownStatusCode httpcode = WSMAN_STATUS_INTERNAL_SERVER_ERROR;
int nfaults = sizeof (fault_code_table) / sizeof (fault_code_table[0]);
for (i = 0; i < nfaults; i++)
{
if (fault_code_table[i].fault_code == faultCode )
{
httpcode = fault_code_table[i].http_code;
break;
}
}
return httpcode;
}
WsXmlDocH
wsman_generate_fault( WsXmlDocH in_doc,
WsmanFaultCodeType faultCode,
WsmanFaultDetailType faultDetail,
char *fault_msg)
{
int i;
WsXmlDocH fault = NULL;
char *reason, *detail;
int nfaults = sizeof (fault_code_table) / sizeof (fault_code_table[0]);
for (i = 0; i < nfaults; i++) {
if (fault_code_table[i].fault_code == faultCode ) {
if (fault_msg!= NULL ) {
reason = fault_msg;
} else {
reason = fault_code_table[i].reason;
}
if (faultDetail>0) {
detail = fault_detail_table[faultDetail].detail;
}
else
detail = NULL;
fault = wsman_create_fault_envelope( in_doc,
fault_code_table[i].code,
fault_code_table[i].subCodeNs,
fault_code_table[i].subCode,
fault_code_table[i].fault_action,
NULL,
reason,
detail);
break;
}
}
return fault;
}
void
wsman_generate_fault_buffer ( WsXmlDocH in_doc,
const char *encoding,
WsmanFaultCodeType faultCode,
WsmanFaultDetailType faultDetail,
char * fault_msg,
char **buf,
int* len)
{
WsXmlDocH doc = wsman_generate_fault( in_doc, faultCode, faultDetail, fault_msg);
debug( "Fault Code: %d", faultCode);
ws_xml_dump_memory_enc(doc, buf, len, encoding);
ws_xml_destroy_doc(doc);
return;
}
int
wsman_fault_occured(WsmanMessage *msg)
{
return (msg->status.fault_code == WSMAN_RC_OK ) ? 0 : 1;
}
void
wsman_get_fault_status_from_doc (WsXmlDocH doc, WsmanStatus *status)
{
int i;
char *subcode_value = ws_xml_get_xpath_value(doc, FAULT_SUBCODE_VALUE_XPATH);
char *subcode_value_msg;
char *start_pos;
if (strlen(subcode_value) == 0)
return;
subcode_value_msg = calloc(1, strlen(subcode_value));
if (subcode_value_msg == NULL) {
error("Out of memory");
status->fault_code = WSMAN_INTERNAL_ERROR;
/* some default values */
status->fault_detail_code = OWSMAN_SYSTEM_ERROR;
status->fault_msg = NULL;
return;
}
start_pos = strchr(subcode_value, ':');
if (start_pos != NULL) {
strcpy(subcode_value_msg, start_pos+1);
int nfaults = sizeof (fault_code_table) / sizeof (fault_code_table[0]);
for (i = 0; i < nfaults; i++) {
if (strcmp (subcode_value_msg , fault_code_table[i].subCode) == 0) {
status->fault_code = fault_code_table[i].fault_code;
/* some default values */
status->fault_detail_code = 0;
status->fault_msg = NULL;
free(subcode_value_msg);
return;
}
}
}
free(subcode_value_msg);
return;
}