Annotation of embedaddon/miniupnpc/miniupnpc.c, revision 1.1
1.1 ! misho 1: /* $Id: miniupnpc.c,v 1.95 2011/05/15 21:42:26 nanard Exp $ */
! 2: /* Project : miniupnp
! 3: * Author : Thomas BERNARD
! 4: * copyright (c) 2005-2011 Thomas Bernard
! 5: * This software is subjet to the conditions detailed in the
! 6: * provided LICENSE file. */
! 7: #define __EXTENSIONS__ 1
! 8: #if !defined(MACOSX) && !defined(__sun)
! 9: #if !defined(_XOPEN_SOURCE) && !defined(__OpenBSD__) && !defined(__NetBSD__)
! 10: #ifndef __cplusplus
! 11: #define _XOPEN_SOURCE 600
! 12: #endif
! 13: #endif
! 14: #ifndef __BSD_VISIBLE
! 15: #define __BSD_VISIBLE 1
! 16: #endif
! 17: #endif
! 18:
! 19: #include <stdlib.h>
! 20: #include <stdio.h>
! 21: #include <string.h>
! 22: #ifdef WIN32
! 23: /* Win32 Specific includes and defines */
! 24: #include <winsock2.h>
! 25: #include <ws2tcpip.h>
! 26: #include <io.h>
! 27: #include <iphlpapi.h>
! 28: #define snprintf _snprintf
! 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: #define MAXHOSTNAMELEN 64
! 37: #else /* #ifdef WIN32 */
! 38: /* Standard POSIX includes */
! 39: #include <unistd.h>
! 40: #if defined(__amigaos__) && !defined(__amigaos4__)
! 41: /* Amiga OS 3 specific stuff */
! 42: #define socklen_t int
! 43: #else
! 44: #include <sys/select.h>
! 45: #endif
! 46: #include <sys/socket.h>
! 47: #include <sys/types.h>
! 48: #include <sys/param.h>
! 49: #include <netinet/in.h>
! 50: #include <arpa/inet.h>
! 51: #include <netdb.h>
! 52: #include <net/if.h>
! 53: #if !defined(__amigaos__) && !defined(__amigaos4__)
! 54: #include <poll.h>
! 55: #endif
! 56: #include <strings.h>
! 57: #include <errno.h>
! 58: #define closesocket close
! 59: #endif /* #else WIN32 */
! 60: #ifdef MINIUPNPC_SET_SOCKET_TIMEOUT
! 61: #include <sys/time.h>
! 62: #endif
! 63: #if defined(__amigaos__) || defined(__amigaos4__)
! 64: /* Amiga OS specific stuff */
! 65: #define TIMEVAL struct timeval
! 66: #endif
! 67:
! 68: #include "miniupnpc.h"
! 69: #include "minissdpc.h"
! 70: #include "miniwget.h"
! 71: #include "minisoap.h"
! 72: #include "minixml.h"
! 73: #include "upnpcommands.h"
! 74: #include "connecthostport.h"
! 75: #include "receivedata.h"
! 76:
! 77: #ifdef WIN32
! 78: #define PRINT_SOCKET_ERROR(x) printf("Socket error: %s, %d\n", x, WSAGetLastError());
! 79: #else
! 80: #define PRINT_SOCKET_ERROR(x) perror(x)
! 81: #endif
! 82:
! 83: #define SOAPPREFIX "s"
! 84: #define SERVICEPREFIX "u"
! 85: #define SERVICEPREFIX2 'u'
! 86:
! 87: /* root description parsing */
! 88: LIBSPEC void parserootdesc(const char * buffer, int bufsize, struct IGDdatas * data)
! 89: {
! 90: struct xmlparser parser;
! 91: /* xmlparser object */
! 92: parser.xmlstart = buffer;
! 93: parser.xmlsize = bufsize;
! 94: parser.data = data;
! 95: parser.starteltfunc = IGDstartelt;
! 96: parser.endeltfunc = IGDendelt;
! 97: parser.datafunc = IGDdata;
! 98: parser.attfunc = 0;
! 99: parsexml(&parser);
! 100: #ifdef DEBUG
! 101: printIGD(data);
! 102: #endif
! 103: }
! 104:
! 105: /* simpleUPnPcommand2 :
! 106: * not so simple !
! 107: * return values :
! 108: * pointer - OK
! 109: * NULL - error */
! 110: char * simpleUPnPcommand2(int s, const char * url, const char * service,
! 111: const char * action, struct UPNParg * args,
! 112: int * bufsize, const char * httpversion)
! 113: {
! 114: char hostname[MAXHOSTNAMELEN+1];
! 115: unsigned short port = 0;
! 116: char * path;
! 117: char soapact[128];
! 118: char soapbody[2048];
! 119: char * buf;
! 120: int n;
! 121:
! 122: *bufsize = 0;
! 123: snprintf(soapact, sizeof(soapact), "%s#%s", service, action);
! 124: if(args==NULL)
! 125: {
! 126: /*soapbodylen = */snprintf(soapbody, sizeof(soapbody),
! 127: "<?xml version=\"1.0\"?>\r\n"
! 128: "<" SOAPPREFIX ":Envelope "
! 129: "xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
! 130: SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
! 131: "<" SOAPPREFIX ":Body>"
! 132: "<" SERVICEPREFIX ":%s xmlns:" SERVICEPREFIX "=\"%s\">"
! 133: "</" SERVICEPREFIX ":%s>"
! 134: "</" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>"
! 135: "\r\n", action, service, action);
! 136: }
! 137: else
! 138: {
! 139: char * p;
! 140: const char * pe, * pv;
! 141: int soapbodylen;
! 142: soapbodylen = snprintf(soapbody, sizeof(soapbody),
! 143: "<?xml version=\"1.0\"?>\r\n"
! 144: "<" SOAPPREFIX ":Envelope "
! 145: "xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
! 146: SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
! 147: "<" SOAPPREFIX ":Body>"
! 148: "<" SERVICEPREFIX ":%s xmlns:" SERVICEPREFIX "=\"%s\">",
! 149: action, service);
! 150: p = soapbody + soapbodylen;
! 151: while(args->elt)
! 152: {
! 153: /* check that we are never overflowing the string... */
! 154: if(soapbody + sizeof(soapbody) <= p + 100)
! 155: {
! 156: /* we keep a margin of at least 100 bytes */
! 157: return NULL;
! 158: }
! 159: *(p++) = '<';
! 160: pe = args->elt;
! 161: while(*pe)
! 162: *(p++) = *(pe++);
! 163: *(p++) = '>';
! 164: if((pv = args->val))
! 165: {
! 166: while(*pv)
! 167: *(p++) = *(pv++);
! 168: }
! 169: *(p++) = '<';
! 170: *(p++) = '/';
! 171: pe = args->elt;
! 172: while(*pe)
! 173: *(p++) = *(pe++);
! 174: *(p++) = '>';
! 175: args++;
! 176: }
! 177: *(p++) = '<';
! 178: *(p++) = '/';
! 179: *(p++) = SERVICEPREFIX2;
! 180: *(p++) = ':';
! 181: pe = action;
! 182: while(*pe)
! 183: *(p++) = *(pe++);
! 184: strncpy(p, "></" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>\r\n",
! 185: soapbody + sizeof(soapbody) - p);
! 186: }
! 187: if(!parseURL(url, hostname, &port, &path)) return NULL;
! 188: if(s<0)
! 189: {
! 190: s = connecthostport(hostname, port);
! 191: if(s < 0)
! 192: {
! 193: return NULL;
! 194: }
! 195: }
! 196:
! 197: n = soapPostSubmit(s, path, hostname, port, soapact, soapbody, httpversion);
! 198: if(n<=0) {
! 199: #ifdef DEBUG
! 200: printf("Error sending SOAP request\n");
! 201: #endif
! 202: closesocket(s);
! 203: return NULL;
! 204: }
! 205:
! 206: buf = getHTTPResponse(s, bufsize);
! 207: #ifdef DEBUG
! 208: if(*bufsize > 0 && buf)
! 209: {
! 210: printf("SOAP Response :\n%.*s\n", *bufsize, buf);
! 211: }
! 212: #endif
! 213: closesocket(s);
! 214: return buf;
! 215: }
! 216:
! 217: /* simpleUPnPcommand :
! 218: * not so simple !
! 219: * return values :
! 220: * pointer - OK
! 221: * NULL - error */
! 222: char * simpleUPnPcommand(int s, const char * url, const char * service,
! 223: const char * action, struct UPNParg * args,
! 224: int * bufsize)
! 225: {
! 226: char * buf;
! 227:
! 228: buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.1");
! 229: /*
! 230: buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.0");
! 231: if (!buf || *bufsize == 0)
! 232: {
! 233: #if DEBUG
! 234: printf("Error or no result from SOAP request; retrying with HTTP/1.1\n");
! 235: #endif
! 236: buf = simpleUPnPcommand2(s, url, service, action, args, bufsize, "1.1");
! 237: }
! 238: */
! 239: return buf;
! 240: }
! 241:
! 242: /* parseMSEARCHReply()
! 243: * the last 4 arguments are filled during the parsing :
! 244: * - location/locationsize : "location:" field of the SSDP reply packet
! 245: * - st/stsize : "st:" field of the SSDP reply packet.
! 246: * The strings are NOT null terminated */
! 247: static void
! 248: parseMSEARCHReply(const char * reply, int size,
! 249: const char * * location, int * locationsize,
! 250: const char * * st, int * stsize)
! 251: {
! 252: int a, b, i;
! 253: i = 0;
! 254: a = i; /* start of the line */
! 255: b = 0; /* end of the "header" (position of the colon) */
! 256: while(i<size)
! 257: {
! 258: switch(reply[i])
! 259: {
! 260: case ':':
! 261: if(b==0)
! 262: {
! 263: b = i; /* end of the "header" */
! 264: /*for(j=a; j<b; j++)
! 265: {
! 266: putchar(reply[j]);
! 267: }
! 268: */
! 269: }
! 270: break;
! 271: case '\x0a':
! 272: case '\x0d':
! 273: if(b!=0)
! 274: {
! 275: /*for(j=b+1; j<i; j++)
! 276: {
! 277: putchar(reply[j]);
! 278: }
! 279: putchar('\n');*/
! 280: /* skip the colon and white spaces */
! 281: do { b++; } while(reply[b]==' ');
! 282: if(0==strncasecmp(reply+a, "location", 8))
! 283: {
! 284: *location = reply+b;
! 285: *locationsize = i-b;
! 286: }
! 287: else if(0==strncasecmp(reply+a, "st", 2))
! 288: {
! 289: *st = reply+b;
! 290: *stsize = i-b;
! 291: }
! 292: b = 0;
! 293: }
! 294: a = i+1;
! 295: break;
! 296: default:
! 297: break;
! 298: }
! 299: i++;
! 300: }
! 301: }
! 302:
! 303: /* port upnp discover : SSDP protocol */
! 304: #define PORT 1900
! 305: #define XSTR(s) STR(s)
! 306: #define STR(s) #s
! 307: #define UPNP_MCAST_ADDR "239.255.255.250"
! 308: /* for IPv6 */
! 309: #define UPNP_MCAST_LL_ADDR "FF02::C" /* link-local */
! 310: #define UPNP_MCAST_SL_ADDR "FF05::C" /* site-local */
! 311:
! 312: /* upnpDiscover() :
! 313: * return a chained list of all devices found or NULL if
! 314: * no devices was found.
! 315: * It is up to the caller to free the chained list
! 316: * delay is in millisecond (poll) */
! 317: LIBSPEC struct UPNPDev *
! 318: upnpDiscover(int delay, const char * multicastif,
! 319: const char * minissdpdsock, int sameport,
! 320: int ipv6,
! 321: int * error)
! 322: {
! 323: struct UPNPDev * tmp;
! 324: struct UPNPDev * devlist = 0;
! 325: int opt = 1;
! 326: static const char MSearchMsgFmt[] =
! 327: "M-SEARCH * HTTP/1.1\r\n"
! 328: "HOST: %s:" XSTR(PORT) "\r\n"
! 329: "ST: %s\r\n"
! 330: "MAN: \"ssdp:discover\"\r\n"
! 331: "MX: %u\r\n"
! 332: "\r\n";
! 333: static const char * const deviceList[] = {
! 334: #if 0
! 335: "urn:schemas-upnp-org:device:InternetGatewayDevice:2",
! 336: "urn:schemas-upnp-org:service:WANIPConnection:2",
! 337: #endif
! 338: "urn:schemas-upnp-org:device:InternetGatewayDevice:1",
! 339: "urn:schemas-upnp-org:service:WANIPConnection:1",
! 340: "urn:schemas-upnp-org:service:WANPPPConnection:1",
! 341: "upnp:rootdevice",
! 342: 0
! 343: };
! 344: int deviceIndex = 0;
! 345: char bufr[1536]; /* reception and emission buffer */
! 346: int sudp;
! 347: int n;
! 348: struct sockaddr_storage sockudp_r;
! 349: unsigned int mx;
! 350: #ifdef NO_GETADDRINFO
! 351: struct sockaddr_storage sockudp_w;
! 352: #else
! 353: int rv;
! 354: struct addrinfo hints, *servinfo, *p;
! 355: #endif
! 356: #ifdef WIN32
! 357: MIB_IPFORWARDROW ip_forward;
! 358: #endif
! 359: int linklocal = 1;
! 360:
! 361: if(error)
! 362: *error = UPNPDISCOVER_UNKNOWN_ERROR;
! 363: #if !defined(WIN32) && !defined(__amigaos__) && !defined(__amigaos4__)
! 364: /* first try to get infos from minissdpd ! */
! 365: if(!minissdpdsock)
! 366: minissdpdsock = "/var/run/minissdpd.sock";
! 367: while(!devlist && deviceList[deviceIndex]) {
! 368: devlist = getDevicesFromMiniSSDPD(deviceList[deviceIndex],
! 369: minissdpdsock);
! 370: /* We return what we have found if it was not only a rootdevice */
! 371: if(devlist && !strstr(deviceList[deviceIndex], "rootdevice")) {
! 372: if(error)
! 373: *error = UPNPDISCOVER_SUCCESS;
! 374: return devlist;
! 375: }
! 376: deviceIndex++;
! 377: }
! 378: deviceIndex = 0;
! 379: #endif
! 380: /* fallback to direct discovery */
! 381: #ifdef WIN32
! 382: sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP);
! 383: #else
! 384: sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0);
! 385: #endif
! 386: if(sudp < 0)
! 387: {
! 388: if(error)
! 389: *error = UPNPDISCOVER_SOCKET_ERROR;
! 390: PRINT_SOCKET_ERROR("socket");
! 391: return NULL;
! 392: }
! 393: /* reception */
! 394: memset(&sockudp_r, 0, sizeof(struct sockaddr_storage));
! 395: if(ipv6) {
! 396: struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_r;
! 397: p->sin6_family = AF_INET6;
! 398: if(sameport)
! 399: p->sin6_port = htons(PORT);
! 400: p->sin6_addr = in6addr_any; /* in6addr_any is not available with MinGW32 3.4.2 */
! 401: } else {
! 402: struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_r;
! 403: p->sin_family = AF_INET;
! 404: if(sameport)
! 405: p->sin_port = htons(PORT);
! 406: p->sin_addr.s_addr = INADDR_ANY;
! 407: }
! 408: #ifdef WIN32
! 409: /* This code could help us to use the right Network interface for
! 410: * SSDP multicast traffic */
! 411: /* Get IP associated with the index given in the ip_forward struct
! 412: * in order to give this ip to setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF) */
! 413: if(!ipv6
! 414: && (GetBestRoute(inet_addr("223.255.255.255"), 0, &ip_forward) == NO_ERROR)) {
! 415: DWORD dwRetVal = 0;
! 416: PMIB_IPADDRTABLE pIPAddrTable;
! 417: DWORD dwSize = 0;
! 418: #ifdef DEBUG
! 419: IN_ADDR IPAddr;
! 420: #endif
! 421: int i;
! 422: #ifdef DEBUG
! 423: printf("ifIndex=%lu nextHop=%lx \n", ip_forward.dwForwardIfIndex, ip_forward.dwForwardNextHop);
! 424: #endif
! 425: pIPAddrTable = (MIB_IPADDRTABLE *) malloc(sizeof (MIB_IPADDRTABLE));
! 426: if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {
! 427: free(pIPAddrTable);
! 428: pIPAddrTable = (MIB_IPADDRTABLE *) malloc(dwSize);
! 429: }
! 430: if(pIPAddrTable) {
! 431: dwRetVal = GetIpAddrTable( pIPAddrTable, &dwSize, 0 );
! 432: #ifdef DEBUG
! 433: printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries);
! 434: #endif
! 435: for (i=0; i < (int) pIPAddrTable->dwNumEntries; i++) {
! 436: #ifdef DEBUG
! 437: printf("\n\tInterface Index[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwIndex);
! 438: IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr;
! 439: printf("\tIP Address[%d]: \t%s\n", i, inet_ntoa(IPAddr) );
! 440: IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask;
! 441: printf("\tSubnet Mask[%d]: \t%s\n", i, inet_ntoa(IPAddr) );
! 442: IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr;
! 443: printf("\tBroadCast[%d]: \t%s (%ld)\n", i, inet_ntoa(IPAddr), pIPAddrTable->table[i].dwBCastAddr);
! 444: printf("\tReassembly size[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwReasmSize);
! 445: printf("\tType and State[%d]:", i);
! 446: printf("\n");
! 447: #endif
! 448: if (pIPAddrTable->table[i].dwIndex == ip_forward.dwForwardIfIndex) {
! 449: /* Set the address of this interface to be used */
! 450: struct in_addr mc_if;
! 451: memset(&mc_if, 0, sizeof(mc_if));
! 452: mc_if.s_addr = pIPAddrTable->table[i].dwAddr;
! 453: if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0) {
! 454: PRINT_SOCKET_ERROR("setsockopt");
! 455: }
! 456: ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = pIPAddrTable->table[i].dwAddr;
! 457: #ifndef DEBUG
! 458: break;
! 459: #endif
! 460: }
! 461: }
! 462: free(pIPAddrTable);
! 463: pIPAddrTable = NULL;
! 464: }
! 465: }
! 466: #endif
! 467:
! 468: #ifdef WIN32
! 469: if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)
! 470: #else
! 471: if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)
! 472: #endif
! 473: {
! 474: if(error)
! 475: *error = UPNPDISCOVER_SOCKET_ERROR;
! 476: PRINT_SOCKET_ERROR("setsockopt");
! 477: return NULL;
! 478: }
! 479:
! 480: if(multicastif)
! 481: {
! 482: if(ipv6) {
! 483: #if !defined(WIN32)
! 484: /* according to MSDN, if_nametoindex() is supported since
! 485: * MS Windows Vista and MS Windows Server 2008.
! 486: * http://msdn.microsoft.com/en-us/library/bb408409%28v=vs.85%29.aspx */
! 487: unsigned int ifindex = if_nametoindex(multicastif); /* eth0, etc. */
! 488: if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(&ifindex)) < 0)
! 489: {
! 490: PRINT_SOCKET_ERROR("setsockopt");
! 491: }
! 492: #else
! 493: #ifdef DEBUG
! 494: printf("Setting of multicast interface not supported in IPv6 under Windows.\n");
! 495: #endif
! 496: #endif
! 497: } else {
! 498: struct in_addr mc_if;
! 499: mc_if.s_addr = inet_addr(multicastif); /* ex: 192.168.x.x */
! 500: ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = mc_if.s_addr;
! 501: if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)
! 502: {
! 503: PRINT_SOCKET_ERROR("setsockopt");
! 504: }
! 505: }
! 506: }
! 507:
! 508: /* Avant d'envoyer le paquet on bind pour recevoir la reponse */
! 509: if (bind(sudp, (const struct sockaddr *)&sockudp_r,
! 510: ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) != 0)
! 511: {
! 512: if(error)
! 513: *error = UPNPDISCOVER_SOCKET_ERROR;
! 514: PRINT_SOCKET_ERROR("bind");
! 515: closesocket(sudp);
! 516: return NULL;
! 517: }
! 518:
! 519: if(error)
! 520: *error = UPNPDISCOVER_SUCCESS;
! 521: /* Calculating maximum response time in seconds */
! 522: mx = ((unsigned int)delay) / 1000u;
! 523: /* receiving SSDP response packet */
! 524: for(n = 0; deviceList[deviceIndex]; deviceIndex++)
! 525: {
! 526: if(n == 0)
! 527: {
! 528: /* sending the SSDP M-SEARCH packet */
! 529: n = snprintf(bufr, sizeof(bufr),
! 530: MSearchMsgFmt,
! 531: ipv6 ?
! 532: (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" : "[" UPNP_MCAST_SL_ADDR "]")
! 533: : UPNP_MCAST_ADDR,
! 534: deviceList[deviceIndex], mx);
! 535: #ifdef DEBUG
! 536: printf("Sending %s", bufr);
! 537: #endif
! 538: #ifdef NO_GETADDRINFO
! 539: /* the following code is not using getaddrinfo */
! 540: /* emission */
! 541: memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));
! 542: if(ipv6) {
! 543: struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;
! 544: p->sin6_family = AF_INET6;
! 545: p->sin6_port = htons(PORT);
! 546: inet_pton(AF_INET6,
! 547: linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,
! 548: &(p->sin6_addr));
! 549: } else {
! 550: struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;
! 551: p->sin_family = AF_INET;
! 552: p->sin_port = htons(PORT);
! 553: p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
! 554: }
! 555: n = sendto(sudp, bufr, n, 0,
! 556: &sockudp_w,
! 557: ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
! 558: if (n < 0) {
! 559: if(error)
! 560: *error = UPNPDISCOVER_SOCKET_ERROR;
! 561: PRINT_SOCKET_ERROR("sendto");
! 562: break;
! 563: }
! 564: #else /* #ifdef NO_GETADDRINFO */
! 565: memset(&hints, 0, sizeof(hints));
! 566: hints.ai_family = AF_UNSPEC; // AF_INET6 or AF_INET
! 567: hints.ai_socktype = SOCK_DGRAM;
! 568: /*hints.ai_flags = */
! 569: if ((rv = getaddrinfo(ipv6
! 570: ? (linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR)
! 571: : UPNP_MCAST_ADDR,
! 572: XSTR(PORT), &hints, &servinfo)) != 0) {
! 573: if(error)
! 574: *error = UPNPDISCOVER_SOCKET_ERROR;
! 575: #ifdef WIN32
! 576: fprintf(stderr, "getaddrinfo() failed: %d\n", rv);
! 577: #else
! 578: fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));
! 579: #endif
! 580: break;
! 581: }
! 582: for(p = servinfo; p; p = p->ai_next) {
! 583: n = sendto(sudp, bufr, n, 0, p->ai_addr, p->ai_addrlen);
! 584: if (n < 0) {
! 585: PRINT_SOCKET_ERROR("sendto");
! 586: continue;
! 587: }
! 588: }
! 589: freeaddrinfo(servinfo);
! 590: if(n < 0) {
! 591: if(error)
! 592: *error = UPNPDISCOVER_SOCKET_ERROR;
! 593: break;
! 594: }
! 595: #endif /* #ifdef NO_GETADDRINFO */
! 596: }
! 597: /* Waiting for SSDP REPLY packet to M-SEARCH */
! 598: n = receivedata(sudp, bufr, sizeof(bufr), delay);
! 599: if (n < 0) {
! 600: /* error */
! 601: if(error)
! 602: *error = UPNPDISCOVER_SOCKET_ERROR;
! 603: break;
! 604: } else if (n == 0) {
! 605: /* no data or Time Out */
! 606: if (devlist) {
! 607: /* no more device type to look for... */
! 608: if(error)
! 609: *error = UPNPDISCOVER_SUCCESS;
! 610: break;
! 611: }
! 612: if(ipv6) {
! 613: if(linklocal) {
! 614: linklocal = 0;
! 615: --deviceIndex;
! 616: } else {
! 617: linklocal = 1;
! 618: }
! 619: }
! 620: } else {
! 621: const char * descURL=NULL;
! 622: int urlsize=0;
! 623: const char * st=NULL;
! 624: int stsize=0;
! 625: /*printf("%d byte(s) :\n%s\n", n, bufr);*/ /* affichage du message */
! 626: parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize);
! 627: if(st&&descURL)
! 628: {
! 629: #ifdef DEBUG
! 630: printf("M-SEARCH Reply:\nST: %.*s\nLocation: %.*s\n",
! 631: stsize, st, urlsize, descURL);
! 632: #endif
! 633: for(tmp=devlist; tmp; tmp = tmp->pNext) {
! 634: if(memcmp(tmp->descURL, descURL, urlsize) == 0 &&
! 635: tmp->descURL[urlsize] == '\0' &&
! 636: memcmp(tmp->st, st, stsize) == 0 &&
! 637: tmp->st[stsize] == '\0')
! 638: break;
! 639: }
! 640: /* at the exit of the loop above, tmp is null if
! 641: * no duplicate device was found */
! 642: if(tmp)
! 643: continue;
! 644: tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize);
! 645: if(!tmp) {
! 646: /* memory allocation error */
! 647: if(error)
! 648: *error = UPNPDISCOVER_MEMORY_ERROR;
! 649: break;
! 650: }
! 651: tmp->pNext = devlist;
! 652: tmp->descURL = tmp->buffer;
! 653: tmp->st = tmp->buffer + 1 + urlsize;
! 654: memcpy(tmp->buffer, descURL, urlsize);
! 655: tmp->buffer[urlsize] = '\0';
! 656: memcpy(tmp->buffer + urlsize + 1, st, stsize);
! 657: tmp->buffer[urlsize+1+stsize] = '\0';
! 658: devlist = tmp;
! 659: }
! 660: }
! 661: }
! 662: closesocket(sudp);
! 663: return devlist;
! 664: }
! 665:
! 666: /* freeUPNPDevlist() should be used to
! 667: * free the chained list returned by upnpDiscover() */
! 668: LIBSPEC void freeUPNPDevlist(struct UPNPDev * devlist)
! 669: {
! 670: struct UPNPDev * next;
! 671: while(devlist)
! 672: {
! 673: next = devlist->pNext;
! 674: free(devlist);
! 675: devlist = next;
! 676: }
! 677: }
! 678:
! 679: static void
! 680: url_cpy_or_cat(char * dst, const char * src, int n)
! 681: {
! 682: if( (src[0] == 'h')
! 683: &&(src[1] == 't')
! 684: &&(src[2] == 't')
! 685: &&(src[3] == 'p')
! 686: &&(src[4] == ':')
! 687: &&(src[5] == '/')
! 688: &&(src[6] == '/'))
! 689: {
! 690: strncpy(dst, src, n);
! 691: }
! 692: else
! 693: {
! 694: int l = strlen(dst);
! 695: if(src[0] != '/')
! 696: dst[l++] = '/';
! 697: if(l<=n)
! 698: strncpy(dst + l, src, n - l);
! 699: }
! 700: }
! 701:
! 702: /* Prepare the Urls for usage...
! 703: */
! 704: LIBSPEC void GetUPNPUrls(struct UPNPUrls * urls, struct IGDdatas * data,
! 705: const char * descURL)
! 706: {
! 707: char * p;
! 708: int n1, n2, n3, n4;
! 709: n1 = strlen(data->urlbase);
! 710: if(n1==0)
! 711: n1 = strlen(descURL);
! 712: n1 += 2; /* 1 byte more for Null terminator, 1 byte for '/' if needed */
! 713: n2 = n1; n3 = n1; n4 = n1;
! 714: n1 += strlen(data->first.scpdurl);
! 715: n2 += strlen(data->first.controlurl);
! 716: n3 += strlen(data->CIF.controlurl);
! 717: n4 += strlen(data->IPv6FC.controlurl);
! 718:
! 719: urls->ipcondescURL = (char *)malloc(n1);
! 720: urls->controlURL = (char *)malloc(n2);
! 721: urls->controlURL_CIF = (char *)malloc(n3);
! 722: urls->controlURL_6FC = (char *)malloc(n4);
! 723: /* maintenant on chope la desc du WANIPConnection */
! 724: if(data->urlbase[0] != '\0')
! 725: strncpy(urls->ipcondescURL, data->urlbase, n1);
! 726: else
! 727: strncpy(urls->ipcondescURL, descURL, n1);
! 728: p = strchr(urls->ipcondescURL+7, '/');
! 729: if(p) p[0] = '\0';
! 730: strncpy(urls->controlURL, urls->ipcondescURL, n2);
! 731: strncpy(urls->controlURL_CIF, urls->ipcondescURL, n3);
! 732: strncpy(urls->controlURL_6FC, urls->ipcondescURL, n4);
! 733:
! 734: url_cpy_or_cat(urls->ipcondescURL, data->first.scpdurl, n1);
! 735:
! 736: url_cpy_or_cat(urls->controlURL, data->first.controlurl, n2);
! 737:
! 738: url_cpy_or_cat(urls->controlURL_CIF, data->CIF.controlurl, n3);
! 739:
! 740: url_cpy_or_cat(urls->controlURL_6FC, data->IPv6FC.controlurl, n4);
! 741:
! 742: #ifdef DEBUG
! 743: printf("urls->ipcondescURL='%s' %u n1=%d\n", urls->ipcondescURL,
! 744: (unsigned)strlen(urls->ipcondescURL), n1);
! 745: printf("urls->controlURL='%s' %u n2=%d\n", urls->controlURL,
! 746: (unsigned)strlen(urls->controlURL), n2);
! 747: printf("urls->controlURL_CIF='%s' %u n3=%d\n", urls->controlURL_CIF,
! 748: (unsigned)strlen(urls->controlURL_CIF), n3);
! 749: printf("urls->controlURL_6FC='%s' %u n4=%d\n", urls->controlURL_6FC,
! 750: (unsigned)strlen(urls->controlURL_6FC), n4);
! 751: #endif
! 752: }
! 753:
! 754: LIBSPEC void
! 755: FreeUPNPUrls(struct UPNPUrls * urls)
! 756: {
! 757: if(!urls)
! 758: return;
! 759: free(urls->controlURL);
! 760: urls->controlURL = 0;
! 761: free(urls->ipcondescURL);
! 762: urls->ipcondescURL = 0;
! 763: free(urls->controlURL_CIF);
! 764: urls->controlURL_CIF = 0;
! 765: free(urls->controlURL_6FC);
! 766: urls->controlURL_6FC = 0;
! 767: }
! 768:
! 769: int
! 770: UPNPIGD_IsConnected(struct UPNPUrls * urls, struct IGDdatas * data)
! 771: {
! 772: char status[64];
! 773: unsigned int uptime;
! 774: status[0] = '\0';
! 775: UPNP_GetStatusInfo(urls->controlURL, data->first.servicetype,
! 776: status, &uptime, NULL);
! 777: if(0 == strcmp("Connected", status))
! 778: {
! 779: return 1;
! 780: }
! 781: else
! 782: return 0;
! 783: }
! 784:
! 785:
! 786: /* UPNP_GetValidIGD() :
! 787: * return values :
! 788: * 0 = NO IGD found
! 789: * 1 = A valid connected IGD has been found
! 790: * 2 = A valid IGD has been found but it reported as
! 791: * not connected
! 792: * 3 = an UPnP device has been found but was not recognized as an IGD
! 793: *
! 794: * In any non zero return case, the urls and data structures
! 795: * passed as parameters are set. Donc forget to call FreeUPNPUrls(urls) to
! 796: * free allocated memory.
! 797: */
! 798: LIBSPEC int
! 799: UPNP_GetValidIGD(struct UPNPDev * devlist,
! 800: struct UPNPUrls * urls,
! 801: struct IGDdatas * data,
! 802: char * lanaddr, int lanaddrlen)
! 803: {
! 804: char * descXML;
! 805: int descXMLsize = 0;
! 806: struct UPNPDev * dev;
! 807: int ndev = 0;
! 808: int state; /* state 1 : IGD connected. State 2 : IGD. State 3 : anything */
! 809: if(!devlist)
! 810: {
! 811: #ifdef DEBUG
! 812: printf("Empty devlist\n");
! 813: #endif
! 814: return 0;
! 815: }
! 816: for(state = 1; state <= 3; state++)
! 817: {
! 818: for(dev = devlist; dev; dev = dev->pNext)
! 819: {
! 820: /* we should choose an internet gateway device.
! 821: * with st == urn:schemas-upnp-org:device:InternetGatewayDevice:1 */
! 822: descXML = miniwget_getaddr(dev->descURL, &descXMLsize,
! 823: lanaddr, lanaddrlen);
! 824: if(descXML)
! 825: {
! 826: ndev++;
! 827: memset(data, 0, sizeof(struct IGDdatas));
! 828: memset(urls, 0, sizeof(struct UPNPUrls));
! 829: parserootdesc(descXML, descXMLsize, data);
! 830: free(descXML);
! 831: descXML = NULL;
! 832: if(0==strcmp(data->CIF.servicetype,
! 833: "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1")
! 834: || state >= 3 )
! 835: {
! 836: GetUPNPUrls(urls, data, dev->descURL);
! 837:
! 838: #ifdef DEBUG
! 839: printf("UPNPIGD_IsConnected(%s) = %d\n",
! 840: urls->controlURL,
! 841: UPNPIGD_IsConnected(urls, data));
! 842: #endif
! 843: if((state >= 2) || UPNPIGD_IsConnected(urls, data))
! 844: return state;
! 845: FreeUPNPUrls(urls);
! 846: if(data->second.servicetype[0] != '\0') {
! 847: #ifdef DEBUG
! 848: printf("We tried %s, now we try %s !\n",
! 849: data->first.servicetype, data->second.servicetype);
! 850: #endif
! 851: /* swaping WANPPPConnection and WANIPConnection ! */
! 852: memcpy(&data->tmp, &data->first, sizeof(struct IGDdatas_service));
! 853: memcpy(&data->first, &data->second, sizeof(struct IGDdatas_service));
! 854: memcpy(&data->second, &data->tmp, sizeof(struct IGDdatas_service));
! 855: GetUPNPUrls(urls, data, dev->descURL);
! 856: #ifdef DEBUG
! 857: printf("UPNPIGD_IsConnected(%s) = %d\n",
! 858: urls->controlURL,
! 859: UPNPIGD_IsConnected(urls, data));
! 860: #endif
! 861: if((state >= 2) || UPNPIGD_IsConnected(urls, data))
! 862: return state;
! 863: FreeUPNPUrls(urls);
! 864: }
! 865: }
! 866: memset(data, 0, sizeof(struct IGDdatas));
! 867: }
! 868: #ifdef DEBUG
! 869: else
! 870: {
! 871: printf("error getting XML description %s\n", dev->descURL);
! 872: }
! 873: #endif
! 874: }
! 875: }
! 876: return 0;
! 877: }
! 878:
! 879: /* UPNP_GetIGDFromUrl()
! 880: * Used when skipping the discovery process.
! 881: * return value :
! 882: * 0 - Not ok
! 883: * 1 - OK */
! 884: int
! 885: UPNP_GetIGDFromUrl(const char * rootdescurl,
! 886: struct UPNPUrls * urls,
! 887: struct IGDdatas * data,
! 888: char * lanaddr, int lanaddrlen)
! 889: {
! 890: char * descXML;
! 891: int descXMLsize = 0;
! 892: descXML = miniwget_getaddr(rootdescurl, &descXMLsize,
! 893: lanaddr, lanaddrlen);
! 894: if(descXML) {
! 895: memset(data, 0, sizeof(struct IGDdatas));
! 896: memset(urls, 0, sizeof(struct UPNPUrls));
! 897: parserootdesc(descXML, descXMLsize, data);
! 898: free(descXML);
! 899: descXML = NULL;
! 900: GetUPNPUrls(urls, data, rootdescurl);
! 901: return 1;
! 902: } else {
! 903: return 0;
! 904: }
! 905: }
! 906:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to miniupnpc.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpc