Logo Search packages:      
Sourcecode: libupnp4 version File versions  Download package

soap_device.c

Go to the documentation of this file.
/*******************************************************************************
 *
 * Copyright (c) 2000-2003 Intel Corporation 
 * 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 name of Intel Corporation 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 OR 
 * 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.
 *
 ******************************************************************************/


/*!
 * \file
 */


#include "config.h"


#ifdef INCLUDE_DEVICE_APIS
#if EXCLUDE_SOAP == 0


#define SOAP_BODY "Body"
#define SOAP_URN "http:/""/schemas.xmlsoap.org/soap/envelope/"

#define QUERY_STATE_VAR_URN "urn:schemas-upnp-org:control-1-0"


#include "ActionRequest.h"
#include "httpparser.h"
#include "httpreadwrite.h"
#include "parsetools.h"
#include "soaplib.h"
#include "ssdplib.h"
#include "statcodes.h"
#include "unixutil.h"
#include "upnpapi.h"


#ifdef WIN32
      #define snprintf _snprintf
#endif


/*! timeout duration in secs for transmission/reception */
#define SOAP_TIMEOUT UPNP_TIMEOUT

#define SREQ_HDR_NOT_FOUND     -1
#define SREQ_BAD_HDR_FORMAT    -2

#define SOAP_INVALID_ACTION 401
#define SOAP_INVALID_ARGS     402
#define SOAP_OUT_OF_SYNC      403
#define SOAP_INVALID_VAR      404
#define SOAP_ACTION_FAILED    501

static const char *Soap_Invalid_Action = "Invalid Action";

/*static const char* Soap_Invalid_Args = "Invalid Args"; */
static const char *Soap_Action_Failed = "Action Failed";
static const char *Soap_Invalid_Var = "Invalid Var";

const char *ContentTypeHeader =
    "CONTENT-TYPE: text/xml; charset=\"utf-8\"\r\n";


/****************************************************************************
*     Function :  get_request_type
*
*     Parameters :
*                 IN http_message_t* request :  HTTP request
*                 OUT memptr* action_name :     SOAP action name
*
*     Description :     This function retrives the name of the SOAP action
*
*     Return : int
*           0 if successful else returns appropriate error.
*     Note :
****************************************************************************/
static UPNP_INLINE int
get_request_type( IN http_message_t * request,
                  OUT memptr * action_name )
{
    memptr value;
    memptr ns_value,
      dummy_quote;
    http_header_t *hdr;
    char save_char;
    char *s;
    membuffer soap_action_name;

    // find soapaction header
    //
    if( request->method == SOAPMETHOD_POST ) {
        if( httpmsg_find_hdr( request, HDR_SOAPACTION, &value )
            == NULL ) {
            return SREQ_HDR_NOT_FOUND;
        }
    } else                      // M-POST
    {
        // get NS value from MAN header
        hdr = httpmsg_find_hdr( request, HDR_MAN, &value );
        if( hdr == NULL ) {
            return SREQ_HDR_NOT_FOUND;
        }

        if( matchstr( value.buf, value.length, "%q%i ; ns = %s",
                      &dummy_quote, &ns_value ) != 0 ) {
            return SREQ_BAD_HDR_FORMAT;
        }
        // create soapaction name header
        membuffer_init( &soap_action_name );
        if( ( membuffer_assign( &soap_action_name,
                                ns_value.buf, ns_value.length )
              == UPNP_E_OUTOF_MEMORY ) ||
            ( membuffer_append_str( &soap_action_name,
                                    "-SOAPACTION" ) ==
              UPNP_E_OUTOF_MEMORY )
             ) {
            membuffer_destroy( &soap_action_name );
            return UPNP_E_OUTOF_MEMORY;
        }

        hdr = httpmsg_find_hdr_str( request, soap_action_name.buf );
        membuffer_destroy( &soap_action_name );
        if( hdr == NULL ) {
            return SREQ_HDR_NOT_FOUND;
        }

        value.buf = hdr->value.buf;
        value.length = hdr->value.length;
    }

    // determine type
    //
    save_char = value.buf[value.length];
    value.buf[value.length] = '\0';

    s = strchr( value.buf, '#' );
    if( s == NULL ) {
        value.buf[value.length] = save_char;
        return SREQ_BAD_HDR_FORMAT;
    }

    s++;                        // move to value

    if( matchstr( s, value.length - ( s - value.buf ), "%s",
                  action_name ) != PARSE_OK ) {
        value.buf[value.length] = save_char;
        return SREQ_BAD_HDR_FORMAT;
    }
    // action name or variable ?
    if( memptr_cmp( action_name, "QueryStateVariable" ) == 0 ) {
        // query variable
        action_name->buf = NULL;
        action_name->length = 0;
    }

    value.buf[value.length] = save_char;    // restore
    return 0;
}

