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       /* Links will just point to itself.  */
 791       if (is_link)
 792         {
 793           free (soname);
 794           soname = xstrdup (direntry->d_name);
 795         }
 796
 797       if (real_name != real_file_name)
 798         free (real_name);
 799
 800       if (flag == FLAG_ELF
 801           && (entry->flag == FLAG_ELF_LIBC5
 802               || entry->flag == FLAG_ELF_LIBC6))
 803         flag = entry->flag;
 804       /* Some sanity checks to print warnings.  */
 805       if (opt_verbose)
 806         {
 807           if (flag == FLAG_ELF_LIBC5 && entry->flag != FLAG_ELF_LIBC5
 808               && entry->flag != FLAG_ANY)
 809             error (0, 0, _("libc5 library %s in wrong directory"), file_name);
 810           if (flag == FLAG_ELF_LIBC6 && entry->flag != FLAG_ELF_LIBC6
 811               && entry->flag != FLAG_ANY)
 812             error (0, 0, _("libc6 library %s in wrong directory"), file_name);
 813           if (flag == FLAG_LIBC4 && entry->flag != FLAG_LIBC4
 814               && entry->flag != FLAG_ANY)
 815             error (0, 0, _("libc4 library %s in wrong directory"), file_name);
 816         }
 817
 818       /* Add library to list.  */
 819       for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
 820         {
 821           /* Is soname already in list?  */
 822           if (strcmp (dlib_ptr->soname, soname) == 0)
 823             {
 824               /* Prefer a file to a link, otherwise check which one
 825                  is newer.  */
 826               if ((!is_link && dlib_ptr->is_link)
 827                   || (is_link == dlib_ptr->is_link
 828                       && _dl_cache_libcmp (dlib_ptr->name, direntry->d_name) < 0))
 829                 {
 830                   /* It's newer - add it.  */
 831                   /* Flag should be the same - sanity check.  */
 832                   if (dlib_ptr->flag != flag)
 833                     {
 834                       if (dlib_ptr->flag == FLAG_ELF
 835                           && (flag == FLAG_ELF_LIBC5 || flag == FLAG_ELF_LIBC6))
 836                         dlib_ptr->flag = flag;
 837                       else if ((dlib_ptr->flag == FLAG_ELF_LIBC5
 838                                 || dlib_ptr->flag == FLAG_ELF_LIBC6)
 839                                && flag == FLAG_ELF)
 840                         dlib_ptr->flag = flag;
 841                       else
 842                         error (0, 0, _("libraries %s and %s in directory %s have same soname but different type."),
 843                                dlib_ptr->name, direntry->d_name, entry->path);
 844                     }
 845                   free (dlib_ptr->name);
 846                   dlib_ptr->osversion = osversion;
 847                   dlib_ptr->name = xstrdup (direntry->d_name);
 848                   dlib_ptr->is_link = is_link;
 849                 }
 850               /* Don't add this library, abort loop.  */
 851               /* Also free soname, since it's dynamically allocated.  */
 852               free (soname);
 853               break;
 854             }
 855         }
 856       /* Add the library if it's not already in.  */
 857       if (dlib_ptr == NULL)
 858         {
 859           dlib_ptr = (struct dlib_entry *)xmalloc (sizeof (struct dlib_entry));
 860           dlib_ptr->name = xstrdup (direntry->d_name);
 861           dlib_ptr->flag = flag;
 862           dlib_ptr->osversion = osversion;
 863           dlib_ptr->soname = soname;
 864           dlib_ptr->is_link = is_link;
 865           /* Add at head of list.  */
 866           dlib_ptr->next = dlibs;
 867           dlibs = dlib_ptr;
 868         }
 869     }
 870
 871   closedir (dir);
 872
 873   /* Now dlibs contains a list of all libs - add those to the cache
 874      and created all symbolic links.  */
 875   for (dlib_ptr = dlibs; dlib_ptr != NULL; dlib_ptr = dlib_ptr->next)
 876     {
 877       /* Don't create links to links.  */
 878       if (dlib_ptr->is_link == 0)
 879         create_links (dir_name, entry->path, dlib_ptr->name,
 880                       dlib_ptr->soname);
 881       if (opt_build_cache)
 882         add_to_cache (entry->path, dlib_ptr->soname, dlib_ptr->flag,
 883                       dlib_ptr->osversion, hwcap);
 884     }
 885
 886   /* Free all resources.  */
 887   while (dlibs)
 888     {
 889       dlib_ptr = dlibs;
 890       free (dlib_ptr->soname);
 891       free (dlib_ptr->name);
 892       dlibs = dlibs->next;
 893       free (dlib_ptr);
 894     }
 895
 896   if (opt_chroot && dir_name)
 897     free (dir_name);
 898 }
 899
 900 /* Search through all libraries.  */
 901 static void
 902 search_dirs (void)
 903 {
 904   struct dir_entry *entry;
 905
 906   for (entry = dir_entries; entry != NULL; entry = entry->next)
 907     search_dir (entry);
 908
 909   /* Free all allocated memory.  */
 910   while (dir_entries)
 911     {
 912       entry = dir_entries;
 913       dir_entries = dir_entries->next;
 914       free (entry->path);
 915       free (entry);
 916     }
 917 }
 918
 919
 920 /* Parse configuration file.  */
 921 static void
 922 parse_conf (const char *filename)
 923 {
 924   FILE *file = NULL;
 925   char *line = NULL;
 926   const char *canon;
 927   size_t len = 0;
 928
 929   if (opt_chroot)
 930     {
 931       canon = chroot_canon (opt_chroot, filename);
 932       if (canon)
 933         file = fopen (canon, "r");
 934       else
 935         canon = filename;
 936     }
 937   else
 938     {
 939       canon = filename;
 940       file = fopen (filename, "r");
 941     }
 942
 943   if (file == NULL)
 944     {
 945       error (0, errno, _("Can't open configuration file %s"), canon);
 946       if (canon != filename)
 947         free ((char *) canon);
 948       return;
 949     }
 950
 951   /* No threads use this stream.  */
 952   __fsetlocking (file, FSETLOCKING_BYCALLER);
 953
 954   if (canon != filename)
 955     free ((char *) canon);
 956
 957   do
 958     {
 959       ssize_t n = getline (&line, &len, file);
 960       if (n < 0)
 961         break;
 962
 963       if (line[n - 1] == '\n')
 964         line[n - 1] = '\0';
 965
 966       /* Because the file format does not know any form of quoting we
 967          can search forward for the next '#' character and if found
 968          make it terminating the line.  */
 969       *strchrnul (line, '#') = '\0';
 970
 971       /* Remove leading whitespace.  NUL is no whitespace character.  */
 972       char *cp = line;
 973       while (isspace (*cp))
 974         ++cp;
 975
 976       /* If the line is blank it is ignored.  */
 977       if (cp[0] == '\0')
 978         continue;
 979
 980       add_dir (cp);
 981     }
 982   while (!feof_unlocked (file));
 983
 984   /* Free buffer and close file.  */
 985   free (line);
 986   fclose (file);
 987 }
 988
 989 /* Honour LD_HWCAP_MASK.  */
 990 static void
 991 set_hwcap (void)
 992 {
 993   char *mask = getenv ("LD_HWCAP_MASK");
 994
 995   if (mask)
 996     hwcap_mask = strtoul (mask, NULL, 0);
 997 }
 998
 999
