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