Annotation of embedaddon/miniupnpd/miniupnpc-libevent/miniupnpc-libevent.c, revision 1.1
1.1 ! misho 1: /* $Id: miniupnpc-libevent.c,v 1.27 2015/07/22 13:51:09 nanard Exp $ */
! 2: /* miniupnpc-libevent
! 3: * Copyright (c) 2008-2016, Thomas BERNARD <miniupnp@free.fr>
! 4: * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
! 5: *
! 6: * Permission to use, copy, modify, and/or distribute this software for any
! 7: * purpose with or without fee is hereby granted, provided that the above
! 8: * copyright notice and this permission notice appear in all copies.
! 9: *
! 10: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
! 11: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
! 12: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
! 13: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
! 14: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
! 15: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
! 16: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */
! 17: #include <stdlib.h>
! 18: #include <string.h>
! 19: #include <sys/types.h>
! 20: #include <sys/socket.h>
! 21: #include <netinet/in.h>
! 22: #include <arpa/inet.h>
! 23: #include <net/if.h>
! 24: #include <stdio.h>
! 25: #include <event2/event.h>
! 26: #include <event2/buffer.h>
! 27: /*#include <event2/bufferevent.h>*/
! 28: #include <event2/http.h>
! 29: #ifdef _WIN32
! 30: #include <winsock2.h>
! 31: #include <ws2tcpip.h>
! 32: #include <io.h>
! 33: #define PRINT_SOCKET_ERROR printf
! 34: #define SOCKET_ERROR GetWSALastError()
! 35: #define WOULDBLOCK(err) (err == WSAEWOULDBLOCK)
! 36: #else /* _WIN32 */
! 37: #include <unistd.h>
! 38: #include <errno.h>
! 39: #define closesocket close
! 40: #define PRINT_SOCKET_ERROR perror
! 41: #define SOCKET_ERROR errno
! 42: #define WOULDBLOCK(err) (err == EAGAIN || err == EWOULDBLOCK)
! 43: #endif /* _WIN32 */
! 44: #include "miniupnpc-libevent.h"
! 45: #include "minixml.h"
! 46: #include "igd_desc_parse.h"
! 47: #include "upnpreplyparse.h"
! 48:
! 49: #ifndef MIN
! 50: #define MIN(x,y) (((x)<(y))?(x):(y))
! 51: #endif /* MIN */
! 52:
! 53: #ifndef MAXHOSTNAMELEN
! 54: #define MAXHOSTNAMELEN 64
! 55: #endif /* MAXHOSTNAMELEN */
! 56:
! 57: #define SSDP_PORT 1900
! 58: #define SSDP_MCAST_ADDR "239.255.255.250"
! 59: #define XSTR(s) STR(s)
! 60: #define STR(s) #s
! 61:
! 62: #ifdef DEBUG
! 63: #define debug_printf(...) fprintf(stderr, __VA_ARGS__)
! 64: #else
! 65: #define debug_printf(...) (void)0
! 66: #endif
! 67:
! 68: /* compare the beginning of a string with a constant string */
! 69: #define COMPARE(str, cstr) (0==memcmp(str, cstr, sizeof(cstr) - 1))
! 70:
! 71: /* stuctures */
! 72:
! 73: struct upnp_args {
! 74: const char * elt;
! 75: const char * val;
! 76: };
! 77:
! 78: /* private functions */
! 79:
! 80: static int upnpc_get_desc(upnpc_device_t * p, const char * url);
! 81: static char * build_url_string(const char * urlbase, const char * root_desc_url, const char * controlurl);
! 82:
! 83: /* data */
! 84: static const char * devices_to_search[] = {
! 85: "urn:schemas-upnp-org:device:InternetGatewayDevice:1",
! 86: "urn:schemas-upnp-org:service:WANIPConnection:1",
! 87: "urn:schemas-upnp-org:service:WANPPPConnection:1",
! 88: "upnp:rootdevice",
! 89: 0
! 90: };
! 91:
! 92: #ifdef DEBUG
! 93: static void upnpc_conn_close_cb(struct evhttp_connection * conn, void * data)
! 94: {
! 95: upnpc_device_t * d = (upnpc_device_t *)data;
! 96: debug_printf("%s %p %p\n", __func__, conn, d);
! 97: }
! 98: #endif /* DEBUG */
! 99:
! 100: /* parse_msearch_reply()
! 101: * the last 4 arguments are filled during the parsing :
! 102: * - location/locationsize : "location:" field of the SSDP reply packet
! 103: * - st/stsize : "st:" field of the SSDP reply packet.
! 104: * The strings are NOT null terminated */
! 105: static void
! 106: parse_msearch_reply(const char * reply, int size,
! 107: const char * * location, int * locationsize,
! 108: const char * * st, int * stsize)
! 109: {
! 110: int a, b, i;
! 111: i = 0; /* current character index */
! 112: a = i; /* start of the line */
! 113: b = 0; /* end of the "header" (position of the colon) */
! 114: while(i<size) {
! 115: switch(reply[i]) {
! 116: case ':':
! 117: if(b==0) {
! 118: b = i; /* end of the "header" */
! 119: }
! 120: break;
! 121: case '\x0a':
! 122: case '\x0d':
! 123: if(b!=0) {
! 124: /* skip the colon and white spaces */
! 125: do { b++; } while(reply[b]==' ' && b<i);
! 126: if(0==strncasecmp(reply+a, "location:", 9)) {
! 127: *location = reply+b;
! 128: *locationsize = i-b;
! 129: } else if(0==strncasecmp(reply+a, "st:", 3)) {
! 130: *st = reply+b;
! 131: *stsize = i-b;
! 132: }
! 133: b = 0;
! 134: }
! 135: a = i+1;
! 136: break;
! 137: default:
! 138: break;
! 139: }
! 140: i++;
! 141: }
! 142: }
! 143:
! 144: static void upnpc_send_ssdp_msearch(evutil_socket_t s, short events, upnpc_t * p)
! 145: {
! 146: /* envoyer les packets de M-SEARCH discovery sur le socket ssdp */
! 147: int n;
! 148: char bufr[1024];
! 149: struct sockaddr_in addr;
! 150: unsigned int mx = 2;
! 151: static const char MSearchMsgFmt[] =
! 152: "M-SEARCH * HTTP/1.1\r\n"
! 153: "HOST: " SSDP_MCAST_ADDR ":" XSTR(SSDP_PORT) "\r\n"
! 154: "ST: %s\r\n"
! 155: "MAN: \"ssdp:discover\"\r\n"
! 156: "MX: %u\r\n"
! 157: "\r\n";
! 158: (void)p;
! 159: (void)events;
! 160:
! 161: memset(&addr, 0, sizeof(struct sockaddr_in));
! 162: addr.sin_family = AF_INET;
! 163: addr.sin_port = htons(SSDP_PORT);
! 164: addr.sin_addr.s_addr = inet_addr(SSDP_MCAST_ADDR);
! 165: n = snprintf(bufr, sizeof(bufr),
! 166: MSearchMsgFmt, devices_to_search[p->discover_device_index++], mx);
! 167: debug_printf("%s: %s", __func__, bufr);
! 168: n = sendto(s, bufr, n, 0,
! 169: (struct sockaddr *)&addr, sizeof(struct sockaddr_in));
! 170: if (n < 0) {
! 171: PRINT_SOCKET_ERROR("sendto");
! 172: }
! 173: }
! 174:
! 175: static int upnpc_set_root_desc_location(upnpc_device_t * d, const char * location, int locationsize)
! 176: {
! 177: char * tmp;
! 178: tmp = realloc(d->root_desc_location, locationsize + 1);
! 179: if(tmp == NULL) {
! 180: return -1;
! 181: }
! 182: memcpy(tmp, location, locationsize);
! 183: tmp[locationsize] = '\0';
! 184: d->root_desc_location = tmp;
! 185: return 0;
! 186: }
! 187:
! 188: static upnpc_device_t * upnpc_find_device_with_location(upnpc_t * p, const char * location, int locationsize)
! 189: {
! 190: upnpc_device_t * d;
! 191: for(d = p->devices; d != NULL; d = d->next) {
! 192: if(d->root_desc_location
! 193: && ((int)strlen(d->root_desc_location) == locationsize)
! 194: && (0 == memcmp(location, d->root_desc_location, locationsize)))
! 195: return d;
! 196: }
! 197: return NULL;
! 198: }
! 199:
! 200: static void upnpc_receive_and_parse_ssdp(evutil_socket_t s, short events, upnpc_t * p)
! 201: {
! 202: char bufr[2048];
! 203: ssize_t len;
! 204:
! 205: if(events == EV_TIMEOUT) {
! 206: /* nothing received ... */
! 207: debug_printf("%s() TIMEOUT\n", __func__);
! 208: if(!devices_to_search[p->discover_device_index]) {
! 209: debug_printf("*** NO MORE DEVICES TO SEARCH ***\n");
! 210: event_del(p->ev_ssdp_recv);
! 211: /* no device found : report error */
! 212: p->ready_cb(UPNPC_ERR_NO_DEVICE_FOUND, p, NULL, p->cb_data);
! 213: } else {
! 214: /* send another SSDP M-SEARCH packet */
! 215: if(event_add(p->ev_ssdp_writable, NULL)) {
! 216: debug_printf("event_add FAILED\n");
! 217: }
! 218: }
! 219: return;
! 220: }
! 221: len = recv(s, bufr, sizeof(bufr), 0);
! 222: debug_printf("input %d bytes\n", (int)len);
! 223: if(len < 0) {
! 224: PRINT_SOCKET_ERROR("recv");
! 225: } else if(len == 0) {
! 226: debug_printf("SSDP socket closed ?\n");
! 227: } else {
! 228: const char * location = NULL;
! 229: int locationsize = 0;
! 230: const char * st = NULL;
! 231: int stsize = 0;
! 232: debug_printf("%.*s", (int)len, bufr);
! 233: parse_msearch_reply(bufr, len, &location, &locationsize, &st, &stsize);
! 234: debug_printf("location = '%.*s'\n", locationsize, location);
! 235: debug_printf("st = '%.*s'\n", stsize, st);
! 236: if(location != NULL) {
! 237: upnpc_device_t * device;
! 238: device = upnpc_find_device_with_location(p, location, locationsize);
! 239: if(device) {
! 240: debug_printf("device already known\n");
! 241: } else {
! 242: device = malloc(sizeof(upnpc_device_t));
! 243: if(device == NULL) {
! 244: debug_printf("Memory allocation error\n");
! 245: return;
! 246: }
! 247: memset(device, 0, sizeof(upnpc_device_t));
! 248: device->parent = p;
! 249: device->next = p->devices;
! 250: p->devices = device;
! 251: if(upnpc_set_root_desc_location(device, location, locationsize) < 0) {
! 252: return;
! 253: }
! 254: if(upnpc_get_desc(device, device->root_desc_location)) {
! 255: debug_printf("FAILED to request device root description\n");
! 256: }
! 257: }
! 258: #if 0
! 259: event_del(p->ev_ssdp_recv); /* stop receiving SSDP responses */
! 260: #endif
! 261: } else {
! 262: /* or do nothing ? */
! 263: debug_printf("no location\n");
! 264: }
! 265: }
! 266: }
! 267:
! 268: static int
! 269: parseURL(const char * url,
! 270: char * hostname, unsigned short * port,
! 271: char * * path, unsigned int * scope_id)
! 272: {
! 273: char * p1, *p2, *p3;
! 274: if(!url)
! 275: return 0;
! 276: p1 = strstr(url, "://");
! 277: if(!p1)
! 278: return 0;
! 279: p1 += 3;
! 280: if( (url[0]!='h') || (url[1]!='t')
! 281: ||(url[2]!='t') || (url[3]!='p'))
! 282: return 0;
! 283: memset(hostname, 0, MAXHOSTNAMELEN + 1);
! 284: if(*p1 == '[') {
! 285: /* IP v6 : http://[2a00:1450:8002::6a]/path/abc */
! 286: char * scope;
! 287: scope = strchr(p1, '%');
! 288: p2 = strchr(p1, ']');
! 289: if(p2 && scope && scope < p2 && scope_id) {
! 290: /* parse scope */
! 291: #ifdef IF_NAMESIZE
! 292: char tmp[IF_NAMESIZE];
! 293: int l;
! 294: scope++;
! 295: /* "%25" is just '%' in URL encoding */
! 296: if(scope[0] == '2' && scope[1] == '5')
! 297: scope += 2; /* skip "25" */
! 298: l = p2 - scope;
! 299: if(l >= IF_NAMESIZE)
! 300: l = IF_NAMESIZE - 1;
! 301: memcpy(tmp, scope, l);
! 302: tmp[l] = '\0';
! 303: *scope_id = if_nametoindex(tmp);
! 304: if(*scope_id == 0) {
! 305: *scope_id = (unsigned int)strtoul(tmp, NULL, 10);
! 306: }
! 307: #else /* IF_NAMESIZE */
! 308: /* under windows, scope is numerical */
! 309: char tmp[8];
! 310: int l;
! 311: scope++;
! 312: /* "%25" is just '%' in URL encoding */
! 313: if(scope[0] == '2' && scope[1] == '5')
! 314: scope += 2; /* skip "25" */
! 315: l = p2 - scope;
! 316: if(l >= (int)sizeof(tmp))
! 317: l = sizeof(tmp) - 1;
! 318: memcpy(tmp, scope, l);
! 319: tmp[l] = '\0';
! 320: *scope_id = (unsigned int)strtoul(tmp, NULL, 10);
! 321: #endif /* IF_NAMESIZE */
! 322: }
! 323: p3 = strchr(p1, '/');
! 324: if(p2 && p3) {
! 325: p2++;
! 326: strncpy(hostname, p1, MIN(MAXHOSTNAMELEN, (int)(p2-p1)));
! 327: if(*p2 == ':') {
! 328: *port = 0;
! 329: p2++;
! 330: while( (*p2 >= '0') && (*p2 <= '9')) {
! 331: *port *= 10;
! 332: *port += (unsigned short)(*p2 - '0');
! 333: p2++;
! 334: }
! 335: } else {
! 336: *port = 80;
! 337: }
! 338: *path = p3;
! 339: return 1;
! 340: }
! 341: }
! 342: p2 = strchr(p1, ':');
! 343: p3 = strchr(p1, '/');
! 344: if(!p3)
! 345: return 0;
! 346: if(!p2 || (p2>p3)) {
! 347: strncpy(hostname, p1, MIN(MAXHOSTNAMELEN, (int)(p3-p1)));
! 348: *port = 80;
! 349: } else {
! 350: strncpy(hostname, p1, MIN(MAXHOSTNAMELEN, (int)(p2-p1)));
! 351: *port = 0;
! 352: p2++;
! 353: while( (*p2 >= '0') && (*p2 <= '9')) {
! 354: *port *= 10;
! 355: *port += (unsigned short)(*p2 - '0');
! 356: p2++;
! 357: }
! 358: }
! 359: *path = p3;
! 360: return 1;
! 361: }
! 362:
! 363: static void upnpc_desc_received(struct evhttp_request * req, void * pvoid)
! 364: {
! 365: size_t len;
! 366: unsigned char * data;
! 367: struct evbuffer * input_buffer;
! 368: struct IGDdatas igd;
! 369: struct xmlparser parser;
! 370: upnpc_device_t * d = (upnpc_device_t *)pvoid;
! 371:
! 372: if(req == NULL) {
! 373: debug_printf("%s(%p, %p) NULL argument !\n", __func__, req, pvoid);
! 374: return;
! 375: }
! 376: input_buffer = evhttp_request_get_input_buffer(req);
! 377: len = evbuffer_get_length(input_buffer);
! 378: data = evbuffer_pullup(input_buffer, len);
! 379: debug_printf("%s %d (%d bytes)\n", __func__, evhttp_request_get_response_code(req), (int)len);
! 380: if(evhttp_request_get_response_code(req) != HTTP_OK) {
! 381: d->parent->ready_cb(evhttp_request_get_response_code(req), d->parent, d, d->parent->cb_data);
! 382: return;
! 383: }
! 384: if(data == NULL) {
! 385: d->parent->ready_cb(UPNPC_ERR_ROOT_DESC_ERROR, d->parent, d, d->parent->cb_data);
! 386: return;
! 387: }
! 388: debug_printf("%.*s\n", (int)len, (char *)data);
! 389:
! 390: memset(&igd, 0, sizeof(struct IGDdatas));
! 391: memset(&parser, 0, sizeof(struct xmlparser));
! 392: parser.xmlstart = (char *)data;
! 393: parser.xmlsize = len;
! 394: parser.data = &igd;
! 395: parser.starteltfunc = IGDstartelt;
! 396: parser.endeltfunc = IGDendelt;
! 397: parser.datafunc = IGDdata;
! 398: parsexml(&parser);
! 399: #ifdef DEBUG
! 400: printIGD(&igd);
! 401: #endif /* DEBUG */
! 402: d->control_conn_url = build_url_string(igd.urlbase, d->root_desc_location, igd.first.controlurl);
! 403: d->event_conn_url = build_url_string(igd.urlbase, d->root_desc_location, igd.first.eventsuburl);
! 404: d->conn_service_type = strdup(igd.first.servicetype);
! 405: d->control_cif_url = build_url_string(igd.urlbase, d->root_desc_location, igd.CIF.controlurl);
! 406: d->event_cif_url = build_url_string(igd.urlbase, d->root_desc_location, igd.CIF.eventsuburl);
! 407: d->cif_service_type = strdup(igd.CIF.servicetype);
! 408: debug_printf("control_conn_url='%s'\n (service_type='%s')\n",
! 409: d->control_conn_url, d->conn_service_type);
! 410: debug_printf("event_conn_url='%s'\n", d->event_conn_url);
! 411: debug_printf("control_cif_url='%s'\n (service_type='%s')\n",
! 412: d->control_cif_url, d->cif_service_type);
! 413:
! 414: if((d->cif_service_type == NULL)
! 415: || (d->cif_service_type[0] == '\0')
! 416: || (!COMPARE(d->cif_service_type, "urn:schemas-upnp-org:service:WANCommonInterfaceConfig:"))) {
! 417: d->parent->ready_cb(UPNPC_ERR_NOT_IGD, d->parent, d, d->parent->cb_data);
! 418: } else {
! 419: d->state |= UPNPC_DEVICE_GETSTATUS;
! 420: upnpc_get_status_info(d);
! 421: }
! 422: }
! 423:
! 424: #ifdef ENABLE_UPNP_EVENTS
! 425: static void upnpc_subscribe_response(struct evhttp_request * req, void * pvoid)
! 426: {
! 427: size_t len;
! 428: unsigned char * data;
! 429: struct evbuffer * input_buffer;
! 430: upnpc_device_t * d = (upnpc_device_t *)pvoid;
! 431:
! 432: if(req == NULL) {
! 433: debug_printf("%s(%p, %p) NULL argument !\n", __func__, req, pvoid);
! 434: return;
! 435: }
! 436: input_buffer = evhttp_request_get_input_buffer(req);
! 437: len = evbuffer_get_length(input_buffer);
! 438: data = evbuffer_pullup(input_buffer, len);
! 439: debug_printf("%s %d (%d bytes)\n", __func__, evhttp_request_get_response_code(req), (int)len);
! 440: d->state &= ~UPNPC_DEVICE_SOAP_REQ;
! 441: if(evhttp_request_get_response_code(req) != HTTP_OK) {
! 442: /* TODO ERROR */
! 443: } else {
! 444: const char * sid;
! 445: struct evkeyvalq * headers = evhttp_request_get_input_headers(req);
! 446: sid = evhttp_find_header(headers, "sid");
! 447: debug_printf("SID=%s\n", sid);
! 448: if(sid) {
! 449: if(d->event_conn_sid)
! 450: free(d->event_conn_sid);
! 451: d->event_conn_sid = strdup(sid);
! 452: }
! 453: }
! 454: }
! 455: #endif /* ENABLE_UPNP_EVENTS */
! 456:
! 457: static void upnpc_soap_response(struct evhttp_request * req, void * pvoid)
! 458: {
! 459: size_t len;
! 460: unsigned char * data;
! 461: struct evbuffer * input_buffer;
! 462: upnpc_device_t * d = (upnpc_device_t *)pvoid;
! 463: int code;
! 464:
! 465: if(req == NULL) {
! 466: debug_printf("%s(%p, %p) NULL argument !\n", __func__, req, pvoid);
! 467: return;
! 468: }
! 469: code = evhttp_request_get_response_code(req);
! 470: input_buffer = evhttp_request_get_input_buffer(req);
! 471: len = evbuffer_get_length(input_buffer);
! 472: data = evbuffer_pullup(input_buffer, len);
! 473: debug_printf("%s %d (%d bytes)\n", __func__, code, (int)len);
! 474: debug_printf("%.*s\n", (int)len, (char *)data);
! 475: if(data == NULL)
! 476: return;
! 477:
! 478: ClearNameValueList(&d->soap_response_data);
! 479: ParseNameValue((char *)data, (int)len,
! 480: &d->soap_response_data);
! 481: d->state &= ~UPNPC_DEVICE_SOAP_REQ;
! 482: if(d->state & UPNPC_DEVICE_READY) {
! 483: d->parent->soap_cb(code, d->parent, d, d->parent->cb_data);
! 484: } else if(d->state & UPNPC_DEVICE_GETSTATUS) {
! 485: const char * connection_status;
! 486: d->state &= ~UPNPC_DEVICE_GETSTATUS;
! 487: connection_status = GetValueFromNameValueList(&d->soap_response_data, "NewConnectionStatus");
! 488: d->state |= UPNPC_DEVICE_READY;
! 489: if((code == 200) && connection_status && (0 == strcmp("Connected", connection_status))) {
! 490: d->parent->ready_cb(code, d->parent, d, d->parent->cb_data);
! 491: d->state |= UPNPC_DEVICE_CONNECTED;
! 492: event_del(d->parent->ev_ssdp_recv);
! 493: } else {
! 494: d->parent->ready_cb(UPNPC_ERR_NOT_CONNECTED, d->parent, d, d->parent->cb_data);
! 495: }
! 496: }
! 497: }
! 498:
! 499: static int upnpc_get_desc(upnpc_device_t * d, const char * url)
! 500: {
! 501: char hostname[MAXHOSTNAMELEN+1];
! 502: char hostname_port[MAXHOSTNAMELEN+1+6];
! 503: unsigned short port;
! 504: char * path;
! 505: unsigned int scope_id;
! 506: struct evhttp_request * req;
! 507: struct evkeyvalq * headers;
! 508:
! 509: /* if(d->root_desc_location == NULL) {
! 510: return -1;
! 511: } */
! 512: if(!parseURL(url/*d->root_desc_location*/, hostname, &port,
! 513: &path, &scope_id)) {
! 514: return -1;
! 515: }
! 516: if(port != 80)
! 517: snprintf(hostname_port, sizeof(hostname_port), "%s:%hu", hostname, port);
! 518: else
! 519: strncpy(hostname_port, hostname, sizeof(hostname_port));
! 520: if(d->desc_conn == NULL) {
! 521: d->desc_conn = evhttp_connection_base_new(d->parent->base, NULL, hostname, port);
! 522: }
! 523: #ifdef DEBUG
! 524: evhttp_connection_set_closecb(d->desc_conn, upnpc_conn_close_cb, d);
! 525: #endif /* DEBUG */
! 526: /*evhttp_connection_set_timeout(p->desc_conn, 600);*/
! 527: req = evhttp_request_new(upnpc_desc_received/*callback*/, d);
! 528: headers = evhttp_request_get_output_headers(req);
! 529: evhttp_add_header(headers, "Host", hostname_port);
! 530: evhttp_add_header(headers, "Connection", "close");
! 531: /*evhttp_add_header(headers, "User-Agent", "***");*/
! 532: return evhttp_make_request(d->desc_conn, req, EVHTTP_REQ_GET, path);
! 533: }
! 534:
! 535: static char * build_url_string(const char * urlbase, const char * root_desc_url, const char * controlurl)
! 536: {
! 537: int l, n;
! 538: char * s;
! 539: const char * base;
! 540: char * p;
! 541: /* if controlurl is an absolute url, return it */
! 542: if(0 == memcmp("http://", controlurl, 7))
! 543: return strdup(controlurl);
! 544: base = (urlbase[0] == '\0') ? root_desc_url : urlbase;
! 545: n = strlen(base);
! 546: if(n > 7) {
! 547: p = strchr(base + 7, '/');
! 548: if(p)
! 549: n = p - base;
! 550: }
! 551: l = n + strlen(controlurl) + 1;
! 552: if(controlurl[0] != '/')
! 553: l++;
! 554: s = malloc(l);
! 555: if(s == NULL) return NULL;
! 556: memcpy(s, base, n);
! 557: if(controlurl[0] != '/')
! 558: s[n++] = '/';
! 559: memcpy(s + n, controlurl, l - n);
! 560: return s;
! 561: }
! 562:
! 563: #define SOAPPREFIX "s"
! 564: #define SERVICEPREFIX "u"
! 565: #define SERVICEPREFIX2 'u'
! 566:
! 567: static int upnpc_send_soap_request(upnpc_device_t * p, const char * url,
! 568: const char * service,
! 569: const char * method,
! 570: const struct upnp_args * args, int arg_count)
! 571: {
! 572: char action[128];
! 573: char * body;
! 574: const char fmt_soap[] =
! 575: "<?xml version=\"1.0\"?>\r\n"
! 576: "<" SOAPPREFIX ":Envelope "
! 577: "xmlns:" SOAPPREFIX "=\"http://schemas.xmlsoap.org/soap/envelope/\" "
! 578: SOAPPREFIX ":encodingStyle=\"http://schemas.xmlsoap.org/soap/encoding/\">"
! 579: "<" SOAPPREFIX ":Body>"
! 580: "<" SERVICEPREFIX ":%s xmlns:" SERVICEPREFIX "=\"%s\">"
! 581: "%s"
! 582: "</" SERVICEPREFIX ":%s>"
! 583: "</" SOAPPREFIX ":Body></" SOAPPREFIX ":Envelope>"
! 584: "\r\n";
! 585: int body_len;
! 586: char hostname[MAXHOSTNAMELEN+1];
! 587: char hostname_port[MAXHOSTNAMELEN+1+6];
! 588: unsigned short port;
! 589: char * path;
! 590: unsigned int scope_id;
! 591: char * args_xml = NULL;
! 592: struct evhttp_request * req;
! 593: struct evkeyvalq * headers;
! 594: struct evbuffer * buffer;
! 595:
! 596: if(p->state & UPNPC_DEVICE_SOAP_REQ) {
! 597: debug_printf("%s: another SOAP request in progress\n", __func__);
! 598: return UPNPC_ERR_REQ_IN_PROGRESS;
! 599: }
! 600:
! 601: if(arg_count > 0) {
! 602: int i;
! 603: size_t l, n;
! 604: for(i = 0, l = 0; i < arg_count; i++) {
! 605: /* <ELT>VAL</ELT> */
! 606: l += strlen(args[i].elt) * 2 + strlen(args[i].val) + 5;
! 607: }
! 608: args_xml = malloc(++l);
! 609: if(args_xml == NULL) {
! 610: return -1;
! 611: }
! 612: for(i = 0, n = 0; i < arg_count && n < l; i++) {
! 613: /* <ELT>VAL</ELT> */
! 614: n += snprintf(args_xml + n, l - n, "<%s>%s</%s>",
! 615: args[i].elt, args[i].val, args[i].elt);
! 616: }
! 617: }
! 618:
! 619: body_len = snprintf(NULL, 0, fmt_soap, method, service, args_xml?args_xml:"", method);
! 620: body = malloc(body_len + 1);
! 621: if(body == NULL) {
! 622: free(args_xml);
! 623: return -1;
! 624: }
! 625: if(snprintf(body, body_len + 1, fmt_soap, method, service, args_xml?args_xml:"", method) != body_len) {
! 626: debug_printf("%s: snprintf() returned strange value...\n", __func__);
! 627: }
! 628: free(args_xml);
! 629: args_xml = NULL;
! 630: if(!parseURL(url, hostname, &port, &path, &scope_id)) {
! 631: free(body);
! 632: return -1;
! 633: }
! 634: if(port != 80)
! 635: snprintf(hostname_port, sizeof(hostname_port), "%s:%hu", hostname, port);
! 636: else
! 637: strncpy(hostname_port, hostname, sizeof(hostname_port));
! 638: snprintf(action, sizeof(action), "\"%s#%s\"", service, method);
! 639: if(p->soap_conn == NULL) {
! 640: p->soap_conn = evhttp_connection_base_new(p->parent->base, NULL, hostname, port);
! 641: }
! 642: req = evhttp_request_new(upnpc_soap_response, p);
! 643: headers = evhttp_request_get_output_headers(req);
! 644: buffer = evhttp_request_get_output_buffer(req);
! 645: evhttp_add_header(headers, "Host", hostname_port);
! 646: evhttp_add_header(headers, "SOAPAction", action);
! 647: evhttp_add_header(headers, "Content-Type", "text/xml");
! 648: /*evhttp_add_header(headers, "User-Agent", "***");*/
! 649: /*evhttp_add_header(headers, "Cache-Control", "no-cache");*/
! 650: /*evhttp_add_header(headers, "Pragma", "no-cache");*/
! 651: evbuffer_add(buffer, body, body_len);
! 652: evhttp_make_request(p->soap_conn, req, EVHTTP_REQ_POST, path);
! 653: free(body);
! 654: p->state |= UPNPC_DEVICE_SOAP_REQ;
! 655: return 0;
! 656: }
! 657:
! 658: #ifdef ENABLE_UPNP_EVENTS
! 659: #define EVHTTP_REQ_NOTIFY ((EVHTTP_REQ_MAX) << 1)
! 660: #define EVHTTP_REQ_SUBSCRIBE ((EVHTTP_REQ_NOTIFY) << 1)
! 661: #define EVHTTP_REQ_UNSUBSCRIBE ((EVHTTP_REQ_SUBSCRIBE) << 1)
! 662: static int ext_methods_cb(struct evhttp_ext_method *p)
! 663: {
! 664: if(p == NULL)
! 665: return -1;
! 666: if(p->method != NULL) {
! 667: if(strcmp(p->method, "NOTIFY") == 0) {
! 668: p->type = EVHTTP_REQ_NOTIFY;
! 669: p->flags = EVHTTP_METHOD_HAS_BODY;
! 670: } else if(strcmp(p->method, "SUBSCRIBE") == 0) {
! 671: p->type = EVHTTP_REQ_SUBSCRIBE;
! 672: } else if(strcmp(p->method, "UNSUBSCRIBE") == 0) {
! 673: p->type = EVHTTP_REQ_UNSUBSCRIBE;
! 674: } else {
! 675: return -1;
! 676: }
! 677: } else switch(p->type) {
! 678: case EVHTTP_REQ_NOTIFY:
! 679: p->method = "NOTIFY";
! 680: p->flags = EVHTTP_METHOD_HAS_BODY;
! 681: break;
! 682: case EVHTTP_REQ_SUBSCRIBE:
! 683: p->method = "SUBSCRIBE";
! 684: break;
! 685: case EVHTTP_REQ_UNSUBSCRIBE:
! 686: p->method = "UNSUBSCRIBE";
! 687: break;
! 688: default:
! 689: return -1;
! 690: }
! 691: return 0;
! 692: };
! 693:
! 694: void upnpc_event_conn_req(struct evhttp_request * req, void * data)
! 695: {
! 696: size_t len;
! 697: char * xml_data;
! 698: struct evbuffer * input_buffer;
! 699: struct evkeyvalq * headers;
! 700: const char * sid;
! 701: const char * nts;
! 702: const char * nt;
! 703: const char * seq;
! 704: struct NameValueParserData parsed_data;
! 705: struct NameValue * nv;
! 706: upnpc_device_t * d = (upnpc_device_t *)data;
! 707:
! 708: debug_printf("%s(%p, %p)\n", __func__, req, d);
! 709: headers = evhttp_request_get_input_headers(req);
! 710: input_buffer = evhttp_request_get_input_buffer(req);
! 711: len = evbuffer_get_length(input_buffer);
! 712: sid = evhttp_find_header(headers, "sid");
! 713: nts = evhttp_find_header(headers, "nts");
! 714: nt = evhttp_find_header(headers, "nt");
! 715: seq = evhttp_find_header(headers, "seq");
! 716: if(len == 0 || nts == NULL || nt == NULL) {
! 717: /* 400 Bad request :
! 718: * The NT or NTS header field is missing
! 719: * or the request is malformed. */
! 720: evhttp_send_reply(req, 400, "Bad Request", NULL);
! 721: return;
! 722: }
! 723: debug_printf("SID=%s NTS=%s SEQ=%s\n", sid, nts, seq);
! 724: if(sid == NULL || 0 != strcmp(sid, d->event_conn_sid)
! 725: || 0 != strcmp(nt, "upnp:event") || 0 != strcmp(nts, "upnp:propchange")) {
! 726: /* 412 Precondition Failed :
! 727: * An SID does not correspond to a known, un-expired subscription
! 728: * or the NT header field does not equal upnp:event
! 729: * or the NTS header field does not equal upnp:propchange
! 730: * or the SID header field is missing or empty. */
! 731: evhttp_send_reply(req, 412, "Precondition Failed", NULL);
! 732: return;
! 733: }
! 734: xml_data = (char *)evbuffer_pullup(input_buffer, len);
! 735: /*debug_printf("%.*s\n", len, xml_data);*/
! 736: ParseNameValue(xml_data, len, &parsed_data);
! 737: for(nv = parsed_data.l_head; nv != NULL; nv = nv->l_next) {
! 738: if(d->parent->value_changed_cb) {
! 739: d->parent->value_changed_cb(d->parent, d, d->parent->cb_data, d->conn_service_type, nv->name, nv->value);
! 740: } else {
! 741: debug_printf("%s=%s\n", nv->name, nv->value);
! 742: }
! 743: }
! 744: ClearNameValueList(&parsed_data);
! 745: /* response : 200 OK */
! 746: evhttp_send_reply(req, 200, "OK", NULL);
! 747: }
! 748: #endif /* ENABLE_UPNP_EVENTS */
! 749:
! 750: /* public functions */
! 751: int upnpc_init(upnpc_t * p, struct event_base * base, const char * multicastif,
! 752: upnpc_callback_fn ready_cb, upnpc_callback_fn soap_cb, void * cb_data)
! 753: {
! 754: int opt = 1;
! 755: struct sockaddr_in addr;
! 756:
! 757: if(p == NULL || base == NULL)
! 758: return UPNPC_ERR_INVALID_ARGS;
! 759: memset(p, 0, sizeof(upnpc_t)); /* clean everything */
! 760: p->base = base;
! 761: p->ready_cb = ready_cb;
! 762: p->soap_cb = soap_cb;
! 763: p->cb_data = cb_data;
! 764: p->ttl = 2;
! 765: /* open the socket for SSDP */
! 766: p->ssdp_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
! 767: if(p->ssdp_socket < 0) {
! 768: return UPNPC_ERR_SOCKET_FAILED;
! 769: }
! 770: /* set multicast TTL */
! 771: if(setsockopt(p->ssdp_socket, IPPROTO_IP, IP_MULTICAST_TTL, &p->ttl, sizeof(p->ttl)) < 0)
! 772: {
! 773: /* not a fatal error */
! 774: debug_printf("setsockopt(%d, ..., IP_MULTICAST_TTL, ...) FAILED\n", p->ssdp_socket);
! 775: }
! 776: /* set REUSEADDR */
! 777: #ifdef _WIN32
! 778: if(setsockopt(p->ssdp_socket, SOL_SOCKET, SO_REUSEADDR, (const char *)&opt, sizeof(opt)) < 0) {
! 779: #else /* _WIN32 */
! 780: if(setsockopt(p->ssdp_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) < 0) {
! 781: #endif /* _WIN32 */
! 782: /* non fatal error ! */
! 783: debug_printf("setsockopt(%d, SOL_SOCKET, SO_REUSEADDR, ...) FAILED\n", p->ssdp_socket);
! 784: }
! 785: if(evutil_make_socket_nonblocking(p->ssdp_socket) < 0) {
! 786: debug_printf("evutil_make_socket_nonblocking FAILED\n");
! 787: }
! 788:
! 789: /* receive address */
! 790: memset(&addr, 0, sizeof(struct sockaddr_in));
! 791: addr.sin_family = AF_INET;
! 792: addr.sin_addr.s_addr = INADDR_ANY;
! 793: /*addr.sin_port = htons(SSDP_PORT);*/
! 794:
! 795: if(multicastif) {
! 796: struct in_addr mc_if;
! 797: mc_if.s_addr = inet_addr(multicastif);
! 798: addr.sin_addr.s_addr = mc_if.s_addr;
! 799: if(setsockopt(p->ssdp_socket, IPPROTO_IP, IP_MULTICAST_IF, (const char *)&mc_if, sizeof(mc_if)) < 0) {
! 800: PRINT_SOCKET_ERROR("setsockopt");
! 801: /* non fatal error ! */
! 802: }
! 803: }
! 804:
! 805: /* bind the socket to the ssdp address in order to receive responses */
! 806: if(bind(p->ssdp_socket, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) != 0) {
! 807: close(p->ssdp_socket);
! 808: return UPNPC_ERR_BIND_FAILED;
! 809: }
! 810: return UPNPC_OK;
! 811: }
! 812:
! 813: int upnpc_start(upnpc_t * p)
! 814: {
! 815: struct timeval timeout;
! 816: if(p == NULL || p->base == NULL)
! 817: return UPNPC_ERR_INVALID_ARGS;
! 818: /* event on SSDP */
! 819: p->ev_ssdp_recv = event_new(p->base, p->ssdp_socket,
! 820: EV_READ|EV_PERSIST,
! 821: (event_callback_fn)upnpc_receive_and_parse_ssdp, p);
! 822: timeout.tv_sec = 3;
! 823: timeout.tv_usec = 0;
! 824: if(event_add(p->ev_ssdp_recv, &timeout)) {
! 825: debug_printf("event_add FAILED\n");
! 826: }
! 827: p->ev_ssdp_writable = event_new(p->base, p->ssdp_socket,
! 828: EV_WRITE,
! 829: (event_callback_fn)upnpc_send_ssdp_msearch, p);
! 830: if(event_add(p->ev_ssdp_writable, NULL)) {
! 831: debug_printf("event_add FAILED\n");
! 832: }
! 833: return UPNPC_OK;
! 834: }
! 835:
! 836: int upnpc_set_local_address(upnpc_t * p, const char * address, uint16_t port)
! 837: {
! 838: if(!p || !address) return UPNPC_ERR_INVALID_ARGS;
! 839: p->local_address = strdup(address); /* TODO check error */
! 840: p->local_port = port;
! 841: return UPNPC_OK;
! 842: }
! 843:
! 844: #ifdef ENABLE_UPNP_EVENTS
! 845: int upnpc_set_event_callback(upnpc_t * p, upnpc_event_callback_fn cb)
! 846: {
! 847: if(!p || !cb) return UPNPC_ERR_INVALID_ARGS;
! 848: p->value_changed_cb = cb;
! 849: return UPNPC_OK;
! 850: }
! 851: #endif /* ENABLE_UPNP_EVENTS */
! 852:
! 853: static void upnpc_device_finalize(upnpc_device_t * d)
! 854: {
! 855: d->state = 0;
! 856: free(d->root_desc_location);
! 857: d->root_desc_location = NULL;
! 858: free(d->control_cif_url);
! 859: d->control_cif_url = NULL;
! 860: free(d->event_cif_url);
! 861: d->event_cif_url = NULL;
! 862: free(d->cif_service_type);
! 863: d->cif_service_type = NULL;
! 864: free(d->control_conn_url);
! 865: d->control_conn_url = NULL;
! 866: free(d->event_conn_url);
! 867: d->event_conn_url = NULL;
! 868: free(d->conn_service_type);
! 869: d->conn_service_type = NULL;
! 870: if(d->desc_conn) {
! 871: evhttp_connection_free(d->desc_conn);
! 872: d->desc_conn = NULL;
! 873: }
! 874: if(d->soap_conn) {
! 875: evhttp_connection_free(d->soap_conn);
! 876: d->soap_conn = NULL;
! 877: }
! 878: ClearNameValueList(&d->soap_response_data);
! 879: #ifdef ENABLE_UPNP_EVENTS
! 880: free(d->event_conn_sid);
! 881: d->event_conn_sid = NULL;
! 882: #endif /* ENABLE_UPNP_EVENTS */
! 883: }
! 884:
! 885: int upnpc_finalize(upnpc_t * p)
! 886: {
! 887: if(!p) return UPNPC_ERR_INVALID_ARGS;
! 888: p->discover_device_index = 0;
! 889: if(p->ssdp_socket >= 0) {
! 890: close(p->ssdp_socket);
! 891: p->ssdp_socket = -1;
! 892: }
! 893: if(p->ev_ssdp_recv) {
! 894: event_free(p->ev_ssdp_recv);
! 895: p->ev_ssdp_recv = NULL;
! 896: }
! 897: if(p->ev_ssdp_writable) {
! 898: event_free(p->ev_ssdp_writable);
! 899: p->ev_ssdp_writable = NULL;
! 900: }
! 901: while(p->devices != NULL) {
! 902: upnpc_device_t * d = p->devices;
! 903: upnpc_device_finalize(d);
! 904: p->devices = d->next;
! 905: free(d);
! 906: }
! 907: free(p->local_address);
! 908: p->local_address = NULL;
! 909: #ifdef ENABLE_UPNP_EVENTS
! 910: if(p->http_server) {
! 911: evhttp_free(p->http_server);
! 912: p->http_server = NULL;
! 913: }
! 914: #endif /* ENABLE_UPNP_EVENTS */
! 915: return UPNPC_OK;
! 916: }
! 917:
! 918: #ifdef ENABLE_UPNP_EVENTS
! 919: int upnpc_event_subscribe(upnpc_device_t * p)
! 920: {
! 921: char hostname[MAXHOSTNAMELEN+1];
! 922: char hostname_port[MAXHOSTNAMELEN+1+6];
! 923: unsigned short port;
! 924: char * path;
! 925: unsigned int scope_id;
! 926: struct evhttp_request * req;
! 927: struct evkeyvalq * headers;
! 928: char callback_header[7+15+1+5+9+2+1];
! 929:
! 930: if(p->parent->http_server == NULL) {
! 931: /* HTTP server to receive event notifications */
! 932: p->parent->http_server = evhttp_new(p->parent->base);
! 933: if(p->parent->http_server == NULL) {
! 934: debug_printf("evhttp_new() FAILED\n");
! 935: return -1;
! 936: }
! 937: evhttp_set_ext_method_cmp(p->parent->http_server, ext_methods_cb);
! 938: evhttp_set_allowed_methods(p->parent->http_server, EVHTTP_REQ_NOTIFY);
! 939: evhttp_set_cb(p->parent->http_server, "/evt_conn", upnpc_event_conn_req, p);
! 940: if(evhttp_bind_socket(p->parent->http_server, p->parent->local_address, p->parent->local_port) < 0) {
! 941: debug_printf("evhttp_bind_socket() FAILED\n");
! 942: return -1;
! 943: }
! 944: }
! 945: /*if(!parseURL(p->event_cif_url, hostname, &port, &path, &scope_id)) {*/
! 946: if(!parseURL(p->event_conn_url, hostname, &port, &path, &scope_id)) {
! 947: return -1;
! 948: }
! 949: if(port != 80)
! 950: snprintf(hostname_port, sizeof(hostname_port), "%s:%hu", hostname, port);
! 951: else
! 952: strncpy(hostname_port, hostname, sizeof(hostname_port));
! 953: if(p->soap_conn == NULL) {
! 954: p->soap_conn = evhttp_connection_base_new(p->parent->base, NULL, hostname, port);
! 955: }
! 956: evhttp_connection_set_ext_method_cmp(p->soap_conn, ext_methods_cb);
! 957: req = evhttp_request_new(upnpc_subscribe_response, p);
! 958: headers = evhttp_request_get_output_headers(req);
! 959: /*buffer = evhttp_request_get_output_buffer(req);*/
! 960: evhttp_add_header(headers, "Host", hostname_port);
! 961: /*evhttp_add_header(headers, "User-Agent", "***");*/
! 962: snprintf(callback_header, sizeof(callback_header), "<http://%s:%hu/evt_conn>", p->parent->local_address, p->parent->local_port);
! 963: evhttp_add_header(headers, "Callback", callback_header);
! 964: evhttp_add_header(headers, "NT", "upnp:event");
! 965: /*evhttp_add_header(headers, "NTS", "");*/
! 966: evhttp_add_header(headers, "Timeout", "3600");
! 967: /*evbuffer_add(buffer, body, body_len);*/
! 968: evhttp_make_request(p->soap_conn, req, EVHTTP_REQ_SUBSCRIBE, path);
! 969: p->state |= UPNPC_DEVICE_SOAP_REQ;
! 970: return 0;
! 971: }
! 972: #endif /* ENABLE_UPNP_EVENTS */
! 973:
! 974: int upnpc_get_external_ip_address(upnpc_device_t * p)
! 975: {
! 976: return upnpc_send_soap_request(p, p->control_conn_url,
! 977: p->conn_service_type/*"urn:schemas-upnp-org:service:WANIPConnection:1"*/,
! 978: "GetExternalIPAddress", NULL, 0);
! 979: }
! 980:
! 981: int upnpc_get_link_layer_max_rate(upnpc_device_t * p)
! 982: {
! 983: return upnpc_send_soap_request(p, p->control_cif_url,
! 984: p->cif_service_type/*"urn:schemas-upnp-org:service:WANCommonInterfaceConfig:1"*/,
! 985: "GetCommonLinkProperties", NULL, 0);
! 986: }
! 987:
! 988: int upnpc_delete_port_mapping(upnpc_device_t * p,
! 989: const char * remote_host, unsigned short ext_port,
! 990: const char * proto)
! 991: {
! 992: struct upnp_args args[3];
! 993: char ext_port_str[8];
! 994:
! 995: if(proto == NULL || ext_port == 0)
! 996: return UPNPC_ERR_INVALID_ARGS;
! 997: snprintf(ext_port_str, sizeof(ext_port_str), "%hu", ext_port);
! 998: args[0].elt = "NewRemoteHost";
! 999: args[0].val = remote_host?remote_host:"";
! 1000: args[1].elt = "NewExternalPort";
! 1001: args[1].val = ext_port_str;
! 1002: args[2].elt = "NewProtocol";
! 1003: args[2].val = proto;
! 1004: return upnpc_send_soap_request(p, p->control_conn_url,
! 1005: p->conn_service_type,/*"urn:schemas-upnp-org:service:WANIPConnection:1",*/
! 1006: "DeletePortMapping",
! 1007: args, 3);
! 1008: }
! 1009:
! 1010: int upnpc_add_port_mapping(upnpc_device_t * p,
! 1011: const char * remote_host, unsigned short ext_port,
! 1012: unsigned short int_port, const char * int_client,
! 1013: const char * proto, const char * description,
! 1014: unsigned int lease_duration)
! 1015: {
! 1016: struct upnp_args args[8];
! 1017: char lease_duration_str[16];
! 1018: char int_port_str[8];
! 1019: char ext_port_str[8];
! 1020:
! 1021: if(int_client == NULL || int_port == 0 || ext_port == 0 || proto == NULL)
! 1022: return UPNPC_ERR_INVALID_ARGS;
! 1023: snprintf(lease_duration_str, sizeof(lease_duration_str), "%u", lease_duration);
! 1024: snprintf(int_port_str, sizeof(int_port_str), "%hu", int_port);
! 1025: snprintf(ext_port_str, sizeof(ext_port_str), "%hu", ext_port);
! 1026: args[0].elt = "NewRemoteHost";
! 1027: args[0].val = remote_host?remote_host:"";
! 1028: args[1].elt = "NewExternalPort";
! 1029: args[1].val = ext_port_str;
! 1030: args[2].elt = "NewProtocol";
! 1031: args[2].val = proto;
! 1032: args[3].elt = "NewInternalPort";
! 1033: args[3].val = int_port_str;
! 1034: args[4].elt = "NewInternalClient";
! 1035: args[4].val = int_client;
! 1036: args[5].elt = "NewEnabled";
! 1037: args[5].val = "1";
! 1038: args[6].elt = "NewPortMappingDescription";
! 1039: args[6].val = description?description:"miniupnpc-libevent";
! 1040: args[7].elt = "NewLeaseDuration";
! 1041: args[7].val = lease_duration_str;
! 1042: return upnpc_send_soap_request(p, p->control_conn_url,
! 1043: p->conn_service_type/*"urn:schemas-upnp-org:service:WANIPConnection:1"*/,
! 1044: "AddPortMapping",
! 1045: args, 8);
! 1046: }
! 1047:
! 1048: int upnpc_get_status_info(upnpc_device_t * p)
! 1049: {
! 1050: return upnpc_send_soap_request(p, p->control_conn_url,
! 1051: p->conn_service_type/*"urn:schemas-upnp-org:service:WANIPConnection:1"*/,
! 1052: "GetStatusInfo", NULL, 0);
! 1053: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to miniupnpc-libevent.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / miniupnpd / miniupnpc-libevent