a building but non-functional address conduit

svn path=/trunk/; revision=4174

6 files changed, 1642 insertions, 0 deletions

diff --git a/addressbook/conduit/Makefile.am b/addressbook/conduit/Makefile.am
new file mode 100644
index 0000000000..64a1103bce
--- /dev/null
+++ b/addressbook/conduit/Makefile.am
@@ -0,0 +1,81 @@
+#
+#
+#
+
+INCLUDES = 				\
+	-I$(top_srcdir)/calendar	\
+	$(GNOME_PILOT_CFLAGS)
+
+file_conduitsdir=$(libdir)/gnome-pilot/conduits
+
+bin_PROGRAMS = address-conduit-control-applet
+
+address_conduit_control_applet_SOURCES = address-conduit-control-applet.c
+
+address_conduit_control_applet_LDADD = \
+		$(CAPPLET_LIBS)  \
+		$(GNOME_LIBDIR) \
+		-lgpilotdcm \
+		-lgpilotd \
+		-lgpilotdconduit \
+		$(GNOME_CAPPLET_LIBS) \
+		$(BONOBO_VFS_GNOME_LIBS) \
+		$(GNOME_XML_LIB) \
+	        $(GNOMEUI_LIBS) \
+		$(PISOCK_LIBDIR) $(PISOCK_LIBS) \
+                $(INTLLIBS)
+
+
+#		$(top_builddir)/libgpilotdCM/libgpilotdcm.la \
+#		$(top_builddir)/gpilotd/libgpilotd.la \
+#		$(top_builddir)/gpilotd/libgpilotdconduit.la \
+
+
+# address_conduit
+address_conduitsdir=$(libdir)/gnome-pilot/conduits
+address_conduits_LTLIBRARIES = libaddress_conduit.la
+
+libaddress_conduit_la_SOURCES = \
+	address-conduit.c
+
+# address-conduit.c: my_gnomecal_idl
+
+address.conduit: address.conduit.in Makefile
+	sed -e 's^\@prefix\@^$(prefix)^g' < $(srcdir)/address.conduit.in > address.conduit.tmp \
+	&& mv address.conduit.tmp address.conduit
+
+#
+# conduit
+#
+
+libaddress_conduit_la_LDFLAGS = \
+	-rpath $(libdir)
+
+libaddress_conduit_la_LIBADD = 					\
+	$(top_builddir)/calendar/cal-client/libcal-client-static.la	\
+	$(top_builddir)/calendar/cal-util/libcal-util-static.la		\
+	$(top_builddir)/libversit/libversit.la				\
+	$(top_builddir)/libical/src/libical/libical-static.la		\
+	$(BONOBO_VFS_GNOME_LIBS)					\
+	$(PISOCK_LIBDIR) $(PISOCK_LIBS) 				\
+	$(GNOME_LIBDIR) 						\
+	$(GNOME_LIBS)
+
+ccenterdir = $(datadir)/control-center
+ccenterPalmPilotdir = $(ccenterdir)/Peripherals
+ccenterConduitsdir = $(ccenterPalmPilotdir)/Conduits
+ccenterConduits_DATA = address-conduit-control-applet.desktop 
+
+panelConduitsdir = $(datadir)/gnome/apps/Settings/Peripherals/Conduits
+panelConduits_DATA = $(ccenterConduits_DATA)
+
+Conduitdir = $(datadir)/gnome-pilot/conduits/
+Conduit_DATA = address.conduit
+
+EXTRA_DIST = \
+	address.conduit.in \
+        $(ccenterConduits_DATA)
+
+install-data-local:
+	$(mkinstalldirs) $(ccenterConduitsdir)
+	$(mkinstalldirs) $(Conduitdir)
diff --git a/addressbook/conduit/address-conduit-control-applet.c b/addressbook/conduit/address-conduit-control-applet.c
new file mode 100644
index 0000000000..79a43fe5c6
--- /dev/null
+++ b/addressbook/conduit/address-conduit-control-applet.c
@@ -0,0 +1,387 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+/* Control applet ("capplet") for the gnome-pilot address conduit,             */
+/* based on                                                                 */
+/* gpilotd control applet ('capplet') for use with the GNOME control center */
+
+#include <pwd.h>
+#include <sys/types.h>
+#include <signal.h>
+#include <gnome.h>
+
+#include <config.h>
+#include <capplet-widget.h>
+
+#include <libgpilotdCM/gnome-pilot-conduit-management.h>
+#include <libgpilotdCM/gnome-pilot-conduit-config.h>
+#include <gpilotd/gnome-pilot-client.h>
+
+#include "address-conduit.h"
+
+
+/* tell changes callbacks to ignore changes or not */
+static gboolean ignore_changes=FALSE;
+
+/* capplet widget */
+static GtkWidget *capplet=NULL;
+
+/* host/device/pilot configuration windows */
+GtkWidget *cfgOptionsWindow=NULL;
+GtkWidget *cfgStateWindow=NULL;
+GtkWidget *dialogWindow=NULL;
+
+gboolean activated,org_activation_state;
+GnomePilotConduitManagement *conduit;
+GnomePilotConduitConfig *conduit_config;
+GCalConduitCfg *origState = NULL;
+GCalConduitCfg *curState = NULL;
+
+static void doTrySettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg);
+static void doRevertSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg);
+static void doSaveSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg);
+
+//static void readStateCfg (GtkWidget *w, GCalConduitCfg *c);
+static void setStateCfg (GtkWidget *w, GCalConduitCfg *c);
+
+gint pilotId;
+CORBA_Environment ev;
+static GnomePilotClient *gpc;
+
+
+
+/* This array must be in the same order as enumerations
+   in GnomePilotConduitSyncType as they are used as index.
+   Custom type implies Disabled state.
+*/
+static gchar* sync_options[] ={ N_("Disabled"),
+				N_("Synchronize"),
+				N_("Copy From Pilot"),
+				N_("Copy To Pilot"),
+				N_("Merge From Pilot"),
+				N_("Merge To Pilot")};
+#define SYNC_OPTIONS_COUNT 6
+
+
+
+
+/* Saves the configuration data. */
+static void 
+gcalconduit_save_configuration(GCalConduitCfg *c) 
+{
+	gchar prefix[256];
+
+	g_snprintf(prefix,255,"/gnome-pilot.d/address-conduit/Pilot_%u/",c->pilotId);
+
+	gnome_config_push_prefix(prefix);
+	gnome_config_set_bool ("open_secret", c->open_secret);
+	gnome_config_pop_prefix();
+
+	gnome_config_sync();
+	gnome_config_drop_all();
+}
+
+/* Creates a duplicate of the configuration data */
+static GCalConduitCfg*
+gcalconduit_dupe_configuration(GCalConduitCfg *c) {
+	GCalConduitCfg *retval;
+	g_return_val_if_fail(c!=NULL,NULL);
+	retval = g_new0(GCalConduitCfg,1);
+	retval->sync_type = c->sync_type;
+	retval->open_secret = c->open_secret;
+	retval->pilotId = c->pilotId;
+	return retval;
+}
+
+
+static void
+doTrySettings(GtkWidget *widget, GCalConduitCfg *c)
+{
+	/*
+	readStateCfg (cfgStateWindow, curState);
+	if (activated)
+		gnome_pilot_conduit_config_enable (conduit_config, GnomePilotConduitSyncTypeCustom);
+	else
+		gnome_pilot_conduit_config_disable (conduit_config);
+	*/
+
+	if (c->sync_type!=GnomePilotConduitSyncTypeCustom)
+		gnome_pilot_conduit_config_enable_with_first_sync (conduit_config,
+								   c->sync_type,
+								   c->sync_type,
+								   TRUE);
+	else
+		gnome_pilot_conduit_config_disable (conduit_config);
+
+	gcalconduit_save_configuration (c);
+}
+
+
+static void
+doSaveSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg)
+{
+	doTrySettings(widget, GCalConduitCfg);
+	gcalconduit_save_configuration(GCalConduitCfg);
+}
+
+
+static void
+doCancelSettings(GtkWidget *widget, GCalConduitCfg *c)
+{
+	doSaveSettings (widget, c);
+}
+
+
+static void
+doRevertSettings(GtkWidget *widget, GCalConduitCfg *GCalConduitCfg)
+{
+	activated = org_activation_state;
+	setStateCfg (cfgStateWindow, curState);
+}
+
+static void 
+about_cb (GtkWidget *widget, gpointer data) 
+{
+	GtkWidget *about;
+	const gchar *authors[] = {_("Eskil Heyn Olsen <deity@eskil.dk>"),NULL};
+  
+	about = gnome_about_new (_("Gpilotd address conduit"), VERSION,
+				 _("(C) 1998 the Free Software Foundation"),
+				 authors,
+				 _("Configuration utility for the address conduit.\n"),
+				 _("gnome-unknown.xpm"));
+	gtk_widget_show (about);
+  
+	return;
+}
+
+
+/* called by the sync_type GtkOptionMenu */
+static void
+sync_action_selection(GtkMenuShell *widget, gpointer unused) 
+{
+	if (!ignore_changes) {
+		capplet_widget_state_changed(CAPPLET_WIDGET (capplet), TRUE);
+	}
+}
+
+
+/* called by the sync_type GtkOptionMenu */
+static void
+activate_sync_type(GtkMenuItem *widget, gpointer data)
+{
+	curState->sync_type = GPOINTER_TO_INT(data);
+	if(!ignore_changes)
+		capplet_widget_state_changed(CAPPLET_WIDGET(capplet), TRUE);
+}
+
+
+static GtkWidget
+*createStateCfgWindow(void)
+{
+	GtkWidget *vbox, *table;
+	GtkWidget *label;
+	GtkWidget *optionMenu,*menuItem;
+	GtkMenu   *menu;
+	gint i;
+	
+	vbox = gtk_vbox_new(FALSE, GNOME_PAD);
+
+	table =  gtk_hbox_new(FALSE, 0); 
+	gtk_box_pack_start(GTK_BOX(vbox), table, FALSE, FALSE, GNOME_PAD);
+
+	label = gtk_label_new(_("Synchronize Action"));
+	gtk_box_pack_start(GTK_BOX(table), label, FALSE, FALSE, GNOME_PAD);    
+
+	optionMenu=gtk_option_menu_new();
+	gtk_object_set_data(GTK_OBJECT(vbox), "conduit_state", optionMenu);
+	menu = GTK_MENU(gtk_menu_new());
+
+	for (i=0; i<SYNC_OPTIONS_COUNT;i++) {
+		sync_options[i]=_(sync_options[i]);
+		menuItem = gtk_menu_item_new_with_label(sync_options[i]);
+		gtk_widget_show(menuItem);
+		gtk_signal_connect(GTK_OBJECT(menuItem),"activate",
+				   GTK_SIGNAL_FUNC(activate_sync_type),
+				   GINT_TO_POINTER(i));
+		gtk_menu_append(menu,menuItem);
+	}
+
+	gtk_option_menu_set_menu(GTK_OPTION_MENU(optionMenu),GTK_WIDGET(menu));
+	gtk_signal_connect(GTK_OBJECT(menu), "selection-done",
+			   GTK_SIGNAL_FUNC(sync_action_selection),
+			   NULL);
+  
+	gtk_box_pack_start(GTK_BOX(table), optionMenu, FALSE, FALSE, 0);    
+	
+	return vbox;
+}
+
+
+static void
+setStateCfg (GtkWidget *w, GCalConduitCfg *c)
+{
+	GtkOptionMenu *optionMenu;
+	GtkMenu *menu;
+	
+	optionMenu = gtk_object_get_data (GTK_OBJECT(w), "conduit_state");
+	g_assert (optionMenu != NULL);
+	menu = GTK_MENU (gtk_option_menu_get_menu (optionMenu));
+  
+	ignore_changes = TRUE;
+	/* Here were are relying on the items in menu being the same 
+	   order as in GnomePilotConduitSyncType. */
+	gtk_option_menu_set_history (optionMenu, (int) c->sync_type);
+	ignore_changes = FALSE;
+}
+
+
+#if 0
+static void
+readStateCfg (GtkWidget *w, GCalConduitCfg *c)
+{
+	/*
+	GtkWidget *button;
+	button  = gtk_object_get_data(GTK_OBJECT(cfg), "conduit_on_off");
+	g_assert(button!=NULL);
+	activated = GTK_TOGGLE_BUTTON(button)->active;
+	*/
+}
+#endif /* 0 */
+
+
+static void
+pilot_capplet_setup(void)
+{
+	GtkWidget *frame, *table;
+
+	capplet = capplet_widget_new();
+
+	table = gtk_table_new(1, 2, FALSE);
+	gtk_container_border_width(GTK_CONTAINER(table), GNOME_PAD);
+	gtk_container_add(GTK_CONTAINER(capplet), table); 
+
+	frame = gtk_frame_new(_("Conduit state"));
+	gtk_container_border_width(GTK_CONTAINER(frame), GNOME_PAD_SMALL);
+	gtk_table_attach_defaults(GTK_TABLE(table), frame, 0, 1, 0, 1);
+	cfgStateWindow = createStateCfgWindow();
+	gtk_container_add(GTK_CONTAINER(frame), cfgStateWindow);
+
+	gtk_signal_connect(GTK_OBJECT(capplet), "try",
+			   GTK_SIGNAL_FUNC(doTrySettings), curState);
+	gtk_signal_connect(GTK_OBJECT(capplet), "revert",
+			   GTK_SIGNAL_FUNC(doRevertSettings), curState);
+	gtk_signal_connect(GTK_OBJECT(capplet), "ok",
+			   GTK_SIGNAL_FUNC(doSaveSettings), curState);
+	gtk_signal_connect(GTK_OBJECT(capplet), "cancel",
+			   GTK_SIGNAL_FUNC(doCancelSettings), curState);
+	gtk_signal_connect(GTK_OBJECT(capplet), "help",
+			   GTK_SIGNAL_FUNC(about_cb), NULL);
+
+
+	setStateCfg (cfgStateWindow, curState);
+
+	gtk_widget_show_all (capplet);
+}
+
+
+static void 
+run_error_dialog(gchar *mesg,...) 
+{
+	char tmp[80];
+	va_list ap;
+
+	va_start(ap,mesg);
+	vsnprintf(tmp,79,mesg,ap);
+	dialogWindow = gnome_message_box_new(mesg,GNOME_MESSAGE_BOX_ERROR,GNOME_STOCK_BUTTON_OK,NULL);
+	gnome_dialog_run_and_close(GNOME_DIALOG(dialogWindow));
+	va_end(ap);
+}
+
+
+static gint 
+get_pilot_id_from_gpilotd() 
+{
+	GList *pilots=NULL;
+	gint pilot;
+	int i,err;
+  
+	i=0;
+	/* we don't worry about leaking here, so pilots isn't freed */
+	switch(err = gnome_pilot_client_get_pilots(gpc,&pilots)) {
+	case GPILOTD_OK: {
+		if(pilots) {
+			for(i=0;i<g_list_length(pilots);i++) {
+				g_message("pilot %d = \"%s\"",i,(gchar*)g_list_nth(pilots,i)->data); 
+			}
+			if(i==0) {
+				run_error_dialog(_("No pilot configured, please choose the\n'Pilot Link Properties' capplet first."));
+				return -1;
+			} else {
+				gnome_pilot_client_get_pilot_id_by_name(gpc,
+									pilots->data,  /* this is the first pilot */
+									&pilot);
+				if(i>1) {
+					g_message("too many pilots...");
+					/* need a choose here */
+				}
+				return pilot;
+			}
+		} else {
+			run_error_dialog(_("No pilot configured, please choose the\n'Pilot Link Properties' capplet first."));
+			return -1;
+		}    
+		break;
+	}
+	case GPILOTD_ERR_NOT_CONNECTED:
+		run_error_dialog(_("Not connected to the gnome-pilot daemon"));
+		return -1;
+		break;
+	default:
+		g_warning("gnome_pilot_client_get_pilot_ids(...) = %d",err);
+		run_error_dialog(_("An error occured when trying to fetch\npilot list from the gnome-pilot daemon"));
+		return -1;
+		break;
+	}
+}
+
+
+int
+main (int argc, char *argv[])
+{
+	g_log_set_always_fatal (G_LOG_LEVEL_ERROR |
+				G_LOG_LEVEL_CRITICAL |
+				G_LOG_LEVEL_WARNING);
+	
+	/* we're a capplet */
+	gnome_capplet_init ("address conduit control applet", NULL, argc, argv, 
+			    NULL, 0, NULL);
+
+   
+	gpc = gnome_pilot_client_new();
+	gnome_pilot_client_connect_to_daemon(gpc);
+	pilotId = get_pilot_id_from_gpilotd();
+	if(!pilotId) return -1;
+
+	/* put all code to set things up in here */
+	gcalconduit_load_configuration (&origState, pilotId);
+
+	conduit = gnome_pilot_conduit_management_new ("address_conduit", GNOME_PILOT_CONDUIT_MGMT_ID);
+	if (conduit == NULL) return -1;
+	conduit_config = gnome_pilot_conduit_config_new (conduit, pilotId);
+	org_activation_state = gnome_pilot_conduit_config_is_enabled (conduit_config,
+								      &origState->sync_type);
+	activated = org_activation_state;
+
+	//gpilotd_conduit_mgmt_get_sync_type (conduit, pilotId, &origState->sync_type);
+
+	curState = gcalconduit_dupe_configuration(origState);
+    
+	pilot_capplet_setup ();
+
+
+	/* done setting up, now run main loop */
+	capplet_gtk_main();
+    
+	gnome_pilot_conduit_management_destroy(conduit);
+
+	return 0;
+}    
diff --git a/addressbook/conduit/address-conduit-control-applet.desktop b/addressbook/conduit/address-conduit-control-applet.desktop
new file mode 100644
index 0000000000..d4941e44fe
--- /dev/null
+++ b/addressbook/conduit/address-conduit-control-applet.desktop
@@ -0,0 +1,10 @@
+[Desktop Entry]
+Name=Address conduit 
+Name[da]=Udstĺende
+Name[no]=Oppgaver
+Comment=Configure the address conduit
+Comment[da]=Konfigurér Udstĺende
+Comment[no]=Konfigurér oppgavelisten
+Exec=address-conduit-control-applet --cap-id=1
+Terminal=0
+Type=Application
diff --git a/addressbook/conduit/address-conduit.c b/addressbook/conduit/address-conduit.c
new file mode 100644
index 0000000000..e954bbb4b0
--- /dev/null
+++ b/addressbook/conduit/address-conduit.c
@@ -0,0 +1,1069 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+#include <config.h>
+#include <sys/stat.h>
+#include <utime.h>
+#include <unistd.h>
+#include <pwd.h>
+#include <signal.h>
+#include <errno.h>
+
+#include <cal-client/cal-client.h>
+#include <cal-util/calobj.h>
+#include <cal-util/timeutil.h>
+#include <pi-source.h>
+#include <pi-socket.h>
+#include <pi-file.h>
+#include <pi-dlp.h>
+#include <libgnorba/gnorba.h>
+#include <libgnorba/gnome-factory.h>
+#include <pi-version.h>
+#include <gpilotd/gnome-pilot-conduit.h>
+#include <gpilotd/gnome-pilot-conduit-standard-abs.h>
+#include <address-conduit.h>
+
+//#include "GnomeCal.h"
+
+GnomePilotConduit * conduit_get_gpilot_conduit (guint32);
+void conduit_destroy_gpilot_conduit (GnomePilotConduit*);
+void local_record_from_icalobject (GCalLocalRecord *local, iCalObject *obj);
+
+#define CONDUIT_VERSION "0.8.11"
+#ifdef G_LOG_DOMAIN
+#undef G_LOG_DOMAIN
+#endif
+#define G_LOG_DOMAIN "addressconduit" 
+
+#define DEBUG_CALCONDUIT 1
+/* #undef DEBUG_CALCONDUIT */
+
+#ifdef DEBUG_CALCONDUIT
+#define show_exception(e) g_warning ("Exception: %s\n", CORBA_exception_id (e))
+#define LOG(e...) g_log(G_LOG_DOMAIN,G_LOG_LEVEL_MESSAGE, e)
+#else
+#define show_exception(e)
+#define LOG(e...)
+#endif 
+
+#define WARN(e...) g_log(G_LOG_DOMAIN,G_LOG_LEVEL_WARNING, e)
+#define INFO(e...) g_log(G_LOG_DOMAIN,G_LOG_LEVEL_MESSAGE, e)
+
+#define catch_ret_val(_env,ret)                                                                 \
+  if (_env._major != CORBA_NO_EXCEPTION) {                                                      \
+        g_log(G_LOG_DOMAIN,G_LOG_LEVEL_MESSAGE,"%s:%d: Caught exception",__FILE__,__LINE__);    \
+        g_warning ("Exception: %s\n", CORBA_exception_id (&(_env)));                               \
+	CORBA_exception_free(&(_env));                                                             \
+	return ret;                                                                             \
+  }
+
+
+
+
+/* Destroys any data allocated by gcalconduit_load_configuration
+   and deallocates the given configuration. */
+static void 
+gcalconduit_destroy_configuration(GCalConduitCfg **c) 
+{
+	g_return_if_fail(c!=NULL);
+	g_return_if_fail(*c!=NULL);
+	g_free(*c);
+	*c = NULL;
+}
+
+
+/* Given a GCalConduitContxt*, allocates the structure */
+static void
+gcalconduit_new_context(GCalConduitContext **ctxt,
+			GCalConduitCfg *c) 
+{
+	*ctxt = g_new0(GCalConduitContext,1);
+	g_assert(ctxt!=NULL);
+	(*ctxt)->cfg = c;
+	CORBA_exception_init (&((*ctxt)->ev));
+}
+
+
+/* Destroys any data allocated by gcalconduit_new_context
+   and deallocates its data. */
+static void
+gcalconduit_destroy_context(GCalConduitContext **ctxt)
+{
+	g_return_if_fail(ctxt!=NULL);
+	g_return_if_fail(*ctxt!=NULL);
+/*
+	if ((*ctxt)->cfg!=NULL)
+		gcalconduit_destroy_configuration(&((*ctxt)->cfg));
+*/
+	g_free(*ctxt);
+	*ctxt = NULL;
+}
+
+
+static void
+gnome_address_load_cb (GtkWidget *cal_client,
+		       CalClientLoadStatus status,
+		       GCalConduitContext *ctxt)
+{
+	//CalClient *client = CAL_CLIENT (cal_client);
+
+	printf ("entering gnome_address_load_cb, tried=%d\n",
+		ctxt->address_load_tried);
+
+	if (status == CAL_CLIENT_LOAD_SUCCESS) {
+		ctxt->address_load_success = TRUE;
+		printf ("  success\n");
+		gtk_main_quit (); /* end the sub event loop */
+	} else {
+		if (ctxt->address_load_tried) {
+			printf ("load and create of address failed\n");
+			gtk_main_quit (); /* end the sub event loop */
+			return;
+		}
+
+		// cal_client_create_address (client, ctxt->address_file);
+		ctxt->address_load_tried = 1;
+	}
+}
+
+
+
+
+
+static int
+start_address_server (GnomePilotConduitStandardAbs *conduit,
+		       GCalConduitContext *ctxt)
+{
+	
+	g_return_val_if_fail(conduit!=NULL,-2);
+	g_return_val_if_fail(ctxt!=NULL,-2);
+
+	ctxt->client = cal_client_new ();
+
+	/* FIX ME */
+	ctxt->address_file = g_concat_dir_and_file (g_get_home_dir (),
+			       "evolution/local/something");
+
+	gtk_signal_connect (GTK_OBJECT (ctxt->client), "cal_loaded",
+			    gnome_address_load_cb, ctxt);
+
+	printf ("calling cal_client_load_address\n");
+	//cal_client_load_address (ctxt->client, ctxt->address_file);
+
+	/* run a sub event loop to turn cal-client's async load
+	   notification into a synchronous call */
+	gtk_main ();
+
+	if (ctxt->address_load_success)
+		return 0;
+
+	return -1;
+}
+
+
+
+static GSList * 
+get_address_objects(GnomePilotConduitStandardAbs *conduit,
+		     gboolean *status,
+		     GCalConduitContext *ctxt) 
+{
+#if 0
+	GList *uids;
+	GSList *result = NULL;
+
+	g_return_val_if_fail (conduit != NULL, NULL);
+	g_return_val_if_fail (ctxt != NULL, NULL);
+
+	uids = cal_client_get_uids (ctxt->client, CALOBJ_TYPE_ADDRESS);
+
+	printf ("got %d address entries from cal server\n", g_list_length (uids));
+
+	if (status != NULL)
+		(*status) = TRUE;
+
+	if (! uids)
+		INFO ("No entries found");
+	else {
+		GList *c;
+		for (c=uids; c; c=c->next)
+			result = g_slist_prepend (result, (gchar *) c->data);
+		/* FIX ME free uids */
+	}
+
+	return result;
+#endif /* 0 */
+	return NULL;
+}
+
+
+static void 
+local_record_from_ical_uid (GCalLocalRecord *local,
+			    char *uid,
+			    GCalConduitContext *ctxt)
+{
+	iCalObject *obj;
+	CalClientGetStatus status;
+
+	g_assert(local!=NULL);
+
+	status = cal_client_get_object (ctxt->client, uid, &obj);
+
+	if (status == CAL_CLIENT_GET_SUCCESS)
+		local_record_from_icalobject(local,obj);
+	else
+		INFO ("Object did not exist");
+}
+
+
+/*
+ * converts a iCalObject to a GCalLocalRecord
+ */
+
+void
+local_record_from_icalobject(GCalLocalRecord *local,
+			     iCalObject *obj) 
+{
+	g_return_if_fail(local!=NULL);
+	g_return_if_fail(obj!=NULL);
+
+	local->ical = obj;
+	local->local.ID = local->ical->pilot_id;
+/*
+	LOG ("local->Id = %ld [%s], status = %d",
+		  local->local.ID,obj->summary,local->ical->pilot_status);
+*/
+	switch(local->ical->pilot_status) {
+	case ICAL_PILOT_SYNC_NONE: 
+		local->local.attr = GnomePilotRecordNothing; 
+		break;
+	case ICAL_PILOT_SYNC_MOD: 
+		local->local.attr = GnomePilotRecordModified; 
+		break;
+	case ICAL_PILOT_SYNC_DEL: 
+		local->local.attr = GnomePilotRecordDeleted; 
+		break;
+	}
+
+	/* Records without a pilot_id are new */
+	if(local->local.ID == 0) 
+		local->local.attr = GnomePilotRecordNew; 
+  
+	local->local.secret = 0;
+	if(obj->class!=NULL) 
+		if(strcmp(obj->class,"PRIVATE")==0)
+			local->local.secret = 1;
+ 
+	local->local.archived = 0;  
+}
+
+
+/*
+ * Given a PilotRecord, find the matching record in
+ * the address repository. If no match, return NULL
+ */
+static GCalLocalRecord *
+find_record_in_repository(GnomePilotConduitStandardAbs *conduit,
+			  PilotRecord *remote,
+			  GCalConduitContext *ctxt) 
+{
+	char *uid = NULL;
+	GCalLocalRecord *loc;
+	CalClientGetStatus status;
+	iCalObject *obj;
+  
+	g_return_val_if_fail(conduit!=NULL,NULL);
+	g_return_val_if_fail(remote!=NULL,NULL);
+  
+	LOG ("requesting %ld", remote->ID);
+
+
+	status = cal_client_get_uid_by_pilot_id (ctxt->client, remote->ID, &uid);
+
+	if (status == CAL_CLIENT_GET_SUCCESS) {
+		status = cal_client_get_object (ctxt->client, uid, &obj);
+		if (status == CAL_CLIENT_GET_SUCCESS) {
+			LOG ("Found");
+			loc = g_new0(GCalLocalRecord,1);
+			/* memory allocated in new_from_string is freed in free_match */
+			local_record_from_icalobject (loc, obj);
+			return loc;
+		}
+	}
+
+	INFO ("Object did not exist");
+	return NULL;
+}
+
+
+/* 
+ * updates an given iCalObject in the repository
+ */
+static void
+update_address_entry_in_repository(GnomePilotConduitStandardAbs *conduit,
+				    iCalObject *obj,
+				    GCalConduitContext *ctxt) 
+{
+	gboolean success;
+
+	g_return_if_fail(conduit!=NULL);
+	g_return_if_fail(obj!=NULL);
+
+	success = cal_client_update_object (ctxt->client, obj);
+}
+
+
+static iCalObject *
+ical_from_remote_record(GnomePilotConduitStandardAbs *conduit,
+			PilotRecord *remote,
+			iCalObject *in_obj)
+{
+#if 0
+	iCalObject *obj;
+	struct Address address;
+	time_t now;
+
+	now = time (NULL);
+
+	g_return_val_if_fail(remote!=NULL,NULL);
+	memset (&address, 0, sizeof (struct Address));
+	unpack_Address (&address, remote->record, remote->length);
+	
+	if (in_obj == NULL)
+		obj = ical_new (address.note ? address.note : "",
+				g_get_user_name (),
+				address.description ? address.description : "");
+	else 
+		obj = in_obj;
+	
+	if (address.note) {
+		g_free (obj->comment);
+		obj->comment = g_strdup (address.note);
+	}
+	if (address.description) {
+		g_free (obj->summary);
+		obj->summary = g_strdup (address.description);
+	}
+
+	obj->type = ICAL_ADDRESS;
+	obj->new = TRUE;
+	obj->created = now;
+	obj->last_mod = now;
+	obj->priority = 0;
+	obj->transp = 0;
+	obj->related = NULL;
+	obj->pilot_id = remote->ID;
+	obj->pilot_status = ICAL_PILOT_SYNC_NONE;
+
+	/*
+	 * Begin and end
+	 */
+	
+	obj->dtend = mktime (& address.due);
+
+	if (address.complete)
+		obj->completed = now-5; /* FIX ME */
+
+	printf ("[%s] from pilot, complete=%d/%ld\n",
+		address.description,
+		address.complete,
+		obj->completed);
+
+	obj->priority = address.priority;
+
+	g_free (obj->class);
+	
+	if (remote->attr & dlpRecAttrSecret)
+		obj->class = g_strdup ("PRIVATE");
+	else
+		obj->class = g_strdup ("PUBLIC");
+
+
+	free_Address(&address);
+
+	return obj;
+#endif /* 0 */
+	return NULL;
+}
+
+
+static gint
+update_record (GnomePilotConduitStandardAbs *conduit,
+	       PilotRecord *remote,
+	       GCalConduitContext *ctxt)
+{
+#if 0
+	iCalObject *obj;
+	struct Address address;
+	CalClientGetStatus status;
+	char *uid;
+
+	g_return_val_if_fail(remote!=NULL,-1);
+
+	memset (&address, 0, sizeof (struct Address));
+	unpack_Address (&address, remote->record, remote->length);
+
+	LOG ("requesting %ld [%s]", remote->ID, address.description);
+	printf ("requesting %ld [%s]\n", remote->ID, address.description);
+
+	status = cal_client_get_uid_by_pilot_id(ctxt->client, remote->ID, &uid);
+	if (status == CAL_CLIENT_GET_SUCCESS)
+		status = cal_client_get_object (ctxt->client, uid, &obj);
+
+	if (status != CAL_CLIENT_GET_SUCCESS) {
+		time_t now = time (NULL);
+
+		LOG ("Object did not exist, creating a new one");
+		printf ("Object did not exist, creating a new one\n");
+
+		obj = ical_new (address.note ? address.note : "",
+				g_get_user_name (),
+				address.description ? address.description : "");
+
+		obj->type = ICAL_ADDRESS;
+		obj->new = TRUE;
+		obj->created = now;
+		obj->last_mod = now;
+		obj->priority = 0;
+		obj->transp = 0;
+		obj->related = NULL;
+		obj->pilot_id = remote->ID;
+		obj->pilot_status = ICAL_PILOT_SYNC_NONE;
+	} else {
+		iCalObject *new_obj;
+		LOG ("Found");
+		printf ("Found\n");
+		new_obj = ical_from_remote_record (conduit, remote, obj);
+		obj = new_obj;
+	}
+
+	/* update record on server */
+	
+	update_address_entry_in_repository (conduit, obj, ctxt);
+	cal_client_update_pilot_id (ctxt->client, obj->uid, obj->pilot_id,
+				    ICAL_PILOT_SYNC_NONE);
+
+	/*
+	 * Shutdown
+	 */
+	ical_object_unref (obj);
+	free_Address(&address);
+
+#endif /* 0 */
+
+	return 0;
+}
+
+static void
+check_for_slow_setting (GnomePilotConduit *c, GCalConduitContext *ctxt)
+{
+#if 0
+	GList *uids;
+	unsigned long int entry_number;
+
+	uids = cal_client_get_uids (ctxt->client, CALOBJ_TYPE_ADDRESS);
+
+	entry_number = g_list_length (uids);
+
+	LOG (_("Address holds %ld address entries"), entry_number);
+	/* If the local base is empty, do a slow sync */
+	if (entry_number == 0) {
+		GnomePilotConduitStandard *conduit;
+		conduit = GNOME_PILOT_CONDUIT_STANDARD (c);
+		gnome_pilot_conduit_standard_set_slow (conduit);
+	}
+#endif /* 0 */
+}
+
+static gint
+pre_sync (GnomePilotConduit *c,
+	  GnomePilotDBInfo *dbi,
+	  GCalConduitContext *ctxt)
+{
+	int l;
+	unsigned char *buf;
+	GnomePilotConduitStandardAbs *conduit;
+	/* gint num_records; */
+	//GList *uids;
+
+	/*
+	g_log_set_always_fatal (G_LOG_LEVEL_ERROR |
+				G_LOG_LEVEL_CRITICAL |
+				G_LOG_LEVEL_WARNING);
+	*/
+
+
+	conduit = GNOME_PILOT_CONDUIT_STANDARD_ABS(c);
+  
+	g_message ("GnomeCal Conduit v.%s",CONDUIT_VERSION);
+
+	ctxt->client = NULL;
+	
+	if (start_address_server (GNOME_PILOT_CONDUIT_STANDARD_ABS(c), ctxt) != 0) {
+		WARN(_("Could not start gnomecal server"));
+		gnome_pilot_conduit_error(GNOME_PILOT_CONDUIT(c),
+					  _("Could not start gnomecal server"));
+		return -1;
+	}
+
+
+#if 0  
+	/* Set the counters for the progress bar crap */
+	num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_ANY, &(ctxt->ev));
+
+	catch_ret_val (ctxt->ev, -1);
+	gnome_pilot_conduit_standard_abs_set_num_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records);
+	num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_MODIFIED, &(ctxt->ev));
+	catch_ret_val (ctxt->ev, -1);
+	gnome_pilot_conduit_standard_abs_set_num_updated_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records);
+	num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_NEW, &(ctxt->ev));
+	catch_ret_val (ctxt->ev, -1);
+	gnome_pilot_conduit_standard_abs_set_num_new_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records);
+	num_records = GNOME_Calendar_Repository_get_number_of_objects (ctxt->calendar, GNOME_Calendar_Repository_DELETED, &(ctxt->ev));
+	catch_ret_val (ctxt->ev, -1);
+	gnome_pilot_conduit_standard_abs_set_num_deleted_local_records(GNOME_PILOT_CONDUIT_STANDARD_ABS(c), num_records);
+#endif /* 0 */
+
+	gtk_object_set_data(GTK_OBJECT(c),"dbinfo",dbi);
+  
+	/* load_records(c); */
+
+	buf = (unsigned char*)g_malloc(0xffff);
+	if((l=dlp_ReadAppBlock(dbi->pilot_socket,dbi->db_handle,0,(unsigned char *)buf,0xffff)) < 0) {
+		WARN(_("Could not read pilot's DateBook application block"));
+		WARN("dlp_ReadAppBlock(...) = %d",l);
+		gnome_pilot_conduit_error(GNOME_PILOT_CONDUIT(c),
+			     _("Could not read pilot's DateBook application block"));
+		return -1;
+	}
+	unpack_AddressAppInfo(&(ctxt->ai),buf,l);
+	g_free(buf);
+
+	check_for_slow_setting(c,ctxt);
+
+	return 0;
+}
+
+/**
+ * Find (if possible) the local record which matches
+ * the given PilotRecord.
+ * if successfull, return non-zero and set *local to
+ * a non-null value (the located local record),
+ * otherwise return 0 and set *local = NULL;
+ */
+
+static gint
+match_record	(GnomePilotConduitStandardAbs *conduit,
+		 GCalLocalRecord **local,
+		 PilotRecord *remote,
+		 GCalConduitContext *ctxt)
+{
+	LOG ("in match_record");
+
+	g_return_val_if_fail(local!=NULL,-1);
+	g_return_val_if_fail(remote!=NULL,-1);
+
+	*local = find_record_in_repository(conduit,remote,ctxt);
+  
+	if (*local==NULL) return -1;
+	return 0;
+}
+
+/**
+ * Free the data allocated by a previous match_record call.
+ * If successfull, return non-zero and ser *local=NULL, otherwise
+ * return 0.
+ */
+static gint
+free_match	(GnomePilotConduitStandardAbs *conduit,
+		 GCalLocalRecord **local,
+		 GCalConduitContext *ctxt)
+{
+	LOG ("entering free_match");
+
+	g_return_val_if_fail(local!=NULL,-1);
+	g_return_val_if_fail(*local!=NULL,-1);
+
+	ical_object_unref (GCAL_LOCALRECORD(*local)->ical); 
+	g_free(*local);
+	
+        *local = NULL;
+	return 0;
+}
+
+/*
+  Move to archive and set status to Nothing
+ */
+static gint
+archive_local (GnomePilotConduitStandardAbs *conduit,
+	       GCalLocalRecord *local,
+	       GCalConduitContext *ctxt)
+{
+	LOG ("entering archive_local");
+
+	g_return_val_if_fail(local!=NULL,-1);
+
+	return -1;
+}
+
+/*
+  Store in archive and set status to Nothing
+ */
+static gint
+archive_remote (GnomePilotConduitStandardAbs *conduit,
+		GCalLocalRecord *local,
+		PilotRecord *remote,
+		GCalConduitContext *ctxt)
+{
+	LOG ("entering archive_remote");
+
+        //g_return_val_if_fail(remote!=NULL,-1);
+	//g_return_val_if_fail(local!=NULL,-1);
+
+	return -1;
+}
+
+/*
+  Store and set status to Nothing
+ */
+static gint
+store_remote (GnomePilotConduitStandardAbs *conduit,
+	      PilotRecord *remote,
+	      GCalConduitContext *ctxt)
+{
+	LOG ("entering store_remote");
+
+	g_return_val_if_fail(remote!=NULL,-1);
+	remote->attr = GnomePilotRecordNothing;
+
+	return update_record(conduit,remote,ctxt);
+}
+
+static gint
+clear_status_archive_local (GnomePilotConduitStandardAbs *conduit,
+			    GCalLocalRecord *local,
+			    GCalConduitContext *ctxt)
+{
+	LOG ("entering clear_status_archive_local");
+
+	g_return_val_if_fail(local!=NULL,-1);
+
+        return -1;
+}
+
+static gint
+iterate (GnomePilotConduitStandardAbs *conduit,
+	 GCalLocalRecord **local,
+	 GCalConduitContext *ctxt)
+{
+	static GSList *events,*iterator;
+	static int hest;
+
+	g_return_val_if_fail(local!=NULL,-1);
+
+	if(*local==NULL) {
+		LOG ("beginning iteration");
+
+		events = get_address_objects (conduit, NULL, ctxt);
+		hest = 0;
+		
+		if(events!=NULL) {
+			LOG ("iterating over %d records", g_slist_length (events));
+			*local = g_new0(GCalLocalRecord,1);
+
+			local_record_from_ical_uid(*local,(gchar*)events->data,ctxt);
+			iterator = events;
+		} else {
+			LOG ("no events");
+			(*local) = NULL;
+		}
+	} else {
+		/* printf ("continuing iteration\n"); */
+		hest++;
+		if(g_slist_next(iterator)==NULL) {
+			GSList *l;
+
+			LOG ("ending");
+			/** free stuff allocated for iteration */
+			g_free((*local));
+
+			LOG ("iterated over %d records", hest);
+			for(l=events;l;l=l->next)
+				g_free(l->data);
+
+			g_slist_free(events);
+
+			/* ends iteration */
+			(*local) = NULL;
+			return 0;
+		} else {
+			iterator = g_slist_next(iterator);
+			local_record_from_ical_uid(*local,(gchar*)(iterator->data),ctxt);
+		}
+	}
+	return 1;
+}
+
+
+static gint
+iterate_specific (GnomePilotConduitStandardAbs *conduit,
+		  GCalLocalRecord **local,
+		  gint flag,
+		  gint archived,
+		  GCalConduitContext *ctxt)
+{
+#ifdef DEBUG_CALCONDUIT
+	{
+		gchar *tmp;
+		switch (flag) {
+		case GnomePilotRecordNothing: tmp = g_strdup("RecordNothing"); break;
+		case GnomePilotRecordModified: tmp = g_strdup("RecordModified"); break;
+		case GnomePilotRecordNew: tmp = g_strdup("RecordNew"); break;
+		default: tmp = g_strdup_printf("0x%x",flag); break;
+		}
+		printf ("entering iterate_specific(flag = %s)\n", tmp);
+		g_free(tmp);
+	}
+#endif
+	g_return_val_if_fail(local!=NULL,-1);
+
+	/* iterate until a record meets the criteria */
+	while(gnome_pilot_conduit_standard_abs_iterate(conduit,(LocalRecord**)local)) {
+		if((*local)==NULL) break;
+		if(archived && ((*local)->local.archived==archived)) break;
+		if(((*local)->local.attr == flag)) break;
+	}
+
+	return (*local)==NULL?0:1;
+}
+
+static gint
+purge (GnomePilotConduitStandardAbs *conduit,
+       GCalConduitContext *ctxt)
+{
+	LOG ("entering purge");
+
+	/* HEST, gem posterne her */
+
+	return -1;
+}
+
+
+static gint
+set_status (GnomePilotConduitStandardAbs *conduit,
+	    GCalLocalRecord *local,
+	    gint status,
+	    GCalConduitContext *ctxt)
+{
+	gboolean success;
+	LOG ("entering set_status(status=%d)",status);
+
+	g_return_val_if_fail(local!=NULL,-1);
+
+	g_assert(local->ical!=NULL);
+	
+	local->local.attr = status;
+	switch(status) {
+	case GnomePilotRecordPending:
+	case GnomePilotRecordNothing:
+		local->ical->pilot_status = ICAL_PILOT_SYNC_NONE;
+		break;
+	case GnomePilotRecordDeleted:
+		break;
+	case GnomePilotRecordNew:
+	case GnomePilotRecordModified:
+		local->ical->pilot_status = ICAL_PILOT_SYNC_MOD;
+		break;	  
+	}
+	
+	if (status == GnomePilotRecordDeleted) {
+		success = cal_client_remove_object (ctxt->client, local->ical->uid);
+	} else {
+		success = cal_client_update_object (ctxt->client, local->ical);
+		cal_client_update_pilot_id (ctxt->client, local->ical->uid,
+					    local->local.ID,
+					    local->ical->pilot_status);
+	}
+
+	if (! success) {
+		WARN (_("Error while communicating with address server"));
+	}
+	
+        return 0;
+}
+
+static gint
+set_archived (GnomePilotConduitStandardAbs *conduit,
+	      GCalLocalRecord *local,
+	      gint archived,
+	      GCalConduitContext *ctxt)
+{
+	LOG ("entering set_archived");
+
+	g_return_val_if_fail(local!=NULL,-1);
+	g_assert(local->ical!=NULL);
+
+	local->local.archived = archived;
+	update_address_entry_in_repository (conduit, local->ical, ctxt);
+        return 0;
+}
+
+static gint
+set_pilot_id (GnomePilotConduitStandardAbs *conduit,
+	      GCalLocalRecord *local,
+	      guint32 ID,
+	      GCalConduitContext *ctxt)
+{
+	LOG ("entering set_pilot_id(id=%d)",ID);
+
+	g_return_val_if_fail(local!=NULL,-1);
+	g_assert(local->ical!=NULL);
+
+	local->local.ID = ID;
+	local->ical->pilot_id = ID;
+
+	cal_client_update_pilot_id (ctxt->client,
+				    local->ical->uid,
+				    local->local.ID,
+				    local->ical->pilot_status);
+
+        return 0;
+}
+
+static gint
+transmit (GnomePilotConduitStandardAbs *conduit,
+	  GCalLocalRecord *local,
+	  PilotRecord **remote,
+	  GCalConduitContext *ctxt)
+{
+#if 0
+	PilotRecord *p;
+	
+	LOG ("entering transmit");
+
+	g_return_val_if_fail(local!=NULL,-1);
+	g_return_val_if_fail(remote!=NULL,-1);
+	g_assert(local->ical!=NULL);
+
+	p = g_new0(PilotRecord,1);
+
+	p->ID = local->local.ID;
+	p->attr = local->local.attr;
+	p->archived = local->local.archived;
+	p->secret = local->local.secret;
+
+	local->address = g_new0(struct Address,1);
+
+	local->address->indefinite = 0; /* FIX ME */
+	local->address->due = *localtime (&local->ical->dtend);
+	local->address->priority = local->ical->priority;
+
+	if (local->ical->completed > 0)
+		local->address->complete = 1; /* FIX ME */
+
+	/* STOP: don't replace these with g_strdup, since free_Address
+	   uses free to deallocte */
+	local->address->description = 
+		local->ical->summary==NULL?NULL:strdup(local->ical->summary);
+	local->address->note = 
+		local->ical->comment==NULL?NULL:strdup(local->ical->comment);
+
+	printf ("transmitting address to pilot [%s] complete=%d/%ld\n",
+		local->ical->summary==NULL?"NULL":local->ical->summary,
+		local->address->complete, local->ical->completed);
+
+	/* Generate pilot record structure */
+	p->record = g_new0(char,0xffff);
+	p->length = pack_Address(local->address,p->record,0xffff);
+
+	*remote = p;
+
+#endif /* 0 */
+
+	return 0;
+}
+
+static gint
+free_transmit (GnomePilotConduitStandardAbs *conduit,
+	       GCalLocalRecord *local,
+	       PilotRecord **remote,
+	       GCalConduitContext *ctxt)
+{
+	LOG ("entering free_transmit");
+
+	g_return_val_if_fail(local!=NULL,-1);
+	g_return_val_if_fail(remote!=NULL,-1);
+
+	free_Address(local->address);
+	g_free((*remote)->record);
+	*remote = NULL;
+        return 0;
+}
+
+static gint
+compare (GnomePilotConduitStandardAbs *conduit,
+	    GCalLocalRecord *local,
+	    PilotRecord *remote,
+	    GCalConduitContext *ctxt)
+{
+#if 0
+	/* used by the quick compare */
+	PilotRecord *remoteOfLocal;
+	int err;
+	int retval;
+
+	g_message ("entering compare");
+	printf ("entering compare\n");
+
+	g_return_val_if_fail (local!=NULL,-1);
+	g_return_val_if_fail (remote!=NULL,-1);
+
+	err = transmit(conduit,local,&remoteOfLocal,ctxt);
+	if (err != 0) return err;
+
+	retval = 0;
+	if (remote->length == remoteOfLocal->length) {
+		if (memcmp(remoteOfLocal->record,remote->record,remote->length)!=0) {
+			g_message("compare failed on contents");
+			printf ("compare failed on contents\n");
+			retval = 1;
+
+			/* debug spew */
+			{
+				struct Address foolocal;
+				struct Address fooremote;
+
+				unpack_Address (&foolocal,
+					     remoteOfLocal->record,
+					     remoteOfLocal->length);
+				unpack_Address (&fooremote,
+					     remote->record,
+					     remote->length);
+
+				printf (" local:[%d %ld %d %d '%s' '%s']\n",
+					foolocal.indefinite,
+					mktime (& foolocal.due),
+					foolocal.priority,
+					foolocal.complete,
+					foolocal.description,
+					foolocal.note);
+
+				printf ("remote:[%d %ld %d %d '%s' '%s']\n",
+					fooremote.indefinite,
+					mktime (& fooremote.due),
+					fooremote.priority,
+					fooremote.complete,
+					fooremote.description,
+					fooremote.note);
+			}
+		}
+	} else {
+		g_message("compare failed on length");
+		printf("compare failed on length\n");
+		retval = 1;
+	}
+
+	free_transmit(conduit,local,&remoteOfLocal,ctxt);	
+	return retval;
+#endif /* 0 */
+	return 0;
+}
+
+static gint
+compare_backup (GnomePilotConduitStandardAbs *conduit,
+		GCalLocalRecord *local,
+		PilotRecord *remote,
+		GCalConduitContext *ctxt)
+{
+	LOG ("entering compare_backup");
+
+	g_return_val_if_fail(local!=NULL,-1);
+	g_return_val_if_fail(remote!=NULL,-1);
+
+        return -1;
+}
+
+
+static gint
+delete_all (GnomePilotConduitStandardAbs *conduit,
+	    GCalConduitContext *ctxt)
+{
+	GSList *events,*it;
+	gboolean error;
+	gboolean success;
+
+	events = get_address_objects (conduit, &error, ctxt);
+
+	if (error == FALSE) return -1;
+	for (it=events; it; it = g_slist_next (it)) {
+		success = cal_client_remove_object (ctxt->client, it->data);
+
+		if (!success)
+			INFO ("Object did not exist");
+
+		g_free (it->data);
+	}
+
+	g_slist_free (events);
+        return -1;
+}
+
+
+GnomePilotConduit *
+conduit_get_gpilot_conduit (guint32 pilotId)
+{
+	GtkObject *retval;
+	GCalConduitCfg *cfg;
+	GCalConduitContext *ctxt;
+
+	printf ("in address's conduit_get_gpilot_conduit\n");
+
+	retval = gnome_pilot_conduit_standard_abs_new ("AddressDB", 0x746F646F);
+	g_assert (retval != NULL);
+	gnome_pilot_conduit_construct(GNOME_PILOT_CONDUIT(retval),"AddressConduit");
+
+	gcalconduit_load_configuration(&cfg,pilotId);
+	gtk_object_set_data(retval,"addressconduit_cfg",cfg);
+
+	gcalconduit_new_context(&ctxt,cfg);
+	gtk_object_set_data(GTK_OBJECT(retval),"addressconduit_context",ctxt);
+
+	gtk_signal_connect (retval, "match_record", (GtkSignalFunc) match_record, ctxt);
+	gtk_signal_connect (retval, "free_match", (GtkSignalFunc) free_match, ctxt);
+	gtk_signal_connect (retval, "archive_local", (GtkSignalFunc) archive_local, ctxt);
+	gtk_signal_connect (retval, "archive_remote", (GtkSignalFunc) archive_remote, ctxt);
+	gtk_signal_connect (retval, "store_remote", (GtkSignalFunc) store_remote, ctxt);
+	gtk_signal_connect (retval, "clear_status_archive_local", (GtkSignalFunc) clear_status_archive_local, ctxt);
+	gtk_signal_connect (retval, "iterate", (GtkSignalFunc) iterate, ctxt);
+	gtk_signal_connect (retval, "iterate_specific", (GtkSignalFunc) iterate_specific, ctxt);
+	gtk_signal_connect (retval, "purge", (GtkSignalFunc) purge, ctxt);
+	gtk_signal_connect (retval, "set_status", (GtkSignalFunc) set_status, ctxt);
+	gtk_signal_connect (retval, "set_archived", (GtkSignalFunc) set_archived, ctxt);
+	gtk_signal_connect (retval, "set_pilot_id", (GtkSignalFunc) set_pilot_id, ctxt);
+	gtk_signal_connect (retval, "compare", (GtkSignalFunc) compare, ctxt);
+	gtk_signal_connect (retval, "compare_backup", (GtkSignalFunc) compare_backup, ctxt);
+	gtk_signal_connect (retval, "free_transmit", (GtkSignalFunc) free_transmit, ctxt);
+	gtk_signal_connect (retval, "delete_all", (GtkSignalFunc) delete_all, ctxt);
+	gtk_signal_connect (retval, "transmit", (GtkSignalFunc) transmit, ctxt);
+	gtk_signal_connect (retval, "pre_sync", (GtkSignalFunc) pre_sync, ctxt);
+
+	return GNOME_PILOT_CONDUIT (retval);
+}
+
+void
+conduit_destroy_gpilot_conduit (GnomePilotConduit *conduit)
+{ 
+        GCalConduitCfg *cc;
+	GCalConduitContext *ctxt;
+
+        cc = GET_GCALCONFIG(conduit);
+	ctxt = GET_GCALCONTEXT(conduit);
+
+	if (ctxt->client != NULL) {
+		gtk_object_unref (GTK_OBJECT (ctxt->client));
+	}
+
+        gcalconduit_destroy_configuration (&cc);
+
+	gcalconduit_destroy_context (&ctxt);
+
+	gtk_object_destroy (GTK_OBJECT (conduit));
+}
diff --git a/addressbook/conduit/address-conduit.h b/addressbook/conduit/address-conduit.h
new file mode 100644
index 0000000000..ec22e6631c
--- /dev/null
+++ b/addressbook/conduit/address-conduit.h
@@ -0,0 +1,87 @@
+/* -*- Mode: C; tab-width: 8; indent-tabs-mode: t; c-basic-offset: 8 -*- */
+
+#ifndef __ADDRESS_CONDUIT_H__
+#define __ADDRESS_CONDUIT_H__
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+#include <gnome.h>
+#include <pi-address.h>
+#include <gpilotd/gnome-pilot-conduit.h>
+#include <gpilotd/gnome-pilot-conduit-standard-abs.h>
+#include <cal-client/cal-client.h>
+#include <cal-util/calobj.h>
+#include <cal-util/timeutil.h>
+
+#ifdef USING_OAF
+#include <liboaf/liboaf.h>
+#else
+#include <libgnorba/gnorba.h>
+#endif
+
+
+/* This is the local record structure for the GnomeCal conduit. */
+typedef struct _GCalLocalRecord GCalLocalRecord;
+struct _GCalLocalRecord {
+	/* The stuff from gnome-pilot-conduit-standard-abs.h
+	   Must be first in the structure, or instances of this
+	   structure cannot be used by gnome-pilot-conduit-standard-abs.
+	*/
+	LocalRecord local;
+	/* The corresponding iCal object, as found by GnomeCal. */
+	iCalObject *ical;
+        /* pilot-link address structure, used for implementing Transmit. */	
+	struct Address *address;
+};
+#define GCAL_LOCALRECORD(s) ((GCalLocalRecord*)(s))
+
+/* This is the configuration of the GnomeCal conduit. */
+typedef struct _GCalConduitCfg GCalConduitCfg;
+struct _GCalConduitCfg {
+	gboolean open_secret;
+	guint32 pilotId;
+	GnomePilotConduitSyncType  sync_type;   /* only used by capplet */
+};
+#define GET_GCALCONFIG(c) ((GCalConduitCfg*)gtk_object_get_data(GTK_OBJECT(c),"addressconduit_cfg"))
+
+/* This is the context for all the GnomeCal conduit methods. */
+typedef struct _GCalConduitContext GCalConduitContext;
+struct _GCalConduitContext {
+	struct AddressAppInfo ai;
+	GCalConduitCfg *cfg;
+	CalClient *client;
+	CORBA_Environment ev;
+	CORBA_ORB orb;
+	gboolean address_load_tried;
+	gboolean address_load_success;
+
+	char *address_file;
+};
+#define GET_GCALCONTEXT(c) ((GCalConduitContext*)gtk_object_get_data(GTK_OBJECT(c),"addressconduit_context"))
+
+
+/* Given a GCalConduitCfg*, allocates the structure and 
+   loads the configuration data for the given pilot.
+   this is defined in the header file because it is used by
+   both address-conduit and address-conduit-control-applet,
+   and we don't want to export any symbols we don't have to. */
+static void 
+gcalconduit_load_configuration(GCalConduitCfg **c,
+			       guint32 pilotId) 
+{
+	gchar prefix[256];
+	g_snprintf(prefix,255,"/gnome-pilot.d/address-conduit/Pilot_%u/",pilotId);
+	
+	*c = g_new0(GCalConduitCfg,1);
+	g_assert(*c != NULL);
+	gnome_config_push_prefix(prefix);
+	(*c)->open_secret = gnome_config_get_bool("open_secret=FALSE");
+	(*c)->sync_type = GnomePilotConduitSyncTypeCustom; /* set in capplets main */
+	gnome_config_pop_prefix();
+	
+	(*c)->pilotId = pilotId;
+}
+
+
+#endif __ADDRESS_CONDUIT_H__ 
diff --git a/addressbook/conduit/address.conduit.in b/addressbook/conduit/address.conduit.in
new file mode 100644
index 0000000000..3a0416fac8
--- /dev/null
+++ b/addressbook/conduit/address.conduit.in
@@ -0,0 +1,8 @@
+<gnome-pilot-conduit version="1.0">
+<conduit id="address_conduit" type="shlib" location="@prefix@/lib/gnome-pilot/conduits/libaddress_conduit.so"/>
+<name value="address"/>
+<conduit-attribute name="description" value="Synchronizes with Evolution"/>
+<conduit-attribute name="default-synctype" value="synchronize"/>
+<conduit-attribute name="icon" value="@prefix@/share/pixmaps/gnome-calendar-conduit.png"/>
+<conduit-attribute name="settings" value="TRUE"/>
+</gnome-pilot-conduit>