1 /* Copyright (C) 1993-2023 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3
4 The GNU C Library is free software; you can redistribute it and/or
5 modify it under the terms of the GNU Lesser General Public
6 License as published by the Free Software Foundation; either
7 version 2.1 of the License, or (at your option) any later version.
8
9 The GNU C Library is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 Lesser General Public License for more details.
13
14 You should have received a copy of the GNU Lesser General Public
15 License along with the GNU C Library; if not, see
16 <https://www.gnu.org/licenses/>. */
17
18 /* This file provides a Linux /etc/host.conf compatible front end to
19 the various name resolvers (/etc/hosts, named, NIS server, etc.).
20 Though mostly compatibly, the following differences exist compared
21 to the original implementation:
22
23 - line comments can appear anywhere (not just at the beginning of
24 a line)
25 */
26
27 #include <assert.h>
28 #include <errno.h>
29 #include <ctype.h>
30 #include <libintl.h>
31 #include <memory.h>
32 #include <stdio.h>
33 #include <stdio_ext.h>
34 #include <stdlib.h>
35 #include <string.h>
36 #include <net/if.h>
37 #include <sys/ioctl.h>
38 #include <unistd.h>
39 #include <netinet/in.h>
40 #include <libc-lock.h>
41 #include "ifreq.h"
42 #include "res_hconf.h"
43 #include <wchar.h>
44 #include <atomic.h>
45 #include <set-freeres.h>
46
47 #if IS_IN (libc)
48 # define fgets_unlocked __fgets_unlocked
49 #endif
50
51 #define _PATH_HOSTCONF "/etc/host.conf"
52
53 /* Environment vars that all user to override default behavior: */
54 #define ENV_HOSTCONF "RESOLV_HOST_CONF"
55 #define ENV_TRIM_OVERR "RESOLV_OVERRIDE_TRIM_DOMAINS"
56 #define ENV_TRIM_ADD "RESOLV_ADD_TRIM_DOMAINS"
57 #define ENV_MULTI "RESOLV_MULTI"
58 #define ENV_REORDER "RESOLV_REORDER"
59
60 enum parse_cbs
61 {
62 CB_none,
63 CB_arg_trimdomain_list,
64 CB_arg_bool
65 };
66
67 static const struct cmd
68 {
69 const char name[11];
70 uint8_t cb;
71 unsigned int arg;
72 } cmd[] =
73 {
74 {"order", CB_none, 0},
75 {"trim", CB_arg_trimdomain_list, 0},
76 {"multi", CB_arg_bool, HCONF_FLAG_MULTI},
77 {"reorder", CB_arg_bool, HCONF_FLAG_REORDER}
78 };
79
80 /* Structure containing the state. */
81 struct hconf _res_hconf;
82
83 /* Skip white space. */
84 static const char *
85 skip_ws (const char *str)
86 {
87 while (isspace (*str)) ++str;
88 return str;
89 }
90
91
92 /* Skip until whitespace, comma, end of line, or comment character. */
93 static const char *
94 skip_string (const char *str)
95 {
96 while (*str && !isspace (*str) && *str != '#' && *str != ',')
97 ++str;
98 return str;
99 }
100
101
102 static const char *
103 arg_trimdomain_list (const char *fname, int line_num, const char *args)
104 {
105 const char * start;
106 size_t len;
107
108 do
109 {
110 start = args;
111 args = skip_string (args);
112 len = args - start;
113
114 if (_res_hconf.num_trimdomains >= TRIMDOMAINS_MAX)
115 {
116 char *buf;
117
118 if (__asprintf (&buf, _("\
119 %s: line %d: cannot specify more than %d trim domains"),
120 fname, line_num, TRIMDOMAINS_MAX) < 0)
121 return 0;
122
123 __fxprintf (NULL, "%s", buf);
124
125 free (buf);
126 return 0;
127 }
128 _res_hconf.trimdomain[_res_hconf.num_trimdomains++] =
129 __strndup (start, len);
130 args = skip_ws (args);
131 switch (*args)
132 {
133 case ',': case ';': case ':':
134 args = skip_ws (++args);
135 if (!*args || *args == '#')
136 {
137 char *buf;
138
139 if (__asprintf (&buf, _("\
140 %s: line %d: list delimiter not followed by domain"),
141 fname, line_num) < 0)
142 return 0;
143
144 __fxprintf (NULL, "%s", buf);
145
146 free (buf);
147 return 0;
148 }
149 default:
150 break;
151 }
152 }
153 while (*args && *args != '#');
154 return args;
155 }
156
157
158 static const char *
159 arg_bool (const char *fname, int line_num, const char *args, unsigned flag)
160 {
161 if (__strncasecmp (args, "on", 2) == 0)
162 {
163 args += 2;
164 _res_hconf.flags |= flag;
165 }
166 else if (__strncasecmp (args, "off", 3) == 0)
167 {
168 args += 3;
169 _res_hconf.flags &= ~flag;
170 }
171 else
172 {
173 char *buf;
174
175 if (__asprintf (&buf,
176 _("%s: line %d: expected `on' or `off', found `%s'\n"),
177 fname, line_num, args) < 0)
178 return 0;
179
180 __fxprintf (NULL, "%s", buf);
181
182 free (buf);
183 return 0;
184 }
185 return args;
186 }
187
188
189 static void
190 parse_line (const char *fname, int line_num, const char *str)
191 {
192 const char *start;
193 const struct cmd *c = 0;
194 size_t len;
195 size_t i;
196
197 str = skip_ws (str);
198
199 /* skip line comment and empty lines: */
200 if (*str == '\0' || *str == '#') return;
201
202 start = str;
203 str = skip_string (str);
204 len = str - start;
205
206 for (i = 0; i < sizeof (cmd) / sizeof (cmd[0]); ++i)
207 {
208 if (__strncasecmp (start, cmd[i].name, len) == 0
209 && strlen (cmd[i].name) == len)
210 {
211 c = &cmd[i];
212 break;
213 }
214 }
215 if (c == NULL)
216 {
217 char *buf;
218
219 if (__asprintf (&buf, _("%s: line %d: bad command `%s'\n"),
220 fname, line_num, start) < 0)
221 return;
222
223 __fxprintf (NULL, "%s", buf);
224
225 free (buf);
226 return;
227 }
228
229 /* process args: */
230 str = skip_ws (str);
231
232 if (c->cb == CB_arg_trimdomain_list)
233 str = arg_trimdomain_list (fname, line_num, str);
234 else if (c->cb == CB_arg_bool)
235 str = arg_bool (fname, line_num, str, c->arg);
236 else
237 /* Ignore the line. */
238 return;
239
240 if (!str)
241 return;
242
243 /* rest of line must contain white space or comment only: */
244 while (*str)
245 {
246 if (!isspace (*str)) {
247 if (*str != '#')
248 {
249 char *buf;
250
251 if (__asprintf (&buf,
252 _("%s: line %d: ignoring trailing garbage `%s'\n"),
253 fname, line_num, str) < 0)
254 break;
255
256 __fxprintf (NULL, "%s", buf);
257
258 free (buf);
259 }
260 break;
261 }
262 ++str;
263 }
264 }
265
266
267 static void
268 do_init (void)
269 {
270 const char *hconf_name;
271 int line_num = 0;
272 char buf[256], *envval;
273 FILE *fp;
274
275 memset (&_res_hconf, '\0', sizeof (_res_hconf));
276
277 hconf_name = getenv (ENV_HOSTCONF);
278 if (hconf_name == NULL)
279 hconf_name = _PATH_HOSTCONF;
280
281 fp = fopen (hconf_name, "rce");
282 if (fp)
283 {
284 /* No threads using this stream. */
285 __fsetlocking (fp, FSETLOCKING_BYCALLER);
286
287 while (fgets_unlocked (buf, sizeof (buf), fp))
288 {
289 ++line_num;
290 *__strchrnul (buf, '\n') = '\0';
291 parse_line (hconf_name, line_num, buf);
292 }
293 fclose (fp);
294 }
295
296 envval = getenv (ENV_MULTI);
297 if (envval)
298 arg_bool (ENV_MULTI, 1, envval, HCONF_FLAG_MULTI);
299
300 envval = getenv (ENV_REORDER);
301 if (envval)
302 arg_bool (ENV_REORDER, 1, envval, HCONF_FLAG_REORDER);
303
304 envval = getenv (ENV_TRIM_ADD);
305 if (envval)
306 arg_trimdomain_list (ENV_TRIM_ADD, 1, envval);
307
308 envval = getenv (ENV_TRIM_OVERR);
309 if (envval)
310 {
311 _res_hconf.num_trimdomains = 0;
312 arg_trimdomain_list (ENV_TRIM_OVERR, 1, envval);
313 }
314
315 /* See comments on the declaration of _res_hconf. */
316 atomic_store_release (&_res_hconf.initialized, 1);
317 }
318
319
320 /* Initialize hconf datastructure by reading host.conf file and
321 environment variables. */
322 void
323 _res_hconf_init (void)
324 {
325 __libc_once_define (static, once);
326
327 __libc_once (once, do_init);
328 }
329
330
331 #if IS_IN (libc)
332 # if defined SIOCGIFCONF && defined SIOCGIFNETMASK
333 /* List of known interfaces. */
334 static struct netaddr *ifaddrs;
335 weak_alias (ifaddrs, __libc_resolv_res_hconf_freemem_ptr)
336 # endif
337
338 /* Reorder addresses returned in a hostent such that the first address
339 is an address on the local subnet, if there is such an address.
340 Otherwise, nothing is changed.
341
342 Note that this function currently only handles IPv4 addresses. */
343
344 void
345 _res_hconf_reorder_addrs (struct hostent *hp)
346 {
347 #if defined SIOCGIFCONF && defined SIOCGIFNETMASK
348 int i, j;
349 /* Number of interfaces. Also serves as a flag for the
350 double-checked locking idiom. */
351 static int num_ifs = -1;
352 /* Local copy of num_ifs, for non-atomic access. */
353 int num_ifs_local;
354 /* We need to protect the dynamic buffer handling. The lock is only
355 acquired during initialization. Afterwards, a positive num_ifs
356 value indicates completed initialization. */
357 __libc_lock_define_initialized (static, lock);
358
359 /* Only reorder if we're supposed to. */
360 if ((_res_hconf.flags & HCONF_FLAG_REORDER) == 0)
361 return;
362
363 /* Can't deal with anything but IPv4 for now... */
364 if (hp->h_addrtype != AF_INET)
365 return;
366
367 /* This load synchronizes with the release MO store in the
368 initialization block below. */
369 num_ifs_local = atomic_load_acquire (&num_ifs);
370 if (num_ifs_local <= 0)
371 {
372 struct ifreq *ifr, *cur_ifr;
373 int sd, num, i;
374 /* Save errno. */
375 int save = errno;
376
377 /* Initialize interface table. */
378
379 /* The SIOCGIFNETMASK ioctl will only work on an AF_INET socket. */
380 sd = __socket (AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
381 if (sd < 0)
382 return;
383
384 /* Get lock. */
385 __libc_lock_lock (lock);
386
387 /* Recheck, somebody else might have done the work by now. No
388 ordering is required for the load because we have the lock,
389 and num_ifs is only updated under the lock. Also see (3) in
390 the analysis below. */
391 num_ifs_local = atomic_load_relaxed (&num_ifs);
392 if (num_ifs_local <= 0)
393 {
394 /* This is the only block which writes to num_ifs. It can
395 be executed several times (sequentially) if
396 initialization does not yield any interfaces, and num_ifs
397 remains zero. However, once we stored a positive value
398 in num_ifs below, this block cannot be entered again due
399 to the condition above. */
400 int new_num_ifs = 0;
401
402 /* Get a list of interfaces. */
403 __ifreq (&ifr, &num, sd);
404 if (!ifr)
405 goto cleanup;
406
407 ifaddrs = malloc (num * sizeof (ifaddrs[0]));
408 if (!ifaddrs)
409 goto cleanup1;
410
411 /* Copy usable interfaces in ifaddrs structure. */
412 for (cur_ifr = ifr, i = 0; i < num;
413 cur_ifr = __if_nextreq (cur_ifr), ++i)
414 {
415 union
416 {
417 struct sockaddr sa;
418 struct sockaddr_in sin;
419 } ss;
420
421 if (cur_ifr->ifr_addr.sa_family != AF_INET)
422 continue;
423
424 ifaddrs[new_num_ifs].addrtype = AF_INET;
425 ss.sa = cur_ifr->ifr_addr;
426 ifaddrs[new_num_ifs].u.ipv4.addr = ss.sin.sin_addr.s_addr;
427
428 if (__ioctl (sd, SIOCGIFNETMASK, cur_ifr) < 0)
429 continue;
430
431 ss.sa = cur_ifr->ifr_netmask;
432 ifaddrs[new_num_ifs].u.ipv4.mask = ss.sin.sin_addr.s_addr;
433
434 /* Now we're committed to this entry. */
435 ++new_num_ifs;
436 }
437 /* Just keep enough memory to hold all the interfaces we want. */
438 ifaddrs = realloc (ifaddrs, new_num_ifs * sizeof (ifaddrs[0]));
439 assert (ifaddrs != NULL);
440
441 cleanup1:
442 __if_freereq (ifr, num);
443
444 cleanup:
445 /* Release lock, preserve error value, and close socket. */
446 errno = save;
447
448 /* Advertise successful initialization if new_num_ifs is
449 positive (and no updates to ifaddrs are permitted after
450 that). Otherwise, num_ifs remains unchanged, at zero.
451 This store synchronizes with the initial acquire MO
452 load. */
453 atomic_store_release (&num_ifs, new_num_ifs);
454 /* Keep the local copy current, to save another load. */
455 num_ifs_local = new_num_ifs;
456 }
457
458 __libc_lock_unlock (lock);
459
460 __close (sd);
461 }
462
463 /* num_ifs_local cannot be negative because the if statement above
464 covered this case. It can still be zero if we just performed
465 initialization, but could not find any interfaces. */
466 if (num_ifs_local == 0)
467 return;
468
469 /* The code below accesses ifaddrs, so we need to ensure that the
470 initialization happens-before this point.
471
472 The actual initialization is sequenced-before the release store
473 to num_ifs, and sequenced-before the end of the critical section.
474
475 This means there are three possible executions:
476
477 (1) The thread that initialized the data also uses it, so
478 sequenced-before is sufficient to ensure happens-before.
479
480 (2) The release MO store of num_ifs synchronizes-with the acquire
481 MO load, and the acquire MO load is sequenced before the use
482 of the initialized data below.
483
484 (3) We enter the critical section, and the relaxed MO load of
485 num_ifs yields a positive value. The write to ifaddrs is
486 sequenced-before leaving the critical section. Leaving the
487 critical section happens-before we entered the critical
488 section ourselves, which means that the write to ifaddrs
489 happens-before this point.
490
491 Consequently, all potential writes to ifaddrs (and the data it
492 points to) happens-before this point. */
493
494 /* Find an address for which we have a direct connection. */
495 for (i = 0; hp->h_addr_list[i]; ++i)
496 {
497 struct in_addr *haddr = (struct in_addr *) hp->h_addr_list[i];
498
499 for (j = 0; j < num_ifs_local; ++j)
500 {
501 uint32_t if_addr = ifaddrs[j].u.ipv4.addr;
502 uint32_t if_netmask = ifaddrs[j].u.ipv4.mask;
503
504 if (((haddr->s_addr ^ if_addr) & if_netmask) == 0)
505 {
506 void *tmp;
507
508 tmp = hp->h_addr_list[i];
509 hp->h_addr_list[i] = hp->h_addr_list[0];
510 hp->h_addr_list[0] = tmp;
511 return;
512 }
513 }
514 }
515 #endif /* defined(SIOCGIFCONF) && ... */
516 }
517
518
519 /* If HOSTNAME has a postfix matching any of the trimdomains, trim away
520 that postfix. Notice that HOSTNAME is modified inplace. Also, the
521 original code applied all trimdomains in order, meaning that the
522 same domainname could be trimmed multiple times. I believe this
523 was unintentional. */
524 void
525 _res_hconf_trim_domain (char *hostname)
526 {
527 size_t hostname_len, trim_len;
528 int i;
529
530 hostname_len = strlen (hostname);
531
532 for (i = 0; i < _res_hconf.num_trimdomains; ++i)
533 {
534 const char *trim = _res_hconf.trimdomain[i];
535
536 trim_len = strlen (trim);
537 if (hostname_len > trim_len
538 && __strcasecmp (&hostname[hostname_len - trim_len], trim) == 0)
539 {
540 hostname[hostname_len - trim_len] = '\0';
541 break;
542 }
543 }
544 }
545
546
547 /* Trim all hostnames/aliases in HP according to the trimdomain list.
548 Notice that HP is modified inplace! */
549 void
550 _res_hconf_trim_domains (struct hostent *hp)
551 {
552 int i;
553
554 if (_res_hconf.num_trimdomains == 0)
555 return;
556
557 _res_hconf_trim_domain (hp->h_name);
558 for (i = 0; hp->h_aliases[i]; ++i)
559 _res_hconf_trim_domain (hp->h_aliases[i]);
560 }
561 #endif