lib-mime/rfc822address.c

   1 /*
   2  *  This program is free software; you can redistribute it and/or modify
   3  *  it under the terms of the GNU General Public License as published by
   4  *  the Free Software Foundation; either version 2 of the License, or (at
   5  *  your option) any later version.
   6  *
   7  *  This program is distributed in the hope that it will be useful, but
   8  *  WITHOUT ANY WARRANTY; without even the implied warranty of
   9  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  10  *  General Public License for more details.
  11  *
  12  *  You should have received a copy of the GNU General Public License
  13  *  along with this program; if not, write to the Free Software
  14  *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston,
  15  *  MA 02110-1301, USA.
  16  *
  17  *  Copyright © 2006 Pierre Habouzit
  18  */
  19
  20 /*
  21  * Copyright notice from original mutt:
  22  * Copyright (C) 1996-2000 Michael R. Elkins <me@mutt.org>
  23  *
  24  * This file is part of mutt-ng, see http://www.muttng.org/.
  25  * It's licensed under the GNU General Public License,
  26  * please see the file GPL in the top level source directory.
  27  */
  28
  29 #include <lib-lib/lib-lib.h>
  30
  31 #include "mutt_idna.h"
  32
  33 void rfc822_qualify(address_t *addr, const char *host)
  34 {
  35     char *p;
  36
  37     for (; addr; addr = addr->next) {
  38         if (!addr->group && addr->mailbox && !strchr(addr->mailbox, '@')) {
  39             p = p_new(char, m_strlen(addr->mailbox) + m_strlen(host) + 2);
  40             sprintf(p, "%s@%s", addr->mailbox, host);        /* __SPRINTF_CHECKED__ */
  41             p_delete(&addr->mailbox);
  42             addr->mailbox = p;
  43         }
  44     }
  45 }
  46
  47 address_t *address_dup(const address_t *addr)
  48 {
  49     address_t *res = address_new();
  50
  51     res->personal = m_strdup(addr->personal);
  52     res->mailbox  = m_strdup(addr->mailbox);
  53     res->group    = addr->group;
  54     return res;
  55 }
  56
  57 address_t *address_list_dup(const address_t *addr)
  58 {
  59     address_t *res = NULL, **resp = &res;
  60
  61     for (; addr; addr = addr->next) {
  62         *resp = address_dup(addr);
  63         resp = &(*resp)->next;
  64     }
  65
  66     return res;
  67 }
  68
  69 /* given a list of addresses, return a list of unique addresses */
  70 void address_list_uniq(address_t *a)
  71 {
  72     for (; a; a = a->next) {
  73         address_t **b = &a->next;
  74
  75         if (!a->mailbox)
  76             continue;
  77
  78         while (*b) {
  79             if ((*b)->mailbox && !ascii_strcasecmp((*b)->mailbox, a->mailbox))
  80             {
  81                 address_t *pop = address_list_pop(b);
  82                 address_delete(&pop);
  83             } else {
  84                 b = &(*b)->next;
  85             }
  86         }
  87     }
  88 }
  89
  90 /****************************************************************************/
  91 /* Parsing functions                                                        */
  92 /****************************************************************************/
  93
  94 typedef struct static_buf {
  95     char buf[STRING];
  96     int  len;
  97 } static_buf;
  98
  99 static inline void stbuf_append(static_buf *buf, int c) {
 100     if (buf->len < ssizeof(buf->buf) - 1) {
 101         buf->buf[buf->len++] = c;
 102         buf->buf[buf->len]   = '\0';
 103     }
 104 }
 105
 106 static inline void stbuf_append_sp(static_buf *buf) {
 107     if (buf->len)
 108         stbuf_append(buf, ' ');
 109 }
 110
 111 static char *rfc822_dequote_comment(static_buf *buf)
 112 {
 113     char *res = p_new(char, buf->len + 1);
 114     char *q   = res;
 115     char *p   = buf->buf;
 116     int i;
 117
 118     for (i = 0; i < buf->len; i++) {
 119         if (p[i] == '\"')
 120             continue;
 121
 122         if (p[i] == '\\') {
 123             if (++i >= buf->len) /* should not happen */
 124                 break;
 125         }
 126
 127         *q++ = p[i];
 128     }
 129
 130     *q++ = '\0';
 131     return res;
 132 }
 133
 134 static const char *parse_comment(const char *s, static_buf *buf)
 135 {
 136     int level = 1;
 137
 138     for (; *s; s++) {
 139         switch (*s) {
 140           case '(':
 141             level++;
 142             break;
 143
 144           case ')':
 145             level--;
 146             if (!level)
 147                 return s;
 148             break;
 149
 150           case '\\':
 151             s++; /* if *++s is NUL it will be an error anyway */
 152             break;
 153
 154           default:
 155             break;
 156         }
 157
 158         stbuf_append(buf, *s);
 159     }
 160
 161     return NULL;
 162 }
 163
 164 static const char *parse_quote(const char *s, static_buf *buf)
 165 {
 166     for (; *s; s++) {
 167         switch (*s) {
 168           case '"':
 169             stbuf_append(buf, *s);
 170             return s + 1;
 171
 172           case '\\':
 173             if (!*++s)
 174                 return NULL;
 175             /* fallthrough */
 176
 177           default:
 178             stbuf_append(buf, *s);
 179             break;
 180         }
 181     }
 182
 183     return NULL;
 184 }
 185
 186 const char RFC822Specials[] = "@.,:;<>[]\\\"()";
 187
 188 static const char *next_phrase(const char *s, static_buf *buf)
 189 {
 190     if (*s == '"') {
 191         stbuf_append(buf, '"');
 192         return parse_quote(s + 1, buf);
 193     }
 194
 195     if (strchr(RFC822Specials, *s)) {
 196         stbuf_append(buf, *s);
 197         return s + 1;
 198     }
 199
 200     while (*s) {
 201         if (ISSPACE(*s) || strchr(RFC822Specials, *s))
 202             break;
 203         stbuf_append(buf, *s++);
 204     }
 205
 206     return s;
 207 }
 208
 209 static const char *
 210 parse_mailboxdomain(const char *s, const char *nonspecial, static_buf *mbox,
 211                     static_buf *comment)
 212 {
 213     while (*s) {
 214         s = skipspaces(s);
 215
 216         if (!strchr(nonspecial, *s) && strchr(RFC822Specials, *s))
 217             return s;
 218
 219         if (*s == '(') {
 220             stbuf_append_sp(comment);
 221             s = parse_comment(s + 1, comment);
 222         } else {
 223             s = next_phrase(s, mbox);
 224         }
 225
 226         if (!s)
 227             return NULL;
 228     }
 229
 230     return s;
 231 }
 232
 233 static const char *
 234 parse_address(const char *s, static_buf *comment, address_t *cur)
 235 {
 236     static_buf token = {"", 0};
 237
 238     s = parse_mailboxdomain(s, ".\"(\\", &token, comment);
 239     if (!s)
 240         return NULL;
 241
 242     if (*s == '@') {
 243         stbuf_append(&token, '@');
 244         s = parse_mailboxdomain(s + 1, ".([]\\", &token, comment);
 245         if (!s)
 246             return NULL;
 247     }
 248
 249     cur->mailbox = p_dupstr(token.buf, token.len);
 250
 251     if (comment->len && !cur->personal) {
 252         cur->personal = p_dupstr(comment->buf, comment->len);
 253     }
 254
 255     return s;
 256 }
 257
 258 static address_t **rfc822_eotoken(address_t **last, static_buf *phrase, static_buf *comment)
 259 {
 260     if (phrase->len) {
 261         const char *s;
 262         address_t *cur = address_new();
 263
 264         s = parse_address(phrase->buf, comment, cur);
 265         if (s && *s && *s != ',' && *s != ';') {
 266             address_list_wipe(&cur);
 267             return last;
 268         }
 269
 270         *last = cur;
 271         return &(*last)->next;
 272     }
 273
 274     return last;
 275 }
 276
 277 address_t *rfc822_parse_adrlist(address_t *top, const char *s)
 278 {
 279     static_buf comment = {"", 0};
 280     static_buf phrase  = {"", 0};
 281
 282     address_t **last = address_list_last(&top);
 283     int ws_pending = 0;
 284
 285     for (;;) {
 286         ws_pending = ISSPACE(*s);
 287         s = skipspaces(s);
 288
 289         switch (*s) {
 290             address_t *cur;
 291
 292           default:
 293             if (ws_pending)
 294                 stbuf_append_sp(&phrase);
 295             s = next_phrase(s, &phrase);
 296             if (!s) {
 297                 address_list_wipe(&top);
 298                 return NULL;
 299             }
 300             continue;
 301
 302           case '(':
 303             stbuf_append_sp(&comment);
 304             s = parse_comment(s + 1, &comment);
 305             if (!s) {
 306                 address_list_wipe(&top);
 307                 return NULL;
 308             }
 309             continue;
 310
 311
 312           case '<':
 313             cur = address_new();
 314             if (phrase.len) {
 315                 /* if we get something like "Michael R. Elkins" remove the quotes */
 316                 cur->personal = rfc822_dequote_comment(&phrase);
 317             }
 318
 319             s = parse_address(skipspaces(s + 1), &comment, cur);
 320             if (!s || *s != '>' || !cur->mailbox) {
 321                 address_list_wipe(&top);
 322                 address_list_wipe(&cur);
 323                 return NULL;
 324             }
 325
 326             *last = cur;
 327             last = &(*last)->next;
 328             break;
 329
 330           case ',':
 331             last = rfc822_eotoken(last, &phrase, &comment);
 332             break;
 333
 334           case ':': /* group start */
 335             *last = address_new();
 336             (*last)->mailbox = p_dupstr(phrase.buf, phrase.len);
 337             (*last)->group = 1;
 338             last = &(*last)->next;
 339             break;
 340
 341           case ';':
 342             last = rfc822_eotoken(last, &phrase, &comment);
 343             /* add group terminator */
 344             *last = address_new();
 345             last = &(*last)->next;
 346             break;
 347
 348           case '\0':
 349             last = rfc822_eotoken(last, &phrase, &comment);
 350             return top;
 351         }
 352
 353         comment.len = phrase.len  = 0;
 354         s++;
 355     }
 356
 357     return NULL;
 358 }
 359
 360
 361 /****************************************************************************/
 362 /* Output functions                                                         */
 363 /****************************************************************************/
 364
 365 ssize_t
 366 rfc822_strcpy(char *buf, ssize_t buflen, const char *p, const char *specials)
 367 {
 368     if (strpbrk(p, specials)) {
 369         ssize_t pos = 0;
 370
 371         buf[pos++] = '"';
 372
 373         while (*p && pos < buflen - 2) {
 374             if (*p == '\\' || *p == '"') {
 375                 if (pos >= buflen - 4)
 376                     break;
 377                 buf[pos++] = '\\';
 378             }
 379
 380             buf[pos++] = *p++;
 381         }
 382
 383         buf[pos++] = '"';
 384         buf[pos]   = '\0';
 385         return pos;
 386     } else {
 387         return m_strcpy(buf, buflen, p);
 388     }
 389 }
 390
 391 ssize_t rfc822_write_address_single(char *buf, ssize_t buflen,
 392                                     address_t *addr, int display)
 393 {
 394     ssize_t pos = 0;
 395
 396     if (!addr)
 397         return 0;
 398
 399     buflen--;                     /* save room for the terminal nul */
 400
 401     if (addr->personal) {
 402         pos = rfc822_strcpy(buf, buflen, addr->personal, RFC822Specials);
 403         if (pos + 2 >= buflen)
 404             goto done;
 405
 406         buf[pos++] = ' ';
 407         buf[pos++] = '<';
 408     }
 409
 410     if (addr->mailbox) {
 411         if (!display) {
 412             pos += m_strcpy(buf + pos, buflen - pos, addr->mailbox);
 413         } else {
 414             pos += m_strcpy(buf + pos, buflen - pos, mutt_addr_for_display(addr));
 415         }
 416
 417         if (addr->personal) {
 418             if (pos + 1 >= buflen)
 419                 goto done;
 420             buf[pos++] = '>';
 421         }
 422
 423         if (addr->group) {
 424             if (pos + 1 >= buflen)
 425                 goto done;
 426             buf[pos++] = ':';
 427         }
 428     } else {
 429         if (pos + 1 >= buflen)
 430             goto done;
 431         buf[pos++] = ';';
 432     }
 433
 434   done:
 435     /* no need to check for length here since we already save space at the
 436        beginning of this routine */
 437     buf[pos] = 0;
 438     return pos;
 439 }
 440
 441 /* note: it is assumed that `buf' is nul terminated! */
 442 ssize_t
 443 rfc822_write_address(char *buf, ssize_t buflen, address_t *addr, int display)
 444 {
 445     ssize_t pos;
 446
 447     buflen--;                     /* save room for the terminal nul */
 448     pos = m_strnlen(buf, buflen);
 449
 450     if (pos) {
 451         if (pos + 2 >= buflen)
 452             goto done;
 453
 454         buf[pos++] = ',';
 455         buf[pos++] = ' ';
 456     }
 457
 458     for (; addr; addr = addr->next) {
 459         pos += rfc822_write_address_single(buf + pos, buflen + 1 - pos,
 460                                            addr, display);
 461
 462         if (!addr->group && addr->next && addr->next->mailbox) {
 463             /* if there is another address, and its not a group mailbox name or
 464                group terminator, add a comma to separate the addresses */
 465             if (pos + 2 >= buflen)
 466                 break;
 467
 468             buf[pos++] = ',';
 469             buf[pos++] = ' ';
 470         }
 471     }
 472
 473   done:
 474     buf[pos] = '\0';
 475     return pos;
 476 }
 477
 478 address_t *mutt_parse_adrlist(address_t *p, const char *s)
 479 {
 480     /* check for a simple whitespace separated list of addresses */
 481     char *q = strpbrk(s, "\"<>():;,\\");
 482     char tmp[HUGE_STRING];
 483
 484     if (q)
 485         return rfc822_parse_adrlist(p, s);
 486
 487     m_strcpy(tmp, sizeof(tmp), s);
 488     q = tmp;
 489     while ((q = strtok(q, " \t"))) {
 490         p = rfc822_parse_adrlist(p, q);
 491         q = NULL;
 492     }
 493
 494     return p;
 495 }
 496