void static_service_load(int in_chroot) {
StaticServiceGroup *g, *n;
glob_t globbuf;
int globret;
char **p;
for (g = groups; g; g = n) {
struct stat st;
n = g->groups_next;
if (stat(g->filename, &st) < 0) {
if (errno == ENOENT)
avahi_log_info("Service group file %s vanished, removing services.", g->filename);
else
avahi_log_warn("Failed to stat() file %s, ignoring: %s", g->filename, strerror(errno));
static_service_group_free(g);
} else if (st.st_mtime != g->mtime) {
avahi_log_info("Service group file %s changed, reloading.", g->filename);
if (static_service_group_load(g) < 0) {
avahi_log_warn("Failed to load service group file %s, removing service.", g->filename);
static_service_group_free(g);
}
}
}
memset(&globbuf, 0, sizeof(globbuf));
if ((globret = glob(in_chroot ? "/services/*.service" : AVAHI_SERVICE_DIR "/*.service", GLOB_ERR, NULL, &globbuf)) != 0)
switch (globret) {
#ifdef GLOB_NOSPACE
case GLOB_NOSPACE:
avahi_log_error("Not enough memory to read service directory "AVAHI_SERVICE_DIR".");
break;
#endif
#ifdef GLOB_NOMATCH
case GLOB_NOMATCH:
avahi_log_info("No service file found in "AVAHI_SERVICE_DIR".");
break;
#endif
default:
avahi_log_error("Failed to read "AVAHI_SERVICE_DIR".");
break;
}
else {
for (p = globbuf.gl_pathv; *p; p++)
load_file(*p);
globfree(&globbuf);
}
}
static void signal_callback(AvahiWatch *watch, AVAHI_GCC_UNUSED int fd, AVAHI_GCC_UNUSED AvahiWatchEvent event, AVAHI_GCC_UNUSED void *userdata) {
int sig;
const AvahiPoll *poll_api;
assert(watch);
assert(simple_poll_api);
poll_api = avahi_simple_poll_get(simple_poll_api);
if ((sig = daemon_signal_next()) <= 0) {
avahi_log_error("daemon_signal_next() failed");
poll_api->watch_free(watch);
return;
}
switch (sig) {
case SIGINT:
case SIGQUIT:
case SIGTERM:
avahi_log_info(
"Got %s, quitting.",
sig == SIGINT ? "SIGINT" :
(sig == SIGQUIT ? "SIGQUIT" : "SIGTERM"));
avahi_simple_poll_quit(simple_poll_api);
break;
case SIGHUP:
avahi_log_info("Got SIGHUP, reloading.");
reload_config();
break;
case SIGUSR1:
avahi_log_info("Got SIGUSR1, dumping record data.");
avahi_server_dump(avahi_server, dump, NULL);
break;
default:
avahi_log_warn("Got spurious signal, ignoring.");
break;
}
}
static void load_file(char *n) {
StaticServiceGroup *g;
assert(n);
for (g = groups; g; g = g->groups_next)
if (strcmp(g->filename, n) == 0)
return;
avahi_log_info("Loading service file %s.", n);
g = static_service_group_new(n);
if (static_service_group_load(g) < 0) {
avahi_log_error("Failed to load service group file %s, ignoring.", g->filename);
static_service_group_free(g);
}
}
static void elapse_timeout_callback(AVAHI_GCC_UNUSED AvahiTimeEvent *e, void *userdata) {
AvahiLLMNRQueryJob *qj = userdata;
AvahiLLMNRQuery *lq = qj->lq;
int c_bit_set, c_bit_clear, counter;
c_bit_set = avahi_record_list_is_empty(lq->c_bit_set);
c_bit_clear = avahi_record_list_is_empty(lq->c_bit_clear);
counter = (2*(!c_bit_set)) + (!c_bit_clear);
switch (counter) { /*TODO, clean it*/
case 0 :
/*We have not yet received any responses. Try to resend the same query*/
resend_llmnr_query(qj);
break;
case 1 :
/*We have received one or multiple reponse/s with 'c' bit clear
and none with 'c' bit set within AVAHI_LLMNR_TIMEOUT. It means
query has been replied. */
call_llmnr_query_callback(lq);
avahi_llmnr_query_job_destroy(qj->scheduler, qj);
/*avahi_time_event_free(qj->time_event);
qj->time_event = NULL;*/
break;
case 2 :
/*We have received atleast one response with 'c' bit set but we didn't
receive any response with 'c' bit clear. We don't want to send this query
further but wait for atleast LLMNR_TIMEOUT + JITTER_INTERVAL to collect
more responses, if any */
reschedule_llmnr_query_job(qj);
break;
case 3 :
/*This is conflict. Let us send AVAHI_LLMNR_CONFLICT_QUERY (with c bit set
in query) along with responses*/
avahi_log_info("CONFLICT..CONFLICT..CONFLICT");
send_conflict_query(qj);
avahi_llmnr_query_job_destroy(qj->scheduler, qj);
break;
}
return;
}
static void kqueue_callback(AvahiWatch *watch, int fd, AVAHI_GCC_UNUSED AvahiWatchEvent event, AVAHI_GCC_UNUSED void *userdata) {
struct kevent ev;
struct timespec nullts = { 0, 0 };
int res;
assert(fd == kq);
assert(watch);
res = kevent(kq, NULL, 0, &ev, 1, &nullts);
if (res > 0) {
/* Sleep for a half-second to avoid potential races
* during install/uninstall. */
usleep(500000);
avahi_log_info("Files changed, reloading.");
reload_config();
} else {
avahi_log_error("Failed to read kqueue event: %s", avahi_strerror(errno));
}
}
static void inotify_callback(AvahiWatch *watch, int fd, AVAHI_GCC_UNUSED AvahiWatchEvent event, AVAHI_GCC_UNUSED void *userdata) {
char* buffer;
int n = 0;
assert(fd == inotify_fd);
assert(watch);
ioctl(inotify_fd, FIONREAD, &n);
if (n <= 0)
n = 128;
buffer = avahi_malloc(n);
if (read(inotify_fd, buffer, n) < 0 ) {
avahi_free(buffer);
avahi_log_error("Failed to read inotify event: %s", avahi_strerror(errno));
return;
}
avahi_free(buffer);
avahi_log_info("Files changed, reloading.");
reload_config();
}
static void entry_group_callback(AvahiServer *s, AVAHI_GCC_UNUSED AvahiSEntryGroup *eg, AvahiEntryGroupState state, void* userdata) {
StaticServiceGroup *g = userdata;
assert(s);
assert(g);
switch (state) {
case AVAHI_ENTRY_GROUP_COLLISION: {
char *n;
remove_static_service_group_from_server(g);
n = avahi_alternative_service_name(g->chosen_name);
avahi_free(g->chosen_name);
g->chosen_name = n;
avahi_log_notice("Service name conflict for \"%s\" (%s), retrying with \"%s\".", g->name, g->filename, g->chosen_name);
add_static_service_group_to_server(g);
break;
}
case AVAHI_ENTRY_GROUP_ESTABLISHED:
avahi_log_info("Service \"%s\" (%s) successfully established.", g->chosen_name, g->filename);
break;
case AVAHI_ENTRY_GROUP_FAILURE:
avahi_log_warn("Failed to publish service \"%s\" (%s): %s", g->chosen_name, g->filename, avahi_strerror(avahi_server_errno(s)));
remove_static_service_group_from_server(g);
break;
case AVAHI_ENTRY_GROUP_UNCOMMITED:
case AVAHI_ENTRY_GROUP_REGISTERING:
;
}
}
static void dump(const char *text, AVAHI_GCC_UNUSED void* userdata) {
avahi_log_info("%s", text);
}
static void server_callback(AvahiServer *s, AvahiServerState state, void *userdata) {
DaemonConfig *c = userdata;
assert(s);
assert(c);
/* This function is possibly called before the global variable
* avahi_server has been set, therefore we do it explicitly */
avahi_server = s;
#ifdef HAVE_DBUS
if (c->enable_dbus && state != AVAHI_SERVER_INVALID && state != AVAHI_SERVER_FAILURE)
dbus_protocol_server_state_changed(state);
#endif
switch (state) {
case AVAHI_SERVER_RUNNING:
avahi_log_info("Server startup complete. Host name is %s. Local service cookie is %u.", avahi_server_get_host_name_fqdn(s), avahi_server_get_local_service_cookie(s));
sd_notifyf(0, "STATUS=Server startup complete. Host name is %s. Local service cookie is %u.", avahi_server_get_host_name_fqdn(s), avahi_server_get_local_service_cookie(s));
avahi_set_proc_title(argv0, "%s: running [%s]", argv0, avahi_server_get_host_name_fqdn(s));
static_service_add_to_server();
static_hosts_add_to_server();
remove_dns_server_entry_groups();
if (c->publish_resolv_conf && resolv_conf_name_servers && resolv_conf_name_servers[0])
resolv_conf_entry_group = add_dns_servers(s, resolv_conf_entry_group, resolv_conf_name_servers);
if (c->publish_dns_servers && c->publish_dns_servers[0])
dns_servers_entry_group = add_dns_servers(s, dns_servers_entry_group, c->publish_dns_servers);
simple_protocol_restart_queries();
break;
case AVAHI_SERVER_COLLISION: {
char *n;
static_service_remove_from_server();
static_hosts_remove_from_server();
remove_dns_server_entry_groups();
n = avahi_alternative_host_name(avahi_server_get_host_name(s));
avahi_log_warn("Host name conflict, retrying with %s", n);
sd_notifyf(0, "STATUS=Host name conflict, retrying with %s", n);
avahi_set_proc_title(argv0, "%s: collision [%s]", argv0, n);
avahi_server_set_host_name(s, n);
avahi_free(n);
break;
}
case AVAHI_SERVER_FAILURE:
avahi_log_error("Server error: %s", avahi_strerror(avahi_server_errno(s)));
sd_notifyf(0, "STATUS=Server error: %s", avahi_strerror(avahi_server_errno(s)));
avahi_simple_poll_quit(simple_poll_api);
break;
case AVAHI_SERVER_REGISTERING:
sd_notifyf(0, "STATUS=Registering host name %s", avahi_server_get_host_name_fqdn(s));
avahi_set_proc_title(argv0, "%s: registering [%s]", argv0, avahi_server_get_host_name_fqdn(s));
static_service_remove_from_server();
static_hosts_remove_from_server();
remove_dns_server_entry_groups();
break;
case AVAHI_SERVER_INVALID:
break;
}
}
int main(int argc, char *argv[]) {
int r = 255;
int wrote_pid_file = 0;
avahi_set_log_function(log_function);
init_rand_seed();
avahi_server_config_init(&config.server_config);
config.command = DAEMON_RUN;
config.daemonize = 0;
config.config_file = NULL;
#ifdef HAVE_DBUS
config.enable_dbus = 1;
config.fail_on_missing_dbus = 1;
config.n_clients_max = 0;
config.n_objects_per_client_max = 0;
config.n_entries_per_entry_group_max = 0;
#endif
config.drop_root = 1;
config.set_rlimits = 1;
#ifdef ENABLE_CHROOT
config.use_chroot = 1;
#endif
config.modify_proc_title = 1;
config.disable_user_service_publishing = 0;
config.publish_dns_servers = NULL;
config.publish_resolv_conf = 0;
config.use_syslog = 0;
config.debug = 0;
config.rlimit_as_set = 0;
config.rlimit_core_set = 0;
config.rlimit_data_set = 0;
config.rlimit_fsize_set = 0;
config.rlimit_nofile_set = 0;
config.rlimit_stack_set = 0;
#ifdef RLIMIT_NPROC
config.rlimit_nproc_set = 0;
#endif
if ((argv0 = strrchr(argv[0], '/')))
argv0 = avahi_strdup(argv0 + 1);
else
argv0 = avahi_strdup(argv[0]);
daemon_pid_file_ident = (const char *) argv0;
daemon_log_ident = (char*) argv0;
daemon_pid_file_proc = pid_file_proc;
if (parse_command_line(&config, argc, argv) < 0)
goto finish;
if (config.modify_proc_title)
avahi_init_proc_title(argc, argv);
#ifdef ENABLE_CHROOT
config.use_chroot = config.use_chroot && config.drop_root;
#endif
if (config.command == DAEMON_HELP) {
help(stdout);
r = 0;
} else if (config.command == DAEMON_VERSION) {
printf("%s "PACKAGE_VERSION"\n", argv0);
r = 0;
} else if (config.command == DAEMON_KILL) {
if (daemon_pid_file_kill_wait(SIGTERM, 5) < 0) {
avahi_log_warn("Failed to kill daemon: %s", strerror(errno));
goto finish;
}
r = 0;
} else if (config.command == DAEMON_RELOAD) {
if (daemon_pid_file_kill(SIGHUP) < 0) {
avahi_log_warn("Failed to kill daemon: %s", strerror(errno));
goto finish;
}
r = 0;
} else if (config.command == DAEMON_CHECK)
r = (daemon_pid_file_is_running() >= 0) ? 0 : 1;
else if (config.command == DAEMON_RUN) {
pid_t pid;
if (getuid() != 0 && config.drop_root) {
avahi_log_error("This program is intended to be run as root.");
goto finish;
}
if ((pid = daemon_pid_file_is_running()) >= 0) {
avahi_log_error("Daemon already running on PID %u", pid);
goto finish;
}
if (load_config_file(&config) < 0)
goto finish;
if (config.daemonize) {
daemon_retval_init();
if ((pid = daemon_fork()) < 0)
goto finish;
else if (pid != 0) {
int ret;
/** Parent **/
if ((ret = daemon_retval_wait(20)) < 0) {
avahi_log_error("Could not receive return value from daemon process.");
goto finish;
}
r = ret;
goto finish;
}
/* Child */
}
if (config.use_syslog || config.daemonize)
daemon_log_use = DAEMON_LOG_SYSLOG;
if (sd_listen_fds(0) <= 0)
if (daemon_close_all(-1) < 0)
avahi_log_warn("Failed to close all remaining file descriptors: %s", strerror(errno));
daemon_reset_sigs(-1);
daemon_unblock_sigs(-1);
if (make_runtime_dir() < 0)
goto finish;
if (config.drop_root) {
#ifdef ENABLE_CHROOT
if (config.use_chroot)
if (avahi_caps_reduce() < 0)
goto finish;
#endif
if (drop_root() < 0)
goto finish;
#ifdef ENABLE_CHROOT
if (config.use_chroot)
if (avahi_caps_reduce2() < 0)
goto finish;
#endif
}
if (daemon_pid_file_create() < 0) {
avahi_log_error("Failed to create PID file: %s", strerror(errno));
if (config.daemonize)
daemon_retval_send(1);
goto finish;
} else
wrote_pid_file = 1;
if (config.set_rlimits)
enforce_rlimits();
chdir("/");
#ifdef ENABLE_CHROOT
if (config.drop_root && config.use_chroot)
if (avahi_chroot_helper_start(argv0) < 0) {
avahi_log_error("failed to start chroot() helper daemon.");
goto finish;
}
#endif
avahi_log_info("%s "PACKAGE_VERSION" starting up.", argv0);
sd_notifyf(0, "STATUS=%s "PACKAGE_VERSION" starting up.", argv0);
avahi_set_proc_title(argv0, "%s: starting up", argv0);
if (run_server(&config) == 0)
r = 0;
avahi_log_info("%s "PACKAGE_VERSION" exiting.", argv0);
sd_notifyf(0, "STATUS=%s "PACKAGE_VERSION" exiting.", argv0);
}
finish:
if (config.daemonize)
daemon_retval_done();
avahi_server_config_free(&config.server_config);
avahi_free(config.config_file);
avahi_strfreev(config.publish_dns_servers);
avahi_strfreev(resolv_conf_name_servers);
avahi_strfreev(resolv_conf_search_domains);
if (wrote_pid_file) {
#ifdef ENABLE_CHROOT
avahi_chroot_helper_unlink(pid_file_proc());
#else
daemon_pid_file_remove();
#endif
}
#ifdef ENABLE_CHROOT
avahi_chroot_helper_shutdown();
#endif
avahi_free(argv0);
return r;
}
static int drop_root(void) {
struct passwd *pw;
struct group * gr;
int r;
if (!(pw = getpwnam(AVAHI_USER))) {
avahi_log_error( "Failed to find user '"AVAHI_USER"'.");
return -1;
}
if (!(gr = getgrnam(AVAHI_GROUP))) {
avahi_log_error( "Failed to find group '"AVAHI_GROUP"'.");
return -1;
}
avahi_log_info("Found user '"AVAHI_USER"' (UID %lu) and group '"AVAHI_GROUP"' (GID %lu).", (unsigned long) pw->pw_uid, (unsigned long) gr->gr_gid);
if (initgroups(AVAHI_USER, gr->gr_gid) != 0) {
avahi_log_error("Failed to change group list: %s", strerror(errno));
return -1;
}
#if defined(HAVE_SETRESGID)
r = setresgid(gr->gr_gid, gr->gr_gid, gr->gr_gid);
#elif defined(HAVE_SETEGID)
if ((r = setgid(gr->gr_gid)) >= 0)
r = setegid(gr->gr_gid);
#elif defined(HAVE_SETREGID)
r = setregid(gr->gr_gid, gr->gr_gid);
#else
#error "No API to drop privileges"
#endif
if (r < 0) {
avahi_log_error("Failed to change GID: %s", strerror(errno));
return -1;
}
#if defined(HAVE_SETRESUID)
r = setresuid(pw->pw_uid, pw->pw_uid, pw->pw_uid);
#elif defined(HAVE_SETEUID)
if ((r = setuid(pw->pw_uid)) >= 0)
r = seteuid(pw->pw_uid);
#elif defined(HAVE_SETREUID)
r = setreuid(pw->pw_uid, pw->pw_uid);
#else
#error "No API to drop privileges"
#endif
if (r < 0) {
avahi_log_error("Failed to change UID: %s", strerror(errno));
return -1;
}
set_env("USER", pw->pw_name);
set_env("LOGNAME", pw->pw_name);
set_env("HOME", pw->pw_dir);
avahi_log_info("Successfully dropped root privileges.");
return 0;
}
static int run_server(DaemonConfig *c) {
int r = -1;
int error;
const AvahiPoll *poll_api = NULL;
AvahiWatch *sig_watch = NULL;
int retval_is_sent = 0;
#ifdef HAVE_INOTIFY
AvahiWatch *inotify_watch = NULL;
#endif
#ifdef HAVE_KQUEUE
int i;
AvahiWatch *kqueue_watch = NULL;
#endif
assert(c);
ignore_signal(SIGPIPE);
if (!(nss_support = avahi_nss_support()))
avahi_log_warn("WARNING: No NSS support for mDNS detected, consider installing nss-mdns!");
if (!(simple_poll_api = avahi_simple_poll_new())) {
avahi_log_error("Failed to create main loop object.");
goto finish;
}
poll_api = avahi_simple_poll_get(simple_poll_api);
if (daemon_signal_init(SIGINT, SIGHUP, SIGTERM, SIGUSR1, 0) < 0) {
avahi_log_error("Could not register signal handlers (%s).", strerror(errno));
goto finish;
}
if (!(sig_watch = poll_api->watch_new(poll_api, daemon_signal_fd(), AVAHI_WATCH_IN, signal_callback, simple_poll_api))) {
avahi_log_error( "Failed to create signal watcher");
goto finish;
}
if (simple_protocol_setup(poll_api) < 0)
goto finish;
#ifdef HAVE_DBUS
if (c->enable_dbus) {
if (dbus_protocol_setup(poll_api,
config.disable_user_service_publishing,
config.n_clients_max,
config.n_objects_per_client_max,
config.n_entries_per_entry_group_max,
!c->fail_on_missing_dbus
#ifdef ENABLE_CHROOT
&& !config.use_chroot
#endif
) < 0) {
avahi_log_warn("WARNING: Failed to contact D-Bus daemon.");
if (c->fail_on_missing_dbus)
goto finish;
}
}
#endif
#ifdef ENABLE_CHROOT
if (config.drop_root && config.use_chroot) {
if (chroot(AVAHI_CONFIG_DIR) < 0) {
avahi_log_error("Failed to chroot(): %s", strerror(errno));
goto finish;
}
avahi_log_info("Successfully called chroot().");
chdir("/");
if (avahi_caps_drop_all() < 0) {
avahi_log_error("Failed to drop capabilities.");
goto finish;
}
avahi_log_info("Successfully dropped remaining capabilities.");
}
#endif
#ifdef HAVE_INOTIFY
if ((inotify_fd = inotify_init()) < 0)
avahi_log_warn( "Failed to initialize inotify: %s", strerror(errno));
else {
add_inotify_watches();
if (!(inotify_watch = poll_api->watch_new(poll_api, inotify_fd, AVAHI_WATCH_IN, inotify_callback, NULL))) {
avahi_log_error( "Failed to create inotify watcher");
goto finish;
}
}
#endif
#ifdef HAVE_KQUEUE
if ((kq = kqueue()) < 0)
avahi_log_warn( "Failed to initialize kqueue: %s", strerror(errno));
else {
add_kqueue_watches();
if (!(kqueue_watch = poll_api->watch_new(poll_api, kq, AVAHI_WATCH_IN, kqueue_callback, NULL))) {
avahi_log_error( "Failed to create kqueue watcher");
goto finish;
}
}
#endif
load_resolv_conf();
#ifdef ENABLE_CHROOT
static_service_load(config.use_chroot);
static_hosts_load(config.use_chroot);
#else
static_service_load(0);
static_hosts_load(0);
#endif
if (!(avahi_server = avahi_server_new(poll_api, &c->server_config, server_callback, c, &error))) {
avahi_log_error("Failed to create server: %s", avahi_strerror(error));
goto finish;
}
update_wide_area_servers();
update_browse_domains();
if (c->daemonize) {
daemon_retval_send(0);
retval_is_sent = 1;
}
for (;;) {
if ((r = avahi_simple_poll_iterate(simple_poll_api, -1)) < 0) {
/* We handle signals through an FD, so let's continue */
if (errno == EINTR)
continue;
avahi_log_error("poll(): %s", strerror(errno));
goto finish;
} else if (r > 0)
/* Quit */
break;
}
r = 0;
finish:
static_service_remove_from_server();
static_service_free_all();
static_hosts_remove_from_server();
static_hosts_free_all();
remove_dns_server_entry_groups();
simple_protocol_shutdown();
#ifdef HAVE_DBUS
if (c->enable_dbus)
dbus_protocol_shutdown();
#endif
if (avahi_server) {
avahi_server_free(avahi_server);
avahi_server = NULL;
}
daemon_signal_done();
if (sig_watch)
poll_api->watch_free(sig_watch);
#ifdef HAVE_INOTIFY
if (inotify_watch)
poll_api->watch_free(inotify_watch);
if (inotify_fd >= 0)
close(inotify_fd);
#endif
#ifdef HAVE_KQUEUE
if (kqueue_watch)
poll_api->watch_free(kqueue_watch);
if (kq >= 0)
close(kq);
for (i = 0; i < num_kfds; i++) {
if (kfds[i] >= 0)
close(kfds[i]);
}
#endif
if (simple_poll_api) {
avahi_simple_poll_free(simple_poll_api);
simple_poll_api = NULL;
}
if (!retval_is_sent && c->daemonize)
daemon_retval_send(1);
return r;
}
static void netlink_callback(AvahiNetlink *nl, struct nlmsghdr *n, void* userdata) {
AvahiInterfaceMonitor *m = userdata;
/* This routine is called for every RTNETLINK response packet */
assert(m);
assert(n);
assert(m->osdep.netlink == nl);
if (n->nlmsg_type == RTM_NEWLINK) {
/* A new interface appeared or an existing one has been modified */
struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
AvahiHwInterface *hw;
struct rtattr *a = NULL;
size_t l;
/* A (superfluous?) sanity check */
if (ifinfomsg->ifi_family != AF_UNSPEC)
return;
/* Check whether there already is an AvahiHwInterface object
* for this link, so that we can update its data. Note that
* Netlink sends us an RTM_NEWLINK not only when a new
* interface appears, but when it changes, too */
if (!(hw = avahi_interface_monitor_get_hw_interface(m, ifinfomsg->ifi_index)))
/* No object found, so let's create a new
* one. avahi_hw_interface_new() will call
* avahi_interface_new() internally twice for IPv4 and
* IPv6, so there is no need for us to do that
* ourselves */
if (!(hw = avahi_hw_interface_new(m, (AvahiIfIndex) ifinfomsg->ifi_index)))
return; /* OOM */
/* Check whether the flags of this interface are OK for us */
hw->flags_ok =
(ifinfomsg->ifi_flags & IFF_UP) &&
(!m->server->config.use_iff_running || (ifinfomsg->ifi_flags & IFF_RUNNING)) &&
!(ifinfomsg->ifi_flags & IFF_LOOPBACK) &&
(ifinfomsg->ifi_flags & IFF_MULTICAST) &&
(m->server->config.allow_point_to_point || !(ifinfomsg->ifi_flags & IFF_POINTOPOINT));
/* Handle interface attributes */
l = NLMSG_PAYLOAD(n, sizeof(struct ifinfomsg));
a = IFLA_RTA(ifinfomsg);
while (RTA_OK(a, l)) {
switch(a->rta_type) {
case IFLA_IFNAME:
/* Fill in interface name */
avahi_free(hw->name);
hw->name = avahi_strndup(RTA_DATA(a), RTA_PAYLOAD(a));
break;
case IFLA_MTU:
/* Fill in MTU */
assert(RTA_PAYLOAD(a) == sizeof(unsigned int));
hw->mtu = *((unsigned int*) RTA_DATA(a));
break;
case IFLA_ADDRESS:
/* Fill in hardware (MAC) address */
hw->mac_address_size = RTA_PAYLOAD(a);
if (hw->mac_address_size > AVAHI_MAC_ADDRESS_MAX)
hw->mac_address_size = AVAHI_MAC_ADDRESS_MAX;
memcpy(hw->mac_address, RTA_DATA(a), hw->mac_address_size);
break;
default:
;
}
a = RTA_NEXT(a, l);
}
/* Check whether this interface is now "relevant" for us. If
* it is Avahi will start to announce its records on this
* interface and send out queries for subscribed records on
* it */
avahi_hw_interface_check_relevant(hw, AVAHI_MDNS);
avahi_hw_interface_check_relevant(hw, AVAHI_LLMNR);
/* Update any associated RRs of this interface. (i.e. the
* _workstation._tcp record containing the MAC address) */
avahi_hw_interface_update_rrs(hw, 0);
} else if (n->nlmsg_type == RTM_DELLINK) {
/* An interface has been removed */
struct ifinfomsg *ifinfomsg = NLMSG_DATA(n);
AvahiHwInterface *hw;
/* A (superfluous?) sanity check */
if (ifinfomsg->ifi_family != AF_UNSPEC)
return;
/* Get a reference to our AvahiHwInterface object of this interface */
if (!(hw = avahi_interface_monitor_get_hw_interface(m, (AvahiIfIndex) ifinfomsg->ifi_index)))
return;
/* Free our object */
avahi_hw_interface_free(hw, 0);
} else if (n->nlmsg_type == RTM_NEWADDR || n->nlmsg_type == RTM_DELADDR) {
/* An address has been added, modified or removed */
struct ifaddrmsg *ifaddrmsg = NLMSG_DATA(n);
AvahiInterface *i;
struct rtattr *a = NULL;
size_t l;
AvahiAddress raddr, rlocal, *r;
int raddr_valid = 0, rlocal_valid = 0;
/* We are only interested in IPv4 and IPv6 */
if (ifaddrmsg->ifa_family != AF_INET && ifaddrmsg->ifa_family != AF_INET6)
return;
/* Try to get a reference to our AvahiInterface object for the
* interface this address is assigned to. If ther is no object
* for this interface, we ignore this address. */
if (!(i = avahi_interface_monitor_get_interface(m, (AvahiIfIndex) ifaddrmsg->ifa_index, avahi_af_to_proto(ifaddrmsg->ifa_family))))
return;
/* Fill in address family for our new address */
rlocal.proto = raddr.proto = avahi_af_to_proto(ifaddrmsg->ifa_family);
l = NLMSG_PAYLOAD(n, sizeof(struct ifaddrmsg));
a = IFA_RTA(ifaddrmsg);
while (RTA_OK(a, l)) {
switch(a->rta_type) {
case IFA_ADDRESS:
if ((rlocal.proto == AVAHI_PROTO_INET6 && RTA_PAYLOAD(a) != 16) ||
(rlocal.proto == AVAHI_PROTO_INET && RTA_PAYLOAD(a) != 4))
return;
memcpy(rlocal.data.data, RTA_DATA(a), RTA_PAYLOAD(a));
rlocal_valid = 1;
break;
case IFA_LOCAL:
/* Fill in local address data. Usually this is
* preferable over IFA_ADDRESS if both are set,
* since this refers to the local address of a PPP
* link while IFA_ADDRESS refers to the other
* end. */
if ((raddr.proto == AVAHI_PROTO_INET6 && RTA_PAYLOAD(a) != 16) ||
(raddr.proto == AVAHI_PROTO_INET && RTA_PAYLOAD(a) != 4))
return;
memcpy(raddr.data.data, RTA_DATA(a), RTA_PAYLOAD(a));
raddr_valid = 1;
break;
default:
;
}
a = RTA_NEXT(a, l);
}
/* If there was no adress attached to this message, let's quit. */
if (rlocal_valid)
r = &rlocal;
else if (raddr_valid)
r = &raddr;
else
return;
if (n->nlmsg_type == RTM_NEWADDR) {
AvahiInterfaceAddress *addr;
/* This address is new or has been modified, so let's get an object for it */
if (!(addr = avahi_interface_monitor_get_address(m, i, r)))
/* Mmm, no object existing yet, so let's create a new one */
if (!(addr = avahi_interface_address_new(m, i, r, ifaddrmsg->ifa_prefixlen)))
return; /* OOM */
/* Update the scope field for the address */
addr->global_scope = ifaddrmsg->ifa_scope == RT_SCOPE_UNIVERSE || ifaddrmsg->ifa_scope == RT_SCOPE_SITE;
addr->deprecated = !!(ifaddrmsg->ifa_flags & IFA_F_DEPRECATED);
} else {
AvahiInterfaceAddress *addr;
assert(n->nlmsg_type == RTM_DELADDR);
/* Try to get a reference to our AvahiInterfaceAddress object for this address */
if (!(addr = avahi_interface_monitor_get_address(m, i, r)))
return;
/* And free it */
avahi_interface_address_free(addr);
}
/* Avahi only considers interfaces with at least one address
* attached relevant. Since we migh have added or removed an
* address, let's have it check again whether the interface is
* now relevant */
avahi_interface_check_relevant(i, AVAHI_MDNS);
avahi_interface_check_relevant(i, AVAHI_LLMNR);
/* Update any associated RRs, like A or AAAA for our new/removed address */
avahi_interface_update_rrs(i, 0);
} else if (n->nlmsg_type == NLMSG_DONE) {
/* This wild dump request ended, so let's see what we do next */
if (m->osdep.list == LIST_IFACE) {
/* Mmmm, interfaces have been wild dumped already, so
* let's go on with wild dumping the addresses */
if (netlink_list_items(m->osdep.netlink, RTM_GETADDR, &m->osdep.query_addr_seq) < 0) {
avahi_log_warn("NETLINK: Failed to list addrs: %s", strerror(errno));
m->osdep.list = LIST_DONE;
} else
/* Update state information */
m->osdep.list = LIST_ADDR;
} else
/* We're done. Tell avahi_interface_monitor_sync() to finish. */
m->osdep.list = LIST_DONE;
if (m->osdep.list == LIST_DONE) {
/* Only after this boolean variable has been set, Avahi
* will start to announce or browse on all interfaces. It
* is originaly set to 0, which means that relevancy
* checks and RR updates are disabled during the wild
* dumps. */
m->list_complete = 1;
/* So let's check if any interfaces are relevant now */
avahi_interface_monitor_check_relevant(m, AVAHI_MDNS);
avahi_interface_monitor_check_relevant(m, AVAHI_LLMNR);
/* And update all RRs attached to any interface */
avahi_interface_monitor_update_rrs(m, 0);
/* Tell the user that the wild dump is complete */
avahi_log_info("Network interface enumeration completed.");
}
} else if (n->nlmsg_type == NLMSG_ERROR &&
(n->nlmsg_seq == m->osdep.query_link_seq || n->nlmsg_seq == m->osdep.query_addr_seq)) {
struct nlmsgerr *e = NLMSG_DATA (n);
/* Some kind of error happened. Let's just tell the user and
* ignore it otherwise */
if (e->error)
avahi_log_warn("NETLINK: Failed to browse: %s", strerror(-e->error));
}
}
void static_hosts_load(int in_chroot) {
FILE *f;
unsigned int line = 0;
StaticHost *h, *next;
const char *filename = in_chroot ? "/hosts" : AVAHI_CONFIG_DIR "/hosts";
if (!(f = fopen(filename, "r"))) {
if (errno != ENOENT)
avahi_log_error ("Failed to open static hosts file: %s", strerror (errno));
return;
}
current_iteration++;
while (!feof(f)) {
unsigned int len;
char ln[256], *s;
char *host, *ip;
AvahiAddress a;
if (!fgets(ln, sizeof (ln), f))
break;
line++;
/* Find the start of the line, ignore whitespace */
s = ln + strspn(ln, " \t");
/* Set the end of the string to NULL */
s[strcspn(s, "#\r\n")] = 0;
/* Ignore blank lines */
if (*s == 0)
continue;
/* Read the first string (ip) up to the next whitespace */
len = strcspn(s, " \t");
ip = avahi_strndup(s, len);
/* Skip past it */
s += len;
/* Find the next token */
s += strspn(s, " \t");
len = strcspn(s, " \t");
host = avahi_strndup(s, len);
if (*host == 0)
{
avahi_log_error("%s:%d: Error, unexpected end of line!", filename, line);
avahi_free(host);
avahi_free(ip);
goto fail;
}
/* Skip over the host */
s += len;
/* Skip past any more spaces */
s += strspn(s, " \t");
/* Anything left? */
if (*s != 0) {
avahi_log_error ("%s:%d: Junk on the end of the line!", filename, line);
avahi_free(host);
avahi_free(ip);
goto fail;
}
if (!avahi_address_parse(ip, AVAHI_PROTO_UNSPEC, &a)) {
avahi_log_error("Static host name %s: failed to parse address %s", host, ip);
avahi_free(host);
avahi_free(ip);
goto fail;
}
avahi_free(ip);
if ((h = static_host_find(host, &a)))
avahi_free(host);
else {
h = static_host_new();
h->host = host;
h->address = a;
avahi_log_info("Loading new static hostname %s.", h->host);
}
h->iteration = current_iteration;
}
for (h = hosts; h; h = next) {
next = h->hosts_next;
if (h->iteration != current_iteration) {
avahi_log_info("Static hostname %s vanished, removing.", h->host);
static_host_free(h);
}
}
fail:
fclose(f);
}
