bootp.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_BOOTP_H
#define TINS_BOOTP_H

#include <stdint.h>
#include <vector>
#include <tins/pdu.h>
#include <tins/macros.h>
#include <tins/endianness.h>
#include <tins/ip_address.h>
#include <tins/hw_address.h>

namespace Tins {

class TINS_API BootP : public PDU {
public:
    typedef IPv4Address ipaddress_type;
    
    typedef HWAddress<16> chaddr_type;
    
    typedef std::vector<uint8_t> vend_type;
    
    static const PDU::PDUType pdu_flag = PDU::BOOTP;

    enum OpCodes {
        BOOTREQUEST = 1,
        BOOTREPLY = 2
    };

    BootP();

    BootP(const uint8_t* buffer, uint32_t total_sz, uint32_t vend_field_size = 64);

    /* Getters */

    uint8_t opcode() const { return bootp_.opcode; }

    uint8_t htype() const { return bootp_.htype; }

    uint8_t hlen() const { return bootp_.hlen; }

    uint8_t hops() const { return bootp_.hops; }

    uint32_t xid() const { return Endian::be_to_host(bootp_.xid); }

    uint16_t secs() const { return Endian::be_to_host(bootp_.secs); }

    uint16_t padding() const { return Endian::be_to_host(bootp_.padding); }

    ipaddress_type ciaddr() const { return ipaddress_type(bootp_.ciaddr); }

    ipaddress_type yiaddr() const { return ipaddress_type(bootp_.yiaddr); }

    ipaddress_type siaddr() const { return ipaddress_type(bootp_.siaddr); }

    ipaddress_type giaddr() const { return ipaddress_type(bootp_.giaddr); }

    chaddr_type chaddr() const { return bootp_.chaddr; }

    const uint8_t* sname() const { return bootp_.sname; }

    const uint8_t* file() const { return bootp_.file; }

    const vend_type& vend() const { return vend_; }

    uint32_t header_size() const;
    /* Setters */

    void opcode(uint8_t code);

    void htype(uint8_t type);

    void hlen(uint8_t length);

    void hops(uint8_t count);

    void xid(uint32_t identifier);

    void secs(uint16_t value);

    void padding(uint16_t value);

    void ciaddr(ipaddress_type address);

    void yiaddr(ipaddress_type address);

    void siaddr(ipaddress_type address);

    void giaddr(ipaddress_type address);

    template<size_t n>
    void chaddr(const HWAddress<n>& new_chaddr) {
        size_t copy_threshold = std::min(n, sizeof(bootp_.chaddr));
        for (size_t i = 0; i < copy_threshold; ++i) {
            if (i < copy_threshold) {
                bootp_.chaddr[i] = new_chaddr[i];
            }
            else {
                bootp_.chaddr[i] = 0;
            }
        }
    }

    void sname(const uint8_t* new_sname);

    void file(const uint8_t* new_file);

    void vend(const vend_type& newvend_);

    bool matches_response(const uint8_t* ptr, uint32_t total_sz) const;

    PDUType pdu_type() const { return pdu_flag; }

    BootP* clone() const {
        return new BootP(*this);
    }
protected:
    vend_type& vend() { return vend_; }

    void write_serialization(uint8_t* buffer, uint32_t total_sz);
    
    TINS_BEGIN_PACK
    struct bootp_header {
        uint8_t opcode;
        uint8_t htype;
        uint8_t hlen;
        uint8_t hops;
        uint32_t xid;
        uint16_t secs;
        uint16_t padding;
        uint32_t ciaddr;
        uint32_t yiaddr;
        uint32_t siaddr;
        uint32_t giaddr;
        uint8_t chaddr[16];
        uint8_t sname[64];
        uint8_t file[128];
    } TINS_END_PACK;

private:
    bootp_header bootp_;
    vend_type vend_;
};

} // Tins

#endif // TINS_BOOTP_H