1 /* Copyright (C) 1999, 2000, 2001 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
);
164 /* Get hwcap (including platform) encoding of path. */
166 path_hwcap (const char *path
)
168 char *str
= xstrdup (path
);
179 /* Search pathname from the end and check for hwcap strings. */
182 ptr
= strrchr (str
, '/');
187 h
= _dl_string_hwcap (ptr
+ 1);
189 if (h
== (uint64_t) -1)
191 h
= _dl_string_platform (ptr
+ 1);
192 if (h
== (uint64_t) -1)
197 /* Search the next part of the path. */
205 /* Handle program arguments. */
207 parse_opt (int key
, char *arg
, struct argp_state
*state
)
240 if (strcmp (arg
, "old") == 0)
242 else if (strcmp (arg
, "compat") == 0)
244 else if (strcmp (arg
, "new") == 0)
248 return ARGP_ERR_UNKNOWN
;
254 /* Print the version information. */
256 print_version (FILE *stream
, struct argp_state
*state
)
258 fprintf (stream
, "ldconfig (GNU %s) %s\n", PACKAGE
, VERSION
);
259 fprintf (stream
, gettext ("\
260 Copyright (C) %s Free Software Foundation, Inc.\n\
261 This is free software; see the source for copying conditions. There is NO\n\
262 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
264 fprintf (stream
, gettext ("Written by %s.\n"),
268 /* Add a single directory entry. */
270 add_single_dir (struct dir_entry
*entry
, int verbose
)
272 struct dir_entry
*ptr
, *prev
;
278 /* Check for duplicates. */
279 if (ptr
->ino
== entry
->ino
&& ptr
->dev
== entry
->dev
)
281 if (opt_verbose
&& verbose
)
282 error (0, 0, _("Path `%s' given more than once"), entry
->path
);
283 /* Use the newer information. */
284 ptr
->flag
= entry
->flag
;
292 /* Is this the first entry? */
293 if (ptr
== NULL
&& dir_entries
== NULL
)
295 else if (ptr
== NULL
)
299 /* Add one directory to the list of directories to process. */
301 add_dir (const char *line
)
304 struct dir_entry
*entry
;
306 struct stat64 stat_buf
;
308 entry
= xmalloc (sizeof (struct dir_entry
));
311 /* Search for an '=' sign. */
312 entry
->path
= xstrdup (line
);
313 equal_sign
= strchr (entry
->path
, '=');
318 entry
->flag
= FLAG_ANY
;
319 for (i
= 0; i
< sizeof (lib_types
) / sizeof (lib_types
[0]); ++i
)
320 if (strcmp (equal_sign
, lib_types
[i
].name
) == 0)
322 entry
->flag
= lib_types
[i
].flag
;
325 if (entry
->flag
== FLAG_ANY
)
326 error (0, 0, _("%s is not a known library type"), equal_sign
);
330 entry
->flag
= FLAG_ANY
;
333 /* Canonify path: for now only remove trailing slashes. */
334 i
= strlen (entry
->path
) - 1;
335 while (entry
->path
[i
] == '/' && i
> 0)
337 entry
->path
[i
] = '\0';
341 if (stat64 (entry
->path
, &stat_buf
))
344 error (0, errno
, _("Can't stat %s"), entry
->path
);
350 entry
->ino
= stat_buf
.st_ino
;
351 entry
->dev
= stat_buf
.st_dev
;
353 add_single_dir (entry
, 1);
358 chroot_stat (const char *real_path
, const char *path
, struct stat64
*st
)
364 return stat64 (real_path
, st
);
366 ret
= lstat64 (real_path
, st
);
367 if (ret
|| !S_ISLNK (st
->st_mode
))
370 canon_path
= chroot_canon (opt_chroot
, path
);
371 if (canon_path
== NULL
)
374 ret
= stat64 (canon_path
, st
);
379 /* Create a symbolic link from soname to libname in directory path. */
381 create_links (const char *real_path
, const char *path
, const char *libname
,
384 char *full_libname
, *full_soname
;
385 char *real_full_libname
, *real_full_soname
;
386 struct stat64 stat_lib
, stat_so
, lstat_so
;
389 /* XXX: The logics in this function should be simplified. */
391 /* Get complete path. */
392 full_libname
= alloca (strlen (path
) + strlen (libname
) + 2);
393 full_soname
= alloca (strlen (path
) + strlen (soname
) + 2);
394 sprintf (full_libname
, "%s/%s", path
, libname
);
395 sprintf (full_soname
, "%s/%s", path
, soname
);
398 real_full_libname
= alloca (strlen (real_path
) + strlen (libname
) + 2);
399 real_full_soname
= alloca (strlen (real_path
) + strlen (soname
) + 2);
400 sprintf (real_full_libname
, "%s/%s", real_path
, libname
);
401 sprintf (real_full_soname
, "%s/%s", real_path
, soname
);
405 real_full_libname
= full_libname
;
406 real_full_soname
= full_soname
;
409 /* Does soname already exist and point to the right library? */
410 if (chroot_stat (real_full_soname
, full_soname
, &stat_so
) == 0)
412 if (chroot_stat (real_full_libname
, full_libname
, &stat_lib
))
414 error (0, 0, _("Can't stat %s\n"), full_libname
);
417 if (stat_lib
.st_dev
== stat_so
.st_dev
418 && stat_lib
.st_ino
== stat_so
.st_ino
)
419 /* Link is already correct. */
421 else if (lstat64 (full_soname
, &lstat_so
) == 0
422 && !S_ISLNK (lstat_so
.st_mode
))
424 error (0, 0, _("%s is not a symbolic link\n"), full_soname
);
429 else if (lstat64 (real_full_soname
, &lstat_so
) != 0
430 || !S_ISLNK (lstat_so
.st_mode
))
431 /* Unless it is a stale symlink, there is no need to remove. */
435 printf ("\t%s -> %s", soname
, libname
);
437 if (do_link
&& opt_link
)
439 /* Remove old link. */
441 if (unlink (real_full_soname
))
443 error (0, 0, _("Can't unlink %s"), full_soname
);
446 /* Create symbolic link. */
447 if (do_link
&& symlink (libname
, real_full_soname
))
449 error (0, 0, _("Can't link %s to %s"), full_soname
, libname
);
455 fputs (_(" (changed)\n"), stdout
);
457 fputs (_(" (SKIPPED)\n"), stdout
);
460 else if (opt_verbose
)
461 fputs ("\n", stdout
);
464 /* Manually link the given library. */
466 manual_link (char *library
)
473 struct stat64 stat_buf
;
475 unsigned int osversion
;
477 /* Prepare arguments for create_links call. Split library name in
478 directory and filename first. Since path is allocated, we've got
479 to be careful to free at the end. */
480 path
= xstrdup (library
);
481 libname
= strrchr (path
, '/');
485 /* Successfully split names. Check if path is just "/" to avoid
489 libname
= library
+ 1;
490 path
= xrealloc (path
, 2);
501 /* There's no path, construct one. */
503 path
= xrealloc (path
, 2);
509 real_path
= chroot_canon (opt_chroot
, path
);
510 if (real_path
== NULL
)
512 error (0, errno
, _("Can't find %s"), path
);
516 real_library
= alloca (strlen (real_path
) + strlen (libname
) + 2);
517 sprintf (real_library
, "%s/%s", real_path
, libname
);
522 real_library
= library
;
525 /* Do some sanity checks first. */
526 if (lstat64 (real_library
, &stat_buf
))
528 error (0, errno
, _("Can't lstat %s"), library
);
532 /* We don't want links here! */
533 else if (!S_ISREG (stat_buf
.st_mode
))
535 error (0, 0, _("Ignored file %s since it is not a regular file."),
540 if (process_file (real_library
, library
, libname
, &flag
, &osversion
,
543 error (0, 0, _("No link created since soname could not be found for %s"),
548 create_links (real_path
, path
, libname
, soname
);
554 /* Read a whole directory and search for libraries.
555 The purpose is two-fold:
556 - search for libraries which will be added to the cache
557 - create symbolic links to the soname for each library
559 This has to be done separatly for each directory.
561 To keep track of which libraries to add to the cache and which
562 links to create, we save a list of all libraries.
564 The algorithm is basically:
565 for all libraries in the directory do
566 get soname of library
567 if soname is already in list
568 if new library is newer, replace entry
569 otherwise ignore this library
570 otherwise add library to list
572 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
573 exist and both have the same soname, e.g. libxy.so, a symbolic link
574 is created from libxy.so.1.2 (the newer one) to libxy.so.
575 libxy.so.1.2 and libxy.so are added to the cache - but not
578 /* Information for one library. */
585 unsigned int osversion
;
586 struct dlib_entry
*next
;
591 search_dir (const struct dir_entry
*entry
)
594 struct dirent
*direntry
;
595 char *file_name
, *dir_name
, *real_file_name
, *real_name
;
596 int file_name_len
, real_file_name_len
, len
;
598 struct dlib_entry
*dlibs
;
599 struct dlib_entry
*dlib_ptr
;
600 struct stat64 lstat_buf
, stat_buf
;
602 uint64_t hwcap
= path_hwcap (entry
->path
);
603 unsigned int osversion
;
605 file_name_len
= PATH_MAX
;
606 file_name
= alloca (file_name_len
);
613 printf ("%s: (hwcap: 0x%" PRIx64
")\n", entry
->path
, hwcap
);
615 printf ("%s:\n", entry
->path
);
620 dir_name
= chroot_canon (opt_chroot
, entry
->path
);
621 real_file_name_len
= PATH_MAX
;
622 real_file_name
= alloca (real_file_name_len
);
626 dir_name
= entry
->path
;
627 real_file_name_len
= 0;
628 real_file_name
= file_name
;
631 if (dir_name
== NULL
|| (dir
= opendir (dir_name
)) == NULL
)
634 error (0, errno
, _("Can't open directory %s"), entry
->path
);
635 if (opt_chroot
&& dir_name
)
640 while ((direntry
= readdir (dir
)) != NULL
)
643 #ifdef _DIRENT_HAVE_D_TYPE
644 /* We only look at links and regular files. */
645 if (direntry
->d_type
!= DT_UNKNOWN
646 && direntry
->d_type
!= DT_LNK
647 && direntry
->d_type
!= DT_REG
648 && direntry
->d_type
!= DT_DIR
)
650 #endif /* _DIRENT_HAVE_D_TYPE */
651 /* Does this file look like a shared library or is it a hwcap
652 subdirectory? The dynamic linker is also considered as
654 if (((strncmp (direntry
->d_name
, "lib", 3) != 0
655 && strncmp (direntry
->d_name
, "ld-", 3) != 0)
656 || strstr (direntry
->d_name
, ".so") == NULL
)
658 #ifdef _DIRENT_HAVE_D_TYPE
659 direntry
->d_type
== DT_REG
||
661 !is_hwcap_platform (direntry
->d_name
)))
663 len
= strlen (entry
->path
) + strlen (direntry
->d_name
);
664 if (len
> file_name_len
)
666 file_name_len
= len
+ 1;
667 file_name
= alloca (file_name_len
);
669 real_file_name
= file_name
;
671 sprintf (file_name
, "%s/%s", entry
->path
, direntry
->d_name
);
674 len
= strlen (dir_name
) + strlen (direntry
->d_name
);
675 if (len
> real_file_name_len
)
677 real_file_name_len
= len
+ 1;
678 real_file_name
= alloca (real_file_name_len
);
680 sprintf (real_file_name
, "%s/%s", dir_name
, direntry
->d_name
);
682 #ifdef _DIRENT_HAVE_D_TYPE
683 if (direntry
->d_type
!= DT_UNKNOWN
)
684 lstat_buf
.st_mode
= DTTOIF (direntry
->d_type
);
687 if (__builtin_expect (lstat64 (real_file_name
, &lstat_buf
), 0))
689 error (0, errno
, _("Cannot lstat %s"), file_name
);
693 is_link
= S_ISLNK (lstat_buf
.st_mode
);
696 /* In case of symlink, we check if the symlink refers to
698 if (__builtin_expect (stat64 (real_file_name
, &stat_buf
), 0))
701 error (0, errno
, _("Cannot stat %s"), file_name
);
704 is_dir
= S_ISDIR (stat_buf
.st_mode
);
707 is_dir
= S_ISDIR (lstat_buf
.st_mode
);
709 if (is_dir
&& is_hwcap_platform (direntry
->d_name
))
711 /* Handle subdirectory later. */
712 struct dir_entry
*new_entry
;
714 new_entry
= xmalloc (sizeof (struct dir_entry
));
715 new_entry
->path
= xstrdup (file_name
);
716 new_entry
->flag
= entry
->flag
;
717 new_entry
->next
= NULL
;
720 new_entry
->ino
= stat_buf
.st_ino
;
721 new_entry
->dev
= stat_buf
.st_dev
;
725 #ifdef _DIRENT_HAVE_D_TYPE
726 /* We have filled in lstat only #ifndef
727 _DIRENT_HAVE_D_TYPE. Fill it in if needed. */
728 if (direntry
->d_type
!= DT_UNKNOWN
729 && __builtin_expect (lstat64 (real_file_name
, &lstat_buf
),
732 error (0, errno
, _("Cannot lstat %s"), file_name
);
733 free (new_entry
->path
);
739 new_entry
->ino
= lstat_buf
.st_ino
;
740 new_entry
->dev
= lstat_buf
.st_dev
;
742 add_single_dir (new_entry
, 0);
745 else if (!S_ISREG (lstat_buf
.st_mode
) && !is_link
)
748 if (opt_chroot
&& is_link
)
750 real_name
= chroot_canon (opt_chroot
, file_name
);
751 if (real_name
== NULL
)
753 if (strstr (file_name
, ".so") == NULL
)
754 error (0, 0, _("Input file %s not found.\n"), file_name
);
759 real_name
= real_file_name
;
761 if (process_file (real_name
, file_name
, direntry
->d_name
, &flag
,
762 &osversion
, &soname
, is_link
))
764 if (real_name
!= real_file_name
)
769 if (real_name
!= real_file_name
)
772 /* Links will just point to itself. */
776 soname
= xstrdup (direntry
->d_name
);
780 && (entry
->flag
== FLAG_ELF_LIBC5
781 || entry
->flag
== FLAG_ELF_LIBC6
))
783 /* Some sanity checks to print warnings. */
786 if (flag
== FLAG_ELF_LIBC5
&& entry
->flag
!= FLAG_ELF_LIBC5
787 && entry
->flag
!= FLAG_ANY
)
788 error (0, 0, _("libc5 library %s in wrong directory"), file_name
);
789 if (flag
== FLAG_ELF_LIBC6
&& entry
->flag
!= FLAG_ELF_LIBC6
790 && entry
->flag
!= FLAG_ANY
)
791 error (0, 0, _("libc6 library %s in wrong directory"), file_name
);
792 if (flag
== FLAG_LIBC4
&& entry
->flag
!= FLAG_LIBC4
793 && entry
->flag
!= FLAG_ANY
)
794 error (0, 0, _("libc4 library %s in wrong directory"), file_name
);
797 /* Add library to list. */
798 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
800 /* Is soname already in list? */
801 if (strcmp (dlib_ptr
->soname
, soname
) == 0)
803 /* Prefer a file to a link, otherwise check which one
805 if ((!is_link
&& dlib_ptr
->is_link
)
806 || (is_link
== dlib_ptr
->is_link
807 && _dl_cache_libcmp (dlib_ptr
->name
, direntry
->d_name
) < 0))
809 /* It's newer - add it. */
810 /* Flag should be the same - sanity check. */
811 if (dlib_ptr
->flag
!= flag
)
813 if (dlib_ptr
->flag
== FLAG_ELF
814 && (flag
== FLAG_ELF_LIBC5
|| flag
== FLAG_ELF_LIBC6
))
815 dlib_ptr
->flag
= flag
;
816 else if ((dlib_ptr
->flag
== FLAG_ELF_LIBC5
817 || dlib_ptr
->flag
== FLAG_ELF_LIBC6
)
819 dlib_ptr
->flag
= flag
;
821 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
822 dlib_ptr
->name
, direntry
->d_name
, entry
->path
);
824 free (dlib_ptr
->name
);
825 dlib_ptr
->osversion
= osversion
;
826 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
827 dlib_ptr
->is_link
= is_link
;
829 /* Don't add this library, abort loop. */
830 /* Also free soname, since it's dynamically allocated. */
835 /* Add the library if it's not already in. */
836 if (dlib_ptr
== NULL
)
838 dlib_ptr
= (struct dlib_entry
*)xmalloc (sizeof (struct dlib_entry
));
839 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
840 dlib_ptr
->flag
= flag
;
841 dlib_ptr
->osversion
= osversion
;
842 dlib_ptr
->soname
= soname
;
843 dlib_ptr
->is_link
= is_link
;
844 /* Add at head of list. */
845 dlib_ptr
->next
= dlibs
;
852 /* Now dlibs contains a list of all libs - add those to the cache
853 and created all symbolic links. */
854 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
856 /* Don't create links to links. */
857 if (dlib_ptr
->is_link
== 0)
858 create_links (dir_name
, entry
->path
, dlib_ptr
->name
,
861 add_to_cache (entry
->path
, dlib_ptr
->soname
, dlib_ptr
->flag
,
862 dlib_ptr
->osversion
, hwcap
);
865 /* Free all resources. */
869 free (dlib_ptr
->soname
);
870 free (dlib_ptr
->name
);
875 if (opt_chroot
&& dir_name
)
879 /* Search through all libraries. */
883 struct dir_entry
*entry
;
885 for (entry
= dir_entries
; entry
!= NULL
; entry
= entry
->next
)
888 /* Free all allocated memory. */
892 dir_entries
= dir_entries
->next
;
899 /* Parse configuration file. */
901 parse_conf (const char *filename
)
910 canon
= chroot_canon (opt_chroot
, filename
);
912 file
= fopen (canon
, "r");
919 file
= fopen (filename
, "r");
924 error (0, errno
, _("Can't open configuration file %s"), canon
);
925 if (canon
!= filename
)
926 free ((char *) canon
);
930 /* No threads use this stream. */
931 __fsetlocking (file
, FSETLOCKING_BYCALLER
);
933 if (canon
!= filename
)
934 free ((char *) canon
);
938 ssize_t n
= getline (&line
, &len
, file
);
942 if (line
[n
- 1] == '\n')
945 /* Because the file format does not know any form of quoting we
946 can search forward for the next '#' character and if found
947 make it terminating the line. */
948 *strchrnul (line
, '#') = '\0';
950 /* If the line is blank it is ignored. */
955 } while (!feof (file
));
957 /* Free buffer and close file. */
962 /* Honour LD_HWCAP_MASK. */
966 char *mask
= getenv ("LD_HWCAP_MASK");
969 hwcap_mask
= strtoul (mask
, NULL
, 0);
974 main (int argc
, char **argv
)
978 /* Parse and process arguments. */
979 argp_parse (&argp
, argc
, argv
, 0, &remaining
, NULL
);
981 /* Remaining arguments are additional libraries if opt_manual_link
983 if (remaining
!= argc
&& !opt_manual_link
)
986 for (i
= remaining
; i
< argc
; ++i
)
994 /* Normalize the path a bit, we might need it for printing later. */
995 char *endp
= strchr (opt_chroot
, '\0');
996 while (endp
> opt_chroot
&& endp
[-1] == '/')
999 if (endp
== opt_chroot
)
1004 /* It is faster to use chroot if we can. */
1005 if (!chroot (opt_chroot
))
1008 error (EXIT_FAILURE
, errno
, _("Can't chdir to /"));
1014 if (cache_file
== NULL
)
1016 cache_file
= alloca (strlen (LD_SO_CACHE
) + 1);
1017 strcpy (cache_file
, LD_SO_CACHE
);
1020 if (config_file
== NULL
)
1021 config_file
= LD_SO_CONF
;
1023 if (opt_print_cache
)
1027 char *p
= chroot_canon (opt_chroot
, cache_file
);
1029 error (EXIT_FAILURE
, errno
, _("Can't open cache file %s\n"),
1033 print_cache (cache_file
);
1041 /* Canonicalize the directory name of cache_file, not cache_file,
1042 because we'll rename a temporary cache file to it. */
1043 char *p
= strrchr (cache_file
, '/');
1044 char *canon
= chroot_canon (opt_chroot
,
1045 p
? (*p
= '\0', cache_file
) : "/");
1049 error (EXIT_FAILURE
, errno
,
1050 _("Can't open cache file directory %s\n"),
1051 p
? cache_file
: "/");
1059 cache_file
= alloca (strlen (canon
) + strlen (p
) + 2);
1060 sprintf (cache_file
, "%s/%s", canon
, p
);
1064 if (opt_manual_link
)
1066 /* Link all given libraries manually. */
1069 for (i
= remaining
; i
< argc
; ++i
)
1070 manual_link (argv
[i
]);
1076 if (opt_build_cache
)
1079 if (!opt_only_cline
)
1081 /* Always add the standard search paths. */
1083 if (strcmp (SLIBDIR
, LIBDIR
))
1086 parse_conf (config_file
);
1091 if (opt_build_cache
)
1092 save_cache (cache_file
);