/* -*- 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));
}
