.
[glibc/history.git] / elf / ldconfig.c
blob78a0f0c2a88a4fc77844ee7bacc4871d5427e535
1 /* Copyright (C) 1999-2008, 2009 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, write to the Free Software Foundation,
17 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
19 #define PROCINFO_CLASS static
20 #include <alloca.h>
21 #include <argp.h>
22 #include <dirent.h>
23 #include <elf.h>
24 #include <error.h>
25 #include <errno.h>
26 #include <inttypes.h>
27 #include <libintl.h>
28 #include <locale.h>
29 #include <stdbool.h>
30 #include <stdio.h>
31 #include <stdio_ext.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <unistd.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 /* Generate links. */
104 static int opt_link = 1;
106 /* Only process directories specified on the command line. */
107 static int opt_only_cline;
109 /* Path to root for chroot. */
110 static char *opt_chroot;
112 /* Manually link given shared libraries. */
113 static int opt_manual_link;
115 /* Should we ignore an old auxiliary cache file? */
116 static int opt_ignore_aux_cache;
118 /* Cache file to use. */
119 static char *cache_file;
121 /* Configuration file. */
122 static const char *config_file;
124 /* Mask to use for important hardware capabilities. */
125 static unsigned long int hwcap_mask = HWCAP_IMPORTANT;
127 /* Configuration-defined capabilities defined in kernel vDSOs. */
128 static const char *hwcap_extra[64 - _DL_FIRST_EXTRA];
130 /* Name and version of program. */
131 static void print_version (FILE *stream, struct argp_state *state);
132 void (*argp_program_version_hook) (FILE *, struct argp_state *)
133 = print_version;
135 /* Function to print some extra text in the help message. */
136 static char *more_help (int key, const char *text, void *input);
138 /* Definitions of arguments for argp functions. */
139 static const struct argp_option options[] =
141 { "print-cache", 'p', NULL, 0, N_("Print cache"), 0},
142 { "verbose", 'v', NULL, 0, N_("Generate verbose messages"), 0},
143 { NULL, 'N', NULL, 0, N_("Don't build cache"), 0},
144 { NULL, 'X', NULL, 0, N_("Don't generate links"), 0},
145 { NULL, 'r', N_("ROOT"), 0, N_("Change to and use ROOT as root directory"), 0},
146 { NULL, 'C', N_("CACHE"), 0, N_("Use CACHE as cache file"), 0},
147 { NULL, 'f', N_("CONF"), 0, N_("Use CONF as configuration file"), 0},
148 { NULL, 'n', NULL, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
149 { NULL, 'l', NULL, 0, N_("Manually link individual libraries."), 0},
150 { "format", 'c', N_("FORMAT"), 0, N_("Format to use: new, old or compat (default)"), 0},
151 { "ignore-aux-cache", 'i', NULL, 0, N_("Ignore auxiliary cache file"), 0},
152 { NULL, 0, NULL, 0, NULL, 0 }
155 #define PROCINFO_CLASS static
156 #include <dl-procinfo.c>
158 /* Short description of program. */
159 static const char doc[] = N_("Configure Dynamic Linker Run Time Bindings.");
161 /* Prototype for option handler. */
162 static error_t parse_opt (int key, char *arg, struct argp_state *state);
164 /* Data structure to communicate with argp functions. */
165 static struct argp argp =
167 options, parse_opt, NULL, doc, NULL, more_help, NULL
170 /* Check if string corresponds to an important hardware capability or
171 a platform. */
172 static int
173 is_hwcap_platform (const char *name)
175 int hwcap_idx = _dl_string_hwcap (name);
177 if (hwcap_idx != -1 && ((1 << hwcap_idx) & hwcap_mask))
178 return 1;
180 hwcap_idx = _dl_string_platform (name);
181 if (hwcap_idx != -1)
182 return 1;
184 for (hwcap_idx = _DL_FIRST_EXTRA; hwcap_idx < 64; ++hwcap_idx)
185 if (hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA] != NULL
186 && !strcmp (name, hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA]))
187 return 1;
189 return 0;
192 /* Get hwcap (including platform) encoding of path. */
193 static uint64_t
194 path_hwcap (const char *path)
196 char *str = xstrdup (path);
197 char *ptr;
198 uint64_t hwcap = 0;
199 uint64_t h;
201 size_t len;
203 len = strlen (str);
204 if (str[len] == '/')
205 str[len] = '\0';
207 /* Search pathname from the end and check for hwcap strings. */
208 for (;;)
210 ptr = strrchr (str, '/');
212 if (ptr == NULL)
213 break;
215 h = _dl_string_hwcap (ptr + 1);
217 if (h == (uint64_t) -1)
219 h = _dl_string_platform (ptr + 1);
220 if (h == (uint64_t) -1)
222 for (h = _DL_FIRST_EXTRA; h < 64; ++h)
223 if (hwcap_extra[h - _DL_FIRST_EXTRA] != NULL
224 && !strcmp (ptr + 1, hwcap_extra[h - _DL_FIRST_EXTRA]))
225 break;
226 if (h == 64)
227 break;
230 hwcap += 1ULL << h;
232 /* Search the next part of the path. */
233 *ptr = '\0';
236 free (str);
237 return hwcap;
240 /* Handle program arguments. */
241 static error_t
242 parse_opt (int key, char *arg, struct argp_state *state)
244 switch (key)
246 case 'C':
247 cache_file = arg;
248 /* Ignore auxiliary cache since we use non-standard cache. */
249 opt_ignore_aux_cache = 1;
250 break;
251 case 'f':
252 config_file = arg;
253 break;
254 case 'i':
255 opt_ignore_aux_cache = 1;
256 break;
257 case 'l':
258 opt_manual_link = 1;
259 break;
260 case 'N':
261 opt_build_cache = 0;
262 break;
263 case 'n':
264 opt_build_cache = 0;
265 opt_only_cline = 1;
266 break;
267 case 'p':
268 opt_print_cache = 1;
269 break;
270 case 'r':
271 opt_chroot = arg;
272 break;
273 case 'v':
274 opt_verbose = 1;
275 break;
276 case 'X':
277 opt_link = 0;
278 break;
279 case 'c':
280 if (strcmp (arg, "old") == 0)
281 opt_format = 0;
282 else if (strcmp (arg, "compat") == 0)
283 opt_format = 1;
284 else if (strcmp (arg, "new") == 0)
285 opt_format = 2;
286 break;
287 default:
288 return ARGP_ERR_UNKNOWN;
291 return 0;
294 /* Print bug-reporting information in the help message. */
295 static char *
296 more_help (int key, const char *text, void *input)
298 switch (key)
300 case ARGP_KEY_HELP_EXTRA:
301 /* We print some extra information. */
302 return strdup (gettext ("\
303 For bug reporting instructions, please see:\n\
304 <http://www.gnu.org/software/libc/bugs.html>.\n"));
305 default:
306 break;
308 return (char *) text;
311 /* Print the version information. */
312 static void
313 print_version (FILE *stream, struct argp_state *state)
315 fprintf (stream, "ldconfig (GNU %s) %s\n", PACKAGE, VERSION);
316 fprintf (stream, gettext ("\
317 Copyright (C) %s Free Software Foundation, Inc.\n\
318 This is free software; see the source for copying conditions. There is NO\n\
319 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
320 "), "2009");
321 fprintf (stream, gettext ("Written by %s.\n"),
322 "Andreas Jaeger");
325 /* Add a single directory entry. */
326 static void
327 add_single_dir (struct dir_entry *entry, int verbose)
329 struct dir_entry *ptr, *prev;
331 ptr = dir_entries;
332 prev = ptr;
333 while (ptr != NULL)
335 /* Check for duplicates. */
336 if (ptr->ino == entry->ino && ptr->dev == entry->dev)
338 if (opt_verbose && verbose)
339 error (0, 0, _("Path `%s' given more than once"), entry->path);
340 /* Use the newer information. */
341 ptr->flag = entry->flag;
342 free (entry->path);
343 free (entry);
344 break;
346 prev = ptr;
347 ptr = ptr->next;
349 /* Is this the first entry? */
350 if (ptr == NULL && dir_entries == NULL)
351 dir_entries = entry;
352 else if (ptr == NULL)
353 prev->next = entry;
356 /* Add one directory to the list of directories to process. */
357 static void
358 add_dir (const char *line)
360 unsigned int i;
361 struct dir_entry *entry = xmalloc (sizeof (struct dir_entry));
362 entry->next = NULL;
364 /* Search for an '=' sign. */
365 entry->path = xstrdup (line);
366 char *equal_sign = strchr (entry->path, '=');
367 if (equal_sign)
369 *equal_sign = '\0';
370 ++equal_sign;
371 entry->flag = FLAG_ANY;
372 for (i = 0; i < sizeof (lib_types) / sizeof (lib_types[0]); ++i)
373 if (strcmp (equal_sign, lib_types[i].name) == 0)
375 entry->flag = lib_types[i].flag;
376 break;
378 if (entry->flag == FLAG_ANY)
379 error (0, 0, _("%s is not a known library type"), equal_sign);
381 else
383 entry->flag = FLAG_ANY;
386 /* Canonify path: for now only remove leading and trailing
387 whitespace and the trailing slashes slashes. */
388 i = strlen (entry->path) - 1;
390 while (isspace (entry->path[i]) && i > 0)
391 entry->path[i--] = '\0';
393 while (entry->path[i] == '/' && i > 0)
394 entry->path[i--] = '\0';
396 char *path = entry->path;
397 if (opt_chroot)
398 path = chroot_canon (opt_chroot, path);
400 struct stat64 stat_buf;
401 if (path == NULL || stat64 (path, &stat_buf))
403 if (opt_verbose)
404 error (0, errno, _("Can't stat %s"), entry->path);
405 free (entry->path);
406 free (entry);
408 else
410 entry->ino = stat_buf.st_ino;
411 entry->dev = stat_buf.st_dev;
413 add_single_dir (entry, 1);
416 if (opt_chroot)
417 free (path);
421 static int
422 chroot_stat (const char *real_path, const char *path, struct stat64 *st)
424 int ret;
425 char *canon_path;
427 if (!opt_chroot)
428 return stat64 (real_path, st);
430 ret = lstat64 (real_path, st);
431 if (ret || !S_ISLNK (st->st_mode))
432 return ret;
434 canon_path = chroot_canon (opt_chroot, path);
435 if (canon_path == NULL)
436 return -1;
438 ret = stat64 (canon_path, st);
439 free (canon_path);
440 return ret;
443 /* Create a symbolic link from soname to libname in directory path. */
444 static void
445 create_links (const char *real_path, const char *path, const char *libname,
446 const char *soname)
448 char *full_libname, *full_soname;
449 char *real_full_libname, *real_full_soname;
450 struct stat64 stat_lib, stat_so, lstat_so;
451 int do_link = 1;
452 int do_remove = 1;
453 /* XXX: The logics in this function should be simplified. */
455 /* Get complete path. */
456 full_libname = alloca (strlen (path) + strlen (libname) + 2);
457 full_soname = alloca (strlen (path) + strlen (soname) + 2);
458 sprintf (full_libname, "%s/%s", path, libname);
459 sprintf (full_soname, "%s/%s", path, soname);
460 if (opt_chroot)
462 real_full_libname = alloca (strlen (real_path) + strlen (libname) + 2);
463 real_full_soname = alloca (strlen (real_path) + strlen (soname) + 2);
464 sprintf (real_full_libname, "%s/%s", real_path, libname);
465 sprintf (real_full_soname, "%s/%s", real_path, soname);
467 else
469 real_full_libname = full_libname;
470 real_full_soname = full_soname;
473 /* Does soname already exist and point to the right library? */
474 if (chroot_stat (real_full_soname, full_soname, &stat_so) == 0)
476 if (chroot_stat (real_full_libname, full_libname, &stat_lib))
478 error (0, 0, _("Can't stat %s\n"), full_libname);
479 return;
481 if (stat_lib.st_dev == stat_so.st_dev
482 && stat_lib.st_ino == stat_so.st_ino)
483 /* Link is already correct. */
484 do_link = 0;
485 else if (lstat64 (full_soname, &lstat_so) == 0
486 && !S_ISLNK (lstat_so.st_mode))
488 error (0, 0, _("%s is not a symbolic link\n"), full_soname);
489 do_link = 0;
490 do_remove = 0;
493 else if (lstat64 (real_full_soname, &lstat_so) != 0
494 || !S_ISLNK (lstat_so.st_mode))
495 /* Unless it is a stale symlink, there is no need to remove. */
496 do_remove = 0;
498 if (opt_verbose)
499 printf ("\t%s -> %s", soname, libname);
501 if (do_link && opt_link)
503 /* Remove old link. */
504 if (do_remove)
505 if (unlink (real_full_soname))
507 error (0, 0, _("Can't unlink %s"), full_soname);
508 do_link = 0;
510 /* Create symbolic link. */
511 if (do_link && symlink (libname, real_full_soname))
513 error (0, 0, _("Can't link %s to %s"), full_soname, libname);
514 do_link = 0;
516 if (opt_verbose)
518 if (do_link)
519 fputs (_(" (changed)\n"), stdout);
520 else
521 fputs (_(" (SKIPPED)\n"), stdout);
524 else if (opt_verbose)
525 fputs ("\n", stdout);
528 /* Manually link the given library. */
529 static void
530 manual_link (char *library)
532 char *path;
533 char *real_path;
534 char *real_library;
535 char *libname;
536 char *soname;
537 struct stat64 stat_buf;
538 int flag;
539 unsigned int osversion;
541 /* Prepare arguments for create_links call. Split library name in
542 directory and filename first. Since path is allocated, we've got
543 to be careful to free at the end. */
544 path = xstrdup (library);
545 libname = strrchr (path, '/');
547 if (libname)
549 /* Successfully split names. Check if path is just "/" to avoid
550 an empty path. */
551 if (libname == path)
553 libname = library + 1;
554 path = xrealloc (path, 2);
555 strcpy (path, "/");
557 else
559 *libname = '\0';
560 ++libname;
563 else
565 /* There's no path, construct one. */
566 libname = library;
567 path = xrealloc (path, 2);
568 strcpy (path, ".");
571 if (opt_chroot)
573 real_path = chroot_canon (opt_chroot, path);
574 if (real_path == NULL)
576 error (0, errno, _("Can't find %s"), path);
577 free (path);
578 return;
580 real_library = alloca (strlen (real_path) + strlen (libname) + 2);
581 sprintf (real_library, "%s/%s", real_path, libname);
583 else
585 real_path = path;
586 real_library = library;
589 /* Do some sanity checks first. */
590 if (lstat64 (real_library, &stat_buf))
592 error (0, errno, _("Cannot lstat %s"), library);
593 free (path);
594 return;
596 /* We don't want links here! */
597 else if (!S_ISREG (stat_buf.st_mode))
599 error (0, 0, _("Ignored file %s since it is not a regular file."),
600 library);
601 free (path);
602 return;
605 if (process_file (real_library, library, libname, &flag, &osversion,
606 &soname, 0, &stat_buf))
608 error (0, 0, _("No link created since soname could not be found for %s"),
609 library);
610 free (path);
611 return;
613 if (soname == NULL)
614 soname = implicit_soname (libname, flag);
615 create_links (real_path, path, libname, soname);
616 free (soname);
617 free (path);
621 /* Read a whole directory and search for libraries.
622 The purpose is two-fold:
623 - search for libraries which will be added to the cache
624 - create symbolic links to the soname for each library
626 This has to be done separatly for each directory.
628 To keep track of which libraries to add to the cache and which
629 links to create, we save a list of all libraries.
631 The algorithm is basically:
632 for all libraries in the directory do
633 get soname of library
634 if soname is already in list
635 if new library is newer, replace entry
636 otherwise ignore this library
637 otherwise add library to list
639 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
640 exist and both have the same soname, e.g. libxy.so, a symbolic link
641 is created from libxy.so.1.2 (the newer one) to libxy.so.
642 libxy.so.1.2 and libxy.so are added to the cache - but not
643 libxy.so.1.1. */
645 /* Information for one library. */
646 struct dlib_entry
648 char *name;
649 char *soname;
650 int flag;
651 int is_link;
652 unsigned int osversion;
653 struct dlib_entry *next;
657 static void
658 search_dir (const struct dir_entry *entry)
660 uint64_t hwcap = path_hwcap (entry->path);
661 if (opt_verbose)
663 if (hwcap != 0)
664 printf ("%s: (hwcap: %#.16" PRIx64 ")\n", entry->path, hwcap);
665 else
666 printf ("%s:\n", entry->path);
669 char *dir_name;
670 char *real_file_name;
671 size_t real_file_name_len;
672 size_t file_name_len = PATH_MAX;
673 char *file_name = alloca (file_name_len);
674 if (opt_chroot)
676 dir_name = chroot_canon (opt_chroot, entry->path);
677 real_file_name_len = PATH_MAX;
678 real_file_name = alloca (real_file_name_len);
680 else
682 dir_name = entry->path;
683 real_file_name_len = 0;
684 real_file_name = file_name;
687 DIR *dir;
688 if (dir_name == NULL || (dir = opendir (dir_name)) == NULL)
690 if (opt_verbose)
691 error (0, errno, _("Can't open directory %s"), entry->path);
692 if (opt_chroot && dir_name)
693 free (dir_name);
694 return;
697 struct dirent64 *direntry;
698 struct dlib_entry *dlibs = NULL;
699 while ((direntry = readdir64 (dir)) != NULL)
701 int flag;
702 #ifdef _DIRENT_HAVE_D_TYPE
703 /* We only look at links and regular files. */
704 if (direntry->d_type != DT_UNKNOWN
705 && direntry->d_type != DT_LNK
706 && direntry->d_type != DT_REG
707 && direntry->d_type != DT_DIR)
708 continue;
709 #endif /* _DIRENT_HAVE_D_TYPE */
710 /* Does this file look like a shared library or is it a hwcap
711 subdirectory? The dynamic linker is also considered as
712 shared library. */
713 if (((strncmp (direntry->d_name, "lib", 3) != 0
714 && strncmp (direntry->d_name, "ld-", 3) != 0)
715 || strstr (direntry->d_name, ".so") == NULL)
716 && (
717 #ifdef _DIRENT_HAVE_D_TYPE
718 direntry->d_type == DT_REG ||
719 #endif
720 !is_hwcap_platform (direntry->d_name)))
721 continue;
723 size_t len = strlen (direntry->d_name);
724 /* Skip temporary files created by the prelink program. Files with
725 names like these are never really DSOs we want to look at. */
726 if (len >= sizeof (".#prelink#") - 1)
728 if (strcmp (direntry->d_name + len - sizeof (".#prelink#") + 1,
729 ".#prelink#") == 0)
730 continue;
731 if (len >= sizeof (".#prelink#.XXXXXX") - 1
732 && memcmp (direntry->d_name + len - sizeof (".#prelink#.XXXXXX")
733 + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
734 continue;
736 len += strlen (entry->path) + 2;
737 if (len > file_name_len)
739 file_name_len = len;
740 file_name = alloca (file_name_len);
741 if (!opt_chroot)
742 real_file_name = file_name;
744 sprintf (file_name, "%s/%s", entry->path, direntry->d_name);
745 if (opt_chroot)
747 len = strlen (dir_name) + strlen (direntry->d_name) + 2;
748 if (len > real_file_name_len)
750 real_file_name_len = len;
751 real_file_name = alloca (real_file_name_len);
753 sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);
756 struct stat64 lstat_buf;
757 #ifdef _DIRENT_HAVE_D_TYPE
758 /* We optimize and try to do the lstat call only if needed. */
759 if (direntry->d_type != DT_UNKNOWN)
760 lstat_buf.st_mode = DTTOIF (direntry->d_type);
761 else
762 #endif
763 if (__builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
765 error (0, errno, _("Cannot lstat %s"), file_name);
766 continue;
769 struct stat64 stat_buf;
770 int is_dir;
771 int is_link = S_ISLNK (lstat_buf.st_mode);
772 if (is_link)
774 /* In case of symlink, we check if the symlink refers to
775 a directory. */
776 if (__builtin_expect (stat64 (real_file_name, &stat_buf), 0))
778 if (opt_verbose)
779 error (0, errno, _("Cannot stat %s"), file_name);
781 /* Remove stale symlinks. */
782 if (strstr (direntry->d_name, ".so."))
783 unlink (real_file_name);
784 continue;
786 is_dir = S_ISDIR (stat_buf.st_mode);
788 /* lstat_buf is later stored, update contents. */
789 lstat_buf.st_dev = stat_buf.st_dev;
790 lstat_buf.st_ino = stat_buf.st_ino;
791 lstat_buf.st_size = stat_buf.st_size;
792 lstat_buf.st_ctime = stat_buf.st_ctime;
794 else
795 is_dir = S_ISDIR (lstat_buf.st_mode);
797 if (is_dir && is_hwcap_platform (direntry->d_name))
799 /* Handle subdirectory later. */
800 struct dir_entry *new_entry;
802 new_entry = xmalloc (sizeof (struct dir_entry));
803 new_entry->path = xstrdup (file_name);
804 new_entry->flag = entry->flag;
805 new_entry->next = NULL;
806 #ifdef _DIRENT_HAVE_D_TYPE
807 /* We have filled in lstat only #ifndef
808 _DIRENT_HAVE_D_TYPE. Fill it in if needed. */
809 if (!is_link
810 && direntry->d_type != DT_UNKNOWN
811 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
813 error (0, errno, _("Cannot lstat %s"), file_name);
814 free (new_entry->path);
815 free (new_entry);
816 continue;
818 #endif
819 new_entry->ino = lstat_buf.st_ino;
820 new_entry->dev = lstat_buf.st_dev;
821 add_single_dir (new_entry, 0);
822 continue;
824 else if (!S_ISREG (lstat_buf.st_mode) && !is_link)
825 continue;
827 char *real_name;
828 if (opt_chroot && is_link)
830 real_name = chroot_canon (opt_chroot, file_name);
831 if (real_name == NULL)
833 if (strstr (file_name, ".so") == NULL)
834 error (0, 0, _("Input file %s not found.\n"), file_name);
835 continue;
838 else
839 real_name = real_file_name;
841 #ifdef _DIRENT_HAVE_D_TYPE
842 /* Call lstat64 if not done yet. */
843 if (!is_link
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);
848 continue;
850 #endif
852 /* First search whether the auxiliary cache contains this
853 library already and it's not changed. */
854 char *soname;
855 unsigned int osversion;
856 if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))
858 if (process_file (real_name, file_name, direntry->d_name, &flag,
859 &osversion, &soname, is_link, &lstat_buf))
861 if (real_name != real_file_name)
862 free (real_name);
863 continue;
865 else if (opt_build_cache)
866 add_to_aux_cache (&lstat_buf, flag, osversion, soname);
869 if (soname == NULL)
870 soname = implicit_soname (direntry->d_name, flag);
872 /* A link may just point to itself. */
873 if (is_link)
875 /* If the path the link points to isn't its soname and it is not
876 .so symlink for ld(1) only, we treat it as a normal file. */
877 const char *real_base_name = basename (real_file_name);
879 if (strcmp (real_base_name, soname) != 0)
881 len = strlen (real_base_name);
882 if (len < strlen (".so")
883 || strcmp (real_base_name + len - strlen (".so"), ".so") != 0
884 || strncmp (real_base_name, soname, len) != 0)
885 is_link = 0;
889 if (real_name != real_file_name)
890 free (real_name);
892 if (is_link)
894 free (soname);
895 soname = xstrdup (direntry->d_name);
898 if (flag == FLAG_ELF
899 && (entry->flag == FLAG_ELF_LIBC5
900 || entry->flag == FLAG_ELF_LIBC6))
901 flag = entry->flag;
903 /* Some sanity checks to print warnings. */
904 if (opt_verbose)
906 if (flag == FLAG_ELF_LIBC5 && entry->flag != FLAG_ELF_LIBC5
907 && entry->flag != FLAG_ANY)
908 error (0, 0, _("libc5 library %s in wrong directory"), file_name);
909 if (flag == FLAG_ELF_LIBC6 && entry->flag != FLAG_ELF_LIBC6
910 && entry->flag != FLAG_ANY)
911 error (0, 0, _("libc6 library %s in wrong directory"), file_name);
912 if (flag == FLAG_LIBC4 && entry->flag != FLAG_LIBC4
913 && entry->flag != FLAG_ANY)
914 error (0, 0, _("libc4 library %s in wrong directory"), file_name);
917 /* Add library to list. */
918 struct dlib_entry *dlib_ptr;
919 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
921 /* Is soname already in list? */
922 if (strcmp (dlib_ptr->soname, soname) == 0)
924 /* Prefer a file to a link, otherwise check which one
925 is newer. */
926 if ((!is_link && dlib_ptr->is_link)
927 || (is_link == dlib_ptr->is_link
928 && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
930 /* It's newer - add it. */
931 /* Flag should be the same - sanity check. */
932 if (dlib_ptr->flag != flag)
934 if (dlib_ptr->flag == FLAG_ELF
935 && (flag == FLAG_ELF_LIBC5 || flag == FLAG_ELF_LIBC6))
936 dlib_ptr->flag = flag;
937 else if ((dlib_ptr->flag == FLAG_ELF_LIBC5
938 || dlib_ptr->flag == FLAG_ELF_LIBC6)
939 && flag == FLAG_ELF)
940 dlib_ptr->flag = flag;
941 else
942 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
943 dlib_ptr->name, direntry->d_name,
944 entry->path);
946 free (dlib_ptr->name);
947 dlib_ptr->name = xstrdup (direntry->d_name);
948 dlib_ptr->is_link = is_link;
949 dlib_ptr->osversion = osversion;
951 /* Don't add this library, abort loop. */
952 /* Also free soname, since it's dynamically allocated. */
953 free (soname);
954 break;
957 /* Add the library if it's not already in. */
958 if (dlib_ptr == NULL)
960 dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
961 dlib_ptr->name = xstrdup (direntry->d_name);
962 dlib_ptr->soname = soname;
963 dlib_ptr->flag = flag;
964 dlib_ptr->is_link = is_link;
965 dlib_ptr->osversion = osversion;
966 /* Add at head of list. */
967 dlib_ptr->next = dlibs;
968 dlibs = dlib_ptr;
972 closedir (dir);
974 /* Now dlibs contains a list of all libs - add those to the cache
975 and created all symbolic links. */
976 struct dlib_entry *dlib_ptr;
977 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
979 /* Don't create links to links. */
980 if (dlib_ptr->is_link == 0)
981 create_links (dir_name, entry->path, dlib_ptr->name,
982 dlib_ptr->soname);
983 if (opt_build_cache)
984 add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag,
985 dlib_ptr->osversion, hwcap);
988 /* Free all resources. */
989 while (dlibs)
991 dlib_ptr = dlibs;
992 free (dlib_ptr->soname);
993 free (dlib_ptr->name);
994 dlibs = dlibs->next;
995 free (dlib_ptr);
998 if (opt_chroot && dir_name)
999 free (dir_name);
1002 /* Search through all libraries. */
1003 static void
1004 search_dirs (void)
1006 struct dir_entry *entry;
1008 for (entry = dir_entries; entry != NULL; entry = entry->next)
1009 search_dir (entry);
1011 /* Free all allocated memory. */
1012 while (dir_entries)
1014 entry = dir_entries;
1015 dir_entries = dir_entries->next;
1016 free (entry->path);
1017 free (entry);
1022 static void parse_conf_include (const char *config_file, unsigned int lineno,
1023 bool do_chroot, const char *pattern);
1025 /* Parse configuration file. */
1026 static void
1027 parse_conf (const char *filename, bool do_chroot)
1029 FILE *file = NULL;
1030 char *line = NULL;
1031 const char *canon;
1032 size_t len = 0;
1033 unsigned int lineno;
1035 if (do_chroot && opt_chroot)
1037 canon = chroot_canon (opt_chroot, filename);
1038 if (canon)
1039 file = fopen (canon, "r");
1040 else
1041 canon = filename;
1043 else
1045 canon = filename;
1046 file = fopen (filename, "r");
1049 if (file == NULL)
1051 error (0, errno, _("Can't open configuration file %s"), canon);
1052 if (canon != filename)
1053 free ((char *) canon);
1054 return;
1057 /* No threads use this stream. */
1058 __fsetlocking (file, FSETLOCKING_BYCALLER);
1060 if (canon != filename)
1061 free ((char *) canon);
1063 lineno = 0;
1066 ssize_t n = getline (&line, &len, file);
1067 if (n < 0)
1068 break;
1070 ++lineno;
1071 if (line[n - 1] == '\n')
1072 line[n - 1] = '\0';
1074 /* Because the file format does not know any form of quoting we
1075 can search forward for the next '#' character and if found
1076 make it terminating the line. */
1077 *strchrnul (line, '#') = '\0';
1079 /* Remove leading whitespace. NUL is no whitespace character. */
1080 char *cp = line;
1081 while (isspace (*cp))
1082 ++cp;
1084 /* If the line is blank it is ignored. */
1085 if (cp[0] == '\0')
1086 continue;
1088 if (!strncmp (cp, "include", 7) && isblank (cp[7]))
1090 char *dir;
1091 cp += 8;
1092 while ((dir = strsep (&cp, " \t")) != NULL)
1093 if (dir[0] != '\0')
1094 parse_conf_include (filename, lineno, do_chroot, dir);
1096 else if (!strncasecmp (cp, "hwcap", 5) && isblank (cp[5]))
1098 cp += 6;
1099 char *p, *name = NULL;
1100 unsigned long int n = strtoul (cp, &cp, 0);
1101 if (cp != NULL && isblank (*cp))
1102 while ((p = strsep (&cp, " \t")) != NULL)
1103 if (p[0] != '\0')
1105 if (name == NULL)
1106 name = p;
1107 else
1109 name = NULL;
1110 break;
1113 if (name == NULL)
1115 error (EXIT_FAILURE, 0, _("%s:%u: bad syntax in hwcap line"),
1116 filename, lineno);
1117 break;
1119 if (n >= (64 - _DL_FIRST_EXTRA))
1120 error (EXIT_FAILURE, 0,
1121 _("%s:%u: hwcap index %lu above maximum %u"),
1122 filename, lineno, n, 64 - _DL_FIRST_EXTRA - 1);
1123 if (hwcap_extra[n] == NULL)
1125 for (unsigned long int h = 0; h < (64 - _DL_FIRST_EXTRA); ++h)
1126 if (hwcap_extra[h] != NULL && !strcmp (name, hwcap_extra[h]))
1127 error (EXIT_FAILURE, 0,
1128 _("%s:%u: hwcap index %lu already defined as %s"),
1129 filename, lineno, h, name);
1130 hwcap_extra[n] = xstrdup (name);
1132 else
1134 if (strcmp (name, hwcap_extra[n]))
1135 error (EXIT_FAILURE, 0,
1136 _("%s:%u: hwcap index %lu already defined as %s"),
1137 filename, lineno, n, hwcap_extra[n]);
1138 if (opt_verbose)
1139 error (0, 0, _("%s:%u: duplicate hwcap %lu %s"),
1140 filename, lineno, n, name);
1143 else
1144 add_dir (cp);
1146 while (!feof_unlocked (file));
1148 /* Free buffer and close file. */
1149 free (line);
1150 fclose (file);
1153 /* Handle one word in an `include' line, a glob pattern of additional
1154 config files to read. */
1155 static void
1156 parse_conf_include (const char *config_file, unsigned int lineno,
1157 bool do_chroot, const char *pattern)
1159 if (opt_chroot && pattern[0] != '/')
1160 error (EXIT_FAILURE, 0,
1161 _("need absolute file name for configuration file when using -r"));
1163 char *copy = NULL;
1164 if (pattern[0] != '/' && strchr (config_file, '/') != NULL)
1166 if (asprintf (&copy, "%s/%s", dirname (strdupa (config_file)),
1167 pattern) < 0)
1168 error (EXIT_FAILURE, 0, _("memory exhausted"));
1169 pattern = copy;
1172 glob64_t gl;
1173 int result;
1174 if (do_chroot && opt_chroot)
1176 char *canon = chroot_canon (opt_chroot, pattern);
1177 result = glob64 (canon ?: pattern, 0, NULL, &gl);
1178 free (canon);
1180 else
1181 result = glob64 (pattern, 0, NULL, &gl);
1183 switch (result)
1185 case 0:
1186 for (size_t i = 0; i < gl.gl_pathc; ++i)
1187 parse_conf (gl.gl_pathv[i], false);
1188 globfree64 (&gl);
1189 break;
1191 case GLOB_NOMATCH:
1192 break;
1194 case GLOB_NOSPACE:
1195 errno = ENOMEM;
1196 case GLOB_ABORTED:
1197 if (opt_verbose)
1198 error (0, errno, _("%s:%u: cannot read directory %s"),
1199 config_file, lineno, pattern);
1200 break;
1202 default:
1203 abort ();
1204 break;
1207 free (copy);
1210 /* Honour LD_HWCAP_MASK. */
1211 static void
1212 set_hwcap (void)
1214 char *mask = getenv ("LD_HWCAP_MASK");
1216 if (mask)
1217 hwcap_mask = strtoul (mask, NULL, 0);
1222 main (int argc, char **argv)
1224 /* Set locale via LC_ALL. */
1225 setlocale (LC_ALL, "");
1227 /* Set the text message domain. */
1228 textdomain (_libc_intl_domainname);
1230 /* Parse and process arguments. */
1231 int remaining;
1232 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1234 /* Remaining arguments are additional directories if opt_manual_link
1235 is not set. */
1236 if (remaining != argc && !opt_manual_link)
1238 int i;
1239 for (i = remaining; i < argc; ++i)
1240 if (opt_build_cache && argv[i][0] != '/')
1241 error (EXIT_FAILURE, 0,
1242 _("relative path `%s' used to build cache"),
1243 argv[i]);
1244 else
1245 add_dir (argv[i]);
1248 hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls";
1250 set_hwcap ();
1252 if (opt_chroot)
1254 /* Normalize the path a bit, we might need it for printing later. */
1255 char *endp = rawmemchr (opt_chroot, '\0');
1256 while (endp > opt_chroot && endp[-1] == '/')
1257 --endp;
1258 *endp = '\0';
1259 if (endp == opt_chroot)
1260 opt_chroot = NULL;
1262 if (opt_chroot)
1264 /* It is faster to use chroot if we can. */
1265 if (!chroot (opt_chroot))
1267 if (chdir ("/"))
1268 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1269 opt_chroot = NULL;
1274 if (cache_file == NULL)
1276 cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1277 strcpy (cache_file, LD_SO_CACHE);
1280 if (config_file == NULL)
1281 config_file = LD_SO_CONF;
1283 if (opt_print_cache)
1285 if (opt_chroot)
1287 char *p = chroot_canon (opt_chroot, cache_file);
1288 if (p == NULL)
1289 error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1290 cache_file);
1291 cache_file = p;
1293 print_cache (cache_file);
1294 if (opt_chroot)
1295 free (cache_file);
1296 exit (0);
1299 if (opt_chroot)
1301 /* Canonicalize the directory name of cache_file, not cache_file,
1302 because we'll rename a temporary cache file to it. */
1303 char *p = strrchr (cache_file, '/');
1304 char *canon = chroot_canon (opt_chroot,
1305 p ? (*p = '\0', cache_file) : "/");
1307 if (canon == NULL)
1309 error (EXIT_FAILURE, errno,
1310 _("Can't open cache file directory %s\n"),
1311 p ? cache_file : "/");
1314 if (p)
1315 ++p;
1316 else
1317 p = cache_file;
1319 cache_file = alloca (strlen (canon) + strlen (p) + 2);
1320 sprintf (cache_file, "%s/%s", canon, p);
1321 free (canon);
1324 if (opt_manual_link)
1326 /* Link all given libraries manually. */
1327 int i;
1329 for (i = remaining; i < argc; ++i)
1330 manual_link (argv[i]);
1332 exit (0);
1336 if (opt_build_cache)
1337 init_cache ();
1339 if (!opt_only_cline)
1341 parse_conf (config_file, true);
1343 /* Always add the standard search paths. */
1344 add_system_dir (SLIBDIR);
1345 if (strcmp (SLIBDIR, LIBDIR))
1346 add_system_dir (LIBDIR);
1349 if (! opt_ignore_aux_cache)
1350 load_aux_cache (_PATH_LDCONFIG_AUX_CACHE);
1351 else
1352 init_aux_cache ();
1354 search_dirs ();
1356 if (opt_build_cache)
1358 save_cache (cache_file);
1359 save_aux_cache (_PATH_LDCONFIG_AUX_CACHE);
1362 return 0;