src/addrharvest.c

   1 /*
   2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 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 for an E-Mail address harvester.
  22  * Code still needs some work. Address parsing not strictly correct.
  23  */
  24
  25 #include <sys/stat.h>
  26 #include <dirent.h>
  27 #include <glib.h>
  28 #include <string.h>
  29
  30 #include "utils.h"
  31 #include "mgutils.h"
  32 #include "addrharvest.h"
  33 #include "addritem.h"
  34
  35 /* Mail header names of interest */
  36 static gchar *_headerFrom_     = HEADER_FROM;
  37 static gchar *_headerReplyTo_  = HEADER_REPLY_TO;
  38 static gchar *_headerSender_   = HEADER_SENDER;
  39 static gchar *_headerErrorsTo_ = HEADER_ERRORS_TO;
  40 static gchar *_headerCC_       = HEADER_CC;
  41 static gchar *_headerTo_       = HEADER_TO;
  42
  43 #define ADDR_BUFFSIZE    1024
  44 #define MSG_BUFFSIZE     2048
  45 #define MSGNUM_BUFFSIZE  32
  46 #define DFL_FOLDER_SIZE  20
  47
  48 /* Noise strings included by some other E-Mail clients */
  49 #define REM_NAME_STRING  "(E-mail)"
  50 #define REM_NAME_STRING2 "(E-mail 2)"
  51
  52 /* Directories to ignore */
  53 #define DIR_IGNORE ".\t..\t.sylpheed_mark\t.sylpheed_cache"
  54
  55 /*
  56  * Header entry.
  57  */
  58 typedef struct _HeaderEntry HeaderEntry;
  59 struct _HeaderEntry {
  60         gchar      *header;
  61         gboolean   selected;
  62         ItemFolder *folder;
  63         gint       count;
  64 };
  65
  66 /*
  67  * Build header table entry.
  68  * Enter: harvester Harvester object.
  69  *        name      Header name.
  70  */
  71 static void *addrharvest_build_entry(
  72                 AddressHarvester* harvester, gchar *name )
  73 {
  74         HeaderEntry *entry;
  75
  76         entry = g_new0( HeaderEntry, 1 );
  77         entry->header = name;
  78         entry->selected = FALSE;
  79         entry->folder = NULL;
  80         entry->count = 0;
  81         harvester->headerTable = g_list_append( harvester->headerTable, entry );
  82 }
  83
  84 static void addrharvest_print_hdrentry( HeaderEntry *entry, FILE *stream ) {
  85         fprintf( stream, "Header Entry\n" );
  86         fprintf( stream, "    name : %s\n", entry->header );
  87         fprintf( stream, "selected : %s\n", entry->selected ? "yes" : "no" );
  88 }
  89
  90 /*
  91  * Free key in table.
  92  */
  93 static gint addrharvest_free_table_vis( gpointer key, gpointer value, gpointer data ) {
  94         g_free( key );
  95         key = NULL;
  96         value = NULL;
  97         return TRUE;
  98 }
  99
 100 /*
 101  * Free lookup table.
 102  */
 103 static void addrharvest_free_table( AddressHarvester* harvester ) {
 104         GList *node;
 105         HeaderEntry *entry;
 106
 107         /* Free header list */
 108         node = harvester->headerTable;
 109         while( node ) {
 110                 entry = ( HeaderEntry * ) node->data;
 111                 entry->header = NULL;
 112                 entry->selected = FALSE;
 113                 entry->folder = NULL;
 114                 entry->count = 0;
 115                 g_free( entry );
 116                 node = g_list_next( node );
 117         }
 118         g_list_free( harvester->headerTable );
 119         harvester->headerTable = NULL;
 120
 121         /* Free duplicate table */
 122         g_hash_table_freeze( harvester->dupTable );
 123         g_hash_table_foreach_remove( harvester->dupTable, addrharvest_free_table_vis, NULL );
 124         g_hash_table_thaw( harvester->dupTable );
 125         g_hash_table_destroy( harvester->dupTable );
 126         harvester->dupTable = NULL;
 127 }
 128
 129 /*
 130 * Create new object.
 131 * Return: Harvester.
 132 */
 133 AddressHarvester *addrharvest_create( void ) {
 134         AddressHarvester *harvester;
 135
 136         harvester = g_new0( AddressHarvester, 1 );
 137         harvester->path = NULL;
 138         harvester->dupTable = g_hash_table_new( g_str_hash, g_str_equal );
 139         harvester->folderSize = DFL_FOLDER_SIZE;
 140         harvester->retVal = MGU_SUCCESS;
 141
 142         /* Build header table */
 143         harvester->headerTable = NULL;
 144         addrharvest_build_entry( harvester, _headerFrom_ );
 145         addrharvest_build_entry( harvester, _headerReplyTo_ );
 146         addrharvest_build_entry( harvester, _headerSender_ );
 147         addrharvest_build_entry( harvester, _headerErrorsTo_ );
 148         addrharvest_build_entry( harvester, _headerCC_ );
 149         addrharvest_build_entry( harvester, _headerTo_ );
 150
 151         return harvester;
 152 }
 153
 154 /*
 155 * Properties...
 156 */
 157 /*
 158  * Specify path to folder that will be harvested.
 159  * Entry: harvester Harvester object.
 160  *        value     Full directory path.
 161  */
 162 void addrharvest_set_path( AddressHarvester* harvester, const gchar *value ) {
 163         g_return_if_fail( harvester != NULL );
 164         harvester->path = mgu_replace_string( harvester->path, value );
 165         g_strstrip( harvester->path );
 166 }
 167
 168 /*
 169  * Specify maximum folder size.
 170  * Entry: harvester Harvester object.
 171  *        value     Folder size.
 172  */
 173 void addrharvest_set_folder_size(
 174         AddressHarvester* harvester, const gint value )
 175 {
 176         g_return_if_fail( harvester != NULL );
 177         if( value > 0 ) {
 178                 harvester->folderSize = value;
 179         }
 180 }
 181
 182 /*
 183  * Specify folder recursion.
 184  * Entry: harvester Harvester object.
 185  *        value     TRUE to process sub-folders, FALSE to process folder only.
 186  */
 187 void addrharvest_set_recurse(
 188         AddressHarvester* harvester, const gboolean value )
 189 {
 190         g_return_if_fail( harvester != NULL );
 191         harvester->folderRecurse = value;
 192 }
 193
 194 /*
 195  * Search (case insensitive) for header entry with specified name.
 196  * Enter: harvester Harvester.
 197  *        name      Header name.
 198  * Return: Header, or NULL if not found.
 199  */
 200 static HeaderEntry *addrharvest_find(
 201         AddressHarvester* harvester, const gchar *name ) {
 202         HeaderEntry *retVal;
 203         GList *node;
 204
 205         retVal = NULL;
 206         node = harvester->headerTable;
 207         while( node ) {
 208                 HeaderEntry *entry;
 209
 210                 entry = node->data;
 211                 if( g_strcasecmp( entry->header, name ) == 0 ) {
 212                         retVal = entry;
 213                         break;
 214                 }
 215                 node = g_list_next( node );
 216         }
 217         return retVal;
 218 }
 219
 220 /*
 221  * Set selection for specified heaader.
 222  * Enter: harvester Harvester.
 223  *        name      Header name.
 224  *        value     Value to set.
 225  */
 226 void addrharvest_set_header(
 227         AddressHarvester* harvester, const gchar *name, const gboolean value )
 228 {
 229         HeaderEntry *entry;
 230
 231         g_return_if_fail( harvester != NULL );
 232         entry = addrharvest_find( harvester, name );
 233         if( entry != NULL ) {
 234                 entry->selected = value;
 235         }
 236 }
 237
 238 /*
 239  * Get address count
 240  * Enter: harvester Harvester.
 241  *        name      Header name.
 242  * Return: Address count, or -1 if header not found.
 243  */
 244 gint addrharvest_get_count( AddressHarvester* harvester, const gchar *name ) {
 245         HeaderEntry *entry;
 246         gint count;
 247
 248         count = -1;
 249         g_return_val_if_fail( harvester != NULL, count );
 250         entry = addrharvest_find( harvester, name );
 251         if( entry != NULL ) {
 252                 count = entry->count;
 253         }
 254         return count;
 255 }
 256
 257 /*
 258 * Free up object by releasing internal memory.
 259 * Enter: harvester Harvester.
 260 */
 261 void addrharvest_free( AddressHarvester *harvester ) {
 262         g_return_if_fail( harvester != NULL );
 263
 264         /* Free internal stuff */
 265         addrharvest_free_table( harvester );
 266         g_free( harvester->path );
 267
 268         /* Clear pointers */
 269         harvester->path = NULL;
 270         harvester->retVal = MGU_SUCCESS;
 271         harvester->headerTable = NULL;
 272
 273         harvester->folderSize = 0;
 274
 275         /* Now release object */
 276         g_free( harvester );
 277 }
 278
 279 /*
 280 * Display object to specified stream.
 281 * Enter: harvester Harvester.
 282 *        stream    Output stream.
 283 */
 284 void addrharvest_print( AddressHarvester *harvester, FILE *stream ) {
 285         GList *node;
 286         HeaderEntry *entry;
 287
 288         g_return_if_fail( harvester != NULL );
 289         fprintf( stream, "Address Harvester:\n" );
 290         fprintf( stream, " file path: '%s'\n", harvester->path );
 291         fprintf( stream, "max folder: %d'\n", harvester->folderSize );
 292
 293         node = harvester->headerTable;
 294         while( node ) {
 295                 entry = node->data;
 296                 fprintf( stream, "   header: %s", entry->header );
 297                 fprintf( stream, "\t: %s", entry->selected ? "yes" : "no" );
 298                 fprintf( stream, "\t: %d\n", entry->count );
 299                 node = g_list_next( node );
 300         }
 301         fprintf( stream, "  ret val: %d\n", harvester->retVal );
 302 }
 303
 304 /*
 305  * Insert address into cache.
 306  * Enter: harvester Harvester object.
 307  *        entry     Header object.
 308  *        cache     Address cache to load.
 309  *        name      Name.
 310  *        address   eMail address.
 311  */
 312 static void addrharvest_insert_cache(
 313                 AddressHarvester *harvester, HeaderEntry *entry,
 314                 AddressCache *cache, const gchar *name,
 315                 const gchar *address )
 316 {
 317         ItemPerson *person;
 318         ItemFolder *folder;
 319         gchar *folderName;
 320         gboolean newFolder;
 321         gint cnt;
 322         gchar *key, *value;
 323
 324         newFolder = FALSE;
 325         folder = entry->folder;
 326         if( folder == NULL ) {
 327                 newFolder = TRUE;       /* No folder yet */
 328         }
 329         if( entry->count % harvester->folderSize == 0 ) {
 330                 newFolder = TRUE;       /* Folder is full */
 331         }
 332
 333         /* Insert address */
 334         key = g_strdup( address );
 335         g_strdown( key );
 336         person = g_hash_table_lookup( harvester->dupTable, key );
 337         if( person ) {
 338                 /* Update existing person to use longest name */
 339                 value = ADDRITEM_NAME(person);
 340                 if( strlen( name ) > strlen( value ) ) {
 341                         addritem_person_set_common_name( person, name );
 342                 }
 343                 g_free( key );
 344         }
 345         else {
 346                 /* Folder if required */
 347                 if( newFolder ) {
 348                         cnt = 1 + ( entry->count / harvester->folderSize );
 349                         folderName =g_strdup_printf( "%s (%d)",
 350                                         entry->header, cnt );
 351                         folder = addritem_create_item_folder();
 352                         addritem_folder_set_name( folder, folderName );
 353                         addritem_folder_set_remarks( folder, "" );
 354                         addrcache_id_folder( cache, folder );
 355                         addrcache_add_folder( cache, folder );
 356                         entry->folder = folder;
 357                         g_free( folderName );
 358                 }
 359
 360                 /* Insert entry */
 361                 person = addrcache_add_contact(
 362                                 cache, folder, name, address, "" );
 363                 g_hash_table_insert( harvester->dupTable, key, person );
 364                 entry->count++;
 365         }
 366         addritem_parse_first_last( person );
 367 }
 368
 369 /*
 370  * Remove specified string from name.
 371  * Enter: name Name.
 372  *        str  String to remove.
 373  */
 374 static void addrharvest_del_email( gchar *name, gchar *str ) {
 375         gchar *p;
 376         gint lenn, lenr;
 377
 378         lenr = strlen( str );
 379         while( p = strcasestr( name, str )  ) {
 380                 lenn = strlen( p );
 381                 memmove( p, p + lenr, lenn );
 382         }
 383 }
 384
 385 /*
 386  * Find position of at (@) character in buffer.
 387  * Enter:  buffer Start of buffer.
 388  * Return: Position of at character, or NULL if not found.
 389  * Note: This function searches for the last occurrence of an 'at' character
 390  * prior to a valid delimiter character for the end of address. This enables
 391  * an address to be found where it is also used as the name of the
 392  * recipient. For example:
 393  *     "axle.rose@netscape.com" <axle.rose@netscape.com>
 394  * The last occurrence of the at character is detected.
 395  */
 396 static gchar *addrharvest_find_at( const gchar *buffer ) {
 397         gchar *atCh;
 398         gchar *p;
 399
 400         atCh = strchr( buffer, '@' );
 401         if( atCh ) {
 402                 /* Search forward for another one */
 403                 p = atCh + 1;
 404                 while( *p ) {
 405                         if( *p == '>' ) {
 406                                 break;
 407                         }
 408                         if( *p == ',' ) {
 409                                 break;
 410                         }
 411                         if( *p == '\n' ) {
 412                                 break;
 413                         }
 414                         if( *p == '@' ) {
 415                                 atCh = p;
 416                                 break;
 417                         }
 418                         p++;
 419                 }
 420         }
 421         return atCh;
 422 }
 423
 424 /*
 425  * Find start and end of address string.
 426  * Enter: buf Start address of buffer to process (not modified).
 427  *        atp Pointer to email at (@) character.
 428  *        bp  Pointer to start of email address (returned).
 429  *        ep  Pointer to end of email address (returned).
 430  */
 431 static void addrharvest_find_address(
 432                 const gchar *buf, const gchar *atp, const gchar **bp,
 433                 const gchar **ep )
 434 {
 435         const gchar *p;
 436
 437         /* Find first non-separator char */
 438         *bp = NULL;
 439         p = buf;
 440         while( TRUE ) {
 441                 if( strchr( ",; \n\r", *p ) == NULL ) break;
 442                 p++;
 443         }
 444         *bp = p;
 445
 446         /* Search forward for end of address */
 447         *ep = NULL;
 448         p = atp + 1;
 449         while( TRUE ) {
 450                 if( strchr( ",;", *p ) ) break;
 451                 p++;
 452         }
 453         *ep = p;
 454 }
 455
 456 /*
 457  * Extract E-Mail address from buffer. If found, address is removed from
 458  * buffer.
 459  * Enter:  buffer Address buffer.
 460  * Return: E-Mail address, or NULL if none found. Must g_free() when done.
 461  */
 462 static gchar *addrharvest_extract_address( gchar *buffer ) {
 463         gchar *addr;
 464         gchar *atCh, *p, *bp, *ep;
 465         gint len;
 466
 467         addr = NULL;
 468         atCh = addrharvest_find_at( buffer );
 469         if( atCh ) {
 470                 /* Search back for start of address */
 471                 bp = NULL;
 472                 p = atCh;
 473                 while( p >= buffer ) {
 474                         bp = p;
 475                         if( *p == '<' ) {
 476                                 *p = ' ';
 477                                 bp++;
 478                                 break;
 479                         }
 480                         p--;
 481                 }
 482
 483                 /* Search fwd for end */
 484                 ep = NULL;
 485                 ep = p = atCh;
 486                 while( *p ) {
 487                         if( *p == '>' ) {
 488                                 *p = ' ';
 489                                 break;
 490                         }
 491                         else if( *p == ' ' ) {
 492                                 break;
 493                         }
 494                         ep = p;
 495                         p++;
 496                 }
 497
 498                 /* Extract email */
 499                 if( bp != NULL ) {
 500                         len = ( ep - bp );
 501                         if( len > 0 ) {
 502                                 addr = g_strndup( bp, len + 1 );
 503                                 memmove( bp, ep, len );
 504                                 *bp = ' ';
 505                         }
 506                 }
 507         }
 508         return addr;
 509 }
 510
 511 /*
 512  * Parse address from header buffer creating address in cache.
 513  * Enter: harvester Harvester object.
 514  *        entry     Header object.
 515  *        cache     Address cache to load.
 516  *        hdrBuf    Pointer to header buffer.
 517  */
 518 static void addrharvest_parse_address(
 519                 AddressHarvester *harvester, HeaderEntry *entry,
 520                 AddressCache *cache, const gchar *hdrBuf )
 521 {
 522         gchar buffer[ ADDR_BUFFSIZE + 2 ];
 523         const gchar *bp;
 524         const gchar *ep;
 525         gchar *atCh, *email, *name;
 526         gint bufLen;
 527
 528         /* Search for an address */
 529         while( atCh = addrharvest_find_at( hdrBuf ) ) {
 530                 /* Find addres string */
 531                 addrharvest_find_address( hdrBuf, atCh, &bp, &ep );
 532
 533                 /* Copy into buffer */
 534                 bufLen = ( size_t ) ( ep - bp );
 535                 if( bufLen > ADDR_BUFFSIZE ) {
 536                         bufLen = ADDR_BUFFSIZE;
 537                 }
 538                 strncpy( buffer, bp, bufLen );
 539                 buffer[ bufLen ] = '\0';
 540                 buffer[ bufLen + 1 ] = '\0';
 541                 buffer[ bufLen + 2 ] = '\0';
 542
 543                 /* Extract address from buffer */
 544                 email = addrharvest_extract_address( buffer );
 545                 if( email ) {
 546                         /* Unescape characters */
 547                         mgu_str_unescape( buffer );
 548
 549                         /* Remove noise characaters */
 550                         addrharvest_del_email( buffer, REM_NAME_STRING );
 551                         addrharvest_del_email( buffer, REM_NAME_STRING2 );
 552
 553                         /* Remove leading trailing quotes and spaces */
 554                         mgu_str_ltc2space( buffer, '\"', '\"' );
 555                         mgu_str_ltc2space( buffer, '\'', '\'' );
 556                         mgu_str_ltc2space( buffer, '\"', '\"' );
 557                         mgu_str_ltc2space( buffer, '(', ')' );
 558                         g_strstrip( buffer );
 559
 560                         if( g_strcasecmp( buffer, email ) == 0 ) {
 561                                 name = "";
 562                         }
 563                         else {
 564                                 name = buffer;
 565                         }
 566
 567                         /* Insert into address book */
 568                         addrharvest_insert_cache(
 569                                 harvester, entry, cache, name, email );
 570                         g_free( email );
 571                 }
 572                 hdrBuf = ep;
 573         }
 574 }
 575
 576 /*
 577  * Test whether buffer contains a header that appears in header list.
 578  * Enter: listHdr Header list.
 579  *        buf     Header buffer.
 580  * Return: TRUE if header in list.
 581  */
 582 static gboolean addrharvest_check_hdr( GList *listHdr, gchar *buf ) {
 583         gboolean retVal;
 584         GList *node;
 585         gchar *p, *hdr, *nhdr;
 586         gint len;
 587
 588         retVal = FALSE;
 589         p = strchr( buf, ':' );
 590         if( p ) {
 591                 len = ( size_t ) ( p - buf );
 592                 hdr = g_strndup( buf, len );
 593                 node = listHdr;
 594                 while( node ) {
 595                         nhdr = node->data;
 596                         if( g_strcasecmp( nhdr, hdr ) == 0 ) {
 597                                 retVal = TRUE;
 598                                 break;
 599                         }
 600                         node = g_list_next( node );
 601                 }
 602                 g_free( hdr );
 603         }
 604         return retVal;
 605 }
 606
 607 /*
 608  * Read header into a linked list of lines.
 609  * Enter:  fp      File to read.
 610  *         listHdr List of header lines of interest.
 611  *         done    End of headers or end of file reached.
 612  * Return: Linked list of lines.
 613  */
 614 static GSList *addrharvest_get_header( FILE *fp, GList *listHdr, gboolean *done ) {
 615         GSList *list;
 616         gchar buf[ MSG_BUFFSIZE + 2 ];
 617         gint ch;
 618         gboolean foundHdr;
 619
 620         list = NULL;
 621
 622         /* Read line */
 623         if( fgets( buf, MSG_BUFFSIZE, fp ) == NULL ) {
 624                 *done = TRUE;
 625                 return list;
 626         }
 627
 628         /* Test for end of headers */
 629         if( buf[0] == '\r' || buf[0] == '\n' ) {
 630                 *done = TRUE;
 631                 return list;
 632         }
 633
 634         /* Test whether required header */
 635         foundHdr = addrharvest_check_hdr( listHdr, buf );
 636
 637         /* Read all header lines. Only add reqd ones to list */
 638         while( TRUE ) {
 639                 gchar *p;
 640
 641                 if( foundHdr ) {
 642                         p = g_strdup( buf );
 643                         list = g_slist_append( list, p );
 644                 }
 645
 646                 /* Read first character */
 647                 ch = fgetc( fp );
 648                 if( ch == ' ' || ch == '\t' ) {
 649                         /* Continuation character - read into buffer */
 650                         if( fgets( buf, MSG_BUFFSIZE, fp ) == NULL ) {
 651                                 break;
 652                         }
 653                 }
 654                 else {
 655                         if( ch == EOF ) {
 656                                 *done = TRUE;
 657                         }
 658                         else {
 659                                 /* Push back character for next header */
 660                                 ungetc( ch, fp );
 661                         }
 662                         break;
 663                 }
 664         }
 665
 666         return list;
 667 }
 668
 669 /*
 670  * Read specified file into address book.
 671  * Enter:  harvester Harvester object.
 672  *         fileName  File to read.
 673  *         cache     Address cache to load.
 674  * Return: Status.
 675  */
 676 static gint addrharvest_readfile(
 677                 AddressHarvester *harvester, const gchar *fileName,
 678                 AddressCache *cache, GList *listHdr )
 679 {
 680         gint retVal;
 681         FILE *msgFile;
 682         gchar *buf, *addr, *p;
 683         HeaderEntry *entry;
 684         GSList *list;
 685         gboolean done;
 686
 687         msgFile = fopen( fileName, "rb" );
 688         if( ! msgFile ) {
 689                 /* Cannot open file */
 690                 retVal = MGU_OPEN_FILE;
 691                 return retVal;
 692         }
 693
 694         done = FALSE;
 695         while( TRUE ) {
 696                 list = addrharvest_get_header( msgFile, listHdr, &done );
 697                 if( done ) break;
 698
 699                 if( list == NULL ) {
 700                         continue;
 701                 }
 702
 703                 buf = mgu_list_coalesce( list );
 704                 mgu_free_list( list );
 705
 706                 if(( p = strchr( buf, ':' ) ) != NULL ) {
 707                         addr = p + 1;
 708                         *p = '\0';
 709
 710                         entry = addrharvest_find( harvester, buf );
 711                         if( entry && entry->selected ) {
 712                                 /* Sanitize control characters */
 713                                 p = addr;
 714                                 while( *p ) {
 715                                         if( *p == '\r' || *p == '\n' || *p == '\t' )
 716                                                 *p = ' ';
 717                                         p++;
 718                                 }
 719                                 addrharvest_parse_address(
 720                                         harvester, entry, cache, addr );
 721                         }
 722                 }
 723                 g_free( buf );
 724         }
 725
 726         fclose( msgFile );
 727         return MGU_SUCCESS;
 728 }
 729
 730 /*
 731  * Read all files in specified directory into address book. Directories are
 732  * traversed recursively if necessary.
 733  * Enter:  harvester Harvester object.
 734  *         cache     Address cache to load.
 735  *         msgList   List of message numbers, or NULL to process folder.
 736  *         dir       Directory to process.
 737  */
 738 static void addrharvest_harvest_dir(
 739         AddressHarvester *harvester, AddressCache *cache, GList *listHdr,
 740         gchar *dir )
 741 {
 742         DIR *dp;
 743         struct dirent *d;
 744         struct stat s;
 745         gint num;
 746
 747         if( ( dp = opendir( dir ) ) == NULL ) {
 748                 return;
 749         }
 750
 751         /* Process directory */
 752         chdir( dir );
 753         while( ( d = readdir( dp ) ) != NULL ) {
 754                 stat( d->d_name, &s );
 755                 if( S_ISDIR( s.st_mode ) ) {
 756                         if( harvester->folderRecurse ) {
 757                                 if( strstr( DIR_IGNORE, d->d_name ) != NULL )
 758                                         continue;
 759                                 addrharvest_harvest_dir(
 760                                         harvester, cache, listHdr, d->d_name );
 761                         }
 762                 }
 763                 if( S_ISREG( s.st_mode ) ) {
 764                         if( ( num = to_number( d->d_name ) ) >= 0 ) {
 765                                 addrharvest_readfile(
 766                                         harvester, d->d_name, cache, listHdr );
 767                         }
 768                 }
 769         }
 770         chdir( ".." );
 771         closedir( dp );
 772 }
 773
 774 /*
 775  * Read list of files in specified directory into address book.
 776  * Enter:  harvester Harvester object.
 777  *         cache     Address cache to load.
 778  *         msgList   List of message numbers, or NULL to process folder.
 779  */
 780 static void addrharvest_harvest_list(
 781         AddressHarvester *harvester, AddressCache *cache, GList *listHdr,
 782         GList *msgList )
 783 {
 784         DIR *dp;
 785         gint num;
 786         GList *node;
 787         gchar msgNum[ MSGNUM_BUFFSIZE ];
 788
 789         if( ( dp = opendir( harvester->path ) ) == NULL ) {
 790                 return;
 791         }
 792
 793         /* Process message list */
 794         chdir( harvester->path );
 795         node = msgList;
 796         while( node ) {
 797                 num = GPOINTER_TO_UINT( node->data );
 798                 sprintf( msgNum, "%d", num );
 799                 addrharvest_readfile( harvester, msgNum, cache, listHdr );
 800                 node = g_list_next( node );
 801         }
 802         closedir( dp );
 803 }
 804
 805 /*
 806  * ============================================================================
 807  * Read all files in specified directory into address book.
 808  * Enter:  harvester Harvester object.
 809  *         cache     Address cache to load.
 810  *         msgList   List of message numbers, or NULL to process folder.
 811  * Return: Status.
 812  * ============================================================================
 813  */
 814 gint addrharvest_harvest(
 815         AddressHarvester *harvester, AddressCache *cache, GList *msgList )
 816 {
 817         gint retVal;
 818         GList *node;
 819         GList *listHdr;
 820
 821         retVal = MGU_BAD_ARGS;
 822         g_return_val_if_fail( harvester != NULL, retVal );
 823         g_return_val_if_fail( cache != NULL, retVal );
 824         g_return_val_if_fail( harvester->path != NULL, retVal );
 825
 826         /* Clear cache */
 827         addrcache_clear( cache );
 828         cache->dataRead = FALSE;
 829
 830         /* Build list of headers of interest */
 831         listHdr = NULL;
 832         node = harvester->headerTable;
 833         while( node ) {
 834                 HeaderEntry *entry;
 835
 836                 entry = node->data;
 837                 if( entry->selected ) {
 838                         gchar *p;
 839
 840                         p = g_strdup( entry->header );
 841                         g_strdown( p );
 842                         listHdr = g_list_append( listHdr, p );
 843                 }
 844                 node = g_list_next( node );
 845         }
 846
 847         /* Process directory/files */
 848         if( msgList == NULL ) {
 849                 addrharvest_harvest_dir( harvester, cache, listHdr, harvester->path );
 850         }
 851         else {
 852                 addrharvest_harvest_list( harvester, cache, listHdr, msgList );
 853         }
 854         mgu_free_dlist( listHdr );
 855
 856         /* Mark cache */
 857         cache->modified = FALSE;
 858         cache->dataRead = TRUE;
 859
 860         return retVal;
 861 }
 862
 863 /*
 864  * ============================================================================
 865  * Test whether any headers have been selected for processing.
 866  * Enter:  harvester Harvester object.
 867  * Return: TRUE if a header was selected, FALSE if none were selected.
 868  * ============================================================================
 869  */
 870 gboolean addrharvest_check_header( AddressHarvester *harvester ) {
 871         gboolean retVal;
 872         GList *node;
 873
 874         retVal = FALSE;
 875         g_return_val_if_fail( harvester != NULL, retVal );
 876
 877         node = harvester->headerTable;
 878         while( node ) {
 879                 HeaderEntry *entry;
 880
 881                 entry = ( HeaderEntry * ) node->data;
 882                 if( entry->selected ) return TRUE;
 883                 node = g_list_next( node );
 884         }
 885         return retVal;
 886 }
 887
 888 /*
 889  * ============================================================================
 890  * End of Source.
 891  * ============================================================================
 892  */
 893
 894