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