1000 int
1001 main (int argc, char **argv)
1002 {
1003   int remaining;
1004
1005   /* Parse and process arguments.  */
1006   argp_parse (&argp, argc, argv, 0, &remaining, NULL);
1007
1008   /* Remaining arguments are additional directories if opt_manual_link
1009      is not set.  */
1010   if (remaining != argc && !opt_manual_link)
1011     {
1012       int i;
1013       for (i = remaining; i < argc; ++i)
1014         if (opt_build_cache && argv[i][0] != '/')
1015           error (EXIT_FAILURE, 0,
1016                  _("relative path `%s' used to build cache"),
1017                  argv[i]);
1018         else
1019           add_dir (argv[i]);
1020     }
1021
1022   set_hwcap ();
1023
1024   if (opt_chroot)
1025     {
1026       /* Normalize the path a bit, we might need it for printing later.  */
1027       char *endp = strchr (opt_chroot, '\0');
1028       while (endp > opt_chroot && endp[-1] == '/')
1029         --endp;
1030       *endp = '\0';
1031       if (endp == opt_chroot)
1032         opt_chroot = NULL;
1033
1034       if (opt_chroot)
1035         {
1036           /* It is faster to use chroot if we can.  */
1037           if (!chroot (opt_chroot))
1038             {
1039               if (chdir ("/"))
1040                 error (EXIT_FAILURE, errno, _("Can't chdir to /"));
1041               opt_chroot = NULL;
1042             }
1043         }
1044     }
1045
1046   if (cache_file == NULL)
1047     {
1048       cache_file = alloca (strlen (LD_SO_CACHE) + 1);
1049       strcpy (cache_file, LD_SO_CACHE);
1050     }
1051
1052   if (config_file == NULL)
1053     config_file = LD_SO_CONF;
1054
1055   if (opt_print_cache)
1056     {
1057       if (opt_chroot)
1058         {
1059           char *p = chroot_canon (opt_chroot, cache_file);
1060           if (p == NULL)
1061             error (EXIT_FAILURE, errno, _("Can't open cache file %s\n"),
1062                    cache_file);
1063           cache_file = p;
1064         }
1065       print_cache (cache_file);
1066       if (opt_chroot)
1067         free (cache_file);
1068       exit (0);
1069     }
1070
1071   if (opt_chroot)
1072     {
1073       /* Canonicalize the directory name of cache_file, not cache_file,
1074          because we'll rename a temporary cache file to it.  */
1075       char *p = strrchr (cache_file, '/');
1076       char *canon = chroot_canon (opt_chroot,
1077                                   p ? (*p = '\0', cache_file) : "/");
1078
1079       if (canon == NULL)
1080         {
1081           error (EXIT_FAILURE, errno,
1082                  _("Can't open cache file directory %s\n"),
1083                  p ? cache_file : "/");
1084         }
1085
1086       if (p)
1087         ++p;
1088       else
1089         p = cache_file;
1090
1091       cache_file = alloca (strlen (canon) + strlen (p) + 2);
1092       sprintf (cache_file, "%s/%s", canon, p);
1093       free (canon);
1094     }
1095
1096   if (opt_manual_link)
1097     {
1098       /* Link all given libraries manually.  */
1099       int i;
1100
1101       for (i = remaining; i < argc; ++i)
1102         manual_link (argv[i]);
1103
1104       exit (0);
1105     }
1106
1107
1108   if (opt_build_cache)
1109     init_cache ();
1110
1111   if (!opt_only_cline)
1112     {
1113       parse_conf (config_file);
1114
1115       /* Always add the standard search paths.  */
1116       add_system_dir (SLIBDIR);
1117       if (strcmp (SLIBDIR, LIBDIR))
1118         add_system_dir (LIBDIR);
1119     }
1120
1121   search_dirs ();
1122
1123   if (opt_build_cache)
1124     save_cache (cache_file);
1125
1126   return 0;
1127 }