git.meshlink.io Git - catta/blob - avahi-dnsconfd/main.c

   1 /* $Id$ */
   2
   3 /***
   4   This file is part of avahi.
   5
   6   avahi is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as
   8   published by the Free Software Foundation; either version 2.1 of the
   9   License, or (at your option) any later version.
  10
  11   avahi is distributed in the hope that it will be useful, but WITHOUT
  12   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  13   or FITNESS FOR A PARTICULAR PURPOSE. See the GNU Lesser General
  14   Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public
  17   License along with avahi; if not, write to the Free Software
  18   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
  19   USA.
  20 ***/
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <sys/un.h>
  27 #include <fcntl.h>
  28 #include <unistd.h>
  29 #include <sys/select.h>
  30 #include <sys/socket.h>
  31 #include <errno.h>
  32 #include <string.h>
  33 #include <stdio.h>
  34 #include <sys/ioctl.h>
  35 #include <net/if.h>
  36 #include <signal.h>
  37 #include <sys/wait.h>
  38 #include <getopt.h>
  39 #include <assert.h>
  40 #include <inttypes.h>
  41 #include <stdlib.h>
  42
  43 #include <avahi-common/llist.h>
  44 #include <avahi-common/malloc.h>
  45
  46 #include <libdaemon/dfork.h>
  47 #include <libdaemon/dsignal.h>
  48 #include <libdaemon/dlog.h>
  49 #include <libdaemon/dpid.h>
  50 #include <libdaemon/dexec.h>
  51
  52 #define BROWSE_DNS_SERVERS "BROWSE-DNS-SERVERS\n"
  53
  54 #define ENV_INTERFACE_DNS_SERVERS  "AVAHI_INTERFACE_DNS_SERVERS"
  55 #define ENV_DNS_SERVERS "AVAHI_DNS_SERVERS"
  56 #define ENV_INTERFACE "AVAHI_INTERFACE"
  57
  58 static enum {
  59     ACKWAIT,
  60     BROWSING
  61 } state = ACKWAIT;
  62
  63 static int quit = 0;
  64
  65 static enum {
  66     DAEMON_RUN,
  67     DAEMON_KILL,
  68     DAEMON_REFRESH,
  69     DAEMON_VERSION,
  70     DAEMON_HELP,
  71     DAEMON_CHECK
  72 } command = DAEMON_RUN;
  73
  74 static int daemonize = 0;
  75
  76 typedef struct DNSServerInfo DNSServerInfo;
  77
  78 struct DNSServerInfo {
  79     int interface;
  80     int protocol;
  81     char *address;
  82     AVAHI_LLIST_FIELDS(DNSServerInfo, servers);
  83 };
  84
  85 static AVAHI_LLIST_HEAD(DNSServerInfo, servers);
  86
  87 static void server_info_free(DNSServerInfo *i) {
  88     assert(i);
  89
  90     avahi_free(i->address);
  91
  92     AVAHI_LLIST_REMOVE(DNSServerInfo, servers, servers, i);
  93     avahi_free(i);
  94 }
  95
  96 static DNSServerInfo* get_server_info(int interface, int protocol, const char *address) {
  97     DNSServerInfo *i;
  98     assert(address);
  99
 100     for (i = servers; i; i = i->servers_next)
 101         if (i->interface == interface &&
 102             i->protocol == protocol &&
 103             strcmp(i->address, address) == 0)
 104             return i;
 105
 106     return NULL;
 107 }
 108
 109 static DNSServerInfo* new_server_info(int interface, int protocol, const char *address) {
 110     DNSServerInfo *i;
 111
 112     assert(address);
 113
 114     i = avahi_new(DNSServerInfo, 1);
 115     i->interface = interface;
 116     i->protocol = protocol;
 117     i->address = avahi_strdup(address);
 118
 119     AVAHI_LLIST_PREPEND(DNSServerInfo, servers, servers, i);
 120
 121     return i;
 122 }
 123
 124 static int set_cloexec(int fd) {
 125     int n;
 126
 127     assert(fd >= 0);
 128
 129     if ((n = fcntl(fd, F_GETFD)) < 0)
 130         return -1;
 131
 132     if (n & FD_CLOEXEC)
 133         return 0;
 134
 135     return fcntl(fd, F_SETFD, n|FD_CLOEXEC);
 136 }
 137
 138 static int open_socket(void) {
 139     int fd = -1;
 140     struct sockaddr_un sa;
 141
 142     if ((fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
 143         daemon_log(LOG_ERR, "socket(): %s", strerror(errno));
 144         goto fail;
 145     }
 146
 147     if (set_cloexec(fd) < 0) {
 148         daemon_log(LOG_ERR, "fcntl(): %s", strerror(errno));
 149         goto fail;
 150     }
 151
 152     memset(&sa, 0, sizeof(sa));
 153     sa.sun_family = AF_UNIX;
 154     strncpy(sa.sun_path, AVAHI_SOCKET, sizeof(sa.sun_path)-1);
 155     sa.sun_path[sizeof(sa.sun_path)-1] = 0;
 156
 157     if (connect(fd, (struct sockaddr*) &sa, sizeof(sa)) < 0) {
 158         daemon_log(LOG_ERR, "connect(): %s", strerror(errno));
 159         daemon_log(LOG_INFO, "Failed to connect to the daemon. This probably means that you");
 160         daemon_log(LOG_INFO, "didn't start avahi-daemon before avahi-dnsconfd.");
 161         goto fail;
 162     }
 163
 164     return fd;
 165
 166 fail:
 167     if (fd >= 0)
 168         close(fd);
 169
 170     return -1;
 171 }
 172
 173 static ssize_t loop_write(int fd, const void*data, size_t size) {
 174
 175     ssize_t ret = 0;
 176     assert(fd >= 0 && data && size);
 177
 178     while (size > 0) {
 179         ssize_t r;
 180
 181         if ((r = write(fd, data, size)) < 0)
 182             return r;
 183
 184         if (r == 0)
 185             break;
 186
 187         ret += r;
 188         data = (const uint8_t*) data + r;
 189         size -= r;
 190     }
 191
 192     return ret;
 193 }
 194
 195 static char *concat_dns_servers(int interface) {
 196     DNSServerInfo *i;
 197     char *r = NULL;
 198
 199     for (i = servers; i; i = i->servers_next)
 200         if (i->interface == interface || interface <= 0) {
 201             char *t;
 202
 203             if (!r)
 204                 t = avahi_strdup(i->address);
 205             else
 206                 t = avahi_strdup_printf("%s %s", r, i->address);
 207
 208             avahi_free(r);
 209             r = t;
 210         }
 211
 212     return r;
 213 }
 214
 215 static char *getifname(int interface, char *name, size_t len) {
 216     int fd = -1;
 217     char *ret = NULL;
 218     struct ifreq ifr;
 219
 220     assert(interface >= 0);
 221
 222     if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) {
 223         daemon_log(LOG_ERR, "socket(): %s", strerror(errno));
 224         goto finish;
 225     }
 226
 227     memset(&ifr, 0, sizeof(ifr));
 228     ifr.ifr_ifindex = interface;
 229
 230     if (ioctl(fd, SIOCGIFNAME, &ifr) < 0) {
 231         daemon_log(LOG_ERR, "SIOCGIFNAME: %s\n", strerror(errno));
 232         goto finish;
 233     }
 234
 235     strncpy(name, ifr.ifr_name, len-1);
 236     name[len-1] = 0;
 237     ret = name;
 238
 239 finish:
 240     if (fd >= 0)
 241         close(fd);
 242
 243     return ret;
 244 }
 245
 246 static void set_env(const char *name, const char *value) {
 247     char **e;
 248     size_t l;
 249
 250     assert(name);
 251     assert(value);
 252
 253     l = strlen(name);
 254
 255     for (e = environ; *e; e++) {
 256         /* Search for the variable */
 257         if (strlen(*e) < l+1)
 258             continue;
 259
 260         if (strncmp(*e, name, l) != 0 || *e[l] != '=')
 261             continue;
 262
 263         /* We simply free the record, sicne we know that we created it previously */
 264         avahi_free(*e);
 265         *e = avahi_strdup_printf("%s=%s", name, value);
 266         return;
 267     }
 268
 269     assert(0);
 270 }
 271
 272 static void run_script(int new, int interface, int protocol, const char *address) {
 273     char *p;
 274     int ret;
 275     char ia[16], pa[16];
 276     char name[IFNAMSIZ+1];
 277
 278     assert(interface > 0);
 279
 280     if (!getifname(interface, name, sizeof(name)))
 281         return;
 282
 283     p = concat_dns_servers(interface);
 284     set_env(ENV_INTERFACE_DNS_SERVERS, p ? p : "");
 285     avahi_free(p);
 286
 287     p = concat_dns_servers(-1);
 288     set_env(ENV_DNS_SERVERS, p ? p : "");
 289     avahi_free(p);
 290
 291     set_env(ENV_INTERFACE, name);
 292
 293     snprintf(ia, sizeof(ia), "%i", interface);
 294     snprintf(pa, sizeof(pa), "%i", protocol);
 295
 296     if (daemon_exec("/", &ret, AVAHI_DNSCONF_SCRIPT, AVAHI_DNSCONF_SCRIPT, new ? "+" : "-", address, ia, pa, NULL) < 0)
 297         daemon_log(LOG_WARNING, "Failed to run script");
 298     else if (ret != 0)
 299         daemon_log(LOG_WARNING, "Script returned with non-zero exit code %i", ret);
 300 }
 301
 302 static int new_line(const char *l) {
 303     assert(l);
 304
 305     if (state == ACKWAIT) {
 306         if (*l != '+') {
 307             daemon_log(LOG_ERR, "Avahi command failed: %s", l);
 308             return -1;
 309         }
 310
 311         daemon_log(LOG_INFO, "Successfully connected to Avahi daemon.");
 312         state = BROWSING;
 313     } else {
 314         int interface;
 315         int protocol;
 316         int port;
 317         char a[64];
 318
 319         assert(state == BROWSING);
 320
 321         if (*l != '<' && *l != '>') {
 322             daemon_log(LOG_ERR, "Avahi sent us an invalid browsing line: %s", l);
 323             return -1;
 324         }
 325
 326         if (sscanf(l+1, "%i %i %64s %i", &interface, &protocol, a, &port) != 4) {
 327             daemon_log(LOG_ERR, "Failed to parse browsing line: %s", l);
 328             return -1;
 329         }
 330
 331         if (*l == '>') {
 332             if (port != 53)
 333                 daemon_log(LOG_WARNING, "DNS server with port address != 53 found, ignoring");
 334             else {
 335                 daemon_log(LOG_INFO, "New DNS Server %s (interface: %i.%u)", a, interface, protocol);
 336                 new_server_info(interface, protocol, a);
 337                 run_script(1, interface, protocol, a);
 338             }
 339         } else {
 340             DNSServerInfo *i;
 341
 342             if (port == 53)
 343                 if ((i = get_server_info(interface, protocol, a))) {
 344                     daemon_log(LOG_INFO, "DNS Server %s removed (interface: %i.%u)", a, interface, protocol);
 345                     server_info_free(i);
 346                     run_script(0, interface, protocol, a);
 347                 }
 348         }
 349
 350     }
 351
 352     return 0;
 353 }
 354
 355 static int do_connect(void) {
 356     int fd = -1;
 357
 358     if ((fd = open_socket()) < 0)
 359         goto fail;
 360
 361     if (loop_write(fd, BROWSE_DNS_SERVERS, sizeof(BROWSE_DNS_SERVERS)-1) < 0) {
 362         daemon_log(LOG_ERR, "write(): %s", strerror(errno));
 363         goto fail;
 364     }
 365
 366     state = ACKWAIT;
 367     return fd;
 368
 369 fail:
 370     if (fd >= 0)
 371         close(fd);
 372
 373     return -1;
 374 }
 375
 376 static void free_dns_server_info_list(void) {
 377     while (servers) {
 378         int interface = servers->interface;
 379         int protocol = servers->protocol;
 380         char *address = avahi_strdup(servers->address);
 381         server_info_free(servers);
 382
 383         run_script(0, interface, protocol, address);
 384         avahi_free(address);
 385     }
 386 }
 387
 388 static void help(FILE *f, const char *argv0) {
 389     fprintf(f,
 390             "%s [options]\n"
 391             "    -h --help        Show this help\n"
 392             "    -D --daemonize   Daemonize after startup\n"
 393             "    -k --kill        Kill a running daemon\n"
 394             "    -r --refresh     Request a running daemon to refresh DNS server data\n"
 395             "    -c --check       Return 0 if a daemon is already running\n"
 396             "    -V --version     Show version\n",
 397             argv0);
 398 }
 399
 400 static int parse_command_line(int argc, char *argv[]) {
 401     int c;
 402
 403     static const struct option long_options[] = {
 404         { "help",      no_argument,       NULL, 'h' },
 405         { "daemonize", no_argument,       NULL, 'D' },
 406         { "kill",      no_argument,       NULL, 'k' },
 407         { "version",   no_argument,       NULL, 'V' },
 408         { "refresh",   no_argument,       NULL, 'r' },
 409         { "check",     no_argument,       NULL, 'c' },
 410     };
 411
 412     opterr = 0;
 413     while ((c = getopt_long(argc, argv, "hDkVrc", long_options, NULL)) >= 0) {
 414
 415         switch(c) {
 416             case 'h':
 417                 command = DAEMON_HELP;
 418                 break;
 419             case 'D':
 420                 daemonize = 1;
 421                 break;
 422             case 'k':
 423                 command = DAEMON_KILL;
 424                 break;
 425             case 'V':
 426                 command = DAEMON_VERSION;
 427                 break;
 428             case 'r':
 429                 command = DAEMON_REFRESH;
 430                 break;
 431             case 'c':
 432                 command = DAEMON_CHECK;
 433                 break;
 434             default:
 435                 fprintf(stderr, "Invalid command line argument: %c\n", c);
 436                 return -1;
 437         }
 438     }
 439
 440     if (optind < argc) {
 441         fprintf(stderr, "Too many arguments\n");
 442         return -1;
 443     }
 444
 445     return 0;
 446 }
 447
 448 static int run_daemon(void) {
 449     int fd = -1, ret = -1;
 450     char buf[1024];
 451     size_t buflen = 0;
 452
 453     AVAHI_LLIST_HEAD_INIT(DNSServerInfo, servers);
 454
 455     daemon_signal_init(SIGINT, SIGTERM, SIGCHLD, SIGHUP, 0);
 456
 457     /* Allocate some memory for our environment variables */
 458     putenv(avahi_strdup(ENV_INTERFACE"="));
 459     putenv(avahi_strdup(ENV_DNS_SERVERS"="));
 460     putenv(avahi_strdup(ENV_INTERFACE_DNS_SERVERS"="));
 461
 462     if ((fd = do_connect()) < 0)
 463         goto finish;
 464
 465     if (daemonize)
 466         daemon_retval_send(0);
 467
 468     ret = 0;
 469
 470     while (!quit) {
 471         fd_set rfds, wfds;
 472
 473         FD_ZERO(&rfds);
 474         FD_ZERO(&wfds);
 475
 476         FD_SET(fd, &rfds);
 477         FD_SET(daemon_signal_fd(), &rfds);
 478
 479         for (;;) {
 480             if (select(fd+1, &rfds, NULL, NULL, NULL) < 0) {
 481                 if (errno == EINTR)
 482                     continue;
 483
 484                 daemon_log(LOG_ERR, "select(): %s", strerror(errno));
 485                 goto finish;
 486             }
 487
 488             break;
 489         }
 490
 491         if (FD_ISSET(daemon_signal_fd(), &rfds)) {
 492
 493             int sig;
 494
 495             if ((sig = daemon_signal_next()) <= 0) {
 496                 daemon_log(LOG_ERR, "daemon_signal_next() failed");
 497                 goto finish;
 498             }
 499
 500             switch(sig) {
 501                 case SIGINT:
 502                 case SIGTERM:
 503                     daemon_log(LOG_INFO, "Got %s, quitting.", sig == SIGINT ? "SIGINT" : "SIGTERM");
 504                     ret = 0;
 505                     goto finish;
 506
 507                 case SIGCHLD:
 508                     waitpid(-1, NULL, WNOHANG);
 509                     break;
 510
 511                 case SIGHUP:
 512                     daemon_log(LOG_INFO, "Refreshing DNS Server list");
 513
 514                     close(fd);
 515                     free_dns_server_info_list();
 516
 517                     if ((fd = do_connect()) < 0)
 518                         goto finish;
 519
 520                     break;
 521             }
 522
 523         } else if (FD_ISSET(fd, &rfds)) {
 524             ssize_t r;
 525             char *n;
 526
 527             if ((r = read(fd, buf, sizeof(buf) - buflen - 1)) <= 0) {
 528                 daemon_log(LOG_ERR, "read(): %s", r < 0 ? strerror(errno) : "EOF");
 529                 goto finish;
 530             }
 531
 532             buflen += r;
 533             assert(buflen <= sizeof(buf)-1);
 534
 535             while ((n = memchr(buf, '\n', buflen))) {
 536                 *(n++) = 0;
 537
 538                 if (new_line(buf) < 0)
 539                     goto finish;
 540
 541                 buflen -= (n - buf);
 542                 memmove(buf, n, buflen);
 543             }
 544
 545             if (buflen >= sizeof(buf)-1) {
 546                 /* The incoming line is horribly long */
 547                 buf[sizeof(buf)-1] = 0;
 548
 549                 if (new_line(buf) < 0)
 550                     goto finish;
 551
 552                 buflen = 0;
 553             }
 554         }
 555     }
 556
 557 finish:
 558
 559     free_dns_server_info_list();
 560
 561     if (fd >= 0)
 562         close(fd);
 563
 564     daemon_signal_done();
 565
 566     if (ret != 0 && daemonize)
 567         daemon_retval_send(1);
 568
 569     return ret;
 570 }
 571
 572 static const char* pid_file_proc(void) {
 573     return AVAHI_RUNTIME_DIR"/avahi-dnsconfd.pid";
 574 }
 575
 576 int main(int argc, char *argv[]) {
 577     char *argv0;
 578     int r = 1;
 579     int wrote_pid_file = 0;
 580
 581     if ((argv0 = strrchr(argv[0], '/')))
 582         argv0++;
 583     else
 584         argv0 = argv[0];
 585
 586     daemon_pid_file_ident = daemon_log_ident = argv0;
 587     daemon_pid_file_proc = pid_file_proc;
 588
 589     if (parse_command_line(argc, argv) < 0)
 590         goto finish;
 591
 592     if (command == DAEMON_RUN) {
 593         pid_t pid;
 594
 595         if (getuid() != 0) {
 596             daemon_log(LOG_ERR, "This program is intended to be run as root.");
 597             goto finish;
 598         }
 599
 600         if ((pid = daemon_pid_file_is_running()) >= 0) {
 601             daemon_log(LOG_ERR, "Daemon already running on PID %u", pid);
 602             goto finish;
 603         }
 604
 605         if (daemonize) {
 606             daemon_retval_init();
 607
 608             if ((pid = daemon_fork()) < 0)
 609                 goto finish;
 610             else if (pid != 0) {
 611                 int ret;
 612                 /** Parent **/
 613
 614                 if ((ret = daemon_retval_wait(20)) < 0) {
 615                     daemon_log(LOG_ERR, "Could not recieve return value from daemon process.");
 616                     goto finish;
 617                 }
 618
 619                 r = ret;
 620                 goto finish;
 621             }
 622
 623             /* Child */
 624         }
 625
 626         chdir("/");
 627
 628         if (daemon_pid_file_create() < 0) {
 629             daemon_log(LOG_ERR, "Failed to create PID file: %s", strerror(errno));
 630
 631             if (daemonize)
 632                 daemon_retval_send(1);
 633             goto finish;
 634         } else
 635             wrote_pid_file = 1;
 636
 637         if (run_daemon() < 0)
 638             goto finish;
 639
 640         r = 0;
 641     } else if (command == DAEMON_HELP) {
 642         help(stdout, argv0);
 643
 644         r = 0;
 645     } else if (command == DAEMON_VERSION) {
 646         printf("%s "PACKAGE_VERSION"\n", argv0);
 647
 648         r = 0;
 649     } else if (command == DAEMON_KILL) {
 650         if (daemon_pid_file_kill_wait(SIGTERM, 5) < 0) {
 651             daemon_log(LOG_WARNING, "Failed to kill daemon: %s", strerror(errno));
 652             goto finish;
 653         }
 654
 655         r = 0;
 656     } else if (command == DAEMON_REFRESH) {
 657         if (daemon_pid_file_kill(SIGHUP) < 0) {
 658             daemon_log(LOG_WARNING, "Failed to kill daemon: %s", strerror(errno));
 659             goto finish;
 660         }
 661
 662         r = 0;
 663     } else if (command == DAEMON_CHECK)
 664         r = (daemon_pid_file_is_running() >= 0) ? 0 : 1;
 665
 666
 667 finish:
 668
 669     if (daemonize)
 670         daemon_retval_done();
 671
 672     if (wrote_pid_file)
 673         daemon_pid_file_remove();
 674
 675     return r;
 676 }