elf/dl-version.c

   1 /* Handle symbol and library versioning.
   2    Copyright (C) 1997-2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4    Contributed by Ulrich Drepper <drepper@cygnus.com>, 1997.
   5
   6    The GNU C Library is free software; you can redistribute it and/or
   7    modify it under the terms of the GNU Lesser General Public
   8    License as published by the Free Software Foundation; either
   9    version 2.1 of the License, or (at your option) any later version.
  10
  11    The GNU C Library is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14    Lesser General Public License for more details.
  15
  16    You should have received a copy of the GNU Lesser General Public
  17    License along with the GNU C Library; if not, see
  18    <http://www.gnu.org/licenses/>.  */
  19
  20 #include <elf.h>
  21 #include <errno.h>
  22 #include <libintl.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <ldsodefs.h>
  26 #include <_itoa.h>
  27
  28 #include <assert.h>
  29
  30
  31 #ifndef VERSYMIDX
  32 # define VERSYMIDX(tag) (DT_NUM + DT_THISPROCNUM + DT_VERSIONTAGIDX (tag))
  33 #endif
  34
  35
  36 #define make_string(string, rest...) \
  37   ({                                                                          \
  38     const char *all[] = { string, ## rest };                                  \
  39     size_t len, cnt;                                                          \
  40     char *result, *cp;                                                        \
  41                                                                               \
  42     len = 1;                                                                  \
  43     for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt)                \
  44       len += strlen (all[cnt]);                                               \
  45                                                                               \
  46     cp = result = alloca (len);                                               \
  47     for (cnt = 0; cnt < sizeof (all) / sizeof (all[0]); ++cnt)                \
  48       cp = __stpcpy (cp, all[cnt]);                                           \
  49                                                                               \
  50     result;                                                                   \
  51   })
  52
  53
  54 static inline struct link_map *
  55 __attribute ((always_inline))
  56 find_needed (const char *name, struct link_map *map)
  57 {
  58   struct link_map *tmap;
  59   unsigned int n;
  60
  61   for (tmap = GL(dl_ns)[map->l_ns]._ns_loaded; tmap != NULL;
  62        tmap = tmap->l_next)
  63     if (_dl_name_match_p (name, tmap))
  64       return tmap;
  65
  66   /* The required object is not in the global scope, look to see if it is
  67      a dependency of the current object.  */
  68   for (n = 0; n < map->l_searchlist.r_nlist; n++)
  69     if (_dl_name_match_p (name, map->l_searchlist.r_list[n]))
  70       return map->l_searchlist.r_list[n];
  71
  72   /* Should never happen.  */
  73   return NULL;
  74 }
  75
  76
  77 static int
  78 internal_function
  79 match_symbol (const char *name, Lmid_t ns, ElfW(Word) hash, const char *string,
  80               struct link_map *map, int verbose, int weak)
  81 {
  82   const char *strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
  83   ElfW(Addr) def_offset;
  84   ElfW(Verdef) *def;
  85   /* Initialize to make the compiler happy.  */
  86   const char *errstring = NULL;
  87   int result = 0;
  88
  89   /* Display information about what we are doing while debugging.  */
  90   if (__builtin_expect (GLRO(dl_debug_mask) & DL_DEBUG_VERSIONS, 0))
  91     _dl_debug_printf ("\
  92 checking for version `%s' in file %s [%lu] required by file %s [%lu]\n",
  93                       string, map->l_name[0] ? map->l_name : rtld_progname,
  94                       map->l_ns, name, ns);
  95
  96   if (__builtin_expect (map->l_info[VERSYMIDX (DT_VERDEF)] == NULL, 0))
  97     {
  98       /* The file has no symbol versioning.  I.e., the dependent
  99          object was linked against another version of this file.  We
 100          only print a message if verbose output is requested.  */
 101       if (verbose)
 102         {
 103           /* XXX We cannot translate the messages.  */
 104           errstring = make_string ("\
 105 no version information available (required by ", name, ")");
 106           goto call_cerror;
 107         }
 108       return 0;
 109     }
 110
 111   def_offset = map->l_info[VERSYMIDX (DT_VERDEF)]->d_un.d_ptr;
 112   assert (def_offset != 0);
 113
 114   def = (ElfW(Verdef) *) ((char *) map->l_addr + def_offset);
 115   while (1)
 116     {
 117       /* Currently the version number of the definition entry is 1.
 118          Make sure all we see is this version.  */
 119       if (__builtin_expect (def->vd_version, 1) != 1)
 120         {
 121           char buf[20];
 122           buf[sizeof (buf) - 1] = '\0';
 123           /* XXX We cannot translate the message.  */
 124           errstring = make_string ("unsupported version ",
 125                                    _itoa (def->vd_version,
 126                                           &buf[sizeof (buf) - 1], 10, 0),
 127                                    " of Verdef record");
 128           result = 1;
 129           goto call_cerror;
 130         }
 131
 132       /* Compare the hash values.  */
 133       if (hash == def->vd_hash)
 134         {
 135           ElfW(Verdaux) *aux = (ElfW(Verdaux) *) ((char *) def + def->vd_aux);
 136
 137           /* To be safe, compare the string as well.  */
 138           if (__builtin_expect (strcmp (string, strtab + aux->vda_name), 0)
 139               == 0)
 140             /* Bingo!  */
 141             return 0;
 142         }
 143
 144       /* If no more definitions we failed to find what we want.  */
 145       if (def->vd_next == 0)
 146         break;
 147
 148       /* Next definition.  */
 149       def = (ElfW(Verdef) *) ((char *) def + def->vd_next);
 150     }
 151
 152   /* Symbol not found.  If it was a weak reference it is not fatal.  */
 153   if (__builtin_expect (weak, 1))
 154     {
 155       if (verbose)
 156         {
 157           /* XXX We cannot translate the message.  */
 158           errstring = make_string ("weak version `", string,
 159                                    "' not found (required by ", name, ")");
 160           goto call_cerror;
 161         }
 162       return 0;
 163     }
 164
 165   /* XXX We cannot translate the message.  */
 166   errstring = make_string ("version `", string, "' not found (required by ",
 167                            name, ")");
 168   result = 1;
 169  call_cerror:
 170   _dl_signal_cerror (0, map->l_name[0] ? map->l_name : rtld_progname,
 171                      N_("version lookup error"), errstring);
 172   return result;
 173 }
 174
 175
 176 int
 177 internal_function
 178 _dl_check_map_versions (struct link_map *map, int verbose, int trace_mode)
 179 {
 180   int result = 0;
 181   const char *strtab;
 182   /* Pointer to section with needed versions.  */
 183   ElfW(Dyn) *dyn;
 184   /* Pointer to dynamic section with definitions.  */
 185   ElfW(Dyn) *def;
 186   /* We need to find out which is the highest version index used
 187     in a dependecy.  */
 188   unsigned int ndx_high = 0;
 189   /* Initialize to make the compiler happy.  */
 190   const char *errstring = NULL;
 191   int errval = 0;
 192
 193   /* If we don't have a string table, we must be ok.  */
 194   if (map->l_info[DT_STRTAB] == NULL)
 195     return 0;
 196   strtab = (const void *) D_PTR (map, l_info[DT_STRTAB]);
 197
 198   dyn = map->l_info[VERSYMIDX (DT_VERNEED)];
 199   def = map->l_info[VERSYMIDX (DT_VERDEF)];
 200
 201   if (dyn != NULL)
 202     {
 203       /* This file requires special versions from its dependencies.  */
 204       ElfW(Verneed) *ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
 205
 206       /* Currently the version number of the needed entry is 1.
 207          Make sure all we see is this version.  */
 208       if (__builtin_expect (ent->vn_version, 1) != 1)
 209         {
 210           char buf[20];
 211           buf[sizeof (buf) - 1] = '\0';
 212           /* XXX We cannot translate the message.  */
 213           errstring = make_string ("unsupported version ",
 214                                    _itoa (ent->vn_version,
 215                                           &buf[sizeof (buf) - 1], 10, 0),
 216                                    " of Verneed record\n");
 217         call_error:
 218           _dl_signal_error (errval, *map->l_name ? map->l_name : rtld_progname,
 219                             NULL, errstring);
 220         }
 221
 222       while (1)
 223         {
 224           ElfW(Vernaux) *aux;
 225           struct link_map *needed = find_needed (strtab + ent->vn_file, map);
 226
 227           /* If NEEDED is NULL this means a dependency was not found
 228              and no stub entry was created.  This should never happen.  */
 229           assert (needed != NULL);
 230
 231           /* Make sure this is no stub we created because of a missing
 232              dependency.  */
 233           if (__builtin_expect (! trace_mode, 1)
 234               || ! __builtin_expect (needed->l_faked, 0))
 235             {
 236               /* NEEDED is the map for the file we need.  Now look for the
 237                  dependency symbols.  */
 238               aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
 239               while (1)
 240                 {
 241                   /* Match the symbol.  */
 242                   result |= match_symbol ((*map->l_name
 243                                            ? map->l_name : rtld_progname),
 244                                           map->l_ns, aux->vna_hash,
 245                                           strtab + aux->vna_name,
 246                                           needed->l_real, verbose,
 247                                           aux->vna_flags & VER_FLG_WEAK);
 248
 249                   /* Compare the version index.  */
 250                   if ((unsigned int) (aux->vna_other & 0x7fff) > ndx_high)
 251                     ndx_high = aux->vna_other & 0x7fff;
 252
 253                   if (aux->vna_next == 0)
 254                     /* No more symbols.  */
 255                     break;
 256
 257                   /* Next symbol.  */
 258                   aux = (ElfW(Vernaux) *) ((char *) aux + aux->vna_next);
 259                 }
 260             }
 261
 262           if (ent->vn_next == 0)
 263             /* No more dependencies.  */
 264             break;
 265
 266           /* Next dependency.  */
 267           ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
 268         }
 269     }
 270
 271   /* We also must store the names of the defined versions.  Determine
 272      the maximum index here as well.
 273
 274      XXX We could avoid the loop by just taking the number of definitions
 275      as an upper bound of new indeces.  */
 276   if (def != NULL)
 277     {
 278       ElfW(Verdef) *ent;
 279       ent = (ElfW(Verdef) *) (map->l_addr + def->d_un.d_ptr);
 280       while (1)
 281         {
 282           if ((unsigned int) (ent->vd_ndx & 0x7fff) > ndx_high)
 283             ndx_high = ent->vd_ndx & 0x7fff;
 284
 285           if (ent->vd_next == 0)
 286             /* No more definitions.  */
 287             break;
 288
 289           ent = (ElfW(Verdef) *) ((char *) ent + ent->vd_next);
 290         }
 291     }
 292
 293   if (ndx_high > 0)
 294     {
 295       /* Now we are ready to build the array with the version names
 296          which can be indexed by the version index in the VERSYM
 297          section.  */
 298       map->l_versions = (struct r_found_version *)
 299         calloc (ndx_high + 1, sizeof (*map->l_versions));
 300       if (__builtin_expect (map->l_versions == NULL, 0))
 301         {
 302           errstring = N_("cannot allocate version reference table");
 303           errval = ENOMEM;
 304           goto call_error;
 305         }
 306
 307       /* Store the number of available symbols.  */
 308       map->l_nversions = ndx_high + 1;
 309
 310       /* Compute the pointer to the version symbols.  */
 311       map->l_versyms = (void *) D_PTR (map, l_info[VERSYMIDX (DT_VERSYM)]);
 312
 313       if (dyn != NULL)
 314         {
 315           ElfW(Verneed) *ent;
 316           ent = (ElfW(Verneed) *) (map->l_addr + dyn->d_un.d_ptr);
 317           while (1)
 318             {
 319               ElfW(Vernaux) *aux;
 320               aux = (ElfW(Vernaux) *) ((char *) ent + ent->vn_aux);
 321               while (1)
 322                 {
 323                   ElfW(Half) ndx = aux->vna_other & 0x7fff;
 324                   /* In trace mode, dependencies may be missing.  */
 325                   if (__builtin_expect (ndx < map->l_nversions, 1))
 326                     {
 327                       map->l_versions[ndx].hash = aux->vna_hash;
 328                       map->l_versions[ndx].hidden = aux->vna_other & 0x8000;
 329                       map->l_versions[ndx].name = &strtab[aux->vna_name];
 330                       map->l_versions[ndx].filename = &strtab[ent->vn_file];
 331                     }
 332
 333                   if (aux->vna_next == 0)
 334                     /* No more symbols.  */
 335                     break;
 336
 337                   /* Advance to next symbol.  */
 338                   aux = (ElfW(Vernaux) *) ((char *) aux + aux->vna_next);
 339                 }
 340
 341               if (ent->vn_next == 0)
 342                 /* No more dependencies.  */
 343                 break;
 344
 345               /* Advance to next dependency.  */
 346               ent = (ElfW(Verneed) *) ((char *) ent + ent->vn_next);
 347             }
 348         }
 349
 350       /* And insert the defined versions.  */
 351       if (def != NULL)
 352         {
 353           ElfW(Verdef) *ent;
 354           ent = (ElfW(Verdef)  *) (map->l_addr + def->d_un.d_ptr);
 355           while (1)
 356             {
 357               ElfW(Verdaux) *aux;
 358               aux = (ElfW(Verdaux) *) ((char *) ent + ent->vd_aux);
 359
 360               if ((ent->vd_flags & VER_FLG_BASE) == 0)
 361                 {
 362                   /* The name of the base version should not be
 363                      available for matching a versioned symbol.  */
 364                   ElfW(Half) ndx = ent->vd_ndx & 0x7fff;
 365                   map->l_versions[ndx].hash = ent->vd_hash;
 366                   map->l_versions[ndx].name = &strtab[aux->vda_name];
 367                   map->l_versions[ndx].filename = NULL;
 368                 }
 369
 370               if (ent->vd_next == 0)
 371                 /* No more definitions.  */
 372                 break;
 373
 374               ent = (ElfW(Verdef) *) ((char *) ent + ent->vd_next);
 375             }
 376         }
 377     }
 378
 379   return result;
 380 }
 381
 382
 383 int
 384 internal_function
 385 _dl_check_all_versions (struct link_map *map, int verbose, int trace_mode)
 386 {
 387   struct link_map *l;
 388   int result = 0;
 389
 390   for (l = map; l != NULL; l = l->l_next)
 391     result |= (! l->l_faked
 392                && _dl_check_map_versions (l, verbose, trace_mode));
 393
 394   return result;
 395 }