Restructure

Cargo.toml

@@ -2,8 +2,6 @@
 
 members = [
   "radius",
-  "radius-server",
-  "radius-client",
 
   # Internal
   "code-generator",

code-generator/src/main.rs

@@ -167,16 +167,16 @@ use std::net::{Ipv4Addr, Ipv6Addr};
 
 use chrono::{DateTime, Utc};
 
-use crate::avp::{AVP, AVPType, AVPError};
+use crate::core::avp::{AVP, AVPType, AVPError};
-use crate::packet::Packet;
+use crate::core::packet::Packet;
-use crate::tag::Tag;
+use crate::core::tag::Tag;
 
 ";
 
     w.write_all(code).unwrap();
 
     for rfc_name in rfc_names {
-        w.write_all(format!("use crate::{};\n", rfc_name).as_bytes())
+        w.write_all(format!("use crate::core::{};\n", rfc_name).as_bytes())
             .unwrap();
     }
 }

e2e-test/Cargo.toml

@@ -7,7 +7,5 @@ publish = false
 
 [dependencies]
 radius = { version = "0.1.0", path = "../radius" }
-radius-client = { version = "0.1.0", path = "../radius-client" }
-radius-server = { version = "0.1.0", path = "../radius-server" }
 tokio = { version = "0.3.5", features = ["signal", "net"] }
 async-trait = "0.1.42"

e2e-test/src/test.rs

@@ -6,11 +6,10 @@ use async_trait::async_trait;
 use tokio::net::UdpSocket;
 use tokio::time::sleep;
 
-use radius::code::Code;
+use radius::core::code::Code;
-use radius::request::Request;
+use radius::core::request::Request;
-use radius::rfc2865;
+use radius::core::rfc2865;
-use radius_server::request_handler::RequestHandler;
+use radius::server::{RequestHandler, SecretProvider, SecretProviderError};
-use radius_server::secret_provider::{SecretProvider, SecretProviderError};
 
 struct MyRequestHandler {}
 
@@ -75,11 +74,11 @@ mod tests {
 
     use tokio::sync::oneshot;
 
-    use radius::code::Code;
+    use radius::client::{Client, ClientError};
-    use radius::packet::Packet;
+    use radius::core::code::Code;
-    use radius::rfc2865;
+    use radius::core::packet::Packet;
-    use radius_client::client::{Client, ClientError};
+    use radius::core::rfc2865;
-    use radius_server::server::Server;
+    use radius::server::Server;
 
     use crate::test::{LongTimeTakingHandler, MyRequestHandler, MySecretProvider};
 

examples/Cargo.toml

@@ -8,8 +8,6 @@ repository = "https://github.com/moznion/radius-rs"
 
 [dev-dependencies]
 radius = { version = "0.1.0", path = "../radius" }
-radius-client = { version = "0.1.0", path = "../radius-client" }
-radius-server = { version = "0.1.0", path = "../radius-server" }
 log = "0.4.11"
 env_logger = "0.8.2"
 tokio = { version = "0.3.4", features = ["signal", "net"] }

examples/client.rs

@@ -1,9 +1,9 @@
 #[macro_use]
 extern crate log;
-use radius::code::Code;
+use radius::client::Client;
-use radius::packet::Packet;
+use radius::core::code::Code;
-use radius::rfc2865;
+use radius::core::packet::Packet;
-use radius_client::client::Client;
+use radius::core::rfc2865;
 use std::net::SocketAddr;
 use tokio::time::Duration;
 

examples/server.rs

@@ -8,12 +8,10 @@ use async_trait::async_trait;
 use tokio::net::UdpSocket;
 use tokio::signal;
 
-use radius::code::Code;
+use radius::core::code::Code;
-use radius::request::Request;
+use radius::core::request::Request;
-use radius::rfc2865;
+use radius::core::rfc2865;
-use radius_server::request_handler::RequestHandler;
+use radius::server::{RequestHandler, SecretProvider, SecretProviderError, Server};
-use radius_server::secret_provider::{SecretProvider, SecretProviderError};
-use radius_server::server::Server;
 
 #[tokio::main]
 async fn main() {

radius-client/Cargo.toml

@@ -1,13 +0,0 @@
-[package]
-name = "radius-client"
-version = "0.1.0"
-authors = ["moznion <moznion@gmail.com>"]
-edition = "2018"
-license-file = "../LICENSE"
-repository = "https://github.com/moznion/radius-rs"
-keywords = ["radius", "client"]
-
-[dependencies]
-radius = { path = "../radius" }
-tokio = { version = "0.3.5", features = ["net", "time"] }
-thiserror = "1.0"

radius-client/src/lib.rs

@@ -1 +0,0 @@
-pub mod client;

radius-server/Cargo.toml

@@ -1,15 +0,0 @@
-[package]
-name = "radius-server"
-version = "0.1.0"
-authors = ["moznion <moznion@gmail.com>"]
-edition = "2018"
-license-file = "../LICENSE"
-repository = "https://github.com/moznion/radius-rs"
-keywords = ["radius", "client"]
-
-[dependencies]
-radius = { path = "../radius" }
-tokio = { version = "0.3.5", features = ["full"] }
-log = "0.4.11"
-thiserror = "1.0"
-async-trait = "0.1.42"

radius-server/src/lib.rs

@@ -1,6 +0,0 @@
-#[macro_use]
-extern crate log;
-
-pub mod request_handler;
-pub mod secret_provider;
-pub mod server;

radius-server/src/request_handler.rs

@@ -1,17 +0,0 @@
-use async_trait::async_trait;
-use tokio::net::UdpSocket;
-
-use radius::request::Request;
-
-/// RequestHandler is a handler for the received RADIUS request.
-#[async_trait]
-pub trait RequestHandler<T, E>: 'static + Sync + Send {
-    /// This method has to implement the core feature of the server application what you need.
-    ///
-    /// # Arguments
-    ///
-    /// * conn - This connection is associated with the remote requester. In the most situations,
-    ///          you have to send a response through this connection object.
-    /// * request - This is a request object that comes from the remote requester.
-    async fn handle_radius_request(&self, conn: &UdpSocket, request: &Request) -> Result<T, E>;
-}

radius-server/src/secret_provider.rs

@@ -1,20 +0,0 @@
-use std::net::SocketAddr;
-
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum SecretProviderError {
-    /// An error that represents a failure to fetch a secret value from the provider.
-    #[error("failed to fetch a secret value: {0}")]
-    FailedFetchingError(String),
-    /// An error that represents a generic (i.e. unclassified) error that occurs on the secret value provider.
-    #[error("unexpected error: {0}")]
-    GenericError(String),
-}
-
-/// SecretProvider is a provider for secret value.
-pub trait SecretProvider: 'static + Sync + Send {
-    /// This method has to implement the generator of the secret value to verify the request of
-    /// `Accounting-Response`, `Accounting-Response` and `CoA-Request`.
-    fn fetch_secret(&self, remote_addr: SocketAddr) -> Result<Vec<u8>, SecretProviderError>;
-}

radius/src/client.rs

@@ -5,7 +5,7 @@ use thiserror::Error;
 use tokio::net::UdpSocket;
 use tokio::time::timeout;
 
