soap_ctrlpt.cpp

Go to the documentation of this file.

/*******************************************************************************
 *
 * Copyright (c) 2000-2003 Intel Corporation
 * All rights reserved.
 * Copyright (C) 2022+ GPL 3 and higher by Ingo Höft, <Ingo@Hoeft-online.de>
 * Redistribution only with this Copyright remark. Last modified: 2024-02-28
 *
 * 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.
 *
 ******************************************************************************/
// Last compare with ./pupnp source file on 2024-02-14, ver 1.14.18
#include <soap_common.hpp>
#include <soap_ctrlpt.hpp>
 
#include <httpreadwrite.hpp>
#include <parsetools.hpp>
#include <statcodes.hpp>
#include <upnpapi.hpp>
 
#ifndef COMPA_INTERNAL_CONFIG_HPP
#error "No or wrong config.hpp header file included."
#endif
 
#include <cassert>
#include <cctype>
#include <cstdarg>
#include <cstdio>
#include <cstdlib>
 
 
namespace {
 
constexpr int SOAP_ACTION_RESP{1};
constexpr int SOAP_VAR_RESP{2};
/*#define SOAP_ERROR_RESP       3*/
constexpr int SOAP_ACTION_RESP_ERROR{3};
constexpr int SOAP_VAR_RESP_ERROR{4};
 
 
int dom_cmp_name(
    /* [in] lookup name. */
    const char* name,
    /* [in] xml node. */
    IXML_Node* node) {
    const DOMString node_name = NULL;
    memptr nameptr;
    memptr dummy;
    int ret_code;
 
    assert(name);
    assert(node);
 
    node_name = ixmlNode_getNodeName(node);
    if (node_name == NULL)
        return UPNP_E_OUTOF_MEMORY;
    if (strcmp(name, node_name) == 0)
        ret_code = 0;
    else if (matchstr((char*)node_name, strlen(node_name), "%s:%s%0", &dummy,
                      &nameptr) == PARSE_OK &&
             strcmp(nameptr.buf, name) == 0)
        ret_code = 0;
    else
        /* names are not the same */
        ret_code = 1;
 
    return ret_code;
}
 
int dom_find_node(
    /* [in] name of the node. */
    const char* node_name,
    /* [in] complete xml node. */
    IXML_Node* start_node,
    /* [out] matched node. */
    IXML_Node** matching_node) {
    IXML_Node* node;
 
    /* invalid args */
    if (!node_name || !start_node)
        return UPNP_E_NOT_FOUND;
    node = ixmlNode_getFirstChild(start_node);
    while (node != NULL) {
        /* match name */
        if (dom_cmp_name(node_name, node) == 0) {
            *matching_node = node;
            return UPNP_E_SUCCESS;
        }
        /* free and next node */
        node = ixmlNode_getNextSibling(node);
    }
 
    return UPNP_E_NOT_FOUND;
}
 
int dom_find_deep_node(
    /* [in] array of names. */
    const char* names[],
    /* [in] size of array. */
    int num_names,
    /* [in] Node from where it should be searched. */
    IXML_Node* start_node,
    /* [out] Node that matches the last name of the array. */
    IXML_Node** matching_node) {
    int i;
    IXML_Node* node;
    IXML_Node* match_node;
 
    assert(num_names > 0);
 
    node = start_node;
    if (dom_cmp_name(names[0], start_node) == 0) {
        if (num_names == 1) {
            *matching_node = start_node;
            return UPNP_E_SUCCESS;
        }
    }
    for (i = 1; i < num_names; i++) {
        if (dom_find_node(names[i], node, &match_node) != UPNP_E_SUCCESS)
            return UPNP_E_NOT_FOUND;
        if (i == num_names - 1) {
            *matching_node = match_node;
            return UPNP_E_SUCCESS;
        }
        /* try again */
        node = match_node;
    }
 
    /* this line not reached */
    return UPNP_E_NOT_FOUND;
}
 
const DOMString get_node_value( //
    IXML_Node* node             
) {
    IXML_Node* text_node = NULL;
    const DOMString text_value = NULL;
 
    text_node = ixmlNode_getFirstChild(node);
    if (text_node == NULL) {
        return NULL;
    }
 
    text_value = ixmlNode_getNodeValue(text_node);
    return text_value;
}
 
inline int get_host_and_path( //
    char* ctrl_url,           
    const memptr* host,       
    const memptr* path,       
    uri_type* url             
) {
    if (parse_uri(ctrl_url, strlen(ctrl_url), url) != HTTP_SUCCESS) {
        return -1;
    }
    /* This is done to ensure that the buffer is kept const */
    ((memptr*)host)->buf = (char*)url->hostport.text.buff;
    ((memptr*)host)->length = url->hostport.text.size;
 
    ((memptr*)path)->buf = (char*)url->pathquery.buff;
    ((memptr*)path)->length = url->pathquery.size;
 
    return 0;
}
 
inline int get_action_name( //
    char* action,           
    memptr* name            
) {
    memptr dummy;
    int ret_code;
 
    ret_code = matchstr(action, strlen(action), " <%s:%s", &dummy, name);
 
    return ret_code == PARSE_OK ? 0 : -1;
}
 
inline int add_man_header(
    /* [in,out] HTTP header. */
    membuffer* headers) {
    size_t n;
    char* soap_action_hdr;
    const char* man_hdr =
        "MAN: \"http://schemas.xmlsoap.org/soap/envelope/\"; ns=01\r\n01-";
 
    /* change POST to M-POST */
    if (membuffer_insert(headers, "M-", 2, 0) != 0)
        return UPNP_E_OUTOF_MEMORY;
    soap_action_hdr = strstr(headers->buf, "SOAPACTION:");
    /* can't fail */
    assert(soap_action_hdr != NULL);
    /* insert MAN header */
    n = (size_t)(soap_action_hdr - headers->buf);
    if (membuffer_insert(headers, man_hdr, strlen(man_hdr), n))
        return UPNP_E_OUTOF_MEMORY;
 
    return 0;
}
 
int soap_request_and_response( //
    membuffer* request, 
    uri_type* destination_url, 
    http_parser_t* response    
) {
    int ret_code;
 
    ret_code =
        http_RequestAndResponse(destination_url, request->buf, request->length,
                                SOAPMETHOD_POST, UPNP_TIMEOUT, response);
    if (ret_code != 0) {
        httpmsg_destroy(&response->msg);
        return ret_code;
    }
    /* method-not-allowed error */
    if (response->msg.status_code == HTTP_METHOD_NOT_ALLOWED) {
        ret_code = add_man_header(request); /* change to M-POST msg */
        if (ret_code != 0) {
            return ret_code;
        }
 
        httpmsg_destroy(&response->msg); /* about to reuse response */
 
        /* try again */
        ret_code = http_RequestAndResponse(destination_url, request->buf,
                                           request->length, HTTPMETHOD_MPOST,
                                           UPNP_TIMEOUT, response);
        if (ret_code != 0) {
            httpmsg_destroy(&response->msg);
        }
    }
 
    return ret_code;
}
 
int get_response_value(       //
    http_message_t* hmsg,     
    int code,                 
    char* name,               
    int* upnp_error_code,     
    IXML_Node** action_value, 
    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 = UPNP_E_BAD_RESPONSE; /* default error */
    int done = 0;
    const char* names[5];
    const DOMString nodeValue;
 
    /* 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 = 1;
        }
    } 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 = 1;
        }
    }
    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)
            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;
}
 
} // anonymous namespace
 
 
int SoapSendAction(char* action_url, char* service_type,
                   IXML_Document* action_node, IXML_Document** response_node) {
    char* action_str = NULL;
    memptr name;
    membuffer request;
    membuffer responsename;
    int err_code;
    int ret_code;
    http_parser_t response;
    uri_type url;
    int upnp_error_code;
    char* upnp_error_str;
    int got_response = 0;
 
    off_t content_length;
    const char* xml_start =
        "<s:Envelope "
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
        "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n"
        "<s:Body>";
    const char* xml_end = "</s:Body>\r\n"
                          "</s:Envelope>\r\n\r\n";
    size_t xml_start_len;
    size_t xml_end_len;
    size_t action_str_len;
 
    *response_node = NULL;          /* init */
 
    err_code = UPNP_E_OUTOF_MEMORY; /* default error */
 
    UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__, "Inside SoapSendAction():");
    /* init */
    membuffer_init(&request);
    membuffer_init(&responsename);
 
