f5ffd958e767c10ee9602059fac13fa1e8c59bde
[ccan] / ccan / rfc822 / rfc822.c
1 /* Licensed under LGPLv2.1+ - see LICENSE file for details */
2
3 #include "config.h"
4
5 #include <string.h>
6
7 #include <ccan/str/str.h>
8 #include <ccan/talloc/talloc.h>
9 #include <ccan/list/list.h>
10
11 #include <ccan/rfc822/rfc822.h>
12
13 #if !HAVE_MEMMEM
14 void *memmem(const void *haystack, size_t haystacklen,
15              const void *needle, size_t needlelen)
16 {
17         const char *p, *last;
18
19         p = haystack;
20         last = p + haystacklen - needlelen;
21
22         do {
23                 if (memcmp(p, needle, needlelen) == 0)
24                         return (void *)p;
25         } while (p++ <= last);
26
27         return NULL;
28 }
29 #endif
30
31 static void (*allocation_failure_hook)(const char *);
32
33 static void NORETURN default_allocation_failure(const char *s)
34 {
35         fprintf(stderr, "ccan/rfc822: Allocation failure: %s", s);
36         abort();
37 }
38
39 static void allocation_failure(const char *s)
40 {
41         if (allocation_failure_hook)
42                 (*allocation_failure_hook)(s);
43         else
44                 default_allocation_failure(s);
45 }
46
47 void rfc822_set_allocation_failure_handler(void (*h)(const char *))
48 {
49         allocation_failure_hook = h;
50 }
51
52 #define ALLOC_CHECK(p, r) \
53         do { \
54                 if (!(p)) { \
55                         allocation_failure(__FILE__ ":" stringify(__LINE__)); \
56                         return (r); \
57                 } \
58         } while (0)
59
60 struct rfc822_msg {
61         const char *data, *end;
62         const char *remainder;
63         struct list_head headers;
64         const char *body;
65 };
66
67 struct rfc822_header {
68         struct bytestring all, rawname, rawvalue;
69         struct bytestring unfolded;
70         struct list_node list;
71 };
72
73 struct rfc822_msg *rfc822_check(const struct rfc822_msg *msg,
74                                 const char *abortstr)
75 {
76         assert(msg);
77         if (!list_check(&msg->headers, abortstr))
78                 return NULL;
79         return (struct rfc822_msg *)msg;
80 }
81
82 #ifdef CCAN_RFC822_DEBUG
83 #define CHECK(msg, str) do { rfc822_check((msg), (str)); } while (0)
84 #else
85 #define CHECK(msg, str) do { } while (0)
86 #endif
87
88 struct rfc822_msg *rfc822_start(const void *ctx, const char *p, size_t len)
89 {
90         struct rfc822_msg *msg;
91
92         msg = talloc(ctx, struct rfc822_msg);
93         ALLOC_CHECK(msg, NULL);
94
95         msg->data = p;
96         msg->end = p + len;
97
98         msg->remainder = msg->data;
99         msg->body = NULL;
100
101         list_head_init(&msg->headers);
102
103         CHECK(msg, "<rfc22_start");
104
105         return msg;
106 }
107
108 void rfc822_free(struct rfc822_msg *msg)
109 {
110         CHECK(msg, ">rfc822_free");
111         talloc_free(msg);
112 }
113
114 static struct rfc822_header *next_header_cached(struct rfc822_msg *msg,
115                                                 struct rfc822_header *hdr)
116 {
117         struct list_node *h = &msg->headers.n;
118         const struct list_node *n = h;
119
120         CHECK(msg, ">next_header_cached");
121
122         if (hdr)
123                 n = &hdr->list;
124
125         if (n->next == h)
126                 return NULL;
127
128         CHECK(msg, "<next_header_cached");
129
130         return list_entry(n->next, struct rfc822_header, list);
131 }
132
133 static const char *next_line(const char *start, const char *end)
134 {
135         const char *p = memchr(start, '\n', end - start);
136
137         return p ? (p + 1) : end;
138 }
139
140 static struct rfc822_header *next_header_parse(struct rfc822_msg *msg)
141 {
142         const char *h, *eh, *ev, *colon;
143         struct rfc822_header *hi;
144
145         CHECK(msg, ">next_header_parse");
146
147         if (!msg->remainder)
148                 return NULL;
149
150         if (msg->body && (msg->remainder >= msg->body))
151                 return NULL;
152
153         h = msg->remainder;
154         eh = next_line(h, msg->end);
155
156         ev = eh;
157         if ((ev > h) && (ev[-1] == '\n'))
158                 ev--;
159         if ((ev > h) && (ev[-1] == '\r'))
160                 ev--;
161         if (ev == h) {
162                 /* Found the end of the headers */
163
164                 assert(!msg->body || (msg->body == eh));
165
166                 if (eh < msg->end)
167                         msg->body = eh;
168                 return NULL;
169         }
170
171         while ((eh < msg->end) && rfc822_iswsp(*eh))
172                 eh = next_line(eh, msg->end);
173
174         if (eh >= msg->end)
175                 msg->remainder = NULL;
176         else
177                 msg->remainder = eh;
178
179
180         hi = talloc_zero(msg, struct rfc822_header);
181         ALLOC_CHECK(hi, NULL);
182
183         hi->all = bytestring(h, eh - h);
184         list_add_tail(&msg->headers, &hi->list);
185
186         colon = memchr(h, ':', hi->all.len);
187         if (colon) {
188                 hi->rawname = bytestring(h, colon - h);
189                 hi->rawvalue = bytestring(colon + 1, eh - colon - 1);
190         } else {
191                 hi->rawname = bytestring_NULL;
192                 hi->rawvalue = bytestring_NULL;
193         }
194
195         CHECK(msg, "<next_header_parse");
196
197         return hi;
198 }
199
200 struct rfc822_header *rfc822_next_header(struct rfc822_msg *msg,
201                                          struct rfc822_header *hdr)
202 {
203         struct rfc822_header *h;
204
205         CHECK(msg, ">rfc822_next_header");
206
207         h = next_header_cached(msg, hdr);
208         if (h)
209                 return h;
210
211         return next_header_parse(msg);
212 }
213
214 struct bytestring rfc822_body(struct rfc822_msg *msg)
215 {
216         CHECK(msg, ">rfc822_body");
217
218         if (!msg->body && msg->remainder) {
219                 const char *p, *q;
220
221                 p = memmem(msg->remainder, msg->end - msg->remainder,
222                            "\n\r\n", 3);
223                 q = memmem(msg->remainder, msg->end - msg->remainder,
224                            "\n\n", 2);
225
226                 if (p && (!q || (p < q)))
227                         msg->body = p + 3;
228                 else if (q && (!p || (q < p)))
229                         msg->body = q + 2;
230
231                 if (msg->body >= msg->end) {
232                         assert(msg->body == msg->end);
233                         msg->body = NULL;
234                 }
235         }
236
237         CHECK(msg, "<rfc822_body");
238
239         if (msg->body)
240                 return bytestring(msg->body, msg->end - msg->body);
241         else
242                 return bytestring_NULL;
243 }
244
245 enum rfc822_header_errors rfc822_header_errors(struct rfc822_msg *msg,
246                                                struct rfc822_header *hdr)
247 {
248         enum rfc822_header_errors err = 0;
249         int i;
250
251         if (!hdr->rawname.ptr) {
252                 err |= RFC822_HDR_NO_COLON;
253         } else {
254                 for (i = 0; i < hdr->rawname.len; i++) {
255                         char c = hdr->rawname.ptr[i];
256
257                         assert(c != ':');
258
259                         if ((c < 33) || (c > 126)) {
260                                 err |= RFC822_HDR_BAD_NAME_CHARS;
261                                 break;
262                         }
263                 }
264         }
265         return err;
266 }
267
268 struct bytestring rfc822_header_raw_content(struct rfc822_msg *msg,
269                                             struct rfc822_header *hdr)
270 {
271         return hdr->all;
272 }
273
274 struct bytestring rfc822_header_raw_name(struct rfc822_msg *msg,
275                                          struct rfc822_header *hdr)
276 {
277         return hdr->rawname;
278 }
279
280 struct bytestring rfc822_header_raw_value(struct rfc822_msg *msg,
281                                           struct rfc822_header *hdr)
282 {
283         return hdr->rawvalue;
284 }
285
286 static void get_line(struct bytestring in, struct bytestring *first,
287                      struct bytestring *rest)
288 {
289         size_t rawlen, trimlen;
290         const char *inp = in.ptr;
291         const char *nl;
292
293         nl = memchr(inp, '\n', in.len);
294         if (!nl)
295                 rawlen = in.len;
296         else
297                 rawlen = nl - inp + 1;
298
299         trimlen = rawlen;
300         if ((trimlen > 0) && (inp[trimlen-1] == '\n')) {
301                 trimlen--;
302                 if ((trimlen > 0) && (inp[trimlen-1] == '\r'))
303                         trimlen--;
304         }
305
306         *first = bytestring(in.ptr, trimlen);
307
308         if (rawlen < in.len)
309                 *rest = bytestring(in.ptr + rawlen, in.len - rawlen);
310         else
311                 *rest = bytestring_NULL;
312 }
313
314
315 struct bytestring rfc822_header_unfolded_value(struct rfc822_msg *msg,
316                                                struct rfc822_header *hdr)
317 {
318         struct bytestring raw = rfc822_header_raw_value(msg, hdr);
319         struct bytestring next, rest;
320         int lines = 0;
321         size_t len = 0;
322
323         if (!hdr->unfolded.ptr) {
324                 rest = raw;
325                 while (rest.ptr) {
326                         get_line(rest, &next, &rest);
327                         lines++;
328                         len += next.len;
329                 }
330
331                 if (lines <= 1) {
332                         hdr->unfolded = bytestring(raw.ptr, len);
333                 } else {
334                         char *unfold = talloc_array(msg, char, len);
335                         char *p = unfold;
336
337                         ALLOC_CHECK(unfold, bytestring_NULL);
338
339                         rest = raw;
340                         while (rest.ptr) {
341                                 get_line(rest, &next, &rest);
342                                 memcpy(p, next.ptr, next.len);
343                                 p += next.len;
344                         }
345
346                         assert(p == (unfold + len));
347                         hdr->unfolded = bytestring(unfold, len);
348                 }
349         }
350
351         return hdr->unfolded;
352 }
353
354 /* Specifically locale *un*aware tolower() - headers should be ascii
355  * only, and if they're not best to leave them as is */
356 static char xtolower(char c)
357 {
358         if ((c >= 'A') && (c <= 'Z'))
359                 return 'a' + (c - 'A');
360         else
361                 return c;
362 }
363
364 static bool hdr_name_eq(struct bytestring a, struct bytestring b)
365 {
366         int i;
367
368         if (a.len != b.len)
369                 return false;
370
371         for (i = 0; i < a.len; i++)
372                 if (xtolower(a.ptr[i]) != xtolower(b.ptr[i]))
373                         return false;
374
375         return true;
376 }
377
378 bool rfc822_header_is(struct rfc822_msg *msg, struct rfc822_header *hdr,
379                       const char *name)
380 {
381         struct bytestring hname = rfc822_header_raw_name(msg, hdr);
382
383         if (!hname.ptr || !name)
384                 return false;
385
386         return hdr_name_eq(hname, bytestring_from_string(name));
387 }
388
389 struct rfc822_header *rfc822_next_header_of_name(struct rfc822_msg *msg,
390                                                  struct rfc822_header *hdr,
391                                                  const char *name)
392 {
393         do {
394                 hdr = rfc822_next_header(msg, hdr);
395         } while (hdr && !rfc822_header_is(msg, hdr, name));
396
397         return hdr;
398 }