git.ozlabs.org Git - ccan/blob - 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         eh = h = msg->remainder;
 154         do {
 155                 eh = next_line(eh, msg->end);
 156         } while ((eh < msg->end) && rfc822_iswsp(*eh));
 157
 158         if (eh >= msg->end)
 159                 msg->remainder = NULL;
 160         else
 161                 msg->remainder = eh;
 162
 163         ev = eh;
 164         if ((ev > h) && (ev[-1] == '\n'))
 165                 ev--;
 166         if ((ev > h) && (ev[-1] == '\r'))
 167                 ev--;
 168
 169         if (ev == h) {
 170                 /* Found the end of the headers */
 171                 if (eh < msg->end)
 172                         msg->body = eh;
 173                 return NULL;
 174         }
 175
 176         hi = talloc_zero(msg, struct rfc822_header);
 177         ALLOC_CHECK(hi, NULL);
 178
 179         hi->all = bytestring(h, eh - h);
 180         list_add_tail(&msg->headers, &hi->list);
 181
 182         colon = memchr(h, ':', hi->all.len);
 183         if (colon) {
 184                 hi->rawname = bytestring(h, colon - h);
 185                 hi->rawvalue = bytestring(colon + 1, eh - colon - 1);
 186         } else {
 187                 hi->rawname = bytestring_NULL;
 188                 hi->rawvalue = bytestring_NULL;
 189         }
 190
 191         CHECK(msg, "<next_header_parse");
 192
 193         return hi;
 194 }
 195
 196 struct rfc822_header *rfc822_next_header(struct rfc822_msg *msg,
 197                                          struct rfc822_header *hdr)
 198 {
 199         struct rfc822_header *h;
 200
 201         CHECK(msg, ">rfc822_next_header");
 202
 203         h = next_header_cached(msg, hdr);
 204         if (h)
 205                 return h;
 206
 207         return next_header_parse(msg);
 208 }
 209
 210 struct bytestring rfc822_body(struct rfc822_msg *msg)
 211 {
 212         CHECK(msg, ">rfc822_body");
 213
 214         if (!msg->body && msg->remainder) {
 215                 const char *p, *q;
 216
 217                 p = memmem(msg->remainder, msg->end - msg->remainder,
 218                            "\n\r\n", 3);
 219                 q = memmem(msg->remainder, msg->end - msg->remainder,
 220                            "\n\n", 2);
 221
 222                 if (p && (!q || (p < q)))
 223                         msg->body = p + 3;
 224                 else if (q && (!p || (q < p)))
 225                         msg->body = q + 2;
 226
 227                 if (msg->body >= msg->end) {
 228                         assert(msg->body == msg->end);
 229                         msg->body = NULL;
 230                 }
 231         }
 232
 233         CHECK(msg, "<rfc822_body");
 234
 235         if (msg->body)
 236                 return bytestring(msg->body, msg->end - msg->body);
 237         else
 238                 return bytestring_NULL;
 239 }
 240
 241 enum rfc822_header_errors rfc822_header_errors(struct rfc822_msg *msg,
 242                                                struct rfc822_header *hdr)
 243 {
 244         enum rfc822_header_errors err = 0;
 245         int i;
 246
 247         if (!hdr->rawname.ptr) {
 248                 err |= RFC822_HDR_NO_COLON;
 249         } else {
 250                 for (i = 0; i < hdr->rawname.len; i++) {
 251                         char c = hdr->rawname.ptr[i];
 252
 253                         assert(c != ':');
 254
 255                         if ((c < 33) || (c > 126)) {
 256                                 err |= RFC822_HDR_BAD_NAME;
 257                                 break;
 258                         }
 259                 }
 260         }
 261         return err;
 262 }
 263
 264 struct bytestring rfc822_header_raw_content(struct rfc822_msg *msg,
 265                                             struct rfc822_header *hdr)
 266 {
 267         return hdr->all;
 268 }
 269
 270 struct bytestring rfc822_header_raw_name(struct rfc822_msg *msg,
 271                                          struct rfc822_header *hdr)
 272 {
 273         return hdr->rawname;
 274 }
 275
 276 struct bytestring rfc822_header_raw_value(struct rfc822_msg *msg,
 277                                           struct rfc822_header *hdr)
 278 {
 279         return hdr->rawvalue;
 280 }
 281
 282 static void get_line(struct bytestring in, struct bytestring *first,
 283                      struct bytestring *rest)
 284 {
 285         size_t rawlen, trimlen;
 286         const char *inp = in.ptr;
 287         const char *nl;
 288
 289         nl = memchr(inp, '\n', in.len);
 290         if (!nl)
 291                 rawlen = in.len;
 292         else
 293                 rawlen = nl - inp + 1;
 294
 295         trimlen = rawlen;
 296         if ((trimlen > 0) && (inp[trimlen-1] == '\n')) {
 297                 trimlen--;
 298                 if ((trimlen > 0) && (inp[trimlen-1] == '\r'))
 299                         trimlen--;
 300         }
 301
 302         *first = bytestring(in.ptr, trimlen);
 303
 304         if (rawlen < in.len)
 305                 *rest = bytestring(in.ptr + rawlen, in.len - rawlen);
 306         else
 307                 *rest = bytestring_NULL;
 308 }
 309
 310
 311 struct bytestring rfc822_header_unfolded_value(struct rfc822_msg *msg,
 312                                                struct rfc822_header *hdr)
 313 {
 314         struct bytestring raw = rfc822_header_raw_value(msg, hdr);
 315         struct bytestring next, rest;
 316         int lines = 0;
 317         size_t len = 0;
 318
 319         if (!hdr->unfolded.ptr) {
 320                 rest = raw;
 321                 while (rest.ptr) {
 322                         get_line(rest, &next, &rest);
 323                         lines++;
 324                         len += next.len;
 325                 }
 326
 327                 if (lines <= 1) {
 328                         hdr->unfolded = bytestring(raw.ptr, len);
 329                 } else {
 330                         char *unfold = talloc_array(msg, char, len);
 331                         char *p = unfold;
 332
 333                         ALLOC_CHECK(unfold, bytestring_NULL);
 334
 335                         rest = raw;
 336                         while (rest.ptr) {
 337                                 get_line(rest, &next, &rest);
 338                                 memcpy(p, next.ptr, next.len);
 339                                 p += next.len;
 340                         }
 341
 342                         assert(p == (unfold + len));
 343                         hdr->unfolded = bytestring(unfold, len);
 344                 }
 345         }
 346
 347         return hdr->unfolded;
 348 }