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