int ll_getLast(LinkedList *ll, void **element) {
int status = 0;
LLNode *p = SENTINEL(ll)->prev;
if (p != SENTINEL(ll)) {
status = 1;
*element = p->element;
}
return status;
}
int
co_call(co_obj_t *connection, co_obj_t **response, const char *method, const size_t mlen, co_obj_t *request)
{
CHECK(method != NULL && mlen > 0 && mlen < UINT8_MAX, "Invalid method name.");
CHECK(connection != NULL && IS_SOCK(connection), "Invalid connection.");
co_obj_t *params = NULL, *rlist = NULL, *rtree = NULL;
int retval = 0;
size_t reqlen = 0, resplen = 0;
char req[REQUEST_MAX];
char resp[RESPONSE_MAX];
if(request != NULL)
{
CHECK(IS_LIST(request), "Not a valid request.");
params = request;
}
else
{
params = co_list16_create();
}
co_obj_t *m = co_str8_create(method, mlen, 0);
reqlen = co_request_alloc(req, sizeof(req), m, params);
CHECK(((co_socket_t*)connection)->send((co_obj_t*)((co_socket_t*)connection)->fd, req, reqlen) != -1, "Send error!");
if((resplen = ((co_socket_t*)connection)->receive(connection, (co_obj_t*)((co_socket_t*)connection)->fd, resp, sizeof(resp))) > 0)
{
CHECK(co_list_import(&rlist, resp, resplen) > 0, "Failed to parse response.");
rtree = co_list_element(rlist, 3);
if(!IS_NIL(rtree))
{
retval = 1;
}
else
{
rtree = co_list_element(rlist, 2);
retval = 0;
}
if(rtree != NULL && IS_TREE(rtree))
{
*response = rtree;
hattach(*response, _pool);
}
else SENTINEL("Invalid response.");
}
else SENTINEL("Failed to receive data.");
co_obj_free(m);
if(params != request) co_obj_free(params);
return retval;
error:
co_obj_free(m);
if(params != request) co_obj_free(params);
return retval;
}
LinkedList *ll_create(void) {
LinkedList *ll;
ll = (LinkedList *)malloc(sizeof(LinkedList));
if (ll != NULL) {
ll->size = 0l;
ll->freel = NULL;
ll->sentinel.next = SENTINEL(ll);
ll->sentinel.prev = SENTINEL(ll);
}
return ll;
}
int ll_addLast(LinkedList *ll, void *element) {
int status = 0;
LLNode *p = getEntry(ll);
if (p != NULL) {
p->element = element;
status = 1;
link(SENTINEL(ll)->prev, p, SENTINEL(ll));
ll->size++;
}
return status;
}
int ll_removeLast(LinkedList *ll, void **element) {
int status = 0;
LLNode *p = SENTINEL(ll)->prev;
if (p != SENTINEL(ll)) {
status = 1;
*element = p->element;
unlink(p);
putEntry(ll, p);
ll->size--;
}
return status;
}
size_t
co_tree_raw(char *output, const size_t olen, const co_obj_t *tree)
{
char *out = output;
size_t written = 0;
switch(CO_TYPE(tree))
{
case _tree16:
memmove(out, &(tree->_type), sizeof(tree->_type));
out += sizeof(tree->_type);
written += sizeof(tree->_type);
memmove(out, &(((co_tree16_t *)tree)->_len), sizeof(((co_tree16_t *)tree)->_len));
out += sizeof(((co_tree16_t *)tree)->_len);
written += sizeof(((co_tree16_t *)tree)->_len);
break;
case _tree32:
memmove(out, &(tree->_type), sizeof(tree->_type));
out += sizeof(tree->_type);
written += sizeof(tree->_type);
memmove(out, &(((co_tree32_t *)tree)->_len), sizeof(((co_tree32_t *)tree)->_len));
out += sizeof(((co_tree32_t *)tree)->_len);
written += sizeof(((co_tree32_t *)tree)->_len);
break;
default:
SENTINEL("Not a tree object.");
break;
}
_co_tree_raw_r(&out, &olen, &written, co_tree_root(tree));
DEBUG("Tree bytes written: %d", (int)written);
return written;
error:
return -1;
}
/**
* Print out the packet content.
* @param p_packet Pointer to the packet.
*/
uint8_t print_packet( icp_packet_t *p_packet ) {
int i = 0;
if (p_packet == NULL) {
SENTINEL("Packet is NULL");
}
printf("Packet content:\n");
printf(" destination[%02X]:\t%s\n", p_packet->destination, mac_addrs[p_packet->destination]);
printf(" source[%02X]:\t%s\n", p_packet->source, mac_addrs[p_packet->source]);
printf(" received:\t%hu\n", p_packet->receive_timestamp);
printf(" data_len[%02X %02X]:\t%d\n", p_packet->data_length >> 8, (uint8_t)(p_packet->data_length & 0x00FF), p_packet->data_length);
printf(" data:\t");
for (i=0; i < p_packet->data_length+1; i++) {
putchar( i ? ' ': '[' );
printf("%02X", p_packet->data[i]);
}
printf("] \"");
for (i=0; i < p_packet->data_length+1; i++) {
putchar( p_packet->data[i] );
}
puts("\"");
return 0;
error:
return -1;
}
static int
_co_node_set_uint(_treenode_t *n, const unsigned long value)
{
CHECK(n != NULL, "Invalid node supplied.");
switch(CO_TYPE(n->value))
{
case _uint8:
(((co_uint8_t *)(n->value))->data) = value;
break;
case _uint16:
(((co_uint16_t *)(n->value))->data) = value;
break;
case _uint32:
(((co_uint32_t *)(n->value))->data) = value;
break;
case _uint64:
(((co_uint64_t *)(n->value))->data) = value;
break;
default:
SENTINEL("Specified object is not a unsigned integer.");
break;
}
return 1;
error:
return 0;
}
int
co_response_get_int(co_obj_t *response, signed long *output, const char *key, const size_t klen)
{
co_obj_t *obj = co_response_get(response, key, klen);
CHECK(obj != NULL, "Response value %s does not exist.", key);
switch(CO_TYPE(obj))
{
case _int8:
*output = (unsigned long)(((co_int8_t *)obj)->data);
break;
case _int16:
*output = (unsigned long)(((co_int16_t *)obj)->data);
break;
case _int32:
*output = (unsigned long)(((co_int32_t *)obj)->data);
break;
case _int64:
*output = (unsigned long)(((co_int64_t *)obj)->data);
break;
default:
SENTINEL("Not an unsigned integer.");
break;
}
return 1;
error:
return 0;
}
/*
* traverses linked list, calling userFunction on each element and freeing
* node associated with element
*/
static void purge(LinkedList *ll, void (*userFunction)(void *element)) {
LLNode *cur = ll->sentinel.next;
while (cur != SENTINEL(ll)) {
LLNode *next;
if (userFunction != NULL)
(*userFunction)(cur->element);
next = cur->next;
putEntry(ll, cur);
cur = next;
}
}
int ll_get(LinkedList *ll, long index, void **element) {
int status = 0;
if (index < ll->size) {
long n;
LLNode *p;
status = 1;
for (n = 0, p = SENTINEL(ll)->next; n < index; n++, p = p->next)
;
*element = p->element;
}
return status;
}
void dispatch(int argc, char *argv[])
{
/* ignore blank commands */
if (argc == 0 || argv[0] == NULL)
return;
for (Namefun *nfp = handlers; nfp < SENTINEL(handlers); nfp++) {
if (istreq(argv[0], nfp->name)) {
(nfp->fn)(argc, argv);
return;
}
}
ERROR("Unknown command '%s'", argv[0]);
}
int co_socket_getopt(void * self, int level, int option, void *optval, socklen_t optvallen) {
co_socket_t *this = self;
//Check to see if this is a standard socket option, or needs custom handling.
if(level <= MAX_IPPROTO) {
CHECK(!getsockopt(this->fd, level, option, optval, &optvallen), "Problem setting socket options.");
} else {
SENTINEL("No custom socket options defined!");
}
return 1;
error:
return 0;
}
int ll_remove(LinkedList *ll, long index, void **element) {
int status = 0;
if (index < ll->size) {
long n;
LLNode *p;
status = 1;
for (n = 0, p = SENTINEL(ll)->next; n < index; n++, p = p->next)
;
*element = p->element;
unlink(p);
putEntry(ll, p);
ll->size--;
}
return status;
}
int ll_insert(LinkedList *ll, long index, void *element) {
int status = 0;
LLNode *p;
if (index <= ll->size && (p = getEntry(ll)) != NULL) {
long n;
LLNode *b;
p->element = element;
status = 1;
for (n = 0, b = SENTINEL(ll); n < index; n++, b = b->next)
;
link(b, p, b->next);
ll->size++;
}
return status;
}
_treenode_t *
co_tree_root(const co_obj_t *tree)
{
CHECK_MEM(tree);
_treenode_t *n = NULL;
if(CO_TYPE(tree) == _tree16)
{
n = ((co_tree16_t *)tree)->root;
}
else if(CO_TYPE(tree) == _tree32)
{
n = ((co_tree32_t *)tree)->root;
}
else SENTINEL("Specified object is not a tree.");
return n;
error:
return NULL;
}
int
co_tree_process(co_obj_t *tree, const co_iter_t iter, void *context)
{
switch(CO_TYPE(tree))
{
case _tree16:
_co_tree_process_r(tree, ((co_tree16_t *)tree)->root, iter, context);
break;
case _tree32:
_co_tree_process_r(tree, ((co_tree32_t *)tree)->root, iter, context);
break;
default:
SENTINEL("Object is not a tree.");
break;
}
return 1;
error:
return 0;
}
static int
_co_node_set_str(_treenode_t *n, const char *value, const size_t vlen)
{
CHECK(n != NULL, "Invalid node supplied.");
CHECK(n->value != NULL, "Invalid node supplied.");
switch(CO_TYPE(n->value))
{
case _str8:
CHECK(vlen <= UINT8_MAX, "Value too large for type str8.");
if(vlen != (((co_str8_t *)(n->value))->_len))
{
n->value = h_realloc(n->value, (size_t)(vlen + sizeof(co_str8_t) - 1));
}
CHECK_MEM(memmove((((co_str8_t *)(n->value))->data), value, vlen));
(((co_str8_t *)(n->value))->_len) = (uint8_t)vlen;
break;
case _str16:
CHECK(vlen <= UINT16_MAX, "Value too large for type str16.");
if(vlen != (((co_str16_t *)(n->value))->_len))
{
n->value = h_realloc(n->value, (size_t)(vlen + sizeof(co_str16_t) - 1));
}
CHECK_MEM(memmove((((co_str16_t *)(n->value))->data), value, vlen));
(((co_str16_t *)(n->value))->_len) = (uint16_t)vlen;
break;
case _str32:
CHECK(vlen <= UINT32_MAX, "Value too large for type str32.");
if(vlen != (((co_str32_t *)(n->value))->_len))
{
n->value = h_realloc(n->value, (size_t)(vlen + sizeof(co_str32_t) - 1));
}
CHECK_MEM(memmove((((co_str32_t *)(n->value))->data), value, vlen));
(((co_str32_t *)(n->value))->_len) = (uint32_t)vlen;
break;
default:
SENTINEL("Specified object is not a string.");
break;
}
return 1;
error:
return 0;
}
int
co_response_get_bool(co_obj_t *response, bool *output, const char *key, const size_t klen) {
co_obj_t *obj = co_response_get(response, key, klen);
CHECK(obj != NULL, "Response value %s does not exist.", key);
switch(CO_TYPE(obj))
{
case _false:
*output = false;
break;
case _true:
*output = true;
break;
default:
SENTINEL("Not a boolean.");
break;
}
return 1;
error:
return 0;
}
co_socket_t *co_socket_create(size_t size, co_socket_t proto) {
if(!proto.init) proto.init = NULL;
if(!proto.destroy) proto.destroy = co_socket_destroy;
if(!proto.hangup) proto.hangup = co_socket_hangup;
if(!proto.bind) proto.bind = NULL;
if(!proto.connect) proto.connect = NULL;
if(!proto.send) proto.send = co_socket_send;
if(!proto.receive) proto.receive = co_socket_receive;
if(!proto.setopt) proto.setopt = co_socket_setopt;
if(!proto.getopt) proto.getopt = co_socket_getopt;
co_socket_t *new_sock = malloc(size);
*new_sock = proto;
if((proto.init != NULL) && (!new_sock->init(new_sock))) {
SENTINEL("Failed to initialize new socket.");
} else {
return new_sock;
}
error:
new_sock->destroy(new_sock);
return NULL;
}
size_t
co_tree_import(co_obj_t **tree, const char *input, const size_t ilen)
{
size_t length = 0, olen = 0, read = 0, klen = 0;
char *kstr = NULL;
int i = 0;
co_obj_t *obj = NULL;
const char *cursor = input;
switch((uint8_t)input[0])
{
case _tree16:
length = *((uint16_t *)(input + 1));
*tree = co_tree16_create();
cursor += sizeof(uint16_t) + 1;
read = sizeof(uint16_t) + 1;
break;
case _tree32:
length = (uint32_t)(*(uint32_t*)(input + 1));
*tree = co_tree32_create();
cursor += sizeof(uint32_t) + 1;
read = sizeof(uint32_t) + 1;
break;
default:
SENTINEL("Not a tree.");
break;
}
while(i < length && read <= ilen)
{
DEBUG("Importing tuple:");
if((uint8_t)cursor[0] == _str8)
{
DEBUG("Reading key...");
cursor += 1;
read += 1;
klen = (uint8_t)cursor[0];
kstr = (char *)&cursor[1];
cursor += klen + 1;
read += klen + 1;
DEBUG("Reading value...");
switch((uint8_t)cursor[0])
{
case _list16:
case _list32:
olen = co_list_import(&obj, cursor, ilen - read);
break;
case _tree16:
case _tree32:
olen = co_tree_import(&obj, cursor, ilen - read);
break;
default:
olen = co_obj_import(&obj, cursor, ilen - read, 0);
break;
}
CHECK(olen > 0, "Failed to import object.");
cursor +=olen;
read += olen;
DEBUG("Inserting value into tree with key.");
CHECK(co_tree_insert(*tree, kstr, klen, obj), "Failed to insert object.");
i++;
}
}
return read;
error:
if(obj != NULL) co_obj_free(obj);
return -1;
}
void ll_clear(LinkedList *ll, void (*userFunction)(void *element)) {
purge(ll, userFunction);
ll->size = 0L;
ll->sentinel.next = SENTINEL(ll);
ll->sentinel.prev = SENTINEL(ll);
}
