handle_form.inl

Go to the documentation of this file.

/* Copyright (c) 2016-2021 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 MG_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_internal(conn, "%s: Cannot decode filename", __func__);
         return MG_FORM_FIELD_STORAGE_SKIP;
      }
      remove_dot_segments(filename_dec);
 
   } else {
      filename_dec[0] = 0;
   }
 
   ret =
       fdh->field_found(key_dec, filename_dec, path, path_len, fdh->user_data);
 
   if ((ret & 0xF) == MG_FORM_FIELD_STORAGE_GET) {
      if (fdh->field_get == NULL) {
         mg_cry_internal(conn,
                         "%s: Function \"Get\" not available",
                         __func__);
         return MG_FORM_FIELD_STORAGE_SKIP;
      }
   }
   if ((ret & 0xF) == MG_FORM_FIELD_STORAGE_STORE) {
      if (fdh->field_store == NULL) {
         mg_cry_internal(conn,
                         "%s: Function \"Store\" not available",
                         __func__);
         return MG_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, /* IN: number of bytes available in "value", OUT: number
                          of bytes processed */
    struct mg_form_data_handler *fdh)
{
   char key_dec[1024];
 
   char *value_dec = (char *)mg_malloc_ctx(*value_len + 1, conn->phys_ctx);
   int value_dec_len, ret;
 
   if (!value_dec) {
      /* Log error message and stop parsing the form data. */
      mg_cry_internal(conn,
                      "%s: Not enough memory (required: %lu)",
                      __func__,
                      (unsigned long)(*value_len + 1));
      return MG_FORM_FIELD_STORAGE_ABORT;
   }
 
   mg_url_decode(key, (int)key_len, key_dec, (int)sizeof(key_dec), 1);
 
   if (*value_len >= 2 && value[*value_len - 2] == '%')
      *value_len -= 2;
   else if (*value_len >= 1 && value[*value_len - 1] == '%')
      (*value_len)--;
   value_dec_len = mg_url_decode(
       value, (int)*value_len, value_dec, ((int)*value_len) + 1, 1);
 
   ret = fdh->field_get(key_dec,
                        value_dec,
                        (size_t)value_dec_len,
                        fdh->user_data);
 
   mg_free(value_dec);
 
   return ret;
}
 
static int
unencoded_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];
   (void)conn;
 
   mg_url_decode(key, (int)key_len, key_dec, (int)sizeof(key_dec), 1);
 
   return fdh->field_get(key_dec, value, value_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[MG_BUF_LEN]; /* Must not be smaller than ~900 */
   int field_storage;
   int buf_fill = 0;
   int r;
   int field_count = 0;
   struct mg_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);
 
   /* Unused without filesystems */
   (void)fstore;
   (void)file_size;
 
   /* 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 (0 != 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:
          * MG_FORM_FIELD_STORAGE_SKIP (0):
          *   ignore the value of this field
          * MG_FORM_FIELD_STORAGE_GET (1):
          *   read the data and call the get callback function
          * MG_FORM_FIELD_STORAGE_STORE (2):
          *   store the data in a file
          * MG_FORM_FIELD_STORAGE_READ (3):
          *   let the user read the data (for parsing long data on the fly)
          * MG_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;
         } else {
            vallen = (ptrdiff_t)strlen(val);
         }
 
         if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
            /* Call callback */
            r = url_encoded_field_get(
                conn, data, (size_t)keylen, val, (size_t *)&vallen, fdh);
            if (r == MG_FORM_FIELD_HANDLE_ABORT) {
               /* Stop request handling */
               break;
            }
            if (r == MG_FORM_FIELD_HANDLE_NEXT) {
               /* Skip to next field */
               field_storage = MG_FORM_FIELD_STORAGE_SKIP;
            }
         }
 
         if (next) {
            next++;
         } else {
            /* vallen may have been modified by url_encoded_field_get */
            next = val + vallen;
         }
 
