main.c revision 287f9866c923e6afe8ffbbc03b90be64acf395e1
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 <stdlib.h> 27#include <unistd.h> 28#include <sys/socket.h> 29#include <netpacket/packet.h> 30#include <net/ethernet.h> 31#include <fcntl.h> 32#include <time.h> 33#include <assert.h> 34#include <errno.h> 35#include <string.h> 36#include <inttypes.h> 37#include <sys/types.h> 38#include <arpa/inet.h> 39#include <sys/ioctl.h> 40#include <poll.h> 41#include <net/if.h> 42#include <stdio.h> 43#include <getopt.h> 44#include <signal.h> 45#include <sys/wait.h> 46 47#include <avahi-common/malloc.h> 48#include <avahi-common/timeval.h> 49 50#include <avahi-daemon/setproctitle.h> 51 52#include <libdaemon/dfork.h> 53#include <libdaemon/dsignal.h> 54#include <libdaemon/dlog.h> 55#include <libdaemon/dpid.h> 56#include <libdaemon/dexec.h> 57 58#include "main.h" 59#include "iface.h" 60 61#ifndef __linux__ 62#error "avahi-autoipd is only available on Linux for now" 63#endif 64 65/* An implementation of RFC 3927 */ 66 67/* Constants from the RFC */ 68#define PROBE_WAIT 1 69#define PROBE_NUM 3 70#define PROBE_MIN 1 71#define PROBE_MAX 2 72#define ANNOUNCE_WAIT 2 73#define ANNOUNCE_NUM 2 74#define ANNOUNCE_INTERVAL 2 75#define MAX_CONFLICTS 10 76#define RATE_LIMIT_INTERVAL 60 77#define DEFEND_INTERVAL 10 78 79#define IPV4LL_NETWORK 0xA9FE0000L 80#define IPV4LL_NETMASK 0xFFFF0000L 81#define IPV4LL_HOSTMASK 0x0000FFFFL 82 83#define ETHER_ADDRLEN 6 84#define ARP_PACKET_SIZE (8+4+4+2*ETHER_ADDRLEN) 85 86typedef enum ArpOperation { 87 ARP_REQUEST = 1, 88 ARP_RESPONSE = 2 89} ArpOperation; 90 91typedef struct ArpPacketInfo { 92 ArpOperation operation; 93 94 uint32_t sender_ip_address, target_ip_address; 95 uint8_t sender_hw_address[ETHER_ADDRLEN], target_hw_address[ETHER_ADDRLEN]; 96} ArpPacketInfo; 97 98static State state = STATE_START; 99static int n_iteration = 0; 100static int n_conflict = 0; 101 102static char *interface_name = NULL; 103static char *pid_file_name = NULL; 104static uint32_t start_address = 0; 105static char *argv0 = NULL; 106static int daemonize = 0; 107static int wait_for_address = 0; 108static int use_syslog = 0; 109static int debug = 0; 110static int modify_proc_title = 1; 111static int force_bind = 0; 112 113static enum { 114 DAEMON_RUN, 115 DAEMON_KILL, 116 DAEMON_REFRESH, 117 DAEMON_VERSION, 118 DAEMON_HELP, 119 DAEMON_CHECK 120} command = DAEMON_RUN; 121 122typedef enum CalloutEvent { 123 CALLOUT_BIND, 124 CALLOUT_CONFLICT, 125 CALLOUT_UNBIND, 126 CALLOUT_STOP, 127 CALLOUT_MAX 128} CalloutEvent; 129 130static const char * const callout_event_table[CALLOUT_MAX] = { 131 [CALLOUT_BIND] = "BIND", 132 [CALLOUT_CONFLICT] = "CONFLICT", 133 [CALLOUT_UNBIND] = "UNBIND", 134 [CALLOUT_STOP] = "STOP" 135}; 136 137typedef struct CalloutEventInfo { 138 CalloutEvent event; 139 uint32_t address; 140 int ifindex; 141} CalloutEventInfo; 142 143#define RANDOM_DEVICE "/dev/urandom" 144 145#define DEBUG(x) do {\ 146if (debug) { \ 147 x; \ 148} \ 149} while (0) 150 151static void init_rand_seed(void) { 152 int fd; 153 unsigned seed = 0; 154 155 /* Try to initialize seed from /dev/urandom, to make it a little 156 * less predictable, and to make sure that multiple machines 157 * booted at the same time choose different random seeds. */ 158 if ((fd = open(RANDOM_DEVICE, O_RDONLY)) >= 0) { 159 read(fd, &seed, sizeof(seed)); 160 close(fd); 161 } 162 163 /* If the initialization failed by some reason, we add the time to the seed */ 164 seed ^= (unsigned) time(NULL); 165 166 srand(seed); 167} 168 169static uint32_t pick_addr(uint32_t old_addr) { 170 uint32_t addr; 171 172 do { 173 unsigned r = (unsigned) rand(); 174 175 /* Reduce to 16 bits */ 176 while (r > 0xFFFF) 177 r = (r >> 16) ^ (r & 0xFFFF); 178 179 addr = htonl(IPV4LL_NETWORK | (uint32_t) r); 180 181 } while (addr == old_addr); 182 183 return addr; 184} 185 186static void* packet_new(const ArpPacketInfo *info, size_t *packet_len) { 187 uint8_t *r; 188 189 assert(info); 190 assert(packet_len); 191 assert(info->operation == ARP_REQUEST || info->operation == ARP_RESPONSE); 192 193 *packet_len = ARP_PACKET_SIZE; 194 r = avahi_new0(uint8_t, *packet_len); 195 196 r[1] = 1; /* HTYPE */ 197 r[2] = 8; /* PTYPE */ 198 r[4] = ETHER_ADDRLEN; /* HLEN */ 199 r[5] = 4; /* PLEN */ 200 r[7] = (uint8_t) info->operation; 201 202 memcpy(r+8, info->sender_hw_address, ETHER_ADDRLEN); 203 memcpy(r+14, &info->sender_ip_address, 4); 204 memcpy(r+18, info->target_hw_address, ETHER_ADDRLEN); 205 memcpy(r+24, &info->target_ip_address, 4); 206 207 return r; 208} 209 210static void *packet_new_probe(uint32_t ip_address, const uint8_t*hw_address, size_t *packet_len) { 211 ArpPacketInfo info; 212 213 memset(&info, 0, sizeof(info)); 214 info.operation = ARP_REQUEST; 215 memcpy(info.sender_hw_address, hw_address, ETHER_ADDRLEN); 216 info.target_ip_address = ip_address; 217 218 return packet_new(&info, packet_len); 219} 220 221static void *packet_new_announcement(uint32_t ip_address, const uint8_t* hw_address, size_t *packet_len) { 222 ArpPacketInfo info; 223 224 memset(&info, 0, sizeof(info)); 225 info.operation = ARP_REQUEST; 226 memcpy(info.sender_hw_address, hw_address, ETHER_ADDRLEN); 227 info.target_ip_address = ip_address; 228 info.sender_ip_address = ip_address; 229 230 return packet_new(&info, packet_len); 231} 232 233static int packet_parse(const void *data, size_t packet_len, ArpPacketInfo *info) { 234 const uint8_t *p = data; 235 236 assert(data); 237 238 if (packet_len < ARP_PACKET_SIZE) 239 return -1; 240 241 /* Check HTYPE and PTYPE */ 242 if (p[0] != 0 || p[1] != 1 || p[2] != 8 || p[3] != 0) 243 return -1; 244 245 /* Check HLEN, PLEN, OPERATION */ 246 if (p[4] != ETHER_ADDRLEN || p[5] != 4 || p[6] != 0 || (p[7] != 1 && p[7] != 2)) 247 return -1; 248 249 info->operation = p[7]; 250 memcpy(info->sender_hw_address, p+8, ETHER_ADDRLEN); 251 memcpy(&info->sender_ip_address, p+14, 4); 252 memcpy(info->target_hw_address, p+18, ETHER_ADDRLEN); 253 memcpy(&info->target_ip_address, p+24, 4); 254 255 return 0; 256} 257 258static void set_state(State st, int reset_counter, uint32_t address) { 259 static const char* const state_table[] = { 260 [STATE_START] = "START", 261 [STATE_WAITING_PROBE] = "WAITING_PROBE", 262 [STATE_PROBING] = "PROBING", 263 [STATE_WAITING_ANNOUNCE] = "WAITING_ANNOUNCE", 264 [STATE_ANNOUNCING] = "ANNOUNCING", 265 [STATE_RUNNING] = "RUNNING", 266 [STATE_SLEEPING] = "SLEEPING" 267 }; 268 char buf[64]; 269 270 assert(st < STATE_MAX); 271 272 if (st == state && !reset_counter) { 273 n_iteration++; 274 DEBUG(daemon_log(LOG_DEBUG, "State iteration %s-%i", state_table[state], n_iteration)); 275 } else { 276 DEBUG(daemon_log(LOG_DEBUG, "State transition %s-%i -> %s-0", state_table[state], n_iteration, state_table[st])); 277 state = st; 278 n_iteration = 0; 279 } 280 281 if (modify_proc_title) { 282 if (state == STATE_SLEEPING) 283 avahi_set_proc_title(argv0, "%s: [%s] sleeping", argv0, interface_name); 284 else if (state == STATE_ANNOUNCING) 285 avahi_set_proc_title(argv0, "%s: [%s] announcing %s", argv0, interface_name, inet_ntop(AF_INET, &address, buf, sizeof(buf))); 286 else if (state == STATE_RUNNING) 287 avahi_set_proc_title(argv0, "%s: [%s] bound %s", argv0, interface_name, inet_ntop(AF_INET, &address, buf, sizeof(buf))); 288 else 289 avahi_set_proc_title(argv0, "%s: [%s] probing %s", argv0, interface_name, inet_ntop(AF_INET, &address, buf, sizeof(buf))); 290 } 291} 292 293static int interface_up(int iface) { 294 int fd = -1; 295 struct ifreq ifreq; 296 297 if ((fd = socket(PF_INET, SOCK_DGRAM, 0)) < 0) { 298 daemon_log(LOG_ERR, "socket() failed: %s", strerror(errno)); 299 goto fail; 300 } 301 302 memset(&ifreq, 0, sizeof(ifreq)); 303 if (!if_indextoname(iface, ifreq.ifr_name)) { 304 daemon_log(LOG_ERR, "if_indextoname() failed: %s", strerror(errno)); 305 goto fail; 306 } 307 308 if (ioctl(fd, SIOCGIFFLAGS, &ifreq) < 0) { 309 daemon_log(LOG_ERR, "SIOCGIFFLAGS failed: %s", strerror(errno)); 310 goto fail; 311 } 312 313 ifreq.ifr_flags |= IFF_UP; 314 315 if (ioctl(fd, SIOCSIFFLAGS, &ifreq) < 0) { 316 daemon_log(LOG_ERR, "SIOCSIFFLAGS failed: %s", strerror(errno)); 317 goto fail; 318 } 319 320 close(fd); 321 322 return 0; 323 324fail: 325 if (fd >= 0) 326 close(fd); 327 328 return -1; 329} 330 331static int open_socket(int iface, uint8_t *hw_address) { 332 int fd = -1; 333 struct sockaddr_ll sa; 334 socklen_t sa_len; 335 336 if (interface_up(iface) < 0) 337 goto fail; 338 339 if ((fd = socket(PF_PACKET, SOCK_DGRAM, 0)) < 0) { 340 daemon_log(LOG_ERR, "socket() failed: %s", strerror(errno)); 341 goto fail; 342 } 343 344 memset(&sa, 0, sizeof(sa)); 345 sa.sll_family = AF_PACKET; 346 sa.sll_protocol = htons(ETH_P_ARP); 347 sa.sll_ifindex = iface; 348 349 if (bind(fd, (struct sockaddr*) &sa, sizeof(sa)) < 0) { 350 daemon_log(LOG_ERR, "bind() failed: %s", strerror(errno)); 351 goto fail; 352 } 353 354 sa_len = sizeof(sa); 355 if (getsockname(fd, (struct sockaddr*) &sa, &sa_len) < 0) { 356 daemon_log(LOG_ERR, "getsockname() failed: %s", strerror(errno)); 357 goto fail; 358 } 359 360 if (sa.sll_halen != ETHER_ADDRLEN) { 361 daemon_log(LOG_ERR, "getsockname() returned invalid hardware address."); 362 goto fail; 363 } 364 365 memcpy(hw_address, sa.sll_addr, ETHER_ADDRLEN); 366 367 return fd; 368 369fail: 370 if (fd >= 0) 371 close(fd); 372 373 return -1; 374} 375 376static int send_packet(int fd, int iface, void *packet, size_t packet_len) { 377 struct sockaddr_ll sa; 378 379 assert(fd >= 0); 380 assert(packet); 381 assert(packet_len > 0); 382 383 memset(&sa, 0, sizeof(sa)); 384 sa.sll_family = AF_PACKET; 385 sa.sll_protocol = htons(ETH_P_ARP); 386 sa.sll_ifindex = iface; 387 sa.sll_halen = ETHER_ADDRLEN; 388 memset(sa.sll_addr, 0xFF, ETHER_ADDRLEN); 389 390 if (sendto(fd, packet, packet_len, 0, (struct sockaddr*) &sa, sizeof(sa)) < 0) { 391 daemon_log(LOG_ERR, "sendto() failed: %s", strerror(errno)); 392 return -1; 393 } 394 395 return 0; 396} 397 398static int recv_packet(int fd, void **packet, size_t *packet_len) { 399 int s; 400 struct sockaddr_ll sa; 401 socklen_t sa_len; 402 ssize_t r; 403 404 assert(fd >= 0); 405 assert(packet); 406 assert(packet_len); 407 408 *packet = NULL; 409 410 if (ioctl(fd, FIONREAD, &s) < 0) { 411 daemon_log(LOG_ERR, "FIONREAD failed: %s", strerror(errno)); 412 goto fail; 413 } 414 415 if (s <= 0) 416 s = 4096; 417 418 *packet = avahi_new(uint8_t, s); 419 420 sa_len = sizeof(sa); 421 if ((r = recvfrom(fd, *packet, s, 0, (struct sockaddr*) &sa, &sa_len)) < 0) { 422 daemon_log(LOG_ERR, "recvfrom() failed: %s", strerror(errno)); 423 goto fail; 424 } 425 426 *packet_len = (size_t) r; 427 428 return 0; 429 430fail: 431 if (*packet) { 432 avahi_free(*packet); 433 *packet = NULL; 434 } 435 436 return -1; 437} 438 439int is_ll_address(uint32_t addr) { 440 return (ntohl(addr) & IPV4LL_NETMASK) == IPV4LL_NETWORK; 441} 442 443static struct timeval *elapse_time(struct timeval *tv, unsigned msec, unsigned jitter) { 444 assert(tv); 445 446 gettimeofday(tv, NULL); 447 448 if (msec) 449 avahi_timeval_add(tv, (AvahiUsec) msec*1000); 450 451 if (jitter) 452 avahi_timeval_add(tv, (AvahiUsec) (jitter*1000.0*rand()/(RAND_MAX+1.0))); 453 454 return tv; 455} 456 457static FILE* fork_dispatcher(void) { 458 FILE *ret; 459 int fds[2]; 460 pid_t pid; 461 462 if (pipe(fds) < 0) { 463 daemon_log(LOG_ERR, "pipe() failed: %s", strerror(errno)); 464 goto fail; 465 } 466 467 if ((pid = fork()) < 0) 468 goto fail; 469 else if (pid == 0) { 470 FILE *f = NULL; 471 int r = 1; 472 473 /* Please note that the signal pipe is not closed at this 474 * point, signals will thus be dispatched in the main 475 * process. */ 476 477 daemon_retval_done(); 478 479 setsid(); 480 481 avahi_set_proc_title(argv0, "%s: [%s] callout dispatcher", argv0, interface_name); 482 483 close(fds[1]); 484 485 if (!(f = fdopen(fds[0], "r"))) { 486 daemon_log(LOG_ERR, "fdopen() failed: %s", strerror(errno)); 487 goto dispatcher_fail; 488 } 489 490 for (;;) { 491 CalloutEventInfo info; 492 char name[IFNAMSIZ], buf[64]; 493 int k; 494 495 if (fread(&info, sizeof(info), 1, f) != 1) { 496 if (feof(f)) 497 break; 498 499 daemon_log(LOG_ERR, "fread() failed: %s", strerror(errno)); 500 goto dispatcher_fail; 501 } 502 503 assert(info.event <= CALLOUT_MAX); 504 505 if (!if_indextoname(info.ifindex, name)) { 506 daemon_log(LOG_ERR, "if_indextoname() failed: %s", strerror(errno)); 507 continue; 508 } 509 510 if (daemon_exec("/", &k, 511 AVAHI_IPCONF_SCRIPT, AVAHI_IPCONF_SCRIPT, 512 callout_event_table[info.event], 513 name, 514 inet_ntop(AF_INET, &info.address, buf, sizeof(buf)), NULL) < 0) { 515 516 daemon_log(LOG_ERR, "Failed to run script: %s", strerror(errno)); 517 continue; 518 } 519 520 if (k != 0) 521 daemon_log(LOG_WARNING, "Script execution failed with return value %i", k); 522 } 523 524 r = 0; 525 526 dispatcher_fail: 527 528 if (f) 529 fclose(f); 530 531 _exit(r); 532 } 533 534 /* parent */ 535 536 close(fds[0]); 537 fds[0] = -1; 538 539 if (!(ret = fdopen(fds[1], "w"))) { 540 daemon_log(LOG_ERR, "fdopen() failed: %s", strerror(errno)); 541 goto fail; 542 } 543 544 return ret; 545 546fail: 547 if (fds[0] >= 0) 548 close(fds[0]); 549 if (fds[1] >= 0) 550 close(fds[1]); 551 552 return NULL; 553} 554 555static int do_callout(FILE *f, CalloutEvent event, int iface, uint32_t addr) { 556 CalloutEventInfo info; 557 char buf[64], ifname[IFNAMSIZ]; 558 559 daemon_log(LOG_INFO, "Callout %s, address %s on interface %s", 560 callout_event_table[event], 561 inet_ntop(AF_INET, &addr, buf, sizeof(buf)), 562 if_indextoname(iface, ifname)); 563 564 info.event = event; 565 info.ifindex = iface; 566 info.address = addr; 567 568 if (fwrite(&info, sizeof(info), 1, f) != 1 || fflush(f) != 0) { 569 daemon_log(LOG_ERR, "Failed to write callout event: %s", strerror(errno)); 570 return -1; 571 } 572 573 return 0; 574} 575 576static int loop(int iface, uint32_t addr) { 577 enum { 578 FD_ARP, 579 FD_IFACE, 580 FD_SIGNAL, 581 FD_MAX, 582 }; 583 584 int fd = -1, ret = -1; 585 struct timeval next_wakeup; 586 int next_wakeup_valid = 0; 587 char buf[64]; 588 void *in_packet = NULL; 589 size_t in_packet_len; 590 void *out_packet = NULL; 591 size_t out_packet_len; 592 uint8_t hw_address[ETHER_ADDRLEN]; 593 struct pollfd pollfds[FD_MAX]; 594 int iface_fd; 595 Event event = EVENT_NULL; 596 int retval_sent = !daemonize; 597 State st; 598 FILE *dispatcher = NULL; 599 600 daemon_signal_init(SIGINT, SIGTERM, SIGCHLD, SIGHUP,0); 601 602 if (!(dispatcher = fork_dispatcher())) 603 goto fail; 604 605 if ((fd = open_socket(iface, hw_address)) < 0) 606 goto fail; 607 608 if ((iface_fd = iface_init(iface)) < 0) 609 goto fail; 610 611/* if (drop_privs() < 0) */ 612/* goto fail; */ 613 614 if (force_bind) 615 st = STATE_START; 616 else if (iface_get_initial_state(&st) < 0) 617 goto fail; 618 619 if (addr && !is_ll_address(addr)) { 620 daemon_log(LOG_WARNING, "Requested address %s is not from IPv4LL range 169.254/16, ignoring.", inet_ntop(AF_INET, &addr, buf, sizeof(buf))); 621 addr = 0; 622 } 623 624 if (!addr) { 625 int i; 626 uint32_t a = 1; 627 628 for (i = 0; i < ETHER_ADDRLEN; i++) 629 a += hw_address[i]*i; 630 631 addr = htonl(IPV4LL_NETWORK | (uint32_t) a); 632 } 633 634 set_state(st, 1, addr); 635 636 daemon_log(LOG_INFO, "Starting with address %s", inet_ntop(AF_INET, &addr, buf, sizeof(buf))); 637 638 if (state == STATE_SLEEPING) 639 daemon_log(LOG_INFO, "Routable address already assigned, sleeping."); 640 641 if (!retval_sent && (!wait_for_address || state == STATE_SLEEPING)) { 642 daemon_retval_send(0); 643 retval_sent = 1; 644 } 645 646 memset(pollfds, 0, sizeof(pollfds)); 647 pollfds[FD_ARP].fd = fd; 648 pollfds[FD_ARP].events = POLLIN; 649 pollfds[FD_IFACE].fd = iface_fd; 650 pollfds[FD_IFACE].events = POLLIN; 651 pollfds[FD_SIGNAL].fd = daemon_signal_fd(); 652 pollfds[FD_SIGNAL].events = POLLIN; 653 654 for (;;) { 655 int r, timeout; 656 AvahiUsec usec; 657 658 if (state == STATE_START) { 659 660 /* First, wait a random time */ 661 set_state(STATE_WAITING_PROBE, 1, addr); 662 663 elapse_time(&next_wakeup, 0, PROBE_WAIT*1000); 664 next_wakeup_valid = 1; 665 666 } else if ((state == STATE_WAITING_PROBE && event == EVENT_TIMEOUT) || 667 (state == STATE_PROBING && event == EVENT_TIMEOUT && n_iteration < PROBE_NUM-2)) { 668 669 /* Send a probe */ 670 out_packet = packet_new_probe(addr, hw_address, &out_packet_len); 671 set_state(STATE_PROBING, 0, addr); 672 673 elapse_time(&next_wakeup, PROBE_MIN*1000, (PROBE_MAX-PROBE_MIN)*1000); 674 next_wakeup_valid = 1; 675 676 } else if (state == STATE_PROBING && event == EVENT_TIMEOUT && n_iteration >= PROBE_NUM-2) { 677 678 /* Send the last probe */ 679 out_packet = packet_new_probe(addr, hw_address, &out_packet_len); 680 set_state(STATE_WAITING_ANNOUNCE, 1, addr); 681 682 elapse_time(&next_wakeup, ANNOUNCE_WAIT*1000, 0); 683 next_wakeup_valid = 1; 684 685 } else if ((state == STATE_WAITING_ANNOUNCE && event == EVENT_TIMEOUT) || 686 (state == STATE_ANNOUNCING && event == EVENT_TIMEOUT && n_iteration < ANNOUNCE_NUM-1)) { 687 688 /* Send announcement packet */ 689 out_packet = packet_new_announcement(addr, hw_address, &out_packet_len); 690 set_state(STATE_ANNOUNCING, 0, addr); 691 692 elapse_time(&next_wakeup, ANNOUNCE_INTERVAL*1000, 0); 693 next_wakeup_valid = 1; 694 695 if (n_iteration == 0) { 696 if (do_callout(dispatcher, CALLOUT_BIND, iface, addr) < 0) 697 goto fail; 698 699 n_conflict = 0; 700 701 if (!retval_sent) { 702 daemon_retval_send(0); 703 retval_sent = 1; 704 } 705 } 706 707 } else if ((state == STATE_ANNOUNCING && event == EVENT_TIMEOUT && n_iteration >= ANNOUNCE_NUM-1)) { 708 709 daemon_log(LOG_INFO, "Successfully claimed IP address %s", inet_ntop(AF_INET, &addr, buf, sizeof(buf))); 710 set_state(STATE_RUNNING, 0, addr); 711 712 next_wakeup_valid = 0; 713 714 } else if (event == EVENT_PACKET) { 715 ArpPacketInfo info; 716 717 assert(in_packet); 718 719 if (packet_parse(in_packet, in_packet_len, &info) < 0) 720 daemon_log(LOG_WARNING, "Failed to parse incoming ARP packet."); 721 else { 722 int conflict = 0; 723 724 if (info.sender_ip_address == addr) { 725 /* Normal conflict */ 726 conflict = 1; 727 daemon_log(LOG_INFO, "Recieved conflicting normal ARP packet."); 728 } else if (state == STATE_WAITING_PROBE || state == STATE_PROBING || state == STATE_WAITING_ANNOUNCE) { 729 /* Probe conflict */ 730 conflict = info.target_ip_address == addr && memcmp(hw_address, info.sender_hw_address, ETHER_ADDRLEN); 731 daemon_log(LOG_INFO, "Recieved conflicting probe ARP packet."); 732 } 733 734 if (conflict) { 735 736 if (state == STATE_RUNNING || state == STATE_ANNOUNCING) 737 if (do_callout(dispatcher, CALLOUT_CONFLICT, iface, addr) < 0) 738 goto fail; 739 740 /* Pick a new address */ 741 addr = pick_addr(addr); 742 743 daemon_log(LOG_INFO, "Trying address %s", inet_ntop(AF_INET, &addr, buf, sizeof(buf))); 744 745 n_conflict++; 746 747 set_state(STATE_WAITING_PROBE, 1, addr); 748 749 if (n_conflict >= MAX_CONFLICTS) { 750 daemon_log(LOG_WARNING, "Got too many conflicts, rate limiting new probes."); 751 elapse_time(&next_wakeup, RATE_LIMIT_INTERVAL*1000, PROBE_WAIT*1000); 752 } else 753 elapse_time(&next_wakeup, 0, PROBE_WAIT*1000); 754 755 next_wakeup_valid = 1; 756 } else 757 DEBUG(daemon_log(LOG_DEBUG, "Ignoring irrelevant ARP packet.")); 758 } 759 760 } else if (event == EVENT_ROUTABLE_ADDR_CONFIGURED) { 761 762 daemon_log(LOG_INFO, "A routable address has been configured."); 763 764 if (state == STATE_RUNNING || state == STATE_ANNOUNCING) 765 if (do_callout(dispatcher, CALLOUT_UNBIND, iface, addr) < 0) 766 goto fail; 767 768 if (!retval_sent) { 769 daemon_retval_send(0); 770 retval_sent = 1; 771 } 772 773 set_state(STATE_SLEEPING, 1, addr); 774 next_wakeup_valid = 0; 775 776 } else if (event == EVENT_ROUTABLE_ADDR_UNCONFIGURED && state == STATE_SLEEPING && !force_bind) { 777 778 daemon_log(LOG_INFO, "No longer a routable address configured, restarting probe process."); 779 780 set_state(STATE_WAITING_PROBE, 1, addr); 781 782 elapse_time(&next_wakeup, 0, PROBE_WAIT*1000); 783 next_wakeup_valid = 1; 784 785 } else if (event == EVENT_REFRESH_REQUEST && state == STATE_RUNNING && !force_bind) { 786 787 /* The user requested a reannouncing of the address by a SIGHUP */ 788 daemon_log(LOG_INFO, "Reannouncing address."); 789 790 /* Send announcement packet */ 791 out_packet = packet_new_announcement(addr, hw_address, &out_packet_len); 792 set_state(STATE_ANNOUNCING, 1, addr); 793 794 elapse_time(&next_wakeup, ANNOUNCE_INTERVAL*1000, 0); 795 next_wakeup_valid = 1; 796 } 797 798 if (out_packet) { 799 DEBUG(daemon_log(LOG_DEBUG, "sending...")); 800 801 if (send_packet(fd, iface, out_packet, out_packet_len) < 0) 802 goto fail; 803 804 avahi_free(out_packet); 805 out_packet = NULL; 806 } 807 808 if (in_packet) { 809 avahi_free(in_packet); 810 in_packet = NULL; 811 } 812 813 event = EVENT_NULL; 814 timeout = -1; 815 816 if (next_wakeup_valid) { 817 usec = avahi_age(&next_wakeup); 818 timeout = usec < 0 ? (int) (-usec/1000) : 0; 819 } 820 821 DEBUG(daemon_log(LOG_DEBUG, "sleeping %ims", timeout)); 822 823 while ((r = poll(pollfds, FD_MAX, timeout)) < 0 && errno == EINTR) 824 ; 825 826 if (r < 0) { 827 daemon_log(LOG_ERR, "poll() failed: %s", strerror(r)); 828 goto fail; 829 } else if (r == 0) { 830 event = EVENT_TIMEOUT; 831 next_wakeup_valid = 0; 832 } else { 833 834 835 if (pollfds[FD_ARP].revents) { 836 837 if (pollfds[FD_ARP].revents == POLLERR) { 838 /* The interface is probably down, let's recreate our socket */ 839 840 close(fd); 841 842 if ((fd = open_socket(iface, hw_address)) < 0) 843 goto fail; 844 845 pollfds[FD_ARP].fd = fd; 846 847 } else { 848 849 assert(pollfds[FD_ARP].revents == POLLIN); 850 851 if (recv_packet(fd, &in_packet, &in_packet_len) < 0) 852 goto fail; 853 854 if (in_packet) 855 event = EVENT_PACKET; 856 } 857 } 858 859 if (event == EVENT_NULL && 860 pollfds[FD_IFACE].revents) { 861 862 assert(pollfds[FD_IFACE].revents == POLLIN); 863 864 if (iface_process(&event) < 0) 865 goto fail; 866 } 867 868 if (event == EVENT_NULL && 869 pollfds[FD_SIGNAL].revents) { 870 871 int sig; 872 assert(pollfds[FD_SIGNAL].revents == POLLIN); 873 874 if ((sig = daemon_signal_next()) <= 0) { 875 daemon_log(LOG_ERR, "daemon_signal_next() failed"); 876 goto fail; 877 } 878 879 switch(sig) { 880 case SIGINT: 881 case SIGTERM: 882 daemon_log(LOG_INFO, "Got %s, quitting.", sig == SIGINT ? "SIGINT" : "SIGTERM"); 883 ret = 0; 884 goto fail; 885 886 case SIGCHLD: 887 waitpid(-1, NULL, WNOHANG); 888 break; 889 890 case SIGHUP: 891 event = EVENT_REFRESH_REQUEST; 892 break; 893 } 894 895 } 896 } 897 } 898 899 ret = 0; 900 901fail: 902 903 if (state == STATE_RUNNING || state == STATE_ANNOUNCING) 904 do_callout(dispatcher, CALLOUT_STOP, iface, addr); 905 906 avahi_free(out_packet); 907 avahi_free(in_packet); 908 909 if (fd >= 0) 910 close(fd); 911 912 if (iface_fd >= 0) 913 iface_done(); 914 915 if (daemonize && !retval_sent) 916 daemon_retval_send(ret); 917 918 if (dispatcher) 919 fclose(dispatcher); 920 921 return ret; 922} 923 924 925static void help(FILE *f, const char *a0) { 926 fprintf(f, 927 "%s [options] INTERFACE\n" 928 " -h --help Show this help\n" 929 " -D --daemonize Daemonize after startup\n" 930 " -s --syslog Write log messages to syslog(3) instead of STDERR\n" 931 " -k --kill Kill a running daemon\n" 932 " -r --refresh Request a running daemon to refresh it's IP address\n" 933 " -c --check Return 0 if a daemon is already running\n" 934 " -V --version Show version\n" 935 " -S --start=ADDRESS Start with this address from the IPv4LL range\n" 936 " 169.254.0.0/16\n" 937 " -w --wait Wait until an address has been acquired before\n" 938 " daemonizing\n" 939 " --no-proc-title Don't modify process title\n" 940 " --force-bind Assign an IPv4LL address even if routable address\n" 941 " is already assigned\n" 942 " --debug Increase verbosity\n", 943 a0); 944} 945 946static int parse_command_line(int argc, char *argv[]) { 947 int c; 948 949 enum { 950 OPTION_NO_PROC_TITLE = 256, 951 OPTION_FORCE_BIND, 952 OPTION_DEBUG 953 }; 954 955 static const struct option long_options[] = { 956 { "help", no_argument, NULL, 'h' }, 957 { "daemonize", no_argument, NULL, 'D' }, 958 { "syslog", no_argument, NULL, 's' }, 959 { "kill", no_argument, NULL, 'k' }, 960 { "refresh", no_argument, NULL, 'r' }, 961 { "check", no_argument, NULL, 'c' }, 962 { "version", no_argument, NULL, 'V' }, 963 { "start", required_argument, NULL, 'S' }, 964 { "wait", no_argument, NULL, 'w' }, 965 { "no-proc-title", no_argument, NULL, OPTION_NO_PROC_TITLE }, 966 { "force-bind", no_argument, NULL, OPTION_FORCE_BIND }, 967 { "debug", no_argument, NULL, OPTION_DEBUG }, 968 { NULL, 0, NULL, 0 } 969 }; 970 971 opterr = 0; 972 while ((c = getopt_long(argc, argv, "hDskrcVS:w", long_options, NULL)) >= 0) { 973 974 switch(c) { 975 case 's': 976 use_syslog = 1; 977 break; 978 case 'h': 979 command = DAEMON_HELP; 980 break; 981 case 'D': 982 daemonize = 1; 983 break; 984 case 'k': 985 command = DAEMON_KILL; 986 break; 987 case 'V': 988 command = DAEMON_VERSION; 989 break; 990 case 'r': 991 command = DAEMON_REFRESH; 992 break; 993 case 'c': 994 command = DAEMON_CHECK; 995 break; 996 case 'S': 997 998 if ((start_address = inet_addr(optarg)) == (uint32_t) -1) { 999 fprintf(stderr, "Failed to parse IP address '%s'.", optarg); 1000 return -1; 1001 } 1002 break; 1003 case 'w': 1004 wait_for_address = 1; 1005 break; 1006 1007 case OPTION_NO_PROC_TITLE: 1008 modify_proc_title = 0; 1009 break; 1010 1011 case OPTION_DEBUG: 1012 debug = 1; 1013 break; 1014 1015 case OPTION_FORCE_BIND: 1016 force_bind = 1; 1017 break; 1018 1019 default: 1020 fprintf(stderr, "Invalid command line argument: %c\n", c); 1021 return -1; 1022 } 1023 } 1024 1025 if (command == DAEMON_RUN || 1026 command == DAEMON_KILL || 1027 command == DAEMON_REFRESH || 1028 command == DAEMON_CHECK) { 1029 1030 if (optind >= argc) { 1031 fprintf(stderr, "Missing interface name.\n"); 1032 return -1; 1033 } 1034 1035 interface_name = avahi_strdup(argv[optind++]); 1036 } 1037 1038 if (optind != argc) { 1039 fprintf(stderr, "Too many arguments\n"); 1040 return -1; 1041 } 1042 1043 return 0; 1044} 1045 1046static const char* pid_file_proc(void) { 1047 return pid_file_name; 1048} 1049 1050int main(int argc, char*argv[]) { 1051 int r = 1; 1052 int wrote_pid_file = 0; 1053 char *log_ident = NULL; 1054 1055 avahi_init_proc_title(argc, argv); 1056 1057 signal(SIGPIPE, SIG_IGN); 1058 1059 if ((argv0 = strrchr(argv[0], '/'))) 1060 argv0++; 1061 else 1062 argv0 = argv[0]; 1063 1064 argv0 = avahi_strdup(argv0); 1065 1066 daemon_log_ident = argv0; 1067 1068 if (parse_command_line(argc, argv) < 0) 1069 goto finish; 1070 1071 daemon_log_ident = log_ident = avahi_strdup_printf("%s(%s)", argv0, interface_name); 1072 daemon_pid_file_proc = pid_file_proc; 1073 pid_file_name = avahi_strdup_printf(AVAHI_RUNTIME_DIR"/avahi-autoipd.%s.pid", interface_name); 1074 1075 if (command == DAEMON_RUN) { 1076 pid_t pid; 1077 int ifindex; 1078 1079 init_rand_seed(); 1080 1081 if ((ifindex = if_nametoindex(interface_name)) <= 0) { 1082 daemon_log(LOG_ERR, "Failed to get index for interface name '%s': %s", interface_name, strerror(errno)); 1083 goto finish; 1084 } 1085 1086 if (getuid() != 0) { 1087 daemon_log(LOG_ERR, "This program is intended to be run as root."); 1088 goto finish; 1089 } 1090 1091 if ((pid = daemon_pid_file_is_running()) >= 0) { 1092 daemon_log(LOG_ERR, "Daemon already running on PID %u", pid); 1093 goto finish; 1094 } 1095 1096 if (daemonize) { 1097 daemon_retval_init(); 1098 1099 if ((pid = daemon_fork()) < 0) 1100 goto finish; 1101 else if (pid != 0) { 1102 int ret; 1103 /** Parent **/ 1104 1105 if ((ret = daemon_retval_wait(20)) < 0) { 1106 daemon_log(LOG_ERR, "Could not receive return value from daemon process."); 1107 goto finish; 1108 } 1109 1110 r = ret; 1111 goto finish; 1112 } 1113 1114 /* Child */ 1115 } 1116 1117 if (use_syslog || daemonize) 1118 daemon_log_use = DAEMON_LOG_SYSLOG; 1119 1120 chdir("/"); 1121 1122 if (daemon_pid_file_create() < 0) { 1123 daemon_log(LOG_ERR, "Failed to create PID file: %s", strerror(errno)); 1124 1125 if (daemonize) 1126 daemon_retval_send(1); 1127 goto finish; 1128 } else 1129 wrote_pid_file = 1; 1130 1131 avahi_set_proc_title(argv0, "%s: [%s] starting up", argv0, interface_name); 1132 1133 if (loop(ifindex, start_address) < 0) 1134 goto finish; 1135 1136 r = 0; 1137 } else if (command == DAEMON_HELP) { 1138 help(stdout, argv0); 1139 1140 r = 0; 1141 } else if (command == DAEMON_VERSION) { 1142 printf("%s "PACKAGE_VERSION"\n", argv0); 1143 1144 r = 0; 1145 } else if (command == DAEMON_KILL) { 1146 if (daemon_pid_file_kill_wait(SIGTERM, 5) < 0) { 1147 daemon_log(LOG_WARNING, "Failed to kill daemon: %s", strerror(errno)); 1148 goto finish; 1149 } 1150 1151 r = 0; 1152 } else if (command == DAEMON_REFRESH) { 1153 if (daemon_pid_file_kill(SIGHUP) < 0) { 1154 daemon_log(LOG_WARNING, "Failed to kill daemon: %s", strerror(errno)); 1155 goto finish; 1156 } 1157 1158 r = 0; 1159 } else if (command == DAEMON_CHECK) 1160 r = (daemon_pid_file_is_running() >= 0) ? 0 : 1; 1161 1162 1163finish: 1164 1165 if (daemonize) 1166 daemon_retval_done(); 1167 1168 if (wrote_pid_file) 1169 daemon_pid_file_remove(); 1170 1171 avahi_free(log_ident); 1172 avahi_free(pid_file_name); 1173 avahi_free(argv0); 1174 avahi_free(interface_name); 1175 1176 return r; 1177} 1178 1179/* TODO: 1180 1181- chroot/drop privs/caps 1182- store last used address 1183- man page 1184 1185*/ 1186