headers.hpp

Go to the documentation of this file.

#ifndef HEADERS_HPP
#define HEADERS_HPP

#include <array>
#include <cstdint>
#include <cstring>
#include <sstream>
#include <string>

#include <arpa/inet.h>

namespace Headers {

struct Ethernet {
    std::array<uint8_t, 6> destMac; 
    std::array<uint8_t, 6> srcMac;  
    uint16_t ethertype;             

    void *getPayload() {
        return reinterpret_cast<void *>(
            reinterpret_cast<uint8_t *>(this) + sizeof(struct Ethernet));
    }

    static std::string addrToStr(std::array<uint8_t, 6> addr) {
        std::stringstream str;
        str << std::hex << static_cast<int>(addr[0]) << ":" << std::hex
            << static_cast<int>(addr[1]) << ":" << std::hex << static_cast<int>(addr[2])
            << ":" << std::hex << static_cast<int>(addr[3]) << ":" << std::hex
            << static_cast<int>(addr[4]) << ":" << std::hex << static_cast<int>(addr[5]);
        return str.str();
    }

    std::string getSrcAddr() { return addrToStr(this->srcMac); }

    std::string getDstAddr() { return addrToStr(this->destMac); }

    uint16_t getEthertype() { return ntohs(this->ethertype); }

    static constexpr uint16_t ETHERTYPE_IPv4 = 0x0800;
    static constexpr uint16_t ETHERTYPE_IPv6 = 0x86dd;

    void setEthertype(uint16_t type) { this->ethertype = htons(type); }

    void setSrcAddr(const std::array<uint8_t, 6> addr) {
        memcpy(this->srcMac.data(), addr.data(), 6);
    }

    void setDstAddr(std::array<uint8_t, 6> addr) {
        memcpy(this->destMac.data(), addr.data(), 6);
    }

} __attribute__((packed));

struct IPv4 {
    uint8_t version_ihl; 

    uint8_t version() const { return (version_ihl & 0xf0) >> 4; }
    uint8_t ihl() const { return version_ihl & 0x0f; }

    void setVersion() {
        version_ihl &= 0x0f;
        version_ihl |= 0x40;
    }

    void setIHL(uint8_t len) {
        version_ihl &= 0xf0;
        len &= 0x0f;
        version_ihl |= len;
    }

    uint8_t tos;           
    uint16_t total_length; 

    void setPayloadLength(uint16_t len) { total_length = htons(ihl() * 4 + len); }

    uint16_t getPayloadLength() const { return ntohl(total_length) - ihl() * 4; }

    uint16_t id;                  
    uint16_t flags_fragmentation; 

    uint16_t fragmentation() const { return flags_fragmentation & 0x1fff; }
    uint16_t flags() const { return flags_fragmentation >> 18; }

    uint8_t ttl;   
    uint8_t proto; 

    static constexpr uint8_t PROTO_ICMP = 1;
    static constexpr uint8_t PROTO_TCP = 6;
    static constexpr uint8_t PROTO_UDP = 17;

    void setProtoICMP() { proto = PROTO_ICMP; }

    void setProtoTCP() { proto = PROTO_TCP; }

    void setProtoUDP() { proto = PROTO_UDP; }

    uint16_t checksum; 
    uint32_t srcIP; 
    uint32_t dstIP; 

    void setSrcIP(uint32_t ip) { srcIP = htonl(ip); }

    void setDstIP(uint32_t ip) { dstIP = htonl(ip); }

    uint32_t getSrcIP() const { return ntohl(srcIP); }

    uint32_t getDstIP() const { return ntohl(dstIP); }

    void *getPayload() {
        return reinterpret_cast<void *>(reinterpret_cast<uint8_t *>(this) + 4 * ihl());
    }

    static std::string addrToStr(uint32_t addr) {
        std::stringstream str;
        str << (addr >> 24) << "." << ((addr >> 16) & 0xff) << "." << ((addr >> 8) & 0xff)
            << "." << (addr & 0xff);
        return str.str();
    }

    std::string getSrcAddr() { return addrToStr(this->srcIP); }

    std::string getDstAddr() { return addrToStr(this->dstIP); }

    void setLength(uint16_t len) { this->total_length = htons(len); }

    uint16_t getLength() { return ntohs(this->total_length); }

    void calcChecksum() {
        uint32_t result = 0;
        uint16_t *hdr_cast = reinterpret_cast<uint16_t *>(this);

        this->checksum = 0;
        for (uint8_t i = 0; i < (this->ihl() * 4); i++) {
            result += ntohs(hdr_cast[i]);
            if (result & (1 << 16)) {
                result &= 0xffff;
                result++;
            }
        }

        this->checksum = htons(~result);
    };

} __attribute__((packed));

struct Tcp {
    uint16_t srcPort;     
    uint16_t dstPort;     
    uint32_t seq;          
    uint32_t ack;          
    uint16_t offset_flags; 
    uint16_t window;       
    uint16_t checksum;   
    uint16_t urgend_ptr;   

    void *getPayload() {
        return reinterpret_cast<void *>(
            reinterpret_cast<uint8_t *>(this) + sizeof(struct Tcp));
    }

} __attribute__((packed));

struct Udp {
    uint16_t srcPort;  
    uint16_t dstPort;  
    uint16_t len;     
    uint16_t checksum; 

    void setSrcPort(uint16_t p) { srcPort = htons(p); }

    void setDstPort(uint16_t p) { dstPort = htons(p); }

    uint16_t getSrcPort() const { return ntohs(srcPort); }

    uint16_t getDstPort() const { return ntohs(dstPort); }

    uint16_t getPayloadLength() const { return ntohs(len) - sizeof(struct Udp); }

    void setPayloadLength(uint16_t length) { len = htons(length + sizeof(struct Udp)); }

    void *getPayload() {
        return reinterpret_cast<void *>(
            reinterpret_cast<uint8_t *>(this) + sizeof(struct Udp));
    }

} __attribute__((packed));

struct Icmp {
    uint8_t type;     
    uint8_t code;     
    uint16_t checksum; 
} __attribute__((packed));

} // namespace Headers

#endif /* HEADERS_HPP */