1 /* $Id: upnpcommands.c,v 1.38 2012/03/05 19:42:47 nanard Exp $ */
3 * Author : Thomas Bernard
4 * Copyright (c) 2005-2011 Thomas Bernard
5 * This software is subject to the conditions detailed in the
6 * LICENCE file provided in this distribution.
11 #include "upnpcommands.h"
12 #include "miniupnpc.h"
13 #include "portlistingparse.h"
15 static UNSIGNED_INTEGER
16 my_atoui(const char * s
)
18 return s
? ((UNSIGNED_INTEGER
)STRTOUI(s
, NULL
, 0)) : 0;
23 LIBSPEC UNSIGNED_INTEGER
24 UPNP_GetTotalBytesSent(const char * controlURL
,
25 const char * servicetype
)
27 struct NameValueParserData pdata
;
32 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
33 "GetTotalBytesSent", 0, &bufsize
))) {
34 return UPNPCOMMAND_HTTP_ERROR
;
36 ParseNameValue(buffer
, bufsize
, &pdata
);
37 /*DisplayNameValueList(buffer, bufsize);*/
38 free(buffer
); buffer
= NULL
;
39 p
= GetValueFromNameValueList(&pdata
, "NewTotalBytesSent");
41 ClearNameValueList(&pdata
);
47 LIBSPEC UNSIGNED_INTEGER
48 UPNP_GetTotalBytesReceived(const char * controlURL
,
49 const char * servicetype
)
51 struct NameValueParserData pdata
;
56 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
57 "GetTotalBytesReceived", 0, &bufsize
))) {
58 return UPNPCOMMAND_HTTP_ERROR
;
60 ParseNameValue(buffer
, bufsize
, &pdata
);
61 /*DisplayNameValueList(buffer, bufsize);*/
62 free(buffer
); buffer
= NULL
;
63 p
= GetValueFromNameValueList(&pdata
, "NewTotalBytesReceived");
65 ClearNameValueList(&pdata
);
71 LIBSPEC UNSIGNED_INTEGER
72 UPNP_GetTotalPacketsSent(const char * controlURL
,
73 const char * servicetype
)
75 struct NameValueParserData pdata
;
80 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
81 "GetTotalPacketsSent", 0, &bufsize
))) {
82 return UPNPCOMMAND_HTTP_ERROR
;
84 ParseNameValue(buffer
, bufsize
, &pdata
);
85 /*DisplayNameValueList(buffer, bufsize);*/
86 free(buffer
); buffer
= NULL
;
87 p
= GetValueFromNameValueList(&pdata
, "NewTotalPacketsSent");
89 ClearNameValueList(&pdata
);
95 LIBSPEC UNSIGNED_INTEGER
96 UPNP_GetTotalPacketsReceived(const char * controlURL
,
97 const char * servicetype
)
99 struct NameValueParserData pdata
;
104 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
105 "GetTotalPacketsReceived", 0, &bufsize
))) {
106 return UPNPCOMMAND_HTTP_ERROR
;
108 ParseNameValue(buffer
, bufsize
, &pdata
);
109 /*DisplayNameValueList(buffer, bufsize);*/
110 free(buffer
); buffer
= NULL
;
111 p
= GetValueFromNameValueList(&pdata
, "NewTotalPacketsReceived");
113 ClearNameValueList(&pdata
);
117 /* UPNP_GetStatusInfo() call the corresponding UPNP method
118 * returns the current status and uptime */
120 UPNP_GetStatusInfo(const char * controlURL
,
121 const char * servicetype
,
123 unsigned int * uptime
,
124 char * lastconnerror
)
126 struct NameValueParserData pdata
;
132 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
134 if(!status
&& !uptime
)
135 return UPNPCOMMAND_INVALID_ARGS
;
137 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
138 "GetStatusInfo", 0, &bufsize
))) {
139 return UPNPCOMMAND_HTTP_ERROR
;
141 ParseNameValue(buffer
, bufsize
, &pdata
);
142 /*DisplayNameValueList(buffer, bufsize);*/
143 free(buffer
); buffer
= NULL
;
144 up
= GetValueFromNameValueList(&pdata
, "NewUptime");
145 p
= GetValueFromNameValueList(&pdata
, "NewConnectionStatus");
146 err
= GetValueFromNameValueList(&pdata
, "NewLastConnectionError");
148 ret
= UPNPCOMMAND_SUCCESS
;
152 strncpy(status
, p
, 64 );
160 sscanf(up
,"%u",uptime
);
167 strncpy(lastconnerror
, err
, 64 );
168 lastconnerror
[63] = '\0';
170 lastconnerror
[0] = '\0';
173 p
= GetValueFromNameValueList(&pdata
, "errorCode");
175 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
176 sscanf(p
, "%d", &ret
);
178 ClearNameValueList(&pdata
);
182 /* UPNP_GetConnectionTypeInfo() call the corresponding UPNP method
183 * returns the connection type */
185 UPNP_GetConnectionTypeInfo(const char * controlURL
,
186 const char * servicetype
,
187 char * connectionType
)
189 struct NameValueParserData pdata
;
193 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
196 return UPNPCOMMAND_INVALID_ARGS
;
198 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
199 "GetConnectionTypeInfo", 0, &bufsize
))) {
200 return UPNPCOMMAND_HTTP_ERROR
;
202 ParseNameValue(buffer
, bufsize
, &pdata
);
203 free(buffer
); buffer
= NULL
;
204 p
= GetValueFromNameValueList(&pdata
, "NewConnectionType");
205 /*p = GetValueFromNameValueList(&pdata, "NewPossibleConnectionTypes");*/
206 /* PossibleConnectionTypes will have several values.... */
208 strncpy(connectionType
, p
, 64 );
209 connectionType
[63] = '\0';
210 ret
= UPNPCOMMAND_SUCCESS
;
212 connectionType
[0] = '\0';
213 p
= GetValueFromNameValueList(&pdata
, "errorCode");
215 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
216 sscanf(p
, "%d", &ret
);
218 ClearNameValueList(&pdata
);
222 /* UPNP_GetLinkLayerMaxBitRate() call the corresponding UPNP method.
223 * Returns 2 values: Downloadlink bandwidth and Uplink bandwidth.
224 * One of the values can be null
225 * Note : GetLinkLayerMaxBitRates belongs to WANPPPConnection:1 only
226 * We can use the GetCommonLinkProperties from WANCommonInterfaceConfig:1 */
228 UPNP_GetLinkLayerMaxBitRates(const char * controlURL
,
229 const char * servicetype
,
230 unsigned int * bitrateDown
,
231 unsigned int * bitrateUp
)
233 struct NameValueParserData pdata
;
236 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
241 if(!bitrateDown
&& !bitrateUp
)
242 return UPNPCOMMAND_INVALID_ARGS
;
244 /* shouldn't we use GetCommonLinkProperties ? */
245 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
246 "GetCommonLinkProperties", 0, &bufsize
))) {
247 /*"GetLinkLayerMaxBitRates", 0, &bufsize);*/
248 return UPNPCOMMAND_HTTP_ERROR
;
250 /*DisplayNameValueList(buffer, bufsize);*/
251 ParseNameValue(buffer
, bufsize
, &pdata
);
252 free(buffer
); buffer
= NULL
;
253 /*down = GetValueFromNameValueList(&pdata, "NewDownstreamMaxBitRate");*/
254 /*up = GetValueFromNameValueList(&pdata, "NewUpstreamMaxBitRate");*/
255 down
= GetValueFromNameValueList(&pdata
, "NewLayer1DownstreamMaxBitRate");
256 up
= GetValueFromNameValueList(&pdata
, "NewLayer1UpstreamMaxBitRate");
257 /*GetValueFromNameValueList(&pdata, "NewWANAccessType");*/
258 /*GetValueFromNameValueList(&pdata, "NewPhysicalLinkStatus");*/
260 ret
= UPNPCOMMAND_SUCCESS
;
264 sscanf(down
,"%u",bitrateDown
);
271 sscanf(up
,"%u",bitrateUp
);
275 p
= GetValueFromNameValueList(&pdata
, "errorCode");
277 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
278 sscanf(p
, "%d", &ret
);
280 ClearNameValueList(&pdata
);
285 /* UPNP_GetExternalIPAddress() call the corresponding UPNP method.
286 * if the third arg is not null the value is copied to it.
287 * at least 16 bytes must be available
291 * NON ZERO : ERROR Either an UPnP error code or an unknown error.
293 * 402 Invalid Args - See UPnP Device Architecture section on Control.
294 * 501 Action Failed - See UPnP Device Architecture section on Control.
297 UPNP_GetExternalIPAddress(const char * controlURL
,
298 const char * servicetype
,
301 struct NameValueParserData pdata
;
305 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
307 if(!extIpAdd
|| !controlURL
|| !servicetype
)
308 return UPNPCOMMAND_INVALID_ARGS
;
310 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
311 "GetExternalIPAddress", 0, &bufsize
))) {
312 return UPNPCOMMAND_HTTP_ERROR
;
314 /*DisplayNameValueList(buffer, bufsize);*/
315 ParseNameValue(buffer
, bufsize
, &pdata
);
316 free(buffer
); buffer
= NULL
;
317 /*printf("external ip = %s\n", GetValueFromNameValueList(&pdata, "NewExternalIPAddress") );*/
318 p
= GetValueFromNameValueList(&pdata
, "NewExternalIPAddress");
320 strncpy(extIpAdd
, p
, 16 );
322 ret
= UPNPCOMMAND_SUCCESS
;
326 p
= GetValueFromNameValueList(&pdata
, "errorCode");
328 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
329 sscanf(p
, "%d", &ret
);
332 ClearNameValueList(&pdata
);
337 UPNP_AddPortMapping(const char * controlURL
, const char * servicetype
,
338 const char * extPort
,
340 const char * inClient
,
343 const char * remoteHost
,
344 const char * leaseDuration
)
346 struct UPNParg
* AddPortMappingArgs
;
349 struct NameValueParserData pdata
;
353 if(!inPort
|| !inClient
|| !proto
|| !extPort
)
354 return UPNPCOMMAND_INVALID_ARGS
;
356 AddPortMappingArgs
= calloc(9, sizeof(struct UPNParg
));
357 AddPortMappingArgs
[0].elt
= "NewRemoteHost";
358 AddPortMappingArgs
[0].val
= remoteHost
;
359 AddPortMappingArgs
[1].elt
= "NewExternalPort";
360 AddPortMappingArgs
[1].val
= extPort
;
361 AddPortMappingArgs
[2].elt
= "NewProtocol";
362 AddPortMappingArgs
[2].val
= proto
;
363 AddPortMappingArgs
[3].elt
= "NewInternalPort";
364 AddPortMappingArgs
[3].val
= inPort
;
365 AddPortMappingArgs
[4].elt
= "NewInternalClient";
366 AddPortMappingArgs
[4].val
= inClient
;
367 AddPortMappingArgs
[5].elt
= "NewEnabled";
368 AddPortMappingArgs
[5].val
= "1";
369 AddPortMappingArgs
[6].elt
= "NewPortMappingDescription";
370 AddPortMappingArgs
[6].val
= desc
?desc
:"libminiupnpc";
371 AddPortMappingArgs
[7].elt
= "NewLeaseDuration";
372 AddPortMappingArgs
[7].val
= leaseDuration
?leaseDuration
:"0";
373 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
374 "AddPortMapping", AddPortMappingArgs
,
376 free(AddPortMappingArgs
);
377 return UPNPCOMMAND_HTTP_ERROR
;
379 /*DisplayNameValueList(buffer, bufsize);*/
380 /*buffer[bufsize] = '\0';*/
382 ParseNameValue(buffer
, bufsize
, &pdata
);
383 free(buffer
); buffer
= NULL
;
384 resVal
= GetValueFromNameValueList(&pdata
, "errorCode");
386 /*printf("AddPortMapping errorCode = '%s'\n", resVal); */
387 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
388 sscanf(resVal
, "%d", &ret
);
390 ret
= UPNPCOMMAND_SUCCESS
;
392 ClearNameValueList(&pdata
);
393 free(AddPortMappingArgs
);
398 UPNP_DeletePortMapping(const char * controlURL
, const char * servicetype
,
399 const char * extPort
, const char * proto
,
400 const char * remoteHost
)
402 /*struct NameValueParserData pdata;*/
403 struct UPNParg
* DeletePortMappingArgs
;
406 struct NameValueParserData pdata
;
410 if(!extPort
|| !proto
)
411 return UPNPCOMMAND_INVALID_ARGS
;
413 DeletePortMappingArgs
= calloc(4, sizeof(struct UPNParg
));
414 DeletePortMappingArgs
[0].elt
= "NewRemoteHost";
415 DeletePortMappingArgs
[0].val
= remoteHost
;
416 DeletePortMappingArgs
[1].elt
= "NewExternalPort";
417 DeletePortMappingArgs
[1].val
= extPort
;
418 DeletePortMappingArgs
[2].elt
= "NewProtocol";
419 DeletePortMappingArgs
[2].val
= proto
;
420 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
422 DeletePortMappingArgs
, &bufsize
))) {
423 free(DeletePortMappingArgs
);
424 return UPNPCOMMAND_HTTP_ERROR
;
426 /*DisplayNameValueList(buffer, bufsize);*/
427 ParseNameValue(buffer
, bufsize
, &pdata
);
428 free(buffer
); buffer
= NULL
;
429 resVal
= GetValueFromNameValueList(&pdata
, "errorCode");
431 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
432 sscanf(resVal
, "%d", &ret
);
434 ret
= UPNPCOMMAND_SUCCESS
;
436 ClearNameValueList(&pdata
);
437 free(DeletePortMappingArgs
);
442 UPNP_GetGenericPortMappingEntry(const char * controlURL
,
443 const char * servicetype
,
454 struct NameValueParserData pdata
;
455 struct UPNParg
* GetPortMappingArgs
;
459 int r
= UPNPCOMMAND_UNKNOWN_ERROR
;
461 return UPNPCOMMAND_INVALID_ARGS
;
464 GetPortMappingArgs
= calloc(2, sizeof(struct UPNParg
));
465 GetPortMappingArgs
[0].elt
= "NewPortMappingIndex";
466 GetPortMappingArgs
[0].val
= index
;
467 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
468 "GetGenericPortMappingEntry",
469 GetPortMappingArgs
, &bufsize
))) {
470 free(GetPortMappingArgs
);
471 return UPNPCOMMAND_HTTP_ERROR
;
473 ParseNameValue(buffer
, bufsize
, &pdata
);
474 free(buffer
); buffer
= NULL
;
476 p
= GetValueFromNameValueList(&pdata
, "NewRemoteHost");
479 strncpy(rHost
, p
, 64);
482 p
= GetValueFromNameValueList(&pdata
, "NewExternalPort");
485 strncpy(extPort
, p
, 6);
487 r
= UPNPCOMMAND_SUCCESS
;
489 p
= GetValueFromNameValueList(&pdata
, "NewProtocol");
492 strncpy(protocol
, p
, 4);
495 p
= GetValueFromNameValueList(&pdata
, "NewInternalClient");
498 strncpy(intClient
, p
, 16);
499 intClient
[15] = '\0';
502 p
= GetValueFromNameValueList(&pdata
, "NewInternalPort");
505 strncpy(intPort
, p
, 6);
508 p
= GetValueFromNameValueList(&pdata
, "NewEnabled");
511 strncpy(enabled
, p
, 4);
514 p
= GetValueFromNameValueList(&pdata
, "NewPortMappingDescription");
517 strncpy(desc
, p
, 80);
520 p
= GetValueFromNameValueList(&pdata
, "NewLeaseDuration");
523 strncpy(duration
, p
, 16);
526 p
= GetValueFromNameValueList(&pdata
, "errorCode");
528 r
= UPNPCOMMAND_UNKNOWN_ERROR
;
531 ClearNameValueList(&pdata
);
532 free(GetPortMappingArgs
);
537 UPNP_GetPortMappingNumberOfEntries(const char * controlURL
,
538 const char * servicetype
,
539 unsigned int * numEntries
)
541 struct NameValueParserData pdata
;
545 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
546 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
547 "GetPortMappingNumberOfEntries", 0,
549 return UPNPCOMMAND_HTTP_ERROR
;
552 DisplayNameValueList(buffer
, bufsize
);
554 ParseNameValue(buffer
, bufsize
, &pdata
);
555 free(buffer
); buffer
= NULL
;
557 p
= GetValueFromNameValueList(&pdata
, "NewPortMappingNumberOfEntries");
558 if(numEntries
&& p
) {
560 sscanf(p
, "%u", numEntries
);
561 ret
= UPNPCOMMAND_SUCCESS
;
564 p
= GetValueFromNameValueList(&pdata
, "errorCode");
566 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
567 sscanf(p
, "%d", &ret
);
570 ClearNameValueList(&pdata
);
574 /* UPNP_GetSpecificPortMappingEntry retrieves an existing port mapping
575 * the result is returned in the intClient and intPort strings
576 * please provide 16 and 6 bytes of data */
578 UPNP_GetSpecificPortMappingEntry(const char * controlURL
,
579 const char * servicetype
,
580 const char * extPort
,
586 char * leaseDuration
)
588 struct NameValueParserData pdata
;
589 struct UPNParg
* GetPortMappingArgs
;
593 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
595 if(!intPort
|| !intClient
|| !extPort
|| !proto
)
596 return UPNPCOMMAND_INVALID_ARGS
;
598 GetPortMappingArgs
= calloc(4, sizeof(struct UPNParg
));
599 GetPortMappingArgs
[0].elt
= "NewRemoteHost";
600 /* TODO : add remote host ? */
601 GetPortMappingArgs
[1].elt
= "NewExternalPort";
602 GetPortMappingArgs
[1].val
= extPort
;
603 GetPortMappingArgs
[2].elt
= "NewProtocol";
604 GetPortMappingArgs
[2].val
= proto
;
605 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
606 "GetSpecificPortMappingEntry",
607 GetPortMappingArgs
, &bufsize
))) {
608 free(GetPortMappingArgs
);
609 return UPNPCOMMAND_HTTP_ERROR
;
611 /*DisplayNameValueList(buffer, bufsize);*/
612 ParseNameValue(buffer
, bufsize
, &pdata
);
613 free(buffer
); buffer
= NULL
;
615 p
= GetValueFromNameValueList(&pdata
, "NewInternalClient");
617 strncpy(intClient
, p
, 16);
618 intClient
[15] = '\0';
619 ret
= UPNPCOMMAND_SUCCESS
;
623 p
= GetValueFromNameValueList(&pdata
, "NewInternalPort");
625 strncpy(intPort
, p
, 6);
630 p
= GetValueFromNameValueList(&pdata
, "NewEnabled");
632 strncpy(enabled
, p
, 4);
636 p
= GetValueFromNameValueList(&pdata
, "NewPortMappingDescription");
638 strncpy(desc
, p
, 80);
642 p
= GetValueFromNameValueList(&pdata
, "NewLeaseDuration");
643 if(p
&& leaseDuration
)
645 strncpy(leaseDuration
, p
, 16);
646 leaseDuration
[15] = '\0';
649 p
= GetValueFromNameValueList(&pdata
, "errorCode");
651 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
652 sscanf(p
, "%d", &ret
);
655 ClearNameValueList(&pdata
);
656 free(GetPortMappingArgs
);
660 /* UPNP_GetListOfPortMappings()
662 * Possible UPNP Error codes :
663 * 606 Action not Authorized
664 * 730 PortMappingNotFound - no port mapping is found in the specified range.
665 * 733 InconsistantParameters - NewStartPort and NewEndPort values are not
669 UPNP_GetListOfPortMappings(const char * controlURL
,
670 const char * servicetype
,
671 const char * startPort
,
672 const char * endPort
,
673 const char * protocol
,
674 const char * numberOfPorts
,
675 struct PortMappingParserData
* data
)
677 struct NameValueParserData pdata
;
678 struct UPNParg
* GetListOfPortMappingsArgs
;
682 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
684 if(!startPort
|| !endPort
|| !protocol
)
685 return UPNPCOMMAND_INVALID_ARGS
;
687 GetListOfPortMappingsArgs
= calloc(6, sizeof(struct UPNParg
));
688 GetListOfPortMappingsArgs
[0].elt
= "NewStartPort";
689 GetListOfPortMappingsArgs
[0].val
= startPort
;
690 GetListOfPortMappingsArgs
[1].elt
= "NewEndPort";
691 GetListOfPortMappingsArgs
[1].val
= endPort
;
692 GetListOfPortMappingsArgs
[2].elt
= "NewProtocol";
693 GetListOfPortMappingsArgs
[2].val
= protocol
;
694 GetListOfPortMappingsArgs
[3].elt
= "NewManage";
695 GetListOfPortMappingsArgs
[3].val
= "1";
696 GetListOfPortMappingsArgs
[4].elt
= "NewNumberOfPorts";
697 GetListOfPortMappingsArgs
[4].val
= numberOfPorts
?numberOfPorts
:"1000";
699 if(!(buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
700 "GetListOfPortMappings",
701 GetListOfPortMappingsArgs
, &bufsize
))) {
702 free(GetListOfPortMappingsArgs
);
703 return UPNPCOMMAND_HTTP_ERROR
;
705 free(GetListOfPortMappingsArgs
);
707 /*DisplayNameValueList(buffer, bufsize);*/
708 ParseNameValue(buffer
, bufsize
, &pdata
);
709 free(buffer
); buffer
= NULL
;
711 /*p = GetValueFromNameValueList(&pdata, "NewPortListing");*/
713 printf("NewPortListing : %s\n", p);
715 /*printf("NewPortListing(%d chars) : %s\n",
716 pdata.portListingLength, pdata.portListing);*/
717 if(pdata
.portListing
)
719 /*struct PortMapping * pm;
721 ParsePortListing(pdata
.portListing
, pdata
.portListingLength
,
723 ret
= UPNPCOMMAND_SUCCESS
;
725 for(pm = data->head.lh_first; pm != NULL; pm = pm->entries.le_next)
727 printf("%2d %s %5hu->%s:%-5hu '%s' '%s'\n",
728 i, pm->protocol, pm->externalPort, pm->internalClient,
730 pm->description, pm->remoteHost);
734 /*FreePortListing(&data);*/
737 p
= GetValueFromNameValueList(&pdata
, "errorCode");
739 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
740 sscanf(p
, "%d", &ret
);
742 ClearNameValueList(&pdata
);
744 //printf("%.*s", bufsize, buffer);
749 /* IGD:2, functions for service WANIPv6FirewallControl:1 */
751 UPNP_GetFirewallStatus(const char * controlURL
,
752 const char * servicetype
,
753 int * firewallEnabled
,
754 int * inboundPinholeAllowed
)
756 struct NameValueParserData pdata
;
760 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
762 if(!firewallEnabled
&& !inboundPinholeAllowed
)
763 return UPNPCOMMAND_INVALID_ARGS
;
765 buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
766 "GetFirewallStatus", 0, &bufsize
);
768 return UPNPCOMMAND_HTTP_ERROR
;
770 ParseNameValue(buffer
, bufsize
, &pdata
);
771 free(buffer
); buffer
= NULL
;
772 fe
= GetValueFromNameValueList(&pdata
, "FirewallEnabled");
773 ipa
= GetValueFromNameValueList(&pdata
, "InboundPinholeAllowed");
775 ret
= UPNPCOMMAND_SUCCESS
;
777 *firewallEnabled
= my_atoui(fe
);
779 *firewallEnabled = 0;*/
781 *inboundPinholeAllowed
= my_atoui(ipa
);
783 *inboundPinholeAllowed = 0;*/
784 p
= GetValueFromNameValueList(&pdata
, "errorCode");
787 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
788 sscanf(p
, "%d", &ret
);
790 ClearNameValueList(&pdata
);
795 UPNP_GetOutboundPinholeTimeout(const char * controlURL
, const char * servicetype
,
796 const char * remoteHost
,
797 const char * remotePort
,
798 const char * intClient
,
799 const char * intPort
,
803 struct UPNParg
* GetOutboundPinholeTimeoutArgs
;
806 struct NameValueParserData pdata
;
811 if(!intPort
|| !intClient
|| !proto
|| !remotePort
|| !remoteHost
)
812 return UPNPCOMMAND_INVALID_ARGS
;
814 GetOutboundPinholeTimeoutArgs
= calloc(6, sizeof(struct UPNParg
));
815 GetOutboundPinholeTimeoutArgs
[0].elt
= "RemoteHost";
816 GetOutboundPinholeTimeoutArgs
[0].val
= remoteHost
;
817 GetOutboundPinholeTimeoutArgs
[1].elt
= "RemotePort";
818 GetOutboundPinholeTimeoutArgs
[1].val
= remotePort
;
819 GetOutboundPinholeTimeoutArgs
[2].elt
= "Protocol";
820 GetOutboundPinholeTimeoutArgs
[2].val
= proto
;
821 GetOutboundPinholeTimeoutArgs
[3].elt
= "InternalPort";
822 GetOutboundPinholeTimeoutArgs
[3].val
= intPort
;
823 GetOutboundPinholeTimeoutArgs
[4].elt
= "InternalClient";
824 GetOutboundPinholeTimeoutArgs
[4].val
= intClient
;
825 buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
826 "GetOutboundPinholeTimeout", GetOutboundPinholeTimeoutArgs
, &bufsize
);
828 return UPNPCOMMAND_HTTP_ERROR
;
829 ParseNameValue(buffer
, bufsize
, &pdata
);
830 free(buffer
); buffer
= NULL
;
831 resVal
= GetValueFromNameValueList(&pdata
, "errorCode");
834 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
835 sscanf(resVal
, "%d", &ret
);
839 ret
= UPNPCOMMAND_SUCCESS
;
840 p
= GetValueFromNameValueList(&pdata
, "OutboundPinholeTimeout");
842 *opTimeout
= my_atoui(p
);
844 ClearNameValueList(&pdata
);
845 free(GetOutboundPinholeTimeoutArgs
);
850 UPNP_AddPinhole(const char * controlURL
, const char * servicetype
,
851 const char * remoteHost
,
852 const char * remotePort
,
853 const char * intClient
,
854 const char * intPort
,
856 const char * leaseTime
,
859 struct UPNParg
* AddPinholeArgs
;
862 struct NameValueParserData pdata
;
867 if(!intPort
|| !intClient
|| !proto
|| !remoteHost
|| !remotePort
|| !leaseTime
)
868 return UPNPCOMMAND_INVALID_ARGS
;
870 AddPinholeArgs
= calloc(7, sizeof(struct UPNParg
));
871 // RemoteHost can be wilcarded
872 if(strncmp(remoteHost
, "empty", 5)==0)
874 AddPinholeArgs
[0].elt
= "RemoteHost";
875 AddPinholeArgs
[0].val
= "";
879 AddPinholeArgs
[0].elt
= "RemoteHost";
880 AddPinholeArgs
[0].val
= remoteHost
;
882 AddPinholeArgs
[1].elt
= "RemotePort";
883 AddPinholeArgs
[1].val
= remotePort
;
884 AddPinholeArgs
[2].elt
= "Protocol";
885 AddPinholeArgs
[2].val
= proto
;
886 AddPinholeArgs
[3].elt
= "InternalPort";
887 AddPinholeArgs
[3].val
= intPort
;
888 if(strncmp(intClient
, "empty", 5)==0)
890 AddPinholeArgs
[4].elt
= "InternalClient";
891 AddPinholeArgs
[4].val
= "";
895 AddPinholeArgs
[4].elt
= "InternalClient";
896 AddPinholeArgs
[4].val
= intClient
;
898 AddPinholeArgs
[5].elt
= "LeaseTime";
899 AddPinholeArgs
[5].val
= leaseTime
;
900 buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
901 "AddPinhole", AddPinholeArgs
, &bufsize
);
903 return UPNPCOMMAND_HTTP_ERROR
;
904 ParseNameValue(buffer
, bufsize
, &pdata
);
905 free(buffer
); buffer
= NULL
;
906 p
= GetValueFromNameValueList(&pdata
, "UniqueID");
909 strncpy(uniqueID
, p
, 8);
912 resVal
= GetValueFromNameValueList(&pdata
, "errorCode");
915 //printf("AddPortMapping errorCode = '%s'\n", resVal);
916 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
917 sscanf(resVal
, "%d", &ret
);
921 ret
= UPNPCOMMAND_SUCCESS
;
923 ClearNameValueList(&pdata
);
924 free(AddPinholeArgs
);
929 UPNP_UpdatePinhole(const char * controlURL
, const char * servicetype
,
930 const char * uniqueID
,
931 const char * leaseTime
)
933 struct UPNParg
* UpdatePinholeArgs
;
936 struct NameValueParserData pdata
;
940 if(!uniqueID
|| !leaseTime
)
941 return UPNPCOMMAND_INVALID_ARGS
;
943 UpdatePinholeArgs
= calloc(3, sizeof(struct UPNParg
));
944 UpdatePinholeArgs
[0].elt
= "UniqueID";
945 UpdatePinholeArgs
[0].val
= uniqueID
;
946 UpdatePinholeArgs
[1].elt
= "NewLeaseTime";
947 UpdatePinholeArgs
[1].val
= leaseTime
;
948 buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
949 "UpdatePinhole", UpdatePinholeArgs
, &bufsize
);
951 return UPNPCOMMAND_HTTP_ERROR
;
952 ParseNameValue(buffer
, bufsize
, &pdata
);
953 free(buffer
); buffer
= NULL
;
954 resVal
= GetValueFromNameValueList(&pdata
, "errorCode");
957 /*printf("AddPortMapping errorCode = '%s'\n", resVal); */
958 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
959 sscanf(resVal
, "%d", &ret
);
963 ret
= UPNPCOMMAND_SUCCESS
;
965 ClearNameValueList(&pdata
);
966 free(UpdatePinholeArgs
);
971 UPNP_DeletePinhole(const char * controlURL
, const char * servicetype
, const char * uniqueID
)
973 /*struct NameValueParserData pdata;*/
974 struct UPNParg
* DeletePinholeArgs
;
977 struct NameValueParserData pdata
;
982 return UPNPCOMMAND_INVALID_ARGS
;
984 DeletePinholeArgs
= calloc(2, sizeof(struct UPNParg
));
985 DeletePinholeArgs
[0].elt
= "UniqueID";
986 DeletePinholeArgs
[0].val
= uniqueID
;
987 buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
988 "DeletePinhole", DeletePinholeArgs
, &bufsize
);
990 return UPNPCOMMAND_HTTP_ERROR
;
991 /*DisplayNameValueList(buffer, bufsize);*/
992 ParseNameValue(buffer
, bufsize
, &pdata
);
993 free(buffer
); buffer
= NULL
;
994 resVal
= GetValueFromNameValueList(&pdata
, "errorCode");
997 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
998 sscanf(resVal
, "%d", &ret
);
1002 ret
= UPNPCOMMAND_SUCCESS
;
1004 ClearNameValueList(&pdata
);
1005 free(DeletePinholeArgs
);
1010 UPNP_CheckPinholeWorking(const char * controlURL
, const char * servicetype
,
1011 const char * uniqueID
, int * isWorking
)
1013 struct NameValueParserData pdata
;
1014 struct UPNParg
* CheckPinholeWorkingArgs
;
1018 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
1021 return UPNPCOMMAND_INVALID_ARGS
;
1023 CheckPinholeWorkingArgs
= calloc(4, sizeof(struct UPNParg
));
1024 CheckPinholeWorkingArgs
[0].elt
= "UniqueID";
1025 CheckPinholeWorkingArgs
[0].val
= uniqueID
;
1026 buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
1027 "CheckPinholeWorking", CheckPinholeWorkingArgs
, &bufsize
);
1029 return UPNPCOMMAND_HTTP_ERROR
;
1030 ParseNameValue(buffer
, bufsize
, &pdata
);
1031 free(buffer
); buffer
= NULL
;
1033 p
= GetValueFromNameValueList(&pdata
, "IsWorking");
1036 *isWorking
=my_atoui(p
);
1037 ret
= UPNPCOMMAND_SUCCESS
;
1042 p
= GetValueFromNameValueList(&pdata
, "errorCode");
1045 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
1046 sscanf(p
, "%d", &ret
);
1049 ClearNameValueList(&pdata
);
1050 free(CheckPinholeWorkingArgs
);
1055 UPNP_GetPinholePackets(const char * controlURL
, const char * servicetype
,
1056 const char * uniqueID
, int * packets
)
1058 struct NameValueParserData pdata
;
1059 struct UPNParg
* GetPinholePacketsArgs
;
1063 int ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
1066 return UPNPCOMMAND_INVALID_ARGS
;
1068 GetPinholePacketsArgs
= calloc(4, sizeof(struct UPNParg
));
1069 GetPinholePacketsArgs
[0].elt
= "UniqueID";
1070 GetPinholePacketsArgs
[0].val
= uniqueID
;
1071 buffer
= simpleUPnPcommand(-1, controlURL
, servicetype
,
1072 "GetPinholePackets", GetPinholePacketsArgs
, &bufsize
);
1074 return UPNPCOMMAND_HTTP_ERROR
;
1075 ParseNameValue(buffer
, bufsize
, &pdata
);
1076 free(buffer
); buffer
= NULL
;
1078 p
= GetValueFromNameValueList(&pdata
, "PinholePackets");
1081 *packets
=my_atoui(p
);
1082 ret
= UPNPCOMMAND_SUCCESS
;
1085 p
= GetValueFromNameValueList(&pdata
, "errorCode");
1088 ret
= UPNPCOMMAND_UNKNOWN_ERROR
;
1089 sscanf(p
, "%d", &ret
);
1092 ClearNameValueList(&pdata
);
1093 free(GetPinholePacketsArgs
);