Solved conflicts.

src/ip.cpp

@@ -54,6 +54,7 @@ void Tins::IP::init_ip_fields() {
     _ip.ihl = sizeof(iphdr) / sizeof(uint32_t);
     _ip.ttl = DEFAULT_TTL;
     _options_size = 0;
+    _padded_options_size = 0;
 }
 
 /* Setters */
@@ -164,7 +165,7 @@ bool Tins::IP::send(PacketSender* sender) {
     return sender->send_l3(this, (const struct sockaddr*)&link_addr, sizeof(link_addr));
 }
 
-void Tins::IP::write_serialization(uint8_t *buffer, uint32_t total_sz) {
+void Tins::IP::write_serialization(uint8_t *buffer, uint32_t total_sz, PDU *) {
     uint32_t my_sz = header_size();
     uint32_t new_flag;
     assert(total_sz >= my_sz);

src/packetsender.cpp

@@ -77,6 +77,7 @@ bool Tins::PacketSender::send_l3(PDU *pdu, const struct sockaddr* link_addr, uin
         int sock = _sockets[IP_SOCKET];
         uint8_t *buffer = pdu->serialize(sz);
         ret_val = (sendto(sock, buffer, sz, 0, link_addr, len_link_addr) != -1);
+        std::cout << "Ret_val: " << ret_val << "\n";
         delete[] buffer;
     }
 

src/pdu.cpp

@@ -52,16 +52,16 @@ void Tins::PDU::inner_pdu(PDU *next_pdu) {
 uint8_t *Tins::PDU::serialize(uint32_t &sz) {
     sz = size();
     uint8_t *buffer = new uint8_t[sz];
-    serialize(buffer, sz);
+    serialize(buffer, sz, 0);
     return buffer;
 }
 
-void Tins::PDU::serialize(uint8_t *buffer, uint32_t total_sz) {
+void Tins::PDU::serialize(uint8_t *buffer, uint32_t total_sz, PDU *parent) {
     uint32_t sz = header_size() + trailer_size();
     /* Must not happen... */
     assert(total_sz >= sz);
     if(_inner_pdu)
-        _inner_pdu->serialize(buffer + header_size(), total_sz - sz);
-    write_serialization(buffer, total_sz);
+        _inner_pdu->serialize(buffer + header_size(), total_sz - sz, this);
+    write_serialization(buffer, total_sz, parent);
 }
 

src/tcp.cpp

@@ -21,10 +21,12 @@
 
 #include <cstring>
 #include <cassert>
+#include <iostream> //borrame
 #ifndef WIN32
     #include <netinet/in.h>
 #endif
 #include "tcp.h"
+#include "ip.h"
 #include "utils.h"
 
 
@@ -126,10 +128,28 @@ void Tins::TCP::add_option(Options tcp_option, uint8_t length, uint8_t *data) {
     _total_options_size = (padding) ? _options_size - padding + 4 : _options_size;
 }
 
-uint16_t Tins::TCP::do_checksum(uint8_t *start, uint8_t *end) const {
-    unsigned checksum(0);
-    while(start < end)
-        checksum += *(start++);
+uint32_t Tins::TCP::do_checksum(uint8_t *start, uint8_t *end) const {
+    uint32_t checksum(0);
+    uint16_t *ptr = (uint16_t*)start, *last = (uint16_t*)end, padding(0);
+    if(((end - start) & 1) == 1) {
+        last = (uint16_t*)end - 1;
+        padding = *(end - 1) << 8;
+    }
+    while(ptr < last)
+        checksum += Utils::net_to_host_s(*(ptr++));
+    return checksum + padding;
+}
+
+uint32_t Tins::TCP::pseudoheader_checksum(uint32_t source_ip, uint32_t dest_ip) const {
+    uint32_t checksum(0), len(header_size());
+    source_ip = Utils::net_to_host_l(source_ip);
+    dest_ip = Utils::net_to_host_l(dest_ip);
+    uint16_t *ptr = (uint16_t*)&source_ip;
+    
+    checksum += *ptr + ptr[1];
+    ptr = (uint16_t*)&dest_ip;
+    checksum += *ptr + ptr[1];
+    checksum += IPPROTO_TCP + len;
     return checksum;
 }
 
@@ -137,7 +157,7 @@ uint32_t Tins::TCP::header_size() const {
     return sizeof(tcphdr) + _payload_size + _total_options_size;
 }
 
-void Tins::TCP::write_serialization(uint8_t *buffer, uint32_t total_sz) {
+void Tins::TCP::write_serialization(uint8_t *buffer, uint32_t total_sz, PDU *parent) {
     assert(total_sz >= header_size());
     uint8_t *tcp_start = buffer;
     buffer += sizeof(tcphdr);
@@ -154,8 +174,16 @@ void Tins::TCP::write_serialization(uint8_t *buffer, uint32_t total_sz) {
     }
         
     memcpy(buffer, _payload, _payload_size);
-    if(!_tcp.check)
-        _tcp.check = Utils::net_to_host_s(do_checksum(tcp_start + sizeof(tcphdr), buffer));
+    buffer += _payload_size;
+    IP *ip_packet = dynamic_cast<IP*>(parent);
+    if(ip_packet) {
+        _tcp.check = 0;
+        uint32_t checksum = pseudoheader_checksum(ip_packet->source_address(), ip_packet->dest_address()) + 
+                            do_checksum(tcp_start + sizeof(tcphdr), buffer) + do_checksum((uint8_t*)&_tcp, ((uint8_t*)&_tcp) + sizeof(tcphdr));
+        while (checksum >> 16)
+            checksum = (checksum & 0xffff)+(checksum >> 16);
+        _tcp.check = Utils::net_to_host_s(~checksum);
+    }
     memcpy(tcp_start, &_tcp, sizeof(tcphdr));
 }