#if !defined(NO_FILESYSTEMS)
         if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
            /* Store the content to a file */
            if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fstore) == 0) {
               fstore.access.fp = NULL;
            }
            file_size = 0;
            if (fstore.access.fp != NULL) {
               size_t n = (size_t)
                   fwrite(val, 1, (size_t)vallen, fstore.access.fp);
               if ((n != (size_t)vallen) || (ferror(fstore.access.fp))) {
                  mg_cry_internal(conn,
                                  "%s: Cannot write file %s",
                                  __func__,
                                  path);
                  (void)mg_fclose(&fstore.access);
                  remove_bad_file(conn, path);
               }
               file_size += (int64_t)n;
 
               if (fstore.access.fp) {
                  r = mg_fclose(&fstore.access);
                  if (r == 0) {
                     /* stored successfully */
                     r = field_stored(conn, path, file_size, fdh);
                     if (r == MG_FORM_FIELD_HANDLE_ABORT) {
                        /* Stop request handling */
                        break;
                     }
 
                  } else {
                     mg_cry_internal(conn,
                                     "%s: Error saving file %s",
                                     __func__,
                                     path);
                     remove_bad_file(conn, path);
                  }
                  fstore.access.fp = NULL;
               }
 
            } else {
               mg_cry_internal(conn,
                               "%s: Cannot create file %s",
                               __func__,
                               path);
            }
         }
#endif /* NO_FILESYSTEMS */
 
         /* if (field_storage == MG_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 & MG_FORM_FIELD_STORAGE_ABORT)
             == MG_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_strncasecmp(content_type,
                          "APPLICATION/X-WWW-FORM-URLENCODED",
                          33)
       || !mg_strncasecmp(content_type,
                          "APPLICATION/WWW-FORM-URLENCODED",
                          31)) {
      /* 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) || ((r == 0) && all_data_read)) {
               /* read error */
               return -1;
            }
            if (r == 0) {
               /* 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 = (buf_fill == 0);
            }
            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 & MG_FORM_FIELD_STORAGE_ABORT)
             == MG_FORM_FIELD_STORAGE_ABORT) {
            /* Stop parsing the request */
            break;
         }
 
#if !defined(NO_FILESYSTEMS)
         if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
            if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fstore) == 0) {
               fstore.access.fp = NULL;
            }
            file_size = 0;
            if (!fstore.access.fp) {
               mg_cry_internal(conn,
                               "%s: Cannot create file %s",
                               __func__,
                               path);
            }
         }
#endif /* NO_FILESYSTEMS */
 
         get_block = 0;
         /* Loop to read values larger than sizeof(buf)-keylen-2 */
         do {
            next = strchr(val, '&');
            if (next) {
               vallen = next - val;
               end_of_key_value_pair_found = 1;
            } else {
               vallen = (ptrdiff_t)strlen(val);
               end_of_key_value_pair_found = all_data_read;
            }
 
            if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
#if 0
               if (!end_of_key_value_pair_found && !all_data_read) {
                  /* This callback will deliver partial contents */
               }
#endif
 
               /* Call callback */
               r = 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 (r == MG_FORM_FIELD_HANDLE_ABORT) {
                  /* Stop request handling */
                  break;
               }
               if (r == MG_FORM_FIELD_HANDLE_NEXT) {
                  /* Skip to next field */
                  field_storage = MG_FORM_FIELD_STORAGE_SKIP;
               }
            }
 
            if (next) {
               next++;
            } else {
               /* vallen may have been modified by url_encoded_field_get */
               next = val + vallen;
            }
 
#if !defined(NO_FILESYSTEMS)
            if (fstore.access.fp) {
               size_t n = (size_t)
                   fwrite(val, 1, (size_t)vallen, fstore.access.fp);
               if ((n != (size_t)vallen) || (ferror(fstore.access.fp))) {
                  mg_cry_internal(conn,
                                  "%s: Cannot write file %s",
                                  __func__,
                                  path);
                  mg_fclose(&fstore.access);
                  remove_bad_file(conn, path);
               }
               file_size += (int64_t)n;
            }
#endif /* NO_FILESYSTEMS */
 
            if (!end_of_key_value_pair_found) {
               used = next - buf;
               memmove(buf,
                       buf + (size_t)used,
                       sizeof(buf) - (size_t)used);
               next = buf;
               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) || ((r == 0) && all_data_read)) {
#if !defined(NO_FILESYSTEMS)
                     /* read error */
                     if (fstore.access.fp) {
                        mg_fclose(&fstore.access);
                        remove_bad_file(conn, path);
                     }
                     return -1;
#endif /* NO_FILESYSTEMS */
                  }
                  if (r == 0) {
                     /* 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 = (buf_fill == 0);
                  }
                  buf_fill += r;
                  buf[buf_fill] = 0;
                  if (buf_fill < 1) {
                     break;
                  }
                  val = buf;
               }
            }
 
         } while (!end_of_key_value_pair_found);
 
#if !defined(NO_FILESYSTEMS)
         if (fstore.access.fp) {
            r = mg_fclose(&fstore.access);
            if (r == 0) {
               /* stored successfully */
               r = field_stored(conn, path, file_size, fdh);
               if (r == MG_FORM_FIELD_HANDLE_ABORT) {
                  /* Stop request handling */
                  break;
               }
            } else {
               mg_cry_internal(conn,
                               "%s: Error saving file %s",
                               __func__,
                               path);
               remove_bad_file(conn, path);
            }
            fstore.access.fp = NULL;
         }
