ble_error_t nRF51GattServer::updateValue(uint16_t charHandle, uint8_t buffer[], uint16_t len, bool localOnly)
{
if (localOnly)
{
/* Only update locally regardless of notify/indicate */
ASSERT_INT( ERROR_NONE, sd_ble_gatts_value_set(nrfCharacteristicHandles[charHandle].value_handle, 0, &len, buffer), BLE_ERROR_PARAM_OUT_OF_RANGE );
}
if ((p_characteristics[charHandle]->properties & (GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_INDICATE | GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY)) &&
(m_connectionHandle != BLE_CONN_HANDLE_INVALID) )
{
/* HVX update for the characteristic value */
ble_gatts_hvx_params_t hvx_params;
hvx_params.handle = nrfCharacteristicHandles[charHandle].value_handle;
hvx_params.type = (p_characteristics[charHandle]->properties & GattCharacteristic::BLE_GATT_CHAR_PROPERTIES_NOTIFY) ? BLE_GATT_HVX_NOTIFICATION : BLE_GATT_HVX_INDICATION;
hvx_params.offset = 0;
hvx_params.p_data = buffer;
hvx_params.p_len = &len;
error_t error = (error_t) sd_ble_gatts_hvx(m_connectionHandle, &hvx_params);
/* ERROR_INVALID_STATE, ERROR_BUSY, ERROR_GATTS_SYS_ATTR_MISSING and ERROR_NO_TX_BUFFERS the ATT table has been updated. */
if ( (error != ERROR_NONE ) && (error != ERROR_INVALID_STATE) &&
(error != ERROR_BLE_NO_TX_BUFFERS ) && (error != ERROR_BUSY ) &&
(error != ERROR_BLEGATTS_SYS_ATTR_MISSING ) )
{
ASSERT_INT( ERROR_NONE, sd_ble_gatts_value_set(nrfCharacteristicHandles[charHandle].value_handle, 0, &len, buffer), BLE_ERROR_PARAM_OUT_OF_RANGE );
}
} else
{
ASSERT_INT( ERROR_NONE, sd_ble_gatts_value_set(nrfCharacteristicHandles[charHandle].value_handle, 0, &len, buffer), BLE_ERROR_PARAM_OUT_OF_RANGE );
}
return BLE_ERROR_NONE;
}
TEST numlookup() {
mvSession session;
mvStrArray script(3);
script.append(REQ14);
script.append(REQ15);
script.append(REQ16);
try
{
session.perform(script);
}
catch (mvError* err)
{
FAIL(err);
}
mvIntset result(8);
mvCommand lookup;
try
{
singletonParser.parse(lookup, REQ17);
}
catch (mvError* err)
{
FAIL(err);
}
FAILFAST(session.lookup(result, lookup));
ASSERT_INT(result.cardinality(), 1);
ASSERT_INT(result.contains(0), 1);
}
TEST lookup_after_destroy() {
mvCommand lookup, destroy;
mvSession state;
mvIntset result(8);
__prepare_for_REQ10_11(state, 1);
try
{
singletonParser.parse(lookup, REQ11);
singletonParser.parse(destroy, REQ12);
}
catch (mvError* err)
{
FAIL(err);
}
FAILFAST(state.lookup(result, lookup));
ASSERT_INT(result.cardinality(), 1);
ASSERT_INT(result.get(0), 0);
result.clear();
try
{
state.execute(destroy);
}
catch (mvError* err)
{
FAIL(err);
}
FAILFAST(state.lookup(result, lookup));
ASSERT_INT(result.cardinality(), 0);
}
void test_xrltLogList(void)
{
xrltLogList ll;
xrltString msg1, msg2, msg3, msg;
xrltLogType type;
xrltLogListInit(&ll);
ASSERT_NULL(ll.first);
ASSERT_NULL(ll.last);
xrltStringInit(&msg1, "log1");
xrltStringInit(&msg2, "log2");
xrltStringInit(&msg3, "log3");
ASSERT_TRUE(xrltLogListPush(&ll, XRLT_ERROR, &msg1));
ASSERT_TRUE(xrltLogListPush(&ll, XRLT_WARNING, &msg2));
ASSERT_TRUE(xrltLogListPush(&ll, XRLT_INFO, &msg3));
ASSERT_TRUE(xrltLogListShift(&ll, &type, &msg));
ASSERT_STR(msg, "log1");
ASSERT_INT(type, XRLT_ERROR);
xrltStringClear(&msg);
ASSERT_TRUE(xrltLogListShift(&ll, &type, &msg));
ASSERT_STR(msg, "log2");
ASSERT_INT(type, XRLT_WARNING);
xrltStringClear(&msg);
ASSERT_TRUE(xrltLogListShift(&ll, &type, &msg));
ASSERT_STR(msg, "log3");
ASSERT_INT(type, XRLT_INFO);
xrltStringClear(&msg);
ASSERT_FALSE(xrltLogListShift(&ll, &type, &msg));
ASSERT_NULL(ll.first);
ASSERT_NULL(ll.last);
ASSERT_TRUE(xrltLogListPush(&ll, XRLT_ERROR, &msg1));
ASSERT_TRUE(xrltLogListPush(&ll, XRLT_WARNING, &msg2));
ASSERT_TRUE(xrltLogListPush(&ll, XRLT_INFO, &msg3));
ASSERT_FALSE(xrltLogListPush(NULL, XRLT_DEBUG, NULL));
ASSERT_FALSE(xrltLogListPush(&ll, XRLT_DEBUG, NULL));
ASSERT_FALSE(xrltLogListPush(NULL, XRLT_DEBUG, &msg1));
ASSERT_FALSE(xrltLogListShift(NULL, NULL, NULL));
ASSERT_FALSE(xrltLogListShift(&ll, NULL, NULL));
ASSERT_FALSE(xrltLogListShift(&ll, &type, NULL));
ASSERT_FALSE(xrltLogListShift(&ll, NULL, &msg));
xrltLogListClear(&ll);
ASSERT_NULL(ll.first);
ASSERT_NULL(ll.last);
xrltStringClear(&msg1);
xrltStringClear(&msg2);
xrltStringClear(&msg3);
TEST_PASSED;
}
static bool test_next_subheaders(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_hop;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_HOP);
hdr_hop = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, NEXTHDR_ROUTING);
hdr_route = add_route_hdr(hdr_hop, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:data");
success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type,
"Frag:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1");
success &= ASSERT_PTR(hdr_hop, iterator.data, "Hop:data");
success &= ASSERT_UINT(NEXTHDR_HOP, iterator.hdr_type, "Hop:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 2");
success &= ASSERT_PTR(hdr_route, iterator.data, "Routing:data");
success &= ASSERT_UINT(NEXTHDR_ROUTING, iterator.hdr_type,
"Routing:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 3");
success &= ASSERT_PTR(payload, iterator.data, "Payload1:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 4");
success &= ASSERT_PTR(payload, iterator.data, "Payload2:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
static bool assert_session_count(int expected, l4_protocol proto)
{
int counter = 0;
struct session_foreach_func cb = { .cb = session_count_fn, .arg = &counter, };
bool success = true;
success &= ASSERT_INT(0, bib_foreach_session(&jool, proto, &cb, NULL), "foreach result");
success &= ASSERT_INT(expected, counter, "computed count");
return success;
}
static bool assert_bib_count(int expected, l4_protocol proto)
{
int counter = 0;
struct bib_foreach_func func = { .cb = bib_count_fn, .arg = &counter, };
bool success = true;
success &= ASSERT_INT(0, bib_foreach(jool.nat64.bib, proto, &func, NULL), "foreach result");
success &= ASSERT_INT(expected, counter, "computed count");
return success;
}
TEST execute_REQ1() {
mvSession state;
__perform__(&state, REQ1);
ASSERT_INT(state.varcount(), 1);
ASSERT_INT(state.entities.size(), 1);
mvAttrlist& attrs = state.entities[0].data;
ASSERT_INT(attrs.size(), 1);
ASSERT_INT(attrs[0].type, STRING);
ASSERT_STRREF(attrs[0].name, "name");
ASSERT_STRING(attrs[0].value.string, "Umberto Eco");
}
TEST execute_REQ14() {
mvSession state;
__perform__(&state, REQ14);
ASSERT_INT(state.varcount(), 1);
ASSERT_INT(state.entities.size(), 1);
mvAttrlist& attrs = state.entities[0].data;
ASSERT_INT(attrs.size(), 1);
ASSERT_INT(attrs[0].type, INTEGER);
ASSERT_STRREF(attrs[0].name, "height");
ASSERT_INT(attrs[0].value.integer, 324);
}
static bool test_foreach_sample(void)
{
struct pool4_sample expected[COUNT];
unsigned int i = 0;
struct foreach_sample_args args;
int error;
bool success = true;
if (!add_common_samples())
return false;
init_sample(&expected[i++], 0xc0000200U, 6, 7);
init_sample(&expected[i++], 0xc0000201U, 6, 7);
init_sample(&expected[i++], 0xc0000210U, 15, 19);
init_sample(&expected[i++], 0xc0000210U, 22, 23);
init_sample(&expected[i++], 0xc0000211U, 19, 19);
init_sample(&expected[i++], 0xc0000220U, 1, 1);
init_sample(&expected[i++], 0xc0000221U, 1, 1);
init_sample(&expected[i++], 0xc0000222U, 1, 1);
init_sample(&expected[i++], 0xc0000223U, 1, 1);
if (i != COUNT) {
log_err("Input mismatch. Unit test is broken: %u %u", i, COUNT);
return false;
}
args.expected = &expected[0];
args.expected_len = COUNT;
args.samples = 0;
args.taddrs = 0;
error = pool4db_foreach_sample(pool, L4PROTO_TCP, validate_sample,
&args, NULL);
success &= ASSERT_INT(0, error, "no-offset call");
success &= ASSERT_UINT(9, args.samples, "no-offset samples");
success &= ASSERT_UINT(16, args.taddrs, "no-offset taddrs");
for (i = 0; i < COUNT; i++) {
/* foreach sample skips offset. */
args.expected = &expected[i + 1];
args.expected_len = COUNT - i - 1;
args.samples = 0;
args.taddrs = 0;
error = pool4db_foreach_sample(pool, L4PROTO_TCP,
validate_sample, &args, &expected[i]);
success &= ASSERT_INT(0, error, "call %u", i);
/* log_debug("--------------"); */
}
return success;
}
ble_error_t nRF5xGap::setAddress(AddressType_t type, const Address_t address)
{
uint8_t cycle_mode;
ble_gap_addr_t dev_addr;
/* When using Public or Static addresses, the cycle mode must be None.
When using Random Private addresses, the cycle mode must be Auto.
In auto mode, the given address is ignored.
*/
if ((type == BLEProtocol::AddressType::PUBLIC) || (type == BLEProtocol::AddressType::RANDOM_STATIC))
{
cycle_mode = BLE_GAP_ADDR_CYCLE_MODE_NONE;
memcpy(dev_addr.addr, address, ADDR_LEN);
}
else if ((type == BLEProtocol::AddressType::RANDOM_PRIVATE_RESOLVABLE) || (type == BLEProtocol::AddressType::RANDOM_PRIVATE_NON_RESOLVABLE))
{
cycle_mode = BLE_GAP_ADDR_CYCLE_MODE_AUTO;
// address is ignored when in auto mode
}
else
{
return BLE_ERROR_PARAM_OUT_OF_RANGE;
}
dev_addr.addr_type = type;
ASSERT_INT(ERROR_NONE, sd_ble_gap_address_set(cycle_mode, &dev_addr), BLE_ERROR_PARAM_OUT_OF_RANGE);
return BLE_ERROR_NONE;
}
static bool remove_entry(char *addr4, __u8 len4, char *addr6, __u8 len6,
int expected_error)
{
struct ipv4_prefix prefix4;
struct ipv6_prefix prefix6;
bool success;
int error;
log_debug("----------------");
log_debug("Removing entry %s/%u %s/%u", addr6, len6, addr4, len4);
if (!addr4 && !addr6) {
log_err("Both addr4 and addr6 are NULL.");
return false;
}
if (addr4) {
if (is_error(str_to_addr4(addr4, &prefix4.address)))
return false;
prefix4.len = len4;
}
if (addr6) {
if (is_error(str_to_addr6(addr6, &prefix6.address)))
return false;
prefix6.len = len6;
}
error = eamt_rm(addr6 ? &prefix6 : NULL, addr4 ? &prefix4 : NULL);
success = ASSERT_INT(expected_error, error, "removing EAM entry");
/* rtrie_print(eamt.tree6); */
return success;
}
ble_error_t nRF5xGap::setPreferredConnectionParams(const ConnectionParams_t *params)
{
ASSERT_INT(NRF_SUCCESS,
sd_ble_gap_ppcp_set(reinterpret_cast<const ble_gap_conn_params_t *>(params)),
BLE_ERROR_PARAM_OUT_OF_RANGE);
return BLE_ERROR_NONE;
}
bool boardButtonCheck(uint8_t button_num)
{
bool is_pushed;
ASSERT_INT( ERROR_NONE, app_button_is_pushed(button_gpio[button_num], &is_pushed), false );
return is_pushed;
}
TEST update() {
mvSession session;
mvStrArray script(2);
script.append(REQ14);
script.append(REQ20);
try
{
session.perform(script);
}
catch (mvError* err)
{
FAIL(err);
}
ASSERT_INT(session.entities.size(), 1);
mvAttrlist& data = session.entities[0].data;
ASSERT_INT(data.size(), 2);
}
static bool test_next_unsupported(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
struct frag_hdr *hdr_frag;
struct ipv6_opt_hdr *hdr_esp;
struct ipv6_opt_hdr *hdr_route;
unsigned char *payload;
hdr6 = kmalloc_packet(FRAG_HDR_LEN + OPT_HDR_LEN + ROUTE_HDR_LEN + 4,
NEXTHDR_FRAGMENT);
if (!hdr6)
return false;
hdr_frag = add_frag_hdr(hdr6, HDR6_LEN, NEXTHDR_ESP);
hdr_esp = add_opt_hdr(hdr_frag, FRAG_HDR_LEN, FRAG_HDR_LEN);
hdr_route = add_route_hdr(hdr_esp, OPT_HDR_LEN, NEXTHDR_UDP);
payload = add_payload(hdr_route, ROUTE_HDR_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(hdr_frag, iterator.data, "Frag:pointer");
success &= ASSERT_UINT(NEXTHDR_FRAGMENT, iterator.hdr_type,
"Frag:type");
if (!success)
goto end;
success &= ASSERT_INT(EAGAIN, hdr_iterator_next(&iterator), "Next 1");
success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP1:pointer");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Next 2");
success &= ASSERT_PTR(hdr_esp, iterator.data, "ESP2:pointer");
success &= ASSERT_UINT(NEXTHDR_ESP, iterator.hdr_type, "ESP2:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
TEST compile_REQ11() {
mvCommand cmd;
try
{
singletonParser.parse(cmd, REQ11);
}
catch (mvError* err)
{
FAIL(err);
}
mvQuery patt(cmd);
ASSERT_STRREF(patt.classname, "person");
ASSERT_INT(patt.attrs.size(), 1);
ASSERT_STRREF(patt.attrs[0].name, "name");
ASSERT_INT(patt.attrs[0].type, STRING);
ASSERT_STRING(patt.attrs[0].value.string, "Umberto Eco");
}
inline static void __validate__(mvStrArray& tokens, int ct, ...) {
ASSERT_INT(tokens.size(), ct);
va_list args;
va_start(args, ct);
int i;
for (i=0; i<ct; i++) {
fflush(stdout);
char* expect = va_arg(args, char*);
ASSERT_STRREF(tokens[i], expect);
}
}
TEST lookup_all_items() {
mvCommand lookup;
mvSession state;
mvIntset result(8);
__prepare_for_REQ10_11(state, 1);
try
{
singletonParser.parse(lookup, REQ13);
}
catch (mvError* err)
{
FAIL(err);
}
FAILFAST(state.lookup(result, lookup));
ASSERT_INT(result.cardinality(), 1);
ASSERT_INT(result.contains(0), 1);
}
TEST execute_REQ11() {
mvCommand action;
mvSession state;
mvIntset result(8);
__prepare_for_REQ10_11(state, 1);
try
{
singletonParser.parse(action, REQ11);
}
catch (mvError* err)
{
FAIL(err);
}
FAILFAST(state.lookup(result, action));
ASSERT_INT(result.cardinality(), 1);
ASSERT_INT(result.get(0), 0);
}
static bool test_6to4(char *addr6_str, char *addr4_str)
{
struct in6_addr addr6;
struct in_addr addr4;
bool success = true;
log_debug("Testing %s -> %s...", addr6_str, addr4_str);
if (str_to_addr6(addr6_str, &addr6))
return false;
if (addr4_str) {
success &= ASSERT_INT(0, eamt_xlat_6to4(&addr6, &addr4), "errcode");
success &= ASSERT_ADDR4(addr4_str, &addr4, "resulting address");
} else {
success &= ASSERT_INT(-ESRCH, eamt_xlat_6to4(&addr6, &addr4), "errcode");
}
return success;
}
TEST subquery() {
mvSession session;
mvStrArray script(2);
script.append(REQ19);
script.append(REQ18);
try
{
session.perform(script);
}
catch (mvError* err)
{
FAIL(err);
}
ASSERT_INT(session.classes.size(), 2);
ASSERT_INT(session.classes[1].data.size(), 1);
mvAttrSpec& spc = session.classes[1].data[0];
ASSERT_INT(spc.get_type(), SUBQUERY);
const mvQuery& qr = spc.subquery();
ASSERT_STRREF(qr.classname, "book");
}
uint8_t custom_add_uuid_base(uint8_t const *const p_uuid_base)
{
ble_uuid128_t base_uuid;
uint8_t uuid_type = 0;
for (unsigned i = 0; i < UUID::LENGTH_OF_LONG_UUID; i++) {
base_uuid.uuid128[i] = p_uuid_base[i];
}
ASSERT_INT( ERROR_NONE, sd_ble_uuid_vs_add( &base_uuid, &uuid_type ), 0);
return uuid_type;
}
static int compare_session_foreach_cb(struct session_entry const *session,
void *arg)
{
struct session_entry *expected = arg;
bool success = true;
if (!session_equals(expected, session))
return 0; /* Still not found; keep foreaching. */
success &= ASSERT_INT(expected->proto, session->proto, "Session's proto");
success &= ASSERT_INT(expected->state, session->state, "Session's state");
success &= ASSERT_BOOL(expected->timer_type, session->timer_type, "Session's timer type");
success &= ASSERT_BOOL(true, session->update_time != 0, "Session's update time");
success &= ASSERT_ULONG(expected->timeout, session->timeout, "Session's timeout");
success &= ASSERT_INT(expected->has_stored, session->has_stored, "Session's stored");
/*
* Success? Interrupt the foreach positively.
* Failure? Interrupt the foreach negatively.
*/
return success ? 1 : -EINVAL;
}
static bool rm(__u32 addr, __u8 prefix_len, __u16 min, __u16 max)
{
struct ipv4_range range;
range.prefix.address.s_addr = cpu_to_be32(addr);
range.prefix.len = prefix_len;
range.ports.min = min;
range.ports.max = max;
return ASSERT_INT(0, pool4db_rm(pool, 1, L4PROTO_TCP, &range),
"rm of %pI4/%u (%u-%u)",
&range.prefix.address, prefix_len, min, max);
}
static bool test_next_no_subheaders(void)
{
bool success = true;
struct hdr_iterator iterator;
/* Init */
struct ipv6hdr *hdr6;
unsigned char *payload;
hdr6 = kmalloc_packet(4, NEXTHDR_UDP);
if (!hdr6)
return false;
payload = add_payload(hdr6, HDR6_LEN);
/* Test */
hdr_iterator_init(&iterator, hdr6);
success &= ASSERT_PTR(payload, iterator.data, "Payload1:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload1:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result1");
success &= ASSERT_PTR(payload, iterator.data, "Payload2:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload2:type");
if (!success)
goto end;
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result2");
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result3");
success &= ASSERT_INT(0, hdr_iterator_next(&iterator), "Result4");
success &= ASSERT_PTR(payload, iterator.data, "Payload3:data");
success &= ASSERT_UINT(NEXTHDR_UDP, iterator.hdr_type, "Payload3:type");
/* Fall through. */
end:
kfree(hdr6);
return success;
}
ble_error_t nRF5xGap::setAddress(AddressType_t type, const Address_t address)
{
if (type > ADDR_TYPE_RANDOM_PRIVATE_NON_RESOLVABLE) {
return BLE_ERROR_PARAM_OUT_OF_RANGE;
}
ble_gap_addr_t dev_addr;
dev_addr.addr_type = type;
memcpy(dev_addr.addr, address, ADDR_LEN);
ASSERT_INT(ERROR_NONE, sd_ble_gap_address_set(BLE_GAP_ADDR_CYCLE_MODE_NONE, &dev_addr), BLE_ERROR_PARAM_OUT_OF_RANGE);
return BLE_ERROR_NONE;
}
TEST match_REQ25() {
mvEntity entity(1, 1);
mvQuery patt;
singletonParser.parse(entity.data[0], "name", "'Umberto Eco");
entity.classes.append("person");
patt.classname = NULL;
patt.attrs.alloc(1);
singletonParser.parse(patt.attrs[0], "name", "'Umberto Eco");
int match = patt.match(entity);
ASSERT_INT(match, 1);
}
uint8_t custom_add_uuid_base(uint8_t const * const p_uuid_base)
{
ble_uuid128_t base_uuid;
uint8_t uuid_type = 0;
/* Reverse the bytes since ble_uuid128_t is LSB */
for(uint8_t i=0; i<16; i++)
{
base_uuid.uuid128[i] = p_uuid_base[15-i];
}
ASSERT_INT( ERROR_NONE, sd_ble_uuid_vs_add( &base_uuid, &uuid_type ), 0);
return uuid_type;
}
static bool assert_session(unsigned int la, unsigned int lp,
unsigned int ra, unsigned int rp)
{
struct session_entry session;
int expected;
init_src6(&session.src6, la, lp);
init_dst6(&session.dst6, ra, rp);
init_src4(&session.src4, la, lp);
init_dst4(&session.dst4, ra, rp);
session.proto = PROTO;
expected = !!sessions[la][lp][ra][rp];
return ASSERT_INT(expected, session_exists(&session),
"session %u %u %u %u lookup", la, lp, ra, rp);
}
