1 /* Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
3 Contributed by Andreas Jaeger <aj@suse.de>, 1999.
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
10 The GNU C Library 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 GNU
13 Lesser General Public License for more details.
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, write to the Free
17 Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
29 #include <stdio_ext.h>
33 #include <sys/fcntl.h>
36 #include <sys/types.h>
41 #include "dl-procinfo.h"
44 # define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
47 /* Get libc version number. */
50 #define PACKAGE _libc_intl_domainname
58 {"libc4", FLAG_LIBC4
},
59 {"libc5", FLAG_ELF_LIBC5
},
60 {"libc6", FLAG_ELF_LIBC6
},
61 {"glibc2", FLAG_ELF_LIBC6
}
65 /* List of directories to handle. */
72 struct dir_entry
*next
;
75 /* The list is unsorted, contains no duplicates. Entries are added at
77 static struct dir_entry
*dir_entries
;
79 /* Flags for different options. */
81 static int opt_print_cache
;
86 /* Format to support. */
87 /* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
91 static int opt_build_cache
= 1;
94 static int opt_link
= 1;
96 /* Only process directories specified on the command line. */
97 static int opt_only_cline
;
99 /* Path to root for chroot. */
100 static char *opt_chroot
;
102 /* Manually link given shared libraries. */
103 static int opt_manual_link
;
105 /* Cache file to use. */
106 static char *cache_file
;
108 /* Configuration file. */
109 static const char *config_file
;
111 /* Mask to use for important hardware capabilities. */
112 static unsigned long int hwcap_mask
= HWCAP_IMPORTANT
;
114 /* Name and version of program. */
115 static void print_version (FILE *stream
, struct argp_state
*state
);
116 void (*argp_program_version_hook
) (FILE *, struct argp_state
*)
119 /* Definitions of arguments for argp functions. */
120 static const struct argp_option options
[] =
122 { "print-cache", 'p', NULL
, 0, N_("Print cache"), 0},
123 { "verbose", 'v', NULL
, 0, N_("Generate verbose messages"), 0},
124 { NULL
, 'N', NULL
, 0, N_("Don't build cache"), 0},
125 { NULL
, 'X', NULL
, 0, N_("Don't generate links"), 0},
126 { NULL
, 'r', "ROOT", 0, N_("Change to and use ROOT as root directory"), 0},
127 { NULL
, 'C', "CACHE", 0, N_("Use CACHE as cache file"), 0},
128 { NULL
, 'f', "CONF", 0, N_("Use CONF as configuration file"), 0},
129 { NULL
, 'n', NULL
, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
130 { NULL
, 'l', NULL
, 0, N_("Manually link individual libraries."), 0},
131 { "format", 'c', "FORMAT", 0, N_("Format to use: new, old or compat (default)"), 0},
132 { NULL
, 0, NULL
, 0, NULL
, 0 }
135 /* Short description of program. */
136 static const char doc
[] = N_("Configure Dynamic Linker Run Time Bindings.");
138 /* Prototype for option handler. */
139 static error_t
parse_opt (int key
, char *arg
, struct argp_state
*state
);
141 /* Data structure to communicate with argp functions. */
142 static struct argp argp
=
144 options
, parse_opt
, NULL
, doc
, NULL
, NULL
, NULL
147 /* Check if string corresponds to an important hardware capability or
150 is_hwcap_platform (const char *name
)
152 int hwcap_idx
= _dl_string_hwcap (name
);
154 if (hwcap_idx
!= -1 && ((1 << hwcap_idx
) & hwcap_mask
))
157 hwcap_idx
= _dl_string_platform (name
);
162 if (strcmp (name
, "tls") == 0)
169 /* Get hwcap (including platform) encoding of path. */
171 path_hwcap (const char *path
)
173 char *str
= xstrdup (path
);
184 /* Search pathname from the end and check for hwcap strings. */
187 ptr
= strrchr (str
, '/');
192 h
= _dl_string_hwcap (ptr
+ 1);
194 if (h
== (uint64_t) -1)
196 h
= _dl_string_platform (ptr
+ 1);
197 if (h
== (uint64_t) -1)
200 if (strcmp (ptr
+ 1, "tls") == 0)
209 /* Search the next part of the path. */
217 /* Handle program arguments. */
219 parse_opt (int key
, char *arg
, struct argp_state
*state
)
252 if (strcmp (arg
, "old") == 0)
254 else if (strcmp (arg
, "compat") == 0)
256 else if (strcmp (arg
, "new") == 0)
260 return ARGP_ERR_UNKNOWN
;
266 /* Print the version information. */
268 print_version (FILE *stream
, struct argp_state
*state
)
270 fprintf (stream
, "ldconfig (GNU %s) %s\n", PACKAGE
, VERSION
);
271 fprintf (stream
, gettext ("\
272 Copyright (C) %s Free Software Foundation, Inc.\n\
273 This is free software; see the source for copying conditions. There is NO\n\
274 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
276 fprintf (stream
, gettext ("Written by %s.\n"),
280 /* Add a single directory entry. */
282 add_single_dir (struct dir_entry
*entry
, int verbose
)
284 struct dir_entry
*ptr
, *prev
;
290 /* Check for duplicates. */
291 if (ptr
->ino
== entry
->ino
&& ptr
->dev
== entry
->dev
)
293 if (opt_verbose
&& verbose
)
294 error (0, 0, _("Path `%s' given more than once"), entry
->path
);
295 /* Use the newer information. */
296 ptr
->flag
= entry
->flag
;
304 /* Is this the first entry? */
305 if (ptr
== NULL
&& dir_entries
== NULL
)
307 else if (ptr
== NULL
)
311 /* Add one directory to the list of directories to process. */
313 add_dir (const char *line
)
316 struct dir_entry
*entry
;
318 struct stat64 stat_buf
;
320 entry
= xmalloc (sizeof (struct dir_entry
));
323 /* Search for an '=' sign. */
324 entry
->path
= xstrdup (line
);
325 equal_sign
= strchr (entry
->path
, '=');
330 entry
->flag
= FLAG_ANY
;
331 for (i
= 0; i
< sizeof (lib_types
) / sizeof (lib_types
[0]); ++i
)
332 if (strcmp (equal_sign
, lib_types
[i
].name
) == 0)
334 entry
->flag
= lib_types
[i
].flag
;
337 if (entry
->flag
== FLAG_ANY
)
338 error (0, 0, _("%s is not a known library type"), equal_sign
);
342 entry
->flag
= FLAG_ANY
;
345 /* Canonify path: for now only remove trailing slashes. */
346 i
= strlen (entry
->path
) - 1;
347 while (entry
->path
[i
] == '/' && i
> 0)
349 entry
->path
[i
] = '\0';
353 if (stat64 (entry
->path
, &stat_buf
))
356 error (0, errno
, _("Can't stat %s"), entry
->path
);
362 entry
->ino
= stat_buf
.st_ino
;
363 entry
->dev
= stat_buf
.st_dev
;
365 add_single_dir (entry
, 1);
370 chroot_stat (const char *real_path
, const char *path
, struct stat64
*st
)
376 return stat64 (real_path
, st
);
378 ret
= lstat64 (real_path
, st
);
379 if (ret
|| !S_ISLNK (st
->st_mode
))
382 canon_path
= chroot_canon (opt_chroot
, path
);
383 if (canon_path
== NULL
)
386 ret
= stat64 (canon_path
, st
);
391 /* Create a symbolic link from soname to libname in directory path. */
393 create_links (const char *real_path
, const char *path
, const char *libname
,
396 char *full_libname
, *full_soname
;
397 char *real_full_libname
, *real_full_soname
;
398 struct stat64 stat_lib
, stat_so
, lstat_so
;
401 /* XXX: The logics in this function should be simplified. */
403 /* Get complete path. */
404 full_libname
= alloca (strlen (path
) + strlen (libname
) + 2);
405 full_soname
= alloca (strlen (path
) + strlen (soname
) + 2);
406 sprintf (full_libname
, "%s/%s", path
, libname
);
407 sprintf (full_soname
, "%s/%s", path
, soname
);
410 real_full_libname
= alloca (strlen (real_path
) + strlen (libname
) + 2);
411 real_full_soname
= alloca (strlen (real_path
) + strlen (soname
) + 2);
412 sprintf (real_full_libname
, "%s/%s", real_path
, libname
);
413 sprintf (real_full_soname
, "%s/%s", real_path
, soname
);
417 real_full_libname
= full_libname
;
418 real_full_soname
= full_soname
;
421 /* Does soname already exist and point to the right library? */
422 if (chroot_stat (real_full_soname
, full_soname
, &stat_so
) == 0)
424 if (chroot_stat (real_full_libname
, full_libname
, &stat_lib
))
426 error (0, 0, _("Can't stat %s\n"), full_libname
);
429 if (stat_lib
.st_dev
== stat_so
.st_dev
430 && stat_lib
.st_ino
== stat_so
.st_ino
)
431 /* Link is already correct. */
433 else if (lstat64 (full_soname
, &lstat_so
) == 0
434 && !S_ISLNK (lstat_so
.st_mode
))
436 error (0, 0, _("%s is not a symbolic link\n"), full_soname
);
441 else if (lstat64 (real_full_soname
, &lstat_so
) != 0
442 || !S_ISLNK (lstat_so
.st_mode
))
443 /* Unless it is a stale symlink, there is no need to remove. */
447 printf ("\t%s -> %s", soname
, libname
);
449 if (do_link
&& opt_link
)
451 /* Remove old link. */
453 if (unlink (real_full_soname
))
455 error (0, 0, _("Can't unlink %s"), full_soname
);
458 /* Create symbolic link. */
459 if (do_link
&& symlink (libname
, real_full_soname
))
461 error (0, 0, _("Can't link %s to %s"), full_soname
, libname
);
467 fputs (_(" (changed)\n"), stdout
);
469 fputs (_(" (SKIPPED)\n"), stdout
);
472 else if (opt_verbose
)
473 fputs ("\n", stdout
);
476 /* Manually link the given library. */
478 manual_link (char *library
)
485 struct stat64 stat_buf
;
487 unsigned int osversion
;
489 /* Prepare arguments for create_links call. Split library name in
490 directory and filename first. Since path is allocated, we've got
491 to be careful to free at the end. */
492 path
= xstrdup (library
);
493 libname
= strrchr (path
, '/');
497 /* Successfully split names. Check if path is just "/" to avoid
501 libname
= library
+ 1;
502 path
= xrealloc (path
, 2);
513 /* There's no path, construct one. */
515 path
= xrealloc (path
, 2);
521 real_path
= chroot_canon (opt_chroot
, path
);
522 if (real_path
== NULL
)
524 error (0, errno
, _("Can't find %s"), path
);
528 real_library
= alloca (strlen (real_path
) + strlen (libname
) + 2);
529 sprintf (real_library
, "%s/%s", real_path
, libname
);
534 real_library
= library
;
537 /* Do some sanity checks first. */
538 if (lstat64 (real_library
, &stat_buf
))
540 error (0, errno
, _("Can't lstat %s"), library
);
544 /* We don't want links here! */
545 else if (!S_ISREG (stat_buf
.st_mode
))
547 error (0, 0, _("Ignored file %s since it is not a regular file."),
552 if (process_file (real_library
, library
, libname
, &flag
, &osversion
,
555 error (0, 0, _("No link created since soname could not be found for %s"),
560 create_links (real_path
, path
, libname
, soname
);
566 /* Read a whole directory and search for libraries.
567 The purpose is two-fold:
568 - search for libraries which will be added to the cache
569 - create symbolic links to the soname for each library
571 This has to be done separatly for each directory.
573 To keep track of which libraries to add to the cache and which
574 links to create, we save a list of all libraries.
576 The algorithm is basically:
577 for all libraries in the directory do
578 get soname of library
579 if soname is already in list
580 if new library is newer, replace entry
581 otherwise ignore this library
582 otherwise add library to list
584 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
585 exist and both have the same soname, e.g. libxy.so, a symbolic link
586 is created from libxy.so.1.2 (the newer one) to libxy.so.
587 libxy.so.1.2 and libxy.so are added to the cache - but not
590 /* Information for one library. */
597 unsigned int osversion
;
598 struct dlib_entry
*next
;
603 search_dir (const struct dir_entry
*entry
)
606 struct dirent64
*direntry
;
607 char *file_name
, *dir_name
, *real_file_name
, *real_name
;
608 int file_name_len
, real_file_name_len
, len
;
610 struct dlib_entry
*dlibs
;
611 struct dlib_entry
*dlib_ptr
;
612 struct stat64 lstat_buf
, stat_buf
;
614 uint64_t hwcap
= path_hwcap (entry
->path
);
615 unsigned int osversion
;
617 file_name_len
= PATH_MAX
;
618 file_name
= alloca (file_name_len
);
625 printf ("%s: (hwcap: 0x%" PRIx64
")\n", entry
->path
, hwcap
);
627 printf ("%s:\n", entry
->path
);
632 dir_name
= chroot_canon (opt_chroot
, entry
->path
);
633 real_file_name_len
= PATH_MAX
;
634 real_file_name
= alloca (real_file_name_len
);
638 dir_name
= entry
->path
;
639 real_file_name_len
= 0;
640 real_file_name
= file_name
;
643 if (dir_name
== NULL
|| (dir
= opendir (dir_name
)) == NULL
)
646 error (0, errno
, _("Can't open directory %s"), entry
->path
);
647 if (opt_chroot
&& dir_name
)
652 while ((direntry
= readdir64 (dir
)) != NULL
)
655 #ifdef _DIRENT_HAVE_D_TYPE
656 /* We only look at links and regular files. */
657 if (direntry
->d_type
!= DT_UNKNOWN
658 && direntry
->d_type
!= DT_LNK
659 && direntry
->d_type
!= DT_REG
660 && direntry
->d_type
!= DT_DIR
)
662 #endif /* _DIRENT_HAVE_D_TYPE */
663 /* Does this file look like a shared library or is it a hwcap
664 subdirectory? The dynamic linker is also considered as
666 if (((strncmp (direntry
->d_name
, "lib", 3) != 0
667 && strncmp (direntry
->d_name
, "ld-", 3) != 0)
668 || strstr (direntry
->d_name
, ".so") == NULL
)
670 #ifdef _DIRENT_HAVE_D_TYPE
671 direntry
->d_type
== DT_REG
||
673 !is_hwcap_platform (direntry
->d_name
)))
675 len
= strlen (entry
->path
) + strlen (direntry
->d_name
);
676 if (len
> file_name_len
)
678 file_name_len
= len
+ 1;
679 file_name
= alloca (file_name_len
);
681 real_file_name
= file_name
;
683 sprintf (file_name
, "%s/%s", entry
->path
, direntry
->d_name
);
686 len
= strlen (dir_name
) + strlen (direntry
->d_name
);
687 if (len
> real_file_name_len
)
689 real_file_name_len
= len
+ 1;
690 real_file_name
= alloca (real_file_name_len
);
692 sprintf (real_file_name
, "%s/%s", dir_name
, direntry
->d_name
);
694 #ifdef _DIRENT_HAVE_D_TYPE
695 if (direntry
->d_type
!= DT_UNKNOWN
)
696 lstat_buf
.st_mode
= DTTOIF (direntry
->d_type
);
699 if (__builtin_expect (lstat64 (real_file_name
, &lstat_buf
), 0))
701 error (0, errno
, _("Cannot lstat %s"), file_name
);
705 is_link
= S_ISLNK (lstat_buf
.st_mode
);
708 /* In case of symlink, we check if the symlink refers to
710 if (__builtin_expect (stat64 (real_file_name
, &stat_buf
), 0))
713 error (0, errno
, _("Cannot stat %s"), file_name
);
715 /* Remove stale symlinks. */
716 if (strstr (direntry
->d_name
, ".so."))
717 unlink (real_file_name
);
720 is_dir
= S_ISDIR (stat_buf
.st_mode
);
723 is_dir
= S_ISDIR (lstat_buf
.st_mode
);
725 if (is_dir
&& is_hwcap_platform (direntry
->d_name
))
727 /* Handle subdirectory later. */
728 struct dir_entry
*new_entry
;
730 new_entry
= xmalloc (sizeof (struct dir_entry
));
731 new_entry
->path
= xstrdup (file_name
);
732 new_entry
->flag
= entry
->flag
;
733 new_entry
->next
= NULL
;
736 new_entry
->ino
= stat_buf
.st_ino
;
737 new_entry
->dev
= stat_buf
.st_dev
;
741 #ifdef _DIRENT_HAVE_D_TYPE
742 /* We have filled in lstat only #ifndef
743 _DIRENT_HAVE_D_TYPE. Fill it in if needed. */
744 if (direntry
->d_type
!= DT_UNKNOWN
745 && __builtin_expect (lstat64 (real_file_name
, &lstat_buf
),
748 error (0, errno
, _("Cannot lstat %s"), file_name
);
749 free (new_entry
->path
);
755 new_entry
->ino
= lstat_buf
.st_ino
;
756 new_entry
->dev
= lstat_buf
.st_dev
;
758 add_single_dir (new_entry
, 0);
761 else if (!S_ISREG (lstat_buf
.st_mode
) && !is_link
)
764 if (opt_chroot
&& is_link
)
766 real_name
= chroot_canon (opt_chroot
, file_name
);
767 if (real_name
== NULL
)
769 if (strstr (file_name
, ".so") == NULL
)
770 error (0, 0, _("Input file %s not found.\n"), file_name
);
775 real_name
= real_file_name
;
777 if (process_file (real_name
, file_name
, direntry
->d_name
, &flag
,
778 &osversion
, &soname
, is_link
))
780 if (real_name
!= real_file_name
)
785 if (real_name
!= real_file_name
)
788 /* Links will just point to itself. */
792 soname
= xstrdup (direntry
->d_name
);
796 && (entry
->flag
== FLAG_ELF_LIBC5
797 || entry
->flag
== FLAG_ELF_LIBC6
))
799 /* Some sanity checks to print warnings. */
802 if (flag
== FLAG_ELF_LIBC5
&& entry
->flag
!= FLAG_ELF_LIBC5
803 && entry
->flag
!= FLAG_ANY
)
804 error (0, 0, _("libc5 library %s in wrong directory"), file_name
);
805 if (flag
== FLAG_ELF_LIBC6
&& entry
->flag
!= FLAG_ELF_LIBC6
806 && entry
->flag
!= FLAG_ANY
)
807 error (0, 0, _("libc6 library %s in wrong directory"), file_name
);
808 if (flag
== FLAG_LIBC4
&& entry
->flag
!= FLAG_LIBC4
809 && entry
->flag
!= FLAG_ANY
)
810 error (0, 0, _("libc4 library %s in wrong directory"), file_name
);
813 /* Add library to list. */
814 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
816 /* Is soname already in list? */
817 if (strcmp (dlib_ptr
->soname
, soname
) == 0)
819 /* Prefer a file to a link, otherwise check which one
821 if ((!is_link
&& dlib_ptr
->is_link
)
822 || (is_link
== dlib_ptr
->is_link
823 && _dl_cache_libcmp (dlib_ptr
->name
, direntry
->d_name
) < 0))
825 /* It's newer - add it. */
826 /* Flag should be the same - sanity check. */
827 if (dlib_ptr
->flag
!= flag
)
829 if (dlib_ptr
->flag
== FLAG_ELF
830 && (flag
== FLAG_ELF_LIBC5
|| flag
== FLAG_ELF_LIBC6
))
831 dlib_ptr
->flag
= flag
;
832 else if ((dlib_ptr
->flag
== FLAG_ELF_LIBC5
833 || dlib_ptr
->flag
== FLAG_ELF_LIBC6
)
835 dlib_ptr
->flag
= flag
;
837 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
838 dlib_ptr
->name
, direntry
->d_name
, entry
->path
);
840 free (dlib_ptr
->name
);
841 dlib_ptr
->osversion
= osversion
;
842 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
843 dlib_ptr
->is_link
= is_link
;
845 /* Don't add this library, abort loop. */
846 /* Also free soname, since it's dynamically allocated. */
851 /* Add the library if it's not already in. */
852 if (dlib_ptr
== NULL
)
854 dlib_ptr
= (struct dlib_entry
*)xmalloc (sizeof (struct dlib_entry
));
855 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
856 dlib_ptr
->flag
= flag
;
857 dlib_ptr
->osversion
= osversion
;
858 dlib_ptr
->soname
= soname
;
859 dlib_ptr
->is_link
= is_link
;
860 /* Add at head of list. */
861 dlib_ptr
->next
= dlibs
;
868 /* Now dlibs contains a list of all libs - add those to the cache
869 and created all symbolic links. */
870 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
872 /* Don't create links to links. */
873 if (dlib_ptr
->is_link
== 0)
874 create_links (dir_name
, entry
->path
, dlib_ptr
->name
,
877 add_to_cache (entry
->path
, dlib_ptr
->soname
, dlib_ptr
->flag
,
878 dlib_ptr
->osversion
, hwcap
);
881 /* Free all resources. */
885 free (dlib_ptr
->soname
);
886 free (dlib_ptr
->name
);
891 if (opt_chroot
&& dir_name
)
895 /* Search through all libraries. */
899 struct dir_entry
*entry
;
901 for (entry
= dir_entries
; entry
!= NULL
; entry
= entry
->next
)
904 /* Free all allocated memory. */
908 dir_entries
= dir_entries
->next
;
915 /* Parse configuration file. */
917 parse_conf (const char *filename
)
926 canon
= chroot_canon (opt_chroot
, filename
);
928 file
= fopen (canon
, "r");
935 file
= fopen (filename
, "r");
940 error (0, errno
, _("Can't open configuration file %s"), canon
);
941 if (canon
!= filename
)
942 free ((char *) canon
);
946 /* No threads use this stream. */
947 __fsetlocking (file
, FSETLOCKING_BYCALLER
);
949 if (canon
!= filename
)
950 free ((char *) canon
);
954 ssize_t n
= getline (&line
, &len
, file
);
958 if (line
[n
- 1] == '\n')
961 /* Because the file format does not know any form of quoting we
962 can search forward for the next '#' character and if found
963 make it terminating the line. */
964 *strchrnul (line
, '#') = '\0';
966 /* If the line is blank it is ignored. */
971 } while (!feof (file
));
973 /* Free buffer and close file. */
978 /* Honour LD_HWCAP_MASK. */
982 char *mask
= getenv ("LD_HWCAP_MASK");
985 hwcap_mask
= strtoul (mask
, NULL
, 0);
990 main (int argc
, char **argv
)
994 /* Parse and process arguments. */
995 argp_parse (&argp
, argc
, argv
, 0, &remaining
, NULL
);
997 /* Remaining arguments are additional libraries if opt_manual_link
999 if (remaining
!= argc
&& !opt_manual_link
)
1002 for (i
= remaining
; i
< argc
; ++i
)
1010 /* Normalize the path a bit, we might need it for printing later. */
1011 char *endp
= strchr (opt_chroot
, '\0');
1012 while (endp
> opt_chroot
&& endp
[-1] == '/')
1015 if (endp
== opt_chroot
)
1020 /* It is faster to use chroot if we can. */
1021 if (!chroot (opt_chroot
))
1024 error (EXIT_FAILURE
, errno
, _("Can't chdir to /"));
1030 if (cache_file
== NULL
)
1032 cache_file
= alloca (strlen (LD_SO_CACHE
) + 1);
1033 strcpy (cache_file
, LD_SO_CACHE
);
1036 if (config_file
== NULL
)
1037 config_file
= LD_SO_CONF
;
1039 if (opt_print_cache
)
1043 char *p
= chroot_canon (opt_chroot
, cache_file
);
1045 error (EXIT_FAILURE
, errno
, _("Can't open cache file %s\n"),
1049 print_cache (cache_file
);
1057 /* Canonicalize the directory name of cache_file, not cache_file,
1058 because we'll rename a temporary cache file to it. */
1059 char *p
= strrchr (cache_file
, '/');
1060 char *canon
= chroot_canon (opt_chroot
,
1061 p
? (*p
= '\0', cache_file
) : "/");
1065 error (EXIT_FAILURE
, errno
,
1066 _("Can't open cache file directory %s\n"),
1067 p
? cache_file
: "/");
1075 cache_file
= alloca (strlen (canon
) + strlen (p
) + 2);
1076 sprintf (cache_file
, "%s/%s", canon
, p
);
1080 if (opt_manual_link
)
1082 /* Link all given libraries manually. */
1085 for (i
= remaining
; i
< argc
; ++i
)
1086 manual_link (argv
[i
]);
1092 if (opt_build_cache
)
1095 if (!opt_only_cline
)
1097 /* Always add the standard search paths. */
1099 if (strcmp (SLIBDIR
, LIBDIR
))
1102 parse_conf (config_file
);
1107 if (opt_build_cache
)
1108 save_cache (cache_file
);