/****************************************************************************
*     Function :  send_error_response
*
*     Parameters :
*                 IN SOCKINFO *info :     socket info
*                 IN int error_code :     error code
*                 IN const char* err_msg :      error message
*                 IN http_message_t* hmsg :     HTTP request
*
*     Description :     This function sends SOAP error response
*
*     Return : void
*
*     Note :
****************************************************************************/
static void
send_error_response( IN SOCKINFO * info,
                     IN int error_code,
                     IN const char *err_msg,
                     IN http_message_t * hmsg )
{
    off_t content_length;
    int timeout_secs = SOAP_TIMEOUT;
    int major,
      minor;
    const char *start_body =
//          "<?xml version=\"1.0\"?>\n" required??
        "<s:Envelope "
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
        "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\n"
        "<s:Body>\n"
        "<s:Fault>\n"
        "<faultcode>s:Client</faultcode>\n"
        "<faultstring>UPnPError</faultstring>\n"
        "<detail>\n"
        "<UPnPError xmlns=\"urn:schemas-upnp-org:control-1-0\">\n"
        "<errorCode>";

    const char *mid_body = "</errorCode>\n" "<errorDescription>";

    const char *end_body =
        "</errorDescription>\n"
        "</UPnPError>\n"
        "</detail>\n" "</s:Fault>\n" "</s:Body>\n" "</s:Envelope>\n";

    char err_code_str[30];

    membuffer headers;

    sprintf( err_code_str, "%d", error_code );

    // calc body len
    content_length = strlen( start_body ) + strlen( err_code_str ) +
        strlen( mid_body ) + strlen( err_msg ) + strlen( end_body );

    http_CalcResponseVersion( hmsg->major_version, hmsg->minor_version,
                              &major, &minor );

    // make headers
    membuffer_init( &headers );
    if (http_MakeMessage(
        &headers, major, minor,
        "RNsDsSXcc" "sssss",
        500,
        content_length,
        ContentTypeHeader,
        "EXT:\r\n",
        X_USER_AGENT,
        start_body, err_code_str, mid_body, err_msg,
        end_body ) != 0 ) {
        membuffer_destroy( &headers );
        return;                 // out of mem
    }
    // send err msg
    http_SendMessage( info, &timeout_secs, "b",
                      headers.buf, headers.length );

    membuffer_destroy( &headers );
}

/****************************************************************************
*     Function :  send_var_query_response
*
*     Parameters :
*                 IN SOCKINFO *info :     socket info
*                 IN const char* var_value :    value of the state variable
*                 IN http_message_t* hmsg :     HTTP request
*
*     Description :     This function sends response of get var status
*
*     Return : void
*
*     Note :
****************************************************************************/
static UPNP_INLINE void
send_var_query_response( IN SOCKINFO * info,
                         IN const char *var_value,
                         IN http_message_t * hmsg )
{
    off_t content_length;
    int timeout_secs = SOAP_TIMEOUT;
    int major;
    int minor;
    const char *start_body =
        "<s:Envelope "
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
        "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\n"
        "<s:Body>\n"
        "<u:QueryStateVariableResponse "
        "xmlns:u=\"urn:schemas-upnp-org:control-1-0\">\n" "<return>";

    const char *end_body =
        "</return>\n"
        "</u:QueryStateVariableResponse>\n"
        "</s:Body>\n" "</s:Envelope>\n";

    membuffer response;

    http_CalcResponseVersion( hmsg->major_version, hmsg->minor_version,
                              &major, &minor );

    content_length = strlen( start_body ) + strlen( var_value ) +
        strlen( end_body );

    // make headers
    membuffer_init( &response );
    
    if (http_MakeMessage(
        &response, major, minor,
        "RNsDsSXcc" "sss",
        HTTP_OK,
        content_length,
        ContentTypeHeader,
        "EXT:\r\n",
        X_USER_AGENT,
        start_body, var_value, end_body ) != 0 ) {
        membuffer_destroy( &response );
        return;                 // out of mem
    }
    
    // send msg
    http_SendMessage( info, &timeout_secs, "b",
                      response.buf, response.length );

    membuffer_destroy( &response );
}

