#![allow(dead_code)]
use std::net::IpAddr;
pub(crate) fn datetime(s: &str) -> bool {
let b = s.as_bytes();
if !date_shape(b) {
return false;
}
if b.len() == 10 {
return true;
}
if b[10] != b'T' && b[10] != b' ' {
return false;
}
let Some(i) = time_shape(b, 11) else {
return false;
};
match &b[i..] {
[] | [b'Z'] => true,
[sign, h1, h2, b':', m1, m2] => {
(*sign == b'+' || *sign == b'-')
&& h1.is_ascii_digit()
&& h2.is_ascii_digit()
&& m1.is_ascii_digit()
&& m2.is_ascii_digit()
}
_ => false,
}
}
pub(crate) fn date(s: &str) -> bool {
let b = s.as_bytes();
b.len() == 10 && date_shape(b)
}
pub(crate) fn time(s: &str) -> bool {
let b = s.as_bytes();
time_shape(b, 0) == Some(b.len())
}
pub(crate) fn inet(s: &str) -> bool {
let (addr, prefix) = split_mask(s);
let Ok(ip) = addr.parse::<IpAddr>() else {
return false;
};
match prefix {
None => true,
Some(prefix) => parse_prefix(prefix, family_bits(ip)).is_some(),
}
}
pub(crate) fn cidr(s: &str) -> bool {
let (addr, prefix) = split_mask(s);
let Ok(ip) = addr.parse::<IpAddr>() else {
return false;
};
let bits = family_bits(ip);
let prefix = match prefix {
None => bits,
Some(prefix) => match parse_prefix(prefix, bits) {
Some(p) => p,
None => return false,
},
};
host_bits_zero(ip, prefix)
}
pub(crate) fn macaddr(s: &str) -> bool {
let Some((sep, groups)) = mac_groups(s) else {
return false;
};
match sep {
None => groups == [12],
Some(':' | '-') if groups == [2, 2, 2, 2, 2, 2] || groups == [6, 6] => true,
Some('.' | '-') if groups == [4, 4, 4] => true,
_ => false,
}
}
pub(crate) fn macaddr8(s: &str) -> bool {
let Some((sep, groups)) = mac_groups(s) else {
return false;
};
match sep {
None => groups == [16],
Some(':' | '-')
if groups == [2, 2, 2, 2, 2, 2, 2, 2] || groups == [6, 10] || groups == [8, 8] =>
{
true
}
Some('.' | '-') if groups == [4, 4, 4, 4] => true,
_ => false,
}
}
pub(crate) fn macaddr_pairs(s: &str) -> bool {
matches!(mac_groups(s), Some((Some(':' | '-'), g)) if g == [2, 2, 2, 2, 2, 2])
}
pub(crate) fn macaddr8_pairs(s: &str) -> bool {
matches!(mac_groups(s), Some((Some(':' | '-'), g)) if g == [2, 2, 2, 2, 2, 2, 2, 2])
}
pub(crate) fn uuid(s: &str) -> bool {
uuid_hyphenated(s) || (s.len() == 32 && s.bytes().all(|c| c.is_ascii_hexdigit()))
}
pub(crate) fn uuid_hyphenated(s: &str) -> bool {
let b = s.as_bytes();
b.len() == 36
&& b.iter().enumerate().all(|(i, &c)| match i {
8 | 13 | 18 | 23 => c == b'-',
_ => c.is_ascii_hexdigit(),
})
}
fn mac_groups(s: &str) -> Option<(Option<char>, Vec<usize>)> {
if s.is_empty() {
return None;
}
let mut sep = None;
for c in s.chars() {
if c.is_ascii_hexdigit() {
continue;
}
if !matches!(c, ':' | '-' | '.') {
return None;
}
match sep {
None => sep = Some(c),
Some(existing) if existing == c => {}
Some(_) => return None, }
}
let groups = match sep {
Some(c) => s.split(c).map(str::len).collect(),
None => vec![s.len()],
};
Some((sep, groups))
}
fn date_shape(b: &[u8]) -> bool {
let digit = |i: usize| b.get(i).is_some_and(u8::is_ascii_digit);
b.len() >= 10
&& (0..4).all(digit)
&& b[4] == b'-'
&& (5..7).all(digit)
&& b[7] == b'-'
&& (8..10).all(digit)
}
fn time_shape(b: &[u8], i: usize) -> Option<usize> {
let digit = |i: usize| b.get(i).is_some_and(u8::is_ascii_digit);
let ok = digit(i)
&& digit(i + 1)
&& b.get(i + 2) == Some(&b':')
&& digit(i + 3)
&& digit(i + 4)
&& b.get(i + 5) == Some(&b':')
&& digit(i + 6)
&& digit(i + 7);
if !ok {
return None;
}
let mut end = i + 8;
if b.get(end) == Some(&b'.') {
let fraction_start = end + 1;
end += 1;
while digit(end) {
end += 1;
}
if end == fraction_start {
return None;
}
}
Some(end)
}
fn split_mask(s: &str) -> (&str, Option<&str>) {
match s.split_once('/') {
Some((addr, prefix)) => (addr, Some(prefix)),
None => (s, None),
}
}
fn family_bits(ip: IpAddr) -> u32 {
match ip {
IpAddr::V4(_) => 32,
IpAddr::V6(_) => 128,
}
}
fn parse_prefix(prefix: &str, bits: u32) -> Option<u32> {
if prefix.is_empty() || !prefix.bytes().all(|b| b.is_ascii_digit()) {
return None;
}
prefix.parse::<u32>().ok().filter(|p| *p <= bits)
}
fn host_bits_zero(ip: IpAddr, prefix: u32) -> bool {
match ip {
IpAddr::V4(v4) => {
let host = if prefix >= 32 { 0 } else { u32::MAX >> prefix };
u32::from(v4) & host == 0
}
IpAddr::V6(v6) => {
let host = if prefix >= 128 {
0
} else {
u128::MAX >> prefix
};
u128::from(v6) & host == 0
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn datetime_shapes() {
assert!(datetime("2024-01-02"));
assert!(datetime("2024-01-02T03:04:05"));
assert!(datetime("2024-01-02T03:04:05Z"));
assert!(datetime("2024-01-02 03:04:05.123+08:00"));
assert!(datetime("2024-01-02T03:04:05-07:00"));
assert!(!datetime("tomorrow"));
assert!(!datetime("2024-1-2")); assert!(!datetime("2024-01-02X03:04:05")); assert!(!datetime("2024-01-02T03:04")); assert!(!datetime("2024-01-02T03:04:05.")); assert!(!datetime("2024-01-02T03:04:05+8:00")); }
#[test]
fn date_shapes() {
assert!(date("2024-01-02"));
assert!(!date("2024-1-2"));
assert!(!date("2024-01-02T03:04:05Z")); assert!(!date("20240102"));
}
#[test]
fn time_shapes() {
assert!(time("03:04:05"));
assert!(time("03:04:05.5"));
assert!(!time("3:04:05")); assert!(!time("03:04")); assert!(!time("03:04:05.")); assert!(!time("03:04:05+08:00")); }
#[test]
fn inet_shapes() {
assert!(inet("10.0.0.1"));
assert!(inet("10.0.0.1/24")); assert!(inet("::1"));
assert!(inet("fe80::1/64"));
assert!(inet("10.0.0.1/32"));
assert!(!inet("10.0.0.1/33")); assert!(!inet("10.0.0/24")); assert!(!inet("10.0.0.1/")); assert!(!inet("example.com"));
}
#[test]
fn cidr_shapes() {
assert!(cidr("10.0.0.0/8"));
assert!(cidr("10.1.2.3")); assert!(cidr("2001:db8::/32"));
assert!(cidr("::/0"));
assert!(!cidr("10.0.0.1/24")); assert!(!cidr("2001:db8::1/32")); assert!(!cidr("10.0.0.0/33")); assert!(!cidr("10.0.0.0/")); }
#[test]
fn macaddr_postgres_forms() {
assert!(macaddr("08:00:2b:01:02:03"));
assert!(macaddr("08-00-2b-01-02-03"));
assert!(macaddr("08002b:010203"));
assert!(macaddr("08002b-010203"));
assert!(macaddr("0800.2b01.0203"));
assert!(macaddr("0800-2b01-0203"));
assert!(macaddr("08002b010203"));
assert!(!macaddr("08:00:2b:01:02")); assert!(!macaddr("08:00-2b:01:02:03")); assert!(!macaddr("0800:2b01:0203")); assert!(!macaddr("08002b.010203")); assert!(!macaddr("08:002b01:0203")); assert!(!macaddr("08002b01020g")); }
#[test]
fn macaddr8_postgres_forms() {
assert!(macaddr8("08:00:2b:01:02:03:04:05"));
assert!(macaddr8("08-00-2b-01-02-03-04-05"));
assert!(macaddr8("08002b:0102030405")); assert!(macaddr8("08002b01:02030405")); assert!(macaddr8("0800.2b01.0203.0405"));
assert!(macaddr8("0800-2b01-0203-0405"));
assert!(macaddr8("08002b0102030405"));
assert!(!macaddr8("08:00:2b:01:02:03")); assert!(!macaddr8("08002b0102030405ff")); }
#[test]
fn mac_pair_spellings_only() {
assert!(macaddr_pairs("08:00:2b:01:02:03"));
assert!(macaddr_pairs("08-00-2b-01-02-03"));
assert!(macaddr8_pairs("aa:bb:cc:dd:ee:ff:00:11"));
assert!(!macaddr_pairs("08002b:010203")); assert!(!macaddr_pairs("08002b010203")); assert!(!macaddr8_pairs("aa:bb:cc:dd:ee:ff")); }
#[test]
fn uuid_shapes() {
assert!(uuid("550e8400-e29b-41d4-a716-446655440000"));
assert!(uuid("550E8400-E29B-41D4-A716-446655440000")); assert!(uuid("550e8400e29b41d4a716446655440000"));
assert!(!uuid("550e8400-e29b-41d4-a716-44665544000")); assert!(!uuid("550e8400-e29b-41d4-a716-44665544000g")); assert!(!uuid("550e8400e29b41d4a71644665544000"));
assert!(uuid_hyphenated("550e8400-e29b-41d4-a716-446655440000"));
assert!(!uuid_hyphenated("550e8400e29b41d4a716446655440000"));
}
}