dns

stable

DNS lookup, IP address parsing, hostname validation, and DNS record formatting utilities for network-aware Zolo programs.

use plugin dns::{lookup, lookup_first, resolve, …}

11 functions Networking

Runs with the native Zolo host

Plugin snippets can be edited in the Playground, but native capabilities are executed locally with the Zolo CLI.

/ filter jk navigate Esc clear

Functions (11)

lookup Resolves a hostname to all its IP addresses
lookup_first Resolves a hostname to its first IP address
resolve Resolves a host:port string to socket addresses
is_ipv4 Returns true if a string is a valid IPv4 address
is_ipv6 Returns true if a string is a valid IPv6 address
is_loopback Returns true if an IP is a loopback address
is_private Returns true if an IP is a private network address
parse_ip Parses an IP string into a detail table
reverse_lookup_str Converts an IP to its reverse DNS ARPA form
format_record Formats a DNS record in zone file syntax
is_valid_hostname Validates a hostname against RFC rules

From import to result

01Import only what you use
02Copy the smallest example
03Run it with the Zolo CLI

Overview¶

The dns plugin gives Zolo programs network-awareness without pulling in an external resolver library. It wraps the operating system's name resolver to turn hostnames into IP addresses, and adds a toolkit of pure string utilities for classifying IPs (IPv4 vs IPv6, loopback, private), validating hostnames, building reverse-DNS ARPA names, and formatting zone-file records. Every function is stateless — there are no handles or connections to manage; you call a function with strings and integers and get a value back. Reach for it whenever you need to resolve a host, sanity-check user-supplied addresses, or emit DNS records.

Common patterns¶

Resolve a hostname and inspect the address it returned:

use plugin dns::{lookup_first, is_private, is_ipv6}

let ip = lookup_first("example.com")
if ip != nil {
  print("resolved to {ip}")
  print("private?  {is_private(ip)}")
  print("ipv6?     {is_ipv6(ip)}")
}

Validate a hostname before trying to resolve it, so a typo doesn't reach the resolver:

use plugin dns::{is_valid_hostname, lookup}

let host = "my-service.internal"
if is_valid_hostname(host) {
  let ips = lookup(host)
  print("first address: {ips[1]}")
} else {
  print("'{host}' is not a valid hostname")
}

Build a zone-file fragment and the matching reverse-DNS name for an address:

use plugin dns::{format_record, reverse_lookup_str}

let ip = "93.184.216.34"
print(format_record("A", "example.com.", ip))
print(reverse_lookup_str(ip))
// "34.216.184.93.in-addr.arpa"

lookup(hostname) → table

Resolves a hostname to all its IP addresses

Resolves a hostname to all its IP addresses using the system resolver. Returns a table (array) of IP address strings. Duplicates are removed.

use plugin dns::{lookup}

let ips = lookup("example.com")
print(ips[1])  // e.g. "93.184.216.34"

Iterate over every address a host resolves to:

use plugin dns::{lookup}

let ips = lookup("localhost")
for ip in ips {
  print("address: {ip}")
}

lookup_first(hostname) → string | nil

Resolves a hostname to its first IP address

Resolves a hostname and returns only the first IP address, or nil if resolution fails. Useful when you only need one address.

use plugin dns::{lookup_first}

let ip = lookup_first("example.com")
if ip != nil {
  print("Resolved: {ip}")
}

resolve(hostname_with_port) → table

Resolves a host:port string to socket addresses

Resolves a "host:port" string to a table of socket address strings (e.g. "93.184.216.34:80"). Use when you need the port preserved in the result.

use plugin dns::{resolve}

let addrs = resolve("example.com:80")
print(addrs[1])  // "93.184.216.34:80"

is_ipv4(addr) → bool

Returns true if a string is a valid IPv4 address

Returns true if the string is a valid IPv4 address, false otherwise.

use plugin dns::{is_ipv4}

print(is_ipv4("192.168.1.1"))  // true
print(is_ipv4("::1"))          // false
print(is_ipv4("not-an-ip"))    // false

