dhcp.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_DHCP_H
#define TINS_DHCP_H

#include <vector>
#include <string>
#include <tins/bootp.h>
#include <tins/macros.h>
#include <tins/pdu_option.h>
#include <tins/cxxstd.h>

namespace Tins {

class TINS_API DHCP : public BootP {
public:
    static const PDU::PDUType pdu_flag = PDU::DHCP;

    enum Flags {
        DISCOVER = 1,
        OFFER    = 2,
        REQUEST  = 3,
        DECLINE  = 4,
        ACK      = 5,
        NAK      = 6,
        RELEASE  = 7,
        INFORM   = 8
    };
    
    enum OptionTypes {
        PAD,
        SUBNET_MASK,
        TIME_OFFSET,
        ROUTERS,
        TIME_SERVERS,
        NAME_SERVERS,
        DOMAIN_NAME_SERVERS,
        LOG_SERVERS,
        COOKIE_SERVERS,
        LPR_SERVERS,
        IMPRESS_SERVERS,
        RESOURCE_LOCATION_SERVERS,
        HOST_NAME,
        BOOT_SIZE,
        MERIT_DUMP,
        DOMAIN_NAME,
        SWAP_SERVER,
        ROOT_PATH,
        EXTENSIONS_PATH,
        IP_FORWARDING,
        NON_LOCAL_SOURCE_ROUTING,
        POLICY_FILTER,
        MAX_DGRAM_REASSEMBLY,
        DEFAULT_IP_TTL,
        PATH_MTU_AGING_TIMEOUT,
        PATH_MTU_PLATEAU_TABLE,
        INTERFACE_MTU,
        ALL_SUBNETS_LOCAL,
        BROADCAST_ADDRESS,
        PERFORM_MASK_DISCOVERY,
        MASK_SUPPLIER,
        ROUTER_DISCOVERY,
        ROUTER_SOLICITATION_ADDRESS,
        STATIC_ROUTES,
        TRAILER_ENCAPSULATION,
        ARP_CACHE_TIMEOUT,
        IEEE802_3_ENCAPSULATION,
        DEFAULT_TCP_TTL,
        TCP_KEEPALIVE_INTERVAL,
        TCP_KEEPALIVE_GARBAGE,
        NIS_DOMAIN,
        NIS_SERVERS,
        NTP_SERVERS,
        VENDOR_ENCAPSULATED_OPTIONS,
        NETBIOS_NAME_SERVERS,
        NETBIOS_DD_SERVER,
        NETBIOS_NODE_TYPE,
        NETBIOS_SCOPE,
        FONT_SERVERS,
        X_DISPLAY_MANAGER,
        DHCP_REQUESTED_ADDRESS,
        DHCP_LEASE_TIME,
        DHCP_OPTION_OVERLOAD,
        DHCP_MESSAGE_TYPE,
        DHCP_SERVER_IDENTIFIER,
        DHCP_PARAMETER_REQUEST_LIST,
        DHCP_MESSAGE,
        DHCP_MAX_MESSAGE_SIZE,
        DHCP_RENEWAL_TIME,
        DHCP_REBINDING_TIME,
        VENDOR_CLASS_IDENTIFIER,
        DHCP_CLIENT_IDENTIFIER,
        NWIP_DOMAIN_NAME,
        NWIP_SUBOPTIONS,
        USER_CLASS = 77,
        FQDN = 81,
        DHCP_AGENT_OPTIONS = 82,
        SUBNET_SELECTION = 118,
        AUTHENTICATE = 210,
        END = 255
    };
    
    typedef PDUOption<uint8_t, DHCP> option;
    
    typedef std::vector<option> options_type;
    
    static metadata extract_metadata(const uint8_t *buffer, uint32_t total_sz);

    DHCP();
    
    DHCP(const uint8_t* buffer, uint32_t total_sz);
    
    void add_option(const option& opt);
    
    #if TINS_IS_CXX11

        void add_option(option &&opt) {
            internal_add_option(opt);
            options_.push_back(std::move(opt));
        }
    #endif 

    bool remove_option(OptionTypes type);

    const option* search_option(OptionTypes opt) const;
    
    void type(Flags type);
    
    void end();
    
    void server_identifier(ipaddress_type ip);
    
    void lease_time(uint32_t time);
    
    void renewal_time(uint32_t time);
    
    void rebind_time(uint32_t time);
    
    void subnet_mask(ipaddress_type mask);
    
    void routers(const std::vector<ipaddress_type>& routers);
    
    void domain_name_servers(const std::vector<ipaddress_type>& dns);
    
    void broadcast(ipaddress_type addr);
    
    void requested_ip(ipaddress_type addr);
    
    void domain_name(const std::string& name);

    void hostname(const std::string& name);
    
    // Option getters
    
    uint8_t type() const;
    
    ipaddress_type server_identifier() const;
    
    uint32_t lease_time() const;
            
    uint32_t renewal_time() const;
    
    uint32_t rebind_time() const;
    
    ipaddress_type subnet_mask() const;
    
    std::vector<ipaddress_type> routers() const;
    
    std::vector<ipaddress_type> domain_name_servers() const; 
    
    ipaddress_type broadcast() const;
    
    ipaddress_type requested_ip() const;
    
    std::string domain_name() const;

    std::string hostname() const;
    
    const options_type options() const { return options_; }
    
    PDUType pdu_type() const { return pdu_flag; }
    
    uint32_t header_size() const;
    
    DHCP* clone() const {
        return new DHCP(*this);
    }
private:
    static const uint32_t MAX_DHCP_SIZE;
  
    void write_serialization(uint8_t* buffer, uint32_t total_sz);

    template <typename T> 
    T search_and_convert(OptionTypes opt) const {
        const option* option = search_option(opt);
        if (!option) {
            throw option_not_found();
        }
        return option->to<T>();
    }
    
    void internal_add_option(const option& opt);
    serialization_type serialize_list(const std::vector<ipaddress_type>& ip_list);
    options_type::const_iterator search_option_iterator(OptionTypes opt) const;
    options_type::iterator search_option_iterator(OptionTypes opt);
    
    options_type options_;
    uint32_t size_;
};

} // Tins

#endif // TINS_DHCP_H