browser.c

   1 /*
   2  * Copyright (C) 1996-2000,2007 Michael R. Elkins <me@mutt.org>
   3  *
   4  *     This program is free software; you can redistribute it and/or modify
   5  *     it under the terms of the GNU General Public License as published by
   6  *     the Free Software Foundation; either version 2 of the License, or
   7  *     (at your option) any later version.
   8  *
   9  *     This program is distributed in the hope that it will be useful,
  10  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *     GNU General Public License for more details.
  13  *
  14  *     You should have received a copy of the GNU General Public License
  15  *     along with this program; if not, write to the Free Software
  16  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  17  */
  18
  19 #if HAVE_CONFIG_H
  20 # include "config.h"
  21 #endif
  22
  23 #include "mutt.h"
  24 #include "mutt_curses.h"
  25 #include "mutt_menu.h"
  26 #include "attach.h"
  27 #include "buffy.h"
  28 #include "mapping.h"
  29 #include "sort.h"
  30 #include "mailbox.h"
  31 #include "browser.h"
  32 #ifdef USE_IMAP
  33 #include "imap.h"
  34 #endif
  35
  36 #include <stdlib.h>
  37 #include <dirent.h>
  38 #include <string.h>
  39 #include <ctype.h>
  40 #include <unistd.h>
  41 #include <sys/stat.h>
  42 #include <errno.h>
  43
  44 static struct mapping_t FolderHelp[] = {
  45   { N_("Exit"),  OP_EXIT },
  46   { N_("Chdir"), OP_CHANGE_DIRECTORY },
  47   { N_("Mask"),  OP_ENTER_MASK },
  48   { N_("Help"),  OP_HELP },
  49   { NULL }
  50 };
  51
  52 typedef struct folder_t
  53 {
  54   struct folder_file *ff;
  55   int num;
  56 } FOLDER;
  57
  58 static char LastDir[_POSIX_PATH_MAX] = "";
  59 static char LastDirBackup[_POSIX_PATH_MAX] = "";
  60
  61 /* Frees up the memory allocated for the local-global variables.  */
  62 static void destroy_state (struct browser_state *state)
  63 {
  64   int c;
  65
  66   for (c = 0; c < state->entrylen; c++)
  67   {
  68     FREE (&((state->entry)[c].name));
  69     FREE (&((state->entry)[c].desc));
  70     FREE (&((state->entry)[c].st));
  71   }
  72 #ifdef USE_IMAP
  73   FREE (&state->folder);
  74 #endif
  75   FREE (&state->entry);
  76 }
  77
  78 static int browser_compare_subject (const void *a, const void *b)
  79 {
  80   struct folder_file *pa = (struct folder_file *) a;
  81   struct folder_file *pb = (struct folder_file *) b;
  82
  83   int r = mutt_strcoll (pa->name, pb->name);
  84
  85   return ((BrowserSort & SORT_REVERSE) ? -r : r);
  86 }
  87
  88 static int browser_compare_date (const void *a, const void *b)
  89 {
  90   struct folder_file *pa = (struct folder_file *) a;
  91   struct folder_file *pb = (struct folder_file *) b;
  92
  93   int r = pa->mtime - pb->mtime;
  94
  95   return ((BrowserSort & SORT_REVERSE) ? -r : r);
  96 }
  97
  98 static int browser_compare_size (const void *a, const void *b)
  99 {
 100   struct folder_file *pa = (struct folder_file *) a;
 101   struct folder_file *pb = (struct folder_file *) b;
 102
 103   int r = pa->size - pb->size;
 104
 105   return ((BrowserSort & SORT_REVERSE) ? -r : r);
 106 }
 107
 108 static void browser_sort (struct browser_state *state)
 109 {
 110   int (*f) (const void *, const void *);
 111
 112   switch (BrowserSort & SORT_MASK)
 113   {
 114     case SORT_ORDER:
 115       return;
 116     case SORT_DATE:
 117       f = browser_compare_date;
 118       break;
 119     case SORT_SIZE:
 120       f = browser_compare_size;
 121       break;
 122     case SORT_SUBJECT:
 123     default:
 124       f = browser_compare_subject;
 125       break;
 126   }
 127   qsort (state->entry, state->entrylen, sizeof (struct folder_file), f);
 128 }
 129
 130 static int link_is_dir (const char *folder, const char *path)
 131 {
 132   struct stat st;
 133   char fullpath[_POSIX_PATH_MAX];
 134
 135   mutt_concat_path (fullpath, folder, path, sizeof (fullpath));
 136
 137   if (stat (fullpath, &st) == 0)
 138     return (S_ISDIR (st.st_mode));
 139   else
 140     return 0;
 141 }
 142
 143 static const char *
 144 folder_format_str (char *dest, size_t destlen, size_t col, char op, const char *src,
 145                    const char *fmt, const char *ifstring, const char *elsestring,
 146                    unsigned long data, format_flag flags)
 147 {
 148   char fn[SHORT_STRING], tmp[SHORT_STRING], permission[11];
 149   char date[16], *t_fmt;
 150   time_t tnow;
 151   FOLDER *folder = (FOLDER *) data;
 152   struct passwd *pw;
 153   struct group *gr;
 154   int optional = (flags & M_FORMAT_OPTIONAL);
 155
 156   switch (op)
 157   {
 158     case 'C':
 159       snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
 160       snprintf (dest, destlen, tmp, folder->num + 1);
 161       break;
 162
 163     case 'd':
 164       if (folder->ff->st != NULL)
 165       {
 166         tnow = time (NULL);
 167         t_fmt = tnow - folder->ff->st->st_mtime < 31536000 ? "%b %d %H:%M" : "%b %d  %Y";
 168         strftime (date, sizeof (date), t_fmt, localtime (&folder->ff->st->st_mtime));
 169         mutt_format_s (dest, destlen, fmt, date);
 170       }
 171       else
 172         mutt_format_s (dest, destlen, fmt, "");
 173       break;
 174
 175     case 'f':
 176     {
 177       char *s;
 178 #ifdef USE_IMAP
 179       if (folder->ff->imap)
 180         s = NONULL (folder->ff->desc);
 181       else
 182 #endif
 183         s = NONULL (folder->ff->name);
 184
 185       snprintf (fn, sizeof (fn), "%s%s", s,
 186                 folder->ff->st ? (S_ISLNK (folder->ff->st->st_mode) ? "@" :
 187                                   (S_ISDIR (folder->ff->st->st_mode) ? "/" :
 188                                    ((folder->ff->st->st_mode & S_IXUSR) != 0 ? "*" : ""))) : "");
 189
 190       mutt_format_s (dest, destlen, fmt, fn);
 191       break;
 192     }
 193     case 'F':
 194       if (folder->ff->st != NULL)
 195       {
 196         snprintf (permission, sizeof (permission), "%c%c%c%c%c%c%c%c%c%c",
 197                   S_ISDIR(folder->ff->st->st_mode) ? 'd' : (S_ISLNK(folder->ff->st->st_mode) ? 'l' : '-'),
 198                   (folder->ff->st->st_mode & S_IRUSR) != 0 ? 'r': '-',
 199                   (folder->ff->st->st_mode & S_IWUSR) != 0 ? 'w' : '-',
 200                   (folder->ff->st->st_mode & S_ISUID) != 0 ? 's' : (folder->ff->st->st_mode & S_IXUSR) != 0 ? 'x': '-',
 201                   (folder->ff->st->st_mode & S_IRGRP) != 0 ? 'r' : '-',
 202                   (folder->ff->st->st_mode & S_IWGRP) != 0 ? 'w' : '-',
 203                   (folder->ff->st->st_mode & S_ISGID) != 0 ? 's' : (folder->ff->st->st_mode & S_IXGRP) != 0 ? 'x': '-',
 204                   (folder->ff->st->st_mode & S_IROTH) != 0 ? 'r' : '-',
 205                   (folder->ff->st->st_mode & S_IWOTH) != 0 ? 'w' : '-',
 206                   (folder->ff->st->st_mode & S_ISVTX) != 0 ? 't' : (folder->ff->st->st_mode & S_IXOTH) != 0 ? 'x': '-');
 207         mutt_format_s (dest, destlen, fmt, permission);
 208       }
 209 #ifdef USE_IMAP
 210       else if (folder->ff->imap)
 211       {
 212         /* mark folders with subfolders AND mail */
 213         snprintf (permission, sizeof (permission), "IMAP %c",
 214                   (folder->ff->inferiors && folder->ff->selectable) ? '+' : ' ');
 215         mutt_format_s (dest, destlen, fmt, permission);
 216       }
 217 #endif
 218       else
 219         mutt_format_s (dest, destlen, fmt, "");
 220       break;
 221
 222     case 'g':
 223       if (folder->ff->st != NULL)
 224       {
 225         if ((gr = getgrgid (folder->ff->st->st_gid)))
 226           mutt_format_s (dest, destlen, fmt, gr->gr_name);
 227         else
 228         {
 229           snprintf (tmp, sizeof (tmp), "%%%sld", fmt);
 230           snprintf (dest, destlen, tmp, folder->ff->st->st_gid);
 231         }
 232       }
 233       else
 234         mutt_format_s (dest, destlen, fmt, "");
 235       break;
 236
 237     case 'l':
 238       if (folder->ff->st != NULL)
 239       {
 240         snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
 241         snprintf (dest, destlen, tmp, folder->ff->st->st_nlink);
 242       }
 243       else
 244         mutt_format_s (dest, destlen, fmt, "");
 245       break;
 246
 247     case 'N':
 248 #ifdef USE_IMAP
 249       if (mx_is_imap (folder->ff->desc))
 250       {
 251         if (!optional)
 252         {
 253           snprintf (tmp, sizeof (tmp), "%%%sd", fmt);
 254           snprintf (dest, destlen, tmp, folder->ff->new);
 255         }
 256         else if (!folder->ff->new)
 257           optional = 0;
 258         break;
 259       }
 260 #endif
 261       snprintf (tmp, sizeof (tmp), "%%%sc", fmt);
 262       snprintf (dest, destlen, tmp, folder->ff->new ? 'N' : ' ');
 263       break;
 264
 265     case 's':
 266       if (folder->ff->st != NULL)
 267       {
 268         mutt_pretty_size(fn, sizeof(fn), folder->ff->st->st_size);
 269         snprintf (tmp, sizeof (tmp), "%%%ss", fmt);
 270         snprintf (dest, destlen, tmp, fn);
 271       }
 272       else
 273         mutt_format_s (dest, destlen, fmt, "");
 274       break;
 275
 276     case 't':
 277       snprintf (tmp, sizeof (tmp), "%%%sc", fmt);
 278       snprintf (dest, destlen, tmp, folder->ff->tagged ? '*' : ' ');
 279       break;
 280
 281     case 'u':
 282       if (folder->ff->st != NULL)
 283       {
 284         if ((pw = getpwuid (folder->ff->st->st_uid)))
 285           mutt_format_s (dest, destlen, fmt, pw->pw_name);
 286         else
 287         {
 288           snprintf (tmp, sizeof (tmp), "%%%sld", fmt);
 289           snprintf (dest, destlen, tmp, folder->ff->st->st_uid);
 290         }
 291       }
 292       else
 293         mutt_format_s (dest, destlen, fmt, "");
 294       break;
 295
 296     default:
 297       snprintf (tmp, sizeof (tmp), "%%%sc", fmt);
 298       snprintf (dest, destlen, tmp, op);
 299       break;
 300   }
 301
 302   if (optional)
 303     mutt_FormatString (dest, destlen, col, ifstring, folder_format_str, data, 0);
 304   else if (flags & M_FORMAT_OPTIONAL)
 305     mutt_FormatString (dest, destlen, col, elsestring, folder_format_str, data, 0);
 306
 307   return (src);
 308 }
 309
 310 static void add_folder (MUTTMENU *m, struct browser_state *state,
 311                         const char *name, const struct stat *s, int new)
 312 {
 313   if (state->entrylen == state->entrymax)
 314   {
 315     /* need to allocate more space */
 316     safe_realloc (&state->entry,
 317                   sizeof (struct folder_file) * (state->entrymax += 256));
 318     memset (&state->entry[state->entrylen], 0,
 319             sizeof (struct folder_file) * 256);
 320     if (m)
 321       m->data = state->entry;
 322   }
 323
 324   if (s != NULL)
 325   {
 326     (state->entry)[state->entrylen].mode = s->st_mode;
 327     (state->entry)[state->entrylen].mtime = s->st_mtime;
 328     (state->entry)[state->entrylen].size = s->st_size;
 329
 330     (state->entry)[state->entrylen].st = safe_malloc (sizeof (struct stat));
 331     memcpy ((state->entry)[state->entrylen].st, s, sizeof (struct stat));
 332   }
 333
 334   (state->entry)[state->entrylen].new = new;
 335   (state->entry)[state->entrylen].name = safe_strdup (name);
 336   (state->entry)[state->entrylen].desc = safe_strdup (name);
 337 #ifdef USE_IMAP
 338   (state->entry)[state->entrylen].imap = 0;
 339 #endif
 340   (state->entrylen)++;
 341 }
 342
 343 static void init_state (struct browser_state *state, MUTTMENU *menu)
 344 {
 345   state->entrylen = 0;
 346   state->entrymax = 256;
 347   state->entry = (struct folder_file *) safe_calloc (state->entrymax, sizeof (struct folder_file));
 348 #ifdef USE_IMAP
 349   state->imap_browse = 0;
 350 #endif
 351   if (menu)
 352     menu->data = state->entry;
 353 }
 354
 355 static int examine_directory (MUTTMENU *menu, struct browser_state *state,
 356                               char *d, const char *prefix)
 357 {
 358   struct stat s;
 359   DIR *dp;
 360   struct dirent *de;
 361   char buffer[_POSIX_PATH_MAX + SHORT_STRING];
 362   BUFFY *tmp;
 363
 364   while (stat (d, &s) == -1)
 365   {
 366     if (errno == ENOENT)
 367     {
 368       /* The last used directory is deleted, try to use the parent dir. */
 369       char *c = strrchr (d, '/');
 370
 371       if (c && (c > d))
 372       {
 373         *c = 0;
 374         continue;
 375       }
 376     }
 377     mutt_perror (d);
 378     return (-1);
 379   }
 380
 381   if (!S_ISDIR (s.st_mode))
 382   {
 383     mutt_error (_("%s is not a directory."), d);
 384     return (-1);
 385   }
 386
 387   mutt_buffy_check (0);
 388
 389   if ((dp = opendir (d)) == NULL)
 390   {
 391     mutt_perror (d);
 392     return (-1);
 393   }
 394
 395   init_state (state, menu);
 396
 397   while ((de = readdir (dp)) != NULL)
 398   {
 399     if (mutt_strcmp (de->d_name, ".") == 0)
 400       continue;    /* we don't need . */
 401
 402     if (prefix && *prefix && mutt_strncmp (prefix, de->d_name, mutt_strlen (prefix)) != 0)
 403       continue;
 404     if (!((regexec (Mask.rx, de->d_name, 0, NULL, 0) == 0) ^ Mask.not))
 405       continue;
 406
 407     mutt_concat_path (buffer, d, de->d_name, sizeof (buffer));
 408     if (lstat (buffer, &s) == -1)
 409       continue;
 410
 411     if ((! S_ISREG (s.st_mode)) && (! S_ISDIR (s.st_mode)) &&
 412         (! S_ISLNK (s.st_mode)))
 413       continue;
 414
 415     tmp = Incoming;
 416     while (tmp && mutt_strcmp (buffer, tmp->path))
 417       tmp = tmp->next;
 418     add_folder (menu, state, de->d_name, &s, (tmp) ? tmp->new : 0);
 419   }
 420   closedir (dp);
 421   browser_sort (state);
 422   return 0;
 423 }
 424
 425 static int examine_mailboxes (MUTTMENU *menu, struct browser_state *state)
 426 {
 427   struct stat s;
 428   char buffer[LONG_STRING];
 429   BUFFY *tmp = Incoming;
 430 #ifdef USE_IMAP
 431   struct mailbox_state mbox;
 432 #endif
 433
 434   if (!Incoming)
 435     return (-1);
 436   mutt_buffy_check (0);
 437
 438   init_state (state, menu);
 439
 440   do
 441   {
 442 #ifdef USE_IMAP
 443     if (mx_is_imap (tmp->path))
 444     {
 445       imap_mailbox_state (tmp->path, &mbox);
 446       add_folder (menu, state, tmp->path, NULL, mbox.new);
 447       continue;
 448     }
 449 #endif
 450 #ifdef USE_POP
 451     if (mx_is_pop (tmp->path))
 452     {
 453       add_folder (menu, state, tmp->path, NULL, tmp->new);
 454       continue;
 455     }
 456 #endif
 457     if (lstat (tmp->path, &s) == -1)
 458       continue;
 459
 460     if ((! S_ISREG (s.st_mode)) && (! S_ISDIR (s.st_mode)) &&
 461         (! S_ISLNK (s.st_mode)))
 462       continue;
 463
 464     strfcpy (buffer, NONULL(tmp->path), sizeof (buffer));
 465     mutt_pretty_mailbox (buffer, sizeof (buffer));
 466
 467     add_folder (menu, state, buffer, &s, tmp->new);
 468   }
 469   while ((tmp = tmp->next));
 470   browser_sort (state);
 471   return 0;
 472 }
 473
 474 static int select_file_search (MUTTMENU *menu, regex_t *re, int n)
 475 {
 476   return (regexec (re, ((struct folder_file *) menu->data)[n].name, 0, NULL, 0));
 477 }
 478
 479 static void folder_entry (char *s, size_t slen, MUTTMENU *menu, int num)
 480 {
 481   FOLDER folder;
 482
 483   folder.ff = &((struct folder_file *) menu->data)[num];
 484   folder.num = num;
 485
 486   mutt_FormatString (s, slen, 0, NONULL(FolderFormat), folder_format_str,
 487       (unsigned long) &folder, M_FORMAT_ARROWCURSOR);
 488 }
 489
 490 static void init_menu (struct browser_state *state, MUTTMENU *menu, char *title,
 491                        size_t titlelen, int buffy)
 492 {
 493   char path[_POSIX_PATH_MAX];
 494
 495   menu->max = state->entrylen;
 496
 497   if(menu->current >= menu->max)
 498     menu->current = menu->max - 1;
 499   if (menu->current < 0)
 500     menu->current = 0;
 501   if (menu->top > menu->current)
 502     menu->top = 0;
 503
 504   menu->tagged = 0;
 505
 506   if (buffy)
 507     snprintf (title, titlelen, _("Mailboxes [%d]"), mutt_buffy_check (0));
 508   else
 509   {
 510     strfcpy (path, LastDir, sizeof (path));
 511     mutt_pretty_mailbox (path, sizeof (path));
 512 #ifdef USE_IMAP
 513   if (state->imap_browse && option (OPTIMAPLSUB))
 514     snprintf (title, titlelen, _("Subscribed [%s], File mask: %s"),
 515               path, NONULL (Mask.pattern));
 516   else
 517 #endif
 518     snprintf (title, titlelen, _("Directory [%s], File mask: %s"),
 519               path, NONULL(Mask.pattern));
 520   }
 521   menu->redraw = REDRAW_FULL;
 522 }
 523
 524 static int file_tag (MUTTMENU *menu, int n, int m)
 525 {
 526   struct folder_file *ff = &(((struct folder_file *)menu->data)[n]);
 527   int ot;
 528   if (S_ISDIR (ff->mode) || (S_ISLNK (ff->mode) && link_is_dir (LastDir, ff->name)))
 529   {
 530     mutt_error _("Can't attach a directory!");
 531     return 0;
 532   }
 533
 534   ot = ff->tagged;
 535   ff->tagged = (m >= 0 ? m : !ff->tagged);
 536
 537   return ff->tagged - ot;
 538 }
 539
 540 void _mutt_select_file (char *f, size_t flen, int flags, char ***files, int *numfiles)
 541 {
 542   char buf[_POSIX_PATH_MAX];
 543   char prefix[_POSIX_PATH_MAX] = "";
 544   char helpstr[LONG_STRING];
 545   char title[STRING];
 546   struct browser_state state;
 547   MUTTMENU *menu;
 548   struct stat st;
 549   int i, killPrefix = 0;
 550   int multiple = (flags & M_SEL_MULTI)  ? 1 : 0;
 551   int folder   = (flags & M_SEL_FOLDER) ? 1 : 0;
 552   int buffy    = (flags & M_SEL_BUFFY)  ? 1 : 0;
 553
 554   buffy = buffy && folder;
 555
 556   memset (&state, 0, sizeof (struct browser_state));
 557
 558   if (!folder)
 559     strfcpy (LastDirBackup, LastDir, sizeof (LastDirBackup));
 560
 561   if (*f)
 562   {
 563     mutt_expand_path (f, flen);
 564 #ifdef USE_IMAP
 565     if (mx_is_imap (f))
 566     {
 567       init_state (&state, NULL);
 568       state.imap_browse = 1;
 569       if (!imap_browse (f, &state))
 570         strfcpy (LastDir, state.folder, sizeof (LastDir));
 571     }
 572     else
 573     {
 574 #endif
 575     for (i = mutt_strlen (f) - 1; i > 0 && f[i] != '/' ; i--);
 576     if (i > 0)
 577     {
 578       if (f[0] == '/')
 579       {
 580         if (i > sizeof (LastDir) - 1) i = sizeof (LastDir) - 1;
 581         strncpy (LastDir, f, i);
 582         LastDir[i] = 0;
 583       }
 584       else
 585       {
 586         getcwd (LastDir, sizeof (LastDir));
 587         safe_strcat (LastDir, sizeof (LastDir), "/");
 588         safe_strncat (LastDir, sizeof (LastDir), f, i);
 589       }
 590     }
 591     else
 592     {
 593       if (f[0] == '/')
 594         strcpy (LastDir, "/");          /* __STRCPY_CHECKED__ */
 595       else
 596         getcwd (LastDir, sizeof (LastDir));
 597     }
 598
 599     if (i <= 0 && f[0] != '/')
 600       strfcpy (prefix, f, sizeof (prefix));
 601     else
 602       strfcpy (prefix, f + i + 1, sizeof (prefix));
 603     killPrefix = 1;
 604 #ifdef USE_IMAP
 605     }
 606 #endif
 607   }
 608   else
 609   {
 610     if (!folder)
 611       getcwd (LastDir, sizeof (LastDir));
 612     else if (!LastDir[0])
 613       strfcpy (LastDir, NONULL(Maildir), sizeof (LastDir));
 614
 615 #ifdef USE_IMAP
 616     if (!buffy && mx_is_imap (LastDir))
 617     {
 618       init_state (&state, NULL);
 619       state.imap_browse = 1;
 620       imap_browse (LastDir, &state);
 621       browser_sort (&state);
 622     }
 623     else
 624 #endif
 625     {
 626       i = mutt_strlen (LastDir);
 627       while (i && LastDir[--i] == '/')
 628         LastDir[i] = '\0';
 629       if (!LastDir[0])
 630         getcwd (LastDir, sizeof (LastDir));
 631     }
 632   }
 633
 634   *f = 0;
 635
 636   if (buffy)
 637   {
 638     if (examine_mailboxes (NULL, &state) == -1)
 639       goto bail;
 640   }
 641   else
 642 #ifdef USE_IMAP
 643   if (!state.imap_browse)
 644 #endif
 645   if (examine_directory (NULL, &state, LastDir, prefix) == -1)
 646     goto bail;
 647
 648   menu = mutt_new_menu (MENU_FOLDER);
 649   menu->make_entry = folder_entry;
 650   menu->search = select_file_search;
 651   menu->title = title;
 652   menu->data = state.entry;
 653   if (multiple)
 654     menu->tag = file_tag;
 655
 656   menu->help = mutt_compile_help (helpstr, sizeof (helpstr), MENU_FOLDER,
 657     FolderHelp);
 658
 659   init_menu (&state, menu, title, sizeof (title), buffy);
 660
 661   FOREVER
 662   {
 663     switch (i = mutt_menuLoop (menu))
 664     {
 665       case OP_GENERIC_SELECT_ENTRY:
 666
 667         if (!state.entrylen)
 668         {
 669           mutt_error _("No files match the file mask");
 670           break;
 671         }
 672
 673         if (S_ISDIR (state.entry[menu->current].mode) ||
 674             (S_ISLNK (state.entry[menu->current].mode) &&
 675             link_is_dir (LastDir, state.entry[menu->current].name))
 676 #ifdef USE_IMAP
 677             || state.entry[menu->current].inferiors
 678 #endif
 679             )
 680         {
 681           /* make sure this isn't a MH or maildir mailbox */
 682           if (buffy)
 683           {
 684             strfcpy (buf, state.entry[menu->current].name, sizeof (buf));
 685             mutt_expand_path (buf, sizeof (buf));
 686           }
 687 #ifdef USE_IMAP
 688           else if (state.imap_browse)
 689           {
 690             strfcpy (buf, state.entry[menu->current].name, sizeof (buf));
 691           }
 692 #endif
 693           else
 694             mutt_concat_path (buf, LastDir, state.entry[menu->current].name, sizeof (buf));
 695
 696           if ((mx_get_magic (buf) <= 0)
 697 #ifdef USE_IMAP
 698             || state.entry[menu->current].inferiors
 699 #endif
 700             )
 701           {
 702             char OldLastDir[_POSIX_PATH_MAX];
 703
 704             /* save the old directory */
 705             strfcpy (OldLastDir, LastDir, sizeof (OldLastDir));
 706
 707             if (mutt_strcmp (state.entry[menu->current].name, "..") == 0)
 708             {
 709               if (mutt_strcmp ("..", LastDir + mutt_strlen (LastDir) - 2) == 0)
 710                 strcat (LastDir, "/..");        /* __STRCAT_CHECKED__ */
 711               else
 712               {
 713                 char *p = strrchr (LastDir + 1, '/');
 714
 715                 if (p)
 716                   *p = 0;
 717                 else
 718                 {
 719                   if (LastDir[0] == '/')
 720                     LastDir[1] = 0;
 721                   else
 722                     strcat (LastDir, "/..");    /* __STRCAT_CHECKED__ */
 723                 }
 724               }
 725             }
 726             else if (buffy)
 727             {
 728               strfcpy (LastDir, state.entry[menu->current].name, sizeof (LastDir));
 729               mutt_expand_path (LastDir, sizeof (LastDir));
 730             }
 731 #ifdef USE_IMAP
 732             else if (state.imap_browse)
 733             {
 734               int n;
 735               ciss_url_t url;
 736
 737               strfcpy (LastDir, state.entry[menu->current].name,
 738                 sizeof (LastDir));
 739               /* tack on delimiter here */
 740               n = strlen (LastDir)+1;
 741
 742               /* special case "" needs no delimiter */
 743               url_parse_ciss (&url, state.entry[menu->current].name);
 744               if (url.path &&
 745                   (state.entry[menu->current].delim != '\0') &&
 746                   (n < sizeof (LastDir)))
 747               {
 748                 LastDir[n] = '\0';
 749                 LastDir[n-1] = state.entry[menu->current].delim;
 750               }
 751             }
 752 #endif
 753             else
 754             {
 755               char tmp[_POSIX_PATH_MAX];
 756               mutt_concat_path (tmp, LastDir, state.entry[menu->current].name, sizeof (tmp));
 757               strfcpy (LastDir, tmp, sizeof (LastDir));
 758             }
 759
 760             destroy_state (&state);
 761             if (killPrefix)
 762             {
 763               prefix[0] = 0;
 764               killPrefix = 0;
 765             }
 766             buffy = 0;
 767 #ifdef USE_IMAP
 768             if (state.imap_browse)
 769             {
 770               init_state (&state, NULL);
 771               state.imap_browse = 1;
 772               imap_browse (LastDir, &state);
 773               browser_sort (&state);
 774               menu->data = state.entry;
 775             }
 776             else
 777 #endif
 778             if (examine_directory (menu, &state, LastDir, prefix) == -1)
 779             {
 780               /* try to restore the old values */
 781               strfcpy (LastDir, OldLastDir, sizeof (LastDir));
 782               if (examine_directory (menu, &state, LastDir, prefix) == -1)
 783               {
 784                 strfcpy (LastDir, NONULL(Homedir), sizeof (LastDir));
 785                 goto bail;
 786               }
 787             }
 788             menu->current = 0;
 789             menu->top = 0;
 790             init_menu (&state, menu, title, sizeof (title), buffy);
 791             break;
 792           }
 793         }
 794
 795         if (buffy)
 796         {
 797           strfcpy (f, state.entry[menu->current].name, flen);
 798           mutt_expand_path (f, flen);
 799         }
 800 #ifdef USE_IMAP
 801         else if (state.imap_browse)
 802           strfcpy (f, state.entry[menu->current].name, flen);
 803 #endif
 804         else
 805           mutt_concat_path (f, LastDir, state.entry[menu->current].name, flen);
 806
 807         /* Fall through to OP_EXIT */
 808
 809       case OP_EXIT:
 810
 811         if (multiple)
 812         {
 813           char **tfiles;
 814           int i, j;
 815
 816           if (menu->tagged)
 817           {
 818             *numfiles = menu->tagged;
 819             tfiles = safe_calloc (*numfiles, sizeof (char *));
 820             for (i = 0, j = 0; i < state.entrylen; i++)
 821             {
 822               struct folder_file ff = state.entry[i];
 823               char full[_POSIX_PATH_MAX];
 824               if (ff.tagged)
 825               {
 826                 mutt_concat_path (full, LastDir, ff.name, sizeof (full));
 827                 mutt_expand_path (full, sizeof (full));
 828                 tfiles[j++] = safe_strdup (full);
 829               }
 830             }
 831             *files = tfiles;
 832           }
 833           else if (f[0]) /* no tagged entries. return selected entry */
 834           {
 835             *numfiles = 1;
 836             tfiles = safe_calloc (*numfiles, sizeof (char *));
 837             mutt_expand_path (f, flen);
 838             tfiles[0] = safe_strdup (f);
 839             *files = tfiles;
 840           }
 841         }
 842
 843         destroy_state (&state);
 844         mutt_menuDestroy (&menu);
 845         goto bail;
 846
 847       case OP_BROWSER_TELL:
 848         if(state.entrylen)
 849           mutt_message("%s", state.entry[menu->current].name);
 850         break;
 851
 852 #ifdef USE_IMAP
 853       case OP_BROWSER_SUBSCRIBE:
 854         imap_subscribe (state.entry[menu->current].name, 1);
 855         break;
 856
 857       case OP_BROWSER_UNSUBSCRIBE:
 858         imap_subscribe (state.entry[menu->current].name, 0);
 859         break;
 860
 861       case OP_BROWSER_TOGGLE_LSUB:
 862         if (option (OPTIMAPLSUB))
 863           unset_option (OPTIMAPLSUB);
 864         else
 865           set_option (OPTIMAPLSUB);
 866
 867         mutt_ungetch (0, OP_CHECK_NEW);
 868         break;
 869
 870       case OP_CREATE_MAILBOX:
 871         if (!state.imap_browse)
 872         {
 873           mutt_error (_("Create is only supported for IMAP mailboxes"));
 874           break;
 875         }
 876
 877         if (!imap_mailbox_create (LastDir))
 878         {
 879           /* TODO: find a way to detect if the new folder would appear in
 880            *   this window, and insert it without starting over. */
 881           destroy_state (&state);
 882           init_state (&state, NULL);
 883           state.imap_browse = 1;
 884           imap_browse (LastDir, &state);
 885           browser_sort (&state);
 886           menu->data = state.entry;
 887           menu->current = 0;
 888           menu->top = 0;
 889           init_menu (&state, menu, title, sizeof (title), buffy);
 890           MAYBE_REDRAW (menu->redraw);
 891         }
 892         /* else leave error on screen */
 893         break;
 894
 895       case OP_RENAME_MAILBOX:
 896         if (!state.entry[menu->current].imap)
 897           mutt_error (_("Rename is only supported for IMAP mailboxes"));
 898         else
 899         {
 900           int nentry = menu->current;
 901
 902           if (imap_mailbox_rename (state.entry[nentry].name) >= 0)
 903           {
 904             destroy_state (&state);
 905             init_state (&state, NULL);
 906             state.imap_browse = 1;
 907             imap_browse (LastDir, &state);
 908             browser_sort (&state);
 909             menu->data = state.entry;
 910             menu->current = 0;
 911             menu->top = 0;
 912             init_menu (&state, menu, title, sizeof (title), buffy);
 913             MAYBE_REDRAW (menu->redraw);
 914           }
 915         }
 916         break;
 917
 918     case OP_DELETE_MAILBOX:
 919         if (!state.entry[menu->current].imap)
 920           mutt_error (_("Delete is only supported for IMAP mailboxes"));
 921         else
 922         {
 923           char msg[SHORT_STRING];
 924           IMAP_MBOX mx;
 925           int nentry = menu->current;
 926
 927           imap_parse_path (state.entry[nentry].name, &mx);
 928           if (!mx.mbox)
 929           {
 930             mutt_error _("Cannot delete root folder");
 931             break;
 932           }
 933           snprintf (msg, sizeof (msg), _("Really delete mailbox \"%s\"?"),
 934             mx.mbox);
 935           if (mutt_yesorno (msg, M_NO) == M_YES)
 936           {
 937             if (!imap_delete_mailbox (Context, mx))
 938             {
 939               /* free the mailbox from the browser */
 940               FREE (&((state.entry)[nentry].name));
 941               FREE (&((state.entry)[nentry].desc));
 942               /* and move all other entries up */
 943               if (nentry+1 < state.entrylen)
 944                 memmove (state.entry + nentry, state.entry + nentry + 1,
 945                   sizeof (struct folder_file) * (state.entrylen - (nentry+1)));
 946               state.entrylen--;
 947               mutt_message _("Mailbox deleted.");
 948               init_menu (&state, menu, title, sizeof (title), buffy);
 949               MAYBE_REDRAW (menu->redraw);
 950             }
 951           }
 952           else
 953             mutt_message _("Mailbox not deleted.");
 954           FREE (&mx.mbox);
 955         }
 956         break;
 957 #endif
 958
 959       case OP_CHANGE_DIRECTORY:
 960
 961         strfcpy (buf, LastDir, sizeof (buf));
 962 #ifdef USE_IMAP
 963         if (!state.imap_browse)
 964 #endif
 965         {
 966           /* add '/' at the end of the directory name if not already there */
 967           int len=mutt_strlen(LastDir);
 968           if (len && LastDir[len-1] != '/' && sizeof (buf) > len)
 969             buf[len]='/';
 970         }
 971
 972         if (mutt_get_field (_("Chdir to: "), buf, sizeof (buf), M_FILE) == 0 &&
 973             buf[0])
 974         {
 975           buffy = 0;
 976           mutt_expand_path (buf, sizeof (buf));
 977 #ifdef USE_IMAP
 978           if (mx_is_imap (buf))
 979           {
 980             strfcpy (LastDir, buf, sizeof (LastDir));
 981             destroy_state (&state);
 982             init_state (&state, NULL);
 983             state.imap_browse = 1;
 984             imap_browse (LastDir, &state);
 985             browser_sort (&state);
 986             menu->data = state.entry;
 987             menu->current = 0;
 988             menu->top = 0;
 989             init_menu (&state, menu, title, sizeof (title), buffy);
 990           }
 991           else
 992 #endif
 993           {
 994             if (*buf != '/')
 995             {
 996               /* in case dir is relative, make it relative to LastDir,
 997                * not current working dir */
 998               char tmp[_POSIX_PATH_MAX];
 999               mutt_concat_path (tmp, LastDir, buf, sizeof (tmp));
1000               strfcpy (buf, tmp, sizeof (buf));
1001             }
1002             if (stat (buf, &st) == 0)
1003             {
1004               if (S_ISDIR (st.st_mode))
1005               {
1006                 destroy_state (&state);
1007                 if (examine_directory (menu, &state, buf, prefix) == 0)
1008                   strfcpy (LastDir, buf, sizeof (LastDir));
1009                 else
1010                 {
1011                   mutt_error _("Error scanning directory.");
1012                   if (examine_directory (menu, &state, LastDir, prefix) == -1)
1013                   {
1014                     mutt_menuDestroy (&menu);
1015                     goto bail;
1016                   }
1017                 }
1018                 menu->current = 0;
1019                 menu->top = 0;
1020                 init_menu (&state, menu, title, sizeof (title), buffy);
1021               }
1022               else
1023                 mutt_error (_("%s is not a directory."), buf);
1024             }
1025             else
1026               mutt_perror (buf);
1027           }
1028         }
1029         MAYBE_REDRAW (menu->redraw);
1030         break;
1031
1032       case OP_ENTER_MASK:
1033
1034         strfcpy (buf, NONULL(Mask.pattern), sizeof (buf));
1035         if (mutt_get_field (_("File Mask: "), buf, sizeof (buf), 0) == 0)
1036         {
1037           regex_t *rx = (regex_t *) safe_malloc (sizeof (regex_t));
1038           char *s = buf;
1039           int not = 0, err;
1040
1041           buffy = 0;
1042           /* assume that the user wants to see everything */
1043           if (!buf[0])
1044             strfcpy (buf, ".", sizeof (buf));
1045           SKIPWS (s);
1046           if (*s == '!')
1047           {
1048             s++;
1049             SKIPWS (s);
1050             not = 1;
1051           }
1052
1053           if ((err = REGCOMP (rx, s, REG_NOSUB)) != 0)
1054           {
1055             regerror (err, rx, buf, sizeof (buf));
1056             regfree (rx);
1057             FREE (&rx);
1058             mutt_error ("%s", buf);
1059           }
1060           else
1061           {
1062             mutt_str_replace (&Mask.pattern, buf);
1063             regfree (Mask.rx);
1064             FREE (&Mask.rx);
1065             Mask.rx = rx;
1066             Mask.not = not;
1067
1068             destroy_state (&state);
1069 #ifdef USE_IMAP
1070             if (state.imap_browse)
1071             {
1072               init_state (&state, NULL);
1073               state.imap_browse = 1;
1074               imap_browse (LastDir, &state);
1075               browser_sort (&state);
1076               menu->data = state.entry;
1077               init_menu (&state, menu, title, sizeof (title), buffy);
1078             }
1079             else
1080 #endif
1081             if (examine_directory (menu, &state, LastDir, NULL) == 0)
1082               init_menu (&state, menu, title, sizeof (title), buffy);
1083             else
1084             {
1085               mutt_error _("Error scanning directory.");
1086               mutt_menuDestroy (&menu);
1087               goto bail;
1088             }
1089             killPrefix = 0;
1090             if (!state.entrylen)
1091             {
1092               mutt_error _("No files match the file mask");
1093               break;
1094             }
1095           }
1096         }
1097         MAYBE_REDRAW (menu->redraw);
1098         break;
1099
1100       case OP_SORT:
1101       case OP_SORT_REVERSE:
1102
1103         {
1104           int resort = 1;
1105           int reverse = (i == OP_SORT_REVERSE);
1106
1107           switch (mutt_multi_choice ((reverse) ?
1108               _("Reverse sort by (d)ate, (a)lpha, si(z)e or do(n)'t sort? ") :
1109               _("Sort by (d)ate, (a)lpha, si(z)e or do(n)'t sort? "),
1110               _("dazn")))
1111           {
1112             case -1: /* abort */
1113               resort = 0;
1114               break;
1115
1116             case 1: /* (d)ate */
1117               BrowserSort = SORT_DATE;
1118               break;
1119
1120             case 2: /* (a)lpha */
1121               BrowserSort = SORT_SUBJECT;
1122               break;
1123
1124             case 3: /* si(z)e */
1125               BrowserSort = SORT_SIZE;
1126               break;
1127
1128             case 4: /* do(n)'t sort */
1129               BrowserSort = SORT_ORDER;
1130               resort = 0;
1131               break;
1132           }
1133           if (resort)
1134           {
1135             BrowserSort |= reverse ? SORT_REVERSE : 0;
1136             browser_sort (&state);
1137             menu->redraw = REDRAW_FULL;
1138           }
1139           break;
1140         }
1141
1142       case OP_TOGGLE_MAILBOXES:
1143         buffy = 1 - buffy;
1144
1145       case OP_CHECK_NEW:
1146         destroy_state (&state);
1147         prefix[0] = 0;
1148         killPrefix = 0;
1149
1150         if (buffy)
1151         {
1152           if (examine_mailboxes (menu, &state) == -1)
1153             goto bail;
1154         }
1155 #ifdef USE_IMAP
1156         else if (mx_is_imap (LastDir))
1157         {
1158           init_state (&state, NULL);
1159           state.imap_browse = 1;
1160           imap_browse (LastDir, &state);
1161           browser_sort (&state);
1162           menu->data = state.entry;
1163         }
1164 #endif
1165         else if (examine_directory (menu, &state, LastDir, prefix) == -1)
1166           goto bail;
1167         init_menu (&state, menu, title, sizeof (title), buffy);
1168         break;
1169
1170       case OP_BUFFY_LIST:
1171         mutt_buffy_list ();
1172         break;
1173
1174       case OP_BROWSER_NEW_FILE:
1175
1176         snprintf (buf, sizeof (buf), "%s/", LastDir);
1177         if (mutt_get_field (_("New file name: "), buf, sizeof (buf), M_FILE) == 0)
1178         {
1179           strfcpy (f, buf, flen);
1180           destroy_state (&state);
1181           mutt_menuDestroy (&menu);
1182           goto bail;
1183         }
1184         MAYBE_REDRAW (menu->redraw);
1185         break;
1186
1187       case OP_BROWSER_VIEW_FILE:
1188         if (!state.entrylen)
1189         {
1190           mutt_error _("No files match the file mask");
1191           break;
1192         }
1193
1194 #ifdef USE_IMAP
1195         if (state.entry[menu->current].selectable)
1196         {
1197           strfcpy (f, state.entry[menu->current].name, flen);
1198           destroy_state (&state);
1199           mutt_menuDestroy (&menu);
1200           goto bail;
1201         }
1202         else
1203 #endif
1204         if (S_ISDIR (state.entry[menu->current].mode) ||
1205             (S_ISLNK (state.entry[menu->current].mode) &&
1206             link_is_dir (LastDir, state.entry[menu->current].name)))
1207         {
1208           mutt_error _("Can't view a directory");
1209           break;
1210         }
1211         else
1212         {
1213           BODY *b;
1214           char buf[_POSIX_PATH_MAX];
1215
1216           mutt_concat_path (buf, LastDir, state.entry[menu->current].name, sizeof (buf));
1217           b = mutt_make_file_attach (buf);
1218           if (b != NULL)
1219           {
1220             mutt_view_attachment (NULL, b, M_REGULAR, NULL, NULL, 0);
1221             mutt_free_body (&b);
1222             menu->redraw = REDRAW_FULL;
1223           }
1224           else
1225             mutt_error _("Error trying to view file");
1226         }
1227     }
1228   }
1229
1230   bail:
1231
1232   if (!folder)
1233     strfcpy (LastDir, LastDirBackup, sizeof (LastDir));
1234
1235 }