haiku.git

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

#include <new>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <KernelExport.h>

#include <boot/platform.h>

#include "network.h"
#include "pxe_undi.h"

//#define TRACE_NETWORK

#ifdef TRACE_NETWORK
#	define TRACE(x...) dprintf(x)
#else
#	define TRACE(x...)
#endif

#ifdef TRACE_NETWORK

static void
hex_dump(const void *_data, int length)
{
	uint8 *data = (uint8*)_data;
	for (int i = 0; i < length; i++) {
		if (i % 4 == 0) {
			if (i % 32 == 0) {
				if (i != 0)
					TRACE("\n");
				TRACE("%03x: ", i);
			} else
				TRACE(" ");
		}

		TRACE("%02x", data[i]);
	}
	TRACE("\n");
}

#else	// !TRACE_NETWORK


#define hex_dump(data, length)

#endif	// !TRACE_NETWORK



// #pragma mark - PXEService



PXEService::PXEService()
	: fPxeData(NULL),
	  fClientIP(0),
	  fServerIP(0),
	  fRootPath(NULL)
{
}


PXEService::~PXEService()
{
	free(fRootPath);
}


status_t
PXEService::Init()
{
	// get !PXE struct

	fPxeData = pxe_undi_find_data();
	if (!fPxeData) {
		panic("can't find !PXE structure");
		return B_ERROR;
	}

	dprintf("PXE API entrypoint at %04x:%04x\n", fPxeData->EntryPointSP.seg, fPxeData->EntryPointSP.ofs);

	// get cached info

	PXENV_GET_CACHED_INFO cached_info;
	cached_info.PacketType = PXENV_PACKET_TYPE_CACHED_REPLY;
	cached_info.BufferSize = 0;
	cached_info.BufferLimit = 0;
	cached_info.Buffer.seg = 0;
	cached_info.Buffer.ofs = 0;
	uint16 res = call_pxe_bios(fPxeData, GET_CACHED_INFO, &cached_info);
	if (res != 0 || cached_info.Status != 0) {
		char s[100];
		snprintf(s, sizeof(s), "Can't determine IP address! PXENV_GET_CACHED_INFO res %x, status %x\n", res, cached_info.Status);
		panic("%s", s);
		return B_ERROR;
	}

	char *buf = (char *)(cached_info.Buffer.seg * 16 + cached_info.Buffer.ofs);
	fClientIP = ntohl(*(ip_addr_t *)(buf + 16));
	fServerIP = ntohl(*(ip_addr_t *)(buf + 20));
	fMACAddress = mac_addr_t((uint8*)(buf + 28));

	uint8* options = (uint8*)buf + 236;
	int optionsLen = int(cached_info.BufferSize) - 236;

	// check magic

	if (optionsLen < 4 || options[0] != 0x63 || options[1] != 0x82
		|| options[2] != 0x53 || options[3] != 0x63) {
		return B_OK;
	}
	options += 4;
	optionsLen -= 4;

	// parse DHCP options

	while (optionsLen > 0) {
		int option = *(options++);
		optionsLen--;

		// check end or pad option

		if (option == 0xff || optionsLen < 0)
			break;
		if (option == 0x00)
			continue;

		// other options have a len field

		int len = *(options++);
		optionsLen--;
		if (len > optionsLen)
			break;

		// root path option

		if (option == 17) {
			dprintf("root path option: \"%.*s\"\n", len, (char*)options);
			free(fRootPath);
			fRootPath = (char*)malloc(len + 1);
			if (!fRootPath)
				return B_NO_MEMORY;
			memcpy(fRootPath, options, len);
			fRootPath[len] = '\0';
		}

		options += len;
		optionsLen -= len;
	}

	return B_OK;
}


// #pragma mark - UNDI



UNDI::UNDI()
 :	fRxFinished(true)
{
	TRACE("UNDI::UNDI\n");
}


UNDI::~UNDI()
{
	TRACE("UNDI::~UNDI\n");
}


