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.
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 <https://www.gnu.org/licenses/>. */
18 #define PROCINFO_CLASS static
31 #include <stdio_ext.h>
36 #include <sys/fcntl.h>
39 #include <sys/types.h>
45 #include <dl-hwcaps.h>
47 #include <dl-procinfo.h>
49 /* This subpath in search path entries is always supported and
50 included in the cache for backwards compatibility. */
51 #define TLS_SUBPATH "tls"
53 /* The MSB of the hwcap field is set for objects in TLS_SUBPATH
54 directories. There is always TLS support in glibc, so the dynamic
55 loader does not check the bit directly. But more hwcap bits make a
56 an object more preferred, so the bit still has meaning. */
57 #define TLS_HWCAP_BIT 63
60 # define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
63 /* Get libc version number. */
66 #define PACKAGE _libc_intl_domainname
74 {"libc4", FLAG_LIBC4
},
75 {"libc5", FLAG_ELF_LIBC5
},
76 {"libc6", FLAG_ELF_LIBC6
},
77 {"glibc2", FLAG_ELF_LIBC6
}
81 /* List of directories to handle. */
88 const char *from_file
;
91 /* Non-NULL for subdirectories under a glibc-hwcaps subdirectory. */
92 struct glibc_hwcaps_subdirectory
*hwcaps
;
94 struct dir_entry
*next
;
97 /* The list is unsorted, contains no duplicates. Entries are added at
99 static struct dir_entry
*dir_entries
;
101 /* Flags for different options. */
103 static int opt_print_cache
;
108 /* Format to support. */
109 enum opt_format opt_format
= opt_format_new
;
112 static int opt_build_cache
= 1;
114 /* Enable symbolic link processing. If set, create or update symbolic
115 links, and remove stale symbolic links. */
116 static int opt_link
= 1;
118 /* Only process directories specified on the command line. */
119 static int opt_only_cline
;
121 /* Path to root for chroot. */
122 static char *opt_chroot
;
124 /* Manually link given shared libraries. */
125 static int opt_manual_link
;
127 /* Should we ignore an old auxiliary cache file? */
128 static int opt_ignore_aux_cache
;
130 /* Cache file to use. */
131 static char *cache_file
;
133 /* Configuration file. */
134 static const char *config_file
;
136 /* Mask to use for important hardware capabilities. */
137 static unsigned long int hwcap_mask
= HWCAP_IMPORTANT
;
139 /* Name and version of program. */
140 static void print_version (FILE *stream
, struct argp_state
*state
);
141 void (*argp_program_version_hook
) (FILE *, struct argp_state
*)
144 /* Function to print some extra text in the help message. */
145 static char *more_help (int key
, const char *text
, void *input
);
147 /* Definitions of arguments for argp functions. */
148 static const struct argp_option options
[] =
150 { "print-cache", 'p', NULL
, 0, N_("Print cache"), 0},
151 { "verbose", 'v', NULL
, 0, N_("Generate verbose messages"), 0},
152 { NULL
, 'N', NULL
, 0, N_("Don't build cache"), 0},
153 { NULL
, 'X', NULL
, 0, N_("Don't update symbolic links"), 0},
154 { NULL
, 'r', N_("ROOT"), 0, N_("Change to and use ROOT as root directory"), 0},
155 { NULL
, 'C', N_("CACHE"), 0, N_("Use CACHE as cache file"), 0},
156 { NULL
, 'f', N_("CONF"), 0, N_("Use CONF as configuration file"), 0},
157 { NULL
, 'n', NULL
, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
158 { NULL
, 'l', NULL
, 0, N_("Manually link individual libraries."), 0},
159 { "format", 'c', N_("FORMAT"), 0, N_("Format to use: new (default), old, or compat"), 0},
160 { "ignore-aux-cache", 'i', NULL
, 0, N_("Ignore auxiliary cache file"), 0},
161 { NULL
, 0, NULL
, 0, NULL
, 0 }
164 #define PROCINFO_CLASS static
165 #include <dl-procinfo.c>
167 /* Short description of program. */
168 static const char doc
[] = N_("Configure Dynamic Linker Run Time Bindings.");
170 /* Prototype for option handler. */
171 static error_t
parse_opt (int key
, char *arg
, struct argp_state
*state
);
173 /* Data structure to communicate with argp functions. */
174 static struct argp argp
=
176 options
, parse_opt
, NULL
, doc
, NULL
, more_help
, NULL
179 /* Check if string corresponds to an important hardware capability or
182 is_hwcap_platform (const char *name
)
184 int hwcap_idx
= _dl_string_hwcap (name
);
186 /* Is this a normal hwcap for the machine like "fpu?" */
187 if (hwcap_idx
!= -1 && ((1 << hwcap_idx
) & hwcap_mask
))
190 /* Is this a platform pseudo-hwcap like "i686?" */
191 hwcap_idx
= _dl_string_platform (name
);
195 /* Backwards-compatibility for the "tls" subdirectory. */
196 if (strcmp (name
, TLS_SUBPATH
) == 0)
202 /* Get hwcap (including platform) encoding of path. */
204 path_hwcap (const char *path
)
206 char *str
= xstrdup (path
);
217 /* Search pathname from the end and check for hwcap strings. */
220 ptr
= strrchr (str
, '/');
225 h
= _dl_string_hwcap (ptr
+ 1);
227 if (h
== (uint64_t) -1)
229 h
= _dl_string_platform (ptr
+ 1);
230 if (h
== (uint64_t) -1)
232 if (strcmp (ptr
+ 1, TLS_SUBPATH
) == 0)
240 /* Search the next part of the path. */
248 /* Handle program arguments. */
250 parse_opt (int key
, char *arg
, struct argp_state
*state
)
256 /* Ignore auxiliary cache since we use non-standard cache. */
257 opt_ignore_aux_cache
= 1;
263 opt_ignore_aux_cache
= 1;
288 if (strcmp (arg
, "old") == 0)
289 opt_format
= opt_format_old
;
290 else if (strcmp (arg
, "compat") == 0)
291 opt_format
= opt_format_compat
;
292 else if (strcmp (arg
, "new") == 0)
293 opt_format
= opt_format_new
;
296 return ARGP_ERR_UNKNOWN
;
302 /* Print bug-reporting information in the help message. */
304 more_help (int key
, const char *text
, void *input
)
309 case ARGP_KEY_HELP_EXTRA
:
310 /* We print some extra information. */
311 if (asprintf (&tp
, gettext ("\
312 For bug reporting instructions, please see:\n\
313 %s.\n"), REPORT_BUGS_TO
) < 0)
319 return (char *) text
;
322 /* Print the version information. */
324 print_version (FILE *stream
, struct argp_state
*state
)
326 fprintf (stream
, "ldconfig %s%s\n", PKGVERSION
, VERSION
);
327 fprintf (stream
, gettext ("\
328 Copyright (C) %s Free Software Foundation, Inc.\n\
329 This is free software; see the source for copying conditions. There is NO\n\
330 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
332 fprintf (stream
, gettext ("Written by %s.\n"),
336 /* Allocate a new subdirectory with full path PATH under ENTRY, using
337 inode data from *ST. */
338 static struct dir_entry
*
339 new_sub_entry (const struct dir_entry
*entry
, const char *path
,
340 const struct stat64
*st
)
342 struct dir_entry
*new_entry
= xmalloc (sizeof (struct dir_entry
));
343 new_entry
->from_file
= entry
->from_file
;
344 new_entry
->from_line
= entry
->from_line
;
345 new_entry
->path
= xstrdup (path
);
346 new_entry
->flag
= entry
->flag
;
347 new_entry
->hwcaps
= NULL
;
348 new_entry
->next
= NULL
;
349 new_entry
->ino
= st
->st_ino
;
350 new_entry
->dev
= st
->st_dev
;
354 /* Add a single directory entry. Return true if the directory is
355 actually added (because it is not a duplicate). */
357 add_single_dir (struct dir_entry
*entry
, int verbose
)
359 struct dir_entry
*ptr
, *prev
;
366 /* Check for duplicates. */
367 if (ptr
->ino
== entry
->ino
&& ptr
->dev
== entry
->dev
)
369 if (opt_verbose
&& verbose
)
371 error (0, 0, _("Path `%s' given more than once"), entry
->path
);
372 fprintf (stderr
, _("(from %s:%d and %s:%d)\n"),
373 entry
->from_file
, entry
->from_line
,
374 ptr
->from_file
, ptr
->from_line
);
376 /* Use the newer information. */
377 ptr
->flag
= entry
->flag
;
386 /* Is this the first entry? */
387 if (ptr
== NULL
&& dir_entries
== NULL
)
389 else if (ptr
== NULL
)
394 /* Check if PATH contains a "glibc-hwcaps" subdirectory. If so, queue
395 its subdirectories for glibc-hwcaps processing. */
397 add_glibc_hwcaps_subdirectories (struct dir_entry
*entry
, const char *path
)
399 /* glibc-hwcaps subdirectories do not nest. */
400 assert (entry
->hwcaps
== NULL
);
403 if (asprintf (&glibc_hwcaps
, "%s/" GLIBC_HWCAPS_SUBDIRECTORY
, path
) < 0)
404 error (EXIT_FAILURE
, errno
, _("Could not form glibc-hwcaps path"));
406 DIR *dir
= opendir (glibc_hwcaps
);
412 struct dirent64
*e
= readdir64 (dir
);
418 error (EXIT_FAILURE
, errno
, _("Listing directory %s"), path
);
421 /* Ignore hidden subdirectories, including "." and "..", and
422 regular files. File names containing a ':' cannot be
423 looked up by the dynamic loader, so skip those as
425 if (e
->d_name
[0] == '.' || e
->d_type
== DT_REG
426 || strchr (e
->d_name
, ':') != NULL
)
429 /* See if this entry eventually resolves to a directory. */
431 if (fstatat64 (dirfd (dir
), e
->d_name
, &st
, 0) < 0)
432 /* Ignore unreadable entries. */
435 if (S_ISDIR (st
.st_mode
))
437 /* This is a directory, so it needs to be scanned for
438 libraries, associated with the hwcaps implied by the
439 subdirectory name. */
441 if (asprintf (&new_path
, "%s/" GLIBC_HWCAPS_SUBDIRECTORY
"/%s",
442 /* Use non-canonicalized path here. */
443 entry
->path
, e
->d_name
) < 0)
444 error (EXIT_FAILURE
, errno
,
445 _("Could not form glibc-hwcaps path"));
446 struct dir_entry
*new_entry
= new_sub_entry (entry
, new_path
,
449 new_entry
->hwcaps
= new_glibc_hwcaps_subdirectory (e
->d_name
);
450 add_single_dir (new_entry
, 0);
460 /* Add one directory to the list of directories to process. */
462 add_dir_1 (const char *line
, const char *from_file
, int from_line
)
465 struct dir_entry
*entry
= xmalloc (sizeof (struct dir_entry
));
466 entry
->hwcaps
= NULL
;
469 entry
->from_file
= strdup (from_file
);
470 entry
->from_line
= from_line
;
472 /* Search for an '=' sign. */
473 entry
->path
= xstrdup (line
);
474 char *equal_sign
= strchr (entry
->path
, '=');
479 entry
->flag
= FLAG_ANY
;
480 for (i
= 0; i
< sizeof (lib_types
) / sizeof (lib_types
[0]); ++i
)
481 if (strcmp (equal_sign
, lib_types
[i
].name
) == 0)
483 entry
->flag
= lib_types
[i
].flag
;
486 if (entry
->flag
== FLAG_ANY
)
487 error (0, 0, _("%s is not a known library type"), equal_sign
);
491 entry
->flag
= FLAG_ANY
;
494 /* Canonify path: for now only remove leading and trailing
495 whitespace and the trailing slashes. */
496 i
= strlen (entry
->path
);
498 while (i
> 0 && isspace (entry
->path
[i
- 1]))
499 entry
->path
[--i
] = '\0';
501 while (i
> 0 && entry
->path
[i
- 1] == '/')
502 entry
->path
[--i
] = '\0';
507 char *path
= entry
->path
;
509 path
= chroot_canon (opt_chroot
, path
);
511 struct stat64 stat_buf
;
512 if (path
== NULL
|| stat64 (path
, &stat_buf
))
515 error (0, errno
, _("Can't stat %s"), entry
->path
);
521 entry
->ino
= stat_buf
.st_ino
;
522 entry
->dev
= stat_buf
.st_dev
;
524 if (add_single_dir (entry
, 1))
525 /* Add glibc-hwcaps subdirectories if present. */
526 add_glibc_hwcaps_subdirectories (entry
, path
);
534 add_dir (const char *line
)
536 add_dir_1 (line
, "<builtin>", 0);
540 chroot_stat (const char *real_path
, const char *path
, struct stat64
*st
)
546 return stat64 (real_path
, st
);
548 ret
= lstat64 (real_path
, st
);
549 if (ret
|| !S_ISLNK (st
->st_mode
))
552 canon_path
= chroot_canon (opt_chroot
, path
);
553 if (canon_path
== NULL
)
556 ret
= stat64 (canon_path
, st
);
561 /* Create a symbolic link from soname to libname in directory path. */
563 create_links (const char *real_path
, const char *path
, const char *libname
,
566 char *full_libname
, *full_soname
;
567 char *real_full_libname
, *real_full_soname
;
568 struct stat64 stat_lib
, stat_so
, lstat_so
;
571 /* XXX: The logics in this function should be simplified. */
573 /* Get complete path. */
574 full_libname
= alloca (strlen (path
) + strlen (libname
) + 2);
575 full_soname
= alloca (strlen (path
) + strlen (soname
) + 2);
576 sprintf (full_libname
, "%s/%s", path
, libname
);
577 sprintf (full_soname
, "%s/%s", path
, soname
);
580 real_full_libname
= alloca (strlen (real_path
) + strlen (libname
) + 2);
581 real_full_soname
= alloca (strlen (real_path
) + strlen (soname
) + 2);
582 sprintf (real_full_libname
, "%s/%s", real_path
, libname
);
583 sprintf (real_full_soname
, "%s/%s", real_path
, soname
);
587 real_full_libname
= full_libname
;
588 real_full_soname
= full_soname
;
591 /* Does soname already exist and point to the right library? */
592 if (chroot_stat (real_full_soname
, full_soname
, &stat_so
) == 0)
594 if (chroot_stat (real_full_libname
, full_libname
, &stat_lib
))
596 error (0, 0, _("Can't stat %s\n"), full_libname
);
599 if (stat_lib
.st_dev
== stat_so
.st_dev
600 && stat_lib
.st_ino
== stat_so
.st_ino
)
601 /* Link is already correct. */
603 else if (lstat64 (full_soname
, &lstat_so
) == 0
604 && !S_ISLNK (lstat_so
.st_mode
))
606 error (0, 0, _("%s is not a symbolic link\n"), full_soname
);
611 else if (lstat64 (real_full_soname
, &lstat_so
) != 0
612 || !S_ISLNK (lstat_so
.st_mode
))
613 /* Unless it is a stale symlink, there is no need to remove. */
617 printf ("\t%s -> %s", soname
, libname
);
619 if (do_link
&& opt_link
)
621 /* Remove old link. */
623 if (unlink (real_full_soname
))
625 error (0, 0, _("Can't unlink %s"), full_soname
);
628 /* Create symbolic link. */
629 if (do_link
&& symlink (libname
, real_full_soname
))
631 error (0, 0, _("Can't link %s to %s"), full_soname
, libname
);
637 fputs (_(" (changed)\n"), stdout
);
639 fputs (_(" (SKIPPED)\n"), stdout
);
642 else if (opt_verbose
)
643 fputs ("\n", stdout
);
646 /* Manually link the given library. */
648 manual_link (char *library
)
655 struct stat64 stat_buf
;
657 unsigned int osversion
;
659 /* Prepare arguments for create_links call. Split library name in
660 directory and filename first. Since path is allocated, we've got
661 to be careful to free at the end. */
662 path
= xstrdup (library
);
663 libname
= strrchr (path
, '/');
667 /* Successfully split names. Check if path is just "/" to avoid
671 libname
= library
+ 1;
672 path
= xrealloc (path
, 2);
683 /* There's no path, construct one. */
685 path
= xrealloc (path
, 2);
691 real_path
= chroot_canon (opt_chroot
, path
);
692 if (real_path
== NULL
)
694 error (0, errno
, _("Can't find %s"), path
);
698 real_library
= alloca (strlen (real_path
) + strlen (libname
) + 2);
699 sprintf (real_library
, "%s/%s", real_path
, libname
);
704 real_library
= library
;
707 /* Do some sanity checks first. */
708 if (lstat64 (real_library
, &stat_buf
))
710 error (0, errno
, _("Cannot lstat %s"), library
);
714 /* We don't want links here! */
715 else if (!S_ISREG (stat_buf
.st_mode
))
717 error (0, 0, _("Ignored file %s since it is not a regular file."),
723 if (process_file (real_library
, library
, libname
, &flag
, &osversion
,
724 &soname
, 0, &stat_buf
))
726 error (0, 0, _("No link created since soname could not be found for %s"),
732 soname
= implicit_soname (libname
, flag
);
733 create_links (real_path
, path
, libname
, soname
);
739 /* Read a whole directory and search for libraries.
740 The purpose is two-fold:
741 - search for libraries which will be added to the cache
742 - create symbolic links to the soname for each library
744 This has to be done separatly for each directory.
746 To keep track of which libraries to add to the cache and which
747 links to create, we save a list of all libraries.
749 The algorithm is basically:
750 for all libraries in the directory do
751 get soname of library
752 if soname is already in list
753 if new library is newer, replace entry
754 otherwise ignore this library
755 otherwise add library to list
757 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
758 exist and both have the same soname, e.g. libxy.so, a symbolic link
759 is created from libxy.so.1.2 (the newer one) to libxy.so.
760 libxy.so.1.2 and libxy.so are added to the cache - but not
763 /* Information for one library. */
770 unsigned int osversion
;
771 struct dlib_entry
*next
;
776 search_dir (const struct dir_entry
*entry
)
779 if (entry
->hwcaps
== NULL
)
781 hwcap
= path_hwcap (entry
->path
);
785 printf ("%s: (hwcap: %#.16" PRIx64
")", entry
->path
, hwcap
);
787 printf ("%s:", entry
->path
);
794 printf ("%s: (hwcap: \"%s\")", entry
->path
,
795 glibc_hwcaps_subdirectory_name (entry
->hwcaps
));
798 printf (_(" (from %s:%d)\n"), entry
->from_file
, entry
->from_line
);
801 char *real_file_name
;
802 size_t real_file_name_len
;
803 size_t file_name_len
= PATH_MAX
;
804 char *file_name
= alloca (file_name_len
);
807 dir_name
= chroot_canon (opt_chroot
, entry
->path
);
808 real_file_name_len
= PATH_MAX
;
809 real_file_name
= alloca (real_file_name_len
);
813 dir_name
= entry
->path
;
814 real_file_name_len
= 0;
815 real_file_name
= file_name
;
819 if (dir_name
== NULL
|| (dir
= opendir (dir_name
)) == NULL
)
822 error (0, errno
, _("Can't open directory %s"), entry
->path
);
823 if (opt_chroot
&& dir_name
)
828 struct dirent64
*direntry
;
829 struct dlib_entry
*dlibs
= NULL
;
830 while ((direntry
= readdir64 (dir
)) != NULL
)
833 /* We only look at links and regular files. */
834 if (direntry
->d_type
!= DT_UNKNOWN
835 && direntry
->d_type
!= DT_LNK
836 && direntry
->d_type
!= DT_REG
837 && direntry
->d_type
!= DT_DIR
)
839 /* Does this file look like a shared library or is it a hwcap
840 subdirectory (if not already processing a glibc-hwcaps
841 subdirectory)? The dynamic linker is also considered as
843 if (((strncmp (direntry
->d_name
, "lib", 3) != 0
844 && strncmp (direntry
->d_name
, "ld-", 3) != 0)
845 || strstr (direntry
->d_name
, ".so") == NULL
)
846 && (direntry
->d_type
== DT_REG
847 || (entry
->hwcaps
== NULL
848 && !is_hwcap_platform (direntry
->d_name
))))
851 size_t len
= strlen (direntry
->d_name
);
852 /* Skip temporary files created by the prelink program. Files with
853 names like these are never really DSOs we want to look at. */
854 if (len
>= sizeof (".#prelink#") - 1)
856 if (strcmp (direntry
->d_name
+ len
- sizeof (".#prelink#") + 1,
859 if (len
>= sizeof (".#prelink#.XXXXXX") - 1
860 && memcmp (direntry
->d_name
+ len
- sizeof (".#prelink#.XXXXXX")
861 + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
864 len
+= strlen (entry
->path
) + 2;
865 if (len
> file_name_len
)
868 file_name
= alloca (file_name_len
);
870 real_file_name
= file_name
;
872 sprintf (file_name
, "%s/%s", entry
->path
, direntry
->d_name
);
875 len
= strlen (dir_name
) + strlen (direntry
->d_name
) + 2;
876 if (len
> real_file_name_len
)
878 real_file_name_len
= len
;
879 real_file_name
= alloca (real_file_name_len
);
881 sprintf (real_file_name
, "%s/%s", dir_name
, direntry
->d_name
);
884 struct stat64 lstat_buf
;
885 /* We optimize and try to do the lstat call only if needed. */
886 if (direntry
->d_type
!= DT_UNKNOWN
)
887 lstat_buf
.st_mode
= DTTOIF (direntry
->d_type
);
889 if (__glibc_unlikely (lstat64 (real_file_name
, &lstat_buf
)))
891 error (0, errno
, _("Cannot lstat %s"), file_name
);
895 struct stat64 stat_buf
;
897 int is_link
= S_ISLNK (lstat_buf
.st_mode
);
900 /* In case of symlink, we check if the symlink refers to
902 char *target_name
= real_file_name
;
905 target_name
= chroot_canon (opt_chroot
, file_name
);
906 if (target_name
== NULL
)
908 if (strstr (file_name
, ".so") == NULL
)
909 error (0, 0, _("Input file %s not found.\n"), file_name
);
913 if (__glibc_unlikely (stat64 (target_name
, &stat_buf
)))
916 error (0, errno
, _("Cannot stat %s"), file_name
);
918 /* Remove stale symlinks. */
919 if (opt_link
&& strstr (direntry
->d_name
, ".so."))
920 unlink (real_file_name
);
923 is_dir
= S_ISDIR (stat_buf
.st_mode
);
925 /* lstat_buf is later stored, update contents. */
926 lstat_buf
.st_dev
= stat_buf
.st_dev
;
927 lstat_buf
.st_ino
= stat_buf
.st_ino
;
928 lstat_buf
.st_size
= stat_buf
.st_size
;
929 lstat_buf
.st_ctime
= stat_buf
.st_ctime
;
932 is_dir
= S_ISDIR (lstat_buf
.st_mode
);
934 /* No descending into subdirectories if this directory is a
935 glibc-hwcaps subdirectory (which are not recursive). */
936 if (entry
->hwcaps
== NULL
937 && is_dir
&& is_hwcap_platform (direntry
->d_name
))
940 && direntry
->d_type
!= DT_UNKNOWN
941 && __builtin_expect (lstat64 (real_file_name
, &lstat_buf
), 0))
943 error (0, errno
, _("Cannot lstat %s"), file_name
);
947 /* Handle subdirectory later. */
948 struct dir_entry
*new_entry
= new_sub_entry (entry
, file_name
,
950 add_single_dir (new_entry
, 0);
953 else if (!S_ISREG (lstat_buf
.st_mode
) && !is_link
)
957 if (opt_chroot
&& is_link
)
959 real_name
= chroot_canon (opt_chroot
, file_name
);
960 if (real_name
== NULL
)
962 if (strstr (file_name
, ".so") == NULL
)
963 error (0, 0, _("Input file %s not found.\n"), file_name
);
968 real_name
= real_file_name
;
970 /* Call lstat64 if not done yet. */
972 && direntry
->d_type
!= DT_UNKNOWN
973 && __builtin_expect (lstat64 (real_file_name
, &lstat_buf
), 0))
975 error (0, errno
, _("Cannot lstat %s"), file_name
);
979 /* First search whether the auxiliary cache contains this
980 library already and it's not changed. */
982 unsigned int osversion
;
983 if (!search_aux_cache (&lstat_buf
, &flag
, &osversion
, &soname
))
985 if (process_file (real_name
, file_name
, direntry
->d_name
, &flag
,
986 &osversion
, &soname
, is_link
, &lstat_buf
))
988 if (real_name
!= real_file_name
)
992 else if (opt_build_cache
)
993 add_to_aux_cache (&lstat_buf
, flag
, osversion
, soname
);
997 soname
= implicit_soname (direntry
->d_name
, flag
);
999 /* A link may just point to itself. */
1002 /* If the path the link points to isn't its soname or it is not
1003 the .so symlink for ld(1), we treat it as a normal file.
1005 You should always do this:
1007 libfoo.so -> SONAME -> Arbitrary package-chosen name.
1009 e.g. libfoo.so -> libfoo.so.1 -> libfooimp.so.9.99.
1010 Given a SONAME of libfoo.so.1.
1012 You should *never* do this:
1014 libfoo.so -> libfooimp.so.9.99
1016 If you do, and your SONAME is libfoo.so.1, then libfoo.so
1017 fails to point at the SONAME. In that case ldconfig may consider
1018 libfoo.so as another implementation of SONAME and will create
1019 symlinks against it causing problems when you try to upgrade
1020 or downgrade. The problems will arise because ldconfig will,
1021 depending on directory ordering, creat symlinks against libfoo.so
1022 e.g. libfoo.so.1.2 -> libfoo.so, but when libfoo.so is removed
1023 (typically by the removal of a development pacakge not required
1024 for the runtime) it will break the libfoo.so.1.2 symlink and the
1025 application will fail to start. */
1026 const char *real_base_name
= basename (real_file_name
);
1028 if (strcmp (real_base_name
, soname
) != 0)
1030 len
= strlen (real_base_name
);
1031 if (len
< strlen (".so")
1032 || strcmp (real_base_name
+ len
- strlen (".so"), ".so") != 0
1033 || strncmp (real_base_name
, soname
, len
) != 0)
1038 if (real_name
!= real_file_name
)
1044 soname
= xstrdup (direntry
->d_name
);
1047 if (flag
== FLAG_ELF
1048 && (entry
->flag
== FLAG_ELF_LIBC5
1049 || entry
->flag
== FLAG_ELF_LIBC6
))
1052 /* Some sanity checks to print warnings. */
1055 if (flag
== FLAG_ELF_LIBC5
&& entry
->flag
!= FLAG_ELF_LIBC5
1056 && entry
->flag
!= FLAG_ANY
)
1057 error (0, 0, _("libc5 library %s in wrong directory"), file_name
);
1058 if (flag
== FLAG_ELF_LIBC6
&& entry
->flag
!= FLAG_ELF_LIBC6
1059 && entry
->flag
!= FLAG_ANY
)
1060 error (0, 0, _("libc6 library %s in wrong directory"), file_name
);
1061 if (flag
== FLAG_LIBC4
&& entry
->flag
!= FLAG_LIBC4
1062 && entry
->flag
!= FLAG_ANY
)
1063 error (0, 0, _("libc4 library %s in wrong directory"), file_name
);
1066 /* Add library to list. */
1067 struct dlib_entry
*dlib_ptr
;
1068 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
1070 /* Is soname already in list? */
1071 if (strcmp (dlib_ptr
->soname
, soname
) == 0)
1073 /* Prefer a file to a link, otherwise check which one
1075 if ((!is_link
&& dlib_ptr
->is_link
)
1076 || (is_link
== dlib_ptr
->is_link
1077 && _dl_cache_libcmp (dlib_ptr
->name
, direntry
->d_name
) < 0))
1079 /* It's newer - add it. */
1080 /* Flag should be the same - sanity check. */
1081 if (dlib_ptr
->flag
!= flag
)
1083 if (dlib_ptr
->flag
== FLAG_ELF
1084 && (flag
== FLAG_ELF_LIBC5
|| flag
== FLAG_ELF_LIBC6
))
1085 dlib_ptr
->flag
= flag
;
1086 else if ((dlib_ptr
->flag
== FLAG_ELF_LIBC5
1087 || dlib_ptr
->flag
== FLAG_ELF_LIBC6
)
1088 && flag
== FLAG_ELF
)
1089 dlib_ptr
->flag
= flag
;
1091 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
1092 dlib_ptr
->name
, direntry
->d_name
,
1095 free (dlib_ptr
->name
);
1096 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
1097 dlib_ptr
->is_link
= is_link
;
1098 dlib_ptr
->osversion
= osversion
;
1100 /* Don't add this library, abort loop. */
1101 /* Also free soname, since it's dynamically allocated. */
1106 /* Add the library if it's not already in. */
1107 if (dlib_ptr
== NULL
)
1109 dlib_ptr
= (struct dlib_entry
*)xmalloc (sizeof (struct dlib_entry
));
1110 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
1111 dlib_ptr
->soname
= soname
;
1112 dlib_ptr
->flag
= flag
;
1113 dlib_ptr
->is_link
= is_link
;
1114 dlib_ptr
->osversion
= osversion
;
1115 /* Add at head of list. */
1116 dlib_ptr
->next
= dlibs
;
1123 /* Now dlibs contains a list of all libs - add those to the cache
1124 and created all symbolic links. */
1125 struct dlib_entry
*dlib_ptr
;
1126 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
1128 /* The cached file name is the soname for non-glibc-hwcaps
1129 subdirectories (relying on symbolic links; this helps with
1130 library updates that change the file name), and the actual
1131 file for glibc-hwcaps subdirectories. */
1132 const char *filename
;
1133 if (entry
->hwcaps
== NULL
)
1135 /* Don't create links to links. */
1136 if (dlib_ptr
->is_link
== 0)
1137 create_links (dir_name
, entry
->path
, dlib_ptr
->name
,
1139 filename
= dlib_ptr
->soname
;
1143 /* Do not create links in glibc-hwcaps subdirectories, but
1144 still log the cache addition. */
1146 printf ("\t%s -> %s\n", dlib_ptr
->soname
, dlib_ptr
->name
);
1147 filename
= dlib_ptr
->name
;
1149 if (opt_build_cache
)
1150 add_to_cache (entry
->path
, filename
, dlib_ptr
->soname
,
1151 dlib_ptr
->flag
, dlib_ptr
->osversion
,
1152 hwcap
, entry
->hwcaps
);
1155 /* Free all resources. */
1159 free (dlib_ptr
->soname
);
1160 free (dlib_ptr
->name
);
1161 dlibs
= dlibs
->next
;
1165 if (opt_chroot
&& dir_name
)
1169 /* Search through all libraries. */
1173 struct dir_entry
*entry
;
1175 for (entry
= dir_entries
; entry
!= NULL
; entry
= entry
->next
)
1178 /* Free all allocated memory. */
1181 entry
= dir_entries
;
1182 dir_entries
= dir_entries
->next
;
1189 static void parse_conf_include (const char *config_file
, unsigned int lineno
,
1190 bool do_chroot
, const char *pattern
);
1192 /* Parse configuration file. */
1194 parse_conf (const char *filename
, bool do_chroot
)
1200 unsigned int lineno
;
1202 if (do_chroot
&& opt_chroot
)
1204 canon
= chroot_canon (opt_chroot
, filename
);
1206 file
= fopen (canon
, "r");
1213 file
= fopen (filename
, "r");
1218 if (errno
!= ENOENT
)
1219 error (0, errno
, _("\
1220 Warning: ignoring configuration file that cannot be opened: %s"),
1222 if (canon
!= filename
)
1223 free ((char *) canon
);
1227 /* No threads use this stream. */
1228 __fsetlocking (file
, FSETLOCKING_BYCALLER
);
1230 if (canon
!= filename
)
1231 free ((char *) canon
);
1236 ssize_t n
= getline (&line
, &len
, file
);
1241 if (line
[n
- 1] == '\n')
1244 /* Because the file format does not know any form of quoting we
1245 can search forward for the next '#' character and if found
1246 make it terminating the line. */
1247 *strchrnul (line
, '#') = '\0';
1249 /* Remove leading whitespace. NUL is no whitespace character. */
1251 while (isspace (*cp
))
1254 /* If the line is blank it is ignored. */
1258 if (!strncmp (cp
, "include", 7) && isblank (cp
[7]))
1262 while ((dir
= strsep (&cp
, " \t")) != NULL
)
1264 parse_conf_include (filename
, lineno
, do_chroot
, dir
);
1266 else if (!strncasecmp (cp
, "hwcap", 5) && isblank (cp
[5]))
1267 error (0, 0, _("%s:%u: hwcap directive ignored"), filename
, lineno
);
1269 add_dir_1 (cp
, filename
, lineno
);
1271 while (!feof_unlocked (file
));
1273 /* Free buffer and close file. */
1278 /* Handle one word in an `include' line, a glob pattern of additional
1279 config files to read. */
1281 parse_conf_include (const char *config_file
, unsigned int lineno
,
1282 bool do_chroot
, const char *pattern
)
1284 if (opt_chroot
&& pattern
[0] != '/')
1285 error (EXIT_FAILURE
, 0,
1286 _("need absolute file name for configuration file when using -r"));
1289 if (pattern
[0] != '/' && strchr (config_file
, '/') != NULL
)
1291 if (asprintf (©
, "%s/%s", dirname (strdupa (config_file
)),
1293 error (EXIT_FAILURE
, 0, _("memory exhausted"));
1299 if (do_chroot
&& opt_chroot
)
1301 char *canon
= chroot_canon (opt_chroot
, pattern
);
1304 result
= glob64 (canon
, 0, NULL
, &gl
);
1308 result
= glob64 (pattern
, 0, NULL
, &gl
);
1313 for (size_t i
= 0; i
< gl
.gl_pathc
; ++i
)
1314 parse_conf (gl
.gl_pathv
[i
], false);
1326 error (0, errno
, _("%s:%u: cannot read directory %s"),
1327 config_file
, lineno
, pattern
);
1338 /* Honour LD_HWCAP_MASK. */
1342 char *mask
= getenv ("LD_HWCAP_MASK");
1345 hwcap_mask
= strtoul (mask
, NULL
, 0);
1350 main (int argc
, char **argv
)
1352 /* Set locale via LC_ALL. */
1353 setlocale (LC_ALL
, "");
1355 /* But keep the C collation. That way `include' directives using
1356 globbing patterns are processed in a locale-independent order. */
1357 setlocale (LC_COLLATE
, "C");
1359 /* Set the text message domain. */
1360 textdomain (_libc_intl_domainname
);
1362 /* Parse and process arguments. */
1364 argp_parse (&argp
, argc
, argv
, 0, &remaining
, NULL
);
1366 /* Remaining arguments are additional directories if opt_manual_link
1368 if (remaining
!= argc
&& !opt_manual_link
)
1371 for (i
= remaining
; i
< argc
; ++i
)
1372 if (opt_build_cache
&& argv
[i
][0] != '/')
1373 error (EXIT_FAILURE
, 0,
1374 _("relative path `%s' used to build cache"),
1377 add_dir_1 (argv
[i
], "<cmdline>", 0);
1384 /* Normalize the path a bit, we might need it for printing later. */
1385 char *endp
= rawmemchr (opt_chroot
, '\0');
1386 while (endp
> opt_chroot
&& endp
[-1] == '/')
1389 if (endp
== opt_chroot
)
1394 /* It is faster to use chroot if we can. */
1395 if (!chroot (opt_chroot
))
1398 error (EXIT_FAILURE
, errno
, _("Can't chdir to /"));
1404 if (cache_file
== NULL
)
1406 cache_file
= alloca (strlen (LD_SO_CACHE
) + 1);
1407 strcpy (cache_file
, LD_SO_CACHE
);
1410 if (config_file
== NULL
)
1411 config_file
= LD_SO_CONF
;
1413 if (opt_print_cache
)
1417 char *p
= chroot_canon (opt_chroot
, cache_file
);
1419 error (EXIT_FAILURE
, errno
, _("Can't open cache file %s\n"),
1423 print_cache (cache_file
);
1431 /* Canonicalize the directory name of cache_file, not cache_file,
1432 because we'll rename a temporary cache file to it. */
1433 char *p
= strrchr (cache_file
, '/');
1434 char *canon
= chroot_canon (opt_chroot
,
1435 p
? (*p
= '\0', cache_file
) : "/");
1438 error (EXIT_FAILURE
, errno
,
1439 _("Can't open cache file directory %s\n"),
1440 p
? cache_file
: "/");
1447 cache_file
= alloca (strlen (canon
) + strlen (p
) + 2);
1448 sprintf (cache_file
, "%s/%s", canon
, p
);
1452 if (opt_manual_link
)
1454 /* Link all given libraries manually. */
1457 for (i
= remaining
; i
< argc
; ++i
)
1458 manual_link (argv
[i
]);
1464 if (opt_build_cache
)
1467 if (!opt_only_cline
)
1469 parse_conf (config_file
, true);
1471 /* Always add the standard search paths. */
1472 add_system_dir (SLIBDIR
);
1473 if (strcmp (SLIBDIR
, LIBDIR
))
1474 add_system_dir (LIBDIR
);
1477 const char *aux_cache_file
= _PATH_LDCONFIG_AUX_CACHE
;
1479 aux_cache_file
= chroot_canon (opt_chroot
, aux_cache_file
);
1481 if (! opt_ignore_aux_cache
&& aux_cache_file
)
1482 load_aux_cache (aux_cache_file
);
1488 if (opt_build_cache
)
1490 save_cache (cache_file
);
1492 save_aux_cache (aux_cache_file
);