src/addrharvest.c

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