Ignore:
Timestamp:
Jul 26, 2011, 1:36:30 AM (10 years ago)
Author:
livings124
Message:

#4387 Update miniupnpc to 1.6

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/third-party/miniupnp/miniupnpc.c

    r11577 r12593  
    1 /* $Id: miniupnpc.c,v 1.85 2010/12/21 16:13:14 nanard Exp $ */
     1/* $Id: miniupnpc.c,v 1.95 2011/05/15 21:42:26 nanard Exp $ */
    22/* Project : miniupnp
    33 * Author : Thomas BERNARD
    4  * copyright (c) 2005-2010 Thomas Bernard
     4 * copyright (c) 2005-2011 Thomas Bernard
    55 * This software is subjet to the conditions detailed in the
    66 * provided LICENSE file. */
     
    2727#include <iphlpapi.h>
    2828#define snprintf _snprintf
     29#ifndef strncasecmp
    2930#if defined(_MSC_VER) && (_MSC_VER >= 1400)
    3031#define strncasecmp _memicmp
     
    3233#define strncasecmp memicmp
    3334#endif /* defined(_MSC_VER) && (_MSC_VER >= 1400) */
     35#endif /* #ifndef strncasecmp */
    3436#define MAXHOSTNAMELEN 64
    3537#else /* #ifdef WIN32 */
     
    4850#include <arpa/inet.h>
    4951#include <netdb.h>
     52#include <net/if.h>
    5053#if !defined(__amigaos__) && !defined(__amigaos4__)
    5154#include <poll.h>
     
    5457#include <errno.h>
    5558#define closesocket close
    56 #define MINIUPNPC_IGNORE_EINTR
    5759#endif /* #else WIN32 */
    5860#ifdef MINIUPNPC_SET_SOCKET_TIMEOUT
     
    7173#include "upnpcommands.h"
    7274#include "connecthostport.h"
     75#include "receivedata.h"
    7376
    7477#ifdef WIN32
     
    100103}
    101104
    102 #if 0
    103 /* getcontentlenfromline() : parse the Content-Length HTTP header line.
    104  * Content-length: nnn */
    105 static int getcontentlenfromline(const char * p, int n)
    106 {
    107         static const char contlenstr[] = "content-length";
    108         const char * p2 = contlenstr;
    109         int a = 0;
    110         while(*p2)
    111         {
    112                 if(n==0)
    113                         return -1;
    114                 if(*p2 != *p && *p2 != (*p + 32))
    115                         return -1;
    116                 p++; p2++; n--;
    117         }
    118         if(n==0)
    119                 return -1;
    120         if(*p != ':')
    121                 return -1;
    122         p++; n--;
    123         while(*p == ' ')
    124         {
    125                 if(n==0)
    126                         return -1;
    127                 p++; n--;
    128         }
    129         while(*p >= '0' && *p <= '9')
    130         {
    131                 if(n==0)
    132                         return -1;
    133                 a = (a * 10) + (*p - '0');
    134                 p++; n--;
    135         }
    136         return a;
    137 }
    138 
    139 /* getContentLengthAndHeaderLength()
    140  * retrieve header length and content length from an HTTP response
    141  * TODO : retrieve Transfer-Encoding: header value, in order to support
    142  *        HTTP/1.1, chunked transfer encoding must be supported. */
    143 static void
    144 getContentLengthAndHeaderLength(char * p, int n,
    145                                 int * contentlen, int * headerlen)
    146 {
    147         char * line;
    148         int linelen;
    149         int r;
    150         line = p;
    151         while(line < p + n)
    152         {
    153                 linelen = 0;
    154                 while(line[linelen] != '\r' && line[linelen] != '\r')
    155                 {
    156                         if(line+linelen >= p+n)
    157                                 return;
    158                         linelen++;
    159                 }
    160                 r = getcontentlenfromline(line, linelen);
    161                 if(r>0)
    162                         *contentlen = r;
    163                 line = line + linelen + 2;
    164                 if(line[0] == '\r' && line[1] == '\n')
    165                 {
    166                         *headerlen = (line - p) + 2;
    167                         return;
    168                 }
    169         }
    170 }
    171 #endif
    172 
    173105/* simpleUPnPcommand2 :
    174106 * not so simple !
    175107 * return values :
    176  *   0 - OK
    177  *  -1 - error */
    178 static int simpleUPnPcommand2(int s, const char * url, const char * service,
     108 *   pointer - OK
     109 *   NULL - error */
     110char * simpleUPnPcommand2(int s, const char * url, const char * service,
    179111                       const char * action, struct UPNParg * args,
    180                        char * buffer, int * bufsize, const char * httpversion)
     112                       int * bufsize, const char * httpversion)
    181113{
    182114        char hostname[MAXHOSTNAMELEN+1];
     
    186118        char soapbody[2048];
    187119        char * buf;
    188         /*int buffree;*/
    189120    int n;
    190         /*int contentlen, headerlen;*/  /* for the response */
    191 
     121
     122        *bufsize = 0;
    192123        snprintf(soapact, sizeof(soapact), "%s#%s", service, action);
    193124        if(args==NULL)
     
    224155                        {
    225156                                /* we keep a margin of at least 100 bytes */
    226                                 *bufsize = 0;
    227                                 return -1;
     157                                return NULL;
    228158                        }
    229159                        *(p++) = '<';
     
    255185                        soapbody + sizeof(soapbody) - p);
    256186        }
    257         if(!parseURL(url, hostname, &port, &path)) return -1;
     187        if(!parseURL(url, hostname, &port, &path)) return NULL;
    258188        if(s<0)
    259189        {
     
    261191                if(s < 0)
    262192                {
    263                         *bufsize = 0;
    264                         return -1;
     193                        return NULL;
    265194                }
    266195        }
     
    272201#endif
    273202                closesocket(s);
    274                 return -1;
    275         }
    276 
    277 #if 0
    278         contentlen = -1;
    279         headerlen = -1;
    280         buf = buffer;
    281         buffree = *bufsize;
    282         *bufsize = 0;
    283         while ((n = ReceiveData(s, buf, buffree, 5000)) > 0) {
    284                 buffree -= n;
    285                 buf += n;
    286                 *bufsize += n;
    287                 getContentLengthAndHeaderLength(buffer, *bufsize,
    288                                                 &contentlen, &headerlen);
    289 #ifdef DEBUG
    290                 printf("received n=%dbytes bufsize=%d ContLen=%d HeadLen=%d\n",
    291                        n, *bufsize, contentlen, headerlen);
    292 #endif
    293                 /* break if we received everything */
    294                 if(contentlen > 0 && headerlen > 0 && *bufsize >= contentlen+headerlen)
    295                         break;
    296         }
    297 #endif
    298         buf = getHTTPResponse(s, &n);
    299         if(n > 0 && buf)
    300         {
    301 #ifdef DEBUG
    302                 printf("SOAP Response :\n%.*s\n", n, buf);
    303 #endif
    304                 if(*bufsize > n)
    305                 {
    306                         memcpy(buffer, buf, n);
    307                         *bufsize = n;
    308                 }
    309                 else
    310                 {
    311                         memcpy(buffer, buf, *bufsize);
    312                 }
    313                 free(buf);
    314                 buf = 0;
    315         }
     203                return NULL;
     204        }
     205
     206        buf = getHTTPResponse(s, bufsize);
     207#ifdef DEBUG
     208        if(*bufsize > 0 && buf)
     209        {
     210                printf("SOAP Response :\n%.*s\n", *bufsize, buf);
     211        }
     212#endif
    316213        closesocket(s);
    317         return 0;
     214        return buf;
    318215}
    319216
     
    321218 * not so simple !
    322219 * return values :
    323  *   0 - OK
    324  *  -1 - error */
    325 int simpleUPnPcommand(int s, const char * url, const char * service,
     220 *   pointer - OK
     221 *   NULL    - error */
     222char * simpleUPnPcommand(int s, const char * url, const char * service,
    326223                       const char * action, struct UPNParg * args,
    327                        char * buffer, int * bufsize)
    328 {
    329         int result;
    330         /*int origbufsize = *bufsize;*/
    331 
    332         result = simpleUPnPcommand2(s, url, service, action, args, buffer, bufsize, "1.1");
     224                       int * bufsize)
     225{
     226        char * buf;
     227
     228        buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.1");
    333229/*
    334         result = simpleUPnPcommand2(s, url, service, action, args, buffer, bufsize, "1.0");
    335         if (result < 0 || *bufsize == 0)
     230        buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.0");
     231        if (!buf || *bufsize == 0)
    336232        {
    337233#if DEBUG
    338234            printf("Error or no result from SOAP request; retrying with HTTP/1.1\n");
    339235#endif
    340                 *bufsize = origbufsize;
    341                 result = simpleUPnPcommand2(s, url, service, action, args, buffer, bufsize, "1.1");
     236                buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.1");
    342237        }
    343238*/
    344         return result;
     239        return buf;
    345240}
    346241
     
    358253        i = 0;
    359254        a = i;  /* start of the line */
    360         b = 0;
     255        b = 0;  /* end of the "header" (position of the colon) */
    361256        while(i<size)
    362257        {
     
    383278                                        }
    384279                                        putchar('\n');*/
     280                                        /* skip the colon and white spaces */
    385281                                        do { b++; } while(reply[b]==' ');
    386282                                        if(0==strncasecmp(reply+a, "location", 8))
     
    410306#define STR(s) #s
    411307#define UPNP_MCAST_ADDR "239.255.255.250"
     308/* for IPv6 */
     309#define UPNP_MCAST_LL_ADDR "FF02::C" /* link-local */
     310#define UPNP_MCAST_SL_ADDR "FF05::C" /* site-local */
    412311
    413312/* upnpDiscover() :
     
    416315 * It is up to the caller to free the chained list
    417316 * delay is in millisecond (poll) */
    418 LIBSPEC struct UPNPDev * upnpDiscover(int delay, const char * multicastif,
    419                               const char * minissdpdsock, int sameport)
     317LIBSPEC struct UPNPDev *
     318upnpDiscover(int delay, const char * multicastif,
     319             const char * minissdpdsock, int sameport,
     320             int ipv6,
     321             int * error)
    420322{
    421323        struct UPNPDev * tmp;
     
    424326        static const char MSearchMsgFmt[] =
    425327        "M-SEARCH * HTTP/1.1\r\n"
    426         "HOST: " UPNP_MCAST_ADDR ":" XSTR(PORT) "\r\n"
     328        "HOST: %s:" XSTR(PORT) "\r\n"
    427329        "ST: %s\r\n"
    428330        "MAN: \"ssdp:discover\"\r\n"
     
    430332        "\r\n";
    431333        static const char * const deviceList[] = {
     334#if 0
     335                "urn:schemas-upnp-org:device:InternetGatewayDevice:2",
     336                "urn:schemas-upnp-org:service:WANIPConnection:2",
     337#endif
    432338                "urn:schemas-upnp-org:device:InternetGatewayDevice:1",
    433339                "urn:schemas-upnp-org:service:WANIPConnection:1",
     
    440346        int sudp;
    441347        int n;
    442         struct sockaddr sockudp_r;
     348        struct sockaddr_storage sockudp_r;
    443349        unsigned int mx;
    444350#ifdef NO_GETADDRINFO
    445         struct sockaddr_in sockudp_w;
     351        struct sockaddr_storage sockudp_w;
    446352#else
    447353        int rv;
     
    451357        MIB_IPFORWARDROW ip_forward;
    452358#endif
    453 
     359        int linklocal = 1;
     360
     361        if(error)
     362                *error = UPNPDISCOVER_UNKNOWN_ERROR;
    454363#if !defined(WIN32) && !defined(__amigaos__) && !defined(__amigaos4__)
    455364        /* first try to get infos from minissdpd ! */
     
    460369                                                  minissdpdsock);
    461370                /* We return what we have found if it was not only a rootdevice */
    462                 if(devlist && !strstr(deviceList[deviceIndex], "rootdevice"))
     371                if(devlist && !strstr(deviceList[deviceIndex], "rootdevice")) {
     372                        if(error)
     373                                *error = UPNPDISCOVER_SUCCESS;
    463374                        return devlist;
     375                }
    464376                deviceIndex++;
    465377        }
     
    468380        /* fallback to direct discovery */
    469381#ifdef WIN32
    470         sudp = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
     382        sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP);
    471383#else
    472         sudp = socket(PF_INET, SOCK_DGRAM, 0);
     384        sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0);
    473385#endif
    474386        if(sudp < 0)
    475387        {
     388                if(error)
     389                        *error = UPNPDISCOVER_SOCKET_ERROR;
    476390                PRINT_SOCKET_ERROR("socket");
    477391                return NULL;
    478392        }
    479393        /* reception */
    480         memset(&sockudp_r, 0, sizeof(struct sockaddr));
    481         if(0/*ipv6*/) {
     394        memset(&sockudp_r, 0, sizeof(struct sockaddr_storage));
     395        if(ipv6) {
    482396                struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_r;
    483397                p->sin6_family = AF_INET6;
    484398                if(sameport)
    485399                        p->sin6_port = htons(PORT);
    486                 p->sin6_addr = in6addr_any;//IN6ADDR_ANY_INIT;/*INADDR_ANY;*/
     400                p->sin6_addr = in6addr_any; /* in6addr_any is not available with MinGW32 3.4.2 */
    487401        } else {
    488402                struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_r;
     
    497411/* Get IP associated with the index given in the ip_forward struct
    498412 * in order to give this ip to setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF) */
    499         if(GetBestRoute(inet_addr("223.255.255.255"), 0, &ip_forward) == NO_ERROR) {
     413        if(!ipv6
     414           && (GetBestRoute(inet_addr("223.255.255.255"), 0, &ip_forward) == NO_ERROR)) {
    500415                DWORD dwRetVal = 0;
    501416                PMIB_IPADDRTABLE pIPAddrTable;
     
    557472#endif
    558473        {
     474                if(error)
     475                        *error = UPNPDISCOVER_SOCKET_ERROR;
    559476                PRINT_SOCKET_ERROR("setsockopt");
    560477                return NULL;
     
    563480        if(multicastif)
    564481        {
    565                 struct in_addr mc_if;
    566                 mc_if.s_addr = inet_addr(multicastif);
    567                 if(0/*ipv6*/) {
     482                if(ipv6) {
     483#if !defined(WIN32)
     484                        /* according to MSDN, if_nametoindex() is supported since
     485                         * MS Windows Vista and MS Windows Server 2008.
     486                         * http://msdn.microsoft.com/en-us/library/bb408409%28v=vs.85%29.aspx */
     487                        unsigned int ifindex = if_nametoindex(multicastif); /* eth0, etc. */
     488                        if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(&ifindex)) < 0)
     489                        {
     490                                PRINT_SOCKET_ERROR("setsockopt");
     491                        }
     492#else
     493#ifdef DEBUG
     494                        printf("Setting of multicast interface not supported in IPv6 under Windows.\n");
     495#endif
     496#endif
    568497                } else {
     498                        struct in_addr mc_if;
     499                        mc_if.s_addr = inet_addr(multicastif); /* ex: 192.168.x.x */
    569500                        ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = mc_if.s_addr;
    570                 }
    571                 if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
    572                 {
    573                         PRINT_SOCKET_ERROR("setsockopt");
     501                        if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
     502                        {
     503                                PRINT_SOCKET_ERROR("setsockopt");
     504                        }
    574505                }
    575506        }
    576507
    577508        /* Avant d'envoyer le paquet on bind pour recevoir la reponse */
    578     if (bind(sudp, &sockudp_r, 0/*ipv6*/?sizeof(struct sockaddr_in6):sizeof(struct sockaddr_in)) != 0)
    579         {
     509    if (bind(sudp, (const struct sockaddr *)&sockudp_r,
     510                 ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) != 0)
     511        {
     512                if(error)
     513                        *error = UPNPDISCOVER_SOCKET_ERROR;
    580514        PRINT_SOCKET_ERROR("bind");
    581515                closesocket(sudp);
     
    583517    }
    584518
     519        if(error)
     520                *error = UPNPDISCOVER_SUCCESS;
    585521        /* Calculating maximum response time in seconds */
    586522        mx = ((unsigned int)delay) / 1000u;
    587523        /* receiving SSDP response packet */
    588         for(n = 0;;)
     524        for(n = 0; deviceList[deviceIndex]; deviceIndex++)
    589525        {
    590526        if(n == 0)
     
    592528                /* sending the SSDP M-SEARCH packet */
    593529                n = snprintf(bufr, sizeof(bufr),
    594                              MSearchMsgFmt, deviceList[deviceIndex++], mx);
    595                 /*printf("Sending %s", bufr);*/
     530                             MSearchMsgFmt,
     531                             ipv6 ?
     532                             (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" :  "[" UPNP_MCAST_SL_ADDR "]")
     533                             : UPNP_MCAST_ADDR,
     534                             deviceList[deviceIndex], mx);
     535#ifdef DEBUG
     536                printf("Sending %s", bufr);
     537#endif
    596538#ifdef NO_GETADDRINFO
    597539                /* the following code is not using getaddrinfo */
    598540                /* emission */
    599                 memset(&sockudp_w, 0, sizeof(struct sockaddr_in));
    600                 sockudp_w.sin_family = AF_INET;
    601                 sockudp_w.sin_port = htons(PORT);
    602                 sockudp_w.sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
     541                memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));
     542                if(ipv6) {
     543                        struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;
     544                        p->sin6_family = AF_INET6;
     545                        p->sin6_port = htons(PORT);
     546                        inet_pton(AF_INET6,
     547                                  linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,
     548                                  &(p->sin6_addr));
     549                } else {
     550                        struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;
     551                        p->sin_family = AF_INET;
     552                        p->sin_port = htons(PORT);
     553                        p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
     554                }
    603555                n = sendto(sudp, bufr, n, 0,
    604                            (struct sockaddr *)&sockudp_w, sizeof(struct sockaddr_in));
     556                           &sockudp_w,
     557                           ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
    605558                if (n < 0) {
     559                        if(error)
     560                                *error = UPNPDISCOVER_SOCKET_ERROR;
    606561                        PRINT_SOCKET_ERROR("sendto");
    607                         closesocket(sudp);
    608                         return devlist;
     562                        break;
    609563                }
    610564#else /* #ifdef NO_GETADDRINFO */
     
    613567                hints.ai_socktype = SOCK_DGRAM;
    614568                /*hints.ai_flags = */
    615                 if ((rv = getaddrinfo(UPNP_MCAST_ADDR, XSTR(PORT), &hints, &servinfo)) != 0) {
     569                if ((rv = getaddrinfo(ipv6
     570                                      ? (linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR)
     571                                      : UPNP_MCAST_ADDR,
     572                                      XSTR(PORT), &hints, &servinfo)) != 0) {
     573                        if(error)
     574                                *error = UPNPDISCOVER_SOCKET_ERROR;
    616575#ifdef WIN32
    617576                    fprintf(stderr, "getaddrinfo() failed: %d\n", rv);
     
    619578                    fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
    620579#endif
    621                     return devlist;
     580                        break;
    622581                }
    623582                for(p = servinfo; p; p = p->ai_next) {
     
    630589                freeaddrinfo(servinfo);
    631590                if(n < 0) {
    632                         closesocket(sudp);
    633                         return devlist;
     591                        if(error)
     592                                *error = UPNPDISCOVER_SOCKET_ERROR;
     593                        break;
    634594                }
    635595#endif /* #ifdef NO_GETADDRINFO */
    636596        }
    637597        /* Waiting for SSDP REPLY packet to M-SEARCH */
    638         n = ReceiveData(sudp, bufr, sizeof(bufr), delay);
     598        n = receivedata(sudp, bufr, sizeof(bufr), delay);
    639599        if (n < 0) {
    640600                /* error */
    641                 closesocket(sudp);
    642                 return devlist;
     601                if(error)
     602                        *error = UPNPDISCOVER_SOCKET_ERROR;
     603                break;
    643604        } else if (n == 0) {
    644605                /* no data or Time Out */
    645                 if (devlist || (deviceList[deviceIndex] == 0)) {
     606                if (devlist) {
    646607                        /* no more device type to look for... */
    647                         closesocket(sudp);
    648                         return devlist;
     608                        if(error)
     609                                *error = UPNPDISCOVER_SUCCESS;
     610                        break;
     611                }
     612                if(ipv6) {
     613                        if(linklocal) {
     614                                linklocal = 0;
     615                                --deviceIndex;
     616                        } else {
     617                                linklocal = 1;
     618                        }
    649619                }
    650620        } else {
     
    673643                                continue;
    674644                        tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
     645                        if(!tmp) {
     646                                /* memory allocation error */
     647                                if(error)
     648                                        *error = UPNPDISCOVER_MEMORY_ERROR;
     649                                break;
     650                        }
    675651                        tmp->pNext = devlist;
    676652                        tmp->descURL = tmp->buffer;
     
    684660        }
    685661        }
     662        closesocket(sudp);
     663        return devlist;
    686664}
    687665
     
    728706{
    729707        char * p;
    730         int n1, n2, n3;
     708        int n1, n2, n3, n4;
    731709        n1 = strlen(data->urlbase);
    732710        if(n1==0)
    733711                n1 = strlen(descURL);
    734712        n1 += 2;        /* 1 byte more for Null terminator, 1 byte for '/' if needed */
    735         n2 = n1; n3 = n1;
     713        n2 = n1; n3 = n1; n4 = n1;
    736714        n1 += strlen(data->first.scpdurl);
    737715        n2 += strlen(data->first.controlurl);
    738716        n3 += strlen(data->CIF.controlurl);
     717        n4 += strlen(data->IPv6FC.controlurl);
    739718
    740719        urls->ipcondescURL = (char *)malloc(n1);
    741720        urls->controlURL = (char *)malloc(n2);
    742721        urls->controlURL_CIF = (char *)malloc(n3);
     722        urls->controlURL_6FC = (char *)malloc(n4);
    743723        /* maintenant on chope la desc du WANIPConnection */
    744724        if(data->urlbase[0] != '\0')
     
    750730        strncpy(urls->controlURL, urls->ipcondescURL, n2);
    751731        strncpy(urls->controlURL_CIF, urls->ipcondescURL, n3);
     732        strncpy(urls->controlURL_6FC, urls->ipcondescURL, n4);
    752733       
    753734        url_cpy_or_cat(urls->ipcondescURL, data->first.scpdurl, n1);
     
    756737
    757738        url_cpy_or_cat(urls->controlURL_CIF, data->CIF.controlurl, n3);
     739
     740        url_cpy_or_cat(urls->controlURL_6FC, data->IPv6FC.controlurl, n4);
    758741
    759742#ifdef DEBUG
     
    764747        printf("urls->controlURL_CIF='%s' %u n3=%d\n", urls->controlURL_CIF,
    765748               (unsigned)strlen(urls->controlURL_CIF), n3);
     749        printf("urls->controlURL_6FC='%s' %u n4=%d\n", urls->controlURL_6FC,
     750               (unsigned)strlen(urls->controlURL_6FC), n4);
    766751#endif
    767752}
     
    778763        free(urls->controlURL_CIF);
    779764        urls->controlURL_CIF = 0;
    780 }
    781 
    782 
    783 int ReceiveData(int socket, char * data, int length, int timeout)
    784 {
    785     int n;
    786 #if !defined(WIN32) && !defined(__amigaos__) && !defined(__amigaos4__)
    787     struct pollfd fds[1]; /* for the poll */
    788 #ifdef MINIUPNPC_IGNORE_EINTR
    789     do {
    790 #endif
    791         fds[0].fd = socket;
    792         fds[0].events = POLLIN;
    793         n = poll(fds, 1, timeout);
    794 #ifdef MINIUPNPC_IGNORE_EINTR
    795     } while(n < 0 && errno == EINTR);
    796 #endif
    797     if(n < 0)
    798     {
    799         PRINT_SOCKET_ERROR("poll");
    800         return -1;
    801     }
    802     else if(n == 0)
    803     {
    804         return 0;
    805     }
    806 #else
    807     fd_set socketSet;
    808     TIMEVAL timeval;
    809     FD_ZERO(&socketSet);
    810     FD_SET(socket, &socketSet);
    811     timeval.tv_sec = timeout / 1000;
    812     timeval.tv_usec = (timeout % 1000) * 1000;
    813     n = select(FD_SETSIZE, &socketSet, NULL, NULL, &timeval);
    814     if(n < 0)
    815     {
    816         PRINT_SOCKET_ERROR("select");
    817         return -1;
    818     }
    819     else if(n == 0)
    820     {
    821         return 0;
    822     }   
    823 #endif
    824         n = recv(socket, data, length, 0);
    825         if(n<0)
    826         {
    827                 PRINT_SOCKET_ERROR("recv");
    828         }
    829         return n;
     765        free(urls->controlURL_6FC);
     766        urls->controlURL_6FC = 0;
    830767}
    831768
Note: See TracChangeset for help on using the changeset viewer.