status_t
UNDI::Init()
{
	TRACE("UNDI::Init\n");

	PXENV_UNDI_GET_INFORMATION get_info;
	PXENV_UNDI_GET_STATE get_state;
	PXENV_UNDI_OPEN undi_open;
	uint16 res;

	status_t error = PXEService::Init();
	if (error != B_OK)
		return error;

	dprintf("client-ip: %u.%u.%u.%u, server-ip: %u.%u.%u.%u\n",
		(fClientIP >> 24) & 0xff, (fClientIP >> 16) & 0xff, (fClientIP >> 8) & 0xff, fClientIP & 0xff,
		(fServerIP >> 24) & 0xff, (fServerIP >> 16) & 0xff, (fServerIP >> 8) & 0xff, fServerIP & 0xff);

	SetIPAddress(fClientIP);

	undi_open.OpenFlag = 0;
	undi_open.PktFilter = FLTR_DIRECTED | FLTR_BRDCST | FLTR_PRMSCS;
	undi_open.R_Mcast_Buf.MCastAddrCount = 0;

	res = call_pxe_bios(fPxeData, UNDI_OPEN, &undi_open);
	if (res != 0 || undi_open.Status != 0) {
		dprintf("PXENV_UNDI_OPEN failed, res %x, status %x, ignoring\n", res, undi_open.Status);
	}

	res = call_pxe_bios(fPxeData, UNDI_GET_STATE, &get_state);
	if (res != 0 || get_state.Status != 0) {
		dprintf("PXENV_UNDI_GET_STATE failed, res %x, status %x, ignoring\n", res, get_state.Status);
	} else {
		switch (get_state.UNDIstate) {
			case PXE_UNDI_GET_STATE_STARTED:
				TRACE("PXE_UNDI_GET_STATE_STARTED\n");
				break;
			case PXE_UNDI_GET_STATE_INITIALIZED:
				TRACE("PXE_UNDI_GET_STATE_INITIALIZED\n");
				break;
			case PXE_UNDI_GET_STATE_OPENED:
				TRACE("PXE_UNDI_GET_STATE_OPENED\n");
				break;
			default:
				TRACE("unknown undi state 0x%02x\n", get_state.UNDIstate);
				break;
		}
	}

	res = call_pxe_bios(fPxeData, UNDI_GET_INFORMATION, &get_info);
	if (res != 0 || get_info.Status != 0) {
		dprintf("PXENV_UNDI_GET_INFORMATION failed, res %x, status %x\n", res, get_info.Status);
		return B_ERROR;
	}

	TRACE("Status = %x\n", get_info.Status);
	TRACE("BaseIo = %x\n", get_info.BaseIo);
	TRACE("IntNumber = %x\n", get_info.IntNumber);
	TRACE("MaxTranUnit = %x\n", get_info.MaxTranUnit);
	TRACE("HwType = %x\n", get_info.HwType);
	TRACE("HwAddrLen = %x\n", get_info.HwAddrLen);
	TRACE("RxBufCt = %x\n", get_info.RxBufCt);
	TRACE("TxBufCt = %x\n", get_info.TxBufCt);

	fMACAddress = get_info.CurrentNodeAddress;

	TRACE("MAC: %02x:%02x:%02x:%02x:%02x:%02x\n", fMACAddress[0], fMACAddress[1], fMACAddress[2], fMACAddress[3], fMACAddress[4], fMACAddress[5]);

	return B_OK;
}


mac_addr_t
UNDI::MACAddress() const
{
	return fMACAddress;
}


void *
UNDI::AllocateSendReceiveBuffer(size_t size)
{
	TRACE("UNDI::AllocateSendReceiveBuffer, size %ld\n", size);
	if (size > 0x3000)
		return NULL;

	return (void *)0x500;
}


void
UNDI::FreeSendReceiveBuffer(void *buffer)
{
	TRACE("UNDI::FreeSendReceiveBuffer\n");
}


ssize_t
UNDI::Send(const void *buffer, size_t size)
{
	TRACE("UNDI::Send, buffer %p, size %ld\n", buffer, size);

//	hex_dump(buffer, size);


	PXENV_UNDI_TRANSMIT undi_tx;
	PXENV_UNDI_TBD undi_tbd;

	undi_tx.Protocol = P_UNKNOWN;
	undi_tx.XmitFlag = XMT_DESTADDR;
	undi_tx.DestAddr.seg = SEG((char *)buffer + 16);
	undi_tx.DestAddr.ofs = OFS((char *)buffer + 16);
	undi_tx.TBD.seg = SEG(&undi_tbd);
	undi_tx.TBD.ofs = OFS(&undi_tbd);

	undi_tbd.ImmedLength = size;
	undi_tbd.Xmit.seg = SEG(buffer);
	undi_tbd.Xmit.ofs = OFS(buffer);
	undi_tbd.DataBlkCount = 0;

	uint16 res = call_pxe_bios(fPxeData, UNDI_TRANSMIT, &undi_tx);
	if (res != 0 || undi_tx.Status != 0) {
		dprintf("UNDI_TRANSMIT failed, res %x, status %x\n", res, undi_tx.Status);
		return 0;
	}

	TRACE("UNDI_TRANSMIT success\n");

	return size;
}


