+Copyright (c) 2005-2016, Thomas BERNARD

+ * This file defines five types of data structures: singly-linked lists,

+

+

+/*

+ * tail queue access methods

+ * Circular queue access methods

+/* $Id: codelength.h,v 1.5 2015/07/09 12:40:18 nanard Exp $ */

+ * copyright (c) 2005-2015 Thomas Bernard

+#ifndef CODELENGTH_H_INCLUDED

+#define CODELENGTH_H_INCLUDED

+

+/* n : unsigned

+ * p : unsigned char *

+ */

+ while((*(p++)&0x80) && (n<(1<<25)));

+

+/* n : unsigned

+ * READ : function/macro to read one byte (unsigned char)

+ */

+#define DECODELENGTH_READ(n, READ) \

+ n = 0; \

+ do { \

+ unsigned char c; \

+ READ(c); \

+ n = (n << 7) | (c & 0x07f); \

+ if(!(c&0x80)) break; \

+ } while(n<(1<<25));

+

+/* n : unsigned

+ * p : unsigned char *

+ * p_limit : unsigned char *

+ */

+#define DECODELENGTH_CHECKLIMIT(n, p, p_limit) \

+ n = 0; \

+ do { \

+ if((p) >= (p_limit)) break; \

+ n = (n << 7) | (*(p) & 0x7f); \

+ } while((*((p)++)&0x80) && (n<(1<<25)));

+

+/* n : unsigned

+ * p : unsigned char *

+ */

+#endif /* CODELENGTH_H_INCLUDED */

+/* $Id: connecthostport.c,v 1.17 2017/04/21 09:58:30 nanard Exp $ */

+ * Copyright (c) 2010-2017 Thomas Bernard

+#ifdef _WIN32

+#else /* #ifdef _WIN32 */

+#include <sys/types.h>

+#ifdef MINIUPNPC_SET_SOCKET_TIMEOUT

+#include <sys/time.h>

+#endif /* #ifdef MINIUPNPC_SET_SOCKET_TIMEOUT */

+#include <sys/select.h>

+#include <netinet/in.h>

+#include <sys/select.h>

+#endif /* #else _WIN32 */

+#ifdef _WIN32

+#define PRINT_SOCKET_ERROR(x) fprintf(stderr, "Socket error: %s, %d\n", x, WSAGetLastError());

+#ifndef MAXHOSTNAMELEN

+#define MAXHOSTNAMELEN 64

+#endif

+

+int connecthostport(const char * host, unsigned short port,

+ unsigned int scope_id)

+

+ timeout.tv_sec = 3;

+ PRINT_SOCKET_ERROR("setsockopt SO_RCVTIMEO");

+ timeout.tv_sec = 3;

+ PRINT_SOCKET_ERROR("setsockopt SO_SNDTIMEO");

+ /* EINTR The system call was interrupted by a signal that was caught

+ * EINPROGRESS The socket is nonblocking and the connection cannot

+ * be completed immediately. */

+ while(n < 0 && (errno == EINTR || errno == EINPROGRESS))

+ int i, j;

+ for(i = 0, j = 1; host[j] && (host[j] != ']') && i < MAXHOSTNAMELEN; i++, j++)

+ tmp_host[i] = host[j];

+ if(0 == memcmp(host+j, "%25", 3)) /* %25 is just url encoding for '%' */

+ j+=2; /* skip "25" */

+#ifdef _WIN32

+ if(p->ai_addr->sa_family == AF_INET6 && scope_id > 0) {

+ struct sockaddr_in6 * addr6 = (struct sockaddr_in6 *)p->ai_addr;

+ addr6->sin6_scope_id = scope_id;

+ }

+ timeout.tv_sec = 3;

+ timeout.tv_sec = 3;

+ /* EINTR The system call was interrupted by a signal that was caught

+ * EINPROGRESS The socket is nonblocking and the connection cannot

+ * be completed immediately. */

+ while(n < 0 && (errno == EINTR || errno == EINPROGRESS))

+/* $Id: connecthostport.h,v 1.3 2012/09/27 15:42:10 nanard Exp $ */

+ * Copyright (c) 2010-2012 Thomas Bernard

+#ifndef CONNECTHOSTPORT_H_INCLUDED

+#define CONNECTHOSTPORT_H_INCLUDED

+int connecthostport(const char * host, unsigned short port,

+ unsigned int scope_id);

+#ifndef DECLSPEC_H_INCLUDED

+#define DECLSPEC_H_INCLUDED

+#if defined(_WIN32) && !defined(STATICLIB)

+/* $Id: igd_desc_parse.c,v 1.17 2015/09/15 13:30:04 nanard Exp $ */

+ * Copyright (c) 2005-2015 Thomas Bernard

+ if(l >= MINIUPNPC_URL_MAXSIZE)

+ l = MINIUPNPC_URL_MAXSIZE-1;

+ memcpy(datas->cureltname, name, l);

+#define COMPARE(str, cstr) (0==memcmp(str, cstr, sizeof(cstr) - 1))

+

+ if(COMPARE(datas->tmp.servicetype,

+ "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:")) {

+ } else if(COMPARE(datas->tmp.servicetype,

+ "urn:schemas-upnp-org:service:WANIPv6FirewallControl:")) {

+ } else if(COMPARE(datas->tmp.servicetype,

+ "urn:schemas-upnp-org:service:WANIPConnection:")

+ || COMPARE(datas->tmp.servicetype,

+ "urn:schemas-upnp-org:service:WANPPPConnection:") ) {

+#ifdef DEBUG

+#endif /* DEBUG */

+/* $Id: igd_desc_parse.h,v 1.12 2014/11/17 17:19:13 nanard Exp $ */

+ * Copyright (c) 2005-2014 Thomas Bernard

+#ifndef IGD_DESC_PARSE_H_INCLUDED

+#define IGD_DESC_PARSE_H_INCLUDED

+#ifdef DEBUG

+#endif /* DEBUG */

+#endif /* IGD_DESC_PARSE_H_INCLUDED */

+/* $Id: minisoap.c,v 1.25 2017/04/21 10:03:24 nanard Exp $ */

+ * Copyright (c) 2005-2015 Thomas Bernard

+#ifdef _WIN32

+#ifdef _WIN32

+#define PRINT_SOCKET_ERROR(x) fprintf(stderr, "Socket error: %s, %d\n", x, WSAGetLastError());

+ /* TODO: AVOID MALLOC, we could use writev() for that */

+ return -1;

+#ifdef _WIN32

+ "User-Agent: " OS_STRING ", " UPNP_VERSION_STRING ", MiniUPnPc/" MINIUPNPC_VERSION_STRING "\r\n"

+ if ((unsigned int)headerssize >= sizeof(headerbuf))

+ return -1;

+/* $Id: minisoap.h,v 1.5 2012/09/27 15:42:10 nanard Exp $ */

+#ifndef MINISOAP_H_INCLUDED

+#define MINISOAP_H_INCLUDED

+/* $Id: minissdpc.c,v 1.34 2017/04/21 10:06:38 nanard Exp $ */

+/* vim: tabstop=4 shiftwidth=4 noexpandtab

+ * Project : miniupnp

+ * Web : http://miniupnp.free.fr/

+ * copyright (c) 2005-2017 Thomas Bernard

+#if defined (__NetBSD__)

+#include <net/if.h>

+#if defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__)

+#ifdef _WIN32

+#include <iphlpapi.h>

+#define snprintf _snprintf

+#if !defined(_MSC_VER)

+#else /* !defined(_MSC_VER) */

+typedef unsigned short uint16_t;

+#endif /* !defined(_MSC_VER) */

+#ifndef strncasecmp

+#if defined(_MSC_VER) && (_MSC_VER >= 1400)

+#define strncasecmp _memicmp

+#else /* defined(_MSC_VER) && (_MSC_VER >= 1400) */

+#define strncasecmp memicmp

+#endif /* defined(_MSC_VER) && (_MSC_VER >= 1400) */

+#endif /* #ifndef strncasecmp */

+#endif /* _WIN32 */

+#endif /* defined(__amigaos__) || defined(__amigaos4__) */

+#endif /* defined(__amigaos__) */

+#else /* defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__) */

+#include <strings.h>

+#include <unistd.h>

+#include <sys/param.h>

+#include <sys/time.h>

+#include <netinet/in.h>

+#include <arpa/inet.h>

+#include <netdb.h>

+#include <net/if.h>

+#define closesocket close

+#endif

+

+#ifdef _WIN32

+#define PRINT_SOCKET_ERROR(x) fprintf(stderr, "Socket error: %s, %d\n", x, WSAGetLastError());

+#else

+#define PRINT_SOCKET_ERROR(x) perror(x)

+#endif

+

+#if !defined(__DragonFly__) && !defined(__OpenBSD__) && !defined(__NetBSD__) && !defined(__APPLE__) && !defined(_WIN32) && !defined(__CYGWIN__) && !defined(__sun) && !defined(__GNU__) && !defined(__FreeBSD_kernel__)

+#define HAS_IP_MREQN

+#endif

+

+#if !defined(HAS_IP_MREQN) && !defined(_WIN32)

+#include <sys/ioctl.h>

+#if defined(__sun)

+#include <sys/sockio.h>

+#endif

+#endif

+

+#if defined(HAS_IP_MREQN) && defined(NEED_STRUCT_IP_MREQN)

+/* Several versions of glibc don't define this structure,

+ * define it here and compile with CFLAGS NEED_STRUCT_IP_MREQN */

+struct ip_mreqn

+{

+ struct in_addr imr_multiaddr; /* IP multicast address of group */

+ struct in_addr imr_address; /* local IP address of interface */

+ int imr_ifindex; /* Interface index */

+};

+#endif

+

+#if defined(__amigaos__) || defined(__amigaos4__)

+/* Amiga OS specific stuff */

+#define TIMEVAL struct timeval

+#include "receivedata.h"

+

+#if !(defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__))

+getDevicesFromMiniSSDPD(const char * devtype, const char * socketpath, int * error)

+ int s;

+ int res;

+

+ s = connectToMiniSSDPD(socketpath);

+ if (s < 0) {

+ if (error)

+ *error = s;

+ return NULL;

+ }

+ res = requestDevicesFromMiniSSDPD(s, devtype);

+ if (res < 0) {

+ if (error)

+ *error = res;

+ } else {

+ devlist = receiveDevicesFromMiniSSDPD(s, error);

+ }

+ disconnectFromMiniSSDPD(s);

+ return devlist;

+}

+

+/* macros used to read from unix socket */

+#define READ_BYTE_BUFFER(c) \

+ if((int)bufferindex >= n) { \

+ n = read(s, buffer, sizeof(buffer)); \

+ if(n<=0) break; \

+ bufferindex = 0; \

+ } \

+ c = buffer[bufferindex++];

+

+#ifndef MIN

+#define MIN(a, b) (((a) < (b)) ? (a) : (b))

+#endif /* MIN */

+

+#define READ_COPY_BUFFER(dst, len) \

+ for(l = len, p = (unsigned char *)dst; l > 0; ) { \

+ unsigned int lcopy; \

+ if((int)bufferindex >= n) { \

+ n = read(s, buffer, sizeof(buffer)); \

+ if(n<=0) break; \

+ bufferindex = 0; \

+ } \

+ lcopy = MIN(l, (n - bufferindex)); \

+ memcpy(p, buffer + bufferindex, lcopy); \

+ l -= lcopy; \

+ p += lcopy; \

+ bufferindex += lcopy; \

+ }

+

+#define READ_DISCARD_BUFFER(len) \

+ for(l = len; l > 0; ) { \

+ unsigned int lcopy; \

+ if(bufferindex >= n) { \

+ n = read(s, buffer, sizeof(buffer)); \

+ if(n<=0) break; \

+ bufferindex = 0; \

+ } \

+ lcopy = MIN(l, (n - bufferindex)); \

+ l -= lcopy; \

+ bufferindex += lcopy; \

+ }

+

+int

+connectToMiniSSDPD(const char * socketpath)

+{

+#if defined(MINIUPNPC_SET_SOCKET_TIMEOUT) && !defined(__sun)

+ struct timeval timeout;

+#endif /* #ifdef MINIUPNPC_SET_SOCKET_TIMEOUT */

+ return MINISSDPC_SOCKET_ERROR;

+#if defined(MINIUPNPC_SET_SOCKET_TIMEOUT) && !defined(__sun)

+ /* setting a 3 seconds timeout */

+ /* not supported for AF_UNIX sockets under Solaris */

+ timeout.tv_sec = 3;

+ timeout.tv_usec = 0;

+ if(setsockopt(s, SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(struct timeval)) < 0)

+ {

+ perror("setsockopt SO_RCVTIMEO unix");

+ }

+ timeout.tv_sec = 3;

+ timeout.tv_usec = 0;

+ if(setsockopt(s, SOL_SOCKET, SO_SNDTIMEO, &timeout, sizeof(struct timeval)) < 0)

+ {

+ perror("setsockopt SO_SNDTIMEO unix");

+ }

+#endif /* #ifdef MINIUPNPC_SET_SOCKET_TIMEOUT */

+ if(!socketpath)

+ socketpath = "/var/run/minissdpd.sock";

+ memset(&addr, 0, sizeof(addr));

+ return MINISSDPC_SOCKET_ERROR;

+ return s;

+}

