mirror of
https://github.com/genodelabs/genode.git
synced 2024-12-22 15:02:25 +00:00
150 lines
4.0 KiB
C++
150 lines
4.0 KiB
C++
/*
|
|
* \brief Transmission Control Protocol
|
|
* \author Martin Stein
|
|
* \date 2016-06-15
|
|
*/
|
|
|
|
/*
|
|
* Copyright (C) 2016-2017 Genode Labs GmbH
|
|
*
|
|
* This file is part of the Genode OS framework, which is distributed
|
|
* under the terms of the GNU Affero General Public License version 3.
|
|
*/
|
|
|
|
#ifndef _TCP_H_
|
|
#define _TCP_H_
|
|
|
|
/* Genode includes */
|
|
#include <base/exception.h>
|
|
#include <base/stdint.h>
|
|
#include <util/endian.h>
|
|
#include <net/ethernet.h>
|
|
#include <net/ipv4.h>
|
|
#include <util/register.h>
|
|
#include <net/port.h>
|
|
|
|
namespace Net
|
|
{
|
|
class Tcp_state;
|
|
class Tcp_packet;
|
|
}
|
|
|
|
/**
|
|
* Data layout of this class conforms to an TCP packet (RFC 768)
|
|
*/
|
|
class Net::Tcp_packet
|
|
{
|
|
private:
|
|
|
|
using uint8_t = Genode::uint8_t;
|
|
using uint16_t = Genode::uint16_t;
|
|
using uint32_t = Genode::uint32_t;
|
|
using size_t = Genode::size_t;
|
|
using Exception = Genode::Exception;
|
|
|
|
uint16_t _src_port;
|
|
uint16_t _dst_port;
|
|
uint32_t _seq_nr;
|
|
uint32_t _ack_nr;
|
|
uint8_t _data_offset;
|
|
uint8_t _flags;
|
|
uint16_t _window_size;
|
|
uint16_t _checksum;
|
|
uint16_t _urgent_ptr;
|
|
uint32_t _data[0];
|
|
|
|
struct Flags : Genode::Register<8>
|
|
{
|
|
struct Fin : Bitfield<0, 1> { };
|
|
struct Syn : Bitfield<1, 1> { };
|
|
struct Rst : Bitfield<2, 1> { };
|
|
struct Psh : Bitfield<3, 1> { };
|
|
struct Ack : Bitfield<4, 1> { };
|
|
struct Urg : Bitfield<5, 1> { };
|
|
};
|
|
|
|
public:
|
|
|
|
bool fin() const { return Flags::Fin::get(_flags); };
|
|
bool syn() const { return Flags::Syn::get(_flags); };
|
|
bool rst() const { return Flags::Rst::get(_flags); };
|
|
bool psh() const { return Flags::Psh::get(_flags); };
|
|
bool ack() const { return Flags::Ack::get(_flags); };
|
|
bool urg() const { return Flags::Urg::get(_flags); };
|
|
|
|
enum Protocol_id { IP_ID = 6 };
|
|
|
|
class No_tcp_packet : Exception {};
|
|
|
|
void src_port(Port p) { _src_port = host_to_big_endian(p.value); }
|
|
void dst_port(Port p) { _dst_port = host_to_big_endian(p.value); }
|
|
|
|
Port src_port() const { return Port(host_to_big_endian(_src_port)); }
|
|
Port dst_port() const { return Port(host_to_big_endian(_dst_port)); }
|
|
uint16_t flags() const { return host_to_big_endian(_flags); }
|
|
|
|
Tcp_packet(size_t size) {
|
|
if (size < sizeof(Tcp_packet)) { throw No_tcp_packet(); } }
|
|
|
|
/**
|
|
* TCP checksum is calculated over the tcp datagram + an IPv4
|
|
* pseudo header.
|
|
*
|
|
* IPv4 pseudo header:
|
|
*
|
|
* --------------------------------------------------------------
|
|
* | src-ipaddr | dst-ipaddr | zero-field | prot.-id | tcp-length |
|
|
* | 4 bytes | 4 bytes | 1 byte | 1 byte | 2 bytes |
|
|
* --------------------------------------------------------------
|
|
*/
|
|
void update_checksum(Ipv4_address ip_src,
|
|
Ipv4_address ip_dst,
|
|
size_t tcp_size)
|
|
{
|
|
/* have to reset the checksum field for calculation */
|
|
_checksum = 0;
|
|
|
|
/* sum up pseudo header */
|
|
uint32_t sum = 0;
|
|
for (size_t i = 0; i < Ipv4_packet::ADDR_LEN; i += sizeof(uint16_t)) {
|
|
uint16_t s = ip_src.addr[i] << 8 | ip_src.addr[i + 1];
|
|
uint16_t d = ip_dst.addr[i] << 8 | ip_dst.addr[i + 1];
|
|
sum += s + d;
|
|
}
|
|
uint8_t prot[] = { 0, IP_ID };
|
|
sum += host_to_big_endian(*(uint16_t *)&prot) + tcp_size;
|
|
|
|
/* sum up TCP packet itself */
|
|
size_t max = (tcp_size & 1) ? (tcp_size - 1) : tcp_size;
|
|
uint16_t * tcp = (uint16_t *)this;
|
|
for (size_t i = 0; i < max; i = i + sizeof(*tcp)) {
|
|
sum += host_to_big_endian(*tcp++); }
|
|
|
|
/* if TCP size is odd, append a zero byte */
|
|
if (tcp_size & 1) {
|
|
uint8_t last[] = { *((uint8_t *)this + (tcp_size - 1)), 0 };
|
|
sum += host_to_big_endian(*(uint16_t *)&last);
|
|
}
|
|
/* keep the last 16 bits of the 32 bit sum and add the carries */
|
|
while (sum >> 16) { sum = (sum & 0xffff) + (sum >> 16); }
|
|
|
|
/* one's complement of sum */
|
|
_checksum = host_to_big_endian((uint16_t)~sum);
|
|
}
|
|
|
|
/**
|
|
* Placement new
|
|
*/
|
|
void * operator new(__SIZE_TYPE__ size, void * addr) { return addr; }
|
|
|
|
|
|
/*********
|
|
** log **
|
|
*********/
|
|
|
|
void print(Genode::Output &output) const;
|
|
|
|
} __attribute__((packed));
|
|
|
|
#endif /* _TCP_H_ */
|