Annotation of embedaddon/miniupnpd/miniupnpd.c, revision 1.1
1.1 ! misho 1: /* $Id: miniupnpd.c,v 1.125 2010/09/21 15:31:01 nanard Exp $ */
! 2: /* MiniUPnP project
! 3: * http://miniupnp.free.fr/ or http://miniupnp.tuxfamily.org/
! 4: * (c) 2006-2010 Thomas Bernard
! 5: * This software is subject to the conditions detailed
! 6: * in the LICENCE file provided within the distribution */
! 7:
! 8: #include "config.h"
! 9:
! 10: /* Experimental support for NFQUEUE interfaces */
! 11: #ifdef ENABLE_NFQUEUE
! 12: /* apt-get install libnetfilter-queue-dev */
! 13: #include <netinet/ip.h>
! 14: #include <netinet/udp.h>
! 15: //#include <linux/netfilter_ipv4.h> /* Defines verdicts (NF_ACCEPT, etc) */
! 16: #include <linux/netfilter.h>
! 17: #include <libnetfilter_queue/libnetfilter_queue.h>
! 18: #include <linux/netfilter/nfnetlink_queue.h>
! 19: #endif
! 20:
! 21: #include <stdlib.h>
! 22: #include <unistd.h>
! 23: #include <string.h>
! 24: #include <stdio.h>
! 25: #include <ctype.h>
! 26: #include <sys/types.h>
! 27: #include <sys/socket.h>
! 28: #include <netinet/in.h>
! 29: #include <arpa/inet.h>
! 30: #include <fcntl.h>
! 31: #include <sys/file.h>
! 32: #include <syslog.h>
! 33: #include <sys/time.h>
! 34: #include <time.h>
! 35: #include <signal.h>
! 36: #include <errno.h>
! 37: #include <sys/param.h>
! 38: #if defined(sun)
! 39: #include <kstat.h>
! 40: #else
! 41: /* for BSD's sysctl */
! 42: #include <sys/sysctl.h>
! 43: #endif
! 44:
! 45: /* unix sockets */
! 46: #ifdef USE_MINIUPNPDCTL
! 47: #include <sys/un.h>
! 48: #endif
! 49:
! 50: #include "upnpglobalvars.h"
! 51: #include "upnphttp.h"
! 52: #include "upnpdescgen.h"
! 53: #include "miniupnpdpath.h"
! 54: #include "getifaddr.h"
! 55: #include "upnpsoap.h"
! 56: #include "options.h"
! 57: #include "minissdp.h"
! 58: #include "upnpredirect.h"
! 59: #include "miniupnpdtypes.h"
! 60: #include "daemonize.h"
! 61: #include "upnpevents.h"
! 62: #ifdef ENABLE_NATPMP
! 63: #include "natpmp.h"
! 64: #endif
! 65: #include "commonrdr.h"
! 66:
! 67: #ifndef DEFAULT_CONFIG
! 68: #define DEFAULT_CONFIG "/etc/miniupnpd.conf"
! 69: #endif
! 70:
! 71: #ifdef USE_MINIUPNPDCTL
! 72: struct ctlelem {
! 73: int socket;
! 74: LIST_ENTRY(ctlelem) entries;
! 75: };
! 76: #endif
! 77:
! 78: #ifdef ENABLE_NFQUEUE
! 79: /* globals */
! 80: static struct nfq_handle *nfqHandle;
! 81: static struct sockaddr_in ssdp;
! 82:
! 83: /* prototypes */
! 84: void ProcessSSDPData(int s, char *bufr, struct sockaddr_in sendername, int n, unsigned short port);
! 85: static int nfqueue_cb( struct nfq_q_handle *qh, struct nfgenmsg *nfmsg, struct nfq_data *nfa, void *data) ;
! 86: int identify_ip_protocol (char *payload);
! 87: int get_udp_dst_port (char *payload);
! 88: #endif
! 89:
! 90:
! 91: static int sudp = -1;
! 92:
! 93: /* MAX_LAN_ADDR : maximum number of interfaces
! 94: * to listen to SSDP traffic */
! 95: /*#define MAX_LAN_ADDR (4)*/
! 96:
! 97: static volatile int quitting = 0;
! 98: static volatile int should_send_public_address_change_notif = 0;
! 99:
! 100: /* OpenAndConfHTTPSocket() :
! 101: * setup the socket used to handle incoming HTTP connections. */
! 102: static int
! 103: OpenAndConfHTTPSocket(unsigned short port)
! 104: {
! 105: int s;
! 106: int i = 1;
! 107: struct sockaddr_in listenname;
! 108:
! 109: if( (s = socket(PF_INET, SOCK_STREAM, 0)) < 0)
! 110: {
! 111: syslog(LOG_ERR, "socket(http): %m");
! 112: return -1;
! 113: }
! 114:
! 115: if(setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &i, sizeof(i)) < 0)
! 116: {
! 117: syslog(LOG_WARNING, "setsockopt(http, SO_REUSEADDR): %m");
! 118: }
! 119:
! 120: memset(&listenname, 0, sizeof(struct sockaddr_in));
! 121: listenname.sin_family = AF_INET;
! 122: listenname.sin_port = htons(port);
! 123: listenname.sin_addr.s_addr = htonl(INADDR_ANY);
! 124:
! 125: if(bind(s, (struct sockaddr *)&listenname, sizeof(struct sockaddr_in)) < 0)
! 126: {
! 127: syslog(LOG_ERR, "bind(http): %m");
! 128: close(s);
! 129: return -1;
! 130: }
! 131:
! 132: if(listen(s, 6) < 0)
! 133: {
! 134: syslog(LOG_ERR, "listen(http): %m");
! 135: close(s);
! 136: return -1;
! 137: }
! 138:
! 139: return s;
! 140: }
! 141: #ifdef ENABLE_NFQUEUE
! 142:
! 143: int identify_ip_protocol(char *payload) {
! 144: return payload[9];
! 145: }
! 146:
! 147:
! 148: /*
! 149: * This function returns the destination port of the captured packet UDP
! 150: */
! 151: int get_udp_dst_port(char *payload) {
! 152: char *pkt_data_ptr = NULL;
! 153: pkt_data_ptr = payload + sizeof(struct ip);
! 154:
! 155: /* Cast the UDP Header from the raw packet */
! 156: struct udphdr *udp = (struct udphdr *) pkt_data_ptr;
! 157:
! 158: /* get the dst port of the packet */
! 159: return(ntohs(udp->dest));
! 160:
! 161: }
! 162: static int
! 163: OpenAndConfNFqueue(){
! 164:
! 165: struct nfq_q_handle *myQueue;
! 166: struct nfnl_handle *netlinkHandle;
! 167:
! 168: int fd = 0, e = 0;
! 169:
! 170: inet_pton(AF_INET, "239.255.255.250", &(ssdp.sin_addr));
! 171:
! 172: //Get a queue connection handle from the module
! 173: if (!(nfqHandle = nfq_open())) {
! 174: syslog(LOG_ERR, "Error in nfq_open(): %m");
! 175: return -1;
! 176: }
! 177:
! 178: //Unbind the handler from processing any IP packets
! 179: // Not totally sure why this is done, or if it's necessary...
! 180: if ((e = nfq_unbind_pf(nfqHandle, AF_INET)) < 0) {
! 181: syslog(LOG_ERR, "Error in nfq_unbind_pf(): %m");
! 182: return -1;
! 183: }
! 184:
! 185: //Bind this handler to process IP packets...
! 186: if (nfq_bind_pf(nfqHandle, AF_INET) < 0) {
! 187: syslog(LOG_ERR, "Error in nfq_bind_pf(): %m");
! 188: return -1;
! 189: }
! 190:
! 191: // Install a callback on queue -Q
! 192: if (!(myQueue = nfq_create_queue(nfqHandle, nfqueue, &nfqueue_cb, NULL))) {
! 193: syslog(LOG_ERR, "Error in nfq_create_queue(): %m");
! 194: return -1;
! 195: }
! 196:
! 197: // Turn on packet copy mode
! 198: if (nfq_set_mode(myQueue, NFQNL_COPY_PACKET, 0xffff) < 0) {
! 199: syslog(LOG_ERR, "Error setting packet copy mode (): %m");
! 200: return -1;
! 201: }
! 202:
! 203: netlinkHandle = nfq_nfnlh(nfqHandle);
! 204: fd = nfnl_fd(netlinkHandle);
! 205:
! 206: return fd;
! 207:
! 208: }
! 209:
! 210:
! 211: static int nfqueue_cb(
! 212: struct nfq_q_handle *qh,
! 213: struct nfgenmsg *nfmsg,
! 214: struct nfq_data *nfa,
! 215: void *data) {
! 216:
! 217: char *pkt;
! 218: struct nfqnl_msg_packet_hdr *ph;
! 219: ph = nfq_get_msg_packet_hdr(nfa);
! 220:
! 221: if ( ph ) {
! 222:
! 223: int id = 0, size = 0;
! 224: id = ntohl(ph->packet_id);
! 225:
! 226: size = nfq_get_payload(nfa, &pkt);
! 227:
! 228: struct ip *iph = (struct ip *) pkt;
! 229:
! 230: int id_protocol = identify_ip_protocol(pkt);
! 231:
! 232: int dport = get_udp_dst_port(pkt);
! 233:
! 234: int x = sizeof (struct ip) + sizeof (struct udphdr);
! 235:
! 236: /* packets we are interested in are UDP multicast to 239.255.255.250:1900
! 237: * and start with a data string M-SEARCH
! 238: */
! 239: if ( (dport == 1900) && (id_protocol == IPPROTO_UDP)
! 240: && (ssdp.sin_addr.s_addr == iph->ip_dst.s_addr) ) {
! 241:
! 242: /* get the index that the packet came in on */
! 243: u_int32_t idx = nfq_get_indev(nfa);
! 244: int i = 0;
! 245: for ( ;i < n_nfqix ; i++) {
! 246: if ( nfqix[i] == idx ) {
! 247:
! 248: struct udphdr *udp = (struct udphdr *) (pkt + sizeof(struct ip));
! 249:
! 250: char *dd = pkt + x;
! 251:
! 252: struct sockaddr_in sendername;
! 253: sendername.sin_family = AF_INET;
! 254: sendername.sin_port = udp->source;
! 255: sendername.sin_addr.s_addr = iph->ip_src.s_addr;
! 256:
! 257: /* printf("pkt found %s\n",dd);*/
! 258: ProcessSSDPData (sudp, dd, sendername, size - x, (unsigned short) 5555);
! 259: }
! 260: }
! 261: }
! 262:
! 263: nfq_set_verdict(qh, id, NF_ACCEPT, 0, NULL);
! 264:
! 265: } else {
! 266: syslog(LOG_ERR,"nfq_get_msg_packet_hdr failed");
! 267: return 1; // from nfqueue source: 0 = ok, >0 = soft error, <0 hard error
! 268: }
! 269:
! 270: return 0;
! 271: }
! 272:
! 273: static void ProcessNFQUEUE(int fd){
! 274: char buf[4096];
! 275:
! 276: socklen_t len_r;
! 277: struct sockaddr_in sendername;
! 278: len_r = sizeof(struct sockaddr_in);
! 279:
! 280: int res = recvfrom(fd, buf, sizeof(buf), 0,
! 281: (struct sockaddr *)&sendername, &len_r);
! 282:
! 283: nfq_handle_packet(nfqHandle, buf, res);
! 284: }
! 285: #endif
! 286:
! 287: /* Functions used to communicate with miniupnpdctl */
! 288: #ifdef USE_MINIUPNPDCTL
! 289: static int
! 290: OpenAndConfCtlUnixSocket(const char * path)
! 291: {
! 292: struct sockaddr_un localun;
! 293: int s;
! 294: s = socket(AF_UNIX, SOCK_STREAM, 0);
! 295: localun.sun_family = AF_UNIX;
! 296: strncpy(localun.sun_path, path,
! 297: sizeof(localun.sun_path));
! 298: if(bind(s, (struct sockaddr *)&localun,
! 299: sizeof(struct sockaddr_un)) < 0)
! 300: {
! 301: syslog(LOG_ERR, "bind(sctl): %m");
! 302: close(s);
! 303: s = -1;
! 304: }
! 305: else if(listen(s, 5) < 0)
! 306: {
! 307: syslog(LOG_ERR, "listen(sctl): %m");
! 308: close(s);
! 309: s = -1;
! 310: }
! 311: return s;
! 312: }
! 313:
! 314: static void
! 315: write_upnphttp_details(int fd, struct upnphttp * e)
! 316: {
! 317: char buffer[256];
! 318: int len;
! 319: write(fd, "HTTP :\n", 7);
! 320: while(e)
! 321: {
! 322: len = snprintf(buffer, sizeof(buffer),
! 323: "%d %d %s req_buf=%p(%dbytes) res_buf=%p(%dbytes alloc)\n",
! 324: e->socket, e->state, e->HttpVer,
! 325: e->req_buf, e->req_buflen,
! 326: e->res_buf, e->res_buf_alloclen);
! 327: write(fd, buffer, len);
! 328: e = e->entries.le_next;
! 329: }
! 330: }
! 331:
! 332: static void
! 333: write_ctlsockets_list(int fd, struct ctlelem * e)
! 334: {
! 335: char buffer[256];
! 336: int len;
! 337: write(fd, "CTL :\n", 6);
! 338: while(e)
! 339: {
! 340: len = snprintf(buffer, sizeof(buffer),
! 341: "struct ctlelem: socket=%d\n", e->socket);
! 342: write(fd, buffer, len);
! 343: e = e->entries.le_next;
! 344: }
! 345: }
! 346:
! 347: static void
! 348: write_option_list(int fd)
! 349: {
! 350: char buffer[256];
! 351: int len;
! 352: int i;
! 353: write(fd, "Options :\n", 10);
! 354: for(i=0; i<num_options; i++)
! 355: {
! 356: len = snprintf(buffer, sizeof(buffer),
! 357: "opt=%02d %s\n",
! 358: ary_options[i].id, ary_options[i].value);
! 359: write(fd, buffer, len);
! 360: }
! 361: }
! 362:
! 363: static void
! 364: write_command_line(int fd, int argc, char * * argv)
! 365: {
! 366: char buffer[256];
! 367: int len;
! 368: int i;
! 369: write(fd, "Command Line :\n", 15);
! 370: for(i=0; i<argc; i++)
! 371: {
! 372: len = snprintf(buffer, sizeof(buffer),
! 373: "argv[%02d]='%s'\n",
! 374: i, argv[i]);
! 375: write(fd, buffer, len);
! 376: }
! 377: }
! 378:
! 379: #endif
! 380:
! 381: /* Handler for the SIGTERM signal (kill)
! 382: * SIGINT is also handled */
! 383: static void
! 384: sigterm(int sig)
! 385: {
! 386: /*int save_errno = errno;*/
! 387: signal(sig, SIG_IGN); /* Ignore this signal while we are quitting */
! 388:
! 389: syslog(LOG_NOTICE, "received signal %d, good-bye", sig);
! 390:
! 391: quitting = 1;
! 392: /*errno = save_errno;*/
! 393: }
! 394:
! 395: /* Handler for the SIGUSR1 signal indicating public IP address change. */
! 396: static void
! 397: sigusr1(int sig)
! 398: {
! 399: syslog(LOG_INFO, "received signal %d, public ip address change", sig);
! 400:
! 401: should_send_public_address_change_notif = 1;
! 402: }
! 403:
! 404: /* record the startup time, for returning uptime */
! 405: static void
! 406: set_startup_time(int sysuptime)
! 407: {
! 408: startup_time = time(NULL);
! 409: if(sysuptime)
! 410: {
! 411: /* use system uptime instead of daemon uptime */
! 412: #if defined(__linux__)
! 413: char buff[64];
! 414: int uptime = 0, fd;
! 415: fd = open("/proc/uptime", O_RDONLY);
! 416: if(fd < 0)
! 417: {
! 418: syslog(LOG_ERR, "open(\"/proc/uptime\" : %m");
! 419: }
! 420: else
! 421: {
! 422: memset(buff, 0, sizeof(buff));
! 423: if(read(fd, buff, sizeof(buff) - 1) < 0)
! 424: {
! 425: syslog(LOG_ERR, "read(\"/proc/uptime\" : %m");
! 426: }
! 427: else
! 428: {
! 429: uptime = atoi(buff);
! 430: syslog(LOG_INFO, "system uptime is %d seconds", uptime);
! 431: }
! 432: close(fd);
! 433: startup_time -= uptime;
! 434: }
! 435: #elif defined(SOLARIS_KSTATS)
! 436: kstat_ctl_t *kc;
! 437: kc = kstat_open();
! 438: if(kc != NULL)
! 439: {
! 440: kstat_t *ksp;
! 441: ksp = kstat_lookup(kc, "unix", 0, "system_misc");
! 442: if(ksp && (kstat_read(kc, ksp, NULL) != -1))
! 443: {
! 444: void *ptr = kstat_data_lookup(ksp, "boot_time");
! 445: if(ptr)
! 446: memcpy(&startup_time, ptr, sizeof(startup_time));
! 447: else
! 448: syslog(LOG_ERR, "cannot find boot_time kstat");
! 449: }
! 450: else
! 451: syslog(LOG_ERR, "cannot open kstats for unix/0/system_misc: %m");
! 452: kstat_close(kc);
! 453: }
! 454: #else
! 455: struct timeval boottime;
! 456: size_t size = sizeof(boottime);
! 457: int name[2] = { CTL_KERN, KERN_BOOTTIME };
! 458: if(sysctl(name, 2, &boottime, &size, NULL, 0) < 0)
! 459: {
! 460: syslog(LOG_ERR, "sysctl(\"kern.boottime\") failed");
! 461: }
! 462: else
! 463: {
! 464: startup_time = boottime.tv_sec;
! 465: }
! 466: #endif
! 467: }
! 468: }
! 469:
! 470: /* structure containing variables used during "main loop"
! 471: * that are filled during the init */
! 472: struct runtime_vars {
! 473: /* LAN IP addresses for SSDP traffic and HTTP */
! 474: /* moved to global vars */
! 475: /*int n_lan_addr;*/
! 476: /*struct lan_addr_s lan_addr[MAX_LAN_ADDR];*/
! 477: int port; /* HTTP Port */
! 478: int notify_interval; /* seconds between SSDP announces */
! 479: /* unused rules cleaning related variables : */
! 480: int clean_ruleset_threshold; /* threshold for removing unused rules */
! 481: int clean_ruleset_interval; /* (minimum) interval between checks */
! 482: };
! 483:
! 484: /* parselanaddr()
! 485: * parse address with mask
! 486: * ex: 192.168.1.1/24
! 487: * When MULTIPLE_EXTERNAL_IP is enabled, the ip address of the
! 488: * external interface associated with the lan subnet follows.
! 489: * ex : 192.168.1.1/24 81.21.41.11
! 490: *
! 491: * return value :
! 492: * 0 : ok
! 493: * -1 : error */
! 494: static int
! 495: parselanaddr(struct lan_addr_s * lan_addr, const char * str)
! 496: {
! 497: const char * p;
! 498: int nbits = 24; /* by default, networks are /24 */
! 499: int n;
! 500: p = str;
! 501: while(*p && *p != '/' && !isspace(*p))
! 502: p++;
! 503: n = p - str;
! 504: if(*p == '/')
! 505: {
! 506: nbits = atoi(++p);
! 507: while(*p && !isspace(*p))
! 508: p++;
! 509: }
! 510: if(n>15)
! 511: {
! 512: fprintf(stderr, "Error parsing address/mask : %s\n", str);
! 513: return -1;
! 514: }
! 515: memcpy(lan_addr->str, str, n);
! 516: lan_addr->str[n] = '\0';
! 517: if(!inet_aton(lan_addr->str, &lan_addr->addr))
! 518: {
! 519: fprintf(stderr, "Error parsing address/mask : %s\n", str);
! 520: return -1;
! 521: }
! 522: lan_addr->mask.s_addr = htonl(nbits ? (0xffffffff << (32 - nbits)) : 0);
! 523: #ifdef MULTIPLE_EXTERNAL_IP
! 524: /* skip spaces */
! 525: while(*p && isspace(*p))
! 526: p++;
! 527: if(*p) {
! 528: /* parse the exteral ip address to associate with this subnet */
! 529: n = 0;
! 530: while(p[n] && !isspace(*p))
! 531: n++;
! 532: if(n<=15) {
! 533: memcpy(lan_addr->ext_ip_str, p, n);
! 534: lan_addr->ext_ip_str[n] = '\0';
! 535: if(!inet_aton(lan_addr->ext_ip_str, &lan_addr->ext_ip_addr)) {
! 536: /* error */
! 537: fprintf(stderr, "Error parsing address : %s\n", lan_addr->ext_ip_str);
! 538: }
! 539: }
! 540: }
! 541: #endif
! 542: return 0;
! 543: }
! 544:
! 545: /* init phase :
! 546: * 1) read configuration file
! 547: * 2) read command line arguments
! 548: * 3) daemonize
! 549: * 4) open syslog
! 550: * 5) check and write pid file
! 551: * 6) set startup time stamp
! 552: * 7) compute presentation URL
! 553: * 8) set signal handlers */
! 554: static int
! 555: init(int argc, char * * argv, struct runtime_vars * v)
! 556: {
! 557: int i;
! 558: int pid;
! 559: int debug_flag = 0;
! 560: int options_flag = 0;
! 561: int openlog_option;
! 562: struct sigaction sa;
! 563: /*const char * logfilename = 0;*/
! 564: const char * presurl = 0;
! 565: const char * optionsfile = DEFAULT_CONFIG;
! 566:
! 567: /* only print usage if -h is used */
! 568: for(i=1; i<argc; i++)
! 569: {
! 570: if(0 == strcmp(argv[i], "-h"))
! 571: goto print_usage;
! 572: }
! 573: /* first check if "-f" option is used */
! 574: for(i=2; i<argc; i++)
! 575: {
! 576: if(0 == strcmp(argv[i-1], "-f"))
! 577: {
! 578: optionsfile = argv[i];
! 579: options_flag = 1;
! 580: break;
! 581: }
! 582: }
! 583:
! 584: /* set initial values */
! 585: SETFLAG(ENABLEUPNPMASK);
! 586:
! 587: /*v->n_lan_addr = 0;*/
! 588: v->port = -1;
! 589: v->notify_interval = 30; /* seconds between SSDP announces */
! 590: v->clean_ruleset_threshold = 20;
! 591: v->clean_ruleset_interval = 0; /* interval between ruleset check. 0=disabled */
! 592:
! 593: /* read options file first since
! 594: * command line arguments have final say */
! 595: if(readoptionsfile(optionsfile) < 0)
! 596: {
! 597: /* only error if file exists or using -f */
! 598: if(access(optionsfile, F_OK) == 0 || options_flag)
! 599: fprintf(stderr, "Error reading configuration file %s\n", optionsfile);
! 600: }
! 601: else
! 602: {
! 603: for(i=0; i<num_options; i++)
! 604: {
! 605: switch(ary_options[i].id)
! 606: {
! 607: case UPNPEXT_IFNAME:
! 608: ext_if_name = ary_options[i].value;
! 609: break;
! 610: case UPNPEXT_IP:
! 611: use_ext_ip_addr = ary_options[i].value;
! 612: break;
! 613: case UPNPLISTENING_IP:
! 614: if(n_lan_addr < MAX_LAN_ADDR)/* if(v->n_lan_addr < MAX_LAN_ADDR)*/
! 615: {
! 616: /*if(parselanaddr(&v->lan_addr[v->n_lan_addr],*/
! 617: if(parselanaddr(&lan_addr[n_lan_addr],
! 618: ary_options[i].value) == 0)
! 619: n_lan_addr++; /*v->n_lan_addr++; */
! 620: }
! 621: else
! 622: {
! 623: fprintf(stderr, "Too many listening ips (max: %d), ignoring %s\n",
! 624: MAX_LAN_ADDR, ary_options[i].value);
! 625: }
! 626: break;
! 627: case UPNPPORT:
! 628: v->port = atoi(ary_options[i].value);
! 629: break;
! 630: case UPNPBITRATE_UP:
! 631: upstream_bitrate = strtoul(ary_options[i].value, 0, 0);
! 632: break;
! 633: case UPNPBITRATE_DOWN:
! 634: downstream_bitrate = strtoul(ary_options[i].value, 0, 0);
! 635: break;
! 636: case UPNPPRESENTATIONURL:
! 637: presurl = ary_options[i].value;
! 638: break;
! 639: #ifdef USE_NETFILTER
! 640: case UPNPFORWARDCHAIN:
! 641: miniupnpd_forward_chain = ary_options[i].value;
! 642: break;
! 643: case UPNPNATCHAIN:
! 644: miniupnpd_nat_chain = ary_options[i].value;
! 645: break;
! 646: #endif
! 647: case UPNPNOTIFY_INTERVAL:
! 648: v->notify_interval = atoi(ary_options[i].value);
! 649: break;
! 650: case UPNPSYSTEM_UPTIME:
! 651: if(strcmp(ary_options[i].value, "yes") == 0)
! 652: SETFLAG(SYSUPTIMEMASK); /*sysuptime = 1;*/
! 653: break;
! 654: case UPNPPACKET_LOG:
! 655: if(strcmp(ary_options[i].value, "yes") == 0)
! 656: SETFLAG(LOGPACKETSMASK); /*logpackets = 1;*/
! 657: break;
! 658: case UPNPUUID:
! 659: strncpy(uuidvalue+5, ary_options[i].value,
! 660: strlen(uuidvalue+5) + 1);
! 661: break;
! 662: case UPNPSERIAL:
! 663: strncpy(serialnumber, ary_options[i].value, SERIALNUMBER_MAX_LEN);
! 664: serialnumber[SERIALNUMBER_MAX_LEN-1] = '\0';
! 665: break;
! 666: case UPNPMODEL_NUMBER:
! 667: strncpy(modelnumber, ary_options[i].value, MODELNUMBER_MAX_LEN);
! 668: modelnumber[MODELNUMBER_MAX_LEN-1] = '\0';
! 669: break;
! 670: case UPNPCLEANTHRESHOLD:
! 671: v->clean_ruleset_threshold = atoi(ary_options[i].value);
! 672: break;
! 673: case UPNPCLEANINTERVAL:
! 674: v->clean_ruleset_interval = atoi(ary_options[i].value);
! 675: break;
! 676: #ifdef USE_PF
! 677: case UPNPQUEUE:
! 678: queue = ary_options[i].value;
! 679: break;
! 680: case UPNPTAG:
! 681: tag = ary_options[i].value;
! 682: break;
! 683: #endif
! 684: #ifdef ENABLE_NATPMP
! 685: case UPNPENABLENATPMP:
! 686: if(strcmp(ary_options[i].value, "yes") == 0)
! 687: SETFLAG(ENABLENATPMPMASK); /*enablenatpmp = 1;*/
! 688: else
! 689: if(atoi(ary_options[i].value))
! 690: SETFLAG(ENABLENATPMPMASK);
! 691: /*enablenatpmp = atoi(ary_options[i].value);*/
! 692: break;
! 693: #endif
! 694: #ifdef PF_ENABLE_FILTER_RULES
! 695: case UPNPQUICKRULES:
! 696: if(strcmp(ary_options[i].value, "no") == 0)
! 697: SETFLAG(PFNOQUICKRULESMASK);
! 698: break;
! 699: #endif
! 700: case UPNPENABLE:
! 701: if(strcmp(ary_options[i].value, "yes") != 0)
! 702: CLEARFLAG(ENABLEUPNPMASK);
! 703: break;
! 704: case UPNPSECUREMODE:
! 705: if(strcmp(ary_options[i].value, "yes") == 0)
! 706: SETFLAG(SECUREMODEMASK);
! 707: break;
! 708: #ifdef ENABLE_LEASEFILE
! 709: case UPNPLEASEFILE:
! 710: lease_file = ary_options[i].value;
! 711: break;
! 712: #endif
! 713: case UPNPMINISSDPDSOCKET:
! 714: minissdpdsocketpath = ary_options[i].value;
! 715: break;
! 716: default:
! 717: fprintf(stderr, "Unknown option in file %s\n",
! 718: optionsfile);
! 719: }
! 720: }
! 721: }
! 722:
! 723: /* command line arguments processing */
! 724: for(i=1; i<argc; i++)
! 725: {
! 726: if(argv[i][0]!='-')
! 727: {
! 728: fprintf(stderr, "Unknown option: %s\n", argv[i]);
! 729: }
! 730: else switch(argv[i][1])
! 731: {
! 732: case 'o':
! 733: if(i+1 < argc)
! 734: use_ext_ip_addr = argv[++i];
! 735: else
! 736: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 737: break;
! 738: case 't':
! 739: if(i+1 < argc)
! 740: v->notify_interval = atoi(argv[++i]);
! 741: else
! 742: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 743: break;
! 744: case 'u':
! 745: if(i+1 < argc)
! 746: strncpy(uuidvalue+5, argv[++i], strlen(uuidvalue+5) + 1);
! 747: else
! 748: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 749: break;
! 750: case 's':
! 751: if(i+1 < argc)
! 752: strncpy(serialnumber, argv[++i], SERIALNUMBER_MAX_LEN);
! 753: else
! 754: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 755: serialnumber[SERIALNUMBER_MAX_LEN-1] = '\0';
! 756: break;
! 757: case 'm':
! 758: if(i+1 < argc)
! 759: strncpy(modelnumber, argv[++i], MODELNUMBER_MAX_LEN);
! 760: else
! 761: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 762: modelnumber[MODELNUMBER_MAX_LEN-1] = '\0';
! 763: break;
! 764: #ifdef ENABLE_NATPMP
! 765: case 'N':
! 766: /*enablenatpmp = 1;*/
! 767: SETFLAG(ENABLENATPMPMASK);
! 768: break;
! 769: #endif
! 770: case 'U':
! 771: /*sysuptime = 1;*/
! 772: SETFLAG(SYSUPTIMEMASK);
! 773: break;
! 774: /*case 'l':
! 775: logfilename = argv[++i];
! 776: break;*/
! 777: case 'L':
! 778: /*logpackets = 1;*/
! 779: SETFLAG(LOGPACKETSMASK);
! 780: break;
! 781: case 'S':
! 782: SETFLAG(SECUREMODEMASK);
! 783: break;
! 784: case 'i':
! 785: if(i+1 < argc)
! 786: ext_if_name = argv[++i];
! 787: else
! 788: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 789: break;
! 790: #ifdef USE_PF
! 791: case 'q':
! 792: if(i+1 < argc)
! 793: queue = argv[++i];
! 794: else
! 795: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 796: break;
! 797: case 'T':
! 798: if(i+1 < argc)
! 799: tag = argv[++i];
! 800: else
! 801: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 802: break;
! 803: #endif
! 804: case 'p':
! 805: if(i+1 < argc)
! 806: v->port = atoi(argv[++i]);
! 807: else
! 808: #ifdef ENABLE_NFQUEUE
! 809: case 'Q':
! 810: if(i+1<argc)
! 811: {
! 812: nfqueue = atoi(argv[++i]);
! 813: }
! 814: else
! 815: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 816: break;
! 817: case 'n':
! 818: if (i+1 < argc) {
! 819: i++;
! 820: if(n_nfqix < MAX_LAN_ADDR) {
! 821: nfqix[n_nfqix++] = if_nametoindex(argv[i]);
! 822: } else {
! 823: fprintf(stderr,"Too many nfq interfaces. Ignoring %s\n", argv[i]);
! 824: }
! 825: } else {
! 826: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 827: }
! 828: break;
! 829: #endif
! 830: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 831: break;
! 832: case 'P':
! 833: if(i+1 < argc)
! 834: pidfilename = argv[++i];
! 835: else
! 836: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 837: break;
! 838: case 'd':
! 839: debug_flag = 1;
! 840: break;
! 841: case 'w':
! 842: if(i+1 < argc)
! 843: presurl = argv[++i];
! 844: else
! 845: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 846: break;
! 847: case 'B':
! 848: if(i+2<argc)
! 849: {
! 850: downstream_bitrate = strtoul(argv[++i], 0, 0);
! 851: upstream_bitrate = strtoul(argv[++i], 0, 0);
! 852: }
! 853: else
! 854: fprintf(stderr, "Option -%c takes two arguments.\n", argv[i][1]);
! 855: break;
! 856: case 'a':
! 857: if(i+1 < argc)
! 858: {
! 859: int address_already_there = 0;
! 860: int j;
! 861: i++;
! 862: for(j=0; j<n_lan_addr; j++)
! 863: {
! 864: struct lan_addr_s tmpaddr;
! 865: parselanaddr(&tmpaddr, argv[i]);
! 866: if(0 == strcmp(lan_addr[j].str, tmpaddr.str))
! 867: address_already_there = 1;
! 868: }
! 869: if(address_already_there)
! 870: break;
! 871: if(n_lan_addr < MAX_LAN_ADDR)
! 872: {
! 873: if(parselanaddr(&lan_addr[n_lan_addr], argv[i]) == 0)
! 874: n_lan_addr++;
! 875: }
! 876: else
! 877: {
! 878: fprintf(stderr, "Too many listening ips (max: %d), ignoring %s\n",
! 879: MAX_LAN_ADDR, argv[i]);
! 880: }
! 881: }
! 882: else
! 883: fprintf(stderr, "Option -%c takes one argument.\n", argv[i][1]);
! 884: break;
! 885: case 'f':
! 886: i++; /* discarding, the config file is already read */
! 887: break;
! 888: default:
! 889: fprintf(stderr, "Unknown option: %s\n", argv[i]);
! 890: }
! 891: }
! 892: if(!ext_if_name || (n_lan_addr==0))
! 893: {
! 894: /* bad configuration */
! 895: goto print_usage;
! 896: }
! 897:
! 898: if(debug_flag)
! 899: {
! 900: pid = getpid();
! 901: }
! 902: else
! 903: {
! 904: #ifdef USE_DAEMON
! 905: if(daemon(0, 0)<0) {
! 906: perror("daemon()");
! 907: }
! 908: pid = getpid();
! 909: #else
! 910: pid = daemonize();
! 911: #endif
! 912: }
! 913:
! 914: openlog_option = LOG_PID|LOG_CONS;
! 915: if(debug_flag)
! 916: {
! 917: openlog_option |= LOG_PERROR; /* also log on stderr */
! 918: }
! 919:
! 920: openlog("miniupnpd", openlog_option, LOG_MINIUPNPD);
! 921:
! 922: if(!debug_flag)
! 923: {
! 924: /* speed things up and ignore LOG_INFO and LOG_DEBUG */
! 925: setlogmask(LOG_UPTO(LOG_NOTICE));
! 926: }
! 927:
! 928: if(checkforrunning(pidfilename) < 0)
! 929: {
! 930: syslog(LOG_ERR, "MiniUPnPd is already running. EXITING");
! 931: return 1;
! 932: }
! 933:
! 934: set_startup_time(GETFLAG(SYSUPTIMEMASK));
! 935:
! 936: /* presentation url */
! 937: if(presurl)
! 938: {
! 939: strncpy(presentationurl, presurl, PRESENTATIONURL_MAX_LEN);
! 940: presentationurl[PRESENTATIONURL_MAX_LEN-1] = '\0';
! 941: }
! 942: else
! 943: {
! 944: snprintf(presentationurl, PRESENTATIONURL_MAX_LEN,
! 945: "http://%s/", lan_addr[0].str);
! 946: /*"http://%s:%d/", lan_addr[0].str, 80);*/
! 947: }
! 948:
! 949: /* set signal handler */
! 950: memset(&sa, 0, sizeof(struct sigaction));
! 951: sa.sa_handler = sigterm;
! 952:
! 953: if (sigaction(SIGTERM, &sa, NULL))
! 954: {
! 955: syslog(LOG_ERR, "Failed to set %s handler. EXITING", "SIGTERM");
! 956: return 1;
! 957: }
! 958: if (sigaction(SIGINT, &sa, NULL))
! 959: {
! 960: syslog(LOG_ERR, "Failed to set %s handler. EXITING", "SIGINT");
! 961: return 1;
! 962: }
! 963:
! 964: if(signal(SIGPIPE, SIG_IGN) == SIG_ERR) {
! 965: syslog(LOG_ERR, "Failed to ignore SIGPIPE signals");
! 966: }
! 967:
! 968: sa.sa_handler = sigusr1;
! 969: if (sigaction(SIGUSR1, &sa, NULL))
! 970: {
! 971: syslog(LOG_NOTICE, "Failed to set %s handler", "SIGUSR1");
! 972: }
! 973:
! 974: if(init_redirect() < 0)
! 975: {
! 976: syslog(LOG_ERR, "Failed to init redirection engine. EXITING");
! 977: return 1;
! 978: }
! 979:
! 980: writepidfile(pidfilename, pid);
! 981:
! 982: #ifdef ENABLE_LEASEFILE
! 983: /*remove(lease_file);*/
! 984: syslog(LOG_INFO, "Reloading rules from lease file");
! 985: reload_from_lease_file();
! 986: #endif
! 987:
! 988: return 0;
! 989: print_usage:
! 990: fprintf(stderr, "Usage:\n\t"
! 991: "%s [-f config_file] [-i ext_ifname] [-o ext_ip]\n"
! 992: #ifndef ENABLE_NATPMP
! 993: "\t\t[-a listening_ip] [-p port] [-d] [-L] [-U] [-S]\n"
! 994: #else
! 995: "\t\t[-a listening_ip] [-p port] [-d] [-L] [-U] [-S] [-N]\n"
! 996: #endif
! 997: /*"[-l logfile] " not functionnal */
! 998: "\t\t[-u uuid] [-s serial] [-m model_number] \n"
! 999: "\t\t[-t notify_interval] [-P pid_filename]\n"
! 1000: "\t\t[-B down up] [-w url]\n"
! 1001: #ifdef USE_PF
! 1002: "\t\t[-q queue] [-T tag]\n"
! 1003: #endif
! 1004: #ifdef ENABLE_NFQUEUE
! 1005: "\t\t[-Q queue] [-n name]\n"
! 1006: #endif
! 1007: "\nNotes:\n\tThere can be one or several listening_ips.\n"
! 1008: "\tNotify interval is in seconds. Default is 30 seconds.\n"
! 1009: "\tDefault pid file is '%s'.\n"
! 1010: "\tDefault config file is '%s'.\n"
! 1011: "\tWith -d miniupnpd will run as a standard program.\n"
! 1012: "\t-L sets packet log in pf and ipf on.\n"
! 1013: "\t-S sets \"secure\" mode : clients can only add mappings to their own ip\n"
! 1014: "\t-U causes miniupnpd to report system uptime instead "
! 1015: "of daemon uptime.\n"
! 1016: #ifdef ENABLE_NATPMP
! 1017: "\t-N enable NAT-PMP functionnality.\n"
! 1018: #endif
! 1019: "\t-B sets bitrates reported by daemon in bits per second.\n"
! 1020: "\t-w sets the presentation url. Default is http address on port 80\n"
! 1021: #ifdef USE_PF
! 1022: "\t-q sets the ALTQ queue in pf.\n"
! 1023: "\t-T sets the tag name in pf.\n"
! 1024: #endif
! 1025: #ifdef ENABLE_NFQUEUE
! 1026: "\t-Q sets the queue number that is used by NFQUEUE.\n"
! 1027: "\t-n sets the name of the interface(s) that packets will arrive on.\n"
! 1028: #endif
! 1029: "\t-h prints this help and quits.\n"
! 1030: "", argv[0], pidfilename, DEFAULT_CONFIG);
! 1031: return 1;
! 1032: }
! 1033:
! 1034: /* === main === */
! 1035: /* process HTTP or SSDP requests */
! 1036: int
! 1037: main(int argc, char * * argv)
! 1038: {
! 1039: int i;
! 1040: int shttpl = -1;
! 1041: #ifdef ENABLE_NATPMP
! 1042: int snatpmp[MAX_LAN_ADDR];
! 1043: #ifdef ENABLE_NFQUEUE
! 1044: int nfqh = -1;
! 1045: #endif
! 1046: #endif
! 1047: int snotify[MAX_LAN_ADDR];
! 1048: LIST_HEAD(httplisthead, upnphttp) upnphttphead;
! 1049: struct upnphttp * e = 0;
! 1050: struct upnphttp * next;
! 1051: fd_set readset; /* for select() */
! 1052: #ifdef ENABLE_EVENTS
! 1053: fd_set writeset;
! 1054: #endif
! 1055: struct timeval timeout, timeofday, lasttimeofday = {0, 0};
! 1056: int max_fd = -1;
! 1057: #ifdef USE_MINIUPNPDCTL
! 1058: int sctl = -1;
! 1059: LIST_HEAD(ctlstructhead, ctlelem) ctllisthead;
! 1060: struct ctlelem * ectl;
! 1061: struct ctlelem * ectlnext;
! 1062: #endif
! 1063: struct runtime_vars v;
! 1064: /* variables used for the unused-rule cleanup process */
! 1065: struct rule_state * rule_list = 0;
! 1066: struct timeval checktime = {0, 0};
! 1067: syslog(LOG_INFO, "SNet version started");
! 1068:
! 1069:
! 1070: memset(snotify, 0, sizeof(snotify));
! 1071: #ifdef ENABLE_NATPMP
! 1072: for(i = 0; i < MAX_LAN_ADDR; i++)
! 1073: snatpmp[i] = -1;
! 1074: #endif
! 1075: if(init(argc, argv, &v) != 0)
! 1076: return 1;
! 1077:
! 1078: LIST_INIT(&upnphttphead);
! 1079: #ifdef USE_MINIUPNPDCTL
! 1080: LIST_INIT(&ctllisthead);
! 1081: #endif
! 1082:
! 1083: if(
! 1084: #ifdef ENABLE_NATPMP
! 1085: !GETFLAG(ENABLENATPMPMASK) &&
! 1086: #endif
! 1087: !GETFLAG(ENABLEUPNPMASK) ) {
! 1088: syslog(LOG_ERR, "Why did you run me anyway?");
! 1089: return 0;
! 1090: }
! 1091:
! 1092: if(GETFLAG(ENABLEUPNPMASK))
! 1093: {
! 1094:
! 1095: /* open socket for HTTP connections. Listen on the 1st LAN address */
! 1096: shttpl = OpenAndConfHTTPSocket((v.port > 0) ? v.port : 0);
! 1097: if(shttpl < 0)
! 1098: {
! 1099: syslog(LOG_ERR, "Failed to open socket for HTTP. EXITING");
! 1100: return 1;
! 1101: }
! 1102: if(v.port <= 0) {
! 1103: struct sockaddr_in sockinfo;
! 1104: socklen_t len = sizeof(struct sockaddr_in);
! 1105: if (getsockname(shttpl, (struct sockaddr *)&sockinfo, &len) < 0) {
! 1106: syslog(LOG_ERR, "getsockname(): %m");
! 1107: return 1;
! 1108: }
! 1109: v.port = ntohs(sockinfo.sin_port);
! 1110: }
! 1111: syslog(LOG_NOTICE, "HTTP listening on port %d", v.port);
! 1112:
! 1113: /* open socket for SSDP connections */
! 1114: sudp = OpenAndConfSSDPReceiveSocket(n_lan_addr, lan_addr);
! 1115: if(sudp < 0)
! 1116: {
! 1117: syslog(LOG_INFO, "Failed to open socket for receiving SSDP. Trying to use MiniSSDPd");
! 1118: if(SubmitServicesToMiniSSDPD(lan_addr[0].str, v.port) < 0) {
! 1119: syslog(LOG_ERR, "Failed to connect to MiniSSDPd. EXITING");
! 1120: return 1;
! 1121: }
! 1122: }
! 1123:
! 1124: /* open socket for sending notifications */
! 1125: if(OpenAndConfSSDPNotifySockets(snotify) < 0)
! 1126: {
! 1127: syslog(LOG_ERR, "Failed to open sockets for sending SSDP notify "
! 1128: "messages. EXITING");
! 1129: return 1;
! 1130: }
! 1131: }
! 1132:
! 1133: #ifdef ENABLE_NATPMP
! 1134: /* open socket for NAT PMP traffic */
! 1135: if(GETFLAG(ENABLENATPMPMASK))
! 1136: {
! 1137: if(OpenAndConfNATPMPSockets(snatpmp) < 0)
! 1138: {
! 1139: syslog(LOG_ERR, "Failed to open sockets for NAT PMP.");
! 1140: } else {
! 1141: syslog(LOG_NOTICE, "Listening for NAT-PMP traffic on port %u",
! 1142: NATPMP_PORT);
! 1143: }
! 1144: ScanNATPMPforExpiration();
! 1145: }
! 1146: #endif
! 1147:
! 1148: /* for miniupnpdctl */
! 1149: #ifdef USE_MINIUPNPDCTL
! 1150: sctl = OpenAndConfCtlUnixSocket("/var/run/miniupnpd.ctl");
! 1151: #endif
! 1152:
! 1153: #ifdef ENABLE_NFQUEUE
! 1154: if ( nfqueue != -1 && n_nfqix > 0) {
! 1155: nfqh = OpenAndConfNFqueue();
! 1156: if(nfqh < 0) {
! 1157: syslog(LOG_ERR, "Failed to open fd for NFQUEUE.");
! 1158: return 1;
! 1159: } else {
! 1160: syslog(LOG_NOTICE, "Opened NFQUEUE %d",nfqueue);
! 1161: }
! 1162: }
! 1163: #endif
! 1164: /* main loop */
! 1165: while(!quitting)
! 1166: {
! 1167: /* Correct startup_time if it was set with a RTC close to 0 */
! 1168: if((startup_time<60*60*24) && (time(NULL)>60*60*24))
! 1169: {
! 1170: set_startup_time(GETFLAG(SYSUPTIMEMASK));
! 1171: }
! 1172: /* Check if we need to send SSDP NOTIFY messages and do it if
! 1173: * needed */
! 1174: if(gettimeofday(&timeofday, 0) < 0)
! 1175: {
! 1176: syslog(LOG_ERR, "gettimeofday(): %m");
! 1177: timeout.tv_sec = v.notify_interval;
! 1178: timeout.tv_usec = 0;
! 1179: }
! 1180: else
! 1181: {
! 1182: /* the comparaison is not very precise but who cares ? */
! 1183: if(timeofday.tv_sec >= (lasttimeofday.tv_sec + v.notify_interval))
! 1184: {
! 1185: if (GETFLAG(ENABLEUPNPMASK))
! 1186: SendSSDPNotifies2(snotify,
! 1187: (unsigned short)v.port,
! 1188: v.notify_interval << 1);
! 1189: memcpy(&lasttimeofday, &timeofday, sizeof(struct timeval));
! 1190: timeout.tv_sec = v.notify_interval;
! 1191: timeout.tv_usec = 0;
! 1192: }
! 1193: else
! 1194: {
! 1195: timeout.tv_sec = lasttimeofday.tv_sec + v.notify_interval
! 1196: - timeofday.tv_sec;
! 1197: if(timeofday.tv_usec > lasttimeofday.tv_usec)
! 1198: {
! 1199: timeout.tv_usec = 1000000 + lasttimeofday.tv_usec
! 1200: - timeofday.tv_usec;
! 1201: timeout.tv_sec--;
! 1202: }
! 1203: else
! 1204: {
! 1205: timeout.tv_usec = lasttimeofday.tv_usec - timeofday.tv_usec;
! 1206: }
! 1207: }
! 1208: }
! 1209: /* remove unused rules */
! 1210: if( v.clean_ruleset_interval
! 1211: && (timeofday.tv_sec >= checktime.tv_sec + v.clean_ruleset_interval))
! 1212: {
! 1213: if(rule_list)
! 1214: {
! 1215: remove_unused_rules(rule_list);
! 1216: rule_list = NULL;
! 1217: }
! 1218: else
! 1219: {
! 1220: rule_list = get_upnp_rules_state_list(v.clean_ruleset_threshold);
! 1221: }
! 1222: memcpy(&checktime, &timeofday, sizeof(struct timeval));
! 1223: }
! 1224: #ifdef ENABLE_NATPMP
! 1225: /* Remove expired NAT-PMP mappings */
! 1226: while( nextnatpmptoclean_timestamp && (timeofday.tv_sec >= nextnatpmptoclean_timestamp + startup_time))
! 1227: {
! 1228: /*syslog(LOG_DEBUG, "cleaning expired NAT-PMP mappings");*/
! 1229: if(CleanExpiredNATPMP() < 0) {
! 1230: syslog(LOG_ERR, "CleanExpiredNATPMP() failed");
! 1231: break;
! 1232: }
! 1233: }
! 1234: if(nextnatpmptoclean_timestamp && timeout.tv_sec >= (nextnatpmptoclean_timestamp + startup_time - timeofday.tv_sec))
! 1235: {
! 1236: /*syslog(LOG_DEBUG, "setting timeout to %d sec", nextnatpmptoclean_timestamp + startup_time - timeofday.tv_sec);*/
! 1237: #ifdef ENABLE_NFQUEUE
! 1238: if (nfqh >= 0)
! 1239: {
! 1240: FD_SET(nfqh, &readset);
! 1241: max_fd = MAX( max_fd, nfqh);
! 1242: }
! 1243: #endif
! 1244:
! 1245: timeout.tv_sec = nextnatpmptoclean_timestamp + startup_time - timeofday.tv_sec;
! 1246: timeout.tv_usec = 0;
! 1247: }
! 1248: #endif
! 1249:
! 1250: /* select open sockets (SSDP, HTTP listen, and all HTTP soap sockets) */
! 1251: FD_ZERO(&readset);
! 1252:
! 1253: if (sudp >= 0)
! 1254: {
! 1255: FD_SET(sudp, &readset);
! 1256: max_fd = MAX( max_fd, sudp);
! 1257: }
! 1258:
! 1259: if (shttpl >= 0)
! 1260: {
! 1261: FD_SET(shttpl, &readset);
! 1262: max_fd = MAX( max_fd, shttpl);
! 1263: }
! 1264:
! 1265: i = 0; /* active HTTP connections count */
! 1266: for(e = upnphttphead.lh_first; e != NULL; e = e->entries.le_next)
! 1267: {
! 1268: if((e->socket >= 0) && (e->state <= 2))
! 1269: {
! 1270: FD_SET(e->socket, &readset);
! 1271: max_fd = MAX( max_fd, e->socket);
! 1272: i++;
! 1273: }
! 1274: }
! 1275: /* for debug */
! 1276: #ifdef DEBUG
! 1277: if(i > 1)
! 1278: {
! 1279: syslog(LOG_DEBUG, "%d active incoming HTTP connections", i);
! 1280: }
! 1281: #endif
! 1282: #ifdef ENABLE_NATPMP
! 1283: for(i=0; i<n_lan_addr; i++) {
! 1284: if(snatpmp[i] >= 0) {
! 1285: FD_SET(snatpmp[i], &readset);
! 1286: max_fd = MAX( max_fd, snatpmp[i]);
! 1287: }
! 1288: }
! 1289: #endif
! 1290: #ifdef USE_MINIUPNPDCTL
! 1291: if(sctl >= 0) {
! 1292: FD_SET(sctl, &readset);
! 1293: max_fd = MAX( max_fd, sctl);
! 1294: }
! 1295:
! 1296: for(ectl = ctllisthead.lh_first; ectl; ectl = ectl->entries.le_next)
! 1297: {
! 1298: if(ectl->socket >= 0) {
! 1299: FD_SET(ectl->socket, &readset);
! 1300: max_fd = MAX( max_fd, ectl->socket);
! 1301: }
! 1302: }
! 1303: #endif
! 1304:
! 1305: #ifdef ENABLE_EVENTS
! 1306: FD_ZERO(&writeset);
! 1307: upnpevents_selectfds(&readset, &writeset, &max_fd);
! 1308: #endif
! 1309:
! 1310: #ifdef ENABLE_EVENTS
! 1311: if(select(max_fd+1, &readset, &writeset, 0, &timeout) < 0)
! 1312: #else
! 1313: if(select(max_fd+1, &readset, 0, 0, &timeout) < 0)
! 1314: #endif
! 1315: {
! 1316: if(quitting) goto shutdown;
! 1317: if(errno == EINTR) continue; /* interrupted by a signal, start again */
! 1318: syslog(LOG_ERR, "select(all): %m");
! 1319: syslog(LOG_ERR, "Failed to select open sockets. EXITING");
! 1320: return 1; /* very serious cause of error */
! 1321: }
! 1322: #ifdef USE_MINIUPNPDCTL
! 1323: for(ectl = ctllisthead.lh_first; ectl;)
! 1324: {
! 1325: ectlnext = ectl->entries.le_next;
! 1326: if((ectl->socket >= 0) && FD_ISSET(ectl->socket, &readset))
! 1327: {
! 1328: char buf[256];
! 1329: int l;
! 1330: l = read(ectl->socket, buf, sizeof(buf));
! 1331: if(l > 0)
! 1332: {
! 1333: /*write(ectl->socket, buf, l);*/
! 1334: write_command_line(ectl->socket, argc, argv);
! 1335: write_option_list(ectl->socket);
! 1336: write_permlist(ectl->socket, upnppermlist, num_upnpperm);
! 1337: write_upnphttp_details(ectl->socket, upnphttphead.lh_first);
! 1338: write_ctlsockets_list(ectl->socket, ctllisthead.lh_first);
! 1339: write_ruleset_details(ectl->socket);
! 1340: #ifdef ENABLE_EVENTS
! 1341: write_events_details(ectl->socket);
! 1342: #endif
! 1343: /* close the socket */
! 1344: close(ectl->socket);
! 1345: ectl->socket = -1;
! 1346: }
! 1347: else
! 1348: {
! 1349: close(ectl->socket);
! 1350: ectl->socket = -1;
! 1351: }
! 1352: }
! 1353: if(ectl->socket < 0)
! 1354: {
! 1355: LIST_REMOVE(ectl, entries);
! 1356: free(ectl);
! 1357: }
! 1358: ectl = ectlnext;
! 1359: }
! 1360: if((sctl >= 0) && FD_ISSET(sctl, &readset))
! 1361: {
! 1362: int s;
! 1363: struct sockaddr_un clientname;
! 1364: struct ctlelem * tmp;
! 1365: socklen_t clientnamelen = sizeof(struct sockaddr_un);
! 1366: //syslog(LOG_DEBUG, "sctl!");
! 1367: s = accept(sctl, (struct sockaddr *)&clientname,
! 1368: &clientnamelen);
! 1369: syslog(LOG_DEBUG, "sctl! : '%s'", clientname.sun_path);
! 1370: tmp = malloc(sizeof(struct ctlelem));
! 1371: tmp->socket = s;
! 1372: LIST_INSERT_HEAD(&ctllisthead, tmp, entries);
! 1373: }
! 1374: #endif
! 1375: #ifdef ENABLE_EVENTS
! 1376: upnpevents_processfds(&readset, &writeset);
! 1377: #endif
! 1378: #ifdef ENABLE_NATPMP
! 1379: /* process NAT-PMP packets */
! 1380: for(i=0; i<n_lan_addr; i++)
! 1381: {
! 1382: if((snatpmp[i] >= 0) && FD_ISSET(snatpmp[i], &readset))
! 1383: {
! 1384: ProcessIncomingNATPMPPacket(snatpmp[i]);
! 1385: }
! 1386: }
! 1387: #endif
! 1388: /* process SSDP packets */
! 1389: if(sudp >= 0 && FD_ISSET(sudp, &readset))
! 1390: {
! 1391: /*syslog(LOG_INFO, "Received UDP Packet");*/
! 1392: ProcessSSDPRequest(sudp, (unsigned short)v.port);
! 1393: }
! 1394: /* process active HTTP connections */
! 1395: /* LIST_FOREACH macro is not available under linux */
! 1396: for(e = upnphttphead.lh_first; e != NULL; e = e->entries.le_next)
! 1397: {
! 1398: if( (e->socket >= 0) && (e->state <= 2)
! 1399: &&(FD_ISSET(e->socket, &readset)) )
! 1400: {
! 1401: Process_upnphttp(e);
! 1402: }
! 1403: }
! 1404: /* process incoming HTTP connections */
! 1405: if(shttpl >= 0 && FD_ISSET(shttpl, &readset))
! 1406: {
! 1407: int shttp;
! 1408: socklen_t clientnamelen;
! 1409: struct sockaddr_in clientname;
! 1410: clientnamelen = sizeof(struct sockaddr_in);
! 1411: shttp = accept(shttpl, (struct sockaddr *)&clientname, &clientnamelen);
! 1412: if(shttp<0)
! 1413: {
! 1414: syslog(LOG_ERR, "accept(http): %m");
! 1415: }
! 1416: else
! 1417: {
! 1418: struct upnphttp * tmp = 0;
! 1419: syslog(LOG_INFO, "HTTP connection from %s:%d",
! 1420: inet_ntoa(clientname.sin_addr),
! 1421: ntohs(clientname.sin_port) );
! 1422: /*if (fcntl(shttp, F_SETFL, O_NONBLOCK) < 0) {
! 1423: syslog(LOG_ERR, "fcntl F_SETFL, O_NONBLOCK");
! 1424: }*/
! 1425: #ifdef ENABLE_NFQUEUE
! 1426: /* process NFQ packets */
! 1427: if(nfqh >= 0 && FD_ISSET(nfqh, &readset))
! 1428: {
! 1429: /* syslog(LOG_INFO, "Received NFQUEUE Packet");*/
! 1430: ProcessNFQUEUE(nfqh);
! 1431: }
! 1432: #endif
! 1433: /* Create a new upnphttp object and add it to
! 1434: * the active upnphttp object list */
! 1435: tmp = New_upnphttp(shttp);
! 1436: if(tmp)
! 1437: {
! 1438: tmp->clientaddr = clientname.sin_addr;
! 1439: LIST_INSERT_HEAD(&upnphttphead, tmp, entries);
! 1440: }
! 1441: else
! 1442: {
! 1443: syslog(LOG_ERR, "New_upnphttp() failed");
! 1444: close(shttp);
! 1445: }
! 1446: }
! 1447: }
! 1448: /* delete finished HTTP connections */
! 1449: for(e = upnphttphead.lh_first; e != NULL; )
! 1450: {
! 1451: next = e->entries.le_next;
! 1452: if(e->state >= 100)
! 1453: {
! 1454: LIST_REMOVE(e, entries);
! 1455: Delete_upnphttp(e);
! 1456: }
! 1457: e = next;
! 1458: }
! 1459:
! 1460: /* send public address change notifications */
! 1461: if(should_send_public_address_change_notif)
! 1462: {
! 1463: #ifdef ENABLE_NATPMP
! 1464: if(GETFLAG(ENABLENATPMPMASK))
! 1465: SendNATPMPPublicAddressChangeNotification(snatpmp/*snotify*/, n_lan_addr);
! 1466: #endif
! 1467: #ifdef ENABLE_EVENTS
! 1468: if(GETFLAG(ENABLEUPNPMASK))
! 1469: {
! 1470: upnp_event_var_change_notify(EWanIPC);
! 1471: }
! 1472: #endif
! 1473: should_send_public_address_change_notif = 0;
! 1474: }
! 1475: } /* end of main loop */
! 1476:
! 1477: shutdown:
! 1478: /* close out open sockets */
! 1479: while(upnphttphead.lh_first != NULL)
! 1480: {
! 1481: e = upnphttphead.lh_first;
! 1482: LIST_REMOVE(e, entries);
! 1483: Delete_upnphttp(e);
! 1484: }
! 1485:
! 1486: if (sudp >= 0) close(sudp);
! 1487: if (shttpl >= 0) close(shttpl);
! 1488: #ifdef ENABLE_NATPMP
! 1489: for(i=0; i<n_lan_addr; i++) {
! 1490: if(snatpmp[i]>=0)
! 1491: {
! 1492: close(snatpmp[i]);
! 1493: snatpmp[i] = -1;
! 1494: }
! 1495: }
! 1496: #endif
! 1497: #ifdef USE_MINIUPNPDCTL
! 1498: if(sctl>=0)
! 1499: {
! 1500: close(sctl);
! 1501: sctl = -1;
! 1502: if(unlink("/var/run/miniupnpd.ctl") < 0)
! 1503: {
! 1504: syslog(LOG_ERR, "unlink() %m");
! 1505: }
! 1506: }
! 1507: #endif
! 1508:
! 1509: /*if(SendSSDPGoodbye(snotify, v.n_lan_addr) < 0)*/
! 1510: if (GETFLAG(ENABLEUPNPMASK))
! 1511: {
! 1512: if(SendSSDPGoodbye(snotify, n_lan_addr) < 0)
! 1513: {
! 1514: syslog(LOG_ERR, "Failed to broadcast good-bye notifications");
! 1515: }
! 1516: for(i=0; i<n_lan_addr; i++)/* for(i=0; i<v.n_lan_addr; i++)*/
! 1517: close(snotify[i]);
! 1518: }
! 1519:
! 1520: if(unlink(pidfilename) < 0)
! 1521: {
! 1522: syslog(LOG_ERR, "Failed to remove pidfile %s: %m", pidfilename);
! 1523: }
! 1524:
! 1525: closelog();
! 1526: freeoptions();
! 1527:
! 1528: return 0;
! 1529: }
! 1530:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to miniupnpd.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