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

Refactor: Attribute -> AVP

Browse Source
This commit is contained in:
moznion
2020-11-28 16:20:38 +09:00
parent 505ac8d61d
commit 43f3e5f844
10 changed files with 534 additions and 576 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
scripts/generate_code.sh
View File

@@ -20,6 +20,6 @@ for DICT in ${DICTS[@]}; do
cargo run --bin code_gen "${DICTS_DIR}/dictionary.${DICT_NAME}" "${SRC_DIR}/${DICT_NAME}.rs"
done
cargo fix --allow-dirty
cargo fix --allow-dirty --allow-staged
cargo fmt

305
src/attribute.rs
View File

@@ -1,305 +0,0 @@
use std::convert::TryInto;
use std::net::{Ipv4Addr, Ipv6Addr};
use std::string::FromUtf8Error;
use chrono::{DateTime, TimeZone, Utc};
#[derive(Debug, Clone, PartialEq)]
pub struct Attribute(pub(crate) Vec<u8>);
impl Attribute {
pub fn from_u32(v: u32) -> Self {
Attribute(u32::to_be_bytes(v).to_vec())
}
pub fn from_string(v: &str) -> Self {
Attribute(v.as_bytes().to_vec())
}
pub fn from_bytes(v: &[u8]) -> Self {
Attribute(v.to_vec())
}
pub fn from_ipv4(v: &Ipv4Addr) -> Self {
Attribute(v.octets().to_vec())
}
pub fn from_ipv6(v: &Ipv6Addr) -> Self {
Attribute(v.octets().to_vec())
}
pub fn from_user_password(
plain_text: &[u8],
secret: &[u8],
request_authenticator: &[u8],
) -> Result<Self, String> {
if plain_text.len() > 128 {
return Err(
"the length of plain_text has to be within 128, but the given value is longer"
.to_owned(),
);
}
if secret.is_empty() {
return Err("secret hasn't be empty, but the given value is empty".to_owned());
}
if request_authenticator.len() != 16 {
return Err(
"request_authenticator has to have 16-bytes payload, but the given value doesn't"
.to_owned(),
);
}
let mut buff = request_authenticator.to_vec();
let l = plain_text.len();
if l < 16 {
let enc = md5::compute([secret, &buff[..]].concat()).to_vec();
return Ok(Attribute(
enc.iter()
.zip([plain_text, vec![0 as u8; 16 - l].as_slice()].concat())
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ zero padding
.map(|(d, p)| d ^ p)
.collect(),
));
}
let mut enc: Vec<u8> = Vec::new();
for chunk in plain_text.chunks(16) {
let mut chunk_vec = chunk.to_vec();
let l = chunk.len();
if l < 16 {
chunk_vec.extend(vec![0 as u8; 16 - l]); // zero padding
}
let enc_block = md5::compute([secret, &buff[..]].concat()).to_vec();
buff = enc_block
.iter()
.zip(chunk_vec)
.map(|(d, p)| d ^ p)
.collect();
enc.extend(&buff);
}
Ok(Attribute(enc))
}
pub fn from_date(dt: &DateTime<Utc>) -> Self {
Attribute(u32::to_be_bytes(dt.timestamp() as u32).to_vec())
}
pub fn to_integer32(&self) -> Result<u32, String> {
const EXPECTED_SIZE: usize = std::mem::size_of::<u32>();
if self.0.len() != EXPECTED_SIZE {
return Err("invalid attribute length for integer".to_owned());
}
let (int_bytes, _) = self.0.split_at(EXPECTED_SIZE);
match int_bytes.try_into() {
Ok(boxed_array) => Ok(u32::from_be_bytes(boxed_array)),
Err(e) => Err(e.to_string()),
}
}
pub fn to_string(&self) -> Result<String, FromUtf8Error> {
String::from_utf8(self.0.to_vec())
}
pub fn to_bytes(&self) -> Vec<u8> {
self.0.to_vec()
}
pub fn to_ipv4(&self) -> Result<Ipv4Addr, String> {
const IPV4_SIZE: usize = std::mem::size_of::<Ipv4Addr>();
if self.0.len() != IPV4_SIZE {
return Err("invalid attribute length for ipv4 address".to_owned());
}
let (int_bytes, _) = self.0.split_at(IPV4_SIZE);
match int_bytes.try_into() {
Ok::<[u8; IPV4_SIZE], _>(boxed_array) => Ok(Ipv4Addr::from(boxed_array)),
Err(e) => Err(e.to_string()),
}
}
pub fn to_ipv6(&self) -> Result<Ipv6Addr, String> {
const IPV6_SIZE: usize = std::mem::size_of::<Ipv6Addr>();
if self.0.len() != IPV6_SIZE {
return Err("invalid attribute length for ipv6 address".to_owned());
}
let (int_bytes, _) = self.0.split_at(IPV6_SIZE);
match int_bytes.try_into() {
Ok::<[u8; IPV6_SIZE], _>(boxed_array) => Ok(Ipv6Addr::from(boxed_array)),
Err(e) => Err(e.to_string()),
}
}
pub fn to_user_password(
&self,
secret: &[u8],
request_authenticator: &[u8],
) -> Result<Vec<u8>, String> {
if self.0.len() < 16 || self.0.len() > 128 {
return Err(format!("invalid attribute length {}", self.0.len()));
}
if secret.is_empty() {
return Err("secret hasn't be empty, but the given value is empty".to_owned());
}
if request_authenticator.len() != 16 {
return Err(
"request_authenticator has to have 16-bytes payload, but the given value doesn't"
.to_owned(),
);
}
let mut dec: Vec<u8> = Vec::new();
let mut buff: Vec<u8> = request_authenticator.to_vec();
// NOTE:
// It ensures attribute value has 16 bytes length at least because the value is encoded by md5.
// And this must be aligned by each 16 bytes length.
for chunk in self.0.chunks(16) {
let chunk_vec = chunk.to_vec();
let dec_block = md5::compute([secret, &buff[..]].concat()).to_vec();
dec.extend(
dec_block
.iter()
.zip(&chunk_vec)
.map(|(d, p)| d ^ p)
.collect::<Vec<u8>>(),
);
buff = chunk_vec.clone();
}
// remove trailing zero bytes
match dec.split(|b| *b == 0).next() {
Some(dec) => Ok(dec.to_vec()),
None => Ok(vec![]),
}
}
pub fn to_date(&self) -> Result<DateTime<Utc>, String> {
let (int_bytes, _) = self.0.split_at(std::mem::size_of::<u32>());
match int_bytes.try_into() {
Ok(boxed_array) => {
let timestamp = u32::from_be_bytes(boxed_array);
Ok(Utc.timestamp(timestamp as i64, 0))
}
Err(e) => Err(e.to_string()),
}
}
}
#[cfg(test)]
mod tests {
use std::net::{Ipv4Addr, Ipv6Addr};
use std::string::FromUtf8Error;
use chrono::Utc;
use crate::attribute::Attribute;
#[test]
fn it_should_convert_attribute_to_integer32() -> Result<(), String> {
assert_eq!(Attribute(vec![1, 2, 3, 4]).to_integer32()?, 16909060);
Ok(())
}
#[test]
fn it_should_convert_attribute_to_string() -> Result<(), FromUtf8Error> {
assert_eq!(
Attribute(vec![
0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64
])
.to_string()?,
"Hello, World"
);
Ok(())
}
#[test]
fn it_should_convert_ipv4() -> Result<(), String> {
let given_ipv4 = Ipv4Addr::new(192, 0, 2, 1);
let ipv4_attr = Attribute::from_ipv4(&given_ipv4);
assert_eq!(ipv4_attr.to_ipv4()?, given_ipv4,);
Ok(())
}
#[test]
fn it_should_convert_ipv6() -> Result<(), String> {
let given_ipv6 = Ipv6Addr::new(
0x2001, 0x0db8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,
);
let ipv6_attr = Attribute::from_ipv6(&given_ipv6);
assert_eq!(ipv6_attr.to_ipv6()?, given_ipv6,);
Ok(())
}
#[test]
fn it_should_convert_user_password() {
let secret = b"12345".to_vec();
let request_authenticator = b"0123456789abcdef".to_vec();
struct TestCase<'a> {
plain_text: &'a str,
expected_encoded_len: usize,
};
let test_cases = &[
TestCase {
plain_text: "",
expected_encoded_len: 16,
},
TestCase {
plain_text: "abc",
expected_encoded_len: 16,
},
TestCase {
plain_text: "0123456789abcde",
expected_encoded_len: 16,
},
TestCase {
plain_text: "0123456789abcdef",
expected_encoded_len: 16,
},
TestCase {
plain_text: "0123456789abcdef0",
expected_encoded_len: 32,
},
TestCase {
plain_text: "0123456789abcdef0123456789abcdef0123456789abcdef",
expected_encoded_len: 48,
},
];
for test_case in test_cases {
let user_password_attr_result = Attribute::from_user_password(
test_case.plain_text.as_bytes(),
&secret,
&request_authenticator,
);
let user_password_attr = user_password_attr_result.unwrap();
assert_eq!(user_password_attr.0.len(), test_case.expected_encoded_len);
let decoded_password = user_password_attr
.to_user_password(&secret, &request_authenticator)
.unwrap();
assert_eq!(
String::from_utf8(decoded_password).unwrap(),
test_case.plain_text
);
}
}
#[test]
fn it_should_convert_date() -> Result<(), String> {
let now = Utc::now();
let attr = Attribute::from_date(&now);
assert_eq!(attr.to_date()?.timestamp(), now.timestamp(),);
Ok(())
}
}

