1 | /* Resolver state initialization and resolv.conf parsing. |
2 | Copyright (C) 1995-2020 Free Software Foundation, Inc. |
3 | This file is part of the GNU C Library. |
4 | |
5 | The GNU C Library is free software; you can redistribute it and/or |
6 | modify it under the terms of the GNU Lesser General Public |
7 | License as published by the Free Software Foundation; either |
8 | version 2.1 of the License, or (at your option) any later version. |
9 | |
10 | The GNU C Library is distributed in the hope that it will be useful, |
11 | but WITHOUT ANY WARRANTY; without even the implied warranty of |
12 | MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
13 | Lesser General Public License for more details. |
14 | |
15 | You should have received a copy of the GNU Lesser General Public |
16 | License along with the GNU C Library; if not, see |
17 | <https://www.gnu.org/licenses/>. */ |
18 | |
19 | /* |
20 | * Copyright (c) 1985, 1989, 1993 |
21 | * The Regents of the University of California. All rights reserved. |
22 | * |
23 | * Redistribution and use in source and binary forms, with or without |
24 | * modification, are permitted provided that the following conditions |
25 | * are met: |
26 | * 1. Redistributions of source code must retain the above copyright |
27 | * notice, this list of conditions and the following disclaimer. |
28 | * 2. Redistributions in binary form must reproduce the above copyright |
29 | * notice, this list of conditions and the following disclaimer in the |
30 | * documentation and/or other materials provided with the distribution. |
31 | * 4. Neither the name of the University nor the names of its contributors |
32 | * may be used to endorse or promote products derived from this software |
33 | * without specific prior written permission. |
34 | * |
35 | * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND |
36 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
37 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
38 | * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE |
39 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
40 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
41 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
42 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
43 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
44 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
45 | * SUCH DAMAGE. |
46 | */ |
47 | |
48 | /* |
49 | * Portions Copyright (c) 1993 by Digital Equipment Corporation. |
50 | * |
51 | * Permission to use, copy, modify, and distribute this software for any |
52 | * purpose with or without fee is hereby granted, provided that the above |
53 | * copyright notice and this permission notice appear in all copies, and that |
54 | * the name of Digital Equipment Corporation not be used in advertising or |
55 | * publicity pertaining to distribution of the document or software without |
56 | * specific, written prior permission. |
57 | * |
58 | * THE SOFTWARE IS PROVIDED "AS IS" AND DIGITAL EQUIPMENT CORP. DISCLAIMS ALL |
59 | * WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES |
60 | * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL DIGITAL EQUIPMENT |
61 | * CORPORATION BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
62 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
63 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS |
64 | * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
65 | * SOFTWARE. |
66 | */ |
67 | |
68 | /* |
69 | * Portions Copyright (c) 1996-1999 by Internet Software Consortium. |
70 | * |
71 | * Permission to use, copy, modify, and distribute this software for any |
72 | * purpose with or without fee is hereby granted, provided that the above |
73 | * copyright notice and this permission notice appear in all copies. |
74 | * |
75 | * THE SOFTWARE IS PROVIDED "AS IS" AND INTERNET SOFTWARE CONSORTIUM DISCLAIMS |
76 | * ALL WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES |
77 | * OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL INTERNET SOFTWARE |
78 | * CONSORTIUM BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL |
79 | * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR |
80 | * PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS |
81 | * ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS |
82 | * SOFTWARE. |
83 | */ |
84 | |
85 | #include <ctype.h> |
86 | #include <netdb.h> |
87 | #include <resolv/resolv-internal.h> |
88 | #include <res_hconf.h> |
89 | #include <stdio.h> |
90 | #include <stdio_ext.h> |
91 | #include <stdlib.h> |
92 | #include <string.h> |
93 | #include <unistd.h> |
94 | #include <stdint.h> |
95 | #include <arpa/inet.h> |
96 | #include <arpa/nameser.h> |
97 | #include <net/if.h> |
98 | #include <netinet/in.h> |
99 | #include <sys/param.h> |
100 | #include <sys/socket.h> |
101 | #include <sys/time.h> |
102 | #include <sys/types.h> |
103 | #include <inet/net-internal.h> |
104 | #include <errno.h> |
105 | #include <resolv_conf.h> |
106 | |
107 | static uint32_t net_mask (struct in_addr); |
108 | |
109 | int |
110 | res_ninit (res_state statp) |
111 | { |
112 | return __res_vinit (statp, 0); |
113 | } |
114 | libc_hidden_def (__res_ninit) |
115 | |
116 | /* Return true if CH separates the netmask in the "sortlist" |
117 | directive. */ |
118 | static inline bool |
119 | is_sort_mask (char ch) |
120 | { |
121 | return ch == '/' || ch == '&'; |
122 | } |
123 | |
124 | /* Array of name server addresses. */ |
125 | #define DYNARRAY_STRUCT nameserver_list |
126 | #define DYNARRAY_ELEMENT const struct sockaddr * |
127 | #define DYNARRAY_ELEMENT_FREE(e) free ((struct sockaddr *) *(e)) |
128 | #define DYNARRAY_INITIAL_SIZE 3 |
129 | #define DYNARRAY_PREFIX nameserver_list_ |
130 | #include <malloc/dynarray-skeleton.c> |
131 | |
132 | /* Array of strings for the search array. The backing store is |
133 | managed separately. */ |
134 | #define DYNARRAY_STRUCT search_list |
135 | #define DYNARRAY_ELEMENT const char * |
136 | #define DYNARRAY_INITIAL_SIZE 6 |
137 | #define DYNARRAY_PREFIX search_list_ |
138 | #include <malloc/dynarray-skeleton.c> |
139 | |
140 | /* Array of name server addresses. */ |
141 | #define DYNARRAY_STRUCT sort_list |
142 | #define DYNARRAY_ELEMENT struct resolv_sortlist_entry |
143 | #define DYNARRAY_INITIAL_SIZE 0 |
144 | #define DYNARRAY_PREFIX sort_list_ |
145 | #include <malloc/dynarray-skeleton.c> |
146 | |
147 | /* resolv.conf parser state and results. */ |
148 | struct resolv_conf_parser |
149 | { |
150 | char *buffer; /* Temporary buffer for reading lines. */ |
151 | |
152 | struct nameserver_list nameserver_list; /* Nameserver addresses. */ |
153 | |
154 | char *search_list_store; /* Backing storage for search list entries. */ |
155 | struct search_list search_list; /* Points into search_list_store. */ |
156 | |
157 | struct sort_list sort_list; /* Address preference sorting list. */ |
158 | |
159 | /* Configuration template. The non-array elements are filled in |
160 | directly. The array elements are updated prior to the call to |
161 | __resolv_conf_attach. */ |
162 | struct resolv_conf template; |
163 | }; |
164 | |
165 | /* Return true if *PREINIT contains actual preinitialization. */ |
166 | static bool |
167 | has_preinit_values (const struct __res_state *preinit) |
168 | { |
169 | return (preinit->retrans != 0 && preinit->retrans != RES_TIMEOUT) |
170 | || (preinit->retry != 0 && preinit->retry != RES_DFLRETRY) |
171 | || (preinit->options != 0 |
172 | && (preinit->options & ~RES_INIT) != RES_DEFAULT); |
173 | } |
174 | |
175 | static void |
176 | resolv_conf_parser_init (struct resolv_conf_parser *parser, |
177 | const struct __res_state *preinit) |
178 | { |
179 | parser->buffer = NULL; |
180 | parser->search_list_store = NULL; |
181 | nameserver_list_init (&parser->nameserver_list); |
182 | search_list_init (&parser->search_list); |
183 | sort_list_init (&parser->sort_list); |
184 | |
185 | if (preinit != NULL) |
186 | { |
187 | parser->template.retrans = preinit->retrans; |
188 | parser->template.retry = preinit->retry; |
189 | parser->template.options = preinit->options | RES_INIT; |
190 | } |
191 | else |
192 | { |
193 | parser->template.retrans = RES_TIMEOUT; |
194 | parser->template.retry = RES_DFLRETRY; |
195 | parser->template.options = RES_DEFAULT | RES_INIT; |
196 | } |
197 | parser->template.ndots = 1; |
198 | } |
199 | |
200 | static void |
201 | resolv_conf_parser_free (struct resolv_conf_parser *parser) |
202 | { |
203 | free (parser->buffer); |
204 | free (parser->search_list_store); |
205 | nameserver_list_free (&parser->nameserver_list); |
206 | search_list_free (&parser->search_list); |
207 | sort_list_free (&parser->sort_list); |
208 | } |
209 | |
210 | /* Allocate a struct sockaddr_in object on the heap, with the |
211 | specified address and port. */ |
212 | static struct sockaddr * |
213 | allocate_address_v4 (struct in_addr a, uint16_t port) |
214 | { |
215 | struct sockaddr_in *sa4 = malloc (sizeof (*sa4)); |
216 | if (sa4 == NULL) |
217 | return NULL; |
218 | sa4->sin_family = AF_INET; |
219 | sa4->sin_addr = a; |
220 | sa4->sin_port = htons (port); |
221 | return (struct sockaddr *) sa4; |
222 | } |
223 | |
224 | /* Try to obtain the domain name from the host name and store it in |
225 | *RESULT. Return false on memory allocation failure. If the domain |
226 | name cannot be determined for any other reason, write NULL to |
227 | *RESULT and return true. */ |
228 | static bool |
229 | domain_from_hostname (char **result) |
230 | { |
231 | char buf[256]; |
232 | /* gethostbyname may not terminate the buffer. */ |
233 | buf[sizeof (buf) - 1] = '\0'; |
234 | if (__gethostname (buf, sizeof (buf) - 1) == 0) |
235 | { |
236 | char *dot = strchr (buf, '.'); |
237 | if (dot != NULL) |
238 | { |
239 | *result = __strdup (dot + 1); |
240 | if (*result == NULL) |
241 | return false; |
242 | return true; |
243 | } |
244 | } |
245 | *result = NULL; |
246 | return true; |
247 | } |
248 | |
249 | static void res_setoptions (struct resolv_conf_parser *, const char *options); |
250 | |
251 | /* Internal helper function for __res_vinit, to aid with resource |
252 | deallocation and error handling. Return true on success, false on |
253 | failure. */ |
254 | static bool |
255 | res_vinit_1 (FILE *fp, struct resolv_conf_parser *parser) |
256 | { |
257 | char *cp; |
258 | size_t buffer_size = 0; |
259 | bool haveenv = false; |
260 | |
261 | /* Allow user to override the local domain definition. */ |
262 | if ((cp = getenv ("LOCALDOMAIN" )) != NULL) |
263 | { |
264 | /* The code below splits the string in place. */ |
265 | cp = __strdup (cp); |
266 | if (cp == NULL) |
267 | return false; |
268 | free (parser->search_list_store); |
269 | parser->search_list_store = cp; |
270 | haveenv = true; |
271 | |
272 | /* The string will be truncated as needed below. */ |
273 | search_list_add (&parser->search_list, cp); |
274 | |
275 | /* Set search list to be blank-separated strings from rest of |
276 | env value. Permits users of LOCALDOMAIN to still have a |
277 | search list, and anyone to set the one that they want to use |
278 | as an individual (even more important now that the rfc1535 |
279 | stuff restricts searches). */ |
280 | for (bool in_name = true; *cp != '\0'; cp++) |
281 | { |
282 | if (*cp == '\n') |
283 | { |
284 | *cp = '\0'; |
285 | break; |
286 | } |
287 | else if (*cp == ' ' || *cp == '\t') |
288 | { |
289 | *cp = '\0'; |
290 | in_name = false; |
291 | } |
292 | else if (!in_name) |
293 | { |
294 | search_list_add (&parser->search_list, cp); |
295 | in_name = true; |
296 | } |
297 | } |
298 | } |
299 | |
300 | #define MATCH(line, name) \ |
301 | (!strncmp ((line), name, sizeof (name) - 1) \ |
302 | && ((line)[sizeof (name) - 1] == ' ' \ |
303 | || (line)[sizeof (name) - 1] == '\t')) |
304 | |
305 | if (fp != NULL) |
306 | { |
307 | /* No threads use this stream. */ |
308 | __fsetlocking (fp, FSETLOCKING_BYCALLER); |
309 | /* Read the config file. */ |
310 | while (true) |
311 | { |
312 | { |
313 | ssize_t ret = __getline (&parser->buffer, &buffer_size, fp); |
314 | if (ret <= 0) |
315 | { |
316 | if (_IO_ferror_unlocked (fp)) |
317 | return false; |
318 | else |
319 | break; |
320 | } |
321 | } |
322 | |
323 | /* Skip comments. */ |
324 | if (*parser->buffer == ';' || *parser->buffer == '#') |
325 | continue; |
326 | /* Read default domain name. */ |
327 | if (MATCH (parser->buffer, "domain" )) |
328 | { |
329 | if (haveenv) |
330 | /* LOCALDOMAIN overrides the configuration file. */ |
331 | continue; |
332 | cp = parser->buffer + sizeof ("domain" ) - 1; |
333 | while (*cp == ' ' || *cp == '\t') |
334 | cp++; |
335 | if ((*cp == '\0') || (*cp == '\n')) |
336 | continue; |
337 | |
338 | cp = __strdup (cp); |
339 | if (cp == NULL) |
340 | return false; |
341 | free (parser->search_list_store); |
342 | parser->search_list_store = cp; |
343 | search_list_clear (&parser->search_list); |
344 | search_list_add (&parser->search_list, cp); |
345 | /* Replace trailing whitespace. */ |
346 | if ((cp = strpbrk (cp, " \t\n" )) != NULL) |
347 | *cp = '\0'; |
348 | continue; |
349 | } |
350 | /* Set search list. */ |
351 | if (MATCH (parser->buffer, "search" )) |
352 | { |
353 | if (haveenv) |
354 | /* LOCALDOMAIN overrides the configuration file. */ |
355 | continue; |
356 | cp = parser->buffer + sizeof ("search" ) - 1; |
357 | while (*cp == ' ' || *cp == '\t') |
358 | cp++; |
359 | if ((*cp == '\0') || (*cp == '\n')) |
360 | continue; |
361 | |
362 | { |
363 | char *p = strchr (cp, '\n'); |
364 | if (p != NULL) |
365 | *p = '\0'; |
366 | } |
367 | cp = __strdup (cp); |
368 | if (cp == NULL) |
369 | return false; |
370 | free (parser->search_list_store); |
371 | parser->search_list_store = cp; |
372 | |
373 | /* The string is truncated below. */ |
374 | search_list_clear (&parser->search_list); |
375 | search_list_add (&parser->search_list, cp); |
376 | |
377 | /* Set search list to be blank-separated strings on rest |
378 | of line. */ |
379 | for (bool in_name = true; *cp != '\0'; cp++) |
380 | { |
381 | if (*cp == ' ' || *cp == '\t') |
382 | { |
383 | *cp = '\0'; |
384 | in_name = false; |
385 | } |
386 | else if (!in_name) |
387 | { |
388 | search_list_add (&parser->search_list, cp); |
389 | in_name = true; |
390 | } |
391 | } |
392 | continue; |
393 | } |
394 | /* Read nameservers to query. */ |
395 | if (MATCH (parser->buffer, "nameserver" )) |
396 | { |
397 | struct in_addr a; |
398 | |
399 | cp = parser->buffer + sizeof ("nameserver" ) - 1; |
400 | while (*cp == ' ' || *cp == '\t') |
401 | cp++; |
402 | |
403 | /* Ignore trailing contents on the name server line. */ |
404 | { |
405 | char *el; |
406 | if ((el = strpbrk (cp, " \t\n" )) != NULL) |
407 | *el = '\0'; |
408 | } |
409 | |
410 | struct sockaddr *sa; |
411 | if ((*cp != '\0') && (*cp != '\n') && __inet_aton_exact (cp, &a)) |
412 | { |
413 | sa = allocate_address_v4 (a, NAMESERVER_PORT); |
414 | if (sa == NULL) |
415 | return false; |
416 | } |
417 | else |
418 | { |
419 | struct in6_addr a6; |
420 | char *el; |
421 | if ((el = strchr (cp, SCOPE_DELIMITER)) != NULL) |
422 | *el = '\0'; |
423 | if ((*cp != '\0') && (__inet_pton (AF_INET6, cp, &a6) > 0)) |
424 | { |
425 | struct sockaddr_in6 *sa6; |
426 | |
427 | sa6 = malloc (sizeof (*sa6)); |
428 | if (sa6 == NULL) |
429 | return false; |
430 | |
431 | sa6->sin6_family = AF_INET6; |
432 | sa6->sin6_port = htons (NAMESERVER_PORT); |
433 | sa6->sin6_flowinfo = 0; |
434 | sa6->sin6_addr = a6; |
435 | |
436 | sa6->sin6_scope_id = 0; |
437 | if (__glibc_likely (el != NULL)) |
438 | /* Ignore errors, for backwards |
439 | compatibility. */ |
440 | __inet6_scopeid_pton |
441 | (&a6, el + 1, &sa6->sin6_scope_id); |
442 | sa = (struct sockaddr *) sa6; |
443 | } |
444 | else |
445 | /* IPv6 address parse failure. */ |
446 | sa = NULL; |
447 | } |
448 | if (sa != NULL) |
449 | { |
450 | const struct sockaddr **p = nameserver_list_emplace |
451 | (&parser->nameserver_list); |
452 | if (p != NULL) |
453 | *p = sa; |
454 | else |
455 | { |
456 | free (sa); |
457 | return false; |
458 | } |
459 | } |
460 | continue; |
461 | } |
462 | if (MATCH (parser->buffer, "sortlist" )) |
463 | { |
464 | struct in_addr a; |
465 | |
466 | cp = parser->buffer + sizeof ("sortlist" ) - 1; |
467 | while (true) |
468 | { |
469 | while (*cp == ' ' || *cp == '\t') |
470 | cp++; |
471 | if (*cp == '\0' || *cp == '\n' || *cp == ';') |
472 | break; |
473 | char *net = cp; |
474 | while (*cp && !is_sort_mask (*cp) && *cp != ';' |
475 | && isascii (*cp) && !isspace (*cp)) |
476 | cp++; |
477 | char separator = *cp; |
478 | *cp = 0; |
479 | struct resolv_sortlist_entry e; |
480 | if (__inet_aton_exact (net, &a)) |
481 | { |
482 | e.addr = a; |
483 | if (is_sort_mask (separator)) |
484 | { |
485 | *cp++ = separator; |
486 | net = cp; |
487 | while (*cp && *cp != ';' |
488 | && isascii (*cp) && !isspace (*cp)) |
489 | cp++; |
490 | separator = *cp; |
491 | *cp = 0; |
492 | if (__inet_aton_exact (net, &a)) |
493 | e.mask = a.s_addr; |
494 | else |
495 | e.mask = net_mask (e.addr); |
496 | } |
497 | else |
498 | e.mask = net_mask (e.addr); |
499 | sort_list_add (&parser->sort_list, e); |
500 | } |
501 | *cp = separator; |
502 | } |
503 | continue; |
504 | } |
505 | if (MATCH (parser->buffer, "options" )) |
506 | { |
507 | res_setoptions (parser, parser->buffer + sizeof ("options" ) - 1); |
508 | continue; |
509 | } |
510 | } |
511 | fclose (fp); |
512 | } |
513 | if (__glibc_unlikely (nameserver_list_size (&parser->nameserver_list) == 0)) |
514 | { |
515 | const struct sockaddr **p |
516 | = nameserver_list_emplace (&parser->nameserver_list); |
517 | if (p == NULL) |
518 | return false; |
519 | *p = allocate_address_v4 (__inet_makeaddr (IN_LOOPBACKNET, 1), |
520 | NAMESERVER_PORT); |
521 | if (*p == NULL) |
522 | return false; |
523 | } |
524 | |
525 | if (search_list_size (&parser->search_list) == 0) |
526 | { |
527 | char *domain; |
528 | if (!domain_from_hostname (&domain)) |
529 | return false; |
530 | if (domain != NULL) |
531 | { |
532 | free (parser->search_list_store); |
533 | parser->search_list_store = domain; |
534 | search_list_add (&parser->search_list, domain); |
535 | } |
536 | } |
537 | |
538 | if ((cp = getenv ("RES_OPTIONS" )) != NULL) |
539 | res_setoptions (parser, cp); |
540 | |
541 | if (nameserver_list_has_failed (&parser->nameserver_list) |
542 | || search_list_has_failed (&parser->search_list) |
543 | || sort_list_has_failed (&parser->sort_list)) |
544 | { |
545 | __set_errno (ENOMEM); |
546 | return false; |
547 | } |
548 | |
549 | return true; |
550 | } |
551 | |
552 | struct resolv_conf * |
553 | __resolv_conf_load (struct __res_state *preinit) |
554 | { |
555 | /* Ensure that /etc/hosts.conf has been loaded (once). */ |
556 | _res_hconf_init (); |
557 | |
558 | FILE *fp = fopen (_PATH_RESCONF, "rce" ); |
559 | if (fp == NULL) |
560 | switch (errno) |
561 | { |
562 | case EACCES: |
563 | case EISDIR: |
564 | case ELOOP: |
565 | case ENOENT: |
566 | case ENOTDIR: |
567 | case EPERM: |
568 | /* Ignore these errors. They are persistent errors caused |
569 | by file system contents. */ |
570 | break; |
571 | default: |
572 | /* Other errors refer to resource allocation problems and |
573 | need to be handled by the application. */ |
574 | return NULL; |
575 | } |
576 | |
577 | struct resolv_conf_parser parser; |
578 | resolv_conf_parser_init (&parser, preinit); |
579 | |
580 | struct resolv_conf *conf = NULL; |
581 | if (res_vinit_1 (fp, &parser)) |
582 | { |
583 | parser.template.nameserver_list |
584 | = nameserver_list_begin (&parser.nameserver_list); |
585 | parser.template.nameserver_list_size |
586 | = nameserver_list_size (&parser.nameserver_list); |
587 | parser.template.search_list = search_list_begin (&parser.search_list); |
588 | parser.template.search_list_size |
589 | = search_list_size (&parser.search_list); |
590 | parser.template.sort_list = sort_list_begin (&parser.sort_list); |
591 | parser.template.sort_list_size = sort_list_size (&parser.sort_list); |
592 | conf = __resolv_conf_allocate (&parser.template); |
593 | } |
594 | resolv_conf_parser_free (&parser); |
595 | |
596 | return conf; |
597 | } |
598 | |
599 | /* Set up default settings. If the /etc/resolv.conf configuration |
600 | file exist, the values there will have precedence. Otherwise, the |
601 | server address is set to INADDR_LOOPBACK and the default domain |
602 | name comes from gethostname. The RES_OPTIONS and LOCALDOMAIN |
603 | environment variables can be used to override some settings. |
604 | Return 0 if completes successfully, -1 on error. */ |
605 | int |
606 | __res_vinit (res_state statp, int preinit) |
607 | { |
608 | struct resolv_conf *conf; |
609 | if (preinit && has_preinit_values (statp)) |
610 | /* For the preinit case, we cannot use the cached configuration |
611 | because some settings could be different. */ |
612 | conf = __resolv_conf_load (statp); |
613 | else |
614 | conf = __resolv_conf_get_current (); |
615 | if (conf == NULL) |
616 | return -1; |
617 | |
618 | bool ok = __resolv_conf_attach (statp, conf); |
619 | __resolv_conf_put (conf); |
620 | if (ok) |
621 | { |
622 | if (preinit) |
623 | statp->id = res_randomid (); |
624 | return 0; |
625 | } |
626 | else |
627 | return -1; |
628 | } |
629 | |
630 | static void |
631 | res_setoptions (struct resolv_conf_parser *parser, const char *options) |
632 | { |
633 | const char *cp = options; |
634 | |
635 | while (*cp) |
636 | { |
637 | /* Skip leading and inner runs of spaces. */ |
638 | while (*cp == ' ' || *cp == '\t') |
639 | cp++; |
640 | /* Search for and process individual options. */ |
641 | if (!strncmp (cp, "ndots:" , sizeof ("ndots:" ) - 1)) |
642 | { |
643 | int i = atoi (cp + sizeof ("ndots:" ) - 1); |
644 | if (i <= RES_MAXNDOTS) |
645 | parser->template.ndots = i; |
646 | else |
647 | parser->template.ndots = RES_MAXNDOTS; |
648 | } |
649 | else if (!strncmp (cp, "timeout:" , sizeof ("timeout:" ) - 1)) |
650 | { |
651 | int i = atoi (cp + sizeof ("timeout:" ) - 1); |
652 | if (i <= RES_MAXRETRANS) |
653 | parser->template.retrans = i; |
654 | else |
655 | parser->template.retrans = RES_MAXRETRANS; |
656 | } |
657 | else if (!strncmp (cp, "attempts:" , sizeof ("attempts:" ) - 1)) |
658 | { |
659 | int i = atoi (cp + sizeof ("attempts:" ) - 1); |
660 | if (i <= RES_MAXRETRY) |
661 | parser->template.retry = i; |
662 | else |
663 | parser->template.retry = RES_MAXRETRY; |
664 | } |
665 | else |
666 | { |
667 | static const struct |
668 | { |
669 | char str[22]; |
670 | uint8_t len; |
671 | uint8_t clear; |
672 | unsigned long int flag; |
673 | } options[] = { |
674 | #define STRnLEN(str) str, sizeof (str) - 1 |
675 | { STRnLEN ("rotate" ), 0, RES_ROTATE }, |
676 | { STRnLEN ("edns0" ), 0, RES_USE_EDNS0 }, |
677 | { STRnLEN ("single-request-reopen" ), 0, RES_SNGLKUPREOP }, |
678 | { STRnLEN ("single-request" ), 0, RES_SNGLKUP }, |
679 | { STRnLEN ("no_tld_query" ), 0, RES_NOTLDQUERY }, |
680 | { STRnLEN ("no-tld-query" ), 0, RES_NOTLDQUERY }, |
681 | { STRnLEN ("no-reload" ), 0, RES_NORELOAD }, |
682 | { STRnLEN ("use-vc" ), 0, RES_USEVC }, |
683 | { STRnLEN ("trust-ad" ), 0, RES_TRUSTAD }, |
684 | }; |
685 | #define noptions (sizeof (options) / sizeof (options[0])) |
686 | for (int i = 0; i < noptions; ++i) |
687 | if (strncmp (cp, options[i].str, options[i].len) == 0) |
688 | { |
689 | if (options[i].clear) |
690 | parser->template.options &= options[i].flag; |
691 | else |
692 | parser->template.options |= options[i].flag; |
693 | break; |
694 | } |
695 | } |
696 | /* Skip to next run of spaces. */ |
697 | while (*cp && *cp != ' ' && *cp != '\t') |
698 | cp++; |
699 | } |
700 | } |
701 | |
702 | static uint32_t |
703 | net_mask (struct in_addr in) |
704 | { |
705 | uint32_t i = ntohl (in.s_addr); |
706 | |
707 | if (IN_CLASSA (i)) |
708 | return htonl (IN_CLASSA_NET); |
709 | else if (IN_CLASSB (i)) |
710 | return htonl (IN_CLASSB_NET); |
711 | return htonl (IN_CLASSC_NET); |
712 | } |
713 | |