Debian Codegraph @

net/dial/resolve.ha

raw
1 // SPDX-License-Identifier: MPL-2.0
2 // (c) Hare authors <https://harelang.org>
3
4 use crypto::random;
5 use net::dns;
6 use net::ip;
7 use strconv;
8 use strings;
9 use unix::hosts;
10
11 // Splits an address:port/service string into separate address and port
12 // components. The return value is borrowed from the input.
13 export fn splitaddr(addr: str, service: str) ((str, u16) | invalid_address) = {
14 let port = 0u16;
15 if (strings::hasprefix(addr, '[')) {
16 // [::1]:80 (IPv6)
17 match (strings::index(addr, "]:")) {
18 case let i: size =>
19 const sub = strings::sub(addr, i + 2, strings::end);
20 addr = strings::sub(addr, 1, i);
21 match (strconv::stou16(sub)) {
22 case let u: u16 =>
23 port = u;
24 case =>
25 return invalid_address;
26 };
27 case void =>
28 match (strconv::stou16(service)) {
29 case let u: u16 =>
30 port = u;
31 case => void;
32 };
33 };
34 return (addr, port);
35 };
36
37 // 1.1.1.1:80 (IPv4)
38 match (strings::index(addr, ':')) {
39 case void =>
40 match (strconv::stou16(service)) {
41 case let u: u16 =>
42 port = u;
43 case => void;
44 };
45 case let i: size =>
46 const sub = strings::sub(addr, i + 1, strings::end);
47 addr = strings::sub(addr, 0, i);
48 match (strconv::stou16(sub)) {
49 case let u: u16 =>
50 port = u;
51 case =>
52 return invalid_address;
53 };
54 };
55 return (addr, port);
56 };
57
58 // Performs DNS resolution on a given address string for a given service,
59 // including /etc/hosts lookup and SRV resolution, and returns a list of
60 // candidate IP addresses and the appropriate port, or an error.
61 //
62 // The caller must free the [[net::ip::addr]] slice.
63 export fn resolve(
64 proto: str,
65 addr: str,
66 service: str,
67 ) (([]ip::addr, u16) | error | nomem) = {
68 const (addr, port) = splitaddr(addr, service)?;
69 if (service == "unknown" && port == 0) {
70 return unknown_service;
71 };
72
73 let addrs = resolve_addr(addr)?;
74 if (port == 0) match (lookup_service(proto, service)) {
75 case let p: u16 =>
76 port = p;
77 case void => void;
78 };
79
80 // TODO:
81 // - Consult /etc/services
82 // - Fetch the SRV record
83
84 if (port == 0) {
85 return unknown_service;
86 };
87 if (len(addrs) == 0) {
88 return dns::name_error: dns::error;
89 };
90
91 return (addrs, port);
92 };
93
94 fn resolve_addr(addr: str) ([]ip::addr | error | nomem) = {
95 match (ip::parse(addr)) {
96 case let addr: ip::addr =>
97 return alloc([addr])?;
98 case ip::invalid => void;
99 };
100
101 const addrs = match (hosts::lookup(addr)) {
102 case let addrs: []ip::addr =>
103 yield addrs;
104 case let e: hosts::error =>
105 return e;
106 case nomem =>
107 return nomem;
108 };
109 if (len(addrs) != 0) {
110 return addrs;
111 };
112
113 const domain = dns::parse_domain(addr)?;
114 defer free(domain);
115
116 let id = 0u16;
117 random::buffer(&id: *[size(u16)]u8);
118
119 const query6 = dns::message {
120 header = dns::header {
121 id = id,
122 op = dns::op {
123 qr = dns::qr::QUERY,
124 opcode = dns::opcode::QUERY,
125 rd = true,
126 ...
127 },
128 qdcount = 1,
129 ...
130 },
131 questions = [
132 dns::question {
133 qname = domain,
134 qtype = dns::qtype::AAAA,
135 qclass = dns::qclass::IN,
136 },
137 ],
138 ...
139 };
140 const query4 = dns::message {
141 header = dns::header {
142 id = id + 1,
143 op = dns::op {
144 qr = dns::qr::QUERY,
145 opcode = dns::opcode::QUERY,
146 rd = true,
147 ...
148 },
149 qdcount = 1,
150 ...
151 },
152 questions = [
153 dns::question {
154 qname = domain,
155 qtype = dns::qtype::A,
156 qclass = dns::qclass::IN,
157 },
158 ],
159 ...
160 };
161
162 const resp6 = match (dns::query(&query6)) {
163 case let msg: *dns::message =>
164 yield msg;
165 case let e: dns::error =>
166 return e;
167 case nomem =>
168 return nomem;
169 };
170 defer dns::message_free(resp6);
171 const resp4 = match (dns::query(&query4)) {
172 case let msg: *dns::message =>
173 yield msg;
174 case let e: dns::error =>
175 return e;
176 case nomem =>
177 return nomem;
178 };
179 defer dns::message_free(resp4);
180
181 let addrs: []ip::addr = [];
182 let ok = false;
183 defer if (!ok) free(addrs);
184 collect_answers(&addrs, &resp6.answers)?;
185 collect_answers(&addrs, &resp4.answers)?;
186 ok = true;
187 return addrs;
188 };
189
190 fn collect_answers(addrs: *[]ip::addr, answers: *[]dns::rrecord) (void | nomem) = {
191 for (let i = 0z; i < len(answers); i += 1) {
192 match (answers[i].rdata) {
193 case let addr: dns::aaaa =>
194 append(addrs, addr: ip::addr)?;
195 case let addr: dns::a =>
196 append(addrs, addr: ip::addr)?;
197 case => void;
198 };
199 };
200 };