]>
Commit | Line | Data |
---|---|---|
53e1b683 | 1 | /* SPDX-License-Identifier: LGPL-2.1+ */ |
2abb5b3b ZJS |
2 | |
3 | #include <dlfcn.h> | |
4 | #include <stdlib.h> | |
5 | #include <net/if.h> | |
6 | ||
7 | #include "log.h" | |
8 | #include "nss-util.h" | |
9 | #include "path-util.h" | |
10 | #include "string-util.h" | |
11 | #include "alloc-util.h" | |
12 | #include "in-addr-util.h" | |
13 | #include "hexdecoct.h" | |
14 | #include "af-list.h" | |
15 | #include "stdio-util.h" | |
16 | #include "strv.h" | |
17 | #include "errno-list.h" | |
18 | #include "hostname-util.h" | |
19 | #include "local-addresses.h" | |
20 | ||
21 | static const char* nss_status_to_string(enum nss_status status, char *buf, size_t buf_len) { | |
22 | switch (status) { | |
23 | case NSS_STATUS_TRYAGAIN: | |
24 | return "NSS_STATUS_TRYAGAIN"; | |
25 | case NSS_STATUS_UNAVAIL: | |
26 | return "NSS_STATUS_UNAVAIL"; | |
27 | case NSS_STATUS_NOTFOUND: | |
28 | return "NSS_STATUS_NOTFOUND"; | |
29 | case NSS_STATUS_SUCCESS: | |
30 | return "NSS_STATUS_SUCCESS"; | |
31 | case NSS_STATUS_RETURN: | |
32 | return "NSS_STATUS_RETURN"; | |
33 | default: | |
34 | snprintf(buf, buf_len, "%i", status); | |
35 | return buf; | |
36 | } | |
37 | }; | |
38 | ||
39 | static const char* af_to_string(int family, char *buf, size_t buf_len) { | |
40 | const char *name; | |
41 | ||
42 | if (family == AF_UNSPEC) | |
43 | return "*"; | |
44 | ||
45 | name = af_to_name(family); | |
46 | if (name) | |
47 | return name; | |
48 | ||
49 | snprintf(buf, buf_len, "%i", family); | |
50 | return buf; | |
51 | } | |
52 | ||
53 | static void* open_handle(const char* dir, const char* module, int flags) { | |
54 | const char *path; | |
55 | void *handle; | |
56 | ||
3762b672 ZJS |
57 | if (dir) { |
58 | path = strjoina(dir, "/libnss_", module, ".so.2"); | |
59 | if (access(path, F_OK) < 0) | |
60 | path = strjoina(dir, "/.libs/libnss_", module, ".so.2"); | |
61 | } else | |
2abb5b3b ZJS |
62 | path = strjoina("libnss_", module, ".so.2"); |
63 | ||
64 | handle = dlopen(path, flags); | |
9f7672b3 ZJS |
65 | if (!handle) |
66 | log_error("Failed to load module %s: %s", module, dlerror()); | |
2abb5b3b ZJS |
67 | return handle; |
68 | } | |
69 | ||
70 | static int print_gaih_addrtuples(const struct gaih_addrtuple *tuples) { | |
71 | const struct gaih_addrtuple *it; | |
72 | int n = 0; | |
73 | ||
74 | for (it = tuples; it; it = it->next) { | |
75 | _cleanup_free_ char *a = NULL; | |
76 | union in_addr_union u; | |
77 | int r; | |
78 | char family_name[DECIMAL_STR_MAX(int)]; | |
79 | char ifname[IF_NAMESIZE]; | |
80 | ||
81 | memcpy(&u, it->addr, 16); | |
82 | r = in_addr_to_string(it->family, &u, &a); | |
4c701096 | 83 | assert_se(IN_SET(r, 0, -EAFNOSUPPORT)); |
2abb5b3b | 84 | if (r == -EAFNOSUPPORT) |
dcd6361e | 85 | assert_se(a = hexmem(it->addr, 16)); |
2abb5b3b ZJS |
86 | |
87 | if (it->scopeid == 0) | |
88 | goto numerical_index; | |
89 | ||
90 | if (if_indextoname(it->scopeid, ifname) == NULL) { | |
25f027c5 | 91 | log_warning_errno(errno, "if_indextoname(%d) failed: %m", it->scopeid); |
2abb5b3b ZJS |
92 | numerical_index: |
93 | xsprintf(ifname, "%i", it->scopeid); | |
94 | }; | |
95 | ||
96 | log_info(" \"%s\" %s %s %%%s", | |
97 | it->name, | |
98 | af_to_string(it->family, family_name, sizeof family_name), | |
99 | a, | |
100 | ifname); | |
101 | n ++; | |
102 | } | |
103 | return n; | |
104 | } | |
105 | ||
106 | static void print_struct_hostent(struct hostent *host, const char *canon) { | |
107 | char **s; | |
108 | ||
109 | log_info(" \"%s\"", host->h_name); | |
110 | STRV_FOREACH(s, host->h_aliases) | |
111 | log_info(" alias \"%s\"", *s); | |
112 | STRV_FOREACH(s, host->h_addr_list) { | |
113 | union in_addr_union u; | |
114 | _cleanup_free_ char *a = NULL; | |
115 | char family_name[DECIMAL_STR_MAX(int)]; | |
116 | int r; | |
117 | ||
118 | assert_se((unsigned) host->h_length == FAMILY_ADDRESS_SIZE(host->h_addrtype)); | |
119 | memcpy(&u, *s, host->h_length); | |
120 | r = in_addr_to_string(host->h_addrtype, &u, &a); | |
121 | assert_se(r == 0); | |
122 | log_info(" %s %s", | |
123 | af_to_string(host->h_addrtype, family_name, sizeof family_name), | |
124 | a); | |
125 | } | |
126 | if (canon) | |
127 | log_info(" canonical: \"%s\"", canon); | |
128 | } | |
129 | ||
130 | static void test_gethostbyname4_r(void *handle, const char *module, const char *name) { | |
131 | const char *fname; | |
132 | _nss_gethostbyname4_r_t f; | |
133 | char buffer[2000]; | |
134 | struct gaih_addrtuple *pat = NULL; | |
135 | int errno1 = 999, errno2 = 999; /* nss-dns doesn't set those */ | |
136 | int32_t ttl = INT32_MAX; /* nss-dns wants to return the lowest ttl, | |
137 | and will access this variable through *ttlp, | |
138 | so we need to set it to something. | |
139 | I'm not sure if this is a bug in nss-dns | |
140 | or not. */ | |
141 | enum nss_status status; | |
142 | char pretty_status[DECIMAL_STR_MAX(enum nss_status)]; | |
143 | int n; | |
144 | ||
145 | fname = strjoina("_nss_", module, "_gethostbyname4_r"); | |
146 | f = dlsym(handle, fname); | |
147 | log_debug("dlsym(0x%p, %s) → 0x%p", handle, fname, f); | |
148 | assert_se(f); | |
149 | ||
150 | status = f(name, &pat, buffer, sizeof buffer, &errno1, &errno2, &ttl); | |
151 | if (status == NSS_STATUS_SUCCESS) { | |
152 | log_info("%s(\"%s\") → status=%s%-20spat=buffer+0x%tx errno=%d/%s h_errno=%d/%s ttl=%"PRIi32, | |
153 | fname, name, | |
154 | nss_status_to_string(status, pretty_status, sizeof pretty_status), "\n", | |
155 | pat ? (char*) pat - buffer : 0, | |
156 | errno1, errno_to_name(errno1) ?: "---", | |
157 | errno2, hstrerror(errno2), | |
158 | ttl); | |
159 | n = print_gaih_addrtuples(pat); | |
160 | } else { | |
161 | log_info("%s(\"%s\") → status=%s%-20spat=0x%p errno=%d/%s h_errno=%d/%s", | |
162 | fname, name, | |
163 | nss_status_to_string(status, pretty_status, sizeof pretty_status), "\n", | |
164 | pat, | |
165 | errno1, errno_to_name(errno1) ?: "---", | |
166 | errno2, hstrerror(errno2)); | |
167 | n = 0; | |
168 | } | |
169 | ||
170 | if (STR_IN_SET(module, "resolve", "mymachines") && status == NSS_STATUS_UNAVAIL) | |
171 | return; | |
172 | ||
173 | if (STR_IN_SET(module, "myhostname", "resolve") && streq(name, "localhost")) { | |
174 | assert_se(status == NSS_STATUS_SUCCESS); | |
175 | assert_se(n == 2); | |
176 | } | |
177 | } | |
178 | ||
2abb5b3b ZJS |
179 | static void test_gethostbyname3_r(void *handle, const char *module, const char *name, int af) { |
180 | const char *fname; | |
181 | _nss_gethostbyname3_r_t f; | |
182 | char buffer[2000]; | |
183 | int errno1 = 999, errno2 = 999; /* nss-dns doesn't set those */ | |
184 | int32_t ttl = INT32_MAX; /* nss-dns wants to return the lowest ttl, | |
185 | and will access this variable through *ttlp, | |
186 | so we need to set it to something. | |
187 | I'm not sure if this is a bug in nss-dns | |
188 | or not. */ | |
189 | enum nss_status status; | |
190 | char pretty_status[DECIMAL_STR_MAX(enum nss_status)]; | |
191 | struct hostent host; | |
192 | char *canon; | |
193 | char family_name[DECIMAL_STR_MAX(int)]; | |
194 | ||
195 | fname = strjoina("_nss_", module, "_gethostbyname3_r"); | |
196 | f = dlsym(handle, fname); | |
197 | log_debug("dlsym(0x%p, %s) → 0x%p", handle, fname, f); | |
198 | assert_se(f); | |
199 | ||
200 | status = f(name, af, &host, buffer, sizeof buffer, &errno1, &errno2, &ttl, &canon); | |
201 | log_info("%s(\"%s\", %s) → status=%s%-20serrno=%d/%s h_errno=%d/%s ttl=%"PRIi32, | |
202 | fname, name, af_to_string(af, family_name, sizeof family_name), | |
203 | nss_status_to_string(status, pretty_status, sizeof pretty_status), "\n", | |
204 | errno1, errno_to_name(errno1) ?: "---", | |
205 | errno2, hstrerror(errno2), | |
206 | ttl); | |
207 | if (status == NSS_STATUS_SUCCESS) | |
208 | print_struct_hostent(&host, canon); | |
209 | } | |
210 | ||
211 | static void test_gethostbyname2_r(void *handle, const char *module, const char *name, int af) { | |
212 | const char *fname; | |
213 | _nss_gethostbyname2_r_t f; | |
214 | char buffer[2000]; | |
215 | int errno1 = 999, errno2 = 999; /* nss-dns doesn't set those */ | |
216 | enum nss_status status; | |
217 | char pretty_status[DECIMAL_STR_MAX(enum nss_status)]; | |
218 | struct hostent host; | |
219 | char family_name[DECIMAL_STR_MAX(int)]; | |
220 | ||
221 | fname = strjoina("_nss_", module, "_gethostbyname2_r"); | |
222 | f = dlsym(handle, fname); | |
223 | log_debug("dlsym(0x%p, %s) → 0x%p", handle, fname, f); | |
224 | assert_se(f); | |
225 | ||
226 | status = f(name, af, &host, buffer, sizeof buffer, &errno1, &errno2); | |
227 | log_info("%s(\"%s\", %s) → status=%s%-20serrno=%d/%s h_errno=%d/%s", | |
228 | fname, name, af_to_string(af, family_name, sizeof family_name), | |
229 | nss_status_to_string(status, pretty_status, sizeof pretty_status), "\n", | |
230 | errno1, errno_to_name(errno1) ?: "---", | |
231 | errno2, hstrerror(errno2)); | |
232 | if (status == NSS_STATUS_SUCCESS) | |
233 | print_struct_hostent(&host, NULL); | |
234 | } | |
235 | ||
236 | static void test_gethostbyname_r(void *handle, const char *module, const char *name) { | |
237 | const char *fname; | |
238 | _nss_gethostbyname_r_t f; | |
239 | char buffer[2000]; | |
240 | int errno1 = 999, errno2 = 999; /* nss-dns doesn't set those */ | |
241 | enum nss_status status; | |
242 | char pretty_status[DECIMAL_STR_MAX(enum nss_status)]; | |
243 | struct hostent host; | |
244 | ||
245 | fname = strjoina("_nss_", module, "_gethostbyname_r"); | |
246 | f = dlsym(handle, fname); | |
247 | log_debug("dlsym(0x%p, %s) → 0x%p", handle, fname, f); | |
248 | assert_se(f); | |
249 | ||
250 | status = f(name, &host, buffer, sizeof buffer, &errno1, &errno2); | |
251 | log_info("%s(\"%s\") → status=%s%-20serrno=%d/%s h_errno=%d/%s", | |
252 | fname, name, | |
253 | nss_status_to_string(status, pretty_status, sizeof pretty_status), "\n", | |
254 | errno1, errno_to_name(errno1) ?: "---", | |
255 | errno2, hstrerror(errno2)); | |
256 | if (status == NSS_STATUS_SUCCESS) | |
257 | print_struct_hostent(&host, NULL); | |
258 | } | |
259 | ||
260 | static void test_gethostbyaddr2_r(void *handle, | |
261 | const char *module, | |
262 | const void* addr, socklen_t len, | |
263 | int af) { | |
264 | ||
265 | const char *fname; | |
266 | _nss_gethostbyaddr2_r_t f; | |
267 | char buffer[2000]; | |
268 | int errno1 = 999, errno2 = 999; /* nss-dns doesn't set those */ | |
269 | enum nss_status status; | |
270 | char pretty_status[DECIMAL_STR_MAX(enum nss_status)]; | |
271 | struct hostent host; | |
272 | int32_t ttl = INT32_MAX; | |
273 | _cleanup_free_ char *addr_pretty = NULL; | |
274 | ||
275 | fname = strjoina("_nss_", module, "_gethostbyaddr2_r"); | |
276 | f = dlsym(handle, fname); | |
277 | ||
278 | log_full_errno(f ? LOG_DEBUG : LOG_INFO, errno, | |
279 | "dlsym(0x%p, %s) → 0x%p: %m", handle, fname, f); | |
280 | if (!f) | |
281 | return; | |
282 | ||
283 | assert_se(in_addr_to_string(af, addr, &addr_pretty) >= 0); | |
284 | ||
285 | status = f(addr, len, af, &host, buffer, sizeof buffer, &errno1, &errno2, &ttl); | |
286 | log_info("%s(\"%s\") → status=%s%-20serrno=%d/%s h_errno=%d/%s ttl=%"PRIi32, | |
287 | fname, addr_pretty, | |
288 | nss_status_to_string(status, pretty_status, sizeof pretty_status), "\n", | |
289 | errno1, errno_to_name(errno1) ?: "---", | |
290 | errno2, hstrerror(errno2), | |
291 | ttl); | |
292 | if (status == NSS_STATUS_SUCCESS) | |
293 | print_struct_hostent(&host, NULL); | |
294 | } | |
295 | ||
296 | static void test_gethostbyaddr_r(void *handle, | |
297 | const char *module, | |
298 | const void* addr, socklen_t len, | |
299 | int af) { | |
300 | ||
301 | const char *fname; | |
302 | _nss_gethostbyaddr_r_t f; | |
303 | char buffer[2000]; | |
304 | int errno1 = 999, errno2 = 999; /* nss-dns doesn't set those */ | |
305 | enum nss_status status; | |
306 | char pretty_status[DECIMAL_STR_MAX(enum nss_status)]; | |
307 | struct hostent host; | |
308 | _cleanup_free_ char *addr_pretty = NULL; | |
309 | ||
310 | fname = strjoina("_nss_", module, "_gethostbyaddr_r"); | |
311 | f = dlsym(handle, fname); | |
312 | ||
313 | log_full_errno(f ? LOG_DEBUG : LOG_INFO, errno, | |
314 | "dlsym(0x%p, %s) → 0x%p: %m", handle, fname, f); | |
315 | if (!f) | |
316 | return; | |
317 | ||
318 | assert_se(in_addr_to_string(af, addr, &addr_pretty) >= 0); | |
319 | ||
320 | status = f(addr, len, af, &host, buffer, sizeof buffer, &errno1, &errno2); | |
321 | log_info("%s(\"%s\") → status=%s%-20serrno=%d/%s h_errno=%d/%s", | |
322 | fname, addr_pretty, | |
323 | nss_status_to_string(status, pretty_status, sizeof pretty_status), "\n", | |
324 | errno1, errno_to_name(errno1) ?: "---", | |
325 | errno2, hstrerror(errno2)); | |
326 | if (status == NSS_STATUS_SUCCESS) | |
327 | print_struct_hostent(&host, NULL); | |
328 | } | |
329 | ||
330 | static void test_byname(void *handle, const char *module, const char *name) { | |
331 | test_gethostbyname4_r(handle, module, name); | |
332 | puts(""); | |
333 | ||
334 | test_gethostbyname3_r(handle, module, name, AF_INET); | |
335 | puts(""); | |
336 | test_gethostbyname3_r(handle, module, name, AF_INET6); | |
337 | puts(""); | |
338 | test_gethostbyname3_r(handle, module, name, AF_UNSPEC); | |
339 | puts(""); | |
340 | test_gethostbyname3_r(handle, module, name, AF_LOCAL); | |
341 | puts(""); | |
342 | ||
343 | test_gethostbyname2_r(handle, module, name, AF_INET); | |
344 | puts(""); | |
345 | test_gethostbyname2_r(handle, module, name, AF_INET6); | |
346 | puts(""); | |
347 | test_gethostbyname2_r(handle, module, name, AF_UNSPEC); | |
348 | puts(""); | |
349 | test_gethostbyname2_r(handle, module, name, AF_LOCAL); | |
350 | puts(""); | |
351 | ||
352 | test_gethostbyname_r(handle, module, name); | |
353 | puts(""); | |
354 | } | |
355 | ||
356 | static void test_byaddr(void *handle, | |
357 | const char *module, | |
358 | const void* addr, socklen_t len, | |
359 | int af) { | |
360 | test_gethostbyaddr2_r(handle, module, addr, len, af); | |
361 | puts(""); | |
362 | ||
363 | test_gethostbyaddr_r(handle, module, addr, len, af); | |
364 | puts(""); | |
365 | } | |
366 | ||
9f7672b3 ZJS |
367 | static int make_addresses(struct local_address **addresses) { |
368 | int n; | |
369 | size_t n_alloc; | |
370 | _cleanup_free_ struct local_address *addrs = NULL; | |
371 | ||
372 | n = local_addresses(NULL, 0, AF_UNSPEC, &addrs); | |
373 | if (n < 0) | |
374 | log_info_errno(n, "Failed to query local addresses: %m"); | |
375 | ||
376 | n_alloc = n; /* we _can_ do that */ | |
377 | if (!GREEDY_REALLOC(addrs, n_alloc, n + 3)) | |
378 | return log_oom(); | |
379 | ||
380 | addrs[n++] = (struct local_address) { .family = AF_INET, | |
381 | .address.in = { htobe32(0x7F000001) } }; | |
382 | addrs[n++] = (struct local_address) { .family = AF_INET, | |
383 | .address.in = { htobe32(0x7F000002) } }; | |
384 | addrs[n++] = (struct local_address) { .family = AF_INET6, | |
385 | .address.in6 = in6addr_loopback }; | |
386 | return 0; | |
387 | } | |
388 | ||
389 | static int test_one_module(const char* dir, | |
390 | const char *module, | |
391 | char **names, | |
392 | struct local_address *addresses, | |
393 | int n_addresses) { | |
394 | void *handle; | |
395 | char **name; | |
396 | int i; | |
397 | ||
9f7672b3 ZJS |
398 | log_info("======== %s ========", module); |
399 | ||
400 | handle = open_handle(streq(module, "dns") ? NULL : dir, | |
401 | module, | |
402 | RTLD_LAZY|RTLD_NODELETE); | |
403 | if (!handle) | |
404 | return -EINVAL; | |
405 | ||
406 | STRV_FOREACH(name, names) | |
407 | test_byname(handle, module, *name); | |
408 | ||
409 | for (i = 0; i < n_addresses; i++) | |
410 | test_byaddr(handle, module, | |
411 | &addresses[i].address, | |
412 | FAMILY_ADDRESS_SIZE(addresses[i].family), | |
413 | addresses[i].family); | |
414 | ||
415 | log_info(" "); | |
416 | dlclose(handle); | |
417 | return 0; | |
418 | } | |
419 | ||
420 | static int parse_argv(int argc, char **argv, | |
421 | char ***the_modules, | |
422 | char ***the_names, | |
423 | struct local_address **the_addresses, int *n_addresses) { | |
424 | ||
425 | int r, n = 0; | |
426 | _cleanup_strv_free_ char **modules = NULL, **names = NULL; | |
427 | _cleanup_free_ struct local_address *addrs = NULL; | |
428 | size_t n_allocated = 0; | |
429 | ||
430 | if (argc > 1) | |
431 | modules = strv_new(argv[1], NULL); | |
432 | else | |
433 | modules = strv_new( | |
08540a95 | 434 | #if ENABLE_NSS_MYHOSTNAME |
9f7672b3 | 435 | "myhostname", |
2abb5b3b | 436 | #endif |
08540a95 | 437 | #if ENABLE_NSS_RESOLVE |
9f7672b3 | 438 | "resolve", |
2abb5b3b | 439 | #endif |
08540a95 | 440 | #if ENABLE_NSS_MYMACHINES |
9f7672b3 | 441 | "mymachines", |
2abb5b3b | 442 | #endif |
9f7672b3 ZJS |
443 | "dns", |
444 | NULL); | |
445 | if (!modules) | |
446 | return -ENOMEM; | |
447 | ||
448 | if (argc > 2) { | |
449 | char **name; | |
450 | int family; | |
451 | union in_addr_union address; | |
452 | ||
453 | STRV_FOREACH(name, argv + 2) { | |
454 | r = in_addr_from_string_auto(*name, &family, &address); | |
455 | if (r < 0) { | |
456 | /* assume this is a name */ | |
457 | r = strv_extend(&names, *name); | |
458 | if (r < 0) | |
459 | return r; | |
460 | } else { | |
461 | if (!GREEDY_REALLOC0(addrs, n_allocated, n + 1)) | |
462 | return -ENOMEM; | |
463 | ||
464 | addrs[n++] = (struct local_address) { .family = family, | |
465 | .address = address }; | |
466 | } | |
467 | } | |
468 | } else { | |
469 | _cleanup_free_ char *hostname; | |
2abb5b3b | 470 | |
9f7672b3 ZJS |
471 | hostname = gethostname_malloc(); |
472 | if (!hostname) | |
473 | return -ENOMEM; | |
2abb5b3b | 474 | |
5248e7e1 | 475 | names = strv_new("localhost", "_gateway", "foo_no_such_host", hostname, NULL); |
9f7672b3 ZJS |
476 | if (!names) |
477 | return -ENOMEM; | |
478 | ||
479 | n = make_addresses(&addrs); | |
480 | if (n < 0) | |
481 | return n; | |
482 | } | |
483 | ||
484 | *the_modules = modules; | |
485 | *the_names = names; | |
486 | modules = names = NULL; | |
487 | *the_addresses = addrs; | |
488 | *n_addresses = n; | |
489 | addrs = NULL; | |
490 | return 0; | |
491 | } | |
492 | ||
493 | int main(int argc, char **argv) { | |
494 | _cleanup_free_ char *dir = NULL; | |
495 | _cleanup_strv_free_ char **modules = NULL, **names = NULL; | |
2abb5b3b | 496 | _cleanup_free_ struct local_address *addresses = NULL; |
6a909d41 | 497 | int n_addresses = 0; |
9f7672b3 ZJS |
498 | char **module; |
499 | int r; | |
2abb5b3b ZJS |
500 | |
501 | log_set_max_level(LOG_INFO); | |
502 | log_parse_environment(); | |
503 | ||
9f7672b3 ZJS |
504 | r = parse_argv(argc, argv, &modules, &names, &addresses, &n_addresses); |
505 | if (r < 0) { | |
506 | log_error_errno(r, "Failed to parse arguments: %m"); | |
507 | return EXIT_FAILURE; | |
2abb5b3b ZJS |
508 | } |
509 | ||
9f7672b3 ZJS |
510 | dir = dirname_malloc(argv[0]); |
511 | if (!dir) | |
512 | return EXIT_FAILURE; | |
2abb5b3b | 513 | |
9f7672b3 ZJS |
514 | STRV_FOREACH(module, modules) { |
515 | r = test_one_module(dir, *module, names, addresses, n_addresses); | |
516 | if (r < 0) | |
517 | return EXIT_FAILURE; | |
2abb5b3b ZJS |
518 | } |
519 | ||
520 | return EXIT_SUCCESS; | |
521 | } |