aiden
/
suricata
mirror of https://github.com/OISF/suricata
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

rust: fix assertions_on_constants for assert!(false)

Browse Source 
using panic! instead with a string message
pull/10167/head
Philippe Antoine 3 years ago committed by Victor Julien
parent c49463c86f
commit a8199bf2ca
6 changed files with 302 additions and 520 deletions
Show Stats Download Patch File Download Diff File

29
rust/src/dcerpc/dcerpc_udp.rs
Unescape Escape View File

@ -410,12 +410,7 @@ mod tests {
0x1c, 0x7d, 0xcf, 0x11,
];
match parser::parse_dcerpc_udp_header(request) {
Ok((_rem, _header)) => {
{ assert!(false); }
}
_ => {}
}
assert!(parser::parse_dcerpc_udp_header(request).is_err());
}
#[test]
@ -428,13 +423,9 @@ mod tests {
0x79, 0xbe, 0x01, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x68, 0x00, 0x00, 0x00, 0x0a, 0x00,
];
match parser::parse_dcerpc_udp_header(request) {
Ok((rem, header)) => {
assert_eq!(4, header.rpc_vers);
assert_eq!(80, request.len() - rem.len());
}
_ => { assert!(false); }
}
let (rem, header) = parser::parse_dcerpc_udp_header(request).unwrap();
assert_eq!(4, header.rpc_vers);
assert_eq!(80, request.len() - rem.len());
}
#[test]
@ -447,14 +438,10 @@ mod tests {
0x79, 0xbe, 0x01, 0x34, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
0xff, 0xff, 0xff, 0xff, 0x68, 0x00, 0x00, 0x00, 0x0a, 0x00,
];
match parser::parse_dcerpc_udp_header(request) {
Ok((rem, header)) => {
assert_eq!(4, header.rpc_vers);
assert_eq!(80, request.len() - rem.len());
assert_eq!(0, rem.len());
}
_ => { assert!(false); }
}
let (rem, header) = parser::parse_dcerpc_udp_header(request).unwrap();
assert_eq!(4, header.rpc_vers);
assert_eq!(80, request.len() - rem.len());
assert_eq!(0, rem.len());
}
#[test]

264
rust/src/detect/byte_math.rs
Unescape Escape View File