+

+int

+disconnectFromMiniSSDPD(int s)

+{

+ if (close(s) < 0)

+ return MINISSDPC_SOCKET_ERROR;

+ return MINISSDPC_SUCCESS;

+}

+

+int

+requestDevicesFromMiniSSDPD(int s, const char * devtype)

+{

+ unsigned char buffer[256];

+ unsigned char * p;

+ unsigned int stsize, l;

+

+ if(stsize == 8 && 0 == memcmp(devtype, "ssdp:all", 8))

+ {

+ buffer[0] = 3; /* request type 3 : everything */

+ }

+ else

+ {

+ buffer[0] = 1; /* request type 1 : request devices/services by type */

+ }

+#ifdef DEBUG

+ fprintf(stderr, "devtype is too long ! stsize=%u sizeof(buffer)=%u\n",

+ stsize, (unsigned)sizeof(buffer));

+#endif /* DEBUG */

+ return MINISSDPC_INVALID_INPUT;

+ return MINISSDPC_SOCKET_ERROR;

+ return MINISSDPC_SUCCESS;

+}

+

+struct UPNPDev *

+receiveDevicesFromMiniSSDPD(int s, int * error)

+{

+ struct UPNPDev * tmp;

+ struct UPNPDev * devlist = NULL;

+ unsigned char buffer[256];

+ ssize_t n;

+ unsigned char * p;

+ unsigned char * url;

+ unsigned char * st;

+ unsigned int bufferindex;

+ unsigned int i, ndev;

+ unsigned int urlsize, stsize, usnsize, l;

+

+ if (error)

+ *error = MINISSDPC_SOCKET_ERROR;

+ ndev = buffer[0];

+ bufferindex = 1;

+ for(i = 0; i < ndev; i++)

+ DECODELENGTH_READ(urlsize, READ_BYTE_BUFFER);

+ if(n<=0) {

+ if (error)

+ *error = MINISSDPC_INVALID_SERVER_REPLY;

+ return devlist;

+ }

+#ifdef DEBUG

+ printf(" urlsize=%u", urlsize);

+#endif /* DEBUG */

+ url = malloc(urlsize);

+ if(url == NULL) {

+ if (error)

+ *error = MINISSDPC_MEMORY_ERROR;

+ return devlist;

+ }

+ READ_COPY_BUFFER(url, urlsize);

+ if(n<=0) {

+ if (error)

+ *error = MINISSDPC_INVALID_SERVER_REPLY;

+ goto free_url_and_return;

+ }

+ DECODELENGTH_READ(stsize, READ_BYTE_BUFFER);

+ if(n<=0) {

+ if (error)

+ *error = MINISSDPC_INVALID_SERVER_REPLY;

+ goto free_url_and_return;

+ }

+#ifdef DEBUG

+ printf(" stsize=%u", stsize);

+#endif /* DEBUG */

+ st = malloc(stsize);

+ if (st == NULL) {

+ if (error)

+ *error = MINISSDPC_MEMORY_ERROR;

+ goto free_url_and_return;

+ }

+ READ_COPY_BUFFER(st, stsize);

+ if(n<=0) {

+ if (error)

+ *error = MINISSDPC_INVALID_SERVER_REPLY;

+ goto free_url_and_st_and_return;

+ }

+ DECODELENGTH_READ(usnsize, READ_BYTE_BUFFER);

+ if(n<=0) {

+ if (error)

+ *error = MINISSDPC_INVALID_SERVER_REPLY;

+ goto free_url_and_st_and_return;

+ }

+#ifdef DEBUG

+ printf(" usnsize=%u\n", usnsize);

+#endif /* DEBUG */

+ tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize+usnsize);

+ if(tmp == NULL) {

+ if (error)

+ *error = MINISSDPC_MEMORY_ERROR;

+ goto free_url_and_st_and_return;

+ }

+ memcpy(tmp->st, st, stsize);

+ free(url);

+ free(st);

+ url = NULL;

+ st = NULL;

+ tmp->usn = tmp->buffer + 1 + urlsize + 1 + stsize;

+ READ_COPY_BUFFER(tmp->usn, usnsize);

+ if(n<=0) {

+ if (error)

+ *error = MINISSDPC_INVALID_SERVER_REPLY;

+ goto free_tmp_and_return;

+ }

+ tmp->buffer[urlsize+1+stsize+1+usnsize] = '\0';

+ tmp->scope_id = 0; /* default value. scope_id is not available with MiniSSDPd */

+ }

+ if (error)

+ *error = MINISSDPC_SUCCESS;

+ return devlist;

+

+free_url_and_st_and_return:

+ free(st);

+free_url_and_return:

+ free(url);

+ return devlist;

+

+free_tmp_and_return:

+ free(tmp);

+ return devlist;

+}

+

+#endif /* !(defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__)) */

+

+/* parseMSEARCHReply()

+ * the last 4 arguments are filled during the parsing :

+ * - location/locationsize : "location:" field of the SSDP reply packet

+ * - st/stsize : "st:" field of the SSDP reply packet.

+ * The strings are NOT null terminated */

+static void

+parseMSEARCHReply(const char * reply, int size,

+ const char * * location, int * locationsize,

+ const char * * st, int * stsize,

+ const char * * usn, int * usnsize)

+{

+ int a, b, i;

+ i = 0;

+ a = i; /* start of the line */

+ b = 0; /* end of the "header" (position of the colon) */

+ while(i<size)

+ {

+ switch(reply[i])

+ {

+ case ':':

+ if(b==0)

+ {

+ b = i; /* end of the "header" */

+ /*for(j=a; j<b; j++)

+ {

+ putchar(reply[j]);

+ }

+ */

+ }

+ break;

+ case '\x0a':

+ case '\x0d':

+ if(b!=0)

+ {

+ /*for(j=b+1; j<i; j++)

+ {

+ putchar(reply[j]);

+ }

+ putchar('\n');*/

+ /* skip the colon and white spaces */

+ do { b++; } while(reply[b]==' ');

+ if(0==strncasecmp(reply+a, "location", 8))

+ {

+ *location = reply+b;

+ *locationsize = i-b;

+ }

+ else if(0==strncasecmp(reply+a, "st", 2))

+ {

+ *st = reply+b;

+ *stsize = i-b;

+ }

+ else if(0==strncasecmp(reply+a, "usn", 3))

+ {

+ *usn = reply+b;

+ *usnsize = i-b;

+ }

+ b = 0;

+ }

+ a = i+1;

+ break;

+ default:

+ break;

+ }

+ i++;

+ }

+}

+

+/* port upnp discover : SSDP protocol */

+#define SSDP_PORT 1900

+#define XSTR(s) STR(s)

+#define STR(s) #s

+#define UPNP_MCAST_ADDR "239.255.255.250"

+/* for IPv6 */

+#define UPNP_MCAST_LL_ADDR "FF02::C" /* link-local */

+#define UPNP_MCAST_SL_ADDR "FF05::C" /* site-local */

+

+/* direct discovery if minissdpd responses are not sufficient */

+/* ssdpDiscoverDevices() :

+ * return a chained list of all devices found or NULL if

+ * no devices was found.

+ * It is up to the caller to free the chained list

+ * delay is in millisecond (poll).

+ * UDA v1.1 says :

+ * The TTL for the IP packet SHOULD default to 2 and

+ * SHOULD be configurable. */

+struct UPNPDev *

+ssdpDiscoverDevices(const char * const deviceTypes[],

+ int delay, const char * multicastif,

+ int localport,

+ int ipv6, unsigned char ttl,

+ int * error,

+ int searchalltypes)

+{

+ struct UPNPDev * tmp;

+ struct UPNPDev * devlist = 0;

+ unsigned int scope_id = 0;

+ int opt = 1;

+ static const char MSearchMsgFmt[] =

+ "M-SEARCH * HTTP/1.1\r\n"

+ "HOST: %s:" XSTR(SSDP_PORT) "\r\n"

+ "ST: %s\r\n"

+ "MAN: \"ssdp:discover\"\r\n"

+ "MX: %u\r\n"

+ "\r\n";

+ int deviceIndex;

+ char bufr[1536]; /* reception and emission buffer */

+ int sudp;

+ int n;

+ struct sockaddr_storage sockudp_r;

+ unsigned int mx;

+#ifdef NO_GETADDRINFO

+ struct sockaddr_storage sockudp_w;

+#else

+ int rv;

+ struct addrinfo hints, *servinfo, *p;

+#endif

+#ifdef _WIN32

+ MIB_IPFORWARDROW ip_forward;

+ unsigned long _ttl = (unsigned long)ttl;

+#endif

+ int linklocal = 1;

+ int sentok;

+

+ if(error)

+ *error = MINISSDPC_UNKNOWN_ERROR;

+

+ if(localport==UPNP_LOCAL_PORT_SAME)

+ localport = SSDP_PORT;

+

+#ifdef _WIN32

+ sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, IPPROTO_UDP);

+#else

+ sudp = socket(ipv6 ? PF_INET6 : PF_INET, SOCK_DGRAM, 0);

+#endif

+ if(sudp < 0)

+ {

+ if(error)

+ *error = MINISSDPC_SOCKET_ERROR;

+ PRINT_SOCKET_ERROR("socket");

+ return NULL;

+ }

+ /* reception */

+ memset(&sockudp_r, 0, sizeof(struct sockaddr_storage));

+ if(ipv6) {

+ struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_r;

+ p->sin6_family = AF_INET6;

+ if(localport > 0 && localport < 65536)

+ p->sin6_port = htons((unsigned short)localport);

+ p->sin6_addr = in6addr_any; /* in6addr_any is not available with MinGW32 3.4.2 */

+ } else {

+ struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_r;

+ p->sin_family = AF_INET;

+ if(localport > 0 && localport < 65536)

+ p->sin_port = htons((unsigned short)localport);

+ p->sin_addr.s_addr = INADDR_ANY;

+ }

+#ifdef _WIN32

+/* This code could help us to use the right Network interface for

+ * SSDP multicast traffic */

+/* Get IP associated with the index given in the ip_forward struct

+ * in order to give this ip to setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF) */

+ if(!ipv6

+ && (GetBestRoute(inet_addr("223.255.255.255"), 0, &ip_forward) == NO_ERROR)) {

+ DWORD dwRetVal = 0;

+ PMIB_IPADDRTABLE pIPAddrTable;

+ DWORD dwSize = 0;

+#ifdef DEBUG

+ IN_ADDR IPAddr;

+#endif

+ int i;

+#ifdef DEBUG

+ printf("ifIndex=%lu nextHop=%lx \n", ip_forward.dwForwardIfIndex, ip_forward.dwForwardNextHop);

+#endif

+ pIPAddrTable = (MIB_IPADDRTABLE *) malloc(sizeof (MIB_IPADDRTABLE));

+ if(pIPAddrTable) {

+ if (GetIpAddrTable(pIPAddrTable, &dwSize, 0) == ERROR_INSUFFICIENT_BUFFER) {

+ free(pIPAddrTable);

+ pIPAddrTable = (MIB_IPADDRTABLE *) malloc(dwSize);

+ }

+ }

+ if(pIPAddrTable) {

+ dwRetVal = GetIpAddrTable( pIPAddrTable, &dwSize, 0 );

+ if (dwRetVal == NO_ERROR) {

+#ifdef DEBUG

+ printf("\tNum Entries: %ld\n", pIPAddrTable->dwNumEntries);

+#endif

+ for (i=0; i < (int) pIPAddrTable->dwNumEntries; i++) {

+#ifdef DEBUG

+ printf("\n\tInterface Index[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwIndex);

+ IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwAddr;

+ printf("\tIP Address[%d]: \t%s\n", i, inet_ntoa(IPAddr) );

+ IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwMask;

+ printf("\tSubnet Mask[%d]: \t%s\n", i, inet_ntoa(IPAddr) );

+ IPAddr.S_un.S_addr = (u_long) pIPAddrTable->table[i].dwBCastAddr;

+ printf("\tBroadCast[%d]: \t%s (%ld)\n", i, inet_ntoa(IPAddr), pIPAddrTable->table[i].dwBCastAddr);

+ printf("\tReassembly size[%d]:\t%ld\n", i, pIPAddrTable->table[i].dwReasmSize);

+ printf("\tType and State[%d]:", i);

+ printf("\n");

+#endif

+ if (pIPAddrTable->table[i].dwIndex == ip_forward.dwForwardIfIndex) {

+ /* Set the address of this interface to be used */

+ struct in_addr mc_if;

+ memset(&mc_if, 0, sizeof(mc_if));

+ mc_if.s_addr = pIPAddrTable->table[i].dwAddr;

+ if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0) {

+ PRINT_SOCKET_ERROR("setsockopt");

+ }

+ ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = pIPAddrTable->table[i].dwAddr;

+#ifndef DEBUG

+ break;

+#endif

+ }

+ }

+ }

+ free(pIPAddrTable);

+ pIPAddrTable = NULL;

+ }

+ }

