claws-mail/src/jpilot.c

1813 lines
44 KiB
C
Raw Normal View History

/*
* Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
2003-01-01 22:20:20 +01:00
* Copyright (C) 2001-2003 Match Grun
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
*/
/*
* Functions necessary to access JPilot database files.
* JPilot is Copyright(c) by Judd Montgomery.
* Visit http://www.jpilot.org for more details.
*/
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef USE_JPILOT
2001-09-13 15:38:32 +02:00
#include <glib.h>
#include <time.h>
#include <stdio.h>
2001-09-13 15:38:32 +02:00
#include <stdlib.h>
#include <string.h>
#include <sys/stat.h>
2001-10-20 09:04:54 +02:00
#include <netinet/in.h>
2001-09-13 15:38:32 +02:00
#ifdef HAVE_LIBPISOCK_PI_ARGS_H
# include <libpisock/pi-args.h>
# include <libpisock/pi-appinfo.h>
# include <libpisock/pi-address.h>
#else
# include <pi-args.h>
# include <pi-appinfo.h>
# include <pi-address.h>
#endif
#include "mgutils.h"
2001-09-02 01:48:06 +02:00
#include "addritem.h"
#include "addrcache.h"
#include "jpilot.h"
#include "adbookbase.h"
#define JPILOT_DBHOME_DIR ".jpilot"
#define JPILOT_DBHOME_FILE "AddressDB.pdb"
#define PILOT_LINK_LIB_NAME "libpisock.so"
2001-09-27 10:16:30 +02:00
#define IND_LABEL_LASTNAME 0 /* Index of last name in address data */
#define IND_LABEL_FIRSTNAME 1 /* Index of first name in address data */
#define IND_PHONE_EMAIL 4 /* Index of E-Mail address in phone labels */
#define OFFSET_PHONE_LABEL 3 /* Offset to phone data in address data */
#define IND_CUSTOM_LABEL 14 /* Offset to custom label names */
#define NUM_CUSTOM_LABEL 4 /* Number of custom labels */
/* Shamelessly copied from JPilot (libplugin.h) */
2001-09-02 01:48:06 +02:00
typedef struct {
unsigned char db_name[32];
unsigned char flags[2];
unsigned char version[2];
unsigned char creation_time[4];
unsigned char modification_time[4];
unsigned char backup_time[4];
unsigned char modification_number[4];
unsigned char app_info_offset[4];
unsigned char sort_info_offset[4];
unsigned char type[4];/*Database ID */
unsigned char creator_id[4];/*Application ID */
unsigned char unique_id_seed[4];
unsigned char next_record_list_id[4];
unsigned char number_of_records[2];
} RawDBHeader;
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.h) */
2001-09-02 01:48:06 +02:00
typedef struct {
char db_name[32];
unsigned int flags;
unsigned int version;
time_t creation_time;
time_t modification_time;
time_t backup_time;
unsigned int modification_number;
unsigned int app_info_offset;
unsigned int sort_info_offset;
char type[5];/*Database ID */
char creator_id[5];/*Application ID */
char unique_id_seed[5];
unsigned int next_record_list_id;
unsigned int number_of_records;
} DBHeader;
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.h) */
2001-09-02 01:48:06 +02:00
typedef struct {
unsigned char Offset[4]; /*4 bytes offset from BOF to record */
unsigned char attrib;
unsigned char unique_ID[3];
} record_header;
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.h) */
2001-09-02 01:48:06 +02:00
typedef struct mem_rec_header_s {
unsigned int rec_num;
unsigned int offset;
unsigned int unique_id;
unsigned char attrib;
struct mem_rec_header_s *next;
} mem_rec_header;
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.h) */
2001-09-02 01:48:06 +02:00
#define SPENT_PC_RECORD_BIT 256
typedef enum {
PALM_REC = 100L,
MODIFIED_PALM_REC = 101L,
DELETED_PALM_REC = 102L,
NEW_PC_REC = 103L,
DELETED_PC_REC = SPENT_PC_RECORD_BIT + 104L,
DELETED_DELETED_PALM_REC = SPENT_PC_RECORD_BIT + 105L
} PCRecType;
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.h) */
2001-09-02 01:48:06 +02:00
typedef struct {
PCRecType rt;
unsigned int unique_id;
unsigned char attrib;
void *buf;
int size;
} buf_rec;
/* Shamelessly copied from JPilot (libplugin.h) */
typedef struct {
2001-10-20 09:04:54 +02:00
unsigned long header_len;
unsigned long header_version;
unsigned long rec_len;
unsigned long unique_id;
unsigned long rt; /* Record Type */
unsigned char attrib;
} PC3RecordHeader;
2003-01-01 22:20:20 +01:00
/**
* Create new pilot file object.
2003-01-01 22:20:20 +01:00
* \return Initialized JPilot file object.
*/
JPilotFile *jpilot_create() {
JPilotFile *pilotFile;
2001-09-02 01:48:06 +02:00
pilotFile = g_new0( JPilotFile, 1 );
pilotFile->type = ADBOOKTYPE_JPILOT;
pilotFile->addressCache = addrcache_create();
pilotFile->retVal = MGU_SUCCESS;
pilotFile->file = NULL;
2001-09-02 01:48:06 +02:00
pilotFile->path = NULL;
pilotFile->readMetadata = FALSE;
pilotFile->customLabels = NULL;
pilotFile->labelInd = NULL;
pilotFile->havePC3 = FALSE;
pilotFile->pc3ModifyTime = 0;
return pilotFile;
}
2003-01-01 22:20:20 +01:00
/**
* Create new pilot file object for specified file.
* \param path Path to JPilot address book.
* \return Initialized JPilot file object.
*/
JPilotFile *jpilot_create_path( const gchar *path ) {
JPilotFile *pilotFile;
pilotFile = jpilot_create();
jpilot_set_file( pilotFile, path );
return pilotFile;
}
2001-09-02 01:48:06 +02:00
/*
* Properties...
*/
void jpilot_set_name( JPilotFile* pilotFile, const gchar *value ) {
g_return_if_fail( pilotFile != NULL );
addrcache_set_name( pilotFile->addressCache, value );
2001-09-02 01:48:06 +02:00
}
void jpilot_set_file( JPilotFile* pilotFile, const gchar *value ) {
g_return_if_fail( pilotFile != NULL );
addrcache_refresh( pilotFile->addressCache );
pilotFile->readMetadata = FALSE;
pilotFile->path = mgu_replace_string( pilotFile->path, value );
}
void jpilot_set_accessed( JPilotFile *pilotFile, const gboolean value ) {
g_return_if_fail( pilotFile != NULL );
2002-03-16 07:10:46 +01:00
pilotFile->addressCache->accessFlag = value;
2001-09-02 01:48:06 +02:00
}
gint jpilot_get_status( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, -1 );
2001-09-02 01:48:06 +02:00
return pilotFile->retVal;
}
ItemFolder *jpilot_get_root_folder( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
2001-09-02 01:48:06 +02:00
return addrcache_get_root_folder( pilotFile->addressCache );
}
gchar *jpilot_get_name( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
return addrcache_get_name( pilotFile->addressCache );
2001-09-02 01:48:06 +02:00
}
/*
2003-01-01 22:20:20 +01:00
* Test whether file was read.
* \param pilotFile JPilot control data.
* \return <i>TRUE</i> if file was read.
*/
2001-09-02 01:48:06 +02:00
gboolean jpilot_get_read_flag( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, FALSE );
2001-09-02 01:48:06 +02:00
return pilotFile->addressCache->dataRead;
}
2003-01-01 22:20:20 +01:00
/**
* Free up custom label list.
* \param pilotFile JPilot control data.
*/
void jpilot_clear_custom_labels( JPilotFile *pilotFile ) {
2001-09-02 01:48:06 +02:00
GList *node;
2001-09-13 15:38:32 +02:00
g_return_if_fail( pilotFile != NULL );
2001-09-27 10:16:30 +02:00
/* Release custom labels */
2001-09-02 01:48:06 +02:00
mgu_free_dlist( pilotFile->customLabels );
pilotFile->customLabels = NULL;
2001-09-27 10:16:30 +02:00
/* Release indexes */
node = pilotFile->labelInd;
while( node ) {
node->data = NULL;
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
2001-09-02 01:48:06 +02:00
g_list_free( pilotFile->labelInd );
pilotFile->labelInd = NULL;
2001-09-27 10:16:30 +02:00
/* Force a fresh read */
2001-09-02 01:48:06 +02:00
addrcache_refresh( pilotFile->addressCache );
}
2003-01-01 22:20:20 +01:00
/**
* Append a custom label, representing an E-Mail address field to the
* custom label list.
* \param pilotFile JPilot control data.
*/
void jpilot_add_custom_label( JPilotFile *pilotFile, const gchar *labelName ) {
g_return_if_fail( pilotFile != NULL );
if( labelName ) {
gchar *labelCopy = g_strdup( labelName );
g_strstrip( labelCopy );
if( *labelCopy == '\0' ) {
g_free( labelCopy );
}
else {
2001-09-02 01:48:06 +02:00
pilotFile->customLabels = g_list_append( pilotFile->customLabels, labelCopy );
2001-09-27 10:16:30 +02:00
/* Force a fresh read */
2001-09-02 01:48:06 +02:00
addrcache_refresh( pilotFile->addressCache );
}
}
}
2003-01-01 22:20:20 +01:00
/**
* Get list of custom labels.
* \param pilotFile JPilot control data.
* \return List of labels. Must use g_free() when done.
*/
GList *jpilot_get_custom_labels( JPilotFile *pilotFile ) {
GList *retVal = NULL;
2001-09-02 01:48:06 +02:00
GList *node;
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
node = pilotFile->customLabels;
while( node ) {
retVal = g_list_append( retVal, g_strdup( node->data ) );
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
return retVal;
}
2003-01-01 22:20:20 +01:00
/**
* Return filespec of PC3 file corresponding to JPilot PDB file.
* \param pilotFile JPilot control data.
* \return File specification; should be g_free() when done.
*/
static gchar *jpilot_get_pc3_file( JPilotFile *pilotFile ) {
gchar *fileSpec, *r;
gint i, len, pos;
if( pilotFile == NULL ) return NULL;
if( pilotFile->path == NULL ) return NULL;
fileSpec = g_strdup( pilotFile->path );
len = strlen( fileSpec );
pos = -1;
r = NULL;
for( i = len; i > 0; i-- ) {
if( *(fileSpec + i) == '.' ) {
pos = i + 1;
r = fileSpec + pos;
break;
}
}
if( r ) {
if( len - pos == 3 ) {
*r++ = 'p'; *r++ = 'c'; *r = '3';
return fileSpec;
}
}
g_free( fileSpec );
return NULL;
}
2003-01-01 22:20:20 +01:00
/**
* Save PC3 file time to cache.
* \param pilotFile JPilot control data.
* \return <i>TRUE</i> if time marked.
*/
static gboolean jpilot_mark_files( JPilotFile *pilotFile ) {
gboolean retVal = FALSE;
struct stat filestat;
gchar *pcFile;
/* Mark PDB file cache */
retVal = addrcache_mark_file( pilotFile->addressCache, pilotFile->path );
/* Now mark PC3 file */
pilotFile->havePC3 = FALSE;
pilotFile->pc3ModifyTime = 0;
pcFile = jpilot_get_pc3_file( pilotFile );
if( pcFile == NULL ) return retVal;
if( 0 == lstat( pcFile, &filestat ) ) {
pilotFile->havePC3 = TRUE;
pilotFile->pc3ModifyTime = filestat.st_mtime;
retVal = TRUE;
}
g_free( pcFile );
return retVal;
}
2003-01-01 22:20:20 +01:00
/**
* Check whether JPilot PDB or PC3 file has changed by comparing
* with cached data.
* \param pilotFile JPilot control data.
* \return <i>TRUE</i> if file has changed.
*/
static gboolean jpilot_check_files( JPilotFile *pilotFile ) {
gboolean retVal = TRUE;
struct stat filestat;
gchar *pcFile;
/* Check main file */
2001-10-20 09:04:54 +02:00
if( addrcache_check_file( pilotFile->addressCache, pilotFile->path ) )
return TRUE;
/* Test PC3 file */
if( ! pilotFile->havePC3 ) return FALSE;
pcFile = jpilot_get_pc3_file( pilotFile );
if( pcFile == NULL ) return FALSE;
if( 0 == lstat( pcFile, &filestat ) ) {
if( filestat.st_mtime == pilotFile->pc3ModifyTime ) retVal = FALSE;
}
g_free( pcFile );
return retVal;
}
/*
* Test whether file was modified since last access.
* Return: TRUE if file was modified.
*/
gboolean jpilot_get_modified( JPilotFile *pilotFile ) {
g_return_val_if_fail( pilotFile != NULL, FALSE );
2002-03-16 07:10:46 +01:00
pilotFile->addressCache->modified = jpilot_check_files( pilotFile );
return pilotFile->addressCache->modified;
}
void jpilot_set_modified( JPilotFile *pilotFile, const gboolean value ) {
g_return_if_fail( pilotFile != NULL );
pilotFile->addressCache->modified = value;
}
gboolean jpilot_get_accessed( JPilotFile *pilotFile ) {
g_return_val_if_fail( pilotFile != NULL, FALSE );
2002-03-16 07:10:46 +01:00
return pilotFile->addressCache->accessFlag;
}
2003-01-01 22:20:20 +01:00
/**
* Free up pilot file object by releasing internal memory.
* \param pilotFile JPilot control data.
*/
void jpilot_free( JPilotFile *pilotFile ) {
g_return_if_fail( pilotFile != NULL );
2001-09-27 10:16:30 +02:00
/* Release custom labels */
jpilot_clear_custom_labels( pilotFile );
/* Clear cache */
addrcache_clear( pilotFile->addressCache );
2001-09-02 01:48:06 +02:00
addrcache_free( pilotFile->addressCache );
/* Free internal stuff */
g_free( pilotFile->path );
pilotFile->file = NULL;
pilotFile->path = NULL;
pilotFile->readMetadata = FALSE;
pilotFile->havePC3 = FALSE;
pilotFile->pc3ModifyTime = 0;
pilotFile->type = ADBOOKTYPE_NONE;
pilotFile->addressCache = NULL;
pilotFile->retVal = MGU_SUCCESS;
/* Now release file object */
g_free( pilotFile );
}
/*
* Refresh internal variables to force a file read.
*/
void jpilot_force_refresh( JPilotFile *pilotFile ) {
2001-09-02 01:48:06 +02:00
addrcache_refresh( pilotFile->addressCache );
}
/*
2001-09-02 01:48:06 +02:00
* Print object to specified stream.
*/
2001-09-02 01:48:06 +02:00
void jpilot_print_file( JPilotFile *pilotFile, FILE *stream ) {
GList *node;
2001-09-13 15:38:32 +02:00
2001-09-02 01:48:06 +02:00
g_return_if_fail( pilotFile != NULL );
2001-09-13 15:38:32 +02:00
2001-09-02 01:48:06 +02:00
fprintf( stream, "JPilotFile:\n" );
fprintf( stream, "file spec: '%s'\n", pilotFile->path );
fprintf( stream, " metadata: %s\n", pilotFile->readMetadata ? "yes" : "no" );
fprintf( stream, " ret val: %d\n", pilotFile->retVal );
node = pilotFile->customLabels;
while( node ) {
2001-09-13 15:38:32 +02:00
fprintf( stream, " c label: %s\n", (gchar *)node->data );
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
2001-09-02 01:48:06 +02:00
node = pilotFile->labelInd;
while( node ) {
2001-09-02 01:48:06 +02:00
fprintf( stream, " labelind: %d\n", GPOINTER_TO_INT(node->data) );
node = g_list_next( node );
}
2001-09-02 01:48:06 +02:00
addrcache_print( pilotFile->addressCache, stream );
fprintf( stream, " ret val: %d\n", pilotFile->retVal );
fprintf( stream, " have pc3: %s\n", pilotFile->havePC3 ? "yes" : "no" );
2001-10-20 09:04:54 +02:00
fprintf( stream, " pc3 time: %lu\n", pilotFile->pc3ModifyTime );
2001-09-02 01:48:06 +02:00
addritem_print_item_folder( pilotFile->addressCache->rootFolder, stream );
}
/*
2001-09-02 01:48:06 +02:00
* Print summary of object to specified stream.
*/
2001-09-02 01:48:06 +02:00
void jpilot_print_short( JPilotFile *pilotFile, FILE *stream ) {
GList *node;
g_return_if_fail( pilotFile != NULL );
fprintf( stream, "JPilotFile:\n" );
fprintf( stream, "file spec: '%s'\n", pilotFile->path );
fprintf( stream, " metadata: %s\n", pilotFile->readMetadata ? "yes" : "no" );
fprintf( stream, " ret val: %d\n", pilotFile->retVal );
node = pilotFile->customLabels;
while( node ) {
2001-09-13 15:38:32 +02:00
fprintf( stream, " c label: %s\n", (gchar *)node->data );
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
node = pilotFile->labelInd;
while( node ) {
fprintf( stream, " labelind: %d\n", GPOINTER_TO_INT(node->data) );
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
2001-09-02 01:48:06 +02:00
addrcache_print( pilotFile->addressCache, stream );
fprintf( stream, " have pc3: %s\n", pilotFile->havePC3 ? "yes" : "no" );
2001-10-20 09:04:54 +02:00
fprintf( stream, " pc3 time: %lu\n", pilotFile->pc3ModifyTime );
}
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.c) */
static unsigned int bytes_to_bin(unsigned char *bytes, unsigned int num_bytes) {
2001-09-02 01:48:06 +02:00
unsigned int i, n;
n=0;
for (i=0;i<num_bytes;i++) {
n = n*256+bytes[i];
}
return n;
}
2001-09-30 13:07:34 +02:00
/* Shamelessly copied from JPilot (utils.c) */
/* These next 2 functions were copied from pi-file.c in the pilot-link app */
2001-09-30 13:07:34 +02:00
/* Exact value of "Jan 1, 1970 0:00:00 GMT" - "Jan 1, 1904 0:00:00 GMT" */
#define PILOT_TIME_DELTA (unsigned)(2082844800)
time_t pilot_time_to_unix_time ( unsigned long raw_time ) {
return (time_t)(raw_time - PILOT_TIME_DELTA);
}
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.c) */
static int raw_header_to_header(RawDBHeader *rdbh, DBHeader *dbh) {
2001-09-02 01:48:06 +02:00
unsigned long temp;
2001-09-13 15:38:32 +02:00
2001-09-02 01:48:06 +02:00
strncpy(dbh->db_name, rdbh->db_name, 31);
dbh->db_name[31] = '\0';
dbh->flags = bytes_to_bin(rdbh->flags, 2);
dbh->version = bytes_to_bin(rdbh->version, 2);
temp = bytes_to_bin(rdbh->creation_time, 4);
dbh->creation_time = pilot_time_to_unix_time(temp);
temp = bytes_to_bin(rdbh->modification_time, 4);
dbh->modification_time = pilot_time_to_unix_time(temp);
temp = bytes_to_bin(rdbh->backup_time, 4);
dbh->backup_time = pilot_time_to_unix_time(temp);
dbh->modification_number = bytes_to_bin(rdbh->modification_number, 4);
dbh->app_info_offset = bytes_to_bin(rdbh->app_info_offset, 4);
dbh->sort_info_offset = bytes_to_bin(rdbh->sort_info_offset, 4);
strncpy(dbh->type, rdbh->type, 4);
dbh->type[4] = '\0';
strncpy(dbh->creator_id, rdbh->creator_id, 4);
dbh->creator_id[4] = '\0';
strncpy(dbh->unique_id_seed, rdbh->unique_id_seed, 4);
dbh->unique_id_seed[4] = '\0';
dbh->next_record_list_id = bytes_to_bin(rdbh->next_record_list_id, 4);
dbh->number_of_records = bytes_to_bin(rdbh->number_of_records, 2);
return 0;
}
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.c) */
/* returns 1 if found */
/* 0 if eof */
static int find_next_offset( mem_rec_header *mem_rh, long fpos,
unsigned int *next_offset, unsigned char *attrib, unsigned int *unique_id )
{
mem_rec_header *temp_mem_rh;
unsigned char found = 0;
unsigned long found_at;
found_at=0xFFFFFF;
for (temp_mem_rh=mem_rh; temp_mem_rh; temp_mem_rh = temp_mem_rh->next) {
if ((temp_mem_rh->offset > fpos) && (temp_mem_rh->offset < found_at)) {
found_at = temp_mem_rh->offset;
/* *attrib = temp_mem_rh->attrib; */
/* *unique_id = temp_mem_rh->unique_id; */
}
if ((temp_mem_rh->offset == fpos)) {
found = 1;
*attrib = temp_mem_rh->attrib;
*unique_id = temp_mem_rh->unique_id;
}
}
*next_offset = found_at;
return found;
}
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.c) */
static void free_mem_rec_header(mem_rec_header **mem_rh) {
mem_rec_header *h, *next_h;
for (h=*mem_rh; h; h=next_h) {
next_h=h->next;
free(h);
}
*mem_rh = NULL;
}
2001-09-27 10:16:30 +02:00
/* Shamelessly copied from JPilot (libplugin.c) */
2001-09-02 01:48:06 +02:00
static int jpilot_free_db_list( GList **br_list ) {
GList *temp_list, *first;
buf_rec *br;
/* Go to first entry in the list */
first=NULL;
for( temp_list = *br_list; temp_list; temp_list = temp_list->prev ) {
first = temp_list;
}
for (temp_list = first; temp_list; temp_list = temp_list->next) {
if (temp_list->data) {
br=temp_list->data;
if (br->buf) {
free(br->buf);
temp_list->data=NULL;
}
free(br);
}
}
g_list_free(*br_list);
*br_list=NULL;
return 0;
}
2001-09-30 13:07:34 +02:00
/* Shamelessly copied from JPilot (libplugin.c) */
/* Read file size */
2001-09-02 01:48:06 +02:00
static int jpilot_get_info_size( FILE *in, int *size ) {
RawDBHeader rdbh;
DBHeader dbh;
unsigned int offset;
record_header rh;
fseek(in, 0, SEEK_SET);
fread(&rdbh, sizeof(RawDBHeader), 1, in);
if (feof(in)) {
return MGU_EOF;
}
raw_header_to_header(&rdbh, &dbh);
if (dbh.app_info_offset==0) {
*size=0;
return MGU_SUCCESS;
}
if (dbh.sort_info_offset!=0) {
*size = dbh.sort_info_offset - dbh.app_info_offset;
return MGU_SUCCESS;
}
if (dbh.number_of_records==0) {
fseek(in, 0, SEEK_END);
*size=ftell(in) - dbh.app_info_offset;
return MGU_SUCCESS;
}
fread(&rh, sizeof(record_header), 1, in);
offset = ((rh.Offset[0]*256+rh.Offset[1])*256+rh.Offset[2])*256+rh.Offset[3];
*size=offset - dbh.app_info_offset;
return MGU_SUCCESS;
}
/*
* Read address file into address list. Based on JPilot's
* libplugin.c (jp_get_app_info)
*/
2001-09-02 01:48:06 +02:00
static gint jpilot_get_file_info( JPilotFile *pilotFile, unsigned char **buf, int *buf_size ) {
FILE *in;
int num;
unsigned int rec_size;
RawDBHeader rdbh;
DBHeader dbh;
if( ( !buf_size ) || ( ! buf ) ) {
return MGU_BAD_ARGS;
}
*buf = NULL;
*buf_size=0;
if( pilotFile->path ) {
2002-03-14 11:17:32 +01:00
in = fopen( pilotFile->path, "rb" );
if( !in ) {
return MGU_OPEN_FILE;
}
}
else {
return MGU_NO_FILE;
}
num = fread( &rdbh, sizeof( RawDBHeader ), 1, in );
if( num != 1 ) {
if( ferror(in) ) {
fclose(in);
return MGU_ERROR_READ;
}
}
if (feof(in)) {
fclose(in);
return MGU_EOF;
}
2001-09-27 10:16:30 +02:00
/* Convert header into something recognizable */
raw_header_to_header(&rdbh, &dbh);
num = jpilot_get_info_size(in, &rec_size);
if (num) {
fclose(in);
return MGU_ERROR_READ;
}
fseek(in, dbh.app_info_offset, SEEK_SET);
*buf = ( char * ) malloc(rec_size);
if (!(*buf)) {
fclose(in);
return MGU_OO_MEMORY;
}
num = fread(*buf, rec_size, 1, in);
if (num != 1) {
if (ferror(in)) {
fclose(in);
free(*buf);
return MGU_ERROR_READ;
}
}
fclose(in);
*buf_size = rec_size;
return MGU_SUCCESS;
}
/* Shamelessly copied from JPilot (libplugin.c) */
static int unpack_header(PC3RecordHeader *header, unsigned char *packed_header) {
unsigned char *p;
unsigned long l;
p = packed_header;
memcpy(&l, p, sizeof(l));
header->header_len=ntohl(l);
p+=sizeof(l);
memcpy(&l, p, sizeof(l));
header->header_version=ntohl(l);
p+=sizeof(l);
memcpy(&l, p, sizeof(l));
header->rec_len=ntohl(l);
p+=sizeof(l);
memcpy(&l, p, sizeof(l));
header->unique_id=ntohl(l);
p+=sizeof(l);
memcpy(&l, p, sizeof(l));
header->rt=ntohl(l);
p+=sizeof(l);
memcpy(&(header->attrib), p, sizeof(unsigned char));
p+=sizeof(unsigned char);
return 0;
}
/* Shamelessly copied from JPilot (libplugin.c) */
static int read_header(FILE *pc_in, PC3RecordHeader *header) {
unsigned long l, len;
unsigned char packed_header[256];
int num;
num = fread(&l, sizeof(l), 1, pc_in);
if (feof(pc_in)) {
return -1;
2001-10-20 09:04:54 +02:00
}
if (num!=1) {
return num;
}
memcpy(packed_header, &l, sizeof(l));
len=ntohl(l);
if (len > 255) {
return -1;
}
num = fread(packed_header+sizeof(l), len-sizeof(l), 1, pc_in);
if (feof(pc_in)) {
return -1;
2001-10-20 09:04:54 +02:00
}
if (num!=1) {
return num;
}
unpack_header(header, packed_header);
return 1;
}
2003-01-01 22:20:20 +01:00
/**
* Read next record from PC3 file. Based on JPilot function
* <code>pc_read_next_rec()</code> (libplugin.c)
*
* \param in File handle.
* \param br Record buffer.
* \return Status/error code. <code>MGU_SUCCESS</code> if data read
* successfully.
*/
static gint jpilot_read_next_pc( FILE *in, buf_rec *br ) {
PC3RecordHeader header;
int rec_len, num;
char *record;
2001-10-20 09:04:54 +02:00
2003-01-01 22:20:20 +01:00
if( feof( in ) ) {
2001-10-20 09:04:54 +02:00
return MGU_EOF;
}
2003-01-01 22:20:20 +01:00
num = read_header( in, &header );
if( num < 1 ) {
if( ferror( in ) ) {
2001-10-20 09:04:54 +02:00
return MGU_ERROR_READ;
}
2003-01-01 22:20:20 +01:00
if( feof( in ) ) {
2001-10-20 09:04:54 +02:00
return MGU_EOF;
}
}
rec_len = header.rec_len;
2003-01-01 22:20:20 +01:00
record = malloc( rec_len );
if( ! record ) {
return MGU_OO_MEMORY;
}
2003-01-01 22:20:20 +01:00
num = fread( record, rec_len, 1, in );
if( num != 1 ) {
if( ferror( in ) ) {
free( record );
2001-10-20 09:04:54 +02:00
return MGU_ERROR_READ;
}
}
br->rt = header.rt;
br->unique_id = header.unique_id;
br->attrib = header.attrib;
br->buf = record;
br->size = rec_len;
return MGU_SUCCESS;
}
2003-01-01 22:20:20 +01:00
/**
* Read address file into a linked list. Based on JPilot function
* <code>jp_read_DB_files()</code> (from libplugin.c)
*
* \param pilotFile JPilot control data.
* \param records Pointer to linked list of records read.
* \return Status/error code. <code>MGU_SUCCESS</code> if data read
* successfully.
*/
static gint jpilot_read_db_files( JPilotFile *pilotFile, GList **records ) {
FILE *in, *pc_in;
char *buf;
GList *temp_list;
int num_records, recs_returned, i, num, r;
unsigned int offset, prev_offset, next_offset, rec_size;
int out_of_order;
long fpos; /*file position indicator */
unsigned char attrib;
unsigned int unique_id;
mem_rec_header *mem_rh, *temp_mem_rh, *last_mem_rh;
record_header rh;
RawDBHeader rdbh;
DBHeader dbh;
buf_rec *temp_br;
gchar *pcFile;
mem_rh = last_mem_rh = NULL;
*records = NULL;
recs_returned = 0;
if( pilotFile->path == NULL ) {
2001-10-20 09:04:54 +02:00
return MGU_BAD_ARGS;
}
2001-10-20 09:04:54 +02:00
2002-03-14 11:17:32 +01:00
in = fopen( pilotFile->path, "rb" );
2003-01-01 22:20:20 +01:00
if( ! in ) {
2001-10-20 09:04:54 +02:00
return MGU_OPEN_FILE;
}
/* Read the database header */
2003-01-01 22:20:20 +01:00
num = fread( &rdbh, sizeof( RawDBHeader ), 1, in );
if( num != 1 ) {
if( ferror( in ) ) {
fclose( in );
return MGU_ERROR_READ;
}
2003-01-01 22:20:20 +01:00
if( feof( in ) ) {
fclose( in );
return MGU_EOF;
}
}
2003-01-01 22:20:20 +01:00
raw_header_to_header( &rdbh, &dbh );
/* Read each record entry header */
num_records = dbh.number_of_records;
out_of_order = 0;
prev_offset = 0;
2001-10-20 09:04:54 +02:00
2003-01-01 22:20:20 +01:00
for( i = 1; i < num_records + 1; i++ ) {
num = fread( &rh, sizeof( record_header ), 1, in );
if( num != 1 ) {
if( ferror( in ) ) {
break;
}
2003-01-01 22:20:20 +01:00
if( feof( in ) ) {
fclose( in );
return MGU_EOF;
}
}
2003-01-01 22:20:20 +01:00
offset =
( ( rh.Offset[0] * 256 + rh.Offset[1] ) * 256
+ rh.Offset[2] ) * 256
+ rh.Offset[3];
if( offset < prev_offset ) {
out_of_order = 1;
}
prev_offset = offset;
2003-01-01 22:20:20 +01:00
temp_mem_rh = ( mem_rec_header * ) malloc( sizeof( mem_rec_header ) );
if( ! temp_mem_rh ) {
break;
}
temp_mem_rh->next = NULL;
temp_mem_rh->rec_num = i;
temp_mem_rh->offset = offset;
temp_mem_rh->attrib = rh.attrib;
2003-01-01 22:20:20 +01:00
temp_mem_rh->unique_id =
( rh.unique_ID[0] * 256 + rh.unique_ID[1] ) * 256
+ rh.unique_ID[2];
if( mem_rh == NULL ) {
mem_rh = temp_mem_rh;
last_mem_rh = temp_mem_rh;
2003-01-01 22:20:20 +01:00
}
else {
last_mem_rh->next = temp_mem_rh;
last_mem_rh = temp_mem_rh;
}
}
temp_mem_rh = mem_rh;
2003-01-01 22:20:20 +01:00
if( num_records ) {
if( out_of_order ) {
find_next_offset(
mem_rh, 0, &next_offset, &attrib, &unique_id );
}
else {
if( mem_rh ) {
next_offset = mem_rh->offset;
attrib = mem_rh->attrib;
unique_id = mem_rh->unique_id;
}
}
2003-01-01 22:20:20 +01:00
fseek( in, next_offset, SEEK_SET );
while( ! feof( in ) ) {
fpos = ftell( in );
if( out_of_order ) {
find_next_offset(
mem_rh, fpos, &next_offset, &attrib,
&unique_id );
} else {
next_offset = 0xFFFFFF;
2003-01-01 22:20:20 +01:00
if( temp_mem_rh ) {
attrib = temp_mem_rh->attrib;
unique_id = temp_mem_rh->unique_id;
2003-01-01 22:20:20 +01:00
if ( temp_mem_rh->next ) {
temp_mem_rh = temp_mem_rh->next;
next_offset = temp_mem_rh->offset;
}
}
}
rec_size = next_offset - fpos;
2003-01-01 22:20:20 +01:00
buf = malloc( rec_size );
if( ! buf ) break;
num = fread( buf, rec_size, 1, in );
if( ( num != 1 ) ) {
if( ferror( in ) ) {
free( buf );
break;
}
}
2003-01-01 22:20:20 +01:00
temp_br = malloc( sizeof( buf_rec ) );
if( ! temp_br ) {
free( buf );
break;
}
temp_br->rt = PALM_REC;
temp_br->unique_id = unique_id;
temp_br->attrib = attrib;
temp_br->buf = buf;
temp_br->size = rec_size;
2003-01-01 22:20:20 +01:00
*records = g_list_append( *records, temp_br );
2001-10-20 09:04:54 +02:00
recs_returned++;
}
}
2003-01-01 22:20:20 +01:00
fclose( in );
free_mem_rec_header( &mem_rh );
/* Read the PC3 file, if present */
pcFile = jpilot_get_pc3_file( pilotFile );
if( pcFile == NULL ) return MGU_SUCCESS;
2002-03-16 07:10:46 +01:00
pc_in = fopen( pcFile, "rb" );
g_free( pcFile );
2001-10-20 09:04:54 +02:00
if( pc_in == NULL ) {
return MGU_SUCCESS;
}
while( ! feof( pc_in ) ) {
2003-01-01 22:20:20 +01:00
gboolean linked;
temp_br = malloc( sizeof( buf_rec ) );
if( ! temp_br ) {
break;
}
r = jpilot_read_next_pc( pc_in, temp_br );
2003-01-01 22:20:20 +01:00
if( r != MGU_SUCCESS ) {
if( (r != MGU_EOF) && (r != MGU_ERROR_READ) ) {
free( temp_br->buf );
}
2003-01-01 22:20:20 +01:00
free( temp_br );
break;
}
2003-01-01 22:20:20 +01:00
linked = FALSE;
if( ( temp_br->rt != DELETED_PC_REC )
&& ( temp_br->rt != DELETED_PALM_REC )
&& ( temp_br->rt != MODIFIED_PALM_REC )
&& ( temp_br->rt != DELETED_DELETED_PALM_REC ) )
{
*records = g_list_append( *records, temp_br );
recs_returned++;
linked = TRUE;
}
2003-01-01 22:20:20 +01:00
if( ( temp_br->rt == DELETED_PALM_REC )
|| ( temp_br->rt == MODIFIED_PALM_REC ) )
{
temp_list = *records;
if( *records ) {
while( temp_list->next ) {
temp_list=temp_list->next;
}
}
2003-01-01 22:20:20 +01:00
for( ; temp_list; temp_list=temp_list->prev ) {
if( ( ( buf_rec * )temp_list->data )->unique_id ==
temp_br->unique_id ) {
( ( buf_rec * )temp_list->data )->rt =
temp_br->rt;
}
}
}
2003-01-01 22:20:20 +01:00
if( ! linked ) {
free( temp_br->buf );
free( temp_br );
}
}
2003-01-01 22:20:20 +01:00
fclose( pc_in );
return MGU_SUCCESS;
}
2003-01-01 22:20:20 +01:00
/**
* Parse buffer containing multiple e-mail addresses into a linked list of
* addresses. Separator characters are " ,;|" and control characters. Address
* is only extracted if it contains an "at" (@) character.
2003-01-01 22:20:20 +01:00
*
* \param buf Buffer to process.
* \return List of strings.
*/
static GList *jpilot_parse_email( gchar *buf ) {
GList *list;
gchar *p, *st, *em;
gchar lch;
gint len;
gboolean valid, done;
valid = done = FALSE;
lch = ' ';
list = NULL;
p = st = buf;
while( ! done ) {
if( *p == ' ' || *p == ',' || *p == ';' || *p == '|' || *p < 32 ) {
if( *p == '\0' ) {
done = TRUE;
}
else {
*p = ' ';
}
if( *p == lch ) {
st++;
}
else {
len = p - st;
if( len > 0 ) {
if( valid ) {
em = g_strndup( st, len );
list = g_list_append( list, em );
}
st = p;
++st;
valid = FALSE;
}
}
}
if( *p == '@' ) valid = TRUE;
lch = *p;
++p;
}
return list;
}
2001-10-20 09:04:54 +02:00
#define FULLNAME_BUFSIZE 256
#define EMAIL_BUFSIZE 256
2003-01-01 22:20:20 +01:00
/**
* Process a single label entry field, parsing multiple e-mail address entries.
2003-01-01 22:20:20 +01:00
*
* \param pilotFile JPilot control data.
* \param labelEntry Label entry data.
* \param person Person.
*/
static void jpilot_parse_label( JPilotFile *pilotFile, gchar *labelEntry, ItemPerson *person ) {
gchar buffer[ EMAIL_BUFSIZE ];
ItemEMail *email;
GList *list, *node;
if( labelEntry ) {
*buffer = '\0';
strcpy( buffer, labelEntry );
node = list = jpilot_parse_email( buffer );
while( node ) {
email = addritem_create_item_email();
addritem_email_set_address( email, node->data );
addrcache_id_email( pilotFile->addressCache, email );
addrcache_person_add_email( pilotFile->addressCache, person, email );
node = g_list_next( node );
}
mgu_free_dlist( list );
list = NULL;
}
}
2003-01-01 22:20:20 +01:00
/**
* Unpack address, building new data inside cache.
2003-01-01 22:20:20 +01:00
* \param pilotFile JPilot control data.
* \param buf Record buffer.
* \param folderInd Array of (category) folders to load.
*/
2003-01-01 22:20:20 +01:00
static void jpilot_load_address(
JPilotFile *pilotFile, buf_rec *buf, ItemFolder *folderInd[] )
{
struct Address addr;
gchar **addrEnt;
gint num, k;
gint cat_id = 0;
guint unique_id;
guchar attrib;
gchar fullName[ FULLNAME_BUFSIZE ];
ItemPerson *person;
gint *indPhoneLbl;
gchar *labelEntry;
GList *node;
gchar* extID;
struct AddressAppInfo *ai;
/* Retrieve address */
num = unpack_Address( & addr, buf->buf, buf->size );
if( num > 0 ) {
addrEnt = addr.entry;
attrib = buf->attrib;
unique_id = buf->unique_id;
2001-10-20 09:04:54 +02:00
cat_id = attrib & 0x0F;
*fullName = '\0';
if( addrEnt[ IND_LABEL_FIRSTNAME ] ) {
strcat( fullName, addrEnt[ IND_LABEL_FIRSTNAME ] );
}
2001-09-02 01:48:06 +02:00
if( addrEnt[ IND_LABEL_LASTNAME ] ) {
strcat( fullName, " " );
strcat( fullName, addrEnt[ IND_LABEL_LASTNAME ] );
}
g_strchug( fullName );
g_strchomp( fullName );
person = addritem_create_item_person();
addritem_person_set_common_name( person, fullName );
addritem_person_set_first_name( person, addrEnt[ IND_LABEL_FIRSTNAME ] );
addritem_person_set_last_name( person, addrEnt[ IND_LABEL_LASTNAME ] );
addrcache_id_person( pilotFile->addressCache, person );
extID = g_strdup_printf( "%d", unique_id );
addritem_person_set_external_id( person, extID );
g_free( extID );
extID = NULL;
/* Pointer to address metadata. */
ai = & pilotFile->addrInfo;
/* Add entry for each email address listed under phone labels. */
indPhoneLbl = addr.phoneLabel;
for( k = 0; k < JPILOT_NUM_ADDR_PHONE; k++ ) {
gint ind;
ind = indPhoneLbl[k];
/*
* fprintf( stdout, "%d : %d : %20s : %s\n", k, ind,
* ai->phoneLabels[ind], addrEnt[3+k] );
*/
if( indPhoneLbl[k] == IND_PHONE_EMAIL ) {
labelEntry = addrEnt[ OFFSET_PHONE_LABEL + k ];
jpilot_parse_label( pilotFile, labelEntry, person );
}
}
/* Add entry for each custom label */
node = pilotFile->labelInd;
while( node ) {
gint ind;
ind = GPOINTER_TO_INT( node->data );
if( ind > -1 ) {
/*
* fprintf( stdout, "%d : %20s : %s\n", ind, ai->labels[ind],
* addrEnt[ind] );
*/
labelEntry = addrEnt[ind];
jpilot_parse_label( pilotFile, labelEntry, person );
}
node = g_list_next( node );
}
if( person->listEMail ) {
if( cat_id > -1 && cat_id < JPILOT_NUM_CATEG ) {
/* Add to specified category */
2003-01-01 22:20:20 +01:00
addrcache_folder_add_person(
pilotFile->addressCache,
folderInd[cat_id], person );
}
else {
/* Add to root folder */
2003-01-01 22:20:20 +01:00
addrcache_add_person(
pilotFile->addressCache, person );
}
2003-01-01 22:20:20 +01:00
}
else {
addritem_free_item_person( person );
person = NULL;
}
}
2003-01-01 22:20:20 +01:00
/* Free up pointer allocated inside address */
free_Address( & addr );
}
2003-01-01 22:20:20 +01:00
/**
* Free up address list.
2003-01-01 22:20:20 +01:00
* \param records List of records to free.
*/
static void jpilot_free_addrlist( GList *records ) {
GList *node;
buf_rec *br;
node = records;
while( node ) {
br = node->data;
2003-01-01 22:20:20 +01:00
free( br->buf );
free( br );
node->data = NULL;
node = g_list_next( node );
}
/* Free up list */
g_list_free( records );
}
2003-01-01 22:20:20 +01:00
/**
* Read metadata from file.
* \param pilotFile JPilot control data.
* \return Status/error code. <code>MGU_SUCCESS</code> if data read
* successfully.
*/
2001-09-02 01:48:06 +02:00
static gint jpilot_read_metadata( JPilotFile *pilotFile ) {
gint retVal;
unsigned int rec_size;
unsigned char *buf;
int num;
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, -1 );
pilotFile->readMetadata = FALSE;
2001-09-02 01:48:06 +02:00
addrcache_clear( pilotFile->addressCache );
2001-09-27 10:16:30 +02:00
/* Read file info */
retVal = jpilot_get_file_info( pilotFile, &buf, &rec_size);
if( retVal != MGU_SUCCESS ) {
pilotFile->retVal = retVal;
return pilotFile->retVal;
}
num = unpack_AddressAppInfo( &pilotFile->addrInfo, buf, rec_size );
if( buf ) {
free(buf);
}
if( num <= 0 ) {
pilotFile->retVal = MGU_ERROR_READ;
return pilotFile->retVal;
}
pilotFile->readMetadata = TRUE;
pilotFile->retVal = MGU_SUCCESS;
return pilotFile->retVal;
}
2003-01-01 22:20:20 +01:00
/**
* Setup labels and indexes from metadata.
* \param pilotFile JPilot control data.
* \return <i>TRUE</i> is setup successfully.
*/
2001-09-02 01:48:06 +02:00
static gboolean jpilot_setup_labels( JPilotFile *pilotFile ) {
gboolean retVal = FALSE;
struct AddressAppInfo *ai;
2001-09-02 01:48:06 +02:00
GList *node;
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, -1 );
2001-09-27 10:16:30 +02:00
/* Release indexes */
node = pilotFile->labelInd;
while( node ) {
node->data = NULL;
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
pilotFile->labelInd = NULL;
if( pilotFile->readMetadata ) {
ai = & pilotFile->addrInfo;
node = pilotFile->customLabels;
while( node ) {
2001-09-02 01:48:06 +02:00
gchar *lbl = node->data;
gint ind = -1;
gint i;
for( i = 0; i < JPILOT_NUM_LABELS; i++ ) {
2001-09-02 01:48:06 +02:00
gchar *labelName = ai->labels[i];
if( g_strcasecmp( labelName, lbl ) == 0 ) {
ind = i;
break;
}
}
2003-01-01 22:20:20 +01:00
pilotFile->labelInd = g_list_append(
pilotFile->labelInd, GINT_TO_POINTER(ind) );
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
retVal = TRUE;
}
return retVal;
}
2003-01-01 22:20:20 +01:00
/**
* Load list with character strings of label names.
* \param pilotFile JPilot control data.
* \param labelList List of label names to load.
* \return List of label names loaded.
*/
2001-09-02 01:48:06 +02:00
GList *jpilot_load_label( JPilotFile *pilotFile, GList *labelList ) {
int i;
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
if( pilotFile->readMetadata ) {
struct AddressAppInfo *ai = & pilotFile->addrInfo;
for( i = 0; i < JPILOT_NUM_LABELS; i++ ) {
gchar *labelName = ai->labels[i];
if( labelName ) {
2003-01-01 22:20:20 +01:00
labelList = g_list_append(
labelList, g_strdup( labelName ) );
}
else {
2003-01-01 22:20:20 +01:00
labelList = g_list_append(
labelList, g_strdup( "" ) );
}
}
}
return labelList;
}
2003-01-01 22:20:20 +01:00
/**
* Return category name for specified category ID.
* \param pilotFile JPilot control data.
* \param catID Category ID.
* \return Category name, or empty string if not invalid ID. Name should be
* <code>g_free()</code> when done.
*/
gchar *jpilot_get_category_name( JPilotFile *pilotFile, gint catID ) {
gchar *catName = NULL;
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
if( pilotFile->readMetadata ) {
struct AddressAppInfo *ai = & pilotFile->addrInfo;
struct CategoryAppInfo *cat = & ai->category;
if( catID < 0 || catID > JPILOT_NUM_CATEG ) {
}
else {
catName = g_strdup( cat->name[catID] );
}
}
if( ! catName ) catName = g_strdup( "" );
return catName;
}
2003-01-01 22:20:20 +01:00
/**
* Load list with character strings of phone label names.
* \param pilotFile JPilot control data.
* \param labelList List of label names to load.
* \return List of label names loaded.
*/
2001-09-02 01:48:06 +02:00
GList *jpilot_load_phone_label( JPilotFile *pilotFile, GList *labelList ) {
2001-09-13 15:38:32 +02:00
gint i;
g_return_val_if_fail( pilotFile != NULL, NULL );
if( pilotFile->readMetadata ) {
struct AddressAppInfo *ai = & pilotFile->addrInfo;
for( i = 0; i < JPILOT_NUM_PHONELABELS; i++ ) {
gchar *labelName = ai->phoneLabels[i];
if( labelName ) {
2003-01-01 22:20:20 +01:00
labelList = g_list_append(
labelList, g_strdup( labelName ) );
}
else {
2003-01-01 22:20:20 +01:00
labelList = g_list_append(
labelList, g_strdup( "" ) );
}
}
}
return labelList;
}
2003-01-01 22:20:20 +01:00
/**
* Load list with character strings of custom label names. Only none blank
* names are loaded.
* \param pilotFile JPilot control data.
* \param labelList List of label names to load.
* \return List of label names loaded. Should be freed when done.
*/
GList *jpilot_load_custom_label( JPilotFile *pilotFile, GList *labelList ) {
2001-09-13 15:38:32 +02:00
gint i;
g_return_val_if_fail( pilotFile != NULL, NULL );
if( pilotFile->readMetadata ) {
struct AddressAppInfo *ai = & pilotFile->addrInfo;
for( i = 0; i < NUM_CUSTOM_LABEL; i++ ) {
gchar *labelName = ai->labels[i+IND_CUSTOM_LABEL];
if( labelName ) {
g_strchomp( labelName );
g_strchug( labelName );
if( *labelName != '\0' ) {
2003-01-01 22:20:20 +01:00
labelList = g_list_append( labelList,
g_strdup( labelName ) );
}
}
}
}
return labelList;
}
2003-01-01 22:20:20 +01:00
/**
* Load list with character strings of category names.
* \param pilotFile JPilot control data.
* \return List of label names loaded. Should be freed when done.
*/
2001-09-02 01:48:06 +02:00
GList *jpilot_get_category_list( JPilotFile *pilotFile ) {
GList *catList = NULL;
2001-09-13 15:38:32 +02:00
gint i;
g_return_val_if_fail( pilotFile != NULL, NULL );
if( pilotFile->readMetadata ) {
struct AddressAppInfo *ai = & pilotFile->addrInfo;
struct CategoryAppInfo *cat = & ai->category;
for( i = 0; i < JPILOT_NUM_CATEG; i++ ) {
gchar *catName = cat->name[i];
if( catName ) {
2003-01-01 22:20:20 +01:00
catList = g_list_append(
catList, g_strdup( catName ) );
}
else {
2003-01-01 22:20:20 +01:00
catList = g_list_append(
catList, g_strdup( "" ) );
}
}
}
return catList;
}
2003-01-01 22:20:20 +01:00
/**
* Build folder in address book for each category.
* \param pilotFile JPilot control data.
*/
2001-09-02 01:48:06 +02:00
static void jpilot_build_category_list( JPilotFile *pilotFile ) {
struct AddressAppInfo *ai = & pilotFile->addrInfo;
struct CategoryAppInfo *cat = & ai->category;
2001-09-02 01:48:06 +02:00
gint i;
2001-09-13 15:38:32 +02:00
2001-09-02 01:48:06 +02:00
for( i = 0; i < JPILOT_NUM_CATEG; i++ ) {
ItemFolder *folder = addritem_create_item_folder();
addritem_folder_set_name( folder, cat->name[i] );
addrcache_id_folder( pilotFile->addressCache, folder );
addrcache_add_folder( pilotFile->addressCache, folder );
}
}
2003-01-01 22:20:20 +01:00
/**
* Remove empty (category) folders.
* \param pilotFile JPilot control data.
*/
2001-09-02 01:48:06 +02:00
static void jpilot_remove_empty( JPilotFile *pilotFile ) {
GList *listFolder;
GList *remList;
GList *node;
2001-09-02 01:48:06 +02:00
gint i = 0;
listFolder = addrcache_get_list_folder( pilotFile->addressCache );
node = listFolder;
remList = NULL;
while( node ) {
2001-09-02 01:48:06 +02:00
ItemFolder *folder = node->data;
if( ADDRITEM_NAME(folder) == NULL || *ADDRITEM_NAME(folder) == '\0' ) {
if( folder->listPerson ) {
2001-09-27 10:16:30 +02:00
/* Give name to folder */
2001-09-02 01:48:06 +02:00
gchar name[20];
sprintf( name, "? %d", i );
addritem_folder_set_name( folder, name );
}
else {
2001-09-27 10:16:30 +02:00
/* Mark for removal */
2001-09-02 01:48:06 +02:00
remList = g_list_append( remList, folder );
}
}
node = g_list_next( node );
2001-09-02 01:48:06 +02:00
i++;
}
2001-09-02 01:48:06 +02:00
node = remList;
while( node ) {
ItemFolder *folder = node->data;
addrcache_remove_folder( pilotFile->addressCache, folder );
node = g_list_next( node );
}
g_list_free( remList );
}
2003-01-01 22:20:20 +01:00
/**
* Read address file into address cache.
* \param pilotFile JPilot control data.
* \return Error/status code. <code>MGU_SUCCESS</code> if data read
* successfully.
*/
static gint jpilot_read_file( JPilotFile *pilotFile ) {
gint retVal, i;
GList *records = NULL;
GList *node;
buf_rec *br;
ItemFolder *folderInd[ JPILOT_NUM_CATEG ];
/* Read list of records from JPilot files */
retVal = jpilot_read_db_files( pilotFile, &records );
if( retVal != MGU_SUCCESS ) {
jpilot_free_addrlist( records );
return retVal;
}
/* Setup labels and category folders */
jpilot_setup_labels( pilotFile );
jpilot_build_category_list( pilotFile );
/* Build array of pointers to categories */
i = 0;
node = addrcache_get_list_folder( pilotFile->addressCache );
while( node ) {
if( i < JPILOT_NUM_CATEG ) {
folderInd[i] = node->data;
}
node = g_list_next( node );
i++;
}
/* Load all addresses, free up old stuff as we go */
node = records;
while( node ) {
br = node->data;
if( ( br->rt != DELETED_PC_REC ) &&
( br->rt != DELETED_PALM_REC ) &&
( br->rt != MODIFIED_PALM_REC ) &&
( br->rt != DELETED_DELETED_PALM_REC ) ) {
jpilot_load_address( pilotFile, br, folderInd );
}
free( br->buf );
free( br );
node->data = NULL;
node = g_list_next( node );
}
/* Free up list */
g_list_free( records );
/* Remove empty category folders */
jpilot_remove_empty( pilotFile );
jpilot_mark_files( pilotFile );
return retVal;
}
/**
* Read file into list. Main entry point
* \param pilotFile JPilot control data.
* \return Error/status code. <code>MGU_SUCCESS</code> if data read
* successfully.
*/
gint jpilot_read_data( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, -1 );
pilotFile->retVal = MGU_SUCCESS;
2002-03-16 07:10:46 +01:00
pilotFile->addressCache->accessFlag = FALSE;
if( jpilot_check_files( pilotFile ) ) {
2001-09-02 01:48:06 +02:00
addrcache_clear( pilotFile->addressCache );
jpilot_read_metadata( pilotFile );
if( pilotFile->retVal == MGU_SUCCESS ) {
2001-09-02 01:48:06 +02:00
pilotFile->retVal = jpilot_read_file( pilotFile );
if( pilotFile->retVal == MGU_SUCCESS ) {
pilotFile->addressCache->modified = FALSE;
pilotFile->addressCache->dataRead = TRUE;
}
}
}
return pilotFile->retVal;
}
2003-01-01 22:20:20 +01:00
/**
* Return linked list of persons. This is a list of references to ItemPerson
* objects. Do <b>NOT</b> attempt to use the <code>addrbook_free_xxx()</code>
* functions... this will destroy the addressbook data!
*
* \param pilotFile JPilot control data.
* \return List of persons.
*/
2001-09-02 01:48:06 +02:00
GList *jpilot_get_list_person( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
2001-09-02 01:48:06 +02:00
return addrcache_get_list_person( pilotFile->addressCache );
}
2003-01-01 22:20:20 +01:00
/**
* Return linked list of folders. This is a list of references to non-empty
* category folders. Do <b>NOT</b> attempt to use the
* <code>addrbook_free_xxx()</code> functions... this will destroy the
* addressbook data!
*
* \param pilotFile JPilot control data.
* \return List of ItemFolder objects. This should not be freed.
*/
2001-09-02 01:48:06 +02:00
GList *jpilot_get_list_folder( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
2001-09-02 01:48:06 +02:00
return addrcache_get_list_folder( pilotFile->addressCache );
}
2003-01-01 22:20:20 +01:00
/**
* Return linked list of all persons. Note that the list contains references
* to items. Do <b>NOT</b> attempt to use the <code>addrbook_free_xxx()</code>
* functions... this will destroy the addressbook data!
*
* \param pilotFile JPilot control data.
* \return List of items, or NULL if none.
*/
2001-09-02 01:48:06 +02:00
GList *jpilot_get_all_persons( JPilotFile *pilotFile ) {
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, NULL );
2001-09-02 01:48:06 +02:00
return addrcache_get_all_persons( pilotFile->addressCache );
}
2003-01-01 22:20:20 +01:00
/**
* Check label list for specified label name.
* \param ai Address info to check.
* \param lblCheck Label name to check.
* \return Index of label in address structure. <code>-1</code> if NULL/empty
* label name, <code>-2</code> if label not found.
*/
2003-01-01 22:20:20 +01:00
static gint jpilot_check_label( struct AddressAppInfo *ai, gchar *lblCheck ) {
2001-09-13 15:38:32 +02:00
gint i;
gchar *lblName;
if( lblCheck == NULL ) return -1;
if( strlen( lblCheck ) < 1 ) return -1;
for( i = 0; i < JPILOT_NUM_LABELS; i++ ) {
lblName = ai->labels[i];
if( lblName ) {
if( strlen( lblName ) ) {
if( g_strcasecmp( lblName, lblCheck ) == 0 ) return i;
}
}
}
return -2;
}
2003-01-01 22:20:20 +01:00
/**
* Validate that all parameters specified.
* \param pilotFile JPilot control data.
* \return <i>TRUE</i> if data is good.
*/
gboolean jpilot_validate( JPilotFile *pilotFile ) {
gboolean retVal;
gchar *name;
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, FALSE );
retVal = TRUE;
if( pilotFile->path ) {
if( strlen( pilotFile->path ) < 1 ) retVal = FALSE;
}
else {
retVal = FALSE;
}
name = jpilot_get_name( pilotFile );
if( name ) {
if( strlen( name ) < 1 ) retVal = FALSE;
}
else {
retVal = FALSE;
}
return retVal;
}
#define WORK_BUFLEN 1024
2003-01-01 22:20:20 +01:00
/**
* Attempt to find a valid JPilot file.
* \param pilotFile JPilot control data.
* \return Filename, or home directory if not found, or empty string if
* no home. Filename should be <code>g_free()</code> when done.
*/
gchar *jpilot_find_pilotdb( void ) {
gchar *homedir;
gchar str[ WORK_BUFLEN ];
gint len;
FILE *fp;
homedir = g_get_home_dir();
if( ! homedir ) return g_strdup( "" );
strcpy( str, homedir );
len = strlen( str );
if( len > 0 ) {
if( str[ len-1 ] != G_DIR_SEPARATOR ) {
str[ len ] = G_DIR_SEPARATOR;
str[ ++len ] = '\0';
}
}
strcat( str, JPILOT_DBHOME_DIR );
strcat( str, G_DIR_SEPARATOR_S );
strcat( str, JPILOT_DBHOME_FILE );
2001-09-27 10:16:30 +02:00
/* Attempt to open */
2002-07-02 23:37:37 +02:00
if( ( fp = fopen( str, "rb" ) ) != NULL ) {
fclose( fp );
}
else {
2001-09-27 10:16:30 +02:00
/* Truncate filename */
str[ len ] = '\0';
}
return g_strdup( str );
}
2003-01-01 22:20:20 +01:00
/**
* Attempt to read file, testing for valid JPilot format.
* \param fileSpec File specification to read.
* \return <i>TRUE<i> if file appears to be valid format.
*/
gint jpilot_test_read_file( const gchar *fileSpec ) {
JPilotFile *pilotFile;
gint retVal;
2001-09-13 15:38:32 +02:00
if( fileSpec ) {
pilotFile = jpilot_create_path( fileSpec );
retVal = jpilot_read_metadata( pilotFile );
jpilot_free( pilotFile );
pilotFile = NULL;
}
else {
retVal = MGU_NO_FILE;
}
return retVal;
}
2003-01-01 22:20:20 +01:00
/**
* Check whether label is in list of custom labels.
* \param pilotFile JPilot control data.
* \param labelName to test.
* \return <i>TRUE</i> if found.
*/
gboolean jpilot_test_custom_label( JPilotFile *pilotFile, const gchar *labelName ) {
gboolean retVal;
2001-09-02 01:48:06 +02:00
GList *node;
2001-09-13 15:38:32 +02:00
g_return_val_if_fail( pilotFile != NULL, FALSE );
retVal = FALSE;
if( labelName ) {
node = pilotFile->customLabels;
while( node ) {
if( g_strcasecmp( labelName, ( gchar * ) node->data ) == 0 ) {
retVal = TRUE;
break;
}
2001-09-02 01:48:06 +02:00
node = g_list_next( node );
}
}
return retVal;
}
2003-01-01 22:20:20 +01:00
/**
* Test whether pilot link library installed.
* \return <i>TRUE</i> if library available.
*/
2001-09-13 15:38:32 +02:00
gboolean jpilot_test_pilot_lib( void ) {
return TRUE;
}
#endif /* USE_JPILOT */
/*
* End of Source.
*/