elf/ldconfig.c

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