/****************************************************************************
*     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;
}

/****************************************************************************
*     Function :  check_soap_body
*
*     Parameters :
*           IN IXML_Document *doc : soap body xml document
*               IN const char *urn : 
*               IN const char *actionName : Name of the requested action      
*
*     Description :     This function checks the soap body xml came in the
*           SOAP request.
*
*     Return : int
*           UPNP_E_SUCCESS if successful else returns appropriate error
*
*     Note :
****************************************************************************/
static int
check_soap_body( IN IXML_Document * doc,
                 IN const char *urn,
                 IN const char *actionName )
{
    IXML_NodeList *nl = NULL;
    IXML_Node *bodyNode = NULL;
    IXML_Node *actionNode = NULL;
    const DOMString ns = NULL;
    const DOMString name = NULL;

    int ret_code = UPNP_E_INVALID_ACTION;

    nl = ixmlDocument_getElementsByTagNameNS( doc, SOAP_URN, SOAP_BODY );

    if( nl ) {
        bodyNode = ixmlNodeList_item( nl, 0 );
        if( bodyNode ) {
            actionNode = ixmlNode_getFirstChild( bodyNode );
            if( actionNode ) {
                ns = ixmlNode_getNamespaceURI( actionNode );
                name = ixmlNode_getLocalName( actionNode );
                if (name && ns &&
                    !strcmp( actionName, name ) &&
                    !strcmp( urn, ns ) ) {
                    ret_code = UPNP_E_SUCCESS;
                }
            }
        }
        ixmlNodeList_free( nl );
    }
    return ret_code;

}

/****************************************************************************
*     Function :  check_soap_action_header
*
*     Parameters :
*           IN http_message_t *request : HTTP request
*           IN const char *urn :
*           OUT char **actionName :  name of the SOAP action
*
*     Description :     This function checks the HTTP header of the SOAP request
*           coming from the control point
*
*     Return :    static int
*           UPNP_E_SUCCESS if successful else returns appropriate error
*
*     Note :
****************************************************************************/
static int
check_soap_action_header( IN http_message_t * request,
                          IN const char *urn,
                          OUT char **actionName )
{
    memptr header_name;
    http_header_t *soap_action_header = NULL;
    char *ns_compare = NULL;
    int tempSize = 0;
    int ret_code = UPNP_E_SUCCESS;
    char *temp_header_value = NULL;
    char *temp = NULL;
    char *temp2 = NULL;

    //check soap action header

    soap_action_header = httpmsg_find_hdr( request, HDR_SOAPACTION,
                                           &header_name );

    if( !soap_action_header ) {
        ret_code = UPNP_E_INVALID_ACTION;
        return ret_code;
    }

    if( soap_action_header->value.length <= 0 ) {
        ret_code = UPNP_E_INVALID_ACTION;
        return ret_code;
    }

    temp_header_value =
        ( char * )malloc( soap_action_header->value.length + 1 );

    if( !temp_header_value ) {
        ret_code = UPNP_E_OUTOF_MEMORY;
        free( temp_header_value );
        return ret_code;
    }

    strncpy( temp_header_value, soap_action_header->value.buf,
             soap_action_header->value.length );
    temp_header_value[soap_action_header->value.length] = 0;

    temp = strchr( temp_header_value, '#' );
    if( !temp ) {
        free( temp_header_value );
        ret_code = UPNP_E_INVALID_ACTION;
        return ret_code;
    }

    ( *temp ) = 0;              //temp make string

    //check to see if it is Query State Variable or
    //Service Action

    tempSize = strlen( urn ) + 2;

    ns_compare = ( char * )malloc( tempSize );

    if( !ns_compare ) {
        ret_code = UPNP_E_OUTOF_MEMORY;
        free( temp_header_value );
        return ret_code;
    }

    snprintf( ns_compare, tempSize, "\"%s", urn );

    if( strcmp( temp_header_value, ns_compare ) ) {
        ret_code = UPNP_E_INVALID_ACTION;
    } else {
        ret_code = UPNP_E_SUCCESS;
        temp++;
        temp2 = strchr( temp, '\"' );

        if( temp2 )             //remove ending " if present
        {
            ( *temp2 ) = 0;
        }

        if( *temp )
            ( *actionName ) = strdup( temp );
        if( !*actionName ) {
            ret_code = UPNP_E_OUTOF_MEMORY;
        }
    }

    free( temp_header_value );
    free( ns_compare );
    return ret_code;
}

