![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to miniupnpc-async.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / miniupnpc-async|
Return to miniupnpc-async.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / miniupnpc-async |
1.1 misho 1: /* $Id: miniupnpc-async.c,v 1.19 2014/11/07 12:05:40 nanard Exp $ */
2: /* miniupnpc-async
3: * Copyright (c) 2008-2017, Thomas BERNARD <miniupnp@free.fr>
4: * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
5: *
6: * Permission to use, copy, modify, and/or distribute this software for any
7: * purpose with or without fee is hereby granted, provided that the above
8: * copyright notice and this permission notice appear in all copies.
9: *
10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
17: #include <stdlib.h>
18: #include <string.h>
19: #include <sys/types.h>
20: #include <sys/socket.h>
21: #include <netinet/in.h>
22: #include <arpa/inet.h>
23: #include <net/if.h>
24: #include <stdio.h>
25: #ifdef WIN32
26: #include <winsock2.h>
27: #include <ws2tcpip.h>
28: #include <io.h>
29: #define PRINT_SOCKET_ERROR printf
30: #define SOCKET_ERROR GetWSALastError()
31: #define WOULDBLOCK(err) (err == WSAEWOULDBLOCK)
32: #else
33: #include <unistd.h>
34: #include <errno.h>
35: #define closesocket close
36: #define PRINT_SOCKET_ERROR perror
37: #define SOCKET_ERROR errno
38: #define WOULDBLOCK(err) (err == EAGAIN || err == EWOULDBLOCK)
39: #endif
40: #include "miniupnpc-async.h"
41: #include "parsessdpreply.h"
42: #include "upnputils.h"
43: #include "minixml.h"
44: #include "igd_desc_parse.h"
45: #include "upnpreplyparse.h"
46:
47: #ifndef MIN
48: #define MIN(x,y) (((x)<(y))?(x):(y))
49: #endif /* MIN */
50:
51: #ifndef MAXHOSTNAMELEN
52: #define MAXHOSTNAMELEN 64
53: #endif /* MAXHOSTNAMELEN */
54:
55: #define SSDP_PORT 1900
56: #define SSDP_MCAST_ADDR "239.255.255.250"
57: #define XSTR(s) STR(s)
58: #define STR(s) #s
59:
60: #ifdef DEBUG
61: #define debug_printf(...) fprintf(stderr, __VA_ARGS__)
62: #else
63: #define debug_printf(...)
64: #endif
65:
66: /* stuctures */
67:
68: struct upnp_args {
69: const char * elt;
70: const char * val;
71: };
72:
73: /* private functions */
74:
75: static int upnpc_connect(upnpc_device_t * p, const char * url);
76: static int upnpc_send_request(upnpc_device_t * p);
77:
78:
79: /* parse_msearch_reply()
80: * the last 4 arguments are filled during the parsing :
81: * - location/locationsize : "location:" field of the SSDP reply packet
82: * - st/stsize : "st:" field of the SSDP reply packet.
83: * The strings are NOT null terminated */
84: static void
85: parse_msearch_reply(const char * reply, int size,
86: const char * * location, unsigned int * locationsize,
87: const char * * st, unsigned int * stsize)
88: {
89: int a, b, i;
90: i = 0; /* current character index */
91: a = i; /* start of the line */
92: b = 0; /* end of the "header" (position of the colon) */
93: while(i<size) {
94: switch(reply[i]) {
95: case ':':
96: if(b==0) {
97: b = i; /* end of the "header" */
98: }
99: break;
100: case '\x0a':
101: case '\x0d':
102: if(b!=0) {
103: /* skip the colon and white spaces */
104: do { b++; } while(reply[b]==' ' && b<size);
105: if(0==strncasecmp(reply+a, "location:", 9)) {
106: *location = reply+b;
107: *locationsize = i-b;
108: } else if(0==strncasecmp(reply+a, "st:", 3)) {
109: *st = reply+b;
110: *stsize = i-b;
111: }
112: b = 0;
113: }
114: a = i+1;
115: break;
116: default:
117: break;
118: }
119: i++;
120: }
121: }
122:
123: static int upnpc_send_ssdp_msearch(upnpc_t * p, const char * device, unsigned int mx)
124: {
125: /* envoyer les packets de M-SEARCH discovery sur le socket ssdp */
126: int n;
127: char bufr[1024];
128: struct sockaddr_in addr;
129: static const char MSearchMsgFmt[] =
130: "M-SEARCH * HTTP/1.1\r\n"
131: "HOST: " SSDP_MCAST_ADDR ":" XSTR(SSDP_PORT) "\r\n"
132: "ST: %s\r\n"
133: "MAN: \"ssdp:discover\"\r\n"
134: "MX: %u\r\n"
135: "\r\n";
136:
137: memset(&addr, 0, sizeof(struct sockaddr_in));
138: addr.sin_family = AF_INET;
139: addr.sin_port = htons(SSDP_PORT);
140: addr.sin_addr.s_addr = inet_addr(SSDP_MCAST_ADDR);
141: n = snprintf(bufr, sizeof(bufr),
142: MSearchMsgFmt, device, mx);
143: debug_printf("upnpc_send_ssdp_msearch: %s", bufr);
144: n = sendto(p->ssdp_socket, bufr, n, 0,
145: (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
146: if (n < 0) {
147: int err = SOCKET_ERROR;
148: if(err == EINTR || WOULDBLOCK(err)) {
149: debug_printf("upnpc_send_ssdp_msearch: should try again");
150: p->state = EUPnPSendSSDP;
151: return 0;
152: }
153: PRINT_SOCKET_ERROR("sendto");
154: return -1;
155: }
156: p->state = EUPnPReceiveSSDP;
157: return 0;
158: }
159:
160: static int upnpc_set_root_desc_location(upnpc_device_t * d, const char * location, int locationsize)
161: {
162: char * tmp;
163: tmp = realloc(d->root_desc_location, locationsize + 1);
164: if(tmp == 0) {
165: return -1;
166: }
167: memcpy(tmp, location, locationsize);
168: tmp[locationsize] = '\0';
169: d->root_desc_location = tmp;
170: return 0;
171: }
172:
173: static int upnpc_receive_and_parse_ssdp(upnpc_t * p)
174: {
175: int n;
176: char bufr[1024];
177: n = recv(p->ssdp_socket, bufr, sizeof(bufr), 0);
178: if (n<0) {
179: PRINT_SOCKET_ERROR("recv");
180: } else if (n==0) {
181: debug_printf("empty packet received\n");
182: } else {
183: const char * location = NULL;
184: unsigned int locationsize;
185: const char * st = NULL;
186: unsigned int stsize;
187: debug_printf("%.*s", n, bufr);
188: parse_msearch_reply(bufr, n, &location, &locationsize, &st, &stsize);
189: debug_printf("location = '%.*s'\n", locationsize, location);
190: debug_printf("st = '%.*s'\n", stsize, st);
191: if(location != NULL) {
192: upnpc_device_t * dev = p->device_list;
193: while(dev != NULL) {
194: if(dev->root_desc_location != NULL
195: && strlen(dev->root_desc_location) == locationsize
196: && memcmp(dev->root_desc_location, location, locationsize) == 0) {
197: debug_printf("device already in list (location='%s')\n", dev->root_desc_location);
198: return -1;
199: }
200: dev = dev->next;
201: }
202: dev = calloc(1, sizeof(upnpc_device_t));
203: if(dev == NULL) {
204: p->state = EUPnPError;
205: return -1;
206: }
207: if(upnpc_set_root_desc_location(dev, location, locationsize) < 0) {
208: free(dev);
209: p->state = EUPnPError;
210: return -1;
211: }
212: dev->next = p->device_list;
213: p->device_list = dev;
214: dev->state = EDevGetDescConnect;
215: upnpc_connect(dev, dev->root_desc_location);
216: } else {
217: /* or do nothing ? */
218: p->state = EUPnPError;
219: }
220: }
221: return 0;
222: }
223:
224: static int
225: parseURL(const char * url,
226: char * hostname, unsigned short * port,
227: char * * path, unsigned int * scope_id)
228: {
229: char * p1, *p2, *p3;
230: if(!url)
231: return 0;
232: p1 = strstr(url, "://");
233: if(!p1)
234: return 0;
235: p1 += 3;
236: if( (url[0]!='h') || (url[1]!='t')
237: ||(url[2]!='t') || (url[3]!='p'))
238: return 0;
239: memset(hostname, 0, MAXHOSTNAMELEN + 1);
240: if(*p1 == '[') {
241: /* IP v6 : http://[2a00:1450:8002::6a]/path/abc */
242: char * scope;
243: scope = strchr(p1, '%');
244: p2 = strchr(p1, ']');
245: if(p2 && scope && scope < p2 && scope_id) {
246: /* parse scope */
247: #ifdef IF_NAMESIZE
248: char tmp[IF_NAMESIZE];
249: int l;
250: scope++;
251: /* "%25" is just '%' in URL encoding */
252: if(scope[0] == '2' && scope[1] == '5')
253: scope += 2; /* skip "25" */
254: l = p2 - scope;
255: if(l >= IF_NAMESIZE)
256: l = IF_NAMESIZE - 1;
257: memcpy(tmp, scope, l);
258: tmp[l] = '\0';
259: *scope_id = if_nametoindex(tmp);
260: if(*scope_id == 0) {
261: *scope_id = (unsigned int)strtoul(tmp, NULL, 10);
262: }
263: #else
264: /* under windows, scope is numerical */
265: char tmp[8];
266: int l;
267: scope++;
268: /* "%25" is just '%' in URL encoding */
269: if(scope[0] == '2' && scope[1] == '5')
270: scope += 2; /* skip "25" */
271: l = p2 - scope;
272: if(l >= (int)sizeof(tmp))
273: l = sizeof(tmp) - 1;
274: memcpy(tmp, scope, l);
275: tmp[l] = '\0';
276: *scope_id = (unsigned int)strtoul(tmp, NULL, 10);
277: #endif
278: }
279: p3 = strchr(p1, '/');
280: if(p2 && p3) {
281: p2++;
282: strncpy(hostname, p1, MIN(MAXHOSTNAMELEN, (int)(p2-p1)));
283: if(*p2 == ':') {
284: *port = 0;
285: p2++;
286: while( (*p2 >= '0') && (*p2 <= '9')) {
287: *port *= 10;
288: *port += (unsigned short)(*p2 - '0');
289: p2++;
290: }
291: } else {
292: *port = 80;
293: }
294: *path = p3;
295: return 1;
296: }
297: }
298: p2 = strchr(p1, ':');
299: p3 = strchr(p1, '/');
300: if(!p3)
301: return 0;
302: if(!p2 || (p2>p3)) {
303: strncpy(hostname, p1, MIN(MAXHOSTNAMELEN, (int)(p3-p1)));
304: *port = 80;
305: } else {
306: strncpy(hostname, p1, MIN(MAXHOSTNAMELEN, (int)(p2-p1)));
307: *port = 0;
308: p2++;
309: while( (*p2 >= '0') && (*p2 <= '9')) {
310: *port *= 10;
311: *port += (unsigned short)(*p2 - '0');
312: p2++;
313: }
314: }
315: *path = p3;
316: return 1;
317: }
318:
319: static int upnpc_connect(upnpc_device_t * p, const char * url)
320: {
321: int r;
322: char hostname[MAXHOSTNAMELEN+1];
323: unsigned short port;
324: char * path;
325: unsigned int scope_id;
326: struct sockaddr_in addr;
327: socklen_t addrlen;
328:
329: /*if(p->root_desc_location == 0) {
330: p->state = EError;
331: return -1;
332: }*/
333: if(!parseURL(url/*p->root_desc_location*/, hostname, &port,
334: &path, &scope_id)) {
335: p->state = EDevError;
336: return -1;
337: }
338: p->http_socket = socket(PF_INET, SOCK_STREAM, 0);
339: if(p->http_socket < 0) {
340: PRINT_SOCKET_ERROR("socket");
341: p->state = EDevError;
342: return -1;
343: }
344: if(!set_non_blocking(p->http_socket)) {
345: /* TODO : ERROR */
346: }
347: memset(&addr, 0, sizeof(struct sockaddr_in));
348: addr.sin_family = AF_INET;
349: inet_pton(AF_INET, hostname, &(addr.sin_addr));
350: addr.sin_port = htons(port);
351: addrlen = sizeof(struct sockaddr_in);
352: do {
353: r = connect(p->http_socket, (struct sockaddr *)&addr, addrlen);
354: if(r < 0) {
355: if(errno == EINPROGRESS) {
356: /*p->state = EGetDescConnect;*/
357: return 0;
358: } else if(errno != EINTR) {
359: PRINT_SOCKET_ERROR("connect");
360: p->state = EDevError;
361: return -1;
362: }
363: }
364: } while(r < 0 && errno == EINTR);
365: if(p->state == EDevGetDescConnect) {
366: p->state = EDevGetDescRequest;
367: } else {
368: p->state = EDevSoapRequest;
369: }
370: upnpc_send_request(p);
371: return 0;
372: }
373:
374: static int upnpc_complete_connect(upnpc_device_t * p)
375: {
376: socklen_t len;
377: int err;
378: len = sizeof(err);
379: if(getsockopt(p->http_socket, SOL_SOCKET, SO_ERROR, &err, &len) < 0) {
380: PRINT_SOCKET_ERROR("getsockopt");
381: p->state = EDevError;
382: return -1;
383: }
384: if(err != 0) {
385: debug_printf("connect failed %d\n", err);
386: p->state = EDevError;
387: return -1;
388: }
389: if(p->state == EDevGetDescConnect)
390: p->state = EDevGetDescRequest;
391: else
392: p->state = EDevSoapRequest;
393: upnpc_send_request(p);
394: return 0;
395: }
396:
397: static int upnpc_send_request(upnpc_device_t * p)
398: {
399: ssize_t n;
400: static const char reqfmt[] = "GET %s HTTP/1.1\r\n"
401: "Host: %s:%hu\r\n"
402: "Connection: Close\r\n"
403: "User-Agent: MiniUPnPc-async\r\n"
404: "\r\n";
405:
406: /* retrieve "our" IP address used to connect to the UPnP device */
407: p->selfaddrlen = sizeof(struct sockaddr_storage);
408: if(getsockname(p->http_socket, (struct sockaddr *)&p->selfaddr, &p->selfaddrlen) < 0) {
409: PRINT_SOCKET_ERROR("getsockname()");
410: }
411:
412: if(p->http_request == NULL) {
413: char hostname[MAXHOSTNAMELEN+1];
414: unsigned short port;
415: char * path;
416: unsigned int scope_id;
417: int len;
418: if(!parseURL(p->root_desc_location, hostname, &port,
419: &path, &scope_id)) {
420: p->state = EDevError;
421: return -1;
422: }
423: len = snprintf(NULL, 0, reqfmt, path, hostname, port);
424: p->http_request = malloc(len + 1);
425: if(p->http_request == NULL) {
426: p->state = EDevError;
427: return -1;
428: }
429: p->http_request_len = snprintf(p->http_request, len + 1,
430: reqfmt, path, hostname, port);
431: p->http_request_sent = 0;
432: }
433: n = send(p->http_socket, p->http_request + p->http_request_sent,
434: p->http_request_len - p->http_request_sent, 0/* flags */);
435: if(n < 0) {
436: PRINT_SOCKET_ERROR("send");
437: p->state = EDevError;
438: return -1;
439: } else {
440: debug_printf("sent %d bytes\n", (int)n);
441: /*if(n == 0) {
442: p->state = EError;
443: return -1;
444: }*/
445: p->http_request_sent += n;
446: if(p->http_request_sent >= p->http_request_len) {
447: /* all bytes sent */
448: #if 0
449: shutdown(p->http_socket, SHUT_WR); /* some routers don't like that */
450: #endif
451: free(p->http_request);
452: p->http_request = NULL;
453: p->http_request_len = 0;
454: if(p->state == EDevGetDescRequest)
455: p->state = EDevGetDescResponse;
456: else
457: p->state = EDevSoapResponse;
458: free(p->http_response);
459: p->http_response = NULL;
460: p->http_response_received = 0;
461: p->http_response_end_of_headers = 0;
462: /* get response */
463: }
464: }
465: return 0;
466: }
467:
468: static int upnpc_parse_headers(upnpc_device_t * p)
469: {
470: /* search for CR LF CR LF (end of headers)
471: * recognize also LF LF */
472: int i = 0;
473: while(i < (p->http_response_received-1) &&
474: p->http_response_end_of_headers == 0) {
475: if(p->http_response[i] == '\r') {
476: i++;
477: if(p->http_response[i] == '\n') {
478: i++;
479: if(i < p->http_response_received && p->http_response[i] == '\r') {
480: i++;
481: if(i < p->http_response_received && p->http_response[i] == '\n') {
482: p->http_response_end_of_headers = i + 1;
483: }
484: }
485: }
486: } else if(p->http_response[i] == '\n') {
487: i++;
488: if(p->http_response[i] == '\n') {
489: p->http_response_end_of_headers = i + 1;
490: }
491: }
492: i++;
493: }
494: if(p->http_response_end_of_headers != 0) {
495: int colon = 0;
496: int linestart = 0;
497: int valuestart = 0;
498: p->http_response_code = -1;
499: for(i = 0; i < p->http_response_end_of_headers - 1; i++) {
500: if(linestart == 0) {
501: /* reading HTTP response code on the 1st line */
502: if(p->http_response[i] == ' ' && p->http_response_code < 0)
503: p->http_response_code = 0;
504: else if(p->http_response[i] >= '0' && p->http_response[i] <= '9') {
505: p->http_response_code = p->http_response_code * 10 + (p->http_response[i] - '0');
506: } else if(p->http_response[i] == ' ')
507: linestart = 1;
508: }
509: if(colon <= linestart && p->http_response[i] == ':') {
510: colon = i;
511: while(i < p->http_response_end_of_headers - 1 &&
512: (p->http_response[i+1] == ' ' || p->http_response[i+1] == '\t'))
513: i++;
514: valuestart = i + 1;
515: } else if(p->http_response[i + 1] == '\r' ||
516: p->http_response[i + 1] == '\n') {
517: if(colon > linestart && valuestart > colon) {
518: debug_printf("header='%.*s', value='%.*s'\n",
519: colon-linestart, p->http_response+linestart,
520: i+1-valuestart, p->http_response+valuestart);
521: if(0==strncasecmp(p->http_response+linestart, "content-length", colon-linestart)) {
522: p->http_response_content_length = atoi(p->http_response + valuestart);
523: debug_printf("Content-Length: %d\n", p->http_response_content_length);
524: if(p->http_response_content_length < 0) {
525: debug_printf("Content-Length overflow ? setting to 0\n");
526: p->http_response_content_length = 0;
527: }
528: } else if(0==strncasecmp(p->http_response+linestart, "transfer-encoding", colon-linestart)
529: && 0==strncasecmp(p->http_response+valuestart, "chunked", 7)) {
530: debug_printf("Chunked transfer-encoding !\n");
531: p->http_response_chunked = 1;
532: }
533: }
534: /* find next line */
535: while((i < p->http_response_received) &&
536: (p->http_response[i]=='\r' || p->http_response[i] == '\n'))
537: i++;
538: linestart = i;
539: colon = linestart;
540: valuestart = 0;
541: }
542: }
543: }
544: return 0;
545: }
546:
547: static char * build_url_string(const char * urlbase, const char * root_desc_url, const char * controlurl)
548: {
549: int l, n;
550: char * s;
551: const char * base;
552: char * p;
553: /* if controlurl is an absolute url, return it */
554: if(0 == memcmp("http://", controlurl, 7))
555: return strdup(controlurl);
556: base = (urlbase[0] == '\0') ? root_desc_url : urlbase;
557: n = strlen(base);
558: if(n > 7) {
559: p = strchr(base + 7, '/');
560: if(p)
561: n = p - base;
562: }
563: l = n + strlen(controlurl) + 1;
564: if(controlurl[0] != '/')
565: l++;
566: s = malloc(l);
567: if(s == NULL) return NULL;
568: memcpy(s, base, n);
569: if(controlurl[0] != '/')
570: s[n++] = '/';
571: memcpy(s + n, controlurl, l - n);
572: return s;
573: }
574:
575: static int upnpc_get_response(upnpc_device_t * p)
576: {
577: ssize_t n;
578: ssize_t count;
579: char buffer[2048];
580: if(p->http_response_content_length > 0) {
581: count = p->http_response_content_length
582: + p->http_response_end_of_headers
583: - p->http_response_received;
584: if(count > (ssize_t)sizeof(buffer)) count = sizeof(buffer);
585: } else {
586: count = sizeof(buffer);
587: }
588: debug_printf("recv(..., %d)\n", (int)count);
589: n = recv(p->http_socket, buffer, count, 0/* flags */);
590: if(n < 0) {
591: if(errno == EINTR || WOULDBLOCK(errno))
592: return 0; /* try again later */
593: PRINT_SOCKET_ERROR("read");
594: p->state = EDevError;
595: return -1;
596: } else if(n == 0) {
597: /* receiving finished */
598: debug_printf("%.*s\n", p->http_response_received, p->http_response);
599: close(p->http_socket);
600: p->http_socket = -1;
601: /* parse */
602: if(p->http_response_end_of_headers == 0) {
603: upnpc_parse_headers(p);
604: }
605: /* TODO : decode chunked transfer-encoding */
606: /* parse xml */
607: if(p->state == EDevGetDescResponse) {
608: struct IGDdatas igd;
609: struct xmlparser parser;
610: memset(&igd, 0, sizeof(struct IGDdatas));
611: memset(&parser, 0, sizeof(struct xmlparser));
612: parser.xmlstart = p->http_response + p->http_response_end_of_headers;
613: parser.xmlsize = p->http_response_received - p->http_response_end_of_headers;
614: parser.data = &igd;
615: parser.starteltfunc = IGDstartelt;
616: parser.endeltfunc = IGDendelt;
617: parser.datafunc = IGDdata;
618: parsexml(&parser);
619: #ifdef DEBUG
620: printIGD(&igd);
621: #endif /* DEBUG */
622: p->control_conn_url = build_url_string(igd.urlbase, p->root_desc_location, igd.first.controlurl);
623: p->control_cif_url = build_url_string(igd.urlbase, p->root_desc_location, igd.CIF.controlurl);
624: debug_printf("control_conn_url='%s'\n", p->control_conn_url);
625: debug_printf("control_cif_url='%s'\n", p->control_cif_url);
626: } else {
627: ClearNameValueList(&p->soap_response_data);
628: ParseNameValue(p->http_response + p->http_response_end_of_headers,
629: p->http_response_received - p->http_response_end_of_headers,
630: &p->soap_response_data);
631: }
632: free(p->http_response);
633: p->http_response = NULL;
634: p->http_response_received = 0;
635: p->http_response_end_of_headers = 0;
636: p->state = EDevReady;
637: } else {
638: /* receiving in progress */
639: debug_printf("received %d bytes:\n%.*s\n", (int)n, (int)n, buffer);
640: if(p->http_response == NULL) {
641: p->http_response = malloc(n);
642: if(p->http_response == NULL) {
643: debug_printf("failed to malloc %d bytes\n", (int)n);
644: p->state = EDevError;
645: return -1;
646: }
647: p->http_response_received = n;
648: memcpy(p->http_response, buffer, n);
649: } else {
650: char * tmp = realloc(p->http_response, p->http_response_received + n);
651: if(tmp == NULL) {
652: debug_printf("failed to realloc %d bytes\n", (int)(p->http_response_received + n));
653: p->state = EDevError;
654: return -1;
655: }
656: p->http_response = tmp;
657: memcpy(p->http_response + p->http_response_received, buffer, n);
658: p->http_response_received += n;
659: }
660: if(p->http_response_end_of_headers == 0) {
661: upnpc_parse_headers(p);
662: }
663: }
664: return 0;
665: }
666:
667: #define SOAPPREFIX "s"
668: #define SERVICEPREFIX "u"
669: #define SERVICEPREFIX2 'u'
670:
671: static int upnpc_build_soap_request(upnpc_device_t * p, const char * url,
672: const char * service,
673: const char * action,
674: const struct upnp_args * args, int arg_count)
675: {
676: char * body;
677: const char fmt_soap[] =
678: "<?xml version=\"1.0\"?>\r\n"
679: "<" SOAPPREFIX ":Envelope "
680: "xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
681: SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
682: "<" SOAPPREFIX ":Body>"
683: "<" SERVICEPREFIX ":%s xmlns:" SERVICEPREFIX "=\"%s\">"
684: "%s"
685: "</" SERVICEPREFIX ":%s>"
686: "</" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>"
687: "\r\n";
688: int body_len;
689: const char fmt_http[] =
690: "POST %s HTTP/1.1\r\n"
691: "Host: %s%s\r\n"
692: "User-Agent: MiniUPnPc-async\r\n"
693: "Content-Length: %d\r\n"
694: "Content-Type: text/xml\r\n"
695: "SOAPAction: \"%s#%s\"\r\n"
696: "Connection: Close\r\n"
697: "Cache-Control: no-cache\r\n" /* ??? */
698: "Pragma: no-cache\r\n"
699: "\r\n"
700: "%s";
701: char hostname[MAXHOSTNAMELEN+1];
702: unsigned short port;
703: char * path;
704: unsigned int scope_id;
705: char portstr[8];
706: char * args_xml = NULL;
707:
708: if(arg_count > 0) {
709: int i;
710: size_t l, n;
711: for(i = 0, l = 0; i < arg_count; i++) {
712: /* <ELT>VAL</ELT> */
713: l += strlen(args[i].elt) * 2 + strlen(args[i].val) + 5;
714: }
715: args_xml = malloc(++l);
716: if(args_xml == NULL) {
717: p->state = EDevError;
718: return -1;
719: }
720: for(i = 0, n = 0; i < arg_count && n < l; i++) {
721: /* <ELT>VAL</ELT> */
722: n += snprintf(args_xml + n, l - n, "<%s>%s</%s>",
723: args[i].elt, args[i].val, args[i].elt);
724: }
725: }
726:
727: body_len = snprintf(NULL, 0, fmt_soap, action, service, args_xml?args_xml:"", action);
728: body = malloc(body_len + 1);
729: if(body == NULL) {
730: p->state = EDevError;
731: free(args_xml);
732: return -1;
733: }
734: if(snprintf(body, body_len + 1, fmt_soap, action, service, args_xml?args_xml:"", action) != body_len) {
735: debug_printf("snprintf() returned strange value...\n");
736: }
737: free(args_xml);
738: args_xml = NULL;
739: if(!parseURL(url, hostname, &port, &path, &scope_id)) {
740: p->state = EDevError;
741: free(body);
742: return -1;
743: }
744: if(port != 80)
745: snprintf(portstr, sizeof(portstr), ":%hu", port);
746: else
747: portstr[0] = '\0';
748: p->http_request_len = snprintf(NULL, 0, fmt_http,
749: path/*url*/, hostname, portstr, body_len, service, action, body);
750: free(p->http_request);
751: p->http_request = malloc(p->http_request_len + 1);
752: if(snprintf(p->http_request, p->http_request_len + 1, fmt_http,
753: path/*url*/, hostname, portstr, body_len, service, action, body) != p->http_request_len) {
754: debug_printf("snprintf() returned strange value...\n");
755: }
756: free(body);
757: debug_printf("%s", p->http_request);
758: p->http_request_sent = 0;
759: return 0;
760: }
761:
762: /* public functions */
763: int upnpc_init(upnpc_t * p, const char * multicastif)
764: {
765: int opt = 1;
766: struct sockaddr_in addr;
767: if(!p)
768: return UPNPC_ERR_INVALID_ARGS;
769: p->state = EUPnPError;
770: memset(p, 0, sizeof(upnpc_t)); /* clean everything */
771: /* open the socket for SSDP */
772: p->ssdp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
773: if(p->ssdp_socket < 0) {
774: return UPNPC_ERR_SOCKET_FAILED;
775: }
776: /* set REUSEADDR */
777: #ifdef WIN32
778: if(setsockopt(p->ssdp_socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt)) < 0) {
779: #else
780: if(setsockopt(p->ssdp_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
781: #endif
782: /* non fatal error ! */
783: }
784: if(!set_non_blocking(p->ssdp_socket)) {
785: /* TODO log error */
786: }
787:
788: /* receive address */
789: memset(&addr, 0, sizeof(struct sockaddr_in));
790: addr.sin_family = AF_INET;
791: addr.sin_addr.s_addr = INADDR_ANY;
792: /*addr.sin_port = htons(SSDP_PORT);*/
793:
794: if(multicastif) {
795: struct in_addr mc_if;
796: mc_if.s_addr = inet_addr(multicastif);
797: addr.sin_addr.s_addr = mc_if.s_addr;
798: if(setsockopt(p->ssdp_socket, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0) {
799: PRINT_SOCKET_ERROR("setsockopt");
800: /* non fatal error ! */
801: }
802: }
803:
804: /* bind the socket to the ssdp address in order to receive responses */
805: if(bind(p->ssdp_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) != 0) {
806: close(p->ssdp_socket);
807: return UPNPC_ERR_BIND_FAILED;
808: }
809:
810: p->state = EUPnPInit;
811: return UPNPC_OK;
812: }
813:
814: int upnpc_finalize(upnpc_t * p)
815: {
816: if(!p) return UPNPC_ERR_INVALID_ARGS;
817: if(p->ssdp_socket >= 0) {
818: close(p->ssdp_socket);
819: p->ssdp_socket = -1;
820: }
821: while(p->device_list) {
822: upnpc_device_t * next = p->device_list->next;
823: free(p->device_list->root_desc_location);
824: p->device_list->root_desc_location = NULL;
825: free(p->device_list->http_request);
826: p->device_list->http_request = NULL;
827: free(p->device_list->http_response);
828: p->device_list->http_response = NULL;
829: free(p->device_list->control_cif_url);
830: p->device_list->control_cif_url = NULL;
831: free(p->device_list->control_conn_url);
832: p->device_list->control_conn_url = NULL;
833: if(p->device_list->http_socket >= 0) {
834: close(p->device_list->http_socket);
835: p->device_list->http_socket = -1;
836: }
837: ClearNameValueList(&p->device_list->soap_response_data);
838: free(p->device_list);
839: p->device_list = next;
840: }
841: p->state = EUPnPFinalized;
842: return UPNPC_OK;
843: }
844:
845: int upnpc_get_external_ip_address(upnpc_device_t * p)
846: {
847: upnpc_build_soap_request(p, p->control_conn_url,
848: "urn:schemas-upnp-org:service:WANIPConnection:1",
849: "GetExternalIPAddress", NULL, 0);
850: p->state = EDevSoapConnect;
851: upnpc_connect(p, p->control_conn_url);
852: return 0;
853: }
854:
855: int upnpc_get_link_layer_max_rate(upnpc_device_t * p)
856: {
857: upnpc_build_soap_request(p, p->control_cif_url,
858: "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1",
859: "GetCommonLinkProperties", NULL, 0);
860: p->state = EDevSoapConnect;
861: upnpc_connect(p, p->control_conn_url);
862: return 0;
863: }
864:
865: int upnpc_add_port_mapping(upnpc_device_t * p,
866: const char * remote_host, unsigned short ext_port,
867: unsigned short int_port, const char * int_client,
868: const char * proto, const char * description,
869: unsigned int lease_duration)
870: {
871: struct upnp_args args[8];
872: char lease_duration_str[16];
873: char int_port_str[8];
874: char ext_port_str[8];
875:
876: if(int_client == NULL || int_port == 0 || ext_port == 0 || proto == NULL)
877: return UPNPC_ERR_INVALID_ARGS;
878: snprintf(lease_duration_str, sizeof(lease_duration_str), "%u", lease_duration);
879: snprintf(int_port_str, sizeof(int_port_str), "%hu", int_port);
880: snprintf(ext_port_str, sizeof(ext_port_str), "%hu", ext_port);
881: args[0].elt = "NewRemoteHost";
882: args[0].val = remote_host?remote_host:"";
883: args[1].elt = "NewExternalPort";
884: args[1].val = ext_port_str;
885: args[2].elt = "NewProtocol";
886: args[2].val = proto;
887: args[3].elt = "NewInternalPort";
888: args[3].val = int_port_str;
889: args[4].elt = "NewInternalClient";
890: args[4].val = int_client;
891: args[5].elt = "NewEnabled";
892: args[5].val = "1";
893: args[6].elt = "NewPortMappingDescription";
894: args[6].val = description?description:"miniupnpc-async";
895: args[7].elt = "NewLeaseDuration";
896: args[7].val = lease_duration_str;
897: upnpc_build_soap_request(p, p->control_conn_url,
898: "urn:schemas-upnp-org:service:WANIPConnection:1",
899: "AddPortMapping",
900: args, 8);
901: p->state = EDevSoapConnect;
902: upnpc_connect(p, p->control_conn_url);
903: return 0;
904: }
905:
906: #ifdef UPNPC_USE_SELECT
907: int upnpc_select_fds(upnpc_t * p, int * nfds, fd_set * readfds, fd_set * writefds)
908: {
909: upnpc_device_t * d;
910: int n = 0;
911: if(!p) return UPNPC_ERR_INVALID_ARGS;
912: for(d = p->device_list; d != NULL; d = d->next) {
913: switch(d->state) {
914: case EDevGetDescConnect:
915: case EDevGetDescRequest:
916: case EDevSoapConnect:
917: case EDevSoapRequest:
918: FD_SET(d->http_socket, writefds);
919: if(*nfds < d->http_socket)
920: *nfds = d->http_socket;
921: n++;
922: break;
923: case EDevGetDescResponse:
924: case EDevSoapResponse:
925: FD_SET(d->http_socket, readfds);
926: if(*nfds < d->http_socket)
927: *nfds = d->http_socket;
928: n++;
929: break;
930: default:
931: break;
932: }
933: }
934:
935: switch(p->state) {
936: case EUPnPSendSSDP:
937: FD_SET(p->ssdp_socket, writefds);
938: if(*nfds < p->ssdp_socket)
939: *nfds = p->ssdp_socket;
940: n++;
941: break;
942: case EUPnPReceiveSSDP:
943: default:
944: /* still receive SSDP responses when processing Description, etc. */
945: FD_SET(p->ssdp_socket, readfds);
946: if(*nfds < p->ssdp_socket)
947: *nfds = p->ssdp_socket;
948: n++;
949: break;
950: }
951: return n;
952: }
953:
954: void upnpc_check_select_fds(upnpc_t * p, const fd_set * readfds, const fd_set * writefds)
955: {
956: upnpc_device_t * d;
957:
958: p->socket_flags = 0;
959: if(FD_ISSET(p->ssdp_socket, readfds))
960: p->socket_flags = UPNPC_SSDP_READABLE;
961: if(FD_ISSET(p->ssdp_socket, writefds))
962: p->socket_flags = UPNPC_SSDP_WRITEABLE;
963:
964: for(d = p->device_list; d != NULL; d = d->next) {
965: d->socket_flags = 0;
966: if(FD_ISSET(d->http_socket, readfds))
967: d->socket_flags = UPNPC_HTTP_READABLE;
968: if(FD_ISSET(d->http_socket, writefds))
969: d->socket_flags = UPNPC_HTTP_WRITEABLE;
970: }
971: }
972: #endif
973:
974: static const char * devices_to_search[] = {
975: "urn:schemas-upnp-org:device:InternetGatewayDevice:1",
976: "urn:schemas-upnp-org:service:WANIPConnection:1",
977: "urn:schemas-upnp-org:service:WANPPPConnection:1",
978: "upnp:rootdevice",
979: 0
980: };
981:
982: int upnpc_process(upnpc_t * p)
983: {
984: upnpc_device_t * d;
985: /*
986: 1) Envoyer les paquets de discovery SSDP
987: 2) Recevoir et traiter les reponses
988: 3) recup les descriptions
989: 4) tester les etats
990: TODO : translate comments to English
991: */
992: if(!p) return UPNPC_ERR_INVALID_ARGS;
993: debug_printf("state=%d socket_flags=0x%04x\n", (int)p->state, p->socket_flags);
994:
995: for(d = p->device_list; d != NULL; d = d->next) {
996: switch(d->state) {
997: case EDevGetDescConnect:
998: case EDevSoapConnect:
999: upnpc_complete_connect(d);
1000: break;
1001: case EDevGetDescRequest:
1002: case EDevSoapRequest:
1003: upnpc_send_request(d);
1004: break;
1005: case EDevGetDescResponse:
1006: case EDevSoapResponse:
1007: upnpc_get_response(d);
1008: break;
1009: default:
1010: break;
1011: }
1012: }
1013: /* all devices ready => ready */
1014: if(p->device_list != NULL) {
1015: d = p->device_list;
1016: while(d && d->state == EDevReady) d = d->next;
1017: p->state = (d == NULL) ? EUPnPReady : EUPnPProcessing;
1018: }
1019:
1020: if(p->socket_flags & UPNPC_SSDP_READABLE) {
1021: upnpc_receive_and_parse_ssdp(p);
1022: }
1023: switch(p->state) {
1024: case EUPnPInit:
1025: upnpc_send_ssdp_msearch(p, devices_to_search[0], 2);
1026: break;
1027: case EUPnPSendSSDP:
1028: upnpc_send_ssdp_msearch(p, devices_to_search[0], 2);
1029: break;
1030: case EUPnPReceiveSSDP:
1031: /*upnpc_receive_and_parse_ssdp(p);*/
1032: break;
1033: /*case EGetDesc:
1034: upnpc_connect(p);
1035: break;*/
1036: case EUPnPReady:
1037: case EUPnPProcessing:
1038: break;
1039: default:
1040: return UPNPC_ERR_UNKNOWN_STATE;
1041: }
1042: return UPNPC_OK;
1043: }
1044: