elf/ldconfig.c

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