elf/ldconfig.c

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