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/list/list.h>
   9 #include <stdio.h>
  10
  11 #include <ccan/memmem/memmem.h>
  12 #include <ccan/rfc822/rfc822.h>
  13
  14 #ifdef TAL_USE_TALLOC
  15 #include <ccan/tal/talloc/talloc.h>
  16 #else
  17 #include <ccan/tal/tal.h>
  18 #endif
  19
  20 static void (*allocation_failure_hook)(const char *);
  21
  22 static void NORETURN default_allocation_failure(const char *s)
  23 {
  24         fprintf(stderr, "ccan/rfc822: Allocation failure: %s", s);
  25         abort();
  26 }
  27
  28 static void allocation_failure(const char *s)
  29 {
  30         if (allocation_failure_hook)
  31                 (*allocation_failure_hook)(s);
  32         else
  33                 default_allocation_failure(s);
  34 }
  35
  36 void rfc822_set_allocation_failure_handler(void (*h)(const char *))
  37 {
  38         allocation_failure_hook = h;
  39 }
  40
  41 #define ALLOC_CHECK(p, r) \
  42         do { \
  43                 if (!(p)) { \
  44                         allocation_failure(__FILE__ ":" stringify(__LINE__)); \
  45                         return (r); \
  46                 } \
  47         } while (0)
  48
  49 /*
  50  * No real point doing fancy resizing hashes, when any given mail
  51  * message is unlikely to have more than a fairly small number of
  52  * distinct header types.  This should be ample.
  53  */
  54 #define INDEX_HASH_SIZE         63
  55
  56 struct rfc822_msg {
  57         const char *data, *end;
  58         const char *remainder;
  59         struct list_head headers;
  60         struct list_head header_index[INDEX_HASH_SIZE];
  61         const char *body;
  62 };
  63
  64 struct rfc822_header {
  65         struct bytestring all, rawname, rawvalue;
  66         struct bytestring unfolded;
  67         struct list_node list;
  68         struct rfc822_header *name_next;
  69 };
  70
  71 struct rfc822_headers_of_name {
  72         struct bytestring name;
  73         struct rfc822_header *first;
  74         struct rfc822_header **lastptr;
  75         struct list_node bucket;
  76 };
  77
  78 struct rfc822_msg *rfc822_check(const struct rfc822_msg *msg,
  79                                 const char *abortstr)
  80 {
  81         assert(msg);
  82         if (!list_check(&msg->headers, abortstr))
  83                 return NULL;
  84         if (!tal_check(msg, abortstr))
  85                 return NULL;
  86         return (struct rfc822_msg *)msg;
  87 }
  88
  89 #ifdef CCAN_RFC822_DEBUG
  90 #define CHECK(msg, str) do { rfc822_check((msg), (str)); } while (0)
  91 #else
  92 #define CHECK(msg, str) do { } while (0)
  93 #endif
  94
  95 struct rfc822_msg *rfc822_start(const void *ctx, const char *p, size_t len)
  96 {
  97         struct rfc822_msg *msg;
  98         int i;
  99
 100         msg = tal(ctx, struct rfc822_msg);
 101         ALLOC_CHECK(msg, NULL);
 102
 103         msg->data = p;
 104         msg->end = p + len;
 105
 106         msg->remainder = msg->data;
 107         msg->body = NULL;
 108
 109         list_head_init(&msg->headers);
 110
 111         for (i = 0; i < INDEX_HASH_SIZE; i++)
 112                 list_head_init(&msg->header_index[i]);
 113
 114         CHECK(msg, "<rfc22_start");
 115
 116         return msg;
 117 }
 118
 119 void rfc822_free(struct rfc822_msg *msg)
 120 {
 121         CHECK(msg, ">rfc822_free");
 122         tal_free(msg);
 123 }
 124
 125 static struct rfc822_header *next_header_cached(struct rfc822_msg *msg,
 126                                                 struct rfc822_header *hdr)
 127 {
 128         struct list_node *h = &msg->headers.n;
 129         const struct list_node *n = h;
 130
 131         CHECK(msg, ">next_header_cached");
 132
 133         if (hdr)
 134                 n = &hdr->list;
 135
 136         if (n->next == h)
 137                 return NULL;
 138
 139         CHECK(msg, "<next_header_cached");
 140
 141         return list_entry(n->next, struct rfc822_header, list);
 142 }
 143
 144 static const char *next_line(const char *start, const char *end)
 145 {
 146         const char *p = memchr(start, '\n', end - start);
 147
 148         return p ? (p + 1) : end;
 149 }
 150
 151 static struct rfc822_header *index_header(struct rfc822_msg *msg,
 152                                           struct rfc822_header *hdr);
 153
 154 static struct rfc822_header *next_header_parse(struct rfc822_msg *msg)
 155 {
 156         const char *h, *eh, *ev, *colon;
 157         struct rfc822_header *hi;
 158
 159         CHECK(msg, ">next_header_parse");
 160
 161         if (!msg->remainder)
 162                 return NULL;
 163
 164         if (msg->body && (msg->remainder >= msg->body))
 165                 return NULL;
 166
 167         h = msg->remainder;
 168         eh = next_line(h, msg->end);
 169
 170         ev = eh;
 171         if ((ev > h) && (ev[-1] == '\n'))
 172                 ev--;
 173         if ((ev > h) && (ev[-1] == '\r'))
 174                 ev--;
 175         if (ev == h) {
 176                 /* Found the end of the headers */
 177
 178                 assert(!msg->body || (msg->body == eh));
 179
 180                 if (eh < msg->end)
 181                         msg->body = eh;
 182                 return NULL;
 183         }
 184
 185         while ((eh < msg->end) && rfc822_iswsp(*eh))
 186                 eh = next_line(eh, msg->end);
 187
 188         if (eh >= msg->end)
 189                 msg->remainder = NULL;
 190         else
 191                 msg->remainder = eh;
 192
 193
 194         hi = talz(msg, struct rfc822_header);
 195         ALLOC_CHECK(hi, NULL);
 196
 197         hi->all = bytestring(h, eh - h);
 198         list_add_tail(&msg->headers, &hi->list);
 199
 200         colon = memchr(h, ':', hi->all.len);
 201         if (colon) {
 202                 hi->rawname = bytestring(h, colon - h);
 203                 hi->rawvalue = bytestring(colon + 1, eh - colon - 1);
 204         } else {
 205                 hi->rawname = bytestring_NULL;
 206                 hi->rawvalue = bytestring_NULL;
 207         }
 208
 209         CHECK(msg, "<next_header_parse");
 210
 211         return index_header(msg, hi);
 212 }
 213
 214 struct rfc822_header *rfc822_next_header(struct rfc822_msg *msg,
 215                                          struct rfc822_header *hdr)
 216 {
 217         struct rfc822_header *h;
 218
 219         CHECK(msg, ">rfc822_next_header");
 220
 221         h = next_header_cached(msg, hdr);
 222         if (h)
 223                 return h;
 224
 225         return next_header_parse(msg);
 226 }
 227
 228 struct bytestring rfc822_body(struct rfc822_msg *msg)
 229 {
 230         CHECK(msg, ">rfc822_body");
 231
 232         if (!msg->body && msg->remainder) {
 233                 const char *p, *q;
 234
 235                 p = memmem(msg->remainder, msg->end - msg->remainder,
 236                            "\n\r\n", 3);
 237                 q = memmem(msg->remainder, msg->end - msg->remainder,
 238                            "\n\n", 2);
 239
 240                 if (p && (!q || (p < q)))
 241                         msg->body = p + 3;
 242                 else if (q && (!p || (q < p)))
 243                         msg->body = q + 2;
 244
 245                 if (msg->body >= msg->end) {
 246                         assert(msg->body == msg->end);
 247                         msg->body = NULL;
 248                 }
 249         }
 250
 251         CHECK(msg, "<rfc822_body");
 252
 253         if (msg->body)
 254                 return bytestring(msg->body, msg->end - msg->body);
 255         else
 256                 return bytestring_NULL;
 257 }
 258
 259 enum rfc822_header_errors rfc822_header_errors(struct rfc822_msg *msg,
 260                                                struct rfc822_header *hdr)
 261 {
 262         enum rfc822_header_errors err = 0;
 263         int i;
 264
 265         if (!hdr->rawname.ptr) {
 266                 err |= RFC822_HDR_NO_COLON;
 267         } else {
 268                 for (i = 0; i < hdr->rawname.len; i++) {
 269                         char c = hdr->rawname.ptr[i];
 270
 271                         assert(c != ':');
 272
 273                         if ((c < 33) || (c > 126)) {
 274                                 err |= RFC822_HDR_BAD_NAME_CHARS;
 275                                 break;
 276                         }
 277                 }
 278         }
 279         return err;
 280 }
 281
 282 struct bytestring rfc822_header_raw_content(struct rfc822_msg *msg,
 283                                             struct rfc822_header *hdr)
 284 {
 285         return hdr->all;
 286 }
 287
 288 struct bytestring rfc822_header_raw_name(struct rfc822_msg *msg,
 289                                          struct rfc822_header *hdr)
 290 {
 291         return hdr->rawname;
 292 }
 293
 294 struct bytestring rfc822_header_raw_value(struct rfc822_msg *msg,
 295                                           struct rfc822_header *hdr)
 296 {
 297         return hdr->rawvalue;
 298 }
 299
 300 static void get_line(struct bytestring in, struct bytestring *first,
 301                      struct bytestring *rest)
 302 {
 303         size_t rawlen, trimlen;
 304         const char *inp = in.ptr;
 305         const char *nl;
 306
 307         nl = memchr(inp, '\n', in.len);
 308         if (!nl)
 309                 rawlen = in.len;
 310         else
 311                 rawlen = nl - inp + 1;
 312
 313         trimlen = rawlen;
 314         if ((trimlen > 0) && (inp[trimlen-1] == '\n')) {
 315                 trimlen--;
 316                 if ((trimlen > 0) && (inp[trimlen-1] == '\r'))
 317                         trimlen--;
 318         }
 319
 320         *first = bytestring(in.ptr, trimlen);
 321
 322         if (rawlen < in.len)
 323                 *rest = bytestring(in.ptr + rawlen, in.len - rawlen);
 324         else
 325                 *rest = bytestring_NULL;
 326 }
 327
 328
 329 struct bytestring rfc822_header_unfolded_value(struct rfc822_msg *msg,
 330                                                struct rfc822_header *hdr)
 331 {
 332         struct bytestring raw = rfc822_header_raw_value(msg, hdr);
 333         struct bytestring next, rest;
 334         int lines = 0;
 335         size_t len = 0;
 336
 337         if (!hdr->unfolded.ptr) {
 338                 rest = raw;
 339                 while (rest.ptr) {
 340                         get_line(rest, &next, &rest);
 341                         lines++;
 342                         len += next.len;
 343                 }
 344
 345                 if (lines <= 1) {
 346                         hdr->unfolded = bytestring(raw.ptr, len);
 347                 } else {
 348                         char *unfold = tal_arr(msg, char, len);
 349                         char *p = unfold;
 350
 351                         ALLOC_CHECK(unfold, bytestring_NULL);
 352
 353                         rest = raw;
 354                         while (rest.ptr) {
 355                                 get_line(rest, &next, &rest);
 356                                 memcpy(p, next.ptr, next.len);
 357                                 p += next.len;
 358                         }
 359
 360                         assert(p == (unfold + len));
 361                         hdr->unfolded = bytestring(unfold, len);
 362                 }
 363         }
 364
 365         return hdr->unfolded;
 366 }
 367
 368 /* Specifically locale *un*aware tolower() - headers should be ascii
 369  * only, and if they're not best to leave them as is */
 370 static char xtolower(char c)
 371 {
 372         if ((c >= 'A') && (c <= 'Z'))
 373                 return 'a' + (c - 'A');
 374         else
 375                 return c;
 376 }
 377
 378 static bool hdr_name_eq(struct bytestring a, struct bytestring b)
 379 {
 380         int i;
 381
 382         if (a.len != b.len)
 383                 return false;
 384
 385         for (i = 0; i < a.len; i++)
 386                 if (xtolower(a.ptr[i]) != xtolower(b.ptr[i]))
 387                         return false;
 388
 389         return true;
 390 }
 391
 392 bool rfc822_header_is(struct rfc822_msg *msg, struct rfc822_header *hdr,
 393                       const char *name)
 394 {
 395         struct bytestring hname = rfc822_header_raw_name(msg, hdr);
 396
 397         if (!hname.ptr || !name)
 398                 return false;
 399
 400         return hdr_name_eq(hname, bytestring_from_string(name));
 401 }
 402
 403 static unsigned headerhash(struct bytestring name)
 404 {
 405         /*
 406          * This is stolen from hash_string() in ccan/hash, but adapted
 407          * to add the xtolower() call and use a bytestring
 408          */
 409         unsigned ret = 0;
 410         size_t i;
 411
 412         for (i = 0; i < name.len; i++)
 413                 ret = (ret << 5) - ret + xtolower(name.ptr[i]);
 414
 415         return ret % INDEX_HASH_SIZE;
 416 }
 417
 418 static struct rfc822_headers_of_name *headers_of_name(struct rfc822_msg *msg,
 419                                                       struct bytestring name)
 420 {
 421         unsigned hash = headerhash(name);
 422         struct rfc822_headers_of_name *hn;
 423
 424         list_for_each(&msg->header_index[hash], hn, bucket) {
 425                 if (hdr_name_eq(hn->name, name))
 426                         return hn;
 427         }
 428
 429         return NULL;
 430 }
 431
 432 static struct rfc822_header *index_header(struct rfc822_msg *msg,
 433                                           struct rfc822_header *hdr)
 434 {
 435         struct bytestring hname = rfc822_header_raw_name(msg, hdr);
 436         struct rfc822_headers_of_name *hn = headers_of_name(msg, hname);
 437
 438         if (!hn) {
 439                 unsigned hash = headerhash(hname);
 440
 441                 hn = talz(msg, struct rfc822_headers_of_name);
 442                 ALLOC_CHECK(hn, NULL);
 443
 444                 hn->name = hname;
 445                 hn->first = NULL;
 446                 hn->lastptr = &hn->first;
 447                 list_add_tail(&msg->header_index[hash], &hn->bucket);
 448         }
 449
 450         hdr->name_next = NULL;
 451         *(hn->lastptr) = hdr;
 452         hn->lastptr = &hdr->name_next;
 453         return hdr;
 454 }
 455
 456 struct rfc822_header *rfc822_first_header_of_name(struct rfc822_msg *msg,
 457                                                   const char *name)
 458 {
 459         struct bytestring namebs = bytestring_from_string(name);
 460         struct rfc822_headers_of_name *hn = headers_of_name(msg, namebs);
 461         struct rfc822_header *hdr;
 462
 463         if (hn)
 464                 return hn->first;
 465
 466         do {
 467                 hdr = next_header_parse(msg);
 468                 if (hdr && rfc822_header_is(msg, hdr, name))
 469                         return hdr;
 470         } while (hdr);
 471
 472         return NULL;
 473 }
 474
 475 struct rfc822_header *rfc822_next_header_of_name(struct rfc822_msg *msg,
 476                                                  struct rfc822_header *hdr,
 477                                                  const char *name)
 478 {
 479         if (!hdr)
 480                 return rfc822_first_header_of_name(msg, name);
 481
 482         if (hdr->name_next) {
 483                 assert(rfc822_header_is(msg, hdr->name_next, name));
 484                 return hdr->name_next;
 485         }
 486
 487         do {
 488                 hdr = next_header_parse(msg);
 489                 if (hdr && rfc822_header_is(msg, hdr, name))
 490                         return hdr;
 491         } while (hdr);
 492
 493         return NULL;
 494 }