?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove inclusion of sys/socket.h from nntp-thread.c
[claws.git] / src / plugins / mailmbox / mailimf.c
bloba861004a6f757d73b8c6fcaa6c3ea60970e90855
1 /*
2 * libEtPan! -- a mail stuff library
3 *
4 * Copyright (C) 2001, 2002 - DINH Viet Hoa
5 * All rights reserved.
6 *
7 * Redistribution and use in source and binary forms, with or without
8 * modification, are permitted provided that the following conditions
9 * are met:
10 * 1. Redistributions of source code must retain the above copyright
11 * notice, this list of conditions and the following disclaimer.
12 * 2. Redistributions in binary form must reproduce the above copyright
13 * notice, this list of conditions and the following disclaimer in the
14 * documentation and/or other materials provided with the distribution.
15 * 3. Neither the name of the libEtPan! project nor the names of its
16 * contributors may be used to endorse or promote products derived
17 * from this software without specific prior written permission.
18 *
19 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
20 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
21 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
22 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
23 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
24 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
25 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
26 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
27 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
28 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
29 * SUCH DAMAGE.
30 */
31
32 /*
33 * $Id$
34 */
35
36 #ifdef HAVE_CONFIG_H
37 # include "config.h"
38 #include "claws-features.h"
39 #endif
40
41 #include "mailimf.h"
42 #include "file-utils.h"
43
44 /*
45 RFC 2822
46
47 RFC 2821 ...
48 A message-originating SMTP system SHOULD NOT send a message that
49 already contains a Return-path header. SMTP servers performing a
50 relay function MUST NOT inspect the message data, and especially not
51 to the extent needed to determine if Return-path headers are present.
52 SMTP servers making final delivery MAY remove Return-path headers
53 before adding their own.
54 */
55
56 #include <ctype.h>
57 #include <mmapstring.h>
58 #include <stdlib.h>
59 #include <string.h>
60
61 #ifndef TRUE
62 #define TRUE 1
63 #endif
64
65 #ifndef FALSE
66 #define FALSE 0
67 #endif
68
69
70
71
72
73
74 #if 0
75 static inline int is_dtext(char ch);
76 #endif
77
78 static int mailimf_quoted_pair_parse(const char * message, size_t length,
79 size_t * index, char * result);
80
81 static int mailimf_ccontent_parse(const char * message, size_t length,
82 size_t * index);
83
84 static int
85 mailimf_comment_fws_ccontent_parse(const char * message, size_t length,
86 size_t * index);
87
88 static inline int mailimf_comment_parse(const char * message, size_t length,
89 size_t * index);
90
91 static int mailimf_qcontent_parse(const char * message, size_t length,
92 size_t * index, char * ch);
93
94 static int mailimf_phrase_parse(const char * message, size_t length,
95 size_t * index, char ** result);
96
97 static int mailimf_unstructured_parse(const char * message, size_t length,
98 size_t * index, char ** result);
99
100 static int mailimf_ignore_unstructured_parse(const char * message, size_t length,
101 size_t * index);
102
103 static int mailimf_day_of_week_parse(const char * message, size_t length,
104 size_t * index, int * result);
105
106 static int mailimf_day_name_parse(const char * message, size_t length,
107 size_t * index, int * result);
108
109 static int mailimf_date_parse(const char * message, size_t length,
110 size_t * index,
111 int * pday, int * pmonth, int * pyear);
112
113 static int mailimf_year_parse(const char * message, size_t length,
114 size_t * index, int * result);
115
116 static int mailimf_month_parse(const char * message, size_t length,
117 size_t * index, int * result);
118
119 static int mailimf_month_name_parse(const char * message, size_t length,
120 size_t * index, int * result);
121
122 static int mailimf_day_parse(const char * message, size_t length,
123 size_t * index, int * result);
124
125 static int mailimf_time_parse(const char * message, size_t length,
126 size_t * index,
127 int * phour, int * pmin,
128 int * psec,
129 int * zone);
130 static int mailimf_time_of_day_parse(const char * message, size_t length,
131 size_t * index,
132 int * phour, int * pmin,
133 int * psec);
134
135 static int mailimf_hour_parse(const char * message, size_t length,
136 size_t * index, int * result);
137
138 static int mailimf_minute_parse(const char * message, size_t length,
139 size_t * index, int * result);
140
141 static int mailimf_second_parse(const char * message, size_t length,
142 size_t * index, int * result);
143
144 static int mailimf_zone_parse(const char * message, size_t length,
145 size_t * index, int * result);
146
147 static int mailimf_name_addr_parse(const char * message, size_t length,
148 size_t * index,
149 char ** pdisplay_name,
150 char ** pangle_addr);
151
152 static int mailimf_angle_addr_parse(const char * message, size_t length,
153 size_t * index, char ** result);
154
155 static int mailimf_group_parse(const char * message, size_t length,
156 size_t * index,
157 struct mailimf_group ** result);
158
159 static int mailimf_display_name_parse(const char * message, size_t length,
160 size_t * index, char ** result);
161
162 static int mailimf_addr_spec_parse(const char * message, size_t length,
163 size_t * index,
164 char ** address);
165
166 #if 0
167 static int mailimf_local_part_parse(const char * message, size_t length,
168 size_t * index,
169 char ** result);
170
171 static int mailimf_domain_parse(const char * message, size_t length,
172 size_t * index,
173 char ** result);
174 #endif
175
176 #if 0
177 static int mailimf_domain_literal_parse(const char * message, size_t length,
178 size_t * index, char ** result);
179 #endif
180
181 #if 0
182 static int mailimf_dcontent_parse(const char * message, size_t length,
183 size_t * index, char * result);
184 #endif
185
186 static int
187 mailimf_orig_date_parse(const char * message, size_t length,
188 size_t * index, struct mailimf_orig_date ** result);
189
190 static int
191 mailimf_from_parse(const char * message, size_t length,
192 size_t * index, struct mailimf_from ** result);
193
194 static int
195 mailimf_sender_parse(const char * message, size_t length,
196 size_t * index, struct mailimf_sender ** result);
197
198 static int
199 mailimf_reply_to_parse(const char * message, size_t length,
200 size_t * index, struct mailimf_reply_to ** result);
201
202 static int
203 mailimf_to_parse(const char * message, size_t length,
204 size_t * index, struct mailimf_to ** result);
205
206 static int
207 mailimf_cc_parse(const char * message, size_t length,
208 size_t * index, struct mailimf_cc ** result);
209
210 static int
211 mailimf_bcc_parse(const char * message, size_t length,
212 size_t * index, struct mailimf_bcc ** result);
213
214 static int mailimf_message_id_parse(const char * message, size_t length,
215 size_t * index,
216 struct mailimf_message_id ** result);
217
218 static int
219 mailimf_in_reply_to_parse(const char * message, size_t length,
220 size_t * index,
221 struct mailimf_in_reply_to ** result);
222
223 #if 0
224 static int mailimf_references_parse(const char * message, size_t length,
225 size_t * index,
226 struct mailimf_references **
227 result);
228 #endif
229
230 static int mailimf_unstrict_msg_id_parse(const char * message, size_t length,
231 size_t * index,
232 char ** result);
233
234 #if 0
235 static int mailimf_id_left_parse(const char * message, size_t length,
236 size_t * index, char ** result);
237
238 static int mailimf_id_right_parse(const char * message, size_t length,
239 size_t * index, char ** result);
240 #endif
241
242 #if 0
243 static int mailimf_no_fold_quote_parse(const char * message, size_t length,
244 size_t * index, char ** result);
245
246 static int mailimf_no_fold_literal_parse(const char * message, size_t length,
247 size_t * index, char ** result);
248 #endif
249
250 static int mailimf_subject_parse(const char * message, size_t length,
251 size_t * index,
252 struct mailimf_subject ** result);
253
254 static int mailimf_comments_parse(const char * message, size_t length,
255 size_t * index,
256 struct mailimf_comments ** result);
257
258 static int mailimf_keywords_parse(const char * message, size_t length,
259 size_t * index,
260 struct mailimf_keywords ** result);
261
262 static int
263 mailimf_resent_date_parse(const char * message, size_t length,
264 size_t * index, struct mailimf_orig_date ** result);
265
266 static int
267 mailimf_resent_from_parse(const char * message, size_t length,
268 size_t * index, struct mailimf_from ** result);
269
270 static int
271 mailimf_resent_sender_parse(const char * message, size_t length,
272 size_t * index, struct mailimf_sender ** result);
273
274 static int
275 mailimf_resent_to_parse(const char * message, size_t length,
276 size_t * index, struct mailimf_to ** result);
277
278 static int
279 mailimf_resent_cc_parse(const char * message, size_t length,
280 size_t * index, struct mailimf_cc ** result);
281
282 static int
283 mailimf_resent_bcc_parse(const char * message, size_t length,
284 size_t * index, struct mailimf_bcc ** result);
285
286 static int
287 mailimf_resent_msg_id_parse(const char * message, size_t length,
288 size_t * index,
289 struct mailimf_message_id ** result);
290
291 static int mailimf_return_parse(const char * message, size_t length,
292 size_t * index,
293 struct mailimf_return ** result);
294
295 static int
296 mailimf_path_parse(const char * message, size_t length,
297 size_t * index, struct mailimf_path ** result);
298
299 static int
300 mailimf_optional_field_parse(const char * message, size_t length,
301 size_t * index,
302 struct mailimf_optional_field ** result);
303
304 static int mailimf_field_name_parse(const char * message, size_t length,
305 size_t * index, char ** result);
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331 /* *************************************************************** */
332
333 static inline int is_digit(char ch)
334 {
335 return (ch >= '0') && (ch <= '9');
336 }
337
338 static int mailimf_digit_parse(const char * message, size_t length,
339 size_t * index, int * result)
340 {
341 size_t cur_token;
342
343 cur_token = * index;
344
345 if (cur_token >= length)
346 return MAILIMF_ERROR_PARSE;
347
348 if (is_digit(message[cur_token])) {
349 * result = message[cur_token] - '0';
350 cur_token ++;
351 * index = cur_token;
352 return MAILIMF_NO_ERROR;
353 }
354 else
355 return MAILIMF_ERROR_PARSE;
356 }
357
358 int
359 mailimf_number_parse(const char * message, size_t length,
360 size_t * index, uint32_t * result)
361 {
362 size_t cur_token;
363 int digit;
364 uint32_t number;
365 int parsed;
366 int r;
367
368 cur_token = * index;
369 parsed = FALSE;
370
371 number = 0;
372 while (1) {
373 r = mailimf_digit_parse(message, length, &cur_token, &digit);
374 if (r != MAILIMF_NO_ERROR) {
375 if (r == MAILIMF_ERROR_PARSE)
376 break;
377 else
378 return r;
379 }
380 number *= 10;
381 number += digit;
382 parsed = TRUE;
383 }
384
385 if (!parsed)
386 return MAILIMF_ERROR_PARSE;
387
388 * result = number;
389 * index = cur_token;
390
391 return MAILIMF_NO_ERROR;
392 }
393
394 int mailimf_char_parse(const char * message, size_t length,
395 size_t * index, char token)
396 {
397 size_t cur_token;
398
399 cur_token = * index;
400
401 if (cur_token >= length)
402 return MAILIMF_ERROR_PARSE;
403
404 if (message[cur_token] == token) {
405 cur_token ++;
406 * index = cur_token;
407 return MAILIMF_NO_ERROR;
408 }
409 else
410 return MAILIMF_ERROR_PARSE;
411 }
412
413 int mailimf_unstrict_char_parse(const char * message, size_t length,
414 size_t * index, char token)
415 {
416 size_t cur_token;
417 int r;
418
419 cur_token = * index;
420
421 r = mailimf_cfws_parse(message, length, &cur_token);
422 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
423 return r;
424
425 r = mailimf_char_parse(message, length, &cur_token, token);
426 if (r != MAILIMF_NO_ERROR)
427 return r;
428
429 * index = cur_token;
430
431 return MAILIMF_NO_ERROR;
432 }
433
434 int
435 mailimf_token_case_insensitive_len_parse(const char * message, size_t length,
436 size_t * index, char * token,
437 size_t token_length)
438 {
439 size_t cur_token;
440
441 cur_token = * index;
442
443 if (cur_token + token_length - 1 >= length)
444 return MAILIMF_ERROR_PARSE;
445
446 if (strncasecmp(message + cur_token, token, token_length) == 0) {
447 cur_token += token_length;
448 * index = cur_token;
449 return MAILIMF_NO_ERROR;
450 }
451 else
452 return MAILIMF_ERROR_PARSE;
453 }
454
455 static int mailimf_oparenth_parse(const char * message, size_t length,
456 size_t * index)
457 {
458 return mailimf_char_parse(message, length, index, '(');
459 }
460
461 static int mailimf_cparenth_parse(const char * message, size_t length,
462 size_t * index)
463 {
464 return mailimf_char_parse(message, length, index, ')');
465 }
466
467 static int mailimf_comma_parse(const char * message, size_t length,
468 size_t * index)
469 {
470 return mailimf_unstrict_char_parse(message, length, index, ',');
471 }
472
473 static int mailimf_dquote_parse(const char * message, size_t length,
474 size_t * index)
475 {
476 return mailimf_char_parse(message, length, index, '\"');
477 }
478
479 static int mailimf_colon_parse(const char * message, size_t length,
480 size_t * index)
481 {
482 return mailimf_unstrict_char_parse(message, length, index, ':');
483 }
484
485 static int mailimf_semi_colon_parse(const char * message, size_t length,
486 size_t * index)
487 {
488 return mailimf_unstrict_char_parse(message, length, index, ';');
489 }
490
491 static int mailimf_plus_parse(const char * message, size_t length,
492 size_t * index)
493 {
494 return mailimf_unstrict_char_parse(message, length, index, '+');
495 }
496
497 static int mailimf_minus_parse(const char * message, size_t length,
498 size_t * index)
499 {
500 return mailimf_unstrict_char_parse(message, length, index, '-');
501 }
502
503 static int mailimf_lower_parse(const char * message, size_t length,
504 size_t * index)
505 {
506 return mailimf_unstrict_char_parse(message, length, index, '<');
507 }
508
509 static int mailimf_greater_parse(const char * message, size_t length,
510 size_t * index)
511 {
512 return mailimf_unstrict_char_parse(message, length, index, '>');
513 }
514
515 #if 0
516 static int mailimf_obracket_parse(const char * message, size_t length,
517 size_t * index)
518 {
519 return mailimf_unstrict_char_parse(message, length, index, '[');
520 }
521
522 static int mailimf_cbracket_parse(const char * message, size_t length,
523 size_t * index)
524 {
525 return mailimf_unstrict_char_parse(message, length, index, ']');
526 }
527 #endif
528
529 static int mailimf_at_sign_parse(const char * message, size_t length,
530 size_t * index)
531 {
532 return mailimf_unstrict_char_parse(message, length, index, '@');
533 }
534
535 static int mailimf_point_parse(const char * message, size_t length,
536 size_t * index)
537 {
538 return mailimf_unstrict_char_parse(message, length, index, '.');
539 }
540
541 int
542 mailimf_custom_string_parse(const char * message, size_t length,
543 size_t * index, char ** result,
544 int (* is_custom_char)(char))
545 {
546 size_t begin;
547 size_t end;
548 char * gstr;
549
550 begin = * index;
551
552 end = begin;
553
554 if (end >= length)
555 return MAILIMF_ERROR_PARSE;
556
557 while (is_custom_char(message[end])) {
558 end ++;
559 if (end >= length)
560 break;
561 }
562
563 if (end != begin) {
564 /*
565 gstr = strndup(message + begin, end - begin);
566 */
567 gstr = malloc(end - begin + 1);
568 if (gstr == NULL)
569 return MAILIMF_ERROR_MEMORY;
570 strncpy(gstr, message + begin, end - begin);
571 gstr[end - begin] = '\0';
572
573 * index = end;
574 * result = gstr;
575 return MAILIMF_NO_ERROR;
576 }
577 else
578 return MAILIMF_ERROR_PARSE;
579 }
580
581
582
583
584
585
586
587 typedef int mailimf_struct_parser(const char * message, size_t length,
588 size_t * index, void * result);
589
590 typedef int mailimf_struct_destructor(void * result);
591
592
593 static int
594 mailimf_struct_multiple_parse(const char * message, size_t length,
595 size_t * index, clist ** result,
596 mailimf_struct_parser * parser,
597 mailimf_struct_destructor * destructor)
598 {
599 clist * struct_list;
600 size_t cur_token;
601 void * value;
602 int r;
603 int res;
604
605 cur_token = * index;
606
607 r = parser(message, length, &cur_token, &value);
608 if (r != MAILIMF_NO_ERROR) {
609 res = r;
610 goto err;
611 }
612
613 struct_list = clist_new();
614 if (struct_list == NULL) {
615 destructor(value);
616 res = MAILIMF_ERROR_MEMORY;
617 goto err;
618 }
619
620 r = clist_append(struct_list, value);
621 if (r < 0) {
622 destructor(value);
623 res = MAILIMF_ERROR_MEMORY;
624 goto free;
625 }
626
627 while (1) {
628 r = parser(message, length, &cur_token, &value);
629 if (r != MAILIMF_NO_ERROR) {
630 if (r == MAILIMF_ERROR_PARSE)
631 break;
632 else {
633 res = r;
634 goto free;
635 }
636 }
637 r = clist_append(struct_list, value);
638 if (r < 0) {
639 (* destructor)(value);
640 res = MAILIMF_ERROR_MEMORY;
641 goto free;
642 }
643 }
644
645 * result = struct_list;
646 * index = cur_token;
647
648 return MAILIMF_NO_ERROR;
649
650 free:
651 clist_foreach(struct_list, (clist_func) destructor, NULL);
652 clist_free(struct_list);
653 err:
654 return res;
655 }
656
657
658
659 static int
660 mailimf_struct_list_parse(const char * message, size_t length,
661 size_t * index, clist ** result,
662 char symbol,
663 mailimf_struct_parser * parser,
664 mailimf_struct_destructor * destructor)
665 {
666 clist * struct_list;
667 size_t cur_token;
668 void * value;
669 size_t final_token;
670 int r;
671 int res;
672
673 cur_token = * index;
674
675 r = parser(message, length, &cur_token, &value);
676 if (r != MAILIMF_NO_ERROR) {
677 res = r;
678 goto err;
679 }
680
681 struct_list = clist_new();
682 if (struct_list == NULL) {
683 destructor(value);
684 res = MAILIMF_ERROR_MEMORY;
685 goto err;
686 }
687
688 r = clist_append(struct_list, value);
689 if (r < 0) {
690 destructor(value);
691 res = MAILIMF_ERROR_MEMORY;
692 goto free;
693 }
694
695 final_token = cur_token;
696
697 while (1) {
698 r = mailimf_unstrict_char_parse(message, length, &cur_token, symbol);
699 if (r != MAILIMF_NO_ERROR) {
700 if (r == MAILIMF_ERROR_PARSE)
701 break;
702 else {
703 res = r;
704 goto free;
705 }
706 }
707
708 r = parser(message, length, &cur_token, &value);
709 if (r != MAILIMF_NO_ERROR) {
710 if (r == MAILIMF_ERROR_PARSE)
711 break;
712 else {
713 res = r;
714 goto free;
715 }
716 }
717
718 r = clist_append(struct_list, value);
719 if (r < 0) {
720 destructor(value);
721 res = MAILIMF_ERROR_MEMORY;
722 goto free;
723 }
724
725 final_token = cur_token;
726 }
727
728 * result = struct_list;
729 * index = final_token;
730
731 return MAILIMF_NO_ERROR;
732
733 free:
734 clist_foreach(struct_list, (clist_func) destructor, NULL);
735 clist_free(struct_list);
736 err:
737 return res;
738 }
739
740 static inline int mailimf_wsp_parse(const char * message, size_t length,
741 size_t * index)
742 {
743 size_t cur_token;
744
745 cur_token = * index;
746
747 if (cur_token >= length)
748 return MAILIMF_ERROR_PARSE;
749
750 if ((message[cur_token] != ' ') && (message[cur_token] != '\t'))
751 return MAILIMF_ERROR_PARSE;
752
753 cur_token ++;
754 * index = cur_token;
755
756 return MAILIMF_NO_ERROR;
757 }
758
759
760 int mailimf_crlf_parse(const char * message, size_t length, size_t * index)
761 {
762 size_t cur_token;
763 int r;
764
765 cur_token = * index;
766
767 r = mailimf_char_parse(message, length, &cur_token, '\r');
768 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
769 return r;
770
771 r = mailimf_char_parse(message, length, &cur_token, '\n');
772 if (r != MAILIMF_NO_ERROR)
773 return r;
774
775 * index = cur_token;
776 return MAILIMF_NO_ERROR;
777 }
778
779 static int mailimf_unstrict_crlf_parse(const char * message,
780 size_t length, size_t * index)
781 {
782 size_t cur_token;
783 int r;
784
785 cur_token = * index;
786
787 mailimf_cfws_parse(message, length, &cur_token);
788
789 r = mailimf_char_parse(message, length, &cur_token, '\r');
790 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
791 return r;
792
793 r = mailimf_char_parse(message, length, &cur_token, '\n');
794 if (r != MAILIMF_NO_ERROR)
795 return r;
796
797 * index = cur_token;
798 return MAILIMF_NO_ERROR;
799 }
800
801 /* ************************************************************************ */
802
803
804
805 /* RFC 2822 grammar */
806
807 /*
808 NO-WS-CTL = %d1-8 / ; US-ASCII control characters
809 %d11 / ; that do not include the
810 %d12 / ; carriage return, line feed,
811 %d14-31 / ; and white space characters
812 %d127
813 */
814
815 static inline int is_no_ws_ctl(char ch)
816 {
817 if ((ch == 9) || (ch == 10) || (ch == 13))
818 return FALSE;
819
820 if (ch == 127)
821 return TRUE;
822
823 return (ch >= 1) && (ch <= 31);
824 }
825
826 /*
827 text = %d1-9 / ; Characters excluding CR and LF
828 %d11 /
829 %d12 /
830 %d14-127 /
831 obs-text
832 */
833
834 /*
835 specials = "(" / ")" / ; Special characters used in
836 "<" / ">" / ; other parts of the syntax
837 "[" / "]" /
838 ":" / ";" /
839 "@" / "\" /
840 "," / "." /
841 DQUOTE
842 */
843
844 /*
845 quoted-pair = ("\" text) / obs-qp
846 */
847
848 static inline int mailimf_quoted_pair_parse(const char * message, size_t length,
849 size_t * index, char * result)
850 {
851 size_t cur_token;
852
853 cur_token = * index;
854
855 if (cur_token + 1 >= length)
856 return MAILIMF_ERROR_PARSE;
857
858 if (message[cur_token] != '\\')
859 return MAILIMF_ERROR_PARSE;
860
861 cur_token ++;
862 * result = message[cur_token];
863 cur_token ++;
864 * index = cur_token;
865
866 return MAILIMF_NO_ERROR;
867 }
868
869 /*
870 FWS = ([*WSP CRLF] 1*WSP) / ; Folding white space
871 obs-FWS
872 */
873
874 int mailimf_fws_parse(const char * message, size_t length, size_t * index)
875 {
876 size_t cur_token;
877 size_t final_token;
878 int fws_1;
879 int fws_2;
880 int fws_3;
881 int r;
882
883 cur_token = * index;
884
885 fws_1 = FALSE;
886 while (1) {
887 r = mailimf_wsp_parse(message, length, &cur_token);
888 if (r != MAILIMF_NO_ERROR) {
889 if (r == MAILIMF_ERROR_PARSE)
890 break;
891 else
892 return r;
893 }
894 fws_1 = TRUE;
895 }
896 final_token = cur_token;
897
898 r = mailimf_crlf_parse(message, length, &cur_token);
899 switch (r) {
900 case MAILIMF_NO_ERROR:
901 fws_2 = TRUE;
902 break;
903 case MAILIMF_ERROR_PARSE:
904 fws_2 = FALSE;
905 break;
906 default:
907 return r;
908 }
909
910 fws_3 = FALSE;
911 if (fws_2) {
912 while (1) {
913 r = mailimf_wsp_parse(message, length, &cur_token);
914 if (r != MAILIMF_NO_ERROR) {
915 if (r == MAILIMF_ERROR_PARSE)
916 break;
917 else
918 return r;
919 }
920 fws_3 = TRUE;
921 }
922 }
923
924 if ((!fws_1) && (!fws_3))
925 return MAILIMF_ERROR_PARSE;
926
927 if (!fws_3)
928 cur_token = final_token;
929
930 * index = cur_token;
931
932 return MAILIMF_NO_ERROR;
933 }
934
935
936 /*
937 ctext = NO-WS-CTL / ; Non white space controls
938
939 %d33-39 / ; The rest of the US-ASCII
940 %d42-91 / ; characters not including "(",
941 %d93-126 ; ")", or "\"
942 */
943
944 static inline int is_ctext(char ch)
945 {
946 unsigned char uch = (unsigned char) ch;
947
948 if (is_no_ws_ctl(ch))
949 return TRUE;
950
951 if (uch < 33)
952 return FALSE;
953
954 if ((uch == 40) || (uch == 41))
955 return FALSE;
956
957 if (uch == 92)
958 return FALSE;
959
960 if (uch == 127)
961 return FALSE;
962
963 return TRUE;
964 }
965
966 /*
967 ccontent = ctext / quoted-pair / comment
968 */
969
970 static inline int mailimf_ccontent_parse(const char * message, size_t length,
971 size_t * index)
972 {
973 size_t cur_token;
974 char ch;
975 int r;
976
977 cur_token = * index;
978
979 if (cur_token >= length)
980 return MAILIMF_ERROR_PARSE;
981
982 if (is_ctext(message[cur_token])) {
983 cur_token ++;
984 }
985 else {
986 r = mailimf_quoted_pair_parse(message, length, &cur_token, &ch);
987
988 if (r == MAILIMF_ERROR_PARSE)
989 r = mailimf_comment_parse(message, length, &cur_token);
990
991 if (r == MAILIMF_ERROR_PARSE)
992 return r;
993 }
994
995 * index = cur_token;
996
997 return MAILIMF_NO_ERROR;
998 }
999
1000 /*
1001 [FWS] ccontent
1002 */
1003
1004 static inline int
1005 mailimf_comment_fws_ccontent_parse(const char * message, size_t length,
1006 size_t * index)
1007 {
1008 size_t cur_token;
1009 int r;
1010
1011 cur_token = * index;
1012
1013 r = mailimf_fws_parse(message, length, &cur_token);
1014 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
1015 return r;
1016
1017 r = mailimf_ccontent_parse(message, length, &cur_token);
1018 if (r != MAILIMF_NO_ERROR)
1019 return r;
1020
1021 * index = cur_token;
1022
1023 return MAILIMF_NO_ERROR;
1024 }
1025
1026 /*
1027 comment = "(" *([FWS] ccontent) [FWS] ")"
1028 */
1029
1030 static inline int mailimf_comment_parse(const char * message, size_t length,
1031 size_t * index)
1032 {
1033 size_t cur_token;
1034 int r;
1035
1036 cur_token = * index;
1037
1038 r = mailimf_oparenth_parse(message, length, &cur_token);
1039 if (r != MAILIMF_NO_ERROR)
1040 return r;
1041
1042 while (1) {
1043 r = mailimf_comment_fws_ccontent_parse(message, length, &cur_token);
1044 if (r != MAILIMF_NO_ERROR) {
1045 if (r == MAILIMF_ERROR_PARSE)
1046 break;
1047 else
1048 return r;
1049 }
1050 }
1051
1052 r = mailimf_fws_parse(message, length, &cur_token);
1053 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
1054 return r;
1055
1056 r = mailimf_cparenth_parse(message, length, &cur_token);
1057 if (r != MAILIMF_NO_ERROR)
1058 return r;
1059
1060 * index = cur_token;
1061
1062 return MAILIMF_NO_ERROR;
1063 }
1064
1065 /*
1066 [FWS] comment
1067 */
1068
1069 static inline int mailimf_cfws_fws_comment_parse(const char * message, size_t length,
1070 size_t * index)
1071 {
1072 size_t cur_token;
1073 int r;
1074
1075 cur_token = * index;
1076
1077 r = mailimf_fws_parse(message, length, &cur_token);
1078 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
1079 return r;
1080
1081 r = mailimf_comment_parse(message, length, &cur_token);
1082 if (r != MAILIMF_NO_ERROR)
1083 return r;
1084
1085 * index = cur_token;
1086
1087 return MAILIMF_NO_ERROR;
1088 }
1089
1090 /*
1091 CFWS = *([FWS] comment) (([FWS] comment) / FWS)
1092 */
1093
1094 int mailimf_cfws_parse(const char * message, size_t length,
1095 size_t * index)
1096 {
1097 size_t cur_token;
1098 int has_comment;
1099 int r;
1100
1101 cur_token = * index;
1102
1103 has_comment = FALSE;
1104 while (1) {
1105 r = mailimf_cfws_fws_comment_parse(message, length, &cur_token);
1106 if (r != MAILIMF_NO_ERROR) {
1107 if (r == MAILIMF_ERROR_PARSE)
1108 break;
1109 else
1110 return r;
1111 }
1112 has_comment = TRUE;
1113 }
1114
1115 if (!has_comment) {
1116 r = mailimf_fws_parse(message, length, &cur_token);
1117 if (r != MAILIMF_NO_ERROR)
1118 return r;
1119 }
1120
1121 * index = cur_token;
1122
1123 return MAILIMF_NO_ERROR;
1124 }
1125
1126 /*
1127 atext = ALPHA / DIGIT / ; Any character except controls,
1128 "!" / "#" / ; SP, and specials.
1129 "$" / "%" / ; Used for atoms
1130 "&" / "'" /
1131 "*" / "+" /
1132 "-" / "/" /
1133 "=" / "?" /
1134 "^" / "_" /
1135 "`" / "{" /
1136 "|" / "}" /
1137 "~"
1138 */
1139
1140 static inline int is_atext(char ch)
1141 {
1142 switch (ch) {
1143 case ' ':
1144 case '\t':
1145 case '\n':
1146 case '\r':
1147 #if 0
1148 case '(':
1149 case ')':
1150 #endif
1151 case '<':
1152 case '>':
1153 #if 0
1154 case '@':
1155 #endif
1156 case ',':
1157 case '"':
1158 case ':':
1159 case ';':
1160 return FALSE;
1161 default:
1162 return TRUE;
1163 }
1164 }
1165
1166 /*
1167 atom = [CFWS] 1*atext [CFWS]
1168 */
1169
1170 int mailimf_atom_parse(const char * message, size_t length,
1171 size_t * index, char ** result)
1172 {
1173 size_t cur_token;
1174 int r;
1175 int res;
1176 char * atom;
1177 size_t end;
1178
1179 cur_token = * index;
1180
1181 r = mailimf_cfws_parse(message, length, &cur_token);
1182 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
1183 res = r;
1184 goto err;
1185 }
1186
1187 end = cur_token;
1188 if (end >= length) {
1189 res = MAILIMF_ERROR_PARSE;
1190 goto err;
1191 }
1192
1193 while (is_atext(message[end])) {
1194 end ++;
1195 if (end >= length)
1196 break;
1197 }
1198 if (end == cur_token) {
1199 res = MAILIMF_ERROR_PARSE;
1200 goto err;
1201 }
1202
1203 atom = malloc(end - cur_token + 1);
1204 if (atom == NULL) {
1205 res = MAILIMF_ERROR_MEMORY;
1206 goto err;
1207 }
1208 strncpy(atom, message + cur_token, end - cur_token);
1209 atom[end - cur_token] = '\0';
1210
1211 cur_token = end;
1212
1213 * index = cur_token;
1214 * result = atom;
1215
1216 return MAILIMF_NO_ERROR;
1217
1218 err:
1219 return res;
1220 }
1221
1222 int mailimf_fws_atom_parse(const char * message, size_t length,
1223 size_t * index, char ** result)
1224 {
1225 size_t cur_token;
1226 int r;
1227 int res;
1228 char * atom;
1229 size_t end;
1230
1231 cur_token = * index;
1232
1233 r = mailimf_fws_parse(message, length, &cur_token);
1234 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
1235 res = r;
1236 goto err;
1237 }
1238
1239 end = cur_token;
1240 if (end >= length) {
1241 res = MAILIMF_ERROR_PARSE;
1242 goto err;
1243 }
1244
1245 while (is_atext(message[end])) {
1246 end ++;
1247 if (end >= length)
1248 break;
1249 }
1250 if (end == cur_token) {
1251 res = MAILIMF_ERROR_PARSE;
1252 goto err;
1253 }
1254
1255 atom = malloc(end - cur_token + 1);
1256 if (atom == NULL) {
1257 res = MAILIMF_ERROR_MEMORY;
1258 goto err;
1259 }
1260 strncpy(atom, message + cur_token, end - cur_token);
1261 atom[end - cur_token] = '\0';
1262
1263 cur_token = end;
1264
1265 * index = cur_token;
1266 * result = atom;
1267
1268 return MAILIMF_NO_ERROR;
1269
1270 err:
1271 return res;
1272 }
1273
1274 /*
1275 dot-atom = [CFWS] dot-atom-text [CFWS]
1276 */
1277
1278 #if 0
1279 static int mailimf_dot_atom_parse(const char * message, size_t length,
1280 size_t * index, char ** result)
1281 {
1282 return mailimf_atom_parse(message, length, index, result);
1283 }
1284 #endif
1285
1286 /*
1287 dot-atom-text = 1*atext *("." 1*atext)
1288 */
1289
1290 #if 0
1291 static int
1292 mailimf_dot_atom_text_parse(const char * message, size_t length,
1293 size_t * index, char ** result)
1294 {
1295 return mailimf_atom_parse(message, length, index, result);
1296 }
1297 #endif
1298
1299 /*
1300 qtext = NO-WS-CTL / ; Non white space controls
1301
1302 %d33 / ; The rest of the US-ASCII
1303 %d35-91 / ; characters not including "\"
1304 %d93-126 ; or the quote character
1305 */
1306
1307 static inline int is_qtext(char ch)
1308 {
1309 unsigned char uch = (unsigned char) ch;
1310
1311 if (is_no_ws_ctl(ch))
1312 return TRUE;
1313
1314 if (uch < 33)
1315 return FALSE;
1316
1317 if (uch == 34)
1318 return FALSE;
1319
1320 if (uch == 92)
1321 return FALSE;
1322
1323 if (uch == 127)
1324 return FALSE;
1325
1326 return TRUE;
1327 }
1328
1329 /*
1330 qcontent = qtext / quoted-pair
1331 */
1332
1333 static int mailimf_qcontent_parse(const char * message, size_t length,
1334 size_t * index, char * result)
1335 {
1336 size_t cur_token;
1337 char ch;
1338 int r;
1339
1340 cur_token = * index;
1341
1342 if (cur_token >= length)
1343 return MAILIMF_ERROR_PARSE;
1344
1345 if (is_qtext(message[cur_token])) {
1346 ch = message[cur_token];
1347 cur_token ++;
1348 }
1349 else {
1350 r = mailimf_quoted_pair_parse(message, length, &cur_token, &ch);
1351
1352 if (r != MAILIMF_NO_ERROR)
1353 return r;
1354 }
1355
1356 * result = ch;
1357 * index = cur_token;
1358
1359 return MAILIMF_NO_ERROR;
1360 }
1361
1362 /*
1363 quoted-string = [CFWS]
1364 DQUOTE *([FWS] qcontent) [FWS] DQUOTE
1365 [CFWS]
1366 */
1367
1368 int mailimf_quoted_string_parse(const char * message, size_t length,
1369 size_t * index, char ** result)
1370 {
1371 size_t cur_token;
1372 MMAPString * gstr;
1373 char ch;
1374 char * str;
1375 int r;
1376 int res;
1377
1378 cur_token = * index;
1379
1380 r = mailimf_cfws_parse(message, length, &cur_token);
1381 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
1382 res = r;
1383 goto err;
1384 }
1385
1386 r = mailimf_dquote_parse(message, length, &cur_token);
1387 if (r != MAILIMF_NO_ERROR) {
1388 res = r;
1389 goto err;
1390 }
1391
1392 gstr = mmap_string_new("");
1393 if (gstr == NULL) {
1394 res = MAILIMF_ERROR_MEMORY;
1395 goto err;
1396 }
1397
1398 #if 0
1399 if (mmap_string_append_c(gstr, '\"') == NULL) {
1400 res = MAILIMF_ERROR_MEMORY;
1401 goto free_gstr;
1402 }
1403 #endif
1404
1405 while (1) {
1406 r = mailimf_fws_parse(message, length, &cur_token);
1407 if (r == MAILIMF_NO_ERROR) {
1408 if (mmap_string_append_c(gstr, ' ') == NULL) {
1409 res = MAILIMF_ERROR_MEMORY;
1410 goto free_gstr;
1411 }
1412 }
1413 else if (r != MAILIMF_ERROR_PARSE) {
1414 res = r;
1415 goto free_gstr;
1416 }
1417
1418 r = mailimf_qcontent_parse(message, length, &cur_token, &ch);
1419 if (r == MAILIMF_NO_ERROR) {
1420 if (mmap_string_append_c(gstr, ch) == NULL) {
1421 res = MAILIMF_ERROR_MEMORY;
1422 goto free_gstr;
1423 }
1424 }
1425 else if (r == MAILIMF_ERROR_PARSE)
1426 break;
1427 else {
1428 res = r;
1429 goto free_gstr;
1430 }
1431 }
1432
1433 r = mailimf_dquote_parse(message, length, &cur_token);
1434 if (r != MAILIMF_NO_ERROR) {
1435 res = r;
1436 goto free_gstr;
1437 }
1438
1439 #if 0
1440 if (mmap_string_append_c(gstr, '\"') == NULL) {
1441 res = MAILIMF_ERROR_MEMORY;
1442 goto free_gstr;
1443 }
1444 #endif
1445
1446 str = strdup(gstr->str);
1447 if (str == NULL) {
1448 res = MAILIMF_ERROR_MEMORY;
1449 goto free_gstr;
1450 }
1451 mmap_string_free(gstr);
1452
1453 * index = cur_token;
1454 * result = str;
1455
1456 return MAILIMF_NO_ERROR;
1457
1458 free_gstr:
1459 mmap_string_free(gstr);
1460 err:
1461 return res;
1462 }
1463
1464 int mailimf_fws_quoted_string_parse(const char * message, size_t length,
1465 size_t * index, char ** result)
1466 {
1467 size_t cur_token;
1468 MMAPString * gstr;
1469 char ch;
1470 char * str;
1471 int r;
1472 int res;
1473
1474 cur_token = * index;
1475
1476 r = mailimf_fws_parse(message, length, &cur_token);
1477 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
1478 res = r;
1479 goto err;
1480 }
1481
1482 r = mailimf_dquote_parse(message, length, &cur_token);
1483 if (r != MAILIMF_NO_ERROR) {
1484 res = r;
1485 goto err;
1486 }
1487
1488 gstr = mmap_string_new("");
1489 if (gstr == NULL) {
1490 res = MAILIMF_ERROR_MEMORY;
1491 goto err;
1492 }
1493
1494 #if 0
1495 if (mmap_string_append_c(gstr, '\"') == NULL) {
1496 res = MAILIMF_ERROR_MEMORY;
1497 goto free_gstr;
1498 }
1499 #endif
1500
1501 while (1) {
1502 r = mailimf_fws_parse(message, length, &cur_token);
1503 if (r == MAILIMF_NO_ERROR) {
1504 if (mmap_string_append_c(gstr, ' ') == NULL) {
1505 res = MAILIMF_ERROR_MEMORY;
1506 goto free_gstr;
1507 }
1508 }
1509 else if (r != MAILIMF_ERROR_PARSE) {
1510 res = r;
1511 goto free_gstr;
1512 }
1513
1514 r = mailimf_qcontent_parse(message, length, &cur_token, &ch);
1515 if (r == MAILIMF_NO_ERROR) {
1516 if (mmap_string_append_c(gstr, ch) == NULL) {
1517 res = MAILIMF_ERROR_MEMORY;
1518 goto free_gstr;
1519 }
1520 }
1521 else if (r == MAILIMF_ERROR_PARSE)
1522 break;
1523 else {
1524 res = r;
1525 goto free_gstr;
1526 }
1527 }
1528
1529 r = mailimf_dquote_parse(message, length, &cur_token);
1530 if (r != MAILIMF_NO_ERROR) {
1531 res = r;
1532 goto free_gstr;
1533 }
1534
1535 #if 0
1536 if (mmap_string_append_c(gstr, '\"') == NULL) {
1537 res = MAILIMF_ERROR_MEMORY;
1538 goto free_gstr;
1539 }
1540 #endif
1541
1542 str = strdup(gstr->str);
1543 if (str == NULL) {
1544 res = MAILIMF_ERROR_MEMORY;
1545 goto free_gstr;
1546 }
1547 mmap_string_free(gstr);
1548
1549 * index = cur_token;
1550 * result = str;
1551
1552 return MAILIMF_NO_ERROR;
1553
1554 free_gstr:
1555 mmap_string_free(gstr);
1556 err:
1557 return res;
1558 }
1559
1560 /*
1561 word = atom / quoted-string
1562 */
1563
1564 int mailimf_word_parse(const char * message, size_t length,
1565 size_t * index, char ** result)
1566 {
1567 size_t cur_token;
1568 char * word;
1569 int r;
1570
1571 cur_token = * index;
1572
1573 r = mailimf_atom_parse(message, length, &cur_token, &word);
1574
1575 if (r == MAILIMF_ERROR_PARSE)
1576 r = mailimf_quoted_string_parse(message, length, &cur_token, &word);
1577
1578 if (r != MAILIMF_NO_ERROR)
1579 return r;
1580
1581 * result = word;
1582 * index = cur_token;
1583
1584 return MAILIMF_NO_ERROR;
1585 }
1586
1587 int mailimf_fws_word_parse(const char * message, size_t length,
1588 size_t * index, char ** result)
1589 {
1590 size_t cur_token;
1591 char * word;
1592 int r;
1593
1594 cur_token = * index;
1595
1596 r = mailimf_fws_atom_parse(message, length, &cur_token, &word);
1597
1598 if (r == MAILIMF_ERROR_PARSE)
1599 r = mailimf_fws_quoted_string_parse(message, length, &cur_token, &word);
1600
1601 if (r != MAILIMF_NO_ERROR)
1602 return r;
1603
1604 * result = word;
1605 * index = cur_token;
1606
1607 return MAILIMF_NO_ERROR;
1608 }
1609
1610 /*
1611 phrase = 1*word / obs-phrase
1612 */
1613
1614 static int mailimf_phrase_parse(const char * message, size_t length,
1615 size_t * index, char ** result)
1616 {
1617 MMAPString * gphrase;
1618 char * word;
1619 int first;
1620 size_t cur_token;
1621 int r;
1622 int res;
1623 char * str;
1624
1625 cur_token = * index;
1626
1627 gphrase = mmap_string_new("");
1628 if (gphrase == NULL) {
1629 res = MAILIMF_ERROR_MEMORY;
1630 goto err;
1631 }
1632
1633 first = TRUE;
1634
1635 while (1) {
1636 r = mailimf_fws_word_parse(message, length, &cur_token, &word);
1637 if (r == MAILIMF_NO_ERROR) {
1638 if (!first) {
1639 if (mmap_string_append_c(gphrase, ' ') == NULL) {
1640 mailimf_word_free(word);
1641 res = MAILIMF_ERROR_MEMORY;
1642 goto free;
1643 }
1644 }
1645 if (mmap_string_append(gphrase, word) == NULL) {
1646 mailimf_word_free(word);
1647 res = MAILIMF_ERROR_MEMORY;
1648 goto free;
1649 }
1650 mailimf_word_free(word);
1651 first = FALSE;
1652 }
1653 else if (r == MAILIMF_ERROR_PARSE)
1654 break;
1655 else {
1656 res = r;
1657 goto free;
1658 }
1659 }
1660
1661 if (first) {
1662 res = MAILIMF_ERROR_PARSE;
1663 goto free;
1664 }
1665
1666 str = strdup(gphrase->str);
1667 if (str == NULL) {
1668 res = MAILIMF_ERROR_MEMORY;
1669 goto free;
1670 }
1671 mmap_string_free(gphrase);
1672
1673 * result = str;
1674 * index = cur_token;
1675
1676 return MAILIMF_NO_ERROR;
1677
1678 free:
1679 mmap_string_free(gphrase);
1680 err:
1681 return res;
1682 }
1683
1684 /*
1685 utext = NO-WS-CTL / ; Non white space controls
1686 %d33-126 / ; The rest of US-ASCII
1687 obs-utext
1688
1689 added : WSP
1690 */
1691
1692 enum {
1693 UNSTRUCTURED_START,
1694 UNSTRUCTURED_CR,
1695 UNSTRUCTURED_LF,
1696 UNSTRUCTURED_WSP,
1697 UNSTRUCTURED_OUT
1698 };
1699
1700 static int mailimf_unstructured_parse(const char * message, size_t length,
1701 size_t * index, char ** result)
1702 {
1703 size_t cur_token;
1704 int state;
1705 size_t begin;
1706 size_t terminal;
1707 char * str;
1708
1709 cur_token = * index;
1710
1711
1712 while (1) {
1713 int r;
1714
1715 r = mailimf_wsp_parse(message, length, &cur_token);
1716 if (r == MAILIMF_NO_ERROR) {
1717 /* do nothing */
1718 }
1719 else if (r == MAILIMF_ERROR_PARSE)
1720 break;
1721 else {
1722 return r;
1723 }
1724 }
1725
1726 state = UNSTRUCTURED_START;
1727 begin = cur_token;
1728 terminal = cur_token;
1729
1730 while (state != UNSTRUCTURED_OUT) {
1731
1732 switch(state) {
1733 case UNSTRUCTURED_START:
1734 if (cur_token >= length)
1735 return MAILIMF_ERROR_PARSE;
1736
1737 terminal = cur_token;
1738 switch(message[cur_token]) {
1739 case '\r':
1740 state = UNSTRUCTURED_CR;
1741 break;
1742 case '\n':
1743 state = UNSTRUCTURED_LF;
1744 break;
1745 default:
1746 state = UNSTRUCTURED_START;
1747 break;
1748 }
1749 break;
1750 case UNSTRUCTURED_CR:
1751 if (cur_token >= length)
1752 return MAILIMF_ERROR_PARSE;
1753
1754 switch(message[cur_token]) {
1755 case '\n':
1756 state = UNSTRUCTURED_LF;
1757 break;
1758 default:
1759 state = UNSTRUCTURED_START;
1760 break;
1761 }
1762 break;
1763
1764 case UNSTRUCTURED_LF:
1765 if (cur_token >= length) {
1766 state = UNSTRUCTURED_OUT;
1767 break;
1768 }
1769
1770 switch(message[cur_token]) {
1771 case '\t':
1772 case ' ':
1773 state = UNSTRUCTURED_WSP;
1774 break;
1775 default:
1776 state = UNSTRUCTURED_OUT;
1777 break;
1778 }
1779 break;
1780 case UNSTRUCTURED_WSP:
1781 if (cur_token >= length)
1782 return MAILIMF_ERROR_PARSE;
1783
1784 switch(message[cur_token]) {
1785 case '\r':
1786 state = UNSTRUCTURED_CR;
1787 break;
1788 case '\n':
1789 state = UNSTRUCTURED_LF;
1790 break;
1791 default:
1792 state = UNSTRUCTURED_START;
1793 break;
1794 }
1795 break;
1796 }
1797
1798 cur_token ++;
1799 }
1800
1801 str = malloc(terminal - begin + 1);
1802 if (str == NULL)
1803 return MAILIMF_ERROR_MEMORY;
1804 strncpy(str, message + begin, terminal - begin);
1805 str[terminal - begin] = '\0';
1806
1807 * index = terminal;
1808 * result = str;
1809
1810 return MAILIMF_NO_ERROR;
1811 }
1812
1813
1814 static int mailimf_ignore_unstructured_parse(const char * message, size_t length,
1815 size_t * index)
1816 {
1817 size_t cur_token;
1818 int state;
1819 size_t terminal;
1820
1821 cur_token = * index;
1822
1823 state = UNSTRUCTURED_START;
1824 terminal = cur_token;
1825
1826 while (state != UNSTRUCTURED_OUT) {
1827
1828 switch(state) {
1829 case UNSTRUCTURED_START:
1830 if (cur_token >= length)
1831 return MAILIMF_ERROR_PARSE;
1832 terminal = cur_token;
1833 switch(message[cur_token]) {
1834 case '\r':
1835 state = UNSTRUCTURED_CR;
1836 break;
1837 case '\n':
1838 state = UNSTRUCTURED_LF;
1839 break;
1840 default:
1841 state = UNSTRUCTURED_START;
1842 break;
1843 }
1844 break;
1845 case UNSTRUCTURED_CR:
1846 if (cur_token >= length)
1847 return MAILIMF_ERROR_PARSE;
1848 switch(message[cur_token]) {
1849 case '\n':
1850 state = UNSTRUCTURED_LF;
1851 break;
1852 default:
1853 state = UNSTRUCTURED_START;
1854 break;
1855 }
1856 break;
1857 case UNSTRUCTURED_LF:
1858 if (cur_token >= length) {
1859 state = UNSTRUCTURED_OUT;
1860 break;
1861 }
1862 switch(message[cur_token]) {
1863 case '\t':
1864 case ' ':
1865 state = UNSTRUCTURED_WSP;
1866 break;
1867 default:
1868 state = UNSTRUCTURED_OUT;
1869 break;
1870 }
1871 break;
1872 case UNSTRUCTURED_WSP:
1873 if (cur_token >= length)
1874 return MAILIMF_ERROR_PARSE;
1875 switch(message[cur_token]) {
1876 case '\r':
1877 state = UNSTRUCTURED_CR;
1878 break;
1879 case '\n':
1880 state = UNSTRUCTURED_LF;
1881 break;
1882 default:
1883 state = UNSTRUCTURED_START;
1884 break;
1885 }
1886 break;
1887 }
1888
1889 cur_token ++;
1890 }
1891
1892 * index = terminal;
1893
1894 return MAILIMF_NO_ERROR;
1895 }
1896
1897
1898 int mailimf_ignore_field_parse(const char * message, size_t length,
1899 size_t * index)
1900 {
1901 int has_field;
1902 size_t cur_token;
1903 int state;
1904 size_t terminal;
1905
1906 has_field = FALSE;
1907 cur_token = * index;
1908
1909 terminal = cur_token;
1910 state = UNSTRUCTURED_START;
1911
1912 /* check if this is not a beginning CRLF */
1913
1914 if (cur_token >= length)
1915 return MAILIMF_ERROR_PARSE;
1916
1917 switch (message[cur_token]) {
1918 case '\r':
1919 return MAILIMF_ERROR_PARSE;
1920 case '\n':
1921 return MAILIMF_ERROR_PARSE;
1922 }
1923
1924 while (state != UNSTRUCTURED_OUT) {
1925
1926 switch(state) {
1927 case UNSTRUCTURED_START:
1928 if (cur_token >= length)
1929 return MAILIMF_ERROR_PARSE;
1930
1931 switch(message[cur_token]) {
1932 case '\r':
1933 state = UNSTRUCTURED_CR;
1934 break;
1935 case '\n':
1936 state = UNSTRUCTURED_LF;
1937 break;
1938 case ':':
1939 has_field = TRUE;
1940 state = UNSTRUCTURED_START;
1941 break;
1942 default:
1943 state = UNSTRUCTURED_START;
1944 break;
1945 }
1946 break;
1947 case UNSTRUCTURED_CR:
1948 if (cur_token >= length)
1949 return MAILIMF_ERROR_PARSE;
1950
1951 switch(message[cur_token]) {
1952 case '\n':
1953 state = UNSTRUCTURED_LF;
1954 break;
1955 case ':':
1956 has_field = TRUE;
1957 state = UNSTRUCTURED_START;
1958 break;
1959 default:
1960 state = UNSTRUCTURED_START;
1961 break;
1962 }
1963 break;
1964 case UNSTRUCTURED_LF:
1965 if (cur_token >= length) {
1966 terminal = cur_token;
1967 state = UNSTRUCTURED_OUT;
1968 break;
1969 }
1970
1971 switch(message[cur_token]) {
1972 case '\t':
1973 case ' ':
1974 state = UNSTRUCTURED_WSP;
1975 break;
1976 default:
1977 terminal = cur_token;
1978 state = UNSTRUCTURED_OUT;
1979 break;
1980 }
1981 break;
1982 case UNSTRUCTURED_WSP:
1983 if (cur_token >= length)
1984 return MAILIMF_ERROR_PARSE;
1985
1986 switch(message[cur_token]) {
1987 case '\r':
1988 state = UNSTRUCTURED_CR;
1989 break;
1990 case '\n':
1991 state = UNSTRUCTURED_LF;
1992 break;
1993 case ':':
1994 has_field = TRUE;
1995 state = UNSTRUCTURED_START;
1996 break;
1997 default:
1998 state = UNSTRUCTURED_START;
1999 break;
2000 }
2001 break;
2002 }
2003
2004 cur_token ++;
2005 }
2006
2007 if (!has_field)
2008 return MAILIMF_ERROR_PARSE;
2009
2010 * index = terminal;
2011
2012 return MAILIMF_NO_ERROR;
2013 }
2014
2015
2016 /*
2017 date-time = [ day-of-week "," ] date FWS time [CFWS]
2018 */
2019
2020 int mailimf_date_time_parse(const char * message, size_t length,
2021 size_t * index,
2022 struct mailimf_date_time ** result)
2023 {
2024 size_t cur_token;
2025 int day_of_week;
2026 struct mailimf_date_time * date_time;
2027 int day;
2028 int month;
2029 int year;
2030 int hour;
2031 int min;
2032 int sec;
2033 int zone;
2034 int r;
2035
2036 cur_token = * index;
2037
2038 day_of_week = -1;
2039 r = mailimf_day_of_week_parse(message, length, &cur_token, &day_of_week);
2040 if (r == MAILIMF_NO_ERROR) {
2041 r = mailimf_comma_parse(message, length, &cur_token);
2042 if (r != MAILIMF_NO_ERROR)
2043 return r;
2044 }
2045 else if (r != MAILIMF_ERROR_PARSE)
2046 return r;
2047
2048 r = mailimf_date_parse(message, length, &cur_token, &day, &month, &year);
2049 if (r != MAILIMF_NO_ERROR)
2050 return r;
2051
2052 r = mailimf_fws_parse(message, length, &cur_token);
2053 if (r != MAILIMF_NO_ERROR)
2054 return r;
2055
2056 r = mailimf_time_parse(message, length, &cur_token,
2057 &hour, &min, &sec, &zone);
2058 if (r != MAILIMF_NO_ERROR)
2059 return r;
2060
2061 date_time = mailimf_date_time_new(day, month, year, hour, min, sec, zone);
2062 if (date_time == NULL)
2063 return MAILIMF_ERROR_MEMORY;
2064
2065 * index = cur_token;
2066 * result = date_time;
2067
2068 return MAILIMF_NO_ERROR;
2069 }
2070
2071 /*
2072 day-of-week = ([FWS] day-name) / obs-day-of-week
2073 */
2074
2075 static int mailimf_day_of_week_parse(const char * message, size_t length,
2076 size_t * index, int * result)
2077 {
2078 size_t cur_token;
2079 int day_of_week;
2080 int r;
2081
2082 cur_token = * index;
2083
2084 r = mailimf_cfws_parse(message, length, &cur_token);
2085 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
2086 return r;
2087
2088 r = mailimf_day_name_parse(message, length, &cur_token, &day_of_week);
2089 if (r != MAILIMF_NO_ERROR)
2090 return r;
2091
2092 * index = cur_token;
2093 * result = day_of_week;
2094
2095 return MAILIMF_NO_ERROR;
2096 }
2097
2098 /*
2099 day-name = "Mon" / "Tue" / "Wed" / "Thu" /
2100 "Fri" / "Sat" / "Sun"
2101 */
2102
2103 struct mailimf_token_value {
2104 int value;
2105 char * str;
2106 };
2107
2108 static struct mailimf_token_value day_names[] = {
2109 {1, "Mon"},
2110 {2, "Tue"},
2111 {3, "Wed"},
2112 {4, "Thu"},
2113 {5, "Fri"},
2114 {6, "Sat"},
2115 {7, "Sun"},
2116 };
2117
2118 enum {
2119 DAY_NAME_START,
2120 DAY_NAME_T,
2121 DAY_NAME_S
2122 };
2123
2124 static int guess_day_name(const char * message, size_t length, size_t index)
2125 {
2126 int state;
2127
2128 state = DAY_NAME_START;
2129
2130 while (1) {
2131
2132 if (index >= length)
2133 return -1;
2134
2135 switch(state) {
2136 case DAY_NAME_START:
2137 switch((char) toupper((unsigned char) message[index])) {
2138 case 'M': /* Mon */
2139 return 1;
2140 break;
2141 case 'T': /* Tue Thu */
2142 state = DAY_NAME_T;
2143 break;
2144 case 'W': /* Wed */
2145 return 3;
2146 case 'F':
2147 return 5;
2148 case 'S': /* Sat Sun */
2149 state = DAY_NAME_S;
2150 break;
2151 default:
2152 return -1;
2153 }
2154 break;
2155 case DAY_NAME_T:
2156 switch((char) toupper((unsigned char) message[index])) {
2157 case 'U':
2158 return 2;
2159 case 'H':
2160 return 4;
2161 default:
2162 return -1;
2163 }
2164 break;
2165 case DAY_NAME_S:
2166 switch((char) toupper((unsigned char) message[index])) {
2167 case 'A':
2168 return 6;
2169 case 'U':
2170 return 7;
2171 default:
2172 return -1;
2173 }
2174 break;
2175 }
2176
2177 index ++;
2178 }
2179 }
2180
2181 static int mailimf_day_name_parse(const char * message, size_t length,
2182 size_t * index, int * result)
2183 {
2184 size_t cur_token;
2185 int day_of_week;
2186 int guessed_day;
2187 int r;
2188
2189 cur_token = * index;
2190
2191 guessed_day = guess_day_name(message, length, cur_token);
2192 if (guessed_day == -1)
2193 return MAILIMF_ERROR_PARSE;
2194
2195 r = mailimf_token_case_insensitive_parse(message, length,
2196 &cur_token,
2197 day_names[guessed_day - 1].str);
2198 if (r != MAILIMF_NO_ERROR)
2199 return r;
2200
2201 day_of_week = guessed_day;
2202
2203 * result = day_of_week;
2204 * index = cur_token;
2205
2206 return MAILIMF_NO_ERROR;
2207 }
2208
2209 /*
2210 date = day month year
2211 */
2212
2213 static int mailimf_date_parse(const char * message, size_t length,
2214 size_t * index,
2215 int * pday, int * pmonth, int * pyear)
2216 {
2217 size_t cur_token;
2218 int day;
2219 int month;
2220 int year;
2221 int r;
2222
2223 cur_token = * index;
2224
2225 r = mailimf_day_parse(message, length, &cur_token, &day);
2226 if (r != MAILIMF_NO_ERROR)
2227 return r;
2228
2229 r = mailimf_month_parse(message, length, &cur_token, &month);
2230 if (r != MAILIMF_NO_ERROR)
2231 return r;
2232
2233 r = mailimf_year_parse(message, length, &cur_token, &year);
2234 if (r != MAILIMF_NO_ERROR)
2235 return r;
2236
2237 * pday = day;
2238 * pmonth = month;
2239 * pyear = year;
2240
2241 * index = cur_token;
2242
2243 return MAILIMF_NO_ERROR;
2244 }
2245
2246 /*
2247 year = 4*DIGIT / obs-year
2248 */
2249
2250 static int mailimf_year_parse(const char * message, size_t length,
2251 size_t * index, int * result)
2252 {
2253 uint32_t number;
2254 size_t cur_token;
2255 int r;
2256
2257 cur_token = * index;
2258
2259 r = mailimf_cfws_parse(message, length, &cur_token);
2260 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
2261 return r;
2262
2263 r = mailimf_number_parse(message, length, &cur_token, &number);
2264 if (r != MAILIMF_NO_ERROR)
2265 return r;
2266
2267 * index = cur_token;
2268 * result = number;
2269
2270 return MAILIMF_NO_ERROR;
2271 }
2272
2273 /*
2274 month = (FWS month-name FWS) / obs-month
2275 */
2276
2277 static int mailimf_month_parse(const char * message, size_t length,
2278 size_t * index, int * result)
2279 {
2280 size_t cur_token;
2281 int month;
2282 int r;
2283
2284 cur_token = * index;
2285
2286 r = mailimf_cfws_parse(message, length, &cur_token);
2287 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
2288 return r;
2289
2290 r = mailimf_month_name_parse(message, length, &cur_token, &month);
2291 if (r != MAILIMF_NO_ERROR)
2292 return r;
2293
2294 * result = month;
2295 * index = cur_token;
2296
2297 return MAILIMF_NO_ERROR;
2298 }
2299
2300 /*
2301 month-name = "Jan" / "Feb" / "Mar" / "Apr" /
2302 "May" / "Jun" / "Jul" / "Aug" /
2303 "Sep" / "Oct" / "Nov" / "Dec"
2304 */
2305
2306 static struct mailimf_token_value month_names[] = {
2307 {1, "Jan"},
2308 {2, "Feb"},
2309 {3, "Mar"},
2310 {4, "Apr"},
2311 {5, "May"},
2312 {6, "Jun"},
2313 {7, "Jul"},
2314 {8, "Aug"},
2315 {9, "Sep"},
2316 {10, "Oct"},
2317 {11, "Nov"},
2318 {12, "Dec"},
2319 };
2320
2321 enum {
2322 MONTH_START,
2323 MONTH_J,
2324 MONTH_JU,
2325 MONTH_M,
2326 MONTH_MA,
2327 MONTH_A
2328 };
2329
2330 static int guess_month(const char * message, size_t length, size_t index)
2331 {
2332 int state;
2333
2334 state = MONTH_START;
2335
2336 while (1) {
2337
2338 if (index >= length)
2339 return -1;
2340
2341 switch(state) {
2342 case MONTH_START:
2343 switch((char) toupper((unsigned char) message[index])) {
2344 case 'J': /* Jan Jun Jul */
2345 state = MONTH_J;
2346 break;
2347 case 'F': /* Feb */
2348 return 2;
2349 case 'M': /* Mar May */
2350 state = MONTH_M;
2351 break;
2352 case 'A': /* Apr Aug */
2353 state = MONTH_A;
2354 break;
2355 case 'S': /* Sep */
2356 return 9;
2357 case 'O': /* Oct */
2358 return 10;
2359 case 'N': /* Nov */
2360 return 11;
2361 case 'D': /* Dec */
2362 return 12;
2363 default:
2364 return -1;
2365 }
2366 break;
2367 case MONTH_J:
2368 switch((char) toupper((unsigned char) message[index])) {
2369 case 'A':
2370 return 1;
2371 case 'U':
2372 state = MONTH_JU;
2373 break;
2374 default:
2375 return -1;
2376 }
2377 break;
2378 case MONTH_JU:
2379 switch((char) toupper((unsigned char) message[index])) {
2380 case 'N':
2381 return 6;
2382 case 'L':
2383 return 7;
2384 default:
2385 return -1;
2386 }
2387 break;
2388 case MONTH_M:
2389 switch((char) toupper((unsigned char) message[index])) {
2390 case 'A':
2391 state = MONTH_MA;
2392 break;
2393 default:
2394 return -1;
2395 }
2396 break;
2397 case MONTH_MA:
2398 switch((char) toupper((unsigned char) message[index])) {
2399 case 'Y':
2400 return 5;
2401 case 'R':
2402 return 3;
2403 default:
2404 return -1;
2405 }
2406 break;
2407 case MONTH_A:
2408 switch((char) toupper((unsigned char) message[index])) {
2409 case 'P':
2410 return 4;
2411 case 'U':
2412 return 8;
2413 default:
2414 return -1;
2415 }
2416 break;
2417 }
2418
2419 index ++;
2420 }
2421 }
2422
2423 static int mailimf_month_name_parse(const char * message, size_t length,
2424 size_t * index, int * result)
2425 {
2426 size_t cur_token;
2427 int month;
2428 int guessed_month;
2429 int r;
2430
2431 cur_token = * index;
2432
2433 guessed_month = guess_month(message, length, cur_token);
2434 if (guessed_month == -1)
2435 return MAILIMF_ERROR_PARSE;
2436
2437 r = mailimf_token_case_insensitive_parse(message, length,
2438 &cur_token,
2439 month_names[guessed_month - 1].str);
2440 if (r != MAILIMF_NO_ERROR)
2441 return r;
2442
2443 month = guessed_month;
2444
2445 * result = month;
2446 * index = cur_token;
2447
2448 return MAILIMF_NO_ERROR;
2449 }
2450
2451 /*
2452 day = ([FWS] 1*2DIGIT) / obs-day
2453 */
2454
2455 static int mailimf_day_parse(const char * message, size_t length,
2456 size_t * index, int * result)
2457 {
2458 size_t cur_token;
2459 uint32_t day;
2460 int r;
2461
2462 cur_token = * index;
2463
2464 r = mailimf_cfws_parse(message, length, &cur_token);
2465 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
2466 return r;
2467
2468 r = mailimf_number_parse(message, length, &cur_token, &day);
2469 if (r != MAILIMF_NO_ERROR)
2470 return r;
2471
2472 * result = day;
2473 * index = cur_token;
2474
2475 return MAILIMF_NO_ERROR;
2476 }
2477
2478 /*
2479 time = time-of-day FWS zone
2480 */
2481
2482 static int mailimf_time_parse(const char * message, size_t length,
2483 size_t * index,
2484 int * phour, int * pmin,
2485 int * psec,
2486 int * pzone)
2487 {
2488 size_t cur_token;
2489 int hour;
2490 int min;
2491 int sec;
2492 int zone;
2493 int r;
2494
2495 cur_token = * index;
2496
2497 r = mailimf_cfws_parse(message, length, &cur_token);
2498 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
2499 return r;
2500
2501 r = mailimf_time_of_day_parse(message, length, &cur_token,
2502 &hour, &min, &sec);
2503 if (r != MAILIMF_NO_ERROR)
2504 return r;
2505
2506 r = mailimf_fws_parse(message, length, &cur_token);
2507 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
2508 return r;
2509
2510 r = mailimf_zone_parse(message, length, &cur_token, &zone);
2511 if (r == MAILIMF_NO_ERROR) {
2512 /* do nothing */
2513 }
2514 else if (r == MAILIMF_ERROR_PARSE) {
2515 zone = 0;
2516 }
2517 else {
2518 return r;
2519 }
2520
2521 * phour = hour;
2522 * pmin = min;
2523 * psec = sec;
2524 * pzone = zone;
2525
2526 * index = cur_token;
2527
2528 return MAILIMF_NO_ERROR;
2529 }
2530
2531 /*
2532 time-of-day = hour ":" minute [ ":" second ]
2533 */
2534
2535 static int mailimf_time_of_day_parse(const char * message, size_t length,
2536 size_t * index,
2537 int * phour, int * pmin,
2538 int * psec)
2539 {
2540 int hour;
2541 int min;
2542 int sec;
2543 size_t cur_token;
2544 int r;
2545
2546 cur_token = * index;
2547
2548 r = mailimf_hour_parse(message, length, &cur_token, &hour);
2549 if (r != MAILIMF_NO_ERROR)
2550 return r;
2551
2552 r = mailimf_colon_parse(message, length, &cur_token);
2553 if (r != MAILIMF_NO_ERROR)
2554 return r;
2555
2556 r = mailimf_minute_parse(message, length, &cur_token, &min);
2557 if (r != MAILIMF_NO_ERROR)
2558 return r;
2559
2560 r = mailimf_colon_parse(message, length, &cur_token);
2561 if (r == MAILIMF_NO_ERROR) {
2562 r = mailimf_second_parse(message, length, &cur_token, &sec);
2563 if (r != MAILIMF_NO_ERROR)
2564 return r;
2565 }
2566 else if (r == MAILIMF_ERROR_PARSE)
2567 sec = 0;
2568 else
2569 return r;
2570
2571 * phour = hour;
2572 * pmin = min;
2573 * psec = sec;
2574 * index = cur_token;
2575
2576 return MAILIMF_NO_ERROR;
2577 }
2578
2579 /*
2580 hour = 2DIGIT / obs-hour
2581 */
2582
2583 static int mailimf_hour_parse(const char * message, size_t length,
2584 size_t * index, int * result)
2585 {
2586 uint32_t hour;
2587 int r;
2588
2589 r = mailimf_number_parse(message, length, index, &hour);
2590 if (r != MAILIMF_NO_ERROR)
2591 return r;
2592
2593 * result = hour;
2594
2595 return MAILIMF_NO_ERROR;
2596 }
2597
2598 /*
2599 minute = 2DIGIT / obs-minute
2600 */
2601
2602 static int mailimf_minute_parse(const char * message, size_t length,
2603 size_t * index, int * result)
2604 {
2605 uint32_t minute;
2606 int r;
2607
2608 r = mailimf_number_parse(message, length, index, &minute);
2609 if (r != MAILIMF_NO_ERROR)
2610 return r;
2611
2612 * result = minute;
2613
2614 return MAILIMF_NO_ERROR;
2615 }
2616
2617 /*
2618 second = 2DIGIT / obs-second
2619 */
2620
2621 static int mailimf_second_parse(const char * message, size_t length,
2622 size_t * index, int * result)
2623 {
2624 uint32_t second;
2625 int r;
2626
2627 r = mailimf_number_parse(message, length, index, &second);
2628 if (r != MAILIMF_NO_ERROR)
2629 return r;
2630
2631 * result = second;
2632
2633 return MAILIMF_NO_ERROR;
2634 }
2635
2636 /*
2637 zone = (( "+" / "-" ) 4DIGIT) / obs-zone
2638 */
2639
2640 /*
2641 obs-zone = "UT" / "GMT" / ; Universal Time
2642 ; North American UT
2643 ; offsets
2644 "EST" / "EDT" / ; Eastern: - 5/ - 4
2645 "CST" / "CDT" / ; Central: - 6/ - 5
2646 "MST" / "MDT" / ; Mountain: - 7/ - 6
2647 "PST" / "PDT" / ; Pacific: - 8/ - 7
2648
2649 %d65-73 / ; Military zones - "A"
2650 %d75-90 / ; through "I" and "K"
2651 %d97-105 / ; through "Z", both
2652 %d107-122 ; upper and lower case
2653 */
2654
2655 enum {
2656 STATE_ZONE_1 = 0,
2657 STATE_ZONE_2 = 1,
2658 STATE_ZONE_3 = 2,
2659 STATE_ZONE_OK = 3,
2660 STATE_ZONE_ERR = 4,
2661 STATE_ZONE_CONT = 5,
2662 };
2663
2664 static int mailimf_zone_parse(const char * message, size_t length,
2665 size_t * index, int * result)
2666 {
2667 uint32_t zone;
2668 int sign;
2669 size_t cur_token;
2670 int r;
2671
2672 cur_token = * index;
2673
2674 if (cur_token + 1 < length) {
2675 if ((message[cur_token] == 'U') && (message[cur_token + 1] == 'T')) {
2676 * result = TRUE;
2677 * index = cur_token + 2;
2678
2679 return MAILIMF_NO_ERROR;
2680 }
2681 }
2682
2683 if (cur_token + 2 < length) {
2684 int state;
2685
2686 state = STATE_ZONE_1;
2687
2688 while (state <= 2) {
2689 switch (state) {
2690 case STATE_ZONE_1:
2691 switch (message[cur_token]) {
2692 case 'G':
2693 if (message[cur_token + 1] == 'M' && message[cur_token + 2] == 'T') {
2694 zone = 0;
2695 state = STATE_ZONE_OK;
2696 }
2697 else {
2698 state = STATE_ZONE_ERR;
2699 }
2700 break;
2701 case 'E':
2702 zone = -5;
2703 state = STATE_ZONE_2;
2704 break;
2705 case 'C':
2706 zone = -6;
2707 state = STATE_ZONE_2;
2708 break;
2709 case 'M':
2710 zone = -7;
2711 state = STATE_ZONE_2;
2712 break;
2713 case 'P':
2714 zone = -8;
2715 state = STATE_ZONE_2;
2716 break;
2717 default:
2718 state = STATE_ZONE_CONT;
2719 break;
2720 }
2721 break;
2722 case STATE_ZONE_2:
2723 switch (message[cur_token + 1]) {
2724 case 'S':
2725 state = STATE_ZONE_3;
2726 break;
2727 case 'D':
2728 zone ++;
2729 state = STATE_ZONE_3;
2730 break;
2731 default:
2732 state = STATE_ZONE_ERR;
2733 break;
2734 }
2735 break;
2736 case STATE_ZONE_3:
2737 if (message[cur_token + 2] == 'T') {
2738 zone *= 100;
2739 state = STATE_ZONE_OK;
2740 }
2741 else
2742 state = STATE_ZONE_ERR;
2743 break;
2744 }
2745 }
2746
2747 switch (state) {
2748 case STATE_ZONE_OK:
2749 * result = zone;
2750 * index = cur_token + 3;
2751 return MAILIMF_NO_ERROR;
2752
2753 case STATE_ZONE_ERR:
2754 return MAILIMF_ERROR_PARSE;
2755 }
2756 }
2757
2758 sign = 1;
2759 r = mailimf_plus_parse(message, length, &cur_token);
2760 if (r == MAILIMF_NO_ERROR)
2761 sign = 1;
2762
2763 if (r == MAILIMF_ERROR_PARSE) {
2764 r = mailimf_minus_parse(message, length, &cur_token);
2765 if (r == MAILIMF_NO_ERROR)
2766 sign = -1;
2767 }
2768
2769 if (r == MAILIMF_NO_ERROR) {
2770 /* do nothing */
2771 }
2772 else if (r == MAILIMF_ERROR_PARSE)
2773 sign = 1;
2774 else
2775 return r;
2776
2777 r = mailimf_number_parse(message, length, &cur_token, &zone);
2778 if (r != MAILIMF_NO_ERROR)
2779 return r;
2780
2781 zone = zone * sign;
2782
2783 * index = cur_token;
2784 * result = zone;
2785
2786 return MAILIMF_NO_ERROR;
2787 }
2788
2789 /*
2790 address = mailbox / group
2791 */
2792
2793 int mailimf_address_parse(const char * message, size_t length,
2794 size_t * index,
2795 struct mailimf_address ** result)
2796 {
2797 int type;
2798 size_t cur_token;
2799 struct mailimf_mailbox * mailbox;
2800 struct mailimf_group * group;
2801 struct mailimf_address * address;
2802 int r;
2803 int res;
2804
2805 cur_token = * index;
2806
2807 mailbox = NULL;
2808 group = NULL;
2809
2810 type = MAILIMF_ADDRESS_ERROR; /* XXX - removes a gcc warning */
2811 r = mailimf_group_parse(message, length, &cur_token, &group);
2812 if (r == MAILIMF_NO_ERROR)
2813 type = MAILIMF_ADDRESS_GROUP;
2814
2815 if (r == MAILIMF_ERROR_PARSE) {
2816 r = mailimf_mailbox_parse(message, length, &cur_token, &mailbox);
2817 if (r == MAILIMF_NO_ERROR)
2818 type = MAILIMF_ADDRESS_MAILBOX;
2819 }
2820
2821 if (r != MAILIMF_NO_ERROR) {
2822 res = r;
2823 goto err;
2824 }
2825
2826 address = mailimf_address_new(type, mailbox, group);
2827 if (address == NULL) {
2828 res = MAILIMF_ERROR_MEMORY;
2829 goto free;
2830 }
2831
2832 * result = address;
2833 * index = cur_token;
2834
2835 return MAILIMF_NO_ERROR;
2836
2837 free:
2838 if (mailbox != NULL)
2839 mailimf_mailbox_free(mailbox);
2840 if (group != NULL)
2841 mailimf_group_free(group);
2842 err:
2843 return res;
2844 }
2845
2846
2847 /*
2848 mailbox = name-addr / addr-spec
2849 */
2850
2851
2852 int mailimf_mailbox_parse(const char * message, size_t length,
2853 size_t * index,
2854 struct mailimf_mailbox ** result)
2855 {
2856 size_t cur_token;
2857 char * display_name;
2858 struct mailimf_mailbox * mailbox;
2859 char * addr_spec;
2860 int r;
2861 int res;
2862
2863 cur_token = * index;
2864 display_name = NULL;
2865 addr_spec = NULL;
2866
2867 r = mailimf_name_addr_parse(message, length, &cur_token,
2868 &display_name, &addr_spec);
2869 if (r == MAILIMF_ERROR_PARSE)
2870 r = mailimf_addr_spec_parse(message, length, &cur_token, &addr_spec);
2871
2872 if (r != MAILIMF_NO_ERROR) {
2873 res = r;
2874 goto err;
2875 }
2876
2877 mailbox = mailimf_mailbox_new(display_name, addr_spec);
2878 if (mailbox == NULL) {
2879 res = MAILIMF_ERROR_MEMORY;
2880 goto free;
2881 }
2882
2883 * result = mailbox;
2884 * index = cur_token;
2885
2886 return MAILIMF_NO_ERROR;
2887
2888 free:
2889 if (display_name != NULL)
2890 mailimf_display_name_free(display_name);
2891 if (addr_spec != NULL)
2892 mailimf_addr_spec_free(addr_spec);
2893 err:
2894 return res;
2895 }
2896
2897 /*
2898 name-addr = [display-name] angle-addr
2899 */
2900
2901 static int mailimf_name_addr_parse(const char * message, size_t length,
2902 size_t * index,
2903 char ** pdisplay_name,
2904 char ** pangle_addr)
2905 {
2906 char * display_name;
2907 char * angle_addr;
2908 size_t cur_token;
2909 int r;
2910 int res;
2911
2912 cur_token = * index;
2913
2914 display_name = NULL;
2915 angle_addr = NULL;
2916
2917 r = mailimf_display_name_parse(message, length, &cur_token, &display_name);
2918 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
2919 res = r;
2920 goto err;
2921 }
2922
2923 r = mailimf_angle_addr_parse(message, length, &cur_token, &angle_addr);
2924 if (r != MAILIMF_NO_ERROR) {
2925 res = r;
2926 goto free_display_name;
2927 }
2928
2929 * pdisplay_name = display_name;
2930 * pangle_addr = angle_addr;
2931 * index = cur_token;
2932
2933 return MAILIMF_NO_ERROR;
2934
2935 free_display_name:
2936 if (display_name != NULL)
2937 mailimf_display_name_free(display_name);
2938 err:
2939 return res;
2940 }
2941
2942 /*
2943 angle-addr = [CFWS] "<" addr-spec ">" [CFWS] / obs-angle-addr
2944 */
2945
2946 static int mailimf_angle_addr_parse(const char * message, size_t length,
2947 size_t * index, char ** result)
2948 {
2949 size_t cur_token;
2950 char * addr_spec;
2951 int r;
2952
2953 cur_token = * index;
2954
2955 r = mailimf_cfws_parse(message, length, &cur_token);
2956 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
2957 return r;
2958
2959 r = mailimf_lower_parse(message, length, &cur_token);
2960 if (r != MAILIMF_NO_ERROR)
2961 return r;
2962
2963 r = mailimf_addr_spec_parse(message, length, &cur_token, &addr_spec);
2964 if (r != MAILIMF_NO_ERROR)
2965 return r;
2966
2967 r = mailimf_greater_parse(message, length, &cur_token);
2968 if (r != MAILIMF_NO_ERROR) {
2969 free(addr_spec);
2970 return r;
2971 }
2972
2973 * result = addr_spec;
2974 * index = cur_token;
2975
2976 return MAILIMF_NO_ERROR;
2977 }
2978
2979 /*
2980 group = display-name ":" [mailbox-list / CFWS] ";"
2981 [CFWS]
2982 */
2983
2984 static int mailimf_group_parse(const char * message, size_t length,
2985 size_t * index,
2986 struct mailimf_group ** result)
2987 {
2988 size_t cur_token;
2989 char * display_name;
2990 struct mailimf_mailbox_list * mailbox_list;
2991 struct mailimf_group * group;
2992 int r;
2993 int res;
2994 clist * list;
2995
2996 cur_token = * index;
2997
2998 mailbox_list = NULL;
2999
3000 r = mailimf_display_name_parse(message, length, &cur_token, &display_name);
3001 if (r != MAILIMF_NO_ERROR) {
3002 res = r;
3003 goto err;
3004 }
3005
3006 r = mailimf_colon_parse(message, length, &cur_token);
3007 if (r != MAILIMF_NO_ERROR) {
3008 res = r;
3009 goto free_display_name;
3010 }
3011
3012 r = mailimf_mailbox_list_parse(message, length, &cur_token, &mailbox_list);
3013 switch (r) {
3014 case MAILIMF_NO_ERROR:
3015 break;
3016 case MAILIMF_ERROR_PARSE:
3017 r = mailimf_cfws_parse(message, length, &cur_token);
3018 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
3019 res = r;
3020 goto free_display_name;
3021 }
3022 list = clist_new();
3023 if (list == NULL) {
3024 res = MAILIMF_ERROR_MEMORY;
3025 goto free_display_name;
3026 }
3027 mailbox_list = mailimf_mailbox_list_new(list);
3028 if (mailbox_list == NULL) {
3029 res = MAILIMF_ERROR_MEMORY;
3030 clist_free(list);
3031 goto free_display_name;
3032 }
3033 break;
3034 default:
3035 res = r;
3036 goto free_display_name;
3037 }
3038
3039 r = mailimf_semi_colon_parse(message, length, &cur_token);
3040 if (r != MAILIMF_NO_ERROR) {
3041 res = r;
3042 goto free_mailbox_list;
3043 }
3044
3045 group = mailimf_group_new(display_name, mailbox_list);
3046 if (group == NULL) {
3047 res = MAILIMF_ERROR_MEMORY;
3048 goto free_mailbox_list;
3049 }
3050
3051 * index = cur_token;
3052 * result = group;
3053
3054 return MAILIMF_NO_ERROR;
3055
3056 free_mailbox_list:
3057 mailimf_mailbox_list_free(mailbox_list);
3058 free_display_name:
3059 mailimf_display_name_free(display_name);
3060 err:
3061 return res;
3062 }
3063
3064 /*
3065 display-name = phrase
3066 */
3067
3068 static int mailimf_display_name_parse(const char * message, size_t length,
3069 size_t * index, char ** result)
3070 {
3071 return mailimf_phrase_parse(message, length, index, result);
3072 }
3073
3074 /*
3075 mailbox-list = (mailbox *("," mailbox)) / obs-mbox-list
3076 */
3077
3078 int
3079 mailimf_mailbox_list_parse(const char * message, size_t length,
3080 size_t * index,
3081 struct mailimf_mailbox_list ** result)
3082 {
3083 size_t cur_token;
3084 clist * list;
3085 struct mailimf_mailbox_list * mailbox_list;
3086 int r;
3087 int res;
3088
3089 cur_token = * index;
3090
3091 r = mailimf_struct_list_parse(message, length,
3092 &cur_token, &list, ',',
3093 (mailimf_struct_parser *)
3094 mailimf_mailbox_parse,
3095 (mailimf_struct_destructor *)
3096 mailimf_mailbox_free);
3097 if (r != MAILIMF_NO_ERROR) {
3098 res = r;
3099 goto err;
3100 }
3101
3102 mailbox_list = mailimf_mailbox_list_new(list);
3103 if (mailbox_list == NULL) {
3104 res = MAILIMF_ERROR_MEMORY;
3105 goto free_list;
3106 }
3107
3108 * result = mailbox_list;
3109 * index = cur_token;
3110
3111 return MAILIMF_NO_ERROR;
3112
3113 free_list:
3114 clist_foreach(list, (clist_func) mailimf_mailbox_free, NULL);
3115 clist_free(list);
3116 err:
3117 return res;
3118 }
3119
3120 /*
3121 address-list = (address *("," address)) / obs-addr-list
3122 */
3123
3124
3125 int
3126 mailimf_address_list_parse(const char * message, size_t length,
3127 size_t * index,
3128 struct mailimf_address_list ** result)
3129 {
3130 size_t cur_token;
3131 clist * list;
3132 struct mailimf_address_list * address_list;
3133 int r;
3134 int res;
3135
3136 cur_token = * index;
3137
3138 r = mailimf_struct_list_parse(message, length,
3139 &cur_token, &list, ',',
3140 (mailimf_struct_parser *)
3141 mailimf_address_parse,
3142 (mailimf_struct_destructor *)
3143 mailimf_address_free);
3144 if (r != MAILIMF_NO_ERROR) {
3145 res = r;
3146 goto err;
3147 }
3148
3149 address_list = mailimf_address_list_new(list);
3150 if (address_list == NULL) {
3151 res = MAILIMF_ERROR_MEMORY;
3152 goto free_list;
3153 }
3154
3155 * result = address_list;
3156 * index = cur_token;
3157
3158 return MAILIMF_NO_ERROR;
3159
3160 free_list:
3161 clist_foreach(list, (clist_func) mailimf_address_free, NULL);
3162 clist_free(list);
3163 err:
3164 return res;
3165 }
3166
3167 /*
3168 addr-spec = local-part "@" domain
3169 */
3170
3171
3172 static int mailimf_addr_spec_parse(const char * message, size_t length,
3173 size_t * index,
3174 char ** result)
3175 {
3176 size_t cur_token;
3177 #if 0
3178 char * local_part;
3179 char * domain;
3180 #endif
3181 char * addr_spec;
3182 int r;
3183 int res;
3184 size_t begin;
3185 size_t end;
3186 int final;
3187 size_t count;
3188 const char * src;
3189 char * dest;
3190 size_t i;
3191
3192 cur_token = * index;
3193
3194 r = mailimf_cfws_parse(message, length, &cur_token);
3195 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
3196 res = r;
3197 goto err;
3198 }
3199
3200 end = cur_token;
3201 if (end >= length) {
3202 res = MAILIMF_ERROR_PARSE;
3203 goto err;
3204 }
3205
3206 begin = cur_token;
3207
3208 final = FALSE;
3209 while (1) {
3210 switch (message[end]) {
3211 case '>':
3212 case ',':
3213 case '\r':
3214 case '\n':
3215 case '(':
3216 case ')':
3217 case ':':
3218 case ';':
3219 final = TRUE;
3220 break;
3221 }
3222
3223 if (final)
3224 break;
3225
3226 end ++;
3227 if (end >= length)
3228 break;
3229 }
3230
3231 if (end == begin) {
3232 res = MAILIMF_ERROR_PARSE;
3233 goto err;
3234 }
3235
3236 addr_spec = malloc(end - cur_token + 1);
3237 if (addr_spec == NULL) {
3238 res = MAILIMF_ERROR_MEMORY;
3239 goto err;
3240 }
3241
3242 count = end - cur_token;
3243 src = message + cur_token;
3244 dest = addr_spec;
3245 for(i = 0 ; i < count ; i ++) {
3246 if ((* src != ' ') && (* src != '\t')) {
3247 * dest = * src;
3248 dest ++;
3249 }
3250 src ++;
3251 }
3252 * dest = '\0';
3253
3254 #if 0
3255 strncpy(addr_spec, message + cur_token, end - cur_token);
3256 addr_spec[end - cur_token] = '\0';
3257 #endif
3258
3259 cur_token = end;
3260
3261 #if 0
3262 r = mailimf_local_part_parse(message, length, &cur_token, &local_part);
3263 if (r != MAILIMF_NO_ERROR) {
3264 res = r;
3265 goto err;
3266 }
3267
3268 r = mailimf_at_sign_parse(message, length, &cur_token);
3269 switch (r) {
3270 case MAILIMF_NO_ERROR:
3271 r = mailimf_domain_parse(message, length, &cur_token, &domain);
3272 if (r != MAILIMF_NO_ERROR) {
3273 res = r;
3274 goto free_local_part;
3275 }
3276 break;
3277
3278 case MAILIMF_ERROR_PARSE:
3279 domain = NULL;
3280 break;
3281
3282 default:
3283 res = r;
3284 goto free_local_part;
3285 }
3286
3287 if (domain) {
3288 addr_spec = malloc(strlen(local_part) + strlen(domain) + 2);
3289 if (addr_spec == NULL) {
3290 res = MAILIMF_ERROR_MEMORY;
3291 goto free_domain;
3292 }
3293
3294 strcpy(addr_spec, local_part);
3295 strcat(addr_spec, "@");
3296 strcat(addr_spec, domain);
3297
3298 mailimf_domain_free(domain);
3299 mailimf_local_part_free(local_part);
3300 }
3301 else {
3302 addr_spec = local_part;
3303 }
3304 #endif
3305
3306 * result = addr_spec;
3307 * index = cur_token;
3308
3309 return MAILIMF_NO_ERROR;
3310
3311 #if 0
3312 free_domain:
3313 mailimf_domain_free(domain);
3314 free_local_part:
3315 mailimf_local_part_free(local_part);
3316 #endif
3317 err:
3318 return res;
3319 }
3320
3321 /*
3322 local-part = dot-atom / quoted-string / obs-local-part
3323 */
3324
3325 #if 0
3326 static int mailimf_local_part_parse(const char * message, size_t length,
3327 size_t * index,
3328 char ** result)
3329 {
3330 int r;
3331
3332 r = mailimf_dot_atom_parse(message, length, index, result);
3333 switch (r) {
3334 case MAILIMF_NO_ERROR:
3335 return r;
3336 case MAILIMF_ERROR_PARSE:
3337 break;
3338 default:
3339 return r;
3340 }
3341
3342 r = mailimf_quoted_string_parse(message, length, index, result);
3343 if (r != MAILIMF_NO_ERROR)
3344 return r;
3345
3346 return MAILIMF_NO_ERROR;
3347 }
3348 #endif
3349
3350 /*
3351 domain = dot-atom / domain-literal / obs-domain
3352 */
3353
3354 #if 0
3355 static int mailimf_domain_parse(const char * message, size_t length,
3356 size_t * index,
3357 char ** result)
3358 {
3359 int r;
3360
3361 r = mailimf_dot_atom_parse(message, length, index, result);
3362 switch (r) {
3363 case MAILIMF_NO_ERROR:
3364 return r;
3365 case MAILIMF_ERROR_PARSE:
3366 break;
3367 default:
3368 return r;
3369 }
3370
3371 r = mailimf_domain_literal_parse(message, length, index, result);
3372 if (r != MAILIMF_NO_ERROR)
3373 return r;
3374
3375 return MAILIMF_NO_ERROR;
3376 }
3377 #endif
3378
3379 /*
3380 [FWS] dcontent
3381 */
3382
3383 #if 0
3384 static int
3385 mailimf_domain_literal_fws_dcontent_parse(const char * message, size_t length,
3386 size_t * index)
3387 {
3388 size_t cur_token;
3389 char ch;
3390 int r;
3391
3392 cur_token = * index;
3393
3394 r = mailimf_cfws_parse(message, length, &cur_token);
3395 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
3396 return r;
3397
3398 r = mailimf_dcontent_parse(message, length, &cur_token, &ch);
3399 if (r != MAILIMF_NO_ERROR)
3400 return r;
3401
3402 * index = cur_token;
3403
3404 return MAILIMF_NO_ERROR;
3405 }
3406 #endif
3407
3408 /*
3409 domain-literal = [CFWS] "[" *([FWS] dcontent) [FWS] "]" [CFWS]
3410 */
3411
3412 #if 0
3413 static int mailimf_domain_literal_parse(const char * message, size_t length,
3414 size_t * index, char ** result)
3415 {
3416 size_t cur_token;
3417 int len;
3418 int begin;
3419 char * domain_literal;
3420 int r;
3421
3422 cur_token = * index;
3423
3424 r = mailimf_cfws_parse(message, length, &cur_token);
3425 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
3426 return r;
3427
3428 begin = cur_token;
3429 r = mailimf_obracket_parse(message, length, &cur_token);
3430 if (r != MAILIMF_NO_ERROR)
3431 return r;
3432
3433 while (1) {
3434 r = mailimf_domain_literal_fws_dcontent_parse(message, length,
3435 &cur_token);
3436 if (r == MAILIMF_NO_ERROR) {
3437 /* do nothing */
3438 }
3439 else if (r == MAILIMF_ERROR_PARSE)
3440 break;
3441 else
3442 return r;
3443 }
3444
3445 r = mailimf_fws_parse(message, length, &cur_token);
3446 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
3447 return r;
3448
3449 r = mailimf_cbracket_parse(message, length, &cur_token);
3450 if (r != MAILIMF_NO_ERROR)
3451 return r;
3452
3453 len = cur_token - begin;
3454
3455 domain_literal = malloc(len + 1);
3456 if (domain_literal == NULL)
3457 return MAILIMF_ERROR_MEMORY;
3458 strncpy(domain_literal, message + begin, len);
3459 domain_literal[len] = '\0';
3460
3461 * result = domain_literal;
3462 * index = cur_token;
3463
3464 return MAILIMF_NO_ERROR;
3465 }
3466 #endif
3467
3468 /*
3469 dcontent = dtext / quoted-pair
3470 */
3471
3472 #if 0
3473 static int mailimf_dcontent_parse(const char * message, size_t length,
3474 size_t * index, char * result)
3475 {
3476 size_t cur_token;
3477 char ch;
3478 int r;
3479
3480 cur_token = * index;
3481
3482 if (cur_token >= length)
3483 return MAILIMF_ERROR_PARSE;
3484
3485 if (is_dtext(message[cur_token])) {
3486 ch = message[cur_token];
3487 cur_token ++;
3488 }
3489 else {
3490 r = mailimf_quoted_pair_parse(message, length, &cur_token, &ch);
3491
3492 if (r != MAILIMF_NO_ERROR)
3493 return r;
3494 }
3495
3496 * index = cur_token;
3497 * result = ch;
3498
3499 return MAILIMF_NO_ERROR;
3500 }
3501 #endif
3502
3503
3504 /*
3505 dtext = NO-WS-CTL / ; Non white space controls
3506
3507 %d33-90 / ; The rest of the US-ASCII
3508 %d94-126 ; characters not including "[",
3509 ; "]", or "\"
3510 */
3511
3512 #if 0
3513 static inline int is_dtext(char ch)
3514 {
3515 unsigned char uch = (unsigned char) ch;
3516
3517 if (is_no_ws_ctl(ch))
3518 return TRUE;
3519
3520 if (uch < 33)
3521 return FALSE;
3522
3523 if ((uch >= 91) && (uch <= 93))
3524 return FALSE;
3525
3526 if (uch == 127)
3527 return FALSE;
3528
3529 return TRUE;
3530 }
3531 #endif
3532
3533 /*
3534 message = (fields / obs-fields)
3535 [CRLF body]
3536 */
3537
3538 int mailimf_message_parse(const char * message, size_t length,
3539 size_t * index,
3540 struct mailimf_message ** result)
3541 {
3542 struct mailimf_fields * fields;
3543 struct mailimf_body * body;
3544 struct mailimf_message * msg;
3545 size_t cur_token;
3546 int r;
3547 int res;
3548
3549 cur_token = * index;
3550
3551 r = mailimf_fields_parse(message, length, &cur_token, &fields);
3552 if (r != MAILIMF_NO_ERROR) {
3553 res = r;
3554 goto err;
3555 }
3556
3557 r = mailimf_crlf_parse(message, length, &cur_token);
3558 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
3559 res = r;
3560 goto err;
3561 }
3562
3563 r = mailimf_body_parse(message, length, &cur_token, &body);
3564 if (r != MAILIMF_NO_ERROR) {
3565 res = r;
3566 goto free_fields;
3567 }
3568
3569 msg = mailimf_message_new(fields, body);
3570 if (msg == NULL) {
3571 res = MAILIMF_ERROR_MEMORY;
3572 goto free_body;
3573 }
3574
3575 * index = cur_token;
3576 * result = msg;
3577
3578 return MAILIMF_NO_ERROR;
3579
3580 free_body:
3581 mailimf_body_free(body);
3582 free_fields:
3583 mailimf_fields_free(fields);
3584 err:
3585 return res;
3586 }
3587
3588 /*
3589 body = *(*998text CRLF) *998text
3590 */
3591
3592 int mailimf_body_parse(const char * message, size_t length,
3593 size_t * index,
3594 struct mailimf_body ** result)
3595 {
3596 size_t cur_token;
3597 struct mailimf_body * body;
3598
3599 cur_token = * index;
3600
3601 body = mailimf_body_new(message + cur_token, length - cur_token);
3602 if (body == NULL)
3603 return MAILIMF_ERROR_MEMORY;
3604
3605 cur_token = length;
3606
3607 * result = body;
3608 * index = cur_token;
3609
3610 return MAILIMF_NO_ERROR;
3611 }
3612
3613 /*
3614 CHANGE TO THE RFC 2822
3615
3616 original :
3617
3618 fields = *(trace
3619 *(resent-date /
3620 resent-from /
3621 resent-sender /
3622 resent-to /
3623 resent-cc /
3624 resent-bcc /
3625 resent-msg-id))
3626 *(orig-date /
3627 from /
3628 sender /
3629 reply-to /
3630 to /
3631 cc /
3632 bcc /
3633 message-id /
3634 in-reply-to /
3635 references /
3636 subject /
3637 comments /
3638 keywords /
3639 optional-field)
3640
3641 INTO THE FOLLOWING :
3642 */
3643
3644 /*
3645 resent-fields-list = *(resent-date /
3646 resent-from /
3647 resent-sender /
3648 resent-to /
3649 resent-cc /
3650 resent-bcc /
3651 resent-msg-id))
3652 */
3653
3654 #if 0
3655 enum {
3656 RESENT_HEADER_START,
3657 };
3658
3659 static int guess_resent_header_type(char * message,
3660 size_t length, size_t index)
3661 {
3662 int r;
3663
3664 r = mailimf_token_case_insensitive_parse(message,
3665 length, &index, "Resent-");
3666 if (r != MAILIMF_NO_ERROR)
3667 return MAILIMF_RESENT_FIELD_NONE;
3668
3669 if (index >= length)
3670 return MAILIMF_RESENT_FIELD_NONE;
3671
3672 switch(toupper(message[index])) {
3673 case 'D':
3674 return MAILIMF_RESENT_FIELD_DATE;
3675 case 'F':
3676 return MAILIMF_RESENT_FIELD_FROM;
3677 case 'S':
3678 return MAILIMF_RESENT_FIELD_SENDER;
3679 case 'T':
3680 return MAILIMF_RESENT_FIELD_TO;
3681 case 'C':
3682 return MAILIMF_RESENT_FIELD_CC;
3683 case 'B':
3684 return MAILIMF_RESENT_FIELD_BCC;
3685 case 'M':
3686 return MAILIMF_RESENT_FIELD_MSG_ID;
3687 default:
3688 return MAILIMF_RESENT_FIELD_NONE;
3689 }
3690 }
3691 #endif
3692
3693 #if 0
3694 static int
3695 mailimf_resent_field_parse(const char * message, size_t length,
3696 size_t * index,
3697 struct mailimf_resent_field ** result)
3698 {
3699 struct mailimf_orig_date * resent_date;
3700 struct mailimf_from * resent_from;
3701 struct mailimf_sender * resent_sender;
3702 struct mailimf_to* resent_to;
3703 struct mailimf_cc * resent_cc;
3704 struct mailimf_bcc * resent_bcc;
3705 struct mailimf_message_id * resent_msg_id;
3706 size_t cur_token;
3707 int type;
3708 struct mailimf_resent_field * resent_field;
3709 int r;
3710 int res;
3711
3712 cur_token = * index;
3713
3714 resent_date = NULL;
3715 resent_from = NULL;
3716 resent_sender = NULL;
3717 resent_to = NULL;
3718 resent_cc = NULL;
3719 resent_bcc = NULL;
3720 resent_msg_id = NULL;
3721
3722 type = guess_resent_header_type(message, length, cur_token);
3723
3724 switch(type) {
3725 case MAILIMF_RESENT_FIELD_DATE:
3726 r = mailimf_resent_date_parse(message, length, &cur_token,
3727 &resent_date);
3728 if (r != MAILIMF_NO_ERROR) {
3729 res = r;
3730 goto free_resent;
3731 }
3732 break;
3733 case MAILIMF_RESENT_FIELD_FROM:
3734 r = mailimf_resent_from_parse(message, length, &cur_token,
3735 &resent_from);
3736 if (r != MAILIMF_NO_ERROR) {
3737 res = r;
3738 goto free_resent;
3739 }
3740 break;
3741 case MAILIMF_RESENT_FIELD_SENDER:
3742 r = mailimf_resent_sender_parse(message, length, &cur_token,
3743 &resent_sender);
3744 if (r != MAILIMF_NO_ERROR) {
3745 res = r;
3746 goto free_resent;
3747 }
3748 break;
3749 case MAILIMF_RESENT_FIELD_TO:
3750 r = mailimf_resent_to_parse(message, length, &cur_token,
3751 &resent_to);
3752 if (r != MAILIMF_NO_ERROR) {
3753 res = r;
3754 goto free_resent;
3755 }
3756 break;
3757 case MAILIMF_RESENT_FIELD_CC:
3758 r= mailimf_resent_cc_parse(message, length, &cur_token,
3759 &resent_cc);
3760 if (r != MAILIMF_NO_ERROR) {
3761 res = r;
3762 goto free_resent;
3763 }
3764 break;
3765 case MAILIMF_RESENT_FIELD_BCC:
3766 r = mailimf_resent_bcc_parse(message, length, &cur_token,
3767 &resent_bcc);
3768 if (r != MAILIMF_NO_ERROR) {
3769 res = r;
3770 goto free_resent;
3771 }
3772 break;
3773 case MAILIMF_RESENT_FIELD_MSG_ID:
3774 r = mailimf_resent_msg_id_parse(message, length, &cur_token,
3775 &resent_msg_id);
3776 if (r != MAILIMF_NO_ERROR) {
3777 res = r;
3778 goto free_resent;
3779 }
3780 break;
3781 default:
3782 res = MAILIMF_ERROR_PARSE;
3783 goto free_resent;
3784 }
3785
3786 resent_field = mailimf_resent_field_new(type, resent_date,
3787 resent_from, resent_sender,
3788 resent_to, resent_cc,
3789 resent_bcc, resent_msg_id);
3790 if (resent_field == NULL) {
3791 res = MAILIMF_ERROR_MEMORY;
3792 goto free_resent;
3793 }
3794
3795 * result = resent_field;
3796 * index = cur_token;
3797
3798 return MAILIMF_NO_ERROR;
3799
3800 free_resent:
3801 if (resent_msg_id != NULL)
3802 mailimf_message_id_free(resent_msg_id);
3803 if (resent_bcc != NULL)
3804 mailimf_bcc_free(resent_bcc);
3805 if (resent_cc != NULL)
3806 mailimf_cc_free(resent_cc);
3807 if (resent_to != NULL)
3808 mailimf_to_free(resent_to);
3809 if (resent_sender != NULL)
3810 mailimf_sender_free(resent_sender);
3811 if (resent_from != NULL)
3812 mailimf_from_free(resent_from);
3813 if (resent_date != NULL)
3814 mailimf_orig_date_free(resent_date);
3815 err:
3816 return res;
3817 }
3818 #endif
3819
3820 #if 0
3821 static int
3822 mailimf_resent_fields_list_parse(const char * message, size_t length,
3823 size_t * index,
3824 struct mailimf_resent_fields_list ** result)
3825 {
3826 clist * list;
3827 size_t cur_token;
3828 struct mailimf_resent_fields_list * resent_fields_list;
3829 int r;
3830 int res;
3831
3832 cur_token = * index;
3833 list = NULL;
3834
3835 r = mailimf_struct_multiple_parse(message, length, &cur_token, &list,
3836 (mailimf_struct_parser *)
3837 mailimf_resent_field_parse,
3838 (mailimf_struct_destructor *)
3839 mailimf_resent_field_free);
3840 if (r != MAILIMF_NO_ERROR) {
3841 res = r;
3842 goto err;
3843 }
3844
3845 resent_fields_list = mailimf_resent_fields_list_new(list);
3846 if (resent_fields_list == NULL) {
3847 res = MAILIMF_ERROR_MEMORY;
3848 goto free_list;
3849 }
3850
3851 * result = resent_fields_list;
3852 * index = cur_token;
3853
3854 return MAILIMF_NO_ERROR;
3855
3856 free_list:
3857 clist_foreach(list, (clist_func) mailimf_resent_field_free, NULL);
3858 clist_free(list);
3859 err:
3860 return res;
3861 }
3862 #endif
3863
3864 /*
3865 ([trace]
3866 [resent-fields-list])
3867 */
3868
3869 #if 0
3870 static int
3871 mailimf_trace_resent_fields_parse(const char * message, size_t length,
3872 size_t * index,
3873 struct mailimf_trace_resent_fields ** result)
3874 {
3875 size_t cur_token;
3876 struct mailimf_return * return_path;
3877 struct mailimf_resent_fields_list * resent_fields;
3878 struct mailimf_trace_resent_fields * trace_resent_fields;
3879 int res;
3880 int r;
3881
3882 cur_token = * index;
3883
3884 return_path = NULL;
3885 resent_fields = NULL;
3886
3887 r = mailimf_return_parse(message, length, &cur_token,
3888 &return_path);
3889 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
3890 res = r;
3891 goto err;
3892 }
3893
3894 r = mailimf_resent_fields_list_parse(message, length, &cur_token,
3895 &resent_fields);
3896 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
3897 res = r;
3898 goto err;
3899 }
3900
3901 if ((return_path == NULL) && (resent_fields == NULL)) {
3902 res = MAILIMF_ERROR_PARSE;
3903 goto err;
3904 }
3905
3906 trace_resent_fields = mailimf_trace_resent_fields_new(return_path,
3907 resent_fields);
3908 if (trace_resent_fields == NULL) {
3909 res = MAILIMF_ERROR_MEMORY;
3910 goto free_resent_fields;
3911 }
3912
3913 * result = trace_resent_fields;
3914 * index = cur_token;
3915
3916 return MAILIMF_NO_ERROR;
3917
3918 free_resent_fields:
3919 if (resent_fields != NULL)
3920 mailimf_resent_fields_list_free(resent_fields);
3921 if (return_path != NULL)
3922 mailimf_return_free(return_path);
3923 err:
3924 return res;
3925 }
3926 #endif
3927
3928 /*
3929 delivering-info = *([trace]
3930 [resent-fields-list])
3931 */
3932
3933 #if 0
3934 static int
3935 mailimf_delivering_info_parse(const char * message, size_t length,
3936 size_t * index,
3937 struct mailimf_delivering_info ** result)
3938 {
3939 size_t cur_token;
3940 clist * list;
3941 struct mailimf_delivering_info * delivering_info;
3942 int r;
3943 int res;
3944
3945 cur_token = * index;
3946
3947 r = mailimf_struct_multiple_parse(message, length, &cur_token,
3948 &list,
3949 (mailimf_struct_parser *)
3950 mailimf_trace_resent_fields_parse,
3951 (mailimf_struct_destructor *)
3952 mailimf_trace_resent_fields_free);
3953 if (r != MAILIMF_NO_ERROR) {
3954 res = r;
3955 goto err;
3956 }
3957
3958 delivering_info = mailimf_delivering_info_new(list);
3959 if (delivering_info == NULL) {
3960 res = MAILIMF_ERROR_MEMORY;
3961 goto free_list;
3962 }
3963
3964 * result = delivering_info;
3965 * index = cur_token;
3966
3967 return MAILIMF_NO_ERROR;
3968
3969 free_list:
3970 clist_foreach(list, (clist_func) mailimf_trace_resent_fields_free, NULL);
3971 clist_free(list);
3972 err:
3973 return res;
3974 }
3975 #endif
3976
3977 /*
3978 field = delivering-info /
3979 orig-date /
3980 from /
3981 sender /
3982 reply-to /
3983 to /
3984 cc /
3985 bcc /
3986 message-id /
3987 in-reply-to /
3988 references /
3989 subject /
3990 comments /
3991 keywords /
3992 optional-field
3993 */
3994
3995 enum {
3996 HEADER_START,
3997 HEADER_C,
3998 HEADER_R,
3999 HEADER_RE,
4000 HEADER_S,
4001 HEADER_RES,
4002 };
4003
4004 static int guess_header_type(const char * message, size_t length, size_t index)
4005 {
4006 int state;
4007 int r;
4008
4009 state = HEADER_START;
4010
4011 while (1) {
4012
4013 if (index >= length)
4014 return MAILIMF_FIELD_NONE;
4015
4016 switch(state) {
4017 case HEADER_START:
4018 switch((char) toupper((unsigned char) message[index])) {
4019 case 'B':
4020 return MAILIMF_FIELD_BCC;
4021 case 'C':
4022 state = HEADER_C;
4023 break;
4024 case 'D':
4025 return MAILIMF_FIELD_ORIG_DATE;
4026 case 'F':
4027 return MAILIMF_FIELD_FROM;
4028 case 'I':
4029 return MAILIMF_FIELD_IN_REPLY_TO;
4030 case 'K':
4031 return MAILIMF_FIELD_KEYWORDS;
4032 case 'M':
4033 return MAILIMF_FIELD_MESSAGE_ID;
4034 case 'R':
4035 state = HEADER_R;
4036 break;
4037 case 'T':
4038 return MAILIMF_FIELD_TO;
4039 break;
4040 case 'S':
4041 state = HEADER_S;
4042 break;
4043 default:
4044 return MAILIMF_FIELD_NONE;
4045 }
4046 break;
4047 case HEADER_C:
4048 switch((char) toupper((unsigned char) message[index])) {
4049 case 'O':
4050 return MAILIMF_FIELD_COMMENTS;
4051 case 'C':
4052 return MAILIMF_FIELD_CC;
4053 default:
4054 return MAILIMF_FIELD_NONE;
4055 }
4056 break;
4057 case HEADER_R:
4058 switch((char) toupper((unsigned char) message[index])) {
4059 case 'E':
4060 state = HEADER_RE;
4061 break;
4062 default:
4063 return MAILIMF_FIELD_NONE;
4064 }
4065 break;
4066 case HEADER_RE:
4067 switch((char) toupper((unsigned char) message[index])) {
4068 case 'F':
4069 return MAILIMF_FIELD_REFERENCES;
4070 case 'P':
4071 return MAILIMF_FIELD_REPLY_TO;
4072 case 'S':
4073 state = HEADER_RES;
4074 break;
4075 case 'T':
4076 return MAILIMF_FIELD_RETURN_PATH;
4077 default:
4078 return MAILIMF_FIELD_NONE;
4079 }
4080 break;
4081 case HEADER_S:
4082 switch((char) toupper((unsigned char) message[index])) {
4083 case 'E':
4084 return MAILIMF_FIELD_SENDER;
4085 case 'U':
4086 return MAILIMF_FIELD_SUBJECT;
4087 default:
4088 return MAILIMF_FIELD_NONE;
4089 }
4090 break;
4091
4092 case HEADER_RES:
4093 r = mailimf_token_case_insensitive_parse(message,
4094 length, &index, "ent-");
4095 if (r != MAILIMF_NO_ERROR)
4096 return MAILIMF_FIELD_NONE;
4097
4098 if (index >= length)
4099 return MAILIMF_FIELD_NONE;
4100
4101 switch((char) toupper((unsigned char) message[index])) {
4102 case 'D':
4103 return MAILIMF_FIELD_RESENT_DATE;
4104 case 'F':
4105 return MAILIMF_FIELD_RESENT_FROM;
4106 case 'S':
4107 return MAILIMF_FIELD_RESENT_SENDER;
4108 case 'T':
4109 return MAILIMF_FIELD_RESENT_TO;
4110 case 'C':
4111 return MAILIMF_FIELD_RESENT_CC;
4112 case 'B':
4113 return MAILIMF_FIELD_RESENT_BCC;
4114 case 'M':
4115 return MAILIMF_FIELD_RESENT_MSG_ID;
4116 default:
4117 return MAILIMF_FIELD_NONE;
4118 }
4119 break;
4120 }
4121 index ++;
4122 }
4123 }
4124
4125 static int mailimf_field_parse(const char * message, size_t length,
4126 size_t * index,
4127 struct mailimf_field ** result)
4128 {
4129 size_t cur_token;
4130 int type;
4131 struct mailimf_return * return_path;
4132 struct mailimf_orig_date * resent_date;
4133 struct mailimf_from * resent_from;
4134 struct mailimf_sender * resent_sender;
4135 struct mailimf_to* resent_to;
4136 struct mailimf_cc * resent_cc;
4137 struct mailimf_bcc * resent_bcc;
4138 struct mailimf_message_id * resent_msg_id;
4139 struct mailimf_orig_date * orig_date;
4140 struct mailimf_from * from;
4141 struct mailimf_sender * sender;
4142 struct mailimf_reply_to * reply_to;
4143 struct mailimf_to * to;
4144 struct mailimf_cc * cc;
4145 struct mailimf_bcc * bcc;
4146 struct mailimf_message_id * message_id;
4147 struct mailimf_in_reply_to * in_reply_to;
4148 struct mailimf_references * references;
4149 struct mailimf_subject * subject;
4150 struct mailimf_comments * comments;
4151 struct mailimf_keywords * keywords;
4152 struct mailimf_optional_field * optional_field;
4153 struct mailimf_field * field;
4154 int guessed_type;
4155 int r;
4156 int res;
4157
4158 cur_token = * index;
4159
4160 return_path = NULL;
4161 resent_date = NULL;
4162 resent_from = NULL;
4163 resent_sender = NULL;
4164 resent_to = NULL;
4165 resent_cc = NULL;
4166 resent_bcc = NULL;
4167 resent_msg_id = NULL;
4168 orig_date = NULL;
4169 from = NULL;
4170 sender = NULL;
4171 reply_to = NULL;
4172 to = NULL;
4173 cc = NULL;
4174 bcc = NULL;
4175 message_id = NULL;
4176 in_reply_to = NULL;
4177 references = NULL;
4178 subject = NULL;
4179 comments = NULL;
4180 keywords = NULL;
4181 optional_field = NULL;
4182
4183 guessed_type = guess_header_type(message, length, cur_token);
4184 type = MAILIMF_FIELD_NONE;
4185
4186 switch (guessed_type) {
4187 case MAILIMF_FIELD_ORIG_DATE:
4188 r = mailimf_orig_date_parse(message, length, &cur_token,
4189 &orig_date);
4190 if (r == MAILIMF_NO_ERROR)
4191 type = MAILIMF_FIELD_ORIG_DATE;
4192 else if (r == MAILIMF_ERROR_PARSE) {
4193 /* do nothing */
4194 }
4195 else {
4196 res = r;
4197 goto free_fields;
4198 }
4199 break;
4200 case MAILIMF_FIELD_FROM:
4201 r = mailimf_from_parse(message, length, &cur_token,
4202 &from);
4203 if (r == MAILIMF_NO_ERROR)
4204 type = guessed_type;
4205 else if (r == MAILIMF_ERROR_PARSE) {
4206 /* do nothing */
4207 }
4208 else {
4209 res = r;
4210 goto free_fields;
4211 }
4212 break;
4213 case MAILIMF_FIELD_SENDER:
4214 r = mailimf_sender_parse(message, length, &cur_token,
4215 &sender);
4216 if (r == MAILIMF_NO_ERROR)
4217 type = guessed_type;
4218 else if (r == MAILIMF_ERROR_PARSE) {
4219 /* do nothing */
4220 }
4221 else {
4222 res = r;
4223 goto free_fields;
4224 }
4225 break;
4226 case MAILIMF_FIELD_REPLY_TO:
4227 r = mailimf_reply_to_parse(message, length, &cur_token,
4228 &reply_to);
4229 if (r == MAILIMF_NO_ERROR)
4230 type = guessed_type;
4231 else if (r == MAILIMF_ERROR_PARSE) {
4232 /* do nothing */
4233 }
4234 else {
4235 res = r;
4236 goto free_fields;
4237 }
4238 break;
4239 case MAILIMF_FIELD_TO:
4240 r = mailimf_to_parse(message, length, &cur_token,
4241 &to);
4242 if (r == MAILIMF_NO_ERROR)
4243 type = guessed_type;
4244 else if (r == MAILIMF_ERROR_PARSE) {
4245 /* do nothing */
4246 }
4247 else {
4248 res = r;
4249 goto free_fields;
4250 }
4251 break;
4252 case MAILIMF_FIELD_CC:
4253 r = mailimf_cc_parse(message, length, &cur_token,
4254 &cc);
4255 if (r == MAILIMF_NO_ERROR)
4256 type = guessed_type;
4257 else if (r == MAILIMF_ERROR_PARSE) {
4258 /* do nothing */
4259 }
4260 else {
4261 res = r;
4262 goto free_fields;
4263 }
4264 break;
4265 case MAILIMF_FIELD_BCC:
4266 r = mailimf_bcc_parse(message, length, &cur_token,
4267 &bcc);
4268 if (r == MAILIMF_NO_ERROR)
4269 type = guessed_type;
4270 else if (r == MAILIMF_ERROR_PARSE) {
4271 /* do nothing */
4272 }
4273 else {
4274 res = r;
4275 goto free_fields;
4276 }
4277 break;
4278 case MAILIMF_FIELD_MESSAGE_ID:
4279 r = mailimf_message_id_parse(message, length, &cur_token,
4280 &message_id);
4281 if (r == MAILIMF_NO_ERROR)
4282 type = guessed_type;
4283 else if (r == MAILIMF_ERROR_PARSE) {
4284 /* do nothing */
4285 }
4286 else {
4287 res = r;
4288 goto free_fields;
4289 }
4290 break;
4291 case MAILIMF_FIELD_IN_REPLY_TO:
4292 r = mailimf_in_reply_to_parse(message, length, &cur_token,
4293 &in_reply_to);
4294 if (r == MAILIMF_NO_ERROR)
4295 type = guessed_type;
4296 else if (r == MAILIMF_ERROR_PARSE) {
4297 /* do nothing */
4298 }
4299 else {
4300 res = r;
4301 goto free_fields;
4302 }
4303 break;
4304 case MAILIMF_FIELD_REFERENCES:
4305 r = mailimf_references_parse(message, length, &cur_token,
4306 &references);
4307 if (r == MAILIMF_NO_ERROR)
4308 type = guessed_type;
4309 else if (r == MAILIMF_ERROR_PARSE) {
4310 /* do nothing */
4311 }
4312 else {
4313 res = r;
4314 goto free_fields;
4315 }
4316 break;
4317 case MAILIMF_FIELD_SUBJECT:
4318 r = mailimf_subject_parse(message, length, &cur_token,
4319 &subject);
4320 if (r == MAILIMF_NO_ERROR)
4321 type = guessed_type;
4322 else if (r == MAILIMF_ERROR_PARSE) {
4323 /* do nothing */
4324 }
4325 else {
4326 res = r;
4327 goto free_fields;
4328 }
4329 break;
4330 case MAILIMF_FIELD_COMMENTS:
4331 r = mailimf_comments_parse(message, length, &cur_token,
4332 &comments);
4333 if (r == MAILIMF_NO_ERROR)
4334 type = guessed_type;
4335 else if (r == MAILIMF_ERROR_PARSE) {
4336 /* do nothing */
4337 }
4338 else {
4339 res = r;
4340 goto free_fields;
4341 }
4342 break;
4343 case MAILIMF_FIELD_KEYWORDS:
4344 r = mailimf_keywords_parse(message, length, &cur_token,
4345 &keywords);
4346 if (r == MAILIMF_NO_ERROR)
4347 type = guessed_type;
4348 else if (r == MAILIMF_ERROR_PARSE) {
4349 /* do nothing */
4350 }
4351 else {
4352 res = r;
4353 goto free_fields;
4354 }
4355 break;
4356 case MAILIMF_FIELD_RETURN_PATH:
4357 r = mailimf_return_parse(message, length, &cur_token,
4358 &return_path);
4359 if (r == MAILIMF_NO_ERROR)
4360 type = guessed_type;
4361 else if (r == MAILIMF_ERROR_PARSE) {
4362 /* do nothing */
4363 }
4364 else {
4365 res = r;
4366 goto free_fields;
4367 }
4368 break;
4369 case MAILIMF_FIELD_RESENT_DATE:
4370 r = mailimf_resent_date_parse(message, length, &cur_token,
4371 &resent_date);
4372 if (r == MAILIMF_NO_ERROR)
4373 type = guessed_type;
4374 else if (r == MAILIMF_ERROR_PARSE) {
4375 /* do nothing */
4376 }
4377 else {
4378 res = r;
4379 goto free_fields;
4380 }
4381 break;
4382 case MAILIMF_FIELD_RESENT_FROM:
4383 r = mailimf_resent_from_parse(message, length, &cur_token,
4384 &resent_from);
4385 if (r == MAILIMF_NO_ERROR)
4386 type = guessed_type;
4387 else if (r == MAILIMF_ERROR_PARSE) {
4388 /* do nothing */
4389 }
4390 else {
4391 res = r;
4392 goto free_fields;
4393 }
4394 break;
4395 case MAILIMF_FIELD_RESENT_SENDER:
4396 r = mailimf_resent_sender_parse(message, length, &cur_token,
4397 &resent_sender);
4398 if (r == MAILIMF_NO_ERROR)
4399 type = guessed_type;
4400 else if (r == MAILIMF_ERROR_PARSE) {
4401 /* do nothing */
4402 }
4403 else {
4404 res = r;
4405 goto free_fields;
4406 }
4407 break;
4408 case MAILIMF_FIELD_RESENT_TO:
4409 r = mailimf_resent_to_parse(message, length, &cur_token,
4410 &resent_to);
4411 if (r == MAILIMF_NO_ERROR)
4412 type = guessed_type;
4413 else if (r == MAILIMF_ERROR_PARSE) {
4414 /* do nothing */
4415 }
4416 else {
4417 res = r;
4418 goto free_fields;
4419 }
4420 break;
4421 case MAILIMF_FIELD_RESENT_CC:
4422 r= mailimf_resent_cc_parse(message, length, &cur_token,
4423 &resent_cc);
4424 if (r == MAILIMF_NO_ERROR)
4425 type = guessed_type;
4426 else if (r == MAILIMF_ERROR_PARSE) {
4427 /* do nothing */
4428 }
4429 else {
4430 res = r;
4431 goto free_fields;
4432 }
4433 break;
4434 case MAILIMF_FIELD_RESENT_BCC:
4435 r = mailimf_resent_bcc_parse(message, length, &cur_token,
4436 &resent_bcc);
4437 if (r == MAILIMF_NO_ERROR)
4438 type = guessed_type;
4439 else if (r == MAILIMF_ERROR_PARSE) {
4440 /* do nothing */
4441 }
4442 else {
4443 res = r;
4444 goto free_fields;
4445 }
4446 break;
4447 case MAILIMF_FIELD_RESENT_MSG_ID:
4448 r = mailimf_resent_msg_id_parse(message, length, &cur_token,
4449 &resent_msg_id);
4450 if (r == MAILIMF_NO_ERROR)
4451 type = guessed_type;
4452 else if (r == MAILIMF_ERROR_PARSE) {
4453 /* do nothing */
4454 }
4455 else {
4456 res = r;
4457 goto free_fields;
4458 }
4459 break;
4460 }
4461
4462 if (type == MAILIMF_FIELD_NONE) {
4463 r = mailimf_optional_field_parse(message, length, &cur_token,
4464 &optional_field);
4465 if (r != MAILIMF_NO_ERROR) {
4466 res = r;
4467 goto free_fields;
4468 }
4469
4470 type = MAILIMF_FIELD_OPTIONAL_FIELD;
4471 }
4472
4473 field = mailimf_field_new(type, return_path, resent_date,
4474 resent_from, resent_sender, resent_to, resent_cc, resent_bcc,
4475 resent_msg_id, orig_date, from, sender, reply_to, to,
4476 cc, bcc, message_id, in_reply_to, references,
4477 subject, comments, keywords, optional_field);
4478 if (field == NULL) {
4479 res = MAILIMF_ERROR_MEMORY;
4480 goto free_fields;
4481 }
4482
4483 * result = field;
4484 * index = cur_token;
4485
4486 return MAILIMF_NO_ERROR;
4487
4488 free_fields:
4489 if (return_path != NULL)
4490 mailimf_return_free(return_path);
4491 if (resent_date != NULL)
4492 mailimf_orig_date_free(resent_date);
4493 if (resent_from != NULL)
4494 mailimf_from_free(resent_from);
4495 if (resent_sender != NULL)
4496 mailimf_sender_free(resent_sender);
4497 if (resent_to != NULL)
4498 mailimf_to_free(resent_to);
4499 if (resent_cc != NULL)
4500 mailimf_cc_free(resent_cc);
4501 if (resent_bcc != NULL)
4502 mailimf_bcc_free(resent_bcc);
4503 if (resent_msg_id != NULL)
4504 mailimf_message_id_free(resent_msg_id);
4505 if (orig_date != NULL)
4506 mailimf_orig_date_free(orig_date);
4507 if (from != NULL)
4508 mailimf_from_free(from);
4509 if (sender != NULL)
4510 mailimf_sender_free(sender);
4511 if (reply_to != NULL)
4512 mailimf_reply_to_free(reply_to);
4513 if (to != NULL)
4514 mailimf_to_free(to);
4515 if (cc != NULL)
4516 mailimf_cc_free(cc);
4517 if (bcc != NULL)
4518 mailimf_bcc_free(bcc);
4519 if (message_id != NULL)
4520 mailimf_message_id_free(message_id);
4521 if (in_reply_to != NULL)
4522 mailimf_in_reply_to_free(in_reply_to);
4523 if (references != NULL)
4524 mailimf_references_free(references);
4525 if (subject != NULL)
4526 mailimf_subject_free(subject);
4527 if (comments != NULL)
4528 mailimf_comments_free(comments);
4529 if (keywords != NULL)
4530 mailimf_keywords_free(keywords);
4531 if (optional_field != NULL)
4532 mailimf_optional_field_free(optional_field);
4533 return res;
4534 }
4535
4536
4537 /*
4538 fields = *(delivering-info /
4539 orig-date /
4540 from /
4541 sender /
4542 reply-to /
4543 to /
4544 cc /
4545 bcc /
4546 message-id /
4547 in-reply-to /
4548 references /
4549 subject /
4550 comments /
4551 keywords /
4552 optional-field)
4553 */
4554
4555 #if 0
4556 int
4557 mailimf_unparsed_fields_parse(const char * message, size_t length,
4558 size_t * index,
4559 struct mailimf_unparsed_fields ** result)
4560 {
4561 size_t cur_token;
4562 clist * list;
4563 struct mailimf_unparsed_fields * fields;
4564 int r;
4565 int res;
4566
4567 cur_token = * index;
4568
4569 list = NULL;
4570
4571 r = mailimf_struct_multiple_parse(message, length, &cur_token,
4572 &list,
4573 (mailimf_struct_parser *)
4574 mailimf_optional_field_parse,
4575 (mailimf_struct_destructor *)
4576 mailimf_optional_field_free);
4577 /*
4578 if ((r = MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
4579 res = r;
4580 goto err;
4581 }
4582 */
4583
4584 switch (r) {
4585 case MAILIMF_NO_ERROR:
4586 /* do nothing */
4587 break;
4588
4589 case MAILIMF_ERROR_PARSE:
4590 list = clist_new();
4591 if (list == NULL) {
4592 res = MAILIMF_ERROR_MEMORY;
4593 goto err;
4594 }
4595 break;
4596
4597 default:
4598 res = r;
4599 goto err;
4600 }
4601
4602 fields = mailimf_unparsed_fields_new(list);
4603 if (fields == NULL) {
4604 res = MAILIMF_ERROR_MEMORY;
4605 goto free;
4606 }
4607
4608 * result = fields;
4609 * index = cur_token;
4610
4611 return MAILIMF_NO_ERROR;
4612
4613 free:
4614 if (list != NULL) {
4615 clist_foreach(list, (clist_func) mailimf_optional_field_free, NULL);
4616 clist_free(list);
4617 }
4618 err:
4619 return res;
4620 }
4621 #endif
4622
4623 int mailimf_fields_parse(const char * message, size_t length,
4624 size_t * index,
4625 struct mailimf_fields ** result)
4626 {
4627 size_t cur_token;
4628 clist * list;
4629 struct mailimf_fields * fields;
4630 int r;
4631 int res;
4632
4633 cur_token = * index;
4634
4635 list = NULL;
4636
4637 r = mailimf_struct_multiple_parse(message, length, &cur_token,
4638 &list,
4639 (mailimf_struct_parser *)
4640 mailimf_field_parse,
4641 (mailimf_struct_destructor *)
4642 mailimf_field_free);
4643 /*
4644 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
4645 res = r;
4646 goto err;
4647 }
4648 */
4649
4650 switch (r) {
4651 case MAILIMF_NO_ERROR:
4652 /* do nothing */
4653 break;
4654
4655 case MAILIMF_ERROR_PARSE:
4656 list = clist_new();
4657 if (list == NULL) {
4658 res = MAILIMF_ERROR_MEMORY;
4659 goto err;
4660 }
4661 break;
4662
4663 default:
4664 res = r;
4665 goto err;
4666 }
4667
4668 fields = mailimf_fields_new(list);
4669 if (fields == NULL) {
4670 res = MAILIMF_ERROR_MEMORY;
4671 goto free;
4672 }
4673
4674 * result = fields;
4675 * index = cur_token;
4676
4677 return MAILIMF_NO_ERROR;
4678
4679 free:
4680 if (list != NULL) {
4681 clist_foreach(list, (clist_func) mailimf_field_free, NULL);
4682 clist_free(list);
4683 }
4684 err:
4685 return res;
4686 }
4687
4688 /*
4689 orig-date = "Date:" date-time CRLF
4690 */
4691
4692
4693 static int
4694 mailimf_orig_date_parse(const char * message, size_t length,
4695 size_t * index, struct mailimf_orig_date ** result)
4696 {
4697 struct mailimf_date_time * date_time;
4698 struct mailimf_orig_date * orig_date;
4699 size_t cur_token;
4700 int r;
4701 int res;
4702
4703 cur_token = * index;
4704
4705 r = mailimf_token_case_insensitive_parse(message, length,
4706 &cur_token, "Date:");
4707 if (r != MAILIMF_NO_ERROR) {
4708 res = r;
4709 goto err;
4710 }
4711
4712 r = mailimf_date_time_parse(message, length, &cur_token, &date_time);
4713 if (r != MAILIMF_NO_ERROR) {
4714 res = r;
4715 goto err;
4716 }
4717
4718 r = mailimf_ignore_unstructured_parse(message, length, &cur_token);
4719 if (r != MAILIMF_NO_ERROR) {
4720 res = r;
4721 goto free_date_time;
4722 }
4723
4724 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
4725 if (r != MAILIMF_NO_ERROR) {
4726 res = r;
4727 goto free_date_time;
4728 }
4729
4730 orig_date = mailimf_orig_date_new(date_time);
4731 if (orig_date == NULL) {
4732 res = MAILIMF_ERROR_MEMORY;
4733 goto free_date_time;
4734 }
4735
4736 * result = orig_date;
4737 * index = cur_token;
4738
4739 return MAILIMF_NO_ERROR;
4740
4741 free_date_time:
4742 mailimf_date_time_free(date_time);
4743 err:
4744 return res;
4745 }
4746
4747 /*
4748 from = "From:" mailbox-list CRLF
4749 */
4750
4751 static int
4752 mailimf_from_parse(const char * message, size_t length,
4753 size_t * index, struct mailimf_from ** result)
4754 {
4755 struct mailimf_mailbox_list * mb_list;
4756 struct mailimf_from * from;
4757 size_t cur_token;
4758 int r;
4759 int res;
4760
4761 cur_token = * index;
4762
4763 r = mailimf_token_case_insensitive_parse(message, length,
4764 &cur_token, "From");
4765 if (r != MAILIMF_NO_ERROR) {
4766 res = r;
4767 goto err;
4768 }
4769
4770 r = mailimf_colon_parse(message, length, &cur_token);
4771 if (r != MAILIMF_NO_ERROR) {
4772 res = r;
4773 goto err;
4774 }
4775
4776 r = mailimf_mailbox_list_parse(message, length, &cur_token, &mb_list);
4777
4778 if (r != MAILIMF_NO_ERROR) {
4779 res = r;
4780 goto err;
4781 }
4782
4783 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
4784 if (r != MAILIMF_NO_ERROR) {
4785 res = r;
4786 goto free_mb_list;
4787 }
4788
4789 from = mailimf_from_new(mb_list);
4790 if (from == NULL) {
4791 res = MAILIMF_ERROR_MEMORY;
4792 goto free_mb_list;
4793 }
4794
4795 * result = from;
4796 * index = cur_token;
4797
4798 return MAILIMF_NO_ERROR;
4799
4800 free_mb_list:
4801 mailimf_mailbox_list_free(mb_list);
4802 err:
4803 return res;
4804 }
4805
4806 /*
4807 sender = "Sender:" mailbox CRLF
4808 */
4809
4810 static int
4811 mailimf_sender_parse(const char * message, size_t length,
4812 size_t * index, struct mailimf_sender ** result)
4813 {
4814 struct mailimf_mailbox * mb;
4815 struct mailimf_sender * sender;
4816 size_t cur_token;
4817 int r;
4818 int res;
4819
4820 cur_token = * index;
4821
4822 r = mailimf_token_case_insensitive_parse(message, length,
4823 &cur_token, "Sender");
4824 if (r != MAILIMF_NO_ERROR) {
4825 res = r;
4826 goto err;
4827 }
4828
4829 r = mailimf_colon_parse(message, length, &cur_token);
4830 if (r != MAILIMF_NO_ERROR) {
4831 res = r;
4832 goto err;
4833 }
4834
4835 r = mailimf_mailbox_parse(message, length, &cur_token, &mb);
4836 if (r != MAILIMF_NO_ERROR) {
4837 res = r;
4838 goto err;
4839 }
4840
4841 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
4842 if (r != MAILIMF_NO_ERROR) {
4843 res = r;
4844 goto free_mb;
4845 }
4846
4847 sender = mailimf_sender_new(mb);
4848 if (sender == NULL) {
4849 res = MAILIMF_ERROR_MEMORY;
4850 goto free_mb;
4851 }
4852
4853 * result = sender;
4854 * index = cur_token;
4855
4856 return MAILIMF_NO_ERROR;
4857
4858 free_mb:
4859 mailimf_mailbox_free(mb);
4860 err:
4861 return res;
4862 }
4863
4864 /*
4865 reply-to = "Reply-To:" address-list CRLF
4866 */
4867
4868
4869 static int
4870 mailimf_reply_to_parse(const char * message, size_t length,
4871 size_t * index, struct mailimf_reply_to ** result)
4872 {
4873 struct mailimf_address_list * addr_list;
4874 struct mailimf_reply_to * reply_to;
4875 size_t cur_token;
4876 int r;
4877 int res;
4878
4879 cur_token = * index;
4880
4881 r = mailimf_token_case_insensitive_parse(message, length,
4882 &cur_token, "Reply-To");
4883 if (r != MAILIMF_NO_ERROR) {
4884 res = r;
4885 goto err;
4886 }
4887
4888 r = mailimf_colon_parse(message, length, &cur_token);
4889 if (r != MAILIMF_NO_ERROR) {
4890 res = r;
4891 goto err;
4892 }
4893
4894 r = mailimf_address_list_parse(message, length, &cur_token, &addr_list);
4895 if (r != MAILIMF_NO_ERROR) {
4896 res = r;
4897 goto err;
4898 }
4899
4900 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
4901 if (r != MAILIMF_NO_ERROR) {
4902 res = r;
4903 goto free_addr_list;
4904 }
4905
4906 reply_to = mailimf_reply_to_new(addr_list);
4907 if (reply_to == NULL) {
4908 res = MAILIMF_ERROR_MEMORY;
4909 goto free_addr_list;
4910 }
4911
4912 * result = reply_to;
4913 * index = cur_token;
4914
4915 return MAILIMF_NO_ERROR;
4916
4917 free_addr_list:
4918 mailimf_address_list_free(addr_list);
4919 err:
4920 return res;
4921 }
4922
4923 /*
4924 to = "To:" address-list CRLF
4925 */
4926
4927 static int
4928 mailimf_to_parse(const char * message, size_t length,
4929 size_t * index, struct mailimf_to ** result)
4930 {
4931 struct mailimf_address_list * addr_list;
4932 struct mailimf_to * to;
4933 size_t cur_token;
4934 int r;
4935 int res;
4936
4937 cur_token = * index;
4938
4939 r = mailimf_token_case_insensitive_parse(message, length,
4940 &cur_token, "To");
4941 if (r != MAILIMF_NO_ERROR) {
4942 res = r;
4943 goto err;
4944 }
4945
4946 r = mailimf_colon_parse(message, length, &cur_token);
4947 if (r != MAILIMF_NO_ERROR) {
4948 res = r;
4949 goto err;
4950 }
4951
4952 r = mailimf_address_list_parse(message, length, &cur_token, &addr_list);
4953 if (r != MAILIMF_NO_ERROR) {
4954 res = r;
4955 goto err;
4956 }
4957
4958 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
4959 if (r != MAILIMF_NO_ERROR) {
4960 res = r;
4961 goto free_addr_list;
4962 }
4963
4964 to = mailimf_to_new(addr_list);
4965 if (to == NULL) {
4966 res = MAILIMF_ERROR_MEMORY;
4967 goto free_addr_list;
4968 }
4969
4970 * result = to;
4971 * index = cur_token;
4972
4973 return MAILIMF_NO_ERROR;
4974
4975 free_addr_list:
4976 mailimf_address_list_free(addr_list);
4977 err:
4978 return res;
4979 }
4980
4981 /*
4982 cc = "Cc:" address-list CRLF
4983 */
4984
4985
4986 static int
4987 mailimf_cc_parse(const char * message, size_t length,
4988 size_t * index, struct mailimf_cc ** result)
4989 {
4990 struct mailimf_address_list * addr_list;
4991 struct mailimf_cc * cc;
4992 size_t cur_token;
4993 int r;
4994 int res;
4995
4996 cur_token = * index;
4997
4998 r = mailimf_token_case_insensitive_parse(message, length,
4999 &cur_token, "Cc");
5000 if (r != MAILIMF_NO_ERROR) {
5001 res = r;
5002 goto err;
5003 }
5004
5005 r = mailimf_colon_parse(message, length, &cur_token);
5006 if (r != MAILIMF_NO_ERROR) {
5007 res = r;
5008 goto err;
5009 }
5010
5011 r = mailimf_address_list_parse(message, length, &cur_token, &addr_list);
5012 if (r != MAILIMF_NO_ERROR) {
5013 res = r;
5014 goto err;
5015 }
5016
5017 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5018 if (r != MAILIMF_NO_ERROR) {
5019 res = r;
5020 goto free_addr_list;
5021 }
5022
5023 cc = mailimf_cc_new(addr_list);
5024 if (cc == NULL) {
5025 res = MAILIMF_ERROR_MEMORY;
5026 goto free_addr_list;
5027 }
5028
5029 * result = cc;
5030 * index = cur_token;
5031
5032 return MAILIMF_NO_ERROR;
5033
5034 free_addr_list:
5035 mailimf_address_list_free(addr_list);
5036 err:
5037 return res;
5038 }
5039
5040 /*
5041 bcc = "Bcc:" (address-list / [CFWS]) CRLF
5042 */
5043
5044
5045 static int
5046 mailimf_bcc_parse(const char * message, size_t length,
5047 size_t * index, struct mailimf_bcc ** result)
5048 {
5049 struct mailimf_address_list * addr_list;
5050 struct mailimf_bcc * bcc;
5051 size_t cur_token;
5052 int r;
5053 int res;
5054
5055 cur_token = * index;
5056 addr_list = NULL;
5057
5058 r = mailimf_token_case_insensitive_parse(message, length,
5059 &cur_token, "Bcc");
5060 if (r != MAILIMF_NO_ERROR) {
5061 res = r;
5062 goto err;
5063 }
5064
5065 r = mailimf_colon_parse(message, length, &cur_token);
5066 if (r != MAILIMF_NO_ERROR) {
5067 res = r;
5068 goto err;
5069 }
5070
5071 r = mailimf_address_list_parse(message, length, &cur_token, &addr_list);
5072 switch (r) {
5073 case MAILIMF_NO_ERROR:
5074 /* do nothing */
5075 break;
5076 case MAILIMF_ERROR_PARSE:
5077 r = mailimf_cfws_parse(message, length, &cur_token);
5078 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
5079 res = r;
5080 goto err;
5081 }
5082 break;
5083 default:
5084 res = r;
5085 goto err;
5086 }
5087
5088 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5089 if (r != MAILIMF_NO_ERROR) {
5090 res = r;
5091 goto free_addr_list;
5092 }
5093
5094 bcc = mailimf_bcc_new(addr_list);
5095 if (bcc == NULL) {
5096 res = MAILIMF_ERROR_MEMORY;
5097 goto free_addr_list;
5098 }
5099
5100 * result = bcc;
5101 * index = cur_token;
5102
5103 return MAILIMF_NO_ERROR;
5104
5105 free_addr_list:
5106 mailimf_address_list_free(addr_list);
5107 err:
5108 return res;
5109 }
5110
5111 /*
5112 message-id = "Message-ID:" msg-id CRLF
5113 */
5114
5115 static int mailimf_message_id_parse(const char * message, size_t length,
5116 size_t * index,
5117 struct mailimf_message_id ** result)
5118 {
5119 char * value;
5120 size_t cur_token;
5121 struct mailimf_message_id * message_id;
5122 int r;
5123 int res;
5124
5125 cur_token = * index;
5126
5127 r = mailimf_token_case_insensitive_parse(message, length,
5128 &cur_token, "Message-ID");
5129 if (r != MAILIMF_NO_ERROR) {
5130 res = r;
5131 goto err;
5132 }
5133
5134 r = mailimf_colon_parse(message, length, &cur_token);
5135 if (r != MAILIMF_NO_ERROR) {
5136 res = r;
5137 goto err;
5138 }
5139
5140 r = mailimf_msg_id_parse(message, length, &cur_token, &value);
5141 if (r != MAILIMF_NO_ERROR) {
5142 res = r;
5143 goto err;
5144 }
5145
5146 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5147 if (r != MAILIMF_NO_ERROR) {
5148 res = r;
5149 goto free_value;
5150 }
5151
5152 message_id = mailimf_message_id_new(value);
5153 if (message_id == NULL) {
5154 res = MAILIMF_ERROR_MEMORY;
5155 goto free_value;
5156 }
5157
5158 * result = message_id;
5159 * index = cur_token;
5160
5161 return MAILIMF_NO_ERROR;
5162
5163 free_value:
5164 mailimf_msg_id_free(value);
5165 err:
5166 return res;
5167 }
5168
5169 /*
5170 in-reply-to = "In-Reply-To:" 1*msg-id CRLF
5171 */
5172
5173 int mailimf_msg_id_list_parse(const char * message, size_t length,
5174 size_t * index, clist ** result)
5175 {
5176 return mailimf_struct_multiple_parse(message, length, index,
5177 result,
5178 (mailimf_struct_parser *)
5179 mailimf_unstrict_msg_id_parse,
5180 (mailimf_struct_destructor *)
5181 mailimf_msg_id_free);
5182 }
5183
5184 static int mailimf_in_reply_to_parse(const char * message, size_t length,
5185 size_t * index,
5186 struct mailimf_in_reply_to ** result)
5187 {
5188 struct mailimf_in_reply_to * in_reply_to;
5189 size_t cur_token;
5190 clist * msg_id_list;
5191 int res;
5192 int r;
5193
5194 cur_token = * index;
5195
5196 r = mailimf_token_case_insensitive_parse(message, length,
5197 &cur_token, "In-Reply-To");
5198 if (r != MAILIMF_NO_ERROR) {
5199 res = r;
5200 goto err;
5201 }
5202
5203 r = mailimf_colon_parse(message, length, &cur_token);
5204 if (r != MAILIMF_NO_ERROR) {
5205 res = r;
5206 goto err;
5207 }
5208
5209 r = mailimf_msg_id_list_parse(message, length, &cur_token, &msg_id_list);
5210 if (r != MAILIMF_NO_ERROR) {
5211 res = r;
5212 goto err;
5213 }
5214
5215 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5216 if (r != MAILIMF_NO_ERROR) {
5217 res = r;
5218 goto free_list;
5219 }
5220
5221 in_reply_to = mailimf_in_reply_to_new(msg_id_list);
5222 if (in_reply_to == NULL) {
5223 res = MAILIMF_ERROR_MEMORY;
5224 goto free_list;
5225 }
5226
5227 * result = in_reply_to;
5228 * index = cur_token;
5229
5230 return MAILIMF_NO_ERROR;
5231
5232 free_list:
5233 clist_foreach(msg_id_list, (clist_func) mailimf_msg_id_free, NULL);
5234 clist_free(msg_id_list);
5235 err:
5236 return res;
5237 }
5238
5239 /*
5240 references = "References:" 1*msg-id CRLF
5241 */
5242
5243 int mailimf_references_parse(const char * message, size_t length,
5244 size_t * index,
5245 struct mailimf_references ** result)
5246 {
5247 struct mailimf_references * references;
5248 size_t cur_token;
5249 clist * msg_id_list;
5250 int r;
5251 int res;
5252
5253 cur_token = * index;
5254
5255 r = mailimf_token_case_insensitive_parse(message, length,
5256 &cur_token, "References");
5257 if (r != MAILIMF_NO_ERROR) {
5258 res = r;
5259 goto err;
5260 }
5261
5262 r = mailimf_colon_parse(message, length, &cur_token);
5263 if (r != MAILIMF_NO_ERROR) {
5264 res = r;
5265 goto err;
5266 }
5267
5268 r = mailimf_msg_id_list_parse(message, length, &cur_token, &msg_id_list);
5269 if (r != MAILIMF_NO_ERROR) {
5270 res = r;
5271 goto err;
5272 }
5273
5274 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5275 if (r != MAILIMF_NO_ERROR) {
5276 res = r;
5277 goto free_list;
5278 }
5279
5280 references = mailimf_references_new(msg_id_list);
5281 if (references == NULL) {
5282 res = MAILIMF_ERROR_MEMORY;
5283 goto free_list;
5284 }
5285
5286 * result = references;
5287 * index = cur_token;
5288
5289 return MAILIMF_NO_ERROR;
5290
5291 free_list:
5292 clist_foreach(msg_id_list, (clist_func) mailimf_msg_id_free, NULL);
5293 clist_free(msg_id_list);
5294 err:
5295 return res;
5296 }
5297
5298 /*
5299 msg-id = [CFWS] "<" id-left "@" id-right ">" [CFWS]
5300 */
5301
5302 int mailimf_msg_id_parse(const char * message, size_t length,
5303 size_t * index,
5304 char ** result)
5305 {
5306 size_t cur_token;
5307 #if 0
5308 char * id_left;
5309 char * id_right;
5310 #endif
5311 char * msg_id;
5312 int r;
5313 int res;
5314
5315 cur_token = * index;
5316
5317 r = mailimf_cfws_parse(message, length, &cur_token);
5318 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
5319 return r;
5320
5321 r = mailimf_lower_parse(message, length, &cur_token);
5322 if (r != MAILIMF_NO_ERROR) {
5323 res = r;
5324 goto err;
5325 }
5326
5327 r = mailimf_addr_spec_parse(message, length, &cur_token, &msg_id);
5328 if (r != MAILIMF_NO_ERROR) {
5329 res = r;
5330 goto err;
5331 }
5332
5333 r = mailimf_greater_parse(message, length, &cur_token);
5334 if (r != MAILIMF_NO_ERROR) {
5335 free(msg_id);
5336 res = r;
5337 goto err;
5338 }
5339
5340 #if 0
5341 r = mailimf_id_left_parse(message, length, &cur_token, &id_left);
5342 if (r != MAILIMF_NO_ERROR) {
5343 res = r;
5344 goto err;
5345 }
5346
5347 r = mailimf_at_sign_parse(message, length, &cur_token);
5348 if (r != MAILIMF_NO_ERROR) {
5349 res = r;
5350 goto free_id_left;
5351 }
5352
5353 r = mailimf_id_right_parse(message, length, &cur_token, &id_right);
5354 if (r != MAILIMF_NO_ERROR) {
5355 res = r;
5356 goto free_id_left;
5357 }
5358
5359 r = mailimf_greater_parse(message, length, &cur_token);
5360 if (r != MAILIMF_NO_ERROR) {
5361 res = r;
5362 goto free_id_right;
5363 }
5364
5365 msg_id = malloc(strlen(id_left) + strlen(id_right) + 2);
5366 if (msg_id == NULL) {
5367 res = MAILIMF_ERROR_MEMORY;
5368 goto free_id_right;
5369 }
5370 strcpy(msg_id, id_left);
5371 strcat(msg_id, "@");
5372 strcat(msg_id, id_right);
5373
5374 mailimf_id_left_free(id_left);
5375 mailimf_id_right_free(id_right);
5376 #endif
5377
5378 * result = msg_id;
5379 * index = cur_token;
5380
5381 return MAILIMF_NO_ERROR;
5382
5383 #if 0
5384 free_id_right:
5385 mailimf_id_right_free(id_right);
5386 free_id_left:
5387 mailimf_id_left_free(id_left);
5388 #endif
5389 /*
5390 free:
5391 mailimf_atom_free(msg_id);
5392 */
5393 err:
5394 return res;
5395 }
5396
5397 static int mailimf_parse_unwanted_msg_id(const char * message, size_t length,
5398 size_t * index)
5399 {
5400 size_t cur_token;
5401 int r;
5402 char * word;
5403 int token_parsed;
5404
5405 cur_token = * index;
5406
5407 token_parsed = TRUE;
5408 while (token_parsed) {
5409 token_parsed = FALSE;
5410 r = mailimf_word_parse(message, length, &cur_token, &word);
5411 if (r == MAILIMF_NO_ERROR) {
5412 mailimf_word_free(word);
5413 token_parsed = TRUE;
5414 }
5415 else if (r == MAILIMF_ERROR_PARSE) {
5416 /* do nothing */
5417 }
5418 else
5419 return r;
5420 r = mailimf_semi_colon_parse(message, length, &cur_token);
5421 if (r == MAILIMF_NO_ERROR)
5422 token_parsed = TRUE;
5423 else if (r == MAILIMF_ERROR_PARSE) {
5424 /* do nothing */
5425 }
5426 else
5427 return r;
5428 r = mailimf_comma_parse(message, length, &cur_token);
5429 if (r == MAILIMF_NO_ERROR)
5430 token_parsed = TRUE;
5431 else if (r == MAILIMF_ERROR_PARSE) {
5432 /* do nothing */
5433 }
5434 else
5435 return r;
5436 r = mailimf_plus_parse(message, length, &cur_token);
5437 if (r == MAILIMF_NO_ERROR)
5438 token_parsed = TRUE;
5439 else if (r == MAILIMF_ERROR_PARSE) {
5440 /* do nothing */
5441 }
5442 else
5443 return r;
5444 r = mailimf_colon_parse(message, length, &cur_token);
5445 if (r == MAILIMF_NO_ERROR)
5446 token_parsed = TRUE;
5447 else if (r == MAILIMF_ERROR_PARSE) {
5448 /* do nothing */
5449 }
5450 else
5451 return r;
5452 r = mailimf_point_parse(message, length, &cur_token);
5453 if (r == MAILIMF_NO_ERROR)
5454 token_parsed = TRUE;
5455 else if (r == MAILIMF_ERROR_PARSE) {
5456 /* do nothing */
5457 }
5458 else
5459 return r;
5460 r = mailimf_at_sign_parse(message, length, &cur_token);
5461 if (r == MAILIMF_NO_ERROR)
5462 token_parsed = TRUE;
5463 else if (r == MAILIMF_ERROR_PARSE) {
5464 /* do nothing */
5465 }
5466 else
5467 return r;
5468 }
5469
5470 return MAILIMF_NO_ERROR;
5471 }
5472
5473 static int mailimf_unstrict_msg_id_parse(const char * message, size_t length,
5474 size_t * index,
5475 char ** result)
5476 {
5477 char * msgid = NULL;
5478 size_t cur_token;
5479 int r;
5480
5481 cur_token = * index;
5482
5483 r = mailimf_cfws_parse(message, length, &cur_token);
5484 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
5485 return r;
5486
5487 r = mailimf_parse_unwanted_msg_id(message, length, &cur_token);
5488 if (r != MAILIMF_NO_ERROR)
5489 return r;
5490
5491 r = mailimf_msg_id_parse(message, length, &cur_token, &msgid);
5492 if (r != MAILIMF_NO_ERROR)
5493 return r;
5494
5495 r = mailimf_parse_unwanted_msg_id(message, length, &cur_token);
5496 if (r != MAILIMF_NO_ERROR) {
5497 free(msgid);
5498 return r;
5499 }
5500
5501 * result = msgid;
5502 * index = cur_token;
5503
5504 return MAILIMF_NO_ERROR;
5505 }
5506
5507 /*
5508 id-left = dot-atom-text / no-fold-quote / obs-id-left
5509 */
5510
5511 #if 0
5512 static int mailimf_id_left_parse(const char * message, size_t length,
5513 size_t * index, char ** result)
5514 {
5515 int r;
5516
5517 r = mailimf_dot_atom_text_parse(message, length, index, result);
5518 switch (r) {
5519 case MAILIMF_NO_ERROR:
5520 return MAILIMF_NO_ERROR;
5521 case MAILIMF_ERROR_PARSE:
5522 break;
5523 default:
5524 return r;
5525 }
5526
5527 r = mailimf_no_fold_quote_parse(message, length, index, result);
5528 if (r != MAILIMF_NO_ERROR)
5529 return r;
5530
5531 return MAILIMF_NO_ERROR;
5532 }
5533 #endif
5534
5535 /*
5536 id-right = dot-atom-text / no-fold-literal / obs-id-right
5537 */
5538
5539 #if 0
5540 static int mailimf_id_right_parse(const char * message, size_t length,
5541 size_t * index, char ** result)
5542 {
5543 int r;
5544
5545 r = mailimf_dot_atom_text_parse(message, length, index, result);
5546 switch (r) {
5547 case MAILIMF_NO_ERROR:
5548 return MAILIMF_NO_ERROR;
5549 case MAILIMF_ERROR_PARSE:
5550 break;
5551 default:
5552 return r;
5553 }
5554
5555 r = mailimf_no_fold_literal_parse(message, length, index, result);
5556 if (r != MAILIMF_NO_ERROR)
5557 return r;
5558
5559 return MAILIMF_NO_ERROR;
5560 }
5561 #endif
5562
5563 /*
5564 no-fold-quote = DQUOTE *(qtext / quoted-pair) DQUOTE
5565 */
5566
5567 #if 0
5568 static int mailimf_no_fold_quote_char_parse(const char * message, size_t length,
5569 size_t * index, char * result)
5570 {
5571 char ch;
5572 size_t cur_token;
5573 int r;
5574
5575 cur_token = * index;
5576
5577 #if 0
5578 r = mailimf_qtext_parse(message, length, &cur_token, &ch);
5579 #endif
5580
5581 if (cur_token >= length)
5582 return MAILIMF_ERROR_PARSE;
5583
5584 if (is_qtext(message[cur_token])) {
5585 ch = message[cur_token];
5586 cur_token ++;
5587 }
5588 else {
5589 r = mailimf_quoted_pair_parse(message, length, &cur_token, &ch);
5590
5591 if (r != MAILIMF_NO_ERROR)
5592 return r;
5593 }
5594
5595 * index = cur_token;
5596 * result = ch;
5597
5598 return MAILIMF_NO_ERROR;
5599 }
5600 #endif
5601
5602 #if 0
5603 static int mailimf_no_fold_quote_parse(const char * message, size_t length,
5604 size_t * index, char ** result)
5605 {
5606 size_t cur_token;
5607 size_t begin;
5608 char ch;
5609 char * no_fold_quote;
5610 int r;
5611 int res;
5612
5613 begin = cur_token;
5614 r = mailimf_dquote_parse(message, length, &cur_token);
5615 if (r != MAILIMF_NO_ERROR) {
5616 res = r;
5617 goto err;
5618 }
5619
5620 while (1) {
5621 r = mailimf_no_fold_quote_char_parse(message, length, &cur_token, &ch);
5622 if (r == MAILIMF_NO_ERROR) {
5623 /* do nothing */
5624 }
5625 else if (r == MAILIMF_ERROR_PARSE)
5626 break;
5627 else {
5628 res = r;
5629 goto err;
5630 }
5631 }
5632
5633 r = mailimf_dquote_parse(message, length, &cur_token);
5634 if (r != MAILIMF_NO_ERROR) {
5635 res = r;
5636 goto err;
5637 }
5638
5639 /* no_fold_quote = strndup(message + begin, cur_token - begin); */
5640 no_fold_quote = malloc(cur_token - begin + 1);
5641 if (no_fold_quote == NULL) {
5642 res = MAILIMF_ERROR_MEMORY;
5643 goto err;
5644 }
5645 strncpy(no_fold_quote, message + begin, cur_token - begin);
5646 no_fold_quote[cur_token - begin] = '\0';
5647
5648 * result = no_fold_quote;
5649 * index = cur_token;
5650
5651 return MAILIMF_NO_ERROR;
5652
5653 err:
5654 return res;
5655 }
5656 #endif
5657
5658 /*
5659 no-fold-literal = "[" *(dtext / quoted-pair) "]"
5660 */
5661
5662 #if 0
5663 static inline int
5664 mailimf_no_fold_literal_char_parse(const char * message, size_t length,
5665 size_t * index, char * result)
5666 {
5667 char ch;
5668 size_t cur_token;
5669 int r;
5670
5671 cur_token = * index;
5672
5673 #if 0
5674 r = mailimf_dtext_parse(message, length, &cur_token, &ch);
5675 #endif
5676 if (cur_token >= length)
5677 return MAILIMF_ERROR_PARSE;
5678
5679 if (is_dtext(message[cur_token])) {
5680 ch = message[cur_token];
5681 cur_token ++;
5682 }
5683 else {
5684 r = mailimf_quoted_pair_parse(message, length, &cur_token, &ch);
5685
5686 if (r != MAILIMF_NO_ERROR)
5687 return r;
5688 }
5689
5690 * index = cur_token;
5691 * result = ch;
5692
5693 return MAILIMF_NO_ERROR;
5694 }
5695 #endif
5696
5697 #if 0
5698 static int mailimf_no_fold_literal_parse(const char * message, size_t length,
5699 size_t * index, char ** result)
5700 {
5701 size_t cur_token;
5702 size_t begin;
5703 char ch;
5704 char * no_fold_literal;
5705 int r;
5706 int res;
5707
5708 begin = cur_token;
5709 r = mailimf_obracket_parse(message, length, &cur_token);
5710 if (r != MAILIMF_NO_ERROR) {
5711 res = r;
5712 goto err;
5713 }
5714
5715 while (1) {
5716 r = mailimf_no_fold_literal_char_parse(message, length,
5717 &cur_token, &ch);
5718 if (r == MAILIMF_NO_ERROR) {
5719 /* do nothing */
5720 }
5721 else if (r == MAILIMF_ERROR_PARSE)
5722 break;
5723 else {
5724 res = r;
5725 goto err;
5726 }
5727 }
5728
5729 r = mailimf_cbracket_parse(message, length, &cur_token);
5730 if (r != MAILIMF_NO_ERROR) {
5731 res = r;
5732 goto err;
5733 }
5734
5735 /*
5736 no_fold_literal = strndup(message + begin, cur_token - begin);
5737 */
5738 no_fold_literal = malloc(cur_token - begin + 1);
5739 if (no_fold_literal == NULL) {
5740 res = MAILIMF_NO_ERROR;
5741 goto err;
5742 }
5743 strncpy(no_fold_literal, message + begin, cur_token - begin);
5744 no_fold_literal[cur_token - begin] = '\0';
5745
5746 * result = no_fold_literal;
5747 * index = cur_token;
5748
5749 return MAILIMF_NO_ERROR;
5750
5751 err:
5752 return res;
5753 }
5754 #endif
5755
5756 /*
5757 subject = "Subject:" unstructured CRLF
5758 */
5759
5760 static int mailimf_subject_parse(const char * message, size_t length,
5761 size_t * index,
5762 struct mailimf_subject ** result)
5763 {
5764 struct mailimf_subject * subject;
5765 char * value;
5766 size_t cur_token;
5767 int r;
5768 int res;
5769
5770 cur_token = * index;
5771
5772 r = mailimf_token_case_insensitive_parse(message, length,
5773 &cur_token, "Subject");
5774 if (r != MAILIMF_NO_ERROR) {
5775 res = r;
5776 goto err;
5777 }
5778
5779 r = mailimf_colon_parse(message, length, &cur_token);
5780 if (r != MAILIMF_NO_ERROR) {
5781 res = r;
5782 goto err;
5783 }
5784
5785 r = mailimf_unstructured_parse(message, length, &cur_token, &value);
5786 if (r != MAILIMF_NO_ERROR) {
5787 res = r;
5788 goto err;
5789 }
5790
5791 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5792 if (r != MAILIMF_NO_ERROR) {
5793 res = r;
5794 goto free_value;
5795 }
5796
5797 subject = mailimf_subject_new(value);
5798 if (subject == NULL) {
5799 res = MAILIMF_ERROR_MEMORY;
5800 goto free_value;
5801 }
5802
5803 * result = subject;
5804 * index = cur_token;
5805
5806 return MAILIMF_NO_ERROR;
5807
5808 free_value:
5809 mailimf_unstructured_free(value);
5810 err:
5811 return res;
5812 }
5813
5814 /*
5815 comments = "Comments:" unstructured CRLF
5816 */
5817
5818 static int mailimf_comments_parse(const char * message, size_t length,
5819 size_t * index,
5820 struct mailimf_comments ** result)
5821 {
5822 struct mailimf_comments * comments;
5823 char * value;
5824 size_t cur_token;
5825 int r;
5826 int res;
5827
5828 cur_token = * index;
5829
5830 r = mailimf_token_case_insensitive_parse(message, length,
5831 &cur_token, "Comments");
5832 if (r != MAILIMF_NO_ERROR) {
5833 res = r;
5834 goto err;
5835 }
5836
5837 r = mailimf_colon_parse(message, length, &cur_token);
5838 if (r != MAILIMF_NO_ERROR) {
5839 res = r;
5840 goto err;
5841 }
5842
5843 r = mailimf_unstructured_parse(message, length, &cur_token, &value);
5844 if (r != MAILIMF_NO_ERROR) {
5845 res = r;
5846 goto err;
5847 }
5848
5849 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5850 if (r != MAILIMF_NO_ERROR) {
5851 res = r;
5852 goto free_value;
5853 }
5854
5855 comments = mailimf_comments_new(value);
5856 if (comments == NULL) {
5857 res = MAILIMF_ERROR_MEMORY;
5858 goto free_value;
5859 }
5860
5861 * result = comments;
5862 * index = cur_token;
5863
5864 return MAILIMF_NO_ERROR;
5865
5866 free_value:
5867 mailimf_unstructured_free(value);
5868 err:
5869 return res;
5870 }
5871
5872 /*
5873 keywords = "Keywords:" phrase *("," phrase) CRLF
5874 */
5875
5876 static int mailimf_keywords_parse(const char * message, size_t length,
5877 size_t * index,
5878 struct mailimf_keywords ** result)
5879 {
5880 struct mailimf_keywords * keywords;
5881 clist * list;
5882 size_t cur_token;
5883 int r;
5884 int res;
5885
5886 cur_token = * index;
5887
5888 r = mailimf_token_case_insensitive_parse(message, length,
5889 &cur_token, "Keywords");
5890 if (r != MAILIMF_NO_ERROR) {
5891 res = r;
5892 goto err;
5893 }
5894
5895 r = mailimf_colon_parse(message, length, &cur_token);
5896 if (r != MAILIMF_NO_ERROR) {
5897 res = r;
5898 goto err;
5899 }
5900
5901 r = mailimf_struct_list_parse(message, length, &cur_token,
5902 &list, ',',
5903 (mailimf_struct_parser *)
5904 mailimf_phrase_parse,
5905 (mailimf_struct_destructor *)
5906 mailimf_phrase_free);
5907 if (r != MAILIMF_NO_ERROR) {
5908 res = r;
5909 goto err;
5910 }
5911
5912 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5913 if (r != MAILIMF_NO_ERROR) {
5914 res = r;
5915 goto free_list;
5916 }
5917
5918 keywords = mailimf_keywords_new(list);
5919 if (keywords == NULL) {
5920 res = MAILIMF_ERROR_MEMORY;
5921 goto free_list;
5922 }
5923
5924 * result = keywords;
5925 * index = cur_token;
5926
5927 return MAILIMF_NO_ERROR;
5928
5929 free_list:
5930 clist_foreach(list, (clist_func) mailimf_phrase_free, NULL);
5931 clist_free(list);
5932 err:
5933 return res;
5934 }
5935
5936 /*
5937 resent-date = "Resent-Date:" date-time CRLF
5938 */
5939
5940 static int
5941 mailimf_resent_date_parse(const char * message, size_t length,
5942 size_t * index, struct mailimf_orig_date ** result)
5943 {
5944 struct mailimf_orig_date * orig_date;
5945 struct mailimf_date_time * date_time;
5946 size_t cur_token;
5947 int r;
5948 int res;
5949
5950 cur_token = * index;
5951
5952 r = mailimf_token_case_insensitive_parse(message, length,
5953 &cur_token, "Resent-Date");
5954 if (r != MAILIMF_NO_ERROR) {
5955 res = r;
5956 goto err;
5957 }
5958
5959 r = mailimf_colon_parse(message, length, &cur_token);
5960 if (r != MAILIMF_NO_ERROR) {
5961 res = r;
5962 goto err;
5963 }
5964
5965 r = mailimf_date_time_parse(message, length, &cur_token, &date_time);
5966 if (r != MAILIMF_NO_ERROR) {
5967 res = r;
5968 goto err;
5969 }
5970
5971 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
5972 if (r != MAILIMF_NO_ERROR) {
5973 res = r;
5974 goto free_date_time;
5975 }
5976
5977 orig_date = mailimf_orig_date_new(date_time);
5978 if (orig_date == NULL) {
5979 res = MAILIMF_ERROR_MEMORY;
5980 goto free_date_time;
5981 }
5982
5983 * result = orig_date;
5984 * index = cur_token;
5985
5986 return MAILIMF_NO_ERROR;
5987
5988 free_date_time:
5989 mailimf_date_time_free(date_time);
5990 err:
5991 return res;
5992 }
5993
5994 /*
5995 resent-from = "Resent-From:" mailbox-list CRLF
5996 */
5997
5998 static int
5999 mailimf_resent_from_parse(const char * message, size_t length,
6000 size_t * index, struct mailimf_from ** result)
6001 {
6002 struct mailimf_mailbox_list * mb_list;
6003 struct mailimf_from * from;
6004 size_t cur_token;
6005 int r;
6006 int res;
6007
6008 cur_token = * index;
6009
6010 r = mailimf_token_case_insensitive_parse(message, length,
6011 &cur_token, "Resent-From");
6012 if (r != MAILIMF_NO_ERROR) {
6013 res = r;
6014 goto err;
6015 }
6016
6017 r = mailimf_colon_parse(message, length, &cur_token);
6018 if (r != MAILIMF_NO_ERROR) {
6019 res = r;
6020 goto err;
6021 }
6022
6023 r = mailimf_mailbox_list_parse(message, length, &cur_token, &mb_list);
6024 if (r != MAILIMF_NO_ERROR) {
6025 res = r;
6026 goto err;
6027 }
6028
6029 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6030 if (r != MAILIMF_NO_ERROR) {
6031 res = r;
6032 goto free_mb_list;
6033 }
6034
6035 from = mailimf_from_new(mb_list);
6036 if (from == NULL) {
6037 res = MAILIMF_ERROR_MEMORY;
6038 goto free_mb_list;
6039 }
6040
6041 * result = from;
6042 * index = cur_token;
6043
6044 return MAILIMF_NO_ERROR;
6045
6046 free_mb_list:
6047 mailimf_mailbox_list_free(mb_list);
6048 err:
6049 return res;
6050 }
6051
6052 /*
6053 resent-sender = "Resent-Sender:" mailbox CRLF
6054 */
6055
6056 static int
6057 mailimf_resent_sender_parse(const char * message, size_t length,
6058 size_t * index, struct mailimf_sender ** result)
6059 {
6060 struct mailimf_mailbox * mb;
6061 struct mailimf_sender * sender;
6062 size_t cur_token;
6063 int r;
6064 int res;
6065
6066 cur_token = length;
6067
6068 r = mailimf_token_case_insensitive_parse(message, length,
6069 &cur_token, "Resent-Sender");
6070 if (r != MAILIMF_NO_ERROR) {
6071 res = r;
6072 goto err;
6073 }
6074
6075 r = mailimf_colon_parse(message, length, &cur_token);
6076 if (r != MAILIMF_NO_ERROR) {
6077 res = r;
6078 goto err;
6079 }
6080
6081 r = mailimf_mailbox_parse(message, length, &cur_token, &mb);
6082 if (r != MAILIMF_NO_ERROR) {
6083 res = r;
6084 goto err;
6085 }
6086
6087 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6088 if (r != MAILIMF_NO_ERROR) {
6089 res = r;
6090 goto free_mb;
6091 }
6092
6093 sender = mailimf_sender_new(mb);
6094 if (sender == NULL) {
6095 res = MAILIMF_ERROR_MEMORY;
6096 goto free_mb;
6097 }
6098
6099 * result = sender;
6100 * index = cur_token;
6101
6102 return MAILIMF_NO_ERROR;
6103
6104 free_mb:
6105 mailimf_mailbox_free(mb);
6106 err:
6107 return res;
6108 }
6109
6110 /*
6111 resent-to = "Resent-To:" address-list CRLF
6112 */
6113
6114 static int
6115 mailimf_resent_to_parse(const char * message, size_t length,
6116 size_t * index, struct mailimf_to ** result)
6117 {
6118 struct mailimf_address_list * addr_list;
6119 struct mailimf_to * to;
6120 size_t cur_token;
6121 int r;
6122 int res;
6123
6124 cur_token = * index;
6125
6126 r = mailimf_token_case_insensitive_parse(message, length,
6127 &cur_token, "Resent-To");
6128 if (r != MAILIMF_NO_ERROR) {
6129 res = r;
6130 goto err;
6131 }
6132
6133 r = mailimf_colon_parse(message, length, &cur_token);
6134 if (r != MAILIMF_NO_ERROR) {
6135 res = r;
6136 goto err;
6137 }
6138
6139 r = mailimf_address_list_parse(message, length, &cur_token, &addr_list);
6140 if (r != MAILIMF_NO_ERROR) {
6141 res = r;
6142 goto err;
6143 }
6144
6145 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6146 if (r != MAILIMF_NO_ERROR) {
6147 res = r;
6148 goto free_addr_list;
6149 }
6150
6151 to = mailimf_to_new(addr_list);
6152 if (to == NULL) {
6153 res = MAILIMF_ERROR_MEMORY;
6154 goto free_addr_list;
6155 }
6156
6157 * result = to;
6158 * index = cur_token;
6159
6160 return MAILIMF_NO_ERROR;
6161
6162 free_addr_list:
6163 mailimf_address_list_free(addr_list);
6164 err:
6165 return res;
6166 }
6167
6168 /*
6169 resent-cc = "Resent-Cc:" address-list CRLF
6170 */
6171
6172 static int
6173 mailimf_resent_cc_parse(const char * message, size_t length,
6174 size_t * index, struct mailimf_cc ** result)
6175 {
6176 struct mailimf_address_list * addr_list;
6177 struct mailimf_cc * cc;
6178 size_t cur_token;
6179 int r;
6180 int res;
6181
6182 cur_token = * index;
6183
6184 r = mailimf_token_case_insensitive_parse(message, length,
6185 &cur_token, "Resent-Cc");
6186 if (r != MAILIMF_NO_ERROR) {
6187 res = r;
6188 goto err;
6189 }
6190
6191 r = mailimf_colon_parse(message, length, &cur_token);
6192 if (r != MAILIMF_NO_ERROR) {
6193 res = r;
6194 goto err;
6195 }
6196
6197 r = mailimf_address_list_parse(message, length, &cur_token, &addr_list);
6198 if (r != MAILIMF_NO_ERROR) {
6199 res = r;
6200 goto err;
6201 }
6202
6203 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6204 if (r != MAILIMF_NO_ERROR) {
6205 res = r;
6206 goto free_addr_list;
6207 }
6208
6209 cc = mailimf_cc_new(addr_list);
6210 if (cc == NULL) {
6211 res = MAILIMF_ERROR_MEMORY;
6212 goto free_addr_list;
6213 }
6214
6215 * result = cc;
6216 * index = cur_token;
6217
6218 return MAILIMF_NO_ERROR;
6219
6220 free_addr_list:
6221 mailimf_address_list_free(addr_list);
6222 err:
6223 return res;
6224 }
6225
6226 /*
6227 resent-bcc = "Resent-Bcc:" (address-list / [CFWS]) CRLF
6228 */
6229
6230 static int
6231 mailimf_resent_bcc_parse(const char * message, size_t length,
6232 size_t * index, struct mailimf_bcc ** result)
6233 {
6234 struct mailimf_address_list * addr_list;
6235 struct mailimf_bcc * bcc;
6236 size_t cur_token;
6237 int r;
6238 int res;
6239
6240 cur_token = * index;
6241 bcc = NULL;
6242
6243 r = mailimf_token_case_insensitive_parse(message, length,
6244 &cur_token, "Resent-Bcc");
6245 if (r != MAILIMF_NO_ERROR) {
6246 res = r;
6247 goto err;
6248 }
6249
6250 r = mailimf_colon_parse(message, length, &cur_token);
6251 if (r != MAILIMF_NO_ERROR) {
6252 res = r;
6253 goto err;
6254 }
6255
6256 r = mailimf_address_list_parse(message, length, &cur_token, &addr_list);
6257 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
6258 res = r;
6259 goto err;
6260 }
6261
6262 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6263 if (r != MAILIMF_NO_ERROR) {
6264 res = r;
6265 goto free_addr_list;
6266 }
6267
6268 bcc = mailimf_bcc_new(addr_list);
6269 if (bcc == NULL) {
6270 res = MAILIMF_ERROR_MEMORY;
6271 goto free_addr_list;
6272 }
6273
6274 * result = bcc;
6275 * index = cur_token;
6276
6277 return TRUE;
6278
6279 free_addr_list:
6280 mailimf_address_list_free(addr_list);
6281 err:
6282 return res;
6283 }
6284
6285 /*
6286 resent-msg-id = "Resent-Message-ID:" msg-id CRLF
6287 */
6288
6289 static int
6290 mailimf_resent_msg_id_parse(const char * message, size_t length,
6291 size_t * index,
6292 struct mailimf_message_id ** result)
6293 {
6294 char * value;
6295 size_t cur_token;
6296 struct mailimf_message_id * message_id;
6297 int r;
6298 int res;
6299
6300 cur_token = * index;
6301
6302 r = mailimf_token_case_insensitive_parse(message, length,
6303 &cur_token, "Resent-Message-ID");
6304 if (r != MAILIMF_NO_ERROR) {
6305 res = r;
6306 goto err;
6307 }
6308
6309 r = mailimf_colon_parse(message, length, &cur_token);
6310 if (r != MAILIMF_NO_ERROR) {
6311 res = r;
6312 goto err;
6313 }
6314
6315 r = mailimf_msg_id_parse(message, length, &cur_token, &value);
6316 if (r != MAILIMF_NO_ERROR) {
6317 res = r;
6318 goto err;
6319 }
6320
6321 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6322 if (r != MAILIMF_NO_ERROR) {
6323 res = r;
6324 goto free_value;
6325 }
6326
6327 message_id = mailimf_message_id_new(value);
6328 if (message_id == NULL) {
6329 res = MAILIMF_ERROR_MEMORY;
6330 goto free_value;
6331 }
6332
6333 * result = message_id;
6334 * index = cur_token;
6335
6336 return MAILIMF_NO_ERROR;
6337
6338 free_value:
6339 mailimf_msg_id_free(value);
6340 err:
6341 return res;
6342 }
6343
6344 /*
6345 trace = [return]
6346 1*received
6347 */
6348
6349 #if 0
6350 static int mailimf_trace_parse(const char * message, size_t length,
6351 size_t * index,
6352 struct mailimf_trace ** result)
6353 {
6354 size_t cur_token;
6355 struct mailimf_return * return_path;
6356 clist * received_list;
6357 struct mailimf_trace * trace;
6358 int r;
6359 int res;
6360
6361 cur_token = * index;
6362 return_path = NULL;
6363 received_list = NULL;
6364
6365 r = mailimf_return_parse(message, length, &cur_token, &return_path);
6366 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
6367 res = r;
6368 goto err;
6369 }
6370
6371 r = mailimf_struct_multiple_parse(message, length, &cur_token,
6372 &received_list,
6373 (mailimf_struct_parser *)
6374 mailimf_received_parse,
6375 (mailimf_struct_destructor *)
6376 mailimf_received_free);
6377 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
6378 res = r;
6379 goto err;
6380 }
6381
6382 if ((received_list == NULL) && (return_path == NULL)) {
6383 res = MAILIMF_ERROR_PARSE;
6384 goto free_return;
6385 }
6386
6387 trace = mailimf_trace_new(return_path, received_list);
6388 if (trace == NULL) {
6389 res = MAILIMF_ERROR_MEMORY;
6390 goto free_list;
6391 }
6392
6393 * result = trace;
6394 * index = cur_token;
6395
6396 return MAILIMF_NO_ERROR;
6397
6398 free_list:
6399 clist_foreach(received_list, (clist_func) mailimf_received_free, NULL);
6400 clist_free(received_list);
6401 free_return:
6402 if (return_path != NULL)
6403 mailimf_return_free(return_path);
6404 err:
6405 return res;
6406 }
6407 #endif
6408
6409 /*
6410 return = "Return-Path:" path CRLF
6411 */
6412
6413 static int mailimf_return_parse(const char * message, size_t length,
6414 size_t * index,
6415 struct mailimf_return ** result)
6416 {
6417 struct mailimf_path * path = NULL;
6418 struct mailimf_return * return_path;
6419 size_t cur_token;
6420 int r;
6421 int res;
6422
6423 cur_token = * index;
6424
6425 r = mailimf_token_case_insensitive_parse(message, length,
6426 &cur_token, "Return-Path");
6427 if (r != MAILIMF_NO_ERROR) {
6428 res = r;
6429 goto err;
6430 }
6431
6432 r = mailimf_colon_parse(message, length, &cur_token);
6433 if (r != MAILIMF_NO_ERROR) {
6434 res = r;
6435 goto err;
6436 }
6437
6438 r = mailimf_path_parse(message, length, &cur_token, &path);
6439 if ( r!= MAILIMF_NO_ERROR) {
6440 res = r;
6441 goto err;
6442 }
6443
6444 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6445 if (r != MAILIMF_NO_ERROR) {
6446 res = r;
6447 goto free_path;
6448 }
6449
6450 return_path = mailimf_return_new(path);
6451 if (return_path == NULL) {
6452 res = MAILIMF_ERROR_MEMORY;
6453 goto free_path;
6454 }
6455
6456 * result = return_path;
6457 * index = cur_token;
6458
6459 return MAILIMF_NO_ERROR;
6460
6461 free_path:
6462 mailimf_path_free(path);
6463 err:
6464 return res;
6465 }
6466
6467 /*
6468 path = ([CFWS] "<" ([CFWS] / addr-spec) ">" [CFWS]) /
6469 obs-path
6470 */
6471
6472 static int mailimf_path_parse(const char * message, size_t length,
6473 size_t * index, struct mailimf_path ** result)
6474 {
6475 size_t cur_token;
6476 char * addr_spec;
6477 struct mailimf_path * path;
6478 int res;
6479 int r;
6480
6481 cur_token = * index;
6482 addr_spec = NULL;
6483
6484 r = mailimf_cfws_parse(message, length, &cur_token);
6485 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
6486 res = r;
6487 goto err;
6488 }
6489
6490 r = mailimf_lower_parse(message, length, &cur_token);
6491 if (r != MAILIMF_NO_ERROR) {
6492 res = r;
6493 goto err;
6494 }
6495
6496 r = mailimf_addr_spec_parse(message, length, &cur_token, &addr_spec);
6497 switch (r) {
6498 case MAILIMF_NO_ERROR:
6499 break;
6500 case MAILIMF_ERROR_PARSE:
6501 r = mailimf_cfws_parse(message, length, &cur_token);
6502 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
6503 res = r;
6504 goto err;
6505 }
6506 break;
6507 default:
6508 return r;
6509 }
6510
6511 r = mailimf_greater_parse(message, length, &cur_token);
6512 if (r != MAILIMF_NO_ERROR) {
6513 res = r;
6514 goto free_addr_spec;
6515 }
6516
6517 path = mailimf_path_new(addr_spec);
6518 if (path == NULL) {
6519 res = MAILIMF_ERROR_MEMORY;
6520 goto free_addr_spec;
6521 }
6522
6523 * index = cur_token;
6524 * result = path;
6525
6526 return MAILIMF_NO_ERROR;
6527
6528 free_addr_spec:
6529 if (addr_spec != NULL)
6530 mailimf_addr_spec_free(addr_spec);
6531 err:
6532 return res;
6533 }
6534
6535 /*
6536 received = "Received:" name-val-list ";" date-time CRLF
6537 */
6538
6539 #if 0
6540 static int mailimf_received_parse(const char * message, size_t length,
6541 size_t * index,
6542 struct mailimf_received ** result)
6543 {
6544 size_t cur_token;
6545 struct mailimf_received * received;
6546 struct mailimf_name_val_list * name_val_list;
6547 struct mailimf_date_time * date_time;
6548 int r;
6549 int res;
6550
6551 cur_token = * index;
6552
6553 r = mailimf_token_case_insensitive_parse(message, length,
6554 &cur_token, "Received");
6555 if (r != MAILIMF_NO_ERROR) {
6556 res = r;
6557 goto err;
6558 }
6559
6560 r = mailimf_colon_parse(message, length, &cur_token);
6561 if (r != MAILIMF_NO_ERROR) {
6562 res = r;
6563 goto err;
6564 }
6565
6566 r = mailimf_name_val_list_parse(message, length,
6567 &cur_token, &name_val_list);
6568 if (r != MAILIMF_NO_ERROR) {
6569 res = r;
6570 goto err;
6571 }
6572
6573 r = mailimf_semi_colon_parse(message, length, &cur_token);
6574 if (r != MAILIMF_NO_ERROR) {
6575 res = r;
6576 goto free_name_val_list;
6577 }
6578
6579 r = mailimf_date_time_parse(message, length, &cur_token, &date_time);
6580 if (r != MAILIMF_NO_ERROR) {
6581 res = r;
6582 goto free_name_val_list;
6583 }
6584
6585 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
6586 if (r != MAILIMF_NO_ERROR) {
6587 res = r;
6588 goto free_date_time;
6589 }
6590
6591 received = mailimf_received_new(name_val_list, date_time);
6592 if (received == NULL) {
6593 res = MAILIMF_ERROR_MEMORY;
6594 goto free_date_time;
6595 }
6596
6597 * index = cur_token;
6598 * result = received;
6599
6600 return MAILIMF_NO_ERROR;
6601
6602 free_date_time:
6603 mailimf_date_time_free(date_time);
6604 free_name_val_list:
6605 mailimf_name_val_list_free(name_val_list);
6606 err:
6607 return res;
6608 }
6609 #endif
6610
6611 /*
6612 name-val-list = [CFWS] [name-val-pair *(CFWS name-val-pair)]
6613 */
6614
6615 #if 0
6616 static int
6617 mailimf_name_val_list_parse(const char * message, size_t length,
6618 size_t * index,
6619 struct mailimf_name_val_list ** result)
6620 {
6621 size_t cur_token;
6622 struct mailimf_name_val_pair * pair;
6623 struct mailimf_name_val_list * name_val_list;
6624 clist* list;
6625 int res;
6626 int r;
6627
6628 cur_token = * index;
6629 list = NULL;
6630
6631 r = mailimf_name_val_pair_parse(message, length, &cur_token, &pair);
6632
6633 if (r == MAILIMF_NO_ERROR){
6634 size_t final_token;
6635
6636 list = clist_new();
6637 if (list == NULL) {
6638 mailimf_name_val_pair_free(pair);
6639 res = MAILIMF_ERROR_MEMORY;
6640 goto err;
6641 }
6642
6643 r = clist_append(list, pair);
6644 if (r < 0) {
6645 mailimf_name_val_pair_free(pair);
6646 res = MAILIMF_ERROR_MEMORY;
6647 goto free_list;
6648 }
6649
6650 final_token = cur_token;
6651
6652 while (1) {
6653 r = mailimf_cfws_parse(message, length, &cur_token);
6654 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
6655 res = r;
6656 goto free_list;
6657 }
6658
6659 r = mailimf_name_val_pair_parse(message, length, &cur_token, &pair);
6660 if (r == MAILIMF_NO_ERROR) {
6661 /* do nothing */
6662 }
6663 else if (r == MAILIMF_ERROR_PARSE)
6664 break;
6665 else {
6666 res = r;
6667 goto free_list;
6668 }
6669
6670 r = clist_append(list, pair);
6671 if (r < 0) {
6672 mailimf_name_val_pair_free(pair);
6673 res = MAILIMF_ERROR_MEMORY;
6674 goto free_list;
6675 }
6676
6677 final_token = cur_token;
6678 }
6679 cur_token = final_token;
6680 }
6681
6682 name_val_list = mailimf_name_val_list_new(list);
6683 if (name_val_list == NULL) {
6684 res = MAILIMF_ERROR_MEMORY;
6685 goto free_list;
6686 }
6687
6688 * index = cur_token;
6689 * result = name_val_list;
6690
6691 return MAILIMF_NO_ERROR;
6692
6693 free_list:
6694 if (list != NULL) {
6695 clist_foreach(list, (clist_func) mailimf_name_val_pair_free, NULL);
6696 clist_free(list);
6697 }
6698 err:
6699 return res;
6700 }
6701 #endif
6702
6703 /*
6704 name-val-pair = item-name CFWS item-value
6705 */
6706
6707 #if 0
6708 static int
6709 mailimf_name_val_pair_parse(const char * message, size_t length,
6710 size_t * index,
6711 struct mailimf_name_val_pair ** result)
6712 {
6713 size_t cur_token;
6714 char * item_name;
6715 struct mailimf_item_value * item_value;
6716 struct mailimf_name_val_pair * name_val_pair;
6717 int r;
6718 int res;
6719
6720 cur_token = * index;
6721
6722 r = mailimf_cfws_parse(message, length, &cur_token);
6723 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE)) {
6724 res = r;
6725 goto err;
6726 }
6727
6728 r = mailimf_item_name_parse(message, length, &cur_token, &item_name);
6729 if (r != MAILIMF_NO_ERROR) {
6730 res = r;
6731 goto err;
6732 }
6733
6734 r = mailimf_cfws_parse(message, length, &cur_token);
6735 if (r != MAILIMF_NO_ERROR) {
6736 res = r;
6737 goto free_item_name;
6738 }
6739
6740 r = mailimf_item_value_parse(message, length, &cur_token, &item_value);
6741 if (r != MAILIMF_NO_ERROR) {
6742 res = r;
6743 goto free_item_name;
6744 }
6745
6746 name_val_pair = mailimf_name_val_pair_new(item_name, item_value);
6747 if (name_val_pair == NULL) {
6748 res = MAILIMF_ERROR_MEMORY;
6749 goto free_item_value;
6750 }
6751
6752 * result = name_val_pair;
6753 * index = cur_token;
6754
6755 return MAILIMF_NO_ERROR;
6756
6757 free_item_value:
6758 mailimf_item_value_free(item_value);
6759 free_item_name:
6760 mailimf_item_name_free(item_name);
6761 err:
6762 return res;
6763 }
6764 #endif
6765
6766 /*
6767 item-name = ALPHA *(["-"] (ALPHA / DIGIT))
6768 */
6769
6770 #if 0
6771 static int mailimf_item_name_parse(const char * message, size_t length,
6772 size_t * index, char ** result)
6773 {
6774 size_t cur_token;
6775 size_t begin;
6776 char * item_name;
6777 char ch;
6778 int digit;
6779 int r;
6780 int res;
6781
6782 cur_token = * index;
6783
6784 begin = cur_token;
6785
6786 r = mailimf_alpha_parse(message, length, &cur_token, &ch);
6787 if (r != MAILIMF_NO_ERROR) {
6788 res = r;
6789 goto err;
6790 }
6791
6792 while (1) {
6793 int minus_sign;
6794
6795 minus_sign = mailimf_minus_parse(message, length, &cur_token);
6796
6797 r = mailimf_alpha_parse(message, length, &cur_token, &ch);
6798 if (r == MAILIMF_ERROR_PARSE)
6799 r = mailimf_digit_parse(message, length, &cur_token, &digit);
6800
6801 if (r == MAILIMF_NO_ERROR) {
6802 /* do nothing */
6803 }
6804 if (r == MAILIMF_ERROR_PARSE)
6805 break;
6806 else if (r != MAILIMF_NO_ERROR) {
6807 res = r;
6808 goto err;
6809 }
6810 }
6811
6812 item_name = strndup(message + begin, cur_token - begin);
6813 if (item_name == NULL) {
6814 res = MAILIMF_ERROR_MEMORY;
6815 goto err;
6816 }
6817
6818 * index = cur_token;
6819 * result = item_name;
6820
6821 return MAILIMF_NO_ERROR;
6822
6823 err:
6824 return res;
6825 }
6826 #endif
6827
6828 /*
6829 item-value = 1*angle-addr / addr-spec /
6830 atom / domain / msg-id
6831 */
6832
6833 #if 0
6834 static int is_item_value_atext(char ch)
6835 {
6836 switch (ch) {
6837 case '\t':
6838 case ' ':
6839 case '\r':
6840 case '\n':
6841 case ';':
6842 return FALSE;
6843 default:
6844 return TRUE;
6845 }
6846 }
6847
6848 static int mailimf_item_value_atom_parse(const char * message, size_t length,
6849 size_t * index, char ** result)
6850 {
6851 char * atom;
6852 size_t cur_token;
6853 int r;
6854
6855 cur_token = * index;
6856
6857 r = mailimf_cfws_parse(message, length, &cur_token);
6858 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
6859 return r;
6860
6861 r = mailimf_custom_string_parse(message, length, &cur_token,
6862 &atom, is_item_value_atext);
6863 if (r != MAILIMF_NO_ERROR)
6864 return r;
6865
6866 r = mailimf_cfws_parse(message, length, &cur_token);
6867 if ((r != MAILIMF_NO_ERROR) && (r != MAILIMF_ERROR_PARSE))
6868 return r;
6869
6870 * index = cur_token;
6871 * result = atom;
6872
6873 return MAILIMF_NO_ERROR;
6874 }
6875
6876 static int mailimf_item_value_parse(const char * message, size_t length,
6877 size_t * index,
6878 struct mailimf_item_value ** result)
6879 {
6880 size_t cur_token;
6881 clist * angle_addr_list;
6882 char * addr_spec;
6883 char * atom;
6884 char * domain;
6885 char * msg_id;
6886 int type;
6887 struct mailimf_item_value * item_value;
6888 int r;
6889 int res;
6890
6891 cur_token = * index;
6892
6893 angle_addr_list = NULL;
6894 addr_spec = NULL;
6895 atom = NULL;
6896 domain = NULL;
6897 msg_id = NULL;
6898
6899 r = mailimf_struct_multiple_parse(message, length, &cur_token,
6900 &angle_addr_list,
6901 (mailimf_struct_parser *)
6902 mailimf_angle_addr_parse,
6903 (mailimf_struct_destructor *)
6904 mailimf_angle_addr_free);
6905 if (r == MAILIMF_NO_ERROR)
6906 type = MAILIMF_ITEM_VALUE_ANGLE_ADDR_LIST;
6907
6908 if (r == MAILIMF_ERROR_PARSE) {
6909 r = mailimf_addr_spec_parse(message, length, &cur_token,
6910 &addr_spec);
6911 if (r == MAILIMF_NO_ERROR)
6912 type = MAILIMF_ITEM_VALUE_ADDR_SPEC;
6913 }
6914
6915 if (r == MAILIMF_ERROR_PARSE) {
6916 r = mailimf_msg_id_parse(message, length, &cur_token,
6917 &msg_id);
6918 if (r == MAILIMF_NO_ERROR)
6919 type = MAILIMF_ITEM_VALUE_MSG_ID;
6920 }
6921
6922 /*
6923 else if (mailimf_domain_parse(message, length, &cur_token,
6924 &domain))
6925 type = MAILIMF_ITEM_VALUE_DOMAIN;
6926 */
6927 /*
6928 else if (mailimf_atom_parse(message, length, &cur_token,
6929 &atom))
6930 type = MAILIMF_ITEM_VALUE_ATOM;
6931 */
6932
6933 if (r == MAILIMF_ERROR_PARSE) {
6934 r = mailimf_item_value_atom_parse(message, length, &cur_token,
6935 &atom);
6936 if (r == MAILIMF_NO_ERROR)
6937 type = MAILIMF_ITEM_VALUE_ATOM;
6938 }
6939
6940 if (r != MAILIMF_NO_ERROR) {
6941 res = r;
6942 goto err;
6943 }
6944
6945 item_value = mailimf_item_value_new(type, angle_addr_list, addr_spec,
6946 atom, domain, msg_id);
6947 if (item_value == NULL) {
6948 res = MAILIMF_ERROR_MEMORY;
6949 goto free;
6950 }
6951
6952 * result = item_value;
6953 * index = cur_token;
6954
6955 return MAILIMF_NO_ERROR;
6956
6957 free:
6958 if (angle_addr_list != NULL) {
6959 clist_foreach(angle_addr_list, (clist_func) mailimf_angle_addr_free, NULL);
6960 clist_free(angle_addr_list);
6961 }
6962 if (addr_spec != NULL)
6963 mailimf_addr_spec_free(addr_spec);
6964 if (atom != NULL)
6965 mailimf_atom_free(atom);
6966 if (domain != NULL)
6967 mailimf_domain_free(domain);
6968 if (msg_id != NULL)
6969 mailimf_msg_id_free(msg_id);
6970 err:
6971 return res;
6972 }
6973 #endif
6974
6975 /*
6976 optional-field = field-name ":" unstructured CRLF
6977 */
6978
6979 static int
6980 mailimf_optional_field_parse(const char * message, size_t length,
6981 size_t * index,
6982 struct mailimf_optional_field ** result)
6983 {
6984 char * name;
6985 char * value;
6986 struct mailimf_optional_field * optional_field;
6987 size_t cur_token;
6988 int r;
6989 int res;
6990
6991 name = NULL;
6992 value = NULL;
6993 optional_field = NULL;
6994
6995 cur_token = * index;
6996
6997 r = mailimf_field_name_parse(message, length, &cur_token, &name);
6998 if (r != MAILIMF_NO_ERROR) {
6999 res = r;
7000 goto err;
7001 }
7002
7003 r = mailimf_colon_parse(message, length, &cur_token);
7004 if (r != MAILIMF_NO_ERROR) {
7005 res = r;
7006 goto free_fields;
7007 }
7008
7009 r = mailimf_unstructured_parse(message, length, &cur_token, &value);
7010 if (r != MAILIMF_NO_ERROR) {
7011 res = r;
7012 goto free_fields;
7013 }
7014
7015 r = mailimf_unstrict_crlf_parse(message, length, &cur_token);
7016 if (r != MAILIMF_NO_ERROR) {
7017 res = r;
7018 goto free_fields;
7019 }
7020
7021 optional_field = mailimf_optional_field_new(name, value);
7022 if (optional_field == NULL) {
7023 res = MAILIMF_ERROR_MEMORY;
7024 goto free_fields;
7025 }
7026
7027 * result = optional_field;
7028 * index = cur_token;
7029
7030 return MAILIMF_NO_ERROR;
7031
7032 free_fields:
7033 if (value)
7034 mailimf_unstructured_free(value);
7035 if (name)
7036 mailimf_field_name_free(name);
7037
7038 err:
7039 return res;
7040 }
7041
7042 /*
7043 field-name = 1*ftext
7044 */
7045
7046 static inline int is_ftext(char ch);
7047
7048 static int mailimf_field_name_parse(const char * message, size_t length,
7049 size_t * index, char ** result)
7050 {
7051 char * field_name;
7052 size_t cur_token;
7053 size_t end;
7054
7055 cur_token = * index;
7056
7057 end = cur_token;
7058 if (end >= length) {
7059 return MAILIMF_ERROR_PARSE;
7060 }
7061
7062 while (is_ftext(message[end])) {
7063 end ++;
7064 if (end >= length)
7065 break;
7066 }
7067 if (end == cur_token) {
7068 return MAILIMF_ERROR_PARSE;
7069 }
7070
7071 /* field_name = strndup(message + cur_token, end - cur_token); */
7072 field_name = malloc(end - cur_token + 1);
7073 if (field_name == NULL) {
7074 return MAILIMF_ERROR_MEMORY;
7075 }
7076 strncpy(field_name, message + cur_token, end - cur_token);
7077 field_name[end - cur_token] = '\0';
7078
7079 cur_token = end;
7080
7081 * index = cur_token;
7082 * result = field_name;
7083
7084 return MAILIMF_NO_ERROR;
7085 }
7086
7087 /*
7088 ftext = %d33-57 / ; Any character except
7089 %d59-126 ; controls, SP, and
7090 ; ":".
7091 */
7092
7093 static inline int is_ftext(char ch)
7094 {
7095 unsigned char uch = (unsigned char) ch;
7096
7097 if (uch < 33)
7098 return FALSE;
7099
7100 if (uch == 58)
7101 return FALSE;
7102
7103 return TRUE;
7104 }
7105
7106 /*
7107 static int mailimf_ftext_parse(const char * message, size_t length,
7108 size_t * index, gchar * result)
7109 {
7110 return mailimf_typed_text_parse(message, length, index, result, is_ftext);
7111 }
7112 */
7113
7114
7115
7116
7117 static int mailimf_envelope_field_parse(const char * message, size_t length,
7118 size_t * index,
7119 struct mailimf_field ** result)
7120 {
7121 size_t cur_token;
7122 int type;
7123 struct mailimf_orig_date * orig_date;
7124 struct mailimf_from * from;
7125 struct mailimf_sender * sender;
7126 struct mailimf_reply_to * reply_to;
7127 struct mailimf_to * to;
7128 struct mailimf_cc * cc;
7129 struct mailimf_bcc * bcc;
7130 struct mailimf_message_id * message_id;
7131 struct mailimf_in_reply_to * in_reply_to;
7132 struct mailimf_references * references;
7133 struct mailimf_subject * subject;
7134 struct mailimf_field * field;
7135 int guessed_type;
7136 int r;
7137 int res;
7138
7139 cur_token = * index;
7140
7141 orig_date = NULL;
7142 from = NULL;
7143 sender = NULL;
7144 reply_to = NULL;
7145 to = NULL;
7146 cc = NULL;
7147 bcc = NULL;
7148 message_id = NULL;
7149 in_reply_to = NULL;
7150 references = NULL;
7151 subject = NULL;
7152
7153 guessed_type = guess_header_type(message, length, cur_token);
7154 type = MAILIMF_FIELD_NONE;
7155
7156 switch (guessed_type) {
7157 case MAILIMF_FIELD_ORIG_DATE:
7158 r = mailimf_orig_date_parse(message, length, &cur_token,
7159 &orig_date);
7160 if (r == MAILIMF_NO_ERROR)
7161 type = guessed_type;
7162 else if (r == MAILIMF_ERROR_PARSE) {
7163 /* do nothing */
7164 }
7165 else {
7166 res = r;
7167 goto err;
7168 }
7169 break;
7170 case MAILIMF_FIELD_FROM:
7171 r = mailimf_from_parse(message, length, &cur_token,
7172 &from);
7173 if (r == MAILIMF_NO_ERROR)
7174 type = guessed_type;
7175 else if (r == MAILIMF_ERROR_PARSE) {
7176 /* do nothing */
7177 }
7178 else {
7179 res = r;
7180 goto err;
7181 }
7182 break;
7183 case MAILIMF_FIELD_SENDER:
7184 r = mailimf_sender_parse(message, length, &cur_token,
7185 &sender);
7186 if (r == MAILIMF_NO_ERROR)
7187 type = guessed_type;
7188 else if (r == MAILIMF_ERROR_PARSE) {
7189 /* do nothing */
7190 }
7191 else {
7192 res = r;
7193 goto err;
7194 }
7195 break;
7196 case MAILIMF_FIELD_REPLY_TO:
7197 r = mailimf_reply_to_parse(message, length, &cur_token,
7198 &reply_to);
7199 if (r == MAILIMF_NO_ERROR)
7200 type = guessed_type;
7201 else if (r == MAILIMF_ERROR_PARSE) {
7202 /* do nothing */
7203 }
7204 else {
7205 res = r;
7206 goto err;
7207 }
7208 break;
7209 case MAILIMF_FIELD_TO:
7210 r = mailimf_to_parse(message, length, &cur_token,
7211 &to);
7212 if (r == MAILIMF_NO_ERROR)
7213 type = guessed_type;
7214 else if (r == MAILIMF_ERROR_PARSE) {
7215 /* do nothing */
7216 }
7217 else {
7218 res = r;
7219 goto err;
7220 }
7221 break;
7222 case MAILIMF_FIELD_CC:
7223 r = mailimf_cc_parse(message, length, &cur_token,
7224 &cc);
7225 if (r == MAILIMF_NO_ERROR)
7226 type = guessed_type;
7227 else if (r == MAILIMF_ERROR_PARSE) {
7228 /* do nothing */
7229 }
7230 else {
7231 res = r;
7232 goto err;
7233 }
7234 break;
7235 case MAILIMF_FIELD_BCC:
7236 r = mailimf_bcc_parse(message, length, &cur_token,
7237 &bcc);
7238 if (r == MAILIMF_NO_ERROR)
7239 type = guessed_type;
7240 else if (r == MAILIMF_ERROR_PARSE) {
7241 /* do nothing */
7242 }
7243 else {
7244 res = r;
7245 goto err;
7246 }
7247 break;
7248 case MAILIMF_FIELD_MESSAGE_ID:
7249 r = mailimf_message_id_parse(message, length, &cur_token,
7250 &message_id);
7251 if (r == MAILIMF_NO_ERROR)
7252 type = guessed_type;
7253 else if (r == MAILIMF_ERROR_PARSE) {
7254 /* do nothing */
7255 }
7256 else {
7257 res = r;
7258 goto err;
7259 }
7260 break;
7261 case MAILIMF_FIELD_IN_REPLY_TO:
7262 r = mailimf_in_reply_to_parse(message, length, &cur_token,
7263 &in_reply_to);
7264 if (r == MAILIMF_NO_ERROR)
7265 type = guessed_type;
7266 else if (r == MAILIMF_ERROR_PARSE) {
7267 /* do nothing */
7268 }
7269 else {
7270 res = r;
7271 goto err;
7272 }
7273 break;
7274 case MAILIMF_FIELD_REFERENCES:
7275 r = mailimf_references_parse(message, length, &cur_token,
7276 &references);
7277 if (r == MAILIMF_NO_ERROR)
7278 type = guessed_type;
7279 else if (r == MAILIMF_ERROR_PARSE) {
7280 /* do nothing */
7281 }
7282 else {
7283 res = r;
7284 goto err;
7285 }
7286 break;
7287 case MAILIMF_FIELD_SUBJECT:
7288 r = mailimf_subject_parse(message, length, &cur_token,
7289 &subject);
7290 if (r == MAILIMF_NO_ERROR)
7291 type = guessed_type;
7292 else if (r == MAILIMF_ERROR_PARSE) {
7293 /* do nothing */
7294 }
7295 else {
7296 res = r;
7297 goto err;
7298 }
7299 break;
7300 }
7301
7302 if (type == MAILIMF_FIELD_NONE) {
7303 res = MAILIMF_ERROR_PARSE;
7304 goto err;
7305 }
7306
7307 field = mailimf_field_new(type, NULL, NULL, NULL, NULL, NULL,
7308 NULL, NULL, NULL,
7309 orig_date, from, sender, reply_to, to,
7310 cc, bcc, message_id, in_reply_to, references,
7311 subject, NULL, NULL, NULL);
7312 if (field == NULL) {
7313 res = MAILIMF_ERROR_MEMORY;
7314 goto free_fields;
7315 }
7316
7317 * result = field;
7318 * index = cur_token;
7319
7320 return MAILIMF_NO_ERROR;
7321
7322 free_fields:
7323 if (orig_date != NULL)
7324 mailimf_orig_date_free(orig_date);
7325 if (from != NULL)
7326 mailimf_from_free(from);
7327 if (sender != NULL)
7328 mailimf_sender_free(sender);
7329 if (reply_to != NULL)
7330 mailimf_reply_to_free(reply_to);
7331 if (to != NULL)
7332 mailimf_to_free(to);
7333 if (cc != NULL)
7334 mailimf_cc_free(cc);
7335 if (bcc != NULL)
7336 mailimf_bcc_free(bcc);
7337 if (message_id != NULL)
7338 mailimf_message_id_free(message_id);
7339 if (in_reply_to != NULL)
7340 mailimf_in_reply_to_free(in_reply_to);
7341 if (references != NULL)
7342 mailimf_references_free(references);
7343 if (subject != NULL)
7344 mailimf_subject_free(subject);
7345 err:
7346 return res;
7347 }
7348
7349 int mailimf_envelope_fields_parse(const char * message, size_t length,
7350 size_t * index,
7351 struct mailimf_fields ** result)
7352 {
7353 size_t cur_token;
7354 clist * list;
7355 struct mailimf_fields * fields;
7356 int r;
7357 int res;
7358
7359 cur_token = * index;
7360
7361 list = clist_new();
7362 if (list == NULL) {
7363 res = MAILIMF_ERROR_MEMORY;
7364 goto err;
7365 }
7366
7367 while (1) {
7368 struct mailimf_field * elt;
7369
7370 r = mailimf_envelope_field_parse(message, length, &cur_token, &elt);
7371 if (r == MAILIMF_NO_ERROR) {
7372 r = clist_append(list, elt);
7373 if (r < 0) {
7374 res = MAILIMF_ERROR_MEMORY;
7375 goto free;
7376 }
7377 }
7378 else if (r == MAILIMF_ERROR_PARSE) {
7379 r = mailimf_ignore_field_parse(message, length, &cur_token);
7380 if (r == MAILIMF_NO_ERROR) {
7381 /* do nothing */
7382 }
7383 else if (r == MAILIMF_ERROR_PARSE) {
7384 break;
7385 }
7386 else {
7387 res = r;
7388 goto free;
7389 }
7390 }
7391 else {
7392 res = r;
7393 goto free;
7394 }
7395 }
7396
7397 fields = mailimf_fields_new(list);
7398 if (fields == NULL) {
7399 res = MAILIMF_ERROR_MEMORY;
7400 goto free;
7401 }
7402
7403 * result = fields;
7404 * index = cur_token;
7405
7406 return MAILIMF_NO_ERROR;
7407
7408 free:
7409 if (list != NULL) {
7410 clist_foreach(list, (clist_func) mailimf_field_free, NULL);
7411 clist_free(list);
7412 }
7413 err:
7414 return res;
7415 }
7416
7417
7418 static int
7419 mailimf_envelope_or_optional_field_parse(const char * message,
7420 size_t length,
7421 size_t * index,
7422 struct mailimf_field ** result)
7423 {
7424 int r;
7425 size_t cur_token;
7426 struct mailimf_optional_field * optional_field;
7427 struct mailimf_field * field;
7428
7429 r = mailimf_envelope_field_parse(message, length, index, result);
7430 if (r == MAILIMF_NO_ERROR)
7431 return MAILIMF_NO_ERROR;
7432
7433 cur_token = * index;
7434
7435 r = mailimf_optional_field_parse(message, length, &cur_token,
7436 &optional_field);
7437 if (r != MAILIMF_NO_ERROR)
7438 return r;
7439
7440 field = mailimf_field_new(MAILIMF_FIELD_OPTIONAL_FIELD, NULL,
7441 NULL, NULL, NULL,
7442 NULL, NULL, NULL,
7443 NULL, NULL, NULL,
7444 NULL, NULL, NULL,
7445 NULL, NULL, NULL, NULL, NULL,
7446 NULL, NULL, NULL, optional_field);
7447 if (field == NULL) {
7448 mailimf_optional_field_free(optional_field);
7449 return MAILIMF_ERROR_MEMORY;
7450 }
7451
7452 * result = field;
7453 * index = cur_token;
7454
7455 return MAILIMF_NO_ERROR;
7456 }
7457
7458
7459 int
7460 mailimf_envelope_and_optional_fields_parse(const char * message, size_t length,
7461 size_t * index,
7462 struct mailimf_fields ** result)
7463 {
7464 size_t cur_token;
7465 clist * list;
7466 struct mailimf_fields * fields;
7467 int r;
7468 int res;
7469
7470 cur_token = * index;
7471
7472 list = NULL;
7473
7474 r = mailimf_struct_multiple_parse(message, length, &cur_token,
7475 &list,
7476 (mailimf_struct_parser *)
7477 mailimf_envelope_or_optional_field_parse,
7478 (mailimf_struct_destructor *)
7479 mailimf_field_free);
7480 switch (r) {
7481 case MAILIMF_NO_ERROR:
7482 /* do nothing */
7483 break;
7484
7485 case MAILIMF_ERROR_PARSE:
7486 list = clist_new();
7487 if (list == NULL) {
7488 res = MAILIMF_ERROR_MEMORY;
7489 goto err;
7490 }
7491 break;
7492
7493 default:
7494 res = r;
7495 goto err;
7496 }
7497
7498 fields = mailimf_fields_new(list);
7499 if (fields == NULL) {
7500 res = MAILIMF_ERROR_MEMORY;
7501 goto free;
7502 }
7503
7504 * result = fields;
7505 * index = cur_token;
7506
7507 return MAILIMF_NO_ERROR;
7508
7509 free:
7510 if (list != NULL) {
7511 clist_foreach(list, (clist_func) mailimf_field_free, NULL);
7512 clist_free(list);
7513 }
7514 err:
7515 return res;
7516 }
7517
7518
7519
7520 static int
7521 mailimf_only_optional_field_parse(const char * message,
7522 size_t length,
7523 size_t * index,
7524 struct mailimf_field ** result)
7525 {
7526 int r;
7527 size_t cur_token;
7528 struct mailimf_optional_field * optional_field;
7529 struct mailimf_field * field;
7530
7531 cur_token = * index;
7532
7533 r = mailimf_optional_field_parse(message, length, &cur_token,
7534 &optional_field);
7535 if (r != MAILIMF_NO_ERROR)
7536 return r;
7537
7538 field = mailimf_field_new(MAILIMF_FIELD_OPTIONAL_FIELD, NULL, NULL, NULL,
7539 NULL, NULL, NULL, NULL, NULL,
7540 NULL, NULL, NULL, NULL, NULL,
7541 NULL, NULL, NULL, NULL, NULL,
7542 NULL, NULL, NULL, optional_field);
7543 if (field == NULL) {
7544 mailimf_optional_field_free(optional_field);
7545 return MAILIMF_ERROR_MEMORY;
7546 }
7547
7548 * result = field;
7549 * index = cur_token;
7550
7551 return MAILIMF_NO_ERROR;
7552 }
7553
7554
7555 int
7556 mailimf_optional_fields_parse(const char * message, size_t length,
7557 size_t * index,
7558 struct mailimf_fields ** result)
7559 {
7560 size_t cur_token;
7561 clist * list;
7562 struct mailimf_fields * fields;
7563 int r;
7564 int res;
7565
7566 cur_token = * index;
7567
7568 list = NULL;
7569
7570 r = mailimf_struct_multiple_parse(message, length, &cur_token,
7571 &list,
7572 (mailimf_struct_parser *)
7573 mailimf_only_optional_field_parse,
7574 (mailimf_struct_destructor *)
7575 mailimf_field_free);
7576 switch (r) {
7577 case MAILIMF_NO_ERROR:
7578 /* do nothing */
7579 break;
7580
7581 case MAILIMF_ERROR_PARSE:
7582 list = clist_new();
7583 if (list == NULL) {
7584 res = MAILIMF_ERROR_MEMORY;
7585 goto err;
7586 }
7587 break;
7588
7589 default:
7590 res = r;
7591 goto err;
7592 }
7593
7594 fields = mailimf_fields_new(list);
7595 if (fields == NULL) {
7596 res = MAILIMF_ERROR_MEMORY;
7597 goto free;
7598 }
7599
7600 * result = fields;
7601 * index = cur_token;
7602
7603 return MAILIMF_NO_ERROR;
7604
7605 free:
7606 if (list != NULL) {
7607 clist_foreach(list, (clist_func) mailimf_field_free, NULL);
7608 clist_free(list);
7609 }
7610 err:
7611 return res;
7612 }