From b82d400aae30e5936860282caf3aa06abc21f168 Mon Sep 17 00:00:00 2001 From: moznion Date: Wed, 2 Dec 2020 02:32:35 +0900 Subject: [PATCH] Refactor for AVP --- code-generator/src/main.rs | 60 +++++----- radius/src/avp.rs | 72 +++++------ radius/src/rfc2865.rs | 240 ++++++++++++++++++------------------- radius/src/rfc2866.rs | 72 +++++------ radius/src/rfc2867.rs | 12 +- radius/src/rfc2868.rs | 60 +++++----- 6 files changed, 258 insertions(+), 258 deletions(-) diff --git a/code-generator/src/main.rs b/code-generator/src/main.rs index 4969ce0..ff922d2 100644 --- a/code-generator/src/main.rs +++ b/code-generator/src/main.rs @@ -263,15 +263,15 @@ fn generate_string_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, value: &str) {{ - packet.add(AVP::encode_string({type_identifier}, value)); + packet.add(AVP::from_string({type_identifier}, value)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option> {{ - packet.lookup({type_identifier}).map(|v| v.decode_string()) + packet.lookup({type_identifier}).map(|v| v.encode_string()) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) }} Ok(vec) }} @@ -289,15 +289,15 @@ fn generate_tagged_string_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, tag: Option<&Tag>, value: &str) {{ - packet.add(AVP::encode_tagged_string({type_identifier}, tag, value)); + packet.add(AVP::from_tagged_string({type_identifier}, tag, value)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option), AVPError>> {{ - packet.lookup({type_identifier}).map(|v| v.decode_tagged_string()) + packet.lookup({type_identifier}).map(|v| v.encode_tagged_string()) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result)>, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_tagged_string()?) + vec.push(avp.encode_tagged_string()?) }} Ok(vec) }} @@ -315,16 +315,16 @@ fn generate_user_password_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {{ - packet.add(AVP::encode_user_password({type_identifier}, value, packet.get_secret(), packet.get_authenticator())?); + packet.add(AVP::from_user_password({type_identifier}, value, packet.get_secret(), packet.get_authenticator())?); Ok(()) }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option, AVPError>> {{ - packet.lookup({type_identifier}).map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator())) + packet.lookup({type_identifier}).map(|v| v.encode_user_password(packet.get_secret(), packet.get_authenticator())) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result>, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_user_password(packet.get_secret(), packet.get_authenticator())?) + vec.push(avp.encode_user_password(packet.get_secret(), packet.get_authenticator())?) }} Ok(vec) }} @@ -342,16 +342,16 @@ fn generate_tunnel_password_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, tag: Option<&Tag>, value: &[u8]) -> Result<(), AVPError> {{ - packet.add(AVP::encode_tunnel_password({type_identifier}, tag, value, packet.get_secret(), packet.get_authenticator())?); + packet.add(AVP::from_tunnel_password({type_identifier}, tag, value, packet.get_secret(), packet.get_authenticator())?); Ok(()) }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option, Tag), AVPError>> {{ - packet.lookup({type_identifier}).map(|v| v.decode_tunnel_password(packet.get_secret(), packet.get_authenticator())) + packet.lookup({type_identifier}).map(|v| v.encode_tunnel_password(packet.get_secret(), packet.get_authenticator())) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result, Tag)>, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_tunnel_password(packet.get_secret(), packet.get_authenticator())?) + vec.push(avp.encode_tunnel_password(packet.get_secret(), packet.get_authenticator())?) }} Ok(vec) }} @@ -369,15 +369,15 @@ fn generate_octets_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, value: &[u8]) {{ - packet.add(AVP::encode_bytes({type_identifier}, value)); + packet.add(AVP::from_bytes({type_identifier}, value)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option> {{ - packet.lookup({type_identifier}).map(|v| v.decode_bytes()) + packet.lookup({type_identifier}).map(|v| v.encode_bytes()) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_bytes()) + vec.push(avp.encode_bytes()) }} vec }} @@ -395,15 +395,15 @@ fn generate_ipaddr_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, value: &Ipv4Addr) {{ - packet.add(AVP::encode_ipv4({type_identifier}, value)); + packet.add(AVP::from_ipv4({type_identifier}, value)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option> {{ - packet.lookup({type_identifier}).map(|v| v.decode_ipv4()) + packet.lookup({type_identifier}).map(|v| v.encode_ipv4()) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_ipv4()?) + vec.push(avp.encode_ipv4()?) }} Ok(vec) }} @@ -421,15 +421,15 @@ fn generate_integer_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, value: u32) {{ - packet.add(AVP::encode_u32({type_identifier}, value)); + packet.add(AVP::from_u32({type_identifier}, value)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option> {{ - packet.lookup({type_identifier}).map(|v| v.decode_u32()) + packet.lookup({type_identifier}).map(|v| v.encode_u32()) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) }} Ok(vec) }} @@ -447,15 +447,15 @@ fn generate_tagged_integer_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, tag: Option<&Tag>, value: u32) {{ - packet.add(AVP::encode_tagged_u32({type_identifier}, tag, value)); + packet.add(AVP::from_tagged_u32({type_identifier}, tag, value)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option> {{ - packet.lookup({type_identifier}).map(|v| v.decode_tagged_u32()) + packet.lookup({type_identifier}).map(|v| v.encode_tagged_u32()) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_tagged_u32()?) + vec.push(avp.encode_tagged_u32()?) }} Ok(vec) }} @@ -474,15 +474,15 @@ fn generate_value_defined_integer_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, value: {value_type}) {{ - packet.add(AVP::encode_u32({type_identifier}, value as u32)); + packet.add(AVP::from_u32({type_identifier}, value as u32)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option> {{ - packet.lookup({type_identifier}).map(|v| Ok(v.decode_u32()? as {value_type})) + packet.lookup({type_identifier}).map(|v| Ok(v.encode_u32()? as {value_type})) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - vec.push(avp.decode_u32()? as {value_type}) + vec.push(avp.encode_u32()? as {value_type}) }} Ok(vec) }} @@ -502,18 +502,18 @@ fn generate_value_tagged_defined_integer_attribute_code( ) { let code = format!( "pub fn add_{method_identifier}(packet: &mut Packet, tag: Option<&Tag>, value: {value_type}) {{ - packet.add(AVP::encode_tagged_u32({type_identifier}, tag, value as u32)); + packet.add(AVP::from_tagged_u32({type_identifier}, tag, value as u32)); }} pub fn lookup_{method_identifier}(packet: &Packet) -> Option> {{ packet.lookup({type_identifier}).map(|v| {{ - let (v, t) = v.decode_tagged_u32()?; + let (v, t) = v.encode_tagged_u32()?; Ok((v as {value_type}, t)) }}) }} pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result, AVPError> {{ let mut vec = Vec::new(); for avp in packet.lookup_all({type_identifier}) {{ - let (v, t) = avp.decode_tagged_u32()?; + let (v, t) = avp.encode_tagged_u32()?; vec.push((v as {value_type}, t)) }} Ok(vec) diff --git a/radius/src/avp.rs b/radius/src/avp.rs index 3943507..004026b 100644 --- a/radius/src/avp.rs +++ b/radius/src/avp.rs @@ -41,14 +41,14 @@ pub struct AVP { } impl AVP { - pub fn encode_u32(typ: AVPType, value: u32) -> Self { + pub fn from_u32(typ: AVPType, value: u32) -> Self { AVP { typ, value: u32::to_be_bytes(value).to_vec(), } } - pub fn encode_tagged_u32(typ: AVPType, tag: Option<&Tag>, value: u32) -> Self { + pub fn from_tagged_u32(typ: AVPType, tag: Option<&Tag>, value: u32) -> Self { let tag = match tag { None => &Tag { value: UNUSED_TAG_VALUE, @@ -62,14 +62,14 @@ impl AVP { } } - pub fn encode_string(typ: AVPType, value: &str) -> Self { + pub fn from_string(typ: AVPType, value: &str) -> Self { AVP { typ, value: value.as_bytes().to_vec(), } } - pub fn encode_tagged_string(typ: AVPType, tag: Option<&Tag>, value: &str) -> Self { + pub fn from_tagged_string(typ: AVPType, tag: Option<&Tag>, value: &str) -> Self { match tag { None => AVP { typ, @@ -82,28 +82,28 @@ impl AVP { } } - pub fn encode_bytes(typ: AVPType, value: &[u8]) -> Self { + pub fn from_bytes(typ: AVPType, value: &[u8]) -> Self { AVP { typ, value: value.to_vec(), } } - pub fn encode_ipv4(typ: AVPType, value: &Ipv4Addr) -> Self { + pub fn from_ipv4(typ: AVPType, value: &Ipv4Addr) -> Self { AVP { typ, value: value.octets().to_vec(), } } - pub fn encode_ipv6(typ: AVPType, value: &Ipv6Addr) -> Self { + pub fn from_ipv6(typ: AVPType, value: &Ipv6Addr) -> Self { AVP { typ, value: value.octets().to_vec(), } } - pub fn encode_user_password( + pub fn from_user_password( typ: AVPType, plain_text: &[u8], secret: &[u8], @@ -166,14 +166,14 @@ impl AVP { Ok(AVP { typ, value: enc }) } - pub fn encode_date(typ: AVPType, dt: &DateTime) -> Self { + pub fn from_date(typ: AVPType, dt: &DateTime) -> Self { AVP { typ, value: u32::to_be_bytes(dt.timestamp() as u32).to_vec(), } } - pub fn encode_tunnel_password( + pub fn from_tunnel_password( typ: AVPType, tag: Option<&Tag>, plain_text: &[u8], @@ -262,7 +262,7 @@ impl AVP { Ok(AVP { typ, value: enc }) } - pub fn decode_u32(&self) -> Result { + pub fn encode_u32(&self) -> Result { const U32_SIZE: usize = std::mem::size_of::(); if self.value.len() != U32_SIZE { return Err(AVPError::InvalidAttributeLengthError(self.value.len())); @@ -275,7 +275,7 @@ impl AVP { } } - pub fn decode_tagged_u32(&self) -> Result<(u32, Tag), AVPError> { + pub fn encode_tagged_u32(&self) -> Result<(u32, Tag), AVPError> { if self.value.is_empty() { return Err(AVPError::InvalidAttributeLengthError(self.value.len())); } @@ -302,14 +302,14 @@ impl AVP { } } - pub fn decode_string(&self) -> Result { + pub fn encode_string(&self) -> Result { match String::from_utf8(self.value.to_vec()) { Ok(str) => Ok(str), Err(e) => Err(AVPError::UnexpectedDecodingError(e.to_string())), } } - pub fn decode_tagged_string(&self) -> Result<(String, Option), AVPError> { + pub fn encode_tagged_string(&self) -> Result<(String, Option), AVPError> { let string_vec = self.value.to_vec(); if string_vec.is_empty() { return Err(AVPError::InvalidAttributeLengthError(string_vec.len())); @@ -344,11 +344,11 @@ impl AVP { } } - pub fn decode_bytes(&self) -> Vec { + pub fn encode_bytes(&self) -> Vec { self.value.to_vec() } - pub fn decode_ipv4(&self) -> Result { + pub fn encode_ipv4(&self) -> Result { const IPV4_SIZE: usize = std::mem::size_of::(); if self.value.len() != IPV4_SIZE { return Err(AVPError::InvalidAttributeLengthError(self.value.len())); @@ -361,7 +361,7 @@ impl AVP { } } - pub fn decode_ipv6(&self) -> Result { + pub fn encode_ipv6(&self) -> Result { const IPV6_SIZE: usize = std::mem::size_of::(); if self.value.len() != IPV6_SIZE { return Err(AVPError::InvalidAttributeLengthError(self.value.len())); @@ -374,7 +374,7 @@ impl AVP { } } - pub fn decode_user_password( + pub fn encode_user_password( &self, secret: &[u8], request_authenticator: &[u8], @@ -417,7 +417,7 @@ impl AVP { } } - pub fn decode_date(&self) -> Result, AVPError> { + pub fn encode_date(&self) -> Result, AVPError> { const U32_SIZE: usize = std::mem::size_of::(); if self.value.len() != U32_SIZE { return Err(AVPError::InvalidAttributeLengthError(self.value.len())); @@ -433,7 +433,7 @@ impl AVP { } } - pub fn decode_tunnel_password( + pub fn encode_tunnel_password( &self, secret: &[u8], request_authenticator: &[u8], @@ -498,31 +498,31 @@ mod tests { #[test] fn it_should_convert_attribute_to_integer32() -> Result<(), AVPError> { let given_u32 = 16909060; - let avp = AVP::encode_u32(1, given_u32); - assert_eq!(avp.decode_u32()?, given_u32); + let avp = AVP::from_u32(1, given_u32); + assert_eq!(avp.encode_u32()?, given_u32); Ok(()) } #[test] fn it_should_convert_attribute_to_string() -> Result<(), AVPError> { let given_str = "Hello, World"; - let avp = AVP::encode_string(1, given_str); - assert_eq!(avp.decode_string()?, given_str); + let avp = AVP::from_string(1, given_str); + assert_eq!(avp.encode_string()?, given_str); Ok(()) } #[test] fn it_should_convert_attribute_to_byte() { let given_bytes = b"Hello, World"; - let avp = AVP::encode_bytes(1, given_bytes); - assert_eq!(avp.decode_bytes(), given_bytes); + let avp = AVP::from_bytes(1, given_bytes); + assert_eq!(avp.encode_bytes(), given_bytes); } #[test] fn it_should_convert_ipv4() -> Result<(), AVPError> { let given_ipv4 = Ipv4Addr::new(192, 0, 2, 1); - let avp = AVP::encode_ipv4(1, &given_ipv4); - assert_eq!(avp.decode_ipv4()?, given_ipv4); + let avp = AVP::from_ipv4(1, &given_ipv4); + assert_eq!(avp.encode_ipv4()?, given_ipv4); Ok(()) } @@ -531,8 +531,8 @@ mod tests { let given_ipv6 = Ipv6Addr::new( 0x2001, 0x0db8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001, ); - let avp = AVP::encode_ipv6(1, &given_ipv6); - assert_eq!(avp.decode_ipv6()?, given_ipv6); + let avp = AVP::from_ipv6(1, &given_ipv6); + assert_eq!(avp.encode_ipv6()?, given_ipv6); Ok(()) } @@ -574,7 +574,7 @@ mod tests { ]; for test_case in test_cases { - let user_password_avp_result = AVP::encode_user_password( + let user_password_avp_result = AVP::from_user_password( 1, test_case.plain_text.as_bytes(), &secret, @@ -584,7 +584,7 @@ mod tests { assert_eq!(avp.value.len(), test_case.expected_encoded_len); let decoded_password = avp - .decode_user_password(&secret, &request_authenticator) + .encode_user_password(&secret, &request_authenticator) .unwrap(); assert_eq!( String::from_utf8(decoded_password).unwrap(), @@ -596,8 +596,8 @@ mod tests { #[test] fn it_should_convert_date() -> Result<(), AVPError> { let now = Utc::now(); - let avp = AVP::encode_date(1, &now); - assert_eq!(avp.decode_date()?.timestamp(), now.timestamp(),); + let avp = AVP::from_date(1, &now); + assert_eq!(avp.encode_date()?.timestamp(), now.timestamp(),); Ok(()) } @@ -640,7 +640,7 @@ mod tests { ]; for test_case in test_cases { - let user_password_avp_result = AVP::encode_tunnel_password( + let user_password_avp_result = AVP::from_tunnel_password( 1, Some(&tag), test_case.plain_text.as_bytes(), @@ -651,7 +651,7 @@ mod tests { assert_eq!(avp.value.len(), test_case.expected_encoded_len); let (decoded_password, got_tag) = avp - .decode_tunnel_password(&secret, &request_authenticator) + .encode_tunnel_password(&secret, &request_authenticator) .unwrap(); assert_eq!(got_tag, tag); assert_eq!( diff --git a/radius/src/rfc2865.rs b/radius/src/rfc2865.rs index 367c3bf..de384d7 100644 --- a/radius/src/rfc2865.rs +++ b/radius/src/rfc2865.rs @@ -84,15 +84,15 @@ pub fn delete_user_name(packet: &mut Packet) { packet.delete(USER_NAME_TYPE); } pub fn add_user_name(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(USER_NAME_TYPE, value)); + packet.add(AVP::from_string(USER_NAME_TYPE, value)); } pub fn lookup_user_name(packet: &Packet) -> Option> { - packet.lookup(USER_NAME_TYPE).map(|v| v.decode_string()) + packet.lookup(USER_NAME_TYPE).map(|v| v.encode_string()) } pub fn lookup_all_user_name(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(USER_NAME_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -102,7 +102,7 @@ pub fn delete_user_password(packet: &mut Packet) { packet.delete(USER_PASSWORD_TYPE); } pub fn add_user_password(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> { - packet.add(AVP::encode_user_password( + packet.add(AVP::from_user_password( USER_PASSWORD_TYPE, value, packet.get_secret(), @@ -113,12 +113,12 @@ pub fn add_user_password(packet: &mut Packet, value: &[u8]) -> Result<(), AVPErr pub fn lookup_user_password(packet: &Packet) -> Option, AVPError>> { packet .lookup(USER_PASSWORD_TYPE) - .map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator())) + .map(|v| v.encode_user_password(packet.get_secret(), packet.get_authenticator())) } pub fn lookup_all_user_password(packet: &Packet) -> Result>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(USER_PASSWORD_TYPE) { - vec.push(avp.decode_user_password(packet.get_secret(), packet.get_authenticator())?) + vec.push(avp.encode_user_password(packet.get_secret(), packet.get_authenticator())?) } Ok(vec) } @@ -128,15 +128,15 @@ pub fn delete_chap_password(packet: &mut Packet) { packet.delete(CHAP_PASSWORD_TYPE); } pub fn add_chap_password(packet: &mut Packet, value: &[u8]) { - packet.add(AVP::encode_bytes(CHAP_PASSWORD_TYPE, value)); + packet.add(AVP::from_bytes(CHAP_PASSWORD_TYPE, value)); } pub fn lookup_chap_password(packet: &Packet) -> Option> { - packet.lookup(CHAP_PASSWORD_TYPE).map(|v| v.decode_bytes()) + packet.lookup(CHAP_PASSWORD_TYPE).map(|v| v.encode_bytes()) } pub fn lookup_all_chap_password(packet: &Packet) -> Vec> { let mut vec = Vec::new(); for avp in packet.lookup_all(CHAP_PASSWORD_TYPE) { - vec.push(avp.decode_bytes()) + vec.push(avp.encode_bytes()) } vec } @@ -146,15 +146,15 @@ pub fn delete_nas_ip_address(packet: &mut Packet) { packet.delete(NAS_IP_ADDRESS_TYPE); } pub fn add_nas_ip_address(packet: &mut Packet, value: &Ipv4Addr) { - packet.add(AVP::encode_ipv4(NAS_IP_ADDRESS_TYPE, value)); + packet.add(AVP::from_ipv4(NAS_IP_ADDRESS_TYPE, value)); } pub fn lookup_nas_ip_address(packet: &Packet) -> Option> { - packet.lookup(NAS_IP_ADDRESS_TYPE).map(|v| v.decode_ipv4()) + packet.lookup(NAS_IP_ADDRESS_TYPE).map(|v| v.encode_ipv4()) } pub fn lookup_all_nas_ip_address(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(NAS_IP_ADDRESS_TYPE) { - vec.push(avp.decode_ipv4()?) + vec.push(avp.encode_ipv4()?) } Ok(vec) } @@ -164,15 +164,15 @@ pub fn delete_nas_port(packet: &mut Packet) { packet.delete(NAS_PORT_TYPE); } pub fn add_nas_port(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(NAS_PORT_TYPE, value)); + packet.add(AVP::from_u32(NAS_PORT_TYPE, value)); } pub fn lookup_nas_port(packet: &Packet) -> Option> { - packet.lookup(NAS_PORT_TYPE).map(|v| v.decode_u32()) + packet.lookup(NAS_PORT_TYPE).map(|v| v.encode_u32()) } pub fn lookup_all_nas_port(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(NAS_PORT_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -182,17 +182,17 @@ pub fn delete_service_type(packet: &mut Packet) { packet.delete(SERVICE_TYPE_TYPE); } pub fn add_service_type(packet: &mut Packet, value: ServiceType) { - packet.add(AVP::encode_u32(SERVICE_TYPE_TYPE, value as u32)); + packet.add(AVP::from_u32(SERVICE_TYPE_TYPE, value as u32)); } pub fn lookup_service_type(packet: &Packet) -> Option> { packet .lookup(SERVICE_TYPE_TYPE) - .map(|v| Ok(v.decode_u32()? as ServiceType)) + .map(|v| Ok(v.encode_u32()? as ServiceType)) } pub fn lookup_all_service_type(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(SERVICE_TYPE_TYPE) { - vec.push(avp.decode_u32()? as ServiceType) + vec.push(avp.encode_u32()? as ServiceType) } Ok(vec) } @@ -202,17 +202,17 @@ pub fn delete_framed_protocol(packet: &mut Packet) { packet.delete(FRAMED_PROTOCOL_TYPE); } pub fn add_framed_protocol(packet: &mut Packet, value: FramedProtocol) { - packet.add(AVP::encode_u32(FRAMED_PROTOCOL_TYPE, value as u32)); + packet.add(AVP::from_u32(FRAMED_PROTOCOL_TYPE, value as u32)); } pub fn lookup_framed_protocol(packet: &Packet) -> Option> { packet .lookup(FRAMED_PROTOCOL_TYPE) - .map(|v| Ok(v.decode_u32()? as FramedProtocol)) + .map(|v| Ok(v.encode_u32()? as FramedProtocol)) } pub fn lookup_all_framed_protocol(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_PROTOCOL_TYPE) { - vec.push(avp.decode_u32()? as FramedProtocol) + vec.push(avp.encode_u32()? as FramedProtocol) } Ok(vec) } @@ -222,17 +222,17 @@ pub fn delete_framed_ip_address(packet: &mut Packet) { packet.delete(FRAMED_IP_ADDRESS_TYPE); } pub fn add_framed_ip_address(packet: &mut Packet, value: &Ipv4Addr) { - packet.add(AVP::encode_ipv4(FRAMED_IP_ADDRESS_TYPE, value)); + packet.add(AVP::from_ipv4(FRAMED_IP_ADDRESS_TYPE, value)); } pub fn lookup_framed_ip_address(packet: &Packet) -> Option> { packet .lookup(FRAMED_IP_ADDRESS_TYPE) - .map(|v| v.decode_ipv4()) + .map(|v| v.encode_ipv4()) } pub fn lookup_all_framed_ip_address(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_IP_ADDRESS_TYPE) { - vec.push(avp.decode_ipv4()?) + vec.push(avp.encode_ipv4()?) } Ok(vec) } @@ -242,17 +242,17 @@ pub fn delete_framed_ip_netmask(packet: &mut Packet) { packet.delete(FRAMED_IP_NETMASK_TYPE); } pub fn add_framed_ip_netmask(packet: &mut Packet, value: &Ipv4Addr) { - packet.add(AVP::encode_ipv4(FRAMED_IP_NETMASK_TYPE, value)); + packet.add(AVP::from_ipv4(FRAMED_IP_NETMASK_TYPE, value)); } pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option> { packet .lookup(FRAMED_IP_NETMASK_TYPE) - .map(|v| v.decode_ipv4()) + .map(|v| v.encode_ipv4()) } pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_IP_NETMASK_TYPE) { - vec.push(avp.decode_ipv4()?) + vec.push(avp.encode_ipv4()?) } Ok(vec) } @@ -262,17 +262,17 @@ pub fn delete_framed_routing(packet: &mut Packet) { packet.delete(FRAMED_ROUTING_TYPE); } pub fn add_framed_routing(packet: &mut Packet, value: FramedRouting) { - packet.add(AVP::encode_u32(FRAMED_ROUTING_TYPE, value as u32)); + packet.add(AVP::from_u32(FRAMED_ROUTING_TYPE, value as u32)); } pub fn lookup_framed_routing(packet: &Packet) -> Option> { packet .lookup(FRAMED_ROUTING_TYPE) - .map(|v| Ok(v.decode_u32()? as FramedRouting)) + .map(|v| Ok(v.encode_u32()? as FramedRouting)) } pub fn lookup_all_framed_routing(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_ROUTING_TYPE) { - vec.push(avp.decode_u32()? as FramedRouting) + vec.push(avp.encode_u32()? as FramedRouting) } Ok(vec) } @@ -282,15 +282,15 @@ pub fn delete_filter_id(packet: &mut Packet) { packet.delete(FILTER_ID_TYPE); } pub fn add_filter_id(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(FILTER_ID_TYPE, value)); + packet.add(AVP::from_string(FILTER_ID_TYPE, value)); } pub fn lookup_filter_id(packet: &Packet) -> Option> { - packet.lookup(FILTER_ID_TYPE).map(|v| v.decode_string()) + packet.lookup(FILTER_ID_TYPE).map(|v| v.encode_string()) } pub fn lookup_all_filter_id(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FILTER_ID_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -300,15 +300,15 @@ pub fn delete_framed_mtu(packet: &mut Packet) { packet.delete(FRAMED_MTU_TYPE); } pub fn add_framed_mtu(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(FRAMED_MTU_TYPE, value)); + packet.add(AVP::from_u32(FRAMED_MTU_TYPE, value)); } pub fn lookup_framed_mtu(packet: &Packet) -> Option> { - packet.lookup(FRAMED_MTU_TYPE).map(|v| v.decode_u32()) + packet.lookup(FRAMED_MTU_TYPE).map(|v| v.encode_u32()) } pub fn lookup_all_framed_mtu(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_MTU_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -318,17 +318,17 @@ pub fn delete_framed_compression(packet: &mut Packet) { packet.delete(FRAMED_COMPRESSION_TYPE); } pub fn add_framed_compression(packet: &mut Packet, value: FramedCompression) { - packet.add(AVP::encode_u32(FRAMED_COMPRESSION_TYPE, value as u32)); + packet.add(AVP::from_u32(FRAMED_COMPRESSION_TYPE, value as u32)); } pub fn lookup_framed_compression(packet: &Packet) -> Option> { packet .lookup(FRAMED_COMPRESSION_TYPE) - .map(|v| Ok(v.decode_u32()? as FramedCompression)) + .map(|v| Ok(v.encode_u32()? as FramedCompression)) } pub fn lookup_all_framed_compression(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_COMPRESSION_TYPE) { - vec.push(avp.decode_u32()? as FramedCompression) + vec.push(avp.encode_u32()? as FramedCompression) } Ok(vec) } @@ -338,15 +338,15 @@ pub fn delete_login_ip_host(packet: &mut Packet) { packet.delete(LOGIN_IP_HOST_TYPE); } pub fn add_login_ip_host(packet: &mut Packet, value: &Ipv4Addr) { - packet.add(AVP::encode_ipv4(LOGIN_IP_HOST_TYPE, value)); + packet.add(AVP::from_ipv4(LOGIN_IP_HOST_TYPE, value)); } pub fn lookup_login_ip_host(packet: &Packet) -> Option> { - packet.lookup(LOGIN_IP_HOST_TYPE).map(|v| v.decode_ipv4()) + packet.lookup(LOGIN_IP_HOST_TYPE).map(|v| v.encode_ipv4()) } pub fn lookup_all_login_ip_host(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(LOGIN_IP_HOST_TYPE) { - vec.push(avp.decode_ipv4()?) + vec.push(avp.encode_ipv4()?) } Ok(vec) } @@ -356,17 +356,17 @@ pub fn delete_login_service(packet: &mut Packet) { packet.delete(LOGIN_SERVICE_TYPE); } pub fn add_login_service(packet: &mut Packet, value: LoginService) { - packet.add(AVP::encode_u32(LOGIN_SERVICE_TYPE, value as u32)); + packet.add(AVP::from_u32(LOGIN_SERVICE_TYPE, value as u32)); } pub fn lookup_login_service(packet: &Packet) -> Option> { packet .lookup(LOGIN_SERVICE_TYPE) - .map(|v| Ok(v.decode_u32()? as LoginService)) + .map(|v| Ok(v.encode_u32()? as LoginService)) } pub fn lookup_all_login_service(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(LOGIN_SERVICE_TYPE) { - vec.push(avp.decode_u32()? as LoginService) + vec.push(avp.encode_u32()? as LoginService) } Ok(vec) } @@ -376,17 +376,17 @@ pub fn delete_login_tcp_port(packet: &mut Packet) { packet.delete(LOGIN_TCP_PORT_TYPE); } pub fn add_login_tcp_port(packet: &mut Packet, value: LoginTCPPort) { - packet.add(AVP::encode_u32(LOGIN_TCP_PORT_TYPE, value as u32)); + packet.add(AVP::from_u32(LOGIN_TCP_PORT_TYPE, value as u32)); } pub fn lookup_login_tcp_port(packet: &Packet) -> Option> { packet .lookup(LOGIN_TCP_PORT_TYPE) - .map(|v| Ok(v.decode_u32()? as LoginTCPPort)) + .map(|v| Ok(v.encode_u32()? as LoginTCPPort)) } pub fn lookup_all_login_tcp_port(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(LOGIN_TCP_PORT_TYPE) { - vec.push(avp.decode_u32()? as LoginTCPPort) + vec.push(avp.encode_u32()? as LoginTCPPort) } Ok(vec) } @@ -396,15 +396,15 @@ pub fn delete_reply_message(packet: &mut Packet) { packet.delete(REPLY_MESSAGE_TYPE); } pub fn add_reply_message(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(REPLY_MESSAGE_TYPE, value)); + packet.add(AVP::from_string(REPLY_MESSAGE_TYPE, value)); } pub fn lookup_reply_message(packet: &Packet) -> Option> { - packet.lookup(REPLY_MESSAGE_TYPE).map(|v| v.decode_string()) + packet.lookup(REPLY_MESSAGE_TYPE).map(|v| v.encode_string()) } pub fn lookup_all_reply_message(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(REPLY_MESSAGE_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -414,17 +414,17 @@ pub fn delete_callback_number(packet: &mut Packet) { packet.delete(CALLBACK_NUMBER_TYPE); } pub fn add_callback_number(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(CALLBACK_NUMBER_TYPE, value)); + packet.add(AVP::from_string(CALLBACK_NUMBER_TYPE, value)); } pub fn lookup_callback_number(packet: &Packet) -> Option> { packet .lookup(CALLBACK_NUMBER_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_callback_number(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(CALLBACK_NUMBER_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -434,15 +434,15 @@ pub fn delete_callback_id(packet: &mut Packet) { packet.delete(CALLBACK_ID_TYPE); } pub fn add_callback_id(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(CALLBACK_ID_TYPE, value)); + packet.add(AVP::from_string(CALLBACK_ID_TYPE, value)); } pub fn lookup_callback_id(packet: &Packet) -> Option> { - packet.lookup(CALLBACK_ID_TYPE).map(|v| v.decode_string()) + packet.lookup(CALLBACK_ID_TYPE).map(|v| v.encode_string()) } pub fn lookup_all_callback_id(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(CALLBACK_ID_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -452,15 +452,15 @@ pub fn delete_framed_route(packet: &mut Packet) { packet.delete(FRAMED_ROUTE_TYPE); } pub fn add_framed_route(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(FRAMED_ROUTE_TYPE, value)); + packet.add(AVP::from_string(FRAMED_ROUTE_TYPE, value)); } pub fn lookup_framed_route(packet: &Packet) -> Option> { - packet.lookup(FRAMED_ROUTE_TYPE).map(|v| v.decode_string()) + packet.lookup(FRAMED_ROUTE_TYPE).map(|v| v.encode_string()) } pub fn lookup_all_framed_route(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_ROUTE_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -470,17 +470,17 @@ pub fn delete_framed_ipx_network(packet: &mut Packet) { packet.delete(FRAMED_IPX_NETWORK_TYPE); } pub fn add_framed_ipx_network(packet: &mut Packet, value: &Ipv4Addr) { - packet.add(AVP::encode_ipv4(FRAMED_IPX_NETWORK_TYPE, value)); + packet.add(AVP::from_ipv4(FRAMED_IPX_NETWORK_TYPE, value)); } pub fn lookup_framed_ipx_network(packet: &Packet) -> Option> { packet .lookup(FRAMED_IPX_NETWORK_TYPE) - .map(|v| v.decode_ipv4()) + .map(|v| v.encode_ipv4()) } pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_IPX_NETWORK_TYPE) { - vec.push(avp.decode_ipv4()?) + vec.push(avp.encode_ipv4()?) } Ok(vec) } @@ -490,15 +490,15 @@ pub fn delete_state(packet: &mut Packet) { packet.delete(STATE_TYPE); } pub fn add_state(packet: &mut Packet, value: &[u8]) { - packet.add(AVP::encode_bytes(STATE_TYPE, value)); + packet.add(AVP::from_bytes(STATE_TYPE, value)); } pub fn lookup_state(packet: &Packet) -> Option> { - packet.lookup(STATE_TYPE).map(|v| v.decode_bytes()) + packet.lookup(STATE_TYPE).map(|v| v.encode_bytes()) } pub fn lookup_all_state(packet: &Packet) -> Vec> { let mut vec = Vec::new(); for avp in packet.lookup_all(STATE_TYPE) { - vec.push(avp.decode_bytes()) + vec.push(avp.encode_bytes()) } vec } @@ -508,15 +508,15 @@ pub fn delete_class(packet: &mut Packet) { packet.delete(CLASS_TYPE); } pub fn add_class(packet: &mut Packet, value: &[u8]) { - packet.add(AVP::encode_bytes(CLASS_TYPE, value)); + packet.add(AVP::from_bytes(CLASS_TYPE, value)); } pub fn lookup_class(packet: &Packet) -> Option> { - packet.lookup(CLASS_TYPE).map(|v| v.decode_bytes()) + packet.lookup(CLASS_TYPE).map(|v| v.encode_bytes()) } pub fn lookup_all_class(packet: &Packet) -> Vec> { let mut vec = Vec::new(); for avp in packet.lookup_all(CLASS_TYPE) { - vec.push(avp.decode_bytes()) + vec.push(avp.encode_bytes()) } vec } @@ -531,15 +531,15 @@ pub fn delete_session_timeout(packet: &mut Packet) { packet.delete(SESSION_TIMEOUT_TYPE); } pub fn add_session_timeout(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(SESSION_TIMEOUT_TYPE, value)); + packet.add(AVP::from_u32(SESSION_TIMEOUT_TYPE, value)); } pub fn lookup_session_timeout(packet: &Packet) -> Option> { - packet.lookup(SESSION_TIMEOUT_TYPE).map(|v| v.decode_u32()) + packet.lookup(SESSION_TIMEOUT_TYPE).map(|v| v.encode_u32()) } pub fn lookup_all_session_timeout(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(SESSION_TIMEOUT_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -549,15 +549,15 @@ pub fn delete_idle_timeout(packet: &mut Packet) { packet.delete(IDLE_TIMEOUT_TYPE); } pub fn add_idle_timeout(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(IDLE_TIMEOUT_TYPE, value)); + packet.add(AVP::from_u32(IDLE_TIMEOUT_TYPE, value)); } pub fn lookup_idle_timeout(packet: &Packet) -> Option> { - packet.lookup(IDLE_TIMEOUT_TYPE).map(|v| v.decode_u32()) + packet.lookup(IDLE_TIMEOUT_TYPE).map(|v| v.encode_u32()) } pub fn lookup_all_idle_timeout(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(IDLE_TIMEOUT_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -567,17 +567,17 @@ pub fn delete_termination_action(packet: &mut Packet) { packet.delete(TERMINATION_ACTION_TYPE); } pub fn add_termination_action(packet: &mut Packet, value: TerminationAction) { - packet.add(AVP::encode_u32(TERMINATION_ACTION_TYPE, value as u32)); + packet.add(AVP::from_u32(TERMINATION_ACTION_TYPE, value as u32)); } pub fn lookup_termination_action(packet: &Packet) -> Option> { packet .lookup(TERMINATION_ACTION_TYPE) - .map(|v| Ok(v.decode_u32()? as TerminationAction)) + .map(|v| Ok(v.encode_u32()? as TerminationAction)) } pub fn lookup_all_termination_action(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TERMINATION_ACTION_TYPE) { - vec.push(avp.decode_u32()? as TerminationAction) + vec.push(avp.encode_u32()? as TerminationAction) } Ok(vec) } @@ -587,17 +587,17 @@ pub fn delete_called_station_id(packet: &mut Packet) { packet.delete(CALLED_STATION_ID_TYPE); } pub fn add_called_station_id(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(CALLED_STATION_ID_TYPE, value)); + packet.add(AVP::from_string(CALLED_STATION_ID_TYPE, value)); } pub fn lookup_called_station_id(packet: &Packet) -> Option> { packet .lookup(CALLED_STATION_ID_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_called_station_id(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(CALLED_STATION_ID_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -607,17 +607,17 @@ pub fn delete_calling_station_id(packet: &mut Packet) { packet.delete(CALLING_STATION_ID_TYPE); } pub fn add_calling_station_id(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(CALLING_STATION_ID_TYPE, value)); + packet.add(AVP::from_string(CALLING_STATION_ID_TYPE, value)); } pub fn lookup_calling_station_id(packet: &Packet) -> Option> { packet .lookup(CALLING_STATION_ID_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_calling_station_id(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(CALLING_STATION_ID_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -627,17 +627,17 @@ pub fn delete_nas_identifier(packet: &mut Packet) { packet.delete(NAS_IDENTIFIER_TYPE); } pub fn add_nas_identifier(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(NAS_IDENTIFIER_TYPE, value)); + packet.add(AVP::from_string(NAS_IDENTIFIER_TYPE, value)); } pub fn lookup_nas_identifier(packet: &Packet) -> Option> { packet .lookup(NAS_IDENTIFIER_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_nas_identifier(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(NAS_IDENTIFIER_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -647,15 +647,15 @@ pub fn delete_proxy_state(packet: &mut Packet) { packet.delete(PROXY_STATE_TYPE); } pub fn add_proxy_state(packet: &mut Packet, value: &[u8]) { - packet.add(AVP::encode_bytes(PROXY_STATE_TYPE, value)); + packet.add(AVP::from_bytes(PROXY_STATE_TYPE, value)); } pub fn lookup_proxy_state(packet: &Packet) -> Option> { - packet.lookup(PROXY_STATE_TYPE).map(|v| v.decode_bytes()) + packet.lookup(PROXY_STATE_TYPE).map(|v| v.encode_bytes()) } pub fn lookup_all_proxy_state(packet: &Packet) -> Vec> { let mut vec = Vec::new(); for avp in packet.lookup_all(PROXY_STATE_TYPE) { - vec.push(avp.decode_bytes()) + vec.push(avp.encode_bytes()) } vec } @@ -665,17 +665,17 @@ pub fn delete_login_lat_service(packet: &mut Packet) { packet.delete(LOGIN_LAT_SERVICE_TYPE); } pub fn add_login_lat_service(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(LOGIN_LAT_SERVICE_TYPE, value)); + packet.add(AVP::from_string(LOGIN_LAT_SERVICE_TYPE, value)); } pub fn lookup_login_lat_service(packet: &Packet) -> Option> { packet .lookup(LOGIN_LAT_SERVICE_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_login_lat_service(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(LOGIN_LAT_SERVICE_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -685,17 +685,17 @@ pub fn delete_login_lat_node(packet: &mut Packet) { packet.delete(LOGIN_LAT_NODE_TYPE); } pub fn add_login_lat_node(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(LOGIN_LAT_NODE_TYPE, value)); + packet.add(AVP::from_string(LOGIN_LAT_NODE_TYPE, value)); } pub fn lookup_login_lat_node(packet: &Packet) -> Option> { packet .lookup(LOGIN_LAT_NODE_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_login_lat_node(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(LOGIN_LAT_NODE_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -705,17 +705,17 @@ pub fn delete_login_lat_group(packet: &mut Packet) { packet.delete(LOGIN_LAT_GROUP_TYPE); } pub fn add_login_lat_group(packet: &mut Packet, value: &[u8]) { - packet.add(AVP::encode_bytes(LOGIN_LAT_GROUP_TYPE, value)); + packet.add(AVP::from_bytes(LOGIN_LAT_GROUP_TYPE, value)); } pub fn lookup_login_lat_group(packet: &Packet) -> Option> { packet .lookup(LOGIN_LAT_GROUP_TYPE) - .map(|v| v.decode_bytes()) + .map(|v| v.encode_bytes()) } pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec> { let mut vec = Vec::new(); for avp in packet.lookup_all(LOGIN_LAT_GROUP_TYPE) { - vec.push(avp.decode_bytes()) + vec.push(avp.encode_bytes()) } vec } @@ -725,17 +725,17 @@ pub fn delete_framed_apple_talk_link(packet: &mut Packet) { packet.delete(FRAMED_APPLE_TALK_LINK_TYPE); } pub fn add_framed_apple_talk_link(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(FRAMED_APPLE_TALK_LINK_TYPE, value)); + packet.add(AVP::from_u32(FRAMED_APPLE_TALK_LINK_TYPE, value)); } pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option> { packet .lookup(FRAMED_APPLE_TALK_LINK_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_APPLE_TALK_LINK_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -745,17 +745,17 @@ pub fn delete_framed_apple_talk_network(packet: &mut Packet) { packet.delete(FRAMED_APPLE_TALK_NETWORK_TYPE); } pub fn add_framed_apple_talk_network(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(FRAMED_APPLE_TALK_NETWORK_TYPE, value)); + packet.add(AVP::from_u32(FRAMED_APPLE_TALK_NETWORK_TYPE, value)); } pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option> { packet .lookup(FRAMED_APPLE_TALK_NETWORK_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_APPLE_TALK_NETWORK_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -765,17 +765,17 @@ pub fn delete_framed_apple_talk_zone(packet: &mut Packet) { packet.delete(FRAMED_APPLE_TALK_ZONE_TYPE); } pub fn add_framed_apple_talk_zone(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(FRAMED_APPLE_TALK_ZONE_TYPE, value)); + packet.add(AVP::from_string(FRAMED_APPLE_TALK_ZONE_TYPE, value)); } pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option> { packet .lookup(FRAMED_APPLE_TALK_ZONE_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(FRAMED_APPLE_TALK_ZONE_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -785,15 +785,15 @@ pub fn delete_chap_challenge(packet: &mut Packet) { packet.delete(CHAP_CHALLENGE_TYPE); } pub fn add_chap_challenge(packet: &mut Packet, value: &[u8]) { - packet.add(AVP::encode_bytes(CHAP_CHALLENGE_TYPE, value)); + packet.add(AVP::from_bytes(CHAP_CHALLENGE_TYPE, value)); } pub fn lookup_chap_challenge(packet: &Packet) -> Option> { - packet.lookup(CHAP_CHALLENGE_TYPE).map(|v| v.decode_bytes()) + packet.lookup(CHAP_CHALLENGE_TYPE).map(|v| v.encode_bytes()) } pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec> { let mut vec = Vec::new(); for avp in packet.lookup_all(CHAP_CHALLENGE_TYPE) { - vec.push(avp.decode_bytes()) + vec.push(avp.encode_bytes()) } vec } @@ -803,17 +803,17 @@ pub fn delete_nas_port_type(packet: &mut Packet) { packet.delete(NAS_PORT_TYPE_TYPE); } pub fn add_nas_port_type(packet: &mut Packet, value: NasPortType) { - packet.add(AVP::encode_u32(NAS_PORT_TYPE_TYPE, value as u32)); + packet.add(AVP::from_u32(NAS_PORT_TYPE_TYPE, value as u32)); } pub fn lookup_nas_port_type(packet: &Packet) -> Option> { packet .lookup(NAS_PORT_TYPE_TYPE) - .map(|v| Ok(v.decode_u32()? as NasPortType)) + .map(|v| Ok(v.encode_u32()? as NasPortType)) } pub fn lookup_all_nas_port_type(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(NAS_PORT_TYPE_TYPE) { - vec.push(avp.decode_u32()? as NasPortType) + vec.push(avp.encode_u32()? as NasPortType) } Ok(vec) } @@ -823,15 +823,15 @@ pub fn delete_port_limit(packet: &mut Packet) { packet.delete(PORT_LIMIT_TYPE); } pub fn add_port_limit(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(PORT_LIMIT_TYPE, value)); + packet.add(AVP::from_u32(PORT_LIMIT_TYPE, value)); } pub fn lookup_port_limit(packet: &Packet) -> Option> { - packet.lookup(PORT_LIMIT_TYPE).map(|v| v.decode_u32()) + packet.lookup(PORT_LIMIT_TYPE).map(|v| v.encode_u32()) } pub fn lookup_all_port_limit(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(PORT_LIMIT_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -841,17 +841,17 @@ pub fn delete_login_lat_port(packet: &mut Packet) { packet.delete(LOGIN_LAT_PORT_TYPE); } pub fn add_login_lat_port(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(LOGIN_LAT_PORT_TYPE, value)); + packet.add(AVP::from_string(LOGIN_LAT_PORT_TYPE, value)); } pub fn lookup_login_lat_port(packet: &Packet) -> Option> { packet .lookup(LOGIN_LAT_PORT_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_login_lat_port(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(LOGIN_LAT_PORT_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } diff --git a/radius/src/rfc2866.rs b/radius/src/rfc2866.rs index d9557dd..7b35bdc 100644 --- a/radius/src/rfc2866.rs +++ b/radius/src/rfc2866.rs @@ -43,17 +43,17 @@ pub fn delete_acct_status_type(packet: &mut Packet) { packet.delete(ACCT_STATUS_TYPE_TYPE); } pub fn add_acct_status_type(packet: &mut Packet, value: AcctStatusType) { - packet.add(AVP::encode_u32(ACCT_STATUS_TYPE_TYPE, value as u32)); + packet.add(AVP::from_u32(ACCT_STATUS_TYPE_TYPE, value as u32)); } pub fn lookup_acct_status_type(packet: &Packet) -> Option> { packet .lookup(ACCT_STATUS_TYPE_TYPE) - .map(|v| Ok(v.decode_u32()? as AcctStatusType)) + .map(|v| Ok(v.encode_u32()? as AcctStatusType)) } pub fn lookup_all_acct_status_type(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_STATUS_TYPE_TYPE) { - vec.push(avp.decode_u32()? as AcctStatusType) + vec.push(avp.encode_u32()? as AcctStatusType) } Ok(vec) } @@ -63,15 +63,15 @@ pub fn delete_acct_delay_time(packet: &mut Packet) { packet.delete(ACCT_DELAY_TIME_TYPE); } pub fn add_acct_delay_time(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_DELAY_TIME_TYPE, value)); + packet.add(AVP::from_u32(ACCT_DELAY_TIME_TYPE, value)); } pub fn lookup_acct_delay_time(packet: &Packet) -> Option> { - packet.lookup(ACCT_DELAY_TIME_TYPE).map(|v| v.decode_u32()) + packet.lookup(ACCT_DELAY_TIME_TYPE).map(|v| v.encode_u32()) } pub fn lookup_all_acct_delay_time(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_DELAY_TIME_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -81,17 +81,17 @@ pub fn delete_acct_input_octets(packet: &mut Packet) { packet.delete(ACCT_INPUT_OCTETS_TYPE); } pub fn add_acct_input_octets(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_INPUT_OCTETS_TYPE, value)); + packet.add(AVP::from_u32(ACCT_INPUT_OCTETS_TYPE, value)); } pub fn lookup_acct_input_octets(packet: &Packet) -> Option> { packet .lookup(ACCT_INPUT_OCTETS_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_acct_input_octets(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_INPUT_OCTETS_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -101,17 +101,17 @@ pub fn delete_acct_output_octets(packet: &mut Packet) { packet.delete(ACCT_OUTPUT_OCTETS_TYPE); } pub fn add_acct_output_octets(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_OUTPUT_OCTETS_TYPE, value)); + packet.add(AVP::from_u32(ACCT_OUTPUT_OCTETS_TYPE, value)); } pub fn lookup_acct_output_octets(packet: &Packet) -> Option> { packet .lookup(ACCT_OUTPUT_OCTETS_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_acct_output_octets(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_OUTPUT_OCTETS_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -121,17 +121,17 @@ pub fn delete_acct_session_id(packet: &mut Packet) { packet.delete(ACCT_SESSION_ID_TYPE); } pub fn add_acct_session_id(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(ACCT_SESSION_ID_TYPE, value)); + packet.add(AVP::from_string(ACCT_SESSION_ID_TYPE, value)); } pub fn lookup_acct_session_id(packet: &Packet) -> Option> { packet .lookup(ACCT_SESSION_ID_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_acct_session_id(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_SESSION_ID_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -141,17 +141,17 @@ pub fn delete_acct_authentic(packet: &mut Packet) { packet.delete(ACCT_AUTHENTIC_TYPE); } pub fn add_acct_authentic(packet: &mut Packet, value: AcctAuthentic) { - packet.add(AVP::encode_u32(ACCT_AUTHENTIC_TYPE, value as u32)); + packet.add(AVP::from_u32(ACCT_AUTHENTIC_TYPE, value as u32)); } pub fn lookup_acct_authentic(packet: &Packet) -> Option> { packet .lookup(ACCT_AUTHENTIC_TYPE) - .map(|v| Ok(v.decode_u32()? as AcctAuthentic)) + .map(|v| Ok(v.encode_u32()? as AcctAuthentic)) } pub fn lookup_all_acct_authentic(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_AUTHENTIC_TYPE) { - vec.push(avp.decode_u32()? as AcctAuthentic) + vec.push(avp.encode_u32()? as AcctAuthentic) } Ok(vec) } @@ -161,17 +161,17 @@ pub fn delete_acct_session_time(packet: &mut Packet) { packet.delete(ACCT_SESSION_TIME_TYPE); } pub fn add_acct_session_time(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_SESSION_TIME_TYPE, value)); + packet.add(AVP::from_u32(ACCT_SESSION_TIME_TYPE, value)); } pub fn lookup_acct_session_time(packet: &Packet) -> Option> { packet .lookup(ACCT_SESSION_TIME_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_acct_session_time(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_SESSION_TIME_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -181,17 +181,17 @@ pub fn delete_acct_input_packets(packet: &mut Packet) { packet.delete(ACCT_INPUT_PACKETS_TYPE); } pub fn add_acct_input_packets(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_INPUT_PACKETS_TYPE, value)); + packet.add(AVP::from_u32(ACCT_INPUT_PACKETS_TYPE, value)); } pub fn lookup_acct_input_packets(packet: &Packet) -> Option> { packet .lookup(ACCT_INPUT_PACKETS_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_acct_input_packets(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_INPUT_PACKETS_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -201,17 +201,17 @@ pub fn delete_acct_output_packets(packet: &mut Packet) { packet.delete(ACCT_OUTPUT_PACKETS_TYPE); } pub fn add_acct_output_packets(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_OUTPUT_PACKETS_TYPE, value)); + packet.add(AVP::from_u32(ACCT_OUTPUT_PACKETS_TYPE, value)); } pub fn lookup_acct_output_packets(packet: &Packet) -> Option> { packet .lookup(ACCT_OUTPUT_PACKETS_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_acct_output_packets(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_OUTPUT_PACKETS_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } @@ -221,21 +221,21 @@ pub fn delete_acct_terminate_cause(packet: &mut Packet) { packet.delete(ACCT_TERMINATE_CAUSE_TYPE); } pub fn add_acct_terminate_cause(packet: &mut Packet, value: AcctTerminateCause) { - packet.add(AVP::encode_u32(ACCT_TERMINATE_CAUSE_TYPE, value as u32)); + packet.add(AVP::from_u32(ACCT_TERMINATE_CAUSE_TYPE, value as u32)); } pub fn lookup_acct_terminate_cause( packet: &Packet, ) -> Option> { packet .lookup(ACCT_TERMINATE_CAUSE_TYPE) - .map(|v| Ok(v.decode_u32()? as AcctTerminateCause)) + .map(|v| Ok(v.encode_u32()? as AcctTerminateCause)) } pub fn lookup_all_acct_terminate_cause( packet: &Packet, ) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_TERMINATE_CAUSE_TYPE) { - vec.push(avp.decode_u32()? as AcctTerminateCause) + vec.push(avp.encode_u32()? as AcctTerminateCause) } Ok(vec) } @@ -245,17 +245,17 @@ pub fn delete_acct_multi_session_id(packet: &mut Packet) { packet.delete(ACCT_MULTI_SESSION_ID_TYPE); } pub fn add_acct_multi_session_id(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(ACCT_MULTI_SESSION_ID_TYPE, value)); + packet.add(AVP::from_string(ACCT_MULTI_SESSION_ID_TYPE, value)); } pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option> { packet .lookup(ACCT_MULTI_SESSION_ID_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_MULTI_SESSION_ID_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -265,15 +265,15 @@ pub fn delete_acct_link_count(packet: &mut Packet) { packet.delete(ACCT_LINK_COUNT_TYPE); } pub fn add_acct_link_count(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_LINK_COUNT_TYPE, value)); + packet.add(AVP::from_u32(ACCT_LINK_COUNT_TYPE, value)); } pub fn lookup_acct_link_count(packet: &Packet) -> Option> { - packet.lookup(ACCT_LINK_COUNT_TYPE).map(|v| v.decode_u32()) + packet.lookup(ACCT_LINK_COUNT_TYPE).map(|v| v.encode_u32()) } pub fn lookup_all_acct_link_count(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_LINK_COUNT_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } diff --git a/radius/src/rfc2867.rs b/radius/src/rfc2867.rs index 402be09..be6669c 100644 --- a/radius/src/rfc2867.rs +++ b/radius/src/rfc2867.rs @@ -16,17 +16,17 @@ pub fn delete_acct_tunnel_connection(packet: &mut Packet) { packet.delete(ACCT_TUNNEL_CONNECTION_TYPE); } pub fn add_acct_tunnel_connection(packet: &mut Packet, value: &str) { - packet.add(AVP::encode_string(ACCT_TUNNEL_CONNECTION_TYPE, value)); + packet.add(AVP::from_string(ACCT_TUNNEL_CONNECTION_TYPE, value)); } pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option> { packet .lookup(ACCT_TUNNEL_CONNECTION_TYPE) - .map(|v| v.decode_string()) + .map(|v| v.encode_string()) } pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_TUNNEL_CONNECTION_TYPE) { - vec.push(avp.decode_string()?) + vec.push(avp.encode_string()?) } Ok(vec) } @@ -36,17 +36,17 @@ pub fn delete_acct_tunnel_packets_lost(packet: &mut Packet) { packet.delete(ACCT_TUNNEL_PACKETS_LOST_TYPE); } pub fn add_acct_tunnel_packets_lost(packet: &mut Packet, value: u32) { - packet.add(AVP::encode_u32(ACCT_TUNNEL_PACKETS_LOST_TYPE, value)); + packet.add(AVP::from_u32(ACCT_TUNNEL_PACKETS_LOST_TYPE, value)); } pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option> { packet .lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE) - .map(|v| v.decode_u32()) + .map(|v| v.encode_u32()) } pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(ACCT_TUNNEL_PACKETS_LOST_TYPE) { - vec.push(avp.decode_u32()?) + vec.push(avp.encode_u32()?) } Ok(vec) } diff --git a/radius/src/rfc2868.rs b/radius/src/rfc2868.rs index 105217b..ef51643 100644 --- a/radius/src/rfc2868.rs +++ b/radius/src/rfc2868.rs @@ -41,18 +41,18 @@ pub fn delete_tunnel_type(packet: &mut Packet) { packet.delete(TUNNEL_TYPE_TYPE); } pub fn add_tunnel_type(packet: &mut Packet, tag: Option<&Tag>, value: TunnelType) { - packet.add(AVP::encode_tagged_u32(TUNNEL_TYPE_TYPE, tag, value as u32)); + packet.add(AVP::from_tagged_u32(TUNNEL_TYPE_TYPE, tag, value as u32)); } pub fn lookup_tunnel_type(packet: &Packet) -> Option> { packet.lookup(TUNNEL_TYPE_TYPE).map(|v| { - let (v, t) = v.decode_tagged_u32()?; + let (v, t) = v.encode_tagged_u32()?; Ok((v as TunnelType, t)) }) } pub fn lookup_all_tunnel_type(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_TYPE_TYPE) { - let (v, t) = avp.decode_tagged_u32()?; + let (v, t) = avp.encode_tagged_u32()?; vec.push((v as TunnelType, t)) } Ok(vec) @@ -63,7 +63,7 @@ pub fn delete_tunnel_medium_type(packet: &mut Packet) { packet.delete(TUNNEL_MEDIUM_TYPE_TYPE); } pub fn add_tunnel_medium_type(packet: &mut Packet, tag: Option<&Tag>, value: TunnelMediumType) { - packet.add(AVP::encode_tagged_u32( + packet.add(AVP::from_tagged_u32( TUNNEL_MEDIUM_TYPE_TYPE, tag, value as u32, @@ -73,7 +73,7 @@ pub fn lookup_tunnel_medium_type( packet: &Packet, ) -> Option> { packet.lookup(TUNNEL_MEDIUM_TYPE_TYPE).map(|v| { - let (v, t) = v.decode_tagged_u32()?; + let (v, t) = v.encode_tagged_u32()?; Ok((v as TunnelMediumType, t)) }) } @@ -82,7 +82,7 @@ pub fn lookup_all_tunnel_medium_type( ) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_MEDIUM_TYPE_TYPE) { - let (v, t) = avp.decode_tagged_u32()?; + let (v, t) = avp.encode_tagged_u32()?; vec.push((v as TunnelMediumType, t)) } Ok(vec) @@ -93,7 +93,7 @@ pub fn delete_tunnel_client_endpoint(packet: &mut Packet) { packet.delete(TUNNEL_CLIENT_ENDPOINT_TYPE); } pub fn add_tunnel_client_endpoint(packet: &mut Packet, tag: Option<&Tag>, value: &str) { - packet.add(AVP::encode_tagged_string( + packet.add(AVP::from_tagged_string( TUNNEL_CLIENT_ENDPOINT_TYPE, tag, value, @@ -104,14 +104,14 @@ pub fn lookup_tunnel_client_endpoint( ) -> Option), AVPError>> { packet .lookup(TUNNEL_CLIENT_ENDPOINT_TYPE) - .map(|v| v.decode_tagged_string()) + .map(|v| v.encode_tagged_string()) } pub fn lookup_all_tunnel_client_endpoint( packet: &Packet, ) -> Result)>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_CLIENT_ENDPOINT_TYPE) { - vec.push(avp.decode_tagged_string()?) + vec.push(avp.encode_tagged_string()?) } Ok(vec) } @@ -121,7 +121,7 @@ pub fn delete_tunnel_server_endpoint(packet: &mut Packet) { packet.delete(TUNNEL_SERVER_ENDPOINT_TYPE); } pub fn add_tunnel_server_endpoint(packet: &mut Packet, tag: Option<&Tag>, value: &str) { - packet.add(AVP::encode_tagged_string( + packet.add(AVP::from_tagged_string( TUNNEL_SERVER_ENDPOINT_TYPE, tag, value, @@ -132,14 +132,14 @@ pub fn lookup_tunnel_server_endpoint( ) -> Option), AVPError>> { packet .lookup(TUNNEL_SERVER_ENDPOINT_TYPE) - .map(|v| v.decode_tagged_string()) + .map(|v| v.encode_tagged_string()) } pub fn lookup_all_tunnel_server_endpoint( packet: &Packet, ) -> Result)>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_SERVER_ENDPOINT_TYPE) { - vec.push(avp.decode_tagged_string()?) + vec.push(avp.encode_tagged_string()?) } Ok(vec) } @@ -153,7 +153,7 @@ pub fn add_tunnel_password( tag: Option<&Tag>, value: &[u8], ) -> Result<(), AVPError> { - packet.add(AVP::encode_tunnel_password( + packet.add(AVP::from_tunnel_password( TUNNEL_PASSWORD_TYPE, tag, value, @@ -165,12 +165,12 @@ pub fn add_tunnel_password( pub fn lookup_tunnel_password(packet: &Packet) -> Option, Tag), AVPError>> { packet .lookup(TUNNEL_PASSWORD_TYPE) - .map(|v| v.decode_tunnel_password(packet.get_secret(), packet.get_authenticator())) + .map(|v| v.encode_tunnel_password(packet.get_secret(), packet.get_authenticator())) } pub fn lookup_all_tunnel_password(packet: &Packet) -> Result, Tag)>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_PASSWORD_TYPE) { - vec.push(avp.decode_tunnel_password(packet.get_secret(), packet.get_authenticator())?) + vec.push(avp.encode_tunnel_password(packet.get_secret(), packet.get_authenticator())?) } Ok(vec) } @@ -180,7 +180,7 @@ pub fn delete_tunnel_private_group_id(packet: &mut Packet) { packet.delete(TUNNEL_PRIVATE_GROUP_ID_TYPE); } pub fn add_tunnel_private_group_id(packet: &mut Packet, tag: Option<&Tag>, value: &str) { - packet.add(AVP::encode_tagged_string( + packet.add(AVP::from_tagged_string( TUNNEL_PRIVATE_GROUP_ID_TYPE, tag, value, @@ -191,14 +191,14 @@ pub fn lookup_tunnel_private_group_id( ) -> Option), AVPError>> { packet .lookup(TUNNEL_PRIVATE_GROUP_ID_TYPE) - .map(|v| v.decode_tagged_string()) + .map(|v| v.encode_tagged_string()) } pub fn lookup_all_tunnel_private_group_id( packet: &Packet, ) -> Result)>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_PRIVATE_GROUP_ID_TYPE) { - vec.push(avp.decode_tagged_string()?) + vec.push(avp.encode_tagged_string()?) } Ok(vec) } @@ -208,7 +208,7 @@ pub fn delete_tunnel_assignment_id(packet: &mut Packet) { packet.delete(TUNNEL_ASSIGNMENT_ID_TYPE); } pub fn add_tunnel_assignment_id(packet: &mut Packet, tag: Option<&Tag>, value: &str) { - packet.add(AVP::encode_tagged_string( + packet.add(AVP::from_tagged_string( TUNNEL_ASSIGNMENT_ID_TYPE, tag, value, @@ -219,14 +219,14 @@ pub fn lookup_tunnel_assignment_id( ) -> Option), AVPError>> { packet .lookup(TUNNEL_ASSIGNMENT_ID_TYPE) - .map(|v| v.decode_tagged_string()) + .map(|v| v.encode_tagged_string()) } pub fn lookup_all_tunnel_assignment_id( packet: &Packet, ) -> Result)>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_ASSIGNMENT_ID_TYPE) { - vec.push(avp.decode_tagged_string()?) + vec.push(avp.encode_tagged_string()?) } Ok(vec) } @@ -236,17 +236,17 @@ pub fn delete_tunnel_preference(packet: &mut Packet) { packet.delete(TUNNEL_PREFERENCE_TYPE); } pub fn add_tunnel_preference(packet: &mut Packet, tag: Option<&Tag>, value: u32) { - packet.add(AVP::encode_tagged_u32(TUNNEL_PREFERENCE_TYPE, tag, value)); + packet.add(AVP::from_tagged_u32(TUNNEL_PREFERENCE_TYPE, tag, value)); } pub fn lookup_tunnel_preference(packet: &Packet) -> Option> { packet .lookup(TUNNEL_PREFERENCE_TYPE) - .map(|v| v.decode_tagged_u32()) + .map(|v| v.encode_tagged_u32()) } pub fn lookup_all_tunnel_preference(packet: &Packet) -> Result, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_PREFERENCE_TYPE) { - vec.push(avp.decode_tagged_u32()?) + vec.push(avp.encode_tagged_u32()?) } Ok(vec) } @@ -256,7 +256,7 @@ pub fn delete_tunnel_client_auth_id(packet: &mut Packet) { packet.delete(TUNNEL_CLIENT_AUTH_ID_TYPE); } pub fn add_tunnel_client_auth_id(packet: &mut Packet, tag: Option<&Tag>, value: &str) { - packet.add(AVP::encode_tagged_string( + packet.add(AVP::from_tagged_string( TUNNEL_CLIENT_AUTH_ID_TYPE, tag, value, @@ -267,14 +267,14 @@ pub fn lookup_tunnel_client_auth_id( ) -> Option), AVPError>> { packet .lookup(TUNNEL_CLIENT_AUTH_ID_TYPE) - .map(|v| v.decode_tagged_string()) + .map(|v| v.encode_tagged_string()) } pub fn lookup_all_tunnel_client_auth_id( packet: &Packet, ) -> Result)>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_CLIENT_AUTH_ID_TYPE) { - vec.push(avp.decode_tagged_string()?) + vec.push(avp.encode_tagged_string()?) } Ok(vec) } @@ -284,7 +284,7 @@ pub fn delete_tunnel_server_auth_id(packet: &mut Packet) { packet.delete(TUNNEL_SERVER_AUTH_ID_TYPE); } pub fn add_tunnel_server_auth_id(packet: &mut Packet, tag: Option<&Tag>, value: &str) { - packet.add(AVP::encode_tagged_string( + packet.add(AVP::from_tagged_string( TUNNEL_SERVER_AUTH_ID_TYPE, tag, value, @@ -295,14 +295,14 @@ pub fn lookup_tunnel_server_auth_id( ) -> Option), AVPError>> { packet .lookup(TUNNEL_SERVER_AUTH_ID_TYPE) - .map(|v| v.decode_tagged_string()) + .map(|v| v.encode_tagged_string()) } pub fn lookup_all_tunnel_server_auth_id( packet: &Packet, ) -> Result)>, AVPError> { let mut vec = Vec::new(); for avp in packet.lookup_all(TUNNEL_SERVER_AUTH_ID_TYPE) { - vec.push(avp.decode_tagged_string()?) + vec.push(avp.encode_tagged_string()?) } Ok(vec) }