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

Typesafe lookup

Browse Source
This commit is contained in:
moznion
2020-11-28 18:29:37 +09:00
parent 09a82d3454
commit a20f1a1d28
5 changed files with 256 additions and 178 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
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_{method_identifier}(packet: &Packet) -> Option<&AVP> {{
packet.lookup({type_identifier})
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<&AVP> {{
packet.lookup_all({type_identifier})
}}
@@ -233,6 +230,9 @@ fn generate_string_attribute_code(
"pub fn add_{method_identifier}(packet: &mut Packet, value: &str) {{
packet.add(AVP::encode_string({type_identifier}, value));
}}
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<String, AVPError>> {{
packet.lookup({type_identifier}).map(|v| v.decode_string())
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -250,6 +250,9 @@ fn generate_user_password_attribute_code(
packet.add(AVP::encode_user_password({type_identifier}, value, packet.get_secret(), packet.get_authenticator())?);
Ok(())
}}
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()))
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -266,6 +269,9 @@ fn generate_octets_attribute_code(
"pub fn add_{method_identifier}(packet: &mut Packet, value: &[u8]) {{
packet.add(AVP::encode_bytes({type_identifier}, value));
}}
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Vec<u8>> {{
packet.lookup({type_identifier}).map(|v| v.decode_bytes())
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -282,6 +288,9 @@ fn generate_ipaddr_attribute_code(
"pub fn add_{method_identifier}(packet: &mut Packet, value: &Ipv4Addr) {{
packet.add(AVP::encode_ipv4({type_identifier}, value));
}}
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {{
packet.lookup({type_identifier}).map(|v| v.decode_ipv4())
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -298,6 +307,9 @@ fn generate_integer_attribute_code(
"pub fn add_{method_identifier}(packet: &mut Packet, value: u32) {{
packet.add(AVP::encode_u32({type_identifier}, value));
}}
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<Result<u32, AVPError>> {{
packet.lookup({type_identifier}).map(|v| v.decode_u32())
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,
@@ -315,6 +327,9 @@ fn generate_value_defined_integer_attribute_code(
"pub fn add_{method_identifier}(packet: &mut Packet, value: {value_type}) {{
packet.add(AVP::encode_u32({type_identifier}, value as u32));
}}
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}))
}}
",
method_identifier = method_identifier,
type_identifier = type_identifier,

10
examples/server.rs
View File

