elf/ldconfig.c

   1 /* Copyright (C) 1999-2016 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 "), "2016");
 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 #ifdef _DIRENT_HAVE_D_TYPE
 714       /* We only look at links and regular files.  */
 715       if (direntry->d_type != DT_UNKNOWN
 716           && direntry->d_type != DT_LNK
 717           && direntry->d_type != DT_REG
 718           && direntry->d_type != DT_DIR)
 719         continue;
 720 #endif /* _DIRENT_HAVE_D_TYPE  */
 721       /* Does this file look like a shared library or is it a hwcap
 722          subdirectory?  The dynamic linker is also considered as
 723          shared library.  */
 724       if (((strncmp (direntry->d_name, "lib", 3) != 0
 725             && strncmp (direntry->d_name, "ld-", 3) != 0)
 726            || strstr (direntry->d_name, ".so") == NULL)
 727           && (
 728 #ifdef _DIRENT_HAVE_D_TYPE
 729               direntry->d_type == DT_REG ||
 730 #endif
 731               !is_hwcap_platform (direntry->d_name)))
 732         continue;
 733
 734       size_t len = strlen (direntry->d_name);
 735       /* Skip temporary files created by the prelink program.  Files with
 736          names like these are never really DSOs we want to look at.  */
 737       if (len >= sizeof (".#prelink#") - 1)
 738         {
 739           if (strcmp (direntry->d_name + len - sizeof (".#prelink#") + 1,
 740                       ".#prelink#") == 0)
 741             continue;
 742           if (len >= sizeof (".#prelink#.XXXXXX") - 1
 743               && memcmp (direntry->d_name + len - sizeof (".#prelink#.XXXXXX")
 744                          + 1, ".#prelink#.", sizeof (".#prelink#.") - 1) == 0)
 745             continue;
 746         }
 747       len += strlen (entry->path) + 2;
 748       if (len > file_name_len)
 749         {
 750           file_name_len = len;
 751           file_name = alloca (file_name_len);
 752           if (!opt_chroot)
 753             real_file_name = file_name;
 754         }
 755       sprintf (file_name, "%s/%s", entry->path, direntry->d_name);
 756       if (opt_chroot)
 757         {
 758           len = strlen (dir_name) + strlen (direntry->d_name) + 2;
 759           if (len > real_file_name_len)
 760             {
 761               real_file_name_len = len;
 762               real_file_name = alloca (real_file_name_len);
 763             }
 764           sprintf (real_file_name, "%s/%s", dir_name, direntry->d_name);
 765         }
 766
 767       struct stat64 lstat_buf;
 768 #ifdef _DIRENT_HAVE_D_TYPE
 769       /* We optimize and try to do the lstat call only if needed.  */
 770       if (direntry->d_type != DT_UNKNOWN)
 771         lstat_buf.st_mode = DTTOIF (direntry->d_type);
 772       else
 773 #endif
 774         if (__glibc_unlikely (lstat64 (real_file_name, &lstat_buf)))
 775           {
 776             error (0, errno, _("Cannot lstat %s"), file_name);
 777             continue;
 778           }
 779
 780       struct stat64 stat_buf;
 781       int is_dir;
 782       int is_link = S_ISLNK (lstat_buf.st_mode);
 783       if (is_link)
 784         {
 785           /* In case of symlink, we check if the symlink refers to
 786              a directory. */
 787           char *target_name = real_file_name;
 788           if (opt_chroot)
 789             {
 790               target_name = chroot_canon (opt_chroot, file_name);
 791               if (target_name == NULL)
 792                 {
 793                   if (strstr (file_name, ".so") == NULL)
 794                     error (0, 0, _("Input file %s not found.\n"), file_name);
 795                   continue;
 796                 }
 797             }
 798           if (__glibc_unlikely (stat64 (target_name, &stat_buf)))
 799             {
 800               if (opt_verbose)
 801                 error (0, errno, _("Cannot stat %s"), file_name);
 802
 803               /* Remove stale symlinks.  */
 804               if (opt_link && strstr (direntry->d_name, ".so."))
 805                 unlink (real_file_name);
 806               continue;
 807             }
 808           is_dir = S_ISDIR (stat_buf.st_mode);
 809
 810           /* lstat_buf is later stored, update contents.  */
 811           lstat_buf.st_dev = stat_buf.st_dev;
 812           lstat_buf.st_ino = stat_buf.st_ino;
 813           lstat_buf.st_size = stat_buf.st_size;
 814           lstat_buf.st_ctime = stat_buf.st_ctime;
 815         }
 816       else
 817         is_dir = S_ISDIR (lstat_buf.st_mode);
 818
 819       if (is_dir && is_hwcap_platform (direntry->d_name))
 820         {
 821           /* Handle subdirectory later.  */
 822           struct dir_entry *new_entry;
 823
 824           new_entry = xmalloc (sizeof (struct dir_entry));
 825           new_entry->path = xstrdup (file_name);
 826           new_entry->flag = entry->flag;
 827           new_entry->next = NULL;
 828 #ifdef _DIRENT_HAVE_D_TYPE
 829           /* We have filled in lstat only #ifndef
 830              _DIRENT_HAVE_D_TYPE.  Fill it in if needed.  */
 831           if (!is_link
 832               && direntry->d_type != DT_UNKNOWN
 833               && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
 834             {
 835               error (0, errno, _("Cannot lstat %s"), file_name);
 836               free (new_entry->path);
 837               free (new_entry);
 838               continue;
 839             }
 840 #endif
 841           new_entry->ino = lstat_buf.st_ino;
 842           new_entry->dev = lstat_buf.st_dev;
 843           add_single_dir (new_entry, 0);
 844           continue;
 845         }
 846       else if (!S_ISREG (lstat_buf.st_mode) && !is_link)
 847         continue;
 848
 849       char *real_name;
 850       if (opt_chroot && is_link)
 851         {
 852           real_name = chroot_canon (opt_chroot, file_name);
 853           if (real_name == NULL)
 854             {
 855               if (strstr (file_name, ".so") == NULL)
 856                 error (0, 0, _("Input file %s not found.\n"), file_name);
 857               continue;
 858             }
 859         }
 860       else
 861         real_name = real_file_name;
 862
 863 #ifdef _DIRENT_HAVE_D_TYPE
 864       /* Call lstat64 if not done yet.  */
 865       if (!is_link
 866           && direntry->d_type != DT_UNKNOWN
 867           && __builtin_expect (lstat64 (real_file_name, &lstat_buf), 0))
 868         {
 869           error (0, errno, _("Cannot lstat %s"), file_name);
 870           continue;
 871         }
 872 #endif
 873
 874       /* First search whether the auxiliary cache contains this
 875          library already and it's not changed.  */
 876       char *soname;
 877       unsigned int osversion;
 878       if (!search_aux_cache (&lstat_buf, &flag, &osversion, &soname))
 879         {
 880           if (process_file (real_name, file_name, direntry->d_name, &flag,
 881                             &osversion, &soname, is_link, &lstat_buf))
 882             {
 883               if (real_name != real_file_name)
 884                 free (real_name);
 885               continue;
 886             }
 887           else if (opt_build_cache)
 888             add_to_aux_cache (&lstat_buf, flag, osversion, soname);
 889         }
 890
 891       if (soname == NULL)
 892         soname = implicit_soname (direntry->d_name, flag);
 893
 894       /* A link may just point to itself.  */
 895       if (is_link)
 896         {
 897           /* If the path the link points to isn't its soname or it is not
 898              the .so symlink for ld(1), we treat it as a normal file.
 899
 900              You should always do this:
 901
 902                 libfoo.so -> SONAME -> Arbitrary package-chosen name.
 903
 904              e.g. libfoo.so -> libfoo.so.1 -> libfooimp.so.9.99.
 905              Given a SONAME of libfoo.so.1.
 906
 907              You should *never* do this:
 908
 909                 libfoo.so -> libfooimp.so.9.99
 910
 911              If you do, and your SONAME is libfoo.so.1, then libfoo.so
 912              fails to point at the SONAME. In that case ldconfig may consider
 913              libfoo.so as another implementation of SONAME and will create
 914              symlinks against it causing problems when you try to upgrade
 915              or downgrade. The problems will arise because ldconfig will,
 916              depending on directory ordering, creat symlinks against libfoo.so
 917              e.g. libfoo.so.1.2 -> libfoo.so, but when libfoo.so is removed
 918              (typically by the removal of a development pacakge not required
 919              for the runtime) it will break the libfoo.so.1.2 symlink and the
 920              application will fail to start.  */
 921           const char *real_base_name = basename (real_file_name);
 922
 923           if (strcmp (real_base_name, soname) != 0)
 924             {
 925               len = strlen (real_base_name);
 926               if (len < strlen (".so")
 927                   || strcmp (real_base_name + len - strlen (".so"), ".so") != 0
 928                   || strncmp (real_base_name, soname, len) != 0)
 929                 is_link = 0;
 930             }
 931         }
 932
 933       if (real_name != real_file_name)
 934         free (real_name);
 935
 936       if (is_link)
 937         {
 938           free (soname);
 939           soname = xstrdup (direntry->d_name);
 940         }
 941
 942       if (flag == FLAG_ELF
 943           && (entry->flag == FLAG_ELF_LIBC5
 944               || entry->flag == FLAG_ELF_LIBC6))
 945         flag = entry->flag;
 946
 947       /* Some sanity checks to print warnings.  */
 948       if (opt_verbose)
 949         {
 950           if (flag == FLAG_ELF_LIBC5 && entry->flag != FLAG_ELF_LIBC5
 951               && entry->flag != FLAG_ANY)
 952             error (0, 0, _("libc5 library %s in wrong directory"), file_name);
 953           if (flag == FLAG_ELF_LIBC6 && entry->flag != FLAG_ELF_LIBC6
 954               && entry->flag != FLAG_ANY)
 955             error (0, 0, _("libc6 library %s in wrong directory"), file_name);
 956           if (flag == FLAG_LIBC4 && entry->flag != FLAG_LIBC4
 957               && entry->flag != FLAG_ANY)
 958             error (0, 0, _("libc4 library %s in wrong directory"), file_name);
 959         }
 960
 961       /* Add library to list.  */
 962       struct dlib_entry *dlib_ptr;
 963       for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
 964         {
 965           /* Is soname already in list?  */
 966           if (strcmp (dlib_ptr->soname, soname) == 0)
 967             {
 968               /* Prefer a file to a link, otherwise check which one
 969                  is newer.  */
 970               if ((!is_link && dlib_ptr->is_link)
 971                   || (is_link == dlib_ptr->is_link
 972                       && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
 973                 {
 974                   /* It's newer - add it.  */
 975                   /* Flag should be the same - sanity check.  */
 976                   if (dlib_ptr->flag != flag)
 977                     {
 978                       if (dlib_ptr->flag == FLAG_ELF
 979                           && (flag == FLAG_ELF_LIBC5 || flag == FLAG_ELF_LIBC6))
 980                         dlib_ptr->flag = flag;
 981                       else if ((dlib_ptr->flag == FLAG_ELF_LIBC5
 982                                 || dlib_ptr->flag == FLAG_ELF_LIBC6)
 983                                && flag == FLAG_ELF)
 984                         dlib_ptr->flag = flag;
 985                       else
 986                         error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
 987                                dlib_ptr->name, direntry->d_name,
 988                                entry->path);
 989                     }
 990                   free (dlib_ptr->name);
 991                   dlib_ptr->name = xstrdup (direntry->d_name);
 992                   dlib_ptr->is_link = is_link;
 993                   dlib_ptr->osversion = osversion;
 994                 }
 995               /* Don't add this library, abort loop.  */
 996               /* Also free soname, since it's dynamically allocated.  */
 997               free (soname);
 998               break;
 999             }
1000         }
1001       /* Add the library if it's not already in.  */
1002       if (dlib_ptr == NULL)
1003         {
1004           dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
1005           dlib_ptr->name = xstrdup (direntry->d_name);
1006           dlib_ptr->soname = soname;
1007           dlib_ptr->flag = flag;
1008           dlib_ptr->is_link = is_link;
1009           dlib_ptr->osversion = osversion;
1010           /* Add at head of list.  */
1011           dlib_ptr->next = dlibs;
1012           dlibs = dlib_ptr;
1013         }
1014     }
1015
1016   closedir (dir);
1017
1018   /* Now dlibs contains a list of all libs - add those to the cache
1019      and created all symbolic links.  */
1020   struct dlib_entry *dlib_ptr;
1021   for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
1022     {
1023       /* Don't create links to links.  */
1024       if (dlib_ptr->is_link == 0)
1025         create_links (dir_name, entry->path, dlib_ptr->name,
1026                       dlib_ptr->soname);
1027       if (opt_build_cache)
1028         add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag,
1029                       dlib_ptr->osversion, hwcap);
1030     }
1031
1032   /* Free all resources.  */
1033   while (dlibs)
1034     {
1035       dlib_ptr = dlibs;
1036       free (dlib_ptr->soname);
1037       free (dlib_ptr->name);
1038       dlibs = dlibs->next;
1039       free (dlib_ptr);
1040     }
1041
1042   if (opt_chroot && dir_name)
1043     free (dir_name);
1044 }
1045
1046 /* Search through all libraries.  */
1047 static void
1048 search_dirs (void)
1049 {
1050   struct dir_entry *entry;
1051
1052   for (entry = dir_entries; entry != NULL; entry = entry->next)
1053     search_dir (entry);
1054
1055   /* Free all allocated memory.  */
1056   while (dir_entries)
1057     {
1058       entry = dir_entries;
1059       dir_entries = dir_entries->next;
1060       free (entry->path);
1061       free (entry);
1062     }
1063 }
1064
1065
1066 static void parse_conf_include (const char *config_file, unsigned int lineno,
1067                                 bool do_chroot, const char *pattern);
1068
1069 /* Parse configuration file.  */
1070 static void
1071 parse_conf (const char *filename, bool do_chroot)
1072 {
1073   FILE *file = NULL;
1074   char *line = NULL;
1075   const char *canon;
1076   size_t len = 0;
1077   unsigned int lineno;
1078
1079   if (do_chroot && opt_chroot)
1080     {
1081       canon = chroot_canon (opt_chroot, filename);
1082       if (canon)
1083         file = fopen (canon, "r");
1084       else
1085         canon = filename;
1086     }
1087   else
1088     {
1089       canon = filename;
1090       file = fopen (filename, "r");
1091     }
1092
1093   if (file == NULL)
1094     {
1095       error (0, errno, _("\
1096 Warning: ignoring configuration file that cannot be opened: %s"),
1097              canon);
1098       if (canon != filename)
1099         free ((char *) canon);
1100       return;
1101     }
1102
1103   /* No threads use this stream.  */
1104   __fsetlocking (file, FSETLOCKING_BYCALLER);
1105
1106   if (canon != filename)
1107     free ((char *) canon);
1108
1109   lineno = 0;
1110   do
1111     {
1112       ssize_t n = getline (&line, &len, file);
1113       if (n < 0)
1114         break;
1115
1116       ++lineno;
1117       if (line[n - 1] == '\n')
1118         line[n - 1] = '\0';
1119
1120       /* Because the file format does not know any form of quoting we
1121          can search forward for the next '#' character and if found
1122          make it terminating the line.  */
1123       *strchrnul (line, '#') = '\0';
1124
1125       /* Remove leading whitespace.  NUL is no whitespace character.  */
1126       char *cp = line;
1127       while (isspace (*cp))
1128         ++cp;
1129
1130       /* If the line is blank it is ignored.  */
1131       if (cp[0] == '\0')
1132         continue;
1133
1134       if (!strncmp (cp, "include", 7) && isblank (cp[7]))
1135         {
1136           char *dir;
1137           cp += 8;
1138           while ((dir = strsep (&cp, " \t")) != NULL)
1139             if (dir[0] != '\0')
1140               parse_conf_include (filename, lineno, do_chroot, dir);
1141         }
1142       else if (!strncasecmp (cp, "hwcap", 5) && isblank (cp[5]))
1143         {
1144           cp += 6;
1145           char *p, *name = NULL;
1146           unsigned long int n = strtoul (cp, &cp, 0);
1147           if (cp != NULL && isblank (*cp))
1148             while ((p = strsep (&cp, " \t")) != NULL)
1149               if (p[0] != '\0')
1150                 {
1151                   if (name == NULL)
1152                     name = p;
1153                   else
1154                     {
1155                       name = NULL;
1156                       break;
1157                     }
1158                 }
1159           if (name == NULL)
1160             {
1161               error (EXIT_FAILURE, 0, _("%s:%u: bad syntax in hwcap line"),
1162                      filename, lineno);
1163               break;
1164             }
1165           if (n >= (64 - _DL_FIRST_EXTRA))
1166             error (EXIT_FAILURE, 0,
1167                    _("%s:%u: hwcap index %lu above maximum %u"),
1168                    filename, lineno, n, 64 - _DL_FIRST_EXTRA - 1);
1169           if (hwcap_extra[n] == NULL)
1170             {
1171               for (unsigned long int h = 0; h < (64 - _DL_FIRST_EXTRA); ++h)
1172                 if (hwcap_extra[h] != NULL && !strcmp (name, hwcap_extra[h]))
1173                   error (EXIT_FAILURE, 0,
1174                          _("%s:%u: hwcap index %lu already defined as %s"),
1175                          filename, lineno, h, name);
1176               hwcap_extra[n] = xstrdup (name);
1177             }
1178           else
1179             {
1180               if (strcmp (name, hwcap_extra[n]))
1181                 error (EXIT_FAILURE, 0,
1182                        _("%s:%u: hwcap index %lu already defined as %s"),
1183                        filename, lineno, n, hwcap_extra[n]);
1184               if (opt_verbose)
1185                 error (0, 0, _("%s:%u: duplicate hwcap %lu %s"),
1186                        filename, lineno, n, name);
1187             }
1188         }
1189       else
1190         add_dir (cp);
1191     }
1192   while (!feof_unlocked (file));
1193
1194   /* Free buffer and close file.  */
1195   free (line);
1196   fclose (file);
1197 }
1198
1199 /* Handle one word in an `include' line, a glob pattern of additional
1200    config files to read.  */
1201 static void
1202 parse_conf_include (const char *config_file, unsigned int lineno,
1203                     bool do_chroot, const char *pattern)
1204 {
1205   if (opt_chroot && pattern[0] != '/')
1206     error (EXIT_FAILURE, 0,
1207            _("need absolute file name for configuration file when using -r"));
1208
1209   char *copy = NULL;
1210   if (pattern[0] != '/' && strchr (config_file, '/') != NULL)
1211     {
1212       if (asprintf (&copy, "%s/%s", dirname (strdupa (config_file)),
1213                     pattern) < 0)
1214         error (EXIT_FAILURE, 0, _("memory exhausted"));
1215       pattern = copy;
1216     }
1217
1218   glob64_t gl;
1219   int result;
1220   if (do_chroot && opt_chroot)
1221     {
1222       char *canon = chroot_canon (opt_chroot, pattern);
1223       if (canon == NULL)
1224         return;
1225       result = glob64 (canon, 0, NULL, &gl);
1226       free (canon);
1227     }
1228   else
1229     result = glob64 (pattern, 0, NULL, &gl);
1230
1231   switch (result)
1232     {
1233     case 0:
1234       for (size_t i = 0; i < gl.gl_pathc; ++i)
1235         parse_conf (gl.gl_pathv[i], false);
1236       globfree64 (&gl);
1237       break;
1238
1239     case GLOB_NOMATCH:
1240       break;
1241
1242     case GLOB_NOSPACE:
1243       errno = ENOMEM;
1244     case GLOB_ABORTED:
1245       if (opt_verbose)
1246         error (0, errno, _("%s:%u: cannot read directory %s"),
1247                config_file, lineno, pattern);
1248       break;
1249
1250     default:
1251       abort ();
1252       break;
1253     }
1254
1255   free (copy);
1256 }
1257
1258 /* Honour LD_HWCAP_MASK.  */
1259 static void
1260 set_hwcap (void)
1261 {
1262   char *mask = getenv ("LD_HWCAP_MASK");
1263
1264   if (mask)
1265     hwcap_mask = strtoul (mask, NULL, 0);
1266 }
1267
1268
1269 int
1270 main (int argc, char **argv)
1271 {
1272   /* Set locale via LC_ALL.  */
1273   setlocale (LC_ALL, "");
1274
1275   /* Set the text message domain.  */
1276   textdomain (_libc_intl_domainname);
1277
1278   /* Parse and process arguments.  */
1279   int remaining;
1280   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1281
1282   /* Remaining arguments are additional directories if opt_manual_link
1283      is not set.  */
1284   if (remaining != argc && !opt_manual_link)
1285     {
1286       int i;
1287       for (i = remaining; i < argc; ++i)
1288         if (opt_build_cache && argv[i][0] != '/')
1289           error (EXIT_FAILURE, 0,
1290                  _("relative path `%s' used to build cache"),
1291                  argv[i]);
1292         else
1293           add_dir (argv[i]);
1294     }
1295
1296   /* The last entry in hwcap_extra is reserved for the "tls" pseudo-hwcap which
1297      indicates support for TLS.  This pseudo-hwcap is only used by old versions
1298      under which TLS support was optional.  The entry is no longer needed, but
1299      must remain for compatibility.  */
1300   hwcap_extra[63 - _DL_FIRST_EXTRA] = "tls";
1301
1302   set_hwcap ();
1303
1304   if (opt_chroot)
1305     {
1306       /* Normalize the path a bit, we might need it for printing later.  */
1307       char *endp = rawmemchr (opt_chroot, '\0');
1308       while (endp > opt_chroot && endp[-1] == '/')
1309         --endp;
1310       *endp = '\0';
1311       if (endp == opt_chroot)
1312         opt_chroot = NULL;
1313
1314       if (opt_chroot)
1315         {
1316           /* It is faster to use chroot if we can.  */
1317           if (!chroot (opt_chroot))
1318             {
1319               if (chdir ("/"))
1320                 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1321               opt_chroot = NULL;
1322             }
1323         }
1324     }
1325
1326   if (cache_file == NULL)
1327     {
1328       cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1329       strcpy (cache_file, LD_SO_CACHE);
1330     }
1331
1332   if (config_file == NULL)
1333     config_file = LD_SO_CONF;
1334
1335   if (opt_print_cache)
1336     {
1337       if (opt_chroot)
1338         {
1339           char *p = chroot_canon (opt_chroot, cache_file);
1340           if (p == NULL)
1341             error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1342                    cache_file);
1343           cache_file = p;
1344         }
1345       print_cache (cache_file);
1346       if (opt_chroot)
1347         free (cache_file);
1348       exit (0);
1349     }
1350
1351   if (opt_chroot)
1352     {
1353       /* Canonicalize the directory name of cache_file, not cache_file,
1354          because we'll rename a temporary cache file to it.  */
1355       char *p = strrchr (cache_file, '/');
1356       char *canon = chroot_canon (opt_chroot,
1357                                   p ? (*p = '\0', cache_file) : "/");
1358
1359       if (canon == NULL)
1360         error (EXIT_FAILURE, errno,
1361                _("Can't open cache file directory %s\n"),
1362                p ? cache_file : "/");
1363
1364       if (p)
1365         ++p;
1366       else
1367         p = cache_file;
1368
1369       cache_file = alloca (strlen (canon) + strlen (p) + 2);
1370       sprintf (cache_file, "%s/%s", canon, p);
1371       free (canon);
1372     }
1373
1374   if (opt_manual_link)
1375     {
1376       /* Link all given libraries manually.  */
1377       int i;
1378
1379       for (i = remaining; i < argc; ++i)
1380         manual_link (argv[i]);
1381
1382       exit (0);
1383     }
1384
1385
1386   if (opt_build_cache)
1387     init_cache ();
1388
1389   if (!opt_only_cline)
1390     {
1391       parse_conf (config_file, true);
1392
1393       /* Always add the standard search paths.  */
1394       add_system_dir (SLIBDIR);
1395       if (strcmp (SLIBDIR, LIBDIR))
1396         add_system_dir (LIBDIR);
1397     }
1398
1399   const char *aux_cache_file = _PATH_LDCONFIG_AUX_CACHE;
1400   if (opt_chroot)
1401     aux_cache_file = chroot_canon (opt_chroot, aux_cache_file);
1402
1403   if (! opt_ignore_aux_cache && aux_cache_file)
1404     load_aux_cache (aux_cache_file);
1405   else
1406     init_aux_cache ();
1407
1408   search_dirs ();
1409
1410   if (opt_build_cache)
1411     {
1412       save_cache (cache_file);
1413       if (aux_cache_file)
1414         save_aux_cache (aux_cache_file);
1415     }
1416
1417   return 0;
1418 }