elf/ldconfig.c

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