#endif /* NO_FILESYSTEMS */
 
         if (all_data_read && (buf_fill == 0)) {
            /* nothing more to process */
            break;
         }
 
         /* 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). */
      char *boundary;
      size_t bl;
      ptrdiff_t used;
      struct mg_request_info part_header;
      char *hbuf;
      const char *content_disp, *hend, *fbeg, *fend, *nbeg, *nend;
      const char *next;
      unsigned part_no;
      int all_data_read = 0;
 
      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;
      }
 
      /* Copy boundary string to variable "boundary" */
      fbeg = content_type + bl + 9;
      bl = strlen(fbeg);
      boundary = (char *)mg_malloc(bl + 1);
      if (!boundary) {
         /* Out of memory */
         mg_cry_internal(conn,
                         "%s: Cannot allocate memory for boundary [%lu]",
                         __func__,
                         (unsigned long)bl);
         return -1;
      }
      memcpy(boundary, fbeg, bl);
      boundary[bl] = 0;
 
      /* RFC 2046 permits the boundary string to be quoted. */
      /* If the boundary is quoted, trim the quotes */
      if (boundary[0] == '"') {
         hbuf = strchr(boundary + 1, '"');
         if ((!hbuf) || (*hbuf != '"')) {
            /* Malformed request */
            mg_free(boundary);
            return -1;
         }
         *hbuf = 0;
         memmove(boundary, boundary + 1, bl);
         bl = strlen(boundary);
      }
 
      /* Do some sanity checks for boundary lengths */
      if (bl > 70) {
         /* From RFC 2046:
          * Boundary delimiters must not appear within the
          * encapsulated material, and must be no longer
          * than 70 characters, not counting the two
          * leading hyphens.
          */
 
         /* The algorithm can not work if bl >= sizeof(buf), or if buf
          * can not hold the multipart header plus the boundary.
          * Requests with long boundaries are not RFC compliant, maybe they
          * are intended attacks to interfere with this algorithm. */
         mg_free(boundary);
         return -1;
      }
      if (bl < 4) {
         /* Sanity check:  A boundary string of less than 4 bytes makes
          * no sense either. */
         mg_free(boundary);
         return -1;
      }
 
      for (part_no = 0;; part_no++) {
         size_t towrite, fnlen, n;
         int get_block;
         size_t to_read = sizeof(buf) - 1 - (size_t)buf_fill;
 
         /* Unused without filesystems */
         (void)n;
 
         r = mg_read(conn, buf + (size_t)buf_fill, to_read);
         if ((r < 0) || ((r == 0) && all_data_read)) {
            /* read error */
            mg_free(boundary);
            return -1;
         }
         if (r == 0) {
            all_data_read = (buf_fill == 0);
         }
 
         buf_fill += r;
         buf[buf_fill] = 0;
         if (buf_fill < 1) {
            /* No data */
            mg_free(boundary);
            return -1;
         }
 
         if (part_no == 0) {
            int d = 0;
            while ((d < buf_fill) && (buf[d] != '-')) {
               d++;
            }
            if ((d > 0) && (buf[d] == '-')) {
               memmove(buf, buf + d, (unsigned)buf_fill - (unsigned)d);
               buf_fill -= d;
               buf[buf_fill] = 0;
            }
         }
 
         if (buf[0] != '-' || buf[1] != '-') {
            /* Malformed request */
            mg_free(boundary);
            return -1;
         }
         if (0 != strncmp(buf + 2, boundary, bl)) {
            /* Malformed request */
            mg_free(boundary);
            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 */
               mg_free(boundary);
               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 */
            mg_free(boundary);
            return -1;
         }
 
         part_header.num_headers =
             parse_http_headers(&hbuf, part_header.http_headers);
         if ((hend + 2) != hbuf) {
            /* Malformed request */
            mg_free(boundary);
            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.http_headers,
                                   part_header.num_headers,
                                   "Content-Disposition");
         if (!content_disp) {
            /* Malformed request */
            mg_free(boundary);
            return -1;
         }
 
         /* Get the mandatory name="..." part of the Content-Disposition
          * header. */
         nbeg = strstr(content_disp, "name=\"");
         while ((nbeg != NULL) && (strcspn(nbeg - 1, ":,; \t") != 0)) {
            /* It could be somethingname= instead of name= */
            nbeg = strstr(nbeg + 1, "name=\"");
         }
 
         /* This line is not required, but otherwise some compilers
          * generate spurious warnings. */
         nend = nbeg;
         /* And others complain, the result is unused. */
         (void)nend;
 
         /* If name=" is found, search for the closing " */
         if (nbeg) {
            nbeg += 6;
            nend = strchr(nbeg, '\"');
            if (!nend) {
               /* Malformed request */
               mg_free(boundary);
               return -1;
            }
         } else {
            /* name= without quotes is also allowed */
            nbeg = strstr(content_disp, "name=");
            while ((nbeg != NULL) && (strcspn(nbeg - 1, ":,; \t") != 0)) {
               /* It could be somethingname= instead of name= */
               nbeg = strstr(nbeg + 1, "name=");
            }
            if (!nbeg) {
               /* Malformed request */
               mg_free(boundary);
               return -1;
            }
            nbeg += 5;
 
            /* RFC 2616 Sec. 2.2 defines a list of allowed
             * separators, but many of them make no sense
             * here, e.g. various brackets or slashes.
             * If they are used, probably someone is
             * trying to attack with curious hand made
             * requests. Only ; , space and tab seem to be
             * reasonable here. Ignore everything else. */
            nend = nbeg + strcspn(nbeg, ",; \t");
         }
 
         /* Get the optional filename="..." part of the Content-Disposition
          * header. */
         fbeg = strstr(content_disp, "filename=\"");
         while ((fbeg != NULL) && (strcspn(fbeg - 1, ":,; \t") != 0)) {
            /* It could be somethingfilename= instead of filename= */
            fbeg = strstr(fbeg + 1, "filename=\"");
         }
 
         /* This line is not required, but otherwise some compilers
          * generate spurious warnings. */
         fend = fbeg;
 
         /* If filename=" is found, search for the closing " */
         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). */
               mg_free(boundary);
               return -1;
            }
 
            /* TODO: check Content-Type */
            /* Content-Type: application/octet-stream */
         }
         if (!fbeg) {
            /* Try the same without quotes */
            fbeg = strstr(content_disp, "filename=");
            while ((fbeg != NULL) && (strcspn(fbeg - 1, ":,; \t") != 0)) {
               /* It could be somethingfilename= instead of filename= */
               fbeg = strstr(fbeg + 1, "filename=");
            }
            if (fbeg) {
               fbeg += 9;
               fend = fbeg + strcspn(fbeg, ",; \t");
            }
         }
 
         if (!fbeg || !fend) {
            fbeg = NULL;
            fend = NULL;
            fnlen = 0;
         } else {
            fnlen = (size_t)(fend - fbeg);
         }
 
         /* In theory, it could be possible that someone crafts
          * a request like name=filename=xyz. Check if name and
          * filename do not overlap. */
         if (!(((ptrdiff_t)fbeg > (ptrdiff_t)nend)
               || ((ptrdiff_t)nbeg > (ptrdiff_t)fend))) {
            mg_free(boundary);
            return -1;
         }
 
         /* Call callback for new field */
         memset(path, 0, sizeof(path));
         field_count++;
         field_storage = url_encoded_field_found(conn,
                                                 nbeg,
                                                 (size_t)(nend - nbeg),
                                                 ((fnlen > 0) ? fbeg : NULL),
                                                 fnlen,
                                                 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 !defined(NO_FILESYSTEMS)
         if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
            /* Store the content to a file */
            if (mg_fopen(conn, path, MG_FOPEN_MODE_WRITE, &fstore) == 0) {
               fstore.access.fp = NULL;
            }
            file_size = 0;
 
            if (!fstore.access.fp) {
               mg_cry_internal(conn,
                               "%s: Cannot create file %s",
                               __func__,
                               path);
            }
         }
