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