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]
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]
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]
..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]
..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]
};
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() {
..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]
..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]
..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]
..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]
#[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);
}
}
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]
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.
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]
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]
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]
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");
}
}
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");
}
}
}
\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]
\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");
}
}
projects / thirdparty / suricata.git / commitdiff
