blob: 04abcb18552a65c9a452a6519862f42376290df5 [file] [log] [blame]
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/dns_reloader.h"
#if defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) && \
#include <resolv.h>
#include "base/basictypes.h"
#include "base/lazy_instance.h"
#include "base/logging.h"
#include "base/message_loop/message_loop.h"
#include "base/synchronization/lock.h"
#include "base/threading/thread_local_storage.h"
#include "net/base/network_change_notifier.h"
namespace {
// On Linux/BSD, changes to /etc/resolv.conf can go unnoticed thus resulting
// in DNS queries failing either because nameservers are unknown on startup
// or because nameserver info has changed as a result of e.g. connecting to
// a new network. Some distributions patch glibc to stat /etc/resolv.conf
// to try to automatically detect such changes but these patches are not
// universal and even patched systems such as Jaunty appear to need calls
// to res_ninit to reload the nameserver information in different threads.
// To fix this, on systems with FilePathWatcher support, we use
// NetworkChangeNotifier::DNSObserver to monitor /etc/resolv.conf to
// enable us to respond to DNS changes and reload the resolver state.
// OpenBSD does not have thread-safe res_ninit/res_nclose so we can't do
// the same trick there and most *BSD's don't yet have support for
// FilePathWatcher (but perhaps the new kqueue mac code just needs to be
// ported to *BSD to support that).
// Android does not have /etc/resolv.conf. The system takes care of nameserver
// changes, so none of this is needed.
class DnsReloader : public net::NetworkChangeNotifier::DNSObserver {
struct ReloadState {
int resolver_generation;
// NetworkChangeNotifier::DNSObserver:
virtual void OnDNSChanged() OVERRIDE {
base::AutoLock l(lock_);
void MaybeReload() {
ReloadState* reload_state = static_cast<ReloadState*>(tls_index_.Get());
base::AutoLock l(lock_);
if (!reload_state) {
reload_state = new ReloadState();
reload_state->resolver_generation = resolver_generation_;
} else if (reload_state->resolver_generation != resolver_generation_) {
reload_state->resolver_generation = resolver_generation_;
// It is safe to call res_nclose here since we know res_ninit will have
// been called above.
// Free the allocated state.
static void SlotReturnFunction(void* data) {
ReloadState* reload_state = static_cast<ReloadState*>(data);
if (reload_state)
delete reload_state;
DnsReloader() : resolver_generation_(0) {
virtual ~DnsReloader() {
NOTREACHED(); // LeakyLazyInstance is not destructed.
base::Lock lock_; // Protects resolver_generation_.
int resolver_generation_;
friend struct base::DefaultLazyInstanceTraits<DnsReloader>;
// We use thread local storage to identify which ReloadState to interact with.
static base::ThreadLocalStorage::StaticSlot tls_index_;
// A TLS slot to the ReloadState for the current thread.
// static
base::ThreadLocalStorage::StaticSlot DnsReloader::tls_index_ = TLS_INITIALIZER;
} // namespace
namespace net {
void EnsureDnsReloaderInit() {
DnsReloader* t ALLOW_UNUSED = g_dns_reloader.Pointer();
void DnsReloaderMaybeReload() {
// This routine can be called by any of the DNS worker threads.
DnsReloader* dns_reloader = g_dns_reloader.Pointer();
} // namespace net
#endif // defined(OS_POSIX) && !defined(OS_MACOSX) && !defined(OS_OPENBSD) &&
// !defined(OS_ANDROID)