+#endif /* _WIN32 */

+

+#ifdef _WIN32

+ if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof (opt)) < 0)

+#else

+ if (setsockopt(sudp, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof (opt)) < 0)

+#endif

+ {

+ if(error)

+ *error = MINISSDPC_SOCKET_ERROR;

+ PRINT_SOCKET_ERROR("setsockopt(SO_REUSEADDR,...)");

+ return NULL;

+ }

+

+ if(ipv6) {

+ int mcastHops = ttl;

+ if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_HOPS, &mcastHops, sizeof(mcastHops)) < 0)

+ {

+ PRINT_SOCKET_ERROR("setsockopt(IPV6_MULTICAST_HOPS,...)");

+ }

+ } else {

+#ifdef _WIN32

+ if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_TTL, (const char *)&_ttl, sizeof(_ttl)) < 0)

+#else /* _WIN32 */

+ if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_TTL, &ttl, sizeof(ttl)) < 0)

+#endif /* _WIN32 */

+ {

+ /* not a fatal error */

+ PRINT_SOCKET_ERROR("setsockopt(IP_MULTICAST_TTL,...)");

+ }

+ }

+

+ if(multicastif)

+ {

+ if(ipv6) {

+#if !defined(_WIN32)

+ /* according to MSDN, if_nametoindex() is supported since

+ * MS Windows Vista and MS Windows Server 2008.

+ * http://msdn.microsoft.com/en-us/library/bb408409%28v=vs.85%29.aspx */

+ unsigned int ifindex = if_nametoindex(multicastif); /* eth0, etc. */

+ if(setsockopt(sudp, IPPROTO_IPV6, IPV6_MULTICAST_IF, &ifindex, sizeof(ifindex)) < 0)

+ {

+ PRINT_SOCKET_ERROR("setsockopt IPV6_MULTICAST_IF");

+ }

+#else

+#ifdef DEBUG

+ printf("Setting of multicast interface not supported in IPv6 under Windows.\n");

+#endif

+#endif

+ } else {

+ struct in_addr mc_if;

+ mc_if.s_addr = inet_addr(multicastif); /* ex: 192.168.x.x */

+ if(mc_if.s_addr != INADDR_NONE)

+ {

+ ((struct sockaddr_in *)&sockudp_r)->sin_addr.s_addr = mc_if.s_addr;

+ if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)

+ {

+ PRINT_SOCKET_ERROR("setsockopt IP_MULTICAST_IF");

+ }

+ } else {

+#ifdef HAS_IP_MREQN

+ /* was not an ip address, try with an interface name */

+ struct ip_mreqn reqn; /* only defined with -D_BSD_SOURCE or -D_GNU_SOURCE */

+ memset(&reqn, 0, sizeof(struct ip_mreqn));

+ reqn.imr_ifindex = if_nametoindex(multicastif);

+ if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&reqn, sizeof(reqn)) < 0)

+ {

+ PRINT_SOCKET_ERROR("setsockopt IP_MULTICAST_IF");

+ }

+#elif !defined(_WIN32)

+ struct ifreq ifr;

+ int ifrlen = sizeof(ifr);

+ strncpy(ifr.ifr_name, multicastif, IFNAMSIZ);

+ ifr.ifr_name[IFNAMSIZ-1] = '\0';

+ if(ioctl(sudp, SIOCGIFADDR, &ifr, &ifrlen) < 0)

+ {

+ PRINT_SOCKET_ERROR("ioctl(...SIOCGIFADDR...)");

+ }

+ mc_if.s_addr = ((struct sockaddr_in *)&ifr.ifr_addr)->sin_addr.s_addr;

+ if(setsockopt(sudp, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0)

+ {

+ PRINT_SOCKET_ERROR("setsockopt IP_MULTICAST_IF");

+ }

+#else /* _WIN32 */

+#ifdef DEBUG

+ printf("Setting of multicast interface not supported with interface name.\n");

+#endif

+#endif /* #ifdef HAS_IP_MREQN / !defined(_WIN32) */

+ }

+ }

+ }

+

+ /* Before sending the packed, we first "bind" in order to be able

+ * to receive the response */

+ if (bind(sudp, (const struct sockaddr *)&sockudp_r,

+ ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in)) != 0)

+ {

+ if(error)

+ *error = MINISSDPC_SOCKET_ERROR;

+ PRINT_SOCKET_ERROR("bind");

+ closesocket(sudp);

+ return NULL;

+ }

+

+ if(error)

+ *error = MINISSDPC_SUCCESS;

+ /* Calculating maximum response time in seconds */

+ mx = ((unsigned int)delay) / 1000u;

+ if(mx == 0) {

+ mx = 1;

+ delay = 1000;

+ }

+ /* receiving SSDP response packet */

+ for(deviceIndex = 0; deviceTypes[deviceIndex]; deviceIndex++) {

+ sentok = 0;

+ /* sending the SSDP M-SEARCH packet */

+ n = snprintf(bufr, sizeof(bufr),

+ MSearchMsgFmt,

+ ipv6 ?

+ (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" : "[" UPNP_MCAST_SL_ADDR "]")

+ : UPNP_MCAST_ADDR,

+ deviceTypes[deviceIndex], mx);

+ if ((unsigned int)n >= sizeof(bufr)) {

+ if(error)

+ *error = MINISSDPC_MEMORY_ERROR;

+ goto error;

+ }

+#ifdef DEBUG

+ /*printf("Sending %s", bufr);*/

+ printf("Sending M-SEARCH request to %s with ST: %s\n",

+ ipv6 ?

+ (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" : "[" UPNP_MCAST_SL_ADDR "]")

+ : UPNP_MCAST_ADDR,

+ deviceTypes[deviceIndex]);

+#endif

+#ifdef NO_GETADDRINFO

+ /* the following code is not using getaddrinfo */

+ /* emission */

+ memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));

+ if(ipv6) {

+ struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;

+ p->sin6_family = AF_INET6;

+ p->sin6_port = htons(SSDP_PORT);

+ inet_pton(AF_INET6,

+ linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,

+ &(p->sin6_addr));

+ } else {

+ struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;

+ p->sin_family = AF_INET;

+ p->sin_port = htons(SSDP_PORT);

+ p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);

+ }

+ n = sendto(sudp, bufr, n, 0, &sockudp_w,

+ ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));

+ if (n < 0) {

+ if(error)

+ *error = MINISSDPC_SOCKET_ERROR;

+ PRINT_SOCKET_ERROR("sendto");

+ } else {

+ sentok = 1;

+ }

+#else /* #ifdef NO_GETADDRINFO */

+ memset(&hints, 0, sizeof(hints));

+ hints.ai_family = AF_UNSPEC; /* AF_INET6 or AF_INET */

+ hints.ai_socktype = SOCK_DGRAM;

+ /*hints.ai_flags = */

+ if ((rv = getaddrinfo(ipv6

+ ? (linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR)

+ : UPNP_MCAST_ADDR,

+ XSTR(SSDP_PORT), &hints, &servinfo)) != 0) {

+ if(error)

+ *error = MINISSDPC_SOCKET_ERROR;

+#ifdef _WIN32

+ fprintf(stderr, "getaddrinfo() failed: %d\n", rv);

+#else

+ fprintf(stderr, "getaddrinfo: %s\n", gai_strerror(rv));

+#endif

+ }

+ for(p = servinfo; p; p = p->ai_next) {

+ n = sendto(sudp, bufr, n, 0, p->ai_addr, p->ai_addrlen);

+ if (n < 0) {

+#ifdef DEBUG

+ char hbuf[NI_MAXHOST], sbuf[NI_MAXSERV];

+ if (getnameinfo(p->ai_addr, p->ai_addrlen, hbuf, sizeof(hbuf), sbuf,

+ sizeof(sbuf), NI_NUMERICHOST | NI_NUMERICSERV) == 0) {

+ fprintf(stderr, "host:%s port:%s\n", hbuf, sbuf);

+ }

+#endif

+ PRINT_SOCKET_ERROR("sendto");

+ continue;

+ } else {

+ sentok = 1;

+ }

+ }

+ freeaddrinfo(servinfo);

+ if(!sentok) {

+ if(error)

+ *error = MINISSDPC_SOCKET_ERROR;

+ }

+#endif /* #ifdef NO_GETADDRINFO */

+ /* Waiting for SSDP REPLY packet to M-SEARCH

+ * if searchalltypes is set, enter the loop only

+ * when the last deviceType is reached */

+ if((sentok && !searchalltypes) || !deviceTypes[deviceIndex + 1]) do {

+ n = receivedata(sudp, bufr, sizeof(bufr), delay, &scope_id);

+ if (n < 0) {

+ /* error */

+ if(error)

+ *error = MINISSDPC_SOCKET_ERROR;

+ goto error;

+ } else if (n == 0) {

+ /* no data or Time Out */

+#ifdef DEBUG

+ printf("NODATA or TIMEOUT\n");

+#endif /* DEBUG */

+ if (devlist && !searchalltypes) {

+ /* found some devices, stop now*/

+ if(error)

+ *error = MINISSDPC_SUCCESS;

+ goto error;

+ }

+ } else {

+ const char * descURL=NULL;

+ int urlsize=0;

+ const char * st=NULL;

+ int stsize=0;

+ const char * usn=NULL;

+ int usnsize=0;

+ parseMSEARCHReply(bufr, n, &descURL, &urlsize, &st, &stsize, &usn, &usnsize);

+ if(st&&descURL) {

+#ifdef DEBUG

+ printf("M-SEARCH Reply:\n ST: %.*s\n USN: %.*s\n Location: %.*s\n",

+ stsize, st, usnsize, (usn?usn:""), urlsize, descURL);

+#endif /* DEBUG */

+ for(tmp=devlist; tmp; tmp = tmp->pNext) {

+ if(memcmp(tmp->descURL, descURL, urlsize) == 0 &&

+ tmp->descURL[urlsize] == '\0' &&

+ memcmp(tmp->st, st, stsize) == 0 &&

+ tmp->st[stsize] == '\0' &&

+ (usnsize == 0 || memcmp(tmp->usn, usn, usnsize) == 0) &&

+ tmp->usn[usnsize] == '\0')

+ break;

+ }

+ /* at the exit of the loop above, tmp is null if

+ * no duplicate device was found */

+ if(tmp)

+ continue;

+ tmp = (struct UPNPDev *)malloc(sizeof(struct UPNPDev)+urlsize+stsize+usnsize);

+ if(!tmp) {

+ /* memory allocation error */

+ if(error)

+ *error = MINISSDPC_MEMORY_ERROR;

+ goto error;

+ }

+ tmp->pNext = devlist;

+ tmp->descURL = tmp->buffer;

+ tmp->st = tmp->buffer + 1 + urlsize;

+ tmp->usn = tmp->st + 1 + stsize;

+ memcpy(tmp->buffer, descURL, urlsize);

+ tmp->buffer[urlsize] = '\0';

+ memcpy(tmp->st, st, stsize);

+ tmp->buffer[urlsize+1+stsize] = '\0';

+ if(usn != NULL)

+ memcpy(tmp->usn, usn, usnsize);

+ tmp->buffer[urlsize+1+stsize+1+usnsize] = '\0';

+ tmp->scope_id = scope_id;

+ devlist = tmp;

+ }

+ }

+ } while(n > 0);

+ if(ipv6) {

+ /* switch linklocal flag */

+ if(linklocal) {

+ linklocal = 0;

+ --deviceIndex;

+ } else {

+ linklocal = 1;

+ }

+ }

+error:

+ closesocket(sudp);

+/* $Id: minissdpc.h,v 1.7 2015/10/08 16:15:47 nanard Exp $ */

+ * Copyright (c) 2005-2015 Thomas Bernard

+#ifndef MINISSDPC_H_INCLUDED

+#define MINISSDPC_H_INCLUDED

+#include "miniupnpc_declspec.h"

+#include "upnpdev.h"

+

+/* error codes : */

+#define MINISSDPC_SUCCESS (0)

+#define MINISSDPC_UNKNOWN_ERROR (-1)

+#define MINISSDPC_SOCKET_ERROR (-101)

+#define MINISSDPC_MEMORY_ERROR (-102)

+#define MINISSDPC_INVALID_INPUT (-103)

+#define MINISSDPC_INVALID_SERVER_REPLY (-104)

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#if !(defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__))

+

+MINIUPNP_LIBSPEC struct UPNPDev *

+getDevicesFromMiniSSDPD(const char * devtype, const char * socketpath, int * error);

+

+MINIUPNP_LIBSPEC int

+connectToMiniSSDPD(const char * socketpath);

+

+MINIUPNP_LIBSPEC int

+disconnectFromMiniSSDPD(int fd);

+

+MINIUPNP_LIBSPEC int

+requestDevicesFromMiniSSDPD(int fd, const char * devtype);

+

+MINIUPNP_LIBSPEC struct UPNPDev *

+receiveDevicesFromMiniSSDPD(int fd, int * error);

+

