Added IP pdu class. It's compiling so far.

src/ip.cpp

@@ -0,0 +1,77 @@
+#include <cstring>
+#include <cassert>
+#ifndef WIN32
+    #include <netinet/in.h>
+#endif
+#include "ip.h"
+#include "utils.h"
+
+using namespace std;
+
+
+Tins::IP::IP(const string &ip_dst, const string &ip_src) : PDU(IPPROTO_IP) {
+    memset(&_ip, 0, sizeof(iphdr));
+    if(ip_dst.size())
+        _ip.daddr = Utils::ip_to_int(ip_dst);
+    if(ip_src.size())
+        _ip.saddr = Utils::ip_to_int(ip_src);
+}
+
+Tins::IP::IP(uint32_t ip_dst, uint32_t ip_src) : PDU(IPPROTO_IP) {
+    memset(&_ip, 0, sizeof(iphdr));
+    _ip.daddr = ip_dst;
+    _ip.saddr = ip_src;
+}
+
+void Tins::IP::tos(uint8_t new_tos) {
+    _ip.tos = new_tos;
+}
+
+void Tins::IP::tot_len(uint16_t new_tot_len) {
+    _ip.tot_len = new_tot_len;
+}
+
+void Tins::IP::id(uint16_t new_id) {
+    _ip.id = new_id;
+}
+
+void Tins::IP::frag_off(uint16_t new_frag_off) {
+    _ip.frag_off = new_frag_off;
+}
+
+void Tins::IP::ttl(uint8_t new_ttl) {
+    _ip.ttl = new_ttl;
+}
+
+void Tins::IP::protocol(uint8_t new_protocol) {
+    _ip.protocol = new_protocol;
+}
+
+void Tins::IP::check(uint16_t new_check) {
+    _ip.check = new_check;
+}
+
+void Tins::IP::source_address(const string &ip) {
+    _ip.saddr = Utils::ip_to_int(ip);
+}
+
+void Tins::IP::source_address(uint32_t ip) {
+    _ip.saddr = ip;
+}
+
+void Tins::IP::dest_address(const string &ip) {
+    _ip.daddr = Utils::ip_to_int(ip);
+}
+
+void Tins::IP::dest_address(uint32_t ip) {
+    _ip.daddr = ip;
+}
+
+uint32_t Tins::IP::header_size() {
+    return sizeof(iphdr);
+}
+
+void Tins::IP::write_serialization(uint8_t *buffer, uint32_t total_sz) {
+    assert(total_sz >= sizeof(iphdr));
+    memcpy(buffer, &_ip, sizeof(iphdr));
+}

src/pdu.cpp

@@ -1,18 +1,17 @@
-#include <cassert.h>
+#include <cassert>
 #include "pdu.h"
 
-
-PDU::PDU(uint32_t pdu_flag, , PDU *next_pdu) : _pdu_flag(pdu_flag), _inner_pdu(next_pdu) {
+Tins::PDU::PDU(uint32_t flag, PDU *next_pdu) : _flag(flag), _inner_pdu(next_pdu) {
     
 }
 
-PDU::~PDU() {
+Tins::PDU::~PDU() {
     delete _inner_pdu;
 }
 
-uint32_t PDU::size() const {
+uint32_t Tins::PDU::size() const {
     uint32_t sz = header_size() + trailer_size();
-    PDU *ptr(_inner_pdu);
+    const PDU *ptr(_inner_pdu);
     while(ptr) {
         sz += ptr->header_size() + trailer_size();
         ptr = ptr->inner_pdu();
@@ -20,22 +19,28 @@ uint32_t PDU::size() const {
     return sz;
 }
 
-void PDU::inner_pdu(PDU *next_pdu) {
+void Tins::PDU::flag(uint32_t new_flag) {
+    _flag = new_flag;
+}
+
+void Tins::PDU::inner_pdu(PDU *next_pdu) {
     delete _inner_pdu;
     _inner_pdu = next_pdu;
 }
 
-uint8_t *PDU::serialize() {
+uint8_t *Tins::PDU::serialize() {
     uint32_t sz(size());
     uint8_t *buffer = new uint8_t[sz];
-    
+    serialize(buffer, sz);
+    return buffer;
 }
 
-void PDU::serialize(uint8_t *buffer, uint32_t total_sz) {
+void Tins::PDU::serialize(uint8_t *buffer, uint32_t total_sz) {
     uint32_t sz = header_size() + trailer_size();
     write_serialization(buffer, total_sz);
     /* Must not happen... */
-    std::assert(total_sz >= sz);
+    assert(total_sz >= sz);
     if(_inner_pdu)
         _inner_pdu->serialize(buffer + header_size(), total_sz - sz);
 }
+

src/utils.cpp

@@ -0,0 +1,38 @@
+#include <stdexcept>
+#include <sstream>
+#include "utils.h"
+
+using namespace std;
+
+uint32_t Tins::Utils::ip_to_int(const string &ip) {
+    uint32_t result(0), i(0), end, bytes_found(0);
+    while(i < ip.size() && bytes_found < 4) {
+        uint8_t this_byte(0);
+        end = i + 3;
+        while(i < ip.size() && i < end && ip[i] != '.') {
+            if(ip[i] < '0' || ip[i] > '9')
+                throw std::runtime_error("Non-digit character found in ip");
+            this_byte = (this_byte * 10)  + (ip[i] - '0');
+            i++;
+        }
+        result = (result << 8) | this_byte;
+        bytes_found++;
+        if(bytes_found < 4 && i < ip.size() && ip[i] == '.')
+            i++;
+    }
+    if(bytes_found < 4 || (i < ip.size() && bytes_found == 4))
+        throw std::runtime_error("Invalid ip address");
+    return result;
+}
+
+string Tins::Utils::ip_to_string(uint32_t ip) {
+    ostringstream oss;
+    int mask(24);
+    while(mask >=0) {
+        oss << ((ip >> mask) & 0xff);
+        if(mask)
+            oss << '.';
+        mask -= 8;
+    }
+    return oss.str();
+}