Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/minissdp.c =================================================================== --- a/minissdp.c +++ b/minissdp.c @@ -39,6 +39,9 @@ #include "asyncsendto.h" #include "codelength.h" #include "macros.h" +#ifdef ENABLE_WSC_SERVICE +#include "wsc/wsc_common.h" +#endif /* ENABLE_WSC_SERVICE */ #ifndef MIN #define MIN(x,y) (((x)<(y))?(x):(y)) @@ -592,6 +595,16 @@ SendSSDPResponse(int s, const struct soc } } +#ifdef ENABLE_WSC_SERVICE +static const char * const wfa_known_service_types[] = +{ + "upnp:rootdevice", + "urn:schemas-wifialliance-org:device:WFADevice:", + "urn:schemas-wifialliance-org:service:WFAWLANConfig:", + 0 +}; +#endif /* ENABLE_WSC_SERVICE */ + static struct { const char * s; const int version; @@ -816,6 +829,76 @@ SendSSDPNotifies(int s, const char * hos #endif /* ENABLE_IPV6 */ } +#ifdef ENABLE_WSC_SERVICE +static void +WSC_SendSSDPNotifies(int s, const char * host, unsigned short port, + unsigned int lifetime) +{ + struct sockaddr_in sockname; + int l, n, i=0; + char bufr[512]; + + memset(&sockname, 0, sizeof(struct sockaddr_in)); + sockname.sin_family = AF_INET; + sockname.sin_port = htons(SSDP_PORT); + sockname.sin_addr.s_addr = inet_addr(SSDP_MCAST_ADDR); + + if (GETFLAG(ENABLEWPSMASK)) + { + while(wfa_known_service_types[i]) + { + l = snprintf(bufr, sizeof(bufr), + "NOTIFY * HTTP/1.1\r\n" + "HOST:%s:%d\r\n" + "Cache-Control:max-age=%u\r\n" + "Location:http://%s:%d" WFA_ROOTDESC_PATH"\r\n" + /*"Server:miniupnpd/1.0 UPnP/1.0\r\n"*/ + "Server: " MINIUPNPD_SERVER_STRING "\r\n" + "NT:%s%s\r\n" + "USN:%s::%s%s\r\n" + "NTS:ssdp:alive\r\n" + "\r\n", + SSDP_MCAST_ADDR, SSDP_PORT, + lifetime, + host, port, + wfa_known_service_types[i], (i==0?"":"1"), + wps_uuidvalue, wfa_known_service_types[i], (i==0?"":"1") ); + if(l>=sizeof(bufr)) + { + syslog(LOG_WARNING, "WSC_SendSSDPNotifies(): truncated output"); + l = sizeof(bufr); + } + + n = sendto(s, bufr, l, 0, + (struct sockaddr *)&sockname, sizeof(struct sockaddr_in) ); + + if(n < 0) + { + syslog(LOG_ERR, "sendto(udp_notify=%d, %s): %m", s, host); + } + i++; + } + } + else + { + ; + } +} + +void +WSC_SendSSDPNotifies2(int * sockets, + unsigned short port, + unsigned int lifetime) +{ + int i; + struct lan_addr_s * lan_addr; + for(i=0, lan_addr = lan_addrs.lh_first; lan_addr != NULL; lan_addr = lan_addr->list.le_next, i++) + { + WSC_SendSSDPNotifies(sockets[i], lan_addr->str, port, lifetime); + } +} +#endif /* ENABLE_WSC_SERVICE */ + /* SendSSDPNotifies2() sends SSDP NOTIFY packets on all interfaces * for all destinations, all devices / services */ void @@ -1339,6 +1422,55 @@ ProcessSSDPData(int s, const char *bufr, uuidvalue_wcd, delay); } } +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + for(i = 0; wfa_known_service_types[i]; i++) + { + l = (int)strlen(wfa_known_service_types[i]); + if(l<=st_len && (0 == memcmp(st, wfa_known_service_types[i], l))) + { + syslog(LOG_INFO, "WPS Single search found"); + SendSSDPResponse(s, sender, + st, st_len, "", + announced_host, WPS_PORT, +#ifdef ENABLE_HTTPS + https_port, +#endif + wfa_known_service_types[i], delay); + break; + } + } + /* Responds to request with ST: ssdp:all */ + /* strlen("ssdp:all") == 8 */ + if(st_len==8 && (0 == memcmp(st, "ssdp:all", 8))) + { + for(i=0; wfa_known_service_types[i]; i++) + { + l = (int)strlen(wfa_known_service_types[i]); + SendSSDPResponse(s, sender, + wfa_known_service_types[i], l, i==0?"":"1", + announced_host, WPS_PORT, +#ifdef ENABLE_HTTPS + https_port, +#endif + wfa_known_service_types[i], delay); + } + } + /* responds to request by UUID value */ + l = (int)strlen(wps_uuidvalue); + if(l==st_len && (0 == memcmp(st, wps_uuidvalue, l))) + { + SendSSDPResponse(s, sender, st, st_len, "", + announced_host, WPS_PORT, +#ifdef ENABLE_HTTPS + https_port, +#endif + wfa_known_service_types[i], delay); + } + + } +#endif /* ENABLE_WSC_SERVICE */ } else { @@ -1481,6 +1613,49 @@ SendSSDPGoodbye(int * sockets, int n_soc return ret; } +#ifdef ENABLE_WSC_SERVICE +/* This will broadcast ssdp:byebye notifications to inform + * the network that UPnP is going down. */ +int +WSC_SendSSDPGoodbye(int * sockets, int n_sockets) +{ + struct sockaddr_in sockname; + int n, l; + int i, j; + char bufr[512]; + + memset(&sockname, 0, sizeof(struct sockaddr_in)); + sockname.sin_family = AF_INET; + sockname.sin_port = htons(SSDP_PORT); + sockname.sin_addr.s_addr = inet_addr(SSDP_MCAST_ADDR); + + for(j=0; j 0) + { + c = *(s++); len--; + switch(c) + { + case '<': + if(len>0 && *s == '/') + elt_close++; + else if(len>0 && *s == '?') + elt_close = 1; + else + elt_close = 0; + if(elt_close!=1) + { + if(elt_close > 1) + indent--; + fputc('\n', f); n++; + for(i=indent; i>0; i--) + fputc(' ', f); + n += indent; + } + fputc(c, f); n++; + break; + case '>': + fputc(c, f); n++; + if(elt_close==1) + { + /*fputc('\n', f); n++; */ + //elt_close = 0; + if(indent > 0) + indent--; + } + else if(elt_close == 0) + indent++; + break; + default: + fputc(c, f); n++; + } + } + return n; +} + +int DescDump() +{ + char * Desc; + int DescLen; + char * s; + int l; + + Desc = genWSCRootDesc((int *)&DescLen); + xml_print(Desc, DescLen, stdout); + free(Desc); + printf("\n-------------\n"); + + s = genWSC((int *)&l); + xml_print(s, l, stdout); + free(s); + printf("\n-------------\n"); +#ifdef ENABLE_EVENTS + s = getVarsWSC((int *)&l); + xml_print(s, l, stdout); + free(s); + printf("\n-------------\n"); +#endif /* ENABLE_EVENTS */ + return 0; +} +#endif /* RT_DEBUG */ +#endif /* ENABLE_WSC_SERVICE */ + #ifdef USE_IFACEWATCHER #include "ifacewatcher.h" #endif @@ -303,6 +385,10 @@ tomato_helper(void) #endif /* 1 (tomato) */ #endif /* TOMATO */ +#ifdef ENABLE_WSC_SERVICE +extern int wsc_debug_level; +#endif /* ENABLE_WSC_SERVICE */ + /* OpenAndConfHTTPSocket() : * setup the socket used to handle incoming HTTP connections. */ static int @@ -1037,6 +1123,7 @@ parselanaddr(struct lan_addr_s * lan_add } } #endif +#ifndef ENABLE_WSC_SERVICE if(lan_addr->ifname[0] != '\0') { lan_addr->index = if_nametoindex(lan_addr->ifname); @@ -1058,6 +1145,7 @@ parselanaddr(struct lan_addr_s * lan_add syslog(LOG_NOTICE, "it is advised to use network interface name instead of %s", str); } #endif +#endif /* ENABLE_WSC_SERVICE */ return 0; parselan_error: fprintf(stderr, "Error parsing address/mask (or interface name) : %s\n", @@ -1149,7 +1237,7 @@ static int init(int argc, char * * argv, struct runtime_vars * v) { int i; -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) int pid; #endif int debug_flag = 0; @@ -1186,7 +1274,12 @@ init(int argc, char * * argv, struct run #endif /* DISABLE_CONFIG_FILE */ /* set initial values */ +#ifdef ENABLE_WSC_SERVICE + SETFLAG(ENABLEWPSMASK); +#else SETFLAG(ENABLEUPNPMASK); /* UPnP is enabled by default */ +#endif /* ENABLE_WSC_SERVICE */ + #ifdef ENABLE_IPV6 ipv6_bind_addr = in6addr_any; #endif /* ENABLE_IPV6 */ @@ -1530,6 +1623,18 @@ init(int argc, char * * argv, struct run fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]); serialnumber[SERIALNUMBER_MAX_LEN-1] = '\0'; break; +#ifdef ENABLE_WSC_SERVICE + case 'M': + if(i+1 < argc) + strncpy(modelnumber, argv[++i], MODELNUMBER_MAX_LEN); + else + fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]); + modelnumber[MODELNUMBER_MAX_LEN-1] = '\0'; + break; + case 'm': + i++; /* discarding */ + break; +#else case 'm': if(i+1 < argc) strncpy(modelnumber, argv[++i], MODELNUMBER_MAX_LEN); @@ -1537,12 +1642,26 @@ init(int argc, char * * argv, struct run fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]); modelnumber[MODELNUMBER_MAX_LEN-1] = '\0'; break; +#endif /* ENABLE_WSC_SERVICE */ #ifdef ENABLE_NATPMP case 'N': /*enablenatpmp = 1;*/ SETFLAG(ENABLENATPMPMASK); break; #endif /* ENABLE_NATPMP */ +#ifdef ENABLE_WSC_SERVICE + case 'G': + /*enable IGD service*/ + SETFLAG(ENABLEUPNPMASK); + break; + case 'I': + i++; /* WPSInit will take care of it. */ + break; + case 'n': + i++; + break; +#endif /* ENABLE_WSC_SERVICE */ + case 'U': /*sysuptime = 1;*/ SETFLAG(SYSUPTIMEMASK); @@ -1566,6 +1685,7 @@ init(int argc, char * * argv, struct run fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]); break; #ifdef ENABLE_IPV6 +#ifndef ENABLE_WSC_SERVICE case 'I': if(i+1 < argc) ext_if_name6 = argv[++i]; @@ -1573,6 +1693,7 @@ init(int argc, char * * argv, struct run fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]); break; #endif +#endif #ifdef USE_PF case 'q': if(i+1 < argc) @@ -1623,7 +1744,7 @@ init(int argc, char * * argv, struct run } break; #endif /* ENABLE_NFQUEUE */ -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) case 'P': if(i+1 < argc) pidfilename = argv[++i]; @@ -1773,13 +1894,17 @@ init(int argc, char * * argv, struct run } } -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) if(debug_flag) { pid = getpid(); } else { +#ifdef ENABLE_WSC_SERVICE + wsc_debug_level = RT_DBG_OFF; +#endif /* ENABLE_WSC_SERVICE */ + #ifdef USE_DAEMON if(daemon(0, 0)<0) { perror("daemon()"); @@ -1816,7 +1941,7 @@ init(int argc, char * * argv, struct run } } -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) if(checkforrunning(pidfilename) < 0) { syslog(LOG_ERR, "MiniUPnPd is already running. EXITING"); @@ -1899,7 +2024,7 @@ init(int argc, char * * argv, struct run #endif #endif -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) if(writepidfile(pidfilename, pid) < 0) pidfilename = NULL; #endif @@ -1946,9 +2071,14 @@ print_usage: #endif "\n" /*"[-l logfile] " not functionnal */ +#ifdef ENABLE_WSC_SERVICE + "\t\t[-u uuid] [-s serial] [-M model_number] \n" +#else + "\t\t[-u uuid] [-s serial] [-m model_number] \n" +#endif /* ENABLE_WSC_SERVICE */ "\t\t[-u uuid] [-s serial] [-m model_number] \n" "\t\t[-t notify_interval] " -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) "[-P pid_filename] " #endif #ifdef ENABLE_MANUFACTURER_INFO_CONFIGURATION @@ -1968,7 +2098,7 @@ print_usage: "\n" "\nNotes:\n\tThere can be one or several listening_ips.\n" "\tNotify interval is in seconds. Default is 30 seconds.\n" -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) "\tDefault pid file is '%s'.\n" #endif "\tDefault config file is '%s'.\n" @@ -1992,6 +2122,10 @@ print_usage: "\t-q sets the ALTQ queue in pf.\n" "\t-T sets the tag name in pf.\n" #endif +#ifdef ENABLE_WSC_SERVICE + "\t-G turns on IGD Device service.\n" +#endif /* ENABLE_WSC_SERVICE */ + #ifdef ENABLE_NFQUEUE "\t-Q sets the queue number that is used by NFQUEUE.\n" "\t-n sets the name of the interface(s) that packets will arrive on.\n" @@ -2008,7 +2142,7 @@ print_usage: "\t-v enables LOG_INFO messages, -vv LOG_DEBUG as well (default with -d)\n" "\t-h / --help prints this help and quits.\n" "", argv[0], argv[0], argv[0], -#ifndef NO_BACKGROUND_NO_PIDFILE +#if defined(ENABLE_WSC_SERVICE) || !defined(NO_BACKGROUND_NO_PIDFILE) pidfilename, #endif DEFAULT_CONFIG); @@ -2048,6 +2182,10 @@ main(int argc, char * * argv) int sifacewatcher = -1; #endif +#ifdef ENABLE_WSC_SERVICE + int shttpwpsl = -1; +#endif /* ENABLE_WSC_SERVICE */ + int * snotify = NULL; int addr_count; LIST_HEAD(httplisthead, upnphttp) upnphttphead; @@ -2131,6 +2269,22 @@ main(int argc, char * * argv) } #endif +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + if (WPSInit(argc, argv)) + { + DBGPRINTF(RT_DBG_OFF, "WPSInit() ok !\n"); + } + else + { + DBGPRINTF(RT_DBG_OFF, "WPSInit() failed !\n"); + CLEARFLAG(ENABLEWPSMASK); + return 1; + } + } +#endif /* ENABLE_WSC_SERVICE */ + LIST_INIT(&upnphttphead); #ifdef USE_MINIUPNPDCTL LIST_INIT(&ctllisthead); @@ -2138,8 +2292,14 @@ main(int argc, char * * argv) if( #ifdef ENABLE_NATPMP +#ifdef ENABLE_WSC_SERVICE + !GETFLAG(ENABLEWPSMASK) && +#endif /* ENABLE_WSC_SERVICE */ !GETFLAG(ENABLENATPMPMASK) && !GETFLAG(ENABLEUPNPMASK) #else +#ifdef ENABLE_WSC_SERVICE + !GETFLAG(ENABLEWPSMASK) && +#endif /* ENABLE_WSC_SERVICE */ !GETFLAG(ENABLEUPNPMASK) #endif ) { @@ -2186,6 +2346,33 @@ main(int argc, char * * argv) } } +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + /* open socket for HTTP connections. Listen on the 1st LAN address */ +#ifdef ENABLE_IPV6 + shttpwpsl = OpenAndConfHTTPSocket(&WPS_PORT, !GETFLAG(IPV6DISABLEDMASK)); +#else /* ENABLE_IPV6 */ + shttpwpsl = OpenAndConfHTTPSocket(&WPS_PORT); +#endif /* ENABLE_IPV6 */ + if(shttpwpsl < 0) + { + syslog(LOG_ERR, "Failed to open socket for WPS. EXITING"); + return 1; + } + syslog(LOG_ERR, "WPS listening on port %d", WPS_PORT); + + { + int flags; + + flags = fcntl(netlink_sock, F_GETFL, 0); + if (flags == -1) + return 1; + fcntl(netlink_sock, F_SETFL, flags | O_NONBLOCK); + } + } +#endif /* ENABLE_WSC_SERVICE */ + if(GETFLAG(ENABLEUPNPMASK)) { unsigned short listen_port; @@ -2328,6 +2515,13 @@ main(int argc, char * * argv) sctl = OpenAndConfCtlUnixSocket("/var/run/miniupnpd.ctl"); #endif +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + DescDump(); + } +#endif /* ENABLE_WSC_SERVICE */ + #ifdef ENABLE_NFQUEUE if ( nfqueue != -1 && n_nfqix > 0) { nfqh = OpenAndConfNFqueue(); @@ -2491,7 +2685,15 @@ main(int argc, char * * argv) { /* the comparaison is not very precise but who cares ? */ if(timeofday.tv_sec >= (lasttimeofday.tv_sec + v.notify_interval)) - { + { +#ifdef ENABLE_WSC_SERVICE + { + // how often to verify the timeouts, in seconds + // default value is equal to notify interval + WscMsgQVerifyTimeouts(v.notify_interval); + } +#endif + if (GETFLAG(ENABLEUPNPMASK)) SendSSDPNotifies2(snotify, (unsigned short)v.port, @@ -2499,6 +2701,16 @@ main(int argc, char * * argv) (unsigned short)v.https_port, #endif v.notify_interval << 1); + +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + WSC_SendSSDPNotifies2(snotify, + (unsigned short)WPS_PORT, + v.notify_interval << 1); + } +#endif /* ENABLE_WSC_SERVICE */ + memcpy(&lasttimeofday, &timeofday, sizeof(struct timeval)); timeout.tv_sec = v.notify_interval; timeout.tv_usec = 0; @@ -2582,6 +2794,20 @@ main(int argc, char * * argv) FD_SET(shttpl, &readset); max_fd = MAX( max_fd, shttpl); } + +#ifdef ENABLE_WSC_SERVICE + if(shttpwpsl >= 0) + { + FD_SET(shttpwpsl, &readset); + max_fd = MAX(max_fd, shttpwpsl); + } + if(netlink_sock >= 0) + { + FD_SET(netlink_sock, &readset); + max_fd = MAX(max_fd, netlink_sock); + } +#endif /* ENABLE_WSC_SERVICE */ + #if defined(V6SOCKETS_ARE_V6ONLY) && defined(ENABLE_IPV6) if (shttpl_v4 >= 0) { @@ -2911,13 +3137,64 @@ main(int argc, char * * argv) { if(e->socket >= 0) { - if(FD_ISSET(e->socket, &readset) || + if((FD_ISSET(e->socket, &readset) || FD_ISSET(e->socket, &writeset)) +#ifdef ENABLE_WSC_SERVICE + && (e->state != DO_NOTHING_IN_MAIN_LOOP) +#endif + ) { Process_upnphttp(e); } } } + +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + /* process incoming HTTP connections */ + if(shttpwpsl >= 0 && FD_ISSET(shttpwpsl, &readset)) + { + int shttpwps; + socklen_t clientnamelen; + struct sockaddr_in clientname; + clientnamelen = sizeof(struct sockaddr_in); + shttpwps = accept(shttpwpsl, (struct sockaddr *)&clientname, &clientnamelen); + if (shttpwps<0) + { + syslog(LOG_ERR, "accept(shttpwpsl): %m"); + } + else + { + struct upnphttp * tmp = 0; + syslog(LOG_ERR, "HTTP connection from %s:%d", + inet_ntoa(clientname.sin_addr), + ntohs(clientname.sin_port) ); + /* Create a new upnphttp object and add it to + * the active upnphttp object list */ + tmp = New_upnphttp(shttpwps); + if(tmp) + { + tmp->clientaddr = clientname.sin_addr; + LIST_INSERT_HEAD(&upnphttphead, tmp, entries); + } + else + { + syslog(LOG_ERR, "New_upnphttp() failed"); + close(shttpwps); + shttpwps = -1; + } + } + } + + if(FD_ISSET(netlink_sock, &readset)) + { + DBGPRINTF(RT_DBG_LOUD, "(%s):netlink socket data is available now.\n", __FUNCTION__); + wscNLSockRecv(netlink_sock); + } + } +#endif /* ENABLE_WSC_SERVICE */ + /* process incoming HTTP connections */ if(shttpl >= 0 && FD_ISSET(shttpl, &readset)) { @@ -3036,6 +3313,18 @@ shutdown: } } #endif +#ifdef ENABLE_WSC_SERVICE + if(shttpwpsl >= 0) + { + close(shttpwpsl); + shttpwpsl = -1; + } + if(netlink_sock >= 0) + { + close(netlink_sock); + netlink_sock = -1; + } +#endif /* ENABLE_WSC_SERVICE */ #if defined(ENABLE_IPV6) && defined(ENABLE_PCP) if(spcp_v6 >= 0) { @@ -3055,6 +3344,22 @@ shutdown: } #endif +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + if(WSC_SendSSDPGoodbye(snotify, addr_count) < 0) + { + syslog(LOG_ERR, "Failed to broadcast good-bye notifications for WSC"); + } + } + + if (!(GETFLAG(ENABLEUPNPMASK))) + { + for(i=0; i bin.base64, but portig code 4 => ui1 + "ui1", +#endif "bin.base64" }; @@ -94,7 +109,11 @@ static const char * const upnpallowedval * ERROR_IP_CONFIGURATION * ERROR_UNKNOWN */ 0, - "", /* 27 */ + "", /* 27 */ +#ifdef ENABLE_WSC_SERVICE + 0, + "0", /* 29 */ +#endif /* ENABLE_WSC_SERVICE */ 0 }; @@ -132,6 +151,13 @@ static const char * magicargname[] = { #endif /* ENABLE_DP_SERVICE */ }; +/* it seems fine to use xmlver instead of wps_xmlver */ +#ifdef ENABLE_WSC_SERVICE +/* it seems fine to use xmlver instead of wps_xmlver in service description */ +static const char wps_xmlver[] = + ""; +#endif /* ENABLE_WSC_SERVICE */ + static const char xmlver[] = "\r\n"; static const char root_service[] = @@ -317,6 +343,41 @@ static const struct XMLElt rootDesc[] = {0, 0} }; +#ifdef ENABLE_WSC_SERVICE +static const struct XMLElt WFArootDesc[] = +{ +/* 0 */ + {root_device, INITHELPER(1,2)}, + {"specVersion", INITHELPER(3,2)}, + {"device", INITHELPER(5,11)}, + + {"/major", "1"}, + {"/minor", "0"}, +/* 5 */ + {"/deviceType", "urn:schemas-wifialliance-org:device:WFADevice:1"}, + {"/friendlyName", WLANDEV_FRIENDLYNAME}, + {"/manufacturer", WLANDEV_MANUFACTURER}, + {"/manufacturerURL", WLANDEV_MANUFACTURERURL}, + {"/modelDescription", WLANDEV_MODELDESCRIPTION}, + {"/modelName", WLANDEV_MODELNAME}, + {"/modelNumber", WLANDEV_MODELNUMBER}, + {"/modelURL", WLANDEV_MODELURL}, + {"/serialNumber", wps_serialnumber}, + {"/UDN", wps_uuidvalue}, +/* 15 */ + {"serviceList", INITHELPER(16,1)}, +/* 16 */ + {"service", INITHELPER(17,5)}, +/* 17 */ + {"/serviceType", "urn:schemas-wifialliance-org:service:WFAWLANConfig:1"}, + {"/serviceId", "urn:wifialliance-org:serviceId:WFAWLANConfig1"}, + {"/SCPDURL", "WFAWLANConfigSCPD.xml"}, + {"/controlURL", "control"}, + {"/eventSubURL", "event"}, + {0, 0} +}; +#endif + /* WANIPCn.xml */ /* see UPnP_IGD_WANIPConnection 1.0.pdf static struct XMLElt scpdWANIPCn[] = @@ -789,7 +850,12 @@ static const struct stateVar DPVars[] = {"A_ARG_TYPE_ACL", 0}, {"A_ARG_TYPE_IdentityList", 0}, {"A_ARG_TYPE_Identity", 0}, + //Mediatek : be care origianl ver 1.2 poritng , 4 => ui1, 5 => bin.base64 +#ifdef ENABLE_WSC_SERVICE + {"A_ARG_TYPE_Base64", 5}, +#else {"A_ARG_TYPE_Base64", 4}, +#endif {"A_ARG_TYPE_String", 0}, {0, 0} }; @@ -798,6 +864,139 @@ static const struct serviceDesc scpdDP = { DPActions, DPVars }; #endif +#ifdef ENABLE_WSC_SERVICE +static const struct argument GetDeviceInfoArgs[] = +{ + {2, 3}, /* out */ + {0, 0} +}; + +static const struct argument PutMessageArgs[] = +{ + {1, 1}, /* in */ + {2, 2}, /* out */ + {0, 0} +}; + +static const struct argument GetAPSettingsArgs[] = +{ + {1, 0}, /* in */ + {2, 4}, /* out */ + {0, 0} +}; + + +static const struct argument SetAPSettingsArgs[] = +{ + {1, 4}, /* in */ + {0, 0} +}; + +static const struct argument DelAPSettingsArgs[] = +{ + {1, 4}, /* in */ + {0, 0} +}; + +static const struct argument GetSTASettingsArgs[] = +{ + {1, 0}, /* in */ + {2, 6}, /* out */ + {0, 0} +}; + +static const struct argument SetSTASettingsArgs[] = +{ + {2, 6}, /* in */ + {0, 0} +}; + +static const struct argument DelSTASettingsArgs[] = +{ + {1, 6}, /* in */ + {0, 0} +}; + +static const struct argument PutWLANResponseArgs[] = +{ + {1, 0}, /* in */ + {1, 9}, /* in */ + {1, 10}, /* in */ + {0, 0} +}; + +static const struct argument RebootAPArgs[] = +{ + {1, 4}, /* in */ + {0, 0} +}; + +static const struct argument ResetAPArgs[] = +{ + {1, 0}, /* in */ + {0, 0} +}; + +static const struct argument RebootSTAArgs[] = +{ + {1, 6}, /* in */ + {0, 0} +}; + +static const struct argument ResetSTAArgs[] = +{ + {1, 0}, /* in */ + {0, 0} +}; + +static const struct argument SetSelectedRegistrarArgs[] = +{ + {1, 0}, /* in */ + {0, 0} +}; + +static const struct action WSCActions[] = +{ + {"DelAPSettings", DelAPSettingsArgs}, + {"DelSTASettings", DelSTASettingsArgs}, + {"GetAPSettings", GetAPSettingsArgs}, + {"GetDeviceInfo", GetDeviceInfoArgs}, + {"GetSTASettings", GetSTASettingsArgs}, + {"PutMessage", PutMessageArgs}, + {"PutWLANResponse", PutWLANResponseArgs}, + {"RebootAP", RebootAPArgs}, + {"RebootSTA", RebootSTAArgs}, + {"ResetAP", ResetAPArgs}, + {"ResetSTA", ResetSTAArgs}, + {"SetAPSettings", SetAPSettingsArgs}, + {"SetSelectedRegistrar", SetSelectedRegistrarArgs}, + {"SetSTASettings", SetSTASettingsArgs}, + {0, 0} +}; + +/* See WFA WLANConfig 1.0.pdf */ +static const struct stateVar WSCVars[] = +{ + {"Message", 5, 0, 0, 0}, /* Required */ + {"InMessage", 5, 0, 0, 0}, /* Required */ + {"OutMessage", 5, 0, 0, 0}, /* Required */ + {"DeviceInfo", 5, 0, 0, 0}, /* Required */ + {"APSettings", 5, 0, 0, 0}, /* Conditional */ + {"WLANEvent", 5|0x80, 0, 0, WSCSERVICE_MAGICALVALUE}, /* Conditional */ /*Mediatek : change magic value from 252 to WSCSERVICE_MAGICALVALUE*/ + {"STASettings", 5, 0, 0, 0}, /* Conditional */ + {"APStatus", 4|0x80, 0, 0, WSCSERVICE_MAGICALVALUE}, /* Conditional */ + {"STAStatus", 4|0x80, 0, 0, WSCSERVICE_MAGICALVALUE}, /* Conditional */ + {"WLANEventType", 4, 0, 0, 0}, /* Conditional */ + {"WLANEventMAC", 0, 0, 0, 0}, /* Conditional */ + {"WLANResponse", 5, 0, 0, 0}, /* Conditional */ + {0, 0} +}; + +static const struct serviceDesc scpdWSC = +{ WSCActions, WSCVars }; +#endif /* ENABLE_WSC_SERVICE */ + + /* strcat_str() * concatenate the string and use realloc to increase the * memory buffer if needed. */ @@ -997,6 +1196,31 @@ genXML(char * str, int * len, int * tmpl } } +#ifdef ENABLE_WSC_SERVICE +/* genRootDesc() : + * - Generate the root description of the UPnP device. + * - the len argument is used to return the length of + * the returned string. + * - tmp_uuid argument is used to build the uuid string */ +char * +genWSCRootDesc(int * len) +{ + char * str; + int tmplen; + + tmplen = 2048; + str = (char *)malloc(tmplen); + if(str == NULL) + return NULL; + *len = strlen(wps_xmlver); + /*strcpy(str, xmlver); */ + memcpy(str, wps_xmlver, *len + 1); + str = genXML(str, len, &tmplen, WFArootDesc); + str[*len] = '\0'; + return str; +} +#endif /* ENABLE_WSC_SERVICE */ + /* genRootDesc() : * - Generate the root description of the UPnP device. * - the len argument is used to return the length of @@ -1186,6 +1410,14 @@ genWANIPCn(int * len) return genServiceDesc(len, &scpdWANIPCn); } +#ifdef ENABLE_WSC_SERVICE +char * +genWSC(int * len) +{ + return genServiceDesc(len, &scpdWSC); +} +#endif /* ENABLE_WSC_SERVICE */ + /* genWANCfg() : * Generate the WANInterfaceConfig xml description. */ char * @@ -1227,6 +1459,10 @@ genEventVars(int * len, const struct ser char * str; int tmplen; tmplen = 512; +#ifdef ENABLE_WSC_SERVICE + int var_index = 0; +#endif /* ENABLE_WSC_SERVICE */ + str = (char *)malloc(tmplen); if(str == NULL) return NULL; @@ -1242,6 +1478,16 @@ genEventVars(int * len, const struct ser switch(v->ieventvalue) { case 0: break; + +#ifdef ENABLE_WSC_SERVICE + case WSCSERVICE_MAGICALVALUE: /* Default WSC service magical value */ + printf("update Event Vars :%s == %s\n", v->name, wscLocalDevice.services.StateVarVal[var_index]); + /* WSC_EVENT_WLANEVENT : 0; WSC_EVENT_APSTATUS : 1; WSC_EVENT_STASTATUS : 2 */ + str = strcat_str(str, len, &tmplen, wscLocalDevice.services.StateVarVal[var_index]); + var_index += 1; + break; +#endif /* ENABLE_WSC_SERVICE */ + #ifdef ENABLE_DP_SERVICE case SETUPREADY_MAGICALVALUE: /* always ready for setup */ @@ -1367,4 +1613,15 @@ getVarsDP(int * l) } #endif +#ifdef ENABLE_WSC_SERVICE +char * +getVarsWSC(int * l) +{ + + return genEventVars(l, + &scpdWSC + /*,WscServiceTypeStr*/); +} +#endif /* ENABLE_WSC_SERVICE */ + #endif /* ENABLE_EVENTS */ Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpdescgen.h =================================================================== --- a/upnpdescgen.h +++ b/upnpdescgen.h @@ -55,6 +55,17 @@ struct stateVar { char * genRootDesc(int * len); +#ifdef ENABLE_WSC_SERVICE +/* The data structure used the save the local Wsc UPnP Device. */ +//extern struct upnpDevice wscLocalDevice; + +char * +genWSCRootDesc(int * len); + +char * +genWSC(int * len); +#endif /* ENABLE_WSC_SERVICE */ + /* for the two following functions */ char * genWANIPCn(int * len); @@ -96,6 +107,10 @@ getVars6FC(int * len); char * getVarsDP(int * len); #endif +#ifdef ENABLE_WSC_SERVICE +char * +getVarsWSC(int * len); +#endif /* ENABLE_WSC_SERVICE */ #endif /* ENABLE_EVENTS */ #endif Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpdescstrings.h =================================================================== --- a/upnpdescstrings.h +++ b/upnpdescstrings.h @@ -37,5 +37,17 @@ #define WANCDEV_UPC "000000000000" /* UPC is 12 digit (barcode) */ +#ifdef ENABLE_WSC_SERVICE +#define WLANDEV_FRIENDLYNAME "MediatekAPS" +#define WLANDEV_MANUFACTURER "Mediatek Technology, Corp." +#define WLANDEV_MANUFACTURERURL "http://www.mediatek.com" +#define WLANDEV_MODELNAME "Mediatek Wireless Access Point" +#define WLANDEV_MODELDESCRIPTION "Mediatek AP WPS device" +//Mediatek : need to modified +#define WLANDEV_MODELNUMBER "RT3062" +#define WLANDEV_MODELURL "http://www.mediatek.com" +//#define WLANDEV_UPC "MINIUPNPD" +#endif /* ENABLE_WSC_SERVICE */ + #endif Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpevents.c =================================================================== --- a/upnpevents.c +++ b/upnpevents.c @@ -32,6 +32,11 @@ #include "upnpdescgen.h" #include "upnputils.h" +#ifdef ENABLE_WSC_SERVICE +#include "wsc/wsc_common.h" +#include "wsc/wsc_upnp.h"/* for wscLocalDevice */ +#endif /* ENABLE_WSC_SERVICE */ + #ifdef ENABLE_EVENTS /*enum subscriber_service_enum { EWanCFG = 1, @@ -39,6 +44,7 @@ EL3F };*/ +#if 0 /* stuctures definitions */ struct subscriber { LIST_ENTRY(subscriber) entries; @@ -49,6 +55,7 @@ struct subscriber { char uuid[42]; char callback[]; }; +#endif struct upnp_event_notify { LIST_ENTRY(upnp_event_notify) entries; @@ -75,7 +82,10 @@ struct upnp_event_notify { }; /* prototypes */ -static void +#ifndef ENABLE_WSC_SERVICE +static +#endif +void upnp_event_create_notify(struct subscriber * sub); /* Subscriber list */ @@ -110,6 +120,10 @@ newSubscriber(const char * eventurl, con else if(strcmp(eventurl, DP_EVENTURL)==0) tmp->service = EDP; #endif +#ifdef ENABLE_WSC_SERVICE + else if(strcmp(eventurl, WSC_EVENTURL)==0) + tmp->service = EWSC; +#endif /* ENABLE_WSC_SERVICE */ else { free(tmp); return NULL; @@ -148,7 +162,14 @@ newSubscriber(const char * eventurl, con } } if(status != uuid_s_ok) { - /* make a dummy uuid */ + /* make a dummy uuid */ +#ifdef ENABLE_WSC_SERVICE + if (tmp->service == EWSC) + { + strncpy(tmp->uuid, wps_uuidvalue, sizeof(tmp->uuid)); + } + else +#endif /* ENABLE_WSC_SERVICE */ strncpy(tmp->uuid, uuidvalue_igd, sizeof(tmp->uuid)); tmp->uuid[sizeof(tmp->uuid)-1] = '\0'; snprintf(tmp->uuid+sizeof(tmp->uuid)-5, 5, "%04lx", random() & 0xffff); @@ -156,6 +177,13 @@ newSubscriber(const char * eventurl, con } #else /* make a dummy uuid */ +#ifdef ENABLE_WSC_SERVICE + if (tmp->service == EWSC) + { + strncpy(tmp->uuid, wps_uuidvalue, sizeof(tmp->uuid)); + } + else +#endif /* ENABLE_WSC_SERVICE */ strncpy(tmp->uuid, uuidvalue_igd, sizeof(tmp->uuid)); tmp->uuid[sizeof(tmp->uuid)-1] = '\0'; snprintf(tmp->uuid+sizeof(tmp->uuid)-5, 5, "%04lx", random() & 0xffff); @@ -233,6 +261,15 @@ void upnp_event_var_change_notify(enum subscriber_service_enum service) { struct subscriber * sub; + +#ifdef RT_DEBUG + sub = subscriberlist.lh_first; + if (sub == NULL) + { + DBGPRINTF(RT_DBG_INFO, "\n--------------subscriberlist is empty !!!--------------\n"); + } +#endif /* RT_DEBUG */ + for(sub = subscriberlist.lh_first; sub != NULL; sub = sub->entries.le_next) { if(sub->service == service && sub->notify == NULL) upnp_event_create_notify(sub); @@ -240,7 +277,10 @@ upnp_event_var_change_notify(enum subscr } /* create and add the notify object to the list */ -static void +#ifndef ENABLE_WSC_SERVICE +static +#endif +void upnp_event_create_notify(struct subscriber * sub) { struct upnp_event_notify * obj; @@ -418,6 +458,11 @@ static void upnp_event_prepare(struct up return; } switch(obj->sub->service) { +#ifdef ENABLE_WSC_SERVICE + case EWSC: + xml = getVarsWSC(&l); + break; +#endif /* ENABLE_WSC_SERVICE */ case EWanCFG: xml = getVarsWANCfg(&l); break; @@ -443,7 +488,12 @@ static void upnp_event_prepare(struct up xml = NULL; l = 0; } +//Mediatek : Need to increase the buffer, or the payload may be cut! +#ifdef ENABLE_WSC_SERVICE + obj->buffersize = 2000;// 1024 ==> 2000 (confirmed : 1024 is not enough) +#else obj->buffersize = 1024; +#endif for (;;) { obj->buffer = malloc(obj->buffersize); if(!obj->buffer) { @@ -686,5 +736,28 @@ void write_events_details(int s) { } #endif +#ifdef ENABLE_WSC_SERVICE +int +WscDevSubscriberSearch( + char *SubsId, + struct subscriber ** sub) +{ + int found = 0; + + *sub = subscriberlist.lh_first; + + while (*sub) + { + if (memcmp(SubsId, (*sub)->uuid, 41) == 0) + { + found = 1; + break; + } + *sub = (*sub)->entries.le_next; + } + + return found; +} +#endif /* ENABLE_WSC_SERVICE */ #endif Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpevents.h =================================================================== --- a/upnpevents.h +++ b/upnpevents.h @@ -25,6 +25,21 @@ enum subscriber_service_enum { #ifdef ENABLE_DP_SERVICE EDP, #endif +#ifdef ENABLE_WSC_SERVICE + EWSC, +#endif +}; + +//Mediatek : move from to upnpevents.c +/* stuctures definitions */ +struct subscriber { + LIST_ENTRY(subscriber) entries; + struct upnp_event_notify * notify; + time_t timeout; + uint32_t seq; + enum subscriber_service_enum service; + char uuid[42]; + char callback[]; }; void Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpglobalvars.c =================================================================== --- a/upnpglobalvars.c +++ b/upnpglobalvars.c @@ -64,6 +64,11 @@ char uuidvalue_wan[] = "uuid:00000000-00 char uuidvalue_wcd[] = "uuid:00000000-0000-0000-0000-000000000000"; char serialnumber[SERIALNUMBER_MAX_LEN] = "00000000"; +#ifdef ENABLE_WSC_SERVICE +char wps_uuidvalue[] = "uuid:00000000-0000-0000-0000-000000000000"; +char wps_serialnumber[SERIALNUMBER_MAX_LEN] = "87654321"; +#endif /* ENABLE_WSC_SERVICE */ + char modelnumber[MODELNUMBER_MAX_LEN] = "1"; /* presentation url : Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpglobalvars.h =================================================================== --- a/upnpglobalvars.h +++ b/upnpglobalvars.h @@ -31,6 +31,9 @@ extern uint16_t ext_stun_port; extern const char * lease_file; #endif +#define FILE_PATH_LEN 256 +extern char pid_file_path[FILE_PATH_LEN]; + /* forced ip address to use for this interface * when NULL, getifaddr() is used */ extern const char * use_ext_ip_addr; @@ -86,6 +89,13 @@ extern int runtime_flags; #define EXTIPRESERVEDIGNOREMASK 0x2000 +#ifdef ENABLE_WSC_SERVICE +#define ENABLEWPSMASK 0x8000 + +extern char wps_uuidvalue[]; +extern char wps_serialnumber[]; +#endif /* ENABLE_WSC_SERVICE */ + #define SETFLAG(mask) runtime_flags |= mask #define GETFLAG(mask) (runtime_flags & mask) #define CLEARFLAG(mask) runtime_flags &= ~mask Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnphttp.c =================================================================== --- a/upnphttp.c +++ b/upnphttp.c @@ -749,6 +749,10 @@ ProcessHttpQuery_upnphttp(struct upnphtt char * (* f)(int *); } path_desc[] = { { ROOTDESC_PATH, genRootDesc}, +#ifdef ENABLE_WSC_SERVICE + { WFA_ROOTDESC_PATH, genWSCRootDesc}, + { WSC_PATH, genWSC}, +#endif { WANIPC_PATH, genWANIPCn}, { WANCFG_PATH, genWANCfg}, #ifdef HAS_DUMMY_SERVICE Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnphttp.h =================================================================== --- a/upnphttp.h +++ b/upnphttp.h @@ -18,11 +18,19 @@ #include #endif /* ENABLE_HTTPS */ +#ifdef ENABLE_WSC_SERVICE +#include "wsc/wsc_upnp.h" +#endif + #define UPNP_VERSION_STRING "UPnP/" UPNP_VERSION_MAJOR_STR "." UPNP_VERSION_MINOR_STR /* server: HTTP header returned in all HTTP responses : */ #define MINIUPNPD_SERVER_STRING OS_VERSION " " UPNP_VERSION_STRING " MiniUPnPd/" MINIUPNPD_VERSION +#ifdef ENABLE_WSC_SERVICE +struct upnpDevice wscLocalDevice; // The data structure used the save the local Wsc UPnP Device. +#endif + /* states : 0 - waiting for data to read @@ -34,7 +42,10 @@ enum httpStates { EWaitingForHttpRequest = 0, EWaitingForHttpContent, ESendingContinue, - ESendingAndClosing, + ESendingAndClosing, +#ifdef ENABLE_WSC_SERVICE + DO_NOTHING_IN_MAIN_LOOP, +#endif EToDelete = 100 }; Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpsoap.c =================================================================== --- a/upnpsoap.c +++ b/upnpsoap.c @@ -45,7 +45,10 @@ static int is_numeric(const char * s) return 1; } -static void +#ifndef ENABLE_WSC_SERVICE +static +#endif +void BuildSendAndCloseSoapResp(struct upnphttp * h, const char * body, int bodylen) { @@ -2137,6 +2140,31 @@ GetPinholePackets(struct upnphttp * h, c } #endif +#ifdef ENABLE_WSC_SERVICE +static const struct +{ + const char * methodName; + int (*methodImpl)(IN struct upnphttp *, IN uint32, OUT IXML_Document *, OUT char **); +} +soapActions[] = +{ + { "GetDeviceInfo", WscDevGetDeviceInfo}, + { "PutMessage", WscDevPutMessage}, + { "GetAPSettings", WscDevGetAPSettings}, + { "SetAPSettings", WscDevSetAPSettings}, + { "DelAPSettings", WscDevDelAPSettings}, + { "GetSTASettings", WscDevGetSTASettings}, + { "SetSTASettings", WscDevSetSTASettings}, + { "PutWLANResponse", WscDevPutWLANResponse}, + { "RebootAP", WscDevRebootAP}, + { "ResetAP", WscDevResetAP}, + { "RebootSTA", WscDevRebootSTA}, + { "ResetSTA", WscDevResetSTA}, + { "SetSelectedRegistrar", WscDevSetSelectedRegistrar}, + { 0, 0 } +}; +#endif /* ENABLE_WSC_SERVICE */ + #ifdef ENABLE_DP_SERVICE static void SendSetupMessage(struct upnphttp * h, const char * action, const char * ns) @@ -2310,9 +2338,33 @@ ExecuteSoapAction(struct upnphttp * h, c int i, len, methodlen; char namespace[256]; +#ifdef ENABLE_WSC_SERVICE + char *error_string = NULL; + int retCode = -1; + int pos=0; +#endif /* ENABLE_WSC_SERVICE */ + /* SoapAction example : * urn:schemas-upnp-org:service:WANIPConnection:1#GetStatusInfo */ p = strchr(action, '#'); + +#ifdef RT_DEBUG + if (p == NULL) + { + printf("\n------h->req_soapActionLen = %d------\n", h->req_soapActionLen); + } +#endif + +#ifdef ENABLE_WSC_SERVICE + /* fix a bug about extracting out the action handler name */ + /* skip string terminator while extracting */ + while (p == NULL) + { + ++pos; + p = strchr(&action[pos], '#'); + } +#endif /* ENABLE_WSC_SERVICE */ + if(p && (p - action) < n) { for(i = 0; i < ((int)sizeof(namespace) - 1) && (action + i) < p; i++) namespace[i] = action[i]; @@ -2336,6 +2388,33 @@ ExecuteSoapAction(struct upnphttp * h, c return; } } + +#ifdef ENABLE_WSC_SERVICE + if (GETFLAG(ENABLEWPSMASK)) + { + i=0; + while(soapActions[i].methodName) + { + len = strlen(soapActions[i].methodName); + if(strncmp(p, soapActions[i].methodName, len) == 0) + { + + IXML_Document resp_node = NULL; + + retCode = soapActions[i].methodImpl(h, + h->clientaddr.s_addr, &resp_node, &error_string); + + if ((error_string) == NULL) + { + ASSERT(retCode == 0); + } + + return; + } + i++; + } + } +#endif /* ENABLE_WSC_SERVICE */ syslog(LOG_NOTICE, "SoapMethod: Unknown: %.*s %s", methodlen, p, namespace); } else { syslog(LOG_NOTICE, "cannot parse SoapAction"); Index: lede/build_dir/target-aarch64_cortex-a53_musl/miniupnpd-2.2.1/upnpsoap.h =================================================================== --- a/upnpsoap.h +++ b/upnpsoap.h @@ -19,5 +19,89 @@ ExecuteSoapAction(struct upnphttp *, con void SoapError(struct upnphttp * h, int errCode, const char * errDesc); +#ifdef ENABLE_WSC_SERVICE +#include "wsc/wsc_common.h" +#include "wsc/wsc_msg.h" + +extern int +WscDevGetAPSettings( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString ); +extern int +WscDevGetSTASettings( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevSetAPSettings( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevDelAPSettings( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevSetSTASettings( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevRebootAP( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevResetAP( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevRebootSTA( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevResetSTA( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevSetSelectedRegistrar( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevPutWLANResponse( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevPutMessage( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +extern int +WscDevGetDeviceInfo( + IN struct upnphttp * h, + IN uint32 ipAddr, + OUT IXML_Document * out, + OUT char **errorString); +#endif /* ENABLE_WSC_SERVICE */ + #endif