static void
test_parse_packet_igmp_query_v2_succeeds() {
const char filename[] = "./unittests/lib/test_packets/igmp_query_v2.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->format, ETH_IPV4_IGMP );
u_char macda[] = { 0x01, 0x00, 0x5e, 0x00, 0x00, 0x01 };
u_char macsa[] = { 0x8c, 0x89, 0xa5, 0x15, 0x84, 0xcb };
assert_memory_equal( packet_info->eth_macda, macda, ETH_ADDRLEN );
assert_memory_equal( packet_info->eth_macsa, macsa, ETH_ADDRLEN );
assert_int_equal( packet_info->l2_payload_length, 32 );
assert_int_equal( packet_info->igmp_type, IGMP_MEMBERSHIP_QUERY );
assert_int_equal( packet_info->igmp_code, 100 );
assert_int_equal( packet_info->igmp_checksum, 0xee9b );
assert_int_equal( packet_info->igmp_group, 0 );
assert_true( packet_type_igmp_membership_query( buffer ) );
free_buffer( buffer );
}
static void test_bytes_node_element_at(void **state)
{
struct bytes_node *head = bytes_node_init_from_str("It");
struct bytes *word_2 = bytes_init_from_str("was");
struct bytes *word_3 = bytes_init_from_str("the");
struct bytes *word_4 = bytes_init_from_str("best");
bytes_node_add(head, word_2);
bytes_node_add(head, word_3);
bytes_node_add(head, word_4);
assert_memory_equal(bytes_node_element_at(head, 1)->bytes->data,
word_2->data, word_2->len *
sizeof(word_2->data[0]));
assert_memory_equal(bytes_node_element_at(head, 2)->bytes->data,
word_3->data, word_3->len *
sizeof(word_3->data[0]));
assert_memory_equal(bytes_node_element_at(head, 3)->bytes->data,
word_4->data, word_4->len *
sizeof(word_4->data[0]));
bytes_put(word_4);
bytes_put(word_3);
bytes_put(word_2);
bytes_node_put(head);
}
static void test_sysdb_attrs_add_base64_blob(void **state)
{
struct sysdb_attrs *attrs;
struct ldb_message_element *el;
char zero[] = { '\1', '\2', '\3' };
int ret;
attrs = sysdb_new_attrs(NULL);
assert_non_null(attrs);
ret = sysdb_attrs_add_base64_blob(attrs, "testAttrABC", TEST_BASE64_ABC);
assert_int_equal(ret, EOK);
ret = sysdb_attrs_add_base64_blob(attrs, "testAttr000", TEST_BASE64_123);
assert_int_equal(ret, EOK);
ret = sysdb_attrs_get_el(attrs, "testAttrABC", &el);
assert_int_equal(ret, EOK);
assert_int_equal(el->num_values, 1);
assert_non_null(el->values);
assert_non_null(el->values[0].data);
assert_int_equal(el->values[0].length, 3);
assert_memory_equal(el->values[0].data, "abc", 3);
ret = sysdb_attrs_get_el(attrs, "testAttr000", &el);
assert_int_equal(ret, EOK);
assert_int_equal(el->num_values, 1);
assert_non_null(el->values);
assert_non_null(el->values[0].data);
assert_int_equal(el->values[0].length, 3);
assert_memory_equal(el->values[0].data, zero, 3);
}
/* Basic behavior tests */
static void
test_irange_basic(void **state)
{
IndexRange irange;
List *irange_list;
/* test irb_pred() */
assert_int_equal(99, irb_pred(100));
assert_int_equal(0, irb_pred(1));
assert_int_equal(0, irb_pred(0));
/* test irb_succ() */
assert_int_equal(100, irb_succ(99));
assert_int_equal(IRANGE_BOUNDARY_MASK, irb_succ(IRANGE_BOUNDARY_MASK));
assert_int_equal(IRANGE_BOUNDARY_MASK, irb_succ(IRANGE_BOUNDARY_MASK + 1));
/* test convenience macros */
irange = make_irange(0, IRANGE_BOUNDARY_MASK, IR_LOSSY);
assert_int_equal(irange_lower(irange), 0);
assert_int_equal(irange_upper(irange), IRANGE_BOUNDARY_MASK);
assert_true(is_irange_lossy(irange));
assert_true(is_irange_valid(irange));
/* test allocation */
irange_list = NIL;
irange_list = lappend_irange(irange_list, irange);
assert_memory_equal(&irange, &linitial_irange(irange_list), sizeof(IndexRange));
assert_memory_equal(&irange, &llast_irange(irange_list), sizeof(IndexRange));
}
static void
test_parse_packet_arp_request_succeeds() {
const char filename[] = "./unittests/lib/test_packets/arp_req.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->format, ETH_ARP );
u_char macda[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
u_char macsa[] = { 0x8c, 0x89, 0xa5, 0x16, 0x22, 0x09 };
assert_memory_equal( packet_info->eth_macda, macda, ETH_ADDRLEN );
assert_memory_equal( packet_info->eth_macsa, macsa, ETH_ADDRLEN );
assert_int_equal( packet_info->eth_type, ETH_ETHTYPE_ARP );
assert_int_equal( packet_info->l2_payload_length, 46 );
assert_int_equal( packet_info->arp_ar_hrd, 0x0001 );
assert_int_equal( packet_info->arp_ar_pro, 0x0800 );
assert_int_equal( packet_info->arp_ar_hln, 6 );
assert_int_equal( packet_info->arp_ar_pln, 4 );
assert_int_equal( packet_info->arp_ar_op, 1 );
assert_int_equal( packet_info->arp_spa, 0xc0a8642c );
assert_memory_equal( packet_info->arp_sha, macsa, ETH_ADDRLEN );
assert_int_equal( packet_info->arp_tpa, 0xc0a8642b );
u_char maczero[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
assert_memory_equal( packet_info->arp_tha, maczero, ETH_ADDRLEN );
assert_true( packet_type_arp_request( buffer ) );
assert_false( packet_type_arp_reply( buffer ) );
free_buffer( buffer );
}
static void
test_parse_packet_ipv6_succeeds() {
const char filename[] = "./unittests/lib/test_packets/icmp6_echo_req.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->ipv6_version, 6 );
assert_int_equal( packet_info->ipv6_tc, 0 );
assert_int_equal( packet_info->ipv6_flowlabel, 0 );
assert_int_equal( packet_info->ipv6_plen, 0x40 );
assert_int_equal( packet_info->ipv6_nexthdr, 0x3a );
assert_int_equal( packet_info->ipv6_hoplimit, 0x40 );
u_char saddr[] = { 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x8e, 0x89, 0xa5, 0xff, 0xfe, 0x16, 0x22, 0x09 };
u_char daddr[] = { 0xfe, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0x8e, 0x89, 0xa5, 0xff, 0xfe, 0x15, 0x84, 0xcb };
assert_memory_equal( packet_info->ipv6_saddr, saddr, IPV6_ADDRLEN );
assert_memory_equal( packet_info->ipv6_daddr, daddr, IPV6_ADDRLEN );
free_buffer( buffer );
}
static void brigade_flatten_leftover(void **state)
{
char buf[80];
char bufcmp[80];
char buf2[2];
char bufcmp2[2];
size_t len = sizeof(buf);
size_t len2 = sizeof(buf2);
sln_brigade_t *bb;
sln_bucket_t *e1;
sln_bucket_t *e2;
SLN_ERR(sln_brigade_create(&bb));
SLN_ERR(sln_bucket_create_empty(&e1, 40));
memset(e1->data, 'A', e1->size);
SLN_BRIGADE_INSERT_TAIL(bb, e1);
SLN_ERR(sln_bucket_create_empty(&e2, 42));
memset(e2->data, 'B', e2->size);
SLN_BRIGADE_INSERT_TAIL(bb, e2);
SLN_ERR(sln_brigade_flatten(bb, &buf[0], &len));
assert_int_equal(len, 80);
assert_int_equal(sln_brigade_size(bb), 2);
SLN_ERR(sln_brigade_flatten(bb, &buf2[0], &len2));
assert_int_equal(len2, 2);
sln_brigade_destroy(bb);
memset(&bufcmp[0], 'A', 40);
memset(&bufcmp[0]+40, 'B', 40);
assert_memory_equal(buf, bufcmp, 80);
memset(&bufcmp2[0], 'B', 2);
assert_memory_equal(buf2, bufcmp2, 2);
}
static void brigade_pread_simple(void **state)
{
sln_brigade_t *bb;
sln_bucket_t *e;
char buf[5];
size_t len = 0;
SLN_ERR(sln_brigade_create(&bb));
SLN_ERR(sln_bucket_create_empty(&e, 20));
SLN_BRIGADE_INSERT_TAIL(bb, e);
memset(e->data, 'B', e->size);
memset(e->data, 'A', 1);
SLN_ERR(sln_brigade_pread_bytes(bb, 0, 1, &buf[0], &len));
assert_int_equal(len, 1);
assert_memory_equal(buf, "A", 1);
SLN_ERR(sln_brigade_pread_bytes(bb, 1, 1, &buf[0], &len));
assert_int_equal(len, 1);
assert_memory_equal(buf, "B", 1);
SLN_ERR(sln_brigade_pread_bytes(bb, 0, 2, &buf[0], &len));
assert_int_equal(len, 2);
assert_memory_equal(buf, "AB", 2);
SLN_ERR(sln_brigade_pread_bytes(bb, 2, 2, &buf[0], &len));
assert_int_equal(len, 2);
assert_memory_equal(buf, "BB", 2);
sln_brigade_destroy(bb);
}
static void test_bytestostr(void **state)
{
char *ans_1 = "this is how the world ends...";
char *ans_2 = "the quick brown fox jumps over the lazy dog";
char *ans_3 = "that's all folks";
struct bytes *b_1 = bytes_init_from_str(ans_1);
struct bytes *b_2 = bytes_init_from_str(ans_2);
struct bytes *b_3 = bytes_init_from_str(ans_3);
char *res_1 = malloc(b_1->len * sizeof(*res_1) + 1);
char *res_2 = malloc(b_2->len * sizeof(*res_2) + 1);
char *res_3 = malloc(b_3->len * sizeof(*res_3) + 1);
bytestostr(res_1, b_1);
bytestostr(res_2, b_2);
bytestostr(res_3, b_3);
assert_memory_equal(res_1, ans_1, strlen(ans_1));
assert_memory_equal(res_2, ans_2, strlen(ans_2));
assert_memory_equal(res_3, ans_3, strlen(ans_3));
free(res_1);
free(res_2);
free(res_3);
bytes_put(b_1);
bytes_put(b_2);
bytes_put(b_3);
}
static void brigade_copy_into(void **state)
{
sln_brigade_t *source;
sln_brigade_t *dest;
sln_bucket_t *e1;
char buf[20];
size_t len = 0;
SLN_ERR(sln_brigade_create(sln_test_alloc, &source));
SLN_ERR(sln_bucket_create_empty(sln_test_alloc, &e1, 10));
SLN_BRIGADE_INSERT_TAIL(source, e1);
memset(e1->data, 'A', e1->size);
SLN_ERR(sln_brigade_create(sln_test_alloc, &dest));
SLN_ERR(sln_brigade_copy_into(source, 0, 10, dest));
assert_int_equal(sln_brigade_size(dest), 10);
SLN_ERR(sln_brigade_pread_bytes(dest, 0, 10, &buf[0], &len));
assert_memory_equal(buf, "AAAAAAAAAA", 2);
sln_brigade_clear(dest);
sln_brigade_destroy(dest);
SLN_ERR(sln_brigade_create(sln_test_alloc, &dest));
SLN_ERR(sln_brigade_copy_into(source, 2, 4, dest));
assert_int_equal(sln_brigade_size(dest), 4);
SLN_ERR(sln_brigade_pread_bytes(dest, 0, 4, &buf[0], &len));
assert_memory_equal(buf, "AAAA", 4);
sln_brigade_clear(dest);
sln_brigade_destroy(dest);
sln_brigade_destroy(source);
}
static void
test_parse_packet_snap_succeeds() {
const char filename[] = "./unittests/lib/test_packets/ipx.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->format, ETH_8023_SNAP );
u_char macda[] = { 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };
u_char macsa[] = { 0x00, 0x19, 0xdb, 0x17, 0xb9, 0x6f };
assert_memory_equal( packet_info->eth_macda, macda, ETH_ADDRLEN );
assert_memory_equal( packet_info->eth_macsa, macsa, ETH_ADDRLEN );
assert_true( packet_info->eth_type < ETH_MTU );
u_char llc[] = { 0xe0, 0xe0, 0x03 };
u_char oui[] = { 0xff, 0xff, 0x00 };
assert_memory_equal( packet_info->snap_llc, llc, SNAP_LLC_LENGTH );
assert_memory_equal( packet_info->snap_oui, oui, SNAP_OUI_LENGTH );
assert_int_equal( packet_info->snap_type, 0xb700 );
uint16_t sample = ntohs( *( uint16_t * ) packet_info->l2_payload );
assert_int_equal( sample, 0x0400 );
assert_int_equal( packet_info->l2_payload_length, 0xb2 );
free_buffer( buffer );
}
void test_migrate_unqualified_names(void)
{
DBHandle *db = setup(true);
assert_int_equal(WriteDB(db, "foo", &dummy_event, sizeof(dummy_event)), true);
assert_int_equal(WriteDB(db, "q.bar", &dummy_event, sizeof(dummy_event)), true);
CloseDB(db);
assert_int_equal(OpenDB(&db, dbid_bundles), true);
/* Old entry migrated */
assert_int_equal(HasKeyDB(db, "foo", strlen("foo") + 1), false);
assert_int_equal(HasKeyDB(db, "default.foo", strlen("default.foo") + 1), true);
Event read_value = { 0 };
ReadDB(db, "default.foo", &read_value, sizeof(read_value));
assert_memory_equal(&read_value, &dummy_event, sizeof(dummy_event));
/* New entry preserved */
assert_int_equal(HasKeyDB(db, "q.bar", strlen("q.bar") + 1), true);
memset(&read_value, 0, sizeof(read_value));
ReadDB(db, "q.bar", &read_value, sizeof(read_value));
assert_memory_equal(&read_value, &dummy_event, sizeof(dummy_event));
/* Version marker */
assert_int_equal(HasKeyDB(db, "version", strlen("version") + 1), true);
CloseDB(db);
}
void opt_test_get(void **state)
{
int ret;
struct sss_test_ctx *tctx;
struct dp_option *opts;
struct sss_test_conf_param params[] = {
{ "string_nodefault", "stringval2" },
{ "blob_nodefault", "blobval2" },
{ "int_nodefault", "456" },
{ "bool_true", "false" },
{ NULL, NULL }, /* Sentinel */
};
char *s;
struct dp_opt_blob b;
int i;
bool bo;
tctx = create_dom_test_ctx(global_talloc_context, TESTS_PATH, TEST_CONF_DB,
TEST_DOM_NAME, TEST_ID_PROVIDER, params);
assert_non_null(tctx);
ret = dp_get_options(global_talloc_context, tctx->confdb, tctx->conf_dom_path,
test_def_opts, OPT_NUM_OPTS, &opts);
assert_int_equal(ret, EOK);
/* Options that were not specified explicitly should only have the default
* value, those that have been specified explicitly should carry that
* value
*/
s = dp_opt_get_string(opts, OPT_STRING_NODEFAULT);
assert_non_null(s);
assert_string_equal(s, "stringval2");
s = dp_opt_get_string(opts, OPT_STRING_DEFAULT);
assert_non_null(s);
assert_string_equal(s, STRING_DEFAULT);
b = dp_opt_get_blob(opts, OPT_BLOB_NODEFAULT);
assert_non_null(b.data);
assert_int_equal(b.length, strlen("blobval2"));
assert_memory_equal(b.data, "blobval2", strlen("blobval2"));
b = dp_opt_get_blob(opts, OPT_BLOB_DEFAULT);
assert_non_null(b.data);
assert_int_equal(b.length, strlen(BLOB_DEFAULT));
assert_memory_equal(b.data, BLOB_DEFAULT, strlen(BLOB_DEFAULT));
i = dp_opt_get_int(opts, OPT_INT_NODEFAULT);
assert_int_equal(i, 456);
i = dp_opt_get_int(opts, OPT_INT_DEFAULT);
assert_int_equal(i, INT_DEFAULT);
bo = dp_opt_get_bool(opts, OPT_BOOL_TRUE);
assert_true(bo == false);
bo = dp_opt_get_bool(opts, OPT_BOOL_FALSE);
assert_true(bo == false);
}
static void
test_parse_packet_vtag_icmpv4_echo_reply_succeeds() {
const char filename[] = "./unittests/lib/test_packets/vtag_icmp_echo_rep.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->format, ETH_VTAG_IPV4_ICMPV4 );
u_char macda[] = { 0x00, 0x1f, 0x3c, 0x48, 0xad, 0x3a };
u_char macsa[] = { 0x00, 0x13, 0xd3, 0x40, 0x2e, 0x22 };
assert_memory_equal( packet_info->eth_macda, macda, ETH_ADDRLEN );
assert_memory_equal( packet_info->eth_macsa, macsa, ETH_ADDRLEN );
assert_int_equal( packet_info->vlan_tci, 0x6f9f );
assert_int_equal( packet_info->vlan_tpid, ETH_ETHTYPE_TPID );
assert_int_equal( packet_info->vlan_prio, 3 );
assert_int_equal( packet_info->vlan_cfi, 0 );
assert_int_equal( packet_info->vlan_vid, 0x0f9f );
assert_int_equal( packet_info->eth_type, ETH_ETHTYPE_IPV4 );
assert_int_equal( packet_info->l2_payload_length, 60 );
assert_int_equal( packet_info->ipv4_version, 4 );
assert_int_equal( packet_info->ipv4_ihl, 5 );
assert_int_equal( packet_info->ipv4_tos, 0 );
assert_int_equal( packet_info->ipv4_tot_len, 0x3c );
assert_int_equal( packet_info->ipv4_id, 0x1652 );
assert_int_equal( packet_info->ipv4_frag_off, 0 );
assert_int_equal( packet_info->ipv4_ttl, 0x40 );
assert_int_equal( packet_info->ipv4_protocol, IPPROTO_ICMP );
assert_int_equal( packet_info->ipv4_checksum, 0xa2d3 );
assert_int_equal( packet_info->ipv4_saddr, 0xc0a82001 );
assert_int_equal( packet_info->ipv4_daddr, 0xc0a8204a );
assert_int_equal( packet_info->l3_payload_length, 40 );
assert_int_equal( packet_info->icmpv4_type, ICMP_TYPE_ECHOREP );
assert_int_equal( packet_info->icmpv4_code, 0 );
assert_int_equal( packet_info->icmpv4_id, 1024 );
assert_int_equal( packet_info->icmpv4_seq, 24576 );
uint16_t sample = ntohs( *( uint16_t * ) packet_info->l4_payload );
assert_int_equal( sample, 0x6162 );
assert_int_equal( packet_info->l4_payload_length, 32 );
assert_false( packet_type_icmpv4_echo_request( buffer ) );
assert_false( packet_type_icmpv4_dst_unreach( buffer ) );
assert_false( packet_type_icmpv4_redirect( buffer ) );
assert_true( packet_type_icmpv4_echo_reply( buffer ) );
free_buffer( buffer );
}
static void arp_process_func(void** state) {
// Timer setting
timer_init("IntelCore(TM) i5-4670 CPU @ 3.40GHz");
// Nic initialization
void* malloc_pool = malloc(POOL_SIZE);
init_memory_pool(POOL_SIZE, malloc_pool, 0);
__nics[0] = malloc(sizeof(NIC));
__nic_count++;
__nics[0]->mac = 0x74d4358f66cb;
__nics[0]->pool_size = POOL_SIZE;
__nics[0]->pool = malloc_pool;
__nics[0]->output_buffer = fifo_create(8, malloc_pool);
__nics[0]->config = map_create(8, NULL, NULL, __nics[0]->pool);
// Arp request
Packet* packet = nic_alloc(__nics[0], sizeof(arp_request_packet));
memcpy(packet->buffer + packet->start, arp_request_packet, sizeof(arp_request_packet));
Ether* ether = (Ether*)(packet->buffer + packet->start);
ARP* arp = (ARP*)ether->payload;
uint32_t addr = endian32(arp->tpa);
nic_ip_add(__nics[0], addr);
assert_true(arp_process(packet));
packet = fifo_pop(__nics[0]->output_buffer);
assert_memory_equal(packet->buffer + packet->start, arp_reply_packet, 42);
nic_free(packet);
packet = NULL;
// Arp response
packet = nic_alloc(__nics[0], sizeof(arp_reply_packet));
memcpy(packet->buffer + packet->start, arp_reply_packet, sizeof(arp_reply_packet));
ether = (Ether*)(packet->buffer + packet->start);
arp = (ARP*)ether->payload;
addr = endian32(arp->tpa);
nic_ip_add(__nics[0], addr);
uint8_t comp_mac[6] = { 0xcb, 0x66, 0x8f, 0x35, 0xd4, 0x74 };
uint32_t sip = endian32(arp->spa);
Map* arp_table = nic_config_get(packet->nic, "net.arp.arptable");
assert_true(arp_process(packet));
ARPEntity* entity = map_get(arp_table, (void*)(uintptr_t)sip);
assert_memory_equal((uint8_t*)&entity->mac, comp_mac, 6);
destroy_memory_pool(malloc_pool);
free(malloc_pool);
malloc_pool = NULL;
}
static void strchr_func() {
char text[1024] = "`11223344567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:ZXCVBNM<>?\0";
int len = strlen(text);
for(int i = 0; i < len; i++) {
if(i < 10 && i != 0 && i % 2 == 0) {
char* str = __strchr(text, text[i]);
assert_memory_equal(str, text + i - 1, strlen(text + i - 1));
} else {
char* str = __strchr(text, text[i]);
assert_memory_equal(str, text + i, strlen(text + i));
}
}
}
static void
test_parse_packet_tcp_succeeds() {
const char filename[] = "./unittests/lib/test_packets/tcp.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->format, ETH_IPV4_TCP );
u_char macda[] = { 0x8c, 0x89, 0xa5, 0x15, 0x84, 0xcb };
u_char macsa[] = { 0x00, 0x16, 0x17, 0x00, 0x43, 0xf3 };
assert_memory_equal( packet_info->eth_macda, macda, ETH_ADDRLEN );
assert_memory_equal( packet_info->eth_macsa, macsa, ETH_ADDRLEN );
assert_int_equal( packet_info->eth_type, ETH_ETHTYPE_IPV4 );
assert_int_equal( packet_info->l2_payload_length, 82 );
assert_int_equal( packet_info->ipv4_version, 4 );
assert_int_equal( packet_info->ipv4_ihl, 5 );
assert_int_equal( packet_info->ipv4_tos, 0 );
assert_int_equal( packet_info->ipv4_tot_len, 0x01dd );
assert_int_equal( packet_info->ipv4_id, 0x0399 );
assert_int_equal( packet_info->ipv4_frag_off, 0x4000 );
assert_int_equal( packet_info->ipv4_ttl, 0x40 );
assert_int_equal( packet_info->ipv4_protocol, IPPROTO_TCP );
assert_int_equal( packet_info->ipv4_checksum, 0xeb24 );
assert_int_equal( packet_info->ipv4_saddr, 0xc0a864e1 );
assert_int_equal( packet_info->ipv4_daddr, 0xc0a8642b );
assert_int_equal( packet_info->l3_payload_length, 62 );
assert_int_equal( packet_info->tcp_src_port, 0x0050 );
assert_int_equal( packet_info->tcp_dst_port, 0xad49 );
assert_int_equal( packet_info->tcp_seq_no, 0x20656b68 );
assert_int_equal( packet_info->tcp_ack_no, 0x51de986e );
assert_int_equal( packet_info->tcp_offset, 0x8 );
assert_int_equal( packet_info->tcp_flags, 0x18 );
assert_int_equal( packet_info->tcp_window, 0x2086 );
assert_int_equal( packet_info->tcp_checksum, 0x4c2d );
assert_int_equal( packet_info->tcp_urgent, 0 );
uint16_t sample = ntohs( *( uint16_t * ) packet_info->l4_payload );
assert_int_equal( sample, 0x4854 );
assert_int_equal( packet_info->l4_payload_length, 30 );
free_buffer( buffer );
}
static void
test_parse_packet_icmpv4_echo_request_succeeds() {
const char filename[] = "./unittests/lib/test_packets/icmp_echo_req.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->format, ETH_IPV4_ICMPV4 );
u_char macda[] = { 0x8c, 0x89, 0xa5, 0x15, 0x84, 0xcb };
u_char macsa[] = { 0x8c, 0x89, 0xa5, 0x16, 0x22, 0x09 };
assert_memory_equal( packet_info->eth_macda, macda, ETH_ADDRLEN );
assert_memory_equal( packet_info->eth_macsa, macsa, ETH_ADDRLEN );
assert_int_equal( packet_info->eth_type, ETH_ETHTYPE_IPV4 );
assert_int_equal( packet_info->l2_payload_length, 84 );
assert_int_equal( packet_info->ipv4_version, 4 );
assert_int_equal( packet_info->ipv4_ihl, 5 );
assert_int_equal( packet_info->ipv4_tos, 0 );
assert_int_equal( packet_info->ipv4_tot_len, 0x54 );
assert_int_equal( packet_info->ipv4_id, 0 );
assert_int_equal( packet_info->ipv4_frag_off, 0x4000 );
assert_int_equal( packet_info->ipv4_ttl, 0x40 );
assert_int_equal( packet_info->ipv4_protocol, IPPROTO_ICMP );
assert_int_equal( packet_info->ipv4_checksum, 0xf100 );
assert_int_equal( packet_info->ipv4_saddr, 0xc0a8642c );
assert_int_equal( packet_info->ipv4_daddr, 0xc0a8642b );
assert_int_equal( packet_info->l3_payload_length, 64 );
assert_int_equal( packet_info->icmpv4_type, ICMP_TYPE_ECHOREQ );
assert_int_equal( packet_info->icmpv4_code, 0 );
assert_int_equal( packet_info->icmpv4_id, 1076 );
assert_int_equal( packet_info->icmpv4_seq, 1 );
uint16_t sample = ntohs( *( uint16_t * ) packet_info->l4_payload );
assert_int_equal( sample, 0xa0a9 );
assert_int_equal( packet_info->l4_payload_length, 56 );
assert_true( packet_type_icmpv4_echo_request( buffer ) );
assert_false( packet_type_icmpv4_dst_unreach( buffer ) );
assert_false( packet_type_icmpv4_redirect( buffer ) );
assert_false( packet_type_icmpv4_echo_reply( buffer ) );
free_buffer( buffer );
}
static void strrchr_func() {
char text[1024] = "`1234567890-=qwertyuiop[]asdfghjkl;'zxcvbnm,./~!@#$%^&*()_+QWERTYUIOP{}|ASDFGHJKL:1ZXCVBNM<>?\0";
int len = strlen(text);
for(int i = 0; i < len; i++) {
char* str;
if(text[i] == '1') {
str = __strrchr(text, '1');
assert_memory_equal(str, "1ZXCVBNM<>?", strlen("1ZXCVBNM<>?"));
} else {
str = __strrchr(text, text[i]);
assert_memory_equal(str, text + i, strlen(text + i));
}
}
}
/*
* GUC array: all non-PGC_USERSET, return the same array
*/
void
test__GUCArrayReset__all_non_userset_guc(void **state)
{
ArrayType *in;
ArrayType *out;
Datum d;
List *guc_list;
bool isnull;
int i;
int elems;
build_guc_variables();
will_return(superuser, false);
/* construct text array */
elems = 3;
guc_list = list_make3("log_error_verbosity=terse", "gp_log_format=csv", "maintenance_mode=true");
in = create_guc_array(guc_list, elems);
out = GUCArrayReset(in);
assert_not_null(out);
assert_int_equal(ARR_DIMS(out)[0], elems);
/* check element 1 */
i = 1;
d = array_ref(out, 1, &i, -1, TEXT_TYPLEN, TEXT_TYPBYVAL, TEXT_TYPALIGN, &isnull);
assert_false(isnull);
assert_int_equal(strlen("log_error_verbosity=terse"), VARLEN(d));
assert_memory_equal(VARDATA(d), "log_error_verbosity=terse", VARLEN(d));
/* check element 2 */
i = 2;
d = array_ref(out, 1, &i, -1, TEXT_TYPLEN, TEXT_TYPBYVAL, TEXT_TYPALIGN, &isnull);
assert_false(isnull);
assert_int_equal(strlen("gp_log_format=csv"), VARLEN(d));
assert_memory_equal(VARDATA(d), "gp_log_format=csv", VARLEN(d));
/* check element 3 */
i = 3;
d = array_ref(out, 1, &i, -1, TEXT_TYPLEN, TEXT_TYPBYVAL, TEXT_TYPALIGN, &isnull);
assert_false(isnull);
assert_int_equal(strlen("maintenance_mode=true"), VARLEN(d));
assert_memory_equal(VARDATA(d), "maintenance_mode=true", VARLEN(d));
list_free(guc_list);
pfree(in);
pfree(out);
}
static void
test_parse_packet_tcp_syn_succeeds() {
const char filename[] = "./unittests/lib/test_packets/tcp_syn.cap";
buffer *buffer = store_packet_to_buffer( filename );
assert_true( parse_packet( buffer ) );
packet_info *packet_info = buffer->user_data;
assert_int_equal( packet_info->format, ETH_IPV4_TCP );
u_char macda[] = { 0x00, 0x16, 0x17, 0x00, 0x43, 0xf3 };
u_char macsa[] = { 0x8c, 0x89, 0xa5, 0x15, 0x84, 0xcb };
assert_memory_equal( packet_info->eth_macda, macda, ETH_ADDRLEN );
assert_memory_equal( packet_info->eth_macsa, macsa, ETH_ADDRLEN );
assert_int_equal( packet_info->eth_type, ETH_ETHTYPE_IPV4 );
assert_int_equal( packet_info->l2_payload_length, 60 );
assert_int_equal( packet_info->ipv4_version, 4 );
assert_int_equal( packet_info->ipv4_ihl, 5 );
assert_int_equal( packet_info->ipv4_tos, 0x10 );
assert_int_equal( packet_info->ipv4_tot_len, 0x003c );
assert_int_equal( packet_info->ipv4_id, 0x5551 );
assert_int_equal( packet_info->ipv4_frag_off, 0x4000 );
assert_int_equal( packet_info->ipv4_ttl, 0x40 );
assert_int_equal( packet_info->ipv4_protocol, IPPROTO_TCP );
assert_int_equal( packet_info->ipv4_checksum, 0x9afd );
assert_int_equal( packet_info->ipv4_saddr, 0xc0a8642b );
assert_int_equal( packet_info->ipv4_daddr, 0xc0a864e1 );
assert_int_equal( packet_info->l3_payload_length, 40 );
assert_int_equal( packet_info->tcp_src_port, 0xad49 );
assert_int_equal( packet_info->tcp_dst_port, 0x0050 );
assert_int_equal( packet_info->tcp_seq_no, 0x51de9851 );
assert_int_equal( packet_info->tcp_ack_no, 0 );
assert_int_equal( packet_info->tcp_offset, 0xa );
assert_int_equal( packet_info->tcp_flags, 0x02 );
assert_int_equal( packet_info->tcp_window, 0x16d0 );
assert_int_equal( packet_info->tcp_checksum, 0x76bb );
assert_int_equal( packet_info->tcp_urgent, 0 );
assert_int_equal( packet_info->l4_payload, NULL );
assert_int_equal( packet_info->l4_payload_length, 0 );
free_buffer( buffer );
}
/**
* A basic test showing mapping of memory, and reading/writing it
*/
static void test_basic(void **state)
{
uc_engine *uc = *state;
const uint64_t mem_start = 0x1000;
const uint64_t mem_len = 0x1000;
const uint64_t test_addr = mem_start + 0x100;
/* Map a region */
uc_assert_success(uc_mem_map(uc, mem_start, mem_len, UC_PROT_NONE));
/* Write some data to it */
uc_assert_success(uc_mem_write(uc, test_addr, "test", 4));
uint8_t buf[4];
memset(buf, 0xCC, sizeof(buf));
/* Read it back */
uc_assert_success(uc_mem_read(uc, test_addr, buf, sizeof(buf)));
/* And make sure it matches what we expect */
assert_memory_equal(buf, "test", 4);
/* Unmap the region */
//uc_assert_success(uc_mem_unmap(uc, mem_start, mem_len));
}
/**
* Move FIFO head and tail at `n`th byte by write and read action.
* Add different length of records to FIFO till `n`th byte get
* overwrite. remove and compare all records and check FIFO's length.
*/
void test_case_14(void **fifo)
{
vfifo_t *e_fifo = *fifo;
char * const str[] = {"Brazil", "Cuba", "Russia", "Iran"};
char buf[10];
int ret;
int len;
int i;
/* Change FIFO's head and tail position to 'n'th byte */
for (i = 0; i < 2; i++)
vfifo_add(e_fifo, str[i], strlen(str[i]));
for (i = 0; i < 2; i++)
vfifo_remove(e_fifo, buf, sizeof(buf));
/* Write and read from 'n'th byte */
for (i = 0; i < ARRAY_LEN(str); i++) {
vfifo_add(e_fifo, str[i], strlen(str[i]));
ret = vfifo_len(e_fifo);
if (i < 3)
assert_int_equal(ret, i + 1);
else
assert_int_equal(ret, 3);
}
for (len = 2, i = 1; i <= 3; i++, len--) {
ret = vfifo_remove(e_fifo, buf, strlen(str[i]));
assert_int_equal(ret, 0);
assert_memory_equal(str[i], buf, strlen(str[i]));
ret = vfifo_len(e_fifo);
assert_int_equal(ret, len);
}
}
/**
* Move FIFO head and tail at `n`th byte by write and read action.
* Add different length of records to FIFO up to `n`th byte. remove
* and compare all records and check FIFO's length.
*/
void test_case_13(void **fifo)
{
vfifo_t *e_fifo = *fifo;
char * const str[] = {"Brazil", "Cuba", "Russia", "Iran"};
char buf[3];
int ret;
int i;
int len;
for (i = 0; i < ARRAY_LEN(str); i++) {
vfifo_add(e_fifo, str[i], strlen(str[i]));
ret = vfifo_len(e_fifo);
if (i < 3)
assert_int_equal(ret, i + 1);
else
assert_int_equal(ret, 3);
}
for (len = 2, i = 1; i <= 3; i++, len--) {
ret = vfifo_remove(e_fifo, buf, sizeof(buf));
assert_int_equal(ret, -2);
assert_memory_equal(str[i], buf, sizeof(buf));
ret = vfifo_len(e_fifo);
assert_int_equal(ret, len);
}
}
static void assert_defaults(struct dp_option *opts)
{
char *s;
struct dp_opt_blob b;
int i;
bool bo;
s = dp_opt_get_string(opts, OPT_STRING_NODEFAULT);
assert_null(s);
s = dp_opt_get_string(opts, OPT_STRING_DEFAULT);
assert_non_null(s);
assert_string_equal(s, STRING_DEFAULT);
b = dp_opt_get_blob(opts, OPT_BLOB_NODEFAULT);
assert_null(b.data);
assert_int_equal(b.length, 0);
b = dp_opt_get_blob(opts, OPT_BLOB_DEFAULT);
assert_non_null(b.data);
assert_int_equal(b.length, strlen(BLOB_DEFAULT));
assert_memory_equal(b.data, BLOB_DEFAULT, strlen(BLOB_DEFAULT));
i = dp_opt_get_int(opts, OPT_INT_NODEFAULT);
assert_int_equal(i, 0);
i = dp_opt_get_int(opts, OPT_INT_DEFAULT);
assert_int_equal(i, INT_DEFAULT);
bo = dp_opt_get_bool(opts, OPT_BOOL_TRUE);
assert_true(bo == true);
bo = dp_opt_get_bool(opts, OPT_BOOL_FALSE);
assert_true(bo == false);
}
void write_callback(void* buffer, int size, void* context) {
char _buffer[1024];
memset(_buffer, 0, 1024);
sprintf(_buffer, "Write Test %d", *(int*)context);
assert_memory_equal(_buffer, buffer, strlen(buffer));
assert_int_equal(1024, size);
}
/**
* Make a call to Marshal_UINT16 function that should succeed. The *_setup
* function is expected to have allocated sufficient buffer to hold a
* uint16_t. This test just 'marshals' a known uint16_t into this data buffer
* and then compares the value to the expected result.
* The workings of the Marshal_UINT16 function is a bit complex, so we
* assert the expected results as well.
*/
void
marshal_TPM2B_NAME_good (void **state)
{
marshal_simple2b_t *data;
/**
* This is what the above TPM2B_NAME should look like when marshalled.
* Interestingly enough the only thing that changes by order is the size
* field. The 'name' field is marshalled as a byte buffer so endianness
* doesn't change.
*/
data = (marshal_simple2b_t*)*state;
uint8_t *nextData = data->buffer;
Marshal_Simple_TPM2B (data->buffer,
data->buffer_size,
&nextData,
(TPM2B*)&name2b,
&data->rc);
/**
* uint16_t that was marshalled into the data buffer should be equal to
* the expected value (data converted from host byte order to network
* byte order).
*/
assert_memory_equal (data->buffer, name2b_marshalled, marshalled_size);
/**
* The Marshal_* functions advance the 'nextData' parameter by the size of
* the marshalled data.
*/
assert_int_equal (data->buffer, nextData - marshalled_size);
/* Finally the return code should indicate success. */
assert_int_equal (data->rc, TSS2_RC_SUCCESS);
}
void
unmarshal_TPM2B_NAME_good (void **state)
{
/**
* rc must be initialized to success or the unmarshal function will do
* nothing.
*/
TSS2_RC rc = TSS2_RC_SUCCESS;
TPM2B_NAME name2b_unmarshal = { .b = {0}, };
/**
* Unmarshal_Simple_TPM2B compares the size field in the destination
* structure to the size indicated by the marshalled data in the buffer
* that's being unmarshalled. So we must set the size to the maximum size
* possible.
*/
name2b_unmarshal.t.size = sizeof (name2b_unmarshal.t.name);
uint8_t *nextData = name2b_marshalled;
Unmarshal_Simple_TPM2B (name2b_marshalled,
marshalled_size,
&nextData,
&name2b_unmarshal.b,
&rc);
/* The return code should indicate success */
assert_int_equal (rc, TSS2_RC_SUCCESS);
/* The size of the unmarshalled structure should match the reference */
assert_int_equal (name2b_unmarshal.t.size, name2b.t.size);
/* the contents of the name buffer should match the reference */
assert_memory_equal (name2b_unmarshal.t.name, name2b.t.name, name2b.t.size);
}
static void discovery_with_services_succeeds()
{
struct await_discovery_args args;
struct cpn_discovery_results results;
struct cpn_thread t;
args.channel = &remote;
args.identity = &remote_keys.pk;
args.name = "test";
args.nservices = 1;
args.services = &service;
assert_success(cpn_spawn(&t, await_discovery, &args));
assert_success(cpn_client_discovery_probe(&local, NULL));
assert_success(cpn_client_discovery_handle_announce(&results, &local));
assert_success(cpn_join(&t, NULL));
assert_success(args.result);
assert_string_equal(results.name, args.name);
assert_int_equal(results.version, CPN_PROTOCOL_VERSION);
assert_memory_equal(&results.identity, &remote_keys.pk, sizeof(struct cpn_sign_pk));
assert_int_equal(results.nservices, args.nservices);
assert_string_equal(results.services[0].category, service.plugin->category);
assert_string_equal(results.services[0].name, service.name);
assert_int_equal(results.services[0].port, service.port);
cpn_discovery_results_clear(&results);
}
static void
test_request_credentials_returns_raw_bytes(void **state)
{
daos_iov_t creds;
size_t expected_len;
uint8_t *expected_data;
memset(&creds, 0, sizeof(daos_iov_t));
/*
* Credential bytes == raw bytes of the packed SecurityCredential
*/
expected_len = security_credential__get_packed_size(
drpc_call_resp_return_security_credential);
D_ALLOC(expected_data, expected_len);
security_credential__pack(drpc_call_resp_return_security_credential,
expected_data);
assert_int_equal(dc_sec_request_creds(&creds), DER_SUCCESS);
assert_int_equal(creds.iov_buf_len, expected_len);
assert_int_equal(creds.iov_len, expected_len);
assert_memory_equal(creds.iov_buf, expected_data, expected_len);
D_FREE(expected_data);
daos_iov_free(&creds);
}
