int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
AvahiServer *server;
AvahiServerConfig config;
int error;
AvahiSimplePoll *simple_poll;
simple_poll = avahi_simple_poll_new();
avahi_server_config_init(&config);
config.publish_hinfo = 0;
config.publish_addresses = 0;
config.publish_workstation = 0;
config.publish_domain = 0;
config.use_ipv6 = 0;
config.enable_reflector = 1;
server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, NULL, NULL, &error);
avahi_server_config_free(&config);
for (;;)
if (avahi_simple_poll_iterate(simple_poll, -1) != 0)
break;
avahi_server_free(server);
avahi_simple_poll_free(simple_poll);
return 0;
}
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
AvahiServerConfig config;
AvahiServer *server = NULL;
int error;
int ret = 1;
/* Initialize the pseudo-RNG */
srand(time(NULL));
/* Allocate main loop object */
if (!(simple_poll = avahi_simple_poll_new())) {
fprintf(stderr, "Failed to create simple poll object.\n");
goto fail;
}
name = avahi_strdup("MegaPrinter");
/* Let's set the host name for this server. */
avahi_server_config_init(&config);
config.host_name = avahi_strdup("gurkiman");
config.publish_workstation = 0;
/* Allocate a new server */
server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, server_callback, NULL, &error);
/* Free the configuration data */
avahi_server_config_free(&config);
/* Check wether creating the server object succeeded */
if (!server) {
fprintf(stderr, "Failed to create server: %s\n", avahi_strerror(error));
goto fail;
}
/* Run the main loop */
avahi_simple_poll_loop(simple_poll);
ret = 0;
fail:
/* Cleanup things */
if (server)
avahi_server_free(server);
if (simple_poll)
avahi_simple_poll_free(simple_poll);
avahi_free(name);
return ret;
}
ControllerDiscoveryMDNS::~ControllerDiscoveryMDNS()
{
if ( group )
{
avahi_s_entry_group_free( group );
}
if ( server )
{
avahi_server_free( server );
}
avahi_glib_poll_free( poll );
}
void ofxAvahiCoreBrowser::close(){
ofLogVerbose(LOG_NAME) << "closing";
if (poll){
avahi_simple_poll_quit(poll);
waitForThread(false);
}
if (sb)
avahi_s_service_browser_free(sb);
if (server)
avahi_server_free(server);
if (poll)
avahi_simple_poll_free(poll);
}
static void start_server(AvahiTimeout *t, void *userdata) {
int error;
assert(t);
if (stb) {
DEBUG("Service type browser already exists");
avahi_s_service_type_browser_free(stb);
stb = NULL;
}
if (server) {
DEBUG("Server already exists");
avahi_server_free(server);
server = NULL;
}
/* Allocate a new server */
server = avahi_server_new(avahi_simple_poll_get(simple_poll), &config, server_callback, NULL, &error);
/* Check whether creating the server object succeeded */
if (!server) {
ERROR("Failed to create server: %s", avahi_strerror(error));
avahi_simple_poll_quit(simple_poll);
return;
}
/* every UPDATE_INTERVAL seconds, shut down and re-create server. This
* has the benefit of causing CSM to send queries to other nodes, prompting
* them to re-multicast their services. This is done because mDNS seems to
* be very unreliable on mesh, and often nodes don't get service announcements
* or can't resolve them. */
struct timeval tv = {0};
avahi_elapse_time(&tv, 1000*UPDATE_INTERVAL, 0);
avahi_simple_poll_get(simple_poll)->timeout_update(t, &tv);
}
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;
}
int main(int argc, char*argv[]) {
int ret = 1;
argp_program_version = "1.0";
static char doc[] = "Commotion Service Manager";
static struct argp_option options[] = {
{"bind", 'b', "URI", 0, "commotiond management socket"},
{"nodaemon", 'n', 0, 0, "Do not fork into the background" },
{"out", 'o', "FILE", 0, "Output file to write services to when USR1 signal is received" },
{"pid", 'p', "FILE", 0, "Specify PID file"},
#ifdef USE_UCI
{"uci", 'u', 0, 0, "Store service cache in UCI" },
#endif
{ 0 }
};
/* Set defaults */
arguments.co_sock = DEFAULT_CO_SOCK;
#ifdef USE_UCI
arguments.uci = 0;
#endif
arguments.nodaemon = 0;
arguments.output_file = DEFAULT_FILENAME;
arguments.pid_file = PIDFILE;
static struct argp argp = { options, parse_opt, NULL, doc };
argp_parse (&argp, argc, argv, 0, 0, &arguments);
//fprintf(stdout,"uci: %d, out: %s\n",arguments.uci,arguments.output_file);
if (!arguments.nodaemon)
daemon_start(arguments.pid_file);
CHECK(co_init(),"Failed to initialize Commotion client");
struct sigaction sa = {0};
sa.sa_handler = print_services;
CHECK(sigaction(SIGUSR1,&sa,NULL) == 0, "Failed to set signal handler");
sa.sa_handler = shutdown;
CHECK(sigaction(SIGINT,&sa,NULL) == 0, "Failed to set signal handler");
CHECK(sigaction(SIGTERM,&sa,NULL) == 0, "Failed to set signal handler");
/* Initialize the psuedo-RNG */
srand(time(NULL));
/* Allocate main loop object */
CHECK((simple_poll = avahi_simple_poll_new()),"Failed to create simple poll object.");
/* Do not publish any local records */
avahi_server_config_init(&config);
config.publish_hinfo = 0;
config.publish_addresses = 0;
config.publish_workstation = 0;
config.publish_domain = 0;
/* Set a unicast DNS server for wide area DNS-SD */
avahi_address_parse("192.168.50.1", AVAHI_PROTO_UNSPEC, &config.wide_area_servers[0]);
config.n_wide_area_servers = 1;
config.enable_wide_area = 1;
// Start timer to create server
struct timeval tv = {0};
avahi_elapse_time(&tv, 0, 0);
avahi_simple_poll_get(simple_poll)->timeout_new(avahi_simple_poll_get(simple_poll), &tv, start_server, NULL); // create expiration event for service
/* Run the main loop */
avahi_simple_poll_loop(simple_poll);
ret = 0;
error:
/* Free the configuration data */
avahi_server_config_free(&config);
co_shutdown();
/* Cleanup things */
if (stb)
avahi_s_service_type_browser_free(stb);
if (server)
avahi_server_free(server);
if (simple_poll)
avahi_simple_poll_free(simple_poll);
return ret;
}
