Increased the version number.
[mymail.git] / mymail.c
index e078bf6..10d4428 100644 (file)
--- a/mymail.c
+++ b/mymail.c
@@ -46,7 +46,7 @@
 #include <time.h>
 
 #define MYMAIL_DB_MAGIC_TOKEN "mymail_index_file"
-#define VERSION "0.9.5"
+#define VERSION "0.9.6"
 
 #define MAX_NB_SEARCH_CONDITIONS 32
 
@@ -73,7 +73,7 @@ enum {
   ID_DATE,
   ID_PARTICIPANT,
   ID_BODY,
-  ID_INTERVAL,
+  ID_TIME_INTERVAL,
   MAX_ID
 };
 
@@ -252,54 +252,24 @@ int is_a_leading_from_line(char *mbox_line) {
 int mbox_line_match_search(struct search_condition *condition,
                            int mbox_id, const char *mbox_value) {
 
-  if(condition->field_id == ID_INTERVAL) {
-    const char *c;
-    time_t t;
-    struct tm tm;
-    if(global_use_leading_time) {
-      if(mbox_id == ID_LEADING_LINE) {
-        c = mbox_value;
-        while(*c && *c != ' ') c++; while(*c && *c == ' ') c++;
-        strptime(c, "%a %b %e %k:%M:%S %Y", &tm);
-        t = mktime(&tm);
-        return (t >= condition->interval_start &&
-                (condition->interval_stop == 0 ||
-                 t <= condition->interval_stop));
-      } else {
-        return 0;
-      }
-    } else {
-      if(mbox_id == ID_DATE) {
-        strptime(mbox_value, "%a, %d %b %Y %k:%M:%S", &tm);
-        t = mktime(&tm);
-        return (t >= condition->interval_start &&
-                (condition->interval_stop == 0 ||
-                 t <= condition->interval_stop));
-      } else {
-        return 0;
-      }
-    }
-  } else {
-    return
-      (
-
-       (condition->field_id == mbox_id)
+  return
+    (
+     (condition->field_id == mbox_id)
 
-       ||
+     ||
 
-       (condition->field_id == ID_PARTICIPANT && (mbox_id == ID_LEADING_LINE ||
-                                                  mbox_id == ID_FROM ||
-                                                  mbox_id == ID_TO))
-       ||
+     (condition->field_id == ID_PARTICIPANT && (mbox_id == ID_LEADING_LINE ||
+                                                mbox_id == ID_FROM ||
+                                                mbox_id == ID_TO))
+     ||
 
-       (condition->field_id == ID_FROM && mbox_id == ID_LEADING_LINE)
+     (condition->field_id == ID_FROM && mbox_id == ID_LEADING_LINE)
 
-       )
+     )
 
-      &&
+    &&
 
-      regexec(&condition->regexp, mbox_value, 0, 0, 0) == 0;
-  }
+    regexec(&condition->regexp, mbox_value, 0, 0, 0) == 0;
 }
 
 void update_body_hits(char *mail_filename, int position_in_mail,
@@ -368,6 +338,78 @@ void extract_mail(const char *mail_filename, unsigned long int position_in_mail,
   fclose(mail_file);
 }
 
+int check_full_mail_match(char *current_mail_filename,
+                          time_t mail_time,
+                          int nb_search_conditions,
+                          struct search_condition *search_conditions,
+                          int nb_body_conditions,
+                          int *hits,
+                          int current_position_in_mail) {
+  int n, nb_fulfilled_body_conditions;
+
+  for(n = 0; n < nb_search_conditions; n++) {
+    if(search_conditions[n].field_id == ID_TIME_INTERVAL) {
+      hits[n] = (mail_time >= search_conditions[n].interval_start &&
+                 (search_conditions[n].interval_stop == 0 ||
+                  mail_time <= search_conditions[n].interval_stop));
+    }
+  }
+
+  /* We first check all conditions but the body ones */
+
+  for(n = 0; n < nb_search_conditions &&
+        ((search_conditions[n].field_id == ID_BODY) ||
+         xor(hits[n], search_conditions[n].negation)); n++);
+
+  if(n == nb_search_conditions) {
+
+    /* Now check the body ones */
+
+    nb_fulfilled_body_conditions = 0;
+
+    if(nb_body_conditions > 0) {
+      update_body_hits(current_mail_filename, current_position_in_mail,
+                       nb_search_conditions, search_conditions,
+                       nb_body_conditions,
+                       hits);
+
+      for(n = 0; n < nb_search_conditions; n++) {
+        if(search_conditions[n].field_id == ID_BODY &&
+           xor(hits[n], search_conditions[n].negation)) {
+          nb_fulfilled_body_conditions++;
+        }
+      }
+    }
+    return nb_body_conditions == nb_fulfilled_body_conditions;
+  } else {
+    return 0;
+  }
+}
+
+/* We use the mail leading line time by default, and if we should and
+   can, we update with the Date: field */
+
+void update_time(int mbox_id, const char *mbox_value, time_t *t) {
+  const char *c;
+  struct tm tm;
+
+  if(mbox_id == ID_LEADING_LINE) {
+    c = mbox_value;
+    while(*c && *c != ' ') c++; while(*c && *c == ' ') c++;
+    strptime(c, "%a %b %e %k:%M:%S %Y", &tm);
+    *t = mktime(&tm);
+  } else {
+    if(!global_use_leading_time) {
+      if(mbox_id == ID_DATE) {
+        if(strptime(mbox_value, "%a, %d %b %Y %k:%M:%S", &tm) ||
+           strptime(mbox_value, "%d %b %Y %k:%M:%S", &tm)) {
+          *t = mktime(&tm);
+        }
+      }
+    }
+  }
+}
+
 int search_in_db(const char *db_filename,
                  int nb_search_conditions,
                  struct search_condition *search_conditions,
@@ -378,12 +420,14 @@ int search_in_db(const char *db_filename,
   char current_mail_filename[PATH_MAX + 1];
   unsigned long int current_position_in_mail;
   char mbox_key[TOKEN_BUFFER_SIZE];
+  char position_in_file_string[TOKEN_BUFFER_SIZE];
   const char *mbox_value;
   int mbox_id;
   int already_written, m, n;
-  int nb_body_conditions, nb_fulfilled_body_conditions;
+  int nb_body_conditions, need_time;
   FILE *db_file;
   int nb_extracted_mails;
+  time_t mail_time;
 
   nb_extracted_mails = 0;
 
@@ -418,10 +462,16 @@ int search_in_db(const char *db_filename,
   for(n = 0; n < nb_search_conditions; n++) { hits[n] = 0; }
 
   nb_body_conditions = 0;
+  need_time = 0;
+  mail_time = 0;
+
   for(n = 0; n < nb_search_conditions; n++) {
     if(search_conditions[n].field_id == ID_BODY) {
       nb_body_conditions++;
     }
+    else if(search_conditions[n].field_id == ID_TIME_INTERVAL) {
+      need_time = 1;
+    }
   }
 
   strcpy(current_mail_filename, "");
@@ -430,47 +480,19 @@ int search_in_db(const char *db_filename,
     mbox_value = parse_token(mbox_key, TOKEN_BUFFER_SIZE, ' ', raw_db_line);
 
     if(strcmp("mail", mbox_key) == 0) {
-      char position_in_file_string[TOKEN_BUFFER_SIZE];
-
       if(current_mail_filename[0]) {
-
-        /* We first check all conditions but the body ones */
-
-        for(n = 0; n < nb_search_conditions &&
-              ((search_conditions[n].field_id == ID_BODY) ||
-               xor(hits[n], search_conditions[n].negation)); n++);
-
-        if(n == nb_search_conditions) {
-
-          /* Now check the body ones */
-
-          nb_fulfilled_body_conditions = 0;
-
-          if(nb_body_conditions > 0) {
-            update_body_hits(current_mail_filename, current_position_in_mail,
-                             nb_search_conditions, search_conditions,
-                             nb_body_conditions,
-                             hits);
-
-            for(n = 0; n < nb_search_conditions; n++) {
-              if(search_conditions[n].field_id == ID_BODY &&
-                 xor(hits[n], search_conditions[n].negation)) {
-                nb_fulfilled_body_conditions++;
-              }
-            }
-          }
-
-          if(nb_body_conditions == nb_fulfilled_body_conditions) {
-            nb_extracted_mails++;
-            extract_mail(current_mail_filename, current_position_in_mail, output_file);
-          }
+        if(check_full_mail_match(current_mail_filename,
+                                 mail_time,
+                                 nb_search_conditions, search_conditions,
+                                 nb_body_conditions, hits, current_position_in_mail)) {
+          extract_mail(current_mail_filename, current_position_in_mail, output_file);
+          nb_extracted_mails++;
         }
       }
 
       for(n = 0; n < nb_search_conditions; n++) { hits[n] = 0; }
-
       mbox_value = parse_token(position_in_file_string, TOKEN_BUFFER_SIZE, ' ', mbox_value);
-      mbox_value = parse_token(current_mail_filename, TOKEN_BUFFER_SIZE, '\n', mbox_value);
+      mbox_value = parse_token(current_mail_filename, PATH_MAX+1, '\n', mbox_value);
       current_position_in_mail = atol(position_in_file_string);
       already_written = 0;
     }
@@ -482,10 +504,25 @@ int search_in_db(const char *db_filename,
           mbox_id = m;
         }
       }
+
       for(n = 0; n < nb_search_conditions; n++) {
         hits[n] |= mbox_line_match_search(&search_conditions[n],
                                           mbox_id, mbox_value);
       }
+
+      if(need_time) {
+        update_time(mbox_id, mbox_value, &mail_time);
+      }
+    }
+  }
+
+  if(current_mail_filename[0]) {
+    if(check_full_mail_match(current_mail_filename,
+                             mail_time,
+                             nb_search_conditions, search_conditions,
+                             nb_body_conditions, hits, current_position_in_mail)) {
+      extract_mail(current_mail_filename, current_position_in_mail, output_file);
+      nb_extracted_mails++;
     }
   }
 
@@ -712,6 +749,7 @@ static struct option long_options[] = {
 
 struct time_criterion {
   char *label;
+  int day_criterion;
   int start_hour, end_hour;
   int past_week_day;
 };
@@ -720,23 +758,23 @@ struct time_criterion {
 
 static struct time_criterion time_criteria[] = {
 
-  { "8h",         8,       -1, -1 },
-  { "today",     24,       -1, -1 },
-  { "24h",       24,       -1, -1 },
-  { "48h",       48,       -1, -1 },
-  { "week",      24 *   7, -1, -1 },
-  { "month",     24 *  31, -1, -1 },
-  { "year",      24 * 365, -1, -1 },
+  { "8h",        0,  8,       -1, -1 },
+  { "24h",       0, 24,       -1, -1 },
+  { "48h",       0, 48,       -1, -1 },
+  { "week",      0, 24 *   7, -1, -1 },
+  { "month",     0, 24 *  31, -1, -1 },
+  { "year",      0, 24 * 365, -1, -1 },
 
-  { "yesterday", 48,       24, -1 },
+  { "yesterday", 1, -1,       -1, -1 },
+  { "today",     1, -1,       -1,  0 },
 
-  { "monday",    -1,       -1,  1 },
-  { "tuesday",   -1,       -1,  2 },
-  { "wednesday", -1,       -1,  3 },
-  { "thursday",  -1,       -1,  4 },
-  { "friday",    -1,       -1,  5 },
-  { "saturday",  -1,       -1,  6 },
-  { "sunday",    -1,       -1,  7 },
+  { "monday",    1, -1,       -1,  1 },
+  { "tuesday",   1, -1,       -1,  2 },
+  { "wednesday", 1, -1,       -1,  3 },
+  { "thursday",  1, -1,       -1,  4 },
+  { "friday",    1, -1,       -1,  5 },
+  { "saturday",  1, -1,       -1,  6 },
+  { "sunday",    1, -1,       -1,  7 },
 
 };
 
@@ -748,8 +786,11 @@ time_t time_for_past_day(int day) {
   int delta_day;
   t = time(0);
   tm = localtime(&t);
-  delta_day = (7 + tm->tm_wday - day) % 7;
-  if(delta_day == 0) { delta_day = 7; }
+  if(day > 0) {
+    delta_day = (7 + tm->tm_wday - day) % 7;
+  } else {
+    delta_day = - day;
+  }
   return t - (delta_day * 3600 * 24 + tm->tm_sec + 60 * tm->tm_min + 3600 * tm->tm_hour);
 }
 
@@ -775,17 +816,17 @@ void init_condition(struct search_condition *condition, const char *full_string,
 
   for(k = 0; k < sizeof(time_criteria) / sizeof(struct time_criterion); k++) {
     if(strcmp(time_criteria[k].label, search_field) == 0) {
-      condition->field_id = ID_INTERVAL;
-      if(time_criteria[k].past_week_day < 0) {
+      condition->field_id = ID_TIME_INTERVAL;
+      if(time_criteria[k].day_criterion) {
+        condition->interval_start = time_for_past_day(time_criteria[k].past_week_day);
+        condition->interval_stop = condition->interval_start + 3600 * 24;
+      } else {
         condition->interval_start = time(0) - 3600 * time_criteria[k].start_hour;
         if(time_criteria[k].end_hour >= 0) {
           condition->interval_stop = time(0) - 3600 * time_criteria[k].end_hour;
         } else {
           condition->interval_stop = 0;
         }
-      } else {
-        condition->interval_start = time_for_past_day(time_criteria[k].past_week_day);
-        condition->interval_stop = condition->interval_start + 3600 * 24;
       }
       break;
     }
@@ -836,7 +877,7 @@ void init_condition(struct search_condition *condition, const char *full_string,
 }
 
 void free_condition(struct search_condition *condition) {
-  if(condition->field_id != ID_INTERVAL) {
+  if(condition->field_id != ID_TIME_INTERVAL) {
     regfree(&condition->regexp);
   }
 }