+#endif /* !(defined(_WIN32) || defined(__amigaos__) || defined(__amigaos4__)) */

+

+MINIUPNP_LIBSPEC struct UPNPDev *

+ssdpDiscoverDevices(const char * const deviceTypes[],

+ int delay, const char * multicastif,

+ int localport,

+ int ipv6, unsigned char ttl,

+ int * error,

+ int searchalltypes);

+

+#ifdef __cplusplus

+}

+#endif

+/* $Id: miniupnpc.c,v 1.149 2016/02/09 09:50:46 nanard Exp $ */

+/* vim: tabstop=4 shiftwidth=4 noexpandtab

+ * Project : miniupnp

+ * Web : http://miniupnp.free.fr/

+ * copyright (c) 2005-2016 Thomas Bernard

+#ifdef _WIN32

+#define strdup _strdup

+#else /* #ifdef _WIN32 */

+#endif /* #else _WIN32 */

+#ifdef __GNU__

+#define MAXHOSTNAMELEN 64

+

+/* compare the begining of a string with a constant string */

+#define COMPARE(str, cstr) (0==memcmp(str, cstr, sizeof(cstr) - 1))

+

+#ifndef MAXHOSTNAMELEN

+#define MAXHOSTNAMELEN 64

+/* check if an ip address is a private (LAN) address

+ * see https://tools.ietf.org/html/rfc1918 */

+static int is_rfc1918addr(const char * addr)

+{

+ /* 192.168.0.0 - 192.168.255.255 (192.168/16 prefix) */

+ if(COMPARE(addr, "192.168."))

+ return 1;

+ /* 10.0.0.0 - 10.255.255.255 (10/8 prefix) */

+ if(COMPARE(addr, "10."))

+ return 1;

+ /* 172.16.0.0 - 172.31.255.255 (172.16/12 prefix) */

+ if(COMPARE(addr, "172.")) {

+ int i = atoi(addr + 4);

+ if((16 <= i) && (i <= 31))

+ return 1;

+ }

+ return 0;

+}

+

+MINIUPNP_LIBSPEC void parserootdesc(const char * buffer, int bufsize, struct IGDdatas * data)

+ int soapbodylen;

+ int n;

+ int status_code;

+ soapbodylen = snprintf(soapbody, sizeof(soapbody),

+ "<?xml version=\"1.0\"?>\r\n"

+ "<" SOAPPREFIX ":Envelope "

+ "\r\n", action, service, action);

+ if ((unsigned int)soapbodylen >= sizeof(soapbody))

+ return NULL;

+ const char * const pend = soapbody + sizeof(soapbody);

+ "<" SOAPPREFIX ":Envelope "

+ if ((unsigned int)soapbodylen >= sizeof(soapbody))

+ return NULL;

+ if(p >= pend) /* check for space to write next byte */

+

+ while(p < pend && *pe)

+

+ if(p >= pend) /* check for space to write next byte */

+ return NULL;

+

+ while(p < pend && *pv)

+

+ if((p+2) > pend) /* check for space to write next 2 bytes */

+ return NULL;

+

+ while(p < pend && *pe)

+

+ if(p >= pend) /* check for space to write next byte */

+ return NULL;

+

+ if((p+4) > pend) /* check for space to write next 4 bytes */

+ return NULL;

+

+ while(p < pend && *pe)

+

+ pend - p);

+ if(soapbody[sizeof(soapbody)-1]) /* strncpy pads buffer with 0s, so if it doesn't end in 0, could not fit full string */

+ return NULL;

+ if(!parseURL(url, hostname, &port, &path, NULL)) return NULL;

