muttlib.c

   1 /*
   2  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
   3  * Copyright (C) 1999-2000 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 (1, (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     FREE (&t->name);
 750     rfc822_free_address (&t->addr);
 751     FREE (&t);
 752   }
 753 }
 754
 755 /* collapse the pathname using ~ or = when possible */
 756 void mutt_pretty_mailbox (char *s)
 757 {
 758   char *p = s, *q = s;
 759   size_t len;
 760   url_scheme_t scheme;
 761
 762   scheme = url_check_scheme (s);
 763
 764 #ifdef USE_IMAP
 765   if (scheme == U_IMAP || scheme == U_IMAPS)
 766   {
 767     imap_pretty_mailbox (s);
 768     return;
 769   }
 770 #endif
 771
 772   /* if s is an url, only collapse path component */
 773   if (scheme != U_UNKNOWN)
 774   {
 775     p = strchr(s, ':')+1;
 776     if (!strncmp (p, "//", 2))
 777       q = strchr (p+2, '/');
 778     if (!q)
 779       q = strchr (p, '\0');
 780     p = q;
 781   }
 782
 783   /* first attempt to collapse the pathname */
 784   while (*p)
 785   {
 786     if (*p == '/' && p[1] == '/')
 787     {
 788       *q++ = '/';
 789       p += 2;
 790     }
 791     else if (p[0] == '/' && p[1] == '.' && p[2] == '/')
 792     {
 793       *q++ = '/';
 794       p += 3;
 795     }
 796     else
 797       *q++ = *p++;
 798   }
 799   *q = 0;
 800
 801   if (mutt_strncmp (s, Maildir, (len = mutt_strlen (Maildir))) == 0 &&
 802       s[len] == '/')
 803   {
 804     *s++ = '=';
 805     memmove (s, s + len, mutt_strlen (s + len) + 1);
 806   }
 807   else if (mutt_strncmp (s, Homedir, (len = mutt_strlen (Homedir))) == 0 &&
 808            s[len] == '/')
 809   {
 810     *s++ = '~';
 811     memmove (s, s + len - 1, mutt_strlen (s + len - 1) + 1);
 812   }
 813 }
 814
 815 void mutt_pretty_size (char *s, size_t len, LOFF_T n)
 816 {
 817   if (n == 0)
 818     strfcpy (s, "0K", len);
 819   else if (n < 10189) /* 0.1K - 9.9K */
 820     snprintf (s, len, "%3.1fK", (n < 103) ? 0.1 : n / 1024.0);
 821   else if (n < 1023949) /* 10K - 999K */
 822   {
 823     /* 51 is magic which causes 10189/10240 to be rounded up to 10 */
 824     snprintf (s, len, OFF_T_FMT "K", (n + 51) / 1024);
 825   }
 826   else if (n < 10433332) /* 1.0M - 9.9M */
 827     snprintf (s, len, "%3.1fM", n / 1048576.0);
 828   else /* 10M+ */
 829   {
 830     /* (10433332 + 52428) / 1048576 = 10 */
 831     snprintf (s, len, OFF_T_FMT "M", (n + 52428) / 1048576);
 832   }
 833 }
 834
 835 void mutt_expand_file_fmt (char *dest, size_t destlen, const char *fmt, const char *src)
 836 {
 837   char tmp[LONG_STRING];
 838
 839   mutt_quote_filename (tmp, sizeof (tmp), src);
 840   mutt_expand_fmt (dest, destlen, fmt, tmp);
 841 }
 842
 843 void mutt_expand_fmt (char *dest, size_t destlen, const char *fmt, const char *src)
 844 {
 845   const char *p;
 846   char *d;
 847   size_t slen;
 848   int found = 0;
 849
 850   slen = mutt_strlen (src);
 851   destlen--;
 852
 853   for (p = fmt, d = dest; destlen && *p; p++)
 854   {
 855     if (*p == '%')
 856     {
 857       switch (p[1])
 858       {
 859         case '%':
 860           *d++ = *p++;
 861           destlen--;
 862           break;
 863         case 's':
 864           found = 1;
 865           strfcpy (d, src, destlen + 1);
 866           d       += destlen > slen ? slen : destlen;
 867           destlen -= destlen > slen ? slen : destlen;
 868           p++;
 869           break;
 870         default:
 871           *d++ = *p;
 872           destlen--;
 873           break;
 874       }
 875     }
 876     else
 877     {
 878       *d++ = *p;
 879       destlen--;
 880     }
 881   }
 882
 883   *d = '\0';
 884
 885   if (!found && destlen > 0)
 886   {
 887     safe_strcat (dest, destlen, " ");
 888     safe_strcat (dest, destlen, src);
 889   }
 890
 891 }
 892
 893 /* return 0 on success, -1 on abort, 1 on error */
 894 int mutt_check_overwrite (const char *attname, const char *path,
 895                                 char *fname, size_t flen, int *append, char **directory)
 896 {
 897   int rc = 0;
 898   char tmp[_POSIX_PATH_MAX];
 899   struct stat st;
 900
 901   strfcpy (fname, path, flen);
 902   if (access (fname, F_OK) != 0)
 903     return 0;
 904   if (stat (fname, &st) != 0)
 905     return -1;
 906   if (S_ISDIR (st.st_mode))
 907   {
 908     if (directory)
 909     {
 910       switch (mutt_multi_choice
 911               (_("File is a directory, save under it? [(y)es, (n)o, (a)ll]"), _("yna")))
 912       {
 913         case 3:         /* all */
 914           mutt_str_replace (directory, fname);
 915           break;
 916         case 1:         /* yes */
 917           FREE (directory);             /* __FREE_CHECKED__ */
 918           break;
 919         case -1:        /* abort */
 920           FREE (directory);             /* __FREE_CHECKED__ */
 921           return -1;
 922         case  2:        /* no */
 923           FREE (directory);             /* __FREE_CHECKED__ */
 924           return 1;
 925       }
 926     }
 927     else if ((rc = mutt_yesorno (_("File is a directory, save under it?"), M_YES)) != M_YES)
 928       return (rc == M_NO) ? 1 : -1;
 929
 930     if (!attname || !attname[0])
 931     {
 932       tmp[0] = 0;
 933       if (mutt_get_field (_("File under directory: "), tmp, sizeof (tmp),
 934                                       M_FILE | M_CLEAR) != 0 || !tmp[0])
 935         return (-1);
 936       mutt_concat_path (fname, path, tmp, flen);
 937     }
 938     else
 939       mutt_concat_path (fname, path, mutt_basename (attname), flen);
 940   }
 941
 942   if (*append == 0 && access (fname, F_OK) == 0)
 943   {
 944     switch (mutt_multi_choice
 945             (_("File exists, (o)verwrite, (a)ppend, or (c)ancel?"), _("oac")))
 946     {
 947       case -1: /* abort */
 948         return -1;
 949       case 3:  /* cancel */
 950         return 1;
 951
 952       case 2: /* append */
 953         *append = M_SAVE_APPEND;
 954         break;
 955       case 1: /* overwrite */
 956         *append = M_SAVE_OVERWRITE;
 957         break;
 958     }
 959   }
 960   return 0;
 961 }
 962
 963 void mutt_save_path (char *d, size_t dsize, ADDRESS *a)
 964 {
 965   if (a && a->mailbox)
 966   {
 967     strfcpy (d, a->mailbox, dsize);
 968     if (!option (OPTSAVEADDRESS))
 969     {
 970       char *p;
 971
 972       if ((p = strpbrk (d, "%@")))
 973         *p = 0;
 974     }
 975     mutt_strlower (d);
 976   }
 977   else
 978     *d = 0;
 979 }
 980
 981 void mutt_safe_path (char *s, size_t l, ADDRESS *a)
 982 {
 983   char *p;
 984
 985   mutt_save_path (s, l, a);
 986   for (p = s; *p; p++)
 987     if (*p == '/' || ISSPACE (*p) || !IsPrint ((unsigned char) *p))
 988       *p = '_';
 989 }
 990
 991
 992 void mutt_FormatString (char *dest,             /* output buffer */
 993                         size_t destlen,         /* output buffer len */
 994                         size_t col,             /* starting column (nonzero when called recursively) */
 995                         const char *src,        /* template string */
 996                         format_t *callback,     /* callback for processing */
 997                         unsigned long data,     /* callback data */
 998                         format_flag flags)      /* callback flags */
 999 {
1000   char prefix[SHORT_STRING], buf[LONG_STRING], *cp, *wptr = dest, ch;
1001   char ifstring[SHORT_STRING], elsestring[SHORT_STRING];
1002   size_t wlen, count, len, wid;
1003   pid_t pid;
1004   FILE *filter;
1005   int n;
1006   char *recycler;
1007
1008   prefix[0] = '\0';
1009   destlen--; /* save room for the terminal \0 */
1010   wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
1011   col += wlen;
1012
1013   if ((flags & M_FORMAT_NOFILTER) == 0)
1014   {
1015     int off = -1;
1016
1017     /* Do not consider filters if no pipe at end */
1018     n = mutt_strlen(src);
1019     if (n > 1 && src[n-1] == '|')
1020     {
1021       /* Scan backwards for backslashes */
1022       off = n;
1023       while (off > 0 && src[off-2] == '\\')
1024         off--;
1025     }
1026
1027     /* If number of backslashes is even, the pipe is real. */
1028     /* n-off is the number of backslashes. */
1029     if (off > 0 && ((n-off) % 2) == 0)
1030     {
1031       BUFFER *srcbuf, *word, *command;
1032       char    srccopy[LONG_STRING];
1033 #ifdef DEBUG
1034       int     i = 0;
1035 #endif
1036
1037       dprint(3, (debugfile, "fmtpipe = %s\n", src));
1038
1039       strncpy(srccopy, src, n);
1040       srccopy[n-1] = '\0';
1041
1042       /* prepare BUFFERs */
1043       srcbuf = mutt_buffer_from(NULL, srccopy);
1044       srcbuf->dptr = srcbuf->data;
1045       word = mutt_buffer_init(NULL);
1046       command = mutt_buffer_init(NULL);
1047
1048       /* Iterate expansions across successive arguments */
1049       do {
1050         char *p;
1051
1052         /* Extract the command name and copy to command line */
1053         dprint(3, (debugfile, "fmtpipe +++: %s\n", srcbuf->dptr));
1054         if (word->data)
1055           *word->data = '\0';
1056         mutt_extract_token(word, srcbuf, 0);
1057         dprint(3, (debugfile, "fmtpipe %2d: %s\n", i++, word->data));
1058         mutt_buffer_addch(command, '\'');
1059         mutt_FormatString(buf, sizeof(buf), 0, word->data, callback, data,
1060                           flags | M_FORMAT_NOFILTER);
1061         for (p = buf; p && *p; p++)
1062         {
1063           if (*p == '\'')
1064             /* shell quoting doesn't permit escaping a single quote within
1065              * single-quoted material.  double-quoting instead will lead
1066              * shell variable expansions, so break out of the single-quoted
1067              * span, insert a double-quoted single quote, and resume. */
1068             mutt_buffer_addstr(command, "'\"'\"'");
1069           else
1070             mutt_buffer_addch(command, *p);
1071         }
1072         mutt_buffer_addch(command, '\'');
1073         mutt_buffer_addch(command, ' ');
1074       } while (MoreArgs(srcbuf));
1075
1076       dprint(3, (debugfile, "fmtpipe > %s\n", command->data));
1077
1078       col -= wlen;      /* reset to passed in value */
1079       wptr = dest;      /* reset write ptr */
1080       wlen = (flags & M_FORMAT_ARROWCURSOR && option (OPTARROWCURSOR)) ? 3 : 0;
1081       if ((pid = mutt_create_filter(command->data, NULL, &filter, NULL)))
1082       {
1083         n = fread(dest, 1, destlen /* already decremented */, filter);
1084         fclose(filter);
1085         dest[n] = '\0';
1086         while (dest[n-1] == '\n' || dest[n-1] == '\r')
1087           dest[--n] = '\0';
1088         dprint(3, (debugfile, "fmtpipe < %s\n", dest));
1089
1090         if (pid != -1)
1091           mutt_wait_filter(pid);
1092
1093         /* If the result ends with '%', this indicates that the filter
1094          * generated %-tokens that mutt can expand.  Eliminate the '%'
1095          * marker and recycle the string through mutt_FormatString().
1096          * To literally end with "%", use "%%". */
1097         if (dest[--n] == '%')
1098         {
1099           dest[n] = '\0';               /* remove '%' */
1100           if (dest[--n] != '%')
1101           {
1102             recycler = safe_strdup(dest);
1103             if (recycler)
1104             {
1105               mutt_FormatString(dest, destlen++, col, recycler, callback, data, flags);
1106               FREE(&recycler);
1107             }
1108           }
1109         }
1110       }
1111       else
1112       {
1113         /* Filter failed; erase write buffer */
1114         *wptr = '\0';
1115       }
1116
1117       mutt_buffer_free(&command);
1118       mutt_buffer_free(&srcbuf);
1119       mutt_buffer_free(&word);
1120       return;
1121     }
1122   }
1123
1124   while (*src && wlen < destlen)
1125   {
1126     if (*src == '%')
1127     {
1128       if (*++src == '%')
1129       {
1130         *wptr++ = '%';
1131         wlen++;
1132         col++;
1133         src++;
1134         continue;
1135       }
1136
1137       if (*src == '?')
1138       {
1139         flags |= M_FORMAT_OPTIONAL;
1140         src++;
1141       }
1142       else
1143       {
1144         flags &= ~M_FORMAT_OPTIONAL;
1145
1146         /* eat the format string */
1147         cp = prefix;
1148         count = 0;
1149         while (count < sizeof (prefix) &&
1150                (isdigit ((unsigned char) *src) || *src == '.' || *src == '-' || *src == '='))
1151         {
1152           *cp++ = *src++;
1153           count++;
1154         }
1155         *cp = 0;
1156       }
1157
1158       if (!*src)
1159         break; /* bad format */
1160
1161       ch = *src++; /* save the character to switch on */
1162
1163       if (flags & M_FORMAT_OPTIONAL)
1164       {
1165         if (*src != '?')
1166           break; /* bad format */
1167         src++;
1168
1169         /* eat the `if' part of the string */
1170         cp = ifstring;
1171         count = 0;
1172         while (count < sizeof (ifstring) && *src && *src != '?' && *src != '&')
1173         {
1174           *cp++ = *src++;
1175           count++;
1176         }
1177         *cp = 0;
1178
1179         /* eat the `else' part of the string (optional) */
1180         if (*src == '&')
1181           src++; /* skip the & */
1182         cp = elsestring;
1183         count = 0;
1184         while (count < sizeof (elsestring) && *src && *src != '?')
1185         {
1186           *cp++ = *src++;
1187           count++;
1188         }
1189         *cp = 0;
1190
1191         if (!*src)
1192           break; /* bad format */
1193
1194         src++; /* move past the trailing `?' */
1195       }
1196
1197       /* handle generic cases first */
1198       if (ch == '>' || ch == '*')
1199       {
1200         /* %>X: right justify to EOL, left takes precedence
1201          * %*X: right justify to EOL, right takes precedence */
1202         int soft = ch == '*';
1203         int pl, pw;
1204         if ((pl = mutt_charlen (src, &pw)) <= 0)
1205           pl = pw = 1;
1206
1207         /* see if there's room to add content, else ignore */
1208         if ((col < COLS && wlen < destlen) || soft)
1209         {
1210           int pad;
1211
1212           /* get contents after padding */
1213           mutt_FormatString (buf, sizeof (buf), 0, src + pl, callback, data, flags);
1214           len = mutt_strlen (buf);
1215           wid = mutt_strwidth (buf);
1216
1217           /* try to consume as many columns as we can, if we don't have
1218            * memory for that, use as much memory as possible */
1219           pad = (COLS - col - wid) / pw;
1220           if (pad > 0 && wlen + (pad * pl) + len > destlen)
1221             pad = ((signed)(destlen - wlen - len)) / pl;
1222           if (pad > 0)
1223           {
1224             while (pad--)
1225             {
1226               memcpy (wptr, src, pl);
1227               wptr += pl;
1228               wlen += pl;
1229               col += pw;
1230             }
1231           }
1232           else if (soft && pad < 0)
1233           {
1234             /* \0-terminate dest for length computation in mutt_wstr_trunc() */
1235             *wptr = 0;
1236             /* make sure right part is at most as wide as display */
1237             len = mutt_wstr_trunc (buf, destlen, COLS, &wid);
1238             /* truncate left so that right part fits completely in */
1239             wlen = mutt_wstr_trunc (dest, destlen - len, col + pad, &col);
1240             wptr = dest + wlen;
1241           }
1242           if (len + wlen > destlen)
1243             len = mutt_wstr_trunc (buf, destlen - wlen, COLS - col, NULL);
1244           memcpy (wptr, buf, len);
1245           wptr += len;
1246           wlen += len;
1247           col += wid;
1248           src += pl;
1249         }
1250         break; /* skip rest of input */
1251       }
1252       else if (ch == '|')
1253       {
1254         /* pad to EOL */
1255         int pl, pw, c;
1256         if ((pl = mutt_charlen (src, &pw)) <= 0)
1257           pl = pw = 1;
1258
1259         /* see if there's room to add content, else ignore */
1260         if (col < COLS && wlen < destlen)
1261         {
1262           c = (COLS - col) / pw;
1263           if (c > 0 && wlen + (c * pl) > destlen)
1264             c = ((signed)(destlen - wlen)) / pl;
1265           while (c > 0)
1266           {
1267             memcpy (wptr, src, pl);
1268             wptr += pl;
1269             wlen += pl;
1270             col += pw;
1271             c--;
1272           }
1273           src += pl;
1274         }
1275         break; /* skip rest of input */
1276       }
1277       else
1278       {
1279         short tolower =  0;
1280         short nodots  = 0;
1281
1282         while (ch == '_' || ch == ':')
1283         {
1284           if (ch == '_')
1285             tolower = 1;
1286           else if (ch == ':')
1287             nodots = 1;
1288
1289           ch = *src++;
1290         }
1291
1292         /* use callback function to handle this case */
1293         src = callback (buf, sizeof (buf), col, ch, src, prefix, ifstring, elsestring, data, flags);
1294
1295         if (tolower)
1296           mutt_strlower (buf);
1297         if (nodots)
1298         {
1299           char *p = buf;
1300           for (; *p; p++)
1301             if (*p == '.')
1302                 *p = '_';
1303         }
1304
1305         if ((len = mutt_strlen (buf)) + wlen > destlen)
1306           len = mutt_wstr_trunc (buf, destlen - wlen, COLS - col, NULL);
1307
1308         memcpy (wptr, buf, len);
1309         wptr += len;
1310         wlen += len;
1311         col += mutt_strwidth (buf);
1312       }
1313     }
1314     else if (*src == '\\')
1315     {
1316       if (!*++src)
1317         break;
1318       switch (*src)
1319       {
1320         case 'n':
1321           *wptr = '\n';
1322           break;
1323         case 't':
1324           *wptr = '\t';
1325           break;
1326         case 'r':
1327           *wptr = '\r';
1328           break;
1329         case 'f':
1330           *wptr = '\f';
1331           break;
1332         case 'v':
1333           *wptr = '\v';
1334           break;
1335         default:
1336           *wptr = *src;
1337           break;
1338       }
1339       src++;
1340       wptr++;
1341       wlen++;
1342       col++;
1343     }
1344     else
1345     {
1346       int tmp, w;
1347       /* in case of error, simply copy byte */
1348       if ((tmp = mutt_charlen (src, &w)) < 0)
1349         tmp = w = 1;
1350       if (tmp > 0 && wlen + tmp < destlen)
1351       {
1352         memcpy (wptr, src, tmp);
1353         wptr += tmp;
1354         src += tmp;
1355         wlen += tmp;
1356         col += w;
1357       }
1358       else
1359       {
1360         src += destlen - wlen;
1361         wlen = destlen;
1362       }
1363     }
1364   }
1365   *wptr = 0;
1366
1367 #if 0
1368   if (flags & M_FORMAT_MAKEPRINT)
1369   {
1370     /* Make sure that the string is printable by changing all non-printable
1371        chars to dots, or spaces for non-printable whitespace */
1372     for (cp = dest ; *cp ; cp++)
1373       if (!IsPrint (*cp) &&
1374           !((flags & M_FORMAT_TREE) && (*cp <= M_TREE_MAX)))
1375         *cp = isspace ((unsigned char) *cp) ? ' ' : '.';
1376   }
1377 #endif
1378 }
1379
1380 /* This function allows the user to specify a command to read stdout from in
1381    place of a normal file.  If the last character in the string is a pipe (|),
1382    then we assume it is a commmand to run instead of a normal file. */
1383 FILE *mutt_open_read (const char *path, pid_t *thepid)
1384 {
1385   FILE *f;
1386   struct stat s;
1387
1388   int len = mutt_strlen (path);
1389
1390   if (path[len - 1] == '|')
1391   {
1392     /* read from a pipe */
1393
1394     char *s = safe_strdup (path);
1395
1396     s[len - 1] = 0;
1397     mutt_endwin (NULL);
1398     *thepid = mutt_create_filter (s, NULL, &f, NULL);
1399     FREE (&s);
1400   }
1401   else
1402   {
1403     if (stat (path, &s) < 0)
1404       return (NULL);
1405     if (S_ISDIR (s.st_mode))
1406     {
1407       errno = EINVAL;
1408       return (NULL);
1409     }
1410     f = fopen (path, "r");
1411     *thepid = -1;
1412   }
1413   return (f);
1414 }
1415
1416 /* returns 0 if OK to proceed, -1 to abort, 1 to retry */
1417 int mutt_save_confirm (const char *s, struct stat *st)
1418 {
1419   char tmp[_POSIX_PATH_MAX];
1420   int ret = 0;
1421   int rc;
1422   int magic = 0;
1423
1424   magic = mx_get_magic (s);
1425
1426 #ifdef USE_POP
1427   if (magic == M_POP)
1428   {
1429     mutt_error _("Can't save message to POP mailbox.");
1430     return 1;
1431   }
1432 #endif
1433
1434   if (magic > 0 && !mx_access (s, W_OK))
1435   {
1436     if (option (OPTCONFIRMAPPEND))
1437     {
1438       snprintf (tmp, sizeof (tmp), _("Append messages to %s?"), s);
1439       if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
1440         ret = 1;
1441       else if (rc == -1)
1442         ret = -1;
1443     }
1444   }
1445
1446   if (stat (s, st) != -1)
1447   {
1448     if (magic == -1)
1449     {
1450       mutt_error (_("%s is not a mailbox!"), s);
1451       return 1;
1452     }
1453   }
1454   else
1455 #ifdef USE_IMAP
1456   if (magic != M_IMAP)
1457 #endif /* execute the block unconditionally if we don't use imap */
1458   {
1459     st->st_mtime = 0;
1460     st->st_atime = 0;
1461
1462     if (errno == ENOENT)
1463     {
1464       if (option (OPTCONFIRMCREATE))
1465       {
1466         snprintf (tmp, sizeof (tmp), _("Create %s?"), s);
1467         if ((rc = mutt_yesorno (tmp, M_YES)) == M_NO)
1468           ret = 1;
1469         else if (rc == -1)
1470           ret = -1;
1471       }
1472     }
1473     else
1474     {
1475       mutt_perror (s);
1476       return 1;
1477     }
1478   }
1479
1480   CLEARLINE (LINES-1);
1481   return (ret);
1482 }
1483
1484 void state_prefix_putc (char c, STATE *s)
1485 {
1486   if (s->flags & M_PENDINGPREFIX)
1487   {
1488     state_reset_prefix (s);
1489     if (s->prefix)
1490       state_puts (s->prefix, s);
1491   }
1492
1493   state_putc (c, s);
1494
1495   if (c == '\n')
1496     state_set_prefix (s);
1497 }
1498
1499 int state_printf (STATE *s, const char *fmt, ...)
1500 {
1501   int rv;
1502   va_list ap;
1503
1504   va_start (ap, fmt);
1505   rv = vfprintf (s->fpout, fmt, ap);
1506   va_end (ap);
1507
1508   return rv;
1509 }
1510
1511 void state_mark_attach (STATE *s)
1512 {
1513   if ((s->flags & M_DISPLAY) && !mutt_strcmp (Pager, "builtin"))
1514     state_puts (AttachmentMarker, s);
1515 }
1516
1517 void state_attach_puts (const char *t, STATE *s)
1518 {
1519   if (*t != '\n') state_mark_attach (s);
1520   while (*t)
1521   {
1522     state_putc (*t, s);
1523     if (*t++ == '\n' && *t)
1524       if (*t != '\n') state_mark_attach (s);
1525   }
1526 }
1527
1528 void mutt_display_sanitize (char *s)
1529 {
1530   for (; *s; s++)
1531   {
1532     if (!IsPrint (*s))
1533       *s = '?';
1534   }
1535 }
1536
1537 void mutt_sleep (short s)
1538 {
1539   if (SleepTime > s)
1540     sleep (SleepTime);
1541   else if (s)
1542     sleep (s);
1543 }
1544
1545 /*
1546  * Creates and initializes a BUFFER*. If passed an existing BUFFER*,
1547  * just initializes. Frees anything already in the buffer.
1548  *
1549  * Disregards the 'destroy' flag, which seems reserved for caller.
1550  * This is bad, but there's no apparent protocol for it.
1551  */
1552 BUFFER * mutt_buffer_init(BUFFER *b)
1553 {
1554   if (!b)
1555   {
1556     b = safe_malloc(sizeof(BUFFER));
1557     if (!b)
1558       return NULL;
1559   }
1560   else
1561   {
1562     FREE(&b->data);
1563   }
1564   memset(b, 0, sizeof(BUFFER));
1565   return b;
1566 }
1567
1568 /*
1569  * Creates and initializes a BUFFER*. If passed an existing BUFFER*,
1570  * just initializes. Frees anything already in the buffer. Copies in
1571  * the seed string.
1572  *
1573  * Disregards the 'destroy' flag, which seems reserved for caller.
1574  * This is bad, but there's no apparent protocol for it.
1575  */
1576 BUFFER * mutt_buffer_from(BUFFER *b, char *seed)
1577 {
1578   if (!seed)
1579     return NULL;
1580
1581   b = mutt_buffer_init(b);
1582   b->data = safe_strdup (seed);
1583   b->dsize = mutt_strlen (seed);
1584   b->dptr = (char *) b->data + b->dsize;
1585   return b;
1586 }
1587
1588 int mutt_buffer_printf (BUFFER* buf, const char* fmt, ...)
1589 {
1590   va_list ap, ap_retry;
1591   int len, blen, doff;
1592
1593   va_start (ap, fmt);
1594   va_copy (ap_retry, ap);
1595
1596   doff = buf->dptr - buf->data;
1597   blen = buf->dsize - doff;
1598   /* solaris 9 vsnprintf barfs when blen is 0 */
1599   if (!blen)
1600   {
1601     blen = 128;
1602     buf->dsize += blen;
1603     safe_realloc (&buf->data, buf->dsize);
1604     buf->dptr = buf->data + doff;
1605   }
1606   if ((len = vsnprintf (buf->dptr, blen, fmt, ap)) >= blen)
1607   {
1608     blen = ++len - blen;
1609     if (blen < 128)
1610       blen = 128;
1611     buf->dsize += blen;
1612     safe_realloc (&buf->data, buf->dsize);
1613     buf->dptr = buf->data + doff;
1614     len = vsnprintf (buf->dptr, len, fmt, ap_retry);
1615     va_end (ap_retry);
1616   }
1617   if (len > 0)
1618     buf->dptr += len;
1619
1620   va_end (ap);
1621
1622   return len;
1623 }
1624
1625 void mutt_buffer_addstr (BUFFER* buf, const char* s)
1626 {
1627   mutt_buffer_add (buf, s, mutt_strlen (s));
1628 }
1629
1630 void mutt_buffer_addch (BUFFER* buf, char c)
1631 {
1632   mutt_buffer_add (buf, &c, 1);
1633 }
1634
1635 void mutt_buffer_free (BUFFER **p)
1636 {
1637   if (!p || !*p)
1638     return;
1639
1640    FREE(&(*p)->data);
1641    /* dptr is just an offset to data and shouldn't be freed */
1642    FREE(p);             /* __FREE_CHECKED__ */
1643 }
1644
1645 /* dynamically grows a BUFFER to accomodate s, in increments of 128 bytes.
1646  * Always one byte bigger than necessary for the null terminator, and
1647  * the buffer is always null-terminated */
1648 void mutt_buffer_add (BUFFER* buf, const char* s, size_t len)
1649 {
1650   size_t offset;
1651
1652   if (buf->dptr + len + 1 > buf->data + buf->dsize)
1653   {
1654     offset = buf->dptr - buf->data;
1655     buf->dsize += len < 128 ? 128 : len + 1;
1656     /* suppress compiler aliasing warning */
1657     safe_realloc ((void**) (void*) &buf->data, buf->dsize);
1658     buf->dptr = buf->data + offset;
1659   }
1660   memcpy (buf->dptr, s, len);
1661   buf->dptr += len;
1662   *(buf->dptr) = '\0';
1663 }
1664
1665 /* Decrease a file's modification time by 1 second */
1666
1667 time_t mutt_decrease_mtime (const char *f, struct stat *st)
1668 {
1669   struct utimbuf utim;
1670   struct stat _st;
1671   time_t mtime;
1672
1673   if (!st)
1674   {
1675     if (stat (f, &_st) == -1)
1676       return -1;
1677     st = &_st;
1678   }
1679
1680   if ((mtime = st->st_mtime) == time (NULL))
1681   {
1682     mtime -= 1;
1683     utim.actime = mtime;
1684     utim.modtime = mtime;
1685     utime (f, &utim);
1686   }
1687
1688   return mtime;
1689 }
1690
1691 /* sets mtime of 'to' to mtime of 'from' */
1692 void mutt_set_mtime (const char* from, const char* to)
1693 {
1694   struct utimbuf utim;
1695   struct stat st;
1696
1697   if (stat (from, &st) != -1)
1698   {
1699     utim.actime = st.st_mtime;
1700     utim.modtime = st.st_mtime;
1701     utime (to, &utim);
1702   }
1703 }
1704
1705 const char *mutt_make_version (void)
1706 {
1707   static char vstring[STRING];
1708   snprintf (vstring, sizeof (vstring), "Mutt %s (%s)",
1709             MUTT_VERSION, ReleaseDate);
1710   return vstring;
1711 }
1712
1713 REGEXP *mutt_compile_regexp (const char *s, int flags)
1714 {
1715   REGEXP *pp = safe_calloc (sizeof (REGEXP), 1);
1716   pp->pattern = safe_strdup (s);
1717   pp->rx = safe_calloc (sizeof (regex_t), 1);
1718   if (REGCOMP (pp->rx, NONULL(s), flags) != 0)
1719     mutt_free_regexp (&pp);
1720
1721   return pp;
1722 }
1723
1724 void mutt_free_regexp (REGEXP **pp)
1725 {
1726   FREE (&(*pp)->pattern);
1727   regfree ((*pp)->rx);
1728   FREE (&(*pp)->rx);
1729   FREE (pp);            /* __FREE_CHECKED__ */
1730 }
1731
1732 void mutt_free_rx_list (RX_LIST **list)
1733 {
1734   RX_LIST *p;
1735
1736   if (!list) return;
1737   while (*list)
1738   {
1739     p = *list;
1740     *list = (*list)->next;
1741     mutt_free_regexp (&p->rx);
1742     FREE (&p);
1743   }
1744 }
1745
1746 void mutt_free_spam_list (SPAM_LIST **list)
1747 {
1748   SPAM_LIST *p;
1749
1750   if (!list) return;
1751   while (*list)
1752   {
1753     p = *list;
1754     *list = (*list)->next;
1755     mutt_free_regexp (&p->rx);
1756     FREE (&p->template);
1757     FREE (&p);
1758   }
1759 }
1760
1761 int mutt_match_rx_list (const char *s, RX_LIST *l)
1762 {
1763   if (!s)  return 0;
1764
1765   for (; l; l = l->next)
1766   {
1767     if (regexec (l->rx->rx, s, (size_t) 0, (regmatch_t *) 0, (int) 0) == 0)
1768     {
1769       dprint (5, (debugfile, "mutt_match_rx_list: %s matches %s\n", s, l->rx->pattern));
1770       return 1;
1771     }
1772   }
1773
1774   return 0;
1775 }
1776
1777 int mutt_match_spam_list (const char *s, SPAM_LIST *l, char *text, int x)
1778 {
1779   static regmatch_t *pmatch = NULL;
1780   static int nmatch = 0;
1781   int i, n, tlen;
1782   char *p;
1783
1784   if (!s)  return 0;
1785
1786   tlen = 0;
1787
1788   for (; l; l = l->next)
1789   {
1790     /* If this pattern needs more matches, expand pmatch. */
1791     if (l->nmatch > nmatch)
1792     {
1793       safe_realloc (&pmatch, l->nmatch * sizeof(regmatch_t));
1794       nmatch = l->nmatch;
1795     }
1796
1797     /* Does this pattern match? */
1798     if (regexec (l->rx->rx, s, (size_t) l->nmatch, (regmatch_t *) pmatch, (int) 0) == 0)
1799     {
1800       dprint (5, (debugfile, "mutt_match_spam_list: %s matches %s\n", s, l->rx->pattern));
1801       dprint (5, (debugfile, "mutt_match_spam_list: %d subs\n", (int)l->rx->rx->re_nsub));
1802
1803       /* Copy template into text, with substitutions. */
1804       for (p = l->template; *p;)
1805       {
1806         if (*p == '%')
1807         {
1808           n = atoi(++p);                        /* find pmatch index */
1809           while (isdigit((unsigned char)*p))
1810             ++p;                                /* skip subst token */
1811           for (i = pmatch[n].rm_so; (i < pmatch[n].rm_eo) && (tlen < x); i++)
1812             text[tlen++] = s[i];
1813         }
1814         else
1815         {
1816           text[tlen++] = *p++;
1817         }
1818       }
1819       text[tlen] = '\0';
1820       dprint (5, (debugfile, "mutt_match_spam_list: \"%s\"\n", text));
1821       return 1;
1822     }
1823   }
1824
1825   return 0;
1826 }
1827