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

Fix weird method names that are generated automatically

Browse Source
This commit is contained in:
moznion
2020-12-08 00:46:12 +09:00
parent 60b67cc2f1
commit cda352e87f
8 changed files with 190 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
dicts/dictionary.rfc3162
View File

@@ -8,9 +8,9 @@
#
# $Id$
#
ATTRIBUTE NAS-Ipv6-Address 95 ipv6addr
ATTRIBUTE NAS-IPV6-Address 95 ipv6addr
ATTRIBUTE Framed-Interface-Id 96 ifid
ATTRIBUTE Framed-Ipv6-Prefix 97 ipv6prefix
ATTRIBUTE Login-Ipv6-Host 98 ipv6addr
ATTRIBUTE Framed-Ipv6-Route 99 string
ATTRIBUTE Framed-Ipv6-Pool 100 string
ATTRIBUTE Framed-IPV6-Prefix 97 ipv6prefix
ATTRIBUTE Login-IPV6-Host 98 ipv6addr
ATTRIBUTE Framed-IPV6-Route 99 string
ATTRIBUTE Framed-IPV6-Pool 100 string

2
dicts/dictionary.rfc4818
View File

@@ -11,4 +11,4 @@
#
##############################################################################
ATTRIBUTE Delegated-IPv6-Prefix 123 ipv6prefix
ATTRIBUTE Delegated-IPV6-Prefix 123 ipv6prefix

16
dicts/dictionary.rfc6572
View File

@@ -11,19 +11,19 @@
ATTRIBUTE Mobile-Node-Identifier 145 octets
ATTRIBUTE Service-Selection 146 string
ATTRIBUTE PMIP6-Home-LMA-IPv6-Address 147 ipv6addr
ATTRIBUTE PMIP6-Visited-LMA-IPv6-Address 148 ipv6addr
ATTRIBUTE PMIP6-Home-LMA-IPv4-Address 149 ipaddr
ATTRIBUTE PMIP6-Visited-LMA-IPv4-Address 150 ipaddr
ATTRIBUTE PMIP6-Home-LMA-IPV6-Address 147 ipv6addr
ATTRIBUTE PMIP6-Visited-LMA-IPV6-Address 148 ipv6addr
ATTRIBUTE PMIP6-Home-LMA-IPV4-Address 149 ipaddr
ATTRIBUTE PMIP6-Visited-LMA-IPV4-Address 150 ipaddr
ATTRIBUTE PMIP6-Home-HN-Prefix 151 ipv6prefix
ATTRIBUTE PMIP6-Visited-HN-Prefix 152 ipv6prefix
ATTRIBUTE PMIP6-Home-Interface-ID 153 ifid
ATTRIBUTE PMIP6-Visited-Interface-ID 154 ifid
ATTRIBUTE PMIP6-Home-IPv4-HoA 155 ipv4prefix
ATTRIBUTE PMIP6-Visited-IPv4-HoA 156 ipv4prefix
ATTRIBUTE PMIP6-Home-IPV4-HoA 155 ipv4prefix
ATTRIBUTE PMIP6-Visited-IPV4-HoA 156 ipv4prefix
ATTRIBUTE PMIP6-Home-DHCP4-Server-Address 157 ipaddr
ATTRIBUTE PMIP6-Visited-DHCP4-Server-Address 158 ipaddr
ATTRIBUTE PMIP6-Home-DHCP6-Server-Address 159 ipv6addr
ATTRIBUTE PMIP6-Visited-DHCP6-Server-Address 160 ipv6addr
ATTRIBUTE PMIP6-Home-IPv4-Gateway 161 ipaddr
ATTRIBUTE PMIP6-Visited-IPv4-Gateway 162 ipaddr
ATTRIBUTE PMIP6-Home-IPV4-Gateway 161 ipaddr
ATTRIBUTE PMIP6-Visited-IPV4-Gateway 162 ipaddr

10
dicts/dictionary.rfc6911
View File