+ if(s < 0) {

+ s = connecthostport(hostname, port, 0);

+ if(s < 0) {

+ /* failed to connect */

+ buf = getHTTPResponse(s, bufsize, &status_code);

+ printf("HTTP %d SOAP Response :\n%.*s\n", status_code, *bufsize, buf);

+ }

+ else

+ {

+ printf("HTTP %d, empty SOAP response. size=%d\n", status_code, *bufsize);

+#if 1

+#else

+#endif

+/* upnpDiscoverDevices() :

+ * delay is in millisecond (poll).

+ * UDA v1.1 says :

+ * The TTL for the IP packet SHOULD default to 2 and

+ * SHOULD be configurable. */

+MINIUPNP_LIBSPEC struct UPNPDev *

+upnpDiscoverDevices(const char * const deviceTypes[],

+ int delay, const char * multicastif,

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+ int * error,

+ int searchalltypes)

+#if !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__)

+ int deviceIndex;

+#endif /* !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__) */

+#if !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__)

+ for(deviceIndex = 0; deviceTypes[deviceIndex]; deviceIndex++) {

+ struct UPNPDev * minissdpd_devlist;

+ int only_rootdevice = 1;

+ minissdpd_devlist = getDevicesFromMiniSSDPD(deviceTypes[deviceIndex],

+ minissdpdsock, 0);

+ if(minissdpd_devlist) {

+ printf("returned by MiniSSDPD: %s\t%s\n",

+ minissdpd_devlist->st, minissdpd_devlist->descURL);

+#endif /* DEBUG */

+ if(!strstr(minissdpd_devlist->st, "rootdevice"))

+ only_rootdevice = 0;

+ for(tmp = minissdpd_devlist; tmp->pNext != NULL; tmp = tmp->pNext) {

+ printf("returned by MiniSSDPD: %s\t%s\n",

+ tmp->pNext->st, tmp->pNext->descURL);

+#endif /* DEBUG */

+ if(!strstr(tmp->st, "rootdevice"))

+ only_rootdevice = 0;

+ tmp->pNext = devlist;

+ devlist = minissdpd_devlist;

+ if(!searchalltypes && !only_rootdevice)

+ break;

+ for(tmp = devlist; tmp != NULL; tmp = tmp->pNext) {

+ /* We return what we have found if it was not only a rootdevice */

+ if(!strstr(tmp->st, "rootdevice")) {

+ if(error)

+ *error = UPNPDISCOVER_SUCCESS;

+ return devlist;

+#endif /* !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__) */

+ /* direct discovery if minissdpd responses are not sufficient */

+ struct UPNPDev * discovered_devlist;

+ discovered_devlist = ssdpDiscoverDevices(deviceTypes, delay, multicastif, localport,

+ ipv6, ttl, error, searchalltypes);

+ if(devlist == NULL)

+ devlist = discovered_devlist;

+ else {

+ for(tmp = devlist; tmp->pNext != NULL; tmp = tmp->pNext);

+ tmp->pNext = discovered_devlist;

+/* upnpDiscover() Discover IGD device */

+MINIUPNP_LIBSPEC struct UPNPDev *

+upnpDiscover(int delay, const char * multicastif,

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+ int * error)

+ static const char * const deviceList[] = {

+#if 0

+ "urn:schemas-upnp-org:device:InternetGatewayDevice:2",

+ "urn:schemas-upnp-org:service:WANIPConnection:2",

+#endif

+ "urn:schemas-upnp-org:device:InternetGatewayDevice:1",

+ "urn:schemas-upnp-org:service:WANIPConnection:1",

+ "urn:schemas-upnp-org:service:WANPPPConnection:1",

+ "upnp:rootdevice",

+ /*"ssdp:all",*/

+ 0

+ };

+ return upnpDiscoverDevices(deviceList,

+ delay, multicastif, minissdpdsock, localport,

+ ipv6, ttl, error, 0);

+/* upnpDiscoverAll() Discover all UPnP devices */

+MINIUPNP_LIBSPEC struct UPNPDev *

+upnpDiscoverAll(int delay, const char * multicastif,

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+ int * error)

+ static const char * const deviceList[] = {

+ /*"upnp:rootdevice",*/

+ "ssdp:all",

+ 0

+ };

+ return upnpDiscoverDevices(deviceList,

+ delay, multicastif, minissdpdsock, localport,

+ ipv6, ttl, error, 0);

+}

+

+/* upnpDiscoverDevice() Discover a specific device */

+MINIUPNP_LIBSPEC struct UPNPDev *

+upnpDiscoverDevice(const char * device, int delay, const char * multicastif,

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+ int * error)

+{

+ const char * const deviceList[] = {

+ device,

+ 0

+ };

+ return upnpDiscoverDevices(deviceList,

+ delay, multicastif, minissdpdsock, localport,

+ ipv6, ttl, error, 0);

+}

+

+static char *

+build_absolute_url(const char * baseurl, const char * descURL,

+ const char * url, unsigned int scope_id)

+{

+ int l, n;

+ char * s;

+ const char * base;

+ char * p;

+#if defined(IF_NAMESIZE) && !defined(_WIN32)

+ char ifname[IF_NAMESIZE];

+#else /* defined(IF_NAMESIZE) && !defined(_WIN32) */

+ char scope_str[8];

+#endif /* defined(IF_NAMESIZE) && !defined(_WIN32) */

+

+ if( (url[0] == 'h')

+ &&(url[1] == 't')

+ &&(url[2] == 't')

+ &&(url[3] == 'p')

+ &&(url[4] == ':')

+ &&(url[5] == '/')

+ &&(url[6] == '/'))

+ return strdup(url);

+ base = (baseurl[0] == '\0') ? descURL : baseurl;

+ n = strlen(base);

+ if(n > 7) {

+ p = strchr(base + 7, '/');

+ if(p)

+ n = p - base;

+ l = n + strlen(url) + 1;

+ if(url[0] != '/')

+ l++;

+ if(scope_id != 0) {

+#if defined(IF_NAMESIZE) && !defined(_WIN32)

+ if(if_indextoname(scope_id, ifname)) {

+ l += 3 + strlen(ifname); /* 3 == strlen(%25) */

+ }

+#else /* defined(IF_NAMESIZE) && !defined(_WIN32) */

+ /* under windows, scope is numerical */

+ l += 3 + snprintf(scope_str, sizeof(scope_str), "%u", scope_id);

+#endif /* defined(IF_NAMESIZE) && !defined(_WIN32) */

+ }

+ s = malloc(l);

+ if(s == NULL) return NULL;

+ memcpy(s, base, n);

+ if(scope_id != 0) {

+ s[n] = '\0';

+ if(0 == memcmp(s, "http://[fe80:", 13)) {

+ /* this is a linklocal IPv6 address */

+ p = strchr(s, ']');

+ if(p) {

+ /* insert %25<scope> into URL */

+#if defined(IF_NAMESIZE) && !defined(_WIN32)

+ memmove(p + 3 + strlen(ifname), p, strlen(p) + 1);

+ memcpy(p, "%25", 3);

+ memcpy(p + 3, ifname, strlen(ifname));

+ n += 3 + strlen(ifname);

+#else /* defined(IF_NAMESIZE) && !defined(_WIN32) */

+ memmove(p + 3 + strlen(scope_str), p, strlen(p) + 1);

+ memcpy(p, "%25", 3);

+ memcpy(p + 3, scope_str, strlen(scope_str));

+ n += 3 + strlen(scope_str);

+#endif /* defined(IF_NAMESIZE) && !defined(_WIN32) */

+ }

+ }

+ if(url[0] != '/')

+ s[n++] = '/';

+ memcpy(s + n, url, l - n);

+ return s;

+MINIUPNP_LIBSPEC void

+GetUPNPUrls(struct UPNPUrls * urls, struct IGDdatas * data,

+ const char * descURL, unsigned int scope_id)

+ /* strdup descURL */

+ urls->rootdescURL = strdup(descURL);

+

+ /* get description of WANIPConnection */

+ urls->ipcondescURL = build_absolute_url(data->urlbase, descURL,

+ data->first.scpdurl, scope_id);

+ urls->controlURL = build_absolute_url(data->urlbase, descURL,

+ data->first.controlurl, scope_id);

+ urls->controlURL_CIF = build_absolute_url(data->urlbase, descURL,

+ data->CIF.controlurl, scope_id);

+ urls->controlURL_6FC = build_absolute_url(data->urlbase, descURL,

+ data->IPv6FC.controlurl, scope_id);

+ printf("urls->ipcondescURL='%s'\n", urls->ipcondescURL);

+ printf("urls->controlURL='%s'\n", urls->controlURL);

+ printf("urls->controlURL_CIF='%s'\n", urls->controlURL_CIF);

+ printf("urls->controlURL_6FC='%s'\n", urls->controlURL_6FC);

+MINIUPNP_LIBSPEC void

+ free(urls->rootdescURL);

+ urls->rootdescURL = 0;

+ else if(0 == strcmp("Up", status)) /* Also accept "Up" */

+ return 1;

+ * -1 = Internal error

+ * In any positive non zero return case, the urls and data structures

+ * passed as parameters are set. Dont forget to call FreeUPNPUrls(urls) to

+MINIUPNP_LIBSPEC int

+ struct xml_desc {

+ char * xml;

+ int size;

+ int is_igd;

+ } * desc = NULL;

+ int i;

+ int state = -1; /* state 1 : IGD connected. State 2 : IGD. State 3 : anything */

+ int n_igd = 0;

+ char extIpAddr[16];

+ char myLanAddr[40];

+ int status_code = -1;

+

+ /* counting total number of devices in the list */

+ for(dev = devlist; dev; dev = dev->pNext)

+ ndev++;

+ if(ndev > 0)

+ {

+ desc = calloc(ndev, sizeof(struct xml_desc));

+ if(!desc)

+ return -1; /* memory allocation error */

+ }

+ /* Step 1 : downloading descriptions and testing type */

+ for(dev = devlist, i = 0; dev; dev = dev->pNext, i++)

+ {

+ /* we should choose an internet gateway device.

+ * with st == urn:schemas-upnp-org:device:InternetGatewayDevice:1 */

+ desc[i].xml = miniwget_getaddr(dev->descURL, &(desc[i].size),

+ myLanAddr, sizeof(myLanAddr),

+ dev->scope_id, &status_code);

+#ifdef DEBUG

+ if(!desc[i].xml)

+ {

+ printf("error getting XML description %s\n", dev->descURL);

+ }

+#endif

+ if(desc[i].xml)

+ {

+ memset(data, 0, sizeof(struct IGDdatas));

+ memset(urls, 0, sizeof(struct UPNPUrls));

+ parserootdesc(desc[i].xml, desc[i].size, data);

+ if(COMPARE(data->CIF.servicetype,

+ "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:"))

+ {

+ desc[i].is_igd = 1;

+ n_igd++;

+ if(lanaddr)

+ strncpy(lanaddr, myLanAddr, lanaddrlen);

+ }

+ }

+ }

+ /* iterate the list to find a device depending on state */

+ for(dev = devlist, i = 0; dev; dev = dev->pNext, i++)

+ if(desc[i].xml)

+ parserootdesc(desc[i].xml, desc[i].size, data);

+ if(desc[i].is_igd || state >= 3 )

+ int is_connected;

+

+ GetUPNPUrls(urls, data, dev->descURL, dev->scope_id);

+ /* in state 2 and 3 we dont test if device is connected ! */

+ if(state >= 2)

+ goto free_and_return;

+ is_connected = UPNPIGD_IsConnected(urls, data);

+ urls->controlURL, is_connected);

+#endif

+ /* checks that status is connected AND there is a external IP address assigned */

+ if(is_connected &&

+ (UPNP_GetExternalIPAddress(urls->controlURL, data->first.servicetype, extIpAddr) == 0)) {

+ if(!is_rfc1918addr(extIpAddr) && (extIpAddr[0] != '\0')

+ && (0 != strcmp(extIpAddr, "0.0.0.0")))

+ goto free_and_return;

+ }

+ GetUPNPUrls(urls, data, dev->descURL, dev->scope_id);

+ is_connected = UPNPIGD_IsConnected(urls, data);

+ urls->controlURL, is_connected);

+#endif

+ if(is_connected &&

+ (UPNP_GetExternalIPAddress(urls->controlURL, data->first.servicetype, extIpAddr) == 0)) {

+ if(!is_rfc1918addr(extIpAddr) && (extIpAddr[0] != '\0')

+ && (0 != strcmp(extIpAddr, "0.0.0.0")))

+ goto free_and_return;

+ }

+ }

+ }

+ state = 0;

+free_and_return:

+ if(desc) {

+ for(i = 0; i < ndev; i++) {

+ if(desc[i].xml) {

+ free(desc[i].xml);

+ free(desc);

+ return state;

+

+ lanaddr, lanaddrlen, 0, NULL);

+ GetUPNPUrls(urls, data, rootdescurl, 0);

+/* $Id: miniupnpc.h,v 1.50 2016/04/19 21:06:21 nanard Exp $ */

+ * Copyright (c) 2005-2016 Thomas Bernard

+#ifndef MINIUPNPC_H_INCLUDED

+#define MINIUPNPC_H_INCLUDED

+#include "miniupnpc_declspec.h"

+#include "upnpdev.h"

+/* versions : */

+#define MINIUPNPC_VERSION "2.0.20170509"

+#define MINIUPNPC_API_VERSION 16

+

+/* Source port:

+ Using "1" as an alias for 1900 for backwards compatability

+ (presuming one would have used that for the "sameport" parameter) */

+#define UPNP_LOCAL_PORT_ANY 0

+#define UPNP_LOCAL_PORT_SAME 1

+

+ * If localport is set to UPNP_LOCAL_PORT_SAME(1) SSDP packets will be sent

+ * from the source port 1900 (same as destination port), if set to

+ * UPNP_LOCAL_PORT_ANY(0) system assign a source port, any other value will

+ * be attempted as the source port.

+ * "searchalltypes" parameter is useful when searching several types,

+ * if 0, the discovery will stop with the first type returning results.

+ * TTL should default to 2. */

+MINIUPNP_LIBSPEC struct UPNPDev *

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+

+MINIUPNP_LIBSPEC struct UPNPDev *

+upnpDiscoverAll(int delay, const char * multicastif,

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+ int * error);

+

+MINIUPNP_LIBSPEC struct UPNPDev *

+upnpDiscoverDevice(const char * device, int delay, const char * multicastif,

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+ int * error);

+

+MINIUPNP_LIBSPEC struct UPNPDev *

+upnpDiscoverDevices(const char * const deviceTypes[],

+ int delay, const char * multicastif,

+ const char * minissdpdsock, int localport,

+ int ipv6, unsigned char ttl,

+ int * error,

+ int searchalltypes);

+MINIUPNP_LIBSPEC void parserootdesc(const char *, int, struct IGDdatas *);

+ char * rootdescURL;

+MINIUPNP_LIBSPEC int

+ * When succeding, urls, data, and lanaddr arguments are set.

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC void

+GetUPNPUrls(struct UPNPUrls *, struct IGDdatas *,

+ const char *, unsigned int);

+MINIUPNP_LIBSPEC void

+FreeUPNPUrls(struct UPNPUrls *);

+MINIUPNP_LIBSPEC int UPNPIGD_IsConnected(struct UPNPUrls *, struct IGDdatas *);

+#ifndef MINIUPNPC_DECLSPEC_H_INCLUDED

+#define MINIUPNPC_DECLSPEC_H_INCLUDED

+

+#if defined(_WIN32) && !defined(MINIUPNP_STATICLIB)

+ /* for windows dll */

+ #ifdef MINIUPNP_EXPORTS

+ #define MINIUPNP_LIBSPEC __declspec(dllexport)

+ #else

+ #define MINIUPNP_LIBSPEC __declspec(dllimport)

+ #endif

+#else

+ #if defined(__GNUC__) && __GNUC__ >= 4

+ /* fix dynlib for OS X 10.9.2 and Apple LLVM version 5.0 */

+ #define MINIUPNP_LIBSPEC __attribute__ ((visibility ("default")))

+ #else

+ #define MINIUPNP_LIBSPEC

+ #endif

+#endif

+

+#endif /* MINIUPNPC_DECLSPEC_H_INCLUDED */

+

+/* $Id: miniupnpctypes.h,v 1.2 2012/09/27 15:42:10 nanard Exp $ */

+#ifndef MINIUPNPCTYPES_H_INCLUDED

+#define MINIUPNPCTYPES_H_INCLUDED

+/* $Id: miniwget.c,v 1.77 2017/05/09 10:04:57 nanard Exp $ */

+ * Website : http://miniupnp.free.fr/

+ * Copyright (c) 2005-2017 Thomas Bernard

+

+#ifdef _WIN32

+#else /* #ifdef _WIN32 */

+#include <netinet/in.h>

+#include <net/if.h>

+#include <strings.h>

+#endif /* #else _WIN32 */

+#ifdef __GNU__

+#define MAXHOSTNAMELEN 64

+#endif /* __GNU__ */

+#ifndef MIN

+#endif /* MIN */

+

+#ifndef MAXHOSTNAMELEN

+#define MAXHOSTNAMELEN 64

+#endif

+

+getHTTPResponse(int s, int * size, int * status_code)

+ unsigned int header_buf_len = 2048;

+ unsigned int header_buf_used = 0;

+ unsigned int content_buf_len = 2048;

+ unsigned int content_buf_used = 0;

+ unsigned int chunksize_buf_index;

+#ifdef DEBUG

+ char * reason_phrase = NULL;

+ int reason_phrase_len = 0;

+#endif

+ if(status_code) *status_code = -1;

+ if(header_buf == NULL)

+ {

+#ifdef DEBUG

+ fprintf(stderr, "%s: Memory allocation error\n", "getHTTPResponse");

+#endif /* DEBUG */

+ *size = -1;

+ return NULL;

+ }

+ if(content_buf == NULL)

+ {

+ free(header_buf);

+#ifdef DEBUG

+ fprintf(stderr, "%s: Memory allocation error\n", "getHTTPResponse");

+#endif /* DEBUG */

+ *size = -1;

+ return NULL;

+ }

+ while((n = receivedata(s, buf, sizeof(buf), 5000, NULL)) > 0)

+ char * tmp = realloc(header_buf, header_buf_used + n);

+ if(tmp == NULL) {

+ /* memory allocation error */

+ free(header_buf);

+ free(content_buf);

+ *size = -1;

+ return NULL;

+ }

+ header_buf = tmp;

+ while(i < ((int)header_buf_used-1) && (endofheaders == 0)) {

+ if(i < (int)header_buf_used && header_buf[i] == '\r') {

+ if(i < (int)header_buf_used && header_buf[i] == '\n') {

+ if(linestart > 0 && colon <= linestart && header_buf[i]==':')

+ if(linestart == 0 && status_code)

+ {

+ /* Status line

+ * HTTP-Version SP Status-Code SP Reason-Phrase CRLF */

+ int sp;

+ for(sp = 0; sp < i; sp++)

+ if(header_buf[sp] == ' ')

+ {

+ if(*status_code < 0)

+ *status_code = atoi(header_buf + sp + 1);

+ else

+ {

+#ifdef DEBUG

+ reason_phrase = header_buf + sp + 1;

+ reason_phrase_len = i - sp - 1;

+#endif

+ break;

+ }

+ }

+#ifdef DEBUG

+ printf("HTTP status code = %d, Reason phrase = %.*s\n",

+ *status_code, reason_phrase_len, reason_phrase);

+#endif

+ }

+ else if(colon > linestart && valuestart > colon)

+ while((i < (int)header_buf_used) && (header_buf[i]=='\r' || header_buf[i] == '\n'))

+ }

+ unsigned int j;

+ /* it is guaranteed that (n >= i) */

+ bytestocopy = (chunksize < (unsigned int)(n - i))?chunksize:(unsigned int)(n - i);

+ if((content_buf_used + bytestocopy) > content_buf_len)

+ char * tmp;

+ if((content_length >= 0) && ((unsigned int)content_length >= (content_buf_used + bytestocopy))) {

+ content_buf_len = content_buf_used + bytestocopy;

+ tmp = realloc(content_buf, content_buf_len);

+ if(tmp == NULL) {

+ /* memory allocation error */

+ free(content_buf);

+ free(header_buf);

+ *size = -1;

+ return NULL;

+ }

+ content_buf = tmp;

+ && (content_buf_used + n) > (unsigned int)content_length) {

+ char * tmp;

+ if(content_length >= 0

+ && (unsigned int)content_length >= (content_buf_used + n)) {

+ tmp = realloc(content_buf, content_buf_len);

+ if(tmp == NULL) {

+ /* memory allocation error */

+ free(content_buf);

+ free(header_buf);

+ *size = -1;

+ return NULL;

+ }

+ content_buf = tmp;

+ if(content_length > 0 && content_buf_used >= (unsigned int)content_length)

+miniwget3(const char * host,

+ const char * httpversion, unsigned int scope_id,

+ int * status_code)

+ s = connecthostport(host, port, scope_id);

+#ifdef _WIN32

+ "User-Agent: " OS_STRING ", " UPNP_VERSION_STRING ", MiniUPnPc/" MINIUPNPC_VERSION_STRING "\r\n"

+ if ((unsigned int)len >= sizeof(buf))

+ {

+ closesocket(s);

+ return NULL;

+ }

+ content = getHTTPResponse(s, size, status_code);

+miniwget2(const char * host,

+ unsigned short port, const char * path,

+ int * size, char * addr_str, int addr_str_len,

+ unsigned int scope_id, int * status_code)

+#if 1

+ respbuffer = miniwget3(host, port, path, size,

+ addr_str, addr_str_len, "1.1",

+ scope_id, status_code);

+#else

+ respbuffer = miniwget3(host, port, path, size,

+ addr_str, addr_str_len, "1.0",

+ scope_id, status_code);

+ respbuffer = miniwget3(host, port, path, size,

+ addr_str, addr_str_len, "1.1",

+ scope_id, status_code);

+#endif

+ * path : pointer to the path part of the URL

+int

+parseURL(const char * url,

+ char * hostname, unsigned short * port,

+ char * * path, unsigned int * scope_id)

+ char * scope;

+ scope = strchr(p1, '%');

+ if(p2 && scope && scope < p2 && scope_id) {

+ /* parse scope */

+#ifdef IF_NAMESIZE

+ char tmp[IF_NAMESIZE];

+ int l;

+ scope++;

+ /* "%25" is just '%' in URL encoding */

+ if(scope[0] == '2' && scope[1] == '5')

+ scope += 2; /* skip "25" */

+ l = p2 - scope;

+ if(l >= IF_NAMESIZE)

+ l = IF_NAMESIZE - 1;

+ memcpy(tmp, scope, l);

+ tmp[l] = '\0';

+ *scope_id = if_nametoindex(tmp);

+ if(*scope_id == 0) {

+ *scope_id = (unsigned int)strtoul(tmp, NULL, 10);

+ }

+#else

+ /* under windows, scope is numerical */

+ char tmp[8];

+ int l;

+ scope++;

+ /* "%25" is just '%' in URL encoding */

+ if(scope[0] == '2' && scope[1] == '5')

+ scope += 2; /* skip "25" */

+ l = p2 - scope;

+ if(l >= sizeof(tmp))

+ l = sizeof(tmp) - 1;

+ memcpy(tmp, scope, l);

+ tmp[l] = '\0';

+ *scope_id = (unsigned int)strtoul(tmp, NULL, 10);

+#endif

+ }

+void *

+miniwget(const char * url, int * size,

+ unsigned int scope_id, int * status_code)

+ if(!parseURL(url, hostname, &port, &path, &scope_id))

+ printf("parsed url : hostname='%s' port=%hu path='%s' scope_id=%u\n",

+ hostname, port, path, scope_id);

+ return miniwget2(hostname, port, path, size, 0, 0, scope_id, status_code);

+void *

+miniwget_getaddr(const char * url, int * size,

+ char * addr, int addrlen, unsigned int scope_id,

+ int * status_code)

+ /* protocol://host:port/path */

+ if(!parseURL(url, hostname, &port, &path, &scope_id))

+ printf("parsed url : hostname='%s' port=%hu path='%s' scope_id=%u\n",

+ hostname, port, path, scope_id);

+ return miniwget2(hostname, port, path, size, addr, addrlen, scope_id, status_code);

+/* $Id: miniwget.h,v 1.12 2016/01/24 17:24:36 nanard Exp $ */

+ * Copyright (c) 2005-2016 Thomas Bernard

+#ifndef MINIWGET_H_INCLUDED

+#define MINIWGET_H_INCLUDED

+#include "miniupnpc_declspec.h"

+MINIUPNP_LIBSPEC void * getHTTPResponse(int s, int * size, int * status_code);

+MINIUPNP_LIBSPEC void * miniwget(const char *, int *, unsigned int, int *);

+MINIUPNP_LIBSPEC void * miniwget_getaddr(const char *, int *, char *, int, unsigned int, int *);

+int parseURL(const char *, char *, unsigned short *, char * *, unsigned int *);

+/* $Id: minixml.c,v 1.11 2014/02/03 15:54:12 nanard Exp $ */

+Copyright (c) 2005-2014, Thomas BERNARD

+ if((p->xml + 4) <= p->xmlend && (0 == memcmp(p->xml, "<!--", 4)))

+ {

+ p->xml += 3;

+ /* ignore comments */

+ do

+ {

+ p->xml++;

+ if ((p->xml + 3) >= p->xmlend)

+ return;

+ }

+ while(memcmp(p->xml, "-->", 3) != 0);

+ p->xml += 3;

+ }

+ else if((p->xml)[0]=='<' && (p->xml)[1]!='?')

+ {

+/* $Id: minixml.h,v 1.7 2012/09/27 15:42:10 nanard Exp $ */

+#ifndef MINIXML_H_INCLUDED

+#define MINIXML_H_INCLUDED

+/* $Id: minixmlvalid.c,v 1.7 2015/07/15 12:41:15 nanard Exp $ */

+ /*return 1;*/

+};

+ if(evtlist.events == NULL)

+ {

+ fprintf(stderr, "Memory allocation error.\n");

+ return -1;

+ }

+ (void)argc; (void)argv;

+

+/* $Id: portlistingparse.c,v 1.10 2016/12/16 08:53:21 nanard Exp $ */

+ * (c) 2011-2016 Thomas Bernard

+#ifdef DEBUG

+#include <stdio.h>

+#endif /* DEBUG */

+ if(strlen(elements[i].str) == (size_t)l && memcmp(name, elements[i].str, l) == 0)

+ if(pm == NULL)

+ {

+ /* malloc error */

+#ifdef DEBUG

+ fprintf(stderr, "%s: error allocating memory",

+ "startelt");

+#endif /* DEBUG */

+ return;

+ }

+ pm->l_next = pdata->l_head; /* insert in list */

+ pdata->l_head = pm;

+ (void)name;

+ (void)l;

+ pm = pdata->l_head;

+ while((pm = pdata->l_head) != NULL)

+ /* remove from list */

+ pdata->l_head = pm->l_next;

+/* $Id: portlistingparse.h,v 1.11 2015/07/21 13:16:55 nanard Exp $ */

+ * (c) 2011-2015 Thomas Bernard

+#ifndef PORTLISTINGPARSE_H_INCLUDED

+#define PORTLISTINGPARSE_H_INCLUDED

+#include "miniupnpc_declspec.h"

+ NewEnabled, NewDescription,

+ struct PortMapping * l_next; /* list next element */

+ struct PortMapping * l_head; /* list head */

+MINIUPNP_LIBSPEC void

+MINIUPNP_LIBSPEC void

+/* $Id: receivedata.c,v 1.8 2017/04/21 10:16:45 nanard Exp $ */

+ * Website : http://miniupnp.free.fr/

+ * Copyright (c) 2011-2014 Thomas Bernard

+#include <string.h>

+#ifdef _WIN32

+#else /* _WIN32 */

+#include <netinet/in.h>

+#endif /* !defined(__amigaos__) && !defined(__amigaos4__) */

+#endif /* _WIN32 */

+#ifdef _WIN32

+#define PRINT_SOCKET_ERROR(x) fprintf(stderr, "Socket error: %s, %d\n", x, WSAGetLastError());

+receivedata(int socket,

+ char * data, int length,

+ int timeout, unsigned int * scope_id)

+#ifdef MINIUPNPC_GET_SRC_ADDR

+ struct sockaddr_storage src_addr;

+ socklen_t src_addr_len = sizeof(src_addr);

+#endif /* MINIUPNPC_GET_SRC_ADDR */

+#if !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__)

+#endif /* MINIUPNPC_IGNORE_EINTR */

+#endif /* MINIUPNPC_IGNORE_EINTR */

+#else /* !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__) */

+ /* using select under _WIN32 and amigaos */

+ }

+#endif /* !defined(_WIN32) && !defined(__amigaos__) && !defined(__amigaos4__) */

+#ifdef MINIUPNPC_GET_SRC_ADDR

+ memset(&src_addr, 0, sizeof(src_addr));

+ n = recvfrom(socket, data, length, 0,

+ (struct sockaddr *)&src_addr, &src_addr_len);

+#else /* MINIUPNPC_GET_SRC_ADDR */

+#endif /* MINIUPNPC_GET_SRC_ADDR */

+#ifdef MINIUPNPC_GET_SRC_ADDR

+ if (src_addr.ss_family == AF_INET6) {

+ const struct sockaddr_in6 * src_addr6 = (struct sockaddr_in6 *)&src_addr;

+#ifdef DEBUG

+ printf("scope_id=%u\n", src_addr6->sin6_scope_id);

+#endif /* DEBUG */

+ if(scope_id)

+ *scope_id = src_addr6->sin6_scope_id;

+ }

+#endif /* MINIUPNPC_GET_SRC_ADDR */

+/* $Id: receivedata.h,v 1.4 2012/09/27 15:42:10 nanard Exp $ */

+ * Copyright (c) 2011-2012 Thomas Bernard

+#ifndef RECEIVEDATA_H_INCLUDED

+#define RECEIVEDATA_H_INCLUDED

+/* Reads data from the specified socket.

+ * Returns the number of bytes read if successful, zero if no bytes were

+int receivedata(int socket,

+ char * data, int length,

+ int timeout, unsigned int * scope_id);

+/* $Id: upnpc.c,v 1.116 2017/04/21 10:20:50 nanard Exp $ */

+ * Copyright (c) 2005-2016 Thomas Bernard

+#ifdef _WIN32

+#else

+/* for IPPROTO_TCP / IPPROTO_UDP */

+#include <netinet/in.h>

+#include <ctype.h>

+#include "miniupnpcstrings.h"

+/* protofix() checks if protocol is "UDP" or "TCP"

+ b = b && ( (proto[i] == proto_tcp[i])

+/* is_int() checks if parameter is an integer or not

+ * 1 for integer

+ * 0 for not an integer */

+int is_int(char const* s)

+{

+ if(s == NULL)

+ return 0;

+ while(*s) {

+ /* #define isdigit(c) ((c) >= '0' && (c) <= '9') */

+ if(!isdigit(*s))

+ return 0;

+ s++;

+ }

+ return 1;

+}

+

+ unsigned int uptime = 0;

+ if(UPNP_GetConnectionTypeInfo(urls->controlURL,

+ data->first.servicetype,

+ connectionType) != UPNPCOMMAND_SUCCESS)

+ printf("GetConnectionTypeInfo failed.\n");

+ else

+ if(UPNP_GetStatusInfo(urls->controlURL, data->first.servicetype,

+ status, &uptime, lastconnerr) != UPNPCOMMAND_SUCCESS)

+ printf("GetStatusInfo failed.\n");

+ printf("Status : %s, uptime=%us, LastConnectionError : %s\n",

+ status, uptime, lastconnerr);

+ if(uptime > 0) {

+ timenow = time(NULL);

+ timestarted = timenow - uptime;

+ printf(" Time started : %s", ctime(&timestarted));

+ }

+ if(UPNP_GetLinkLayerMaxBitRates(urls->controlURL_CIF, data->CIF.servicetype,

+ &brDown, &brUp) != UPNPCOMMAND_SUCCESS) {

+ printf("GetLinkLayerMaxBitRates failed.\n");

+ } else {

+ printf("MaxBitRateDown : %u bps", brDown);

+ if(brDown >= 1000000) {

+ printf(" (%u.%u Mbps)", brDown / 1000000, (brDown / 100000) % 10);

+ } else if(brDown >= 1000) {

+ printf(" (%u Kbps)", brDown / 1000);

+ }

+ printf(" MaxBitRateUp %u bps", brUp);

+ if(brUp >= 1000000) {

+ printf(" (%u.%u Mbps)", brUp / 1000000, (brUp / 100000) % 10);

+ } else if(brUp >= 1000) {

+ printf(" (%u Kbps)", brUp / 1000);

+ }

+ printf("\n");

+ }

+ if(r != UPNPCOMMAND_SUCCESS) {

+ printf("GetExternalIPAddress failed. (errorcode=%d)\n", r);

+ } else {

+ }

+ printf(" i protocol exPort->inAddr:inPort description remoteHost leaseTime\n");

+ printf(" i protocol exPort->inAddr:inPort description remoteHost leaseTime\n");

+ for(pm = pdata.l_head; pm != NULL; pm = pm->l_next)

+ for(pm = pdata.l_head; pm != NULL; pm = pm->l_next)

+/* Test function

+static int SetRedirectAndTest(struct UPNPUrls * urls,

+ struct IGDdatas * data,

+ const char * iaddr,

+ const char * iport,

+ const char * eport,

+ const char * proto,

+ const char * leaseDuration,

+ const char * description,

+ int addAny)

+ char reservedPort[6];

+ return -1;

+ return -1;

+

+ r = UPNP_GetExternalIPAddress(urls->controlURL,

+ data->first.servicetype,

+ externalIPAddress);

+ printf("GetExternalIPAddress failed.\n");

+ else

+ printf("ExternalIPAddress = %s\n", externalIPAddress);

+

+ if (addAny) {

+ r = UPNP_AddAnyPortMapping(urls->controlURL, data->first.servicetype,

+ eport, iport, iaddr, description,

+ proto, 0, leaseDuration, reservedPort);

+ if(r==UPNPCOMMAND_SUCCESS)

+ eport = reservedPort;

+ else

+ printf("AddAnyPortMapping(%s, %s, %s) failed with code %d (%s)\n",

+ eport, iport, iaddr, r, strupnperror(r));

+ } else {

+ r = UPNP_AddPortMapping(urls->controlURL, data->first.servicetype,

+ eport, iport, iaddr, description,

+ proto, 0, leaseDuration);

+ if(r!=UPNPCOMMAND_SUCCESS) {

+ printf("AddPortMapping(%s, %s, %s) failed with code %d (%s)\n",

+ eport, iport, iaddr, r, strupnperror(r));

+ return -2;

+ }

+ }

+ data->first.servicetype,

+ eport, proto, NULL/*remoteHost*/,

+ intClient, intPort, NULL/*desc*/,

+ NULL/*enabled*/, duration);

+ if(r!=UPNPCOMMAND_SUCCESS) {

+ return -2;

+ } else {

+ return 0;

+static int

+ const char * eport,

+ const char * proto,

+ const char * remoteHost)

+ return -1;

+ return -1;

+ }

+ r = UPNP_DeletePortMapping(urls->controlURL, data->first.servicetype, eport, proto, remoteHost);

+ if(r!=UPNPCOMMAND_SUCCESS) {

+ printf("UPNP_DeletePortMapping() failed with code : %d\n", r);

+ return -2;

+ }else {

+ printf("UPNP_DeletePortMapping() returned : %d\n", r);

+ }

+ return 0;

+}

+

+static int

+RemoveRedirectRange(struct UPNPUrls * urls,

+ struct IGDdatas * data,

+ const char * ePortStart, char const * ePortEnd,

+ const char * proto, const char * manage)

+{

+ int r;

+

+ if (!manage)

+ manage = "0";

+

+ if(!proto || !ePortStart || !ePortEnd)

+ {

+ fprintf(stderr, "invalid arguments\n");

+ return -1;

+ }

+ proto = protofix(proto);

+ if(!proto)

+ {

+ fprintf(stderr, "protocol invalid\n");

+ return -1;

+ r = UPNP_DeletePortMappingRange(urls->controlURL, data->first.servicetype, ePortStart, ePortEnd, proto, manage);

+ if(r!=UPNPCOMMAND_SUCCESS) {

+ printf("UPNP_DeletePortMappingRange() failed with code : %d\n", r);

+ return -2;

+ }else {

+ printf("UPNP_DeletePortMappingRange() returned : %d\n", r);

+ }

+ return 0;

+

+/* Test function

+ /*int isWorking = 0;*/

+ char proto_tmp[8];

+ if(atoi(proto) == 0)

+ const char * protocol;

+ protocol = protofix(proto);

+ if(protocol && (strcmp("TCP", protocol) == 0))

+ {

+ snprintf(proto_tmp, sizeof(proto_tmp), "%d", IPPROTO_TCP);

+ proto = proto_tmp;

+ }

+ else if(protocol && (strcmp("UDP", protocol) == 0))

+ {

+ snprintf(proto_tmp, sizeof(proto_tmp), "%d", IPPROTO_UDP);

+ proto = proto_tmp;

+ }

+ else

+ {

+ fprintf(stderr, "invalid protocol\n");

+ return;

+ }

+ }

+ remoteaddr, eport, intaddr, iport, r, strupnperror(r));

+ printf("AddPinhole: ([%s]:%s -> [%s]:%s) / Pinhole ID = %s\n",

+ remoteaddr, eport, intaddr, iport, uniqueID);

+/* Test function

+ char lanaddr[64] = "unset"; /* my ip address on the LAN */

+ int localport = UPNP_LOCAL_PORT_ANY;

+ unsigned char ttl = 2; /* defaulting to 2 */

+ const char * description = 0;

+#ifdef _WIN32

+ printf("upnpc : miniupnpc library test client, version %s.\n", MINIUPNPC_VERSION_STRING);

+ printf(" (c) 2005-2016 Thomas Bernard.\n");

+ if(0 == strcmp(argv[i], "--help") || 0 == strcmp(argv[i], "-h"))

+ {

+ command = 0;

+ break;

+ }

+ else if(argv[i][1] == 'z')

+ {

+ char junk;

+ if(sscanf(argv[++i], "%d%c", &localport, &junk)!=1 ||

+ localport<0 || localport>65535 ||

+ (localport >1 && localport < 1024))

+ {

+ fprintf(stderr, "Invalid localport '%s'\n", argv[i]);

+ localport = UPNP_LOCAL_PORT_ANY;

+ break;

+ }

+ }

+ else if(argv[i][1] == 'e')

+ description = argv[++i];

+ else if(argv[i][1] == 't')

+ ttl = (unsigned char)atoi(argv[++i]);

+ if(!command

+ || (command == 'a' && commandargc<4)

+ fprintf(stderr, " \t%s [options] -d external_port protocol <remote host>\n\t\tDelete port redirection\n", argv[0]);

+ fprintf(stderr, " \t%s [options] -L\n\t\tList redirections (using GetListOfPortMappings (for IGD:2 only)\n", argv[0]);

+ fprintf(stderr, " \t%s [options] -n ip port external_port protocol [duration]\n\t\tAdd (any) port redirection allowing IGD to use alternative external_port (for IGD:2 only)\n", argv[0]);

+ fprintf(stderr, " \t%s [options] -N external_port_start external_port_end protocol [manage]\n\t\tDelete range of port redirections (for IGD:2 only)\n", argv[0]);

+ fprintf(stderr, " \t%s [options] -r port1 [external_port1] protocol1 [port2 [external_port2] protocol2] [...]\n\t\tAdd all redirections to the current host\n", argv[0]);

+ fprintf(stderr, " -e description : set description for port mapping.\n");

+ fprintf(stderr, " -m address/interface : provide ip address (ip v4) or interface name (ip v4 or v6) to use for sending SSDP multicast packets.\n");

+ fprintf(stderr, " -z localport : SSDP packets local (source) port (1024-65535).\n");

+ fprintf(stderr, " -t ttl : set multicast TTL. Default value is 2.\n");

+ localport, ipv6, ttl, &error)))

+ else if(!rootdescurl)

+ if (SetRedirectAndTest(&urls, &data,

+ commandargv[0], commandargv[1],

+ commandargv[2], commandargv[3],

+ (commandargc > 4)?commandargv[4]:"0",

+ description, 0) < 0)

+ retcode = 2;

+ if (RemoveRedirect(&urls, &data, commandargv[0], commandargv[1],

+ commandargc > 2 ? commandargv[2] : NULL) < 0)

+ retcode = 2;

+ break;

+ case 'n': /* aNy */

+ if (SetRedirectAndTest(&urls, &data,

+ commandargv[0], commandargv[1],

+ commandargv[2], commandargv[3],

+ (commandargc > 4)?commandargv[4]:"0",

+ description, 1) < 0)

+ retcode = 2;

+ break;

+ case 'N':

+ if (commandargc < 3)

+ fprintf(stderr, "too few arguments\n");

+

+ if (RemoveRedirectRange(&urls, &data, commandargv[0], commandargv[1], commandargv[2],

+ commandargc > 3 ? commandargv[3] : NULL) < 0)

+ retcode = 2;

+ i = 0;

+ while(i<commandargc)

+ if(!is_int(commandargv[i])) {

+ /* 1st parameter not an integer : error */

+ fprintf(stderr, "command -r : %s is not an port number\n", commandargv[i]);

+ retcode = 1;

+ break;

+ } else if(is_int(commandargv[i+1])){

+ /* 2nd parameter is an integer : <port> <external_port> <protocol> */

+ if (SetRedirectAndTest(&urls, &data,

+ lanaddr, commandargv[i],

+ commandargv[i+1], commandargv[i+2], "0",

+ description, 0) < 0)

+ retcode = 2;

+ i+=3; /* 3 parameters parsed */

+ } else {

+ /* 2nd parameter not an integer : <port> <protocol> */

+ if (SetRedirectAndTest(&urls, &data,

+ lanaddr, commandargv[i],

+ commandargv[i], commandargv[i+1], "0",

+ description, 0) < 0)

+ retcode = 2;

+ i+=2; /* 2 parameters parsed */

+ }

+#ifdef _WIN32

+ nResult = WSACleanup();

+ if(nResult != NO_ERROR) {

+ fprintf(stderr, "WSACleanup() failed.\n");

+ }

+#endif /* _WIN32 */

+/* $Id: upnpcommands.c,v 1.48 2017/04/21 10:22:40 nanard Exp $ */

+/* vim: tabstop=4 shiftwidth=4 noexpandtab

+ * Project : miniupnp

+ * Copyright (c) 2005-2017 Thomas Bernard

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC int

+ char * status,

+ *uptime = 0;

+MINIUPNP_LIBSPEC int

+ * One of the values can be null

+ * Note : GetLinkLayerMaxBitRates belongs to WANPPPConnection:1 only

+MINIUPNP_LIBSPEC int

+ *

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+ const char * extPort,

+ const char * inPort,

+ const char * inClient,

+ const char * desc,

+ const char * proto,

+ const char * remoteHost,

+ const char * leaseDuration)

+ if(AddPortMappingArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ buffer = simpleUPnPcommand(-1, controlURL, servicetype,

+ "AddPortMapping", AddPortMappingArgs,

+ &bufsize);

+ free(AddPortMappingArgs);

+ if(!buffer) {

+ return ret;

+}

+

+MINIUPNP_LIBSPEC int

+UPNP_AddAnyPortMapping(const char * controlURL, const char * servicetype,

+ const char * extPort,

+ const char * inPort,

+ const char * inClient,

+ const char * desc,

+ const char * proto,

+ const char * remoteHost,

+ const char * leaseDuration,

+ char * reservedPort)

+{

+ struct UPNParg * AddPortMappingArgs;

+ char * buffer;

+ int bufsize;

+ struct NameValueParserData pdata;

+ const char * resVal;

+ int ret;

+

+ if(!inPort || !inClient || !proto || !extPort)

+ return UPNPCOMMAND_INVALID_ARGS;

+

+ AddPortMappingArgs = calloc(9, sizeof(struct UPNParg));

+ if(AddPortMappingArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ AddPortMappingArgs[0].elt = "NewRemoteHost";

+ AddPortMappingArgs[0].val = remoteHost;

+ AddPortMappingArgs[1].elt = "NewExternalPort";

+ AddPortMappingArgs[1].val = extPort;

+ AddPortMappingArgs[2].elt = "NewProtocol";

+ AddPortMappingArgs[2].val = proto;

+ AddPortMappingArgs[3].elt = "NewInternalPort";

+ AddPortMappingArgs[3].val = inPort;

+ AddPortMappingArgs[4].elt = "NewInternalClient";

+ AddPortMappingArgs[4].val = inClient;

+ AddPortMappingArgs[5].elt = "NewEnabled";

+ AddPortMappingArgs[5].val = "1";

+ AddPortMappingArgs[6].elt = "NewPortMappingDescription";

+ AddPortMappingArgs[6].val = desc?desc:"libminiupnpc";

+ AddPortMappingArgs[7].elt = "NewLeaseDuration";

+ AddPortMappingArgs[7].val = leaseDuration?leaseDuration:"0";

+ buffer = simpleUPnPcommand(-1, controlURL, servicetype,

+ "AddAnyPortMapping", AddPortMappingArgs,

+ &bufsize);

+ if(!buffer) {

+ return UPNPCOMMAND_HTTP_ERROR;

+ }

+ ParseNameValue(buffer, bufsize, &pdata);

+ free(buffer); buffer = NULL;

+ resVal = GetValueFromNameValueList(&pdata, "errorCode");

+ if(resVal) {

+ ret = UPNPCOMMAND_UNKNOWN_ERROR;

+ sscanf(resVal, "%d", &ret);

+ } else {

+ char *p;

+

+ p = GetValueFromNameValueList(&pdata, "NewReservedPort");

+ if(p) {

+ strncpy(reservedPort, p, 6);

+ reservedPort[5] = '\0';

+ ret = UPNPCOMMAND_SUCCESS;

+ } else {

+ ret = UPNPCOMMAND_INVALID_RESPONSE;

+ }

+ }

+ ClearNameValueList(&pdata);

+MINIUPNP_LIBSPEC int

+ if(DeletePortMappingArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ buffer = simpleUPnPcommand(-1, controlURL, servicetype,

+ "DeletePortMapping",

+ DeletePortMappingArgs, &bufsize);

+ free(DeletePortMappingArgs);

+ if(!buffer) {

+ return ret;

+}

+

+MINIUPNP_LIBSPEC int

+UPNP_DeletePortMappingRange(const char * controlURL, const char * servicetype,

+ const char * extPortStart, const char * extPortEnd,

+ const char * proto,

+ const char * manage)

+{

+ struct UPNParg * DeletePortMappingArgs;

+ char * buffer;

+ int bufsize;

+ struct NameValueParserData pdata;

+ const char * resVal;

+ int ret;

+

+ if(!extPortStart || !extPortEnd || !proto || !manage)

+ return UPNPCOMMAND_INVALID_ARGS;

+

+ DeletePortMappingArgs = calloc(5, sizeof(struct UPNParg));

+ if(DeletePortMappingArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ DeletePortMappingArgs[0].elt = "NewStartPort";

+ DeletePortMappingArgs[0].val = extPortStart;

+ DeletePortMappingArgs[1].elt = "NewEndPort";

+ DeletePortMappingArgs[1].val = extPortEnd;

+ DeletePortMappingArgs[2].elt = "NewProtocol";

+ DeletePortMappingArgs[2].val = proto;

+ DeletePortMappingArgs[3].elt = "NewManage";

+ DeletePortMappingArgs[3].val = manage;

+

+ buffer = simpleUPnPcommand(-1, controlURL, servicetype,

+ "DeletePortMappingRange",

+ DeletePortMappingArgs, &bufsize);

+ if(!buffer) {

+ return UPNPCOMMAND_HTTP_ERROR;

+ }

+ ParseNameValue(buffer, bufsize, &pdata);

+ free(buffer); buffer = NULL;

+ resVal = GetValueFromNameValueList(&pdata, "errorCode");

+ if(resVal) {

+ ret = UPNPCOMMAND_UNKNOWN_ERROR;

+ sscanf(resVal, "%d", &ret);

+ } else {

+ ret = UPNPCOMMAND_SUCCESS;

+ }

+ ClearNameValueList(&pdata);

+MINIUPNP_LIBSPEC int

+ if(GetPortMappingArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ buffer = simpleUPnPcommand(-1, controlURL, servicetype,

+ "GetGenericPortMappingEntry",

+ GetPortMappingArgs, &bufsize);

+ free(GetPortMappingArgs);

+ if(!buffer) {

+ if(p)

+ if(p)

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+ const char * proto,

+ const char * remoteHost,

+ if(GetPortMappingArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ GetPortMappingArgs[0].val = remoteHost;

+ buffer = simpleUPnPcommand(-1, controlURL, servicetype,

+ "GetSpecificPortMappingEntry",

+ GetPortMappingArgs, &bufsize);

+ free(GetPortMappingArgs);

+ if(!buffer) {

+MINIUPNP_LIBSPEC int

+ if(GetListOfPortMappingsArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ buffer = simpleUPnPcommand(-1, controlURL, servicetype,

+ "GetListOfPortMappings",

+ GetListOfPortMappingsArgs, &bufsize);

+ free(GetListOfPortMappingsArgs);

+ if(!buffer) {

+ /*printf("%.*s", bufsize, buffer);*/

+/* IGD:2, functions for service WANIPv6FirewallControl:1 */

+MINIUPNP_LIBSPEC int

+ int * firewallEnabled,

+ if(!firewallEnabled || !inboundPinholeAllowed)

+MINIUPNP_LIBSPEC int

+ if(GetOutboundPinholeTimeoutArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ free(GetOutboundPinholeTimeoutArgs);

+MINIUPNP_LIBSPEC int

+ if(AddPinholeArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ /* RemoteHost can be wilcarded */

+ free(AddPinholeArgs);

+ /*printf("AddPortMapping errorCode = '%s'\n", resVal);*/

+MINIUPNP_LIBSPEC int

+ if(UpdatePinholeArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ free(UpdatePinholeArgs);

+MINIUPNP_LIBSPEC int

+ if(DeletePinholeArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ free(DeletePinholeArgs);

+MINIUPNP_LIBSPEC int

+ if(CheckPinholeWorkingArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ free(CheckPinholeWorkingArgs);

+ {

+ }

+MINIUPNP_LIBSPEC int

+ if(GetPinholePacketsArgs == NULL)

+ return UPNPCOMMAND_MEM_ALLOC_ERROR;

+ free(GetPinholePacketsArgs);

+/* $Id: upnpcommands.h,v 1.31 2015/07/21 13:16:55 nanard Exp $ */

+ * Copyright (c) 2005-2015 Thomas Bernard

+#ifndef UPNPCOMMANDS_H_INCLUDED

+#define UPNPCOMMANDS_H_INCLUDED

+#include "miniupnpc_declspec.h"

+#define UPNPCOMMAND_INVALID_RESPONSE (-4)

+#define UPNPCOMMAND_MEM_ALLOC_ERROR (-5)

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC UNSIGNED_INTEGER

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+ * at least 16 bytes must be available

+ *

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+ *

+ * 606 Action not authorized - The action requested REQUIRES authorization and

+ * the sender was not authorized.

+ * must be the same

+ * cannot be a specific port value

+ * 728 NoPortMapsAvailable - There are not enough free ports available to

+ * complete port mapping.

+ * 729 ConflictWithOtherMechanisms - Attempted port mapping is not allowed

+ * due to conflict with other mechanisms.

+ * 732 WildCardNotPermittedInIntPort - The internal port cannot be wild-carded

+ */

+MINIUPNP_LIBSPEC int

+ const char * extPort,

+ const char * inPort,

+ const char * inClient,

+ const char * desc,

+ const char * proto,

+ const char * remoteHost,

+ const char * leaseDuration);

+

+/* UPNP_AddAnyPortMapping()

+ * if desc is NULL, it will be defaulted to "libminiupnpc"

+ * remoteHost is usually NULL because IGD don't support it.

+ *

+ * Return values :

+ * 0 : SUCCESS

+ * NON ZERO : ERROR. Either an UPnP error code or an unknown error.

+ *

+ * List of possible UPnP errors for AddPortMapping :

+ * errorCode errorDescription (short) - Description (long)

+ * 402 Invalid Args - See UPnP Device Architecture section on Control.

+ * 501 Action Failed - See UPnP Device Architecture section on Control.

+ * 606 Action not authorized - The action requested REQUIRES authorization and

+ * the sender was not authorized.

+ * 715 WildCardNotPermittedInSrcIP - The source IP address cannot be

+ * wild-carded

+ * 716 WildCardNotPermittedInExtPort - The external port cannot be wild-carded

+ * 728 NoPortMapsAvailable - There are not enough free ports available to

+ * complete port mapping.

+ * 729 ConflictWithOtherMechanisms - Attempted port mapping is not allowed

+ * due to conflict with other mechanisms.

+ * 732 WildCardNotPermittedInIntPort - The internal port cannot be wild-carded

+ */

+MINIUPNP_LIBSPEC int

+UPNP_AddAnyPortMapping(const char * controlURL, const char * servicetype,

+ const char * extPort,

+ const char * inPort,

+ const char * inClient,

+ const char * desc,

+ const char * proto,

+ const char * remoteHost,

+ const char * leaseDuration,

+ char * reservedPort);

+ * 606 Action not authorized - The action requested REQUIRES authorization

+ * and the sender was not authorized.

+MINIUPNP_LIBSPEC int

+ const char * extPort, const char * proto,

+ const char * remoteHost);

+

+/* UPNP_DeletePortRangeMapping()

+ * Use same argument values as what was used for AddPortMapping().

+ * remoteHost is usually NULL because IGD don't support it.

+ * Return Values :

+ * 0 : SUCCESS

+ * NON ZERO : error. Either an UPnP error code or an undefined error.

+ *

+ * List of possible UPnP errors for DeletePortMapping :

+ * 606 Action not authorized - The action requested REQUIRES authorization

+ * and the sender was not authorized.

+ * 730 PortMappingNotFound - This error message is returned if no port

+ * mapping is found in the specified range.

+ * 733 InconsistentParameters - NewStartPort and NewEndPort values are not consistent. */

+MINIUPNP_LIBSPEC int

+UPNP_DeletePortMappingRange(const char * controlURL, const char * servicetype,

+ const char * extPortStart, const char * extPortEnd,

+ const char * proto,

+ const char * manage);

+MINIUPNP_LIBSPEC int

+ * in remoteHost

+ * or a UPnP Error Code.

+ *

+ * List of possible UPnP errors for _GetSpecificPortMappingEntry :

+ * 402 Invalid Args - See UPnP Device Architecture section on Control.

+ * 501 Action Failed - See UPnP Device Architecture section on Control.

+ * 606 Action not authorized - The action requested REQUIRES authorization

+ * and the sender was not authorized.

+ * 714 NoSuchEntryInArray - The specified value does not exist in the array.

+ */

+MINIUPNP_LIBSPEC int

+ const char * remoteHost,

+ * 606 Action not authorized - The action requested REQUIRES authorization

+ * and the sender was not authorized.

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+/* IGD:2, functions for service WANIPv6FirewallControl:1 */

+MINIUPNP_LIBSPEC int

+ int * firewallEnabled,

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+MINIUPNP_LIBSPEC int

+/* $Id: upnpdev.c,v 1.1 2015/08/28 12:14:19 nanard Exp $ */

+/* Project : miniupnp

+ * Web : http://miniupnp.free.fr/

+ * Author : Thomas BERNARD

+ * copyright (c) 2005-2015 Thomas Bernard

+ * This software is subjet to the conditions detailed in the

+ * provided LICENSE file. */

+#include <stdlib.h>

+#include "upnpdev.h"

+

+/* freeUPNPDevlist() should be used to

+ * free the chained list returned by upnpDiscover() */

+void freeUPNPDevlist(struct UPNPDev * devlist)

+{

+ struct UPNPDev * next;

+ while(devlist)

+ {

+ next = devlist->pNext;

+ free(devlist);

+ devlist = next;

+ }

+}

+

+/* $Id: upnpdev.h,v 1.1 2015/08/28 12:14:19 nanard Exp $ */

+/* Project : miniupnp

+ * Web : http://miniupnp.free.fr/

+ * Author : Thomas BERNARD

+ * copyright (c) 2005-2015 Thomas Bernard

+ * This software is subjet to the conditions detailed in the

+ * provided LICENSE file. */

+#ifndef UPNPDEV_H_INCLUDED

+#define UPNPDEV_H_INCLUDED

+

+#include "miniupnpc_declspec.h"

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+struct UPNPDev {

+ struct UPNPDev * pNext;

+ char * descURL;

+ char * st;

+ unsigned int scope_id;

+ char * usn;

+ char buffer[3];

+};

+

+/* freeUPNPDevlist()

+ * free list returned by upnpDiscover() */

+MINIUPNP_LIBSPEC void freeUPNPDevlist(struct UPNPDev * devlist);

+

+

+#ifdef __cplusplus

+}

+#endif

+

+

+#endif /* UPNPDEV_H_INCLUDED */

+/* $Id: upnperrors.c,v 1.8 2014/06/10 09:41:48 nanard Exp $ */

+ case UPNPCOMMAND_INVALID_RESPONSE:

+ s = "Miniupnpc Invalid response";

+ break;

+ s = "UnknownError";

+ break;

+/* $Id: upnperrors.h,v 1.6 2015/07/21 13:16:55 nanard Exp $ */

+/* (c) 2007-2015 Thomas Bernard

+#ifndef UPNPERRORS_H_INCLUDED

+#define UPNPERRORS_H_INCLUDED

+#include "miniupnpc_declspec.h"

+ * Return a string description of the UPnP error code

+MINIUPNP_LIBSPEC const char * strupnperror(int err);

+/* $Id: upnpreplyparse.c,v 1.19 2015/07/15 10:29:11 nanard Exp $ */

+ * (c) 2006-2015 Thomas Bernard

+ struct NameValueParserData * data = (struct NameValueParserData *)d;

+ data->topelt = 1;

+ data->cdata = NULL;

+ data->cdatalen = 0;

+NameValueParserEndElt(void * d, const char * name, int l)

+ (void)name;

+ (void)l;

+ if(!data->topelt)

+ return;

+ if(strcmp(data->curelt, "NewPortListing") != 0)

+ {

+ int l;

+ /* standard case. Limited to n chars strings */

+ l = data->cdatalen;

+ nv = malloc(sizeof(struct NameValue));

+ if(nv == NULL)

+ {

+ /* malloc error */

+#ifdef DEBUG

+ fprintf(stderr, "%s: error allocating memory",

+ "NameValueParserEndElt");

+#endif /* DEBUG */

+ return;

+ }

+ if(l>=(int)sizeof(nv->value))

+ l = sizeof(nv->value) - 1;

+ strncpy(nv->name, data->curelt, 64);

+ nv->name[63] = '\0';

+ if(data->cdata != NULL)

+ {

+ memcpy(nv->value, data->cdata, l);

+ nv->value[l] = '\0';

+ }

+ else

+ {

+ nv->value[0] = '\0';

+ }

+ nv->l_next = data->l_head; /* insert in list */

+ data->l_head = nv;

+ }

+ data->cdata = NULL;

+ data->cdatalen = 0;

+ data->topelt = 0;

+}

+

+static void

+NameValueParserGetData(void * d, const char * datas, int l)

+{

+ struct NameValueParserData * data = (struct NameValueParserData *)d;

+#ifdef DEBUG

+ fprintf(stderr, "%s: error allocating memory",

+ "NameValueParserGetData");

+#endif /* DEBUG */

+ /* standard case. */

+ data->cdata = datas;

+ data->cdatalen = l;

+ struct xmlparser parser;

+ data->l_head = NULL;

+ /* init xmlparser object */

+ parser.xmlstart = buffer;

+ parser.xmlsize = bufsize;

+ parser.data = data;

+ parser.starteltfunc = NameValueParserStartElt;

+ parser.endeltfunc = NameValueParserEndElt;

+ parser.datafunc = NameValueParserGetData;

+ parsexml(&parser);

+ while((nv = pdata->l_head) != NULL)

+ pdata->l_head = nv->l_next;

+char *

+ for(nv = pdata->l_head;

+ nv = nv->l_next)

+/* debug all-in-one function

+ for(nv = pdata.l_head;

+ nv = nv->l_next)

+#endif /* DEBUG */

+/* $Id: upnpreplyparse.h,v 1.19 2014/10/27 16:33:19 nanard Exp $ */

+ * (c) 2006-2013 Thomas Bernard

+#ifndef UPNPREPLYPARSE_H_INCLUDED

+#define UPNPREPLYPARSE_H_INCLUDED

+ struct NameValue * l_next;

+ char name[64];

+ char value[128];

+ struct NameValue * l_head;

+ char curelt[64];

+ int topelt;

+ const char * cdata;

+ int cdatalen;

+#if 0

+#endif