int main(int argc, const char *argv[])
{
int db,
sd = -1,
i,
l,
category,
po_err = -1,
replace_category = 0;
char
*category_name = NULL,
*expenseType = NULL,
*paymentType = NULL;
size_t size;
int found;
unsigned char buf[0xffff];
unsigned char *b;
pi_buffer_t *appblock;
struct PilotUser User;
struct ExpenseAppInfo eai;
struct Expense theExpense;
poptContext po;
struct poptOption options[] = {
USERLAND_RESERVED_OPTIONS
{"ptype", 't', POPT_ARG_STRING, &paymentType, 0,"Payment type (Cash, Check, etc.)"},
{"etype", 'e', POPT_ARG_STRING, &expenseType, 0, "Expense type (Airfare, Hotel, etc.)"},
{"amount", 'a', POPT_ARG_STRING, &theExpense.amount, 0, "Payment amount"},
{"vendor", 'V', POPT_ARG_STRING, &theExpense.vendor, 0, "Expense vendor name (Joe's Restaurant)"},
{"city", 'i', POPT_ARG_STRING, &theExpense.city, 0, "Location/city for this expense entry"},
{"guests", 'g', POPT_ARG_STRING, &theExpense.attendees, 0, "Number of guests for this expense entry","NUMBER"},
{"note", 'n', POPT_ARG_STRING, &theExpense.note, 0, "Notes for this expense entry"},
{"category", 'c', POPT_ARG_STRING, &category_name, 0, "Install entry into this category", "CATEGORY" },
{"replace", 0, POPT_ARG_VAL, &replace_category, 1, "Replace all entries in category by this one"},
POPT_TABLEEND
};
/* Zero 'em out to be sure. */
theExpense.amount=theExpense.vendor=theExpense.city=
theExpense.attendees=theExpense.note = NULL ;
po = poptGetContext("pilot-install-expenses", argc, argv, options, 0);
poptSetOtherOptionHelp(po,"\n\n"
" Install Expense application entries to your Palm device\n\n"
" Example arguments:\n"
" %s -p /dev/pilot -c Unfiled -t Cash -e Meals -a 10.00 -V McDonalds \n"
" -g 21 -l \"San Francisco\" -N \"This is a note\"\n\n");
if (argc < 2) {
poptPrintUsage(po,stderr,0);
return 1;
}
while ((po_err = poptGetNextOpt(po)) >= 0) {
fprintf(stderr," ERROR: Unhandled option %d.\n",po_err);
return 1;
}
theExpense.type = etBus;
found = 0;
for (i = 0; expenseType && ExpenseTypeNames[i] != NULL; i++)
{
if (strcasecmp(expenseType, ExpenseTypeNames[i]) == 0)
{
theExpense.type = i;
found = 1;
break;
}
}
if (!found) {
fprintf(stderr," WARNING: Expense type '%s' not recognized, using 'Bus Fare'.\n",expenseType);
}
theExpense.payment = epCash;
found = 0;
for (i = 0; paymentType && ExpensePaymentNames[i] != NULL; i++)
{
if (strcasecmp(paymentType, ExpensePaymentNames[i]) == 0)
{
theExpense.payment = i;
found = 1;
break;
}
}
if (!found) {
fprintf(stderr," WARNING: Payment type '%s' not recognized, using 'Cash'.\n", paymentType);
}
if (replace_category && (!category_name)) {
fprintf(stderr,
" ERROR: category required when specifying replace\n");
return 1;
}
if (!(theExpense.amount || theExpense.vendor || theExpense.city ||
theExpense.attendees ||theExpense.note)) {
fprintf(stderr," ERROR: Must specify at least one of amount, vendor, city, attendees or note.\n");
return 1;
}
sd = plu_connect();
if (sd < 0)
goto error;
if (dlp_OpenConduit(sd) < 0)
goto error_close;
dlp_ReadUserInfo(sd, &User);
dlp_OpenConduit(sd);
/* Open the Expense's database, store access handle in db */
if (dlp_OpenDB(sd, 0, 0x80 | 0x40, Expense_DB, &db) < 0) {
fprintf(stderr," ERROR: Unable to open ExpenseDB on Palm.");
dlp_AddSyncLogEntry(sd, "Unable to open ExpenseDB.\n");
goto error_close;
}
appblock = pi_buffer_new(0xffff);
l = dlp_ReadAppBlock(sd, db, 0, 0xffff, appblock);
unpack_ExpenseAppInfo(&eai, appblock->data, l);
pi_buffer_free(appblock);
category = 0; /* unfiled */
if (category_name) {
category = plu_findcategory(&eai.category,category_name,
PLU_CAT_CASE_INSENSITIVE | PLU_CAT_WARN_UNKNOWN);
if (category < 0) {
goto error_close;
}
if (replace_category) {
dlp_DeleteCategory(sd, db, category);
}
}
theExpense.currency = 0;
if (!theExpense.amount) {
theExpense.amount = "";
}
if (!theExpense.vendor) {
theExpense.vendor = "";
}
if (!theExpense.city) {
theExpense.city = "";
}
if (!theExpense.attendees) {
theExpense.attendees = "";
}
if (!theExpense.note) {
theExpense.note = "";
}
b = buf;
/* Date */
*(b++) = 0xc3;
*(b++) = 0x45;
*(b++) = theExpense.type;
*(b++) = theExpense.payment;
*(b++) = theExpense.currency;
*(b++) = 0x00;
strcpy(b, theExpense.amount);
b += strlen(theExpense.amount) + 1;
strcpy(b, theExpense.vendor);
b += strlen(theExpense.vendor) + 1;
strcpy(b, theExpense.city);
b += strlen(theExpense.city) + 1;
strcpy(b, theExpense.attendees);
b += strlen(theExpense.attendees) + 1;
strcpy(b, theExpense.note);
b += strlen(theExpense.note) + 1;
size = b - buf;
dlp_WriteRecord(sd, (unsigned char)db, 0, 0, category,
(unsigned char *)buf, size, 0);
/* Close the database */
dlp_CloseDB(sd, db);
/* Tell the user who it is, with a different PC id. */
User.lastSyncPC = 0x00010000;
User.successfulSyncDate = time(NULL);
User.lastSyncDate = User.successfulSyncDate;
dlp_WriteUserInfo(sd, &User);
dlp_AddSyncLogEntry(sd, "Wrote expense entry to Palm.\n");
dlp_EndOfSync(sd, 0);
pi_close(sd);
poptFreeContext(po);
return 0;
error_close:
pi_close(sd);
error:
return -1;
}
int main(int argc, const char *argv[]) {
int c, /* switch */
db,
l,
sd = -1;
enum { mode_none, mode_read, mode_write, mode_delete_all, mode_delete }
run_mode = mode_none;
const char
*progname = argv[0];
char *defaultcategoryname = 0,
*deletecategory = 0,
*wrFilename = NULL,
*rdFilename = NULL,
buf[0xffff];
int writehuman = 0;
pi_buffer_t *appblock;
struct AddressAppInfo aai;
struct PilotUser User;
struct SysInfo info;
poptContext po;
struct poptOption options[] = {
USERLAND_RESERVED_OPTIONS
{"delete-all", 0 , POPT_ARG_NONE, NULL, mode_delete_all, "Delete all Palm records in all categories", NULL},
{"delimiter", 't', POPT_ARG_INT, &tabledelim, 0, "Include category, use delimiter (3=tab, 2=;, 1=,)", "<delimeter>"},
{"delete-category", 'd', POPT_ARG_STRING, &deletecategory,'d', "Delete old Palm records in <category>", "category"},
{"category", 'c', POPT_ARG_STRING, &defaultcategoryname, 0, "Category to install to", "category"},
{"augment", 'a', POPT_ARG_NONE, &augment, 0, "Augment records with additional information", NULL},
{"read", 'r', POPT_ARG_STRING, &rdFilename, 'r', "Read records from <file> and install them to Palm", "file"},
{"write", 'w', POPT_ARG_STRING, &wrFilename, 'w', "Get records from Palm and write them to <file>", "file"},
{"human-readable",'C', POPT_ARG_NONE, &writehuman, 0, "Write generic human-readable output instead of CSV", NULL},
POPT_TABLEEND
};
const char *mode_error = " ERROR: Specify exactly one of read, write, delete or delete all.\n";
po = poptGetContext("pilot-addresses", argc, argv, options, 0);
poptSetOtherOptionHelp(po,"\n\n"
" Reads addresses from a file and installs on the Palm, or\n"
" writes addresses from the Palm to a file.\n\n"
" Provide exactly one of --read or --write.\n\n");
plu_popt_alias(po,"delall",0,"--bad-option --delete-all");
plu_popt_alias(po,"delcat",0,"--bad-option --delete-category");
plu_popt_alias(po,"install",0,"--bad-option --category");
/* Useful alias */
plu_popt_alias(po,"no-csv",0,"--human-readable");
if (argc < 2) {
poptPrintUsage(po,stderr,0);
return 1;
}
while ((c = poptGetNextOpt(po)) >= 0) {
switch (c) {
/* These are the mode-setters. delete-all does it through
* popt hooks, since it doesn't take an argument.
*
* Special case is that you can mix -w and -d to write the
* file and then delete a category.
*/
case mode_delete_all :
if (run_mode != mode_none) {
fprintf(stderr,"%s",mode_error);
return 1;
}
run_mode = mode_delete_all;
break;
case 'r':
if (run_mode != mode_none) {
fprintf(stderr,"%s",mode_error);
return 1;
}
run_mode = mode_read;
break;
case 'w':
if ((run_mode != mode_none) && (run_mode != mode_delete)) {
fprintf(stderr,"%s",mode_error);
return 1;
}
run_mode = mode_write;
break;
case 'd':
if ((run_mode != mode_none) && (run_mode != mode_write)) {
fprintf(stderr,"%s",mode_error);
return 1;
}
run_mode = mode_delete;
break;
default:
fprintf(stderr," ERROR: Unhandled option %d.\n",c);
return 1;
}
}
if (c < -1)
plu_badoption(po,c);
if (mode_none == run_mode) {
fprintf(stderr,"%s",mode_error);
return 1;
}
/* The first implies that -t was given; the second that it wasn't,
so use default, and the third if handles weird values. */
if ((tabledelim < 0) || (tabledelim > sizeof(tabledelim))) {
fprintf(stderr," ERROR: Invalid delimiter number %d (use 0-%d).\n",
tabledelim,(int)(sizeof(tabledelim)));
return 1;
}
sd = plu_connect();
if (sd < 0)
goto error;
if (dlp_ReadUserInfo(sd, &User) < 0)
goto error_close;
if (dlp_ReadSysInfo(sd,&info) < 0) {
fprintf(stderr," ERROR: Could not read Palm System Information.\n");
return -1;
}
if (info.romVersion > 0x05003000) {
printf(" PalmOS 5.x (Garnet) and later devices are not currently supported by this\n"
" tool. The data format of the AddressBook has changed. The legacy format\n"
" is called \"Classic\" and PalmOS 5.x and later uses \"Extended\" databases\n"
" with a different structure. Your Palm has \"Contacts\", and this tool reads\n"
" the \"AddressBook\" database. (Found OS version: %x)\n\n"
" Due to this change, pilot-addresses and other tools must be rewritten to\n"
" compensate. Sorry about the inconvenience.\n\n", info.romVersion);
/* return -1; FIXME: Need to adjust this to clealy detect OS version and rewrite */
}
/* Open the AddressDB.pdb database, store access handle in db */
if (dlp_OpenDB(sd, 0, 0x80 | 0x40, "AddressDB", &db) < 0) {
puts("Unable to open AddressDB");
dlp_AddSyncLogEntry(sd, "Unable to open AddressDB.\n");
goto error_close;
}
appblock = pi_buffer_new(0xffff);
l = dlp_ReadAppBlock(sd, db, 0, 0xffff, appblock);
unpack_AddressAppInfo(&aai, appblock->data, l);
pi_buffer_free(appblock);
if (defaultcategoryname) {
defaultcategory =
plu_findcategory(&aai.category,defaultcategoryname,
PLU_CAT_CASE_INSENSITIVE | PLU_CAT_DEFAULT_UNFILED);
} else {
defaultcategory = 0; /* Unfiled */
}
switch(run_mode) {
FILE *f;
int i;
int old_quiet;
case mode_none:
/* impossible */
fprintf(stderr,"%s",mode_error);
break;
case mode_write:
/* FIXME - Must test for existing file first! DD 2002/03/18 */
if (strcmp(wrFilename,"-") == 0) {
f = stdout;
old_quiet = plu_quiet;
plu_quiet = 1;
} else {
f = fopen(wrFilename, "w");
}
if (f == NULL) {
sprintf(buf, "%s: %s", progname, wrFilename);
perror(buf);
goto error_close;
}
write_file(f, sd, db, &aai, writehuman);
if (f == stdout) {
plu_quiet = old_quiet;
}
if (deletecategory) {
dlp_DeleteCategory(sd, db,
plu_findcategory(&aai.category,deletecategory,PLU_CAT_CASE_INSENSITIVE | PLU_CAT_WARN_UNKNOWN));
}
if (f != stdout) {
fclose(f);
}
break;
case mode_read:
f = fopen(rdFilename, "r");
if (f == NULL) {
fprintf(stderr, "Unable to open input file");
fprintf(stderr, " '%s' (%s)\n\n",
rdFilename, strerror(errno));
fprintf(stderr, "Please make sure the file");
fprintf(stderr, "'%s' exists, and that\n",
rdFilename);
fprintf(stderr, "it is readable by this user");
fprintf(stderr, " before launching.\n\n");
goto error_close;
}
read_file(f, sd, db, &aai);
fclose(f);
break;
case mode_delete:
i = plu_findcategory (&aai.category,deletecategory,PLU_CAT_CASE_INSENSITIVE | PLU_CAT_WARN_UNKNOWN);
if (i>=0) {
dlp_DeleteCategory(sd, db, i);
}
break;
case mode_delete_all:
for (i = 0; i < 16; i++)
if (aai.category.name[i][0])
dlp_DeleteCategory(sd, db, i);
break;
}
/* Close the database */
dlp_CloseDB(sd, db);
/* Tell the user who it is, with a different PC id. */
User.lastSyncPC = 0x00010000;
User.successfulSyncDate = time(NULL);
User.lastSyncDate = User.successfulSyncDate;
dlp_WriteUserInfo(sd, &User);
if (run_mode == mode_read) {
dlp_AddSyncLogEntry(sd, "Wrote entries to Palm Address Book.\n");
} else if (run_mode == mode_write) {
dlp_AddSyncLogEntry(sd, "Successfully read Address Book from Palm.\n");
}
dlp_EndOfSync(sd, 0);
pi_close(sd);
return 0;
error_close:
pi_close(sd);
error:
return -1;
}
int main(int argc, const char *argv[])
{
int c, /* switch */
db,
sd = -1,
i,
read_todos = -1;
FILE *ical = NULL;
char cmd[255],
*ptext = NULL,
*icalfile = NULL,
*pubtext = NULL;
struct ToDoAppInfo tai;
pi_buffer_t *recbuf,
*appblock;
poptContext pc;
struct poptOption options[] = {
USERLAND_RESERVED_OPTIONS
{"datebook", 'd', POPT_ARG_VAL, &read_todos, 0,
"Datebook only, no ToDos", NULL},
{"pubtext", 't', POPT_ARG_STRING, &ptext, 0,
"Replace text of items not started with a bullet with <pubtext>",
"pubtext"},
{"file", 'f', POPT_ARG_STRING, &icalfile, 0,
"Write the ical formatted data to <file> (overwrites existing <file>)",
"file"},
POPT_TABLEEND
};
pc = poptGetContext("read-ical", argc, argv, options, 0);
poptSetOtherOptionHelp(pc,"\n\n"
" Dumps the DatebookDB and/or ToDo applications to ical format.\n"
" Requires the program 'ical'.\n\n");
if (argc < 2) {
poptPrintUsage(pc,stderr,0);
return 1;
}
while ((c = poptGetNextOpt(pc)) >= 0) {
fprintf(stderr," ERROR: Unhandled option %d.\n",c);
return 1;
}
if (c < -1) {
plu_badoption(pc,c);
return 1;
}
if (icalfile == NULL) {
fprintf(stderr, " ERROR: ical filename not specified. Please use the -f option.\n");
return 1;
}
sd = plu_connect();
if (sd < 0)
goto error;
unlink(icalfile);
sprintf(cmd, "ical -list -f - -calendar %s", icalfile);
ical = popen(cmd, "w");
if (ical == NULL) {
int e = errno;
fprintf(stderr," ERROR: cannot start communication with ical.\n"
" %s\n",strerror(e));
return 1;
}
fprintf(ical, "calendar cal $ical(calendar)\n");
if (dlp_OpenConduit(sd) < 0)
goto error_close;
if (read_todos) {
/* Open the ToDo database, store access handle in db */
if (dlp_OpenDB
(sd, 0, 0x80 | 0x40, "ToDoDB", &db) < 0) {
fprintf(stderr," ERROR: Unable to open ToDoDB on Palm.\n");
dlp_AddSyncLogEntry(sd, "Unable to open ToDoDB.\n");
goto error_close;
}
appblock = pi_buffer_new(0xffff);
dlp_ReadAppBlock(sd, db, 0, 0xffff, appblock);
unpack_ToDoAppInfo(&tai, appblock->data, appblock->used);
pi_buffer_free(appblock);
recbuf = pi_buffer_new (0xffff);
for (i = 0;; i++) {
int attr,
category;
char id_buf[255];
struct ToDo t;
recordid_t id_;
int len = dlp_ReadRecordByIndex(sd, db, i, recbuf, &id_, &attr, &category);
if (len < 0)
break;
/* Skip deleted records */
if ((attr & dlpRecAttrDeleted)
|| (attr & dlpRecAttrArchived))
continue;
unpack_ToDo(&t, recbuf, todo_v1);
fprintf(ical, "set n [notice]\n");
/* '\x95' is the "bullet" chcter */
fprintf(ical, "$n text %s\n", tclquote((pubtext && t.description[0] != '\x95') ? pubtext : t.description));
fprintf(ical, "$n date [date today]\n");
fprintf(ical, "$n todo 1\n");
fprintf(ical, "$n option Priority %d\n", t.priority);
sprintf(id_buf, "%lx", id_);
fprintf(ical, "$n option PilotRecordId %s\n", id_buf);
fprintf(ical, "$n done %d\n", t.complete ? 1 : 0);
fprintf(ical, "cal add $n\n");
free_ToDo(&t);
}
pi_buffer_free(recbuf);
/* Close the database */
dlp_CloseDB(sd, db);
dlp_AddSyncLogEntry(sd, "Successfully read todos from Palm.\nThank you for using pilot-link.\n");
}
/* Open the Datebook's database, store access handle in db */
if (dlp_OpenDB
(sd, 0, 0x80 | 0x40, "DatebookDB", &db) < 0) {
fprintf(stderr," ERROR: Unable to open DatebookDB on Palm.\n");
dlp_AddSyncLogEntry(sd, "Unable to open DatebookDB.\n");
goto error_close;
}
recbuf = pi_buffer_new (0xffff);
for (i = 0;; i++) {
int j,
attr;
char id_buf[255];
struct Appointment a;
recordid_t id_;
int len =
dlp_ReadRecordByIndex(sd, db, i, recbuf, &id_, &attr, 0);
if (len < 0)
break;
/* Skip deleted records */
if ((attr & dlpRecAttrDeleted)
|| (attr & dlpRecAttrArchived))
continue;
unpack_Appointment(&a, recbuf, datebook_v1);
if (a.event) {
fprintf(ical, "set i [notice]\n");
} else {
int start,
end;
fprintf(ical, "set i [appointment]\n");
start =
a.begin.tm_hour * 60 +
a.begin.tm_min;
end =
a.end.tm_hour * 60 +
a.end.tm_min;
fprintf(ical, "$i starttime %d\n", start);
fprintf(ical, "$i length %d\n", end - start);
}
/* Don't hilight private (secret) records */
if (attr & dlpRecAttrSecret) {
fprintf(ical, "$i hilite never\n");
}
/* Handle alarms */
if (a.alarm) {
if (a.event) {
if (a.advanceUnits == 2) {
fprintf(ical, "$i earlywarning %d\n", a.advance);
} else {
printf("Minute or hour alarm on untimed event ignored: %s\n", a.description);
}
} else {
switch (a.advanceUnits) {
case 0:
fprintf(ical, "$i alarms { %d }\n", a.advance);
break;
case 1:
fprintf(ical, "$i alarms { %d }\n", a.advance * 60);
break;
case 2:
fprintf(ical, "$i earlywarning %d\n", a.advance);
break;
}
}
}
/* '\x95' is the "bullet" chcter */
fprintf(ical, "$i text %s\n",
tclquote((pubtext
&& a.description[0] !=
'\x95') ? pubtext : a.
description));
fprintf(ical,
"set begin [date make %d %d %d]\n",
a.begin.tm_mday,
a.begin.tm_mon + 1,
a.begin.tm_year + 1900);
if (a.repeatFrequency) {
if (a.repeatType == repeatDaily) {
fprintf(ical,
"$i dayrepeat %d $begin\n", a.repeatFrequency);
} else if (a.repeatType == repeatMonthlyByDate) {
fprintf(ical, "$i month_day %d $begin %d\n", a.begin.tm_mon + 1, a.repeatFrequency);
} else if (a.repeatType == repeatMonthlyByDay) {
if (a.repeatDay >= domLastSun) {
fprintf(ical, "$i month_last_week_day %d 1 $begin %d\n", a.repeatDay % 7 + 1, a.repeatFrequency);
} else {
fprintf(ical, "$i month_week_day %d %d $begin %d\n", a.repeatDay % 7 + 1, a.repeatDay / 7 + 1, a.repeatFrequency);
}
} else if (a.repeatType == repeatWeekly) {
/*
* Handle the case where the user said weekly repeat, but
* really meant daily repeat every n*7 days. Note: We can't
* do days of the week and a repeat-frequency > 1, so do the
* best we can and go on.
*/
if (a.repeatFrequency > 1) {
int ii, found;
for (ii = 0, found = 0; ii < 7; ii++) {
if (a.repeatDays [ii])
found++;
}
if (found > 1) {
fprintf(stderr," WARNING: Incomplete translation of %s\n", a.description);
}
fprintf(ical, "$i dayrepeat %d $begin\n", a.repeatFrequency * 7);
} else {
int ii;
fprintf(ical, "$i weekdays ");
for (ii = 0; ii < 7; ii++)
if (a.repeatDays [ii])
fprintf(ical, "%d ", ii + 1);
fprintf(ical, "\n");
}
} else if (a.repeatType == repeatYearly) {
fprintf(ical, "$i monthrepeat %d $begin\n", 12 * a.repeatFrequency);
}
fprintf(ical, "$i start $begin\n");
if (!a.repeatForever)
fprintf(ical,
"$i finish [date make %d %d %d]\n",
a.repeatEnd.tm_mday, a.repeatEnd.tm_mon + 1, a.repeatEnd.tm_year + 1900);
if (a.exceptions)
for (j = 0; j < a.exceptions; j++)
fprintf(ical, "$i deletion [date make %d %d %d]\n", a.exception[j].tm_mday, a.exception[j].tm_mon + 1, a.exception[j].tm_year + 1900);
} else
fprintf(ical, "$i date $begin\n");
sprintf(id_buf, "%lx", id_);
fprintf(ical, "$i option PilotRecordId %s\n", id_buf);
fprintf(ical, "cal add $i\n");
free_Appointment(&a);
}
pi_buffer_free (recbuf);
fprintf(ical, "cal save [cal main]\n");
fprintf(ical, "exit\n");
pclose(ical);
/* Close the database */
dlp_CloseDB(sd, db);
dlp_AddSyncLogEntry(sd, "read-ical successfully read Datebook from Palm.\n"
"Thank you for using pilot-link.\n");
dlp_EndOfSync(sd, 0);
pi_close(sd);
return 0;
error_close:
if (ical) {
/* explicitly do NOT save on failure. since we've already unlinked
the original ical file, we've still destroyed something. */
fprintf(ical, "exit\n");
pclose(ical);
}
pi_close(sd);
error:
return -1;
}
/* Pilot syncing callbacks */
static gint
pre_sync (GnomePilotConduit *conduit,
GnomePilotDBInfo *dbi,
EAddrConduitContext *ctxt)
{
GnomePilotConduitSyncAbs *abs_conduit;
EBookQuery *query;
GList *l;
int len;
char *filename;
char *change_id;
char *auth;
gint num_records, add_records = 0, mod_records = 0, del_records = 0;
#ifdef PILOT_LINK_0_12
pi_buffer_t *buffer;
#else
unsigned char *buf;
#endif
abs_conduit = GNOME_PILOT_CONDUIT_SYNC_ABS (conduit);
LOG (g_message ( "---------------------------------------------------------\n" ));
LOG (g_message ( "pre_sync: Addressbook Conduit v.%s", CONDUIT_VERSION ));
/* g_message ("Addressbook Conduit v.%s", CONDUIT_VERSION); */
ctxt->dbi = dbi;
if (ctxt->cfg->source) {
ctxt->ebook = e_book_new (ctxt->cfg->source, NULL);
} else {
ctxt->ebook = e_book_new_default_addressbook (NULL);
}
auth = (gchar *)e_source_get_property (ctxt->cfg->source, "auth");
if (auth) {
LOG (g_message ("contacts needs authentication\n"));
g_signal_connect (ctxt->ebook, "auth_required",
G_CALLBACK (addressbook_authenticate), ctxt->cfg->source);
}
if (!ctxt->ebook || !e_book_open (ctxt->ebook, TRUE, NULL)) {
WARN(_("Could not load addressbook"));
gnome_pilot_conduit_error (conduit, _("Could not load addressbook"));
return -1;
}
/* Load the uid <--> pilot id mappings */
filename = map_name (ctxt);
e_pilot_map_read (filename, &ctxt->map);
g_free (filename);
/* Get a list of all contacts */
if (!(query = e_book_query_any_field_contains (""))) {
LOG (g_warning ("Failed to get EBookQuery"));
return -1;
}
if (!e_book_get_contacts (ctxt->ebook, query, &ctxt->cards, NULL)) {
LOG (g_warning ("Failed to get Contacts"));
e_book_query_unref (query);
return -1;
}
e_book_query_unref (query);
/* Count and hash the changes */
change_id = g_strdup_printf ("pilot-sync-evolution-addressbook-%d", ctxt->cfg->pilot_id);
if (!e_book_get_changes (ctxt->ebook, change_id, &ctxt->changed, NULL))
return -1;
ctxt->changed_hash = g_hash_table_new (g_str_hash, g_str_equal);
g_free (change_id);
for (l = ctxt->changed; l != NULL; l = l->next) {
EBookChange *ebc = l->data;
const char *uid;
uid = e_contact_get_const (ebc->contact, E_CONTACT_UID);
if (!e_pilot_map_uid_is_archived (ctxt->map, uid)) {
g_hash_table_insert (ctxt->changed_hash, g_strdup (uid), ebc);
switch (ebc->change_type) {
case E_BOOK_CHANGE_CARD_ADDED:
add_records++;
break;
case E_BOOK_CHANGE_CARD_MODIFIED:
mod_records++;
break;
case E_BOOK_CHANGE_CARD_DELETED:
del_records++;
break;
}
} else if (ebc->change_type == E_BOOK_CHANGE_CARD_DELETED) {
e_pilot_map_remove_by_uid (ctxt->map, uid);
}
}
/* Set the count information */
num_records = g_list_length (ctxt->cards);
gnome_pilot_conduit_sync_abs_set_num_local_records(abs_conduit, num_records);
gnome_pilot_conduit_sync_abs_set_num_new_local_records (abs_conduit, add_records);
gnome_pilot_conduit_sync_abs_set_num_updated_local_records (abs_conduit, mod_records);
gnome_pilot_conduit_sync_abs_set_num_deleted_local_records(abs_conduit, del_records);
#ifdef PILOT_LINK_0_12
buffer = pi_buffer_new(DLP_BUF_SIZE);
if(buffer == NULL){
return pi_set_error(dbi->pilot_socket, PI_ERR_GENERIC_MEMORY);
}
len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0,
DLP_BUF_SIZE, buffer);
#else
buf = (unsigned char*)g_malloc (0xffff);
len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0,
(unsigned char *)buf, 0xffff);
#endif
if (len < 0) {
WARN (_("Could not read pilot's Address application block"));
WARN ("dlp_ReadAppBlock(...) = %d", len);
gnome_pilot_conduit_error (conduit,
_("Could not read pilot's Address application block"));
return -1;
}
#ifdef PILOT_LINK_0_12
unpack_AddressAppInfo (&(ctxt->ai), buffer->data, len);
pi_buffer_free (buffer);
#else
unpack_AddressAppInfo (&(ctxt->ai), buf, len);
g_free (buf);
#endif
check_for_slow_setting (conduit, ctxt);
if (ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyToPilot
|| ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyFromPilot)
ctxt->map->write_touched_only = TRUE;
return 0;
}
/* Pilot syncing callbacks */
static gint
pre_sync (GnomePilotConduit *conduit,
GnomePilotDBInfo *dbi,
EMemoConduitContext *ctxt)
{
GnomePilotConduitSyncAbs *abs_conduit;
GList *l;
int len;
unsigned char *buf;
char *filename, *change_id;
icalcomponent *icalcomp;
gint num_records, add_records = 0, mod_records = 0, del_records = 0;
#ifdef PILOT_LINK_0_12
pi_buffer_t * buffer;
#endif
abs_conduit = GNOME_PILOT_CONDUIT_SYNC_ABS (conduit);
LOG (g_message ( "---------------------------------------------------------\n" ));
LOG (g_message ( "pre_sync: Memo Conduit v.%s", CONDUIT_VERSION ));
g_message ("Memo Conduit v.%s", CONDUIT_VERSION);
ctxt->dbi = dbi;
ctxt->client = NULL;
if (start_calendar_server (ctxt) != 0) {
WARN(_("Could not start evolution-data-server"));
gnome_pilot_conduit_error (conduit, _("Could not start evolution-data-server"));
return -1;
}
/* Get the timezone */
ctxt->timezone = get_default_timezone ();
if (ctxt->timezone == NULL)
return -1;
LOG (g_message ( " Using timezone: %s", icaltimezone_get_tzid (ctxt->timezone) ));
/* Set the default timezone on the backend. */
if (ctxt->timezone && !e_cal_set_default_timezone (ctxt->client, ctxt->timezone, NULL))
return -1;
/* Get the default component */
if (!e_cal_get_default_object (ctxt->client, &icalcomp, NULL))
return -1;
ctxt->default_comp = e_cal_component_new ();
if (!e_cal_component_set_icalcomponent (ctxt->default_comp, icalcomp)) {
g_object_unref (ctxt->default_comp);
icalcomponent_free (icalcomp);
return -1;
}
/* Load the uid <--> pilot id map */
filename = map_name (ctxt);
e_pilot_map_read (filename, &ctxt->map);
g_free (filename);
/* Get the local database */
if (!e_cal_get_object_list_as_comp (ctxt->client, "#t", &ctxt->comps, NULL))
return -1;
/* Count and hash the changes */
change_id = g_strdup_printf ("pilot-sync-evolution-memo-%d", ctxt->cfg->pilot_id);
if (!e_cal_get_changes (ctxt->client, change_id, &ctxt->changed, NULL))
return -1;
ctxt->changed_hash = g_hash_table_new (g_str_hash, g_str_equal);
g_free (change_id);
for (l = ctxt->changed; l != NULL; l = l->next) {
ECalChange *ccc = l->data;
const char *uid;
e_cal_component_get_uid (ccc->comp, &uid);
if (!e_pilot_map_uid_is_archived (ctxt->map, uid)) {
g_hash_table_insert (ctxt->changed_hash, g_strdup (uid), ccc);
switch (ccc->type) {
case E_CAL_CHANGE_ADDED:
add_records++;
break;
case E_CAL_CHANGE_MODIFIED:
mod_records++;
break;
case E_CAL_CHANGE_DELETED:
del_records++;
break;
}
} else if (ccc->type == E_CAL_CHANGE_DELETED) {
e_pilot_map_remove_by_uid (ctxt->map, uid);
}
}
/* Set the count information */
num_records = g_list_length (ctxt->comps);
gnome_pilot_conduit_sync_abs_set_num_local_records(abs_conduit, num_records);
gnome_pilot_conduit_sync_abs_set_num_new_local_records (abs_conduit, add_records);
gnome_pilot_conduit_sync_abs_set_num_updated_local_records (abs_conduit, mod_records);
gnome_pilot_conduit_sync_abs_set_num_deleted_local_records(abs_conduit, del_records);
g_message("num_records: %d\nadd_records: %d\nmod_records: %d\ndel_records: %d\n",
num_records, add_records, mod_records, del_records);
#ifdef PILOT_LINK_0_12
buffer = pi_buffer_new(DLP_BUF_SIZE);
if(buffer == NULL){
pi_set_error(dbi->pilot_socket, PI_ERR_GENERIC_MEMORY);
return -1;
}
len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0,
DLP_BUF_SIZE,
buffer);
#else
buf = (unsigned char*)g_malloc (0xffff);
len = dlp_ReadAppBlock (dbi->pilot_socket, dbi->db_handle, 0,
(unsigned char *)buf, 0xffff);
#endif
if (len < 0) {
WARN (_("Could not read pilot's Memo application block"));
WARN ("dlp_ReadAppBlock(...) = %d", len);
gnome_pilot_conduit_error (conduit,
_("Could not read pilot's Memo application block"));
return -1;
}
#ifdef PILOT_LINK_0_12
buf = g_new0 (unsigned char,buffer->used);
memcpy(buf, buffer->data, buffer->used);
unpack_MemoAppInfo (&(ctxt->ai), buf, len);
pi_buffer_free(buffer);
#else
unpack_MemoAppInfo (&(ctxt->ai), buf, len);
#endif
g_free (buf);
lastDesktopUniqueID = 128;
check_for_slow_setting (conduit, ctxt);
if (ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyToPilot
|| ctxt->cfg->sync_type == GnomePilotConduitSyncTypeCopyFromPilot)
ctxt->map->write_touched_only = TRUE;
return 0;
}
int
main (int argc, char **argv)
{
int sd;
int result;
struct SysInfo s;
struct PilotUser u1, u2;
struct NetSyncInfo n1, n2;
struct CardInfo c;
struct DBInfo dbi;
struct DBSizeInfo dbsi;
unsigned long romVersion;
time_t t1, t2;
int handle;
unsigned char pref1[256], pref2[256];
unsigned char ablock1[256];
unsigned char sblock1[256];
unsigned char ires1[256];
unsigned char dres1[256];
unsigned char record1[256], record2[256], record3[256];
recordid_t rid1, rid2, rid3, rlist[4];
int index, id_, count;
unsigned long type;
int cardno;
int i;
pi_buffer_t *record4,
*dres2,
*ires2,
*appblock;
record4 = pi_buffer_new (sizeof(record1));
ires2 = pi_buffer_new (sizeof (ires1));
dres2 = pi_buffer_new (sizeof (dres1));
appblock = pi_buffer_new(256);
sd = pilot_connect (argv[1]);
t1 = time (NULL);
LOG((PI_DBG_USER, PI_DBG_LVL_INFO, "DLPTEST Starting at %s", ctime (&t1)));
/*********************************************************************
*
* Test: Open Conduit
*
* Direct Testing Functions:
* dlp_OpenConduit
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
result = dlp_OpenConduit (sd);
CHECK_RESULT(dlp_OpenConduit);
/*********************************************************************
*
* Test: System Information
*
* Direct Testing Functions:
* dlp_ReadSysInfo
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
result = dlp_ReadSysInfo (sd, &s);
CHECK_RESULT(dlp_ReadSysInfo);
/*********************************************************************
*
* Test: User Info
*
* Direct Testing Functions:
* dlp_WriteUserInfo
* dlp_ReadUserInfo
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
memset (&u1, '\0', sizeof (struct PilotUser));
memset (&u2, '\0', sizeof (struct PilotUser));
u1.passwordLength = 0;
strcpy (u1.username, "Test User");
strcpy (u1.password, "");
u1.userID = 500;
u1.viewerID = 5000;
u1.lastSyncPC = 111111;
u1.successfulSyncDate = time(NULL);
u1.lastSyncDate = time(NULL) + 100;
result = dlp_WriteUserInfo (sd, &u1);
CHECK_RESULT(dlp_WriteUserInfo);
result = dlp_ReadUserInfo (sd, &u2);
CHECK_RESULT(dlp_ReadUserInfo);
if (memcmp(&u1, &u2, sizeof(struct PilotUser) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST User info mismatch\n"));
goto error;
}
/*********************************************************************
*
* Test: Feature
*
* Direct Testing Functions:
* dlp_ReadFeature
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
romVersion = 0;
result = dlp_ReadFeature(sd, makelong("psys"), 1, &romVersion);
CHECK_RESULT(dlp_ReadFeature);
if (romVersion != s.romVersion) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Rom Version mismatch\n"));
goto error;
}
/*********************************************************************
*
* Test: Net Sync Info
*
* Direct Testing Functions:
* dlp_WriteNetSyncInfo
* dlp_ReadNetSyncInfo
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
#if DLP_1_1
memset (&n1, '\0', sizeof (struct NetSyncInfo));
memset (&n2, '\0', sizeof (struct NetSyncInfo));
n1.lanSync = 0;
strcpy (n1.hostName, "localhost");
strcpy (n1.hostAddress, "192.168.1.1");
strcpy (n1.hostSubnetMask, "255.255.255.0");
result = dlp_WriteNetSyncInfo (sd, &n1);
CHECK_RESULT(dlp_WriteNetSyncInfo);
result = dlp_ReadNetSyncInfo (sd, &n2);
CHECK_RESULT(dlp_ReadNetSyncInfo);
if (memcmp(&n1, &n2, sizeof(struct NetSyncInfo) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Net sync info mismatch\n"));
goto error;
}
#endif
/*********************************************************************
*
* Test: Time
*
* Direct Testing Functions:
* dlp_SetSysDateTime
* dlp_GetSysDateTime
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
t1 = time(NULL);
dlp_SetSysDateTime (sd, t1);
CHECK_RESULT(dlp_SetSysDateTime);
dlp_GetSysDateTime (sd, &t2);
CHECK_RESULT(dlp_GetSysDateTime);
if (t2 > t1 + 1) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST System Time Mismatch\n"));
goto error;
}
/*********************************************************************
*
* Test: Storage Information
*
* Direct Testing Functions:
* dlp_ReadStorageInfo
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
c.more = 1;
for (i = 0; c.more != 0; i++) {
result = dlp_ReadStorageInfo (sd, i, &c);
CHECK_RESULT(dlp_ReadStorageInfo);
}
/*********************************************************************
*
* Test: Database List
*
* Direct Testing Functions:
* dlp_ReadDBList
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
dbi.more = 1;
for (i = 0; dbi.more != 0; i++) {
result = dlp_ReadDBList (sd, 0, dlpDBListRAM | dlpDBListROM, i, record4);
CHECK_RESULT(dlp_ReadDBList);
memcpy(&dbi, record4->data, sizeof(struct DBInfo));
}
/*********************************************************************
*
* Test: Existing Database
*
* Direct Testing Functions:
* dlp_OpenDB
* dlp_CloseDB
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
result = dlp_OpenDB (sd, 0, dlpOpenReadWrite, "ToDoDB", &handle);
CHECK_RESULT(dlp_OpenDB);
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB);
/*********************************************************************
*
* Test: New Database
*
* Direct Testing Functions:
* dlp_CreateDB
* dlp_CloseDB
* dlp_DeleteDB
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
result = dlp_CreateDB (sd, CREATOR, DATA, 0, dlpDBFlagResource, 1, "TestResource", &handle);
CHECK_RESULT(dlp_CreateDB);
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB);
result = dlp_DeleteDB (sd, 0, "TestResource");
CHECK_RESULT(dlp_DeleteDB);
/*********************************************************************
*
* Test: Database Info and Searching
*
* Direct Testing Functions:
* dlp_SetDBInfo
* dlp_FindDBByName
* dlp_FindDBByOpenHandle
* dlp_FindDBByTypeCreator
*
* Indirect Testing Functions:
* dlp_CreateDB
* dlp_OpenDB
* dlp_ReadDBList
* dlp_CloseDB
* dlp_DeleteDB
*
*********************************************************************/
#if DLP_1_2
result = dlp_CreateDB (sd, CREATOR, DATA, 0, 0, 1, "TestRecord", &handle);
CHECK_RESULT(dlp_CreateDB);
result = dlp_SetDBInfo (sd, handle, dlpDBFlagBackup, dlpDBFlagCopyPrevention, 0, 0, 0, 0, 0, 0);
CHECK_RESULT(dlp_SetDBInfo);
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB);
result = dlp_OpenDB (sd, 0, dlpOpenReadWrite, "TestRecord", &handle);
CHECK_RESULT(dlp_OpenDB);
result = dlp_FindDBByOpenHandle (sd, handle, &cardno, NULL, &dbi, &dbsi);
CHECK_RESULT(dlp_FindDBByOpenHandle);
if (strcmp (dbi.name, "TestRecord") || !(dbi.flags & dlpDBFlagBackup)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Database info mismatch with openhandle\n"));
goto error;
}
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB);
result = dlp_FindDBByName (sd, 0, "TestRecord", NULL, NULL, &dbi, &dbsi);
CHECK_RESULT(dlp_FindDBByName);
if (strcmp (dbi.name, "TestRecord") || !(dbi.flags & dlpDBFlagBackup)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Database info mismatch with name\n"));
goto error;
}
result = dlp_FindDBByTypeCreator (sd, DATA, CREATOR, 1, 0, &cardno, NULL, NULL, &dbi, &dbsi);
CHECK_RESULT(dlp_FindDBByName);
if (strcmp (dbi.name, "TestRecord") || !(dbi.flags & dlpDBFlagBackup)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Database info mismatch with type/creator\n"));
goto error;
}
result = dlp_DeleteDB (sd, 0, "TestRecord");
CHECK_RESULT(dlp_DeleteDB);
#endif
/*********************************************************************
*
* Test: App Preference
*
* Direct Testing Functions:
* dlp_WriteAppPreference
* dlp_ReadAppPreference
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
memset (pref1, '\0', sizeof (pref1));
memset (pref2, '\0', sizeof (pref2));
pref1[9] = 'T';
pref2[10] = 'T';
result = dlp_WriteAppPreference (sd, CREATOR, 0, 1, 1, pref1, sizeof(pref1));
CHECK_RESULT(dlp_WriteAppPrefence);
result = dlp_ReadAppPreference (sd, CREATOR, 0, 1, sizeof(pref2), pref2, NULL, NULL);
CHECK_RESULT(dlp_ReadAppPreference);
if (memcmp(&pref1, &pref2, sizeof(pref1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Preference mismatch\n"));
goto error;
}
/*********************************************************************
*
* Test: Record
*
* Direct Testing Functions:
* dlp_WriteAppBlock
* dlp_ReadAppBlock
* dlp_WriteSortBlock
* dlp_ReadSortBlock
* dlp_WriteRecord
* dlp_ReadOpenDBInfo
* dlp_ReadRecordById
* dlp_ReadRecordByIndex
* dlp_ReadNextModifiedRec
* dlp_ReadNextRecInCategory
* dlp_ReadNextModifiedRecInCategory
* dlp_MoveCategory
* dlp_DeleteRecord
* dlp_DeleteCategory
* dlp_ResetDBIndex
*
* Indirect Testing Functions:
* dlp_CreateDB
* dlp_CloseDB
* dlp_DeleteDB
*
*********************************************************************/
memset (ablock1, '\0', sizeof (ablock1));
memset (sblock1, '\0', sizeof (sblock1));
memset (record1, '\0', sizeof (record1));
memset (record2, '\0', sizeof (record2));
memset (record3, '\0', sizeof (record3));
ablock1[3] = 'T';
sblock1[17] = 'T';
record1[32] = 'T';
record2[33] = 'T';
record3[34] = 'T';
result = dlp_CreateDB (sd, CREATOR, DATA, 0, 0, 1, "TestRecord", &handle);
CHECK_RESULT(dlp_CreateDB);
/* Write and read back an app block */
result = dlp_WriteAppBlock (sd, handle, ablock1, sizeof(ablock1));
CHECK_RESULT(dlp_WriteAppBlock);
result = dlp_ReadAppBlock (sd, handle, 0, sizeof(ablock1), appblock);
CHECK_RESULT(dlp_ReadAppBlock);
if (result != sizeof(ablock1) || memcmp(ablock1, appblock->data, sizeof(ablock1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST App block mismatch\n"));
goto error;
}
/* Write and read back a sort block */
result = dlp_WriteSortBlock (sd, handle, sblock1, sizeof(sblock1));
CHECK_RESULT(dlp_WriteSortBlock);
result = dlp_ReadSortBlock (sd, handle, 0, sizeof(sblock1), appblock);
CHECK_RESULT(dlp_ReadSortBlock);
if (result != sizeof(sblock1) || memcmp(sblock1, appblock->data, sizeof(sblock1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST App block mismatch\n"));
goto error;
}
/* Write some records out */
result = dlp_WriteRecord (sd, handle, 0, 0, 1, record1, sizeof(record1), &rid1);
CHECK_RESULT(dlp_WriteRecord);
result = dlp_WriteRecord (sd, handle, dlpRecAttrDirty, 0, 2, record2, sizeof(record2), &rid2);
CHECK_RESULT(dlp_WriteRecord);
result = dlp_WriteRecord (sd, handle, 0, 0, 3, record3, sizeof(record3), &rid3);
CHECK_RESULT(dlp_WriteRecord);
/* Get the db info */
result = dlp_ReadOpenDBInfo (sd, handle, &count);
CHECK_RESULT(dlp_ReadOpenDBInfo);
if (count != 3) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Read wrong open database info\n"));
goto error;
}
/* Get the id list */
result = dlp_ReadRecordIDList (sd, handle, 0, 0, 4, rlist, &count);
CHECK_RESULT(dlp_ReadRecordIDList);
if (count != 3) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Read wrong record id list length\n"));
goto error;
}
for (i = 0; i < 3; i++) {
if (rlist[i] != rid1 && rlist[i] != rid2 && rlist[i] != rid3) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Read wrong record id\n"));
goto error;
}
}
/* Try reading the records in various ways */
result = dlp_ReadRecordById (sd, handle, rid1, record4, &index, NULL, NULL);
CHECK_RESULT(dlp_ReadRecordById);
if (memcmp(record1, record4->data, sizeof(record1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Record by Id mismatch\n"));
goto error;
}
result = dlp_ReadRecordByIndex (sd, handle, index, record4, NULL, NULL, NULL);
CHECK_RESULT(dlp_ReadRecordByIndex);
if (memcmp(record1, record4->data, sizeof(record1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Record by index mismatch\n"));
goto error;
}
result = dlp_ReadNextModifiedRec (sd, handle, record4, NULL, NULL, NULL, NULL);
CHECK_RESULT(dlp_ReadNextModifiedRec);
if (memcmp(record2, record4->data, sizeof(record2) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Next modified record mismatch\n"));
goto error;
}
/* Reset because of the above next modified record call */
result = dlp_ResetDBIndex (sd, handle);
CHECK_RESULT(dlp_ResetDBIndex)
/* This is a DLP 1.1 call, but pilot-link has a 1.0 implementation */
result = dlp_ReadNextRecInCategory (sd, handle, 3, record4, NULL, NULL, NULL);
CHECK_RESULT(dlp_ReadNextRecInCategory)
if (memcmp(record3, record4->data, sizeof(record3) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST dlp_ReadNextRecInCategory mismatch\n"));
goto error;
}
/* Reset because of the above next record in category call */
result = dlp_ResetDBIndex (sd, handle);
CHECK_RESULT(dlp_ResetDBIndex)
/* This is a DLP 1.1 call, but pilot-link has a 1.0 implementation */
result = dlp_ReadNextModifiedRecInCategory (sd, handle, 2, record4, NULL, NULL, NULL);
CHECK_RESULT(dlp_ReadNextModifiedRecInCategory)
if (memcmp(record2, record4->data, sizeof(record2) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST dlp_ReadNextModifiedRecInCategory mismatch\n"));
goto error;
}
/* Reset because of the above next modified record in category call */
result = dlp_ResetDBIndex (sd, handle);
CHECK_RESULT(dlp_ResetDBIndex)
/* Move a category and try to read the record back in */
result = dlp_MoveCategory (sd, handle, 1, 4);
CHECK_RESULT(dlp_MoveCategory)
result = dlp_ReadNextRecInCategory (sd, handle, 4, record4, NULL, NULL, NULL);
CHECK_RESULT(dlp_ReadNextRecInCategory)
if (memcmp(record1, record4->data, sizeof(record1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST dlp_ReadNextRecInCategory mismatch\n"));
goto error;
}
/* Delete records in various ways */
result = dlp_DeleteRecord (sd, handle, 0, rid1);
CHECK_RESULT(dlp_DeleteRecord <Single>);
result = dlp_ReadRecordById (sd, handle, rid1, record4, NULL, NULL, NULL);
if (result >= 0) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted record could still be read\n"));
goto error;
}
result = dlp_DeleteCategory (sd, handle, 3);
CHECK_RESULT(dlp_DeleteCategory);
result = dlp_ReadRecordById (sd, handle, rid3, record4, NULL, NULL, NULL);
if (result >= 0) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted category could still be read\n"));
goto error;
}
result = dlp_DeleteRecord (sd, handle, 1, 0);
CHECK_RESULT(dlp_DeleteRecord <All>);
result = dlp_ReadRecordById (sd, handle, rid2, record4, NULL, NULL, NULL);
if (result >= 0) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted all record could still be read\n"));
goto error;
}
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB);
result = dlp_DeleteDB (sd, 0, "TestRecord");
CHECK_RESULT(dlp_DeleteDB);
/*********************************************************************
*
* Test: Resource
*
* Direct Testing Functions:
* dlp_WriteResource
* dlp_ReadResourceByType
* dlp_ReadResourceByIndex
* dlp_DeleteResource
*
* Indirect Testing Functions:
* dlp_CreateDB
* dlp_CloseDB
* dlp_DeleteDB
*
*********************************************************************/
memset (ires1, '\0', sizeof (ires1));
memset (dres1, '\0', sizeof (dres1));
ires1[3] = 'T';
dres1[4] = 'T';
result = dlp_CreateDB (sd, CREATOR, DATA, 0, dlpDBFlagResource, 1, "TestResource", &handle);
CHECK_RESULT(dlp_CreateDB);
/* Write out some resources */
result = dlp_WriteResource (sd, handle, INFO, 1, ires1, sizeof(ires1));
CHECK_RESULT(dlp_WriteResource);
result = dlp_WriteResource (sd, handle, DATA, 0, dres1, sizeof(dres1));
CHECK_RESULT(dlp_WriteResource);
/* Read in the resources by various methods */
result = dlp_ReadResourceByType (sd, handle, INFO, 1, ires2, &index);
CHECK_RESULT(dlp_ReadResourceByType)
if (memcmp(ires1, ires2->data, sizeof(ires1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by type mismatch\n"));
goto error;
}
result = dlp_ReadResourceByIndex (sd, handle, index, ires2, &type, &id_);
CHECK_RESULT(dlp_ReadResourceByIndex)
if (memcmp(ires1, ires2->data, sizeof(ires1) != 0)) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by index mismatch\n"));
goto error;
}
if (type != INFO) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by index return type mismatch\n"));
goto error;
}
if (id_ != 1) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Resource by index return id mismatch\n"));
goto error;
}
/* Delete resources by the various methods */
result = dlp_DeleteResource (sd, handle, 0, INFO, 1);
CHECK_RESULT(dlp_DeleteResource <Single>)
result = dlp_ReadResourceByType (sd, handle, INFO, 1, ires2, &index);
if (result >= 0) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted resource could still be read\n"));
goto error;
}
result = dlp_DeleteResource (sd, handle, 1, INFO, 1);
CHECK_RESULT(dlp_DeleteResource <All>)
result = dlp_ReadResourceByType (sd, handle, DATA, 0, dres2, &index);
if (result >= 0) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Deleted all resource could still be read\n"));
goto error;
}
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB)
result = dlp_DeleteDB (sd, 0, "TestResource");
CHECK_RESULT(dlp_DeleteDB)
/*********************************************************************
*
* Test: Database Cleanup
*
* Direct Testing Functions:
* dlp_CleanUpDatabase
* dlp_ResetSyncFlags
*
* Indirect Testing Functions:
* dlp_CreateDB
* dlp_WriteRecord
* dlp_CloseDB
* dlp_DeleteDB
*
*********************************************************************/
result = dlp_CreateDB (sd, CREATOR, DATA, 0, 0, 1, "TestRecord", &handle);
CHECK_RESULT(dlp_CreateDB);
/* Create dummy records */
result = dlp_WriteRecord (sd, handle, dlpRecAttrDeleted, 0, 0, record1, sizeof(record1), &rid1);
CHECK_RESULT(dlp_WriteRecord);
result = dlp_WriteRecord (sd, handle, dlpRecAttrDirty, 0, 0, record2, sizeof(record2), &rid2);
CHECK_RESULT(dlp_WriteRecord);
/* Call the test functions */
result = dlp_CleanUpDatabase (sd, handle);
CHECK_RESULT(dlp_CleanUpDatabase);
result = dlp_ResetSyncFlags (sd, handle);
CHECK_RESULT(dlp_ResetSyncFlags);
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB);
/* Confirm the test functions worked */
result = dlp_OpenDB (sd, 0, dlpOpenReadWrite, "TestRecord", &handle);
CHECK_RESULT(dlp_OpenDB);
result = dlp_ReadRecordById (sd, handle, rid1, record4, NULL, NULL, NULL);
if (result >= 0) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Cleaned up record could still be read\n"));
goto error;
}
result = dlp_ReadNextModifiedRec (sd, handle, record4, NULL, NULL, NULL, NULL);
if (result >= 0) {
LOG((PI_DBG_USER, PI_DBG_LVL_ERR, "DLPTEST Modified recorded could still be read\n"));
goto error;
}
result = dlp_CloseDB (sd, handle);
CHECK_RESULT(dlp_CloseDB);
result = dlp_DeleteDB (sd, 0, "TestRecord");
CHECK_RESULT(dlp_DeleteDB);
/*********************************************************************
*
* Test: Sync Log
*
* Direct Testing Functions:
* dlp_AddSyncLogEntry
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
result = dlp_AddSyncLogEntry (sd, "dlp-test added sync log entry");
CHECK_RESULT(dlp_AddSyncLogEntry);
/*********************************************************************
*
* Test: End Sync
*
* Direct Testing Functions:
* dlp_EndOfSync
*
* Indirect Testing Functions:
* None
*
*********************************************************************/
result = dlp_EndOfSync (sd, dlpEndCodeNormal);
CHECK_RESULT(dlp_EndOfSync);
t1 = time (NULL);
LOG((PI_DBG_USER, PI_DBG_LVL_INFO, "DLPTEST Ending at %s", ctime (&t1)));
error:
pi_close (sd);
pi_buffer_free (record4);
pi_buffer_free (ires2);
pi_buffer_free (dres2);
pi_buffer_free(appblock);
return 0;
}
