Annotation of embedaddon/miniupnpc/src/minissdpc.c, revision 1.1

1.1     ! misho       1: /* $Id: minissdpc.c,v 1.49 2021/05/13 11:00:36 nanard Exp $ */
        !             2: /* vim: tabstop=4 shiftwidth=4 noexpandtab
        !             3:  * Project : miniupnp
        !             4:  * Web : http://miniupnp.free.fr/ or https://miniupnp.tuxfamily.org/
        !             5:  * Author : Thomas BERNARD
        !             6:  * copyright (c) 2005-2021 Thomas Bernard
        !             7:  * This software is subjet to the conditions detailed in the
        !             8:  * provided LICENCE file. */
        !             9: #include <stdio.h>
        !            10: #include <string.h>
        !            11: #include <stdlib.h>
        !            12: #include <time.h>
        !            13: #include <sys/types.h>
        !            14: #if defined (__NetBSD__)
        !            15: #include <net/if.h>
        !            16: #endif
        !            17: #if defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__)
        !            18: #ifdef _WIN32
        !            19: #include <winsock2.h>
        !            20: #include <ws2tcpip.h>
        !            21: #include <io.h>
        !            22: #include <iphlpapi.h>
        !            23: #include "win32_snprintf.h"
        !            24: #if !defined(_MSC_VER)
        !            25: #include <stdint.h>
        !            26: #else /* !defined(_MSC_VER) */
        !            27: typedef unsigned short uint16_t;
        !            28: #endif /* !defined(_MSC_VER) */
        !            29: #ifndef strncasecmp
        !            30: #if defined(_MSC_VER) && (_MSC_VER >= 1400)
        !            31: #define strncasecmp _memicmp
        !            32: #else /* defined(_MSC_VER) && (_MSC_VER >= 1400) */
        !            33: #define strncasecmp memicmp
        !            34: #endif /* defined(_MSC_VER) && (_MSC_VER >= 1400) */
        !            35: #endif /* #ifndef strncasecmp */
        !            36: #if defined(WINAPI_FAMILY) && defined(WINAPI_FAMILY_PARTITION)
        !            37: #if WINAPI_FAMILY_PARTITION(WINAPI_PARTITION_APP) && WINAPI_FAMILY != WINAPI_FAMILY_DESKTOP_APP
        !            38: #define in6addr_any in6addr_any_init
        !            39: static const IN6_ADDR in6addr_any_init = {0};
        !            40: #endif
        !            41: #endif
        !            42: #endif /* _WIN32 */
        !            43: #if defined(__amigaos__) || defined(__amigaos4__)
        !            44: #include <sys/socket.h>
        !            45: #endif /* defined(__amigaos__) || defined(__amigaos4__) */
        !            46: #if defined(__amigaos__)
        !            47: #define uint16_t unsigned short
        !            48: #endif /* defined(__amigaos__) */
        !            49: /* Hack */
        !            50: #define UNIX_PATH_LEN   108
        !            51: struct sockaddr_un {
        !            52:   uint16_t sun_family;
        !            53:   char     sun_path[UNIX_PATH_LEN];
        !            54: };
        !            55: #else /* defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__) */
        !            56: #include <strings.h>
        !            57: #include <unistd.h>
        !            58: #include <sys/socket.h>
        !            59: #include <sys/param.h>
        !            60: #include <sys/time.h>
        !            61: #include <sys/un.h>
        !            62: #include <netinet/in.h>
        !            63: #include <arpa/inet.h>
        !            64: #include <netdb.h>
        !            65: #include <net/if.h>
        !            66: #define closesocket close
        !            67: #endif
        !            68: 
        !            69: #include "miniupnpc_socketdef.h"
        !            70: 
        !            71: #if !defined(__DragonFly__) && !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(__APPLE__) && !defined(_WIN32) && !defined(__CYGWIN__) && !defined(__sun) && !defined(__GNU__) && !defined(__FreeBSD_kernel__) && !defined(__HAIKU__)
        !            72: #define HAS_IP_MREQN
        !            73: #endif
        !            74: 
        !            75: #ifndef _WIN32
        !            76: #include <sys/ioctl.h>
        !            77: #if defined(__sun) || defined(__HAIKU__)
        !            78: #include <sys/sockio.h>
        !            79: #endif
        !            80: #endif
        !            81: 
        !            82: #if defined(HAS_IP_MREQN) && defined(NEED_STRUCT_IP_MREQN)
        !            83: /* Several versions of glibc don't define this structure,
        !            84:  * define it here and compile with CFLAGS NEED_STRUCT_IP_MREQN */
        !            85: struct ip_mreqn
        !            86: {
        !            87:    struct in_addr  imr_multiaddr;      /* IP multicast address of group */
        !            88:    struct in_addr  imr_address;        /* local IP address of interface */
        !            89:    int     imr_ifindex;        /* Interface index */
        !            90: };
        !            91: #endif
        !            92: 
        !            93: #if defined(__amigaos__) || defined(__amigaos4__)
        !            94: /* Amiga OS specific stuff */
        !            95: #define TIMEVAL struct timeval
        !            96: #endif
        !            97: 
        !            98: #include "minissdpc.h"
        !            99: #include "miniupnpc.h"
        !           100: #include "receivedata.h"
        !           101: 
        !           102: #if !(defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__))
        !           103: 
        !           104: #include "codelength.h"
        !           105: 
        !           106: struct UPNPDev *
        !           107: getDevicesFromMiniSSDPD(const char * devtype, const char * socketpath, int * error)
        !           108: {
        !           109:    struct UPNPDev * devlist = NULL;
        !           110:    int s;
        !           111:    int res;
        !           112: 
        !           113:    s = connectToMiniSSDPD(socketpath);
        !           114:    if (s < 0) {
        !           115:        if (error)
        !           116:            *error = s;
        !           117:        return NULL;
        !           118:    }
        !           119:    res = requestDevicesFromMiniSSDPD(s, devtype);
        !           120:    if (res < 0) {
        !           121:        if (error)
        !           122:            *error = res;
        !           123:    } else {
        !           124:        devlist = receiveDevicesFromMiniSSDPD(s, error);
        !           125:    }
        !           126:    disconnectFromMiniSSDPD(s);
        !           127:    return devlist;
        !           128: }
        !           129: 
        !           130: /* macros used to read from unix socket */
        !           131: #define READ_BYTE_BUFFER(c) \
        !           132:    if((int)bufferindex >= n) { \
        !           133:        n = read(s, buffer, sizeof(buffer)); \
        !           134:        if(n<=0) break; \
        !           135:        bufferindex = 0; \
        !           136:    } \
        !           137:    c = buffer[bufferindex++];
        !           138: 
        !           139: #ifndef MIN
        !           140: #define MIN(a, b) (((a) < (b)) ? (a) : (b))
        !           141: #endif /* MIN */
        !           142: 
        !           143: #define READ_COPY_BUFFER(dst, len) \
        !           144:    for(l = len, p = (unsigned char *)dst; l > 0; ) { \
        !           145:        unsigned int lcopy; \
        !           146:        if((int)bufferindex >= n) { \
        !           147:            n = read(s, buffer, sizeof(buffer)); \
        !           148:            if(n<=0) break; \
        !           149:            bufferindex = 0; \
        !           150:        } \
        !           151:        lcopy = MIN(l, (n - bufferindex)); \
        !           152:        memcpy(p, buffer + bufferindex, lcopy); \
        !           153:        l -= lcopy; \
        !           154:        p += lcopy; \
        !           155:        bufferindex += lcopy; \
        !           156:    }
        !           157: 
        !           158: #define READ_DISCARD_BUFFER(len) \
        !           159:    for(l = len; l > 0; ) { \
        !           160:        unsigned int lcopy; \
        !           161:        if(bufferindex >= n) { \
        !           162:            n = read(s, buffer, sizeof(buffer)); \
        !           163:            if(n<=0) break; \
        !           164:            bufferindex = 0; \
        !           165:        } \
        !           166:        lcopy = MIN(l, (n - bufferindex)); \
        !           167:        l -= lcopy; \
        !           168:        bufferindex += lcopy; \
        !           169:    }
        !           170: 
        !           171: int
        !           172: connectToMiniSSDPD(const char * socketpath)
        !           173: {
        !           174:    int s;
        !           175:    struct sockaddr_un addr;
        !           176: #if defined(MINIUPNPC_SET_SOCKET_TIMEOUT) && !defined(__sun)
        !           177:    struct timeval timeout;
        !           178: #endif /* #ifdef MINIUPNPC_SET_SOCKET_TIMEOUT */
        !           179: 
        !           180:    s = socket(AF_UNIX, SOCK_STREAM, 0);
        !           181:    if(s < 0)
        !           182:    {
        !           183:        /*syslog(LOG_ERR, "socket(unix): %m");*/
        !           184:        perror("socket(unix)");
        !           185:        return MINISSDPC_SOCKET_ERROR;
        !           186:    }
        !           187: #if defined(MINIUPNPC_SET_SOCKET_TIMEOUT) && !defined(__sun)
        !           188:    /* setting a 3 seconds timeout */
        !           189:    /* not supported for AF_UNIX sockets under Solaris */
        !           190:    timeout.tv_sec = 3;
        !           191:    timeout.tv_usec = 0;
        !           192:    if(setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(struct timeval)) < 0)
        !           193:    {
        !           194:        perror("setsockopt SO_RCVTIMEO unix");
        !           195:    }
        !           196:    timeout.tv_sec = 3;
        !           197:    timeout.tv_usec = 0;
        !           198:    if(setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(struct timeval)) < 0)
        !           199:    {
        !           200:        perror("setsockopt SO_SNDTIMEO unix");
        !           201:    }
        !           202: #endif /* #ifdef MINIUPNPC_SET_SOCKET_TIMEOUT */
        !           203:    if(!socketpath)
        !           204:        socketpath = "/var/run/minissdpd.sock";
        !           205:    memset(&addr, 0, sizeof(addr));
        !           206:    addr.sun_family = AF_UNIX;
        !           207:    strncpy(addr.sun_path, socketpath, sizeof(addr.sun_path));
        !           208:    /* TODO : check if we need to handle the EINTR */
        !           209:    if(connect(s, (struct sockaddr *)&addr, sizeof(struct sockaddr_un)) < 0)
        !           210:    {
        !           211:        /*syslog(LOG_WARNING, "connect(\"%s\"): %m", socketpath);*/
        !           212:        close(s);
        !           213:        return MINISSDPC_SOCKET_ERROR;
        !           214:    }
        !           215:    return s;
        !           216: }
        !           217: 
        !           218: int
        !           219: disconnectFromMiniSSDPD(int s)
        !           220: {
        !           221:    if (close(s) < 0)
        !           222:        return MINISSDPC_SOCKET_ERROR;
        !           223:    return MINISSDPC_SUCCESS;
        !           224: }
        !           225: 
        !           226: int
        !           227: requestDevicesFromMiniSSDPD(int s, const char * devtype)
        !           228: {
        !           229:    unsigned char buffer[256];
        !           230:    unsigned char * p;
        !           231:    unsigned int stsize, l;
        !           232: 
        !           233:    stsize = strlen(devtype);
        !           234:    if(stsize == 8 && 0 == memcmp(devtype, "ssdp:all", 8))
        !           235:    {
        !           236:        buffer[0] = 3;  /* request type 3 : everything */
        !           237:    }
        !           238:    else
        !           239:    {
        !           240:        buffer[0] = 1; /* request type 1 : request devices/services by type */
        !           241:    }
        !           242:    p = buffer + 1;
        !           243:    l = stsize; CODELENGTH(l, p);
        !           244:    if(p + stsize > buffer + sizeof(buffer))
        !           245:    {
        !           246:        /* devtype is too long ! */
        !           247: #ifdef DEBUG
        !           248:        fprintf(stderr, "devtype is too long ! stsize=%u sizeof(buffer)=%u\n",
        !           249:                stsize, (unsigned)sizeof(buffer));
        !           250: #endif /* DEBUG */
        !           251:        return MINISSDPC_INVALID_INPUT;
        !           252:    }
        !           253:    memcpy(p, devtype, stsize);
        !           254:    p += stsize;
        !           255:    if(write(s, buffer, p - buffer) < 0)
        !           256:    {
        !           257:        /*syslog(LOG_ERR, "write(): %m");*/
        !           258:        perror("minissdpc.c: write()");
        !           259:        return MINISSDPC_SOCKET_ERROR;
        !           260:    }
        !           261:    return MINISSDPC_SUCCESS;
        !           262: }
        !           263: 
        !           264: struct UPNPDev *
        !           265: receiveDevicesFromMiniSSDPD(int s, int * error)
        !           266: {
        !           267:    struct UPNPDev * tmp;
        !           268:    struct UPNPDev * devlist = NULL;
        !           269:    unsigned char buffer[256];
        !           270:    ssize_t n;
        !           271:    unsigned char * p;
        !           272:    unsigned char * url;
        !           273:    unsigned char * st;
        !           274:    unsigned int bufferindex;
        !           275:    unsigned int i, ndev;
        !           276:    unsigned int urlsize, stsize, usnsize, l;
        !           277: 
        !           278:    n = read(s, buffer, sizeof(buffer));
        !           279:    if(n<=0)
        !           280:    {
        !           281:        perror("minissdpc.c: read()");
        !           282:        if (error)
        !           283:            *error = MINISSDPC_SOCKET_ERROR;
        !           284:        return NULL;
        !           285:    }
        !           286:    ndev = buffer[0];
        !           287:    bufferindex = 1;
        !           288:    for(i = 0; i < ndev; i++)
        !           289:    {
        !           290:        DECODELENGTH_READ(urlsize, READ_BYTE_BUFFER);
        !           291:        if(n<=0) {
        !           292:            if (error)
        !           293:                *error = MINISSDPC_INVALID_SERVER_REPLY;
        !           294:            return devlist;
        !           295:        }
        !           296: #ifdef DEBUG
        !           297:        printf("  urlsize=%u", urlsize);
        !           298: #endif /* DEBUG */
        !           299:        url = malloc(urlsize);
        !           300:        if(url == NULL) {
        !           301:            if (error)
        !           302:                *error = MINISSDPC_MEMORY_ERROR;
        !           303:            return devlist;
        !           304:        }
        !           305:        READ_COPY_BUFFER(url, urlsize);
        !           306:        if(n<=0) {
        !           307:            if (error)
        !           308:                *error = MINISSDPC_INVALID_SERVER_REPLY;
        !           309:            goto free_url_and_return;
        !           310:        }
        !           311:        DECODELENGTH_READ(stsize, READ_BYTE_BUFFER);
        !           312:        if(n<=0) {
        !           313:            if (error)
        !           314:                *error = MINISSDPC_INVALID_SERVER_REPLY;
        !           315:            goto free_url_and_return;
        !           316:        }
        !           317: #ifdef DEBUG
        !           318:        printf("   stsize=%u", stsize);
        !           319: #endif /* DEBUG */
        !           320:        st = malloc(stsize);
        !           321:        if (st == NULL) {
        !           322:            if (error)
        !           323:                *error = MINISSDPC_MEMORY_ERROR;
        !           324:            goto free_url_and_return;
        !           325:        }
        !           326:        READ_COPY_BUFFER(st, stsize);
        !           327:        if(n<=0) {
        !           328:            if (error)
        !           329:                *error = MINISSDPC_INVALID_SERVER_REPLY;
        !           330:            goto free_url_and_st_and_return;
        !           331:        }
        !           332:        DECODELENGTH_READ(usnsize, READ_BYTE_BUFFER);
        !           333:        if(n<=0) {
        !           334:            if (error)
        !           335:                *error = MINISSDPC_INVALID_SERVER_REPLY;
        !           336:            goto free_url_and_st_and_return;
        !           337:        }
        !           338: #ifdef DEBUG
        !           339:        printf("   usnsize=%u\n", usnsize);
        !           340: #endif /* DEBUG */
        !           341:        tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize+usnsize);
        !           342:        if(tmp == NULL) {
        !           343:            if (error)
        !           344:                *error = MINISSDPC_MEMORY_ERROR;
        !           345:            goto free_url_and_st_and_return;
        !           346:        }
        !           347:        tmp->pNext = devlist;
        !           348:        tmp->descURL = tmp->buffer;
        !           349:        tmp->st = tmp->buffer + 1 + urlsize;
        !           350:        memcpy(tmp->buffer, url, urlsize);
        !           351:        tmp->buffer[urlsize] = '\0';
        !           352:        memcpy(tmp->st, st, stsize);
        !           353:        tmp->buffer[urlsize+1+stsize] = '\0';
        !           354:        free(url);
        !           355:        free(st);
        !           356:        url = NULL;
        !           357:        st = NULL;
        !           358:        tmp->usn = tmp->buffer + 1 + urlsize + 1 + stsize;
        !           359:        READ_COPY_BUFFER(tmp->usn, usnsize);
        !           360:        if(n<=0) {
        !           361:            if (error)
        !           362:                *error = MINISSDPC_INVALID_SERVER_REPLY;
        !           363:            goto free_tmp_and_return;
        !           364:        }
        !           365:        tmp->buffer[urlsize+1+stsize+1+usnsize] = '\0';
        !           366:        tmp->scope_id = 0;  /* default value. scope_id is not available with MiniSSDPd */
        !           367:        devlist = tmp;
        !           368:    }
        !           369:    if (error)
        !           370:        *error = MINISSDPC_SUCCESS;
        !           371:    return devlist;
        !           372: 
        !           373: free_url_and_st_and_return:
        !           374:    free(st);
        !           375: free_url_and_return:
        !           376:    free(url);
        !           377:    return devlist;
        !           378: 
        !           379: free_tmp_and_return:
        !           380:    free(tmp);
        !           381:    return devlist;
        !           382: }
        !           383: 
        !           384: #endif /* !(defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__)) */
        !           385: 
        !           386: /* parseMSEARCHReply()
        !           387:  * the last 4 arguments are filled during the parsing :
        !           388:  *    - location/locationsize : "location:" field of the SSDP reply packet
        !           389:  *    - st/stsize : "st:" field of the SSDP reply packet.
        !           390:  *    - usn/usnsize : "usn:" filed of the SSDP reply packet
        !           391:  * The strings are NOT null terminated */
        !           392: static void
        !           393: parseMSEARCHReply(const char * reply, int size,
        !           394:                   const char * * location, int * locationsize,
        !           395:                  const char * * st, int * stsize,
        !           396:                  const char * * usn, int * usnsize)
        !           397: {
        !           398:    int a, b, i;
        !           399:    i = 0;
        !           400:    a = i;  /* start of the line */
        !           401:    b = 0;  /* end of the "header" (position of the colon) */
        !           402:    while(i<size)
        !           403:    {
        !           404:        switch(reply[i])
        !           405:        {
        !           406:        case ':':
        !           407:                if(b==0)
        !           408:                {
        !           409:                    b = i; /* end of the "header" */
        !           410:                    /*for(j=a; j<b; j++)
        !           411:                    {
        !           412:                        putchar(reply[j]);
        !           413:                    }
        !           414:                    */
        !           415:                }
        !           416:                break;
        !           417:        case '\x0a':
        !           418:        case '\x0d':
        !           419:                if(b!=0)
        !           420:                {
        !           421:                    /*for(j=b+1; j<i; j++)
        !           422:                    {
        !           423:                        putchar(reply[j]);
        !           424:                    }
        !           425:                    putchar('\n');*/
        !           426:                    /* skip the colon and white spaces */
        !           427:                    do { b++; } while(reply[b]==' ');
        !           428:                    if(0==strncasecmp(reply+a, "location:", 9))
        !           429:                    {
        !           430:                        *location = reply+b;
        !           431:                        *locationsize = i-b;
        !           432:                    }
        !           433:                    else if(0==strncasecmp(reply+a, "st:", 3))
        !           434:                    {
        !           435:                        *st = reply+b;
        !           436:                        *stsize = i-b;
        !           437:                    }
        !           438:                    else if(0==strncasecmp(reply+a, "usn:", 4))
        !           439:                    {
        !           440:                        *usn = reply+b;
        !           441:                        *usnsize = i-b;
        !           442:                    }
        !           443:                    b = 0;
        !           444:                }
        !           445:                a = i+1;
        !           446:                break;
        !           447:        default:
        !           448:                break;
        !           449:        }
        !           450:        i++;
        !           451:    }
        !           452: }
        !           453: 
        !           454: #if defined(CLOCK_MONOTONIC_FAST)
        !           455: #define UPNP_CLOCKID CLOCK_MONOTONIC_FAST
        !           456: #elif defined(CLOCK_MONOTONIC)
        !           457: #define UPNP_CLOCKID CLOCK_MONOTONIC
        !           458: #endif
        !           459: 
        !           460: static int upnp_gettimeofday(struct timeval * tv)
        !           461: {
        !           462: #if defined(_WIN32)
        !           463: #if _WIN32_WINNT >= 0x0600 // _WIN32_WINNT_VISTA
        !           464:    ULONGLONG ts = GetTickCount64();
        !           465: #else
        !           466:    DWORD ts = GetTickCount();
        !           467: #endif
        !           468:    tv->tv_sec = (long)(ts / 1000);
        !           469:    tv->tv_usec = (ts % 1000) * 1000;
        !           470:    return 0; /* success */
        !           471: #elif defined(CLOCK_MONOTONIC_FAST) || defined(CLOCK_MONOTONIC)
        !           472: #if defined(__APPLE__)
        !           473: #if defined(__clang__)
        !           474:    if (__builtin_available(macOS 10.12, iOS 10.0, tvOS 10.0, watchOS 3.0, *)) {
        !           475: #else /* !defined(__clang__) */
        !           476:    if (clock_gettime != NULL) {
        !           477: #endif /* defined(__clang__) */
        !           478: #endif /* defined(__APPLE__) */
        !           479:        struct timespec ts;
        !           480:        int ret_code = clock_gettime(UPNP_CLOCKID, &ts);
        !           481:        if (ret_code == 0)
        !           482:        {
        !           483:            tv->tv_sec = ts.tv_sec;
        !           484:            tv->tv_usec = ts.tv_nsec / 1000;
        !           485:        }
        !           486:        return ret_code;
        !           487: #if defined(__APPLE__)
        !           488:    }
        !           489:    else
        !           490:    {
        !           491:        /* fall-back for earlier Apple platforms */
        !           492:        return gettimeofday(tv, NULL);
        !           493:    }
        !           494: #endif /* defined(__APPLE__) */
        !           495: #else
        !           496:    return gettimeofday(tv, NULL);
        !           497: #endif
        !           498: }
        !           499: /* port upnp discover : SSDP protocol */
        !           500: #define SSDP_PORT 1900
        !           501: #define XSTR(s) STR(s)
        !           502: #define STR(s) #s
        !           503: #define UPNP_MCAST_ADDR "239.255.255.250"
        !           504: /* for IPv6 */
        !           505: #define UPNP_MCAST_LL_ADDR "FF02::C" /* link-local */
        !           506: #define UPNP_MCAST_SL_ADDR "FF05::C" /* site-local */
        !           507: 
        !           508: /* direct discovery if minissdpd responses are not sufficient */
        !           509: /* ssdpDiscoverDevices() :
        !           510:  * return a chained list of all devices found or NULL if
        !           511:  * no devices was found.
        !           512:  * It is up to the caller to free the chained list
        !           513:  * delay is in millisecond (poll).
        !           514:  * UDA v1.1 says :
        !           515:  *   The TTL for the IP packet SHOULD default to 2 and
        !           516:  *   SHOULD be configurable. */
        !           517: struct UPNPDev *
        !           518: ssdpDiscoverDevices(const char * const deviceTypes[],
        !           519:                     int delay, const char * multicastif,
        !           520:                     int localport,
        !           521:                     int ipv6, unsigned char ttl,
        !           522:                     int * error,
        !           523:                     int searchalltypes)
        !           524: {
        !           525:    struct UPNPDev * tmp;
        !           526:    struct UPNPDev * devlist = NULL;
        !           527:    unsigned int scope_id = 0;
        !           528:    int opt = 1;
        !           529:    static const char MSearchMsgFmt[] =
        !           530:    "M-SEARCH * HTTP/1.1\r\n"
        !           531:    "HOST: %s:" XSTR(SSDP_PORT) "\r\n"
        !           532:    "ST: %s\r\n"
        !           533:    "MAN: \"ssdp:discover\"\r\n"
        !           534:    "MX: %u\r\n"
        !           535:    "\r\n";
        !           536:    int deviceIndex;
        !           537:    char bufr[1536];    /* reception and emission buffer */
        !           538:    SOCKET sudp;
        !           539:    int n;
        !           540:    struct sockaddr_storage sockudp_r;
        !           541:    unsigned int mx;
        !           542: #ifdef NO_GETADDRINFO
        !           543:    struct sockaddr_storage sockudp_w;
        !           544: #else
        !           545:    int rv;
        !           546:    struct addrinfo hints, *servinfo;
        !           547: #endif
        !           548: #ifdef _WIN32
        !           549:    unsigned long _ttl = (unsigned long)ttl;
        !           550: #endif
        !           551:    int linklocal = 1;
        !           552:    int sentok;
        !           553: 
        !           554:    if(error)
        !           555:        *error = MINISSDPC_UNKNOWN_ERROR;
        !           556: 
        !           557:    if(localport==UPNP_LOCAL_PORT_SAME)
        !           558:        localport = SSDP_PORT;
        !           559: 
        !           560: #ifdef _WIN32
        !           561:    sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP);
        !           562: #else
        !           563:    sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0);
        !           564: #endif
        !           565:    if(ISINVALID(sudp))
        !           566:    {
        !           567:        if(error)
        !           568:            *error = MINISSDPC_SOCKET_ERROR;
        !           569:        PRINT_SOCKET_ERROR("socket");
        !           570:        return NULL;
        !           571:    }
        !           572:    /* reception */
        !           573:    memset(&sockudp_r, 0, sizeof(struct sockaddr_storage));
        !           574:    if(ipv6) {
        !           575:        struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_r;
        !           576:        p->sin6_family = AF_INET6;
        !           577:        if(localport > 0 && localport < 65536)
        !           578:            p->sin6_port = htons((unsigned short)localport);
        !           579:        p->sin6_addr = in6addr_any; /* in6addr_any is not available with MinGW32 3.4.2 */
        !           580:    } else {
        !           581:        struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_r;
        !           582:        p->sin_family = AF_INET;
        !           583:        if(localport > 0 && localport < 65536)
        !           584:            p->sin_port = htons((unsigned short)localport);
        !           585:        p->sin_addr.s_addr = INADDR_ANY;
        !           586:    }
        !           587: #ifdef _WIN32
        !           588: /* This code could help us to use the right Network interface for
        !           589:  * SSDP multicast traffic */
        !           590: /* Get IP associated with the index given in the ip_forward struct
        !           591:  * in order to give this ip to setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF) */
        !           592:    if(!ipv6) {
        !           593:        DWORD ifbestidx;
        !           594: #if _WIN32_WINNT >= 0x0600 // _WIN32_WINNT_VISTA
        !           595:        // While we don't need IPv6 support, the IPv4 only funciton is not available in UWP apps.
        !           596:        SOCKADDR_IN destAddr;
        !           597:        memset(&destAddr, 0, sizeof(destAddr));
        !           598:        destAddr.sin_family = AF_INET;
        !           599:        destAddr.sin_addr.s_addr = inet_addr("223.255.255.255");
        !           600:        destAddr.sin_port = 0;
        !           601:        if (GetBestInterfaceEx((struct sockaddr *)&destAddr, &ifbestidx) == NO_ERROR) {
        !           602: #else
        !           603:        if (GetBestInterface(inet_addr("223.255.255.255"), &ifbestidx) == NO_ERROR) {
        !           604: #endif
        !           605:            DWORD dwRetVal = NO_ERROR;
        !           606:            PIP_ADAPTER_ADDRESSES pAddresses = NULL;
        !           607:            ULONG outBufLen = 15360;
        !           608:            int Iterations;
        !           609:            PIP_ADAPTER_ADDRESSES pCurrAddresses = NULL;
        !           610:            PIP_ADAPTER_UNICAST_ADDRESS pUnicast = NULL;
        !           611: 
        !           612:            for (Iterations = 0; Iterations < 3; Iterations++) {
        !           613:                pAddresses = (IP_ADAPTER_ADDRESSES *) HeapAlloc(GetProcessHeap(), 0, outBufLen);
        !           614:                if (pAddresses == NULL) {
        !           615:                    break;
        !           616:                }
        !           617: 
        !           618:                dwRetVal = GetAdaptersAddresses(AF_INET, GAA_FLAG_INCLUDE_PREFIX, NULL, pAddresses, &outBufLen);
        !           619: 
        !           620:                if (dwRetVal != ERROR_BUFFER_OVERFLOW) {
        !           621:                    break;
        !           622:                }
        !           623:                HeapFree(GetProcessHeap(), 0, pAddresses);
        !           624:                pAddresses = NULL;
        !           625:            }
        !           626: 
        !           627:            if (dwRetVal == NO_ERROR) {
        !           628:                pCurrAddresses = pAddresses;
        !           629:                while (pCurrAddresses) {
        !           630: #ifdef DEBUG
        !           631:                    int i;
        !           632:                    PIP_ADAPTER_MULTICAST_ADDRESS pMulticast = NULL;
        !           633:                    PIP_ADAPTER_ANYCAST_ADDRESS pAnycast = NULL;
        !           634: 
        !           635:                    printf("\tIfIndex (IPv4 interface): %u\n", pCurrAddresses->IfIndex);
        !           636:                    printf("\tAdapter name: %s\n", pCurrAddresses->AdapterName);
        !           637:                    pUnicast = pCurrAddresses->FirstUnicastAddress;
        !           638:                    if (pUnicast != NULL) {
        !           639:                        for (i = 0; pUnicast != NULL; i++) {
        !           640:                            printf("\tIP Address[%d]:     \t%s\n", i, inet_ntoa(((PSOCKADDR_IN)pUnicast->Address.lpSockaddr)->sin_addr) );
        !           641:                            pUnicast = pUnicast->Next;
        !           642:                        }
        !           643:                        printf("\tNumber of Unicast Addresses: %d\n", i);
        !           644:                    }
        !           645:                    pAnycast = pCurrAddresses->FirstAnycastAddress;
        !           646:                    if (pAnycast) {
        !           647:                        for (i = 0; pAnycast != NULL; i++) {
        !           648:                            printf("\tAnycast Address[%d]:     \t%s\n", i, inet_ntoa(((PSOCKADDR_IN)pAnycast->Address.lpSockaddr)->sin_addr) );
        !           649:                            pAnycast = pAnycast->Next;
        !           650:                        }
        !           651:                        printf("\tNumber of Anycast Addresses: %d\n", i);
        !           652:                    }
        !           653:                    pMulticast = pCurrAddresses->FirstMulticastAddress;
        !           654:                    if (pMulticast) {
        !           655:                        for (i = 0; pMulticast != NULL; i++) {
        !           656:                            printf("\tMulticast Address[%d]:     \t%s\n", i, inet_ntoa(((PSOCKADDR_IN)pMulticast->Address.lpSockaddr)->sin_addr) );
        !           657:               pMulticast = pMulticast->Next;
        !           658:                        }
        !           659:                    }
        !           660:                    printf("\n");
        !           661: #endif
        !           662:                    pUnicast = pCurrAddresses->FirstUnicastAddress;
        !           663:                    if (pCurrAddresses->IfIndex == ifbestidx && pUnicast != NULL) {
        !           664:                        SOCKADDR_IN *ipv4 = (SOCKADDR_IN *)(pUnicast->Address.lpSockaddr);
        !           665:                        /* Set the address of this interface to be used */
        !           666:                        struct in_addr mc_if;
        !           667:                        memset(&mc_if, 0, sizeof(mc_if));
        !           668:                        mc_if.s_addr = ipv4->sin_addr.s_addr;
        !           669:                        if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0) {
        !           670:                            PRINT_SOCKET_ERROR("setsockopt");
        !           671:                        }
        !           672:                        ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = ipv4->sin_addr.s_addr;
        !           673: #ifndef DEBUG
        !           674:                        break;
        !           675: #endif
        !           676:                    }
        !           677:                    pCurrAddresses = pCurrAddresses->Next;
        !           678:                }
        !           679:            }
        !           680:            if (pAddresses != NULL) {
        !           681:                HeapFree(GetProcessHeap(), 0, pAddresses);
        !           682:                pAddresses = NULL;
        !           683:            }
        !           684:        }
        !           685:    }
        !           686: #endif /* _WIN32 */
        !           687: 
        !           688: #ifdef _WIN32
        !           689:    if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)
        !           690: #else
        !           691:    if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
        !           692: #endif
        !           693:    {
        !           694:        if(error)
        !           695:            *error = MINISSDPC_SOCKET_ERROR;
        !           696:        PRINT_SOCKET_ERROR("setsockopt(SO_REUSEADDR,...)");
        !           697:        goto error;
        !           698:    }
        !           699: 
        !           700:    if(ipv6) {
        !           701: #ifdef _WIN32
        !           702:        DWORD mcastHops = ttl;
        !           703:        if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, (const char *)&mcastHops, sizeof(mcastHops)) < 0)
        !           704: #else  /* _WIN32 */
        !           705:        int mcastHops = ttl;
        !           706:        if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &mcastHops, sizeof(mcastHops)) < 0)
        !           707: #endif /* _WIN32 */
        !           708:        {
        !           709:            PRINT_SOCKET_ERROR("setsockopt(IPV6_MULTICAST_HOPS,...)");
        !           710:        }
        !           711:    } else {
        !           712: #ifdef _WIN32
        !           713:        if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_TTL, (const char *)&_ttl, sizeof(_ttl)) < 0)
        !           714: #else  /* _WIN32 */
        !           715:        if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0)
        !           716: #endif /* _WIN32 */
        !           717:        {
        !           718:            /* not a fatal error */
        !           719:            PRINT_SOCKET_ERROR("setsockopt(IP_MULTICAST_TTL,...)");
        !           720:        }
        !           721:    }
        !           722: 
        !           723:    if(multicastif && multicastif[0] != '\0')
        !           724:    {
        !           725:        if(ipv6) {
        !           726: #if !defined(_WIN32)
        !           727:            /* according to MSDN, if_nametoindex() is supported since
        !           728:             * MS Windows Vista and MS Windows Server 2008.
        !           729:             * http://msdn.microsoft.com/en-us/library/bb408409%28v=vs.85%29.aspx */
        !           730:            unsigned int ifindex = if_nametoindex(multicastif); /* eth0, etc. */
        !           731:            if(ifindex == 0)
        !           732:            {
        !           733:                if(error)
        !           734:                    *error = MINISSDPC_INVALID_INPUT;
        !           735:                fprintf(stderr, "Invalid multicast interface name %s\n", multicastif);
        !           736:                goto error;
        !           737:            }
        !           738:            if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(ifindex)) < 0)
        !           739:            {
        !           740:                PRINT_SOCKET_ERROR("setsockopt IPV6_MULTICAST_IF");
        !           741:            }
        !           742: #else
        !           743: #ifdef DEBUG
        !           744:            printf("Setting of multicast interface not supported in IPv6 under Windows.\n");
        !           745: #endif
        !           746: #endif
        !           747:        } else {
        !           748:            struct in_addr mc_if;
        !           749: #if defined(_WIN32)
        !           750: #if _WIN32_WINNT >= 0x0600 // _WIN32_WINNT_VISTA
        !           751:            InetPtonA(AF_INET, multicastif, &mc_if);
        !           752: #else
        !           753:            mc_if.s_addr = inet_addr(multicastif); /* old Windows SDK do not support InetPtoA() */
        !           754: #endif
        !           755: #else
        !           756:            /* was : mc_if.s_addr = inet_addr(multicastif); */ /* ex: 192.168.x.x */
        !           757:            if (inet_pton(AF_INET, multicastif, &mc_if.s_addr) <= 0) {
        !           758:                mc_if.s_addr = INADDR_NONE;
        !           759:            }
        !           760: #endif
        !           761:            if(mc_if.s_addr != INADDR_NONE)
        !           762:            {
        !           763:                ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = mc_if.s_addr;
        !           764:                if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
        !           765:                {
        !           766:                    PRINT_SOCKET_ERROR("setsockopt IP_MULTICAST_IF");
        !           767:                }
        !           768:            } else {
        !           769:                /* was not an ip address, try with an interface name */
        !           770: #ifndef _WIN32
        !           771: #ifdef HAS_IP_MREQN
        !           772:                struct ip_mreqn reqn;   /* only defined with -D_BSD_SOURCE or -D_GNU_SOURCE */
        !           773: #endif
        !           774:                struct ifreq ifr;
        !           775:                int ifrlen = sizeof(ifr);
        !           776:                strncpy(ifr.ifr_name, multicastif, IFNAMSIZ);
        !           777:                ifr.ifr_name[IFNAMSIZ-1] = '\0';
        !           778:                if(ioctl(sudp, SIOCGIFADDR, &ifr, &ifrlen) < 0)
        !           779:                {
        !           780:                    PRINT_SOCKET_ERROR("ioctl(...SIOCGIFADDR...)");
        !           781:                    goto error;
        !           782:                }
        !           783:                mc_if.s_addr = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;
        !           784: #ifdef HAS_IP_MREQN
        !           785:                memset(&reqn, 0, sizeof(struct ip_mreqn));
        !           786:                reqn.imr_address.s_addr = mc_if.s_addr;
        !           787:                reqn.imr_ifindex = if_nametoindex(multicastif);
        !           788:                if(reqn.imr_ifindex == 0)
        !           789:                {
        !           790:                    if(error)
        !           791:                        *error = MINISSDPC_INVALID_INPUT;
        !           792:                    fprintf(stderr, "Invalid multicast ip address / interface name %s\n", multicastif);
        !           793:                    goto error;
        !           794:                }
        !           795:                if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&reqn, sizeof(reqn)) < 0)
        !           796:                {
        !           797:                    PRINT_SOCKET_ERROR("setsockopt IP_MULTICAST_IF");
        !           798:                }
        !           799: #else
        !           800:                if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
        !           801:                {
        !           802:                    PRINT_SOCKET_ERROR("setsockopt IP_MULTICAST_IF");
        !           803:                }
        !           804: #endif
        !           805: #else /* _WIN32 */
        !           806: #ifdef DEBUG
        !           807:                printf("Setting of multicast interface not supported with interface name.\n");
        !           808: #endif
        !           809: #endif /* #ifdef HAS_IP_MREQN / !defined(_WIN32) */
        !           810:            }
        !           811:        }
        !           812:    }
        !           813: 
        !           814:    /* Before sending the packed, we first "bind" in order to be able
        !           815:     * to receive the response */
        !           816:    if (bind(sudp, (const struct sockaddr *)&sockudp_r,
        !           817:             ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) != 0)
        !           818:    {
        !           819:        if(error)
        !           820:            *error = MINISSDPC_SOCKET_ERROR;
        !           821:        PRINT_SOCKET_ERROR("bind");
        !           822:        closesocket(sudp);
        !           823:        return NULL;
        !           824:    }
        !           825: 
        !           826:    if(error)
        !           827:        *error = MINISSDPC_SUCCESS;
        !           828:    /* Calculating maximum response time in seconds */
        !           829:    mx = ((unsigned int)delay) / 1000u;
        !           830:    if(mx == 0) {
        !           831:        mx = 1;
        !           832:        delay = 1000;
        !           833:    }
        !           834:    /* receiving SSDP response packet */
        !           835:    for(deviceIndex = 0; deviceTypes[deviceIndex]; deviceIndex++) {
        !           836:        sentok = 0;
        !           837:        /* sending the SSDP M-SEARCH packet */
        !           838:        n = snprintf(bufr, sizeof(bufr),
        !           839:                     MSearchMsgFmt,
        !           840:                     ipv6 ?
        !           841:                     (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" :  "[" UPNP_MCAST_SL_ADDR "]")
        !           842:                     : UPNP_MCAST_ADDR,
        !           843:                     deviceTypes[deviceIndex], mx);
        !           844:        if ((unsigned int)n >= sizeof(bufr)) {
        !           845:            if(error)
        !           846:                *error = MINISSDPC_MEMORY_ERROR;
        !           847:            goto error;
        !           848:        }
        !           849: #ifdef DEBUG
        !           850:        /*printf("Sending %s", bufr);*/
        !           851:        printf("Sending M-SEARCH request to %s with ST: %s\n",
        !           852:               ipv6 ?
        !           853:               (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" :  "[" UPNP_MCAST_SL_ADDR "]")
        !           854:               : UPNP_MCAST_ADDR,
        !           855:               deviceTypes[deviceIndex]);
        !           856: #endif
        !           857: #ifdef NO_GETADDRINFO
        !           858:        /* the following code is not using getaddrinfo */
        !           859:        /* emission */
        !           860:        memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));
        !           861:        if(ipv6) {
        !           862:            struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;
        !           863:            p->sin6_family = AF_INET6;
        !           864:            p->sin6_port = htons(SSDP_PORT);
        !           865:            inet_pton(AF_INET6,
        !           866:                      linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,
        !           867:                      &(p->sin6_addr));
        !           868:        } else {
        !           869:            struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;
        !           870:            p->sin_family = AF_INET;
        !           871:            p->sin_port = htons(SSDP_PORT);
        !           872:            p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
        !           873:        }
        !           874:        n = sendto(sudp, bufr, n, 0, &sockudp_w,
        !           875:                   ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
        !           876:        if (n < 0) {
        !           877:            if(error)
        !           878:                *error = MINISSDPC_SOCKET_ERROR;
        !           879:            PRINT_SOCKET_ERROR("sendto");
        !           880:        } else {
        !           881:            sentok = 1;
        !           882:        }
        !           883: #else /* #ifdef NO_GETADDRINFO */
        !           884:        memset(&hints, 0, sizeof(hints));
        !           885:        hints.ai_family = AF_UNSPEC; /* AF_INET6 or AF_INET */
        !           886:        hints.ai_socktype = SOCK_DGRAM;
        !           887:        /*hints.ai_flags = */
        !           888:        if ((rv = getaddrinfo(ipv6
        !           889:                              ? (linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR)
        !           890:                              : UPNP_MCAST_ADDR,
        !           891:                              XSTR(SSDP_PORT), &hints, &servinfo)) != 0) {
        !           892:            if(error)
        !           893:                *error = MINISSDPC_SOCKET_ERROR;
        !           894: #ifdef _WIN32
        !           895:            fprintf(stderr, "getaddrinfo() failed: %d\n", rv);
        !           896: #else
        !           897:            fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
        !           898: #endif
        !           899:            break;
        !           900:        } else {
        !           901:            struct addrinfo *p;
        !           902:            for(p = servinfo; p; p = p->ai_next) {
        !           903:                n = sendto(sudp, bufr, n, 0, p->ai_addr, MSC_CAST_INT p->ai_addrlen);
        !           904:                if (n < 0) {
        !           905: #ifdef DEBUG
        !           906:                    char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];
        !           907:                    if (getnameinfo(p->ai_addr, (socklen_t)p->ai_addrlen, hbuf, sizeof(hbuf), sbuf,
        !           908:                                    sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV) == 0) {
        !           909:                        fprintf(stderr, "host:%s port:%s\n", hbuf, sbuf);
        !           910:                    }
        !           911: #endif
        !           912:                    PRINT_SOCKET_ERROR("sendto");
        !           913:                    continue;
        !           914:                } else {
        !           915:                    sentok = 1;
        !           916:                }
        !           917:            }
        !           918:            freeaddrinfo(servinfo);
        !           919:        }
        !           920:        if(!sentok) {
        !           921:            if(error)
        !           922:                *error = MINISSDPC_SOCKET_ERROR;
        !           923:        }
        !           924: #endif /* #ifdef NO_GETADDRINFO */
        !           925:        /* Waiting for SSDP REPLY packet to M-SEARCH
        !           926:         * if searchalltypes is set, enter the loop only
        !           927:         * when the last deviceType is reached */
        !           928:        if((sentok && !searchalltypes) || !deviceTypes[deviceIndex + 1]) {
        !           929:            struct timeval start = {0, 0}, current = {0, 0};
        !           930:            upnp_gettimeofday(&start);
        !           931:            do {
        !           932:                n = receivedata(sudp, bufr, sizeof(bufr), delay, &scope_id);
        !           933:                if (n < 0) {
        !           934:                    /* error */
        !           935:                    if(error)
        !           936:                        *error = MINISSDPC_SOCKET_ERROR;
        !           937:                    goto error;
        !           938:                } else if (n == 0) {
        !           939:                    /* no data or Time Out */
        !           940: #ifdef DEBUG
        !           941:                    printf("NODATA or TIMEOUT\n");
        !           942: #endif /* DEBUG */
        !           943:                    if (devlist && !searchalltypes) {
        !           944:                        /* found some devices, stop now*/
        !           945:                        if(error)
        !           946:                            *error = MINISSDPC_SUCCESS;
        !           947:                        goto error;
        !           948:                    }
        !           949:                } else {
        !           950:                    const char * descURL=NULL;
        !           951:                    int urlsize=0;
        !           952:                    const char * st=NULL;
        !           953:                    int stsize=0;
        !           954:                    const char * usn=NULL;
        !           955:                    int usnsize=0;
        !           956:                    parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize, &usn, &usnsize);
        !           957:                    if(st&&descURL) {
        !           958: #ifdef DEBUG
        !           959:                        printf("M-SEARCH Reply:\n  ST: %.*s\n  USN: %.*s\n  Location: %.*s\n",
        !           960:                               stsize, st, usnsize, (usn?usn:""), urlsize, descURL);
        !           961: #endif /* DEBUG */
        !           962:                        for(tmp=devlist; tmp; tmp = tmp->pNext) {
        !           963:                            if(strncmp(tmp->descURL, descURL, urlsize) == 0 &&
        !           964:                               tmp->descURL[urlsize] == '\0' &&
        !           965:                               strncmp(tmp->st, st, stsize) == 0 &&
        !           966:                               tmp->st[stsize] == '\0' &&
        !           967:                               (usnsize == 0 || strncmp(tmp->usn, usn, usnsize) == 0) &&
        !           968:                               tmp->usn[usnsize] == '\0')
        !           969:                                break;
        !           970:                        }
        !           971:                        /* at the exit of the loop above, tmp is null if
        !           972:                         * no duplicate device was found */
        !           973:                        if(tmp)
        !           974:                            continue;
        !           975:                        tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize+usnsize+3);
        !           976:                        if(!tmp) {
        !           977:                            /* memory allocation error */
        !           978:                            if(error)
        !           979:                                *error = MINISSDPC_MEMORY_ERROR;
        !           980:                            goto error;
        !           981:                        }
        !           982:                        tmp->pNext = devlist;
        !           983:                        tmp->descURL = tmp->buffer;
        !           984:                        tmp->st = tmp->buffer + 1 + urlsize;
        !           985:                        tmp->usn = tmp->st + 1 + stsize;
        !           986:                        memcpy(tmp->buffer, descURL, urlsize);
        !           987:                        tmp->buffer[urlsize] = '\0';
        !           988:                        memcpy(tmp->st, st, stsize);
        !           989:                        tmp->buffer[urlsize+1+stsize] = '\0';
        !           990:                        if(usn != NULL)
        !           991:                            memcpy(tmp->usn, usn, usnsize);
        !           992:                        tmp->buffer[urlsize+1+stsize+1+usnsize] = '\0';
        !           993:                        tmp->scope_id = scope_id;
        !           994:                        devlist = tmp;
        !           995:                    }
        !           996:                    if (upnp_gettimeofday(&current) >= 0) {
        !           997:                        /* exit the loop if delay is reached */
        !           998:                        long interval = (current.tv_sec - start.tv_sec) * 1000;
        !           999:                        interval += (current.tv_usec - start.tv_usec) / 1000;
        !          1000:                        if (interval > (long)delay)
        !          1001:                            break;
        !          1002:                    }
        !          1003:                }
        !          1004:            } while(n > 0);
        !          1005:        }
        !          1006:        if(ipv6) {
        !          1007:            /* switch linklocal flag */
        !          1008:            if(linklocal) {
        !          1009:                linklocal = 0;
        !          1010:                --deviceIndex;
        !          1011:            } else {
        !          1012:                linklocal = 1;
        !          1013:            }
        !          1014:        }
        !          1015:    }
        !          1016: error:
        !          1017:    closesocket(sudp);
        !          1018:    return devlist;
        !          1019: }

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>