/*
 * Copyright 2010 Andreas Färber <andreas.faerber@web.de>
 * All rights reserved. Distributed under the terms of the MIT License.
 */
 
 
/*
 * NOTE This is a cleanroom TCP implementation with some known issues.
 * Protection Against Wrapping Sequence (PAWS) needs to be added.
 * Congestion control needs to be implemented (slow start, recv. window size).
 * The use of *Packets needs to be re-evaluated in the context of TCP;
 * probably a singly-linked list of received data chunks is more efficient.
 * Debug output should be tuned for better aspect oriented tracing.
 * While Little Endian systems have been considered, this still needs testing.
 */
 
 
#include <boot/net/TCP.h>
 
#include <stdio.h>
 
#include <KernelExport.h>
 
#include <boot/net/ChainBuffer.h>
#include <boot/net/NetStack.h>
 
#include "real_time_clock.h"
 
 
//#define TRACE_TCP
//#define TRACE_TCP_RANDOMNESS
//#define TRACE_TCP_CHECKSUM
//#define TRACE_TCP_QUEUE
 
 
#ifdef TRACE_TCP
#	define TRACE(x, ...) dprintf(x, ## __VA_ARGS__)
#else
#	define TRACE(x, ...) ;
#endif
#ifdef TRACE_TCP_RANDOMNESS
#	define TRACE_PORT(x, ...) dprintf(x, ## __VA_ARGS__)
#else
#	define TRACE_PORT(x, ...) ;
#endif
#if defined(TRACE_TCP_CHECKSUM)
#	define TRACE_CHECKSUM(x, ...) dprintf(x, ## __VA_ARGS__)
#else
#	define TRACE_CHECKSUM(x, ...) ;
#endif
#if defined(TRACE_TCP_QUEUE)
#	define TRACE_QUEUE(x, ...) dprintf(x, ## __VA_ARGS__)
#else
#	define TRACE_QUEUE(x, ...) ;
#endif
 
 
static unsigned int
_rand32(void)
{
	static unsigned int next = 0;
	if (next == 0)
		next = real_time_clock_usecs() / 1000000;
 
	next = (next >> 1) ^ (unsigned int)((0 - (next & 1U)) & 0xd0000001U);
		// characteristic polynomial: x^32 + x^31 + x^29 + x + 1
	return next;
}
 
 
static unsigned short
_rand14(void)
{
	// TODO: Find suitable generator polynomial.
	return _rand32() & 0x3fff;
}
 
 
TCPPacket::TCPPacket()
	:
	fData(NULL),
	fNext(NULL)
{
}
 
 
TCPPacket::~TCPPacket()
{
	free(fData);
}
 
 
status_t
TCPPacket::SetTo(const void* data, size_t size, ip_addr_t sourceAddress,
	uint16 sourcePort, ip_addr_t destinationAddress, uint16 destinationPort,
	uint32 sequenceNumber, uint32 acknowledgmentNumber, uint8 flags)
{
	if (data == NULL && size > 0)
		return B_BAD_VALUE;
 
	if (size > 0) {
		fData = malloc(size);
		if (fData == NULL)
			return B_NO_MEMORY;
		memcpy(fData, data, size);
	} else
		fData = NULL;
 
	fSize = size;
	fSourceAddress = sourceAddress;
	fSourcePort = sourcePort;
	fDestinationAddress = destinationAddress;
	fDestinationPort = destinationPort;
	fSequenceNumber = sequenceNumber;
	fAcknowledgmentNumber = acknowledgmentNumber;
	fFlags = flags;
 
	return B_OK;
}
 
 
ip_addr_t
TCPPacket::SourceAddress() const
{
	return fSourceAddress;
}
 
 
ip_addr_t
TCPPacket::DestinationAddress() const
{
	return fDestinationAddress;
}
 
 
uint16
TCPPacket::SourcePort() const
{
	return fSourcePort;
}
 
 
uint16
TCPPacket::DestinationPort() const
{
	return fDestinationPort;
}
 
 
uint32
TCPPacket::SequenceNumber() const
{
	return fSequenceNumber;
}
 
 
uint32
TCPPacket::AcknowledgmentNumber() const
{
	return fAcknowledgmentNumber;
}
 
 
bool
TCPPacket::ProvidesSequenceNumber(uint32 sequenceNumber) const
{
	// TODO PAWS
	return fSequenceNumber <= sequenceNumber
		&& fSequenceNumber + fSize > sequenceNumber;
}
 
 
TCPPacket*
TCPPacket::Next() const
{
	return fNext;
}
 
 
void
TCPPacket::SetNext(TCPPacket* packet)
{
	fNext = packet;
}
 
 
 
 
TCPSocket::TCPSocket()
	:
	fTCPService(NetStack::Default()->GetTCPService()),
	fAddress(INADDR_ANY),
	fPort(0),
	fSequenceNumber(0),
	fFirstPacket(NULL),
	fLastPacket(NULL),
	fFirstSentPacket(NULL),
	fLastSentPacket(NULL),
	fState(TCP_SOCKET_STATE_INITIAL),
	fRemoteState(TCP_SOCKET_STATE_INITIAL)
{
}
 
 
TCPSocket::~TCPSocket()
{
	if (fTCPService != NULL && fPort != 0)
		fTCPService->UnbindSocket(this);
}
 
 
uint16
TCPSocket::WindowSize() const
{
	// TODO A large window size leads to read timeouts
	// due to resends occuring too late.
#if 0
	size_t windowSize = 0xffff;
	for (TCPPacket* packet = fFirstPacket;
			packet != NULL && windowSize > packet->DataSize();
			packet = packet->Next())
		windowSize -= packet->DataSize();
	return windowSize;
#else
	return 4096;
#endif
}
 
 
status_t
TCPSocket::Connect(ip_addr_t address, uint16 port)
{
	fRemoteAddress = address;
	fRemotePort = port;
	fSequenceNumber = _rand32();
	fPort = 0xC000 + (_rand14() & ~0xc000);
	TRACE_PORT("TCPSocket::Connect(): connecting from port %u\n", fPort);
	fAcknowledgeNumber = 0;
	fNextSequence = 0;
 
	status_t error = fTCPService->BindSocket(this);
	if (error != B_OK)
		return error;
 
	// send SYN
	TCPPacket* packet = new(nothrow) TCPPacket();
	if (packet == NULL)
		return B_NO_MEMORY;
	error = packet->SetTo(NULL, 0, fAddress, fPort, address, port,
		fSequenceNumber, fAcknowledgeNumber, TCP_SYN);
	if (error != B_OK) {
		delete packet;
		return error;
	}
	error = _Send(packet);
	if (error != B_OK)
		return error;
	fState = TCP_SOCKET_STATE_SYN_SENT;
	fSequenceNumber++;
	TRACE("SYN sent\n");
 
	// receive SYN-ACK
	error = _WaitForState(TCP_SOCKET_STATE_OPEN, 1000000LL);
	if (error != B_OK) {
		TRACE("no SYN-ACK received\n");
		return error;
	}
	TRACE("SYN-ACK received\n");
 
	return B_OK;
}
 
 
status_t
TCPSocket::Close()
{
	// send FIN
	TCPPacket* packet = new(nothrow) TCPPacket();
	if (packet == NULL)
		return B_NO_MEMORY;
	status_t error = packet->SetTo(NULL, 0, fAddress, fPort, fRemoteAddress,
		fRemotePort, fSequenceNumber, fAcknowledgeNumber, TCP_FIN | TCP_ACK);
	if (error != B_OK) {
		delete packet;
		return error;
	}
	error = _Send(packet);
	if (error != B_OK)
		return error;
	fState = TCP_SOCKET_STATE_FIN_SENT;
	TRACE("FIN sent\n");
 
	error = _WaitForState(TCP_SOCKET_STATE_CLOSED, 1000000LL);
	if (error != B_OK)
		return error;
 
	return B_OK;
}
 
 
status_t
TCPSocket::Read(void* buffer, size_t bufferSize, size_t* bytesRead,
	bigtime_t timeout)
{
	TRACE("TCPSocket::Read(): size = %lu\n", bufferSize);
	if (bytesRead == NULL)
		return B_BAD_VALUE;
 
	*bytesRead = 0;
	TCPPacket* packet = NULL;
	
	bigtime_t startTime = system_time();
	do {
		fTCPService->ProcessIncomingPackets();
		//_ResendQueue();
		packet = _PeekPacket();
		if (packet == NULL && fRemoteState != TCP_SOCKET_STATE_OPEN)
			return B_ERROR;
		if (packet == NULL && timeout > 0LL)
			_Ack();
	} while (packet == NULL && system_time() - startTime < timeout);
	if (packet == NULL) {
#ifdef TRACE_TCP_QUEUE
		_DumpQueue();
#endif
		return (timeout == 0) ? B_WOULD_BLOCK : B_TIMED_OUT;
	}
	uint32 packetOffset = fNextSequence - packet->SequenceNumber();
	size_t readBytes = packet->DataSize() - packetOffset;
	if (readBytes > bufferSize)
		readBytes = bufferSize;
	if (buffer != NULL)
		memcpy(buffer, (uint8*)packet->Data() + packetOffset, readBytes);
	*bytesRead = readBytes;
	if (!packet->ProvidesSequenceNumber(fNextSequence + readBytes)) {
		_DequeuePacket();
		delete packet;
		packet = NULL;
	}
	fNextSequence += readBytes;
 
	if (packet == NULL && *bytesRead < bufferSize) {
		do {
			if (buffer != NULL)
				buffer = (uint8*)buffer + readBytes;
			bufferSize -= readBytes;
			fTCPService->ProcessIncomingPackets();
			packet = _PeekPacket();
			if (packet == NULL && fRemoteState != TCP_SOCKET_STATE_OPEN)
				break;
			readBytes = 0;
			if (packet == NULL) {
				_Ack();
				continue;
			}
			readBytes = packet->DataSize();
			if (readBytes > bufferSize)
				readBytes = bufferSize;
			if (buffer != NULL)
				memcpy(buffer, packet->Data(), readBytes);
			*bytesRead += readBytes;
			if (readBytes == packet->DataSize()) {
				_DequeuePacket();
				delete packet;
			}
			fNextSequence += readBytes;
		} while (readBytes < bufferSize &&
			system_time() - startTime < timeout);
#ifdef TRACE_TCP_QUEUE
		if (readBytes < bufferSize) {
			TRACE_QUEUE("TCP: Unable to deliver more data!\n");
			_DumpQueue();
		}
#endif
	}
 
	return B_OK;
}
 
 
status_t
TCPSocket::Write(const void* buffer, size_t bufferSize)
{
	if (buffer == NULL || bufferSize == 0)
		return B_BAD_VALUE;
 
	// TODO: Check for MTU and create multiple packets if necessary.
 
	TCPPacket* packet = new(nothrow) TCPPacket();
	if (packet == NULL)
		return B_NO_MEMORY;
	status_t error = packet->SetTo(buffer, bufferSize, fAddress, fPort,
		fRemoteAddress, fRemotePort, fSequenceNumber, fAcknowledgeNumber,
		TCP_ACK);
	if (error != B_OK) {
		delete packet;
		return error;
	}
	return _Send(packet);
}
 
 
void
TCPSocket::Acknowledge(uint32 number)
{
	TRACE("TCPSocket::Acknowledge(): %lu\n", number);
	// dequeue packets
	for (TCPPacket* packet = fFirstSentPacket; packet != NULL;
			packet = fFirstSentPacket) {
		if (packet->SequenceNumber() >= number)
			return;
		fFirstSentPacket = packet->Next();
		delete packet;
	}
	fLastSentPacket = NULL;
}
 
 
void
TCPSocket::ProcessPacket(TCPPacket* packet)
{
	TRACE("TCPSocket::ProcessPacket()\n");
 
	if ((packet->Flags() & TCP_FIN) != 0) {
		fRemoteState = TCP_SOCKET_STATE_FIN_SENT;
		TRACE("FIN received\n");
		_Ack();
	}
 
	if (fState == TCP_SOCKET_STATE_SYN_SENT) {
		if ((packet->Flags() & TCP_SYN) != 0
				&& (packet->Flags() & TCP_ACK) != 0) {
			fNextSequence = fAcknowledgeNumber = packet->SequenceNumber() + 1;
			fRemoteState = TCP_SOCKET_STATE_SYN_SENT;
			delete packet;
			_Ack();
			fState = fRemoteState = TCP_SOCKET_STATE_OPEN;
			return;
		}
	} else if (fState == TCP_SOCKET_STATE_OPEN) {
	} else if (fState == TCP_SOCKET_STATE_FIN_SENT) {
		if ((packet->Flags() & TCP_ACK) != 0) {
			TRACE("FIN-ACK received\n");
			if (fRemoteState == TCP_SOCKET_STATE_FIN_SENT)
				fState = TCP_SOCKET_STATE_CLOSED;
		}
	}
 
	if (packet->DataSize() == 0) {
		TRACE("TCPSocket::ProcessPacket(): not queuing due to lack of data\n");
		delete packet;
		return;
	}
 
	// For now rather protect us against being flooded with packets already
	// acknowledged. "If it's important, they'll send it again."
	// TODO PAWS
	if (packet->SequenceNumber() < fAcknowledgeNumber) {
		TRACE_QUEUE("TCPSocket::ProcessPacket(): not queuing due to wraparound\n");
		delete packet;
		return;
	}
 
	if (fLastPacket == NULL) {
		// no packets enqueued
		TRACE("TCPSocket::ProcessPacket(): first in queue\n");
		packet->SetNext(NULL);
		fFirstPacket = fLastPacket = packet;
	} else if (fLastPacket->SequenceNumber() < packet->SequenceNumber()) {
		// enqueue in back
		TRACE("TCPSocket::ProcessPacket(): enqueue in back\n");
		packet->SetNext(NULL);
		fLastPacket->SetNext(packet);
		fLastPacket = packet;
	} else if (fFirstPacket->SequenceNumber() > packet->SequenceNumber()) {
		// enqueue in front
		TRACE("TCPSocket::ProcessPacket(): enqueue in front\n");
		TRACE_QUEUE("TCP: Enqueuing %lx - %lx in front! (next is %lx)\n",
			packet->SequenceNumber(),
			packet->SequenceNumber() + packet->DataSize() - 1,
			fNextSequence);
		packet->SetNext(fFirstPacket);
		fFirstPacket = packet;
	} else if (fFirstPacket->SequenceNumber() == packet->SequenceNumber()) {
		TRACE_QUEUE("%s(): dropping due to identical first packet\n", __func__);
		delete packet;
		return;
	} else {
		// enqueue in middle
		TRACE("TCPSocket::ProcessPacket(): enqueue in middle\n");
		for (TCPPacket* queuedPacket = fFirstPacket; queuedPacket != NULL;
				queuedPacket = queuedPacket->Next()) {
			if (queuedPacket->SequenceNumber() == packet->SequenceNumber()) {
				TRACE_QUEUE("TCPSocket::EnqueuePacket(): TCP packet dropped\n");
				// we may be waiting for a previous packet
				delete packet;
				return;
			}
			if (queuedPacket->Next()->SequenceNumber()
					> packet->SequenceNumber()) {
				packet->SetNext(queuedPacket->Next());
				queuedPacket->SetNext(packet);
				break;
			}
		}
	}
	while (packet != NULL && packet->SequenceNumber() == fAcknowledgeNumber) {
		fAcknowledgeNumber = packet->SequenceNumber() + packet->DataSize();
		packet = packet->Next();
	}
}
 
 
TCPPacket*
TCPSocket::_PeekPacket()
{
	TRACE("TCPSocket::_PeekPacket(): fNextSequence = %lu\n", fNextSequence);
	for (TCPPacket* packet = fFirstPacket; packet != NULL;
			packet = packet->Next()) {
		if (packet->ProvidesSequenceNumber(fNextSequence))
			return packet;
	}
	return NULL;
}
 
 
TCPPacket*
TCPSocket::_DequeuePacket()
{
	//TRACE("TCPSocket::DequeuePacket()\n");
	if (fFirstPacket == NULL)
		return NULL;
 
	if (fFirstPacket->ProvidesSequenceNumber(fNextSequence)) {
		TCPPacket* packet = fFirstPacket;
		fFirstPacket = packet->Next();
		if (fFirstPacket == NULL)
			fLastPacket = NULL;
		packet->SetNext(NULL);
		TRACE("TCP: Dequeuing %lx - %lx from front.\n",
			packet->SequenceNumber(),
			packet->SequenceNumber() + packet->DataSize() - 1);
		return packet;
	}
 
	for (TCPPacket* packet = fFirstPacket;
			packet != NULL && packet->Next() != NULL;
			packet = packet->Next()) {
		if (packet->Next()->ProvidesSequenceNumber(fNextSequence)) {
			TCPPacket* nextPacket = packet->Next();
			packet->SetNext(nextPacket->Next());
			if (fLastPacket == nextPacket)
				fLastPacket = packet;
			TRACE("TCP: Dequeuing %lx - %lx.\n",
				nextPacket->SequenceNumber(),
				nextPacket->SequenceNumber() + nextPacket->DataSize() - 1);
			return nextPacket;
		}
	}
	TRACE_QUEUE("dequeue failed!\n");
	return NULL;
}
 
 
status_t
TCPSocket::_Send(TCPPacket* packet, bool enqueue)
{
	ChainBuffer buffer((void*)packet->Data(), packet->DataSize());
	status_t error = fTCPService->Send(fPort, fRemoteAddress, fRemotePort,
		packet->SequenceNumber(), fAcknowledgeNumber, packet->Flags(),
		WindowSize(), &buffer);
	if (error != B_OK)
		return error;
	if (packet->SequenceNumber() == fSequenceNumber)
		fSequenceNumber += packet->DataSize();
 
	if (enqueue)
		_EnqueueOutgoingPacket(packet);
 
	return B_OK;
}
 
 
status_t
TCPSocket::_ResendQueue()
{
	TRACE("resending queue\n");
	for (TCPPacket* packet = fFirstSentPacket; packet != NULL;
			packet = packet->Next()) {
		ChainBuffer buffer((void*)packet->Data(), packet->DataSize());
		status_t error = fTCPService->Send(fPort, fRemoteAddress, fRemotePort,
			packet->SequenceNumber(), fAcknowledgeNumber, packet->Flags(),
			WindowSize(), &buffer);
		if (error != B_OK)
			return error;
	}
	return B_OK;
}
 
 
void
TCPSocket::_EnqueueOutgoingPacket(TCPPacket* packet)
{
	if (fLastSentPacket != NULL) {
		fLastSentPacket->SetNext(packet);
		fLastSentPacket = packet;
	} else {
		fFirstSentPacket = fLastSentPacket = packet;
	}
}
 
 
#ifdef TRACE_TCP_QUEUE
 
