/*++ /* NAME /* header_token 3 /* SUMMARY /* mail header parser /* SYNOPSIS /* #include <header_token.h> /* /* typedef struct { /* .in +4 /* int type; /* const char *u.value; /* /* ... */ /* .in /* } HEADER_TOKEN; /* /* ssize_t header_token(token, token_len, token_buffer, ptr, /* specials, terminator) /* HEADER_TOKEN *token; /* ssize_t token_len; /* VSTRING *token_buffer; /* const char **ptr; /* const char *specials; /* int terminator; /* DESCRIPTION /* This module parses a mail header value (text after field-name:) /* into tokens. The parser understands RFC 822 linear white space, /* quoted-string, comment, control characters, and a set of /* user-specified special characters. /* /* A result token type is one of the following: /* .IP HEADER_TOK_QSTRING /* Quoted string as per RFC 822. /* .IP HEADER_TOK_TOKEN /* Token as per RFC 822, and the special characters supplied by the /* caller. /* .IP other /* The value of a control character or special character. /* .PP /* header_token() tokenizes the input and stops after a user-specified /* terminator (ignoring all tokens that exceed the capacity of /* the result storage), or when it runs out of space for the result. /* The terminator is not stored. The result value is the number of /* tokens stored, or -1 when the input was exhausted before any tokens /* were found. /* /* Arguments: /* .IP token /* Result array of HEADER_TOKEN structures. Token string values /* are pointers to null-terminated substrings in the token_buffer. /* .IP token_len /* Length of the array of HEADER_TOKEN structures. /* .IP token_buffer /* Storage for result token string values. /* .IP ptr /* Input/output read position. The input is a null-terminated string. /* .IP specials /* Special characters according to the relevant RFC, or a /* null pointer (default to the RFC 822 special characters). /* This must include the optional terminator if one is specified. /* .IP terminator /* The special character to stop after, or zero. /* BUGS /* Eight-bit characters are not given special treatment. /* SEE ALSO /* RFC 822 (ARPA Internet Text Messages) /* DIAGNOSTICS /* Fatal errors: memory allocation problem. /* LICENSE /* .ad /* .fi /* The Secure Mailer license must be distributed with this software. /* AUTHOR(S) /* Wietse Venema /* IBM T.J. Watson Research /* P.O. Box 704 /* Yorktown Heights, NY 10598, USA /*--*/ /* System library. */ #include <sys_defs.h> #include <string.h> #include <ctype.h> /* Utility library. */ #include <msg.h> #include <vstring.h> /* Global library. */ #include <lex_822.h> #include <header_token.h> /* Application-specific. */ /* * Silly little macros. */ #define STR(x) vstring_str(x) #define LEN(x) VSTRING_LEN(x) #define CU_CHAR_PTR(x) ((const unsigned char *) (x)) /* header_token - parse out the next item in a message header */ ssize_t header_token(HEADER_TOKEN *token, ssize_t token_len, VSTRING *token_buffer, const char **ptr, const char *user_specials, int user_terminator) { ssize_t comment_level; const unsigned char *cp; ssize_t len; int ch; ssize_t tok_count; ssize_t n; /* * Initialize. */ VSTRING_RESET(token_buffer); cp = CU_CHAR_PTR(*ptr); tok_count = 0; if (user_specials == 0) user_specials = LEX_822_SPECIALS; /* * Main parsing loop. * * XXX What was the reason to continue parsing when user_terminator is * specified? Perhaps this was needed at some intermediate stage of * development? */ while ((ch = *cp) != 0 && (user_terminator != 0 || tok_count < token_len)) { cp++; /* * Skip RFC 822 linear white space. */ if (IS_SPACE_TAB_CR_LF(ch)) continue; /* * Terminator. */ if (ch == user_terminator) break; /* * Skip RFC 822 comment. */ if (ch == '(') { comment_level = 1; while ((ch = *cp) != 0) { cp++; if (ch == '(') { /* comments can nest! */ comment_level++; } else if (ch == ')') { if (--comment_level == 0) break; } else if (ch == '\\') { if ((ch = *cp) == 0) break; cp++; } } continue; } /* * Copy quoted text according to RFC 822. */ if (ch == '"') { if (tok_count < token_len) { token[tok_count].u.offset = LEN(token_buffer); token[tok_count].type = HEADER_TOK_QSTRING; } while ((ch = *cp) != 0) { cp++; if (ch == '"') break; if (ch == '\n') { /* unfold */ if (tok_count < token_len) { len = LEN(token_buffer); while (len > 0 && IS_SPACE_TAB_CR_LF(STR(token_buffer)[len - 1])) len--; if (len < LEN(token_buffer)) vstring_truncate(token_buffer, len); } continue; } if (ch == '\\') { if ((ch = *cp) == 0) break; cp++; } if (tok_count < token_len) VSTRING_ADDCH(token_buffer, ch); } if (tok_count < token_len) { VSTRING_ADDCH(token_buffer, 0); tok_count++; } continue; } /* * Control, or special. */ if (strchr(user_specials, ch) || ISCNTRL(ch)) { if (tok_count < token_len) { token[tok_count].u.offset = LEN(token_buffer); token[tok_count].type = ch; VSTRING_ADDCH(token_buffer, ch); VSTRING_ADDCH(token_buffer, 0); tok_count++; } continue; } /* * Token. */ else { if (tok_count < token_len) { token[tok_count].u.offset = LEN(token_buffer); token[tok_count].type = HEADER_TOK_TOKEN; VSTRING_ADDCH(token_buffer, ch); } while ((ch = *cp) != 0 && !IS_SPACE_TAB_CR_LF(ch) && !ISCNTRL(ch) && !strchr(user_specials, ch)) { cp++; if (tok_count < token_len) VSTRING_ADDCH(token_buffer, ch); } if (tok_count < token_len) { VSTRING_ADDCH(token_buffer, 0); tok_count++; } continue; } } /* * Ignore a zero-length item after the last terminator. */ if (tok_count == 0 && ch == 0) return (-1); /* * Finalize. Fill in the string pointer array, now that the token buffer * is no longer dynamically reallocated as it grows. */ *ptr = (const char *) cp; for (n = 0; n < tok_count; n++) token[n].u.value = STR(token_buffer) + token[n].u.offset; if (msg_verbose) msg_info("header_token: %s %s %s", tok_count > 0 ? token[0].u.value : "", tok_count > 1 ? token[1].u.value : "", tok_count > 2 ? token[2].u.value : ""); return (tok_count); }