use super::detect;
use crate::core::{
HttpRangeContainerBlock, StreamingBufferConfig, SuricataFileContext, SC,
};
use crate::direction::Direction;
use crate::flow::Flow;
use crate::http2::http2::HTTP2Transaction;
use crate::http2::http2::SURICATA_HTTP2_FILE_CONFIG;
use nom7::branch::alt;
use nom7::bytes::streaming::{take_till, take_while};
use nom7::character::complete::{char, digit1};
use nom7::combinator::{map_res, value};
use nom7::error::{make_error, ErrorKind};
use nom7::{Err, IResult};
use std::os::raw::c_uchar;
use std::str::FromStr;
#[derive(Debug)]
#[repr(C)]
pub struct HTTPContentRange {
pub start: i64,
pub end: i64,
pub size: i64,
}
pub fn http2_parse_content_range_star(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
let (i2, _) = char('*')(input)?;
let (i2, _) = char('/')(i2)?;
let (i2, size) = map_res(map_res(digit1, std::str::from_utf8), i64::from_str)(i2)?;
return Ok((
i2,
HTTPContentRange {
start: -1,
end: -1,
size,
},
));
}
pub fn http2_parse_content_range_def(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
let (i2, start) = map_res(map_res(digit1, std::str::from_utf8), i64::from_str)(input)?;
let (i2, _) = char('-')(i2)?;
let (i2, end) = map_res(map_res(digit1, std::str::from_utf8), i64::from_str)(i2)?;
let (i2, _) = char('/')(i2)?;
let (i2, size) = alt((
value(-1, char('*')),
map_res(map_res(digit1, std::str::from_utf8), i64::from_str),
))(i2)?;
return Ok((i2, HTTPContentRange { start, end, size }));
}
fn http2_parse_content_range(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
let (i2, _) = take_while(|c| c == b' ')(input)?;
let (i2, _) = take_till(|c| c == b' ')(i2)?;
let (i2, _) = take_while(|c| c == b' ')(i2)?;
return alt((
http2_parse_content_range_star,
http2_parse_content_range_def,
))(i2);
}
pub fn http2_parse_check_content_range(input: &[u8]) -> IResult<&[u8], HTTPContentRange> {
let (rem, v) = http2_parse_content_range(input)?;
if v.start > v.end || (v.end > 0 && v.size > 0 && v.end > v.size - 1) {
return Err(Err::Error(make_error(rem, ErrorKind::Verify)));
}
return Ok((rem, v));
}
#[no_mangle]
pub unsafe extern "C" fn SCHttpParseContentRange(
cr: &mut HTTPContentRange, buffer: *const u8, buffer_len: u32,
) -> std::os::raw::c_int {
let slice = build_slice!(buffer, buffer_len as usize);
match http2_parse_content_range(slice) {
Ok((_, c)) => {
*cr = c;
return 0;
}
_ => {
return -1;
}
}
}
fn http2_range_key_get(tx: &mut HTTP2Transaction) -> Result<(Vec<u8>, usize), ()> {
let hostv = detect::http2_frames_get_header_value_vec(tx, Direction::ToServer, ":authority")?;
let mut hostv = &hostv[..];
if let Some(p) = hostv.iter().position(|&x| x == b':') {
hostv = &hostv[..p];
}
let uriv = detect::http2_frames_get_header_value_vec(tx, Direction::ToServer, ":path")?;
let mut uriv = &uriv[..];
if let Some(p) = uriv.iter().position(|&x| x == b'?') {
uriv = &uriv[..p];
}
if let Some(p) = uriv.iter().rposition(|&x| x == b'/') {
uriv = &uriv[p..];
}
let mut r = Vec::with_capacity(hostv.len() + uriv.len());
r.extend_from_slice(hostv);
r.extend_from_slice(uriv);
return Ok((r, hostv.len()));
}
pub fn http2_range_open(
tx: &mut HTTP2Transaction, v: &HTTPContentRange, flow: *const Flow,
cfg: &'static SuricataFileContext, dir: Direction, data: &[u8],
) {
if v.end <= 0 || v.size <= 0 {
return;
}
if v.end == v.size - 1 && v.start == 0 {
return;
}
let flags = if dir == Direction::ToServer {
tx.ft_ts.file_flags
} else {
tx.ft_tc.file_flags
};
if let Ok((key, index)) = http2_range_key_get(tx) {
let name = &key[index..];
tx.file_range = unsafe {
HttpRangeContainerOpenFile(
key.as_ptr(),
key.len() as u32,
flow,
v,
cfg.files_sbcfg,
name.as_ptr(),
name.len() as u16,
flags,
data.as_ptr(),
data.len() as u32,
)
};
}
}
pub fn http2_range_append(
cfg: &'static SuricataFileContext, fr: *mut HttpRangeContainerBlock, data: &[u8],
) {
unsafe {
HttpRangeAppendData(cfg.files_sbcfg, fr, data.as_ptr(), data.len() as u32);
}
}
pub fn http2_range_close(tx: &mut HTTP2Transaction, dir: Direction, data: &[u8]) {
let added = if let Some(c) = unsafe { SC } {
if let Some(sfcm) = unsafe { SURICATA_HTTP2_FILE_CONFIG } {
let (files, flags) = if dir == Direction::ToServer {
(&mut tx.ft_ts.file, tx.ft_ts.file_flags)
} else {
(&mut tx.ft_tc.file, tx.ft_tc.file_flags)
};
let added = (c.HTPFileCloseHandleRange)(
sfcm.files_sbcfg,
files,
flags,
tx.file_range,
data.as_ptr(),
data.len() as u32,
);
(c.HttpRangeFreeBlock)(tx.file_range);
added
} else {
false
}
} else {
false
};
tx.file_range = std::ptr::null_mut();
if added {
tx.tx_data.incr_files_opened();
}
}
extern "C" {
pub fn HttpRangeContainerOpenFile(
key: *const c_uchar, keylen: u32, f: *const Flow, cr: &HTTPContentRange,
sbcfg: *const StreamingBufferConfig, name: *const c_uchar, name_len: u16, flags: u16,
data: *const c_uchar, data_len: u32,
) -> *mut HttpRangeContainerBlock;
pub fn HttpRangeAppendData(
cfg: *const StreamingBufferConfig, c: *mut HttpRangeContainerBlock, data: *const c_uchar,
data_len: u32,
) -> std::os::raw::c_int;
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_http2_parse_content_range() {
let buf0: &[u8] = " bytes */100".as_bytes();
let r0 = http2_parse_content_range(buf0);
match r0 {
Ok((rem, rg)) => {
assert_eq!(rg.start, -1);
assert_eq!(rg.end, -1);
assert_eq!(rg.size, 100);
assert_eq!(rem.len(), 0);
}
_ => {
panic!("Result should have been ok.");
}
}
let buf1: &[u8] = " bytes 10-20/200".as_bytes();
let r1 = http2_parse_content_range(buf1);
match r1 {
Ok((rem, rg)) => {
assert_eq!(rg.start, 10);
assert_eq!(rg.end, 20);
assert_eq!(rg.size, 200);
assert_eq!(rem.len(), 0);
}
_ => {
panic!("Result should have been ok.");
}
}
let buf2: &[u8] = " bytes 30-68/*".as_bytes();
let r2 = http2_parse_content_range(buf2);
match r2 {
Ok((rem, rg)) => {
assert_eq!(rg.start, 30);
assert_eq!(rg.end, 68);
assert_eq!(rg.size, -1);
assert_eq!(rem.len(), 0);
}
_ => {
panic!("Result should have been ok.");
}
}
}
}