mhd_upload.c File Reference

functions to parse JSON snippets we receive via MHD More...

#include "platform.h"
#include "gnunet_mhd_lib.h"
#include <zlib.h>
#include <jansson.h>

Include dependency graph for mhd_upload.c:

Go to the source code of this file.

Data Structures
struct	Buffer
	Buffer for POST requests. More...

Macros
#define	REQUEST_BUFFER_INITIAL   (2 * 1024)
	Initial size for POST request buffers. More...

Functions
static enum GNUNET_GenericReturnValue	buffer_init (struct Buffer *buf, const void *data, size_t data_size, size_t alloc_size, size_t max_size)
	Initialize a buffer. More...
static void	buffer_deinit (struct Buffer *buf)
	Free the data in a buffer. More...
static enum GNUNET_GenericReturnValue	buffer_append (struct Buffer *buf, const void *data, size_t data_size, size_t max_size)
	Append data to a buffer, growing the buffer if necessary. More...
static enum GNUNET_MHD_PostResult	inflate_data (struct Buffer *buf)
	Decompress data in buf. More...
enum GNUNET_MHD_PostResult	GNUNET_MHD_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)
	Process a POST request containing a JSON object. More...
void	GNUNET_MHD_post_parser_cleanup (void *con_cls)
	Function called whenever we are done with a request to clean up our state. More...

Detailed Description

functions to parse JSON snippets we receive via MHD

Author

Florian Dold

Benedikt Mueller

Christian Grothoff

Definition in file mhd_upload.c.

Macro Definition Documentation

REQUEST_BUFFER_INITIAL

#define REQUEST_BUFFER_INITIAL   (2 * 1024)

Initial size for POST request buffers.

Should be big enough to usually not require a reallocation, but not so big that it hurts in terms of memory use.

Definition at line 38 of file mhd_upload.c.

Function Documentation

buffer_init()

static enum GNUNET_GenericReturnValue buffer_init ( struct Buffer *  buf, const void *  data, size_t  data_size, size_t  alloc_size, size_t  max_size  )

static

Initialize a buffer.

Parameters

buf	the buffer to initialize
data	the initial data
data_size	size of the initial data
alloc_size	size of the buffer
max_size	maximum size that the buffer can grow to

Returns

a GNUnet result code

Definition at line 79 of file mhd_upload.c.

{
  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->alloc = alloc_size;
  GNUNET_memcpy (buf->data,
                 data,
                 data_size);
  buf->fill = data_size;
  buf->max = max_size;
  return GNUNET_OK;
}

References Buffer::alloc, data, Buffer::data, data_size, Buffer::fill, GNUNET_malloc, GNUNET_memcpy, GNUNET_OK, GNUNET_SYSERR, Buffer::max, and max_size.

Referenced by GNUNET_MHD_post_parser().

Here is the caller graph for this function:

buffer_deinit()

static void buffer_deinit ( struct Buffer *  buf )

static

Free the data in a buffer.

Does not free the buffer object itself.

Parameters

buf	buffer to de-initialize

Definition at line 108 of file mhd_upload.c.

{
  GNUNET_free (buf->data);
  buf->data = NULL;
}

References Buffer::data, and GNUNET_free.

Referenced by GNUNET_MHD_post_parser(), and GNUNET_MHD_post_parser_cleanup().

Here is the caller graph for this function:

buffer_append()

static enum GNUNET_GenericReturnValue buffer_append ( struct Buffer *  buf, const void *  data, size_t  data_size, size_t  max_size  )

static

Append data to a buffer, growing the buffer if necessary.

Parameters

buf	the buffer to append to
data	the data to append
data_size	the size of data
max_size	maximum size that the buffer can grow to

Returns

GNUNET_OK on success, GNUNET_NO if the buffer can't accommodate for the new data

Definition at line 126 of file mhd_upload.c.

{
  if (buf->fill + data_size < data_size)
  {
    GNUNET_break (0);
    return GNUNET_NO; /* overflow */
  }
  if (buf->fill + data_size > max_size)
    return GNUNET_NO;
  if (buf->fill + data_size > buf->alloc)
  {
    size_t new_size = buf->alloc;
 
    while ( (new_size < buf->fill + data_size) &&
            (new_size < SIZE_MAX / 2) )
      new_size *= 2;
    if ( (new_size > max_size) ||
         (new_size < buf->fill + data_size) )
      return GNUNET_NO;
    buf->data = GNUNET_realloc (buf->data,
                                new_size);
    buf->alloc = new_size;
  }
  GNUNET_memcpy (buf->data + buf->fill,
                 data,
                 data_size);
  buf->fill += data_size;
  return GNUNET_OK;
}

References Buffer::alloc, data, Buffer::data, data_size, Buffer::fill, GNUNET_break, GNUNET_memcpy, GNUNET_NO, GNUNET_OK, GNUNET_realloc, max_size, and SIZE_MAX.

Referenced by GNUNET_MHD_post_parser().

Here is the caller graph for this function:

inflate_data()

static enum GNUNET_MHD_PostResult inflate_data ( struct Buffer *  buf )

static

Decompress data in buf.

Parameters

buf	input data to inflate

Returns

result code indicating the status of the operation

Definition at line 167 of file mhd_upload.c.

