elf/ldconfig.c

   1 /* Copyright (C) 1999-2018 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 <http://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 "), "2018");
 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       error (0, errno, _("\
1083 Warning: ignoring configuration file that cannot be opened: %s"),
1084              canon);
1085       if (canon != filename)
1086         free ((char *) canon);
1087       return;
1088     }
1089
1090   /* No threads use this stream.  */
1091   __fsetlocking (file, FSETLOCKING_BYCALLER);
1092
1093   if (canon != filename)
1094     free ((char *) canon);
1095
1096   lineno = 0;
1097   do
1098     {
1099       ssize_t n = getline (&line, &len, file);
1100       if (n < 0)
1101         break;
1102
1103       ++lineno;
1104       if (line[n - 1] == '\n')
1105         line[n - 1] = '\0';
1106
1107       /* Because the file format does not know any form of quoting we
1108          can search forward for the next '#' character and if found
1109          make it terminating the line.  */
1110       *strchrnul (line, '#') = '\0';
1111
1112       /* Remove leading whitespace.  NUL is no whitespace character.  */
1113       char *cp = line;
1114       while (isspace (*cp))
1115         ++cp;
1116
1117       /* If the line is blank it is ignored.  */
1118       if (cp[0] == '\0')
1119         continue;
1120
1121       if (!strncmp (cp, "include", 7) && isblank (cp[7]))
1122         {
1123           char *dir;
1124           cp += 8;
1125           while ((dir = strsep (&cp, " \t")) != NULL)
1126             if (dir[0] != '\0')
1127               parse_conf_include (filename, lineno, do_chroot, dir);
1128         }
1129       else if (!strncasecmp (cp, "hwcap", 5) && isblank (cp[5]))
1130         {
1131           cp += 6;
1132           char *p, *name = NULL;
1133           unsigned long int n = strtoul (cp, &cp, 0);
1134           if (cp != NULL && isblank (*cp))
1135             while ((p = strsep (&cp, " \t")) != NULL)
1136               if (p[0] != '\0')
1137                 {
1138                   if (name == NULL)
1139                     name = p;
1140                   else
1141                     {
1142                       name = NULL;
1143                       break;
1144                     }
1145                 }
1146           if (name == NULL)
1147             {
1148               error (EXIT_FAILURE, 0, _("%s:%u: bad syntax in hwcap line"),
1149                      filename, lineno);
1150               break;
1151             }
1152           if (n >= (64 - _DL_FIRST_EXTRA))
1153             error (EXIT_FAILURE, 0,
1154                    _("%s:%u: hwcap index %lu above maximum %u"),
1155                    filename, lineno, n, 64 - _DL_FIRST_EXTRA - 1);
1156           if (hwcap_extra[n] == NULL)
1157             {
1158               for (unsigned long int h = 0; h < (64 - _DL_FIRST_EXTRA); ++h)
1159                 if (hwcap_extra[h] != NULL && !strcmp (name, hwcap_extra[h]))
1160                   error (EXIT_FAILURE, 0,
1161                          _("%s:%u: hwcap index %lu already defined as %s"),
1162                          filename, lineno, h, name);
1163               hwcap_extra[n] = xstrdup (name);
1164             }
1165           else
1166             {
1167               if (strcmp (name, hwcap_extra[n]))
1168                 error (EXIT_FAILURE, 0,
1169                        _("%s:%u: hwcap index %lu already defined as %s"),
1170                        filename, lineno, n, hwcap_extra[n]);
1171               if (opt_verbose)
1172                 error (0, 0, _("%s:%u: duplicate hwcap %lu %s"),
1173                        filename, lineno, n, name);
1174             }
1175         }
1176       else
1177         add_dir (cp);
1178     }
1179   while (!feof_unlocked (file));
1180
1181   /* Free buffer and close file.  */
1182   free (line);
1183   fclose (file);
1184 }
1185
1186 /* Handle one word in an `include' line, a glob pattern of additional
1187    config files to read.  */
1188 static void
1189 parse_conf_include (const char *config_file, unsigned int lineno,
1190                     bool do_chroot, const char *pattern)
1191 {
1192   if (opt_chroot && pattern[0] != '/')
1193     error (EXIT_FAILURE, 0,
1194            _("need absolute file name for configuration file when using -r"));
1195
1196   char *copy = NULL;
1197   if (pattern[0] != '/' && strchr (config_file, '/') != NULL)
1198     {
1199       if (asprintf (&copy, "%s/%s", dirname (strdupa (config_file)),
1200                     pattern) < 0)
1201         error (EXIT_FAILURE, 0, _("memory exhausted"));
1202       pattern = copy;
1203     }
1204
1205   glob64_t gl;
1206   int result;
1207   if (do_chroot && opt_chroot)
1208     {
1209       char *canon = chroot_canon (opt_chroot, pattern);
1210       if (canon == NULL)
1211         return;
1212       result = glob64 (canon, 0, NULL, &gl);
1213       free (canon);
1214     }
1215   else
1216     result = glob64 (pattern, 0, NULL, &gl);
1217
1218   switch (result)
1219     {
1220     case 0:
1221       for (size_t i = 0; i < gl.gl_pathc; ++i)
1222         parse_conf (gl.gl_pathv[i], false);
1223       globfree64 (&gl);
1224       break;
1225
1226     case GLOB_NOMATCH:
1227       break;
1228
1229     case GLOB_NOSPACE:
1230       errno = ENOMEM;
1231     case GLOB_ABORTED:
1232       if (opt_verbose)
1233         error (0, errno, _("%s:%u: cannot read directory %s"),
1234                config_file, lineno, pattern);
1235       break;
1236
1237     default:
1238       abort ();
1239       break;
1240     }
1241
1242   free (copy);
1243 }
1244
1245 /* Honour LD_HWCAP_MASK.  */
1246 static void
1247 set_hwcap (void)
1248 {
1249   char *mask = getenv ("LD_HWCAP_MASK");
1250
1251   if (mask)
1252     hwcap_mask = strtoul (mask, NULL, 0);
1253 }
1254
1255
1256 int
1257 main (int argc, char **argv)
1258 {
1259   /* Set locale via LC_ALL.  */
1260   setlocale (LC_ALL, "");
1261
1262   /* But keep the C collation.  That way `include' directives using
1263      globbing patterns are processed in a locale-independent order.  */
1264   setlocale (LC_COLLATE, "C");
1265
1266   /* Set the text message domain.  */
1267   textdomain (_libc_intl_domainname);
1268
1269   /* Parse and process arguments.  */
1270   int remaining;
1271   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1272
1273   /* Remaining arguments are additional directories if opt_manual_link
1274      is not set.  */
1275   if (remaining != argc && !opt_manual_link)
1276     {
1277       int i;
1278       for (i = remaining; i < argc; ++i)
1279         if (opt_build_cache && argv[i][0] != '/')
1280           error (EXIT_FAILURE, 0,
1281                  _("relative path `%s' used to build cache"),
1282                  argv[i]);
1283         else
1284           add_dir (argv[i]);
1285     }
1286
1287   /* The last entry in hwcap_extra is reserved for the "tls" pseudo-hwcap which
1288      indicates support for TLS.  This pseudo-hwcap is only used by old versions
1289      under which TLS support was optional.  The entry is no longer needed, but
1290      must remain for compatibility.  */
1291   hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls";
1292
1293   set_hwcap ();
1294
1295   if (opt_chroot)
1296     {
1297       /* Normalize the path a bit, we might need it for printing later.  */
1298       char *endp = rawmemchr (opt_chroot, '\0');
1299       while (endp > opt_chroot && endp[-1] == '/')
1300         --endp;
1301       *endp = '\0';
1302       if (endp == opt_chroot)
1303         opt_chroot = NULL;
1304
1305       if (opt_chroot)
1306         {
1307           /* It is faster to use chroot if we can.  */
1308           if (!chroot (opt_chroot))
1309             {
1310               if (chdir ("/"))
1311                 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1312               opt_chroot = NULL;
1313             }
1314         }
1315     }
1316
1317   if (cache_file == NULL)
1318     {
1319       cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1320       strcpy (cache_file, LD_SO_CACHE);
1321     }
1322
1323   if (config_file == NULL)
1324     config_file = LD_SO_CONF;
1325
1326   if (opt_print_cache)
1327     {
1328       if (opt_chroot)
1329         {
1330           char *p = chroot_canon (opt_chroot, cache_file);
1331           if (p == NULL)
1332             error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1333                    cache_file);
1334           cache_file = p;
1335         }
1336       print_cache (cache_file);
1337       if (opt_chroot)
1338         free (cache_file);
1339       exit (0);
1340     }
1341
1342   if (opt_chroot)
1343     {
1344       /* Canonicalize the directory name of cache_file, not cache_file,
1345          because we'll rename a temporary cache file to it.  */
1346       char *p = strrchr (cache_file, '/');
1347       char *canon = chroot_canon (opt_chroot,
1348                                   p ? (*p = '\0', cache_file) : "/");
1349
1350       if (canon == NULL)
1351         error (EXIT_FAILURE, errno,
1352                _("Can't open cache file directory %s\n"),
1353                p ? cache_file : "/");
1354
1355       if (p)
1356         ++p;
1357       else
1358         p = cache_file;
1359
1360       cache_file = alloca (strlen (canon) + strlen (p) + 2);
1361       sprintf (cache_file, "%s/%s", canon, p);
1362       free (canon);
1363     }
1364
1365   if (opt_manual_link)
1366     {
1367       /* Link all given libraries manually.  */
1368       int i;
1369
1370       for (i = remaining; i < argc; ++i)
1371         manual_link (argv[i]);
1372
1373       exit (0);
1374     }
1375
1376
1377   if (opt_build_cache)
1378     init_cache ();
1379
1380   if (!opt_only_cline)
1381     {
1382       parse_conf (config_file, true);
1383
1384       /* Always add the standard search paths.  */
1385       add_system_dir (SLIBDIR);
1386       if (strcmp (SLIBDIR, LIBDIR))
1387         add_system_dir (LIBDIR);
1388     }
1389
1390   const char *aux_cache_file = _PATH_LDCONFIG_AUX_CACHE;
1391   if (opt_chroot)
1392     aux_cache_file = chroot_canon (opt_chroot, aux_cache_file);
1393
1394   if (! opt_ignore_aux_cache && aux_cache_file)
1395     load_aux_cache (aux_cache_file);
1396   else
1397     init_aux_cache ();
1398
1399   search_dirs ();
1400
1401   if (opt_build_cache)
1402     {
1403       save_cache (cache_file);
1404       if (aux_cache_file)
1405         save_aux_cache (aux_cache_file);
1406     }
1407
1408   return 0;
1409 }