ril/ipv6_monitor.cpp - device/generic/goldfish - Git at Google

 /*
  * Copyright 2019, The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 #include "ipv6_monitor.h"

 #include <errno.h>
 #include <linux/filter.h>
 #include <net/if.h>
 #include <netinet/ether.h>
 #include <netinet/icmp6.h>
 #include <netinet/ip6.h>
 #include <poll.h>
 #include <string.h>
 #include <unistd.h>

 #include <array>
 #include <mutex>
 #include <string>
 #include <thread>
 #include <unordered_set>
 #include <vector>

 #define LOG_TAG "RIL-IPV6MON"
 #include <utils/Log.h>

 static constexpr size_t kReadBufferSize = 32768;

 static constexpr size_t kRecursiveDnsOptHeaderSize = 8;

 static constexpr size_t kControlClient = 0;
 static constexpr size_t kControlServer = 1;

 static constexpr char kMonitorAckCommand = '\1';
 static constexpr char kMonitorStopCommand = '\2';

 // The amount of time to wait before trying to initialize interface again if
 // it's not ready when rild starts.
 static constexpr int kDeferredTimeoutMilliseconds = 1000;

 bool operator==(const in6_addr& left, const in6_addr& right) {
     return ::memcmp(left.s6_addr, right.s6_addr, sizeof(left.s6_addr)) == 0;
 }

 bool operator!=(const in6_addr& left, const in6_addr& right) {
     return ::memcmp(left.s6_addr, right.s6_addr, sizeof(left.s6_addr)) != 0;
 }

 template<class T>
 static inline void hash_combine(size_t& seed, const T& value) {
     std::hash<T> hasher;
     seed ^= hasher(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
 }

 namespace std {
 template<> struct hash<in6_addr> {
     size_t operator()(const in6_addr& ad) const {
         size_t seed = 0;
         hash_combine(seed, *reinterpret_cast<const uint32_t*>(&ad.s6_addr[0]));
         hash_combine(seed, *reinterpret_cast<const uint32_t*>(&ad.s6_addr[4]));
         hash_combine(seed, *reinterpret_cast<const uint32_t*>(&ad.s6_addr[8]));
         hash_combine(seed, *reinterpret_cast<const uint32_t*>(&ad.s6_addr[12]));
         return seed;
     }
 };
 }  // namespace std

 static constexpr uint32_t kIpTypeOffset = offsetof(ip6_hdr, ip6_nxt);
 static constexpr uint32_t kIcmpTypeOffset = sizeof(ip6_hdr) +
                                             offsetof(icmp6_hdr, icmp6_type);

 // This is BPF program that will filter out anything that is not an NDP router
 // advertisement. It's a very basic assembler syntax. The jumps indicate how
 // many instructions to jump in addition to the automatic increment of the
 // program counter. So a jump statement with a zero means to go to the next
 // instruction, a value of 3 means that the next instruction will be the 4th
 // after the current one.
 static const struct sock_filter kNdpFilter[] = {
     // Load byte at absolute address kIpTypeOffset
     BPF_STMT(BPF_LD | BPF_B | BPF_ABS, kIpTypeOffset),
     // Jump, if byte is IPPROTO_ICMPV6 jump 0 instructions, if not jump 3.
     BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, IPPROTO_ICMPV6, 0, 3),
     // Load byte at absolute address kIcmpTypeOffset
     BPF_STMT(BPF_LD | BPF_B | BPF_ABS, kIcmpTypeOffset),
     // Jump, if byte is ND_ROUTER_ADVERT jump 0 instructions, if not jump 1
     BPF_JUMP(BPF_JMP | BPF_JEQ | BPF_K, ND_ROUTER_ADVERT, 0, 1),
     // Return the number of bytes to accept, accept all of them
     BPF_STMT(BPF_RET | BPF_K, std::numeric_limits<uint32_t>::max()),
     // Accept zero bytes, this is where the failed jumps go
     BPF_STMT(BPF_RET | BPF_K, 0)
 };
 static constexpr size_t kNdpFilterSize =
     sizeof(kNdpFilter) / sizeof(kNdpFilter[0]);

 class Ipv6Monitor {
 public:
     Ipv6Monitor(const char* interfaceName);
     ~Ipv6Monitor();

     enum class InitResult {
         Error,
         Deferred,
         Success,
     };
     InitResult init();
     void setCallback(ipv6MonitorCallback callback);
     void runAsync();
     void stop();

 private:
     InitResult initInterfaces();
     void run();
     void onReadAvailable();

     ipv6MonitorCallback mMonitorCallback;

     in6_addr mGateway;
     std::unordered_set<in6_addr> mDnsServers;

     std::unique_ptr<std::thread> mThread;
     std::mutex mThreadMutex;

     std::string mInterfaceName;
     int mSocketFd;
     int mControlSocket[2];
     int mPollTimeout = -1;
     bool mFullyInitialized = false;
 };

 Ipv6Monitor::Ipv6Monitor(const char* interfaceName) :
     mMonitorCallback(nullptr),
     mInterfaceName(interfaceName),
     mSocketFd(-1) {
     memset(&mGateway, 0, sizeof(mGateway));
     mControlSocket[0] = -1;
     mControlSocket[1] = -1;
 }

 Ipv6Monitor::~Ipv6Monitor() {
     for (int& fd : mControlSocket) {
         if (fd != -1) {
             ::close(fd);
             fd = -1;
         }
     }
     if (mSocketFd != -1) {
         ::close(mSocketFd);
         mSocketFd = -1;
     }
 }

 Ipv6Monitor::InitResult Ipv6Monitor::init() {
     if (mSocketFd != -1) {
         RLOGE("Ipv6Monitor already initialized");
         return InitResult::Error;
     }

     if (::socketpair(AF_UNIX, SOCK_DGRAM, 0, mControlSocket) != 0) {
         RLOGE("Ipv6Monitor failed to create control socket pair: %s",
               strerror(errno));
         return InitResult::Error;
     }

     mSocketFd = ::socket(AF_PACKET, SOCK_DGRAM | SOCK_CLOEXEC, ETH_P_IPV6);
     if (mSocketFd == -1) {
         RLOGE("Ipv6Monitor failed to open socket: %s", strerror(errno));
         return InitResult::Error;
     }
     // If interface initialization fails we'll retry later
     return initInterfaces();
 }

 void Ipv6Monitor::setCallback(ipv6MonitorCallback callback) {
     mMonitorCallback = callback;
 }

 Ipv6Monitor::InitResult Ipv6Monitor::initInterfaces() {
     if (mFullyInitialized) {
         RLOGE("Ipv6Monitor already initialized");
         return InitResult::Error;
     }
     struct ifreq request;
     memset(&request, 0, sizeof(request));
     strlcpy(request.ifr_name, mInterfaceName.c_str(), sizeof(request.ifr_name));

     // Set the ALLMULTI flag so we can capture multicast traffic
     int status = ::ioctl(mSocketFd, SIOCGIFFLAGS, &request);
     if (status != 0) {
         if (errno == ENODEV) {
             // It is not guaranteed that the network is entirely set up by the
             // time rild has started. If that's the case the radio interface
             // might not be up yet, try again later.
             RLOGE("Ipv6Monitor could not initialize %s yet, retrying later",
                   mInterfaceName.c_str());
             mPollTimeout = kDeferredTimeoutMilliseconds;
             return InitResult::Deferred;
         }
         RLOGE("Ipv6Monitor failed to get interface flags for %s: %s",
               mInterfaceName.c_str(), strerror(errno));
         return InitResult::Error;
     }

     if ((request.ifr_flags & IFF_ALLMULTI) == 0) {
         // The flag is not set, we have to make another call
         request.ifr_flags |= IFF_ALLMULTI;

         status = ::ioctl(mSocketFd, SIOCSIFFLAGS, &request);
         if (status != 0) {
             RLOGE("Ipv6Monitor failed to set interface flags for %s: %s",
                   mInterfaceName.c_str(), strerror(errno));
             return InitResult::Error;
         }
     }

     // Add a BPF filter to the socket so that we only receive the specific
     // type of packet we're interested in. Otherwise we will receive ALL
     // traffic on this interface.
     struct sock_fprog filter;
     filter.len = kNdpFilterSize;
     // The API doesn't have const but it's not going to modify it so this is OK
     filter.filter = const_cast<struct sock_filter*>(kNdpFilter);
     status = ::setsockopt(mSocketFd,
                           SOL_SOCKET,
                           SO_ATTACH_FILTER,
                           &filter,
                           sizeof(filter));
     if (status != 0) {
         RLOGE("Ipv6Monitor failed to set socket filter: %s", strerror(errno));
         return InitResult::Error;
     }

     // Get the hardware address of the interface into a sockaddr struct for bind
     struct sockaddr_ll ethAddr;
     memset(&ethAddr, 0, sizeof(ethAddr));
     ethAddr.sll_family = AF_PACKET;
     ethAddr.sll_protocol = htons(ETH_P_IPV6);
     ethAddr.sll_ifindex = if_nametoindex(mInterfaceName.c_str());
     if (ethAddr.sll_ifindex == 0) {
         RLOGE("Ipv6Monitor failed to find index for %s: %s",
               mInterfaceName.c_str(), strerror(errno));
         return InitResult::Error;
     }

     status = ::ioctl(mSocketFd, SIOCGIFHWADDR, &request);
     if (status != 0) {
         RLOGE("Ipv6Monitor failed to get hardware address for %s: %s",
               mInterfaceName.c_str(), strerror(errno));
         return InitResult::Error;
     }
     memcpy(ethAddr.sll_addr, request.ifr_addr.sa_data, ETH_ALEN);

     // Now bind to the hardware address
     status = ::bind(mSocketFd,
                     reinterpret_cast<const struct sockaddr*>(&ethAddr),
                     sizeof(ethAddr));
     if (status != 0) {
         RLOGE("Ipv6Monitor failed to bind to %s hardware address: %s",
               mInterfaceName.c_str(), strerror(errno));
         return InitResult::Error;
     }
     mFullyInitialized = true;
     return InitResult::Success;
 }

 void Ipv6Monitor::runAsync() {
     std::unique_lock<std::mutex> lock(mThreadMutex);
     mThread = std::make_unique<std::thread>([this]() { run(); });
 }

 void Ipv6Monitor::stop() {
     std::unique_lock<std::mutex> lock(mThreadMutex);
     if (!mThread) {
         return;
     }
     ::write(mControlSocket[kControlClient], &kMonitorStopCommand, 1);
     char ack = -1;
     while (ack != kMonitorAckCommand) {
         ::read(mControlSocket[kControlClient], &ack, sizeof(ack));
     }
     mThread->join();
     mThread.reset();
 }

 void Ipv6Monitor::run() {
     std::array<struct pollfd, 2> fds;
     fds[0].events = POLLIN;
     fds[0].fd = mControlSocket[kControlServer];
     fds[1].events = POLLIN;
     fds[1].fd = mSocketFd;

     bool running = true;
     while (running) {
         int status = ::poll(fds.data(), fds.size(), mPollTimeout);
         if (status < 0) {
             if (errno == EINTR) {
                 // Interrupted, keep going
                 continue;
             }
             // An error occurred
             RLOGE("Ipv6Monitor fatal failure polling failed; %s",
                   strerror(errno));
             break;
         } else if (status == 0) {
             // Timeout, nothing to read
             if (!mFullyInitialized) {
                 InitResult result = initInterfaces();
                 switch (result) {
                     case InitResult::Error:
                         // Something went wrong this time and we can't recover
                         running = false;
                         break;
                     case InitResult::Deferred:
                         // We need to keep waiting and then try again
                         mPollTimeout = kDeferredTimeoutMilliseconds;
                         break;
                     case InitResult::Success:
                         // Interfaces are initialized, no need to timeout again
                         mPollTimeout = -1;
                         break;
                 }
             }
             continue;
         }

         if (fds[0].revents & POLLIN) {
             // Control message received
             char command = -1;
             if (::read(mControlSocket[kControlServer],
                        &command,
                        sizeof(command)) == 1) {
                 if (command == kMonitorStopCommand) {
                     break;
                 }
             }
         } else if (fds[1].revents & POLLIN) {
             onReadAvailable();
         }
     }
     ::write(mControlSocket[kControlServer], &kMonitorAckCommand, 1);
 }

 void Ipv6Monitor::onReadAvailable() {
     char buffer[kReadBufferSize];

     ssize_t bytesRead = 0;
     while (true) {
         bytesRead = ::recv(mSocketFd, buffer, sizeof(buffer), 0);
         if (bytesRead < 0) {
             if (errno == EINTR) {
                 // Interrupted, try again right away
                 continue;
             }
             if (errno != EAGAIN && errno != EWOULDBLOCK) {
                 // Do not report an error for the above error codes, they are
                 // part of the normal turn of events. We just need to try again
                 // later when we run into those errors.
                 RLOGE("Ipv6Monitor failed to receive data: %s",
                       strerror(errno));
             }
             return;
         }
         break;
     }

     if (mMonitorCallback == nullptr) {
         // No point in doing anything, we have read the data so the socket
         // buffer doesn't fill up and that's all we can do.
         return;
     }

     if (static_cast<size_t>(bytesRead) < sizeof(ip6_hdr) + sizeof(icmp6_hdr)) {
         // This message cannot be an ICMPv6 packet, ignore it
         return;
     }

     auto ipv6 = reinterpret_cast<const ip6_hdr*>(buffer);
     uint8_t version = (ipv6->ip6_vfc & 0xF0) >> 4;
     if (version != 6 || ipv6->ip6_nxt != IPPROTO_ICMPV6) {
         // This message is not an IPv6 packet or not an ICMPv6 packet, ignore it
         return;
     }

     // The ICMP header starts right after the IPv6 header
     auto icmp = reinterpret_cast<const icmp6_hdr*>(buffer + sizeof(ip6_hdr));
     if (icmp->icmp6_code != 0) {
         // All packets we care about have an icmp code of zero.
         return;
     }

     if (icmp->icmp6_type != ND_ROUTER_ADVERT) {
         // We only care about router advertisements
         return;
     }

     // At this point we know it's a valid packet, let's look inside

     // The gateway is the same as the source in the IP header
     in6_addr gateway = ipv6->ip6_src;

     // Search through the options for DNS servers
     const char* options = buffer + sizeof(ip6_hdr) + sizeof(nd_router_advert);
     const nd_opt_hdr* option = reinterpret_cast<const nd_opt_hdr*>(options);

     std::vector<in6_addr> dnsServers;
     const nd_opt_hdr* nextOpt = nullptr;
     for (const nd_opt_hdr* opt = option; opt; opt = nextOpt) {
         auto nextOptLoc =
             reinterpret_cast<const char*>(opt) + opt->nd_opt_len * 8u;
         if (nextOptLoc > buffer + bytesRead) {
             // Not enough room for this option, abort
             break;
         }
         if (nextOptLoc < buffer + bytesRead) {
             nextOpt = reinterpret_cast<const nd_opt_hdr*>(nextOptLoc);
         } else {
             nextOpt = nullptr;
         }
         if (opt->nd_opt_type != 25 || opt->nd_opt_len < 1) {
             // Not an RNDSS option, skip it
             continue;
         }

         size_t numEntries = (opt->nd_opt_len - 1) / 2;
         const char* addrLoc = reinterpret_cast<const char*>(opt);
         addrLoc += kRecursiveDnsOptHeaderSize;
         auto addrs = reinterpret_cast<const in6_addr*>(addrLoc);

         for (size_t i = 0; i < numEntries; ++i) {
             dnsServers.push_back(addrs[i]);
         }
     }

     bool changed = false;
     if (gateway != mGateway) {
         changed = true;
         mGateway = gateway;
     }

     for (const auto& dns : dnsServers) {
         if (mDnsServers.find(dns) == mDnsServers.end()) {
             mDnsServers.insert(dns);
             changed = true;
         }
     }

     if (changed) {
         mMonitorCallback(&gateway, dnsServers.data(), dnsServers.size());
     }
 }

 extern "C"
 struct ipv6Monitor* ipv6MonitorCreate(const char* interfaceName) {
     auto monitor = std::make_unique<Ipv6Monitor>(interfaceName);
     if (!monitor || monitor->init() == Ipv6Monitor::InitResult::Error) {
         return nullptr;
     }
     return reinterpret_cast<struct ipv6Monitor*>(monitor.release());
 }

 extern "C"
 void ipv6MonitorFree(struct ipv6Monitor* ipv6Monitor) {
     auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
     delete monitor;
 }

 extern "C"
 void ipv6MonitorSetCallback(struct ipv6Monitor* ipv6Monitor,
                             ipv6MonitorCallback callback) {
     auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
     monitor->setCallback(callback);
 }

 extern "C"
 void ipv6MonitorRunAsync(struct ipv6Monitor* ipv6Monitor) {
     auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
     monitor->runAsync();
 }

 extern "C"
 void ipv6MonitorStop(struct ipv6Monitor* ipv6Monitor) {
     auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
     monitor->stop();
 }
	/*
	* Copyright 2019, The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	#include "ipv6_monitor.h"

	#include <errno.h>
	#include <linux/filter.h>
	#include <net/if.h>
	#include <netinet/ether.h>
	#include <netinet/icmp6.h>
	#include <netinet/ip6.h>
	#include <poll.h>
	#include <string.h>
	#include <unistd.h>

	#include <array>
	#include <mutex>
	#include <string>
	#include <thread>
	#include <unordered_set>
	#include <vector>

	#define LOG_TAG "RIL-IPV6MON"
	#include <utils/Log.h>

	static constexpr size_t kReadBufferSize = 32768;

	static constexpr size_t kRecursiveDnsOptHeaderSize = 8;

	static constexpr size_t kControlClient = 0;
	static constexpr size_t kControlServer = 1;

	static constexpr char kMonitorAckCommand = '\1';
	static constexpr char kMonitorStopCommand = '\2';

	// The amount of time to wait before trying to initialize interface again if
	// it's not ready when rild starts.
	static constexpr int kDeferredTimeoutMilliseconds = 1000;

	bool operator==(const in6_addr& left, const in6_addr& right) {
	return ::memcmp(left.s6_addr, right.s6_addr, sizeof(left.s6_addr)) == 0;
	}

	bool operator!=(const in6_addr& left, const in6_addr& right) {
	return ::memcmp(left.s6_addr, right.s6_addr, sizeof(left.s6_addr)) != 0;
	}

	template<class T>
	static inline void hash_combine(size_t& seed, const T& value) {
	std::hash<T> hasher;
	seed ^= hasher(value) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
	}

	namespace std {
	template<> struct hash<in6_addr> {
	size_t operator()(const in6_addr& ad) const {
	size_t seed = 0;
	hash_combine(seed, reinterpret_cast<const uint32_t>(&ad.s6_addr[0]));
	hash_combine(seed, reinterpret_cast<const uint32_t>(&ad.s6_addr[4]));
	hash_combine(seed, reinterpret_cast<const uint32_t>(&ad.s6_addr[8]));
	hash_combine(seed, reinterpret_cast<const uint32_t>(&ad.s6_addr[12]));
	return seed;
	}
	};
	} // namespace std

	static constexpr uint32_t kIpTypeOffset = offsetof(ip6_hdr, ip6_nxt);
	static constexpr uint32_t kIcmpTypeOffset = sizeof(ip6_hdr) +
	offsetof(icmp6_hdr, icmp6_type);

	// This is BPF program that will filter out anything that is not an NDP router
	// advertisement. It's a very basic assembler syntax. The jumps indicate how
	// many instructions to jump in addition to the automatic increment of the
	// program counter. So a jump statement with a zero means to go to the next
	// instruction, a value of 3 means that the next instruction will be the 4th
	// after the current one.
	static const struct sock_filter kNdpFilter[] = {
	// Load byte at absolute address kIpTypeOffset
	BPF_STMT(BPF_LD \| BPF_B \| BPF_ABS, kIpTypeOffset),
	// Jump, if byte is IPPROTO_ICMPV6 jump 0 instructions, if not jump 3.
	BPF_JUMP(BPF_JMP \| BPF_JEQ \| BPF_K, IPPROTO_ICMPV6, 0, 3),
	// Load byte at absolute address kIcmpTypeOffset
	BPF_STMT(BPF_LD \| BPF_B \| BPF_ABS, kIcmpTypeOffset),
	// Jump, if byte is ND_ROUTER_ADVERT jump 0 instructions, if not jump 1
	BPF_JUMP(BPF_JMP \| BPF_JEQ \| BPF_K, ND_ROUTER_ADVERT, 0, 1),
	// Return the number of bytes to accept, accept all of them
	BPF_STMT(BPF_RET \| BPF_K, std::numeric_limits<uint32_t>::max()),
	// Accept zero bytes, this is where the failed jumps go
	BPF_STMT(BPF_RET \| BPF_K, 0)
	};
	static constexpr size_t kNdpFilterSize =
	sizeof(kNdpFilter) / sizeof(kNdpFilter[0]);

	class Ipv6Monitor {
	public:
	Ipv6Monitor(const char* interfaceName);
	~Ipv6Monitor();

	enum class InitResult {
	Error,
	Deferred,
	Success,
	};
	InitResult init();
	void setCallback(ipv6MonitorCallback callback);
	void runAsync();
	void stop();

	private:
	InitResult initInterfaces();
	void run();
	void onReadAvailable();

	ipv6MonitorCallback mMonitorCallback;

	in6_addr mGateway;
	std::unordered_set<in6_addr> mDnsServers;

	std::unique_ptr<std::thread> mThread;
	std::mutex mThreadMutex;

	std::string mInterfaceName;
	int mSocketFd;
	int mControlSocket[2];
	int mPollTimeout = -1;
	bool mFullyInitialized = false;
	};

	Ipv6Monitor::Ipv6Monitor(const char* interfaceName) :
	mMonitorCallback(nullptr),
	mInterfaceName(interfaceName),
	mSocketFd(-1) {
	memset(&mGateway, 0, sizeof(mGateway));
	mControlSocket[0] = -1;
	mControlSocket[1] = -1;
	}

	Ipv6Monitor::~Ipv6Monitor() {
	for (int& fd : mControlSocket) {
	if (fd != -1) {
	::close(fd);
	fd = -1;
	}
	}
	if (mSocketFd != -1) {
	::close(mSocketFd);
	mSocketFd = -1;
	}
	}

	Ipv6Monitor::InitResult Ipv6Monitor::init() {
	if (mSocketFd != -1) {
	RLOGE("Ipv6Monitor already initialized");
	return InitResult::Error;
	}

	if (::socketpair(AF_UNIX, SOCK_DGRAM, 0, mControlSocket) != 0) {
	RLOGE("Ipv6Monitor failed to create control socket pair: %s",
	strerror(errno));
	return InitResult::Error;
	}

	mSocketFd = ::socket(AF_PACKET, SOCK_DGRAM \| SOCK_CLOEXEC, ETH_P_IPV6);
	if (mSocketFd == -1) {
	RLOGE("Ipv6Monitor failed to open socket: %s", strerror(errno));
	return InitResult::Error;
	}
	// If interface initialization fails we'll retry later
	return initInterfaces();
	}

	void Ipv6Monitor::setCallback(ipv6MonitorCallback callback) {
	mMonitorCallback = callback;
	}

	Ipv6Monitor::InitResult Ipv6Monitor::initInterfaces() {
	if (mFullyInitialized) {
	RLOGE("Ipv6Monitor already initialized");
	return InitResult::Error;
	}
	struct ifreq request;
	memset(&request, 0, sizeof(request));
	strlcpy(request.ifr_name, mInterfaceName.c_str(), sizeof(request.ifr_name));

	// Set the ALLMULTI flag so we can capture multicast traffic
	int status = ::ioctl(mSocketFd, SIOCGIFFLAGS, &request);
	if (status != 0) {
	if (errno == ENODEV) {
	// It is not guaranteed that the network is entirely set up by the
	// time rild has started. If that's the case the radio interface
	// might not be up yet, try again later.
	RLOGE("Ipv6Monitor could not initialize %s yet, retrying later",
	mInterfaceName.c_str());
	mPollTimeout = kDeferredTimeoutMilliseconds;
	return InitResult::Deferred;
	}
	RLOGE("Ipv6Monitor failed to get interface flags for %s: %s",
	mInterfaceName.c_str(), strerror(errno));
	return InitResult::Error;
	}

	if ((request.ifr_flags & IFF_ALLMULTI) == 0) {
	// The flag is not set, we have to make another call
	request.ifr_flags \|= IFF_ALLMULTI;

	status = ::ioctl(mSocketFd, SIOCSIFFLAGS, &request);
	if (status != 0) {
	RLOGE("Ipv6Monitor failed to set interface flags for %s: %s",
	mInterfaceName.c_str(), strerror(errno));
	return InitResult::Error;
	}
	}

	// Add a BPF filter to the socket so that we only receive the specific
	// type of packet we're interested in. Otherwise we will receive ALL
	// traffic on this interface.
	struct sock_fprog filter;
	filter.len = kNdpFilterSize;
	// The API doesn't have const but it's not going to modify it so this is OK
	filter.filter = const_cast<struct sock_filter*>(kNdpFilter);
	status = ::setsockopt(mSocketFd,
	SOL_SOCKET,
	SO_ATTACH_FILTER,
	&filter,
	sizeof(filter));
	if (status != 0) {
	RLOGE("Ipv6Monitor failed to set socket filter: %s", strerror(errno));
	return InitResult::Error;
	}

	// Get the hardware address of the interface into a sockaddr struct for bind
	struct sockaddr_ll ethAddr;
	memset(&ethAddr, 0, sizeof(ethAddr));
	ethAddr.sll_family = AF_PACKET;
	ethAddr.sll_protocol = htons(ETH_P_IPV6);
	ethAddr.sll_ifindex = if_nametoindex(mInterfaceName.c_str());
	if (ethAddr.sll_ifindex == 0) {
	RLOGE("Ipv6Monitor failed to find index for %s: %s",
	mInterfaceName.c_str(), strerror(errno));
	return InitResult::Error;
	}

	status = ::ioctl(mSocketFd, SIOCGIFHWADDR, &request);
	if (status != 0) {
	RLOGE("Ipv6Monitor failed to get hardware address for %s: %s",
	mInterfaceName.c_str(), strerror(errno));
	return InitResult::Error;
	}
	memcpy(ethAddr.sll_addr, request.ifr_addr.sa_data, ETH_ALEN);

	// Now bind to the hardware address
	status = ::bind(mSocketFd,
	reinterpret_cast<const struct sockaddr*>(&ethAddr),
	sizeof(ethAddr));
	if (status != 0) {
	RLOGE("Ipv6Monitor failed to bind to %s hardware address: %s",
	mInterfaceName.c_str(), strerror(errno));
	return InitResult::Error;
	}
	mFullyInitialized = true;
	return InitResult::Success;
	}

	void Ipv6Monitor::runAsync() {
	std::unique_lock<std::mutex> lock(mThreadMutex);
	mThread = std::make_unique<std::thread>([this]() { run(); });
	}

	void Ipv6Monitor::stop() {
	std::unique_lock<std::mutex> lock(mThreadMutex);
	if (!mThread) {
	return;
	}
	::write(mControlSocket[kControlClient], &kMonitorStopCommand, 1);
	char ack = -1;
	while (ack != kMonitorAckCommand) {
	::read(mControlSocket[kControlClient], &ack, sizeof(ack));
	}
	mThread->join();
	mThread.reset();
	}

	void Ipv6Monitor::run() {
	std::array<struct pollfd, 2> fds;
	fds[0].events = POLLIN;
	fds[0].fd = mControlSocket[kControlServer];
	fds[1].events = POLLIN;
	fds[1].fd = mSocketFd;

	bool running = true;
	while (running) {
	int status = ::poll(fds.data(), fds.size(), mPollTimeout);
	if (status < 0) {
	if (errno == EINTR) {
	// Interrupted, keep going
	continue;
	}
	// An error occurred
	RLOGE("Ipv6Monitor fatal failure polling failed; %s",
	strerror(errno));
	break;
	} else if (status == 0) {
	// Timeout, nothing to read
	if (!mFullyInitialized) {
	InitResult result = initInterfaces();
	switch (result) {
	case InitResult::Error:
	// Something went wrong this time and we can't recover
	running = false;
	break;
	case InitResult::Deferred:
	// We need to keep waiting and then try again
	mPollTimeout = kDeferredTimeoutMilliseconds;
	break;
	case InitResult::Success:
	// Interfaces are initialized, no need to timeout again
	mPollTimeout = -1;
	break;
	}
	}
	continue;
	}

	if (fds[0].revents & POLLIN) {
	// Control message received
	char command = -1;
	if (::read(mControlSocket[kControlServer],
	&command,
	sizeof(command)) == 1) {
	if (command == kMonitorStopCommand) {
	break;
	}
	}
	} else if (fds[1].revents & POLLIN) {
	onReadAvailable();
	}
	}
	::write(mControlSocket[kControlServer], &kMonitorAckCommand, 1);
	}

	void Ipv6Monitor::onReadAvailable() {
	char buffer[kReadBufferSize];

	ssize_t bytesRead = 0;
	while (true) {
	bytesRead = ::recv(mSocketFd, buffer, sizeof(buffer), 0);
	if (bytesRead < 0) {
	if (errno == EINTR) {
	// Interrupted, try again right away
	continue;
	}
	if (errno != EAGAIN && errno != EWOULDBLOCK) {
	// Do not report an error for the above error codes, they are
	// part of the normal turn of events. We just need to try again
	// later when we run into those errors.
	RLOGE("Ipv6Monitor failed to receive data: %s",
	strerror(errno));
	}
	return;
	}
	break;
	}

	if (mMonitorCallback == nullptr) {
	// No point in doing anything, we have read the data so the socket
	// buffer doesn't fill up and that's all we can do.
	return;
	}

	if (static_cast<size_t>(bytesRead) < sizeof(ip6_hdr) + sizeof(icmp6_hdr)) {
	// This message cannot be an ICMPv6 packet, ignore it
	return;
	}

	auto ipv6 = reinterpret_cast<const ip6_hdr*>(buffer);
	uint8_t version = (ipv6->ip6_vfc & 0xF0) >> 4;
	if (version != 6 \|\| ipv6->ip6_nxt != IPPROTO_ICMPV6) {
	// This message is not an IPv6 packet or not an ICMPv6 packet, ignore it
	return;
	}

	// The ICMP header starts right after the IPv6 header
	auto icmp = reinterpret_cast<const icmp6_hdr*>(buffer + sizeof(ip6_hdr));
	if (icmp->icmp6_code != 0) {
	// All packets we care about have an icmp code of zero.
	return;
	}

	if (icmp->icmp6_type != ND_ROUTER_ADVERT) {
	// We only care about router advertisements
	return;
	}

	// At this point we know it's a valid packet, let's look inside

	// The gateway is the same as the source in the IP header
	in6_addr gateway = ipv6->ip6_src;

	// Search through the options for DNS servers
	const char* options = buffer + sizeof(ip6_hdr) + sizeof(nd_router_advert);
	const nd_opt_hdr* option = reinterpret_cast<const nd_opt_hdr*>(options);

	std::vector<in6_addr> dnsServers;
	const nd_opt_hdr* nextOpt = nullptr;
	for (const nd_opt_hdr* opt = option; opt; opt = nextOpt) {
	auto nextOptLoc =
	reinterpret_cast<const char>(opt) + opt->nd_opt_len 8u;
	if (nextOptLoc > buffer + bytesRead) {
	// Not enough room for this option, abort
	break;
	}
	if (nextOptLoc < buffer + bytesRead) {
	nextOpt = reinterpret_cast<const nd_opt_hdr*>(nextOptLoc);
	} else {
	nextOpt = nullptr;
	}
	if (opt->nd_opt_type != 25 \|\| opt->nd_opt_len < 1) {
	// Not an RNDSS option, skip it
	continue;
	}

	size_t numEntries = (opt->nd_opt_len - 1) / 2;
	const char* addrLoc = reinterpret_cast<const char*>(opt);
	addrLoc += kRecursiveDnsOptHeaderSize;
	auto addrs = reinterpret_cast<const in6_addr*>(addrLoc);

	for (size_t i = 0; i < numEntries; ++i) {
	dnsServers.push_back(addrs[i]);
	}
	}

	bool changed = false;
	if (gateway != mGateway) {
	changed = true;
	mGateway = gateway;
	}

	for (const auto& dns : dnsServers) {
	if (mDnsServers.find(dns) == mDnsServers.end()) {
	mDnsServers.insert(dns);
	changed = true;
	}
	}

	if (changed) {
	mMonitorCallback(&gateway, dnsServers.data(), dnsServers.size());
	}
	}

	extern "C"
	struct ipv6Monitor* ipv6MonitorCreate(const char* interfaceName) {
	auto monitor = std::make_unique<Ipv6Monitor>(interfaceName);
	if (!monitor \|\| monitor->init() == Ipv6Monitor::InitResult::Error) {
	return nullptr;
	}
	return reinterpret_cast<struct ipv6Monitor*>(monitor.release());
	}

	extern "C"
	void ipv6MonitorFree(struct ipv6Monitor* ipv6Monitor) {
	auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
	delete monitor;
	}

	extern "C"
	void ipv6MonitorSetCallback(struct ipv6Monitor* ipv6Monitor,
	ipv6MonitorCallback callback) {
	auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
	monitor->setCallback(callback);
	}

	extern "C"
	void ipv6MonitorRunAsync(struct ipv6Monitor* ipv6Monitor) {
	auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
	monitor->runAsync();
	}

	extern "C"
	void ipv6MonitorStop(struct ipv6Monitor* ipv6Monitor) {
	auto monitor = reinterpret_cast<Ipv6Monitor*>(ipv6Monitor);
	monitor->stop();
	}