#endif /* NO_FILESYSTEMS */
 
         get_block = 0;
         while (!next) {
            /* Set "towrite" to the number of bytes available
             * in the buffer */
            towrite = (size_t)(buf - hend + buf_fill);
 
            if (towrite < bl + 4) {
               /* Not enough data stored. */
               /* Incomplete request. */
               mg_free(boundary);
               return -1;
            }
 
            /* Subtract the boundary length, to deal with
             * cases the boundary is only partially stored
             * in the buffer. */
            towrite -= bl + 4;
 
            if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
               r = unencoded_field_get(conn,
                                       ((get_block > 0) ? NULL : nbeg),
                                       ((get_block > 0)
                                            ? 0
                                            : (size_t)(nend - nbeg)),
                                       hend,
                                       towrite,
                                       fdh);
               get_block++;
               if (r == MG_FORM_FIELD_HANDLE_ABORT) {
                  /* Stop request handling */
                  break;
               }
               if (r == MG_FORM_FIELD_HANDLE_NEXT) {
                  /* Skip to next field */
                  field_storage = MG_FORM_FIELD_STORAGE_SKIP;
               }
            }
 
#if !defined(NO_FILESYSTEMS)
            if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
               if (fstore.access.fp) {
 
                  /* Store the content of the buffer. */
                  n = (size_t)fwrite(hend, 1, towrite, fstore.access.fp);
                  if ((n != towrite) || (ferror(fstore.access.fp))) {
                     mg_cry_internal(conn,
                                     "%s: Cannot write file %s",
                                     __func__,
                                     path);
                     mg_fclose(&fstore.access);
                     remove_bad_file(conn, path);
                  }
                  file_size += (int64_t)n;
               }
            }
