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

Support RFC5090

Browse Source
This commit is contained in:
moznion
2020-12-02 02:49:55 +09:00
parent 7e3c900ad5
commit 5053597ad7
4 changed files with 416 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
README.md
View File

@@ -15,6 +15,7 @@ This supports the following RFC dictionaries at the moment:
- [RFC2867](https://tools.ietf.org/html/rfc2867)
- [RFC2868](https://tools.ietf.org/html/rfc2868)
- [RFC3576](https://tools.ietf.org/html/rfc3576)
- [RFC5090](https://tools.ietf.org/html/rfc5090)
- [RFC6519](https://tools.ietf.org/html/rfc6519)
- [RFC6677](https://tools.ietf.org/html/rfc6677)

30
dicts/dictionary.rfc5090 Normal file
View File

@@ -0,0 +1,30 @@
# -*- text -*-
# Copyright (C) 2020 The FreeRADIUS Server project and contributors
# This work is licensed under CC-BY version 4.0 https://creativecommons.org/licenses/by/4.0
# Version $Id$
#
# Attributes and values defined in RFC 5090.
# http://www.ietf.org/rfc/rfc5090.txt
#
# $Id$
#
ATTRIBUTE Digest-Response 103 string
ATTRIBUTE Digest-Realm 104 string
ATTRIBUTE Digest-Nonce 105 string
ATTRIBUTE Digest-Response-Auth 106 string
ATTRIBUTE Digest-Nextnonce 107 string
ATTRIBUTE Digest-Method 108 string
ATTRIBUTE Digest-URI 109 string
ATTRIBUTE Digest-Qop 110 string
ATTRIBUTE Digest-Algorithm 111 string
ATTRIBUTE Digest-Entity-Body-Hash 112 string
ATTRIBUTE Digest-CNonce 113 string
ATTRIBUTE Digest-Nonce-Count 114 string
ATTRIBUTE Digest-Username 115 string
ATTRIBUTE Digest-Opaque 116 string
ATTRIBUTE Digest-Auth-Param 117 string
ATTRIBUTE Digest-AKA-Auts 118 string
ATTRIBUTE Digest-Domain 119 string
ATTRIBUTE Digest-Stale 120 string
ATTRIBUTE Digest-HA1 121 string
ATTRIBUTE SIP-AOR 122 string

1
radius/src/lib.rs
View File

@@ -8,6 +8,7 @@ pub mod rfc2866;
pub mod rfc2867;
pub mod rfc2868;
pub mod rfc3576;
pub mod rfc5090;
pub mod rfc6519;
pub mod rfc6677;
pub mod tag;

384
radius/src/rfc5090.rs Normal file
View File

@@ -0,0 +1,384 @@
// Code generated by machine generator; DO NOT EDIT.
use crate::avp::{AVPError, AVPType, AVP};
use crate::packet::Packet;
pub const DIGEST_RESPONSE_TYPE: AVPType = 103;
pub fn delete_digest_response(packet: &mut Packet) {
packet.delete(DIGEST_RESPONSE_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_RESPONSE_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_REALM_TYPE: AVPType = 104;
pub fn delete_digest_realm(packet: &mut Packet) {
packet.delete(DIGEST_REALM_TYPE);
}
pub fn add_digest_realm(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_REALM_TYPE, value));
}
pub fn lookup_digest_realm(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_REALM_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_realm(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_REALM_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_NONCE_TYPE: AVPType = 105;
pub fn delete_digest_nonce(packet: &mut Packet) {
packet.delete(DIGEST_NONCE_TYPE);
}
pub fn add_digest_nonce(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_NONCE_TYPE, value));
}
pub fn lookup_digest_nonce(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_NONCE_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_nonce(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_NONCE_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_RESPONSE_AUTH_TYPE: AVPType = 106;
pub fn delete_digest_response_auth(packet: &mut Packet) {
packet.delete(DIGEST_RESPONSE_AUTH_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_RESPONSE_AUTH_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_NEXTNONCE_TYPE: AVPType = 107;
pub fn delete_digest_nextnonce(packet: &mut Packet) {
packet.delete(DIGEST_NEXTNONCE_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_NEXTNONCE_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_METHOD_TYPE: AVPType = 108;
pub fn delete_digest_method(packet: &mut Packet) {
packet.delete(DIGEST_METHOD_TYPE);
}
pub fn add_digest_method(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_METHOD_TYPE, value));
}
pub fn lookup_digest_method(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_METHOD_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_method(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_METHOD_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_URI_TYPE: AVPType = 109;
pub fn delete_digest_uri(packet: &mut Packet) {
packet.delete(DIGEST_URI_TYPE);
}
pub fn add_digest_uri(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_URI_TYPE, value));
}
pub fn lookup_digest_uri(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_URI_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_uri(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_URI_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_QOP_TYPE: AVPType = 110;
pub fn delete_digest_qop(packet: &mut Packet) {
packet.delete(DIGEST_QOP_TYPE);
}
pub fn add_digest_qop(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_QOP_TYPE, value));
}
pub fn lookup_digest_qop(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_QOP_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_qop(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_QOP_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_ALGORITHM_TYPE: AVPType = 111;
pub fn delete_digest_algorithm(packet: &mut Packet) {
packet.delete(DIGEST_ALGORITHM_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_ALGORITHM_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_ENTITY_BODY_HASH_TYPE: AVPType = 112;
pub fn delete_digest_entity_body_hash(packet: &mut Packet) {
packet.delete(DIGEST_ENTITY_BODY_HASH_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_ENTITY_BODY_HASH_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_C_NONCE_TYPE: AVPType = 113;
pub fn delete_digest_c_nonce(packet: &mut Packet) {
packet.delete(DIGEST_C_NONCE_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_C_NONCE_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_NONCE_COUNT_TYPE: AVPType = 114;
pub fn delete_digest_nonce_count(packet: &mut Packet) {
packet.delete(DIGEST_NONCE_COUNT_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_NONCE_COUNT_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_USERNAME_TYPE: AVPType = 115;
pub fn delete_digest_username(packet: &mut Packet) {
packet.delete(DIGEST_USERNAME_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_USERNAME_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_OPAQUE_TYPE: AVPType = 116;
pub fn delete_digest_opaque(packet: &mut Packet) {
packet.delete(DIGEST_OPAQUE_TYPE);
}
pub fn add_digest_opaque(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_OPAQUE_TYPE, value));
}
pub fn lookup_digest_opaque(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_OPAQUE_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_opaque(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_OPAQUE_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_AUTH_PARAM_TYPE: AVPType = 117;
pub fn delete_digest_auth_param(packet: &mut Packet) {
packet.delete(DIGEST_AUTH_PARAM_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_AUTH_PARAM_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_AKA_AUTS_TYPE: AVPType = 118;
pub fn delete_digest_aka_auts(packet: &mut Packet) {
packet.delete(DIGEST_AKA_AUTS_TYPE);
}
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
.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();
for avp in packet.lookup_all(DIGEST_AKA_AUTS_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_DOMAIN_TYPE: AVPType = 119;
pub fn delete_digest_domain(packet: &mut Packet) {
packet.delete(DIGEST_DOMAIN_TYPE);
}
pub fn add_digest_domain(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_DOMAIN_TYPE, value));
}
pub fn lookup_digest_domain(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_DOMAIN_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_domain(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_DOMAIN_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_STALE_TYPE: AVPType = 120;
pub fn delete_digest_stale(packet: &mut Packet) {
packet.delete(DIGEST_STALE_TYPE);
}
pub fn add_digest_stale(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_STALE_TYPE, value));
}
pub fn lookup_digest_stale(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_STALE_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_stale(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_STALE_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const DIGEST_HA1_TYPE: AVPType = 121;
pub fn delete_digest_ha1(packet: &mut Packet) {
packet.delete(DIGEST_HA1_TYPE);
}
pub fn add_digest_ha1(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(DIGEST_HA1_TYPE, value));
}
pub fn lookup_digest_ha1(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(DIGEST_HA1_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_digest_ha1(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(DIGEST_HA1_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}
pub const SIP_AOR_TYPE: AVPType = 122;
pub fn delete_sip_aor(packet: &mut Packet) {
packet.delete(SIP_AOR_TYPE);
}
pub fn add_sip_aor(packet: &mut Packet, value: &str) {
packet.add(AVP::from_string(SIP_AOR_TYPE, value));
}
pub fn lookup_sip_aor(packet: &Packet) -> Option<Result<String, AVPError>> {
packet.lookup(SIP_AOR_TYPE).map(|v| v.encode_string())
}
pub fn lookup_all_sip_aor(packet: &Packet) -> Result<Vec<String>, AVPError> {
let mut vec = Vec::new();
for avp in packet.lookup_all(SIP_AOR_TYPE) {
vec.push(avp.encode_string()?)
}
Ok(vec)
}