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 Library General Public License as
7 published by the Free Software Foundation; either version 2 of the
8 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 Library General Public License for more details.
15 You should have received a copy of the GNU Library General Public
16 License along with the GNU C Library; see the file COPYING.LIB. If not,
17 write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA. */
32 #include <sys/fcntl.h>
35 #include <sys/types.h>
40 #include "dl-procinfo.h"
43 # define LD_SO_CONF SYSCONFDIR "/ld.so.conf"
46 /* Get libc version number. */
49 #define PACKAGE _libc_intl_domainname
57 {"libc4", FLAG_LIBC4
},
58 {"libc5", FLAG_ELF_LIBC5
},
59 {"libc6", FLAG_ELF_LIBC6
},
60 {"glibc2", FLAG_ELF_LIBC6
}
64 /* List of directories to handle. */
69 struct dir_entry
*next
;
72 /* The list is unsorted, contains no duplicates. Entries are added at
74 static struct dir_entry
*dir_entries
;
76 /* Flags for different options. */
78 static int opt_print_cache
= 0;
83 /* Format to support. */
84 /* 0: only libc5/glibc2; 1: both; 2: only glibc 2.2. */
88 static int opt_build_cache
= 1;
91 static int opt_link
= 1;
93 /* Only process directories specified on the command line. */
94 static int opt_only_cline
= 0;
96 /* Path to root for chroot. */
97 static char *opt_chroot
;
99 /* Manually link given shared libraries. */
100 static int opt_manual_link
= 0;
102 /* Cache file to use. */
103 static char *cache_file
;
105 /* Configuration file. */
106 static const char *config_file
;
108 /* Name and version of program. */
109 static void print_version (FILE *stream
, struct argp_state
*state
);
110 void (*argp_program_version_hook
) (FILE *, struct argp_state
*)
113 /* Definitions of arguments for argp functions. */
114 static const struct argp_option options
[] =
116 { "print-cache", 'p', NULL
, 0, N_("Print cache"), 0},
117 { "verbose", 'v', NULL
, 0, N_("Generate verbose messages"), 0},
118 { NULL
, 'N', NULL
, 0, N_("Don't build cache"), 0},
119 { NULL
, 'X', NULL
, 0, N_("Don't generate links"), 0},
120 { NULL
, 'r', "ROOT", 0, N_("Change to and use ROOT as root directory"), 0},
121 { NULL
, 'C', "CACHE", 0, N_("Use CACHE as cache file"), 0},
122 { NULL
, 'f', "CONF", 0, N_("Use CONF as configuration file"), 0},
123 { NULL
, 'n', NULL
, 0, N_("Only process directories specified on the command line. Don't build cache."), 0},
124 { NULL
, 'l', NULL
, 0, N_("Manually link individual libraries."), 0},
125 { "format", 'c', "FORMAT", 0, N_("Format to use: new, old or compat (default)"), 0},
126 { NULL
, 0, NULL
, 0, NULL
, 0 }
129 /* Short description of program. */
130 static const char doc
[] = N_("Configure Dynamic Linker Run Time Bindings.");
132 /* Prototype for option handler. */
133 static error_t
parse_opt (int key
, char *arg
, struct argp_state
*state
);
135 /* Data structure to communicate with argp functions. */
136 static struct argp argp
=
138 options
, parse_opt
, NULL
, doc
, NULL
, NULL
, NULL
141 /* Check if string corresponds to an important hardware capability or
144 is_hwcap_platform (const char *name
)
146 int hwcap_idx
= _dl_string_hwcap (name
);
148 if (hwcap_idx
!= -1 && ((1 << hwcap_idx
) & HWCAP_IMPORTANT
))
151 hwcap_idx
= _dl_string_platform (name
);
158 /* Get hwcap (including platform) encoding of path. */
160 path_hwcap (const char *path
)
162 char *str
= xstrdup (path
);
173 /* Search pathname from the end and check for hwcap strings. */
176 ptr
= strrchr (str
, '/');
181 h
= _dl_string_hwcap (ptr
+ 1);
183 if (h
== (uint64_t) -1)
185 h
= _dl_string_platform (ptr
+ 1);
186 if (h
== (uint64_t) -1)
191 /* Search the next part of the path. */
199 /* Handle program arguments. */
201 parse_opt (int key
, char *arg
, struct argp_state
*state
)
234 if (strcmp (arg
, "old") == 0)
236 else if (strcmp (arg
, "compat") == 0)
238 else if (strcmp (arg
, "new") == 0)
242 return ARGP_ERR_UNKNOWN
;
248 /* Print the version information. */
250 print_version (FILE *stream
, struct argp_state
*state
)
252 fprintf (stream
, "ldconfig (GNU %s) %s\n", PACKAGE
, VERSION
);
253 fprintf (stream
, gettext ("\
254 Copyright (C) %s Free Software Foundation, Inc.\n\
255 This is free software; see the source for copying conditions. There is NO\n\
256 warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n\
258 fprintf (stream
, gettext ("Written by %s.\n"),
262 /* Add a single directory entry. */
264 add_single_dir (struct dir_entry
*entry
, int verbose
)
266 struct dir_entry
*ptr
, *prev
;
272 /* Check for duplicates. */
273 if (strcmp (ptr
->path
, entry
->path
) == 0)
275 if (opt_verbose
&& verbose
)
276 error (0, 0, _("Path `%s' given more than once"), entry
->path
);
277 /* Use the newer information. */
278 ptr
->flag
= entry
->flag
;
285 /* Is this the first entry? */
286 if (ptr
== NULL
&& dir_entries
== NULL
)
288 else if (ptr
== NULL
)
292 /* Add one directory to the list of directories to process. */
294 add_dir (const char *line
)
297 struct dir_entry
*entry
;
300 entry
= xmalloc (sizeof (struct dir_entry
));
303 /* Search for an '=' sign. */
304 entry
->path
= xstrdup (line
);
305 equal_sign
= strchr (entry
->path
, '=');
310 entry
->flag
= FLAG_ANY
;
311 for (i
= 0; i
< sizeof (lib_types
) / sizeof (lib_types
[0]); ++i
)
312 if (strcmp (equal_sign
, lib_types
[i
].name
) == 0)
314 entry
->flag
= lib_types
[i
].flag
;
317 if (entry
->flag
== FLAG_ANY
)
318 error (0, 0, _("%s is not a known library type"), equal_sign
);
322 entry
->flag
= FLAG_ANY
;
325 /* Canonify path: for now only remove trailing slashes. */
326 i
= strlen (entry
->path
) - 1;
327 while (entry
->path
[i
] == '/' && i
> 0)
329 entry
->path
[i
] = '\0';
333 add_single_dir (entry
, 1);
338 chroot_stat (const char *real_path
, const char *path
, struct stat64
*st
)
344 return stat64 (real_path
, st
);
346 ret
= lstat64 (real_path
, st
);
347 if (ret
|| !S_ISLNK (st
->st_mode
))
350 canon_path
= chroot_canon (opt_chroot
, path
);
351 if (canon_path
== NULL
)
354 ret
= stat64 (canon_path
, st
);
359 /* Create a symbolic link from soname to libname in directory path. */
361 create_links (const char *real_path
, const char *path
, const char *libname
,
364 char *full_libname
, *full_soname
;
365 char *real_full_libname
, *real_full_soname
;
366 struct stat64 stat_lib
, stat_so
, lstat_so
;
369 /* XXX: The logics in this function should be simplified. */
371 /* Get complete path. */
372 full_libname
= alloca (strlen (path
) + strlen (libname
) + 2);
373 full_soname
= alloca (strlen (path
) + strlen (soname
) + 2);
374 sprintf (full_libname
, "%s/%s", path
, libname
);
375 sprintf (full_soname
, "%s/%s", path
, soname
);
378 real_full_libname
= alloca (strlen (real_path
) + strlen (libname
) + 2);
379 real_full_soname
= alloca (strlen (real_path
) + strlen (soname
) + 2);
380 sprintf (real_full_libname
, "%s/%s", real_path
, libname
);
381 sprintf (real_full_soname
, "%s/%s", real_path
, soname
);
385 real_full_libname
= full_libname
;
386 real_full_soname
= full_soname
;
389 /* Does soname already exist and point to the right library? */
390 if (chroot_stat (real_full_soname
, full_soname
, &stat_so
) == 0)
392 if (chroot_stat (real_full_libname
, full_libname
, &stat_lib
))
394 error (0, 0, _("Can't stat %s\n"), full_libname
);
397 if (stat_lib
.st_dev
== stat_so
.st_dev
398 && stat_lib
.st_ino
== stat_so
.st_ino
)
399 /* Link is already correct. */
401 else if (lstat64 (full_soname
, &lstat_so
) == 0
402 && !S_ISLNK (lstat_so
.st_mode
))
404 error (0, 0, _("%s is not a symbolic link\n"), full_soname
);
409 else if (lstat64 (real_full_soname
, &lstat_so
) != 0
410 || !S_ISLNK (lstat_so
.st_mode
))
411 /* Unless it is a stale symlink, there is no need to remove. */
415 printf ("\t%s -> %s", soname
, libname
);
417 if (do_link
&& opt_link
)
419 /* Remove old link. */
421 if (unlink (real_full_soname
))
423 error (0, 0, _("Can't unlink %s"), full_soname
);
426 /* Create symbolic link. */
427 if (do_link
&& symlink (libname
, real_full_soname
))
429 error (0, 0, _("Can't link %s to %s"), full_soname
, libname
);
435 fputs (_(" (changed)\n"), stdout
);
437 fputs (_(" (SKIPPED)\n"), stdout
);
440 else if (opt_verbose
)
441 fputs ("\n", stdout
);
444 /* Manually link the given library. */
446 manual_link (char *library
)
453 struct stat64 stat_buf
;
455 unsigned int osversion
;
457 /* Prepare arguments for create_links call. Split library name in
458 directory and filename first. Since path is allocated, we've got
459 to be careful to free at the end. */
460 path
= xstrdup (library
);
461 libname
= strrchr (path
, '/');
465 /* Successfully split names. Check if path is just "/" to avoid
469 libname
= library
+ 1;
470 path
= xrealloc (path
, 2);
481 /* There's no path, construct one. */
483 path
= xrealloc (path
, 2);
489 real_path
= chroot_canon (opt_chroot
, path
);
490 if (real_path
== NULL
)
492 error (0, errno
, _("Can't find %s"), path
);
496 real_library
= alloca (strlen (real_path
) + strlen (libname
) + 2);
497 sprintf (real_library
, "%s/%s", real_path
, libname
);
502 real_library
= library
;
505 /* Do some sanity checks first. */
506 if (lstat64 (real_library
, &stat_buf
))
508 error (0, errno
, _("Can't lstat %s"), library
);
512 /* We don't want links here! */
513 else if (!S_ISREG (stat_buf
.st_mode
))
515 error (0, 0, _("Ignored file %s since it is not a regular file."),
520 if (process_file (real_library
, library
, libname
, &flag
, &osversion
,
523 error (0, 0, _("No link created since soname could not be found for %s"),
528 create_links (real_path
, path
, libname
, soname
);
534 /* Read a whole directory and search for libraries.
535 The purpose is two-fold:
536 - search for libraries which will be added to the cache
537 - create symbolic links to the soname for each library
539 This has to be done separatly for each directory.
541 To keep track of which libraries to add to the cache and which
542 links to create, we save a list of all libraries.
544 The algorithm is basically:
545 for all libraries in the directory do
546 get soname of library
547 if soname is already in list
548 if new library is newer, replace entry
549 otherwise ignore this library
550 otherwise add library to list
552 For example, if the two libraries libxy.so.1.1 and libxy.so.1.2
553 exist and both have the same soname, e.g. libxy.so, a symbolic link
554 is created from libxy.so.1.2 (the newer one) to libxy.so.
555 libxy.so.1.2 and libxy.so are added to the cache - but not
558 /* Information for one library. */
565 unsigned int osversion
;
566 struct dlib_entry
*next
;
571 search_dir (const struct dir_entry
*entry
)
574 struct dirent
*direntry
;
575 char *file_name
, *dir_name
, *real_file_name
, *real_name
;
576 int file_name_len
, real_file_name_len
, len
;
578 struct dlib_entry
*dlibs
;
579 struct dlib_entry
*dlib_ptr
;
580 struct stat64 stat_buf
;
582 uint64_t hwcap
= path_hwcap (entry
->path
);
583 unsigned int osversion
;
585 file_name_len
= PATH_MAX
;
586 file_name
= alloca (file_name_len
);
593 printf ("%s: (hwcap: 0x%" PRIx64
")\n", entry
->path
, hwcap
);
595 printf ("%s:\n", entry
->path
);
600 dir_name
= chroot_canon (opt_chroot
, entry
->path
);
601 real_file_name_len
= PATH_MAX
;
602 real_file_name
= alloca (real_file_name_len
);
606 dir_name
= entry
->path
;
607 real_file_name_len
= 0;
608 real_file_name
= file_name
;
611 if (dir_name
== NULL
|| (dir
= opendir (dir_name
)) == NULL
)
614 error (0, errno
, _("Can't open directory %s"), entry
->path
);
615 if (opt_chroot
&& dir_name
)
620 while ((direntry
= readdir (dir
)) != NULL
)
623 #ifdef _DIRENT_HAVE_D_TYPE
624 /* We only look at links and regular files. */
625 if (direntry
->d_type
!= DT_UNKNOWN
626 && direntry
->d_type
!= DT_LNK
627 && direntry
->d_type
!= DT_REG
628 && direntry
->d_type
!= DT_DIR
)
630 #endif /* _DIRENT_HAVE_D_TYPE */
631 /* Does this file look like a shared library or is it a hwcap
632 subdirectory? The dynamic linker is also considered as
634 if (((strncmp (direntry
->d_name
, "lib", 3) != 0
635 && strncmp (direntry
->d_name
, "ld-", 3) != 0)
636 || strstr (direntry
->d_name
, ".so") == NULL
)
637 && !is_hwcap_platform (direntry
->d_name
))
639 len
= strlen (entry
->path
) + strlen (direntry
->d_name
);
640 if (len
> file_name_len
)
642 file_name_len
= len
+ 1;
643 file_name
= alloca (file_name_len
);
645 real_file_name
= file_name
;
647 sprintf (file_name
, "%s/%s", entry
->path
, direntry
->d_name
);
650 len
= strlen (dir_name
) + strlen (direntry
->d_name
);
651 if (len
> real_file_name_len
)
653 real_file_name_len
= len
+ 1;
654 real_file_name
= alloca (real_file_name_len
);
656 sprintf (real_file_name
, "%s/%s", dir_name
, direntry
->d_name
);
658 #ifdef _DIRENT_HAVE_D_TYPE
659 if (direntry
->d_type
!= DT_UNKNOWN
)
660 stat_buf
.st_mode
= DTTOIF (direntry
->d_type
);
663 if (lstat64 (real_file_name
, &stat_buf
))
665 error (0, errno
, _("Can't lstat %s"), file_name
);
669 if (S_ISDIR (stat_buf
.st_mode
) && is_hwcap_platform (direntry
->d_name
))
671 /* Handle subdirectory later. */
672 struct dir_entry
*new_entry
;
674 new_entry
= xmalloc (sizeof (struct dir_entry
));
675 new_entry
->path
= xstrdup (file_name
);
676 new_entry
->flag
= entry
->flag
;
677 new_entry
->next
= NULL
;
678 add_single_dir (new_entry
, 0);
681 else if (!S_ISREG (stat_buf
.st_mode
) && !S_ISLNK (stat_buf
.st_mode
))
684 is_link
= S_ISLNK (stat_buf
.st_mode
);
685 if (opt_chroot
&& is_link
)
687 real_name
= chroot_canon (opt_chroot
, file_name
);
688 if (real_name
== NULL
)
690 if (strstr (file_name
, ".so") == NULL
)
691 error (0, 0, _("Input file %s not found.\n"), file_name
);
696 real_name
= real_file_name
;
698 if (process_file (real_name
, file_name
, direntry
->d_name
, &flag
,
699 &osversion
, &soname
, is_link
))
701 if (real_name
!= real_file_name
)
706 if (real_name
!= real_file_name
)
709 /* Links will just point to itself. */
713 soname
= xstrdup (direntry
->d_name
);
717 && (entry
->flag
== FLAG_ELF_LIBC5
718 || entry
->flag
== FLAG_ELF_LIBC6
))
720 /* Some sanity checks to print warnings. */
723 if (flag
== FLAG_ELF_LIBC5
&& entry
->flag
!= FLAG_ELF_LIBC5
724 && entry
->flag
!= FLAG_ANY
)
725 error (0, 0, _("libc5 library %s in wrong directory"), file_name
);
726 if (flag
== FLAG_ELF_LIBC6
&& entry
->flag
!= FLAG_ELF_LIBC6
727 && entry
->flag
!= FLAG_ANY
)
728 error (0, 0, _("libc6 library %s in wrong directory"), file_name
);
729 if (flag
== FLAG_LIBC4
&& entry
->flag
!= FLAG_LIBC4
730 && entry
->flag
!= FLAG_ANY
)
731 error (0, 0, _("libc4 library %s in wrong directory"), file_name
);
734 /* Add library to list. */
735 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
737 /* Is soname already in list? */
738 if (strcmp (dlib_ptr
->soname
, soname
) == 0)
740 /* Prefer a file to a link, otherwise check which one
742 if ((!is_link
&& dlib_ptr
->is_link
)
743 || (is_link
== dlib_ptr
->is_link
744 && _dl_cache_libcmp (dlib_ptr
->name
, direntry
->d_name
) < 0))
746 /* It's newer - add it. */
747 /* Flag should be the same - sanity check. */
748 if (dlib_ptr
->flag
!= flag
)
750 if (dlib_ptr
->flag
== FLAG_ELF
751 && (flag
== FLAG_ELF_LIBC5
|| flag
== FLAG_ELF_LIBC6
))
752 dlib_ptr
->flag
= flag
;
753 else if ((dlib_ptr
->flag
== FLAG_ELF_LIBC5
754 || dlib_ptr
->flag
== FLAG_ELF_LIBC6
)
756 dlib_ptr
->flag
= flag
;
758 error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
759 dlib_ptr
->name
, direntry
->d_name
, entry
->path
);
761 free (dlib_ptr
->name
);
762 dlib_ptr
->osversion
= osversion
;
763 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
764 dlib_ptr
->is_link
= is_link
;
766 /* Don't add this library, abort loop. */
767 /* Also free soname, since it's dynamically allocated. */
772 /* Add the library if it's not already in. */
773 if (dlib_ptr
== NULL
)
775 dlib_ptr
= (struct dlib_entry
*)xmalloc (sizeof (struct dlib_entry
));
776 dlib_ptr
->name
= xstrdup (direntry
->d_name
);
777 dlib_ptr
->flag
= flag
;
778 dlib_ptr
->osversion
= osversion
;
779 dlib_ptr
->soname
= soname
;
780 dlib_ptr
->is_link
= is_link
;
781 /* Add at head of list. */
782 dlib_ptr
->next
= dlibs
;
789 /* Now dlibs contains a list of all libs - add those to the cache
790 and created all symbolic links. */
791 for (dlib_ptr
= dlibs
; dlib_ptr
!= NULL
; dlib_ptr
= dlib_ptr
->next
)
793 /* Don't create links to links. */
794 if (dlib_ptr
->is_link
== 0)
795 create_links (dir_name
, entry
->path
, dlib_ptr
->name
,
798 add_to_cache (entry
->path
, dlib_ptr
->soname
, dlib_ptr
->flag
,
799 dlib_ptr
->osversion
, hwcap
);
802 /* Free all resources. */
806 free (dlib_ptr
->soname
);
807 free (dlib_ptr
->name
);
812 if (opt_chroot
&& dir_name
)
816 /* Search through all libraries. */
820 struct dir_entry
*entry
;
822 for (entry
= dir_entries
; entry
!= NULL
; entry
= entry
->next
)
825 /* Free all allocated memory. */
829 dir_entries
= dir_entries
->next
;
836 /* Parse configuration file. */
838 parse_conf (const char *filename
)
847 canon
= chroot_canon (opt_chroot
, filename
);
849 file
= fopen (canon
, "r");
856 file
= fopen (filename
, "r");
861 error (0, errno
, _("Can't open configuration file %s"), canon
);
862 if (canon
!= filename
)
863 free ((char *) canon
);
867 if (canon
!= filename
)
868 free ((char *) canon
);
872 ssize_t n
= getline (&line
, &len
, file
);
876 if (line
[n
- 1] == '\n')
879 /* Because the file format does not know any form of quoting we
880 can search forward for the next '#' character and if found
881 make it terminating the line. */
882 *strchrnul (line
, '#') = '\0';
884 /* If the line is blank it is ignored. */
889 } while (!feof (file
));
891 /* Free buffer and close file. */
898 main (int argc
, char **argv
)
902 /* Parse and process arguments. */
903 argp_parse (&argp
, argc
, argv
, 0, &remaining
, NULL
);
905 /* Remaining arguments are additional libraries if opt_manual_link
907 if (remaining
!= argc
&& !opt_manual_link
)
910 for (i
= remaining
; i
< argc
; ++i
)
916 /* Normalize the path a bit, we might need it for printing later. */
917 char *endp
= strchr (opt_chroot
, '\0');
918 while (endp
> opt_chroot
&& endp
[-1] == '/')
921 if (endp
== opt_chroot
)
926 /* It is faster to use chroot if we can. */
927 if (!chroot (opt_chroot
))
930 error (EXIT_FAILURE
, errno
, _("Can't chdir to /"));
936 if (cache_file
== NULL
)
938 cache_file
= alloca (strlen (LD_SO_CACHE
) + 1);
939 strcpy (cache_file
, LD_SO_CACHE
);
942 if (config_file
== NULL
)
943 config_file
= LD_SO_CONF
;
949 char *p
= chroot_canon (opt_chroot
, cache_file
);
951 error (EXIT_FAILURE
, errno
, _("Can't open cache file %s\n"),
955 print_cache (cache_file
);
963 /* Canonicalize the directory name of cache_file, not cache_file,
964 because we'll rename a temporary cache file to it. */
965 char *p
= strrchr (cache_file
, '/');
966 char *canon
= chroot_canon (opt_chroot
,
967 p
? (*p
= '\0', cache_file
) : "/");
971 error (EXIT_FAILURE
, errno
,
972 _("Can't open cache file directory %s\n"),
973 p
? cache_file
: "/");
981 cache_file
= alloca (strlen (canon
) + strlen (p
) + 2);
982 sprintf (cache_file
, "%s/%s", canon
, p
);
988 /* Link all given libraries manually. */
991 for (i
= remaining
; i
< argc
; ++i
)
992 manual_link (argv
[i
]);
1001 if (!opt_only_cline
)
1003 /* Always add the standard search paths. */
1005 if (strcmp (SLIBDIR
, LIBDIR
))
1008 parse_conf (config_file
);
1013 if (opt_build_cache
)
1014 save_cache (cache_file
);