34
src/attributes.rs
View File

@@ -1,14 +1,4 @@
use crate::attribute::Attribute;
pub type AVPType = u8;
pub const TYPE_INVALID: AVPType = 255;
#[derive(Debug, Clone, PartialEq)]
pub struct AVP {
typ: AVPType,
attribute: Attribute,
}
use crate::avp::{AVPType, AVP};
#[derive(Debug, Clone, PartialEq)]
pub struct Attributes(pub(crate) Vec<AVP>);
@@ -30,10 +20,10 @@ impl Attributes {
attrs.push(AVP {
typ: bs[i],
attribute: if length > 2 {
Attribute(bs[i + 2..i + length].to_vec())
value: if length > 2 {
bs[i + 2..i + length].to_vec()
} else {
Attribute(vec![])
vec![]
},
});
@@ -43,8 +33,8 @@ impl Attributes {
Ok(Attributes(attrs))
}
pub(crate) fn add(&mut self, typ: AVPType, attribute: Attribute) {
self.0.push(AVP { typ, attribute })
pub(crate) fn add(&mut self, avp: AVP) {
self.0.push(avp)
}
pub(crate) fn del(&mut self, typ: AVPType) {
@@ -56,21 +46,21 @@ impl Attributes {
.collect();
}
pub(crate) fn lookup(&self, typ: AVPType) -> Option<&Attribute> {
pub(crate) fn lookup(&self, typ: AVPType) -> Option<&AVP> {
self.0.iter().find_map(|avp| {
if avp.typ == typ {
return Some(&avp.attribute);
return Some(avp);
}
None
})
}
pub(crate) fn lookup_all(&self, typ: AVPType) -> Vec<&Attribute> {
pub(crate) fn lookup_all(&self, typ: AVPType) -> Vec<&AVP> {
self.0
.iter()
.filter_map(|avp| {
if avp.typ == typ {
Some(&avp.attribute);
Some(avp);
}
None
})
@@ -81,13 +71,13 @@ impl Attributes {
let mut encoded: Vec<u8> = Vec::new();
for avp in &self.0 {
let attr_len = avp.attribute.0.len();
let attr_len = avp.value.len();
if attr_len > 253 {
return Err("attribute is too large".to_owned());
}
encoded.push(avp.typ);
encoded.push(2 + attr_len as u8);
encoded.extend(&avp.attribute.0);
encoded.extend(&avp.value);
}
Ok(encoded)

333
src/avp.rs Normal file
View File

@@ -0,0 +1,333 @@
use std::convert::TryInto;
use std::net::{Ipv4Addr, Ipv6Addr};
use std::string::FromUtf8Error;
use chrono::{DateTime, TimeZone, Utc};
pub type AVPType = u8;
pub const TYPE_INVALID: AVPType = 255;
#[derive(Debug, Clone, PartialEq)]
pub struct AVP {
pub(crate) typ: AVPType,
pub(crate) value: Vec<u8>,
}
impl AVP {
pub fn from_u32(typ: AVPType, value: u32) -> Self {
AVP {
typ,
value: u32::to_be_bytes(value).to_vec(),
}
}
pub fn from_string(typ: AVPType, value: &str) -> Self {
AVP {
typ,
value: value.as_bytes().to_vec(),
}
}
pub fn from_bytes(typ: AVPType, value: &[u8]) -> Self {
AVP {
typ,
value: value.to_vec(),
}
}
pub fn from_ipv4(typ: AVPType, value: &Ipv4Addr) -> Self {
AVP {
typ,
value: value.octets().to_vec(),
}
}
pub fn from_ipv6(typ: AVPType, value: &Ipv6Addr) -> Self {
AVP {
typ,
value: value.octets().to_vec(),
}
}
pub fn from_user_password(
typ: AVPType,
plain_text: &[u8],
secret: &[u8],
request_authenticator: &[u8],
) -> Result<Self, String> {
if plain_text.len() > 128 {
return Err(
"the length of plain_text has to be within 128, but the given value is longer"
.to_owned(),
);
}
if secret.is_empty() {
return Err("secret hasn't be empty, but the given value is empty".to_owned());
}
if request_authenticator.len() != 16 {
return Err(
"request_authenticator has to have 16-bytes payload, but the given value doesn't"
.to_owned(),
);
}
let mut buff = request_authenticator.to_vec();
let l = plain_text.len();
if l < 16 {
let enc = md5::compute([secret, &buff[..]].concat()).to_vec();
return Ok(AVP {
typ,
value: enc
.iter()
.zip([plain_text, vec![0 as u8; 16 - l].as_slice()].concat())
// ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ zero padding
.map(|(d, p)| d ^ p)
.collect(),
});
}
let mut enc: Vec<u8> = Vec::new();
for chunk in plain_text.chunks(16) {
let mut chunk_vec = chunk.to_vec();
let l = chunk.len();
if l < 16 {
chunk_vec.extend(vec![0 as u8; 16 - l]); // zero padding
}
let enc_block = md5::compute([secret, &buff[..]].concat()).to_vec();
buff = enc_block
.iter()
.zip(chunk_vec)
.map(|(d, p)| d ^ p)
.collect();
enc.extend(&buff);
}
Ok(AVP { typ, value: enc })
}
pub fn from_date(typ: AVPType, dt: &DateTime<Utc>) -> Self {
AVP {
typ,
value: u32::to_be_bytes(dt.timestamp() as u32).to_vec(),
}
}
pub fn to_integer32(&self) -> Result<u32, String> {
const EXPECTED_SIZE: usize = std::mem::size_of::<u32>();
if self.value.len() != EXPECTED_SIZE {
return Err("invalid attribute length for integer".to_owned());
}
let (int_bytes, _) = self.value.split_at(EXPECTED_SIZE);
match int_bytes.try_into() {
Ok(boxed_array) => Ok(u32::from_be_bytes(boxed_array)),
Err(e) => Err(e.to_string()),
}
}
pub fn to_string(&self) -> Result<String, FromUtf8Error> {
String::from_utf8(self.value.to_vec())
}
pub fn to_bytes(&self) -> Vec<u8> {
self.value.to_vec()
}
pub fn to_ipv4(&self) -> Result<Ipv4Addr, String> {
const IPV4_SIZE: usize = std::mem::size_of::<Ipv4Addr>();
if self.value.len() != IPV4_SIZE {
return Err("invalid attribute length for ipv4 address".to_owned());
}
let (int_bytes, _) = self.value.split_at(IPV4_SIZE);
match int_bytes.try_into() {
Ok::<[u8; IPV4_SIZE], _>(boxed_array) => Ok(Ipv4Addr::from(boxed_array)),
Err(e) => Err(e.to_string()),
}
}
pub fn to_ipv6(&self) -> Result<Ipv6Addr, String> {
const IPV6_SIZE: usize = std::mem::size_of::<Ipv6Addr>();
if self.value.len() != IPV6_SIZE {
return Err("invalid attribute length for ipv6 address".to_owned());
}
let (int_bytes, _) = self.value.split_at(IPV6_SIZE);
match int_bytes.try_into() {
Ok::<[u8; IPV6_SIZE], _>(boxed_array) => Ok(Ipv6Addr::from(boxed_array)),
Err(e) => Err(e.to_string()),
}
}
pub fn to_user_password(
&self,
secret: &[u8],
request_authenticator: &[u8],
) -> Result<Vec<u8>, String> {
if self.value.len() < 16 || self.value.len() > 128 {
return Err(format!("invalid attribute length {}", self.value.len()));
}
if secret.is_empty() {
return Err("secret hasn't be empty, but the given value is empty".to_owned());
}
if request_authenticator.len() != 16 {
return Err(
"request_authenticator has to have 16-bytes payload, but the given value doesn't"
.to_owned(),
);
}
let mut dec: Vec<u8> = Vec::new();
let mut buff: Vec<u8> = request_authenticator.to_vec();
// NOTE:
// It ensures attribute value has 16 bytes length at least because the value is encoded by md5.
// And this must be aligned by each 16 bytes length.
for chunk in self.value.chunks(16) {
let chunk_vec = chunk.to_vec();
let dec_block = md5::compute([secret, &buff[..]].concat()).to_vec();
dec.extend(
dec_block
.iter()
.zip(&chunk_vec)
.map(|(d, p)| d ^ p)
.collect::<Vec<u8>>(),
);
buff = chunk_vec.clone();
}
// remove trailing zero bytes
match dec.split(|b| *b == 0).next() {
Some(dec) => Ok(dec.to_vec()),
None => Ok(vec![]),
}
}
pub fn to_date(&self) -> Result<DateTime<Utc>, String> {
let (int_bytes, _) = self.value.split_at(std::mem::size_of::<u32>());
match int_bytes.try_into() {
Ok(boxed_array) => {
let timestamp = u32::from_be_bytes(boxed_array);
Ok(Utc.timestamp(timestamp as i64, 0))
}
Err(e) => Err(e.to_string()),
}
}
}
// #[cfg(test)]
// mod tests {
// use std::net::{Ipv4Addr, Ipv6Addr};
// use std::string::FromUtf8Error;
//
// use chrono::Utc;
//
// use crate::avp::Attribute;
//
// #[test]
// fn it_should_convert_attribute_to_integer32() -> Result<(), String> {
// assert_eq!(Attribute(vec![1, 2, 3, 4]).to_integer32()?, 16909060);
// Ok(())
// }
//
// #[test]
// fn it_should_convert_attribute_to_string() -> Result<(), FromUtf8Error> {
// assert_eq!(
// Attribute(vec![
// 0x48, 0x65, 0x6c, 0x6c, 0x6f, 0x2c, 0x20, 0x57, 0x6f, 0x72, 0x6c, 0x64
// ])
// .to_string()?,
// "Hello, World"
// );
// Ok(())
// }
//
// #[test]
// fn it_should_convert_ipv4() -> Result<(), String> {
// let given_ipv4 = Ipv4Addr::new(192, 0, 2, 1);
// let ipv4_attr = Attribute::from_ipv4(&given_ipv4);
// assert_eq!(ipv4_attr.to_ipv4()?, given_ipv4,);
// Ok(())
// }
//
// #[test]
// fn it_should_convert_ipv6() -> Result<(), String> {
// let given_ipv6 = Ipv6Addr::new(
// 0x2001, 0x0db8, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0001,
// );
// let ipv6_attr = Attribute::from_ipv6(&given_ipv6);
// assert_eq!(ipv6_attr.to_ipv6()?, given_ipv6,);
// Ok(())
// }
//
// #[test]
// fn it_should_convert_user_password() {
// let secret = b"12345".to_vec();
// let request_authenticator = b"0123456789abcdef".to_vec();
//
// struct TestCase<'a> {
// plain_text: &'a str,
// expected_encoded_len: usize,
// };
//
// let test_cases = &[
// TestCase {
// plain_text: "",
// expected_encoded_len: 16,
// },
// TestCase {
// plain_text: "abc",
// expected_encoded_len: 16,
// },
// TestCase {
// plain_text: "0123456789abcde",
// expected_encoded_len: 16,
// },
// TestCase {
// plain_text: "0123456789abcdef",
// expected_encoded_len: 16,
// },
// TestCase {
// plain_text: "0123456789abcdef0",
// expected_encoded_len: 32,
// },
// TestCase {
// plain_text: "0123456789abcdef0123456789abcdef0123456789abcdef",
// expected_encoded_len: 48,
// },
// ];
//
// for test_case in test_cases {
// let user_password_attr_result = Attribute::from_user_password(
// test_case.plain_text.as_bytes(),
// &secret,
// &request_authenticator,
// );
// let user_password_attr = user_password_attr_result.unwrap();
// assert_eq!(user_password_attr.0.len(), test_case.expected_encoded_len);
//
// let decoded_password = user_password_attr
// .to_user_password(&secret, &request_authenticator)
// .unwrap();
// assert_eq!(
// String::from_utf8(decoded_password).unwrap(),
// test_case.plain_text
// );
// }
// }
//
// #[test]
// fn it_should_convert_date() -> Result<(), String> {
// let now = Utc::now();
// let attr = Attribute::from_date(&now);
// assert_eq!(attr.to_date()?.timestamp(), now.timestamp(),);
// Ok(())
// }
// }

25
src/bin/code_gen.rs
View File

@@ -99,8 +99,7 @@ fn generate_header(w: &mut BufWriter<File>) {
use std::net::Ipv4Addr;
use crate::attribute::Attribute;
use crate::attributes::AVPType;
use crate::avp::{AVP, AVPType};
use crate::packet::Packet;
";
@@ -210,10 +209,10 @@ pub const {type_identifier}: AVPType = {type_value};
pub fn delete_{method_identifier}(packet: &mut Packet) {{
packet.delete({type_identifier});
}}
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<&Attribute> {{
pub fn lookup_{method_identifier}(packet: &Packet) -> Option<&AVP> {{
packet.lookup({type_identifier})
}}
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<&Attribute> {{
pub fn lookup_all_{method_identifier}(packet: &Packet) -> Vec<&AVP> {{
packet.lookup_all({type_identifier})
}}
",
@@ -231,8 +230,7 @@ fn generate_string_attribute_code(
) {
let code = format!(
"pub fn add_{method_identifier}(packet: &mut Packet, value: &str) {{
let attr = Attribute::from_string(value);
packet.add({type_identifier}, &attr);
packet.add(AVP::from_string({type_identifier}, value));
}}
",
method_identifier = method_identifier,
@@ -248,8 +246,7 @@ fn generate_user_password_attribute_code(
) {
let code = format!(
"pub fn add_{method_identifier}(packet: &mut Packet, value: &[u8]) -> Result<(), String> {{
let attr = Attribute::from_user_password(value, packet.get_secret(), packet.get_authenticator())?;
packet.add({type_identifier}, &attr);
packet.add(AVP::from_user_password({type_identifier}, value, packet.get_secret(), packet.get_authenticator())?);
Ok(())
}}
",
@@ -266,8 +263,7 @@ fn generate_octets_attribute_code(
) {
let code = format!(
"pub fn add_{method_identifier}(packet: &mut Packet, value: &[u8]) {{
let attr = Attribute::from_bytes(value);
packet.add({type_identifier}, &attr);
packet.add(AVP::from_bytes({type_identifier}, value));
}}
",
method_identifier = method_identifier,
@@ -283,8 +279,7 @@ fn generate_ipaddr_attribute_code(
) {
let code = format!(
"pub fn add_{method_identifier}(packet: &mut Packet, value: &Ipv4Addr) {{
let attr = Attribute::from_ipv4(value);
packet.add({type_identifier}, &attr);
packet.add(AVP::from_ipv4({type_identifier}, value));
}}
",
method_identifier = method_identifier,
@@ -300,8 +295,7 @@ fn generate_integer_attribute_code(
) {
let code = format!(
"pub fn add_{method_identifier}(packet: &mut Packet, value: u32) {{
let attr = Attribute::from_u32(value);
packet.add({type_identifier}, &attr);
packet.add(AVP::from_u32({type_identifier}, value));
}}
",
method_identifier = method_identifier,
@@ -318,8 +312,7 @@ fn generate_value_defined_integer_attribute_code(
) {
let code = format!(
"pub fn add_{method_identifier}(packet: &mut Packet, value: {value_type}) {{
let attr = Attribute::from_u32(value as u32);
packet.add({type_identifier}, &attr);
packet.add(AVP::from_u32({type_identifier}, value as u32));
}}
",
method_identifier = method_identifier,

2
src/lib.rs
View File

@@ -2,8 +2,8 @@ extern crate inflector;
#[macro_use]
extern crate log;
pub mod attribute;
pub mod attributes;
pub mod avp;
pub mod client;
pub mod code;
pub mod packet;

12
src/packet.rs
View File

@@ -2,8 +2,8 @@ use std::convert::TryInto;
use rand::Rng;
use crate::attribute::Attribute;
use crate::attributes::{AVPType, Attributes};
use crate::attributes::Attributes;
use crate::avp::{AVPType, AVP};
use crate::code::Code;
const MAX_PACKET_LENGTH: usize = 4096;
@@ -206,19 +206,19 @@ impl Packet {
}
}
pub fn add(&mut self, typ: AVPType, attr: &Attribute) {
self.attributes.add(typ, attr.clone());
pub fn add(&mut self, avp: AVP) {
self.attributes.add(avp);
}
pub fn delete(&mut self, typ: AVPType) {
self.attributes.del(typ);
}
pub fn lookup(&self, typ: AVPType) -> Option<&Attribute> {
pub fn lookup(&self, typ: AVPType) -> Option<&AVP> {
self.attributes.lookup(typ)
}
pub fn lookup_all(&self, typ: AVPType) -> Vec<&Attribute> {
pub fn lookup_all(&self, typ: AVPType) -> Vec<&AVP> {
self.attributes.lookup_all(typ)
}
}

293
src/rfc2865.rs
View File

@@ -2,8 +2,7 @@
use std::net::Ipv4Addr;
use crate::attribute::Attribute;
use crate::attributes::AVPType;
use crate::avp::{AVPType, AVP};
use crate::packet::Packet;
pub type FramedCompression = u32;
@@ -84,31 +83,33 @@ pub const USER_NAME_TYPE: AVPType = 1;
pub fn delete_user_name(packet: &mut Packet) {
packet.delete(USER_NAME_TYPE);
}
pub fn lookup_user_name(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_user_name(packet: &Packet) -> Option<&AVP> {
packet.lookup(USER_NAME_TYPE)
}
pub fn lookup_all_user_name(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_user_name(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(USER_NAME_TYPE)
}
pub fn add_user_name(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(USER_NAME_TYPE, &attr);
packet.add(AVP::from_string(USER_NAME_TYPE, value));
}
pub const USER_PASSWORD_TYPE: AVPType = 2;
pub fn delete_user_password(packet: &mut Packet) {
packet.delete(USER_PASSWORD_TYPE);
}
pub fn lookup_user_password(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_user_password(packet: &Packet) -> Option<&AVP> {
packet.lookup(USER_PASSWORD_TYPE)
}
pub fn lookup_all_user_password(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_user_password(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(USER_PASSWORD_TYPE)
}
pub fn add_user_password(packet: &mut Packet, value: &[u8]) -> Result<(), String> {
let attr =
Attribute::from_user_password(value, packet.get_secret(), packet.get_authenticator())?;
packet.add(USER_PASSWORD_TYPE, &attr);
packet.add(AVP::from_user_password(
USER_PASSWORD_TYPE,
value,
packet.get_secret(),
packet.get_authenticator(),
)?);
Ok(())
}
@@ -116,325 +117,304 @@ pub const CHAP_PASSWORD_TYPE: AVPType = 3;
pub fn delete_chap_password(packet: &mut Packet) {
packet.delete(CHAP_PASSWORD_TYPE);
}
pub fn lookup_chap_password(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_chap_password(packet: &Packet) -> Option<&AVP> {
packet.lookup(CHAP_PASSWORD_TYPE)
}
pub fn lookup_all_chap_password(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_chap_password(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CHAP_PASSWORD_TYPE)
}
pub fn add_chap_password(packet: &mut Packet, value: &[u8]) {
let attr = Attribute::from_bytes(value);
packet.add(CHAP_PASSWORD_TYPE, &attr);
packet.add(AVP::from_bytes(CHAP_PASSWORD_TYPE, value));
}
pub const NAS_IP_ADDRESS_TYPE: AVPType = 4;
pub fn delete_nas_ip_address(packet: &mut Packet) {
packet.delete(NAS_IP_ADDRESS_TYPE);
}
pub fn lookup_nas_ip_address(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_nas_ip_address(packet: &Packet) -> Option<&AVP> {
packet.lookup(NAS_IP_ADDRESS_TYPE)
}
pub fn lookup_all_nas_ip_address(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_nas_ip_address(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(NAS_IP_ADDRESS_TYPE)
}
pub fn add_nas_ip_address(packet: &mut Packet, value: &Ipv4Addr) {
let attr = Attribute::from_ipv4(value);
packet.add(NAS_IP_ADDRESS_TYPE, &attr);
packet.add(AVP::from_ipv4(NAS_IP_ADDRESS_TYPE, value));
}
pub const NAS_PORT_TYPE: AVPType = 5;
pub fn delete_nas_port(packet: &mut Packet) {
packet.delete(NAS_PORT_TYPE);
}
pub fn lookup_nas_port(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_nas_port(packet: &Packet) -> Option<&AVP> {
packet.lookup(NAS_PORT_TYPE)
}
pub fn lookup_all_nas_port(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_nas_port(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(NAS_PORT_TYPE)
}
pub fn add_nas_port(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(NAS_PORT_TYPE, &attr);
packet.add(AVP::from_u32(NAS_PORT_TYPE, value));
}
pub const SERVICE_TYPE_TYPE: AVPType = 6;
pub fn delete_service_type(packet: &mut Packet) {
packet.delete(SERVICE_TYPE_TYPE);
}
pub fn lookup_service_type(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_service_type(packet: &Packet) -> Option<&AVP> {
packet.lookup(SERVICE_TYPE_TYPE)
}
pub fn lookup_all_service_type(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_service_type(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(SERVICE_TYPE_TYPE)
}
pub fn add_service_type(packet: &mut Packet, value: ServiceType) {
let attr = Attribute::from_u32(value as u32);
packet.add(SERVICE_TYPE_TYPE, &attr);
packet.add(AVP::from_u32(SERVICE_TYPE_TYPE, value as u32));
}
pub const FRAMED_PROTOCOL_TYPE: AVPType = 7;
pub fn delete_framed_protocol(packet: &mut Packet) {
packet.delete(FRAMED_PROTOCOL_TYPE);
}
pub fn lookup_framed_protocol(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_protocol(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_PROTOCOL_TYPE)
}
pub fn lookup_all_framed_protocol(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_protocol(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_PROTOCOL_TYPE)
}
pub fn add_framed_protocol(packet: &mut Packet, value: FramedProtocol) {
let attr = Attribute::from_u32(value as u32);
packet.add(FRAMED_PROTOCOL_TYPE, &attr);
packet.add(AVP::from_u32(FRAMED_PROTOCOL_TYPE, value as u32));
}
pub const FRAMED_IP_ADDRESS_TYPE: AVPType = 8;
pub fn delete_framed_ip_address(packet: &mut Packet) {
packet.delete(FRAMED_IP_ADDRESS_TYPE);
}
pub fn lookup_framed_ip_address(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_ip_address(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_IP_ADDRESS_TYPE)
}
pub fn lookup_all_framed_ip_address(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_ip_address(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_IP_ADDRESS_TYPE)
}
pub fn add_framed_ip_address(packet: &mut Packet, value: &Ipv4Addr) {
let attr = Attribute::from_ipv4(value);
packet.add(FRAMED_IP_ADDRESS_TYPE, &attr);
packet.add(AVP::from_ipv4(FRAMED_IP_ADDRESS_TYPE, value));
}
pub const FRAMED_IP_NETMASK_TYPE: AVPType = 9;
pub fn delete_framed_ip_netmask(packet: &mut Packet) {
packet.delete(FRAMED_IP_NETMASK_TYPE);
}
pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_ip_netmask(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_IP_NETMASK_TYPE)
}
pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_ip_netmask(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_IP_NETMASK_TYPE)
}
pub fn add_framed_ip_netmask(packet: &mut Packet, value: &Ipv4Addr) {
let attr = Attribute::from_ipv4(value);
packet.add(FRAMED_IP_NETMASK_TYPE, &attr);
packet.add(AVP::from_ipv4(FRAMED_IP_NETMASK_TYPE, value));
}
pub const FRAMED_ROUTING_TYPE: AVPType = 10;
pub fn delete_framed_routing(packet: &mut Packet) {
packet.delete(FRAMED_ROUTING_TYPE);
}
pub fn lookup_framed_routing(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_routing(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_ROUTING_TYPE)
}
pub fn lookup_all_framed_routing(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_routing(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_ROUTING_TYPE)
}
pub fn add_framed_routing(packet: &mut Packet, value: FramedRouting) {
let attr = Attribute::from_u32(value as u32);
packet.add(FRAMED_ROUTING_TYPE, &attr);
packet.add(AVP::from_u32(FRAMED_ROUTING_TYPE, value as u32));
}
pub const FILTER_ID_TYPE: AVPType = 11;
pub fn delete_filter_id(packet: &mut Packet) {
packet.delete(FILTER_ID_TYPE);
}
pub fn lookup_filter_id(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_filter_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(FILTER_ID_TYPE)
}
pub fn lookup_all_filter_id(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_filter_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FILTER_ID_TYPE)
}
pub fn add_filter_id(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(FILTER_ID_TYPE, &attr);
packet.add(AVP::from_string(FILTER_ID_TYPE, value));
}
pub const FRAMED_MTU_TYPE: AVPType = 12;
pub fn delete_framed_mtu(packet: &mut Packet) {
packet.delete(FRAMED_MTU_TYPE);
}
pub fn lookup_framed_mtu(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_mtu(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_MTU_TYPE)
}
pub fn lookup_all_framed_mtu(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_mtu(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_MTU_TYPE)
}
pub fn add_framed_mtu(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(FRAMED_MTU_TYPE, &attr);
packet.add(AVP::from_u32(FRAMED_MTU_TYPE, value));
}
pub const FRAMED_COMPRESSION_TYPE: AVPType = 13;
pub fn delete_framed_compression(packet: &mut Packet) {
packet.delete(FRAMED_COMPRESSION_TYPE);
}
pub fn lookup_framed_compression(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_compression(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_COMPRESSION_TYPE)
}
pub fn lookup_all_framed_compression(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_compression(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_COMPRESSION_TYPE)
}
pub fn add_framed_compression(packet: &mut Packet, value: FramedCompression) {
let attr = Attribute::from_u32(value as u32);
packet.add(FRAMED_COMPRESSION_TYPE, &attr);
packet.add(AVP::from_u32(FRAMED_COMPRESSION_TYPE, value as u32));
}
pub const LOGIN_IP_HOST_TYPE: AVPType = 14;
pub fn delete_login_ip_host(packet: &mut Packet) {
packet.delete(LOGIN_IP_HOST_TYPE);
}
pub fn lookup_login_ip_host(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_login_ip_host(packet: &Packet) -> Option<&AVP> {
packet.lookup(LOGIN_IP_HOST_TYPE)
}
pub fn lookup_all_login_ip_host(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_login_ip_host(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_IP_HOST_TYPE)
}
pub fn add_login_ip_host(packet: &mut Packet, value: &Ipv4Addr) {
let attr = Attribute::from_ipv4(value);
packet.add(LOGIN_IP_HOST_TYPE, &attr);
packet.add(AVP::from_ipv4(LOGIN_IP_HOST_TYPE, value));
}
pub const LOGIN_SERVICE_TYPE: AVPType = 15;
pub fn delete_login_service(packet: &mut Packet) {
packet.delete(LOGIN_SERVICE_TYPE);
}
pub fn lookup_login_service(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_login_service(packet: &Packet) -> Option<&AVP> {
packet.lookup(LOGIN_SERVICE_TYPE)
}
pub fn lookup_all_login_service(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_login_service(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_SERVICE_TYPE)
}
pub fn add_login_service(packet: &mut Packet, value: LoginService) {
let attr = Attribute::from_u32(value as u32);
packet.add(LOGIN_SERVICE_TYPE, &attr);
packet.add(AVP::from_u32(LOGIN_SERVICE_TYPE, value as u32));
}
pub const LOGIN_TCP_PORT_TYPE: AVPType = 16;
pub fn delete_login_tcp_port(packet: &mut Packet) {
packet.delete(LOGIN_TCP_PORT_TYPE);
}
pub fn lookup_login_tcp_port(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_login_tcp_port(packet: &Packet) -> Option<&AVP> {
packet.lookup(LOGIN_TCP_PORT_TYPE)
}
pub fn lookup_all_login_tcp_port(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_login_tcp_port(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_TCP_PORT_TYPE)
}
pub fn add_login_tcp_port(packet: &mut Packet, value: LoginTCPPort) {
let attr = Attribute::from_u32(value as u32);
packet.add(LOGIN_TCP_PORT_TYPE, &attr);
packet.add(AVP::from_u32(LOGIN_TCP_PORT_TYPE, value as u32));
}
pub const REPLY_MESSAGE_TYPE: AVPType = 18;
pub fn delete_reply_message(packet: &mut Packet) {
packet.delete(REPLY_MESSAGE_TYPE);
}
pub fn lookup_reply_message(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_reply_message(packet: &Packet) -> Option<&AVP> {
packet.lookup(REPLY_MESSAGE_TYPE)
}
pub fn lookup_all_reply_message(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_reply_message(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(REPLY_MESSAGE_TYPE)
}
pub fn add_reply_message(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(REPLY_MESSAGE_TYPE, &attr);
packet.add(AVP::from_string(REPLY_MESSAGE_TYPE, value));
}
pub const CALLBACK_NUMBER_TYPE: AVPType = 19;
pub fn delete_callback_number(packet: &mut Packet) {
packet.delete(CALLBACK_NUMBER_TYPE);
}
pub fn lookup_callback_number(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_callback_number(packet: &Packet) -> Option<&AVP> {
packet.lookup(CALLBACK_NUMBER_TYPE)
}
pub fn lookup_all_callback_number(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_callback_number(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CALLBACK_NUMBER_TYPE)
}
pub fn add_callback_number(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(CALLBACK_NUMBER_TYPE, &attr);
packet.add(AVP::from_string(CALLBACK_NUMBER_TYPE, value));
}
pub const CALLBACK_ID_TYPE: AVPType = 20;
pub fn delete_callback_id(packet: &mut Packet) {
packet.delete(CALLBACK_ID_TYPE);
}
pub fn lookup_callback_id(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_callback_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(CALLBACK_ID_TYPE)
}
pub fn lookup_all_callback_id(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_callback_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CALLBACK_ID_TYPE)
}
pub fn add_callback_id(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(CALLBACK_ID_TYPE, &attr);
packet.add(AVP::from_string(CALLBACK_ID_TYPE, value));
}
pub const FRAMED_ROUTE_TYPE: AVPType = 22;
pub fn delete_framed_route(packet: &mut Packet) {
packet.delete(FRAMED_ROUTE_TYPE);
}
pub fn lookup_framed_route(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_route(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_ROUTE_TYPE)
}
pub fn lookup_all_framed_route(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_route(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_ROUTE_TYPE)
}
pub fn add_framed_route(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(FRAMED_ROUTE_TYPE, &attr);
packet.add(AVP::from_string(FRAMED_ROUTE_TYPE, value));
}
pub const FRAMED_IPX_NETWORK_TYPE: AVPType = 23;
pub fn delete_framed_ipx_network(packet: &mut Packet) {
packet.delete(FRAMED_IPX_NETWORK_TYPE);
}
pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_ipx_network(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_IPX_NETWORK_TYPE)
}
pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_ipx_network(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_IPX_NETWORK_TYPE)
}
pub fn add_framed_ipx_network(packet: &mut Packet, value: &Ipv4Addr) {
let attr = Attribute::from_ipv4(value);
packet.add(FRAMED_IPX_NETWORK_TYPE, &attr);
packet.add(AVP::from_ipv4(FRAMED_IPX_NETWORK_TYPE, value));
}
pub const STATE_TYPE: AVPType = 24;
pub fn delete_state(packet: &mut Packet) {
packet.delete(STATE_TYPE);
}
pub fn lookup_state(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_state(packet: &Packet) -> Option<&AVP> {
packet.lookup(STATE_TYPE)
}
pub fn lookup_all_state(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_state(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(STATE_TYPE)
}
pub fn add_state(packet: &mut Packet, value: &[u8]) {
let attr = Attribute::from_bytes(value);
packet.add(STATE_TYPE, &attr);
packet.add(AVP::from_bytes(STATE_TYPE, value));
}
pub const CLASS_TYPE: AVPType = 25;
pub fn delete_class(packet: &mut Packet) {
packet.delete(CLASS_TYPE);
}
pub fn lookup_class(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_class(packet: &Packet) -> Option<&AVP> {
packet.lookup(CLASS_TYPE)
}
pub fn lookup_all_class(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_class(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CLASS_TYPE)
}
pub fn add_class(packet: &mut Packet, value: &[u8]) {
let attr = Attribute::from_bytes(value);
packet.add(CLASS_TYPE, &attr);
packet.add(AVP::from_bytes(CLASS_TYPE, value));
}
pub const VENDOR_SPECIFIC_TYPE: AVPType = 26;
pub fn delete_vendor_specific(packet: &mut Packet) {
packet.delete(VENDOR_SPECIFIC_TYPE);
}
pub fn lookup_vendor_specific(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_vendor_specific(packet: &Packet) -> Option<&AVP> {
packet.lookup(VENDOR_SPECIFIC_TYPE)
}
pub fn lookup_all_vendor_specific(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_vendor_specific(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(VENDOR_SPECIFIC_TYPE)
}
@@ -442,253 +422,236 @@ pub const SESSION_TIMEOUT_TYPE: AVPType = 27;
pub fn delete_session_timeout(packet: &mut Packet) {
packet.delete(SESSION_TIMEOUT_TYPE);
}
pub fn lookup_session_timeout(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_session_timeout(packet: &Packet) -> Option<&AVP> {
packet.lookup(SESSION_TIMEOUT_TYPE)
}
pub fn lookup_all_session_timeout(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_session_timeout(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(SESSION_TIMEOUT_TYPE)
}
pub fn add_session_timeout(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(SESSION_TIMEOUT_TYPE, &attr);
packet.add(AVP::from_u32(SESSION_TIMEOUT_TYPE, value));
}
pub const IDLE_TIMEOUT_TYPE: AVPType = 28;
pub fn delete_idle_timeout(packet: &mut Packet) {
packet.delete(IDLE_TIMEOUT_TYPE);
}
pub fn lookup_idle_timeout(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_idle_timeout(packet: &Packet) -> Option<&AVP> {
packet.lookup(IDLE_TIMEOUT_TYPE)
}
pub fn lookup_all_idle_timeout(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_idle_timeout(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(IDLE_TIMEOUT_TYPE)
}
pub fn add_idle_timeout(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(IDLE_TIMEOUT_TYPE, &attr);
packet.add(AVP::from_u32(IDLE_TIMEOUT_TYPE, value));
}
pub const TERMINATION_ACTION_TYPE: AVPType = 29;
pub fn delete_termination_action(packet: &mut Packet) {
packet.delete(TERMINATION_ACTION_TYPE);
}
pub fn lookup_termination_action(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_termination_action(packet: &Packet) -> Option<&AVP> {
packet.lookup(TERMINATION_ACTION_TYPE)
}
pub fn lookup_all_termination_action(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_termination_action(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(TERMINATION_ACTION_TYPE)
}
pub fn add_termination_action(packet: &mut Packet, value: TerminationAction) {
let attr = Attribute::from_u32(value as u32);
packet.add(TERMINATION_ACTION_TYPE, &attr);
packet.add(AVP::from_u32(TERMINATION_ACTION_TYPE, value as u32));
}
pub const CALLED_STATION_ID_TYPE: AVPType = 30;
pub fn delete_called_station_id(packet: &mut Packet) {
packet.delete(CALLED_STATION_ID_TYPE);
}
pub fn lookup_called_station_id(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_called_station_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(CALLED_STATION_ID_TYPE)
}
pub fn lookup_all_called_station_id(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_called_station_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CALLED_STATION_ID_TYPE)
}
pub fn add_called_station_id(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(CALLED_STATION_ID_TYPE, &attr);
packet.add(AVP::from_string(CALLED_STATION_ID_TYPE, value));
}
pub const CALLING_STATION_ID_TYPE: AVPType = 31;
pub fn delete_calling_station_id(packet: &mut Packet) {
packet.delete(CALLING_STATION_ID_TYPE);
}
pub fn lookup_calling_station_id(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_calling_station_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(CALLING_STATION_ID_TYPE)
}
pub fn lookup_all_calling_station_id(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_calling_station_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CALLING_STATION_ID_TYPE)
}
pub fn add_calling_station_id(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(CALLING_STATION_ID_TYPE, &attr);
packet.add(AVP::from_string(CALLING_STATION_ID_TYPE, value));
}
pub const NAS_IDENTIFIER_TYPE: AVPType = 32;
pub fn delete_nas_identifier(packet: &mut Packet) {
packet.delete(NAS_IDENTIFIER_TYPE);
}
pub fn lookup_nas_identifier(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_nas_identifier(packet: &Packet) -> Option<&AVP> {
packet.lookup(NAS_IDENTIFIER_TYPE)
}
pub fn lookup_all_nas_identifier(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_nas_identifier(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(NAS_IDENTIFIER_TYPE)
}
pub fn add_nas_identifier(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(NAS_IDENTIFIER_TYPE, &attr);
packet.add(AVP::from_string(NAS_IDENTIFIER_TYPE, value));
}
pub const PROXY_STATE_TYPE: AVPType = 33;
pub fn delete_proxy_state(packet: &mut Packet) {
packet.delete(PROXY_STATE_TYPE);
}
pub fn lookup_proxy_state(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_proxy_state(packet: &Packet) -> Option<&AVP> {
packet.lookup(PROXY_STATE_TYPE)
}
pub fn lookup_all_proxy_state(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_proxy_state(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(PROXY_STATE_TYPE)
}
pub fn add_proxy_state(packet: &mut Packet, value: &[u8]) {
let attr = Attribute::from_bytes(value);
packet.add(PROXY_STATE_TYPE, &attr);
packet.add(AVP::from_bytes(PROXY_STATE_TYPE, value));
}
pub const LOGIN_LAT_SERVICE_TYPE: AVPType = 34;
pub fn delete_login_lat_service(packet: &mut Packet) {
packet.delete(LOGIN_LAT_SERVICE_TYPE);
}
pub fn lookup_login_lat_service(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_login_lat_service(packet: &Packet) -> Option<&AVP> {
packet.lookup(LOGIN_LAT_SERVICE_TYPE)
}
pub fn lookup_all_login_lat_service(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_login_lat_service(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_LAT_SERVICE_TYPE)
}
pub fn add_login_lat_service(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(LOGIN_LAT_SERVICE_TYPE, &attr);
packet.add(AVP::from_string(LOGIN_LAT_SERVICE_TYPE, value));
}
pub const LOGIN_LAT_NODE_TYPE: AVPType = 35;
pub fn delete_login_lat_node(packet: &mut Packet) {
packet.delete(LOGIN_LAT_NODE_TYPE);
}
pub fn lookup_login_lat_node(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_login_lat_node(packet: &Packet) -> Option<&AVP> {
packet.lookup(LOGIN_LAT_NODE_TYPE)
}
pub fn lookup_all_login_lat_node(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_login_lat_node(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_LAT_NODE_TYPE)
}
pub fn add_login_lat_node(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(LOGIN_LAT_NODE_TYPE, &attr);
packet.add(AVP::from_string(LOGIN_LAT_NODE_TYPE, value));
}
pub const LOGIN_LAT_GROUP_TYPE: AVPType = 36;
pub fn delete_login_lat_group(packet: &mut Packet) {
packet.delete(LOGIN_LAT_GROUP_TYPE);
}
pub fn lookup_login_lat_group(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_login_lat_group(packet: &Packet) -> Option<&AVP> {
packet.lookup(LOGIN_LAT_GROUP_TYPE)
}
pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_login_lat_group(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_LAT_GROUP_TYPE)
}
pub fn add_login_lat_group(packet: &mut Packet, value: &[u8]) {
let attr = Attribute::from_bytes(value);
packet.add(LOGIN_LAT_GROUP_TYPE, &attr);
packet.add(AVP::from_bytes(LOGIN_LAT_GROUP_TYPE, value));
}
pub const FRAMED_APPLE_TALK_LINK_TYPE: AVPType = 37;
pub fn delete_framed_apple_talk_link(packet: &mut Packet) {
packet.delete(FRAMED_APPLE_TALK_LINK_TYPE);
}
pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_apple_talk_link(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_APPLE_TALK_LINK_TYPE)
}
pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_apple_talk_link(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_APPLE_TALK_LINK_TYPE)
}
pub fn add_framed_apple_talk_link(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(FRAMED_APPLE_TALK_LINK_TYPE, &attr);
packet.add(AVP::from_u32(FRAMED_APPLE_TALK_LINK_TYPE, value));
}
pub const FRAMED_APPLE_TALK_NETWORK_TYPE: AVPType = 38;
pub fn delete_framed_apple_talk_network(packet: &mut Packet) {
packet.delete(FRAMED_APPLE_TALK_NETWORK_TYPE);
}
pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_apple_talk_network(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_APPLE_TALK_NETWORK_TYPE)
}
pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_apple_talk_network(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_APPLE_TALK_NETWORK_TYPE)
}
pub fn add_framed_apple_talk_network(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(FRAMED_APPLE_TALK_NETWORK_TYPE, &attr);
packet.add(AVP::from_u32(FRAMED_APPLE_TALK_NETWORK_TYPE, value));
}
pub const FRAMED_APPLE_TALK_ZONE_TYPE: AVPType = 39;
pub fn delete_framed_apple_talk_zone(packet: &mut Packet) {
packet.delete(FRAMED_APPLE_TALK_ZONE_TYPE);
}
pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_framed_apple_talk_zone(packet: &Packet) -> Option<&AVP> {
packet.lookup(FRAMED_APPLE_TALK_ZONE_TYPE)
}
pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_framed_apple_talk_zone(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(FRAMED_APPLE_TALK_ZONE_TYPE)
}
pub fn add_framed_apple_talk_zone(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(FRAMED_APPLE_TALK_ZONE_TYPE, &attr);
packet.add(AVP::from_string(FRAMED_APPLE_TALK_ZONE_TYPE, value));
}
pub const CHAP_CHALLENGE_TYPE: AVPType = 60;
pub fn delete_chap_challenge(packet: &mut Packet) {
packet.delete(CHAP_CHALLENGE_TYPE);
}
pub fn lookup_chap_challenge(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_chap_challenge(packet: &Packet) -> Option<&AVP> {
packet.lookup(CHAP_CHALLENGE_TYPE)
}
pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_chap_challenge(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(CHAP_CHALLENGE_TYPE)
}
pub fn add_chap_challenge(packet: &mut Packet, value: &[u8]) {
let attr = Attribute::from_bytes(value);
packet.add(CHAP_CHALLENGE_TYPE, &attr);
packet.add(AVP::from_bytes(CHAP_CHALLENGE_TYPE, value));
}
pub const NAS_PORT_TYPE_TYPE: AVPType = 61;
pub fn delete_nas_port_type(packet: &mut Packet) {
packet.delete(NAS_PORT_TYPE_TYPE);
}
pub fn lookup_nas_port_type(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_nas_port_type(packet: &Packet) -> Option<&AVP> {
packet.lookup(NAS_PORT_TYPE_TYPE)
}
pub fn lookup_all_nas_port_type(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_nas_port_type(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(NAS_PORT_TYPE_TYPE)
}
pub fn add_nas_port_type(packet: &mut Packet, value: NasPortType) {
let attr = Attribute::from_u32(value as u32);
packet.add(NAS_PORT_TYPE_TYPE, &attr);
packet.add(AVP::from_u32(NAS_PORT_TYPE_TYPE, value as u32));
}
pub const PORT_LIMIT_TYPE: AVPType = 62;
pub fn delete_port_limit(packet: &mut Packet) {
packet.delete(PORT_LIMIT_TYPE);
}
pub fn lookup_port_limit(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_port_limit(packet: &Packet) -> Option<&AVP> {
packet.lookup(PORT_LIMIT_TYPE)
}
pub fn lookup_all_port_limit(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_port_limit(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(PORT_LIMIT_TYPE)
}
pub fn add_port_limit(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(PORT_LIMIT_TYPE, &attr);
packet.add(AVP::from_u32(PORT_LIMIT_TYPE, value));
}
pub const LOGIN_LAT_PORT_TYPE: AVPType = 63;
pub fn delete_login_lat_port(packet: &mut Packet) {
packet.delete(LOGIN_LAT_PORT_TYPE);
}
pub fn lookup_login_lat_port(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_login_lat_port(packet: &Packet) -> Option<&AVP> {
packet.lookup(LOGIN_LAT_PORT_TYPE)
}
pub fn lookup_all_login_lat_port(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_login_lat_port(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(LOGIN_LAT_PORT_TYPE)
}
pub fn add_login_lat_port(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(LOGIN_LAT_PORT_TYPE, &attr);
packet.add(AVP::from_string(LOGIN_LAT_PORT_TYPE, value));
}

87
src/rfc2866.rs
View File

@@ -1,7 +1,6 @@
// Code generated by machine generator; DO NOT EDIT.
use crate::attribute::Attribute;
use crate::attributes::AVPType;
use crate::avp::{AVPType, AVP};
use crate::packet::Packet;
pub type AcctAuthentic = u32;
@@ -43,178 +42,166 @@ pub const ACCT_STATUS_TYPE_TYPE: AVPType = 40;
pub fn delete_acct_status_type(packet: &mut Packet) {
packet.delete(ACCT_STATUS_TYPE_TYPE);
}
pub fn lookup_acct_status_type(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_status_type(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_STATUS_TYPE_TYPE)
}
pub fn lookup_all_acct_status_type(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_status_type(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_STATUS_TYPE_TYPE)
}
pub fn add_acct_status_type(packet: &mut Packet, value: AcctStatusType) {
let attr = Attribute::from_u32(value as u32);
packet.add(ACCT_STATUS_TYPE_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_STATUS_TYPE_TYPE, value as u32));
}
pub const ACCT_DELAY_TIME_TYPE: AVPType = 41;
pub fn delete_acct_delay_time(packet: &mut Packet) {
packet.delete(ACCT_DELAY_TIME_TYPE);
}
pub fn lookup_acct_delay_time(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_delay_time(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_DELAY_TIME_TYPE)
}
pub fn lookup_all_acct_delay_time(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_delay_time(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_DELAY_TIME_TYPE)
}
pub fn add_acct_delay_time(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_DELAY_TIME_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_DELAY_TIME_TYPE, value));
}
pub const ACCT_INPUT_OCTETS_TYPE: AVPType = 42;
pub fn delete_acct_input_octets(packet: &mut Packet) {
packet.delete(ACCT_INPUT_OCTETS_TYPE);
}
pub fn lookup_acct_input_octets(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_input_octets(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_INPUT_OCTETS_TYPE)
}
pub fn lookup_all_acct_input_octets(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_input_octets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_INPUT_OCTETS_TYPE)
}
pub fn add_acct_input_octets(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_INPUT_OCTETS_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_INPUT_OCTETS_TYPE, value));
}
pub const ACCT_OUTPUT_OCTETS_TYPE: AVPType = 43;
pub fn delete_acct_output_octets(packet: &mut Packet) {
packet.delete(ACCT_OUTPUT_OCTETS_TYPE);
}
pub fn lookup_acct_output_octets(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_output_octets(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_OUTPUT_OCTETS_TYPE)
}
pub fn lookup_all_acct_output_octets(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_output_octets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_OUTPUT_OCTETS_TYPE)
}
pub fn add_acct_output_octets(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_OUTPUT_OCTETS_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_OUTPUT_OCTETS_TYPE, value));
}
pub const ACCT_SESSION_ID_TYPE: AVPType = 44;
pub fn delete_acct_session_id(packet: &mut Packet) {
packet.delete(ACCT_SESSION_ID_TYPE);
}
pub fn lookup_acct_session_id(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_session_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_SESSION_ID_TYPE)
}
pub fn lookup_all_acct_session_id(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_session_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_SESSION_ID_TYPE)
}
pub fn add_acct_session_id(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(ACCT_SESSION_ID_TYPE, &attr);
packet.add(AVP::from_string(ACCT_SESSION_ID_TYPE, value));
}
pub const ACCT_AUTHENTIC_TYPE: AVPType = 45;
pub fn delete_acct_authentic(packet: &mut Packet) {
packet.delete(ACCT_AUTHENTIC_TYPE);
}
pub fn lookup_acct_authentic(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_authentic(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_AUTHENTIC_TYPE)
}
pub fn lookup_all_acct_authentic(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_authentic(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_AUTHENTIC_TYPE)
}
pub fn add_acct_authentic(packet: &mut Packet, value: AcctAuthentic) {
let attr = Attribute::from_u32(value as u32);
packet.add(ACCT_AUTHENTIC_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_AUTHENTIC_TYPE, value as u32));
}
pub const ACCT_SESSION_TIME_TYPE: AVPType = 46;
pub fn delete_acct_session_time(packet: &mut Packet) {
packet.delete(ACCT_SESSION_TIME_TYPE);
}
pub fn lookup_acct_session_time(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_session_time(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_SESSION_TIME_TYPE)
}
pub fn lookup_all_acct_session_time(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_session_time(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_SESSION_TIME_TYPE)
}
pub fn add_acct_session_time(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_SESSION_TIME_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_SESSION_TIME_TYPE, value));
}
pub const ACCT_INPUT_PACKETS_TYPE: AVPType = 47;
pub fn delete_acct_input_packets(packet: &mut Packet) {
packet.delete(ACCT_INPUT_PACKETS_TYPE);
}
pub fn lookup_acct_input_packets(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_input_packets(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_INPUT_PACKETS_TYPE)
}
pub fn lookup_all_acct_input_packets(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_input_packets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_INPUT_PACKETS_TYPE)
}
pub fn add_acct_input_packets(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_INPUT_PACKETS_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_INPUT_PACKETS_TYPE, value));
}
pub const ACCT_OUTPUT_PACKETS_TYPE: AVPType = 48;
pub fn delete_acct_output_packets(packet: &mut Packet) {
packet.delete(ACCT_OUTPUT_PACKETS_TYPE);
}
pub fn lookup_acct_output_packets(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_output_packets(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_OUTPUT_PACKETS_TYPE)
}
pub fn lookup_all_acct_output_packets(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_output_packets(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_OUTPUT_PACKETS_TYPE)
}
pub fn add_acct_output_packets(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_OUTPUT_PACKETS_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_OUTPUT_PACKETS_TYPE, value));
}
pub const ACCT_TERMINATE_CAUSE_TYPE: AVPType = 49;
pub fn delete_acct_terminate_cause(packet: &mut Packet) {
packet.delete(ACCT_TERMINATE_CAUSE_TYPE);
}
pub fn lookup_acct_terminate_cause(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_terminate_cause(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_TERMINATE_CAUSE_TYPE)
}
pub fn lookup_all_acct_terminate_cause(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_terminate_cause(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_TERMINATE_CAUSE_TYPE)
}
pub fn add_acct_terminate_cause(packet: &mut Packet, value: AcctTerminateCause) {
let attr = Attribute::from_u32(value as u32);
packet.add(ACCT_TERMINATE_CAUSE_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_TERMINATE_CAUSE_TYPE, value as u32));
}
pub const ACCT_MULTI_SESSION_ID_TYPE: AVPType = 50;
pub fn delete_acct_multi_session_id(packet: &mut Packet) {
packet.delete(ACCT_MULTI_SESSION_ID_TYPE);
}
pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_multi_session_id(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_MULTI_SESSION_ID_TYPE)
}
pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_multi_session_id(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_MULTI_SESSION_ID_TYPE)
}
pub fn add_acct_multi_session_id(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(ACCT_MULTI_SESSION_ID_TYPE, &attr);
packet.add(AVP::from_string(ACCT_MULTI_SESSION_ID_TYPE, value));
}
pub const ACCT_LINK_COUNT_TYPE: AVPType = 51;
pub fn delete_acct_link_count(packet: &mut Packet) {
packet.delete(ACCT_LINK_COUNT_TYPE);
}
pub fn lookup_acct_link_count(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_link_count(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_LINK_COUNT_TYPE)
}
pub fn lookup_all_acct_link_count(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_link_count(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_LINK_COUNT_TYPE)
}
pub fn add_acct_link_count(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_LINK_COUNT_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_LINK_COUNT_TYPE, value));
}

17
src/rfc2867.rs
View File

@@ -1,7 +1,6 @@
// Code generated by machine generator; DO NOT EDIT.
use crate::attribute::Attribute;
use crate::attributes::AVPType;
use crate::avp::{AVPType, AVP};
use crate::packet::Packet;
pub type AcctStatusType = u32;
@@ -16,28 +15,26 @@ pub const ACCT_TUNNEL_CONNECTION_TYPE: AVPType = 68;
pub fn delete_acct_tunnel_connection(packet: &mut Packet) {
packet.delete(ACCT_TUNNEL_CONNECTION_TYPE);
}
pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_tunnel_connection(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_TUNNEL_CONNECTION_TYPE)
}
pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_tunnel_connection(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_TUNNEL_CONNECTION_TYPE)
}
pub fn add_acct_tunnel_connection(packet: &mut Packet, value: &str) {
let attr = Attribute::from_string(value);
packet.add(ACCT_TUNNEL_CONNECTION_TYPE, &attr);
packet.add(AVP::from_string(ACCT_TUNNEL_CONNECTION_TYPE, value));
}
pub const ACCT_TUNNEL_PACKETS_LOST_TYPE: AVPType = 86;
pub fn delete_acct_tunnel_packets_lost(packet: &mut Packet) {
packet.delete(ACCT_TUNNEL_PACKETS_LOST_TYPE);
}
pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<&Attribute> {
pub fn lookup_acct_tunnel_packets_lost(packet: &Packet) -> Option<&AVP> {
packet.lookup(ACCT_TUNNEL_PACKETS_LOST_TYPE)
}
pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Vec<&Attribute> {
pub fn lookup_all_acct_tunnel_packets_lost(packet: &Packet) -> Vec<&AVP> {
packet.lookup_all(ACCT_TUNNEL_PACKETS_LOST_TYPE)
}
pub fn add_acct_tunnel_packets_lost(packet: &mut Packet, value: u32) {
let attr = Attribute::from_u32(value);
packet.add(ACCT_TUNNEL_PACKETS_LOST_TYPE, &attr);
packet.add(AVP::from_u32(ACCT_TUNNEL_PACKETS_LOST_TYPE, value));
}