masqmail

view src/parse.c @ 310:f10a56dc7481

find changesets by author, revision, files, or words in the commit message
reworked online_detect to the simpler online_query Only pipe is supported now. Use online_query="/bin/cat /path/to/file" instead of online_detect=file online_file=/path/to/file and online_query="/path/to/some/script foo" instead of online_detect=pipe online_pipe="/path/to/some/script foo" See man page masqmail.conf(5) and admin/config-transition.
author meillo@marmaro.de
date Sun, 24 Apr 2011 19:14:38 +0200
parents 00724782b6c9
children 41958685480d
line source
1 /* MasqMail
2 Copyright (C) 1999-2001 Oliver Kurth
3 Copyright (C) 2010 markus schnalke <meillo@marmaro.de>
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published by
7 the Free Software Foundation; either version 2 of the License, or
8 (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19
20 #ifndef PARSE_TEST
21 #include "masqmail.h"
22 #endif
23
24 /* This is really dangerous. I hope that I was careful enough,
25 but maybe there is some malformed address possible that causes
26 this to segfault or be caught in endless loops.
27
28 If you find something like that, PLEASE mail the string to me
29 (no matter how idiotic it is), so that I can debug that.
30 Those things really should not happen.
31 */
32
33 static gchar *specials = "()<>@,;:\\\".[]`";
34
35 char *parse_error = NULL;
36
37 static gchar*
38 skip_comment(gchar * p)
39 {
40
41 #ifdef PARSE_TEST
42 g_print("skip_comment: %s\n", p);
43 #endif
44
45 p++;
46 while (*p && *p != ')') {
47 p++;
48 if (*p == '(') {
49 p = skip_comment(p);
50 }
51 }
52 p++;
53
54 return p;
55 }
56
57 static gboolean
58 read_word(gchar * p, gchar ** b, gchar ** e)
59 {
60 #ifdef PARSE_TEST
61 g_print("read_word: %s\n", p);
62 #endif
63 /* eat leading spaces */
64 while (*p && isspace(*p)) {
65 p++;
66 }
67
68 *b = p;
69 /* b = &p; */
70 if (*p == '\"') {
71 /* quoted-string */
72 p++;
73 while (*p && (*p != '\"')) {
74 p++;
75 }
76 p++;
77 } else {
78 /* atom */
79 while (*p && !strchr(specials, *p) && !iscntrl(*p) && !isspace(*p)) {
80 p++;
81 }
82 }
83 *e = p;
84 return TRUE;
85 }
86
87 static gboolean
88 read_word_with_dots(gchar * p, gchar ** b, gchar ** e)
89 {
90 gchar *b0 = p;
91
92 #ifdef PARSE_TEST
93 g_print("read_word_with_dots: %s\n", p);
94 #endif
95 while (TRUE) {
96 if (!read_word(p, b, e)) {
97 return FALSE;
98 }
99 p = *e;
100 if (*p != '.') {
101 break;
102 }
103 p++;
104 }
105 *b = b0;
106 *e = p;
107 return TRUE;
108 }
109
110 static gboolean
111 read_domain(gchar * p, gchar ** b, gchar ** e)
112 {
113 #ifdef PARSE_TEST
114 g_print("read_domain: %s\n", p);
115 #endif
116 *b = p;
117 if (*p != '[') {
118 while (isalnum(*p) || (*p == '-') || (*p == '.')) {
119 p++;
120 }
121 } else {
122 p++;
123 while (isalpha(*p) || (*p == '.')) {
124 p++;
125 }
126 if (*p != ']') {
127 parse_error = g_strdup_printf("']' expected at end of literal address %s", *b);
128 return FALSE;
129 }
130 p++;
131 }
132 *e = p;
133 return TRUE;
134 }
135
136 gboolean
137 parse_address_rfc822(gchar* string, gchar** local_begin, gchar** local_end, gchar** domain_begin,
138 gchar** domain_end, gchar** address_end)
139 {
140 gint angle_brackets = 0;
141
142 gchar *p = string;
143 gchar *b, *e;
144
145 *local_begin = *local_end = NULL;
146 *domain_begin = *domain_end = NULL;
147
148 /* might be some memory left from previous call: */
149 if (parse_error) {
150 g_free(parse_error);
151 parse_error = NULL;
152 }
153
154 /* leading spaces and angle brackets */
155 while (*p && (isspace(*p) || (*p == '<'))) {
156 if (*p == '<') {
157 angle_brackets++;
158 }
159 p++;
160 }
161
162 if (!*p) {
163 return FALSE;
164 }
165
166 while (TRUE) {
167 if (!read_word_with_dots(p, &b, &e)) {
168 return FALSE;
169 }
170
171 p = e;
172 #ifdef PARSE_TEST
173 g_print("after read_word_with_dots: %s\n", p);
174 #endif
175 /* eat white spaces and comments */
176 while ((*p && (isspace(*p))) || (*p == '(')) {
177 if (*p == '(') {
178 if (!(p = skip_comment(p))) {
179 parse_error = g_strdup("missing right bracket ')'");
180 return FALSE;
181 }
182 } else {
183 p++;
184 }
185 }
186 /* we now have a non-space char that is not
187 the beginning of a comment */
188
189 if (*p == '@' || *p == ',') {
190 /* the last word was the local_part of an addr-spec */
191 *local_begin = b;
192 *local_end = e;
193 #ifdef PARSE_TEST
194 g_print("found local part: %s\n", *local_begin);
195 #endif
196 if (*p == '@') {
197 p++; /* skip @ */
198 /* now the domain */
199 if (!read_domain(p, &b, &e)) {
200 return FALSE;
201 }
202 p = e;
203 *domain_begin = b;
204 *domain_end = e;
205 } else {
206 /* unqualified? */
207 /* something like `To: alice, bob' with -t */
208 *domain_begin = *domain_end = NULL;
209 }
210 break;
211
212 } else if (*p == '<') {
213 /* addr-spec follows */
214 while (isspace(*p) || (*p == '<')) {
215 if (*p == '<') {
216 angle_brackets++;
217 }
218 p++;
219 }
220 if (!read_word_with_dots(p, &b, &e)) {
221 return FALSE;
222 }
223 p = e;
224 *local_begin = b;
225 *local_end = e;
226 #ifdef PARSE_TEST
227 g_print("found local part: %s\n", *local_begin);
228 #endif
229 if (*p == '@') {
230 p++;
231 if (!read_domain(p, &b, &e)) {
232 return FALSE;
233 }
234 p = e;
235 *domain_begin = b;
236 *domain_end = e;
237 } else {
238 /* may be unqualified address */
239 *domain_begin = *domain_end = NULL;
240 }
241 break;
242
243 } else if (!*p || *p == '>') {
244 *local_begin = b;
245 *local_end = e;
246 #ifdef PARSE_TEST
247 g_print("found local part: %s\n", *local_begin);
248 #endif
249 *domain_begin = *domain_end = NULL;
250 break;
251
252 } else if (strchr(specials, *p) || iscntrl(*p) || isspace(*p)) {
253 parse_error = g_strdup_printf("unexpected character: %c", *p);
254 #ifdef PARSE_TEST
255 g_print("unexpected character: %c", *p);
256 #endif
257 return FALSE;
258 }
259 }
260
261 /* trailing spaces and angle brackets */
262 #ifdef PARSE_TEST
263 g_print("down counting trailing '>'\n");
264 #endif
265 while (*p && (isspace(*p) || (*p == '>'))) {
266 if (*p == '>') {
267 angle_brackets--;
268 }
269 p++;
270 }
271
272 *address_end = p;
273
274 if (angle_brackets > 0) {
275 parse_error = g_strdup("missing '>' at end of string");
276 return FALSE;
277 } else if (angle_brackets < 0) {
278 parse_error = g_strdup("superfluous '>' at end of string");
279 return FALSE;
280 }
281
282 /* we successfully parsed the address */
283 return TRUE;
284 }
285
286 gboolean
287 parse_address_rfc821(gchar* string, gchar** local_begin, gchar** local_end, gchar** domain_begin,
288 gchar** domain_end, gchar** address_end)
289 {
290 gint angle_brackets = 0;
291
292 gchar *p = string;
293 gchar *b, *e;
294
295 *local_begin = *local_end = NULL;
296 *domain_begin = *domain_end = NULL;
297
298 /* might be some memory left from previous call: */
299 if (parse_error != NULL) {
300 g_free(parse_error);
301 parse_error = NULL;
302 }
303
304 /* leading spaces and angle brackets */
305 while (*p && (isspace(*p) || (*p == '<'))) {
306 if (*p == '<') {
307 angle_brackets++;
308 }
309 p++;
310 }
311
312 if (!*p) {
313 return FALSE;
314 }
315
316 while (TRUE) {
317 if (!read_word_with_dots(p, &b, &e)) {
318 return FALSE;
319 }
320
321 p = e;
322 #ifdef PARSE_TEST
323 g_print("after read_word_with_dots: %s\n", p);
324 #endif
325 *local_begin = b;
326 *local_end = e;
327 #ifdef PARSE_TEST
328 g_print("found local part: %s\n", *local_begin);
329 g_print("local_end = %s\n", *local_end);
330 #endif
331 if (!(*p) || isspace(*p) || (*p == '>')) {
332 /* unqualified ? */
333 domain_begin = domain_end = NULL;
334 break;
335 } else if (*p == '@') {
336 p++;
337 if (read_domain(p, &b, &e)) {
338 p = e;
339 *domain_begin = b;
340 *domain_end = e;
341 }
342 break;
343 } else {
344 parse_error = g_strdup_printf ("unexpected character after local part '%c'", *p);
345 return FALSE;
346 }
347 }
348
349 /* trailing spaces and angle brackets */
350 #ifdef PARSE_TEST
351 g_print("down counting trailing '>'\n");
352 #endif
353 while (*p && (isspace(*p) || (*p == '>'))) {
354 if (*p == '>') {
355 angle_brackets--;
356 }
357 p++;
358 }
359 *address_end = p;
360
361 if (angle_brackets > 0) {
362 parse_error = g_strdup("missing '>' at end of string");
363 return FALSE;
364 } else if (angle_brackets < 0) {
365 parse_error = g_strdup("superfluous '>' at end of string");
366 return FALSE;
367 }
368
369 /* we successfully parsed the address */
370 return TRUE;
371 }
372
373 /*
374 allocate address, reading from string.
375 On failure, returns NULL.
376 after call, end contains a pointer to the end of the parsed string
377 end may be NULL, if we are not interested.
378
379 parses both rfc 821 and rfc 822 addresses, depending on flag is_rfc821
380 */
381 address*
382 _create_address(gchar * string, gchar ** end, gboolean is_rfc821)
383 {
384 gchar *loc_beg, *loc_end;
385 gchar *dom_beg, *dom_end;
386 gchar *addr_end;
387 gboolean ret;
388
389 /* TODO: what about (string == NULL)? */
390 if (string && (string[0] == '\0')) {
391 address *addr = g_malloc(sizeof(address));
392 addr->address = g_strdup("");
393 addr->local_part = g_strdup("");
394 /* 'NULL' address (failure notice),
395 "" makes sure it will not be qualified with a hostname */
396 addr->domain = g_strdup("");
397 return addr;
398 }
399
400 if (is_rfc821) {
401 ret = parse_address_rfc821(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end);
402 } else {
403 ret = parse_address_rfc822(string, &loc_beg, &loc_end, &dom_beg, &dom_end, &addr_end);
404 }
405 if (!ret) {
406 return NULL;
407 }
408
409 address *addr = g_malloc(sizeof(address));
410 gchar *p = addr_end;
411
412 memset(addr, 0, sizeof(address));
413
414 if (loc_beg[0] == '|') {
415 parse_error = g_strdup("no pipe allowed for RFC 822/821 address");
416 return NULL;
417 }
418
419 while (*p && (*p != ',')) {
420 p++;
421 }
422 addr->address = g_strndup(string, p - string);
423 addr->local_part = g_strndup(loc_beg, loc_end - loc_beg);
424
425 #ifdef PARSE_TEST
426 g_print("addr->local_part = %s\n", addr->local_part);
427 #endif
428
429 if (dom_beg != NULL) {
430 addr->domain = g_strndup(dom_beg, dom_end - dom_beg);
431 } else if (addr->local_part[0] == '\0') {
432 /* 'NULL' address (failure notice),
433 "" makes sure it will not be qualified with a hostname */
434 addr->domain = g_strdup("");
435 } else {
436 addr->domain = NULL;
437 }
438
439 if (end) {
440 *end = p;
441 }
442
443 #ifndef PARSE_TEST
444 addr_unmark_delivered(addr);
445 #endif
446
447 return addr;
448 }
449
450 address*
451 create_address_rfc822(gchar * string, gchar ** end)
452 {
453 return _create_address(string, end, FALSE);
454 }
455
456 address*
457 create_address_rfc821(gchar * string, gchar ** end)
458 {
459 return _create_address(string, end, TRUE);
460 }
461
462 GList*
463 addr_list_append_rfc822(GList * addr_list, gchar * string, gchar * domain)
464 {
465 gchar *p = string;
466 gchar *end;
467
468 while (*p) {
469 #ifdef PARSE_TEST
470 g_print("string: %s\n", p);
471 #endif
472
473 address *addr = _create_address(p, &end, FALSE);
474 if (!addr) {
475 break;
476 }
477
478 #ifdef PARSE_TEST
479 g_print("addr: %s (%s<@>%s)", addr->address, addr->local_part, addr->domain);
480 #endif
481 if (domain && !addr->domain) {
482 addr->domain = g_strdup(domain);
483 }
484 #ifdef PARSE_TEST
485 g_print(" (%s<@>%s)\n", addr->local_part, addr->domain);
486 #endif
487
488 addr_list = g_list_append(addr_list, addr);
489 p = end;
490
491 while (*p == ',' || isspace(*p)) {
492 p++;
493 }
494 }
495 return addr_list;
496 }