From 6bf0a5cb5034a7e684dcc3500e841785237ce2dd Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 19:32:43 +0200 Subject: Adding upstream version 1:115.7.0. Signed-off-by: Daniel Baumann --- netwerk/system/netlink/NetlinkService.cpp | 1903 +++++++++++++++++++++++++++++ netwerk/system/netlink/NetlinkService.h | 168 +++ netwerk/system/netlink/moz.build | 12 + 3 files changed, 2083 insertions(+) create mode 100644 netwerk/system/netlink/NetlinkService.cpp create mode 100644 netwerk/system/netlink/NetlinkService.h create mode 100644 netwerk/system/netlink/moz.build (limited to 'netwerk/system/netlink') diff --git a/netwerk/system/netlink/NetlinkService.cpp b/netwerk/system/netlink/NetlinkService.cpp new file mode 100644 index 0000000000..9e882e5ab6 --- /dev/null +++ b/netwerk/system/netlink/NetlinkService.cpp @@ -0,0 +1,1903 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set et sw=2 ts=4: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ + +#include +#include +#include +#include +#include +#include + +#include "nsThreadUtils.h" +#include "NetlinkService.h" +#include "nsIThread.h" +#include "nsString.h" +#include "nsPrintfCString.h" +#include "mozilla/Logging.h" +#include "../../base/IPv6Utils.h" +#include "../LinkServiceCommon.h" +#include "../NetworkLinkServiceDefines.h" + +#include "mozilla/Base64.h" +#include "mozilla/FunctionTypeTraits.h" +#include "mozilla/ProfilerThreadSleep.h" +#include "mozilla/Telemetry.h" +#include "mozilla/DebugOnly.h" + +#if defined(HAVE_RES_NINIT) +# include +# include +#endif + +namespace mozilla::net { + +template +static auto eintr_retry(F&& func) -> + typename FunctionTypeTraits::ReturnType { + typename FunctionTypeTraits::ReturnType _rc; + do { + _rc = func(); + } while (_rc == -1 && errno == EINTR); + return _rc; +} + +#define EINTR_RETRY(expr) eintr_retry([&]() { return expr; }) + +// period during which to absorb subsequent network change events, in +// milliseconds +static const unsigned int kNetworkChangeCoalescingPeriod = 1000; + +static LazyLogModule gNlSvcLog("NetlinkService"); +#define LOG(args) MOZ_LOG(gNlSvcLog, mozilla::LogLevel::Debug, args) + +#undef LOG_ENABLED +#define LOG_ENABLED() MOZ_LOG_TEST(gNlSvcLog, mozilla::LogLevel::Debug) + +using in_common_addr = union { + struct in_addr addr4; + struct in6_addr addr6; +}; + +static void GetAddrStr(const in_common_addr* aAddr, uint8_t aFamily, + nsACString& _retval) { + char addr[INET6_ADDRSTRLEN]; + addr[0] = 0; + + if (aFamily == AF_INET) { + inet_ntop(AF_INET, &(aAddr->addr4), addr, INET_ADDRSTRLEN); + } else { + inet_ntop(AF_INET6, &(aAddr->addr6), addr, INET6_ADDRSTRLEN); + } + _retval.Assign(addr); +} + +class NetlinkAddress { + public: + NetlinkAddress() = default; + + uint8_t Family() const { return mIfam.ifa_family; } + uint32_t GetIndex() const { return mIfam.ifa_index; } + uint8_t GetPrefixLen() const { return mIfam.ifa_prefixlen; } + bool ScopeIsUniverse() const { return mIfam.ifa_scope == RT_SCOPE_UNIVERSE; } + const in_common_addr* GetAddrPtr() const { return &mAddr; } + + bool MsgEquals(const NetlinkAddress& aOther) const { + return !memcmp(&mIfam, &(aOther.mIfam), sizeof(mIfam)); + } + + bool Equals(const NetlinkAddress& aOther) const { + if (mIfam.ifa_family != aOther.mIfam.ifa_family) { + return false; + } + if (mIfam.ifa_index != aOther.mIfam.ifa_index) { + // addresses are different when they are on a different interface + return false; + } + if (mIfam.ifa_prefixlen != aOther.mIfam.ifa_prefixlen) { + // It's possible to have two equal addresses with a different netmask on + // the same interface, so we need to check prefixlen too. + return false; + } + size_t addrSize = (mIfam.ifa_family == AF_INET) ? sizeof(mAddr.addr4) + : sizeof(mAddr.addr6); + return memcmp(&mAddr, aOther.GetAddrPtr(), addrSize) == 0; + } + + bool ContainsAddr(const in_common_addr* aAddr) { + int32_t addrSize = (mIfam.ifa_family == AF_INET) + ? (int32_t)sizeof(mAddr.addr4) + : (int32_t)sizeof(mAddr.addr6); + uint8_t maskit[] = {0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe}; + int32_t bits = mIfam.ifa_prefixlen; + if (bits > addrSize * 8) { + MOZ_ASSERT(false, "Unexpected prefix length!"); + LOG(("Unexpected prefix length %d, maximum for this family is %d", bits, + addrSize * 8)); + return false; + } + for (int32_t i = 0; i < addrSize; i++) { + uint8_t mask = (bits >= 8) ? 0xff : maskit[bits]; + if ((((unsigned char*)aAddr)[i] & mask) != + (((unsigned char*)(&mAddr))[i] & mask)) { + return false; + } + bits -= 8; + if (bits <= 0) { + return true; + } + } + return true; + } + + bool Init(struct nlmsghdr* aNlh) { + struct ifaddrmsg* ifam; + struct rtattr* attr; + int len; + + ifam = (ifaddrmsg*)NLMSG_DATA(aNlh); + len = IFA_PAYLOAD(aNlh); + + if (ifam->ifa_family != AF_INET && ifam->ifa_family != AF_INET6) { + return false; + } + + bool hasAddr = false; + for (attr = IFA_RTA(ifam); RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) { + if (attr->rta_type == IFA_ADDRESS || attr->rta_type == IFA_LOCAL) { + memcpy(&mAddr, RTA_DATA(attr), + ifam->ifa_family == AF_INET ? sizeof(mAddr.addr4) + : sizeof(mAddr.addr6)); + hasAddr = true; + if (attr->rta_type == IFA_LOCAL) { + // local address is preferred, so don't continue parsing other + // attributes + break; + } + } + } + + if (!hasAddr) { + return false; + } + + memcpy(&mIfam, (ifaddrmsg*)NLMSG_DATA(aNlh), sizeof(mIfam)); + return true; + } + + private: + in_common_addr mAddr; + struct ifaddrmsg mIfam; +}; + +class NetlinkNeighbor { + public: + NetlinkNeighbor() = default; + + uint8_t Family() const { return mNeigh.ndm_family; } + uint32_t GetIndex() const { return mNeigh.ndm_ifindex; } + const in_common_addr* GetAddrPtr() const { return &mAddr; } + const uint8_t* GetMACPtr() const { return mMAC; } + bool HasMAC() const { return mHasMAC; }; + + void GetAsString(nsACString& _retval) const { + nsAutoCString addrStr; + _retval.Assign("addr="); + GetAddrStr(&mAddr, mNeigh.ndm_family, addrStr); + _retval.Append(addrStr); + if (mNeigh.ndm_family == AF_INET) { + _retval.Append(" family=AF_INET if="); + } else { + _retval.Append(" family=AF_INET6 if="); + } + _retval.AppendInt(mNeigh.ndm_ifindex); + if (mHasMAC) { + _retval.Append(" mac="); + _retval.Append(nsPrintfCString("%02x:%02x:%02x:%02x:%02x:%02x", mMAC[0], + mMAC[1], mMAC[2], mMAC[3], mMAC[4], + mMAC[5])); + } + } + + bool Init(struct nlmsghdr* aNlh) { + struct ndmsg* neigh; + struct rtattr* attr; + int len; + + neigh = (ndmsg*)NLMSG_DATA(aNlh); + len = aNlh->nlmsg_len - NLMSG_LENGTH(sizeof(*neigh)); + + if (neigh->ndm_family != AF_INET && neigh->ndm_family != AF_INET6) { + return false; + } + + bool hasDST = false; + for (attr = RTM_RTA(neigh); RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) { + if (attr->rta_type == NDA_LLADDR) { + memcpy(mMAC, RTA_DATA(attr), ETH_ALEN); + mHasMAC = true; + } + + if (attr->rta_type == NDA_DST) { + memcpy(&mAddr, RTA_DATA(attr), + neigh->ndm_family == AF_INET ? sizeof(mAddr.addr4) + : sizeof(mAddr.addr6)); + hasDST = true; + } + } + + if (!hasDST) { + return false; + } + + memcpy(&mNeigh, (ndmsg*)NLMSG_DATA(aNlh), sizeof(mNeigh)); + return true; + } + + private: + bool mHasMAC{false}; + uint8_t mMAC[ETH_ALEN]{}; + in_common_addr mAddr{}; + struct ndmsg mNeigh {}; +}; + +class NetlinkLink { + public: + NetlinkLink() = default; + + bool IsUp() const { + return (mIface.ifi_flags & IFF_RUNNING) && + !(mIface.ifi_flags & IFF_LOOPBACK); + } + + void GetName(nsACString& _retval) const { _retval = mName; } + bool IsTypeEther() const { return mIface.ifi_type == ARPHRD_ETHER; } + uint32_t GetIndex() const { return mIface.ifi_index; } + uint32_t GetFlags() const { return mIface.ifi_flags; } + uint16_t GetType() const { return mIface.ifi_type; } + + bool Init(struct nlmsghdr* aNlh) { + struct ifinfomsg* iface; + struct rtattr* attr; + int len; + + iface = (ifinfomsg*)NLMSG_DATA(aNlh); + len = aNlh->nlmsg_len - NLMSG_LENGTH(sizeof(*iface)); + + bool hasName = false; + for (attr = IFLA_RTA(iface); RTA_OK(attr, len); + attr = RTA_NEXT(attr, len)) { + if (attr->rta_type == IFLA_IFNAME) { + mName.Assign((char*)RTA_DATA(attr)); + hasName = true; + break; + } + } + + if (!hasName) { + return false; + } + + memcpy(&mIface, (ifinfomsg*)NLMSG_DATA(aNlh), sizeof(mIface)); + return true; + } + + private: + nsCString mName; + struct ifinfomsg mIface {}; +}; + +class NetlinkRoute { + public: + NetlinkRoute() + : mHasGWAddr(false), + mHasPrefSrcAddr(false), + mHasDstAddr(false), + mHasOif(false), + mHasPrio(false) {} + + bool IsUnicast() const { return mRtm.rtm_type == RTN_UNICAST; } + bool ScopeIsUniverse() const { return mRtm.rtm_scope == RT_SCOPE_UNIVERSE; } + bool IsDefault() const { return mRtm.rtm_dst_len == 0; } + bool HasOif() const { return mHasOif; } + uint8_t Oif() const { return mOif; } + uint8_t Family() const { return mRtm.rtm_family; } + bool HasPrefSrcAddr() const { return mHasPrefSrcAddr; } + const in_common_addr* GetGWAddrPtr() const { + return mHasGWAddr ? &mGWAddr : nullptr; + } + const in_common_addr* GetPrefSrcAddrPtr() const { + return mHasPrefSrcAddr ? &mPrefSrcAddr : nullptr; + } + + bool Equals(const NetlinkRoute& aOther) const { + size_t addrSize = (mRtm.rtm_family == AF_INET) ? sizeof(mDstAddr.addr4) + : sizeof(mDstAddr.addr6); + if (memcmp(&mRtm, &(aOther.mRtm), sizeof(mRtm)) != 0) { + return false; + } + if (mHasOif != aOther.mHasOif || mOif != aOther.mOif) { + return false; + } + if (mHasPrio != aOther.mHasPrio || mPrio != aOther.mPrio) { + return false; + } + if ((mHasGWAddr != aOther.mHasGWAddr) || + (mHasGWAddr && memcmp(&mGWAddr, &(aOther.mGWAddr), addrSize) != 0)) { + return false; + } + if ((mHasDstAddr != aOther.mHasDstAddr) || + (mHasDstAddr && memcmp(&mDstAddr, &(aOther.mDstAddr), addrSize) != 0)) { + return false; + } + if ((mHasPrefSrcAddr != aOther.mHasPrefSrcAddr) || + (mHasPrefSrcAddr && + memcmp(&mPrefSrcAddr, &(aOther.mPrefSrcAddr), addrSize) != 0)) { + return false; + } + return true; + } + + bool GatewayEquals(const NetlinkNeighbor& aNeigh) const { + if (!mHasGWAddr) { + return false; + } + if (aNeigh.Family() != mRtm.rtm_family) { + return false; + } + size_t addrSize = (mRtm.rtm_family == AF_INET) ? sizeof(mGWAddr.addr4) + : sizeof(mGWAddr.addr6); + return memcmp(&mGWAddr, aNeigh.GetAddrPtr(), addrSize) == 0; + } + + bool GatewayEquals(const NetlinkRoute* aRoute) const { + if (!mHasGWAddr || !aRoute->mHasGWAddr) { + return false; + } + if (mRtm.rtm_family != aRoute->mRtm.rtm_family) { + return false; + } + size_t addrSize = (mRtm.rtm_family == AF_INET) ? sizeof(mGWAddr.addr4) + : sizeof(mGWAddr.addr6); + return memcmp(&mGWAddr, &(aRoute->mGWAddr), addrSize) == 0; + } + + bool PrefSrcAddrEquals(const NetlinkAddress& aAddress) const { + if (!mHasPrefSrcAddr) { + return false; + } + if (mRtm.rtm_family != aAddress.Family()) { + return false; + } + size_t addrSize = (mRtm.rtm_family == AF_INET) ? sizeof(mPrefSrcAddr.addr4) + : sizeof(mPrefSrcAddr.addr6); + return memcmp(&mPrefSrcAddr, aAddress.GetAddrPtr(), addrSize) == 0; + } + + void GetAsString(nsACString& _retval) const { + nsAutoCString addrStr; + _retval.Assign("table="); + _retval.AppendInt(mRtm.rtm_table); + _retval.Append(" type="); + _retval.AppendInt(mRtm.rtm_type); + _retval.Append(" scope="); + _retval.AppendInt(mRtm.rtm_scope); + if (mRtm.rtm_family == AF_INET) { + _retval.Append(" family=AF_INET dst="); + addrStr.Assign("0.0.0.0/"); + } else { + _retval.Append(" family=AF_INET6 dst="); + addrStr.Assign("::/"); + } + if (mHasDstAddr) { + GetAddrStr(&mDstAddr, mRtm.rtm_family, addrStr); + addrStr.Append("/"); + } + _retval.Append(addrStr); + _retval.AppendInt(mRtm.rtm_dst_len); + if (mHasPrefSrcAddr) { + _retval.Append(" src="); + GetAddrStr(&mPrefSrcAddr, mRtm.rtm_family, addrStr); + _retval.Append(addrStr); + } + if (mHasGWAddr) { + _retval.Append(" via="); + GetAddrStr(&mGWAddr, mRtm.rtm_family, addrStr); + _retval.Append(addrStr); + } + if (mHasOif) { + _retval.Append(" oif="); + _retval.AppendInt(mOif); + } + if (mHasPrio) { + _retval.Append(" prio="); + _retval.AppendInt(mPrio); + } + } + + bool Init(struct nlmsghdr* aNlh) { + struct rtmsg* rtm; + struct rtattr* attr; + int len; + + rtm = (rtmsg*)NLMSG_DATA(aNlh); + len = RTM_PAYLOAD(aNlh); + + if (rtm->rtm_family != AF_INET && rtm->rtm_family != AF_INET6) { + return false; + } + + for (attr = RTM_RTA(rtm); RTA_OK(attr, len); attr = RTA_NEXT(attr, len)) { + if (attr->rta_type == RTA_DST) { + memcpy(&mDstAddr, RTA_DATA(attr), + (rtm->rtm_family == AF_INET) ? sizeof(mDstAddr.addr4) + : sizeof(mDstAddr.addr6)); + mHasDstAddr = true; + } else if (attr->rta_type == RTA_GATEWAY) { + memcpy(&mGWAddr, RTA_DATA(attr), + (rtm->rtm_family == AF_INET) ? sizeof(mGWAddr.addr4) + : sizeof(mGWAddr.addr6)); + mHasGWAddr = true; + } else if (attr->rta_type == RTA_PREFSRC) { + memcpy(&mPrefSrcAddr, RTA_DATA(attr), + (rtm->rtm_family == AF_INET) ? sizeof(mPrefSrcAddr.addr4) + : sizeof(mPrefSrcAddr.addr6)); + mHasPrefSrcAddr = true; + } else if (attr->rta_type == RTA_OIF) { + mOif = *(uint32_t*)RTA_DATA(attr); + mHasOif = true; + } else if (attr->rta_type == RTA_PRIORITY) { + mPrio = *(uint32_t*)RTA_DATA(attr); + mHasPrio = true; + } + } + + memcpy(&mRtm, (rtmsg*)NLMSG_DATA(aNlh), sizeof(mRtm)); + return true; + } + + private: + bool mHasGWAddr : 1; + bool mHasPrefSrcAddr : 1; + bool mHasDstAddr : 1; + bool mHasOif : 1; + bool mHasPrio : 1; + + in_common_addr mGWAddr{}; + in_common_addr mDstAddr{}; + in_common_addr mPrefSrcAddr{}; + + uint32_t mOif{}; + uint32_t mPrio{}; + struct rtmsg mRtm {}; +}; + +class NetlinkMsg { + public: + static uint8_t const kGenMsg = 1; + static uint8_t const kRtMsg = 2; + + NetlinkMsg() = default; + virtual ~NetlinkMsg() = default; + + virtual bool Send(int aFD) = 0; + virtual bool IsPending() { return mIsPending; } + virtual uint32_t SeqId() = 0; + virtual uint8_t Family() = 0; + virtual uint8_t MsgType() = 0; + + protected: + bool SendRequest(int aFD, void* aRequest, uint32_t aRequestLength) { + MOZ_ASSERT(!mIsPending, "Request has been already sent!"); + + struct sockaddr_nl kernel {}; + memset(&kernel, 0, sizeof(kernel)); + kernel.nl_family = AF_NETLINK; + kernel.nl_groups = 0; + + struct iovec io {}; + memset(&io, 0, sizeof(io)); + io.iov_base = aRequest; + io.iov_len = aRequestLength; + + struct msghdr rtnl_msg {}; + memset(&rtnl_msg, 0, sizeof(rtnl_msg)); + rtnl_msg.msg_iov = &io; + rtnl_msg.msg_iovlen = 1; + rtnl_msg.msg_name = &kernel; + rtnl_msg.msg_namelen = sizeof(kernel); + + ssize_t rc = EINTR_RETRY(sendmsg(aFD, (struct msghdr*)&rtnl_msg, 0)); + if (rc > 0 && (uint32_t)rc == aRequestLength) { + mIsPending = true; + } + + return mIsPending; + } + + bool mIsPending{false}; +}; + +class NetlinkGenMsg : public NetlinkMsg { + public: + NetlinkGenMsg(uint16_t aMsgType, uint8_t aFamily, uint32_t aSeqId) { + memset(&mReq, 0, sizeof(mReq)); + + mReq.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtgenmsg)); + mReq.hdr.nlmsg_type = aMsgType; + mReq.hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP; + mReq.hdr.nlmsg_seq = aSeqId; + mReq.hdr.nlmsg_pid = 0; + + mReq.gen.rtgen_family = aFamily; + } + + virtual bool Send(int aFD) { + return SendRequest(aFD, &mReq, mReq.hdr.nlmsg_len); + } + + virtual uint32_t SeqId() { return mReq.hdr.nlmsg_seq; } + virtual uint8_t Family() { return mReq.gen.rtgen_family; } + virtual uint8_t MsgType() { return kGenMsg; } + + private: + struct { + struct nlmsghdr hdr; + struct rtgenmsg gen; + } mReq{}; +}; + +class NetlinkRtMsg : public NetlinkMsg { + public: + NetlinkRtMsg(uint8_t aFamily, void* aAddress, uint32_t aSeqId) { + MOZ_ASSERT(aFamily == AF_INET || aFamily == AF_INET6); + + memset(&mReq, 0, sizeof(mReq)); + + mReq.hdr.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg)); + mReq.hdr.nlmsg_type = RTM_GETROUTE; + mReq.hdr.nlmsg_flags = NLM_F_REQUEST; + mReq.hdr.nlmsg_seq = aSeqId; + mReq.hdr.nlmsg_pid = 0; + + mReq.rtm.rtm_family = aFamily; + mReq.rtm.rtm_flags = 0; + mReq.rtm.rtm_dst_len = aFamily == AF_INET ? 32 : 128; + + struct rtattr* rta; + rta = (struct rtattr*)(((char*)&mReq) + NLMSG_ALIGN(mReq.hdr.nlmsg_len)); + rta->rta_type = RTA_DST; + size_t addrSize = + aFamily == AF_INET ? sizeof(struct in_addr) : sizeof(struct in6_addr); + rta->rta_len = RTA_LENGTH(addrSize); + memcpy(RTA_DATA(rta), aAddress, addrSize); + mReq.hdr.nlmsg_len = NLMSG_ALIGN(mReq.hdr.nlmsg_len) + RTA_LENGTH(addrSize); + } + + virtual bool Send(int aFD) { + return SendRequest(aFD, &mReq, mReq.hdr.nlmsg_len); + } + + virtual uint32_t SeqId() { return mReq.hdr.nlmsg_seq; } + virtual uint8_t Family() { return mReq.rtm.rtm_family; } + virtual uint8_t MsgType() { return kRtMsg; } + + private: + struct { + struct nlmsghdr hdr; + struct rtmsg rtm; + unsigned char data[1024]; + } mReq{}; +}; + +NetlinkService::LinkInfo::LinkInfo(UniquePtr&& aLink) + : mLink(std::move(aLink)), mIsUp(false) {} + +NetlinkService::LinkInfo::~LinkInfo() = default; + +bool NetlinkService::LinkInfo::UpdateStatus() { + LOG(("NetlinkService::LinkInfo::UpdateStatus")); + + bool oldIsUp = mIsUp; + mIsUp = false; + + if (!mLink->IsUp()) { + // The link is not up or is a loopback + LOG(("The link is down or is a loopback")); + } else { + // Link is up when there is non-local address associated with it. + for (uint32_t i = 0; i < mAddresses.Length(); ++i) { + if (LOG_ENABLED()) { + nsAutoCString dbgStr; + GetAddrStr(mAddresses[i]->GetAddrPtr(), mAddresses[i]->Family(), + dbgStr); + LOG(("checking address %s", dbgStr.get())); + } + if (mAddresses[i]->ScopeIsUniverse()) { + mIsUp = true; + LOG(("global address found")); + break; + } + } + } + + return mIsUp == oldIsUp; +} + +NS_IMPL_ISUPPORTS(NetlinkService, nsIRunnable) + +NetlinkService::NetlinkService() : mPid(getpid()) {} + +NetlinkService::~NetlinkService() { + MOZ_ASSERT(!mThread, "NetlinkService thread shutdown failed"); + + if (mShutdownPipe[0] != -1) { + EINTR_RETRY(close(mShutdownPipe[0])); + } + if (mShutdownPipe[1] != -1) { + EINTR_RETRY(close(mShutdownPipe[1])); + } +} + +void NetlinkService::OnNetlinkMessage(int aNetlinkSocket) { + // The buffer size 4096 is a common page size, which is a recommended limit + // for netlink messages. + char buffer[4096]; + + struct sockaddr_nl kernel {}; + memset(&kernel, 0, sizeof(kernel)); + kernel.nl_family = AF_NETLINK; + kernel.nl_groups = 0; + + struct iovec io {}; + memset(&io, 0, sizeof(io)); + io.iov_base = buffer; + io.iov_len = sizeof(buffer); + + struct msghdr rtnl_reply {}; + memset(&rtnl_reply, 0, sizeof(rtnl_reply)); + rtnl_reply.msg_iov = &io; + rtnl_reply.msg_iovlen = 1; + rtnl_reply.msg_name = &kernel; + rtnl_reply.msg_namelen = sizeof(kernel); + + ssize_t rc = EINTR_RETRY(recvmsg(aNetlinkSocket, &rtnl_reply, MSG_DONTWAIT)); + if (rc < 0) { + return; + } + size_t netlink_bytes = rc; + + struct nlmsghdr* nlh = reinterpret_cast(buffer); + + for (; NLMSG_OK(nlh, netlink_bytes); nlh = NLMSG_NEXT(nlh, netlink_bytes)) { + // If PID in the message is our PID, then it's a response to our request. + // Otherwise it's a multicast message. + bool isResponse = (pid_t)nlh->nlmsg_pid == mPid; + if (isResponse) { + if (!mOutgoingMessages.Length() || !mOutgoingMessages[0]->IsPending()) { + // There is no enqueued message pending? + LOG(( + "Ignoring message seq_id %u, because there is no associated message" + " pending", + nlh->nlmsg_seq)); + continue; + } + + if (mOutgoingMessages[0]->SeqId() != nlh->nlmsg_seq) { + LOG(("Received unexpected seq_id [received=%u, expected=%u]", + nlh->nlmsg_seq, mOutgoingMessages[0]->SeqId())); + RemovePendingMsg(); + continue; + } + } + + switch (nlh->nlmsg_type) { + case NLMSG_DONE: /* Message signalling end of dump for responses to + request containing NLM_F_DUMP flag */ + LOG(("received NLMSG_DONE")); + if (isResponse) { + RemovePendingMsg(); + } + break; + case NLMSG_ERROR: + LOG(("received NLMSG_ERROR")); + if (isResponse) { + if (mOutgoingMessages[0]->MsgType() == NetlinkMsg::kRtMsg) { + OnRouteCheckResult(nullptr); + } + RemovePendingMsg(); + } + break; + case RTM_NEWLINK: + case RTM_DELLINK: + MOZ_ASSERT(!isResponse || + (nlh->nlmsg_flags & NLM_F_MULTI) == NLM_F_MULTI); + OnLinkMessage(nlh); + break; + case RTM_NEWADDR: + case RTM_DELADDR: + MOZ_ASSERT(!isResponse || + (nlh->nlmsg_flags & NLM_F_MULTI) == NLM_F_MULTI); + OnAddrMessage(nlh); + break; + case RTM_NEWROUTE: + case RTM_DELROUTE: + if (isResponse && ((nlh->nlmsg_flags & NLM_F_MULTI) != NLM_F_MULTI)) { + // If it's not multipart message, then it must be response to a route + // check. + MOZ_ASSERT(mOutgoingMessages[0]->MsgType() == NetlinkMsg::kRtMsg); + OnRouteCheckResult(nlh); + RemovePendingMsg(); + } else { + OnRouteMessage(nlh); + } + break; + case RTM_NEWNEIGH: + case RTM_DELNEIGH: + MOZ_ASSERT(!isResponse || + (nlh->nlmsg_flags & NLM_F_MULTI) == NLM_F_MULTI); + OnNeighborMessage(nlh); + break; + default: + break; + } + } +} + +void NetlinkService::OnLinkMessage(struct nlmsghdr* aNlh) { + LOG(("NetlinkService::OnLinkMessage [type=%s]", + aNlh->nlmsg_type == RTM_NEWLINK ? "new" : "del")); + + UniquePtr link(new NetlinkLink()); + if (!link->Init(aNlh)) { + return; + } + + const uint32_t linkIndex = link->GetIndex(); + mLinks.WithEntryHandle(linkIndex, [&](auto&& entry) { + nsAutoCString linkName; + link->GetName(linkName); + + if (aNlh->nlmsg_type == RTM_NEWLINK) { + if (!entry) { + LOG(("Creating new link [index=%u, name=%s, flags=%u, type=%u]", + linkIndex, linkName.get(), link->GetFlags(), link->GetType())); + entry.Insert(MakeUnique(std::move(link))); + } else { + LOG(("Updating link [index=%u, name=%s, flags=%u, type=%u]", linkIndex, + linkName.get(), link->GetFlags(), link->GetType())); + + auto* linkInfo = entry->get(); + + // Check whether administrative state has changed. + if (linkInfo->mLink->GetFlags() & IFF_UP && + !(link->GetFlags() & IFF_UP)) { + LOG((" link went down")); + // If the link went down, remove all routes and neighbors, but keep + // addresses. + linkInfo->mDefaultRoutes.Clear(); + linkInfo->mNeighbors.Clear(); + } + + linkInfo->mLink = std::move(link); + linkInfo->UpdateStatus(); + } + } else { + if (!entry) { + // This can happen during startup + LOG(("Link info doesn't exist [index=%u, name=%s]", linkIndex, + linkName.get())); + } else { + LOG(("Removing link [index=%u, name=%s]", linkIndex, linkName.get())); + entry.Remove(); + } + } + }); +} + +void NetlinkService::OnAddrMessage(struct nlmsghdr* aNlh) { + LOG(("NetlinkService::OnAddrMessage [type=%s]", + aNlh->nlmsg_type == RTM_NEWADDR ? "new" : "del")); + + UniquePtr address(new NetlinkAddress()); + if (!address->Init(aNlh)) { + return; + } + + uint32_t ifIdx = address->GetIndex(); + + nsAutoCString addrStr; + GetAddrStr(address->GetAddrPtr(), address->Family(), addrStr); + + LinkInfo* linkInfo = nullptr; + mLinks.Get(ifIdx, &linkInfo); + if (!linkInfo) { + // This can happen during startup + LOG(("Cannot find link info [ifIdx=%u, addr=%s/%u", ifIdx, addrStr.get(), + address->GetPrefixLen())); + return; + } + + // There might be already an equal address in the array even in case of + // RTM_NEWADDR message, e.g. when lifetime of IPv6 address is renewed. Equal + // in this case means that IP and prefix is the same but some attributes + // might be different. Remove existing equal address in case of RTM_DELADDR + // as well as RTM_NEWADDR message and add a new one in the latter case. + for (uint32_t i = 0; i < linkInfo->mAddresses.Length(); ++i) { + if (aNlh->nlmsg_type == RTM_NEWADDR && + linkInfo->mAddresses[i]->MsgEquals(*address)) { + // If the new address is exactly the same, there is nothing to do. + LOG(("Exactly the same address already exists [ifIdx=%u, addr=%s/%u", + ifIdx, addrStr.get(), address->GetPrefixLen())); + return; + } + + if (linkInfo->mAddresses[i]->Equals(*address)) { + LOG(("Removing address [ifIdx=%u, addr=%s/%u]", ifIdx, addrStr.get(), + address->GetPrefixLen())); + linkInfo->mAddresses.RemoveElementAt(i); + break; + } + } + + if (aNlh->nlmsg_type == RTM_NEWADDR) { + LOG(("Adding address [ifIdx=%u, addr=%s/%u]", ifIdx, addrStr.get(), + address->GetPrefixLen())); + linkInfo->mAddresses.AppendElement(std::move(address)); + } else { + // Remove all routes associated with this address + for (uint32_t i = linkInfo->mDefaultRoutes.Length(); i-- > 0;) { + MOZ_ASSERT(linkInfo->mDefaultRoutes[i]->GetGWAddrPtr(), + "Stored routes must have gateway!"); + if (linkInfo->mDefaultRoutes[i]->Family() == address->Family() && + address->ContainsAddr(linkInfo->mDefaultRoutes[i]->GetGWAddrPtr())) { + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + linkInfo->mDefaultRoutes[i]->GetAsString(routeDbgStr); + LOG(("Removing default route: %s", routeDbgStr.get())); + } + linkInfo->mDefaultRoutes.RemoveElementAt(i); + } + } + + // Remove all neighbors associated with this address + for (auto iter = linkInfo->mNeighbors.Iter(); !iter.Done(); iter.Next()) { + NetlinkNeighbor* neigh = iter.UserData(); + if (neigh->Family() == address->Family() && + address->ContainsAddr(neigh->GetAddrPtr())) { + if (LOG_ENABLED()) { + nsAutoCString neighDbgStr; + neigh->GetAsString(neighDbgStr); + LOG(("Removing neighbor %s", neighDbgStr.get())); + } + iter.Remove(); + } + } + } + + // Address change on the interface can change its status + linkInfo->UpdateStatus(); + + // Don't treat address changes during initial scan as a network change + if (mInitialScanFinished) { + // Send network event change regardless of whether the ID has changed or + // not + mSendNetworkChangeEvent = true; + TriggerNetworkIDCalculation(); + } +} + +void NetlinkService::OnRouteMessage(struct nlmsghdr* aNlh) { + LOG(("NetlinkService::OnRouteMessage [type=%s]", + aNlh->nlmsg_type == RTM_NEWROUTE ? "new" : "del")); + + UniquePtr route(new NetlinkRoute()); + if (!route->Init(aNlh)) { + return; + } + + if (!route->IsUnicast() || !route->ScopeIsUniverse()) { + // Use only unicast routes + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Not an unicast global route: %s", routeDbgStr.get())); + } + return; + } + + // Adding/removing any unicast route might change network ID + TriggerNetworkIDCalculation(); + + if (!route->IsDefault()) { + // Store only default routes + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Not a default route: %s", routeDbgStr.get())); + } + return; + } + + if (!route->HasOif()) { + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("There is no output interface in route: %s", routeDbgStr.get())); + } + return; + } + + if (!route->GetGWAddrPtr()) { + // We won't use the route if there is no gateway, so don't store it + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("There is no gateway in route: %s", routeDbgStr.get())); + } + return; + } + + if (route->Family() == AF_INET6 && + net::utils::ipv6_scope((const unsigned char*)route->GetGWAddrPtr()) != + IPV6_SCOPE_GLOBAL) { + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Scope of GW isn't global: %s", routeDbgStr.get())); + } + return; + } + + LinkInfo* linkInfo = nullptr; + mLinks.Get(route->Oif(), &linkInfo); + if (!linkInfo) { + // This can happen during startup + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Cannot find link info for route: %s", routeDbgStr.get())); + } + return; + } + + for (uint32_t i = 0; i < linkInfo->mDefaultRoutes.Length(); ++i) { + if (linkInfo->mDefaultRoutes[i]->Equals(*route)) { + // We shouldn't find equal route when adding a new one, but just in case + // it can happen remove the old one to avoid duplicities. + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Removing default route: %s", routeDbgStr.get())); + } + linkInfo->mDefaultRoutes.RemoveElementAt(i); + break; + } + } + + if (aNlh->nlmsg_type == RTM_NEWROUTE) { + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Adding default route: %s", routeDbgStr.get())); + } + linkInfo->mDefaultRoutes.AppendElement(std::move(route)); + } +} + +void NetlinkService::OnNeighborMessage(struct nlmsghdr* aNlh) { + LOG(("NetlinkService::OnNeighborMessage [type=%s]", + aNlh->nlmsg_type == RTM_NEWNEIGH ? "new" : "del")); + + UniquePtr neigh(new NetlinkNeighbor()); + if (!neigh->Init(aNlh)) { + return; + } + + LinkInfo* linkInfo = nullptr; + mLinks.Get(neigh->GetIndex(), &linkInfo); + if (!linkInfo) { + // This can happen during startup + if (LOG_ENABLED()) { + nsAutoCString neighDbgStr; + neigh->GetAsString(neighDbgStr); + LOG(("Cannot find link info for neighbor: %s", neighDbgStr.get())); + } + return; + } + + if (!linkInfo->mLink->IsTypeEther()) { + if (LOG_ENABLED()) { + nsAutoCString neighDbgStr; + neigh->GetAsString(neighDbgStr); + LOG(("Ignoring message on non-ethernet link: %s", neighDbgStr.get())); + } + return; + } + + nsAutoCString key; + GetAddrStr(neigh->GetAddrPtr(), neigh->Family(), key); + + if (aNlh->nlmsg_type == RTM_NEWNEIGH) { + if (!mRecalculateNetworkId && neigh->HasMAC()) { + NetlinkNeighbor* oldNeigh = nullptr; + linkInfo->mNeighbors.Get(key, &oldNeigh); + + if (!oldNeigh || !oldNeigh->HasMAC()) { + // The MAC address was added, if it's a host from some of the saved + // routing tables we should recalculate network ID + for (uint32_t i = 0; i < linkInfo->mDefaultRoutes.Length(); ++i) { + if (linkInfo->mDefaultRoutes[i]->GatewayEquals(*neigh)) { + TriggerNetworkIDCalculation(); + break; + } + } + if ((mIPv4RouteCheckResult && + mIPv4RouteCheckResult->GatewayEquals(*neigh)) || + (mIPv6RouteCheckResult && + mIPv6RouteCheckResult->GatewayEquals(*neigh))) { + TriggerNetworkIDCalculation(); + } + } + } + + if (LOG_ENABLED()) { + nsAutoCString neighDbgStr; + neigh->GetAsString(neighDbgStr); + LOG(("Adding neighbor: %s", neighDbgStr.get())); + } + linkInfo->mNeighbors.InsertOrUpdate(key, std::move(neigh)); + } else { + if (LOG_ENABLED()) { + nsAutoCString neighDbgStr; + neigh->GetAsString(neighDbgStr); + LOG(("Removing neighbor %s", neighDbgStr.get())); + } + linkInfo->mNeighbors.Remove(key); + } +} + +void NetlinkService::OnRouteCheckResult(struct nlmsghdr* aNlh) { + LOG(("NetlinkService::OnRouteCheckResult")); + UniquePtr route; + + if (aNlh) { + route = MakeUnique(); + if (!route->Init(aNlh)) { + route = nullptr; + } else { + if (!route->IsUnicast() || !route->ScopeIsUniverse()) { + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Not an unicast global route: %s", routeDbgStr.get())); + } + route = nullptr; + } else if (!route->HasOif()) { + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("There is no output interface in route: %s", routeDbgStr.get())); + } + route = nullptr; + } + } + } + + if (LOG_ENABLED()) { + if (route) { + nsAutoCString routeDbgStr; + route->GetAsString(routeDbgStr); + LOG(("Storing route: %s", routeDbgStr.get())); + } else { + LOG(("Clearing result for the check")); + } + } + + if (mOutgoingMessages[0]->Family() == AF_INET) { + mIPv4RouteCheckResult = std::move(route); + } else { + mIPv6RouteCheckResult = std::move(route); + } +} + +void NetlinkService::EnqueueGenMsg(uint16_t aMsgType, uint8_t aFamily) { + NetlinkGenMsg* msg = new NetlinkGenMsg(aMsgType, aFamily, ++mMsgId); + mOutgoingMessages.AppendElement(msg); +} + +void NetlinkService::EnqueueRtMsg(uint8_t aFamily, void* aAddress) { + NetlinkRtMsg* msg = new NetlinkRtMsg(aFamily, aAddress, ++mMsgId); + mOutgoingMessages.AppendElement(msg); +} + +void NetlinkService::RemovePendingMsg() { + LOG(("NetlinkService::RemovePendingMsg [seqId=%u]", + mOutgoingMessages[0]->SeqId())); + + MOZ_ASSERT(mOutgoingMessages[0]->IsPending()); + + DebugOnly isRtMessage = + (mOutgoingMessages[0]->MsgType() == NetlinkMsg::kRtMsg); + + mOutgoingMessages.RemoveElementAt(0); + if (!mOutgoingMessages.Length()) { + if (!mInitialScanFinished) { + // Now we've received all initial data from the kernel. Perform a link + // check and trigger network ID calculation even if it wasn't triggered + // by the incoming messages. + mInitialScanFinished = true; + + TriggerNetworkIDCalculation(); + + // Link status should be known by now. + RefPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + } + if (listener) { + listener->OnLinkStatusKnown(); + } + } else { + // We've received last response for route check, calculate ID now + MOZ_ASSERT(isRtMessage); + CalculateNetworkID(); + } + } +} + +NS_IMETHODIMP +NetlinkService::Run() { + int netlinkSocket = socket(AF_NETLINK, SOCK_RAW, NETLINK_ROUTE); + if (netlinkSocket < 0) { + return NS_ERROR_FAILURE; + } + + struct sockaddr_nl addr {}; + memset(&addr, 0, sizeof(addr)); + + addr.nl_family = AF_NETLINK; + addr.nl_groups = RTMGRP_IPV4_IFADDR | RTMGRP_IPV6_IFADDR | RTMGRP_LINK | + RTMGRP_NEIGH | RTMGRP_IPV4_ROUTE | RTMGRP_IPV6_ROUTE; + + if (bind(netlinkSocket, (struct sockaddr*)&addr, sizeof(addr)) < 0) { + // failure! + EINTR_RETRY(close(netlinkSocket)); + return NS_ERROR_FAILURE; + } + + struct pollfd fds[2]; + fds[0].fd = mShutdownPipe[0]; + fds[0].events = POLLIN; + fds[0].revents = 0; + + fds[1].fd = netlinkSocket; + fds[1].events = POLLIN; + fds[1].revents = 0; + + // send all requests to get initial network information + EnqueueGenMsg(RTM_GETLINK, AF_PACKET); + EnqueueGenMsg(RTM_GETNEIGH, AF_INET); + EnqueueGenMsg(RTM_GETNEIGH, AF_INET6); + EnqueueGenMsg(RTM_GETADDR, AF_PACKET); + EnqueueGenMsg(RTM_GETROUTE, AF_PACKET); + + nsresult rv = NS_OK; + bool shutdown = false; + while (!shutdown) { + if (mOutgoingMessages.Length() && !mOutgoingMessages[0]->IsPending()) { + if (!mOutgoingMessages[0]->Send(netlinkSocket)) { + LOG(("Failed to send netlink message")); + mOutgoingMessages.RemoveElementAt(0); + // try to send another message if available before polling + continue; + } + } + + int rc = eintr_retry([&]() { + AUTO_PROFILER_THREAD_SLEEP; + return poll(fds, 2, GetPollWait()); + }); + + if (rc > 0) { + if (fds[0].revents & POLLIN) { + // shutdown, abort the loop! + LOG(("thread shutdown received, dying...\n")); + shutdown = true; + } else if (fds[1].revents & POLLIN) { + LOG(("netlink message received, handling it...\n")); + OnNetlinkMessage(netlinkSocket); + } + } else if (rc < 0) { + rv = NS_ERROR_FAILURE; + break; + } + } + + EINTR_RETRY(close(netlinkSocket)); + + return rv; +} + +nsresult NetlinkService::Init(NetlinkServiceListener* aListener) { + nsresult rv; + + mListener = aListener; + + if (inet_pton(AF_INET, ROUTE_CHECK_IPV4, &mRouteCheckIPv4) != 1) { + LOG(("Cannot parse address " ROUTE_CHECK_IPV4)); + MOZ_DIAGNOSTIC_ASSERT(false, "Cannot parse address " ROUTE_CHECK_IPV4); + return NS_ERROR_UNEXPECTED; + } + + if (inet_pton(AF_INET6, ROUTE_CHECK_IPV6, &mRouteCheckIPv6) != 1) { + LOG(("Cannot parse address " ROUTE_CHECK_IPV6)); + MOZ_DIAGNOSTIC_ASSERT(false, "Cannot parse address " ROUTE_CHECK_IPV6); + return NS_ERROR_UNEXPECTED; + } + + if (pipe(mShutdownPipe) == -1) { + LOG(("Cannot create pipe")); + return NS_ERROR_FAILURE; + } + + rv = NS_NewNamedThread("Netlink Monitor", getter_AddRefs(mThread), this); + NS_ENSURE_SUCCESS(rv, rv); + + return NS_OK; +} + +nsresult NetlinkService::Shutdown() { + LOG(("write() to signal thread shutdown\n")); + + { + MutexAutoLock lock(mMutex); + mListener = nullptr; + } + + // awake the thread to make it terminate + ssize_t rc = EINTR_RETRY(write(mShutdownPipe[1], "1", 1)); + LOG(("write() returned %d, errno == %d\n", (int)rc, errno)); + + nsresult rv = mThread->Shutdown(); + + // Have to break the cycle here, otherwise NetlinkService holds + // onto the thread and the thread holds onto the NetlinkService + // via its mRunnable + mThread = nullptr; + + return rv; +} + +/* + * A network event that might change network ID has been registered. Delay + * network ID calculation and sending of the event in case it changed for + * a while. Absorbing potential subsequent events increases chance of successful + * network ID calculation (e.g. MAC address of the router might be discovered in + * the meantime) + */ +void NetlinkService::TriggerNetworkIDCalculation() { + LOG(("NetlinkService::TriggerNetworkIDCalculation")); + + if (mRecalculateNetworkId) { + return; + } + + mRecalculateNetworkId = true; + mTriggerTime = TimeStamp::Now(); +} + +int NetlinkService::GetPollWait() { + if (!mRecalculateNetworkId) { + return -1; + } + + if (mOutgoingMessages.Length()) { + MOZ_ASSERT(mOutgoingMessages[0]->IsPending()); + // Message is pending, we don't have to set timeout because we'll receive + // reply from kernel ASAP + return -1; + } + + MOZ_ASSERT(mInitialScanFinished); + + double period = (TimeStamp::Now() - mTriggerTime).ToMilliseconds(); + if (period >= kNetworkChangeCoalescingPeriod) { + // Coalescing time has elapsed, send route check messages to find out + // where IPv4 and IPv6 traffic is routed and calculate network ID after + // the response is received. + EnqueueRtMsg(AF_INET, &mRouteCheckIPv4); + EnqueueRtMsg(AF_INET6, &mRouteCheckIPv6); + + // Return 0 to make sure we start sending enqueued messages immediately + return 0; + } + + return static_cast(kNetworkChangeCoalescingPeriod - period); +} + +class NeighborComparator { + public: + bool Equals(const NetlinkNeighbor* a, const NetlinkNeighbor* b) const { + return (memcmp(a->GetMACPtr(), b->GetMACPtr(), ETH_ALEN) == 0); + } + bool LessThan(const NetlinkNeighbor* a, const NetlinkNeighbor* b) const { + return (memcmp(a->GetMACPtr(), b->GetMACPtr(), ETH_ALEN) < 0); + } +}; + +class LinknameComparator { + public: + bool LessThan(const nsCString& aA, const nsCString& aB) const { + return aA < aB; + } + bool Equals(const nsCString& aA, const nsCString& aB) const { + return aA == aB; + } +}; + +// Get Gateway Neighbours for a particular Address Family, for which we know MAC +// address +void NetlinkService::GetGWNeighboursForFamily( + uint8_t aFamily, nsTArray& aGwNeighbors) { + LOG(("NetlinkService::GetGWNeighboursForFamily")); + // Check only routes on links that are up + for (const auto& linkInfo : mLinks.Values()) { + nsAutoCString linkName; + linkInfo->mLink->GetName(linkName); + + if (!linkInfo->mIsUp) { + LOG((" %s is down", linkName.get())); + continue; + } + + if (!linkInfo->mLink->IsTypeEther()) { + LOG((" %s is not ethernet link", linkName.get())); + continue; + } + + LOG((" checking link %s", linkName.get())); + + // Check all default routes and try to get MAC of the gateway + for (uint32_t i = 0; i < linkInfo->mDefaultRoutes.Length(); ++i) { + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + linkInfo->mDefaultRoutes[i]->GetAsString(routeDbgStr); + LOG(("Checking default route: %s", routeDbgStr.get())); + } + + if (linkInfo->mDefaultRoutes[i]->Family() != aFamily) { + LOG((" skipping due to different family")); + continue; + } + + MOZ_ASSERT(linkInfo->mDefaultRoutes[i]->GetGWAddrPtr(), + "Stored routes must have gateway!"); + + nsAutoCString neighKey; + GetAddrStr(linkInfo->mDefaultRoutes[i]->GetGWAddrPtr(), aFamily, + neighKey); + + NetlinkNeighbor* neigh = nullptr; + if (!linkInfo->mNeighbors.Get(neighKey, &neigh)) { + LOG(("Neighbor %s not found in hashtable.", neighKey.get())); + continue; + } + + if (!neigh->HasMAC()) { + // We don't know MAC address + LOG(("We have no MAC for neighbor %s.", neighKey.get())); + continue; + } + + if (aGwNeighbors.IndexOf(neigh, 0, NeighborComparator()) != + nsTArray::NoIndex) { + // avoid host duplicities + LOG(("MAC of neighbor %s is already selected for hashing.", + neighKey.get())); + continue; + } + + LOG(("MAC of neighbor %s will be used for network ID.", neighKey.get())); + aGwNeighbors.AppendElement(neigh); + } + } +} + +bool NetlinkService::CalculateIDForEthernetLink(uint8_t aFamily, + NetlinkRoute* aRouteCheckResult, + uint32_t aRouteCheckIfIdx, + LinkInfo* aRouteCheckLinkInfo, + SHA1Sum* aSHA1) { + LOG(("NetlinkService::CalculateIDForEthernetLink")); + bool retval = false; + const in_common_addr* addrPtr = aRouteCheckResult->GetGWAddrPtr(); + + if (!addrPtr) { + // This shouldn't normally happen, missing next hop in case of ethernet + // device would mean that the checked host is on the same network. + if (LOG_ENABLED()) { + nsAutoCString routeDbgStr; + aRouteCheckResult->GetAsString(routeDbgStr); + LOG(("There is no next hop in route: %s", routeDbgStr.get())); + } + return retval; + } + + // If we know MAC address of the next hop for mRouteCheckIPv4/6 host, hash + // it even if it's MAC of some of the default routes we've checked above. + // This ensures that if we have 2 different default routes and next hop for + // mRouteCheckIPv4/6 changes from one default route to the other, we'll + // detect it as a network change. + nsAutoCString neighKey; + GetAddrStr(addrPtr, aFamily, neighKey); + LOG(("Next hop for the checked host is %s on ifIdx %u.", neighKey.get(), + aRouteCheckIfIdx)); + + NetlinkNeighbor* neigh = nullptr; + if (!aRouteCheckLinkInfo->mNeighbors.Get(neighKey, &neigh)) { + LOG(("Neighbor %s not found in hashtable.", neighKey.get())); + return retval; + } + + if (!neigh->HasMAC()) { + LOG(("We have no MAC for neighbor %s.", neighKey.get())); + return retval; + } + + if (LOG_ENABLED()) { + nsAutoCString neighDbgStr; + neigh->GetAsString(neighDbgStr); + LOG(("Hashing MAC address of neighbor: %s", neighDbgStr.get())); + } + aSHA1->update(neigh->GetMACPtr(), ETH_ALEN); + retval = true; + + return retval; +} + +bool NetlinkService::CalculateIDForNonEthernetLink( + uint8_t aFamily, NetlinkRoute* aRouteCheckResult, + nsTArray& aLinkNamesToHash, uint32_t aRouteCheckIfIdx, + LinkInfo* aRouteCheckLinkInfo, SHA1Sum* aSHA1) { + LOG(("NetlinkService::CalculateIDForNonEthernetLink")); + bool retval = false; + const in_common_addr* addrPtr = aRouteCheckResult->GetGWAddrPtr(); + nsAutoCString routeCheckLinkName; + aRouteCheckLinkInfo->mLink->GetName(routeCheckLinkName); + + if (addrPtr) { + // The route contains next hop. Hash the name of the interface (e.g. + // "tun1") and the IP address of the next hop. + + nsAutoCString addrStr; + GetAddrStr(addrPtr, aFamily, addrStr); + size_t addrSize = + (aFamily == AF_INET) ? sizeof(addrPtr->addr4) : sizeof(addrPtr->addr6); + + LOG(("Hashing link name %s", routeCheckLinkName.get())); + aSHA1->update(routeCheckLinkName.get(), routeCheckLinkName.Length()); + + // Don't hash GW address if it's rmnet_data device. + if (!aLinkNamesToHash.Contains(routeCheckLinkName)) { + LOG(("Hashing GW address %s", addrStr.get())); + aSHA1->update(addrPtr, addrSize); + } + + retval = true; + } else { + // The traffic is routed directly via an interface. Hash the name of the + // interface and the network address. Using host address would cause that + // network ID would be different every time we get a different IP address + // in this network/VPN. + + bool hasSrcAddr = aRouteCheckResult->HasPrefSrcAddr(); + if (!hasSrcAddr) { + LOG(("There is no preferred source address.")); + } + + NetlinkAddress* linkAddress = nullptr; + // Find network address of the interface matching the source address. In + // theory there could be multiple addresses with different prefix length. + // Get the one with smallest prefix length. + for (uint32_t i = 0; i < aRouteCheckLinkInfo->mAddresses.Length(); ++i) { + if (!hasSrcAddr) { + // there is no preferred src, match just the family + if (aRouteCheckLinkInfo->mAddresses[i]->Family() != aFamily) { + continue; + } + } else if (!aRouteCheckResult->PrefSrcAddrEquals( + *aRouteCheckLinkInfo->mAddresses[i])) { + continue; + } + + if (!linkAddress || + linkAddress->GetPrefixLen() > + aRouteCheckLinkInfo->mAddresses[i]->GetPrefixLen()) { + // We have no address yet or this one has smaller prefix length, + // use it. + linkAddress = aRouteCheckLinkInfo->mAddresses[i].get(); + } + } + + if (!linkAddress) { + // There is no address in our array? + if (LOG_ENABLED()) { + nsAutoCString dbgStr; + aRouteCheckResult->GetAsString(dbgStr); + LOG(("No address found for preferred source address in route: %s", + dbgStr.get())); + } + return retval; + } + + in_common_addr prefix; + int32_t prefixSize = (aFamily == AF_INET) ? (int32_t)sizeof(prefix.addr4) + : (int32_t)sizeof(prefix.addr6); + memcpy(&prefix, linkAddress->GetAddrPtr(), prefixSize); + uint8_t maskit[] = {0x00, 0x80, 0xc0, 0xe0, 0xf0, 0xf8, 0xfc, 0xfe}; + int32_t bits = linkAddress->GetPrefixLen(); + if (bits > prefixSize * 8) { + MOZ_ASSERT(false, "Unexpected prefix length!"); + LOG(("Unexpected prefix length %d, maximum for this family is %d", bits, + prefixSize * 8)); + return retval; + } + for (int32_t i = 0; i < prefixSize; i++) { + uint8_t mask = (bits >= 8) ? 0xff : maskit[bits]; + ((unsigned char*)&prefix)[i] &= mask; + bits -= 8; + if (bits <= 0) { + bits = 0; + } + } + + nsAutoCString addrStr; + GetAddrStr(&prefix, aFamily, addrStr); + LOG(("Hashing link name %s and network address %s/%u", + routeCheckLinkName.get(), addrStr.get(), linkAddress->GetPrefixLen())); + aSHA1->update(routeCheckLinkName.get(), routeCheckLinkName.Length()); + aSHA1->update(&prefix, prefixSize); + bits = linkAddress->GetPrefixLen(); + aSHA1->update(&bits, sizeof(bits)); + retval = true; + } + return retval; +} + +bool NetlinkService::CalculateIDForFamily(uint8_t aFamily, SHA1Sum* aSHA1) { + LOG(("NetlinkService::CalculateIDForFamily [family=%s]", + aFamily == AF_INET ? "AF_INET" : "AF_INET6")); + + bool retval = false; + + if (!mLinkUp) { + // Skip ID calculation if the link is down, we have no ID... + LOG(("Link is down, skipping ID calculation.")); + return retval; + } + + NetlinkRoute* routeCheckResult; + if (aFamily == AF_INET) { + routeCheckResult = mIPv4RouteCheckResult.get(); + } else { + routeCheckResult = mIPv6RouteCheckResult.get(); + } + + // All GW neighbors for which we know MAC address. We'll probably have at + // most only one, but in case we have more default routes, we hash them all + // even though the routing rules sends the traffic only via one of them. + // If the system switches between them, we'll detect the change with + // mIPv4/6RouteCheckResult. + nsTArray gwNeighbors; + + GetGWNeighboursForFamily(aFamily, gwNeighbors); + + // Sort them so we always have the same network ID on the same network + gwNeighbors.Sort(NeighborComparator()); + + for (uint32_t i = 0; i < gwNeighbors.Length(); ++i) { + if (LOG_ENABLED()) { + nsAutoCString neighDbgStr; + gwNeighbors[i]->GetAsString(neighDbgStr); + LOG(("Hashing MAC address of neighbor: %s", neighDbgStr.get())); + } + aSHA1->update(gwNeighbors[i]->GetMACPtr(), ETH_ALEN); + retval = true; + } + + nsTArray linkNamesToHash; + if (!gwNeighbors.Length()) { + // If we don't know MAC of the gateway and link is up, it's probably not + // an ethernet link. If the name of the link begins with "rmnet" then + // the mobile data is used. We cannot easily differentiate when user + // switches sim cards so let's treat mobile data as a single network. We'll + // simply hash link name. If the traffic is redirected via some VPN, it'll + // still be detected below. + + // TODO: maybe we could get operator name via AndroidBridge + for (const auto& linkInfo : mLinks.Values()) { + if (linkInfo->mIsUp) { + nsAutoCString linkName; + linkInfo->mLink->GetName(linkName); + if (StringBeginsWith(linkName, "rmnet"_ns)) { + // Check whether there is some non-local address associated with this + // link. + for (uint32_t i = 0; i < linkInfo->mAddresses.Length(); ++i) { + if (linkInfo->mAddresses[i]->Family() == aFamily && + linkInfo->mAddresses[i]->ScopeIsUniverse()) { + linkNamesToHash.AppendElement(linkName); + break; + } + } + } + } + } + + // Sort link names to ensure consistent results + linkNamesToHash.Sort(LinknameComparator()); + + for (uint32_t i = 0; i < linkNamesToHash.Length(); ++i) { + LOG(("Hashing name of adapter: %s", linkNamesToHash[i].get())); + aSHA1->update(linkNamesToHash[i].get(), linkNamesToHash[i].Length()); + retval = true; + } + } + + if (!routeCheckResult) { + // If we don't have result for route check to mRouteCheckIPv4/6 host, the + // network is unreachable and there is no more to do. + LOG(("There is no route check result.")); + return retval; + } + + LinkInfo* routeCheckLinkInfo = nullptr; + uint32_t routeCheckIfIdx = routeCheckResult->Oif(); + if (!mLinks.Get(routeCheckIfIdx, &routeCheckLinkInfo)) { + LOG(("Cannot find link with index %u ??", routeCheckIfIdx)); + return retval; + } + + if (routeCheckLinkInfo->mLink->IsTypeEther()) { + // The traffic is routed through an ethernet device. + retval |= CalculateIDForEthernetLink( + aFamily, routeCheckResult, routeCheckIfIdx, routeCheckLinkInfo, aSHA1); + } else { + // The traffic is routed through a non-ethernet device. + retval |= CalculateIDForNonEthernetLink(aFamily, routeCheckResult, + linkNamesToHash, routeCheckIfIdx, + routeCheckLinkInfo, aSHA1); + } + + return retval; +} + +void NetlinkService::ExtractDNSProperties() { + MOZ_ASSERT(!NS_IsMainThread(), "Must not be called on the main thread"); + nsTArray suffixList; + nsTArray resolvers; +#if defined(HAVE_RES_NINIT) + [&]() { + struct __res_state res {}; + int ret = res_ninit(&res); + if (ret != 0) { + LOG(("Call to res_ninit failed: %d", ret)); + return; + } + + // Get DNS suffixes + for (int i = 0; i < MAXDNSRCH; i++) { + if (!res.dnsrch[i]) { + break; + } + suffixList.AppendElement(nsCString(res.dnsrch[i])); + } + + // Get DNS resolvers + // Chromium's dns_config_service_posix.cc is the origin of this code + // Initially, glibc stores IPv6 in |_ext.nsaddrs| and IPv4 in |nsaddr_list|. + // In res_send.c:res_nsend, it merges |nsaddr_list| into |nsaddrs|, + // but we have to combine the two arrays ourselves. + for (int i = 0; i < res.nscount; ++i) { + const struct sockaddr* addr = nullptr; + size_t addr_len = 0; + if (res.nsaddr_list[i].sin_family) { // The indicator used by res_nsend. + addr = reinterpret_cast(&res.nsaddr_list[i]); + addr_len = sizeof res.nsaddr_list[i]; + } else if (res._u._ext.nsaddrs[i]) { + addr = reinterpret_cast(res._u._ext.nsaddrs[i]); + addr_len = sizeof *res._u._ext.nsaddrs[i]; + } else { + LOG(("Bad ext struct")); + return; + } + const socklen_t kSockaddrInSize = sizeof(struct sockaddr_in); + const socklen_t kSockaddrIn6Size = sizeof(struct sockaddr_in6); + + if ((addr->sa_family == AF_INET && addr_len < kSockaddrInSize) || + (addr->sa_family == AF_INET6 && addr_len < kSockaddrIn6Size)) { + LOG(("Bad address size")); + return; + } + + NetAddr ip; + if (addr->sa_family == AF_INET) { + const struct sockaddr_in* sin = (const struct sockaddr_in*)addr; + ip.inet.family = AF_INET; + ip.inet.ip = sin->sin_addr.s_addr; + ip.inet.port = sin->sin_port; + } else if (addr->sa_family == AF_INET6) { + const struct sockaddr_in6* sin6 = (const struct sockaddr_in6*)addr; + ip.inet6.family = AF_INET6; + memcpy(&ip.inet6.ip.u8, &sin6->sin6_addr, sizeof(ip.inet6.ip.u8)); + ip.inet6.port = sin6->sin6_port; + } else { + MOZ_ASSERT_UNREACHABLE("Unexpected sa_family"); + return; + } + + resolvers.AppendElement(ip); + } + + res_nclose(&res); + }(); + +#endif + RefPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + mDNSSuffixList = std::move(suffixList); + mDNSResolvers = std::move(resolvers); + } + + if (listener) { + listener->OnDnsSuffixListUpdated(); + } +} + +void NetlinkService::UpdateLinkStatus() { + LOG(("NetlinkService::UpdateLinkStatus")); + + MOZ_ASSERT(!mRecalculateNetworkId); + MOZ_ASSERT(mInitialScanFinished); + + // Link is up when we have a route for ROUTE_CHECK_IPV4 or ROUTE_CHECK_IPV6 + bool newLinkUp = mIPv4RouteCheckResult || mIPv6RouteCheckResult; + + if (mLinkUp == newLinkUp) { + LOG(("Link status hasn't changed [linkUp=%d]", mLinkUp)); + } else { + LOG(("Link status has changed [linkUp=%d]", newLinkUp)); + RefPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + mLinkUp = newLinkUp; + } + if (mLinkUp) { + if (listener) { + listener->OnLinkUp(); + } + } else { + if (listener) { + listener->OnLinkDown(); + } + } + } +} + +// Figure out the "network identification". +void NetlinkService::CalculateNetworkID() { + LOG(("NetlinkService::CalculateNetworkID")); + + MOZ_ASSERT(!NS_IsMainThread(), "Must not be called on the main thread"); + MOZ_ASSERT(mRecalculateNetworkId); + + mRecalculateNetworkId = false; + + SHA1Sum sha1; + + UpdateLinkStatus(); + ExtractDNSProperties(); + + bool idChanged = false; + bool found4 = CalculateIDForFamily(AF_INET, &sha1); + bool found6 = CalculateIDForFamily(AF_INET6, &sha1); + + if (found4 || found6) { + nsAutoCString output; + SeedNetworkId(sha1); + uint8_t digest[SHA1Sum::kHashSize]; + sha1.finish(digest); + nsAutoCString newString(reinterpret_cast(digest), + SHA1Sum::kHashSize); + nsresult rv = Base64Encode(newString, output); + MOZ_RELEASE_ASSERT(NS_SUCCEEDED(rv)); + LOG(("networkid: id %s\n", output.get())); + MutexAutoLock lock(mMutex); + if (mNetworkId != output) { + // new id + if (found4 && !found6) { + Telemetry::Accumulate(Telemetry::NETWORK_ID2, 1); // IPv4 only + } else if (!found4 && found6) { + Telemetry::Accumulate(Telemetry::NETWORK_ID2, 3); // IPv6 only + } else { + Telemetry::Accumulate(Telemetry::NETWORK_ID2, 4); // Both! + } + mNetworkId = output; + idChanged = true; + } else { + // same id + LOG(("Same network id")); + Telemetry::Accumulate(Telemetry::NETWORK_ID2, 2); + } + } else { + // no id + LOG(("No network id")); + MutexAutoLock lock(mMutex); + if (!mNetworkId.IsEmpty()) { + mNetworkId.Truncate(); + idChanged = true; + Telemetry::Accumulate(Telemetry::NETWORK_ID2, 0); + } + } + + // If this is first time we calculate network ID, don't report it as a network + // change. We've started with an empty ID and we've just calculated the + // correct ID. The network hasn't really changed. + static bool initialIDCalculation = true; + + RefPtr listener; + { + MutexAutoLock lock(mMutex); + listener = mListener; + } + + if (!initialIDCalculation && idChanged && listener) { + listener->OnNetworkIDChanged(); + mSendNetworkChangeEvent = true; + } + + if (mSendNetworkChangeEvent && listener) { + listener->OnNetworkChanged(); + } + + initialIDCalculation = false; + mSendNetworkChangeEvent = false; +} + +void NetlinkService::GetNetworkID(nsACString& aNetworkID) { + MutexAutoLock lock(mMutex); + aNetworkID = mNetworkId; +} + +nsresult NetlinkService::GetDnsSuffixList(nsTArray& aDnsSuffixList) { +#if defined(HAVE_RES_NINIT) + MutexAutoLock lock(mMutex); + aDnsSuffixList = mDNSSuffixList.Clone(); + return NS_OK; +#else + return NS_ERROR_NOT_IMPLEMENTED; +#endif +} + +nsresult NetlinkService::GetResolvers(nsTArray& aResolvers) { +#if defined(HAVE_RES_NINIT) + MutexAutoLock lock(mMutex); + aResolvers = mDNSResolvers.Clone(); + return NS_OK; +#else + return NS_ERROR_NOT_IMPLEMENTED; +#endif +} + +void NetlinkService::GetIsLinkUp(bool* aIsUp) { + MutexAutoLock lock(mMutex); + *aIsUp = mLinkUp; +} + +} // namespace mozilla::net diff --git a/netwerk/system/netlink/NetlinkService.h b/netwerk/system/netlink/NetlinkService.h new file mode 100644 index 0000000000..1de3992f47 --- /dev/null +++ b/netwerk/system/netlink/NetlinkService.h @@ -0,0 +1,168 @@ +/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +/* vim:set et sw=2 ts=4: */ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */ +#ifndef NETLINKSERVICE_H_ +#define NETLINKSERVICE_H_ + +#include + +#include "nsIRunnable.h" +#include "nsThreadUtils.h" +#include "nsCOMPtr.h" +#include "mozilla/Mutex.h" +#include "mozilla/TimeStamp.h" +#include "nsClassHashtable.h" +#include "mozilla/SHA1.h" +#include "mozilla/UniquePtr.h" +#include "nsTArray.h" +#include "mozilla/net/DNS.h" + +namespace mozilla { +namespace net { + +class NetlinkAddress; +class NetlinkNeighbor; +class NetlinkLink; +class NetlinkRoute; +class NetlinkMsg; + +class NetlinkServiceListener : public nsISupports { + public: + virtual void OnNetworkChanged() = 0; + virtual void OnNetworkIDChanged() = 0; + virtual void OnLinkUp() = 0; + virtual void OnLinkDown() = 0; + virtual void OnLinkStatusKnown() = 0; + virtual void OnDnsSuffixListUpdated() = 0; + + protected: + virtual ~NetlinkServiceListener() = default; +}; + +class NetlinkService : public nsIRunnable { + virtual ~NetlinkService(); + + public: + NS_DECL_THREADSAFE_ISUPPORTS + NS_DECL_NSIRUNNABLE + + NetlinkService(); + nsresult Init(NetlinkServiceListener* aListener); + nsresult Shutdown(); + void GetNetworkID(nsACString& aNetworkID); + void GetIsLinkUp(bool* aIsUp); + nsresult GetDnsSuffixList(nsTArray& aDnsSuffixList); + nsresult GetResolvers(nsTArray& aResolvers); + + private: + void EnqueueGenMsg(uint16_t aMsgType, uint8_t aFamily); + void EnqueueRtMsg(uint8_t aFamily, void* aAddress); + void RemovePendingMsg(); + + mozilla::Mutex mMutex MOZ_UNANNOTATED{"NetlinkService::mMutex"}; + + void OnNetlinkMessage(int aNetlinkSocket); + void OnLinkMessage(struct nlmsghdr* aNlh); + void OnAddrMessage(struct nlmsghdr* aNlh); + void OnRouteMessage(struct nlmsghdr* aNlh); + void OnNeighborMessage(struct nlmsghdr* aNlh); + void OnRouteCheckResult(struct nlmsghdr* aNlh); + + void UpdateLinkStatus(); + + void TriggerNetworkIDCalculation(); + int GetPollWait(); + void GetGWNeighboursForFamily(uint8_t aFamily, + nsTArray& aGwNeighbors); + bool CalculateIDForFamily(uint8_t aFamily, mozilla::SHA1Sum* aSHA1); + void CalculateNetworkID(); + void ExtractDNSProperties(); + + nsCOMPtr mThread; + + bool mInitialScanFinished{false}; + + // A pipe to signal shutdown with. + int mShutdownPipe[2]{-1, -1}; + + // IP addresses that are used to check the route for public traffic. + struct in_addr mRouteCheckIPv4 {}; + struct in6_addr mRouteCheckIPv6 {}; + + pid_t mPid; + uint32_t mMsgId{0}; + + bool mLinkUp{true}; + + // Flag indicating that network ID could change and should be recalculated. + // Calculation is postponed until we receive responses to all enqueued + // messages. + bool mRecalculateNetworkId{false}; + + // Flag indicating that network change event needs to be sent even if + // network ID hasn't changed. + bool mSendNetworkChangeEvent{false}; + + // Time stamp of setting mRecalculateNetworkId to true + mozilla::TimeStamp mTriggerTime; + + nsCString mNetworkId; + nsTArray mDNSSuffixList; + nsTArray mDNSResolvers; + + class LinkInfo { + public: + explicit LinkInfo(UniquePtr&& aLink); + virtual ~LinkInfo(); + + // Updates mIsUp according to current mLink and mAddresses. Returns true if + // the value has changed. + bool UpdateStatus(); + + // NetlinkLink structure for this link + UniquePtr mLink; + + // All IPv4/IPv6 addresses on this link + nsTArray> mAddresses; + + // All neighbors on this link, key is an address + nsClassHashtable mNeighbors; + + // Default IPv4/IPv6 routes + nsTArray> mDefaultRoutes; + + // Link is up when it's running, it's not a loopback and there is + // a non-local address associated with it. + bool mIsUp; + }; + + bool CalculateIDForEthernetLink(uint8_t aFamily, + NetlinkRoute* aRouteCheckResult, + uint32_t aRouteCheckIfIdx, + LinkInfo* aRouteCheckLinkInfo, + mozilla::SHA1Sum* aSHA1); + bool CalculateIDForNonEthernetLink(uint8_t aFamily, + NetlinkRoute* aRouteCheckResult, + nsTArray& aLinkNamesToHash, + uint32_t aRouteCheckIfIdx, + LinkInfo* aRouteCheckLinkInfo, + mozilla::SHA1Sum* aSHA1); + + nsClassHashtable mLinks; + + // Route for mRouteCheckIPv4 address + UniquePtr mIPv4RouteCheckResult; + // Route for mRouteCheckIPv6 address + UniquePtr mIPv6RouteCheckResult; + + nsTArray> mOutgoingMessages; + + RefPtr mListener; +}; + +} // namespace net +} // namespace mozilla + +#endif /* NETLINKSERVICE_H_ */ diff --git a/netwerk/system/netlink/moz.build b/netwerk/system/netlink/moz.build new file mode 100644 index 0000000000..6882a21126 --- /dev/null +++ b/netwerk/system/netlink/moz.build @@ -0,0 +1,12 @@ +# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*- +# vim: set filetype=python: +# This Source Code Form is subject to the terms of the Mozilla Public +# License, v. 2.0. If a copy of the MPL was not distributed with this +# file, You can obtain one at http://mozilla.org/MPL/2.0/. + +if CONFIG["OS_ARCH"] == "Linux": + SOURCES += [ + "NetlinkService.cpp", + ] + +FINAL_LIBRARY = "xul" -- cgit v1.2.3