elf/ldconfig.c

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