From 5053597ad753e9891a81a7b68cf92f2aaedefba0 Mon Sep 17 00:00:00 2001 From: moznion Date: Wed, 2 Dec 2020 02:49:55 +0900 Subject: [PATCH] Support RFC5090 --- README.md | 1 + dicts/dictionary.rfc5090 | 30 +++ radius/src/lib.rs | 1 + radius/src/rfc5090.rs | 384 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 416 insertions(+) create mode 100644 dicts/dictionary.rfc5090 create mode 100644 radius/src/rfc5090.rs diff --git a/README.md b/README.md index 7bafbc4..bdfc248 100644 --- a/README.md +++ b/README.md @@ -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) diff --git a/dicts/dictionary.rfc5090 b/dicts/dictionary.rfc5090 new file mode 100644 index 0000000..c8a1d7b --- /dev/null +++ b/dicts/dictionary.rfc5090 @@ -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 diff --git a/radius/src/lib.rs b/radius/src/lib.rs index 5492e5d..a6c94d0 100644 --- a/radius/src/lib.rs +++ b/radius/src/lib.rs @@ -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; diff --git a/radius/src/rfc5090.rs b/radius/src/rfc5090.rs new file mode 100644 index 0000000..5389d89 --- /dev/null +++ b/radius/src/rfc5090.rs @@ -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> { + packet + .lookup(DIGEST_RESPONSE_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_response(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_REALM_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_realm(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_NONCE_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_nonce(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_RESPONSE_AUTH_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_response_auth(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_NEXTNONCE_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_nextnonce(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_METHOD_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_method(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_URI_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_uri(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_QOP_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_qop(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_ALGORITHM_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_algorithm(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_ENTITY_BODY_HASH_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_entity_body_hash(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_C_NONCE_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_c_nonce(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_NONCE_COUNT_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_nonce_count(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_USERNAME_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_username(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_OPAQUE_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_opaque(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_AUTH_PARAM_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_auth_param(packet: &Packet) -> Result, 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> { + packet + .lookup(DIGEST_AKA_AUTS_TYPE) + .map(|v| v.encode_string()) +} +pub fn lookup_all_digest_aka_auts(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_DOMAIN_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_domain(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_STALE_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_stale(packet: &Packet) -> Result, 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> { + packet.lookup(DIGEST_HA1_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_digest_ha1(packet: &Packet) -> Result, 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> { + packet.lookup(SIP_AOR_TYPE).map(|v| v.encode_string()) +} +pub fn lookup_all_sip_aor(packet: &Packet) -> Result, AVPError> { + let mut vec = Vec::new(); + for avp in packet.lookup_all(SIP_AOR_TYPE) { + vec.push(avp.encode_string()?) + } + Ok(vec) +}