cm.c

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