werunplugged/unplugged-system
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
main
unplugged-system/external/cronet/net/base/address_tracker_linux.cc

696 lines
24 KiB
C++
Raw Permalink Blame History

// Copyright 2012 The Chromium Authors
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "net/base/address_tracker_linux.h"
#include <errno.h>
#include <linux/if.h>
#include <stdint.h>
#include <sys/ioctl.h>
#include <vector>
#include <utility>
#include "base/check.h"
#include "base/dcheck_is_on.h"
#include "base/files/scoped_file.h"
#include "base/functional/bind.h"
#include "base/functional/callback_helpers.h"
#include "base/logging.h"
#include "base/memory/page_size.h"
#include "base/posix/eintr_wrapper.h"
#include "base/sequence_checker.h"
#include "base/task/current_thread.h"
#include "base/threading/scoped_blocking_call.h"
#include "base/threading/thread_restrictions.h"
#include "build/build_config.h"
#include "net/base/network_interfaces_linux.h"
#include "third_party/abseil-cpp/absl/types/optional.h"
#if BUILDFLAG(IS_ANDROID)
#include "base/android/build_info.h"
#endif
namespace net::internal {
namespace {
// Some kernel functions such as wireless_send_event and rtnetlink_ifinfo_prep
// may send spurious messages over rtnetlink. RTM_NEWLINK messages where
// ifi_change == 0 and rta_type == IFLA_WIRELESS should be ignored.
bool IgnoreWirelessChange(const struct ifinfomsg* msg, int length) {
for (const struct rtattr* attr = IFLA_RTA(msg); RTA_OK(attr, length);
attr = RTA_NEXT(attr, length)) {
if (attr->rta_type == IFLA_WIRELESS && msg->ifi_change == 0)
return true;
}
return false;
}
// Retrieves address from NETLINK address message.
// Sets |really_deprecated| for IPv6 addresses with preferred lifetimes of 0.
// Precondition: |header| must already be validated with NLMSG_OK.
bool GetAddress(const struct nlmsghdr* header,
int header_length,
IPAddress* out,
bool* really_deprecated) {
if (really_deprecated)
*really_deprecated = false;
// Extract the message and update |header_length| to be the number of
// remaining bytes.
const struct ifaddrmsg* msg =
reinterpret_cast<const struct ifaddrmsg*>(NLMSG_DATA(header));
header_length -= NLMSG_HDRLEN;
size_t address_length = 0;
switch (msg->ifa_family) {
case AF_INET:
address_length = IPAddress::kIPv4AddressSize;
break;
case AF_INET6:
address_length = IPAddress::kIPv6AddressSize;
break;
default:
// Unknown family.
return false;
}
// Use IFA_ADDRESS unless IFA_LOCAL is present. This behavior here is based on
// getaddrinfo in glibc (check_pf.c). Judging from kernel implementation of
// NETLINK, IPv4 addresses have only the IFA_ADDRESS attribute, while IPv6
// have the IFA_LOCAL attribute.
uint8_t* address = nullptr;
uint8_t* local = nullptr;
int length = IFA_PAYLOAD(header);
if (length > header_length) {
LOG(ERROR) << "ifaddrmsg length exceeds bounds";
return false;
}
for (const struct rtattr* attr =
reinterpret_cast<const struct rtattr*>(IFA_RTA(msg));
RTA_OK(attr, length); attr = RTA_NEXT(attr, length)) {
switch (attr->rta_type) {
case IFA_ADDRESS:
if (RTA_PAYLOAD(attr) < address_length) {
LOG(ERROR) << "attr does not have enough bytes to read an address";
return false;
}
address = reinterpret_cast<uint8_t*>(RTA_DATA(attr));
break;
case IFA_LOCAL:
if (RTA_PAYLOAD(attr) < address_length) {
LOG(ERROR) << "attr does not have enough bytes to read an address";
return false;
}
local = reinterpret_cast<uint8_t*>(RTA_DATA(attr));
break;
case IFA_CACHEINFO: {
if (RTA_PAYLOAD(attr) < sizeof(struct ifa_cacheinfo)) {
LOG(ERROR)
<< "attr does not have enough bytes to read an ifa_cacheinfo";
return false;
}
const struct ifa_cacheinfo* cache_info =
reinterpret_cast<const struct ifa_cacheinfo*>(RTA_DATA(attr));
if (really_deprecated)
*really_deprecated = (cache_info->ifa_prefered == 0);
} break;
default:
break;
}
}
if (local)
address = local;
if (!address)
return false;
*out = IPAddress(address, address_length);
return true;
}
// SafelyCastNetlinkMsgData<T> performs a bounds check before casting |header|'s
// data to a |T*|. When the bounds check fails, returns nullptr.
template <typename T>
T* SafelyCastNetlinkMsgData(const struct nlmsghdr* header, int length) {
DCHECK(NLMSG_OK(header, static_cast<__u32>(length)));
if (length <= 0 || static_cast<size_t>(length) < NLMSG_HDRLEN + sizeof(T))
return nullptr;
return reinterpret_cast<const T*>(NLMSG_DATA(header));
}
} // namespace
// static
char* AddressTrackerLinux::GetInterfaceName(int interface_index, char* buf) {
memset(buf, 0, IFNAMSIZ);
base::ScopedFD ioctl_socket = GetSocketForIoctl();
if (!ioctl_socket.is_valid())
return buf;
struct ifreq ifr = {};
ifr.ifr_ifindex = interface_index;
if (ioctl(ioctl_socket.get(), SIOCGIFNAME, &ifr) == 0)
strncpy(buf, ifr.ifr_name, IFNAMSIZ - 1);
return buf;
}
AddressTrackerLinux::AddressTrackerLinux()
: get_interface_name_(GetInterfaceName),
address_callback_(base::DoNothing()),
link_callback_(base::DoNothing()),
tunnel_callback_(base::DoNothing()),
ignored_interfaces_(),
connection_type_initialized_cv_(&connection_type_lock_),
tracking_(false) {}
AddressTrackerLinux::AddressTrackerLinux(
const base::RepeatingClosure& address_callback,
const base::RepeatingClosure& link_callback,
const base::RepeatingClosure& tunnel_callback,
const std::unordered_set<std::string>& ignored_interfaces,
scoped_refptr<base::SequencedTaskRunner> blocking_thread_runner)
: get_interface_name_(GetInterfaceName),
address_callback_(address_callback),
link_callback_(link_callback),
tunnel_callback_(tunnel_callback),
ignored_interfaces_(ignored_interfaces),
connection_type_initialized_cv_(&connection_type_lock_),
tracking_(true),
sequenced_task_runner_(std::move(blocking_thread_runner)) {
DCHECK(!address_callback.is_null());
DCHECK(!link_callback.is_null());
DETACH_FROM_SEQUENCE(sequence_checker_);
}
AddressTrackerLinux::~AddressTrackerLinux() = default;
void AddressTrackerLinux::InitWithFdForTesting(base::ScopedFD fd) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
netlink_fd_ = std::move(fd);
DumpInitialAddressesAndWatch();
}
void AddressTrackerLinux::Init() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
#if BUILDFLAG(IS_ANDROID)
// RTM_GETLINK stopped working in Android 11 (see
// https://developer.android.com/preview/privacy/mac-address),
// so AddressTrackerLinux should not be used in later versions
// of Android. Chromium code doesn't need it past Android P.
DCHECK_LT(base::android::BuildInfo::GetInstance()->sdk_int(),
base::android::SDK_VERSION_P);
#endif
netlink_fd_.reset(socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE));
if (!netlink_fd_.is_valid()) {
PLOG(ERROR) << "Could not create NETLINK socket";
AbortAndForceOnline();
return;
}
int rv;
if (tracking_) {
// Request notifications.
struct sockaddr_nl addr = {};
addr.nl_family = AF_NETLINK;
addr.nl_pid = 0; // Let the kernel select a unique value.
// TODO(szym): Track RTMGRP_LINK as well for ifi_type,
// http://crbug.com/113993
addr.nl_groups =
RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_NOTIFY | RTMGRP_LINK;
rv = bind(netlink_fd_.get(), reinterpret_cast<struct sockaddr*>(&addr),
sizeof(addr));
if (rv < 0) {
PLOG(ERROR) << "Could not bind NETLINK socket";
AbortAndForceOnline();
return;
}
}
DumpInitialAddressesAndWatch();
}
bool AddressTrackerLinux::DidTrackingInitSucceedForTesting() const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
CHECK(tracking_);
return watcher_ != nullptr;
}
void AddressTrackerLinux::AbortAndForceOnline() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
watcher_.reset();
netlink_fd_.reset();
AddressTrackerAutoLock lock(*this, connection_type_lock_);
current_connection_type_ = NetworkChangeNotifier::CONNECTION_UNKNOWN;
connection_type_initialized_ = true;
connection_type_initialized_cv_.Broadcast();
}
AddressTrackerLinux::AddressMap AddressTrackerLinux::GetAddressMap() const {
AddressTrackerAutoLock lock(*this, address_map_lock_);
return address_map_;
}
std::unordered_set<int> AddressTrackerLinux::GetOnlineLinks() const {
AddressTrackerAutoLock lock(*this, online_links_lock_);
return online_links_;
}
AddressTrackerLinux* AddressTrackerLinux::GetAddressTrackerLinux() {
return this;
}
std::pair<AddressTrackerLinux::AddressMap, std::unordered_set<int>>
AddressTrackerLinux::GetInitialDataAndStartRecordingDiffs() {
DCHECK(tracking_);
AddressTrackerAutoLock lock_address_map(*this, address_map_lock_);
AddressTrackerAutoLock lock_online_links(*this, online_links_lock_);
address_map_diff_ = AddressMapDiff();
online_links_diff_ = OnlineLinksDiff();
return {address_map_, online_links_};
}
void AddressTrackerLinux::SetDiffCallback(DiffCallback diff_callback) {
DCHECK(tracking_);
DCHECK(sequenced_task_runner_);
if (!sequenced_task_runner_->RunsTasksInCurrentSequence()) {
sequenced_task_runner_->PostTask(
FROM_HERE, base::BindOnce(&AddressTrackerLinux::SetDiffCallback,
weak_ptr_factory_.GetWeakPtr(),
std::move(diff_callback)));
return;
}
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
#if DCHECK_IS_ON()
{
// GetInitialDataAndStartRecordingDiffs() must be called before
// SetDiffCallback().
AddressTrackerAutoLock lock_address_map(*this, address_map_lock_);
AddressTrackerAutoLock lock_online_links(*this, online_links_lock_);
DCHECK(address_map_diff_.has_value());
DCHECK(online_links_diff_.has_value());
}
#endif // DCHECK_IS_ON()
diff_callback_ = std::move(diff_callback);
RunDiffCallback();
}
bool AddressTrackerLinux::IsInterfaceIgnored(int interface_index) const {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
if (ignored_interfaces_.empty())
return false;
char buf[IFNAMSIZ] = {0};
const char* interface_name = get_interface_name_(interface_index, buf);
return ignored_interfaces_.find(interface_name) != ignored_interfaces_.end();
}
NetworkChangeNotifier::ConnectionType
AddressTrackerLinux::GetCurrentConnectionType() {
// http://crbug.com/125097
base::ScopedAllowBaseSyncPrimitivesOutsideBlockingScope allow_wait;
AddressTrackerAutoLock lock(*this, connection_type_lock_);
// Make sure the initial connection type is set before returning.
threads_waiting_for_connection_type_initialization_++;
while (!connection_type_initialized_) {
connection_type_initialized_cv_.Wait();
}
threads_waiting_for_connection_type_initialization_--;
return current_connection_type_;
}
void AddressTrackerLinux::DumpInitialAddressesAndWatch() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
// Request dump of addresses.
struct sockaddr_nl peer = {};
peer.nl_family = AF_NETLINK;
struct {
struct nlmsghdr header;
struct rtgenmsg msg;
} request = {};
request.header.nlmsg_len = NLMSG_LENGTH(sizeof(request.msg));
request.header.nlmsg_type = RTM_GETADDR;
request.header.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
request.header.nlmsg_pid = 0; // This field is opaque to netlink.
request.msg.rtgen_family = AF_UNSPEC;
int rv = HANDLE_EINTR(
sendto(netlink_fd_.get(), &request, request.header.nlmsg_len, 0,
reinterpret_cast<struct sockaddr*>(&peer), sizeof(peer)));
if (rv < 0) {
PLOG(ERROR) << "Could not send NETLINK request";
AbortAndForceOnline();
return;
}
// Consume pending message to populate the AddressMap, but don't notify.
// Sending another request without first reading responses results in EBUSY.
bool address_changed;
bool link_changed;
bool tunnel_changed;
ReadMessages(&address_changed, &link_changed, &tunnel_changed);
// Request dump of link state
request.header.nlmsg_type = RTM_GETLINK;
rv = HANDLE_EINTR(
sendto(netlink_fd_.get(), &request, request.header.nlmsg_len, 0,
reinterpret_cast<struct sockaddr*>(&peer), sizeof(peer)));
if (rv < 0) {
PLOG(ERROR) << "Could not send NETLINK request";
AbortAndForceOnline();
return;
}
// Consume pending message to populate links_online_, but don't notify.
ReadMessages(&address_changed, &link_changed, &tunnel_changed);
{
AddressTrackerAutoLock lock(*this, connection_type_lock_);
connection_type_initialized_ = true;
connection_type_initialized_cv_.Broadcast();
}
if (tracking_) {
DCHECK(!sequenced_task_runner_ ||
sequenced_task_runner_->RunsTasksInCurrentSequence());
watcher_ = base::FileDescriptorWatcher::WatchReadable(
netlink_fd_.get(),
base::BindRepeating(&AddressTrackerLinux::OnFileCanReadWithoutBlocking,
base::Unretained(this)));
}
}
void AddressTrackerLinux::ReadMessages(bool* address_changed,
bool* link_changed,
bool* tunnel_changed) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
*address_changed = false;
*link_changed = false;
*tunnel_changed = false;
bool first_loop = true;
// Varying sources have different opinions regarding the buffer size needed
// for netlink messages to avoid truncation:
// - The official documentation on netlink says messages are generally 8kb
// or the system page size, whichever is *larger*:
// https://www.kernel.org/doc/html/v6.2/userspace-api/netlink/intro.html#buffer-sizing
// - The kernel headers would imply that messages are generally the system
// page size or 8kb, whichever is *smaller*:
// https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git/tree/include/linux/netlink.h?h=v6.2.2#n226
// (libmnl follows this.)
// - The netlink(7) man page's example always uses a fixed size 8kb buffer:
// https://man7.org/linux/man-pages/man7/netlink.7.html
// Here, we follow the guidelines in the documentation, for two primary
// reasons:
// - Erring on the side of a larger size is the safer way to go to avoid
// MSG_TRUNC.
// - Since this is heap-allocated anyway, there's no risk to the stack by
// using the larger size.
constexpr size_t kMinNetlinkBufferSize = 8 * 1024;
std::vector<char> buffer(
std::max(base::GetPageSize(), kMinNetlinkBufferSize));
{
absl::optional<base::ScopedBlockingCall> blocking_call;
if (tracking_) {
// If the loop below takes a long time to run, a new thread should added
// to the current thread pool to ensure forward progress of all tasks.
blocking_call.emplace(FROM_HERE, base::BlockingType::MAY_BLOCK);
}
for (;;) {
int rv =
HANDLE_EINTR(recv(netlink_fd_.get(), buffer.data(), buffer.size(),
// Block the first time through loop.
first_loop ? 0 : MSG_DONTWAIT));
first_loop = false;
if (rv == 0) {
LOG(ERROR) << "Unexpected shutdown of NETLINK socket.";
return;
}
if (rv < 0) {
if ((errno == EAGAIN) || (errno == EWOULDBLOCK))
break;
PLOG(ERROR) << "Failed to recv from netlink socket";
return;
}
HandleMessage(buffer.data(), rv, address_changed, link_changed,
tunnel_changed);
}
}
if (*link_changed || *address_changed)
UpdateCurrentConnectionType();
}
void AddressTrackerLinux::HandleMessage(const char* buffer,
int length,
bool* address_changed,
bool* link_changed,
bool* tunnel_changed) {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(buffer);
// Note that NLMSG_NEXT decrements |length| to reflect the number of bytes
// remaining in |buffer|.
for (const struct nlmsghdr* header =
reinterpret_cast<const struct nlmsghdr*>(buffer);
length >= 0 && NLMSG_OK(header, static_cast<__u32>(length));
header = NLMSG_NEXT(header, length)) {
// The |header| pointer should never precede |buffer|.
DCHECK_LE(buffer, reinterpret_cast<const char*>(header));
switch (header->nlmsg_type) {
case NLMSG_DONE:
return;
case NLMSG_ERROR: {
const struct nlmsgerr* msg =
SafelyCastNetlinkMsgData<const struct nlmsgerr>(header, length);
if (msg == nullptr)
return;
LOG(ERROR) << "Unexpected netlink error " << msg->error << ".";
} return;
case RTM_NEWADDR: {
IPAddress address;
bool really_deprecated;
const struct ifaddrmsg* msg =
SafelyCastNetlinkMsgData<const struct ifaddrmsg>(header, length);
if (msg == nullptr)
return;
if (IsInterfaceIgnored(msg->ifa_index))
break;
if (GetAddress(header, length, &address, &really_deprecated)) {
struct ifaddrmsg msg_copy = *msg;
AddressTrackerAutoLock lock(*this, address_map_lock_);
// Routers may frequently (every few seconds) output the IPv6 ULA
// prefix which can cause the linux kernel to frequently output two
// back-to-back messages, one without the deprecated flag and one with
// the deprecated flag but both with preferred lifetimes of 0. Avoid
// interpreting this as an actual change by canonicalizing the two
// messages by setting the deprecated flag based on the preferred
// lifetime also. http://crbug.com/268042
if (really_deprecated)
msg_copy.ifa_flags |= IFA_F_DEPRECATED;
// Only indicate change if the address is new or ifaddrmsg info has
// changed.
auto it = address_map_.find(address);
if (it == address_map_.end()) {
address_map_.insert(it, std::make_pair(address, msg_copy));
*address_changed = true;
} else if (memcmp(&it->second, &msg_copy, sizeof(msg_copy))) {
it->second = msg_copy;
*address_changed = true;
}
if (*address_changed && address_map_diff_.has_value()) {
(*address_map_diff_)[address] = msg_copy;
}
}
} break;
case RTM_DELADDR: {
IPAddress address;
const struct ifaddrmsg* msg =
SafelyCastNetlinkMsgData<const struct ifaddrmsg>(header, length);
if (msg == nullptr)
return;
if (IsInterfaceIgnored(msg->ifa_index))
break;
if (GetAddress(header, length, &address, nullptr)) {
AddressTrackerAutoLock lock(*this, address_map_lock_);
if (address_map_.erase(address)) {
*address_changed = true;
if (address_map_diff_.has_value()) {
(*address_map_diff_)[address] = absl::nullopt;
}
}
}
} break;
case RTM_NEWLINK: {
const struct ifinfomsg* msg =
SafelyCastNetlinkMsgData<const struct ifinfomsg>(header, length);
if (msg == nullptr)
return;
if (IsInterfaceIgnored(msg->ifi_index))
break;
if (IgnoreWirelessChange(msg, IFLA_PAYLOAD(header))) {
VLOG(2) << "Ignoring RTM_NEWLINK message";
break;
}
if (!(msg->ifi_flags & IFF_LOOPBACK) && (msg->ifi_flags & IFF_UP) &&
(msg->ifi_flags & IFF_LOWER_UP) && (msg->ifi_flags & IFF_RUNNING)) {
AddressTrackerAutoLock lock(*this, online_links_lock_);
if (online_links_.insert(msg->ifi_index).second) {
*link_changed = true;
if (online_links_diff_.has_value()) {
(*online_links_diff_)[msg->ifi_index] = true;
}
if (IsTunnelInterface(msg->ifi_index))
*tunnel_changed = true;
}
} else {
AddressTrackerAutoLock lock(*this, online_links_lock_);
if (online_links_.erase(msg->ifi_index)) {
*link_changed = true;
if (online_links_diff_.has_value()) {
(*online_links_diff_)[msg->ifi_index] = false;
}
if (IsTunnelInterface(msg->ifi_index))
*tunnel_changed = true;
}
}
} break;
case RTM_DELLINK: {
const struct ifinfomsg* msg =
SafelyCastNetlinkMsgData<const struct ifinfomsg>(header, length);
if (msg == nullptr)
return;
if (IsInterfaceIgnored(msg->ifi_index))
break;
AddressTrackerAutoLock lock(*this, online_links_lock_);
if (online_links_.erase(msg->ifi_index)) {
*link_changed = true;
if (online_links_diff_.has_value()) {
(*online_links_diff_)[msg->ifi_index] = false;
}
if (IsTunnelInterface(msg->ifi_index))
*tunnel_changed = true;
}
} break;
default:
break;
}
}
}
void AddressTrackerLinux::OnFileCanReadWithoutBlocking() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
bool address_changed;
bool link_changed;
bool tunnel_changed;
ReadMessages(&address_changed, &link_changed, &tunnel_changed);
if (diff_callback_) {
RunDiffCallback();
}
if (address_changed) {
address_callback_.Run();
}
if (link_changed) {
link_callback_.Run();
}
if (tunnel_changed) {
tunnel_callback_.Run();
}
}
bool AddressTrackerLinux::IsTunnelInterface(int interface_index) const {
char buf[IFNAMSIZ] = {0};
return IsTunnelInterfaceName(get_interface_name_(interface_index, buf));
}
// static
bool AddressTrackerLinux::IsTunnelInterfaceName(const char* name) {
// Linux kernel drivers/net/tun.c uses "tun" name prefix.
return strncmp(name, "tun", 3) == 0;
}
void AddressTrackerLinux::UpdateCurrentConnectionType() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
AddressTrackerLinux::AddressMap address_map = GetAddressMap();
std::unordered_set<int> online_links = GetOnlineLinks();
// Strip out tunnel interfaces from online_links
for (auto it = online_links.cbegin(); it != online_links.cend();) {
if (IsTunnelInterface(*it)) {
it = online_links.erase(it);
} else {
++it;
}
}
NetworkInterfaceList networks;
NetworkChangeNotifier::ConnectionType type =
NetworkChangeNotifier::CONNECTION_NONE;
if (GetNetworkListImpl(&networks, 0, online_links, address_map,
get_interface_name_)) {
type = NetworkChangeNotifier::ConnectionTypeFromInterfaceList(networks);
} else {
type = online_links.empty() ? NetworkChangeNotifier::CONNECTION_NONE
: NetworkChangeNotifier::CONNECTION_UNKNOWN;
}
AddressTrackerAutoLock lock(*this, connection_type_lock_);
current_connection_type_ = type;
}
void AddressTrackerLinux::RunDiffCallback() {
DCHECK_CALLED_ON_VALID_SEQUENCE(sequence_checker_);
DCHECK(tracking_);
DCHECK(address_map_diff_.has_value());
DCHECK(online_links_diff_.has_value());
// It's fine to access `address_map_diff_` and `online_links_diff_` without
// any locking here, as the only time they are ever accessed on another thread
// is in GetInitialDataAndStartRecordingDiffs(). But
// GetInitialDataAndStartRecordingDiffs() must be called before
// SetDiffCallback(), which must be called before RunDiffCallback(), so this
// function cannot overlap with any modifications on another thread.
// There should be a diff or the DiffCallback shouldn't be run.
if (address_map_diff_->empty() && online_links_diff_->empty()) {
return;
}
diff_callback_.Run(address_map_diff_.value(), online_links_diff_.value());
address_map_diff_->clear();
online_links_diff_->clear();
}
int AddressTrackerLinux::GetThreadsWaitingForConnectionTypeInitForTesting() {
AddressTrackerAutoLock lock(*this, connection_type_lock_);
return threads_waiting_for_connection_type_initialization_;
}
AddressTrackerLinux::AddressTrackerAutoLock::AddressTrackerAutoLock(
const AddressTrackerLinux& tracker,
base::Lock& lock)
: tracker_(tracker), lock_(lock) {
if (tracker_->tracking_) {
lock_->Acquire();
} else {
DCHECK_CALLED_ON_VALID_SEQUENCE(tracker_->sequence_checker_);
}
}
AddressTrackerLinux::AddressTrackerAutoLock::~AddressTrackerAutoLock() {
if (tracker_->tracking_) {
lock_->AssertAcquired();
lock_->Release();
} else {
DCHECK_CALLED_ON_VALID_SEQUENCE(tracker_->sequence_checker_);
}
}
} // namespace net::internal
Reference in New Issue View Git Blame Copy Permalink