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

Last change on this file since 13258 was 13258, checked in by livings124, 10 years ago

#4825 update miniupnp to miniupnpc-1.6.20120320

File size: 25.0 KB
Line 
1/* $Id: miniupnpc.c,v 1.103 2012/03/05 19:42:46 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                                PRINT_SOCKET_ERROR("sendto");
609                                continue;
610                        }
611                }
612                freeaddrinfo(servinfo);
613                if(n < 0) {
614                        if(error)
615                                *error = UPNPDISCOVER_SOCKET_ERROR;
616                        break;
617                }
618#endif /* #ifdef NO_GETADDRINFO */
619        }
620        /* Waiting for SSDP REPLY packet to M-SEARCH */
621        n = receivedata(sudp, bufr, sizeof(bufr), delay);
622        if (n < 0) {
623                /* error */
624                if(error)
625                        *error = UPNPDISCOVER_SOCKET_ERROR;
626                break;
627        } else if (n == 0) {
628                /* no data or Time Out */
629                if (devlist) {
630                        /* no more device type to look for... */
631                        if(error)
632                                *error = UPNPDISCOVER_SUCCESS;
633                        break;
634                }
635                if(ipv6) {
636                        if(linklocal) {
637                                linklocal = 0;
638                                --deviceIndex;
639                        } else {
640                                linklocal = 1;
641                        }
642                }
643        } else {
644                const char * descURL=NULL;
645                int urlsize=0;
646                const char * st=NULL;
647                int stsize=0;
648        /*printf("%d byte(s) :\n%s\n", n, bufr);*/ /* affichage du message */
649                parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize);
650                if(st&&descURL)
651                {
652#ifdef DEBUG
653                        printf("M-SEARCH Reply:\nST: %.*s\nLocation: %.*s\n",
654                               stsize, st, urlsize, descURL);
655#endif
656                        for(tmp=devlist; tmp; tmp = tmp->pNext) {
657                                if(memcmp(tmp->descURL, descURL, urlsize) == 0 &&
658                                   tmp->descURL[urlsize] == '\0' &&
659                                   memcmp(tmp->st, st, stsize) == 0 &&
660                                   tmp->st[stsize] == '\0')
661                                        break;
662                        }
663                        /* at the exit of the loop above, tmp is null if
664                         * no duplicate device was found */
665                        if(tmp)
666                                continue;
667                        tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
668                        if(!tmp) {
669                                /* memory allocation error */
670                                if(error)
671                                        *error = UPNPDISCOVER_MEMORY_ERROR;
672                                break;
673                        }
674                        tmp->pNext = devlist;
675                        tmp->descURL = tmp->buffer;
676                        tmp->st = tmp->buffer + 1 + urlsize;
677                        memcpy(tmp->buffer, descURL, urlsize);
678                        tmp->buffer[urlsize] = '\0';
679                        memcpy(tmp->buffer + urlsize + 1, st, stsize);
680                        tmp->buffer[urlsize+1+stsize] = '\0';
681                        devlist = tmp;
682                }
683        }
684        }
685        closesocket(sudp);
686        return devlist;
687}
688
689/* freeUPNPDevlist() should be used to
690 * free the chained list returned by upnpDiscover() */
691LIBSPEC void freeUPNPDevlist(struct UPNPDev * devlist)
692{
693        struct UPNPDev * next;
694        while(devlist)
695        {
696                next = devlist->pNext;
697                free(devlist);
698                devlist = next;
699        }
700}
701
702static void
703url_cpy_or_cat(char * dst, const char * src, int n)
704{
705        if(  (src[0] == 'h')
706           &&(src[1] == 't')
707           &&(src[2] == 't')
708           &&(src[3] == 'p')
709           &&(src[4] == ':')
710           &&(src[5] == '/')
711           &&(src[6] == '/'))
712        {
713                strncpy(dst, src, n);
714        }
715        else
716        {
717                int l = strlen(dst);
718                if(src[0] != '/')
719                        dst[l++] = '/';
720                if(l<=n)
721                        strncpy(dst + l, src, n - l);
722        }
723}
724
725/* Prepare the Urls for usage...
726 */
727LIBSPEC void GetUPNPUrls(struct UPNPUrls * urls, struct IGDdatas * data,
728                 const char * descURL)
729{
730        char * p;
731        int n1, n2, n3, n4;
732
733        n1 = strlen(data->urlbase);
734        if(n1==0)
735                n1 = strlen(descURL);
736        n1 += 2;        /* 1 byte more for Null terminator, 1 byte for '/' if needed */
737        n2 = n1; n3 = n1; n4 = n1;
738        n1 += strlen(data->first.scpdurl);
739        n2 += strlen(data->first.controlurl);
740        n3 += strlen(data->CIF.controlurl);
741        n4 += strlen(data->IPv6FC.controlurl);
742
743        /* allocate memory to store URLs */
744        urls->ipcondescURL = (char *)malloc(n1);
745        urls->controlURL = (char *)malloc(n2);
746        urls->controlURL_CIF = (char *)malloc(n3);
747        urls->controlURL_6FC = (char *)malloc(n4);
748
749        /* strdup descURL */
750        urls->rootdescURL = strdup(descURL);
751
752        /* get description of WANIPConnection */
753        if(data->urlbase[0] != '\0')
754                strncpy(urls->ipcondescURL, data->urlbase, n1);
755        else
756                strncpy(urls->ipcondescURL, descURL, n1);
757        p = strchr(urls->ipcondescURL+7, '/');
758        if(p) p[0] = '\0';
759        strncpy(urls->controlURL, urls->ipcondescURL, n2);
760        strncpy(urls->controlURL_CIF, urls->ipcondescURL, n3);
761        strncpy(urls->controlURL_6FC, urls->ipcondescURL, n4);
762
763        url_cpy_or_cat(urls->ipcondescURL, data->first.scpdurl, n1);
764
765        url_cpy_or_cat(urls->controlURL, data->first.controlurl, n2);
766
767        url_cpy_or_cat(urls->controlURL_CIF, data->CIF.controlurl, n3);
768
769        url_cpy_or_cat(urls->controlURL_6FC, data->IPv6FC.controlurl, n4);
770
771#ifdef DEBUG
772        printf("urls->ipcondescURL='%s' %u n1=%d\n", urls->ipcondescURL,
773               (unsigned)strlen(urls->ipcondescURL), n1);
774        printf("urls->controlURL='%s' %u n2=%d\n", urls->controlURL,
775               (unsigned)strlen(urls->controlURL), n2);
776        printf("urls->controlURL_CIF='%s' %u n3=%d\n", urls->controlURL_CIF,
777               (unsigned)strlen(urls->controlURL_CIF), n3);
778        printf("urls->controlURL_6FC='%s' %u n4=%d\n", urls->controlURL_6FC,
779               (unsigned)strlen(urls->controlURL_6FC), n4);
780#endif
781}
782
783LIBSPEC void
784FreeUPNPUrls(struct UPNPUrls * urls)
785{
786        if(!urls)
787                return;
788        free(urls->controlURL);
789        urls->controlURL = 0;
790        free(urls->ipcondescURL);
791        urls->ipcondescURL = 0;
792        free(urls->controlURL_CIF);
793        urls->controlURL_CIF = 0;
794        free(urls->controlURL_6FC);
795        urls->controlURL_6FC = 0;
796        free(urls->rootdescURL);
797        urls->rootdescURL = 0;
798}
799
800int
801UPNPIGD_IsConnected(struct UPNPUrls * urls, struct IGDdatas * data)
802{
803        char status[64];
804        unsigned int uptime;
805        status[0] = '\0';
806        UPNP_GetStatusInfo(urls->controlURL, data->first.servicetype,
807                           status, &uptime, NULL);
808        if(0 == strcmp("Connected", status))
809        {
810                return 1;
811        }
812        else
813                return 0;
814}
815
816
817/* UPNP_GetValidIGD() :
818 * return values :
819 *     0 = NO IGD found
820 *     1 = A valid connected IGD has been found
821 *     2 = A valid IGD has been found but it reported as
822 *         not connected
823 *     3 = an UPnP device has been found but was not recognized as an IGD
824 *
825 * In any non zero return case, the urls and data structures
826 * passed as parameters are set. Donc forget to call FreeUPNPUrls(urls) to
827 * free allocated memory.
828 */
829LIBSPEC int
830UPNP_GetValidIGD(struct UPNPDev * devlist,
831                 struct UPNPUrls * urls,
832                                 struct IGDdatas * data,
833                                 char * lanaddr, int lanaddrlen)
834{
835        char * descXML;
836        int descXMLsize = 0;
837        struct UPNPDev * dev;
838        int ndev = 0;
839        int state; /* state 1 : IGD connected. State 2 : IGD. State 3 : anything */
840        if(!devlist)
841        {
842#ifdef DEBUG
843                printf("Empty devlist\n");
844#endif
845                return 0;
846        }
847        for(state = 1; state <= 3; state++)
848        {
849                for(dev = devlist; dev; dev = dev->pNext)
850                {
851                        /* we should choose an internet gateway device.
852                        * with st == urn:schemas-upnp-org:device:InternetGatewayDevice:1 */
853                        descXML = miniwget_getaddr(dev->descURL, &descXMLsize,
854                                                        lanaddr, lanaddrlen);
855                        if(descXML)
856                        {
857                                ndev++;
858                                memset(data, 0, sizeof(struct IGDdatas));
859                                memset(urls, 0, sizeof(struct UPNPUrls));
860                                parserootdesc(descXML, descXMLsize, data);
861                                free(descXML);
862                                descXML = NULL;
863                                if(0==strcmp(data->CIF.servicetype,
864                                   "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1")
865                                   || state >= 3 )
866                                {
867                                  GetUPNPUrls(urls, data, dev->descURL);
868
869#ifdef DEBUG
870                                  printf("UPNPIGD_IsConnected(%s) = %d\n",
871                                     urls->controlURL,
872                                 UPNPIGD_IsConnected(urls, data));
873#endif
874                                  if((state >= 2) || UPNPIGD_IsConnected(urls, data))
875                                        return state;
876                                  FreeUPNPUrls(urls);
877                                  if(data->second.servicetype[0] != '\0') {
878#ifdef DEBUG
879                                    printf("We tried %s, now we try %s !\n",
880                                           data->first.servicetype, data->second.servicetype);
881#endif
882                                    /* swaping WANPPPConnection and WANIPConnection ! */
883                                    memcpy(&data->tmp, &data->first, sizeof(struct IGDdatas_service));
884                                    memcpy(&data->first, &data->second, sizeof(struct IGDdatas_service));
885                                    memcpy(&data->second, &data->tmp, sizeof(struct IGDdatas_service));
886                                    GetUPNPUrls(urls, data, dev->descURL);
887#ifdef DEBUG
888                                    printf("UPNPIGD_IsConnected(%s) = %d\n",
889                                       urls->controlURL,
890                                   UPNPIGD_IsConnected(urls, data));
891#endif
892                                    if((state >= 2) || UPNPIGD_IsConnected(urls, data))
893                                          return state;
894                                    FreeUPNPUrls(urls);
895                                  }
896                                }
897                                memset(data, 0, sizeof(struct IGDdatas));
898                        }
899#ifdef DEBUG
900                        else
901                        {
902                                printf("error getting XML description %s\n", dev->descURL);
903                        }
904#endif
905                }
906        }
907        return 0;
908}
909
910/* UPNP_GetIGDFromUrl()
911 * Used when skipping the discovery process.
912 * return value :
913 *   0 - Not ok
914 *   1 - OK */
915int
916UPNP_GetIGDFromUrl(const char * rootdescurl,
917                   struct UPNPUrls * urls,
918                   struct IGDdatas * data,
919                   char * lanaddr, int lanaddrlen)
920{
921        char * descXML;
922        int descXMLsize = 0;
923        descXML = miniwget_getaddr(rootdescurl, &descXMLsize,
924                                       lanaddr, lanaddrlen);
925        if(descXML) {
926                memset(data, 0, sizeof(struct IGDdatas));
927                memset(urls, 0, sizeof(struct UPNPUrls));
928                parserootdesc(descXML, descXMLsize, data);
929                free(descXML);
930                descXML = NULL;
931                GetUPNPUrls(urls, data, rootdescurl);
932                return 1;
933        } else {
934                return 0;
935        }
936}
937
Note: See TracBrowser for help on using the repository browser.