muttlib.c

   1 /*
   2  * Copyright (C) 1996-2000,2007 Michael R. Elkins <me@mutt.org>
   3  * Copyright (C) 1999-2008 Thomas Roessler <roessler@does-not-exist.org>
   4  *
   5  *     This program is free software; you can redistribute it and/or modify
   6  *     it under the terms of the GNU General Public License as published by
   7  *     the Free Software Foundation; either version 2 of the License, or
   8  *     (at your option) any later version.
   9  *
  10  *     This program is distributed in the hope that it will be useful,
  11  *     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *     GNU General Public License for more details.
  14  *
  15  *     You should have received a copy of the GNU General Public License
  16  *     along with this program; if not, write to the Free Software
  17  *     Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
  18  */
  19
  20 #if HAVE_CONFIG_H
  21 # include "config.h"
  22 #endif
  23
  24 #include "mutt.h"
  25 #include "mutt_curses.h"
  26 #include "mime.h"
  27 #include "mailbox.h"
  28 #include "mx.h"
  29 #include "url.h"
  30
  31 #ifdef USE_IMAP
  32 #include "imap.h"
  33 #endif
  34
  35 #include "mutt_crypt.h"
  36
  37 #include <string.h>
  38 #include <ctype.h>
  39 #include <unistd.h>
  40 #include <stdlib.h>
  41 #include <sys/wait.h>
  42 #include <errno.h>
  43 #include <sys/stat.h>
  44 #include <fcntl.h>
  45 #include <time.h>
  46 #include <sys/types.h>
  47 #include <utime.h>
  48
  49 BODY *mutt_new_body (void)
  50 {
  51   BODY *p = (BODY *) safe_calloc (1, sizeof (BODY));
  52
  53   p->disposition = DISPATTACH;
  54   p->use_disp = 1;
  55   return (p);
  56 }
  57
  58
  59 /* Modified by blong to accept a "suggestion" for file name.  If
  60  * that file exists, then construct one with unique name but
  61  * keep any extension.  This might fail, I guess.
  62  * Renamed to mutt_adv_mktemp so I only have to change where it's
  63  * called, and not all possible cases.
  64  */
  65 void mutt_adv_mktemp (char *s, size_t l)
  66 {
  67   char buf[_POSIX_PATH_MAX];
  68   char tmp[_POSIX_PATH_MAX];
  69   char *period;
  70   size_t sl;
  71   struct stat sb;
  72
  73   strfcpy (buf, NONULL (Tempdir), sizeof (buf));
  74   mutt_expand_path (buf, sizeof (buf));
  75   if (s[0] == '\0')
  76   {
  77     snprintf (s, l, "%s/muttXXXXXX", buf);
  78     mktemp (s);
  79   }
  80   else
  81   {
  82     strfcpy (tmp, s, sizeof (tmp));
  83     mutt_sanitize_filename (tmp, 1);
  84     snprintf (s, l, "%s/%s", buf, tmp);
  85     if (lstat (s, &sb) == -1 && errno == ENOENT)
  86       return;
  87     if ((period = strrchr (tmp, '.')) != NULL)
  88       *period = 0;
  89     snprintf (s, l, "%s/%s.XXXXXX", buf, tmp);
  90     mktemp (s);
  91     if (period != NULL)
  92     {
  93       *period = '.';
  94       sl = mutt_strlen(s);
  95       strfcpy(s + sl, period, l - sl);
  96     }
  97   }
  98 }
  99
 100 /* create a send-mode duplicate from a receive-mode body */
 101
 102 int mutt_copy_body (FILE *fp, BODY **tgt, BODY *src)
 103 {
 104   char tmp[_POSIX_PATH_MAX];
 105   BODY *b;
 106
 107   PARAMETER *par, **ppar;
 108
 109   short use_disp;
 110
 111   if (src->filename)
 112   {
 113     use_disp = 1;
 114     strfcpy (tmp, src->filename, sizeof (tmp));
 115   }
 116   else
 117   {
 118     use_disp = 0;
 119     tmp[0] = '\0';
 120   }
 121
 122   mutt_adv_mktemp (tmp, sizeof (tmp));
 123   if (mutt_save_attachment (fp, src, tmp, 0, NULL) == -1)
 124     return -1;
 125
 126   *tgt = mutt_new_body ();
 127   b = *tgt;
 128
 129   memcpy (b, src, sizeof (BODY));
 130   b->parts = NULL;
 131   b->next  = NULL;
 132
 133   b->filename = safe_strdup (tmp);
 134   b->use_disp = use_disp;
 135   b->unlink = 1;
 136
 137   if (mutt_is_text_part (b))
 138     b->noconv = 1;
 139
 140   b->xtype = safe_strdup (b->xtype);
 141   b->subtype = safe_strdup (b->subtype);
 142   b->form_name = safe_strdup (b->form_name);
 143   b->filename = safe_strdup (b->filename);
 144   b->d_filename = safe_strdup (b->d_filename);
 145   b->description = safe_strdup (b->description);
 146
 147   /*
 148    * we don't seem to need the HEADER structure currently.
 149    * XXX - this may change in the future
 150    */
 151
 152   if (b->hdr) b->hdr = NULL;
 153
 154   /* copy parameters */
 155   for (par = b->parameter, ppar = &b->parameter; par; ppar = &(*ppar)->next, par = par->next)
 156   {
 157     *ppar = mutt_new_parameter ();
 158     (*ppar)->attribute = safe_strdup (par->attribute);
 159     (*ppar)->value = safe_strdup (par->value);
 160   }
 161
 162   mutt_stamp_attachment (b);
 163
 164   return 0;
 165 }
 166
 167
 168
 169 void mutt_free_body (BODY **p)
 170 {
 171   BODY *a = *p, *b;
 172
 173   while (a)
 174   {
 175     b = a;
 176     a = a->next;
 177
 178     if (b->parameter)
 179       mutt_free_parameter (&b->parameter);
 180     if (b->unlink && b->filename)
 181     {
 182       dprint (1, (debugfile, "mutt_free_body: Unlinking %s.\n", b->filename));
 183       unlink (b->filename);
 184     }
 185     else if (b->filename)
 186       dprint (1, (debugfile, "mutt_free_body: Not unlinking %s.\n", b->filename));
 187
 188     FREE (&b->filename);
 189     FREE (&b->content);
 190     FREE (&b->xtype);
 191     FREE (&b->subtype);
 192     FREE (&b->description);
 193     FREE (&b->form_name);
 194
 195     if (b->hdr)
 196     {
 197       /* Don't free twice (b->hdr->content = b->parts) */
 198       b->hdr->content = NULL;
 199       mutt_free_header(&b->hdr);
 200     }
 201
 202     if (b->parts)
 203       mutt_free_body (&b->parts);
 204
 205     FREE (&b);
 206   }
 207
 208   *p = 0;
 209 }
 210
 211 void mutt_free_parameter (PARAMETER **p)
 212 {
 213   PARAMETER *t = *p;
 214   PARAMETER *o;
 215
 216   while (t)
 217   {
 218     FREE (&t->attribute);
 219     FREE (&t->value);
 220     o = t;
 221     t = t->next;
 222     FREE (&o);
 223   }
 224   *p = 0;
 225 }
 226
 227 LIST *mutt_add_list (LIST *head, const char *data)
 228 {
 229   size_t len = mutt_strlen (data);
 230
 231   return mutt_add_list_n (head, data, len ? len + 1 : 0);
 232 }
 233
 234 LIST *mutt_add_list_n (LIST *head, const void *data, size_t len)
 235 {
 236   LIST *tmp;
 237
 238   for (tmp = head; tmp && tmp->next; tmp = tmp->next)
 239     ;
 240   if (tmp)
 241   {
 242     tmp->next = safe_malloc (sizeof (LIST));
 243     tmp = tmp->next;
 244   }
 245   else
 246     head = tmp = safe_malloc (sizeof (LIST));
 247
 248   tmp->data = safe_malloc (len);
 249   if (len)
 250     memcpy (tmp->data, data, len);
 251   tmp->next = NULL;
 252   return head;
 253 }
 254
 255 void mutt_free_list (LIST **list)
 256 {
 257   LIST *p;
 258
 259   if (!list) return;
 260   while (*list)
 261   {
 262     p = *list;
 263     *list = (*list)->next;
 264     FREE (&p->data);
 265     FREE (&p);
 266   }
 267 }
 268
 269 HEADER *mutt_dup_header(HEADER *h)
 270 {
 271   HEADER *hnew;
 272
 273   hnew = mutt_new_header();
 274   memcpy(hnew, h, sizeof (HEADER));
 275   return hnew;
 276 }
 277
 278 void mutt_free_header (HEADER **h)
 279 {
 280   if(!h || !*h) return;
 281   mutt_free_envelope (&(*h)->env);
 282   mutt_free_body (&(*h)->content);
 283   FREE (&(*h)->maildir_flags);
 284   FREE (&(*h)->tree);
 285   FREE (&(*h)->path);
 286 #ifdef MIXMASTER
 287   mutt_free_list (&(*h)->chain);
 288 #endif
 289 #if defined USE_POP || defined USE_IMAP
 290   FREE (&(*h)->data);
 291 #endif
 292   FREE (h);             /* __FREE_CHECKED__ */
 293 }
 294
 295 /* returns true if the header contained in "s" is in list "t" */
 296 int mutt_matches_ignore (const char *s, LIST *t)
 297 {
 298   for (; t; t = t->next)
 299   {
 300     if (!ascii_strncasecmp (s, t->data, mutt_strlen (t->data)) || *t->data == '*')
 301       return 1;
 302   }
 303   return 0;
 304 }
 305
 306 /* prepend the path part of *path to *link */
 307 void mutt_expand_link (char *newpath, const char *path, const char *link)
 308 {
 309   const char *lb = NULL;
 310   size_t len;
 311
 312   /* link is full path */
 313   if (*link == '/')
 314   {
 315     strfcpy (newpath, link, _POSIX_PATH_MAX);
 316     return;
 317   }
 318
 319   if ((lb = strrchr (path, '/')) == NULL)
 320   {
 321     /* no path in link */
 322     strfcpy (newpath, link, _POSIX_PATH_MAX);
 323     return;
 324   }
 325
 326   len = lb - path + 1;
 327   memcpy (newpath, path, len);
 328   strfcpy (newpath + len, link, _POSIX_PATH_MAX - len);
 329 }
 330
 331 char *mutt_expand_path (char *s, size_t slen)
 332 {
 333   return _mutt_expand_path (s, slen, 0);
 334 }
 335
 336 char *_mutt_expand_path (char *s, size_t slen, int rx)
 337 {
 338   char p[_POSIX_PATH_MAX] = "";
 339   char q[_POSIX_PATH_MAX] = "";
 340   char tmp[_POSIX_PATH_MAX];
 341   char *t;
 342
 343   char *tail = "";
 344
 345   int recurse = 0;
 346
 347   do
 348   {
 349     recurse = 0;
 350
 351     switch (*s)
 352     {
 353       case '~':
 354       {
 355         if (*(s + 1) == '/' || *(s + 1) == 0)
 356         {
 357           strfcpy (p, NONULL(Homedir), sizeof (p));
 358           tail = s + 1;
 359         }
 360         else
 361         {
 362           struct passwd *pw;
 363           if ((t = strchr (s + 1, '/')))
 364             *t = 0;
 365
 366           if ((pw = getpwnam (s + 1)))
 367           {
 368             strfcpy (p, pw->pw_dir, sizeof (p));
 369             if (t)
 370             {
 371               *t = '/';
 372               tail = t;
 373             }
 374             else
 375               tail = "";
 376           }
 377           else
 378           {
 379             /* user not found! */
 380             if (t)
 381               *t = '/';
 382             *p = '\0';
 383             tail = s;
 384           }
 385         }
 386       }
 387       break;
 388
 389       case '=':
 390       case '+':
 391       {
 392 #ifdef USE_IMAP
 393         /* if folder = {host} or imap[s]://host/: don't append slash */
 394         if (mx_is_imap (NONULL (Maildir)) &&
 395             (Maildir[strlen (Maildir) - 1] == '}' ||
 396              Maildir[strlen (Maildir) - 1] == '/'))
 397           strfcpy (p, NONULL (Maildir), sizeof (p));
 398         else
 399 #endif
 400         if (Maildir && *Maildir && Maildir[strlen (Maildir) - 1] == '/')
 401           strfcpy (p, NONULL (Maildir), sizeof (p));
 402         else
 403           snprintf (p, sizeof (p), "%s/", NONULL (Maildir));
 404
 405         tail = s + 1;
 406       }
 407       break;
 408
 409       /* elm compatibility, @ expands alias to user name */
 410
 411       case '@':
 412       {
 413         HEADER *h;
 414         ADDRESS *alias;
 415
 416         if ((alias = mutt_lookup_alias (s + 1)))
 417         {
 418           h = mutt_new_header();
 419           h->env = mutt_new_envelope();
 420           h->env->from = h->env->to = alias;
 421           mutt_default_save (p, sizeof (p), h);
 422           h->env->from = h->env->to = NULL;
 423           mutt_free_header (&h);
 424           /* Avoid infinite recursion if the resulting folder starts with '@' */
 425           if (*p != '@')
 426             recurse = 1;
 427
 428           tail = "";
 429         }
 430       }
 431       break;
 432
 433       case '>':
 434       {
 435         strfcpy (p, NONULL(Inbox), sizeof (p));
 436         tail = s + 1;
 437       }
 438       break;
 439
 440       case '<':
 441       {
 442         strfcpy (p, NONULL(Outbox), sizeof (p));
 443         tail = s + 1;
 444       }
 445       break;
 446
 447       case '!':
 448       {
 449         if (*(s+1) == '!')
 450         {
 451           strfcpy (p, NONULL(LastFolder), sizeof (p));
 452           tail = s + 2;
 453         }
 454         else
 455         {
 456           strfcpy (p, NONULL(Spoolfile), sizeof (p));
 457           tail = s + 1;
 458         }
 459       }
 460       break;
 461
 462       case '-':
 463       {
 464         strfcpy (p, NONULL(LastFolder), sizeof (p));
 465         tail = s + 1;
 466       }
 467       break;
 468
 469       case '^':
 470       {
 471         strfcpy (p, NONULL(CurrentFolder), sizeof (p));
 472         tail = s + 1;
 473       }
 474       break;
 475
 476       default:
 477       {
 478         *p = '\0';
 479         tail = s;
 480       }
 481     }
 482
 483     if (rx && *p && !recurse)
 484     {
 485       mutt_rx_sanitize_string (q, sizeof (q), p);
 486       snprintf (tmp, sizeof (tmp), "%s%s", q, tail);
 487     }
 488     else
 489       snprintf (tmp, sizeof (tmp), "%s%s", p, tail);
 490
 491     strfcpy (s, tmp, slen);
 492   }
 493   while (recurse);
 494
 495 #ifdef USE_IMAP
 496   /* Rewrite IMAP path in canonical form - aids in string comparisons of
 497    * folders. May possibly fail, in which case s should be the same. */
 498   if (mx_is_imap (s))
 499     imap_expand_path (s, slen);
 500 #endif
 501
 502   return (s);
 503 }
 504
 505 /* Extract the real name from /etc/passwd's GECOS field.
 506  * When set, honor the regular expression in GecosMask,
 507  * otherwise assume that the GECOS field is a
 508  * comma-separated list.
 509  * Replace "&" by a capitalized version of the user's login
 510  * name.
 511  */
 512
 513 char *mutt_gecos_name (char *dest, size_t destlen, struct passwd *pw)
 514 {
 515   regmatch_t pat_match[1];
 516   size_t pwnl;
 517   int idx;
 518   char *p;
 519
 520   if (!pw || !pw->pw_gecos)
 521     return NULL;
 522
 523   memset (dest, 0, destlen);
 524
 525   if (GecosMask.rx)
 526   {
 527     if (regexec (GecosMask.rx, pw->pw_gecos, 1, pat_match, 0) == 0)
 528       strfcpy (dest, pw->pw_gecos + pat_match[0].rm_so,
 529                MIN (pat_match[0].rm_eo - pat_match[0].rm_so + 1, destlen));
 530   }
 531   else if ((p = strchr (pw->pw_gecos, ',')))
 532     strfcpy (dest, pw->pw_gecos, MIN (destlen, p - pw->pw_gecos + 1));
 533   else
 534     strfcpy (dest, pw->pw_gecos, destlen);
 535
 536   pwnl = strlen (pw->pw_name);
 537
 538   for (idx = 0; dest[idx]; idx++)
 539   {
 540     if (dest[idx] == '&')
 541     {
 542       memmove (&dest[idx + pwnl], &dest[idx + 1],
 543                MAX((ssize_t)(destlen - idx - pwnl - 1), 0));
 544       memcpy (&dest[idx], pw->pw_name, MIN(destlen - idx - 1, pwnl));
 545       dest[idx] = toupper ((unsigned char) dest[idx]);
 546     }
 547   }
 548
 549   return dest;
 550 }
 551
 552
 553 char *mutt_get_parameter (const char *s, PARAMETER *p)
 554 {
 555   for (; p; p = p->next)
 556     if (ascii_strcasecmp (s, p->attribute) == 0)
 557       return (p->value);
 558
 559   return NULL;
 560 }
 561
 562 void mutt_set_parameter (const char *attribute, const char *value, PARAMETER **p)
 563 {
 564   PARAMETER *q;
 565
 566   if (!value)
 567   {
 568     mutt_delete_parameter (attribute, p);
 569     return;
 570   }
 571
 572   for(q = *p; q; q = q->next)
 573   {
 574     if (ascii_strcasecmp (attribute, q->attribute) == 0)
 575     {
 576       mutt_str_replace (&q->value, value);
 577       return;
 578     }
 579   }
 580
 581   q = mutt_new_parameter();
 582   q->attribute = safe_strdup(attribute);
 583   q->value = safe_strdup(value);
 584   q->next = *p;
 585   *p = q;
 586 }
 587
 588 void mutt_delete_parameter (const char *attribute, PARAMETER **p)
 589 {
 590   PARAMETER *q;
 591
 592   for (q = *p; q; p = &q->next, q = q->next)
 593   {
 594     if (ascii_strcasecmp (attribute, q->attribute) == 0)
 595     {
 596       *p = q->next;
 597       q->next = NULL;
 598       mutt_free_parameter (&q);
 599       return;
 600     }
 601   }
 602 }
 603
 604 /* returns 1 if Mutt can't display this type of data, 0 otherwise */
 605 int mutt_needs_mailcap (BODY *m)
 606 {
 607   switch (m->type)
 608   {
 609     case TYPETEXT:
 610
 611       if (!ascii_strcasecmp ("plain", m->subtype) ||
 612           !ascii_strcasecmp ("rfc822-headers", m->subtype) ||
 613           !ascii_strcasecmp ("enriched", m->subtype))
 614         return 0;
 615       break;
 616
 617     case TYPEAPPLICATION:
 618       if((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp(m))
 619         return 0;
 620       if((WithCrypto & APPLICATION_SMIME) && mutt_is_application_smime(m))
 621         return 0;
 622       break;
 623
 624     case TYPEMULTIPART:
 625     case TYPEMESSAGE:
 626       return 0;
 627   }
 628
 629   return 1;
 630 }
 631
 632 int mutt_is_text_part (BODY *b)
 633 {
 634   int t = b->type;
 635   char *s = b->subtype;
 636
 637   if ((WithCrypto & APPLICATION_PGP) && mutt_is_application_pgp (b))
 638     return 0;
 639
 640   if (t == TYPETEXT)
 641     return 1;
 642
 643   if (t == TYPEMESSAGE)
 644   {
 645     if (!ascii_strcasecmp ("delivery-status", s))
 646       return 1;
 647   }
 648
 649   if ((WithCrypto & APPLICATION_PGP) && t == TYPEAPPLICATION)
 650   {
 651     if (!ascii_strcasecmp ("pgp-keys", s))
 652       return 1;
 653   }
 654
 655   return 0;
 656 }
 657
 658 void mutt_free_envelope (ENVELOPE **p)
 659 {
 660   if (!*p) return;
 661   rfc822_free_address (&(*p)->return_path);
 662   rfc822_free_address (&(*p)->from);
 663   rfc822_free_address (&(*p)->to);
 664   rfc822_free_address (&(*p)->cc);
 665   rfc822_free_address (&(*p)->bcc);
 666   rfc822_free_address (&(*p)->sender);
 667   rfc822_free_address (&(*p)->reply_to);
 668   rfc822_free_address (&(*p)->mail_followup_to);
 669
 670   FREE (&(*p)->list_post);
 671   FREE (&(*p)->subject);
 672   /* real_subj is just an offset to subject and shouldn't be freed */
 673   FREE (&(*p)->message_id);
 674   FREE (&(*p)->supersedes);
 675   FREE (&(*p)->date);
 676   FREE (&(*p)->x_label);
 677
 678   mutt_buffer_free (&(*p)->spam);
 679
 680   mutt_free_list (&(*p)->references);
 681   mutt_free_list (&(*p)->in_reply_to);
 682   mutt_free_list (&(*p)->userhdrs);
 683   FREE (p);             /* __FREE_CHECKED__ */
 684 }
 685
 686 /* move all the headers from extra not present in base into base */
 687 void mutt_merge_envelopes(ENVELOPE* base, ENVELOPE** extra)
 688 {
 689   /* copies each existing element if necessary, and sets the element
 690   * to NULL in the source so that mutt_free_envelope doesn't leave us
 691   * with dangling pointers. */
 692 #define MOVE_ELEM(h) if (!base->h) { base->h = (*extra)->h; (*extra)->h = NULL; }
 693   MOVE_ELEM(return_path);
 694   MOVE_ELEM(from);
 695   MOVE_ELEM(to);
 696   MOVE_ELEM(cc);
 697   MOVE_ELEM(bcc);
 698   MOVE_ELEM(sender);
 699   MOVE_ELEM(reply_to);
 700   MOVE_ELEM(mail_followup_to);
 701   MOVE_ELEM(list_post);
 702   MOVE_ELEM(message_id);
 703   MOVE_ELEM(supersedes);
 704   MOVE_ELEM(date);
 705   MOVE_ELEM(x_label);
 706   if (!base->refs_changed)
 707   {
 708     MOVE_ELEM(references);
 709   }
 710   if (!base->irt_changed)
 711   {
 712     MOVE_ELEM(in_reply_to);
 713   }
 714
 715   /* real_subj is subordinate to subject */
 716   if (!base->subject)
 717   {
 718     base->subject = (*extra)->subject;
 719     base->real_subj = (*extra)->real_subj;
 720     (*extra)->subject = NULL;
 721     (*extra)->real_subj = NULL;
 722   }
 723   /* spam and user headers should never be hashed, and the new envelope may
 724     * have better values. Use new versions regardless. */
 725   mutt_buffer_free (&base->spam);
 726   mutt_free_list (&base->userhdrs);
 727   MOVE_ELEM(spam);
 728   MOVE_ELEM(userhdrs);
 729 #undef MOVE_ELEM
 730
 731   mutt_free_envelope(extra);
 732 }
 733
 734 void _mutt_mktemp (char *s, const char *src, int line)
 735 {
 736   snprintf (s, _POSIX_PATH_MAX, "%s/mutt-%s-%d-%d-%d", NONULL (Tempdir), NONULL(Hostname), (int) getuid(), (int) getpid (), Counter++);
 737   dprint (3, (debugfile, "%s:%d: mutt_mktemp returns \"%s\".\n", src, line, s));
 738   unlink (s);
 739 }
 740
 741 void mutt_free_alias (ALIAS **p)
 742 {
 743   ALIAS *t;
 744
 745   while (*p)
 746   {
 747     t = *p;
 748     *p = (*p)->next;
 749     mutt_alias_delete_reverse (t);
 750     FREE (&t->name);
 751     rfc822_free_address (&t->addr);
 752     FREE (&t);
 753   }
 754 }
 755
 756 /* collapse the pathname using ~ or = when possible */
 757 void mutt_pretty_mailbox (char *s, size_t buflen)
 758 {
 759   char *p = s, *q = s;
 760   size_t len;
 761   url_scheme_t scheme;
 762   char tmp[_POSIX_PATH_MAX];
 763
 764   scheme = url_check_scheme (s);
 765
 766 #ifdef USE_IMAP
 767   if (scheme == U_IMAP || scheme == U_IMAPS)
 768   {
 769     imap_pretty_mailbox (s);
 770     return;
 771   }
 772 #endif
 773
 774   /* if s is an url, only collapse path component */
 775   if (scheme != U_UNKNOWN)
 776   {
 777     p = strchr(s, ':')+1;
 778     if (!strncmp (p, "//", 2))
 779       q = strchr (p+2, '/');
 780     if (!q)
 781       q = strchr (p, '\0');
 782     p = q;
 783   }
 784
 785   /* cleanup path */
 786   if (strstr (p, "//") || strstr (p, "/./"))
 787   {
 788     /* first attempt to collapse the pathname, this is more
 789      * lightweight than realpath() and doesn't resolve links
 790      */
 791     while (*p)
 792     {
 793       if (*p == '/' && p[1] == '/')
 794       {
 795         *q++ = '/';
 796         p += 2;
 797       }
 798       else if (p[0] == '/' && p[1] == '.' && p[2] == '/')
 799       {
 800         *q++ = '/';
 801         p += 3;
 802       }
 803       else
 804         *q++ = *p++;
 805     }
 806     *q = 0;
 807   }
 808   else if (strstr (p, "..") &&
 809            (scheme == U_UNKNOWN || scheme == U_FILE) &&
 810            realpath (p, tmp))
 811     strfcpy (p, tmp, buflen - (p - s));
 812
 813   if (mutt_strncmp (s, Maildir, (len = mutt_strlen (Maildir))) == 0 &&
 814       s[len] == '/')
 815   {
 816     *s++ = '=';
 817     memmove (s, s + len, mutt_strlen (s + len) + 1);
 818   }
 819   else if (mutt_strncmp (s, Homedir, (len = mutt_strlen (Homedir))) == 0 &&
 820            s[len] == '/')
 821   {
 822     *s++ = '~';
 823     memmove (s, s + len - 1, mutt_strlen (s + len - 1) + 1);
 824   }
 825 }
 826
 827 void mutt_pretty_size (char *s, size_t len, LOFF_T n)
 828 {
 829   if (n == 0)
 830     strfcpy (s, "0K", len);
 831   else if (n < 10189) /* 0.1K - 9.9K */
 832     snprintf (s, len, "%3.1fK", (n < 103) ? 0.1 : n / 1024.0);
 833   else if (n < 1023949) /* 10K - 999K */
 834   {
 835     /* 51 is magic which causes 10189/10240 to be rounded up to 10 */
 836     snprintf (s, len, OFF_T_FMT "K", (n + 51) / 1024);
 837   }
 838   else if (n < 10433332) /* 1.0M - 9.9M */
 839     snprintf (s, len, "%3.1fM", n / 1048576.0);
 840   else /* 10M+ */
 841   {
 842     /* (10433332 + 52428) / 1048576 = 10 */
 843     snprintf (s, len, OFF_T_FMT "M", (n + 52428) / 1048576);
 844   }
 845 }
 846
 847 void mutt_expand_file_fmt (char *dest, size_t destlen, const char *fmt, const char *src)
 848 {
 849   char tmp[LONG_STRING];
 850
 851   mutt_quote_filename (tmp, sizeof (tmp), src);
 852   mutt_expand_fmt (dest, destlen, fmt, tmp);
 853 }
 854
 855 void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, const char *src)
 856 {
 857   const char *p;
 858   char *d;
 859   size_t slen;
 860   int found = 0;
 861
 862   slen = mutt_strlen (src);
 863   destlen--;
 864
 865   for (p = fmt, d = dest; destlen && *p; p++)
 866   {
 867     if (*p == '%')
 868     {
 869       switch (p[1])
 870       {
 871         case '%':
 872           *d++ = *p++;
 873           destlen--;
 874           break;
 875         case 's':
 876           found = 1;
 877           strfcpy (d, src, destlen + 1);
 878           d       += destlen > slen ? slen : destlen;
 879           destlen -= destlen > slen ? slen : destlen;
 880           p++;
 881           break;
 882         default:
 883           *d++ = *p;
 884           destlen--;
 885           break;
 886       }
 887     }
 888     else
 889     {
 890       *d++ = *p;
 891       destlen--;
 892     }
 893   }
 894
 895   *d = '\0';
 896
 897   if (!found && destlen > 0)
 898   {
 899     safe_strcat (dest, destlen, " ");
 900     safe_strcat (dest, destlen, src);
 901   }
 902
 903 }
 904
 905 /* return 0 on success, -1 on abort, 1 on error */
 906 int mutt_check_overwrite (const char *attname, const char *path,
 907                                 char *fname, size_t flen, int *append, char **directory)
 908 {
 909   int rc = 0;
 910   char tmp[_POSIX_PATH_MAX];
 911   struct stat st;
 912
 913   strfcpy (fname, path, flen);
 914   if (access (fname, F_OK) != 0)
 915     return 0;
 916   if (stat (fname, &st) != 0)
 917     return -1;
 918   if (S_ISDIR (st.st_mode))
 919   {
 920     if (directory)
 921     {
 922       switch (mutt_multi_choice
 923               (_("File is a directory, save under it? [(y)es, (n)o, (a)ll]"), _("yna")))
 924       {
 925         case 3:         /* all */
 926           mutt_str_replace (directory, fname);
 927           break;
 928         case 1:         /* yes */
 929           FREE (directory);             /* __FREE_CHECKED__ */
 930           break;
 931         case -1:        /* abort */
 932           FREE (directory);             /* __FREE_CHECKED__ */
 933           return -1;
 934         case  2:        /* no */
 935           FREE (directory);             /* __FREE_CHECKED__ */
 936           return 1;
 937       }
 938     }
 939     else if ((rc = mutt_yesorno (_("File is a directory, save under it?"), M_YES)) != M_YES)
 940       return (rc == M_NO) ? 1 : -1;
 941
 942     if (!attname || !attname[0])
 943     {
 944       tmp[0] = 0;
 945       if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp),
 946                                       M_FILE | M_CLEAR) != 0 || !tmp[0])
 947         return (-1);
 948       mutt_concat_path (fname, path, tmp, flen);
 949     }
 950     else
 951       mutt_concat_path (fname, path, mutt_basename (attname), flen);
 952   }
 953
 954   if (*append == 0 && access (fname, F_OK) == 0)
 955   {
 956     switch (mutt_multi_choice
 957             (_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"), _("oac")))
 958     {
 959       case -1: /* abort */
 960         return -1;
 961       case 3:  /* cancel */
 962         return 1;
 963
 964       case 2: /* append */
 965         *append = M_SAVE_APPEND;
 966         break;
 967       case 1: /* overwrite */
 968         *append = M_SAVE_OVERWRITE;
 969         break;
 970     }
 971   }
 972   return 0;
 973 }
 974
 975 void mutt_save_path (char *d, size_t dsize, ADDRESS *a)
 976 {
 977   if (a && a->mailbox)
 978   {
 979     strfcpy (d, a->mailbox, dsize);
 980     if (!option (OPTSAVEADDRESS))
 981     {
 982       char *p;
 983
 984       if ((p = strpbrk (d, "%@")))
 985         *p = 0;
 986     }
 987     mutt_strlower (d);
 988   }
 989   else
 990     *d = 0;
 991 }
 992
 993 void mutt_safe_path (char *s, size_t l, ADDRESS *a)
 994 {
 995   char *p;
 996
 997   mutt_save_path (s, l, a);
 998   for (p = s; *p; p++)
 999     if (*p == '/' || ISSPACE (*p) || !IsPrint ((unsigned char) *p))
1000       *p = '_';
1001 }
1002
1003
1004 void mutt_FormatString (char *dest,             /* output buffer */
1005                         size_t destlen,         /* output buffer len */
1006                         size_t col,             /* starting column (nonzero when called recursively) */
1007                         const char *src,        /* template string */
1008                         format_t *callback,     /* callback for processing */
1009                         unsigned long data,     /* callback data */
1010                         format_flag flags)      /* callback flags */
1011 {
1012   char prefix[SHORT_STRING], buf[LONG_STRING], *cp, *wptr = dest, ch;
1013   char ifstring[SHORT_STRING], elsestring[SHORT_STRING];
1014   size_t wlen, count, len, wid;
1015   pid_t pid;
1016   FILE *filter;
1017   int n;
1018   char *recycler;
1019
1020   prefix[0] = '\0';
1021   destlen--; /* save room for the terminal \0 */
1022   wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
1023   col += wlen;
1024
1025   if ((flags & M_FORMAT_NOFILTER) == 0)
1026   {
1027     int off = -1;
1028
1029     /* Do not consider filters if no pipe at end */
1030     n = mutt_strlen(src);
1031     if (n > 1 && src[n-1] == '|')
1032     {
1033       /* Scan backwards for backslashes */
1034       off = n;
1035       while (off > 0 && src[off-2] == '\\')
1036         off--;
1037     }
1038
1039     /* If number of backslashes is even, the pipe is real. */
1040     /* n-off is the number of backslashes. */
1041     if (off > 0 && ((n-off) % 2) == 0)
1042     {
1043       BUFFER *srcbuf, *word, *command;
1044       char    srccopy[LONG_STRING];
1045 #ifdef DEBUG
1046       int     i = 0;
1047 #endif
1048
1049       dprint(3, (debugfile, "fmtpipe = %s\n", src));
1050
1051       strncpy(srccopy, src, n);
1052       srccopy[n-1] = '\0';
1053
1054       /* prepare BUFFERs */
1055       srcbuf = mutt_buffer_from(NULL, srccopy);
1056       srcbuf->dptr = srcbuf->data;
1057       word = mutt_buffer_init(NULL);
1058       command = mutt_buffer_init(NULL);
1059
1060       /* Iterate expansions across successive arguments */
1061       do {
1062         char *p;
1063
1064         /* Extract the command name and copy to command line */
1065         dprint(3, (debugfile, "fmtpipe +++: %s\n", srcbuf->dptr));
1066         if (word->data)
1067           *word->data = '\0';
1068         mutt_extract_token(word, srcbuf, 0);
1069         dprint(3, (debugfile, "fmtpipe %2d: %s\n", i++, word->data));
1070         mutt_buffer_addch(command, '\'');
1071         mutt_FormatString(buf, sizeof(buf), 0, word->data, callback, data,
1072                           flags | M_FORMAT_NOFILTER);
1073         for (p = buf; p && *p; p++)
1074         {
1075           if (*p == '\'')
1076             /* shell quoting doesn't permit escaping a single quote within
1077              * single-quoted material.  double-quoting instead will lead
1078              * shell variable expansions, so break out of the single-quoted
1079              * span, insert a double-quoted single quote, and resume. */
1080             mutt_buffer_addstr(command, "'\"'\"'");
1081           else
1082             mutt_buffer_addch(command, *p);
1083         }
1084         mutt_buffer_addch(command, '\'');
1085         mutt_buffer_addch(command, ' ');
1086       } while (MoreArgs(srcbuf));
1087
1088       dprint(3, (debugfile, "fmtpipe > %s\n", command->data));
1089
1090       col -= wlen;      /* reset to passed in value */
1091       wptr = dest;      /* reset write ptr */
1092       wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
1093       if ((pid = mutt_create_filter(command->data, NULL, &filter, NULL)))
1094       {
1095         n = fread(dest, 1, destlen /* already decremented */, filter);
1096         fclose(filter);
1097         dest[n] = '\0';
1098         while (dest[n-1] == '\n' || dest[n-1] == '\r')
1099           dest[--n] = '\0';
1100         dprint(3, (debugfile, "fmtpipe < %s\n", dest));
1101
1102         if (pid != -1)
1103           mutt_wait_filter(pid);
1104
1105         /* If the result ends with '%', this indicates that the filter
1106          * generated %-tokens that mutt can expand.  Eliminate the '%'
1107          * marker and recycle the string through mutt_FormatString().
1108          * To literally end with "%", use "%%". */
1109         if (dest[--n] == '%')
1110         {
1111           dest[n] = '\0';               /* remove '%' */
1112           if (dest[--n] != '%')
1113           {
1114             recycler = safe_strdup(dest);
1115             if (recycler)
1116             {
1117               mutt_FormatString(dest, destlen++, col, recycler, callback, data, flags);
1118               FREE(&recycler);
1119             }
1120           }
1121         }
1122       }
1123       else
1124       {
1125         /* Filter failed; erase write buffer */
1126         *wptr = '\0';
1127       }
1128
1129       mutt_buffer_free(&command);
1130       mutt_buffer_free(&srcbuf);
1131       mutt_buffer_free(&word);
1132       return;
1133     }
1134   }
1135
1136   while (*src && wlen < destlen)
1137   {
1138     if (*src == '%')
1139     {
1140       if (*++src == '%')
1141       {
1142         *wptr++ = '%';
1143         wlen++;
1144         col++;
1145         src++;
1146         continue;
1147       }
1148
1149       if (*src == '?')
1150       {
1151         flags |= M_FORMAT_OPTIONAL;
1152         src++;
1153       }
1154       else
1155       {
1156         flags &= ~M_FORMAT_OPTIONAL;
1157
1158         /* eat the format string */
1159         cp = prefix;
1160         count = 0;
1161         while (count < sizeof (prefix) &&
1162                (isdigit ((unsigned char) *src) || *src == '.' || *src == '-' || *src == '='))
1163         {
1164           *cp++ = *src++;
1165           count++;
1166         }
1167         *cp = 0;
1168       }
1169
1170       if (!*src)
1171         break; /* bad format */
1172
1173       ch = *src++; /* save the character to switch on */
1174
1175       if (flags & M_FORMAT_OPTIONAL)
1176       {
1177         if (*src != '?')
1178           break; /* bad format */
1179         src++;
1180
1181         /* eat the `if' part of the string */
1182         cp = ifstring;
1183         count = 0;
1184         while (count < sizeof (ifstring) && *src && *src != '?' && *src != '&')
1185         {
1186           *cp++ = *src++;
1187           count++;
1188         }
1189         *cp = 0;
1190
1191         /* eat the `else' part of the string (optional) */
1192         if (*src == '&')
1193           src++; /* skip the & */
1194         cp = elsestring;
1195         count = 0;
1196         while (count < sizeof (elsestring) && *src && *src != '?')
1197         {
1198           *cp++ = *src++;
1199           count++;
1200         }
1201         *cp = 0;
1202
1203         if (!*src)
1204           break; /* bad format */
1205
1206         src++; /* move past the trailing `?' */
1207       }
1208
1209       /* handle generic cases first */
1210       if (ch == '>' || ch == '*')
1211       {
1212         /* %>X: right justify to EOL, left takes precedence
1213          * %*X: right justify to EOL, right takes precedence */
1214         int soft = ch == '*';
1215         int pl, pw;
1216         if ((pl = mutt_charlen (src, &pw)) <= 0)
1217           pl = pw = 1;
1218
1219         /* see if there's room to add content, else ignore */
1220         if ((col < COLS && wlen < destlen) || soft)
1221         {
1222           int pad;
1223
1224           /* get contents after padding */
1225           mutt_FormatString (buf, sizeof (buf), 0, src + pl, callback, data, flags);
1226           len = mutt_strlen (buf);
1227           wid = mutt_strwidth (buf);
1228
1229           /* try to consume as many columns as we can, if we don't have
1230            * memory for that, use as much memory as possible */
1231           pad = (COLS - col - wid) / pw;
1232           if (pad > 0 && wlen + (pad * pl) + len > destlen)
1233             pad = ((signed)(destlen - wlen - len)) / pl;
1234           if (pad > 0)
1235           {
1236             while (pad--)
1237             {
1238               memcpy (wptr, src, pl);
1239               wptr += pl;
1240               wlen += pl;
1241               col += pw;
1242             }
1243           }
1244           else if (soft && pad < 0)
1245           {
1246             /* \0-terminate dest for length computation in mutt_wstr_trunc() */
1247             *wptr = 0;
1248             /* make sure right part is at most as wide as display */
1249             len = mutt_wstr_trunc (buf, destlen, COLS, &wid);
1250             /* truncate left so that right part fits completely in */
1251             wlen = mutt_wstr_trunc (dest, destlen - len, col + pad, &col);
1252             wptr = dest + wlen;
1253           }
1254           if (len + wlen > destlen)
1255             len = mutt_wstr_trunc (buf, destlen - wlen, COLS - col, NULL);
1256           memcpy (wptr, buf, len);
1257           wptr += len;
1258           wlen += len;
1259           col += wid;
1260           src += pl;
1261         }
1262         break; /* skip rest of input */
1263       }
1264       else if (ch == '|')
1265       {
1266         /* pad to EOL */
1267         int pl, pw, c;
1268         if ((pl = mutt_charlen (src, &pw)) <= 0)
1269           pl = pw = 1;
1270
1271         /* see if there's room to add content, else ignore */
1272         if (col < COLS && wlen < destlen)
1273         {
1274           c = (COLS - col) / pw;
1275           if (c > 0 && wlen + (c * pl) > destlen)
1276             c = ((signed)(destlen - wlen)) / pl;
1277           while (c > 0)
1278           {
1279             memcpy (wptr, src, pl);
1280             wptr += pl;
1281             wlen += pl;
1282             col += pw;
1283             c--;
1284           }
1285           src += pl;
1286         }
1287         break; /* skip rest of input */
1288       }
1289       else
1290       {
1291         short tolower =  0;
1292         short nodots  = 0;
1293
1294         while (ch == '_' || ch == ':')
1295         {
1296           if (ch == '_')
1297             tolower = 1;
1298           else if (ch == ':')
1299             nodots = 1;
1300
1301           ch = *src++;
1302         }
1303
1304         /* use callback function to handle this case */
1305         src = callback (buf, sizeof (buf), col, ch, src, prefix, ifstring, elsestring, data, flags);
1306
1307         if (tolower)
1308           mutt_strlower (buf);
1309         if (nodots)
1310         {
1311           char *p = buf;
1312           for (; *p; p++)
1313             if (*p == '.')
1314                 *p = '_';
1315         }
1316
1317         if ((len = mutt_strlen (buf)) + wlen > destlen)
1318           len = mutt_wstr_trunc (buf, destlen - wlen, COLS - col, NULL);
1319
1320         memcpy (wptr, buf, len);
1321         wptr += len;
1322         wlen += len;
1323         col += mutt_strwidth (buf);
1324       }
1325     }
1326     else if (*src == '\\')
1327     {
1328       if (!*++src)
1329         break;
1330       switch (*src)
1331       {
1332         case 'n':
1333           *wptr = '\n';
1334           break;
1335         case 't':
1336           *wptr = '\t';
1337           break;
1338         case 'r':
1339           *wptr = '\r';
1340           break;
1341         case 'f':
1342           *wptr = '\f';
1343           break;
1344         case 'v':
1345           *wptr = '\v';
1346           break;
1347         default:
1348           *wptr = *src;
1349           break;
1350       }
1351       src++;
1352       wptr++;
1353       wlen++;
1354       col++;
1355     }
1356     else
1357     {
1358       int tmp, w;
1359       /* in case of error, simply copy byte */
1360       if ((tmp = mutt_charlen (src, &w)) < 0)
1361         tmp = w = 1;
1362       if (tmp > 0 && wlen + tmp < destlen)
1363       {
1364         memcpy (wptr, src, tmp);
1365         wptr += tmp;
1366         src += tmp;
1367         wlen += tmp;
1368         col += w;
1369       }
1370       else
1371       {
1372         src += destlen - wlen;
1373         wlen = destlen;
1374       }
1375     }
1376   }
1377   *wptr = 0;
1378
1379 #if 0
1380   if (flags & M_FORMAT_MAKEPRINT)
1381   {
1382     /* Make sure that the string is printable by changing all non-printable
1383        chars to dots, or spaces for non-printable whitespace */
1384     for (cp = dest ; *cp ; cp++)
1385       if (!IsPrint (*cp) &&
1386           !((flags & M_FORMAT_TREE) && (*cp <= M_TREE_MAX)))
1387         *cp = isspace ((unsigned char) *cp) ? ' ' : '.';
1388   }
1389 #endif
1390 }
1391
1392 /* This function allows the user to specify a command to read stdout from in
1393    place of a normal file.  If the last character in the string is a pipe (|),
1394    then we assume it is a commmand to run instead of a normal file. */
1395 FILE *mutt_open_read (const char *path, pid_t *thepid)
1396 {
1397   FILE *f;
1398   struct stat s;
1399
1400   int len = mutt_strlen (path);
1401
1402   if (path[len - 1] == '|')
1403   {
1404     /* read from a pipe */
1405
1406     char *s = safe_strdup (path);
1407
1408     s[len - 1] = 0;
1409     mutt_endwin (NULL);
1410     *thepid = mutt_create_filter (s, NULL, &f, NULL);
1411     FREE (&s);
1412   }
1413   else
1414   {
1415     if (stat (path, &s) < 0)
1416       return (NULL);
1417     if (S_ISDIR (s.st_mode))
1418     {
1419       errno = EINVAL;
1420       return (NULL);
1421     }
1422     f = fopen (path, "r");
1423     *thepid = -1;
1424   }
1425   return (f);
1426 }
1427
1428 /* returns 0 if OK to proceed, -1 to abort, 1 to retry */
1429 int mutt_save_confirm (const char *s, struct stat *st)
1430 {
1431   char tmp[_POSIX_PATH_MAX];
1432   int ret = 0;
1433   int rc;
1434   int magic = 0;
1435
1436   magic = mx_get_magic (s);
1437
1438 #ifdef USE_POP
1439   if (magic == M_POP)
1440   {
1441     mutt_error _("Can't save message to POP mailbox.");
1442     return 1;
1443   }
1444 #endif
1445
1446   if (magic > 0 && !mx_access (s, W_OK))
1447   {
1448     if (option (OPTCONFIRMAPPEND))
1449     {
1450       snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s);
1451       if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
1452         ret = 1;
1453       else if (rc == -1)
1454         ret = -1;
1455     }
1456   }
1457
1458   if (stat (s, st) != -1)
1459   {
1460     if (magic == -1)
1461     {
1462       mutt_error (_("%s is not a mailbox!"), s);
1463       return 1;
1464     }
1465   }
1466   else
1467 #ifdef USE_IMAP
1468   if (magic != M_IMAP)
1469 #endif /* execute the block unconditionally if we don't use imap */
1470   {
1471     st->st_mtime = 0;
1472     st->st_atime = 0;
1473
1474     if (errno == ENOENT)
1475     {
1476       if (option (OPTCONFIRMCREATE))
1477       {
1478         snprintf (tmp, sizeof (tmp), _("Create %s?"), s);
1479         if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
1480           ret = 1;
1481         else if (rc == -1)
1482           ret = -1;
1483       }
1484     }
1485     else
1486     {
1487       mutt_perror (s);
1488       return 1;
1489     }
1490   }
1491
1492   CLEARLINE (LINES-1);
1493   return (ret);
1494 }
1495
1496 void state_prefix_putc (char c, STATE *s)
1497 {
1498   if (s->flags & M_PENDINGPREFIX)
1499   {
1500     state_reset_prefix (s);
1501     if (s->prefix)
1502       state_puts (s->prefix, s);
1503   }
1504
1505   state_putc (c, s);
1506
1507   if (c == '\n')
1508     state_set_prefix (s);
1509 }
1510
1511 int state_printf (STATE *s, const char *fmt, ...)
1512 {
1513   int rv;
1514   va_list ap;
1515
1516   va_start (ap, fmt);
1517   rv = vfprintf (s->fpout, fmt, ap);
1518   va_end (ap);
1519
1520   return rv;
1521 }
1522
1523 void state_mark_attach (STATE *s)
1524 {
1525   if ((s->flags & M_DISPLAY) && !mutt_strcmp (Pager, "builtin"))
1526     state_puts (AttachmentMarker, s);
1527 }
1528
1529 void state_attach_puts (const char *t, STATE *s)
1530 {
1531   if (*t != '\n') state_mark_attach (s);
1532   while (*t)
1533   {
1534     state_putc (*t, s);
1535     if (*t++ == '\n' && *t)
1536       if (*t != '\n') state_mark_attach (s);
1537   }
1538 }
1539
1540 void mutt_display_sanitize (char *s)
1541 {
1542   for (; *s; s++)
1543   {
1544     if (!IsPrint (*s))
1545       *s = '?';
1546   }
1547 }
1548
1549 void mutt_sleep (short s)
1550 {
1551   if (SleepTime > s)
1552     sleep (SleepTime);
1553   else if (s)
1554     sleep (s);
1555 }
1556
1557 /*
1558  * Creates and initializes a BUFFER*. If passed an existing BUFFER*,
1559  * just initializes. Frees anything already in the buffer.
1560  *
1561  * Disregards the 'destroy' flag, which seems reserved for caller.
1562  * This is bad, but there's no apparent protocol for it.
1563  */
1564 BUFFER * mutt_buffer_init(BUFFER *b)
1565 {
1566   if (!b)
1567   {
1568     b = safe_malloc(sizeof(BUFFER));
1569     if (!b)
1570       return NULL;
1571   }
1572   else
1573   {
1574     FREE(&b->data);
1575   }
1576   memset(b, 0, sizeof(BUFFER));
1577   return b;
1578 }
1579
1580 /*
1581  * Creates and initializes a BUFFER*. If passed an existing BUFFER*,
1582  * just initializes. Frees anything already in the buffer. Copies in
1583  * the seed string.
1584  *
1585  * Disregards the 'destroy' flag, which seems reserved for caller.
1586  * This is bad, but there's no apparent protocol for it.
1587  */
1588 BUFFER * mutt_buffer_from(BUFFER *b, char *seed)
1589 {
1590   if (!seed)
1591     return NULL;
1592
1593   b = mutt_buffer_init(b);
1594   b->data = safe_strdup (seed);
1595   b->dsize = mutt_strlen (seed);
1596   b->dptr = (char *) b->data + b->dsize;
1597   return b;
1598 }
1599
1600 int mutt_buffer_printf (BUFFER* buf, const char* fmt, ...)
1601 {
1602   va_list ap, ap_retry;
1603   int len, blen, doff;
1604
1605   va_start (ap, fmt);
1606   va_copy (ap_retry, ap);
1607
1608   doff = buf->dptr - buf->data;
1609   blen = buf->dsize - doff;
1610   /* solaris 9 vsnprintf barfs when blen is 0 */
1611   if (!blen)
1612   {
1613     blen = 128;
1614     buf->dsize += blen;
1615     safe_realloc (&buf->data, buf->dsize);
1616     buf->dptr = buf->data + doff;
1617   }
1618   if ((len = vsnprintf (buf->dptr, blen, fmt, ap)) >= blen)
1619   {
1620     blen = ++len - blen;
1621     if (blen < 128)
1622       blen = 128;
1623     buf->dsize += blen;
1624     safe_realloc (&buf->data, buf->dsize);
1625     buf->dptr = buf->data + doff;
1626     len = vsnprintf (buf->dptr, len, fmt, ap_retry);
1627   }
1628   if (len > 0)
1629     buf->dptr += len;
1630
1631   va_end (ap);
1632   va_end (ap_retry);
1633
1634   return len;
1635 }
1636
1637 void mutt_buffer_addstr (BUFFER* buf, const char* s)
1638 {
1639   mutt_buffer_add (buf, s, mutt_strlen (s));
1640 }
1641
1642 void mutt_buffer_addch (BUFFER* buf, char c)
1643 {
1644   mutt_buffer_add (buf, &c, 1);
1645 }
1646
1647 void mutt_buffer_free (BUFFER **p)
1648 {
1649   if (!p || !*p)
1650     return;
1651
1652    FREE(&(*p)->data);
1653    /* dptr is just an offset to data and shouldn't be freed */
1654    FREE(p);             /* __FREE_CHECKED__ */
1655 }
1656
1657 /* dynamically grows a BUFFER to accomodate s, in increments of 128 bytes.
1658  * Always one byte bigger than necessary for the null terminator, and
1659  * the buffer is always null-terminated */
1660 void mutt_buffer_add (BUFFER* buf, const char* s, size_t len)
1661 {
1662   size_t offset;
1663
1664   if (buf->dptr + len + 1 > buf->data + buf->dsize)
1665   {
1666     offset = buf->dptr - buf->data;
1667     buf->dsize += len < 128 ? 128 : len + 1;
1668     /* suppress compiler aliasing warning */
1669     safe_realloc ((void**) (void*) &buf->data, buf->dsize);
1670     buf->dptr = buf->data + offset;
1671   }
1672   memcpy (buf->dptr, s, len);
1673   buf->dptr += len;
1674   *(buf->dptr) = '\0';
1675 }
1676
1677 /* Decrease a file's modification time by 1 second */
1678
1679 time_t mutt_decrease_mtime (const char *f, struct stat *st)
1680 {
1681   struct utimbuf utim;
1682   struct stat _st;
1683   time_t mtime;
1684
1685   if (!st)
1686   {
1687     if (stat (f, &_st) == -1)
1688       return -1;
1689     st = &_st;
1690   }
1691
1692   if ((mtime = st->st_mtime) == time (NULL))
1693   {
1694     mtime -= 1;
1695     utim.actime = mtime;
1696     utim.modtime = mtime;
1697     utime (f, &utim);
1698   }
1699
1700   return mtime;
1701 }
1702
1703 /* sets mtime of 'to' to mtime of 'from' */
1704 void mutt_set_mtime (const char* from, const char* to)
1705 {
1706   struct utimbuf utim;
1707   struct stat st;
1708
1709   if (stat (from, &st) != -1)
1710   {
1711     utim.actime = st.st_mtime;
1712     utim.modtime = st.st_mtime;
1713     utime (to, &utim);
1714   }
1715 }
1716
1717 const char *mutt_make_version (void)
1718 {
1719   static char vstring[STRING];
1720   snprintf (vstring, sizeof (vstring), "Mutt %s (%s)",
1721             MUTT_VERSION, ReleaseDate);
1722   return vstring;
1723 }
1724
1725 REGEXP *mutt_compile_regexp (const char *s, int flags)
1726 {
1727   REGEXP *pp = safe_calloc (sizeof (REGEXP), 1);
1728   pp->pattern = safe_strdup (s);
1729   pp->rx = safe_calloc (sizeof (regex_t), 1);
1730   if (REGCOMP (pp->rx, NONULL(s), flags) != 0)
1731     mutt_free_regexp (&pp);
1732
1733   return pp;
1734 }
1735
1736 void mutt_free_regexp (REGEXP **pp)
1737 {
1738   FREE (&(*pp)->pattern);
1739   regfree ((*pp)->rx);
1740   FREE (&(*pp)->rx);
1741   FREE (pp);            /* __FREE_CHECKED__ */
1742 }
1743
1744 void mutt_free_rx_list (RX_LIST **list)
1745 {
1746   RX_LIST *p;
1747
1748   if (!list) return;
1749   while (*list)
1750   {
1751     p = *list;
1752     *list = (*list)->next;
1753     mutt_free_regexp (&p->rx);
1754     FREE (&p);
1755   }
1756 }
1757
1758 void mutt_free_spam_list (SPAM_LIST **list)
1759 {
1760   SPAM_LIST *p;
1761
1762   if (!list) return;
1763   while (*list)
1764   {
1765     p = *list;
1766     *list = (*list)->next;
1767     mutt_free_regexp (&p->rx);
1768     FREE (&p->template);
1769     FREE (&p);
1770   }
1771 }
1772
1773 int mutt_match_rx_list (const char *s, RX_LIST *l)
1774 {
1775   if (!s)  return 0;
1776
1777   for (; l; l = l->next)
1778   {
1779     if (regexec (l->rx->rx, s, (size_t) 0, (regmatch_t *) 0, (int) 0) == 0)
1780     {
1781       dprint (5, (debugfile, "mutt_match_rx_list: %s matches %s\n", s, l->rx->pattern));
1782       return 1;
1783     }
1784   }
1785
1786   return 0;
1787 }
1788
1789 int mutt_match_spam_list (const char *s, SPAM_LIST *l, char *text, int x)
1790 {
1791   static regmatch_t *pmatch = NULL;
1792   static int nmatch = 0;
1793   int i, n, tlen;
1794   char *p;
1795
1796   if (!s)  return 0;
1797
1798   tlen = 0;
1799
1800   for (; l; l = l->next)
1801   {
1802     /* If this pattern needs more matches, expand pmatch. */
1803     if (l->nmatch > nmatch)
1804     {
1805       safe_realloc (&pmatch, l->nmatch * sizeof(regmatch_t));
1806       nmatch = l->nmatch;
1807     }
1808
1809     /* Does this pattern match? */
1810     if (regexec (l->rx->rx, s, (size_t) l->nmatch, (regmatch_t *) pmatch, (int) 0) == 0)
1811     {
1812       dprint (5, (debugfile, "mutt_match_spam_list: %s matches %s\n", s, l->rx->pattern));
1813       dprint (5, (debugfile, "mutt_match_spam_list: %d subs\n", (int)l->rx->rx->re_nsub));
1814
1815       /* Copy template into text, with substitutions. */
1816       for (p = l->template; *p;)
1817       {
1818         if (*p == '%')
1819         {
1820           n = atoi(++p);                        /* find pmatch index */
1821           while (isdigit((unsigned char)*p))
1822             ++p;                                /* skip subst token */
1823           for (i = pmatch[n].rm_so; (i < pmatch[n].rm_eo) && (tlen < x); i++)
1824             text[tlen++] = s[i];
1825         }
1826         else
1827         {
1828           text[tlen++] = *p++;
1829         }
1830       }
1831       text[tlen] = '\0';
1832       dprint (5, (debugfile, "mutt_match_spam_list: \"%s\"\n", text));
1833       return 1;
1834     }
1835   }
1836
1837   return 0;
1838 }
1839