@ -517,14 +517,8 @@ mod tests {
..Default::default()
};
match parse_bytemath(args) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath(args).unwrap();
assert_eq!(val, bmd);
}
#[test]
@ -623,52 +617,26 @@ mod tests {
..Default::default()
};
match parse_bytemath(
let (_, val) = parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string dec",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
).unwrap();
assert_eq!(val, bmd);
bmd.flags = DETECT_BYTEMATH_FLAG_RVALUE_VAR;
bmd.base = BASE_DEFAULT;
match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
bmd.flags = DETECT_BYTEMATH_FLAG_RVALUE_VAR | DETECT_BYTEMATH_FLAG_STRING;
bmd.base = ByteMathBase::BaseHex;
match parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string hex",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string hex").unwrap();
assert_eq!(val, bmd);
bmd.base = ByteMathBase::BaseOct;
match parse_bytemath(
let (_, val) = parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, string oct",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
).unwrap();
assert_eq!(val, bmd);
}
#[test]
@ -774,40 +742,25 @@ mod tests {
};
bmd.bitmask_val = 0x12345678;
match parse_bytemath(
let (_, val) = parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, bitmask 0x12345678",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
).unwrap();
assert_eq!(val, bmd);
bmd.bitmask_val = 0xffff1234;
match parse_bytemath(
let (_, val) = parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, bitmask ffff1234",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
).unwrap();
assert_eq!(val, bmd);
bmd.bitmask_val = 0xffff1234;
match parse_bytemath(
let (_, val) = parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, bitmask 0Xffff1234",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
).unwrap();
assert_eq!(val, bmd);
}
#[test]
fn test_parser_endian_valid() {
@ -824,49 +777,29 @@ mod tests {
..Default::default()
};
match parse_bytemath(
let (_, val) = parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, endian big",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
).unwrap();
assert_eq!(val, bmd);
bmd.endian = ByteMathEndian::LittleEndian;
match parse_bytemath(
let (_, val) = parse_bytemath(
"bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, endian little",
) {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
).unwrap();
assert_eq!(val, bmd);
bmd.endian = ByteMathEndian::EndianDCE;
match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, dce") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo, dce").unwrap();
assert_eq!(val, bmd);
bmd.endian = DETECT_BYTEMATH_ENDIAN_DEFAULT;
bmd.flags = DETECT_BYTEMATH_FLAG_RVALUE_VAR;
match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
}
#[test]
@ -920,61 +853,31 @@ mod tests {
..Default::default()
};
match parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper +, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
bmd.oper = ByteMathOperator::Subtraction;
match parse_bytemath("bytes 4, offset 3933, oper -, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper -, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
bmd.oper = ByteMathOperator::Multiplication;
match parse_bytemath("bytes 4, offset 3933, oper *, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper *, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
bmd.oper = ByteMathOperator::Division;
match parse_bytemath("bytes 4, offset 3933, oper /, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper /, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
bmd.oper = ByteMathOperator::RightShift;
match parse_bytemath("bytes 4, offset 3933, oper >>, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper >>, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
bmd.oper = ByteMathOperator::LeftShift;
match parse_bytemath("bytes 4, offset 3933, oper <<, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 3933, oper <<, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
}
#[test]
@ -1013,33 +916,18 @@ mod tests {
..Default::default()
};
match parse_bytemath("bytes 4, offset 47303, oper *, rvalue 4294967295 , result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 47303, oper *, rvalue 4294967295 , result foo").unwrap();
assert_eq!(val, bmd);
bmd.rvalue = 1;
match parse_bytemath("bytes 4, offset 47303, oper *, rvalue 1, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 47303, oper *, rvalue 1, result foo").unwrap();
assert_eq!(val, bmd);
bmd.rvalue = 0;
match parse_bytemath("bytes 4, offset 47303, oper *, rvalue 0, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 47303, oper *, rvalue 0, result foo").unwrap();
assert_eq!(val, bmd);
}
#[test]
@ -1064,24 +952,14 @@ mod tests {
..Default::default()
};
match parse_bytemath("bytes 4, offset -65535, oper *, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset -65535, oper *, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
bmd.offset = 65535;
match parse_bytemath("bytes 4, offset 65535, oper *, rvalue myrvalue, result foo") {
Ok((_, val)) => {
assert_eq!(val, bmd);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = parse_bytemath("bytes 4, offset 65535, oper *, rvalue myrvalue, result foo").unwrap();
assert_eq!(val, bmd);
}
#[test]

29
rust/src/detect/uint.rs
Unescape Escape View File

@ -409,27 +409,12 @@ mod tests {
#[test]
fn test_parse_uint_unit() {
match detect_parse_uint::<u64>(" 2kb") {
Ok((_, val)) => {
assert_eq!(val.arg1, 2048);
}
Err(_) => {
assert!(false);
}
}
match detect_parse_uint::<u8>("2kb") {
Ok((_, _val)) => {
assert!(false);
}
Err(_) => {}
}
match detect_parse_uint::<u32>("3MB") {
Ok((_, val)) => {
assert_eq!(val.arg1, 3 * 1024 * 1024);
}
Err(_) => {
assert!(false);
}
}
let (_, val) = detect_parse_uint::<u64>(" 2kb").unwrap();
assert_eq!(val.arg1, 2048);
assert!(detect_parse_uint::<u8>("2kb").is_err());
let (_, val) = detect_parse_uint::<u32>("3MB").unwrap();
assert_eq!(val.arg1, 3 * 1024 * 1024);
}
}

62
rust/src/dhcp/parser.rs
Unescape Escape View File

@ -242,42 +242,36 @@ mod tests {
let pcap = include_bytes!("discover.pcap");
let payload = &pcap[24 + 16 + 42..];
match dhcp_parse(payload) {
Ok((_rem, message)) => {
let header = message.header;
assert_eq!(header.opcode, BOOTP_REQUEST);
assert_eq!(header.htype, 1);
assert_eq!(header.hlen, 6);
assert_eq!(header.hops, 0);
assert_eq!(header.txid, 0x00003d1d);
assert_eq!(header.seconds, 0);
assert_eq!(header.flags, 0);
assert_eq!(header.clientip, &[0, 0, 0, 0]);
assert_eq!(header.yourip, &[0, 0, 0, 0]);
assert_eq!(header.serverip, &[0, 0, 0, 0]);
assert_eq!(header.giaddr, &[0, 0, 0, 0]);
assert_eq!(
&header.clienthw[..(header.hlen as usize)],
&[0x00, 0x0b, 0x82, 0x01, 0xfc, 0x42]
);
assert!(header.servername.iter().all(|&x| x == 0));
assert!(header.bootfilename.iter().all(|&x| x == 0));
assert_eq!(header.magic, &[0x63, 0x82, 0x53, 0x63]);
let (_rem, message) = dhcp_parse(payload).unwrap();
let header = message.header;
assert_eq!(header.opcode, BOOTP_REQUEST);
assert_eq!(header.htype, 1);
assert_eq!(header.hlen, 6);
assert_eq!(header.hops, 0);
assert_eq!(header.txid, 0x00003d1d);
assert_eq!(header.seconds, 0);
assert_eq!(header.flags, 0);
assert_eq!(header.clientip, &[0, 0, 0, 0]);
assert_eq!(header.yourip, &[0, 0, 0, 0]);
assert_eq!(header.serverip, &[0, 0, 0, 0]);
assert_eq!(header.giaddr, &[0, 0, 0, 0]);
assert_eq!(
&header.clienthw[..(header.hlen as usize)],
&[0x00, 0x0b, 0x82, 0x01, 0xfc, 0x42]
);
assert!(header.servername.iter().all(|&x| x == 0));
assert!(header.bootfilename.iter().all(|&x| x == 0));
assert_eq!(header.magic, &[0x63, 0x82, 0x53, 0x63]);
assert!(!message.malformed_options);
assert!(!message.truncated_options);
assert!(!message.malformed_options);
assert!(!message.truncated_options);
assert_eq!(message.options.len(), 5);
assert_eq!(message.options[0].code, DHCP_OPT_TYPE);
assert_eq!(message.options[1].code, DHCP_OPT_CLIENT_ID);
assert_eq!(message.options[2].code, DHCP_OPT_REQUESTED_IP);
assert_eq!(message.options[3].code, DHCP_OPT_PARAMETER_LIST);
assert_eq!(message.options[4].code, DHCP_OPT_END);
}
_ => {
assert!(false);
}
}
assert_eq!(message.options.len(), 5);
assert_eq!(message.options[0].code, DHCP_OPT_TYPE);
assert_eq!(message.options[1].code, DHCP_OPT_CLIENT_ID);
assert_eq!(message.options[2].code, DHCP_OPT_REQUESTED_IP);
assert_eq!(message.options[3].code, DHCP_OPT_PARAMETER_LIST);
assert_eq!(message.options[4].code, DHCP_OPT_END);
}
#[test]

408
rust/src/dns/parser.rs
Unescape Escape View File

@ -477,35 +477,29 @@ mod tests {
let (body, header) = dns_parse_header(pkt).unwrap();
let res = dns_parse_body(body, pkt, header);
match res {
Ok((rem, request)) => {
// For now we have some remainder data as there is an
// additional record type we don't parse yet.
assert!(!rem.is_empty());
assert_eq!(
request.header,
DNSHeader {
tx_id: 0x8d32,
flags: 0x0120,
questions: 1,
answer_rr: 0,
authority_rr: 0,
additional_rr: 1,
}
);
assert_eq!(request.queries.len(), 1);
let (rem, request) = res.unwrap();
// For now we have some remainder data as there is an
// additional record type we don't parse yet.
assert!(!rem.is_empty());
let query = &request.queries[0];
assert_eq!(query.name, "www.suricata-ids.org".as_bytes().to_vec());
assert_eq!(query.rrtype, 1);
assert_eq!(query.rrclass, 1);
}
_ => {
assert!(false);
assert_eq!(
request.header,
DNSHeader {
tx_id: 0x8d32,
flags: 0x0120,
questions: 1,
answer_rr: 0,
authority_rr: 0,
additional_rr: 1,
}
}
);
assert_eq!(request.queries.len(), 1);
let query = &request.queries[0];
assert_eq!(query.name, "www.suricata-ids.org".as_bytes().to_vec());
assert_eq!(query.rrtype, 1);
assert_eq!(query.rrclass, 1);
}
/// Parse a DNS response.
@ -534,64 +528,57 @@ mod tests {
0x00, 0x04, 0xc0, 0x00, 0x4e, 0x19, /* ....N. */
];
let res = dns_parse_response(pkt);
match res {
Ok((rem, response)) => {
// The response should be full parsed.
assert_eq!(rem.len(), 0);
assert_eq!(
response.header,
DNSHeader {
tx_id: 0x8d32,
flags: 0x81a0,
questions: 1,
answer_rr: 3,
authority_rr: 0,
additional_rr: 0,
}
);
assert_eq!(response.answers.len(), 3);
let answer1 = &response.answers[0];
assert_eq!(answer1.name, "www.suricata-ids.org".as_bytes().to_vec());
assert_eq!(answer1.rrtype, 5);
assert_eq!(answer1.rrclass, 1);
assert_eq!(answer1.ttl, 3544);
assert_eq!(
answer1.data,
DNSRData::CNAME("suricata-ids.org".as_bytes().to_vec())
);
let answer2 = &response.answers[1];
assert_eq!(
answer2,
&DNSAnswerEntry {
name: "suricata-ids.org".as_bytes().to_vec(),
rrtype: 1,
rrclass: 1,
ttl: 244,
data: DNSRData::A([192, 0, 78, 24].to_vec()),
}
);
let answer3 = &response.answers[2];
assert_eq!(
answer3,
&DNSAnswerEntry {
name: "suricata-ids.org".as_bytes().to_vec(),
rrtype: 1,
rrclass: 1,
ttl: 244,
data: DNSRData::A([192, 0, 78, 25].to_vec()),
}
)
let (rem, response) = dns_parse_response(pkt).unwrap();
// The response should be full parsed.
assert_eq!(rem.len(), 0);
assert_eq!(
response.header,
DNSHeader {
tx_id: 0x8d32,
flags: 0x81a0,
questions: 1,
answer_rr: 3,
authority_rr: 0,
additional_rr: 0,
}
);
assert_eq!(response.answers.len(), 3);
let answer1 = &response.answers[0];
assert_eq!(answer1.name, "www.suricata-ids.org".as_bytes().to_vec());
assert_eq!(answer1.rrtype, 5);
assert_eq!(answer1.rrclass, 1);
assert_eq!(answer1.ttl, 3544);
assert_eq!(
answer1.data,
DNSRData::CNAME("suricata-ids.org".as_bytes().to_vec())
);
let answer2 = &response.answers[1];
assert_eq!(
answer2,
&DNSAnswerEntry {
name: "suricata-ids.org".as_bytes().to_vec(),
rrtype: 1,
rrclass: 1,
ttl: 244,
data: DNSRData::A([192, 0, 78, 24].to_vec()),
}
_ => {
assert!(false);
);
let answer3 = &response.answers[2];
assert_eq!(
answer3,
&DNSAnswerEntry {
name: "suricata-ids.org".as_bytes().to_vec(),
rrtype: 1,
rrclass: 1,
ttl: 244,
data: DNSRData::A([192, 0, 78, 25].to_vec()),
}
}
)
}
#[test]
@ -617,49 +604,42 @@ mod tests {
0x00, 0x00, 0x00, 0x00, /* .... */
];
let res = dns_parse_response(pkt);
match res {
Ok((rem, response)) => {
// For now we have some remainder data as there is an
// additional record type we don't parse yet.
assert!(!rem.is_empty());
assert_eq!(
response.header,
DNSHeader {
tx_id: 0x8295,
flags: 0x8183,
questions: 1,
answer_rr: 0,
authority_rr: 1,
additional_rr: 1,
}
);
assert_eq!(response.authorities.len(), 1);
let authority = &response.authorities[0];
assert_eq!(authority.name, "oisf.net".as_bytes().to_vec());
assert_eq!(authority.rrtype, 6);
assert_eq!(authority.rrclass, 1);
assert_eq!(authority.ttl, 899);
assert_eq!(
authority.data,
DNSRData::SOA(DNSRDataSOA {
mname: "ns-110.awsdns-13.com".as_bytes().to_vec(),
rname: "awsdns-hostmaster.amazon.com".as_bytes().to_vec(),
serial: 1,
refresh: 7200,
retry: 900,
expire: 1209600,
minimum: 86400,
})
);
}
_ => {
assert!(false);
let (rem, response) = dns_parse_response(pkt).unwrap();
// For now we have some remainder data as there is an
// additional record type we don't parse yet.
assert!(!rem.is_empty());
assert_eq!(
response.header,
DNSHeader {
tx_id: 0x8295,
flags: 0x8183,
questions: 1,
answer_rr: 0,
authority_rr: 1,
additional_rr: 1,
}
}
);
assert_eq!(response.authorities.len(), 1);
let authority = &response.authorities[0];
assert_eq!(authority.name, "oisf.net".as_bytes().to_vec());
assert_eq!(authority.rrtype, 6);
assert_eq!(authority.rrclass, 1);
assert_eq!(authority.ttl, 899);
assert_eq!(
authority.data,
DNSRData::SOA(DNSRDataSOA {
mname: "ns-110.awsdns-13.com".as_bytes().to_vec(),
rname: "awsdns-hostmaster.amazon.com".as_bytes().to_vec(),
serial: 1,
refresh: 7200,
retry: 900,
expire: 1209600,
minimum: 86400,
})
);
}
#[test]
@ -678,49 +658,42 @@ mod tests {
0x44, 0x03, 0xc5, 0xe9, 0x01, /* D.... */
];
let res = dns_parse_response(pkt);
match res {
Ok((rem, response)) => {
// The response should be fully parsed.
assert_eq!(rem.len(), 0);
assert_eq!(
response.header,
DNSHeader {
tx_id: 0x12b0,
flags: 0x8400,
questions: 1,
answer_rr: 1,
authority_rr: 0,
additional_rr: 0,
}
);
assert_eq!(response.queries.len(), 1);
let query = &response.queries[0];
assert_eq!(query.name, "vaaaakardli.pirate.sea".as_bytes().to_vec());
assert_eq!(query.rrtype, DNS_RECORD_TYPE_NULL);
assert_eq!(query.rrclass, 1);
assert_eq!(response.answers.len(), 1);
let answer = &response.answers[0];
assert_eq!(answer.name, "vaaaakardli.pirate.sea".as_bytes().to_vec());
assert_eq!(answer.rrtype, DNS_RECORD_TYPE_NULL);
assert_eq!(answer.rrclass, 1);
assert_eq!(answer.ttl, 0);
assert_eq!(
answer.data,
DNSRData::NULL(vec![
0x56, 0x41, 0x43, 0x4b, /* VACK */
0x44, 0x03, 0xc5, 0xe9, 0x01, /* D.... */
])
);
}
_ => {
assert!(false);
let (rem, response) = dns_parse_response(pkt).unwrap();
// The response should be fully parsed.
assert_eq!(rem.len(), 0);
assert_eq!(
response.header,
DNSHeader {
tx_id: 0x12b0,
flags: 0x8400,
questions: 1,
answer_rr: 1,
authority_rr: 0,
additional_rr: 0,
}
}
);
assert_eq!(response.queries.len(), 1);
let query = &response.queries[0];
assert_eq!(query.name, "vaaaakardli.pirate.sea".as_bytes().to_vec());
assert_eq!(query.rrtype, DNS_RECORD_TYPE_NULL);
assert_eq!(query.rrclass, 1);
assert_eq!(response.answers.len(), 1);
let answer = &response.answers[0];
assert_eq!(answer.name, "vaaaakardli.pirate.sea".as_bytes().to_vec());
assert_eq!(answer.rrtype, DNS_RECORD_TYPE_NULL);
assert_eq!(answer.rrclass, 1);
assert_eq!(answer.ttl, 0);
assert_eq!(
answer.data,
DNSRData::NULL(vec![
0x56, 0x41, 0x43, 0x4b, /* VACK */
0x44, 0x03, 0xc5, 0xe9, 0x01, /* D.... */
])
);
}
#[test]
@ -734,26 +707,16 @@ mod tests {
0x9a, 0xbc, 0xde, 0xf6, 0x78, 0x90,
];
let res = dns_parse_rdata_sshfp(data);
match res {
Ok((rem, rdata)) => {
// The data should be fully parsed.
assert_eq!(rem.len(), 0);
match rdata {
DNSRData::SSHFP(sshfp) => {
assert_eq!(sshfp.algo, 2);
assert_eq!(sshfp.fp_type, 1);
assert_eq!(sshfp.fingerprint, &data[2..]);
}
_ => {
assert!(false);
}
}
}
_ => {
assert!(false);
}
let (rem, rdata) = dns_parse_rdata_sshfp(data).unwrap();
// The data should be fully parsed.
assert_eq!(rem.len(), 0);
if let DNSRData::SSHFP(sshfp) = rdata {
assert_eq!(sshfp.algo, 2);
assert_eq!(sshfp.fp_type, 1);
assert_eq!(sshfp.fingerprint, &data[2..]);
} else {
panic!("Expected DNSRData::SSHFP");
}
}
@ -790,48 +753,35 @@ mod tests {
0x67, 0x6c, 0x65, 0x03, 0x63, 0x6f, 0x6d, 0x00,
];
let res = dns_parse_response(pkt);
match res {
Ok((rem, response)) => {
// The data should be fully parsed.
assert_eq!(rem.len(), 0);
assert_eq!(response.answers.len(), 2);
let answer1 = &response.answers[0];
match &answer1.data {
DNSRData::SRV(srv) => {
assert_eq!(srv.priority, 20);
assert_eq!(srv.weight, 1);
assert_eq!(srv.port, 5060);
assert_eq!(
srv.target,
"sip-anycast-2.voice.google.com".as_bytes().to_vec()
);
}
_ => {
assert!(false);
}
}
let answer2 = &response.answers[1];
match &answer2.data {
DNSRData::SRV(srv) => {
assert_eq!(srv.priority, 10);
assert_eq!(srv.weight, 1);
assert_eq!(srv.port, 5060);
assert_eq!(
srv.target,
"sip-anycast-1.voice.google.com".as_bytes().to_vec()
);
}
_ => {
assert!(false);
}
}
}
_ => {
assert!(false);
}
let (rem, response) = dns_parse_response(pkt).unwrap();
// The data should be fully parsed.
assert_eq!(rem.len(), 0);
assert_eq!(response.answers.len(), 2);
let answer1 = &response.answers[0];
if let DNSRData::SRV(srv) = &answer1.data {
assert_eq!(srv.priority, 20);
assert_eq!(srv.weight, 1);
assert_eq!(srv.port, 5060);
assert_eq!(
srv.target,
"sip-anycast-2.voice.google.com".as_bytes().to_vec()
);
} else {
panic!("Expected DNSRData::SRV");
}
let answer2 = &response.answers[1];
if let DNSRData::SRV(srv) = &answer2.data {
assert_eq!(srv.priority, 10);
assert_eq!(srv.weight, 1);
assert_eq!(srv.port, 5060);
assert_eq!(
srv.target,
"sip-anycast-1.voice.google.com".as_bytes().to_vec()
);
} else {
panic!("Expected DNSRData::SRV");
}
}
}

30
rust/src/sip/parser.rs
Unescape Escape View File

@ -275,17 +275,11 @@ mod tests {
\r\n"
.as_bytes();
match sip_parse_request(buf) {
Ok((_, req)) => {
assert_eq!(req.method, "REGISTER");
assert_eq!(req.path, "sip:sip.cybercity.dk");
assert_eq!(req.version, "SIP/2.0");
assert_eq!(req.headers["Content-Length"], "0");
}
_ => {
assert!(false);
}
}
let (_, req) = sip_parse_request(buf).unwrap();
assert_eq!(req.method, "REGISTER");
assert_eq!(req.path, "sip:sip.cybercity.dk");
assert_eq!(req.version, "SIP/2.0");
assert_eq!(req.headers["Content-Length"], "0");
}
#[test]
@ -311,15 +305,9 @@ mod tests {
\r\n"
.as_bytes();
match sip_parse_response(buf) {
Ok((_, resp)) => {
assert_eq!(resp.version, "SIP/2.0");
assert_eq!(resp.code, "401");
assert_eq!(resp.reason, "Unauthorized");
}
_ => {
assert!(false);
}
}
let (_, resp) = sip_parse_response(buf).unwrap();
assert_eq!(resp.version, "SIP/2.0");
assert_eq!(resp.code, "401");
assert_eq!(resp.reason, "Unauthorized");
}
}

Write Preview
Loading…
Cancel
Save