src/vcard.c

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