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

Last change on this file since 6848 was 6848, checked in by charles, 14 years ago

updated to miniupnpc-20081002
File size: 17.4 KB
Line 
1/* $Id: miniupnpc.c,v 1.55 2008/09/25 18:02:50 nanard Exp $ */
2/* Project : miniupnp
3 * Author : Thomas BERNARD
4 * copyright (c) 2005-2007 Thomas Bernard
5 * This software is subjet to the conditions detailed in the
6 * provided LICENCE file. */
7#include <stdio.h>
8#include <stdlib.h>
9#include <string.h>
10#ifdef WIN32
11#include <winsock2.h>
12#include <Ws2tcpip.h>
13#include <io.h>
14#define snprintf _snprintf
15#define strncasecmp memicmp
16#define MAXHOSTNAMELEN 64
17#else
18#include <unistd.h>
19#include <sys/socket.h>
20#include <sys/types.h>
21#include <sys/param.h>
22#include <netinet/in.h>
23#include <arpa/inet.h>
24#include <poll.h>
25#include <netdb.h>
26#define closesocket close
27#endif
28#include "miniupnpc.h"
29#include "minissdpc.h"
30#include "miniwget.h"
31#include "minisoap.h"
32#include "minixml.h"
33#include "upnpcommands.h"
34
35#ifdef WIN32
36#define PRINT_SOCKET_ERROR(x)    printf("Socket error: %s, %d\n", x, WSAGetLastError());
37#else
38#define PRINT_SOCKET_ERROR(x) perror(x)
39#endif
40
41#define SOAPPREFIX "s"
42
43/* root description parsing */
44void parserootdesc(const char * buffer, int bufsize, struct IGDdatas * data)
45{
46        struct xmlparser parser;
47        /* xmlparser object */
48        parser.xmlstart = buffer;
49        parser.xmlsize = bufsize;
50        parser.data = data;
51        parser.starteltfunc = IGDstartelt;
52        parser.endeltfunc = IGDendelt;
53        parser.datafunc = IGDdata;
54        parser.attfunc = 0;
55        parsexml(&parser);
56#ifndef NDEBUG
57        printIGD(data);
58#endif
59}
60
61/* Content-length: nnn */
62static int getcontentlenfromline(const char * p, int n)
63{
64        static const char contlenstr[] = "content-length";
65        const char * p2 = contlenstr;
66        int a = 0;
67        while(*p2)
68        {
69                if(n==0)
70                        return -1;
71                if(*p2 != *p && *p2 != (*p + 32))
72                        return -1;
73                p++; p2++; n--;
74        }
75        if(n==0)
76                return -1;
77        if(*p != ':')
78                return -1;
79        p++; n--;
80        while(*p == ' ')
81        {
82                if(n==0)
83                        return -1;
84                p++; n--;
85        }
86        while(*p >= '0' && *p <= '9')
87        {
88                if(n==0)
89                        return -1;
90                a = (a * 10) + (*p - '0');
91                p++; n--;
92        }
93        return a;
94}
95
96static void
97getContentLengthAndHeaderLength(char * p, int n,
98                                int * contentlen, int * headerlen)
99{
100        char * line;
101        int linelen;
102        int r;
103        line = p;
104        while(line < p + n)
105        {
106                linelen = 0;
107                while(line[linelen] != '\r' && line[linelen] != '\r')
108                {
109                        if(line+linelen >= p+n)
110                                return;
111                        linelen++;
112                }
113                r = getcontentlenfromline(line, linelen);
114                if(r>0)
115                        *contentlen = r;
116                line = line + linelen + 2;
117                if(line[0] == '\r' && line[1] == '\n')
118                {
119                        *headerlen = (line - p) + 2;
120                        return;
121                }
122        }
123}
124
125/* simpleUPnPcommand :
126 * not so simple !
127 * return values :
128 *   0 - OK
129 *  -1 - error */
130int simpleUPnPcommand(int s, const char * url, const char * service,
131                      const char * action, struct UPNParg * args,
132                      char * buffer, int * bufsize)
133{
134        struct sockaddr_in dest;
135        char hostname[MAXHOSTNAMELEN+1];
136        unsigned short port = 0;
137        char * path;
138        char soapact[128];
139        char soapbody[2048];
140        char * buf;
141        int buffree;
142    int n;
143        int contentlen, headerlen;      /* for the response */
144        snprintf(soapact, sizeof(soapact), "%s#%s", service, action);
145        if(args==NULL)
146        {
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                                                  "<m:%s xmlns:m=\"%s\">"
154                                                  "</m:%s>"
155                                                  "</" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>"
156                                                  "\r\n", action, service, action);
157        }
158        else
159        {
160                char * p;
161                const char * pe, * pv;
162                int soapbodylen;
163                soapbodylen = snprintf(soapbody, sizeof(soapbody),
164                                                "<?xml version=\"1.0\"?>\r\n"
165                            "<" SOAPPREFIX ":Envelope "
166                                                "xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
167                                                SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
168                                                "<" SOAPPREFIX ":Body>"
169                                                "<m:%s xmlns:m=\"%s\">",
170                                                action, service);
171                p = soapbody + soapbodylen;
172                while(args->elt)
173                {
174                        /* check that we are never overflowing the string... */
175                        if(soapbody + sizeof(soapbody) <= p + 100)
176                        {
177                                /* we keep a margin of at least 100 bytes */
178                                *bufsize = 0;
179                                return -1;
180                        }
181                        *(p++) = '<';
182                        pe = args->elt;
183                        while(*pe)
184                                *(p++) = *(pe++);
185                        *(p++) = '>';
186                        if((pv = args->val))
187                        {
188                                while(*pv)
189                                        *(p++) = *(pv++);
190                        }
191                        *(p++) = '<';
192                        *(p++) = '/';
193                        pe = args->elt;
194                        while(*pe)
195                                *(p++) = *(pe++);
196                        *(p++) = '>';
197                        args++;
198                }
199                *(p++) = '<';
200                *(p++) = '/';
201                *(p++) = 'm';
202                *(p++) = ':';
203                pe = action;
204                while(*pe)
205                        *(p++) = *(pe++);
206                strncpy(p, "></" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>\r\n",
207                        soapbody + sizeof(soapbody) - p);
208        }
209        if(!parseURL(url, hostname, &port, &path)) return -1;
210        if(s<0)
211        {
212                s = socket(PF_INET, SOCK_STREAM, 0);
213                if(s<0)
214                {
215                        PRINT_SOCKET_ERROR("socket");
216                        *bufsize = 0;
217                        return -1;
218                }
219                dest.sin_family = AF_INET;
220                dest.sin_port = htons(port);
221                dest.sin_addr.s_addr = inet_addr(hostname);
222                if(connect(s, (struct sockaddr *)&dest, sizeof(struct sockaddr))<0)
223                {
224                        PRINT_SOCKET_ERROR("connect");
225                        closesocket(s);
226                        *bufsize = 0;
227                        return -1;
228                }
229        }
230
231        n = soapPostSubmit(s, path, hostname, port, soapact, soapbody);
232        if(n<=0) {
233#ifdef DEBUG
234                printf("Error sending SOAP request\n");
235#endif
236                closesocket(s);
237                return -1;
238        }
239
240        contentlen = -1;
241        headerlen = -1;
242        buf = buffer;
243        buffree = *bufsize;
244        *bufsize = 0;
245        while ((n = ReceiveData(s, buf, buffree, 5000)) > 0) {
246                buffree -= n;
247                buf += n;
248                *bufsize += n;
249                getContentLengthAndHeaderLength(buffer, *bufsize,
250                                                &contentlen, &headerlen);
251#ifdef DEBUG
252                printf("received n=%dbytes bufsize=%d ContLen=%d HeadLen=%d\n",
253                       n, *bufsize, contentlen, headerlen);
254#endif
255                /* break if we received everything */
256                if(contentlen > 0 && headerlen > 0 && *bufsize >= contentlen+headerlen)
257                        break;
258        }
259       
260        closesocket(s);
261        return 0;
262}
263
264/* parseMSEARCHReply()
265 * the last 4 arguments are filled during the parsing :
266 *    - location/locationsize : "location:" field of the SSDP reply packet
267 *    - st/stsize : "st:" field of the SSDP reply packet.
268 * The strings are NOT null terminated */
269static void
270parseMSEARCHReply(const char * reply, int size,
271                  const char * * location, int * locationsize,
272                              const char * * st, int * stsize)
273{
274        int a, b, i;
275        i = 0;
276        a = i;  /* start of the line */
277        b = 0;
278        while(i<size)
279        {
280                switch(reply[i])
281                {
282                case ':':
283                                if(b==0)
284                                {
285                                        b = i; /* end of the "header" */
286                                        /*for(j=a; j<b; j++)
287                                        {
288                                                putchar(reply[j]);
289                                        }
290                                        */
291                                }
292                                break;
293                case '\x0a':
294                case '\x0d':
295                                if(b!=0)
296                                {
297                                        /*for(j=b+1; j<i; j++)
298                                        {
299                                                putchar(reply[j]);
300                                        }
301                                        putchar('\n');*/
302                                        do { b++; } while(reply[b]==' ');
303                                        if(0==strncasecmp(reply+a, "location", 8))
304                                        {
305                                                *location = reply+b;
306                                                *locationsize = i-b;
307                                        }
308                                        else if(0==strncasecmp(reply+a, "st", 2))
309                                        {
310                                                *st = reply+b;
311                                                *stsize = i-b;
312                                        }
313                                        b = 0;
314                                }
315                                a = i+1;
316                                break;
317                default:
318                                break;
319                }
320                i++;
321        }
322}
323
324/* port upnp discover : SSDP protocol */
325#define PORT 1900
326#define XSTR(s) STR(s)
327#define STR(s) #s
328#define UPNP_MCAST_ADDR "239.255.255.250"
329
330/* upnpDiscover() :
331 * return a chained list of all devices found or NULL if
332 * no devices was found.
333 * It is up to the caller to free the chained list
334 * delay is in millisecond (poll) */
335struct UPNPDev * upnpDiscover(int delay, const char * multicastif,
336                              const char * minissdpdsock, int sameport)
337{
338        struct UPNPDev * tmp;
339        struct UPNPDev * devlist = 0;
340        int opt = 1;
341        static const char MSearchMsgFmt[] = 
342        "M-SEARCH * HTTP/1.1\r\n"
343        "HOST: " UPNP_MCAST_ADDR ":" XSTR(PORT) "\r\n"
344        "ST: %s\r\n"
345        "MAN: \"ssdp:discover\"\r\n"
346        "MX: 3\r\n"
347        "\r\n";
348        static const char * const deviceList[] = {
349                "urn:schemas-upnp-org:device:InternetGatewayDevice:1",
350                "urn:schemas-upnp-org:service:WANIPConnection:1",
351                "urn:schemas-upnp-org:service:WANPPPConnection:1",
352                "upnp:rootdevice",
353                0
354        };
355        int deviceIndex = 0;
356        char bufr[1536];        /* reception and emission buffer */
357        int sudp;
358        int n;
359        struct sockaddr_in sockudp_r, sockudp_w;
360
361#ifndef WIN32
362        /* first try to get infos from minissdpd ! */
363        if(!minissdpdsock)
364                minissdpdsock = "/var/run/minissdpd.sock";
365        while(!devlist && deviceList[deviceIndex]) {
366                devlist = getDevicesFromMiniSSDPD(deviceList[deviceIndex],
367                                                  minissdpdsock);
368                /* We return what we have found if it was not only a rootdevice */
369                if(devlist && !strstr(deviceList[deviceIndex], "rootdevice"))
370                        return devlist;
371                deviceIndex++;
372        }
373        deviceIndex = 0;
374#endif
375        /* fallback to direct discovery */
376#ifdef WIN32
377        sudp = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
378#else
379        sudp = socket(PF_INET, SOCK_DGRAM, 0);
380#endif
381        if(sudp < 0)
382        {
383                PRINT_SOCKET_ERROR("socket");
384                return NULL;
385        }
386    /* reception */
387    memset(&sockudp_r, 0, sizeof(struct sockaddr_in));
388    sockudp_r.sin_family = AF_INET;
389        if(sameport)
390        sockudp_r.sin_port = htons(PORT);
391    sockudp_r.sin_addr.s_addr = INADDR_ANY;
392    /* emission */
393    memset(&sockudp_w, 0, sizeof(struct sockaddr_in));
394    sockudp_w.sin_family = AF_INET;
395    sockudp_w.sin_port = htons(PORT);
396    sockudp_w.sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
397
398#ifdef WIN32
399        if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)
400#else
401        if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
402#endif
403        {
404                PRINT_SOCKET_ERROR("setsockopt");
405                return NULL;
406        }
407
408        if(multicastif)
409        {
410                struct in_addr mc_if;
411                mc_if.s_addr = inet_addr(multicastif);
412        sockudp_r.sin_addr.s_addr = mc_if.s_addr;
413                if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
414                {
415                        PRINT_SOCKET_ERROR("setsockopt");
416                }
417        }
418
419        /* Avant d'envoyer le paquet on bind pour recevoir la reponse */
420    if (bind(sudp, (struct sockaddr *)&sockudp_r, sizeof(struct sockaddr_in)) != 0)
421        {
422        PRINT_SOCKET_ERROR("bind");
423                closesocket(sudp);
424                return NULL;
425    }
426
427        /* receiving SSDP response packet */
428        for(n = 0;;)
429        {
430        if(n == 0)
431        {
432                /* sending the SSDP M-SEARCH packet */
433                n = snprintf(bufr, sizeof(bufr),
434                             MSearchMsgFmt, deviceList[deviceIndex++]);
435                /*printf("Sending %s", bufr);*/
436                n = sendto(sudp, bufr, n, 0,
437                           (struct sockaddr *)&sockudp_w, sizeof(struct sockaddr_in));
438                if (n < 0) {
439                        PRINT_SOCKET_ERROR("sendto");
440                        closesocket(sudp);
441                        return devlist;
442                }
443        }
444        /* Waiting for SSDP REPLY packet to M-SEARCH */
445        n = ReceiveData(sudp, bufr, sizeof(bufr), delay);
446        if (n < 0) {
447                /* error */
448                closesocket(sudp);
449                return devlist;
450        } else if (n == 0) {
451                /* no data or Time Out */
452                if (devlist || (deviceList[deviceIndex] == 0)) {
453                        /* no more device type to look for... */
454                        closesocket(sudp);
455                        return devlist;
456                }
457        } else {
458                const char * descURL=NULL;
459                int urlsize=0;
460                const char * st=NULL;
461                int stsize=0;
462        /*printf("%d byte(s) :\n%s\n", n, bufr);*/ /* affichage du message */
463                parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize);
464                if(st&&descURL)
465                {
466                        /*printf("M-SEARCH Reply:\nST: %.*s\nLocation: %.*s\n",
467                               stsize, st, urlsize, descURL); */
468                        tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
469                        tmp->pNext = devlist;
470                        tmp->descURL = tmp->buffer;
471                        tmp->st = tmp->buffer + 1 + urlsize;
472                        memcpy(tmp->buffer, descURL, urlsize);
473                        tmp->buffer[urlsize] = '\0';
474                        memcpy(tmp->buffer + urlsize + 1, st, stsize);
475                        tmp->buffer[urlsize+1+stsize] = '\0';
476                        devlist = tmp;
477                }
478        }
479        }
480}
481
482/* freeUPNPDevlist() should be used to
483 * free the chained list returned by upnpDiscover() */
484void freeUPNPDevlist(struct UPNPDev * devlist)
485{
486        struct UPNPDev * next;
487        while(devlist)
488        {
489                next = devlist->pNext;
490                free(devlist);
491                devlist = next;
492        }
493}
494
495static void
496url_cpy_or_cat(char * dst, const char * src, int n)
497{
498        if(  (src[0] == 'h')
499           &&(src[1] == 't')
500           &&(src[2] == 't')
501           &&(src[3] == 'p')
502           &&(src[4] == ':')
503           &&(src[5] == '/')
504           &&(src[6] == '/'))
505        {
506                strncpy(dst, src, n);
507        }
508        else
509        {
510                int l = strlen(dst);
511                if(src[0] != '/')
512                        dst[l++] = '/';
513                if(l<=n)
514                        strncpy(dst + l, src, n - l);
515        }
516}
517
518/* Prepare the Urls for usage...
519 */
520void GetUPNPUrls(struct UPNPUrls * urls, struct IGDdatas * data,
521                 const char * descURL)
522{
523        char * p;
524        int n1, n2, n3;
525        n1 = strlen(data->urlbase);
526        if(n1==0)
527                n1 = strlen(descURL);
528        n1 += 2;        /* 1 byte more for Null terminator, 1 byte for '/' if needed */
529        n2 = n1; n3 = n1;
530        n1 += strlen(data->scpdurl);
531        n2 += strlen(data->controlurl);
532        n3 += strlen(data->controlurl_CIF);
533
534        urls->ipcondescURL = (char *)malloc(n1);
535        urls->controlURL = (char *)malloc(n2);
536        urls->controlURL_CIF = (char *)malloc(n3);
537        /* maintenant on chope la desc du WANIPConnection */
538        if(data->urlbase[0] != '\0')
539                strncpy(urls->ipcondescURL, data->urlbase, n1);
540        else
541                strncpy(urls->ipcondescURL, descURL, n1);
542        p = strchr(urls->ipcondescURL+7, '/');
543        if(p) p[0] = '\0';
544        strncpy(urls->controlURL, urls->ipcondescURL, n2);
545        strncpy(urls->controlURL_CIF, urls->ipcondescURL, n3);
546       
547        url_cpy_or_cat(urls->ipcondescURL, data->scpdurl, n1);
548
549        url_cpy_or_cat(urls->controlURL, data->controlurl, n2);
550
551        url_cpy_or_cat(urls->controlURL_CIF, data->controlurl_CIF, n3);
552
553#ifdef DEBUG
554        printf("urls->ipcondescURL='%s' %d n1=%d\n", urls->ipcondescURL,
555               strlen(urls->ipcondescURL), n1);
556        printf("urls->controlURL='%s' %d n2=%d\n", urls->controlURL,
557               strlen(urls->controlURL), n2);
558        printf("urls->controlURL_CIF='%s' %d n3=%d\n", urls->controlURL_CIF,
559               strlen(urls->controlURL_CIF), n3);
560#endif
561}
562
563void
564FreeUPNPUrls(struct UPNPUrls * urls)
565{
566        if(!urls)
567                return;
568        free(urls->controlURL);
569        urls->controlURL = 0;
570        free(urls->ipcondescURL);
571        urls->ipcondescURL = 0;
572        free(urls->controlURL_CIF);
573        urls->controlURL_CIF = 0;
574}
575
576
577int ReceiveData(int socket, char * data, int length, int timeout)
578{
579    int n;
580#ifndef WIN32
581    struct pollfd fds[1]; /* for the poll */
582    fds[0].fd = socket;
583    fds[0].events = POLLIN;
584    n = poll(fds, 1, timeout);
585    if(n < 0)
586    {
587        PRINT_SOCKET_ERROR("poll");
588        return -1;
589    }
590    else if(n == 0)
591    {
592        return 0;
593    }
594#else
595    fd_set socketSet;
596    TIMEVAL timeval;
597    FD_ZERO(&socketSet);
598    FD_SET(socket, &socketSet);
599    timeval.tv_sec = timeout / 1000;
600    timeval.tv_usec = (timeout % 1000) * 1000;
601    /*n = select(0, &socketSet, NULL, NULL, &timeval);*/
602    n = select(FD_SETSIZE, &socketSet, NULL, NULL, &timeval);
603    if(n < 0)
604    {
605        PRINT_SOCKET_ERROR("select");
606        return -1;
607    }
608    else if(n == 0)
609    {
610        return 0;
611    }   
612#endif
613        n = recv(socket, data, length, 0);
614        if(n<0)
615        {
616                PRINT_SOCKET_ERROR("recv");
617        }
618        return n;
619}
620
621int
622UPNPIGD_IsConnected(struct UPNPUrls * urls, struct IGDdatas * data)
623{
624        char status[64];
625        unsigned int uptime;
626        status[0] = '\0';
627        UPNP_GetStatusInfo(urls->controlURL, data->servicetype,
628                           status, &uptime, NULL);
629        if(0 == strcmp("Connected", status))
630        {
631                return 1;
632        }
633        else
634                return 0;
635}
636
637
638/* UPNP_GetValidIGD() :
639 * return values :
640 *     0 = NO IGD found
641 *     1 = A valid connected IGD has been found
642 *     2 = A valid IGD has been found but it reported as
643 *         not connected
644 *     3 = an UPnP device has been found but was not recognized as an IGD
645 *
646 * In any non zero return case, the urls and data structures
647 * passed as parameters are set. Donc forget to call FreeUPNPUrls(urls) to
648 * free allocated memory.
649 */
650int
651UPNP_GetValidIGD(struct UPNPDev * devlist,
652                 struct UPNPUrls * urls,
653                                 struct IGDdatas * data,
654                                 char * lanaddr, int lanaddrlen)
655{
656        char * descXML;
657        int descXMLsize = 0;
658        struct UPNPDev * dev;
659        int ndev = 0;
660        int state; /* state 1 : IGD connected. State 2 : IGD. State 3 : anything */
661        if(!devlist)
662        {
663#ifdef DEBUG
664                printf("Empty devlist\n");
665#endif
666                return 0;
667        }
668        for(state = 1; state <= 3; state++)
669        {
670                for(dev = devlist; dev; dev = dev->pNext)
671                {
672                        /* we should choose an internet gateway device.
673                        * with st == urn:schemas-upnp-org:device:InternetGatewayDevice:1 */
674                        descXML = miniwget_getaddr(dev->descURL, &descXMLsize,
675                                                        lanaddr, lanaddrlen);
676                        if(descXML)
677                        {
678                                ndev++;
679                                memset(data, 0, sizeof(struct IGDdatas));
680                                memset(urls, 0, sizeof(struct UPNPUrls));
681                                parserootdesc(descXML, descXMLsize, data);
682                                free(descXML);
683                                descXML = NULL;
684                                if(0==strcmp(data->servicetype_CIF,
685                                   "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1")
686                                   || state >= 3 )
687                                {
688                                  GetUPNPUrls(urls, data, dev->descURL);
689
690#ifdef DEBUG
691                                  printf("UPNPIGD_IsConnected(%s) = %d\n",
692                                     urls->controlURL,
693                                 UPNPIGD_IsConnected(urls, data));
694#endif
695                                  if((state >= 2) || UPNPIGD_IsConnected(urls, data))
696                                        return state;
697                                  FreeUPNPUrls(urls);
698                                }
699                                memset(data, 0, sizeof(struct IGDdatas));
700                        }
701#ifdef DEBUG
702                        else
703                        {
704                                printf("error getting XML description %s\n", dev->descURL);
705                        }
706#endif
707                }
708        }
709        return 0;
710}
711
712/* UPNP_GetIGDFromUrl()
713 * Used when skipping the discovery process.
714 * return value :
715 *   0 - Not ok
716 *   1 - OK */
717int
718UPNP_GetIGDFromUrl(const char * rootdescurl,
719                   struct UPNPUrls * urls,
720                   struct IGDdatas * data,
721                   char * lanaddr, int lanaddrlen)
722{
723        char * descXML;
724        int descXMLsize = 0;
725        descXML = miniwget_getaddr(rootdescurl, &descXMLsize,
726                                       lanaddr, lanaddrlen);
727        if(descXML) {
728                memset(data, 0, sizeof(struct IGDdatas));
729                memset(urls, 0, sizeof(struct UPNPUrls));
730                parserootdesc(descXML, descXMLsize, data);
731                free(descXML);
732                descXML = NULL;
733                GetUPNPUrls(urls, data, rootdescurl);
734                return 1;
735        } else {
736                return 0;
737        }
738}
739
Note: See TracBrowser for help on using the repository browser.