    /* print action */
    action_str = ixmlPrintNode((IXML_Node*)action_node);
    if (action_str == NULL) {
        goto error_handler;
    }
    /* get action name */
    if (get_action_name(action_str, &name) != 0) {
        err_code = UPNP_E_INVALID_ACTION;
        goto error_handler;
    }
    /* parse url */
    if (http_FixStrUrl(action_url, strlen(action_url), &url) != 0) {
        err_code = UPNP_E_INVALID_URL;
        goto error_handler;
    }
 
    UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__,
               "path=%.*s, hostport=%.*s\n", (int)url.pathquery.size,
               url.pathquery.buff, (int)url.hostport.text.size,
               url.hostport.text.buff);
 
    xml_start_len = strlen(xml_start);
    xml_end_len = strlen(xml_end);
    action_str_len = strlen(action_str);
 
    /* make request msg */
    request.size_inc = 50;
    content_length = (off_t)(xml_start_len + action_str_len + xml_end_len);
    if (http_MakeMessage(&request, 1, 1,
                         "q"
                         "N"
                         "s"
                         "sssbsc"
                         "Uc"
                         "b"
                         "b"
                         "b",
                         SOAPMETHOD_POST, &url, content_length,
                         ContentTypeHeader, "SOAPACTION: \"", service_type, "#",
                         name.buf, name.length, "\"", xml_start, xml_start_len,
                         action_str, action_str_len, xml_end,
                         xml_end_len) != 0) {
        goto error_handler;
    }
 
    ret_code = soap_request_and_response(&request, &url, &response);
    got_response = 1;
    if (ret_code != UPNP_E_SUCCESS) {
        err_code = ret_code;
        goto error_handler;
    }
 
    if (membuffer_append(&responsename, name.buf, name.length) != 0 ||
        membuffer_append_str(&responsename, "Response") != 0) {
        goto error_handler;
    }
    /* get action node from the response */
    ret_code = get_response_value(&response.msg, SOAP_ACTION_RESP,
                                  responsename.buf, &upnp_error_code,
                                  (IXML_Node**)response_node, &upnp_error_str);
 
    if (ret_code == SOAP_ACTION_RESP) {
        err_code = UPNP_E_SUCCESS;
    } else if (ret_code == SOAP_ACTION_RESP_ERROR) {
        err_code = upnp_error_code;
    } else {
        err_code = ret_code;
    }
 
