dhcp/server/lease.h

/*
 * Copyright 2017, 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.
 */

#pragma once

#include <linux/if_ether.h>
#include <stdint.h>

#include <functional>

// A lease consists of both the interface index and the MAC address. This
// way the server can run on many different interfaces that have the same
// client MAC address without giving out the same IP address. The reason
// this is useful is because we might have several virtual interfaces, one
// for each access point, that all have the same endpoint on the other side.
// This endpoint would then have the same MAC address and always get the
// same address. But for routing purposes it's useful to give it different
// addresses depending on the server side interface. That way the routing
// table can be set up so that packets are forwarded to the correct access
// point interface based on IP address.
struct Lease {
    Lease(unsigned int interfaceIndex, const uint8_t* macAddress) {
        InterfaceIndex = interfaceIndex;
        memcpy(MacAddress, macAddress, sizeof(MacAddress));
    }
    unsigned int InterfaceIndex;
    uint8_t MacAddress[ETH_ALEN];
};

template<class T>
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<Lease> {
    size_t operator()(const Lease& lease) const {
        size_t seed = 0;
        hash_combine(seed, lease.InterfaceIndex);
        // Treat the first 4 bytes as an uint32_t to save some computation
        hash_combine(seed, *reinterpret_cast<const uint32_t*>(lease.MacAddress));
        // And the remaining 2 bytes as an uint16_t
        hash_combine(seed,
                     *reinterpret_cast<const uint16_t*>(lease.MacAddress + 4));
        return seed;
    }
};
}

inline bool operator==(const Lease& left, const Lease& right) {
    return left.InterfaceIndex == right.InterfaceIndex &&
        memcmp(left.MacAddress, right.MacAddress, sizeof(left.MacAddress)) == 0;
}