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