@@ -46,14 +46,8 @@ impl RequestHandler<(), io::Error> for MyRequestHandler {
let maybe_user_name_attr = rfc2865::lookup_user_name(req_packet);
let maybe_user_password_attr = rfc2865::lookup_user_password(req_packet);
let user_name = maybe_user_name_attr.unwrap().decode_string().unwrap();
let user_password = String::from_utf8(
maybe_user_password_attr
.unwrap()
.decode_user_password(req_packet.get_secret(), req_packet.get_authenticator())
.unwrap(),
)
.unwrap();
let user_name = maybe_user_name_attr.unwrap().unwrap();
let user_password = String::from_utf8(maybe_user_password_attr.unwrap().unwrap()).unwrap();
let code = if user_name == "admin" && user_password == "p@ssw0rd" {
Code::AccessAccept
} else {

289
src/rfc2865.rs
View File

@@ -83,23 +83,20 @@ pub const USER_NAME_TYPE: AVPType = 1;
pub fn delete_user_name(packet: &mut Packet) {
packet.delete(USER_NAME_TYPE);
}
pub fn lookup_user_name(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const USER_PASSWORD_TYPE: AVPType = 2;
pub fn delete_user_password(packet: &mut Packet) {
packet.delete(USER_PASSWORD_TYPE);
}
pub fn lookup_user_password(packet: &Packet) -> Option<&AVP> {
packet.lookup(USER_PASSWORD_TYPE)
}
pub fn lookup_all_user_password(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(USER_PASSWORD_TYPE)
}
@@ -112,308 +109,330 @@ pub fn add_user_password(packet: &mut Packet, value: &[u8]) -> Result<(), AVPErr
)?);
Ok(())
}
pub fn lookup_user_password(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
packet
.lookup(USER_PASSWORD_TYPE)
.map(|v| v.decode_user_password(packet.get_secret(), packet.get_authenticator()))
}
pub const CHAP_PASSWORD_TYPE: AVPType = 3;
pub fn delete_chap_password(packet: &mut Packet) {
packet.delete(CHAP_PASSWORD_TYPE);
}
pub fn lookup_chap_password(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 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_nas_ip_address(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const NAS_PORT_TYPE: AVPType = 5;
pub fn delete_nas_port(packet: &mut Packet) {
packet.delete(NAS_PORT_TYPE);
}
pub fn lookup_nas_port(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const SERVICE_TYPE_TYPE: AVPType = 6;
pub fn delete_service_type(packet: &mut Packet) {
packet.delete(SERVICE_TYPE_TYPE);
}
pub fn lookup_service_type(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_service_type(packet: &Packet) -> Option<Result<ServiceType, AVPError>> {
packet
.lookup(SERVICE_TYPE_TYPE)
.map(|v| Ok(v.decode_u32()? as ServiceType))
}
pub const FRAMED_PROTOCOL_TYPE: AVPType = 7;
pub fn delete_framed_protocol(packet: &mut Packet) {
packet.delete(FRAMED_PROTOCOL_TYPE);
}
pub fn lookup_framed_protocol(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_protocol(packet: &Packet) -> Option<Result<FramedProtocol, AVPError>> {
packet
.lookup(FRAMED_PROTOCOL_TYPE)
.map(|v| Ok(v.decode_u32()? as FramedProtocol))
}
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_framed_ip_address(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet
.lookup(FRAMED_IP_ADDRESS_TYPE)
.map(|v| v.decode_ipv4())
}
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_framed_ip_netmask(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet
.lookup(FRAMED_IP_NETMASK_TYPE)
.map(|v| v.decode_ipv4())
}
pub const FRAMED_ROUTING_TYPE: AVPType = 10;
pub fn delete_framed_routing(packet: &mut Packet) {
packet.delete(FRAMED_ROUTING_TYPE);
}
pub fn lookup_framed_routing(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_routing(packet: &Packet) -> Option<Result<FramedRouting, AVPError>> {
packet
.lookup(FRAMED_ROUTING_TYPE)
.map(|v| Ok(v.decode_u32()? as FramedRouting))
}
pub const FILTER_ID_TYPE: AVPType = 11;
pub fn delete_filter_id(packet: &mut Packet) {
packet.delete(FILTER_ID_TYPE);
}
pub fn lookup_filter_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const FRAMED_MTU_TYPE: AVPType = 12;
pub fn delete_framed_mtu(packet: &mut Packet) {
packet.delete(FRAMED_MTU_TYPE);
}
pub fn lookup_framed_mtu(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const FRAMED_COMPRESSION_TYPE: AVPType = 13;
pub fn delete_framed_compression(packet: &mut Packet) {
packet.delete(FRAMED_COMPRESSION_TYPE);
}
pub fn lookup_framed_compression(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_compression(packet: &Packet) -> Option<Result<FramedCompression, AVPError>> {
packet
.lookup(FRAMED_COMPRESSION_TYPE)
.map(|v| Ok(v.decode_u32()? as FramedCompression))
}
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_login_ip_host(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const LOGIN_SERVICE_TYPE: AVPType = 15;
pub fn delete_login_service(packet: &mut Packet) {
packet.delete(LOGIN_SERVICE_TYPE);
}
pub fn lookup_login_service(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_login_service(packet: &Packet) -> Option<Result<LoginService, AVPError>> {
packet
.lookup(LOGIN_SERVICE_TYPE)
.map(|v| Ok(v.decode_u32()? as LoginService))
}
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_login_tcp_port(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_login_tcp_port(packet: &Packet) -> Option<Result<LoginTCPPort, AVPError>> {
packet
.lookup(LOGIN_TCP_PORT_TYPE)
.map(|v| Ok(v.decode_u32()? as LoginTCPPort))
}
pub const REPLY_MESSAGE_TYPE: AVPType = 18;
pub fn delete_reply_message(packet: &mut Packet) {
packet.delete(REPLY_MESSAGE_TYPE);
}
pub fn lookup_reply_message(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const CALLBACK_NUMBER_TYPE: AVPType = 19;
pub fn delete_callback_number(packet: &mut Packet) {
packet.delete(CALLBACK_NUMBER_TYPE);
}
pub fn lookup_callback_number(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_callback_number(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(CALLBACK_NUMBER_TYPE)
.map(|v| v.decode_string())
}
pub const CALLBACK_ID_TYPE: AVPType = 20;
pub fn delete_callback_id(packet: &mut Packet) {
packet.delete(CALLBACK_ID_TYPE);
}
pub fn lookup_callback_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const FRAMED_ROUTE_TYPE: AVPType = 22;
pub fn delete_framed_route(packet: &mut Packet) {
packet.delete(FRAMED_ROUTE_TYPE);
}
pub fn lookup_framed_route(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 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_framed_ipx_network(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet
.lookup(FRAMED_IPX_NETWORK_TYPE)
.map(|v| v.decode_ipv4())
}
pub const STATE_TYPE: AVPType = 24;
pub fn delete_state(packet: &mut Packet) {
packet.delete(STATE_TYPE);
}
pub fn lookup_state(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const CLASS_TYPE: AVPType = 25;
pub fn delete_class(packet: &mut Packet) {
packet.delete(CLASS_TYPE);
}
pub fn lookup_class(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const VENDOR_SPECIFIC_TYPE: AVPType = 26;
pub fn delete_vendor_specific(packet: &mut Packet) {
packet.delete(VENDOR_SPECIFIC_TYPE);
}
pub fn lookup_vendor_specific(packet: &Packet) -> Option<&AVP> {
packet.lookup(VENDOR_SPECIFIC_TYPE)
}
pub fn lookup_all_vendor_specific(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(VENDOR_SPECIFIC_TYPE)
}
@@ -422,236 +441,260 @@ pub const SESSION_TIMEOUT_TYPE: AVPType = 27;
pub fn delete_session_timeout(packet: &mut Packet) {
packet.delete(SESSION_TIMEOUT_TYPE);
}
pub fn lookup_session_timeout(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const IDLE_TIMEOUT_TYPE: AVPType = 28;
pub fn delete_idle_timeout(packet: &mut Packet) {
packet.delete(IDLE_TIMEOUT_TYPE);
}
pub fn lookup_idle_timeout(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 const TERMINATION_ACTION_TYPE: AVPType = 29;
pub fn delete_termination_action(packet: &mut Packet) {
packet.delete(TERMINATION_ACTION_TYPE);
}
pub fn lookup_termination_action(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_termination_action(packet: &Packet) -> Option<Result<TerminationAction, AVPError>> {
packet
.lookup(TERMINATION_ACTION_TYPE)
.map(|v| Ok(v.decode_u32()? as TerminationAction))
}
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_called_station_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_called_station_id(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(CALLED_STATION_ID_TYPE)
.map(|v| v.decode_string())
}
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_calling_station_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_calling_station_id(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(CALLING_STATION_ID_TYPE)
.map(|v| v.decode_string())
}
pub const NAS_IDENTIFIER_TYPE: AVPType = 32;
pub fn delete_nas_identifier(packet: &mut Packet) {
packet.delete(NAS_IDENTIFIER_TYPE);
}
pub fn lookup_nas_identifier(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_nas_identifier(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(NAS_IDENTIFIER_TYPE)
.map(|v| v.decode_string())
}
pub const PROXY_STATE_TYPE: AVPType = 33;
pub fn delete_proxy_state(packet: &mut Packet) {
packet.delete(PROXY_STATE_TYPE);
}
pub fn lookup_proxy_state(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 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_login_lat_service(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_login_lat_service(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(LOGIN_LAT_SERVICE_TYPE)
.map(|v| v.decode_string())
}
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_login_lat_node(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_login_lat_node(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(LOGIN_LAT_NODE_TYPE)
.map(|v| v.decode_string())
}
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_login_lat_group(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_login_lat_group(packet: &Packet) -> Option<Vec<u8>> {
packet
.lookup(LOGIN_LAT_GROUP_TYPE)
.map(|v| v.decode_bytes())
}
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_framed_apple_talk_link(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(FRAMED_APPLE_TALK_LINK_TYPE)
.map(|v| v.decode_u32())
}
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_framed_apple_talk_network(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(FRAMED_APPLE_TALK_NETWORK_TYPE)
.map(|v| v.decode_u32())
}
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_framed_apple_talk_zone(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(FRAMED_APPLE_TALK_ZONE_TYPE)
.map(|v| v.decode_string())
}
pub const CHAP_CHALLENGE_TYPE: AVPType = 60;
pub fn delete_chap_challenge(packet: &mut Packet) {
packet.delete(CHAP_CHALLENGE_TYPE);
}
pub fn lookup_chap_challenge(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 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_nas_port_type(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_nas_port_type(packet: &Packet) -> Option<Result<NasPortType, AVPError>> {
packet
.lookup(NAS_PORT_TYPE_TYPE)
.map(|v| Ok(v.decode_u32()? as NasPortType))
}
pub const PORT_LIMIT_TYPE: AVPType = 62;
pub fn delete_port_limit(packet: &mut Packet) {
packet.delete(PORT_LIMIT_TYPE);
}
pub fn lookup_port_limit(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 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_login_lat_port(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_login_lat_port(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(LOGIN_LAT_PORT_TYPE)
.map(|v| v.decode_string())
}

96
src/rfc2866.rs
View File

@@ -1,6 +1,6 @@
// Code generated by machine generator; DO NOT EDIT.
use crate::avp::{AVPType, AVP};
use crate::avp::{AVPError, AVPType, AVP};
use crate::packet::Packet;
pub type AcctAuthentic = u32;
@@ -42,166 +42,188 @@ 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_acct_status_type(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_status_type(packet: &Packet) -> Option<Result<AcctStatusType, AVPError>> {
packet
.lookup(ACCT_STATUS_TYPE_TYPE)
.map(|v| Ok(v.decode_u32()? as AcctStatusType))
}
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_acct_delay_time(packet: &Packet) -> Option<&AVP> {
packet.lookup(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 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_acct_input_octets(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_input_octets(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(ACCT_INPUT_OCTETS_TYPE)
.map(|v| v.decode_u32())
}
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_acct_output_octets(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_output_octets(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(ACCT_OUTPUT_OCTETS_TYPE)
.map(|v| v.decode_u32())
}
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_acct_session_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_session_id(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(ACCT_SESSION_ID_TYPE)
.map(|v| v.decode_string())
}
pub const ACCT_AUTHENTIC_TYPE: AVPType = 45;
pub fn delete_acct_authentic(packet: &mut Packet) {
packet.delete(ACCT_AUTHENTIC_TYPE);
}
pub fn lookup_acct_authentic(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_authentic(packet: &Packet) -> Option<Result<AcctAuthentic, AVPError>> {
packet
.lookup(ACCT_AUTHENTIC_TYPE)
.map(|v| Ok(v.decode_u32()? as AcctAuthentic))
}
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_acct_session_time(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_session_time(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(ACCT_SESSION_TIME_TYPE)
.map(|v| v.decode_u32())
}
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_acct_input_packets(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_input_packets(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(ACCT_INPUT_PACKETS_TYPE)
.map(|v| v.decode_u32())
}
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_acct_output_packets(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_output_packets(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(ACCT_OUTPUT_PACKETS_TYPE)
.map(|v| v.decode_u32())
}
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_acct_terminate_cause(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_terminate_cause(
packet: &Packet,
) -> Option<Result<AcctTerminateCause, AVPError>> {
packet
.lookup(ACCT_TERMINATE_CAUSE_TYPE)
.map(|v| Ok(v.decode_u32()? as AcctTerminateCause))
}
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_acct_multi_session_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(ACCT_MULTI_SESSION_ID_TYPE)
.map(|v| v.decode_string())
}
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_acct_link_count(packet: &Packet) -> Option<&AVP> {
packet.lookup(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())
}

18
src/rfc2867.rs
View File

@@ -1,6 +1,6 @@
// Code generated by machine generator; DO NOT EDIT.
use crate::avp::{AVPType, AVP};
use crate::avp::{AVPError, AVPType, AVP};
use crate::packet::Packet;
pub type AcctStatusType = u32;
@@ -15,26 +15,30 @@ 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_acct_tunnel_connection(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(ACCT_TUNNEL_CONNECTION_TYPE)
.map(|v| v.decode_string())
}
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_acct_tunnel_packets_lost(packet: &Packet) -> Option<&AVP> {
packet.lookup(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));
}
pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<Result<u32, AVPError>> {
packet
.lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE)
.map(|v| v.decode_u32())
}