#endif /* NO_FILESYSTEMS */
 
            memmove(buf, hend + towrite, bl + 4);
            buf_fill = (int)(bl + 4);
            hend = buf;
 
            /* Read new data */
            to_read = sizeof(buf) - 1 - (size_t)buf_fill;
            r = mg_read(conn, buf + (size_t)buf_fill, to_read);
            if ((r < 0) || ((r == 0) && all_data_read)) {
#if !defined(NO_FILESYSTEMS)
               /* read error */
               if (fstore.access.fp) {
                  mg_fclose(&fstore.access);
                  remove_bad_file(conn, path);
               }
#endif /* NO_FILESYSTEMS */
               mg_free(boundary);
               return -1;
            }
            /* r==0 already handled, all_data_read is false here */
 
            buf_fill += r;
            buf[buf_fill] = 0;
            /* buf_fill is at least 8 here */
 
            /* Find boundary */
            next = search_boundary(buf, (size_t)buf_fill, boundary, bl);
 
            if (!next && (r == 0)) {
               /* incomplete request */
               all_data_read = 1;
            }
         }
 
         towrite = (next ? (size_t)(next - hend) : 0);
 
         if (field_storage == MG_FORM_FIELD_STORAGE_GET) {
            /* Call callback */
            r = unencoded_field_get(conn,
                                    ((get_block > 0) ? NULL : nbeg),
                                    ((get_block > 0)
                                         ? 0
                                         : (size_t)(nend - nbeg)),
                                    hend,
                                    towrite,
                                    fdh);
            if (r == MG_FORM_FIELD_HANDLE_ABORT) {
               /* Stop request handling */
               break;
            }
            if (r == MG_FORM_FIELD_HANDLE_NEXT) {
               /* Skip to next field */
               field_storage = MG_FORM_FIELD_STORAGE_SKIP;
            }
         }
 
#if !defined(NO_FILESYSTEMS)
         if (field_storage == MG_FORM_FIELD_STORAGE_STORE) {
 
            if (fstore.access.fp) {
               n = (size_t)fwrite(hend, 1, towrite, fstore.access.fp);
               if ((n != towrite) || (ferror(fstore.access.fp))) {
                  mg_cry_internal(conn,
                                  "%s: Cannot write file %s",
                                  __func__,
                                  path);
                  mg_fclose(&fstore.access);
                  remove_bad_file(conn, path);
               } else {
                  file_size += (int64_t)n;
                  r = mg_fclose(&fstore.access);
                  if (r == 0) {
                     /* stored successfully */
                     r = field_stored(conn, path, file_size, fdh);
                     if (r == MG_FORM_FIELD_HANDLE_ABORT) {
                        /* Stop request handling */
                        break;
                     }
                  } else {
                     mg_cry_internal(conn,
                                     "%s: Error saving file %s",
                                     __func__,
                                     path);
                     remove_bad_file(conn, path);
                  }
               }
               fstore.access.fp = NULL;
            }
         }
#endif /* NO_FILESYSTEMS */
 
         if ((field_storage & MG_FORM_FIELD_STORAGE_ABORT)
             == MG_FORM_FIELD_STORAGE_ABORT) {
            /* Stop parsing the request */
            break;
         }
 
         /* Remove from the buffer */
         if (next) {
            used = next - buf + 2;
            memmove(buf, buf + (size_t)used, sizeof(buf) - (size_t)used);
            buf_fill -= (int)used;
         } else {
            buf_fill = 0;
         }
      }
 
      /* All parts handled */
      mg_free(boundary);
      return field_count;
   }
 
   /* Unknown Content-Type */
   return -1;
}
 
/* End of handle_form.inl */