]> git.meshlink.io Git - catta/blob - avahi-dnsconfd/main.c
gcc 2.95 compatibility
[catta] / 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 }