static void a_copy_test(void) {
printsln((String)__func__);
Array array, copy;
array = sa_of_string("-1, -2, -3");
copy = a_copy(array);
sa_check_expect(copy, array);
sa_free(array);
a_free(copy);
array = sa_of_string("10");
copy = a_copy(array);
sa_check_expect(copy, array);
sa_free(array);
a_free(copy);
array = sa_of_string("100, -200");
copy = a_copy(array);
sa_check_expect(copy, array);
sa_free(array);
a_free(copy);
array = sa_of_string("");
copy = a_copy(array);
sa_check_expect(copy, array);
sa_free(array);
a_free(copy);
}
int parse_mathematical_input(const char* str, fp_t *val) {
errlevel = 0;
char *stripped = strip_all_whitespace(str);
if (!check_alphanumeric_validity(stripped)) {
sa_free(stripped);
return 0;
}
int pb = check_parenthesis_balance(stripped);
if (pb != 0) {
parse_error(ERR_BAD_PARENTHESIS, "NULL", 0);
sa_free(stripped);
return 0;
}
struct term_t t = term_create(stripped, 1);
term_get_result(&t, 0);
fp_t_assign(val, t.value);
sa_free(stripped);
return errlevel == 0;
}
static void sa_reverse_test(void) {
printsln((String)__func__);
Array ac, ex;
ac = sa_of_string("1, 2, 3");
ex = sa_of_string("3, 2, 1");
a_reverse(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_of_string("1, 2, 3, 4");
ex = sa_of_string("4, 3, 2, 1");
a_reverse(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_create(0, "");
ex = sa_create(0, "");
a_reverse(ac);
sa_check_expect(ac, ex);
a_free(ac);
a_free(ex);
ac = sa_create(0, "x");
ex = sa_create(0, "x");
a_reverse(ac);
sa_check_expect(ac, ex);
a_free(ac);
a_free(ex);
}
void
ikev2_msg_retransmit_timeout(struct iked *env, void *arg)
{
struct iked_message *msg = arg;
struct iked_sa *sa = msg->msg_sa;
if (msg->msg_tries < IKED_RETRANSMIT_TRIES) {
if (sendtofrom(msg->msg_fd, ibuf_data(msg->msg_data),
ibuf_size(msg->msg_data), 0,
(struct sockaddr *)&msg->msg_peer, msg->msg_peerlen,
(struct sockaddr *)&msg->msg_local,
msg->msg_locallen) == -1) {
log_warn("%s: sendtofrom", __func__);
sa_free(env, sa);
return;
}
/* Exponential timeout */
timer_add(env, &msg->msg_timer,
IKED_RETRANSMIT_TIMEOUT * (2 << (msg->msg_tries++)));
} else {
log_debug("%s: retransmit limit reached for msgid %u",
__func__, msg->msg_msgid);
sa_free(env, sa);
}
}
static int
setMcastInfo(
McastInfo** const mcastInfo,
const feedtypet feedtype)
{
ServiceAddr* mcastServAddr;
int status = sa_new(&mcastServAddr, "224.0.0.1", 38800);
if (status) {
LOG_ADD0("Couldn't create multicast service address object");
}
else {
ServiceAddr* ucastServAddr;
status = sa_new(&ucastServAddr, LOCAL_HOST, 0);
if (status) {
LOG_ADD0("Couldn't create unicast service address object");
}
else {
status = mi_new(mcastInfo, feedtype, mcastServAddr, ucastServAddr);
if (status) {
LOG_ADD0("Couldn't create multicast information object");
}
else {
sa_free(ucastServAddr);
sa_free(mcastServAddr);
}
}
}
return status;
}
static void sa_foldl_state_test(void) {
printsln((String)__func__);
Array a;
// compute total length of all strings in array
a = sa_of_string("11, 22, 33, 44");
int length = 0;
sa_foldl_state(a, f_length, &length);
check_expect_i(length, 8);
sa_free(a);
a = sa_of_string("11, 22, 33, ");
length = 0;
sa_foldl_state(a, f_length, &length);
check_expect_i(length, 6);
sa_free(a);
a = sa_of_string(", 22, 33, ");
length = 0;
sa_foldl_state(a, f_length, &length);
check_expect_i(length, 4);
sa_free(a);
a = sa_of_string(", , , ");
length = 0;
sa_foldl_state(a, f_length, &length);
check_expect_i(length, 0);
sa_free(a);
a = sa_of_string("");
length = 0;
sa_foldl_state(a, f_length, &length);
check_expect_i(length, 0);
sa_free(a);
}
static void sa_sort_dec_ignore_case_test(void) {
printsln((String)__func__);
Array ac, ex;
ac = sa_of_string("a, b, c, A, B");
ex = sa_of_string("c, b, B, a, A");
sa_sort_dec_ignore_case(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
}
static void sa_filter_test(void) {
printsln((String)__func__);
Array a, ac, ex;
a = sa_of_string("Kürbis, Brombeere, Heidelbeere, Himbeere, Apfel");
ac = sa_filter(a, f_ends_width, "beere");
ex = sa_of_string("Brombeere, Heidelbeere, Himbeere");
sa_check_expect(ac, ex);
sa_free(a);
a_free(ac);
sa_free(ex);
}
void
sa_close_mmap(SA_MMAP *mms)
{
if (mms != NULL) {
UnmapViewOfFile(mms->map);
CloseHandle(((MMAP_HANDLES *)(mms->other))->hMap);
CloseHandle(((MMAP_HANDLES *)(mms->other))->hFile);
if (mms->other != NULL)
sa_free((MMAP_HANDLES *)(mms->other));
sa_free(mms);
}
}
static void
init()
{
ServiceAddr* groupAddr = sa_new(GROUP_ADDR, GROUP_PORT);
OP_ASSERT_TRUE(groupAddr != NULL);
ServiceAddr* serverAddr = sa_new(SERVER_ADDR, SERVER_PORT);
OP_ASSERT_TRUE(serverAddr != NULL);
mcastInfo = mi_new(feedtype, groupAddr, serverAddr);
OP_ASSERT_TRUE(mcastInfo != NULL);
sa_free(groupAddr);
sa_free(serverAddr);
prodQ = (void*)2;
}
static void sa_choose_test(void) {
printsln((String)__func__);
Array a, ac, ex;
a = sa_of_string("a1, a2, b3, b4, a5, b6");
ac = sa_choose(a, starts_with_toupper, "a");
ex = sa_of_string("A1, A2, A5");
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
sa_free(a);
}
static void sa_sort_dec_test(void) {
printsln((String)__func__);
Array ac, ex;
ac = sa_of_string("1, 2, 3, 4, 5");
ex = sa_of_string("5, 4, 3, 2, 1");
a_shuffle(ac);
sa_sort_dec(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_of_string("1, 2, 1, 3, 2");
ex = sa_of_string("3, 2, 2, 1, 1");
sa_sort_dec(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_of_string("");
ex = sa_of_string("");
sa_sort_dec(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_of_string("-3, -2, -1");
ex = sa_of_string("-3, -2, -1"); // decreasing order alphabetically, not numerically!
sa_sort_dec(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
}
static void sa_sort_test(void) {
printsln((String)__func__);
Array ac, ex;
ac = sa_of_string("1, 2, 3, 4, 5");
ex = sa_of_string("1, 2, 3, 4, 5");
a_shuffle(ac);
sa_sort(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_of_string("1, 2, 1, 3, 2");
ex = sa_of_string("1, 1, 2, 2, 3");
sa_sort(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_of_string("");
ex = sa_of_string("");
sa_sort(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
ac = sa_of_string("-1, -2, -3, -1");
ex = sa_of_string("-1, -1, -2, -3"); // alphabetic, not numeric sort
sa_sort(ac);
sa_check_expect(ac, ex);
sa_free(ac);
sa_free(ex);
}
/* Delete an SA. Tell the peer if NOTIFY is set. */
void
sa_delete(struct sa *sa, int notify)
{
if (notify)
message_send_delete(sa);
sa_free(sa);
}
static void sa_forall_test(void) {
printsln((String)__func__);
Array a = sa_of_string("1, 2, 3, 4, 5, 6");
check_expect_b(sa_forall(a, sa_element_eq, "3"), false);
check_expect_b(sa_forall(a, sa_element_ne, "9"), true);
sa_free(a);
}
void
sa_close_mmap(SA_MMAP *mms)
{
if (mms != NULL) {
munmap(mms->map, mms->size);
sa_free(mms);
}
}
static void sa_last_index_test(void) {
printsln((String)__func__);
Array a = sa_of_string("10, 20, 30, 10, 20, 30");
check_expect_i(sa_last_index(a, "20"), 4);
check_expect_i(sa_last_index(a, "30"), 5);
check_expect_i(sa_last_index(a, "60"), -1);
sa_free(a);
}
static void sa_shuffle_test(void) {
printsln((String)__func__);
Array a = sa_of_string("1, 2, 3, 4, 5, 6, 7, 8, 9, 10");
sa_println(a);
a_shuffle(a);
sa_println(a);
sa_free(a);
}
static void sa_foldl_test(void) {
printsln((String)__func__);
Array a;
String s;
a = sa_of_string("a, b, c");
s = sa_foldl(a, sa_concat, s_copy("init"));
check_expect_s(s, "initabc");
s_free(s);
sa_free(a);
a = sa_of_string("");
s = sa_foldl(a, sa_concat, s_copy("init"));
check_expect_s(s, "init");
s_free(s);
sa_free(a);
}
static void sa_contains_test(void) {
printsln((String)__func__);
Array array;
array = sa_of_string("10, 20, 30");
check_expect_b(sa_contains(array, "10"), true);
check_expect_b(sa_contains(array, "11"), false);
check_expect_b(sa_contains(array, "30"), true);
sa_free(array);
}
static void sa_last_index_from_test(void) {
printsln((String)__func__);
Array a = sa_of_string("10, 20, 30, 10, 20, 30");
check_expect_i(sa_last_index_from(a, "20", 5), 4);
check_expect_i(sa_last_index_from(a, "20", 4), 4);
check_expect_i(sa_last_index_from(a, "20", 3), 1);
check_expect_i(sa_last_index_from(a, "30", 2), 2);
check_expect_i(sa_last_index_from(a, "30", 1), -1);
sa_free(a);
}
static void sa_of_string_test(void) {
printsln((String)__func__);
Array ac, ex;
ac = sa_of_string("1, 2, 3");
ex = sa_create(3, "");
sa_set(ex, 0, "1");
sa_set(ex, 1, "2");
sa_set(ex, 2, "3");
sa_check_expect(ac, ex);
sa_free(ac);
ac = sa_of_string("1 , 2, 3 ");
sa_set(ex, 0, "1 ");
sa_set(ex, 1, "2");
sa_set(ex, 2, "3 ");
sa_check_expect(ac, ex);
sa_free(ac);
a_free(ex);
ac = sa_of_string("1 , 2");
ex = sa_create(2, "");
sa_set(ex, 0, "1 ");
sa_set(ex, 1, "2");
sa_check_expect(ac, ex);
sa_free(ac);
a_free(ex);
ac = sa_of_string("");
ex = sa_create(1, "");
sa_check_expect(ac, ex);
sa_free(ac);
a_free(ex);
ac = sa_of_string("123");
ex = sa_create(1, "123");
sa_check_expect(ac, ex);
sa_free(ac);
a_free(ex);
}
static void a_sub_test(void) {
printsln((String)__func__);
Array array, array2, sub;
array = sa_of_string("1, 2, 3, 4");
sub = a_sub(array, 0, a_length(array));
sa_check_expect(array, sub);
a_free(sub);
sub = a_sub(array, -1, a_length(array) + 1);
sa_check_expect(array, sub);
a_free(sub);
array2 = sa_of_string("2, 3, 4");
// sa_println(array2);
// printiln(a_length(array2));
sub = a_sub(array, 1, a_length(array));
sa_check_expect(array2, sub);
sa_free(array2);
a_free(sub);
array2 = sa_of_string("2, 3");
sub = a_sub(array, 1, a_length(array) - 1);
sa_check_expect(array2, sub);
sa_free(array2);
a_free(sub);
array2 = sa_create(0, "");
sub = a_sub(array, 1, 1);
sa_check_expect(array2, sub);
a_free(sub);
sub = a_sub(array, 2, 1);
sa_check_expect(array2, sub);
sa_free(array2);
a_free(sub);
sa_free(array);
}
void *worker(void *arg)
{
int i, j;
void *items[CONCURRENT];
for (i=0; i<CONCURRENT; i++)
items[i]=NULL;
inc(&b1);
while (b1!=(NWORKER));
inc(&b2);
while (b2!=(NWORKER));
for (j=0; j<NITER; j++) {
/* get i from 0 to CONCURRENT -1 */
i=rand()%CONCURRENT;
if (items[i]) {
sa_free(&sa, items[i]);
items[i]=NULL;
}
else
items[i]=sa_alloc(&sa);
}
dec(&b1);
while (b1!=0);
dec(&b2);
while (b2!=0);
for (i=0; i<CONCURRENT; i++)
if (items[i]) {
sa_free(&sa, items[i]);
items[i]=NULL;
}
return NULL;
}
static void
test_sa_parseWithDefaults(void)
{
ServiceAddr* sa;
int status;
const char* hostId = "uni14.unidata.ucar.edu";
const short port = 388;
status = sa_parseWithDefaults(&sa, hostId, NULL, 388);
log_flush_error();
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_STRING_EQUAL(sa_getInetId(sa), hostId);
CU_ASSERT_EQUAL(sa_getPort(sa), port);
sa_free(sa);
}
int
ikev2_msg_retransmit_response(struct iked *env, struct iked_sa *sa,
struct iked_message *msg)
{
if ((sendto(msg->msg_fd, ibuf_data(msg->msg_data),
ibuf_size(msg->msg_data), 0, (struct sockaddr *)&msg->msg_peer,
msg->msg_peerlen)) == -1) {
log_warn("%s: sendto", __func__);
sa_free(env, sa);
return (-1);
}
timer_register(env, &msg->msg_timer, IKED_RESPONSE_TIMEOUT);
return (0);
}
static void destroy_sa_list (SA *sa, sa_list *node, int flush)
{
/*
* recursively destroy the spi list. 1st tell the kernel to delete
* its corresponding security association, then remove from our list
*/
if(node->next != NULL){
destroy_sa_list(sa, node->next, flush);
}
#if 0
if(flush)
kernel_delete_spi(sa, node->spi);
#endif
sa_free(node);
free(node);
}
/*
* open and map a file
*/
SA_MMAP *
sa_open_mmap(const char *fname, const SA_MMAP_MODE mode)
{
SA_MMAP *mm;
mm = sa_malloc(sizeof(SA_MMAP));
if (mm == NULL)
return NULL;
if (sa_open_mmap_aux(mm, fname, mode)) {
sa_free(mm);
return NULL;
}
return mm;
}
static int term_varfuncid_strcmp_pass(struct term_t *term) {
int i = 0;
for (; i < functions_table_size; ++i) {
char *b;
if ((b = strstr(term->string, functions[i].key)) == &term->string[0]) {
int opening_par_pos = functions[i].key_len;
int closing_par_pos = find_matching_parenthesis(term->string, opening_par_pos);
int tlen = closing_par_pos - opening_par_pos;
if (tlen <= 0) {
parse_error(ERR_INTERNAL, NULL, 0);
return -1;
} else if (closing_par_pos < (strlen(term->string) - 1)) {
parse_error(ERR_TRAILING_PARINPUT, term->string, closing_par_pos + 1);
return -1;
}
char *argstr = substring(term->string, opening_par_pos, tlen+1);
struct term_t arg_term = term_create(argstr, 1);
term_get_result(&arg_term, 0);
functions[i].funcptr(&term->value, arg_term.value);
sa_free(argstr);
return 1;
}
}
for (i = 0; i < constants_table_size; ++i) {
if (strcmp(term->string, constants[i].key) == 0) {
fp_t_assign(&term->value, constants[i].value);
return 1;
}
}
struct udc_node *n = udctree_search(term->string);
if (n) {
fp_t_assign(&term->value, n->pair.value);
return 1;
}
return 0;
}
static void
sa_parse_test(
const char* const inetId,
const unsigned short port)
{
ServiceAddr* sa;
char* buf = ldm_format(80, strchr(inetId, ':') ? "[%s]:%d" : "%s:%d",
inetId, port);
int status;
CU_ASSERT_PTR_NOT_NULL_FATAL(buf);
status = sa_parse(&sa, buf);
log_flush_error();
CU_ASSERT_EQUAL_FATAL(status, 0);
CU_ASSERT_STRING_EQUAL(sa_getInetId(sa), inetId);
CU_ASSERT_EQUAL(sa_getPort(sa), port);
sa_free(sa);
}