error_handler:
    ixmlFreeDOMString(action_str);
    membuffer_destroy(&request);
    membuffer_destroy(&responsename);
    if (got_response) {
        httpmsg_destroy(&response.msg);
    }
 
    return err_code;
}
 
int SoapSendActionEx(char* action_url, char* service_type,
                     IXML_Document* header, IXML_Document* action_node,
                     IXML_Document** response_node) {
    char* xml_header_str = NULL;
    char* action_str = NULL;
    memptr name;
    membuffer request;
    membuffer responsename;
    int err_code;
    int ret_code;
    http_parser_t response;
    uri_type url;
    int upnp_error_code;
    char* upnp_error_str;
    int got_response = 0;
    const char* xml_start =
        "<s:Envelope "
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
        "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n";
    const char* xml_header_start = "<s:Header>\r\n";
    const char* xml_header_end = "</s:Header>\r\n";
    const char* xml_body_start = "<s:Body>";
    const char* xml_end = "</s:Body>\r\n"
                          "</s:Envelope>\r\n";
    size_t xml_start_len;
    size_t xml_header_start_len;
    size_t xml_header_str_len;
    size_t xml_header_end_len;
    size_t xml_body_start_len;
    size_t action_str_len;
    size_t xml_end_len;
    off_t content_length;
 
    *response_node = NULL;          /* init */
 
    err_code = UPNP_E_OUTOF_MEMORY; /* default error */
 
    UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__,
               "Inside SoapSendActionEx():");
    /* init */
    membuffer_init(&request);
    membuffer_init(&responsename);
 
    /* header string */
    xml_header_str = ixmlPrintNode((IXML_Node*)header);
    if (xml_header_str == NULL) {
        goto error_handler;
    }
    /* print action */
    action_str = ixmlPrintNode((IXML_Node*)action_node);
    if (action_str == NULL) {
        goto error_handler;
    }
    /* get action name */
    if (get_action_name(action_str, &name) != 0) {
        err_code = UPNP_E_INVALID_ACTION;
        goto error_handler;
    }
    /* parse url */
    if (http_FixStrUrl(action_url, strlen(action_url), &url) != 0) {
        err_code = UPNP_E_INVALID_URL;
        goto error_handler;
    }
 
    UpnpPrintf(UPNP_INFO, SOAP, __FILE__, __LINE__,
               "path=%.*s, hostport=%.*s\n", (int)url.pathquery.size,
               url.pathquery.buff, (int)url.hostport.text.size,
               url.hostport.text.buff);
 
    xml_start_len = strlen(xml_start);
    xml_body_start_len = strlen(xml_body_start);
    xml_end_len = strlen(xml_end);
    action_str_len = strlen(action_str);
 
    xml_header_start_len = strlen(xml_header_start);
    xml_header_end_len = strlen(xml_header_end);
    xml_header_str_len = strlen(xml_header_str);
 
    /* make request msg */
    request.size_inc = 50;
    content_length = (off_t)(xml_start_len + xml_header_start_len +
                             xml_header_str_len + xml_header_end_len +
                             xml_body_start_len + action_str_len + xml_end_len);
    if (http_MakeMessage(&request, 1, 1,
                         "q"
                         "N"
                         "s"
                         "sssbsc"
                         "Uc"
                         "b"
                         "b"
                         "b"
                         "b"
                         "b"
                         "b"
                         "b",
                         SOAPMETHOD_POST, &url, content_length,
                         ContentTypeHeader, "SOAPACTION: \"", service_type, "#",
                         name.buf, name.length, "\"", xml_start, xml_start_len,
                         xml_header_start, xml_header_start_len, xml_header_str,
                         xml_header_str_len, xml_header_end, xml_header_end_len,
                         xml_body_start, xml_body_start_len, action_str,
                         action_str_len, xml_end, xml_end_len) != 0) {
        goto error_handler;
    }
 
    ret_code = soap_request_and_response(&request, &url, &response);
    got_response = 1;
    if (ret_code != UPNP_E_SUCCESS) {
        err_code = ret_code;
        goto error_handler;
    }
 
    if (membuffer_append(&responsename, name.buf, name.length) != 0 ||
        membuffer_append_str(&responsename, "Response") != 0) {
        goto error_handler;
    }
    /* get action node from the response */
    ret_code = get_response_value(&response.msg, SOAP_ACTION_RESP,
                                  responsename.buf, &upnp_error_code,
                                  (IXML_Node**)response_node, &upnp_error_str);
 
    if (ret_code == SOAP_ACTION_RESP) {
        err_code = UPNP_E_SUCCESS;
    } else if (ret_code == SOAP_ACTION_RESP_ERROR) {
        err_code = upnp_error_code;
    } else {
        err_code = ret_code;
    }
 
