elf/ldconfig.c

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