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
30 #include <stdio_ext.h>
35 #include <sys/fcntl.h>
38 #include <sys/types.h>
45 #include <dl-procinfo.h>
47 /* This subpath in search path entries is always supported and
48 included in the cache for backwards compatibility. */
49 #define TLS_SUBPATH "tls"
51 /* The MSB of the hwcap field is set for objects in TLS_SUBPATH
52 directories. There is always TLS support in glibc, so the dynamic
53 loader does not check the bit directly. But more hwcap bits make a
54 an object more preferred, so the bit still has meaning. */
55 #define TLS_HWCAP_BIT 63
58 # define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
61 /* Get libc version number. */
64 #define PACKAGE _libc_intl_domainname
72 {"libc4", FLAG_LIBC4
},
73 {"libc5", FLAG_ELF_LIBC5
},
74 {"libc6", FLAG_ELF_LIBC6
},
75 {"glibc2", FLAG_ELF_LIBC6
}
79 /* List of directories to handle. */
86 const char *from_file
;
88 struct dir_entry
*next
;
91 /* The list is unsorted, contains no duplicates. Entries are added at
93 static struct dir_entry
*dir_entries
;
95 /* Flags for different options. */
97 static int opt_print_cache
;
102 /* Format to support. */
103 /* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
107 static int opt_build_cache
= 1;
109 /* Enable symbolic link processing. If set, create or update symbolic
110 links, and remove stale symbolic links. */
111 static int opt_link
= 1;
113 /* Only process directories specified on the command line. */
114 static int opt_only_cline
;
116 /* Path to root for chroot. */
117 static char *opt_chroot
;
119 /* Manually link given shared libraries. */
120 static int opt_manual_link
;
122 /* Should we ignore an old auxiliary cache file? */
123 static int opt_ignore_aux_cache
;
125 /* Cache file to use. */
126 static char *cache_file
;
128 /* Configuration file. */
129 static const char *config_file
;
131 /* Mask to use for important hardware capabilities. */
132 static unsigned long int hwcap_mask
= HWCAP_IMPORTANT
;
134 /* Name and version of program. */
135 static void print_version (FILE *stream
, struct argp_state
*state
);
136 void (*argp_program_version_hook
) (FILE *, struct argp_state
*)
139 /* Function to print some extra text in the help message. */
140 static char *more_help (int key
, const char *text
, void *input
);
142 /* Definitions of arguments for argp functions. */
143 static const struct argp_option options
[] =
145 { "print-cache", 'p', NULL
, 0, N_("Print cache"), 0},
146 { "verbose", 'v', NULL
, 0, N_("Generate verbose messages"), 0},
147 { NULL
, 'N', NULL
, 0, N_("Don't build cache"), 0},
148 { NULL
, 'X', NULL
, 0, N_("Don't update symbolic links"), 0},
149 { NULL
, 'r', N_("ROOT"), 0, N_("Change to and use ROOT as root directory"), 0},
150 { NULL
, 'C', N_("CACHE"), 0, N_("Use CACHE as cache file"), 0},
151 { NULL
, 'f', N_("CONF"), 0, N_("Use CONF as configuration file"), 0},
152 { NULL
, 'n', NULL
, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
153 { NULL
, 'l', NULL
, 0, N_("Manually link individual libraries."), 0},
154 { "format", 'c', N_("FORMAT"), 0, N_("Format to use: new (default), old, or compat"), 0},
155 { "ignore-aux-cache", 'i', NULL
, 0, N_("Ignore auxiliary cache file"), 0},
156 { NULL
, 0, NULL
, 0, NULL
, 0 }
159 #define PROCINFO_CLASS static
160 #include <dl-procinfo.c>
162 /* Short description of program. */
163 static const char doc
[] = N_("Configure Dynamic Linker Run Time Bindings.");
165 /* Prototype for option handler. */
166 static error_t
parse_opt (int key
, char *arg
, struct argp_state
*state
);
168 /* Data structure to communicate with argp functions. */
169 static struct argp argp
=
171 options
, parse_opt
, NULL
, doc
, NULL
, more_help
, NULL
174 /* Check if string corresponds to an important hardware capability or
177 is_hwcap_platform (const char *name
)
179 int hwcap_idx
= _dl_string_hwcap (name
);
181 /* Is this a normal hwcap for the machine like "fpu?" */
182 if (hwcap_idx
!= -1 && ((1 << hwcap_idx
) & hwcap_mask
))
185 /* Is this a platform pseudo-hwcap like "i686?" */
186 hwcap_idx
= _dl_string_platform (name
);
190 /* Backwards-compatibility for the "tls" subdirectory. */
191 if (strcmp (name
, TLS_SUBPATH
) == 0)
197 /* Get hwcap (including platform) encoding of path. */
199 path_hwcap (const char *path
)
201 char *str
= xstrdup (path
);
212 /* Search pathname from the end and check for hwcap strings. */
215 ptr
= strrchr (str
, '/');
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 if (strcmp (ptr
+ 1, TLS_SUBPATH
) == 0)
235 /* Search the next part of the path. */
243 /* Handle program arguments. */
245 parse_opt (int key
, char *arg
, struct argp_state
*state
)
251 /* Ignore auxiliary cache since we use non-standard cache. */
252 opt_ignore_aux_cache
= 1;
258 opt_ignore_aux_cache
= 1;
283 if (strcmp (arg
, "old") == 0)
285 else if (strcmp (arg
, "compat") == 0)
287 else if (strcmp (arg
, "new") == 0)
291 return ARGP_ERR_UNKNOWN
;
297 /* Print bug-reporting information in the help message. */
299 more_help (int key
, const char *text
, void *input
)
304 case ARGP_KEY_HELP_EXTRA
:
305 /* We print some extra information. */
306 if (asprintf (&tp
, gettext ("\
307 For bug reporting instructions, please see:\n\
308 %s.\n"), REPORT_BUGS_TO
) < 0)
314 return (char *) text
;
317 /* Print the version information. */
319 print_version (FILE *stream
, struct argp_state
*state
)
321 fprintf (stream
, "ldconfig %s%s\n", PKGVERSION
, VERSION
);
322 fprintf (stream
, gettext ("\
323 Copyright (C) %s Free Software Foundation, Inc.\n\
324 This is free software; see the source for copying conditions. There is NO\n\
325 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
327 fprintf (stream
, gettext ("Written by %s.\n"),
331 /* Allocate a new subdirectory with full path PATH under ENTRY, using
332 inode data from *ST. */
333 static struct dir_entry
*
334 new_sub_entry (const struct dir_entry
*entry
, const char *path
,
335 const struct stat64
*st
)
337 struct dir_entry
*new_entry
= xmalloc (sizeof (struct dir_entry
));
338 new_entry
->from_file
= entry
->from_file
;
339 new_entry
->from_line
= entry
->from_line
;
340 new_entry
->path
= xstrdup (path
);
341 new_entry
->flag
= entry
->flag
;
342 new_entry
->next
= NULL
;
343 new_entry
->ino
= st
->st_ino
;
344 new_entry
->dev
= st
->st_dev
;
348 /* Add a single directory entry. */
350 add_single_dir (struct dir_entry
*entry
, int verbose
)
352 struct dir_entry
*ptr
, *prev
;
358 /* Check for duplicates. */
359 if (ptr
->ino
== entry
->ino
&& ptr
->dev
== entry
->dev
)
361 if (opt_verbose
&& verbose
)
363 error (0, 0, _("Path `%s' given more than once"), entry
->path
);
364 fprintf (stderr
, _("(from %s:%d and %s:%d)\n"),
365 entry
->from_file
, entry
->from_line
,
366 ptr
->from_file
, ptr
->from_line
);
368 /* Use the newer information. */
369 ptr
->flag
= entry
->flag
;
377 /* Is this the first entry? */
378 if (ptr
== NULL
&& dir_entries
== NULL
)
380 else if (ptr
== NULL
)
384 /* Add one directory to the list of directories to process. */
386 add_dir_1 (const char *line
, const char *from_file
, int from_line
)
389 struct dir_entry
*entry
= xmalloc (sizeof (struct dir_entry
));
392 entry
->from_file
= strdup (from_file
);
393 entry
->from_line
= from_line
;
395 /* Search for an '=' sign. */
396 entry
->path
= xstrdup (line
);
397 char *equal_sign
= strchr (entry
->path
, '=');
402 entry
->flag
= FLAG_ANY
;
403 for (i
= 0; i
< sizeof (lib_types
) / sizeof (lib_types
[0]); ++i
)
404 if (strcmp (equal_sign
, lib_types
[i
].name
) == 0)
406 entry
->flag
= lib_types
[i
].flag
;
409 if (entry
->flag
== FLAG_ANY
)
410 error (0, 0, _("%s is not a known library type"), equal_sign
);
414 entry
->flag
= FLAG_ANY
;
417 /* Canonify path: for now only remove leading and trailing
418 whitespace and the trailing slashes. */
419 i
= strlen (entry
->path
);
421 while (i
> 0 && isspace (entry
->path
[i
- 1]))
422 entry
->path
[--i
] = '\0';
424 while (i
> 0 && entry
->path
[i
- 1] == '/')
425 entry
->path
[--i
] = '\0';
430 char *path
= entry
->path
;
432 path
= chroot_canon (opt_chroot
, path
);
434 struct stat64 stat_buf
;
435 if (path
== NULL
|| stat64 (path
, &stat_buf
))
438 error (0, errno
, _("Can't stat %s"), entry
->path
);
444 entry
->ino
= stat_buf
.st_ino
;
445 entry
->dev
= stat_buf
.st_dev
;
447 add_single_dir (entry
, 1);
455 add_dir (const char *line
)
457 add_dir_1 (line
, "<builtin>", 0);
461 chroot_stat (const char *real_path
, const char *path
, struct stat64
*st
)
467 return stat64 (real_path
, st
);
469 ret
= lstat64 (real_path
, st
);
470 if (ret
|| !S_ISLNK (st
->st_mode
))
473 canon_path
= chroot_canon (opt_chroot
, path
);
474 if (canon_path
== NULL
)
477 ret
= stat64 (canon_path
, st
);
482 /* Create a symbolic link from soname to libname in directory path. */
484 create_links (const char *real_path
, const char *path
, const char *libname
,
487 char *full_libname
, *full_soname
;
488 char *real_full_libname
, *real_full_soname
;
489 struct stat64 stat_lib
, stat_so
, lstat_so
;
492 /* XXX: The logics in this function should be simplified. */
494 /* Get complete path. */
495 full_libname
= alloca (strlen (path
) + strlen (libname
) + 2);
496 full_soname
= alloca (strlen (path
) + strlen (soname
) + 2);
497 sprintf (full_libname
, "%s/%s", path
, libname
);
498 sprintf (full_soname
, "%s/%s", path
, soname
);
501 real_full_libname
= alloca (strlen (real_path
) + strlen (libname
) + 2);
502 real_full_soname
= alloca (strlen (real_path
) + strlen (soname
) + 2);
503 sprintf (real_full_libname
, "%s/%s", real_path
, libname
);
504 sprintf (real_full_soname
, "%s/%s", real_path
, soname
);
508 real_full_libname
= full_libname
;
509 real_full_soname
= full_soname
;
512 /* Does soname already exist and point to the right library? */
513 if (chroot_stat (real_full_soname
, full_soname
, &stat_so
) == 0)
515 if (chroot_stat (real_full_libname
, full_libname
, &stat_lib
))
517 error (0, 0, _("Can't stat %s\n"), full_libname
);
520 if (stat_lib
.st_dev
== stat_so
.st_dev
521 && stat_lib
.st_ino
== stat_so
.st_ino
)
522 /* Link is already correct. */
524 else if (lstat64 (full_soname
, &lstat_so
) == 0
525 && !S_ISLNK (lstat_so
.st_mode
))
527 error (0, 0, _("%s is not a symbolic link\n"), full_soname
);
532 else if (lstat64 (real_full_soname
, &lstat_so
) != 0
533 || !S_ISLNK (lstat_so
.st_mode
))
534 /* Unless it is a stale symlink, there is no need to remove. */
538 printf ("\t%s -> %s", soname
, libname
);
540 if (do_link
&& opt_link
)
542 /* Remove old link. */
544 if (unlink (real_full_soname
))
546 error (0, 0, _("Can't unlink %s"), full_soname
);
549 /* Create symbolic link. */
550 if (do_link
&& symlink (libname
, real_full_soname
))
552 error (0, 0, _("Can't link %s to %s"), full_soname
, libname
);
558 fputs (_(" (changed)\n"), stdout
);
560 fputs (_(" (SKIPPED)\n"), stdout
);
563 else if (opt_verbose
)
564 fputs ("\n", stdout
);
567 /* Manually link the given library. */
569 manual_link (char *library
)
576 struct stat64 stat_buf
;
578 unsigned int osversion
;
580 /* Prepare arguments for create_links call. Split library name in
581 directory and filename first. Since path is allocated, we've got
582 to be careful to free at the end. */
583 path
= xstrdup (library
);
584 libname
= strrchr (path
, '/');
588 /* Successfully split names. Check if path is just "/" to avoid
592 libname
= library
+ 1;
593 path
= xrealloc (path
, 2);
604 /* There's no path, construct one. */
606 path
= xrealloc (path
, 2);
612 real_path
= chroot_canon (opt_chroot
, path
);
613 if (real_path
== NULL
)
615 error (0, errno
, _("Can't find %s"), path
);
619 real_library
= alloca (strlen (real_path
) + strlen (libname
) + 2);
620 sprintf (real_library
, "%s/%s", real_path
, libname
);
625 real_library
= library
;
628 /* Do some sanity checks first. */
629 if (lstat64 (real_library
, &stat_buf
))
631 error (0, errno
, _("Cannot lstat %s"), library
);
635 /* We don't want links here! */
636 else if (!S_ISREG (stat_buf
.st_mode
))
638 error (0, 0, _("Ignored file %s since it is not a regular file."),
644 if (process_file (real_library
, library
, libname
, &flag
, &osversion
,
645 &soname
, 0, &stat_buf
))
647 error (0, 0, _("No link created since soname could not be found for %s"),
653 soname
= implicit_soname (libname
, flag
);
654 create_links (real_path
, path
, libname
, soname
);
660 /* Read a whole directory and search for libraries.
661 The purpose is two-fold:
662 - search for libraries which will be added to the cache
663 - create symbolic links to the soname for each library
665 This has to be done separatly for each directory.
667 To keep track of which libraries to add to the cache and which
668 links to create, we save a list of all libraries.
670 The algorithm is basically:
671 for all libraries in the directory do
672 get soname of library
673 if soname is already in list
674 if new library is newer, replace entry
675 otherwise ignore this library
676 otherwise add library to list
678 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
679 exist and both have the same soname, e.g. libxy.so, a symbolic link
680 is created from libxy.so.1.2 (the newer one) to libxy.so.
681 libxy.so.1.2 and libxy.so are added to the cache - but not
684 /* Information for one library. */
691 unsigned int osversion
;
692 struct dlib_entry
*next
;
697 search_dir (const struct dir_entry
*entry
)
699 uint64_t hwcap
= path_hwcap (entry
->path
);
703 printf ("%s: (hwcap: %#.16" PRIx64
")", entry
->path
, hwcap
);
705 printf ("%s:", entry
->path
);
706 printf (_(" (from %s:%d)\n"), entry
->from_file
, entry
->from_line
);
710 char *real_file_name
;
711 size_t real_file_name_len
;
712 size_t file_name_len
= PATH_MAX
;
713 char *file_name
= alloca (file_name_len
);
716 dir_name
= chroot_canon (opt_chroot
, entry
->path
);
717 real_file_name_len
= PATH_MAX
;
718 real_file_name
= alloca (real_file_name_len
);
722 dir_name
= entry
->path
;
723 real_file_name_len
= 0;
724 real_file_name
= file_name
;
728 if (dir_name
== NULL
|| (dir
= opendir (dir_name
)) == NULL
)
731 error (0, errno
, _("Can't open directory %s"), entry
->path
);
732 if (opt_chroot
&& dir_name
)
737 struct dirent64
*direntry
;
738 struct dlib_entry
*dlibs
= NULL
;
739 while ((direntry
= readdir64 (dir
)) != NULL
)
742 /* We only look at links and regular files. */
743 if (direntry
->d_type
!= DT_UNKNOWN
744 && direntry
->d_type
!= DT_LNK
745 && direntry
->d_type
!= DT_REG
746 && direntry
->d_type
!= DT_DIR
)
748 /* Does this file look like a shared library or is it a hwcap
749 subdirectory? The dynamic linker is also considered as
751 if (((strncmp (direntry
->d_name
, "lib", 3) != 0
752 && strncmp (direntry
->d_name
, "ld-", 3) != 0)
753 || strstr (direntry
->d_name
, ".so") == NULL
)
754 && (direntry
->d_type
== DT_REG
755 || !is_hwcap_platform (direntry
->d_name
)))
758 size_t len
= strlen (direntry
->d_name
);
759 /* Skip temporary files created by the prelink program. Files with
760 names like these are never really DSOs we want to look at. */
761 if (len
>= sizeof (".#prelink#") - 1)
763 if (strcmp (direntry
->d_name
+ len
- sizeof (".#prelink#") + 1,
766 if (len
>= sizeof (".#prelink#.XXXXXX") - 1
767 && memcmp (direntry
->d_name
+ len
- sizeof (".#prelink#.XXXXXX")
768 + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
771 len
+= strlen (entry
->path
) + 2;
772 if (len
> file_name_len
)
775 file_name
= alloca (file_name_len
);
777 real_file_name
= file_name
;
779 sprintf (file_name
, "%s/%s", entry
->path
, direntry
->d_name
);
782 len
= strlen (dir_name
) + strlen (direntry
->d_name
) + 2;
783 if (len
> real_file_name_len
)
785 real_file_name_len
= len
;
786 real_file_name
= alloca (real_file_name_len
);
788 sprintf (real_file_name
, "%s/%s", dir_name
, direntry
->d_name
);
791 struct stat64 lstat_buf
;
792 /* We optimize and try to do the lstat call only if needed. */
793 if (direntry
->d_type
!= DT_UNKNOWN
)
794 lstat_buf
.st_mode
= DTTOIF (direntry
->d_type
);
796 if (__glibc_unlikely (lstat64 (real_file_name
, &lstat_buf
)))
798 error (0, errno
, _("Cannot lstat %s"), file_name
);
802 struct stat64 stat_buf
;
804 int is_link
= S_ISLNK (lstat_buf
.st_mode
);
807 /* In case of symlink, we check if the symlink refers to
809 char *target_name
= real_file_name
;
812 target_name
= chroot_canon (opt_chroot
, file_name
);
813 if (target_name
== NULL
)
815 if (strstr (file_name
, ".so") == NULL
)
816 error (0, 0, _("Input file %s not found.\n"), file_name
);
820 if (__glibc_unlikely (stat64 (target_name
, &stat_buf
)))
823 error (0, errno
, _("Cannot stat %s"), file_name
);
825 /* Remove stale symlinks. */
826 if (opt_link
&& strstr (direntry
->d_name
, ".so."))
827 unlink (real_file_name
);
830 is_dir
= S_ISDIR (stat_buf
.st_mode
);
832 /* lstat_buf is later stored, update contents. */
833 lstat_buf
.st_dev
= stat_buf
.st_dev
;
834 lstat_buf
.st_ino
= stat_buf
.st_ino
;
835 lstat_buf
.st_size
= stat_buf
.st_size
;
836 lstat_buf
.st_ctime
= stat_buf
.st_ctime
;
839 is_dir
= S_ISDIR (lstat_buf
.st_mode
);
841 if (is_dir
&& is_hwcap_platform (direntry
->d_name
))
844 && direntry
->d_type
!= DT_UNKNOWN
845 && __builtin_expect (lstat64 (real_file_name
, &lstat_buf
), 0))
847 error (0, errno
, _("Cannot lstat %s"), file_name
);
851 /* Handle subdirectory later. */
852 struct dir_entry
*new_entry
= new_sub_entry (entry
, file_name
,
854 add_single_dir (new_entry
, 0);
857 else if (!S_ISREG (lstat_buf
.st_mode
) && !is_link
)
861 if (opt_chroot
&& is_link
)
863 real_name
= chroot_canon (opt_chroot
, file_name
);
864 if (real_name
== NULL
)
866 if (strstr (file_name
, ".so") == NULL
)
867 error (0, 0, _("Input file %s not found.\n"), file_name
);
872 real_name
= real_file_name
;
874 /* Call lstat64 if not done yet. */
876 && direntry
->d_type
!= DT_UNKNOWN
877 && __builtin_expect (lstat64 (real_file_name
, &lstat_buf
), 0))
879 error (0, errno
, _("Cannot lstat %s"), file_name
);
883 /* First search whether the auxiliary cache contains this
884 library already and it's not changed. */
886 unsigned int osversion
;
887 if (!search_aux_cache (&lstat_buf
, &flag
, &osversion
, &soname
))
889 if (process_file (real_name
, file_name
, direntry
->d_name
, &flag
,
890 &osversion
, &soname
, is_link
, &lstat_buf
))
892 if (real_name
!= real_file_name
)
896 else if (opt_build_cache
)
897 add_to_aux_cache (&lstat_buf
, flag
, osversion
, soname
);
901 soname
= implicit_soname (direntry
->d_name
, flag
);
903 /* A link may just point to itself. */
906 /* If the path the link points to isn't its soname or it is not
907 the .so symlink for ld(1), we treat it as a normal file.
909 You should always do this:
911 libfoo.so -> SONAME -> Arbitrary package-chosen name.
913 e.g. libfoo.so -> libfoo.so.1 -> libfooimp.so.9.99.
914 Given a SONAME of libfoo.so.1.
916 You should *never* do this:
918 libfoo.so -> libfooimp.so.9.99
920 If you do, and your SONAME is libfoo.so.1, then libfoo.so
921 fails to point at the SONAME. In that case ldconfig may consider
922 libfoo.so as another implementation of SONAME and will create
923 symlinks against it causing problems when you try to upgrade
924 or downgrade. The problems will arise because ldconfig will,
925 depending on directory ordering, creat symlinks against libfoo.so
926 e.g. libfoo.so.1.2 -> libfoo.so, but when libfoo.so is removed
927 (typically by the removal of a development pacakge not required
928 for the runtime) it will break the libfoo.so.1.2 symlink and the
929 application will fail to start. */
930 const char *real_base_name
= basename (real_file_name
);
932 if (strcmp (real_base_name
, soname
) != 0)
934 len
= strlen (real_base_name
);
935 if (len
< strlen (".so")
936 || strcmp (real_base_name
+ len
- strlen (".so"), ".so") != 0
937 || strncmp (real_base_name
, soname
, len
) != 0)
942 if (real_name
!= real_file_name
)
948 soname
= xstrdup (direntry
->d_name
);
952 && (entry
->flag
== FLAG_ELF_LIBC5
953 || entry
->flag
== FLAG_ELF_LIBC6
))
956 /* Some sanity checks to print warnings. */
959 if (flag
== FLAG_ELF_LIBC5
&& entry
->flag
!= FLAG_ELF_LIBC5
960 && entry
->flag
!= FLAG_ANY
)
961 error (0, 0, _("libc5 library %s in wrong directory"), file_name
);
962 if (flag
== FLAG_ELF_LIBC6
&& entry
->flag
!= FLAG_ELF_LIBC6
963 && entry
->flag
!= FLAG_ANY
)
964 error (0, 0, _("libc6 library %s in wrong directory"), file_name
);
965 if (flag
== FLAG_LIBC4
&& entry
->flag
!= FLAG_LIBC4
966 && entry
->flag
!= FLAG_ANY
)
967 error (0, 0, _("libc4 library %s in wrong directory"), file_name
);
970 /* Add library to list. */
971 struct dlib_entry
*dlib_ptr
;
972 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
974 /* Is soname already in list? */
975 if (strcmp (dlib_ptr
->soname
, soname
) == 0)
977 /* Prefer a file to a link, otherwise check which one
979 if ((!is_link
&& dlib_ptr
->is_link
)
980 || (is_link
== dlib_ptr
->is_link
981 && _dl_cache_libcmp (dlib_ptr
->name
, direntry
->d_name
) < 0))
983 /* It's newer - add it. */
984 /* Flag should be the same - sanity check. */
985 if (dlib_ptr
->flag
!= flag
)
987 if (dlib_ptr
->flag
== FLAG_ELF
988 && (flag
== FLAG_ELF_LIBC5
|| flag
== FLAG_ELF_LIBC6
))
989 dlib_ptr
->flag
= flag
;
990 else if ((dlib_ptr
->flag
== FLAG_ELF_LIBC5
991 || dlib_ptr
->flag
== FLAG_ELF_LIBC6
)
993 dlib_ptr
->flag
= flag
;
995 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
996 dlib_ptr
->name
, direntry
->d_name
,
999 free (dlib_ptr
->name
);
1000 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
1001 dlib_ptr
->is_link
= is_link
;
1002 dlib_ptr
->osversion
= osversion
;
1004 /* Don't add this library, abort loop. */
1005 /* Also free soname, since it's dynamically allocated. */
1010 /* Add the library if it's not already in. */
1011 if (dlib_ptr
== NULL
)
1013 dlib_ptr
= (struct dlib_entry
*)xmalloc (sizeof (struct dlib_entry
));
1014 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
1015 dlib_ptr
->soname
= soname
;
1016 dlib_ptr
->flag
= flag
;
1017 dlib_ptr
->is_link
= is_link
;
1018 dlib_ptr
->osversion
= osversion
;
1019 /* Add at head of list. */
1020 dlib_ptr
->next
= dlibs
;
1027 /* Now dlibs contains a list of all libs - add those to the cache
1028 and created all symbolic links. */
1029 struct dlib_entry
*dlib_ptr
;
1030 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
1032 /* Don't create links to links. */
1033 if (dlib_ptr
->is_link
== 0)
1034 create_links (dir_name
, entry
->path
, dlib_ptr
->name
,
1036 if (opt_build_cache
)
1037 add_to_cache (entry
->path
, dlib_ptr
->soname
, dlib_ptr
->flag
,
1038 dlib_ptr
->osversion
, hwcap
);
1041 /* Free all resources. */
1045 free (dlib_ptr
->soname
);
1046 free (dlib_ptr
->name
);
1047 dlibs
= dlibs
->next
;
1051 if (opt_chroot
&& dir_name
)
1055 /* Search through all libraries. */
1059 struct dir_entry
*entry
;
1061 for (entry
= dir_entries
; entry
!= NULL
; entry
= entry
->next
)
1064 /* Free all allocated memory. */
1067 entry
= dir_entries
;
1068 dir_entries
= dir_entries
->next
;
1075 static void parse_conf_include (const char *config_file
, unsigned int lineno
,
1076 bool do_chroot
, const char *pattern
);
1078 /* Parse configuration file. */
1080 parse_conf (const char *filename
, bool do_chroot
)
1086 unsigned int lineno
;
1088 if (do_chroot
&& opt_chroot
)
1090 canon
= chroot_canon (opt_chroot
, filename
);
1092 file
= fopen (canon
, "r");
1099 file
= fopen (filename
, "r");
1104 if (errno
!= ENOENT
)
1105 error (0, errno
, _("\
1106 Warning: ignoring configuration file that cannot be opened: %s"),
1108 if (canon
!= filename
)
1109 free ((char *) canon
);
1113 /* No threads use this stream. */
1114 __fsetlocking (file
, FSETLOCKING_BYCALLER
);
1116 if (canon
!= filename
)
1117 free ((char *) canon
);
1122 ssize_t n
= getline (&line
, &len
, file
);
1127 if (line
[n
- 1] == '\n')
1130 /* Because the file format does not know any form of quoting we
1131 can search forward for the next '#' character and if found
1132 make it terminating the line. */
1133 *strchrnul (line
, '#') = '\0';
1135 /* Remove leading whitespace. NUL is no whitespace character. */
1137 while (isspace (*cp
))
1140 /* If the line is blank it is ignored. */
1144 if (!strncmp (cp
, "include", 7) && isblank (cp
[7]))
1148 while ((dir
= strsep (&cp
, " \t")) != NULL
)
1150 parse_conf_include (filename
, lineno
, do_chroot
, dir
);
1152 else if (!strncasecmp (cp
, "hwcap", 5) && isblank (cp
[5]))
1153 error (0, 0, _("%s:%u: hwcap directive ignored"), filename
, lineno
);
1155 add_dir_1 (cp
, filename
, lineno
);
1157 while (!feof_unlocked (file
));
1159 /* Free buffer and close file. */
1164 /* Handle one word in an `include' line, a glob pattern of additional
1165 config files to read. */
1167 parse_conf_include (const char *config_file
, unsigned int lineno
,
1168 bool do_chroot
, const char *pattern
)
1170 if (opt_chroot
&& pattern
[0] != '/')
1171 error (EXIT_FAILURE
, 0,
1172 _("need absolute file name for configuration file when using -r"));
1175 if (pattern
[0] != '/' && strchr (config_file
, '/') != NULL
)
1177 if (asprintf (©
, "%s/%s", dirname (strdupa (config_file
)),
1179 error (EXIT_FAILURE
, 0, _("memory exhausted"));
1185 if (do_chroot
&& opt_chroot
)
1187 char *canon
= chroot_canon (opt_chroot
, pattern
);
1190 result
= glob64 (canon
, 0, NULL
, &gl
);
1194 result
= glob64 (pattern
, 0, NULL
, &gl
);
1199 for (size_t i
= 0; i
< gl
.gl_pathc
; ++i
)
1200 parse_conf (gl
.gl_pathv
[i
], false);
1212 error (0, errno
, _("%s:%u: cannot read directory %s"),
1213 config_file
, lineno
, pattern
);
1224 /* Honour LD_HWCAP_MASK. */
1228 char *mask
= getenv ("LD_HWCAP_MASK");
1231 hwcap_mask
= strtoul (mask
, NULL
, 0);
1236 main (int argc
, char **argv
)
1238 /* Set locale via LC_ALL. */
1239 setlocale (LC_ALL
, "");
1241 /* But keep the C collation. That way `include' directives using
1242 globbing patterns are processed in a locale-independent order. */
1243 setlocale (LC_COLLATE
, "C");
1245 /* Set the text message domain. */
1246 textdomain (_libc_intl_domainname
);
1248 /* Parse and process arguments. */
1250 argp_parse (&argp
, argc
, argv
, 0, &remaining
, NULL
);
1252 /* Remaining arguments are additional directories if opt_manual_link
1254 if (remaining
!= argc
&& !opt_manual_link
)
1257 for (i
= remaining
; i
< argc
; ++i
)
1258 if (opt_build_cache
&& argv
[i
][0] != '/')
1259 error (EXIT_FAILURE
, 0,
1260 _("relative path `%s' used to build cache"),
1263 add_dir_1 (argv
[i
], "<cmdline>", 0);
1270 /* Normalize the path a bit, we might need it for printing later. */
1271 char *endp
= rawmemchr (opt_chroot
, '\0');
1272 while (endp
> opt_chroot
&& endp
[-1] == '/')
1275 if (endp
== opt_chroot
)
1280 /* It is faster to use chroot if we can. */
1281 if (!chroot (opt_chroot
))
1284 error (EXIT_FAILURE
, errno
, _("Can't chdir to /"));
1290 if (cache_file
== NULL
)
1292 cache_file
= alloca (strlen (LD_SO_CACHE
) + 1);
1293 strcpy (cache_file
, LD_SO_CACHE
);
1296 if (config_file
== NULL
)
1297 config_file
= LD_SO_CONF
;
1299 if (opt_print_cache
)
1303 char *p
= chroot_canon (opt_chroot
, cache_file
);
1305 error (EXIT_FAILURE
, errno
, _("Can't open cache file %s\n"),
1309 print_cache (cache_file
);
1317 /* Canonicalize the directory name of cache_file, not cache_file,
1318 because we'll rename a temporary cache file to it. */
1319 char *p
= strrchr (cache_file
, '/');
1320 char *canon
= chroot_canon (opt_chroot
,
1321 p
? (*p
= '\0', cache_file
) : "/");
1324 error (EXIT_FAILURE
, errno
,
1325 _("Can't open cache file directory %s\n"),
1326 p
? cache_file
: "/");
1333 cache_file
= alloca (strlen (canon
) + strlen (p
) + 2);
1334 sprintf (cache_file
, "%s/%s", canon
, p
);
1338 if (opt_manual_link
)
1340 /* Link all given libraries manually. */
1343 for (i
= remaining
; i
< argc
; ++i
)
1344 manual_link (argv
[i
]);
1350 if (opt_build_cache
)
1353 if (!opt_only_cline
)
1355 parse_conf (config_file
, true);
1357 /* Always add the standard search paths. */
1358 add_system_dir (SLIBDIR
);
1359 if (strcmp (SLIBDIR
, LIBDIR
))
1360 add_system_dir (LIBDIR
);
1363 const char *aux_cache_file
= _PATH_LDCONFIG_AUX_CACHE
;
1365 aux_cache_file
= chroot_canon (opt_chroot
, aux_cache_file
);
1367 if (! opt_ignore_aux_cache
&& aux_cache_file
)
1368 load_aux_cache (aux_cache_file
);
1374 if (opt_build_cache
)
1376 save_cache (cache_file
);
1378 save_aux_cache (aux_cache_file
);