fix(resolv): match glibc resolver label predicates (bd-vo0toc)

Author: Dicklesworthstone

crates/frankenlibc-abi/src/glibc_internal_abi.rs

@@ -1662,36 +1662,36 @@ pub unsafe extern "C" fn __res_state() -> *mut c_void {
 
 fn hostname_labels_ok(bytes: &[u8]) -> bool {
     if bytes.is_empty() {
-        return false;
+        return true;
     }
 
     let mut label_len: usize = 0;
-    let mut last = b'.';
+    let mut at_label_start = true;
     for &c in bytes {
         if c == b'.' {
-            if label_len == 0 || last == b'-' {
+            if label_len == 0 {
                 return false;
             }
             label_len = 0;
-            last = c;
-        } else if c.is_ascii_alphanumeric() || c == b'-' {
-            if label_len == 0 && c == b'-' {
+            at_label_start = true;
+        } else if c.is_ascii_alphanumeric() || c == b'-' || c == b'_' {
+            if at_label_start && c == b'-' {
                 return false;
             }
             label_len += 1;
             if label_len > 63 {
                 return false;
             }
-            last = c;
+            at_label_start = false;
         } else {
             return false;
         }
     }
 
-    label_len != 0 && last != b'-'
+    label_len != 0 || bytes.last() == Some(&b'.')
 }
 
-// res_hnok: hostname — letters, digits, hyphens only (RFC 952)
+// res_hnok: glibc-compatible hostname-label predicate.
 #[cfg_attr(not(debug_assertions), unsafe(no_mangle))]
 pub unsafe extern "C" fn res_hnok(dn: *const c_char) -> c_int {
     let Some(bytes) = (unsafe { dns_c_string_bytes(dn) }) else {

crates/frankenlibc-abi/tests/conformance_diff_resolver_validators.rs

@@ -0,0 +1,36 @@
+#![cfg(target_os = "linux")]
+#![allow(unsafe_code)]
+//! Live host-glibc differential coverage for DNS label predicates.
+//!
+//! These predicates are consumed before resolver queries are assembled, so
+//! boundary labels must follow the host contract exactly rather than merely
+//! accepting the common alphanumeric cases.
+
+use frankenlibc_abi::glibc_internal_abi as fl;
+use std::ffi::CString;
+use std::os::raw::{c_char, c_int};
+
+unsafe extern "C" {
+    fn res_dnok(name: *const c_char) -> c_int;
+    fn res_hnok(name: *const c_char) -> c_int;
+}
+
+#[test]
+fn resolver_label_boundaries_match_glibc() {
+    for raw in [
+        "",
+        "-bad.example",
+        "bad-.example",
+        "example.com.",
+        "two..dots",
+        "_service._tcp.example",
+    ] {
+        let name = CString::new(raw).unwrap();
+        let fl_hnok = unsafe { fl::res_hnok(name.as_ptr()) };
+        let host_hnok = unsafe { res_hnok(name.as_ptr()) };
+        let fl_dnok = unsafe { fl::res_dnok(name.as_ptr()) };
+        let host_dnok = unsafe { res_dnok(name.as_ptr()) };
+        assert_eq!(fl_hnok, host_hnok, "res_hnok({raw:?})");
+        assert_eq!(fl_dnok, host_dnok, "res_dnok({raw:?})");
+    }
+}