Annotation of embedaddon/miniupnpc/src/minissdpc.c, revision 1.1.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>