path: root/src/zeroconf.c

/* the Music Player Daemon (MPD)
 * (c)2003-2006 by Warren Dukes (warren.dukes@gmail.com)
 * This project's homepage is: http://www.musicpd.org
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#include <stdlib.h>
#include <assert.h>
#include <string.h>

#include "zeroconf.h"
#include "conf.h"
#include "log.h"
#include "listen.h"
#include "ioops.h"
#include "utils.h"

/* The dns-sd service type qualifier to publish */
#define SERVICE_TYPE		"_mpd._tcp"

/* The default service name to publish 
 * (overridden by 'zeroconf_name' config parameter)
 */
#define SERVICE_NAME		"Music Player"

/* Here is the implementation for Avahi (http://avahi.org) Zeroconf support */
#ifdef HAVE_AVAHI

#include <avahi-client/client.h>
#include <avahi-client/publish.h>

#include <avahi-common/alternative.h>
#include <avahi-common/domain.h>
#include <avahi-common/malloc.h>
#include <avahi-common/error.h>

/* Static avahi data */
static AvahiEntryGroup *avahiGroup;
static char *avahiName;
static AvahiClient* avahiClient;
static AvahiPoll avahiPoll;
static int avahiRunning;

static int avahiFdset( fd_set* rfds, fd_set* wfds, fd_set* efds );
static int avahiFdconsume( int fdCount, fd_set* rfds, fd_set* wfds, fd_set* efds );
static struct ioOps avahiIo = {
	.fdset = avahiFdset,
	.consume = avahiFdconsume,
};

/* Forward Declaration */
static void avahiRegisterService(AvahiClient *c);

struct AvahiWatch {
	struct AvahiWatch* prev;
	struct AvahiWatch* next;
	int fd;
	AvahiWatchEvent requestedEvent;
	AvahiWatchEvent observedEvent;
	AvahiWatchCallback callback;
	void* userdata;
};

struct AvahiTimeout {
	struct AvahiTimeout* prev;
	struct AvahiTimeout* next;
	struct timeval expiry;
	int enabled;
	AvahiTimeoutCallback callback;
	void* userdata;
};

static AvahiWatch* avahiWatchList;
static AvahiTimeout* avahiTimeoutList;

static AvahiWatch* avahiWatchNew( const AvahiPoll *api, int fd, AvahiWatchEvent event, AvahiWatchCallback callback, void *userdata )
{
	struct AvahiWatch* newWatch = xmalloc( sizeof(struct AvahiWatch) );

	newWatch->fd = fd;
	newWatch->requestedEvent = event;
	newWatch->observedEvent = 0;
	newWatch->callback = callback;
	newWatch->userdata = userdata;

	/* Insert at front of list */
	newWatch->next = avahiWatchList;
	avahiWatchList = newWatch;
	newWatch->prev = NULL;
	if( newWatch->next )
		newWatch->next->prev = newWatch;

	return newWatch;
}

static void avahiWatchUpdate( AvahiWatch *w, AvahiWatchEvent event )
{
	assert( w != NULL );
	w->requestedEvent = event;
}

static AvahiWatchEvent avahiWatchGetEvents( AvahiWatch *w )
{
	assert( w != NULL );
	return w->observedEvent;
}

static void avahiWatchFree( AvahiWatch *w )
{
	assert( w != NULL );

	if( avahiWatchList == w )
		avahiWatchList = w->next;
	else if( w->prev != NULL )
		w->prev->next = w->next;

	free( w );
}

static void avahiCheckExpiry( AvahiTimeout *t )
{
	assert( t != NULL );
	if( t->enabled ) {
		struct timeval now;
		gettimeofday( &now, NULL );
		if( timercmp( &now, &(t->expiry), > ) ) {
			t->enabled = 0;
			t->callback( t, t->userdata );
		}
	}
}

static void avahiTimeoutUpdate( AvahiTimeout *t, const struct timeval *tv )
{
	assert( t != NULL );
	if( tv ) {
		t->enabled = 1;
		t->expiry.tv_sec = tv->tv_sec;
		t->expiry.tv_usec = tv->tv_usec;
	} else {
		t->enabled = 0;
	}
}

static void avahiTimeoutFree( AvahiTimeout *t )
{
	assert( t != NULL );

	if( avahiTimeoutList == t )
		avahiTimeoutList = t->next;
	else if( t->prev != NULL )
		t->prev->next = t->next;

	free( t );
}

static AvahiTimeout* avahiTimeoutNew( const AvahiPoll *api, const struct timeval *tv, AvahiTimeoutCallback callback, void *userdata )
{
	struct AvahiTimeout* newTimeout = xmalloc( sizeof(struct AvahiTimeout) );

	newTimeout->callback = callback;
	newTimeout->userdata = userdata;

	avahiTimeoutUpdate( newTimeout, tv );

	/* Insert at front of list */
	newTimeout->next = avahiTimeoutList;
	avahiTimeoutList = newTimeout;
	newTimeout->prev = NULL;
	if( newTimeout->next )
		newTimeout->next->prev = newTimeout;
	
	return newTimeout;
}

/* Callback when the EntryGroup changes state */
static void avahiGroupCallback(
		AvahiEntryGroup *g,
		AvahiEntryGroupState state,
		void *userdata)
{
	assert(g);

	DEBUG( "Avahi: Service group changed to state %d\n", state );

	switch (state) {
		case AVAHI_ENTRY_GROUP_ESTABLISHED :
			/* The entry group has been established successfully */
			LOG( "Avahi: Service '%s' successfully established.\n", avahiName );
			break;

		case AVAHI_ENTRY_GROUP_COLLISION : {
			char *n;
			
			/* A service name collision happened. Let's pick a new name */
			n = avahi_alternative_service_name(avahiName);
			avahi_free(avahiName);
			avahiName = n;
			
			LOG( "Avahi: Service name collision, renaming service to '%s'\n", avahiName );

			/* And recreate the services */
			avahiRegisterService(avahi_entry_group_get_client(g));
			break;
		}

		case AVAHI_ENTRY_GROUP_FAILURE :
			ERROR( "Avahi: Entry group failure: %s\n",
					avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g))) );
			/* Some kind of failure happened while we were registering our services */
			avahiRunning = 0;
			break;

		case AVAHI_ENTRY_GROUP_UNCOMMITED:
			DEBUG( "Avahi: Service group is UNCOMMITED\n" );
			break;
		case AVAHI_ENTRY_GROUP_REGISTERING:
			DEBUG( "Avahi: Service group is REGISTERING\n" );
			;
	}
}

/* Registers a new service with avahi */
static void avahiRegisterService(AvahiClient *c)
{
	int ret;
	assert(c);
	DEBUG( "Avahi: Registering service %s/%s\n", SERVICE_TYPE, avahiName );

	/* If this is the first time we're called, let's create a new entry group */
	if (!avahiGroup) {
		avahiGroup = avahi_entry_group_new(c, avahiGroupCallback, NULL);
		if( !avahiGroup ) {
			ERROR( "Avahi: Failed to create avahi EntryGroup: %s\n", avahi_strerror(avahi_client_errno(c)) );
			goto fail;
		}
	}

	/* Add the service */
	/* TODO: This currently binds to ALL interfaces.
	 *       We could maybe add a service per actual bound interface, if that's better. */
	ret = avahi_entry_group_add_service(avahiGroup,
					AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, 0,
					avahiName, SERVICE_TYPE,
					NULL, NULL,
					getBoundPort(),
					NULL);
	if( ret < 0 ) {
		ERROR( "Avahi: Failed to add service %s: %s\n", SERVICE_TYPE, avahi_strerror(ret) );
		goto fail;
	}

	/* Tell the server to register the service group */
	ret = avahi_entry_group_commit(avahiGroup);
	if( ret < 0 ) {
		ERROR( "Avahi: Failed to commit service group: %s\n", avahi_strerror(ret) );
		goto fail;
	}
	return;

fail:
	avahiRunning = 0;
}

/* Callback when avahi changes state */
static void avahiClientCallback(AvahiClient *c, AvahiClientState state, void *userdata)
{
	assert(c);

	/* Called whenever the client or server state changes */
	DEBUG( "Avahi: Client changed to state %d\n", state );

	switch (state) {
		case AVAHI_CLIENT_S_RUNNING:
			DEBUG( "Avahi: Client is RUNNING\n" );
		
			/* The server has startup successfully and registered its host
			 * name on the network, so it's time to create our services */
			if (!avahiGroup)
				avahiRegisterService(c);
			break;

		case AVAHI_CLIENT_FAILURE:
			{
				int reason = avahi_client_errno(c);
				if( reason == AVAHI_ERR_DISCONNECTED ) {
					LOG( "Avahi: Client Disconnected, will reconnect shortly\n");
					avahi_entry_group_free( avahiGroup );
					avahiGroup = NULL;
					avahi_client_free( avahiClient );
					avahiClient = NULL;
					avahiClient = avahi_client_new( &avahiPoll, AVAHI_CLIENT_NO_FAIL,
						avahiClientCallback, NULL, &reason );
					if( !avahiClient ) {
						ERROR( "Avahi: Could not reconnect: %s\n", avahi_strerror(reason) );
						avahiRunning = 0;
					}
				} else {
					ERROR( "Avahi: Client failure: %s (terminal)\n", avahi_strerror(reason));
					avahiRunning = 0;
				}
			}
			break;

		case AVAHI_CLIENT_S_COLLISION:
			DEBUG( "Avahi: Client is COLLISION\n" );
			/* Let's drop our registered services. When the server is back
			 * in AVAHI_SERVER_RUNNING state we will register them
			 * again with the new host name. */
			if (avahiGroup) {
				DEBUG( "Avahi: Resetting group\n" );
				avahi_entry_group_reset(avahiGroup);
			}
			
		case AVAHI_CLIENT_S_REGISTERING:
			DEBUG( "Avahi: Client is REGISTERING\n" );
			/* The server records are now being established. This
			 * might be caused by a host name change. We need to wait
			 * for our own records to register until the host name is
			 * properly esatblished. */
			
			if (avahiGroup) {
				DEBUG( "Avahi: Resetting group\n" );
				avahi_entry_group_reset(avahiGroup);
			}
			
			break;

		case AVAHI_CLIENT_CONNECTING:
			DEBUG( "Avahi: Client is CONNECTING\n" );
			;
	}
}

static int avahiFdset( fd_set* rfds, fd_set* wfds, fd_set* efds )
{
	AvahiWatch* w;
	int maxfd = -1;
	if( !avahiRunning )
		return maxfd;
	for( w = avahiWatchList; w != NULL; w = w->next ) {
		if( w->requestedEvent & AVAHI_WATCH_IN ) {
			FD_SET( w->fd, rfds );
		} 
		if( w->requestedEvent & AVAHI_WATCH_OUT ) {
			FD_SET( w->fd, wfds );
		}
		if( w->requestedEvent & AVAHI_WATCH_ERR ) {
			FD_SET( w->fd, efds );
		}
		if( w->requestedEvent & AVAHI_WATCH_HUP ) {
			ERROR( "Avahi: No support for HUP events! (ignoring)\n" );
		}

		if( w->fd > maxfd )
			maxfd = w->fd;
	}
	return maxfd; 
}

static int avahiFdconsume( int fdCount, fd_set* rfds, fd_set* wfds, fd_set* efds )
{
	int retval = fdCount;
	AvahiTimeout* t;
	AvahiWatch* w = avahiWatchList;

	while( w != NULL && retval > 0 ) {
		AvahiWatch* current = w;
		current->observedEvent = 0;
		if( FD_ISSET( current->fd, rfds ) ) {
			current->observedEvent |= AVAHI_WATCH_IN;
			FD_CLR( current->fd, rfds );
			retval--;
		}
		if( FD_ISSET( current->fd, wfds ) ) {
			current->observedEvent |= AVAHI_WATCH_OUT;
			FD_CLR( current->fd, wfds );
			retval--;
		}
		if( FD_ISSET( current->fd, efds ) ) {
			current->observedEvent |= AVAHI_WATCH_ERR;
			FD_CLR( current->fd, efds );
			retval--;
		}

		/* Advance to the next one right now, in case the callback
		 * removes itself
		 */
		w = w->next;

		if( current->observedEvent && avahiRunning ) {
			current->callback( current, current->fd,
					current->observedEvent, current->userdata );
		}
	}

	t = avahiTimeoutList;
	while( t != NULL && avahiRunning ) {
		AvahiTimeout* current = t;

		/* Advance to the next one right now, in case the callback
		 * removes itself
		 */
		t = t->next;
		avahiCheckExpiry( current );
	}

	return retval;
}

static void init_avahi(const char *serviceName)
{
	int error;
	DEBUG( "Avahi: Initializing interface\n" );

	if( avahi_is_valid_service_name( serviceName ) ) {
		avahiName = avahi_strdup( serviceName );
	} else {
		ERROR( "Invalid zeroconf_name \"%s\", defaulting to \"%s\" instead.\n", serviceName, SERVICE_NAME );
		avahiName = avahi_strdup( SERVICE_NAME );
	}

	avahiRunning = 1;

	avahiPoll.userdata = NULL;
	avahiPoll.watch_new = avahiWatchNew;
	avahiPoll.watch_update = avahiWatchUpdate;
	avahiPoll.watch_get_events = avahiWatchGetEvents;
	avahiPoll.watch_free = avahiWatchFree;
	avahiPoll.timeout_new = avahiTimeoutNew;
	avahiPoll.timeout_update = avahiTimeoutUpdate;
	avahiPoll.timeout_free = avahiTimeoutFree;

	avahiClient = avahi_client_new( &avahiPoll, AVAHI_CLIENT_NO_FAIL,
			avahiClientCallback, NULL, &error );

	if( !avahiClient ) {
		ERROR( "Avahi: Failed to create client: %s\n", avahi_strerror(error) );
		goto fail;
	}

	avahiIo.fdset = avahiFdset;
	avahiIo.consume = avahiFdconsume;
	registerIO( &avahiIo );

	return;

fail:
	finishZeroconf();
}
#else  /* !HAVE_AVAHI */
static void init_avahi(const char *serviceName) { }
#endif /* HAVE_AVAHI */

void initZeroconf(void)
{
	const char* serviceName = SERVICE_NAME;
	ConfigParam *param;

	param = getConfigParam(CONF_ZEROCONF_NAME);

	if (param && strlen(param->value) > 0)
		serviceName = param->value;
	init_avahi(serviceName);
}

void finishZeroconf(void)
{
#ifdef HAVE_AVAHI
	DEBUG( "Avahi: Shutting down interface\n" );
	deregisterIO( &avahiIo );

	if( avahiGroup ) {
		avahi_entry_group_free( avahiGroup );
		avahiGroup = NULL;
	}

	if( avahiClient ) {
		avahi_client_free( avahiClient );
		avahiClient = NULL;
	}

	avahi_free( avahiName );
	avahiName = NULL;
#endif // HAVE_AVAHI
}