haiku.git

/*
 * Copyright 2014, Haiku, Inc. All Rights Reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Lin Longzhou, linlongzhou@163.com
 */


#include <ethernet.h>
#include <net/if_types.h>
#include <net_datalink_protocol.h>
#include <net_datalink.h>

#include <KernelExport.h>

#include <new>

#include <PPPControl.h>
#include <ppp_device.h>

struct ppp_frame_protocol : net_datalink_protocol {
};


static net_stack_module_info *sStackModule;

status_t
ppp_deframe(net_device* device, net_buffer* buffer)
{
	TRACE("%s: buffer type:0x%" B_PRIx32 "\n", __func__, buffer->type);
	return B_OK;
}


//	#pragma mark -

status_t
ppp_frame_init(struct net_interface* interface, net_domain* domain,
	net_datalink_protocol** _protocol)
{
	// We only support a single type!
	dprintf("in function: %s::%s\n", __FILE__, __func__);
	if (interface->device->type != IFT_PPP)
		return B_BAD_TYPE;

	ppp_frame_protocol* protocol;

	status_t status = sStackModule->register_device_deframer(interface->device,
		&ppp_deframe);
	if (status != B_OK)
		return status;

	status = sStackModule->register_domain_device_handler(
		interface->device, B_NET_FRAME_TYPE(IFT_ETHER, ETHER_TYPE_PPPOE), domain);
	if (status != B_OK)
		return status;

	status = sStackModule->register_domain_device_handler(
		interface->device, B_NET_FRAME_TYPE_IPV4, domain);
	if (status != B_OK)
		return status;

	// Locally received buffers don't need a domain device handler, as the
	// buffer reception is handled internally.

	protocol = new(std::nothrow) ppp_frame_protocol;
	if (protocol == NULL) {
		sStackModule->unregister_device_deframer(interface->device);
		return B_NO_MEMORY;
	}

	*_protocol = protocol;
	return B_OK;
}


status_t
ppp_frame_uninit(net_datalink_protocol* protocol)
{
	sStackModule->unregister_device_deframer(protocol->interface->device);
	sStackModule->unregister_device_handler(protocol->interface->device, 0);

	delete protocol;
	TRACE("%s\n", __func__);
	return B_OK;
}


status_t
ppp_frame_send_data(net_datalink_protocol* protocol, net_buffer* buffer)
{
	TRACE("%s: next module is %s\n", __func__, protocol->next->module->info.name);
	return protocol->next->module->send_data(protocol->next, buffer);
}


status_t
ppp_frame_up(net_datalink_protocol* protocol)
{
	dprintf("in function: %s\n", __func__);

	return protocol->next->module->interface_up(protocol->next);
}


void
ppp_frame_down(net_datalink_protocol* protocol)
{
	dprintf("%s::%s: entry\n", __FILE__, __func__);
	protocol->next->module->interface_down(protocol->next);
	return;
}


status_t
ppp_frame_change_address(net_datalink_protocol* protocol,
	net_interface_address* address, int32 option,
	const struct sockaddr* oldAddress, const struct sockaddr* newAddress)
{
	TRACE("in function: %s::%s\n", __FILE__, __func__);
	return protocol->next->module->change_address(protocol->next, address,
		option, oldAddress, newAddress);
}


static status_t
PPP_module_control(int32 option, void* argument, size_t length)
{
	// control_net_module_args* args=(control_net_module_args*)argument;

	if (option < PPPC_CONTROL_MODULE || option > PPP_CONTROL_OPS_END)
		return B_ERROR;

	// if (args->name != PPP_INTERFACE_MODULE_NAME)
		// return B_ERROR;

	switch(option)
	{
		case PPPC_CREATE_INTERFACE:
			// process_CreateInterface(args->data, args->length);
		case PPPC_CREATE_INTERFACE_WITH_NAME:
		case PPPC_DELETE_INTERFACE:
		case PPPC_BRING_INTERFACE_UP:
		case PPPC_BRING_INTERFACE_DOWN:
		case PPPC_CONTROL_INTERFACE:
		case PPPC_GET_INTERFACES:
		case PPPC_COUNT_INTERFACES:
		case PPPC_FIND_INTERFACE_WITH_SETTINGS:

		// interface control
		case PPPC_GET_INTERFACE_INFO:
		case PPPC_SET_USERNAME:
		case PPPC_SET_PASSWORD:
		case PPPC_SET_ASK_BEFORE_CONNECTING:
			// ppp_up uses this in order to finalize a connection request
		case PPPC_SET_MRU:
		case PPPC_SET_CONNECT_ON_DEMAND:
		case PPPC_SET_AUTO_RECONNECT:
		case PPPC_HAS_INTERFACE_SETTINGS:
		case PPPC_GET_STATISTICS:
		// handler access
		case PPPC_CONTROL_DEVICE:
		case PPPC_CONTROL_PROTOCOL:
		case PPPC_CONTROL_OPTION_HANDLER:
		case PPPC_CONTROL_LCP_EXTENSION:
		case PPPC_CONTROL_CHILD:
		// KPPPDevice
		case PPPC_GET_DEVICE_INFO:
		// KPPPProtocol
		case PPPC_GET_PROTOCOL_INFO:
		// Common/mixed ops
		case PPPC_ENABLE:
		case PPPC_GET_SIMPLE_HANDLER_INFO:

		// these two control ops use the ppp_report_request structure
		case PPPC_ENABLE_REPORTS:
		case PPPC_DISABLE_REPORTS:

		case PPP_CONTROL_OPS_END:
		case PPPC_CONTROL_MODULE:
		default:
			return B_ERROR;
	}
}


static status_t
ppp_frame_control(net_datalink_protocol* protocol, int32 option,
	void* argument, size_t length)
{
	TRACE("%s: option:%" B_PRId32 "\n", __func__, option);

	if (option >= PPPC_CONTROL_MODULE && option <=PPP_CONTROL_OPS_END)
	{
		status_t status =PPP_module_control(option, argument, length);
		// gPPPInterfaceModule->ControlInterface(1, option, argument, length);
		return status;
	}

	return protocol->next->module->control(protocol->next, option, argument,
		length);
}


static status_t
ppp_frame_join_multicast(net_datalink_protocol* protocol,
	const sockaddr* address)
{
	TRACE("in function: %s\n", __func__);
	return protocol->next->module->join_multicast(protocol->next, address);
}


static status_t
ppp_frame_leave_multicast(net_datalink_protocol* protocol,
	const sockaddr* address)
{
	TRACE("in function: %s\n", __func__);
	return protocol->next->module->leave_multicast(protocol->next, address);
}


static status_t
pppoe_frame_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
			if (get_module(NET_STACK_MODULE_NAME,
				(module_info **)&sStackModule) != B_OK)
				return B_ERROR;
			return B_OK;

		case B_MODULE_UNINIT:
			put_module(NET_STACK_MODULE_NAME);
			return B_OK;

		default:
			return B_ERROR;
	}
}


static net_datalink_protocol_module_info sPPPFrameModule = {
	{
		"network/datalink_protocols/ppp_frame/v1",
		0,
		pppoe_frame_std_ops
	},
	ppp_frame_init,
	ppp_frame_uninit,
	ppp_frame_send_data,
	ppp_frame_up,
	ppp_frame_down,
	ppp_frame_change_address,
	ppp_frame_control,
	ppp_frame_join_multicast,
	ppp_frame_leave_multicast,
};


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