rfc822: new module.
[ccan] / ccan / rfc822 / test / run-hdr-and-body.c
1 #include <ccan/foreach/foreach.h>
2 #include <ccan/failtest/failtest_override.h>
3 #include <ccan/failtest/failtest.h>
4 #include <ccan/tap/tap.h>
5 #include <stdlib.h>
6 #include <string.h>
7
8 #define CCAN_RFC822_DEBUG
9
10 #include <ccan/rfc822/rfc822.h>
11
12 #include <ccan/rfc822/rfc822.c>
13
14 #include "testdata.h"
15 #include "helper.h"
16
17 #define CHECK_HEADERS(_e, _msg, _h, _n, _crlf)  \
18         do { \
19                 int _i; \
20                 for (_i = 0; _i < (_e)->nhdrs; _i++) {  \
21                         (_h) = rfc822_next_header((_msg), (_h)); \
22                         ok((_h), "header %d exists %s", _i, (_n)); \
23                         if (!(_h)) \
24                                 break; \
25                         check_header((_msg), (_h), (_e)->hdrs[_i].name, \
26                                      (_e)->hdrs[_i].val, crlf); \
27                 } \
28         } while (0)
29
30 static void check_header(struct rfc822_msg *msg,
31                          struct rfc822_header *h,
32                          const char *name, const char *val,
33                          int crlf)
34 {
35         struct bytestring hname, hvalue, hfull;
36         size_t namelen = strlen(name);
37         size_t valuelen = strlen(val);
38         size_t nln = crlf ? 2 : 1;
39         size_t fulllen = namelen + valuelen + 1 + nln;
40
41         ok(rfc822_header_errors(msg, h) == 0, "Header valid");
42         allocation_failure_check();
43
44         hname = rfc822_header_raw_name(msg, h);
45         allocation_failure_check();
46
47         ok(hname.ptr && bytestring_eq(hname, bytestring_from_string(name)),
48            "Header name \"%.*s\"", hname.len, hname.ptr);
49
50         hvalue = rfc822_header_raw_value(msg, h);
51         allocation_failure_check();
52
53         ok(hvalue.ptr && ((valuelen + nln) == hvalue.len)
54            && (memcmp(val, hvalue.ptr, valuelen) == 0)
55            && (!crlf || (hvalue.ptr[hvalue.len - 2] == '\r'))
56            && (hvalue.ptr[hvalue.len - 1] == '\n'),
57            "Header value");
58
59         hfull = rfc822_header_raw_content(msg, h);
60         allocation_failure_check();
61
62         ok(hfull.ptr && (fulllen == hfull.len)
63            && (memcmp(name, hfull.ptr, namelen) == 0)
64            && (hfull.ptr[namelen] == ':')
65            && (memcmp(val, hfull.ptr + namelen + 1, valuelen) == 0)
66            && (!crlf || (hfull.ptr[fulllen-2] == '\r'))
67            && (hfull.ptr[fulllen-1] == '\n'),
68            "Full header");
69 }
70
71 static void test_bodyhdr(const struct aexample *e, const char *buf, size_t len,
72                          const char *exname, int crlf)
73 {
74         struct rfc822_msg *msg;
75         struct rfc822_header *h = NULL;
76         struct bytestring body;
77
78         msg = rfc822_start(NULL, buf, len);
79         allocation_failure_check();
80
81         ok(msg, "opened %s", exname);
82
83         body = rfc822_body(msg);
84         allocation_failure_check();
85         ok(bytestring_eq(body, bytestring_from_string(e->body)),
86            "body content %s", exname);
87
88         CHECK_HEADERS(e, msg, h, exname, crlf);
89         h = rfc822_next_header(msg, h);
90         allocation_failure_check();
91         ok(!h, "Too many headers for %s", exname);
92
93         rfc822_free(msg);
94         allocation_failure_check();
95 }
96
97 static void test_hdrbody(const struct aexample *e, const char *buf, size_t len,
98                          const char *exname, int crlf)
99 {
100         struct rfc822_msg *msg;
101         struct rfc822_header *h = NULL;
102         struct bytestring body;
103
104         msg = rfc822_start(NULL, buf, len);
105         allocation_failure_check();
106         ok(msg, "opened %s", exname);
107
108         CHECK_HEADERS(e, msg, h, exname, crlf);
109         h = rfc822_next_header(msg, h);
110         allocation_failure_check();
111         ok(!h, "Too many headers for %s", exname);
112
113         body = rfc822_body(msg);
114         allocation_failure_check();
115         ok(bytestring_eq(body, bytestring_from_string(e->body)),
116            "body content %s", exname);
117
118         rfc822_free(msg);
119         allocation_failure_check();
120 }
121
122 static void test_hdrhdr(const struct aexample *e, const char *buf, size_t len,
123                         const char *exname, int crlf)
124 {
125         struct rfc822_msg *msg;
126         struct rfc822_header *h;
127
128         msg = rfc822_start(NULL, buf, len);
129         allocation_failure_check();
130         ok(msg, "opened %s", exname);
131
132         h = NULL;
133         CHECK_HEADERS(e, msg, h, exname, crlf);
134
135         h = rfc822_next_header(msg, h);
136         allocation_failure_check();
137         ok(!h, "Too many headers for %s", exname);
138
139         /* And again, this time it should be cached */
140         h = NULL;
141         CHECK_HEADERS(e, msg, h, exname, crlf);
142
143         h = rfc822_next_header(msg, h);
144         allocation_failure_check();
145         ok(!h, "Too many headers for %s", exname);
146
147         rfc822_free(msg);
148         allocation_failure_check();
149 }
150
151 int main(int argc, char *argv[])
152 {
153         struct aexample *e;
154
155         /* This is how many tests you plan to run */
156         plan_tests(20*num_aexamples() + 40*num_aexample_hdrs());
157
158         failtest_setup(argc, argv);
159
160         for_each_aexample(e) {
161                 int crlf;
162
163                 foreach_int(crlf, 0, 1) {
164                         const char *buf;
165                         size_t len;
166                         char exname[256];
167
168                         sprintf(exname, "%s[%s]", e->name, NLT(crlf));
169
170                         buf = assemble_msg(e, &len, crlf);
171                         ok((buf), "assembled %s", exname);
172                         if (!buf)
173                                 continue;
174
175                         test_bodyhdr(e, buf, len, exname, crlf);
176                         test_hdrbody(e, buf, len, exname, crlf);
177                         test_hdrhdr(e, buf, len, exname, crlf);
178
179                         talloc_free(buf);
180                 }
181         }
182
183         /* This exits depending on whether all tests passed */
184         failtest_exit(exit_status());
185 }