/*!
* \brief Separates the action node from the root DOM node.
*
* \return 0 if successful, or -1 if fails.
*/
static UPNP_INLINE int get_action_node(
/*! [in] The root DOM node. */
IXML_Document *TempDoc,
/*! [in] IXML_Node name to be searched. */
char *NodeName,
/*! [out] Response/Output node. */
IXML_Document **RespNode)
{
IXML_Node *EnvpNode = NULL;
IXML_Node *BodyNode = NULL;
IXML_Node *ActNode = NULL;
DOMString ActNodeName = NULL;
const DOMString nodeName;
int ret_code = -1; /* error, by default */
IXML_NodeList *nl = NULL;
UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__,
"get_action_node(): node name =%s\n ", NodeName);
*RespNode = NULL;
/* Got the Envelope node here */
EnvpNode = ixmlNode_getFirstChild((IXML_Node *) TempDoc);
if (!EnvpNode)
goto error_handler;
nl = ixmlElement_getElementsByTagNameNS((IXML_Element *)EnvpNode,
"*", "Body");
if (!nl)
goto error_handler;
BodyNode = ixmlNodeList_item(nl, 0);
if (!BodyNode)
goto error_handler;
/* Got action node here */
ActNode = ixmlNode_getFirstChild(BodyNode);
if (!ActNode)
goto error_handler;
/* Test whether this is the action node */
nodeName = ixmlNode_getNodeName(ActNode);
if (!nodeName)
goto error_handler;
if (!strstr(nodeName, NodeName))
goto error_handler;
else {
ActNodeName = ixmlPrintNode(ActNode);
if (!ActNodeName)
goto error_handler;
ret_code = ixmlParseBufferEx(ActNodeName, RespNode);
if (ret_code != IXML_SUCCESS) {
ixmlFreeDOMString(ActNodeName);
ret_code = -1;
goto error_handler;
}
}
/* success */
ret_code = 0;
error_handler:
ixmlFreeDOMString(ActNodeName);
if (nl)
ixmlNodeList_free(nl);
return ret_code;
}
/*================================================================
* ixmlParseBuffer
* Parse xml file stored in buffer.
* External function.
*
*=================================================================*/
IXML_Document *
ixmlParseBuffer( IN char *buffer )
{
IXML_Document *doc = NULL;
ixmlParseBufferEx( buffer, &doc );
return doc;
}
/************************************************************************
* Function : addToAction
*
* Parameters:
* IN int response: flag to tell if the ActionDoc is for response
* or request
* INOUT IXML_Document **ActionDoc: request or response document
* IN char *ActionName: Name of the action request or response
* IN char *ServType: Service type
* IN char * ArgName: Name of the argument
* IN char * ArgValue: Value of the argument
*
* Description:
* This function adds the argument in the action request or response.
* This function creates the action request or response if it is a first
* argument else it will add the argument in the document
*
* Returns: int
* returns UPNP_E_SUCCESS if successful else returns appropriate error
***************************************************************************/
static int
addToAction( IN int response,
INOUT IXML_Document ** ActionDoc,
IN const char *ActionName,
IN const char *ServType,
IN const char *ArgName,
IN const char *ArgValue )
{
char *ActBuff = NULL;
IXML_Node *node = NULL;
IXML_Element *Ele = NULL;
IXML_Node *Txt = NULL;
int rc = 0;
if( ActionName == NULL || ServType == NULL ) {
return UPNP_E_INVALID_PARAM;
}
if( *ActionDoc == NULL ) {
ActBuff = ( char * )malloc( HEADER_LENGTH );
if( ActBuff == NULL ) {
return UPNP_E_OUTOF_MEMORY;
}
if( response ) {
sprintf( ActBuff,
"<u:%sResponse xmlns:u=\"%s\">\r\n</u:%sResponse>",
ActionName, ServType, ActionName );
} else {
sprintf( ActBuff,
"<u:%s xmlns:u=\"%s\">\r\n</u:%s>",
ActionName, ServType, ActionName );
}
rc = ixmlParseBufferEx( ActBuff, ActionDoc );
free( ActBuff );
if( rc != IXML_SUCCESS ) {
if( rc == IXML_INSUFFICIENT_MEMORY ) {
return UPNP_E_OUTOF_MEMORY;
} else {
return UPNP_E_INVALID_DESC;
}
}
}
if( ArgName != NULL /*&& ArgValue != NULL */ ) {
node = ixmlNode_getFirstChild( ( IXML_Node * ) * ActionDoc );
Ele = ixmlDocument_createElement( *ActionDoc, ArgName );
if( ArgValue ) {
Txt = ixmlDocument_createTextNode( *ActionDoc, ArgValue );
ixmlNode_appendChild( ( IXML_Node * ) Ele, Txt );
}
ixmlNode_appendChild( node, ( IXML_Node * ) Ele );
}
return UPNP_E_SUCCESS;
}
/****************************************************************************
* Function : soap_device_callback
*
* Parameters :
* IN http_parser_t *parser : Parsed request received by the device
* IN http_message_t* request : HTTP request
* INOUT SOCKINFO *info : socket info
*
* Description : This is a callback called by minisever after receiving
* the request from the control point. This function will start
* processing the request. It calls handle_invoke_action to handle the
* SOAP action
*
* Return : void
*
* Note :
****************************************************************************/
void
soap_device_callback( IN http_parser_t * parser,
IN http_message_t * request,
INOUT SOCKINFO * info )
{
int err_code;
const char *err_str;
memptr action_name;
IXML_Document *xml_doc = NULL;
// set default error
err_code = SOAP_INVALID_ACTION;
err_str = Soap_Invalid_Action;
// validate: content-type == text/xml
if( !has_xml_content_type( request ) ) {
goto error_handler;
}
// type of request
if( get_request_type( request, &action_name ) != 0 ) {
goto error_handler;
}
// parse XML
err_code = ixmlParseBufferEx( request->entity.buf, &xml_doc );
if( err_code != IXML_SUCCESS ) {
if( err_code == IXML_INSUFFICIENT_MEMORY ) {
err_code = UPNP_E_OUTOF_MEMORY;
} else {
err_code = SOAP_ACTION_FAILED;
}
err_str = "XML error";
goto error_handler;
}
if( action_name.length == 0 ) {
// query var
handle_query_variable( info, request, xml_doc );
} else {
// invoke action
handle_invoke_action( info, request, action_name, xml_doc );
}
err_code = 0; // no error
error_handler:
ixmlDocument_free( xml_doc );
if( err_code != 0 ) {
send_error_response( info, err_code, err_str, request );
}
}
/*!
* \brief This is a callback called by minisever after receiving the request
* from the control point. This function will start processing the request.
* It calls handle_invoke_action to handle the SOAP action.
*/
void soap_device_callback(
int iface,
/*! [in] Parsed request received by the device. */
http_parser_t *parser,
/*! [in] HTTP request. */
http_message_t *request,
/*! [in,out] Socket info. */
SOCKINFO *info)
{
int err_code;
const char *err_str;
memptr action_name;
IXML_Document *xml_doc = NULL;
/* set default error */
err_code = SOAP_INVALID_ACTION;
err_str = Soap_Invalid_Action;
/* validate: content-type == text/xml */
if (!has_xml_content_type(request))
goto error_handler;
/* type of request */
if (get_request_type(request, &action_name) != 0)
goto error_handler;
/* parse XML */
err_code = ixmlParseBufferEx(request->entity.buf, &xml_doc);
if (err_code != IXML_SUCCESS) {
if (err_code == IXML_INSUFFICIENT_MEMORY)
err_code = UPNP_E_OUTOF_MEMORY;
else
err_code = SOAP_ACTION_FAILED;
err_str = "XML error";
goto error_handler;
}
if (action_name.length == 0)
/* query var */
handle_query_variable(iface, info, request, xml_doc);
else
/* invoke action */
handle_invoke_action(iface, info, request, action_name, xml_doc);
/* no error */
err_code = 0;
error_handler:
ixmlDocument_free(xml_doc);
if (err_code != 0)
send_error_response(info, err_code, err_str, request);
return;
parser = parser;
}
/************************************************************************
* Function : gena_process_notification_event
*
* Parameters:
* IN SOCKINFO *info: Socket structure containing the device socket
* information
* IN http_message_t* event: The http message contains the GENA
* notification
*
* Description:
* This function processes NOTIFY events that are sent by devices.
* called by genacallback()
*
* Returns: void
*
* Note : called by genacallback()
****************************************************************************/
void
gena_process_notification_event( IN SOCKINFO * info,
IN http_message_t * event )
{
struct Upnp_Event event_struct;
int eventKey;
token sid;
client_subscription *subscription;
IXML_Document *ChangedVars;
struct Handle_Info *handle_info;
void *cookie;
Upnp_FunPtr callback;
UpnpClient_Handle client_handle;
memptr sid_hdr;
memptr nt_hdr,
nts_hdr;
memptr seq_hdr;
// get SID
if( httpmsg_find_hdr( event, HDR_SID, &sid_hdr ) == NULL ) {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
return;
}
sid.buff = sid_hdr.buf;
sid.size = sid_hdr.length;
// get event key
if( httpmsg_find_hdr( event, HDR_SEQ, &seq_hdr ) == NULL ||
matchstr( seq_hdr.buf, seq_hdr.length, "%d%0", &eventKey )
!= PARSE_OK ) {
error_respond( info, HTTP_BAD_REQUEST, event );
return;
}
// get NT and NTS headers
if( httpmsg_find_hdr( event, HDR_NT, &nt_hdr ) == NULL ||
httpmsg_find_hdr( event, HDR_NTS, &nts_hdr ) == NULL ) {
error_respond( info, HTTP_BAD_REQUEST, event );
return;
}
// verify NT and NTS headers
if( memptr_cmp( &nt_hdr, "upnp:event" ) != 0 ||
memptr_cmp( &nts_hdr, "upnp:propchange" ) != 0 ) {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
return;
}
// parse the content (should be XML)
if( !has_xml_content_type( event ) ||
event->msg.length == 0 ||
( ixmlParseBufferEx( event->entity.buf, &ChangedVars ) ) !=
IXML_SUCCESS ) {
error_respond( info, HTTP_BAD_REQUEST, event );
return;
}
HandleLock( );
// get client info
if( GetClientHandleInfo( &client_handle, &handle_info ) != HND_CLIENT ) {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
HandleUnlock( );
ixmlDocument_free( ChangedVars );
return;
}
// get subscription based on SID
if( ( subscription = GetClientSubActualSID( handle_info->ClientSubList,
&sid ) ) == NULL ) {
if( eventKey == 0 ) {
// wait until we've finished processing a subscription
// (if we are in the middle)
// this is to avoid mistakenly rejecting the first event if we
// receive it before the subscription response
HandleUnlock( );
// try and get Subscription Lock
// (in case we are in the process of subscribing)
SubscribeLock( );
// get HandleLock again
HandleLock( );
if( GetClientHandleInfo( &client_handle, &handle_info )
!= HND_CLIENT ) {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
SubscribeUnlock( );
HandleUnlock( );
ixmlDocument_free( ChangedVars );
return;
}
if( ( subscription =
GetClientSubActualSID( handle_info->ClientSubList,
&sid ) ) == NULL ) {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
SubscribeUnlock( );
HandleUnlock( );
ixmlDocument_free( ChangedVars );
return;
}
SubscribeUnlock( );
} else {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
HandleUnlock( );
ixmlDocument_free( ChangedVars );
return;
}
}
error_respond( info, HTTP_OK, event ); // success
// fill event struct
strcpy( event_struct.Sid, subscription->sid );
event_struct.EventKey = eventKey;
event_struct.ChangedVariables = ChangedVars;
// copy callback
callback = handle_info->Callback;
cookie = handle_info->Cookie;
HandleUnlock( );
// make callback with event struct
// In future, should find a way of mainting
// that the handle is not unregistered in the middle of a
// callback
callback( UPNP_EVENT_RECEIVED, &event_struct, cookie );
ixmlDocument_free( ChangedVars );
}
int rtpxmlParseBufferEx(char *buffer, RTPXML_Document** doc)
{
return ixmlParseBufferEx(buffer, (IXML_Document **) doc);
}
/************************************************************************
* Function : makeAction
*
* Parameters:
* IN int response: flag to tell if the ActionDoc is for response
* or request
* IN char * ActionName: Name of the action request or response
* IN char * ServType: Service type
* IN int NumArg :Number of arguments in the action request or response
* IN char * Arg : pointer to the first argument
* IN va_list ArgList: Argument list
*
* Description:
* This function creates the action request or response from the argument
* list.
* Returns: IXML_Document *
* returns action request or response document if successful
* else returns NULL
***************************************************************************/
static IXML_Document *
makeAction( IN int response,
IN const char *ActionName,
IN const char *ServType,
IN int NumArg,
IN const char *Arg,
IN va_list ArgList )
{
const char *ArgName,
*ArgValue;
char *ActBuff;
int Idx = 0;
IXML_Document *ActionDoc;
IXML_Node *node;
IXML_Element *Ele;
IXML_Node *Txt = NULL;
if( ActionName == NULL || ServType == NULL ) {
return NULL;
}
ActBuff = ( char * )malloc( HEADER_LENGTH );
if( ActBuff == NULL ) {
return NULL;
}
if( response ) {
sprintf( ActBuff, "<u:%sResponse xmlns:u=\"%s\"></u:%sResponse>",
ActionName, ServType, ActionName );
} else {
sprintf( ActBuff, "<u:%s xmlns:u=\"%s\"></u:%s>",
ActionName, ServType, ActionName );
}
if( ixmlParseBufferEx( ActBuff, &ActionDoc ) != IXML_SUCCESS ) {
free( ActBuff );
return NULL;
}
free( ActBuff );
if( ActionDoc == NULL ) {
return NULL;
}
if( NumArg > 0 ) {
//va_start(ArgList, Arg);
ArgName = Arg;
while( Idx++ != NumArg ) {
ArgValue = va_arg( ArgList, const char * );
if( ArgName != NULL ) {
node = ixmlNode_getFirstChild( ( IXML_Node * ) ActionDoc );
Ele = ixmlDocument_createElement( ActionDoc, ArgName );
if( ArgValue ) {
Txt =
ixmlDocument_createTextNode( ActionDoc, ArgValue );
ixmlNode_appendChild( ( IXML_Node * ) Ele, Txt );
}
ixmlNode_appendChild( node, ( IXML_Node * ) Ele );
}
ArgName = va_arg( ArgList, const char * );
}
//va_end(ArgList);
}
/****************************************************************************
* Function : get_response_value
*
* Parameters :
* IN http_message_t* hmsg : HTTP response message
* IN int code : return code in the HTTP response
* IN char*name : name of the action
* OUT int *upnp_error_code : UPnP error code
* OUT IXML_Node ** action_value : SOAP response node
* OUT DOMString * str_value : state varible value ( in the case of
* querry state variable request)
*
* Description : This function handles the response coming back from the
* device. This function parses the response and gives back the SOAP
* response node.
*
* Return : int
* return the type of the SOAP message if successful else returns
* appropriate error.
*
* Note :
****************************************************************************/
static int
get_response_value( IN http_message_t * hmsg,
IN int code,
IN char *name,
OUT int *upnp_error_code,
OUT IXML_Node ** action_value,
OUT DOMString * str_value )
{
IXML_Node *node = NULL;
IXML_Node *root_node = NULL;
IXML_Node *error_node = NULL;
IXML_Document *doc = NULL;
char *node_str = NULL;
const char *temp_str = NULL;
DOMString error_node_str = NULL;
int err_code;
xboolean done = FALSE;
char *names[5];
const DOMString nodeValue;
err_code = UPNP_E_BAD_RESPONSE; // default error
// only 200 and 500 status codes are relevant
if( ( hmsg->status_code != HTTP_OK &&
hmsg->status_code != HTTP_INTERNAL_SERVER_ERROR ) ||
!has_xml_content_type( hmsg ) ) {
goto error_handler;
}
if( ixmlParseBufferEx( hmsg->entity.buf, &doc ) != IXML_SUCCESS ) {
goto error_handler;
}
root_node = ixmlNode_getFirstChild( ( IXML_Node * ) doc );
if( root_node == NULL ) {
goto error_handler;
}
if( code == SOAP_ACTION_RESP ) {
//
// try reading soap action response
//
assert( action_value != NULL );
*action_value = NULL;
names[0] = "Envelope";
names[1] = "Body";
names[2] = name;
if( dom_find_deep_node( names, 3, root_node, &node ) ==
UPNP_E_SUCCESS ) {
node_str = ixmlPrintNode( node );
if( node_str == NULL ) {
err_code = UPNP_E_OUTOF_MEMORY;
goto error_handler;
}
if( ixmlParseBufferEx( node_str,
( IXML_Document ** ) action_value ) !=
IXML_SUCCESS ) {
err_code = UPNP_E_BAD_RESPONSE;
goto error_handler;
}
err_code = SOAP_ACTION_RESP;
done = TRUE;
}
} else if( code == SOAP_VAR_RESP ) {
// try reading var response
assert( str_value != NULL );
*str_value = NULL;
names[0] = "Envelope";
names[1] = "Body";
names[2] = "QueryStateVariableResponse";
names[3] = "return";
if( dom_find_deep_node( names, 4, root_node, &node )
== UPNP_E_SUCCESS ) {
nodeValue = get_node_value( node );
if( nodeValue == NULL ) {
goto error_handler;
}
*str_value = ixmlCloneDOMString( nodeValue );
err_code = SOAP_VAR_RESP;
done = TRUE;
}
}
if( !done ) {
// not action or var resp; read error code and description
*str_value = NULL;
names[0] = "Envelope";
names[1] = "Body";
names[2] = "Fault";
names[3] = "detail";
names[4] = "UPnPError";
if( dom_find_deep_node( names, 5, root_node, &error_node )
!= UPNP_E_SUCCESS ) {
goto error_handler;
}
if( dom_find_node( "errorCode", error_node, &node )
!= UPNP_E_SUCCESS ) {
goto error_handler;
}
temp_str = get_node_value( node );
if( temp_str == NULL ) {
goto error_handler;
}
*upnp_error_code = atoi( temp_str );
if( *upnp_error_code > 400 ) {
err_code = *upnp_error_code;
goto error_handler; // bad SOAP error code
}
if( code == SOAP_VAR_RESP ) {
if( dom_find_node( "errorDescription", error_node, &node )
!= UPNP_E_SUCCESS ) {
goto error_handler;
}
nodeValue = get_node_value( node );
if( nodeValue == NULL ) {
goto error_handler;
}
*str_value = ixmlCloneDOMString( nodeValue );
if( *str_value == NULL ) {
goto error_handler;
}
err_code = SOAP_VAR_RESP_ERROR;
}
else if( code == SOAP_ACTION_RESP ) {
error_node_str = ixmlPrintNode( error_node );
if( error_node_str == NULL ) {
err_code = UPNP_E_OUTOF_MEMORY;
goto error_handler;
}
if( ixmlParseBufferEx( error_node_str,
( IXML_Document ** ) action_value ) !=
IXML_SUCCESS ) {
err_code = UPNP_E_BAD_RESPONSE;
goto error_handler;
}
err_code = SOAP_ACTION_RESP_ERROR;
}
}
error_handler:
ixmlDocument_free( doc );
ixmlFreeDOMString( node_str );
ixmlFreeDOMString( error_node_str );
return err_code;
}
void gena_process_notification_event(
SOCKINFO *info,
http_message_t *event)
{
struct Upnp_Event event_struct;
IXML_Document *ChangedVars = NULL;
int eventKey;
token sid;
ClientSubscription *subscription = NULL;
struct Handle_Info *handle_info;
void *cookie;
Upnp_FunPtr callback;
UpnpClient_Handle client_handle;
const UpnpString *tmpSID = NULL;
memptr sid_hdr;
memptr nt_hdr,
nts_hdr;
memptr seq_hdr;
/* get SID */
if (httpmsg_find_hdr(event, HDR_SID, &sid_hdr) == NULL) {
error_respond(info, HTTP_PRECONDITION_FAILED, event);
goto exit_function;
}
sid.buff = sid_hdr.buf;
sid.size = sid_hdr.length;
/* get event key */
if (httpmsg_find_hdr(event, HDR_SEQ, &seq_hdr) == NULL ||
matchstr(seq_hdr.buf, seq_hdr.length, "%d%0", &eventKey) != PARSE_OK) {
error_respond( info, HTTP_BAD_REQUEST, event );
goto exit_function;
}
/* get NT and NTS headers */
if (httpmsg_find_hdr(event, HDR_NT, &nt_hdr) == NULL ||
httpmsg_find_hdr(event, HDR_NTS, &nts_hdr) == NULL) {
error_respond( info, HTTP_BAD_REQUEST, event );
goto exit_function;
}
/* verify NT and NTS headers */
if (memptr_cmp(&nt_hdr, "upnp:event") != 0 ||
memptr_cmp(&nts_hdr, "upnp:propchange") != 0) {
error_respond(info, HTTP_PRECONDITION_FAILED, event);
goto exit_function;
}
/* parse the content (should be XML) */
if (!has_xml_content_type(event) ||
event->msg.length == 0 ||
ixmlParseBufferEx(event->entity.buf, &ChangedVars) != IXML_SUCCESS) {
error_respond(info, HTTP_BAD_REQUEST, event);
goto exit_function;
}
HandleLock();
/* get client info */
if (GetClientHandleInfo(&client_handle, &handle_info) != HND_CLIENT) {
error_respond(info, HTTP_PRECONDITION_FAILED, event);
HandleUnlock();
goto exit_function;
}
/* get subscription based on SID */
subscription = GetClientSubActualSID(handle_info->ClientSubList, &sid);
if (subscription == NULL) {
if (eventKey == 0) {
/* wait until we've finished processing a subscription */
/* (if we are in the middle) */
/* this is to avoid mistakenly rejecting the first event if we */
/* receive it before the subscription response */
HandleUnlock();
/* try and get Subscription Lock */
/* (in case we are in the process of subscribing) */
SubscribeLock();
/* get HandleLock again */
HandleLock();
if (GetClientHandleInfo(&client_handle, &handle_info) != HND_CLIENT) {
error_respond(info, HTTP_PRECONDITION_FAILED, event);
SubscribeUnlock();
HandleUnlock();
goto exit_function;
}
subscription = GetClientSubActualSID(handle_info->ClientSubList, &sid);
if (subscription == NULL) {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
SubscribeUnlock();
HandleUnlock();
goto exit_function;
}
SubscribeUnlock();
} else {
error_respond( info, HTTP_PRECONDITION_FAILED, event );
HandleUnlock();
goto exit_function;
}
}
/* success */
error_respond(info, HTTP_OK, event);
/* fill event struct */
tmpSID = UpnpClientSubscription_get_SID(subscription);
memset(event_struct.Sid, 0, sizeof(event_struct.Sid));
strncpy(event_struct.Sid, UpnpString_get_String(tmpSID),
sizeof(event_struct.Sid) - 1);
event_struct.EventKey = eventKey;
event_struct.ChangedVariables = ChangedVars;
/* copy callback */
callback = handle_info->Callback;
cookie = handle_info->Cookie;
HandleUnlock();
/* make callback with event struct */
/* In future, should find a way of mainting */
/* that the handle is not unregistered in the middle of a */
/* callback */
callback(UPNP_EVENT_RECEIVED, &event_struct, cookie);
exit_function:
ixmlDocument_free(ChangedVars);
}
/****************************************************************************
* Function : get_action_node
*
* Parameters :
* IN IXML_Document *TempDoc : The root DOM node.
* IN char *NodeName : IXML_Node name to be searched.
* OUT IXML_Document ** RespNode : Response/Output node.
*
* Description : This function separates the action node from
* the root DOM node.
*
* Return : static UPNP_INLINE int
* 0 if successful, or -1 if fails.
*
* Note :
****************************************************************************/
static UPNP_INLINE int
get_action_node( IN IXML_Document * TempDoc,
IN char *NodeName,
OUT IXML_Document ** RespNode )
{
IXML_Node *EnvpNode = NULL;
IXML_Node *BodyNode = NULL;
IXML_Node *ActNode = NULL;
DOMString ActNodeName = NULL;
const DOMString nodeName;
int ret_code = -1; // error, by default
IXML_NodeList *nl = NULL;
UpnpPrintf( UPNP_INFO, SOAP, __FILE__, __LINE__,
"get_action_node(): node name =%s\n ", NodeName );
*RespNode = NULL;
// Got the Envelope node here
EnvpNode = ixmlNode_getFirstChild( ( IXML_Node * ) TempDoc );
if( EnvpNode == NULL ) {
goto error_handler;
}
nl = ixmlElement_getElementsByTagNameNS( ( IXML_Element * ) EnvpNode,
"*", "Body" );
if( nl == NULL ) {
goto error_handler;
}
BodyNode = ixmlNodeList_item( nl, 0 );
if( BodyNode == NULL ) {
goto error_handler;
}
// Got action node here
ActNode = ixmlNode_getFirstChild( BodyNode );
if( ActNode == NULL ) {
goto error_handler;
}
//Test whether this is the action node
nodeName = ixmlNode_getNodeName( ActNode );
if( nodeName == NULL ) {
goto error_handler;
}
if( strstr( nodeName, NodeName ) == NULL ) {
goto error_handler;
} else {
ActNodeName = ixmlPrintNode( ActNode );
if( ActNodeName == NULL ) {
goto error_handler;
}
ret_code = ixmlParseBufferEx( ActNodeName, RespNode );
if( ret_code != IXML_SUCCESS ) {
ixmlFreeDOMString( ActNodeName );
ret_code = -1;
goto error_handler;
}
}
ret_code = 0; // success
error_handler:
ixmlFreeDOMString( ActNodeName );
if( nl )
ixmlNodeList_free( nl );
return ret_code;
}