-use radius::packet::Packet;
+use crate::core::packet::Packet;
 
 #[derive(Error, Debug)]
 pub enum ClientError {

radius/src/core/attributes.rs

@@ -1,4 +1,4 @@
-use crate::avp::{AVPType, AVP};
+use crate::core::avp::{AVPType, AVP};
 
 #[derive(Debug, Clone, PartialEq)]
 pub(crate) struct Attributes(pub(crate) Vec<AVP>);

radius/src/core/avp.rs

@@ -5,7 +5,7 @@ use std::net::{Ipv4Addr, Ipv6Addr};
 use chrono::{DateTime, TimeZone, Utc};
 use thiserror::Error;
 
-use crate::tag::{Tag, UNUSED_TAG_VALUE};
+use crate::core::tag::{Tag, UNUSED_TAG_VALUE};
 
 #[derive(Error, PartialEq, Debug)]
 pub enum AVPError {
@@ -631,8 +631,8 @@ mod tests {
 
     use chrono::Utc;
 
-    use crate::avp::{AVPError, AVP};
+    use crate::core::avp::{AVPError, AVP};
-    use crate::tag::Tag;
+    use crate::core::tag::Tag;
 
     #[test]
     fn it_should_convert_attribute_to_integer32() -> Result<(), AVPError> {

radius/src/core/mod.rs

@@ -0,0 +1,30 @@
+pub(crate) mod attributes;
+pub mod avp;
+pub mod code;
+pub mod packet;
+pub mod request;
+pub mod rfc2865;
+pub mod rfc2866;
+pub mod rfc2867;
+pub mod rfc2868;
+pub mod rfc2869;
+pub mod rfc3162;
+pub mod rfc3576;
+pub mod rfc3580;
+pub mod rfc4072;
+pub mod rfc4372;
+pub mod rfc4603;
+pub mod rfc4675;
+pub mod rfc4818;
+pub mod rfc4849;
+pub mod rfc5090;
+pub mod rfc5176;
+pub mod rfc5607;
+pub mod rfc5904;
+pub mod rfc6519;
+pub mod rfc6572;
+pub mod rfc6677;
+pub mod rfc6911;
+pub mod rfc7055;
+pub mod rfc7155;
+pub mod tag;

radius/src/core/packet.rs

@@ -3,9 +3,9 @@ use std::convert::TryInto;
 use rand::Rng;
 use thiserror::Error;
 
-use crate::attributes::Attributes;
+use crate::core::attributes::Attributes;
-use crate::avp::{AVPType, AVP};
+use crate::core::avp::{AVPType, AVP};
-use crate::code::Code;
+use crate::core::code::Code;
 
 const MAX_PACKET_LENGTH: usize = 4096;
 const RADIUS_PACKET_HEADER_LENGTH: usize = 20; // i.e. minimum packet length
@@ -293,10 +293,12 @@ impl Packet {
 mod tests {
     use std::net::Ipv4Addr;
 
-    use crate::avp::AVP;
+    use crate::core::avp::AVP;
-    use crate::code::Code;
+    use crate::core::code::Code;
-    use crate::packet::{Packet, PacketError, MAX_PACKET_LENGTH, RADIUS_PACKET_HEADER_LENGTH};
+    use crate::core::packet::{
-    use crate::rfc2865;
+        Packet, PacketError, MAX_PACKET_LENGTH, RADIUS_PACKET_HEADER_LENGTH,
+    };
+    use crate::core::rfc2865;
 
     #[test]
     fn test_for_rfc2865_7_1() -> Result<(), PacketError> {

radius/src/core/request.rs

@@ -1,6 +1,6 @@
 use std::net::SocketAddr;
 
-use crate::packet::Packet;
+use crate::core::packet::Packet;
 
 /// RADIUS request object.
 pub struct Request {

radius/src/core/rfc2865.rs

@@ -1,9 +1,13 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use std::net::Ipv4Addr;
+use std::net::{Ipv4Addr};
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
 
-use crate::avp::{AVPError, AVPType, AVP};
-use crate::packet::Packet;
 
 pub const USER_NAME_TYPE: AVPType = 1;
 pub fn delete_user_name(packet: &mut Packet) {
@@ -28,18 +32,11 @@ 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::from_user_password(
+    packet.add(AVP::from_user_password(USER_PASSWORD_TYPE, value, packet.get_secret(), packet.get_authenticator())?);
-        USER_PASSWORD_TYPE,
-        value,
-        packet.get_secret(),
-        packet.get_authenticator(),
-    )?);
     Ok(())
 }
 pub fn lookup_user_password(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(USER_PASSWORD_TYPE).map(|v| v.encode_user_password(packet.get_secret(), packet.get_authenticator()))
-        .lookup(USER_PASSWORD_TYPE)
-        .map(|v| v.encode_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();
@@ -111,9 +108,7 @@ pub fn add_service_type(packet: &mut Packet, value: ServiceType) {
     packet.add(AVP::from_u32(SERVICE_TYPE_TYPE, value as u32));
 }
 pub fn lookup_service_type(packet: &Packet) -> Option<Result<ServiceType, AVPError>> {
-    packet
+    packet.lookup(SERVICE_TYPE_TYPE).map(|v| Ok(v.encode_u32()? as ServiceType))
-        .lookup(SERVICE_TYPE_TYPE)
-        .map(|v| Ok(v.encode_u32()? as ServiceType))
 }
 pub fn lookup_all_service_type(packet: &Packet) -> Result<Vec<ServiceType>, AVPError> {
     let mut vec = Vec::new();
@@ -131,9 +126,7 @@ pub fn add_framed_protocol(packet: &mut Packet, value: FramedProtocol) {
     packet.add(AVP::from_u32(FRAMED_PROTOCOL_TYPE, value as u32));
 }
 pub fn lookup_framed_protocol(packet: &Packet) -> Option<Result<FramedProtocol, AVPError>> {
-    packet
+    packet.lookup(FRAMED_PROTOCOL_TYPE).map(|v| Ok(v.encode_u32()? as FramedProtocol))
-        .lookup(FRAMED_PROTOCOL_TYPE)
-        .map(|v| Ok(v.encode_u32()? as FramedProtocol))
 }
 pub fn lookup_all_framed_protocol(packet: &Packet) -> Result<Vec<FramedProtocol>, AVPError> {
     let mut vec = Vec::new();
@@ -151,9 +144,7 @@ pub fn add_framed_ip_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(FRAMED_IP_ADDRESS_TYPE, value));
 }
 pub fn lookup_framed_ip_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
+    packet.lookup(FRAMED_IP_ADDRESS_TYPE).map(|v| v.encode_ipv4())
-        .lookup(FRAMED_IP_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv4())
 }
 pub fn lookup_all_framed_ip_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -171,9 +162,7 @@ pub fn add_framed_ip_netmask(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(FRAMED_IP_NETMASK_TYPE, value));
 }
 pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
+    packet.lookup(FRAMED_IP_NETMASK_TYPE).map(|v| v.encode_ipv4())
-        .lookup(FRAMED_IP_NETMASK_TYPE)
-        .map(|v| v.encode_ipv4())
 }
 pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -191,9 +180,7 @@ pub fn add_framed_routing(packet: &mut Packet, value: FramedRouting) {
     packet.add(AVP::from_u32(FRAMED_ROUTING_TYPE, value as u32));
 }
 pub fn lookup_framed_routing(packet: &Packet) -> Option<Result<FramedRouting, AVPError>> {
-    packet
+    packet.lookup(FRAMED_ROUTING_TYPE).map(|v| Ok(v.encode_u32()? as FramedRouting))
-        .lookup(FRAMED_ROUTING_TYPE)
-        .map(|v| Ok(v.encode_u32()? as FramedRouting))
 }
 pub fn lookup_all_framed_routing(packet: &Packet) -> Result<Vec<FramedRouting>, AVPError> {
     let mut vec = Vec::new();
@@ -247,9 +234,7 @@ pub fn add_framed_compression(packet: &mut Packet, value: FramedCompression) {
     packet.add(AVP::from_u32(FRAMED_COMPRESSION_TYPE, value as u32));
 }
 pub fn lookup_framed_compression(packet: &Packet) -> Option<Result<FramedCompression, AVPError>> {
-    packet
+    packet.lookup(FRAMED_COMPRESSION_TYPE).map(|v| Ok(v.encode_u32()? as FramedCompression))
-        .lookup(FRAMED_COMPRESSION_TYPE)
-        .map(|v| Ok(v.encode_u32()? as FramedCompression))
 }
 pub fn lookup_all_framed_compression(packet: &Packet) -> Result<Vec<FramedCompression>, AVPError> {
     let mut vec = Vec::new();
@@ -285,9 +270,7 @@ pub fn add_login_service(packet: &mut Packet, value: LoginService) {
     packet.add(AVP::from_u32(LOGIN_SERVICE_TYPE, value as u32));
 }
 pub fn lookup_login_service(packet: &Packet) -> Option<Result<LoginService, AVPError>> {
-    packet
+    packet.lookup(LOGIN_SERVICE_TYPE).map(|v| Ok(v.encode_u32()? as LoginService))
-        .lookup(LOGIN_SERVICE_TYPE)
-        .map(|v| Ok(v.encode_u32()? as LoginService))
 }
 pub fn lookup_all_login_service(packet: &Packet) -> Result<Vec<LoginService>, AVPError> {
     let mut vec = Vec::new();
@@ -305,9 +288,7 @@ pub fn add_login_tcp_port(packet: &mut Packet, value: LoginTCPPort) {
     packet.add(AVP::from_u32(LOGIN_TCP_PORT_TYPE, value as u32));
 }
 pub fn lookup_login_tcp_port(packet: &Packet) -> Option<Result<LoginTCPPort, AVPError>> {
-    packet
+    packet.lookup(LOGIN_TCP_PORT_TYPE).map(|v| Ok(v.encode_u32()? as LoginTCPPort))
-        .lookup(LOGIN_TCP_PORT_TYPE)
-        .map(|v| Ok(v.encode_u32()? as LoginTCPPort))
 }
 pub fn lookup_all_login_tcp_port(packet: &Packet) -> Result<Vec<LoginTCPPort>, AVPError> {
     let mut vec = Vec::new();
@@ -343,9 +324,7 @@ pub fn add_callback_number(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(CALLBACK_NUMBER_TYPE, value));
 }
 pub fn lookup_callback_number(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(CALLBACK_NUMBER_TYPE).map(|v| v.encode_string())
-        .lookup(CALLBACK_NUMBER_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_callback_number(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -399,9 +378,7 @@ pub fn add_framed_ipx_network(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(FRAMED_IPX_NETWORK_TYPE, value));
 }
 pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
+    packet.lookup(FRAMED_IPX_NETWORK_TYPE).map(|v| v.encode_ipv4())
-        .lookup(FRAMED_IPX_NETWORK_TYPE)
-        .map(|v| v.encode_ipv4())
 }
 pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -496,9 +473,7 @@ pub fn add_termination_action(packet: &mut Packet, value: TerminationAction) {
     packet.add(AVP::from_u32(TERMINATION_ACTION_TYPE, value as u32));
 }
 pub fn lookup_termination_action(packet: &Packet) -> Option<Result<TerminationAction, AVPError>> {
-    packet
+    packet.lookup(TERMINATION_ACTION_TYPE).map(|v| Ok(v.encode_u32()? as TerminationAction))
-        .lookup(TERMINATION_ACTION_TYPE)
-        .map(|v| Ok(v.encode_u32()? as TerminationAction))
 }
 pub fn lookup_all_termination_action(packet: &Packet) -> Result<Vec<TerminationAction>, AVPError> {
     let mut vec = Vec::new();
@@ -516,9 +491,7 @@ pub fn add_called_station_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(CALLED_STATION_ID_TYPE, value));
 }
 pub fn lookup_called_station_id(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(CALLED_STATION_ID_TYPE).map(|v| v.encode_string())
-        .lookup(CALLED_STATION_ID_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_called_station_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -536,9 +509,7 @@ pub fn add_calling_station_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(CALLING_STATION_ID_TYPE, value));
 }
 pub fn lookup_calling_station_id(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(CALLING_STATION_ID_TYPE).map(|v| v.encode_string())
-        .lookup(CALLING_STATION_ID_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_calling_station_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -556,9 +527,7 @@ pub fn add_nas_identifier(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(NAS_IDENTIFIER_TYPE, value));
 }
 pub fn lookup_nas_identifier(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(NAS_IDENTIFIER_TYPE).map(|v| v.encode_string())
-        .lookup(NAS_IDENTIFIER_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_nas_identifier(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -594,9 +563,7 @@ pub fn add_login_lat_service(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(LOGIN_LAT_SERVICE_TYPE, value));
 }
 pub fn lookup_login_lat_service(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(LOGIN_LAT_SERVICE_TYPE).map(|v| v.encode_string())
-        .lookup(LOGIN_LAT_SERVICE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_login_lat_service(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -614,9 +581,7 @@ pub fn add_login_lat_node(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(LOGIN_LAT_NODE_TYPE, value));
 }
 pub fn lookup_login_lat_node(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(LOGIN_LAT_NODE_TYPE).map(|v| v.encode_string())
-        .lookup(LOGIN_LAT_NODE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_login_lat_node(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -634,9 +599,7 @@ pub fn add_login_lat_group(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(LOGIN_LAT_GROUP_TYPE, value));
 }
 pub fn lookup_login_lat_group(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(LOGIN_LAT_GROUP_TYPE).map(|v| v.encode_bytes())
-        .lookup(LOGIN_LAT_GROUP_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -654,9 +617,7 @@ pub fn add_framed_apple_talk_link(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(FRAMED_APPLE_TALK_LINK_TYPE, value));
 }
 pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(FRAMED_APPLE_TALK_LINK_TYPE).map(|v| v.encode_u32())
-        .lookup(FRAMED_APPLE_TALK_LINK_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -674,9 +635,7 @@ pub fn add_framed_apple_talk_network(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(FRAMED_APPLE_TALK_NETWORK_TYPE, value));
 }
 pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(FRAMED_APPLE_TALK_NETWORK_TYPE).map(|v| v.encode_u32())
-        .lookup(FRAMED_APPLE_TALK_NETWORK_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -694,9 +653,7 @@ pub fn add_framed_apple_talk_zone(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(FRAMED_APPLE_TALK_ZONE_TYPE, value));
 }
 pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(FRAMED_APPLE_TALK_ZONE_TYPE).map(|v| v.encode_string())
-        .lookup(FRAMED_APPLE_TALK_ZONE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -732,9 +689,7 @@ pub fn add_nas_port_type(packet: &mut Packet, value: NasPortType) {
     packet.add(AVP::from_u32(NAS_PORT_TYPE_TYPE, value as u32));
 }
 pub fn lookup_nas_port_type(packet: &Packet) -> Option<Result<NasPortType, AVPError>> {
-    packet
+    packet.lookup(NAS_PORT_TYPE_TYPE).map(|v| Ok(v.encode_u32()? as NasPortType))
-        .lookup(NAS_PORT_TYPE_TYPE)
-        .map(|v| Ok(v.encode_u32()? as NasPortType))
 }
 pub fn lookup_all_nas_port_type(packet: &Packet) -> Result<Vec<NasPortType>, AVPError> {
     let mut vec = Vec::new();
@@ -770,9 +725,7 @@ pub fn add_login_lat_port(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(LOGIN_LAT_PORT_TYPE, value));
 }
 pub fn lookup_login_lat_port(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(LOGIN_LAT_PORT_TYPE).map(|v| v.encode_string())
-        .lookup(LOGIN_LAT_PORT_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_login_lat_port(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -788,6 +741,7 @@ pub const FRAMED_COMPRESSION_VAN_JACOBSON_TCP_IP: FramedCompression = 1;
 pub const FRAMED_COMPRESSION_IPX_HEADER_COMPRESSION: FramedCompression = 2;
 pub const FRAMED_COMPRESSION_STAC_LZS: FramedCompression = 3;
 
+
 pub type FramedProtocol = u32;
 pub const FRAMED_PROTOCOL_PPP: FramedProtocol = 1;
 pub const FRAMED_PROTOCOL_SLIP: FramedProtocol = 2;
@@ -796,12 +750,14 @@ pub const FRAMED_PROTOCOL_GANDALF_SLML: FramedProtocol = 4;
 pub const FRAMED_PROTOCOL_XYLOGICS_IPX_SLIP: FramedProtocol = 5;
 pub const FRAMED_PROTOCOL_X_75_SYNCHRONOUS: FramedProtocol = 6;
 
+
 pub type FramedRouting = u32;
 pub const FRAMED_ROUTING_NONE: FramedRouting = 0;
 pub const FRAMED_ROUTING_BROADCAST: FramedRouting = 1;
 pub const FRAMED_ROUTING_LISTEN: FramedRouting = 2;
 pub const FRAMED_ROUTING_BROADCAST_LISTEN: FramedRouting = 3;
 
+
 pub type LoginService = u32;
 pub const LOGIN_SERVICE_TELNET: LoginService = 0;
 pub const LOGIN_SERVICE_RLOGIN: LoginService = 1;
@@ -812,11 +768,13 @@ pub const LOGIN_SERVICE_X25_PAD: LoginService = 5;
 pub const LOGIN_SERVICE_X25_T3POS: LoginService = 6;
 pub const LOGIN_SERVICE_TCP_CLEAR_QUIET: LoginService = 8;
 
+
 pub type LoginTCPPort = u32;
 pub const LOGIN_TCP_PORT_TELNET: LoginTCPPort = 23;
 pub const LOGIN_TCP_PORT_RLOGIN: LoginTCPPort = 513;
 pub const LOGIN_TCP_PORT_RSH: LoginTCPPort = 514;
 
+
 pub type NasPortType = u32;
 pub const NAS_PORT_TYPE_ASYNC: NasPortType = 0;
 pub const NAS_PORT_TYPE_SYNC: NasPortType = 1;
@@ -839,6 +797,7 @@ pub const NAS_PORT_TYPE_CABLE: NasPortType = 17;
 pub const NAS_PORT_TYPE_WIRELESS_OTHER: NasPortType = 18;
 pub const NAS_PORT_TYPE_WIRELESS_802_11: NasPortType = 19;
 
+
 pub type ServiceType = u32;
 pub const SERVICE_TYPE_LOGIN_USER: ServiceType = 1;
 pub const SERVICE_TYPE_FRAMED_USER: ServiceType = 2;
@@ -852,6 +811,8 @@ pub const SERVICE_TYPE_CALLBACK_NAS_PROMPT: ServiceType = 9;
 pub const SERVICE_TYPE_CALL_CHECK: ServiceType = 10;
 pub const SERVICE_TYPE_CALLBACK_ADMINISTRATIVE: ServiceType = 11;
 
+
 pub type TerminationAction = u32;
 pub const TERMINATION_ACTION_DEFAULT: TerminationAction = 0;
 pub const TERMINATION_ACTION_RADIUS_REQUEST: TerminationAction = 1;
+

radius/src/core/rfc2866.rs

@@ -1,7 +1,14 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
 
 pub const ACCT_STATUS_TYPE_TYPE: AVPType = 40;
 pub fn delete_acct_status_type(packet: &mut Packet) {
@@ -11,9 +18,7 @@ pub fn add_acct_status_type(packet: &mut Packet, value: AcctStatusType) {
     packet.add(AVP::from_u32(ACCT_STATUS_TYPE_TYPE, value as u32));
 }
 pub fn lookup_acct_status_type(packet: &Packet) -> Option<Result<AcctStatusType, AVPError>> {
-    packet
+    packet.lookup(ACCT_STATUS_TYPE_TYPE).map(|v| Ok(v.encode_u32()? as AcctStatusType))
-        .lookup(ACCT_STATUS_TYPE_TYPE)
-        .map(|v| Ok(v.encode_u32()? as AcctStatusType))
 }
 pub fn lookup_all_acct_status_type(packet: &Packet) -> Result<Vec<AcctStatusType>, AVPError> {
     let mut vec = Vec::new();
@@ -49,9 +54,7 @@ pub fn add_acct_input_octets(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_INPUT_OCTETS_TYPE, value));
 }
 pub fn lookup_acct_input_octets(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_INPUT_OCTETS_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_INPUT_OCTETS_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_input_octets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -69,9 +72,7 @@ pub fn add_acct_output_octets(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_OUTPUT_OCTETS_TYPE, value));
 }
 pub fn lookup_acct_output_octets(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_OUTPUT_OCTETS_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_OUTPUT_OCTETS_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_output_octets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -89,9 +90,7 @@ pub fn add_acct_session_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(ACCT_SESSION_ID_TYPE, value));
 }
 pub fn lookup_acct_session_id(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(ACCT_SESSION_ID_TYPE).map(|v| v.encode_string())
-        .lookup(ACCT_SESSION_ID_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_acct_session_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -109,9 +108,7 @@ pub fn add_acct_authentic(packet: &mut Packet, value: AcctAuthentic) {
     packet.add(AVP::from_u32(ACCT_AUTHENTIC_TYPE, value as u32));
 }
 pub fn lookup_acct_authentic(packet: &Packet) -> Option<Result<AcctAuthentic, AVPError>> {
-    packet
+    packet.lookup(ACCT_AUTHENTIC_TYPE).map(|v| Ok(v.encode_u32()? as AcctAuthentic))
-        .lookup(ACCT_AUTHENTIC_TYPE)
-        .map(|v| Ok(v.encode_u32()? as AcctAuthentic))
 }
 pub fn lookup_all_acct_authentic(packet: &Packet) -> Result<Vec<AcctAuthentic>, AVPError> {
     let mut vec = Vec::new();
@@ -129,9 +126,7 @@ pub fn add_acct_session_time(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_SESSION_TIME_TYPE, value));
 }
 pub fn lookup_acct_session_time(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_SESSION_TIME_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_SESSION_TIME_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_session_time(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -149,9 +144,7 @@ pub fn add_acct_input_packets(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_INPUT_PACKETS_TYPE, value));
 }
 pub fn lookup_acct_input_packets(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_INPUT_PACKETS_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_INPUT_PACKETS_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_input_packets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -169,9 +162,7 @@ pub fn add_acct_output_packets(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_OUTPUT_PACKETS_TYPE, value));
 }
 pub fn lookup_acct_output_packets(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_OUTPUT_PACKETS_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_OUTPUT_PACKETS_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_output_packets(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -188,16 +179,10 @@ pub fn delete_acct_terminate_cause(packet: &mut Packet) {
 pub fn add_acct_terminate_cause(packet: &mut Packet, value: AcctTerminateCause) {
     packet.add(AVP::from_u32(ACCT_TERMINATE_CAUSE_TYPE, value as u32));
 }
-pub fn lookup_acct_terminate_cause(
+pub fn lookup_acct_terminate_cause(packet: &Packet) -> Option<Result<AcctTerminateCause, AVPError>> {
-    packet: &Packet,
+    packet.lookup(ACCT_TERMINATE_CAUSE_TYPE).map(|v| Ok(v.encode_u32()? as AcctTerminateCause))
-) -> Option<Result<AcctTerminateCause, AVPError>> {
-    packet
-        .lookup(ACCT_TERMINATE_CAUSE_TYPE)
-        .map(|v| Ok(v.encode_u32()? as AcctTerminateCause))
 }
-pub fn lookup_all_acct_terminate_cause(
+pub fn lookup_all_acct_terminate_cause(packet: &Packet) -> Result<Vec<AcctTerminateCause>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<AcctTerminateCause>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(ACCT_TERMINATE_CAUSE_TYPE) {
         vec.push(avp.encode_u32()? as AcctTerminateCause)
@@ -213,9 +198,7 @@ pub fn add_acct_multi_session_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(ACCT_MULTI_SESSION_ID_TYPE, value));
 }
 pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(ACCT_MULTI_SESSION_ID_TYPE).map(|v| v.encode_string())
-        .lookup(ACCT_MULTI_SESSION_ID_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -249,6 +232,7 @@ pub const ACCT_AUTHENTIC_LOCAL: AcctAuthentic = 2;
 pub const ACCT_AUTHENTIC_REMOTE: AcctAuthentic = 3;
 pub const ACCT_AUTHENTIC_DIAMETER: AcctAuthentic = 4;
 
+
 pub type AcctStatusType = u32;
 pub const ACCT_STATUS_TYPE_START: AcctStatusType = 1;
 pub const ACCT_STATUS_TYPE_STOP: AcctStatusType = 2;
@@ -258,6 +242,7 @@ pub const ACCT_STATUS_TYPE_ACCOUNTING_ON: AcctStatusType = 7;
 pub const ACCT_STATUS_TYPE_ACCOUNTING_OFF: AcctStatusType = 8;
 pub const ACCT_STATUS_TYPE_FAILED: AcctStatusType = 15;
 
+
 pub type AcctTerminateCause = u32;
 pub const ACCT_TERMINATE_CAUSE_USER_REQUEST: AcctTerminateCause = 1;
 pub const ACCT_TERMINATE_CAUSE_LOST_CARRIER: AcctTerminateCause = 2;
@@ -277,3 +262,4 @@ pub const ACCT_TERMINATE_CAUSE_SERVICE_UNAVAILABLE: AcctTerminateCause = 15;
 pub const ACCT_TERMINATE_CAUSE_CALLBACK: AcctTerminateCause = 16;
 pub const ACCT_TERMINATE_CAUSE_USER_ERROR: AcctTerminateCause = 17;
 pub const ACCT_TERMINATE_CAUSE_HOST_REQUEST: AcctTerminateCause = 18;
+

radius/src/core/rfc2867.rs

@@ -1,9 +1,15 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
-use crate::packet::Packet;
 
-use crate::rfc2866;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+use crate::core::rfc2866;
 
 pub const ACCT_TUNNEL_CONNECTION_TYPE: AVPType = 68;
 pub fn delete_acct_tunnel_connection(packet: &mut Packet) {
@@ -13,9 +19,7 @@ pub fn add_acct_tunnel_connection(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(ACCT_TUNNEL_CONNECTION_TYPE, value));
 }
 pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(ACCT_TUNNEL_CONNECTION_TYPE).map(|v| v.encode_string())
-        .lookup(ACCT_TUNNEL_CONNECTION_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -33,9 +37,7 @@ pub fn add_acct_tunnel_packets_lost(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_TUNNEL_PACKETS_LOST_TYPE, value));
 }
 pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -50,3 +52,4 @@ pub const ACCT_STATUS_TYPE_TUNNEL_REJECT: rfc2866::AcctStatusType = 11;
 pub const ACCT_STATUS_TYPE_TUNNEL_LINK_START: rfc2866::AcctStatusType = 12;
 pub const ACCT_STATUS_TYPE_TUNNEL_LINK_STOP: rfc2866::AcctStatusType = 13;
 pub const ACCT_STATUS_TYPE_TUNNEL_LINK_REJECT: rfc2866::AcctStatusType = 14;
+

radius/src/core/rfc2868.rs

@@ -1,8 +1,16 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
-use crate::tag::Tag;
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+use crate::core::tag::Tag;
+
+
+
+
 
 pub const TUNNEL_TYPE_TYPE: AVPType = 64;
 pub fn delete_tunnel_type(packet: &mut Packet) {
@@ -31,23 +39,15 @@ 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::from_tagged_u32(
+    packet.add(AVP::from_tagged_u32(TUNNEL_MEDIUM_TYPE_TYPE, tag, value as u32));
-        TUNNEL_MEDIUM_TYPE_TYPE,
-        tag,
-        value as u32,
-    ));
 }
-pub fn lookup_tunnel_medium_type(
+pub fn lookup_tunnel_medium_type(packet: &Packet) -> Option<Result<(TunnelMediumType, Tag), AVPError>> {
-    packet: &Packet,
-) -> Option<Result<(TunnelMediumType, Tag), AVPError>> {
     packet.lookup(TUNNEL_MEDIUM_TYPE_TYPE).map(|v| {
         let (v, t) = v.encode_tagged_u32()?;
         Ok((v as TunnelMediumType, t))
     })
 }
-pub fn lookup_all_tunnel_medium_type(
+pub fn lookup_all_tunnel_medium_type(packet: &Packet) -> Result<Vec<(TunnelMediumType, Tag)>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<(TunnelMediumType, Tag)>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(TUNNEL_MEDIUM_TYPE_TYPE) {
         let (v, t) = avp.encode_tagged_u32()?;
@@ -61,22 +61,12 @@ 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::from_tagged_string(
+    packet.add(AVP::from_tagged_string(TUNNEL_CLIENT_ENDPOINT_TYPE, tag, value));
-        TUNNEL_CLIENT_ENDPOINT_TYPE,
-        tag,
-        value,
-    ));
 }
-pub fn lookup_tunnel_client_endpoint(
+pub fn lookup_tunnel_client_endpoint(packet: &Packet) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet: &Packet,
+    packet.lookup(TUNNEL_CLIENT_ENDPOINT_TYPE).map(|v| v.encode_tagged_string())
-) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet
-        .lookup(TUNNEL_CLIENT_ENDPOINT_TYPE)
-        .map(|v| v.encode_tagged_string())
 }
-pub fn lookup_all_tunnel_client_endpoint(
+pub fn lookup_all_tunnel_client_endpoint(packet: &Packet) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(TUNNEL_CLIENT_ENDPOINT_TYPE) {
         vec.push(avp.encode_tagged_string()?)
@@ -89,22 +79,12 @@ 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::from_tagged_string(
+    packet.add(AVP::from_tagged_string(TUNNEL_SERVER_ENDPOINT_TYPE, tag, value));
-        TUNNEL_SERVER_ENDPOINT_TYPE,
-        tag,
-        value,
-    ));
 }
-pub fn lookup_tunnel_server_endpoint(
+pub fn lookup_tunnel_server_endpoint(packet: &Packet) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet: &Packet,
+    packet.lookup(TUNNEL_SERVER_ENDPOINT_TYPE).map(|v| v.encode_tagged_string())
-) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet
-        .lookup(TUNNEL_SERVER_ENDPOINT_TYPE)
-        .map(|v| v.encode_tagged_string())
 }
-pub fn lookup_all_tunnel_server_endpoint(
+pub fn lookup_all_tunnel_server_endpoint(packet: &Packet) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(TUNNEL_SERVER_ENDPOINT_TYPE) {
         vec.push(avp.encode_tagged_string()?)
@@ -116,24 +96,12 @@ pub const TUNNEL_PASSWORD_TYPE: AVPType = 69;
 pub fn delete_tunnel_password(packet: &mut Packet) {
     packet.delete(TUNNEL_PASSWORD_TYPE);
 }
-pub fn add_tunnel_password(
+pub fn add_tunnel_password(packet: &mut Packet, tag: Option<&Tag>, value: &[u8]) -> Result<(), AVPError> {
-    packet: &mut Packet,
+    packet.add(AVP::from_tunnel_password(TUNNEL_PASSWORD_TYPE, tag, value, packet.get_secret(), packet.get_authenticator())?);
-    tag: Option<&Tag>,
-    value: &[u8],
-) -> Result<(), AVPError> {
-    packet.add(AVP::from_tunnel_password(
-        TUNNEL_PASSWORD_TYPE,
-        tag,
-        value,
-        packet.get_secret(),
-        packet.get_authenticator(),
-    )?);
     Ok(())
 }
 pub fn lookup_tunnel_password(packet: &Packet) -> Option<Result<(Vec<u8>, Tag), AVPError>> {
-    packet
+    packet.lookup(TUNNEL_PASSWORD_TYPE).map(|v| v.encode_tunnel_password(packet.get_secret(), packet.get_authenticator()))
-        .lookup(TUNNEL_PASSWORD_TYPE)
-        .map(|v| v.encode_tunnel_password(packet.get_secret(), packet.get_authenticator()))
 }
 pub fn lookup_all_tunnel_password(packet: &Packet) -> Result<Vec<(Vec<u8>, Tag)>, AVPError> {
     let mut vec = Vec::new();
@@ -148,22 +116,12 @@ 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::from_tagged_string(
+    packet.add(AVP::from_tagged_string(TUNNEL_PRIVATE_GROUP_ID_TYPE, tag, value));
-        TUNNEL_PRIVATE_GROUP_ID_TYPE,
-        tag,
-        value,
-    ));
 }
-pub fn lookup_tunnel_private_group_id(
+pub fn lookup_tunnel_private_group_id(packet: &Packet) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet: &Packet,
+    packet.lookup(TUNNEL_PRIVATE_GROUP_ID_TYPE).map(|v| v.encode_tagged_string())
-) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet
-        .lookup(TUNNEL_PRIVATE_GROUP_ID_TYPE)
-        .map(|v| v.encode_tagged_string())
 }
-pub fn lookup_all_tunnel_private_group_id(
+pub fn lookup_all_tunnel_private_group_id(packet: &Packet) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(TUNNEL_PRIVATE_GROUP_ID_TYPE) {
         vec.push(avp.encode_tagged_string()?)
@@ -176,22 +134,12 @@ 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::from_tagged_string(
+    packet.add(AVP::from_tagged_string(TUNNEL_ASSIGNMENT_ID_TYPE, tag, value));
-        TUNNEL_ASSIGNMENT_ID_TYPE,
-        tag,
-        value,
-    ));
 }
-pub fn lookup_tunnel_assignment_id(
+pub fn lookup_tunnel_assignment_id(packet: &Packet) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet: &Packet,
+    packet.lookup(TUNNEL_ASSIGNMENT_ID_TYPE).map(|v| v.encode_tagged_string())
-) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet
-        .lookup(TUNNEL_ASSIGNMENT_ID_TYPE)
-        .map(|v| v.encode_tagged_string())
 }
-pub fn lookup_all_tunnel_assignment_id(
+pub fn lookup_all_tunnel_assignment_id(packet: &Packet) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(TUNNEL_ASSIGNMENT_ID_TYPE) {
         vec.push(avp.encode_tagged_string()?)
@@ -207,9 +155,7 @@ pub fn add_tunnel_preference(packet: &mut Packet, tag: Option<&Tag>, value: u32)
     packet.add(AVP::from_tagged_u32(TUNNEL_PREFERENCE_TYPE, tag, value));
 }
 pub fn lookup_tunnel_preference(packet: &Packet) -> Option<Result<(u32, Tag), AVPError>> {
-    packet
+    packet.lookup(TUNNEL_PREFERENCE_TYPE).map(|v| v.encode_tagged_u32())
-        .lookup(TUNNEL_PREFERENCE_TYPE)
-        .map(|v| v.encode_tagged_u32())
 }
 pub fn lookup_all_tunnel_preference(packet: &Packet) -> Result<Vec<(u32, Tag)>, AVPError> {
     let mut vec = Vec::new();
@@ -224,22 +170,12 @@ 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::from_tagged_string(
+    packet.add(AVP::from_tagged_string(TUNNEL_CLIENT_AUTH_ID_TYPE, tag, value));
-        TUNNEL_CLIENT_AUTH_ID_TYPE,
-        tag,
-        value,
-    ));
 }
-pub fn lookup_tunnel_client_auth_id(
+pub fn lookup_tunnel_client_auth_id(packet: &Packet) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet: &Packet,
+    packet.lookup(TUNNEL_CLIENT_AUTH_ID_TYPE).map(|v| v.encode_tagged_string())
-) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet
-        .lookup(TUNNEL_CLIENT_AUTH_ID_TYPE)
-        .map(|v| v.encode_tagged_string())
 }
-pub fn lookup_all_tunnel_client_auth_id(
+pub fn lookup_all_tunnel_client_auth_id(packet: &Packet) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(TUNNEL_CLIENT_AUTH_ID_TYPE) {
         vec.push(avp.encode_tagged_string()?)
@@ -252,22 +188,12 @@ 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::from_tagged_string(
+    packet.add(AVP::from_tagged_string(TUNNEL_SERVER_AUTH_ID_TYPE, tag, value));
-        TUNNEL_SERVER_AUTH_ID_TYPE,
-        tag,
-        value,
-    ));
 }
-pub fn lookup_tunnel_server_auth_id(
+pub fn lookup_tunnel_server_auth_id(packet: &Packet) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet: &Packet,
+    packet.lookup(TUNNEL_SERVER_AUTH_ID_TYPE).map(|v| v.encode_tagged_string())
-) -> Option<Result<(String, Option<Tag>), AVPError>> {
-    packet
-        .lookup(TUNNEL_SERVER_AUTH_ID_TYPE)
-        .map(|v| v.encode_tagged_string())
 }
-pub fn lookup_all_tunnel_server_auth_id(
+pub fn lookup_all_tunnel_server_auth_id(packet: &Packet) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<(String, Option<Tag>)>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(TUNNEL_SERVER_AUTH_ID_TYPE) {
         vec.push(avp.encode_tagged_string()?)
@@ -293,6 +219,7 @@ pub const TUNNEL_MEDIUM_TYPE_DEC_NET_IV: TunnelMediumType = 13;
 pub const TUNNEL_MEDIUM_TYPE_BANYAN_VINES: TunnelMediumType = 14;
 pub const TUNNEL_MEDIUM_TYPE_E_164_NSAP: TunnelMediumType = 15;
 
+
 pub type TunnelType = u32;
 pub const TUNNEL_TYPE_PPTP: TunnelType = 1;
 pub const TUNNEL_TYPE_L2F: TunnelType = 2;
@@ -306,3 +233,4 @@ pub const TUNNEL_TYPE_ESP: TunnelType = 9;
 pub const TUNNEL_TYPE_GRE: TunnelType = 10;
 pub const TUNNEL_TYPE_DVS: TunnelType = 11;
 pub const TUNNEL_TYPE_IP_IN_IP: TunnelType = 12;
+

radius/src/core/rfc2869.rs

@@ -1,9 +1,17 @@
 // Code generated by machine generator; DO NOT EDIT.
 
+
+
 use chrono::{DateTime, Utc};
 
-use crate::avp::{AVPError, AVPType, AVP};
+use crate::core::avp::{AVP, AVPType, AVPError};
-use crate::packet::Packet;
+use crate::core::packet::Packet;
+
+
+
+
+
+
 
 pub const ACCT_INPUT_GIGAWORDS_TYPE: AVPType = 52;
 pub fn delete_acct_input_gigawords(packet: &mut Packet) {
@@ -13,9 +21,7 @@ pub fn add_acct_input_gigawords(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_INPUT_GIGAWORDS_TYPE, value));
 }
 pub fn lookup_acct_input_gigawords(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_INPUT_GIGAWORDS_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_INPUT_GIGAWORDS_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_input_gigawords(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -33,9 +39,7 @@ pub fn add_acct_output_gigawords(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_OUTPUT_GIGAWORDS_TYPE, value));
 }
 pub fn lookup_acct_output_gigawords(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_OUTPUT_GIGAWORDS_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_OUTPUT_GIGAWORDS_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_output_gigawords(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -69,10 +73,7 @@ pub fn delete_arap_password(packet: &mut Packet) {
 }
 pub fn add_arap_password(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     if value.len() != 16 {
-        return Err(AVPError::InvalidAttributeLengthError(
+        return Err(AVPError::InvalidAttributeLengthError("16 bytes".to_owned(), value.len()));
-            "16 bytes".to_owned(),
-            value.len(),
-        ));
     }
     packet.add(AVP::from_bytes(ARAP_PASSWORD_TYPE, value));
     Ok(())
@@ -94,10 +95,7 @@ pub fn delete_arap_features(packet: &mut Packet) {
 }
 pub fn add_arap_features(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     if value.len() != 14 {
-        return Err(AVPError::InvalidAttributeLengthError(
+        return Err(AVPError::InvalidAttributeLengthError("14 bytes".to_owned(), value.len()));
-            "14 bytes".to_owned(),
-            value.len(),
-        ));
     }
     packet.add(AVP::from_bytes(ARAP_FEATURES_TYPE, value));
     Ok(())
@@ -121,9 +119,7 @@ pub fn add_arap_zone_access(packet: &mut Packet, value: ArapZoneAccess) {
     packet.add(AVP::from_u32(ARAP_ZONE_ACCESS_TYPE, value as u32));
 }
 pub fn lookup_arap_zone_access(packet: &Packet) -> Option<Result<ArapZoneAccess, AVPError>> {
-    packet
+    packet.lookup(ARAP_ZONE_ACCESS_TYPE).map(|v| Ok(v.encode_u32()? as ArapZoneAccess))
-        .lookup(ARAP_ZONE_ACCESS_TYPE)
-        .map(|v| Ok(v.encode_u32()? as ArapZoneAccess))
 }
 pub fn lookup_all_arap_zone_access(packet: &Packet) -> Result<Vec<ArapZoneAccess>, AVPError> {
     let mut vec = Vec::new();
@@ -159,9 +155,7 @@ pub fn add_arap_security_data(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(ARAP_SECURITY_DATA_TYPE, value));
 }
 pub fn lookup_arap_security_data(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(ARAP_SECURITY_DATA_TYPE).map(|v| v.encode_string())
-        .lookup(ARAP_SECURITY_DATA_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_arap_security_data(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -197,9 +191,7 @@ pub fn add_prompt(packet: &mut Packet, value: Prompt) {
     packet.add(AVP::from_u32(PROMPT_TYPE, value as u32));
 }
 pub fn lookup_prompt(packet: &Packet) -> Option<Result<Prompt, AVPError>> {
-    packet
+    packet.lookup(PROMPT_TYPE).map(|v| Ok(v.encode_u32()? as Prompt))
-        .lookup(PROMPT_TYPE)
-        .map(|v| Ok(v.encode_u32()? as Prompt))
 }
 pub fn lookup_all_prompt(packet: &Packet) -> Result<Vec<Prompt>, AVPError> {
     let mut vec = Vec::new();
@@ -235,9 +227,7 @@ pub fn add_configuration_token(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(CONFIGURATION_TOKEN_TYPE, value));
 }
 pub fn lookup_configuration_token(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(CONFIGURATION_TOKEN_TYPE).map(|v| v.encode_string())
-        .lookup(CONFIGURATION_TOKEN_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_configuration_token(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -278,9 +268,7 @@ pub fn add_message_authenticator(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(MESSAGE_AUTHENTICATOR_TYPE, value));
 }
 pub fn lookup_message_authenticator(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(MESSAGE_AUTHENTICATOR_TYPE).map(|v| v.encode_bytes())
-        .lookup(MESSAGE_AUTHENTICATOR_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_message_authenticator(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -296,18 +284,13 @@ pub fn delete_arap_challenge_response(packet: &mut Packet) {
 }
 pub fn add_arap_challenge_response(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     if value.len() != 8 {
-        return Err(AVPError::InvalidAttributeLengthError(
+        return Err(AVPError::InvalidAttributeLengthError("8 bytes".to_owned(), value.len()));
-            "8 bytes".to_owned(),
-            value.len(),
-        ));
     }
     packet.add(AVP::from_bytes(ARAP_CHALLENGE_RESPONSE_TYPE, value));
     Ok(())
 }
 pub fn lookup_arap_challenge_response(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(ARAP_CHALLENGE_RESPONSE_TYPE).map(|v| v.encode_bytes())
-        .lookup(ARAP_CHALLENGE_RESPONSE_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_arap_challenge_response(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -325,9 +308,7 @@ pub fn add_acct_interim_interval(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(ACCT_INTERIM_INTERVAL_TYPE, value));
 }
 pub fn lookup_acct_interim_interval(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(ACCT_INTERIM_INTERVAL_TYPE).map(|v| v.encode_u32())
-        .lookup(ACCT_INTERIM_INTERVAL_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_acct_interim_interval(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -378,6 +359,8 @@ pub const ARAP_ZONE_ACCESS_DEFAULT_ZONE: ArapZoneAccess = 1;
 pub const ARAP_ZONE_ACCESS_ZONE_FILTER_INCLUSIVE: ArapZoneAccess = 2;
 pub const ARAP_ZONE_ACCESS_ZONE_FILTER_EXCLUSIVE: ArapZoneAccess = 4;
 
+
 pub type Prompt = u32;
 pub const PROMPT_NO_ECHO: Prompt = 0;
 pub const PROMPT_ECHO: Prompt = 1;
+

radius/src/core/rfc3162.rs

@@ -1,9 +1,18 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use std::net::Ipv6Addr;
+use std::net::{Ipv6Addr};
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
 
-use crate::avp::{AVPError, AVPType, AVP};
-use crate::packet::Packet;
 
 pub const NAS_IPV6_ADDRESS_TYPE: AVPType = 95;
 pub fn delete_nas_ipv6_address(packet: &mut Packet) {
@@ -13,9 +22,7 @@ pub fn add_nas_ipv6_address(packet: &mut Packet, value: &Ipv6Addr) {
     packet.add(AVP::from_ipv6(NAS_IPV6_ADDRESS_TYPE, value));
 }
 pub fn lookup_nas_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet
+    packet.lookup(NAS_IPV6_ADDRESS_TYPE).map(|v| v.encode_ipv6())
-        .lookup(NAS_IPV6_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv6())
 }
 pub fn lookup_all_nas_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -31,18 +38,13 @@ pub fn delete_framed_interface_id(packet: &mut Packet) {
 }
 pub fn add_framed_interface_id(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     if value.len() != 8 {
-        return Err(AVPError::InvalidAttributeLengthError(
+        return Err(AVPError::InvalidAttributeLengthError("8 bytes".to_owned(), value.len()));
-            "8 bytes".to_owned(),
-            value.len(),
-        ));
     }
     packet.add(AVP::from_bytes(FRAMED_INTERFACE_ID_TYPE, value));
     Ok(())
 }
 pub fn lookup_framed_interface_id(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(FRAMED_INTERFACE_ID_TYPE).map(|v| v.encode_bytes())
-        .lookup(FRAMED_INTERFACE_ID_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_framed_interface_id(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -61,9 +63,7 @@ pub fn add_framed_ipv6_prefix(packet: &mut Packet, value: &[u8]) -> Result<(), A
     Ok(())
 }
 pub fn lookup_framed_ipv6_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(FRAMED_IPV6_PREFIX_TYPE).map(|v| v.encode_ipv6_prefix())
-        .lookup(FRAMED_IPV6_PREFIX_TYPE)
-        .map(|v| v.encode_ipv6_prefix())
 }
 pub fn lookup_all_framed_ipv6_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
     let mut vec = Vec::new();
@@ -99,9 +99,7 @@ pub fn add_framed_ipv6_route(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(FRAMED_IPV6_ROUTE_TYPE, value));
 }
 pub fn lookup_framed_ipv6_route(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(FRAMED_IPV6_ROUTE_TYPE).map(|v| v.encode_string())
-        .lookup(FRAMED_IPV6_ROUTE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_framed_ipv6_route(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -119,9 +117,7 @@ pub fn add_framed_ipv6_pool(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(FRAMED_IPV6_POOL_TYPE, value));
 }
 pub fn lookup_framed_ipv6_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(FRAMED_IPV6_POOL_TYPE).map(|v| v.encode_string())
-        .lookup(FRAMED_IPV6_POOL_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_framed_ipv6_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc3576.rs

@@ -1,9 +1,19 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
-use crate::packet::Packet;
 
-use crate::rfc2865;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+use crate::core::rfc2865;
+
+
+
+
+
 
 pub const ERROR_CAUSE_TYPE: AVPType = 101;
 pub fn delete_error_cause(packet: &mut Packet) {
@@ -13,9 +23,7 @@ pub fn add_error_cause(packet: &mut Packet, value: ErrorCause) {
     packet.add(AVP::from_u32(ERROR_CAUSE_TYPE, value as u32));
 }
 pub fn lookup_error_cause(packet: &Packet) -> Option<Result<ErrorCause, AVPError>> {
-    packet
+    packet.lookup(ERROR_CAUSE_TYPE).map(|v| Ok(v.encode_u32()? as ErrorCause))
-        .lookup(ERROR_CAUSE_TYPE)
-        .map(|v| Ok(v.encode_u32()? as ErrorCause))
 }
 pub fn lookup_all_error_cause(packet: &Packet) -> Result<Vec<ErrorCause>, AVPError> {
     let mut vec = Vec::new();
@@ -43,3 +51,4 @@ pub const ERROR_CAUSE_RESOURCES_UNAVAILABLE: ErrorCause = 506;
 pub const ERROR_CAUSE_REQUEST_INITIATED: ErrorCause = 507;
 
 pub const SERVICE_TYPE_AUTHORIZE_ONLY: rfc2865::ServiceType = 17;
+

radius/src/core/rfc3580.rs

@@ -1,9 +1,19 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::rfc2865;
-use crate::rfc2866;
 
-use crate::rfc2868;
+
+
+
+
+
+
+
+use crate::core::rfc2865;
+use crate::core::rfc2866;
+
+use crate::core::rfc2868;
+
+
 
 pub const ACCT_TERMINATE_CAUSE_SUPPLICANT_RESTART: rfc2866::AcctTerminateCause = 19;
 pub const ACCT_TERMINATE_CAUSE_REAUTHENTICATION_FAILURE: rfc2866::AcctTerminateCause = 20;
@@ -14,3 +24,4 @@ pub const NAS_PORT_TYPE_TOKEN_RING: rfc2865::NasPortType = 20;
 pub const NAS_PORT_TYPE_FDDI: rfc2865::NasPortType = 21;
 
 pub const TUNNEL_TYPE_VLAN: rfc2868::TunnelType = 13;
+

radius/src/core/rfc4072.rs

@@ -1,7 +1,21 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
 
 pub const EAP_KEY_NAME_TYPE: AVPType = 102;
 pub fn delete_eap_key_name(packet: &mut Packet) {

radius/src/core/rfc4372.rs

@@ -1,7 +1,22 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
 
 pub const CHARGEABLE_USER_IDENTITY_TYPE: AVPType = 89;
 pub fn delete_chargeable_user_identity(packet: &mut Packet) {
@@ -11,9 +26,7 @@ pub fn add_chargeable_user_identity(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(CHARGEABLE_USER_IDENTITY_TYPE, value));
 }
 pub fn lookup_chargeable_user_identity(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(CHARGEABLE_USER_IDENTITY_TYPE).map(|v| v.encode_bytes())
-        .lookup(CHARGEABLE_USER_IDENTITY_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_chargeable_user_identity(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();

radius/src/core/rfc4603.rs

@@ -1,9 +1,26 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::rfc2865;
+
+
+
+
+
+
+
+
+use crate::core::rfc2865;
+
+
+
+
+
+
+
+
 
 pub const NAS_PORT_TYPE_PP_PO_A: rfc2865::NasPortType = 30;
 pub const NAS_PORT_TYPE_PP_PO_EO_A: rfc2865::NasPortType = 31;
 pub const NAS_PORT_TYPE_PP_PO_EO_E: rfc2865::NasPortType = 32;
 pub const NAS_PORT_TYPE_PP_PO_EO_VLAN: rfc2865::NasPortType = 33;
 pub const NAS_PORT_TYPE_PP_PO_EO_QIN_Q: rfc2865::NasPortType = 34;
+

radius/src/core/rfc4675.rs

@@ -1,7 +1,24 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const EGRESS_VLANID_TYPE: AVPType = 56;
 pub fn delete_egress_vlanid(packet: &mut Packet) {
@@ -29,9 +46,7 @@ pub fn add_ingress_filters(packet: &mut Packet, value: IngressFilters) {
     packet.add(AVP::from_u32(INGRESS_FILTERS_TYPE, value as u32));
 }
 pub fn lookup_ingress_filters(packet: &Packet) -> Option<Result<IngressFilters, AVPError>> {
-    packet
+    packet.lookup(INGRESS_FILTERS_TYPE).map(|v| Ok(v.encode_u32()? as IngressFilters))
-        .lookup(INGRESS_FILTERS_TYPE)
-        .map(|v| Ok(v.encode_u32()? as IngressFilters))
 }
 pub fn lookup_all_ingress_filters(packet: &Packet) -> Result<Vec<IngressFilters>, AVPError> {
     let mut vec = Vec::new();
@@ -49,9 +64,7 @@ pub fn add_egress_vlan_name(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(EGRESS_VLAN_NAME_TYPE, value));
 }
 pub fn lookup_egress_vlan_name(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(EGRESS_VLAN_NAME_TYPE).map(|v| v.encode_string())
-        .lookup(EGRESS_VLAN_NAME_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_egress_vlan_name(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -69,9 +82,7 @@ pub fn add_user_priority_table(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(USER_PRIORITY_TABLE_TYPE, value));
 }
 pub fn lookup_user_priority_table(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(USER_PRIORITY_TABLE_TYPE).map(|v| v.encode_bytes())
-        .lookup(USER_PRIORITY_TABLE_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_user_priority_table(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -84,3 +95,4 @@ pub fn lookup_all_user_priority_table(packet: &Packet) -> Vec<Vec<u8>> {
 pub type IngressFilters = u32;
 pub const INGRESS_FILTERS_ENABLED: IngressFilters = 1;
 pub const INGRESS_FILTERS_DISABLED: IngressFilters = 2;
+

radius/src/core/rfc4818.rs

@@ -1,7 +1,25 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const DELEGATED_IPV6_PREFIX_TYPE: AVPType = 123;
 pub fn delete_delegated_ipv6_prefix(packet: &mut Packet) {
@@ -12,9 +30,7 @@ pub fn add_delegated_ipv6_prefix(packet: &mut Packet, value: &[u8]) -> Result<()
     Ok(())
 }
 pub fn lookup_delegated_ipv6_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(DELEGATED_IPV6_PREFIX_TYPE).map(|v| v.encode_ipv6_prefix())
-        .lookup(DELEGATED_IPV6_PREFIX_TYPE)
-        .map(|v| v.encode_ipv6_prefix())
 }
 pub fn lookup_all_delegated_ipv6_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc4849.rs

@@ -1,7 +1,26 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const NAS_FILTER_RULE_TYPE: AVPType = 92;
 pub fn delete_nas_filter_rule(packet: &mut Packet) {
@@ -11,9 +30,7 @@ pub fn add_nas_filter_rule(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(NAS_FILTER_RULE_TYPE, value));
 }
 pub fn lookup_nas_filter_rule(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(NAS_FILTER_RULE_TYPE).map(|v| v.encode_string())
-        .lookup(NAS_FILTER_RULE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_nas_filter_rule(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc5090.rs

@@ -1,7 +1,27 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const DIGEST_RESPONSE_TYPE: AVPType = 103;
 pub fn delete_digest_response(packet: &mut Packet) {
@@ -11,9 +31,7 @@ pub fn add_digest_response(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_RESPONSE_TYPE, value));
 }
 pub fn lookup_digest_response(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_RESPONSE_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_RESPONSE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_response(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -67,9 +85,7 @@ pub fn add_digest_response_auth(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_RESPONSE_AUTH_TYPE, value));
 }
 pub fn lookup_digest_response_auth(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_RESPONSE_AUTH_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_RESPONSE_AUTH_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_response_auth(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -87,9 +103,7 @@ pub fn add_digest_nextnonce(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_NEXTNONCE_TYPE, value));
 }
 pub fn lookup_digest_nextnonce(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_NEXTNONCE_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_NEXTNONCE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_nextnonce(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -161,9 +175,7 @@ pub fn add_digest_algorithm(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_ALGORITHM_TYPE, value));
 }
 pub fn lookup_digest_algorithm(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_ALGORITHM_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_ALGORITHM_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_algorithm(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -181,9 +193,7 @@ pub fn add_digest_entity_body_hash(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_ENTITY_BODY_HASH_TYPE, value));
 }
 pub fn lookup_digest_entity_body_hash(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_ENTITY_BODY_HASH_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_ENTITY_BODY_HASH_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_entity_body_hash(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -201,9 +211,7 @@ pub fn add_digest_c_nonce(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_C_NONCE_TYPE, value));
 }
 pub fn lookup_digest_c_nonce(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_C_NONCE_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_C_NONCE_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_c_nonce(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -221,9 +229,7 @@ pub fn add_digest_nonce_count(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_NONCE_COUNT_TYPE, value));
 }
 pub fn lookup_digest_nonce_count(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_NONCE_COUNT_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_NONCE_COUNT_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_nonce_count(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -241,9 +247,7 @@ pub fn add_digest_username(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_USERNAME_TYPE, value));
 }
 pub fn lookup_digest_username(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_USERNAME_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_USERNAME_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_username(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -279,9 +283,7 @@ pub fn add_digest_auth_param(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_AUTH_PARAM_TYPE, value));
 }
 pub fn lookup_digest_auth_param(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_AUTH_PARAM_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_AUTH_PARAM_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_auth_param(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -299,9 +301,7 @@ pub fn add_digest_aka_auts(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DIGEST_AKA_AUTS_TYPE, value));
 }
 pub fn lookup_digest_aka_auts(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DIGEST_AKA_AUTS_TYPE).map(|v| v.encode_string())
-        .lookup(DIGEST_AKA_AUTS_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_digest_aka_auts(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc5176.rs

@@ -1,6 +1,28 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::rfc3576;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+use crate::core::rfc3576;
+
+
+
+
+
+
+
 
 pub const ERROR_CAUSE_INVALID_ATTRIBUTE_VALUE: rfc3576::ErrorCause = 407;
 pub const ERROR_CAUSE_MULTIPLE_SESSION_SELECTION_UNSUPPORTED: rfc3576::ErrorCause = 508;
+

radius/src/core/rfc5607.rs

@@ -1,9 +1,29 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
-use crate::packet::Packet;
 
-use crate::rfc2865;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+use crate::core::rfc2865;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const FRAMED_MANAGEMENT_TYPE: AVPType = 133;
 pub fn delete_framed_management(packet: &mut Packet) {
@@ -13,9 +33,7 @@ pub fn add_framed_management(packet: &mut Packet, value: FramedManagement) {
     packet.add(AVP::from_u32(FRAMED_MANAGEMENT_TYPE, value as u32));
 }
 pub fn lookup_framed_management(packet: &Packet) -> Option<Result<FramedManagement, AVPError>> {
-    packet
+    packet.lookup(FRAMED_MANAGEMENT_TYPE).map(|v| Ok(v.encode_u32()? as FramedManagement))
-        .lookup(FRAMED_MANAGEMENT_TYPE)
-        .map(|v| Ok(v.encode_u32()? as FramedManagement))
 }
 pub fn lookup_all_framed_management(packet: &Packet) -> Result<Vec<FramedManagement>, AVPError> {
     let mut vec = Vec::new();
@@ -29,25 +47,13 @@ pub const MANAGEMENT_TRANSPORT_PROTECTION_TYPE: AVPType = 134;
 pub fn delete_management_transport_protection(packet: &mut Packet) {
     packet.delete(MANAGEMENT_TRANSPORT_PROTECTION_TYPE);
 }
-pub fn add_management_transport_protection(
+pub fn add_management_transport_protection(packet: &mut Packet, value: ManagementTransportProtection) {
-    packet: &mut Packet,
+    packet.add(AVP::from_u32(MANAGEMENT_TRANSPORT_PROTECTION_TYPE, value as u32));
-    value: ManagementTransportProtection,
-) {
-    packet.add(AVP::from_u32(
-        MANAGEMENT_TRANSPORT_PROTECTION_TYPE,
-        value as u32,
-    ));
 }
-pub fn lookup_management_transport_protection(
+pub fn lookup_management_transport_protection(packet: &Packet) -> Option<Result<ManagementTransportProtection, AVPError>> {
-    packet: &Packet,
+    packet.lookup(MANAGEMENT_TRANSPORT_PROTECTION_TYPE).map(|v| Ok(v.encode_u32()? as ManagementTransportProtection))
-) -> Option<Result<ManagementTransportProtection, AVPError>> {
-    packet
-        .lookup(MANAGEMENT_TRANSPORT_PROTECTION_TYPE)
-        .map(|v| Ok(v.encode_u32()? as ManagementTransportProtection))
 }
-pub fn lookup_all_management_transport_protection(
+pub fn lookup_all_management_transport_protection(packet: &Packet) -> Result<Vec<ManagementTransportProtection>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<ManagementTransportProtection>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(MANAGEMENT_TRANSPORT_PROTECTION_TYPE) {
         vec.push(avp.encode_u32()? as ManagementTransportProtection)
@@ -63,9 +69,7 @@ pub fn add_management_policy_id(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(MANAGEMENT_POLICY_ID_TYPE, value));
 }
 pub fn lookup_management_policy_id(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(MANAGEMENT_POLICY_ID_TYPE).map(|v| v.encode_string())
-        .lookup(MANAGEMENT_POLICY_ID_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_management_policy_id(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -83,9 +87,7 @@ pub fn add_management_privilege_level(packet: &mut Packet, value: u32) {
     packet.add(AVP::from_u32(MANAGEMENT_PRIVILEGE_LEVEL_TYPE, value));
 }
 pub fn lookup_management_privilege_level(packet: &Packet) -> Option<Result<u32, AVPError>> {
-    packet
+    packet.lookup(MANAGEMENT_PRIVILEGE_LEVEL_TYPE).map(|v| v.encode_u32())
-        .lookup(MANAGEMENT_PRIVILEGE_LEVEL_TYPE)
-        .map(|v| v.encode_u32())
 }
 pub fn lookup_all_management_privilege_level(packet: &Packet) -> Result<Vec<u32>, AVPError> {
     let mut vec = Vec::new();
@@ -105,10 +107,11 @@ pub const FRAMED_MANAGEMENT_SFTP: FramedManagement = 6;
 pub const FRAMED_MANAGEMENT_RCP: FramedManagement = 7;
 pub const FRAMED_MANAGEMENT_SCP: FramedManagement = 8;
 
+
 pub type ManagementTransportProtection = u32;
 pub const MANAGEMENT_TRANSPORT_PROTECTION_NO_PROTECTION: ManagementTransportProtection = 1;
 pub const MANAGEMENT_TRANSPORT_PROTECTION_INTEGRITY_PROTECTION: ManagementTransportProtection = 2;
-pub const MANAGEMENT_TRANSPORT_PROTECTION_INTEGRITY_CONFIDENTIALITY_PROTECTION:
+pub const MANAGEMENT_TRANSPORT_PROTECTION_INTEGRITY_CONFIDENTIALITY_PROTECTION: ManagementTransportProtection = 3;
-    ManagementTransportProtection = 3;
 
 pub const SERVICE_TYPE_FRAMED_MANAGEMENT: rfc2865::ServiceType = 18;
+

radius/src/core/rfc5904.rs

@@ -1,7 +1,30 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const PKM_SS_CERT_TYPE: AVPType = 137;
 pub fn delete_pkm_ss_cert(packet: &mut Packet) {
@@ -57,9 +80,7 @@ pub fn add_pkm_config_settings(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(PKM_CONFIG_SETTINGS_TYPE, value));
 }
 pub fn lookup_pkm_config_settings(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(PKM_CONFIG_SETTINGS_TYPE).map(|v| v.encode_bytes())
-        .lookup(PKM_CONFIG_SETTINGS_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_pkm_config_settings(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -77,9 +98,7 @@ pub fn add_pkm_cryptosuite_list(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(PKM_CRYPTOSUITE_LIST_TYPE, value));
 }
 pub fn lookup_pkm_cryptosuite_list(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(PKM_CRYPTOSUITE_LIST_TYPE).map(|v| v.encode_bytes())
-        .lookup(PKM_CRYPTOSUITE_LIST_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_pkm_cryptosuite_list(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -115,9 +134,7 @@ pub fn add_pkm_sa_descriptor(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(PKM_SA_DESCRIPTOR_TYPE, value));
 }
 pub fn lookup_pkm_sa_descriptor(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(PKM_SA_DESCRIPTOR_TYPE).map(|v| v.encode_bytes())
-        .lookup(PKM_SA_DESCRIPTOR_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_pkm_sa_descriptor(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();

radius/src/core/rfc6519.rs

@@ -1,7 +1,31 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const DS_LITE_TUNNEL_NAME_TYPE: AVPType = 144;
 pub fn delete_ds_lite_tunnel_name(packet: &mut Packet) {
@@ -11,9 +35,7 @@ pub fn add_ds_lite_tunnel_name(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DS_LITE_TUNNEL_NAME_TYPE, value));
 }
 pub fn lookup_ds_lite_tunnel_name(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DS_LITE_TUNNEL_NAME_TYPE).map(|v| v.encode_string())
-        .lookup(DS_LITE_TUNNEL_NAME_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_ds_lite_tunnel_name(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc6572.rs

@@ -2,8 +2,31 @@
 
 use std::net::{Ipv4Addr, Ipv6Addr};
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const MOBILE_NODE_IDENTIFIER_TYPE: AVPType = 145;
 pub fn delete_mobile_node_identifier(packet: &mut Packet) {
@@ -13,9 +36,7 @@ pub fn add_mobile_node_identifier(packet: &mut Packet, value: &[u8]) {
     packet.add(AVP::from_bytes(MOBILE_NODE_IDENTIFIER_TYPE, value));
 }
 pub fn lookup_mobile_node_identifier(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(MOBILE_NODE_IDENTIFIER_TYPE).map(|v| v.encode_bytes())
-        .lookup(MOBILE_NODE_IDENTIFIER_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_mobile_node_identifier(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -33,9 +54,7 @@ pub fn add_service_selection(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(SERVICE_SELECTION_TYPE, value));
 }
 pub fn lookup_service_selection(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(SERVICE_SELECTION_TYPE).map(|v| v.encode_string())
-        .lookup(SERVICE_SELECTION_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_service_selection(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -53,9 +72,7 @@ pub fn add_pmip6_home_lma_ipv6_address(packet: &mut Packet, value: &Ipv6Addr) {
     packet.add(AVP::from_ipv6(PMIP6_HOME_LMA_IPV6_ADDRESS_TYPE, value));
 }
 pub fn lookup_pmip6_home_lma_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet
+    packet.lookup(PMIP6_HOME_LMA_IPV6_ADDRESS_TYPE).map(|v| v.encode_ipv6())
-        .lookup(PMIP6_HOME_LMA_IPV6_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv6())
 }
 pub fn lookup_all_pmip6_home_lma_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -72,16 +89,10 @@ pub fn delete_pmip6_visited_lma_ipv6_address(packet: &mut Packet) {
 pub fn add_pmip6_visited_lma_ipv6_address(packet: &mut Packet, value: &Ipv6Addr) {
     packet.add(AVP::from_ipv6(PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE, value));
 }
-pub fn lookup_pmip6_visited_lma_ipv6_address(
+pub fn lookup_pmip6_visited_lma_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet: &Packet,
+    packet.lookup(PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE).map(|v| v.encode_ipv6())
-) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet
-        .lookup(PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv6())
 }
-pub fn lookup_all_pmip6_visited_lma_ipv6_address(
+pub fn lookup_all_pmip6_visited_lma_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<Ipv6Addr>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE) {
         vec.push(avp.encode_ipv6()?)
@@ -97,9 +108,7 @@ pub fn add_pmip6_home_lma_ipv4_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(PMIP6_HOME_LMA_IPV4_ADDRESS_TYPE, value));
 }
 pub fn lookup_pmip6_home_lma_ipv4_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
+    packet.lookup(PMIP6_HOME_LMA_IPV4_ADDRESS_TYPE).map(|v| v.encode_ipv4())
-        .lookup(PMIP6_HOME_LMA_IPV4_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv4())
 }
 pub fn lookup_all_pmip6_home_lma_ipv4_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -116,16 +125,10 @@ pub fn delete_pmip6_visited_lma_ipv4_address(packet: &mut Packet) {
 pub fn add_pmip6_visited_lma_ipv4_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE, value));
 }
-pub fn lookup_pmip6_visited_lma_ipv4_address(
+pub fn lookup_pmip6_visited_lma_ipv4_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet: &Packet,
+    packet.lookup(PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE).map(|v| v.encode_ipv4())
-) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
-        .lookup(PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv4())
 }
-pub fn lookup_all_pmip6_visited_lma_ipv4_address(
+pub fn lookup_all_pmip6_visited_lma_ipv4_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE) {
         vec.push(avp.encode_ipv4()?)
@@ -142,9 +145,7 @@ pub fn add_pmip6_home_hn_prefix(packet: &mut Packet, value: &[u8]) -> Result<(),
     Ok(())
 }
 pub fn lookup_pmip6_home_hn_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(PMIP6_HOME_HN_PREFIX_TYPE).map(|v| v.encode_ipv6_prefix())
-        .lookup(PMIP6_HOME_HN_PREFIX_TYPE)
-        .map(|v| v.encode_ipv6_prefix())
 }
 pub fn lookup_all_pmip6_home_hn_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
     let mut vec = Vec::new();
@@ -163,9 +164,7 @@ pub fn add_pmip6_visited_hn_prefix(packet: &mut Packet, value: &[u8]) -> Result<
     Ok(())
 }
 pub fn lookup_pmip6_visited_hn_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(PMIP6_VISITED_HN_PREFIX_TYPE).map(|v| v.encode_ipv6_prefix())
-        .lookup(PMIP6_VISITED_HN_PREFIX_TYPE)
-        .map(|v| v.encode_ipv6_prefix())
 }
 pub fn lookup_all_pmip6_visited_hn_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
     let mut vec = Vec::new();
@@ -181,18 +180,13 @@ pub fn delete_pmip6_home_interface_id(packet: &mut Packet) {
 }
 pub fn add_pmip6_home_interface_id(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     if value.len() != 8 {
-        return Err(AVPError::InvalidAttributeLengthError(
+        return Err(AVPError::InvalidAttributeLengthError("8 bytes".to_owned(), value.len()));
-            "8 bytes".to_owned(),
-            value.len(),
-        ));
     }
     packet.add(AVP::from_bytes(PMIP6_HOME_INTERFACE_ID_TYPE, value));
     Ok(())
 }
 pub fn lookup_pmip6_home_interface_id(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(PMIP6_HOME_INTERFACE_ID_TYPE).map(|v| v.encode_bytes())
-        .lookup(PMIP6_HOME_INTERFACE_ID_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_pmip6_home_interface_id(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -208,18 +202,13 @@ pub fn delete_pmip6_visited_interface_id(packet: &mut Packet) {
 }
 pub fn add_pmip6_visited_interface_id(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     if value.len() != 8 {
-        return Err(AVPError::InvalidAttributeLengthError(
+        return Err(AVPError::InvalidAttributeLengthError("8 bytes".to_owned(), value.len()));
-            "8 bytes".to_owned(),
-            value.len(),
-        ));
     }
     packet.add(AVP::from_bytes(PMIP6_VISITED_INTERFACE_ID_TYPE, value));
     Ok(())
 }
 pub fn lookup_pmip6_visited_interface_id(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(PMIP6_VISITED_INTERFACE_ID_TYPE).map(|v| v.encode_bytes())
-        .lookup(PMIP6_VISITED_INTERFACE_ID_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_pmip6_visited_interface_id(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();
@@ -238,9 +227,7 @@ pub fn add_pmip6_home_ipv4_ho_a(packet: &mut Packet, value: &[u8]) -> Result<(),
     Ok(())
 }
 pub fn lookup_pmip6_home_ipv4_ho_a(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(PMIP6_HOME_IPV4_HO_A_TYPE).map(|v| v.encode_ipv4_prefix())
-        .lookup(PMIP6_HOME_IPV4_HO_A_TYPE)
-        .map(|v| v.encode_ipv4_prefix())
 }
 pub fn lookup_all_pmip6_home_ipv4_ho_a(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
     let mut vec = Vec::new();
@@ -259,9 +246,7 @@ pub fn add_pmip6_visited_ipv4_ho_a(packet: &mut Packet, value: &[u8]) -> Result<
     Ok(())
 }
 pub fn lookup_pmip6_visited_ipv4_ho_a(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(PMIP6_VISITED_IPV4_HO_A_TYPE).map(|v| v.encode_ipv4_prefix())
-        .lookup(PMIP6_VISITED_IPV4_HO_A_TYPE)
-        .map(|v| v.encode_ipv4_prefix())
 }
 pub fn lookup_all_pmip6_visited_ipv4_ho_a(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
     let mut vec = Vec::new();
@@ -278,16 +263,10 @@ pub fn delete_pmip6_home_dhcp4_server_address(packet: &mut Packet) {
 pub fn add_pmip6_home_dhcp4_server_address(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(PMIP6_HOME_DHCP4_SERVER_ADDRESS_TYPE, value));
 }
-pub fn lookup_pmip6_home_dhcp4_server_address(
+pub fn lookup_pmip6_home_dhcp4_server_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet: &Packet,
+    packet.lookup(PMIP6_HOME_DHCP4_SERVER_ADDRESS_TYPE).map(|v| v.encode_ipv4())
-) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
-        .lookup(PMIP6_HOME_DHCP4_SERVER_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv4())
 }
-pub fn lookup_all_pmip6_home_dhcp4_server_address(
+pub fn lookup_all_pmip6_home_dhcp4_server_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(PMIP6_HOME_DHCP4_SERVER_ADDRESS_TYPE) {
         vec.push(avp.encode_ipv4()?)
@@ -300,21 +279,12 @@ pub fn delete_pmip6_visited_dhcp4_server_address(packet: &mut Packet) {
     packet.delete(PMIP6_VISITED_DHCP4_SERVER_ADDRESS_TYPE);
 }
 pub fn add_pmip6_visited_dhcp4_server_address(packet: &mut Packet, value: &Ipv4Addr) {
-    packet.add(AVP::from_ipv4(
+    packet.add(AVP::from_ipv4(PMIP6_VISITED_DHCP4_SERVER_ADDRESS_TYPE, value));
-        PMIP6_VISITED_DHCP4_SERVER_ADDRESS_TYPE,
-        value,
-    ));
 }
-pub fn lookup_pmip6_visited_dhcp4_server_address(
+pub fn lookup_pmip6_visited_dhcp4_server_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet: &Packet,
+    packet.lookup(PMIP6_VISITED_DHCP4_SERVER_ADDRESS_TYPE).map(|v| v.encode_ipv4())
-) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
-        .lookup(PMIP6_VISITED_DHCP4_SERVER_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv4())
 }
-pub fn lookup_all_pmip6_visited_dhcp4_server_address(
+pub fn lookup_all_pmip6_visited_dhcp4_server_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(PMIP6_VISITED_DHCP4_SERVER_ADDRESS_TYPE) {
         vec.push(avp.encode_ipv4()?)
@@ -329,16 +299,10 @@ pub fn delete_pmip6_home_dhcp6_server_address(packet: &mut Packet) {
 pub fn add_pmip6_home_dhcp6_server_address(packet: &mut Packet, value: &Ipv6Addr) {
     packet.add(AVP::from_ipv6(PMIP6_HOME_DHCP6_SERVER_ADDRESS_TYPE, value));
 }
-pub fn lookup_pmip6_home_dhcp6_server_address(
+pub fn lookup_pmip6_home_dhcp6_server_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet: &Packet,
+    packet.lookup(PMIP6_HOME_DHCP6_SERVER_ADDRESS_TYPE).map(|v| v.encode_ipv6())
-) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet
-        .lookup(PMIP6_HOME_DHCP6_SERVER_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv6())
 }
-pub fn lookup_all_pmip6_home_dhcp6_server_address(
+pub fn lookup_all_pmip6_home_dhcp6_server_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<Ipv6Addr>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(PMIP6_HOME_DHCP6_SERVER_ADDRESS_TYPE) {
         vec.push(avp.encode_ipv6()?)
@@ -351,21 +315,12 @@ pub fn delete_pmip6_visited_dhcp6_server_address(packet: &mut Packet) {
     packet.delete(PMIP6_VISITED_DHCP6_SERVER_ADDRESS_TYPE);
 }
 pub fn add_pmip6_visited_dhcp6_server_address(packet: &mut Packet, value: &Ipv6Addr) {
-    packet.add(AVP::from_ipv6(
+    packet.add(AVP::from_ipv6(PMIP6_VISITED_DHCP6_SERVER_ADDRESS_TYPE, value));
-        PMIP6_VISITED_DHCP6_SERVER_ADDRESS_TYPE,
-        value,
-    ));
 }
-pub fn lookup_pmip6_visited_dhcp6_server_address(
+pub fn lookup_pmip6_visited_dhcp6_server_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet: &Packet,
+    packet.lookup(PMIP6_VISITED_DHCP6_SERVER_ADDRESS_TYPE).map(|v| v.encode_ipv6())
-) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet
-        .lookup(PMIP6_VISITED_DHCP6_SERVER_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv6())
 }
-pub fn lookup_all_pmip6_visited_dhcp6_server_address(
+pub fn lookup_all_pmip6_visited_dhcp6_server_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
-    packet: &Packet,
-) -> Result<Vec<Ipv6Addr>, AVPError> {
     let mut vec = Vec::new();
     for avp in packet.lookup_all(PMIP6_VISITED_DHCP6_SERVER_ADDRESS_TYPE) {
         vec.push(avp.encode_ipv6()?)
@@ -381,9 +336,7 @@ pub fn add_pmip6_home_ipv4_gateway(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(PMIP6_HOME_IPV4_GATEWAY_TYPE, value));
 }
 pub fn lookup_pmip6_home_ipv4_gateway(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
+    packet.lookup(PMIP6_HOME_IPV4_GATEWAY_TYPE).map(|v| v.encode_ipv4())
-        .lookup(PMIP6_HOME_IPV4_GATEWAY_TYPE)
-        .map(|v| v.encode_ipv4())
 }
 pub fn lookup_all_pmip6_home_ipv4_gateway(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -401,9 +354,7 @@ pub fn add_pmip6_visited_ipv4_gateway(packet: &mut Packet, value: &Ipv4Addr) {
     packet.add(AVP::from_ipv4(PMIP6_VISITED_IPV4_GATEWAY_TYPE, value));
 }
 pub fn lookup_pmip6_visited_ipv4_gateway(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
-    packet
+    packet.lookup(PMIP6_VISITED_IPV4_GATEWAY_TYPE).map(|v| v.encode_ipv4())
-        .lookup(PMIP6_VISITED_IPV4_GATEWAY_TYPE)
-        .map(|v| v.encode_ipv4())
 }
 pub fn lookup_all_pmip6_visited_ipv4_gateway(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc6677.rs

@@ -1,7 +1,33 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const EAP_LOWER_LAYER_TYPE: AVPType = 163;
 pub fn delete_eap_lower_layer(packet: &mut Packet) {
@@ -11,9 +37,7 @@ pub fn add_eap_lower_layer(packet: &mut Packet, value: EapLowerLayer) {
     packet.add(AVP::from_u32(EAP_LOWER_LAYER_TYPE, value as u32));
 }
 pub fn lookup_eap_lower_layer(packet: &Packet) -> Option<Result<EapLowerLayer, AVPError>> {
-    packet
+    packet.lookup(EAP_LOWER_LAYER_TYPE).map(|v| Ok(v.encode_u32()? as EapLowerLayer))
-        .lookup(EAP_LOWER_LAYER_TYPE)
-        .map(|v| Ok(v.encode_u32()? as EapLowerLayer))
 }
 pub fn lookup_all_eap_lower_layer(packet: &Packet) -> Result<Vec<EapLowerLayer>, AVPError> {
     let mut vec = Vec::new();
@@ -33,3 +57,4 @@ pub const EAP_LOWER_LAYER_PPP: EapLowerLayer = 6;
 pub const EAP_LOWER_LAYER_PANA_NO_PREAUTH: EapLowerLayer = 7;
 pub const EAP_LOWER_LAYER_GSS_API: EapLowerLayer = 8;
 pub const EAP_LOWER_LAYER_PANA_PREAUTH: EapLowerLayer = 9;
+

radius/src/core/rfc6911.rs

@@ -1,9 +1,34 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use std::net::Ipv6Addr;
+use std::net::{Ipv6Addr};
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
-use crate::avp::{AVPError, AVPType, AVP};
-use crate::packet::Packet;
 
 pub const FRAMED_IPV6_ADDRESS_TYPE: AVPType = 168;
 pub fn delete_framed_ipv6_address(packet: &mut Packet) {
@@ -13,9 +38,7 @@ pub fn add_framed_ipv6_address(packet: &mut Packet, value: &Ipv6Addr) {
     packet.add(AVP::from_ipv6(FRAMED_IPV6_ADDRESS_TYPE, value));
 }
 pub fn lookup_framed_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet
+    packet.lookup(FRAMED_IPV6_ADDRESS_TYPE).map(|v| v.encode_ipv6())
-        .lookup(FRAMED_IPV6_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv6())
 }
 pub fn lookup_all_framed_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -33,9 +56,7 @@ pub fn add_dns_server_ipv6_address(packet: &mut Packet, value: &Ipv6Addr) {
     packet.add(AVP::from_ipv6(DNS_SERVER_IPV6_ADDRESS_TYPE, value));
 }
 pub fn lookup_dns_server_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
-    packet
+    packet.lookup(DNS_SERVER_IPV6_ADDRESS_TYPE).map(|v| v.encode_ipv6())
-        .lookup(DNS_SERVER_IPV6_ADDRESS_TYPE)
-        .map(|v| v.encode_ipv6())
 }
 pub fn lookup_all_dns_server_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
     let mut vec = Vec::new();
@@ -54,9 +75,7 @@ pub fn add_route_ipv6_information(packet: &mut Packet, value: &[u8]) -> Result<(
     Ok(())
 }
 pub fn lookup_route_ipv6_information(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
-    packet
+    packet.lookup(ROUTE_IPV6_INFORMATION_TYPE).map(|v| v.encode_ipv6_prefix())
-        .lookup(ROUTE_IPV6_INFORMATION_TYPE)
-        .map(|v| v.encode_ipv6_prefix())
 }
 pub fn lookup_all_route_ipv6_information(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
     let mut vec = Vec::new();
@@ -74,9 +93,7 @@ pub fn add_delegated_ipv6_prefix_pool(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(DELEGATED_IPV6_PREFIX_POOL_TYPE, value));
 }
 pub fn lookup_delegated_ipv6_prefix_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(DELEGATED_IPV6_PREFIX_POOL_TYPE).map(|v| v.encode_string())
-        .lookup(DELEGATED_IPV6_PREFIX_POOL_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_delegated_ipv6_prefix_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -94,9 +111,7 @@ pub fn add_stateful_ipv6_address_pool(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(STATEFUL_IPV6_ADDRESS_POOL_TYPE, value));
 }
 pub fn lookup_stateful_ipv6_address_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(STATEFUL_IPV6_ADDRESS_POOL_TYPE).map(|v| v.encode_string())
-        .lookup(STATEFUL_IPV6_ADDRESS_POOL_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_stateful_ipv6_address_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc7055.rs

@@ -1,7 +1,35 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const GSS_ACCEPTOR_SERVICE_NAME_TYPE: AVPType = 164;
 pub fn delete_gss_acceptor_service_name(packet: &mut Packet) {
@@ -11,9 +39,7 @@ pub fn add_gss_acceptor_service_name(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(GSS_ACCEPTOR_SERVICE_NAME_TYPE, value));
 }
 pub fn lookup_gss_acceptor_service_name(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(GSS_ACCEPTOR_SERVICE_NAME_TYPE).map(|v| v.encode_string())
-        .lookup(GSS_ACCEPTOR_SERVICE_NAME_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_gss_acceptor_service_name(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -31,9 +57,7 @@ pub fn add_gss_acceptor_host_name(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(GSS_ACCEPTOR_HOST_NAME_TYPE, value));
 }
 pub fn lookup_gss_acceptor_host_name(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(GSS_ACCEPTOR_HOST_NAME_TYPE).map(|v| v.encode_string())
-        .lookup(GSS_ACCEPTOR_HOST_NAME_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_gss_acceptor_host_name(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -51,9 +75,7 @@ pub fn add_gss_acceptor_service_specifics(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(GSS_ACCEPTOR_SERVICE_SPECIFICS_TYPE, value));
 }
 pub fn lookup_gss_acceptor_service_specifics(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(GSS_ACCEPTOR_SERVICE_SPECIFICS_TYPE).map(|v| v.encode_string())
-        .lookup(GSS_ACCEPTOR_SERVICE_SPECIFICS_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_gss_acceptor_service_specifics(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();
@@ -71,9 +93,7 @@ pub fn add_gss_acceptor_realm_name(packet: &mut Packet, value: &str) {
     packet.add(AVP::from_string(GSS_ACCEPTOR_REALM_NAME_TYPE, value));
 }
 pub fn lookup_gss_acceptor_realm_name(packet: &Packet) -> Option<Result<String, AVPError>> {
-    packet
+    packet.lookup(GSS_ACCEPTOR_REALM_NAME_TYPE).map(|v| v.encode_string())
-        .lookup(GSS_ACCEPTOR_REALM_NAME_TYPE)
-        .map(|v| v.encode_string())
 }
 pub fn lookup_all_gss_acceptor_realm_name(packet: &Packet) -> Result<Vec<String>, AVPError> {
     let mut vec = Vec::new();

radius/src/core/rfc7155.rs

@@ -1,7 +1,36 @@
 // Code generated by machine generator; DO NOT EDIT.
 
-use crate::avp::{AVPError, AVPType, AVP};
+
-use crate::packet::Packet;
+
+
+
+use crate::core::avp::{AVP, AVPType, AVPError};
+use crate::core::packet::Packet;
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
 pub const ORIGINATING_LINE_INFO_TYPE: AVPType = 94;
 pub fn delete_originating_line_info(packet: &mut Packet) {
@@ -9,18 +38,13 @@ pub fn delete_originating_line_info(packet: &mut Packet) {
 }
 pub fn add_originating_line_info(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
     if value.len() != 2 {
-        return Err(AVPError::InvalidAttributeLengthError(
+        return Err(AVPError::InvalidAttributeLengthError("2 bytes".to_owned(), value.len()));
-            "2 bytes".to_owned(),
-            value.len(),
-        ));
     }
     packet.add(AVP::from_bytes(ORIGINATING_LINE_INFO_TYPE, value));
     Ok(())
 }
 pub fn lookup_originating_line_info(packet: &Packet) -> Option<Vec<u8>> {
-    packet
+    packet.lookup(ORIGINATING_LINE_INFO_TYPE).map(|v| v.encode_bytes())
-        .lookup(ORIGINATING_LINE_INFO_TYPE)
-        .map(|v| v.encode_bytes())
 }
 pub fn lookup_all_originating_line_info(packet: &Packet) -> Vec<Vec<u8>> {
     let mut vec = Vec::new();

radius/src/core/tag.rs

@@ -33,7 +33,7 @@ impl Tag {
 
 #[cfg(test)]
 mod tests {
-    use crate::tag::Tag;
+    use crate::core::tag::Tag;
 
     #[test]
     fn test_is_zero() {

radius/src/lib.rs

@@ -1,30 +1,6 @@
-pub(crate) mod attributes;
+#[macro_use]
-pub mod avp;
+extern crate log;
-pub mod code;
+
-pub mod packet;
+pub mod client;
-pub mod request;
+pub mod core;
-pub mod rfc2865;
+pub mod server;
-pub mod rfc2866;
-pub mod rfc2867;
-pub mod rfc2868;
-pub mod rfc2869;
-pub mod rfc3162;
-pub mod rfc3576;
-pub mod rfc3580;
-pub mod rfc4072;
-pub mod rfc4372;
-pub mod rfc4603;
-pub mod rfc4675;
-pub mod rfc4818;
-pub mod rfc4849;
-pub mod rfc5090;
-pub mod rfc5176;
-pub mod rfc5607;
-pub mod rfc5904;
-pub mod rfc6519;
-pub mod rfc6572;
-pub mod rfc6677;
-pub mod rfc6911;
-pub mod rfc7055;
-pub mod rfc7155;
-pub mod tag;

radius/src/server.rs

@@ -1,3 +1,4 @@
+use async_trait::async_trait;
 use std::borrow::Borrow;
 use std::collections::HashSet;
 use std::future::Future;
@@ -5,12 +6,11 @@ use std::io;
 use std::net::SocketAddr;
 use std::sync::{Arc, RwLock};
 
+use thiserror::Error;
 use tokio::net::UdpSocket;
 
-use crate::request_handler::RequestHandler;
+use crate::core::packet::Packet;
-use crate::secret_provider::SecretProvider;
+use crate::core::request::Request;
-use radius::packet::Packet;
-use radius::request::Request;
 use std::fmt::Debug;
 
 /// A basic implementation of the RADIUS server.
@@ -169,6 +169,36 @@ impl Server {
     }
 }
 
+/// RequestHandler is a handler for the received RADIUS request.
+#[async_trait]
+pub trait RequestHandler<T, E>: 'static + Sync + Send {
+    /// This method has to implement the core feature of the server application what you need.
+    ///
+    /// # Arguments
+    ///
+    /// * conn - This connection is associated with the remote requester. In the most situations,
+    ///          you have to send a response through this connection object.
+    /// * request - This is a request object that comes from the remote requester.
+    async fn handle_radius_request(&self, conn: &UdpSocket, request: &Request) -> Result<T, E>;
+}
+
+#[derive(Error, Debug)]
+pub enum SecretProviderError {
+    /// An error that represents a failure to fetch a secret value from the provider.
+    #[error("failed to fetch a secret value: {0}")]
+    FailedFetchingError(String),
+    /// An error that represents a generic (i.e. unclassified) error that occurs on the secret value provider.
+    #[error("unexpected error: {0}")]
+    GenericError(String),
+}
+
+/// SecretProvider is a provider for secret value.
+pub trait SecretProvider: 'static + Sync + Send {
+    /// This method has to implement the generator of the secret value to verify the request of
+    /// `Accounting-Response`, `Accounting-Response` and `CoA-Request`.
+    fn fetch_secret(&self, remote_addr: SocketAddr) -> Result<Vec<u8>, SecretProviderError>;
+}
+
 #[derive(PartialEq, Eq, Hash, Clone)]
 struct RequestKey {
     ip: String,

scripts/generate-code.sh

@@ -14,13 +14,13 @@ for DICT in ${DICTS[@]}; do
   DICT_NAME="${DICT##*.}"
   DICT_FILE="${DICTS_DIR}/dictionary.${DICT_NAME}"
   if [ -f "$DICT_FILE" ]; then
-    cat /dev/null > "${SRC_DIR}/${DICT_NAME}.rs"
+    cat /dev/null > "${SRC_DIR}/core/${DICT_NAME}.rs"
     DICT_FILES+=("$DICT_FILE")
   fi
 done
 
 # shellcheck disable=SC2068
-cargo run --bin code-generator -- --out-dir="${SRC_DIR}/" ${DICT_FILES[@]}
+cargo run --bin code-generator -- --out-dir="${SRC_DIR}/core/" ${DICT_FILES[@]}
 
 cargo fix --allow-dirty --allow-staged
 cargo fmt