Annotation of embedaddon/miniupnpc/upnpcommands.c, revision 1.1.1.1
1.1 misho 1: /* $Id: upnpcommands.c,v 1.37 2011/06/04 15:56:23 nanard Exp $ */
2: /* Project : miniupnp
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.
7: * */
8: #include <stdlib.h>
9: #include <stdio.h>
10: #include <string.h>
11: #include "upnpcommands.h"
12: #include "miniupnpc.h"
13: #include "portlistingparse.h"
14:
15: static UNSIGNED_INTEGER
16: my_atoui(const char * s)
17: {
18: return s ? ((UNSIGNED_INTEGER)STRTOUI(s, NULL, 0)) : 0;
19: }
20:
21: /*
22: * */
23: LIBSPEC UNSIGNED_INTEGER
24: UPNP_GetTotalBytesSent(const char * controlURL,
25: const char * servicetype)
26: {
27: struct NameValueParserData pdata;
28: char * buffer;
29: int bufsize;
30: unsigned int r = 0;
31: char * p;
32: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
33: "GetTotalBytesSent", 0, &bufsize))) {
34: return UPNPCOMMAND_HTTP_ERROR;
35: }
36: ParseNameValue(buffer, bufsize, &pdata);
37: /*DisplayNameValueList(buffer, bufsize);*/
38: free(buffer); buffer = NULL;
39: p = GetValueFromNameValueList(&pdata, "NewTotalBytesSent");
40: r = my_atoui(p);
41: ClearNameValueList(&pdata);
42: return r;
43: }
44:
45: /*
46: * */
47: LIBSPEC UNSIGNED_INTEGER
48: UPNP_GetTotalBytesReceived(const char * controlURL,
49: const char * servicetype)
50: {
51: struct NameValueParserData pdata;
52: char * buffer;
53: int bufsize;
54: unsigned int r = 0;
55: char * p;
56: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
57: "GetTotalBytesReceived", 0, &bufsize))) {
58: return UPNPCOMMAND_HTTP_ERROR;
59: }
60: ParseNameValue(buffer, bufsize, &pdata);
61: /*DisplayNameValueList(buffer, bufsize);*/
62: free(buffer); buffer = NULL;
63: p = GetValueFromNameValueList(&pdata, "NewTotalBytesReceived");
64: r = my_atoui(p);
65: ClearNameValueList(&pdata);
66: return r;
67: }
68:
69: /*
70: * */
71: LIBSPEC UNSIGNED_INTEGER
72: UPNP_GetTotalPacketsSent(const char * controlURL,
73: const char * servicetype)
74: {
75: struct NameValueParserData pdata;
76: char * buffer;
77: int bufsize;
78: unsigned int r = 0;
79: char * p;
80: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
81: "GetTotalPacketsSent", 0, &bufsize))) {
82: return UPNPCOMMAND_HTTP_ERROR;
83: }
84: ParseNameValue(buffer, bufsize, &pdata);
85: /*DisplayNameValueList(buffer, bufsize);*/
86: free(buffer); buffer = NULL;
87: p = GetValueFromNameValueList(&pdata, "NewTotalPacketsSent");
88: r = my_atoui(p);
89: ClearNameValueList(&pdata);
90: return r;
91: }
92:
93: /*
94: * */
95: LIBSPEC UNSIGNED_INTEGER
96: UPNP_GetTotalPacketsReceived(const char * controlURL,
97: const char * servicetype)
98: {
99: struct NameValueParserData pdata;
100: char * buffer;
101: int bufsize;
102: unsigned int r = 0;
103: char * p;
104: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
105: "GetTotalPacketsReceived", 0, &bufsize))) {
106: return UPNPCOMMAND_HTTP_ERROR;
107: }
108: ParseNameValue(buffer, bufsize, &pdata);
109: /*DisplayNameValueList(buffer, bufsize);*/
110: free(buffer); buffer = NULL;
111: p = GetValueFromNameValueList(&pdata, "NewTotalPacketsReceived");
112: r = my_atoui(p);
113: ClearNameValueList(&pdata);
114: return r;
115: }
116:
117: /* UPNP_GetStatusInfo() call the corresponding UPNP method
118: * returns the current status and uptime */
119: LIBSPEC int
120: UPNP_GetStatusInfo(const char * controlURL,
121: const char * servicetype,
122: char * status,
123: unsigned int * uptime,
124: char * lastconnerror)
125: {
126: struct NameValueParserData pdata;
127: char * buffer;
128: int bufsize;
129: char * p;
130: char * up;
131: char * err;
132: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
133:
134: if(!status && !uptime)
135: return UPNPCOMMAND_INVALID_ARGS;
136:
137: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
138: "GetStatusInfo", 0, &bufsize))) {
139: return UPNPCOMMAND_HTTP_ERROR;
140: }
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");
147: if(p && up)
148: ret = UPNPCOMMAND_SUCCESS;
149:
150: if(status) {
151: if(p){
152: strncpy(status, p, 64 );
153: status[63] = '\0';
154: }else
155: status[0]= '\0';
156: }
157:
158: if(uptime) {
159: if(up)
160: sscanf(up,"%u",uptime);
161: else
162: uptime = 0;
163: }
164:
165: if(lastconnerror) {
166: if(err) {
167: strncpy(lastconnerror, err, 64 );
168: lastconnerror[63] = '\0';
169: } else
170: lastconnerror[0] = '\0';
171: }
172:
173: p = GetValueFromNameValueList(&pdata, "errorCode");
174: if(p) {
175: ret = UPNPCOMMAND_UNKNOWN_ERROR;
176: sscanf(p, "%d", &ret);
177: }
178: ClearNameValueList(&pdata);
179: return ret;
180: }
181:
182: /* UPNP_GetConnectionTypeInfo() call the corresponding UPNP method
183: * returns the connection type */
184: LIBSPEC int
185: UPNP_GetConnectionTypeInfo(const char * controlURL,
186: const char * servicetype,
187: char * connectionType)
188: {
189: struct NameValueParserData pdata;
190: char * buffer;
191: int bufsize;
192: char * p;
193: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
194:
195: if(!connectionType)
196: return UPNPCOMMAND_INVALID_ARGS;
197:
198: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
199: "GetConnectionTypeInfo", 0, &bufsize))) {
200: return UPNPCOMMAND_HTTP_ERROR;
201: }
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.... */
207: if(p) {
208: strncpy(connectionType, p, 64 );
209: connectionType[63] = '\0';
210: ret = UPNPCOMMAND_SUCCESS;
211: } else
212: connectionType[0] = '\0';
213: p = GetValueFromNameValueList(&pdata, "errorCode");
214: if(p) {
215: ret = UPNPCOMMAND_UNKNOWN_ERROR;
216: sscanf(p, "%d", &ret);
217: }
218: ClearNameValueList(&pdata);
219: return ret;
220: }
221:
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 */
227: LIBSPEC int
228: UPNP_GetLinkLayerMaxBitRates(const char * controlURL,
229: const char * servicetype,
230: unsigned int * bitrateDown,
231: unsigned int * bitrateUp)
232: {
233: struct NameValueParserData pdata;
234: char * buffer;
235: int bufsize;
236: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
237: char * down;
238: char * up;
239: char * p;
240:
241: if(!bitrateDown && !bitrateUp)
242: return UPNPCOMMAND_INVALID_ARGS;
243:
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;
249: }
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");*/
259: if(down && up)
260: ret = UPNPCOMMAND_SUCCESS;
261:
262: if(bitrateDown) {
263: if(down)
264: sscanf(down,"%u",bitrateDown);
265: else
266: *bitrateDown = 0;
267: }
268:
269: if(bitrateUp) {
270: if(up)
271: sscanf(up,"%u",bitrateUp);
272: else
273: *bitrateUp = 0;
274: }
275: p = GetValueFromNameValueList(&pdata, "errorCode");
276: if(p) {
277: ret = UPNPCOMMAND_UNKNOWN_ERROR;
278: sscanf(p, "%d", &ret);
279: }
280: ClearNameValueList(&pdata);
281: return ret;
282: }
283:
284:
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
288: *
289: * Return values :
290: * 0 : SUCCESS
291: * NON ZERO : ERROR Either an UPnP error code or an unknown error.
292: *
293: * 402 Invalid Args - See UPnP Device Architecture section on Control.
294: * 501 Action Failed - See UPnP Device Architecture section on Control.
295: */
296: LIBSPEC int
297: UPNP_GetExternalIPAddress(const char * controlURL,
298: const char * servicetype,
299: char * extIpAdd)
300: {
301: struct NameValueParserData pdata;
302: char * buffer;
303: int bufsize;
304: char * p;
305: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
306:
307: if(!extIpAdd || !controlURL || !servicetype)
308: return UPNPCOMMAND_INVALID_ARGS;
309:
310: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
311: "GetExternalIPAddress", 0, &bufsize))) {
312: return UPNPCOMMAND_HTTP_ERROR;
313: }
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");
319: if(p) {
320: strncpy(extIpAdd, p, 16 );
321: extIpAdd[15] = '\0';
322: ret = UPNPCOMMAND_SUCCESS;
323: } else
324: extIpAdd[0] = '\0';
325:
326: p = GetValueFromNameValueList(&pdata, "errorCode");
327: if(p) {
328: ret = UPNPCOMMAND_UNKNOWN_ERROR;
329: sscanf(p, "%d", &ret);
330: }
331:
332: ClearNameValueList(&pdata);
333: return ret;
334: }
335:
336: LIBSPEC int
337: UPNP_AddPortMapping(const char * controlURL, const char * servicetype,
338: const char * extPort,
339: const char * inPort,
340: const char * inClient,
341: const char * desc,
342: const char * proto,
343: const char * remoteHost,
344: const char * leaseDuration)
345: {
346: struct UPNParg * AddPortMappingArgs;
347: char * buffer;
348: int bufsize;
349: struct NameValueParserData pdata;
350: const char * resVal;
351: int ret;
352:
353: if(!inPort || !inClient || !proto || !extPort)
354: return UPNPCOMMAND_INVALID_ARGS;
355:
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,
375: &bufsize))) {
376: free(AddPortMappingArgs);
377: return UPNPCOMMAND_HTTP_ERROR;
378: }
379: /*DisplayNameValueList(buffer, bufsize);*/
380: /*buffer[bufsize] = '\0';*/
381: /*puts(buffer);*/
382: ParseNameValue(buffer, bufsize, &pdata);
383: free(buffer); buffer = NULL;
384: resVal = GetValueFromNameValueList(&pdata, "errorCode");
385: if(resVal) {
386: /*printf("AddPortMapping errorCode = '%s'\n", resVal); */
387: ret = UPNPCOMMAND_UNKNOWN_ERROR;
388: sscanf(resVal, "%d", &ret);
389: } else {
390: ret = UPNPCOMMAND_SUCCESS;
391: }
392: ClearNameValueList(&pdata);
393: free(AddPortMappingArgs);
394: return ret;
395: }
396:
397: LIBSPEC int
398: UPNP_DeletePortMapping(const char * controlURL, const char * servicetype,
399: const char * extPort, const char * proto,
400: const char * remoteHost)
401: {
402: /*struct NameValueParserData pdata;*/
403: struct UPNParg * DeletePortMappingArgs;
404: char * buffer;
405: int bufsize;
406: struct NameValueParserData pdata;
407: const char * resVal;
408: int ret;
409:
410: if(!extPort || !proto)
411: return UPNPCOMMAND_INVALID_ARGS;
412:
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,
421: "DeletePortMapping",
422: DeletePortMappingArgs, &bufsize))) {
423: free(DeletePortMappingArgs);
424: return UPNPCOMMAND_HTTP_ERROR;
425: }
426: /*DisplayNameValueList(buffer, bufsize);*/
427: ParseNameValue(buffer, bufsize, &pdata);
428: free(buffer); buffer = NULL;
429: resVal = GetValueFromNameValueList(&pdata, "errorCode");
430: if(resVal) {
431: ret = UPNPCOMMAND_UNKNOWN_ERROR;
432: sscanf(resVal, "%d", &ret);
433: } else {
434: ret = UPNPCOMMAND_SUCCESS;
435: }
436: ClearNameValueList(&pdata);
437: free(DeletePortMappingArgs);
438: return ret;
439: }
440:
441: LIBSPEC int
442: UPNP_GetGenericPortMappingEntry(const char * controlURL,
443: const char * servicetype,
444: const char * index,
445: char * extPort,
446: char * intClient,
447: char * intPort,
448: char * protocol,
449: char * desc,
450: char * enabled,
451: char * rHost,
452: char * duration)
453: {
454: struct NameValueParserData pdata;
455: struct UPNParg * GetPortMappingArgs;
456: char * buffer;
457: int bufsize;
458: char * p;
459: int r = UPNPCOMMAND_UNKNOWN_ERROR;
460: if(!index)
461: return UPNPCOMMAND_INVALID_ARGS;
462: intClient[0] = '\0';
463: intPort[0] = '\0';
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;
472: }
473: ParseNameValue(buffer, bufsize, &pdata);
474: free(buffer); buffer = NULL;
475:
476: p = GetValueFromNameValueList(&pdata, "NewRemoteHost");
477: if(p && rHost)
478: {
479: strncpy(rHost, p, 64);
480: rHost[63] = '\0';
481: }
482: p = GetValueFromNameValueList(&pdata, "NewExternalPort");
483: if(p && extPort)
484: {
485: strncpy(extPort, p, 6);
486: extPort[5] = '\0';
487: r = UPNPCOMMAND_SUCCESS;
488: }
489: p = GetValueFromNameValueList(&pdata, "NewProtocol");
490: if(p && protocol)
491: {
492: strncpy(protocol, p, 4);
493: protocol[3] = '\0';
494: }
495: p = GetValueFromNameValueList(&pdata, "NewInternalClient");
496: if(p && intClient)
497: {
498: strncpy(intClient, p, 16);
499: intClient[15] = '\0';
500: r = 0;
501: }
502: p = GetValueFromNameValueList(&pdata, "NewInternalPort");
503: if(p && intPort)
504: {
505: strncpy(intPort, p, 6);
506: intPort[5] = '\0';
507: }
508: p = GetValueFromNameValueList(&pdata, "NewEnabled");
509: if(p && enabled)
510: {
511: strncpy(enabled, p, 4);
512: enabled[3] = '\0';
513: }
514: p = GetValueFromNameValueList(&pdata, "NewPortMappingDescription");
515: if(p && desc)
516: {
517: strncpy(desc, p, 80);
518: desc[79] = '\0';
519: }
520: p = GetValueFromNameValueList(&pdata, "NewLeaseDuration");
521: if(p && duration)
522: {
523: strncpy(duration, p, 16);
524: duration[15] = '\0';
525: }
526: p = GetValueFromNameValueList(&pdata, "errorCode");
527: if(p) {
528: r = UPNPCOMMAND_UNKNOWN_ERROR;
529: sscanf(p, "%d", &r);
530: }
531: ClearNameValueList(&pdata);
532: free(GetPortMappingArgs);
533: return r;
534: }
535:
536: LIBSPEC int
537: UPNP_GetPortMappingNumberOfEntries(const char * controlURL,
538: const char * servicetype,
539: unsigned int * numEntries)
540: {
541: struct NameValueParserData pdata;
542: char * buffer;
543: int bufsize;
544: char* p;
545: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
546: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
547: "GetPortMappingNumberOfEntries", 0,
548: &bufsize))) {
549: return UPNPCOMMAND_HTTP_ERROR;
550: }
551: #ifdef DEBUG
552: DisplayNameValueList(buffer, bufsize);
553: #endif
554: ParseNameValue(buffer, bufsize, &pdata);
555: free(buffer); buffer = NULL;
556:
557: p = GetValueFromNameValueList(&pdata, "NewPortMappingNumberOfEntries");
558: if(numEntries && p) {
559: *numEntries = 0;
560: sscanf(p, "%u", numEntries);
561: ret = UPNPCOMMAND_SUCCESS;
562: }
563:
564: p = GetValueFromNameValueList(&pdata, "errorCode");
565: if(p) {
566: ret = UPNPCOMMAND_UNKNOWN_ERROR;
567: sscanf(p, "%d", &ret);
568: }
569:
570: ClearNameValueList(&pdata);
571: return ret;
572: }
573:
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 */
577: LIBSPEC int
578: UPNP_GetSpecificPortMappingEntry(const char * controlURL,
579: const char * servicetype,
580: const char * extPort,
581: const char * proto,
582: char * intClient,
583: char * intPort,
584: char * desc,
585: char * enabled,
586: char * leaseDuration)
587: {
588: struct NameValueParserData pdata;
589: struct UPNParg * GetPortMappingArgs;
590: char * buffer;
591: int bufsize;
592: char * p;
593: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
594:
595: if(!intPort || !intClient || !extPort || !proto)
596: return UPNPCOMMAND_INVALID_ARGS;
597:
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;
610: }
611: /*DisplayNameValueList(buffer, bufsize);*/
612: ParseNameValue(buffer, bufsize, &pdata);
613: free(buffer); buffer = NULL;
614:
615: p = GetValueFromNameValueList(&pdata, "NewInternalClient");
616: if(p) {
617: strncpy(intClient, p, 16);
618: intClient[15] = '\0';
619: ret = UPNPCOMMAND_SUCCESS;
620: } else
621: intClient[0] = '\0';
622:
623: p = GetValueFromNameValueList(&pdata, "NewInternalPort");
624: if(p) {
625: strncpy(intPort, p, 6);
626: intPort[5] = '\0';
627: } else
628: intPort[0] = '\0';
629:
630: p = GetValueFromNameValueList(&pdata, "NewEnabled");
631: if(p && enabled) {
632: strncpy(enabled, p, 4);
633: enabled[3] = '\0';
634: }
635:
636: p = GetValueFromNameValueList(&pdata, "NewPortMappingDescription");
637: if(p && desc) {
638: strncpy(desc, p, 80);
639: desc[79] = '\0';
640: }
641:
642: p = GetValueFromNameValueList(&pdata, "NewLeaseDuration");
643: if(p && leaseDuration)
644: {
645: strncpy(leaseDuration, p, 16);
646: leaseDuration[15] = '\0';
647: }
648:
649: p = GetValueFromNameValueList(&pdata, "errorCode");
650: if(p) {
651: ret = UPNPCOMMAND_UNKNOWN_ERROR;
652: sscanf(p, "%d", &ret);
653: }
654:
655: ClearNameValueList(&pdata);
656: free(GetPortMappingArgs);
657: return ret;
658: }
659:
660: /* UPNP_GetListOfPortMappings()
661: *
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
666: * consistent.
667: */
668: LIBSPEC int
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)
676: {
677: struct NameValueParserData pdata;
678: struct UPNParg * GetListOfPortMappingsArgs;
679: const char * p;
680: char * buffer;
681: int bufsize;
682: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
683:
684: if(!startPort || !endPort || !protocol)
685: return UPNPCOMMAND_INVALID_ARGS;
686:
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";
698:
699: if(!(buffer = simpleUPnPcommand(-1, controlURL, servicetype,
700: "GetListOfPortMappings",
701: GetListOfPortMappingsArgs, &bufsize))) {
702: free(GetListOfPortMappingsArgs);
703: return UPNPCOMMAND_HTTP_ERROR;
704: }
705: free(GetListOfPortMappingsArgs);
706:
707: /*DisplayNameValueList(buffer, bufsize);*/
708: ParseNameValue(buffer, bufsize, &pdata);
709: free(buffer); buffer = NULL;
710:
711: /*p = GetValueFromNameValueList(&pdata, "NewPortListing");*/
712: /*if(p) {
713: printf("NewPortListing : %s\n", p);
714: }*/
715: /*printf("NewPortListing(%d chars) : %s\n",
716: pdata.portListingLength, pdata.portListing);*/
717: if(pdata.portListing)
718: {
719: /*struct PortMapping * pm;
720: int i = 0;*/
721: ParsePortListing(pdata.portListing, pdata.portListingLength,
722: data);
723: ret = UPNPCOMMAND_SUCCESS;
724: /*
725: for(pm = data->head.lh_first; pm != NULL; pm = pm->entries.le_next)
726: {
727: printf("%2d %s %5hu->%s:%-5hu '%s' '%s'\n",
728: i, pm->protocol, pm->externalPort, pm->internalClient,
729: pm->internalPort,
730: pm->description, pm->remoteHost);
731: i++;
732: }
733: */
734: /*FreePortListing(&data);*/
735: }
736:
737: p = GetValueFromNameValueList(&pdata, "errorCode");
738: if(p) {
739: ret = UPNPCOMMAND_UNKNOWN_ERROR;
740: sscanf(p, "%d", &ret);
741: }
742: ClearNameValueList(&pdata);
743:
744: //printf("%.*s", bufsize, buffer);
745:
746: return ret;
747: }
748:
749: /* IGD:2, functions for service WANIPv6FirewallControl:1 */
750: LIBSPEC int
751: UPNP_GetFirewallStatus(const char * controlURL,
752: const char * servicetype,
753: int * firewallEnabled,
754: int * inboundPinholeAllowed)
755: {
756: struct NameValueParserData pdata;
757: char * buffer;
758: int bufsize;
759: char * fe, *ipa, *p;
760: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
761:
762: if(!firewallEnabled && !inboundPinholeAllowed)
763: return UPNPCOMMAND_INVALID_ARGS;
764:
765: buffer = simpleUPnPcommand(-1, controlURL, servicetype,
766: "GetFirewallStatus", 0, &bufsize);
767: if(!buffer) {
768: return UPNPCOMMAND_HTTP_ERROR;
769: }
770: ParseNameValue(buffer, bufsize, &pdata);
771: free(buffer); buffer = NULL;
772: fe = GetValueFromNameValueList(&pdata, "FirewallEnabled");
773: ipa = GetValueFromNameValueList(&pdata, "InboundPinholeAllowed");
774: if(ipa && fe)
775: ret = UPNPCOMMAND_SUCCESS;
776: if(fe)
777: *firewallEnabled = my_atoui(fe);
778: /*else
779: *firewallEnabled = 0;*/
780: if(ipa)
781: *inboundPinholeAllowed = my_atoui(ipa);
782: /*else
783: *inboundPinholeAllowed = 0;*/
784: p = GetValueFromNameValueList(&pdata, "errorCode");
785: if(p)
786: {
787: ret = UPNPCOMMAND_UNKNOWN_ERROR;
788: sscanf(p, "%d", &ret);
789: }
790: ClearNameValueList(&pdata);
791: return ret;
792: }
793:
794: LIBSPEC int
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,
800: const char * proto,
801: int * opTimeout)
802: {
803: struct UPNParg * GetOutboundPinholeTimeoutArgs;
804: char * buffer;
805: int bufsize;
806: struct NameValueParserData pdata;
807: const char * resVal;
808: char * p;
809: int ret;
810:
811: if(!intPort || !intClient || !proto || !remotePort || !remoteHost)
812: return UPNPCOMMAND_INVALID_ARGS;
813:
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);
827: if(!buffer)
828: return UPNPCOMMAND_HTTP_ERROR;
829: ParseNameValue(buffer, bufsize, &pdata);
830: free(buffer); buffer = NULL;
831: resVal = GetValueFromNameValueList(&pdata, "errorCode");
832: if(resVal)
833: {
834: ret = UPNPCOMMAND_UNKNOWN_ERROR;
835: sscanf(resVal, "%d", &ret);
836: }
837: else
838: {
839: ret = UPNPCOMMAND_SUCCESS;
840: p = GetValueFromNameValueList(&pdata, "OutboundPinholeTimeout");
841: if(p)
842: *opTimeout = my_atoui(p);
843: }
844: ClearNameValueList(&pdata);
845: free(GetOutboundPinholeTimeoutArgs);
846: return ret;
847: }
848:
849: LIBSPEC int
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,
855: const char * proto,
856: const char * leaseTime,
857: char * uniqueID)
858: {
859: struct UPNParg * AddPinholeArgs;
860: char * buffer;
861: int bufsize;
862: struct NameValueParserData pdata;
863: const char * resVal;
864: char * p;
865: int ret;
866:
867: if(!intPort || !intClient || !proto || !remoteHost || !remotePort || !leaseTime)
868: return UPNPCOMMAND_INVALID_ARGS;
869:
870: AddPinholeArgs = calloc(7, sizeof(struct UPNParg));
871: // RemoteHost can be wilcarded
872: if(strncmp(remoteHost, "empty", 5)==0)
873: {
874: AddPinholeArgs[0].elt = "RemoteHost";
875: AddPinholeArgs[0].val = "";
876: }
877: else
878: {
879: AddPinholeArgs[0].elt = "RemoteHost";
880: AddPinholeArgs[0].val = remoteHost;
881: }
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)
889: {
890: AddPinholeArgs[4].elt = "InternalClient";
891: AddPinholeArgs[4].val = "";
892: }
893: else
894: {
895: AddPinholeArgs[4].elt = "InternalClient";
896: AddPinholeArgs[4].val = intClient;
897: }
898: AddPinholeArgs[5].elt = "LeaseTime";
899: AddPinholeArgs[5].val = leaseTime;
900: buffer = simpleUPnPcommand(-1, controlURL, servicetype,
901: "AddPinhole", AddPinholeArgs, &bufsize);
902: if(!buffer)
903: return UPNPCOMMAND_HTTP_ERROR;
904: ParseNameValue(buffer, bufsize, &pdata);
905: free(buffer); buffer = NULL;
906: p = GetValueFromNameValueList(&pdata, "UniqueID");
907: if(p)
908: {
909: strncpy(uniqueID, p, 8);
910: uniqueID[7] = '\0';
911: }
912: resVal = GetValueFromNameValueList(&pdata, "errorCode");
913: if(resVal)
914: {
915: //printf("AddPortMapping errorCode = '%s'\n", resVal);
916: ret = UPNPCOMMAND_UNKNOWN_ERROR;
917: sscanf(resVal, "%d", &ret);
918: }
919: else
920: {
921: ret = UPNPCOMMAND_SUCCESS;
922: }
923: ClearNameValueList(&pdata);
924: free(AddPinholeArgs);
925: return ret;
926: }
927:
928: LIBSPEC int
929: UPNP_UpdatePinhole(const char * controlURL, const char * servicetype,
930: const char * uniqueID,
931: const char * leaseTime)
932: {
933: struct UPNParg * UpdatePinholeArgs;
934: char * buffer;
935: int bufsize;
936: struct NameValueParserData pdata;
937: const char * resVal;
938: int ret;
939:
940: if(!uniqueID || !leaseTime)
941: return UPNPCOMMAND_INVALID_ARGS;
942:
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);
950: if(!buffer)
951: return UPNPCOMMAND_HTTP_ERROR;
952: ParseNameValue(buffer, bufsize, &pdata);
953: free(buffer); buffer = NULL;
954: resVal = GetValueFromNameValueList(&pdata, "errorCode");
955: if(resVal)
956: {
957: /*printf("AddPortMapping errorCode = '%s'\n", resVal); */
958: ret = UPNPCOMMAND_UNKNOWN_ERROR;
959: sscanf(resVal, "%d", &ret);
960: }
961: else
962: {
963: ret = UPNPCOMMAND_SUCCESS;
964: }
965: ClearNameValueList(&pdata);
966: free(UpdatePinholeArgs);
967: return ret;
968: }
969:
970: LIBSPEC int
971: UPNP_DeletePinhole(const char * controlURL, const char * servicetype, const char * uniqueID)
972: {
973: /*struct NameValueParserData pdata;*/
974: struct UPNParg * DeletePinholeArgs;
975: char * buffer;
976: int bufsize;
977: struct NameValueParserData pdata;
978: const char * resVal;
979: int ret;
980:
981: if(!uniqueID)
982: return UPNPCOMMAND_INVALID_ARGS;
983:
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);
989: if(!buffer)
990: return UPNPCOMMAND_HTTP_ERROR;
991: /*DisplayNameValueList(buffer, bufsize);*/
992: ParseNameValue(buffer, bufsize, &pdata);
993: free(buffer); buffer = NULL;
994: resVal = GetValueFromNameValueList(&pdata, "errorCode");
995: if(resVal)
996: {
997: ret = UPNPCOMMAND_UNKNOWN_ERROR;
998: sscanf(resVal, "%d", &ret);
999: }
1000: else
1001: {
1002: ret = UPNPCOMMAND_SUCCESS;
1003: }
1004: ClearNameValueList(&pdata);
1005: free(DeletePinholeArgs);
1006: return ret;
1007: }
1008:
1009: LIBSPEC int
1010: UPNP_CheckPinholeWorking(const char * controlURL, const char * servicetype,
1011: const char * uniqueID, int * isWorking)
1012: {
1013: struct NameValueParserData pdata;
1014: struct UPNParg * CheckPinholeWorkingArgs;
1015: char * buffer;
1016: int bufsize;
1017: char * p;
1018: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
1019:
1020: if(!uniqueID)
1021: return UPNPCOMMAND_INVALID_ARGS;
1022:
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);
1028: if(!buffer)
1029: return UPNPCOMMAND_HTTP_ERROR;
1030: ParseNameValue(buffer, bufsize, &pdata);
1031: free(buffer); buffer = NULL;
1032:
1033: p = GetValueFromNameValueList(&pdata, "IsWorking");
1034: if(p)
1035: {
1036: *isWorking=my_atoui(p);
1037: ret = UPNPCOMMAND_SUCCESS;
1038: }
1039: else
1040: *isWorking = 0;
1041:
1042: p = GetValueFromNameValueList(&pdata, "errorCode");
1043: if(p)
1044: {
1045: ret = UPNPCOMMAND_UNKNOWN_ERROR;
1046: sscanf(p, "%d", &ret);
1047: }
1048:
1049: ClearNameValueList(&pdata);
1050: free(CheckPinholeWorkingArgs);
1051: return ret;
1052: }
1053:
1054: LIBSPEC int
1055: UPNP_GetPinholePackets(const char * controlURL, const char * servicetype,
1056: const char * uniqueID, int * packets)
1057: {
1058: struct NameValueParserData pdata;
1059: struct UPNParg * GetPinholePacketsArgs;
1060: char * buffer;
1061: int bufsize;
1062: char * p;
1063: int ret = UPNPCOMMAND_UNKNOWN_ERROR;
1064:
1065: if(!uniqueID)
1066: return UPNPCOMMAND_INVALID_ARGS;
1067:
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);
1073: if(!buffer)
1074: return UPNPCOMMAND_HTTP_ERROR;
1075: ParseNameValue(buffer, bufsize, &pdata);
1076: free(buffer); buffer = NULL;
1077:
1078: p = GetValueFromNameValueList(&pdata, "PinholePackets");
1079: if(p)
1080: {
1081: *packets=my_atoui(p);
1082: ret = UPNPCOMMAND_SUCCESS;
1083: }
1084:
1085: p = GetValueFromNameValueList(&pdata, "errorCode");
1086: if(p)
1087: {
1088: ret = UPNPCOMMAND_UNKNOWN_ERROR;
1089: sscanf(p, "%d", &ret);
1090: }
1091:
1092: ClearNameValueList(&pdata);
1093: free(GetPinholePacketsArgs);
1094: return ret;
1095: }
1096:
1097:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to upnpcommands.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpc