File synergy-zeroconf-poc.diff of Package synergy

Overview Repositories Revisions Requests Users Attributes Meta

File synergy-zeroconf-poc.diff of Package synergy (Revision 50ab8f8b65af8e9d87dd8721d42e912f)

Currently displaying revision 50ab8f8b65af8e9d87dd8721d42e912f , Show latest

diff -x CVS -Nrup a/cmd/Makefile.am b/cmd/Makefile.am
--- a/cmd/Makefile.am	2004-05-27 06:53:48.000000000 +0200
+++ b/cmd/Makefile.am	2007-11-29 15:20:02.000000000 +0100
@@ -17,6 +17,7 @@ SUBDIRS =					\
 	launcher				\
 	synergyc				\
 	synergys				\
+	synergyd				\
 	$(NULL)
 
 EXTRA_DIST =				\
diff -x CVS -Nrup a/cmd/synergyd/Makefile.am b/cmd/synergyd/Makefile.am
--- a/cmd/synergyd/Makefile.am	1970-01-01 01:00:00.000000000 +0100
+++ b/cmd/synergyd/Makefile.am	2007-11-29 15:20:02.000000000 +0100
@@ -0,0 +1,75 @@
+# synergy -- mouse and keyboard sharing utility
+# Copyright (C) 2002 Chris Schoeneman
+# Copyright (C) 2007 Daniel Gollub
+# 
+# This package is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# found in the file COPYING that should have accompanied this file.
+# 
+# This package 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.
+
+## Process this file with automake to produce Makefile.in
+NULL =
+
+COMMON_SOURCE_FILES =					\
+	synergyd.cpp					\
+	synergyd.h					\
+	$(NULL)
+
+EXTRA_DIST =							\
+	$(NULL)
+
+MAINTAINERCLEANFILES =					\
+	Makefile.in							\
+	$(NULL)
+
+bin_PROGRAMS = synergyd
+if XWINDOWS
+synergyd_SOURCES =						\
+	$(COMMON_SOURCE_FILES)				\
+	$(XWINDOWS_SOURCE_FILES)			\
+	$(NULL)
+endif
+
+synergyd_LDFLAGS = 					\
+	$(AVAHI_LIBS)					\
+	$(LIBXML2_LIBS)					\
+	$(NULL)
+
+synergyd_CFLAGS = 					\
+	$(AVAHI_CFLAGS)					\
+	$(LIBXML2_CFLAGS)				\
+	$(NULL)
+
+synergyd_LDADD =								\
+	$(top_builddir)/lib/client/libclient.a		\
+	$(top_builddir)/lib/server/libserver.a		\
+	$(top_builddir)/lib/platform/libplatform.a	\
+	$(top_builddir)/lib/synergy/libsynergy.a	\
+	$(top_builddir)/lib/net/libnet.a			\
+	$(top_builddir)/lib/io/libio.a				\
+	$(top_builddir)/lib/mt/libmt.a				\
+	$(top_builddir)/lib/base/libbase.a			\
+	$(top_builddir)/lib/common/libcommon.a		\
+	$(top_builddir)/lib/arch/libarch.a			\
+	$(top_builddir)/lib/zeroconf/libzeroconf.a			\
+	$(NULL)
+INCLUDES =								\
+	-I$(top_srcdir)/lib/common			\
+	-I$(top_srcdir)/lib/arch			\
+	-I$(top_srcdir)/lib/base 			\
+	-I$(top_srcdir)/lib/mt	 			\
+	-I$(top_srcdir)/lib/io	 			\
+	-I$(top_srcdir)/lib/net	 			\
+	-I$(top_srcdir)/lib/synergy			\
+	-I$(top_srcdir)/lib/platform 		\
+	-I$(top_srcdir)/lib/server	 		\
+	-I$(top_srcdir)/lib/client	 		\
+	-I$(top_srcdir)/lib/zeroconf	 		\
+	$(NULL)
+
+autostartdir = $(sysconfdir)/xdg/autostart
+autostart_DATA = synergyd-autostart.desktop
diff -x CVS -Nrup a/cmd/synergyd/synergyd-autostart.desktop b/cmd/synergyd/synergyd-autostart.desktop
--- a/cmd/synergyd/synergyd-autostart.desktop	1970-01-01 01:00:00.000000000 +0100
+++ b/cmd/synergyd/synergyd-autostart.desktop	2007-11-29 15:20:02.000000000 +0100
@@ -0,0 +1,8 @@
+[Desktop Entry]
+Encoding=UTF-8
+Exec=synergyd
+Name=Synergy Session Daemon
+Terminal=false
+X-KDE-autostart-phase=2
+X-KDE-autostart-after=panel
+X-KDE-StartupNotify=false
diff -x CVS -Nrup a/cmd/synergyd/synergyd.cpp b/cmd/synergyd/synergyd.cpp
--- a/cmd/synergyd/synergyd.cpp	1970-01-01 01:00:00.000000000 +0100
+++ b/cmd/synergyd/synergyd.cpp	2007-11-29 15:20:02.000000000 +0100
@@ -0,0 +1,955 @@
+/*
+ * synergyd -- mouse and keyboard sharing utility
+ * Copyright (C) 2002 Chris Schoeneman
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#include <pthread.h>
+
+#include <string.h>
+
+#include "CArch.h"
+#include "XArch.h"
+#include "XSocket.h"
+#include "XScreen.h"
+
+#include "CArchMultithreadPosix.h"
+
+#include "ProtocolTypes.h"
+#include "Version.h"
+
+
+#include "CClient.h"
+#include "CServer.h"
+#include "CClientListener.h"
+#include "CClientProxy.h"
+
+#include "CPrimaryClient.h"
+
+#include "CConfigXml.h"
+#include "CScreen.h"
+#include "CSocketMultiplexer.h"
+#include "CTCPSocketFactory.h"
+#include "CEventQueue.h"
+#include "CFunctionEventJob.h"
+#include "CXWindowsScreen.h"
+#include "LogOutputters.h"
+
+#include "stdfstream.h"
+
+#include "CZeroConf.h"
+
+#define USR_CONFIG_NAME ".synergyd.conf"
+#define SYS_CONFIG_NAME "synergyd.conf"
+
+enum EServerState {
+	kUninitialized,
+	kInitializing,
+	kInitializingToStart,
+	kInitialized,
+	kStarting,
+	kStarted
+};
+
+static CZeroConf *zc = NULL;
+static CClient* s_client = NULL;
+static CScreen* s_screen = NULL;
+static bool isClient = false; 
+static bool connected = false;
+static bool serviceRegistered = false;
+
+
+static EServerState s_serverState = kUninitialized;
+static CServer*	s_server = NULL;
+static CPrimaryClient* s_primaryClient       = NULL;
+static CClientListener* s_listener            = NULL;
+static CEvent::Type s_forceReconnectEvent = CEvent::kUnknown;
+static CEvent::Type s_newClientEvent = CEvent::kUnknown;
+static CEvent::Type s_startServerEvent = CEvent::kUnknown;
+static CEvent::Type s_serverStartEvent = CEvent::kUnknown;
+static CEvent::Type s_serverStoppedEvent = CEvent::kUnknown;
+static bool s_suspended = false;
+//static CEvent::Type s_reloadConfigEvent   = CEvent::kUnknown;
+//static CEventQueueTimer* s_timer = NULL;
+
+static void handleSuspend(const CEvent& event, void*);
+static void handleResume(const CEvent& event, void*);
+
+
+
+class CArgs {
+public:
+	CArgs() :
+		m_pname(NULL),
+		m_backend(false),
+		m_restartable(true),
+		m_daemon(true),
+		m_configFile(),
+		m_logFilter(NULL),
+		m_display(NULL),
+		m_serverAddress(NULL),
+		m_synergyAddress(NULL),
+		m_config(NULL)
+		{ s_instance = this; }
+	~CArgs() { s_instance = NULL; }
+
+public:
+	static CArgs*		s_instance;
+	const char* 		m_pname;
+	bool				m_backend;
+	bool				m_restartable;
+	bool				m_daemon;
+	CString		 		m_configFile;
+	const char* 		m_logFilter;
+	const char*			m_display;
+	CString 			m_name;
+	CNetworkAddress* 	m_serverAddress;
+	CNetworkAddress*	m_synergyAddress;
+	CConfigXml*			m_config;
+};
+
+#define ARG CArgs::s_instance
+CArgs *CArgs::s_instance = NULL;
+
+/// Events
+CEvent::Type getForceReconnectEvent()
+{
+	return CEvent::registerTypeOnce(s_forceReconnectEvent, "forceReconnect");
+}
+
+CEvent::Type getNewClientEvent()
+{
+	return CEvent::registerTypeOnce(s_newClientEvent, "newClientEvent");
+}
+
+CEvent::Type getStartServerEvent()
+{
+	return CEvent::registerTypeOnce(s_startServerEvent, "startServerEvent");
+}
+
+CEvent::Type getServerStartedEvent()
+{
+	return CEvent::registerTypeOnce(s_serverStartEvent, "serverStartedEvent");
+}
+
+CEvent::Type getServerStoppedEvent()
+{
+	return CEvent::registerTypeOnce(s_serverStoppedEvent, "serverStoppedEvent");
+}
+
+/// Client
+static void handleClientConnected(const CEvent&, void*)
+{
+	LOG((CLOG_NOTE "connected to server"));
+}
+
+static void handleClientFailed(const CEvent& e, void*)
+{
+	CClient::CFailInfo* info =
+		reinterpret_cast<CClient::CFailInfo*>(e.getData());
+
+	if (!ARG->m_restartable || !info->m_retry) {
+		LOG((CLOG_ERR "failed to connect to server: %s", info->m_what));
+		EVENTQUEUE->addEvent(CEvent(CEvent::kQuit));
+	}
+	else {
+		LOG((CLOG_WARN "failed to connect to server: %s", info->m_what));
+	}
+
+	connected = false;
+}
+
+static void closeClient(CClient* client)
+{
+	if (client == NULL) {
+		return;
+	}
+
+	EVENTQUEUE->removeHandler(CClient::getConnectedEvent(), client);
+	EVENTQUEUE->removeHandler(CClient::getConnectionFailedEvent(), client);
+	EVENTQUEUE->removeHandler(CClient::getDisconnectedEvent(), client);
+	delete client;
+}
+
+
+static void closeClientScreen(CScreen* screen)
+{
+	if (screen != NULL) {
+		EVENTQUEUE->removeHandler(IScreen::getErrorEvent(),
+							screen->getEventTarget());
+		delete screen;
+	}
+}
+
+
+
+static void stopClient()
+{
+	closeClient(s_client);
+	closeClientScreen(s_screen);
+	s_client       = NULL;
+	s_screen = NULL;
+	connected = false;
+}
+
+static void handleClientDisconnected(const CEvent&, void*)
+{
+	LOG((CLOG_NOTE "disconnected from server"));
+	if (!ARG->m_restartable) {
+		EVENTQUEUE->addEvent(CEvent(CEvent::kQuit));
+	}
+
+	stopClient();
+
+	// Trigger an event to start the server again ...
+	EVENTQUEUE->addEvent(CEvent(getStartServerEvent(), IEventQueue::getSystemTarget()));
+}
+
+static CClient *openClient(const CString& name, const CNetworkAddress& address, CScreen* screen)
+{
+	CClient* client = new CClient(name, address,
+					new CTCPSocketFactory, NULL, screen);
+
+	EVENTQUEUE->adoptHandler(CClient::getConnectedEvent(),
+				client->getEventTarget(),
+				new CFunctionEventJob(handleClientConnected));
+	EVENTQUEUE->adoptHandler(CClient::getConnectionFailedEvent(),
+				client->getEventTarget(),
+				new CFunctionEventJob(handleClientFailed));
+	EVENTQUEUE->adoptHandler(CClient::getDisconnectedEvent(),
+				client->getEventTarget(),
+					new CFunctionEventJob(handleClientDisconnected));
+
+	return client;
+}
+
+static void version()
+{
+	LOG((CLOG_PRINT "%s %s, protocol version %d.%d\n%s",
+							ARG->m_pname,
+							kVersion,
+							kProtocolMajorVersion,
+							kProtocolMinorVersion,
+							kCopyright));
+}
+
+static void handleScreenError(const CEvent&, void*)
+{
+	LOG((CLOG_CRIT "error on screen"));
+	EVENTQUEUE->addEvent(CEvent(CEvent::kQuit));
+}
+
+static CScreen* openClientScreen()
+{
+	CScreen* screen = new CScreen(new CXWindowsScreen(NULL, false));
+
+	EVENTQUEUE->adoptHandler(IScreen::getErrorEvent(),
+			screen->getEventTarget(),
+			new CFunctionEventJob(
+				&handleScreenError));
+
+	return screen;
+}
+
+static bool startClient()
+{
+	if (s_screen == NULL)
+		s_screen = openClientScreen();
+
+	if (s_client == NULL)
+		s_client = openClient(ARG->m_name, *ARG->m_serverAddress, s_screen);
+
+	s_client->connect();
+
+	LOG((CLOG_DEBUG " [%u] Started Client", pthread_self() ));
+
+	return true;
+}
+
+static void help()
+{
+#if WINAPI_XWINDOWS
+#  define USAGE_DISPLAY_ARG		\
+" [--display <display>]"
+#  define USAGE_DISPLAY_INFO	\
+"      --display <display>  connect to the X server at <display>\n"
+#else
+#  define USAGE_DISPLAY_ARG
+#  define USAGE_DISPLAY_INFO
+#endif
+
+	LOG((CLOG_PRINT
+"Usage: %s"
+" [--daemon|--no-daemon]"
+" [--debug <level>]"
+USAGE_DISPLAY_ARG
+" [--restart|--no-restart]"
+"\n\n"
+"Start the synergy mouse/keyboard sharing server.\n"
+"\n"
+"  -d, --debug <level>      filter out log messages with priorty below level.\n"
+"                           level may be: FATAL, ERROR, WARNING, NOTE, INFO,\n"
+"                           DEBUG, DEBUG1, DEBUG2.\n"
+USAGE_DISPLAY_INFO
+"  -f, --no-daemon          run the client in the foreground.\n"
+"*     --daemon             run the client as a daemon.\n"
+"  -1, --no-restart         do not try to restart the client if it fails for\n"
+"                           some reason.\n"
+"*     --restart            restart the client automatically if it fails.\n"
+"  -h, --help               display this help and exit.\n"
+"      --version            display version information and exit.\n"
+"\n"
+"* marks defaults.\n"
+"\n"
+"Where log messages go depends on the platform and whether or not the\n"
+"client is running as a daemon.",
+								ARG->m_pname ));
+
+}
+
+#define BYE "\nTry `%s --help' for more information."
+
+static bool isArg(int argi, int argc, const char* const* argv,
+				const char* name1, const char* name2,
+				int minRequiredParameters = 0)
+{
+	if ((name1 != NULL && strcmp(argv[argi], name1) == 0) ||
+		(name2 != NULL && strcmp(argv[argi], name2) == 0)) {
+		// match.  check args left.
+		if (argi + minRequiredParameters >= argc) {
+			LOG((CLOG_PRINT "%s: missing arguments for `%s'" BYE,
+								ARG->m_pname, argv[argi], ARG->m_pname));
+			exit(kExitArgs);
+		}
+		return true;
+	}
+
+	// no match
+	return false;
+}
+
+static void parse(int argc, const char* const* argv)
+{
+	assert(ARG->m_pname != NULL);
+	assert(argv         != NULL);
+	assert(argc         >= 1);
+
+	// parse options
+	int i;
+	for (i = 1; i < argc; ++i) {
+		if (isArg(i, argc, argv, "-d", "--debug", 1)) {
+			// change logging level
+			ARG->m_logFilter = argv[++i];
+		}
+
+		/*
+		else if (isArg(i, argc, argv, "-n", "--name", 1)) {
+			// save screen name
+			ARG->m_name = argv[++i];
+		}
+
+		else if (isArg(i, argc, argv, "-a", "--address", 1)) {
+			// save listen address
+			try {
+				*ARG->m_synergyAddress = CNetworkAddress(argv[i + 1],
+														kDefaultPort);
+				ARG->m_synergyAddress->resolve();
+			}
+			catch (XSocketAddress& e) {
+				LOG((CLOG_PRINT "%s: %s" BYE,
+								ARG->m_pname, e.what(), ARG->m_pname));
+				exit(kExitArgs);
+			}
+			++i;
+		}
+		*/
+
+		else if (isArg(i, argc, argv, "-f", "--no-daemon")) {
+			// not a daemon
+			ARG->m_daemon = false;
+		}
+
+		else if (isArg(i, argc, argv, NULL, "--daemon")) {
+			// daemonize
+			ARG->m_daemon = true;
+		}
+
+#if WINAPI_XWINDOWS
+		else if (isArg(i, argc, argv, "-display", "--display", 1)) {
+			// use alternative display
+			ARG->m_display = argv[++i];
+		}
+#endif
+
+		else if (isArg(i, argc, argv, "-1", "--no-restart")) {
+			// don't try to restart
+			ARG->m_restartable = false;
+		}
+
+		else if (isArg(i, argc, argv, NULL, "--restart")) {
+			// try to restart
+			ARG->m_restartable = true;
+		}
+
+		else if (isArg(i, argc, argv, "-z", NULL)) {
+			ARG->m_backend = true;
+		}
+
+		else if (isArg(i, argc, argv, "-h", "--help")) {
+			help();
+			exit(kExitSuccess);
+		}
+
+		else if (isArg(i, argc, argv, NULL, "--version")) {
+			version();
+			exit(kExitSuccess);
+		}
+
+		else if (isArg(i, argc, argv, "--", NULL)) {
+			// remaining arguments are not options
+			++i;
+			break;
+		}
+
+		else if (argv[i][0] == '-') {
+			LOG((CLOG_PRINT "%s: unrecognized option `%s'" BYE,
+								ARG->m_pname, argv[i], ARG->m_pname));
+			exit(kExitArgs);
+		}
+
+		else {
+			// this and remaining arguments are not options
+			break;
+		}
+	}
+
+	// increase default filter level for daemon.  the user must
+	// explicitly request another level for a daemon.
+	if (ARG->m_daemon && ARG->m_logFilter == NULL) {
+		ARG->m_logFilter = "NOTE";
+	}
+
+	// set log filter
+	if (!CLOG->setFilter(ARG->m_logFilter)) {
+		LOG((CLOG_PRINT "%s: unrecognized log level `%s'" BYE,
+								ARG->m_pname, ARG->m_logFilter, ARG->m_pname));
+		exit(kExitArgs);
+	}
+
+	// identify system
+	LOG((CLOG_INFO "Synergy client %s on %s", kVersion, ARCH->getOSName().c_str()));
+}
+
+// Server
+static CScreen* openServerScreen()
+{
+	CScreen* screen = new CScreen(new CXWindowsScreen(ARG->m_display, true));
+
+	EVENTQUEUE->adoptHandler(IScreen::getErrorEvent(),
+							screen->getEventTarget(),
+							new CFunctionEventJob(
+								&handleScreenError));
+	EVENTQUEUE->adoptHandler(IScreen::getSuspendEvent(),
+							screen->getEventTarget(),
+							new CFunctionEventJob(
+								&handleSuspend));
+	EVENTQUEUE->adoptHandler(IScreen::getResumeEvent(),
+							screen->getEventTarget(),
+							new CFunctionEventJob(
+								&handleResume));
+
+	return screen;
+}
+
+static void closeServerScreen(CScreen* screen)
+{
+	if (screen != NULL) {
+		EVENTQUEUE->removeHandler(IScreen::getErrorEvent(),
+							screen->getEventTarget());
+		EVENTQUEUE->removeHandler(IScreen::getSuspendEvent(),
+							screen->getEventTarget());
+		EVENTQUEUE->removeHandler(IScreen::getResumeEvent(),
+							screen->getEventTarget());
+		delete screen;
+	}
+}
+
+static CPrimaryClient *openPrimaryClient(const CString& name, CScreen* screen)
+{
+	LOG((CLOG_DEBUG1 "creating primary screen"));
+	return new CPrimaryClient(name, screen);
+}
+
+static void closePrimaryClient(CPrimaryClient* primaryClient)
+{
+	delete primaryClient;
+}
+
+static void handleNoClients(const CEvent&, void*)
+{
+	// NOOP
+}
+
+static void handleClientsDisconnected(const CEvent&, void*)
+{
+	EVENTQUEUE->addEvent(CEvent(CEvent::kQuit));
+}
+
+static bool initServer()
+{
+	// skip if already initialized or initializing
+	if (s_serverState != kUninitialized) {
+		return true;
+	}
+
+	CScreen* serverScreen         = NULL;
+	CPrimaryClient* primaryClient = NULL;
+	try {
+		CString name    = ARG->m_config->getCanonicalName(ARG->m_name);
+		serverScreen    = openServerScreen();
+		primaryClient   = openPrimaryClient(name, serverScreen);
+		s_screen  = serverScreen;
+		s_primaryClient = primaryClient;
+		s_serverState   = kInitialized;
+		return true;
+	}
+	catch (XScreenUnavailable& e) {
+		LOG((CLOG_WARN "cannot open primary screen: %s", e.what()));
+		closePrimaryClient(primaryClient);
+		closeServerScreen(serverScreen);
+	}
+	catch (XScreenOpenFailure& e) {
+		LOG((CLOG_CRIT "cannot open primary screen: %s", e.what()));
+		closePrimaryClient(primaryClient);
+		closeServerScreen(serverScreen);
+		return false;
+	}
+	catch (XBase& e) {
+		LOG((CLOG_CRIT "failed to start server: %s", e.what()));
+		closePrimaryClient(primaryClient);
+		closeServerScreen(serverScreen);
+		return false;
+	}
+	
+	return false;
+}
+
+static void serverHandleClientConnected(const CEvent&, void* vlistener)
+{
+	LOG((CLOG_DEBUG "[%u] %s(%p)", pthread_self(), __func__, vlistener));
+
+	CClientListener* listener = reinterpret_cast<CClientListener*>(vlistener);
+	CClientProxy* client = listener->getNextClient();
+
+	if (client != NULL)
+		s_server->adoptClient(client);
+}
+
+
+
+static CClientListener *openClientListener(const CNetworkAddress& address)
+{
+	assert(address.isValid());
+
+	CClientListener* listen =
+		new CClientListener(address, new CTCPSocketFactory, NULL);
+	EVENTQUEUE->adoptHandler(CClientListener::getConnectedEvent(), listen,
+							new CFunctionEventJob(
+								&serverHandleClientConnected, listen));
+	return listen;
+}
+
+static void closeClientListener(CClientListener* listen)
+{
+	LOG((CLOG_DEBUG "[%u] %s(%p)", pthread_self(), __func__, listen));
+
+	if (listen != NULL) {
+		EVENTQUEUE->removeHandler(CClientListener::getConnectedEvent(), listen);
+		delete listen;
+	}
+}
+
+static CServer *openServer(const CConfigXml& config, CPrimaryClient* primaryClient)
+{
+	LOG((CLOG_DEBUG "[%u] %s(%p)", pthread_self(), __func__, primaryClient));
+
+	CServer* server = new CServer(config, primaryClient);
+	EVENTQUEUE->adoptHandler(CServer::getDisconnectedEvent(), server,
+						new CFunctionEventJob(handleNoClients));
+	return server;
+}
+
+static void closeServer(CServer* server)
+{
+	LOG((CLOG_DEBUG "[%u] %s(%p)", pthread_self(), __func__, server));
+
+	if (server == NULL) {
+		return;
+	}
+
+	// tell all clients to disconnect
+	server->disconnect();
+
+	// wait for clients to disconnect for up to timeout seconds
+	double timeout = 3.0;
+	CEventQueueTimer* timer = EVENTQUEUE->newOneShotTimer(timeout, NULL);
+	EVENTQUEUE->adoptHandler(CEvent::kTimer, timer,
+						new CFunctionEventJob(handleClientsDisconnected));
+	EVENTQUEUE->adoptHandler(CServer::getDisconnectedEvent(), server,
+						new CFunctionEventJob(handleClientsDisconnected));
+	CEvent event;
+	EVENTQUEUE->getEvent(event);
+	while (event.getType() != CEvent::kQuit) {
+		EVENTQUEUE->dispatchEvent(event);
+		CEvent::deleteData(event);
+		EVENTQUEUE->getEvent(event);
+	}
+	EVENTQUEUE->removeHandler(CEvent::kTimer, timer);
+	EVENTQUEUE->deleteTimer(timer);
+	EVENTQUEUE->removeHandler(CServer::getDisconnectedEvent(), server);
+
+	// done with server
+	delete server;
+}
+
+static bool startServer()
+{
+	LOG((CLOG_DEBUG "[%u] %s", pthread_self(), __func__));
+
+	// create the event queue
+
+	// if configuration has no screens then add this system
+	// as the default
+	if (ARG->m_config->begin() == ARG->m_config->end()) {
+		ARG->m_config->addScreen(ARG->m_name);
+	}
+
+	// set the contact address, if provided, in the config.
+	// otherwise, if the config doesn't have an address, use
+	// the default.
+	if (ARG->m_synergyAddress->isValid()) {
+		ARG->m_config->setSynergyAddress(*ARG->m_synergyAddress);
+	} else if (!ARG->m_config->getSynergyAddress().isValid()) {
+		ARG->m_config->setSynergyAddress( CNetworkAddress(kDefaultPort));
+	}
+
+	// canonicalize the primary screen name
+	CString primaryName = ARG->m_config->getCanonicalName(ARG->m_name);
+	if (primaryName.empty()) {
+		LOG((CLOG_CRIT "unknown screen name `%s'", ARG->m_name.c_str()));
+		return kExitFailed;
+	}
+
+	// skip if already started or starting
+	if (s_serverState == kStarting || s_serverState == kStarted) {
+		return true;
+	}
+
+	// initialize if necessary
+	if (s_serverState != kInitialized) {
+		if (!initServer()) {
+			// hard initialization failure
+			return false;
+		}
+		if (s_serverState == kInitializing) {
+			// not ready to start
+			s_serverState = kInitializingToStart;
+			return true;
+		}
+		assert(s_serverState == kInitialized);
+	}
+
+	double retryTime;
+	CClientListener* listener = NULL;
+	try {
+		listener   = openClientListener(ARG->m_config->getSynergyAddress());
+		s_server   = openServer(*ARG->m_config, s_primaryClient);
+		s_listener = listener;
+		LOG(( CLOG_DEBUG "started server: %u", pthread_self() ));
+		s_serverState = kStarted;
+		EVENTQUEUE->addEvent(CEvent(getServerStartedEvent(), IEventQueue::getSystemTarget()));
+		return true;
+	}
+	catch (XSocketAddressInUse& e) {
+		LOG((CLOG_WARN "cannot listen for clients: %s", e.what()));
+		closeClientListener(listener);
+		retryTime = 10.0;
+	}
+	catch (XBase& e) {
+		LOG((CLOG_CRIT "failed to start server: %s", e.what()));
+		closeClientListener(listener);
+		return false;
+	}
+
+	return false;
+}
+
+static void stopServer()
+{
+	LOG((CLOG_DEBUG "[%u] %s", pthread_self(), __func__));
+
+	if (s_serverState == kStarted) {
+		closeClientListener(s_listener);
+		closeServer(s_server);
+		s_server      = NULL;
+		s_listener    = NULL;
+		s_serverState = kInitialized;
+	}
+	else if (s_serverState == kStarting) {
+		s_serverState = kInitialized;
+	}
+	assert(s_server == NULL);
+	assert(s_listener == NULL);
+	EVENTQUEUE->addEvent(CEvent(getServerStoppedEvent(), IEventQueue::getSystemTarget()));
+}
+
+static void cleanupServer()
+{
+	LOG((CLOG_DEBUG "[%u] %s", pthread_self(), __func__));
+	stopServer();
+	if (s_serverState == kInitialized) {
+		closePrimaryClient(s_primaryClient);
+		closeServerScreen(s_screen);
+		s_primaryClient = NULL;
+		s_screen  = NULL;
+		s_serverState   = kUninitialized;
+	}
+	else if (s_serverState == kInitializing ||
+			s_serverState == kInitializingToStart) {
+		s_serverState = kUninitialized;
+	}
+	assert(s_primaryClient == NULL);
+	assert(s_screen == NULL);
+	assert(s_serverState == kUninitialized);
+}
+
+static void handleSuspend(const CEvent&, void*)
+{
+	if (!s_suspended) {
+		LOG((CLOG_INFO "suspend"));
+		stopServer();
+		s_suspended = true;
+	}
+}
+
+static void handleResume(const CEvent&, void*)
+{
+	if (s_suspended) {
+		LOG((CLOG_INFO "resume"));
+		startServer();
+		s_suspended = false;
+	}
+}
+
+
+
+/*
+static void forceReconnect(const CEvent&, void*)
+{
+	if (s_server != NULL) {
+		s_server->disconnect();
+	}
+}
+*/
+
+static void handleNewClient(const CEvent &event, void *data)
+{
+
+	LOG((CLOG_DEBUG "[%u] %s(%i, %p)", pthread_self(), __func__, event.getType(), data));
+
+	if (s_serverState == kStarting || s_serverState == kStarted)
+		cleanupServer();
+
+	startClient();
+}
+
+static bool loadConfig(const CString& pathname)
+{
+	// load configuration
+	LOG((CLOG_DEBUG "opening configuration \"%s\"", pathname.c_str()));
+
+	if (!ARG->m_config->load( pathname ))
+		return false;
+
+	LOG((CLOG_DEBUG "configuration read successfully"));
+	return true;
+}
+
+static void loadConfig()
+{
+	bool loaded = false;
+
+	// load the config file, if specified
+	if (!ARG->m_configFile.empty()) {
+		loaded = loadConfig(ARG->m_configFile);
+	}
+
+	// load the default configuration if no explicit file given
+	else {
+		// get the user's home directory
+		CString path = ARCH->getUserDirectory();
+		if (!path.empty()) {
+			// complete path
+			path = ARCH->concatPath(path, USR_CONFIG_NAME);
+
+			// now try loading the user's configuration
+			if (loadConfig(path)) {
+				loaded            = true;
+				ARG->m_configFile = path;
+			}
+		}
+		if (!loaded) {
+			// try the system-wide config file
+			path = ARCH->getSystemDirectory();
+			if (!path.empty()) {
+				path = ARCH->concatPath(path, SYS_CONFIG_NAME);
+				if (loadConfig(path)) {
+					loaded            = true;
+					ARG->m_configFile = path;
+				}
+			}
+		}
+	}
+
+	if (!loaded) {
+		LOG((CLOG_PRINT "%s: no configuration available", ARG->m_pname));
+		exit(kExitConfig);
+	}
+}
+
+static void handleStartServer(const CEvent&, void*)
+{
+	startServer();
+}
+
+static void handleServerStarted(const CEvent &event, void *data)
+{
+	// If the server got already registered once, we reannounce
+	// the service again, to trigger the clients.
+	if (serviceRegistered)
+		zc->unregisterService();
+
+	zc->registerService();
+	serviceRegistered = true;
+}
+
+static void handleServerStopped(const CEvent &event, void *data)
+{
+	zc->unregisterService();
+	serviceRegistered = false;
+}
+
+//// Zeroconf
+void probeClient(const CNetworkAddress &address, const CString &servicename)
+{
+	LOG(( CLOG_DEBUG "[%u]", pthread_self()));
+
+	if (connected)
+		return;
+
+	// Check config for valid/trusted Synergy Host.
+	if (!ARG->m_config->isHost(servicename)) {
+		LOG(( CLOG_WARN "%s - \'%s\' is not in the list -  Sorry.", __func__, servicename.c_str()));
+
+		return;
+	}
+
+	connected = true;
+
+	LOG(( CLOG_DEBUG "%s - \'%s\' in the map. Intersting!", __func__, address.getHostname().c_str()));
+
+	*ARG->m_serverAddress = address;
+	ARG->m_serverAddress->resolve();
+
+	isClient = true;
+
+	EVENTQUEUE->addEvent(CEvent(getNewClientEvent(), IEventQueue::getSystemTarget()));
+}
+
+void initialBrowseFinished()
+{
+	LOG(( CLOG_DEBUG "[%u]", pthread_self()));
+
+	if (connected)
+		return;
+
+	EVENTQUEUE->addEvent(CEvent(getStartServerEvent(), IEventQueue::getSystemTarget()));
+}
+
+int main(int argc, char **argv)
+{
+	CArgs args;
+	CArch arch;
+
+	ARG->m_serverAddress = new CNetworkAddress;
+	ARG->m_synergyAddress = new CNetworkAddress;
+	ARG->m_config         = new CConfigXml;
+	ARG->m_pname         = ARCH->getBasename(argv[0]);
+
+	parse(argc, argv);
+
+	loadConfig();
+
+	CSocketMultiplexer multiplexer;
+
+	// create the event queue
+	CEventQueue eventQueue;
+
+	zc = new CZeroConf();
+	if (!zc) {
+		LOG(( CLOG_ERR "Can't initiailze Zerconf component." ));
+		return -1;
+	}
+
+	// register Zeroconf Callbacks 
+	zc->setNewServiceCb(probeClient);
+	zc->setBrowseAllForNowCb(initialBrowseFinished);
+
+	// start Zeroconf Service Discovery for Synergy instances.
+	zc->startDiscover();
+
+	ARG->m_name = zc->getHostname(); 
+	LOG(( CLOG_NOTE "Multicast DNS Hostname: %s", zc->getHostname().c_str()));
+	LOG(( CLOG_NOTE "Zeroconf Service: %s", zc->getServicename().c_str()));
+
+	// FIXME: This event loop isn't likely the smartest choice for starting/stopping/connecting/... 
+	// client/server processes.
+	EVENTQUEUE->adoptHandler(getServerStartedEvent(), IEventQueue::getSystemTarget(), new CFunctionEventJob(&handleServerStarted));
+
+	EVENTQUEUE->adoptHandler(getServerStoppedEvent(), IEventQueue::getSystemTarget(), new CFunctionEventJob(&handleServerStopped));
+
+	EVENTQUEUE->adoptHandler(getStartServerEvent(),	IEventQueue::getSystemTarget(),	new CFunctionEventJob(&handleStartServer));
+	EVENTQUEUE->adoptHandler(getNewClientEvent(), IEventQueue::getSystemTarget(), new CFunctionEventJob(&handleNewClient));
+
+	CEvent event;
+	EVENTQUEUE->getEvent(event);
+
+	while (event.getType() != CEvent::kQuit) {
+		EVENTQUEUE->dispatchEvent(event);
+		CEvent::deleteData(event);
+		EVENTQUEUE->getEvent(event);
+	}
+
+	EVENTQUEUE->removeHandler(getNewClientEvent(), IEventQueue::getSystemTarget());
+	EVENTQUEUE->removeHandler(getStartServerEvent(), IEventQueue::getSystemTarget());
+	EVENTQUEUE->removeHandler(getServerStoppedEvent(), IEventQueue::getSystemTarget());
+	EVENTQUEUE->removeHandler(getServerStartedEvent(), IEventQueue::getSystemTarget());
+
+	zc->stopDiscover();
+
+	delete zc;
+	delete ARG->m_config;
+	delete ARG->m_synergyAddress;
+
+	return 0;
+}
+
diff -x CVS -Nrup a/cmd/synergyd/synergyd.example.conf b/cmd/synergyd/synergyd.example.conf
--- a/cmd/synergyd/synergyd.example.conf	1970-01-01 01:00:00.000000000 +0100
+++ b/cmd/synergyd/synergyd.example.conf	2007-11-29 15:25:34.000000000 +0100
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<synergy>
+  <Environments>
+
+   <Environment>
+     <Role>CLIENT</Role>
+     <Screens>
+       <Host>dani@marvin.local</Host>
+     </Screens>
+   </Environment>
+
+   <Environment>
+     <Role>CLIENT</Role>
+     <Screens>
+       <Host>dani@foobar.local</Host>
+     </Screens>
+   </Environment>
+
+   <Environment>
+     <Role>SERVER</Role>
+     <Screens>
+       <Host Left="linux-9rbi.local">sugga.local</Host>
+       <Host Right="sugga.local">linux-9rbi.local</Host>
+     </Screens>
+   </Environment>
+
+ </Environments>
+</synergy>
diff -x CVS -Nrup a/configure.in b/configure.in
--- a/configure.in	2007-06-17 19:31:08.000000000 +0200
+++ b/configure.in	2007-11-29 15:22:23.000000000 +0100
@@ -52,6 +52,7 @@ AM_CONDITIONAL(MSWINDOWS, test x$acx_hos
 AM_CONDITIONAL(CARBON, test x$acx_host_winapi = xCARBON)
 AM_CONDITIONAL(XWINDOWS, test x$acx_host_winapi = xXWINDOWS)
 
+
 dnl checks for programs
 AC_PROG_CC
 AC_PROG_CXX
@@ -80,6 +81,12 @@ else
 	CXXFLAGS="$CXXFLAGS -DNDEBUG"
 fi
 
+dnl enable code coverrage/profiling
+AC_ARG_ENABLE([profiling], [  --enable-profiling          enable profiling])
+if test "x$enable_profiling" == xyes; then
+	CXXFLAGS="$CXXFLAGS -fprofile-arcs -ftest-coverage -O0"
+fi
+
 dnl check compiler
 ACX_CHECK_CXX
 
@@ -241,6 +248,22 @@ dnl enable maximum compiler warnings and
 ACX_CXX_WARNINGS
 ACX_CXX_WARNINGS_ARE_ERRORS
 
+dnl avahi check
+PKG_CHECK_MODULES([AVAHI], [avahi-client], [AC_DEFINE([HAVE_AVAHI], 1, [Avahi Zeroconf support])])
+AC_SUBST(AVAHI_CFLAGS)	
+AC_SUBST(AVAHI_LIBS)	
+AM_CONDITIONAL(AVAHI, test "x" != "x$AVAHI_LIBS")
+
+dnl libxml2 check
+PKG_CHECK_MODULES([LIBXML2], [libxml-2.0], [AC_DEFINE([HAVE_LIBXML2], 1, [libxml2 support])])
+AC_SUBST(LIBXML2_CFLAGS)	
+AC_SUBST(LIBXML2_LIBS)	
+
+dnl "check" check
+PKG_CHECK_MODULES([CHECK], [check])
+AC_SUBST(CHECK_CFLAGS)	
+AC_SUBST(CHECK_LIBS)	
+
 dnl adjust compiler and linker variables
 CXXFLAGS="$CXXFLAGS $SYNERGY_CXXFLAGS $ARCH_CFLAGS"
 OBJCXXFLAGS="$OBJCXXFLAGS $CXXFLAGS $ARCH_CFLAGS"
@@ -267,6 +290,7 @@ Makefile
 cmd/Makefile
 cmd/launcher/Makefile
 cmd/synergyc/Makefile
+cmd/synergyd/Makefile
 cmd/synergys/Makefile
 dist/Makefile
 dist/nullsoft/Makefile
@@ -285,4 +309,6 @@ lib/net/Makefile
 lib/platform/Makefile
 lib/server/Makefile
 lib/synergy/Makefile
+lib/zeroconf/Makefile
+tests/Makefile
 ])
diff -x CVS -Nrup a/lib/arch/CArchDaemonUnix.cpp b/lib/arch/CArchDaemonUnix.cpp
--- a/lib/arch/CArchDaemonUnix.cpp	2004-05-27 06:53:49.000000000 +0200
+++ b/lib/arch/CArchDaemonUnix.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -15,6 +15,7 @@
 #include "CArchDaemonUnix.h"
 #include "XArchUnix.h"
 #include <unistd.h>
+#include <stdlib.h>
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
@@ -57,7 +58,8 @@ CArchDaemonUnix::daemonize(const char* n
 	setsid();
 
 	// chdir to root so we don't keep mounted filesystems points busy
-	chdir("/");
+	if (chdir("/") < 0)
+		throw XArchDaemonFailed(new XArchEvalUnix(errno));
 
 	// mask off permissions for any but owner
 	umask(077);
@@ -71,7 +73,10 @@ CArchDaemonUnix::daemonize(const char* n
 	// of standard I/O safely goes in the bit bucket.
 	open("/dev/null", O_RDONLY);
 	open("/dev/null", O_RDWR);
-	dup(1);
+
+	
+	if (dup(1) < 0)
+		throw XArchDaemonFailed(new XArchEvalUnix(errno));
 
 	// invoke function
 	return func(1, &name);
diff -x CVS -Nrup a/lib/arch/CArchMultithreadPosix.cpp b/lib/arch/CArchMultithreadPosix.cpp
--- a/lib/arch/CArchMultithreadPosix.cpp	2005-10-18 04:31:52.000000000 +0200
+++ b/lib/arch/CArchMultithreadPosix.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -392,8 +392,17 @@ CArchMultithreadPosix::newCurrentThread(
 {
 	lockMutex(m_threadMutex);
 	CArchThreadImpl* thread = find(pthread_self());
+
+	// don't emit an assert - just add the new thread in the list
+	// This is needed to reference foreign threads - e.g. from ZeroConf callbacks
+	if (!thread) {
+		thread           = new CArchThreadImpl;
+		thread->m_thread = pthread_self();
+		insert(thread);
+	}
+
 	unlockMutex(m_threadMutex);
-	assert(thread != NULL);
+
 	return thread;
 }
 
diff -x CVS -Nrup a/lib/arch/CArchNetworkBSD.cpp b/lib/arch/CArchNetworkBSD.cpp
--- a/lib/arch/CArchNetworkBSD.cpp	2007-06-17 19:31:10.000000000 +0200
+++ b/lib/arch/CArchNetworkBSD.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -315,7 +315,12 @@ CArchNetworkBSD::pollSocket(CPollEntry p
 		// the unblock event was signalled.  flush the pipe.
 		char dummy[100];
 		do {
-			read(unblockPipe[0], dummy, sizeof(dummy));
+			if (read(unblockPipe[0], dummy, sizeof(dummy)) < 0) {
+				if (errno != EAGAIN) {
+					delete[] pfd;
+					throwError(errno);
+				}
+			}
 		} while (errno != EAGAIN);
 
 		// don't count this unblock pipe in return value
@@ -487,7 +492,8 @@ CArchNetworkBSD::unblockPollSocket(CArch
 	const int* unblockPipe = getUnblockPipeForThread(thread);
 	if (unblockPipe != NULL) {
 		char dummy = 0;
-		write(unblockPipe[1], &dummy, 1);
+		if (write(unblockPipe[1], &dummy, 1) < 0)
+			throwError(errno);
 	}
 }
 
diff -x CVS -Nrup a/lib/arch/CMultibyte.cpp b/lib/arch/CMultibyte.cpp
--- a/lib/arch/CMultibyte.cpp	2005-12-19 02:46:34.000000000 +0100
+++ b/lib/arch/CMultibyte.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -22,10 +22,14 @@
 #if HAVE_LOCALE_H
 #	include <locale.h>
 #endif
+
 #if HAVE_WCHAR_H || defined(_MSC_VER)
 #	include <wchar.h>
-#elif __APPLE__
+#endif
+
+#if __APPLE__ || __GNUC__
 	// wtf?  Darwin puts mbtowc() et al. in stdlib
+	// ... gcc 4.3 requires this as well. include pathes got cleaned up...
 #	include <stdlib.h>
 #else
 	// platform apparently has no wchar_t support.  provide dummy
diff -x CVS -Nrup a/lib/base/CStringUtil.cpp b/lib/base/CStringUtil.cpp
--- a/lib/base/CStringUtil.cpp	2005-12-19 02:46:34.000000000 +0100
+++ b/lib/base/CStringUtil.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -20,6 +20,7 @@
 #include <cstdio>
 #include <cstdlib>
 #include <algorithm>
+#include <string.h>
 
 //
 // CStringUtil
diff -x CVS -Nrup a/lib/client/CClient.cpp b/lib/client/CClient.cpp
--- a/lib/client/CClient.cpp	2006-03-23 07:03:13.000000000 +0100
+++ b/lib/client/CClient.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -12,6 +12,9 @@
  * GNU General Public License for more details.
  */
 
+#include <string.h>
+#include <stdlib.h>
+
 #include "CClient.h"
 #include "CServerProxy.h"
 #include "CScreen.h"
diff -x CVS -Nrup a/lib/client/CServerProxy.cpp b/lib/client/CServerProxy.cpp
--- a/lib/client/CServerProxy.cpp	2007-06-17 19:31:11.000000000 +0200
+++ b/lib/client/CServerProxy.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -24,6 +24,7 @@
 #include "TMethodEventJob.h"
 #include "XBase.h"
 #include <memory>
+#include <string.h>
 
 //
 // CServerProxy
diff -x CVS -Nrup a/lib/Makefile.am b/lib/Makefile.am
--- a/lib/Makefile.am	2004-05-27 06:53:49.000000000 +0200
+++ b/lib/Makefile.am	2007-11-29 15:19:55.000000000 +0100
@@ -24,6 +24,7 @@ SUBDIRS =					\
 	platform				\
 	client					\
 	server					\
+	zeroconf				\
 	$(NULL)
 
 EXTRA_DIST =				\
diff -x CVS -Nrup a/lib/net/CTCPSocket.cpp b/lib/net/CTCPSocket.cpp
--- a/lib/net/CTCPSocket.cpp	2007-06-17 19:31:12.000000000 +0200
+++ b/lib/net/CTCPSocket.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -24,6 +24,7 @@
 #include "CArch.h"
 #include "XArch.h"
 #include <string.h>
+#include <stdlib.h>
 
 //
 // CTCPSocket
diff -x CVS -Nrup a/lib/platform/CXWindowsScreen.cpp b/lib/platform/CXWindowsScreen.cpp
--- a/lib/platform/CXWindowsScreen.cpp	2007-06-17 19:31:12.000000000 +0200
+++ b/lib/platform/CXWindowsScreen.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -27,6 +27,7 @@
 #include "IEventQueue.h"
 #include "TMethodEventJob.h"
 #include <cstring>
+#include <stdlib.h>
 #if X_DISPLAY_MISSING
 #	error X11 is required to build synergy
 #else
@@ -92,6 +93,10 @@ CXWindowsScreen::CXWindowsScreen(const c
 	m_xtestIsXineramaUnaware(true),
 	m_xkb(false)
 {
+
+	pthread_t tid = pthread_self();
+
+	LOG((CLOG_DEBUG "[TID: %u (0x%x)] %s (s_screen: %p)", tid, tid, __func__, s_screen));
 	assert(s_screen == NULL);
 
 	s_screen = this;
@@ -146,6 +151,11 @@ CXWindowsScreen::CXWindowsScreen(const c
 
 CXWindowsScreen::~CXWindowsScreen()
 {
+	pthread_t tid = pthread_self();
+
+
+	LOG((CLOG_DEBUG "[TID: %u (0x%x)] %s (s_screen: %p)", tid, tid, __func__, s_screen));
+
 	assert(s_screen  != NULL);
 	assert(m_display != NULL);
 
diff -x CVS -Nrup a/lib/server/CClientProxy1_3.cpp b/lib/server/CClientProxy1_3.cpp
--- a/lib/server/CClientProxy1_3.cpp	2006-03-23 07:03:22.000000000 +0100
+++ b/lib/server/CClientProxy1_3.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -12,6 +12,8 @@
  * GNU General Public License for more details.
  */
 
+#include <string.h>
+
 #include "CClientProxy1_3.h"
 #include "CProtocolUtil.h"
 #include "CLog.h"
diff -x CVS -Nrup a/lib/server/CConfig.cpp b/lib/server/CConfig.cpp
--- a/lib/server/CConfig.cpp	2006-03-23 07:03:22.000000000 +0100
+++ b/lib/server/CConfig.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -12,6 +12,7 @@
  * GNU General Public License for more details.
  */
 
+#include "CLog.h"
 #include "CConfig.h"
 #include "CServer.h"
 #include "CKeyMap.h"
@@ -427,6 +428,7 @@ CConfig::endAll() const
 bool
 CConfig::isScreen(const CString& name) const
 {
+	LOG(( CLOG_NOTE "count: %i", m_nameToCanonicalName.size() ));
 	return (m_nameToCanonicalName.count(name) > 0);
 }
 
diff -x CVS -Nrup a/lib/server/CConfigXml.cpp b/lib/server/CConfigXml.cpp
--- a/lib/server/CConfigXml.cpp	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/server/CConfigXml.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,267 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#include <string.h>
+
+#include "CLog.h"
+#include "CConfigXml.h"
+
+CConfigXml::CConfigXml() : CConfig(), doc(NULL), root(NULL)
+{
+}
+
+CConfigXml::~CConfigXml()
+{
+	xmlFreeDoc(doc);
+}
+
+bool CConfigXml::load(const CString &pathname) {
+
+	doc = xmlParseFile(pathname.c_str());
+	if (!doc) {
+		LOG((CLOG_ERR "cannot read configuration \"%s\"", 
+					pathname.c_str()));
+		return false;
+	}
+
+	if (!validate())
+		return false;
+
+	root = xmlDocGetRootElement(doc);
+	if (!root) {
+		LOG((CLOG_ERR "cannot read configuration, config looks empty"));
+		xmlFreeDoc(doc);
+		return false;
+	}
+
+	xmlNodePtr cur = root->children;
+	
+	cur = cur->next;
+
+	cur = cur->children;
+	cur = getNextElement(cur);
+
+
+	for (; cur; cur = cur->next) {
+		if (cur->children && !strcmp("Environment", (char *) cur->name))
+			getEnvironment(cur);
+	}
+
+	return true;
+}
+
+bool CConfigXml::validate() {
+
+	int ret = 0;
+	xmlSchemaParserCtxtPtr schemaParser;
+	xmlSchemaPtr xmlSchema;
+	xmlSchemaValidCtxtPtr schemaValid;
+
+	if (m_schema.empty())
+		m_schema = SYNERGY_CONFIGDIR "/" SYNERGYD_SCHEMA;
+
+	schemaParser = xmlSchemaNewParserCtxt(m_schema.c_str());
+	if (!schemaParser) {
+		LOG((CLOG_ERR "Cannot read configuration schema."));
+		return false;
+	}
+
+	xmlSchema = xmlSchemaParse(schemaParser);
+	if (!xmlSchema) {
+		LOG((CLOG_ERR "Cannot parse schema."));
+		xmlSchemaFreeParserCtxt(schemaParser);
+		return false;
+	}
+
+	xmlSchemaFreeParserCtxt(schemaParser);
+
+	schemaValid = xmlSchemaNewValidCtxt(xmlSchema);
+	if (!schemaValid) {
+		LOG((CLOG_ERR "Cannot create new xmlSchemaValidCtx object."));
+		xmlSchemaFree(xmlSchema);
+		return false;
+	}
+
+	ret = xmlSchemaValidateDoc(schemaValid, doc);
+
+	xmlSchemaFree(xmlSchema);
+	xmlSchemaFreeValidCtxt(schemaValid);
+
+	if (ret)
+		LOG((CLOG_ERR "Config is not valid."));
+
+	return !ret;
+}
+
+void CConfigXml::getEnvironment(xmlNodePtr cur)
+{
+	assert(cur);
+
+	bool server; 
+	xmlChar *role = NULL;
+
+	cur = cur->children;
+	cur = getNextElement(cur);
+
+	assert(!strcmp("Role", (char*) cur->name));
+	assert(cur->children);
+
+	// Role
+	role = xmlNodeGetContent(cur->children);
+	if (!strcmp("SERVER", (char *) role)) {
+		server = true;
+	} else {
+		server = false;
+	}
+
+	xmlFree(role);
+
+	cur = getNextElement(cur);
+
+	// Screens
+	assert(!strcmp("Screens", (char*) cur->name));
+
+	// Clients MUST only have one single host entry in Screens section
+	// The single entry is the server.
+	if (server)
+		getScreens(cur);
+	else
+		addHost(cur);
+
+}
+
+bool CConfigXml::connectScreens(xmlNodePtr cur, CString configprop, EDirection dir)
+{
+	xmlChar *prop, *host;
+
+	if (!(prop = xmlGetProp(cur, (xmlChar *) configprop.c_str())))
+			return false;
+
+	host = xmlNodeGetContent(cur);
+	assert(host);
+
+	connect((char *) host, dir, 0.0f, 1.0f,	(char *) prop, 0.0f, 1.0f);
+
+	xmlFree(prop);
+	xmlFree(host);
+	return true;
+}
+
+void CConfigXml::getScreenLinks(xmlNodePtr cur)
+{
+	connectScreens(cur, "Left", kLeft);
+	connectScreens(cur, "Right", kRight);
+	connectScreens(cur, "Top", kTop);
+	connectScreens(cur, "Bottom", kBottom);
+}
+
+void CConfigXml::addHost(xmlNodePtr cur)
+{
+
+	cur = cur->children;
+	cur = getNextElement(cur);
+	assert(cur);
+
+	xmlChar *host = xmlNodeGetContent(cur->children);
+	assert(host);
+	m_environment.insert(std::make_pair((char *)host, (char *)host));
+	xmlFree(host);
+}
+
+bool CConfigXml::isHost(const CString &host)
+{
+	return !!m_environment.count(host);
+}
+
+void CConfigXml::getScreens(xmlNodePtr cur)
+{
+
+	for (cur = getNextElement(cur->children); cur; cur = getNextElement(cur)) {
+
+		xmlChar *screen = xmlNodeGetContent(cur);
+
+
+		// verify validity of screen name
+		if (!isValidScreenName((char *) screen)) {
+			//throw XConfigXml(this, "invalid screen name \"%{1}\"", screen);
+			// TODO
+			xmlFree(screen);
+			return;
+		}
+
+		// add the screen to the configuration
+		LOG(( CLOG_DEBUG "Adding screen: %s", screen ));
+		if (!addScreen((char *) screen)) {
+			//throw XConfigXml(this, "duplicate screen name \"%{1}\"", screen);
+			// TODO
+			xmlFree(screen);
+			return;
+		}
+
+
+		xmlFree(screen);
+
+		getScreenLinks(cur);
+		
+	}
+
+}
+
+xmlNodePtr CConfigXml::getNextElement(xmlNodePtr cur)
+{
+	cur = cur->next; 
+
+	while (cur) {
+		if (cur->type == XML_ELEMENT_NODE)
+			return cur;
+
+		cur = cur->next;
+	}
+
+	return NULL;
+}
+
+//
+// CConfigXml I/O exceptions
+//
+
+/*
+XConfigXml::XConfigXml(const CConfigXml& context,
+				const CString& error) :
+	m_error(CStringUtil::print("line %p: %s",
+							context.getCurrentNode(), error.c_str()))
+{
+	// do nothing
+}
+
+XConfigXml::XConfigXml(const CConfigXml& context,
+				const char* errorFmt, const CString& arg) :
+	m_error(CStringUtil::print("line %p: ", context.getCurrentNode()) +
+							CStringUtil::format(errorFmt, arg.c_str()))
+{
+	// do nothing
+}
+
+XConfigXml::~XConfigXml()
+{
+	// do nothing
+}
+
+CString
+XConfigXml::getWhat() const throw()
+{
+	return format("XConfigXml", "read error: %{1}", m_error.c_str());
+}
+*/
+
diff -x CVS -Nrup a/lib/server/CConfigXml.h b/lib/server/CConfigXml.h
--- a/lib/server/CConfigXml.h	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/server/CConfigXml.h	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,82 @@
+/* synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#ifndef CCONFIGXML_H
+#define CCONFIGXML_H
+
+#include <libxml/xmlschemas.h>
+#include <libxml/xmlmemory.h>
+#include <libxml/parser.h>
+#include <libxml/tree.h>
+
+#include "CConfig.h"
+#define SYNERGYD_SCHEMA "synergy.xsd"
+
+
+typedef std::map<CString, CString, CStringUtil::CaselessCmp> CEnvMap;
+
+//! Zeroconf support
+/*!
+This class represent the XML Synergy configuration
+*/
+class CConfigXml : public CConfig {
+	public:
+		CConfigXml();
+		~CConfigXml();
+
+		
+		//! Load a XML configuration file 
+		/*!
+		This is loading the configuration from given path.
+		Before the actually loading it get checked by the XML Schema validation.
+		If the validation fails, the configuration get not parsed and this function
+		returns FALSE.
+		*/
+		bool load(const CString &pathname);
+
+		//! Check if host is known and configured.
+		/*!
+		Returns TRUE if the service description OR hostname is a configured service instance.
+		*/
+		bool isHost(const CString&);
+
+		//! Set location of XML Schema.
+		/*!
+		Overwrites the default location of XML Validation Schema.
+		Default is SYNERGYD_SCHEMA in synergy sysconfdir.
+		*/
+		void setXMLSchema(const CString &schema) { m_schema = schema; };
+
+		//! Get location of XML Schema
+		/*!
+		*/
+		const CString& getXMLSchema() { return m_schema; };
+
+	private:
+		bool validate();
+
+		void addHost(xmlNodePtr);
+		void getScreens(xmlNodePtr);
+		void getEnvironment(xmlNodePtr);
+		void getScreenLinks(xmlNodePtr);
+
+		bool connectScreens(xmlNodePtr, CString, EDirection);
+		xmlNodePtr getNextElement(xmlNodePtr cur);
+
+		xmlDocPtr doc;
+		xmlNodePtr root;
+		CString m_schema;
+		CEnvMap m_environment;
+};
+
+#endif // CCONFIGXML_H
diff -x CVS -Nrup a/lib/server/CServer.cpp b/lib/server/CServer.cpp
--- a/lib/server/CServer.cpp	2007-06-17 19:31:13.000000000 +0200
+++ b/lib/server/CServer.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -29,6 +29,7 @@
 #include "TMethodEventJob.h"
 #include "CArch.h"
 #include <string.h>
+#include <stdlib.h>
 
 //
 // CServer
diff -x CVS -Nrup a/lib/server/Makefile.am b/lib/server/Makefile.am
--- a/lib/server/Makefile.am	2007-06-17 19:31:13.000000000 +0200
+++ b/lib/server/Makefile.am	2007-11-29 15:20:57.000000000 +0100
@@ -13,6 +13,13 @@
 ## Process this file with automake to produce Makefile.in
 NULL =
 
+synergyconfigdir = $(sysconfdir)/synergy
+
+synergyconfig_DATA = 	\
+	synergy.xsd	\
+	$(NULL)
+
+
 EXTRA_DIST =						\
 	server.dsp						\
 	$(NULL)
@@ -31,6 +38,7 @@ libserver_a_SOURCES = 				\
 	CClientProxy1_2.cpp				\
 	CClientProxy1_3.cpp				\
 	CClientProxyUnknown.cpp			\
+	CConfigXml.cpp					\
 	CConfig.cpp						\
 	CInputFilter.cpp				\
 	CPrimaryClient.cpp				\
@@ -42,12 +50,18 @@ libserver_a_SOURCES = 				\
 	CClientProxy1_1.h				\
 	CClientProxy1_2.h				\
 	CClientProxy1_3.h				\
-	CClientProxyUnknown.h			\
-	CConfig.h						\
+	CClientProxyUnknown.h				\
+	CConfigXml.h					\
+	CConfig.h					\
 	CInputFilter.h					\
 	CPrimaryClient.h				\
-	CServer.h						\
+	CServer.h					\
 	$(NULL)
+
+libserver_a_CXXFLAGS = 					\
+	-DSYNERGY_CONFIGDIR=\"$(synergyconfigdir)\"	\
+	$(NULL)
+
 INCLUDES =							\
 	-I$(top_srcdir)/lib/common		\
 	-I$(top_srcdir)/lib/arch		\
diff -x CVS -Nrup a/lib/server/synergy.xsd b/lib/server/synergy.xsd
--- a/lib/server/synergy.xsd	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/server/synergy.xsd	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,52 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema" version="1.0">
+
+  <xsd:element name="synergy">
+    <xsd:complexType>
+      <xsd:sequence>
+	<xsd:element maxOccurs="1" name="Environments" type="Environments"/>
+	
+      </xsd:sequence>
+    </xsd:complexType>
+  </xsd:element>
+
+  <xsd:complexType name="Environments">
+    <xsd:sequence>
+      <xsd:element minOccurs="0" maxOccurs="unbounded" name="Environment" type="Environment"/>
+    </xsd:sequence>  
+  </xsd:complexType>  
+
+  
+  <xsd:complexType name="Environment">
+    <xsd:sequence>
+      <xsd:element minOccurs="1" maxOccurs="1" name="Role" type="Role"/>
+      <xsd:element minOccurs="1" maxOccurs="1" name="Screens" type="Screens"/>
+    </xsd:sequence>  
+  </xsd:complexType>  
+
+  <xsd:simpleType name="Role">
+    <xsd:restriction base="xsd:string">
+      <xsd:enumeration value="CLIENT"/>
+      <xsd:enumeration value="SERVER"/>
+    </xsd:restriction>  
+  </xsd:simpleType>  
+
+  <xsd:complexType name="Screens">
+    <xsd:sequence>
+      <xsd:element minOccurs="1" maxOccurs="unbounded" name="Host" type="Host"/>
+    </xsd:sequence>  
+  </xsd:complexType>  
+
+  <xsd:complexType name="Host">
+    <xsd:simpleContent>
+      <xsd:extension base="xsd:string">
+        <xsd:attribute name="Left" type="xsd:string"/>
+        <xsd:attribute name="Right" type="xsd:string"/>
+        <xsd:attribute name="Top" type="xsd:string"/>
+        <xsd:attribute name="Bottom" type="xsd:string"/>
+      </xsd:extension>
+    </xsd:simpleContent>
+  </xsd:complexType>  
+
+</xsd:schema>
diff -x CVS -Nrup a/lib/synergy/CPacketStreamFilter.cpp b/lib/synergy/CPacketStreamFilter.cpp
--- a/lib/synergy/CPacketStreamFilter.cpp	2004-11-07 23:36:37.000000000 +0100
+++ b/lib/synergy/CPacketStreamFilter.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -12,6 +12,7 @@
  * GNU General Public License for more details.
  */
 
+#include <string.h>
 #include "CPacketStreamFilter.h"
 #include "IEventQueue.h"
 #include "CLock.h"
diff -x CVS -Nrup a/lib/synergy/IKeyState.cpp b/lib/synergy/IKeyState.cpp
--- a/lib/synergy/IKeyState.cpp	2006-03-23 07:03:22.000000000 +0100
+++ b/lib/synergy/IKeyState.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -14,6 +14,7 @@
 
 #include "IKeyState.h"
 #include <string.h>
+#include <stdlib.h>
 
 //
 // IKeyState
diff -x CVS -Nrup a/lib/synergy/IPrimaryScreen.cpp b/lib/synergy/IPrimaryScreen.cpp
--- a/lib/synergy/IPrimaryScreen.cpp	2006-03-23 07:03:22.000000000 +0100
+++ b/lib/synergy/IPrimaryScreen.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -13,6 +13,7 @@
  */
 
 #include "IPrimaryScreen.h"
+#include <stdlib.h>
 
 //
 // IPrimaryScreen
diff -x CVS -Nrup a/lib/zeroconf/CZeroConfAvahi.cpp b/lib/zeroconf/CZeroConfAvahi.cpp
--- a/lib/zeroconf/CZeroConfAvahi.cpp	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/zeroconf/CZeroConfAvahi.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,408 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#include "CLog.h"
+#include "CNetworkAddress.h"
+#include "CZeroConfAvahi.h"
+
+#include <pwd.h>
+#include <sys/types.h>
+
+#include <avahi-common/alternative.h>
+#include <avahi-common/thread-watch.h>
+#include <avahi-common/domain.h>
+#include <avahi-common/malloc.h>
+#include <avahi-common/error.h>
+
+static AvahiThreadedPoll *threaded_poll = NULL;
+
+static AvahiEntryGroup *group = NULL;
+static AvahiServiceBrowser *sb = NULL; 
+
+static CZeroConfAvahi* self = NULL;
+
+CZeroConfAvahi::CZeroConfAvahi() : client(NULL)
+{
+	int error = 0;
+	self = this;
+
+	m_connectCb = NULL;
+	m_disconnectCb = NULL;
+	m_newServiceCb = NULL;
+	m_browseAllForNowCb = NULL;
+
+	/* TODO: Is there a synergy platform abstraction for this? */
+	CString user = getpwuid(getuid())->pw_name;
+
+	if (!(threaded_poll = avahi_threaded_poll_new()))
+		goto fail;
+
+	/* Allocate a new avahi client */
+	client = avahi_client_new(avahi_threaded_poll_get(threaded_poll), 
+			(AvahiClientFlags) 0, client_callback, NULL, &error);
+
+	if (!client)
+		goto fail;
+
+	m_hostname = avahi_client_get_host_name_fqdn(client);
+	if (m_hostname.empty())
+		goto fail;
+
+	/* Create service identifier string - the human-readable-one */
+	m_servicedesc = user + "@" + m_hostname;
+
+	if (avahi_threaded_poll_start(threaded_poll) < 0)
+		goto fail;
+
+	LOG(( CLOG_DEBUG1 "Avahi Client is running..." ));
+	return;
+fail:
+
+	if (error)
+		LOG(( CLOG_ERR "Avahi Error: %s", avahi_strerror(error)));
+
+	if (client)
+		avahi_client_free(client);
+
+	if (threaded_poll)
+		avahi_threaded_poll_stop(threaded_poll);
+}
+
+CZeroConfAvahi::~CZeroConfAvahi()
+{
+	if (threaded_poll)
+		avahi_threaded_poll_stop(threaded_poll);
+
+	if (client)
+		avahi_client_free(client);
+
+	if (threaded_poll)
+		avahi_threaded_poll_free(threaded_poll);
+}
+
+void CZeroConfAvahi::entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, void *userdata) {
+    assert(g == group || group == NULL);
+
+    /* Called whenever the entry group state changes */
+
+    switch (state) {
+        case AVAHI_ENTRY_GROUP_ESTABLISHED :
+            /* The entry group has been established successfully */
+            LOG((CLOG_DEBUG1 "Service '%s' successfully established.", self->m_servicedesc.c_str()));
+            break;
+
+        case AVAHI_ENTRY_GROUP_COLLISION : {
+            char *n;
+            
+            /* A service name collision happened. Let's pick a new name */
+            n = avahi_alternative_service_name(self->m_servicedesc.c_str());
+            self->m_servicedesc = n;
+            
+            LOG(( CLOG_ERR "Service name collision, renaming service to '%s'", self->m_servicedesc.c_str()));
+            
+            /* And recreate the services */
+            create_services(avahi_entry_group_get_client(g));
+            break;
+        }
+
+        case AVAHI_ENTRY_GROUP_FAILURE :
+
+            LOG(( CLOG_ERR "Entry group failure: %s", avahi_strerror(avahi_client_errno(avahi_entry_group_get_client(g)))));
+
+            /* Some kind of failure happened while we were registering our services */
+            avahi_threaded_poll_quit(threaded_poll);
+
+            break;
+
+        case AVAHI_ENTRY_GROUP_UNCOMMITED:
+        case AVAHI_ENTRY_GROUP_REGISTERING:
+            ;
+    }
+}
+
+bool  CZeroConfAvahi::startDiscover()
+{
+	if (!self->m_newServiceCb)
+		return false;
+
+	if (!client)
+		return false;
+
+	browse_service(client);
+	return true;
+}
+
+void CZeroConfAvahi::stopDiscover()
+{
+	avahi_service_browser_free(sb);
+	sb = NULL;
+}
+
+void CZeroConfAvahi::browse_service(AvahiClient *client)
+{
+	assert(client);
+
+	if (!(sb = avahi_service_browser_new(client, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, SYNERGY_ZEROCONF_SERVICE, NULL, (AvahiLookupFlags) 0, browse_callback, client))) {
+		LOG(( CLOG_ERR, "Failed to create service browser: %s\n", avahi_strerror(avahi_client_errno(client)) ));
+		return;
+	}
+
+}
+
+bool CZeroConfAvahi::registerService()
+{
+	AvahiClient *c = NULL;
+	
+	if (!group)
+		group = self->register_group();
+
+	if (!group)
+		goto fail;
+
+	if (!(c = avahi_entry_group_get_client(group)))
+		goto fail;
+
+	create_services(c);
+
+	return true;
+
+fail:
+	LOG(( CLOG_ERR "Failed to register Synergy Service" ));
+	return false;
+}
+
+void CZeroConfAvahi::unregisterService()
+{
+	if (group) {
+		avahi_entry_group_free(group);
+		group = NULL;
+	}
+
+}
+
+AvahiEntryGroup* CZeroConfAvahi::register_group()
+{
+
+    /* If this is the first time we're called, let's create a new entry group */
+    if (!group) {
+        if (!(group = avahi_entry_group_new(client, entry_group_callback, NULL))) {
+            LOG(( CLOG_ERR "Creating new Avahi Service Entry failed: %s", avahi_strerror(avahi_client_errno(client)) ));
+            goto fail;
+        }
+     }
+    
+    return group;
+
+fail:
+	avahi_threaded_poll_quit(threaded_poll);
+	return NULL;
+}
+
+
+void CZeroConfAvahi::create_services(AvahiClient *c) {
+    int ret;
+    assert(c);
+
+    if (!group)
+	    group = self->register_group();
+
+    LOG(( CLOG_DEBUG1 "Adding Avahi service '%s'", self->m_servicedesc.c_str()));
+    
+    if ((ret = avahi_entry_group_add_service(group, AVAHI_IF_UNSPEC, AVAHI_PROTO_UNSPEC, (AvahiPublishFlags) 0, self->m_servicedesc.c_str(), SYNERGY_ZEROCONF_SERVICE, NULL, NULL, SYNERGY_ZEROCONF_SERVICE_PORT, NULL)) < 0) {
+        LOG(( CLOG_ERR "Failed to create \"%s\" Service Record: %s", SYNERGY_ZEROCONF_SERVICE, avahi_strerror(ret)));
+        goto fail;
+    }
+
+    /* Tell the server to register the service */
+    if ((ret = avahi_entry_group_commit(group)) < 0) {
+        LOG(( CLOG_ERR "Failed to register the Service: %s", avahi_strerror(ret)));
+        goto fail;
+    }
+
+    return;
+
+fail:
+	avahi_threaded_poll_quit(threaded_poll);
+	return;
+}
+
+void CZeroConfAvahi::client_callback(AvahiClient *c, AvahiClientState state, void * userdata) {
+    assert(c);
+
+    /* Called whenever the client or server state changes */
+
+    LOG(( CLOG_DEBUG1 "Avahi Client Cb: %i", state ));
+
+    switch (state) {
+        case AVAHI_CLIENT_S_RUNNING:
+        
+	    /* XXX: Don't register/announce any service here!
+
+	       Avoid race and wait until server got started.
+	       Use registerService(), when the server instance is ready.
+	       Otherwise the remote synergy client instance try immidetaily
+	       to connect to this annound synergy service instance, even
+	       if the server isn't ready.
+	    */		
+            break;
+
+        case AVAHI_CLIENT_FAILURE:
+            
+            LOG(( CLOG_ERR "Client failure: %s", avahi_strerror(avahi_client_errno(c))));
+            avahi_threaded_poll_quit(threaded_poll);
+            
+            break;
+
+        case AVAHI_CLIENT_S_COLLISION:
+        
+            /* 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. */
+	    self->unregisterService();
+	    break;
+            
+        case AVAHI_CLIENT_S_REGISTERING:
+
+            /* 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 (group)
+                avahi_entry_group_reset(group);
+            
+            break;
+
+        case AVAHI_CLIENT_CONNECTING:
+            ;
+    }
+}
+
+void CZeroConfAvahi::resolve_callback(
+    AvahiServiceResolver *r,
+    AVAHI_GCC_UNUSED AvahiIfIndex interface,
+    AVAHI_GCC_UNUSED AvahiProtocol protocol,
+    AvahiResolverEvent event,
+    const char *name,
+    const char *type,
+    const char *domain,
+    const char *host_name,
+    const AvahiAddress *address,
+    uint16_t port,
+    AvahiStringList *txt,
+    AvahiLookupResultFlags flags,
+    AVAHI_GCC_UNUSED void* userdata) {
+
+    assert(r);
+
+    /* Called whenever a service has been resolved successfully or timed out */
+
+    switch (event) {
+        case AVAHI_RESOLVER_FAILURE:
+            LOG(( CLOG_WARN "Failed to resolve service '%s' of type '%s' in domain '%s': %s\n", 
+		    name, type, domain, avahi_strerror(avahi_client_errno(avahi_service_resolver_get_client(r))) ));
+
+            break;
+
+        case AVAHI_RESOLVER_FOUND: {
+            char a[AVAHI_ADDRESS_STR_MAX], *t;
+            
+            LOG(( CLOG_DEBUG1 "Service '%s' of type '%s' in domain '%s':\n", name, type, domain ));
+            
+            avahi_address_snprint(a, sizeof(a), address);
+            t = avahi_string_list_to_string(txt);
+            LOG(( CLOG_DEBUG1
+                    "\t%s:%u (%s)\n"
+                    "\tTXT=%s\n"
+                    "\tcookie is %u\n"
+                    "\tis_local: %i\n"
+                    "\tour_own: %i\n"
+                    "\twide_area: %i\n"
+                    "\tmulticast: %i\n"
+                    "\tcached: %i\n",
+                    host_name, port, a,
+                    t,
+                    avahi_string_list_get_service_cookie(txt),
+                    !!(flags & AVAHI_LOOKUP_RESULT_LOCAL),
+                    !!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN),
+                    !!(flags & AVAHI_LOOKUP_RESULT_WIDE_AREA),
+                    !!(flags & AVAHI_LOOKUP_RESULT_MULTICAST),
+                    !!(flags & AVAHI_LOOKUP_RESULT_CACHED) ));
+                
+	    if (!(flags & AVAHI_LOOKUP_RESULT_OUR_OWN)) {
+		    CNetworkAddress caddress(host_name, port);
+	    	    caddress.resolve();
+
+		    self->m_newServiceCb(caddress, name);
+	    }
+
+            avahi_free(t);
+        }
+    }
+
+    avahi_service_resolver_free(r);
+}
+
+void CZeroConfAvahi::browse_callback(
+    AvahiServiceBrowser *b,
+    AvahiIfIndex interface,
+    AvahiProtocol protocol,
+    AvahiBrowserEvent event,
+    const char *name,
+    const char *type,
+    const char *domain,
+    AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
+    void* userdata) {
+
+    AvahiClient *c = (AvahiClient *) userdata;
+    assert(b);
+
+    /* Called whenever a new services becomes available on the LAN or is removed from the LAN */
+    switch (event) {
+        case AVAHI_BROWSER_FAILURE:
+
+            LOG(( CLOG_DEBUG1 "%s\n", avahi_strerror(avahi_client_errno(avahi_service_browser_get_client(b))) ));
+            avahi_threaded_poll_quit(threaded_poll);
+            return;
+
+        case AVAHI_BROWSER_NEW:
+            LOG(( CLOG_DEBUG1 "NEW: service '%s' of type '%s' in domain '%s'\n", name, type, domain));
+
+            /* We ignore the returned resolver object. In the callback
+               function we free it. If the server is terminated before
+               the callback function is called the server will free
+               the resolver for us. */
+
+            if ( !(avahi_service_resolver_new(c, interface, protocol, name, type, domain, 
+					    AVAHI_PROTO_UNSPEC, (AvahiLookupFlags) 0, resolve_callback, c)) ) {
+                LOG(( CLOG_ERR "Failed to resolve Service '%s': %s\n", name, avahi_strerror(avahi_client_errno(c))));
+	    }
+
+            break;
+
+        case AVAHI_BROWSER_REMOVE:
+            LOG(( CLOG_DEBUG1 "REMOVE: service '%s' of type '%s' in domain '%s'\n", name, type, domain));
+            break;
+
+        case AVAHI_BROWSER_ALL_FOR_NOW:
+            LOG(( CLOG_DEBUG1 "ALL FOR NOW"));
+	    self->m_browseAllForNowCb();
+	    break;
+
+        case AVAHI_BROWSER_CACHE_EXHAUSTED:
+            LOG(( CLOG_DEBUG1 "CACHE_EXHAUSTED"));
+            break;
+    }
+}
+
diff -x CVS -Nrup a/lib/zeroconf/CZeroConfAvahi.h b/lib/zeroconf/CZeroConfAvahi.h
--- a/lib/zeroconf/CZeroConfAvahi.h	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/zeroconf/CZeroConfAvahi.h	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,55 @@
+/* synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#ifndef CZEROCONFAVAHI_H
+#define CZEROCONFAVAHI_H
+
+#include <avahi-client/client.h>
+#include <avahi-client/publish.h>
+#include <avahi-client/lookup.h>
+#include "IZeroConf.h"
+
+#define ZEROCONF CZeroConfAvahi
+
+class CZeroConfAvahi : public virtual IZeroConf {
+	public:
+		CZeroConfAvahi();
+		virtual ~CZeroConfAvahi();
+		bool registerService();
+		void unregisterService();
+		bool startDiscover();
+		void stopDiscover();
+		CString getHostname() { return m_hostname; };
+		CString getServicename() { return m_servicedesc; };
+	private:
+		AvahiEntryGroup *register_group();
+		static void create_services(AvahiClient *c);
+		static void browse_service(AvahiClient *c);
+		static void resolve_callback(AvahiServiceResolver *r, AvahiIfIndex interface, 
+				AvahiProtocol protocol,
+		AvahiResolverEvent event, const char *name, const char *type, const char *domain, 
+				const char *host_name, const AvahiAddress *address, uint16_t port, 
+				AvahiStringList *txt, AvahiLookupResultFlags flags, void* userdata);
+		static void browse_callback(AvahiServiceBrowser *b, AvahiIfIndex interface, 
+				AvahiProtocol protocol, AvahiBrowserEvent event, const char *name,
+				const char *type, const char *domain, AvahiLookupResultFlags flags, 
+				void* userdata);
+		static void client_callback(AvahiClient *c, AvahiClientState state, void *);
+		static void entry_group_callback(AvahiEntryGroup *g, AvahiEntryGroupState state, 
+				void *userdata) ;
+		AvahiClient *client;
+		CString m_hostname;
+		CString m_servicedesc;
+};
+
+#endif // CZEROCONFAVAHI_H
diff -x CVS -Nrup a/lib/zeroconf/CZeroConf.cpp b/lib/zeroconf/CZeroConf.cpp
--- a/lib/zeroconf/CZeroConf.cpp	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/zeroconf/CZeroConf.cpp	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,46 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#include "config.h"
+#include "CString.h"
+#include "CZeroConf.h"
+
+#undef ZEROCONF
+
+#if HAVE_AVAHI
+#	include "CZeroConfAvahi.h"
+#endif
+
+#if !defined(ZEROCONF)
+#	error no supported ZeroConf selected
+#endif
+
+CZeroConf* CZeroConf::s_instance = NULL;
+
+CZeroConf::CZeroConf() {
+
+	assert(s_instance == NULL);
+	s_instance = this;
+
+	m_zeroconf = new ZEROCONF;
+	
+}
+
+CZeroConf::~CZeroConf() {
+
+	delete m_zeroconf;
+
+	s_instance = NULL;
+}
+
diff -x CVS -Nrup a/lib/zeroconf/CZeroConf.h b/lib/zeroconf/CZeroConf.h
--- a/lib/zeroconf/CZeroConf.h	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/zeroconf/CZeroConf.h	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,89 @@
+/*
+ * synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#ifndef CZEROCONF_H
+#define CZEROCONF_H
+
+#include "IZeroConf.h"
+
+//! Zeroconf support
+/*!
+This class represent an abstraction for Zeroconf support
+*/
+class CZeroConf {
+	public:
+
+		/*!
+		Constructs the Zeroconf component
+		*/
+		CZeroConf();
+		~CZeroConf();
+
+		//! Register Synergy Zeroconf Service
+		/*!
+		This announces the Synergy Service via DNS-SD via the Zeroconf specific implementation.
+		*/
+		bool registerService() { return m_zeroconf->registerService(); };
+
+		//! Unregister Synergy Zeroconf Service
+		/*!
+		This unregisteres the Synergy Service via DNS-SD via the Zeroconf specific implementation.
+		*/
+		void unregisterService() { m_zeroconf->unregisterService(); };
+
+		//! Start Discovery
+		/*!
+		*/
+		bool startDiscover() { return m_zeroconf->startDiscover(); };
+
+		//! Stop Discovery
+		/*!
+		*/
+		void stopDiscover() { m_zeroconf->stopDiscover(); };
+
+		//! Get mDNS hostname
+		/*!
+		Returns the mDNS hostname.
+		*/
+		CString getHostname() { return m_zeroconf->getHostname(); };
+
+		//! Get Zeroconf (DNS-SD) Service Name
+		/*!
+		Returns the Zeroconf (DNS-SD) Service Name.
+		*/
+		CString getServicename() { return m_zeroconf->getServicename(); };
+
+		//! Set "New Service" Callback Function
+		/*!
+		This callback gets called everytime a synergy service gets discovered.
+		*/
+		void setNewServiceCb(ZeroConfNewServiceCb cb) { m_zeroconf->setNewServiceCb(cb); };
+
+		//! Set "All for now" Callback Function
+		/*!
+		This callback gets called when the initial discovery finished. This requires to trigger
+		a discovery process with startDiscover(). This should be used to avoid race conditions and to time 
+		"role" (client/server) conditions.
+		*/
+		void setBrowseAllForNowCb(ZeroConfBrowseAllForNowCb cb) { m_zeroconf->setBrowseAllForNowCb(cb); };
+
+	private:
+		static CZeroConf *getInstance() { return s_instance; };
+
+		IZeroConf *m_zeroconf;
+		static CZeroConf *s_instance;
+
+};
+
+#endif // CZEROCONF_H
diff -x CVS -Nrup a/lib/zeroconf/IZeroConf.h b/lib/zeroconf/IZeroConf.h
--- a/lib/zeroconf/IZeroConf.h	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/zeroconf/IZeroConf.h	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,50 @@
+/* synergy -- mouse and keyboard sharing utility
+ * Copyright (C) 2007 Daniel Gollub
+ * 
+ * This package is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License
+ * found in the file COPYING that should have accompanied this file.
+ * 
+ * This package 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.
+ */
+
+#ifndef IZERCONF_H
+#define IZERCONF_H
+
+#include "CNetworkAddress.h"
+#include "ProtocolTypes.h"
+
+#define SYNERGY_ZEROCONF_SERVICE "_synergy._tcp"
+#define SYNERGY_ZEROCONF_SERVICE_PORT kDefaultPort 
+
+typedef bool (*ZeroConfConnectCb) (const CNetworkAddress &);
+typedef void (*ZeroConfDisconnectCb) (const CNetworkAddress &);
+typedef void (*ZeroConfNewServiceCb) (const CNetworkAddress &, const CString &);
+typedef void (*ZeroConfBrowseAllForNowCb) ();
+
+class IZeroConf {
+	public:
+		virtual bool registerService() = 0;
+		virtual void unregisterService() = 0;
+		virtual bool startDiscover() = 0;
+		virtual void stopDiscover() = 0;
+		virtual CString getHostname() = 0;
+		virtual CString getServicename() = 0;
+
+		void setConnectCb(ZeroConfConnectCb cb) { m_connectCb = cb; };
+		void setDisconnectCb(ZeroConfDisconnectCb cb) { m_disconnectCb = cb; };
+		void setNewServiceCb(ZeroConfNewServiceCb cb) { m_newServiceCb = cb; };
+		void setBrowseAllForNowCb(ZeroConfBrowseAllForNowCb cb) { m_browseAllForNowCb = cb; };
+
+	protected:
+		ZeroConfConnectCb m_connectCb;
+		ZeroConfDisconnectCb m_disconnectCb;
+		ZeroConfNewServiceCb m_newServiceCb;
+		ZeroConfBrowseAllForNowCb m_browseAllForNowCb;
+
+};
+
+#endif // IZERCONF_H
diff -x CVS -Nrup a/lib/zeroconf/Makefile.am b/lib/zeroconf/Makefile.am
--- a/lib/zeroconf/Makefile.am	1970-01-01 01:00:00.000000000 +0100
+++ b/lib/zeroconf/Makefile.am	2007-11-29 15:19:55.000000000 +0100
@@ -0,0 +1,54 @@
+# synergy -- mouse and keyboard sharing utility
+# Copyright (C) 2002 Chris Schoeneman
+# Copyright (C) 2007 Daniel Gollub 
+# 
+# This package is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License
+# found in the file COPYING that should have accompanied this file.
+# 
+# This package 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.
+
+## Process this file with automake to produce Makefile.in
+NULL =
+
+if AVAHI
+AVAHI_SOURCE_FILES = 			\
+	CZeroConfAvahi.cpp		\
+	CZeroConfAvahi.h
+endif	
+
+COMMON_SOURCE_FILES =			\
+	CZeroConf.cpp			\
+	CZeroConf.h			\
+	IZeroConf.h
+
+ZEROCONF_SOURCE_FILES = 		\
+	$(AVAHI_SOURCE_FILES) 		\
+	$(NULL)
+
+EXTRA_DIST =				\
+	$(COMMON_SOURCE_FILES)		\
+	$(AVAHI_SOURCE_FILES)		\
+	$(NULL)
+
+MAINTAINERCLEANFILES =			\
+	Makefile.in			\
+	$(NULL)
+
+noinst_LIBRARIES = libzeroconf.a
+
+libzeroconf_a_SOURCES =				\
+	$(AVAHI_SOURCE_FILES)			\
+	$(COMMON_SOURCE_FILES)			\
+	$(NULL)
+
+INCLUDES =				\
+	-I$(top_srcdir)/lib/arch	\
+	-I$(top_srcdir)/lib/base	\
+	-I$(top_srcdir)/lib/common	\
+	-I$(top_srcdir)/lib/net		\
+	-I$(top_srcdir)/lib/synergy	\
+	$(NULL)
diff -x CVS -Nrup a/Makefile.am b/Makefile.am
--- a/Makefile.am	2004-08-06 07:26:08.000000000 +0200
+++ b/Makefile.am	2007-11-29 15:19:55.000000000 +0100
@@ -18,6 +18,7 @@ SUBDIRS =							\
 	cmd								\
 	doc								\
 	dist							\
+	tests						\
 	$(NULL)
 
 EXTRA_DIST =						\
diff -x CVS -Nrup a/tests/cconfigxml.cpp b/tests/cconfigxml.cpp
--- a/tests/cconfigxml.cpp	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/cconfigxml.cpp	2007-11-29 15:19:49.000000000 +0100
@@ -0,0 +1,182 @@
+#include <stdlib.h>
+#include <check.h>
+
+#include "CLog.h"
+#include "CArch.h"
+#include "CConfigXml.h"
+
+static CConfigXml *setup_testbed()
+{
+	CConfigXml *xml = new CConfigXml;
+	fail_unless(xml != NULL);
+
+	xml->setXMLSchema("../lib/server/synergy.xsd");
+
+	return xml;
+}
+
+START_TEST (test_invalid_noschema)
+{
+	CConfigXml *xml = new CConfigXml;
+	fail_unless(xml != NULL);
+
+	xml->setXMLSchema("/wrong/path/../lib/server/synergy.xsd");
+
+	bool ret = xml->load("./testdata/cconfigxml/valid_server.conf");
+	fail_unless(ret == false);
+
+	delete xml;
+}
+END_TEST
+
+START_TEST (test_invalid_nofile)
+{
+	CConfigXml *xml = setup_testbed();
+
+	bool ret = xml->load("");
+	fail_unless(ret == false);
+
+	delete xml;
+}
+END_TEST
+
+START_TEST (test_invalid_filenotfound)
+{
+	CConfigXml *xml = setup_testbed();
+
+	bool ret = xml->load("/../../wrong/file/path");
+	fail_unless(ret == false);
+
+	delete xml;
+}
+END_TEST
+
+START_TEST (test_invalid_empty)
+{
+	CConfigXml *xml = setup_testbed();
+
+	bool ret = xml->load("./testdata/cconfigxml/empty.conf");
+	fail_unless(ret == false);
+
+	delete xml;
+}
+END_TEST
+
+START_TEST (test_invalid_missingrole)
+{
+	CConfigXml *xml = setup_testbed();
+
+	bool ret = xml->load("./testdata/cconfigxml/invalid_client.conf");
+	fail_unless(ret == false);
+
+	delete xml;
+}
+END_TEST
+
+
+START_TEST (test_valid)
+{
+	CConfigXml *xml = setup_testbed(); 
+
+	bool ret = xml->load("./testdata/cconfigxml/valid_server.conf");
+	fail_unless(ret == true);
+
+	ret = xml->load("./testdata/cconfigxml/valid_client.conf");
+	fail_unless(ret == true);
+
+	delete xml;
+}
+END_TEST
+
+START_TEST (test_valid_ishost)
+{
+	CConfigXml *xml = setup_testbed(); 
+
+	bool ret = xml->load("./testdata/cconfigxml/valid_client.conf");
+	fail_unless(ret == true);
+
+	ret = xml->isHost("marvin.local");
+	fail_unless(ret == true);
+
+	ret = xml->isHost("xxxxxxxx.anotherdomain");
+	fail_unless(ret == false);
+
+	delete xml;
+}
+END_TEST
+
+START_TEST (test_valid_noenviroments)
+{
+	CConfigXml *xml = setup_testbed();
+
+	bool ret = xml->load("testdata/cconfigxml/noenv.conf");
+	fail_unless(ret == true);
+
+	delete xml;
+}
+END_TEST
+
+START_TEST (test_valid_multihoming)
+{
+	CConfigXml *xml = setup_testbed(); 
+
+	bool ret = xml->load("./testdata/cconfigxml/multihoming.conf");
+	fail_unless(ret == true);
+
+	ret = xml->isHost("dani@marvin.local");
+	fail_unless(ret == true);
+
+	ret = xml->isHost("foo@bar.local");
+	fail_unless(ret == true);
+
+	ret = xml->isHost("linux-9rbi.local");
+	fail_unless(ret == false);
+
+	ret = xml->isScreen("linux-9rbi.local");
+	fail_unless(ret == true);
+
+	ret = xml->isScreen("marvin.local");
+	fail_unless(ret == true);
+
+	delete xml;
+}
+END_TEST
+
+Suite *cconfigxml_suite()
+{
+
+	Suite *s = suite_create("CConfigXml");
+
+	TCase *tc = tcase_create("InvalidConfigs");
+	tcase_add_test(tc, test_invalid_noschema);
+	tcase_add_test(tc, test_invalid_nofile);
+	tcase_add_test(tc, test_invalid_filenotfound);
+	tcase_add_test(tc, test_invalid_empty);
+	tcase_add_test(tc, test_invalid_missingrole);
+	suite_add_tcase(s, tc);
+
+	tc = tcase_create("ValidConfigs");
+	tcase_add_test(tc, test_valid);
+	tcase_add_test(tc, test_valid_ishost);
+	tcase_add_test(tc, test_valid_noenviroments);
+	tcase_add_test(tc, test_valid_multihoming);
+	suite_add_tcase(s, tc);
+
+	return s;
+
+}
+
+int main(void)
+{
+	CArch arch;
+
+	int failed = 0;
+
+	Suite *s = cconfigxml_suite();
+	SRunner *sr = srunner_create(s);
+	srunner_run_all(sr, CK_VERBOSE);
+	failed = srunner_ntests_failed(sr);
+	srunner_free(sr);
+
+	return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}
diff -x CVS -Nrup a/tests/Makefile.am b/tests/Makefile.am
--- a/tests/Makefile.am	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/Makefile.am	2007-11-29 15:19:49.000000000 +0100
@@ -0,0 +1,85 @@
+NULL =
+
+TESTS = cconfigxml zeroconf_avahi
+
+check_PROGRAMS = cconfigxml zeroconf_avahi
+
+cconfigxml_SOURCES = cconfigxml.cpp
+cconfigxml_CFLAGS = 					\
+	$(CHECK_CFLAGS)					\
+	$(LIBXML2_CFLAGS)				\
+	$(NULL)
+
+cconfigxml_LDFLAGS =					\
+	$(CHECK_LIBS)					\
+	$(LIBXML2_LIBS)					\
+	$(NULL)
+
+cconfigxml_LDADD =					\
+	$(top_builddir)/lib/client/libclient.a		\
+	$(top_builddir)/lib/server/libserver.a		\
+	$(top_builddir)/lib/platform/libplatform.a	\
+	$(top_builddir)/lib/synergy/libsynergy.a	\
+	$(top_builddir)/lib/net/libnet.a		\
+	$(top_builddir)/lib/io/libio.a			\
+	$(top_builddir)/lib/mt/libmt.a			\
+	$(top_builddir)/lib/base/libbase.a		\
+	$(top_builddir)/lib/common/libcommon.a		\
+	$(top_builddir)/lib/arch/libarch.a		\
+	$(top_builddir)/lib/zeroconf/libzeroconf.a	\
+	$(NULL)
+
+zeroconf_avahi_SOURCES = zeroconf_avahi.cpp
+zeroconf_avahi_CFLAGS = 					\
+	$(AVAHI_CFLAGS)					\
+	$(CHECK_CFLAGS)					\
+	$(LIBXML2_CFLAGS)				\
+	$(NULL)
+
+zeroconf_avahi_LDFLAGS = 					\
+	$(AVAHI_LIBS)					\
+	$(CHECK_LIBS)					\
+	$(LIBXML2_LIBS)					\
+	$(NULL)
+
+zeroconf_avahi_LDADD =					\
+	$(top_builddir)/lib/client/libclient.a		\
+	$(top_builddir)/lib/server/libserver.a		\
+	$(top_builddir)/lib/platform/libplatform.a	\
+	$(top_builddir)/lib/synergy/libsynergy.a	\
+	$(top_builddir)/lib/net/libnet.a		\
+	$(top_builddir)/lib/io/libio.a			\
+	$(top_builddir)/lib/mt/libmt.a			\
+	$(top_builddir)/lib/base/libbase.a		\
+	$(top_builddir)/lib/common/libcommon.a		\
+	$(top_builddir)/lib/arch/libarch.a		\
+	$(top_builddir)/lib/zeroconf/libzeroconf.a	\
+	$(NULL)
+
+INCLUDES =                                              \
+	-I$(top_srcdir)/lib/common			\
+	-I$(top_srcdir)/lib/arch			\
+	-I$(top_srcdir)/lib/base 			\
+	-I$(top_srcdir)/lib/mt	 			\
+	-I$(top_srcdir)/lib/io	 			\
+	-I$(top_srcdir)/lib/net	 			\
+	-I$(top_srcdir)/lib/synergy			\
+	-I$(top_srcdir)/lib/platform 			\
+	-I$(top_srcdir)/lib/server	 		\
+	-I$(top_srcdir)/lib/client	 		\
+	-I$(top_srcdir)/lib/zeroconf	 		\
+        $(NULL)
+
+coverage: lcov-reset check lcov genhtml
+
+lcov-reset:
+	lcov -q --directory $(top_srcdir) --zerocounters
+	rm -f lcov.info
+
+lcov:
+	lcov -q --directory $(top_srcdir) --capture --output-file lcov.info --test-name "synergy coverage test: `date  --rfc-3339=ns`"
+	
+genhtml:
+	mv coverage-result coverage-result-`date +%s` 2> /dev/null
+	mkdir coverage-result/
+	genhtml -q lcov.info -o coverage-result/
diff -x CVS -Nrup a/tests/testdata/cconfigxml/invalid_client.conf b/tests/testdata/cconfigxml/invalid_client.conf
--- a/tests/testdata/cconfigxml/invalid_client.conf	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/testdata/cconfigxml/invalid_client.conf	2007-11-29 15:19:49.000000000 +0100
@@ -0,0 +1,12 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<synergy>
+  <Environments>
+
+   <Environment>
+     <Screens>
+       <Host>marvin.local</Host>
+     </Screens>
+    </Environment>
+
+   </Environments>
+</synergy>
diff -x CVS -Nrup a/tests/testdata/cconfigxml/multihoming.conf b/tests/testdata/cconfigxml/multihoming.conf
--- a/tests/testdata/cconfigxml/multihoming.conf	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/testdata/cconfigxml/multihoming.conf	2007-11-29 15:19:49.000000000 +0100
@@ -0,0 +1,27 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<synergy>
+  <Environments>
+   <Environment>
+     <Role>CLIENT</Role>
+     <Screens>
+       <Host>dani@marvin.local</Host>
+     </Screens>
+   </Environment>
+
+   <Environment>
+     <Role>CLIENT</Role>
+     <Screens>
+       <Host>foo@bar.local</Host>
+     </Screens>
+   </Environment>
+
+   <Environment>
+     <Role>SERVER</Role>
+     <Screens>
+       <Host Left="linux-9rbi.local">marvin.local</Host>
+       <Host Right="marvin.local">linux-9rbi.local</Host>
+     </Screens>
+   </Environment>
+
+ </Environments>
+</synergy>
diff -x CVS -Nrup a/tests/testdata/cconfigxml/noenv.conf b/tests/testdata/cconfigxml/noenv.conf
--- a/tests/testdata/cconfigxml/noenv.conf	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/testdata/cconfigxml/noenv.conf	2007-11-29 15:19:49.000000000 +0100
@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<synergy>
+  <Environments>
+   </Environments>
+</synergy>
diff -x CVS -Nrup a/tests/testdata/cconfigxml/valid_client.conf b/tests/testdata/cconfigxml/valid_client.conf
--- a/tests/testdata/cconfigxml/valid_client.conf	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/testdata/cconfigxml/valid_client.conf	2007-11-29 15:19:49.000000000 +0100
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<synergy>
+  <Environments>
+
+   <Environment>
+     <Role>CLIENT</Role>
+     <Screens>
+       <Host>marvin.local</Host>
+     </Screens>
+    </Environment>
+
+   </Environments>
+</synergy>
diff -x CVS -Nrup a/tests/testdata/cconfigxml/valid_server.conf b/tests/testdata/cconfigxml/valid_server.conf
--- a/tests/testdata/cconfigxml/valid_server.conf	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/testdata/cconfigxml/valid_server.conf	2007-11-29 15:19:49.000000000 +0100
@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<synergy>
+  <Environments>
+
+   <Environment>
+     <Role>SERVER</Role>
+     <Screens>
+       <Host Left="marvin.local">sugga.local</Host>
+       <Host Right="sugga.local">marvin.local</Host>
+     </Screens>
+    </Environment>
+
+   </Environments>
+</synergy>
diff -x CVS -Nrup a/tests/zeroconf_avahi.cpp b/tests/zeroconf_avahi.cpp
--- a/tests/zeroconf_avahi.cpp	1970-01-01 01:00:00.000000000 +0100
+++ b/tests/zeroconf_avahi.cpp	2007-11-29 15:26:33.000000000 +0100
@@ -0,0 +1,115 @@
+#include <stdlib.h>
+#include <check.h>
+
+#include "CLog.h"
+#include "CArch.h"
+#include "CZeroConf.h"
+#include "CZeroConfAvahi.h"
+
+static void _avahi_dummy_new_service(const CNetworkAddress &, const CString &)
+{
+}
+
+static void _avahi_dummy_allfornow()
+{
+}
+
+START_TEST (zc_avahi_init)
+{
+	CZeroConfAvahi *zc_avahi = new CZeroConfAvahi;
+	fail_unless(zc_avahi != NULL);
+
+	delete zc_avahi;
+
+}
+END_TEST
+
+START_TEST (zc_avahi_gethostname)
+{
+	CZeroConfAvahi *zc_avahi = new CZeroConfAvahi;
+	fail_unless(zc_avahi != NULL);
+
+	CString host = zc_avahi->getHostname();
+
+	fail_unless(host.empty() == false, "Hostname is empty....");
+
+	delete zc_avahi;
+
+}
+END_TEST
+
+
+START_TEST (zc_avahi_simplediscover)
+{
+	bool ret;
+
+	CZeroConfAvahi *zc_avahi = new CZeroConfAvahi;
+	fail_unless(zc_avahi != NULL);
+
+	zc_avahi->setNewServiceCb(_avahi_dummy_new_service);
+	zc_avahi->setBrowseAllForNowCb(_avahi_dummy_allfornow);
+
+	
+	ret = zc_avahi->startDiscover();
+
+	fail_unless(ret == true);
+
+
+	sleep(1);
+
+	zc_avahi->stopDiscover();
+
+	delete zc_avahi;
+
+}
+END_TEST
+
+START_TEST (zc_avahi_registerservice)
+{
+	CZeroConfAvahi *zc_avahi = new CZeroConfAvahi;
+	fail_unless(zc_avahi != NULL);
+
+	zc_avahi->registerService();
+
+	sleep(1);
+
+	zc_avahi->unregisterService();
+
+	delete zc_avahi;
+
+}
+END_TEST
+
+
+Suite *zc_avahi_suite()
+{
+
+	Suite *s = suite_create("ZeroConfAvahi");
+
+	TCase *tc = tcase_create("Basic");
+	tcase_add_test(tc, zc_avahi_init);
+	tcase_add_test(tc, zc_avahi_simplediscover);
+	tcase_add_test(tc, zc_avahi_registerservice);
+	tcase_add_test(tc, zc_avahi_gethostname);
+	suite_add_tcase(s, tc);
+
+	return s;
+}
+
+int main(void)
+{
+	CArch arch;
+
+	CLOG;
+	CNetworkAddress addr; 
+
+	int failed = 0;
+
+	Suite *s = zc_avahi_suite();
+	SRunner *sr = srunner_create(s);
+	srunner_run_all(sr, CK_VERBOSE);
+	failed = srunner_ntests_failed(sr);
+	srunner_free(sr);
+
+	return (failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE;
+}

Places

File synergy-zeroconf-poc.diff of Package synergy (Revision 50ab8f8b65af8e9d87dd8721d42e912f)

Places