abook.c

   1 /*
   2  * $Id$
   3  *
   4  * by JH <jheinonen@users.sourceforge.net>
   5  *
   6  * Copyright (C) Jaakko Heinonen
   7  */
   8
   9 #include <errno.h>
  10 #include <fcntl.h>
  11 #include <ctype.h>
  12 #include <signal.h>
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #include <unistd.h>
  17 #include <sys/stat.h>
  18 #ifdef HAVE_CONFIG_H
  19 #       include "config.h"
  20 #endif
  21 #if defined(HAVE_LOCALE_H) && defined(HAVE_SETLOCALE)
  22 #       include <locale.h>
  23 #endif
  24 #include <assert.h>
  25 #include "abook.h"
  26 #include "gettext.h"
  27 #include "ui.h"
  28 #include "database.h"
  29 #include "list.h"
  30 #include "filter.h"
  31 #include "edit.h"
  32 #include "misc.h"
  33 #include "options.h"
  34 #include "getname.h"
  35 #include "getopt.h"
  36 #include "views.h"
  37 #include "xmalloc.h"
  38
  39 static void             init_abook();
  40 static void             quit_abook_sig(int i);
  41 static void             set_filenames();
  42 static void             parse_command_line(int argc, char **argv);
  43 static void             show_usage();
  44 static void             mutt_query(char *str);
  45 static void             init_mutt_query();
  46 static void             convert(char *srcformat, char *srcfile,
  47                                 char *dstformat, char *dstfile);
  48 static void             add_email(int);
  49
  50 char *datafile = NULL;
  51 static char *rcfile = NULL;
  52
  53 // custom formatting
  54 char custom_format[FORMAT_STRING_LEN] = "{nick} ({name}): {mobile}";
  55 struct abook_output_item_filter selected_item_filter;
  56
  57 bool alternative_datafile = FALSE;
  58 bool alternative_rcfile = FALSE;
  59
  60
  61 static int
  62 datafile_writeable()
  63 {
  64         FILE *f;
  65
  66         assert(datafile != NULL);
  67
  68         if( (f = fopen(datafile, "a")) == NULL)
  69                 return FALSE;
  70
  71         fclose(f);
  72
  73         return TRUE;
  74 }
  75
  76 static void
  77 check_abook_directory()
  78 {
  79         struct stat s;
  80         char *dir;
  81
  82         assert(!is_ui_initialized());
  83
  84         if(alternative_datafile)
  85                 return;
  86
  87         dir = strconcat(getenv("HOME"), "/" DIR_IN_HOME, NULL);
  88         assert(dir != NULL);
  89
  90         if(stat(dir, &s) == -1) {
  91                 if(errno != ENOENT) {
  92                         perror(dir);
  93                         free(dir);
  94                         exit(EXIT_FAILURE);
  95                 }
  96                 if(mkdir(dir, 0700) == -1) {
  97                         printf(_("Cannot create directory %s\n"), dir);
  98                         perror(dir);
  99                         free(dir);
 100                         exit(EXIT_FAILURE);
 101                 }
 102         } else if(!S_ISDIR(s.st_mode)) {
 103                 printf(_("%s is not a directory\n"), dir);
 104                 free(dir);
 105                 exit(EXIT_FAILURE);
 106         }
 107
 108         free(dir);
 109 }
 110
 111 static void
 112 xmalloc_error_handler(int err)
 113 {
 114         /*
 115          * We don't try to save addressbook here because we don't know
 116          * if it's fully loaded to memory.
 117          */
 118         if(is_ui_initialized())
 119                 close_ui();
 120
 121         fprintf(stderr, _("Memory allocation failure: %s\n"), strerror(err));
 122         exit(EXIT_FAILURE);
 123 }
 124
 125 static void
 126 init_abook()
 127 {
 128         set_filenames();
 129         check_abook_directory();
 130         init_opts();
 131         if(load_opts(rcfile) > 0) {
 132                 printf(_("Press enter to continue...\n"));
 133                 fgetc(stdin);
 134         }
 135         init_default_views();
 136
 137         signal(SIGTERM, quit_abook_sig);
 138
 139         init_index();
 140
 141         if(init_ui())
 142                 exit(EXIT_FAILURE);
 143
 144         umask(DEFAULT_UMASK);
 145
 146         if(!datafile_writeable()) {
 147                 char *s = strdup_printf(_("File %s is not writeable"), datafile);
 148                 refresh_screen();
 149                 statusline_msg(s);
 150                 free(s);
 151                 if(load_database(datafile) || !statusline_ask_boolean(
 152                                         _("If you continue all changes will "
 153                                 "be lost. Do you want to continue?"), FALSE)) {
 154                         free_opts();
 155                         /*close_database();*/
 156                         close_ui();
 157                         exit(EXIT_FAILURE);
 158                 }
 159         } else
 160                 load_database(datafile);
 161
 162         refresh_screen();
 163 }
 164
 165 void
 166 quit_abook(int save_db)
 167 {
 168         if(save_db)  {
 169                 if(opt_get_bool(BOOL_AUTOSAVE))
 170                         save_database();
 171                 else if(statusline_ask_boolean(_("Save database"), TRUE))
 172                         save_database();
 173         } else if(!statusline_ask_boolean(_("Quit without saving"), FALSE))
 174                 return;
 175
 176         free_opts();
 177         close_database();
 178
 179         close_ui();
 180
 181         exit(EXIT_SUCCESS);
 182 }
 183
 184 static void
 185 quit_abook_sig(int i)
 186 {
 187         quit_abook(QUIT_SAVE);
 188 }
 189
 190 int
 191 main(int argc, char **argv)
 192 {
 193 #if defined(HAVE_SETLOCALE) && defined(HAVE_LOCALE_H)
 194         setlocale(LC_MESSAGES, "");
 195         setlocale(LC_TIME, "");
 196         setlocale(LC_CTYPE, "");
 197         setlocale(LC_COLLATE, "");
 198 #endif
 199         bindtextdomain(PACKAGE, LOCALEDIR);
 200         textdomain(PACKAGE);
 201
 202         xmalloc_set_error_handler(xmalloc_error_handler);
 203
 204         prepare_database_internals();
 205
 206         parse_command_line(argc, argv);
 207
 208         init_abook();
 209
 210         get_commands();
 211
 212         quit_abook(QUIT_SAVE);
 213
 214         return 0;
 215 }
 216
 217 static void
 218 free_filenames()
 219 {
 220         xfree(rcfile);
 221         xfree(datafile);
 222 }
 223
 224
 225 static void
 226 set_filenames()
 227 {
 228         struct stat s;
 229
 230         if( (stat(getenv("HOME"), &s)) == -1 || ! S_ISDIR(s.st_mode) ) {
 231                 fprintf(stderr,_("%s is not a valid HOME directory\n"), getenv("HOME") );
 232                 exit(EXIT_FAILURE);
 233         }
 234
 235         if(!datafile)
 236                 datafile = strconcat(getenv("HOME"), "/" DIR_IN_HOME "/"
 237                                 DATAFILE, NULL);
 238
 239         if(!rcfile)
 240                 rcfile = strconcat(getenv("HOME"), "/" DIR_IN_HOME "/"
 241                                 RCFILE, NULL);
 242
 243         atexit(free_filenames);
 244 }
 245
 246 /*
 247  * CLI
 248  */
 249
 250 enum {
 251         MODE_CONT,
 252         MODE_ADD_EMAIL,
 253         MODE_ADD_EMAIL_QUIET,
 254         MODE_QUERY,
 255         MODE_CONVERT
 256 };
 257
 258 static void
 259 change_mode(int *current, int mode)
 260 {
 261         if(*current != MODE_CONT) {
 262                 fprintf(stderr, _("Cannot combine options --mutt-query, "
 263                                 "--convert, "
 264                                 "--add-email or --add-email-quiet\n"));
 265                 exit(EXIT_FAILURE);
 266         }
 267
 268         *current = mode;
 269 }
 270
 271 void
 272 set_filename(char **var, char *path)
 273 {
 274         char *cwd;
 275
 276         assert(var != NULL);
 277         assert(*var == NULL); /* or else we probably leak memory */
 278         assert(path != NULL);
 279
 280         if(*path == '/') {
 281                 *var = xstrdup(path);
 282                 return;
 283         }
 284
 285         cwd = my_getcwd();
 286
 287         *var = strconcat(cwd, "/", path, NULL);
 288
 289         free(cwd);
 290 }
 291
 292 #define set_convert_var(X) do { if(mode != MODE_CONVERT) {\
 293         fprintf(stderr, _("please use option --%s after --convert option\n"),\
 294                         long_options[option_index].name);\
 295                 exit(EXIT_FAILURE);\
 296         } else\
 297                 X = optarg;\
 298         } while(0)
 299
 300 static void
 301 parse_command_line(int argc, char **argv)
 302 {
 303         int mode = MODE_CONT;
 304         char *query_string = NULL;
 305         char *informat = "abook",
 306                 *outformat = "text",
 307                 *infile = "-",
 308                 *outfile = "-";
 309         int c;
 310         selected_item_filter = select_output_item_filter("muttq");
 311
 312         for(;;) {
 313                 int option_index = 0;
 314                 enum {
 315                         OPT_ADD_EMAIL,
 316                         OPT_ADD_EMAIL_QUIET,
 317                         OPT_MUTT_QUERY,
 318                         OPT_CONVERT,
 319                         OPT_INFORMAT,
 320                         OPT_OUTFORMAT,
 321                         OPT_OUTFORMAT_STR,
 322                         OPT_INFILE,
 323                         OPT_OUTFILE,
 324                         OPT_FORMATS
 325                 };
 326                 static struct option long_options[] = {
 327                         { "help", 0, 0, 'h' },
 328                         { "add-email", 0, 0, OPT_ADD_EMAIL },
 329                         { "add-email-quiet", 0, 0, OPT_ADD_EMAIL_QUIET },
 330                         { "datafile", 1, 0, 'f' },
 331                         { "mutt-query", 1, 0, OPT_MUTT_QUERY },
 332                         { "config", 1, 0, 'C' },
 333                         { "convert", 0, 0, OPT_CONVERT },
 334                         { "informat", 1, 0, OPT_INFORMAT },
 335                         { "outformat", 1, 0, OPT_OUTFORMAT },
 336                         { "outformatstr", 1, 0, OPT_OUTFORMAT_STR },
 337                         { "infile", 1, 0, OPT_INFILE },
 338                         { "outfile", 1, 0, OPT_OUTFILE },
 339                         { "formats", 0, 0, OPT_FORMATS },
 340                         { 0, 0, 0, 0 }
 341                 };
 342
 343                 c = getopt_long(argc, argv, "hC:f:",
 344                                 long_options, &option_index);
 345
 346                 if(c == -1)
 347                         break;
 348
 349                 switch(c) {
 350                         case 'h':
 351                                 show_usage();
 352                                 exit(EXIT_SUCCESS);
 353                         case OPT_ADD_EMAIL:
 354                                 change_mode(&mode, MODE_ADD_EMAIL);
 355                                 break;
 356                         case OPT_ADD_EMAIL_QUIET:
 357                                 change_mode(&mode, MODE_ADD_EMAIL_QUIET);
 358                                 break;
 359                         case 'f':
 360                                 set_filename(&datafile, optarg);
 361                                 alternative_datafile = TRUE;
 362                                 break;
 363                         case OPT_MUTT_QUERY:
 364                                 query_string = optarg;
 365                                 change_mode(&mode, MODE_QUERY);
 366                                 break;
 367                         case 'C':
 368                                 set_filename(&rcfile, optarg);
 369                                 alternative_rcfile = TRUE;
 370                                 break;
 371                         case OPT_CONVERT:
 372                                 change_mode(&mode, MODE_CONVERT);
 373                                 break;
 374                         case OPT_INFORMAT:
 375                                 set_convert_var(informat);
 376                                 break;
 377                         case OPT_OUTFORMAT:
 378                                 if(mode != MODE_CONVERT && mode != MODE_QUERY) {
 379                                   fprintf(stderr,
 380                                           _("please use option --outformat after --convert or --mutt-query option\n"));
 381                                   exit(EXIT_FAILURE);
 382                                 }
 383                                 // ascii-name is stored, it's used to traverse
 384                                 // e_filters[] in MODE_CONVERT (see export_file())
 385                                 outformat = optarg;
 386                                 // but in case a query-compatible filter is requested
 387                                 // try to guess right now which one it is, from u_filters[]
 388                                 selected_item_filter = select_output_item_filter(outformat);
 389                                 break;
 390                         case OPT_OUTFORMAT_STR:
 391                                 strncpy(custom_format, optarg, FORMAT_STRING_LEN);
 392                                 custom_format[FORMAT_STRING_LEN - 1] = 0;
 393                                 break;
 394                         case OPT_INFILE:
 395                                 set_convert_var(infile);
 396                                 break;
 397                         case OPT_OUTFILE:
 398                                 set_convert_var(outfile);
 399                                 break;
 400                         case OPT_FORMATS:
 401                                 print_filters();
 402                                 exit(EXIT_SUCCESS);
 403                         default:
 404                                 exit(EXIT_FAILURE);
 405                 }
 406         }
 407
 408         // if the output format requested does not allow filtered querying
 409         // (not in u_filter[]) and --convert has not been specified; bailout
 410         if(! selected_item_filter.func && mode != MODE_CONVERT) {
 411           printf("output format %s not supported or incompatible with --mutt-query\n", outformat);
 412           exit(EXIT_FAILURE);
 413         }
 414         if(! selected_item_filter.func)
 415                 selected_item_filter = select_output_item_filter("muttq");
 416         else if (! strcmp(outformat, "custom")) {
 417                 if(! *custom_format) {
 418                         fprintf(stderr, _("Invalid custom format string\n"));
 419                         exit(EXIT_FAILURE);
 420                 }
 421         }
 422         if(optind < argc) {
 423                 fprintf(stderr, _("%s: unrecognized arguments on command line\n"),
 424                                 argv[0]);
 425                 exit(EXIT_FAILURE);
 426         }
 427
 428         switch(mode) {
 429                 case MODE_ADD_EMAIL:
 430                         add_email(0);
 431                 case MODE_ADD_EMAIL_QUIET:
 432                         add_email(1);
 433                 case MODE_QUERY:
 434                         mutt_query(query_string);
 435                 case MODE_CONVERT:
 436                         convert(informat, infile, outformat, outfile);
 437         }
 438 }
 439
 440
 441 static void
 442 show_usage()
 443 {
 444         puts    (PACKAGE " v" VERSION "\n");
 445         puts    (_("     -h     --help                          show usage"));
 446         puts    (_("     -C     --config        <file>          use an alternative configuration file"));
 447         puts    (_("     -f     --datafile      <file>          use an alternative addressbook file"));
 448         puts    (_("    --mutt-query    <string>        make a query for mutt"));
 449         puts    (_("    --add-email                     "
 450                         "read an e-mail message from stdin and\n"
 451                 "                                       "
 452                 "add the sender to the addressbook"));
 453         puts    (_("    --add-email-quiet               "
 454                 "same as --add-email but doesn't\n"
 455                 "                                       require to confirm adding"));
 456         putchar('\n');
 457         puts    (_("    --convert                       convert address book files"));
 458         puts    (_("    options to use with --convert:"));
 459         puts    (_("    --informat      <format>        format for input file"));
 460         puts    (_("                                    (default: abook)"));
 461         puts    (_("    --infile        <file>          source file"));
 462         puts    (_("                                    (default: stdin)"));
 463         puts    (_("    --outformat     <format>        format for output file"));
 464         puts    (_("                                    (default: text)"));
 465         puts    (_("    --outfile       <file>          destination file"));
 466         puts    (_("                                    (default: stdout)"));
 467         puts    (_("    --outformatstr  <str>           format to use for \"custom\" --outformat"));
 468         puts    (_("                                    (default: \"{nick} ({name}): {mobile}\")"));
 469         puts    (_("    --formats                       list available formats"));
 470 }
 471
 472 /*
 473  * end of CLI
 474  */
 475
 476
 477 static void
 478 quit_mutt_query(int status)
 479 {
 480         close_database();
 481         free_opts();
 482
 483         exit(status);
 484 }
 485
 486 static void
 487 mutt_query(char *str)
 488 {
 489         init_mutt_query();
 490
 491         if( str == NULL || !strcasecmp(str, "all") ) {
 492                 export_file("muttq", "-");
 493         } else {
 494                 int search_fields[] = {NAME, EMAIL, NICK, -1};
 495                 int i;
 496                 if( (i = find_item(str, 0, search_fields)) < 0 ) {
 497                         printf("Not found\n");
 498                         quit_mutt_query(EXIT_FAILURE);
 499                 }
 500                 // mutt expects a leading line containing
 501                 // a message about the query.
 502                 // Others output filter supporting query (vcard, custom)
 503                 // don't needs this.
 504                 if(!strcmp(selected_item_filter.filtname, "muttq"))
 505                         putchar('\n');
 506                 while(i >= 0) {
 507                         e_write_item(stdout, i, selected_item_filter.func);
 508                         i = find_item(str, i + 1, search_fields);
 509                 }
 510         }
 511
 512         quit_mutt_query(EXIT_SUCCESS);
 513 }
 514
 515 static void
 516 init_mutt_query()
 517 {
 518         set_filenames();
 519         init_opts();
 520         load_opts(rcfile);
 521
 522         if( load_database(datafile) ) {
 523                 printf(_("Cannot open database\n"));
 524                 quit_mutt_query(EXIT_FAILURE);
 525                 exit(EXIT_FAILURE);
 526         }
 527 }
 528
 529
 530 static char *
 531 make_mailstr(int item)
 532 {
 533         char email[MAX_EMAIL_LEN];
 534         char *ret;
 535         char *name = strdup_printf("\"%s\"", db_name_get(item));
 536
 537         get_first_email(email, item);
 538
 539         ret = *email ?
 540                 strdup_printf("%s <%s>", name, email) :
 541                 xstrdup(name);
 542
 543         free(name);
 544
 545         return ret;
 546 }
 547
 548 void
 549 print_stderr(int item)
 550 {
 551         fprintf (stderr, "%c", '\n');
 552
 553         if( is_valid_item(item) )
 554                 muttq_print_item(stderr, item);
 555         else {
 556                 struct db_enumerator e = init_db_enumerator(ENUM_SELECTED);
 557                 db_enumerate_items(e) {
 558                         muttq_print_item(stderr, e.item);
 559                 }
 560         }
 561
 562 }
 563
 564 void
 565 launch_mutt(int item)
 566 {
 567         char *cmd = NULL, *mailstr = NULL;
 568         char *mutt_command = opt_get_str(STR_MUTT_COMMAND);
 569
 570         if(mutt_command == NULL || !*mutt_command)
 571                 return;
 572
 573         if( is_valid_item(item) )
 574                 mailstr = make_mailstr(item);
 575         else {
 576                 struct db_enumerator e = init_db_enumerator(ENUM_SELECTED);
 577                 char *tmp = NULL;
 578                 db_enumerate_items(e) {
 579                         tmp = mailstr;
 580                         mailstr = tmp ?
 581                                 strconcat(tmp, ",", make_mailstr(e.item), NULL):
 582                                 strconcat(make_mailstr(e.item), NULL);
 583                         free(tmp);
 584                 }
 585         }
 586
 587         cmd = strconcat(mutt_command, " \'", mailstr, "\'", NULL);
 588         free(mailstr);
 589 #ifdef DEBUG
 590         fprintf(stderr, "cmd: %s\n", cmd);
 591 #endif
 592         system(cmd);
 593         free(cmd);
 594
 595         /*
 596          * we need to make sure that curses settings are correct
 597          */
 598         ui_init_curses();
 599 }
 600
 601 void
 602 launch_wwwbrowser(int item)
 603 {
 604         char *cmd = NULL;
 605
 606         if( !is_valid_item(item) )
 607                 return;
 608
 609         if(db_fget(item, URL))
 610                 cmd = strdup_printf("%s '%s'",
 611                                 opt_get_str(STR_WWW_COMMAND),
 612                                 safe_str(db_fget(item, URL)));
 613         else
 614                 return;
 615
 616         if ( cmd )
 617                 system(cmd);
 618
 619         free(cmd);
 620
 621         /*
 622          * we need to make sure that curses settings are correct
 623          */
 624         ui_init_curses();
 625 }
 626
 627 FILE *
 628 abook_fopen (const char *path, const char *mode)
 629 {
 630         struct stat s;
 631         bool stat_ok;
 632
 633         stat_ok = (stat(path, &s) != -1);
 634
 635         if(strchr(mode, 'r'))
 636                 return (stat_ok && S_ISREG(s.st_mode)) ?
 637                         fopen(path, mode) : NULL;
 638         else
 639                 return (stat_ok && S_ISDIR(s.st_mode)) ?
 640                         NULL : fopen(path, mode);
 641 }
 642
 643 static void
 644 convert(char *srcformat, char *srcfile, char *dstformat, char *dstfile)
 645 {
 646         int ret=0;
 647
 648         if( !srcformat || !srcfile || !dstformat || !dstfile ) {
 649                 fprintf(stderr, _("too few arguments to make conversion\n"));
 650                 fprintf(stderr, _("try --help\n"));
 651         }
 652
 653 #ifndef DEBUG
 654         if( !strcasecmp(srcformat, dstformat) ) {
 655                 printf( _("input and output formats are the same\n"
 656                         "exiting...\n"));
 657                 exit(EXIT_FAILURE);
 658         }
 659 #endif
 660
 661         set_filenames();
 662         init_opts();
 663         load_opts(rcfile);
 664         init_standard_fields();
 665
 666         switch(import_file(srcformat, srcfile)) {
 667                 case -1:
 668                         fprintf(stderr,
 669                                 _("input format %s not supported\n"), srcformat);
 670                         ret = 1;
 671                         break;
 672                 case 1:
 673                         fprintf(stderr, _("cannot read file %s\n"), srcfile);
 674                         ret = 1;
 675                         break;
 676         }
 677
 678         if(!ret)
 679                 switch(export_file(dstformat, dstfile)) {
 680                         case -1:
 681                                 fprintf(stderr,
 682                                         _("output format %s not supported\n"),
 683                                         dstformat);
 684                                 ret = 1;
 685                                 break;
 686                         case 1:
 687                                 fprintf(stderr,
 688                                         _("cannot write file %s\n"), dstfile);
 689                                 ret = 1;
 690                                 break;
 691                 }
 692
 693         close_database();
 694         free_opts();
 695         exit(ret);
 696 }
 697
 698 /*
 699  * --add-email handling
 700  */
 701
 702 static int add_email_count = 0, add_email_found = 0;
 703
 704 static void
 705 quit_add_email()
 706 {
 707         if(add_email_count > 0) {
 708                 if(save_database() < 0) {
 709                         fprintf(stderr, _("cannot open %s\n"), datafile);
 710                         exit(EXIT_FAILURE);
 711                 }
 712                 printf(_("%d item(s) added to %s\n"), add_email_count, datafile);
 713         } else if (add_email_found == 0) {
 714                 puts(_("Valid sender address not found"));
 715         }
 716
 717         exit(EXIT_SUCCESS);
 718 }
 719
 720 static void
 721 quit_add_email_sig(int signal)
 722 {
 723         quit_add_email();
 724 }
 725
 726 static void
 727 init_add_email()
 728 {
 729         set_filenames();
 730         check_abook_directory();
 731         init_opts();
 732         load_opts(rcfile);
 733         init_standard_fields();
 734         atexit(free_opts);
 735
 736         /*
 737          * we don't actually care if loading fails or not
 738          */
 739         load_database(datafile);
 740
 741         atexit(close_database);
 742
 743         signal(SIGINT, quit_add_email_sig);
 744 }
 745
 746 static int
 747 add_email_add_item(int quiet, char *name, char *email)
 748 {
 749         list_item item;
 750
 751         if(opt_get_bool(BOOL_ADD_EMAIL_PREVENT_DUPLICATES)) {
 752                 int search_fields[] = { EMAIL, -1 };
 753                 if(find_item(email, 0, search_fields) >= 0) {
 754                         if(!quiet)
 755                                 printf(_("Address %s already in addressbook\n"),
 756                                                 email);
 757                         return 0;
 758                 }
 759         }
 760
 761         if(!quiet) {
 762                 FILE *in = fopen("/dev/tty", "r");
 763                 char c;
 764                 if(!in) {
 765                         fprintf(stderr, _("cannot open /dev/tty\n"
 766                                 "you may want to use --add-email-quiet\n"));
 767                         exit(EXIT_FAILURE);
 768                 }
 769
 770                 do {
 771                         printf(_("Add \"%s <%s>\" to %s? (%c/%c)\n"),
 772                                         name,
 773                                         email,
 774                                         datafile,
 775                                         *S_("keybinding for yes|y"),
 776                                         *S_("keybinding for no|n"));
 777                         c = tolower(getc(in));
 778                         if(c == *S_("keybinding for no|n")) {
 779                                 fclose(in);
 780                                 return 0;
 781                         }
 782                 } while(c != *S_("keybinding for yes|y"));
 783                 fclose(in);
 784         }
 785
 786         item = item_create();
 787         item_fput(item, NAME, xstrdup(name));
 788         item_fput(item, EMAIL, xstrdup(email));
 789         add_item2database(item);
 790         item_free(&item);
 791
 792         return 1;
 793 }
 794
 795 static void
 796 add_email(int quiet)
 797 {
 798         char *line;
 799         char *name = NULL, *email = NULL;
 800         struct stat s;
 801
 802         if( (fstat(fileno(stdin), &s)) == -1 || S_ISDIR(s.st_mode) ) {
 803                 fprintf(stderr, _("stdin is a directory or cannot stat stdin\n"));
 804                 exit(EXIT_FAILURE);
 805         }
 806
 807         init_add_email();
 808
 809         do {
 810                 line = getaline(stdin);
 811                 if(line && !strncasecmp("From:", line, 5) ) {
 812                         add_email_found++;
 813                         getname(line, &name, &email);
 814                         add_email_count += add_email_add_item(quiet,
 815                                         name, email);
 816                         xfree(name);
 817                         xfree(email);
 818                 }
 819                 xfree(line);
 820         } while( !feof(stdin) );
 821
 822         quit_add_email();
 823 }
 824
 825 /*
 826  * end of --add-email handling
 827  */