elf/ldconfig.c

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