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

 /*
  * Copyright 2018, 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 "if_monitor.h"

 #include <errno.h>
 #include <linux/rtnetlink.h>
 #include <net/if.h>
 #include <poll.h>
 #include <stdio.h>
 #include <string.h>
 #include <sys/socket.h>
 #include <sys/types.h>
 #include <unistd.h>

 #include <memory>
 #include <mutex>
 #include <thread>
 #include <unordered_map>
 #include <vector>

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

 static const size_t kReadBufferSize = 32768;

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

 // A list of commands that can be sent to the monitor. These should be one
 // character long as that is all that the monitor will read and process.
 static const char kMonitorStopCommand[] = "\1";
 static const char kMonitorAckCommand[] = "\2";

 static size_t addrLength(int addrFamily) {
     switch (addrFamily) {
         case AF_INET:
             return 4;
         case AF_INET6:
             return 16;
         default:
             return 0;
     }
 }

 bool operator==(const struct ifAddress& left, const struct ifAddress& right) {
     // The prefix length does not factor in to whether two addresses are the
     // same or not. Only the family and the address data. This matches the
     // kernel behavior when attempting to add the same address with different
     // prefix lengths, those changes are rejected because the address already
     // exists.
     return left.family == right.family &&
            memcmp(&left.addr, &right.addr, addrLength(left.family)) == 0;
 }

 class InterfaceMonitor {
 public:
     InterfaceMonitor() : mSocketFd(-1) {
         mControlSocket[kControlServer] = -1;
         mControlSocket[kControlClient] = -1;
     }

     ~InterfaceMonitor() {
         if (mControlSocket[kControlClient] != -1) {
             ::close(mControlSocket[kControlClient]);
             mControlSocket[kControlClient] = -1;
         }
         if (mControlSocket[kControlServer] != -1) {
             ::close(mControlSocket[kControlServer]);
             mControlSocket[kControlServer] = -1;
         }

         if (mSocketFd != -1) {
             ::close(mSocketFd);
             mSocketFd = -1;
         }
     }

     bool init() {
         if (mSocketFd != -1) {
             RLOGE("InterfaceMonitor already initialized");
             return false;
         }

         mSocketFd = ::socket(AF_NETLINK,
                              SOCK_DGRAM | SOCK_CLOEXEC,
                              NETLINK_ROUTE);
         if (mSocketFd == -1) {
             RLOGE("InterfaceMonitor failed to open socket: %s", strerror(errno));
             return false;
         }

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

         struct sockaddr_nl addr;
         memset(&addr, 0, sizeof(addr));
         addr.nl_family = AF_NETLINK;
         addr.nl_groups = (1 << (RTNLGRP_IPV4_IFADDR - 1)) |
                          (1 << (RTNLGRP_IPV6_IFADDR - 1));

         struct sockaddr* sa = reinterpret_cast<struct sockaddr*>(&addr);
         if (::bind(mSocketFd, sa, sizeof(addr)) != 0) {
             RLOGE("InterfaceMonitor failed to bind socket: %s",
                   strerror(errno));
             return false;
         }

         return true;
     }

     void setCallback(ifMonitorCallback callback) {
         mOnAddressChangeCallback = callback;
     }

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

     void requestAddress() {
         struct {
             struct nlmsghdr hdr;
             struct ifaddrmsg msg;
             char padding[16];
         } request;

         memset(&request, 0, sizeof(request));
         request.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(request.msg));
         request.hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_ROOT;
         request.hdr.nlmsg_type = RTM_GETADDR;

         int status = ::send(mSocketFd, &request, request.hdr.nlmsg_len, 0);
         if (status < 0 ||
             static_cast<unsigned int>(status) != request.hdr.nlmsg_len) {
             if (status < 0) {
                 RLOGE("Failed to send netlink request: %s", strerror(errno));
             } else {
                 RLOGE("Short send only sent %d out of %d bytes",
                       status, (int)request.hdr.nlmsg_len);
             }
         }
     }

     void run() {
         requestAddress();

         std::vector<struct pollfd> fds(2);
         fds[0].events = POLLIN;
         fds[0].fd = mControlSocket[kControlServer];
         fds[1].events = POLLIN;
         fds[1].fd = mSocketFd;
         while (true) {
             int status = ::poll(fds.data(), fds.size(), -1);
             if (status < 0) {
                 if (errno == EINTR) {
                     // Interrupted, just keep going
                     continue;
                 }
                 // Actual error, time to quit
                 RLOGE("Polling failed: %s", strerror(errno));
                 break;
             } else if (status == 0) {
                 // Timeout
                 continue;
             }

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

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

 private:
     void onReadAvailable() {
         char buffer[kReadBufferSize];
         struct sockaddr_storage storage;

         while (true) {
             socklen_t addrSize = sizeof(storage);
             int status = ::recvfrom(mSocketFd,
                                     buffer,
                                     sizeof(buffer),
                                     MSG_DONTWAIT,
                                     reinterpret_cast<struct sockaddr*>(&storage),
                                     &addrSize);
             if (status < 0 && (errno == EAGAIN || errno == EWOULDBLOCK)) {
                 // Nothing to receive, everything is fine
                 return;
             } else if (status < 0 && errno == EINTR) {
                 // Caught interrupt, try again
                 continue;
             } else if (status < 0) {
                 RLOGE("InterfaceMonitor receive failed: %s", strerror(errno));
                 return;
             } else if (addrSize < 0 ||
                        static_cast<size_t>(addrSize) != sizeof(struct sockaddr_nl)) {
                 RLOGE("InterfaceMonitor received invalid address size");
                 return;
             }

             size_t length = static_cast<size_t>(status);

             auto hdr = reinterpret_cast<struct nlmsghdr*>(buffer);
             while (NLMSG_OK(hdr, length) && hdr->nlmsg_type != NLMSG_DONE) {
                 switch (hdr->nlmsg_type) {
                     case RTM_NEWADDR:
                     case RTM_DELADDR:
                         handleAddressChange(hdr);
                         break;
                     default:
                         RLOGE("Received message type %d", (int)hdr->nlmsg_type);
                         break;
                 }
                 NLMSG_NEXT(hdr, length);
             }
         }
     }

     void handleAddressChange(const struct nlmsghdr* hdr) {
         if (!mOnAddressChangeCallback) {
             return;
         }

         auto msg = reinterpret_cast<const struct ifaddrmsg*>(NLMSG_DATA(hdr));
         std::vector<ifAddress>& ifAddrs = mAddresses[msg->ifa_index];

         auto attr = reinterpret_cast<const struct rtattr*>(IFA_RTA(msg));
         int attrLen = IFA_PAYLOAD(hdr);

         bool somethingChanged = false;
         for (;attr && RTA_OK(attr, attrLen); attr = RTA_NEXT(attr, attrLen)) {
             if (attr->rta_type != IFA_LOCAL && attr->rta_type != IFA_ADDRESS) {
                 continue;
             }

             ifAddress addr;
             memset(&addr, 0, sizeof(addr));

             // Ensure that the payload matches the expected address length
             if (RTA_PAYLOAD(attr) >= addrLength(msg->ifa_family)) {
                 addr.family = msg->ifa_family;
                 addr.prefix = msg->ifa_prefixlen;
                 memcpy(&addr.addr, RTA_DATA(attr), addrLength(addr.family));
             } else {
                 RLOGE("Invalid address family (%d) and size (%d) combination",
                       int(msg->ifa_family), int(RTA_PAYLOAD(attr)));
                 continue;
             }

             auto it = std::find(ifAddrs.begin(), ifAddrs.end(), addr);
             if (hdr->nlmsg_type == RTM_NEWADDR && it == ifAddrs.end()) {
                 // New address does not exist, add it
                 ifAddrs.push_back(addr);
                 somethingChanged = true;
             } else if (hdr->nlmsg_type == RTM_DELADDR && it != ifAddrs.end()) {
                 // Address was removed and it exists, remove it
                 ifAddrs.erase(it);
                 somethingChanged = true;
             }
         }

         if (somethingChanged) {
             mOnAddressChangeCallback(msg->ifa_index,
                                      ifAddrs.data(),
                                      ifAddrs.size());
         }
     }

     ifMonitorCallback mOnAddressChangeCallback;
     std::unordered_map<unsigned int, std::vector<ifAddress>> mAddresses;
     std::unique_ptr<std::thread> mThread;
     std::mutex mThreadMutex;
     int mSocketFd;
     int mControlSocket[2];
 };

 extern "C"
 struct ifMonitor* ifMonitorCreate() {
     auto monitor = std::make_unique<InterfaceMonitor>();
     if (!monitor || !monitor->init()) {
         return nullptr;
     }
     return reinterpret_cast<struct ifMonitor*>(monitor.release());
 }

 extern "C"
 void ifMonitorFree(struct ifMonitor* ifMonitor) {
     InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);
     delete monitor;
 }

 extern "C"
 void ifMonitorSetCallback(struct ifMonitor* ifMonitor,
                           ifMonitorCallback callback) {
     InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);
     monitor->setCallback(callback);
 }

 extern "C"
 void ifMonitorRunAsync(struct ifMonitor* ifMonitor) {
     InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);

     monitor->runAsync();
 }

 extern "C"
 void ifMonitorStop(struct ifMonitor* ifMonitor) {
     InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);

     monitor->stop();
 }
	/*
	* Copyright 2018, 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 "if_monitor.h"

	#include <errno.h>
	#include <linux/rtnetlink.h>
	#include <net/if.h>
	#include <poll.h>
	#include <stdio.h>
	#include <string.h>
	#include <sys/socket.h>
	#include <sys/types.h>
	#include <unistd.h>

	#include <memory>
	#include <mutex>
	#include <thread>
	#include <unordered_map>
	#include <vector>

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

	static const size_t kReadBufferSize = 32768;

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

	// A list of commands that can be sent to the monitor. These should be one
	// character long as that is all that the monitor will read and process.
	static const char kMonitorStopCommand[] = "\1";
	static const char kMonitorAckCommand[] = "\2";

	static size_t addrLength(int addrFamily) {
	switch (addrFamily) {
	case AF_INET:
	return 4;
	case AF_INET6:
	return 16;
	default:
	return 0;
	}
	}

	bool operator==(const struct ifAddress& left, const struct ifAddress& right) {
	// The prefix length does not factor in to whether two addresses are the
	// same or not. Only the family and the address data. This matches the
	// kernel behavior when attempting to add the same address with different
	// prefix lengths, those changes are rejected because the address already
	// exists.
	return left.family == right.family &&
	memcmp(&left.addr, &right.addr, addrLength(left.family)) == 0;
	}

	class InterfaceMonitor {
	public:
	InterfaceMonitor() : mSocketFd(-1) {
	mControlSocket[kControlServer] = -1;
	mControlSocket[kControlClient] = -1;
	}

	~InterfaceMonitor() {
	if (mControlSocket[kControlClient] != -1) {
	::close(mControlSocket[kControlClient]);
	mControlSocket[kControlClient] = -1;
	}
	if (mControlSocket[kControlServer] != -1) {
	::close(mControlSocket[kControlServer]);
	mControlSocket[kControlServer] = -1;
	}

	if (mSocketFd != -1) {
	::close(mSocketFd);
	mSocketFd = -1;
	}
	}

	bool init() {
	if (mSocketFd != -1) {
	RLOGE("InterfaceMonitor already initialized");
	return false;
	}

	mSocketFd = ::socket(AF_NETLINK,
	SOCK_DGRAM \| SOCK_CLOEXEC,
	NETLINK_ROUTE);
	if (mSocketFd == -1) {
	RLOGE("InterfaceMonitor failed to open socket: %s", strerror(errno));
	return false;
	}

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

	struct sockaddr_nl addr;
	memset(&addr, 0, sizeof(addr));
	addr.nl_family = AF_NETLINK;
	addr.nl_groups = (1 << (RTNLGRP_IPV4_IFADDR - 1)) \|
	(1 << (RTNLGRP_IPV6_IFADDR - 1));

	struct sockaddr* sa = reinterpret_cast<struct sockaddr*>(&addr);
	if (::bind(mSocketFd, sa, sizeof(addr)) != 0) {
	RLOGE("InterfaceMonitor failed to bind socket: %s",
	strerror(errno));
	return false;
	}

	return true;
	}

	void setCallback(ifMonitorCallback callback) {
	mOnAddressChangeCallback = callback;
	}

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

	void requestAddress() {
	struct {
	struct nlmsghdr hdr;
	struct ifaddrmsg msg;
	char padding[16];
	} request;

	memset(&request, 0, sizeof(request));
	request.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(request.msg));
	request.hdr.nlmsg_flags = NLM_F_REQUEST \| NLM_F_ROOT;
	request.hdr.nlmsg_type = RTM_GETADDR;

	int status = ::send(mSocketFd, &request, request.hdr.nlmsg_len, 0);
	if (status < 0 \|\|
	static_cast<unsigned int>(status) != request.hdr.nlmsg_len) {
	if (status < 0) {
	RLOGE("Failed to send netlink request: %s", strerror(errno));
	} else {
	RLOGE("Short send only sent %d out of %d bytes",
	status, (int)request.hdr.nlmsg_len);
	}
	}
	}

	void run() {
	requestAddress();

	std::vector<struct pollfd> fds(2);
	fds[0].events = POLLIN;
	fds[0].fd = mControlSocket[kControlServer];
	fds[1].events = POLLIN;
	fds[1].fd = mSocketFd;
	while (true) {
	int status = ::poll(fds.data(), fds.size(), -1);
	if (status < 0) {
	if (errno == EINTR) {
	// Interrupted, just keep going
	continue;
	}
	// Actual error, time to quit
	RLOGE("Polling failed: %s", strerror(errno));
	break;
	} else if (status == 0) {
	// Timeout
	continue;
	}

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

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

	private:
	void onReadAvailable() {
	char buffer[kReadBufferSize];
	struct sockaddr_storage storage;

	while (true) {
	socklen_t addrSize = sizeof(storage);
	int status = ::recvfrom(mSocketFd,
	buffer,
	sizeof(buffer),
	MSG_DONTWAIT,
	reinterpret_cast<struct sockaddr*>(&storage),
	&addrSize);
	if (status < 0 && (errno == EAGAIN \|\| errno == EWOULDBLOCK)) {
	// Nothing to receive, everything is fine
	return;
	} else if (status < 0 && errno == EINTR) {
	// Caught interrupt, try again
	continue;
	} else if (status < 0) {
	RLOGE("InterfaceMonitor receive failed: %s", strerror(errno));
	return;
	} else if (addrSize < 0 \|\|
	static_cast<size_t>(addrSize) != sizeof(struct sockaddr_nl)) {
	RLOGE("InterfaceMonitor received invalid address size");
	return;
	}

	size_t length = static_cast<size_t>(status);

	auto hdr = reinterpret_cast<struct nlmsghdr*>(buffer);
	while (NLMSG_OK(hdr, length) && hdr->nlmsg_type != NLMSG_DONE) {
	switch (hdr->nlmsg_type) {
	case RTM_NEWADDR:
	case RTM_DELADDR:
	handleAddressChange(hdr);
	break;
	default:
	RLOGE("Received message type %d", (int)hdr->nlmsg_type);
	break;
	}
	NLMSG_NEXT(hdr, length);
	}
	}
	}

	void handleAddressChange(const struct nlmsghdr* hdr) {
	if (!mOnAddressChangeCallback) {
	return;
	}

	auto msg = reinterpret_cast<const struct ifaddrmsg*>(NLMSG_DATA(hdr));
	std::vector<ifAddress>& ifAddrs = mAddresses[msg->ifa_index];

	auto attr = reinterpret_cast<const struct rtattr*>(IFA_RTA(msg));
	int attrLen = IFA_PAYLOAD(hdr);

	bool somethingChanged = false;
	for (;attr && RTA_OK(attr, attrLen); attr = RTA_NEXT(attr, attrLen)) {
	if (attr->rta_type != IFA_LOCAL && attr->rta_type != IFA_ADDRESS) {
	continue;
	}

	ifAddress addr;
	memset(&addr, 0, sizeof(addr));

	// Ensure that the payload matches the expected address length
	if (RTA_PAYLOAD(attr) >= addrLength(msg->ifa_family)) {
	addr.family = msg->ifa_family;
	addr.prefix = msg->ifa_prefixlen;
	memcpy(&addr.addr, RTA_DATA(attr), addrLength(addr.family));
	} else {
	RLOGE("Invalid address family (%d) and size (%d) combination",
	int(msg->ifa_family), int(RTA_PAYLOAD(attr)));
	continue;
	}

	auto it = std::find(ifAddrs.begin(), ifAddrs.end(), addr);
	if (hdr->nlmsg_type == RTM_NEWADDR && it == ifAddrs.end()) {
	// New address does not exist, add it
	ifAddrs.push_back(addr);
	somethingChanged = true;
	} else if (hdr->nlmsg_type == RTM_DELADDR && it != ifAddrs.end()) {
	// Address was removed and it exists, remove it
	ifAddrs.erase(it);
	somethingChanged = true;
	}
	}

	if (somethingChanged) {
	mOnAddressChangeCallback(msg->ifa_index,
	ifAddrs.data(),
	ifAddrs.size());
	}
	}

	ifMonitorCallback mOnAddressChangeCallback;
	std::unordered_map<unsigned int, std::vector<ifAddress>> mAddresses;
	std::unique_ptr<std::thread> mThread;
	std::mutex mThreadMutex;
	int mSocketFd;
	int mControlSocket[2];
	};

	extern "C"
	struct ifMonitor* ifMonitorCreate() {
	auto monitor = std::make_unique<InterfaceMonitor>();
	if (!monitor \|\| !monitor->init()) {
	return nullptr;
	}
	return reinterpret_cast<struct ifMonitor*>(monitor.release());
	}

	extern "C"
	void ifMonitorFree(struct ifMonitor* ifMonitor) {
	InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);
	delete monitor;
	}

	extern "C"
	void ifMonitorSetCallback(struct ifMonitor* ifMonitor,
	ifMonitorCallback callback) {
	InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);
	monitor->setCallback(callback);
	}

	extern "C"
	void ifMonitorRunAsync(struct ifMonitor* ifMonitor) {
	InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);

	monitor->runAsync();
	}

	extern "C"
	void ifMonitorStop(struct ifMonitor* ifMonitor) {
	InterfaceMonitor* monitor = reinterpret_cast<InterfaceMonitor*>(ifMonitor);

	monitor->stop();
	}