muttlib.c

   1 /*
   2  * Copyright notice from original mutt:
   3  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
   4  * Copyright (C) 1999-2000 Thomas Roessler <roessler@does-not-exist.org>
   5  *
   6  * This file is part of mutt-ng, see http://www.muttng.org/.
   7  * It's licensed under the GNU General Public License,
   8  * please see the file GPL in the top level source directory.
   9  */
  10
  11 #include <lib-lib/lib-lib.h>
  12
  13 #include <grp.h>
  14 #include <pwd.h>
  15
  16 #include <lib-ui/curses.h>
  17 #include <lib-ui/enter.h>
  18 #include <lib-sys/unix.h>
  19 #include <imap/imap.h>
  20
  21 #include "alias.h"
  22 #include "mutt.h"
  23 #include "attach.h"
  24
  25 /* Modified by blong to accept a "suggestion" for file name.  If
  26  * that file exists, then construct one with unique name but
  27  * keep any extension.  This might fail, I guess.
  28  * Renamed to mutt_adv_mktemp so I only have to change where it's
  29  * called, and not all possible cases.
  30  */
  31 void mutt_adv_mktemp (const char* dir, char *s, ssize_t l)
  32 {
  33     int fd;
  34
  35     fd = m_tempfd(s, l, m_strisempty(dir) ? NONULL(MCore.tmpdir) : dir, s);
  36     if (fd < 0) {
  37         *s = '\0';
  38     } else {
  39         close(fd);
  40         unlink(s);
  41     }
  42 }
  43
  44 void mutt_mktemp(char *s)
  45 {
  46     int fd = m_tempfd(s, _POSIX_PATH_MAX, NONULL(MCore.tmpdir), NULL);
  47     if (fd < 0) {
  48         *s = '\0';
  49     } else {
  50         close(fd);
  51         unlink(s);
  52     }
  53 }
  54
  55 ssize_t _mutt_expand_path(char *buf, ssize_t len, const char *s, int rx)
  56 {
  57     char p[_POSIX_PATH_MAX] = "";
  58     char tmp[_POSIX_PATH_MAX];
  59     const char *tail = "";
  60     const address_t *alias;
  61
  62     switch (*s) {
  63       case '~':
  64         if (s[1] == '/' || s[1] == '\0') {
  65             m_strcpy(p, sizeof(p), MCore.homedir);
  66             tail = s + 1;
  67         } else {
  68             struct passwd *pw;
  69             tail = m_strchrnul(s + 1, '/');
  70
  71             m_strncpy(tmp, sizeof(tmp), s + 1, tail - s - 1);
  72
  73             if ((pw = getpwnam(tmp))) {
  74                 m_strcpy(p, sizeof(p), pw->pw_dir);
  75             } else {
  76                 /* user not found! */
  77                 tail = s;
  78             }
  79         }
  80         break;
  81
  82       case '=':
  83       case '+':
  84         /* if folder = imap[s]://host/: don't append slash */
  85         if (imap_is_magic(NONULL(Maildir), NULL) == M_IMAP
  86         &&  Maildir[m_strlen(Maildir) - 1] == '/') {
  87             m_strcpy(p, sizeof(p), Maildir);
  88         } else {
  89             snprintf(p, sizeof(p), "%s/", NONULL(Maildir));
  90         }
  91
  92         tail = s + 1;
  93         break;
  94
  95         /* elm compatibility, @ expands alias to user name */
  96
  97       case '@':
  98         if ((alias = alias_lookup(s + 1))) {
  99             HEADER h;
 100             header_init(&h);
 101             h.env = envelope_new();
 102             h.env->from = h.env->to = (address_t *)alias;
 103             mutt_default_save(p, sizeof (p), &h);
 104             h.env->from = h.env->to = NULL;
 105             header_wipe(&h);
 106
 107             if (*p != '@')
 108                 return _mutt_expand_path(buf, len, p, rx);
 109         }
 110         break;
 111
 112       case '>':
 113         m_strcpy(p, sizeof(p), Inbox);
 114         tail = s + 1;
 115         break;
 116
 117       case '<':
 118         m_strcpy(p, sizeof(p), MAlias.record);
 119         tail = s + 1;
 120         break;
 121
 122       case '!':
 123         if (s[1] == '!') {
 124             m_strcpy(p, sizeof(p), LastFolder);
 125             tail = s + 2;
 126         } else {
 127             m_strcpy(p, sizeof(p), Spoolfile);
 128             tail = s + 1;
 129         }
 130         break;
 131
 132       case '-':
 133         m_strcpy(p, sizeof(p), NONULL(LastFolder));
 134         tail = s + 1;
 135         break;
 136
 137       case '^':
 138         m_strcpy(p, sizeof(p), NONULL(CurrentFolder));
 139         tail = s + 1;
 140         break;
 141
 142       default:
 143         *p = '\0';
 144         tail = s;
 145     }
 146
 147     if (rx) {
 148         char q[_POSIX_PATH_MAX];
 149         rx_sanitize_string(q, sizeof(q), p);
 150         snprintf(tmp, sizeof(tmp), "%s%s", q, tail);
 151     } else {
 152         snprintf(tmp, sizeof(tmp), "%s%s", p, tail);
 153     }
 154
 155     return m_strcpy(buf, len, tmp);
 156 }
 157
 158 /* collapse the pathname using ~ or = when possible */
 159 void mutt_pretty_mailbox (char *s)
 160 {
 161   char *p = s, *q = s;
 162   ssize_t len;
 163   url_scheme_t scheme;
 164
 165   scheme = url_check_scheme (s);
 166
 167   if (scheme == U_IMAP || scheme == U_IMAPS) {
 168     imap_pretty_mailbox (s);
 169     return;
 170   }
 171
 172   /* if s is an url, only collapse path component */
 173   if (scheme != U_UNKNOWN) {
 174     p = strchr (s, ':') + 1;
 175     if (!m_strncmp (p, "//", 2))
 176       q = strchr (p + 2, '/');
 177     if (!q)
 178       q = strchr (p, '\0');
 179     p = q;
 180   }
 181
 182   /* first attempt to collapse the pathname */
 183   while (*p) {
 184     if (*p == '/' && p[1] == '/') {
 185       *q++ = '/';
 186       p += 2;
 187     }
 188     else if (p[0] == '/' && p[1] == '.' && p[2] == '/') {
 189       *q++ = '/';
 190       p += 3;
 191     }
 192     else
 193       *q++ = *p++;
 194   }
 195   *q = 0;
 196
 197   if (m_strncmp(s, Maildir, (len = m_strlen(Maildir))) == 0 &&
 198       s[len] == '/') {
 199     *s++ = '=';
 200     memmove (s, s + len, m_strlen(s + len) + 1);
 201   }
 202   else if (m_strncmp(s, MCore.homedir, (len = m_strlen(MCore.homedir))) == 0
 203            && s[len] == '/') {
 204     *s++ = '~';
 205     memmove (s, s + len - 1, m_strlen(s + len - 1) + 1);
 206   }
 207 }
 208
 209 /* return 0 on success, -1 on abort, 1 on error */
 210 int mutt_check_overwrite (const char *attname, const char *path,
 211                           char *fname, ssize_t flen, int *append,
 212                           char **directory)
 213 {
 214   int rc = 0;
 215   char tmp[_POSIX_PATH_MAX];
 216   struct stat st;
 217
 218   m_strcpy(fname, flen, path);
 219   if (access (fname, F_OK) != 0)
 220     return 0;
 221   if (stat (fname, &st) != 0)
 222     return -1;
 223   if (S_ISDIR (st.st_mode)) {
 224     if (directory) {
 225       switch (mutt_multi_choice
 226               (_("File is a directory, save under it? [(y)es, (n)o, (a)ll]"),
 227                _("yna"))) {
 228       case 3:                  /* all */
 229         m_strreplace(directory, fname);
 230         break;
 231       case 1:                  /* yes */
 232         p_delete(directory);
 233         break;
 234       case -1:                 /* abort */
 235         p_delete(directory);
 236         return -1;
 237       case 2:                  /* no */
 238         p_delete(directory);
 239         return 1;
 240       }
 241     }
 242     else
 243       if ((rc = mutt_yesorno(_("File is a directory, save under it?"),
 244                              M_YES)) != M_YES)
 245       return (rc == M_NO) ? 1 : -1;
 246
 247     if (!attname || !attname[0]) {
 248       tmp[0] = 0;
 249       if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp),
 250                           M_FILE | M_CLEAR) != 0 || !tmp[0])
 251         return (-1);
 252       mutt_concat_path(fname, flen, path, tmp);
 253     }
 254     else
 255       mutt_concat_path(fname, flen, path, mutt_basename(attname));
 256   }
 257
 258   if (*append == 0 && access (fname, F_OK) == 0) {
 259     switch (mutt_multi_choice
 260             (_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"), _("oac")))
 261     {
 262     case -1:                   /* abort */
 263       return -1;
 264     case 3:                    /* cancel */
 265       return 1;
 266
 267     case 2:                    /* append */
 268       *append = M_SAVE_APPEND;
 269       break;
 270     case 1:                    /* overwrite */
 271       *append = M_SAVE_OVERWRITE;
 272       break;
 273     }
 274   }
 275   return 0;
 276 }
 277
 278 void mutt_save_path(char *d, ssize_t dsize, address_t *a)
 279 {
 280     if (a && a->mailbox) {
 281         m_strcpy(d, dsize, a->mailbox);
 282
 283         if (!option(OPTSAVEADDRESS)) {
 284             char *p = strpbrk(d, "%@");
 285             if (p)
 286                 *p = '\0';
 287         }
 288         m_strtolower(d);
 289     } else {
 290         *d = '\0';
 291     }
 292 }
 293
 294 void mutt_safe_path(char *s, ssize_t l, address_t *a)
 295 {
 296     mutt_save_path(s, l, a);
 297
 298     while (*s) {
 299         if (*s == '/' || ISSPACE(*s) || !isprint((unsigned char)*s))
 300             *s = '_';
 301         s++;
 302     }
 303 }
 304
 305 /* returns 0 if OK to proceed, -1 to abort, 1 to retry */
 306 int mutt_save_confirm (const char *s, struct stat *st)
 307 {
 308   char tmp[_POSIX_PATH_MAX];
 309   int ret = 0;
 310   int rc;
 311   int magic = 0;
 312
 313   magic = mx_get_magic (s);
 314
 315   if (magic == M_POP) {
 316     mutt_error _("Can't save message to POP mailbox.");
 317
 318     return 1;
 319   }
 320
 321 #ifdef USE_NNTP
 322   if (magic == M_NNTP) {
 323     mutt_error _("Can't save message to newsserver.");
 324
 325     return 0;
 326   }
 327 #endif
 328
 329   if (magic > 0 && !mx_access (s, W_OK)) {
 330     if (option (OPTCONFIRMAPPEND) &&
 331         (!TrashPath || (m_strcmp(s, TrashPath) != 0))) {
 332       /* if we're appending to the trash, there's no point in asking */
 333       snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s);
 334       if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
 335         ret = 1;
 336       else if (rc == -1)
 337         ret = -1;
 338     }
 339   }
 340
 341   if (stat (s, st) != -1) {
 342     if (magic == -1) {
 343       mutt_error (_("%s is not a mailbox!"), s);
 344       return 1;
 345     }
 346   } else {
 347     if (magic != M_IMAP)
 348     {
 349       st->st_mtime = 0;
 350       st->st_atime = 0;
 351
 352       if (errno == ENOENT) {
 353         if (option (OPTCONFIRMCREATE)) {
 354           snprintf (tmp, sizeof (tmp), _("Create %s?"), s);
 355           if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
 356             ret = 1;
 357           else if (rc == -1)
 358             ret = -1;
 359         }
 360       } else {
 361         mutt_perror (s);
 362         return 1;
 363       }
 364     }
 365   }
 366
 367   CLEARLINE (LINES - 1);
 368   return (ret);
 369 }
 370
 371 void mutt_sleep (short s)
 372 {
 373     sleep(MAX(s, SleepTime));
 374 }
 375
 376 const char *mutt_make_version(void)
 377 {
 378   static char vstring[STRING];
 379   snprintf(vstring, sizeof (vstring), "Madmutt/%s", MUTT_VERSION);
 380   return vstring;
 381 }
 382
 383 /* return 1 if address lists are strictly identical */
 384 static int mutt_cmp_addr (const address_t * a, const address_t * b)
 385 {
 386   while (a && b) {
 387     if (m_strcmp(a->mailbox, b->mailbox) ||
 388         m_strcmp(a->personal, b->personal))
 389       return (0);
 390
 391     a = a->next;
 392     b = b->next;
 393   }
 394   if (a || b)
 395     return (0);
 396
 397   return (1);
 398 }
 399
 400 static int mutt_cmp_list (const string_list_t * a, const string_list_t * b)
 401 {
 402   while (a && b) {
 403     if (m_strcmp(a->data, b->data))
 404       return (0);
 405
 406     a = a->next;
 407     b = b->next;
 408   }
 409   if (a || b)
 410     return (0);
 411
 412   return (1);
 413 }
 414
 415 static int mutt_cmp_env (const ENVELOPE * e1, const ENVELOPE * e2)
 416 {
 417   if (e1 && e2) {
 418     if (m_strcmp(e1->message_id, e2->message_id) ||
 419         m_strcmp(e1->subject, e2->subject) ||
 420         !mutt_cmp_list (e1->references, e2->references) ||
 421         !mutt_cmp_addr (e1->from, e2->from) ||
 422         !mutt_cmp_addr (e1->sender, e2->sender) ||
 423         !mutt_cmp_addr (e1->reply_to, e2->reply_to) ||
 424         !mutt_cmp_addr (e1->to, e2->to) ||
 425         !mutt_cmp_addr (e1->cc, e2->cc) ||
 426         !mutt_cmp_addr (e1->return_path, e2->return_path))
 427       return (0);
 428     else
 429       return (1);
 430   }
 431   else {
 432     if (e1 == NULL && e2 == NULL)
 433       return (1);
 434     else
 435       return (0);
 436   }
 437 }
 438
 439 static int mutt_cmp_body (const BODY * b1, const BODY * b2)
 440 {
 441   if (b1->type != b2->type ||
 442       b1->encoding != b2->encoding ||
 443       m_strcmp(b1->subtype, b2->subtype) ||
 444       m_strcmp(b1->description, b2->description) ||
 445       !parameter_equal(b1->parameter, b2->parameter) ||
 446       b1->length != b2->length)
 447     return (0);
 448   return (1);
 449 }
 450 int mutt_cmp_header (const HEADER * h1, const HEADER * h2) {
 451   if (h1 && h2) {
 452     if (h1->received != h2->received ||
 453         h1->date_sent != h2->date_sent ||
 454         h1->content->length != h2->content->length ||
 455         h1->lines != h2->lines ||
 456         h1->zhours != h2->zhours ||
 457         h1->zminutes != h2->zminutes ||
 458         h1->zoccident != h2->zoccident ||
 459         h1->mime != h2->mime ||
 460         !mutt_cmp_env (h1->env, h2->env) ||
 461         !mutt_cmp_body (h1->content, h2->content))
 462       return (0);
 463     else
 464       return (1);
 465   }
 466   else {
 467     if (h1 == NULL && h2 == NULL)
 468       return (1);
 469     else
 470       return (0);
 471   }
 472 }
 473
 474
 475 int mutt_extract_token(BUFFER *dest, BUFFER *tok, int flags)
 476 {
 477     char ch;
 478     char qc = 0;                  /* quote char */
 479     char *pc;
 480
 481     /* reset the destination pointer to the beginning of the buffer */
 482     dest->dptr = dest->data;
 483
 484     tok->dptr = vskipspaces(tok->dptr);
 485     while ((ch = *tok->dptr)) {
 486         if (!qc) {
 487             if ((ISSPACE(ch) && !(flags & M_TOKEN_SPACE))
 488             || (ch == '#' && !(flags & M_TOKEN_COMMENT))
 489             || (ch == '=' && (flags & M_TOKEN_EQUAL))
 490             || ((flags & M_TOKEN_PATTERN) && strchr("~=!|", ch)))
 491             {
 492                 break;
 493             }
 494         }
 495
 496         tok->dptr++;
 497
 498         if (ch == qc) {
 499             qc = 0;                     /* end of quote */
 500         } else
 501         if (!qc && (ch == '\'' || ch == '"') && !(flags & M_TOKEN_QUOTE)) {
 502             qc = ch;
 503         } else
 504         if (ch == '\\' && qc != '\'') {
 505             if (!*tok->dptr)
 506                 return -1;              /* premature end of token */
 507
 508             switch (ch = *tok->dptr++) {
 509               case 'c':
 510               case 'C':
 511                 if (!*tok->dptr)
 512                     return -1;          /* premature end of token */
 513                 mutt_buffer_addch(dest,
 514                                   (toupper((unsigned char)*tok->dptr) - 'A' + 1) & 0x7f);
 515                 tok->dptr++;
 516                 break;
 517               case 'r':
 518                 mutt_buffer_addch(dest, '\r');
 519                 break;
 520               case 'n':
 521                 mutt_buffer_addch(dest, '\n');
 522                 break;
 523               case 't':
 524                 mutt_buffer_addch(dest, '\t');
 525                 break;
 526               case 'f':
 527                 mutt_buffer_addch(dest, '\f');
 528                 break;
 529               case 'e':
 530                 mutt_buffer_addch(dest, '\033');
 531                 break;
 532               default:
 533                 if (isdigit((unsigned char)ch)
 534                 &&  isdigit((unsigned char)*tok->dptr)
 535                 &&  isdigit((unsigned char)*(tok->dptr + 1)))
 536                 {
 537                     mutt_buffer_addch(dest, (ch << 6) + (*tok->dptr << 3) +
 538                                             *(tok->dptr + 1) - 3504);
 539                     tok->dptr += 2;
 540                 } else {
 541                     mutt_buffer_addch(dest, ch);
 542                 }
 543             }
 544         } else
 545         if (ch == '^' && (flags & M_TOKEN_CONDENSE)) {
 546             if (!*tok->dptr)
 547                 return -1;              /* premature end of token */
 548             ch = *tok->dptr++;
 549             if (ch == '^') {
 550                 mutt_buffer_addch(dest, ch);
 551             } else
 552             if (ch == '[') {
 553                 mutt_buffer_addch(dest, '\033');
 554             } else
 555             if (isalpha((unsigned char)ch)) {
 556                 mutt_buffer_addch(dest, toupper((unsigned char)ch) - 'A' + 1);
 557             } else {
 558                 mutt_buffer_addch(dest, '^');
 559                 mutt_buffer_addch(dest, ch);
 560             }
 561         } else
 562         if (ch == '`' && (!qc || qc == '"')) {
 563             FILE *fp;
 564             pid_t pid;
 565             char *cmd, *ptr;
 566             ssize_t expnlen;
 567             BUFFER expn;
 568             int line = 0;
 569
 570             pc = tok->dptr;
 571             do {
 572                 if ((pc = strpbrk(pc, "\\`"))) {
 573                     /* skip any quoted chars */
 574                     if (*pc == '\\')
 575                         pc += 2;
 576                 }
 577             } while (pc && *pc != '`');
 578             if (!pc) {
 579                 return (-1);
 580             }
 581
 582             cmd = p_dupstr(tok->dptr, pc - tok->dptr);
 583             if ((pid = mutt_create_filter(cmd, NULL, &fp, NULL)) < 0) {
 584                 p_delete(&cmd);
 585                 return -1;
 586             }
 587             p_delete(&cmd);
 588
 589             tok->dptr = pc + 1;
 590
 591             /* read line */
 592             p_clear(&expn, 1);
 593             expn.data = mutt_read_line(NULL, &expn.dsize, fp, &line);
 594             m_fclose(&fp);
 595             mutt_wait_filter(pid);
 596
 597             /* if we got output, make a new string consiting of the shell ouptput
 598                plus whatever else was left on the original line */
 599             /* BUT: If this is inside a quoted string, directly add output to
 600              * the token */
 601             if (expn.data && qc) {
 602                 mutt_buffer_addstr(dest, expn.data);
 603                 p_delete(&expn.data);
 604             } else
 605             if (expn.data) {
 606                 expnlen = m_strlen(expn.data);
 607                 tok->dsize = expnlen + m_strlen(tok->dptr) + 1;
 608                 ptr = xmalloc(tok->dsize);
 609                 memcpy(ptr, expn.data, expnlen);
 610                 m_strcpy(ptr + expnlen, tok->dsize - expnlen, tok->dptr);
 611                 if (tok->destroy)
 612                     p_delete(&tok->data);
 613                 tok->data = ptr;
 614                 tok->dptr = ptr;
 615                 tok->destroy = 1;       /* mark that the caller should destroy this data */
 616                 ptr = NULL;
 617                 p_delete(&expn.data);
 618             }
 619         } else
 620         if (ch == '$' && (!qc || qc == '"')
 621         && (*tok->dptr == '{' || isalpha((unsigned char)*tok->dptr)))
 622         {
 623             char *env = NULL, *var = NULL;
 624
 625             if (*tok->dptr == '{') {
 626                 tok->dptr++;
 627                 if ((pc = strchr (tok->dptr, '}'))) {
 628                     var = p_dupstr(tok->dptr, pc - tok->dptr);
 629                     tok->dptr = pc + 1;
 630                 }
 631             } else {
 632                 for (pc = tok->dptr; isalnum((unsigned char)*pc) || *pc == '_';
 633                      pc++);
 634                 var = p_dupstr(tok->dptr, pc - tok->dptr);
 635                 tok->dptr = pc;
 636             }
 637             if (var) {
 638                 char tmp[STRING];
 639                 if ((env = getenv (var))
 640                 || (mutt_option_value (var, tmp, sizeof (tmp)) && (env = tmp)))
 641                 {
 642                     mutt_buffer_addstr (dest, env);
 643                 }
 644             }
 645             p_delete(&var);
 646         } else {
 647             mutt_buffer_addch(dest, ch);
 648         }
 649     }
 650     mutt_buffer_addch(dest, 0);  /* terminate the string */
 651     tok->dptr = vskipspaces(tok->dptr);
 652     return 0;
 653 }