ssize_t
UNDI::Receive(void *buffer, size_t size)
{
	//TRACE("UNDI::Receive, buffer %p, size %ld\n", buffer, size);


	PXENV_UNDI_ISR undi_isr;
	uint16 res;

	if (!fRxFinished) {
		TRACE("continue receive...\n");

		undi_isr.FuncFlag = PXENV_UNDI_ISR_IN_GET_NEXT;
		res = call_pxe_bios(fPxeData, UNDI_ISR, &undi_isr);
		if (res != 0 || undi_isr.Status != 0) {
			dprintf("PXENV_UNDI_ISR_IN_GET_NEXT failed, res %x, status %x\n", res, undi_isr.Status);
			fRxFinished = true;
			return 0;
		}

	} else {

		undi_isr.FuncFlag = PXENV_UNDI_ISR_IN_START;

		res = call_pxe_bios(fPxeData, UNDI_ISR, &undi_isr);
		if (res != 0 || undi_isr.Status != 0) {
			dprintf("PXENV_UNDI_ISR_IN_START failed, res %x, status %x\n", res, undi_isr.Status);
			return -1;
		}

		if (undi_isr.FuncFlag != PXENV_UNDI_ISR_OUT_OURS) {
//			TRACE("not ours\n");

			return -1;
		}

		// send EOI to pic ?


//		TRACE("PXENV_UNDI_ISR_OUT_OURS\n");


		undi_isr.FuncFlag = PXENV_UNDI_ISR_IN_PROCESS;
		res = call_pxe_bios(fPxeData, UNDI_ISR, &undi_isr);
		if (res != 0 || undi_isr.Status != 0) {
			dprintf("PXENV_UNDI_ISR_IN_PROCESS failed, res %x, status %x\n", res, undi_isr.Status);
			return -1;
		}
	}

	switch (undi_isr.FuncFlag) {
		case PXENV_UNDI_ISR_OUT_TRANSMIT:
			TRACE("PXENV_UNDI_ISR_OUT_TRANSMIT\n");
			fRxFinished = false;
			return 0;

		case PXENV_UNDI_ISR_OUT_RECEIVE:
			TRACE("PXENV_UNDI_ISR_OUT_RECEIVE\n");
//			TRACE("BufferLength %d\n", undi_isr.BufferLength);

//			TRACE("FrameLength %d\n", undi_isr.FrameLength);

//			TRACE("FrameHeaderLength %d\n", undi_isr.FrameHeaderLength);

			if (undi_isr.FrameLength > undi_isr.BufferLength)
				panic("UNDI::Receive: multi buffer frames not supported");
			if (size > undi_isr.BufferLength)
				size = undi_isr.BufferLength;
			memcpy(buffer, (const void *)(undi_isr.Frame.seg * 16 + undi_isr.Frame.ofs), size);
//			hex_dump(buffer, size);

			fRxFinished = false;
			return size;

		case PXENV_UNDI_ISR_OUT_BUSY:
			TRACE("PXENV_UNDI_ISR_OUT_BUSY\n");
			fRxFinished = true;
			return -1;

		case PXENV_UNDI_ISR_OUT_DONE:
			TRACE("PXENV_UNDI_ISR_OUT_DONE\n");
			fRxFinished = true;
			return -1;

		default:
			TRACE("default!!!\n");
			return -1;
	}
}


// #pragma mark - TFTP


TFTP::TFTP()
{
}


TFTP::~TFTP()
{
}


status_t
TFTP::Init()
{
	status_t error = PXEService::Init();
	if (error != B_OK)
		return error;



	return B_OK;
}


uint16
TFTP::ServerPort() const
{
	return 69;
}