/****************************************************************************
*     Function :  get_device_info
*
*     Parameters :
*           IN http_message_t* request :  HTTP request
*           IN int isQuery :  flag for a querry
*           IN IXML_Document *actionDoc : action request document
*           OUT UpnpString *device_udn :  Device UDN string
*           OUT UpnpString *service_id :  Service ID string
*           OUT Upnp_FunPtr *callback :   callback function of the device 
*                                   application
*           OUT void** cookie :     cookie stored by device application 
*                                         
*     Description :     This function retrives all the information needed to 
*           process the incoming SOAP request. It finds the device and service info
*           and also the callback function to hand-over the request to the device
*           application.
*
*     Return : int
*           UPNP_E_SUCCESS if successful else returns appropriate error
*
*     Note :
****************************************************************************/
static int
get_device_info( IN http_message_t *request,
                 IN int isQuery,
                 IN IXML_Document *actionDoc,
                 IN int AddressFamily,
                 OUT UpnpString *device_udn,
                 OUT UpnpString *service_id,
                 OUT Upnp_FunPtr *callback,
                 OUT void **cookie )
{
    struct Handle_Info *device_info;
    int device_hnd;
    service_info *serv_info;
    char save_char;
    int ret_code = -1;          // error by default
    const char *control_url;
    char *actionName = NULL;

    // null-terminate pathquery of url
    control_url = request->uri.pathquery.buff;
    save_char = control_url[request->uri.pathquery.size];
    ((char *)control_url)[request->uri.pathquery.size] = '\0';

    HandleLock();

    if( GetDeviceHandleInfo( AddressFamily, 
        &device_hnd, &device_info ) != HND_DEVICE ) {
        goto error_handler;
    }

    if( ( serv_info =
          FindServiceControlURLPath( &device_info->ServiceTable,
                                     control_url ) ) == NULL ) {
        goto error_handler;
    }

    if( isQuery ) {
        ret_code = check_soap_action_header( request, QUERY_STATE_VAR_URN,
                                             &actionName );
        if( ( ret_code != UPNP_E_SUCCESS )
            && ( ret_code != UPNP_E_OUTOF_MEMORY ) ) {
            ret_code = UPNP_E_INVALID_ACTION;
            goto error_handler;
        }
        //check soap body
        ret_code =
            check_soap_body( actionDoc, QUERY_STATE_VAR_URN, actionName );
        free( actionName );
        if( ret_code != UPNP_E_SUCCESS ) {
            goto error_handler;
        }
    } else {
        ret_code = check_soap_action_header( request,
                                             serv_info->serviceType,
                                             &actionName );
        if( ( ret_code != UPNP_E_SUCCESS )
            && ( ret_code != UPNP_E_OUTOF_MEMORY ) ) {
            ret_code = UPNP_E_INVALID_SERVICE;
            goto error_handler;
        }
        //check soap body
        ret_code =
            check_soap_body( actionDoc, serv_info->serviceType,
                             actionName );
        free( actionName );
        if( ret_code != UPNP_E_SUCCESS ) {
            ret_code = UPNP_E_INVALID_SERVICE;
            goto error_handler;
        }
    }

    UpnpString_set_String( device_udn, serv_info->UDN );
    UpnpString_set_String( service_id, serv_info->serviceId );
    *callback = device_info->Callback;
    *cookie = device_info->Cookie;

    ret_code = 0;

  error_handler:
    ((char *)control_url)[request->uri.pathquery.size] = save_char;   // restore
    HandleUnlock();
    return ret_code;
}

