From 3524694ee7108763404d57cb6ae7a6cc7d095e28 Mon Sep 17 00:00:00 2001 From: Guillermo Perez Date: Tue, 10 Mar 2026 22:32:46 +0100 Subject: [PATCH] Upgrade rust stable 1.94 --- Cargo.toml | 2 +- src/impl_build_cmd.rs | 2 +- src/impl_parse_header.rs | 96 ++++++++++----- src/impl_parse_header_tests.rs | 208 ++++++++++++++++----------------- src/lib.rs | 6 +- src/request_flags.rs | 18 +-- src/response_flags.rs | 30 ++--- 7 files changed, 199 insertions(+), 163 deletions(-) diff --git a/Cargo.toml b/Cargo.toml index 0df9388..03d944f 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "meta-memcache-socket" version = "0.1.6" -edition = "2021" +edition = "2024" [lib] name = "meta_memcache_socket" diff --git a/src/impl_build_cmd.rs b/src/impl_build_cmd.rs index e898a92..2cbca96 100644 --- a/src/impl_build_cmd.rs +++ b/src/impl_build_cmd.rs @@ -1,4 +1,4 @@ -use base64::{engine::general_purpose, Engine as _}; +use base64::{Engine as _, engine::general_purpose}; use crate::RequestFlags; diff --git a/src/impl_parse_header.rs b/src/impl_parse_header.rs index e7298c1..e03f10e 100644 --- a/src/impl_parse_header.rs +++ b/src/impl_parse_header.rs @@ -1,12 +1,18 @@ use memchr::memmem; -use crate::{constants::*, ResponseFlags}; +use crate::constants::*; +use crate::response_flags::ResponseFlags; -pub fn impl_parse_header( - data: &[u8], - start: usize, - end: usize, -) -> Option<(usize, Option, Option, Option)> { +/// Result of parsing a memcache meta-protocol response header. +#[derive(Debug)] +pub struct ParsedHeader { + pub end_pos: usize, + pub response_type: Option, + pub size: Option, + pub flags: Option, +} + +pub fn impl_parse_header(data: &[u8], start: usize, end: usize) -> Option { if end - start < 4 { return None; } @@ -15,28 +21,60 @@ pub fn impl_parse_header( if search_start >= end { return None; } - // Use memmem SIMD-accelerated search for \r\n - if let Some(pos) = memmem::find(&data[search_start..end], b"\r\n") { - let n = search_start + pos; - let endl_pos = n + 2; - match &data[start..start + 2] { - b"VA" => match ResponseFlags::from_value_header(&data[start..n]) { - Some((size, flags)) => { - Some((endl_pos, Some(RESPONSE_VALUE), Some(size), Some(flags))) - } - None => Some((endl_pos, None, None, None)), - }, - b"HD" | b"OK" => { - let flags = ResponseFlags::from_success_header(&data[start..n]); - Some((endl_pos, Some(RESPONSE_SUCCESS), None, Some(flags))) - } - b"NS" => Some((endl_pos, Some(RESPONSE_NOT_STORED), None, None)), - b"EX" => Some((endl_pos, Some(RESPONSE_CONFLICT), None, None)), - b"EN" | b"NF" => Some((endl_pos, Some(RESPONSE_MISS), None, None)), - b"MN" => Some((endl_pos, Some(RESPONSE_NOOP), None, None)), - _ => Some((endl_pos, None, None, None)), - } - } else { - None + // SIMD-accelerated search for \r\n + let pos = memmem::find(&data[search_start..end], b"\r\n")?; + let n = search_start + pos; + let end_pos = n + 2; + match &data[start..start + 2] { + b"VA" => match ResponseFlags::from_value_header(&data[start..n]) { + Some((size, flags)) => Some(ParsedHeader { + end_pos, + response_type: Some(RESPONSE_VALUE), + size: Some(size), + flags: Some(flags), + }), + None => Some(ParsedHeader { + end_pos, + response_type: None, + size: None, + flags: None, + }), + }, + b"HD" | b"OK" => Some(ParsedHeader { + end_pos, + response_type: Some(RESPONSE_SUCCESS), + size: None, + flags: Some(ResponseFlags::from_success_header(&data[start..n])), + }), + b"NS" => Some(ParsedHeader { + end_pos, + response_type: Some(RESPONSE_NOT_STORED), + size: None, + flags: None, + }), + b"EX" => Some(ParsedHeader { + end_pos, + response_type: Some(RESPONSE_CONFLICT), + size: None, + flags: None, + }), + b"EN" | b"NF" => Some(ParsedHeader { + end_pos, + response_type: Some(RESPONSE_MISS), + size: None, + flags: None, + }), + b"MN" => Some(ParsedHeader { + end_pos, + response_type: Some(RESPONSE_NOOP), + size: None, + flags: None, + }), + _ => Some(ParsedHeader { + end_pos, + response_type: None, + size: None, + flags: None, + }), } } diff --git a/src/impl_parse_header_tests.rs b/src/impl_parse_header_tests.rs index 6e5c778..20a4e97 100644 --- a/src/impl_parse_header_tests.rs +++ b/src/impl_parse_header_tests.rs @@ -1,30 +1,29 @@ #[cfg(test)] mod tests { use crate::constants::*; - use crate::impl_parse_header; + use crate::impl_parse_header::impl_parse_header; #[test] fn test_no_crnl_in_buffer() { let data = b"X\rX\nX"; - let no_result = impl_parse_header(data, 0, data.len()); - assert!(no_result.is_none()); + assert!(impl_parse_header(data, 0, data.len()).is_none()); } + #[test] fn test_value_response() { let data = b"VA 1234 c1234567 h0 l1111 t2222 f1 Z s3333 MORE_SPACES_ARE_OK_TOO Ofooonly UNKNOWN FLAGS Ofoobar\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_VALUE)); - assert_eq!(size, Some(1234)); - assert!(flags.is_some()); - let flags = flags.unwrap(); - assert_eq!(flags.cas_token, Some(1234567)); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_VALUE)); + assert_eq!(h.size, Some(1234)); + let flags = h.flags.unwrap(); + assert_eq!(flags.cas_token, Some(1_234_567)); assert_eq!(flags.fetched, Some(false)); assert_eq!(flags.last_access, Some(1111)); assert_eq!(flags.ttl, Some(2222)); assert_eq!(flags.client_flag, Some(1)); assert_eq!(flags.win, Some(false)); - assert_eq!(flags.stale, false); + assert!(!flags.stale); assert_eq!(flags.size, Some(3333)); assert_eq!(flags.opaque, Some(b"foobar".to_vec())); } @@ -32,30 +31,28 @@ mod tests { #[test] fn test_size_int_overflow() { let data = b"VA 12345678901234567890 c123456789001234567890 l111 t12345678901234567890\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(end_pos, data.len()); - assert!(response_type.is_none()); - assert!(size.is_none()); - assert!(flags.is_none()); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert!(h.response_type.is_none()); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); } #[test] fn test_flags_int_overflow() { let data = b"VA 1234 c123456789001234567890 l111 t12345678901234567890\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_VALUE)); - assert_eq!(size, Some(1234)); - assert!(flags.is_some()); - let flags = flags.unwrap(); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_VALUE)); + assert_eq!(h.size, Some(1234)); + let flags = h.flags.unwrap(); assert!(flags.cas_token.is_none()); assert!(flags.fetched.is_none()); assert_eq!(flags.last_access, Some(111)); assert!(flags.ttl.is_none()); assert!(flags.client_flag.is_none()); assert!(flags.win.is_none()); - assert_eq!(flags.stale, false); + assert!(!flags.stale); assert!(flags.size.is_none()); assert!(flags.opaque.is_none()); } @@ -63,51 +60,50 @@ mod tests { #[test] fn test_bad_ttls() { let data = b"VA 1234 c111 t\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_VALUE)); - assert_eq!(size, Some(1234)); - assert!(flags.is_some()); - let flags = flags.unwrap(); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_VALUE)); + assert_eq!(h.size, Some(1234)); + let flags = h.flags.unwrap(); assert_eq!(flags.cas_token, Some(111)); assert!(flags.fetched.is_none()); assert!(flags.last_access.is_none()); assert!(flags.ttl.is_none()); assert!(flags.client_flag.is_none()); assert!(flags.win.is_none()); - assert_eq!(flags.stale, false); + assert!(!flags.stale); assert!(flags.size.is_none()); assert!(flags.opaque.is_none()); + let data = b"VA 1234 t-999 c111\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_VALUE)); - assert_eq!(size, Some(1234)); - assert!(flags.is_some()); - let flags = flags.unwrap(); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_VALUE)); + assert_eq!(h.size, Some(1234)); + let flags = h.flags.unwrap(); assert_eq!(flags.cas_token, Some(111)); assert!(flags.fetched.is_none()); assert!(flags.last_access.is_none()); assert_eq!(flags.ttl, Some(-1)); assert!(flags.client_flag.is_none()); assert!(flags.win.is_none()); - assert_eq!(flags.stale, false); + assert!(!flags.stale); assert!(flags.size.is_none()); assert!(flags.opaque.is_none()); + let data = b"VA 1234 t- c111\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_VALUE)); - assert_eq!(size, Some(1234)); - assert!(flags.is_some()); - let flags = flags.unwrap(); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_VALUE)); + assert_eq!(h.size, Some(1234)); + let flags = h.flags.unwrap(); assert_eq!(flags.cas_token, Some(111)); assert!(flags.fetched.is_none()); assert!(flags.last_access.is_none()); assert_eq!(flags.ttl, Some(-1)); assert!(flags.client_flag.is_none()); assert!(flags.win.is_none()); - assert_eq!(flags.stale, false); + assert!(!flags.stale); assert!(flags.size.is_none()); assert!(flags.opaque.is_none()); } @@ -115,19 +111,18 @@ mod tests { #[test] fn test_value_response_no_flags() { let data = b"VA 1234\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_VALUE)); - assert_eq!(size, Some(1234)); - assert!(flags.is_some()); - let flags = flags.unwrap(); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_VALUE)); + assert_eq!(h.size, Some(1234)); + let flags = h.flags.unwrap(); assert!(flags.cas_token.is_none()); assert!(flags.fetched.is_none()); assert!(flags.last_access.is_none()); assert!(flags.ttl.is_none()); assert!(flags.client_flag.is_none()); assert!(flags.win.is_none()); - assert_eq!(flags.stale, false); + assert!(!flags.stale); assert!(flags.size.is_none()); assert!(flags.opaque.is_none()); } @@ -135,45 +130,42 @@ mod tests { #[test] fn test_value_response_no_size() { let data = b"VA c123\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert!(response_type.is_none()); - assert!(size.is_none()); - assert!(flags.is_none()); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert!(h.response_type.is_none()); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); } #[test] fn test_success_reponse() { let data = b"HD c1234567 h0 l1111 t-1 f1 X W s2222 Ofoobar UNKNOWN FLAGS\r\nOK\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len() - 4); - assert_eq!(response_type, Some(RESPONSE_SUCCESS)); - assert!(size.is_none()); - assert!(flags.is_some()); - let flags = flags.unwrap(); - assert_eq!(flags.cas_token, Some(1234567)); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len() - 4); + assert_eq!(h.response_type, Some(RESPONSE_SUCCESS)); + assert!(h.size.is_none()); + let flags = h.flags.unwrap(); + assert_eq!(flags.cas_token, Some(1_234_567)); assert_eq!(flags.fetched, Some(false)); assert_eq!(flags.last_access, Some(1111)); assert_eq!(flags.ttl, Some(-1)); assert_eq!(flags.client_flag, Some(1)); assert_eq!(flags.win, Some(true)); - assert_eq!(flags.stale, true); + assert!(flags.stale); assert_eq!(flags.size, Some(2222)); assert_eq!(flags.opaque, Some(b"foobar".to_vec())); - let (end_pos, response_type, size, flags) = - impl_parse_header(data, data.len() - 4, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_SUCCESS)); - assert!(size.is_none()); - assert!(flags.is_some()); - let flags = flags.unwrap(); + + let h = impl_parse_header(data, data.len() - 4, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_SUCCESS)); + let flags = h.flags.unwrap(); assert!(flags.cas_token.is_none()); assert!(flags.fetched.is_none()); assert!(flags.last_access.is_none()); assert!(flags.ttl.is_none()); assert!(flags.client_flag.is_none()); assert!(flags.win.is_none()); - assert_eq!(flags.stale, false); + assert!(!flags.stale); assert!(flags.size.is_none()); assert!(flags.opaque.is_none()); } @@ -181,66 +173,68 @@ mod tests { #[test] fn test_not_stored_response() { let data = b"NS\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_NOT_STORED)); - assert!(size.is_none()); - assert!(flags.is_none()); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_NOT_STORED)); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); } + #[test] fn test_conflict_response() { let data = b"EX\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_CONFLICT)); - assert!(size.is_none()); - assert!(flags.is_none()); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_CONFLICT)); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); } + #[test] fn test_miss_response() { let data = b"EN\r\nNF\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, 4); // Only reads the first response header - assert_eq!(response_type, Some(RESPONSE_MISS)); - assert!(size.is_none()); - assert!(flags.is_none()); - let (end_pos, response_type, size, flags) = impl_parse_header(data, 4, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_MISS)); - assert!(size.is_none()); - assert!(flags.is_none()); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, 4); + assert_eq!(h.response_type, Some(RESPONSE_MISS)); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); + + let h = impl_parse_header(data, 4, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_MISS)); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); } + #[test] fn test_noop_response() { let data = b"MN\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert_eq!(response_type, Some(RESPONSE_NOOP)); - assert!(size.is_none()); - assert!(flags.is_none()); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert_eq!(h.response_type, Some(RESPONSE_NOOP)); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); } #[test] fn test_unknown_response() { let data = b"XX 33 c1 Z f1\r\n"; - let (end_pos, response_type, size, flags) = impl_parse_header(data, 0, data.len()).unwrap(); - assert_eq!(end_pos, data.len()); - assert!(response_type.is_none()); - assert!(size.is_none()); - assert!(flags.is_none()); + let h = impl_parse_header(data, 0, data.len()).unwrap(); + assert_eq!(h.end_pos, data.len()); + assert!(h.response_type.is_none()); + assert!(h.size.is_none()); + assert!(h.flags.is_none()); } #[test] fn test_response_too_small() { let data = b"X\r\n"; - let no_result = impl_parse_header(data, 0, data.len()); - assert!(no_result.is_none()); + assert!(impl_parse_header(data, 0, data.len()).is_none()); } #[test] fn test_end_is_out_of_bounds() { let data = b"NOENDLINE"; - let no_result = impl_parse_header(data, 0, data.len() + 100); - assert!(no_result.is_none()); + assert!(impl_parse_header(data, 0, data.len() + 100).is_none()); } } diff --git a/src/lib.rs b/src/lib.rs index 1a2b628..1acd8b8 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -28,6 +28,7 @@ use pyo3::types::PyBytes; ), text_signature = "(buffer: Union[memoryview, bytearray], start: int, end: int)", )] +#[allow(clippy::type_complexity)] pub fn parse_header( buffer: PyBuffer, start: usize, @@ -38,8 +39,9 @@ pub fn parse_header( "End must be less than buffer length", )); } + // SAFETY: PyBuffer guarantees buf_ptr() is valid and len_bytes() is accurate let data = unsafe { slice::from_raw_parts(buffer.buf_ptr() as *const u8, buffer.len_bytes()) }; - Ok(impl_parse_header(data, start, end)) + Ok(impl_parse_header(data, start, end).map(|h| (h.end_pos, h.response_type, h.size, h.flags))) } #[pyfunction] @@ -147,7 +149,7 @@ pub fn build_meta_arithmetic<'py>( } } -#[pymodule] +#[pymodule(gil_used = false)] fn meta_memcache_socket(module: &Bound<'_, PyModule>) -> PyResult<()> { module.add_class::()?; module.add_class::()?; diff --git a/src/request_flags.rs b/src/request_flags.rs index 1b27e8e..8d2f6f6 100644 --- a/src/request_flags.rs +++ b/src/request_flags.rs @@ -4,7 +4,7 @@ use pyo3::types::PyBytes; use crate::{MA_MODE_INC, SET_MODE_SET}; #[pyclass(eq, skip_from_py_object)] -#[derive(Clone, PartialEq)] +#[derive(Clone, Debug, PartialEq)] pub struct RequestFlags { #[pyo3(get, set)] no_reply: bool, @@ -135,13 +135,14 @@ impl RequestFlags { buf.push(b'O'); buf.extend_from_slice(v); } - if let Some(v) = self.mode { - if v != SET_MODE_SET && v != MA_MODE_INC { - // Set/inc are the default, no need to send them - buf.push(b' '); - buf.push(b'M'); - buf.push(v); - } + if let Some(v) = self.mode + && v != SET_MODE_SET + && v != MA_MODE_INC + { + // Set/inc are the default, no need to send them + buf.push(b' '); + buf.push(b'M'); + buf.push(v); } } } @@ -149,6 +150,7 @@ impl RequestFlags { #[pymethods] impl RequestFlags { #[new] + #[allow(clippy::too_many_arguments)] #[pyo3( signature = ( /, diff --git a/src/response_flags.rs b/src/response_flags.rs index 5b6b9a8..0a8b9f8 100644 --- a/src/response_flags.rs +++ b/src/response_flags.rs @@ -14,7 +14,7 @@ fn find_space_or_end(header: &[u8], start: usize) -> usize { fn get_u32_value(header: &[u8], start: usize) -> (Option, usize) { match u32::from_radix_10_checked(&header[start..]) { (Some(v), len) if len > 0 => (Some(v), start + len), - _ => (None, find_space_or_end(&header, start)), + _ => (None, find_space_or_end(header, start)), } } @@ -22,12 +22,12 @@ fn get_u32_value(header: &[u8], start: usize) -> (Option, usize) { fn get_i32_value(header: &[u8], start: usize) -> (Option, usize) { match i32::from_radix_10_checked(&header[start..]) { (Some(v), len) if len > 0 => (Some(v), start + len), - _ => (None, find_space_or_end(&header, start)), + _ => (None, find_space_or_end(header, start)), } } -#[pyclass(frozen, eq, skip_from_py_object)] -#[derive(Clone, PartialEq)] +#[pyclass(frozen, eq, from_py_object)] +#[derive(Clone, Debug, PartialEq)] pub struct ResponseFlags { #[pyo3(get)] pub cas_token: Option, @@ -52,6 +52,7 @@ pub struct ResponseFlags { #[pymethods] impl ResponseFlags { #[new] + #[allow(clippy::too_many_arguments)] #[pyo3( signature = ( /, @@ -118,7 +119,7 @@ impl ResponseFlags { #[staticmethod] pub fn from_success_header(header: &[u8]) -> Self { - return ResponseFlags::parse_flags(header, 3); + ResponseFlags::parse_flags(header, 3) } #[staticmethod] @@ -127,7 +128,6 @@ impl ResponseFlags { if header.len() < size_start + 1 { return None; } - // let (size, pos) = u32::from_radix_10_checked(&header[size_start..]); match u32::from_radix_10_checked(&header[size_start..]) { (Some(size), pos) if pos > 0 => { let flags = ResponseFlags::parse_flags(header, size_start + pos); @@ -161,7 +161,7 @@ impl ResponseFlags { } b'c' => { // cas_token flag (u32) - (cas_token, n) = get_u32_value(&header, n); + (cas_token, n) = get_u32_value(header, n); } b'h' => { // fetched flag (bool) encoded as 1 or 0 @@ -170,24 +170,24 @@ impl ResponseFlags { b'0' => Some(false), _ => None, }; - n = find_space_or_end(&header, n + 1); + n = find_space_or_end(header, n + 1); } b'l' => { // last_access flag (u32) - (last_access, n) = get_u32_value(&header, n); + (last_access, n) = get_u32_value(header, n); } b't' => { // ttl flag (i32) encoded as -1 (for no ttl) or a positive number if n < header.len() && header[n] == b'-' { ttl = Some(-1); - n = find_space_or_end(&header, n) + n = find_space_or_end(header, n) } else { - (ttl, n) = get_i32_value(&header, n); + (ttl, n) = get_i32_value(header, n); } } b'f' => { // client_flag flag (u32) - (client_flag, n) = get_u32_value(&header, n); + (client_flag, n) = get_u32_value(header, n); } b'W' => { // win flag (bool), no value @@ -203,17 +203,17 @@ impl ResponseFlags { } b's' => { // size flag (u32) - (size, n) = get_u32_value(&header, n); + (size, n) = get_u32_value(header, n); } b'O' => { // opaque flag (bytes) let start = n; - n = find_space_or_end(&header, start); + n = find_space_or_end(header, start); opaque = Some(header[start..n].to_vec()); } _ => { // Unknown flag, skip it - n = find_space_or_end(&header, n); + n = find_space_or_end(header, n); } } // n points now to a space, so continue past it