status_t
TFTP::ReceiveFile(const char* fileName, uint8** data, size_t* size)
{
	// get file size

	pxenv_tftp_get_fsize getFileSize;
	getFileSize.server_ip.num = htonl(fServerIP);
	getFileSize.gateway_ip.num = 0;
	strlcpy(getFileSize.file_name, fileName, sizeof(getFileSize.file_name));

	uint16 res = call_pxe_bios(fPxeData, TFTP_GET_FILE_SIZE, &getFileSize);
	if (res != 0 || getFileSize.status != 0) {
		dprintf("TFTP_GET_FILE_SIZE failed, res %x, status %x\n", res,
			getFileSize.status);

		return B_ERROR;
	}

	uint32 fileSize = getFileSize.file_size;
	dprintf("size of boot archive \"%s\": %u\n", fileName, fileSize);

	// allocate memory for the data

	uint8* fileData = NULL;
	if (platform_allocate_region((void**)&fileData, fileSize,
			B_READ_AREA | B_WRITE_AREA) != B_OK) {
		TRACE(("TFTP: allocating memory for file data failed\n"));
		return B_NO_MEMORY;
	}

	// open TFTP connection

	pxenv_tftp_open openConnection;
	openConnection.server_ip.num = htonl(fServerIP);
	openConnection.gateway_ip.num = 0;
	strlcpy(openConnection.file_name, fileName, sizeof(getFileSize.file_name));
	openConnection.port = htons(ServerPort());
	openConnection.packet_size = 1456;

	res = call_pxe_bios(fPxeData, TFTP_OPEN, &openConnection);
	if (res != 0 || openConnection.status != 0) {
		dprintf("TFTP_OPEN failed, res %x, status %x\n", res,
			openConnection.status);

		platform_free_region(fileData, fileSize);
		return B_ERROR;
	}

	uint16 packetSize = openConnection.packet_size;
	dprintf("successfully opened TFTP connection, packet size %u\n",
		packetSize);

	// check, if the file is too big for the TFTP protocol

	if (fileSize > 0xffff * (uint32)packetSize) {
		dprintf("TFTP: File is too big to be transferred via TFTP\n");
		_Close();
		platform_free_region(fileData, fileSize);
		return B_ERROR;
	}

	// transfer the file

	status_t error = B_OK;
	uint32 remainingBytes = fileSize;
	uint8* buffer = fileData;
	while (remainingBytes > 0) {
		void* scratchBuffer = (void*)0x07C00;
		pxenv_tftp_read readPacket;
		readPacket.buffer.seg = SEG(scratchBuffer);
		readPacket.buffer.ofs = OFS(scratchBuffer);

		res = call_pxe_bios(fPxeData, TFTP_READ, &readPacket);
		if (res != 0 || readPacket.status != 0) {
			dprintf("TFTP_READ failed, res %x, status %x\n", res,
				readPacket.status);
			error = B_ERROR;
			break;
		}

		uint32 bytesRead = readPacket.buffer_size;
		if (bytesRead > remainingBytes) {
			dprintf("TFTP: Read more bytes than should be remaining!");
			error = B_ERROR;
			break;
		}

		memcpy(buffer, scratchBuffer, bytesRead);
		buffer += bytesRead;
		remainingBytes -= bytesRead;
	}

	// close TFTP connection

	_Close();

	if (error == B_OK) {
		dprintf("TFTP: Successfully received file\n");
		*data = fileData;
		*size = fileSize;
	} else {
		platform_free_region(fileData, fileSize);
	}

	return error;
}

status_t
TFTP::_Close()
{
	// close TFTP connection

	pxenv_tftp_close closeConnection;
	uint16 res = call_pxe_bios(fPxeData, TFTP_CLOSE, &closeConnection);
	if (res != 0 || closeConnection.status != 0) {
		dprintf("TFTP_CLOSE failed, res %x, status %x\n", res,
			closeConnection.status);
		return B_ERROR;
	}

	return B_OK;
}



// #pragma mark -



status_t
platform_net_stack_init()
{
	TRACE("platform_net_stack_init\n");

	UNDI *interface = new(nothrow) UNDI;
	if (!interface)
		return B_NO_MEMORY;

	status_t error = interface->Init();
	if (error != B_OK) {
		TRACE("platform_net_stack_init: interface init failed\n");
		delete interface;
		return error;
	}

	error = NetStack::Default()->AddEthernetInterface(interface);
	if (error != B_OK) {
		delete interface;
		return error;
	}

	return B_OK;
}