/*
 * Copyright 2006-2010, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Axel Dörfler, axeld@pinc-software.de
 */


#include <ethernet.h>
#include <net_datalink_protocol.h>
#include <net_device.h>
#include <net_datalink.h>
#include <net_stack.h>
#include <NetBufferUtilities.h>

#include <ByteOrder.h>
#include <KernelExport.h>

#include <net/if.h>
#include <net/if_types.h>
#include <net/if_dl.h>
#include <new>
#include <string.h>


struct loopback_frame_protocol : net_datalink_protocol {
};


struct net_buffer_module_info* gBufferModule;


status_t
loopback_deframe(net_device* device, net_buffer* buffer)
{
	// there is not that much to do...
	return B_OK;
}


//	#pragma mark -


status_t
loopback_frame_init(struct net_interface*interface, net_domain* domain,
	net_datalink_protocol** _protocol)
{
	if (interface->device->type != IFT_LOOP && interface->device->type != IFT_TUNNEL)
		return B_BAD_TYPE;

	loopback_frame_protocol* protocol;

	net_stack_module_info* stack;
	status_t status = get_module(NET_STACK_MODULE_NAME, (module_info**)&stack);
	if (status != B_OK)
		return status;
	status = stack->register_device_deframer(interface->device,
		&loopback_deframe);
	if (status != B_OK)
		goto err1;

	if (interface->device->type == IFT_LOOP) {
		// Locally received buffers don't need a domain device handler, as the
		// buffer reception is handled internally.
	} else if (interface->device->type == IFT_TUNNEL) {
		status = stack->register_domain_device_handler(
			interface->device, B_NET_FRAME_TYPE_IPV4, domain);
		if (status != B_OK)
			return status;
	}

	protocol = new(std::nothrow) loopback_frame_protocol;
	if (protocol == NULL) {
		status = B_NO_MEMORY;
		goto err2;
	}

	put_module(NET_STACK_MODULE_NAME);

	*_protocol = protocol;
	return B_OK;

err2:
	stack->unregister_device_deframer(interface->device);
err1:
	put_module(NET_STACK_MODULE_NAME);
	return status;
}


status_t
loopback_frame_uninit(net_datalink_protocol* protocol)
{
	net_stack_module_info* stack;
	if (get_module(NET_STACK_MODULE_NAME, (module_info**)&stack) == B_OK) {
		stack->unregister_device_deframer(protocol->interface->device);
		stack->unregister_device_handler(protocol->interface->device, 0);
		put_module(NET_STACK_MODULE_NAME);
	}

	delete protocol;
	return B_OK;
}


status_t
loopback_frame_send_data(net_datalink_protocol* protocol, net_buffer* buffer)
{
	return protocol->next->module->send_data(protocol->next, buffer);
}


status_t
loopback_frame_up(net_datalink_protocol* protocol)
{
	return protocol->next->module->interface_up(protocol->next);
}


void
loopback_frame_down(net_datalink_protocol* protocol)
{
	return protocol->next->module->interface_down(protocol->next);
}


status_t
loopback_frame_change_address(net_datalink_protocol* protocol,
	net_interface_address* address, int32 option,
	const struct sockaddr* oldAddress, const struct sockaddr* newAddress)
{
	return protocol->next->module->change_address(protocol->next, address,
		option, oldAddress, newAddress);
}


status_t
loopback_frame_control(net_datalink_protocol* protocol, int32 option,
	void* argument, size_t length)
{
	return protocol->next->module->control(protocol->next, option, argument,
		length);
}


static status_t
loopback_frame_join_multicast(net_datalink_protocol* protocol,
	const sockaddr* address)
{
	return protocol->next->module->join_multicast(protocol->next, address);
}


static status_t
loopback_frame_leave_multicast(net_datalink_protocol* protocol,
	const sockaddr* address)
{
	return protocol->next->module->leave_multicast(protocol->next, address);
}


static status_t
loopback_frame_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
			return get_module(NET_BUFFER_MODULE_NAME,
				(module_info**)&gBufferModule);
		case B_MODULE_UNINIT:
			put_module(NET_BUFFER_MODULE_NAME);
			return B_OK;

		default:
			return B_ERROR;
	}
}


static net_datalink_protocol_module_info sLoopbackFrameModule = {
	{
		"network/datalink_protocols/loopback_frame/v1",
		0,
		loopback_frame_std_ops
	},
	loopback_frame_init,
	loopback_frame_uninit,
	loopback_frame_send_data,
	loopback_frame_up,
	loopback_frame_down,
	loopback_frame_change_address,
	loopback_frame_control,
	loopback_frame_join_multicast,
	loopback_frame_leave_multicast,
};

module_info* modules[] = {
	(module_info*)&sLoopbackFrameModule,
	NULL
};