From c4e9ba925ffd758aaa3feee2ccfc0b76f26fe207 Mon Sep 17 00:00:00 2001 From: Christian Grothoff Date: Sat, 5 Oct 2019 15:09:28 +0200 Subject: global reindent, now with uncrustify hook enabled --- src/json/json_mhd.c | 331 ++++++++++++++++++++++++++-------------------------- 1 file changed, 166 insertions(+), 165 deletions(-) (limited to 'src/json/json_mhd.c') diff --git a/src/json/json_mhd.c b/src/json/json_mhd.c index 0b4dcfee8..602a15b7a 100644 --- a/src/json/json_mhd.c +++ b/src/json/json_mhd.c @@ -40,7 +40,8 @@ /** * Buffer for POST requests. */ -struct Buffer { +struct Buffer +{ /** * Allocated memory */ @@ -74,19 +75,19 @@ struct Buffer { * @return a GNUnet result code */ static int -buffer_init(struct Buffer *buf, - const void *data, - size_t data_size, - size_t alloc_size, - size_t max_size) +buffer_init (struct Buffer *buf, + const void *data, + size_t data_size, + size_t alloc_size, + size_t max_size) { if ((data_size > max_size) || (alloc_size > max_size)) return GNUNET_SYSERR; if (data_size > alloc_size) alloc_size = data_size; - buf->data = GNUNET_malloc(alloc_size); + buf->data = GNUNET_malloc (alloc_size); buf->alloc = alloc_size; - GNUNET_memcpy(buf->data, data, data_size); + GNUNET_memcpy (buf->data, data, data_size); buf->fill = data_size; buf->max = max_size; return GNUNET_OK; @@ -100,9 +101,9 @@ buffer_init(struct Buffer *buf, * @param buf buffer to de-initialize */ static void -buffer_deinit(struct Buffer *buf) +buffer_deinit (struct Buffer *buf) { - GNUNET_free(buf->data); + GNUNET_free (buf->data); buf->data = NULL; } @@ -118,28 +119,28 @@ buffer_deinit(struct Buffer *buf) * #GNUNET_NO if the buffer can't accomodate for the new data */ static int -buffer_append(struct Buffer *buf, - const void *data, - size_t data_size, - size_t max_size) +buffer_append (struct Buffer *buf, + const void *data, + size_t data_size, + size_t max_size) { if (buf->fill + data_size > max_size) return GNUNET_NO; if (buf->fill + data_size > buf->alloc) - { - char *new_buf; - size_t new_size = buf->alloc; - while (new_size < buf->fill + data_size) - new_size += 2; - if (new_size > max_size) - return GNUNET_NO; - new_buf = GNUNET_malloc(new_size); - GNUNET_memcpy(new_buf, buf->data, buf->fill); - GNUNET_free(buf->data); - buf->data = new_buf; - buf->alloc = new_size; - } - GNUNET_memcpy(buf->data + buf->fill, data, data_size); + { + char *new_buf; + size_t new_size = buf->alloc; + while (new_size < buf->fill + data_size) + new_size += 2; + if (new_size > max_size) + return GNUNET_NO; + new_buf = GNUNET_malloc (new_size); + GNUNET_memcpy (new_buf, buf->data, buf->fill); + GNUNET_free (buf->data); + buf->data = new_buf; + buf->alloc = new_size; + } + GNUNET_memcpy (buf->data + buf->fill, data, data_size); buf->fill += data_size; return GNUNET_OK; } @@ -152,95 +153,95 @@ buffer_append(struct Buffer *buf, * @return result code indicating the status of the operation */ static enum GNUNET_JSON_PostResult -inflate_data(struct Buffer *buf) +inflate_data (struct Buffer *buf) { z_stream z; char *tmp; size_t tmp_size; int ret; - memset(&z, 0, sizeof(z)); - z.next_in = (Bytef *)buf->data; + memset (&z, 0, sizeof(z)); + z.next_in = (Bytef *) buf->data; z.avail_in = buf->fill; - tmp_size = GNUNET_MIN(buf->max, buf->fill * 4); - tmp = GNUNET_malloc(tmp_size); - z.next_out = (Bytef *)tmp; + tmp_size = GNUNET_MIN (buf->max, buf->fill * 4); + tmp = GNUNET_malloc (tmp_size); + z.next_out = (Bytef *) tmp; z.avail_out = tmp_size; - ret = inflateInit(&z); + ret = inflateInit (&z); switch (ret) + { + case Z_MEM_ERROR: + GNUNET_break (0); + return GNUNET_JSON_PR_OUT_OF_MEMORY; + + case Z_STREAM_ERROR: + GNUNET_break_op (0); + return GNUNET_JSON_PR_JSON_INVALID; + + case Z_OK: + break; + } + while (1) + { + ret = inflate (&z, 0); + switch (ret) { case Z_MEM_ERROR: - GNUNET_break(0); + GNUNET_break (0); + GNUNET_break (Z_OK == inflateEnd (&z)); + GNUNET_free (tmp); return GNUNET_JSON_PR_OUT_OF_MEMORY; - case Z_STREAM_ERROR: - GNUNET_break_op(0); + case Z_DATA_ERROR: + GNUNET_break (0); + GNUNET_break (Z_OK == inflateEnd (&z)); + GNUNET_free (tmp); + return GNUNET_JSON_PR_JSON_INVALID; + + case Z_NEED_DICT: + GNUNET_break (0); + GNUNET_break (Z_OK == inflateEnd (&z)); + GNUNET_free (tmp); return GNUNET_JSON_PR_JSON_INVALID; case Z_OK: - break; + if ((0 < z.avail_out) && (0 == z.avail_in)) + { + /* truncated input stream */ + GNUNET_break (0); + GNUNET_break (Z_OK == inflateEnd (&z)); + GNUNET_free (tmp); + return GNUNET_JSON_PR_JSON_INVALID; + } + if (0 < z.avail_out) + continue; /* just call it again */ + /* output buffer full, can we grow it? */ + if (tmp_size == buf->max) + { + /* already at max */ + GNUNET_break (0); + GNUNET_break (Z_OK == inflateEnd (&z)); + GNUNET_free (tmp); + return GNUNET_JSON_PR_OUT_OF_MEMORY; + } + if (tmp_size * 2 < tmp_size) + tmp_size = buf->max; + else + tmp_size = GNUNET_MIN (buf->max, tmp_size * 2); + tmp = GNUNET_realloc (tmp, tmp_size); + z.next_out = (Bytef *) &tmp[z.total_out]; + continue; + + case Z_STREAM_END: + /* decompression successful, make 'tmp' the new 'data' */ + GNUNET_free (buf->data); + buf->data = tmp; + buf->alloc = tmp_size; + buf->fill = z.total_out; + GNUNET_break (Z_OK == inflateEnd (&z)); + return GNUNET_JSON_PR_SUCCESS; /* at least for now */ } - while (1) - { - ret = inflate(&z, 0); - switch (ret) - { - case Z_MEM_ERROR: - GNUNET_break(0); - GNUNET_break(Z_OK == inflateEnd(&z)); - GNUNET_free(tmp); - return GNUNET_JSON_PR_OUT_OF_MEMORY; - - case Z_DATA_ERROR: - GNUNET_break(0); - GNUNET_break(Z_OK == inflateEnd(&z)); - GNUNET_free(tmp); - return GNUNET_JSON_PR_JSON_INVALID; - - case Z_NEED_DICT: - GNUNET_break(0); - GNUNET_break(Z_OK == inflateEnd(&z)); - GNUNET_free(tmp); - return GNUNET_JSON_PR_JSON_INVALID; - - case Z_OK: - if ((0 < z.avail_out) && (0 == z.avail_in)) - { - /* truncated input stream */ - GNUNET_break(0); - GNUNET_break(Z_OK == inflateEnd(&z)); - GNUNET_free(tmp); - return GNUNET_JSON_PR_JSON_INVALID; - } - if (0 < z.avail_out) - continue; /* just call it again */ - /* output buffer full, can we grow it? */ - if (tmp_size == buf->max) - { - /* already at max */ - GNUNET_break(0); - GNUNET_break(Z_OK == inflateEnd(&z)); - GNUNET_free(tmp); - return GNUNET_JSON_PR_OUT_OF_MEMORY; - } - if (tmp_size * 2 < tmp_size) - tmp_size = buf->max; - else - tmp_size = GNUNET_MIN(buf->max, tmp_size * 2); - tmp = GNUNET_realloc(tmp, tmp_size); - z.next_out = (Bytef *)&tmp[z.total_out]; - continue; - - case Z_STREAM_END: - /* decompression successful, make 'tmp' the new 'data' */ - GNUNET_free(buf->data); - buf->data = tmp; - buf->alloc = tmp_size; - buf->fill = z.total_out; - GNUNET_break(Z_OK == inflateEnd(&z)); - return GNUNET_JSON_PR_SUCCESS; /* at least for now */ - } - } /* while (1) */ + } /* while (1) */ } @@ -260,12 +261,12 @@ inflate_data(struct Buffer *buf) * @return result code indicating the status of the operation */ enum GNUNET_JSON_PostResult -GNUNET_JSON_post_parser(size_t buffer_max, - struct MHD_Connection *connection, - void **con_cls, - const char *upload_data, - size_t *upload_data_size, - json_t **json) +GNUNET_JSON_post_parser (size_t buffer_max, + struct MHD_Connection *connection, + void **con_cls, + const char *upload_data, + size_t *upload_data_size, + json_t **json) { struct Buffer *r = *con_cls; const char *ce; @@ -273,71 +274,71 @@ GNUNET_JSON_post_parser(size_t buffer_max, *json = NULL; if (NULL == *con_cls) + { + /* We are seeing a fresh POST request. */ + r = GNUNET_new (struct Buffer); + if (GNUNET_OK != buffer_init (r, + upload_data, + *upload_data_size, + REQUEST_BUFFER_INITIAL, + buffer_max)) { - /* We are seeing a fresh POST request. */ - r = GNUNET_new(struct Buffer); - if (GNUNET_OK != buffer_init(r, - upload_data, - *upload_data_size, - REQUEST_BUFFER_INITIAL, - buffer_max)) - { - *con_cls = NULL; - buffer_deinit(r); - GNUNET_free(r); - return GNUNET_JSON_PR_OUT_OF_MEMORY; - } - /* everything OK, wait for more POST data */ - *upload_data_size = 0; - *con_cls = r; - return GNUNET_JSON_PR_CONTINUE; + *con_cls = NULL; + buffer_deinit (r); + GNUNET_free (r); + return GNUNET_JSON_PR_OUT_OF_MEMORY; } + /* everything OK, wait for more POST data */ + *upload_data_size = 0; + *con_cls = r; + return GNUNET_JSON_PR_CONTINUE; + } if (0 != *upload_data_size) + { + /* We are seeing an old request with more data available. */ + + if (GNUNET_OK != + buffer_append (r, upload_data, *upload_data_size, buffer_max)) { - /* We are seeing an old request with more data available. */ - - if (GNUNET_OK != - buffer_append(r, upload_data, *upload_data_size, buffer_max)) - { - /* Request too long */ - *con_cls = NULL; - buffer_deinit(r); - GNUNET_free(r); - return GNUNET_JSON_PR_REQUEST_TOO_LARGE; - } - /* everything OK, wait for more POST data */ - *upload_data_size = 0; - return GNUNET_JSON_PR_CONTINUE; + /* Request too long */ + *con_cls = NULL; + buffer_deinit (r); + GNUNET_free (r); + return GNUNET_JSON_PR_REQUEST_TOO_LARGE; } + /* everything OK, wait for more POST data */ + *upload_data_size = 0; + return GNUNET_JSON_PR_CONTINUE; + } /* We have seen the whole request. */ - ce = MHD_lookup_connection_value(connection, - MHD_HEADER_KIND, - MHD_HTTP_HEADER_CONTENT_ENCODING); - if ((NULL != ce) && (0 == strcasecmp("deflate", ce))) + ce = MHD_lookup_connection_value (connection, + MHD_HEADER_KIND, + MHD_HTTP_HEADER_CONTENT_ENCODING); + if ((NULL != ce) && (0 == strcasecmp ("deflate", ce))) + { + ret = inflate_data (r); + if (GNUNET_JSON_PR_SUCCESS != ret) { - ret = inflate_data(r); - if (GNUNET_JSON_PR_SUCCESS != ret) - { - buffer_deinit(r); - GNUNET_free(r); - *con_cls = NULL; - return ret; - } + buffer_deinit (r); + GNUNET_free (r); + *con_cls = NULL; + return ret; } + } - *json = json_loadb(r->data, r->fill, 0, NULL); + *json = json_loadb (r->data, r->fill, 0, NULL); if (NULL == *json) - { - GNUNET_log(GNUNET_ERROR_TYPE_WARNING, - "Failed to parse JSON request body\n"); - buffer_deinit(r); - GNUNET_free(r); - *con_cls = NULL; - return GNUNET_JSON_PR_JSON_INVALID; - } - buffer_deinit(r); - GNUNET_free(r); + { + GNUNET_log (GNUNET_ERROR_TYPE_WARNING, + "Failed to parse JSON request body\n"); + buffer_deinit (r); + GNUNET_free (r); + *con_cls = NULL; + return GNUNET_JSON_PR_JSON_INVALID; + } + buffer_deinit (r); + GNUNET_free (r); *con_cls = NULL; return GNUNET_JSON_PR_SUCCESS; @@ -352,15 +353,15 @@ GNUNET_JSON_post_parser(size_t buffer_max, * #GNUNET_JSON_post_parser(), to be cleaned up */ void -GNUNET_JSON_post_parser_cleanup(void *con_cls) +GNUNET_JSON_post_parser_cleanup (void *con_cls) { struct Buffer *r = con_cls; if (NULL != r) - { - buffer_deinit(r); - GNUNET_free(r); - } + { + buffer_deinit (r); + GNUNET_free (r); + } } /* end of mhd_json.c */ -- cgit v1.2.3