hw_address.h

/*
 * Copyright (c) 2017, Matias Fontanini
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met:
 * 
 * * Redistributions of source code must retain the above copyright
 *   notice, this list of conditions and the following disclaimer.
 * * Redistributions in binary form must reproduce the above
 *   copyright notice, this list of conditions and the following disclaimer
 *   in the documentation and/or other materials provided with the
 *   distribution.
 * 
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
 * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
 * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
 * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
 * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
 * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 */
 
#ifndef TINS_HWADDRESS_H
#define TINS_HWADDRESS_H

#include <stdint.h>
#include <iosfwd>
#include <string>
#include <cstring>
#include <tins/cxxstd.h>
#include <tins/macros.h>
#if TINS_IS_CXX11
    // std::hash
    #include <memory>
#endif // TINS_IS_CXX11

namespace Tins {
namespace Internals {

// Defined in hw_address.cpp
TINS_API std::string hw_address_to_string(const uint8_t* ptr, size_t count);

TINS_API void string_to_hw_address(const std::string& hw_addr, uint8_t* output,
                                   size_t output_size);

TINS_API bool hw_address_equal_compare(const uint8_t* start1, const uint8_t* end1,
                                      const uint8_t* start2);

TINS_API bool hw_address_lt_compare(const uint8_t* start1, const uint8_t* end1,
                                    const uint8_t* start2, const uint8_t* end2);

TINS_API bool hw_address_gt_compare(const uint8_t* start1, const uint8_t* end1,
                                    const uint8_t* start2, const uint8_t* end2);

} // Internals

template<size_t n>
class HWAddress {
public:
    typedef uint8_t storage_type;
    
    typedef storage_type* iterator;
    
    typedef const storage_type* const_iterator;
    
    static const size_t address_size = n;

    static const HWAddress<n> broadcast;
    
    HWAddress(const storage_type* ptr = 0) {
        if (ptr) {
            std::memcpy(buffer_, ptr, address_size);
        }
        else {
            std::memset(buffer_, 0, address_size);
        }
    }
    
    HWAddress(const std::string& address) {
        Internals::string_to_hw_address(address, buffer_, n);
    }
    
    template<size_t i>
    HWAddress(const char (&address)[i]) {
        Internals::string_to_hw_address(address, buffer_, n);
    }
    
    template<size_t i>
    HWAddress(const HWAddress<i>& rhs) {
        size_t copy_threshold = i < n ? i : n;
        for (size_t index = 0; index < n; ++index) {
            if (index < copy_threshold) {
                buffer_[index] = rhs[index];
            }
            else {
                buffer_[index] = storage_type();
            }
        }
    }
    
    iterator begin() {
        return buffer_;
    }
    
    const_iterator begin() const {
        return buffer_;
    }
    
    iterator end() {
        return buffer_ + address_size;
    }

    const_iterator end() const {
        return buffer_ + address_size;
    }
    
    bool operator==(const HWAddress& rhs) const {
        return Internals::hw_address_equal_compare(begin(), end(), rhs.begin());
    }
    
    bool operator!=(const HWAddress& rhs) const {
        return !(*this == rhs);
    }
    
    bool operator<(const HWAddress& rhs) const {
        return Internals::hw_address_lt_compare(begin(), end(), rhs.begin(), rhs.end());
    }

    bool operator<=(const HWAddress& rhs) const {
        return !operator>(rhs);
    }

    bool operator>(const HWAddress& rhs) const {
        return Internals::hw_address_gt_compare(begin(), end(), rhs.begin(), rhs.end());
    }

    bool operator>=(const HWAddress& rhs) const {
        return !operator<(rhs);
    }

    HWAddress operator&(const HWAddress& mask) const {
        HWAddress<n> output = *this;
        for (size_t i = 0; i < n; ++i) {
            output[i] = output[i] & mask[i];
        }
        return output;
    }

   HWAddress operator|(const HWAddress& mask) const {
       HWAddress<n> output = *this;
       for (size_t i = 0; i < n; ++i) {
           output[i] = output[i] | mask[i];
       }
       return output;
   }

   HWAddress operator~() const {
       HWAddress<n> output = *this;
       for (size_t i = 0; i < n; ++i) {
           output[i] = ~output[i];
       }
       return output;
   }

    size_t size() const {
        return address_size;
    }
    
    bool is_broadcast() const {
        return* this == broadcast;
    }
    
    bool is_multicast() const {
        return (*begin() & 0x01);
    }

    bool is_unicast() const {
        return !is_broadcast() && !is_multicast();
    }

    std::string to_string() const {
        return Internals::hw_address_to_string(buffer_, size());
    }

    storage_type operator[](size_t i) const {
        return begin()[i];
    }

    storage_type& operator[](size_t i) {
        return begin()[i];
    }
    
    friend std::ostream& operator<<(std::ostream& os, const HWAddress& addr) {
        return os << addr.to_string();
    }
    
    template<typename OutputIterator>
    OutputIterator copy(OutputIterator output) const {
        for (const_iterator iter = begin(); iter != end(); ++iter) {
            *output++ = *iter;
        }
        return output;
    }
private:
    static HWAddress<n> make_broadcast_address() {
        // Build a buffer made of n 0xff bytes
        uint8_t buffer[n];
        for (size_t i = 0; i < n; ++i) {
            buffer[i] = 0xff;
        }
        return HWAddress<n>(buffer);
    }

    storage_type buffer_[n];
};

template<size_t n>
const HWAddress<n> HWAddress<n>::broadcast = make_broadcast_address();

} // namespace Tins

#if TINS_IS_CXX11
namespace std {

// Specialization of std::hash for HWAddress
template<size_t n>
struct hash<Tins::HWAddress<n>> {
    size_t operator()(const Tins::HWAddress<n>& addr) const {
        return std::hash<std::string>()(addr.to_string());
    }
};

} // namespace std
#endif // TINS_IS_CXX11

#endif // TINS_HWADDRESS_H