elf/ldconfig.c

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