1/* Copyright (C) 1999-2016 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Andreas Jaeger <aj@suse.de>, 1999.
4
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.
9
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.
14
15 You should have received a copy of the GNU General Public License
16 along with this program; if not, see <http://www.gnu.org/licenses/>. */
17
18#define PROCINFO_CLASS static
19#include <alloca.h>
20#include <argp.h>
21#include <dirent.h>
22#include <elf.h>
23#include <error.h>
24#include <errno.h>
25#include <inttypes.h>
26#include <libintl.h>
27#include <locale.h>
28#include <stdbool.h>
29#include <stdio.h>
30#include <stdio_ext.h>
31#include <stdlib.h>
32#include <string.h>
33#include <unistd.h>
34#include <stdint.h>
35#include <sys/fcntl.h>
36#include <sys/mman.h>
37#include <sys/stat.h>
38#include <sys/types.h>
39#include <glob.h>
40#include <libgen.h>
41
42#include <ldconfig.h>
43#include <dl-cache.h>
44
45#include <dl-procinfo.h>
46
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
52
53#ifndef LD_SO_CONF
54# define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
55#endif
56
57/* Get libc version number. */
58#include <version.h>
59
60#define PACKAGE _libc_intl_domainname
61
62static const struct
63{
64 const char *name;
65 int flag;
66} lib_types[] =
67{
68 {"libc4", FLAG_LIBC4},
69 {"libc5", FLAG_ELF_LIBC5},
70 {"libc6", FLAG_ELF_LIBC6},
71 {"glibc2", FLAG_ELF_LIBC6}
72};
73
74
75/* List of directories to handle. */
76struct dir_entry
77{
78 char *path;
79 int flag;
80 ino64_t ino;
81 dev_t dev;
82 struct dir_entry *next;
83};
84
85/* The list is unsorted, contains no duplicates. Entries are added at
86 the end. */
87static struct dir_entry *dir_entries;
88
89/* Flags for different options. */
90/* Print Cache. */
91static int opt_print_cache;
92
93/* Be verbose. */
94int opt_verbose;
95
96/* Format to support. */
97/* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
98int opt_format = 1;
99
100/* Build cache. */
101static int opt_build_cache = 1;
102
103/* Generate links. */
104static int opt_link = 1;
105
106/* Only process directories specified on the command line. */
107static int opt_only_cline;
108
109/* Path to root for chroot. */
110static char *opt_chroot;
111
112/* Manually link given shared libraries. */
113static int opt_manual_link;
114
115/* Should we ignore an old auxiliary cache file? */
116static int opt_ignore_aux_cache;
117
118/* Cache file to use. */
119static char *cache_file;
120
121/* Configuration file. */
122static const char *config_file;
123
124/* Mask to use for important hardware capabilities. */
125static unsigned long int hwcap_mask = HWCAP_IMPORTANT;
126
127/* Configuration-defined capabilities defined in kernel vDSOs. */
128static const char *hwcap_extra[64 - _DL_FIRST_EXTRA];
129
130/* Name and version of program. */
131static void print_version (FILE *stream, struct argp_state *state);
132void (*argp_program_version_hook) (FILE *, struct argp_state *)
133 = print_version;
134
135/* Function to print some extra text in the help message. */
136static char *more_help (int key, const char *text, void *input);
137
138/* Definitions of arguments for argp functions. */
139static const struct argp_option options[] =
140{
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 }
153};
154
155#define PROCINFO_CLASS static
156#include <dl-procinfo.c>
157
158/* Short description of program. */
159static const char doc[] = N_("Configure Dynamic Linker Run Time Bindings.");
160
161/* Prototype for option handler. */
162static error_t parse_opt (int key, char *arg, struct argp_state *state);
163
164/* Data structure to communicate with argp functions. */
165static struct argp argp =
166{
167 options, parse_opt, NULL, doc, NULL, more_help, NULL
168};
169
170/* Check if string corresponds to an important hardware capability or
171 a platform. */
172static int
173is_hwcap_platform (const char *name)
174{
175 int hwcap_idx = _dl_string_hwcap (name);
176
177 /* Is this a normal hwcap for the machine like "fpu?" */
178 if (hwcap_idx != -1 && ((1 << hwcap_idx) & hwcap_mask))
179 return 1;
180
181 /* Is this a platform pseudo-hwcap like "i686?" */
182 hwcap_idx = _dl_string_platform (name);
183 if (hwcap_idx != -1)
184 return 1;
185
186 /* Is this one of the extra pseudo-hwcaps that we map beyond
187 _DL_FIRST_EXTRA like "tls", or "nosegneg?" */
188 for (hwcap_idx = _DL_FIRST_EXTRA; hwcap_idx < 64; ++hwcap_idx)
189 if (hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA] != NULL
190 && !strcmp (name, hwcap_extra[hwcap_idx - _DL_FIRST_EXTRA]))
191 return 1;
192
193 return 0;
194}
195
196/* Get hwcap (including platform) encoding of path. */
197static uint64_t
198path_hwcap (const char *path)
199{
200 char *str = xstrdup (path);
201 char *ptr;
202 uint64_t hwcap = 0;
203 uint64_t h;
204
205 size_t len;
206
207 len = strlen (str);
208 if (str[len] == '/')
209 str[len] = '\0';
210
211 /* Search pathname from the end and check for hwcap strings. */
212 for (;;)
213 {
214 ptr = strrchr (str, '/');
215
216 if (ptr == NULL)
217 break;
218
219 h = _dl_string_hwcap (ptr + 1);
220
221 if (h == (uint64_t) -1)
222 {
223 h = _dl_string_platform (ptr + 1);
224 if (h == (uint64_t) -1)
225 {
226 for (h = _DL_FIRST_EXTRA; h < 64; ++h)
227 if (hwcap_extra[h - _DL_FIRST_EXTRA] != NULL
228 && !strcmp (ptr + 1, hwcap_extra[h - _DL_FIRST_EXTRA]))
229 break;
230 if (h == 64)
231 break;
232 }
233 }
234 hwcap += 1ULL << h;
235
236 /* Search the next part of the path. */
237 *ptr = '\0';
238 }
239
240 free (str);
241 return hwcap;
242}
243
244/* Handle program arguments. */
245static error_t
246parse_opt (int key, char *arg, struct argp_state *state)
247{
248 switch (key)
249 {
250 case 'C':
251 cache_file = arg;
252 /* Ignore auxiliary cache since we use non-standard cache. */
253 opt_ignore_aux_cache = 1;
254 break;
255 case 'f':
256 config_file = arg;
257 break;
258 case 'i':
259 opt_ignore_aux_cache = 1;
260 break;
261 case 'l':
262 opt_manual_link = 1;
263 break;
264 case 'N':
265 opt_build_cache = 0;
266 break;
267 case 'n':
268 opt_build_cache = 0;
269 opt_only_cline = 1;
270 break;
271 case 'p':
272 opt_print_cache = 1;
273 break;
274 case 'r':
275 opt_chroot = arg;
276 break;
277 case 'v':
278 opt_verbose = 1;
279 break;
280 case 'X':
281 opt_link = 0;
282 break;
283 case 'c':
284 if (strcmp (arg, "old") == 0)
285 opt_format = 0;
286 else if (strcmp (arg, "compat") == 0)
287 opt_format = 1;
288 else if (strcmp (arg, "new") == 0)
289 opt_format = 2;
290 break;
291 default:
292 return ARGP_ERR_UNKNOWN;
293 }
294
295 return 0;
296}
297
298/* Print bug-reporting information in the help message. */
299static char *
300more_help (int key, const char *text, void *input)
301{
302 char *tp = NULL;
303 switch (key)
304 {
305 case ARGP_KEY_HELP_EXTRA:
306 /* We print some extra information. */
307 if (asprintf (&tp, gettext ("\
308For bug reporting instructions, please see:\n\
309%s.\n"), REPORT_BUGS_TO) < 0)
310 return NULL;
311 return tp;
312 default:
313 break;
314 }
315 return (char *) text;
316}
317
318/* Print the version information. */
319static void
320print_version (FILE *stream, struct argp_state *state)
321{
322 fprintf (stream, "ldconfig %s%s\n", PKGVERSION, VERSION);
323 fprintf (stream, gettext ("\
324Copyright (C) %s Free Software Foundation, Inc.\n\
325This is free software; see the source for copying conditions. There is NO\n\
326warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
327"), "2016");
328 fprintf (stream, gettext ("Written by %s.\n"),
329 "Andreas Jaeger");
330}
331
332/* Add a single directory entry. */
333static void
334add_single_dir (struct dir_entry *entry, int verbose)
335{
336 struct dir_entry *ptr, *prev;
337
338 ptr = dir_entries;
339 prev = ptr;
340 while (ptr != NULL)
341 {
342 /* Check for duplicates. */
343 if (ptr->ino == entry->ino && ptr->dev == entry->dev)
344 {
345 if (opt_verbose && verbose)
346 error (0, 0, _("Path `%s' given more than once"), entry->path);
347 /* Use the newer information. */
348 ptr->flag = entry->flag;
349 free (entry->path);
350 free (entry);
351 break;
352 }
353 prev = ptr;
354 ptr = ptr->next;
355 }
356 /* Is this the first entry? */
357 if (ptr == NULL && dir_entries == NULL)
358 dir_entries = entry;
359 else if (ptr == NULL)
360 prev->next = entry;
361}
362
363/* Add one directory to the list of directories to process. */
364static void
365add_dir (const char *line)
366{
367 unsigned int i;
368 struct dir_entry *entry = xmalloc (sizeof (struct dir_entry));
369 entry->next = NULL;
370
371 /* Search for an '=' sign. */
372 entry->path = xstrdup (line);
373 char *equal_sign = strchr (entry->path, '=');
374 if (equal_sign)
375 {
376 *equal_sign = '\0';
377 ++equal_sign;
378 entry->flag = FLAG_ANY;
379 for (i = 0; i < sizeof (lib_types) / sizeof (lib_types[0]); ++i)
380 if (strcmp (equal_sign, lib_types[i].name) == 0)
381 {
382 entry->flag = lib_types[i].flag;
383 break;
384 }
385 if (entry->flag == FLAG_ANY)
386 error (0, 0, _("%s is not a known library type"), equal_sign);
387 }
388 else
389 {
390 entry->flag = FLAG_ANY;
391 }
392
393 /* Canonify path: for now only remove leading and trailing
394 whitespace and the trailing slashes. */
395 i = strlen (entry->path);
396
397 while (i > 0 && isspace (entry->path[i - 1]))
398 entry->path[--i] = '\0';
399
400 while (i > 0 && entry->path[i - 1] == '/')
401 entry->path[--i] = '\0';
402
403 if (i == 0)
404 return;
405
406 char *path = entry->path;
407 if (opt_chroot)
408 path = chroot_canon (opt_chroot, path);
409
410 struct stat64 stat_buf;
411 if (path == NULL || stat64 (path, &stat_buf))
412 {
413 if (opt_verbose)
414 error (0, errno, _("Can't stat %s"), entry->path);
415 free (entry->path);
416 free (entry);
417 }
418 else
419 {
420 entry->ino = stat_buf.st_ino;
421 entry->dev = stat_buf.st_dev;
422
423 add_single_dir (entry, 1);
424 }
425
426 if (opt_chroot)
427 free (path);
428}
429
430
431static int
432chroot_stat (const char *real_path, const char *path, struct stat64 *st)
433{
434 int ret;
435 char *canon_path;
436
437 if (!opt_chroot)
438 return stat64 (real_path, st);
439
440 ret = lstat64 (real_path, st);
441 if (ret || !S_ISLNK (st->st_mode))
442 return ret;
443
444 canon_path = chroot_canon (opt_chroot, path);
445 if (canon_path == NULL)
446 return -1;
447
448 ret = stat64 (canon_path, st);
449 free (canon_path);
450 return ret;
451}
452
453/* Create a symbolic link from soname to libname in directory path. */
454static void
455create_links (const char *real_path, const char *path, const char *libname,
456 const char *soname)
457{
458 char *full_libname, *full_soname;
459 char *real_full_libname, *real_full_soname;
460 struct stat64 stat_lib, stat_so, lstat_so;
461 int do_link = 1;
462 int do_remove = 1;
463 /* XXX: The logics in this function should be simplified. */
464
465 /* Get complete path. */
466 full_libname = alloca (strlen (path) + strlen (libname) + 2);
467 full_soname = alloca (strlen (path) + strlen (soname) + 2);
468 sprintf (full_libname, "%s/%s", path, libname);
469 sprintf (full_soname, "%s/%s", path, soname);
470 if (opt_chroot)
471 {
472 real_full_libname = alloca (strlen (real_path) + strlen (libname) + 2);
473 real_full_soname = alloca (strlen (real_path) + strlen (soname) + 2);
474 sprintf (real_full_libname, "%s/%s", real_path, libname);
475 sprintf (real_full_soname, "%s/%s", real_path, soname);
476 }
477 else
478 {
479 real_full_libname = full_libname;
480 real_full_soname = full_soname;
481 }
482
483 /* Does soname already exist and point to the right library? */
484 if (chroot_stat (real_full_soname, full_soname, &stat_so) == 0)
485 {
486 if (chroot_stat (real_full_libname, full_libname, &stat_lib))
487 {
488 error (0, 0, _("Can't stat %s\n"), full_libname);
489 return;
490 }
491 if (stat_lib.st_dev == stat_so.st_dev
492 && stat_lib.st_ino == stat_so.st_ino)
493 /* Link is already correct. */
494 do_link = 0;
495 else if (lstat64 (full_soname, &lstat_so) == 0
496 && !S_ISLNK (lstat_so.st_mode))
497 {
498 error (0, 0, _("%s is not a symbolic link\n"), full_soname);
499 do_link = 0;
500 do_remove = 0;
501 }
502 }
503 else if (lstat64 (real_full_soname, &lstat_so) != 0
504 || !S_ISLNK (lstat_so.st_mode))
505 /* Unless it is a stale symlink, there is no need to remove. */
506 do_remove = 0;
507
508 if (opt_verbose)
509 printf ("\t%s -> %s", soname, libname);
510
511 if (do_link && opt_link)
512 {
513 /* Remove old link. */
514 if (do_remove)
515 if (unlink (real_full_soname))
516 {
517 error (0, 0, _("Can't unlink %s"), full_soname);
518 do_link = 0;
519 }
520 /* Create symbolic link. */
521 if (do_link && symlink (libname, real_full_soname))
522 {
523 error (0, 0, _("Can't link %s to %s"), full_soname, libname);
524 do_link = 0;
525 }
526 if (opt_verbose)
527 {
528 if (do_link)
529 fputs (_(" (changed)\n"), stdout);
530 else
531 fputs (_(" (SKIPPED)\n"), stdout);
532 }
533 }
534 else if (opt_verbose)
535 fputs ("\n", stdout);
536}
537
538/* Manually link the given library. */
539static void
540manual_link (char *library)
541{
542 char *path;
543 char *real_path;
544 char *real_library;
545 char *libname;
546 char *soname;
547 struct stat64 stat_buf;
548 int flag;
549 unsigned int osversion;
550
551 /* Prepare arguments for create_links call. Split library name in
552 directory and filename first. Since path is allocated, we've got
553 to be careful to free at the end. */
554 path = xstrdup (library);
555 libname = strrchr (path, '/');
556
557 if (libname)
558 {
559 /* Successfully split names. Check if path is just "/" to avoid
560 an empty path. */
561 if (libname == path)
562 {
563 libname = library + 1;
564 path = xrealloc (path, 2);
565 strcpy (path, "/");
566 }
567 else
568 {
569 *libname = '\0';
570 ++libname;
571 }
572 }
573 else
574 {
575 /* There's no path, construct one. */
576 libname = library;
577 path = xrealloc (path, 2);
578 strcpy (path, ".");
579 }
580
581 if (opt_chroot)
582 {
583 real_path = chroot_canon (opt_chroot, path);
584 if (real_path == NULL)
585 {
586 error (0, errno, _("Can't find %s"), path);
587 free (path);
588 return;
589 }
590 real_library = alloca (strlen (real_path) + strlen (libname) + 2);
591 sprintf (real_library, "%s/%s", real_path, libname);
592 }
593 else
594 {
595 real_path = path;
596 real_library = library;
597 }
598
599 /* Do some sanity checks first. */
600 if (lstat64 (real_library, &stat_buf))
601 {
602 error (0, errno, _("Cannot lstat %s"), library);
603 free (path);
604 return;
605 }
606 /* We don't want links here! */
607 else if (!S_ISREG (stat_buf.st_mode))
608 {
609 error (0, 0, _("Ignored file %s since it is not a regular file."),
610 library);
611 free (path);
612 return;
613 }
614
615 if (process_file (real_library, library, libname, &flag, &osversion,
616 &soname, 0, &stat_buf))
617 {
618 error (0, 0, _("No link created since soname could not be found for %s"),
619 library);
620 free (path);
621 return;
622 }
623 if (soname == NULL)
624 soname = implicit_soname (libname, flag);
625 create_links (real_path, path, libname, soname);
626 free (soname);
627 free (path);
628}
629
630
631/* Read a whole directory and search for libraries.
632 The purpose is two-fold:
633 - search for libraries which will be added to the cache
634 - create symbolic links to the soname for each library
635
636 This has to be done separatly for each directory.
637
638 To keep track of which libraries to add to the cache and which
639 links to create, we save a list of all libraries.
640
641 The algorithm is basically:
642 for all libraries in the directory do
643 get soname of library
644 if soname is already in list
645 if new library is newer, replace entry
646 otherwise ignore this library
647 otherwise add library to list
648
649 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
650 exist and both have the same soname, e.g. libxy.so, a symbolic link
651 is created from libxy.so.1.2 (the newer one) to libxy.so.
652 libxy.so.1.2 and libxy.so are added to the cache - but not
653 libxy.so.1.1. */
654
655/* Information for one library. */
656struct dlib_entry
657{
658 char *name;
659 char *soname;
660 int flag;
661 int is_link;
662 unsigned int osversion;
663 struct dlib_entry *next;
664};
665
666
667static void
668search_dir (const struct dir_entry *entry)
669{
670 uint64_t hwcap = path_hwcap (entry->path);
671 if (opt_verbose)
672 {
673 if (hwcap != 0)
674 printf ("%s: (hwcap: %#.16" PRIx64 ")\n", entry->path, hwcap);
675 else
676 printf ("%s:\n", entry->path);
677 }
678
679 char *dir_name;
680 char *real_file_name;
681 size_t real_file_name_len;
682 size_t file_name_len = PATH_MAX;
683 char *file_name = alloca (file_name_len);
684 if (opt_chroot)
685 {
686 dir_name = chroot_canon (opt_chroot, entry->path);
687 real_file_name_len = PATH_MAX;
688 real_file_name = alloca (real_file_name_len);
689 }
690 else
691 {
692 dir_name = entry->path;
693 real_file_name_len = 0;
694 real_file_name = file_name;
695 }
696
697 DIR *dir;
698 if (dir_name == NULL || (dir = opendir (dir_name)) == NULL)
699 {
700 if (opt_verbose)
701 error (0, errno, _("Can't open directory %s"), entry->path);
702 if (opt_chroot && dir_name)
703 free (dir_name);
704 return;
705 }
706
707 struct dirent64 *direntry;
708 struct dlib_entry *dlibs = NULL;
709 while ((direntry = readdir64 (dir)) != NULL)
710 {
711 int flag;
712#ifdef _DIRENT_HAVE_D_TYPE
713 /* We only look at links and regular files. */
714 if (direntry->d_type != DT_UNKNOWN
715 && direntry->d_type != DT_LNK
716 && direntry->d_type != DT_REG
717 && direntry->d_type != DT_DIR)
718 continue;
719#endif /* _DIRENT_HAVE_D_TYPE */
720 /* Does this file look like a shared library or is it a hwcap
721 subdirectory? The dynamic linker is also considered as
722 shared library. */
723 if (((strncmp (direntry->d_name, "lib", 3) != 0
724 && strncmp (direntry->d_name, "ld-", 3) != 0)
725 || strstr (direntry->d_name, ".so") == NULL)
726 && (
727#ifdef _DIRENT_HAVE_D_TYPE
728 direntry->d_type == DT_REG ||
729#endif
730 !is_hwcap_platform (direntry->d_name)))
731 continue;
732
733 size_t len = strlen (direntry->d_name);
734 /* Skip temporary files created by the prelink program. Files with
735 names like these are never really DSOs we want to look at. */
736 if (len >= sizeof (".#prelink#") - 1)
737 {
738 if (strcmp (direntry->d_name + len - sizeof (".#prelink#") + 1,
739 ".#prelink#") == 0)
740 continue;
741 if (len >= sizeof (".#prelink#.XXXXXX") - 1
742 && memcmp (direntry->d_name + len - sizeof (".#prelink#.XXXXXX")
743 + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
744 continue;
745 }
746 len += strlen (entry->path) + 2;
747 if (len > file_name_len)
748 {
749 file_name_len = len;
750 file_name = alloca (file_name_len);
751 if (!opt_chroot)
752 real_file_name = file_name;
753 }
754 sprintf (file_name, "%s/%s", entry->path, direntry->d_name);
755 if (opt_chroot)
756 {
757 len = strlen (dir_name) + strlen (direntry->d_name) + 2;
758 if (len > real_file_name_len)
759 {
760 real_file_name_len = len;
761 real_file_name = alloca (real_file_name_len);
762 }
763 sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);
764 }
765
766 struct stat64 lstat_buf;
767#ifdef _DIRENT_HAVE_D_TYPE
768 /* We optimize and try to do the lstat call only if needed. */
769 if (direntry->d_type != DT_UNKNOWN)
770 lstat_buf.st_mode = DTTOIF (direntry->d_type);
771 else
772#endif
773 if (__glibc_unlikely (lstat64 (real_file_name, &lstat_buf)))
774 {
775 error (0, errno, _("Cannot lstat %s"), file_name);
776 continue;
777 }
778
779 struct stat64 stat_buf;
780 int is_dir;
781 int is_link = S_ISLNK (lstat_buf.st_mode);
782 if (is_link)
783 {
784 /* In case of symlink, we check if the symlink refers to
785 a directory. */
786 char *target_name = real_file_name;
787 if (opt_chroot)
788 {
789 target_name = chroot_canon (opt_chroot, file_name);
790 if (target_name == NULL)
791 {
792 if (strstr (file_name, ".so") == NULL)
793 error (0, 0, _("Input file %s not found.\n"), file_name);
794 continue;
795 }
796 }
797 if (__glibc_unlikely (stat64 (target_name, &stat_buf)))
798 {
799 if (opt_verbose)
800 error (0, errno, _("Cannot stat %s"), file_name);
801
802 /* Remove stale symlinks. */
803 if (strstr (direntry->d_name, ".so."))
804 unlink (real_file_name);
805 continue;
806 }
807 is_dir = S_ISDIR (stat_buf.st_mode);
808
809 /* lstat_buf is later stored, update contents. */
810 lstat_buf.st_dev = stat_buf.st_dev;
811 lstat_buf.st_ino = stat_buf.st_ino;
812 lstat_buf.st_size = stat_buf.st_size;
813 lstat_buf.st_ctime = stat_buf.st_ctime;
814 }
815 else
816 is_dir = S_ISDIR (lstat_buf.st_mode);
817
818 if (is_dir && is_hwcap_platform (direntry->d_name))
819 {
820 /* Handle subdirectory later. */
821 struct dir_entry *new_entry;
822
823 new_entry = xmalloc (sizeof (struct dir_entry));
824 new_entry->path = xstrdup (file_name);
825 new_entry->flag = entry->flag;
826 new_entry->next = NULL;
827#ifdef _DIRENT_HAVE_D_TYPE
828 /* We have filled in lstat only #ifndef
829 _DIRENT_HAVE_D_TYPE. Fill it in if needed. */
830 if (!is_link
831 && direntry->d_type != DT_UNKNOWN
832 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
833 {
834 error (0, errno, _("Cannot lstat %s"), file_name);
835 free (new_entry->path);
836 free (new_entry);
837 continue;
838 }
839#endif
840 new_entry->ino = lstat_buf.st_ino;
841 new_entry->dev = lstat_buf.st_dev;
842 add_single_dir (new_entry, 0);
843 continue;
844 }
845 else if (!S_ISREG (lstat_buf.st_mode) && !is_link)
846 continue;
847
848 char *real_name;
849 if (opt_chroot && is_link)
850 {
851 real_name = chroot_canon (opt_chroot, file_name);
852 if (real_name == NULL)
853 {
854 if (strstr (file_name, ".so") == NULL)
855 error (0, 0, _("Input file %s not found.\n"), file_name);
856 continue;
857 }
858 }
859 else
860 real_name = real_file_name;
861
862#ifdef _DIRENT_HAVE_D_TYPE
863 /* Call lstat64 if not done yet. */
864 if (!is_link
865 && direntry->d_type != DT_UNKNOWN
866 && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
867 {
868 error (0, errno, _("Cannot lstat %s"), file_name);
869 continue;
870 }
871#endif
872
873 /* First search whether the auxiliary cache contains this
874 library already and it's not changed. */
875 char *soname;
876 unsigned int osversion;
877 if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))
878 {
879 if (process_file (real_name, file_name, direntry->d_name, &flag,
880 &osversion, &soname, is_link, &lstat_buf))
881 {
882 if (real_name != real_file_name)
883 free (real_name);
884 continue;
885 }
886 else if (opt_build_cache)
887 add_to_aux_cache (&lstat_buf, flag, osversion, soname);
888 }
889
890 if (soname == NULL)
891 soname = implicit_soname (direntry->d_name, flag);
892
893 /* A link may just point to itself. */
894 if (is_link)
895 {
896 /* If the path the link points to isn't its soname or it is not
897 the .so symlink for ld(1), we treat it as a normal file.
898
899 You should always do this:
900
901 libfoo.so -> SONAME -> Arbitrary package-chosen name.
902
903 e.g. libfoo.so -> libfoo.so.1 -> libfooimp.so.9.99.
904 Given a SONAME of libfoo.so.1.
905
906 You should *never* do this:
907
908 libfoo.so -> libfooimp.so.9.99
909
910 If you do, and your SONAME is libfoo.so.1, then libfoo.so
911 fails to point at the SONAME. In that case ldconfig may consider
912 libfoo.so as another implementation of SONAME and will create
913 symlinks against it causing problems when you try to upgrade
914 or downgrade. The problems will arise because ldconfig will,
915 depending on directory ordering, creat symlinks against libfoo.so
916 e.g. libfoo.so.1.2 -> libfoo.so, but when libfoo.so is removed
917 (typically by the removal of a development pacakge not required
918 for the runtime) it will break the libfoo.so.1.2 symlink and the
919 application will fail to start. */
920 const char *real_base_name = basename (real_file_name);
921
922 if (strcmp (real_base_name, soname) != 0)
923 {
924 len = strlen (real_base_name);
925 if (len < strlen (".so")
926 || strcmp (real_base_name + len - strlen (".so"), ".so") != 0
927 || strncmp (real_base_name, soname, len) != 0)
928 is_link = 0;
929 }
930 }
931
932 if (real_name != real_file_name)
933 free (real_name);
934
935 if (is_link)
936 {
937 free (soname);
938 soname = xstrdup (direntry->d_name);
939 }
940
941 if (flag == FLAG_ELF
942 && (entry->flag == FLAG_ELF_LIBC5
943 || entry->flag == FLAG_ELF_LIBC6))
944 flag = entry->flag;
945
946 /* Some sanity checks to print warnings. */
947 if (opt_verbose)
948 {
949 if (flag == FLAG_ELF_LIBC5 && entry->flag != FLAG_ELF_LIBC5
950 && entry->flag != FLAG_ANY)
951 error (0, 0, _("libc5 library %s in wrong directory"), file_name);
952 if (flag == FLAG_ELF_LIBC6 && entry->flag != FLAG_ELF_LIBC6
953 && entry->flag != FLAG_ANY)
954 error (0, 0, _("libc6 library %s in wrong directory"), file_name);
955 if (flag == FLAG_LIBC4 && entry->flag != FLAG_LIBC4
956 && entry->flag != FLAG_ANY)
957 error (0, 0, _("libc4 library %s in wrong directory"), file_name);
958 }
959
960 /* Add library to list. */
961 struct dlib_entry *dlib_ptr;
962 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
963 {
964 /* Is soname already in list? */
965 if (strcmp (dlib_ptr->soname, soname) == 0)
966 {
967 /* Prefer a file to a link, otherwise check which one
968 is newer. */
969 if ((!is_link && dlib_ptr->is_link)
970 || (is_link == dlib_ptr->is_link
971 && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
972 {
973 /* It's newer - add it. */
974 /* Flag should be the same - sanity check. */
975 if (dlib_ptr->flag != flag)
976 {
977 if (dlib_ptr->flag == FLAG_ELF
978 && (flag == FLAG_ELF_LIBC5 || flag == FLAG_ELF_LIBC6))
979 dlib_ptr->flag = flag;
980 else if ((dlib_ptr->flag == FLAG_ELF_LIBC5
981 || dlib_ptr->flag == FLAG_ELF_LIBC6)
982 && flag == FLAG_ELF)
983 dlib_ptr->flag = flag;
984 else
985 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
986 dlib_ptr->name, direntry->d_name,
987 entry->path);
988 }
989 free (dlib_ptr->name);
990 dlib_ptr->name = xstrdup (direntry->d_name);
991 dlib_ptr->is_link = is_link;
992 dlib_ptr->osversion = osversion;
993 }
994 /* Don't add this library, abort loop. */
995 /* Also free soname, since it's dynamically allocated. */
996 free (soname);
997 break;
998 }
999 }
1000 /* Add the library if it's not already in. */
1001 if (dlib_ptr == NULL)
1002 {
1003 dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
1004 dlib_ptr->name = xstrdup (direntry->d_name);
1005 dlib_ptr->soname = soname;
1006 dlib_ptr->flag = flag;
1007 dlib_ptr->is_link = is_link;
1008 dlib_ptr->osversion = osversion;
1009 /* Add at head of list. */
1010 dlib_ptr->next = dlibs;
1011 dlibs = dlib_ptr;
1012 }
1013 }
1014
1015 closedir (dir);
1016
1017 /* Now dlibs contains a list of all libs - add those to the cache
1018 and created all symbolic links. */
1019 struct dlib_entry *dlib_ptr;
1020 for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
1021 {
1022 /* Don't create links to links. */
1023 if (dlib_ptr->is_link == 0)
1024 create_links (dir_name, entry->path, dlib_ptr->name,
1025 dlib_ptr->soname);
1026 if (opt_build_cache)
1027 add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag,
1028 dlib_ptr->osversion, hwcap);
1029 }
1030
1031 /* Free all resources. */
1032 while (dlibs)
1033 {
1034 dlib_ptr = dlibs;
1035 free (dlib_ptr->soname);
1036 free (dlib_ptr->name);
1037 dlibs = dlibs->next;
1038 free (dlib_ptr);
1039 }
1040
1041 if (opt_chroot && dir_name)
1042 free (dir_name);
1043}
1044
1045/* Search through all libraries. */
1046static void
1047search_dirs (void)
1048{
1049 struct dir_entry *entry;
1050
1051 for (entry = dir_entries; entry != NULL; entry = entry->next)
1052 search_dir (entry);
1053
1054 /* Free all allocated memory. */
1055 while (dir_entries)
1056 {
1057 entry = dir_entries;
1058 dir_entries = dir_entries->next;
1059 free (entry->path);
1060 free (entry);
1061 }
1062}
1063
1064
1065static void parse_conf_include (const char *config_file, unsigned int lineno,
1066 bool do_chroot, const char *pattern);
1067
1068/* Parse configuration file. */
1069static void
1070parse_conf (const char *filename, bool do_chroot)
1071{
1072 FILE *file = NULL;
1073 char *line = NULL;
1074 const char *canon;
1075 size_t len = 0;
1076 unsigned int lineno;
1077
1078 if (do_chroot && opt_chroot)
1079 {
1080 canon = chroot_canon (opt_chroot, filename);
1081 if (canon)
1082 file = fopen (canon, "r");
1083 else
1084 canon = filename;
1085 }
1086 else
1087 {
1088 canon = filename;
1089 file = fopen (filename, "r");
1090 }
1091
1092 if (file == NULL)
1093 {
1094 error (0, errno, _("\
1095Warning: ignoring configuration file that cannot be opened: %s"),
1096 canon);
1097 if (canon != filename)
1098 free ((char *) canon);
1099 return;
1100 }
1101
1102 /* No threads use this stream. */
1103 __fsetlocking (file, FSETLOCKING_BYCALLER);
1104
1105 if (canon != filename)
1106 free ((char *) canon);
1107
1108 lineno = 0;
1109 do
1110 {
1111 ssize_t n = getline (&line, &len, file);
1112 if (n < 0)
1113 break;
1114
1115 ++lineno;
1116 if (line[n - 1] == '\n')
1117 line[n - 1] = '\0';
1118
1119 /* Because the file format does not know any form of quoting we
1120 can search forward for the next '#' character and if found
1121 make it terminating the line. */
1122 *strchrnul (line, '#') = '\0';
1123
1124 /* Remove leading whitespace. NUL is no whitespace character. */
1125 char *cp = line;
1126 while (isspace (*cp))
1127 ++cp;
1128
1129 /* If the line is blank it is ignored. */
1130 if (cp[0] == '\0')
1131 continue;
1132
1133 if (!strncmp (cp, "include", 7) && isblank (cp[7]))
1134 {
1135 char *dir;
1136 cp += 8;
1137 while ((dir = strsep (&cp, " \t")) != NULL)
1138 if (dir[0] != '\0')
1139 parse_conf_include (filename, lineno, do_chroot, dir);
1140 }
1141 else if (!strncasecmp (cp, "hwcap", 5) && isblank (cp[5]))
1142 {
1143 cp += 6;
1144 char *p, *name = NULL;
1145 unsigned long int n = strtoul (cp, &cp, 0);
1146 if (cp != NULL && isblank (*cp))
1147 while ((p = strsep (&cp, " \t")) != NULL)
1148 if (p[0] != '\0')
1149 {
1150 if (name == NULL)
1151 name = p;
1152 else
1153 {
1154 name = NULL;
1155 break;
1156 }
1157 }
1158 if (name == NULL)
1159 {
1160 error (EXIT_FAILURE, 0, _("%s:%u: bad syntax in hwcap line"),
1161 filename, lineno);
1162 break;
1163 }
1164 if (n >= (64 - _DL_FIRST_EXTRA))
1165 error (EXIT_FAILURE, 0,
1166 _("%s:%u: hwcap index %lu above maximum %u"),
1167 filename, lineno, n, 64 - _DL_FIRST_EXTRA - 1);
1168 if (hwcap_extra[n] == NULL)
1169 {
1170 for (unsigned long int h = 0; h < (64 - _DL_FIRST_EXTRA); ++h)
1171 if (hwcap_extra[h] != NULL && !strcmp (name, hwcap_extra[h]))
1172 error (EXIT_FAILURE, 0,
1173 _("%s:%u: hwcap index %lu already defined as %s"),
1174 filename, lineno, h, name);
1175 hwcap_extra[n] = xstrdup (name);
1176 }
1177 else
1178 {
1179 if (strcmp (name, hwcap_extra[n]))
1180 error (EXIT_FAILURE, 0,
1181 _("%s:%u: hwcap index %lu already defined as %s"),
1182 filename, lineno, n, hwcap_extra[n]);
1183 if (opt_verbose)
1184 error (0, 0, _("%s:%u: duplicate hwcap %lu %s"),
1185 filename, lineno, n, name);
1186 }
1187 }
1188 else
1189 add_dir (cp);
1190 }
1191 while (!feof_unlocked (file));
1192
1193 /* Free buffer and close file. */
1194 free (line);
1195 fclose (file);
1196}
1197
1198/* Handle one word in an `include' line, a glob pattern of additional
1199 config files to read. */
1200static void
1201parse_conf_include (const char *config_file, unsigned int lineno,
1202 bool do_chroot, const char *pattern)
1203{
1204 if (opt_chroot && pattern[0] != '/')
1205 error (EXIT_FAILURE, 0,
1206 _("need absolute file name for configuration file when using -r"));
1207
1208 char *copy = NULL;
1209 if (pattern[0] != '/' && strchr (config_file, '/') != NULL)
1210 {
1211 if (asprintf (&copy, "%s/%s", dirname (strdupa (config_file)),
1212 pattern) < 0)
1213 error (EXIT_FAILURE, 0, _("memory exhausted"));
1214 pattern = copy;
1215 }
1216
1217 glob64_t gl;
1218 int result;
1219 if (do_chroot && opt_chroot)
1220 {
1221 char *canon = chroot_canon (opt_chroot, pattern);
1222 if (canon == NULL)
1223 return;
1224 result = glob64 (canon, 0, NULL, &gl);
1225 free (canon);
1226 }
1227 else
1228 result = glob64 (pattern, 0, NULL, &gl);
1229
1230 switch (result)
1231 {
1232 case 0:
1233 for (size_t i = 0; i < gl.gl_pathc; ++i)
1234 parse_conf (gl.gl_pathv[i], false);
1235 globfree64 (&gl);
1236 break;
1237
1238 case GLOB_NOMATCH:
1239 break;
1240
1241 case GLOB_NOSPACE:
1242 errno = ENOMEM;
1243 case GLOB_ABORTED:
1244 if (opt_verbose)
1245 error (0, errno, _("%s:%u: cannot read directory %s"),
1246 config_file, lineno, pattern);
1247 break;
1248
1249 default:
1250 abort ();
1251 break;
1252 }
1253
1254 free (copy);
1255}
1256
1257/* Honour LD_HWCAP_MASK. */
1258static void
1259set_hwcap (void)
1260{
1261 char *mask = getenv ("LD_HWCAP_MASK");
1262
1263 if (mask)
1264 hwcap_mask = strtoul (mask, NULL, 0);
1265}
1266
1267
1268int
1269main (int argc, char **argv)
1270{
1271 /* Set locale via LC_ALL. */
1272 setlocale (LC_ALL, "");
1273
1274 /* Set the text message domain. */
1275 textdomain (_libc_intl_domainname);
1276
1277 /* Parse and process arguments. */
1278 int remaining;
1279 argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1280
1281 /* Remaining arguments are additional directories if opt_manual_link
1282 is not set. */
1283 if (remaining != argc && !opt_manual_link)
1284 {
1285 int i;
1286 for (i = remaining; i < argc; ++i)
1287 if (opt_build_cache && argv[i][0] != '/')
1288 error (EXIT_FAILURE, 0,
1289 _("relative path `%s' used to build cache"),
1290 argv[i]);
1291 else
1292 add_dir (argv[i]);
1293 }
1294
1295 /* The last entry in hwcap_extra is reserved for the "tls" pseudo-hwcap which
1296 indicates support for TLS. This pseudo-hwcap is only used by old versions
1297 under which TLS support was optional. The entry is no longer needed, but
1298 must remain for compatibility. */
1299 hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls";
1300
1301 set_hwcap ();
1302
1303 if (opt_chroot)
1304 {
1305 /* Normalize the path a bit, we might need it for printing later. */
1306 char *endp = rawmemchr (opt_chroot, '\0');
1307 while (endp > opt_chroot && endp[-1] == '/')
1308 --endp;
1309 *endp = '\0';
1310 if (endp == opt_chroot)
1311 opt_chroot = NULL;
1312
1313 if (opt_chroot)
1314 {
1315 /* It is faster to use chroot if we can. */
1316 if (!chroot (opt_chroot))
1317 {
1318 if (chdir ("/"))
1319 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1320 opt_chroot = NULL;
1321 }
1322 }
1323 }
1324
1325 if (cache_file == NULL)
1326 {
1327 cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1328 strcpy (cache_file, LD_SO_CACHE);
1329 }
1330
1331 if (config_file == NULL)
1332 config_file = LD_SO_CONF;
1333
1334 if (opt_print_cache)
1335 {
1336 if (opt_chroot)
1337 {
1338 char *p = chroot_canon (opt_chroot, cache_file);
1339 if (p == NULL)
1340 error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1341 cache_file);
1342 cache_file = p;
1343 }
1344 print_cache (cache_file);
1345 if (opt_chroot)
1346 free (cache_file);
1347 exit (0);
1348 }
1349
1350 if (opt_chroot)
1351 {
1352 /* Canonicalize the directory name of cache_file, not cache_file,
1353 because we'll rename a temporary cache file to it. */
1354 char *p = strrchr (cache_file, '/');
1355 char *canon = chroot_canon (opt_chroot,
1356 p ? (*p = '\0', cache_file) : "/");
1357
1358 if (canon == NULL)
1359 error (EXIT_FAILURE, errno,
1360 _("Can't open cache file directory %s\n"),
1361 p ? cache_file : "/");
1362
1363 if (p)
1364 ++p;
1365 else
1366 p = cache_file;
1367
1368 cache_file = alloca (strlen (canon) + strlen (p) + 2);
1369 sprintf (cache_file, "%s/%s", canon, p);
1370 free (canon);
1371 }
1372
1373 if (opt_manual_link)
1374 {
1375 /* Link all given libraries manually. */
1376 int i;
1377
1378 for (i = remaining; i < argc; ++i)
1379 manual_link (argv[i]);
1380
1381 exit (0);
1382 }
1383
1384
1385 if (opt_build_cache)
1386 init_cache ();
1387
1388 if (!opt_only_cline)
1389 {
1390 parse_conf (config_file, true);
1391
1392 /* Always add the standard search paths. */
1393 add_system_dir (SLIBDIR);
1394 if (strcmp (SLIBDIR, LIBDIR))
1395 add_system_dir (LIBDIR);
1396 }
1397
1398 const char *aux_cache_file = _PATH_LDCONFIG_AUX_CACHE;
1399 if (opt_chroot)
1400 aux_cache_file = chroot_canon (opt_chroot, aux_cache_file);
1401
1402 if (! opt_ignore_aux_cache && aux_cache_file)
1403 load_aux_cache (aux_cache_file);
1404 else
1405 init_aux_cache ();
1406
1407 search_dirs ();
1408
1409 if (opt_build_cache)
1410 {
1411 save_cache (cache_file);
1412 if (aux_cache_file)
1413 save_aux_cache (aux_cache_file);
1414 }
1415
1416 return 0;
1417}
1418