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