inline void
TCPSocket::_DumpQueue()
{
	TRACE_QUEUE("TCP: waiting for %lx (ack'ed %lx)\n", fNextSequence, fAcknowledgeNumber);
	if (fFirstPacket == NULL)
		TRACE_QUEUE("TCP: Queue is empty.\n");
	else {
		for (TCPPacket* packet = fFirstPacket; packet != NULL;
				packet = packet->Next()) {
			TRACE_QUEUE("TCP: Queue: %lx\n", packet->SequenceNumber());
		}
	}
	if (fFirstSentPacket != NULL)
		TRACE_QUEUE("TCP: Send queue is non-empty.\n");
	else
		TRACE_QUEUE("TCP: Send queue is empty.\n");
}
 
#endif
 
 
status_t
TCPSocket::_Ack()
{
	TCPPacket* packet = new(nothrow) TCPPacket();
	if (packet == NULL)
		return B_NO_MEMORY;
	status_t error = packet->SetTo(NULL, 0, fAddress, fPort, fRemoteAddress,
		fRemotePort, fSequenceNumber, fAcknowledgeNumber, TCP_ACK);
	if (error != B_OK) {
		delete packet;
		return error;
	}
	error = _Send(packet, false);
	delete packet;
	if (error != B_OK)
		return error;
	return B_OK;
}
 
 
status_t
TCPSocket::_WaitForState(TCPSocketState state, bigtime_t timeout)
{
	if (fTCPService == NULL)
		return B_NO_INIT;
 
	bigtime_t startTime = system_time();
	do {
		fTCPService->ProcessIncomingPackets();
		if (fState == state)
			return B_OK;
	} while (system_time() - startTime < timeout);
	return timeout == 0 ? B_WOULD_BLOCK : B_TIMED_OUT;
}
 
 
 
 
TCPService::TCPService(IPService* ipService)
	:
	IPSubService(kTCPServiceName),
	fIPService(ipService)
{
}
 
 
TCPService::~TCPService()
{
	if (fIPService != NULL)
		fIPService->UnregisterIPSubService(this);
}
 
 
status_t
TCPService::Init()
{
	if (fIPService == NULL)
		return B_BAD_VALUE;
 
	if (!fIPService->RegisterIPSubService(this))
		return B_NO_MEMORY;
 
	return B_OK;
}
 
 
uint8
TCPService::IPProtocol() const
{
	return IPPROTO_TCP;
}
 
 
void
TCPService::HandleIPPacket(IPService* ipService, ip_addr_t sourceIP,
	ip_addr_t destinationIP, const void* data, size_t size)
{
	TRACE("TCPService::HandleIPPacket(): source = %08lx, "
		"destination = %08lx, %lu - %lu bytes\n", sourceIP, destinationIP,
		size, sizeof(tcp_header));
 
	if (data == NULL || size < sizeof(tcp_header))
		return;
 
	const tcp_header* header = (const tcp_header*)data;
 
	uint16 chksum = _ChecksumData(data, size, sourceIP, destinationIP);
	if (chksum != 0) {
		TRACE_CHECKSUM("TCPService::HandleIPPacket(): invalid checksum "
			"(%04x vs. %04x), padding %lu\n",
			header->checksum, chksum, size % 2);
		return;
	}
 
	uint16 source = ntohs(header->source);
	uint16 destination = ntohs(header->destination);
	uint32 sequenceNumber = ntohl(header->seqNumber);
	uint32 ackedNumber = ntohl(header->ackNumber);
	TRACE("\tsource = %u, dest = %u, seq = %lu, ack = %lu, dataOffset = %u, "
		"flags %s %s %s %s\n", source, destination, sequenceNumber,
		ackedNumber, header->dataOffset,
		(header->flags & TCP_ACK) != 0 ? "ACK" : "",
		(header->flags & TCP_SYN) != 0 ? "SYN" : "",
		(header->flags & TCP_FIN) != 0 ? "FIN" : "",
		(header->flags & TCP_RST) != 0 ? "RST" : "");
	if (header->dataOffset > 5) {
		uint8* option = (uint8*)data + sizeof(tcp_header);
		while ((uint32*)option < (uint32*)data + header->dataOffset) {
			uint8 optionKind = option[0];
			if (optionKind == 0)
				break;
			uint8 optionLength = 1;
			if (optionKind > 1) {
				optionLength = option[1];
				TRACE("\tTCP option kind %u, length %u\n",
					optionKind, optionLength);
				if (optionKind == 2)
					TRACE("\tTCP MSS = %04hu\n", *(uint16_t*)&option[2]);
			}
			option += optionLength;
		}
	}
 
	TCPSocket* socket = _FindSocket(destinationIP, destination);
	if (socket == NULL) {
		// TODO If SYN, answer with RST?
		TRACE("TCPService::HandleIPPacket(): no socket\n");
		return;
	}
 
	if ((header->flags & TCP_ACK) != 0) {
		socket->Acknowledge(ackedNumber);
	}
 
	TCPPacket* packet = new(nothrow) TCPPacket();
	if (packet == NULL)
		return;
	status_t error = packet->SetTo((uint32*)data + header->dataOffset,
		size - header->dataOffset * 4, sourceIP, source, destinationIP,
		destination, sequenceNumber, ackedNumber, header->flags);
	if (error == B_OK)
		socket->ProcessPacket(packet);
	else
		delete packet;
}
 
 
status_t
TCPService::Send(uint16 sourcePort, ip_addr_t destinationAddress,
	uint16 destinationPort, uint32 sequenceNumber,
	uint32 acknowledgmentNumber, uint8 flags, uint16 windowSize,
	ChainBuffer* buffer)
{
	TRACE("TCPService::Send(): seq = %lu, ack = %lu\n",
		sequenceNumber, acknowledgmentNumber);
	if (fIPService == NULL)
		return B_NO_INIT;
	if (buffer == NULL)
		return B_BAD_VALUE;
 
	tcp_header header;
	ChainBuffer headerBuffer(&header, sizeof(header), buffer);
	memset(&header, 0, sizeof(header));
	header.source = htons(sourcePort);
	header.destination = htons(destinationPort);
	header.seqNumber = htonl(sequenceNumber);
	header.ackNumber = htonl(acknowledgmentNumber);
	header.dataOffset = 5;
	header.flags = flags;
	header.window = htons(windowSize);
 
	header.checksum = 0;
	header.checksum = htons(_ChecksumBuffer(&headerBuffer,
		fIPService->IPAddress(), destinationAddress,
		headerBuffer.TotalSize()));
 
	return fIPService->Send(destinationAddress, IPPROTO_TCP, &headerBuffer);
}
 
 
void
TCPService::ProcessIncomingPackets()
{
	if (fIPService != NULL)
		fIPService->ProcessIncomingPackets();
}
 
 
status_t
TCPService::BindSocket(TCPSocket* socket)
{
	if (socket == NULL)
		return B_BAD_VALUE;
 
	if (_FindSocket(socket->Address(), socket->Port()) != NULL)
		return EADDRINUSE;
 
	return fSockets.Add(socket);
}
 
 
void
TCPService::UnbindSocket(TCPSocket* socket)
{
	fSockets.Remove(socket);
}
 
 
uint16
TCPService::_ChecksumBuffer(ChainBuffer* buffer, ip_addr_t source,
	ip_addr_t destination, uint16 length)
{
	struct pseudo_header {
		ip_addr_t	source;
		ip_addr_t	destination;
		uint8		pad;
		uint8		protocol;
		uint16		length;
	} __attribute__ ((__packed__));
	pseudo_header header = {
		htonl(source),
		htonl(destination),
		0,
		IPPROTO_TCP,
		htons(length)
	};
 
	ChainBuffer headerBuffer(&header, sizeof(header), buffer);
	uint16 checksum = ip_checksum(&headerBuffer);
	headerBuffer.DetachNext();
	return checksum;
}
 
 
uint16
TCPService::_ChecksumData(const void* data, uint16 length, ip_addr_t source,
	ip_addr_t destination)
{
	ChainBuffer buffer((void*)data, length);
	return _ChecksumBuffer(&buffer, source, destination, length);
}
 
 
TCPSocket*
TCPService::_FindSocket(ip_addr_t address, uint16 port)
{
	for (int i = 0; i < fSockets.Count(); i++) {
		TCPSocket* socket = fSockets.ElementAt(i);
		// TODO Remove socket->Address() INADDR_ANY check once the socket is
		// aware of both its IP addresses (local one is INADDR_ANY for now).
		if ((address == INADDR_ANY || socket->Address() == INADDR_ANY
					|| socket->Address() == address)
				&& socket->Port() == port) {
			return socket;
		}
	}
	return NULL;
}