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