path: root/nbrpc_event.c

#include "nbrpc_event.h"

extern char* alloc_new_str(char *);
extern char *alloc_new_str_s(char *, size_t);

rpc_request* rpc_req_new(char *method, char *params, int id)
{
	rpc_request *ret = NULL;

	ret = malloc(sizeof(rpc_request));
	if (!ret)
	{
		return NULL;
	}
	ret->id = id;
	ret->method = alloc_new_str(method);
	ret->params = alloc_new_str(params);
	ret->user = NULL;
	ret->mask = NULL;
	ret->server = NULL;
	return ret;
}


rpc_response* rpc_resp_new(char *result, char *error, int id)
{
	rpc_response *ret = NULL;

	ret = malloc(sizeof(rpc_response));
	if (!ret)
	{
		return NULL;
	}

	PRINT("resp->id %d\n", id);
	ret->id = id;
	ret->result = alloc_new_str(result);
	ret->error  = alloc_new_str(error);
	ret->user = NULL;
	ret->mask = NULL;
	ret->server = NULL;
	return ret;
}


int rpc_req_free(rpc_request   *req)
{
	if (req)
	{
		FREE(req->user);
		FREE(req->mask);
		FREE(req->user);
		FREE(req->method);
		FREE(req->params);
		FREE(req);
		return 0;
	}
	return -1;
}


int rpc_resp_free(rpc_response *resp)
{
	if (resp)
	{
		FREE(resp->user);
		FREE(resp->mask);
		FREE(resp->server);
		FREE(resp->result);
		FREE(resp->error);
		FREE(resp);
		return 0;
	}
	return -1;
}


int rpc_req_marsh(   rpc_request   *req,     netbyte_store **nb_req)
{
	netbyte_store *nb = NULL;
	nb_u32 nb_id;
	nb_u8arr nb_method, nb_params, nb_user, nb_mask, nb_server;

	nb = calloc(1,sizeof(netbyte_store));
	nb_init(nb);

	nb_u8arr_create(&nb_method, strlen(req->method), (uint8_t *)req->method);
	nb_add_u8arr(nb, &nb_method);

	nb_u8arr_create(&nb_params, strlen(req->params), (uint8_t *)req->params);
	nb_add_u8arr(nb, &nb_params);

	nb_u32_create(&nb_id, req->id);
	nb_add_u32(nb, &nb_id);

	nb_u8arr_create(&nb_user, strlen(req->user), (uint8_t *)req->user);
	nb_add_u8arr(nb, &nb_user);

	nb_u8arr_create(&nb_mask, strlen(req->mask), (uint8_t *)req->mask);
	nb_add_u8arr(nb, &nb_mask);

	nb_u8arr_create(&nb_server, strlen(req->server), (uint8_t *)req->server);
	nb_add_u8arr(nb, &nb_server);

	*nb_req = nb;
	return 0;
}


int rpc_resp_marsh(  rpc_response  *resp,    netbyte_store **nb_resp)
{
	int eret;
	netbyte_store *nb = NULL;
	nb_u32 nb_id;
	nb_u8arr nb_result, nb_error, nb_user, nb_mask, nb_server;

	nb = calloc(1,sizeof(netbyte_store));
	nb_init(nb);

	eret = nb_u8arr_create(&nb_result, strlen(resp->result), (uint8_t *)resp->result);
	eret |= nb_add_u8arr(nb, &nb_result);

	eret = nb_u8arr_create(&nb_error, strlen(resp->error), (uint8_t *)resp->error);
	eret |= nb_add_u8arr(nb, &nb_error);

	eret = nb_u32_create(&nb_id, resp->id);
	eret |= nb_add_u32