mod_dns_resolver/
lib.rs

1use ::config::{any_err, get_or_create_sub_module, serialize_options, SerdeWrappedValue};
2use dns_resolver::{
3    get_resolver, ptr_host, resolve_a_or_aaaa, reverse_ip, AggregateResolver, HickoryResolver,
4    IpLookupStrategy, Resolver, TestResolver,
5};
6use kumo_address::host_or_socket::HostOrSocketAddress;
7use mailexchanger::{
8    set_mx_concurrency_limit, set_mx_negative_cache_ttl, set_mx_timeout,
9    set_mx_transient_negative_cache_ttl, MailExchanger,
10};
11use mlua::{Lua, LuaSerdeExt, Value};
12use parking_lot::Mutex;
13use std::collections::HashMap;
14use std::net::IpAddr;
15use std::str::FromStr;
16use std::sync::{Arc, LazyLock};
17use std::time::Duration;
18
19mod config;
20mod hickory_backend;
21mod resolv_conf_loader;
22mod unbound_backend;
23
24use crate::config::DnsResolverConfig;
25
26static RESOLVERS: LazyLock<Mutex<HashMap<String, Arc<Box<dyn Resolver>>>>> =
27    LazyLock::new(|| Mutex::new(HashMap::new()));
28
29pub fn get_resolver_instance(
30    opt_resolver_name: &Option<String>,
31) -> anyhow::Result<Arc<Box<dyn Resolver>>> {
32    if let Some(name) = opt_resolver_name {
33        return RESOLVERS
34            .lock()
35            .get(name)
36            .cloned()
37            .ok_or_else(|| anyhow::anyhow!("resolver {name} is not defined"));
38    }
39
40    Ok(get_resolver())
41}
42
43pub fn get_opt_resolver(
44    opt_resolver_name: &Option<String>,
45) -> anyhow::Result<Option<Arc<Box<dyn Resolver>>>> {
46    if let Some(name) = opt_resolver_name {
47        let r = RESOLVERS
48            .lock()
49            .get(name)
50            .cloned()
51            .ok_or_else(|| anyhow::anyhow!("resolver {name} is not defined"))?;
52        Ok(Some(r))
53    } else {
54        Ok(None)
55    }
56}
57
58pub fn register(lua: &Lua) -> anyhow::Result<()> {
59    let dns_mod = get_or_create_sub_module(lua, "dns")?;
60
61    dns_mod.set(
62        "lookup_mx",
63        lua.create_async_function(
64            |lua, (domain, opt_resolver_name): (String, Option<String>)| async move {
65                let opt_resolver = get_opt_resolver(&opt_resolver_name).map_err(any_err)?;
66                let mx = MailExchanger::resolve_via(&domain, opt_resolver.as_ref().map(|r| &***r))
67                    .await
68                    .map_err(any_err)?;
69                Ok(lua.to_value_with(&*mx, serialize_options()))
70            },
71        )?,
72    )?;
73
74    dns_mod.set(
75        "set_mx_concurrency_limit",
76        lua.create_function(move |_lua, limit: usize| {
77            set_mx_concurrency_limit(limit);
78            Ok(())
79        })?,
80    )?;
81
82    dns_mod.set(
83        "set_mx_timeout",
84        lua.create_function(move |lua, duration: Value| {
85            let duration: duration_serde::Wrap<Duration> = lua.from_value(duration)?;
86            set_mx_timeout(duration.into_inner()).map_err(any_err)
87        })?,
88    )?;
89
90    dns_mod.set(
91        "set_mx_negative_cache_ttl",
92        lua.create_function(move |lua, duration: Value| {
93            let duration: duration_serde::Wrap<Duration> = lua.from_value(duration)?;
94            set_mx_negative_cache_ttl(duration.into_inner()).map_err(any_err)
95        })?,
96    )?;
97
98    dns_mod.set(
99        "set_mx_transient_negative_cache_ttl",
100        lua.create_function(move |lua, duration: Value| {
101            let duration: duration_serde::Wrap<Duration> = lua.from_value(duration)?;
102            set_mx_transient_negative_cache_ttl(duration.into_inner()).map_err(any_err)
103        })?,
104    )?;
105
106    dns_mod.set(
107        "set_mta_sts_enabled",
108        lua.create_function(move |_lua, enabled: bool| {
109            mailexchanger::set_mta_sts_enabled(enabled);
110            Ok(())
111        })?,
112    )?;
113
114    dns_mod.set(
115        "ptr_host",
116        lua.create_function(move |_lua, ip: String| {
117            let ip: IpAddr = ip.parse().map_err(any_err)?;
118            Ok(ptr_host(ip))
119        })?,
120    )?;
121
122    dns_mod.set(
123        "reverse_ip",
124        lua.create_function(move |_lua, ip: String| {
125            let ip: IpAddr = ip.parse().map_err(any_err)?;
126            Ok(reverse_ip(ip))
127        })?,
128    )?;
129
130    dns_mod.set(
131        "rbl_lookup",
132        lua.create_async_function(
133            |_lua, (ip_str, bl_domain, opt_resolver_name): (String, String, Option<String>)| async move {
134                let resolver = get_resolver_instance(&opt_resolver_name).map_err(any_err)?;
135
136                let address: HostOrSocketAddress = ip_str.parse().map_err(any_err)?;
137                let reversed_ip = reverse_ip(address.ip().ok_or_else(||mlua::Error::external(format!("{ip_str} is not a valid IpAddr or SocketAddr")))?);
138                let name = format!("{reversed_ip}.{bl_domain}.");
139
140                let answers = resolver.resolve_ip(&name).await.map_err(any_err)?;
141                match answers.first() {
142                    Some(ip) => {
143                        let txt = resolver.resolve_txt(&name).await.map(|a| a.as_txt().join("")).ok();
144                        Ok((Some(ip.to_string()), txt))
145                    }
146                    None => {
147                        Ok((None, None))
148                    }
149                }
150            },
151        )?,
152    )?;
153
154    dns_mod.set(
155        "lookup_ptr",
156        lua.create_async_function(
157            |lua, (ip_str, opt_resolver_name): (String, Option<String>)| async move {
158                let resolver = get_resolver_instance(&opt_resolver_name).map_err(any_err)?;
159                let addr = std::net::IpAddr::from_str(&ip_str).map_err(any_err)?;
160                let answer = resolver.resolve_ptr(addr).await.map_err(any_err)?;
161                Ok(lua.to_value_with(&*answer, serialize_options()))
162            },
163        )?,
164    )?;
165
166    dns_mod.set(
167        "lookup_txt",
168        lua.create_async_function(
169            |_lua, (domain, opt_resolver_name): (String, Option<String>)| async move {
170                let resolver = get_resolver_instance(&opt_resolver_name).map_err(any_err)?;
171                let answer = resolver.resolve_txt(&domain).await.map_err(any_err)?;
172                Ok(answer.as_txt())
173            },
174        )?,
175    )?;
176
177    dns_mod.set(
178        "lookup_addr",
179        lua.create_async_function(
180            |_lua,
181             (domain, opt_resolver_name, strategy): (
182                String,
183                Option<String>,
184                Option<SerdeWrappedValue<IpLookupStrategy>>,
185            )| async move {
186                let opt_resolver = get_opt_resolver(&opt_resolver_name).map_err(any_err)?;
187                let result = resolve_a_or_aaaa(
188                    &domain,
189                    opt_resolver.as_ref().map(|r| &***r),
190                    strategy.map(|v| v.0).unwrap_or_default(),
191                )
192                .await
193                .map_err(any_err)?;
194                let result: Vec<String> = result
195                    .into_iter()
196                    .map(|item| item.addr.to_string())
197                    .collect();
198                Ok(result)
199            },
200        )?,
201    )?;
202
203    #[derive(serde::Deserialize, Debug)]
204    #[serde(untagged)]
205    enum ZoneSpec {
206        /// An insecure (non-DNSSEC) zone.
207        Insecure(String),
208        /// A zone with an explicit DNSSEC secure flag.
209        Detailed {
210            zone: String,
211            #[serde(default)]
212            secure: bool,
213        },
214    }
215
216    #[derive(serde::Deserialize, Debug)]
217    #[serde(untagged)]
218    enum TestResolverConfig {
219        /// A bare list of zones (each an insecure string or `{zone, secure}`).
220        Zones(Vec<ZoneSpec>),
221        /// The full form, which additionally supports forcing SERVFAIL for a
222        /// set of owner names.
223        Detailed {
224            zones: Vec<ZoneSpec>,
225            #[serde(default)]
226            servfail: Vec<String>,
227        },
228    }
229
230    impl TestResolverConfig {
231        fn make_resolver(&self) -> anyhow::Result<TestResolver> {
232            let mut resolver = TestResolver::default();
233
234            let (zones, servfail): (&[ZoneSpec], &[String]) = match self {
235                Self::Zones(zones) => (zones, &[]),
236                Self::Detailed { zones, servfail } => (zones, servfail),
237            };
238
239            for zone in zones {
240                resolver = match zone {
241                    ZoneSpec::Insecure(zone) => resolver.with_zone(zone),
242                    ZoneSpec::Detailed { zone, secure: true } => resolver.with_secure_zone(zone),
243                    ZoneSpec::Detailed {
244                        zone,
245                        secure: false,
246                    } => resolver.with_zone(zone),
247                }
248                .map_err(|err| anyhow::anyhow!("{err}"))?;
249            }
250
251            for name in servfail {
252                resolver = resolver.with_servfail(name);
253            }
254
255            Ok(resolver)
256        }
257    }
258
259    #[derive(serde::Deserialize, Debug)]
260    enum KumoResolverConfig {
261        Hickory(DnsResolverConfig),
262        HickorySystemConfig,
263        Unbound(DnsResolverConfig),
264        Test(TestResolverConfig),
265        Aggregate(Vec<KumoResolverConfig>),
266    }
267
268    impl KumoResolverConfig {
269        fn make_resolver(&self, path: &str) -> anyhow::Result<Box<dyn Resolver>> {
270            match self {
271                Self::Hickory(config) => Ok(Box::new(
272                    hickory_backend::build_hickory_resolver(config)
273                        .map_err(|e| anyhow::anyhow!("{path}: {e}"))?,
274                )),
275                Self::HickorySystemConfig => Ok(Box::new(HickoryResolver::new()?)),
276                Self::Unbound(config) => Ok(Box::new(
277                    unbound_backend::build_unbound_resolver(config)
278                        .map_err(|e| anyhow::anyhow!("{path}: {e}"))?,
279                )),
280                Self::Test(config) => Ok(Box::new(config.make_resolver()?)),
281                Self::Aggregate(children) => {
282                    let mut resolver = AggregateResolver::new();
283                    for (idx, child) in children.iter().enumerate() {
284                        let child_path = format!("{path}.Aggregate[{idx}]");
285                        resolver.push_resolver(child.make_resolver(&child_path)?);
286                    }
287                    Ok(Box::new(resolver))
288                }
289            }
290        }
291    }
292
293    dns_mod.set(
294        "configure_resolver",
295        lua.create_function(move |lua, config: mlua::Value| {
296            match lua.from_value::<KumoResolverConfig>(config.clone()) {
297                Ok(config) => {
298                    let resolver = config
299                        .make_resolver("configure_resolver")
300                        .map_err(any_err)?;
301                    dns_resolver::reconfigure_resolver(resolver);
302                    Ok(())
303                }
304                Err(err1) => match lua.from_value::<DnsResolverConfig>(config) {
305                    Ok(config) => {
306                        let resolver = hickory_backend::build_hickory_resolver(&config)
307                            .map_err(any_err)?;
308                        dns_resolver::reconfigure_resolver(resolver);
309                        Ok(())
310                    }
311                    Err(err2) => Err(mlua::Error::external(format!(
312                        "failed to parse config as either KumoResolverConfig ({err1:#}) or DnsResolverConfig ({err2:#})"
313                    ))),
314                },
315            }
316        })?,
317    )?;
318
319    dns_mod.set(
320        "define_resolver",
321        lua.create_function(move |lua, (name, config): (String, mlua::Value)| {
322            let config = lua
323                .from_value::<KumoResolverConfig>(config.clone())
324                .map_err(any_err)?;
325            let path = format!("define_resolver({name:?})");
326            let resolver = config.make_resolver(&path).map_err(any_err)?;
327
328            RESOLVERS.lock().insert(name, resolver.into());
329
330            Ok(())
331        })?,
332    )?;
333
334    dns_mod.set(
335        "configure_unbound_resolver",
336        lua.create_function(move |lua, config: mlua::Value| {
337            tracing::error!(
338                "kumo.dns.configure_unbound_resolver is deprecated and will be \
339                 removed in a future release; use kumo.dns.configure_resolver instead"
340            );
341            let config: DnsResolverConfig = lua.from_value(config)?;
342            let resolver = unbound_backend::build_unbound_resolver(&config).map_err(any_err)?;
343            dns_resolver::reconfigure_resolver(resolver);
344            Ok(())
345        })?,
346    )?;
347
348    dns_mod.set(
349        "configure_test_resolver",
350        lua.create_function(move |lua, config: mlua::Value| {
351            let config = lua
352                .from_value::<TestResolverConfig>(config)
353                .map_err(any_err)?;
354            let resolver = config.make_resolver().map_err(any_err)?;
355            dns_resolver::reconfigure_resolver(resolver);
356            Ok(())
357        })?,
358    )?;
359
360    dns_mod.set(
361        "configure_test_mta_sts",
362        lua.create_function(
363            move |_lua, policies: std::collections::BTreeMap<String, String>| {
364                let parsed = policies
365                    .into_iter()
366                    .map(|(domain, text)| {
367                        let policy =
368                            mta_sts::policy::MtaStsPolicy::parse(&text).map_err(any_err)?;
369                        Ok((domain, policy))
370                    })
371                    .collect::<mlua::Result<std::collections::BTreeMap<_, _>>>()?;
372                mta_sts::set_test_policies(parsed);
373                Ok(())
374            },
375        )?,
376    )?;
377
378    dns_mod.set(
379        "load_resolv_conf",
380        lua.create_function(move |lua, path: Option<String>| {
381            let config = resolv_conf_loader::load_resolv_conf(path.as_deref()).map_err(any_err)?;
382            lua.to_value_with(&config, serialize_options())
383        })?,
384    )?;
385
386    Ok(())
387}
mod_dns_resolver/lib.rs

mod_dns_resolver/
lib.rs
