cm.c

   1 /*
   2  *      Incoming Mail Checker
   3  *
   4  *      (c) 2005 Martin Mares <mj@ucw.cz>
   5  */
   6
   7 #include <stdio.h>
   8 #include <string.h>
   9 #include <stdlib.h>
  10 #include <ctype.h>
  11 #include <getopt.h>
  12 #include <fcntl.h>
  13 #include <glob.h>
  14 #include <fnmatch.h>
  15 #include <sys/stat.h>
  16 #include <unistd.h>
  17 #include <pwd.h>
  18 #include <time.h>
  19 #include <curses.h>
  20
  21 #include "util.h"
  22 #include "clists.h"
  23
  24 static int check_interval = 30;
  25 static int force_refresh;
  26 static int allow_bells = 1;
  27 static int minimum_priority;
  28 static time_t last_scan_time;
  29 static char *run_cmd = "mutt -f %s";
  30
  31 struct options {
  32   int priority;
  33   int hide;
  34   int hide_if_empty;
  35   int highlight;
  36   int beep;
  37   int snippets;
  38 };
  39
  40 struct option_node {
  41   cnode n;
  42   struct options o;
  43   char pattern[1];
  44 };
  45
  46 struct pattern_node {
  47   cnode n;
  48   char *name;
  49   char pattern[1];
  50 };
  51
  52 static clist options, patterns;
  53 static struct options global_options;
  54
  55 struct mbox {
  56   cnode n;
  57   struct options o;
  58   char *name;
  59   char *path;
  60   int index;
  61   int scanning;
  62   int seen;
  63   time_t last_time;
  64   int last_size, last_pos;
  65   int total, new;
  66   int last_total, last_new;
  67   int last_beep_new;
  68   int force_refresh;
  69   char snippet[256];
  70 };
  71
  72 static clist mboxes;
  73 static struct mbox **mbox_array;
  74 static int num_mboxes, mbox_array_size;
  75
  76 static void redraw_line(int i);
  77 static void rethink_display(void);
  78
  79 static void
  80 add_pattern(char *patt)
  81 {
  82   struct pattern_node *n = xmalloc(sizeof(*n) + strlen(patt));
  83   strcpy(n->pattern, patt);
  84   if (patt = strchr(n->pattern, '='))
  85     {
  86       *patt++ = 0;
  87       n->name = patt;
  88     }
  89   else
  90     n->name = NULL;
  91   clist_add_tail(&patterns, &n->n);
  92 }
  93
  94 static void
  95 add_inbox(void)
  96 {
  97   struct passwd *p = getpwuid(getuid());
  98   if (!p)
  99     die("You don't exist, go away!");
 100   char buf[sizeof("/var/mail/") + strlen(p->pw_name) + 7];
 101   sprintf(buf, "/var/mail/%s=INBOX", p->pw_name);
 102   add_pattern(buf);
 103 }
 104
 105 static void
 106 init_options(struct options *o)
 107 {
 108   o->priority = -1;
 109   o->hide = -1;
 110   o->hide_if_empty = -1;
 111   o->beep = -1;
 112   o->highlight = -1;
 113   o->snippets = -1;
 114 }
 115
 116 static void
 117 setup_options(struct mbox *b)
 118 {
 119   b->o = global_options;
 120   CLIST_FOR_EACH(struct option_node *, n, options)
 121     if (!fnmatch(n->pattern, b->name, 0))
 122       {
 123         debug("\tApplied options %s\n", n->pattern);
 124 #define MERGE(f) if (n->o.f >= 0) b->o.f = n->o.f
 125         MERGE(priority);
 126         MERGE(hide);
 127         MERGE(hide_if_empty);
 128         MERGE(highlight);
 129         MERGE(beep);
 130         MERGE(snippets);
 131       }
 132 }
 133
 134 static char *
 135 mbox_name(char *path)
 136 {
 137   char *c = strrchr(path, '/');
 138   return c ? (c+1) : path;
 139 }
 140
 141 static struct mbox *
 142 add_mbox(clist *l, char *path, char *name)
 143 {
 144   struct mbox *b = xmalloc(sizeof(*b));
 145   bzero(b, sizeof(*b));
 146   b->path = xstrdup(path);
 147   b->name = xstrdup(name);
 148
 149   if (name)
 150     {
 151       cnode *prev = l->head.prev;
 152       while (prev != &l->head && strcmp(((struct mbox *)prev)->name, name) > 0)
 153         prev = prev->prev;
 154       clist_insert_after(&b->n, prev);
 155     }
 156   else
 157     clist_add_tail(l, &b->n);
 158
 159   return b;
 160 }
 161
 162 static void
 163 del_mbox(struct mbox *b)
 164 {
 165   clist_remove(&b->n);
 166   free(b->path);
 167   free(b->name);
 168   free(b);
 169 }
 170
 171 static struct mbox *
 172 find_mbox(clist *l, char *path)
 173 {
 174   CLIST_FOR_EACH(struct mbox *, b, *l)
 175     if (!strcmp(b->path, path))
 176       return b;
 177   return NULL;
 178 }
 179
 180 static inline int
 181 mbox_active_p(struct mbox *b)
 182 {
 183   if (b->o.priority < minimum_priority)
 184     return 0;
 185   if (b->o.hide)
 186     return 0;
 187   return 1;
 188 }
 189
 190 static inline int
 191 mbox_visible_p(struct mbox *b)
 192 {
 193   if (!mbox_active_p(b))
 194     return 0;
 195   if (b->scanning < 0)
 196     return 1;
 197   if (b->o.hide_if_empty && !b->total)
 198     return 0;
 199   return 1;
 200 }
 201
 202 static void
 203 add_snippet(char **ppos, char *term, unsigned char *add)
 204 {
 205   char *pos = *ppos;
 206   int space = 1;
 207   while (*add && pos < term)
 208     {
 209       if (*add <= ' ')
 210         {
 211           if (!space)
 212             *pos++ = ' ';
 213           space = 1;
 214         }
 215       else if (*add >= 0x7f)
 216         {
 217           *pos++ = '?';
 218           space = 0;
 219         }
 220       else
 221         {
 222           *pos++ = *add;
 223           space = 0;
 224         }
 225       add++;
 226     }
 227   *ppos = pos;
 228   *pos = 0;
 229 }
 230
 231 static void
 232 prepare_snippet(struct mbox *b, char *sender, char *subject)
 233 {
 234   while (*sender == ' ' || *sender == '\t')
 235     sender++;
 236   while (*subject == ' ' || *subject == '\t')
 237     subject++;
 238
 239   char *pos = b->snippet;
 240   char *term = b->snippet + sizeof(b->snippet) - 1;
 241   if (sender[0])
 242     {
 243       add_snippet(&pos, term, sender);
 244       add_snippet(&pos, term, ": ");
 245     }
 246   if (subject[0])
 247     add_snippet(&pos, term, subject);
 248   else
 249     add_snippet(&pos, term, "No subject");
 250 }
 251
 252 static int mb_fd, mb_pos;
 253 static unsigned char mb_buf[4096], *mb_cc, *mb_end;
 254
 255 static void
 256 mb_reset(int pos)
 257 {
 258   mb_cc = mb_end = mb_buf;
 259   mb_pos = pos;
 260 }
 261
 262 static void
 263 mb_seek(uns pos)
 264 {
 265   lseek(mb_fd, pos, SEEK_SET);
 266   mb_reset(pos);
 267 }
 268
 269 static int
 270 mb_tell(void)
 271 {
 272   return mb_pos - (mb_end - mb_cc);
 273 }
 274
 275 static int
 276 mb_ll_get(void)
 277 {
 278   int len = read(mb_fd, mb_buf, sizeof(mb_buf));
 279   mb_cc = mb_buf;
 280   if (len <= 0)
 281     {
 282       mb_end = mb_buf;
 283       return -1;
 284     }
 285   else
 286     {
 287       mb_end = mb_buf + len;
 288       mb_pos += len;
 289       return *mb_cc++;
 290     }
 291 }
 292
 293 static inline int
 294 mb_get(void)
 295 {
 296   return (mb_cc < mb_end) ? *mb_cc++ : mb_ll_get();
 297 }
 298
 299 static int
 300 mb_check(const char *p, int len)
 301 {
 302   while (len--)
 303     {
 304       if (mb_get() != *p++)
 305         return 0;
 306     }
 307   return 1;
 308 }
 309
 310 static void
 311 scan_mbox(struct mbox *b, struct stat *st)
 312 {
 313   char buf[1024], sender[1024], subject[1024];
 314   int c;
 315   const char from[] = "\nFrom ";
 316
 317   if (!st->st_size)
 318     {
 319       b->total = b->new = 0;
 320       b->last_pos = 0;
 321       return;
 322     }
 323
 324   /* FIXME: Locking! */
 325
 326   mb_fd = open(b->path, O_RDONLY);
 327   if (mb_fd < 0)
 328     {
 329       debug("[open failed: %m] ");
 330       b->total = b->new = -1;
 331       return;
 332     }
 333   mb_reset(0);
 334
 335   int incremental = 0;
 336   if (b->last_size && b->last_pos && st->st_size > b->last_size && !b->force_refresh)
 337     {
 338       mb_seek(b->last_pos);
 339       if (mb_check(from, 6))
 340         {
 341           debug("[incremental] ");
 342           incremental = 1;
 343         }
 344       else
 345         {
 346           debug("[incremental failed] ");
 347           mb_seek(0);
 348         }
 349     }
 350   if (!incremental)
 351     {
 352       if (!mb_check(from+1, 5))
 353         {
 354           debug("[inconsistent] ");
 355           b->total = b->new = -1;
 356           goto done;
 357         }
 358       b->total = b->new = 0;
 359       b->last_total = b->last_new = 0;
 360     }
 361   else
 362     {
 363       b->total = b->last_total;
 364       b->new = b->last_new;
 365     }
 366
 367   for(;;)
 368     {
 369       b->last_pos = mb_tell() - 5;
 370       if (b->last_pos)
 371         b->last_pos--;          // last_pos should be the previous \n character
 372       b->last_total = b->total;
 373       b->last_new = b->new;
 374       while ((c = mb_get()) >= 0 && c != '\n')
 375         ;
 376
 377       int new = 1;
 378       sender[0] = 0;
 379       subject[0] = 0;
 380       for (;;)
 381         {
 382           uns i = 0;
 383           for (;;)
 384             {
 385               c = mb_get();
 386               if (c < 0)
 387                 {
 388                   debug("[truncated] ");
 389                   goto done;
 390                 }
 391               if (c == '\n')
 392                 break;
 393               if (c == '\r')
 394                 continue;
 395               if (i < sizeof(buf) - 1)
 396                 buf[i++] = c;
 397             }
 398           buf[i] = 0;
 399           if (!buf[0])
 400             break;
 401           if (!strncasecmp(buf, "Status:", 7))
 402             new = 0;
 403           else if (!strncasecmp(buf, "From:", 5))
 404             strcpy(sender, buf+5);
 405           else if (!strncasecmp(buf, "Subject:", 8))
 406             strcpy(subject, buf+8);
 407         }
 408
 409       b->total++;
 410       if (new)
 411         {
 412           b->new++;
 413           prepare_snippet(b, sender, subject);
 414         }
 415
 416       int ct = 1;
 417       while (from[ct])
 418         {
 419           c = mb_get();
 420           if (c < 0)
 421             goto done;
 422           if (c != from[ct++])
 423             ct = (c == '\n');
 424         }
 425     }
 426
 427  done:
 428   close(mb_fd);
 429 }
 430
 431 static void
 432 scan(void)
 433 {
 434   debug("Searching for mailboxes...\n");
 435   last_scan_time = time(NULL);
 436   CLIST_FOR_EACH(struct pattern_node *, p, patterns)
 437     {
 438       debug("Trying pattern %s (name %s)\n", p->pattern, p->name);
 439       glob_t g;
 440       int err = glob(p->pattern, GLOB_ERR | GLOB_NOSORT | GLOB_TILDE | GLOB_TILDE_CHECK, NULL, &g);
 441       if (err && err != GLOB_NOMATCH)
 442         die("Failed to glob %s: %m", p->pattern);
 443       for (uns i=0; i<g.gl_pathc; i++)
 444         {
 445           char *name = g.gl_pathv[i];
 446           struct mbox *b = find_mbox(&mboxes, name);
 447           if (!b)
 448             {
 449               b = add_mbox(&mboxes, name, (p->name ? p->name : mbox_name(name)));
 450               debug("Discovered mailbox %s (%s)\n", b->name, b->path);
 451               setup_options(b);
 452               b->scanning = -1;
 453             }
 454           b->seen = 1;
 455         }
 456       globfree(&g);
 457     }
 458
 459   struct mbox *tmp;
 460   CLIST_FOR_EACH_DELSAFE(struct mbox *, b, mboxes, tmp)
 461     {
 462       if (b->seen)
 463         b->seen = 0;
 464       else
 465         {
 466           debug("Lost mailbox %s\n", b->name);
 467           del_mbox(b);
 468         }
 469     }
 470
 471   rethink_display();
 472
 473   debug("Scanning mailboxes...\n");
 474   CLIST_FOR_EACH(struct mbox *, b, mboxes)
 475     {
 476       struct stat st;
 477       debug("%s: ", b->name);
 478       if (!mbox_active_p(b))
 479         {
 480           debug("inactive\n");
 481           continue;
 482         }
 483       if (force_refresh)
 484         b->force_refresh = 1;
 485       if (stat(b->path, &st) < 0)
 486         {
 487           b->total = b->new = -1;
 488           debug("%m\n");
 489         }
 490       else if (!b->last_time || st.st_mtime != b->last_time || st.st_size != b->last_size || b->force_refresh)
 491         {
 492           b->scanning = 1;
 493           redraw_line(b->index);
 494           refresh();
 495
 496           scan_mbox(b, &st);
 497           b->last_time = st.st_mtime;
 498           b->last_size = st.st_size;
 499           debug("%d %d (stopped at %d of %d)\n", b->total, b->new, b->last_pos, b->last_size);
 500
 501           b->scanning = 0;
 502           redraw_line(b->index);
 503           refresh();
 504         }
 505       else
 506         debug("not changed\n");
 507       b->force_refresh = 0;
 508     }
 509   force_refresh = 0;
 510
 511   debug("Scan finished\n");
 512   last_scan_time = time(NULL);
 513   rethink_display();
 514 }
 515
 516 static int cursor_at, cursor_max;
 517
 518 enum {
 519   M_IDLE,
 520   M_SCAN,
 521   M_NEW,
 522   M_BAD,
 523   M_MAX
 524 };
 525 static int attrs[2][2][M_MAX];          // active, hilite, status
 526
 527 static void
 528 redraw_line(int i)
 529 {
 530   move(i, 0);
 531   if (i < cursor_max)
 532     {
 533       struct mbox *b = mbox_array[i];
 534       int cc = (cursor_at == i);
 535       int hi = b->o.highlight;
 536
 537       attrset(attrs[cc][hi][M_IDLE]);
 538       if (cc)
 539         printw("> ");
 540       else
 541         printw("  ");
 542       if (b->new)
 543         attrset(attrs[cc][hi][M_NEW]);
 544       printw("%-20s ", b->name);
 545       if (b->scanning < 0)
 546         ;
 547       else if (b->scanning)
 548         {
 549           attrset(attrs[cc][hi][M_SCAN]);
 550           printw("[SCANNING]");
 551         }
 552       else if (b->total < 0)
 553         {
 554           attrset(attrs[cc][hi][M_BAD]);
 555           printw("BROKEN");
 556         }
 557       else
 558         {
 559           attrset(attrs[cc][hi][M_IDLE]);
 560           printw("%6d ", b->total);
 561           if (b->new)
 562             {
 563               attrset(attrs[cc][hi][M_NEW]);
 564               printw("%6d  ", b->new);
 565               attrset(attrs[cc][hi][M_IDLE]);
 566               int age = (last_scan_time - b->last_time);
 567               if (age < 0)
 568                 age = 0;
 569               if (age < 3600)
 570                 printw("%2d min  ", age/60);
 571               else if (age < 86400)
 572                 printw("%2d hrs  ", age/3600);
 573               else
 574                 printw("        ");
 575               if (b->o.snippets && b->snippet[0])
 576                 {
 577                   int xx, yy;
 578                   getyx(stdscr, yy, xx);
 579                   int remains = COLS-1-xx;
 580                   if (remains > 2)
 581                     printw("%-.*s", remains, b->snippet);
 582                 }
 583             }
 584         }
 585     }
 586   attrset(attrs[0][0][M_IDLE]);
 587   clrtoeol();
 588 }
 589
 590 static void
 591 redraw_all(void)
 592 {
 593   cursor_max = num_mboxes;
 594   if (cursor_max > LINES-1)
 595     cursor_max = LINES-1;
 596   if (cursor_at >= cursor_max)
 597     cursor_at = cursor_max - 1;
 598   if (cursor_at < 0)
 599     cursor_at = 0;
 600
 601   for (int i=0; i<cursor_max; i++)
 602     redraw_line(i);
 603   move(cursor_max, 0);
 604   if (!cursor_max)
 605     {
 606       printw("(no mailboxes found)");
 607       clrtoeol();
 608       move(1, 0);
 609     }
 610   clrtobot();
 611 }
 612
 613 static void
 614 rethink_display(void)
 615 {
 616   int i = 0;
 617   int changed = 0;
 618   int beeeep = 0;
 619   CLIST_FOR_EACH(struct mbox *, b, mboxes)
 620     if (mbox_visible_p(b))
 621       {
 622         b->index = i;
 623         if (i >= num_mboxes || mbox_array[i] != b)
 624           {
 625             changed = 1;
 626             if (i >= mbox_array_size)
 627               {
 628                 mbox_array_size = (mbox_array_size ? 2*mbox_array_size : 16);
 629                 mbox_array = xrealloc(mbox_array, sizeof(struct mbox *) * mbox_array_size);
 630               }
 631             mbox_array[i] = b;
 632           }
 633         if (b->o.beep && b->new > b->last_beep_new)
 634           beeeep = 1;
 635         b->last_beep_new = b->new;
 636         i++;
 637       }
 638   if (i != num_mboxes)
 639     changed = 1;
 640   num_mboxes = i;
 641
 642   if (changed)
 643     {
 644       redraw_all();
 645       refresh();
 646     }
 647   if (beeeep && allow_bells)
 648     beep();
 649 }
 650
 651 static void
 652 term_init(void)
 653 {
 654   initscr();
 655   cbreak();
 656   noecho();
 657   nonl();
 658   intrflush(stdscr, FALSE);
 659   keypad(stdscr, TRUE);
 660   curs_set(0);
 661
 662   static const int attrs_mono[2][M_MAX] = {
 663     [0] = { [M_IDLE] = 0, [M_SCAN] = A_BOLD, [M_NEW] = A_BOLD, [M_BAD] = A_DIM },
 664     [1] = { [M_IDLE] = 0, [M_SCAN] = A_BOLD, [M_NEW] = A_REVERSE | A_BOLD, [M_BAD] = A_DIM },
 665   };
 666   for (int i=0; i<2; i++)
 667     for (int j=0; j<M_MAX; j++)
 668       {
 669         attrs[0][i][j] = attrs_mono[i][j];
 670         attrs[1][i][j] = attrs_mono[i][j] | A_UNDERLINE;
 671       }
 672
 673   if (has_colors())
 674     {
 675       start_color();
 676       if (COLOR_PAIRS >= 5)
 677         {
 678           init_pair(1, COLOR_YELLOW, COLOR_BLACK);
 679           init_pair(2, COLOR_RED, COLOR_BLACK);
 680           init_pair(3, COLOR_WHITE, COLOR_BLUE);
 681           init_pair(4, COLOR_YELLOW, COLOR_BLUE);
 682           init_pair(5, COLOR_RED, COLOR_BLUE);
 683           static const int attrs_color[2][2][M_MAX] = {
 684             [0][0] = { [M_IDLE] = 0, [M_SCAN] = COLOR_PAIR(1), [M_NEW] = COLOR_PAIR(1), [M_BAD] = COLOR_PAIR(2) },
 685             [0][1] = { [M_IDLE] = A_BOLD, [M_SCAN] = COLOR_PAIR(1), [M_NEW] = COLOR_PAIR(1) | A_BOLD, [M_BAD] = COLOR_PAIR(2) | A_BOLD },
 686             [1][0] = { [M_IDLE] = COLOR_PAIR(3), [M_SCAN] = COLOR_PAIR(4), [M_NEW] = COLOR_PAIR(4), [M_BAD] = COLOR_PAIR(5) },
 687             [1][1] = { [M_IDLE] = COLOR_PAIR(3) | A_BOLD, [M_SCAN] = COLOR_PAIR(4), [M_NEW] = COLOR_PAIR(4) | A_BOLD, [M_BAD] = COLOR_PAIR(5) | A_BOLD },
 688           };
 689           memcpy(attrs, attrs_color, sizeof(attrs));
 690         }
 691     }
 692 }
 693
 694 static void
 695 term_cleanup(void)
 696 {
 697   endwin();
 698 }
 699
 700 static void
 701 print_status(char *status)
 702 {
 703   move(LINES-1, 0);
 704   if (status)
 705     printw("%s", status);
 706   clrtoeol();
 707   refresh();
 708 }
 709
 710 static void
 711 scan_and_redraw(void)
 712 {
 713   print_status("Busy...");
 714   scan();
 715   print_status(NULL);
 716 }
 717
 718 static void
 719 move_cursor(int i)
 720 {
 721   if (i >= 0 && i < cursor_max && i != cursor_at)
 722     {
 723       int old = cursor_at;
 724       cursor_at = i;
 725       redraw_line(old);
 726       redraw_line(i);
 727     }
 728 }
 729
 730 static void
 731 next_active(int since, int step)
 732 {
 733   if (!cursor_max)
 734     return;
 735   since = (since+cursor_max) % cursor_max;
 736   step = (step+cursor_max) % cursor_max;
 737   int besti = -1;
 738   int bestp = -1;
 739   int i = since;
 740   do
 741     {
 742       struct mbox *b = mbox_array[i];
 743       if (b->new && b->o.priority > bestp)
 744         {
 745           besti = i;
 746           bestp = b->o.priority;
 747         }
 748       i = (i+step) % cursor_max;
 749     }
 750   while (i != since);
 751   if (besti >= 0)
 752     move_cursor(besti);
 753 }
 754
 755 #define STR2(c) #c
 756 #define STR(c) STR2(c)
 757
 758 static void NONRET
 759 usage(void)
 760 {
 761   fprintf(stderr, "Usage: cm [<options>] [<mbox-pattern> | <mbox>[=<name>]] ...\n\
 762 \n\
 763 Options:\n\
 764 -c <interval>\t\tScan mailboxes every <interval> seconds (default is 30)\n\
 765 -d\t\t\tLog debug messages to stderr\n\
 766 -i\t\t\tInclude user's INBOX\n\
 767 -m <cmd>\t\tCommand to run on the selected mailbox, %%s gets replaced by mailbox path\n\
 768 -o <pattern>=<opts>\tSet mailbox options\n\
 769 -o <opts>\t\tSet default options for all mailboxes\n\
 770 -p <pri>\t\tSet minimum priority to show\n\
 771 \n\
 772 Mailbox options (set with `-o', use upper case to negate):\n\
 773 0-9\t\t\tSet mailbox priority (0=default)\n\
 774 b\t\t\tBeep when a message arrives\n\
 775 e\t\t\tHide from display if empty\n\
 776 h\t\t\tHide from display\n\
 777 s\t\t\tShow message snippets\n\
 778 t\t\t\tHighlight the entry\n\
 779 \n\
 780 CheckMail " STR(VERSION) ", (c) " STR(YEAR) " Martin Mares <mj@ucw.cz>\n\
 781 It can be freely distributed and used according to the GNU GPL v2.\n\
 782 ");
 783   exit(1);
 784 }
 785
 786 static void
 787 parse_options(char *c)
 788 {
 789   struct options *o;
 790   char *sep;
 791   if (sep = strchr(c, '='))
 792     {
 793       struct option_node *n = xmalloc(sizeof(*n) + sep-c);
 794       memcpy(n->pattern, c, sep-c);
 795       n->pattern[sep-c] = 0;
 796       clist_add_tail(&options, &n->n);
 797       o = &n->o;
 798       init_options(o);
 799       c = sep+1;
 800     }
 801   else
 802     o = &global_options;
 803
 804   int x;
 805   while (x = *c++)
 806     if (x >= '0' && x <= '9')
 807       o->priority = x - '0';
 808     else
 809       {
 810         int value = !!islower(x);
 811         switch (tolower(x))
 812           {
 813           case 'b':
 814             o->beep = value;
 815             break;
 816           case 'e':
 817             o->hide_if_empty = value;
 818             break;
 819           case 'h':
 820             o->hide = value;
 821             break;
 822           case 's':
 823             o->snippets = value;
 824             break;
 825           case 't':
 826             o->highlight = value;
 827             break;
 828           default:
 829             fprintf(stderr, "Invalid mailbox option `%c'\n", x);
 830             usage();
 831           }
 832       }
 833 }
 834
 835 int
 836 main(int argc, char **argv)
 837 {
 838   clist_init(&mboxes);
 839   clist_init(&options);
 840   clist_init(&patterns);
 841
 842   int c;
 843   while ((c = getopt(argc, argv, "c:dim:o:p:")) >= 0)
 844     switch (c)
 845       {
 846       case 'c':
 847         check_interval = atol(optarg);
 848         if (check_interval <= 0)
 849           usage();
 850         break;
 851       case 'd':
 852         debug_mode++;
 853         break;
 854       case 'i':
 855         add_inbox();
 856         break;
 857       case 'm':
 858         run_cmd = optarg;
 859         break;
 860       case 'o':
 861         parse_options(optarg);
 862         break;
 863       case 'p':
 864         minimum_priority = atol(optarg);
 865         break;
 866       default:
 867         usage();
 868       }
 869   while (optind < argc)
 870     add_pattern(argv[optind++]);
 871
 872   term_init();
 873   scan_and_redraw();
 874   next_active(0, 1);
 875
 876   int should_exit = 0;
 877   while (!should_exit)
 878     {
 879       time_t now = time(NULL);
 880       int remains = last_scan_time + check_interval - now;
 881       if (remains <= 0 || force_refresh)
 882         scan_and_redraw();
 883       else
 884         {
 885           remains *= 10;
 886           halfdelay((remains > 255) ? 255 : remains);
 887           int ch = getch();
 888           switch (ch)
 889             {
 890             case 'q':
 891               should_exit = 1;
 892               break;
 893             case 'j':
 894             case KEY_DOWN:
 895               move_cursor(cursor_at+1);
 896               break;
 897             case 'k':
 898             case KEY_UP:
 899               move_cursor(cursor_at-1);
 900               break;
 901             case '^':
 902             case KEY_HOME:
 903             case KEY_PPAGE:
 904               move_cursor(0);
 905               break;
 906             case '$':
 907             case KEY_END:
 908             case KEY_NPAGE:
 909               move_cursor(cursor_max-1);
 910               break;
 911             case '\t':
 912               next_active(cursor_at+1, 1);
 913               break;
 914             case '`':
 915               next_active(cursor_at-1, -1);
 916               break;
 917             case '\r':
 918             case '\n':
 919               if (cursor_at < cursor_max)
 920                 {
 921                   struct mbox *b = mbox_array[cursor_at];
 922                   char cmd[strlen(run_cmd) + strlen(b->path) + 16];
 923                   sprintf(cmd, run_cmd, b->path);
 924                   term_cleanup();
 925                   system(cmd);
 926                   term_init();
 927                   redraw_all();
 928                   refresh();
 929                   b->force_refresh = 1;
 930                   scan_and_redraw();
 931                 }
 932               break;
 933             case 'l' & 0x1f:
 934               clearok(stdscr, TRUE);
 935               redraw_all();
 936               refresh();
 937               break;
 938             case 'r' & 0x1f:
 939               force_refresh = 1;
 940               break;
 941             case 'b':
 942               allow_bells = 1;
 943               print_status("Bells and whistles are now enabled. Toot!");
 944               break;
 945             case 'B':
 946               allow_bells = 0;
 947               print_status("Bells and whistles are now disabled. Pssst!");
 948               break;
 949             default:
 950               if (ch >= '0' && ch <= '9')
 951                 {
 952                   minimum_priority = ch - '0';
 953                   scan_and_redraw();
 954                 }
 955               else
 956                 debug("Pressed unknown key %d\n", ch);
 957             }
 958           refresh();
 959         }
 960     }
 961
 962   term_cleanup();
 963   return 0;
 964 }