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