@@ -7,8 +7,8 @@
# http://www.ietf.org/rfc/rfc6911.txt
#
ATTRIBUTE Framed-IPv6-Address 168 ipv6addr
ATTRIBUTE DNS-Server-IPv6-Address 169 ipv6addr
ATTRIBUTE Route-IPv6-Information 170 ipv6prefix
ATTRIBUTE Delegated-IPv6-Prefix-Pool 171 string
ATTRIBUTE Stateful-IPv6-Address-Pool 172 string
ATTRIBUTE Framed-IPV6-Address 168 ipv6addr
ATTRIBUTE DNS-Server-IPV6-Address 169 ipv6addr
ATTRIBUTE Route-IPV6-Information 170 ipv6prefix
ATTRIBUTE Delegated-IPV6-Prefix-Pool 171 string
ATTRIBUTE Stateful-IPV6-Address-Pool 172 string

92
radius/src/rfc3162.rs
View File

@@ -5,21 +5,21 @@ use std::net::Ipv6Addr;
use crate::avp::{AVPError, AVPType, AVP};
use crate::packet::Packet;
pub const NAS_IPV_6_ADDRESS_TYPE: AVPType = 95;
pub fn delete_nas_ipv_6_address(packet: &mut Packet) {
packet.delete(NAS_IPV_6_ADDRESS_TYPE);
pub const NAS_IPV6_ADDRESS_TYPE: AVPType = 95;
pub fn delete_nas_ipv6_address(packet: &mut Packet) {
packet.delete(NAS_IPV6_ADDRESS_TYPE);
}
pub fn add_nas_ipv_6_address(packet: &mut Packet, value: &Ipv6Addr) {
packet.add(AVP::from_ipv6(NAS_IPV_6_ADDRESS_TYPE, value));
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_ipv_6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
pub fn lookup_nas_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
packet
.lookup(NAS_IPV_6_ADDRESS_TYPE)
.lookup(NAS_IPV6_ADDRESS_TYPE)
.map(|v| v.encode_ipv6())
}
pub fn lookup_all_nas_ipv_6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
pub fn lookup_all_nas_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(NAS_IPV_6_ADDRESS_TYPE) {
for avp in packet.lookup_all(NAS_IPV6_ADDRESS_TYPE) {
vec.push(avp.encode_ipv6()?)
}
Ok(vec)
@@ -49,82 +49,80 @@ pub fn lookup_all_framed_interface_id(packet: &Packet) -> Vec<Vec<u8>> {
vec
}
pub const FRAMED_IPV_6_PREFIX_TYPE: AVPType = 97;
pub fn delete_framed_ipv_6_prefix(packet: &mut Packet) {
packet.delete(FRAMED_IPV_6_PREFIX_TYPE);
pub const FRAMED_IPV6_PREFIX_TYPE: AVPType = 97;
pub fn delete_framed_ipv6_prefix(packet: &mut Packet) {
packet.delete(FRAMED_IPV6_PREFIX_TYPE);
}
pub fn add_framed_ipv_6_prefix(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv6_prefix(FRAMED_IPV_6_PREFIX_TYPE, value)?);
pub fn add_framed_ipv6_prefix(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv6_prefix(FRAMED_IPV6_PREFIX_TYPE, value)?);
Ok(())
}
pub fn lookup_framed_ipv_6_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
pub fn lookup_framed_ipv6_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
packet
.lookup(FRAMED_IPV_6_PREFIX_TYPE)
.lookup(FRAMED_IPV6_PREFIX_TYPE)
.map(|v| v.encode_ipv6_prefix())
}
pub fn lookup_all_framed_ipv_6_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
pub fn lookup_all_framed_ipv6_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_IPV_6_PREFIX_TYPE) {
for avp in packet.lookup_all(FRAMED_IPV6_PREFIX_TYPE) {
vec.push(avp.encode_ipv6_prefix()?)
}
Ok(vec)
}
pub const LOGIN_IPV_6_HOST_TYPE: AVPType = 98;
pub fn delete_login_ipv_6_host(packet: &mut Packet) {
packet.delete(LOGIN_IPV_6_HOST_TYPE);
pub const LOGIN_IPV6_HOST_TYPE: AVPType = 98;
pub fn delete_login_ipv6_host(packet: &mut Packet) {
packet.delete(LOGIN_IPV6_HOST_TYPE);
}
pub fn add_login_ipv_6_host(packet: &mut Packet, value: &Ipv6Addr) {
packet.add(AVP::from_ipv6(LOGIN_IPV_6_HOST_TYPE, value));
pub fn add_login_ipv6_host(packet: &mut Packet, value: &Ipv6Addr) {
packet.add(AVP::from_ipv6(LOGIN_IPV6_HOST_TYPE, value));
}
pub fn lookup_login_ipv_6_host(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
packet
.lookup(LOGIN_IPV_6_HOST_TYPE)
.map(|v| v.encode_ipv6())
pub fn lookup_login_ipv6_host(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
packet.lookup(LOGIN_IPV6_HOST_TYPE).map(|v| v.encode_ipv6())
}
pub fn lookup_all_login_ipv_6_host(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
pub fn lookup_all_login_ipv6_host(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(LOGIN_IPV_6_HOST_TYPE) {
for avp in packet.lookup_all(LOGIN_IPV6_HOST_TYPE) {
vec.push(avp.encode_ipv6()?)
}
Ok(vec)
}
pub const FRAMED_IPV_6_ROUTE_TYPE: AVPType = 99;
pub fn delete_framed_ipv_6_route(packet: &mut Packet) {
packet.delete(FRAMED_IPV_6_ROUTE_TYPE);
pub const FRAMED_IPV6_ROUTE_TYPE: AVPType = 99;
pub fn delete_framed_ipv6_route(packet: &mut Packet) {
packet.delete(FRAMED_IPV6_ROUTE_TYPE);
}
pub fn add_framed_ipv_6_route(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(FRAMED_IPV_6_ROUTE_TYPE, value));
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_ipv_6_route(packet: &Packet) -> Option<Result<String, AVPError>> {
pub fn lookup_framed_ipv6_route(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(FRAMED_IPV_6_ROUTE_TYPE)
.lookup(FRAMED_IPV6_ROUTE_TYPE)
.map(|v| v.encode_string())
}
pub fn lookup_all_framed_ipv_6_route(packet: &Packet) -> Result<Vec<String>, AVPError> {
pub fn lookup_all_framed_ipv6_route(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_IPV_6_ROUTE_TYPE) {
for avp in packet.lookup_all(FRAMED_IPV6_ROUTE_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const FRAMED_IPV_6_POOL_TYPE: AVPType = 100;
pub fn delete_framed_ipv_6_pool(packet: &mut Packet) {
packet.delete(FRAMED_IPV_6_POOL_TYPE);
pub const FRAMED_IPV6_POOL_TYPE: AVPType = 100;
pub fn delete_framed_ipv6_pool(packet: &mut Packet) {
packet.delete(FRAMED_IPV6_POOL_TYPE);
}
pub fn add_framed_ipv_6_pool(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(FRAMED_IPV_6_POOL_TYPE, value));
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_ipv_6_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
pub fn lookup_framed_ipv6_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(FRAMED_IPV_6_POOL_TYPE)
.lookup(FRAMED_IPV6_POOL_TYPE)
.map(|v| v.encode_string())
}
pub fn lookup_all_framed_ipv_6_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
pub fn lookup_all_framed_ipv6_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_IPV_6_POOL_TYPE) {
for avp in packet.lookup_all(FRAMED_IPV6_POOL_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)

18
radius/src/rfc4818.rs
View File

@@ -3,22 +3,22 @@
use crate::avp::{AVPError, AVPType, AVP};
use crate::packet::Packet;
pub const DELEGATED_I_PV_6_PREFIX_TYPE: AVPType = 123;
pub fn delete_delegated_i_pv_6_prefix(packet: &mut Packet) {
packet.delete(DELEGATED_I_PV_6_PREFIX_TYPE);
pub const DELEGATED_IPV6_PREFIX_TYPE: AVPType = 123;
pub fn delete_delegated_ipv6_prefix(packet: &mut Packet) {
packet.delete(DELEGATED_IPV6_PREFIX_TYPE);
}
pub fn add_delegated_i_pv_6_prefix(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv6_prefix(DELEGATED_I_PV_6_PREFIX_TYPE, value)?);
pub fn add_delegated_ipv6_prefix(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv6_prefix(DELEGATED_IPV6_PREFIX_TYPE, value)?);
Ok(())
}
pub fn lookup_delegated_i_pv_6_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
pub fn lookup_delegated_ipv6_prefix(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
packet
.lookup(DELEGATED_I_PV_6_PREFIX_TYPE)
.lookup(DELEGATED_IPV6_PREFIX_TYPE)
.map(|v| v.encode_ipv6_prefix())
}
pub fn lookup_all_delegated_i_pv_6_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
pub fn lookup_all_delegated_ipv6_prefix(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DELEGATED_I_PV_6_PREFIX_TYPE) {
for avp in packet.lookup_all(DELEGATED_IPV6_PREFIX_TYPE) {
vec.push(avp.encode_ipv6_prefix()?)
}
Ok(vec)

151
radius/src/rfc6572.rs
View File

@@ -45,93 +45,89 @@ pub fn lookup_all_service_selection(packet: &Packet) -> Result<Vec<String>, AVPE
Ok(vec)
}
pub const PMIP6_HOME_LMA_I_PV_6_ADDRESS_TYPE: AVPType = 147;
pub fn delete_pmip6_home_lma_i_pv_6_address(packet: &mut Packet) {
packet.delete(PMIP6_HOME_LMA_I_PV_6_ADDRESS_TYPE);
pub const PMIP6_HOME_LMA_IPV6_ADDRESS_TYPE: AVPType = 147;
pub fn delete_pmip6_home_lma_ipv6_address(packet: &mut Packet) {
packet.delete(PMIP6_HOME_LMA_IPV6_ADDRESS_TYPE);
}
pub fn add_pmip6_home_lma_i_pv_6_address(packet: &mut Packet, value: &Ipv6Addr) {
packet.add(AVP::from_ipv6(PMIP6_HOME_LMA_I_PV_6_ADDRESS_TYPE, value));
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_i_pv_6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
pub fn lookup_pmip6_home_lma_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
packet
.lookup(PMIP6_HOME_LMA_I_PV_6_ADDRESS_TYPE)
.lookup(PMIP6_HOME_LMA_IPV6_ADDRESS_TYPE)
.map(|v| v.encode_ipv6())
}
pub fn lookup_all_pmip6_home_lma_i_pv_6_address(
packet: &Packet,
) -> Result<Vec<Ipv6Addr>, AVPError> {
pub fn lookup_all_pmip6_home_lma_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_HOME_LMA_I_PV_6_ADDRESS_TYPE) {
for avp in packet.lookup_all(PMIP6_HOME_LMA_IPV6_ADDRESS_TYPE) {
vec.push(avp.encode_ipv6()?)
}
Ok(vec)
}
pub const PMIP6_VISITED_LMA_I_PV_6_ADDRESS_TYPE: AVPType = 148;
pub fn delete_pmip6_visited_lma_i_pv_6_address(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_LMA_I_PV_6_ADDRESS_TYPE);
pub const PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE: AVPType = 148;
pub fn delete_pmip6_visited_lma_ipv6_address(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE);
}
pub fn add_pmip6_visited_lma_i_pv_6_address(packet: &mut Packet, value: &Ipv6Addr) {
packet.add(AVP::from_ipv6(PMIP6_VISITED_LMA_I_PV_6_ADDRESS_TYPE, value));
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_i_pv_6_address(
pub fn lookup_pmip6_visited_lma_ipv6_address(
packet: &Packet,
) -> Option<Result<Ipv6Addr, AVPError>> {
packet
.lookup(PMIP6_VISITED_LMA_I_PV_6_ADDRESS_TYPE)
.lookup(PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE)
.map(|v| v.encode_ipv6())
}
pub fn lookup_all_pmip6_visited_lma_i_pv_6_address(
pub fn lookup_all_pmip6_visited_lma_ipv6_address(
packet: &Packet,
) -> Result<Vec<Ipv6Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_VISITED_LMA_I_PV_6_ADDRESS_TYPE) {
for avp in packet.lookup_all(PMIP6_VISITED_LMA_IPV6_ADDRESS_TYPE) {
vec.push(avp.encode_ipv6()?)
}
Ok(vec)
}
pub const PMIP6_HOME_LMA_I_PV_4_ADDRESS_TYPE: AVPType = 149;
pub fn delete_pmip6_home_lma_i_pv_4_address(packet: &mut Packet) {
packet.delete(PMIP6_HOME_LMA_I_PV_4_ADDRESS_TYPE);
pub const PMIP6_HOME_LMA_IPV4_ADDRESS_TYPE: AVPType = 149;
pub fn delete_pmip6_home_lma_ipv4_address(packet: &mut Packet) {
packet.delete(PMIP6_HOME_LMA_IPV4_ADDRESS_TYPE);
}
pub fn add_pmip6_home_lma_i_pv_4_address(packet: &mut Packet, value: &Ipv4Addr) {
packet.add(AVP::from_ipv4(PMIP6_HOME_LMA_I_PV_4_ADDRESS_TYPE, value));
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_i_pv_4_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
pub fn lookup_pmip6_home_lma_ipv4_address(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet
.lookup(PMIP6_HOME_LMA_I_PV_4_ADDRESS_TYPE)
.lookup(PMIP6_HOME_LMA_IPV4_ADDRESS_TYPE)
.map(|v| v.encode_ipv4())
}
pub fn lookup_all_pmip6_home_lma_i_pv_4_address(
packet: &Packet,
) -> Result<Vec<Ipv4Addr>, AVPError> {
pub fn lookup_all_pmip6_home_lma_ipv4_address(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_HOME_LMA_I_PV_4_ADDRESS_TYPE) {
for avp in packet.lookup_all(PMIP6_HOME_LMA_IPV4_ADDRESS_TYPE) {
vec.push(avp.encode_ipv4()?)
}
Ok(vec)
}
pub const PMIP6_VISITED_LMA_I_PV_4_ADDRESS_TYPE: AVPType = 150;
pub fn delete_pmip6_visited_lma_i_pv_4_address(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_LMA_I_PV_4_ADDRESS_TYPE);
pub const PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE: AVPType = 150;
pub fn delete_pmip6_visited_lma_ipv4_address(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE);
}
pub fn add_pmip6_visited_lma_i_pv_4_address(packet: &mut Packet, value: &Ipv4Addr) {
packet.add(AVP::from_ipv4(PMIP6_VISITED_LMA_I_PV_4_ADDRESS_TYPE, value));
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_i_pv_4_address(
pub fn lookup_pmip6_visited_lma_ipv4_address(
packet: &Packet,
) -> Option<Result<Ipv4Addr, AVPError>> {
packet
.lookup(PMIP6_VISITED_LMA_I_PV_4_ADDRESS_TYPE)
.lookup(PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE)
.map(|v| v.encode_ipv4())
}
pub fn lookup_all_pmip6_visited_lma_i_pv_4_address(
pub fn lookup_all_pmip6_visited_lma_ipv4_address(
packet: &Packet,
) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_VISITED_LMA_I_PV_4_ADDRESS_TYPE) {
for avp in packet.lookup_all(PMIP6_VISITED_LMA_IPV4_ADDRESS_TYPE) {
vec.push(avp.encode_ipv4()?)
}
Ok(vec)
@@ -227,46 +223,43 @@ pub fn lookup_all_pmip6_visited_interface_id(packet: &Packet) -> Vec<Vec<u8>> {
vec
}
pub const PMIP6_HOME_I_PV_4_HO_A_TYPE: AVPType = 155;
pub fn delete_pmip6_home_i_pv_4_ho_a(packet: &mut Packet) {
packet.delete(PMIP6_HOME_I_PV_4_HO_A_TYPE);
pub const PMIP6_HOME_IPV4_HO_A_TYPE: AVPType = 155;
pub fn delete_pmip6_home_ipv4_ho_a(packet: &mut Packet) {
packet.delete(PMIP6_HOME_IPV4_HO_A_TYPE);
}
pub fn add_pmip6_home_i_pv_4_ho_a(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv4_prefix(PMIP6_HOME_I_PV_4_HO_A_TYPE, value)?);
pub fn add_pmip6_home_ipv4_ho_a(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv4_prefix(PMIP6_HOME_IPV4_HO_A_TYPE, value)?);
Ok(())
}
pub fn lookup_pmip6_home_i_pv_4_ho_a(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
pub fn lookup_pmip6_home_ipv4_ho_a(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
packet
.lookup(PMIP6_HOME_I_PV_4_HO_A_TYPE)
.lookup(PMIP6_HOME_IPV4_HO_A_TYPE)
.map(|v| v.encode_ipv4_prefix())
}
pub fn lookup_all_pmip6_home_i_pv_4_ho_a(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
pub fn lookup_all_pmip6_home_ipv4_ho_a(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_HOME_I_PV_4_HO_A_TYPE) {
for avp in packet.lookup_all(PMIP6_HOME_IPV4_HO_A_TYPE) {
vec.push(avp.encode_ipv4_prefix()?)
}
Ok(vec)
}
pub const PMIP6_VISITED_I_PV_4_HO_A_TYPE: AVPType = 156;
pub fn delete_pmip6_visited_i_pv_4_ho_a(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_I_PV_4_HO_A_TYPE);
pub const PMIP6_VISITED_IPV4_HO_A_TYPE: AVPType = 156;
pub fn delete_pmip6_visited_ipv4_ho_a(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_IPV4_HO_A_TYPE);
}
pub fn add_pmip6_visited_i_pv_4_ho_a(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv4_prefix(
PMIP6_VISITED_I_PV_4_HO_A_TYPE,
value,
)?);
pub fn add_pmip6_visited_ipv4_ho_a(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv4_prefix(PMIP6_VISITED_IPV4_HO_A_TYPE, value)?);
Ok(())
}
pub fn lookup_pmip6_visited_i_pv_4_ho_a(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
pub fn lookup_pmip6_visited_ipv4_ho_a(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
packet
.lookup(PMIP6_VISITED_I_PV_4_HO_A_TYPE)
.lookup(PMIP6_VISITED_IPV4_HO_A_TYPE)
.map(|v| v.encode_ipv4_prefix())
}
pub fn lookup_all_pmip6_visited_i_pv_4_ho_a(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
pub fn lookup_all_pmip6_visited_ipv4_ho_a(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_VISITED_I_PV_4_HO_A_TYPE) {
for avp in packet.lookup_all(PMIP6_VISITED_IPV4_HO_A_TYPE) {
vec.push(avp.encode_ipv4_prefix()?)
}
Ok(vec)
@@ -374,41 +367,41 @@ pub fn lookup_all_pmip6_visited_dhcp6_server_address(
Ok(vec)
}
pub const PMIP6_HOME_I_PV_4_GATEWAY_TYPE: AVPType = 161;
pub fn delete_pmip6_home_i_pv_4_gateway(packet: &mut Packet) {
packet.delete(PMIP6_HOME_I_PV_4_GATEWAY_TYPE);
pub const PMIP6_HOME_IPV4_GATEWAY_TYPE: AVPType = 161;
pub fn delete_pmip6_home_ipv4_gateway(packet: &mut Packet) {
packet.delete(PMIP6_HOME_IPV4_GATEWAY_TYPE);
}
pub fn add_pmip6_home_i_pv_4_gateway(packet: &mut Packet, value: &Ipv4Addr) {
packet.add(AVP::from_ipv4(PMIP6_HOME_I_PV_4_GATEWAY_TYPE, value));
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_i_pv_4_gateway(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
pub fn lookup_pmip6_home_ipv4_gateway(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet
.lookup(PMIP6_HOME_I_PV_4_GATEWAY_TYPE)
.lookup(PMIP6_HOME_IPV4_GATEWAY_TYPE)
.map(|v| v.encode_ipv4())
}
pub fn lookup_all_pmip6_home_i_pv_4_gateway(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
pub fn lookup_all_pmip6_home_ipv4_gateway(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_HOME_I_PV_4_GATEWAY_TYPE) {
for avp in packet.lookup_all(PMIP6_HOME_IPV4_GATEWAY_TYPE) {
vec.push(avp.encode_ipv4()?)
}
Ok(vec)
}
pub const PMIP6_VISITED_I_PV_4_GATEWAY_TYPE: AVPType = 162;
pub fn delete_pmip6_visited_i_pv_4_gateway(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_I_PV_4_GATEWAY_TYPE);
pub const PMIP6_VISITED_IPV4_GATEWAY_TYPE: AVPType = 162;
pub fn delete_pmip6_visited_ipv4_gateway(packet: &mut Packet) {
packet.delete(PMIP6_VISITED_IPV4_GATEWAY_TYPE);
}
pub fn add_pmip6_visited_i_pv_4_gateway(packet: &mut Packet, value: &Ipv4Addr) {
packet.add(AVP::from_ipv4(PMIP6_VISITED_I_PV_4_GATEWAY_TYPE, value));
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_i_pv_4_gateway(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
pub fn lookup_pmip6_visited_ipv4_gateway(packet: &Packet) -> Option<Result<Ipv4Addr, AVPError>> {
packet
.lookup(PMIP6_VISITED_I_PV_4_GATEWAY_TYPE)
.lookup(PMIP6_VISITED_IPV4_GATEWAY_TYPE)
.map(|v| v.encode_ipv4())
}
pub fn lookup_all_pmip6_visited_i_pv_4_gateway(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
pub fn lookup_all_pmip6_visited_ipv4_gateway(packet: &Packet) -> Result<Vec<Ipv4Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(PMIP6_VISITED_I_PV_4_GATEWAY_TYPE) {
for avp in packet.lookup_all(PMIP6_VISITED_IPV4_GATEWAY_TYPE) {
vec.push(avp.encode_ipv4()?)
}
Ok(vec)

90
radius/src/rfc6911.rs
View File

@@ -5,102 +5,102 @@ use std::net::Ipv6Addr;
use crate::avp::{AVPError, AVPType, AVP};
use crate::packet::Packet;
pub const FRAMED_I_PV_6_ADDRESS_TYPE: AVPType = 168;
pub fn delete_framed_i_pv_6_address(packet: &mut Packet) {
packet.delete(FRAMED_I_PV_6_ADDRESS_TYPE);
pub const FRAMED_IPV6_ADDRESS_TYPE: AVPType = 168;
pub fn delete_framed_ipv6_address(packet: &mut Packet) {
packet.delete(FRAMED_IPV6_ADDRESS_TYPE);
}
pub fn add_framed_i_pv_6_address(packet: &mut Packet, value: &Ipv6Addr) {
packet.add(AVP::from_ipv6(FRAMED_I_PV_6_ADDRESS_TYPE, value));
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_i_pv_6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
pub fn lookup_framed_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
packet
.lookup(FRAMED_I_PV_6_ADDRESS_TYPE)
.lookup(FRAMED_IPV6_ADDRESS_TYPE)
.map(|v| v.encode_ipv6())
}
pub fn lookup_all_framed_i_pv_6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
pub fn lookup_all_framed_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(FRAMED_I_PV_6_ADDRESS_TYPE) {
for avp in packet.lookup_all(FRAMED_IPV6_ADDRESS_TYPE) {
vec.push(avp.encode_ipv6()?)
}
Ok(vec)
}
pub const DNS_SERVER_I_PV_6_ADDRESS_TYPE: AVPType = 169;
pub fn delete_dns_server_i_pv_6_address(packet: &mut Packet) {
packet.delete(DNS_SERVER_I_PV_6_ADDRESS_TYPE);
pub const DNS_SERVER_IPV6_ADDRESS_TYPE: AVPType = 169;
pub fn delete_dns_server_ipv6_address(packet: &mut Packet) {
packet.delete(DNS_SERVER_IPV6_ADDRESS_TYPE);
}
pub fn add_dns_server_i_pv_6_address(packet: &mut Packet, value: &Ipv6Addr) {
packet.add(AVP::from_ipv6(DNS_SERVER_I_PV_6_ADDRESS_TYPE, value));
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_i_pv_6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
pub fn lookup_dns_server_ipv6_address(packet: &Packet) -> Option<Result<Ipv6Addr, AVPError>> {
packet
.lookup(DNS_SERVER_I_PV_6_ADDRESS_TYPE)
.lookup(DNS_SERVER_IPV6_ADDRESS_TYPE)
.map(|v| v.encode_ipv6())
}
pub fn lookup_all_dns_server_i_pv_6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
pub fn lookup_all_dns_server_ipv6_address(packet: &Packet) -> Result<Vec<Ipv6Addr>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DNS_SERVER_I_PV_6_ADDRESS_TYPE) {
for avp in packet.lookup_all(DNS_SERVER_IPV6_ADDRESS_TYPE) {
vec.push(avp.encode_ipv6()?)
}
Ok(vec)
}
pub const ROUTE_I_PV_6_INFORMATION_TYPE: AVPType = 170;
pub fn delete_route_i_pv_6_information(packet: &mut Packet) {
packet.delete(ROUTE_I_PV_6_INFORMATION_TYPE);
pub const ROUTE_IPV6_INFORMATION_TYPE: AVPType = 170;
pub fn delete_route_ipv6_information(packet: &mut Packet) {
packet.delete(ROUTE_IPV6_INFORMATION_TYPE);
}
pub fn add_route_i_pv_6_information(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv6_prefix(ROUTE_I_PV_6_INFORMATION_TYPE, value)?);
pub fn add_route_ipv6_information(packet: &mut Packet, value: &[u8]) -> Result<(), AVPError> {
packet.add(AVP::from_ipv6_prefix(ROUTE_IPV6_INFORMATION_TYPE, value)?);
Ok(())
}
pub fn lookup_route_i_pv_6_information(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
pub fn lookup_route_ipv6_information(packet: &Packet) -> Option<Result<Vec<u8>, AVPError>> {
packet
.lookup(ROUTE_I_PV_6_INFORMATION_TYPE)
.lookup(ROUTE_IPV6_INFORMATION_TYPE)
.map(|v| v.encode_ipv6_prefix())
}
pub fn lookup_all_route_i_pv_6_information(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
pub fn lookup_all_route_ipv6_information(packet: &Packet) -> Result<Vec<Vec<u8>>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(ROUTE_I_PV_6_INFORMATION_TYPE) {
for avp in packet.lookup_all(ROUTE_IPV6_INFORMATION_TYPE) {
vec.push(avp.encode_ipv6_prefix()?)
}
Ok(vec)
}
pub const DELEGATED_I_PV_6_PREFIX_POOL_TYPE: AVPType = 171;
pub fn delete_delegated_i_pv_6_prefix_pool(packet: &mut Packet) {
packet.delete(DELEGATED_I_PV_6_PREFIX_POOL_TYPE);
pub const DELEGATED_IPV6_PREFIX_POOL_TYPE: AVPType = 171;
pub fn delete_delegated_ipv6_prefix_pool(packet: &mut Packet) {
packet.delete(DELEGATED_IPV6_PREFIX_POOL_TYPE);
}
pub fn add_delegated_i_pv_6_prefix_pool(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DELEGATED_I_PV_6_PREFIX_POOL_TYPE, value));
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_i_pv_6_prefix_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
pub fn lookup_delegated_ipv6_prefix_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(DELEGATED_I_PV_6_PREFIX_POOL_TYPE)
.lookup(DELEGATED_IPV6_PREFIX_POOL_TYPE)
.map(|v| v.encode_string())
}
pub fn lookup_all_delegated_i_pv_6_prefix_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
pub fn lookup_all_delegated_ipv6_prefix_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DELEGATED_I_PV_6_PREFIX_POOL_TYPE) {
for avp in packet.lookup_all(DELEGATED_IPV6_PREFIX_POOL_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const STATEFUL_I_PV_6_ADDRESS_POOL_TYPE: AVPType = 172;
pub fn delete_stateful_i_pv_6_address_pool(packet: &mut Packet) {
packet.delete(STATEFUL_I_PV_6_ADDRESS_POOL_TYPE);
pub const STATEFUL_IPV6_ADDRESS_POOL_TYPE: AVPType = 172;
pub fn delete_stateful_ipv6_address_pool(packet: &mut Packet) {
packet.delete(STATEFUL_IPV6_ADDRESS_POOL_TYPE);
}
pub fn add_stateful_i_pv_6_address_pool(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(STATEFUL_I_PV_6_ADDRESS_POOL_TYPE, value));
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_i_pv_6_address_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
pub fn lookup_stateful_ipv6_address_pool(packet: &Packet) -> Option<Result<String, AVPError>> {
packet
.lookup(STATEFUL_I_PV_6_ADDRESS_POOL_TYPE)
.lookup(STATEFUL_IPV6_ADDRESS_POOL_TYPE)
.map(|v| v.encode_string())
}
pub fn lookup_all_stateful_i_pv_6_address_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
pub fn lookup_all_stateful_ipv6_address_pool(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(STATEFUL_I_PV_6_ADDRESS_POOL_TYPE) {
for avp in packet.lookup_all(STATEFUL_IPV6_ADDRESS_POOL_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)