src/vcard.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2001 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 VCard files. VCard files are used
  22  * by GnomeCard for addressbook, and Netscape for sending business
  23  * card information. Refer to RFC2426 for more information.
  24  */
  25
  26 #include <glib.h>
  27 #include <sys/stat.h>
  28 #include <string.h>
  29
  30 #include "mgutils.h"
  31 #include "vcard.h"
  32 #include "addritem.h"
  33 #include "addrcache.h"
  34
  35 #define GNOMECARD_DIR     ".gnome"
  36 #define GNOMECARD_FILE    "GnomeCard"
  37 #define GNOMECARD_SECTION "[file]"
  38 #define GNOMECARD_PARAM   "open"
  39
  40 #define VCARD_TEST_LINES  200
  41
  42 /*
  43 * Create new cardfile object.
  44 */
  45 VCardFile *vcard_create() {
  46         VCardFile *cardFile;
  47         cardFile = g_new0( VCardFile, 1 );
  48         cardFile->name = NULL;
  49         cardFile->path = NULL;
  50         cardFile->file = NULL;
  51         cardFile->bufptr = cardFile->buffer;
  52         cardFile->addressCache = addrcache_create();
  53         cardFile->retVal = MGU_SUCCESS;
  54         cardFile->accessFlag = FALSE;
  55         return cardFile;
  56 }
  57
  58 /*
  59 * Properties...
  60 */
  61 void vcard_set_name( VCardFile* cardFile, const gchar *value ) {
  62         g_return_if_fail( cardFile != NULL );
  63         cardFile->name = mgu_replace_string( cardFile->name, value );
  64         g_strstrip( cardFile->name );
  65 }
  66 void vcard_set_file( VCardFile* cardFile, const gchar *value ) {
  67         g_return_if_fail( cardFile != NULL );
  68         addrcache_refresh( cardFile->addressCache );
  69         cardFile->path = mgu_replace_string( cardFile->path, value );
  70         g_strstrip( cardFile->path );
  71 }
  72 void vcard_set_accessed( VCardFile *cardFile, const gboolean value ) {
  73         g_return_if_fail( cardFile != NULL );
  74         cardFile->accessFlag = value;
  75 }
  76
  77 /*
  78 * Test whether file was modified since last access.
  79 * Return: TRUE if file was modified.
  80 */
  81 gboolean vcard_get_modified( VCardFile *vcardFile ) {
  82         g_return_val_if_fail( vcardFile != NULL, FALSE );
  83         return addrcache_check_file( vcardFile->addressCache, vcardFile->path );
  84 }
  85 gboolean vcard_get_accessed( VCardFile *vcardFile ) {
  86         g_return_val_if_fail( vcardFile != NULL, FALSE );
  87         return addrcache_check_file( vcardFile->addressCache, vcardFile->path );
  88 }
  89
  90 /*
  91 * Test whether file was read.
  92 * Return: TRUE if file was read.
  93 */
  94 gboolean vcard_get_read_flag( VCardFile *vcardFile ) {
  95         g_return_val_if_fail( vcardFile != NULL, FALSE );
  96         return vcardFile->addressCache->dataRead;
  97 }
  98
  99 /*
 100 * Return status code from last file operation.
 101 * Return: Status code.
 102 */
 103 gint vcard_get_status( VCardFile *cardFile ) {
 104         g_return_val_if_fail( cardFile != NULL, -1 );
 105         return cardFile->retVal;
 106 }
 107
 108 ItemFolder *vcard_get_root_folder( VCardFile *cardFile ) {
 109         g_return_val_if_fail( cardFile != NULL, NULL );
 110         return addrcache_get_root_folder( cardFile->addressCache );
 111 }
 112 gchar *vcard_get_name( VCardFile *cardFile ) {
 113         g_return_val_if_fail( cardFile != NULL, NULL );
 114         return cardFile->name;
 115 }
 116
 117 /*
 118 * Refresh internal variables to force a file read.
 119 */
 120 void vcard_force_refresh( VCardFile *cardFile ) {
 121         addrcache_refresh( cardFile->addressCache );
 122 }
 123
 124 /*
 125 * Create new cardfile object for specified file.
 126 */
 127 VCardFile *vcard_create_path( const gchar *path ) {
 128         VCardFile *cardFile;
 129         cardFile = vcard_create();
 130         vcard_set_file(cardFile, path);
 131         return cardFile;
 132 }
 133
 134 /*
 135 * Free up cardfile object by releasing internal memory.
 136 */
 137 void vcard_free( VCardFile *cardFile ) {
 138         g_return_if_fail( cardFile != NULL );
 139
 140         /* Close file */
 141         if( cardFile->file ) fclose( cardFile->file );
 142
 143         /* Free internal stuff */
 144         g_free( cardFile->name );
 145         g_free( cardFile->path );
 146
 147         /* Clear cache */
 148         addrcache_clear( cardFile->addressCache );
 149         addrcache_free( cardFile->addressCache );
 150
 151         // Clear pointers
 152         cardFile->file = NULL;
 153         cardFile->name = NULL;
 154         cardFile->path = NULL;
 155         cardFile->addressCache = NULL;
 156         cardFile->retVal = MGU_SUCCESS;
 157         cardFile->accessFlag = FALSE;
 158
 159         /* Now release file object */
 160         g_free( cardFile );
 161
 162 }
 163
 164 /*
 165 * Display object to specified stream.
 166 */
 167 void vcard_print_file( VCardFile *cardFile, FILE *stream ) {
 168         g_return_if_fail( cardFile != NULL );
 169
 170         fprintf( stream, "VCardFile:\n" );
 171         fprintf( stream, "     name: '%s'\n", cardFile->name );
 172         fprintf( stream, "file spec: '%s'\n", cardFile->path );
 173         fprintf( stream, "  ret val: %d\n",   cardFile->retVal );
 174         addrcache_print( cardFile->addressCache, stream );
 175         addritem_print_item_folder( cardFile->addressCache->rootFolder, stream );
 176 }
 177
 178 /*
 179 * Open file for read.
 180 * return: TRUE if file opened successfully.
 181 */
 182 static gint vcard_open_file( VCardFile* cardFile ) {
 183         g_return_val_if_fail( cardFile != NULL, -1 );
 184
 185         // fprintf( stdout, "Opening file\n" );
 186         cardFile->addressCache->dataRead = FALSE;
 187         if( cardFile->path ) {
 188                 cardFile->file = fopen( cardFile->path, "r" );
 189                 if( ! cardFile->file ) {
 190                         // fprintf( stderr, "can't open %s\n", cardFile->path );
 191                         cardFile->retVal = MGU_OPEN_FILE;
 192                         return cardFile->retVal;
 193                 }
 194         }
 195         else {
 196                 // fprintf( stderr, "file not specified\n" );
 197                 cardFile->retVal = MGU_NO_FILE;
 198                 return cardFile->retVal;
 199         }
 200
 201         /* Setup a buffer area */
 202         cardFile->buffer[0] = '\0';
 203         cardFile->bufptr = cardFile->buffer;
 204         cardFile->retVal = MGU_SUCCESS;
 205         return cardFile->retVal;
 206 }
 207
 208 /*
 209 * Close file.
 210 */
 211 static void vcard_close_file( VCardFile *cardFile ) {
 212         g_return_if_fail( cardFile != NULL );
 213         if( cardFile->file ) fclose( cardFile->file );
 214         cardFile->file = NULL;
 215 }
 216
 217 /*
 218 * Read line of text from file.
 219 * Return: ptr to buffer where line starts.
 220 */
 221 static gchar *vcard_read_line( VCardFile *cardFile ) {
 222         while( *cardFile->bufptr == '\n' || *cardFile->bufptr == '\0' ) {
 223                 if( fgets( cardFile->buffer, VCARDBUFSIZE, cardFile->file ) == NULL )
 224                         return NULL;
 225                 g_strstrip( cardFile->buffer );
 226                 cardFile->bufptr = cardFile->buffer;
 227         }
 228         return cardFile->bufptr;
 229 }
 230
 231 /*
 232 * Read line of text from file.
 233 * Return: ptr to buffer where line starts.
 234 */
 235 static gchar *vcard_get_line( VCardFile *cardFile ) {
 236         gchar buf[ VCARDBUFSIZE ];
 237         gchar *start, *end;
 238         gint len;
 239
 240         if (vcard_read_line( cardFile ) == NULL ) {
 241                 buf[0] = '\0';
 242                 return NULL;
 243         }
 244
 245         /* Copy into private buffer */
 246         start = cardFile->bufptr;
 247         len = strlen( start );
 248         end = start + len;
 249         strncpy( buf, start, len );
 250         buf[ len ] = '\0';
 251         g_strstrip(buf);
 252         cardFile->bufptr = end + 1;
 253
 254         /* Return a copy of buffer */
 255         return g_strdup( buf );
 256 }
 257
 258 /*
 259 * Free linked lists of character strings.
 260 */
 261 static void vcard_free_lists( GSList *listName, GSList *listAddr, GSList *listRem, GSList* listID ) {
 262         mgu_free_list( listName );
 263         mgu_free_list( listAddr );
 264         mgu_free_list( listRem );
 265         mgu_free_list( listID );
 266 }
 267
 268 /*
 269 * Read quoted-printable text, which may span several lines into one long string.
 270 * Param: cardFile - object.
 271 * Param: tagvalue - will be placed into the linked list.
 272 */
 273 static gchar *vcard_read_qp( VCardFile *cardFile, char *tagvalue ) {
 274         GSList *listQP = NULL;
 275         gint len = 0;
 276         gchar *line = tagvalue;
 277         while( line ) {
 278                 listQP = g_slist_append( listQP, line );
 279                 len = strlen( line ) - 1;
 280                 if( len > 0 ) {
 281                         if( line[ len ] != '=' ) break;
 282                         line[ len ] = '\0';
 283                 }
 284                 line = vcard_get_line( cardFile );
 285         }
 286
 287         // Coalesce linked list into one long buffer.
 288         line = mgu_list_coalesce( listQP );
 289
 290         // Clean up
 291         mgu_free_list( listQP );
 292         listQP = NULL;
 293         return line;
 294 }
 295
 296 /*
 297 * Parse tag name from line buffer.
 298 * Return: Buffer containing the tag name, or NULL if no delimiter char found.
 299 */
 300 static gchar *vcard_get_tagname( char* line, gchar dlm ) {
 301         gint len = 0;
 302         gchar *tag = NULL;
 303         gchar *lptr = line;
 304         while( *lptr++ ) {
 305                 if( *lptr == dlm ) {
 306                         len = lptr - line;
 307                         tag = g_strndup( line, len+1 );
 308                         tag[ len ] = '\0';
 309                         g_strdown( tag );
 310                         return tag;
 311                 }
 312         }
 313         return tag;
 314 }
 315
 316 /*
 317 * Parse tag value from line buffer.
 318 * Return: Buffer containing the tag value. Empty string is returned if
 319 * no delimiter char found.
 320 */
 321 static gchar *vcard_get_tagvalue( gchar* line, gchar dlm ) {
 322         gchar *value = NULL;
 323         gchar *start = NULL;
 324         gchar *lptr;
 325         gint len = 0;
 326
 327         for( lptr = line; *lptr; lptr++ ) {
 328                 if( *lptr == dlm ) {
 329                         if( ! start )
 330                                 start = lptr + 1;
 331                 }
 332         }
 333         if( start ) {
 334                 len = lptr - start;
 335                 value = g_strndup( start, len+1 );
 336         }
 337         else {
 338                 // Ensure that we get an empty string
 339                 value = g_strndup( "", 1 );
 340         }
 341         value[ len ] = '\0';
 342         return value;
 343 }
 344
 345 /*
 346 * Dump linked lists of character strings (for debug).
 347 */
 348 static void vcard_dump_lists( GSList *listName, GSList *listAddr, GSList *listRem, GSList *listID, FILE *stream ) {
 349         fprintf( stream, "dump name\n" );
 350         fprintf( stream, "------------\n" );
 351         mgu_print_list( listName, stdout );
 352         fprintf( stream, "dump address\n" );
 353         fprintf( stream, "------------\n" );
 354         mgu_print_list( listAddr, stdout );
 355         fprintf( stream, "dump remarks\n" );
 356         fprintf( stdout, "------------\n" );
 357         mgu_print_list( listRem, stdout );
 358         fprintf( stream, "dump id\n" );
 359         fprintf( stdout, "------------\n" );
 360         mgu_print_list( listID, stdout );
 361 }
 362
 363 /*
 364 * Build an address list entry and append to list of address items.
 365 */
 366 static void vcard_build_items( VCardFile *cardFile, GSList *listName, GSList *listAddr, GSList *listRem,
 367                                 GSList *listID )
 368 {
 369         GSList *nodeName = listName;
 370         GSList *nodeID = listID;
 371         gchar *str;
 372         while( nodeName ) {
 373                 GSList *nodeAddress = listAddr;
 374                 GSList *nodeRemarks = listRem;
 375                 ItemPerson *person = addritem_create_item_person();
 376                 addritem_person_set_common_name( person, nodeName->data );
 377                 while( nodeAddress ) {
 378                         str = nodeAddress->data;
 379                         if( *str != '\0' ) {
 380                                 ItemEMail *email = addritem_create_item_email();
 381                                 addritem_email_set_address( email, str );
 382                                 str = nodeRemarks->data;
 383                                 if( nodeRemarks ) {
 384                                         if( str ) {
 385                                                 if( g_strcasecmp( str, "internet" ) != 0 ) {
 386                                                         if( *str != '\0' ) addritem_email_set_remarks( email, str );
 387                                                 }
 388                                         }
 389                                 }
 390                                 addrcache_id_email( cardFile->addressCache, email );
 391                                 addrcache_person_add_email( cardFile->addressCache, person, email );
 392                         }
 393                         nodeAddress = g_slist_next( nodeAddress );
 394                         nodeRemarks = g_slist_next( nodeRemarks );
 395                 }
 396                 if( person->listEMail ) {
 397                         addrcache_id_person( cardFile->addressCache, person );
 398                         addrcache_add_person( cardFile->addressCache, person );
 399                 }
 400                 else {
 401                         addritem_free_item_person( person );
 402                 }
 403                 if( nodeID ) {
 404                         str = nodeID->data;
 405                         addritem_person_set_external_id( person, str );
 406                 }
 407                 nodeName = g_slist_next( nodeName );
 408                 nodeID = g_slist_next( nodeID );
 409         }
 410 }
 411
 412 // Unescape characters in quoted-printable string.
 413 static void vcard_unescape_qp( gchar *value ) {
 414         gchar *ptr, *src, *dest;
 415         gint d, v = 0;
 416         gchar ch;
 417         gboolean gotch;
 418         ptr = value;
 419         while( *ptr ) {
 420                 gotch = FALSE;
 421                 if( *ptr == '=' ) {
 422                         v = 0;
 423                         ch = *(ptr + 1);
 424                         if( ch ) {
 425                                 if( ch > '0' && ch < '8' ) v = ch - '0';
 426                         }
 427                         d = -1;
 428                         ch = *(ptr + 2);
 429                         if( ch ) {
 430                                 if( ch > '\x60' ) ch -= '\x20';
 431                                 if( ch > '0' && ch < ' ' ) d = ch - '0';
 432                                 d = ch - '0';
 433                                 if( d > 9 ) d -= 7;
 434                                 if( d > -1 && d < 16 ) {
 435                                         v = ( 16 * v ) + d;
 436                                         gotch = TRUE;
 437                                 }
 438                         }
 439                 }
 440                 if( gotch ) {
 441                         // Replace = with char and move down in buffer
 442                         *ptr = v;
 443                         src = ptr + 3;
 444                         dest = ptr + 1;
 445                         while( *src ) {
 446                                 *dest++ = *src++;
 447                         }
 448                         *dest = '\0';
 449                 }
 450                 ptr++;
 451         }
 452 }
 453
 454 /*
 455 * Read file data into root folder.
 456 * Note that one VCard can have multiple E-Mail addresses (MAIL tags);
 457 * these are broken out into separate address items. An address item
 458 * is generated for the person identified by FN tag and each EMAIL tag.
 459 * If a sub-type is included in the EMAIL entry, this will be used as
 460 * the Remarks member. Also note that it is possible for one VCard
 461 * entry to have multiple FN tags; this might not make sense. However,
 462 * it will generate duplicate address entries for each person listed.
 463 */
 464 static void vcard_read_file( VCardFile *cardFile ) {
 465         gchar *tagtemp = NULL, *tagname = NULL, *tagvalue = NULL, *tagtype = NULL;
 466         GSList *listName = NULL, *listAddress = NULL, *listRemarks = NULL, *listID = NULL;
 467         //GSList *listQP = NULL;
 468
 469         for( ;; ) {
 470                 gchar *line =  vcard_get_line( cardFile );
 471                 if( line == NULL ) break;
 472
 473                 // fprintf( stdout, "%s\n", line );
 474
 475                 /* Parse line */
 476                 tagtemp = vcard_get_tagname( line, VCARD_SEP_TAG );
 477                 if( tagtemp ) {
 478                         // fprintf( stdout, "\ttemp:  %s\n", tagtemp );
 479                         tagvalue = vcard_get_tagvalue( line, VCARD_SEP_TAG );
 480                         tagname = vcard_get_tagname( tagtemp, VCARD_SEP_TYPE );
 481                         tagtype = vcard_get_tagvalue( tagtemp, VCARD_SEP_TYPE );
 482                         if( tagname == NULL ) {
 483                                 tagname = tagtemp;
 484                                 tagtemp = NULL;
 485                         }
 486
 487                         // fprintf( stdout, "\tname:  %s\n", tagname );
 488                         // fprintf( stdout, "\ttype:  %s\n", tagtype );
 489                         // fprintf( stdout, "\tvalue: %s\n", tagvalue );
 490
 491                         if( tagvalue ) {
 492                                 if( g_strcasecmp( tagtype, VCARD_TYPE_QP ) == 0 ) {
 493                                         // Quoted-Printable: could span multiple lines
 494                                         tagvalue = vcard_read_qp( cardFile, tagvalue );
 495                                         vcard_unescape_qp( tagvalue );
 496                                         // fprintf( stdout, "QUOTED-PRINTABLE !!! final\n>%s<\n", tagvalue );
 497                                 }
 498
 499                                 if( g_strcasecmp( tagname, VCARD_TAG_START ) == 0 &&
 500                                         g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 501                                         // fprintf( stdout, "start card\n" );
 502                                         vcard_free_lists( listName, listAddress, listRemarks, listID );
 503                                         listName = listAddress = listRemarks = listID = NULL;
 504                                 }
 505                                 if( g_strcasecmp( tagname, VCARD_TAG_FULLNAME ) == 0 ) {
 506                                         // fprintf( stdout, "- full name: %s\n", tagvalue );
 507                                         listName = g_slist_append( listName, g_strdup( tagvalue ) );
 508                                 }
 509                                 if( g_strcasecmp( tagname, VCARD_TAG_EMAIL ) == 0 ) {
 510                                         // fprintf( stdout, "- address: %s\n", tagvalue );
 511                                         listAddress = g_slist_append( listAddress, g_strdup( tagvalue ) );
 512                                         listRemarks = g_slist_append( listRemarks, g_strdup( tagtype ) );
 513                                 }
 514                                 if( g_strcasecmp( tagname, VCARD_TAG_UID ) == 0 ) {
 515                                         // fprintf( stdout, "- id: %s\n", tagvalue );
 516                                         listID = g_slist_append( listID, g_strdup( tagvalue ) );
 517                                 }
 518                                 if( g_strcasecmp( tagname, VCARD_TAG_END ) == 0 &&
 519                                         g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 520                                         // VCard is complete
 521                                         // fprintf( stdout, "end card\n--\n" );
 522                                         // vcard_dump_lists( listName, listAddress, listRemarks, listID, stdout );
 523                                         vcard_build_items( cardFile, listName, listAddress, listRemarks, listID );
 524                                         vcard_free_lists( listName, listAddress, listRemarks, listID );
 525                                         listName = listAddress = listRemarks = listID = NULL;
 526                                 }
 527                                 g_free( tagvalue );
 528                         }
 529                         g_free( tagname );
 530                         g_free( tagtype );
 531                 }
 532         }
 533
 534         // Free lists
 535         vcard_free_lists( listName, listAddress, listRemarks, listID );
 536         listName = listAddress = listRemarks = listID = NULL;
 537 }
 538
 539 // ============================================================================================
 540 /*
 541 * Read file into list. Main entry point
 542 * Return: TRUE if file read successfully.
 543 */
 544 // ============================================================================================
 545 gint vcard_read_data( VCardFile *cardFile ) {
 546         g_return_val_if_fail( cardFile != NULL, -1 );
 547
 548         cardFile->retVal = MGU_SUCCESS;
 549         cardFile->accessFlag = FALSE;
 550         if( addrcache_check_file( cardFile->addressCache, cardFile->path ) ) {
 551                 addrcache_clear( cardFile->addressCache );
 552                 vcard_open_file( cardFile );
 553                 if( cardFile->retVal == MGU_SUCCESS ) {
 554                         // Read data into the list
 555                         vcard_read_file( cardFile );
 556                         vcard_close_file( cardFile );
 557
 558                         // Mark cache
 559                         addrcache_mark_file( cardFile->addressCache, cardFile->path );
 560                         cardFile->addressCache->modified = FALSE;
 561                         cardFile->addressCache->dataRead = TRUE;
 562                 }
 563         }
 564         return cardFile->retVal;
 565 }
 566
 567 /*
 568 * Return link list of persons.
 569 */
 570 GList *vcard_get_list_person( VCardFile *cardFile ) {
 571         g_return_val_if_fail( cardFile != NULL, NULL );
 572         return addrcache_get_list_person( cardFile->addressCache );
 573 }
 574
 575 /*
 576 * Return link list of folders. This is always NULL since there are
 577 * no folders in GnomeCard.
 578 * Return: NULL.
 579 */
 580 GList *vcard_get_list_folder( VCardFile *cardFile ) {
 581         g_return_val_if_fail( cardFile != NULL, NULL );
 582         return NULL;
 583 }
 584
 585 /*
 586 * Return link list of all persons. Note that the list contains references
 587 * to items. Do *NOT* attempt to use the addrbook_free_xxx() functions...
 588 * this will destroy the addressbook data!
 589 * Return: List of items, or NULL if none.
 590 */
 591 GList *vcard_get_all_persons( VCardFile *cardFile ) {
 592         g_return_val_if_fail( cardFile != NULL, NULL );
 593         return addrcache_get_all_persons( cardFile->addressCache );
 594 }
 595
 596 /*
 597 * Validate that all parameters specified.
 598 * Return: TRUE if data is good.
 599 */
 600 gboolean vcard_validate( const VCardFile *cardFile ) {
 601         gboolean retVal;
 602
 603         g_return_val_if_fail( cardFile != NULL, FALSE );
 604
 605         retVal = TRUE;
 606         if( cardFile->path ) {
 607                 if( strlen( cardFile->path ) < 1 ) retVal = FALSE;
 608         }
 609         else {
 610                 retVal = FALSE;
 611         }
 612         if( cardFile->name ) {
 613                 if( strlen( cardFile->name ) < 1 ) retVal = FALSE;
 614         }
 615         else {
 616                 retVal = FALSE;
 617         }
 618         return retVal;
 619 }
 620
 621 #define WORK_BUFLEN 1024
 622
 623 /*
 624 * Attempt to find a valid GnomeCard file.
 625 * Return: Filename, or home directory if not found. Filename should
 626 *       be g_free() when done.
 627 */
 628 gchar *vcard_find_gnomecard( void ) {
 629         gchar *homedir;
 630         gchar buf[ WORK_BUFLEN ];
 631         gchar str[ WORK_BUFLEN ];
 632         gchar *fileSpec;
 633         gint len, lenlbl, i;
 634         FILE *fp;
 635
 636         homedir = g_get_home_dir();
 637         if( ! homedir ) return NULL;
 638
 639         strcpy( str, homedir );
 640         len = strlen( str );
 641         if( len > 0 ) {
 642                 if( str[ len-1 ] != G_DIR_SEPARATOR ) {
 643                         str[ len ] = G_DIR_SEPARATOR;
 644                         str[ ++len ] = '\0';
 645                 }
 646         }
 647         strcat( str, GNOMECARD_DIR );
 648         strcat( str, G_DIR_SEPARATOR_S );
 649         strcat( str, GNOMECARD_FILE );
 650
 651         fileSpec = NULL;
 652         if( ( fp = fopen( str, "r" ) ) != NULL ) {
 653                 // Read configuration file
 654                 lenlbl = strlen( GNOMECARD_SECTION );
 655                 while( fgets( buf, sizeof( buf ), fp ) != NULL ) {
 656                         if( 0 == g_strncasecmp( buf, GNOMECARD_SECTION, lenlbl ) ) {
 657                                 break;
 658                         }
 659                 }
 660
 661                 while( fgets( buf, sizeof( buf ), fp ) != NULL ) {
 662                         g_strchomp( buf );
 663                         if( buf[0] == '[' ) break;
 664                         for( i = 0; i < lenlbl; i++ ) {
 665                                 if( buf[i] == '=' ) {
 666                                         if( 0 == g_strncasecmp( buf, GNOMECARD_PARAM, i ) ) {
 667                                                 fileSpec = g_strdup( buf + i + 1 );
 668                                                 g_strstrip( fileSpec );
 669                                         }
 670                                 }
 671                         }
 672                 }
 673                 fclose( fp );
 674         }
 675
 676         if( fileSpec == NULL ) {
 677                 // Use the home directory
 678                 str[ len ] = '\0';
 679                 fileSpec = g_strdup( str );
 680         }
 681
 682         return fileSpec;
 683 }
 684
 685 /*
 686 * Attempt to read file, testing for valid VCard format.
 687 * Return: TRUE if file appears to be valid format.
 688 */
 689 gint vcard_test_read_file( const gchar *fileSpec ) {
 690         gboolean haveStart;
 691         gchar *tagtemp = NULL, *tagname = NULL, *tagvalue = NULL, *tagtype = NULL, *line;
 692         VCardFile *cardFile;
 693         gint retVal, lines;
 694
 695         if( ! fileSpec ) return MGU_NO_FILE;
 696
 697         cardFile = vcard_create_path( fileSpec );
 698         cardFile->retVal = MGU_SUCCESS;
 699         vcard_open_file( cardFile );
 700         if( cardFile->retVal == MGU_SUCCESS ) {
 701                 cardFile->retVal = MGU_BAD_FORMAT;
 702                 haveStart = FALSE;
 703                 lines = VCARD_TEST_LINES;
 704                 while( lines > 0 ) {
 705                         lines--;
 706                         if( ( line =  vcard_get_line( cardFile ) ) == NULL ) break;
 707
 708                         /* Parse line */
 709                         tagtemp = vcard_get_tagname( line, VCARD_SEP_TAG );
 710                         if( tagtemp ) {
 711                                 tagvalue = vcard_get_tagvalue( line, VCARD_SEP_TAG );
 712                                 tagname = vcard_get_tagname( tagtemp, VCARD_SEP_TYPE );
 713                                 tagtype = vcard_get_tagvalue( tagtemp, VCARD_SEP_TYPE );
 714                                 if( tagname == NULL ) {
 715                                         tagname = tagtemp;
 716                                         tagtemp = NULL;
 717                                 }
 718
 719                                 if( tagvalue ) {
 720                                         if( g_strcasecmp( tagtype, VCARD_TYPE_QP ) == 0 ) {
 721                                                 // Quoted-Printable: could span multiple lines
 722                                                 tagvalue = vcard_read_qp( cardFile, tagvalue );
 723                                                 vcard_unescape_qp( tagvalue );
 724                                         }
 725                                         if( g_strcasecmp( tagname, VCARD_TAG_START ) == 0 &&
 726                                                 g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 727                                                 haveStart = TRUE;
 728                                         }
 729                                         if( g_strcasecmp( tagname, VCARD_TAG_END ) == 0 &&
 730                                                 g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 731                                                 // VCard is complete
 732                                                 if( haveStart ) cardFile->retVal = MGU_SUCCESS;
 733                                         }
 734                                         g_free( tagvalue );
 735                                 }
 736                                 g_free( tagname );
 737                                 g_free( tagtype );
 738                         }
 739                 }
 740                 vcard_close_file( cardFile );
 741         }
 742         retVal = cardFile->retVal;
 743         vcard_free( cardFile );
 744         cardFile = NULL;
 745         return retVal;
 746 }
 747
 748 /*
 749 * End of Source.
 750 */
 751