/****************************************************************************
*     Function :  send_action_response
*
*     Parameters :
*           IN SOCKINFO *info :     socket info
*           IN IXML_Document *action_resp : The response document 
*           IN http_message_t* request :  action request document
*
*     Description :     This function sends the SOAP response 
*
*     Return : void
*
*     Note :
****************************************************************************/
static UPNP_INLINE void
send_action_response( IN SOCKINFO * info,
                      IN IXML_Document * action_resp,
                      IN http_message_t * request )
{
    char *xml_response = NULL;
    membuffer headers;
    int major,
      minor;
    int err_code;
    off_t content_length;
    int ret_code;
    int timeout_secs = SOAP_TIMEOUT;
    static char *start_body =
//        "<?xml version=\"1.0\"?>" required??
        "<s:Envelope xmlns:s=\"http://schemas.xmlsoap."
        "org/soap/envelope/\" s:encodingStyle=\"http://schemas.xmlsoap."
        "org/soap/encoding/\"><s:Body>\n";
    static char *end_body = "</s:Body> </s:Envelope>";

    // init
    http_CalcResponseVersion( request->major_version,
                              request->minor_version, &major, &minor );
    membuffer_init( &headers );
    err_code = UPNP_E_OUTOF_MEMORY; // one error only

    // get xml
    xml_response = ixmlPrintNode( ( IXML_Node * ) action_resp );
    if( xml_response == NULL ) {
        goto error_handler;
    }

    content_length =
        strlen( start_body ) +
        strlen( xml_response ) +
        strlen( end_body );

    // make headers
    if (http_MakeMessage(
        &headers, major, minor,
        "RNsDsSXcc",
        HTTP_OK,   // status code
        content_length,
        ContentTypeHeader,
        "EXT:\r\n",
        X_USER_AGENT) != 0 ) {
        goto error_handler;
    }

    // send whole msg
    ret_code = http_SendMessage( info, &timeout_secs, "bbbb",
                                 headers.buf, headers.length,
                                 start_body, strlen( start_body ),
                                 xml_response, strlen( xml_response ),
                                 end_body, strlen( end_body ) );

    if( ret_code != 0 ) {
        UpnpPrintf( UPNP_INFO, SOAP, __FILE__, __LINE__,
            "Failed to send response: err code = %d\n",
            ret_code );
    }

    err_code = 0;

error_handler:
    ixmlFreeDOMString( xml_response );
    membuffer_destroy( &headers );
    if( err_code != 0 ) {
        // only one type of error to worry about - out of mem
        send_error_response( info, SOAP_ACTION_FAILED, "Out of memory",
                             request );
    }
}

