mirror of https://github.com/ventoy/Ventoy
794 lines
22 KiB
C++
794 lines
22 KiB
C++
/* Copyright (c) 2016 the Civetweb developers
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
|
|
static int
|
|
url_encoded_field_found(const struct mg_connection *conn,
|
|
const char *key,
|
|
size_t key_len,
|
|
const char *filename,
|
|
size_t filename_len,
|
|
char *path,
|
|
size_t path_len,
|
|
struct mg_form_data_handler *fdh)
|
|
{
|
|
char key_dec[1024];
|
|
char filename_dec[1024];
|
|
int key_dec_len;
|
|
int filename_dec_len;
|
|
int ret;
|
|
|
|
key_dec_len =
|
|
mg_url_decode(key, (int)key_len, key_dec, (int)sizeof(key_dec), 1);
|
|
|
|
if (((size_t)key_dec_len >= (size_t)sizeof(key_dec)) || (key_dec_len < 0)) {
|
|
return FORM_FIELD_STORAGE_SKIP;
|
|
}
|
|
|
|
if (filename) {
|
|
filename_dec_len = mg_url_decode(filename,
|
|
(int)filename_len,
|
|
filename_dec,
|
|
(int)sizeof(filename_dec),
|
|
1);
|
|
|
|
if (((size_t)filename_dec_len >= (size_t)sizeof(filename_dec))
|
|
|| (filename_dec_len < 0)) {
|
|
/* Log error message and skip this field. */
|
|
mg_cry(conn, "%s: Cannot decode filename", __func__);
|
|
return FORM_FIELD_STORAGE_SKIP;
|
|
}
|
|
} else {
|
|
filename_dec[0] = 0;
|
|
}
|
|
|
|
ret =
|
|
fdh->field_found(key_dec, filename_dec, path, path_len, fdh->user_data);
|
|
|
|
if ((ret & 0xF) == FORM_FIELD_STORAGE_GET) {
|
|
if (fdh->field_get == NULL) {
|
|
mg_cry(conn, "%s: Function \"Get\" not available", __func__);
|
|
return FORM_FIELD_STORAGE_SKIP;
|
|
}
|
|
}
|
|
if ((ret & 0xF) == FORM_FIELD_STORAGE_STORE) {
|
|
if (fdh->field_store == NULL) {
|
|
mg_cry(conn, "%s: Function \"Store\" not available", __func__);
|
|
return FORM_FIELD_STORAGE_SKIP;
|
|
}
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
|
|
static int
|
|
url_encoded_field_get(const struct mg_connection *conn,
|
|
const char *key,
|
|
size_t key_len,
|
|
const char *value,
|
|
size_t value_len,
|
|
struct mg_form_data_handler *fdh)
|
|
{
|
|
char key_dec[1024];
|
|
|
|
char *value_dec = mg_malloc(value_len + 1);
|
|
int value_dec_len;
|
|
|
|
if (!value_dec) {
|
|
/* Log error message and stop parsing the form data. */
|
|
mg_cry(conn,
|
|
"%s: Not enough memory (required: %lu)",
|
|
__func__,
|
|
(unsigned long)(value_len + 1));
|
|
return FORM_FIELD_STORAGE_ABORT;
|
|
}
|
|
|
|
mg_url_decode(key, (int)key_len, key_dec, (int)sizeof(key_dec), 1);
|
|
|
|
value_dec_len =
|
|
mg_url_decode(value, (int)value_len, value_dec, (int)value_len + 1, 1);
|
|
|
|
return fdh->field_get(key_dec,
|
|
value_dec,
|
|
(size_t)value_dec_len,
|
|
fdh->user_data);
|
|
}
|
|
|
|
|
|
static int
|
|
field_stored(const struct mg_connection *conn,
|
|
const char *path,
|
|
long long file_size,
|
|
struct mg_form_data_handler *fdh)
|
|
{
|
|
/* Equivalent to "upload" callback of "mg_upload". */
|
|
|
|
(void)conn; /* we do not need mg_cry here, so conn is currently unused */
|
|
|
|
return fdh->field_store(path, file_size, fdh->user_data);
|
|
}
|
|
|
|
|
|
static const char *
|
|
search_boundary(const char *buf,
|
|
size_t buf_len,
|
|
const char *boundary,
|
|
size_t boundary_len)
|
|
{
|
|
/* We must do a binary search here, not a string search, since the buffer
|
|
* may contain '\x00' bytes, if binary data is transferred. */
|
|
int clen = (int)buf_len - (int)boundary_len - 4;
|
|
int i;
|
|
|
|
for (i = 0; i <= clen; i++) {
|
|
if (!memcmp(buf + i, "\r\n--", 4)) {
|
|
if (!memcmp(buf + i + 4, boundary, boundary_len)) {
|
|
return buf + i;
|
|
}
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int
|
|
mg_handle_form_request(struct mg_connection *conn,
|
|
struct mg_form_data_handler *fdh)
|
|
{
|
|
const char *content_type;
|
|
char path[512];
|
|
char buf[1024];
|
|
int field_storage;
|
|
int buf_fill = 0;
|
|
int r;
|
|
int field_count = 0;
|
|
struct file fstore = STRUCT_FILE_INITIALIZER;
|
|
int64_t file_size = 0; /* init here, to a avoid a false positive
|
|
"uninitialized variable used" warning */
|
|
|
|
int has_body_data =
|
|
(conn->request_info.content_length > 0) || (conn->is_chunked);
|
|
|
|
/* There are three ways to encode data from a HTML form:
|
|
* 1) method: GET (default)
|
|
* The form data is in the HTTP query string.
|
|
* 2) method: POST, enctype: "application/x-www-form-urlencoded"
|
|
* The form data is in the request body.
|
|
* The body is url encoded (the default encoding for POST).
|
|
* 3) method: POST, enctype: "multipart/form-data".
|
|
* The form data is in the request body of a multipart message.
|
|
* This is the typical way to handle file upload from a form.
|
|
*/
|
|
|
|
if (!has_body_data) {
|
|
const char *data;
|
|
|
|
if (strcmp(conn->request_info.request_method, "GET")) {
|
|
/* No body data, but not a GET request.
|
|
* This is not a valid form request. */
|
|
return -1;
|
|
}
|
|
|
|
/* GET request: form data is in the query string. */
|
|
/* The entire data has already been loaded, so there is no nead to
|
|
* call mg_read. We just need to split the query string into key-value
|
|
* pairs. */
|
|
data = conn->request_info.query_string;
|
|
if (!data) {
|
|
/* No query string. */
|
|
return -1;
|
|
}
|
|
|
|
/* Split data in a=1&b=xy&c=3&c=4 ... */
|
|
while (*data) {
|
|
const char *val = strchr(data, '=');
|
|
const char *next;
|
|
ptrdiff_t keylen, vallen;
|
|
|
|
if (!val) {
|
|
break;
|
|
}
|
|
keylen = val - data;
|
|
|
|
/* In every "field_found" callback we ask what to do with the
|
|
* data ("field_storage"). This could be:
|
|
* FORM_FIELD_STORAGE_SKIP (0) ... ignore the value of this field
|
|
* FORM_FIELD_STORAGE_GET (1) ... read the data and call the get
|
|
* callback function
|
|
* FORM_FIELD_STORAGE_STORE (2) ... store the data in a file
|
|
* FORM_FIELD_STORAGE_READ (3) ... let the user read the data
|
|
* (for parsing long data on the fly)
|
|
* (currently not implemented)
|
|
* FORM_FIELD_STORAGE_ABORT (flag) ... stop parsing
|
|
*/
|
|
memset(path, 0, sizeof(path));
|
|
field_count++;
|
|
field_storage = url_encoded_field_found(conn,
|
|
data,
|
|
(size_t)keylen,
|
|
NULL,
|
|
0,
|
|
path,
|
|
sizeof(path) - 1,
|
|
fdh);
|
|
|
|
val++;
|
|
next = strchr(val, '&');
|
|
if (next) {
|
|
vallen = next - val;
|
|
next++;
|
|
} else {
|
|
vallen = (ptrdiff_t)strlen(val);
|
|
next = val + vallen;
|
|
}
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_GET) {
|
|
/* Call callback */
|
|
url_encoded_field_get(
|
|
conn, data, (size_t)keylen, val, (size_t)vallen, fdh);
|
|
}
|
|
if (field_storage == FORM_FIELD_STORAGE_STORE) {
|
|
/* Store the content to a file */
|
|
if (mg_fopen(conn, path, "wb", &fstore) == 0) {
|
|
fstore.fp = NULL;
|
|
}
|
|
file_size = 0;
|
|
if (fstore.fp != NULL) {
|
|
size_t n =
|
|
(size_t)fwrite(val, 1, (size_t)vallen, fstore.fp);
|
|
if ((n != (size_t)vallen) || (ferror(fstore.fp))) {
|
|
mg_cry(conn,
|
|
"%s: Cannot write file %s",
|
|
__func__,
|
|
path);
|
|
fclose(fstore.fp);
|
|
fstore.fp = NULL;
|
|
remove_bad_file(conn, path);
|
|
}
|
|
file_size += (int64_t)n;
|
|
|
|
if (fstore.fp) {
|
|
r = fclose(fstore.fp);
|
|
if (r == 0) {
|
|
/* stored successfully */
|
|
field_stored(conn, path, file_size, fdh);
|
|
} else {
|
|
mg_cry(conn,
|
|
"%s: Error saving file %s",
|
|
__func__,
|
|
path);
|
|
remove_bad_file(conn, path);
|
|
}
|
|
fstore.fp = NULL;
|
|
}
|
|
|
|
} else {
|
|
mg_cry(conn, "%s: Cannot create file %s", __func__, path);
|
|
}
|
|
}
|
|
|
|
/* if (field_storage == FORM_FIELD_STORAGE_READ) { */
|
|
/* The idea of "field_storage=read" is to let the API user read
|
|
* data chunk by chunk and to some data processing on the fly.
|
|
* This should avoid the need to store data in the server:
|
|
* It should neither be stored in memory, like
|
|
* "field_storage=get" does, nor in a file like
|
|
* "field_storage=store".
|
|
* However, for a "GET" request this does not make any much
|
|
* sense, since the data is already stored in memory, as it is
|
|
* part of the query string.
|
|
*/
|
|
/* } */
|
|
|
|
if ((field_storage & FORM_FIELD_STORAGE_ABORT)
|
|
== FORM_FIELD_STORAGE_ABORT) {
|
|
/* Stop parsing the request */
|
|
break;
|
|
}
|
|
|
|
/* Proceed to next entry */
|
|
data = next;
|
|
}
|
|
|
|
return field_count;
|
|
}
|
|
|
|
content_type = mg_get_header(conn, "Content-Type");
|
|
|
|
if (!content_type
|
|
|| !mg_strcasecmp(content_type, "APPLICATION/X-WWW-FORM-URLENCODED")
|
|
|| !mg_strcasecmp(content_type, "APPLICATION/WWW-FORM-URLENCODED")) {
|
|
/* The form data is in the request body data, encoded in key/value
|
|
* pairs. */
|
|
int all_data_read = 0;
|
|
|
|
/* Read body data and split it in keys and values.
|
|
* The encoding is like in the "GET" case above: a=1&b&c=3&c=4.
|
|
* Here we use "POST", and read the data from the request body.
|
|
* The data read on the fly, so it is not required to buffer the
|
|
* entire request in memory before processing it. */
|
|
for (;;) {
|
|
const char *val;
|
|
const char *next;
|
|
ptrdiff_t keylen, vallen;
|
|
ptrdiff_t used;
|
|
int end_of_key_value_pair_found = 0;
|
|
int get_block;
|
|
|
|
if ((size_t)buf_fill < (sizeof(buf) - 1)) {
|
|
|
|
size_t to_read = sizeof(buf) - 1 - (size_t)buf_fill;
|
|
r = mg_read(conn, buf + (size_t)buf_fill, to_read);
|
|
if (r < 0) {
|
|
/* read error */
|
|
return -1;
|
|
}
|
|
if (r != (int)to_read) {
|
|
/* TODO: Create a function to get "all_data_read" from
|
|
* the conn object. All data is read if the Content-Length
|
|
* has been reached, or if chunked encoding is used and
|
|
* the end marker has been read, or if the connection has
|
|
* been closed. */
|
|
all_data_read = 1;
|
|
}
|
|
buf_fill += r;
|
|
buf[buf_fill] = 0;
|
|
if (buf_fill < 1) {
|
|
break;
|
|
}
|
|
}
|
|
|
|
val = strchr(buf, '=');
|
|
|
|
if (!val) {
|
|
break;
|
|
}
|
|
keylen = val - buf;
|
|
val++;
|
|
|
|
/* Call callback */
|
|
memset(path, 0, sizeof(path));
|
|
field_count++;
|
|
field_storage = url_encoded_field_found(conn,
|
|
buf,
|
|
(size_t)keylen,
|
|
NULL,
|
|
0,
|
|
path,
|
|
sizeof(path) - 1,
|
|
fdh);
|
|
|
|
if ((field_storage & FORM_FIELD_STORAGE_ABORT)
|
|
== FORM_FIELD_STORAGE_ABORT) {
|
|
/* Stop parsing the request */
|
|
break;
|
|
}
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_STORE) {
|
|
if (mg_fopen(conn, path, "wb", &fstore) == 0) {
|
|
fstore.fp = NULL;
|
|
}
|
|
file_size = 0;
|
|
if (!fstore.fp) {
|
|
mg_cry(conn, "%s: Cannot create file %s", __func__, path);
|
|
}
|
|
}
|
|
|
|
get_block = 0;
|
|
/* Loop to read values larger than sizeof(buf)-keylen-2 */
|
|
do {
|
|
next = strchr(val, '&');
|
|
if (next) {
|
|
vallen = next - val;
|
|
next++;
|
|
end_of_key_value_pair_found = 1;
|
|
} else {
|
|
vallen = (ptrdiff_t)strlen(val);
|
|
next = val + vallen;
|
|
}
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_GET) {
|
|
#if 0
|
|
if (!end_of_key_value_pair_found && !all_data_read) {
|
|
/* This callback will deliver partial contents */
|
|
}
|
|
#else
|
|
(void)all_data_read; /* avoid warning */
|
|
#endif
|
|
|
|
/* Call callback */
|
|
url_encoded_field_get(conn,
|
|
((get_block > 0) ? NULL : buf),
|
|
((get_block > 0) ? 0
|
|
: (size_t)keylen),
|
|
val,
|
|
(size_t)vallen,
|
|
fdh);
|
|
get_block++;
|
|
}
|
|
if (fstore.fp) {
|
|
size_t n =
|
|
(size_t)fwrite(val, 1, (size_t)vallen, fstore.fp);
|
|
if ((n != (size_t)vallen) || (ferror(fstore.fp))) {
|
|
mg_cry(conn,
|
|
"%s: Cannot write file %s",
|
|
__func__,
|
|
path);
|
|
fclose(fstore.fp);
|
|
fstore.fp = NULL;
|
|
remove_bad_file(conn, path);
|
|
}
|
|
file_size += (int64_t)n;
|
|
}
|
|
|
|
if (!end_of_key_value_pair_found) {
|
|
used = next - buf;
|
|
memmove(buf,
|
|
buf + (size_t)used,
|
|
sizeof(buf) - (size_t)used);
|
|
buf_fill -= (int)used;
|
|
if ((size_t)buf_fill < (sizeof(buf) - 1)) {
|
|
|
|
size_t to_read = sizeof(buf) - 1 - (size_t)buf_fill;
|
|
r = mg_read(conn, buf + (size_t)buf_fill, to_read);
|
|
if (r < 0) {
|
|
/* read error */
|
|
return -1;
|
|
}
|
|
if (r != (int)to_read) {
|
|
/* TODO: Create a function to get "all_data_read"
|
|
* from the conn object. All data is read if the
|
|
* Content-Length has been reached, or if chunked
|
|
* encoding is used and the end marker has been
|
|
* read, or if the connection has been closed. */
|
|
all_data_read = 1;
|
|
}
|
|
buf_fill += r;
|
|
buf[buf_fill] = 0;
|
|
if (buf_fill < 1) {
|
|
break;
|
|
}
|
|
val = buf;
|
|
}
|
|
}
|
|
|
|
} while (!end_of_key_value_pair_found);
|
|
|
|
if (fstore.fp) {
|
|
r = fclose(fstore.fp);
|
|
if (r == 0) {
|
|
/* stored successfully */
|
|
field_stored(conn, path, file_size, fdh);
|
|
} else {
|
|
mg_cry(conn, "%s: Error saving file %s", __func__, path);
|
|
remove_bad_file(conn, path);
|
|
}
|
|
fstore.fp = NULL;
|
|
}
|
|
|
|
/* Proceed to next entry */
|
|
used = next - buf;
|
|
memmove(buf, buf + (size_t)used, sizeof(buf) - (size_t)used);
|
|
buf_fill -= (int)used;
|
|
}
|
|
|
|
return field_count;
|
|
}
|
|
|
|
if (!mg_strncasecmp(content_type, "MULTIPART/FORM-DATA;", 20)) {
|
|
/* The form data is in the request body data, encoded as multipart
|
|
* content (see https://www.ietf.org/rfc/rfc1867.txt,
|
|
* https://www.ietf.org/rfc/rfc2388.txt). */
|
|
const char *boundary;
|
|
size_t bl;
|
|
ptrdiff_t used;
|
|
struct mg_request_info part_header;
|
|
char *hbuf, *hend, *fbeg, *fend, *nbeg, *nend;
|
|
const char *content_disp;
|
|
const char *next;
|
|
|
|
memset(&part_header, 0, sizeof(part_header));
|
|
|
|
/* Skip all spaces between MULTIPART/FORM-DATA; and BOUNDARY= */
|
|
bl = 20;
|
|
while (content_type[bl] == ' ') {
|
|
bl++;
|
|
}
|
|
|
|
/* There has to be a BOUNDARY definition in the Content-Type header */
|
|
if (mg_strncasecmp(content_type + bl, "BOUNDARY=", 9)) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
|
|
boundary = content_type + bl + 9;
|
|
bl = strlen(boundary);
|
|
|
|
if (bl + 800 > sizeof(buf)) {
|
|
/* Sanity check: The algorithm can not work if bl >= sizeof(buf),
|
|
* and it will not work effectively, if the buf is only a few byte
|
|
* larger than bl, or it buf can not hold the multipart header
|
|
* plus the boundary.
|
|
* Check some reasonable number here, that should be fulfilled by
|
|
* any reasonable request from every browser. If it is not
|
|
* fulfilled, it might be a hand-made request, intended to
|
|
* interfere with the algorithm. */
|
|
return -1;
|
|
}
|
|
|
|
for (;;) {
|
|
size_t towrite, n;
|
|
int get_block;
|
|
|
|
r = mg_read(conn,
|
|
buf + (size_t)buf_fill,
|
|
sizeof(buf) - 1 - (size_t)buf_fill);
|
|
if (r < 0) {
|
|
/* read error */
|
|
return -1;
|
|
}
|
|
buf_fill += r;
|
|
buf[buf_fill] = 0;
|
|
if (buf_fill < 1) {
|
|
/* No data */
|
|
return -1;
|
|
}
|
|
|
|
if (buf[0] != '-' || buf[1] != '-') {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
if (strncmp(buf + 2, boundary, bl)) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
if (buf[bl + 2] != '\r' || buf[bl + 3] != '\n') {
|
|
/* Every part must end with \r\n, if there is another part.
|
|
* The end of the request has an extra -- */
|
|
if (((size_t)buf_fill != (size_t)(bl + 6))
|
|
|| (strncmp(buf + bl + 2, "--\r\n", 4))) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
/* End of the request */
|
|
break;
|
|
}
|
|
|
|
/* Next, we need to get the part header: Read until \r\n\r\n */
|
|
hbuf = buf + bl + 4;
|
|
hend = strstr(hbuf, "\r\n\r\n");
|
|
if (!hend) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
|
|
parse_http_headers(&hbuf, &part_header);
|
|
if ((hend + 2) != hbuf) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
|
|
/* Skip \r\n\r\n */
|
|
hend += 4;
|
|
|
|
/* According to the RFC, every part has to have a header field like:
|
|
* Content-Disposition: form-data; name="..." */
|
|
content_disp = get_header(&part_header, "Content-Disposition");
|
|
if (!content_disp) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
|
|
/* Get the mandatory name="..." part of the Content-Disposition
|
|
* header. */
|
|
nbeg = strstr(content_disp, "name=\"");
|
|
if (!nbeg) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
nbeg += 6;
|
|
nend = strchr(nbeg, '\"');
|
|
if (!nend) {
|
|
/* Malformed request */
|
|
return -1;
|
|
}
|
|
|
|
/* Get the optional filename="..." part of the Content-Disposition
|
|
* header. */
|
|
fbeg = strstr(content_disp, "filename=\"");
|
|
if (fbeg) {
|
|
fbeg += 10;
|
|
fend = strchr(fbeg, '\"');
|
|
if (!fend) {
|
|
/* Malformed request (the filename field is optional, but if
|
|
* it exists, it needs to be terminated correctly). */
|
|
return -1;
|
|
}
|
|
|
|
/* TODO: check Content-Type */
|
|
/* Content-Type: application/octet-stream */
|
|
|
|
} else {
|
|
fend = fbeg;
|
|
}
|
|
|
|
memset(path, 0, sizeof(path));
|
|
field_count++;
|
|
field_storage = url_encoded_field_found(conn,
|
|
nbeg,
|
|
(size_t)(nend - nbeg),
|
|
fbeg,
|
|
(size_t)(fend - fbeg),
|
|
path,
|
|
sizeof(path) - 1,
|
|
fdh);
|
|
|
|
/* If the boundary is already in the buffer, get the address,
|
|
* otherwise next will be NULL. */
|
|
next = search_boundary(hbuf,
|
|
(size_t)((buf - hbuf) + buf_fill),
|
|
boundary,
|
|
bl);
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_STORE) {
|
|
/* Store the content to a file */
|
|
if (mg_fopen(conn, path, "wb", &fstore) == 0) {
|
|
fstore.fp = NULL;
|
|
}
|
|
file_size = 0;
|
|
|
|
if (!fstore.fp) {
|
|
mg_cry(conn, "%s: Cannot create file %s", __func__, path);
|
|
}
|
|
}
|
|
|
|
get_block = 0;
|
|
while (!next) {
|
|
/* Set "towrite" to the number of bytes available
|
|
* in the buffer */
|
|
towrite = (size_t)(buf - hend + buf_fill);
|
|
/* Subtract the boundary length, to deal with
|
|
* cases the boundary is only partially stored
|
|
* in the buffer. */
|
|
towrite -= bl + 4;
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_GET) {
|
|
url_encoded_field_get(conn,
|
|
((get_block > 0) ? NULL : nbeg),
|
|
((get_block > 0)
|
|
? 0
|
|
: (size_t)(nend - nbeg)),
|
|
hend,
|
|
towrite,
|
|
fdh);
|
|
get_block++;
|
|
}
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_STORE) {
|
|
if (fstore.fp) {
|
|
|
|
/* Store the content of the buffer. */
|
|
n = (size_t)fwrite(hend, 1, towrite, fstore.fp);
|
|
if ((n != towrite) || (ferror(fstore.fp))) {
|
|
mg_cry(conn,
|
|
"%s: Cannot write file %s",
|
|
__func__,
|
|
path);
|
|
fclose(fstore.fp);
|
|
fstore.fp = NULL;
|
|
remove_bad_file(conn, path);
|
|
}
|
|
file_size += (int64_t)n;
|
|
}
|
|
}
|
|
|
|
memmove(buf, hend + towrite, bl + 4);
|
|
buf_fill = (int)(bl + 4);
|
|
hend = buf;
|
|
|
|
/* Read new data */
|
|
r = mg_read(conn,
|
|
buf + (size_t)buf_fill,
|
|
sizeof(buf) - 1 - (size_t)buf_fill);
|
|
if (r < 0) {
|
|
/* read error */
|
|
return -1;
|
|
}
|
|
buf_fill += r;
|
|
buf[buf_fill] = 0;
|
|
if (buf_fill < 1) {
|
|
/* No data */
|
|
return -1;
|
|
}
|
|
|
|
/* Find boundary */
|
|
next = search_boundary(buf, (size_t)buf_fill, boundary, bl);
|
|
}
|
|
|
|
towrite = (size_t)(next - hend);
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_GET) {
|
|
/* Call callback */
|
|
url_encoded_field_get(conn,
|
|
((get_block > 0) ? NULL : nbeg),
|
|
((get_block > 0) ? 0
|
|
: (size_t)(nend - nbeg)),
|
|
hend,
|
|
towrite,
|
|
fdh);
|
|
}
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_STORE) {
|
|
|
|
if (fstore.fp) {
|
|
n = (size_t)fwrite(hend, 1, towrite, fstore.fp);
|
|
if ((n != towrite) || (ferror(fstore.fp))) {
|
|
mg_cry(conn,
|
|
"%s: Cannot write file %s",
|
|
__func__,
|
|
path);
|
|
fclose(fstore.fp);
|
|
fstore.fp = NULL;
|
|
remove_bad_file(conn, path);
|
|
}
|
|
file_size += (int64_t)n;
|
|
}
|
|
}
|
|
|
|
if (field_storage == FORM_FIELD_STORAGE_STORE) {
|
|
|
|
if (fstore.fp) {
|
|
r = fclose(fstore.fp);
|
|
if (r == 0) {
|
|
/* stored successfully */
|
|
field_stored(conn, path, file_size, fdh);
|
|
} else {
|
|
mg_cry(conn,
|
|
"%s: Error saving file %s",
|
|
__func__,
|
|
path);
|
|
remove_bad_file(conn, path);
|
|
}
|
|
fstore.fp = NULL;
|
|
}
|
|
}
|
|
|
|
if ((field_storage & FORM_FIELD_STORAGE_ABORT)
|
|
== FORM_FIELD_STORAGE_ABORT) {
|
|
/* Stop parsing the request */
|
|
break;
|
|
}
|
|
|
|
/* Remove from the buffer */
|
|
used = next - buf + 2;
|
|
memmove(buf, buf + (size_t)used, sizeof(buf) - (size_t)used);
|
|
buf_fill -= (int)used;
|
|
}
|
|
|
|
/* All parts handled */
|
|
return field_count;
|
|
}
|
|
|
|
/* Unknown Content-Type */
|
|
return -1;
|
|
}
|