aboutsummaryrefslogtreecommitdiff
path: root/src/nat/miniupnp/upnpcommands.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/nat/miniupnp/upnpcommands.c')
-rw-r--r--src/nat/miniupnp/upnpcommands.c605
1 files changed, 0 insertions, 605 deletions
diff --git a/src/nat/miniupnp/upnpcommands.c b/src/nat/miniupnp/upnpcommands.c
deleted file mode 100644
index 8b59bc7cc..000000000
--- a/src/nat/miniupnp/upnpcommands.c
+++ /dev/null
@@ -1,605 +0,0 @@
1/* $Id: upnpcommands.c,v 1.24 2009/04/17 21:21:19 nanard Exp $ */
2/* Project : miniupnp
3 * Author : Thomas Bernard
4 * Copyright (c) 2005-2009 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
14static UNSIGNED_INTEGER
15my_atoui (const char *s)
16{
17 return s ? ((UNSIGNED_INTEGER) STRTOUI (s, NULL, 0)) : 0;
18}
19
20/*
21 * */
22UNSIGNED_INTEGER
23UPNP_GetTotalBytesSent (const char *controlURL, const char *servicetype)
24{
25 struct NameValueParserData pdata;
26 char buffer[4096];
27 int bufsize = 4096;
28 unsigned int r = 0;
29 char *p;
30 simpleUPnPcommand (-1, controlURL, servicetype, "GetTotalBytesSent", 0,
31 buffer, &bufsize);
32 ParseNameValue (buffer, bufsize, &pdata);
33 /*DisplayNameValueList(buffer, bufsize); */
34 p = GetValueFromNameValueList (&pdata, "NewTotalBytesSent");
35 r = my_atoui (p);
36 ClearNameValueList (&pdata);
37 return r;
38}
39
40/*
41 * */
42UNSIGNED_INTEGER
43UPNP_GetTotalBytesReceived (const char *controlURL, const char *servicetype)
44{
45 struct NameValueParserData pdata;
46 char buffer[4096];
47 int bufsize = 4096;
48 unsigned int r = 0;
49 char *p;
50 simpleUPnPcommand (-1, controlURL, servicetype, "GetTotalBytesReceived", 0,
51 buffer, &bufsize);
52 ParseNameValue (buffer, bufsize, &pdata);
53 /*DisplayNameValueList(buffer, bufsize); */
54 p = GetValueFromNameValueList (&pdata, "NewTotalBytesReceived");
55 r = my_atoui (p);
56 ClearNameValueList (&pdata);
57 return r;
58}
59
60/*
61 * */
62UNSIGNED_INTEGER
63UPNP_GetTotalPacketsSent (const char *controlURL, const char *servicetype)
64{
65 struct NameValueParserData pdata;
66 char buffer[4096];
67 int bufsize = 4096;
68 unsigned int r = 0;
69 char *p;
70 simpleUPnPcommand (-1, controlURL, servicetype, "GetTotalPacketsSent", 0,
71 buffer, &bufsize);
72 ParseNameValue (buffer, bufsize, &pdata);
73 /*DisplayNameValueList(buffer, bufsize); */
74 p = GetValueFromNameValueList (&pdata, "NewTotalPacketsSent");
75 r = my_atoui (p);
76 ClearNameValueList (&pdata);
77 return r;
78}
79
80/*
81 * */
82UNSIGNED_INTEGER
83UPNP_GetTotalPacketsReceived (const char *controlURL, const char *servicetype)
84{
85 struct NameValueParserData pdata;
86 char buffer[4096];
87 int bufsize = 4096;
88 unsigned int r = 0;
89 char *p;
90 simpleUPnPcommand (-1, controlURL, servicetype, "GetTotalPacketsReceived",
91 0, buffer, &bufsize);
92 ParseNameValue (buffer, bufsize, &pdata);
93 /*DisplayNameValueList(buffer, bufsize); */
94 p = GetValueFromNameValueList (&pdata, "NewTotalPacketsReceived");
95 r = my_atoui (p);
96 ClearNameValueList (&pdata);
97 return r;
98}
99
100/* UPNP_GetStatusInfo() call the corresponding UPNP method
101 * returns the current status and uptime */
102int
103UPNP_GetStatusInfo (const char *controlURL,
104 const char *servicetype,
105 char *status, unsigned int *uptime, char *lastconnerror)
106{
107 struct NameValueParserData pdata;
108 char buffer[4096];
109 int bufsize = 4096;
110 char *p;
111 char *up;
112 char *err;
113 int ret = UPNPCOMMAND_UNKNOWN_ERROR;
114
115 if (!status && !uptime)
116 return UPNPCOMMAND_INVALID_ARGS;
117
118 simpleUPnPcommand (-1, controlURL, servicetype, "GetStatusInfo", 0, buffer,
119 &bufsize);
120 ParseNameValue (buffer, bufsize, &pdata);
121 /*DisplayNameValueList(buffer, bufsize); */
122 up = GetValueFromNameValueList (&pdata, "NewUptime");
123 p = GetValueFromNameValueList (&pdata, "NewConnectionStatus");
124 err = GetValueFromNameValueList (&pdata, "NewLastConnectionError");
125 if (p && up)
126 ret = UPNPCOMMAND_SUCCESS;
127
128 if (status)
129 {
130 if (p)
131 {
132 strncpy (status, p, 64);
133 status[63] = '\0';
134 }
135 else
136 status[0] = '\0';
137 }
138
139 if (uptime)
140 {
141 if (up)
142 sscanf (up, "%u", uptime);
143 else
144 uptime = 0;
145 }
146
147 if (lastconnerror)
148 {
149 if (err)
150 {
151 strncpy (lastconnerror, err, 64);
152 lastconnerror[63] = '\0';
153 }
154 else
155 lastconnerror[0] = '\0';
156 }
157
158 p = GetValueFromNameValueList (&pdata, "errorCode");
159 if (p)
160 {
161 ret = UPNPCOMMAND_UNKNOWN_ERROR;
162 sscanf (p, "%d", &ret);
163 }
164 ClearNameValueList (&pdata);
165 return ret;
166}
167
168/* UPNP_GetConnectionTypeInfo() call the corresponding UPNP method
169 * returns the connection type */
170int
171UPNP_GetConnectionTypeInfo (const char *controlURL,
172 const char *servicetype, char *connectionType)
173{
174 struct NameValueParserData pdata;
175 char buffer[4096];
176 int bufsize = 4096;
177 char *p;
178 int ret = UPNPCOMMAND_UNKNOWN_ERROR;
179
180 if (!connectionType)
181 return UPNPCOMMAND_INVALID_ARGS;
182
183 simpleUPnPcommand (-1, controlURL, servicetype,
184 "GetConnectionTypeInfo", 0, buffer, &bufsize);
185 ParseNameValue (buffer, bufsize, &pdata);
186 p = GetValueFromNameValueList (&pdata, "NewConnectionType");
187 /*p = GetValueFromNameValueList(&pdata, "NewPossibleConnectionTypes"); */
188 /* PossibleConnectionTypes will have several values.... */
189 if (p)
190 {
191 strncpy (connectionType, p, 64);
192 connectionType[63] = '\0';
193 ret = UPNPCOMMAND_SUCCESS;
194 }
195 else
196 connectionType[0] = '\0';
197 p = GetValueFromNameValueList (&pdata, "errorCode");
198 if (p)
199 {
200 ret = UPNPCOMMAND_UNKNOWN_ERROR;
201 sscanf (p, "%d", &ret);
202 }
203 ClearNameValueList (&pdata);
204 return ret;
205}
206
207/* UPNP_GetLinkLayerMaxBitRate() call the corresponding UPNP method.
208 * Returns 2 values: Downloadlink bandwidth and Uplink bandwidth.
209 * One of the values can be null
210 * Note : GetLinkLayerMaxBitRates belongs to WANPPPConnection:1 only
211 * We can use the GetCommonLinkProperties from WANCommonInterfaceConfig:1 */
212int
213UPNP_GetLinkLayerMaxBitRates (const char *controlURL, const char *servicetype,
214 unsigned int *bitrateDown,
215 unsigned int *bitrateUp)
216{
217 struct NameValueParserData pdata;
218 char buffer[4096];
219 int bufsize = 4096;
220 int ret = UPNPCOMMAND_UNKNOWN_ERROR;
221 char *down;
222 char *up;
223 char *p;
224
225 if (!bitrateDown && !bitrateUp)
226 return UPNPCOMMAND_INVALID_ARGS;
227
228 /* shouldn't we use GetCommonLinkProperties ? */
229 simpleUPnPcommand (-1, controlURL, servicetype,
230 "GetCommonLinkProperties", 0, buffer, &bufsize);
231 /*"GetLinkLayerMaxBitRates", 0, buffer, &bufsize); */
232 /*DisplayNameValueList(buffer, bufsize); */
233 ParseNameValue (buffer, bufsize, &pdata);
234 /*down = GetValueFromNameValueList(&pdata, "NewDownstreamMaxBitRate"); */
235 /*up = GetValueFromNameValueList(&pdata, "NewUpstreamMaxBitRate"); */
236 down = GetValueFromNameValueList (&pdata, "NewLayer1DownstreamMaxBitRate");
237 up = GetValueFromNameValueList (&pdata, "NewLayer1UpstreamMaxBitRate");
238 /*GetValueFromNameValueList(&pdata, "NewWANAccessType"); */
239 /*GetValueFromNameValueList(&pdata, "NewPhysicalLinkSatus"); */
240 if (down && up)
241 ret = UPNPCOMMAND_SUCCESS;
242
243 if (bitrateDown)
244 {
245 if (down)
246 sscanf (down, "%u", bitrateDown);
247 else
248 *bitrateDown = 0;
249 }
250
251 if (bitrateUp)
252 {
253 if (up)
254 sscanf (up, "%u", bitrateUp);
255 else
256 *bitrateUp = 0;
257 }
258 p = GetValueFromNameValueList (&pdata, "errorCode");
259 if (p)
260 {
261 ret = UPNPCOMMAND_UNKNOWN_ERROR;
262 sscanf (p, "%d", &ret);
263 }
264 ClearNameValueList (&pdata);
265 return ret;
266}
267
268
269/* UPNP_GetExternalIPAddress() call the corresponding UPNP method.
270 * if the third arg is not null the value is copied to it.
271 * at least 128 bytes must be available
272 *
273 * Return values :
274 * 0 : SUCCESS
275 * NON ZERO : ERROR Either an UPnP error code or an unknown error.
276 *
277 * 402 Invalid Args - See UPnP Device Architecture section on Control.
278 * 501 Action Failed - See UPnP Device Architecture section on Control.
279 */
280int
281UPNP_GetExternalIPAddress (const char *controlURL,
282 const char *servicetype, char *extIpAdd)
283{
284 struct NameValueParserData pdata;
285 char buffer[4096];
286 int bufsize = 4096;
287 char *p;
288 int ret = UPNPCOMMAND_UNKNOWN_ERROR;
289
290 if (!extIpAdd || !controlURL || !servicetype)
291 return UPNPCOMMAND_INVALID_ARGS;
292
293 simpleUPnPcommand (-1, controlURL, servicetype, "GetExternalIPAddress", 0,
294 buffer, &bufsize);
295 /*DisplayNameValueList(buffer, bufsize); */
296 ParseNameValue (buffer, bufsize, &pdata);
297 /*printf("external ip = %s\n", GetValueFromNameValueList(&pdata, "NewExternalIPAddress") ); */
298 p = GetValueFromNameValueList (&pdata, "NewExternalIPAddress");
299 if (p)
300 {
301 strncpy (extIpAdd, p, 128);
302 extIpAdd[127] = '\0';
303 ret = UPNPCOMMAND_SUCCESS;
304 }
305 else
306 extIpAdd[0] = '\0';
307
308 p = GetValueFromNameValueList (&pdata, "errorCode");
309 if (p)
310 {
311 ret = UPNPCOMMAND_UNKNOWN_ERROR;
312 sscanf (p, "%d", &ret);
313 }
314
315 ClearNameValueList (&pdata);
316 return ret;
317}
318
319int
320UPNP_AddPortMapping (const char *controlURL, const char *servicetype,
321 const char *extPort,
322 const char *inPort,
323 const char *inClient,
324 const char *desc,
325 const char *proto, const char *remoteHost)
326{
327 struct UPNParg *AddPortMappingArgs;
328 char buffer[4096];
329 int bufsize = 4096;
330 struct NameValueParserData pdata;
331 const char *resVal;
332 int ret;
333
334 if (!inPort || !inClient || !proto || !extPort)
335 return UPNPCOMMAND_INVALID_ARGS;
336
337 AddPortMappingArgs = calloc (9, sizeof (struct UPNParg));
338 AddPortMappingArgs[0].elt = "NewRemoteHost";
339 AddPortMappingArgs[0].val = remoteHost;
340 AddPortMappingArgs[1].elt = "NewExternalPort";
341 AddPortMappingArgs[1].val = extPort;
342 AddPortMappingArgs[2].elt = "NewProtocol";
343 AddPortMappingArgs[2].val = proto;
344 AddPortMappingArgs[3].elt = "NewInternalPort";
345 AddPortMappingArgs[3].val = inPort;
346 AddPortMappingArgs[4].elt = "NewInternalClient";
347 AddPortMappingArgs[4].val = inClient;
348 AddPortMappingArgs[5].elt = "NewEnabled";
349 AddPortMappingArgs[5].val = "1";
350 AddPortMappingArgs[6].elt = "NewPortMappingDescription";
351 AddPortMappingArgs[6].val = desc ? desc : "libminiupnpc";
352 AddPortMappingArgs[7].elt = "NewLeaseDuration";
353 AddPortMappingArgs[7].val = "0";
354 simpleUPnPcommand (-1, controlURL, servicetype, "AddPortMapping",
355 AddPortMappingArgs, buffer, &bufsize);
356 /*DisplayNameValueList(buffer, bufsize); */
357 /*buffer[bufsize] = '\0'; */
358 /*puts(buffer); */
359 ParseNameValue (buffer, bufsize, &pdata);
360 resVal = GetValueFromNameValueList (&pdata, "errorCode");
361 if (resVal)
362 {
363 /* printf("AddPortMapping errorCode = '%s'\n", resVal); */
364 ret = UPNPCOMMAND_UNKNOWN_ERROR;
365 sscanf (resVal, "%d", &ret);
366 }
367 else
368 {
369 ret = UPNPCOMMAND_SUCCESS;
370 }
371 ClearNameValueList (&pdata);
372 free (AddPortMappingArgs);
373 return ret;
374}
375
376int
377UPNP_DeletePortMapping (const char *controlURL, const char *servicetype,
378 const char *extPort, const char *proto,
379 const char *remoteHost)
380{
381 /*struct NameValueParserData pdata; */
382 struct UPNParg *DeletePortMappingArgs;
383 char buffer[4096];
384 int bufsize = 4096;
385 struct NameValueParserData pdata;
386 const char *resVal;
387 int ret;
388
389 if (!extPort || !proto)
390 return UPNPCOMMAND_INVALID_ARGS;
391
392 DeletePortMappingArgs = calloc (4, sizeof (struct UPNParg));
393 DeletePortMappingArgs[0].elt = "NewRemoteHost";
394 DeletePortMappingArgs[0].val = remoteHost;
395 DeletePortMappingArgs[1].elt = "NewExternalPort";
396 DeletePortMappingArgs[1].val = extPort;
397 DeletePortMappingArgs[2].elt = "NewProtocol";
398 DeletePortMappingArgs[2].val = proto;
399 simpleUPnPcommand (-1, controlURL, servicetype,
400 "DeletePortMapping",
401 DeletePortMappingArgs, buffer, &bufsize);
402 /*DisplayNameValueList(buffer, bufsize); */
403 ParseNameValue (buffer, bufsize, &pdata);
404 resVal = GetValueFromNameValueList (&pdata, "errorCode");
405 if (resVal)
406 {
407 ret = UPNPCOMMAND_UNKNOWN_ERROR;
408 sscanf (resVal, "%d", &ret);
409 }
410 else
411 {
412 ret = UPNPCOMMAND_SUCCESS;
413 }
414 ClearNameValueList (&pdata);
415 free (DeletePortMappingArgs);
416 return ret;
417}
418
419int
420UPNP_GetGenericPortMappingEntry (const char *controlURL,
421 const char *servicetype,
422 const char *index,
423 char *extPort,
424 char *intClient,
425 char *intPort,
426 char *protocol,
427 char *desc,
428 char *enabled, char *rHost, char *duration)
429{
430 struct NameValueParserData pdata;
431 struct UPNParg *GetPortMappingArgs;
432 char buffer[4096];
433 int bufsize = 4096;
434 char *p;
435 int r = UPNPCOMMAND_UNKNOWN_ERROR;
436 if (!index)
437 return UPNPCOMMAND_INVALID_ARGS;
438
439 GetPortMappingArgs = calloc (2, sizeof (struct UPNParg));
440 GetPortMappingArgs[0].elt = "NewPortMappingIndex";
441 GetPortMappingArgs[0].val = index;
442 simpleUPnPcommand (-1, controlURL, servicetype,
443 "GetGenericPortMappingEntry",
444 GetPortMappingArgs, buffer, &bufsize);
445 ParseNameValue (buffer, bufsize, &pdata);
446 p = GetValueFromNameValueList (&pdata, "NewRemoteHost");
447 if (p && rHost)
448 {
449 strncpy (rHost, p, 64);
450 rHost[63] = '\0';
451 }
452 p = GetValueFromNameValueList (&pdata, "NewExternalPort");
453 if (p && extPort)
454 {
455 strncpy (extPort, p, 6);
456 extPort[5] = '\0';
457 r = UPNPCOMMAND_SUCCESS;
458 }
459 p = GetValueFromNameValueList (&pdata, "NewProtocol");
460 if (p && protocol)
461 {
462 strncpy (protocol, p, 4);
463 protocol[3] = '\0';
464 }
465 p = GetValueFromNameValueList (&pdata, "NewInternalClient");
466 if (p && intClient)
467 {
468 strncpy (intClient, p, 128);
469 intClient[127] = '\0';
470 r = 0;
471 }
472 p = GetValueFromNameValueList (&pdata, "NewInternalPort");
473 if (p && intPort)
474 {
475 strncpy (intPort, p, 6);
476 intPort[5] = '\0';
477 }
478 p = GetValueFromNameValueList (&pdata, "NewEnabled");
479 if (p && enabled)
480 {
481 strncpy (enabled, p, 4);
482 enabled[3] = '\0';
483 }
484 p = GetValueFromNameValueList (&pdata, "NewPortMappingDescription");
485 if (p && desc)
486 {
487 strncpy (desc, p, 80);
488 desc[79] = '\0';
489 }
490 p = GetValueFromNameValueList (&pdata, "NewLeaseDuration");
491 if (p && duration)
492 {
493 strncpy (duration, p, 16);
494 duration[15] = '\0';
495 }
496 p = GetValueFromNameValueList (&pdata, "errorCode");
497 if (p)
498 {
499 r = UPNPCOMMAND_UNKNOWN_ERROR;
500 sscanf (p, "%d", &r);
501 }
502 ClearNameValueList (&pdata);
503 free (GetPortMappingArgs);
504 return r;
505}
506
507int
508UPNP_GetPortMappingNumberOfEntries (const char *controlURL,
509 const char *servicetype,
510 unsigned int *numEntries)
511{
512 struct NameValueParserData pdata;
513 char buffer[4096];
514 int bufsize = 4096;
515 char *p;
516 int ret = UPNPCOMMAND_UNKNOWN_ERROR;
517 simpleUPnPcommand (-1, controlURL, servicetype,
518 "GetPortMappingNumberOfEntries", 0, buffer, &bufsize);
519#ifdef DEBUG
520 DisplayNameValueList (buffer, bufsize);
521#endif
522 ParseNameValue (buffer, bufsize, &pdata);
523
524 p = GetValueFromNameValueList (&pdata, "NewPortMappingNumberOfEntries");
525 if (numEntries && p)
526 {
527 *numEntries = 0;
528 sscanf (p, "%u", numEntries);
529 ret = UPNPCOMMAND_SUCCESS;
530 }
531
532 p = GetValueFromNameValueList (&pdata, "errorCode");
533 if (p)
534 {
535 ret = UPNPCOMMAND_UNKNOWN_ERROR;
536 sscanf (p, "%d", &ret);
537 }
538
539 ClearNameValueList (&pdata);
540 return ret;
541}
542
543/* UPNP_GetSpecificPortMappingEntry retrieves an existing port mapping
544 * the result is returned in the intClient and intPort strings
545 * please provide 128 and 6 bytes of data */
546int
547UPNP_GetSpecificPortMappingEntry (const char *controlURL,
548 const char *servicetype,
549 const char *extPort,
550 const char *proto,
551 char *intClient, char *intPort)
552{
553 struct NameValueParserData pdata;
554 struct UPNParg *GetPortMappingArgs;
555 char buffer[4096];
556 int bufsize = 4096;
557 char *p;
558 int ret = UPNPCOMMAND_UNKNOWN_ERROR;
559
560 if (!intPort || !intClient || !extPort || !proto)
561 return UPNPCOMMAND_INVALID_ARGS;
562
563 GetPortMappingArgs = calloc (4, sizeof (struct UPNParg));
564 GetPortMappingArgs[0].elt = "NewRemoteHost";
565 GetPortMappingArgs[1].elt = "NewExternalPort";
566 GetPortMappingArgs[1].val = extPort;
567 GetPortMappingArgs[2].elt = "NewProtocol";
568 GetPortMappingArgs[2].val = proto;
569 simpleUPnPcommand (-1, controlURL, servicetype,
570 "GetSpecificPortMappingEntry",
571 GetPortMappingArgs, buffer, &bufsize);
572 /*fd = simpleUPnPcommand(fd, controlURL, data.servicetype, "GetSpecificPortMappingEntry", AddPortMappingArgs, buffer, &bufsize); */
573 /*DisplayNameValueList(buffer, bufsize); */
574 ParseNameValue (buffer, bufsize, &pdata);
575
576 p = GetValueFromNameValueList (&pdata, "NewInternalClient");
577 if (p)
578 {
579 strncpy (intClient, p, 128);
580 intClient[127] = '\0';
581 ret = UPNPCOMMAND_SUCCESS;
582 }
583 else
584 intClient[0] = '\0';
585
586 p = GetValueFromNameValueList (&pdata, "NewInternalPort");
587 if (p)
588 {
589 strncpy (intPort, p, 6);
590 intPort[5] = '\0';
591 }
592 else
593 intPort[0] = '\0';
594
595 p = GetValueFromNameValueList (&pdata, "errorCode");
596 if (p)
597 {
598 ret = UPNPCOMMAND_UNKNOWN_ERROR;
599 sscanf (p, "%d", &ret);
600 }
601
602 ClearNameValueList (&pdata);
603 free (GetPortMappingArgs);
604 return ret;
605}
generated by cgit v1.2.3 (git 2.39.1) at 2024-04-20 01:36:42 +0000