/*
 * Copyright 2005, Ingo Weinhold <bonefish@cs.tu-berlin.de>.
 * All rights reserved. Distributed under the terms of the MIT License.
 */

#include <boot/net/Ethernet.h>

#include <stdio.h>
#include <KernelExport.h>

#include <boot/net/ChainBuffer.h>


//#define TRACE_ETHERNET
#ifdef TRACE_ETHERNET
#       define TRACE(x) dprintf x
#else
#       define TRACE(x) ;
#endif


// #pragma mark - EthernetInterface

// constructor  
EthernetInterface::EthernetInterface()
        : fIPAddress(INADDR_ANY)
{
}

// destructor   
EthernetInterface::~EthernetInterface()
{
}

// IPAddress
ip_addr_t
EthernetInterface::IPAddress() const
{
        return fIPAddress;
}

// SetIPAddress
void
EthernetInterface::SetIPAddress(ip_addr_t ipAddress)
{
        fIPAddress = ipAddress;
}


// #pragma mark - EthernetSubService

// constructor
EthernetSubService::EthernetSubService(const char *serviceName)
        : NetService(serviceName)
{
}

// destructor
EthernetSubService::~EthernetSubService()
{
}


// #pragma mark - EthernetService

// constructor
EthernetService::EthernetService()
        : NetService(kEthernetServiceName),
          fInterface(NULL),
          fSendBuffer(NULL),
          fReceiveBuffer(NULL)
{
}

// destructor
EthernetService::~EthernetService()
{
        if (fSendBuffer)
                fInterface->FreeSendReceiveBuffer(fSendBuffer);
}

// Init
status_t
EthernetService::Init(EthernetInterface *interface)
{
        if (!interface)
                return B_BAD_VALUE;

        fInterface = interface;

        fSendBuffer = fInterface->AllocateSendReceiveBuffer(
                SEND_BUFFER_SIZE + RECEIVE_BUFFER_SIZE);
        if (!fSendBuffer)
                return B_NO_MEMORY;
        fReceiveBuffer = (uint8*)fSendBuffer + SEND_BUFFER_SIZE;

        return B_OK;
}

// MACAddress
mac_addr_t
EthernetService::MACAddress() const
{
        return fInterface->MACAddress();
}

// IPAddress
ip_addr_t
EthernetService::IPAddress() const
{
        return fInterface->IPAddress();
}

// SetIPAddress
void
EthernetService::SetIPAddress(ip_addr_t ipAddress)
{
        fInterface->SetIPAddress(ipAddress);
}

// Send
status_t
EthernetService::Send(const mac_addr_t &destination, uint16 protocol,
        ChainBuffer *buffer)
{
        TRACE(("EthernetService::Send(to: %012" B_PRIx64 ", proto: 0x%hx, %"
                PRIu32 " bytes)\n",
                destination.ToUInt64(), protocol, (buffer ? buffer->TotalSize() : 0)));

        if (!fInterface || !fSendBuffer)
                return B_NO_INIT;

        // sending has time, but we need to handle incoming packets as soon as
        // possible
        ProcessIncomingPackets();

        if (!buffer)
                return B_BAD_VALUE;

        // data too long?
        size_t dataSize = buffer->TotalSize();
        if (dataSize > ETHER_MAX_TRANSFER_UNIT)
                return B_BAD_VALUE;

        // prepend ethernet header
        ether_header header;
        ChainBuffer headerBuffer(&header, sizeof(header), buffer);
        header.source = fInterface->MACAddress();
        header.destination = destination;
        header.type = htons(protocol);

        // flatten
        size_t totalSize = headerBuffer.TotalSize();
        headerBuffer.Flatten(fSendBuffer);

        // pad data, if necessary
        if (dataSize < ETHER_MIN_TRANSFER_UNIT) {
                size_t paddingSize = ETHER_MIN_TRANSFER_UNIT - dataSize;
                memset((uint8*)fSendBuffer + totalSize, 0, paddingSize);
                totalSize += paddingSize;
        }

        // send
        ssize_t bytesSent = fInterface->Send(fSendBuffer, totalSize);
        if (bytesSent < 0)
                return bytesSent;
        if (bytesSent != (ssize_t)totalSize)
                return B_ERROR;

        return B_OK;
}

// ProcessIncomingPackets
void
EthernetService::ProcessIncomingPackets()
{
        if (!fInterface || !fReceiveBuffer)
                return;

        for (;;) {
                // read from the interface
                ssize_t bytesReceived = fInterface->Receive(fReceiveBuffer,
                        RECEIVE_BUFFER_SIZE);
                if (bytesReceived < 0)
                        return;

                // basic sanity checks (packet too small/too big)
                if (bytesReceived
                                < (ssize_t)sizeof(ether_header) + ETHER_MIN_TRANSFER_UNIT
                        || bytesReceived
                                > (ssize_t)sizeof(ether_header) + ETHER_MAX_TRANSFER_UNIT) {
                        continue;
                }

                // is the packet intended for us?
                ether_header *header = (ether_header*)fReceiveBuffer;
                if (header->destination != kBroadcastMACAddress
                        && header->destination != fInterface->MACAddress()) {
                        continue;
                }

                TRACE(("EthernetService::ProcessIncomingPackets(): received ethernet "
                        "frame: to: %012" B_PRIx64 ", proto: 0x%hx, %" B_PRIuSIZE " bytes\n",
                        header->destination.ToUInt64(), ntohs(header->type),
                        bytesReceived - (ssize_t)sizeof(ether_header)));

                // find a service handling this kind of packet
                int serviceCount = fServices.Count();
                for (int i = 0; i < serviceCount; i++) {
                        EthernetSubService *service = fServices.ElementAt(i);
                        if (service->EthernetProtocol() == ntohs(header->type)) {
                                service->HandleEthernetPacket(this, header->destination,
                                        (uint8*)fReceiveBuffer + sizeof(ether_header),
                                        bytesReceived - sizeof(ether_header));
                                break;
                        }
                }
        }
}

// RegisterEthernetSubService
bool
EthernetService::RegisterEthernetSubService(EthernetSubService *service)
{
        return (service && fServices.Add(service) == B_OK);
}

// UnregisterEthernetSubService
bool
EthernetService::UnregisterEthernetSubService(EthernetSubService *service)
{
        return (service && fServices.Remove(service) >= 0);
}

// CountSubNetServices
int
EthernetService::CountSubNetServices() const
{
        return fServices.Count();
}

// SubNetServiceAt
NetService *
EthernetService::SubNetServiceAt(int index) const
{
        return fServices.ElementAt(index);
}