Make MAlias public. migrate $signature, so that I can test the new MCore.folder_hook...
[apps/madmutt.git] / 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), Outbox);
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 }