cerr << "XXXXXXXXX SID case 1" << endl;
return {};
}
- MOADNSParser parser(false, reinterpret_cast<char *>(buffer.data()), buffer.size()); // NOLINT
+ MOADNSParser parser(false, reinterpret_cast<char*>(buffer.data()), buffer.size()); // NOLINT
if (parser.d_header.rcode != RCode::NoError || parser.d_answers.size() != 1) {
cerr << "XXXXXXXXX SID case 2" << endl;
return {};
}
- const auto& answer = parser.d_answers.at(0);
+ const auto& answer = parser.d_answers.at(0);
if (answer.first.d_type == QType::TXT) {
if (auto txt = getRR<TXTRecordContent>(answer.first); txt != nullptr) {
cerr << "XXXXXXXXX SID is " << txt->d_text << endl;
return txt->d_text;
}
}
- cerr << "XXXXXXXXX SID case 3" << endl;
+ cerr << "XXXXXXXXX SID case 3" << endl;
return {};
}
} // anonymous namespace
{
auto data = d_data.lock();
if (auto iter = data->d_map.find(name); iter != data->d_map.end()) {
- if (iter->second.d_ttd < now) {
- return iter->second.d_address;
- }
- // If it's stale, re-resolve below
+ if (iter->second.d_ttd < now) {
+ return iter->second.d_address;
+ }
+ // If it's stale, re-resolve below
}
// We keep the lock while resolving, even though this might take a while...
auto address = resolve(name);
}
pub fn validate_socket_address_or_name(field: &str, val: &String) -> Result<(), ValidationError> {
- let sa = SocketAddr::from_str(val);
+ let sa = validate_socket_address(field, val);
if sa.is_err() {
- let ip = IpAddr::from_str(val);
- if ip.is_err() {
- if !hostname_validator::is_valid(val) {
- let parts:Vec<&str> = val.split(':').collect();
- if parts.len () != 2 || !hostname_validator::is_valid(parts[0]) || !is_port_number(parts[1]) {
- let msg = format!(
- "{}: value `{}' is not an IP, IP:port, name or name:port combination",
- field, val
- );
- return Err(ValidationError { msg });
- }
+ if !hostname_validator::is_valid(val) {
+ let parts: Vec<&str> = val.split(':').collect();
+ if parts.len() != 2
+ || !hostname_validator::is_valid(parts[0])
+ || !is_port_number(parts[1])
+ {
+ let msg = format!(
+ "{}: value `{}' is not an IP, IP:port, name or name:port combination",
+ field, val
+ );
+ return Err(ValidationError { msg });
}
}
}
serde_yaml::from_str(str)
}
-pub fn parse_yaml_string_to_allow_notify_for(
- str: &str,
-) -> Result<Vec<String>, serde_yaml::Error> {
+pub fn parse_yaml_string_to_allow_notify_for(str: &str) -> Result<Vec<String>, serde_yaml::Error> {
serde_yaml::from_str(str)
}
}
#[allow(clippy::ptr_arg)] //# Avoids creating a rust::Slice object on the C++ side.
-pub fn validate_forward_zones(
- field: &str,
- vec: &Vec<ForwardZone>,
-) -> Result<(), ValidationError> {
+pub fn validate_forward_zones(field: &str, vec: &Vec<ForwardZone>) -> Result<(), ValidationError> {
validate_vec(field, vec, |field, element| element.validate(field))
}
}
serde_yaml::Value::Sequence(seq)
}
- other => serde_yaml::Value::String("map_to_yaml_string: Unknown type: ".to_owned() + other),
+ other => serde_yaml::Value::String(
+ "map_to_yaml_string: Unknown type: ".to_owned() + other,
+ ),
};
if entry.overriding {
let tagged_value = Box::new(serde_yaml::value::TaggedValue {
}
// This function is called from C++, it needs to acquire the lock
-pub fn api_add_forward_zones(path: &str, forwardzones: &mut Vec<ForwardZone>) -> Result<(), std::io::Error> {
+pub fn api_add_forward_zones(
+ path: &str,
+ forwardzones: &mut Vec<ForwardZone>,
+) -> Result<(), std::io::Error> {
let _lock = LOCK.lock().unwrap();
let mut zones = api_read_zones_locked(path, true)?;
zones.forward_zones.append(forwardzones);
* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-use std::{error::Error, fmt};
use crate::ValidationError;
+use std::{error::Error, fmt};
/* Helper code for validation */
impl Error for ValidationError {}
pub const OVERRIDE_TAG: &str = "!override";
-pub fn is_overriding(m: &serde_yaml::Mapping, key: &str) -> bool{
+pub fn is_overriding(m: &serde_yaml::Mapping, key: &str) -> bool {
if let Some(serde_yaml::Value::Tagged(vvv)) = m.get(key) {
return vvv.tag == OVERRIDE_TAG;
}
false
}
-