cubixle/radius-rs
1
0
Fork 0
mirror of https://github.com/cubixle/radius-rs.git synced 2026-04-24 21:24:43 +01:00
Code Issues Packages Projects Releases Wiki Activity

Typesafe lookup_all

Browse Source
This commit is contained in:
moznion
2020-11-28 18:43:58 +09:00
parent a20f1a1d28
commit 4a99b9f9b2
4 changed files with 422 additions and 168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
code_generator/src/main.rs
View File

@@ -210,9 +210,6 @@ pub const {type_identifier}: AVPType = {type_value};
pub fn delete_{method_identifier}(packet: &mut Packet) {{
packet.delete({type_identifier});
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<&AVP> {{
packet.lookup_all({type_identifier})
}}
",
method_identifier = attr_name.to_snake_case(),
type_identifier = type_identifier,
@@ -233,6 +230,13 @@ fn generate_string_attribute_code(
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<String, AVPError>> {{
packet.lookup({type_identifier}).map(|v| v.decode_string())
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<String>, AVPError> {{
let mut vec = Vec::new();
for avp in packet.lookup_all({type_identifier}) {{
vec.push(avp.decode_string()?)
}}
Ok(vec)
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -253,6 +257,13 @@ fn generate_user_password_attribute_code(
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {{
packet.lookup({type_identifier}).map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator()))
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<Vec<u8>>, 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())?)
}}
Ok(vec)
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -272,6 +283,13 @@ fn generate_octets_attribute_code(
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Vec<u8>> {{
packet.lookup({type_identifier}).map(|v| v.decode_bytes())
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<Vec<u8>> {{
let mut vec = Vec::new();
for avp in packet.lookup_all({type_identifier}) {{
vec.push(avp.decode_bytes())
}}
vec
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -291,6 +309,13 @@ fn generate_ipaddr_attribute_code(
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {{
packet.lookup({type_identifier}).map(|v| v.decode_ipv4())
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {{
let mut vec = Vec::new();
for avp in packet.lookup_all({type_identifier}) {{
vec.push(avp.decode_ipv4()?)
}}
Ok(vec)
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -310,6 +335,13 @@ fn generate_integer_attribute_code(
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<u32, AVPError>> {{
packet.lookup({type_identifier}).map(|v| v.decode_u32())
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<u32>, AVPError> {{
let mut vec = Vec::new();
for avp in packet.lookup_all({type_identifier}) {{
vec.push(avp.decode_u32()?)
}}
Ok(vec)
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -330,6 +362,13 @@ fn generate_value_defined_integer_attribute_code(
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<{value_type}, AVPError>> {{
packet.lookup({type_identifier}).map(|v| Ok(v.decode_u32()? as {value_type}))
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Result<Vec<{value_type}>, AVPError> {{
let mut vec = Vec::new();
for avp in packet.lookup_all({type_identifier}) {{
vec.push(avp.decode_u32()? as {value_type})
}}
Ok(vec)
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,

403
src/rfc2865.rs
View File

@@ -83,23 +83,24 @@ pub const USER_NAME_TYPE: AVPType = 1;
pub fn delete_user_name(packet: &mut Packet) {
packet.delete(USER_NAME_TYPE);
}
pub fn lookup_all_user_name(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(USER_NAME_TYPE)
}
pub fn add_user_name(packet: &mut Packet, value: &str) {
packet.add(AVP::encode_string(USER_NAME_TYPE, value));
}
pub fn lookup_user_name(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(USER_NAME_TYPE).map(|v| v.decode_string())
}
pub fn lookup_all_user_name(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(USER_NAME_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const USER_PASSWORD_TYPE: AVPType = 2;
pub fn delete_user_password(packet: &mut Packet) {
packet.delete(USER_PASSWORD_TYPE);
}
pub fn lookup_all_user_password(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(USER_PASSWORD_TYPE)
}
pub fn add_user_password(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::encode_user_password(
USER_PASSWORD_TYPE,
@@ -114,56 +115,72 @@ pub fn lookup_user_password(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>
.lookup(USER_PASSWORD_TYPE)
.map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator()))
}
pub fn lookup_all_user_password(packet: &Packet) -> Result<Vec<Vec<u8>>, 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())?)
}
Ok(vec)
}
pub const CHAP_PASSWORD_TYPE: AVPType = 3;
pub fn delete_chap_password(packet: &mut Packet) {
packet.delete(CHAP_PASSWORD_TYPE);
}
pub fn lookup_all_chap_password(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CHAP_PASSWORD_TYPE)
}
pub fn add_chap_password(packet: &mut Packet, value: &[u8]) {
packet.add(AVP::encode_bytes(CHAP_PASSWORD_TYPE, value));
}
pub fn lookup_chap_password(packet: &Packet) -> Option<Vec<u8>> {
packet.lookup(CHAP_PASSWORD_TYPE).map(|v| v.decode_bytes())
}
pub fn lookup_all_chap_password(packet: &Packet) -> Vec<Vec<u8>> {
let mut vec = Vec::new();
for avp in packet.lookup_all(CHAP_PASSWORD_TYPE) {
vec.push(avp.decode_bytes())
}
vec
}
pub const NAS_IP_ADDRESS_TYPE: AVPType = 4;
pub fn delete_nas_ip_address(packet: &mut Packet) {
packet.delete(NAS_IP_ADDRESS_TYPE);
}
pub fn lookup_all_nas_ip_address(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
pub fn lookup_nas_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet.lookup(NAS_IP_ADDRESS_TYPE).map(|v| v.decode_ipv4())
}
pub fn lookup_all_nas_ip_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(NAS_IP_ADDRESS_TYPE) {
vec.push(avp.decode_ipv4()?)
}
Ok(vec)
}
pub const NAS_PORT_TYPE: AVPType = 5;
pub fn delete_nas_port(packet: &mut Packet) {
packet.delete(NAS_PORT_TYPE);
}
pub fn lookup_all_nas_port(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(NAS_PORT_TYPE)
}
pub fn add_nas_port(packet: &mut Packet, value: u32) {
packet.add(AVP::encode_u32(NAS_PORT_TYPE, value));
}
pub fn lookup_nas_port(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet.lookup(NAS_PORT_TYPE).map(|v| v.decode_u32())
}
pub fn lookup_all_nas_port(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(NAS_PORT_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const SERVICE_TYPE_TYPE: AVPType = 6;
pub fn delete_service_type(packet: &mut Packet) {
packet.delete(SERVICE_TYPE_TYPE);
}
pub fn lookup_all_service_type(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(SERVICE_TYPE_TYPE)
}
pub fn add_service_type(packet: &mut Packet, value: ServiceType) {
packet.add(AVP::encode_u32(SERVICE_TYPE_TYPE, value as u32));
}
@@ -172,14 +189,18 @@ pub fn lookup_service_type(packet: &Packet) -> Option<Result<ServiceType, AVPErr
.lookup(SERVICE_TYPE_TYPE)
.map(|v| Ok(v.decode_u32()? as ServiceType))
}
pub fn lookup_all_service_type(packet: &Packet) -> Result<Vec<ServiceType>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(SERVICE_TYPE_TYPE) {
vec.push(avp.decode_u32()? as ServiceType)
}
Ok(vec)
}
pub const FRAMED_PROTOCOL_TYPE: AVPType = 7;
pub fn delete_framed_protocol(packet: &mut Packet) {
packet.delete(FRAMED_PROTOCOL_TYPE);
}
pub fn lookup_all_framed_protocol(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_PROTOCOL_TYPE)
}
pub fn add_framed_protocol(packet: &mut Packet, value: FramedProtocol) {
packet.add(AVP::encode_u32(FRAMED_PROTOCOL_TYPE, value as u32));
}
@@ -188,14 +209,18 @@ pub fn lookup_framed_protocol(packet: &Packet) -> Option<Result<FramedProtocol,
.lookup(FRAMED_PROTOCOL_TYPE)
.map(|v| Ok(v.decode_u32()? as FramedProtocol))
}
pub fn lookup_all_framed_protocol(packet: &Packet) -> Result<Vec<FramedProtocol>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_PROTOCOL_TYPE) {
vec.push(avp.decode_u32()? as FramedProtocol)
}
Ok(vec)
}
pub const FRAMED_IP_ADDRESS_TYPE: AVPType = 8;
pub fn delete_framed_ip_address(packet: &mut Packet) {
packet.delete(FRAMED_IP_ADDRESS_TYPE);
}
pub fn lookup_all_framed_ip_address(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -204,14 +229,18 @@ pub fn lookup_framed_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPE
.lookup(FRAMED_IP_ADDRESS_TYPE)
.map(|v| v.decode_ipv4())
}
pub fn lookup_all_framed_ip_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_IP_ADDRESS_TYPE) {
vec.push(avp.decode_ipv4()?)
}
Ok(vec)
}
pub const FRAMED_IP_NETMASK_TYPE: AVPType = 9;
pub fn delete_framed_ip_netmask(packet: &mut Packet) {
packet.delete(FRAMED_IP_NETMASK_TYPE);
}
pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -220,14 +249,18 @@ pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<Result<Ipv4Addr, AVPE
.lookup(FRAMED_IP_NETMASK_TYPE)
.map(|v| v.decode_ipv4())
}
pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_IP_NETMASK_TYPE) {
vec.push(avp.decode_ipv4()?)
}
Ok(vec)
}
pub const FRAMED_ROUTING_TYPE: AVPType = 10;
pub fn delete_framed_routing(packet: &mut Packet) {
packet.delete(FRAMED_ROUTING_TYPE);
}
pub fn lookup_all_framed_routing(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_ROUTING_TYPE)
}
pub fn add_framed_routing(packet: &mut Packet, value: FramedRouting) {
packet.add(AVP::encode_u32(FRAMED_ROUTING_TYPE, value as u32));
}
@@ -236,42 +269,54 @@ pub fn lookup_framed_routing(packet: &Packet) -> Option<Result<FramedRouting, AV
.lookup(FRAMED_ROUTING_TYPE)
.map(|v| Ok(v.decode_u32()? as FramedRouting))
}
pub fn lookup_all_framed_routing(packet: &Packet) -> Result<Vec<FramedRouting>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_ROUTING_TYPE) {
vec.push(avp.decode_u32()? as FramedRouting)
}
Ok(vec)
}
pub const FILTER_ID_TYPE: AVPType = 11;
pub fn delete_filter_id(packet: &mut Packet) {
packet.delete(FILTER_ID_TYPE);
}
pub fn lookup_all_filter_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FILTER_ID_TYPE)
}
pub fn add_filter_id(packet: &mut Packet, value: &str) {
packet.add(AVP::encode_string(FILTER_ID_TYPE, value));
}
pub fn lookup_filter_id(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(FILTER_ID_TYPE).map(|v| v.decode_string())
}
pub fn lookup_all_filter_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FILTER_ID_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const FRAMED_MTU_TYPE: AVPType = 12;
pub fn delete_framed_mtu(packet: &mut Packet) {
packet.delete(FRAMED_MTU_TYPE);
}
pub fn lookup_all_framed_mtu(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_MTU_TYPE)
}
pub fn add_framed_mtu(packet: &mut Packet, value: u32) {
packet.add(AVP::encode_u32(FRAMED_MTU_TYPE, value));
}
pub fn lookup_framed_mtu(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet.lookup(FRAMED_MTU_TYPE).map(|v| v.decode_u32())
}
pub fn lookup_all_framed_mtu(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_MTU_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const FRAMED_COMPRESSION_TYPE: AVPType = 13;
pub fn delete_framed_compression(packet: &mut Packet) {
packet.delete(FRAMED_COMPRESSION_TYPE);
}
pub fn lookup_all_framed_compression(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_COMPRESSION_TYPE)
}
pub fn add_framed_compression(packet: &mut Packet, value: FramedCompression) {
packet.add(AVP::encode_u32(FRAMED_COMPRESSION_TYPE, value as u32));
}
@@ -280,28 +325,36 @@ pub fn lookup_framed_compression(packet: &Packet) -> Option<Result<FramedCompres
.lookup(FRAMED_COMPRESSION_TYPE)
.map(|v| Ok(v.decode_u32()? as FramedCompression))
}
pub fn lookup_all_framed_compression(packet: &Packet) -> Result<Vec<FramedCompression>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_COMPRESSION_TYPE) {
vec.push(avp.decode_u32()? as FramedCompression)
}
Ok(vec)
}
pub const LOGIN_IP_HOST_TYPE: AVPType = 14;
pub fn delete_login_ip_host(packet: &mut Packet) {
packet.delete(LOGIN_IP_HOST_TYPE);
}
pub fn lookup_all_login_ip_host(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
pub fn lookup_login_ip_host(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet.lookup(LOGIN_IP_HOST_TYPE).map(|v| v.decode_ipv4())
}
pub fn lookup_all_login_ip_host(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_IP_HOST_TYPE) {
vec.push(avp.decode_ipv4()?)
}
Ok(vec)
}
pub const LOGIN_SERVICE_TYPE: AVPType = 15;
pub fn delete_login_service(packet: &mut Packet) {
packet.delete(LOGIN_SERVICE_TYPE);
}
pub fn lookup_all_login_service(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_SERVICE_TYPE)
}
pub fn add_login_service(packet: &mut Packet, value: LoginService) {
packet.add(AVP::encode_u32(LOGIN_SERVICE_TYPE, value as u32));
}
@@ -310,14 +363,18 @@ pub fn lookup_login_service(packet: &Packet) -> Option<Result<LoginService, AVPE
.lookup(LOGIN_SERVICE_TYPE)
.map(|v| Ok(v.decode_u32()? as LoginService))
}
pub fn lookup_all_login_service(packet: &Packet) -> Result<Vec<LoginService>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_SERVICE_TYPE) {
vec.push(avp.decode_u32()? as LoginService)
}
Ok(vec)
}
pub const LOGIN_TCP_PORT_TYPE: AVPType = 16;
pub fn delete_login_tcp_port(packet: &mut Packet) {
packet.delete(LOGIN_TCP_PORT_TYPE);
}
pub fn lookup_all_login_tcp_port(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -326,28 +383,36 @@ pub fn lookup_login_tcp_port(packet: &Packet) -> Option<Result<LoginTCPPort, AVP
.lookup(LOGIN_TCP_PORT_TYPE)
.map(|v| Ok(v.decode_u32()? as LoginTCPPort))
}
pub fn lookup_all_login_tcp_port(packet: &Packet) -> Result<Vec<LoginTCPPort>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_TCP_PORT_TYPE) {
vec.push(avp.decode_u32()? as LoginTCPPort)
}
Ok(vec)
}
pub const REPLY_MESSAGE_TYPE: AVPType = 18;
pub fn delete_reply_message(packet: &mut Packet) {
packet.delete(REPLY_MESSAGE_TYPE);
}
pub fn lookup_all_reply_message(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(REPLY_MESSAGE_TYPE)
}
pub fn add_reply_message(packet: &mut Packet, value: &str) {
packet.add(AVP::encode_string(REPLY_MESSAGE_TYPE, value));
}
pub fn lookup_reply_message(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(REPLY_MESSAGE_TYPE).map(|v| v.decode_string())
}
pub fn lookup_all_reply_message(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(REPLY_MESSAGE_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const CALLBACK_NUMBER_TYPE: AVPType = 19;
pub fn delete_callback_number(packet: &mut Packet) {
packet.delete(CALLBACK_NUMBER_TYPE);
}
pub fn lookup_all_callback_number(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CALLBACK_NUMBER_TYPE)
}
pub fn add_callback_number(packet: &mut Packet, value: &str) {
packet.add(AVP::encode_string(CALLBACK_NUMBER_TYPE, value));
}
@@ -356,42 +421,54 @@ pub fn lookup_callback_number(packet: &Packet) -> Option<Result<String, AVPError
.lookup(CALLBACK_NUMBER_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_callback_number(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(CALLBACK_NUMBER_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const CALLBACK_ID_TYPE: AVPType = 20;
pub fn delete_callback_id(packet: &mut Packet) {
packet.delete(CALLBACK_ID_TYPE);
}
pub fn lookup_all_callback_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CALLBACK_ID_TYPE)
}
pub fn add_callback_id(packet: &mut Packet, value: &str) {
packet.add(AVP::encode_string(CALLBACK_ID_TYPE, value));
}
pub fn lookup_callback_id(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(CALLBACK_ID_TYPE).map(|v| v.decode_string())
}
pub fn lookup_all_callback_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(CALLBACK_ID_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const FRAMED_ROUTE_TYPE: AVPType = 22;
pub fn delete_framed_route(packet: &mut Packet) {
packet.delete(FRAMED_ROUTE_TYPE);
}
pub fn lookup_all_framed_route(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_ROUTE_TYPE)
}
pub fn add_framed_route(packet: &mut Packet, value: &str) {
packet.add(AVP::encode_string(FRAMED_ROUTE_TYPE, value));
}
pub fn lookup_framed_route(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(FRAMED_ROUTE_TYPE).map(|v| v.decode_string())
}
pub fn lookup_all_framed_route(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_ROUTE_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const FRAMED_IPX_NETWORK_TYPE: AVPType = 23;
pub fn delete_framed_ipx_network(packet: &mut Packet) {
packet.delete(FRAMED_IPX_NETWORK_TYPE);
}
pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -400,78 +477,95 @@ pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<Result<Ipv4Addr, AVP
.lookup(FRAMED_IPX_NETWORK_TYPE)
.map(|v| v.decode_ipv4())
}
pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_IPX_NETWORK_TYPE) {
vec.push(avp.decode_ipv4()?)
}
Ok(vec)
}
pub const STATE_TYPE: AVPType = 24;
pub fn delete_state(packet: &mut Packet) {
packet.delete(STATE_TYPE);
}
pub fn lookup_all_state(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(STATE_TYPE)
}
pub fn add_state(packet: &mut Packet, value: &[u8]) {
packet.add(AVP::encode_bytes(STATE_TYPE, value));
}
pub fn lookup_state(packet: &Packet) -> Option<Vec<u8>> {
packet.lookup(STATE_TYPE).map(|v| v.decode_bytes())
}
pub fn lookup_all_state(packet: &Packet) -> Vec<Vec<u8>> {
let mut vec = Vec::new();
for avp in packet.lookup_all(STATE_TYPE) {
vec.push(avp.decode_bytes())
}
vec
}
pub const CLASS_TYPE: AVPType = 25;
pub fn delete_class(packet: &mut Packet) {
packet.delete(CLASS_TYPE);
}
pub fn lookup_all_class(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CLASS_TYPE)
}
pub fn add_class(packet: &mut Packet, value: &[u8]) {
packet.add(AVP::encode_bytes(CLASS_TYPE, value));
}
pub fn lookup_class(packet: &Packet) -> Option<Vec<u8>> {
packet.lookup(CLASS_TYPE).map(|v| v.decode_bytes())
}
pub fn lookup_all_class(packet: &Packet) -> Vec<Vec<u8>> {
let mut vec = Vec::new();
for avp in packet.lookup_all(CLASS_TYPE) {
vec.push(avp.decode_bytes())
}
vec
}
pub const VENDOR_SPECIFIC_TYPE: AVPType = 26;
pub fn delete_vendor_specific(packet: &mut Packet) {
packet.delete(VENDOR_SPECIFIC_TYPE);
}
pub fn lookup_all_vendor_specific(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(VENDOR_SPECIFIC_TYPE)
}
pub const SESSION_TIMEOUT_TYPE: AVPType = 27;
pub fn delete_session_timeout(packet: &mut Packet) {
packet.delete(SESSION_TIMEOUT_TYPE);
}
pub fn lookup_all_session_timeout(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(SESSION_TIMEOUT_TYPE)
}
pub fn add_session_timeout(packet: &mut Packet, value: u32) {
packet.add(AVP::encode_u32(SESSION_TIMEOUT_TYPE, value));
}
pub fn lookup_session_timeout(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet.lookup(SESSION_TIMEOUT_TYPE).map(|v| v.decode_u32())
}
pub fn lookup_all_session_timeout(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(SESSION_TIMEOUT_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const IDLE_TIMEOUT_TYPE: AVPType = 28;
pub fn delete_idle_timeout(packet: &mut Packet) {
packet.delete(IDLE_TIMEOUT_TYPE);
}
pub fn lookup_all_idle_timeout(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(IDLE_TIMEOUT_TYPE)
}
pub fn add_idle_timeout(packet: &mut Packet, value: u32) {
packet.add(AVP::encode_u32(IDLE_TIMEOUT_TYPE, value));
}
pub fn lookup_idle_timeout(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet.lookup(IDLE_TIMEOUT_TYPE).map(|v| v.decode_u32())
}
pub fn lookup_all_idle_timeout(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(IDLE_TIMEOUT_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const TERMINATION_ACTION_TYPE: AVPType = 29;
pub fn delete_termination_action(packet: &mut Packet) {
packet.delete(TERMINATION_ACTION_TYPE);
}
pub fn lookup_all_termination_action(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(TERMINATION_ACTION_TYPE)
}
pub fn add_termination_action(packet: &mut Packet, value: TerminationAction) {
packet.add(AVP::encode_u32(TERMINATION_ACTION_TYPE, value as u32));
}
@@ -480,14 +574,18 @@ pub fn lookup_termination_action(packet: &Packet) -> Option<Result<TerminationAc
.lookup(TERMINATION_ACTION_TYPE)
.map(|v| Ok(v.decode_u32()? as TerminationAction))
}
pub fn lookup_all_termination_action(packet: &Packet) -> Result<Vec<TerminationAction>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(TERMINATION_ACTION_TYPE) {
vec.push(avp.decode_u32()? as TerminationAction)
}
Ok(vec)
}
pub const CALLED_STATION_ID_TYPE: AVPType = 30;
pub fn delete_called_station_id(packet: &mut Packet) {
packet.delete(CALLED_STATION_ID_TYPE);
}
pub fn lookup_all_called_station_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -496,14 +594,18 @@ pub fn lookup_called_station_id(packet: &Packet) -> Option<Result<String, AVPErr
.lookup(CALLED_STATION_ID_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_called_station_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(CALLED_STATION_ID_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const CALLING_STATION_ID_TYPE: AVPType = 31;
pub fn delete_calling_station_id(packet: &mut Packet) {
packet.delete(CALLING_STATION_ID_TYPE);
}
pub fn lookup_all_calling_station_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -512,14 +614,18 @@ pub fn lookup_calling_station_id(packet: &Packet) -> Option<Result<String, AVPEr
.lookup(CALLING_STATION_ID_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_calling_station_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(CALLING_STATION_ID_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const NAS_IDENTIFIER_TYPE: AVPType = 32;
pub fn delete_nas_identifier(packet: &mut Packet) {
packet.delete(NAS_IDENTIFIER_TYPE);
}
pub fn lookup_all_nas_identifier(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(NAS_IDENTIFIER_TYPE)
}
pub fn add_nas_identifier(packet: &mut Packet, value: &str) {
packet.add(AVP::encode_string(NAS_IDENTIFIER_TYPE, value));
}
@@ -528,28 +634,36 @@ pub fn lookup_nas_identifier(packet: &Packet) -> Option<Result<String, AVPError>
.lookup(NAS_IDENTIFIER_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_nas_identifier(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(NAS_IDENTIFIER_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const PROXY_STATE_TYPE: AVPType = 33;
pub fn delete_proxy_state(packet: &mut Packet) {
packet.delete(PROXY_STATE_TYPE);
}
pub fn lookup_all_proxy_state(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(PROXY_STATE_TYPE)
}
pub fn add_proxy_state(packet: &mut Packet, value: &[u8]) {
packet.add(AVP::encode_bytes(PROXY_STATE_TYPE, value));
}
pub fn lookup_proxy_state(packet: &Packet) -> Option<Vec<u8>> {
packet.lookup(PROXY_STATE_TYPE).map(|v| v.decode_bytes())
}
pub fn lookup_all_proxy_state(packet: &Packet) -> Vec<Vec<u8>> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PROXY_STATE_TYPE) {
vec.push(avp.decode_bytes())
}
vec
}
pub const LOGIN_LAT_SERVICE_TYPE: AVPType = 34;
pub fn delete_login_lat_service(packet: &mut Packet) {
packet.delete(LOGIN_LAT_SERVICE_TYPE);
}
pub fn lookup_all_login_lat_service(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -558,14 +672,18 @@ pub fn lookup_login_lat_service(packet: &Packet) -> Option<Result<String, AVPErr
.lookup(LOGIN_LAT_SERVICE_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_login_lat_service(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_LAT_SERVICE_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const LOGIN_LAT_NODE_TYPE: AVPType = 35;
pub fn delete_login_lat_node(packet: &mut Packet) {
packet.delete(LOGIN_LAT_NODE_TYPE);
}
pub fn lookup_all_login_lat_node(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -574,14 +692,18 @@ pub fn lookup_login_lat_node(packet: &Packet) -> Option<Result<String, AVPError>
.lookup(LOGIN_LAT_NODE_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_login_lat_node(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_LAT_NODE_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const LOGIN_LAT_GROUP_TYPE: AVPType = 36;
pub fn delete_login_lat_group(packet: &mut Packet) {
packet.delete(LOGIN_LAT_GROUP_TYPE);
}
pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -590,14 +712,18 @@ pub fn lookup_login_lat_group(packet: &Packet) -> Option<Vec<u8>> {
.lookup(LOGIN_LAT_GROUP_TYPE)
.map(|v| v.decode_bytes())
}
pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<Vec<u8>> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_LAT_GROUP_TYPE) {
vec.push(avp.decode_bytes())
}
vec
}
pub const FRAMED_APPLE_TALK_LINK_TYPE: AVPType = 37;
pub fn delete_framed_apple_talk_link(packet: &mut Packet) {
packet.delete(FRAMED_APPLE_TALK_LINK_TYPE);
}
pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -606,14 +732,18 @@ pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<Result<u32, AVPE
.lookup(FRAMED_APPLE_TALK_LINK_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_APPLE_TALK_LINK_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const FRAMED_APPLE_TALK_NETWORK_TYPE: AVPType = 38;
pub fn delete_framed_apple_talk_network(packet: &mut Packet) {
packet.delete(FRAMED_APPLE_TALK_NETWORK_TYPE);
}
pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -622,14 +752,18 @@ pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<Result<u32, A
.lookup(FRAMED_APPLE_TALK_NETWORK_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_APPLE_TALK_NETWORK_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const FRAMED_APPLE_TALK_ZONE_TYPE: AVPType = 39;
pub fn delete_framed_apple_talk_zone(packet: &mut Packet) {
packet.delete(FRAMED_APPLE_TALK_ZONE_TYPE);
}
pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -638,28 +772,36 @@ pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<Result<String, A
.lookup(FRAMED_APPLE_TALK_ZONE_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_APPLE_TALK_ZONE_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const CHAP_CHALLENGE_TYPE: AVPType = 60;
pub fn delete_chap_challenge(packet: &mut Packet) {
packet.delete(CHAP_CHALLENGE_TYPE);
}
pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CHAP_CHALLENGE_TYPE)
}
pub fn add_chap_challenge(packet: &mut Packet, value: &[u8]) {
packet.add(AVP::encode_bytes(CHAP_CHALLENGE_TYPE, value));
}
pub fn lookup_chap_challenge(packet: &Packet) -> Option<Vec<u8>> {
packet.lookup(CHAP_CHALLENGE_TYPE).map(|v| v.decode_bytes())
}
pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec<Vec<u8>> {
let mut vec = Vec::new();
for avp in packet.lookup_all(CHAP_CHALLENGE_TYPE) {
vec.push(avp.decode_bytes())
}
vec
}
pub const NAS_PORT_TYPE_TYPE: AVPType = 61;
pub fn delete_nas_port_type(packet: &mut Packet) {
packet.delete(NAS_PORT_TYPE_TYPE);
}
pub fn lookup_all_nas_port_type(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -668,28 +810,36 @@ pub fn lookup_nas_port_type(packet: &Packet) -> Option<Result<NasPortType, AVPEr
.lookup(NAS_PORT_TYPE_TYPE)
.map(|v| Ok(v.decode_u32()? as NasPortType))
}
pub fn lookup_all_nas_port_type(packet: &Packet) -> Result<Vec<NasPortType>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(NAS_PORT_TYPE_TYPE) {
vec.push(avp.decode_u32()? as NasPortType)
}
Ok(vec)
}
pub const PORT_LIMIT_TYPE: AVPType = 62;
pub fn delete_port_limit(packet: &mut Packet) {
packet.delete(PORT_LIMIT_TYPE);
}
pub fn lookup_all_port_limit(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(PORT_LIMIT_TYPE)
}
pub fn add_port_limit(packet: &mut Packet, value: u32) {
packet.add(AVP::encode_u32(PORT_LIMIT_TYPE, value));
}
pub fn lookup_port_limit(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet.lookup(PORT_LIMIT_TYPE).map(|v| v.decode_u32())
}
pub fn lookup_all_port_limit(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PORT_LIMIT_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const LOGIN_LAT_PORT_TYPE: AVPType = 63;
pub fn delete_login_lat_port(packet: &mut Packet) {
packet.delete(LOGIN_LAT_PORT_TYPE);
}
pub fn lookup_all_login_lat_port(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -698,3 +848,10 @@ pub fn lookup_login_lat_port(packet: &Packet) -> Option<Result<String, AVPError>
.lookup(LOGIN_LAT_PORT_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_login_lat_port(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_LAT_PORT_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}

122
src/rfc2866.rs
View File

@@ -42,9 +42,6 @@ pub const ACCT_STATUS_TYPE_TYPE: AVPType = 40;
pub fn delete_acct_status_type(packet: &mut Packet) {
packet.delete(ACCT_STATUS_TYPE_TYPE);
}
pub fn lookup_all_acct_status_type(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -53,28 +50,36 @@ pub fn lookup_acct_status_type(packet: &Packet) -> Option<Result<AcctStatusType,
.lookup(ACCT_STATUS_TYPE_TYPE)
.map(|v| Ok(v.decode_u32()? as AcctStatusType))
}
pub fn lookup_all_acct_status_type(packet: &Packet) -> Result<Vec<AcctStatusType>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_STATUS_TYPE_TYPE) {
vec.push(avp.decode_u32()? as AcctStatusType)
}
Ok(vec)
}
pub const ACCT_DELAY_TIME_TYPE: AVPType = 41;
pub fn delete_acct_delay_time(packet: &mut Packet) {
packet.delete(ACCT_DELAY_TIME_TYPE);
}
pub fn lookup_all_acct_delay_time(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
pub fn lookup_acct_delay_time(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet.lookup(ACCT_DELAY_TIME_TYPE).map(|v| v.decode_u32())
}
pub fn lookup_all_acct_delay_time(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_DELAY_TIME_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const ACCT_INPUT_OCTETS_TYPE: AVPType = 42;
pub fn delete_acct_input_octets(packet: &mut Packet) {
packet.delete(ACCT_INPUT_OCTETS_TYPE);
}
pub fn lookup_all_acct_input_octets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -83,14 +88,18 @@ pub fn lookup_acct_input_octets(packet: &Packet) -> Option<Result<u32, AVPError>
.lookup(ACCT_INPUT_OCTETS_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_acct_input_octets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_INPUT_OCTETS_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const ACCT_OUTPUT_OCTETS_TYPE: AVPType = 43;
pub fn delete_acct_output_octets(packet: &mut Packet) {
packet.delete(ACCT_OUTPUT_OCTETS_TYPE);
}
pub fn lookup_all_acct_output_octets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -99,14 +108,18 @@ pub fn lookup_acct_output_octets(packet: &Packet) -> Option<Result<u32, AVPError
.lookup(ACCT_OUTPUT_OCTETS_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_acct_output_octets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_OUTPUT_OCTETS_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const ACCT_SESSION_ID_TYPE: AVPType = 44;
pub fn delete_acct_session_id(packet: &mut Packet) {
packet.delete(ACCT_SESSION_ID_TYPE);
}
pub fn lookup_all_acct_session_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -115,14 +128,18 @@ pub fn lookup_acct_session_id(packet: &Packet) -> Option<Result<String, AVPError
.lookup(ACCT_SESSION_ID_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_acct_session_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_SESSION_ID_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const ACCT_AUTHENTIC_TYPE: AVPType = 45;
pub fn delete_acct_authentic(packet: &mut Packet) {
packet.delete(ACCT_AUTHENTIC_TYPE);
}
pub fn lookup_all_acct_authentic(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_AUTHENTIC_TYPE)
}
pub fn add_acct_authentic(packet: &mut Packet, value: AcctAuthentic) {
packet.add(AVP::encode_u32(ACCT_AUTHENTIC_TYPE, value as u32));
}
@@ -131,14 +148,18 @@ pub fn lookup_acct_authentic(packet: &Packet) -> Option<Result<AcctAuthentic, AV
.lookup(ACCT_AUTHENTIC_TYPE)
.map(|v| Ok(v.decode_u32()? as AcctAuthentic))
}
pub fn lookup_all_acct_authentic(packet: &Packet) -> Result<Vec<AcctAuthentic>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_AUTHENTIC_TYPE) {
vec.push(avp.decode_u32()? as AcctAuthentic)
}
Ok(vec)
}
pub const ACCT_SESSION_TIME_TYPE: AVPType = 46;
pub fn delete_acct_session_time(packet: &mut Packet) {
packet.delete(ACCT_SESSION_TIME_TYPE);
}
pub fn lookup_all_acct_session_time(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -147,14 +168,18 @@ pub fn lookup_acct_session_time(packet: &Packet) -> Option<Result<u32, AVPError>
.lookup(ACCT_SESSION_TIME_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_acct_session_time(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_SESSION_TIME_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const ACCT_INPUT_PACKETS_TYPE: AVPType = 47;
pub fn delete_acct_input_packets(packet: &mut Packet) {
packet.delete(ACCT_INPUT_PACKETS_TYPE);
}
pub fn lookup_all_acct_input_packets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -163,14 +188,18 @@ pub fn lookup_acct_input_packets(packet: &Packet) -> Option<Result<u32, AVPError
.lookup(ACCT_INPUT_PACKETS_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_acct_input_packets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_INPUT_PACKETS_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const ACCT_OUTPUT_PACKETS_TYPE: AVPType = 48;
pub fn delete_acct_output_packets(packet: &mut Packet) {
packet.delete(ACCT_OUTPUT_PACKETS_TYPE);
}
pub fn lookup_all_acct_output_packets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -179,14 +208,18 @@ pub fn lookup_acct_output_packets(packet: &Packet) -> Option<Result<u32, AVPErro
.lookup(ACCT_OUTPUT_PACKETS_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_acct_output_packets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_OUTPUT_PACKETS_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}
pub const ACCT_TERMINATE_CAUSE_TYPE: AVPType = 49;
pub fn delete_acct_terminate_cause(packet: &mut Packet) {
packet.delete(ACCT_TERMINATE_CAUSE_TYPE);
}
pub fn lookup_all_acct_terminate_cause(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -197,14 +230,20 @@ pub fn lookup_acct_terminate_cause(
.lookup(ACCT_TERMINATE_CAUSE_TYPE)
.map(|v| Ok(v.decode_u32()? as AcctTerminateCause))
}
pub fn lookup_all_acct_terminate_cause(
packet: &Packet,
) -> Result<Vec<AcctTerminateCause>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_TERMINATE_CAUSE_TYPE) {
vec.push(avp.decode_u32()? as AcctTerminateCause)
}
Ok(vec)
}
pub const ACCT_MULTI_SESSION_ID_TYPE: AVPType = 50;
pub fn delete_acct_multi_session_id(packet: &mut Packet) {
packet.delete(ACCT_MULTI_SESSION_ID_TYPE);
}
pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -213,17 +252,28 @@ pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<Result<String, AV
.lookup(ACCT_MULTI_SESSION_ID_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_MULTI_SESSION_ID_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const ACCT_LINK_COUNT_TYPE: AVPType = 51;
pub fn delete_acct_link_count(packet: &mut Packet) {
packet.delete(ACCT_LINK_COUNT_TYPE);
}
pub fn lookup_all_acct_link_count(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
pub fn lookup_acct_link_count(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet.lookup(ACCT_LINK_COUNT_TYPE).map(|v| v.decode_u32())
}
pub fn lookup_all_acct_link_count(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_LINK_COUNT_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}

20
src/rfc2867.rs
View File

@@ -15,9 +15,6 @@ pub const ACCT_TUNNEL_CONNECTION_TYPE: AVPType = 68;
pub fn delete_acct_tunnel_connection(packet: &mut Packet) {
packet.delete(ACCT_TUNNEL_CONNECTION_TYPE);
}
pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -26,14 +23,18 @@ pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<Result<String, A
.lookup(ACCT_TUNNEL_CONNECTION_TYPE)
.map(|v| v.decode_string())
}
pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_TUNNEL_CONNECTION_TYPE) {
vec.push(avp.decode_string()?)
}
Ok(vec)
}
pub const ACCT_TUNNEL_PACKETS_LOST_TYPE: AVPType = 86;
pub fn delete_acct_tunnel_packets_lost(packet: &mut Packet) {
packet.delete(ACCT_TUNNEL_PACKETS_LOST_TYPE);
}
pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(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));
}
@@ -42,3 +43,10 @@ pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<Result<u32, AV
.lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE)
.map(|v| v.decode_u32())
}
pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Result<Vec<u32>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ACCT_TUNNEL_PACKETS_LOST_TYPE) {
vec.push(avp.decode_u32()?)
}
Ok(vec)
}