source: trunk/third-party/miniupnp/miniupnpc.c @ 13289

Last change on this file since 13289 was 13289, checked in by livings124, 9 years ago

#4878 update miniupnpc to 1.6.20120410

File size: 25.6 KB
Line 
1/* $Id: miniupnpc.c,v 1.104 2012/04/09 12:40:11 nanard Exp $ */
2/* Project : miniupnp
3 * Web : http://miniupnp.free.fr/
4 * Author : Thomas BERNARD
5 * copyright (c) 2005-2012 Thomas Bernard
6 * This software is subjet to the conditions detailed in the
7 * provided LICENSE file. */
8#define __EXTENSIONS__ 1
9#if !defined(MACOSX) && !defined(__sun)
10#if !defined(_XOPEN_SOURCE) && !defined(__OpenBSD__) && !defined(__NetBSD__)
11#ifndef __cplusplus
12#define _XOPEN_SOURCE 600
13#endif
14#endif
15#ifndef __BSD_VISIBLE
16#define __BSD_VISIBLE 1
17#endif
18#endif
19
20#if !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(MACOSX) && !defined(_WIN32)
21#define HAS_IP_MREQN
22#endif
23
24#include <stdlib.h>
25#include <stdio.h>
26#include <string.h>
27#ifdef _WIN32
28/* Win32 Specific includes and defines */
29#include <winsock2.h>
30#include <ws2tcpip.h>
31#include <io.h>
32#include <iphlpapi.h>
33#define snprintf _snprintf
34#ifndef strncasecmp
35#if defined(_MSC_VER) && (_MSC_VER >= 1400)
36#define strncasecmp _memicmp
37#else /* defined(_MSC_VER) && (_MSC_VER >= 1400) */
38#define strncasecmp memicmp
39#endif /* defined(_MSC_VER) && (_MSC_VER >= 1400) */
40#endif /* #ifndef strncasecmp */
41#define MAXHOSTNAMELEN 64
42#else /* #ifdef _WIN32 */
43/* Standard POSIX includes */
44#include <unistd.h>
45#if defined(__amigaos__) && !defined(__amigaos4__)
46/* Amiga OS 3 specific stuff */
47#define socklen_t int
48#else
49#include <sys/select.h>
50#endif
51#include <sys/socket.h>
52#include <sys/types.h>
53#include <sys/param.h>
54#include <netinet/in.h>
55#include <arpa/inet.h>
56#include <netdb.h>
57#include <net/if.h>
58#if !defined(__amigaos__) && !defined(__amigaos4__)
59#include <poll.h>
60#endif
61#include <strings.h>
62#include <errno.h>
63#define closesocket close
64#endif /* #else _WIN32 */
65#ifdef MINIUPNPC_SET_SOCKET_TIMEOUT
66#include <sys/time.h>
67#endif
68#if defined(__amigaos__) || defined(__amigaos4__)
69/* Amiga OS specific stuff */
70#define TIMEVAL struct timeval
71#endif
72
73#include "miniupnpc.h"
74#include "minissdpc.h"
75#include "miniwget.h"
76#include "minisoap.h"
77#include "minixml.h"
78#include "upnpcommands.h"
79#include "connecthostport.h"
80#include "receivedata.h"
81
82#ifdef _WIN32
83#define PRINT_SOCKET_ERROR(x)    printf("Socket error: %s, %d\n", x, WSAGetLastError());
84#else
85#define PRINT_SOCKET_ERROR(x) perror(x)
86#endif
87
88#define SOAPPREFIX "s"
89#define SERVICEPREFIX "u"
90#define SERVICEPREFIX2 'u'
91
92/* root description parsing */
93LIBSPEC void parserootdesc(const char * buffer, int bufsize, struct IGDdatas * data)
94{
95        struct xmlparser parser;
96        /* xmlparser object */
97        parser.xmlstart = buffer;
98        parser.xmlsize = bufsize;
99        parser.data = data;
100        parser.starteltfunc = IGDstartelt;
101        parser.endeltfunc = IGDendelt;
102        parser.datafunc = IGDdata;
103        parser.attfunc = 0;
104        parsexml(&parser);
105#ifdef DEBUG
106        printIGD(data);
107#endif
108}
109
110/* simpleUPnPcommand2 :
111 * not so simple !
112 * return values :
113 *   pointer - OK
114 *   NULL - error */
115char * simpleUPnPcommand2(int s, const char * url, const char * service,
116                       const char * action, struct UPNParg * args,
117                       int * bufsize, const char * httpversion)
118{
119        char hostname[MAXHOSTNAMELEN+1];
120        unsigned short port = 0;
121        char * path;
122        char soapact[128];
123        char soapbody[2048];
124        char * buf;
125    int n;
126
127        *bufsize = 0;
128        snprintf(soapact, sizeof(soapact), "%s#%s", service, action);
129        if(args==NULL)
130        {
131                /*soapbodylen = */snprintf(soapbody, sizeof(soapbody),
132                                                "<?xml version=\"1.0\"?>\r\n"
133                              "<" SOAPPREFIX ":Envelope "
134                                                  "xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
135                                                  SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
136                                                  "<" SOAPPREFIX ":Body>"
137                                                  "<" SERVICEPREFIX ":%s xmlns:" SERVICEPREFIX "=\"%s\">"
138                                                  "</" SERVICEPREFIX ":%s>"
139                                                  "</" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>"
140                                                  "\r\n", action, service, action);
141        }
142        else
143        {
144                char * p;
145                const char * pe, * pv;
146                int soapbodylen;
147                soapbodylen = snprintf(soapbody, sizeof(soapbody),
148                                                "<?xml version=\"1.0\"?>\r\n"
149                            "<" SOAPPREFIX ":Envelope "
150                                                "xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
151                                                SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
152                                                "<" SOAPPREFIX ":Body>"
153                                                "<" SERVICEPREFIX ":%s xmlns:" SERVICEPREFIX "=\"%s\">",
154                                                action, service);
155                p = soapbody + soapbodylen;
156                while(args->elt)
157                {
158                        /* check that we are never overflowing the string... */
159                        if(soapbody + sizeof(soapbody) <= p + 100)
160                        {
161                                /* we keep a margin of at least 100 bytes */
162                                return NULL;
163                        }
164                        *(p++) = '<';
165                        pe = args->elt;
166                        while(*pe)
167                                *(p++) = *(pe++);
168                        *(p++) = '>';
169                        if((pv = args->val))
170                        {
171                                while(*pv)
172                                        *(p++) = *(pv++);
173                        }
174                        *(p++) = '<';
175                        *(p++) = '/';
176                        pe = args->elt;
177                        while(*pe)
178                                *(p++) = *(pe++);
179                        *(p++) = '>';
180                        args++;
181                }
182                *(p++) = '<';
183                *(p++) = '/';
184                *(p++) = SERVICEPREFIX2;
185                *(p++) = ':';
186                pe = action;
187                while(*pe)
188                        *(p++) = *(pe++);
189                strncpy(p, "></" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>\r\n",
190                        soapbody + sizeof(soapbody) - p);
191        }
192        if(!parseURL(url, hostname, &port, &path)) return NULL;
193        if(s<0)
194        {
195                s = connecthostport(hostname, port);
196                if(s < 0)
197                {
198                        return NULL;
199                }
200        }
201
202        n = soapPostSubmit(s, path, hostname, port, soapact, soapbody, httpversion);
203        if(n<=0) {
204#ifdef DEBUG
205                printf("Error sending SOAP request\n");
206#endif
207                closesocket(s);
208                return NULL;
209        }
210
211        buf = getHTTPResponse(s, bufsize);
212#ifdef DEBUG
213        if(*bufsize > 0 && buf)
214        {
215                printf("SOAP Response :\n%.*s\n", *bufsize, buf);
216        }
217#endif
218        closesocket(s);
219        return buf;
220}
221
222/* simpleUPnPcommand :
223 * not so simple !
224 * return values :
225 *   pointer - OK
226 *   NULL    - error */
227char * simpleUPnPcommand(int s, const char * url, const char * service,
228                       const char * action, struct UPNParg * args,
229                       int * bufsize)
230{
231        char * buf;
232
233        buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.1");
234/*
235        buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.0");
236        if (!buf || *bufsize == 0)
237        {
238#if DEBUG
239            printf("Error or no result from SOAP request; retrying with HTTP/1.1\n");
240#endif
241                buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.1");
242        }
243*/
244        return buf;
245}
246
247/* parseMSEARCHReply()
248 * the last 4 arguments are filled during the parsing :
249 *    - location/locationsize : "location:" field of the SSDP reply packet
250 *    - st/stsize : "st:" field of the SSDP reply packet.
251 * The strings are NOT null terminated */
252static void
253parseMSEARCHReply(const char * reply, int size,
254                  const char * * location, int * locationsize,
255                              const char * * st, int * stsize)
256{
257        int a, b, i;
258        i = 0;
259        a = i;  /* start of the line */
260        b = 0;  /* end of the "header" (position of the colon) */
261        while(i<size)
262        {
263                switch(reply[i])
264                {
265                case ':':
266                                if(b==0)
267                                {
268                                        b = i; /* end of the "header" */
269                                        /*for(j=a; j<b; j++)
270                                        {
271                                                putchar(reply[j]);
272                                        }
273                                        */
274                                }
275                                break;
276                case '\x0a':
277                case '\x0d':
278                                if(b!=0)
279                                {
280                                        /*for(j=b+1; j<i; j++)
281                                        {
282                                                putchar(reply[j]);
283                                        }
284                                        putchar('\n');*/
285                                        /* skip the colon and white spaces */
286                                        do { b++; } while(reply[b]==' ');
287                                        if(0==strncasecmp(reply+a, "location", 8))
288                                        {
289                                                *location = reply+b;
290                                                *locationsize = i-b;
291                                        }
292                                        else if(0==strncasecmp(reply+a, "st", 2))
293                                        {
294                                                *st = reply+b;
295                                                *stsize = i-b;
296                                        }
297                                        b = 0;
298                                }
299                                a = i+1;
300                                break;
301                default:
302                                break;
303                }
304                i++;
305        }
306}
307
308/* port upnp discover : SSDP protocol */
309#define PORT 1900
310#define XSTR(s) STR(s)
311#define STR(s) #s
312#define UPNP_MCAST_ADDR "239.255.255.250"
313/* for IPv6 */
314#define UPNP_MCAST_LL_ADDR "FF02::C" /* link-local */
315#define UPNP_MCAST_SL_ADDR "FF05::C" /* site-local */
316
317/* upnpDiscover() :
318 * return a chained list of all devices found or NULL if
319 * no devices was found.
320 * It is up to the caller to free the chained list
321 * delay is in millisecond (poll) */
322LIBSPEC struct UPNPDev *
323upnpDiscover(int delay, const char * multicastif,
324             const char * minissdpdsock, int sameport,
325             int ipv6,
326             int * error)
327{
328        struct UPNPDev * tmp;
329        struct UPNPDev * devlist = 0;
330        int opt = 1;
331        static const char MSearchMsgFmt[] =
332        "M-SEARCH * HTTP/1.1\r\n"
333        "HOST: %s:" XSTR(PORT) "\r\n"
334        "ST: %s\r\n"
335        "MAN: \"ssdp:discover\"\r\n"
336        "MX: %u\r\n"
337        "\r\n";
338        static const char * const deviceList[] = {
339#if 0
340                "urn:schemas-upnp-org:device:InternetGatewayDevice:2",
341                "urn:schemas-upnp-org:service:WANIPConnection:2",
342#endif
343                "urn:schemas-upnp-org:device:InternetGatewayDevice:1",
344                "urn:schemas-upnp-org:service:WANIPConnection:1",
345                "urn:schemas-upnp-org:service:WANPPPConnection:1",
346                "upnp:rootdevice",
347                0
348        };
349        int deviceIndex = 0;
350        char bufr[1536];        /* reception and emission buffer */
351        int sudp;
352        int n;
353        struct sockaddr_storage sockudp_r;
354        unsigned int mx;
355#ifdef NO_GETADDRINFO
356        struct sockaddr_storage sockudp_w;
357#else
358        int rv;
359        struct addrinfo hints, *servinfo, *p;
360#endif
361#ifdef _WIN32
362        MIB_IPFORWARDROW ip_forward;
363#endif
364        int linklocal = 1;
365
366        if(error)
367                *error = UPNPDISCOVER_UNKNOWN_ERROR;
368#if !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__)
369        /* first try to get infos from minissdpd ! */
370        if(!minissdpdsock)
371                minissdpdsock = "/var/run/minissdpd.sock";
372        while(!devlist && deviceList[deviceIndex]) {
373                devlist = getDevicesFromMiniSSDPD(deviceList[deviceIndex],
374                                                  minissdpdsock);
375                /* We return what we have found if it was not only a rootdevice */
376                if(devlist && !strstr(deviceList[deviceIndex], "rootdevice")) {
377                        if(error)
378                                *error = UPNPDISCOVER_SUCCESS;
379                        return devlist;
380                }
381                deviceIndex++;
382        }
383        deviceIndex = 0;
384#endif
385        /* fallback to direct discovery */
386#ifdef _WIN32
387        sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP);
388#else
389        sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0);
390#endif
391        if(sudp < 0)
392        {
393                if(error)
394                        *error = UPNPDISCOVER_SOCKET_ERROR;
395                PRINT_SOCKET_ERROR("socket");
396                return NULL;
397        }
398        /* reception */
399        memset(&sockudp_r, 0, sizeof(struct sockaddr_storage));
400        if(ipv6) {
401                struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_r;
402                p->sin6_family = AF_INET6;
403                if(sameport)
404                        p->sin6_port = htons(PORT);
405                p->sin6_addr = in6addr_any; /* in6addr_any is not available with MinGW32 3.4.2 */
406        } else {
407                struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_r;
408                p->sin_family = AF_INET;
409                if(sameport)
410                        p->sin_port = htons(PORT);
411                p->sin_addr.s_addr = INADDR_ANY;
412        }
413#ifdef _WIN32
414/* This code could help us to use the right Network interface for
415 * SSDP multicast traffic */
416/* Get IP associated with the index given in the ip_forward struct
417 * in order to give this ip to setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF) */
418        if(!ipv6
419           && (GetBestRoute(inet_addr("223.255.255.255"), 0, &ip_forward) == NO_ERROR)) {
420                DWORD dwRetVal = 0;
421                PMIB_IPADDRTABLE pIPAddrTable;
422                DWORD dwSize = 0;
423#ifdef DEBUG
424                IN_ADDR IPAddr;
425#endif
426                int i;
427#ifdef DEBUG
428                printf("ifIndex=%lu nextHop=%lx \n", ip_forward.dwForwardIfIndex, ip_forward.dwForwardNextHop);
429#endif
430                pIPAddrTable = (MIB_IPADDRTABLE *) malloc(sizeof (MIB_IPADDRTABLE));
431                if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
432                        free(pIPAddrTable);
433                        pIPAddrTable = (MIB_IPADDRTABLE *) malloc(dwSize);
434                }
435                if(pIPAddrTable) {
436                        dwRetVal = GetIpAddrTable( pIPAddrTable, &dwSize, 0 );
437#ifdef DEBUG
438                        printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries);
439#endif
440                        for (i=0; i < (int) pIPAddrTable->dwNumEntries; i++) {
441#ifdef DEBUG
442                                printf("\n\tInterface Index[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwIndex);
443                                IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr;
444                                printf("\tIP Address[%d]:     \t%s\n", i, inet_ntoa(IPAddr) );
445                                IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask;
446                                printf("\tSubnet Mask[%d]:    \t%s\n", i, inet_ntoa(IPAddr) );
447                                IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr;
448                                printf("\tBroadCast[%d]:      \t%s (%ld)\n", i, inet_ntoa(IPAddr), pIPAddrTable->table[i].dwBCastAddr);
449                                printf("\tReassembly size[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwReasmSize);
450                                printf("\tType and State[%d]:", i);
451                                printf("\n");
452#endif
453                                if (pIPAddrTable->table[i].dwIndex == ip_forward.dwForwardIfIndex) {
454                                        /* Set the address of this interface to be used */
455                                        struct in_addr mc_if;
456                                        memset(&mc_if, 0, sizeof(mc_if));
457                                        mc_if.s_addr = pIPAddrTable->table[i].dwAddr;
458                                        if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0) {
459                                                PRINT_SOCKET_ERROR("setsockopt");
460                                        }
461                                        ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = pIPAddrTable->table[i].dwAddr;
462#ifndef DEBUG
463                                        break;
464#endif
465                                }
466                        }
467                        free(pIPAddrTable);
468                        pIPAddrTable = NULL;
469                }
470        }
471#endif
472
473#ifdef _WIN32
474        if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)
475#else
476        if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
477#endif
478        {
479                if(error)
480                        *error = UPNPDISCOVER_SOCKET_ERROR;
481                PRINT_SOCKET_ERROR("setsockopt");
482                return NULL;
483        }
484
485        if(multicastif)
486        {
487                if(ipv6) {
488#if !defined(_WIN32)
489                        /* according to MSDN, if_nametoindex() is supported since
490                         * MS Windows Vista and MS Windows Server 2008.
491                         * http://msdn.microsoft.com/en-us/library/bb408409%28v=vs.85%29.aspx */
492                        unsigned int ifindex = if_nametoindex(multicastif); /* eth0, etc. */
493                        if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(&ifindex)) < 0)
494                        {
495                                PRINT_SOCKET_ERROR("setsockopt");
496                        }
497#else
498#ifdef DEBUG
499                        printf("Setting of multicast interface not supported in IPv6 under Windows.\n");
500#endif
501#endif
502                } else {
503                        struct in_addr mc_if;
504                        mc_if.s_addr = inet_addr(multicastif); /* ex: 192.168.x.x */
505                        if(mc_if.s_addr != INADDR_NONE)
506                        {
507                                ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = mc_if.s_addr;
508                                if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
509                                {
510                                        PRINT_SOCKET_ERROR("setsockopt");
511                                }
512                        } else {
513#ifdef HAS_IP_MREQN
514                                /* was not an ip address, try with an interface name */
515                                struct ip_mreqn reqn;   /* only defined with -D_BSD_SOURCE or -D_GNU_SOURCE */
516                                memset(&reqn, 0, sizeof(struct ip_mreqn));
517                                reqn.imr_ifindex = if_nametoindex(multicastif);
518                                if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&reqn, sizeof(reqn)) < 0)
519                                {
520                                        PRINT_SOCKET_ERROR("setsockopt");
521                                }
522#else
523#ifdef DEBUG
524                                printf("Setting of multicast interface not supported with interface name.\n");
525#endif
526#endif
527                        }
528                }
529        }
530
531        /* Avant d'envoyer le paquet on bind pour recevoir la reponse */
532    if (bind(sudp, (const struct sockaddr *)&sockudp_r,
533                 ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) != 0)
534        {
535                if(error)
536                        *error = UPNPDISCOVER_SOCKET_ERROR;
537        PRINT_SOCKET_ERROR("bind");
538                closesocket(sudp);
539                return NULL;
540    }
541
542        if(error)
543                *error = UPNPDISCOVER_SUCCESS;
544        /* Calculating maximum response time in seconds */
545        mx = ((unsigned int)delay) / 1000u;
546        /* receiving SSDP response packet */
547        for(n = 0; deviceList[deviceIndex]; deviceIndex++)
548        {
549        if(n == 0)
550        {
551                /* sending the SSDP M-SEARCH packet */
552                n = snprintf(bufr, sizeof(bufr),
553                             MSearchMsgFmt,
554                             ipv6 ?
555                             (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" :  "[" UPNP_MCAST_SL_ADDR "]")
556                             : UPNP_MCAST_ADDR,
557                             deviceList[deviceIndex], mx);
558#ifdef DEBUG
559                printf("Sending %s", bufr);
560#endif
561#ifdef NO_GETADDRINFO
562                /* the following code is not using getaddrinfo */
563                /* emission */
564                memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));
565                if(ipv6) {
566                        struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;
567                        p->sin6_family = AF_INET6;
568                        p->sin6_port = htons(PORT);
569                        inet_pton(AF_INET6,
570                                  linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,
571                                  &(p->sin6_addr));
572                } else {
573                        struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;
574                        p->sin_family = AF_INET;
575                        p->sin_port = htons(PORT);
576                        p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
577                }
578                n = sendto(sudp, bufr, n, 0,
579                           &sockudp_w,
580                           ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
581                if (n < 0) {
582                        if(error)
583                                *error = UPNPDISCOVER_SOCKET_ERROR;
584                        PRINT_SOCKET_ERROR("sendto");
585                        break;
586                }
587#else /* #ifdef NO_GETADDRINFO */
588                memset(&hints, 0, sizeof(hints));
589                hints.ai_family = AF_UNSPEC; /* AF_INET6 or AF_INET */
590                hints.ai_socktype = SOCK_DGRAM;
591                /*hints.ai_flags = */
592                if ((rv = getaddrinfo(ipv6
593                                      ? (linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR)
594                                      : UPNP_MCAST_ADDR,
595                                      XSTR(PORT), &hints, &servinfo)) != 0) {
596                        if(error)
597                                *error = UPNPDISCOVER_SOCKET_ERROR;
598#ifdef _WIN32
599                    fprintf(stderr, "getaddrinfo() failed: %d\n", rv);
600#else
601                    fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
602#endif
603                        break;
604                }
605                for(p = servinfo; p; p = p->ai_next) {
606                        n = sendto(sudp, bufr, n, 0, p->ai_addr, p->ai_addrlen);
607                        if (n < 0) {
608#ifdef DEBUG
609                                char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
610                                if (getnameinfo(p->ai_addr, p->ai_addrlen, hbuf, sizeof(hbuf), sbuf,
611                                                sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
612                                        fprintf(stderr, "host:%s port:%s\n", hbuf, sbuf);
613                                }
614#endif
615                                PRINT_SOCKET_ERROR("sendto");
616                                continue;
617                        }
618                }
619                freeaddrinfo(servinfo);
620                if(n < 0) {
621                        if(error)
622                                *error = UPNPDISCOVER_SOCKET_ERROR;
623                        break;
624                }
625#endif /* #ifdef NO_GETADDRINFO */
626        }
627        /* Waiting for SSDP REPLY packet to M-SEARCH */
628        n = receivedata(sudp, bufr, sizeof(bufr), delay);
629        if (n < 0) {
630                /* error */
631                if(error)
632                        *error = UPNPDISCOVER_SOCKET_ERROR;
633                break;
634        } else if (n == 0) {
635                /* no data or Time Out */
636                if (devlist) {
637                        /* no more device type to look for... */
638                        if(error)
639                                *error = UPNPDISCOVER_SUCCESS;
640                        break;
641                }
642                if(ipv6) {
643                        if(linklocal) {
644                                linklocal = 0;
645                                --deviceIndex;
646                        } else {
647                                linklocal = 1;
648                        }
649                }
650        } else {
651                const char * descURL=NULL;
652                int urlsize=0;
653                const char * st=NULL;
654                int stsize=0;
655        /*printf("%d byte(s) :\n%s\n", n, bufr);*/ /* affichage du message */
656                parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize);
657                if(st&&descURL)
658                {
659#ifdef DEBUG
660                        printf("M-SEARCH Reply:\nST: %.*s\nLocation: %.*s\n",
661                               stsize, st, urlsize, descURL);
662#endif
663                        for(tmp=devlist; tmp; tmp = tmp->pNext) {
664                                if(memcmp(tmp->descURL, descURL, urlsize) == 0 &&
665                                   tmp->descURL[urlsize] == '\0' &&
666                                   memcmp(tmp->st, st, stsize) == 0 &&
667                                   tmp->st[stsize] == '\0')
668                                        break;
669                        }
670                        /* at the exit of the loop above, tmp is null if
671                         * no duplicate device was found */
672                        if(tmp)
673                                continue;
674                        tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
675                        if(!tmp) {
676                                /* memory allocation error */
677                                if(error)
678                                        *error = UPNPDISCOVER_MEMORY_ERROR;
679                                break;
680                        }
681                        tmp->pNext = devlist;
682                        tmp->descURL = tmp->buffer;
683                        tmp->st = tmp->buffer + 1 + urlsize;
684                        memcpy(tmp->buffer, descURL, urlsize);
685                        tmp->buffer[urlsize] = '\0';
686                        memcpy(tmp->buffer + urlsize + 1, st, stsize);
687                        tmp->buffer[urlsize+1+stsize] = '\0';
688                        devlist = tmp;
689                }
690        }
691        }
692        closesocket(sudp);
693        return devlist;
694}
695
696/* freeUPNPDevlist() should be used to
697 * free the chained list returned by upnpDiscover() */
698LIBSPEC void freeUPNPDevlist(struct UPNPDev * devlist)
699{
700        struct UPNPDev * next;
701        while(devlist)
702        {
703                next = devlist->pNext;
704                free(devlist);
705                devlist = next;
706        }
707}
708
709static void
710url_cpy_or_cat(char * dst, const char * src, int n)
711{
712        if(  (src[0] == 'h')
713           &&(src[1] == 't')
714           &&(src[2] == 't')
715           &&(src[3] == 'p')
716           &&(src[4] == ':')
717           &&(src[5] == '/')
718           &&(src[6] == '/'))
719        {
720                strncpy(dst, src, n);
721        }
722        else
723        {
724                int l = strlen(dst);
725                if(src[0] != '/')
726                        dst[l++] = '/';
727                if(l<=n)
728                        strncpy(dst + l, src, n - l);
729        }
730}
731
732/* Prepare the Urls for usage...
733 */
734LIBSPEC void GetUPNPUrls(struct UPNPUrls * urls, struct IGDdatas * data,
735                 const char * descURL)
736{
737        char * p;
738        int n1, n2, n3, n4;
739
740        n1 = strlen(data->urlbase);
741        if(n1==0)
742                n1 = strlen(descURL);
743        n1 += 2;        /* 1 byte more for Null terminator, 1 byte for '/' if needed */
744        n2 = n1; n3 = n1; n4 = n1;
745        n1 += strlen(data->first.scpdurl);
746        n2 += strlen(data->first.controlurl);
747        n3 += strlen(data->CIF.controlurl);
748        n4 += strlen(data->IPv6FC.controlurl);
749
750        /* allocate memory to store URLs */
751        urls->ipcondescURL = (char *)malloc(n1);
752        urls->controlURL = (char *)malloc(n2);
753        urls->controlURL_CIF = (char *)malloc(n3);
754        urls->controlURL_6FC = (char *)malloc(n4);
755
756        /* strdup descURL */
757        urls->rootdescURL = strdup(descURL);
758
759        /* get description of WANIPConnection */
760        if(data->urlbase[0] != '\0')
761                strncpy(urls->ipcondescURL, data->urlbase, n1);
762        else
763                strncpy(urls->ipcondescURL, descURL, n1);
764        p = strchr(urls->ipcondescURL+7, '/');
765        if(p) p[0] = '\0';
766        strncpy(urls->controlURL, urls->ipcondescURL, n2);
767        strncpy(urls->controlURL_CIF, urls->ipcondescURL, n3);
768        strncpy(urls->controlURL_6FC, urls->ipcondescURL, n4);
769
770        url_cpy_or_cat(urls->ipcondescURL, data->first.scpdurl, n1);
771
772        url_cpy_or_cat(urls->controlURL, data->first.controlurl, n2);
773
774        url_cpy_or_cat(urls->controlURL_CIF, data->CIF.controlurl, n3);
775
776        url_cpy_or_cat(urls->controlURL_6FC, data->IPv6FC.controlurl, n4);
777
778#ifdef DEBUG
779        printf("urls->ipcondescURL='%s' %u n1=%d\n", urls->ipcondescURL,
780               (unsigned)strlen(urls->ipcondescURL), n1);
781        printf("urls->controlURL='%s' %u n2=%d\n", urls->controlURL,
782               (unsigned)strlen(urls->controlURL), n2);
783        printf("urls->controlURL_CIF='%s' %u n3=%d\n", urls->controlURL_CIF,
784               (unsigned)strlen(urls->controlURL_CIF), n3);
785        printf("urls->controlURL_6FC='%s' %u n4=%d\n", urls->controlURL_6FC,
786               (unsigned)strlen(urls->controlURL_6FC), n4);
787#endif
788}
789
790LIBSPEC void
791FreeUPNPUrls(struct UPNPUrls * urls)
792{
793        if(!urls)
794                return;
795        free(urls->controlURL);
796        urls->controlURL = 0;
797        free(urls->ipcondescURL);
798        urls->ipcondescURL = 0;
799        free(urls->controlURL_CIF);
800        urls->controlURL_CIF = 0;
801        free(urls->controlURL_6FC);
802        urls->controlURL_6FC = 0;
803        free(urls->rootdescURL);
804        urls->rootdescURL = 0;
805}
806
807int
808UPNPIGD_IsConnected(struct UPNPUrls * urls, struct IGDdatas * data)
809{
810        char status[64];
811        unsigned int uptime;
812        status[0] = '\0';
813        UPNP_GetStatusInfo(urls->controlURL, data->first.servicetype,
814                           status, &uptime, NULL);
815        if(0 == strcmp("Connected", status))
816        {
817                return 1;
818        }
819        else
820                return 0;
821}
822
823
824/* UPNP_GetValidIGD() :
825 * return values :
826 *    -1 = Internal error
827 *     0 = NO IGD found
828 *     1 = A valid connected IGD has been found
829 *     2 = A valid IGD has been found but it reported as
830 *         not connected
831 *     3 = an UPnP device has been found but was not recognized as an IGD
832 *
833 * In any non zero return case, the urls and data structures
834 * passed as parameters are set. Donc forget to call FreeUPNPUrls(urls) to
835 * free allocated memory.
836 */
837LIBSPEC int
838UPNP_GetValidIGD(struct UPNPDev * devlist,
839                 struct UPNPUrls * urls,
840                                 struct IGDdatas * data,
841                                 char * lanaddr, int lanaddrlen)
842{
843        struct xml_desc {
844                char * xml;
845                int size;
846        } * desc = NULL;
847        struct UPNPDev * dev;
848        int ndev = 0;
849        int i;
850        int state = -1; /* state 1 : IGD connected. State 2 : IGD. State 3 : anything */
851        if(!devlist)
852        {
853#ifdef DEBUG
854                printf("Empty devlist\n");
855#endif
856                return 0;
857        }
858        for(dev = devlist; dev; dev = dev->pNext)
859                ndev++;
860        if(ndev > 0)
861        {
862                desc = calloc(ndev, sizeof(struct xml_desc));
863                if(!desc)
864                        return -1; /* memory allocation error */
865        }
866        for(state = 1; state <= 3; state++)
867        {
868                for(dev = devlist, i = 0; dev; dev = dev->pNext, i++)
869                {
870                        /* we should choose an internet gateway device.
871                        * with st == urn:schemas-upnp-org:device:InternetGatewayDevice:1 */
872                        if(state == 1)
873                        {
874                                desc[i].xml = miniwget_getaddr(dev->descURL, &(desc[i].size),
875                                                                   lanaddr, lanaddrlen);
876#ifdef DEBUG
877                                if(!desc[i].xml)
878                                {
879                                        printf("error getting XML description %s\n", dev->descURL);
880                                }
881#endif
882                        }
883                        if(desc[i].xml)
884                        {
885                                memset(data, 0, sizeof(struct IGDdatas));
886                                memset(urls, 0, sizeof(struct UPNPUrls));
887                                parserootdesc(desc[i].xml, desc[i].size, data);
888                                if(0==strcmp(data->CIF.servicetype,
889                                   "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1")
890                                   || state >= 3 )
891                                {
892                                  GetUPNPUrls(urls, data, dev->descURL);
893
894#ifdef DEBUG
895                                  printf("UPNPIGD_IsConnected(%s) = %d\n",
896                                     urls->controlURL,
897                                 UPNPIGD_IsConnected(urls, data));
898#endif
899                                  if((state >= 2) || UPNPIGD_IsConnected(urls, data))
900                                        goto free_and_return;
901                                  FreeUPNPUrls(urls);
902                                  if(data->second.servicetype[0] != '\0') {
903#ifdef DEBUG
904                                    printf("We tried %s, now we try %s !\n",
905                                           data->first.servicetype, data->second.servicetype);
906#endif
907                                    /* swaping WANPPPConnection and WANIPConnection ! */
908                                    memcpy(&data->tmp, &data->first, sizeof(struct IGDdatas_service));
909                                    memcpy(&data->first, &data->second, sizeof(struct IGDdatas_service));
910                                    memcpy(&data->second, &data->tmp, sizeof(struct IGDdatas_service));
911                                    GetUPNPUrls(urls, data, dev->descURL);
912#ifdef DEBUG
913                                    printf("UPNPIGD_IsConnected(%s) = %d\n",
914                                       urls->controlURL,
915                                   UPNPIGD_IsConnected(urls, data));
916#endif
917                                    if((state >= 2) || UPNPIGD_IsConnected(urls, data))
918                                          goto free_and_return;
919                                    FreeUPNPUrls(urls);
920                                  }
921                                }
922                                memset(data, 0, sizeof(struct IGDdatas));
923                        }
924                }
925        }
926        state = 0;
927free_and_return:
928        free(desc);
929        return state;
930}
931
932/* UPNP_GetIGDFromUrl()
933 * Used when skipping the discovery process.
934 * return value :
935 *   0 - Not ok
936 *   1 - OK */
937int
938UPNP_GetIGDFromUrl(const char * rootdescurl,
939                   struct UPNPUrls * urls,
940                   struct IGDdatas * data,
941                   char * lanaddr, int lanaddrlen)
942{
943        char * descXML;
944        int descXMLsize = 0;
945        descXML = miniwget_getaddr(rootdescurl, &descXMLsize,
946                                       lanaddr, lanaddrlen);
947        if(descXML) {
948                memset(data, 0, sizeof(struct IGDdatas));
949                memset(urls, 0, sizeof(struct UPNPUrls));
950                parserootdesc(descXML, descXMLsize, data);
951                free(descXML);
952                descXML = NULL;
953                GetUPNPUrls(urls, data, rootdescurl);
954                return 1;
955        } else {
956                return 0;
957        }
958}
959
Note: See TracBrowser for help on using the repository browser.