| /* |
| This file is part of libmicrohttpd |
| Copyright (C) 2007-2021 Daniel Pittman, Christian Grothoff, and Evgeny Grin |
| |
| This library is free software; you can redistribute it and/or |
| modify it under the terms of the GNU Lesser General Public |
| License as published by the Free Software Foundation; either |
| version 2.1 of the License, or (at your option) any later version. |
| |
| This library is distributed in the hope that it will be useful, |
| but WITHOUT ANY WARRANTY; without even the implied warranty of |
| MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
| Lesser General Public License for more details. |
| |
| You should have received a copy of the GNU Lesser General Public |
| License along with this library; if not, write to the Free Software |
| Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
| */ |
| |
| /** |
| * @file postprocessor.c |
| * @brief Methods for parsing POST data |
| * @author Christian Grothoff |
| * @author Karlson2k (Evgeny Grin) |
| */ |
| |
| #include "postprocessor.h" |
| #include "internal.h" |
| #include "mhd_str.h" |
| #include "mhd_compat.h" |
| #include "mhd_assert.h" |
| |
| /** |
| * Size of on-stack buffer that we use for un-escaping of the value. |
| * We use a pretty small value to be nice to the stack on embedded |
| * systems. |
| */ |
| #define XBUF_SIZE 512 |
| |
| |
| _MHD_EXTERN struct MHD_PostProcessor * |
| MHD_create_post_processor (struct MHD_Connection *connection, |
| size_t buffer_size, |
| MHD_PostDataIterator iter, |
| void *iter_cls) |
| { |
| struct MHD_PostProcessor *ret; |
| const char *encoding; |
| const char *boundary; |
| size_t blen; |
| |
| if ( (buffer_size < 256) || |
| (NULL == connection) || |
| (NULL == iter)) |
| MHD_PANIC (_ ("libmicrohttpd API violation.\n")); |
| encoding = NULL; |
| if (MHD_NO == |
| MHD_lookup_connection_value_n (connection, |
| MHD_HEADER_KIND, |
| MHD_HTTP_HEADER_CONTENT_TYPE, |
| MHD_STATICSTR_LEN_ ( |
| MHD_HTTP_HEADER_CONTENT_TYPE), |
| &encoding, |
| NULL)) |
| return NULL; |
| mhd_assert (NULL != encoding); |
| boundary = NULL; |
| if (! MHD_str_equal_caseless_n_ (MHD_HTTP_POST_ENCODING_FORM_URLENCODED, |
| encoding, |
| MHD_STATICSTR_LEN_ ( |
| MHD_HTTP_POST_ENCODING_FORM_URLENCODED))) |
| { |
| if (! MHD_str_equal_caseless_n_ (MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA, |
| encoding, |
| MHD_STATICSTR_LEN_ ( |
| MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA))) |
| return NULL; |
| boundary = |
| &encoding[MHD_STATICSTR_LEN_ (MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA)]; |
| /* Q: should this be "strcasestr"? */ |
| boundary = strstr (boundary, "boundary="); |
| if (NULL == boundary) |
| return NULL; /* failed to determine boundary */ |
| boundary += MHD_STATICSTR_LEN_ ("boundary="); |
| blen = strlen (boundary); |
| if ( (blen < 2) || |
| (blen * 2 + 2 > buffer_size) ) |
| return NULL; /* (will be) out of memory or invalid boundary */ |
| if ( (boundary[0] == '"') && |
| (boundary[blen - 1] == '"') ) |
| { |
| /* remove enclosing quotes */ |
| ++boundary; |
| blen -= 2; |
| } |
| } |
| else |
| blen = 0; |
| buffer_size += 4; /* round up to get nice block sizes despite boundary search */ |
| |
| /* add +1 to ensure we ALWAYS have a zero-termination at the end */ |
| if (NULL == (ret = MHD_calloc_ (1, sizeof (struct MHD_PostProcessor) |
| + buffer_size + 1))) |
| return NULL; |
| ret->connection = connection; |
| ret->ikvi = iter; |
| ret->cls = iter_cls; |
| ret->encoding = encoding; |
| ret->buffer_size = buffer_size; |
| ret->state = PP_Init; |
| ret->blen = blen; |
| ret->boundary = boundary; |
| ret->skip_rn = RN_Inactive; |
| return ret; |
| } |
| |
| |
| /** |
| * Give a (possibly partial) value to the application callback. We have some |
| * part of the value in the 'pp->xbuf', the rest is between @a value_start and |
| * @a value_end. If @a last_escape is non-NULL, there may be an incomplete |
| * escape sequence at at @a value_escape between @a value_start and @a |
| * value_end which we should preserve in 'pp->xbuf' for the future. |
| * |
| * Unescapes the value and calls the iterator together with the key. The key |
| * must already be in the key buffer allocated and 0-terminated at the end of |
| * @a pp at the time of the call. |
| * |
| * @param[in,out] pp post processor to act upon |
| * @param value_start where in memory is the value |
| * @param value_end where does the value end |
| * @param last_escape last '%'-sign in value range, |
| * if relevant, or NULL |
| */ |
| static void |
| process_value (struct MHD_PostProcessor *pp, |
| const char *value_start, |
| const char *value_end, |
| const char *last_escape) |
| { |
| char xbuf[XBUF_SIZE + 1]; |
| size_t xoff; |
| |
| mhd_assert (pp->xbuf_pos < sizeof (xbuf)); |
| /* 'value_start' and 'value_end' must be either both non-NULL or both NULL */ |
| mhd_assert ( (NULL == value_start) || (NULL != value_end) ); |
| mhd_assert ( (NULL != value_start) || (NULL == value_end) ); |
| mhd_assert ( (NULL == last_escape) || (NULL != value_start) ); |
| /* move remaining input from previous round into processing buffer */ |
| if (0 != pp->xbuf_pos) |
| memcpy (xbuf, |
| pp->xbuf, |
| pp->xbuf_pos); |
| xoff = pp->xbuf_pos; |
| pp->xbuf_pos = 0; |
| if ( (NULL != last_escape) && |
| (((size_t) (value_end - last_escape)) < sizeof (pp->xbuf)) ) |
| { |
| mhd_assert (value_end >= last_escape); |
| pp->xbuf_pos = (size_t) (value_end - last_escape); |
| memcpy (pp->xbuf, |
| last_escape, |
| (size_t) (value_end - last_escape)); |
| value_end = last_escape; |
| } |
| while ( (value_start != value_end) || |
| (pp->must_ikvi) || |
| (xoff > 0) ) |
| { |
| size_t delta = (size_t) (value_end - value_start); |
| bool cut = false; |
| size_t clen = 0; |
| |
| mhd_assert (value_end >= value_start); |
| |
| if (delta > XBUF_SIZE - xoff) |
| delta = XBUF_SIZE - xoff; |
| /* move (additional) input into processing buffer */ |
| if (0 != delta) |
| { |
| memcpy (&xbuf[xoff], |
| value_start, |
| delta); |
| xoff += delta; |
| value_start += delta; |
| } |
| /* find if escape sequence is at the end of the processing buffer; |
| if so, exclude those from processing (reduce delta to point at |
| end of processed region) */ |
| if ( (xoff > 0) && |
| ('%' == xbuf[xoff - 1]) ) |
| { |
| cut = (xoff != XBUF_SIZE); |
| xoff--; |
| if (cut) |
| { |
| /* move escape sequence into buffer for next function invocation */ |
| pp->xbuf[0] = '%'; |
| pp->xbuf_pos = 1; |
| } |
| else |
| { |
| /* just skip escape sequence for next loop iteration */ |
| delta = xoff; |
| clen = 1; |
| } |
| } |
| else if ( (xoff > 1) && |
| ('%' == xbuf[xoff - 2]) ) |
| { |
| cut = (xoff != XBUF_SIZE); |
| xoff -= 2; |
| if (cut) |
| { |
| /* move escape sequence into buffer for next function invocation */ |
| memcpy (pp->xbuf, |
| &xbuf[xoff], |
| 2); |
| pp->xbuf_pos = 2; |
| } |
| else |
| { |
| /* just skip escape sequence for next loop iteration */ |
| delta = xoff; |
| clen = 2; |
| } |
| } |
| mhd_assert (xoff < sizeof (xbuf)); |
| /* unescape */ |
| xbuf[xoff] = '\0'; /* 0-terminate in preparation */ |
| if (0 != xoff) |
| { |
| MHD_unescape_plus (xbuf); |
| xoff = MHD_http_unescape (xbuf); |
| } |
| /* finally: call application! */ |
| if (pp->must_ikvi || (0 != xoff) ) |
| { |
| pp->must_ikvi = false; |
| if (MHD_NO == pp->ikvi (pp->cls, |
| MHD_POSTDATA_KIND, |
| (const char *) &pp[1], /* key */ |
| NULL, |
| NULL, |
| NULL, |
| xbuf, |
| pp->value_offset, |
| xoff)) |
| { |
| pp->state = PP_Error; |
| return; |
| } |
| } |
| pp->value_offset += xoff; |
| if (cut) |
| break; |
| if (0 != clen) |
| { |
| xbuf[delta] = '%'; /* undo 0-termination */ |
| memmove (xbuf, |
| &xbuf[delta], |
| clen); |
| } |
| xoff = clen; |
| } |
| } |
| |
| |
| /** |
| * Process url-encoded POST data. |
| * |
| * @param pp post processor context |
| * @param post_data upload data |
| * @param post_data_len number of bytes in @a post_data |
| * @return #MHD_YES on success, #MHD_NO if there was an error processing the data |
| */ |
| static enum MHD_Result |
| post_process_urlencoded (struct MHD_PostProcessor *pp, |
| const char *post_data, |
| size_t post_data_len) |
| { |
| char *kbuf = (char *) &pp[1]; |
| size_t poff; |
| const char *start_key = NULL; |
| const char *end_key = NULL; |
| const char *start_value = NULL; |
| const char *end_value = NULL; |
| const char *last_escape = NULL; |
| |
| mhd_assert (PP_Callback != pp->state); |
| |
| poff = 0; |
| while ( ( (poff < post_data_len) || |
| (pp->state == PP_Callback) ) && |
| (pp->state != PP_Error) ) |
| { |
| switch (pp->state) |
| { |
| case PP_Error: |
| /* clearly impossible as per while loop invariant */ |
| abort (); |
| break; /* Unreachable */ |
| case PP_Init: |
| /* initial phase */ |
| mhd_assert (NULL == start_key); |
| mhd_assert (NULL == end_key); |
| mhd_assert (NULL == start_value); |
| mhd_assert (NULL == end_value); |
| switch (post_data[poff]) |
| { |
| case '=': |
| /* Case: (no key)'=' */ |
| /* Empty key with value */ |
| pp->state = PP_Error; |
| continue; |
| case '&': |
| /* Case: (no key)'&' */ |
| /* Empty key without value */ |
| poff++; |
| continue; |
| case '\n': |
| case '\r': |
| /* Case: (no key)'\n' or (no key)'\r' */ |
| pp->state = PP_Done; |
| poff++; |
| break; |
| default: |
| /* normal character, key start, advance! */ |
| pp->state = PP_ProcessKey; |
| start_key = &post_data[poff]; |
| pp->must_ikvi = true; |
| poff++; |
| continue; |
| } |
| break; /* end PP_Init */ |
| case PP_ProcessKey: |
| /* key phase */ |
| mhd_assert (NULL == start_value); |
| mhd_assert (NULL == end_value); |
| mhd_assert (NULL != start_key || 0 == poff); |
| mhd_assert (0 != poff || NULL == start_key); |
| mhd_assert (NULL == end_key); |
| switch (post_data[poff]) |
| { |
| case '=': |
| /* Case: 'key=' */ |
| if (0 != poff) |
| end_key = &post_data[poff]; |
| poff++; |
| pp->state = PP_ProcessValue; |
| break; |
| case '&': |
| /* Case: 'key&' */ |
| if (0 != poff) |
| end_key = &post_data[poff]; |
| poff++; |
| pp->state = PP_Callback; |
| break; |
| case '\n': |
| case '\r': |
| /* Case: 'key\n' or 'key\r' */ |
| if (0 != poff) |
| end_key = &post_data[poff]; |
| /* No advance here, 'PP_Done' will be selected by next 'PP_Init' phase */ |
| pp->state = PP_Callback; |
| break; |
| default: |
| /* normal character, advance! */ |
| if (0 == poff) |
| start_key = post_data; |
| poff++; |
| break; |
| } |
| mhd_assert (NULL == end_key || NULL != start_key); |
| break; /* end PP_ProcessKey */ |
| case PP_ProcessValue: |
| if (NULL == start_value) |
| start_value = &post_data[poff]; |
| switch (post_data[poff]) |
| { |
| case '=': |
| /* case 'key==' */ |
| pp->state = PP_Error; |
| continue; |
| case '&': |
| /* case 'value&' */ |
| end_value = &post_data[poff]; |
| poff++; |
| if (pp->must_ikvi || |
| (start_value != end_value) ) |
| { |
| pp->state = PP_Callback; |
| } |
| else |
| { |
| pp->buffer_pos = 0; |
| pp->value_offset = 0; |
| pp->state = PP_Init; |
| start_value = NULL; |
| end_value = NULL; |
| } |
| continue; |
| case '\n': |
| case '\r': |
| /* Case: 'value\n' or 'value\r' */ |
| end_value = &post_data[poff]; |
| if (pp->must_ikvi || |
| (start_value != end_value) ) |
| pp->state = PP_Callback; /* No poff advance here to set PP_Done in the next iteration */ |
| else |
| { |
| poff++; |
| pp->state = PP_Done; |
| } |
| break; |
| case '%': |
| last_escape = &post_data[poff]; |
| poff++; |
| break; |
| case '0': |
| case '1': |
| case '2': |
| case '3': |
| case '4': |
| case '5': |
| case '6': |
| case '7': |
| case '8': |
| case '9': |
| /* character, may be part of escaping */ |
| poff++; |
| continue; |
| default: |
| /* normal character, no more escaping! */ |
| last_escape = NULL; |
| poff++; |
| continue; |
| } |
| break; /* end PP_ProcessValue */ |
| case PP_Done: |
| switch (post_data[poff]) |
| { |
| case '\n': |
| case '\r': |
| poff++; |
| continue; |
| } |
| /* unexpected data at the end, fail! */ |
| pp->state = PP_Error; |
| break; |
| case PP_Callback: |
| mhd_assert ((NULL != end_key) || (NULL == start_key)); |
| if (1) |
| { |
| const size_t key_len = (size_t) (end_key - start_key); |
| mhd_assert (end_key >= start_key); |
| if (0 != key_len) |
| { |
| if ( (pp->buffer_pos + key_len >= pp->buffer_size) || |
| (pp->buffer_pos + key_len < pp->buffer_pos) ) |
| { |
| /* key too long, cannot parse! */ |
| pp->state = PP_Error; |
| continue; |
| } |
| /* compute key, if we have not already */ |
| memcpy (&kbuf[pp->buffer_pos], |
| start_key, |
| key_len); |
| pp->buffer_pos += key_len; |
| start_key = NULL; |
| end_key = NULL; |
| pp->must_unescape_key = true; |
| } |
| } |
| #ifdef _DEBUG |
| else |
| mhd_assert (0 != pp->buffer_pos); |
| #endif /* _DEBUG */ |
| if (pp->must_unescape_key) |
| { |
| kbuf[pp->buffer_pos] = '\0'; /* 0-terminate key */ |
| MHD_unescape_plus (kbuf); |
| MHD_http_unescape (kbuf); |
| pp->must_unescape_key = false; |
| } |
| process_value (pp, |
| start_value, |
| end_value, |
| NULL); |
| if (PP_Error == pp->state) |
| continue; |
| pp->value_offset = 0; |
| start_value = NULL; |
| end_value = NULL; |
| pp->buffer_pos = 0; |
| pp->state = PP_Init; |
| break; |
| case PP_NextBoundary: |
| case PP_ProcessEntryHeaders: |
| case PP_PerformCheckMultipart: |
| case PP_ProcessValueToBoundary: |
| case PP_PerformCleanup: |
| case PP_Nested_Init: |
| case PP_Nested_PerformMarking: |
| case PP_Nested_ProcessEntryHeaders: |
| case PP_Nested_ProcessValueToBoundary: |
| case PP_Nested_PerformCleanup: |
| default: |
| MHD_PANIC (_ ("internal error.\n")); /* should never happen! */ |
| } |
| mhd_assert ((end_key == NULL) || (start_key != NULL)); |
| mhd_assert ((end_value == NULL) || (start_value != NULL)); |
| } |
| |
| mhd_assert (PP_Callback != pp->state); |
| |
| if (PP_Error == pp->state) |
| { |
| /* State in error, returning failure */ |
| return MHD_NO; |
| } |
| |
| /* save remaining data for next iteration */ |
| if (NULL != start_key) |
| { |
| size_t key_len; |
| mhd_assert ((PP_ProcessKey == pp->state) || (NULL != end_key)); |
| if (NULL == end_key) |
| end_key = &post_data[poff]; |
| mhd_assert (end_key >= start_key); |
| key_len = (size_t) (end_key - start_key); |
| mhd_assert (0 != key_len); /* it must be always non-zero here */ |
| if (pp->buffer_pos + key_len >= pp->buffer_size) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; |
| } |
| memcpy (&kbuf[pp->buffer_pos], |
| start_key, |
| key_len); |
| pp->buffer_pos += key_len; |
| pp->must_unescape_key = true; |
| start_key = NULL; |
| end_key = NULL; |
| } |
| if ( (NULL != start_value) && |
| (PP_ProcessValue == pp->state) ) |
| { |
| /* compute key, if we have not already */ |
| if (pp->must_unescape_key) |
| { |
| kbuf[pp->buffer_pos] = '\0'; /* 0-terminate key */ |
| MHD_unescape_plus (kbuf); |
| MHD_http_unescape (kbuf); |
| pp->must_unescape_key = false; |
| } |
| if (NULL == end_value) |
| end_value = &post_data[poff]; |
| if ( (NULL != last_escape) && |
| (2 < (end_value - last_escape)) ) |
| last_escape = NULL; |
| process_value (pp, |
| start_value, |
| end_value, |
| last_escape); |
| pp->must_ikvi = false; |
| } |
| if (PP_Error == pp->state) |
| { |
| /* State in error, returning failure */ |
| return MHD_NO; |
| } |
| return MHD_YES; |
| } |
| |
| |
| /** |
| * If the given line matches the prefix, strdup the |
| * rest of the line into the suffix ptr. |
| * |
| * @param prefix prefix to match |
| * @param prefix_len length of @a prefix |
| * @param line line to match prefix in |
| * @param suffix set to a copy of the rest of the line, starting at the end of the match |
| * @return #MHD_YES if there was a match, #MHD_NO if not |
| */ |
| static int |
| try_match_header (const char *prefix, |
| size_t prefix_len, |
| char *line, |
| char **suffix) |
| { |
| if (NULL != *suffix) |
| return MHD_NO; |
| while (0 != *line) |
| { |
| if (MHD_str_equal_caseless_n_ (prefix, |
| line, |
| prefix_len)) |
| { |
| *suffix = strdup (&line[prefix_len]); |
| return MHD_YES; |
| } |
| ++line; |
| } |
| return MHD_NO; |
| } |
| |
| |
| /** |
| * |
| * @param pp post processor context |
| * @param boundary boundary to look for |
| * @param blen number of bytes in boundary |
| * @param ioffptr set to the end of the boundary if found, |
| * otherwise incremented by one (FIXME: quirky API!) |
| * @param next_state state to which we should advance the post processor |
| * if the boundary is found |
| * @param next_dash_state dash_state to which we should advance the |
| * post processor if the boundary is found |
| * @return #MHD_NO if the boundary is not found, #MHD_YES if we did find it |
| */ |
| static int |
| find_boundary (struct MHD_PostProcessor *pp, |
| const char *boundary, |
| size_t blen, |
| size_t *ioffptr, |
| enum PP_State next_state, |
| enum PP_State next_dash_state) |
| { |
| char *buf = (char *) &pp[1]; |
| const char *dash; |
| |
| if (pp->buffer_pos < 2 + blen) |
| { |
| if (pp->buffer_pos == pp->buffer_size) |
| pp->state = PP_Error; /* out of memory */ |
| /* ++(*ioffptr); */ |
| return MHD_NO; /* not enough data */ |
| } |
| if ( (0 != memcmp ("--", |
| buf, |
| 2)) || |
| (0 != memcmp (&buf[2], |
| boundary, |
| blen))) |
| { |
| if (pp->state != PP_Init) |
| { |
| /* garbage not allowed */ |
| pp->state = PP_Error; |
| } |
| else |
| { |
| /* skip over garbage (RFC 2046, 5.1.1) */ |
| dash = memchr (buf, |
| '-', |
| pp->buffer_pos); |
| if (NULL == dash) |
| (*ioffptr) += pp->buffer_pos; /* skip entire buffer */ |
| else if (dash == buf) |
| (*ioffptr)++; /* at least skip one byte */ |
| else |
| (*ioffptr) += (size_t) (dash - buf); /* skip to first possible boundary */ |
| } |
| return MHD_NO; /* expected boundary */ |
| } |
| /* remove boundary from buffer */ |
| (*ioffptr) += 2 + blen; |
| /* next: start with headers */ |
| pp->skip_rn = RN_Dash; |
| pp->state = next_state; |
| pp->dash_state = next_dash_state; |
| return MHD_YES; |
| } |
| |
| |
| /** |
| * In buf, there maybe an expression '$key="$value"'. If that is the |
| * case, copy a copy of $value to destination. |
| * |
| * If destination is already non-NULL, do nothing. |
| */ |
| static void |
| try_get_value (const char *buf, |
| const char *key, |
| char **destination) |
| { |
| const char *spos; |
| const char *bpos; |
| const char *endv; |
| size_t klen; |
| size_t vlen; |
| |
| if (NULL != *destination) |
| return; |
| bpos = buf; |
| klen = strlen (key); |
| while (NULL != (spos = strstr (bpos, key))) |
| { |
| if ( (spos[klen] != '=') || |
| ( (spos != buf) && |
| (spos[-1] != ' ') ) ) |
| { |
| /* no match */ |
| bpos = spos + 1; |
| continue; |
| } |
| if (spos[klen + 1] != '"') |
| return; /* not quoted */ |
| if (NULL == (endv = strchr (&spos[klen + 2], |
| '\"'))) |
| return; /* no end-quote */ |
| vlen = (size_t) (endv - spos) - klen - 1; |
| *destination = malloc (vlen); |
| if (NULL == *destination) |
| return; /* out of memory */ |
| (*destination)[vlen - 1] = '\0'; |
| memcpy (*destination, |
| &spos[klen + 2], |
| vlen - 1); |
| return; /* success */ |
| } |
| } |
| |
| |
| /** |
| * Go over the headers of the part and update |
| * the fields in "pp" according to what we find. |
| * If we are at the end of the headers (as indicated |
| * by an empty line), transition into next_state. |
| * |
| * @param pp post processor context |
| * @param ioffptr set to how many bytes have been |
| * processed |
| * @param next_state state to which the post processor should |
| * be advanced if we find the end of the headers |
| * @return #MHD_YES if we can continue processing, |
| * #MHD_NO on error or if we do not have |
| * enough data yet |
| */ |
| static int |
| process_multipart_headers (struct MHD_PostProcessor *pp, |
| size_t *ioffptr, |
| enum PP_State next_state) |
| { |
| char *buf = (char *) &pp[1]; |
| size_t newline; |
| |
| newline = 0; |
| while ( (newline < pp->buffer_pos) && |
| (buf[newline] != '\r') && |
| (buf[newline] != '\n') ) |
| newline++; |
| if (newline == pp->buffer_size) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; /* out of memory */ |
| } |
| if (newline == pp->buffer_pos) |
| return MHD_NO; /* will need more data */ |
| if (0 == newline) |
| { |
| /* empty line - end of headers */ |
| pp->skip_rn = RN_Full; |
| pp->state = next_state; |
| return MHD_YES; |
| } |
| /* got an actual header */ |
| if (buf[newline] == '\r') |
| pp->skip_rn = RN_OptN; |
| buf[newline] = '\0'; |
| if (MHD_str_equal_caseless_n_ ("Content-disposition: ", |
| buf, |
| MHD_STATICSTR_LEN_ ("Content-disposition: "))) |
| { |
| try_get_value (&buf[MHD_STATICSTR_LEN_ ("Content-disposition: ")], |
| "name", |
| &pp->content_name); |
| try_get_value (&buf[MHD_STATICSTR_LEN_ ("Content-disposition: ")], |
| "filename", |
| &pp->content_filename); |
| } |
| else |
| { |
| try_match_header ("Content-type: ", |
| MHD_STATICSTR_LEN_ ("Content-type: "), |
| buf, |
| &pp->content_type); |
| try_match_header ("Content-Transfer-Encoding: ", |
| MHD_STATICSTR_LEN_ ("Content-Transfer-Encoding: "), |
| buf, |
| &pp->content_transfer_encoding); |
| } |
| (*ioffptr) += newline + 1; |
| return MHD_YES; |
| } |
| |
| |
| /** |
| * We have the value until we hit the given boundary; |
| * process accordingly. |
| * |
| * @param pp post processor context |
| * @param ioffptr incremented based on the number of bytes processed |
| * @param boundary the boundary to look for |
| * @param blen strlen(boundary) |
| * @param next_state what state to go into after the |
| * boundary was found |
| * @param next_dash_state state to go into if the next |
| * boundary ends with "--" |
| * @return #MHD_YES if we can continue processing, |
| * #MHD_NO on error or if we do not have |
| * enough data yet |
| */ |
| static int |
| process_value_to_boundary (struct MHD_PostProcessor *pp, |
| size_t *ioffptr, |
| const char *boundary, |
| size_t blen, |
| enum PP_State next_state, |
| enum PP_State next_dash_state) |
| { |
| char *buf = (char *) &pp[1]; |
| size_t newline; |
| const char *r; |
| |
| /* all data in buf until the boundary |
| (\r\n--+boundary) is part of the value */ |
| newline = 0; |
| while (1) |
| { |
| while (newline + 4 < pp->buffer_pos) |
| { |
| r = memchr (&buf[newline], |
| '\r', |
| pp->buffer_pos - newline - 4); |
| if (NULL == r) |
| { |
| newline = pp->buffer_pos - 4; |
| break; |
| } |
| newline = (size_t) (r - buf); |
| if (0 == memcmp ("\r\n--", |
| &buf[newline], |
| 4)) |
| break; |
| newline++; |
| } |
| if (newline + blen + 4 <= pp->buffer_pos) |
| { |
| /* can check boundary */ |
| if (0 != memcmp (&buf[newline + 4], |
| boundary, |
| blen)) |
| { |
| /* no boundary, "\r\n--" is part of content, skip */ |
| newline += 4; |
| continue; |
| } |
| else |
| { |
| /* boundary found, process until newline then |
| skip boundary and go back to init */ |
| pp->skip_rn = RN_Dash; |
| pp->state = next_state; |
| pp->dash_state = next_dash_state; |
| (*ioffptr) += blen + 4; /* skip boundary as well */ |
| buf[newline] = '\0'; |
| break; |
| } |
| } |
| else |
| { |
| /* cannot check for boundary, process content that |
| we have and check again later; except, if we have |
| no content, abort (out of memory) */ |
| if ( (0 == newline) && |
| (pp->buffer_pos == pp->buffer_size) ) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; |
| } |
| break; |
| } |
| } |
| /* newline is either at beginning of boundary or |
| at least at the last character that we are sure |
| is not part of the boundary */ |
| if ( ( (pp->must_ikvi) || |
| (0 != newline) ) && |
| (MHD_NO == pp->ikvi (pp->cls, |
| MHD_POSTDATA_KIND, |
| pp->content_name, |
| pp->content_filename, |
| pp->content_type, |
| pp->content_transfer_encoding, |
| buf, |
| pp->value_offset, |
| newline)) ) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; |
| } |
| pp->must_ikvi = false; |
| pp->value_offset += newline; |
| (*ioffptr) += newline; |
| return MHD_YES; |
| } |
| |
| |
| /** |
| * |
| * @param pp post processor context |
| */ |
| static void |
| free_unmarked (struct MHD_PostProcessor *pp) |
| { |
| if ( (NULL != pp->content_name) && |
| (0 == (pp->have & NE_content_name)) ) |
| { |
| free (pp->content_name); |
| pp->content_name = NULL; |
| } |
| if ( (NULL != pp->content_type) && |
| (0 == (pp->have & NE_content_type)) ) |
| { |
| free (pp->content_type); |
| pp->content_type = NULL; |
| } |
| if ( (NULL != pp->content_filename) && |
| (0 == (pp->have & NE_content_filename)) ) |
| { |
| free (pp->content_filename); |
| pp->content_filename = NULL; |
| } |
| if ( (NULL != pp->content_transfer_encoding) && |
| (0 == (pp->have & NE_content_transfer_encoding)) ) |
| { |
| free (pp->content_transfer_encoding); |
| pp->content_transfer_encoding = NULL; |
| } |
| } |
| |
| |
| /** |
| * Decode multipart POST data. |
| * |
| * @param pp post processor context |
| * @param post_data data to decode |
| * @param post_data_len number of bytes in @a post_data |
| * @return #MHD_NO on error, |
| */ |
| static enum MHD_Result |
| post_process_multipart (struct MHD_PostProcessor *pp, |
| const char *post_data, |
| size_t post_data_len) |
| { |
| char *buf; |
| size_t max; |
| size_t ioff; |
| size_t poff; |
| int state_changed; |
| |
| buf = (char *) &pp[1]; |
| ioff = 0; |
| poff = 0; |
| state_changed = 1; |
| while ( (poff < post_data_len) || |
| ( (pp->buffer_pos > 0) && |
| (0 != state_changed) ) ) |
| { |
| /* first, move as much input data |
| as possible to our internal buffer */ |
| max = pp->buffer_size - pp->buffer_pos; |
| if (max > post_data_len - poff) |
| max = post_data_len - poff; |
| memcpy (&buf[pp->buffer_pos], |
| &post_data[poff], |
| max); |
| poff += max; |
| pp->buffer_pos += max; |
| if ( (0 == max) && |
| (0 == state_changed) && |
| (poff < post_data_len) ) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; /* out of memory */ |
| } |
| state_changed = 0; |
| |
| /* first state machine for '\r'-'\n' and '--' handling */ |
| switch (pp->skip_rn) |
| { |
| case RN_Inactive: |
| break; |
| case RN_OptN: |
| if (buf[0] == '\n') |
| { |
| ioff++; |
| pp->skip_rn = RN_Inactive; |
| goto AGAIN; |
| } |
| /* fall-through! */ |
| case RN_Dash: |
| if (buf[0] == '-') |
| { |
| ioff++; |
| pp->skip_rn = RN_Dash2; |
| goto AGAIN; |
| } |
| pp->skip_rn = RN_Full; |
| /* fall-through! */ |
| case RN_Full: |
| if (buf[0] == '\r') |
| { |
| if ( (pp->buffer_pos > 1) && |
| ('\n' == buf[1]) ) |
| { |
| pp->skip_rn = RN_Inactive; |
| ioff += 2; |
| } |
| else |
| { |
| pp->skip_rn = RN_OptN; |
| ioff++; |
| } |
| goto AGAIN; |
| } |
| if (buf[0] == '\n') |
| { |
| ioff++; |
| pp->skip_rn = RN_Inactive; |
| goto AGAIN; |
| } |
| pp->skip_rn = RN_Inactive; |
| pp->state = PP_Error; |
| return MHD_NO; /* no '\r\n' */ |
| case RN_Dash2: |
| if (buf[0] == '-') |
| { |
| ioff++; |
| pp->skip_rn = RN_Full; |
| pp->state = pp->dash_state; |
| goto AGAIN; |
| } |
| pp->state = PP_Error; |
| break; |
| } |
| |
| /* main state engine */ |
| switch (pp->state) |
| { |
| case PP_Error: |
| return MHD_NO; |
| case PP_Done: |
| /* did not expect to receive more data */ |
| pp->state = PP_Error; |
| return MHD_NO; |
| case PP_Init: |
| /** |
| * Per RFC2046 5.1.1 NOTE TO IMPLEMENTORS, consume anything |
| * prior to the first multipart boundary: |
| * |
| * > There appears to be room for additional information prior |
| * > to the first boundary delimiter line and following the |
| * > final boundary delimiter line. These areas should |
| * > generally be left blank, and implementations must ignore |
| * > anything that appears before the first boundary delimiter |
| * > line or after the last one. |
| */ |
| (void) find_boundary (pp, |
| pp->boundary, |
| pp->blen, |
| &ioff, |
| PP_ProcessEntryHeaders, |
| PP_Done); |
| break; |
| case PP_NextBoundary: |
| if (MHD_NO == find_boundary (pp, |
| pp->boundary, |
| pp->blen, |
| &ioff, |
| PP_ProcessEntryHeaders, |
| PP_Done)) |
| { |
| if (pp->state == PP_Error) |
| return MHD_NO; |
| goto END; |
| } |
| break; |
| case PP_ProcessEntryHeaders: |
| pp->must_ikvi = true; |
| if (MHD_NO == |
| process_multipart_headers (pp, |
| &ioff, |
| PP_PerformCheckMultipart)) |
| { |
| if (pp->state == PP_Error) |
| return MHD_NO; |
| else |
| goto END; |
| } |
| state_changed = 1; |
| break; |
| case PP_PerformCheckMultipart: |
| if ( (NULL != pp->content_type) && |
| (MHD_str_equal_caseless_n_ (pp->content_type, |
| "multipart/mixed", |
| MHD_STATICSTR_LEN_ ("multipart/mixed")))) |
| { |
| pp->nested_boundary = strstr (pp->content_type, |
| "boundary="); |
| if (NULL == pp->nested_boundary) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; |
| } |
| pp->nested_boundary = |
| strdup (&pp->nested_boundary[MHD_STATICSTR_LEN_ ("boundary=")]); |
| if (NULL == pp->nested_boundary) |
| { |
| /* out of memory */ |
| pp->state = PP_Error; |
| return MHD_NO; |
| } |
| /* free old content type, we will need that field |
| for the content type of the nested elements */ |
| free (pp->content_type); |
| pp->content_type = NULL; |
| pp->nlen = strlen (pp->nested_boundary); |
| pp->state = PP_Nested_Init; |
| state_changed = 1; |
| break; |
| } |
| pp->state = PP_ProcessValueToBoundary; |
| pp->value_offset = 0; |
| state_changed = 1; |
| break; |
| case PP_ProcessValueToBoundary: |
| if (MHD_NO == process_value_to_boundary (pp, |
| &ioff, |
| pp->boundary, |
| pp->blen, |
| PP_PerformCleanup, |
| PP_Done)) |
| { |
| if (pp->state == PP_Error) |
| return MHD_NO; |
| break; |
| } |
| break; |
| case PP_PerformCleanup: |
| /* clean up state of one multipart form-data element! */ |
| pp->have = NE_none; |
| free_unmarked (pp); |
| if (NULL != pp->nested_boundary) |
| { |
| free (pp->nested_boundary); |
| pp->nested_boundary = NULL; |
| } |
| pp->state = PP_ProcessEntryHeaders; |
| state_changed = 1; |
| break; |
| case PP_Nested_Init: |
| if (NULL == pp->nested_boundary) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; |
| } |
| if (MHD_NO == find_boundary (pp, |
| pp->nested_boundary, |
| pp->nlen, |
| &ioff, |
| PP_Nested_PerformMarking, |
| PP_NextBoundary /* or PP_Error? */)) |
| { |
| if (pp->state == PP_Error) |
| return MHD_NO; |
| goto END; |
| } |
| break; |
| case PP_Nested_PerformMarking: |
| /* remember what headers were given |
| globally */ |
| pp->have = NE_none; |
| if (NULL != pp->content_name) |
| pp->have |= NE_content_name; |
| if (NULL != pp->content_type) |
| pp->have |= NE_content_type; |
| if (NULL != pp->content_filename) |
| pp->have |= NE_content_filename; |
| if (NULL != pp->content_transfer_encoding) |
| pp->have |= NE_content_transfer_encoding; |
| pp->state = PP_Nested_ProcessEntryHeaders; |
| state_changed = 1; |
| break; |
| case PP_Nested_ProcessEntryHeaders: |
| pp->value_offset = 0; |
| if (MHD_NO == |
| process_multipart_headers (pp, |
| &ioff, |
| PP_Nested_ProcessValueToBoundary)) |
| { |
| if (pp->state == PP_Error) |
| return MHD_NO; |
| else |
| goto END; |
| } |
| state_changed = 1; |
| break; |
| case PP_Nested_ProcessValueToBoundary: |
| if (MHD_NO == process_value_to_boundary (pp, |
| &ioff, |
| pp->nested_boundary, |
| pp->nlen, |
| PP_Nested_PerformCleanup, |
| PP_NextBoundary)) |
| { |
| if (pp->state == PP_Error) |
| return MHD_NO; |
| break; |
| } |
| break; |
| case PP_Nested_PerformCleanup: |
| free_unmarked (pp); |
| pp->state = PP_Nested_ProcessEntryHeaders; |
| state_changed = 1; |
| break; |
| case PP_ProcessKey: |
| case PP_ProcessValue: |
| case PP_Callback: |
| default: |
| MHD_PANIC (_ ("internal error.\n")); /* should never happen! */ |
| } |
| AGAIN: |
| if (ioff > 0) |
| { |
| memmove (buf, |
| &buf[ioff], |
| pp->buffer_pos - ioff); |
| pp->buffer_pos -= ioff; |
| ioff = 0; |
| state_changed = 1; |
| } |
| } |
| END: |
| if (0 != ioff) |
| { |
| memmove (buf, |
| &buf[ioff], |
| pp->buffer_pos - ioff); |
| pp->buffer_pos -= ioff; |
| } |
| if (poff < post_data_len) |
| { |
| pp->state = PP_Error; |
| return MHD_NO; /* serious error */ |
| } |
| return MHD_YES; |
| } |
| |
| |
| _MHD_EXTERN enum MHD_Result |
| MHD_post_process (struct MHD_PostProcessor *pp, |
| const char *post_data, |
| size_t post_data_len) |
| { |
| if (0 == post_data_len) |
| return MHD_YES; |
| if (NULL == pp) |
| return MHD_NO; |
| if (MHD_str_equal_caseless_n_ (MHD_HTTP_POST_ENCODING_FORM_URLENCODED, |
| pp->encoding, |
| MHD_STATICSTR_LEN_ ( |
| MHD_HTTP_POST_ENCODING_FORM_URLENCODED))) |
| return post_process_urlencoded (pp, |
| post_data, |
| post_data_len); |
| if (MHD_str_equal_caseless_n_ (MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA, |
| pp->encoding, |
| MHD_STATICSTR_LEN_ ( |
| MHD_HTTP_POST_ENCODING_MULTIPART_FORMDATA))) |
| return post_process_multipart (pp, |
| post_data, |
| post_data_len); |
| /* this should never be reached */ |
| return MHD_NO; |
| } |
| |
| |
| _MHD_EXTERN enum MHD_Result |
| MHD_destroy_post_processor (struct MHD_PostProcessor *pp) |
| { |
| enum MHD_Result ret; |
| |
| if (NULL == pp) |
| return MHD_YES; |
| if (PP_ProcessValue == pp->state) |
| { |
| /* key without terminated value left at the end of the |
| buffer; fake receiving a termination character to |
| ensure it is also processed */ |
| post_process_urlencoded (pp, |
| "\n", |
| 1); |
| } |
| /* These internal strings need cleaning up since |
| the post-processing may have been interrupted |
| at any stage */ |
| if ( (pp->xbuf_pos > 0) || |
| ( (pp->state != PP_Done) && |
| (pp->state != PP_Init) ) ) |
| ret = MHD_NO; |
| else |
| ret = MHD_YES; |
| pp->have = NE_none; |
| free_unmarked (pp); |
| if (NULL != pp->nested_boundary) |
| free (pp->nested_boundary); |
| free (pp); |
| return ret; |
| } |
| |
| |
| /* end of postprocessor.c */ |
