File: | src/lib/libc/asr/getaddrinfo_async.c |
Warning: | line 430, column 8 Although the value stored to 'r' is used in the enclosing expression, the value is never actually read from 'r' |
Press '?' to see keyboard shortcuts
Keyboard shortcuts:
1 | /* $OpenBSD: getaddrinfo_async.c,v 1.61 2023/11/21 15:26:56 florian Exp $ */ |
2 | /* |
3 | * Copyright (c) 2012 Eric Faurot <eric@openbsd.org> |
4 | * |
5 | * Permission to use, copy, modify, and distribute this software for any |
6 | * purpose with or without fee is hereby granted, provided that the above |
7 | * copyright notice and this permission notice appear in all copies. |
8 | * |
9 | * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES |
10 | * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF |
11 | * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR |
12 | * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES |
13 | * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
14 | * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
15 | * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
16 | */ |
17 | |
18 | #include <sys/types.h> |
19 | #include <sys/socket.h> |
20 | #include <sys/uio.h> |
21 | #include <netinet/in.h> |
22 | #include <arpa/nameser.h> |
23 | #include <net/if.h> |
24 | #include <netdb.h> |
25 | |
26 | #include <asr.h> |
27 | #include <errno(*__errno()).h> |
28 | #include <ifaddrs.h> |
29 | #include <resolv.h> |
30 | #include <stdlib.h> |
31 | #include <string.h> |
32 | #include <unistd.h> |
33 | #include <limits.h> |
34 | |
35 | #include "asr_private.h" |
36 | |
37 | struct match { |
38 | int family; |
39 | int socktype; |
40 | int protocol; |
41 | }; |
42 | |
43 | static int getaddrinfo_async_run(struct asr_query *, struct asr_result *); |
44 | static int get_port(const char *, const char *, int); |
45 | static int iter_family(struct asr_query *, int); |
46 | static int addrinfo_add(struct asr_query *, const struct sockaddr *, const char *); |
47 | static int addrinfo_from_file(struct asr_query *, int, FILE *); |
48 | static int addrinfo_from_pkt(struct asr_query *, char *, size_t); |
49 | static int addrconfig_setup(struct asr_query *); |
50 | |
51 | static const struct match matches[] = { |
52 | { PF_INET2, SOCK_DGRAM2, IPPROTO_UDP17 }, |
53 | { PF_INET2, SOCK_STREAM1, IPPROTO_TCP6 }, |
54 | { PF_INET2, SOCK_RAW3, 0 }, |
55 | { PF_INET624, SOCK_DGRAM2, IPPROTO_UDP17 }, |
56 | { PF_INET624, SOCK_STREAM1, IPPROTO_TCP6 }, |
57 | { PF_INET624, SOCK_RAW3, 0 }, |
58 | { -1, 0, 0, }, |
59 | }; |
60 | |
61 | #define MATCH_FAMILY(a, b)((a) == matches[(b)].family || (a) == 0) ((a) == matches[(b)].family || (a) == PF_UNSPEC0) |
62 | #define MATCH_PROTO(a, b)((a) == matches[(b)].protocol || (a) == 0 || matches[(b)].protocol == 0) ((a) == matches[(b)].protocol || (a) == 0 || matches[(b)].protocol == 0) |
63 | /* Do not match SOCK_RAW unless explicitly specified */ |
64 | #define MATCH_SOCKTYPE(a, b)((a) == matches[(b)].socktype || ((a) == 0 && matches [(b)].socktype != 3)) ((a) == matches[(b)].socktype || ((a) == 0 && \ |
65 | matches[(b)].socktype != SOCK_RAW3)) |
66 | |
67 | enum { |
68 | DOM_INIT, |
69 | DOM_DOMAIN, |
70 | DOM_DONE |
71 | }; |
72 | |
73 | struct asr_query * |
74 | getaddrinfo_async(const char *hostname, const char *servname, |
75 | const struct addrinfo *hints, void *asr) |
76 | { |
77 | struct asr_ctx *ac; |
78 | struct asr_query *as; |
79 | |
80 | if (hints == NULL((void *)0) || (hints->ai_flags & AI_NUMERICHOST4) == 0) |
81 | ac = _asr_use_resolver(asr); |
82 | else |
83 | ac = _asr_no_resolver(); |
84 | if ((as = _asr_async_new(ac, ASR_GETADDRINFO)) == NULL((void *)0)) |
85 | goto abort; /* errno set */ |
86 | as->as_run = getaddrinfo_async_run; |
87 | |
88 | if (hostname) { |
89 | if ((as->as.ai.hostname = strdup(hostname)) == NULL((void *)0)) |
90 | goto abort; /* errno set */ |
91 | } |
92 | if (servname && (as->as.ai.servname = strdup(servname)) == NULL((void *)0)) |
93 | goto abort; /* errno set */ |
94 | if (hints) |
95 | memmove(&as->as.ai.hints, hints, sizeof *hints); |
96 | else { |
97 | memset(&as->as.ai.hints, 0, sizeof as->as.ai.hints); |
98 | as->as.ai.hints.ai_family = PF_UNSPEC0; |
99 | as->as.ai.hints.ai_flags = AI_ADDRCONFIG64; |
100 | } |
101 | |
102 | _asr_ctx_unref(ac); |
103 | return (as); |
104 | abort: |
105 | if (as) |
106 | _asr_async_free(as); |
107 | _asr_ctx_unref(ac); |
108 | return (NULL((void *)0)); |
109 | } |
110 | DEF_WEAK(getaddrinfo_async)__asm__(".weak " "getaddrinfo_async" " ; " "getaddrinfo_async" " = " "_libc_getaddrinfo_async"); |
111 | |
112 | static int |
113 | getaddrinfo_async_run(struct asr_query *as, struct asr_result *ar) |
114 | { |
115 | char fqdn[MAXDNAME1025]; |
116 | const char *str; |
117 | struct addrinfo *ai; |
118 | int i, family, r, is_localhost = 0; |
119 | FILE *f; |
120 | union { |
121 | struct sockaddr sa; |
122 | struct sockaddr_in sain; |
123 | struct sockaddr_in6 sain6; |
124 | } sa; |
125 | |
126 | next: |
127 | switch (as->as_state) { |
128 | |
129 | case ASR_STATE_INIT: |
130 | |
131 | /* |
132 | * First, make sure the parameters are valid. |
133 | */ |
134 | |
135 | as->as_count = 0; |
136 | |
137 | if (as->as.ai.hostname == NULL((void *)0) && |
138 | as->as.ai.servname == NULL((void *)0)) { |
139 | ar->ar_gai_errno = EAI_NONAME-2; |
140 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
141 | break; |
142 | } |
143 | |
144 | if (as->as.ai.hostname && as->as.ai.hostname[0] == '\0') { |
145 | ar->ar_gai_errno = EAI_NODATA-5; |
146 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
147 | break; |
148 | } |
149 | |
150 | ai = &as->as.ai.hints; |
151 | |
152 | if (ai->ai_addrlen || |
153 | ai->ai_canonname || |
154 | ai->ai_addr || |
155 | ai->ai_next) { |
156 | ar->ar_gai_errno = EAI_BADHINTS-12; |
157 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
158 | break; |
159 | } |
160 | |
161 | if (ai->ai_flags & ~AI_MASK(1 | 2 | 4 | 16 | 32 | 64) || |
162 | (ai->ai_flags & AI_CANONNAME2 && ai->ai_flags & AI_FQDN32)) { |
163 | ar->ar_gai_errno = EAI_BADFLAGS-1; |
164 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
165 | break; |
166 | } |
167 | |
168 | if (ai->ai_family != PF_UNSPEC0 && |
169 | ai->ai_family != PF_INET2 && |
170 | ai->ai_family != PF_INET624) { |
171 | ar->ar_gai_errno = EAI_FAMILY-6; |
172 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
173 | break; |
174 | } |
175 | |
176 | if (ai->ai_socktype && |
177 | ai->ai_socktype != SOCK_DGRAM2 && |
178 | ai->ai_socktype != SOCK_STREAM1 && |
179 | ai->ai_socktype != SOCK_RAW3) { |
180 | ar->ar_gai_errno = EAI_SOCKTYPE-7; |
181 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
182 | break; |
183 | } |
184 | |
185 | if (ai->ai_socktype == SOCK_RAW3 && |
186 | get_port(as->as.ai.servname, NULL((void *)0), 1) != 0) { |
187 | ar->ar_gai_errno = EAI_SERVICE-8; |
188 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
189 | break; |
190 | } |
191 | |
192 | /* Restrict result set to configured address families */ |
193 | if (ai->ai_flags & AI_ADDRCONFIG64) { |
194 | if (addrconfig_setup(as) == -1) { |
195 | ar->ar_errno = errno(*__errno()); |
196 | ar->ar_gai_errno = EAI_SYSTEM-11; |
197 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
198 | break; |
199 | } |
200 | } |
201 | |
202 | /* Make sure there is at least a valid combination */ |
203 | for (i = 0; matches[i].family != -1; i++) |
204 | if (MATCH_FAMILY(ai->ai_family, i)((ai->ai_family) == matches[(i)].family || (ai->ai_family ) == 0) && |
205 | MATCH_SOCKTYPE(ai->ai_socktype, i)((ai->ai_socktype) == matches[(i)].socktype || ((ai->ai_socktype ) == 0 && matches[(i)].socktype != 3)) && |
206 | MATCH_PROTO(ai->ai_protocol, i)((ai->ai_protocol) == matches[(i)].protocol || (ai->ai_protocol ) == 0 || matches[(i)].protocol == 0)) |
207 | break; |
208 | if (matches[i].family == -1) { |
209 | ar->ar_gai_errno = EAI_BADHINTS-12; |
210 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
211 | break; |
212 | } |
213 | |
214 | if (ai->ai_protocol == 0 || ai->ai_protocol == IPPROTO_UDP17) |
215 | as->as.ai.port_udp = get_port(as->as.ai.servname, "udp", |
216 | as->as.ai.hints.ai_flags & AI_NUMERICSERV16); |
217 | if (ai->ai_protocol == 0 || ai->ai_protocol == IPPROTO_TCP6) |
218 | as->as.ai.port_tcp = get_port(as->as.ai.servname, "tcp", |
219 | as->as.ai.hints.ai_flags & AI_NUMERICSERV16); |
220 | if (as->as.ai.port_tcp == -2 || as->as.ai.port_udp == -2 || |
221 | (as->as.ai.port_tcp == -1 && as->as.ai.port_udp == -1) || |
222 | (ai->ai_protocol && (as->as.ai.port_udp == -1 || |
223 | as->as.ai.port_tcp == -1))) { |
224 | ar->ar_gai_errno = EAI_SERVICE-8; |
225 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
226 | break; |
227 | } |
228 | |
229 | ar->ar_gai_errno = 0; |
230 | |
231 | if (!(ai->ai_flags & AI_NUMERICHOST4)) |
232 | is_localhost = _asr_is_localhost(as->as.ai.hostname); |
233 | /* |
234 | * If hostname is NULL, "localhost" or falls within the |
235 | * ".localhost." domain, use local address. |
236 | * RFC 6761, 6.3: |
237 | * 3. Name resolution APIs and libraries SHOULD recognize |
238 | * localhost names as special and SHOULD always return the IP |
239 | * loopback address for address queries and negative responses |
240 | * for all other query types. Name resolution APIs SHOULD NOT |
241 | * send queries for localhost names to their configured caching |
242 | * DNS server(s). |
243 | */ |
244 | if (as->as.ai.hostname == NULL((void *)0) || is_localhost) { |
245 | for (family = iter_family(as, 1); |
246 | family != -1; |
247 | family = iter_family(as, 0)) { |
248 | /* |
249 | * We could use statically built sockaddrs for |
250 | * those, rather than parsing over and over. |
251 | */ |
252 | if (family == PF_INET2) |
253 | str = (ai->ai_flags & AI_PASSIVE1 && |
254 | !is_localhost) ? "0.0.0.0" : |
255 | "127.0.0.1"; |
256 | else /* PF_INET6 */ |
257 | str = (ai->ai_flags & AI_PASSIVE1 && |
258 | !is_localhost) ? "::" : "::1"; |
259 | /* This can't fail */ |
260 | _asr_sockaddr_from_str(&sa.sa, family, str); |
261 | if ((r = addrinfo_add(as, &sa.sa, NULL((void *)0)))) { |
262 | ar->ar_gai_errno = r; |
263 | break; |
264 | } |
265 | } |
266 | if (ar->ar_gai_errno == 0 && as->as_count == 0) { |
267 | ar->ar_gai_errno = EAI_NODATA-5; |
268 | } |
269 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
270 | break; |
271 | } |
272 | |
273 | /* Try numeric addresses first */ |
274 | for (family = iter_family(as, 1); |
275 | family != -1; |
276 | family = iter_family(as, 0)) { |
277 | |
278 | if (_asr_sockaddr_from_str(&sa.sa, family, |
279 | as->as.ai.hostname) == -1) |
280 | continue; |
281 | |
282 | if ((r = addrinfo_add(as, &sa.sa, NULL((void *)0)))) |
283 | ar->ar_gai_errno = r; |
284 | break; |
285 | } |
286 | if (ar->ar_gai_errno || as->as_count) { |
287 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
288 | break; |
289 | } |
290 | |
291 | if (ai->ai_flags & AI_NUMERICHOST4) { |
292 | ar->ar_gai_errno = EAI_NONAME-2; |
293 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
294 | break; |
295 | } |
296 | |
297 | /* make sure there are no funny characters in hostname */ |
298 | if (!hnok_lenient(as->as.ai.hostname)) { |
299 | ar->ar_gai_errno = EAI_FAIL-4; |
300 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
301 | break; |
302 | } |
303 | |
304 | async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0); |
305 | break; |
306 | |
307 | case ASR_STATE_NEXT_DB: |
308 | if (_asr_iter_db(as) == -1) { |
309 | async_set_state(as, ASR_STATE_NOT_FOUND)do { ; (as)->as_state = (ASR_STATE_NOT_FOUND); } while (0); |
310 | break; |
311 | } |
312 | as->as_family_idx = 0; |
313 | async_set_state(as, ASR_STATE_SAME_DB)do { ; (as)->as_state = (ASR_STATE_SAME_DB); } while (0); |
314 | break; |
315 | |
316 | case ASR_STATE_NEXT_FAMILY: |
317 | as->as_family_idx += 1; |
318 | if (as->as.ai.hints.ai_family != AF_UNSPEC0 || |
319 | AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]) == -1) { |
320 | /* The family was specified, or we have tried all |
321 | * families with this DB. |
322 | */ |
323 | if (as->as_count) { |
324 | ar->ar_gai_errno = 0; |
325 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
326 | } else |
327 | async_set_state(as, ASR_STATE_NEXT_DOMAIN)do { ; (as)->as_state = (ASR_STATE_NEXT_DOMAIN); } while ( 0); |
328 | break; |
329 | } |
330 | async_set_state(as, ASR_STATE_SAME_DB)do { ; (as)->as_state = (ASR_STATE_SAME_DB); } while (0); |
331 | break; |
332 | |
333 | case ASR_STATE_NEXT_DOMAIN: |
334 | /* domain search is only for dns */ |
335 | if (AS_DB(as)((as)->as_ctx->ac_db[(as)->as_db_idx - 1]) != ASR_DB_DNS'b') { |
336 | async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0); |
337 | break; |
338 | } |
339 | as->as_family_idx = 0; |
340 | |
341 | free(as->as.ai.fqdn); |
342 | as->as.ai.fqdn = NULL((void *)0); |
343 | r = _asr_iter_domain(as, as->as.ai.hostname, fqdn, sizeof(fqdn)); |
344 | if (r == -1) { |
345 | async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0); |
346 | break; |
347 | } |
348 | if (r == 0) { |
349 | ar->ar_gai_errno = EAI_FAIL-4; |
350 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
351 | break; |
352 | } |
353 | as->as.ai.fqdn = strdup(fqdn); |
354 | if (as->as.ai.fqdn == NULL((void *)0)) { |
355 | ar->ar_gai_errno = EAI_MEMORY-10; |
356 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
357 | break; |
358 | } |
359 | |
360 | async_set_state(as, ASR_STATE_SAME_DB)do { ; (as)->as_state = (ASR_STATE_SAME_DB); } while (0); |
361 | break; |
362 | |
363 | case ASR_STATE_SAME_DB: |
364 | /* query the current DB again */ |
365 | switch (AS_DB(as)((as)->as_ctx->ac_db[(as)->as_db_idx - 1])) { |
366 | case ASR_DB_DNS'b': |
367 | if (as->as.ai.fqdn == NULL((void *)0)) { |
368 | /* First try, initialize domain iteration */ |
369 | as->as_dom_flags = 0; |
370 | as->as_dom_step = DOM_INIT; |
371 | async_set_state(as, ASR_STATE_NEXT_DOMAIN)do { ; (as)->as_state = (ASR_STATE_NEXT_DOMAIN); } while ( 0); |
372 | break; |
373 | } |
374 | |
375 | family = (as->as.ai.hints.ai_family == AF_UNSPEC0) ? |
376 | AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]) : as->as.ai.hints.ai_family; |
377 | |
378 | if (family == AF_INET2 && |
379 | as->as_flags & ASYNC_NO_INET0x00010000) { |
380 | async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while ( 0); |
381 | break; |
382 | } else if (family == AF_INET624 && |
383 | as->as_flags & ASYNC_NO_INET60x00020000) { |
384 | async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while ( 0); |
385 | break; |
386 | } |
387 | |
388 | as->as_subq = _res_query_async_ctx(as->as.ai.fqdn, |
389 | C_IN1, (family == AF_INET624) ? T_AAAA28 : T_A1, |
390 | as->as_ctx); |
391 | |
392 | if (as->as_subq == NULL((void *)0)) { |
393 | if (errno(*__errno()) == ENOMEM12) |
394 | ar->ar_gai_errno = EAI_MEMORY-10; |
395 | else |
396 | ar->ar_gai_errno = EAI_FAIL-4; |
397 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
398 | break; |
399 | } |
400 | async_set_state(as, ASR_STATE_SUBQUERY)do { ; (as)->as_state = (ASR_STATE_SUBQUERY); } while (0); |
401 | break; |
402 | |
403 | case ASR_DB_FILE'f': |
404 | f = fopen(_PATH_HOSTS"/etc/hosts", "re"); |
405 | if (f == NULL((void *)0)) { |
406 | async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0); |
407 | break; |
408 | } |
409 | family = (as->as.ai.hints.ai_family == AF_UNSPEC0) ? |
410 | AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]) : as->as.ai.hints.ai_family; |
411 | |
412 | r = addrinfo_from_file(as, family, f); |
413 | if (r == -1) { |
414 | if (errno(*__errno()) == ENOMEM12) |
415 | ar->ar_gai_errno = EAI_MEMORY-10; |
416 | else |
417 | ar->ar_gai_errno = EAI_FAIL-4; |
418 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
419 | } else |
420 | async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while ( 0); |
421 | fclose(f); |
422 | break; |
423 | |
424 | default: |
425 | async_set_state(as, ASR_STATE_NEXT_DB)do { ; (as)->as_state = (ASR_STATE_NEXT_DB); } while (0); |
426 | } |
427 | break; |
428 | |
429 | case ASR_STATE_SUBQUERY: |
430 | if ((r = asr_run(as->as_subq, ar)) == ASYNC_COND0) |
Although the value stored to 'r' is used in the enclosing expression, the value is never actually read from 'r' | |
431 | return (ASYNC_COND0); |
432 | |
433 | as->as_subq = NULL((void *)0); |
434 | |
435 | if (ar->ar_datalen == -1) { |
436 | async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while ( 0); |
437 | break; |
438 | } |
439 | |
440 | r = addrinfo_from_pkt(as, ar->ar_data, ar->ar_datalen); |
441 | if (r == -1) { |
442 | if (errno(*__errno()) == ENOMEM12) |
443 | ar->ar_gai_errno = EAI_MEMORY-10; |
444 | else |
445 | ar->ar_gai_errno = EAI_FAIL-4; |
446 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
447 | } else |
448 | async_set_state(as, ASR_STATE_NEXT_FAMILY)do { ; (as)->as_state = (ASR_STATE_NEXT_FAMILY); } while ( 0); |
449 | free(ar->ar_data); |
450 | break; |
451 | |
452 | case ASR_STATE_NOT_FOUND: |
453 | /* No result found. Maybe we can try again. */ |
454 | if (as->as_flags & ASYNC_AGAIN0x00000200) |
455 | ar->ar_gai_errno = EAI_AGAIN-3; |
456 | else |
457 | ar->ar_gai_errno = EAI_NODATA-5; |
458 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
459 | break; |
460 | |
461 | case ASR_STATE_HALT: |
462 | if (ar->ar_gai_errno == 0) { |
463 | ar->ar_count = as->as_count; |
464 | ar->ar_addrinfo = as->as.ai.aifirst; |
465 | as->as.ai.aifirst = NULL((void *)0); |
466 | } else { |
467 | ar->ar_count = 0; |
468 | ar->ar_addrinfo = NULL((void *)0); |
469 | } |
470 | return (ASYNC_DONE1); |
471 | |
472 | default: |
473 | ar->ar_errno = EOPNOTSUPP45; |
474 | ar->ar_gai_errno = EAI_SYSTEM-11; |
475 | async_set_state(as, ASR_STATE_HALT)do { ; (as)->as_state = (ASR_STATE_HALT); } while (0); |
476 | break; |
477 | } |
478 | goto next; |
479 | } |
480 | |
481 | /* |
482 | * Retrieve the port number for the service name "servname" and |
483 | * the protocol "proto". |
484 | */ |
485 | static int |
486 | get_port(const char *servname, const char *proto, int numonly) |
487 | { |
488 | struct servent se; |
489 | struct servent_data sed; |
490 | int port; |
491 | const char *e; |
492 | |
493 | if (servname == NULL((void *)0)) |
494 | return (0); |
495 | |
496 | e = NULL((void *)0); |
497 | port = strtonum(servname, 0, USHRT_MAX0xffff, &e); |
498 | if (e == NULL((void *)0)) |
499 | return (port); |
500 | if (errno(*__errno()) == ERANGE34) |
501 | return (-2); /* invalid */ |
502 | if (numonly) |
503 | return (-2); |
504 | |
505 | port = -1; |
506 | memset(&sed, 0, sizeof(sed)); |
507 | if (getservbyname_r(servname, proto, &se, &sed) != -1) |
508 | port = ntohs(se.s_port)(__uint16_t)(__builtin_constant_p(se.s_port) ? (__uint16_t)(( (__uint16_t)(se.s_port) & 0xffU) << 8 | ((__uint16_t )(se.s_port) & 0xff00U) >> 8) : __swap16md(se.s_port )); |
509 | endservent_r(&sed); |
510 | |
511 | return (port); |
512 | } |
513 | |
514 | /* |
515 | * Iterate over the address families that are to be queried. Use the |
516 | * list on the async context, unless a specific family was given in hints. |
517 | */ |
518 | static int |
519 | iter_family(struct asr_query *as, int first) |
520 | { |
521 | if (first) { |
522 | as->as_family_idx = 0; |
523 | if (as->as.ai.hints.ai_family != PF_UNSPEC0) |
524 | return as->as.ai.hints.ai_family; |
525 | return AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]); |
526 | } |
527 | |
528 | if (as->as.ai.hints.ai_family != PF_UNSPEC0) |
529 | return (-1); |
530 | |
531 | as->as_family_idx++; |
532 | |
533 | return AS_FAMILY(as)((as)->as_ctx->ac_family[(as)->as_family_idx]); |
534 | } |
535 | |
536 | /* |
537 | * Use the sockaddr at "sa" to extend the result list on the "as" context, |
538 | * with the specified canonical name "cname". This function adds one |
539 | * entry per protocol/socktype match. |
540 | */ |
541 | static int |
542 | addrinfo_add(struct asr_query *as, const struct sockaddr *sa, const char *cname) |
543 | { |
544 | struct addrinfo *ai; |
545 | int i, port, proto; |
546 | |
547 | for (i = 0; matches[i].family != -1; i++) { |
548 | if (matches[i].family != sa->sa_family || |
549 | !MATCH_SOCKTYPE(as->as.ai.hints.ai_socktype, i)((as->as.ai.hints.ai_socktype) == matches[(i)].socktype || ((as->as.ai.hints.ai_socktype) == 0 && matches[(i )].socktype != 3)) || |
550 | !MATCH_PROTO(as->as.ai.hints.ai_protocol, i)((as->as.ai.hints.ai_protocol) == matches[(i)].protocol || (as->as.ai.hints.ai_protocol) == 0 || matches[(i)].protocol == 0)) |
551 | continue; |
552 | |
553 | proto = as->as.ai.hints.ai_protocol; |
554 | if (!proto) |
555 | proto = matches[i].protocol; |
556 | |
557 | if (proto == IPPROTO_TCP6) |
558 | port = as->as.ai.port_tcp; |
559 | else if (proto == IPPROTO_UDP17) |
560 | port = as->as.ai.port_udp; |
561 | else |
562 | port = 0; |
563 | |
564 | /* servname specified, but not defined for this protocol */ |
565 | if (port == -1) |
566 | continue; |
567 | |
568 | ai = calloc(1, sizeof(*ai) + sa->sa_len); |
569 | if (ai == NULL((void *)0)) |
570 | return (EAI_MEMORY-10); |
571 | ai->ai_family = sa->sa_family; |
572 | ai->ai_socktype = matches[i].socktype; |
573 | ai->ai_protocol = proto; |
574 | ai->ai_flags = as->as.ai.hints.ai_flags; |
575 | ai->ai_addrlen = sa->sa_len; |
576 | ai->ai_addr = (void *)(ai + 1); |
577 | if (cname && |
578 | as->as.ai.hints.ai_flags & (AI_CANONNAME2 | AI_FQDN32)) { |
579 | if ((ai->ai_canonname = strdup(cname)) == NULL((void *)0)) { |
580 | free(ai); |
581 | return (EAI_MEMORY-10); |
582 | } |
583 | } |
584 | memmove(ai->ai_addr, sa, sa->sa_len); |
585 | if (sa->sa_family == PF_INET2) |
586 | ((struct sockaddr_in *)ai->ai_addr)->sin_port = |
587 | htons(port)(__uint16_t)(__builtin_constant_p(port) ? (__uint16_t)(((__uint16_t )(port) & 0xffU) << 8 | ((__uint16_t)(port) & 0xff00U ) >> 8) : __swap16md(port)); |
588 | else if (sa->sa_family == PF_INET624) |
589 | ((struct sockaddr_in6 *)ai->ai_addr)->sin6_port = |
590 | htons(port)(__uint16_t)(__builtin_constant_p(port) ? (__uint16_t)(((__uint16_t )(port) & 0xffU) << 8 | ((__uint16_t)(port) & 0xff00U ) >> 8) : __swap16md(port)); |
591 | |
592 | if (as->as.ai.aifirst == NULL((void *)0)) |
593 | as->as.ai.aifirst = ai; |
594 | if (as->as.ai.ailast) |
595 | as->as.ai.ailast->ai_next = ai; |
596 | as->as.ai.ailast = ai; |
597 | as->as_count += 1; |
598 | } |
599 | |
600 | return (0); |
601 | } |
602 | |
603 | static int |
604 | addrinfo_from_file(struct asr_query *as, int family, FILE *f) |
605 | { |
606 | char *tokens[MAXTOKEN10], *c, buf[BUFSIZ1024 + 1]; |
607 | int n, i; |
608 | union { |
609 | struct sockaddr sa; |
610 | struct sockaddr_in sain; |
611 | struct sockaddr_in6 sain6; |
612 | } u; |
613 | |
614 | for (;;) { |
615 | n = _asr_parse_namedb_line(f, tokens, MAXTOKEN10, buf, sizeof(buf)); |
616 | if (n == -1) |
617 | break; /* ignore errors reading the file */ |
618 | |
619 | for (i = 1; i < n; i++) { |
620 | if (strcasecmp(as->as.ai.hostname, tokens[i])) |
621 | continue; |
622 | if (_asr_sockaddr_from_str(&u.sa, family, tokens[0]) == -1) |
623 | continue; |
624 | break; |
625 | } |
626 | if (i == n) |
627 | continue; |
628 | |
629 | if (as->as.ai.hints.ai_flags & (AI_CANONNAME2 | AI_FQDN32)) |
630 | c = tokens[1]; |
631 | else |
632 | c = NULL((void *)0); |
633 | |
634 | if (addrinfo_add(as, &u.sa, c)) |
635 | return (-1); /* errno set */ |
636 | } |
637 | return (0); |
638 | } |
639 | |
640 | static int |
641 | addrinfo_from_pkt(struct asr_query *as, char *pkt, size_t pktlen) |
642 | { |
643 | struct asr_unpack p; |
644 | struct asr_dns_header h; |
645 | struct asr_dns_query q; |
646 | struct asr_dns_rr rr; |
647 | int i; |
648 | union { |
649 | struct sockaddr sa; |
650 | struct sockaddr_in sain; |
651 | struct sockaddr_in6 sain6; |
652 | } u; |
653 | char buf[MAXDNAME1025], *c; |
654 | |
655 | _asr_unpack_init(&p, pkt, pktlen); |
656 | _asr_unpack_header(&p, &h); |
657 | for (; h.qdcount; h.qdcount--) |
658 | _asr_unpack_query(&p, &q); |
659 | |
660 | for (i = 0; i < h.ancount; i++) { |
661 | _asr_unpack_rr(&p, &rr); |
662 | if (rr.rr_type != q.q_type || |
663 | rr.rr_class != q.q_class) |
664 | continue; |
665 | |
666 | memset(&u, 0, sizeof u); |
667 | if (rr.rr_type == T_A1) { |
668 | u.sain.sin_len = sizeof u.sain; |
669 | u.sain.sin_family = AF_INET2; |
670 | u.sain.sin_addr = rr.rr.in_a.addr; |
671 | u.sain.sin_port = 0; |
672 | } else if (rr.rr_type == T_AAAA28) { |
673 | u.sain6.sin6_len = sizeof u.sain6; |
674 | u.sain6.sin6_family = AF_INET624; |
675 | u.sain6.sin6_addr = rr.rr.in_aaaa.addr6; |
676 | u.sain6.sin6_port = 0; |
677 | } else |
678 | continue; |
679 | |
680 | if (as->as.ai.hints.ai_flags & AI_CANONNAME2) { |
681 | _asr_strdname(rr.rr_dname, buf, sizeof buf); |
682 | buf[strlen(buf) - 1] = '\0'; |
683 | c = res_hnok__res_hnok(buf) ? buf : NULL((void *)0); |
684 | } else if (as->as.ai.hints.ai_flags & AI_FQDN32) |
685 | c = as->as.ai.fqdn; |
686 | else |
687 | c = NULL((void *)0); |
688 | |
689 | if (addrinfo_add(as, &u.sa, c)) |
690 | return (-1); /* errno set */ |
691 | } |
692 | return (0); |
693 | } |
694 | |
695 | static int |
696 | addrconfig_setup(struct asr_query *as) |
697 | { |
698 | struct ifaddrs *ifa, *ifa0; |
699 | struct if_data *ifa_data; |
700 | struct sockaddr_in *sinp; |
701 | struct sockaddr_in6 *sin6p; |
702 | int rtable, ifa_rtable = -1; |
703 | |
704 | if (getifaddrs(&ifa0) == -1) |
705 | return (-1); |
706 | |
707 | rtable = getrtable(); |
708 | |
709 | as->as_flags |= ASYNC_NO_INET0x00010000 | ASYNC_NO_INET60x00020000; |
710 | |
711 | for (ifa = ifa0; ifa != NULL((void *)0); ifa = ifa->ifa_next) { |
712 | if (ifa->ifa_addr == NULL((void *)0)) |
713 | continue; |
714 | |
715 | switch (ifa->ifa_addr->sa_family) { |
716 | case PF_LINK18: |
717 | /* AF_LINK comes before inet / inet6 on an interface */ |
718 | ifa_data = (struct if_data *)ifa->ifa_data; |
719 | ifa_rtable = ifa_data->ifi_rdomain; |
720 | break; |
721 | case PF_INET2: |
722 | if (ifa_rtable != rtable) |
723 | continue; |
724 | |
725 | sinp = (struct sockaddr_in *)ifa->ifa_addr; |
726 | |
727 | if (sinp->sin_addr.s_addr == htonl(INADDR_LOOPBACK)(__uint32_t)(__builtin_constant_p(((u_int32_t)(0x7f000001))) ? (__uint32_t)(((__uint32_t)(((u_int32_t)(0x7f000001))) & 0xff ) << 24 | ((__uint32_t)(((u_int32_t)(0x7f000001))) & 0xff00) << 8 | ((__uint32_t)(((u_int32_t)(0x7f000001)) ) & 0xff0000) >> 8 | ((__uint32_t)(((u_int32_t)(0x7f000001 ))) & 0xff000000) >> 24) : __swap32md(((u_int32_t)( 0x7f000001))))) |
728 | continue; |
729 | |
730 | as->as_flags &= ~ASYNC_NO_INET0x00010000; |
731 | break; |
732 | case PF_INET624: |
733 | if (ifa_rtable != rtable) |
734 | continue; |
735 | |
736 | sin6p = (struct sockaddr_in6 *)ifa->ifa_addr; |
737 | |
738 | if (IN6_IS_ADDR_LOOPBACK(&sin6p->sin6_addr)((*(const u_int32_t *)(const void *)(&(&sin6p->sin6_addr )->__u6_addr.__u6_addr8[0]) == 0) && (*(const u_int32_t *)(const void *)(&(&sin6p->sin6_addr)->__u6_addr .__u6_addr8[4]) == 0) && (*(const u_int32_t *)(const void *)(&(&sin6p->sin6_addr)->__u6_addr.__u6_addr8[ 8]) == 0) && (*(const u_int32_t *)(const void *)(& (&sin6p->sin6_addr)->__u6_addr.__u6_addr8[12]) == ( __uint32_t)(__builtin_constant_p(1) ? (__uint32_t)(((__uint32_t )(1) & 0xff) << 24 | ((__uint32_t)(1) & 0xff00) << 8 | ((__uint32_t)(1) & 0xff0000) >> 8 | ( (__uint32_t)(1) & 0xff000000) >> 24) : __swap32md(1 ))))) |
739 | continue; |
740 | |
741 | if (IN6_IS_ADDR_LINKLOCAL(&sin6p->sin6_addr)(((&sin6p->sin6_addr)->__u6_addr.__u6_addr8[0] == 0xfe ) && (((&sin6p->sin6_addr)->__u6_addr.__u6_addr8 [1] & 0xc0) == 0x80))) |
742 | continue; |
743 | |
744 | as->as_flags &= ~ASYNC_NO_INET60x00020000; |
745 | break; |
746 | } |
747 | } |
748 | |
749 | freeifaddrs(ifa0); |
750 | |
751 | return (0); |
752 | } |