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