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 leading and trailing
346 whitespace and the trailing slashes slashes. */
347 i
= strlen (entry
->path
) - 1;
349 while (isspace (entry
->path
[i
]) && i
> 0)
350 entry
->path
[i
--] = '\0';
352 while (entry
->path
[i
] == '/' && i
> 0)
353 entry
->path
[i
--] = '\0';
355 if (stat64 (entry
->path
, &stat_buf
))
358 error (0, errno
, _("Can't stat %s"), entry
->path
);
364 entry
->ino
= stat_buf
.st_ino
;
365 entry
->dev
= stat_buf
.st_dev
;
367 add_single_dir (entry
, 1);
372 chroot_stat (const char *real_path
, const char *path
, struct stat64
*st
)
378 return stat64 (real_path
, st
);
380 ret
= lstat64 (real_path
, st
);
381 if (ret
|| !S_ISLNK (st
->st_mode
))
384 canon_path
= chroot_canon (opt_chroot
, path
);
385 if (canon_path
== NULL
)
388 ret
= stat64 (canon_path
, st
);
393 /* Create a symbolic link from soname to libname in directory path. */
395 create_links (const char *real_path
, const char *path
, const char *libname
,
398 char *full_libname
, *full_soname
;
399 char *real_full_libname
, *real_full_soname
;
400 struct stat64 stat_lib
, stat_so
, lstat_so
;
403 /* XXX: The logics in this function should be simplified. */
405 /* Get complete path. */
406 full_libname
= alloca (strlen (path
) + strlen (libname
) + 2);
407 full_soname
= alloca (strlen (path
) + strlen (soname
) + 2);
408 sprintf (full_libname
, "%s/%s", path
, libname
);
409 sprintf (full_soname
, "%s/%s", path
, soname
);
412 real_full_libname
= alloca (strlen (real_path
) + strlen (libname
) + 2);
413 real_full_soname
= alloca (strlen (real_path
) + strlen (soname
) + 2);
414 sprintf (real_full_libname
, "%s/%s", real_path
, libname
);
415 sprintf (real_full_soname
, "%s/%s", real_path
, soname
);
419 real_full_libname
= full_libname
;
420 real_full_soname
= full_soname
;
423 /* Does soname already exist and point to the right library? */
424 if (chroot_stat (real_full_soname
, full_soname
, &stat_so
) == 0)
426 if (chroot_stat (real_full_libname
, full_libname
, &stat_lib
))
428 error (0, 0, _("Can't stat %s\n"), full_libname
);
431 if (stat_lib
.st_dev
== stat_so
.st_dev
432 && stat_lib
.st_ino
== stat_so
.st_ino
)
433 /* Link is already correct. */
435 else if (lstat64 (full_soname
, &lstat_so
) == 0
436 && !S_ISLNK (lstat_so
.st_mode
))
438 error (0, 0, _("%s is not a symbolic link\n"), full_soname
);
443 else if (lstat64 (real_full_soname
, &lstat_so
) != 0
444 || !S_ISLNK (lstat_so
.st_mode
))
445 /* Unless it is a stale symlink, there is no need to remove. */
449 printf ("\t%s -> %s", soname
, libname
);
451 if (do_link
&& opt_link
)
453 /* Remove old link. */
455 if (unlink (real_full_soname
))
457 error (0, 0, _("Can't unlink %s"), full_soname
);
460 /* Create symbolic link. */
461 if (do_link
&& symlink (libname
, real_full_soname
))
463 error (0, 0, _("Can't link %s to %s"), full_soname
, libname
);
469 fputs (_(" (changed)\n"), stdout
);
471 fputs (_(" (SKIPPED)\n"), stdout
);
474 else if (opt_verbose
)
475 fputs ("\n", stdout
);
478 /* Manually link the given library. */
480 manual_link (char *library
)
487 struct stat64 stat_buf
;
489 unsigned int osversion
;
491 /* Prepare arguments for create_links call. Split library name in
492 directory and filename first. Since path is allocated, we've got
493 to be careful to free at the end. */
494 path
= xstrdup (library
);
495 libname
= strrchr (path
, '/');
499 /* Successfully split names. Check if path is just "/" to avoid
503 libname
= library
+ 1;
504 path
= xrealloc (path
, 2);
515 /* There's no path, construct one. */
517 path
= xrealloc (path
, 2);
523 real_path
= chroot_canon (opt_chroot
, path
);
524 if (real_path
== NULL
)
526 error (0, errno
, _("Can't find %s"), path
);
530 real_library
= alloca (strlen (real_path
) + strlen (libname
) + 2);
531 sprintf (real_library
, "%s/%s", real_path
, libname
);
536 real_library
= library
;
539 /* Do some sanity checks first. */
540 if (lstat64 (real_library
, &stat_buf
))
542 error (0, errno
, _("Can't lstat %s"), library
);
546 /* We don't want links here! */
547 else if (!S_ISREG (stat_buf
.st_mode
))
549 error (0, 0, _("Ignored file %s since it is not a regular file."),
554 if (process_file (real_library
, library
, libname
, &flag
, &osversion
,
557 error (0, 0, _("No link created since soname could not be found for %s"),
562 create_links (real_path
, path
, libname
, soname
);
568 /* Read a whole directory and search for libraries.
569 The purpose is two-fold:
570 - search for libraries which will be added to the cache
571 - create symbolic links to the soname for each library
573 This has to be done separatly for each directory.
575 To keep track of which libraries to add to the cache and which
576 links to create, we save a list of all libraries.
578 The algorithm is basically:
579 for all libraries in the directory do
580 get soname of library
581 if soname is already in list
582 if new library is newer, replace entry
583 otherwise ignore this library
584 otherwise add library to list
586 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
587 exist and both have the same soname, e.g. libxy.so, a symbolic link
588 is created from libxy.so.1.2 (the newer one) to libxy.so.
589 libxy.so.1.2 and libxy.so are added to the cache - but not
592 /* Information for one library. */
599 unsigned int osversion
;
600 struct dlib_entry
*next
;
605 search_dir (const struct dir_entry
*entry
)
608 struct dirent64
*direntry
;
609 char *file_name
, *dir_name
, *real_file_name
, *real_name
;
610 int file_name_len
, real_file_name_len
, len
;
612 struct dlib_entry
*dlibs
;
613 struct dlib_entry
*dlib_ptr
;
614 struct stat64 lstat_buf
, stat_buf
;
616 uint64_t hwcap
= path_hwcap (entry
->path
);
617 unsigned int osversion
;
619 file_name_len
= PATH_MAX
;
620 file_name
= alloca (file_name_len
);
627 printf ("%s: (hwcap: 0x%" PRIx64
")\n", entry
->path
, hwcap
);
629 printf ("%s:\n", entry
->path
);
634 dir_name
= chroot_canon (opt_chroot
, entry
->path
);
635 real_file_name_len
= PATH_MAX
;
636 real_file_name
= alloca (real_file_name_len
);
640 dir_name
= entry
->path
;
641 real_file_name_len
= 0;
642 real_file_name
= file_name
;
645 if (dir_name
== NULL
|| (dir
= opendir (dir_name
)) == NULL
)
648 error (0, errno
, _("Can't open directory %s"), entry
->path
);
649 if (opt_chroot
&& dir_name
)
654 while ((direntry
= readdir64 (dir
)) != NULL
)
657 #ifdef _DIRENT_HAVE_D_TYPE
658 /* We only look at links and regular files. */
659 if (direntry
->d_type
!= DT_UNKNOWN
660 && direntry
->d_type
!= DT_LNK
661 && direntry
->d_type
!= DT_REG
662 && direntry
->d_type
!= DT_DIR
)
664 #endif /* _DIRENT_HAVE_D_TYPE */
665 /* Does this file look like a shared library or is it a hwcap
666 subdirectory? The dynamic linker is also considered as
668 if (((strncmp (direntry
->d_name
, "lib", 3) != 0
669 && strncmp (direntry
->d_name
, "ld-", 3) != 0)
670 || strstr (direntry
->d_name
, ".so") == NULL
)
672 #ifdef _DIRENT_HAVE_D_TYPE
673 direntry
->d_type
== DT_REG
||
675 !is_hwcap_platform (direntry
->d_name
)))
677 len
= strlen (entry
->path
) + strlen (direntry
->d_name
);
678 if (len
> file_name_len
)
680 file_name_len
= len
+ 1;
681 file_name
= alloca (file_name_len
);
683 real_file_name
= file_name
;
685 sprintf (file_name
, "%s/%s", entry
->path
, direntry
->d_name
);
688 len
= strlen (dir_name
) + strlen (direntry
->d_name
);
689 if (len
> real_file_name_len
)
691 real_file_name_len
= len
+ 1;
692 real_file_name
= alloca (real_file_name_len
);
694 sprintf (real_file_name
, "%s/%s", dir_name
, direntry
->d_name
);
696 #ifdef _DIRENT_HAVE_D_TYPE
697 if (direntry
->d_type
!= DT_UNKNOWN
)
698 lstat_buf
.st_mode
= DTTOIF (direntry
->d_type
);
701 if (__builtin_expect (lstat64 (real_file_name
, &lstat_buf
), 0))
703 error (0, errno
, _("Cannot lstat %s"), file_name
);
707 is_link
= S_ISLNK (lstat_buf
.st_mode
);
710 /* In case of symlink, we check if the symlink refers to
712 if (__builtin_expect (stat64 (real_file_name
, &stat_buf
), 0))
715 error (0, errno
, _("Cannot stat %s"), file_name
);
717 /* Remove stale symlinks. */
718 if (strstr (direntry
->d_name
, ".so."))
719 unlink (real_file_name
);
722 is_dir
= S_ISDIR (stat_buf
.st_mode
);
725 is_dir
= S_ISDIR (lstat_buf
.st_mode
);
727 if (is_dir
&& is_hwcap_platform (direntry
->d_name
))
729 /* Handle subdirectory later. */
730 struct dir_entry
*new_entry
;
732 new_entry
= xmalloc (sizeof (struct dir_entry
));
733 new_entry
->path
= xstrdup (file_name
);
734 new_entry
->flag
= entry
->flag
;
735 new_entry
->next
= NULL
;
738 new_entry
->ino
= stat_buf
.st_ino
;
739 new_entry
->dev
= stat_buf
.st_dev
;
743 #ifdef _DIRENT_HAVE_D_TYPE
744 /* We have filled in lstat only #ifndef
745 _DIRENT_HAVE_D_TYPE. Fill it in if needed. */
746 if (direntry
->d_type
!= DT_UNKNOWN
747 && __builtin_expect (lstat64 (real_file_name
, &lstat_buf
),
750 error (0, errno
, _("Cannot lstat %s"), file_name
);
751 free (new_entry
->path
);
757 new_entry
->ino
= lstat_buf
.st_ino
;
758 new_entry
->dev
= lstat_buf
.st_dev
;
760 add_single_dir (new_entry
, 0);
763 else if (!S_ISREG (lstat_buf
.st_mode
) && !is_link
)
766 if (opt_chroot
&& is_link
)
768 real_name
= chroot_canon (opt_chroot
, file_name
);
769 if (real_name
== NULL
)
771 if (strstr (file_name
, ".so") == NULL
)
772 error (0, 0, _("Input file %s not found.\n"), file_name
);
777 real_name
= real_file_name
;
779 if (process_file (real_name
, file_name
, direntry
->d_name
, &flag
,
780 &osversion
, &soname
, is_link
))
782 if (real_name
!= real_file_name
)
787 if (real_name
!= real_file_name
)
790 /* Links will just point to itself. */
794 soname
= xstrdup (direntry
->d_name
);
798 && (entry
->flag
== FLAG_ELF_LIBC5
799 || entry
->flag
== FLAG_ELF_LIBC6
))
801 /* Some sanity checks to print warnings. */
804 if (flag
== FLAG_ELF_LIBC5
&& entry
->flag
!= FLAG_ELF_LIBC5
805 && entry
->flag
!= FLAG_ANY
)
806 error (0, 0, _("libc5 library %s in wrong directory"), file_name
);
807 if (flag
== FLAG_ELF_LIBC6
&& entry
->flag
!= FLAG_ELF_LIBC6
808 && entry
->flag
!= FLAG_ANY
)
809 error (0, 0, _("libc6 library %s in wrong directory"), file_name
);
810 if (flag
== FLAG_LIBC4
&& entry
->flag
!= FLAG_LIBC4
811 && entry
->flag
!= FLAG_ANY
)
812 error (0, 0, _("libc4 library %s in wrong directory"), file_name
);
815 /* Add library to list. */
816 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
818 /* Is soname already in list? */
819 if (strcmp (dlib_ptr
->soname
, soname
) == 0)
821 /* Prefer a file to a link, otherwise check which one
823 if ((!is_link
&& dlib_ptr
->is_link
)
824 || (is_link
== dlib_ptr
->is_link
825 && _dl_cache_libcmp (dlib_ptr
->name
, direntry
->d_name
) < 0))
827 /* It's newer - add it. */
828 /* Flag should be the same - sanity check. */
829 if (dlib_ptr
->flag
!= flag
)
831 if (dlib_ptr
->flag
== FLAG_ELF
832 && (flag
== FLAG_ELF_LIBC5
|| flag
== FLAG_ELF_LIBC6
))
833 dlib_ptr
->flag
= flag
;
834 else if ((dlib_ptr
->flag
== FLAG_ELF_LIBC5
835 || dlib_ptr
->flag
== FLAG_ELF_LIBC6
)
837 dlib_ptr
->flag
= flag
;
839 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
840 dlib_ptr
->name
, direntry
->d_name
, entry
->path
);
842 free (dlib_ptr
->name
);
843 dlib_ptr
->osversion
= osversion
;
844 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
845 dlib_ptr
->is_link
= is_link
;
847 /* Don't add this library, abort loop. */
848 /* Also free soname, since it's dynamically allocated. */
853 /* Add the library if it's not already in. */
854 if (dlib_ptr
== NULL
)
856 dlib_ptr
= (struct dlib_entry
*)xmalloc (sizeof (struct dlib_entry
));
857 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
858 dlib_ptr
->flag
= flag
;
859 dlib_ptr
->osversion
= osversion
;
860 dlib_ptr
->soname
= soname
;
861 dlib_ptr
->is_link
= is_link
;
862 /* Add at head of list. */
863 dlib_ptr
->next
= dlibs
;
870 /* Now dlibs contains a list of all libs - add those to the cache
871 and created all symbolic links. */
872 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
874 /* Don't create links to links. */
875 if (dlib_ptr
->is_link
== 0)
876 create_links (dir_name
, entry
->path
, dlib_ptr
->name
,
879 add_to_cache (entry
->path
, dlib_ptr
->soname
, dlib_ptr
->flag
,
880 dlib_ptr
->osversion
, hwcap
);
883 /* Free all resources. */
887 free (dlib_ptr
->soname
);
888 free (dlib_ptr
->name
);
893 if (opt_chroot
&& dir_name
)
897 /* Search through all libraries. */
901 struct dir_entry
*entry
;
903 for (entry
= dir_entries
; entry
!= NULL
; entry
= entry
->next
)
906 /* Free all allocated memory. */
910 dir_entries
= dir_entries
->next
;
917 /* Parse configuration file. */
919 parse_conf (const char *filename
)
928 canon
= chroot_canon (opt_chroot
, filename
);
930 file
= fopen (canon
, "r");
937 file
= fopen (filename
, "r");
942 error (0, errno
, _("Can't open configuration file %s"), canon
);
943 if (canon
!= filename
)
944 free ((char *) canon
);
948 /* No threads use this stream. */
949 __fsetlocking (file
, FSETLOCKING_BYCALLER
);
951 if (canon
!= filename
)
952 free ((char *) canon
);
956 ssize_t n
= getline (&line
, &len
, file
);
960 if (line
[n
- 1] == '\n')
963 /* Because the file format does not know any form of quoting we
964 can search forward for the next '#' character and if found
965 make it terminating the line. */
966 *strchrnul (line
, '#') = '\0';
968 /* Remove leading whitespace. NUL is no whitespace character. */
970 while (isspace (*cp
))
973 /* If the line is blank it is ignored. */
979 while (!feof_unlocked (file
));
981 /* Free buffer and close file. */
986 /* Honour LD_HWCAP_MASK. */
990 char *mask
= getenv ("LD_HWCAP_MASK");
993 hwcap_mask
= strtoul (mask
, NULL
, 0);
998 main (int argc
, char **argv
)
1002 /* Parse and process arguments. */
1003 argp_parse (&argp
, argc
, argv
, 0, &remaining
, NULL
);
1005 /* Remaining arguments are additional libraries if opt_manual_link
1007 if (remaining
!= argc
&& !opt_manual_link
)
1010 for (i
= remaining
; i
< argc
; ++i
)
1018 /* Normalize the path a bit, we might need it for printing later. */
1019 char *endp
= strchr (opt_chroot
, '\0');
1020 while (endp
> opt_chroot
&& endp
[-1] == '/')
1023 if (endp
== opt_chroot
)
1028 /* It is faster to use chroot if we can. */
1029 if (!chroot (opt_chroot
))
1032 error (EXIT_FAILURE
, errno
, _("Can't chdir to /"));
1038 if (cache_file
== NULL
)
1040 cache_file
= alloca (strlen (LD_SO_CACHE
) + 1);
1041 strcpy (cache_file
, LD_SO_CACHE
);
1044 if (config_file
== NULL
)
1045 config_file
= LD_SO_CONF
;
1047 if (opt_print_cache
)
1051 char *p
= chroot_canon (opt_chroot
, cache_file
);
1053 error (EXIT_FAILURE
, errno
, _("Can't open cache file %s\n"),
1057 print_cache (cache_file
);
1065 /* Canonicalize the directory name of cache_file, not cache_file,
1066 because we'll rename a temporary cache file to it. */
1067 char *p
= strrchr (cache_file
, '/');
1068 char *canon
= chroot_canon (opt_chroot
,
1069 p
? (*p
= '\0', cache_file
) : "/");
1073 error (EXIT_FAILURE
, errno
,
1074 _("Can't open cache file directory %s\n"),
1075 p
? cache_file
: "/");
1083 cache_file
= alloca (strlen (canon
) + strlen (p
) + 2);
1084 sprintf (cache_file
, "%s/%s", canon
, p
);
1088 if (opt_manual_link
)
1090 /* Link all given libraries manually. */
1093 for (i
= remaining
; i
< argc
; ++i
)
1094 manual_link (argv
[i
]);
1100 if (opt_build_cache
)
1103 if (!opt_only_cline
)
1105 /* Always add the standard search paths. */
1107 if (strcmp (SLIBDIR
, LIBDIR
))
1110 parse_conf (config_file
);
1115 if (opt_build_cache
)
1116 save_cache (cache_file
);