YGGverse/aquatic
1
0
Fork 0
mirror of https://github.com/YGGverse/aquatic.git synced 2026-03-31 09:45:31 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

http protocol: rename methods for writing to and parsing from bytes

Browse source
This commit is contained in:
Joakim Frostegård 2024-01-29 19:52:41 +01:00
parent 3c906f48ee
commit 38de05a6c4
7 changed files with 30 additions and 30 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/http/src/workers/socket/connection.rs
View file

@ -389,7 +389,7 @@ where
let mut position = RESPONSE_HEADER.len(); let mut position = RESPONSE_HEADER.len();
let body_len = response let body_len = response
.write(&mut &mut self.response_buffer[position..]) .write_bytes(&mut &mut self.response_buffer[position..])
.map_err(ConnectionError::ResponseBufferWrite)?; .map_err(ConnectionError::ResponseBufferWrite)?;
position += body_len; position += body_len;

2
crates/http/src/workers/socket/request.rs
View file

@ -25,7 +25,7 @@ pub fn parse_request(
match http_request.parse(buffer).with_context(|| "httparse")? { match http_request.parse(buffer).with_context(|| "httparse")? {
httparse::Status::Complete(_) => { httparse::Status::Complete(_) => {
let path = http_request.path.ok_or(anyhow::anyhow!("no http path"))?; let path = http_request.path.ok_or(anyhow::anyhow!("no http path"))?;
let request = Request::from_http_get_path(path)?; let request = Request::parse_http_get_path(path)?;
let opt_peer_ip = if config.network.runs_behind_reverse_proxy { let opt_peer_ip = if config.network.runs_behind_reverse_proxy {
let header_name = &config.network.reverse_proxy_ip_header_name; let header_name = &config.network.reverse_proxy_ip_header_name;

2
crates/http_load_test/src/network.rs
View file

@ -229,7 +229,7 @@ where
} }
if let Some(body_start_index) = opt_body_start_index { if let Some(body_start_index) = opt_body_start_index {
match Response::from_bytes(&interesting_bytes[body_start_index..]) { match Response::parse_bytes(&interesting_bytes[body_start_index..]) {
Ok(response) => { Ok(response) => {
match response { match response {
Response::Announce(_) => { Response::Announce(_) => {

2
crates/http_protocol/benches/bench_announce_response_to_bytes.rs
View file

@ -33,7 +33,7 @@ pub fn bench(c: &mut Criterion) {
b.iter(|| { b.iter(|| {
buffer.set_position(0); buffer.set_position(0);
Response::write(black_box(&response), black_box(&mut buffer)).unwrap(); Response::write_bytes(black_box(&response), black_box(&mut buffer)).unwrap();
}) })
}); });
} }

2
crates/http_protocol/benches/bench_request_from_bytes.rs
View file

@ -7,7 +7,7 @@ static INPUT: &[u8] = b"GET /announce?info_hash=%04%0bkV%3f%5cr%14%a6%b7%98%adC%
pub fn bench(c: &mut Criterion) { pub fn bench(c: &mut Criterion) {
c.bench_function("request-from-bytes", |b| { c.bench_function("request-from-bytes", |b| {
b.iter(|| Request::from_bytes(black_box(INPUT))) b.iter(|| Request::parse_bytes(black_box(INPUT)))
}); });
} }

28
crates/http_protocol/src/request.rs
View file

@ -21,7 +21,7 @@ pub struct AnnounceRequest {
} }
impl AnnounceRequest { impl AnnounceRequest {
fn write<W: Write>(&self, output: &mut W, url_suffix: &[u8]) -> ::std::io::Result<()> { fn write_bytes<W: Write>(&self, output: &mut W, url_suffix: &[u8]) -> ::std::io::Result<()> {
output.write_all(b"GET /announce")?; output.write_all(b"GET /announce")?;
output.write_all(url_suffix)?; output.write_all(url_suffix)?;
output.write_all(b"?info_hash=")?; output.write_all(b"?info_hash=")?;
@ -67,7 +67,7 @@ impl AnnounceRequest {
Ok(()) Ok(())
} }
pub fn from_query_string(query_string: &str) -> anyhow::Result<Self> { pub fn parse_query_string(query_string: &str) -> anyhow::Result<Self> {
// -- Parse key-value pairs // -- Parse key-value pairs
let mut opt_info_hash = None; let mut opt_info_hash = None;
@ -173,7 +173,7 @@ pub struct ScrapeRequest {
} }
impl ScrapeRequest { impl ScrapeRequest {
fn write<W: Write>(&self, output: &mut W, url_suffix: &[u8]) -> ::std::io::Result<()> { fn write_bytes<W: Write>(&self, output: &mut W, url_suffix: &[u8]) -> ::std::io::Result<()> {
output.write_all(b"GET /scrape")?; output.write_all(b"GET /scrape")?;
output.write_all(url_suffix)?; output.write_all(url_suffix)?;
output.write_all(b"?")?; output.write_all(b"?")?;
@ -196,7 +196,7 @@ impl ScrapeRequest {
Ok(()) Ok(())
} }
pub fn from_query_string(query_string: &str) -> anyhow::Result<Self> { pub fn parse_query_string(query_string: &str) -> anyhow::Result<Self> {
// -- Parse key-value pairs // -- Parse key-value pairs
let mut info_hashes = Vec::new(); let mut info_hashes = Vec::new();
@ -252,14 +252,14 @@ pub enum Request {
impl Request { impl Request {
/// Parse Request from HTTP request bytes /// Parse Request from HTTP request bytes
pub fn from_bytes(bytes: &[u8]) -> anyhow::Result<Option<Self>> { pub fn parse_bytes(bytes: &[u8]) -> anyhow::Result<Option<Self>> {
let mut headers = [httparse::EMPTY_HEADER; 16]; let mut headers = [httparse::EMPTY_HEADER; 16];
let mut http_request = httparse::Request::new(&mut headers); let mut http_request = httparse::Request::new(&mut headers);
match http_request.parse(bytes) { match http_request.parse(bytes) {
Ok(httparse::Status::Complete(_)) => { Ok(httparse::Status::Complete(_)) => {
if let Some(path) = http_request.path { if let Some(path) = http_request.path {
Self::from_http_get_path(path).map(Some) Self::parse_http_get_path(path).map(Some)
} else { } else {
Err(anyhow::anyhow!("no http path")) Err(anyhow::anyhow!("no http path"))
} }
@ -282,7 +282,7 @@ impl Request {
/// UTF-8 string, meaning that non-ascii bytes are invalid characters. /// UTF-8 string, meaning that non-ascii bytes are invalid characters.
/// Therefore, these bytes must be converted to their equivalent multi-byte /// Therefore, these bytes must be converted to their equivalent multi-byte
/// UTF-8 encodings. /// UTF-8 encodings.
pub fn from_http_get_path(path: &str) -> anyhow::Result<Self> { pub fn parse_http_get_path(path: &str) -> anyhow::Result<Self> {
::log::debug!("request GET path: {}", path); ::log::debug!("request GET path: {}", path);
let mut split_parts = path.splitn(2, '?'); let mut split_parts = path.splitn(2, '?');
@ -291,11 +291,11 @@ impl Request {
let query_string = split_parts.next().with_context(|| "no query string")?; let query_string = split_parts.next().with_context(|| "no query string")?;
if location == "/announce" { if location == "/announce" {
Ok(Request::Announce(AnnounceRequest::from_query_string( Ok(Request::Announce(AnnounceRequest::parse_query_string(
query_string, query_string,
)?)) )?))
} else if location == "/scrape" { } else if location == "/scrape" {
Ok(Request::Scrape(ScrapeRequest::from_query_string( Ok(Request::Scrape(ScrapeRequest::parse_query_string(
query_string, query_string,
)?)) )?))
} else { } else {
@ -305,8 +305,8 @@ impl Request {
pub fn write<W: Write>(&self, output: &mut W, url_suffix: &[u8]) -> ::std::io::Result<()> { pub fn write<W: Write>(&self, output: &mut W, url_suffix: &[u8]) -> ::std::io::Result<()> {
match self { match self {
Self::Announce(r) => r.write(output, url_suffix), Self::Announce(r) => r.write_bytes(output, url_suffix),
Self::Scrape(r) => r.write(output, url_suffix), Self::Scrape(r) => r.write_bytes(output, url_suffix),
} }
} }
} }
@ -351,7 +351,7 @@ mod tests {
bytes.extend_from_slice(ANNOUNCE_REQUEST_PATH.as_bytes()); bytes.extend_from_slice(ANNOUNCE_REQUEST_PATH.as_bytes());
bytes.extend_from_slice(b" HTTP/1.1\r\n\r\n"); bytes.extend_from_slice(b" HTTP/1.1\r\n\r\n");
let parsed_request = Request::from_bytes(&bytes[..]).unwrap().unwrap(); let parsed_request = Request::parse_bytes(&bytes[..]).unwrap().unwrap();
let reference_request = get_reference_announce_request(); let reference_request = get_reference_announce_request();
assert_eq!(parsed_request, reference_request); assert_eq!(parsed_request, reference_request);
@ -365,7 +365,7 @@ mod tests {
bytes.extend_from_slice(SCRAPE_REQUEST_PATH.as_bytes()); bytes.extend_from_slice(SCRAPE_REQUEST_PATH.as_bytes());
bytes.extend_from_slice(b" HTTP/1.1\r\n\r\n"); bytes.extend_from_slice(b" HTTP/1.1\r\n\r\n");
let parsed_request = Request::from_bytes(&bytes[..]).unwrap().unwrap(); let parsed_request = Request::parse_bytes(&bytes[..]).unwrap().unwrap();
let reference_request = Request::Scrape(ScrapeRequest { let reference_request = Request::Scrape(ScrapeRequest {
info_hashes: vec![InfoHash(REFERENCE_INFO_HASH)], info_hashes: vec![InfoHash(REFERENCE_INFO_HASH)],
}); });
@ -432,7 +432,7 @@ mod tests {
request.write(&mut bytes, &[]).unwrap(); request.write(&mut bytes, &[]).unwrap();
let parsed_request = Request::from_bytes(&bytes[..]).unwrap().unwrap(); let parsed_request = Request::parse_bytes(&bytes[..]).unwrap().unwrap();
let success = request == parsed_request; let success = request == parsed_request;

22
crates/http_protocol/src/response.rs
View file

@ -61,7 +61,7 @@ pub struct AnnounceResponse {
} }
impl AnnounceResponse { impl AnnounceResponse {
pub fn write<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> { pub fn write_bytes<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> {
let mut bytes_written = 0usize; let mut bytes_written = 0usize;
bytes_written += output.write(b"d8:completei")?; bytes_written += output.write(b"d8:completei")?;
@ -124,7 +124,7 @@ pub struct ScrapeResponse {
} }
impl ScrapeResponse { impl ScrapeResponse {
pub fn write<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> { pub fn write_bytes<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> {
let mut bytes_written = 0usize; let mut bytes_written = 0usize;
bytes_written += output.write(b"d5:filesd")?; bytes_written += output.write(b"d5:filesd")?;
@ -160,7 +160,7 @@ impl FailureResponse {
} }
} }
pub fn write<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> { pub fn write_bytes<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> {
let mut bytes_written = 0usize; let mut bytes_written = 0usize;
let reason_bytes = self.failure_reason.as_bytes(); let reason_bytes = self.failure_reason.as_bytes();
@ -184,14 +184,14 @@ pub enum Response {
} }
impl Response { impl Response {
pub fn write<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> { pub fn write_bytes<W: Write>(&self, output: &mut W) -> ::std::io::Result<usize> {
match self { match self {
Response::Announce(r) => r.write(output), Response::Announce(r) => r.write_bytes(output),
Response::Failure(r) => r.write(output), Response::Failure(r) => r.write_bytes(output),
Response::Scrape(r) => r.write(output), Response::Scrape(r) => r.write_bytes(output),
} }
} }
pub fn from_bytes(bytes: &[u8]) -> Result<Self, ::serde_bencode::Error> { pub fn parse_bytes(bytes: &[u8]) -> Result<Self, ::serde_bencode::Error> {
::serde_bencode::from_bytes(bytes) ::serde_bencode::from_bytes(bytes)
} }
} }
@ -285,7 +285,7 @@ mod tests {
let mut hand_written = Vec::new(); let mut hand_written = Vec::new();
response.write(&mut hand_written).unwrap(); response.write_bytes(&mut hand_written).unwrap();
let success = hand_written == reference; let success = hand_written == reference;
@ -303,7 +303,7 @@ mod tests {
let mut hand_written = Vec::new(); let mut hand_written = Vec::new();
response.write(&mut hand_written).unwrap(); response.write_bytes(&mut hand_written).unwrap();
let success = hand_written == reference; let success = hand_written == reference;
@ -321,7 +321,7 @@ mod tests {
let mut hand_written = Vec::new(); let mut hand_written = Vec::new();
response.write(&mut hand_written).unwrap(); response.write_bytes(&mut hand_written).unwrap();
let success = hand_written == reference; let success = hand_written == reference;