/****************************************************************************
*     Function :  get_var_name
*
*     Parameters :
*           IN IXML_Document *TempDoc :   Document containing variable request
*           OUT char* VarName :     Name of the state varible
*
*     Description :     This function finds the name of the state variable 
*                       asked in the SOAP request.
*
*     Return :    int
*           returns 0 if successful else returns -1.
*     Note :
****************************************************************************/
static UPNP_INLINE int
get_var_name( IN IXML_Document * TempDoc,
              OUT char *VarName )
{
    IXML_Node *EnvpNode = NULL;
    IXML_Node *BodyNode = NULL;
    IXML_Node *StNode = NULL;
    IXML_Node *VarNameNode = NULL;
    IXML_Node *VarNode = NULL;
    const DOMString StNodeName = NULL;
    const DOMString Temp = NULL;
    int ret_val = -1;

    // Got the Envelop node here
    EnvpNode = ixmlNode_getFirstChild( ( IXML_Node * ) TempDoc );
    if( EnvpNode == NULL ) {
        goto error_handler;
    }
    // Got Body here
    BodyNode = ixmlNode_getFirstChild( EnvpNode );
    if( BodyNode == NULL ) {
        goto error_handler;
    }
    // Got action node here
    StNode = ixmlNode_getFirstChild( BodyNode );
    if( StNode == NULL ) {
        goto error_handler;
    }
    //Test whether this is the action node
    StNodeName = ixmlNode_getNodeName( StNode );
    if( StNodeName == NULL || strstr( StNodeName,
                                      "QueryStateVariable" ) == NULL ) {
        goto error_handler;
    }

    VarNameNode = ixmlNode_getFirstChild( StNode );
    if( VarNameNode == NULL ) {
        goto error_handler;
    }

    VarNode = ixmlNode_getFirstChild( VarNameNode );
    Temp = ixmlNode_getNodeValue( VarNode );
    linecopy( VarName, Temp );

    UpnpPrintf( UPNP_INFO, SOAP, __FILE__, __LINE__,
        "Received query for variable  name %s\n",
        VarName );

    ret_val = 0;            // success

error_handler:
    return ret_val;
}

/****************************************************************************
*     Function :  handle_query_variable
*
*     Parameters :
*           IN SOCKINFO *info :     Socket info
*           IN http_message_t* request : HTTP request 
*           IN IXML_Document *xml_doc :   Document containing the variable request 
*                                                     SOAP message
*
*     Description :     This action handles the SOAP requests to querry the 
*                       state variables. This functionality has been deprecated in 
*                       the UPnP V1.0 architecture
*
*     Return :    void
*
*     Note :
****************************************************************************/
static UPNP_INLINE void handle_query_variable(
      IN SOCKINFO *info,
      IN http_message_t *request,
      IN IXML_Document *xml_doc )
{
    UpnpStateVarRequest *variable = UpnpStateVarRequest_new();
    Upnp_FunPtr soap_event_callback;
    void *cookie;
    char var_name[LINE_SIZE];
    const char *err_str;
    int err_code;

    // get var name
    if( get_var_name( xml_doc, var_name ) != 0 ) {
        send_error_response( info, SOAP_INVALID_VAR,
                             Soap_Invalid_Var, request );
        return;
    }
    // get info for event
    err_code = get_device_info(
        request, 1, xml_doc,
      info->foreign_sockaddr.ss_family,
        (UpnpString *)UpnpStateVarRequest_get_DevUDN(variable),
        (UpnpString *)UpnpStateVarRequest_get_ServiceID(variable),
        &soap_event_callback,
        &cookie);
    if( err_code != 0 ) {
        send_error_response( info, SOAP_INVALID_VAR,
                             Soap_Invalid_Var, request );
        return;
    }

    UpnpStateVarRequest_set_ErrCode(variable, UPNP_E_SUCCESS);
    UpnpStateVarRequest_strcpy_StateVarName(variable, var_name);
    UpnpStateVarRequest_set_CtrlPtIPAddr(variable, (struct sockaddr *)&info->foreign_sockaddr);

    // send event
    soap_event_callback( UPNP_CONTROL_GET_VAR_REQUEST, variable, cookie );

    UpnpPrintf( UPNP_INFO, SOAP, __FILE__, __LINE__,
        "Return from callback for var request\n" );

    // validate, and handle result
    if( UpnpStateVarRequest_get_CurrentVal(variable) == NULL ) {
        err_code = SOAP_ACTION_FAILED;
        err_str = Soap_Action_Failed;
        send_error_response( info, SOAP_INVALID_VAR, Soap_Invalid_Var, request );

        return;
    }
    if( UpnpStateVarRequest_get_ErrCode(variable) != UPNP_E_SUCCESS ) {
        if( UpnpString_get_Length(UpnpStateVarRequest_get_ErrStr(variable)) > 0 ) {
            err_code = SOAP_INVALID_VAR;
            err_str = Soap_Invalid_Var;
        } else {
            err_code = UpnpStateVarRequest_get_ErrCode(variable);
            err_str = UpnpString_get_String(UpnpStateVarRequest_get_ErrStr(variable));
        }
        send_error_response( info, err_code, err_str, request );
        return;
    }
    // send response
    send_var_query_response( info, UpnpStateVarRequest_get_CurrentVal(variable), request );
    UpnpStateVarRequest_delete(variable);
}

/****************************************************************************
*     Function :  handle_invoke_action
*
*     Parameters :
*           IN SOCKINFO *info :     Socket info
*           IN http_message_t* request : HTTP Request 
*           IN memptr action_name :  Name of the SOAP Action
*           IN IXML_Document *xml_doc :   document containing the SOAP action 
*                                                     request
*
*     Description :     This functions handle the SOAP action request. It checks 
*           the integrity of the SOAP action request and gives the call back to 
*           the device application.
*
*     Return : void
*
*     Note :
****************************************************************************/
static void
handle_invoke_action( IN SOCKINFO * info,
                      IN http_message_t * request,
                      IN memptr action_name,
                      IN IXML_Document * xml_doc )
{
    char save_char;
    UpnpActionRequest *action = UpnpActionRequest_new();
    UpnpString *devUDN = UpnpString_new();
    UpnpString *serviceID = UpnpString_new();
    IXML_Document *actionRequestDoc = NULL;
    IXML_Document *actionResultDoc = NULL;
    Upnp_FunPtr soap_event_callback;
    void *cookie = NULL;
    int err_code;
    const char *err_str;

    // null-terminate
    save_char = action_name.buf[action_name.length];
    action_name.buf[action_name.length] = '\0';

    // set default error
    err_code = SOAP_INVALID_ACTION;
    err_str = Soap_Invalid_Action;

    // get action node
    if( get_action_node( xml_doc, action_name.buf, &actionRequestDoc ) == -1 ) {
        goto error_handler;
    }
    // get device info for action event
    err_code = get_device_info(
        request,
      0,
      xml_doc,
      info->foreign_sockaddr.ss_family,
        devUDN,
        serviceID,
        &soap_event_callback,
        &cookie );

    if( err_code != UPNP_E_SUCCESS ) {
        goto error_handler;
    }

    UpnpActionRequest_set_ErrCode(action, UPNP_E_SUCCESS);
    UpnpActionRequest_strcpy_ErrStr(action, "");
    UpnpActionRequest_strcpy_ActionName(action, action_name.buf);
    UpnpActionRequest_set_DevUDN(action, devUDN);
    UpnpActionRequest_set_ServiceID(action, serviceID);
    UpnpActionRequest_set_ActionRequest(action, actionRequestDoc);
    UpnpActionRequest_set_CtrlPtIPAddr(action, (struct sockaddr *)&info->foreign_sockaddr);

    UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__, "Calling Callback\n");

    soap_event_callback(UPNP_CONTROL_ACTION_REQUEST, action, cookie);

    err_code = UpnpActionRequest_get_ErrCode(action);
    if (err_code != UPNP_E_SUCCESS) {
        err_str = UpnpString_get_String(UpnpActionRequest_get_ErrStr(action));
        if  (strlen(err_str) <= 0) {
            err_code = SOAP_ACTION_FAILED;
            err_str = Soap_Action_Failed;
        }
        goto error_handler;
    }
    // validate, and handle action error
    actionResultDoc = UpnpActionRequest_get_ActionResult(action);
    if (actionResultDoc == NULL) {
        err_code = SOAP_ACTION_FAILED;
        err_str = Soap_Action_Failed;
        goto error_handler;
    }
    // send response
    send_action_response(info, actionResultDoc, request);

    err_code = 0;

    // error handling and cleanup
error_handler:
    action_name.buf[action_name.length] = save_char;    // restore
    if( err_code != 0 ) {
        send_error_response( info, err_code, err_str, request );
    }

    UpnpString_delete(serviceID);
    UpnpString_delete(devUDN);
    UpnpActionRequest_delete(action);
}

/****************************************************************************
*     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 );
    }
}

#endif // EXCLUDE_SOAP

#endif // INCLUDE_DEVICE_APIS

Generated by  Doxygen 1.6.0   Back to index