mymail.c

   1
   2 /*
   3  *  Copyright (c) 2013 Francois Fleuret
   4  *  Written by Francois Fleuret <francois@fleuret.org>
   5  *
   6  *  This file is part of mymail.
   7  *
   8  *  mymail is free software: you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License version 3 as
  10  *  published by the Free Software Foundation.
  11  *
  12  *  mymail is distributed in the hope that it will be useful, but
  13  *  WITHOUT ANY WARRANTY; without even the implied warranty of
  14  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  *  General Public License for more details.
  16  *
  17  *  You should have received a copy of the GNU General Public License
  18  *  along with mymail.  If not, see <http://www.gnu.org/licenses/>.
  19  *
  20  */
  21
  22 #define _GNU_SOURCE
  23
  24 #include <stdio.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <errno.h>
  28 #include <fcntl.h>
  29 #include <locale.h>
  30 #include <getopt.h>
  31 #include <limits.h>
  32 #include <dirent.h>
  33 #include <regex.h>
  34
  35 #define VERSION "0.1"
  36
  37 #define BUFFER_SIZE 16384
  38
  39 struct parsable_field {
  40   char *name;
  41   char *regexp_string;
  42   regex_t regexp;
  43 };
  44
  45 char *db_filename;
  46 char *search_pattern;
  47
  48 int action_index;
  49
  50 /********************************************************************/
  51
  52 /* malloc with error checking.  */
  53
  54 void *safe_malloc(size_t n) {
  55   void *p = malloc(n);
  56   if(!p && n != 0) {
  57     fprintf(stderr,
  58             "mymail: can not allocate memory: %s\n", strerror(errno));
  59     exit(EXIT_FAILURE);
  60   }
  61   return p;
  62 }
  63
  64 /*********************************************************************/
  65
  66 void usage(FILE *out) {
  67   fprintf(out, "mymail version %s (%s)\n", VERSION, UNAME);
  68   fprintf(out, "Written by Francois Fleuret <francois@fleuret.org>.\n");
  69   fprintf(out, "\n");
  70   fprintf(out, "Usage: mymail [options] [<filename1> [<filename2> ...]]\n");
  71   fprintf(out, "\n");
  72 }
  73
  74 /*********************************************************************/
  75
  76 void search_in_db(const char *search_name, const char *search_regexp_string,
  77                   FILE *db_file) {
  78   char raw_line[BUFFER_SIZE];
  79   char current_mail[BUFFER_SIZE];
  80   char *name, *value;
  81   regex_t regexp;
  82
  83   if(regcomp(&regexp,
  84              search_regexp_string,
  85              REG_ICASE)) {
  86     fprintf(stderr,
  87             "mymail: Syntax error in regexp \"%s\" for field \"%s\".\n",
  88             search_regexp_string,
  89             search_name);
  90     exit(EXIT_FAILURE);
  91   }
  92
  93   while(fgets(raw_line, BUFFER_SIZE, db_file)) {
  94     name = raw_line;
  95     value = raw_line;
  96     while(*value && *value != ' ') value++;
  97     *value = '\0'; value++;
  98     while(*value && *value == ' ') value++;
  99
 100     /* printf("LINE [%s] %s", name, value); */
 101
 102     if(strcmp("mail", name) == 0) {
 103       strcpy(current_mail, value);
 104       /* printf("READING [%s]\n", current_mail); */
 105     } else {
 106       if(strcmp(search_name, name) == 0 && regexec(&regexp, value, 0, 0, 0) == 0) {
 107         printf("%s", current_mail);
 108       }
 109     }
 110   }
 111 }
 112
 113
 114 /*********************************************************************/
 115
 116 void read_file(const char *input_filename,
 117                int nb_fields_to_parse, struct parsable_field *fields_to_parse,
 118                FILE *db_file) {
 119   char raw_line[BUFFER_SIZE];
 120   FILE *file;
 121   int in_header, new_header;
 122   unsigned int position_in_file;
 123
 124   file = fopen(input_filename, "r");
 125
 126   if(!file) {
 127     fprintf(stderr, "mymail: Can not open `%s'.\n", input_filename);
 128     exit(EXIT_FAILURE);
 129   }
 130
 131   in_header = 0;
 132   new_header = 0;
 133
 134   position_in_file = 0;
 135
 136   while(fgets(raw_line, BUFFER_SIZE, file)) {
 137     if(strncmp(raw_line, "From ", 5) == 0) {
 138       if(in_header) {
 139         fprintf(stderr,
 140                 "Got a 'From ' in the header in %s:%u.\n",
 141                 input_filename, position_in_file);
 142         fprintf(stderr, "%s", raw_line);
 143         exit(EXIT_FAILURE);
 144       }
 145       in_header = 1;
 146       new_header = 1;
 147     } else if(strncmp(raw_line, "\n", 1) == 0) {
 148       if(in_header) { in_header = 0; }
 149     }
 150
 151     /* if(in_header) { */
 152     /* printf("LINE.H %s", raw_line); */
 153     /* } else { */
 154     /* printf("LINE.B %s", raw_line); */
 155     /* } */
 156
 157     if(in_header) {
 158       int f;
 159       regmatch_t matches;
 160       if(new_header) {
 161         fprintf(db_file, "mail %s:%d\n", input_filename, position_in_file);
 162         new_header = 0;
 163       }
 164       for(f = 0; f < nb_fields_to_parse; f++) {
 165         if(regexec(&fields_to_parse[f].regexp, raw_line, 1, &matches, 0) == 0) {
 166           fprintf(db_file, "%s %s",
 167                   fields_to_parse[f].name,
 168                   raw_line + matches.rm_eo);
 169         }
 170       }
 171     }
 172
 173     position_in_file += strlen(raw_line);
 174   }
 175
 176   fclose(file);
 177 }
 178
 179 int ignore_entry(const char *name) {
 180   return
 181     strcmp(name, ".") == 0 ||
 182     strcmp(name, "..") == 0 ||
 183     (name[0] == '.' && name[1] != '/');
 184 }
 185
 186 void process_entry(const char *dir_name,
 187                    int nb_fields_to_parse, struct parsable_field *fields_to_parse,
 188                    FILE *db_file) {
 189   DIR *dir;
 190   struct dirent *dir_e;
 191   struct stat sb;
 192   char subname[PATH_MAX + 1];
 193
 194   if(lstat(dir_name, &sb) != 0) {
 195     fprintf(stderr,
 196             "mymail: Can not stat \"%s\": %s\n",
 197             dir_name,
 198             strerror(errno));
 199     exit(EXIT_FAILURE);
 200   } else {
 201   }
 202
 203   if(S_ISLNK(sb.st_mode)) {
 204     return;
 205   }
 206
 207   dir = opendir(dir_name);
 208
 209   if(dir) {
 210     printf("Processing directory '%s'.\n", dir_name);
 211     while((dir_e = readdir(dir))) {
 212       if(!ignore_entry(dir_e->d_name)) {
 213         snprintf(subname, PATH_MAX, "%s/%s", dir_name, dir_e->d_name);
 214         process_entry(subname, nb_fields_to_parse, fields_to_parse, db_file);
 215       }
 216     }
 217     closedir(dir);
 218   } else {
 219     if(S_ISREG(sb.st_mode)) {
 220       /* printf("Processing regular file '%s'.\n", dir_name); */
 221       read_file(dir_name, nb_fields_to_parse, fields_to_parse, db_file);
 222     }
 223   }
 224 }
 225
 226 /*********************************************************************/
 227
 228 /* For long options that have no equivalent short option, use a
 229    non-character as a pseudo short option, starting with CHAR_MAX + 1.  */
 230 enum
 231 {
 232   OPT_BASH_MODE = CHAR_MAX + 1
 233 };
 234
 235 static struct option long_options[] = {
 236   { "help", no_argument, 0, 'h' },
 237   { "db-prefix", 1, 0, 'p' },
 238   { "search-pattern", 1, 0, 's' },
 239   { "index", 0, 0, 'i' },
 240   { 0, 0, 0, 0 }
 241 };
 242
 243 static struct parsable_field fields_to_parse[] = {
 244   {
 245     "from",
 246     "^\\([Ff][Rr][Oo][Mm]:\\|From\\) *",
 247     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 248   },
 249
 250   {
 251     "dest",
 252     "^\\([Tt][Oo]\\|[Cc][Cc]\\|[Bb][Cc][Cc]\\): *",
 253     { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
 254   },
 255 };
 256
 257 int main(int argc, char **argv) {
 258   int error = 0, show_help = 0;
 259   const int nb_fields_to_parse = sizeof(fields_to_parse) / sizeof(struct parsable_field);
 260   char c;
 261   int f;
 262
 263   action_index = 0;
 264   search_pattern = 0;
 265
 266   setlocale(LC_ALL, "");
 267
 268   while ((c = getopt_long(argc, argv, "hip:s:",
 269                           long_options, NULL)) != -1) {
 270
 271     switch(c) {
 272
 273     case 'h':
 274       show_help = 1;
 275       break;
 276
 277     case 'i':
 278       action_index = 1;
 279       break;
 280
 281     case 'p':
 282       db_filename = strdup(optarg);
 283       break;
 284
 285     case 's':
 286       if(search_pattern) {
 287         fprintf(stderr,
 288                 "mymail: Search pattern already defined.\n");
 289         exit(EXIT_FAILURE);
 290       }
 291       search_pattern = strdup(optarg);
 292       break;
 293
 294     default:
 295       error = 1;
 296       break;
 297     }
 298   }
 299
 300   if(!db_filename) {
 301     db_filename = strdup("/tmp/mymail");
 302   }
 303
 304   if(error) {
 305     usage(stderr);
 306     exit(EXIT_FAILURE);
 307   }
 308
 309   if(show_help) {
 310     usage(stdout);
 311     exit(EXIT_SUCCESS);
 312   }
 313
 314   if(action_index) {
 315     FILE *db_file = fopen(db_filename, "w");
 316     if(!db_file) {
 317       fprintf(stderr,
 318               "mymail: Can not open \"%s\" for writing: %s\n",
 319               db_filename,
 320               strerror(errno));
 321       exit(EXIT_FAILURE);
 322     }
 323
 324     for(f = 0; f < nb_fields_to_parse; f++) {
 325       if(regcomp(&fields_to_parse[f].regexp,
 326                  fields_to_parse[f].regexp_string,
 327                  REG_ICASE)) {
 328         fprintf(stderr,
 329                 "mymail: Syntax error in regexp \"%s\" for field \"%s\".\n",
 330                 fields_to_parse[f].regexp_string,
 331                 fields_to_parse[f].name);
 332         exit(EXIT_FAILURE);
 333       }
 334     }
 335
 336     while(optind < argc) {
 337       process_entry(argv[optind],
 338                     nb_fields_to_parse, fields_to_parse, db_file);
 339       optind++;
 340     }
 341
 342     fclose(db_file);
 343
 344     for(f = 0; f < nb_fields_to_parse; f++) {
 345       regfree(&fields_to_parse[f].regexp);
 346     }
 347   }
 348
 349   else {
 350     if(search_pattern) {
 351       FILE *db_file;
 352       char *search_name;
 353       char *search_regexp_string;
 354       search_name = search_pattern;
 355       search_regexp_string = search_pattern;
 356       while(*search_regexp_string && *search_regexp_string != ' ') search_regexp_string++;
 357       *search_regexp_string = '\0'; search_regexp_string++;
 358       while(*search_regexp_string && *search_regexp_string == ' ') search_regexp_string++;
 359       if(!*search_regexp_string) {
 360         fprintf(stderr,
 361                 "Syntax error in the search pattern.\n");
 362         exit(EXIT_FAILURE);
 363       }
 364
 365       printf("Starting search in %s for field \"%s\" matching \"%s\".\n",
 366              db_filename,
 367              search_name,
 368              search_regexp_string);
 369
 370       db_file = fopen(db_filename, "r");
 371
 372       if(!db_file) {
 373         fprintf(stderr,
 374                 "mymail: Can not open \"%s\" for reading: %s\n",
 375                 db_filename,
 376                 strerror(errno));
 377         exit(EXIT_FAILURE);
 378       }
 379       search_in_db(search_name, search_regexp_string, db_file);
 380
 381       fclose(db_file);
 382       free(search_pattern);
 383     }
 384   }
 385
 386   exit(EXIT_SUCCESS);
 387 }