dns_reloader.cc revision 90dce4d38c5ff5333bea97d859d4e484e27edf0c
1// Copyright (c) 2012 The Chromium Authors. All rights reserved.
2// Use of this source code is governed by a BSD-style license that can be
3// found in the LICENSE file.
4
5#include "net/base/dns_reloader.h"
6
7#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) && \
8    !defined(OS_ANDROID)
9
10#include <resolv.h>
11
12#include "base/basictypes.h"
13#include "base/lazy_instance.h"
14#include "base/logging.h"
15#include "base/message_loop.h"
16#include "base/synchronization/lock.h"
17#include "base/threading/thread_local_storage.h"
18#include "net/base/network_change_notifier.h"
19
20namespace {
21
22// On Linux/BSD, changes to /etc/resolv.conf can go unnoticed thus resulting
23// in DNS queries failing either because nameservers are unknown on startup
24// or because nameserver info has changed as a result of e.g. connecting to
25// a new network. Some distributions patch glibc to stat /etc/resolv.conf
26// to try to automatically detect such changes but these patches are not
27// universal and even patched systems such as Jaunty appear to need calls
28// to res_ninit to reload the nameserver information in different threads.
29//
30// To fix this, on systems with FilePathWatcher support, we use
31// NetworkChangeNotifier::DNSObserver to monitor /etc/resolv.conf to
32// enable us to respond to DNS changes and reload the resolver state.
33//
34// OpenBSD does not have thread-safe res_ninit/res_nclose so we can't do
35// the same trick there and most *BSD's don't yet have support for
36// FilePathWatcher (but perhaps the new kqueue mac code just needs to be
37// ported to *BSD to support that).
38//
39// Android does not have /etc/resolv.conf. The system takes care of nameserver
40// changes, so none of this is needed.
41
42class DnsReloader : public net::NetworkChangeNotifier::DNSObserver {
43 public:
44  struct ReloadState {
45    int resolver_generation;
46  };
47
48  // NetworkChangeNotifier::DNSObserver:
49  virtual void OnDNSChanged() OVERRIDE {
50    DCHECK_EQ(base::MessageLoop::current()->type(), base::MessageLoop::TYPE_IO);
51    base::AutoLock l(lock_);
52    resolver_generation_++;
53  }
54
55  void MaybeReload() {
56    ReloadState* reload_state = static_cast<ReloadState*>(tls_index_.Get());
57    base::AutoLock l(lock_);
58
59    if (!reload_state) {
60      reload_state = new ReloadState();
61      reload_state->resolver_generation = resolver_generation_;
62      res_ninit(&_res);
63      tls_index_.Set(reload_state);
64    } else if (reload_state->resolver_generation != resolver_generation_) {
65      reload_state->resolver_generation = resolver_generation_;
66      // It is safe to call res_nclose here since we know res_ninit will have
67      // been called above.
68      res_nclose(&_res);
69      res_ninit(&_res);
70    }
71  }
72
73  // Free the allocated state.
74  static void SlotReturnFunction(void* data) {
75    ReloadState* reload_state = static_cast<ReloadState*>(data);
76    if (reload_state)
77      res_nclose(&_res);
78    delete reload_state;
79  }
80
81 private:
82  DnsReloader() : resolver_generation_(0) {
83    tls_index_.Initialize(SlotReturnFunction);
84    net::NetworkChangeNotifier::AddDNSObserver(this);
85  }
86
87  virtual ~DnsReloader() {
88    NOTREACHED();  // LeakyLazyInstance is not destructed.
89  }
90
91  base::Lock lock_;  // Protects resolver_generation_.
92  int resolver_generation_;
93  friend struct base::DefaultLazyInstanceTraits<DnsReloader>;
94
95  // We use thread local storage to identify which ReloadState to interact with.
96  static base::ThreadLocalStorage::StaticSlot tls_index_;
97
98  DISALLOW_COPY_AND_ASSIGN(DnsReloader);
99};
100
101// A TLS slot to the ReloadState for the current thread.
102// static
103base::ThreadLocalStorage::StaticSlot DnsReloader::tls_index_ = TLS_INITIALIZER;
104
105base::LazyInstance<DnsReloader>::Leaky
106    g_dns_reloader = LAZY_INSTANCE_INITIALIZER;
107
108}  // namespace
109
110namespace net {
111
112void EnsureDnsReloaderInit() {
113  DnsReloader* t ALLOW_UNUSED = g_dns_reloader.Pointer();
114}
115
116void DnsReloaderMaybeReload() {
117  // This routine can be called by any of the DNS worker threads.
118  DnsReloader* dns_reloader = g_dns_reloader.Pointer();
119  dns_reloader->MaybeReload();
120}
121
122}  // namespace net
123
124#endif  // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) &&
125        // !defined(OS_ANDROID)
126