msg.c File Reference

a simple message serialization library More...

#include <stdlib.h>
#include <stddef.h>
#include <stdbool.h>
#include <string.h>
#include <inttypes.h>
#include <arpa/inet.h>
#include "debug.h"
#include "util.h"
#include "msg.h"
#include "obj.h"
#include "list.h"
#include "tree.h"

Functions
size_t	co_request_alloc (char *output, const size_t olen, const co_obj_t *method, co_obj_t *param)
	allocate request More...
size_t	co_response_alloc (char *output, const size_t olen, const uint32_t id, const co_obj_t *error, co_obj_t *result)
	allocate response More...

Detailed Description

a simple message serialization library

Author

Josh King (jheretic), jking.nosp@m.@cha.nosp@m.mbana.nosp@m..net

Function Documentation

size_t co_request_alloc	(	char *	output,
		const size_t	olen,
		const co_obj_t *	method,
		co_obj_t *	param
	)

allocate request

Parameters

output	buffer for output
olen	output buffer length
method	name of method
param	parameters to method

References co_list_raw().

Referenced by co_call().

{
  
  CHECK(((output != NULL) && (method != NULL)), "Invalid request components.");
  CHECK(olen > sizeof(_req_header) + sizeof(uint32_t) + sizeof(co_str16_t) + sizeof(co_list16_t), "Output buffer too small.");
  size_t written = 0;
  char *cursor = NULL;
  size_t s = 0;

  /* Pack request header */
  memmove(output + written, &_req_header.list_type, sizeof(_req_header.list_type));
  written += sizeof(_req_header.list_type);

  memmove(output + written, &_req_header.list_len, sizeof(_req_header.list_len));
  written += sizeof(_req_header.list_len);

  memmove(output + written, &_req_header.type_type, sizeof(_req_header.type_type));
  written += sizeof(_req_header.type_type);
  
  memmove(output + written, &_req_header.type_value, sizeof(_req_header.type_value));
  written += sizeof(_req_header.type_value);
  
  memmove(output + written, &_req_header.id_type, sizeof(_req_header.id_type));
  written += sizeof(_req_header.id_type);

  /* Pack request ID */
  memmove(output + written, &_id, sizeof(uint32_t));
  written += sizeof(uint32_t);
  _id++;

  /* Pack method call */
  CHECK(IS_STR(method), "Not a valid method name.");
  char *buffer = NULL;
  size_t buffer_write = co_obj_raw(&buffer, method);
  CHECK(buffer_write >= 0, "Failed to pack object.");
  memmove(output + written, buffer, buffer_write);
  written += buffer_write;

  /* Pack parameters */
  CHECK(written < olen, "Output buffer too small.");
  if(param != NULL)
  {
    if(IS_LIST(param))
      written += co_list_raw(output + written, olen - written, param);
    else 
    {
      s = co_obj_raw(&cursor, param);
      written += s;
      memmove(output + written, cursor, s);
    }
  }
  CHECK(written >= 0, "Failed to pack object.");
  DEBUG("Request bytes written: %d", (int)written);
  CHECK(written < olen, "Output buffer too small.");

  return written;
error:
  return -1;
  
}

size_t co_response_alloc	(	char *	output,
		const size_t	olen,
		const uint32_t	id,
		const co_obj_t *	error,
		co_obj_t *	result
	)

allocate response

Parameters

output	buffer for output
olen	output buffer length
id	response ID
error	error object
result	result of request

References co_list_raw(), and co_tree_raw().

Referenced by dispatcher_cb().

{
  CHECK(((output != NULL) && (error != NULL) && (result != NULL)), "Invalid response components.");
  CHECK(olen > sizeof(_resp_header) + sizeof(uint32_t) + sizeof(co_str16_t) + sizeof(co_list16_t), "Output buffer too small.");
  size_t written = 0;
  char *cursor = NULL;
  size_t s = 0;

  /* Pack response header */
  memmove(output + written, &_resp_header.list_type, sizeof(_resp_header.list_type));
  written += sizeof(_resp_header.list_type);

  memmove(output + written, &_resp_header.list_len, sizeof(_resp_header.list_len));
  written += sizeof(_resp_header.list_len);

  memmove(output + written, &_resp_header.type_type, sizeof(_resp_header.type_type));
  written += sizeof(_resp_header.type_type);
  
  memmove(output + written, &_resp_header.type_value, sizeof(_resp_header.type_value));
  written += sizeof(_resp_header.type_value);
  
  memmove(output + written, &_resp_header.id_type, sizeof(_resp_header.id_type));
  written += sizeof(_resp_header.id_type);

  /* Pack response ID */
  memmove(output + written, &id, sizeof(uint32_t));
  written += sizeof(uint32_t);

  /* Pack error code */
  //CHECK(IS_STR(error) || IS_NIL(error), "Not a valid error name.");
  if(error != NULL)
  {
    if(IS_LIST(error))
      written += co_list_raw(output + written, olen - written, error);
    else if(IS_TREE(error))
    {
      written += co_tree_raw(output + written, olen - written, error);
    }
    else
    {
      s = co_obj_raw(&cursor, error);
      memmove(output + written, cursor, s);
      written += s;
    }
  }

  /* Pack method result */
  CHECK(written < olen, "Output buffer too small.");
  if(result != NULL)
  {
    if(IS_LIST(result))
      written += co_list_raw(output + written, olen - written, result);
    else if(IS_TREE(result))
    {
      written += co_tree_raw(output + written, olen - written, result);
    }
    else
    {
      s = co_obj_raw(&cursor, result);
      memmove(output + written, cursor, s);
      written += s;
    }
  }

  DEBUG("Response bytes written: %d", (int)written);
  CHECK(written < olen, "Output buffer too small.");

  return written;
error:
  return -1;
}