1 /* Copyright (C) 1999-2012 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
30 #include <stdio_ext.h>
34 #include <sys/fcntl.h>
37 #include <sys/types.h>
44 #include <dl-procinfo.h>
46 #ifdef _DL_FIRST_PLATFORM
47 # define _DL_FIRST_EXTRA (_DL_FIRST_PLATFORM + _DL_PLATFORMS_COUNT)
49 # define _DL_FIRST_EXTRA _DL_HWCAP_COUNT
53 # define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
56 /* Get libc version number. */
59 #define PACKAGE _libc_intl_domainname
67 {"libc4", FLAG_LIBC4},
68 {"libc5", FLAG_ELF_LIBC5},
69 {"libc6", FLAG_ELF_LIBC6},
70 {"glibc2", FLAG_ELF_LIBC6}
74 /* List of directories to handle. */
81 struct dir_entry *next;
84 /* The list is unsorted, contains no duplicates. Entries are added at
86 static struct dir_entry *dir_entries;
88 /* Flags for different options. */
90 static int opt_print_cache;
95 /* Format to support. */
96 /* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
100 static int opt_build_cache = 1;
102 /* Generate links. */
103 static int opt_link = 1;
105 /* Only process directories specified on the command line. */
106 static int opt_only_cline;
108 /* Path to root for chroot. */
109 static char *opt_chroot;
111 /* Manually link given shared libraries. */
112 static int opt_manual_link;
114 /* Should we ignore an old auxiliary cache file? */
115 static int opt_ignore_aux_cache;
117 /* Cache file to use. */
118 static char *cache_file;
120 /* Configuration file. */
121 static const char *config_file;
123 /* Mask to use for important hardware capabilities. */
124 static unsigned long int hwcap_mask = HWCAP_IMPORTANT;
126 /* Configuration-defined capabilities defined in kernel vDSOs. */
127 static const char *hwcap_extra[64 - _DL_FIRST_EXTRA];
129 /* Name and version of program. */
130 static void print_version (FILE *stream, struct argp_state *state);
131 void (*argp_program_version_hook) (FILE *, struct argp_state *)
134 /* Function to print some extra text in the help message. */
135 static char *more_help (int key, const char *text, void *input);
137 /* Definitions of arguments for argp functions. */
138 static const struct argp_option options[] =
140 { "print-cache", 'p', NULL, 0, N_("Print cache"), 0},
141 { "verbose", 'v', NULL, 0, N_("Generate verbose messages"), 0},
142 { NULL, 'N', NULL, 0, N_("Don't build cache"), 0},
143 { NULL, 'X', NULL, 0, N_("Don't generate links"), 0},
144 { NULL, 'r', N_("ROOT"), 0, N_("Change to and use ROOT as root directory"), 0},
145 { NULL, 'C', N_("CACHE"), 0, N_("Use CACHE as cache file"), 0},
146 { NULL, 'f', N_("CONF"), 0, N_("Use CONF as configuration file"), 0},
147 { NULL, 'n', NULL, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
148 { NULL, 'l', NULL, 0, N_("Manually link individual libraries."), 0},
149 { "format", 'c', N_("FORMAT"), 0, N_("Format to use: new, old or compat (default)"), 0},
150 { "ignore-aux-cache", 'i', NULL, 0, N_("Ignore auxiliary cache file"), 0},
151 { NULL, 0, NULL, 0, NULL, 0 }
154 #define PROCINFO_CLASS static
155 #include <dl-procinfo.c>
157 /* Short description of program. */
158 static const char doc[] = N_("Configure Dynamic Linker Run Time Bindings.");
160 /* Prototype for option handler. */
161 static error_t parse_opt (int key, char *arg, struct argp_state *state);
163 /* Data structure to communicate with argp functions. */
164 static struct argp argp =
166 options, parse_opt, NULL, doc, NULL, more_help, NULL
169 /* Check if string corresponds to an important hardware capability or
172 is_hwcap_platform (const char *name)
174 int hwcap_idx = _dl_string_hwcap (name);
176 if (hwcap_idx != -1 && ((1 << hwcap_idx) & hwcap_mask))
179 hwcap_idx = _dl_string_platform (name);
183 for (hwcap_idx = _DL_FIRST_EXTRA; hwcap_idx < 64; ++hwcap_idx)
184 if (hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA] != NULL
185 && !strcmp (name, hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA]))
191 /* Get hwcap (including platform) encoding of path. */
193 path_hwcap (const char *path)
195 char *str = xstrdup (path);
206 /* Search pathname from the end and check for hwcap strings. */
209 ptr = strrchr (str, '/');
214 h = _dl_string_hwcap (ptr + 1);
216 if (h == (uint64_t) -1)
218 h = _dl_string_platform (ptr + 1);
219 if (h == (uint64_t) -1)
221 for (h = _DL_FIRST_EXTRA; h < 64; ++h)
222 if (hwcap_extra[h - _DL_FIRST_EXTRA] != NULL
223 && !strcmp (ptr + 1, hwcap_extra[h - _DL_FIRST_EXTRA]))
231 /* Search the next part of the path. */
239 /* Handle program arguments. */
241 parse_opt (int key, char *arg, struct argp_state *state)
247 /* Ignore auxiliary cache since we use non-standard cache. */
248 opt_ignore_aux_cache = 1;
254 opt_ignore_aux_cache = 1;
279 if (strcmp (arg, "old") == 0)
281 else if (strcmp (arg, "compat") == 0)
283 else if (strcmp (arg, "new") == 0)
287 return ARGP_ERR_UNKNOWN;
293 /* Print bug-reporting information in the help message. */
295 more_help (int key, const char *text, void *input)
300 case ARGP_KEY_HELP_EXTRA:
301 /* We print some extra information. */
302 if (asprintf (&tp, gettext ("\
303 For bug reporting instructions, please see:\n\
304 %s.\n"), REPORT_BUGS_TO) < 0)
310 return (char *) text;
313 /* Print the version information. */
315 print_version (FILE *stream, struct argp_state *state)
317 fprintf (stream, "ldconfig %s%s\n", PKGVERSION, VERSION);
318 fprintf (stream, gettext ("\
319 Copyright (C) %s Free Software Foundation, Inc.\n\
320 This is free software; see the source for copying conditions. There is NO\n\
321 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
323 fprintf (stream, gettext ("Written by %s.\n"),
327 /* Add a single directory entry. */
329 add_single_dir (struct dir_entry *entry, int verbose)
331 struct dir_entry *ptr, *prev;
337 /* Check for duplicates. */
338 if (ptr->ino == entry->ino && ptr->dev == entry->dev)
340 if (opt_verbose && verbose)
341 error (0, 0, _("Path `%s' given more than once"), entry->path);
342 /* Use the newer information. */
343 ptr->flag = entry->flag;
351 /* Is this the first entry? */
352 if (ptr == NULL && dir_entries == NULL)
354 else if (ptr == NULL)
358 /* Add one directory to the list of directories to process. */
360 add_dir (const char *line)
363 struct dir_entry *entry = xmalloc (sizeof (struct dir_entry));
366 /* Search for an '=' sign. */
367 entry->path = xstrdup (line);
368 char *equal_sign = strchr (entry->path, '=');
373 entry->flag = FLAG_ANY;
374 for (i = 0; i < sizeof (lib_types) / sizeof (lib_types[0]); ++i)
375 if (strcmp (equal_sign, lib_types[i].name) == 0)
377 entry->flag = lib_types[i].flag;
380 if (entry->flag == FLAG_ANY)
381 error (0, 0, _("%s is not a known library type"), equal_sign);
385 entry->flag = FLAG_ANY;
388 /* Canonify path: for now only remove leading and trailing
389 whitespace and the trailing slashes. */
390 i = strlen (entry->path);
392 while (i > 0 && isspace (entry->path[i - 1]))
393 entry->path[--i] = '\0';
395 while (i > 0 && entry->path[i - 1] == '/')
396 entry->path[--i] = '\0';
401 char *path = entry->path;
403 path = chroot_canon (opt_chroot, path);
405 struct stat64 stat_buf;
406 if (path == NULL || stat64 (path, &stat_buf))
409 error (0, errno, _("Can't stat %s"), entry->path);
415 entry->ino = stat_buf.st_ino;
416 entry->dev = stat_buf.st_dev;
418 add_single_dir (entry, 1);
427 chroot_stat (const char *real_path, const char *path, struct stat64 *st)
433 return stat64 (real_path, st);
435 ret = lstat64 (real_path, st);
436 if (ret || !S_ISLNK (st->st_mode))
439 canon_path = chroot_canon (opt_chroot, path);
440 if (canon_path == NULL)
443 ret = stat64 (canon_path, st);
448 /* Create a symbolic link from soname to libname in directory path. */
450 create_links (const char *real_path, const char *path, const char *libname,
453 char *full_libname, *full_soname;
454 char *real_full_libname, *real_full_soname;
455 struct stat64 stat_lib, stat_so, lstat_so;
458 /* XXX: The logics in this function should be simplified. */
460 /* Get complete path. */
461 full_libname = alloca (strlen (path) + strlen (libname) + 2);
462 full_soname = alloca (strlen (path) + strlen (soname) + 2);
463 sprintf (full_libname, "%s/%s", path, libname);
464 sprintf (full_soname, "%s/%s", path, soname);
467 real_full_libname = alloca (strlen (real_path) + strlen (libname) + 2);
468 real_full_soname = alloca (strlen (real_path) + strlen (soname) + 2);
469 sprintf (real_full_libname, "%s/%s", real_path, libname);
470 sprintf (real_full_soname, "%s/%s", real_path, soname);
474 real_full_libname = full_libname;
475 real_full_soname = full_soname;
478 /* Does soname already exist and point to the right library? */
479 if (chroot_stat (real_full_soname, full_soname, &stat_so) == 0)
481 if (chroot_stat (real_full_libname, full_libname, &stat_lib))
483 error (0, 0, _("Can't stat %s\n"), full_libname);
486 if (stat_lib.st_dev == stat_so.st_dev
487 && stat_lib.st_ino == stat_so.st_ino)
488 /* Link is already correct. */
490 else if (lstat64 (full_soname, &lstat_so) == 0
491 && !S_ISLNK (lstat_so.st_mode))
493 error (0, 0, _("%s is not a symbolic link\n"), full_soname);
498 else if (lstat64 (real_full_soname, &lstat_so) != 0
499 || !S_ISLNK (lstat_so.st_mode))
500 /* Unless it is a stale symlink, there is no need to remove. */
504 printf ("\t%s -> %s", soname, libname);
506 if (do_link && opt_link)
508 /* Remove old link. */
510 if (unlink (real_full_soname))
512 error (0, 0, _("Can't unlink %s"), full_soname);
515 /* Create symbolic link. */
516 if (do_link && symlink (libname, real_full_soname))
518 error (0, 0, _("Can't link %s to %s"), full_soname, libname);
524 fputs (_(" (changed)\n"), stdout);
526 fputs (_(" (SKIPPED)\n"), stdout);
529 else if (opt_verbose)
530 fputs ("\n", stdout);
533 /* Manually link the given library. */
535 manual_link (char *library)
542 struct stat64 stat_buf;
544 unsigned int osversion;
546 /* Prepare arguments for create_links call. Split library name in
547 directory and filename first. Since path is allocated, we've got
548 to be careful to free at the end. */
549 path = xstrdup (library);
550 libname = strrchr (path, '/');
554 /* Successfully split names. Check if path is just "/" to avoid
558 libname = library + 1;
559 path = xrealloc (path, 2);
570 /* There's no path, construct one. */
572 path = xrealloc (path, 2);
578 real_path = chroot_canon (opt_chroot, path);
579 if (real_path == NULL)
581 error (0, errno, _("Can't find %s"), path);
585 real_library = alloca (strlen (real_path) + strlen (libname) + 2);
586 sprintf (real_library, "%s/%s", real_path, libname);
591 real_library = library;
594 /* Do some sanity checks first. */
595 if (lstat64 (real_library, &stat_buf))
597 error (0, errno, _("Cannot lstat %s"), library);
601 /* We don't want links here! */
602 else if (!S_ISREG (stat_buf.st_mode))
604 error (0, 0, _("Ignored file %s since it is not a regular file."),
610 if (process_file (real_library, library, libname, &flag, &osversion,
611 &soname, 0, &stat_buf))
613 error (0, 0, _("No link created since soname could not be found for %s"),
619 soname = implicit_soname (libname, flag);
620 create_links (real_path, path, libname, soname);
626 /* Read a whole directory and search for libraries.
627 The purpose is two-fold:
628 - search for libraries which will be added to the cache
629 - create symbolic links to the soname for each library
631 This has to be done separatly for each directory.
633 To keep track of which libraries to add to the cache and which
634 links to create, we save a list of all libraries.
636 The algorithm is basically:
637 for all libraries in the directory do
638 get soname of library
639 if soname is already in list
640 if new library is newer, replace entry
641 otherwise ignore this library
642 otherwise add library to list
644 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
645 exist and both have the same soname, e.g. libxy.so, a symbolic link
646 is created from libxy.so.1.2 (the newer one) to libxy.so.
647 libxy.so.1.2 and libxy.so are added to the cache - but not
650 /* Information for one library. */
657 unsigned int osversion;
658 struct dlib_entry *next;
663 search_dir (const struct dir_entry *entry)
665 uint64_t hwcap = path_hwcap (entry->path);
669 printf ("%s: (hwcap: %#.16" PRIx64 ")\n", entry->path, hwcap);
671 printf ("%s:\n", entry->path);
675 char *real_file_name;
676 size_t real_file_name_len;
677 size_t file_name_len = PATH_MAX;
678 char *file_name = alloca (file_name_len);
681 dir_name = chroot_canon (opt_chroot, entry->path);
682 real_file_name_len = PATH_MAX;
683 real_file_name = alloca (real_file_name_len);
687 dir_name = entry->path;
688 real_file_name_len = 0;
689 real_file_name = file_name;
693 if (dir_name == NULL || (dir = opendir (dir_name)) == NULL)
696 error (0, errno, _("Can't open directory %s"), entry->path);
697 if (opt_chroot && dir_name)
702 struct dirent64 *direntry;
703 struct dlib_entry *dlibs = NULL;
704 while ((direntry = readdir64 (dir)) != NULL)
707 #ifdef _DIRENT_HAVE_D_TYPE
708 /* We only look at links and regular files. */
709 if (direntry->d_type != DT_UNKNOWN
710 && direntry->d_type != DT_LNK
711 && direntry->d_type != DT_REG
712 && direntry->d_type != DT_DIR)
714 #endif /* _DIRENT_HAVE_D_TYPE */
715 /* Does this file look like a shared library or is it a hwcap
716 subdirectory? The dynamic linker is also considered as
718 if (((strncmp (direntry->d_name, "lib", 3) != 0
719 && strncmp (direntry->d_name, "ld-", 3) != 0)
720 || strstr (direntry->d_name, ".so") == NULL)
722 #ifdef _DIRENT_HAVE_D_TYPE
723 direntry->d_type == DT_REG ||
725 !is_hwcap_platform (direntry->d_name)))
728 size_t len = strlen (direntry->d_name);
729 /* Skip temporary files created by the prelink program. Files with
730 names like these are never really DSOs we want to look at. */
731 if (len >= sizeof (".#prelink#") - 1)
733 if (strcmp (direntry->d_name + len - sizeof (".#prelink#") + 1,
736 if (len >= sizeof (".#prelink#.XXXXXX") - 1
737 && memcmp (direntry->d_name + len - sizeof (".#prelink#.XXXXXX")
738 + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
741 len += strlen (entry->path) + 2;
742 if (len > file_name_len)
745 file_name = alloca (file_name_len);
747 real_file_name = file_name;
749 sprintf (file_name, "%s/%s", entry->path, direntry->d_name);
752 len = strlen (dir_name) + strlen (direntry->d_name) + 2;
753 if (len > real_file_name_len)
755 real_file_name_len = len;
756 real_file_name = alloca (real_file_name_len);
758 sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);
761 struct stat64 lstat_buf;
762 #ifdef _DIRENT_HAVE_D_TYPE
763 /* We optimize and try to do the lstat call only if needed. */
764 if (direntry->d_type != DT_UNKNOWN)
765 lstat_buf.st_mode = DTTOIF (direntry->d_type);
768 if (__builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
770 error (0, errno, _("Cannot lstat %s"), file_name);
774 struct stat64 stat_buf;
776 int is_link = S_ISLNK (lstat_buf.st_mode);
779 /* In case of symlink, we check if the symlink refers to
781 char *target_name = real_file_name;
784 target_name = chroot_canon (opt_chroot, file_name);
785 if (target_name == NULL)
787 if (strstr (file_name, ".so") == NULL)
788 error (0, 0, _("Input file %s not found.\n"), file_name);
792 if (__builtin_expect (stat64 (target_name, &stat_buf), 0))
795 error (0, errno, _("Cannot stat %s"), file_name);
797 /* Remove stale symlinks. */
798 if (strstr (direntry->d_name, ".so."))
799 unlink (real_file_name);
802 is_dir = S_ISDIR (stat_buf.st_mode);
804 /* lstat_buf is later stored, update contents. */
805 lstat_buf.st_dev = stat_buf.st_dev;
806 lstat_buf.st_ino = stat_buf.st_ino;
807 lstat_buf.st_size = stat_buf.st_size;
808 lstat_buf.st_ctime = stat_buf.st_ctime;
811 is_dir = S_ISDIR (lstat_buf.st_mode);
813 if (is_dir && is_hwcap_platform (direntry->d_name))
815 /* Handle subdirectory later. */
816 struct dir_entry *new_entry;
818 new_entry = xmalloc (sizeof (struct dir_entry));
819 new_entry->path = xstrdup (file_name);
820 new_entry->flag = entry->flag;
821 new_entry->next = NULL;
822 #ifdef _DIRENT_HAVE_D_TYPE
823 /* We have filled in lstat only #ifndef
824 _DIRENT_HAVE_D_TYPE. Fill it in if needed. */
826 && direntry->d_type != DT_UNKNOWN
827 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
829 error (0, errno, _("Cannot lstat %s"), file_name);
830 free (new_entry->path);
835 new_entry->ino = lstat_buf.st_ino;
836 new_entry->dev = lstat_buf.st_dev;
837 add_single_dir (new_entry, 0);
840 else if (!S_ISREG (lstat_buf.st_mode) && !is_link)
844 if (opt_chroot && is_link)
846 real_name = chroot_canon (opt_chroot, file_name);
847 if (real_name == NULL)
849 if (strstr (file_name, ".so") == NULL)
850 error (0, 0, _("Input file %s not found.\n"), file_name);
855 real_name = real_file_name;
857 #ifdef _DIRENT_HAVE_D_TYPE
858 /* Call lstat64 if not done yet. */
860 && direntry->d_type != DT_UNKNOWN
861 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
863 error (0, errno, _("Cannot lstat %s"), file_name);
868 /* First search whether the auxiliary cache contains this
869 library already and it's not changed. */
871 unsigned int osversion;
872 if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))
874 if (process_file (real_name, file_name, direntry->d_name, &flag,
875 &osversion, &soname, is_link, &lstat_buf))
877 if (real_name != real_file_name)
881 else if (opt_build_cache)
882 add_to_aux_cache (&lstat_buf, flag, osversion, soname);
886 soname = implicit_soname (direntry->d_name, flag);
888 /* A link may just point to itself. */
891 /* If the path the link points to isn't its soname and it is not
892 .so symlink for ld(1) only, we treat it as a normal file. */
893 const char *real_base_name = basename (real_file_name);
895 if (strcmp (real_base_name, soname) != 0)
897 len = strlen (real_base_name);
898 if (len < strlen (".so")
899 || strcmp (real_base_name + len - strlen (".so"), ".so") != 0
900 || strncmp (real_base_name, soname, len) != 0)
905 if (real_name != real_file_name)
911 soname = xstrdup (direntry->d_name);
915 && (entry->flag == FLAG_ELF_LIBC5
916 || entry->flag == FLAG_ELF_LIBC6))
919 /* Some sanity checks to print warnings. */
922 if (flag == FLAG_ELF_LIBC5 && entry->flag != FLAG_ELF_LIBC5
923 && entry->flag != FLAG_ANY)
924 error (0, 0, _("libc5 library %s in wrong directory"), file_name);
925 if (flag == FLAG_ELF_LIBC6 && entry->flag != FLAG_ELF_LIBC6
926 && entry->flag != FLAG_ANY)
927 error (0, 0, _("libc6 library %s in wrong directory"), file_name);
928 if (flag == FLAG_LIBC4 && entry->flag != FLAG_LIBC4
929 && entry->flag != FLAG_ANY)
930 error (0, 0, _("libc4 library %s in wrong directory"), file_name);
933 /* Add library to list. */
934 struct dlib_entry *dlib_ptr;
935 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
937 /* Is soname already in list? */
938 if (strcmp (dlib_ptr->soname, soname) == 0)
940 /* Prefer a file to a link, otherwise check which one
942 if ((!is_link && dlib_ptr->is_link)
943 || (is_link == dlib_ptr->is_link
944 && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
946 /* It's newer - add it. */
947 /* Flag should be the same - sanity check. */
948 if (dlib_ptr->flag != flag)
950 if (dlib_ptr->flag == FLAG_ELF
951 && (flag == FLAG_ELF_LIBC5 || flag == FLAG_ELF_LIBC6))
952 dlib_ptr->flag = flag;
953 else if ((dlib_ptr->flag == FLAG_ELF_LIBC5
954 || dlib_ptr->flag == FLAG_ELF_LIBC6)
956 dlib_ptr->flag = flag;
958 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
959 dlib_ptr->name, direntry->d_name,
962 free (dlib_ptr->name);
963 dlib_ptr->name = xstrdup (direntry->d_name);
964 dlib_ptr->is_link = is_link;
965 dlib_ptr->osversion = osversion;
967 /* Don't add this library, abort loop. */
968 /* Also free soname, since it's dynamically allocated. */
973 /* Add the library if it's not already in. */
974 if (dlib_ptr == NULL)
976 dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
977 dlib_ptr->name = xstrdup (direntry->d_name);
978 dlib_ptr->soname = soname;
979 dlib_ptr->flag = flag;
980 dlib_ptr->is_link = is_link;
981 dlib_ptr->osversion = osversion;
982 /* Add at head of list. */
983 dlib_ptr->next = dlibs;
990 /* Now dlibs contains a list of all libs - add those to the cache
991 and created all symbolic links. */
992 struct dlib_entry *dlib_ptr;
993 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
995 /* Don't create links to links. */
996 if (dlib_ptr->is_link == 0)
997 create_links (dir_name, entry->path, dlib_ptr->name,
1000 add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag,
1001 dlib_ptr->osversion, hwcap);
1004 /* Free all resources. */
1008 free (dlib_ptr->soname);
1009 free (dlib_ptr->name);
1010 dlibs = dlibs->next;
1014 if (opt_chroot && dir_name)
1018 /* Search through all libraries. */
1022 struct dir_entry *entry;
1024 for (entry = dir_entries; entry != NULL; entry = entry->next)
1027 /* Free all allocated memory. */
1030 entry = dir_entries;
1031 dir_entries = dir_entries->next;
1038 static void parse_conf_include (const char *config_file, unsigned int lineno,
1039 bool do_chroot, const char *pattern);
1041 /* Parse configuration file. */
1043 parse_conf (const char *filename, bool do_chroot)
1049 unsigned int lineno;
1051 if (do_chroot && opt_chroot)
1053 canon = chroot_canon (opt_chroot, filename);
1055 file = fopen (canon, "r");
1062 file = fopen (filename, "r");
1067 error (0, errno, _("\
1068 Warning: ignoring configuration file that cannot be opened: %s"),
1070 if (canon != filename)
1071 free ((char *) canon);
1075 /* No threads use this stream. */
1076 __fsetlocking (file, FSETLOCKING_BYCALLER);
1078 if (canon != filename)
1079 free ((char *) canon);
1084 ssize_t n = getline (&line, &len, file);
1089 if (line[n - 1] == '\n')
1092 /* Because the file format does not know any form of quoting we
1093 can search forward for the next '#' character and if found
1094 make it terminating the line. */
1095 *strchrnul (line, '#') = '\0';
1097 /* Remove leading whitespace. NUL is no whitespace character. */
1099 while (isspace (*cp))
1102 /* If the line is blank it is ignored. */
1106 if (!strncmp (cp, "include", 7) && isblank (cp[7]))
1110 while ((dir = strsep (&cp, " \t")) != NULL)
1112 parse_conf_include (filename, lineno, do_chroot, dir);
1114 else if (!strncasecmp (cp, "hwcap", 5) && isblank (cp[5]))
1117 char *p, *name = NULL;
1118 unsigned long int n = strtoul (cp, &cp, 0);
1119 if (cp != NULL && isblank (*cp))
1120 while ((p = strsep (&cp, " \t")) != NULL)
1133 error (EXIT_FAILURE, 0, _("%s:%u: bad syntax in hwcap line"),
1137 if (n >= (64 - _DL_FIRST_EXTRA))
1138 error (EXIT_FAILURE, 0,
1139 _("%s:%u: hwcap index %lu above maximum %u"),
1140 filename, lineno, n, 64 - _DL_FIRST_EXTRA - 1);
1141 if (hwcap_extra[n] == NULL)
1143 for (unsigned long int h = 0; h < (64 - _DL_FIRST_EXTRA); ++h)
1144 if (hwcap_extra[h] != NULL && !strcmp (name, hwcap_extra[h]))
1145 error (EXIT_FAILURE, 0,
1146 _("%s:%u: hwcap index %lu already defined as %s"),
1147 filename, lineno, h, name);
1148 hwcap_extra[n] = xstrdup (name);
1152 if (strcmp (name, hwcap_extra[n]))
1153 error (EXIT_FAILURE, 0,
1154 _("%s:%u: hwcap index %lu already defined as %s"),
1155 filename, lineno, n, hwcap_extra[n]);
1157 error (0, 0, _("%s:%u: duplicate hwcap %lu %s"),
1158 filename, lineno, n, name);
1164 while (!feof_unlocked (file));
1166 /* Free buffer and close file. */
1171 /* Handle one word in an `include' line, a glob pattern of additional
1172 config files to read. */
1174 parse_conf_include (const char *config_file, unsigned int lineno,
1175 bool do_chroot, const char *pattern)
1177 if (opt_chroot && pattern[0] != '/')
1178 error (EXIT_FAILURE, 0,
1179 _("need absolute file name for configuration file when using -r"));
1182 if (pattern[0] != '/' && strchr (config_file, '/') != NULL)
1184 if (asprintf (©, "%s/%s", dirname (strdupa (config_file)),
1186 error (EXIT_FAILURE, 0, _("memory exhausted"));
1192 if (do_chroot && opt_chroot)
1194 char *canon = chroot_canon (opt_chroot, pattern);
1197 result = glob64 (canon, 0, NULL, &gl);
1201 result = glob64 (pattern, 0, NULL, &gl);
1206 for (size_t i = 0; i < gl.gl_pathc; ++i)
1207 parse_conf (gl.gl_pathv[i], false);
1218 error (0, errno, _("%s:%u: cannot read directory %s"),
1219 config_file, lineno, pattern);
1230 /* Honour LD_HWCAP_MASK. */
1234 char *mask = getenv ("LD_HWCAP_MASK");
1237 hwcap_mask = strtoul (mask, NULL, 0);
1242 main (int argc, char **argv)
1244 /* Set locale via LC_ALL. */
1245 setlocale (LC_ALL, "");
1247 /* Set the text message domain. */
1248 textdomain (_libc_intl_domainname);
1250 /* Parse and process arguments. */
1252 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1254 /* Remaining arguments are additional directories if opt_manual_link
1256 if (remaining != argc && !opt_manual_link)
1259 for (i = remaining; i < argc; ++i)
1260 if (opt_build_cache && argv[i][0] != '/')
1261 error (EXIT_FAILURE, 0,
1262 _("relative path `%s' used to build cache"),
1268 hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls";
1274 /* Normalize the path a bit, we might need it for printing later. */
1275 char *endp = rawmemchr (opt_chroot, '\0');
1276 while (endp > opt_chroot && endp[-1] == '/')
1279 if (endp == opt_chroot)
1284 /* It is faster to use chroot if we can. */
1285 if (!chroot (opt_chroot))
1288 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1294 if (cache_file == NULL)
1296 cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1297 strcpy (cache_file, LD_SO_CACHE);
1300 if (config_file == NULL)
1301 config_file = LD_SO_CONF;
1303 if (opt_print_cache)
1307 char *p = chroot_canon (opt_chroot, cache_file);
1309 error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1313 print_cache (cache_file);
1321 /* Canonicalize the directory name of cache_file, not cache_file,
1322 because we'll rename a temporary cache file to it. */
1323 char *p = strrchr (cache_file, '/');
1324 char *canon = chroot_canon (opt_chroot,
1325 p ? (*p = '\0', cache_file) : "/");
1328 error (EXIT_FAILURE, errno,
1329 _("Can't open cache file directory %s\n"),
1330 p ? cache_file : "/");
1337 cache_file = alloca (strlen (canon) + strlen (p) + 2);
1338 sprintf (cache_file, "%s/%s", canon, p);
1342 if (opt_manual_link)
1344 /* Link all given libraries manually. */
1347 for (i = remaining; i < argc; ++i)
1348 manual_link (argv[i]);
1354 if (opt_build_cache)
1357 if (!opt_only_cline)
1359 parse_conf (config_file, true);
1361 /* Always add the standard search paths. */
1362 add_system_dir (SLIBDIR);
1363 if (strcmp (SLIBDIR, LIBDIR))
1364 add_system_dir (LIBDIR);
1367 const char *aux_cache_file = _PATH_LDCONFIG_AUX_CACHE;
1369 aux_cache_file = chroot_canon (opt_chroot, aux_cache_file);
1371 if (! opt_ignore_aux_cache && aux_cache_file)
1372 load_aux_cache (aux_cache_file);
1378 if (opt_build_cache)
1380 save_cache (cache_file);
1382 save_aux_cache (aux_cache_file);