static void astream_parse_header(struct attachment_istream *astream,
struct message_header_line *hdr)
{
if (!hdr->continued) {
stream_add_data(astream, hdr->name, hdr->name_len);
stream_add_data(astream, hdr->middle, hdr->middle_len);
}
stream_add_data(astream, hdr->value, hdr->value_len);
if (!hdr->no_newline) {
if (hdr->crlf_newline)
stream_add_data(astream, "\r\n", 2);
else
stream_add_data(astream, "\n", 1);
}
if (hdr->continues) {
hdr->use_full_value = TRUE;
return;
}
if (strcasecmp(hdr->name, "Content-Type") == 0)
parse_content_type(astream, hdr);
else if (strcasecmp(hdr->name, "Content-Disposition") == 0)
parse_content_disposition(astream, hdr);
}
size_t HttpResponseParser::curl_headerfunction( void *ptr, size_t size,
size_t nmemb, void *data )
{
size_t lSize = size*nmemb;
size_t lResult = lSize;
HttpResponseParser* lParser = static_cast<HttpResponseParser*>(data);
if (lParser->theInsideRead) {
lParser->theHandler.endBody();
lParser->theInsideRead = false;
}
const char* lDataChar = (const char*) ptr;
while (lSize != 0 && (lDataChar[lSize - 1] == 10
|| lDataChar[lSize - 1] == 13)) {
lSize--;
}
if (lSize == 0) {
return lResult;
}
std::string lData(lDataChar, lSize);
if (lData.find("HTTP") == 0) {
lParser->parseStatusAndMessage(lData);
return lResult;
}
std::string::size_type lPos = lData.find(':');
if (lPos == std::string::npos) {
return lResult;
}
std::string lName = lData.substr(0, lPos);
std::string lValue = lData.substr(lPos + 2);
{
std::string::size_type lPosition = lValue.size() - 1;
while (true) {
if (lPosition != std::string::npos) {
break;
}
if (lValue[lPosition] == '\n' || lValue[lPosition] == '\r') {
--lPosition;
} else {
break;
}
}
lValue = lValue.substr(0, lPosition + 1);
}
String lNameS = fn::lower_case( lName );
if (lNameS == "content-type") {
parse_content_type(
lValue, &lParser->theCurrentContentType, &lParser->theCurrentCharset,
&lParser->theIsMultipart, &lParser->theBoundary
);
} else if (lNameS == "content-id") {
lParser->theId = lValue;
} else if (lNameS == "content-description") {
lParser->theDescription = lValue;
}
lParser->theHeaders.push_back(
std::pair<std::string, std::string>(lName, lValue));
return lResult;
}
void RequestParser::getCharset(const String& aMediaType, std::string& charset)
{
std::string mime_type;
parse_content_type(aMediaType.c_str(),&mime_type,&charset);
if (!charset.empty() && transcode::is_necessary(charset.c_str()) && !transcode::is_supported(charset.c_str()))
{
std::ostringstream lMsg;
lMsg << charset << ": unsupported encoding charset";
theThrower->raiseException("CHARSET", lMsg.str());
}
}
static void handle_header(struct message_search_context *ctx,
struct message_header_line *hdr)
{
if (hdr->name_len == 12 &&
strcasecmp(hdr->name, "Content-Type") == 0) {
if (hdr->continues) {
hdr->use_full_value = TRUE;
return;
}
T_BEGIN {
parse_content_type(ctx, hdr);
} T_END;
}
}
void HttpResponseParser::parseHeader(const std::string& aHeader)
{
std::string::size_type lSeparator = aHeader.find(':');
std::string::size_type lNameEnd = aHeader.find_last_not_of(" \t", lSeparator);
std::string::size_type lNameStart = aHeader.find_first_not_of(" \t");
std::string lName = aHeader.substr( lNameStart, lNameEnd - lNameStart );
std::string::size_type lValueStart = aHeader.find_first_not_of(" \t", lSeparator + 1);
std::string::size_type lValueEnd = aHeader.find_last_not_of(" \t\r");
std::string lValue = aHeader.substr( lValueStart, lValueEnd + 1 - lValueStart );
String lNameS = fn::lower_case( lName );
if (lNameS == "content-type")
parse_content_type(lValue, &theCurrentContentType, &theCurrentCharset);
theHandler.header(lName, lValue);
}
static bool message_decode_header(struct message_decoder_context *ctx,
struct message_header_line *hdr,
struct message_block *output)
{
size_t value_len;
if (hdr->continues) {
hdr->use_full_value = TRUE;
return FALSE;
}
T_BEGIN {
if (hdr->name_len == 12 &&
strcasecmp(hdr->name, "Content-Type") == 0)
parse_content_type(ctx, hdr);
if (hdr->name_len == 25 &&
strcasecmp(hdr->name, "Content-Transfer-Encoding") == 0)
ctx->message_cte = message_decoder_parse_cte(hdr);
} T_END;
buffer_set_used_size(ctx->buf, 0);
message_header_decode_utf8(hdr->full_value, hdr->full_value_len,
ctx->buf, ctx->normalizer);
value_len = ctx->buf->used;
if (ctx->normalizer != NULL) {
(void)ctx->normalizer(hdr->name, hdr->name_len, ctx->buf);
buffer_append_c(ctx->buf, '\0');
} else {
if (!uni_utf8_get_valid_data((const unsigned char *)hdr->name,
hdr->name_len, ctx->buf))
buffer_append_c(ctx->buf, '\0');
}
ctx->hdr = *hdr;
ctx->hdr.full_value = ctx->buf->data;
ctx->hdr.full_value_len = value_len;
ctx->hdr.value_len = 0;
if (ctx->buf->used != value_len) {
ctx->hdr.name = CONST_PTR_OFFSET(ctx->buf->data,
ctx->hdr.full_value_len);
ctx->hdr.name_len = ctx->buf->used - 1 - value_len;
}
output->hdr = &ctx->hdr;
return TRUE;
}
static int parse_next_header(struct message_parser_ctx *ctx,
struct message_block *block_r)
{
struct message_part *part = ctx->part;
struct message_header_line *hdr;
size_t size;
int ret;
if (ctx->skip > 0) {
i_stream_skip(ctx->input, ctx->skip);
ctx->skip = 0;
}
ret = message_parse_header_next(ctx->hdr_parser_ctx, &hdr);
if (ret == 0 || (ret < 0 && ctx->input->stream_errno != 0)) {
(void)i_stream_get_data(ctx->input, &size);
ctx->want_count = size + 1;
return ret;
}
if (hdr != NULL) {
if (hdr->eoh)
;
else if (strcasecmp(hdr->name, "Mime-Version") == 0) {
/* it's MIME. Content-* headers are valid */
part->flags |= MESSAGE_PART_FLAG_IS_MIME;
} else if (strcasecmp(hdr->name, "Content-Type") == 0) {
if ((ctx->flags &
MESSAGE_PARSER_FLAG_MIME_VERSION_STRICT) == 0)
part->flags |= MESSAGE_PART_FLAG_IS_MIME;
if (hdr->continues)
hdr->use_full_value = TRUE;
else T_BEGIN {
parse_content_type(ctx, hdr);
} T_END;
}
block_r->hdr = hdr;
block_r->size = 0;
return 1;
}
/* end of headers */
if ((part->flags & MESSAGE_PART_FLAG_MULTIPART) != 0 &&
ctx->last_boundary == NULL) {
/* multipart type but no message boundary */
part->flags = 0;
}
if ((part->flags & MESSAGE_PART_FLAG_IS_MIME) == 0) {
/* It's not MIME. Reset everything we found from
Content-Type. */
part->flags = 0;
ctx->last_boundary = NULL;
}
if (!ctx->part_seen_content_type ||
(part->flags & MESSAGE_PART_FLAG_IS_MIME) == 0) {
if (part->parent != NULL &&
(part->parent->flags &
MESSAGE_PART_FLAG_MULTIPART_DIGEST) != 0) {
/* when there's no content-type specified and we're
below multipart/digest, assume message/rfc822
content-type */
part->flags |= MESSAGE_PART_FLAG_MESSAGE_RFC822;
} else {
/* otherwise we default to text/plain */
part->flags |= MESSAGE_PART_FLAG_TEXT;
}
}
if (message_parse_header_has_nuls(ctx->hdr_parser_ctx))
part->flags |= MESSAGE_PART_FLAG_HAS_NULS;
message_parse_header_deinit(&ctx->hdr_parser_ctx);
i_assert((part->flags & MUTEX_FLAGS) != MUTEX_FLAGS);
ctx->last_chr = '\n';
if (ctx->last_boundary != NULL) {
parse_next_body_multipart_init(ctx);
ctx->parse_next_block = parse_next_body_to_boundary;
} else if (part->flags & MESSAGE_PART_FLAG_MESSAGE_RFC822)
ctx->parse_next_block = parse_next_body_message_rfc822_init;
else if (ctx->boundaries != NULL)
ctx->parse_next_block = parse_next_body_to_boundary;
else
ctx->parse_next_block = parse_next_body_to_eof;
ctx->want_count = 1;
/* return empty block as end of headers */
block_r->hdr = NULL;
block_r->size = 0;
return 1;
}
static int parse_next_header(struct message_parser_ctx *ctx,
struct message_block *block_r)
{
struct message_part *part = ctx->part;
struct message_header_line *hdr;
struct message_boundary *boundary;
bool full;
int ret;
if ((ret = message_parser_read_more(ctx, block_r, &full)) == 0)
return ret;
if (ret > 0 && block_is_at_eoh(block_r) &&
ctx->last_boundary != NULL &&
(part->flags & MESSAGE_PART_FLAG_IS_MIME) != 0) {
/* we are at the end of headers and we've determined that we're
going to start a multipart. add the boundary already here
at this point so we can reliably determine whether the
"\n--boundary" belongs to us or to a previous boundary.
this is a problem if the boundary prefixes are identical,
because MIME requires only the prefix to match. */
parse_next_body_multipart_init(ctx);
ctx->multipart = TRUE;
}
/* before parsing the header see if we can find a --boundary from here.
we're guaranteed to be at the beginning of the line here. */
if (ret > 0) {
ret = ctx->boundaries == NULL ? -1 :
boundary_line_find(ctx, block_r->data,
block_r->size, full, &boundary);
if (ret > 0 && boundary->part == ctx->part) {
/* our own body begins with our own --boundary.
we don't want to handle that yet. */
ret = -1;
}
}
if (ret < 0) {
/* no boundary */
ret = message_parse_header_next(ctx->hdr_parser_ctx, &hdr);
if (ret == 0 || (ret < 0 && ctx->input->stream_errno != 0)) {
ctx->want_count = i_stream_get_data_size(ctx->input) + 1;
return ret;
}
} else if (ret == 0) {
/* need more data */
return 0;
} else {
/* boundary found. stop parsing headers here. The previous
[CR]LF belongs to the MIME boundary though. */
if (ctx->prev_hdr_newline_size > 0) {
i_assert(ctx->part->header_size.lines > 0);
/* remove the newline size from the MIME header */
ctx->part->header_size.lines--;
ctx->part->header_size.physical_size -=
ctx->prev_hdr_newline_size;
ctx->part->header_size.virtual_size -= 2;
/* add the newline size to the parent's body */
ctx->part->parent->body_size.lines++;
ctx->part->parent->body_size.physical_size +=
ctx->prev_hdr_newline_size;
ctx->part->parent->body_size.virtual_size += 2;
}
hdr = NULL;
}
if (hdr != NULL) {
if (hdr->eoh)
;
else if (strcasecmp(hdr->name, "Mime-Version") == 0) {
/* it's MIME. Content-* headers are valid */
part->flags |= MESSAGE_PART_FLAG_IS_MIME;
} else if (strcasecmp(hdr->name, "Content-Type") == 0) {
if ((ctx->flags &
MESSAGE_PARSER_FLAG_MIME_VERSION_STRICT) == 0)
part->flags |= MESSAGE_PART_FLAG_IS_MIME;
if (hdr->continues)
hdr->use_full_value = TRUE;
else T_BEGIN {
parse_content_type(ctx, hdr);
} T_END;
}
block_r->hdr = hdr;
block_r->size = 0;
ctx->prev_hdr_newline_size = hdr->no_newline ? 0 :
(hdr->crlf_newline ? 2 : 1);
return 1;
}
/* end of headers */
if ((part->flags & MESSAGE_PART_FLAG_IS_MIME) == 0) {
/* It's not MIME. Reset everything we found from
Content-Type. */
i_assert(!ctx->multipart);
part->flags = 0;
}
ctx->last_boundary = NULL;
if (!ctx->part_seen_content_type ||
(part->flags & MESSAGE_PART_FLAG_IS_MIME) == 0) {
if (part->parent != NULL &&
(part->parent->flags &
MESSAGE_PART_FLAG_MULTIPART_DIGEST) != 0) {
/* when there's no content-type specified and we're
below multipart/digest, assume message/rfc822
content-type */
part->flags |= MESSAGE_PART_FLAG_MESSAGE_RFC822;
} else {
/* otherwise we default to text/plain */
part->flags |= MESSAGE_PART_FLAG_TEXT;
}
}
if (message_parse_header_has_nuls(ctx->hdr_parser_ctx))
part->flags |= MESSAGE_PART_FLAG_HAS_NULS;
message_parse_header_deinit(&ctx->hdr_parser_ctx);
i_assert((part->flags & MUTEX_FLAGS) != MUTEX_FLAGS);
ctx->last_chr = '\n';
if (ctx->multipart) {
i_assert(ctx->last_boundary == NULL);
ctx->multipart = FALSE;
ctx->parse_next_block = parse_next_body_to_boundary;
} else if ((part->flags & MESSAGE_PART_FLAG_MESSAGE_RFC822) != 0)
ctx->parse_next_block = parse_next_body_message_rfc822_init;
else if (ctx->boundaries != NULL)
ctx->parse_next_block = parse_next_body_to_boundary;
else
ctx->parse_next_block = parse_next_body_to_eof;
ctx->want_count = 1;
/* return empty block as end of headers */
block_r->hdr = NULL;
block_r->size = 0;
return 1;
}
inline int MIMEParser<ParserConfig>::parse_headers(const char* line, size_t l)
{
int ret_code = PARSE_OK;
const char* p = line, *p2;
size_t count, l_newlines;
int length = l, length2;
#define RETURN(x) \
do { \
if(x == PARSE_ERROR) \
global_state = GS_ERROR; \
ret_code = x; \
goto finish; \
} while(0)
if(l == 0)
{
global_state = GS_BODY;
RETURN(PARSE_OK);
}
for(l_newlines = 0; l_newlines < l && line[l_newlines] == '\r'; l_newlines++)
;
if(l_newlines == l)
{
global_state = GS_BODY;
RETURN(PARSE_OK);
}
if(isspace(*p))
{
if(headers_count == 0)
RETURN(PARSE_ERROR);
if(!bad_header)
pc->header_continue();
}
else
{
bad_header = 0;
last_atom_encoded = false;
/*
if(cur_header == HDR_CONTENT_TYPE && parse_content_type("", 0) != PARSE_OK)
RETURN(PARSE_ERROR);
*/
if(cur_header == HDR_CONTENT_TYPE)
parse_content_type("", 0);
if(!is_printable(*line) || *line == ':')
{
bad_header = 1;
RETURN(PARSE_OK);
/* RETURN(PARSE_ERROR); */
}
p = line;
count = 0;
for( ; length >= 0 && is_printable(p[count]) && p[count] != ':' ; count++, length-- )
;
if(count && length >= 0 && (isspace(p[count]) || p[count] == ':'))
{
pc->header_name(p, count);
cur_header = check_header(p, count);
if(cur_header != HDR_UNKNOWN)
headers_seen |= 1 >> cur_header;
}
else
{
