/*
 * 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.
 */
/****/

#include "Arp.hpp"

#include "OSUtils.hpp"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

namespace ZeroTier {

static const uint8_t ARP_REQUEST_HEADER[8] = { 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x01 };
static const uint8_t ARP_RESPONSE_HEADER[8] = { 0x00, 0x01, 0x08, 0x00, 0x06, 0x04, 0x00, 0x02 };

Arp::Arp() : _cache(256), _lastCleaned(OSUtils::now())
{
}

void Arp::addLocal(uint32_t ip, const MAC& mac)
{
    _ArpEntry& e = _cache[ip];
    e.lastQuerySent = 0;          // local IP
    e.lastResponseReceived = 0;   // local IP
    e.mac = mac;
    e.local = true;
}

void Arp::remove(uint32_t ip)
{
    _cache.erase(ip);
}

uint32_t Arp::processIncomingArp(const void* arp, unsigned int len, void* response, unsigned int& responseLen, MAC& responseDest)
{
    const uint64_t now = OSUtils::now();
    uint32_t ip = 0;

    responseLen = 0;
    responseDest.zero();

    if (len >= 28) {
        if (! memcmp(arp, ARP_REQUEST_HEADER, 8)) {
            // Respond to ARP requests for locally-known IPs
            _ArpEntry* targetEntry = _cache.get(reinterpret_cast<const uint32_t*>(arp)[6]);
            if ((targetEntry) && (targetEntry->local)) {
                memcpy(response, ARP_RESPONSE_HEADER, 8);
                targetEntry->mac.copyTo(reinterpret_cast<uint8_t*>(response) + 8, 6);
                memcpy(reinterpret_cast<uint8_t*>(response) + 14, reinterpret_cast<const uint8_t*>(arp) + 24, 4);
                memcpy(reinterpret_cast<uint8_t*>(response) + 18, reinterpret_cast<const uint8_t*>(arp) + 8, 10);
                responseLen = 28;
                responseDest.setTo(reinterpret_cast<const uint8_t*>(arp) + 8, 6);
            }
        }
        else if (! memcmp(arp, ARP_RESPONSE_HEADER, 8)) {
            // Learn cache entries for remote IPs from relevant ARP replies
            uint32_t responseIp = 0;
            memcpy(&responseIp, reinterpret_cast<const uint8_t*>(arp) + 14, 4);
            _ArpEntry* queryEntry = _cache.get(responseIp);
            if ((queryEntry) && (! queryEntry->local) && ((now - queryEntry->lastQuerySent) <= ZT_ARP_QUERY_MAX_TTL)) {
                queryEntry->lastResponseReceived = now;
                queryEntry->mac.setTo(reinterpret_cast<const uint8_t*>(arp) + 8, 6);
                ip = responseIp;
            }
        }
    }

    if ((now - _lastCleaned) >= ZT_ARP_EXPIRE) {
        _lastCleaned = now;
        Hashtable<uint32_t, _ArpEntry>::Iterator i(_cache);
        uint32_t* k = (uint32_t*)0;
        _ArpEntry* v = (_ArpEntry*)0;
        while (i.next(k, v)) {
            if ((! v->local) && ((now - v->lastResponseReceived) >= ZT_ARP_EXPIRE))
                _cache.erase(*k);
        }
    }

    return ip;
}

MAC Arp::query(const MAC& localMac, uint32_t localIp, uint32_t targetIp, void* query, unsigned int& queryLen, MAC& queryDest)
{
    const uint64_t now = OSUtils::now();

    _ArpEntry& e = _cache[targetIp];

    if (((e.mac) && ((now - e.lastResponseReceived) >= (ZT_ARP_EXPIRE / 3))) || ((! e.mac) && ((now - e.lastQuerySent) >= ZT_ARP_QUERY_INTERVAL))) {
        e.lastQuerySent = now;

        uint8_t* q = reinterpret_cast<uint8_t*>(query);
        memcpy(q, ARP_REQUEST_HEADER, 8);
        q += 8;   // ARP request header information, always the same
        localMac.copyTo(q, 6);
        q += 6;   // sending host MAC address
        memcpy(q, &localIp, 4);
        q += 4;   // sending host IP (IP already in big-endian byte order)
        memset(q, 0, 6);
        q += 6;                    // sending zeros for target MAC address as thats what we want to find
        memcpy(q, &targetIp, 4);   // target IP address for resolution (IP already in big-endian byte order)
        queryLen = 28;
        if (e.mac)
            queryDest = e.mac;   // confirmation query, send directly to address holder
        else
            queryDest = (uint64_t)0xffffffffffffULL;   // broadcast query
    }
    else {
        queryLen = 0;
        queryDest.zero();
    }

    return e.mac;
}

}   // namespace ZeroTier