src/jpilot.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2001-2003 Match Grun
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 /*
  21  * Functions necessary to access JPilot database files.
  22  * JPilot is Copyright(c) by Judd Montgomery.
  23  * Visit http://www.jpilot.org for more details.
  24  */
  25
  26 #ifdef HAVE_CONFIG_H
  27 #  include "config.h"
  28 #endif
  29
  30 #ifdef USE_JPILOT
  31
  32 #include <glib.h>
  33 #include <time.h>
  34 #include <stdio.h>
  35 #include <stdlib.h>
  36 #include <string.h>
  37 #include <sys/stat.h>
  38 #include <netinet/in.h>
  39
  40 #ifdef HAVE_LIBPISOCK_PI_ARGS_H
  41 #  include <libpisock/pi-args.h>
  42 #  include <libpisock/pi-appinfo.h>
  43 #  include <libpisock/pi-address.h>
  44 #else
  45 #  include <pi-args.h>
  46 #  include <pi-appinfo.h>
  47 #  include <pi-address.h>
  48 #endif
  49
  50 #include "mgutils.h"
  51 #include "addritem.h"
  52 #include "addrcache.h"
  53 #include "jpilot.h"
  54 #include "adbookbase.h"
  55
  56 #define JPILOT_DBHOME_DIR   ".jpilot"
  57 #define JPILOT_DBHOME_FILE  "AddressDB.pdb"
  58 #define PILOT_LINK_LIB_NAME "libpisock.so"
  59
  60 #define IND_LABEL_LASTNAME  0   /* Index of last name in address data */
  61 #define IND_LABEL_FIRSTNAME 1   /* Index of first name in address data */
  62 #define IND_PHONE_EMAIL     4   /* Index of E-Mail address in phone labels */
  63 #define OFFSET_PHONE_LABEL  3   /* Offset to phone data in address data */
  64 #define IND_CUSTOM_LABEL    14  /* Offset to custom label names */
  65 #define NUM_CUSTOM_LABEL    4   /* Number of custom labels */
  66
  67 /* Shamelessly copied from JPilot (libplugin.h) */
  68 typedef struct {
  69         unsigned char db_name[32];
  70         unsigned char flags[2];
  71         unsigned char version[2];
  72         unsigned char creation_time[4];
  73         unsigned char modification_time[4];
  74         unsigned char backup_time[4];
  75         unsigned char modification_number[4];
  76         unsigned char app_info_offset[4];
  77         unsigned char sort_info_offset[4];
  78         unsigned char type[4];/*Database ID */
  79         unsigned char creator_id[4];/*Application ID */
  80         unsigned char unique_id_seed[4];
  81         unsigned char next_record_list_id[4];
  82         unsigned char number_of_records[2];
  83 } RawDBHeader;
  84
  85 /* Shamelessly copied from JPilot (libplugin.h) */
  86 typedef struct {
  87         char db_name[32];
  88         unsigned int flags;
  89         unsigned int version;
  90         time_t creation_time;
  91         time_t modification_time;
  92         time_t backup_time;
  93         unsigned int modification_number;
  94         unsigned int app_info_offset;
  95         unsigned int sort_info_offset;
  96         char type[5];/*Database ID */
  97         char creator_id[5];/*Application ID */
  98         char unique_id_seed[5];
  99         unsigned int next_record_list_id;
 100         unsigned int number_of_records;
 101 } DBHeader;
 102
 103 /* Shamelessly copied from JPilot (libplugin.h) */
 104 typedef struct {
 105         unsigned char Offset[4];  /*4 bytes offset from BOF to record */
 106         unsigned char attrib;
 107         unsigned char unique_ID[3];
 108 } record_header;
 109
 110 /* Shamelessly copied from JPilot (libplugin.h) */
 111 typedef struct mem_rec_header_s {
 112         unsigned int rec_num;
 113         unsigned int offset;
 114         unsigned int unique_id;
 115         unsigned char attrib;
 116         struct mem_rec_header_s *next;
 117 } mem_rec_header;
 118
 119 /* Shamelessly copied from JPilot (libplugin.h) */
 120 #define SPENT_PC_RECORD_BIT     256
 121
 122 typedef enum {
 123         PALM_REC = 100L,
 124         MODIFIED_PALM_REC = 101L,
 125         DELETED_PALM_REC = 102L,
 126         NEW_PC_REC = 103L,
 127         DELETED_PC_REC = SPENT_PC_RECORD_BIT + 104L,
 128         DELETED_DELETED_PALM_REC = SPENT_PC_RECORD_BIT + 105L
 129 } PCRecType;
 130
 131 /* Shamelessly copied from JPilot (libplugin.h) */
 132 typedef struct {
 133         PCRecType rt;
 134         unsigned int unique_id;
 135         unsigned char attrib;
 136         void *buf;
 137         int size;
 138 } buf_rec;
 139
 140 /* Shamelessly copied from JPilot (libplugin.h) */
 141 typedef struct {
 142         unsigned long header_len;
 143         unsigned long header_version;
 144         unsigned long rec_len;
 145         unsigned long unique_id;
 146         unsigned long rt; /* Record Type */
 147         unsigned char attrib;
 148 } PC3RecordHeader;
 149
 150 /**
 151 * Create new pilot file object.
 152 * \return Initialized JPilot file object.
 153 */
 154 JPilotFile *jpilot_create() {
 155         JPilotFile *pilotFile;
 156         pilotFile = g_new0( JPilotFile, 1 );
 157         pilotFile->type = ADBOOKTYPE_JPILOT;
 158         pilotFile->addressCache = addrcache_create();
 159         pilotFile->retVal = MGU_SUCCESS;
 160
 161         pilotFile->file = NULL;
 162         pilotFile->path = NULL;
 163         pilotFile->readMetadata = FALSE;
 164         pilotFile->customLabels = NULL;
 165         pilotFile->labelInd = NULL;
 166         pilotFile->havePC3 = FALSE;
 167         pilotFile->pc3ModifyTime = 0;
 168         return pilotFile;
 169 }
 170
 171 /**
 172  * Create new pilot file object for specified file.
 173  * \param path Path to JPilot address book.
 174  * \return Initialized JPilot file object.
 175  */
 176 JPilotFile *jpilot_create_path( const gchar *path ) {
 177         JPilotFile *pilotFile;
 178         pilotFile = jpilot_create();
 179         jpilot_set_file( pilotFile, path );
 180         return pilotFile;
 181 }
 182
 183 /*
 184 * Properties...
 185 */
 186 void jpilot_set_name( JPilotFile* pilotFile, const gchar *value ) {
 187         g_return_if_fail( pilotFile != NULL );
 188         addrcache_set_name( pilotFile->addressCache, value );
 189 }
 190 void jpilot_set_file( JPilotFile* pilotFile, const gchar *value ) {
 191         g_return_if_fail( pilotFile != NULL );
 192         addrcache_refresh( pilotFile->addressCache );
 193         pilotFile->readMetadata = FALSE;
 194         pilotFile->path = mgu_replace_string( pilotFile->path, value );
 195 }
 196 void jpilot_set_accessed( JPilotFile *pilotFile, const gboolean value ) {
 197         g_return_if_fail( pilotFile != NULL );
 198         pilotFile->addressCache->accessFlag = value;
 199 }
 200
 201 gint jpilot_get_status( JPilotFile *pilotFile ) {
 202         g_return_val_if_fail( pilotFile != NULL, -1 );
 203         return pilotFile->retVal;
 204 }
 205 ItemFolder *jpilot_get_root_folder( JPilotFile *pilotFile ) {
 206         g_return_val_if_fail( pilotFile != NULL, NULL );
 207         return addrcache_get_root_folder( pilotFile->addressCache );
 208 }
 209 gchar *jpilot_get_name( JPilotFile *pilotFile ) {
 210         g_return_val_if_fail( pilotFile != NULL, NULL );
 211         return addrcache_get_name( pilotFile->addressCache );
 212 }
 213
 214 /*
 215  * Test whether file was read.
 216  * \param pilotFile  JPilot control data.
 217  * \return <i>TRUE</i> if file was read.
 218  */
 219 gboolean jpilot_get_read_flag( JPilotFile *pilotFile ) {
 220         g_return_val_if_fail( pilotFile != NULL, FALSE );
 221         return pilotFile->addressCache->dataRead;
 222 }
 223
 224 /**
 225  * Free up custom label list.
 226  * \param pilotFile  JPilot control data.
 227  */
 228 void jpilot_clear_custom_labels( JPilotFile *pilotFile ) {
 229         GList *node;
 230
 231         g_return_if_fail( pilotFile != NULL );
 232
 233         /* Release custom labels */
 234         mgu_free_dlist( pilotFile->customLabels );
 235         pilotFile->customLabels = NULL;
 236
 237         /* Release indexes */
 238         node = pilotFile->labelInd;
 239         while( node ) {
 240                 node->data = NULL;
 241                 node = g_list_next( node );
 242         }
 243         g_list_free( pilotFile->labelInd );
 244         pilotFile->labelInd = NULL;
 245
 246         /* Force a fresh read */
 247         addrcache_refresh( pilotFile->addressCache );
 248 }
 249
 250 /**
 251  * Append a custom label, representing an E-Mail address field to the
 252  * custom label list.
 253  * \param pilotFile  JPilot control data.
 254  */
 255 void jpilot_add_custom_label( JPilotFile *pilotFile, const gchar *labelName ) {
 256         g_return_if_fail( pilotFile != NULL );
 257
 258         if( labelName ) {
 259                 gchar *labelCopy = g_strdup( labelName );
 260                 g_strstrip( labelCopy );
 261                 if( *labelCopy == '\0' ) {
 262                         g_free( labelCopy );
 263                 }
 264                 else {
 265                         pilotFile->customLabels = g_list_append( pilotFile->customLabels, labelCopy );
 266                         /* Force a fresh read */
 267                         addrcache_refresh( pilotFile->addressCache );
 268                 }
 269         }
 270 }
 271
 272 /**
 273  * Get list of custom labels.
 274  * \param pilotFile  JPilot control data.
 275  * \return List of labels. Must use g_free() when done.
 276  */
 277 GList *jpilot_get_custom_labels( JPilotFile *pilotFile ) {
 278         GList *retVal = NULL;
 279         GList *node;
 280
 281         g_return_val_if_fail( pilotFile != NULL, NULL );
 282
 283         node = pilotFile->customLabels;
 284         while( node ) {
 285                 retVal = g_list_append( retVal, g_strdup( node->data ) );
 286                 node = g_list_next( node );
 287         }
 288         return retVal;
 289 }
 290
 291 /**
 292  * Return filespec of PC3 file corresponding to JPilot PDB file.
 293  * \param pilotFile  JPilot control data.
 294  * \return File specification; should be g_free() when done.
 295  */
 296 static gchar *jpilot_get_pc3_file( JPilotFile *pilotFile ) {
 297         gchar *fileSpec, *r;
 298         gint i, len, pos;
 299
 300         if( pilotFile == NULL ) return NULL;
 301         if( pilotFile->path == NULL ) return NULL;
 302
 303         fileSpec = g_strdup( pilotFile->path );
 304         len = strlen( fileSpec );
 305         pos = -1;
 306         r = NULL;
 307         for( i = len; i > 0; i-- ) {
 308                 if( *(fileSpec + i) == '.' ) {
 309                         pos = i + 1;
 310                         r = fileSpec + pos;
 311                         break;
 312                 }
 313         }
 314         if( r ) {
 315                 if( len - pos == 3 ) {
 316                         *r++ = 'p'; *r++ = 'c'; *r = '3';
 317                         return fileSpec;
 318                 }
 319         }
 320         g_free( fileSpec );
 321         return NULL;
 322 }
 323
 324 /**
 325  * Save PC3 file time to cache.
 326  * \param pilotFile  JPilot control data.
 327  * \return <i>TRUE</i> if time marked.
 328  */
 329 static gboolean jpilot_mark_files( JPilotFile *pilotFile ) {
 330         gboolean retVal = FALSE;
 331         struct stat filestat;
 332         gchar *pcFile;
 333
 334         /* Mark PDB file cache */
 335         retVal = addrcache_mark_file( pilotFile->addressCache, pilotFile->path );
 336
 337         /* Now mark PC3 file */
 338         pilotFile->havePC3 = FALSE;
 339         pilotFile->pc3ModifyTime = 0;
 340         pcFile = jpilot_get_pc3_file( pilotFile );
 341         if( pcFile == NULL ) return retVal;
 342         if( 0 == lstat( pcFile, &filestat ) ) {
 343                 pilotFile->havePC3 = TRUE;
 344                 pilotFile->pc3ModifyTime = filestat.st_mtime;
 345                 retVal = TRUE;
 346         }
 347         g_free( pcFile );
 348         return retVal;
 349 }
 350
 351 /**
 352  * Check whether JPilot PDB or PC3 file has changed by comparing
 353  * with cached data.
 354  * \param pilotFile  JPilot control data.
 355  * \return <i>TRUE</i> if file has changed.
 356  */
 357 static gboolean jpilot_check_files( JPilotFile *pilotFile ) {
 358         gboolean retVal = TRUE;
 359         struct stat filestat;
 360         gchar *pcFile;
 361
 362         /* Check main file */
 363         if( addrcache_check_file( pilotFile->addressCache, pilotFile->path ) )
 364                 return TRUE;
 365
 366         /* Test PC3 file */
 367         if( ! pilotFile->havePC3 ) return FALSE;
 368         pcFile = jpilot_get_pc3_file( pilotFile );
 369         if( pcFile == NULL ) return FALSE;
 370
 371         if( 0 == lstat( pcFile, &filestat ) ) {
 372                 if( filestat.st_mtime == pilotFile->pc3ModifyTime ) retVal = FALSE;
 373         }
 374         g_free( pcFile );
 375         return retVal;
 376 }
 377
 378 /*
 379 * Test whether file was modified since last access.
 380 * Return: TRUE if file was modified.
 381 */
 382 gboolean jpilot_get_modified( JPilotFile *pilotFile ) {
 383         g_return_val_if_fail( pilotFile != NULL, FALSE );
 384         pilotFile->addressCache->modified = jpilot_check_files( pilotFile );
 385         return pilotFile->addressCache->modified;
 386 }
 387 void jpilot_set_modified( JPilotFile *pilotFile, const gboolean value ) {
 388         g_return_if_fail( pilotFile != NULL );
 389         pilotFile->addressCache->modified = value;
 390 }
 391 gboolean jpilot_get_accessed( JPilotFile *pilotFile ) {
 392         g_return_val_if_fail( pilotFile != NULL, FALSE );
 393         return pilotFile->addressCache->accessFlag;
 394 }
 395
 396 /**
 397  * Free up pilot file object by releasing internal memory.
 398  * \param pilotFile  JPilot control data.
 399  */
 400 void jpilot_free( JPilotFile *pilotFile ) {
 401         g_return_if_fail( pilotFile != NULL );
 402
 403         /* Release custom labels */
 404         jpilot_clear_custom_labels( pilotFile );
 405
 406         /* Clear cache */
 407         addrcache_clear( pilotFile->addressCache );
 408         addrcache_free( pilotFile->addressCache );
 409
 410         /* Free internal stuff */
 411         g_free( pilotFile->path );
 412
 413         pilotFile->file = NULL;
 414         pilotFile->path = NULL;
 415         pilotFile->readMetadata = FALSE;
 416         pilotFile->havePC3 = FALSE;
 417         pilotFile->pc3ModifyTime = 0;
 418
 419         pilotFile->type = ADBOOKTYPE_NONE;
 420         pilotFile->addressCache = NULL;
 421         pilotFile->retVal = MGU_SUCCESS;
 422
 423         /* Now release file object */
 424         g_free( pilotFile );
 425 }
 426
 427 /*
 428 * Refresh internal variables to force a file read.
 429 */
 430 void jpilot_force_refresh( JPilotFile *pilotFile ) {
 431         addrcache_refresh( pilotFile->addressCache );
 432 }
 433
 434 /*
 435 * Print object to specified stream.
 436 */
 437 void jpilot_print_file( JPilotFile *pilotFile, FILE *stream ) {
 438         GList *node;
 439
 440         g_return_if_fail( pilotFile != NULL );
 441
 442         fprintf( stream, "JPilotFile:\n" );
 443         fprintf( stream, "file spec: '%s'\n", pilotFile->path );
 444         fprintf( stream, " metadata: %s\n", pilotFile->readMetadata ? "yes" : "no" );
 445         fprintf( stream, "  ret val: %d\n", pilotFile->retVal );
 446
 447         node = pilotFile->customLabels;
 448         while( node ) {
 449                 fprintf( stream, "  c label: %s\n", (gchar *)node->data );
 450                 node = g_list_next( node );
 451         }
 452
 453         node = pilotFile->labelInd;
 454         while( node ) {
 455                 fprintf( stream, " labelind: %d\n", GPOINTER_TO_INT(node->data) );
 456                 node = g_list_next( node );
 457         }
 458
 459         addrcache_print( pilotFile->addressCache, stream );
 460         fprintf( stream, "  ret val: %d\n", pilotFile->retVal );
 461         fprintf( stream, " have pc3: %s\n", pilotFile->havePC3 ? "yes" : "no" );
 462         fprintf( stream, " pc3 time: %lu\n", pilotFile->pc3ModifyTime );
 463         addritem_print_item_folder( pilotFile->addressCache->rootFolder, stream );
 464 }
 465
 466 /*
 467 * Print summary of object to specified stream.
 468 */
 469 void jpilot_print_short( JPilotFile *pilotFile, FILE *stream ) {
 470         GList *node;
 471         g_return_if_fail( pilotFile != NULL );
 472         fprintf( stream, "JPilotFile:\n" );
 473         fprintf( stream, "file spec: '%s'\n", pilotFile->path );
 474         fprintf( stream, " metadata: %s\n", pilotFile->readMetadata ? "yes" : "no" );
 475         fprintf( stream, "  ret val: %d\n", pilotFile->retVal );
 476
 477         node = pilotFile->customLabels;
 478         while( node ) {
 479                 fprintf( stream, "  c label: %s\n", (gchar *)node->data );
 480                 node = g_list_next( node );
 481         }
 482
 483         node = pilotFile->labelInd;
 484         while( node ) {
 485                 fprintf( stream, " labelind: %d\n", GPOINTER_TO_INT(node->data) );
 486                 node = g_list_next( node );
 487         }
 488         addrcache_print( pilotFile->addressCache, stream );
 489         fprintf( stream, " have pc3: %s\n", pilotFile->havePC3 ? "yes" : "no" );
 490         fprintf( stream, " pc3 time: %lu\n", pilotFile->pc3ModifyTime );
 491 }
 492
 493 /* Shamelessly copied from JPilot (libplugin.c) */
 494 static unsigned int bytes_to_bin(unsigned char *bytes, unsigned int num_bytes) {
 495 unsigned int i, n;
 496         n=0;
 497         for (i=0;i<num_bytes;i++) {
 498                 n = n*256+bytes[i];
 499         }
 500         return n;
 501 }
 502
 503 /* Shamelessly copied from JPilot (utils.c) */
 504 /* These next 2 functions were copied from pi-file.c in the pilot-link app */
 505 /* Exact value of "Jan 1, 1970 0:00:00 GMT" - "Jan 1, 1904 0:00:00 GMT" */
 506 #define PILOT_TIME_DELTA (unsigned)(2082844800)
 507
 508 time_t pilot_time_to_unix_time ( unsigned long raw_time ) {
 509    return (time_t)(raw_time - PILOT_TIME_DELTA);
 510 }
 511
 512 /* Shamelessly copied from JPilot (libplugin.c) */
 513 static int raw_header_to_header(RawDBHeader *rdbh, DBHeader *dbh) {
 514         unsigned long temp;
 515
 516         strncpy(dbh->db_name, rdbh->db_name, 31);
 517         dbh->db_name[31] = '\0';
 518         dbh->flags = bytes_to_bin(rdbh->flags, 2);
 519         dbh->version = bytes_to_bin(rdbh->version, 2);
 520         temp = bytes_to_bin(rdbh->creation_time, 4);
 521         dbh->creation_time = pilot_time_to_unix_time(temp);
 522         temp = bytes_to_bin(rdbh->modification_time, 4);
 523         dbh->modification_time = pilot_time_to_unix_time(temp);
 524         temp = bytes_to_bin(rdbh->backup_time, 4);
 525         dbh->backup_time = pilot_time_to_unix_time(temp);
 526         dbh->modification_number = bytes_to_bin(rdbh->modification_number, 4);
 527         dbh->app_info_offset = bytes_to_bin(rdbh->app_info_offset, 4);
 528         dbh->sort_info_offset = bytes_to_bin(rdbh->sort_info_offset, 4);
 529         strncpy(dbh->type, rdbh->type, 4);
 530         dbh->type[4] = '\0';
 531         strncpy(dbh->creator_id, rdbh->creator_id, 4);
 532         dbh->creator_id[4] = '\0';
 533         strncpy(dbh->unique_id_seed, rdbh->unique_id_seed, 4);
 534         dbh->unique_id_seed[4] = '\0';
 535         dbh->next_record_list_id = bytes_to_bin(rdbh->next_record_list_id, 4);
 536         dbh->number_of_records = bytes_to_bin(rdbh->number_of_records, 2);
 537         return 0;
 538 }
 539
 540 /* Shamelessly copied from JPilot (libplugin.c) */
 541 /* returns 1 if found */
 542 /*         0 if eof */
 543 static int find_next_offset( mem_rec_header *mem_rh, long fpos,
 544         unsigned int *next_offset, unsigned char *attrib, unsigned int *unique_id )
 545 {
 546         mem_rec_header *temp_mem_rh;
 547         unsigned char found = 0;
 548         unsigned long found_at;
 549
 550         found_at=0xFFFFFF;
 551         for (temp_mem_rh=mem_rh; temp_mem_rh; temp_mem_rh = temp_mem_rh->next) {
 552                 if ((temp_mem_rh->offset > fpos) && (temp_mem_rh->offset < found_at)) {
 553                         found_at = temp_mem_rh->offset;
 554                         /* *attrib = temp_mem_rh->attrib; */
 555                         /* *unique_id = temp_mem_rh->unique_id; */
 556                 }
 557                 if ((temp_mem_rh->offset == fpos)) {
 558                         found = 1;
 559                         *attrib = temp_mem_rh->attrib;
 560                         *unique_id = temp_mem_rh->unique_id;
 561                 }
 562         }
 563         *next_offset = found_at;
 564         return found;
 565 }
 566
 567 /* Shamelessly copied from JPilot (libplugin.c) */
 568 static void free_mem_rec_header(mem_rec_header **mem_rh) {
 569         mem_rec_header *h, *next_h;
 570         for (h=*mem_rh; h; h=next_h) {
 571                 next_h=h->next;
 572                 free(h);
 573         }
 574         *mem_rh = NULL;
 575 }
 576
 577 /* Shamelessly copied from JPilot (libplugin.c) */
 578 static int jpilot_free_db_list( GList **br_list ) {
 579         GList *temp_list, *first;
 580         buf_rec *br;
 581
 582         /* Go to first entry in the list */
 583         first=NULL;
 584         for( temp_list = *br_list; temp_list; temp_list = temp_list->prev ) {
 585                 first = temp_list;
 586         }
 587         for (temp_list = first; temp_list; temp_list = temp_list->next) {
 588                 if (temp_list->data) {
 589                         br=temp_list->data;
 590                         if (br->buf) {
 591                                 free(br->buf);
 592                                 temp_list->data=NULL;
 593                         }
 594                         free(br);
 595                 }
 596         }
 597         g_list_free(*br_list);
 598         *br_list=NULL;
 599         return 0;
 600 }
 601
 602 /* Shamelessly copied from JPilot (libplugin.c) */
 603 /* Read file size */
 604 static int jpilot_get_info_size( FILE *in, int *size ) {
 605         RawDBHeader rdbh;
 606         DBHeader dbh;
 607         unsigned int offset;
 608         record_header rh;
 609
 610         fseek(in, 0, SEEK_SET);
 611         fread(&rdbh, sizeof(RawDBHeader), 1, in);
 612         if (feof(in)) {
 613                 return MGU_EOF;
 614         }
 615
 616         raw_header_to_header(&rdbh, &dbh);
 617         if (dbh.app_info_offset==0) {
 618                 *size=0;
 619                 return MGU_SUCCESS;
 620         }
 621         if (dbh.sort_info_offset!=0) {
 622                 *size = dbh.sort_info_offset - dbh.app_info_offset;
 623                 return MGU_SUCCESS;
 624         }
 625         if (dbh.number_of_records==0) {
 626                 fseek(in, 0, SEEK_END);
 627                 *size=ftell(in) - dbh.app_info_offset;
 628                 return MGU_SUCCESS;
 629         }
 630
 631         fread(&rh, sizeof(record_header), 1, in);
 632         offset = ((rh.Offset[0]*256+rh.Offset[1])*256+rh.Offset[2])*256+rh.Offset[3];
 633         *size=offset - dbh.app_info_offset;
 634
 635         return MGU_SUCCESS;
 636 }
 637
 638 /*
 639  * Read address file into address list. Based on JPilot's
 640  * libplugin.c (jp_get_app_info)
 641  */
 642 static gint jpilot_get_file_info( JPilotFile *pilotFile, unsigned char **buf, int *buf_size ) {
 643         FILE *in;
 644         int num;
 645         unsigned int rec_size;
 646         RawDBHeader rdbh;
 647         DBHeader dbh;
 648
 649         if( ( !buf_size ) || ( ! buf ) ) {
 650                 return MGU_BAD_ARGS;
 651         }
 652
 653         *buf = NULL;
 654         *buf_size=0;
 655
 656         if( pilotFile->path ) {
 657                 in = fopen( pilotFile->path, "rb" );
 658                 if( !in ) {
 659                         return MGU_OPEN_FILE;
 660                 }
 661         }
 662         else {
 663                 return MGU_NO_FILE;
 664         }
 665
 666         num = fread( &rdbh, sizeof( RawDBHeader ), 1, in );
 667         if( num != 1 ) {
 668                 if( ferror(in) ) {
 669                         fclose(in);
 670                         return MGU_ERROR_READ;
 671                 }
 672         }
 673         if (feof(in)) {
 674                 fclose(in);
 675                 return MGU_EOF;
 676         }
 677
 678         /* Convert header into something recognizable */
 679         raw_header_to_header(&rdbh, &dbh);
 680
 681         num = jpilot_get_info_size(in, &rec_size);
 682         if (num) {
 683                 fclose(in);
 684                 return MGU_ERROR_READ;
 685         }
 686
 687         fseek(in, dbh.app_info_offset, SEEK_SET);
 688         *buf = ( char * ) malloc(rec_size);
 689         if (!(*buf)) {
 690                 fclose(in);
 691                 return MGU_OO_MEMORY;
 692         }
 693         num = fread(*buf, rec_size, 1, in);
 694         if (num != 1) {
 695                 if (ferror(in)) {
 696                         fclose(in);
 697                         free(*buf);
 698                         return MGU_ERROR_READ;
 699                 }
 700         }
 701         fclose(in);
 702
 703         *buf_size = rec_size;
 704
 705         return MGU_SUCCESS;
 706 }
 707
 708 /* Shamelessly copied from JPilot (libplugin.c) */
 709 static int unpack_header(PC3RecordHeader *header, unsigned char *packed_header) {
 710         unsigned char *p;
 711         unsigned long l;
 712
 713         p = packed_header;
 714
 715         memcpy(&l, p, sizeof(l));
 716         header->header_len=ntohl(l);
 717         p+=sizeof(l);
 718
 719         memcpy(&l, p, sizeof(l));
 720         header->header_version=ntohl(l);
 721         p+=sizeof(l);
 722
 723         memcpy(&l, p, sizeof(l));
 724         header->rec_len=ntohl(l);
 725         p+=sizeof(l);
 726
 727         memcpy(&l, p, sizeof(l));
 728         header->unique_id=ntohl(l);
 729         p+=sizeof(l);
 730
 731         memcpy(&l, p, sizeof(l));
 732         header->rt=ntohl(l);
 733         p+=sizeof(l);
 734
 735         memcpy(&(header->attrib), p, sizeof(unsigned char));
 736         p+=sizeof(unsigned char);
 737
 738         return 0;
 739 }
 740
 741 /* Shamelessly copied from JPilot (libplugin.c) */
 742 static int read_header(FILE *pc_in, PC3RecordHeader *header) {
 743         unsigned long l, len;
 744         unsigned char packed_header[256];
 745         int num;
 746
 747         num = fread(&l, sizeof(l), 1, pc_in);
 748         if (feof(pc_in)) {
 749                 return -1;
 750         }
 751         if (num!=1) {
 752                 return num;
 753         }
 754         memcpy(packed_header, &l, sizeof(l));
 755         len=ntohl(l);
 756         if (len > 255) {
 757                 return -1;
 758         }
 759         num = fread(packed_header+sizeof(l), len-sizeof(l), 1, pc_in);
 760         if (feof(pc_in)) {
 761                 return -1;
 762         }
 763         if (num!=1) {
 764                 return num;
 765         }
 766         unpack_header(header, packed_header);
 767         return 1;
 768 }
 769
 770 /**
 771  * Read next record from PC3 file. Based on JPilot function
 772  * <code>pc_read_next_rec()</code> (libplugin.c)
 773  *
 774  * \param in File handle.
 775  * \param br Record buffer.
 776  * \return Status/error code. <code>MGU_SUCCESS</code> if data read
 777  *         successfully.
 778  */
 779 static gint jpilot_read_next_pc( FILE *in, buf_rec *br ) {
 780         PC3RecordHeader header;
 781         int rec_len, num;
 782         char *record;
 783
 784         if( feof( in ) ) {
 785                 return MGU_EOF;
 786         }
 787         num = read_header( in, &header );
 788         if( num < 1 ) {
 789                 if( ferror( in ) ) {
 790                         return MGU_ERROR_READ;
 791                 }
 792                 if( feof( in ) ) {
 793                         return MGU_EOF;
 794                 }
 795         }
 796         rec_len = header.rec_len;
 797         record = malloc( rec_len );
 798         if( ! record ) {
 799                 return MGU_OO_MEMORY;
 800         }
 801         num = fread( record, rec_len, 1, in );
 802         if( num != 1 ) {
 803                 if( ferror( in ) ) {
 804                         free( record );
 805                         return MGU_ERROR_READ;
 806                 }
 807         }
 808         br->rt = header.rt;
 809         br->unique_id = header.unique_id;
 810         br->attrib = header.attrib;
 811         br->buf = record;
 812         br->size = rec_len;
 813
 814         return MGU_SUCCESS;
 815 }
 816
 817 /**
 818  * Read address file into a linked list. Based on JPilot function
 819  * <code>jp_read_DB_files()</code> (from libplugin.c)
 820  *
 821  * \param pilotFile  JPilot control data.
 822  * \param records Pointer to linked list of records read.
 823  * \return Status/error code. <code>MGU_SUCCESS</code> if data read
 824  *         successfully.
 825  */
 826 static gint jpilot_read_db_files( JPilotFile *pilotFile, GList **records ) {
 827         FILE *in, *pc_in;
 828         char *buf;
 829         GList *temp_list;
 830         int num_records, recs_returned, i, num, r;
 831         unsigned int offset, prev_offset, next_offset, rec_size;
 832         int out_of_order;
 833         long fpos;  /*file position indicator */
 834         unsigned char attrib;
 835         unsigned int unique_id;
 836         mem_rec_header *mem_rh, *temp_mem_rh, *last_mem_rh;
 837         record_header rh;
 838         RawDBHeader rdbh;
 839         DBHeader dbh;
 840         buf_rec *temp_br;
 841         gchar *pcFile;
 842
 843         mem_rh = last_mem_rh = NULL;
 844         *records = NULL;
 845         recs_returned = 0;
 846
 847         if( pilotFile->path == NULL ) {
 848                 return MGU_BAD_ARGS;
 849         }
 850
 851         in = fopen( pilotFile->path, "rb" );
 852         if( ! in ) {
 853                 return MGU_OPEN_FILE;
 854         }
 855
 856         /* Read the database header */
 857         num = fread( &rdbh, sizeof( RawDBHeader ), 1, in );
 858         if( num != 1 ) {
 859                 if( ferror( in ) ) {
 860                         fclose( in );
 861                         return MGU_ERROR_READ;
 862                 }
 863                 if( feof( in ) ) {
 864                         fclose( in );
 865                         return MGU_EOF;
 866                 }
 867         }
 868         raw_header_to_header( &rdbh, &dbh );
 869
 870         /* Read each record entry header */
 871         num_records = dbh.number_of_records;
 872         out_of_order = 0;
 873         prev_offset = 0;
 874
 875         for( i = 1; i < num_records + 1; i++ ) {
 876                 num = fread( &rh, sizeof( record_header ), 1, in );
 877                 if( num != 1 ) {
 878                         if( ferror( in ) ) {
 879                                 break;
 880                         }
 881                         if( feof( in ) ) {
 882                                 fclose( in );
 883                                 return MGU_EOF;
 884                         }
 885                 }
 886
 887                 offset =
 888                         ( ( rh.Offset[0] * 256 + rh.Offset[1] ) * 256
 889                         + rh.Offset[2] ) * 256
 890                         + rh.Offset[3];
 891                 if( offset < prev_offset ) {
 892                         out_of_order = 1;
 893                 }
 894                 prev_offset = offset;
 895                 temp_mem_rh = ( mem_rec_header * ) malloc( sizeof( mem_rec_header ) );
 896                 if( ! temp_mem_rh ) {
 897                         break;
 898                 }
 899                 temp_mem_rh->next = NULL;
 900                 temp_mem_rh->rec_num = i;
 901                 temp_mem_rh->offset = offset;
 902                 temp_mem_rh->attrib = rh.attrib;
 903                 temp_mem_rh->unique_id =
 904                         ( rh.unique_ID[0] * 256 + rh.unique_ID[1] ) * 256
 905                         + rh.unique_ID[2];
 906                 if( mem_rh == NULL ) {
 907                         mem_rh = temp_mem_rh;
 908                         last_mem_rh = temp_mem_rh;
 909                 }
 910                 else {
 911                         last_mem_rh->next = temp_mem_rh;
 912                         last_mem_rh = temp_mem_rh;
 913                 }
 914         }
 915
 916         temp_mem_rh = mem_rh;
 917
 918         if( num_records ) {
 919                 if( out_of_order ) {
 920                         find_next_offset(
 921                                 mem_rh, 0, &next_offset, &attrib, &unique_id );
 922                 }
 923                 else {
 924                         if( mem_rh ) {
 925                                 next_offset = mem_rh->offset;
 926                                 attrib = mem_rh->attrib;
 927                                 unique_id = mem_rh->unique_id;
 928                         }
 929                 }
 930                 fseek( in, next_offset, SEEK_SET );
 931                 while( ! feof( in ) ) {
 932                         fpos = ftell( in );
 933                         if( out_of_order ) {
 934                                 find_next_offset(
 935                                         mem_rh, fpos, &next_offset, &attrib,
 936                                         &unique_id );
 937                         } else {
 938                                 next_offset = 0xFFFFFF;
 939                                 if( temp_mem_rh ) {
 940                                         attrib = temp_mem_rh->attrib;
 941                                         unique_id = temp_mem_rh->unique_id;
 942                                         if ( temp_mem_rh->next ) {
 943                                                 temp_mem_rh = temp_mem_rh->next;
 944                                                 next_offset = temp_mem_rh->offset;
 945                                         }
 946                                 }
 947                         }
 948                         rec_size = next_offset - fpos;
 949                         buf = malloc( rec_size );
 950                         if( ! buf ) break;
 951                         num = fread( buf, rec_size, 1, in );
 952                         if( ( num != 1 ) ) {
 953                                 if( ferror( in ) ) {
 954                                         free( buf );
 955                                         break;
 956                                 }
 957                         }
 958
 959                         temp_br = malloc( sizeof( buf_rec ) );
 960                         if( ! temp_br ) {
 961                                 free( buf );
 962                                 break;
 963                         }
 964                         temp_br->rt = PALM_REC;
 965                         temp_br->unique_id = unique_id;
 966                         temp_br->attrib = attrib;
 967                         temp_br->buf = buf;
 968                         temp_br->size = rec_size;
 969
 970                         *records = g_list_append( *records, temp_br );
 971
 972                         recs_returned++;
 973                 }
 974         }
 975         fclose( in );
 976         free_mem_rec_header( &mem_rh );
 977
 978         /* Read the PC3 file, if present */
 979         pcFile = jpilot_get_pc3_file( pilotFile );
 980         if( pcFile == NULL ) return MGU_SUCCESS;
 981         pc_in = fopen( pcFile, "rb" );
 982         g_free( pcFile );
 983
 984         if( pc_in == NULL ) {
 985                 return MGU_SUCCESS;
 986         }
 987
 988         while( ! feof( pc_in ) ) {
 989                 gboolean linked;
 990
 991                 temp_br = malloc( sizeof( buf_rec ) );
 992                 if( ! temp_br ) {
 993                         break;
 994                 }
 995                 r = jpilot_read_next_pc( pc_in, temp_br );
 996                 if( r != MGU_SUCCESS ) {
 997                         free( temp_br->buf );
 998                         free( temp_br );
 999                         break;
1000                 }
1001
1002                 linked = FALSE;
1003                 if( ( temp_br->rt != DELETED_PC_REC )
1004                  && ( temp_br->rt != DELETED_PALM_REC )
1005                  && ( temp_br->rt != MODIFIED_PALM_REC )
1006                  && ( temp_br->rt != DELETED_DELETED_PALM_REC ) )
1007                 {
1008                         *records = g_list_append( *records, temp_br );
1009                         recs_returned++;
1010                         linked = TRUE;
1011                 }
1012
1013                 if( ( temp_br->rt == DELETED_PALM_REC )
1014                  || ( temp_br->rt == MODIFIED_PALM_REC ) )
1015                 {
1016                         temp_list = *records;
1017                         if( *records ) {
1018                                 while( temp_list->next ) {
1019                                         temp_list=temp_list->next;
1020                                 }
1021                         }
1022                         for( ; temp_list; temp_list=temp_list->prev ) {
1023                                 if( ( ( buf_rec * )temp_list->data )->unique_id ==
1024                                     temp_br->unique_id ) {
1025                                         ( ( buf_rec * )temp_list->data )->rt =
1026                                                 temp_br->rt;
1027                                 }
1028                         }
1029                 }
1030
1031                 if( ! linked ) {
1032                         free( temp_br->buf );
1033                         free( temp_br );
1034                 }
1035         }
1036         fclose( pc_in );
1037
1038         return MGU_SUCCESS;
1039 }
1040
1041 /**
1042  * Parse buffer containing multiple e-mail addresses into a linked list of
1043  * addresses. Separator characters are " ,;|" and control characters. Address
1044  * is only extracted if it contains an "at" (@) character.
1045  *
1046  * \param buf Buffer to process.
1047  * \return List of strings.
1048  */
1049 static GList *jpilot_parse_email( gchar *buf ) {
1050         GList *list;
1051         gchar *p, *st, *em;
1052         gchar lch;
1053         gint len;
1054         gboolean valid, done;
1055
1056         valid = done = FALSE;
1057         lch = ' ';
1058         list = NULL;
1059         p = st = buf;
1060         while( ! done ) {
1061                 if( *p == ' ' || *p == ',' || *p == ';' || *p == '|' || *p < 32 ) {
1062                         if( *p == '\0' ) {
1063                                 done = TRUE;
1064                         }
1065                         else {
1066                                 *p = ' ';
1067                         }
1068
1069                         if( *p == lch ) {
1070                                 st++;
1071                         }
1072                         else {
1073                                 len = p - st;
1074                                 if( len > 0 ) {
1075                                         if( valid ) {
1076                                                 em = g_strndup( st, len );
1077                                                 list = g_list_append( list, em );
1078                                         }
1079                                         st = p;
1080                                         ++st;
1081                                         valid = FALSE;
1082                                 }
1083                         }
1084                 }
1085                 if( *p == '@' ) valid = TRUE;
1086                 lch = *p;
1087                 ++p;
1088         }
1089
1090         return list;
1091 }
1092
1093 #define FULLNAME_BUFSIZE        256
1094 #define EMAIL_BUFSIZE           256
1095
1096 /**
1097  * Process a single label entry field, parsing multiple e-mail address entries.
1098  *
1099  * \param pilotFile  JPilot control data.
1100  * \param labelEntry Label entry data.
1101  * \param person     Person.
1102  */
1103 static void jpilot_parse_label( JPilotFile *pilotFile, gchar *labelEntry, ItemPerson *person ) {
1104         gchar buffer[ EMAIL_BUFSIZE ];
1105         ItemEMail *email;
1106         GList *list, *node;
1107
1108         if( labelEntry ) {
1109                 *buffer = '\0';
1110                 strcpy( buffer, labelEntry );
1111                 node = list = jpilot_parse_email( buffer );
1112                 while( node ) {
1113                         email = addritem_create_item_email();
1114                         addritem_email_set_address( email, node->data );
1115                         addrcache_id_email( pilotFile->addressCache, email );
1116                         addrcache_person_add_email( pilotFile->addressCache, person, email );
1117                         node = g_list_next( node );
1118                 }
1119                 mgu_free_dlist( list );
1120                 list = NULL;
1121         }
1122 }
1123
1124 /**
1125  * Unpack address, building new data inside cache.
1126  * \param pilotFile  JPilot control data.
1127  * \param buf        Record buffer.
1128  * \param folderInd  Array of (category) folders to load.
1129  */
1130 static void jpilot_load_address(
1131                 JPilotFile *pilotFile, buf_rec *buf, ItemFolder *folderInd[] )
1132 {
1133         struct Address addr;
1134         gchar **addrEnt;
1135         gint num, k;
1136         gint cat_id = 0;
1137         guint unique_id;
1138         guchar attrib;
1139         gchar fullName[ FULLNAME_BUFSIZE ];
1140         ItemPerson *person;
1141         gint *indPhoneLbl;
1142         gchar *labelEntry;
1143         GList *node;
1144         gchar* extID;
1145         struct AddressAppInfo *ai;
1146
1147         /* Retrieve address */
1148         num = unpack_Address( & addr, buf->buf, buf->size );
1149         if( num > 0 ) {
1150                 addrEnt = addr.entry;
1151                 attrib = buf->attrib;
1152                 unique_id = buf->unique_id;
1153                 cat_id = attrib & 0x0F;
1154
1155                 *fullName = '\0';
1156                 if( addrEnt[ IND_LABEL_FIRSTNAME ] ) {
1157                         strcat( fullName, addrEnt[ IND_LABEL_FIRSTNAME ] );
1158                 }
1159
1160                 if( addrEnt[ IND_LABEL_LASTNAME ] ) {
1161                         strcat( fullName, " " );
1162                         strcat( fullName, addrEnt[ IND_LABEL_LASTNAME ] );
1163                 }
1164                 g_strchug( fullName );
1165                 g_strchomp( fullName );
1166
1167                 person = addritem_create_item_person();
1168                 addritem_person_set_common_name( person, fullName );
1169                 addritem_person_set_first_name( person, addrEnt[ IND_LABEL_FIRSTNAME ] );
1170                 addritem_person_set_last_name( person, addrEnt[ IND_LABEL_LASTNAME ] );
1171                 addrcache_id_person( pilotFile->addressCache, person );
1172
1173                 extID = g_strdup_printf( "%d", unique_id );
1174                 addritem_person_set_external_id( person, extID );
1175                 g_free( extID );
1176                 extID = NULL;
1177
1178                 /* Pointer to address metadata. */
1179                 ai = & pilotFile->addrInfo;
1180
1181                 /* Add entry for each email address listed under phone labels. */
1182                 indPhoneLbl = addr.phoneLabel;
1183                 for( k = 0; k < JPILOT_NUM_ADDR_PHONE; k++ ) {
1184                         gint ind;
1185                         ind = indPhoneLbl[k];
1186                         /*
1187                         * fprintf( stdout, "%d : %d : %20s : %s\n", k, ind,
1188                         * ai->phoneLabels[ind], addrEnt[3+k] );
1189                         */
1190                         if( indPhoneLbl[k] == IND_PHONE_EMAIL ) {
1191                                 labelEntry = addrEnt[ OFFSET_PHONE_LABEL + k ];
1192                                 jpilot_parse_label( pilotFile, labelEntry, person );
1193                         }
1194                 }
1195
1196                 /* Add entry for each custom label */
1197                 node = pilotFile->labelInd;
1198                 while( node ) {
1199                         gint ind;
1200                         ind = GPOINTER_TO_INT( node->data );
1201                         if( ind > -1 ) {
1202                                 /*
1203                                 * fprintf( stdout, "%d : %20s : %s\n", ind, ai->labels[ind],
1204                                 * addrEnt[ind] );
1205                                 */
1206                                 labelEntry = addrEnt[ind];
1207                                 jpilot_parse_label( pilotFile, labelEntry, person );
1208                         }
1209
1210                         node = g_list_next( node );
1211                 }
1212
1213                 if( person->listEMail ) {
1214                         if( cat_id > -1 && cat_id < JPILOT_NUM_CATEG ) {
1215                                 /* Add to specified category */
1216                                 addrcache_folder_add_person(
1217                                         pilotFile->addressCache,
1218                                         folderInd[cat_id], person );
1219                         }
1220                         else {
1221                                 /* Add to root folder */
1222                                 addrcache_add_person(
1223                                         pilotFile->addressCache, person );
1224                         }
1225                 }
1226                 else {
1227                         addritem_free_item_person( person );
1228                         person = NULL;
1229                 }
1230         }
1231
1232         /* Free up pointer allocated inside address */
1233         free_Address( & addr );
1234 }
1235
1236 /**
1237  * Free up address list.
1238  * \param records List of records to free.
1239  */
1240 static void jpilot_free_addrlist( GList *records ) {
1241         GList *node;
1242         buf_rec *br;
1243
1244         node = records;
1245         while( node ) {
1246                 br = node->data;
1247                 free( br->buf );
1248                 free( br );
1249                 node->data = NULL;
1250                 node = g_list_next( node );
1251         }
1252
1253         /* Free up list */
1254         g_list_free( records );
1255 }
1256
1257 /**
1258  * Read metadata from file.
1259  * \param pilotFile  JPilot control data.
1260  * \return Status/error code. <code>MGU_SUCCESS</code> if data read
1261  *         successfully.
1262  */
1263 static gint jpilot_read_metadata( JPilotFile *pilotFile ) {
1264         gint retVal;
1265         unsigned int rec_size;
1266         unsigned char *buf;
1267         int num;
1268
1269         g_return_val_if_fail( pilotFile != NULL, -1 );
1270
1271         pilotFile->readMetadata = FALSE;
1272         addrcache_clear( pilotFile->addressCache );
1273
1274         /* Read file info */
1275         retVal = jpilot_get_file_info( pilotFile, &buf, &rec_size);
1276         if( retVal != MGU_SUCCESS ) {
1277                 pilotFile->retVal = retVal;
1278                 return pilotFile->retVal;
1279         }
1280
1281         num = unpack_AddressAppInfo( &pilotFile->addrInfo, buf, rec_size );
1282         if( buf ) {
1283                 free(buf);
1284         }
1285         if( num <= 0 ) {
1286                 pilotFile->retVal = MGU_ERROR_READ;
1287                 return pilotFile->retVal;
1288         }
1289
1290         pilotFile->readMetadata = TRUE;
1291         pilotFile->retVal = MGU_SUCCESS;
1292         return pilotFile->retVal;
1293 }
1294
1295 /**
1296  * Setup labels and indexes from metadata.
1297  * \param pilotFile  JPilot control data.
1298  * \return <i>TRUE</i> is setup successfully.
1299  */
1300 static gboolean jpilot_setup_labels( JPilotFile *pilotFile ) {
1301         gboolean retVal = FALSE;
1302         struct AddressAppInfo *ai;
1303         GList *node;
1304
1305         g_return_val_if_fail( pilotFile != NULL, -1 );
1306
1307         /* Release indexes */
1308         node = pilotFile->labelInd;
1309         while( node ) {
1310                 node->data = NULL;
1311                 node = g_list_next( node );
1312         }
1313         pilotFile->labelInd = NULL;
1314
1315         if( pilotFile->readMetadata ) {
1316                 ai = & pilotFile->addrInfo;
1317                 node = pilotFile->customLabels;
1318                 while( node ) {
1319                         gchar *lbl = node->data;
1320                         gint ind = -1;
1321                         gint i;
1322                         for( i = 0; i < JPILOT_NUM_LABELS; i++ ) {
1323                                 gchar *labelName = ai->labels[i];
1324                                 if( g_strcasecmp( labelName, lbl ) == 0 ) {
1325                                         ind = i;
1326                                         break;
1327                                 }
1328                         }
1329                         pilotFile->labelInd = g_list_append(
1330                                 pilotFile->labelInd, GINT_TO_POINTER(ind) );
1331                         node = g_list_next( node );
1332                 }
1333                 retVal = TRUE;
1334         }
1335         return retVal;
1336 }
1337
1338 /**
1339  * Load list with character strings of label names.
1340  * \param pilotFile  JPilot control data.
1341  * \param labelList List of label names to load.
1342  * \return List of label names loaded.
1343  */
1344 GList *jpilot_load_label( JPilotFile *pilotFile, GList *labelList ) {
1345         int i;
1346
1347         g_return_val_if_fail( pilotFile != NULL, NULL );
1348
1349         if( pilotFile->readMetadata ) {
1350                 struct AddressAppInfo *ai = & pilotFile->addrInfo;
1351                 for( i = 0; i < JPILOT_NUM_LABELS; i++ ) {
1352                         gchar *labelName = ai->labels[i];
1353                         if( labelName ) {
1354                                 labelList = g_list_append(
1355                                         labelList, g_strdup( labelName ) );
1356                         }
1357                         else {
1358                                 labelList = g_list_append(
1359                                         labelList, g_strdup( "" ) );
1360                         }
1361                 }
1362         }
1363         return labelList;
1364 }
1365
1366 /**
1367  * Return category name for specified category ID.
1368  * \param pilotFile  JPilot control data.
1369  * \param catID      Category ID.
1370  * \return Category name, or empty string if not invalid ID. Name should be
1371  *         <code>g_free()</code> when done.
1372  */
1373 gchar *jpilot_get_category_name( JPilotFile *pilotFile, gint catID ) {
1374         gchar *catName = NULL;
1375
1376         g_return_val_if_fail( pilotFile != NULL, NULL );
1377
1378         if( pilotFile->readMetadata ) {
1379                 struct AddressAppInfo *ai = & pilotFile->addrInfo;
1380                 struct CategoryAppInfo *cat = & ai->category;
1381                 if( catID < 0 || catID > JPILOT_NUM_CATEG ) {
1382                 }
1383                 else {
1384                         catName = g_strdup( cat->name[catID] );
1385                 }
1386         }
1387         if( ! catName ) catName = g_strdup( "" );
1388         return catName;
1389 }
1390
1391 /**
1392  * Load list with character strings of phone label names.
1393  * \param pilotFile  JPilot control data.
1394  * \param labelList List of label names to load.
1395  * \return List of label names loaded.
1396  */
1397 GList *jpilot_load_phone_label( JPilotFile *pilotFile, GList *labelList ) {
1398         gint i;
1399
1400         g_return_val_if_fail( pilotFile != NULL, NULL );
1401
1402         if( pilotFile->readMetadata ) {
1403                 struct AddressAppInfo *ai = & pilotFile->addrInfo;
1404                 for( i = 0; i < JPILOT_NUM_PHONELABELS; i++ ) {
1405                         gchar   *labelName = ai->phoneLabels[i];
1406                         if( labelName ) {
1407                                 labelList = g_list_append(
1408                                         labelList, g_strdup( labelName ) );
1409                         }
1410                         else {
1411                                 labelList = g_list_append(
1412                                         labelList, g_strdup( "" ) );
1413                         }
1414                 }
1415         }
1416         return labelList;
1417 }
1418
1419 /**
1420  * Load list with character strings of custom label names. Only none blank
1421  * names are loaded.
1422  * \param pilotFile  JPilot control data.
1423  * \param labelList List of label names to load.
1424  * \return List of label names loaded. Should be freed when done.
1425  */
1426 GList *jpilot_load_custom_label( JPilotFile *pilotFile, GList *labelList ) {
1427         gint i;
1428
1429         g_return_val_if_fail( pilotFile != NULL, NULL );
1430
1431         if( pilotFile->readMetadata ) {
1432                 struct AddressAppInfo *ai = & pilotFile->addrInfo;
1433                 for( i = 0; i < NUM_CUSTOM_LABEL; i++ ) {
1434                         gchar *labelName = ai->labels[i+IND_CUSTOM_LABEL];
1435                         if( labelName ) {
1436                                 g_strchomp( labelName );
1437                                 g_strchug( labelName );
1438                                 if( *labelName != '\0' ) {
1439                                         labelList = g_list_append( labelList,
1440                                                 g_strdup( labelName ) );
1441                                 }
1442                         }
1443                 }
1444         }
1445         return labelList;
1446 }
1447
1448 /**
1449  * Load list with character strings of category names.
1450  * \param pilotFile  JPilot control data.
1451  * \return List of label names loaded. Should be freed when done.
1452  */
1453 GList *jpilot_get_category_list( JPilotFile *pilotFile ) {
1454         GList *catList = NULL;
1455         gint i;
1456
1457         g_return_val_if_fail( pilotFile != NULL, NULL );
1458
1459         if( pilotFile->readMetadata ) {
1460                 struct AddressAppInfo *ai = & pilotFile->addrInfo;
1461                 struct CategoryAppInfo *cat = & ai->category;
1462                 for( i = 0; i < JPILOT_NUM_CATEG; i++ ) {
1463                         gchar *catName = cat->name[i];
1464                         if( catName ) {
1465                                 catList = g_list_append(
1466                                         catList, g_strdup( catName ) );
1467                         }
1468                         else {
1469                                 catList = g_list_append(
1470                                         catList, g_strdup( "" ) );
1471                         }
1472                 }
1473         }
1474         return catList;
1475 }
1476
1477 /**
1478  * Build folder in address book for each category.
1479  * \param pilotFile  JPilot control data.
1480  */
1481 static void jpilot_build_category_list( JPilotFile *pilotFile ) {
1482         struct AddressAppInfo *ai = & pilotFile->addrInfo;
1483         struct CategoryAppInfo *cat = & ai->category;
1484         gint i;
1485
1486         for( i = 0; i < JPILOT_NUM_CATEG; i++ ) {
1487                 ItemFolder *folder = addritem_create_item_folder();
1488                 addritem_folder_set_name( folder, cat->name[i] );
1489                 addrcache_id_folder( pilotFile->addressCache, folder );
1490                 addrcache_add_folder( pilotFile->addressCache, folder );
1491         }
1492 }
1493
1494 /**
1495  * Remove empty (category) folders.
1496  * \param pilotFile  JPilot control data.
1497  */
1498 static void jpilot_remove_empty( JPilotFile *pilotFile ) {
1499         GList *listFolder;
1500         GList *remList;
1501         GList *node;
1502         gint i = 0;
1503
1504         listFolder = addrcache_get_list_folder( pilotFile->addressCache );
1505         node = listFolder;
1506         remList = NULL;
1507         while( node ) {
1508                 ItemFolder *folder = node->data;
1509                 if( ADDRITEM_NAME(folder) == NULL || *ADDRITEM_NAME(folder) == '\0' ) {
1510                         if( folder->listPerson ) {
1511                                 /* Give name to folder */
1512                                 gchar name[20];
1513                                 sprintf( name, "? %d", i );
1514                                 addritem_folder_set_name( folder, name );
1515                         }
1516                         else {
1517                                 /* Mark for removal */
1518                                 remList = g_list_append( remList, folder );
1519                         }
1520                 }
1521                 node = g_list_next( node );
1522                 i++;
1523         }
1524         node = remList;
1525         while( node ) {
1526                 ItemFolder *folder = node->data;
1527                 addrcache_remove_folder( pilotFile->addressCache, folder );
1528                 node = g_list_next( node );
1529         }
1530         g_list_free( remList );
1531 }
1532
1533 /**
1534  * Read address file into address cache.
1535  * \param pilotFile  JPilot control data.
1536  * \return Error/status code. <code>MGU_SUCCESS</code> if data read
1537  *         successfully.
1538  */
1539 static gint jpilot_read_file( JPilotFile *pilotFile ) {
1540         gint retVal, i;
1541         GList *records = NULL;
1542         GList *node;
1543         buf_rec *br;
1544         ItemFolder *folderInd[ JPILOT_NUM_CATEG ];
1545
1546         /* Read list of records from JPilot files */
1547         retVal = jpilot_read_db_files( pilotFile, &records );
1548         if( retVal != MGU_SUCCESS ) {
1549                 jpilot_free_addrlist( records );
1550                 return retVal;
1551         }
1552
1553         /* Setup labels and category folders */
1554         jpilot_setup_labels( pilotFile );
1555         jpilot_build_category_list( pilotFile );
1556
1557         /* Build array of pointers to categories */
1558         i = 0;
1559         node = addrcache_get_list_folder( pilotFile->addressCache );
1560         while( node ) {
1561                 if( i < JPILOT_NUM_CATEG ) {
1562                         folderInd[i] = node->data;
1563                 }
1564                 node = g_list_next( node );
1565                 i++;
1566         }
1567
1568         /* Load all addresses, free up old stuff as we go */
1569         node = records;
1570         while( node ) {
1571                 br = node->data;
1572                 if( ( br->rt != DELETED_PC_REC ) &&
1573                     ( br->rt != DELETED_PALM_REC ) &&
1574                     ( br->rt != MODIFIED_PALM_REC ) &&
1575                     ( br->rt != DELETED_DELETED_PALM_REC ) ) {
1576                         jpilot_load_address( pilotFile, br, folderInd );
1577                 }
1578                 free( br->buf );
1579                 free( br );
1580                 node->data = NULL;
1581                 node = g_list_next( node );
1582         }
1583
1584         /* Free up list */
1585         g_list_free( records );
1586
1587         /* Remove empty category folders */
1588         jpilot_remove_empty( pilotFile );
1589         jpilot_mark_files( pilotFile );
1590
1591         return retVal;
1592 }
1593
1594 /**
1595  * Read file into list. Main entry point
1596  * \param pilotFile  JPilot control data.
1597  * \return Error/status code. <code>MGU_SUCCESS</code> if data read
1598  *         successfully.
1599  */
1600 gint jpilot_read_data( JPilotFile *pilotFile ) {
1601         g_return_val_if_fail( pilotFile != NULL, -1 );
1602
1603         pilotFile->retVal = MGU_SUCCESS;
1604         pilotFile->addressCache->accessFlag = FALSE;
1605         if( jpilot_check_files( pilotFile ) ) {
1606                 addrcache_clear( pilotFile->addressCache );
1607                 jpilot_read_metadata( pilotFile );
1608                 if( pilotFile->retVal == MGU_SUCCESS ) {
1609                         pilotFile->retVal = jpilot_read_file( pilotFile );
1610                         if( pilotFile->retVal == MGU_SUCCESS ) {
1611                                 pilotFile->addressCache->modified = FALSE;
1612                                 pilotFile->addressCache->dataRead = TRUE;
1613                         }
1614                 }
1615         }
1616         return pilotFile->retVal;
1617 }
1618
1619 /**
1620  * Return linked list of persons. This is a list of references to ItemPerson
1621  * objects. Do <b>NOT</b> attempt to use the <code>addrbook_free_xxx()</code>
1622  * functions... this will destroy the addressbook data!
1623  *
1624  * \param  pilotFile  JPilot control data.
1625  * \return List of persons.
1626  */
1627 GList *jpilot_get_list_person( JPilotFile *pilotFile ) {
1628         g_return_val_if_fail( pilotFile != NULL, NULL );
1629         return addrcache_get_list_person( pilotFile->addressCache );
1630 }
1631
1632 /**
1633  * Return linked list of folders. This is a list of references to non-empty
1634  * category folders. Do <b>NOT</b> attempt to use the
1635  * <code>addrbook_free_xxx()</code> functions... this will destroy the
1636  * addressbook data!
1637  *
1638  * \param  pilotFile  JPilot control data.
1639  * \return List of ItemFolder objects. This should not be freed.
1640  */
1641 GList *jpilot_get_list_folder( JPilotFile *pilotFile ) {
1642         g_return_val_if_fail( pilotFile != NULL, NULL );
1643         return addrcache_get_list_folder( pilotFile->addressCache );
1644 }
1645
1646 /**
1647  * Return linked list of all persons. Note that the list contains references
1648  * to items. Do <b>NOT</b> attempt to use the <code>addrbook_free_xxx()</code>
1649  * functions... this will destroy the addressbook data!
1650  *
1651  * \param pilotFile  JPilot control data.
1652  * \return List of items, or NULL if none.
1653  */
1654 GList *jpilot_get_all_persons( JPilotFile *pilotFile ) {
1655         g_return_val_if_fail( pilotFile != NULL, NULL );
1656         return addrcache_get_all_persons( pilotFile->addressCache );
1657 }
1658
1659 /**
1660  * Check label list for specified label name.
1661  * \param ai Address info to check.
1662  * \param lblCheck Label name to check.
1663  * \return Index of label in address structure. <code>-1</code> if NULL/empty
1664  *         label name, <code>-2</code> if label not found.
1665 */
1666 static gint jpilot_check_label( struct AddressAppInfo *ai, gchar *lblCheck ) {
1667         gint i;
1668         gchar *lblName;
1669
1670         if( lblCheck == NULL ) return -1;
1671         if( strlen( lblCheck ) < 1 ) return -1;
1672         for( i = 0; i < JPILOT_NUM_LABELS; i++ ) {
1673                 lblName = ai->labels[i];
1674                 if( lblName ) {
1675                         if( strlen( lblName ) ) {
1676                                 if( g_strcasecmp( lblName, lblCheck ) == 0 ) return i;
1677                         }
1678                 }
1679         }
1680         return -2;
1681 }
1682
1683 /**
1684  * Validate that all parameters specified.
1685  * \param pilotFile  JPilot control data.
1686  * \return <i>TRUE</i> if data is good.
1687  */
1688 gboolean jpilot_validate( JPilotFile *pilotFile ) {
1689         gboolean retVal;
1690         gchar *name;
1691
1692         g_return_val_if_fail( pilotFile != NULL, FALSE );
1693
1694         retVal = TRUE;
1695         if( pilotFile->path ) {
1696                 if( strlen( pilotFile->path ) < 1 ) retVal = FALSE;
1697         }
1698         else {
1699                 retVal = FALSE;
1700         }
1701         name = jpilot_get_name( pilotFile );
1702         if( name ) {
1703                 if( strlen( name ) < 1 ) retVal = FALSE;
1704         }
1705         else {
1706                 retVal = FALSE;
1707         }
1708         return retVal;
1709 }
1710
1711 #define WORK_BUFLEN 1024
1712
1713 /**
1714  * Attempt to find a valid JPilot file.
1715  * \param pilotFile  JPilot control data.
1716  * \return Filename, or home directory if not found, or empty string if
1717  *         no home. Filename should be <code>g_free()</code> when done.
1718  */
1719 gchar *jpilot_find_pilotdb( void ) {
1720         gchar *homedir;
1721         gchar str[ WORK_BUFLEN ];
1722         gint len;
1723         FILE *fp;
1724
1725         homedir = g_get_home_dir();
1726         if( ! homedir ) return g_strdup( "" );
1727
1728         strcpy( str, homedir );
1729         len = strlen( str );
1730         if( len > 0 ) {
1731                 if( str[ len-1 ] != G_DIR_SEPARATOR ) {
1732                         str[ len ] = G_DIR_SEPARATOR;
1733                         str[ ++len ] = '\0';
1734                 }
1735         }
1736         strcat( str, JPILOT_DBHOME_DIR );
1737         strcat( str, G_DIR_SEPARATOR_S );
1738         strcat( str, JPILOT_DBHOME_FILE );
1739
1740         /* Attempt to open */
1741         if( ( fp = fopen( str, "rb" ) ) != NULL ) {
1742                 fclose( fp );
1743         }
1744         else {
1745                 /* Truncate filename */
1746                 str[ len ] = '\0';
1747         }
1748         return g_strdup( str );
1749 }
1750
1751 /**
1752  * Attempt to read file, testing for valid JPilot format.
1753  * \param fileSpec File specification to read.
1754  * \return <i>TRUE<i> if file appears to be valid format.
1755  */
1756 gint jpilot_test_read_file( const gchar *fileSpec ) {
1757         JPilotFile *pilotFile;
1758         gint retVal;
1759
1760         if( fileSpec ) {
1761                 pilotFile = jpilot_create_path( fileSpec );
1762                 retVal = jpilot_read_metadata( pilotFile );
1763                 jpilot_free( pilotFile );
1764                 pilotFile = NULL;
1765         }
1766         else {
1767                 retVal = MGU_NO_FILE;
1768         }
1769         return retVal;
1770 }
1771
1772 /**
1773  * Check whether label is in list of custom labels.
1774  * \param pilotFile JPilot control data.
1775  * \param labelName to test.
1776  * \return <i>TRUE</i> if found.
1777  */
1778 gboolean jpilot_test_custom_label( JPilotFile *pilotFile, const gchar *labelName ) {
1779         gboolean retVal;
1780         GList *node;
1781
1782         g_return_val_if_fail( pilotFile != NULL, FALSE );
1783
1784         retVal = FALSE;
1785         if( labelName ) {
1786                 node = pilotFile->customLabels;
1787                 while( node ) {
1788                         if( g_strcasecmp( labelName, ( gchar * ) node->data ) == 0 ) {
1789                                 retVal = TRUE;
1790                                 break;
1791                         }
1792                         node = g_list_next( node );
1793                 }
1794         }
1795         return retVal;
1796 }
1797
1798 /**
1799  * Test whether pilot link library installed.
1800  * \return <i>TRUE</i> if library available.
1801  */
1802 gboolean jpilot_test_pilot_lib( void ) {
1803         return TRUE;
1804 }
1805
1806 #endif  /* USE_JPILOT */
1807
1808 /*
1809 * End of Source.
1810 */