elf/ldconfig.c

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