resolv/resolv_conf.c

   1 /* Extended resolver state separate from struct __res_state.
   2    Copyright (C) 2017-2023 Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   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, see
  17    <https://www.gnu.org/licenses/>.  */
  18
  19 #include <resolv_conf.h>
  20
  21 #include <alloc_buffer.h>
  22 #include <assert.h>
  23 #include <libc-lock.h>
  24 #include <resolv-internal.h>
  25 #include <sys/stat.h>
  26 #include <libc-symbols.h>
  27 #include <file_change_detection.h>
  28
  29 /* _res._u._ext.__glibc_extension_index is used as an index into a
  30    struct resolv_conf_array object.  The intent of this construction
  31    is to make reasonably sure that even if struct __res_state objects
  32    are copied around and patched by applications, we can still detect
  33    accesses to stale extended resolver state.  The array elements are
  34    either struct resolv_conf * pointers (if the LSB is cleared) or
  35    free list entries (if the LSB is set).  The free list is used to
  36    speed up finding available entries in the array.  */
  37 #define DYNARRAY_STRUCT resolv_conf_array
  38 #define DYNARRAY_ELEMENT uintptr_t
  39 #define DYNARRAY_PREFIX resolv_conf_array_
  40 #define DYNARRAY_INITIAL_SIZE 0
  41 #include <malloc/dynarray-skeleton.c>
  42
  43 /* A magic constant for XORing the extension index
  44    (_res._u._ext.__glibc_extension_index).  This makes it less likely
  45    that a valid index is created by accident.  In particular, a zero
  46    value leads to an invalid index.  */
  47 #define INDEX_MAGIC 0x26a8fa5e48af8061ULL
  48
  49 /* Global resolv.conf-related state.  */
  50 struct resolv_conf_global
  51 {
  52   /* struct __res_state objects contain the extension index
  53      (_res._u._ext.__glibc_extension_index ^ INDEX_MAGIC), which
  54      refers to an element of this array.  When a struct resolv_conf
  55      object (extended resolver state) is associated with a struct
  56      __res_state object (legacy resolver state), its reference count
  57      is increased and added to this array.  Conversely, if the
  58      extended state is detached from the basic state (during
  59      reinitialization or deallocation), the index is decremented, and
  60      the array element is overwritten with NULL.  */
  61   struct resolv_conf_array array;
  62
  63   /* Start of the free list in the array.  Zero if the free list is
  64      empty.  Otherwise, free_list_start >> 1 is the first element of
  65      the free list (and the free list entries all have their LSB set
  66      and are shifted one to the left).  */
  67   uintptr_t free_list_start;
  68
  69   /* Cached current configuration object for /etc/resolv.conf.  */
  70   struct resolv_conf *conf_current;
  71
  72   /* File system identification for /etc/resolv.conf.  */
  73   struct file_change_detection file_resolve_conf;
  74 };
  75
  76 /* Lazily allocated storage for struct resolv_conf_global.  */
  77 static struct resolv_conf_global *global;
  78
  79 /* The lock synchronizes access to global and *global.  It also
  80    protects the __refcount member of struct resolv_conf.  */
  81 __libc_lock_define_initialized (static, lock);
  82
  83 /* Ensure that GLOBAL is allocated and lock it.  Return NULL if
  84    memory allocation fails.  */
  85 static struct resolv_conf_global *
  86 get_locked_global (void)
  87 {
  88   __libc_lock_lock (lock);
  89   /* Use relaxed MO through because of load outside the lock in
  90      __resolv_conf_detach.  */
  91   struct resolv_conf_global *global_copy = atomic_load_relaxed (&global);
  92   if (global_copy == NULL)
  93     {
  94       global_copy = calloc (1, sizeof (*global));
  95       if (global_copy == NULL)
  96         {
  97           __libc_lock_unlock (lock);
  98           return NULL;
  99         }
 100       atomic_store_relaxed (&global, global_copy);
 101       resolv_conf_array_init (&global_copy->array);
 102     }
 103   return global_copy;
 104 }
 105
 106 /* Relinquish the lock acquired by get_locked_global.  */
 107 static void
 108 put_locked_global (struct resolv_conf_global *global_copy)
 109 {
 110   __libc_lock_unlock (lock);
 111 }
 112
 113 /* Decrement the reference counter.  The caller must acquire the lock
 114    around the function call.  */
 115 static void
 116 conf_decrement (struct resolv_conf *conf)
 117 {
 118   assert (conf->__refcount > 0);
 119   if (--conf->__refcount == 0)
 120     free (conf);
 121 }
 122
 123 struct resolv_conf *
 124 __resolv_conf_get_current (void)
 125 {
 126   struct file_change_detection initial;
 127   if (!__file_change_detection_for_path (&initial, _PATH_RESCONF))
 128     return NULL;
 129
 130   struct resolv_conf_global *global_copy = get_locked_global ();
 131   if (global_copy == NULL)
 132     return NULL;
 133   struct resolv_conf *conf;
 134   if (global_copy->conf_current != NULL
 135       && __file_is_unchanged (&initial, &global_copy->file_resolve_conf))
 136     /* We can reuse the cached configuration object.  */
 137     conf = global_copy->conf_current;
 138   else
 139     {
 140       /* Parse configuration while holding the lock.  This avoids
 141          duplicate work.  */
 142       struct file_change_detection after_load;
 143       conf = __resolv_conf_load (NULL, &after_load);
 144       if (conf != NULL)
 145         {
 146           if (global_copy->conf_current != NULL)
 147             conf_decrement (global_copy->conf_current);
 148           global_copy->conf_current = conf; /* Takes ownership.  */
 149
 150           /* Update file change detection data, but only if it matches
 151              the initial measurement.  This avoids an ABA race in case
 152              /etc/resolv.conf is temporarily replaced while the file
 153              is read (after the initial measurement), and restored to
 154              the initial version later.  */
 155           if (__file_is_unchanged (&initial, &after_load))
 156             global_copy->file_resolve_conf = after_load;
 157           else
 158             /* If there is a discrepancy, trigger a reload during the
 159                next use.  */
 160             global_copy->file_resolve_conf.size = -1;
 161         }
 162     }
 163
 164   if (conf != NULL)
 165     {
 166       /* Return an additional reference.  */
 167       assert (conf->__refcount > 0);
 168       ++conf->__refcount;
 169       assert (conf->__refcount > 0);
 170     }
 171   put_locked_global (global_copy);
 172   return conf;
 173 }
 174
 175 /* Internal implementation of __resolv_conf_get, without validation
 176    against *RESP.  */
 177 static struct resolv_conf *
 178 resolv_conf_get_1 (const struct __res_state *resp)
 179 {
 180   /* Not initialized, and therefore no associated context.  */
 181   if (!(resp->options & RES_INIT))
 182     return NULL;
 183
 184   struct resolv_conf_global *global_copy = get_locked_global ();
 185   if (global_copy == NULL)
 186     /* A memory allocation failure here means that no associated
 187        contexts exists, so returning NULL is correct.  */
 188     return NULL;
 189   size_t index = resp->_u._ext.__glibc_extension_index ^ INDEX_MAGIC;
 190   struct resolv_conf *conf = NULL;
 191   if (index < resolv_conf_array_size (&global_copy->array))
 192     {
 193       uintptr_t *slot = resolv_conf_array_at (&global_copy->array, index);
 194       if (!(*slot & 1))
 195         {
 196           conf = (struct resolv_conf *) *slot;
 197           assert (conf->__refcount > 0);
 198           ++conf->__refcount;
 199         }
 200     }
 201   put_locked_global (global_copy);
 202   return conf;
 203 }
 204
 205 /* Return true if both IPv4 addresses are equal.  */
 206 static bool
 207 same_address_v4 (const struct sockaddr_in *left,
 208                  const struct sockaddr_in *right)
 209 {
 210   return left->sin_addr.s_addr == right->sin_addr.s_addr
 211     && left->sin_port == right->sin_port;
 212 }
 213
 214 /* Return true if both IPv6 addresses are equal.  This ignores the
 215    flow label.  */
 216 static bool
 217 same_address_v6 (const struct sockaddr_in6 *left,
 218                  const struct sockaddr_in6 *right)
 219 {
 220   return memcmp (&left->sin6_addr, &right->sin6_addr,
 221                  sizeof (left->sin6_addr)) == 0
 222     && left->sin6_port == right->sin6_port
 223     && left->sin6_scope_id == right->sin6_scope_id;
 224 }
 225
 226 static bool
 227 same_address (const struct sockaddr *left, const struct sockaddr *right)
 228 {
 229   if (left->sa_family != right->sa_family)
 230     return false;
 231   switch (left->sa_family)
 232     {
 233     case AF_INET:
 234       return same_address_v4 ((const struct sockaddr_in *) left,
 235                               (const struct sockaddr_in *) right);
 236     case AF_INET6:
 237       return same_address_v6 ((const struct sockaddr_in6 *) left,
 238                               (const struct sockaddr_in6 *) right);
 239     }
 240   return false;
 241 }
 242
 243 /* Check that *RESP and CONF match.  Used by __resolv_conf_get.  */
 244 static bool
 245 resolv_conf_matches (const struct __res_state *resp,
 246                      const struct resolv_conf *conf)
 247 {
 248   /* NB: Do not compare the options, retrans, retry, ndots.  These can
 249      be changed by application.  */
 250
 251   /* Check that the name servers in *RESP have not been modified by
 252      the application.  */
 253   {
 254     size_t nserv = conf->nameserver_list_size;
 255     if (nserv > MAXNS)
 256       nserv = MAXNS;
 257     /* _ext.nscount is 0 until initialized by res_send.c.  */
 258     if (resp->nscount != nserv
 259         || (resp->_u._ext.nscount != 0 && resp->_u._ext.nscount != nserv))
 260       return false;
 261     for (size_t i = 0; i < nserv; ++i)
 262       {
 263         if (resp->nsaddr_list[i].sin_family == 0)
 264           {
 265             if (resp->_u._ext.nsaddrs[i]->sin6_family != AF_INET6)
 266               return false;
 267             if (!same_address ((struct sockaddr *) resp->_u._ext.nsaddrs[i],
 268                                conf->nameserver_list[i]))
 269               return false;
 270           }
 271         else if (resp->nsaddr_list[i].sin_family != AF_INET)
 272           return false;
 273         else if (!same_address ((struct sockaddr *) &resp->nsaddr_list[i],
 274                                 conf->nameserver_list[i]))
 275           return false;
 276       }
 277   }
 278
 279   /* Check that the search list in *RESP has not been modified by the
 280      application.  */
 281   {
 282     if (resp->dnsrch[0] == NULL)
 283       {
 284         /* Empty search list.  No default domain name.  */
 285         return conf->search_list_size == 0 && resp->defdname[0] == '\0';
 286       }
 287
 288     if (resp->dnsrch[0] != resp->defdname)
 289       /* If the search list is not empty, it must start with the
 290          default domain name.  */
 291       return false;
 292
 293     size_t nsearch;
 294     for (nsearch = 0; nsearch < MAXDNSRCH; ++nsearch)
 295       if (resp->dnsrch[nsearch] == NULL)
 296         break;
 297     if (nsearch > MAXDNSRCH)
 298       /* Search list is not null-terminated.  */
 299       return false;
 300
 301     size_t search_list_size = 0;
 302     for (size_t i = 0; i < conf->search_list_size; ++i)
 303       {
 304         if (resp->dnsrch[i] != NULL)
 305           {
 306             search_list_size += strlen (resp->dnsrch[i]) + 1;
 307             if (strcmp (resp->dnsrch[i], conf->search_list[i]) != 0)
 308               return false;
 309           }
 310         else
 311           {
 312             /* resp->dnsrch is truncated if the number of elements
 313                exceeds MAXDNSRCH, or if the combined storage space for
 314                the search list exceeds what can be stored in
 315                resp->defdname.  */
 316             if (i == MAXDNSRCH || search_list_size > sizeof (resp->dnsrch))
 317               break;
 318             /* Otherwise, a mismatch indicates a match failure.  */
 319             return false;
 320           }
 321       }
 322   }
 323
 324   /* Check that the sort list has not been modified.  */
 325   {
 326     size_t nsort = conf->sort_list_size;
 327     if (nsort > MAXRESOLVSORT)
 328       nsort = MAXRESOLVSORT;
 329     if (resp->nsort != nsort)
 330       return false;
 331     for (size_t i = 0; i < nsort; ++i)
 332       if (resp->sort_list[i].addr.s_addr != conf->sort_list[i].addr.s_addr
 333           || resp->sort_list[i].mask != conf->sort_list[i].mask)
 334         return false;
 335   }
 336
 337   return true;
 338 }
 339
 340 struct resolv_conf *
 341 __resolv_conf_get (struct __res_state *resp)
 342 {
 343   struct resolv_conf *conf = resolv_conf_get_1 (resp);
 344   if (conf == NULL)
 345     return NULL;
 346   if (resolv_conf_matches (resp, conf))
 347     return conf;
 348   __resolv_conf_put (conf);
 349   return NULL;
 350 }
 351
 352 void
 353 __resolv_conf_put (struct resolv_conf *conf)
 354 {
 355   if (conf == NULL)
 356     return;
 357
 358   __libc_lock_lock (lock);
 359   conf_decrement (conf);
 360   __libc_lock_unlock (lock);
 361 }
 362
 363 struct resolv_conf *
 364 __resolv_conf_allocate (const struct resolv_conf *init)
 365 {
 366   /* Allocate in decreasing order of alignment.  */
 367   _Static_assert (__alignof__ (const char *const *)
 368                   <= __alignof__ (struct resolv_conf), "alignment");
 369   _Static_assert (__alignof__ (struct sockaddr_in6)
 370                   <= __alignof__ (const char *const *), "alignment");
 371   _Static_assert (__alignof__ (struct sockaddr_in)
 372                   ==  __alignof__ (struct sockaddr_in6), "alignment");
 373   _Static_assert (__alignof__ (struct resolv_sortlist_entry)
 374                   <= __alignof__ (struct sockaddr_in), "alignment");
 375
 376   /* Space needed by the nameserver addresses.  */
 377   size_t address_space = 0;
 378   for (size_t i = 0; i < init->nameserver_list_size; ++i)
 379     if (init->nameserver_list[i]->sa_family == AF_INET)
 380       address_space += sizeof (struct sockaddr_in);
 381     else
 382       {
 383         assert (init->nameserver_list[i]->sa_family == AF_INET6);
 384         address_space += sizeof (struct sockaddr_in6);
 385       }
 386
 387   /* Space needed by the search list strings.  */
 388   size_t string_space = 0;
 389   for (size_t i = 0; i < init->search_list_size; ++i)
 390     string_space += strlen (init->search_list[i]) + 1;
 391
 392   /* Allocate the buffer.  */
 393   void *ptr;
 394   struct alloc_buffer buffer = alloc_buffer_allocate
 395     (sizeof (struct resolv_conf)
 396      + init->nameserver_list_size * sizeof (init->nameserver_list[0])
 397      + address_space
 398      + init->search_list_size * sizeof (init->search_list[0])
 399      + init->sort_list_size * sizeof (init->sort_list[0])
 400      + string_space,
 401      &ptr);
 402   struct resolv_conf *conf
 403     = alloc_buffer_alloc (&buffer, struct resolv_conf);
 404   if (conf == NULL)
 405     /* Memory allocation failure.  */
 406     return NULL;
 407   assert (conf == ptr);
 408
 409   /* Initialize the contents.  */
 410   conf->__refcount = 1;
 411   conf->retrans = init->retrans;
 412   conf->retry = init->retry;
 413   conf->options = init->options;
 414   conf->ndots = init->ndots;
 415
 416   /* Allocate the arrays with pointers.  These must come first because
 417      they have the highets alignment.  */
 418   conf->nameserver_list_size = init->nameserver_list_size;
 419   const struct sockaddr **nameserver_array = alloc_buffer_alloc_array
 420     (&buffer, const struct sockaddr *, init->nameserver_list_size);
 421   conf->nameserver_list = nameserver_array;
 422
 423   conf->search_list_size = init->search_list_size;
 424   const char **search_array = alloc_buffer_alloc_array
 425     (&buffer, const char *, init->search_list_size);
 426   conf->search_list = search_array;
 427
 428   /* Fill the name server list array.  */
 429   for (size_t i = 0; i < init->nameserver_list_size; ++i)
 430     if (init->nameserver_list[i]->sa_family == AF_INET)
 431       {
 432         struct sockaddr_in *sa = alloc_buffer_alloc
 433           (&buffer, struct sockaddr_in);
 434         *sa = *(struct sockaddr_in *) init->nameserver_list[i];
 435         nameserver_array[i] = (struct sockaddr *) sa;
 436       }
 437     else
 438       {
 439         struct sockaddr_in6 *sa = alloc_buffer_alloc
 440           (&buffer, struct sockaddr_in6);
 441         *sa = *(struct sockaddr_in6 *) init->nameserver_list[i];
 442         nameserver_array[i] = (struct sockaddr *) sa;
 443       }
 444
 445   /* Allocate and fill the sort list array.  */
 446   {
 447     conf->sort_list_size = init->sort_list_size;
 448     struct resolv_sortlist_entry *array = alloc_buffer_alloc_array
 449       (&buffer, struct resolv_sortlist_entry, init->sort_list_size);
 450     conf->sort_list = array;
 451     for (size_t i = 0; i < init->sort_list_size; ++i)
 452       array[i] = init->sort_list[i];
 453   }
 454
 455   /* Fill the search list array.  This must come last because the
 456      strings are the least aligned part of the allocation.  */
 457   {
 458     for (size_t i = 0; i < init->search_list_size; ++i)
 459       search_array[i] = alloc_buffer_copy_string
 460         (&buffer, init->search_list[i]);
 461   }
 462
 463   assert (!alloc_buffer_has_failed (&buffer));
 464   return conf;
 465 }
 466
 467 /* Update *RESP from the extended state.  */
 468 static __attribute__ ((nonnull (1, 2), warn_unused_result)) bool
 469 update_from_conf (struct __res_state *resp, const struct resolv_conf *conf)
 470 {
 471   resp->defdname[0] = '\0';
 472   resp->pfcode = 0;
 473   resp->_vcsock = -1;
 474   resp->_flags = 0;
 475   resp->ipv6_unavail = false;
 476   resp->__glibc_unused_qhook = NULL;
 477   resp->__glibc_unused_rhook = NULL;
 478
 479   resp->retrans = conf->retrans;
 480   resp->retry = conf->retry;
 481   resp->options = conf->options;
 482   resp->ndots = conf->ndots;
 483
 484   /* Copy the name server addresses.  */
 485   {
 486     resp->nscount = 0;
 487     resp->_u._ext.nscount = 0;
 488     size_t nserv = conf->nameserver_list_size;
 489     if (nserv > MAXNS)
 490       nserv = MAXNS;
 491     for (size_t i = 0; i < nserv; i++)
 492       {
 493         if (conf->nameserver_list[i]->sa_family == AF_INET)
 494           {
 495             resp->nsaddr_list[i]
 496               = *(struct sockaddr_in *)conf->nameserver_list[i];
 497             resp->_u._ext.nsaddrs[i] = NULL;
 498           }
 499         else
 500           {
 501             assert (conf->nameserver_list[i]->sa_family == AF_INET6);
 502             resp->nsaddr_list[i].sin_family = 0;
 503             /* Make a defensive copy of the name server address, in
 504                case the application overwrites it.  */
 505             struct sockaddr_in6 *sa = malloc (sizeof (*sa));
 506             if (sa == NULL)
 507               {
 508                 for (size_t j = 0; j < i; ++j)
 509                   free (resp->_u._ext.nsaddrs[j]);
 510                 return false;
 511               }
 512             *sa = *(struct sockaddr_in6 *)conf->nameserver_list[i];
 513             resp->_u._ext.nsaddrs[i] = sa;
 514           }
 515         resp->_u._ext.nssocks[i] = -1;
 516       }
 517     resp->nscount = nserv;
 518     /* Leave resp->_u._ext.nscount at 0.  res_send.c handles this.  */
 519   }
 520
 521   /* Fill in the prefix of the search list.  It is truncated either at
 522      MAXDNSRCH, or if reps->defdname has insufficient space.  */
 523   {
 524     struct alloc_buffer buffer
 525       = alloc_buffer_create (resp->defdname, sizeof (resp->defdname));
 526     size_t size = conf->search_list_size;
 527     size_t i;
 528     for (i = 0; i < size && i < MAXDNSRCH; ++i)
 529       {
 530         resp->dnsrch[i] = alloc_buffer_copy_string
 531           (&buffer, conf->search_list[i]);
 532         if (resp->dnsrch[i] == NULL)
 533           /* No more space in resp->defdname.  Truncate.  */
 534           break;
 535       }
 536     resp->dnsrch[i] = NULL;
 537   }
 538
 539   /* Copy the sort list.  */
 540   {
 541     size_t nsort = conf->sort_list_size;
 542     if (nsort > MAXRESOLVSORT)
 543       nsort = MAXRESOLVSORT;
 544     for (size_t i = 0; i < nsort; ++i)
 545       {
 546         resp->sort_list[i].addr = conf->sort_list[i].addr;
 547         resp->sort_list[i].mask = conf->sort_list[i].mask;
 548       }
 549     resp->nsort = nsort;
 550   }
 551
 552   /* The overlapping parts of both configurations should agree after
 553      initialization.  */
 554   assert (resolv_conf_matches (resp, conf));
 555   return true;
 556 }
 557
 558 /* Decrement the configuration object at INDEX and free it if the
 559    reference counter reaches 0.  *GLOBAL_COPY must be locked and
 560    remains so.  */
 561 static void
 562 decrement_at_index (struct resolv_conf_global *global_copy, size_t index)
 563 {
 564   if (index < resolv_conf_array_size (&global_copy->array))
 565     {
 566       /* Index found.  */
 567       uintptr_t *slot = resolv_conf_array_at (&global_copy->array, index);
 568       /* Check that the slot is not already part of the free list.  */
 569       if (!(*slot & 1))
 570         {
 571           struct resolv_conf *conf = (struct resolv_conf *) *slot;
 572           conf_decrement (conf);
 573           /* Put the slot onto the free list.  */
 574           *slot = global_copy->free_list_start;
 575           global_copy->free_list_start = (index << 1) | 1;
 576         }
 577     }
 578 }
 579
 580 bool
 581 __resolv_conf_attach (struct __res_state *resp, struct resolv_conf *conf)
 582 {
 583   assert (conf->__refcount > 0);
 584
 585   struct resolv_conf_global *global_copy = get_locked_global ();
 586   if (global_copy == NULL)
 587     return false;
 588
 589   /* Try to find an unused index in the array.  */
 590   size_t index;
 591   {
 592     if (global_copy->free_list_start & 1)
 593       {
 594         /* Unlink from the free list.  */
 595         index = global_copy->free_list_start >> 1;
 596         uintptr_t *slot = resolv_conf_array_at (&global_copy->array, index);
 597         global_copy->free_list_start = *slot;
 598         assert (global_copy->free_list_start == 0
 599                 || global_copy->free_list_start & 1);
 600         /* Install the configuration pointer.  */
 601         *slot = (uintptr_t) conf;
 602       }
 603     else
 604       {
 605         size_t size = resolv_conf_array_size (&global_copy->array);
 606         /* No usable index found.  Increase the array size.  */
 607         resolv_conf_array_add (&global_copy->array, (uintptr_t) conf);
 608         if (resolv_conf_array_has_failed (&global_copy->array))
 609           {
 610             put_locked_global (global_copy);
 611             __set_errno (ENOMEM);
 612             return false;
 613           }
 614         /* The new array element was added at the end.  */
 615         index = size;
 616       }
 617   }
 618
 619   /* We have added a new reference to the object.  */
 620   ++conf->__refcount;
 621   assert (conf->__refcount > 0);
 622   put_locked_global (global_copy);
 623
 624   if (!update_from_conf (resp, conf))
 625     {
 626       /* Drop the reference we acquired.  Reacquire the lock.  The
 627          object has already been allocated, so it cannot be NULL this
 628          time.  */
 629       global_copy = get_locked_global ();
 630       decrement_at_index (global_copy, index);
 631       put_locked_global (global_copy);
 632       return false;
 633     }
 634   resp->_u._ext.__glibc_extension_index = index ^ INDEX_MAGIC;
 635
 636   return true;
 637 }
 638
 639 void
 640 __resolv_conf_detach (struct __res_state *resp)
 641 {
 642   if (atomic_load_relaxed (&global) == NULL)
 643     /* Detach operation after a shutdown, or without any prior
 644        attachment.  We cannot free the data (and there might not be
 645        anything to free anyway).  */
 646     return;
 647
 648   struct resolv_conf_global *global_copy = get_locked_global ();
 649   size_t index = resp->_u._ext.__glibc_extension_index ^ INDEX_MAGIC;
 650   decrement_at_index (global_copy, index);
 651
 652   /* Clear the index field, so that accidental reuse is less
 653      likely.  */
 654   resp->_u._ext.__glibc_extension_index = 0;
 655
 656   put_locked_global (global_copy);
 657 }
 658
 659 /* Deallocate the global data.  */
 660 void
 661 __libc_resolv_conf_freemem (void)
 662 {
 663   /* No locking because this function is supposed to be called when
 664      the process has turned single-threaded.  */
 665   if (global == NULL)
 666     return;
 667
 668   if (global->conf_current != NULL)
 669     {
 670       conf_decrement (global->conf_current);
 671       global->conf_current = NULL;
 672     }
 673
 674   /* Note that this frees only the array itself.  The pointed-to
 675      configuration objects should have been deallocated by res_nclose
 676      and per-thread cleanup functions.  */
 677   resolv_conf_array_free (&global->array);
 678
 679   free (global);
 680
 681   /* Stop potential future __resolv_conf_detach calls from accessing
 682      deallocated memory.  */
 683   global = NULL;
 684 }