inline
void
LqhKeyReq::setGCIFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setGciFlag");
requestInfo |= (val << RI_GCI_SHIFT);
}
inline
void
LqhTransConf::setDirtyFlag(UintR & requestInfo, UintR val) {
ASSERT_BOOL(val, "LqhTransConf::setDirtyFlag");
requestInfo |= (val << LTC_DIRTY_SHIFT);
}
inline
void
FsReadWriteReq::setSyncFlag(UintR & opFlag, Uint8 flag){
ASSERT_BOOL(flag, "FsReadWriteReq::setSyncFlag");
opFlag |= (flag << SYNC_SHIFT);
}
inline
void
ScanFragReq::setNoDiskFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setNoDiskFlag");
requestInfo |= (val << SF_NO_DISK_SHIFT);
}
inline
void
ScanFragReq::setStatScanFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setStatScanFlag");
requestInfo |= (val << SF_STAT_SCAN_SHIFT);
}
inline
void
ScanFragReq::setKeyinfoFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setKeyinfoFlag");
requestInfo |= (val << SF_KEYINFO_SHIFT);
}
inline
void
ScanFragReq::setRangeScanFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setRangeScanFlag");
requestInfo |= (val << SF_RANGE_SCAN_SHIFT);
}
inline
void
LqhKeyReq::setQueueOnRedoProblemFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setQueueOnRedoProblem");
requestInfo |= (val << RI_QUEUE_REDO_SHIFT);
}
inline
void
AccScanReq::setDescendingFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "AccScanReq::setDescendingFlag");
requestInfo |= (val << AS_DESCENDING_SHIFT);
}
inline
void
LqhKeyReq::setDeferredConstraints(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setDeferredConstraints");
requestInfo |= (val << RI_DEFERRED_CONSTAINTS);
}
inline
void
LqhKeyReq::setDisableFkConstraints(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setDisableFkConstraints");
requestInfo |= (val << RI_DISABLE_FK);
}
inline
void
LqhKeyReq::setCorrFactorFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setCorrFactorFlag");
requestInfo |= (val << RI_CORR_FACTOR_VALUE);
}
inline
void
LqhKeyReq::setNormalProtocolFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setNrCopyFlag");
requestInfo |= (val << RI_NORMAL_DIRTY);
}
inline
void
LqhKeyReq::setNrCopyFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setNrCopyFlag");
requestInfo |= (val << RI_NR_COPY_SHIFT);
}
inline
void
TcKeyReq::setTakeOverScanFlag(UintR & scanInfo, Uint8 flag){
ASSERT_BOOL(flag, "TcKeyReq::setTakeOverScanFlag");
scanInfo |= (flag << TAKE_OVER_SHIFT);
}
inline
void
AccScanReq::setLcpScanFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "AccScanReq::setNoDiskScanFlag");
requestInfo |= (val << AS_LCP_SCAN);
}
inline
void
ScanFragReq::setHoldLockFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setHoldLockFlag");
requestInfo |= (val << SF_HOLD_LOCK_SHIFT);
}
static bool test_function_icmp6_minimum_mtu(void)
{
struct xlation state = { .jool.global = config };
int i;
bool success = true;
/*
* I'm assuming the default plateaus list has 3 elements or more.
* (so I don't have to reallocate mtu_plateaus)
*/
config->cfg.mtu_plateaus[0] = 5000;
config->cfg.mtu_plateaus[1] = 4000;
config->cfg.mtu_plateaus[2] = 500;
config->cfg.mtu_plateau_count = 2;
/* Simple tests */
success &= ASSERT_UINT(1320, min_mtu(1300, 3000, 3000, 2000), "min(1300, 3000, 3000)");
success &= ASSERT_UINT(1321, min_mtu(3001, 1301, 3001, 2001), "min(3001, 1301, 3001)");
success &= ASSERT_UINT(1302, min_mtu(3002, 3002, 1302, 2002), "min(3002, 3002, 1302)");
if (!success)
return false;
/* Lowest MTU is illegal on IPv6. */
success &= ASSERT_UINT(1280, min_mtu(100, 200, 200, 150), "min(100, 200, 200)");
success &= ASSERT_UINT(1280, min_mtu(200, 100, 200, 150), "min(200, 100, 200)");
success &= ASSERT_UINT(1280, min_mtu(200, 200, 100, 150), "min(200, 200, 100)");
/* Test plateaus (pkt is min). */
for (i = 5500; i > 5000 && success; --i)
success &= ASSERT_UINT(5020, min_mtu(0, 6000, 6000, i), "min(%d, 6000, 6000)", i);
for (i = 5000; i > 4000 && success; --i)
success &= ASSERT_UINT(4020, min_mtu(0, 6000, 6000, i), "min(%d, 6000, 6000)", i);
for (i = 4000; i >= 0 && success; --i)
success &= ASSERT_UINT(1280, min_mtu(0, 6000, 6000, i), "min(%d, 6000, 6000)", i);
/* Test plateaus (in/out is min). */
success &= ASSERT_UINT(1420, min_mtu(0, 1400, 5500, 4500), "min(4000,1400,5500)");
success &= ASSERT_UINT(1400, min_mtu(0, 5500, 1400, 4500), "min(4000,5500,1400)");
/* Plateaus and illegal MTU at the same time. */
success &= ASSERT_UINT(1280, min_mtu(0, 700, 700, 1000), "min(500, 700, 700)");
success &= ASSERT_UINT(1280, min_mtu(0, 1, 700, 1000), "min(500, 1, 700)");
success &= ASSERT_UINT(1280, min_mtu(0, 700, 1, 1000), "min(500, 700, 1)");
return success;
}
#undef min_mtu
static bool test_function_icmp4_to_icmp6_param_prob(void)
{
struct icmphdr hdr4;
struct icmp6hdr hdr6;
bool success = true;
hdr4.type = ICMP_PARAMETERPROB;
hdr4.code = ICMP_PTR_INDICATES_ERROR;
hdr4.icmp4_unused = cpu_to_be32(0x08000000U);
success &= ASSERT_INT(0, icmp4_to_icmp6_param_prob(&hdr4, &hdr6), "func result 1");
success &= ASSERT_UINT(ICMPV6_HDR_FIELD, hdr6.icmp6_code, "code");
success &= ASSERT_UINT(7, be32_to_cpu(hdr6.icmp6_pointer), "pointer");
hdr4.icmp4_unused = cpu_to_be32(0x05000000U);
success &= ASSERT_INT(-EINVAL, icmp4_to_icmp6_param_prob(&hdr4, &hdr6), "func result 2");
return success;
}
static bool test_function_generate_ipv4_id(void)
{
struct frag_hdr hdr;
__be16 attempt_1, attempt_2, attempt_3;
bool success = true;
attempt_1 = generate_ipv4_id(NULL);
attempt_2 = generate_ipv4_id(NULL);
attempt_3 = generate_ipv4_id(NULL);
/*
* At least one of the attempts should be nonzero,
* otherwise the random would be sucking major ****.
*/
success &= ASSERT_BOOL(true, (attempt_1 | attempt_2 | attempt_3) != 0, "No frag");
hdr.identification = 0;
success &= ASSERT_BE16(0, generate_ipv4_id(&hdr), "Simplest id");
hdr.identification = cpu_to_be32(0x0000abcdU);
success &= ASSERT_BE16(0xabcd, generate_ipv4_id(&hdr), "No overflow");
hdr.identification = cpu_to_be32(0x12345678U);
success &= ASSERT_BE16(0x5678, generate_ipv4_id(&hdr), "Overflow");
return success;
}
static bool test_function_generate_df_flag(void)
{
struct packet pkt;
struct sk_buff *skb;
bool success = true;
skb = alloc_skb(1500, GFP_ATOMIC);
if (!skb)
return false;
pkt.skb = skb;
skb_put(skb, 1000);
success &= ASSERT_UINT(0, generate_df_flag(&pkt), "Len < 1260");
skb_put(skb, 260);
success &= ASSERT_UINT(0, generate_df_flag(&pkt), "Len = 1260");
skb_put(skb, 200);
success &= ASSERT_UINT(1, generate_df_flag(&pkt), "Len > 1260");
kfree_skb(skb);
return success;
}
/**
* By the way. This test kind of looks like it should test more combinations of headers.
* But that'd be testing the header iterator, not the build_protocol_field() function.
* Please look elsewhere for that.
*/
static bool test_function_build_protocol_field(void)
{
struct ipv6hdr *ip6_hdr;
struct ipv6_opt_hdr *hop_by_hop_hdr;
struct ipv6_opt_hdr *routing_hdr;
struct ipv6_opt_hdr *dest_options_hdr;
struct icmp6hdr *icmp6_hdr;
ip6_hdr = kmalloc(sizeof(*ip6_hdr) + 8 + 16 + 24 + sizeof(struct tcphdr), GFP_ATOMIC);
if (!ip6_hdr) {
log_err("Could not allocate a test packet.");
goto failure;
}
/* Just ICMP. */
ip6_hdr->nexthdr = NEXTHDR_ICMP;
ip6_hdr->payload_len = cpu_to_be16(sizeof(*icmp6_hdr));
if (!ASSERT_UINT(IPPROTO_ICMP, ttp64_xlat_proto(ip6_hdr), "Just ICMP"))
goto failure;
/* Skippable headers then ICMP. */
ip6_hdr->nexthdr = NEXTHDR_HOP;
ip6_hdr->payload_len = cpu_to_be16(8 + 16 + 24 + sizeof(*icmp6_hdr));
hop_by_hop_hdr = (struct ipv6_opt_hdr *) (ip6_hdr + 1);
hop_by_hop_hdr->nexthdr = NEXTHDR_ROUTING;
hop_by_hop_hdr->hdrlen = 0; /* the hdrlen field does not include the first 8 octets. */
routing_hdr = (struct ipv6_opt_hdr *) (((unsigned char *) hop_by_hop_hdr) + 8);
routing_hdr->nexthdr = NEXTHDR_DEST;
routing_hdr->hdrlen = 1;
dest_options_hdr = (struct ipv6_opt_hdr *) (((unsigned char *) routing_hdr) + 16);
dest_options_hdr->nexthdr = NEXTHDR_ICMP;
dest_options_hdr->hdrlen = 2;
if (!ASSERT_UINT(IPPROTO_ICMP, ttp64_xlat_proto(ip6_hdr), "Skippable then ICMP"))
goto failure;
/* Skippable headers then something else */
dest_options_hdr->nexthdr = NEXTHDR_TCP;
ip6_hdr->payload_len = cpu_to_be16(8 + 16 + 24 + sizeof(struct tcphdr));
if (!ASSERT_UINT(IPPROTO_TCP, ttp64_xlat_proto(ip6_hdr), "Skippable then TCP"))
goto failure;
kfree(ip6_hdr);
return true;
failure:
kfree(ip6_hdr);
return false;
}
static bool test_function_has_nonzero_segments_left(void)
{
struct ipv6hdr *ip6_hdr;
struct ipv6_rt_hdr *routing_hdr;
struct frag_hdr *fragment_hdr;
__u32 offset;
bool success = true;
ip6_hdr = kmalloc(sizeof(*ip6_hdr) + sizeof(*fragment_hdr) + sizeof(*routing_hdr), GFP_ATOMIC);
if (!ip6_hdr) {
log_err("Could not allocate a test packet.");
return false;
}
ip6_hdr->payload_len = cpu_to_be16(sizeof(*fragment_hdr) + sizeof(*routing_hdr));
/* No extension headers. */
ip6_hdr->nexthdr = NEXTHDR_TCP;
success &= ASSERT_BOOL(false, has_nonzero_segments_left(ip6_hdr, &offset), "No extension headers");
if (!success)
goto end;
/* Routing header with nonzero segments left. */
ip6_hdr->nexthdr = NEXTHDR_ROUTING;
routing_hdr = (struct ipv6_rt_hdr *) (ip6_hdr + 1);
routing_hdr->segments_left = 12;
success &= ASSERT_BOOL(true, has_nonzero_segments_left(ip6_hdr, &offset), "Nonzero left - result");
success &= ASSERT_UINT(40 + 3, offset, "Nonzero left - offset");
if (!success)
goto end;
/* Routing header with zero segments left. */
routing_hdr->segments_left = 0;
success &= ASSERT_BOOL(false, has_nonzero_segments_left(ip6_hdr, &offset), "Zero left");
if (!success)
goto end;
/*
* Fragment header, then routing header with nonzero segments left
* (further test the out parameter).
*/
ip6_hdr->nexthdr = NEXTHDR_FRAGMENT;
fragment_hdr = (struct frag_hdr *) (ip6_hdr + 1);
fragment_hdr->nexthdr = NEXTHDR_ROUTING;
routing_hdr = (struct ipv6_rt_hdr *) (fragment_hdr + 1);
routing_hdr->segments_left = 24;
success &= ASSERT_BOOL(true, has_nonzero_segments_left(ip6_hdr, &offset), "Two headers - result");
success &= ASSERT_UINT(40 + 8 + 3, offset, "Two headers - offset");
/* Fall through. */
end:
kfree(ip6_hdr);
return success;
}
static bool test_function_icmp4_minimum_mtu(void)
{
bool success = true;
success &= ASSERT_UINT(2, be16_to_cpu(minimum(2, 4, 6)), "First is min");
success &= ASSERT_UINT(8, be16_to_cpu(minimum(10, 8, 12)), "Second is min");
success &= ASSERT_UINT(14, be16_to_cpu(minimum(16, 18, 14)), "Third is min");
return success;
}
inline
void
ScanFragReq::setReadCommittedFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setReadCommittedFlag");
requestInfo |= (val << SF_READ_COMMITTED_SHIFT);
}
static bool test_function_has_unexpired_src_route(void)
{
struct iphdr *hdr = kmalloc(60, GFP_ATOMIC); /* 60 is the max value allowed by hdr.ihl. */
unsigned char *options;
bool success = true;
if (!hdr) {
log_err("Can't allocate a test header.");
return false;
}
options = (unsigned char *) (hdr + 1);
hdr->ihl = 5; /* min legal value. */
success &= ASSERT_BOOL(false, has_unexpired_src_route(hdr), "No options");
hdr->ihl = 6;
options[0] = IPOPT_SID;
options[1] = 4;
options[2] = 0xAB;
options[3] = 0xCD;
success = ASSERT_BOOL(false, has_unexpired_src_route(hdr), "No source route option, simple");
hdr->ihl = 9;
options[0] = IPOPT_RR; /* Record route option */
options[1] = 11;
options[2] = 8;
options[3] = 0x12;
options[4] = 0x34;
options[5] = 0x56;
options[6] = 0x78;
options[7] = 0x00;
options[8] = 0x00;
options[9] = 0x00;
options[10] = 0x00;
options[11] = IPOPT_NOOP; /* No operation option. */
options[12] = IPOPT_NOOP; /* No operation option. */
options[13] = IPOPT_END; /* End of options list option. */
/* Leave the rest as garbage. */
success &= ASSERT_BOOL(false, has_unexpired_src_route(hdr), "No source option, multiple options");
hdr->ihl = 9;
options[0] = IPOPT_LSRR;
options[1] = 15;
options[2] = 16;
options[3] = 0x11; /* First address */
options[4] = 0x11;
options[5] = 0x11;
options[6] = 0x11;
options[7] = 0x22; /* Second address */
options[8] = 0x22;
options[9] = 0x22;
options[10] = 0x22;
options[11] = 0x33; /* Third address */
options[12] = 0x33;
options[13] = 0x33;
options[14] = 0x33;
options[15] = IPOPT_END;
success &= ASSERT_BOOL(false, has_unexpired_src_route(hdr), "Expired source route");
options[2] = 4;
success &= ASSERT_BOOL(true, has_unexpired_src_route(hdr), "Unexpired source route, first address");
options[2] = 8;
success &= ASSERT_BOOL(true, has_unexpired_src_route(hdr), "Unexpired source route, second address");
options[2] = 12;
success &= ASSERT_BOOL(true, has_unexpired_src_route(hdr), "Unexpired source route, third address");
hdr->ihl = 11;
options[0] = IPOPT_NOOP;
options[1] = IPOPT_SID;
options[2] = 4;
options[3] = 0xAB;
options[4] = 0xCD;
options[5] = IPOPT_LSRR;
options[6] = 15;
options[7] = 16;
options[8] = 0x11; /* First address */
options[9] = 0x11;
options[10] = 0x11;
options[11] = 0x11;
options[12] = 0x22; /* Second address */
options[13] = 0x22;
options[14] = 0x22;
options[15] = 0x22;
options[16] = 0x33; /* Third address */
options[17] = 0x33;
options[18] = 0x33;
options[19] = 0x33;
options[20] = IPOPT_SID;
options[21] = 4;
options[22] = 0xAB;
options[23] = 0xCD;
success &= ASSERT_BOOL(false, has_unexpired_src_route(hdr), "Expired source route, multiple opts");
options[7] = 4;
success &= ASSERT_BOOL(true, has_unexpired_src_route(hdr), "Unexpired src route, multiple opts (1)");
options[7] = 8;
success &= ASSERT_BOOL(true, has_unexpired_src_route(hdr), "Unexpired src route, multiple opts (2)");
options[7] = 12;
success &= ASSERT_BOOL(true, has_unexpired_src_route(hdr), "Unexpired src route, multiple opts (3)");
kfree(hdr);
return success;
}
inline
void
ScanFragReq::setDescendingFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setDescendingFlag");
requestInfo |= (val << SF_DESCENDING_SHIFT);
}
inline
void
TcKeyReq::setReorgFlag(UintR & requestInfo, Uint32 flag){
ASSERT_BOOL(flag, "TcKeyReq::setReorgFlag");
requestInfo |= (flag << TC_REORG_SHIFT);
}
inline
void
ScanFragReq::setCorrFactorFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "ScanFragReq::setCorrFactorFlag");
requestInfo |= (val << SF_CORR_FACTOR_SHIFT);
}
inline
void
TcKeyReq::setQueueOnRedoProblemFlag(UintR & requestInfo, Uint32 flag){
ASSERT_BOOL(flag, "TcKeyReq::setNoDiskFlag");
requestInfo |= (flag << QUEUE_ON_REDO_SHIFT);
}
inline
void
LqhTransConf::setSimpleFlag(UintR & requestInfo, UintR val) {
ASSERT_BOOL(val, "LqhTransConf::setSimpleFlag");
requestInfo |= (val << LTC_SIMPLE_SHIFT);
}
inline
void
TcKeyReq::setDeferredConstraints(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "TcKeyReq::setDeferredConstraints");
requestInfo |= (val << TC_DEFERRED_CONSTAINTS_SHIFT);
}
inline
void
LqhTransConf::setMarkerFlag(UintR & requestInfo, UintR val) {
ASSERT_BOOL(val, "LqhTransConf::setMarkerFlag");
requestInfo |= (val << LTC_MARKER_SHIFT);
}
inline
void
TcKeyReq::setDisableFkConstraints(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "TcKeyReq::setDisableFkConstraints");
requestInfo |= (val << TC_DISABLE_FK_SHIFT);
}
inline
void
FsReadWriteReq::setPartialReadFlag(UintR & opFlag, Uint32 flag){
ASSERT_BOOL(flag, "FsReadWriteReq::setSyncFlag");
opFlag |= (flag << PARTIAL_READ_SHIFT);
}
inline
void
LqhKeyReq::setRowidFlag(UintR & requestInfo, UintR val){
ASSERT_BOOL(val, "LqhKeyReq::setRowidFlag");
requestInfo |= (val << RI_ROWID_SHIFT);
}
