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, gchar *tagvalue ) {
 274         GSList *listQP = NULL;
 275         gint len = 0;
 276         gchar *line = tagvalue;
 277
 278         while( line ) {
 279                 listQP = g_slist_append( listQP, line );
 280                 len = strlen( line ) - 1;
 281                 if( len > 0 ) {
 282                         if( line[ len ] != '=' ) break;
 283                         line[ len ] = '\0';
 284                 }
 285                 line = vcard_get_line( cardFile );
 286         }
 287
 288         /* Coalesce linked list into one long buffer. */
 289         line = mgu_list_coalesce( listQP );
 290
 291         /* Clean up */
 292         mgu_free_list( listQP );
 293         listQP = NULL;
 294         return line;
 295 }
 296
 297 /*
 298 * Parse tag name from line buffer.
 299 * Return: Buffer containing the tag name, or NULL if no delimiter char found.
 300 */
 301 static gchar *vcard_get_tagname( gchar* line, gchar dlm ) {
 302         gint len = 0;
 303         gchar *tag = NULL;
 304         gchar *lptr = line;
 305
 306         while( *lptr++ ) {
 307                 if( *lptr == dlm ) {
 308                         len = lptr - line;
 309                         tag = g_strndup( line, len+1 );
 310                         tag[ len ] = '\0';
 311                         g_strdown( tag );
 312                         return tag;
 313                 }
 314         }
 315         return tag;
 316 }
 317
 318 /*
 319 * Parse tag value from line buffer.
 320 * Return: Buffer containing the tag value. Empty string is returned if
 321 * no delimiter char found.
 322 */
 323 static gchar *vcard_get_tagvalue( gchar* line, gchar dlm ) {
 324         gchar *value = NULL;
 325         gchar *start = NULL;
 326         gchar *lptr;
 327         gint len = 0;
 328
 329         for( lptr = line; *lptr; lptr++ ) {
 330                 if( *lptr == dlm ) {
 331                         if( ! start )
 332                                 start = lptr + 1;
 333                 }
 334         }
 335         if( start ) {
 336                 len = lptr - start;
 337                 value = g_strndup( start, len+1 );
 338         }
 339         else {
 340                 /* Ensure that we get an empty string */
 341                 value = g_strndup( "", 1 );
 342         }
 343         value[ len ] = '\0';
 344         return value;
 345 }
 346
 347 /*
 348 * Dump linked lists of character strings (for debug).
 349 */
 350 static void vcard_dump_lists( GSList *listName, GSList *listAddr, GSList *listRem, GSList *listID, FILE *stream ) {
 351         fprintf( stream, "dump name\n" );
 352         fprintf( stream, "------------\n" );
 353         mgu_print_list( listName, stdout );
 354         fprintf( stream, "dump address\n" );
 355         fprintf( stream, "------------\n" );
 356         mgu_print_list( listAddr, stdout );
 357         fprintf( stream, "dump remarks\n" );
 358         fprintf( stdout, "------------\n" );
 359         mgu_print_list( listRem, stdout );
 360         fprintf( stream, "dump id\n" );
 361         fprintf( stdout, "------------\n" );
 362         mgu_print_list( listID, stdout );
 363 }
 364
 365 /*
 366 * Build an address list entry and append to list of address items.
 367 */
 368 static void vcard_build_items( VCardFile *cardFile, GSList *listName, GSList *listAddr, GSList *listRem,
 369                                 GSList *listID )
 370 {
 371         GSList *nodeName = listName;
 372         GSList *nodeID = listID;
 373         gchar *str;
 374         while( nodeName ) {
 375                 GSList *nodeAddress = listAddr;
 376                 GSList *nodeRemarks = listRem;
 377                 ItemPerson *person = addritem_create_item_person();
 378                 addritem_person_set_common_name( person, nodeName->data );
 379                 while( nodeAddress ) {
 380                         str = nodeAddress->data;
 381                         if( *str != '\0' ) {
 382                                 ItemEMail *email = addritem_create_item_email();
 383                                 addritem_email_set_address( email, str );
 384                                 str = nodeRemarks->data;
 385                                 if( nodeRemarks ) {
 386                                         if( str ) {
 387                                                 if( g_strcasecmp( str, "internet" ) != 0 ) {
 388                                                         if( *str != '\0' ) addritem_email_set_remarks( email, str );
 389                                                 }
 390                                         }
 391                                 }
 392                                 addrcache_id_email( cardFile->addressCache, email );
 393                                 addrcache_person_add_email( cardFile->addressCache, person, email );
 394                         }
 395                         nodeAddress = g_slist_next( nodeAddress );
 396                         nodeRemarks = g_slist_next( nodeRemarks );
 397                 }
 398                 if( person->listEMail ) {
 399                         addrcache_id_person( cardFile->addressCache, person );
 400                         addrcache_add_person( cardFile->addressCache, person );
 401                 }
 402                 else {
 403                         addritem_free_item_person( person );
 404                 }
 405                 if( nodeID ) {
 406                         str = nodeID->data;
 407                         addritem_person_set_external_id( person, str );
 408                 }
 409                 nodeName = g_slist_next( nodeName );
 410                 nodeID = g_slist_next( nodeID );
 411         }
 412 }
 413
 414 /* Unescape characters in quoted-printable string. */
 415 static void vcard_unescape_qp( gchar *value ) {
 416         gchar *ptr, *src, *dest;
 417         gint d, v = 0;
 418         gchar ch;
 419         gboolean gotch;
 420         ptr = value;
 421         while( *ptr ) {
 422                 gotch = FALSE;
 423                 if( *ptr == '=' ) {
 424                         v = 0;
 425                         ch = *(ptr + 1);
 426                         if( ch ) {
 427                                 if( ch > '0' && ch < '8' ) v = ch - '0';
 428                         }
 429                         d = -1;
 430                         ch = *(ptr + 2);
 431                         if( ch ) {
 432                                 if( ch > '\x60' ) ch -= '\x20';
 433                                 if( ch > '0' && ch < ' ' ) d = ch - '0';
 434                                 d = ch - '0';
 435                                 if( d > 9 ) d -= 7;
 436                                 if( d > -1 && d < 16 ) {
 437                                         v = ( 16 * v ) + d;
 438                                         gotch = TRUE;
 439                                 }
 440                         }
 441                 }
 442                 if( gotch ) {
 443                         /* Replace = with char and move down in buffer */
 444                         *ptr = v;
 445                         src = ptr + 3;
 446                         dest = ptr + 1;
 447                         while( *src ) {
 448                                 *dest++ = *src++;
 449                         }
 450                         *dest = '\0';
 451                 }
 452                 ptr++;
 453         }
 454 }
 455
 456 /*
 457 * Read file data into root folder.
 458 * Note that one vCard can have multiple E-Mail addresses (MAIL tags);
 459 * these are broken out into separate address items. An address item
 460 * is generated for the person identified by FN tag and each EMAIL tag.
 461 * If a sub-type is included in the EMAIL entry, this will be used as
 462 * the Remarks member. Also note that it is possible for one vCard
 463 * entry to have multiple FN tags; this might not make sense. However,
 464 * it will generate duplicate address entries for each person listed.
 465 */
 466 static void vcard_read_file( VCardFile *cardFile ) {
 467         gchar *tagtemp = NULL, *tagname = NULL, *tagvalue = NULL, *tagtype = NULL;
 468         GSList *listName = NULL, *listAddress = NULL, *listRemarks = NULL, *listID = NULL;
 469         /* GSList *listQP = NULL; */
 470
 471         for( ;; ) {
 472                 gchar *line;
 473
 474                 line = vcard_get_line( cardFile );
 475                 if( line == NULL ) break;
 476
 477                 /* fprintf( stdout, "%s\n", line ); */
 478
 479                 /* Parse line */
 480                 tagtemp = vcard_get_tagname( line, VCARD_SEP_TAG );
 481                 if( tagtemp == NULL ) {
 482                         g_free( line );
 483                         continue;
 484                 }
 485
 486                 /* fprintf( stdout, "\ttemp:  %s\n", tagtemp ); */
 487
 488                 tagvalue = vcard_get_tagvalue( line, VCARD_SEP_TAG );
 489                 if( tagvalue == NULL ) {
 490                         g_free( tagtemp );
 491                         g_free( line );
 492                         continue;
 493                 }
 494
 495                 tagname = vcard_get_tagname( tagtemp, VCARD_SEP_TYPE );
 496                 tagtype = vcard_get_tagvalue( tagtemp, VCARD_SEP_TYPE );
 497                 if( tagname == NULL ) {
 498                         tagname = tagtemp;
 499                         tagtemp = NULL;
 500                 }
 501
 502                 /* fprintf( stdout, "\tname:  %s\n", tagname ); */
 503                 /* fprintf( stdout, "\ttype:  %s\n", tagtype ); */
 504                 /* fprintf( stdout, "\tvalue: %s\n", tagvalue ); */
 505
 506                 if( g_strcasecmp( tagtype, VCARD_TYPE_QP ) == 0 ) {
 507                         /* Quoted-Printable: could span multiple lines */
 508                         tagvalue = vcard_read_qp( cardFile, tagvalue );
 509                         vcard_unescape_qp( tagvalue );
 510                         /* fprintf( stdout, "QUOTED-PRINTABLE !!! final\n>%s<\n", tagvalue ); */
 511                 }
 512
 513                 if( g_strcasecmp( tagname, VCARD_TAG_START ) == 0 &&
 514                         g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 515                         /* fprintf( stdout, "start card\n" ); */
 516                         vcard_free_lists( listName, listAddress, listRemarks, listID );
 517                         listName = listAddress = listRemarks = listID = NULL;
 518                 }
 519                 if( g_strcasecmp( tagname, VCARD_TAG_FULLNAME ) == 0 ) {
 520                         /* fprintf( stdout, "- full name: %s\n", tagvalue ); */
 521                         listName = g_slist_append( listName, g_strdup( tagvalue ) );
 522                 }
 523                 if( g_strcasecmp( tagname, VCARD_TAG_EMAIL ) == 0 ) {
 524                         /* fprintf( stdout, "- address: %s\n", tagvalue ); */
 525                         listAddress = g_slist_append( listAddress, g_strdup( tagvalue ) );
 526                         listRemarks = g_slist_append( listRemarks, g_strdup( tagtype ) );
 527                 }
 528                 if( g_strcasecmp( tagname, VCARD_TAG_UID ) == 0 ) {
 529                         /* fprintf( stdout, "- id: %s\n", tagvalue ); */
 530                         listID = g_slist_append( listID, g_strdup( tagvalue ) );
 531                 }
 532                 if( g_strcasecmp( tagname, VCARD_TAG_END ) == 0 &&
 533                         g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 534                         /* vCard is complete */
 535                         /* fprintf( stdout, "end card\n--\n" ); */
 536                         /* vcard_dump_lists( listName, listAddress, listRemarks, listID, stdout ); */
 537                         vcard_build_items( cardFile, listName, listAddress, listRemarks, listID );
 538                         vcard_free_lists( listName, listAddress, listRemarks, listID );
 539                         listName = listAddress = listRemarks = listID = NULL;
 540                 }
 541
 542                 g_free( tagname );
 543                 g_free( tagtype );
 544                 g_free( tagvalue );
 545                 g_free( tagtemp );
 546                 g_free( line );
 547         }
 548
 549         /* Free lists */
 550         vcard_free_lists( listName, listAddress, listRemarks, listID );
 551         listName = listAddress = listRemarks = listID = NULL;
 552 }
 553
 554 /* ============================================================================================ */
 555 /*
 556 * Read file into list. Main entry point
 557 * Return: TRUE if file read successfully.
 558 */
 559 /* ============================================================================================ */
 560 gint vcard_read_data( VCardFile *cardFile ) {
 561         g_return_val_if_fail( cardFile != NULL, -1 );
 562
 563         cardFile->retVal = MGU_SUCCESS;
 564         cardFile->accessFlag = FALSE;
 565         if( addrcache_check_file( cardFile->addressCache, cardFile->path ) ) {
 566                 addrcache_clear( cardFile->addressCache );
 567                 vcard_open_file( cardFile );
 568                 if( cardFile->retVal == MGU_SUCCESS ) {
 569                         /* Read data into the list */
 570                         vcard_read_file( cardFile );
 571                         vcard_close_file( cardFile );
 572
 573                         /* Mark cache */
 574                         addrcache_mark_file( cardFile->addressCache, cardFile->path );
 575                         cardFile->addressCache->modified = FALSE;
 576                         cardFile->addressCache->dataRead = TRUE;
 577                 }
 578         }
 579         return cardFile->retVal;
 580 }
 581
 582 /*
 583 * Return link list of persons.
 584 */
 585 GList *vcard_get_list_person( VCardFile *cardFile ) {
 586         g_return_val_if_fail( cardFile != NULL, NULL );
 587         return addrcache_get_list_person( cardFile->addressCache );
 588 }
 589
 590 /*
 591 * Return link list of folders. This is always NULL since there are
 592 * no folders in GnomeCard.
 593 * Return: NULL.
 594 */
 595 GList *vcard_get_list_folder( VCardFile *cardFile ) {
 596         g_return_val_if_fail( cardFile != NULL, NULL );
 597         return NULL;
 598 }
 599
 600 /*
 601 * Return link list of all persons. Note that the list contains references
 602 * to items. Do *NOT* attempt to use the addrbook_free_xxx() functions...
 603 * this will destroy the addressbook data!
 604 * Return: List of items, or NULL if none.
 605 */
 606 GList *vcard_get_all_persons( VCardFile *cardFile ) {
 607         g_return_val_if_fail( cardFile != NULL, NULL );
 608         return addrcache_get_all_persons( cardFile->addressCache );
 609 }
 610
 611 /*
 612 * Validate that all parameters specified.
 613 * Return: TRUE if data is good.
 614 */
 615 gboolean vcard_validate( const VCardFile *cardFile ) {
 616         gboolean retVal;
 617
 618         g_return_val_if_fail( cardFile != NULL, FALSE );
 619
 620         retVal = TRUE;
 621         if( cardFile->path ) {
 622                 if( strlen( cardFile->path ) < 1 ) retVal = FALSE;
 623         }
 624         else {
 625                 retVal = FALSE;
 626         }
 627         if( cardFile->name ) {
 628                 if( strlen( cardFile->name ) < 1 ) retVal = FALSE;
 629         }
 630         else {
 631                 retVal = FALSE;
 632         }
 633         return retVal;
 634 }
 635
 636 #define WORK_BUFLEN 1024
 637
 638 /*
 639 * Attempt to find a valid GnomeCard file.
 640 * Return: Filename, or home directory if not found. Filename should
 641 *       be g_free() when done.
 642 */
 643 gchar *vcard_find_gnomecard( void ) {
 644         gchar *homedir;
 645         gchar buf[ WORK_BUFLEN ];
 646         gchar str[ WORK_BUFLEN ];
 647         gchar *fileSpec;
 648         gint len, lenlbl, i;
 649         FILE *fp;
 650
 651         homedir = g_get_home_dir();
 652         if( ! homedir ) return NULL;
 653
 654         strcpy( str, homedir );
 655         len = strlen( str );
 656         if( len > 0 ) {
 657                 if( str[ len-1 ] != G_DIR_SEPARATOR ) {
 658                         str[ len ] = G_DIR_SEPARATOR;
 659                         str[ ++len ] = '\0';
 660                 }
 661         }
 662         strcat( str, GNOMECARD_DIR );
 663         strcat( str, G_DIR_SEPARATOR_S );
 664         strcat( str, GNOMECARD_FILE );
 665
 666         fileSpec = NULL;
 667         if( ( fp = fopen( str, "r" ) ) != NULL ) {
 668                 /* Read configuration file */
 669                 lenlbl = strlen( GNOMECARD_SECTION );
 670                 while( fgets( buf, sizeof( buf ), fp ) != NULL ) {
 671                         if( 0 == g_strncasecmp( buf, GNOMECARD_SECTION, lenlbl ) ) {
 672                                 break;
 673                         }
 674                 }
 675
 676                 while( fgets( buf, sizeof( buf ), fp ) != NULL ) {
 677                         g_strchomp( buf );
 678                         if( buf[0] == '[' ) break;
 679                         for( i = 0; i < lenlbl; i++ ) {
 680                                 if( buf[i] == '=' ) {
 681                                         if( 0 == g_strncasecmp( buf, GNOMECARD_PARAM, i ) ) {
 682                                                 fileSpec = g_strdup( buf + i + 1 );
 683                                                 g_strstrip( fileSpec );
 684                                         }
 685                                 }
 686                         }
 687                 }
 688                 fclose( fp );
 689         }
 690
 691         if( fileSpec == NULL ) {
 692                 /* Use the home directory */
 693                 str[ len ] = '\0';
 694                 fileSpec = g_strdup( str );
 695         }
 696
 697         return fileSpec;
 698 }
 699
 700 /*
 701 * Attempt to read file, testing for valid vCard format.
 702 * Return: TRUE if file appears to be valid format.
 703 */
 704 gint vcard_test_read_file( const gchar *fileSpec ) {
 705         gboolean haveStart;
 706         gchar *tagtemp = NULL, *tagname = NULL, *tagvalue = NULL, *tagtype = NULL, *line;
 707         VCardFile *cardFile;
 708         gint retVal, lines;
 709
 710         if( ! fileSpec ) return MGU_NO_FILE;
 711
 712         cardFile = vcard_create_path( fileSpec );
 713         cardFile->retVal = MGU_SUCCESS;
 714         vcard_open_file( cardFile );
 715         if( cardFile->retVal == MGU_SUCCESS ) {
 716                 cardFile->retVal = MGU_BAD_FORMAT;
 717                 haveStart = FALSE;
 718                 lines = VCARD_TEST_LINES;
 719                 while( lines > 0 ) {
 720                         lines--;
 721                         if( ( line =  vcard_get_line( cardFile ) ) == NULL ) break;
 722
 723                         /* Parse line */
 724                         tagtemp = vcard_get_tagname( line, VCARD_SEP_TAG );
 725                         if( tagtemp == NULL ) {
 726                                 g_free( line );
 727                                 continue;
 728                         }
 729
 730                         tagvalue = vcard_get_tagvalue( line, VCARD_SEP_TAG );
 731                         if( tagvalue == NULL ) {
 732                                 g_free( tagtemp );
 733                                 g_free( line );
 734                                 continue;
 735                         }
 736
 737                         tagname = vcard_get_tagname( tagtemp, VCARD_SEP_TYPE );
 738                         tagtype = vcard_get_tagvalue( tagtemp, VCARD_SEP_TYPE );
 739                         if( tagname == NULL ) {
 740                                 tagname = tagtemp;
 741                                 tagtemp = NULL;
 742                         }
 743
 744                         if( g_strcasecmp( tagtype, VCARD_TYPE_QP ) == 0 ) {
 745                                 /* Quoted-Printable: could span multiple lines */
 746                                 tagvalue = vcard_read_qp( cardFile, tagvalue );
 747                                 vcard_unescape_qp( tagvalue );
 748                         }
 749                         if( g_strcasecmp( tagname, VCARD_TAG_START ) == 0 &&
 750                                 g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 751                                 haveStart = TRUE;
 752                         }
 753                         if( g_strcasecmp( tagname, VCARD_TAG_END ) == 0 &&
 754                                 g_strcasecmp( tagvalue, VCARD_NAME ) == 0 ) {
 755                                 /* vCard is complete */
 756                                 if( haveStart ) cardFile->retVal = MGU_SUCCESS;
 757                         }
 758
 759                         g_free( tagname );
 760                         g_free( tagtype );
 761                         g_free( tagvalue );
 762                         g_free( tagtemp );
 763                         g_free( line );
 764                 }
 765                 vcard_close_file( cardFile );
 766         }
 767         retVal = cardFile->retVal;
 768         vcard_free( cardFile );
 769         cardFile = NULL;
 770         return retVal;
 771 }
 772
 773 /*
 774 * End of Source.
 775 */