is_ipv6(addr) → bool

Returns true if a string is a valid IPv6 address

Returns true if the string is a valid IPv6 address, false otherwise.

use plugin dns::{is_ipv6}

print(is_ipv6("::1"))           // true
print(is_ipv6("192.168.1.1"))   // false

is_loopback(addr) → bool

Returns true if an IP is a loopback address

Returns true if the IP address is a loopback address (127.x.x.x for IPv4 or ::1 for IPv6).

use plugin dns::{is_loopback}

print(is_loopback("127.0.0.1"))  // true
print(is_loopback("::1"))        // true
print(is_loopback("8.8.8.8"))    // false

is_private(addr) → bool

Returns true if an IP is a private network address

Returns true if the IP address is in a private network range: 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16 for IPv4, or fc00::/7 for IPv6.

use plugin dns::{is_private}

print(is_private("192.168.0.1"))  // true
print(is_private("10.0.0.5"))     // true
print(is_private("8.8.8.8"))      // false

parse_ip(addr) → table

Parses an IP string into a detail table

Parses an IP address string into a table with fields: address (normalized), kind ("v4" or "v6"), is_loopback, and is_unspecified. Errors if the string is not a valid IP.

use plugin dns::{parse_ip}

let info = parse_ip("192.168.1.100")
print(info["kind"])        // "v4"
print(info["is_loopback"]) // false

Use parse_ip to branch on address family and flag special addresses:

use plugin dns::{parse_ip}

let info = parse_ip("::1")
print("normalized: {info["address"]}")  // "::1"
print("kind: {info["kind"]}")            // "v6"
if info["is_loopback"] {
  print("this is a loopback address")
}

reverse_lookup_str(ip) → string

Converts an IP to its reverse DNS ARPA form

Returns the reverse DNS ARPA form of an IP address. For IPv4, this is d.c.b.a.in-addr.arpa; for IPv6, it is the full nibble-reversed .ip6.arpa form.

use plugin dns::{reverse_lookup_str}

print(reverse_lookup_str("93.184.216.34"))
// "34.216.184.93.in-addr.arpa"

IPv6 addresses produce the full nibble-reversed .ip6.arpa name:

use plugin dns::{reverse_lookup_str}

print(reverse_lookup_str("::1"))
// "1.0.0. ... .0.0.ip6.arpa"

format_record(record_type, name, value, ttl?, priority?, weight?) → string

Formats a DNS record in zone file syntax

Formats a DNS record in standard zone file syntax. Supports A, AAAA, CNAME, MX, TXT, NS, SOA, and SRV record types. ttl defaults to 3600.

use plugin dns::{format_record}

print(format_record("A", "example.com.", "93.184.216.34"))
// "example.com.  3600  IN  A  93.184.216.34"

print(format_record("MX", "example.com.", "mail.example.com.", 3600, 10))
// "example.com.  3600  IN  MX  10  mail.example.com."

print(format_record("TXT", "example.com.", "v=spf1 include:_spf.google.com ~all"))
// "example.com.  3600  IN  TXT  \"v=spf1 include:_spf.google.com ~all\""

SRV records take both a priority and a weight, and any record type accepts a custom ttl:

use plugin dns::{format_record}

print(format_record("SRV", "_sip._tcp.example.com.", "sip.example.com.", 7200, 10, 60))
// "_sip._tcp.example.com.  7200  IN  SRV  10  60  sip.example.com."

print(format_record("CNAME", "www.example.com.", "example.com.", 300))
// "www.example.com.  300  IN  CNAME  example.com."

is_valid_hostname(hostname) → bool

Validates a hostname against RFC rules

Validates a hostname against RFC rules: max 253 characters total, each label max 63 characters, labels contain only alphanumeric characters and hyphens, and labels do not start or end with a hyphen.

use plugin dns::{is_valid_hostname}

print(is_valid_hostname("example.com"))       // true
print(is_valid_hostname("-bad.example.com"))  // false
print(is_valid_hostname("ok-label.test"))     // true

View source code

dns