ZeroTierOne/osdep/LinuxNetLink.hpp

/*
 * Copyright (c)2019 ZeroTier, Inc.
 *
 * Use of this software is governed by the Business Source License included
 * in the LICENSE.TXT file in the project's root directory.
 *
 * Change Date: 2026-01-01
 *
 * On the date above, in accordance with the Business Source License, use
 * of this software will be governed by version 2.0 of the Apache License.
 */
/****/

#ifndef ZT_LINUX_NETLINK_HPP
#define ZT_LINUX_NETLINK_HPP

#include "../node/Constants.hpp"

#ifdef __LINUX__

#include <asm/types.h>
#include <linux/rtnetlink.h>
#include <map>
#include <set>
#include <sys/socket.h>
#include <vector>
// #include <linux/if.h>

#include "../node/Hashtable.hpp"
#include "../node/InetAddress.hpp"
#include "../node/MAC.hpp"
#include "../node/Mutex.hpp"
#include "Thread.hpp"

namespace ZeroTier {

/**
 * Interface with Linux's RTNETLINK
 */
class LinuxNetLink {
  private:
    LinuxNetLink();
    ~LinuxNetLink();

  public:
    struct Route {
        InetAddress target;
        InetAddress via;
        InetAddress src;
        int ifidx;

        inline bool operator==(const Route& r) const
        {
            return ((target == r.target) && (via == r.via) && (src == r.src) && (ifidx == r.ifidx));
        }
        inline bool operator!=(const Route& r) const
        {
            return (! (*this == r));
        }
        inline bool operator<(const Route& r) const
        {
            if (target < r.target) {
                return true;
            }
            else if (target == r.target) {
                if (via < r.via) {
                    return true;
                }
                else if (via == r.via) {
                    if (src < r.src) {
                        return true;
                    }
                    else if (src == r.src) {
                        return (ifidx < r.ifidx);
                    }
                }
            }
            return false;
        }
        inline bool operator>(const Route& r) const
        {
            return (r < *this);
        }
        inline bool operator<=(const Route& r) const
        {
            return ! (r < *this);
        }
        inline bool operator>=(const Route& r) const
        {
            return ! (*this < r);
        }
    };

    static LinuxNetLink& getInstance()
    {
        static LinuxNetLink instance;
        return instance;
    }

    LinuxNetLink(LinuxNetLink const&) = delete;
    void operator=(LinuxNetLink const&) = delete;

    void addRoute(const InetAddress& target, const InetAddress& via, const InetAddress& src, const char* ifaceName);
    void delRoute(const InetAddress& target, const InetAddress& via, const InetAddress& src, const char* ifaceName);

    void addAddress(const InetAddress& addr, const char* iface);
    void removeAddress(const InetAddress& addr, const char* iface);

    bool routeIsSet(const InetAddress& target, const InetAddress& via, const InetAddress& src, const char* ifname);

    void threadMain() throw();

  private:
    int _doRecv(int fd);

    void _processMessage(struct nlmsghdr* nlp, int nll);
    void _routeAdded(struct nlmsghdr* nlp);
    void _routeDeleted(struct nlmsghdr* nlp);
    void _linkAdded(struct nlmsghdr* nlp);
    void _linkDeleted(struct nlmsghdr* nlp);
    void _ipAddressAdded(struct nlmsghdr* nlp);
    void _ipAddressDeleted(struct nlmsghdr* nlp);

    void _requestInterfaceList();
    void _requestIPv4Routes();
    void _requestIPv6Routes();

    int _indexForInterface(const char* iface);

    void _setSocketTimeout(int fd, int seconds = 1);

    Thread _t;
    bool _running;

    uint32_t _seq;

    std::map<InetAddress, std::set<LinuxNetLink::Route> > _routes;
    Mutex _routes_m;

    struct iface_entry {
        iface_entry()
        {
            memset(this, 0, sizeof(iface_entry));
        }
        int index;
        char ifacename[16];   // IFNAMSIZ on Linux == 16
        char mac[18];
        char mac_bin[6];
        unsigned int mtu;
    };
    Hashtable<int, iface_entry> _interfaces;
    Mutex _if_m;

    // socket communication vars;
    int _fd;
    struct sockaddr_nl _la;
};

}   // namespace ZeroTier

#endif

#endif   // ZT_LINUX_NETLINK_HPPS