Annotation of embedaddon/miniupnpd/minissdpd/minissdpd.c, revision 1.1
1.1 ! misho 1: /* $Id: minissdpd.c,v 1.61 2021/11/04 23:27:28 nanard Exp $ */
! 2: /* vim: tabstop=4 shiftwidth=4 noexpandtab
! 3: * MiniUPnP project
! 4: * (c) 2007-2022 Thomas Bernard
! 5: * website : http://miniupnp.free.fr/ or https://miniupnp.tuxfamily.org/
! 6: * This software is subject to the conditions detailed
! 7: * in the LICENCE file provided within the distribution */
! 8:
! 9: #include "config.h"
! 10:
! 11: #include <stdlib.h>
! 12: #include <stdio.h>
! 13: #include <string.h>
! 14: #include <signal.h>
! 15: #include <errno.h>
! 16: #include <sys/time.h>
! 17: #include <sys/types.h>
! 18: #include <sys/socket.h>
! 19: #include <unistd.h>
! 20: #include <netinet/in.h>
! 21: #include <arpa/inet.h>
! 22: #include <syslog.h>
! 23: #include <ctype.h>
! 24: #include <time.h>
! 25: #include <sys/queue.h>
! 26: /* for chmod : */
! 27: #include <sys/stat.h>
! 28: /* unix sockets */
! 29: #include <sys/un.h>
! 30: /* for getpwnam() and getgrnam() */
! 31: #if 0
! 32: #include <pwd.h>
! 33: #include <grp.h>
! 34: #endif
! 35:
! 36: /* LOG_PERROR does not exist on Solaris */
! 37: #ifndef LOG_PERROR
! 38: #define LOG_PERROR 0
! 39: #endif /* LOG_PERROR */
! 40:
! 41: #include "getifaddr.h"
! 42: #include "upnputils.h"
! 43: #include "openssdpsocket.h"
! 44: #include "daemonize.h"
! 45: #include "codelength.h"
! 46: #include "ifacewatch.h"
! 47: #include "minissdpdtypes.h"
! 48: #include "asyncsendto.h"
! 49:
! 50: #define SET_MAX(max, x) if((x) > (max)) (max) = (x)
! 51: #ifndef MIN
! 52: #define MIN(x,y) (((x)<(y))?(x):(y))
! 53: #endif
! 54:
! 55: /* current request management structure */
! 56: struct reqelem {
! 57: int socket;
! 58: int is_notify; /* has subscribed to notifications */
! 59: LIST_ENTRY(reqelem) entries;
! 60: unsigned char * output_buffer;
! 61: int output_buffer_offset;
! 62: int output_buffer_len;
! 63: };
! 64:
! 65: /* device data structures */
! 66: struct header {
! 67: const char * p; /* string pointer */
! 68: int l; /* string length */
! 69: };
! 70:
! 71: #define HEADER_NT 0
! 72: #define HEADER_USN 1
! 73: #define HEADER_LOCATION 2
! 74:
! 75: struct device {
! 76: struct device * next;
! 77: time_t t; /* validity time */
! 78: struct header headers[3]; /* NT, USN and LOCATION headers */
! 79: char data[];
! 80: };
! 81:
! 82: /* Services stored for answering to M-SEARCH */
! 83: struct service {
! 84: char * st; /* Service type */
! 85: char * usn; /* Unique identifier */
! 86: char * server; /* Server string */
! 87: char * location; /* URL */
! 88: LIST_ENTRY(service) entries;
! 89: };
! 90: LIST_HEAD(servicehead, service) servicelisthead;
! 91:
! 92: #define NTS_SSDP_ALIVE 1
! 93: #define NTS_SSDP_BYEBYE 2
! 94: #define NTS_SSDP_UPDATE 3
! 95:
! 96: /* request types */
! 97: enum request_type {
! 98: MINISSDPD_GET_VERSION = 0,
! 99: MINISSDPD_SEARCH_TYPE = 1,
! 100: MINISSDPD_SEARCH_USN = 2,
! 101: MINISSDPD_SEARCH_ALL = 3,
! 102: MINISSDPD_SUBMIT = 4,
! 103: MINISSDPD_NOTIF = 5
! 104: };
! 105:
! 106: /* discovered device list kept in memory */
! 107: struct device * devlist = 0;
! 108:
! 109: /* bootid and configid */
! 110: unsigned int upnp_bootid = 1;
! 111: unsigned int upnp_configid = 1337;
! 112:
! 113: /* LAN interfaces/addresses */
! 114: struct lan_addr_list lan_addrs;
! 115:
! 116: /* connected clients */
! 117: LIST_HEAD(reqstructhead, reqelem) reqlisthead;
! 118:
! 119: /* functions prototypes */
! 120:
! 121: #define NOTIF_NEW 1
! 122: #define NOTIF_UPDATE 2
! 123: #define NOTIF_REMOVE 3
! 124: static void
! 125: sendNotifications(int notif_type, const struct device * dev, const struct service * serv);
! 126:
! 127: /* functions */
! 128:
! 129: /* parselanaddr()
! 130: * parse address with mask
! 131: * ex: 192.168.1.1/24 or 192.168.1.1/255.255.255.0
! 132: *
! 133: * Can also use the interface name (ie eth0)
! 134: *
! 135: * return value :
! 136: * 0 : ok
! 137: * -1 : error */
! 138: static int
! 139: parselanaddr(struct lan_addr_s * lan_addr, const char * str)
! 140: {
! 141: const char * p;
! 142: int n;
! 143: char tmp[16];
! 144:
! 145: memset(lan_addr, 0, sizeof(struct lan_addr_s));
! 146: p = str;
! 147: while(*p && *p != '/' && !isspace(*p))
! 148: p++;
! 149: n = p - str;
! 150: if(!isdigit(str[0]) && n < (int)sizeof(lan_addr->ifname)) {
! 151: /* not starting with a digit : suppose it is an interface name */
! 152: memcpy(lan_addr->ifname, str, n);
! 153: lan_addr->ifname[n] = '\0';
! 154: if(getifaddr(lan_addr->ifname, lan_addr->str, sizeof(lan_addr->str),
! 155: &lan_addr->addr, &lan_addr->mask) < 0)
! 156: goto parselan_error;
! 157: /*printf("%s => %s\n", lan_addr->ifname, lan_addr->str);*/
! 158: } else {
! 159: if(n>15)
! 160: goto parselan_error;
! 161: memcpy(lan_addr->str, str, n);
! 162: lan_addr->str[n] = '\0';
! 163: if(!inet_aton(lan_addr->str, &lan_addr->addr))
! 164: goto parselan_error;
! 165: }
! 166: if(*p == '/') {
! 167: const char * q = ++p;
! 168: while(*p && isdigit(*p))
! 169: p++;
! 170: if(*p=='.') {
! 171: /* parse mask in /255.255.255.0 format */
! 172: while(*p && (*p=='.' || isdigit(*p)))
! 173: p++;
! 174: n = p - q;
! 175: if(n>15)
! 176: goto parselan_error;
! 177: memcpy(tmp, q, n);
! 178: tmp[n] = '\0';
! 179: if(!inet_aton(tmp, &lan_addr->mask))
! 180: goto parselan_error;
! 181: } else {
! 182: /* it is a /24 format */
! 183: int nbits = atoi(q);
! 184: if(nbits > 32 || nbits < 0)
! 185: goto parselan_error;
! 186: lan_addr->mask.s_addr = htonl(nbits ? (0xffffffffu << (32 - nbits)) : 0);
! 187: }
! 188: } else if(lan_addr->mask.s_addr == 0) {
! 189: /* by default, networks are /24 */
! 190: lan_addr->mask.s_addr = htonl(0xffffff00u);
! 191: }
! 192: #ifdef ENABLE_IPV6
! 193: if(lan_addr->ifname[0] != '\0') {
! 194: lan_addr->index = if_nametoindex(lan_addr->ifname);
! 195: if(lan_addr->index == 0)
! 196: fprintf(stderr, "Cannot get index for network interface %s\n",
! 197: lan_addr->ifname);
! 198: } else {
! 199: fprintf(stderr,
! 200: "Error: please specify LAN network interface by name instead of IPv4 address : %s\n",
! 201: str);
! 202: return -1;
! 203: }
! 204: #endif /* ENABLE_IPV6 */
! 205: return 0;
! 206: parselan_error:
! 207: fprintf(stderr, "Error parsing address/mask (or interface name) : %s\n",
! 208: str);
! 209: return -1;
! 210: }
! 211:
! 212: static int
! 213: write_buffer(struct reqelem * req)
! 214: {
! 215: if(req->output_buffer && req->output_buffer_len > 0) {
! 216: int n = write(req->socket,
! 217: req->output_buffer + req->output_buffer_offset,
! 218: req->output_buffer_len);
! 219: if(n >= 0) {
! 220: req->output_buffer_offset += n;
! 221: req->output_buffer_len -= n;
! 222: } else if(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN) {
! 223: return 0;
! 224: }
! 225: return n;
! 226: } else {
! 227: return 0;
! 228: }
! 229: }
! 230:
! 231: static int
! 232: add_to_buffer(struct reqelem * req, const unsigned char * data, int len)
! 233: {
! 234: unsigned char * tmp;
! 235: if(req->output_buffer_offset > 0) {
! 236: memmove(req->output_buffer, req->output_buffer + req->output_buffer_offset, req->output_buffer_len);
! 237: req->output_buffer_offset = 0;
! 238: }
! 239: tmp = realloc(req->output_buffer, req->output_buffer_len + len);
! 240: if(tmp == NULL) {
! 241: syslog(LOG_ERR, "%s: failed to allocate %d bytes",
! 242: __func__, req->output_buffer_len + len);
! 243: return -1;
! 244: }
! 245: req->output_buffer = tmp;
! 246: memcpy(req->output_buffer + req->output_buffer_len, data, len);
! 247: req->output_buffer_len += len;
! 248: return len;
! 249: }
! 250:
! 251: static int
! 252: write_or_buffer(struct reqelem * req, const unsigned char * data, int len)
! 253: {
! 254: if(write_buffer(req) < 0)
! 255: return -1;
! 256: if(req->output_buffer && req->output_buffer_len > 0) {
! 257: return add_to_buffer(req, data, len);
! 258: } else {
! 259: int n = write(req->socket, data, len);
! 260: if(n == len)
! 261: return len;
! 262: if(n < 0) {
! 263: if(errno == EINTR || errno == EWOULDBLOCK || errno == EAGAIN) {
! 264: n = add_to_buffer(req, data, len);
! 265: if(n < 0) return n;
! 266: } else {
! 267: return n;
! 268: }
! 269: } else {
! 270: n = add_to_buffer(req, data + n, len - n);
! 271: if(n < 0) return n;
! 272: }
! 273: }
! 274: return len;
! 275: }
! 276:
! 277: static const char *
! 278: nts_to_str(int nts)
! 279: {
! 280: switch(nts)
! 281: {
! 282: case NTS_SSDP_ALIVE:
! 283: return "ssdp:alive";
! 284: case NTS_SSDP_BYEBYE:
! 285: return "ssdp:byebye";
! 286: case NTS_SSDP_UPDATE:
! 287: return "ssdp:update";
! 288: }
! 289: return "unknown";
! 290: }
! 291:
! 292: /* updateDevice() :
! 293: * adds or updates the device to the list.
! 294: * return value :
! 295: * 0 : the device was updated (or nothing done)
! 296: * 1 : the device was new */
! 297: static int
! 298: updateDevice(const struct header * headers, time_t t)
! 299: {
! 300: struct device ** pp = &devlist;
! 301: struct device * p = *pp; /* = devlist; */
! 302: while(p)
! 303: {
! 304: if( p->headers[HEADER_NT].l == headers[HEADER_NT].l
! 305: && (0==memcmp(p->headers[HEADER_NT].p, headers[HEADER_NT].p, headers[HEADER_NT].l))
! 306: && p->headers[HEADER_USN].l == headers[HEADER_USN].l
! 307: && (0==memcmp(p->headers[HEADER_USN].p, headers[HEADER_USN].p, headers[HEADER_USN].l)) )
! 308: {
! 309: /*printf("found! %d\n", (int)(t - p->t));*/
! 310: syslog(LOG_DEBUG, "device updated : %.*s", headers[HEADER_USN].l, headers[HEADER_USN].p);
! 311: p->t = t;
! 312: /* update Location ! */
! 313: if(headers[HEADER_LOCATION].l > p->headers[HEADER_LOCATION].l)
! 314: {
! 315: struct device * tmp;
! 316: tmp = realloc(p, sizeof(struct device)
! 317: + headers[0].l+headers[1].l+headers[2].l);
! 318: if(!tmp) /* allocation error */
! 319: {
! 320: syslog(LOG_ERR, "updateDevice() : memory allocation error");
! 321: *pp = p->next; /* remove "p" from the list */
! 322: free(p);
! 323: return 0;
! 324: }
! 325: p = tmp;
! 326: *pp = p;
! 327: }
! 328: memcpy(p->data + p->headers[0].l + p->headers[1].l,
! 329: headers[2].p, headers[2].l);
! 330: /* TODO : check p->headers[HEADER_LOCATION].l */
! 331: return 0;
! 332: }
! 333: pp = &p->next;
! 334: p = *pp; /* p = p->next; */
! 335: }
! 336: syslog(LOG_INFO, "new device discovered : %.*s",
! 337: headers[HEADER_USN].l, headers[HEADER_USN].p);
! 338: /* add */
! 339: {
! 340: char * pc;
! 341: int i;
! 342: p = malloc( sizeof(struct device)
! 343: + headers[0].l+headers[1].l+headers[2].l );
! 344: if(!p) {
! 345: syslog(LOG_ERR, "updateDevice(): cannot allocate memory");
! 346: return -1;
! 347: }
! 348: p->next = devlist;
! 349: p->t = t;
! 350: pc = p->data;
! 351: for(i = 0; i < 3; i++)
! 352: {
! 353: p->headers[i].p = pc;
! 354: p->headers[i].l = headers[i].l;
! 355: memcpy(pc, headers[i].p, headers[i].l);
! 356: pc += headers[i].l;
! 357: }
! 358: devlist = p;
! 359: sendNotifications(NOTIF_NEW, p, NULL);
! 360: }
! 361: return 1;
! 362: }
! 363:
! 364: /* removeDevice() :
! 365: * remove a device from the list
! 366: * return value :
! 367: * 0 : no device removed
! 368: * -1 : device removed */
! 369: static int
! 370: removeDevice(const struct header * headers)
! 371: {
! 372: struct device ** pp = &devlist;
! 373: struct device * p = *pp; /* = devlist */
! 374: while(p)
! 375: {
! 376: if( p->headers[HEADER_NT].l == headers[HEADER_NT].l
! 377: && (0==memcmp(p->headers[HEADER_NT].p, headers[HEADER_NT].p, headers[HEADER_NT].l))
! 378: && p->headers[HEADER_USN].l == headers[HEADER_USN].l
! 379: && (0==memcmp(p->headers[HEADER_USN].p, headers[HEADER_USN].p, headers[HEADER_USN].l)) )
! 380: {
! 381: syslog(LOG_INFO, "remove device : %.*s", headers[HEADER_USN].l, headers[HEADER_USN].p);
! 382: sendNotifications(NOTIF_REMOVE, p, NULL);
! 383: *pp = p->next;
! 384: free(p);
! 385: return -1;
! 386: }
! 387: pp = &p->next;
! 388: p = *pp; /* p = p->next; */
! 389: }
! 390: syslog(LOG_WARNING, "device not found for removing : %.*s", headers[HEADER_USN].l, headers[HEADER_USN].p);
! 391: return 0;
! 392: }
! 393:
! 394: /* sent notifications to client having subscribed */
! 395: static void
! 396: sendNotifications(int notif_type, const struct device * dev, const struct service * serv)
! 397: {
! 398: struct reqelem * req;
! 399: unsigned int m;
! 400: unsigned char rbuf[RESPONSE_BUFFER_SIZE];
! 401: unsigned char * rp;
! 402:
! 403: for(req = reqlisthead.lh_first; req; req = req->entries.le_next) {
! 404: if(!req->is_notify) continue;
! 405: rbuf[0] = '\xff'; /* special code for notifications */
! 406: rbuf[1] = (unsigned char)notif_type;
! 407: rbuf[2] = 0;
! 408: rp = rbuf + 3;
! 409: if(dev) {
! 410: /* response :
! 411: * 1 - Location
! 412: * 2 - NT (device/service type)
! 413: * 3 - usn */
! 414: m = dev->headers[HEADER_LOCATION].l;
! 415: CODELENGTH(m, rp);
! 416: memcpy(rp, dev->headers[HEADER_LOCATION].p, dev->headers[HEADER_LOCATION].l);
! 417: rp += dev->headers[HEADER_LOCATION].l;
! 418: m = dev->headers[HEADER_NT].l;
! 419: CODELENGTH(m, rp);
! 420: memcpy(rp, dev->headers[HEADER_NT].p, dev->headers[HEADER_NT].l);
! 421: rp += dev->headers[HEADER_NT].l;
! 422: m = dev->headers[HEADER_USN].l;
! 423: CODELENGTH(m, rp);
! 424: memcpy(rp, dev->headers[HEADER_USN].p, dev->headers[HEADER_USN].l);
! 425: rp += dev->headers[HEADER_USN].l;
! 426: rbuf[2]++;
! 427: }
! 428: if(serv) {
! 429: /* response :
! 430: * 1 - Location
! 431: * 2 - NT (device/service type)
! 432: * 3 - usn */
! 433: m = strlen(serv->location);
! 434: CODELENGTH(m, rp);
! 435: memcpy(rp, serv->location, m);
! 436: rp += m;
! 437: m = strlen(serv->st);
! 438: CODELENGTH(m, rp);
! 439: memcpy(rp, serv->st, m);
! 440: rp += m;
! 441: m = strlen(serv->usn);
! 442: CODELENGTH(m, rp);
! 443: memcpy(rp, serv->usn, m);
! 444: rp += m;
! 445: rbuf[2]++;
! 446: }
! 447: if(rbuf[2] > 0) {
! 448: if(write_or_buffer(req, rbuf, rp - rbuf) < 0) {
! 449: syslog(LOG_ERR, "(s=%d) write: %m", req->socket);
! 450: /*goto error;*/
! 451: }
! 452: }
! 453: }
! 454: }
! 455:
! 456: /* SendSSDPMSEARCHResponse() :
! 457: * build and send response to M-SEARCH SSDP packets. */
! 458: static void
! 459: SendSSDPMSEARCHResponse(int s, const struct sockaddr * sockname,
! 460: const char * st, size_t st_len, const char * usn,
! 461: const char * server, const char * location)
! 462: {
! 463: int l, n;
! 464: char buf[1024];
! 465: socklen_t sockname_len;
! 466: /*
! 467: * follow guideline from document "UPnP Device Architecture 1.0"
! 468: * uppercase is recommended.
! 469: * DATE: is recommended
! 470: * SERVER: OS/ver UPnP/1.0 miniupnpd/1.0
! 471: * - check what to put in the 'Cache-Control' header
! 472: *
! 473: * have a look at the document "UPnP Device Architecture v1.1 */
! 474: l = snprintf(buf, sizeof(buf), "HTTP/1.1 200 OK\r\n"
! 475: "CACHE-CONTROL: max-age=120\r\n"
! 476: /*"DATE: ...\r\n"*/
! 477: "ST: %.*s\r\n"
! 478: "USN: %s\r\n"
! 479: "EXT:\r\n"
! 480: "SERVER: %s\r\n"
! 481: "LOCATION: %s\r\n"
! 482: "OPT: \"http://schemas.upnp.org/upnp/1/0/\"; ns=01\r\n" /* UDA v1.1 */
! 483: "01-NLS: %u\r\n" /* same as BOOTID. UDA v1.1 */
! 484: "BOOTID.UPNP.ORG: %u\r\n" /* UDA v1.1 */
! 485: "CONFIGID.UPNP.ORG: %u\r\n" /* UDA v1.1 */
! 486: "\r\n",
! 487: (int)st_len, st, usn,
! 488: server, location,
! 489: upnp_bootid, upnp_bootid, upnp_configid);
! 490: #ifdef ENABLE_IPV6
! 491: sockname_len = (sockname->sa_family == PF_INET6)
! 492: ? sizeof(struct sockaddr_in6)
! 493: : sizeof(struct sockaddr_in);
! 494: #else /* ENABLE_IPV6 */
! 495: sockname_len = sizeof(struct sockaddr_in);
! 496: #endif /* ENABLE_IPV6 */
! 497: n = sendto_or_schedule(s, buf, l, 0, sockname, sockname_len);
! 498: if(n < 0) {
! 499: syslog(LOG_ERR, "%s: sendto(udp): %m", __func__);
! 500: }
! 501: }
! 502:
! 503: /* Process M-SEARCH requests */
! 504: static void
! 505: processMSEARCH(int s, const char * st, size_t st_len,
! 506: const struct sockaddr * addr)
! 507: {
! 508: struct service * serv;
! 509: #ifdef ENABLE_IPV6
! 510: char buf[64];
! 511: #endif /* ENABLE_IPV6 */
! 512:
! 513: if(!st || st_len==0)
! 514: return;
! 515: #ifdef ENABLE_IPV6
! 516: sockaddr_to_string(addr, buf, sizeof(buf));
! 517: syslog(LOG_INFO, "SSDP M-SEARCH from %s ST:%.*s",
! 518: buf, (int)st_len, st);
! 519: #else /* ENABLE_IPV6 */
! 520: syslog(LOG_INFO, "SSDP M-SEARCH from %s:%d ST: %.*s",
! 521: inet_ntoa(((const struct sockaddr_in *)addr)->sin_addr),
! 522: ntohs(((const struct sockaddr_in *)addr)->sin_port),
! 523: (int)st_len, st);
! 524: #endif /* ENABLE_IPV6 */
! 525: if(st_len==8 && (0==memcmp(st, "ssdp:all", 8))) {
! 526: /* send a response for all services */
! 527: for(serv = servicelisthead.lh_first;
! 528: serv;
! 529: serv = serv->entries.le_next) {
! 530: SendSSDPMSEARCHResponse(s, addr,
! 531: serv->st, strlen(serv->st), serv->usn,
! 532: serv->server, serv->location);
! 533: }
! 534: } else if(st_len > 5 && (0==memcmp(st, "uuid:", 5))) {
! 535: /* find a matching UUID value */
! 536: for(serv = servicelisthead.lh_first;
! 537: serv;
! 538: serv = serv->entries.le_next) {
! 539: if(0 == strncmp(serv->usn, st, st_len)) {
! 540: SendSSDPMSEARCHResponse(s, addr,
! 541: serv->st, strlen(serv->st), serv->usn,
! 542: serv->server, serv->location);
! 543: }
! 544: }
! 545: } else {
! 546: size_t l;
! 547: int st_ver = 0;
! 548: char atoi_buffer[8];
! 549:
! 550: /* remove version at the end of the ST string */
! 551: for (l = st_len; l > 0; l--) {
! 552: if (st[l-1] == ':') {
! 553: memset(atoi_buffer, 0, sizeof(atoi_buffer));
! 554: memcpy(atoi_buffer, st + l, MIN((sizeof(atoi_buffer) - 1), st_len - l));
! 555: st_ver = atoi(atoi_buffer);
! 556: break;
! 557: }
! 558: }
! 559: if (l == 0)
! 560: l = st_len;
! 561: /* answer for each matching service */
! 562: /* From UPnP Device Architecture v1.1 :
! 563: * 1.3.2 [...] Updated versions of device and service types
! 564: * are REQUIRED to be full backward compatible with
! 565: * previous versions. Devices MUST respond to M-SEARCH
! 566: * requests for any supported version. For example, if a
! 567: * device implements “urn:schemas-upnporg:service:xyz:2”,
! 568: * it MUST respond to search requests for both that type
! 569: * and “urn:schemas-upnp-org:service:xyz:1”. The response
! 570: * MUST specify the same version as was contained in the
! 571: * search request. [...] */
! 572: for(serv = servicelisthead.lh_first;
! 573: serv;
! 574: serv = serv->entries.le_next) {
! 575: if(0 == strncmp(serv->st, st, l)) {
! 576: syslog(LOG_DEBUG, "Found matching service : %s %s (v %d)", serv->st, serv->location, st_ver);
! 577: SendSSDPMSEARCHResponse(s, addr,
! 578: st, st_len, serv->usn,
! 579: serv->server, serv->location);
! 580: }
! 581: }
! 582: }
! 583: }
! 584:
! 585: /**
! 586: * helper function.
! 587: * reject any non ASCII or non printable character.
! 588: */
! 589: static int
! 590: containsForbiddenChars(const unsigned char * p, int len)
! 591: {
! 592: while(len > 0) {
! 593: if(*p < ' ' || *p >= '\x7f')
! 594: return 1;
! 595: p++;
! 596: len--;
! 597: }
! 598: return 0;
! 599: }
! 600:
! 601: #define METHOD_MSEARCH 1
! 602: #define METHOD_NOTIFY 2
! 603:
! 604: /* ParseSSDPPacket() :
! 605: * parse a received SSDP Packet and call
! 606: * updateDevice() or removeDevice() as needed
! 607: * return value :
! 608: * -1 : a device was removed
! 609: * 0 : no device removed nor added
! 610: * 1 : a device was added. */
! 611: static int
! 612: ParseSSDPPacket(int s, const char * p, ssize_t n,
! 613: const struct sockaddr * addr,
! 614: const char * searched_device)
! 615: {
! 616: const char * linestart;
! 617: const char * lineend;
! 618: const char * nameend;
! 619: const char * valuestart;
! 620: struct header headers[3];
! 621: int i, r = 0;
! 622: int methodlen;
! 623: int nts = -1;
! 624: int method = -1;
! 625: unsigned int lifetime = 180; /* 3 minutes by default */
! 626: const char * st = NULL;
! 627: int st_len = 0;
! 628:
! 629: /* first check from what subnet is the sender */
! 630: if(get_lan_for_peer(addr) == NULL) {
! 631: char addr_str[64];
! 632: sockaddr_to_string(addr, addr_str, sizeof(addr_str));
! 633: syslog(LOG_WARNING, "peer %s is not from a LAN",
! 634: addr_str);
! 635: return 0;
! 636: }
! 637:
! 638: /* do the parsing */
! 639: memset(headers, 0, sizeof(headers));
! 640: for(methodlen = 0;
! 641: methodlen < n && (isalpha(p[methodlen]) || p[methodlen]=='-');
! 642: methodlen++);
! 643: if(methodlen==8 && 0==memcmp(p, "M-SEARCH", 8))
! 644: method = METHOD_MSEARCH;
! 645: else if(methodlen==6 && 0==memcmp(p, "NOTIFY", 6))
! 646: method = METHOD_NOTIFY;
! 647: else if(methodlen==4 && 0==memcmp(p, "HTTP", 4)) {
! 648: /* answer to a M-SEARCH => process it as a NOTIFY
! 649: * with NTS: ssdp:alive */
! 650: method = METHOD_NOTIFY;
! 651: nts = NTS_SSDP_ALIVE;
! 652: }
! 653: linestart = p;
! 654: while(linestart < p + n - 2) {
! 655: /* start parsing the line : detect line end */
! 656: lineend = linestart;
! 657: while(lineend < p + n && *lineend != '\n' && *lineend != '\r')
! 658: lineend++;
! 659: /*printf("line: '%.*s'\n", lineend - linestart, linestart);*/
! 660: /* detect name end : ':' character */
! 661: nameend = linestart;
! 662: while(nameend < lineend && *nameend != ':')
! 663: nameend++;
! 664: /* detect value */
! 665: if(nameend < lineend)
! 666: valuestart = nameend + 1;
! 667: else
! 668: valuestart = nameend;
! 669: /* trim spaces */
! 670: while(valuestart < lineend && isspace(*valuestart))
! 671: valuestart++;
! 672: /* suppress leading " if needed */
! 673: if(valuestart < lineend && *valuestart=='\"')
! 674: valuestart++;
! 675: if(nameend > linestart && valuestart < lineend) {
! 676: int l = nameend - linestart; /* header name length */
! 677: int m = lineend - valuestart; /* header value length */
! 678: /* suppress tailing spaces */
! 679: while(m>0 && isspace(valuestart[m-1]))
! 680: m--;
! 681: /* suppress tailing ' if needed */
! 682: if(m>0 && valuestart[m-1] == '\"')
! 683: m--;
! 684: i = -1;
! 685: /*printf("--%.*s: (%d)%.*s--\n", l, linestart,
! 686: m, m, valuestart);*/
! 687: if(l==2 && 0==strncasecmp(linestart, "nt", 2))
! 688: i = HEADER_NT;
! 689: else if(l==3 && 0==strncasecmp(linestart, "usn", 3))
! 690: i = HEADER_USN;
! 691: else if(l==3 && 0==strncasecmp(linestart, "nts", 3)) {
! 692: if(m==10 && 0==strncasecmp(valuestart, "ssdp:alive", 10))
! 693: nts = NTS_SSDP_ALIVE;
! 694: else if(m==11 && 0==strncasecmp(valuestart, "ssdp:byebye", 11))
! 695: nts = NTS_SSDP_BYEBYE;
! 696: else if(m==11 && 0==strncasecmp(valuestart, "ssdp:update", 11))
! 697: nts = NTS_SSDP_UPDATE;
! 698: }
! 699: else if(l==8 && 0==strncasecmp(linestart, "location", 8))
! 700: i = HEADER_LOCATION;
! 701: else if(l==13 && 0==strncasecmp(linestart, "cache-control", 13)) {
! 702: /* parse "name1=value1, name_alone, name2=value2" string */
! 703: const char * name = valuestart; /* name */
! 704: const char * val; /* value */
! 705: int rem = m; /* remaining bytes to process */
! 706: while(rem > 0) {
! 707: val = name;
! 708: while(val < name + rem && *val != '=' && *val != ',')
! 709: val++;
! 710: if(val >= name + rem)
! 711: break;
! 712: if(*val == '=') {
! 713: while(val < name + rem && (*val == '=' || isspace(*val)))
! 714: val++;
! 715: if(val >= name + rem)
! 716: break;
! 717: if(0==strncasecmp(name, "max-age", 7))
! 718: lifetime = (unsigned int)strtoul(val, 0, 0);
! 719: /* move to the next name=value pair */
! 720: while(rem > 0 && *name != ',') {
! 721: rem--;
! 722: name++;
! 723: }
! 724: /* skip spaces */
! 725: while(rem > 0 && (*name == ',' || isspace(*name))) {
! 726: rem--;
! 727: name++;
! 728: }
! 729: } else {
! 730: rem -= (val - name);
! 731: name = val;
! 732: while(rem > 0 && (*name == ',' || isspace(*name))) {
! 733: rem--;
! 734: name++;
! 735: }
! 736: }
! 737: }
! 738: /*syslog(LOG_DEBUG, "**%.*s**%u", m, valuestart, lifetime);*/
! 739: } else if(l==2 && 0==strncasecmp(linestart, "st", 2)) {
! 740: st = valuestart;
! 741: st_len = m;
! 742: if(method == METHOD_NOTIFY)
! 743: i = HEADER_NT; /* it was a M-SEARCH response */
! 744: }
! 745: if(i>=0) {
! 746: headers[i].p = valuestart;
! 747: headers[i].l = m;
! 748: }
! 749: }
! 750: linestart = lineend;
! 751: while((linestart < p + n) && (*linestart == '\n' || *linestart == '\r'))
! 752: linestart++;
! 753: }
! 754: #if 0
! 755: printf("NTS=%d\n", nts);
! 756: for(i=0; i<3; i++) {
! 757: if(headers[i].p)
! 758: printf("%d-'%.*s'\n", i, headers[i].l, headers[i].p);
! 759: }
! 760: #endif
! 761: syslog(LOG_DEBUG,"SSDP request: '%.*s' (%d) %s %s=%.*s",
! 762: methodlen, p, method, nts_to_str(nts),
! 763: (method==METHOD_NOTIFY)?"nt":"st",
! 764: (method==METHOD_NOTIFY)?headers[HEADER_NT].l:st_len,
! 765: (method==METHOD_NOTIFY)?headers[HEADER_NT].p:st);
! 766: switch(method) {
! 767: case METHOD_NOTIFY:
! 768: if(nts==NTS_SSDP_ALIVE || nts==NTS_SSDP_UPDATE) {
! 769: if(headers[HEADER_NT].p && headers[HEADER_USN].p && headers[HEADER_LOCATION].p) {
! 770: /* filter if needed */
! 771: if(searched_device &&
! 772: 0 != memcmp(headers[HEADER_NT].p, searched_device, headers[HEADER_NT].l))
! 773: break;
! 774: r = updateDevice(headers, time(NULL) + lifetime);
! 775: } else {
! 776: syslog(LOG_WARNING, "missing header nt=%p usn=%p location=%p",
! 777: headers[HEADER_NT].p, headers[HEADER_USN].p,
! 778: headers[HEADER_LOCATION].p);
! 779: }
! 780: } else if(nts==NTS_SSDP_BYEBYE) {
! 781: if(headers[HEADER_NT].p && headers[HEADER_USN].p) {
! 782: r = removeDevice(headers);
! 783: } else {
! 784: syslog(LOG_WARNING, "missing header nt=%p usn=%p",
! 785: headers[HEADER_NT].p, headers[HEADER_USN].p);
! 786: }
! 787: }
! 788: break;
! 789: case METHOD_MSEARCH:
! 790: processMSEARCH(s, st, st_len, addr);
! 791: break;
! 792: default:
! 793: {
! 794: char addr_str[64];
! 795: sockaddr_to_string(addr, addr_str, sizeof(addr_str));
! 796: syslog(LOG_WARNING, "method %.*s, don't know what to do (from %s)",
! 797: methodlen, p, addr_str);
! 798: }
! 799: }
! 800: return r;
! 801: }
! 802:
! 803: /* OpenUnixSocket()
! 804: * open the unix socket and call bind() and listen()
! 805: * return -1 in case of error */
! 806: static int
! 807: OpenUnixSocket(const char * path)
! 808: {
! 809: struct sockaddr_un addr;
! 810: int s;
! 811: int rv;
! 812: s = socket(AF_UNIX, SOCK_STREAM, 0);
! 813: if(s < 0)
! 814: {
! 815: syslog(LOG_ERR, "socket(AF_UNIX): %m");
! 816: return -1;
! 817: }
! 818: /* unlink the socket pseudo file before binding */
! 819: rv = unlink(path);
! 820: if(rv < 0 && errno != ENOENT)
! 821: {
! 822: syslog(LOG_ERR, "unlink(unixsocket, \"%s\"): %m", path);
! 823: close(s);
! 824: return -1;
! 825: }
! 826: addr.sun_family = AF_UNIX;
! 827: strncpy(addr.sun_path, path, sizeof(addr.sun_path));
! 828: if(bind(s, (struct sockaddr *)&addr,
! 829: sizeof(struct sockaddr_un)) < 0)
! 830: {
! 831: syslog(LOG_ERR, "bind(unixsocket, \"%s\"): %m", path);
! 832: close(s);
! 833: return -1;
! 834: }
! 835: else if(listen(s, 5) < 0)
! 836: {
! 837: syslog(LOG_ERR, "listen(unixsocket): %m");
! 838: close(s);
! 839: return -1;
! 840: }
! 841: /* Change rights so everyone can communicate with us */
! 842: if(chmod(path, 0666) < 0)
! 843: {
! 844: syslog(LOG_WARNING, "chmod(\"%s\"): %m", path);
! 845: }
! 846: return s;
! 847: }
! 848:
! 849: static ssize_t processRequestSub(struct reqelem * req, const unsigned char * buf, ssize_t n);
! 850:
! 851: /* processRequest() :
! 852: * process the request coming from a unix socket */
! 853: void processRequest(struct reqelem * req)
! 854: {
! 855: ssize_t n, r;
! 856: unsigned char buf[2048];
! 857: const unsigned char * p;
! 858:
! 859: n = read(req->socket, buf, sizeof(buf));
! 860: if(n<0) {
! 861: if(errno == EINTR || errno == EAGAIN || errno == EWOULDBLOCK)
! 862: return; /* try again later */
! 863: syslog(LOG_ERR, "(s=%d) processRequest(): read(): %m", req->socket);
! 864: goto error;
! 865: }
! 866: if(n==0) {
! 867: syslog(LOG_INFO, "(s=%d) request connection closed", req->socket);
! 868: goto error;
! 869: }
! 870: p = buf;
! 871: while (n > 0)
! 872: {
! 873: r = processRequestSub(req, p, n);
! 874: if (r < 0)
! 875: goto error;
! 876: p += r;
! 877: n -= r;
! 878: }
! 879: return;
! 880: error:
! 881: close(req->socket);
! 882: req->socket = -1;
! 883: }
! 884:
! 885: static ssize_t processRequestSub(struct reqelem * req, const unsigned char * buf, ssize_t n)
! 886: {
! 887: unsigned int l, m;
! 888: unsigned int baselen; /* without the version */
! 889: const unsigned char * p;
! 890: enum request_type type;
! 891: struct device * d = devlist;
! 892: unsigned char rbuf[RESPONSE_BUFFER_SIZE];
! 893: unsigned char * rp;
! 894: unsigned char nrep = 0;
! 895: time_t t;
! 896: struct service * newserv = NULL;
! 897: struct service * serv;
! 898:
! 899: t = time(NULL);
! 900: type = buf[0];
! 901: p = buf + 1;
! 902: DECODELENGTH_CHECKLIMIT(l, p, buf + n);
! 903: if(l > (unsigned)(buf+n-p)) {
! 904: syslog(LOG_WARNING, "bad request (length encoding l=%u n=%u)",
! 905: l, (unsigned)n);
! 906: goto error;
! 907: }
! 908: if(l == 0 && type != MINISSDPD_SEARCH_ALL
! 909: && type != MINISSDPD_GET_VERSION && type != MINISSDPD_NOTIF) {
! 910: syslog(LOG_WARNING, "bad request (length=0, type=%d)", type);
! 911: goto error;
! 912: }
! 913: syslog(LOG_INFO, "(s=%d) request type=%d str='%.*s'",
! 914: req->socket, type, l, p);
! 915: switch(type) {
! 916: case MINISSDPD_GET_VERSION:
! 917: rp = rbuf;
! 918: CODELENGTH((sizeof(MINISSDPD_VERSION) - 1), rp);
! 919: memcpy(rp, MINISSDPD_VERSION, sizeof(MINISSDPD_VERSION) - 1);
! 920: rp += (sizeof(MINISSDPD_VERSION) - 1);
! 921: if(write_or_buffer(req, rbuf, rp - rbuf) < 0) {
! 922: syslog(LOG_ERR, "(s=%d) write: %m", req->socket);
! 923: goto error;
! 924: }
! 925: p += l;
! 926: break;
! 927: case MINISSDPD_SEARCH_TYPE: /* request by type */
! 928: case MINISSDPD_SEARCH_USN: /* request by USN (unique id) */
! 929: case MINISSDPD_SEARCH_ALL: /* everything */
! 930: rp = rbuf+1;
! 931: /* From UPnP Device Architecture v1.1 :
! 932: * 1.3.2 [...] Updated versions of device and service types
! 933: * are REQUIRED to be full backward compatible with
! 934: * previous versions. Devices MUST respond to M-SEARCH
! 935: * requests for any supported version. For example, if a
! 936: * device implements “urn:schemas-upnporg:service:xyz:2”,
! 937: * it MUST respond to search requests for both that type
! 938: * and “urn:schemas-upnp-org:service:xyz:1”. The response
! 939: * MUST specify the same version as was contained in the
! 940: * search request. [...] */
! 941: baselen = l; /* remove the version */
! 942: while(baselen > 0) {
! 943: if(p[baselen-1] == ':')
! 944: break;
! 945: if(!(p[baselen-1] >= '0' && p[baselen-1] <= '9'))
! 946: break;
! 947: baselen--;
! 948: }
! 949: while(d && (nrep < 255)) {
! 950: if(d->t < t) {
! 951: syslog(LOG_INFO, "outdated device");
! 952: } else {
! 953: /* test if we can put more responses in the buffer */
! 954: if(d->headers[HEADER_LOCATION].l + d->headers[HEADER_NT].l
! 955: + d->headers[HEADER_USN].l + 6
! 956: + (rp - rbuf) >= (int)sizeof(rbuf))
! 957: break;
! 958: if( (type==MINISSDPD_SEARCH_TYPE && 0==memcmp(d->headers[HEADER_NT].p, p, baselen))
! 959: ||(type==MINISSDPD_SEARCH_USN && 0==memcmp(d->headers[HEADER_USN].p, p, l))
! 960: ||(type==MINISSDPD_SEARCH_ALL) ) {
! 961: /* response :
! 962: * 1 - Location
! 963: * 2 - NT (device/service type)
! 964: * 3 - usn */
! 965: m = d->headers[HEADER_LOCATION].l;
! 966: CODELENGTH(m, rp);
! 967: memcpy(rp, d->headers[HEADER_LOCATION].p, d->headers[HEADER_LOCATION].l);
! 968: rp += d->headers[HEADER_LOCATION].l;
! 969: m = d->headers[HEADER_NT].l;
! 970: CODELENGTH(m, rp);
! 971: memcpy(rp, d->headers[HEADER_NT].p, d->headers[HEADER_NT].l);
! 972: rp += d->headers[HEADER_NT].l;
! 973: m = d->headers[HEADER_USN].l;
! 974: CODELENGTH(m, rp);
! 975: memcpy(rp, d->headers[HEADER_USN].p, d->headers[HEADER_USN].l);
! 976: rp += d->headers[HEADER_USN].l;
! 977: nrep++;
! 978: }
! 979: }
! 980: d = d->next;
! 981: }
! 982: /* Also look in service list */
! 983: for(serv = servicelisthead.lh_first;
! 984: serv && (nrep < 255);
! 985: serv = serv->entries.le_next) {
! 986: /* test if we can put more responses in the buffer */
! 987: if(strlen(serv->location) + strlen(serv->st)
! 988: + strlen(serv->usn) + 6 + (rp - rbuf) >= sizeof(rbuf))
! 989: break;
! 990: if( (type==MINISSDPD_SEARCH_TYPE && 0==strncmp(serv->st, (const char *)p, l))
! 991: ||(type==MINISSDPD_SEARCH_USN && 0==strncmp(serv->usn, (const char *)p, l))
! 992: ||(type==MINISSDPD_SEARCH_ALL) ) {
! 993: /* response :
! 994: * 1 - Location
! 995: * 2 - NT (device/service type)
! 996: * 3 - usn */
! 997: m = strlen(serv->location);
! 998: CODELENGTH(m, rp);
! 999: memcpy(rp, serv->location, m);
! 1000: rp += m;
! 1001: m = strlen(serv->st);
! 1002: CODELENGTH(m, rp);
! 1003: memcpy(rp, serv->st, m);
! 1004: rp += m;
! 1005: m = strlen(serv->usn);
! 1006: CODELENGTH(m, rp);
! 1007: memcpy(rp, serv->usn, m);
! 1008: rp += m;
! 1009: nrep++;
! 1010: }
! 1011: }
! 1012: rbuf[0] = nrep;
! 1013: syslog(LOG_DEBUG, "(s=%d) response : %d device%s",
! 1014: req->socket, nrep, (nrep > 1) ? "s" : "");
! 1015: if(write_or_buffer(req, rbuf, rp - rbuf) < 0) {
! 1016: syslog(LOG_ERR, "(s=%d) write: %m", req->socket);
! 1017: goto error;
! 1018: }
! 1019: p += l;
! 1020: break;
! 1021: case MINISSDPD_SUBMIT: /* submit service */
! 1022: newserv = malloc(sizeof(struct service));
! 1023: if(!newserv) {
! 1024: syslog(LOG_ERR, "cannot allocate memory");
! 1025: goto error;
! 1026: }
! 1027: memset(newserv, 0, sizeof(struct service)); /* set pointers to NULL */
! 1028: if(containsForbiddenChars(p, l)) {
! 1029: syslog(LOG_ERR, "bad request (st contains forbidden chars)");
! 1030: goto error;
! 1031: }
! 1032: newserv->st = malloc(l + 1);
! 1033: if(!newserv->st) {
! 1034: syslog(LOG_ERR, "cannot allocate memory");
! 1035: goto error;
! 1036: }
! 1037: memcpy(newserv->st, p, l);
! 1038: newserv->st[l] = '\0';
! 1039: p += l;
! 1040: if(p >= buf + n) {
! 1041: syslog(LOG_WARNING, "bad request (missing usn)");
! 1042: goto error;
! 1043: }
! 1044: DECODELENGTH_CHECKLIMIT(l, p, buf + n);
! 1045: if(l > (unsigned)(buf+n-p)) {
! 1046: syslog(LOG_WARNING, "bad request (length encoding)");
! 1047: goto error;
! 1048: }
! 1049: if(containsForbiddenChars(p, l)) {
! 1050: syslog(LOG_ERR, "bad request (usn contains forbidden chars)");
! 1051: goto error;
! 1052: }
! 1053: syslog(LOG_INFO, "usn='%.*s'", l, p);
! 1054: newserv->usn = malloc(l + 1);
! 1055: if(!newserv->usn) {
! 1056: syslog(LOG_ERR, "cannot allocate memory");
! 1057: goto error;
! 1058: }
! 1059: memcpy(newserv->usn, p, l);
! 1060: newserv->usn[l] = '\0';
! 1061: p += l;
! 1062: DECODELENGTH_CHECKLIMIT(l, p, buf + n);
! 1063: if(l > (unsigned)(buf+n-p)) {
! 1064: syslog(LOG_WARNING, "bad request (length encoding)");
! 1065: goto error;
! 1066: }
! 1067: if(containsForbiddenChars(p, l)) {
! 1068: syslog(LOG_ERR, "bad request (server contains forbidden chars)");
! 1069: goto error;
! 1070: }
! 1071: syslog(LOG_INFO, "server='%.*s'", l, p);
! 1072: newserv->server = malloc(l + 1);
! 1073: if(!newserv->server) {
! 1074: syslog(LOG_ERR, "cannot allocate memory");
! 1075: goto error;
! 1076: }
! 1077: memcpy(newserv->server, p, l);
! 1078: newserv->server[l] = '\0';
! 1079: p += l;
! 1080: DECODELENGTH_CHECKLIMIT(l, p, buf + n);
! 1081: if(l > (unsigned)(buf+n-p)) {
! 1082: syslog(LOG_WARNING, "bad request (length encoding)");
! 1083: goto error;
! 1084: }
! 1085: if(containsForbiddenChars(p, l)) {
! 1086: syslog(LOG_ERR, "bad request (location contains forbidden chars)");
! 1087: goto error;
! 1088: }
! 1089: syslog(LOG_INFO, "location='%.*s'", l, p);
! 1090: newserv->location = malloc(l + 1);
! 1091: if(!newserv->location) {
! 1092: syslog(LOG_ERR, "cannot allocate memory");
! 1093: goto error;
! 1094: }
! 1095: memcpy(newserv->location, p, l);
! 1096: newserv->location[l] = '\0';
! 1097: p += l;
! 1098: /* look in service list for duplicate */
! 1099: for(serv = servicelisthead.lh_first;
! 1100: serv;
! 1101: serv = serv->entries.le_next) {
! 1102: if(0 == strcmp(newserv->usn, serv->usn)
! 1103: && 0 == strcmp(newserv->st, serv->st)) {
! 1104: syslog(LOG_INFO, "Service already in the list. Updating...");
! 1105: free(newserv->st);
! 1106: free(newserv->usn);
! 1107: free(serv->server);
! 1108: serv->server = newserv->server;
! 1109: free(serv->location);
! 1110: serv->location = newserv->location;
! 1111: free(newserv);
! 1112: newserv = NULL;
! 1113: return (p - buf);
! 1114: }
! 1115: }
! 1116: /* Inserting new service */
! 1117: LIST_INSERT_HEAD(&servicelisthead, newserv, entries);
! 1118: sendNotifications(NOTIF_NEW, NULL, newserv);
! 1119: newserv = NULL;
! 1120: break;
! 1121: case MINISSDPD_NOTIF: /* switch socket to notify */
! 1122: rbuf[0] = '\0';
! 1123: if(write_or_buffer(req, rbuf, 1) < 0) {
! 1124: syslog(LOG_ERR, "(s=%d) write: %m", req->socket);
! 1125: goto error;
! 1126: }
! 1127: req->is_notify = 1;
! 1128: p += l;
! 1129: break;
! 1130: default:
! 1131: syslog(LOG_WARNING, "Unknown request type %d", type);
! 1132: rbuf[0] = '\0';
! 1133: if(write_or_buffer(req, rbuf, 1) < 0) {
! 1134: syslog(LOG_ERR, "(s=%d) write: %m", req->socket);
! 1135: goto error;
! 1136: }
! 1137: }
! 1138: return (p - buf);
! 1139: error:
! 1140: if(newserv) {
! 1141: free(newserv->st);
! 1142: free(newserv->usn);
! 1143: free(newserv->server);
! 1144: free(newserv->location);
! 1145: free(newserv);
! 1146: newserv = NULL;
! 1147: }
! 1148: return -1;
! 1149: }
! 1150:
! 1151: static volatile sig_atomic_t quitting = 0;
! 1152: /* SIGTERM signal handler */
! 1153: static void
! 1154: sigterm(int sig)
! 1155: {
! 1156: (void)sig;
! 1157: /*int save_errno = errno;*/
! 1158: /*signal(sig, SIG_IGN);*/
! 1159: #if 0
! 1160: /* calling syslog() is forbidden in a signal handler according to
! 1161: * signal(3) */
! 1162: syslog(LOG_NOTICE, "received signal %d, good-bye", sig);
! 1163: #endif
! 1164: quitting = 1;
! 1165: /*errno = save_errno;*/
! 1166: }
! 1167:
! 1168: #define PORT 1900
! 1169: #define XSTR(s) STR(s)
! 1170: #define STR(s) #s
! 1171: #define UPNP_MCAST_ADDR "239.255.255.250"
! 1172: /* for IPv6 */
! 1173: #define UPNP_MCAST_LL_ADDR "FF02::C" /* link-local */
! 1174: #define UPNP_MCAST_SL_ADDR "FF05::C" /* site-local */
! 1175:
! 1176: /* send the M-SEARCH request for devices
! 1177: * either all devices (third argument is NULL or "*") or a specific one */
! 1178: static void ssdpDiscover(int s, int ipv6, const char * search)
! 1179: {
! 1180: static const char MSearchMsgFmt[] =
! 1181: "M-SEARCH * HTTP/1.1\r\n"
! 1182: "HOST: %s:" XSTR(PORT) "\r\n"
! 1183: "ST: %s\r\n"
! 1184: "MAN: \"ssdp:discover\"\r\n"
! 1185: "MX: %u\r\n"
! 1186: "\r\n";
! 1187: char bufr[512];
! 1188: int n;
! 1189: int mx = 3;
! 1190: int linklocal = 1;
! 1191: struct sockaddr_storage sockudp_w;
! 1192:
! 1193: {
! 1194: n = snprintf(bufr, sizeof(bufr),
! 1195: MSearchMsgFmt,
! 1196: ipv6 ?
! 1197: (linklocal ? "[" UPNP_MCAST_LL_ADDR "]" : "[" UPNP_MCAST_SL_ADDR "]")
! 1198: : UPNP_MCAST_ADDR,
! 1199: (search ? search : "ssdp:all"), mx);
! 1200: memset(&sockudp_w, 0, sizeof(struct sockaddr_storage));
! 1201: if(ipv6) {
! 1202: struct sockaddr_in6 * p = (struct sockaddr_in6 *)&sockudp_w;
! 1203: p->sin6_family = AF_INET6;
! 1204: p->sin6_port = htons(PORT);
! 1205: inet_pton(AF_INET6,
! 1206: linklocal ? UPNP_MCAST_LL_ADDR : UPNP_MCAST_SL_ADDR,
! 1207: &(p->sin6_addr));
! 1208: } else {
! 1209: struct sockaddr_in * p = (struct sockaddr_in *)&sockudp_w;
! 1210: p->sin_family = AF_INET;
! 1211: p->sin_port = htons(PORT);
! 1212: p->sin_addr.s_addr = inet_addr(UPNP_MCAST_ADDR);
! 1213: }
! 1214:
! 1215: n = sendto_or_schedule(s, bufr, n, 0, (const struct sockaddr *)&sockudp_w,
! 1216: ipv6 ? sizeof(struct sockaddr_in6) : sizeof(struct sockaddr_in));
! 1217: if (n < 0) {
! 1218: syslog(LOG_ERR, "%s: sendto(s=%d, ipv6=%d): %m", __func__, s, ipv6);
! 1219: }
! 1220: }
! 1221: }
! 1222:
! 1223: /* main(): program entry point */
! 1224: int main(int argc, char * * argv)
! 1225: {
! 1226: int ret = 0;
! 1227: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1228: int pid;
! 1229: #endif
! 1230: struct sigaction sa;
! 1231: char buf[1500];
! 1232: ssize_t n;
! 1233: int s_ssdp = -1; /* udp socket receiving ssdp packets */
! 1234: #ifdef ENABLE_IPV6
! 1235: int s_ssdp6 = -1; /* udp socket receiving ssdp packets IPv6*/
! 1236: #else /* ENABLE_IPV6 */
! 1237: #define s_ssdp6 (-1)
! 1238: #endif /* ENABLE_IPV6 */
! 1239: int s_unix = -1; /* unix socket communicating with clients */
! 1240: int s_ifacewatch = -1; /* socket to receive Route / network interface config changes */
! 1241: struct reqelem * req;
! 1242: struct reqelem * reqnext;
! 1243: fd_set readfds;
! 1244: fd_set writefds;
! 1245: struct timeval now;
! 1246: int max_fd;
! 1247: struct lan_addr_s * lan_addr;
! 1248: int i;
! 1249: const char * sockpath = "/var/run/minissdpd.sock";
! 1250: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1251: const char * pidfilename = "/var/run/minissdpd.pid";
! 1252: #endif
! 1253: int debug_flag = 0;
! 1254: #ifdef ENABLE_IPV6
! 1255: int ipv6 = 0;
! 1256: #endif /* ENABLE_IPV6 */
! 1257: int deltadev = 0;
! 1258: struct sockaddr_in sendername;
! 1259: socklen_t sendername_len;
! 1260: #ifdef ENABLE_IPV6
! 1261: struct sockaddr_in6 sendername6;
! 1262: socklen_t sendername6_len;
! 1263: #endif /* ENABLE_IPV6 */
! 1264: unsigned char ttl = 2; /* UDA says it should default to 2 */
! 1265: const char * searched_device = NULL; /* if not NULL, search/filter a specific device type */
! 1266: int opt;
! 1267:
! 1268: LIST_INIT(&reqlisthead);
! 1269: LIST_INIT(&servicelisthead);
! 1270: LIST_INIT(&lan_addrs);
! 1271: /* process command line */
! 1272: #define OPTSTRING "d6i:s:p:t:f:"
! 1273: while ((opt = getopt(argc, argv, "di:s:t:f:"
! 1274: #ifdef ENABLE_IPV6
! 1275: "6"
! 1276: #endif
! 1277: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1278: "p:"
! 1279: #endif
! 1280:
! 1281: )) != -1)
! 1282: {
! 1283: switch(opt)
! 1284: {
! 1285: case 'd':
! 1286: debug_flag = 1;
! 1287: break;
! 1288: #ifdef ENABLE_IPV6
! 1289: case '6':
! 1290: ipv6 = 1;
! 1291: break;
! 1292: #endif /* ENABLE_IPV6 */
! 1293: case 'i':
! 1294: lan_addr = malloc(sizeof(struct lan_addr_s));
! 1295: if(lan_addr == NULL) {
! 1296: fprintf(stderr, "malloc(%d) FAILED\n", (int)sizeof(struct lan_addr_s));
! 1297: break;
! 1298: }
! 1299: if(parselanaddr(lan_addr, optarg) != 0) {
! 1300: fprintf(stderr, "can't parse \"%s\" as a valid "
! 1301: #ifndef ENABLE_IPV6
! 1302: "address or "
! 1303: #endif
! 1304: "interface name\n", optarg);
! 1305: free(lan_addr);
! 1306: } else {
! 1307: LIST_INSERT_HEAD(&lan_addrs, lan_addr, list);
! 1308: }
! 1309: break;
! 1310: case 's':
! 1311: sockpath = optarg;
! 1312: break;
! 1313: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1314: case 'p':
! 1315: pidfilename = optarg;
! 1316: break;
! 1317: #endif
! 1318: case 't':
! 1319: ttl = (unsigned char)atoi(optarg);
! 1320: break;
! 1321: case 'f':
! 1322: searched_device = optarg;
! 1323: break;
! 1324: }
! 1325: }
! 1326: if(lan_addrs.lh_first == NULL)
! 1327: {
! 1328: fprintf(stderr,
! 1329: "Usage: %s [-d] "
! 1330: #ifdef ENABLE_IPV6
! 1331: "[-6] "
! 1332: #endif /* ENABLE_IPV6 */
! 1333: "[-s socket] "
! 1334: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1335: "[-p pidfile] "
! 1336: #endif
! 1337: "[-t TTL] "
! 1338: "[-f device] "
! 1339: "-i <interface> [-i <interface2>] ...\n",
! 1340: argv[0]);
! 1341: fprintf(stderr,
! 1342: "\n <interface> is "
! 1343: #ifndef ENABLE_IPV6
! 1344: "either an IPv4 address with mask such as\n"
! 1345: " 192.168.1.42/255.255.255.0, or "
! 1346: #endif
! 1347: "an interface name such as eth0.\n");
! 1348: fprintf(stderr,
! 1349: "\n By default, socket will be open as %s\n"
! 1350: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1351: " and pid written to file %s\n",
! 1352: sockpath, pidfilename
! 1353: #else
! 1354: ,sockpath
! 1355: #endif
! 1356: );
! 1357: return 1;
! 1358: }
! 1359:
! 1360: /* open log */
! 1361: openlog("minissdpd",
! 1362: LOG_CONS|LOG_PID|(debug_flag?LOG_PERROR:0),
! 1363: LOG_MINISSDPD);
! 1364: if(!debug_flag) /* speed things up and ignore LOG_INFO and LOG_DEBUG */
! 1365: setlogmask(LOG_UPTO(LOG_NOTICE));
! 1366:
! 1367: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1368: if(checkforrunning(pidfilename) < 0)
! 1369: {
! 1370: syslog(LOG_ERR, "MiniSSDPd is already running. EXITING");
! 1371: return 1;
! 1372: }
! 1373: #endif
! 1374:
! 1375: upnp_bootid = (unsigned int)time(NULL);
! 1376:
! 1377: /* set signal handlers */
! 1378: memset(&sa, 0, sizeof(struct sigaction));
! 1379: sa.sa_handler = sigterm;
! 1380: if(sigaction(SIGTERM, &sa, NULL))
! 1381: {
! 1382: syslog(LOG_ERR, "Failed to set SIGTERM handler. EXITING");
! 1383: ret = 1;
! 1384: goto quit;
! 1385: }
! 1386: if(sigaction(SIGINT, &sa, NULL))
! 1387: {
! 1388: syslog(LOG_ERR, "Failed to set SIGINT handler. EXITING");
! 1389: ret = 1;
! 1390: goto quit;
! 1391: }
! 1392: /* open route/interface config changes socket */
! 1393: s_ifacewatch = OpenAndConfInterfaceWatchSocket();
! 1394: /* open UDP socket(s) for receiving SSDP packets */
! 1395: s_ssdp = OpenAndConfSSDPReceiveSocket(0, ttl);
! 1396: if(s_ssdp < 0)
! 1397: {
! 1398: syslog(LOG_ERR, "Cannot open socket for receiving SSDP messages, exiting");
! 1399: ret = 1;
! 1400: goto quit;
! 1401: }
! 1402: #ifdef ENABLE_IPV6
! 1403: if(ipv6) {
! 1404: s_ssdp6 = OpenAndConfSSDPReceiveSocket(1, ttl);
! 1405: if(s_ssdp6 < 0)
! 1406: {
! 1407: syslog(LOG_ERR, "Cannot open socket for receiving SSDP messages (IPv6), exiting");
! 1408: ret = 1;
! 1409: goto quit;
! 1410: }
! 1411: }
! 1412: #endif /* ENABLE_IPV6 */
! 1413: /* Open Unix socket to communicate with other programs on
! 1414: * the same machine */
! 1415: s_unix = OpenUnixSocket(sockpath);
! 1416: if(s_unix < 0)
! 1417: {
! 1418: syslog(LOG_ERR, "Cannot open unix socket for communicating with clients. Exiting");
! 1419: ret = 1;
! 1420: goto quit;
! 1421: }
! 1422:
! 1423: /* drop privileges */
! 1424: #if 0
! 1425: /* if we drop privileges, how to unlink(/var/run/minissdpd.sock) ? */
! 1426: if(getuid() == 0) {
! 1427: struct passwd * user;
! 1428: struct group * group;
! 1429: user = getpwnam("nobody");
! 1430: if(!user) {
! 1431: syslog(LOG_ERR, "getpwnam(\"%s\") : %m", "nobody");
! 1432: ret = 1;
! 1433: goto quit;
! 1434: }
! 1435: group = getgrnam("nogroup");
! 1436: if(!group) {
! 1437: syslog(LOG_ERR, "getgrnam(\"%s\") : %m", "nogroup");
! 1438: ret = 1;
! 1439: goto quit;
! 1440: }
! 1441: if(setgid(group->gr_gid) < 0) {
! 1442: syslog(LOG_ERR, "setgit(%d) : %m", group->gr_gid);
! 1443: ret = 1;
! 1444: goto quit;
! 1445: }
! 1446: if(setuid(user->pw_uid) < 0) {
! 1447: syslog(LOG_ERR, "setuid(%d) : %m", user->pw_uid);
! 1448: ret = 1;
! 1449: goto quit;
! 1450: }
! 1451: }
! 1452: #endif
! 1453:
! 1454: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1455: /* daemonize or in any case get pid ! */
! 1456: if(debug_flag)
! 1457: pid = getpid();
! 1458: else {
! 1459: #ifdef USE_DAEMON
! 1460: if(daemon(0, 0) < 0)
! 1461: perror("daemon()");
! 1462: pid = getpid();
! 1463: #else /* USE_DAEMON */
! 1464: pid = daemonize();
! 1465: #endif /* USE_DAEMON */
! 1466: }
! 1467:
! 1468: writepidfile(pidfilename, pid);
! 1469: #endif
! 1470:
! 1471: /* send M-SEARCH ssdp:all Requests */
! 1472: if(s_ssdp >= 0) {
! 1473: for(lan_addr = lan_addrs.lh_first; lan_addr != NULL; lan_addr = lan_addr->list.le_next) {
! 1474: #ifndef HAVE_IP_MREQN
! 1475: struct in_addr mc_if;
! 1476:
! 1477: mc_if.s_addr = lan_addr->addr.s_addr; /*inet_addr(addr);*/
! 1478: #else
! 1479: struct ip_mreqn mc_if;
! 1480:
! 1481: mc_if.imr_address.s_addr = lan_addr->addr.s_addr; /*inet_addr(addr);*/
! 1482: #ifdef ENABLE_IPV6
! 1483: mc_if.imr_ifindex = lan_addr->index;
! 1484: #else /* ENABLE_IPV6 */
! 1485: mc_if.imr_ifindex = if_nametoindex(lan_addr->ifname);
! 1486: #endif /* ENABLE_IPV6 */
! 1487: #endif /* HAVE_IP_MREQN */
! 1488: if(setsockopt(s_ssdp, IPPROTO_IP, IP_MULTICAST_IF, &mc_if, sizeof(mc_if)) < 0) {
! 1489: syslog(LOG_WARNING, "setsockopt(IP_MULTICAST_IF): %m");
! 1490: }
! 1491: ssdpDiscover(s_ssdp, 0, searched_device);
! 1492: /* XXX if ssdpDiscover() doesn't send the SSDP packet at once,
! 1493: * we should wait here */
! 1494: }
! 1495: }
! 1496: if(s_ssdp6 >= 0)
! 1497: ssdpDiscover(s_ssdp6, 1, searched_device);
! 1498:
! 1499: /* Main loop */
! 1500: while(!quitting) {
! 1501: /* fill readfds fd_set */
! 1502: FD_ZERO(&readfds);
! 1503: FD_ZERO(&writefds);
! 1504:
! 1505: FD_SET(s_unix, &readfds);
! 1506: max_fd = s_unix;
! 1507: if(s_ssdp >= 0) {
! 1508: FD_SET(s_ssdp, &readfds);
! 1509: SET_MAX(max_fd, s_ssdp);
! 1510: }
! 1511: #ifdef ENABLE_IPV6
! 1512: if(s_ssdp6 >= 0) {
! 1513: FD_SET(s_ssdp6, &readfds);
! 1514: SET_MAX(max_fd, s_ssdp6);
! 1515: }
! 1516: #endif /* ENABLE_IPV6 */
! 1517: if(s_ifacewatch >= 0) {
! 1518: FD_SET(s_ifacewatch, &readfds);
! 1519: SET_MAX(max_fd, s_ifacewatch);
! 1520: }
! 1521: for(req = reqlisthead.lh_first; req; req = req->entries.le_next) {
! 1522: if(req->socket >= 0) {
! 1523: FD_SET(req->socket, &readfds);
! 1524: SET_MAX(max_fd, req->socket);
! 1525: }
! 1526: if(req->output_buffer_len > 0) {
! 1527: FD_SET(req->socket, &writefds);
! 1528: SET_MAX(max_fd, req->socket);
! 1529: }
! 1530: }
! 1531: gettimeofday(&now, NULL);
! 1532: i = get_sendto_fds(&writefds, &max_fd, &now);
! 1533: /* select call */
! 1534: if(select(max_fd + 1, &readfds, &writefds, 0, 0) < 0) {
! 1535: if(errno != EINTR) {
! 1536: syslog(LOG_ERR, "select: %m");
! 1537: break; /* quit */
! 1538: }
! 1539: continue; /* try again */
! 1540: }
! 1541: if(try_sendto(&writefds) < 0) {
! 1542: syslog(LOG_ERR, "try_sendto: %m");
! 1543: break;
! 1544: }
! 1545: #ifdef ENABLE_IPV6
! 1546: if((s_ssdp6 >= 0) && FD_ISSET(s_ssdp6, &readfds))
! 1547: {
! 1548: sendername6_len = sizeof(struct sockaddr_in6);
! 1549: n = recvfrom(s_ssdp6, buf, sizeof(buf), 0,
! 1550: (struct sockaddr *)&sendername6, &sendername6_len);
! 1551: if(n<0)
! 1552: {
! 1553: /* EAGAIN, EWOULDBLOCK, EINTR : silently ignore (try again next time)
! 1554: * other errors : log to LOG_ERR */
! 1555: if(errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
! 1556: syslog(LOG_ERR, "recvfrom: %m");
! 1557: }
! 1558: else
! 1559: {
! 1560: /* Parse and process the packet received */
! 1561: /*printf("%.*s", n, buf);*/
! 1562: i = ParseSSDPPacket(s_ssdp6, buf, n,
! 1563: (struct sockaddr *)&sendername6, searched_device);
! 1564: syslog(LOG_DEBUG, "** i=%d deltadev=%d **", i, deltadev);
! 1565: if(i==0 || (i*deltadev < 0))
! 1566: {
! 1567: if(deltadev > 0)
! 1568: syslog(LOG_NOTICE, "%d new devices added", deltadev);
! 1569: else if(deltadev < 0)
! 1570: syslog(LOG_NOTICE, "%d devices removed (good-bye!)", -deltadev);
! 1571: deltadev = i;
! 1572: }
! 1573: else if((i*deltadev) >= 0)
! 1574: {
! 1575: deltadev += i;
! 1576: }
! 1577: }
! 1578: }
! 1579: #endif /* ENABLE_IPV6 */
! 1580: if((s_ssdp >= 0) && FD_ISSET(s_ssdp, &readfds))
! 1581: {
! 1582: sendername_len = sizeof(struct sockaddr_in);
! 1583: n = recvfrom(s_ssdp, buf, sizeof(buf), 0,
! 1584: (struct sockaddr *)&sendername, &sendername_len);
! 1585: if(n<0)
! 1586: {
! 1587: /* EAGAIN, EWOULDBLOCK, EINTR : silently ignore (try again next time)
! 1588: * other errors : log to LOG_ERR */
! 1589: if(errno != EAGAIN && errno != EWOULDBLOCK && errno != EINTR)
! 1590: syslog(LOG_ERR, "recvfrom: %m");
! 1591: }
! 1592: else
! 1593: {
! 1594: /* Parse and process the packet received */
! 1595: /*printf("%.*s", n, buf);*/
! 1596: i = ParseSSDPPacket(s_ssdp, buf, n,
! 1597: (struct sockaddr *)&sendername, searched_device);
! 1598: syslog(LOG_DEBUG, "** i=%d deltadev=%d **", i, deltadev);
! 1599: if(i==0 || (i*deltadev < 0))
! 1600: {
! 1601: if(deltadev > 0)
! 1602: syslog(LOG_NOTICE, "%d new devices added", deltadev);
! 1603: else if(deltadev < 0)
! 1604: syslog(LOG_NOTICE, "%d devices removed (good-bye!)", -deltadev);
! 1605: deltadev = i;
! 1606: }
! 1607: else if((i*deltadev) >= 0)
! 1608: {
! 1609: deltadev += i;
! 1610: }
! 1611: }
! 1612: }
! 1613: /* processing unix socket requests */
! 1614: for(req = reqlisthead.lh_first; req;) {
! 1615: reqnext = req->entries.le_next;
! 1616: if((req->socket >= 0) && FD_ISSET(req->socket, &readfds)) {
! 1617: processRequest(req);
! 1618: }
! 1619: if((req->socket >= 0) && FD_ISSET(req->socket, &writefds)) {
! 1620: write_buffer(req);
! 1621: }
! 1622: if(req->socket < 0) {
! 1623: LIST_REMOVE(req, entries);
! 1624: free(req->output_buffer);
! 1625: free(req);
! 1626: }
! 1627: req = reqnext;
! 1628: }
! 1629: /* processing new requests */
! 1630: if(FD_ISSET(s_unix, &readfds))
! 1631: {
! 1632: struct reqelem * tmp;
! 1633: int s = accept(s_unix, NULL, NULL);
! 1634: if(s < 0) {
! 1635: syslog(LOG_ERR, "accept(s_unix): %m");
! 1636: } else {
! 1637: syslog(LOG_INFO, "(s=%d) new request connection", s);
! 1638: if(!set_non_blocking(s))
! 1639: syslog(LOG_WARNING, "Failed to set new socket non blocking : %m");
! 1640: tmp = malloc(sizeof(struct reqelem));
! 1641: if(!tmp) {
! 1642: syslog(LOG_ERR, "cannot allocate memory for request");
! 1643: close(s);
! 1644: } else {
! 1645: memset(tmp, 0, sizeof(struct reqelem));
! 1646: tmp->socket = s;
! 1647: LIST_INSERT_HEAD(&reqlisthead, tmp, entries);
! 1648: }
! 1649: }
! 1650: }
! 1651: /* processing route/network interface config changes */
! 1652: if((s_ifacewatch >= 0) && FD_ISSET(s_ifacewatch, &readfds)) {
! 1653: ProcessInterfaceWatch(s_ifacewatch, s_ssdp, s_ssdp6);
! 1654: }
! 1655: }
! 1656: syslog(LOG_DEBUG, "quitting...");
! 1657: finalize_sendto();
! 1658:
! 1659: /* closing and cleaning everything */
! 1660: quit:
! 1661: if(s_ssdp >= 0) {
! 1662: close(s_ssdp);
! 1663: s_ssdp = -1;
! 1664: }
! 1665: #ifdef ENABLE_IPV6
! 1666: if(s_ssdp6 >= 0) {
! 1667: close(s_ssdp6);
! 1668: s_ssdp6 = -1;
! 1669: }
! 1670: #endif /* ENABLE_IPV6 */
! 1671: if(s_unix >= 0) {
! 1672: close(s_unix);
! 1673: s_unix = -1;
! 1674: if(unlink(sockpath) < 0)
! 1675: syslog(LOG_ERR, "unlink(%s): %m", sockpath);
! 1676: }
! 1677: if(s_ifacewatch >= 0) {
! 1678: close(s_ifacewatch);
! 1679: s_ifacewatch = -1;
! 1680: }
! 1681: /* empty LAN interface/address list */
! 1682: while(lan_addrs.lh_first != NULL) {
! 1683: lan_addr = lan_addrs.lh_first;
! 1684: LIST_REMOVE(lan_addrs.lh_first, list);
! 1685: free(lan_addr);
! 1686: }
! 1687: /* empty device list */
! 1688: while(devlist != NULL) {
! 1689: struct device * next = devlist->next;
! 1690: free(devlist);
! 1691: devlist = next;
! 1692: }
! 1693: /* empty service list */
! 1694: while(servicelisthead.lh_first != NULL) {
! 1695: struct service * serv = servicelisthead.lh_first;
! 1696: LIST_REMOVE(servicelisthead.lh_first, entries);
! 1697: free(serv->st);
! 1698: free(serv->usn);
! 1699: free(serv->server);
! 1700: free(serv->location);
! 1701: free(serv);
! 1702: }
! 1703: #ifndef NO_BACKGROUND_NO_PIDFILE
! 1704: if(unlink(pidfilename) < 0)
! 1705: syslog(LOG_ERR, "unlink(%s): %m", pidfilename);
! 1706: #endif
! 1707: closelog();
! 1708: return ret;
! 1709: }
! 1710:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to minissdpd.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 / minissdpd