/*
 * Copyright 2008, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */

#include "stack_private.h"


/*!	Interface module providing networking to the kernel.
*/


static status_t
stack_interface_open(int family, int type, int protocol, net_socket** _socket)
{
	return gNetSocketModule.open_socket(family, type, protocol, _socket);
}


static status_t
stack_interface_close(net_socket* socket)
{
	return gNetSocketModule.close(socket);
}


static status_t
stack_interface_free(net_socket* socket)
{
	gNetSocketModule.free(socket);
	return B_OK;
}


static status_t
stack_interface_bind(net_socket* socket, const struct sockaddr* address,
	socklen_t addressLength)
{
	return gNetSocketModule.bind(socket, address, addressLength);
}


static status_t
stack_interface_shutdown(net_socket* socket, int how)
{
	return gNetSocketModule.shutdown(socket, how);
}


static status_t
stack_interface_connect(net_socket* socket, const struct sockaddr* address,
	socklen_t addressLength)
{
	return gNetSocketModule.connect(socket, address, addressLength);
}


static status_t
stack_interface_listen(net_socket* socket, int backlog)
{
	return gNetSocketModule.listen(socket, backlog);
}


static status_t
stack_interface_accept(net_socket* socket, struct sockaddr* address,
	socklen_t* _addressLength, net_socket** _acceptedSocket)
{
	return gNetSocketModule.accept(socket, address, _addressLength,
		_acceptedSocket);
}


static ssize_t
stack_interface_recv(net_socket* socket, void* data, size_t length, int flags)
{
	return gNetSocketModule.receive(socket, NULL, data, length, flags);
}


static ssize_t
stack_interface_recvfrom(net_socket* socket, void* data, size_t length,
	int flags, struct sockaddr* address, socklen_t* _addressLength)
{
	msghdr message;
	iovec vec = { data, length };
	message.msg_name = address;
	if (_addressLength != NULL)
		message.msg_namelen = *_addressLength;
	else
		message.msg_namelen = 0;
	message.msg_iov = &vec;
	message.msg_iovlen = 1;
	message.msg_control = NULL;
	message.msg_controllen = 0;
	message.msg_flags = 0;

	ssize_t received = gNetSocketModule.receive(socket, &message, data, length,
		flags);

	if (received >= 0 && _addressLength != NULL)
		*_addressLength = message.msg_namelen;

	return received;
}


static ssize_t
stack_interface_recvmsg(net_socket* socket, struct msghdr* message, int flags)
{
	void* buffer = NULL;
	size_t length = 0;
	if (message->msg_iovlen > 0) {
		buffer = message->msg_iov[0].iov_base;
		length = message->msg_iov[0].iov_len;
	}

	return gNetSocketModule.receive(socket, message, buffer, length, flags);
}


static ssize_t
stack_interface_send(net_socket* socket, const void* data, size_t length,
	int flags)
{
	return gNetSocketModule.send(socket, NULL, data, length, flags);
}


static ssize_t
stack_interface_sendto(net_socket* socket, const void* data, size_t length,
	int flags, const struct sockaddr* address, socklen_t addressLength)
{
	msghdr message;
	iovec vec = { (void*)data, length };
	message.msg_name = (void*)address;
	message.msg_namelen = addressLength;
	message.msg_iov = &vec;
	message.msg_iovlen = 1;
	message.msg_control = NULL;
	message.msg_controllen = 0;
	message.msg_flags = 0;

	return gNetSocketModule.send(socket, &message, data, length, flags);
}


static ssize_t
stack_interface_sendmsg(net_socket* socket, const struct msghdr* message,
	int flags)
{
	void* buffer = NULL;
	size_t length = 0;
	if (message->msg_iovlen > 0) {
		buffer = message->msg_iov[0].iov_base;
		length = message->msg_iov[0].iov_len;
	}

	return gNetSocketModule.send(socket, (msghdr*)message, buffer, length,
		flags);
}


static status_t
stack_interface_getsockopt(net_socket* socket, int level, int option,
	void* value, socklen_t* _length)
{
	int length = *_length;
	status_t error = gNetSocketModule.getsockopt(socket, level, option, value,
		&length);
	*_length = length;
	return error;
}


static status_t
stack_interface_setsockopt(net_socket* socket, int level, int option,
	const void* value, socklen_t length)
{
	return gNetSocketModule.setsockopt(socket, level, option, value, length);
}


static status_t
stack_interface_getpeername(net_socket* socket, struct sockaddr* address,
	socklen_t* _addressLength)
{
	return gNetSocketModule.getpeername(socket, address, _addressLength);
}


static status_t
stack_interface_getsockname(net_socket* socket, struct sockaddr* address,
	socklen_t* _addressLength)
{
	return gNetSocketModule.getsockname(socket, address, _addressLength);
}


static int
stack_interface_sockatmark(net_socket* socket)
{
	// TODO: sockatmark() missing
	return B_UNSUPPORTED;
}


static status_t
stack_interface_socketpair(int family, int type, int protocol,
	net_socket* _sockets[2])
{
	return gNetSocketModule.socketpair(family, type, protocol, _sockets);
}


static status_t
stack_interface_ioctl(net_socket* socket, uint32 op, void* buffer,
	size_t length)
{
	return gNetSocketModule.control(socket, op, buffer, length);
}


static status_t
stack_interface_select(net_socket* socket, uint8 event, struct selectsync* sync)
{
	return gNetSocketModule.request_notification(socket, event, sync);
}


static status_t
stack_interface_deselect(net_socket* socket, uint8 event,
	struct selectsync* sync)
{
	return gNetSocketModule.cancel_notification(socket, event, sync);
}


status_t
stack_interface_get_next_socket_stat(int family, uint32* cookie,
	struct net_stat* stat)
{
	return gNetSocketModule.get_next_stat(cookie, family, stat);
}


static status_t
stack_interface_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
			return init_stack();
		case B_MODULE_UNINIT:
			return uninit_stack();

		default:
			return B_ERROR;
	}
}


net_stack_interface_module_info gNetStackInterfaceModule = {
	{
		NET_STACK_INTERFACE_MODULE_NAME,
		0,
		stack_interface_std_ops
	},

	&stack_interface_open,
	&stack_interface_close,
	&stack_interface_free,

	&stack_interface_bind,
	&stack_interface_shutdown,
	&stack_interface_connect,
	&stack_interface_listen,
	&stack_interface_accept,

	&stack_interface_recv,
	&stack_interface_recvfrom,
	&stack_interface_recvmsg,

	&stack_interface_send,
	&stack_interface_sendto,
	&stack_interface_sendmsg,

	&stack_interface_getsockopt,
	&stack_interface_setsockopt,

	&stack_interface_getpeername,
	&stack_interface_getsockname,

	&stack_interface_sockatmark,

	&stack_interface_socketpair,

	&stack_interface_ioctl,
	&stack_interface_select,
	&stack_interface_deselect,

	&stack_interface_get_next_socket_stat
};