chiark - git - mdw - disorder/blob - lib/mime.c

   1 /*
   2  * This file is part of DisOrder
   3  * Copyright (C) 2005, 2007-10, 2013 Richard Kettlewell
   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 3 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, see <http://www.gnu.org/licenses/>.
  17  */
  18 /** @file lib/mime.c
  19  * @brief Support for MIME and allied protocols
  20  */
  21
  22 #include "common.h"
  23
  24 #include <ctype.h>
  25
  26 #include "mem.h"
  27 #include "mime.h"
  28 #include "vector.h"
  29 #include "hex.h"
  30 #include "log.h"
  31 #include "base64.h"
  32 #include "kvp.h"
  33 #include "printf.h"
  34
  35 /** @brief Match whitespace characters */
  36 static int whitespace(int c) {
  37   switch(c) {
  38   case ' ':
  39   case '\t':
  40   case '\r':
  41   case '\n':
  42     return 1;
  43   default:
  44     return 0;
  45   }
  46 }
  47
  48 /** @brief Match RFC2045 tspecial characters */
  49 int mime_tspecial(int c) {
  50   switch(c) {
  51   case '(':
  52   case ')':
  53   case '<':
  54   case '>':
  55   case '@':
  56   case ',':
  57   case ';':
  58   case ':':
  59   case '\\':
  60   case '"':
  61   case '/':
  62   case '[':
  63   case ']':
  64   case '?':
  65   case '=':
  66     return 1;
  67   default:
  68     return 0;
  69   }
  70 }
  71
  72 /** @brief Match RFC2616 separator characters */
  73 int mime_http_separator(int c) {
  74   switch(c) {
  75   case '(':
  76   case ')':
  77   case '<':
  78   case '>':
  79   case '@':
  80   case ',':
  81   case ';':
  82   case ':':
  83   case '\\':
  84   case '"':
  85   case '/':
  86   case '[':
  87   case ']':
  88   case '?':
  89   case '=':
  90   case '{':
  91   case '}':
  92   case ' ':
  93   case '\t':
  94     return 1;
  95   default:
  96     return 0;
  97   }
  98 }
  99
 100 /** @brief Match CRLF */
 101 static int iscrlf(const char *ptr) {
 102   return ptr[0] == '\r' && ptr[1] == '\n';
 103 }
 104
 105 /** @brief Skip whitespace
 106  * @param s Pointer into string
 107  * @param rfc822_comments If true, skip RFC822 nested comments
 108  * @return Pointer into string after whitespace
 109  */
 110 static const char *skipwhite(const char *s, int rfc822_comments) {
 111   int c, depth;
 112
 113   for(;;) {
 114     switch(*s) {
 115     case ' ':
 116     case '\t':
 117     case '\r':
 118     case '\n':
 119       ++s;
 120       break;
 121     case '(':
 122       if(!rfc822_comments)
 123         return s;
 124       ++s;
 125       depth = 1;
 126       while(*s && depth) {
 127         c = *s++;
 128         switch(c) {
 129         case '(': ++depth; break;
 130         case ')': --depth; break;
 131         case '\\':
 132           if(!*s)
 133             return 0;
 134           ++s;
 135           break;
 136         }
 137       }
 138       if(depth)
 139         return 0;
 140       break;
 141     default:
 142       return s;
 143     }
 144   }
 145 }
 146
 147 /** @brief Test for a word character
 148  * @param c Character to test
 149  * @param special mime_tspecial() (MIME/RFC2405) or mime_http_separator() (HTTP/RFC2616)
 150  * @return 1 if @p c is a word character, else 0
 151  */
 152 static int iswordchar(int c, int (*special)(int)) {
 153   return !(c <= ' ' || c > '~' || special(c));
 154 }
 155
 156 /** @brief Parse an RFC1521/RFC2616 word
 157  * @param s Pointer to start of word
 158  * @param valuep Where to store value
 159  * @param special mime_tspecial() (MIME/RFC2405) or mime_http_separator() (HTTP/RFC2616)
 160  * @return Pointer just after end of word or NULL if there's no word
 161  *
 162  * A word is a token or a quoted-string.
 163  */
 164 const char *mime_parse_word(const char *s, char **valuep,
 165                             int (*special)(int)) {
 166   struct dynstr value[1];
 167   int c;
 168
 169   dynstr_init(value);
 170   if(*s == '"') {
 171     ++s;
 172     while((c = *s++) != '"') {
 173       switch(c) {
 174       case '\\':
 175         if(!(c = *s++))
 176           return 0;
 177       default:
 178         dynstr_append(value, c);
 179         break;
 180       }
 181     }
 182     if(!c)
 183       return 0;
 184   } else {
 185     if(!iswordchar((unsigned char)*s, special))
 186       return NULL;
 187     dynstr_init(value);
 188     while(iswordchar((unsigned char)*s, special))
 189       dynstr_append(value, *s++);
 190   }
 191   dynstr_terminate(value);
 192   *valuep = value->vec;
 193   return s;
 194 }
 195
 196 /** @brief Parse an RFC1521/RFC2616 token
 197  * @param s Pointer to start of token
 198  * @param valuep Where to store value
 199  * @param special mime_tspecial() (MIME/RFC2405) or mime_http_separator() (HTTP/RFC2616)
 200  * @return Pointer just after end of token or NULL if there's no token
 201  */
 202 static const char *parsetoken(const char *s, char **valuep,
 203                               int (*special)(int)) {
 204   if(*s == '"')
 205     return 0;
 206   return mime_parse_word(s, valuep, special);
 207 }
 208
 209 /** @brief Parse a MIME content-type field
 210  * @param s Start of field
 211  * @param typep Where to store type
 212  * @param parametersp Where to store parameter list
 213  * @return 0 on success, non-0 on error
 214  *
 215  * See <a href="http://tools.ietf.org/html/rfc2045#section-5">RFC 2045 s5</a>.
 216  */
 217 int mime_content_type(const char *s,
 218                       char **typep,
 219                       struct kvp **parametersp) {
 220   struct dynstr type, parametername;
 221   struct kvp *parameters = 0;
 222   char *parametervalue;
 223
 224   dynstr_init(&type);
 225   if(!(s = skipwhite(s, 1)))
 226     return -1;
 227   if(!*s)
 228     return -1;
 229   while(*s && !mime_tspecial(*s) && !whitespace(*s))
 230     dynstr_append(&type, tolower((unsigned char)*s++));
 231   if(!(s = skipwhite(s, 1)))
 232     return -1;
 233   if(*s++ != '/')
 234     return -1;
 235   dynstr_append(&type, '/');
 236   if(!(s = skipwhite(s, 1)))
 237     return -1;
 238   while(*s && !mime_tspecial(*s) && !whitespace(*s))
 239     dynstr_append(&type, tolower((unsigned char)*s++));
 240   if(!(s = skipwhite(s, 1)))
 241     return -1;
 242
 243   while(*s == ';') {
 244     dynstr_init(&parametername);
 245     ++s;
 246     if(!(s = skipwhite(s, 1)))
 247       return -1;
 248     if(!*s)
 249       return -1;
 250     while(*s && !mime_tspecial(*s) && !whitespace(*s))
 251       dynstr_append(&parametername, tolower((unsigned char)*s++));
 252     if(!(s = skipwhite(s, 1)))
 253       return -1;
 254     if(*s++ != '=')
 255       return -1;
 256     if(!(s = skipwhite(s, 1)))
 257       return -1;
 258     if(!(s = mime_parse_word(s, &parametervalue, mime_tspecial)))
 259       return -1;
 260     if(!(s = skipwhite(s, 1)))
 261       return -1;
 262     dynstr_terminate(&parametername);
 263     kvp_set(&parameters, parametername.vec, parametervalue);
 264   }
 265   dynstr_terminate(&type);
 266   *typep = type.vec;
 267   *parametersp = parameters;
 268   return 0;
 269 }
 270
 271 /** @brief Parse a MIME message
 272  * @param s Start of message
 273  * @param callback Called for each header field
 274  * @param u Passed to callback
 275  * @return Pointer to decoded body (might be in original string), or NULL on error
 276  *
 277  * This does an RFC 822-style parse and honors Content-Transfer-Encoding as
 278  * described in <a href="http://tools.ietf.org/html/rfc2045#section-6">RFC 2045
 279  * s6</a>.  @p callback is called for each header field encountered, in order,
 280  * with ASCII characters in the header name forced to lower case.
 281  */
 282 const char *mime_parse(const char *s,
 283                        int (*callback)(const char *name, const char *value,
 284                                        void *u),
 285                        void *u) {
 286   struct dynstr name, value;
 287   char *cte = 0, *p;
 288
 289   while(*s && !iscrlf(s)) {
 290     dynstr_init(&name);
 291     dynstr_init(&value);
 292     while(*s && !mime_tspecial(*s) && !whitespace(*s))
 293       dynstr_append(&name, tolower((unsigned char)*s++));
 294     if(!(s = skipwhite(s, 1)))
 295       return 0;
 296     if(*s != ':')
 297       return 0;
 298     ++s;
 299     while(*s && !(*s == '\n' && !(s[1] == ' ' || s[1] == '\t'))) {
 300       const int c = *s++;
 301       /* Strip leading whitespace */
 302       if(value.nvec || !(c == ' ' || c == '\t' || c == '\n' || c == '\r'))
 303         dynstr_append(&value, c);
 304     }
 305     /* Strip trailing whitespace */
 306     while(value.nvec > 0 && (value.vec[value.nvec - 1] == ' '
 307                              || value.vec[value.nvec - 1] == '\t'
 308                              || value.vec[value.nvec - 1] == '\n'
 309                              || value.vec[value.nvec - 1] == '\r'))
 310       --value.nvec;
 311     if(*s)
 312       ++s;
 313     dynstr_terminate(&name);
 314     dynstr_terminate(&value);
 315     if(!strcmp(name.vec, "content-transfer-encoding")) {
 316       cte = xstrdup(value.vec);
 317       for(p = cte; *p; p++)
 318         *p = tolower((unsigned char)*p);
 319     }
 320     if(callback(name.vec, value.vec, u))
 321       return 0;
 322   }
 323   if(*s)
 324     s += 2;
 325   if(cte) {
 326     if(!strcmp(cte, "base64"))
 327       return mime_base64(s, 0);
 328     if(!strcmp(cte, "quoted-printable"))
 329       return mime_qp(s);
 330     if(!strcmp(cte, "7bit") || !strcmp(cte, "8bit"))
 331       return s;
 332     disorder_error(0, "unknown content-transfer-encoding '%s'", cte);
 333     return 0;
 334   }
 335   return s;
 336 }
 337
 338 /** @brief Match the boundary string */
 339 static int isboundary(const char *ptr, const char *boundary, size_t bl) {
 340   return (ptr[0] == '-'
 341           && ptr[1] == '-'
 342           && !strncmp(ptr + 2, boundary, bl)
 343           && (iscrlf(ptr + bl + 2)
 344               || (ptr[bl + 2] == '-'
 345                   && ptr[bl + 3] == '-'
 346                   && (iscrlf(ptr + bl + 4) || *(ptr + bl + 4) == 0))));
 347 }
 348
 349 /** @brief Match the final boundary string */
 350 static int isfinal(const char *ptr, const char *boundary, size_t bl) {
 351   return (ptr[0] == '-'
 352           && ptr[1] == '-'
 353           && !strncmp(ptr + 2, boundary, bl)
 354           && ptr[bl + 2] == '-'
 355           && ptr[bl + 3] == '-'
 356           && (iscrlf(ptr + bl + 4) || *(ptr + bl + 4) == 0));
 357 }
 358
 359 /** @brief Parse a multipart MIME body
 360  * @param s Start of message
 361  * @param callback Callback for each part
 362  * @param boundary Boundary string
 363  * @param u Passed to callback
 364  * @return 0 on success, non-0 on error
 365  *
 366  * See <a href="http://tools.ietf.org/html/rfc2046#section-5.1">RFC 2046
 367  * s5.1</a>.  @p callback is called for each part (not yet decoded in any way)
 368  * in succession; you should probably call mime_parse() for each part.
 369  */
 370 int mime_multipart(const char *s,
 371                    int (*callback)(const char *s, void *u),
 372                    const char *boundary,
 373                    void *u) {
 374   size_t bl = strlen(boundary);
 375   const char *start, *e;
 376   int ret;
 377
 378   /* We must start with a boundary string */
 379   if(!isboundary(s, boundary, bl)) {
 380     disorder_error(0, "mime_multipart: first line is not the boundary string");
 381     return -1;
 382   }
 383   /* Keep going until we hit a final boundary */
 384   while(!isfinal(s, boundary, bl)) {
 385     s = strstr(s, "\r\n") + 2;
 386     start = s;
 387     while(!isboundary(s, boundary, bl)) {
 388       if(!(e = strstr(s, "\r\n"))) {
 389         disorder_error(0, "mime_multipart: line does not end CRLF");
 390         return -1;
 391       }
 392       s = e + 2;
 393     }
 394     if((ret = callback(xstrndup(start,
 395                                 s == start ? 0 : s - start - 2),
 396                        u)))
 397       return ret;
 398   }
 399   return 0;
 400 }
 401
 402 /** @brief Parse an RFC2388-style content-disposition field
 403  * @param s Start of field
 404  * @param dispositionp Where to store disposition
 405  * @param parameternamep Where to store parameter name
 406  * @param parametervaluep Where to store parameter value
 407  * @return 0 on success, non-0 on error
 408  *
 409  * See <a href="http://tools.ietf.org/html/rfc2388#section-3">RFC 2388 s3</a>
 410  * and <a href="http://tools.ietf.org/html/rfc2183">RFC 2183</a>.
 411  */
 412 int mime_rfc2388_content_disposition(const char *s,
 413                                      char **dispositionp,
 414                                      char **parameternamep,
 415                                      char **parametervaluep) {
 416   struct dynstr disposition, parametername;
 417
 418   dynstr_init(&disposition);
 419   if(!(s = skipwhite(s, 1)))
 420     return -1;
 421   if(!*s)
 422     return -1;
 423   while(*s && !mime_tspecial(*s) && !whitespace(*s))
 424     dynstr_append(&disposition, tolower((unsigned char)*s++));
 425   if(!(s = skipwhite(s, 1)))
 426     return -1;
 427
 428   if(*s == ';') {
 429     dynstr_init(&parametername);
 430     ++s;
 431     if(!(s = skipwhite(s, 1)))
 432       return -1;
 433     if(!*s)
 434       return -1;
 435     while(*s && !mime_tspecial(*s) && !whitespace(*s))
 436       dynstr_append(&parametername, tolower((unsigned char)*s++));
 437     if(!(s = skipwhite(s, 1)))
 438       return -1;
 439     if(*s++ != '=')
 440       return -1;
 441     if(!(s = skipwhite(s, 1)))
 442       return -1;
 443     if(!(s = mime_parse_word(s, parametervaluep, mime_tspecial)))
 444       return -1;
 445     if(!(s = skipwhite(s, 1)))
 446       return -1;
 447     dynstr_terminate(&parametername);
 448     *parameternamep = parametername.vec;
 449   } else
 450     *parametervaluep = *parameternamep = 0;
 451   dynstr_terminate(&disposition);
 452   *dispositionp = disposition.vec;
 453   return 0;
 454 }
 455
 456 /** @brief Convert MIME quoted-printable
 457  * @param s Quoted-printable data
 458  * @return Decoded data
 459  *
 460  * See <a href="http://tools.ietf.org/html/rfc2045#section-6.7">RFC 2045
 461  * s6.7</a>.
 462  */
 463 char *mime_qp(const char *s) {
 464   struct dynstr d;
 465   int c, a, b;
 466   const char *t;
 467
 468   dynstr_init(&d);
 469   while((c = *s++)) {
 470     switch(c) {
 471     case '=':
 472       if((a = unhexdigitq(s[0])) != -1
 473          && (b = unhexdigitq(s[1])) != -1) {
 474         dynstr_append(&d, a * 16 + b);
 475         s += 2;
 476       } else {
 477         t = s;
 478         while(*t == ' ' || *t == '\t') ++t;
 479         if(iscrlf(t)) {
 480           /* soft line break */
 481           s = t + 2;
 482         } else
 483           return 0;
 484       }
 485       break;
 486     case ' ':
 487     case '\t':
 488       t = s;
 489       while(*t == ' ' || *t == '\t') ++t;
 490       if(iscrlf(t))
 491         /* trailing space is always eliminated */
 492         s = t;
 493       else
 494         dynstr_append(&d, c);
 495       break;
 496     default:
 497       dynstr_append(&d, c);
 498       break;
 499     }
 500   }
 501   dynstr_terminate(&d);
 502   return d.vec;
 503 }
 504
 505 /** @brief Match cookie separator characters
 506  *
 507  * This is a subset of the RFC2616 specials, and technically is in breach of
 508  * the specification.  However rejecting (in particular) slashes is
 509  * unreasonably strict and has broken at least one (admittedly somewhat
 510  * obscure) browser, so we're more forgiving.
 511  */
 512 static int cookie_separator(int c) {
 513   switch(c) {
 514   case '(':
 515   case ')':
 516   case ',':
 517   case ';':
 518   case '=':
 519   case ' ':
 520   case '"':
 521   case '\t':
 522     return 1;
 523
 524   default:
 525     return 0;
 526   }
 527 }
 528
 529 /** @brief Match cookie value separator characters
 530  *
 531  * Same as cookie_separator() but allows for @c = in cookie values.
 532  */
 533 static int cookie_value_separator(int c) {
 534   switch(c) {
 535   case '(':
 536   case ')':
 537   case ',':
 538   case ';':
 539   case ' ':
 540   case '"':
 541   case '\t':
 542     return 1;
 543
 544   default:
 545     return 0;
 546   }
 547 }
 548
 549 /** @brief Parse a RFC2109 Cookie: header
 550  * @param s Header field value
 551  * @param cd Where to store result
 552  * @return 0 on success, non-0 on error
 553  *
 554  * See <a href="http://tools.ietf.org/html/rfc2109">RFC 2109</a>.
 555  */
 556 int parse_cookie(const char *s,
 557                  struct cookiedata *cd) {
 558   char *n = 0, *v = 0;
 559
 560   memset(cd, 0, sizeof *cd);
 561   s = skipwhite(s, 0);
 562   while(*s) {
 563     /* Skip separators */
 564     if(*s == ';' || *s == ',') {
 565       ++s;
 566       s = skipwhite(s, 0);
 567       continue;
 568     }
 569     if(!(s = parsetoken(s, &n, cookie_separator))) {
 570       disorder_error(0, "parse_cookie: cannot parse attribute name");
 571       return -1;
 572     }
 573     s = skipwhite(s, 0);
 574     if(*s++ != '=') {
 575       disorder_error(0, "parse_cookie: did not find expected '='");
 576       return -1;
 577     }
 578     s = skipwhite(s, 0);
 579     if(!(s = mime_parse_word(s, &v, cookie_value_separator))) {
 580       disorder_error(0, "parse_cookie: cannot parse value for '%s'", n);
 581       return -1;
 582     }
 583     if(n[0] == '$') {
 584       /* Some bit of meta-information */
 585       if(!strcmp(n, "$Version"))
 586         cd->version = v;
 587       else if(!strcmp(n, "$Path")) {
 588         if(cd->ncookies > 0 && cd->cookies[cd->ncookies-1].path == 0)
 589           cd->cookies[cd->ncookies-1].path = v;
 590         else {
 591           disorder_error(0, "redundant $Path in Cookie: header");
 592           return -1;
 593         }
 594       } else if(!strcmp(n, "$Domain")) {
 595         if(cd->ncookies > 0 && cd->cookies[cd->ncookies-1].domain == 0)
 596           cd->cookies[cd->ncookies-1].domain = v;
 597         else {
 598           disorder_error(0, "redundant $Domain in Cookie: header");
 599           return -1;
 600         }
 601       }
 602     } else {
 603       /* It's a new cookie */
 604       cd->cookies = xrealloc(cd->cookies,
 605                              (cd->ncookies + 1) * sizeof (struct cookie));
 606       cd->cookies[cd->ncookies].name = n;
 607       cd->cookies[cd->ncookies].value = v;
 608       cd->cookies[cd->ncookies].path = 0;
 609       cd->cookies[cd->ncookies].domain = 0;
 610       ++cd->ncookies;
 611     }
 612     s = skipwhite(s, 0);
 613     if(*s && (*s != ',' && *s != ';')) {
 614       disorder_error(0, "missing separator in Cookie: header");
 615       return -1;
 616     }
 617   }
 618   return 0;
 619 }
 620
 621 /** @brief Find a named cookie
 622  * @param cd Parse cookie data
 623  * @param name Name of cookie
 624  * @return Cookie structure or NULL if not found
 625  */
 626 const struct cookie *find_cookie(const struct cookiedata *cd,
 627                                  const char *name) {
 628   int n;
 629
 630   for(n = 0; n < cd->ncookies; ++n)
 631     if(!strcmp(cd->cookies[n].name, name))
 632       return &cd->cookies[n];
 633   return 0;
 634 }
 635
 636 /** @brief RFC822 quoting
 637  * @param s String to quote
 638  * @param force If non-0, always quote
 639  * @return Possibly quoted string
 640  */
 641 char *quote822(const char *s, int force) {
 642   const char *t;
 643   struct dynstr d[1];
 644   int c;
 645
 646   if(!force) {
 647     /* See if we need to quote */
 648     for(t = s; (c = (unsigned char)*t); ++t) {
 649       if(mime_tspecial(c) || mime_http_separator(c) || whitespace(c))
 650         break;
 651     }
 652     if(*t)
 653       force = 1;
 654   }
 655
 656   if(!force)
 657     return xstrdup(s);
 658
 659   dynstr_init(d);
 660   dynstr_append(d, '"');
 661   for(t = s; (c = (unsigned char)*t); ++t) {
 662     if(c == '"' || c == '\\')
 663       dynstr_append(d, '\\');
 664     dynstr_append(d, c);
 665   }
 666   dynstr_append(d, '"');
 667   dynstr_terminate(d);
 668   return d->vec;
 669 }
 670
 671 /** @brief Return true if @p ptr points at trailing space */
 672 static int is_trailing_space(const char *ptr) {
 673   if(*ptr == ' ' || *ptr == '\t') {
 674     while(*ptr == ' ' || *ptr == '\t')
 675       ++ptr;
 676     return *ptr == '\n' || *ptr == 0;
 677   } else
 678     return 0;
 679 }
 680
 681 /** @brief Encoding text as quoted-printable
 682  * @param text String to encode
 683  * @return Encoded string
 684  *
 685  * See <a href="http://tools.ietf.org/html/rfc2045#section-6.7">RFC2045
 686  * s6.7</a>.
 687  */
 688 char *mime_to_qp(const char *text) {
 689   struct dynstr d[1];
 690   int linelength = 0;                   /* length of current line */
 691   char buffer[10];
 692
 693   dynstr_init(d);
 694   /* The rules are:
 695    * 1. Anything except newline can be replaced with =%02X
 696    * 2. Newline, 33-60 and 62-126 stand for themselves (i.e. not '=')
 697    * 3. Non-trailing space/tab stand for themselves.
 698    * 4. Output lines are limited to 76 chars, with =<newline> being used
 699    *    as a soft line break
 700    * 5. Newlines aren't counted towards the 76 char limit.
 701    */
 702   while(*text) {
 703     const int c = (unsigned char)*text;
 704     if(c == '\n') {
 705       /* Newline stands as itself */
 706       dynstr_append(d, '\n');
 707       linelength = 0;
 708     } else if((c >= 33 && c <= 126 && c != '=')
 709               || ((c == ' ' || c == '\t')
 710                   && !is_trailing_space(text))) {
 711       /* Things that can stand for themselves  */
 712       dynstr_append(d, c);
 713       ++linelength;
 714     } else {
 715       /* Anything else that needs encoding */
 716       byte_snprintf(buffer, sizeof buffer, "=%02X", c);
 717       dynstr_append_string(d, buffer);
 718       linelength += 3;
 719     }
 720     ++text;
 721     if(linelength > 73 && *text && *text != '\n') {
 722       /* Next character might overflow 76 character limit if encoded, so we
 723        * insert a soft break */
 724       dynstr_append_string(d, "=\n");
 725       linelength = 0;
 726     }
 727   }
 728   /* Ensure there is a final newline */
 729   if(linelength)
 730     dynstr_append(d, '\n');
 731   /* That's all */
 732   dynstr_terminate(d);
 733   return d->vec;
 734 }
 735
 736 /** @brief Encode text
 737  * @param text Underlying UTF-8 text
 738  * @param charsetp Where to store charset string
 739  * @param encodingp Where to store encoding string
 740  * @return Encoded text (might be @p text)
 741  */
 742 const char *mime_encode_text(const char *text,
 743                              const char **charsetp,
 744                              const char **encodingp) {
 745   const char *ptr;
 746
 747   /* See if there are in fact any non-ASCII characters */
 748   for(ptr = text; *ptr; ++ptr)
 749     if((unsigned char)*ptr >= 128)
 750       break;
 751   if(!*ptr) {
 752     /* Plain old ASCII, no encoding required */
 753     *charsetp = "us-ascii";
 754     *encodingp = "7bit";
 755     return text;
 756   }
 757   *charsetp = "utf-8";
 758   *encodingp = "quoted-printable";
 759   return mime_to_qp(text);
 760 }
 761
 762 /*
 763 Local Variables:
 764 c-basic-offset:2
 765 comment-column:40
 766 fill-column:79
 767 End:
 768 */