Index: lede/feeds/packages/net/miniupnpd/patches/302-add_wsc_new_file.patch =================================================================== --- /dev/null +++ lede/feeds/packages/net/miniupnpd/patches/302-add_wsc_new_file.patch @@ -0,0 +1,6539 @@ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/README +=================================================================== +--- /dev/null ++++ b/wsc/README +@@ -0,0 +1,9 @@ ++Mediatek WPS(WiFi Portected Setup) miniupnpd supported ++ ++Please firstly refer to "MediatekWPSMiniUPnPDaemonHowTo.doc". ++ ++Release Notes ++-------- ++2.3.0: ++ 1. Initial verison. ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/Version +=================================================================== +--- /dev/null ++++ b/wsc/Version +@@ -0,0 +1 @@ ++2.3.0 +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/sample_util.c +=================================================================== +--- /dev/null ++++ b/wsc/sample_util.c +@@ -0,0 +1,292 @@ ++/////////////////////////////////////////////////////////////////////////// ++// ++// 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. ++// ++/////////////////////////////////////////////////////////////////////////// ++ ++#include ++#include "sample_util.h" ++ ++/******************************************************************************** ++ * SampleUtil_GetElementValue ++ * ++ * Description: ++ * Given a DOM node such as 11, this routine ++ * extracts the value (e.g., 11) from the node and returns it as ++ * a string. The string must be freed by the caller using ++ * free. ++ * ++ * Parameters: ++ * node -- The DOM node from which to extract the value ++ * ++ ********************************************************************************/ ++ ++char * ++SampleUtil_GetElementValue( IN IXML_Element * element ) ++{ ++ ++ IXML_Node *child = ixmlNode_getFirstChild( ( IXML_Node * ) element ); ++ ++ char *temp = NULL; ++ ++ if( ( child != 0 ) && ( ixmlNode_getNodeType( child ) == eTEXT_NODE ) ) { ++ temp = strdup( ixmlNode_getNodeValue( child ) ); ++ } ++ ++ return temp; ++} ++ ++ ++/******************************************************************************** ++ * SampleUtil_GetFirstServiceList ++ * ++ * Description: ++ * Given a DOM node representing a UPnP Device Description Document, ++ * this routine parses the document and finds the first service list ++ * (i.e., the service list for the root device). The service list ++ * is returned as a DOM node list. ++ * ++ * Parameters: ++ * node -- The DOM node from which to extract the service list ++ * ++ ********************************************************************************/ ++IXML_NodeList * ++SampleUtil_GetFirstServiceList( ++ IN IXML_Document * doc) ++{ ++ IXML_NodeList *ServiceList = NULL; ++ IXML_NodeList *servlistnodelist = NULL; ++ IXML_Node *servlistnode = NULL; ++ ++ servlistnodelist = ixmlDocument_getElementsByTagName(doc, "serviceList"); ++ if (servlistnodelist && ixmlNodeList_length(servlistnodelist)) ++ { ++ ++ /* ++ we only care about the first service list, from the root device ++ */ ++ servlistnode = ixmlNodeList_item(servlistnodelist, 0); ++ ++ /* ++ create as list of DOM nodes ++ */ ++ ServiceList = ixmlElement_getElementsByTagName((IXML_Element *)servlistnode, "service"); ++ } ++ ++ if (servlistnodelist) ++ ixmlNodeList_free(servlistnodelist); ++ ++ return ServiceList; ++} ++ ++ ++/******************************************************************************** ++ * SampleUtil_GetFirstDocumentItem ++ * ++ * Description: ++ * Given a document node, this routine searches for the first element ++ * named by the input string item, and returns its value as a string. ++ * String must be freed by caller using free. ++ * Parameters: ++ * doc -- The DOM document from which to extract the value ++ * item -- The item to search for ++ * ++ ********************************************************************************/ ++char * ++SampleUtil_GetFirstDocumentItem( ++ IN IXML_Document * doc, ++ IN const char *item) ++{ ++ IXML_NodeList *nodeList = NULL; ++ IXML_Node *textNode = NULL; ++ IXML_Node *tmpNode = NULL; ++ ++ char *ret = NULL; ++ ++ nodeList = ixmlDocument_getElementsByTagName( doc, ( char * )item ); ++ ++ if( nodeList ) { ++ if( ( tmpNode = ixmlNodeList_item( nodeList, 0 ) ) ) { ++ textNode = ixmlNode_getFirstChild( tmpNode ); ++ ++ ret = strdup( ixmlNode_getNodeValue( textNode ) ); ++ } ++ } ++ ++ if( nodeList ) ++ ixmlNodeList_free( nodeList ); ++ return ret; ++} ++ ++ ++/******************************************************************************** ++ * SampleUtil_GetFirstElementItem ++ * ++ * Description: ++ * Given a DOM element, this routine searches for the first element ++ * named by the input string item, and returns its value as a string. ++ * The string must be freed using free. ++ * Parameters: ++ * node -- The DOM element from which to extract the value ++ * item -- The item to search for ++ * ++ ********************************************************************************/ ++char * ++SampleUtil_GetFirstElementItem( ++ IN IXML_Element * element, ++ IN const char *item) ++{ ++ IXML_NodeList *nodeList = NULL; ++ IXML_Node *textNode = NULL; ++ IXML_Node *tmpNode = NULL; ++ ++ char *ret = NULL; ++ ++ nodeList = ixmlElement_getElementsByTagName( element, ( char * )item ); ++ ++ if( nodeList == NULL ) { ++ return NULL; ++ } ++ ++ if( ( tmpNode = ixmlNodeList_item( nodeList, 0 ) ) == NULL ) { ++ ixmlNodeList_free( nodeList ); ++ return NULL; ++ } ++ ++ textNode = ixmlNode_getFirstChild( tmpNode ); ++ ++ ret = strdup( ixmlNode_getNodeValue( textNode ) ); ++ ++ if( !ret ) { ++ ixmlNodeList_free( nodeList ); ++ return NULL; ++ } ++ ++ ixmlNodeList_free( nodeList ); ++ ++ return ret; ++} ++ ++ ++/******************************************************************************** ++ * SampleUtil_FindAndParseService ++ * ++ * Description: ++ * This routine finds the first occurance of a service in a DOM representation ++ * of a description document and parses it. ++ * ++ * Parameters: ++ * DescDoc -- The DOM description document ++ * location -- The location of the description document ++ * serviceSearchType -- The type of service to search for ++ * serviceId -- OUT -- The service ID ++ * eventURL -- OUT -- The event URL for the service ++ * controlURL -- OUT -- The control URL for the service ++ * ++ ********************************************************************************/ ++int ++SampleUtil_FindAndParseService( ++ IN IXML_Document * DescDoc, ++ IN char *location, ++ IN char *serviceType, ++ OUT char **serviceId, ++ OUT char **SCPDURL, ++ OUT char **eventURL, ++ OUT char **controlURL) ++{ ++ int i, length, found = 0; ++ int ret; ++ char *tempServiceType = NULL; ++ char *baseURL = NULL; ++ char *base; ++ char *relcontrolURL = NULL, *releventURL = NULL, *relSCPDURL = NULL; ++ IXML_NodeList *serviceList = NULL; ++ IXML_Element *service = NULL; ++ ++ baseURL = SampleUtil_GetFirstDocumentItem(DescDoc, "URLBase"); ++ ++ if( baseURL ) ++ base = baseURL; ++ else ++ base = location; ++ ++ ++ serviceList = SampleUtil_GetFirstServiceList(DescDoc); ++ length = ixmlNodeList_length(serviceList); ++ for (i = 0; i < length; i++) ++ { ++ service = (IXML_Element *)ixmlNodeList_item(serviceList, i); ++ tempServiceType = SampleUtil_GetFirstElementItem((IXML_Element *)service, "serviceType"); ++ ++ if (strcmp(tempServiceType, serviceType) == 0) ++ { ++ *serviceId = SampleUtil_GetFirstElementItem(service, "serviceId"); ++ relSCPDURL = SampleUtil_GetFirstElementItem(service, "SCPDURL"); ++ relcontrolURL = SampleUtil_GetFirstElementItem(service, "controlURL"); ++ releventURL = SampleUtil_GetFirstElementItem(service, "eventSubURL"); ++ ++ *SCPDURL = malloc(strlen(base) + strlen(relSCPDURL) + 1); ++ if(*SCPDURL) ++ ret = UpnpResolveURL(base, relSCPDURL, *SCPDURL); ++ ++ *controlURL = malloc(strlen(base) + strlen(relcontrolURL) + 1); ++ if(*controlURL) ++ ret = UpnpResolveURL(base, relcontrolURL, *controlURL); ++ ++ *eventURL = malloc(strlen(base) + strlen(releventURL) + 1); ++ if(*eventURL) ++ ret = UpnpResolveURL(base, releventURL, *eventURL); ++ ++ if(relSCPDURL) ++ free(relSCPDURL); ++ if(relcontrolURL) ++ free(relcontrolURL); ++ if(releventURL) ++ free(releventURL); ++ relSCPDURL = relcontrolURL = releventURL = NULL; ++ ++ found = 1; ++ break; ++ } ++ ++ if (tempServiceType) ++ free(tempServiceType); ++ tempServiceType = NULL; ++ } ++ ++ if( tempServiceType ) ++ free( tempServiceType ); ++ if( serviceList ) ++ ixmlNodeList_free( serviceList ); ++ if( baseURL ) ++ free( baseURL ); ++ ++ return ( found ); ++} ++ ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/sample_util.h +=================================================================== +--- /dev/null ++++ b/wsc/sample_util.h +@@ -0,0 +1,146 @@ ++/////////////////////////////////////////////////////////////////////////// ++// ++// 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. ++// ++/////////////////////////////////////////////////////////////////////////// ++ ++#ifndef SAMPLE_UTIL_H ++#define SAMPLE_UTIL_H ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#include ++#include ++#include "upnptools.h" ++#include "ixml.h" ++ ++typedef enum { ++ STATE_UPDATE = 0, ++ DEVICE_ADDED =1, ++ DEVICE_REMOVED=2, ++ GET_VAR_COMPLETE=3 ++} eventType; ++ ++ ++/******************************************************************************** ++ * SampleUtil_GetElementValue ++ * ++ * Description: ++ * Given a DOM node such as 11, this routine ++ * extracts the value (e.g., 11) from the node and returns it as ++ * a string. The string must be freed by the caller using ++ * free. ++ * ++ * Parameters: ++ * node -- The DOM node from which to extract the value ++ * ++ ********************************************************************************/ ++char * SampleUtil_GetElementValue(IN IXML_Element *element); ++ ++/******************************************************************************** ++ * SampleUtil_GetFirstServiceList ++ * ++ * Description: ++ * Given a DOM node representing a UPnP Device Description Document, ++ * this routine parses the document and finds the first service list ++ * (i.e., the service list for the root device). The service list ++ * is returned as a DOM node list. The NodeList must be freed using ++ * NodeList_free. ++ * ++ * Parameters: ++ * node -- The DOM node from which to extract the service list ++ * ++ ********************************************************************************/ ++ ++IXML_NodeList *SampleUtil_GetFirstServiceList(IN IXML_Document * doc); ++ ++ ++/******************************************************************************** ++ * SampleUtil_GetFirstDocumentItem ++ * ++ * Description: ++ * Given a document node, this routine searches for the first element ++ * named by the input string item, and returns its value as a string. ++ * String must be freed by caller using free. ++ * Parameters: ++ * doc -- The DOM document from which to extract the value ++ * item -- The item to search for ++ * ++ ********************************************************************************/ ++char * SampleUtil_GetFirstDocumentItem(IN IXML_Document *doc, IN const char *item); ++ ++ ++/******************************************************************************** ++ * SampleUtil_GetFirstElementItem ++ * ++ * Description: ++ * Given a DOM element, this routine searches for the first element ++ * named by the input string item, and returns its value as a string. ++ * The string must be freed using free. ++ * Parameters: ++ * node -- The DOM element from which to extract the value ++ * item -- The item to search for ++ * ++ ********************************************************************************/ ++char * SampleUtil_GetFirstElementItem(IN IXML_Element *element, IN const char *item); ++ ++ ++/******************************************************************************** ++ * SampleUtil_FindAndParseService ++ * ++ * Description: ++ * This routine finds the first occurance of a service in a DOM representation ++ * of a description document and parses it. Note that this function currently ++ * assumes that the eventURL and controlURL values in the service definitions ++ * are full URLs. Relative URLs are not handled here. ++ * ++ * Parameters: ++ * DescDoc -- The DOM description document ++ * location -- The location of the description document ++ * serviceSearchType -- The type of service to search for ++ * serviceId -- OUT -- The service ID ++ * eventURL -- OUT -- The event URL for the service ++ * controlURL -- OUT -- The control URL for the service ++ * ++ ********************************************************************************/ ++int SampleUtil_FindAndParseService ( ++ IN IXML_Document *DescDoc, ++ IN char* location, ++ IN char *serviceType, ++ OUT char **serviceId, ++ OUT char **SCDPURL, ++ OUT char **eventURL, ++ OUT char **controlURL); ++ ++#ifdef __cplusplus ++}; ++#endif ++ ++#endif /* UPNPSDK_UTIL_H */ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_common.c +=================================================================== +--- /dev/null ++++ b/wsc/wsc_common.c +@@ -0,0 +1,221 @@ ++#include ++#include ++#include ++#include "wsc_common.h" ++ ++ ++static const char cb64[]="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; ++static const char cd64[]="|$$$}rstuvwxyz{$$$$$$$>?@ABCDEFGHIJKLMNOPQRSTUVW$$$$$$XYZ[\\]^_`abcdefghijklmnopq"; ++ ++ ++extern int wsc_debug_level; ++ ++#ifdef RT_DEBUG ++void DBGPRINTF(int level, char *fmt, ...) ++{ ++ va_list ap; ++ ++ va_start(ap, fmt); ++ if (level <= wsc_debug_level) ++ { ++ vprintf(fmt, ap); ++ } ++ va_end(ap); ++} ++#endif ++ ++#ifdef ENABLE_WSC_SERVICE ++char * ++WSCGetValueFromNameValueList(char *pbuf, ++ const char *Name, int *len) ++{ ++ char prefix[32], postfix[32], *ptr, *endptr; ++ ++ *len = 0; ++ sprintf(prefix, "<%s", Name); ++ sprintf(postfix, "", Name); ++ ptr = strstr(pbuf, prefix); ++ ptr = strstr(ptr, ">"); ++ /* for ">" */ ++ ptr += 1; ++ endptr = strstr(pbuf, postfix); ++ if (ptr && endptr) ++ { ++ *len = endptr - ptr; ++ } ++ ++ return ptr; ++} ++ ++void wsc_chardump(char *title, char *ptr, int len) ++{ ++ ++ int32 i; ++ char *tmp = ptr; ++ ++ if (RT_DBG_PKT <= wsc_debug_level) ++ { ++ printf("\n===StartOfMsgCharDump:%s\n", title); ++ for(i = 0; i < len; i++) ++ { ++ printf("%c", tmp[i] & 0xff); ++ } ++ printf("\n===EndOfMsgCharDump!\n"); ++ } ++ ++ return; ++} ++ ++void wsc_hexdump(char *title, char *ptr, int len) ++{ ++ ++ int32 i; ++ char *tmp = ptr; ++ ++ if (RT_DBG_PKT <= wsc_debug_level) ++ { ++ printf("\n---StartOfMsgHexDump:%s\n", title); ++ for(i = 0; i < len; i++) ++ { ++ if(i%16==0 && i!=0) ++ printf("\n"); ++ printf("%02x ", tmp[i] & 0xff); ++ } ++ printf("\n---EndOfMsgHexDump!\n"); ++ } ++ ++ return; ++} ++#endif /* ENABLE_WSC_SERVICE */ ++ ++/* encode 3 8-bit binary bytes as 4 '6-bit' characters */ ++void ILibencodeblock( unsigned char in[3], unsigned char out[4], int len ) ++{ ++ out[0] = cb64[ in[0] >> 2 ]; ++ out[1] = cb64[ ((in[0] & 0x03) << 4) | ((in[1] & 0xf0) >> 4) ]; ++ out[2] = (unsigned char) (len > 1 ? cb64[ ((in[1] & 0x0f) << 2) | ((in[2] & 0xc0) >> 6) ] : '='); ++ out[3] = (unsigned char) (len > 2 ? cb64[ in[2] & 0x3f ] : '='); ++} ++ ++/*! \fn ILibBase64Encode(unsigned char* input, const int inputlen, unsigned char** output) ++ \brief Base64 encode a stream adding padding and line breaks as per spec. ++ \par ++ \b Note: The encoded stream must be freed ++ \param input The stream to encode ++ \param inputlen The length of \a input ++ \param output The encoded stream ++ \returns The length of the encoded stream ++*/ ++int ILibBase64Encode(unsigned char* input, const int inputlen, unsigned char** output) ++{ ++ unsigned char* out; ++ unsigned char* in; ++ ++ *output = (unsigned char*)malloc(((inputlen * 4) / 3) + 5); ++ out = *output; ++ ++ if (out == NULL) ++ { ++ return 0; ++ } ++ ++ in = input; ++ ++ if (input == NULL || inputlen == 0) ++ { ++ if (out) ++ free(out); ++ *output = NULL; ++ return 0; ++ } ++ ++ while ((in+3) <= (input+inputlen)) ++ { ++ ILibencodeblock(in, out, 3); ++ in += 3; ++ out += 4; ++ } ++ if ((input+inputlen)-in == 1) ++ { ++ ILibencodeblock(in, out, 1); ++ out += 4; ++ } ++ else ++ if ((input+inputlen)-in == 2) ++ { ++ ILibencodeblock(in, out, 2); ++ out += 4; ++ } ++ *out = 0; ++ ++ return (int)(out-*output); ++} ++ ++/* Decode 4 '6-bit' characters into 3 8-bit binary bytes */ ++void ILibdecodeblock( unsigned char in[4], unsigned char out[3] ) ++{ ++ out[ 0 ] = (unsigned char ) (in[0] << 2 | in[1] >> 4); ++ out[ 1 ] = (unsigned char ) (in[1] << 4 | in[2] >> 2); ++ out[ 2 ] = (unsigned char ) (((in[2] << 6) & 0xc0) | in[3]); ++} ++ ++/*! \fn ILibBase64Decode(unsigned char* input, const int inputlen, unsigned char** output) ++ \brief Decode a base64 encoded stream discarding padding, line breaks and noise ++ \par ++ \b Note: The decoded stream must be freed ++ \param input The stream to decode ++ \param inputlen The length of \a input ++ \param output The decoded stream ++ \returns The length of the decoded stream ++*/ ++int ILibBase64Decode(unsigned char* input, const int inputlen, unsigned char** output) ++{ ++ unsigned char* inptr; ++ unsigned char* out; ++ unsigned char v; ++ unsigned char in[4]; ++ int i, len; ++ ++ if (input == NULL || inputlen == 0) ++ { ++ *output = NULL; ++ return 0; ++ } ++ ++ *output = (unsigned char*)malloc(((inputlen * 3) / 4) + 4); ++ out = *output; ++ inptr = input; ++ ++ while( inptr <= (input+inputlen) ) ++ { ++ for( len = 0, i = 0; i < 4 && inptr <= (input+inputlen); i++ ) ++ { ++ v = 0; ++ while( inptr <= (input+inputlen) && v == 0 ) { ++ v = (unsigned char) *inptr; ++ inptr++; ++ v = (unsigned char) ((v < 43 || v > 122) ? 0 : cd64[ v - 43 ]); ++ if( v ) { ++ v = (unsigned char) ((v == '$') ? 0 : v - 61); ++ } ++ } ++ if( inptr <= (input+inputlen) ) { ++ len++; ++ if( v ) { ++ in[ i ] = (unsigned char) (v - 1); ++ } ++ } ++ else { ++ in[i] = 0; ++ } ++ } ++ if( len ) ++ { ++ ILibdecodeblock( in, out ); ++ out += len-1; ++ } ++ } ++ *out = 0; ++ return (int)(out-*output); ++} ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_common.h +=================================================================== +--- /dev/null ++++ b/wsc/wsc_common.h +@@ -0,0 +1,277 @@ ++#ifndef __WSC_COMMON_H__ ++#define __WSC_COMMON_H__ ++ ++#include ++#include ++#include ++#include ++#include ++#include "config.h" ++ ++#define WSC_VERSION "0.1.1" ++ ++#ifdef ENABLE_WSC_SERVICE ++ ++#define DEFAULT_WPS_PORT (8888) ++ ++extern unsigned short WPS_PORT; ++extern int netlink_sock; ++#ifndef TRUE ++#define TRUE 1 ++#endif ++ ++#ifndef FALSE ++#define FALSE 0 ++#endif ++typedef char * DOMString; ++#define IXML_Document DOMString ++ ++ ++/** {\bf UpnpAddToAction} creates an action request packet based on its input ++ * parameters (status variable name and value pair). This API is specially ++ * suitable inside a loop to add any number input parameters into an existing ++ * action. If no action document exists in the beginning then a ++ * {\bf Upnp_Document} variable initialized with {\tt NULL} should be passed ++ * as a parameter. ++ * ++ * @return [int] An integer representing one of the following: ++ * \begin{itemize} ++ * \item {\tt UPNP_E_SUCCESS}: The operation completed successfully. ++ * \item {\tt UPNP_E_INVALID_PARAM}: One or more of the parameters ++ * are invalid. ++ * \item {\tt UPNP_E_OUTOF_MEMORY}: Insufficient resources exist to ++ * complete this operation. ++ * \end{itemize} ++ */ ++ ++int UpnpAddToAction( ++ IXML_Document * ActionDoc, ++ /** A pointer to store the action ++ document node. */ ++ const char * ActionName, /** The action name. */ ++ const char * ServType, /** The service type. */ ++ const char * ArgName, /** The status variable name. */ ++ const char * ArgVal /** The status variable value. */ ++ ); ++ ++ ++/** {\bf UpnpAddToActionResponse} creates an action response ++ * packet based on its output parameters (status variable name ++ * and value pair). This API is especially suitable inside ++ * a loop to add any number of input parameters into an existing action ++ * response. If no action document exists in the beginning, a ++ * {\bf Upnp_Document} variable initialized with {\tt NULL} should be passed ++ * as a parameter. ++ * ++ * @return [int] An integer representing one of the following: ++ * \begin{itemize} ++ * \item {\tt UPNP_E_SUCCESS}: The operation completed successfully. ++ * \item {\tt UPNP_E_INVALID_PARAM}: One or more of the parameters ++ * are invalid. ++ * \item {\tt UPNP_E_OUTOF_MEMORY}: Insufficient resources exist to ++ * complete this operation. ++ * \end{itemize} ++ */ ++ ++int UpnpAddToActionResponse( ++ IXML_Document * ActionResponse, ++ /** Pointer to a document to ++ store the action document ++ node. */ ++ const char * ActionName, /** The action name. */ ++ const char * ServType, /** The service type. */ ++ const char * ArgName, /** The status variable name. */ ++ const char * ArgVal /** The status variable value. */ ++ ); ++ ++ ++char * ++WSCGetValueFromNameValueList(char *pbuffer, ++ const char * Name, int *len); ++#endif /* ENABLE_WSC_SERVICE */ ++ ++typedef unsigned char uint8; ++typedef unsigned short uint16; ++typedef unsigned int uint32; ++typedef signed char int8; ++typedef signed short int16; ++typedef signed int int32; ++ ++#ifndef PACKED ++#define PACKED __attribute__ ((packed)) ++#endif ++ ++#ifndef IFLA_IFNAME ++#define IFLA_IFNAME 3 ++#endif ++#ifndef IFLA_WIRELESS ++#define IFLA_WIRELESS 11 ++#endif ++ ++#ifndef ASSERT ++#define ASSERT(expr) \ ++ do{\ ++ if(!(expr)) \ ++ printf("%s(%d): ASSERTION Error!\n", __FUNCTION__, __LINE__); \ ++ }while(0); ++#endif ++ ++#ifndef RT_DEBUG ++#define DBGPRINTF(args...) do{}while(0) ++#else ++//void DBGPRINTF(int level, char *fmt, ...) __attribute__ ((format (printf, 2, 3))); ++void DBGPRINTF(int level, char *fmt, ...); ++#endif ++ ++ ++#ifndef IFNAMSIZ ++#define IFNAMSIZ 16 ++#endif ++ ++#define MAC_ADDR_LEN 6 ++#define LENGTH_802_1_H 8 ++ ++ ++#define BIT(x) (1< ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include "wsc_common.h" ++#include "wsc_ioctl.h" ++ ++ ++/****************************************************************************** ++ * wsc_set_oid ++ * ++ * Description: ++ * Send Wsc Message to kernel space by ioctl function call. ++ * ++ * Parameters: ++ * uint16 oid - The ioctl flag type for the ioctl function call. ++ * char *data - The data message want to send by ioctl ++ * int len - The length of data ++ * ++ * Return Value: ++ * Indicate if the ioctl success or failure. ++ * -1 = failure. ++ * 0 = If success. ++ *****************************************************************************/ ++int wsc_set_oid(uint16 oid, char *data, int len) ++{ ++ char *buf; ++ struct iwreq iwr; ++ ++ if(ioctl_sock < 0) ++ return -1; ++ ++ if((buf = malloc(len)) == NULL) ++ return -1; ++ ++ memset(buf, 0,len); ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, WSC_IOCTL_IF, IFNAMSIZ); ++ iwr.u.data.flags = oid; ++ iwr.u.data.flags |= OID_GET_SET_TOGGLE; ++ ++ if (data) ++ memcpy(buf, data, len); ++ ++ iwr.u.data.pointer = (caddr_t) buf; ++ iwr.u.data.length = len; ++ ++ if (ioctl(ioctl_sock, RT_PRIV_IOCTL, &iwr) < 0) { ++ DBGPRINTF(RT_DBG_INFO, "%s: oid=0x%x len (%d) failed", __FUNCTION__, oid, len); ++ free(buf); ++ return -1; ++ } ++ free(buf); ++ return 0; ++} ++ ++ ++/****************************************************************************** ++ * wsc_get_oid ++ * ++ * Description: ++ * Get Wsc Message from kernel space by ioctl function call. ++ * ++ * Parameters: ++ * uint16 oid - The ioctl flag type for the ioctl function call. ++ * char *data - The data pointer want to receive msg from ioctl. ++ * int len - The length of returned data. ++ * ++ * Return Value: ++ * Indicate if the ioctl success or failure. ++ * -1 = failure. ++ * 0 = If success. ++ *****************************************************************************/ ++int wsc_get_oid(uint16 oid, char *data, int *len) ++{ ++ struct iwreq iwr; ++ ++ if(ioctl_sock < 0 || data == NULL) ++ return -1; ++ ++ memset(&iwr, 0, sizeof(iwr)); ++ strncpy(iwr.ifr_name, WSC_IOCTL_IF, IFNAMSIZ); ++ iwr.u.data.flags = oid; ++ ++ iwr.u.data.pointer = (caddr_t)data; ++ if (ioctl(ioctl_sock, RT_PRIV_IOCTL, &iwr) < 0) { ++ DBGPRINTF(RT_DBG_ERROR, "%s: oid=0x%x failed", __FUNCTION__, oid); ++ return -1; ++ } ++ *len = iwr.u.data.length; ++ ++ return 0; ++} ++ ++ ++/****************************************************************************** ++ * wscU2KModuleInit ++ * ++ * Description: ++ * Initialize the U2K Message subsystem(i.e. it's ioctl sub-system now). ++ * ++ * Parameters: ++ * void ++ * ++ * Return Value: ++ * The created ioctl socket id or -1 to indicate if the initialize success or failure. ++ * -1 = failure. ++ * ioctl socket id = If success. ++ *****************************************************************************/ ++int wscU2KModuleInit(void) ++{ ++ int s; ++ struct ifreq ifr; ++ ++ /* open socket to kernel */ ++ if ((s = socket(AF_INET, SOCK_DGRAM, 0)) < 0) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "ioctl socket create failed! errno=%d!\n", errno); ++ return -1; ++ } ++ /* do it */ ++ strncpy(ifr.ifr_name, WSC_IOCTL_IF, IFNAMSIZ); ++ ++ if (ioctl(s, SIOCGIFINDEX, &ifr) < 0) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "ioctl to get the interface(%s) index failed! errno=%d!\n" , ifr.ifr_name, errno); ++ return -1; ++ } ++ ++ return s; ++ ++} ++ ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_ioctl.h +=================================================================== +--- /dev/null ++++ b/wsc/wsc_ioctl.h +@@ -0,0 +1,24 @@ ++/* ++ header file for wsc_ioctl ++ ++*/ ++#ifndef __WSC_IOCTL_H__ ++#define __WSC_IOCTL_H__ ++ ++ ++#if WIRELESS_EXT <= 11 ++#ifndef SIOCDEVPRIVATE ++#define SIOCDEVPRIVATE 0x8BE0 ++#endif ++#define SIOCIWFIRSTPRIV SIOCDEVPRIVATE ++#endif ++ ++#define RT_PRIV_IOCTL (SIOCIWFIRSTPRIV + 0x01) ++ ++#define OID_GET_SET_TOGGLE 0x8000 ++ ++#define RT_OID_WSC_UUID 0x0753 ++#define RT_OID_WSC_SET_SELECTED_REGISTRAR 0x0754 ++#define RT_OID_WSC_EAPMSG 0x0755 ++ ++#endif +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_main.c +=================================================================== +--- /dev/null ++++ b/wsc/wsc_main.c +@@ -0,0 +1,468 @@ ++/*************************************** ++ wsc main function ++****************************************/ ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++#include ++ ++//#include "config.h" ++#include "upnpglobalvars.h" ++#include "wsc_common.h" ++#include "wsc_msg.h" ++#include "wsc_upnp.h" ++ ++#include "upnpreplyparse.h" ++ ++//int wsc_debug_level = RT_DBG_OFF; ++int wsc_debug_level = RT_DBG_INFO; ++ ++int ioctl_sock = -1; ++unsigned char UUID[16]= {0}; ++ ++int enableDaemon = 0; ++ ++static int wscUPnPDevInit = FALSE; ++static int wscK2UMInit = FALSE; ++static int wscU2KMInit = FALSE; ++static int wscMsgQInit = FALSE; ++ ++ ++int WscUPnPOpMode; ++//peter : 0523 ++//char HostDescURL[WSC_UPNP_DESC_URL_LEN] = {0}; // Used to save the DescriptionURL of local host. ++unsigned char HostMacAddr[MAC_ADDR_LEN]={0}; // Used to save the MAC address of local host. ++unsigned int HostIPAddr; // Used to save the binded IP address of local host. ++char WSC_IOCTL_IF[IFNAMSIZ]; ++unsigned short WPS_PORT; ++#if 1 //def MULTIPLE_CARD_SUPPORT ++#define FILE_PATH_LEN 256 ++char pid_file_path[FILE_PATH_LEN]; ++#endif // MULTIPLE_CARD_SUPPORT // ++ ++void usage(void) ++{ ++ printf("Usage: miniupnpd -G [-I infName] [-A ipaddress] [-n port] [-F descDoc] [-w webRootDir] -m UPnPOpMode -D [-l debugLevel] -h\n"); ++ printf("\t-G: Enable IGD Device service in miniupnpd\n"); ++ printf("\t-I: Interface name this daemon will run wsc protocol(if not set, will use the default interface name - ra0)\n"); ++ printf("\t\t\te.g.: ra0\n"); ++ printf("\t-A: IP address of the device (if not set, will auto assigned)\n"); ++ printf("\t\t\t e.g.: 192.168.0.1\n"); ++ printf("\t-n: Port number for receiving UPnP messages (if not set, will auto assigned)\n"); ++ printf("\t\t\t e.g.: 54312\n"); ++ printf("\t-F: Name of device description document (If not set, will used default value)\n"); ++ printf("\t\t\t e.g.: WFADeviceDesc.xml\n"); ++ printf("\t-w: Filesystem path where descDoc and web files related to the device are stored\n"); ++ printf("\t\t\t e.g.: /etc/xml/\n"); ++ printf("\t-m: UPnP system operation mode\n"); ++ printf("\t\t\t 1: Enable UPnP Device service(Support Enrolle or Proxy functions)\n"); ++ printf("\t\t\t 2: Enable UPnP Control Point service(Support Registratr function)\n"); ++ printf("\t\t\t 3: Enable both UPnP device service and Control Point services.\n"); ++ printf("\t-D: Run program in daemon mode.\n"); ++ printf("\t-l: Debug level of WPS module.\n"); ++ printf("\t\t\t 0: debug printing off\n"); ++ printf("\t\t\t 1: DEBUG_ERROR\n"); ++ printf("\t\t\t 2: DEBUG_PKT\n"); ++ printf("\t\t\t 3: DEBUG_INFO\n"); ++ ++ exit(1); ++ ++} ++ ++ ++void sig_handler(int sigNum) ++{ ++ sig_atomic_t status; ++ ++ DBGPRINTF(RT_DBG_INFO, "Get a signal=%d!\n", sigNum); ++ switch(sigNum) ++ { ++ case SIGCHLD: ++ wait3(&status, WNOHANG, NULL); ++ break; ++ default: ++ break; ++ } ++ ++} ++ ++int wscSystemInit(void) ++{ ++ int retVal; ++ ++ struct sigaction sig; ++ memset(&sig, 0, sizeof(struct sigaction)); ++ sig.sa_handler= &sig_handler; ++ sigaction(SIGCHLD, &sig, NULL); ++ ++ retVal = wscMsgSubSystemInit(); ++ ++ return retVal; ++} ++ ++ ++int wscSystemStop(void) ++{ ++ /* Stop the K2U and U2K msg subsystem */ ++ if (wscU2KMInit && ioctl_sock >= 0) ++ { ++ // Close the ioctl socket. ++ close(ioctl_sock); ++ ioctl_sock = -1; ++ } ++ ++ if (wscK2UMInit) ++ { ++ ++ } ++ ++ if(wscUPnPDevInit) ++ { ++ WscUPnPDevStop(); ++ } ++/* ++ if(wscUPnPCPInit) ++ WscUPnPCPStop(); ++*/ ++#if 0 ++ if(wscUPnPSDKInit) ++ UpnpFinish(); ++#endif ++ ++ if( wscMsgQInit) ++ { ++ wscMsgSubSystemStop(); ++ } ++ return 1; ++} ++ ++/****************************************************************************** ++ * WscDeviceCommandLoop ++ * ++ * Description: ++ * Function that receives commands from the user at the command prompt ++ * during the lifetime of the device, and calls the appropriate ++ * functions for those commands. Only one command, exit, is currently ++ * defined. ++ * ++ * Parameters: ++ * None ++ * ++ *****************************************************************************/ ++void * ++WscDeviceCommandLoop( void *args ) ++{ ++ int stoploop = 0; ++ char cmdline[100]; ++ char cmd[100]; ++ ++ while( !stoploop ) { ++ sprintf( cmdline, " " ); ++ sprintf( cmd, " " ); ++ ++ printf( "\n>> " ); ++ ++ // Get a command line ++ fgets( cmdline, 100, stdin ); ++ ++ sscanf( cmdline, "%s", cmd ); ++ ++ if( strcasecmp( cmd, "exit" ) == 0 ) { ++ printf( "Shutting down...\n" ); ++ wscSystemStop(); ++ } else { ++ printf("\n Unknown command: %s\n\n", cmd); ++ printf(" Valid Commands:\n" ); ++ printf(" Exit\n\n" ); ++ } ++ ++ } ++ ++ return NULL; ++} ++ ++ ++ ++/****************************************************************************** ++ * main of WPS module ++ * ++ * Description: ++ * Main entry point for WSC device application. ++ * Initializes and registers with the sdk. ++ * Initializes the state stables of the service. ++ * Starts the command loop. ++ * ++ * Parameters: ++ * int argc - count of arguments ++ * char ** argv -arguments. The application ++ * accepts the following optional arguments: ++ * ++ * -ip ipAddress ++ * -port port ++ * -desc descDoc ++ * -webdir webRootDir" ++ * -help ++ * -i ioctl binding interface. ++ * ++ *****************************************************************************/ ++int WPSInit(int argc, char **argv) ++{ ++ unsigned int portTemp = 0; ++ char *ipAddr = NULL, *descDoc = NULL, *webRootDir = NULL, *infName = NULL; ++// unsigned short port = 0; ++ FILE *fp; ++ int retVal; ++ int opt; ++ ++ if (argc < 2) ++ usage(); ++ ++ printf("\n@@@@@@@@@ WPSInit @@@@@@@@@\n"); ++ ++ /* default op mode is device */ ++ WscUPnPOpMode = WSC_UPNP_OPMODE_DEV; ++ /* default op mode is device */ ++ memset(&WSC_IOCTL_IF[0], 0, IFNAMSIZ); ++ strcpy(&WSC_IOCTL_IF[0], "ra0"); ++ ++ /* first, parsing the input options */ ++ while((opt = getopt(argc, argv, "A:I:n:F:w:m:l:DGdh"))!= -1) ++ { ++ switch (opt) ++ { ++ case 'A': ++ ipAddr = optarg; ++ break; ++ case 'n': ++ sscanf(optarg, "%u", &portTemp); ++ break; ++ case 'F': ++ descDoc = optarg; ++ break; ++ case 'I': ++ infName = optarg; ++ memset(&WSC_IOCTL_IF[0], 0, IFNAMSIZ); ++ if (strlen(infName)) ++ strncpy(&WSC_IOCTL_IF[0], infName, IFNAMSIZ); ++ else ++ strcpy(&WSC_IOCTL_IF[0], "ra0"); ++ break; ++ case 'w': ++ webRootDir = optarg; ++ break; ++ case 'm': ++ WscUPnPOpMode = strtol(optarg, NULL, 10); ++ if (WscUPnPOpMode < WSC_UPNP_OPMODE_DEV || WscUPnPOpMode > WSC_UPNP_OPMODE_BOTH) ++ usage(); ++ break; ++ case 'D': ++ enableDaemon = 1; ++ break; ++ case 'l': ++ wsc_debug_level = strtol(optarg, NULL, 10); ++ break; ++ case 'G': ++ /* dummy option - In fact : be handled in miniupnpd */ ++ break; ++ case 'd': ++ /* dummy option - In fact : be handled in miniupnpd */ ++ break; ++ case 'h': ++ usage(); ++ break; ++ } ++ } ++ ++ if ((WscUPnPOpMode < WSC_UPNP_OPMODE_DEV) || (WscUPnPOpMode > WSC_UPNP_OPMODE_BOTH)) ++ { ++ fprintf(stderr, "Wrong UPnP Operation Mode: %d\n", WscUPnPOpMode); ++ usage(); ++ } ++ if ((wsc_debug_level > RT_DBG_ALL) || (wsc_debug_level < RT_DBG_OFF)) ++ { ++ fprintf(stderr, "Wrong Debug Level: %d\n", wsc_debug_level); ++ usage(); ++ } ++ ++ if (enableDaemon) ++ { ++ pid_t childPid; ++ ++ childPid = fork(); ++ if(childPid < 0) ++ { ++ fprintf(stderr, "Run in daemon mode failed --ErrMsg=%s!\n", strerror(errno)); ++ exit(0); ++ } ++ else if (childPid > 0) ++ exit(0); ++ else ++ { ++ /* normal programming style to make a program work as a daemon */ ++ close(0); /* close the stdin fd */ ++ close(1); /* close the stdout fd */ ++ } ++ } ++ ++ /* Write the pid file */ ++#if 1 // def MULTIPLE_CARD_SUPPORT ++ memset(&pid_file_path[0], 0, FILE_PATH_LEN); ++ sprintf(pid_file_path, "%s.%s", DEFAULT_PID_FILE_PATH, WSC_IOCTL_IF); ++ DBGPRINTF(RT_DBG_INFO, "The pid file is: %s!\n", pid_file_path); ++ if ((fp = fopen(pid_file_path, "w")) != NULL) ++#else ++ if((fp = fopen(DEFAULT_PID_FILE_PATH, "w"))!= NULL) ++#endif // MULTIPLE_CARD_SUPPORT // ++ { ++ fprintf(fp, "%d", getpid()); ++ fclose(fp); ++ } ++ ++ /* System paramters initialization */ ++ if (wscSystemInit() == WSC_SYS_ERROR) ++ { ++ fprintf(stderr, "wsc MsgQ System Initialization failed!\n"); ++ goto STOP; ++ } ++ wscMsgQInit = TRUE; ++ ++ /* Initialize the netlink interface from kernel space */ ++ if(wscK2UModuleInit() != WSC_SYS_SUCCESS) ++ { ++ fprintf(stderr, "creat netlink socket failed!\n"); ++ goto STOP; ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_INFO, "Create netlink socket success!\n"); ++ wscK2UMInit = TRUE; ++ } ++ ++ /* Initialize the ioctl interface for data path to kernel space */ ++ ioctl_sock = wscU2KModuleInit(); ++ if(ioctl_sock == -1) ++ { ++ fprintf(stderr, "creat ioctl socket failed!err=%d!\n", errno); ++ goto STOP; ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_INFO, "Create ioctl socket(%d) success!\n", ioctl_sock); ++ wscU2KMInit = TRUE; ++ } ++ ++ /* Initialize the upnp related data structure and start upnp service */ ++ if(WscUPnPOpMode) ++ { ++ struct ifreq ifr; ++#if 0 ++ // Initializing UPnP SDK ++ if ((retVal = UpnpInit(ipAddr, port)) != 0) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error with UpnpInit -- %d\n", retVal); ++ UpnpFinish(); ++ goto STOP; ++ } ++ wscUPnPSDKInit = TRUE; ++#endif ++ // Get the IP/Port the UPnP services want to bind. ++ ++ if (ipAddr == NULL) ++ { ++// ipAddr = UpnpGetServerIpAddress(); ++// ipAddr = "192.168.15.43"; ++#if 1 ++#if 1 //Porting for miniupnpd 1.6 ++ struct lan_addr_s * tmp_addr; ++ tmp_addr = lan_addrs.lh_first; ++ if (tmp_addr!=NULL) ++ { ++ ipAddr =tmp_addr->str; ++ } ++#else ++ ipAddr = lan_addr[0].str; ++#endif ++#else ++ if ((lan_addr[n_lan_addr-1].str != NULL) && (GETFLAG(ENABLEWPSMASK))) ++ ipAddr = lan_addr[n_lan_addr-1].str; ++#endif ++ } ++ ASSERT(ipAddr != NULL); ++ inet_aton(ipAddr, (struct in_addr *)&HostIPAddr); ++ ++ if (portTemp != 0) ++ { ++ WPS_PORT = (unsigned short)portTemp; ++ } ++ else ++ { ++ /* set default port number for WPS service */ ++ WPS_PORT = (unsigned short)DEFAULT_WPS_PORT; ++ } ++ ++ ASSERT(WPS_PORT > 0); ++ ++ // Get the Mac Address of wireless interface ++ memset(&ifr, 0, sizeof(struct ifreq)); ++ strcpy(ifr.ifr_name, WSC_IOCTL_IF); ++ if (ioctl(ioctl_sock, SIOCGIFHWADDR, &ifr) > 0) ++ { ++ perror("ioctl to get Mac Address"); ++ goto STOP; ++ } ++ memcpy(HostMacAddr, ifr.ifr_hwaddr.sa_data, MAC_ADDR_LEN); ++ ++ DBGPRINTF(RT_DBG_INFO, "\t HW-Addr: "MACSTR"!\n", MAC2STR(HostMacAddr)); ++ ++ // Start UPnP Device Service. ++ if (WscUPnPOpMode & WSC_UPNP_OPMODE_DEV) ++ { ++ retVal = WscUPnPDevStart(ipAddr, WPS_PORT, descDoc, webRootDir); ++ if (retVal != WSC_SYS_SUCCESS) ++ goto STOP; ++ wscUPnPDevInit = TRUE; ++ } ++#if 0 /* apply for control point only */ ++ // Start UPnP Control Point Service. ++ if(WscUPnPOpMode & WSC_UPNP_OPMODE_CP) ++ { ++ retVal = WscUPnPCPStart(ipAddr, port); ++ if (retVal != WSC_SYS_SUCCESS) ++ goto STOP; ++ wscUPnPCPInit = TRUE; ++ } ++#endif ++ } ++ ++#if 0 /* handled in main() of miniupnpd */ ++ /* Catch Ctrl-C and properly shutdown */ ++ sigemptyset(&sigs_to_catch); ++ sigaddset(&sigs_to_catch, SIGINT); ++ sigwait(&sigs_to_catch, &sig); ++ ++ DBGPRINTF(RT_DBG_INFO, "Shutting down on signal %d...\n", sig); ++#endif ++ ++ return 1; ++ ++ DBGPRINTF(RT_DBG_INFO, "wscSystemStop()...\n"); ++ wscSystemStop(); ++STOP: ++ /* Trigger other thread to stop the procedures. */ ++#if 1 //def MULTIPLE_CARD_SUPPORT ++ unlink(pid_file_path); ++#else ++ unlink(DEFAULT_PID_FILE_PATH); ++#endif // MULTIPLE_CARD_SUPPORT // ++ return 0; ++// exit(0); ++} ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_msg.c +=================================================================== +--- /dev/null ++++ b/wsc/wsc_msg.c +@@ -0,0 +1,569 @@ ++/* ++ wsc_msg.c used to handle wsc msg system. ++*/ ++#include ++#include "wsc_msg.h" ++#include "wsc_upnp.h" ++#include "wsc_common.h" ++ ++ ++/* Used for Passive Queue system */ ++#define WSCPASSIVEMSGQ_MAX_ENTRY 32 ++ ++static uint32 gPassiveMsgID=0; ++static WscU2KMsgQ gPassiveMsgQ[WSCPASSIVEMSGQ_MAX_ENTRY]; ++ ++/* Used for Active Queue system */ ++#define WSCACTIVEMSGQ_MAX_ENTRY 32 ++ ++static pthread_mutex_t gActiveMsgQLock; ++static WscU2KMsgQ gActiveMsgQ[WSCACTIVEMSGQ_MAX_ENTRY]; ++ ++/* Used for Active Message Handler callback fucntion list */ ++#define WSCACTIVEMSGHANDLE_LSIT_MAX_ENTRY 3 ++ ++static WscMsgHandle gActiveMsgHandleList[WSCACTIVEMSGHANDLE_LSIT_MAX_ENTRY]={ ++ {WSC_OPCODE_UPNP_DATA, WscEventDataMsgRecv}, ++ {WSC_OPCODE_UPNP_MGMT, WscEventMgmtMsgRecv}, ++ {WSC_OPCODE_UPNP_CTRL, WscEventCtrlMsgRecv}, ++}; ++ ++ ++int wscEnvelopeFree(IN WscEnvelope *envelope) ++{ ++ if(envelope) ++ { ++ if(envelope->pMsgPtr) ++ free(envelope->pMsgPtr); ++ free(envelope); ++ } ++ ++ return 0; ++} ++ ++int wscEnvelopeRemove( ++ IN WscEnvelope *envelope, ++ OUT int qIdx) ++{ ++ if(!envelope) ++ return WSC_SYS_ERROR; ++ ++ wscEnvelopeFree(envelope); ++ if((qIdx >= 0) && (qIdx < WSCPASSIVEMSGQ_MAX_ENTRY)) ++ { ++ gPassiveMsgQ[qIdx].pEnvelope = NULL; ++ gPassiveMsgQ[qIdx].used = 0; ++ } ++ ++ return WSC_SYS_SUCCESS;; ++} ++ ++ ++/****************************************************************************** ++ * wscEnvelopeCreate ++ * ++ * Description: ++ * Allocate the memory space for a new envelope and init it. ++ * ++ * Parameters: ++ * void ++ ++ * Return Value: ++ * The pointer of cretaed envelope. ++ * NULL = failure. ++ * others = True. ++ *****************************************************************************/ ++WscEnvelope *wscEnvelopeCreate(void) ++{ ++ WscEnvelope *envelope = NULL; ++ ++ if((envelope = malloc(sizeof(WscEnvelope))) == NULL) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Allocate memory to create a new envelope failed!\n"); ++ return NULL; ++ } ++ ++ memset(envelope, 0 ,sizeof(WscEnvelope)); ++ ++ envelope->h = NULL; ++ envelope->DevCallBack = NULL; ++ envelope->callBack = NULL; ++ envelope->timerCount = DEF_WSC_ENVELOPE_TIME_OUT; ++ return envelope; ++} ++ ++ ++/****************************************************************************** ++ * wscEnvelopeCreate ++ * ++ * Description: ++ * Insert a envelope to the message Queue(gPassiveMsgQ) and assign a ++ * eventID to this envelope. ++ * ++ * Parameters: ++ * WscEnvelope *envelope - The envelope want to insert. ++ * int *pQIdx - The msg Q index of the envelope inserted in. ++ * ++ * Return Value: ++ * Indicate if the envelope insetion success or failure. ++ * WSC_SYS_SUCCESS = failure. ++ * WSC_SYS_ERROR = True. ++ *****************************************************************************/ ++int wscMsgQInsert( ++ IN WscEnvelope *envelope, ++ OUT int *pQIdx) ++{ ++ int idx; ++ ++ if(!envelope) ++ return WSC_SYS_ERROR; ++ ++ for(idx = 0; idx < WSCPASSIVEMSGQ_MAX_ENTRY; idx++) ++ { ++ if(gPassiveMsgQ[idx].used == 0) ++ { ++ envelope->envID = ((++gPassiveMsgID) == 0 ? (++gPassiveMsgID) : gPassiveMsgID); //ID 0 is reserved for msg directly send by kernel. ++ gPassiveMsgQ[idx].pEnvelope = envelope; ++ gPassiveMsgQ[idx].used = 1; ++ ++ break; ++ } ++ } ++ ++ if(idx < WSCPASSIVEMSGQ_MAX_ENTRY) ++ { ++ *pQIdx = idx; ++ DBGPRINTF(RT_DBG_INFO, "Insert envelope to msgQ success, msgQIdx = %d!envID=0x%x!\n", idx, envelope->envID); ++ return WSC_SYS_SUCCESS; ++ } ++ ++ return WSC_SYS_ERROR; ++} ++ ++ ++/****************************************************************************** ++ * wscMsgQRemove ++ * ++ * Description: ++ * Remove the envelope in the message Queue. ++ * Note: ++ * This function just remove the envelope from the Q but not free it. You ++ * should free it yourself. ++ * ++ * Parameters: ++ * int qType - The Message Queue type want to handle. ++ * int qIdx - The msg Q index want to be removed. ++ * ++ * Return Value: ++ * Indicate if the envelope delete success or failure. ++ * WSC_SYS_SUCCESS = failure. ++ * WSC_SYS_ERROR = True. ++ *****************************************************************************/ ++int wscMsgQRemove( ++ IN int qType, ++ IN int qIdx) ++{ ++ // The ActiveQ and PassiveQ have the same maximum capacity of the envelope. ++ if (qIdx < 0 || qIdx >= WSCPASSIVEMSGQ_MAX_ENTRY) ++ return WSC_SYS_ERROR; ++ ++ if(qType == Q_TYPE_ACTIVE) ++ { // Handle the Active Q. ++ if(pthread_mutex_lock(&gActiveMsgQLock) == 0) ++ { ++ wscEnvelopeFree(gActiveMsgQ[qIdx].pEnvelope); ++ gActiveMsgQ[qIdx].pEnvelope = NULL; ++ gActiveMsgQ[qIdx].used = 0; ++ pthread_mutex_unlock(&gActiveMsgQLock); ++ } ++ } ++ else if(qType ==Q_TYPE_PASSIVE) ++ { // Handle the Passive Q. ++ wscEnvelopeFree(gPassiveMsgQ[qIdx].pEnvelope); ++ gPassiveMsgQ[qIdx].pEnvelope = NULL; ++ gPassiveMsgQ[qIdx].used = 0; ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_ERROR, "%s():Wrong MsgQ Type -- type=%d!\n", __FUNCTION__, qType); ++ } ++ ++ return WSC_SYS_ERROR; ++ ++} ++ ++int registerActiveMsgTypeHandle( ++ IN int MsgType, ++ IN msgHandleCallback handle) ++{ ++ ++ return -1; ++} ++ ++int wscActiveMsgHandler(IN WscEnvelope* pEnvelope) ++{ ++ int i; ++ RTMP_WSC_MSG_HDR *pHdr = NULL; ++ ++ pHdr = (RTMP_WSC_MSG_HDR *)pEnvelope->pMsgPtr; ++ ++ DBGPRINTF(RT_DBG_INFO, "%s(): the ActiveMsgType=%d, SubType=%d!\n", __FUNCTION__, pHdr->msgType, pHdr->msgSubType); ++ for(i=0; i< WSCACTIVEMSGHANDLE_LSIT_MAX_ENTRY; i++) ++ { ++ if((gActiveMsgHandleList[i].msgType == pHdr->msgType) && (gActiveMsgHandleList[i].handle != NULL)) ++ { ++ DBGPRINTF(RT_DBG_INFO, "find ActiveMsgHandler!\n"); ++ return (gActiveMsgHandleList[i].handle)((char *)pEnvelope->pMsgPtr, pEnvelope->msgLen); ++ } ++ } ++ ++ return 0; ++} ++ ++ ++int wscMsgStateUpdate(char *pBuf, int len) ++{ ++ ++ /* ++ TODO: If we want to maintain our UPnP engine status. We need to add the code here. ++ */ ++#if 0 ++ RTMP_WSC_MSG_HDR *pHdr; ++ ++ pHdr = (RTMP_WSC_MSG_HDR *)pBuf; ++ ++ if(pHdr == NULL) ++ return 0; ++ ++ if(pHdr->msgType != WSC_OPCODE_UPNP_DATA) ++ return 0; ++#endif ++ return 0; ++ ++} ++ ++ ++/* ++ NETLINK tunnel msg format send to WSCUPnP handler in user space: ++ 1. Signature of following string(Not include the quote, 8 bytes) ++ "RAWSCMSG" ++ 2. eID: eventID (4 bytes) ++ the ID of this message(4 bytes) ++ 3. aID: ackID (4 bytes) ++ means that which event ID this mesage was response to. ++ 4. TL: Message Total Length (4 bytes) ++ Total length of this message. ++ 5. F: Flag (2 bytes) ++ used to notify some specific character of this msg segment. ++ Bit 1: fragment ++ set as 1 if netlink layer have more segment of this Msg need to send. ++ Bit 2~15: reserve, should set as 0 now. ++ 5. SL: Segment Length(2 bytes) ++ msg actual length in this segment, The SL may not equal the "TL" field if "F" ==1 ++ 6. devMac: device mac address(6 bytes) ++ Indicate the netdevice which this msg belong. For the wscd in user space will ++ depends this address dispatch the msg to correct UPnP Device instance to handle it. ++ 7. "WSC_MSG" info: ++ ++ 8 4 4 4 2 2 6 variable length(MAXIMA=232) ++ +------------+----+----+----+--+--+------+------------------------+ ++ | Signature |eID |aID | TL | F | SL|devMac| WSC_MSG | ++ ++*/ ++int WscRTMPMsgHandler(char *pBuf, int len) ++{ ++ char *pos, *pBufPtr; ++ int dataLen = 0, qIdx, workQIdx = -1; ++ RTMP_WSC_NLMSG_HDR *pSegHdr; ++ WscEnvelope *pEnvPtr = NULL; ++ int qType; ++ ++ pSegHdr = (RTMP_WSC_NLMSG_HDR *)pBuf; ++ ++ ++#if 1 // def MULTIPLE_CARD_SUPPORT ++ if (memcmp(&pSegHdr->devAddr[0], &HostMacAddr[0], MAC_ADDR_LEN) != 0) ++ { ++ DBGPRINTF(RT_DBG_INFO, "This msg are not the device we served("MACSTR")!!\n", ++ getpid(), MAC2STR(HostMacAddr)); ++ return 0; ++ } ++#endif // MULTIPLE_CARD_SUPPORT // ++ ++ DBGPRINTF(RT_DBG_INFO, "pSegHdr->envID=0x%08x, ackID=0x%08x, devAddr="MACSTR"\n", ++ pSegHdr->envID, pSegHdr->ackID, MAC2STR(pSegHdr->devAddr)); ++ ++ if(pSegHdr->ackID == 0) ++ { ++ int emptyIdx = -1; ++ ++ /* The message should insert into the ActiveMsgQ */ ++ pthread_mutex_lock(&gActiveMsgQLock); ++ for(qIdx = 0; qIdx < WSCACTIVEMSGQ_MAX_ENTRY; qIdx++) ++ { // Search for mailBox to check if we have a matched eventID. ++ if((gActiveMsgQ[qIdx].used == 1) && ((pEnvPtr = gActiveMsgQ[qIdx].pEnvelope) != NULL)) ++ { ++ if(pEnvPtr->envID == pSegHdr->envID) ++ { ++ workQIdx = qIdx; ++ pEnvPtr->timerCount = DEF_WSC_ENVELOPE_TIME_OUT; ++ break; ++ } ++ } ++ else if(emptyIdx < 0 && gActiveMsgQ[qIdx].used == 0){ ++ emptyIdx = qIdx; //record the first un-used qIdx. ++ } ++ } ++ ++ if((qIdx == WSCACTIVEMSGQ_MAX_ENTRY) && (emptyIdx >= 0)) ++ { ++ pEnvPtr = wscEnvelopeCreate(); ++ if(pEnvPtr != NULL) ++ { ++ wscEnvelopeFree(gActiveMsgQ[emptyIdx].pEnvelope); ++ pEnvPtr->envID = pSegHdr->envID; ++ gActiveMsgQ[emptyIdx].used = 1; ++ gActiveMsgQ[emptyIdx].pEnvelope = pEnvPtr; ++ workQIdx = emptyIdx; ++ } ++ } ++ pthread_mutex_unlock(&gActiveMsgQLock); ++ ++ if(pEnvPtr == NULL) ++ return -1; ++ ++ qType = Q_TYPE_ACTIVE; ++ ++ //For debug ++ if (pEnvPtr->pMsgPtr == NULL) { ++ DBGPRINTF(RT_DBG_INFO, "Receive a new wireless event(WscActiveMsg):\n" ++ "\tMsgHdr->msgLen=%d\n" ++ "\tMsgHdr->envID=0x%08x\n" ++ "\tMsgHdr->ackID=0x%08x\n" ++ "\tMsgHdr->flags=0x%04x\n" ++ "\tMsgHdr->segLen=%d\n", ++ pSegHdr->msgLen, pSegHdr->envID, pSegHdr->ackID, ++ pSegHdr->flags, pSegHdr->segLen); ++ } ++ } ++ else ++ { ++ /* The message should insert into the PassiveMsgQ */ ++ for(qIdx = 0; qIdx < WSCPASSIVEMSGQ_MAX_ENTRY; qIdx++) ++ { // Search for mailBox to check if we have a matched ackID. ++ if(gPassiveMsgQ[qIdx].used == 1 && ((pEnvPtr = gPassiveMsgQ[qIdx].pEnvelope) != NULL)) ++ { ++ if(pEnvPtr->envID == pSegHdr->ackID) ++ { ++ pEnvPtr->timerCount = DEF_WSC_ENVELOPE_TIME_OUT; ++ break; ++ } ++ } ++ } ++ ++ if(qIdx == WSCPASSIVEMSGQ_MAX_ENTRY) //Queue is full, drop it directly? ++ return -1; ++ ++ qType = Q_TYPE_PASSIVE; ++ ++ //For debug ++ if (pEnvPtr->pMsgPtr == NULL) { ++ DBGPRINTF(RT_DBG_INFO, "Receive a new wireless event(WscPassiveMsg):\n" ++ "\tMsgHdr->msgLen=%d\n" ++ "\tMsgHdr->envID=0x%x\n" ++ "\tMsgHdr->ackID=0x%x\n" ++ "\tMsgHdr->flags=0x%x\n" ++ "\tMsgHdr->segLen=%d\n", ++ pSegHdr->msgLen, pSegHdr->envID, pSegHdr->ackID, ++ pSegHdr->flags, pSegHdr->segLen); ++ } ++ } ++ ++ //Now handle the wsc_msg payload. ++ pos = ((char *)pSegHdr + sizeof(RTMP_WSC_NLMSG_HDR)); ++ dataLen = pSegHdr->segLen; ++ if (pos) ++ { ++ /* TODO: Need to handle it to Upnp Module */ ++ //wsc_hexdump("WSCENROLMSG", pos, dataLen); ++ if (pEnvPtr->pMsgPtr == NULL) ++ { ++ if ((pEnvPtr->pMsgPtr = malloc(pSegHdr->msgLen)) != NULL) ++ { ++ pEnvPtr->msgLen = pSegHdr->msgLen; ++ pEnvPtr->actLen = 0; ++ } else { ++ DBGPRINTF(RT_DBG_ERROR, "%s():allocate memory for pEnvPtr->pMsgPtr failed!\n", __FUNCTION__); ++ pEnvPtr->flag = WSC_ENVELOPE_MEM_FAILED; ++ } ++ } ++ ++ if((pEnvPtr->flag & WSC_ENVELOPE_MEM_FAILED) != WSC_ENVELOPE_MEM_FAILED) ++ { ++ pBufPtr = &((char *)pEnvPtr->pMsgPtr)[pEnvPtr->actLen]; ++ memcpy(pBufPtr, pos, dataLen); ++ pEnvPtr->actLen += dataLen; ++ ++ if (pSegHdr->flags == 0) ++ pEnvPtr->flag = WSC_ENVELOPE_SUCCESS; ++ } ++ } ++ ++ // Trigger the event handler to process the received msgs. ++ if(pEnvPtr->flag != WSC_ENVELOPE_NONE) ++ { ++ // Check and update the WSC status depends on the messages. ++ if(pEnvPtr->flag == WSC_ENVELOPE_SUCCESS) ++ wscMsgStateUpdate(pEnvPtr->pMsgPtr, pEnvPtr->msgLen); ++ ++ // Deliver the message to corresponding handler. ++ if(qType == Q_TYPE_PASSIVE) ++ { ++ gPassiveMsgQ[qIdx].used = 0; ++ gPassiveMsgQ[qIdx].pEnvelope = NULL; ++ ++ //wsc_hexdump("NLMsg", pEnvPtr->pMsgPtr, pEnvPtr->msgLen); ++ if(pEnvPtr->DevCallBack != NULL) ++ { ++ pEnvPtr->DevCallBack(pEnvPtr); ++ /* We reuse the same envelope until the complete message has been received ? */ ++ // wscEnvelopeFree(pEnvPtr); ++ } ++ else if(pEnvPtr->callBack != NULL) ++ { ++ pEnvPtr->callBack(pEnvPtr->pMsgPtr, pEnvPtr->msgLen); ++ wscEnvelopeFree(pEnvPtr); ++ } ++ } ++ else ++ { ++ pthread_mutex_lock(&gActiveMsgQLock); ++ gActiveMsgQ[workQIdx].pEnvelope = NULL; ++ gActiveMsgQ[workQIdx].used = 0; ++ pthread_mutex_unlock(&gActiveMsgQLock); ++ ++ //Call handler ++ wscActiveMsgHandler(pEnvPtr); ++ ++ //After handle this message, remove it from ActiveMsgQ. ++ wscEnvelopeFree(pEnvPtr); ++ } ++ } ++ ++ return 0; ++} ++ ++ ++/******************************************************************************** ++ * WscMsgQVerifyTimeouts ++ * ++ * Description: ++ * Checks if the envelope in MsgQ(active and passive) was expired. ++ * If the envelope expires, this handle is removed from the list and trigger the ++ * corresponding handler handle it. ++ * ++ * Parameters: ++ * incr -- The increment to subtract from the timeouts each time the ++ * function is called. ++ * ++ ********************************************************************************/ ++void WscMsgQVerifyTimeouts(int incr) ++{ ++ int idx; ++ WscEnvelope *envelope = NULL; ++ ++ //First check the passive queue! ++ for(idx = 0; idx < WSCPASSIVEMSGQ_MAX_ENTRY; idx++) ++ { ++ if(gPassiveMsgQ[idx].used == 1 && ((envelope = gPassiveMsgQ[idx].pEnvelope) != NULL)) ++ { ++ envelope->timerCount -= incr; ++ if(envelope->timerCount <= 0) ++ { ++ DBGPRINTF(RT_DBG_INFO, "WscMsgQVerifyTimeouts(): PassiveQIdx(%d) timeout happened, eventID=0x%x!\n", ++ idx, envelope->envID); ++ if((envelope->callBack != NULL) || (envelope->DevCallBack != NULL)) ++ { ++ wscEnvelopeFree(envelope); ++ envelope = NULL; ++ } ++ else ++ { ++ envelope->flag = WSC_ENVELOPE_TIME_OUT; ++ } ++ gPassiveMsgQ[idx].used = 0; ++ gPassiveMsgQ[idx].pEnvelope = NULL; ++ } ++ } ++ } ++ ++ ++ // Check the Active Queue. ++ pthread_mutex_lock(&gActiveMsgQLock); ++ for(idx = 0; idx < WSCACTIVEMSGQ_MAX_ENTRY; idx++) ++ { ++ if((gActiveMsgQ[idx].used == 1) && ((envelope = gActiveMsgQ[idx].pEnvelope) != NULL)) ++ { ++ envelope->timerCount -= incr; ++ if(envelope->timerCount <= 0) ++ { ++ DBGPRINTF(RT_DBG_INFO, "WscMsgQVerifyTimeouts(): ActiveQIdx(%d) timeout happened!\n", idx); ++ wscEnvelopeFree(envelope); ++ envelope = NULL; ++ gActiveMsgQ[idx].used = 0; ++ gActiveMsgQ[idx].pEnvelope = NULL; ++ } ++ } ++ } ++ pthread_mutex_unlock(&gActiveMsgQLock); ++ ++} ++ ++static inline int WscMsgQRemoveAll(void) ++{ ++ // Just set all queueed envelope as expired! ++ WscMsgQVerifyTimeouts(DEF_WSC_ENVELOPE_TIME_OUT); ++ return 0; ++} ++ ++ ++int wscMsgSubSystemStop() ++{ ++ WscMsgQRemoveAll(); ++ pthread_mutex_destroy(&gActiveMsgQLock); ++ return 0; ++} ++ ++ ++int wscMsgSubSystemInit(void) ++{ ++ time_t nowTime; ++ ++ ++ // Initialize the Passive message Queue. ++ if ((time(&nowTime)) != ((time_t)-1)) ++ { ++ gPassiveMsgID = (uint32)nowTime; ++ memset(gPassiveMsgQ, 0, sizeof(WscU2KMsgQ)* WSCPASSIVEMSGQ_MAX_ENTRY); ++ DBGPRINTF(RT_DBG_INFO, "gPassiveMsgQ Init success! gPassiveMsgID=0x%x!\n", gPassiveMsgID); ++ } ++ ++ // Initialize the Active message Queue system. ++ if(pthread_mutex_init(&gActiveMsgQLock, NULL) != 0) ++ { ++ goto FailedActiveQ; ++ } else { ++ pthread_mutex_lock(&gActiveMsgQLock); ++ memset(gActiveMsgQ, 0, sizeof(WscU2KMsgQ)* WSCACTIVEMSGQ_MAX_ENTRY); ++ DBGPRINTF(RT_DBG_INFO, "gActiveMsgQ Init success!\n"); ++ pthread_mutex_unlock(&gActiveMsgQLock); ++ } ++ ++ return WSC_SYS_SUCCESS; ++FailedActiveQ: ++ pthread_mutex_destroy(&gActiveMsgQLock); ++Failed: ++ return WSC_SYS_ERROR; ++ ++} ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_msg.h +=================================================================== +--- /dev/null ++++ b/wsc/wsc_msg.h +@@ -0,0 +1,114 @@ ++#ifndef __WSC_MSG_H__ ++#define __WSC_MSG_H__ ++ ++#include "wsc_common.h" ++ ++#ifndef IN ++#define IN ++#endif ++ ++#ifndef OUT ++#define OUT ++#endif ++ ++#ifndef INOUT ++#define INOUT ++#endif ++ ++#define WSC_OPCODE_UPNP_MASK 0x10 ++#define WSC_OPCODE_UPNP_DATA 0x11 ++#define WSC_OPCODE_UPNP_MGMT 0x12 ++#define WSC_OPCODE_UPNP_CTRL 0x13 ++ ++#define WSC_UPNP_MGMT_SUB_PROBE_REQ 0x01 ++#define WSC_UPNP_MGMT_SUB_CONFIG_REQ 0x02 ++#define WSC_UPNP_MGMT_SUB_REG_SELECT 0x03 ++ ++//patch for Atheros External registrar ++#define WSC_UPNP_DATA_SUB_INCLUDE_MAC 0x0100 ++ ++#define WSC_UPNP_DATA_SUB_NORMAL 0x00 ++#define WSC_UPNP_DATA_SUB_TO_ALL 0x01 ++#define WSC_UPNP_DATA_SUB_TO_ONE 0x02 ++#define WSC_UPNP_DATA_SUB_ACK 0x03 ++#define WSC_UPNP_DATA_SUB_M1 0x04 ++#define WSC_UPNP_DATA_SUB_M2 0x05 ++#define WSC_UPNP_DATA_SUB_M2D 0x06 ++#define WSC_UPNP_DATA_SUB_M3 0x07 ++#define WSC_UPNP_DATA_SUB_M4 0x08 ++#define WSC_UPNP_DATA_SUB_M5 0x09 ++#define WSC_UPNP_DATA_SUB_M6 0x0A ++#define WSC_UPNP_DATA_SUB_M7 0x0B ++#define WSC_UPNP_DATA_SUB_M8 0x0C ++#define WSC_UPNP_DATA_SUB_WSC_ACK 0x0D ++#define WSC_UPNP_DATA_SUB_WSC_NACK 0x0E ++#define WSC_UPNP_DATA_SUB_WSC_DONE 0x0F ++#define WSC_UPNP_DATA_SUB_WSC_UNKNOWN 0xff ++ ++#define WSC_ENVELOPE_NONE 0x0 ++#define WSC_ENVELOPE_SUCCESS 0x1 ++#define WSC_ENVELOPE_MEM_FAILED 0x2 ++#define WSC_ENVELOPE_TIME_OUT 0x3 ++/* ++ This data structrue used for communication between UPnP threads and netlink thread. ++ The UPnP thread create a ++*/ ++#define Q_TYPE_ACTIVE 1 ++#define Q_TYPE_PASSIVE 2 ++ ++#define DEF_WSC_ENVELOPE_TIME_OUT 30 ++typedef int (*envCallBack)(char *msg, int msgLen); ++ ++/* for compile issue */ ++struct _WscEnvelope; ++ ++typedef int (*httpCallBack)(struct _WscEnvelope *pEnvelope); ++ ++typedef struct _WscEnvelope{ ++ uint32 envID; //envID = 0 was reserved for msg directly send from kernel space. other value means send by upnp daemon. ++ void *pMsgPtr; ++ int msgLen; ++ int actLen; ++ int flag; ++ int timerCount; ++ struct upnphttp * h; ++ httpCallBack DevCallBack; ++ envCallBack callBack; //Used for UPnP Control Point. ++}WscEnvelope; ++ ++typedef struct _WscU2KMsgQ{ ++ WscEnvelope *pEnvelope; ++ int used; ++}WscU2KMsgQ; ++ ++typedef int (*msgHandleCallback)(char *pMsgBuf, int msgLen); ++typedef struct wscMsgHandle{ ++ uint32 msgType; ++ msgHandleCallback handle; ++}WscMsgHandle; ++ ++int wscEnvelopeFree(IN WscEnvelope *envelope); ++ ++WscEnvelope *wscEnvelopeCreate(void); ++ ++int wscEnvelopeRemove( ++ IN WscEnvelope *envelope, ++ OUT int qIdx); ++ ++int wscMsgQInsert( ++ IN WscEnvelope *envelope, ++ OUT int *pQIdx); ++ ++int wscMsgQRemove( ++ IN int qType, ++ IN int qIdx); ++ ++int WscRTMPMsgHandler( ++ IN char *pBuf, ++ IN int len); ++ ++int wscMsgSubSystemStop(void); ++ ++int wscMsgSubSystemInit(void); ++ ++#endif //endif of "#ifndef __WSC_MSG_H__" +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_netlink.c +=================================================================== +--- /dev/null ++++ b/wsc/wsc_netlink.c +@@ -0,0 +1,229 @@ ++/* ++ function handler for linux netlink socket! ++ */ ++#include ++#include ++#include ++#include ++#include ++#include ++#include "wsc_common.h" ++#include "wsc_netlink.h" ++#include "wsc_msg.h" ++ ++int we_version_compiled = WIRELESS_EXT; ++/*static*/ int netlink_sock = -1; ++ ++static void wscEventHandler(char *data, int len) ++{ ++ struct iw_event iwe_buf, *iwe = &iwe_buf; ++ char *pos, *end, *custom; ++// char *buf; ++ ++ pos = data; ++ end = data + len; ++ ++ //wsc_hexdump("wscEventHandler", pos, len); ++ ++ while (pos + IW_EV_LCP_LEN <= end) ++ { ++ /* Event data may be unaligned, so make a local, aligned copy ++ * before processing. */ ++ memcpy(&iwe_buf, pos, IW_EV_LCP_LEN); ++ //DBGPRINTF(RT_DBG_INFO, "Wireless event: cmd=0x%x len=%d, we_version_compiled=%d!\n", iwe->cmd, iwe->len, we_version_compiled); ++ if (iwe->len <= IW_EV_LCP_LEN) ++ return; ++ ++ custom = pos + IW_EV_POINT_LEN; ++ if(iwe->cmd == IWEVCUSTOM) ++ { ++ if (we_version_compiled > 18) ++ { ++ /* WE-19 removed the pointer from struct iw_point */ ++ char *dpos = (char *) &iwe_buf.u.data.length; ++ int dlen = dpos - (char *) &iwe_buf; ++ memcpy(dpos, pos + IW_EV_LCP_LEN, sizeof(struct iw_event) - dlen); ++ } ++ else ++ { ++ memcpy(&iwe_buf, pos, sizeof(struct iw_event)); ++ } ++ //wsc_hexdump("After Stripped", custom, len - IW_EV_POINT_LEN); ++ ++ if (custom + iwe->u.data.length > end){ ++ DBGPRINTF(RT_DBG_ERROR, "custom(0x%x) + iwe->u.data.length(0x%x >end!\n", custom, iwe->u.data.length); ++ return; ++ } ++#if 0 ++ buf = malloc(iwe->u.data.length + 1); ++ if (buf == NULL) ++ return; ++ ++ memcpy(buf, custom, iwe->u.data.length); ++ buf[iwe->u.data.length] = '\0'; ++ DBGPRINTF(RT_DBG_INFO, "iwe->u.data.flags=0x%x!\n", iwe->u.data.flags); ++#endif ++ switch(iwe->u.data.flags) ++ { ++ case RT_ASSOC_EVENT_FLAG: ++ case RT_DISASSOC_EVENT_FLAG: ++ case RT_REQIE_EVENT_FLAG: ++ case RT_RESPIE_EVENT_FLAG: ++ case RT_ASSOCINFO_EVENT_FLAG: ++ case RT_PMKIDCAND_FLAG: ++ break; ++ default: ++ if(strncmp(custom, "RAWSCMSG", 8) == 0) ++ { ++ DBGPRINTF(RT_DBG_LOUD, "Recevive a RAWSCMSG segment\n"); ++ WscRTMPMsgHandler(custom, iwe->u.data.length); ++ } ++ break; ++ } ++// free(buf); ++ } ++ pos += iwe->len; ++ } ++ ++} ++ ++ ++static void wscNLEventRTMNewlinkHandle(struct nlmsghdr *nlmsgHdr, int len) ++{ ++ struct ifinfomsg *ifi; ++ int attrlen, nlmsg_len, rta_len; ++ struct rtattr * attr; ++ ++ DBGPRINTF(RT_DBG_LOUD, "%s", __FUNCTION__); ++ ++ if (len < sizeof(struct ifinfomsg)) ++ return; ++ ++ ifi = NLMSG_DATA(nlmsgHdr); ++ //wsc_hexdump("ifi: ", (char *)ifi, sizeof(struct ifinfomsg)); ++ ++ nlmsg_len = NLMSG_ALIGN(sizeof(struct ifinfomsg)); ++ ++ attrlen = nlmsgHdr->nlmsg_len - nlmsg_len; ++ DBGPRINTF(RT_DBG_LOUD, "attrlen=%d\n",attrlen); ++ if (attrlen < 0) ++ return; ++ ++ attr = (struct rtattr *) (((char *) ifi) + nlmsg_len); ++ //wsc_hexdump("rtattr: ", (char *)attr,sizeof(struct rtattr)); ++ rta_len = RTA_ALIGN(sizeof(struct rtattr)); ++ //wsc_hexdump("rtattr: ", (char *)attr, rta_len); ++ while (RTA_OK(attr, attrlen)) ++ { ++ if (attr->rta_type == IFLA_WIRELESS) ++ { ++ wscEventHandler(((char *) attr) + rta_len, attr->rta_len - rta_len); ++ } ++ attr = RTA_NEXT(attr, attrlen); ++ //wsc_hexdump("rta_type: ", (char *)attr,sizeof(struct rtattr)); ++ } ++} ++ ++void wscNLSockRecv(int sock) ++{ ++ char buf[2000];// 8192 ==> 2000 ++ int left; ++ struct sockaddr_nl from; ++ socklen_t fromlen; ++ struct nlmsghdr *nlmsgHdr; ++ ++ fromlen = sizeof(from); ++ left = recvfrom(sock, buf, sizeof(buf), MSG_DONTWAIT, (struct sockaddr *)&from, &fromlen); ++ ++ if (left < 0) ++ { ++ if (errno != EINTR && errno != EAGAIN) ++ perror("recvfrom(netlink)"); ++ return; ++ } ++ ++ nlmsgHdr = (struct nlmsghdr *)buf; ++ //wsc_hexdump("nlmsgHdr: ", (char *)nlmsgHdr, nlmsgHdr->nlmsg_len); ++ ++ while (left >= sizeof(*nlmsgHdr)) ++ { ++ int len, plen; ++ ++ len = nlmsgHdr->nlmsg_len; ++ plen = len - sizeof(*nlmsgHdr); ++ if (len > left || plen < 0) ++ { ++ DBGPRINTF(RT_DBG_LOUD, "Malformed netlink message: len=%d left=%d plen=%d", len, left, plen); ++ break; ++ } ++ ++ switch (nlmsgHdr->nlmsg_type) ++ { ++ case RTM_NEWLINK: ++ wscNLEventRTMNewlinkHandle(nlmsgHdr, plen); ++ break; ++ } ++ ++ len = NLMSG_ALIGN(len); ++ left -= len; ++ nlmsgHdr = (struct nlmsghdr *) ((char *) nlmsgHdr + len); ++ } ++ ++ if (left > 0) ++ { ++ DBGPRINTF(RT_DBG_INFO, "%d extra bytes in the end of netlink message", left); ++ } ++ ++} ++ ++ ++/****************************************************************************** ++ * wscK2UModuleInit ++ * ++ * Description: ++ * The Kernel space 2 user space msg subsystem entry point. ++ * In Linux system, we use netlink socket to receive the specific type msg ++ * send from wireless driver. ++ * This function mainly create a posix thread and recvive msg then dispatch ++ * to coressponding handler. ++ * ++ * Parameters: ++ * None ++ * ++ * Return: ++ * success: 1 ++ * fail : 0 ++ *****************************************************************************/ ++int wscK2UModuleInit(void) ++{ ++ int sock = -1; ++ struct sockaddr_nl local; ++ ++ //Create netlink socket ++ sock = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE); ++ if (sock < 0) ++ { ++ perror("socket(PF_NETLINK,SOCK_RAW,NETLINK_ROUTE)"); ++ return WSC_SYS_ERROR; ++ } ++ ++ memset(&local, 0, sizeof(local)); ++ local.nl_family = AF_NETLINK; ++ local.nl_groups = RTMGRP_LINK; ++ ++ if (bind(sock, (struct sockaddr *)&local, sizeof(local)) < 0) ++ { ++ perror("bind(netlink)"); ++ close(sock); ++ return WSC_SYS_ERROR; ++ } ++ ++ /* ++ start a netlink socket receiver handle thread ++ */ ++ DBGPRINTF(RT_DBG_INFO, "sock=%d!(0x%p)\n", sock, &sock); ++ netlink_sock = sock; ++ ++ return WSC_SYS_SUCCESS; ++} ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_netlink.h +=================================================================== +--- /dev/null ++++ b/wsc/wsc_netlink.h +@@ -0,0 +1,94 @@ ++/* ++ header file for wsc_netlink.c ++*/ ++ ++#ifndef __WSC_NETLINK_H__ ++#define __WSC_NETLINK_H__ ++ ++#include ++#include ++#include ++ ++#define NETLINK_ROUTE 0 ++#define RTMGRP_LINK 1 ++#ifndef RTM_BASE ++#define RTM_BASE 0x10 ++#endif ++ ++//extern int netlink_sock; ++ ++#if 0 //already defined in ++#define RTM_NEWLINK (RTM_BASE + 0) ++#define RTM_DELLINK (RTM_BASE + 1) ++ ++#define RTA_ALIGNTO 4 ++#define RTA_ALIGN(len) (((len) + RTA_ALIGNTO - 1) & ~(RTA_ALIGNTO - 1)) ++#define RTA_NEXT(rta,attrlen) \ ++ ((attrlen) -= RTA_ALIGN((rta)->rta_len), \ ++ (struct rtattr *) (((char *)(rta)) + RTA_ALIGN((rta)->rta_len))) ++ ++#define NLMSG_ALIGNTO 4 ++#define NLMSG_ALIGN(len) (((len) + NLMSG_ALIGNTO - 1) & ~(NLMSG_ALIGNTO - 1)) ++#define NLMSG_LENGTH(len) ((len) + NLMSG_ALIGN(sizeof(struct nlmsghdr))) ++#define NLMSG_DATA(nlh) ((void*) (((char*) nlh) + NLMSG_LENGTH(0))) ++#endif ++ ++#ifndef RTA_OK ++#define RTA_OK(rta,len) \ ++ ((len) > 0 && (rta)->rta_len >= sizeof(struct rtattr) && \ ++ (rta)->rta_len <= (len)) ++#endif ++ ++#if (WIRELESS_EXT < 15) ++/* ----------------------- WIRELESS EVENTS ----------------------- */ ++/* ++ * Wireless events are carried through the rtnetlink socket to user ++ * space. They are encapsulated in the IFLA_WIRELESS field of ++ * a RTM_NEWLINK message. ++ */ ++ ++/* ++ * A Wireless Event. Contains basically the same data as the ioctl... ++ */ ++struct iw_event ++{ ++ unsigned short len; /* Real lenght of this stuff */ ++ unsigned short cmd; /* Wireless IOCTL */ ++ union iwreq_data u; /* IOCTL fixed payload */ ++}; ++ ++/* Size of the Event prefix (including padding and alignement junk) */ ++#define IW_EV_LCP_LEN (sizeof(struct iw_event) - sizeof(union iwreq_data)) ++ ++/* Size of the various events */ ++#define IW_EV_CHAR_LEN (IW_EV_LCP_LEN + IFNAMSIZ) ++#define IW_EV_UINT_LEN (IW_EV_LCP_LEN + sizeof(__u32)) ++#define IW_EV_FREQ_LEN (IW_EV_LCP_LEN + sizeof(struct iw_freq)) ++#define IW_EV_POINT_LEN (IW_EV_LCP_LEN + sizeof(struct iw_point)) ++#define IW_EV_PARAM_LEN (IW_EV_LCP_LEN + sizeof(struct iw_param)) ++#define IW_EV_ADDR_LEN (IW_EV_LCP_LEN + sizeof(struct sockaddr)) ++#define IW_EV_QUAL_LEN (IW_EV_LCP_LEN + sizeof(struct iw_quality)) ++ ++/* Note : in the case of iw_point, the extra data will come at the ++ * end of the event */ ++ ++#endif /* _LINUX_WIRELESS_H */ ++ ++ ++#define IWEVCUSTOM 0x8C02 /* Driver specific ascii string */ ++#define IWEVFIRST 0x8C00 ++#define IW_EVENT_IDX(cmd) ((cmd) - IWEVFIRST) ++ ++/* iw_point events are special. First, the payload (extra data) come at ++ * the end of the event, so they are bigger than IW_EV_POINT_LEN. Second, ++ * we omit the pointer, so start at an offset. */ ++#define IW_EV_POINT_OFF (((char *) &(((struct iw_point *) NULL)->length)) - (char *) NULL) ++ ++//wpa_supplicant event flags. ++#define RT_ASSOC_EVENT_FLAG 0x0101 ++#define RT_DISASSOC_EVENT_FLAG 0x0102 ++#define RT_REQIE_EVENT_FLAG 0x0103 ++#define RT_RESPIE_EVENT_FLAG 0x0104 ++#define RT_ASSOCINFO_EVENT_FLAG 0x0105 ++#define RT_PMKIDCAND_FLAG 0x0106 ++#endif +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_upnp.h +=================================================================== +--- /dev/null ++++ b/wsc/wsc_upnp.h +@@ -0,0 +1,163 @@ ++/* ++ ++ ++*/ ++#ifndef __WSC_UPNP_H__ ++#define __WSC_UPNP_H__ ++ ++#ifdef __cplusplus ++extern "C" { ++#endif ++ ++#ifndef IN ++#define IN ++#endif ++ ++#ifndef OUT ++#define OUT ++#endif ++ ++#ifndef INOUT ++#define INOUT ++#endif ++ ++#define WSC_UPNP_DESC_URL_LEN 200 ++//peter : 0523 ++//extern char HostDescURL[WSC_UPNP_DESC_URL_LEN]; // Used to save the DescriptionURL of local host. ++extern unsigned int HostIPAddr; // Used to save the binded IP address of local host. ++/* ++ Wsc Event format and Service State variable names, values, and defaults. ++ WLANEvent: ++ This state variable event indicates that a WCN-NET Probe-Request or an 802.1X/WCN-NET ++ EAP frame was received on the 802.11 network. The proxy service issues the event. ++ APStatus: ++ This state variable event indicates that the AP has either had a configuration change ++ or that the AP has had too many failed authentications against its PIN/password and has ++ locked itself out of Enrollee mode. ++ STAStatus: ++ This state variable event indicates that the STA has either had a configuration change ++ or that the STA has had too many failed authentications against its PIN/password and ++ has locked itself out of Enrollee mode. ++*/ ++#define WSC_STATE_VAR_COUNT 3 ++#define WSC_STATE_VAR_MAXVARS WSC_STATE_VAR_COUNT ++// Max value length. TODO: shiang: shall we need this?? ++#define WSC_STATE_VAR_MAX_STR_LEN 1024 ++ ++#define WSC_EVENT_WLANEVENT 0 // Index of "WLANEvent" State variable// shiang ++#define WSC_EVENT_APSTATUS 1 // Index of "APStatus" State variable ++#define WSC_EVENT_STASTATUS 2 // Index of "STAStatus" State variable ++ ++ ++/***************************************************************************** ++ Wsc Control Point Related data structures. ++ *****************************************************************************/ ++#define NAME_SIZE 256 //refer to UPnP Library ++struct upnpService{ ++ char ServiceId[NAME_SIZE]; //Service identification ++ char ServiceType[NAME_SIZE]; //Service type. ++ char SCPDURL[NAME_SIZE]; //URL to service description ++ char EventURL[NAME_SIZE]; //URL for eventing ++ char ControlURL[NAME_SIZE]; //URL for control ++ char SID[NAME_SIZE]; //Subscribe Identifier ++ char *StateVarVal[WSC_STATE_VAR_COUNT]; ++ struct upnpService *next; //Pointer to next service. ++}; ++ ++/* ++ The following data structure used to save the UPnP Device which ++ support WSC. ++*/ ++ ++struct upnpDevice ++{ ++ char UDN[NAME_SIZE]; //uuid ++ char DescDocURL[NAME_SIZE]; //URL of the device description file ++ char FriendlyName[NAME_SIZE]; //short user-friendly title ++ char PresURL[NAME_SIZE]; //URL for presentation ++ int AdvrTimeOut; //Device Advertisement timeout ++ int timeCount; ++ unsigned int ipAddr; //IP address of this device ++ struct upnpService services; //Wsc Device Service related info ++}; ++ ++//typedef struct upnpDevice upnpDevice_t; ++ ++struct upnpDeviceNode { ++ struct upnpDevice device; ++ struct upnpDeviceNode *next; ++}; ++ ++ ++/* ++ The following data structure used to save the UPnP Contorl Point ++ which subscribe to us. ++*/ ++struct upnpCtrlPoint ++{ ++ char SubURL[NAME_SIZE]; //URL for subscription ++ char SID[NAME_SIZE]; //Subscription ID of the Control Point ++ int SubTimeOut; //Subscription time-out ++ unsigned int ipAddr; //IP address of this control point ++}; ++ ++struct upnpCPNode { ++ struct upnpCtrlPoint device; ++ struct upnpCPNode *next; ++}; ++ ++ ++/* Device type for wsc device */ ++#define WscDeviceTypeStr "urn:schemas-wifialliance-org:device:WFADevice:1" ++ ++/* Service type for wsc services */ ++#define WscServiceTypeStr "urn:schemas-wifialliance-org:service:WFAWLANConfig:1" ++ ++/* Service Id for wsc services */ ++#define WscServiceIDStr "urn:wifialliance-org:serviceId:WFAWLANConfig1" ++ ++typedef enum{ ++ ERR_UPNP_WSC_ACTION_ACT = 401, ++ ERR_UPNP_WSC_ACTION_ARG = 402, ++ ERR_UPNP_WSC_ACTION_VAR = 403, ++ ERR_UPNP_WSC_ACTION_FAILED = 501, ++}WSC_UPNP_ACTION_ERRCODE; ++ ++ ++int WscEventCtrlMsgRecv( ++ IN char *pBuf, ++ IN int bufLen); ++ ++int WscEventDataMsgRecv( ++ IN char *pBuf, ++ IN int bufLen); ++ ++int WscEventMgmtMsgRecv( ++ IN char *pBuf, ++ IN int bufLen); ++ ++int wscU2KMsgCreate( ++ INOUT char **dstPtr, ++ IN char *srcPtr, ++ IN int msgLen, ++ IN int EAPType); ++ ++ ++int WscUPnPDevStop(void); ++int WscUPnPDevStart( ++ IN char *ipAddr, ++ IN unsigned short port, ++ IN char *descDoc, ++ IN char *webRootDir); ++ ++ ++int WscUPnPCPStop(void); ++int WscUPnPCPStart( ++ IN char *ip_address, ++ IN unsigned short port); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_upnp_cp.c +=================================================================== +--- /dev/null ++++ b/wsc/wsc_upnp_cp.c +@@ -0,0 +1,1368 @@ ++/* ++ wsc UPnP Contorl Point routines ++ ++ ++*/ ++#include ++#include ++#include "sample_util.h" ++#include "wsc_common.h" ++#include "wsc_msg.h" ++#include "wsc_upnp.h" ++#include "wsc_ioctl.h" ++#include "upnp.h" ++#include "ixmlparser.h" ++ ++static UpnpClient_Handle WscCPHandle = -1; ++ ++/* Global arrays for storing variable names and counts for Wsc services */ ++static char *WscVarName[WSC_STATE_VAR_COUNT] = {"WLANEvent", "APStatus", "STAStatus"}; ++ ++/* Timeout to request during subscriptions */ ++#define DEF_SUBSCRIPTION_TIMEOUT 1801 ++ ++/* The first node in the global device list, or NULL if empty */ ++struct upnpDeviceNode *WscDeviceList = NULL; ++ ++ ++ ++int WscUPnPCPDeviceHandler( ++ IN Upnp_EventType EventType, ++ IN void *Event, ++ IN void *Cookie); ++ ++ ++/******************************************************************************** ++ * WscUPnPCPDumpList ++ * ++ * Description: ++ * Print the universal device names for each device in the Wsc device list ++ * ++ * Parameters: ++ * None ++ * ++ ********************************************************************************/ ++int WscUPnPCPDumpList(void) ++{ ++ struct upnpDeviceNode *nodePtr; ++ struct upnpDevice *dev; ++ struct upnpService *service; ++ int i = 0; ++ ++ printf("WscUPnPCPDumpList:\n"); ++ nodePtr = WscDeviceList; ++ while (nodePtr) ++ { ++ dev = &nodePtr->device; ++ service = &dev->services; ++ ++ printf("UPnPDevice No.%3d:\n", ++i); ++ printf("\tDevice:\n"); ++ printf("\t\tFriendlyName=%s!\n", dev->FriendlyName); ++ printf("\t\tDescDocURL=%s!\n", dev->DescDocURL); ++ printf("\t\tUDN=%s!\n", dev->UDN); ++ printf("\t\tPresURL=%s!\n", dev->PresURL); ++ printf("\t\tIP Address=0x%x!\n", dev->ipAddr); ++ printf("\t\tAdvrTimeOut=%d!\n", dev->AdvrTimeOut); ++ printf("\tService:\n"); ++ printf("\t\tservIdStr=%s!\n", service->ServiceId); ++ printf("\t\tservTypeStr=%s!\n", service->ServiceType); ++ printf("\t\tscpdURL=%s!\n", service->SCPDURL); ++ printf("\t\teventURL=%s!\n", service->EventURL); ++ printf("\t\tcontrolURL=%s!\n", service->ControlURL); ++ printf("\t\tsubscribeID=%s!\n", service->SID); ++ ++ nodePtr = nodePtr->next; ++ } ++ printf("\n"); ++ ++ return WSC_SYS_SUCCESS; ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPDeleteNode ++ * ++ * Description: ++ * Delete a device node from the Wsc device list. Note that this function is ++ * NOT thread safe, and should be called from another function that has already ++ * locked the Wsc device list. ++ * ++ * Parameters: ++ * node -- The device node ++ * ++ * Return: ++ * WSC_SYS_SUCCESS - if success ++ * WSC_SYS_ERROR - if failure ++ ********************************************************************************/ ++int WscUPnPCPDeleteNode( ++ IN struct upnpDeviceNode *node) ++{ ++ int rc, var; ++ ++ if (NULL == node) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "ERROR: WscUPnPCPDeleteNode: Node is empty\n"); ++ return WSC_SYS_ERROR; ++ } ++ ++ /* If we have a valid control SID, then unsubscribe */ ++ if (strcmp(node->device.services.SID, "") != 0) ++ { ++ rc = UpnpUnSubscribe(WscCPHandle, node->device.services.SID); ++ if (rc == 0) ++ DBGPRINTF(RT_DBG_INFO, "Unsubscribed from WscService EventURL with SID=%s\n", node->device.services.SID); ++ else ++ DBGPRINTF(RT_DBG_ERROR, "Error unsubscribing to WscService EventURL -- %d\n", rc); ++ } ++ ++ for (var = 0; var < WSC_STATE_VAR_COUNT; var++) ++ { ++ if (node->device.services.StateVarVal[var]) ++ free(node->device.services.StateVarVal[var]); ++ } ++ ++ //Notify New Device Added ++// WscCPDevUpdate(NULL, NULL, node->device.UDN, DEVICE_REMOVED); ++ free(node); ++ node = NULL; ++ ++ return WSC_SYS_SUCCESS; ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPRemoveDevice ++ * ++ * Description: ++ * Remove a device from the wsc device list. ++ * ++ * Parameters: ++ * UDN -- The Unique Device Name for the device to remove ++ * ++ * Return: ++ * Always success ++ ********************************************************************************/ ++int WscUPnPCPRemoveDevice(IN char *UDN) ++{ ++ struct upnpDeviceNode *devNodePtr, *prev; ++ ++ devNodePtr = WscDeviceList; ++ if (!devNodePtr) ++ { ++ DBGPRINTF(RT_DBG_INFO, "WARNING: WscUPnPCPRemoveDevice: Device list empty\n"); ++ } ++ else ++ { ++ if (strcmp(devNodePtr->device.UDN, UDN) == 0) ++ { ++ WscDeviceList = devNodePtr->next; ++ WscUPnPCPDeleteNode(devNodePtr); ++ } ++ else ++ { ++ prev = devNodePtr; ++ devNodePtr = devNodePtr->next; ++ ++ while (devNodePtr) ++ { ++ if (strcmp(devNodePtr->device.UDN, UDN) == 0) ++ { ++ prev->next = devNodePtr->next; ++ WscUPnPCPDeleteNode(devNodePtr); ++ break; ++ } ++ ++ prev = devNodePtr; ++ devNodePtr = devNodePtr->next; ++ } ++ } ++ } ++ ++ return WSC_SYS_SUCCESS; ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPRemoveAll ++ * ++ * Description: ++ * Remove all devices from the wsc device list. ++ * ++ * Parameters: ++ * void ++ * ++ * Return: ++ * Always success ++ ********************************************************************************/ ++int WscUPnPCPRemoveAll(void) ++{ ++ struct upnpDeviceNode *devNodePtr, *next; ++ ++ devNodePtr = WscDeviceList; ++ WscDeviceList = NULL; ++ ++ while(devNodePtr) ++ { ++ next = devNodePtr->next; ++ WscUPnPCPDeleteNode(devNodePtr); ++ devNodePtr = next; ++ } ++ ++ return WSC_SYS_SUCCESS; ++} ++ ++ ++int WscUPnPCPCheckService( ++ IN IXML_Document * DescDoc) ++{ ++ // TODO:Check if the SCPD description XML file has correct format ++ return 0; ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPAddDevice ++ * ++ * Description: ++ * Add a new Wsc device into the wsc device list or just update its advertisement ++ * expiration timeout if it alreay exists in the list. ++ * ++ * Parameters: ++ * deviceType -- The device type want to add to the Device List ++ * d_event -- The "Upnp_Discovery" data ++ * ++ * Return: ++ * WSC_SYS_SUCCESS - if success ++ * other value - if failure ++ ********************************************************************************/ ++int WscUPnPCPAddDevice( ++ IN char *deviceType, ++ IN struct Upnp_Discovery *d_event, ++ OUT unsigned int *outIPAddr) ++{ ++ IXML_Document *DescDoc = NULL, *scpdDescDoc = NULL; ++ char *deviceTypeStr = NULL, *friendlyName = NULL, *baseURL = NULL, *relURL = NULL, *UDN = NULL; ++ char presURL[200] = {0}; ++ char *serviceId = NULL, *SCPDURL = NULL, *eventURL = NULL, *controlURL = NULL; ++ Upnp_SID eventSID; ++ struct upnpDeviceNode *newDeviceNode, *devNodePtr; ++ int ret = WSC_SYS_ERROR; ++ int found = 0; ++ int TimeOut = DEF_SUBSCRIPTION_TIMEOUT; ++ unsigned int ipAddr = 0; ++ unsigned short port = 0; ++ ++ if(d_event->DestAddr != NULL) ++ { ++ ipAddr = (unsigned int)d_event->DestAddr->sin_addr.s_addr; ++ port = (unsigned short)d_event->DestAddr->sin_port; ++ *outIPAddr = ipAddr; ++ } ++ ++ printf("%s():outIPAddr=0x%x!\n", __FUNCTION__, *outIPAddr); ++ if( !(strcmp(&HostDescURL[0], &d_event->Location[0]))) ++ { ++// DBGPRINTF(RT_DBG_INFO, "%s():Adver from LocalDev, ignore it!\n", __FUNCTION__); ++ goto done; ++ } ++ ++ // Check if this device is already in the list ++ devNodePtr = WscDeviceList; ++ while (devNodePtr) ++ { ++ if((strcmp(devNodePtr->device.UDN, d_event->DeviceId) == 0) ++ && (strcmp(devNodePtr->device.DescDocURL, d_event->Location) == 0)) ++ { ++ found = 1; ++ break; ++ } ++ devNodePtr = devNodePtr->next; ++ } ++ ++ if (found) ++ { ++ // Update the advertisement timeout field ++// DBGPRINTF(RT_DBG_INFO, "Old device, just update the expires!\n"); ++ devNodePtr->device.AdvrTimeOut = d_event->Expires; ++ devNodePtr->device.timeCount = 0; ++ } else { ++ DBGPRINTF(RT_DBG_INFO, "Adver from a new device!\n"); ++ if((ret = UpnpDownloadXmlDoc(d_event->Location, &DescDoc)) != UPNP_E_SUCCESS){ ++ DBGPRINTF(RT_DBG_ERROR, "Get device description failed from %s -- err=%d\n", d_event->Location, ret); ++ goto done; ++ } ++ ++ /* Read key elements from description document */ ++ UDN = SampleUtil_GetFirstDocumentItem(DescDoc, "UDN"); ++ deviceTypeStr = SampleUtil_GetFirstDocumentItem(DescDoc, "deviceType"); ++ friendlyName = SampleUtil_GetFirstDocumentItem(DescDoc, "friendlyName"); ++ baseURL = SampleUtil_GetFirstDocumentItem(DescDoc, "URLBase"); ++ relURL = SampleUtil_GetFirstDocumentItem(DescDoc, "presentationURL"); ++ ++ if((UDN == NULL) || (deviceTypeStr == NULL) || (friendlyName == NULL)) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "%s(): Get UDN failed!\n", __FUNCTION__); ++ goto done; ++ } ++ UpnpResolveURL((baseURL ? baseURL : d_event->Location), relURL, presURL); ++ ++ if (SampleUtil_FindAndParseService(DescDoc, d_event->Location, WscServiceTypeStr, ++ &serviceId, &SCPDURL, &eventURL,&controlURL)) ++ { ++ if (SCPDURL != NULL) ++ { ++ if ((ret = UpnpDownloadXmlDoc(SCPDURL, &scpdDescDoc)) != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Get service description failed from %s -- err=%d\n", SCPDURL, ret); ++ } else { ++ WscUPnPCPCheckService(scpdDescDoc); ++ free(scpdDescDoc); ++ } ++ } ++ ++ if ((ret = UpnpSubscribe(WscCPHandle, eventURL, &TimeOut, eventSID)) != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error Subscribing to EventURL(%s) -- %d\n", eventURL, ret); ++ goto done; ++ } ++ ++ /* Create a new device node */ ++ newDeviceNode = (struct upnpDeviceNode *)malloc(sizeof(struct upnpDeviceNode)); ++ if (newDeviceNode == NULL) { ++ DBGPRINTF(RT_DBG_ERROR, "%s: create new wsc Device Node failed!\n", __FUNCTION__); ++ goto done; ++ } ++ memset(newDeviceNode, 0, sizeof(newDeviceNode)); ++ newDeviceNode->device.services.StateVarVal[WSC_EVENT_WLANEVENT] = NULL; ++ newDeviceNode->device.services.StateVarVal[WSC_EVENT_APSTATUS] = NULL; ++ newDeviceNode->device.services.StateVarVal[WSC_EVENT_STASTATUS] = NULL; ++ ++ strncpy(newDeviceNode->device.UDN, UDN, NAME_SIZE-1); ++ strncpy(newDeviceNode->device.DescDocURL, d_event->Location, NAME_SIZE-1); ++ strncpy(newDeviceNode->device.FriendlyName, friendlyName, NAME_SIZE-1); ++ strncpy(newDeviceNode->device.PresURL, presURL, NAME_SIZE-1); ++ newDeviceNode->device.AdvrTimeOut = d_event->Expires; ++ newDeviceNode->device.timeCount = 0; ++ newDeviceNode->device.ipAddr = ipAddr; ++ strncpy(newDeviceNode->device.services.ServiceType, WscServiceTypeStr, NAME_SIZE-1); ++ if (serviceId) ++ strncpy(newDeviceNode->device.services.ServiceId, serviceId, NAME_SIZE-1); ++ if (SCPDURL) ++ strncpy(newDeviceNode->device.services.SCPDURL, SCPDURL, NAME_SIZE-1); ++ if (eventURL) ++ strncpy(newDeviceNode->device.services.EventURL, eventURL, NAME_SIZE-1); ++ if (controlURL) ++ strncpy(newDeviceNode->device.services.ControlURL, controlURL, NAME_SIZE-1); ++ if (eventSID) ++ strncpy(newDeviceNode->device.services.SID, eventSID, NAME_SIZE-1); ++ ++ newDeviceNode->next = NULL; ++#if 0 ++ for (var = 0; var < WSC_STATE_VAR_COUNT; var++) ++ { ++ deviceNode->device.services.serviceList.stateVarVals[var] = (char *)malloc(WSC_STATE_VAR_MAX_STR_LEN); ++ strcpy(deviceNode->device.services.serviceList.stateVarVals[var], ""); ++ } ++#endif ++ // Insert the new device node in the list ++ if(WscDeviceList) ++ { ++ newDeviceNode->next = WscDeviceList->next; ++ WscDeviceList->next = newDeviceNode; ++ } else { ++ WscDeviceList = newDeviceNode; ++ } ++ ++ ret = WSC_SYS_SUCCESS; ++ ++ // TODO:Notify New Device Added ++ //WscCPDevUpdate(NULL, NULL, deviceNode->device.UDN, DEVICE_ADDED); ++ } else { ++ DBGPRINTF(RT_DBG_ERROR, "Error: Could not find Service: %s\n", WscServiceTypeStr); ++ } ++ } ++ ++done: ++ if (DescDoc) ++ ixmlDocument_free(DescDoc); ++ ++ if (UDN) ++ free(UDN); ++ if (deviceTypeStr) ++ free(deviceTypeStr); ++ if (friendlyName) ++ free(friendlyName); ++ if (baseURL) ++ free(baseURL); ++ if (relURL) ++ free(relURL); ++ ++ if (serviceId) ++ free(serviceId); ++ if (controlURL) ++ free(controlURL); ++ if (eventURL) ++ free(eventURL); ++ ++ return ret; ++} ++ ++ ++/******************************************************************************** ++ * WscStateVarUpdate ++ * ++ * Description: ++ * Update a Wsc state table. Called when an event is received. ++ * ++ * Parameters: ++ * devNode -- The Wsc Device which need to update the State Variables. ++ * ChangedStateVars -- DOM document representing the XML received with the event ++ * ++ * Note: ++ * This function is NOT thread save. It must be called from another function ++ * that has locked the global device list. ++ ********************************************************************************/ ++void WscStateVarUpdate( ++ IN struct upnpDeviceNode *devNode, ++ IN IXML_Document *stateDoc) ++{ ++ IXML_NodeList *properties, *stateVars; ++ IXML_Element *propItem, *varItem; ++ int propLen; ++ int i, j; ++ char *stateVal = NULL; ++ ++ ++ /* Find all of the e:property tags in the document */ ++ properties = ixmlDocument_getElementsByTagName(stateDoc, "e:property"); ++ if (properties != NULL) ++ { ++ propLen = ixmlNodeList_length(properties); ++ for (i = 0; i < propLen; i++) ++ { /* Loop through each property change found */ ++ propItem = (IXML_Element *)ixmlNodeList_item(properties, i); ++ ++ /* ++ For each stateVar name in the state table, check if this ++ is a corresponding property change ++ */ ++ for (j = 0; j < WSC_STATE_VAR_MAXVARS; j++) ++ { ++ stateVars = ixmlElement_getElementsByTagName(propItem, WscVarName[j]); ++ /* If found matched item, extract the value, and update the stateVar table */ ++ if (stateVars) ++ { ++ if (ixmlNodeList_length(stateVars)) ++ { ++ varItem = (IXML_Element *)ixmlNodeList_item(stateVars, 0); ++ stateVal = SampleUtil_GetElementValue(varItem); ++ if (stateVal) ++ { ++ if (devNode->device.services.StateVarVal[j] != NULL) ++ { ++ //DBGPRINTF(RT_DBG_INFO, "Free the OLD statVarVal!\n"); ++ // We didn't need do this, because the libupnp will free it. ++ //free(&devNode->device.services.StateVarVal[j]); ++ } ++ devNode->device.services.StateVarVal[j] = stateVal; ++ } ++ } ++ ++ ixmlNodeList_free(stateVars); ++ stateVars = NULL; ++ } ++ } ++ } ++ ++ ixmlNodeList_free(properties); ++ ++ } ++} ++ ++ ++void WscUPnPCPHandleGetVar( ++ IN char *controlURL, ++ IN char *varName, ++ IN DOMString varValue) ++{ ++ struct upnpDeviceNode *tmpdevnode; ++ ++ tmpdevnode = WscDeviceList; ++ while (tmpdevnode) ++ { ++ if(strcmp(tmpdevnode->device.services.ControlURL, controlURL) == 0) ++ { ++// SampleUtil_StateUpdate(varName, varValue, tmpdevnode->device.UDN, GET_VAR_COMPLETE); ++ break; ++ } ++ tmpdevnode = tmpdevnode->next; ++ } ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPGetDevice ++ * ++ * Description: ++ * Given a list number, returns the pointer to the device ++ * node at that position in the global device list. Note ++ * that this function is not thread safe. It must be called ++ * from a function that has locked the global device list. ++ * ++ * Parameters: ++ * devIPAddr -- The IP address of the device. ++ * devnode -- The output device node pointer. ++ * ++ ********************************************************************************/ ++int WscUPnPCPGetDevice( ++ IN uint32 devIPAddr, ++ IN struct upnpDeviceNode **devnode) ++{ ++ struct upnpDeviceNode *devPtr = NULL; ++ ++ devPtr = WscDeviceList; ++ ++ while (devPtr) ++ { ++ if (devPtr->device.ipAddr == devIPAddr) ++ break; ++ devPtr = devPtr->next; ++ } ++ ++ if (!devPtr) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Didn't find the UPnP Device with IP Address -- 0x%x\n", devIPAddr); ++ return WSC_SYS_ERROR; ++ } ++ ++ *devnode = devPtr; ++ ++ return WSC_SYS_SUCCESS; ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPSendAction ++ * ++ * Description: ++ * Send an Action request to the specified service of a device. ++ * ++ * Parameters: ++ * devnum -- The number of the device (order in the list, ++ * starting with 1) ++ * actionname -- The name of the action. ++ * param_name -- An array of parameter names ++ * param_val -- The corresponding parameter values ++ * param_count -- The number of parameters ++ * ++ ********************************************************************************/ ++int WscUPnPCPSendAction( ++ IN uint32 ipAddr, ++ IN char *actionname, ++ IN char **param_name, ++ IN char **param_val, ++ IN int param_count) ++{ ++ struct upnpDeviceNode *devnode; ++ IXML_Document *actionNode = NULL; ++ int rc = WSC_SYS_SUCCESS; ++ int param; ++ ++ rc = WscUPnPCPGetDevice(ipAddr, &devnode); ++ if (rc == WSC_SYS_SUCCESS) ++ { ++ if (param_count == 0) ++ { ++ actionNode = UpnpMakeAction(actionname, WscServiceTypeStr, 0, NULL); ++ } ++ else ++ { ++ for (param = 0; param < param_count; param++) ++ { ++ rc = UpnpAddToAction(actionNode, actionname, WscServiceTypeStr, ++ param_name[param], param_val[param]); ++ if (rc != UPNP_E_SUCCESS ) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "ERROR: WscUPnPCPSendAction: Trying to add action param, rc=%d!\n", rc); ++ //return -1; // TBD - BAD! leaves mutex locked ++ } ++ } ++ } ++ DBGPRINTF(RT_DBG_INFO, "ControlURL=%s!\n", devnode->device.services.ControlURL); ++ rc = UpnpSendActionAsync( WscCPHandle, devnode->device.services.ControlURL, ++ WscServiceTypeStr, NULL, actionNode, ++ WscUPnPCPDeviceHandler, NULL); ++ ++ if (rc != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error in UpnpSendActionAsync -- %d\n", rc); ++ rc = WSC_SYS_ERROR; ++ } ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_ERROR, "WscUPnPCPGetDevice failed!\n"); ++ } ++ ++ if (actionNode) ++ ixmlDocument_free(actionNode); ++ ++ return rc; ++} ++ ++ ++char *wscCPPutWLANResponseParam[]={"NewMessage", "NewWLANEventType", "NewWLANEventMAC"}; ++char *wscCPPutWLANResponseStr[3]={NULL, "2", "00:80:c8:34:c9:56"}; ++int wscCPPutWLANResponse(char *msg, int msgLen) ++{ ++ unsigned char *encodeStr = NULL; ++ RTMP_WSC_MSG_HDR *rtmpHdr = NULL; ++ int len; ++ ++ rtmpHdr = (RTMP_WSC_MSG_HDR *)msg; ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(TotalLen=%d, headerLen=%d)!\n", __FUNCTION__, msgLen, sizeof(RTMP_WSC_MSG_HDR)); ++ DBGPRINTF(RT_DBG_INFO, "\tMsgType=%d!\n", rtmpHdr->msgType); ++ DBGPRINTF(RT_DBG_INFO, "\tMsgSubType=%d!\n", rtmpHdr->msgSubType); ++ DBGPRINTF(RT_DBG_INFO, "\tipAddress=0x%x!\n", rtmpHdr->ipAddr); ++ DBGPRINTF(RT_DBG_INFO, "\tMsgLen=%d!\n", rtmpHdr->msgLen); ++ ++ if(rtmpHdr->msgType == WSC_OPCODE_UPNP_CTRL || rtmpHdr->msgType == WSC_OPCODE_UPNP_MGMT) ++ { ++ DBGPRINTF(RT_DBG_INFO, "Receive a UPnP Ctrl/Mgmt Msg!\n"); ++ return 0; ++ } ++ wsc_hexdump("wscCPPutWLANResponse-K2UMsg", msg, msgLen); ++ ++ len = ILibBase64Encode((unsigned char *)(msg + sizeof(RTMP_WSC_MSG_HDR)), rtmpHdr->msgLen, &encodeStr); ++ if (len >0 && encodeStr){ ++ wscCPPutWLANResponseStr[0] = (char *)encodeStr; ++ WscUPnPCPSendAction(rtmpHdr->ipAddr, "PutWLANResponse", wscCPPutWLANResponseParam, wscCPPutWLANResponseStr, 3); ++ free(encodeStr); ++ } ++ ++ return 0; ++} ++ ++ ++int wscCPPutMessage(char *msg, int msgLen) ++{ ++ unsigned char *encodeStr = NULL; ++ RTMP_WSC_MSG_HDR *rtmpHdr = NULL; ++ int len; ++ char *wscCPStateVarParam="NewInMessage"; ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(TotalLen=%d, headerLen=%d)!\n", __FUNCTION__, msgLen, sizeof(RTMP_WSC_MSG_HDR)); ++ rtmpHdr = (RTMP_WSC_MSG_HDR *)msg; ++ DBGPRINTF(RT_DBG_INFO, "\tMsgType=%d!\n", rtmpHdr->msgType); ++ DBGPRINTF(RT_DBG_INFO, "\tMsgSubType=%d!\n", rtmpHdr->msgSubType); ++ DBGPRINTF(RT_DBG_INFO, "\tipAddress=0x%x!\n", rtmpHdr->ipAddr); ++ DBGPRINTF(RT_DBG_INFO, "\tMsgLen=%d!\n", rtmpHdr->msgLen); ++ ++ if(rtmpHdr->msgType == WSC_OPCODE_UPNP_CTRL || rtmpHdr->msgType == WSC_OPCODE_UPNP_MGMT) ++ { ++ DBGPRINTF(RT_DBG_INFO, "Receive a UPnP Ctrl/Mgmt Msg!\n"); ++ return 0; ++ } ++ wsc_hexdump("wscCPPutMessage-K2UMsg", msg, msgLen); ++ ++ len = ILibBase64Encode((unsigned char *)(msg + sizeof(RTMP_WSC_MSG_HDR)), rtmpHdr->msgLen, &encodeStr); ++ if (len >0) ++ { ++ WscUPnPCPSendAction(rtmpHdr->ipAddr, "PutMessage", &wscCPStateVarParam, &encodeStr, 1); ++ free(encodeStr); ++ } ++ return 0; ++} ++ ++ ++ ++/******************************************************************************** ++ * WscUPnPCPSendAction ++ * ++ * Description: ++ * Send an Action request to the specified service of a device. ++ * ++ * Parameters: ++ * devnum -- The number of the device (order in the list, ++ * starting with 1) ++ * actionname -- The name of the action. ++ * param_name -- An array of parameter names ++ * param_val -- The corresponding parameter values ++ * param_count -- The number of parameters ++ * ++ ********************************************************************************/ ++#define CP_RESP_SUPPORT_LIST_NUM 2 ++ ++static char *stateVarNames[CP_RESP_SUPPORT_LIST_NUM]={"NewDeviceInfo", "NewOutMessage"}; ++static char *actionResNames[CP_RESP_SUPPORT_LIST_NUM]= {"u:GetDeviceInfoResponse", "u:PutMessageResponse"}; ++ ++int WscUPnPCPHandleActionResponse( ++ IN struct Upnp_Action_Complete *a_event) ++{ ++ IXML_NodeList *nodeList = NULL, *msgNodeList = NULL; ++ IXML_Node *element, *child = NULL; ++ char *varName = NULL; ++ struct upnpDeviceNode *nodePtr; ++ ++ char *inStr = NULL, *pWscU2KMsg = NULL; ++ unsigned char *decodeStr = NULL; ++ int i, decodeLen = 0, wscU2KMsgLen; ++ ++ unsigned int UPnPDevIP = 0; ++ ++ DBGPRINTF(RT_DBG_INFO, "ErrCode = %d, CtrlUrl=%s!\n", a_event->ErrCode, a_event->CtrlUrl); ++ ++ if(a_event->ActionResult == NULL || a_event->ErrCode != 0) ++ return 0; ++ ++ // Check if this device is already in the list ++ nodePtr = WscDeviceList; ++ while (nodePtr) ++ { ++ if(strcmp(nodePtr->device.services.ControlURL, a_event->CtrlUrl) == 0) ++ { ++ UPnPDevIP = nodePtr->device.ipAddr; ++ nodePtr->device.timeCount = nodePtr->device.AdvrTimeOut; ++ break; ++ } ++ nodePtr = nodePtr->next; ++ } ++ if (UPnPDevIP == 0) ++ goto done; ++ DBGPRINTF(RT_DBG_INFO, "Find the ActionResponse Device IP=%x\n", UPnPDevIP); ++ ++ ++ /* ++ We just support following ActionResponse from remote device. ++ */ ++ for (i=0; i < CP_RESP_SUPPORT_LIST_NUM; i++) ++ { ++ DBGPRINTF(RT_DBG_INFO, "check actionResNames[%d]=%s!\n", i, actionResNames[i]); ++ nodeList = ixmlDocument_getElementsByTagName(a_event->ActionResult, actionResNames[i]); ++ if(nodeList){ ++ varName = stateVarNames[i]; ++ break; ++ } ++ } ++ ++ if(nodeList == NULL) ++ { ++ DBGPRINTF(RT_DBG_INFO, "UnSupportted ActResponse!\n"); ++ goto done; ++ } ++ ++ if ((element = ixmlNodeList_item(nodeList, 0))) ++ { ++ //First check if we have supportted State Variable name! ++ ixmlNode_getElementsByTagName(element, varName, &msgNodeList); ++ if(msgNodeList != NULL) ++ { ++ DBGPRINTF(RT_DBG_INFO, "find stateVarName=%s!\n", varName); ++ while((child = ixmlNode_getFirstChild(element))!= NULL) ++ { // Find the Response text content! ++ if (ixmlNode_getNodeType(child) == eTEXT_NODE) ++ { ++ inStr = strdup(ixmlNode_getNodeValue(child)); ++ break; ++ } ++ element = child; ++ } ++ ixmlNodeList_free(msgNodeList); ++ } ++ } ++ ++ // Here depends on the ActionRequest and ActionResponse, dispatch to correct handler! ++ if(inStr!= NULL) ++ { ++ DBGPRINTF(RT_DBG_INFO, "Receive a %s Message!\n", actionResNames[i]); ++ DBGPRINTF(RT_DBG_INFO, "\tinStr=%s!\n", inStr); ++ decodeLen = ILibBase64Decode((unsigned char *)inStr, strlen(inStr), &decodeStr); ++ if((decodeLen > 0) && (ioctl_sock >= 0)) ++ { ++ RTMP_WSC_U2KMSG_HDR *msgHdr; ++ WscEnvelope *msgEnvelope; ++ int msgQIdx = -1; ++ ++ /* Prepare the msg buffers */ ++ wscU2KMsgLen = wscU2KMsgCreate(&pWscU2KMsg, (char *)decodeStr, decodeLen, EAP_FRAME_TYPE_WSC); ++ if (wscU2KMsgLen == 0) ++ goto done; ++ ++ /* Prepare the msg envelope */ ++ if ((msgEnvelope = wscEnvelopeCreate()) == NULL) ++ goto done; ++ msgEnvelope->callBack = wscCPPutMessage; ++ ++ /* Lock the msgQ and check if we can get a valid mailbox to insert our request! */ ++ if (wscMsgQInsert(msgEnvelope, &msgQIdx) != WSC_SYS_SUCCESS) ++ goto done; ++ ++ // Fill the session ID to the U2KMsg buffer header. ++ msgHdr = (RTMP_WSC_U2KMSG_HDR *)pWscU2KMsg; ++ msgHdr->envID = msgEnvelope->envID; ++ ++ // copy the Addr1 & Addr2 ++ memcpy(msgHdr->Addr1, HostMacAddr, MAC_ADDR_LEN); ++ memcpy(msgHdr->Addr2, &UPnPDevIP, sizeof(unsigned int)); ++ ++ // Now send the msg to kernel space. ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to send pWscU2KMsg(len=%d) to kernel by ioctl(%d)!\n", __FUNCTION__, wscU2KMsgLen, ioctl_sock); ++ wsc_hexdump("U2KMsg", pWscU2KMsg, wscU2KMsgLen); ++ ++ if(wsc_set_oid(RT_OID_WSC_EAPMSG, pWscU2KMsg, wscU2KMsgLen) != 0) ++ wscEnvelopeRemove(msgEnvelope, msgQIdx); ++ } ++ } ++ ++ ++done: ++ if (nodeList) ++ ixmlNodeList_free(nodeList); ++ if (inStr) ++ free(inStr); ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ if (decodeStr) ++ free(decodeStr); ++ ++ //wsc_printEvent(UPNP_CONTROL_ACTION_COMPLETE, (void *)a_event); ++ return 0; ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPHandleEvent ++ * ++ * Description: ++ * Handle a UPnP event that was received. Process the event and update ++ * the appropriate service state table. ++ * ++ * Parameters: ++ * sid -- The subscription id for the event ++ * eventkey -- The eventkey number for the event ++ * changes -- The DOM document representing the changes ++ * ++ * Return: ++ * None ++ ********************************************************************************/ ++void WscUPnPCPHandleEvent( ++ IN Upnp_SID sid, ++ IN int evntkey, ++ IN IXML_Document * changes) ++{ ++ struct upnpDeviceNode *devNode; ++ char *inStr = NULL, *pWscU2KMsg = NULL; ++ unsigned char *decodeStr = NULL; ++ int decodeLen, wscU2KMsgLen; ++ unsigned int UPnPDevIP = 0; ++ ++ devNode = WscDeviceList; ++ while (devNode) ++ { ++ if(strcmp(devNode->device.services.SID, sid) == 0) ++ { ++ devNode->device.timeCount = devNode->device.AdvrTimeOut; ++ UPnPDevIP = devNode->device.ipAddr; ++ ++ DBGPRINTF(RT_DBG_INFO, "Received WscService Event: %d for SID %s\n", evntkey, sid); ++ WscStateVarUpdate(devNode, changes); ++ ++ inStr = devNode->device.services.StateVarVal[WSC_EVENT_WLANEVENT]; ++ if (inStr) ++ { ++#define WSC_EVENT_WLANEVENT_MSG_LEN_MIN 18 // The first byte is the msg type, the next 17 bytes is the MAC address in xx:xx format ++ ++ DBGPRINTF(RT_DBG_INFO, "\tWLANEvent=%s!\n", devNode->device.services.StateVarVal[WSC_EVENT_WLANEVENT]); ++ decodeLen = ILibBase64Decode((unsigned char *)inStr, strlen(inStr), &decodeStr); ++ ++ if((decodeLen > WSC_EVENT_WLANEVENT_MSG_LEN_MIN) && (ioctl_sock >= 0)) ++ { ++ RTMP_WSC_U2KMSG_HDR *msgHdr; ++ WscEnvelope *msgEnvelope; ++ int msgQIdx = -1; ++ ++ ++ decodeLen -= WSC_EVENT_WLANEVENT_MSG_LEN_MIN; ++ ++ /* Prepare the msg buffers */ ++ wscU2KMsgLen = wscU2KMsgCreate(&pWscU2KMsg, (char *)(decodeStr + WSC_EVENT_WLANEVENT_MSG_LEN_MIN), ++ decodeLen, EAP_FRAME_TYPE_WSC); ++ if (wscU2KMsgLen == 0) ++ goto done; ++ ++ /* Prepare the msg envelope */ ++ if ((msgEnvelope = wscEnvelopeCreate()) == NULL) ++ goto done; ++ msgEnvelope->callBack = wscCPPutMessage; ++ ++ /* Lock the msgQ and check if we can get a valid mailbox to insert our request! */ ++ if (wscMsgQInsert(msgEnvelope, &msgQIdx) != WSC_SYS_SUCCESS) ++ goto done; ++ ++ // Fill the session ID to the U2KMsg buffer header. ++ msgHdr = (RTMP_WSC_U2KMSG_HDR *)pWscU2KMsg; ++ msgHdr->envID = msgEnvelope->envID; ++ ++ // copy the Addr1 & Addr2 ++ memcpy(msgHdr->Addr1, HostMacAddr, MAC_ADDR_LEN); ++ memcpy(msgHdr->Addr2, &UPnPDevIP, sizeof(unsigned int)); ++ ++ // Now send the msg to kernel space. ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to send pWscU2KMsg(len=%d) to kernel by ioctl(%d)!\n", __FUNCTION__, wscU2KMsgLen, ioctl_sock); ++ wsc_hexdump("U2KMsg", pWscU2KMsg, wscU2KMsgLen); ++ ++ if(wsc_set_oid(RT_OID_WSC_EAPMSG, pWscU2KMsg, wscU2KMsgLen) != 0) ++ wscEnvelopeRemove(msgEnvelope, msgQIdx); ++ } ++ } ++ if (devNode->device.services.StateVarVal[WSC_EVENT_APSTATUS] != NULL) ++ DBGPRINTF(RT_DBG_INFO, "\tAPStatus=%s!\n", devNode->device.services.StateVarVal[WSC_EVENT_APSTATUS]); ++ if (devNode->device.services.StateVarVal[WSC_EVENT_STASTATUS] != NULL) ++ DBGPRINTF(RT_DBG_INFO, "\tSTAStatus=%s!\n", devNode->device.services.StateVarVal[WSC_EVENT_STASTATUS]); ++ break; ++ } ++ devNode = devNode->next; ++ } ++ ++done: ++ ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPHandleSubscribeUpdate ++ * ++ * Description: ++ * Handle a UPnP subscription update that was received. Find the ++ * service the update belongs to, and update its subscription ++ * timeout. ++ * ++ * Parameters: ++ * eventURL -- The event URL for the subscription ++ * sid -- The subscription id for the subscription ++ * timeout -- The new timeout for the subscription ++ * ++ * Return: ++ * None ++ ********************************************************************************/ ++void WscUPnPCPHandleSubscribeUpdate( ++ IN char *eventURL, ++ IN Upnp_SID sid, ++ IN int timeout) ++{ ++ struct upnpDeviceNode *tmpdevnode; ++ ++ tmpdevnode = WscDeviceList; ++ while (tmpdevnode) ++ { ++ if( strcmp(tmpdevnode->device.services.EventURL, eventURL) == 0) ++ { ++ DBGPRINTF(RT_DBG_INFO, "Received WscService Event Renewal for eventURL %s\n", eventURL); ++ strcpy(tmpdevnode->device.services.SID, sid); ++ break; ++ } ++ ++ tmpdevnode = tmpdevnode->next; ++ } ++} ++ ++ ++ ++/******************************************************************************** ++ * WscUPnPCPDeviceHandler ++ * ++ * Description: ++ * The callback handler registered with the SDK while registering the Control Point. ++ * This callback funtion detects the type of callback, and passes the request on to ++ * the appropriate function. ++ * ++ * Parameters: ++ * EventType -- The type of callback event ++ * Event -- Data structure containing event data ++ * Cookie -- Optional data specified during callback registration ++ * ++ * Return: ++ * Always zero ++ ********************************************************************************/ ++int ++WscUPnPCPDeviceHandler( ++ IN Upnp_EventType EventType, ++ IN void *Event, ++ IN void *Cookie) ++{ ++ //wsc_PrintEvent( EventType, Event ); ++ ++ switch (EventType) ++ { ++ /* ++ SSDP Stuff ++ */ ++ case UPNP_DISCOVERY_ADVERTISEMENT_ALIVE: ++ case UPNP_DISCOVERY_SEARCH_RESULT: ++ { ++ struct Upnp_Discovery *d_event = (struct Upnp_Discovery *)Event; ++ unsigned int ipAddr = 0; ++ if (d_event->ErrCode != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error in Discovery Adv Callback -- %d\n", d_event->ErrCode); ++ } ++ else ++ { ++ if (strcmp(d_event->DeviceType, WscDeviceTypeStr) == 0) ++ { //We just need to take care about the WscDeviceTypeStr ++ DBGPRINTF(RT_DBG_INFO, "Receive a Advertisement from a WFADevice(URL=%s)\n", d_event->Location); ++ if (WscUPnPCPAddDevice(WscDeviceTypeStr, d_event, &ipAddr) == WSC_SYS_SUCCESS) ++ { ++ WscUPnPCPDumpList(); // Printing the Wsc Device List for debug ++ WscUPnPCPSendAction(ipAddr,"GetDeviceInfo", NULL, NULL, 0); ++ } ++ } ++ } ++ break; ++ } ++ ++ case UPNP_DISCOVERY_SEARCH_TIMEOUT: ++ // Nothing to do here.. ++ break; ++ ++ case UPNP_DISCOVERY_ADVERTISEMENT_BYEBYE: ++ { ++ struct Upnp_Discovery *d_event = (struct Upnp_Discovery *)Event; ++ ++ if (d_event->ErrCode != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error in Discovery ByeBye Callback -- %d\n", d_event->ErrCode); ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_INFO, "Received ByeBye for Device: %s\n", d_event->DeviceId); ++ WscUPnPCPRemoveDevice(d_event->DeviceId); ++ //Dump it for debug ++ WscUPnPCPDumpList(); ++ } ++ ++ break; ++ } ++ ++ /* ++ SOAP Stuff ++ */ ++ case UPNP_CONTROL_ACTION_COMPLETE: ++ { ++ struct Upnp_Action_Complete *a_event = (struct Upnp_Action_Complete *)Event; ++ ++ if (a_event->ErrCode != UPNP_E_SUCCESS) ++ DBGPRINTF(RT_DBG_ERROR, "Error in Action Complete Callback -- %d\n", a_event->ErrCode); ++ else ++ { ++ DBGPRINTF(RT_DBG_INFO, "Get event:UPNP_CONTROL_ACTION_COMPLETE!\n"); ++ WscUPnPCPHandleActionResponse(a_event); ++ } ++ break; ++ } ++ ++ case UPNP_CONTROL_GET_VAR_COMPLETE: ++ { ++ struct Upnp_State_Var_Complete *sv_event = (struct Upnp_State_Var_Complete *)Event; ++ ++ if (sv_event->ErrCode != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error in Get Var Complete Callback -- %d\n", sv_event->ErrCode); ++ } else { ++ WscUPnPCPHandleGetVar(sv_event->CtrlUrl, sv_event->StateVarName, sv_event->CurrentVal); ++ } ++ ++ break; ++ } ++ ++ /* ++ GENA Stuff ++ */ ++ case UPNP_EVENT_RECEIVED: ++ { ++ struct Upnp_Event *e_event = (struct Upnp_Event *)Event; ++ ++ DBGPRINTF(RT_DBG_INFO, "Get event:UPNP_EVENT_RECEIVED!\n"); ++ ++ WscUPnPCPHandleEvent(e_event->Sid, e_event->EventKey, e_event->ChangedVariables); ++ break; ++ } ++ ++ case UPNP_EVENT_SUBSCRIBE_COMPLETE: ++ case UPNP_EVENT_UNSUBSCRIBE_COMPLETE: ++ case UPNP_EVENT_RENEWAL_COMPLETE: ++ { ++ struct Upnp_Event_Subscribe *es_event = (struct Upnp_Event_Subscribe *)Event; ++ ++ if (es_event->ErrCode != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error in Event Subscribe Callback -- %d\n", es_event->ErrCode); ++ } else { ++ WscUPnPCPHandleSubscribeUpdate(es_event->PublisherUrl, es_event->Sid, es_event->TimeOut); ++ } ++ ++ break; ++ } ++ ++ case UPNP_EVENT_AUTORENEWAL_FAILED: ++ case UPNP_EVENT_SUBSCRIPTION_EXPIRED: ++ { ++ int TimeOut = DEF_SUBSCRIPTION_TIMEOUT; ++ Upnp_SID newSID; ++ int ret; ++ ++ struct Upnp_Event_Subscribe *es_event = (struct Upnp_Event_Subscribe *)Event; ++ ++ ret = UpnpSubscribe(WscCPHandle, es_event->PublisherUrl, &TimeOut, newSID); ++ ++ if (ret == UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_INFO, "Subscribed to EventURL with SID=%s\n", newSID); ++ WscUPnPCPHandleSubscribeUpdate(es_event->PublisherUrl, newSID, TimeOut); ++ } else { ++ DBGPRINTF(RT_DBG_ERROR, "Error Subscribing to EventURL -- %d\n", ret); ++ } ++ break; ++ } ++ ++ /* ++ Ignore these cases, since this is not a device ++ */ ++ case UPNP_EVENT_SUBSCRIPTION_REQUEST: ++ case UPNP_CONTROL_GET_VAR_REQUEST: ++ case UPNP_CONTROL_ACTION_REQUEST: ++ break; ++ } ++ ++ return 0; ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPGetVar ++ * ++ * Description: ++ * Send a GetVar request to the specified service of a device. ++ * ++ * Parameters: ++ * ipAddr -- The IP address of the device. ++ * varname -- The name of the variable to request. ++ * ++ * Return: ++ * UPNP_E_SUCCESS - if success ++ * WSC_SYS_ERROR - if failure ++ ********************************************************************************/ ++int ++WscUPnPCPGetVar( ++ IN uint32 ipAddr, ++ IN char *varname) ++{ ++ struct upnpDeviceNode *devnode; ++ int rc; ++ ++ rc = WscUPnPCPGetDevice(ipAddr, &devnode); ++ ++ if (rc == WSC_SYS_SUCCESS) ++ { ++ rc = UpnpGetServiceVarStatusAsync( WscCPHandle, devnode->device.services.ControlURL, ++ varname, WscUPnPCPDeviceHandler, NULL); ++ if( rc != UPNP_E_SUCCESS ) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error in UpnpGetServiceVarStatusAsync -- %d\n", rc); ++ rc = WSC_SYS_ERROR; ++ } ++ } ++ ++ return rc; ++} ++ ++ ++#if 0 ++int WscUPnPCPGetVarSampleCode( ++ IN int devnum) ++{ ++ return WscUPnPCPGetVar(devnum, "Power"); ++} ++#endif ++ ++ ++/******************************************************************************** ++ * WscUPnPCPVerifyTimeouts ++ * ++ * Description: ++ * Checks the advertisement each device in the global device list. ++ * If an advertisement expires, the device is removed from the list. ++ * If an advertisement is about to expire, a search request is sent ++ * for that device. ++ * ++ * Parameters: ++ * incr -- The increment to subtract from the timeouts each time the ++ * function is called. ++ * ++ * Return: ++ * None ++ ********************************************************************************/ ++void WscUPnPCPVerifyTimeouts(int incr) ++{ ++ struct upnpDeviceNode *prevdevnode, *curdevnode; ++ int ret, timeLeft; ++ ++ prevdevnode = NULL; ++ curdevnode = WscDeviceList; ++ ++ while (curdevnode) ++ { ++ curdevnode->device.timeCount += incr; ++ timeLeft = curdevnode->device.AdvrTimeOut - curdevnode->device.timeCount; ++ ++ if (timeLeft <= 0) ++ { ++ /* This advertisement has expired, so we should remove the device from the list */ ++ if (WscDeviceList == curdevnode) ++ WscDeviceList = curdevnode->next; ++ else ++ prevdevnode->next = curdevnode->next; ++ DBGPRINTF(RT_DBG_INFO, "%s(), delete the node(ipAddr=0x%08x)!\n", __FUNCTION__, curdevnode->device.ipAddr); ++ WscUPnPCPDeleteNode(curdevnode); ++ curdevnode = prevdevnode ? prevdevnode->next : WscDeviceList; ++ } else { ++ if (timeLeft < 3 * incr) ++ { ++ /* ++ This advertisement is about to expire, so send out a search request for this ++ device UDN to try to renew ++ */ ++ ret = UpnpSearchAsync(WscCPHandle, incr, curdevnode->device.UDN, NULL); ++ if (ret != UPNP_E_SUCCESS) ++ DBGPRINTF(RT_DBG_ERROR, "Err sending SearchReq for Device UDN: %s -- err = %d\n", curdevnode->device.UDN, ret); ++ } ++ ++ prevdevnode = curdevnode; ++ curdevnode = curdevnode->next; ++ } ++ ++ } ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPHouseKeep ++ * ++ * Description: ++ * Function that runs in its own thread and monitors advertisement ++ * and subscription timeouts for devices in the global device list. ++ * ++ * Parameters: ++ * None ++ * ++ * Return: ++ * UPNP_E_SUCCESS - if success ++ * WSC_SYS_ERROR - if failure ++ ********************************************************************************/ ++void *WscUPnPCPHouseKeep(void *args) ++{ ++ int incr = 30; // how often to verify the timeouts, in seconds ++ ++ while(1) ++ { ++ sleep(incr); ++ WscUPnPCPVerifyTimeouts(incr); ++ } ++} ++ ++ ++/******************************************************************************** ++ * WscUPnPCPRefresh ++ * ++ * Description: ++ * Clear the current wsc device list and issue new search ++ * requests to build it up again from scratch. ++ * ++ * Parameters: ++ * None ++ * ++ * Return: ++ * Always success ++ ********************************************************************************/ ++int WscUPnPCPRefresh(void) ++{ ++ int rc; ++ ++ WscUPnPCPRemoveAll(); ++ ++ /* ++ Search for all devices of type Wsc UPnP Device version 1, ++ waiting for up to 5 seconds for the response ++ */ ++ rc = UpnpSearchAsync(WscCPHandle, 5, WscDeviceTypeStr, NULL); ++ if (rc != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error sending search request%d\n", rc); ++ return WSC_SYS_ERROR; ++ } ++ ++ return WSC_SYS_SUCCESS; ++} ++ ++ ++/****************************************************************************** ++ * WscUPnPCPStop ++ * ++ * Description: ++ * Stop the UPnP Control Point, and remove all remote Device node. ++ * ++ * Parameters: ++ * void ++ * ++ * Return: ++ * Always success ++ *****************************************************************************/ ++int WscUPnPCPStop(void) ++{ ++ WscUPnPCPRemoveAll(); ++ UpnpUnRegisterClient(WscCPHandle); ++ ++ return WSC_SYS_SUCCESS; ++} ++ ++ ++/****************************************************************************** ++ * WscUPnPCPStart ++ * ++ * Description: ++ * Registers the UPnP Control Point, and sends out M-SEARCH. ++ * ++ * Parameters: ++ * ++ * char *ipAddr - ip address to initialize the Control Point Service. ++ * unsigned short port - port number to initialize the control Point Service. ++ * ++ * Return: ++ * success - WSC_SYS_SUCCESS ++ * failed - WSC_SYS_ERROR ++ *****************************************************************************/ ++int WscUPnPCPStart( ++ IN char *ipAddr, ++ IN unsigned short port) ++{ ++ int rc; ++ ++ DBGPRINTF(RT_DBG_INFO, "Registering Control Point...\n"); ++ rc = UpnpRegisterClient(WscUPnPCPDeviceHandler, &WscCPHandle, &WscCPHandle); ++ if (rc != UPNP_E_SUCCESS) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Error registering CP: %d\n", rc); ++ ++ return WSC_SYS_ERROR; ++ } ++ DBGPRINTF(RT_DBG_INFO, "Control Point Registered\n"); ++ ++ WscUPnPCPRefresh(); ++ ++ // start a timer thread ++ if(rc == 0) ++ ++ return WSC_SYS_SUCCESS; ++ ++} +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_upnp_cp.h +=================================================================== +--- /dev/null ++++ b/wsc/wsc_upnp_cp.h +@@ -0,0 +1,9 @@ ++/* ++ wsc upnp control point related structures ++ ++*/ ++#ifndef __WSC_UPNP_CP_H__ ++#define __WSC_UPNP_CP_H__ ++ ++ ++#endif +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_upnp_device.c +=================================================================== +--- /dev/null ++++ b/wsc/wsc_upnp_device.c +@@ -0,0 +1,2225 @@ ++/////////////////////////////////////////////////////////////////////////// ++// ++// Copyright (c) 2000-2003 Mediatek 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. ++// ++/////////////////////////////////////////////////////////////////////////// ++ ++#include ++#include ++#include ++#include ++#include ++#include "upnphttp.h" ++#include "upnpevents.h" ++#include "upnpglobalvars.h" ++#include "wsc_msg.h" ++#include "wsc_common.h" ++#include "wsc_ioctl.h" ++#include "wsc_upnp.h" ++#include "wsc_upnp_device.h" ++ ++#include "upnpreplyparse.h"/* for struct NameValueParserData */ ++ ++ ++//#include "sample_util.h" ++//#include "ThreadPool.h" ++//#include "service_table.h" ++//#include "upnpapi.h" ++//#include "ssdplib.h" ++ ++#if 0 //Mediatek : move to upnphttp.h ++#define DO_NOTHING_IN_MAIN_LOOP 3 ++#endif ++ ++#define UUID_STR_LEN 36 ++#define WSC_UPNP_UUID_STR_LEN (5 + UUID_STR_LEN + 1) // The UUID string get from the driver by ioctl and the strlen is 36 plus 1 '\0', ++ // and we need extra 5 bytes for prefix string "uuid:" ++ ++struct upnpCPNode *WscCPList = NULL; ++ ++int wscDevHandle = -1; // Device handle of "wscLocalDevice" supplied by UPnP SDK. ++ ++/* The amount of time (in seconds) before advertisements will expire */ ++int defAdvrExpires = 100; ++ ++ ++/* ++ Structure for storing Wsc Device Service identifiers and state table ++*/ ++#define WSC_ACTION_COUNTS 13 ++#define WSC_ACTION_MAXCOUNT WSC_ACTION_COUNTS ++ ++typedef int (*upnp_action) (IXML_Document *request, uint32 ipAddr, IXML_Document **out, char **errorString); ++ ++struct WscDevActionList { ++ char *actionNames[WSC_ACTION_COUNTS]; ++ upnp_action actionFuncs[WSC_ACTION_COUNTS]; ++}; ++ ++struct WscDevActionList wscDevActTable; ++ ++ ++//static char *wscStateVarName[] = {"WLANEvent", "APStatus", "STAStatus"}; ++static char wscStateVarCont[WSC_STATE_VAR_COUNT][WSC_STATE_VAR_MAX_STR_LEN]; ++ ++static char *wscStateVarDefVal[] = {"", "0", "0"}; ++ ++char wscAckMsg[]= {0x10, 0x4a, 0x00, 0x01, 0x10, 0x10, 0x22, 0x00, 0x01, 0x0d, 0x10, 0x1a, 0x00, 0x10, 0x00, 0x00, ++ 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x39, ++ 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, ++ 0x00, 0x00}; ++ ++ ++typedef enum _WSC_EVENT_STATUS_CODE{ ++ WSC_EVENT_STATUS_CONFIG_CHANGED = 0x00000001, ++ WSC_EVENT_STATUS_AUTH_THRESHOLD_REACHED = 0x00000010, ++}WSC_EVENT_STATUS_CODE; ++ ++typedef enum _WSC_EVENT_WLANEVENTTYPE_CODE{ ++ WSC_EVENT_WLANEVENTTYPE_PROBE = 1, ++ WSC_EVENT_WLANEVENTTYPE_EAP = 2, ++}WSC_EVENT_WLANEVENTTYPE_CODE; ++ ++ ++int senderID = 1; ++char CfgMacStr[18]={0}; ++ ++#ifdef ENABLE_WSC_SERVICE ++/************************************************************************ ++* 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 0 if successful else returns appropriate error ++***************************************************************************/ ++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 ) ++{ ++ int rc = 0; ++ int buffer_size = 2000; ++ ++ if( ActionName == NULL || ServType == NULL ) ++ { ++ return -1; ++ } ++ ++ *ActionDoc = malloc(buffer_size); ++ ++ if (*ActionDoc == NULL) ++ { ++ printf("malloc failed in addToAction()\n"); ++ return -1; ++ } ++ ++ memset(*ActionDoc, 0x00, buffer_size); ++ ++ if(response) ++ { ++ if (ArgName != NULL) ++ { ++ sprintf( *ActionDoc, ++ "<%s>%s", ++ ActionName, ServType, ArgName, ArgValue, ArgName, ActionName); ++ } ++ else ++ { ++ sprintf( *ActionDoc, ++ "", ++ ActionName, ServType, ActionName); ++ } ++ } ++ else ++ { ++ sprintf( *ActionDoc, "", ++ ActionName, ServType, ActionName ); ++ } ++ return rc; ++} ++ ++/************************************************************************ ++* Function : UpnpAddToActionResponse ++* ++* Parameters: ++* INOUT IXML_Document **ActionResponse: action response document ++* IN char * ActionName: Name of the action request or response ++* IN char * ServType: Service type ++* IN int ArgName :Name of argument to be added in the action response ++* IN char * ArgValue : value of the argument ++* ++* Description: ++* This function adds the argument in the action response. Its a wrapper ++* function that calls addToAction function to add the argument in the ++* action response. ++* ++* Returns: int ++* returns 0 if successful ++* else returns appropriate error ++***************************************************************************/ ++int ++UpnpAddToActionResponse( INOUT IXML_Document * ActionResponse, ++ IN const char *ActionName, ++ IN const char *ServType, ++ IN const char *ArgName, ++ IN const char *ArgValue ) ++{ ++ return addToAction( 1, ActionResponse, ActionName, ServType, ArgName, ++ ArgValue ); ++} ++ ++/************************************************************************ ++* Function : UpnpAddToAction ++* ++* Parameters: ++* INOUT IXML_Document **ActionDoc: action request document ++* IN char * ActionName: Name of the action request or response ++* IN char * ServType: Service type ++* IN int ArgName :Name of argument to be added in the action response ++* IN char * ArgValue : value of the argument ++* ++* Description: ++* This function adds the argument in the action request. Its a wrapper ++* function that calls addToAction function to add the argument in the ++* action request. ++* ++* Returns: int ++* returns 0 if successful ++* else returns appropriate error ++***************************************************************************/ ++int ++UpnpAddToAction( INOUT IXML_Document * ActionDoc, ++ const char *ActionName, ++ const char *ServType, ++ const char *ArgName, ++ const char *ArgValue ) ++{ ++ ++ return addToAction( 0, ActionDoc, ActionName, ServType, ArgName, ++ ArgValue ); ++} ++#endif /* ENABLE_WSC_SERVICE */ ++ ++ ++/****************************************************************************** ++ * wscU2KMsgCreate ++ * ++ * Description: ++ * Allocate the memory and copy the content to the buffer. ++ * ++ * Parameters: ++ * char **dstPtr - pointer used for refer the allocated U2Kmsg. ++ * char *srcPtr - the message need to copy into the U2KMsg. ++ * int msgLen - length of the message "srcPtr". ++ * int EAPType - the EAP message type. ++ * 1=Identity, 0xFE=reserved, used by WSC ++ * Return Value: ++ * Total length of created U2KMsg ++ * zero - if failure ++ * others - if success ++ *****************************************************************************/ ++int ++wscU2KMsgCreate( ++ INOUT char **dstPtr, ++ IN char *srcPtr, ++ IN int msgLen, ++ IN int EAPType) ++{ ++ int totalLen; ++ char *pPos = NULL, *pMsgPtr = NULL; ++ RTMP_WSC_U2KMSG_HDR *pU2KMsgHdr; ++ IEEE8021X_FRAME *p1xFrameHdr; ++ EAP_FRAME *pEAPFrameHdr; ++ ++ /* Allocate the msg buffer and fill the content */ ++ totalLen = sizeof(RTMP_WSC_U2KMSG_HDR) + msgLen; ++ if ((pMsgPtr = malloc(totalLen)) != NULL) ++ { ++ memset(pMsgPtr , 0, totalLen); ++ pU2KMsgHdr = (RTMP_WSC_U2KMSG_HDR *)pMsgPtr; ++ ++ // create the IEEE8021X_FRAME header ++ p1xFrameHdr = &pU2KMsgHdr->IEEE8021XHdr; ++ p1xFrameHdr->Version = IEEE8021X_FRAME_VERSION; ++ p1xFrameHdr->Length = htons(sizeof(EAP_FRAME) + msgLen); ++ p1xFrameHdr->Type = IEEE8021X_FRAME_TYPE_EAP; ++ ++ // create the EAP header ++ pEAPFrameHdr = &pU2KMsgHdr->EAPHdr; ++ pEAPFrameHdr->Code = EAP_FRAME_CODE_RESPONSE; ++ pEAPFrameHdr->Id = 1; // The Id field is useless here. ++ pEAPFrameHdr->Type = EAPType; ++ pEAPFrameHdr->Length = htons(sizeof(EAP_FRAME) + msgLen); ++ ++ //copy the msg payload ++ pPos = (char *)(pMsgPtr + sizeof(RTMP_WSC_U2KMSG_HDR)); ++ memcpy(pPos, srcPtr, msgLen); ++ *dstPtr = pMsgPtr; ++ DBGPRINTF(RT_DBG_INFO, "create U2KMsg success!MsgLen = %d, headerLen=%d! totalLen=%d!\n", msgLen, sizeof(RTMP_WSC_U2KMSG_HDR), totalLen); ++ } else { ++ DBGPRINTF(RT_DBG_INFO, "malloc allocation(size=%d) failed in wscU2KMsgCreate()!\n", totalLen); ++ totalLen = 0; ++ } ++ ++ return totalLen; ++} ++ ++ ++/*---------------------------action handler---------------------------*/ ++ ++/****************************************************************************** ++ * WscDevGetAPSettings ++ * ++ * Description: ++ * Wsc Service action callback used to get the AP's settings. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevGetAPSettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ IXML_Document * out, ++ OUT char **errorString ) ++{ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "GetAPSettings", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevGetSTASettings ++ * ++ * Description: ++ * Wsc Service action callback used to get the STA's settings. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevGetSTASettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "GetSTASettings", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++/****************************************************************************** ++ * WscDevSetAPSettings ++ * ++ * Description: ++ * Wsc Service action callback used to set the AP's settings. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevSetAPSettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "SetAPSettings", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevDelAPSettings ++ * ++ * Description: ++ * Wsc Service action callback used to delete the AP's settings. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevDelAPSettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "DelAPSettings", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevSetSTASettings ++ * ++ * Description: ++ * Wsc Service action callback used to set the STA's settings. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevSetSTASettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "SetSTASettings", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevRebootAP ++ * ++ * Description: ++ * Wsc Service action callback used to reboot the AP. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevRebootAP( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "RebootAP", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevResetAP ++ * ++ * Description: ++ * Wsc Service action callback used to reset the AP device to factory default config. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevResetAP( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "ResetAP", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++} ++ ++ ++/****************************************************************************** ++ * WscDevRebootSTA ++ * ++ * Description: ++ * Wsc Service action callback used to reboot the STA. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevRebootSTA( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "RebootSTA", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ (*out) = NULL; ++ (*errorString) = "Internal Error"; ++ ++ return -1; ++ } ++ ++ return 0; ++} ++ ++ ++/****************************************************************************** ++ * WscDevResetSTA ++ * ++ * Description: ++ * Wsc Service action callback used to reset the STA to factory default value. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int ++WscDevResetSTA( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ ++ // TODO: Need to complete it, currently do nothing and return directly. ++ ++ //create a response ++ if(UpnpAddToActionResponse(out, "ResetSTA", WscServiceTypeStr, NULL, NULL) != 0) ++ { ++ ( *out ) = NULL; ++ ( *errorString ) = "Internal Error"; ++ ++ return -1; ++ } ++ return 0; ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevSetSelectedRegistrar ++ * ++ * Description: ++ * This action callback used to receive a SetSelectedRegistar message send by ++ * contorl Point(Registrar). ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * others - if failure ++ *****************************************************************************/ ++int WscDevSetSelectedRegistrar( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ char *inStr = NULL; ++ unsigned char *decodeStr = NULL; ++ int decodeLen, retVal = -1; ++ int inStrLen=0; ++ ++ (*out) = NULL; ++ (*errorString) = NULL; ++ ++ inStr = WSCGetValueFromNameValueList((char *)(h->req_buf + h->req_contentoff), "NewMessage", &inStrLen); ++ ASSERT(inStrLen > 0); ++ if (!inStr) ++ { ++ (*errorString) = "Invalid SetSelectedRegistrar mesg parameter"; ++ SoapError(h, 402, "Invalid Args"); ++ return -1; ++ } ++ decodeLen = ILibBase64Decode((unsigned char *)inStr, inStrLen, &decodeStr); ++ if (decodeLen == 0 || decodeStr == NULL) ++ { ++ goto done; ++ } ++#ifdef RT_DEBUG ++ wsc_hexdump("WscDevSetSelectedRegistrar", (char *)decodeStr, decodeLen); ++#endif ++ /* Now send ioctl to wireless driver to set the ProbeReponse bit field. */ ++ if (ioctl_sock >= 0) ++ retVal = wsc_set_oid(RT_OID_WSC_SET_SELECTED_REGISTRAR, (char *)decodeStr, decodeLen); ++ ++ if (retVal != 0) ++ goto done; ++ ++ /* ++ Send UPnP repsone to remote UPnP device controller ++ */ ++ retVal = UpnpAddToActionResponse(out, "SetSelectedRegistrar", WscServiceTypeStr, NULL, NULL); ++ if (retVal != 0) ++ { ++ retVal = -1; ++ } ++ else ++ { ++ BuildSendAndCloseSoapResp(h, *out, strlen(*out)); ++ if (*out != NULL) ++ { ++ free(*out); ++ } ++ } ++done: ++ if (inStr) ++ { ++// free(inStr); ++ } ++ if (decodeStr) ++ free(decodeStr); ++ ++ if (retVal != 0) ++ (*errorString) = "Internal Error"; ++ ++ return 0; ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevPutWLANResponse ++ * ++ * Description: ++ * When Device in Proxy Mode, the Registrar will use this Action response ++ * the M2/M2D, M4, M6, and M8 messages. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - action request document ++ * IXML_Document **out - action result document ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * -1 - if failure ++ *****************************************************************************/ ++int ++WscDevPutWLANResponse( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ char *inStr = NULL; ++ unsigned char *decodeStr = NULL; ++ int decodeLen, retVal = -1; ++ ++ char *pWscU2KMsg = NULL; ++ RTMP_WSC_U2KMSG_HDR *msgHdr = NULL; ++ int wscU2KMsgLen; ++ int inStrLen=0; ++ ++ (*out) = NULL; ++ (*errorString) = NULL; ++ ++ inStr = WSCGetValueFromNameValueList((char *)(h->req_buf + h->req_contentoff), "NewMessage", &inStrLen); ++ ASSERT(inStrLen > 0); ++ if (!inStr) ++ { ++ (*errorString) = "Invalid PutWLANResponse mesg"; ++ SoapError(h, 402, "Invalid Args"); ++ return retVal; ++ } ++ decodeLen = ILibBase64Decode((unsigned char *)inStr, inStrLen, &decodeStr); ++ if (decodeLen == 0 || decodeStr == NULL) ++ { ++ goto done; ++ } ++ ++ /* Prepare the msg buffers */ ++ wscU2KMsgLen = wscU2KMsgCreate(&pWscU2KMsg, (char *)decodeStr, decodeLen, EAP_FRAME_TYPE_WSC); ++ if (wscU2KMsgLen == 0) ++ goto done; ++ ++ // Fill the sessionID, Addr1, and Adde2 to the U2KMsg buffer header. ++ msgHdr = (RTMP_WSC_U2KMSG_HDR *)pWscU2KMsg; ++ msgHdr->envID = 0; ++ ++ memcpy(msgHdr->Addr1, HostMacAddr, MAC_ADDR_LEN); ++ memcpy(msgHdr->Addr2, &ipAddr, sizeof(unsigned int)); ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to send pWscU2KMsg(len=%d) to kernel by ioctl(%d)!\n", __FUNCTION__, ++ wscU2KMsgLen, ioctl_sock); ++ ++ wsc_hexdump("U2KMsg", pWscU2KMsg, wscU2KMsgLen); ++ ++ // Now send the msg to kernel space. ++ if (ioctl_sock >= 0) ++ retVal = wsc_set_oid(RT_OID_WSC_EAPMSG, (char *)pWscU2KMsg, wscU2KMsgLen); ++ ++ // Waiting for the response from the kernel space. ++ DBGPRINTF(RT_DBG_INFO, "ioctl retval=%d! senderID=%d!\n", retVal, senderID); ++ if(retVal == 0) ++ { ++ retVal = UpnpAddToActionResponse(out, "PutWLANResponse", WscServiceTypeStr, NULL, NULL); ++ } ++ BuildSendAndCloseSoapResp(h, *out, strlen(*out)); ++ ++ if (*out != NULL) ++ { ++ free(*out); ++ } ++done: ++ ++ if (inStr) ++ { ++// free(inStr); ++ } ++ if (decodeStr) ++ free(decodeStr); ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ ++ if (retVal == 0) ++ return 0; ++ else { ++ (*errorString) = "Internal Error"; ++ return -1; ++ } ++} ++ ++ ++/****************************************************************************** ++ * WscDevPutMessageResp ++ * ++ * Description: ++ * This action used by Registrar send WSC_MSG(M2,M4,M6, M8) to Enrollee. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - document of action request ++ * IXML_Document **out - action result ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * -1 - if failure ++ *****************************************************************************/ ++int ++WscDevPutMessageResp( ++ IN WscEnvelope *msgEnvelope) ++{ ++ int retVal= -1; ++ char *pWscU2KMsg = NULL; ++ char *out = NULL; ++ struct upnphttp * h = msgEnvelope->h; ++ ++ ++ DBGPRINTF(RT_DBG_INFO, "Got msg from netlink! envID=0x%x!\n", msgEnvelope->envID); ++ ++#if 0 ++ ( out ) = malloc(2500); ++#endif ++ if ((msgEnvelope->flag != WSC_ENVELOPE_SUCCESS) || ++ (msgEnvelope->pMsgPtr == NULL) || ++ (msgEnvelope->msgLen == 0)) ++ { ++ goto done; ++ } ++ ++ // Response the msg from state machine back to the remote UPnP control device. ++ if (msgEnvelope->pMsgPtr) ++ { ++ unsigned char *encodeStr = NULL; ++ RTMP_WSC_MSG_HDR *rtmpHdr = NULL; ++ int len; ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(len=%d)!\n", __FUNCTION__, msgEnvelope->msgLen); ++ wsc_hexdump("WscDevPutMessage-K2UMsg", msgEnvelope->pMsgPtr, msgEnvelope->msgLen); ++ ++ rtmpHdr = (RTMP_WSC_MSG_HDR *)(msgEnvelope->pMsgPtr); ++ ++ if(rtmpHdr->msgType == WSC_OPCODE_UPNP_CTRL || rtmpHdr->msgType == WSC_OPCODE_UPNP_MGMT) ++ { ++ DBGPRINTF(RT_DBG_INFO, "Receive a UPnP Ctrl/Mgmt Msg!\n"); ++ goto done; ++ } ++ ++ if(rtmpHdr->msgSubType == WSC_UPNP_DATA_SUB_ACK) ++ { ++ retVal = UpnpAddToActionResponse(&out, "PutMessage", WscServiceTypeStr, NULL, NULL); ++ } ++ else ++ { ++ len = ILibBase64Encode((unsigned char *)(msgEnvelope->pMsgPtr + sizeof(RTMP_WSC_MSG_HDR)), ++ rtmpHdr->msgLen, &encodeStr); ++ if (len >0) ++ retVal = UpnpAddToActionResponse(&out, "PutMessage", WscServiceTypeStr, ++ "NewOutMessage", (char *)encodeStr); ++ if (encodeStr != NULL) ++ free(encodeStr); ++ } ++ ++ if (out) ++ BuildSendAndCloseSoapResp(h, out, strlen(out)); ++ } ++ ++done: ++ if (out != NULL) ++ { ++ free(out); ++ } ++ ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ wscEnvelopeFree(msgEnvelope); ++ if (retVal == 0) ++ { ++ return retVal; ++ } ++ else ++ { ++ return -1; ++ } ++} ++ ++ ++ ++/****************************************************************************** ++ * WscDevPutMessage ++ * ++ * Description: ++ * This action used by Registrar request WSC_MSG(M2,M4,M6, M8) from WIFI driver to Enrollee. ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - document of action request ++ * IXML_Document **out - action result ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * -1 - if failure ++ *****************************************************************************/ ++int ++WscDevPutMessage( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ char *inStr = NULL; ++ int inStrLen=0; ++ unsigned char *decodeStr = NULL; ++ int decodeLen, retVal = -1; ++ ++ char *pWscU2KMsg = NULL; ++ RTMP_WSC_U2KMSG_HDR *msgHdr = NULL; ++ WscEnvelope *msgEnvelope = NULL; ++ int wscU2KMsgLen; ++ int msgQIdx = -1; ++ ++ (*out) = NULL; ++ (*errorString) = NULL; ++ ++ inStr = WSCGetValueFromNameValueList((char *)(h->req_buf + h->req_contentoff), "NewInMessage", &inStrLen); ++ ASSERT(inStrLen > 0); ++ if (!inStr) ++ { ++ (*errorString) = "Invalid PutMessage mesg"; ++ SoapError(h, 402, "Invalid Args"); ++ return retVal; ++ } ++ decodeLen = ILibBase64Decode((unsigned char *)inStr, inStrLen, &decodeStr); ++ if (decodeLen == 0 || decodeStr == NULL) ++ { ++ goto done; ++ } ++ ++ /* Prepare the msg buffers */ ++ wscU2KMsgLen = wscU2KMsgCreate(&pWscU2KMsg, (char *)decodeStr, decodeLen, EAP_FRAME_TYPE_WSC); ++ if (wscU2KMsgLen == 0) ++ goto done; ++ ++ /* Prepare the msg envelope */ ++ if ((msgEnvelope = wscEnvelopeCreate()) == NULL) ++ goto done; ++ ++ /* Lock the msgQ and check if we can get a valid mailbox to insert our request! */ ++ if(wscMsgQInsert(msgEnvelope, &msgQIdx)!= WSC_SYS_SUCCESS) ++ { ++ goto done; ++ } ++ ++ /* log the socket ID and callback in the msgEnvelope */ ++ msgEnvelope->h = h; ++ msgEnvelope->DevCallBack = WscDevPutMessageResp; ++ ++ // Fill the sessionID, Addr1, and Adde2 to the U2KMsg buffer header. ++ msgHdr = (RTMP_WSC_U2KMSG_HDR *)pWscU2KMsg; ++ msgHdr->envID = msgEnvelope->envID; ++ memcpy(msgHdr->Addr1, HostMacAddr, MAC_ADDR_LEN); ++ memcpy(msgHdr->Addr2, &ipAddr, sizeof(unsigned int)); ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to send pWscU2KMsg(len=%d) to kernel by ioctl(%d)!\n", __FUNCTION__, ++ wscU2KMsgLen, ioctl_sock); ++ wsc_hexdump("U2KMsg", pWscU2KMsg, wscU2KMsgLen); ++ ++ // Now send the msg to kernel space. ++ if (ioctl_sock >= 0) ++ retVal = wsc_set_oid(RT_OID_WSC_EAPMSG, (char *)pWscU2KMsg, wscU2KMsgLen); ++ ++ if (retVal == 0) ++ { ++ /* let main loop do nothing about the current http exchange */ ++ ++ #if 1 //Mediatek : porting for miniupnpd 1.6 ++ h->state = DO_NOTHING_IN_MAIN_LOOP; ++ #else ++ h->state = 3; ++ #endif ++ ++ // Waiting for the response from the kernel space. ++ DBGPRINTF(RT_DBG_INFO, "%s():ioctl to kernel success, waiting for condition!\n", __FUNCTION__); ++ ++ if (inStr) ++// free(inStr);// I have no right to free this pointer, because the buffer is not alloc by me. ++ if (decodeStr) ++ free(decodeStr); ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ return retVal; ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_INFO, "%s():ioctl to kernel failed, retVal=%d, goto done!\n", __FUNCTION__, retVal); ++ wscMsgQRemove(Q_TYPE_PASSIVE, msgQIdx); ++ goto done; ++ } ++ ++done: ++ if (inStr) ++ { ++// free(inStr);// I have no right to free this pointer, because the buffer is not alloc by me. ++ } ++ if (decodeStr) ++ free(decodeStr); ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ ++ wscEnvelopeFree(msgEnvelope); ++ ++ if (retVal == 0) ++ { ++ return retVal; ++ } ++ else ++ { ++ (*errorString) = "Internal Error"; ++ return -1; ++ } ++} ++ ++ ++/****************************************************************************** ++ * WscDevGetDeviceInfoResp ++ * ++ * Description: ++ * This action callback used to send AP's M1 message to the Control Point(Registrar). ++ * ++ * Parameters: ++ * ++ * WscEnvelope *msgEnvelope - response from wifi driver of action request ++ * ++ * ++ * ++ * ++ * Return: ++ * 0 - if success ++ * -1 - if failure ++ *****************************************************************************/ ++int ++WscDevGetDeviceInfoResp( ++ IN WscEnvelope *msgEnvelope) ++{ ++ int retVal= -1; ++ char *pWscU2KMsg = NULL; ++ char *out = NULL; ++ struct upnphttp * h = msgEnvelope->h; ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Got msg from netlink! envID=0x%x, flag=%d!\n", ++ __FUNCTION__, msgEnvelope->envID, msgEnvelope->flag); ++ ++#if 0 ++ ( out ) = malloc(2500); ++#endif ++ ++ if ((msgEnvelope->flag != WSC_ENVELOPE_SUCCESS) || ++ (msgEnvelope->pMsgPtr == NULL) || ++ (msgEnvelope->msgLen == 0)) ++ { ++ goto done; ++ } ++ ++ // Response the msg from state machine back to the remote UPnP control device. ++ if (msgEnvelope->pMsgPtr) ++ { ++ unsigned char *encodeStr = NULL; ++ RTMP_WSC_MSG_HDR *rtmpHdr = NULL; ++ int len; ++ ++ rtmpHdr = (RTMP_WSC_MSG_HDR *)(msgEnvelope->pMsgPtr); ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(TotalLen=%d, headerLen=%d)!\n", __FUNCTION__, ++ msgEnvelope->msgLen, sizeof(RTMP_WSC_MSG_HDR)); ++ DBGPRINTF(RT_DBG_INFO, "\tMsgType=%d!\n" ++ "\tMsgSubType=%d!\n" ++ "\tipAddress=0x%x!\n" ++ "\tMsgLen=%d!\n", ++ rtmpHdr->msgType, rtmpHdr->msgSubType, rtmpHdr->ipAddr, rtmpHdr->msgLen); ++ ++ if(rtmpHdr->msgType == WSC_OPCODE_UPNP_CTRL || rtmpHdr->msgType == WSC_OPCODE_UPNP_MGMT) ++ { ++ DBGPRINTF(RT_DBG_INFO, "Receive a UPnP Ctrl/Mgmt Msg!\n"); ++ goto done; ++ } ++ wsc_hexdump("WscDevGetDeviceInfoResp-K2UMsg", msgEnvelope->pMsgPtr, msgEnvelope->msgLen); ++ ++ if(rtmpHdr->msgSubType == WSC_UPNP_DATA_SUB_ACK) ++ { ++ retVal = UpnpAddToActionResponse(&out, "GetDeviceInfo", WscServiceTypeStr, NULL, NULL); ++ } ++ else ++ { ++ len = ILibBase64Encode((unsigned char *)(msgEnvelope->pMsgPtr + sizeof(RTMP_WSC_MSG_HDR)), ++ rtmpHdr->msgLen, &encodeStr); ++ ++ if (len > 0) ++ { ++ retVal = UpnpAddToActionResponse(&out, "GetDeviceInfo", WscServiceTypeStr, ++ "NewDeviceInfo", (char *)encodeStr); ++ } ++ ++ if (encodeStr != NULL) ++ free(encodeStr); ++ } ++ ++ if (out) ++ BuildSendAndCloseSoapResp(h, out, strlen(out)); ++ } ++ ++done: ++ if (out != NULL) ++ { ++ free(out); ++ } ++ ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ ++ wscEnvelopeFree(msgEnvelope); ++ ++ if (retVal == 0) ++ { ++ return retVal; ++ } ++ else ++ { ++ return -1; ++ } ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevGetDeviceInfo ++ * ++ * Description: ++ * This action callback used to send AP's M1 message to the Control Point(Registrar). ++ * ++ * Parameters: ++ * ++ * IXML_Document * in - document of action request ++ * uint32 ipAddr - ipAddr, ++ * IXML_Document **out - action result ++ * char **errorString - errorString (in case action was unsuccessful) ++ * ++ * Return: ++ * 0 - if success ++ * -1 - if failure ++ *****************************************************************************/ ++int ++WscDevGetDeviceInfo( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString) ++{ ++ char UPnPIdentity[] = {"WFA-SimpleConfig-Registrar"}; ++ int retVal= -1; ++ char *pWscU2KMsg = NULL; ++ WscEnvelope *msgEnvelope = NULL; ++ RTMP_WSC_U2KMSG_HDR *msgHdr = NULL; ++ int wscU2KMsgLen; ++ int msgQIdx = -1; ++ ++ ++ DBGPRINTF(RT_DBG_INFO, "Receive a GetDeviceInfo msg from Remote Upnp Control Point!\n"); ++ ++#if 0 ++ ( out ) = NULL; ++#endif ++ ( *errorString ) = NULL; ++ ++ /* Prepare the msg buffers */ ++ wscU2KMsgLen = wscU2KMsgCreate(&pWscU2KMsg, UPnPIdentity, strlen(UPnPIdentity), EAP_FRAME_TYPE_IDENTITY); ++ if (wscU2KMsgLen == 0) ++ goto done; ++ ++ /* Prepare the msg envelope */ ++ if ((msgEnvelope = wscEnvelopeCreate()) == NULL) ++ goto done; ++ ++ /* Lock the msgQ and check if we can get a valid mailbox to insert our request! */ ++ if (wscMsgQInsert(msgEnvelope, &msgQIdx) != WSC_SYS_SUCCESS) ++ { ++ goto done; ++ } ++ ++ /* log the http info and callback at the msgEnvelope */ ++ msgEnvelope->h = h; ++ msgEnvelope->DevCallBack = WscDevGetDeviceInfoResp; ++ ++ // Fill the sessionID, Addr1, and Adde2 to the U2KMsg buffer header. ++ msgHdr = (RTMP_WSC_U2KMSG_HDR *)pWscU2KMsg; ++ msgHdr->envID = msgEnvelope->envID; ++ memcpy(msgHdr->Addr1, HostMacAddr, MAC_ADDR_LEN); ++ memcpy(msgHdr->Addr2, &ipAddr, sizeof(int)); ++ ++ // Now send the msg to kernel space. ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to send pWscU2KMsg(len=%d) to kernel by ioctl(%d)!\n", __FUNCTION__, ++ wscU2KMsgLen, ioctl_sock); ++ wsc_hexdump("U2KMsg", pWscU2KMsg, wscU2KMsgLen); ++ ++ if (ioctl_sock >= 0) ++ retVal = wsc_set_oid(RT_OID_WSC_EAPMSG, pWscU2KMsg, wscU2KMsgLen); ++ else ++ retVal = -1; ++ ++ if (retVal == 0) ++ { ++ /* let main loop do nothing about the current http exchange */ ++ h->state = DO_NOTHING_IN_MAIN_LOOP; ++ ++ // Waiting for the response from the kernel space. ++ DBGPRINTF(RT_DBG_INFO, "%s():ioctl to kernel success, waiting for response!\n", __FUNCTION__); ++ ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ return retVal; ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_ERROR, "%s():ioctl to kernel failed, retVal=%d, goto done!\n", __FUNCTION__, retVal); ++ wscMsgQRemove(Q_TYPE_PASSIVE, msgQIdx); ++ goto done; ++ } ++ ++ /* moved to WscDevGetDeviceInfoResp() */ ++ ++done: ++ if (pWscU2KMsg) ++ free(pWscU2KMsg); ++ ++ wscEnvelopeFree(msgEnvelope); ++ ++ if (retVal == 0) ++ return retVal; ++ else ++ { ++ (*errorString) = "Internal Error"; ++ return -1; ++ } ++} ++/*---------------------------end of action handler---------------------------*/ ++ ++ ++ ++/****************************************************************************** ++ * WscDevHandleActionReq ++ * ++ * Description: ++ * Called during an action request callback. If the request is for the ++ * Wsc device and match the ServiceID, then perform the action and respond. ++ * ++ * Parameters: ++ * ca_event -- The "Upnp_Action_Request" structure ++ * ++ * Return: ++ * ++ *****************************************************************************/ ++static int ++WscDevHandleActionReq(IN struct upnphttp * h) ++{ ++ return 0; ++} ++ ++ ++/****************************************************************************** ++ * WscDevCPNodeInsert ++ * ++ * Description: ++ * Depends on the UDN String, service identifier and Subscription ID, find ++ * the IP address of the remote Control Point. And insert the Control Point ++ * into the "WscCPList". ++ * ++ * NOTE: ++ * Since this function blocks on the mutex WscDevMutex, to avoid a hang this ++ * function should not be called within any other function that currently has ++ * this mutex locked. ++ * ++ * Besides, this function use the internal data structure of libupnp-1.3.1 ++ * SDK, so if you wanna change the libupnp to other versions, please make sure ++ * the data structure refered in this function was not changed! ++ * ++ * Parameters: ++ * UpnpDevice_Handle - UpnpDevice handle of WscLocalDevice assigned by UPnP SDK. ++ * char *UDN - The UUID string of the Subscription requested. ++ * char *servId - The service Identifier of the Subscription requested. ++ * char *sid - The Subscription ID of the ControlPoint. ++ * ++ * Return: ++ * TRUE - If success ++ * FALSE - If failure ++ *****************************************************************************/ ++static int ++WscDevCPNodeInsert( ++ IN int device_handle, ++ IN const char *sid) ++{ ++// struct Handle_Info *handle_info; ++ int found = 0; ++ struct upnpCPNode *CPNode, *newCPNode; ++ ++ HandleLock(); ++ ++ CPNode = WscCPList; ++ while(CPNode) ++ { ++ if (strcmp(CPNode->device.SID, sid) == 0) ++ { ++ found = 1; ++ break; ++ } ++ CPNode = CPNode->next; ++ } ++ ++ if (found) ++ { ++ strncpy(CPNode->device.SID, sid, NAME_SIZE); ++ } ++ else ++ { ++ // It's a new subscriber, insert it. ++ if ((newCPNode = malloc(sizeof(struct upnpCPNode))) != NULL) ++ { ++ memset(newCPNode, 0, sizeof(struct upnpCPNode)); ++ strncpy(newCPNode->device.SID, sid, NAME_SIZE); ++ newCPNode->next = NULL; ++ ++ if(WscCPList) ++ { ++ newCPNode->next = WscCPList->next; ++ WscCPList->next = newCPNode; ++ } ++ else ++ { ++ WscCPList = newCPNode; ++ } ++ } ++ else ++ { ++ goto Fail; ++ } ++ } ++ ++ HandleUnlock(); ++ DBGPRINTF(RT_DBG_INFO, "Insert ControlPoint success!\n"); ++ ++ return TRUE; ++ ++Fail: ++ ++ HandleUnlock(); ++ DBGPRINTF(RT_DBG_ERROR, "Insert ControlPoint failed!\n"); ++ return FALSE; ++} ++ ++ ++ ++/****************************************************************************** ++ * WscDevCPNodeSearch ++ * ++ * Description: ++ * Search for specific Control Point Node by ip address in WscCPList ++ * ++ * Parameters: ++ * unsigned int ipAddr - ip address of the contorl point we want to seach. ++ * char *sid - used to copy the SID string ++ * ++ * Return: ++ * 1 - if found ++ * 0 - if not found ++ *****************************************************************************/ ++static int ++WscDevCPNodeSearch( ++ IN unsigned int ipAddr, ++ OUT char **strSID) ++{ ++ struct upnpCPNode *CPNode; ++ int found = 0; ++ ++ ++ CPNode = WscCPList; ++ while (CPNode) ++ { ++ if(CPNode->device.ipAddr == ipAddr) ++ { ++ *strSID = strdup(CPNode->device.SID); ++ found = 1; ++ break; ++ } ++ CPNode = CPNode->next; ++ } ++ ++ return found; ++} ++ ++ ++/****************************************************************************** ++ * WscDevCPListRemoveAll ++ * ++ * Description: ++ * Remove all Control Point Node in WscCPList ++ * ++ * Parameters: ++ * None ++ * ++ * Return: ++ * TRUE ++ *****************************************************************************/ ++static int WscDevCPListRemoveAll(void) ++{ ++ struct upnpCPNode *CPNode; ++ ++ while((CPNode = WscCPList)) ++ { ++ WscCPList = CPNode->next; ++ free(CPNode); ++ } ++ ++ return TRUE; ++} ++ ++/****************************************************************************** ++ * WscDevCPNodeRemove ++ * ++ * Description: ++ * Remove the ControlPoint Node in WscCPList depends on the subscription ID. ++ * ++ * Parameters: ++ * char *SID - The subscription ID of the ControlPoint will be deleted ++ * ++ * Return: ++ * TRUE - If success ++ * FALSE - If failure ++ *****************************************************************************/ ++int WscDevCPNodeRemove(IN char *SID) ++{ ++ struct upnpCPNode *CPNode, *prevNode = NULL; ++ ++ CPNode = prevNode = WscCPList; ++ ++ if(strcmp(WscCPList->device.SID, SID) == 0) ++ { ++ WscCPList = WscCPList->next; ++ free(CPNode); ++ } ++ else ++ { ++ while((CPNode = CPNode->next)) ++ { ++ if(strcmp(CPNode->device.SID, SID) == 0) ++ { ++ prevNode->next = CPNode->next; ++ free(CPNode); ++ break; ++ } ++ prevNode = CPNode; ++ } ++ } ++ ++ return TRUE; ++} ++ ++ ++/****************************************************************************** ++ * dumpDevCPNodeList ++ * ++ * Description: ++ * Dump the WscCPList. Used for debug. ++ * ++ * Parameters: ++ * void ++ * ++ *****************************************************************************/ ++void dumpDevCPNodeList(void) ++{ ++ struct upnpCPNode *CPNode; ++ int i=0; ++ ++ printf("Dump The UPnP Subscribed ControlPoint:\n"); ++ ++ CPNode = WscCPList; ++ while(CPNode) ++ { ++ i++; ++ printf("ControlPoint Node[%d]:\n", i); ++ printf("\t ->sid=%s\n", CPNode->device.SID); ++ printf("\t ->SubURL=%s\n", CPNode->device.SubURL); ++ printf("\t ->ipAddr=0x%x!\n", CPNode->device.ipAddr); ++ printf("\t ->SubTimeOut=%d\n", CPNode->device.SubTimeOut); ++ CPNode = CPNode->next; ++ } ++ ++ printf("\n-----DumpFinished!\n"); ++ ++} ++ ++ ++/****************************************************************************** ++ * WscDevStateVarUpdate ++ * ++ * Description: ++ * Update the Wsc Device Service State variable, and notify all subscribed ++ * Control Points of the updated state. Note that since this function ++ * blocks on the mutex WscDevMutex, to avoid a hang this function should ++ * not be called within any other function that currently has this mutex ++ * locked. ++ * ++ * Parameters: ++ * variable -- The variable number (WSC_EVENT_WLANEVENT, WSC_EVENT_APSTATUS, ++ * WSC_EVENT_STASTATUS) ++ * value -- The string representation of the new value ++ * ++ *****************************************************************************/ ++static int ++WscDevStateVarUpdate( ++ IN unsigned int variable, ++ IN char *value, ++ IN char *SubsId) ++{ ++ struct subscriber* sub = NULL; ++ int sub_found = 0; ++ ++ if((variable >= WSC_STATE_VAR_MAXVARS) || (strlen(value) >= WSC_STATE_VAR_MAX_STR_LEN)) ++ return (0); ++ ++ strcpy(wscLocalDevice.services.StateVarVal[variable], value); ++ ++ if (SubsId == NULL) ++ { ++ upnp_event_var_change_notify(EWSC); ++ } ++ else ++ { ++ sub_found = WscDevSubscriberSearch(SubsId, &sub); ++ ++ if ((sub_found)/* && (sub->service == EWSC)*/) ++ { ++ if (sub != NULL) ++ { ++ if ((sub->service == EWSC) && (sub->notify == NULL)) ++ { ++ upnp_event_create_notify(sub); ++ } ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_ERROR, "\n%s() : ERROR!!! : sub = NULL!.\n", __FUNCTION__); ++ } ++ } ++ else if (!sub_found) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "\n%s() : ERROR!!! : The subscriber can not be found in subscriberlist., SubsId=%s\n", __FUNCTION__,SubsId); ++ if (sub) ++ { ++ DBGPRINTF(RT_DBG_ERROR, "\n%s() : ERROR!!! : The subscriber can not be found in subscriberlist., sub->service=%d, SubsId=%s\n", __FUNCTION__,sub->service,SubsId); ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_ERROR, "\n%s() : ERROR!!! : sub = NULL!. \n", __FUNCTION__); ++ } ++ } ++ } ++ ++ return (1); ++} ++ ++ ++/* ++ The format of UPnP WLANEvent message send to Remote Registrar. ++ WLANEvent: ++ =>This variable represents the concatenation of the WLANEventType, WLANEventMac and the ++ 802.11 WSC message received from the Enrollee & forwarded by the proxy over UPnP. ++ =>the format of this variable ++ ->represented as base64(WLANEventType || WLANEventMAC || Enrollee's message). ++ WLANEventType: ++ =>This variable represents the type of WLANEvent frame that was received by the proxy on ++ the 802.11 network. ++ =>the options for this variable ++ ->1: 802.11 WCN-NET Probe Frame ++ ->2: 802.11 WCN-NET 802.1X/EAP Frame ++ WLANEventMAC: ++ =>This variable represents the MAC address of the WLAN Enrollee that generated the 802.11 ++ frame that was received by the proxy. ++ =>Depends on the WFAWLANConfig:1 Service Template Version 1.01, the format is ++ ->"xx:xx:xx:xx:xx:xx", case-independent, 17 char ++*/ ++int WscEventCtrlMsgRecv( ++ IN char *pBuf, ++ IN int bufLen) ++{ ++ ++ DBGPRINTF(RT_DBG_INFO, "Receive a Control Message!\n"); ++ return 0; ++ ++} ++ ++ ++//receive a WSC message and send it to remote UPnP Contorl Point ++int WscEventDataMsgRecv( ++ IN char *pBuf, ++ IN int bufLen) ++{ ++ RTMP_WSC_MSG_HDR *pHdr = NULL; ++ unsigned char *encodeStr = NULL, *pWscMsg = NULL, *pUPnPMsg = NULL; ++ int encodeLen = 0, UPnPMsgLen = 0; ++ int retVal; ++ uint32 wscLen; ++ char *strSID = NULL; ++ unsigned char includeMAC = 0; ++ char curMacStr[18]; ++ ++ if ((WscUPnPOpMode & WSC_UPNP_OPMODE_DEV) == 0) ++ return -1; ++ ++ pHdr = (RTMP_WSC_MSG_HDR *)pBuf; ++ ++#if 0 //Mediatek : Sync with wscd, skip search control point by IP, and send the upnp data to all control points ++ // Find the SID. ++ if(WscDevCPNodeSearch(pHdr->ipAddr, &strSID) == 0) ++ { ++ DBGPRINTF(RT_DBG_INFO, "%s(): Didn't find the SID by ip(0x%x)!\n", __FUNCTION__, pHdr->ipAddr); ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_INFO, "%s(): The SID(%s) by ip(0x%x)!\n", __FUNCTION__, strSID, pHdr->ipAddr); ++ } ++#endif ++ DBGPRINTF(RT_DBG_INFO, "%s:Receive a Data event, msgSubType=%d!\n", __FUNCTION__, pHdr->msgSubType); ++ ++ memset(curMacStr, 0 , sizeof(curMacStr)); ++ if ((pHdr->msgSubType & WSC_UPNP_DATA_SUB_INCLUDE_MAC) == WSC_UPNP_DATA_SUB_INCLUDE_MAC) ++ { ++ if (pHdr->msgLen < 6){ ++ DBGPRINTF(RT_DBG_ERROR, "pHdr->msgSubType didn't have enoguh length!\n", pHdr->msgLen); ++ return -1; ++ } ++ includeMAC = 1; ++ pHdr->msgSubType &= 0x00ff; ++ pWscMsg = (unsigned char *)(pBuf + sizeof(RTMP_WSC_MSG_HDR)); ++ snprintf(curMacStr, 18, "%02x:%02x:%02x:%02x:%02x:%02x", pWscMsg[0], pWscMsg[1], pWscMsg[2], pWscMsg[3],pWscMsg[4],pWscMsg[5]); ++ } ++ else ++ { ++ memcpy(&curMacStr[0], CfgMacStr, 17); ++ } ++ ++ ++ if (pHdr->msgSubType == WSC_UPNP_DATA_SUB_NORMAL || ++ pHdr->msgSubType == WSC_UPNP_DATA_SUB_TO_ALL || ++ pHdr->msgSubType == WSC_UPNP_DATA_SUB_TO_ONE) ++ { ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(len=%d)!\n", __FUNCTION__, bufLen); ++ ++ pWscMsg = (unsigned char *)(pBuf + sizeof(RTMP_WSC_MSG_HDR)); ++ //Get the WscData Length ++ wscLen = pHdr->msgLen; ++ ++ if (includeMAC) ++ { ++ wscLen -= MAC_ADDR_LEN; ++ pWscMsg += MAC_ADDR_LEN; ++ } ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s): pWscMsg Len=%d!\n", __FUNCTION__, wscLen); ++ ++ ++ UPnPMsgLen = wscLen + 18; ++ pUPnPMsg = malloc(UPnPMsgLen); ++ if(pUPnPMsg) ++ { ++ memset(pUPnPMsg, 0, UPnPMsgLen); ++ pUPnPMsg[0] = WSC_EVENT_WLANEVENTTYPE_EAP; ++ memcpy(&pUPnPMsg[1], &curMacStr[0], 17); ++ ++ //Copy the WscMsg to pUPnPMsg buffer ++ memcpy(&pUPnPMsg[18], pWscMsg, wscLen); ++ wsc_hexdump("UPnP WLANEVENT Msg", (char *)pUPnPMsg, UPnPMsgLen); ++ ++ //encode the message use base64 ++ encodeLen = ILibBase64Encode(pUPnPMsg, UPnPMsgLen, &encodeStr); ++ ++ //Send event out ++ if (encodeLen > 0){ ++ DBGPRINTF(RT_DBG_INFO, "EAP->Msg=%s!\n", encodeStr); ++ retVal = WscDevStateVarUpdate(WSC_EVENT_WLANEVENT, (char *)encodeStr, strSID); ++ } ++ if (encodeStr != NULL) ++ free(encodeStr); ++ free(pUPnPMsg); ++ } ++ } ++ ++ if (strSID) ++ free(strSID); ++ ++ return 0; ++ ++} ++ ++ ++/* ++ Format of iwcustom msg WSC RegistrarSelected message: ++ 1. The Registrar ID which send M2 to the Enrollee(4 bytes): ++ ++ 4 ++ +-----------+ ++ |RegistrarID| ++*/ ++static int WscEventMgmt_RegSelect( ++ IN char *pBuf, ++ IN int bufLen) ++{ ++ char *pWscMsg = NULL; ++ int registrarID = 0; ++ ++ if ((WscUPnPOpMode & WSC_UPNP_OPMODE_DEV) == 0) ++ return -1; ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(len=%d)!\n", __FUNCTION__, bufLen); ++ wsc_hexdump("WscEventMgmt_RegSelect-K2UMsg", pBuf, bufLen); ++ ++ pWscMsg = (char *)(pBuf + sizeof(RTMP_WSC_MSG_HDR)); ++ ++ registrarID = *((int *)pWscMsg); ++ DBGPRINTF(RT_DBG_INFO, "The registrarID=%d!\n", registrarID); ++ ++ return 0; ++ ++} ++ ++/* ++ Format of iwcustom msg WSC clientJoin message: ++ 1. SSID which station want to probe(32 bytes): ++ ++ *If the length if SSID string is small than 32 bytes, fill 0x0 for remaining bytes. ++ 2. Station MAC address(6 bytes): ++ 3. Status: ++ Value 1 means change APStatus as 1. ++ Value 2 means change STAStatus as 1. ++ Value 3 means trigger msg. ++ ++ 32 6 1 ++ +----------+--------+------+ ++ |SSIDString| SrcMAC |Status| ++*/ ++static int WscEventMgmt_ConfigReq( ++ IN char *pBuf, ++ IN int bufLen) ++{ ++ unsigned char *encodeStr = NULL, *pWscMsg = NULL, *pUPnPMsg = NULL; ++ int encodeLen = 0, UPnPMsgLen = 0; ++ int retVal; ++ unsigned char Status; ++ char triggerMac[18]; ++ ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(len=%d)!\n", __FUNCTION__, bufLen); ++ wsc_hexdump("WscEventMgmt_ConfigReq-K2UMsg", pBuf, bufLen); ++ ++ pWscMsg = (unsigned char *)(pBuf + sizeof(RTMP_WSC_MSG_HDR)); ++ ++ memset(&triggerMac[0], 0, 18); ++ memcpy(&triggerMac[0], pWscMsg, 18); ++ //Skip the SSID field ++ pWscMsg += 32; ++ ++#if 0 ++ // Get the SrcMAC and copy to the WLANEVENTMAC, in format "xx:xx:xx:xx:xx:xx", case-independent, 17 char. ++ memset(CfgMacStr, 0 , sizeof(CfgMacStr)); ++ snprintf(CfgMacStr, 18, "%02x:%02x:%02x:%02x:%02x:%02x", pWscMsg[0], pWscMsg[1], pWscMsg[2], ++ pWscMsg[3],pWscMsg[4],pWscMsg[5]); ++#endif ++ //Skip the SrcMAC field ++ pWscMsg += 6; ++ ++ //Change APStatus and STAStatus ++ Status = *(pWscMsg); ++ DBGPRINTF(RT_DBG_INFO, "(%s): Status =%d!\n", __FUNCTION__, Status); ++ ++ if ((WscUPnPOpMode & WSC_UPNP_OPMODE_DEV) && (strlen(triggerMac) == 0)) ++ { ++ strcpy(wscLocalDevice.services.StateVarVal[WSC_EVENT_APSTATUS], "0"); ++ strcpy(wscLocalDevice.services.StateVarVal[WSC_EVENT_STASTATUS], "0"); ++ ++ /* not needed right now */ ++#if 0 ++ if(Status == 3) ++ { ++ /* This "ConfigReq" is the trigger msg, we should send BYEBYE to all external registrar for ++ reset the cache status of those Vista devices. Then re-send Notify out. ++ */ ++ retVal = AdvertiseAndReply(-1, wscDevHandle, 0, (struct sockaddr_in *)NULL,(char *)NULL, ++ (char *)NULL, (char *)NULL, defAdvrExpires); ++ retVal = AdvertiseAndReply(1, wscDevHandle, 0, (struct sockaddr_in *)NULL,(char *)NULL, ++ (char *)NULL, (char *)NULL, defAdvrExpires); ++ } ++#endif ++ //Prepare the message. ++ UPnPMsgLen = 18 + sizeof(wscAckMsg); ++ pUPnPMsg = malloc(UPnPMsgLen); ++ ++ if(pUPnPMsg) ++ { ++ memset(pUPnPMsg, 0, UPnPMsgLen); ++ pUPnPMsg[0] = WSC_EVENT_WLANEVENTTYPE_EAP; ++ memcpy(&pUPnPMsg[1], CfgMacStr, 17); ++ ++ //jump to the WscProbeReqData and copy to pUPnPMsg buffer ++ pWscMsg++; ++ memcpy(&pUPnPMsg[18], wscAckMsg, sizeof(wscAckMsg)); ++ wsc_hexdump("UPnP WLANEVENT Msg", (char *)pUPnPMsg, UPnPMsgLen); ++ ++ //encode the message use base64 ++ encodeLen = ILibBase64Encode(pUPnPMsg, UPnPMsgLen, &encodeStr); ++ if(encodeLen > 0) ++ DBGPRINTF(RT_DBG_INFO, "ConfigReq->Msg=%s!\n", encodeStr); ++ strcpy(wscLocalDevice.services.StateVarVal[WSC_EVENT_WLANEVENT], (const char *)encodeStr); ++ ++ //Send event out ++ if (encodeLen > 0) ++ retVal = WscDevStateVarUpdate(WSC_EVENT_WLANEVENT, (char *)encodeStr, NULL); ++ ++ if (encodeStr != NULL) ++ free(encodeStr); ++ free(pUPnPMsg); ++ } ++ } ++ ++ if ((WscUPnPOpMode & WSC_UPNP_OPMODE_CP) && (strlen(triggerMac) > 0)) ++ { ++ ++ } ++ ++ DBGPRINTF(RT_DBG_INFO, "<-----End(%s)\n", __FUNCTION__); ++ return 0; ++} ++ ++/* ++ Format of iwcustom msg WSC ProbeReq message: ++ 1. SSID which station want to probe(32 bytes): ++ ++ *If the length if SSID string is small than 32 bytes, fill 0x0 for remaining bytes. ++ 2. Station MAC address(6 bytes): ++ 3. element ID(OID)(1 byte): ++ val=0xDD for eID ++ val=other values, high byte of length fields. ++ 4. Length of "WscProbeReqData" in the probeReq packet(1 byte): ++ 5. "WscProbeReqData" info in ProbeReq: ++ ++ 32 6 1 1 variable length ++ +----------+--------+---+-----------------+----------------------+ ++ |SSIDString| SrcMAC |eID|LenOfWscProbeData| WscProbeReqData | ++ ++*/ ++static int WscEventMgmt_ProbreReq( ++ IN char *pBuf, ++ IN int bufLen) ++{ ++ unsigned char *encodeStr = NULL, *pWscMsg = NULL, *pUPnPMsg = NULL; ++ char srcMacStr[18]; ++ int encodeLen = 0, UPnPMsgLen = 0; ++ int retVal; ++ unsigned short wscLen; ++ ++ if ((WscUPnPOpMode & WSC_UPNP_OPMODE_DEV) == 0) ++ return -1; ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s):Ready to parse the K2U msg(len=%d)!\n", __FUNCTION__, bufLen); ++ wsc_hexdump("WscMgmtEvent_ProbreReq-K2UMsg", pBuf, bufLen); ++ ++ pWscMsg = (unsigned char *)(pBuf + sizeof(RTMP_WSC_MSG_HDR)); ++ //Skip the SSID field ++ pWscMsg += 32; ++ ++ /* Get the SrcMAC and copy to the WLANEVENTMAC, ++ depends on the WFAWLANConfig:1 Service Template Version 1.01, ++ the MAC format is "xx:xx:xx:xx:xx:xx", case-independent, 17 char. ++ */ ++ memset(srcMacStr, 0 , sizeof(srcMacStr)); ++ snprintf(srcMacStr, 18, "%02x:%02x:%02x:%02x:%02x:%02x", pWscMsg[0], pWscMsg[1], pWscMsg[2],pWscMsg[3],pWscMsg[4],pWscMsg[5]); ++ DBGPRINTF(RT_DBG_INFO, "ProbeReq->Mac=%s!\n", srcMacStr); ++ ++ //Skip the SrcMAC field ++ pWscMsg += 6; ++ ++ //Get the WscProbeData Length ++ if (*pWscMsg == 0xdd) ++ wscLen = (unsigned char)(*(pWscMsg + 1)); ++ else ++ wscLen = ((*(pWscMsg))<<8) + (*(pWscMsg + 1)); ++ ++ DBGPRINTF(RT_DBG_INFO, "(%s): pWscHdr Len=%d!\n", __FUNCTION__, wscLen); ++ ++ UPnPMsgLen = wscLen + 18; ++ pUPnPMsg = malloc(UPnPMsgLen); ++ ++ if(pUPnPMsg) ++ { ++ memset(pUPnPMsg, 0, UPnPMsgLen); ++ pUPnPMsg[0] = WSC_EVENT_WLANEVENTTYPE_PROBE; ++ memcpy(&pUPnPMsg[1], srcMacStr, 17); ++ ++ //jump to the WscProbeReqData and copy to pUPnPMsg buffer ++ pWscMsg += 2; ++ memcpy(&pUPnPMsg[18], pWscMsg, wscLen); ++ wsc_hexdump("UPnP WLANEVENT Msg", (char *)pUPnPMsg, UPnPMsgLen); ++ ++ //encode the message use base64 ++ encodeLen = ILibBase64Encode(pUPnPMsg, UPnPMsgLen, &encodeStr); ++ ++ //Send event out ++ if (encodeLen > 0){ ++ DBGPRINTF(RT_DBG_INFO, "ProbeReq->Msg=%s!\n", encodeStr); ++ retVal = WscDevStateVarUpdate(WSC_EVENT_WLANEVENT, (char *)encodeStr, NULL); ++ } ++ if (encodeStr != NULL) ++ free(encodeStr); ++ free(pUPnPMsg); ++ } ++ ++ return 0; ++ ++} ++ ++ ++int WscEventMgmtMsgRecv( ++ IN char *pBuf, ++ IN int bufLen) ++{ ++ RTMP_WSC_MSG_HDR *pHdr = NULL; ++ ++ pHdr = (RTMP_WSC_MSG_HDR *)pBuf; ++ if (!pHdr) ++ return -1; ++ ++ if (pHdr->msgType != WSC_OPCODE_UPNP_MGMT) ++ return -1; ++ ++ DBGPRINTF(RT_DBG_INFO, "%s:Receive a MGMT event, msgSubType=%d\n", __FUNCTION__, pHdr->msgSubType); ++ switch(pHdr->msgSubType) ++ { ++ case WSC_UPNP_MGMT_SUB_PROBE_REQ: ++ WscEventMgmt_ProbreReq(pBuf, bufLen); ++ break; ++ case WSC_UPNP_MGMT_SUB_CONFIG_REQ: ++ WscEventMgmt_ConfigReq(pBuf, bufLen); ++ break; ++ case WSC_UPNP_MGMT_SUB_REG_SELECT: ++ WscEventMgmt_RegSelect(pBuf, bufLen); ++ break; ++ default: ++ DBGPRINTF(RT_DBG_ERROR, "Un-Supported WSC Mgmt event type(%d)!\n", pHdr->msgSubType); ++ break; ++ } ++ ++ return 0; ++} ++ ++ ++/****************************************************************************** ++ * WscDevHandleSubscriptionReq ++ * ++ * Description: ++ * Called during a subscription request callback. If the subscription ++ * request is for the Wsc device and match the serviceId, then accept it. ++ * ++ * Parameters: ++ * sr_event -- The "Upnp_Subscription_Request" structure ++ * ++ * Return: ++ * TRUE ++ *****************************************************************************/ ++int ++WscDevHandleSubscriptionReq(IN struct upnphttp * h) ++{ ++ /* Insert this Control Point into WscCPList*/ ++ WscDevCPNodeInsert(wscDevHandle, (char *)(&h->req_SIDOff)); ++ dumpDevCPNodeList(); ++ ++ return TRUE; ++} ++ ++ ++/****************************************************************************** ++ * WscDevServiceHandler ++ * ++ * Description: ++ * The callback handler registered with the SDK while registering ++ * root device. Dispatches the request to the appropriate procedure ++ * based on the value of EventType. The four requests handled by the ++ * device are: ++ * 1) Event Subscription requests. ++ * 2) Get Variable requests. ++ * 3) Action requests. ++ * ++ * Parameters: ++ * ++ * EventType - The type of callback event ++ * Event - Data structure containing event data ++ * Cookie - Optional data specified during callback registration ++ * ++ * Return: ++ * Zero ++ *****************************************************************************/ ++int WscDevServiceHandler( ++ struct upnphttp * h) ++{ ++ ++ switch (h->req_command) ++ { ++ case ESubscribe: ++ WscDevHandleSubscriptionReq(h); ++ break; ++ ++ case EUnSubscribe: ++ WscDevCPNodeRemove((char *)(&h->req_SIDOff)); ++ break; ++ ++ case EGet: ++ case EPost: ++ /* do nothing */ ++ WscDevHandleActionReq(h); ++ break; ++ ++ default: ++ DBGPRINTF(RT_DBG_ERROR, "Error in WscDevServiceHandler: unknown event type %d\n", h->req_command); ++ } ++ ++ return (0); ++} ++ ++ ++/****************************************************************************** ++ * WscLocalDevServTbInit ++ * ++ * Description: ++ * Initializes the service table for the Wsc UPnP service. ++ * Note that knowledge of the service description is assumed. ++ * ++ * Paramters: ++ * None ++ * ++ * Return: ++ * always TRUE. ++ *****************************************************************************/ ++static int WscLocalDevServTbInit(void) ++{ ++ unsigned int i = 0; ++ ++ for (i = 0; i < WSC_STATE_VAR_MAXVARS; i++) ++ { ++ wscLocalDevice.services.StateVarVal[i] = wscStateVarCont[i]; ++ strncpy(wscLocalDevice.services.StateVarVal[i], wscStateVarDefVal[i], WSC_STATE_VAR_MAX_STR_LEN-1); ++ } ++ ++ /* replaced by soapMethods[] in upnpsoap.c */ ++ ++ return TRUE; ++} ++ ++ ++/****************************************************************************** ++ * WscUPnPDevStop ++ * ++ * Description: ++ * Stops the device. Uninitializes the sdk. ++ * ++ * Parameters: ++ * None ++ * Return: ++ * TRUE ++ *****************************************************************************/ ++int WscUPnPDevStop(void) ++{ ++// UpnpUnRegisterRootDevice(wscDevHandle); ++ WscDevCPListRemoveAll(); ++ ++ return 0; ++} ++ ++/****************************************************************************** ++ * WscUPnPDevStart ++ * ++ * Description: ++ * Registers the UPnP device, and sends out advertisements. ++ * ++ * Parameters: ++ * ++ * char *ipAddr - ip address to initialize the Device Service. ++ * unsigned short port - port number to initialize the Device Service. ++ * char *descDoc - name of description document. ++ * If NULL, use default description file name. ++ * char *webRootDir - path of web directory. ++ * If NULL, use default PATH. ++ * Return: ++ * success - WSC_SYS_SUCCESS ++ * failed - WSC_SYS_ERROR ++ *****************************************************************************/ ++int WscUPnPDevStart( ++ IN char *ipAddr, ++ IN unsigned short port, ++ IN char *descDoc, ++ IN char *webRootDir) ++{ ++ int ret, strLen = 0; ++ char descDocUrl[WSC_UPNP_DESC_URL_LEN] = {0}; ++ char udnStr[WSC_UPNP_UUID_STR_LEN]={0}; ++ ++ if (descDoc == NULL) ++ descDoc = DEFAULT_DESC_FILE_NAME; ++ ++ if (webRootDir == NULL) ++ webRootDir = DEFAULT_WEB_ROOT_DIR; ++ ++ memset(CfgMacStr, 0 , sizeof(CfgMacStr)); ++ snprintf(CfgMacStr, 18, "%02x:%02x:%02x:%02x:%02x:%02x", HostMacAddr[0], HostMacAddr[1], ++ HostMacAddr[2],HostMacAddr[3],HostMacAddr[4],HostMacAddr[5]); ++//peter : 0523 ++// memset(&HostDescURL[0], 0, WSC_UPNP_DESC_URL_LEN); ++ ++#ifdef USE_XML_TEMPLATE ++ memset(udnStr, 0, WSC_UPNP_UUID_STR_LEN); ++ ret = wsc_get_oid(RT_OID_WSC_UUID, &udnStr[5], &strLen); ++ if (ret == 0) ++ { ++ memcpy(&udnStr[0], "uuid:", 5); ++ DBGPRINTF(RT_DBG_PKT, "UUID Str=%s!\n", udnStr); ++ ++ /* We replace the uuid string generated by init() of miniupnpd. */ ++ strncpy(wps_uuidvalue+5, &udnStr[5], strLen); ++ ASSERT((*(wps_uuidvalue+5+strLen-1)) == '\0'); ++ DBGPRINTF(RT_DBG_PKT, "wps_uuidvalue[]=%s!\n", wps_uuidvalue); ++ } ++ else ++ { ++ DBGPRINTF(RT_DBG_ERROR, "Get UUID string failed -- ret=%d\n", ret); ++ goto failed; ++ } ++#if 0//peter : 0523 ++ memset(descDocUrl, 0, WSC_UPNP_DESC_URL_LEN); ++ snprintf(descDocUrl, WSC_UPNP_DESC_URL_LEN, "http://%s:%d/WFADeviceDesc.xml", ipAddr, port); ++ strcpy(&HostDescURL[0], &descDocUrl[0]); ++ DBGPRINTF(RT_DBG_PKT, "Registering the RootDevice\n\t with descDocUrl: %s\n", descDocUrl); ++#endif ++#else ++//peter : 0523 ++// snprintf(descDocUrl, WSC_UPNP_DESC_URL_LEN, "http://%s:%d/%s", ipAddr, port, descDoc); ++// strcpy(&HostDescURL[0], &descDocUrl[0]); ++#endif /* USE_XML_TEMPLATE */ ++//peter : 0523 ++// DBGPRINTF(RT_DBG_PKT, "HostDescURL Prepared\n"); ++ ++ memset(&wscLocalDevice, 0, sizeof(wscLocalDevice)); ++ WscLocalDevServTbInit(); ++ DBGPRINTF(RT_DBG_PKT, "WscLocalDevServTbInit Initialized\n"); ++ ++ //Init the ControlPoint List. ++ WscCPList = NULL; ++ ++ return 0; ++ ++failed: ++ ++ return WSC_SYS_ERROR; ++} ++ +Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/wsc/wsc_upnp_device.h +=================================================================== +--- /dev/null ++++ b/wsc/wsc_upnp_device.h +@@ -0,0 +1,98 @@ ++ ++ ++#ifndef __WSC_UPNP_DEVICE_H__ ++#define __WSC_UPNP_DEVICE_H__ ++ ++int ++WscDevGetAPSettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString ); ++int ++WscDevGetSTASettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevSetAPSettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevDelAPSettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevSetSTASettings( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevRebootAP( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevResetAP( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevRebootSTA( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevResetSTA( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int WscDevSetSelectedRegistrar( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++int ++WscDevPutWLANResponse( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++ ++int ++WscDevPutMessageResp( ++ IN WscEnvelope *msgEnvelope); ++ ++int ++WscDevPutMessage( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++ ++int ++WscDevGetDeviceInfoResp( ++ IN WscEnvelope *envelope); ++ ++int ++WscDevGetDeviceInfo( ++ IN struct upnphttp * h, ++ IN uint32 ipAddr, ++ OUT IXML_Document * out, ++ OUT char **errorString); ++ ++#ifdef __cplusplus ++} ++#endif ++ ++#endif