{
  z_stream z;
  char *tmp;
  size_t tmp_size;
  int ret;
 
  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;
  z.avail_out = tmp_size;
  ret = inflateInit (&z);
  switch (ret)
  {
  case Z_MEM_ERROR:
    GNUNET_break (0);
    return GNUNET_MHD_PR_OUT_OF_MEMORY;
  case Z_STREAM_ERROR:
    GNUNET_break_op (0);
    return GNUNET_MHD_PR_JSON_INVALID;
  case Z_OK:
    break;
  }
  while (1)
  {
    ret = inflate (&z,
                   0);
    switch (ret)
    {
    case Z_BUF_ERROR:
      GNUNET_break_op (0);
      GNUNET_break (Z_OK == inflateEnd (&z));
      GNUNET_free (tmp);
      return GNUNET_MHD_PR_JSON_INVALID;
    case Z_MEM_ERROR:
      GNUNET_break (0);
      GNUNET_break (Z_OK == inflateEnd (&z));
      GNUNET_free (tmp);
      return GNUNET_MHD_PR_OUT_OF_MEMORY;
    case Z_DATA_ERROR:
      GNUNET_break_op (0);
      GNUNET_break (Z_OK == inflateEnd (&z));
      GNUNET_free (tmp);
      return GNUNET_MHD_PR_JSON_INVALID;
    case Z_NEED_DICT:
      GNUNET_break_op (0);
      GNUNET_break (Z_OK == inflateEnd (&z));
      GNUNET_free (tmp);
      return GNUNET_MHD_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_MHD_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_MHD_PR_OUT_OF_MEMORY;
      }
      if (tmp_size * 2 < tmp_size)
        tmp_size = buf->max; /* overflow */
      else
        tmp_size = GNUNET_MIN (buf->max,
                               tmp_size * 2);
      tmp = GNUNET_realloc (tmp,
                            tmp_size);
      z.next_out = (Bytef *) &tmp[z.total_out];
      z.avail_out = tmp_size - 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_MHD_PR_SUCCESS;     /* at least for now */
    }
  }   /* while (1) */
}

References Buffer::alloc, Buffer::data, Buffer::fill, GNUNET_break, GNUNET_break_op, GNUNET_free, GNUNET_malloc, GNUNET_MHD_PR_JSON_INVALID, GNUNET_MHD_PR_OUT_OF_MEMORY, GNUNET_MHD_PR_SUCCESS, GNUNET_MIN, GNUNET_realloc, Buffer::max, and ret.

Referenced by GNUNET_MHD_post_parser().

Here is the caller graph for this function:

GNUNET_MHD_post_parser()

enum GNUNET_MHD_PostResult GNUNET_MHD_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
	)

Process a POST request containing a JSON object.

This function realizes an MHD POST processor that will (incrementally) process JSON data uploaded to the HTTP server. It will store the required state in the con_cls, which must be cleaned up using #GNUNET_MHD_post_parser_callback().

Parameters

buffer_max	maximum allowed size for the buffer
connection	MHD connection handle (for meta data about the upload)
con_cls	the closure (will point to a struct Buffer *)
upload_data	the POST data
upload_data_size	number of bytes in upload_data
json	the JSON object for a completed request

Returns

result code indicating the status of the operation

Definition at line 282 of file mhd_upload.c.

{
  struct Buffer *r = *con_cls;
  const char *ce;
 
  *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))
    {
      *con_cls = NULL;
      buffer_deinit (r);
      GNUNET_free (r);
      return GNUNET_MHD_PR_OUT_OF_MEMORY;
    }
    /* everything OK, wait for more POST data */
    *upload_data_size = 0;
    *con_cls = r;
    return GNUNET_MHD_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))
    {
      /* Request too long */
      *con_cls = NULL;
      buffer_deinit (r);
      GNUNET_free (r);
      return GNUNET_MHD_PR_REQUEST_TOO_LARGE;
    }
    /* everything OK, wait for more POST data */
    *upload_data_size = 0;
    return GNUNET_MHD_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)) )
  {
    enum GNUNET_MHD_PostResult ret;
 
    ret = inflate_data (r);
    if (GNUNET_MHD_PR_SUCCESS != ret)
    {
      buffer_deinit (r);
      GNUNET_free (r);
      *con_cls = NULL;
      return ret;
    }
  }
 
  {
    json_error_t err;
 
    *json = json_loadb (r->data,
                        r->fill,
                        0,
                        &err);
    if (NULL == *json)
    {
      GNUNET_log (GNUNET_ERROR_TYPE_WARNING,
                  "Failed to parse JSON request body of %u byte at offset %d: %s\n",
                  (unsigned int) r->fill,
                  err.position,
                  err.text);
      buffer_deinit (r);
      GNUNET_free (r);
      *con_cls = NULL;
      return GNUNET_MHD_PR_JSON_INVALID;
    }
  }
  buffer_deinit (r);
  GNUNET_free (r);
  *con_cls = NULL;
  return GNUNET_MHD_PR_SUCCESS;
}

References buffer_append(), buffer_deinit(), buffer_init(), Buffer::data, Buffer::fill, GNUNET_ERROR_TYPE_WARNING, GNUNET_free, GNUNET_log, GNUNET_MHD_PR_CONTINUE, GNUNET_MHD_PR_JSON_INVALID, GNUNET_MHD_PR_OUT_OF_MEMORY, GNUNET_MHD_PR_REQUEST_TOO_LARGE, GNUNET_MHD_PR_SUCCESS, GNUNET_new, GNUNET_OK, inflate_data(), REQUEST_BUFFER_INITIAL, and ret.

Here is the call graph for this function:

GNUNET_MHD_post_parser_cleanup()

void GNUNET_MHD_post_parser_cleanup

(

void *

con_cls

)

Function called whenever we are done with a request to clean up our state.

Parameters

con_cls

value as it was left by GNUNET_MHD_post_parser(), to be cleaned up

Definition at line 390 of file mhd_upload.c.

{
  struct Buffer *r = con_cls;
 
  if (NULL != r)
  {
    buffer_deinit (r);
    GNUNET_free (r);
  }
}

References buffer_deinit(), and GNUNET_free.

Here is the call graph for this function: