TreeTest()
{
Tree16 = co_tree16_create();
Tree32 = co_tree32_create();
TestString1 = co_str8_create("1TESTVALUE1", 12, 0);
TestString2 = co_str8_create("2TESTVALUE2", 12, 0);
ReplaceString1 = co_str8_create("REPLACE", 9, 0);
ret = 0;
ptr = NULL;
}
void TreeTest::UpdateObj()
{
ret = co_tree_insert(Tree16, "1TESTKEY1", 10, TestString1);
ASSERT_EQ(1, ret);
ret = co_tree_set_str(Tree16, "1TESTKEY1", 10, "REPLACE", 9);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree16, "1TESTKEY1", 10);
ASSERT_EQ(0, co_str_cmp(ptr, ReplaceString1));
// reinitialize TestString1
TestString1 = co_str8_create("1TESTVALUE1", 12, 0);
// repeat for Tree32
ret = co_tree_insert(Tree32, "1TESTKEY1", 10, TestString1);
ASSERT_EQ(1, ret);
ret = co_tree_set_str(Tree32, "1TESTKEY1", 10, "REPLACE", 9);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree32, "1TESTKEY1", 10);
ASSERT_EQ(0, co_str_cmp(ptr, ReplaceString1));
}
static inline _treenode_t *
_co_tree_insert_r(_treenode_t *root, _treenode_t *current, const char *orig_key, const size_t orig_klen, const char *key, const size_t klen, co_obj_t *value)
{
if (current == NULL)
{
current = (_treenode_t *) h_calloc(1, sizeof(_treenode_t));
if(root == NULL)
{
root = current;
}
else
{
hattach(current, root);
}
current->splitchar = *key;
}
if (*key < current->splitchar)
{
current->low = _co_tree_insert_r(root, current->low, orig_key, orig_klen, key, klen, value);
}
else if (*key == current->splitchar)
{
if (klen > 1)
{
// not done yet, keep going but one less
current->equal = _co_tree_insert_r(root, current->equal, orig_key, orig_klen, key+1, klen - 1, value);
}
else
{
if(current->value != NULL)
{
co_obj_free(current->value);
}
if(current->key != NULL)
{
co_obj_free(current->key);
}
current->value = value;
current->key = co_str8_create(orig_key, orig_klen, 0);
hattach(current->key, current);
hattach(current->value, current);
current->key->_ref++;
current->value->_ref++;
}
}
else
{
current->high = _co_tree_insert_r(root, current->high, orig_key, orig_klen, key, klen, value);
}
return current;
}
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;
}
int
co_request_append_str(co_obj_t *request, const char *s, const size_t slen)
{
CHECK_MEM(request);
CHECK_MEM(s);
CHECK(IS_LIST(request), "Not a valid request.");
CHECK(slen < UINT32_MAX, "String is too large.");
if(slen > UINT16_MAX) return co_list_append(request, co_str32_create(s, slen, 0));
if(slen > UINT8_MAX) return co_list_append(request, co_str16_create(s, slen, 0));
return co_list_append(request, co_str8_create(s, slen, 0));
error:
return 0;
}
void TreeTest::InsertObj()
{
ret = co_tree_insert(Tree16, "1TESTKEY1", 10, TestString1);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree16, "1TESTKEY1", 10);
ASSERT_EQ(TestString1, ptr);
ret = co_tree_insert(Tree16, "2TESTKEY2", 10, TestString2);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree16, "2TESTKEY2", 10);
ASSERT_EQ(TestString2, ptr);
ret = co_tree_insert_force(Tree16, "1TESTKEY1", 10, ReplaceString1);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree16, "1TESTKEY1", 10);
ASSERT_EQ(ReplaceString1, ptr);
// reinitialize TestString1 since it was freed by co_tree_insert_force()
TestString1 = co_str8_create("1TESTVALUE1", 12, 0);
// repeat for Tree 32
ret = co_tree_insert(Tree32, "1TESTKEY1", 10, TestString1);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree32, "1TESTKEY1", 10);
ASSERT_EQ(TestString1, ptr);
ret = co_tree_insert(Tree32, "2TESTKEY2", 10, TestString2);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree32, "2TESTKEY2", 10);
ASSERT_EQ(TestString2, ptr);
ret = co_tree_insert_force(Tree32, "1TESTKEY1", 10, ReplaceString1);
ASSERT_EQ(1, ret);
ptr = co_tree_find(Tree32, "1TESTKEY1", 10);
ASSERT_EQ(ReplaceString1, ptr);
}
int serval_crypto_handler(co_obj_t *self, co_obj_t **output, co_obj_t *params) {
CLEAR_ERR();
int list_len = co_list_length(params), keypath = 0;
CHECK_ERR(IS_LIST(params) && list_len >= 2,"Invalid params");
if (!strncmp("--keyring=",co_obj_data_ptr(co_list_get_last(params)),10)) {
keypath = 1;
--list_len;
}
if (co_str_cmp_str(co_list_element(params,0),"sign") == 0) {
CHECK_ERR(list_len == 2 || list_len == 3,"Invalid arguments");
char sig_buf[2*SIGNATURE_BYTES + 1] = {0};
if (list_len == 3) {
CHECK_ERR(cmd_serval_sign(_LIST_ELEMENT(params,1),
co_str_len(co_list_element(params,1)) - 1,
(unsigned char*)_LIST_ELEMENT(params,2),
co_str_len(co_list_element(params,2)) - 1,
sig_buf,
2*SIGNATURE_BYTES + 1,
keypath ? _LIST_ELEMENT(params,3) + 10 : NULL, // strlen("--length=") == 10
keypath ? co_str_len(co_list_element(params,3)) - 11 : 0),"Failed to create signature");
} else if (list_len == 2) {
CHECK_ERR(cmd_serval_sign(NULL,
0,
(unsigned char*)_LIST_ELEMENT(params,1),
co_str_len(co_list_element(params,1)) - 1,
sig_buf,
2*SIGNATURE_BYTES + 1,
keypath ? _LIST_ELEMENT(params,2) + 10 : NULL, // strlen("--length=") == 10
keypath ? co_str_len(co_list_element(params,2)) - 11 : 0),"Failed to create signature");
}
CMD_OUTPUT("result",co_str8_create(sig_buf,2*SIGNATURE_BYTES+1,0));
} else if (co_str_cmp_str(co_list_element(params,0),"verify") == 0) {
CHECK_ERR(!keypath,"Keyring option not available for verification");
CHECK_ERR(list_len == 4,"Invalid arguments");
int verdict = cmd_serval_verify(_LIST_ELEMENT(params,1),
co_str_len(co_list_element(params,1)) - 1,
(unsigned char*)_LIST_ELEMENT(params,3),
co_str_len(co_list_element(params,3)) - 1,
_LIST_ELEMENT(params,2),
co_str_len(co_list_element(params,2)) - 1);
// keypath ? _LIST_ELEMENT(params,4) + 10 : NULL, // strlen("--length=") == 10
// keypath ? co_str_len(co_list_element(params,4)) - 10 : 0);
if (verdict == 1) {
DEBUG("signature verified");
CMD_OUTPUT("result",co_bool_create(true,0)); // successfully verified
} else if (verdict == 0) {
DEBUG("signature NOT verified");
CMD_OUTPUT("result",co_bool_create(false,0));
}
}
return 1;
error:
INS_ERROR();
return 0;
}
int
serval_crypto_handler(co_obj_t *self, co_obj_t **output, co_obj_t *params)
{
CLEAR_ERR();
svl_crypto_ctx *ctx = NULL;
int list_len = co_list_length(params);
int keypath = 0;
CHECK_ERR(IS_LIST(params) && list_len >= 2, "Invalid params");
if (!strncmp("--keyring=", co_obj_data_ptr(co_list_get_last(params)), 10)) {
keypath = 1;
--list_len;
}
ctx = svl_crypto_ctx_new();
if (co_str_cmp_str(co_list_element(params, 0), "sign") == 0) {
CHECK_ERR(list_len == 2 || list_len == 3, "Invalid arguments");
if (list_len == 3) {
char *sid_str = _LIST_ELEMENT(params, 1);
size_t sid_len = co_str_len(co_list_element(params, 1)) - 1;
CHECK_ERR(sid_len == (2 * SID_SIZE) && str_is_subscriber_id(sid_str) == 1,
"Invalid SID");
stowSid(ctx->sid, 0, sid_str);
ctx->msg = (unsigned char*)_LIST_ELEMENT(params, 2);
ctx->msg_len = co_str_len(co_list_element(params, 2)) - 1;
if (keypath) {
ctx->keyring_path = _LIST_ELEMENT(params, 3) + 10;
ctx->keyring_len = co_str_len(co_list_element(params, 3)) - 11;
CHECK_ERR(ctx->keyring_len < PATH_MAX,"Keyring path too long");
}
} else if (list_len == 2) {
ctx->msg = (unsigned char*)_LIST_ELEMENT(params, 1);
ctx->msg_len = co_str_len(co_list_element(params, 1)) - 1;
if (keypath) {
ctx->keyring_path = _LIST_ELEMENT(params, 2) + 10;
ctx->keyring_len = co_str_len(co_list_element(params, 2)) - 11;
CHECK_ERR(ctx->keyring_len < PATH_MAX,"Keyring path too long");
}
}
CHECK_ERR(cmd_serval_sign(ctx), "Failed to create signature");
// convert ctx->signature, ctx->sas_public, and ctx->sid to hex:
char sid_str[(2 * SID_SIZE) + 1] = {0};
strncpy(sid_str, alloca_tohex(ctx->sid, SID_SIZE), 2 * SID_SIZE);
char sas_str[(2 * crypto_sign_PUBLICKEYBYTES) + 1] = {0};
strncpy(sas_str, alloca_tohex(ctx->sas_public, crypto_sign_PUBLICKEYBYTES), 2 * crypto_sign_PUBLICKEYBYTES);
char sig_str[(2 * SIGNATURE_BYTES) + 1] = {0};
strncpy(sig_str, alloca_tohex(ctx->signature, SIGNATURE_BYTES), 2 * SIGNATURE_BYTES);
CMD_OUTPUT("SID", co_str8_create(sid_str, (2 * SID_SIZE) + 1, 0));
CMD_OUTPUT("SAS", co_str8_create(sas_str, (2 * crypto_sign_PUBLICKEYBYTES) + 1, 0));
CMD_OUTPUT("signature", co_str8_create(sig_str, (2 * SIGNATURE_BYTES) + 1, 0));
} else if (co_str_cmp_str(co_list_element(params, 0), "verify") == 0) {
CHECK_ERR(!keypath, "Keyring option not available for verification");
CHECK_ERR(list_len == 4, "Invalid arguments");
// convert SAS and signature from hex to bin
CHECK_ERR(fromhexstr(ctx->signature, _LIST_ELEMENT(params, 2), SIGNATURE_BYTES) == 0, "Invalid signature");
CHECK_ERR(fromhexstr(ctx->sas_public, _LIST_ELEMENT(params, 1), crypto_sign_PUBLICKEYBYTES) == 0, "Invalid SAS key");
ctx->msg = (unsigned char*)_LIST_ELEMENT(params, 3);
ctx->msg_len = co_str_len(co_list_element(params, 3)) - 1;
int verdict = cmd_serval_verify(ctx);
if (verdict == 1) {
DEBUG("signature verified");
CMD_OUTPUT("result", co_bool_create(true, 0)); // successfully verified
CMD_OUTPUT("verified",co_str8_create("true",sizeof("true"),0));
} else if (verdict == 0) {
DEBUG("signature NOT verified");
CMD_OUTPUT("result", co_bool_create(false, 0));
CMD_OUTPUT("verified",co_str8_create("false",sizeof("false"),0));
}
}
error:
INS_ERROR();
if (ctx)
svl_crypto_ctx_free(ctx);
return 1;
}