error_handler:
 
    ixmlFreeDOMString(action_str);
    ixmlFreeDOMString(xml_header_str);
    membuffer_destroy(&request);
    membuffer_destroy(&responsename);
    if (got_response) {
        httpmsg_destroy(&response.msg);
    }
 
    return err_code;
}
 
int SoapGetServiceVarStatus(char* action_url, DOMString var_name,
                            DOMString* var_value) {
#ifdef UPNPLIB_PUPNP_BUG
    // Error old code: uninitialized 'const host|path' [-fpermissive]. Need to
    // fix it here otherwise it will not compile. --Ingo
    const memptr host; /* value for HOST header */
    const memptr path; /* ctrl path in first line in msg */
#else
    const memptr host{}; /* value for HOST header */
    const memptr path{}; /* ctrl path in first line in msg */
#endif
    uri_type url;
    membuffer request;
    int ret_code;
    http_parser_t response;
    int upnp_error_code;
    off_t content_length;
    const char* xml_start =
        "<s:Envelope "
        "xmlns:s=\"http://schemas.xmlsoap.org/soap/envelope/\" "
        "s:encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">\r\n"
        "<s:Body>\r\n"
        "<u:QueryStateVariable "
        "xmlns:u=\"urn:schemas-upnp-org:control-1-0\">\r\n"
        "<u:varName>";
    const char* xml_end = "</u:varName>\r\n"
                          "</u:QueryStateVariable>\r\n"
                          "</s:Body>\r\n"
                          "</s:Envelope>\r\n";
 
    *var_value = NULL; /* return NULL in case of an error */
    membuffer_init(&request);
    /* get host hdr and url path */
    if (get_host_and_path(action_url, &host, &path, &url) == -1) {
        return UPNP_E_INVALID_URL;
    }
    /* make headers */
    request.size_inc = 50;
    content_length =
        (off_t)(strlen(xml_start) + strlen(var_name) + strlen(xml_end));
    if (http_MakeMessage(
            &request, 1, 1,
            "Q"
            "sbc"
            "N"
            "s"
            "sc"
            "Ucc"
            "sss",
            SOAPMETHOD_POST, path.buf, path.length, "HOST: ", host.buf,
            host.length, content_length, ContentTypeHeader,
            "SOAPACTION: "
            "\"urn:schemas-upnp-org:control-1-0#QueryStateVariable\"",
            xml_start, var_name, xml_end) != 0) {
        return UPNP_E_OUTOF_MEMORY;
    }
    /* send msg and get reply */
    ret_code = soap_request_and_response(&request, &url, &response);
    membuffer_destroy(&request);
    if (ret_code != UPNP_E_SUCCESS) {
        return ret_code;
    }
    /* get variable value from the response */
    ret_code = get_response_value(&response.msg, SOAP_VAR_RESP, NULL,
                                  &upnp_error_code, NULL, var_value);
    httpmsg_destroy(&response.msg);
    if (ret_code == SOAP_VAR_RESP) {
        return UPNP_E_SUCCESS;
    } else if (ret_code == SOAP_VAR_RESP_ERROR) {
        return upnp_error_code;
    } else {
        return ret_code;
    }
}