1/* Copyright (C) 1999-2020 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Andreas Jaeger <aj@suse.de>, 1999.
4
5 This program is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; version 2 of the License, or
8 (at your option) any later version.
9
10 This program 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
13 GNU General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <https://www.gnu.org/licenses/>. */
17
18#define PROCINFO_CLASS static
19#include <alloca.h>
20#include <argp.h>
21#include <dirent.h>
22#include <elf.h>
23#include <error.h>
24#include <errno.h>
25#include <inttypes.h>
26#include <libintl.h>
27#include <locale.h>
28#include <stdbool.h>
29#include <stdio.h>
30#include <stdio_ext.h>
31#include <stdlib.h>
32#include <string.h>
33#include <unistd.h>
34#include <stdint.h>
35#include <sys/fcntl.h>
36#include <sys/mman.h>
37#include <sys/stat.h>
38#include <sys/types.h>
39#include <glob.h>
40#include <libgen.h>
41
42#include <ldconfig.h>
43#include <dl-cache.h>
44
45#include <dl-procinfo.h>
46
47#ifdef _DL_FIRST_PLATFORM
48# define _DL_FIRST_EXTRA (_DL_FIRST_PLATFORM + _DL_PLATFORMS_COUNT)
49#else
50# define _DL_FIRST_EXTRA _DL_HWCAP_COUNT
51#endif
52
53#ifndef LD_SO_CONF
54# define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
55#endif
56
57/* Get libc version number. */
58#include <version.h>
59
60#define PACKAGE _libc_intl_domainname
61
62static const struct
63{
64 const char *name;
65 int flag;
66} lib_types[] =
67{
68 {"libc4", FLAG_LIBC4},
69 {"libc5", FLAG_ELF_LIBC5},
70 {"libc6", FLAG_ELF_LIBC6},
71 {"glibc2", FLAG_ELF_LIBC6}
72};
73
74
75/* List of directories to handle. */
76struct dir_entry
77{
78 char *path;
79 int flag;
80 ino64_t ino;
81 dev_t dev;
82 struct dir_entry *next;
83};
84
85/* The list is unsorted, contains no duplicates. Entries are added at
86 the end. */
87static struct dir_entry *dir_entries;
88
89/* Flags for different options. */
90/* Print Cache. */
91static int opt_print_cache;
92
93/* Be verbose. */
94int opt_verbose;
95
96/* Format to support. */
97/* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
98int opt_format = 1;
99
100/* Build cache. */
101static int opt_build_cache = 1;
102
103/* Enable symbolic link processing. If set, create or update symbolic
104 links, and remove stale symbolic links. */
105static int opt_link = 1;
106
107/* Only process directories specified on the command line. */
108static int opt_only_cline;
109
110/* Path to root for chroot. */
111static char *opt_chroot;
112
113/* Manually link given shared libraries. */
114static int opt_manual_link;
115
116/* Should we ignore an old auxiliary cache file? */
117static int opt_ignore_aux_cache;
118
119/* Cache file to use. */
120static char *cache_file;
121
122/* Configuration file. */
123static const char *config_file;
124
125/* Mask to use for important hardware capabilities. */
126static unsigned long int hwcap_mask = HWCAP_IMPORTANT;
127
128/* Configuration-defined capabilities defined in kernel vDSOs. */
129static const char *hwcap_extra[64 - _DL_FIRST_EXTRA];
130
131/* Name and version of program. */
132static void print_version (FILE *stream, struct argp_state *state);
133void (*argp_program_version_hook) (FILE *, struct argp_state *)
134 = print_version;
135
136/* Function to print some extra text in the help message. */
137static char *more_help (int key, const char *text, void *input);
138
139/* Definitions of arguments for argp functions. */
140static const struct argp_option options[] =
141{
142 { "print-cache", 'p', NULL, 0, N_("Print cache"), 0},
143 { "verbose", 'v', NULL, 0, N_("Generate verbose messages"), 0},
144 { NULL, 'N', NULL, 0, N_("Don't build cache"), 0},
145 { NULL, 'X', NULL, 0, N_("Don't update symbolic links"), 0},
146 { NULL, 'r', N_("ROOT"), 0, N_("Change to and use ROOT as root directory"), 0},
147 { NULL, 'C', N_("CACHE"), 0, N_("Use CACHE as cache file"), 0},
148 { NULL, 'f', N_("CONF"), 0, N_("Use CONF as configuration file"), 0},
149 { NULL, 'n', NULL, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
150 { NULL, 'l', NULL, 0, N_("Manually link individual libraries."), 0},
151 { "format", 'c', N_("FORMAT"), 0, N_("Format to use: new, old or compat (default)"), 0},
152 { "ignore-aux-cache", 'i', NULL, 0, N_("Ignore auxiliary cache file"), 0},
153 { NULL, 0, NULL, 0, NULL, 0 }
154};
155
156#define PROCINFO_CLASS static
157#include <dl-procinfo.c>
158
159/* Short description of program. */
160static const char doc[] = N_("Configure Dynamic Linker Run Time Bindings.");
161
162/* Prototype for option handler. */
163static error_t parse_opt (int key, char *arg, struct argp_state *state);
164
165/* Data structure to communicate with argp functions. */
166static struct argp argp =
167{
168 options, parse_opt, NULL, doc, NULL, more_help, NULL
169};
170
171/* Check if string corresponds to an important hardware capability or
172 a platform. */
173static int
174is_hwcap_platform (const char *name)
175{
176 int hwcap_idx = _dl_string_hwcap (name);
177
178 /* Is this a normal hwcap for the machine like "fpu?" */
179 if (hwcap_idx != -1 && ((1 << hwcap_idx) & hwcap_mask))
180 return 1;
181
182 /* Is this a platform pseudo-hwcap like "i686?" */
183 hwcap_idx = _dl_string_platform (name);
184 if (hwcap_idx != -1)
185 return 1;
186
187 /* Is this one of the extra pseudo-hwcaps that we map beyond
188 _DL_FIRST_EXTRA like "tls", or "nosegneg?" */
189 for (hwcap_idx = _DL_FIRST_EXTRA; hwcap_idx < 64; ++hwcap_idx)
190 if (hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA] != NULL
191 && !strcmp (name, hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA]))
192 return 1;
193
194 return 0;
195}
196
197/* Get hwcap (including platform) encoding of path. */
198static uint64_t
199path_hwcap (const char *path)
200{
201 char *str = xstrdup (path);
202 char *ptr;
203 uint64_t hwcap = 0;
204 uint64_t h;
205
206 size_t len;
207
208 len = strlen (str);
209 if (str[len] == '/')
210 str[len] = '\0';
211
212 /* Search pathname from the end and check for hwcap strings. */
213 for (;;)
214 {
215 ptr = strrchr (str, '/');
216
217 if (ptr == NULL)
218 break;
219
220 h = _dl_string_hwcap (ptr + 1);
221
222 if (h == (uint64_t) -1)
223 {
224 h = _dl_string_platform (ptr + 1);
225 if (h == (uint64_t) -1)
226 {
227 for (h = _DL_FIRST_EXTRA; h < 64; ++h)
228 if (hwcap_extra[h - _DL_FIRST_EXTRA] != NULL
229 && !strcmp (ptr + 1, hwcap_extra[h - _DL_FIRST_EXTRA]))
230 break;
231 if (h == 64)
232 break;
233 }
234 }
235 hwcap += 1ULL << h;
236
237 /* Search the next part of the path. */
238 *ptr = '\0';
239 }
240
241 free (str);
242 return hwcap;
243}
244
245/* Handle program arguments. */
246static error_t
247parse_opt (int key, char *arg, struct argp_state *state)
248{
249 switch (key)
250 {
251 case 'C':
252 cache_file = arg;
253 /* Ignore auxiliary cache since we use non-standard cache. */
254 opt_ignore_aux_cache = 1;
255 break;
256 case 'f':
257 config_file = arg;
258 break;
259 case 'i':
260 opt_ignore_aux_cache = 1;
261 break;
262 case 'l':
263 opt_manual_link = 1;
264 break;
265 case 'N':
266 opt_build_cache = 0;
267 break;
268 case 'n':
269 opt_build_cache = 0;
270 opt_only_cline = 1;
271 break;
272 case 'p':
273 opt_print_cache = 1;
274 break;
275 case 'r':
276 opt_chroot = arg;
277 break;
278 case 'v':
279 opt_verbose = 1;
280 break;
281 case 'X':
282 opt_link = 0;
283 break;
284 case 'c':
285 if (strcmp (arg, "old") == 0)
286 opt_format = 0;
287 else if (strcmp (arg, "compat") == 0)
288 opt_format = 1;
289 else if (strcmp (arg, "new") == 0)
290 opt_format = 2;
291 break;
292 default:
293 return ARGP_ERR_UNKNOWN;
294 }
295
296 return 0;
297}
298
299/* Print bug-reporting information in the help message. */
300static char *
301more_help (int key, const char *text, void *input)
302{
303 char *tp = NULL;
304 switch (key)
305 {
306 case ARGP_KEY_HELP_EXTRA:
307 /* We print some extra information. */
308 if (asprintf (&tp, gettext ("\
309For bug reporting instructions, please see:\n\
310%s.\n"), REPORT_BUGS_TO) < 0)
311 return NULL;
312 return tp;
313 default:
314 break;
315 }
316 return (char *) text;
317}
318
319/* Print the version information. */
320static void
321print_version (FILE *stream, struct argp_state *state)
322{
323 fprintf (stream, "ldconfig %s%s\n", PKGVERSION, VERSION);
324 fprintf (stream, gettext ("\
325Copyright (C) %s Free Software Foundation, Inc.\n\
326This is free software; see the source for copying conditions. There is NO\n\
327warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
328"), "2020");
329 fprintf (stream, gettext ("Written by %s.\n"),
330 "Andreas Jaeger");
331}
332
333/* Add a single directory entry. */
334static void
335add_single_dir (struct dir_entry *entry, int verbose)
336{
337 struct dir_entry *ptr, *prev;
338
339 ptr = dir_entries;
340 prev = ptr;
341 while (ptr != NULL)
342 {
343 /* Check for duplicates. */
344 if (ptr->ino == entry->ino && ptr->dev == entry->dev)
345 {
346 if (opt_verbose && verbose)
347 error (0, 0, _("Path `%s' given more than once"), entry->path);
348 /* Use the newer information. */
349 ptr->flag = entry->flag;
350 free (entry->path);
351 free (entry);
352 break;
353 }
354 prev = ptr;
355 ptr = ptr->next;
356 }
357 /* Is this the first entry? */
358 if (ptr == NULL && dir_entries == NULL)
359 dir_entries = entry;
360 else if (ptr == NULL)
361 prev->next = entry;
362}
363
364/* Add one directory to the list of directories to process. */
365static void
366add_dir (const char *line)
367{
368 unsigned int i;
369 struct dir_entry *entry = xmalloc (sizeof (struct dir_entry));
370 entry->next = NULL;
371
372 /* Search for an '=' sign. */
373 entry->path = xstrdup (line);
374 char *equal_sign = strchr (entry->path, '=');
375 if (equal_sign)
376 {
377 *equal_sign = '\0';
378 ++equal_sign;
379 entry->flag = FLAG_ANY;
380 for (i = 0; i < sizeof (lib_types) / sizeof (lib_types[0]); ++i)
381 if (strcmp (equal_sign, lib_types[i].name) == 0)
382 {
383 entry->flag = lib_types[i].flag;
384 break;
385 }
386 if (entry->flag == FLAG_ANY)
387 error (0, 0, _("%s is not a known library type"), equal_sign);
388 }
389 else
390 {
391 entry->flag = FLAG_ANY;
392 }
393
394 /* Canonify path: for now only remove leading and trailing
395 whitespace and the trailing slashes. */
396 i = strlen (entry->path);
397
398 while (i > 0 && isspace (entry->path[i - 1]))
399 entry->path[--i] = '\0';
400
401 while (i > 0 && entry->path[i - 1] == '/')
402 entry->path[--i] = '\0';
403
404 if (i == 0)
405 return;
406
407 char *path = entry->path;
408 if (opt_chroot)
409 path = chroot_canon (opt_chroot, path);
410
411 struct stat64 stat_buf;
412 if (path == NULL || stat64 (path, &stat_buf))
413 {
414 if (opt_verbose)
415 error (0, errno, _("Can't stat %s"), entry->path);
416 free (entry->path);
417 free (entry);
418 }
419 else
420 {
421 entry->ino = stat_buf.st_ino;
422 entry->dev = stat_buf.st_dev;
423
424 add_single_dir (entry, 1);
425 }
426
427 if (opt_chroot)
428 free (path);
429}
430
431
432static int
433chroot_stat (const char *real_path, const char *path, struct stat64 *st)
434{
435 int ret;
436 char *canon_path;
437
438 if (!opt_chroot)
439 return stat64 (real_path, st);
440
441 ret = lstat64 (real_path, st);
442 if (ret || !S_ISLNK (st->st_mode))
443 return ret;
444
445 canon_path = chroot_canon (opt_chroot, path);
446 if (canon_path == NULL)
447 return -1;
448
449 ret = stat64 (canon_path, st);
450 free (canon_path);
451 return ret;
452}
453
454/* Create a symbolic link from soname to libname in directory path. */
455static void
456create_links (const char *real_path, const char *path, const char *libname,
457 const char *soname)
458{
459 char *full_libname, *full_soname;
460 char *real_full_libname, *real_full_soname;
461 struct stat64 stat_lib, stat_so, lstat_so;
462 int do_link = 1;
463 int do_remove = 1;
464 /* XXX: The logics in this function should be simplified. */
465
466 /* Get complete path. */
467 full_libname = alloca (strlen (path) + strlen (libname) + 2);
468 full_soname = alloca (strlen (path) + strlen (soname) + 2);
469 sprintf (full_libname, "%s/%s", path, libname);
470 sprintf (full_soname, "%s/%s", path, soname);
471 if (opt_chroot)
472 {
473 real_full_libname = alloca (strlen (real_path) + strlen (libname) + 2);
474 real_full_soname = alloca (strlen (real_path) + strlen (soname) + 2);
475 sprintf (real_full_libname, "%s/%s", real_path, libname);
476 sprintf (real_full_soname, "%s/%s", real_path, soname);
477 }
478 else
479 {
480 real_full_libname = full_libname;
481 real_full_soname = full_soname;
482 }
483
484 /* Does soname already exist and point to the right library? */
485 if (chroot_stat (real_full_soname, full_soname, &stat_so) == 0)
486 {
487 if (chroot_stat (real_full_libname, full_libname, &stat_lib))
488 {
489 error (0, 0, _("Can't stat %s\n"), full_libname);
490 return;
491 }
492 if (stat_lib.st_dev == stat_so.st_dev
493 && stat_lib.st_ino == stat_so.st_ino)
494 /* Link is already correct. */
495 do_link = 0;
496 else if (lstat64 (full_soname, &lstat_so) == 0
497 && !S_ISLNK (lstat_so.st_mode))
498 {
499 error (0, 0, _("%s is not a symbolic link\n"), full_soname);
500 do_link = 0;
501 do_remove = 0;
502 }
503 }
504 else if (lstat64 (real_full_soname, &lstat_so) != 0
505 || !S_ISLNK (lstat_so.st_mode))
506 /* Unless it is a stale symlink, there is no need to remove. */
507 do_remove = 0;
508
509 if (opt_verbose)
510 printf ("\t%s -> %s", soname, libname);
511
512 if (do_link && opt_link)
513 {
514 /* Remove old link. */
515 if (do_remove)
516 if (unlink (real_full_soname))
517 {
518 error (0, 0, _("Can't unlink %s"), full_soname);
519 do_link = 0;
520 }
521 /* Create symbolic link. */
522 if (do_link && symlink (libname, real_full_soname))
523 {
524 error (0, 0, _("Can't link %s to %s"), full_soname, libname);
525 do_link = 0;
526 }
527 if (opt_verbose)
528 {
529 if (do_link)
530 fputs (_(" (changed)\n"), stdout);
531 else
532 fputs (_(" (SKIPPED)\n"), stdout);
533 }
534 }
535 else if (opt_verbose)
536 fputs ("\n", stdout);
537}
538
539/* Manually link the given library. */
540static void
541manual_link (char *library)
542{
543 char *path;
544 char *real_path;
545 char *real_library;
546 char *libname;
547 char *soname;
548 struct stat64 stat_buf;
549 int flag;
550 unsigned int osversion;
551
552 /* Prepare arguments for create_links call. Split library name in
553 directory and filename first. Since path is allocated, we've got
554 to be careful to free at the end. */
555 path = xstrdup (library);
556 libname = strrchr (path, '/');
557
558 if (libname)
559 {
560 /* Successfully split names. Check if path is just "/" to avoid
561 an empty path. */
562 if (libname == path)
563 {
564 libname = library + 1;
565 path = xrealloc (path, 2);
566 strcpy (path, "/");
567 }
568 else
569 {
570 *libname = '\0';
571 ++libname;
572 }
573 }
574 else
575 {
576 /* There's no path, construct one. */
577 libname = library;
578 path = xrealloc (path, 2);
579 strcpy (path, ".");
580 }
581
582 if (opt_chroot)
583 {
584 real_path = chroot_canon (opt_chroot, path);
585 if (real_path == NULL)
586 {
587 error (0, errno, _("Can't find %s"), path);
588 free (path);
589 return;
590 }
591 real_library = alloca (strlen (real_path) + strlen (libname) + 2);
592 sprintf (real_library, "%s/%s", real_path, libname);
593 }
594 else
595 {
596 real_path = path;
597 real_library = library;
598 }
599
600 /* Do some sanity checks first. */
601 if (lstat64 (real_library, &stat_buf))
602 {
603 error (0, errno, _("Cannot lstat %s"), library);
604 free (path);
605 return;
606 }
607 /* We don't want links here! */
608 else if (!S_ISREG (stat_buf.st_mode))
609 {
610 error (0, 0, _("Ignored file %s since it is not a regular file."),
611 library);
612 free (path);
613 return;
614 }
615
616 if (process_file (real_library, library, libname, &flag, &osversion,
617 &soname, 0, &stat_buf))
618 {
619 error (0, 0, _("No link created since soname could not be found for %s"),
620 library);
621 free (path);
622 return;
623 }
624 if (soname == NULL)
625 soname = implicit_soname (libname, flag);
626 create_links (real_path, path, libname, soname);
627 free (soname);
628 free (path);
629}
630
631
632/* Read a whole directory and search for libraries.
633 The purpose is two-fold:
634 - search for libraries which will be added to the cache
635 - create symbolic links to the soname for each library
636
637 This has to be done separatly for each directory.
638
639 To keep track of which libraries to add to the cache and which
640 links to create, we save a list of all libraries.
641
642 The algorithm is basically:
643 for all libraries in the directory do
644 get soname of library
645 if soname is already in list
646 if new library is newer, replace entry
647 otherwise ignore this library
648 otherwise add library to list
649
650 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
651 exist and both have the same soname, e.g. libxy.so, a symbolic link
652 is created from libxy.so.1.2 (the newer one) to libxy.so.
653 libxy.so.1.2 and libxy.so are added to the cache - but not
654 libxy.so.1.1. */
655
656/* Information for one library. */
657struct dlib_entry
658{
659 char *name;
660 char *soname;
661 int flag;
662 int is_link;
663 unsigned int osversion;
664 struct dlib_entry *next;
665};
666
667
668static void
669search_dir (const struct dir_entry *entry)
670{
671 uint64_t hwcap = path_hwcap (entry->path);
672 if (opt_verbose)
673 {
674 if (hwcap != 0)
675 printf ("%s: (hwcap: %#.16" PRIx64 ")\n", entry->path, hwcap);
676 else
677 printf ("%s:\n", entry->path);
678 }
679
680 char *dir_name;
681 char *real_file_name;
682 size_t real_file_name_len;
683 size_t file_name_len = PATH_MAX;
684 char *file_name = alloca (file_name_len);
685 if (opt_chroot)
686 {
687 dir_name = chroot_canon (opt_chroot, entry->path);
688 real_file_name_len = PATH_MAX;
689 real_file_name = alloca (real_file_name_len);
690 }
691 else
692 {
693 dir_name = entry->path;
694 real_file_name_len = 0;
695 real_file_name = file_name;
696 }
697
698 DIR *dir;
699 if (dir_name == NULL || (dir = opendir (dir_name)) == NULL)
700 {
701 if (opt_verbose)
702 error (0, errno, _("Can't open directory %s"), entry->path);
703 if (opt_chroot && dir_name)
704 free (dir_name);
705 return;
706 }
707
708 struct dirent64 *direntry;
709 struct dlib_entry *dlibs = NULL;
710 while ((direntry = readdir64 (dir)) != NULL)
711 {
712 int flag;
713 /* We only look at links and regular files. */
714 if (direntry->d_type != DT_UNKNOWN
715 && direntry->d_type != DT_LNK
716 && direntry->d_type != DT_REG
717 && direntry->d_type != DT_DIR)
718 continue;
719 /* Does this file look like a shared library or is it a hwcap
720 subdirectory? The dynamic linker is also considered as
721 shared library. */
722 if (((strncmp (direntry->d_name, "lib", 3) != 0
723 && strncmp (direntry->d_name, "ld-", 3) != 0)
724 || strstr (direntry->d_name, ".so") == NULL)
725 && (direntry->d_type == DT_REG
726 || !is_hwcap_platform (direntry->d_name)))
727 continue;
728
729 size_t len = strlen (direntry->d_name);
730 /* Skip temporary files created by the prelink program. Files with
731 names like these are never really DSOs we want to look at. */
732 if (len >= sizeof (".#prelink#") - 1)
733 {
734 if (strcmp (direntry->d_name + len - sizeof (".#prelink#") + 1,
735 ".#prelink#") == 0)
736 continue;
737 if (len >= sizeof (".#prelink#.XXXXXX") - 1
738 && memcmp (direntry->d_name + len - sizeof (".#prelink#.XXXXXX")
739 + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
740 continue;
741 }
742 len += strlen (entry->path) + 2;
743 if (len > file_name_len)
744 {
745 file_name_len = len;
746 file_name = alloca (file_name_len);
747 if (!opt_chroot)
748 real_file_name = file_name;
749 }
750 sprintf (file_name, "%s/%s", entry->path, direntry->d_name);
751 if (opt_chroot)
752 {
753 len = strlen (dir_name) + strlen (direntry->d_name) + 2;
754 if (len > real_file_name_len)
755 {
756 real_file_name_len = len;
757 real_file_name = alloca (real_file_name_len);
758 }
759 sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);
760 }
761
762 struct stat64 lstat_buf;
763 /* We optimize and try to do the lstat call only if needed. */
764 if (direntry->d_type != DT_UNKNOWN)
765 lstat_buf.st_mode = DTTOIF (direntry->d_type);
766 else
767 if (__glibc_unlikely (lstat64 (real_file_name, &lstat_buf)))
768 {
769 error (0, errno, _("Cannot lstat %s"), file_name);
770 continue;
771 }
772
773 struct stat64 stat_buf;
774 int is_dir;
775 int is_link = S_ISLNK (lstat_buf.st_mode);
776 if (is_link)
777 {
778 /* In case of symlink, we check if the symlink refers to
779 a directory. */
780 char *target_name = real_file_name;
781 if (opt_chroot)
782 {
783 target_name = chroot_canon (opt_chroot, file_name);
784 if (target_name == NULL)
785 {
786 if (strstr (file_name, ".so") == NULL)
787 error (0, 0, _("Input file %s not found.\n"), file_name);
788 continue;
789 }
790 }
791 if (__glibc_unlikely (stat64 (target_name, &stat_buf)))
792 {
793 if (opt_verbose)
794 error (0, errno, _("Cannot stat %s"), file_name);
795
796 /* Remove stale symlinks. */
797 if (opt_link && strstr (direntry->d_name, ".so."))
798 unlink (real_file_name);
799 continue;
800 }
801 is_dir = S_ISDIR (stat_buf.st_mode);
802
803 /* lstat_buf is later stored, update contents. */
804 lstat_buf.st_dev = stat_buf.st_dev;
805 lstat_buf.st_ino = stat_buf.st_ino;
806 lstat_buf.st_size = stat_buf.st_size;
807 lstat_buf.st_ctime = stat_buf.st_ctime;
808 }
809 else
810 is_dir = S_ISDIR (lstat_buf.st_mode);
811
812 if (is_dir && is_hwcap_platform (direntry->d_name))
813 {
814 /* Handle subdirectory later. */
815 struct dir_entry *new_entry;
816
817 new_entry = xmalloc (sizeof (struct dir_entry));
818 new_entry->path = xstrdup (file_name);
819 new_entry->flag = entry->flag;
820 new_entry->next = NULL;
821 if (!is_link
822 && direntry->d_type != DT_UNKNOWN
823 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
824 {
825 error (0, errno, _("Cannot lstat %s"), file_name);
826 free (new_entry->path);
827 free (new_entry);
828 continue;
829 }
830 new_entry->ino = lstat_buf.st_ino;
831 new_entry->dev = lstat_buf.st_dev;
832 add_single_dir (new_entry, 0);
833 continue;
834 }
835 else if (!S_ISREG (lstat_buf.st_mode) && !is_link)
836 continue;
837
838 char *real_name;
839 if (opt_chroot && is_link)
840 {
841 real_name = chroot_canon (opt_chroot, file_name);
842 if (real_name == NULL)
843 {
844 if (strstr (file_name, ".so") == NULL)
845 error (0, 0, _("Input file %s not found.\n"), file_name);
846 continue;
847 }
848 }
849 else
850 real_name = real_file_name;
851
852 /* Call lstat64 if not done yet. */
853 if (!is_link
854 && direntry->d_type != DT_UNKNOWN
855 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
856 {
857 error (0, errno, _("Cannot lstat %s"), file_name);
858 continue;
859 }
860
861 /* First search whether the auxiliary cache contains this
862 library already and it's not changed. */
863 char *soname;
864 unsigned int osversion;
865 if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))
866 {
867 if (process_file (real_name, file_name, direntry->d_name, &flag,
868 &osversion, &soname, is_link, &lstat_buf))
869 {
870 if (real_name != real_file_name)
871 free (real_name);
872 continue;
873 }
874 else if (opt_build_cache)
875 add_to_aux_cache (&lstat_buf, flag, osversion, soname);
876 }
877
878 if (soname == NULL)
879 soname = implicit_soname (direntry->d_name, flag);
880
881 /* A link may just point to itself. */
882 if (is_link)
883 {
884 /* If the path the link points to isn't its soname or it is not
885 the .so symlink for ld(1), we treat it as a normal file.
886
887 You should always do this:
888
889 libfoo.so -> SONAME -> Arbitrary package-chosen name.
890
891 e.g. libfoo.so -> libfoo.so.1 -> libfooimp.so.9.99.
892 Given a SONAME of libfoo.so.1.
893
894 You should *never* do this:
895
896 libfoo.so -> libfooimp.so.9.99
897
898 If you do, and your SONAME is libfoo.so.1, then libfoo.so
899 fails to point at the SONAME. In that case ldconfig may consider
900 libfoo.so as another implementation of SONAME and will create
901 symlinks against it causing problems when you try to upgrade
902 or downgrade. The problems will arise because ldconfig will,
903 depending on directory ordering, creat symlinks against libfoo.so
904 e.g. libfoo.so.1.2 -> libfoo.so, but when libfoo.so is removed
905 (typically by the removal of a development pacakge not required
906 for the runtime) it will break the libfoo.so.1.2 symlink and the
907 application will fail to start. */
908 const char *real_base_name = basename (real_file_name);
909
910 if (strcmp (real_base_name, soname) != 0)
911 {
912 len = strlen (real_base_name);
913 if (len < strlen (".so")
914 || strcmp (real_base_name + len - strlen (".so"), ".so") != 0
915 || strncmp (real_base_name, soname, len) != 0)
916 is_link = 0;
917 }
918 }
919
920 if (real_name != real_file_name)
921 free (real_name);
922
923 if (is_link)
924 {
925 free (soname);
926 soname = xstrdup (direntry->d_name);
927 }
928
929 if (flag == FLAG_ELF
930 && (entry->flag == FLAG_ELF_LIBC5
931 || entry->flag == FLAG_ELF_LIBC6))
932 flag = entry->flag;
933
934 /* Some sanity checks to print warnings. */
935 if (opt_verbose)
936 {
937 if (flag == FLAG_ELF_LIBC5 && entry->flag != FLAG_ELF_LIBC5
938 && entry->flag != FLAG_ANY)
939 error (0, 0, _("libc5 library %s in wrong directory"), file_name);
940 if (flag == FLAG_ELF_LIBC6 && entry->flag != FLAG_ELF_LIBC6
941 && entry->flag != FLAG_ANY)
942 error (0, 0, _("libc6 library %s in wrong directory"), file_name);
943 if (flag == FLAG_LIBC4 && entry->flag != FLAG_LIBC4
944 && entry->flag != FLAG_ANY)
945 error (0, 0, _("libc4 library %s in wrong directory"), file_name);
946 }
947
948 /* Add library to list. */
949 struct dlib_entry *dlib_ptr;
950 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
951 {
952 /* Is soname already in list? */
953 if (strcmp (dlib_ptr->soname, soname) == 0)
954 {
955 /* Prefer a file to a link, otherwise check which one
956 is newer. */
957 if ((!is_link && dlib_ptr->is_link)
958 || (is_link == dlib_ptr->is_link
959 && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
960 {
961 /* It's newer - add it. */
962 /* Flag should be the same - sanity check. */
963 if (dlib_ptr->flag != flag)
964 {
965 if (dlib_ptr->flag == FLAG_ELF
966 && (flag == FLAG_ELF_LIBC5 || flag == FLAG_ELF_LIBC6))
967 dlib_ptr->flag = flag;
968 else if ((dlib_ptr->flag == FLAG_ELF_LIBC5
969 || dlib_ptr->flag == FLAG_ELF_LIBC6)
970 && flag == FLAG_ELF)
971 dlib_ptr->flag = flag;
972 else
973 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
974 dlib_ptr->name, direntry->d_name,
975 entry->path);
976 }
977 free (dlib_ptr->name);
978 dlib_ptr->name = xstrdup (direntry->d_name);
979 dlib_ptr->is_link = is_link;
980 dlib_ptr->osversion = osversion;
981 }
982 /* Don't add this library, abort loop. */
983 /* Also free soname, since it's dynamically allocated. */
984 free (soname);
985 break;
986 }
987 }
988 /* Add the library if it's not already in. */
989 if (dlib_ptr == NULL)
990 {
991 dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
992 dlib_ptr->name = xstrdup (direntry->d_name);
993 dlib_ptr->soname = soname;
994 dlib_ptr->flag = flag;
995 dlib_ptr->is_link = is_link;
996 dlib_ptr->osversion = osversion;
997 /* Add at head of list. */
998 dlib_ptr->next = dlibs;
999 dlibs = dlib_ptr;
1000 }
1001 }
1002
1003 closedir (dir);
1004
1005 /* Now dlibs contains a list of all libs - add those to the cache
1006 and created all symbolic links. */
1007 struct dlib_entry *dlib_ptr;
1008 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
1009 {
1010 /* Don't create links to links. */
1011 if (dlib_ptr->is_link == 0)
1012 create_links (dir_name, entry->path, dlib_ptr->name,
1013 dlib_ptr->soname);
1014 if (opt_build_cache)
1015 add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag,
1016 dlib_ptr->osversion, hwcap);
1017 }
1018
1019 /* Free all resources. */
1020 while (dlibs)
1021 {
1022 dlib_ptr = dlibs;
1023 free (dlib_ptr->soname);
1024 free (dlib_ptr->name);
1025 dlibs = dlibs->next;
1026 free (dlib_ptr);
1027 }
1028
1029 if (opt_chroot && dir_name)
1030 free (dir_name);
1031}
1032
1033/* Search through all libraries. */
1034static void
1035search_dirs (void)
1036{
1037 struct dir_entry *entry;
1038
1039 for (entry = dir_entries; entry != NULL; entry = entry->next)
1040 search_dir (entry);
1041
1042 /* Free all allocated memory. */
1043 while (dir_entries)
1044 {
1045 entry = dir_entries;
1046 dir_entries = dir_entries->next;
1047 free (entry->path);
1048 free (entry);
1049 }
1050}
1051
1052
1053static void parse_conf_include (const char *config_file, unsigned int lineno,
1054 bool do_chroot, const char *pattern);
1055
1056/* Parse configuration file. */
1057static void
1058parse_conf (const char *filename, bool do_chroot)
1059{
1060 FILE *file = NULL;
1061 char *line = NULL;
1062 const char *canon;
1063 size_t len = 0;
1064 unsigned int lineno;
1065
1066 if (do_chroot && opt_chroot)
1067 {
1068 canon = chroot_canon (opt_chroot, filename);
1069 if (canon)
1070 file = fopen (canon, "r");
1071 else
1072 canon = filename;
1073 }
1074 else
1075 {
1076 canon = filename;
1077 file = fopen (filename, "r");
1078 }
1079
1080 if (file == NULL)
1081 {
1082 if (errno != ENOENT)
1083 error (0, errno, _("\
1084Warning: ignoring configuration file that cannot be opened: %s"),
1085 canon);
1086 if (canon != filename)
1087 free ((char *) canon);
1088 return;
1089 }
1090
1091 /* No threads use this stream. */
1092 __fsetlocking (file, FSETLOCKING_BYCALLER);
1093
1094 if (canon != filename)
1095 free ((char *) canon);
1096
1097 lineno = 0;
1098 do
1099 {
1100 ssize_t n = getline (&line, &len, file);
1101 if (n < 0)
1102 break;
1103
1104 ++lineno;
1105 if (line[n - 1] == '\n')
1106 line[n - 1] = '\0';
1107
1108 /* Because the file format does not know any form of quoting we
1109 can search forward for the next '#' character and if found
1110 make it terminating the line. */
1111 *strchrnul (line, '#') = '\0';
1112
1113 /* Remove leading whitespace. NUL is no whitespace character. */
1114 char *cp = line;
1115 while (isspace (*cp))
1116 ++cp;
1117
1118 /* If the line is blank it is ignored. */
1119 if (cp[0] == '\0')
1120 continue;
1121
1122 if (!strncmp (cp, "include", 7) && isblank (cp[7]))
1123 {
1124 char *dir;
1125 cp += 8;
1126 while ((dir = strsep (&cp, " \t")) != NULL)
1127 if (dir[0] != '\0')
1128 parse_conf_include (filename, lineno, do_chroot, dir);
1129 }
1130 else if (!strncasecmp (cp, "hwcap", 5) && isblank (cp[5]))
1131 {
1132 cp += 6;
1133 char *p, *name = NULL;
1134 unsigned long int n = strtoul (cp, &cp, 0);
1135 if (cp != NULL && isblank (*cp))
1136 while ((p = strsep (&cp, " \t")) != NULL)
1137 if (p[0] != '\0')
1138 {
1139 if (name == NULL)
1140 name = p;
1141 else
1142 {
1143 name = NULL;
1144 break;
1145 }
1146 }
1147 if (name == NULL)
1148 {
1149 error (EXIT_FAILURE, 0, _("%s:%u: bad syntax in hwcap line"),
1150 filename, lineno);
1151 break;
1152 }
1153 if (n >= (64 - _DL_FIRST_EXTRA))
1154 error (EXIT_FAILURE, 0,
1155 _("%s:%u: hwcap index %lu above maximum %u"),
1156 filename, lineno, n, 64 - _DL_FIRST_EXTRA - 1);
1157 if (hwcap_extra[n] == NULL)
1158 {
1159 for (unsigned long int h = 0; h < (64 - _DL_FIRST_EXTRA); ++h)
1160 if (hwcap_extra[h] != NULL && !strcmp (name, hwcap_extra[h]))
1161 error (EXIT_FAILURE, 0,
1162 _("%s:%u: hwcap index %lu already defined as %s"),
1163 filename, lineno, h, name);
1164 hwcap_extra[n] = xstrdup (name);
1165 }
1166 else
1167 {
1168 if (strcmp (name, hwcap_extra[n]))
1169 error (EXIT_FAILURE, 0,
1170 _("%s:%u: hwcap index %lu already defined as %s"),
1171 filename, lineno, n, hwcap_extra[n]);
1172 if (opt_verbose)
1173 error (0, 0, _("%s:%u: duplicate hwcap %lu %s"),
1174 filename, lineno, n, name);
1175 }
1176 }
1177 else
1178 add_dir (cp);
1179 }
1180 while (!feof_unlocked (file));
1181
1182 /* Free buffer and close file. */
1183 free (line);
1184 fclose (file);
1185}
1186
1187/* Handle one word in an `include' line, a glob pattern of additional
1188 config files to read. */
1189static void
1190parse_conf_include (const char *config_file, unsigned int lineno,
1191 bool do_chroot, const char *pattern)
1192{
1193 if (opt_chroot && pattern[0] != '/')
1194 error (EXIT_FAILURE, 0,
1195 _("need absolute file name for configuration file when using -r"));
1196
1197 char *copy = NULL;
1198 if (pattern[0] != '/' && strchr (config_file, '/') != NULL)
1199 {
1200 if (asprintf (&copy, "%s/%s", dirname (strdupa (config_file)),
1201 pattern) < 0)
1202 error (EXIT_FAILURE, 0, _("memory exhausted"));
1203 pattern = copy;
1204 }
1205
1206 glob64_t gl;
1207 int result;
1208 if (do_chroot && opt_chroot)
1209 {
1210 char *canon = chroot_canon (opt_chroot, pattern);
1211 if (canon == NULL)
1212 return;
1213 result = glob64 (canon, 0, NULL, &gl);
1214 free (canon);
1215 }
1216 else
1217 result = glob64 (pattern, 0, NULL, &gl);
1218
1219 switch (result)
1220 {
1221 case 0:
1222 for (size_t i = 0; i < gl.gl_pathc; ++i)
1223 parse_conf (gl.gl_pathv[i], false);
1224 globfree64 (&gl);
1225 break;
1226
1227 case GLOB_NOMATCH:
1228 break;
1229
1230 case GLOB_NOSPACE:
1231 errno = ENOMEM;
1232 /* Fall through. */
1233 case GLOB_ABORTED:
1234 if (opt_verbose)
1235 error (0, errno, _("%s:%u: cannot read directory %s"),
1236 config_file, lineno, pattern);
1237 break;
1238
1239 default:
1240 abort ();
1241 break;
1242 }
1243
1244 free (copy);
1245}
1246
1247/* Honour LD_HWCAP_MASK. */
1248static void
1249set_hwcap (void)
1250{
1251 char *mask = getenv ("LD_HWCAP_MASK");
1252
1253 if (mask)
1254 hwcap_mask = strtoul (mask, NULL, 0);
1255}
1256
1257
1258int
1259main (int argc, char **argv)
1260{
1261 /* Set locale via LC_ALL. */
1262 setlocale (LC_ALL, "");
1263
1264 /* But keep the C collation. That way `include' directives using
1265 globbing patterns are processed in a locale-independent order. */
1266 setlocale (LC_COLLATE, "C");
1267
1268 /* Set the text message domain. */
1269 textdomain (_libc_intl_domainname);
1270
1271 /* Parse and process arguments. */
1272 int remaining;
1273 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1274
1275 /* Remaining arguments are additional directories if opt_manual_link
1276 is not set. */
1277 if (remaining != argc && !opt_manual_link)
1278 {
1279 int i;
1280 for (i = remaining; i < argc; ++i)
1281 if (opt_build_cache && argv[i][0] != '/')
1282 error (EXIT_FAILURE, 0,
1283 _("relative path `%s' used to build cache"),
1284 argv[i]);
1285 else
1286 add_dir (argv[i]);
1287 }
1288
1289 /* The last entry in hwcap_extra is reserved for the "tls" pseudo-hwcap which
1290 indicates support for TLS. This pseudo-hwcap is only used by old versions
1291 under which TLS support was optional. The entry is no longer needed, but
1292 must remain for compatibility. */
1293 hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls";
1294
1295 set_hwcap ();
1296
1297 if (opt_chroot)
1298 {
1299 /* Normalize the path a bit, we might need it for printing later. */
1300 char *endp = rawmemchr (opt_chroot, '\0');
1301 while (endp > opt_chroot && endp[-1] == '/')
1302 --endp;
1303 *endp = '\0';
1304 if (endp == opt_chroot)
1305 opt_chroot = NULL;
1306
1307 if (opt_chroot)
1308 {
1309 /* It is faster to use chroot if we can. */
1310 if (!chroot (opt_chroot))
1311 {
1312 if (chdir ("/"))
1313 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1314 opt_chroot = NULL;
1315 }
1316 }
1317 }
1318
1319 if (cache_file == NULL)
1320 {
1321 cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1322 strcpy (cache_file, LD_SO_CACHE);
1323 }
1324
1325 if (config_file == NULL)
1326 config_file = LD_SO_CONF;
1327
1328 if (opt_print_cache)
1329 {
1330 if (opt_chroot)
1331 {
1332 char *p = chroot_canon (opt_chroot, cache_file);
1333 if (p == NULL)
1334 error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1335 cache_file);
1336 cache_file = p;
1337 }
1338 print_cache (cache_file);
1339 if (opt_chroot)
1340 free (cache_file);
1341 exit (0);
1342 }
1343
1344 if (opt_chroot)
1345 {
1346 /* Canonicalize the directory name of cache_file, not cache_file,
1347 because we'll rename a temporary cache file to it. */
1348 char *p = strrchr (cache_file, '/');
1349 char *canon = chroot_canon (opt_chroot,
1350 p ? (*p = '\0', cache_file) : "/");
1351
1352 if (canon == NULL)
1353 error (EXIT_FAILURE, errno,
1354 _("Can't open cache file directory %s\n"),
1355 p ? cache_file : "/");
1356
1357 if (p)
1358 ++p;
1359 else
1360 p = cache_file;
1361
1362 cache_file = alloca (strlen (canon) + strlen (p) + 2);
1363 sprintf (cache_file, "%s/%s", canon, p);
1364 free (canon);
1365 }
1366
1367 if (opt_manual_link)
1368 {
1369 /* Link all given libraries manually. */
1370 int i;
1371
1372 for (i = remaining; i < argc; ++i)
1373 manual_link (argv[i]);
1374
1375 exit (0);
1376 }
1377
1378
1379 if (opt_build_cache)
1380 init_cache ();
1381
1382 if (!opt_only_cline)
1383 {
1384 parse_conf (config_file, true);
1385
1386 /* Always add the standard search paths. */
1387 add_system_dir (SLIBDIR);
1388 if (strcmp (SLIBDIR, LIBDIR))
1389 add_system_dir (LIBDIR);
1390 }
1391
1392 const char *aux_cache_file = _PATH_LDCONFIG_AUX_CACHE;
1393 if (opt_chroot)
1394 aux_cache_file = chroot_canon (opt_chroot, aux_cache_file);
1395
1396 if (! opt_ignore_aux_cache && aux_cache_file)
1397 load_aux_cache (aux_cache_file);
1398 else
1399 init_aux_cache ();
1400
1401 search_dirs ();
1402
1403 if (opt_build_cache)
1404 {
1405 save_cache (cache_file);
1406 if (aux_cache_file)
1407 save_aux_cache (aux_cache_file);
1408 }
1409
1410 return 0;
1411}
1412