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