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