manual: Document getcontext uc_stack value on Linux [BZ #759]
[glibc.git] / elf / ldconfig.c
blob99caf9e9bb9ff20eac07fc45b28c16d1958aec38
1 /* Copyright (C) 1999-2017 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Andreas Jaeger <aj@suse.de>, 1999.
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.
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.
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <http://www.gnu.org/licenses/>. */
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>
42 #include <ldconfig.h>
43 #include <dl-cache.h>
45 #include <dl-procinfo.h>
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
53 #ifndef LD_SO_CONF
54 # define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
55 #endif
57 /* Get libc version number. */
58 #include <version.h>
60 #define PACKAGE _libc_intl_domainname
62 static const struct
64 const char *name;
65 int flag;
66 } lib_types[] =
68 {"libc4", FLAG_LIBC4},
69 {"libc5", FLAG_ELF_LIBC5},
70 {"libc6", FLAG_ELF_LIBC6},
71 {"glibc2", FLAG_ELF_LIBC6}
75 /* List of directories to handle. */
76 struct dir_entry
78 char *path;
79 int flag;
80 ino64_t ino;
81 dev_t dev;
82 struct dir_entry *next;
85 /* The list is unsorted, contains no duplicates. Entries are added at
86 the end. */
87 static struct dir_entry *dir_entries;
89 /* Flags for different options. */
90 /* Print Cache. */
91 static int opt_print_cache;
93 /* Be verbose. */
94 int opt_verbose;
96 /* Format to support. */
97 /* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
98 int opt_format = 1;
100 /* Build cache. */
101 static int opt_build_cache = 1;
103 /* Enable symbolic link processing. If set, create or update symbolic
104 links, and remove stale symbolic links. */
105 static int opt_link = 1;
107 /* Only process directories specified on the command line. */
108 static int opt_only_cline;
110 /* Path to root for chroot. */
111 static char *opt_chroot;
113 /* Manually link given shared libraries. */
114 static int opt_manual_link;
116 /* Should we ignore an old auxiliary cache file? */
117 static int opt_ignore_aux_cache;
119 /* Cache file to use. */
120 static char *cache_file;
122 /* Configuration file. */
123 static const char *config_file;
125 /* Mask to use for important hardware capabilities. */
126 static unsigned long int hwcap_mask = HWCAP_IMPORTANT;
128 /* Configuration-defined capabilities defined in kernel vDSOs. */
129 static const char *hwcap_extra[64 - _DL_FIRST_EXTRA];
131 /* Name and version of program. */
132 static void print_version (FILE *stream, struct argp_state *state);
133 void (*argp_program_version_hook) (FILE *, struct argp_state *)
134 = print_version;
136 /* Function to print some extra text in the help message. */
137 static char *more_help (int key, const char *text, void *input);
139 /* Definitions of arguments for argp functions. */
140 static const struct argp_option options[] =
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 }
156 #define PROCINFO_CLASS static
157 #include <dl-procinfo.c>
159 /* Short description of program. */
160 static const char doc[] = N_("Configure Dynamic Linker Run Time Bindings.");
162 /* Prototype for option handler. */
163 static error_t parse_opt (int key, char *arg, struct argp_state *state);
165 /* Data structure to communicate with argp functions. */
166 static struct argp argp =
168 options, parse_opt, NULL, doc, NULL, more_help, NULL
171 /* Check if string corresponds to an important hardware capability or
172 a platform. */
173 static int
174 is_hwcap_platform (const char *name)
176 int hwcap_idx = _dl_string_hwcap (name);
178 /* Is this a normal hwcap for the machine like "fpu?" */
179 if (hwcap_idx != -1 && ((1 << hwcap_idx) & hwcap_mask))
180 return 1;
182 /* Is this a platform pseudo-hwcap like "i686?" */
183 hwcap_idx = _dl_string_platform (name);
184 if (hwcap_idx != -1)
185 return 1;
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;
194 return 0;
197 /* Get hwcap (including platform) encoding of path. */
198 static uint64_t
199 path_hwcap (const char *path)
201 char *str = xstrdup (path);
202 char *ptr;
203 uint64_t hwcap = 0;
204 uint64_t h;
206 size_t len;
208 len = strlen (str);
209 if (str[len] == '/')
210 str[len] = '\0';
212 /* Search pathname from the end and check for hwcap strings. */
213 for (;;)
215 ptr = strrchr (str, '/');
217 if (ptr == NULL)
218 break;
220 h = _dl_string_hwcap (ptr + 1);
222 if (h == (uint64_t) -1)
224 h = _dl_string_platform (ptr + 1);
225 if (h == (uint64_t) -1)
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;
235 hwcap += 1ULL << h;
237 /* Search the next part of the path. */
238 *ptr = '\0';
241 free (str);
242 return hwcap;
245 /* Handle program arguments. */
246 static error_t
247 parse_opt (int key, char *arg, struct argp_state *state)
249 switch (key)
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;
296 return 0;
299 /* Print bug-reporting information in the help message. */
300 static char *
301 more_help (int key, const char *text, void *input)
303 char *tp = NULL;
304 switch (key)
306 case ARGP_KEY_HELP_EXTRA:
307 /* We print some extra information. */
308 if (asprintf (&tp, gettext ("\
309 For bug reporting instructions, please see:\n\
310 %s.\n"), REPORT_BUGS_TO) < 0)
311 return NULL;
312 return tp;
313 default:
314 break;
316 return (char *) text;
319 /* Print the version information. */
320 static void
321 print_version (FILE *stream, struct argp_state *state)
323 fprintf (stream, "ldconfig %s%s\n", PKGVERSION, VERSION);
324 fprintf (stream, gettext ("\
325 Copyright (C) %s Free Software Foundation, Inc.\n\
326 This is free software; see the source for copying conditions. There is NO\n\
327 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
328 "), "2017");
329 fprintf (stream, gettext ("Written by %s.\n"),
330 "Andreas Jaeger");
333 /* Add a single directory entry. */
334 static void
335 add_single_dir (struct dir_entry *entry, int verbose)
337 struct dir_entry *ptr, *prev;
339 ptr = dir_entries;
340 prev = ptr;
341 while (ptr != NULL)
343 /* Check for duplicates. */
344 if (ptr->ino == entry->ino && ptr->dev == entry->dev)
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;
354 prev = ptr;
355 ptr = ptr->next;
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;
364 /* Add one directory to the list of directories to process. */
365 static void
366 add_dir (const char *line)
368 unsigned int i;
369 struct dir_entry *entry = xmalloc (sizeof (struct dir_entry));
370 entry->next = NULL;
372 /* Search for an '=' sign. */
373 entry->path = xstrdup (line);
374 char *equal_sign = strchr (entry->path, '=');
375 if (equal_sign)
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)
383 entry->flag = lib_types[i].flag;
384 break;
386 if (entry->flag == FLAG_ANY)
387 error (0, 0, _("%s is not a known library type"), equal_sign);
389 else
391 entry->flag = FLAG_ANY;
394 /* Canonify path: for now only remove leading and trailing
395 whitespace and the trailing slashes. */
396 i = strlen (entry->path);
398 while (i > 0 && isspace (entry->path[i - 1]))
399 entry->path[--i] = '\0';
401 while (i > 0 && entry->path[i - 1] == '/')
402 entry->path[--i] = '\0';
404 if (i == 0)
405 return;
407 char *path = entry->path;
408 if (opt_chroot)
409 path = chroot_canon (opt_chroot, path);
411 struct stat64 stat_buf;
412 if (path == NULL || stat64 (path, &stat_buf))
414 if (opt_verbose)
415 error (0, errno, _("Can't stat %s"), entry->path);
416 free (entry->path);
417 free (entry);
419 else
421 entry->ino = stat_buf.st_ino;
422 entry->dev = stat_buf.st_dev;
424 add_single_dir (entry, 1);
427 if (opt_chroot)
428 free (path);
432 static int
433 chroot_stat (const char *real_path, const char *path, struct stat64 *st)
435 int ret;
436 char *canon_path;
438 if (!opt_chroot)
439 return stat64 (real_path, st);
441 ret = lstat64 (real_path, st);
442 if (ret || !S_ISLNK (st->st_mode))
443 return ret;
445 canon_path = chroot_canon (opt_chroot, path);
446 if (canon_path == NULL)
447 return -1;
449 ret = stat64 (canon_path, st);
450 free (canon_path);
451 return ret;
454 /* Create a symbolic link from soname to libname in directory path. */
455 static void
456 create_links (const char *real_path, const char *path, const char *libname,
457 const char *soname)
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. */
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)
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);
478 else
480 real_full_libname = full_libname;
481 real_full_soname = full_soname;
484 /* Does soname already exist and point to the right library? */
485 if (chroot_stat (real_full_soname, full_soname, &stat_so) == 0)
487 if (chroot_stat (real_full_libname, full_libname, &stat_lib))
489 error (0, 0, _("Can't stat %s\n"), full_libname);
490 return;
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))
499 error (0, 0, _("%s is not a symbolic link\n"), full_soname);
500 do_link = 0;
501 do_remove = 0;
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;
509 if (opt_verbose)
510 printf ("\t%s -> %s", soname, libname);
512 if (do_link && opt_link)
514 /* Remove old link. */
515 if (do_remove)
516 if (unlink (real_full_soname))
518 error (0, 0, _("Can't unlink %s"), full_soname);
519 do_link = 0;
521 /* Create symbolic link. */
522 if (do_link && symlink (libname, real_full_soname))
524 error (0, 0, _("Can't link %s to %s"), full_soname, libname);
525 do_link = 0;
527 if (opt_verbose)
529 if (do_link)
530 fputs (_(" (changed)\n"), stdout);
531 else
532 fputs (_(" (SKIPPED)\n"), stdout);
535 else if (opt_verbose)
536 fputs ("\n", stdout);
539 /* Manually link the given library. */
540 static void
541 manual_link (char *library)
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;
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, '/');
558 if (libname)
560 /* Successfully split names. Check if path is just "/" to avoid
561 an empty path. */
562 if (libname == path)
564 libname = library + 1;
565 path = xrealloc (path, 2);
566 strcpy (path, "/");
568 else
570 *libname = '\0';
571 ++libname;
574 else
576 /* There's no path, construct one. */
577 libname = library;
578 path = xrealloc (path, 2);
579 strcpy (path, ".");
582 if (opt_chroot)
584 real_path = chroot_canon (opt_chroot, path);
585 if (real_path == NULL)
587 error (0, errno, _("Can't find %s"), path);
588 free (path);
589 return;
591 real_library = alloca (strlen (real_path) + strlen (libname) + 2);
592 sprintf (real_library, "%s/%s", real_path, libname);
594 else
596 real_path = path;
597 real_library = library;
600 /* Do some sanity checks first. */
601 if (lstat64 (real_library, &stat_buf))
603 error (0, errno, _("Cannot lstat %s"), library);
604 free (path);
605 return;
607 /* We don't want links here! */
608 else if (!S_ISREG (stat_buf.st_mode))
610 error (0, 0, _("Ignored file %s since it is not a regular file."),
611 library);
612 free (path);
613 return;
616 if (process_file (real_library, library, libname, &flag, &osversion,
617 &soname, 0, &stat_buf))
619 error (0, 0, _("No link created since soname could not be found for %s"),
620 library);
621 free (path);
622 return;
624 if (soname == NULL)
625 soname = implicit_soname (libname, flag);
626 create_links (real_path, path, libname, soname);
627 free (soname);
628 free (path);
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
637 This has to be done separatly for each directory.
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.
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
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. */
656 /* Information for one library. */
657 struct dlib_entry
659 char *name;
660 char *soname;
661 int flag;
662 int is_link;
663 unsigned int osversion;
664 struct dlib_entry *next;
668 static void
669 search_dir (const struct dir_entry *entry)
671 uint64_t hwcap = path_hwcap (entry->path);
672 if (opt_verbose)
674 if (hwcap != 0)
675 printf ("%s: (hwcap: %#.16" PRIx64 ")\n", entry->path, hwcap);
676 else
677 printf ("%s:\n", entry->path);
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)
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);
691 else
693 dir_name = entry->path;
694 real_file_name_len = 0;
695 real_file_name = file_name;
698 DIR *dir;
699 if (dir_name == NULL || (dir = opendir (dir_name)) == NULL)
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;
708 struct dirent64 *direntry;
709 struct dlib_entry *dlibs = NULL;
710 while ((direntry = readdir64 (dir)) != NULL)
712 int flag;
713 #ifdef _DIRENT_HAVE_D_TYPE
714 /* We only look at links and regular files. */
715 if (direntry->d_type != DT_UNKNOWN
716 && direntry->d_type != DT_LNK
717 && direntry->d_type != DT_REG
718 && direntry->d_type != DT_DIR)
719 continue;
720 #endif /* _DIRENT_HAVE_D_TYPE */
721 /* Does this file look like a shared library or is it a hwcap
722 subdirectory? The dynamic linker is also considered as
723 shared library. */
724 if (((strncmp (direntry->d_name, "lib", 3) != 0
725 && strncmp (direntry->d_name, "ld-", 3) != 0)
726 || strstr (direntry->d_name, ".so") == NULL)
727 && (
728 #ifdef _DIRENT_HAVE_D_TYPE
729 direntry->d_type == DT_REG ||
730 #endif
731 !is_hwcap_platform (direntry->d_name)))
732 continue;
734 size_t len = strlen (direntry->d_name);
735 /* Skip temporary files created by the prelink program. Files with
736 names like these are never really DSOs we want to look at. */
737 if (len >= sizeof (".#prelink#") - 1)
739 if (strcmp (direntry->d_name + len - sizeof (".#prelink#") + 1,
740 ".#prelink#") == 0)
741 continue;
742 if (len >= sizeof (".#prelink#.XXXXXX") - 1
743 && memcmp (direntry->d_name + len - sizeof (".#prelink#.XXXXXX")
744 + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
745 continue;
747 len += strlen (entry->path) + 2;
748 if (len > file_name_len)
750 file_name_len = len;
751 file_name = alloca (file_name_len);
752 if (!opt_chroot)
753 real_file_name = file_name;
755 sprintf (file_name, "%s/%s", entry->path, direntry->d_name);
756 if (opt_chroot)
758 len = strlen (dir_name) + strlen (direntry->d_name) + 2;
759 if (len > real_file_name_len)
761 real_file_name_len = len;
762 real_file_name = alloca (real_file_name_len);
764 sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);
767 struct stat64 lstat_buf;
768 #ifdef _DIRENT_HAVE_D_TYPE
769 /* We optimize and try to do the lstat call only if needed. */
770 if (direntry->d_type != DT_UNKNOWN)
771 lstat_buf.st_mode = DTTOIF (direntry->d_type);
772 else
773 #endif
774 if (__glibc_unlikely (lstat64 (real_file_name, &lstat_buf)))
776 error (0, errno, _("Cannot lstat %s"), file_name);
777 continue;
780 struct stat64 stat_buf;
781 int is_dir;
782 int is_link = S_ISLNK (lstat_buf.st_mode);
783 if (is_link)
785 /* In case of symlink, we check if the symlink refers to
786 a directory. */
787 char *target_name = real_file_name;
788 if (opt_chroot)
790 target_name = chroot_canon (opt_chroot, file_name);
791 if (target_name == NULL)
793 if (strstr (file_name, ".so") == NULL)
794 error (0, 0, _("Input file %s not found.\n"), file_name);
795 continue;
798 if (__glibc_unlikely (stat64 (target_name, &stat_buf)))
800 if (opt_verbose)
801 error (0, errno, _("Cannot stat %s"), file_name);
803 /* Remove stale symlinks. */
804 if (opt_link && strstr (direntry->d_name, ".so."))
805 unlink (real_file_name);
806 continue;
808 is_dir = S_ISDIR (stat_buf.st_mode);
810 /* lstat_buf is later stored, update contents. */
811 lstat_buf.st_dev = stat_buf.st_dev;
812 lstat_buf.st_ino = stat_buf.st_ino;
813 lstat_buf.st_size = stat_buf.st_size;
814 lstat_buf.st_ctime = stat_buf.st_ctime;
816 else
817 is_dir = S_ISDIR (lstat_buf.st_mode);
819 if (is_dir && is_hwcap_platform (direntry->d_name))
821 /* Handle subdirectory later. */
822 struct dir_entry *new_entry;
824 new_entry = xmalloc (sizeof (struct dir_entry));
825 new_entry->path = xstrdup (file_name);
826 new_entry->flag = entry->flag;
827 new_entry->next = NULL;
828 #ifdef _DIRENT_HAVE_D_TYPE
829 /* We have filled in lstat only #ifndef
830 _DIRENT_HAVE_D_TYPE. Fill it in if needed. */
831 if (!is_link
832 && direntry->d_type != DT_UNKNOWN
833 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
835 error (0, errno, _("Cannot lstat %s"), file_name);
836 free (new_entry->path);
837 free (new_entry);
838 continue;
840 #endif
841 new_entry->ino = lstat_buf.st_ino;
842 new_entry->dev = lstat_buf.st_dev;
843 add_single_dir (new_entry, 0);
844 continue;
846 else if (!S_ISREG (lstat_buf.st_mode) && !is_link)
847 continue;
849 char *real_name;
850 if (opt_chroot && is_link)
852 real_name = chroot_canon (opt_chroot, file_name);
853 if (real_name == NULL)
855 if (strstr (file_name, ".so") == NULL)
856 error (0, 0, _("Input file %s not found.\n"), file_name);
857 continue;
860 else
861 real_name = real_file_name;
863 #ifdef _DIRENT_HAVE_D_TYPE
864 /* Call lstat64 if not done yet. */
865 if (!is_link
866 && direntry->d_type != DT_UNKNOWN
867 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
869 error (0, errno, _("Cannot lstat %s"), file_name);
870 continue;
872 #endif
874 /* First search whether the auxiliary cache contains this
875 library already and it's not changed. */
876 char *soname;
877 unsigned int osversion;
878 if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))
880 if (process_file (real_name, file_name, direntry->d_name, &flag,
881 &osversion, &soname, is_link, &lstat_buf))
883 if (real_name != real_file_name)
884 free (real_name);
885 continue;
887 else if (opt_build_cache)
888 add_to_aux_cache (&lstat_buf, flag, osversion, soname);
891 if (soname == NULL)
892 soname = implicit_soname (direntry->d_name, flag);
894 /* A link may just point to itself. */
895 if (is_link)
897 /* If the path the link points to isn't its soname or it is not
898 the .so symlink for ld(1), we treat it as a normal file.
900 You should always do this:
902 libfoo.so -> SONAME -> Arbitrary package-chosen name.
904 e.g. libfoo.so -> libfoo.so.1 -> libfooimp.so.9.99.
905 Given a SONAME of libfoo.so.1.
907 You should *never* do this:
909 libfoo.so -> libfooimp.so.9.99
911 If you do, and your SONAME is libfoo.so.1, then libfoo.so
912 fails to point at the SONAME. In that case ldconfig may consider
913 libfoo.so as another implementation of SONAME and will create
914 symlinks against it causing problems when you try to upgrade
915 or downgrade. The problems will arise because ldconfig will,
916 depending on directory ordering, creat symlinks against libfoo.so
917 e.g. libfoo.so.1.2 -> libfoo.so, but when libfoo.so is removed
918 (typically by the removal of a development pacakge not required
919 for the runtime) it will break the libfoo.so.1.2 symlink and the
920 application will fail to start. */
921 const char *real_base_name = basename (real_file_name);
923 if (strcmp (real_base_name, soname) != 0)
925 len = strlen (real_base_name);
926 if (len < strlen (".so")
927 || strcmp (real_base_name + len - strlen (".so"), ".so") != 0
928 || strncmp (real_base_name, soname, len) != 0)
929 is_link = 0;
933 if (real_name != real_file_name)
934 free (real_name);
936 if (is_link)
938 free (soname);
939 soname = xstrdup (direntry->d_name);
942 if (flag == FLAG_ELF
943 && (entry->flag == FLAG_ELF_LIBC5
944 || entry->flag == FLAG_ELF_LIBC6))
945 flag = entry->flag;
947 /* Some sanity checks to print warnings. */
948 if (opt_verbose)
950 if (flag == FLAG_ELF_LIBC5 && entry->flag != FLAG_ELF_LIBC5
951 && entry->flag != FLAG_ANY)
952 error (0, 0, _("libc5 library %s in wrong directory"), file_name);
953 if (flag == FLAG_ELF_LIBC6 && entry->flag != FLAG_ELF_LIBC6
954 && entry->flag != FLAG_ANY)
955 error (0, 0, _("libc6 library %s in wrong directory"), file_name);
956 if (flag == FLAG_LIBC4 && entry->flag != FLAG_LIBC4
957 && entry->flag != FLAG_ANY)
958 error (0, 0, _("libc4 library %s in wrong directory"), file_name);
961 /* Add library to list. */
962 struct dlib_entry *dlib_ptr;
963 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
965 /* Is soname already in list? */
966 if (strcmp (dlib_ptr->soname, soname) == 0)
968 /* Prefer a file to a link, otherwise check which one
969 is newer. */
970 if ((!is_link && dlib_ptr->is_link)
971 || (is_link == dlib_ptr->is_link
972 && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
974 /* It's newer - add it. */
975 /* Flag should be the same - sanity check. */
976 if (dlib_ptr->flag != flag)
978 if (dlib_ptr->flag == FLAG_ELF
979 && (flag == FLAG_ELF_LIBC5 || flag == FLAG_ELF_LIBC6))
980 dlib_ptr->flag = flag;
981 else if ((dlib_ptr->flag == FLAG_ELF_LIBC5
982 || dlib_ptr->flag == FLAG_ELF_LIBC6)
983 && flag == FLAG_ELF)
984 dlib_ptr->flag = flag;
985 else
986 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
987 dlib_ptr->name, direntry->d_name,
988 entry->path);
990 free (dlib_ptr->name);
991 dlib_ptr->name = xstrdup (direntry->d_name);
992 dlib_ptr->is_link = is_link;
993 dlib_ptr->osversion = osversion;
995 /* Don't add this library, abort loop. */
996 /* Also free soname, since it's dynamically allocated. */
997 free (soname);
998 break;
1001 /* Add the library if it's not already in. */
1002 if (dlib_ptr == NULL)
1004 dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
1005 dlib_ptr->name = xstrdup (direntry->d_name);
1006 dlib_ptr->soname = soname;
1007 dlib_ptr->flag = flag;
1008 dlib_ptr->is_link = is_link;
1009 dlib_ptr->osversion = osversion;
1010 /* Add at head of list. */
1011 dlib_ptr->next = dlibs;
1012 dlibs = dlib_ptr;
1016 closedir (dir);
1018 /* Now dlibs contains a list of all libs - add those to the cache
1019 and created all symbolic links. */
1020 struct dlib_entry *dlib_ptr;
1021 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
1023 /* Don't create links to links. */
1024 if (dlib_ptr->is_link == 0)
1025 create_links (dir_name, entry->path, dlib_ptr->name,
1026 dlib_ptr->soname);
1027 if (opt_build_cache)
1028 add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag,
1029 dlib_ptr->osversion, hwcap);
1032 /* Free all resources. */
1033 while (dlibs)
1035 dlib_ptr = dlibs;
1036 free (dlib_ptr->soname);
1037 free (dlib_ptr->name);
1038 dlibs = dlibs->next;
1039 free (dlib_ptr);
1042 if (opt_chroot && dir_name)
1043 free (dir_name);
1046 /* Search through all libraries. */
1047 static void
1048 search_dirs (void)
1050 struct dir_entry *entry;
1052 for (entry = dir_entries; entry != NULL; entry = entry->next)
1053 search_dir (entry);
1055 /* Free all allocated memory. */
1056 while (dir_entries)
1058 entry = dir_entries;
1059 dir_entries = dir_entries->next;
1060 free (entry->path);
1061 free (entry);
1066 static void parse_conf_include (const char *config_file, unsigned int lineno,
1067 bool do_chroot, const char *pattern);
1069 /* Parse configuration file. */
1070 static void
1071 parse_conf (const char *filename, bool do_chroot)
1073 FILE *file = NULL;
1074 char *line = NULL;
1075 const char *canon;
1076 size_t len = 0;
1077 unsigned int lineno;
1079 if (do_chroot && opt_chroot)
1081 canon = chroot_canon (opt_chroot, filename);
1082 if (canon)
1083 file = fopen (canon, "r");
1084 else
1085 canon = filename;
1087 else
1089 canon = filename;
1090 file = fopen (filename, "r");
1093 if (file == NULL)
1095 error (0, errno, _("\
1096 Warning: ignoring configuration file that cannot be opened: %s"),
1097 canon);
1098 if (canon != filename)
1099 free ((char *) canon);
1100 return;
1103 /* No threads use this stream. */
1104 __fsetlocking (file, FSETLOCKING_BYCALLER);
1106 if (canon != filename)
1107 free ((char *) canon);
1109 lineno = 0;
1112 ssize_t n = getline (&line, &len, file);
1113 if (n < 0)
1114 break;
1116 ++lineno;
1117 if (line[n - 1] == '\n')
1118 line[n - 1] = '\0';
1120 /* Because the file format does not know any form of quoting we
1121 can search forward for the next '#' character and if found
1122 make it terminating the line. */
1123 *strchrnul (line, '#') = '\0';
1125 /* Remove leading whitespace. NUL is no whitespace character. */
1126 char *cp = line;
1127 while (isspace (*cp))
1128 ++cp;
1130 /* If the line is blank it is ignored. */
1131 if (cp[0] == '\0')
1132 continue;
1134 if (!strncmp (cp, "include", 7) && isblank (cp[7]))
1136 char *dir;
1137 cp += 8;
1138 while ((dir = strsep (&cp, " \t")) != NULL)
1139 if (dir[0] != '\0')
1140 parse_conf_include (filename, lineno, do_chroot, dir);
1142 else if (!strncasecmp (cp, "hwcap", 5) && isblank (cp[5]))
1144 cp += 6;
1145 char *p, *name = NULL;
1146 unsigned long int n = strtoul (cp, &cp, 0);
1147 if (cp != NULL && isblank (*cp))
1148 while ((p = strsep (&cp, " \t")) != NULL)
1149 if (p[0] != '\0')
1151 if (name == NULL)
1152 name = p;
1153 else
1155 name = NULL;
1156 break;
1159 if (name == NULL)
1161 error (EXIT_FAILURE, 0, _("%s:%u: bad syntax in hwcap line"),
1162 filename, lineno);
1163 break;
1165 if (n >= (64 - _DL_FIRST_EXTRA))
1166 error (EXIT_FAILURE, 0,
1167 _("%s:%u: hwcap index %lu above maximum %u"),
1168 filename, lineno, n, 64 - _DL_FIRST_EXTRA - 1);
1169 if (hwcap_extra[n] == NULL)
1171 for (unsigned long int h = 0; h < (64 - _DL_FIRST_EXTRA); ++h)
1172 if (hwcap_extra[h] != NULL && !strcmp (name, hwcap_extra[h]))
1173 error (EXIT_FAILURE, 0,
1174 _("%s:%u: hwcap index %lu already defined as %s"),
1175 filename, lineno, h, name);
1176 hwcap_extra[n] = xstrdup (name);
1178 else
1180 if (strcmp (name, hwcap_extra[n]))
1181 error (EXIT_FAILURE, 0,
1182 _("%s:%u: hwcap index %lu already defined as %s"),
1183 filename, lineno, n, hwcap_extra[n]);
1184 if (opt_verbose)
1185 error (0, 0, _("%s:%u: duplicate hwcap %lu %s"),
1186 filename, lineno, n, name);
1189 else
1190 add_dir (cp);
1192 while (!feof_unlocked (file));
1194 /* Free buffer and close file. */
1195 free (line);
1196 fclose (file);
1199 /* Handle one word in an `include' line, a glob pattern of additional
1200 config files to read. */
1201 static void
1202 parse_conf_include (const char *config_file, unsigned int lineno,
1203 bool do_chroot, const char *pattern)
1205 if (opt_chroot && pattern[0] != '/')
1206 error (EXIT_FAILURE, 0,
1207 _("need absolute file name for configuration file when using -r"));
1209 char *copy = NULL;
1210 if (pattern[0] != '/' && strchr (config_file, '/') != NULL)
1212 if (asprintf (&copy, "%s/%s", dirname (strdupa (config_file)),
1213 pattern) < 0)
1214 error (EXIT_FAILURE, 0, _("memory exhausted"));
1215 pattern = copy;
1218 glob64_t gl;
1219 int result;
1220 if (do_chroot && opt_chroot)
1222 char *canon = chroot_canon (opt_chroot, pattern);
1223 if (canon == NULL)
1224 return;
1225 result = glob64 (canon, 0, NULL, &gl);
1226 free (canon);
1228 else
1229 result = glob64 (pattern, 0, NULL, &gl);
1231 switch (result)
1233 case 0:
1234 for (size_t i = 0; i < gl.gl_pathc; ++i)
1235 parse_conf (gl.gl_pathv[i], false);
1236 globfree64 (&gl);
1237 break;
1239 case GLOB_NOMATCH:
1240 break;
1242 case GLOB_NOSPACE:
1243 errno = ENOMEM;
1244 case GLOB_ABORTED:
1245 if (opt_verbose)
1246 error (0, errno, _("%s:%u: cannot read directory %s"),
1247 config_file, lineno, pattern);
1248 break;
1250 default:
1251 abort ();
1252 break;
1255 free (copy);
1258 /* Honour LD_HWCAP_MASK. */
1259 static void
1260 set_hwcap (void)
1262 char *mask = getenv ("LD_HWCAP_MASK");
1264 if (mask)
1265 hwcap_mask = strtoul (mask, NULL, 0);
1270 main (int argc, char **argv)
1272 /* Set locale via LC_ALL. */
1273 setlocale (LC_ALL, "");
1275 /* Set the text message domain. */
1276 textdomain (_libc_intl_domainname);
1278 /* Parse and process arguments. */
1279 int remaining;
1280 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1282 /* Remaining arguments are additional directories if opt_manual_link
1283 is not set. */
1284 if (remaining != argc && !opt_manual_link)
1286 int i;
1287 for (i = remaining; i < argc; ++i)
1288 if (opt_build_cache && argv[i][0] != '/')
1289 error (EXIT_FAILURE, 0,
1290 _("relative path `%s' used to build cache"),
1291 argv[i]);
1292 else
1293 add_dir (argv[i]);
1296 /* The last entry in hwcap_extra is reserved for the "tls" pseudo-hwcap which
1297 indicates support for TLS. This pseudo-hwcap is only used by old versions
1298 under which TLS support was optional. The entry is no longer needed, but
1299 must remain for compatibility. */
1300 hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls";
1302 set_hwcap ();
1304 if (opt_chroot)
1306 /* Normalize the path a bit, we might need it for printing later. */
1307 char *endp = rawmemchr (opt_chroot, '\0');
1308 while (endp > opt_chroot && endp[-1] == '/')
1309 --endp;
1310 *endp = '\0';
1311 if (endp == opt_chroot)
1312 opt_chroot = NULL;
1314 if (opt_chroot)
1316 /* It is faster to use chroot if we can. */
1317 if (!chroot (opt_chroot))
1319 if (chdir ("/"))
1320 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1321 opt_chroot = NULL;
1326 if (cache_file == NULL)
1328 cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1329 strcpy (cache_file, LD_SO_CACHE);
1332 if (config_file == NULL)
1333 config_file = LD_SO_CONF;
1335 if (opt_print_cache)
1337 if (opt_chroot)
1339 char *p = chroot_canon (opt_chroot, cache_file);
1340 if (p == NULL)
1341 error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1342 cache_file);
1343 cache_file = p;
1345 print_cache (cache_file);
1346 if (opt_chroot)
1347 free (cache_file);
1348 exit (0);
1351 if (opt_chroot)
1353 /* Canonicalize the directory name of cache_file, not cache_file,
1354 because we'll rename a temporary cache file to it. */
1355 char *p = strrchr (cache_file, '/');
1356 char *canon = chroot_canon (opt_chroot,
1357 p ? (*p = '\0', cache_file) : "/");
1359 if (canon == NULL)
1360 error (EXIT_FAILURE, errno,
1361 _("Can't open cache file directory %s\n"),
1362 p ? cache_file : "/");
1364 if (p)
1365 ++p;
1366 else
1367 p = cache_file;
1369 cache_file = alloca (strlen (canon) + strlen (p) + 2);
1370 sprintf (cache_file, "%s/%s", canon, p);
1371 free (canon);
1374 if (opt_manual_link)
1376 /* Link all given libraries manually. */
1377 int i;
1379 for (i = remaining; i < argc; ++i)
1380 manual_link (argv[i]);
1382 exit (0);
1386 if (opt_build_cache)
1387 init_cache ();
1389 if (!opt_only_cline)
1391 parse_conf (config_file, true);
1393 /* Always add the standard search paths. */
1394 add_system_dir (SLIBDIR);
1395 if (strcmp (SLIBDIR, LIBDIR))
1396 add_system_dir (LIBDIR);
1399 const char *aux_cache_file = _PATH_LDCONFIG_AUX_CACHE;
1400 if (opt_chroot)
1401 aux_cache_file = chroot_canon (opt_chroot, aux_cache_file);
1403 if (! opt_ignore_aux_cache && aux_cache_file)
1404 load_aux_cache (aux_cache_file);
1405 else
1406 init_aux_cache ();
1408 search_dirs ();
1410 if (opt_build_cache)
1412 save_cache (cache_file);
1413 if (aux_cache_file)
1414 save_aux_cache (aux_cache_file);
1417 return 0;