reorganize code so that the rfc822parse.c does not needs lib-crypt nor
[apps/madmutt.git] / 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 <string.h>
30 #include <ctype.h>
31 #include <stdlib.h>
32
33 #include <lib-lib/mem.h>
34 #include <lib-lib/str.h>
35 #include <lib-lib/ascii.h>
36 #include <lib-lib/macros.h>
37
38 #include "mutt_idna.h"
39
40 void rfc822_qualify(address_t *addr, const char *host)
41 {
42     char *p;
43
44     for (; addr; addr = addr->next) {
45         if (!addr->group && addr->mailbox && !strchr(addr->mailbox, '@')) {
46             p = p_new(char, m_strlen(addr->mailbox) + m_strlen(host) + 2);
47             sprintf(p, "%s@%s", addr->mailbox, host);        /* __SPRINTF_CHECKED__ */
48             p_delete(&addr->mailbox);
49             addr->mailbox = p;
50         }
51     }
52 }
53
54 address_t *address_dup(address_t *addr)
55 {
56     address_t *res = address_new();
57
58     res->personal = m_strdup(addr->personal);
59     res->mailbox  = m_strdup(addr->mailbox);
60     res->group    = addr->group;
61     return res;
62 }
63
64 address_t *address_list_dup(address_t *addr)
65 {
66     address_t *res = NULL, **resp = &res;
67
68     for (; addr; addr = addr->next) {
69         *resp = address_dup(addr);
70         resp = &(*resp)->next;
71     }
72
73     return res;
74 }
75
76
77 /****************************************************************************/
78 /* Parsing functions                                                        */
79 /****************************************************************************/
80
81 typedef struct static_buf {
82     char buf[STRING];
83     int  len;
84 } static_buf;
85
86 static inline void stbuf_append(static_buf *buf, int c) {
87     if (buf->len < ssizeof(buf->buf) - 1) {
88         buf->buf[buf->len++] = c;
89         buf->buf[buf->len]   = '\0';
90     }
91 }
92
93 static inline void stbuf_append_sp(static_buf *buf) {
94     if (buf->len)
95         stbuf_append(buf, ' ');
96 }
97
98 static char *rfc822_dequote_comment(static_buf *buf)
99 {
100     char *res = p_new(char, buf->len + 1);
101     char *q   = res;
102     char *p   = buf->buf;
103     int i;
104
105     for (i = 0; i < buf->len; i++) {
106         if (p[i] == '\"')
107             continue;
108
109         if (p[i] == '\\') {
110             if (++i >= buf->len) /* should not happen */
111                 break;
112         }
113
114         *q++ = p[i];
115     }
116
117     *q++ = '\0';
118     return res;
119 }
120
121 static const char *parse_comment(const char *s, static_buf *buf)
122 {
123     int level = 1;
124
125     for (; *s; s++) {
126         switch (*s) {
127           case '(':
128             level++;
129             break;
130
131           case ')':
132             level--;
133             if (!level)
134                 return s;
135             break;
136
137           case '\\':
138             s++; /* if *++s is NUL it will be an error anyway */
139             break;
140
141           default:
142             break;
143         }
144
145         stbuf_append(buf, *s);
146     }
147
148     return NULL;
149 }
150
151 static const char *parse_quote(const char *s, static_buf *buf)
152 {
153     for (; *s; s++) {
154         switch (*s) {
155           case '"':
156             stbuf_append(buf, *s);
157             return s + 1;
158
159           case '\\':
160             if (!*++s)
161                 return NULL;
162             /* fallthrough */
163
164           default:
165             stbuf_append(buf, *s);
166             break;
167         }
168     }
169
170     return NULL;
171 }
172
173 const char RFC822Specials[] = "@.,:;<>[]\\\"()";
174
175 static const char *next_phrase(const char *s, static_buf *buf)
176 {
177     if (*s == '"') {
178         stbuf_append(buf, '"');
179         return parse_quote(s + 1, buf);
180     }
181
182     if (strchr(RFC822Specials, *s)) {
183         stbuf_append(buf, *s);
184         return s + 1;
185     }
186
187     while (*s) {
188         if (ISSPACE(*s) || strchr(RFC822Specials, *s))
189             break;
190         stbuf_append(buf, *s++);
191     }
192
193     return s;
194 }
195
196 static const char *
197 parse_mailboxdomain(const char *s, const char *nonspecial, static_buf *mbox,
198                     static_buf *comment)
199 {
200     while (*s) {
201         s = skipspaces(s);
202
203         if (!strchr(nonspecial, *s) && strchr(RFC822Specials, *s))
204             return s;
205
206         if (*s == '(') {
207             stbuf_append_sp(comment);
208             s = parse_comment(s + 1, comment);
209         } else {
210             s = next_phrase(s, mbox);
211         }
212
213         if (!s)
214             return NULL;
215     }
216
217     return s;
218 }
219
220 static const char *
221 parse_address(const char *s, static_buf *comment, address_t *cur)
222 {
223     static_buf token = {"", 0};
224
225     s = parse_mailboxdomain(s, ".\"(\\", &token, comment);
226     if (!s)
227         return NULL;
228
229     if (*s == '@') {
230         stbuf_append(&token, '@');
231         s = parse_mailboxdomain(s + 1, ".([]\\", &token, comment);
232         if (!s)
233             return NULL;
234     }
235
236     cur->mailbox = p_dupstr(token.buf, token.len);
237
238     if (comment->len && !cur->personal) {
239         cur->personal = p_dupstr(comment->buf, comment->len);
240     }
241
242     return s;
243 }
244
245 address_t **rfc822_eotoken(address_t **last, static_buf *phrase, static_buf *comment)
246 {
247     if (phrase->len) {
248         const char *s;
249         address_t *cur = address_new();
250
251         s = parse_address(phrase->buf, comment, cur);
252         if (s && *s && *s != ',' && *s != ';') {
253             address_delete(&cur);
254             return last;
255         }
256
257         *last = cur;
258         return &(*last)->next;
259     }
260
261     return last;
262 }
263
264 address_t *rfc822_parse_adrlist(address_t *top, const char *s)
265 {
266     static_buf comment = {"", 0};
267     static_buf phrase  = {"", 0};
268
269     address_t **last = address_list_last(&top);
270     int ws_pending = 0;
271
272     for (;;) {
273         ws_pending = ISSPACE(*s);
274         s = skipspaces(s);
275
276         switch (*s) {
277             address_t *cur;
278
279           default:
280             if (ws_pending)
281                 stbuf_append_sp(&phrase);
282             s = next_phrase(s, &phrase);
283             if (!s) {
284                 address_delete(&top);
285                 return NULL;
286             }
287             continue;
288
289           case '(':
290             stbuf_append_sp(&comment);
291             s = parse_comment(s + 1, &comment);
292             if (!s) {
293                 address_delete(&top);
294                 return NULL;
295             }
296             continue;
297
298
299           case '<':
300             cur = address_new();
301             if (phrase.len) {
302                 /* if we get something like "Michael R. Elkins" remove the quotes */
303                 cur->personal = rfc822_dequote_comment(&phrase);
304             }
305
306             s = parse_address(skipspaces(s + 1), &comment, cur);
307             if (!s || *s != '>' || !cur->mailbox) {
308                 address_delete(&top);
309                 address_delete(&cur);
310                 return NULL;
311             }
312
313             *last = cur;
314             last = &(*last)->next;
315             break;
316
317           case ',':
318             last = rfc822_eotoken(last, &phrase, &comment);
319             break;
320
321           case ':': /* group start */
322             *last = address_new();
323             (*last)->mailbox = p_dupstr(phrase.buf, phrase.len);
324             (*last)->group = 1;
325             last = &(*last)->next;
326             break;
327
328           case ';':
329             last = rfc822_eotoken(last, &phrase, &comment);
330             /* add group terminator */
331             *last = address_new();
332             last = &(*last)->next;
333             break;
334
335           case '\0':
336             last = rfc822_eotoken(last, &phrase, &comment);
337             return top;
338         }
339
340         comment.len = phrase.len  = 0;
341         s++;
342     }
343
344     return NULL;
345 }
346
347
348 /****************************************************************************/
349 /* Output functions                                                         */
350 /****************************************************************************/
351
352 ssize_t
353 rfc822_strcpy(char *buf, ssize_t buflen, const char *p, const char *specials)
354 {
355     if (strpbrk(p, specials)) {
356         ssize_t pos = 0;
357
358         buf[pos++] = '"';
359
360         while (*p && pos < buflen - 2) {
361             if (*p == '\\' || *p == '"') {
362                 if (pos >= buflen - 4)
363                     break;
364                 buf[pos++] = '\\';
365             }
366
367             buf[pos++] = *p++;
368         }
369
370         buf[pos++] = '"';
371         buf[pos]   = '\0';
372         return pos;
373     } else {
374         return m_strcpy(buf, buflen, p);
375     }
376 }
377
378 ssize_t rfc822_write_address_single(char *buf, ssize_t buflen,
379                                     address_t *addr, int display)
380 {
381     ssize_t pos = 0;
382
383     if (!addr)
384         return 0;
385
386     buflen--;                     /* save room for the terminal nul */
387
388     if (addr->personal) {
389         pos = rfc822_strcpy(buf, buflen, addr->personal, RFC822Specials);
390         if (pos + 2 >= buflen)
391             goto done;
392
393         buf[pos++] = ' ';
394         buf[pos++] = '<';
395     }
396
397     if (addr->mailbox) {
398         if (!display) {
399             pos += m_strcpy(buf + pos, buflen - pos, addr->mailbox);
400         } else {
401             pos += m_strcpy(buf + pos, buflen - pos, mutt_addr_for_display(addr));
402         }
403
404         if (addr->personal) {
405             if (pos + 1 >= buflen)
406                 goto done;
407             buf[pos++] = '>';
408         }
409
410         if (addr->group) {
411             if (pos + 1 >= buflen)
412                 goto done;
413             buf[pos++] = ':';
414         }
415     } else {
416         if (pos + 1 >= buflen)
417             goto done;
418         buf[pos++] = ';';
419     }
420
421   done:
422     /* no need to check for length here since we already save space at the
423        beginning of this routine */
424     buf[pos] = 0;
425     return pos;
426 }
427
428 /* note: it is assumed that `buf' is nul terminated! */
429 ssize_t
430 rfc822_write_address(char *buf, ssize_t buflen, address_t *addr, int display)
431 {
432     ssize_t pos;
433
434     buflen--;                     /* save room for the terminal nul */
435     pos = m_strnlen(buf, buflen);
436
437     if (pos) {
438         if (pos + 2 >= buflen)
439             goto done;
440
441         buf[pos++] = ',';
442         buf[pos++] = ' ';
443     }
444
445     for (; addr; addr = addr->next) {
446         pos += rfc822_write_address_single(buf + pos, buflen + 1 - pos,
447                                            addr, display);
448
449         if (!addr->group && addr->next && addr->next->mailbox) {
450             /* if there is another address, and its not a group mailbox name or
451                group terminator, add a comma to separate the addresses */
452             if (pos + 2 >= buflen)
453                 break;
454
455             buf[pos++] = ',';
456             buf[pos++] = ' ';
457         }
458     }
459
460   done:
461     buf[pos] = '\0';
462     return pos;
463 }
464