/*
 * 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 "domains.h"
#include "interfaces.h"
#include "routes.h"
#include "stack_private.h"
#include "utility.h"

#include <net_device.h>
#include <NetUtilities.h>

#include <lock.h>
#include <util/AutoLock.h>

#include <KernelExport.h>

#include <net/if_dl.h>
#include <net/route.h>
#include <new>
#include <stdlib.h>
#include <string.h>
#include <sys/sockio.h>


//#define TRACE_ROUTES
#ifdef TRACE_ROUTES
#	define TRACE(x...) dprintf(STACK_DEBUG_PREFIX x)
#else
#	define TRACE(x...) ;
#endif


net_route_private::net_route_private()
{
	destination = mask = gateway = NULL;
}


net_route_private::~net_route_private()
{
	free(destination);
	free(mask);
	free(gateway);
}


//	#pragma mark - private functions


static status_t
user_copy_address(const sockaddr* from, sockaddr** to)
{
	if (from == NULL) {
		*to = NULL;
		return B_OK;
	}

	sockaddr address;
	if (user_memcpy(&address, from, sizeof(struct sockaddr)) < B_OK)
		return B_BAD_ADDRESS;

	*to = (sockaddr*)malloc(address.sa_len);
	if (*to == NULL)
		return B_NO_MEMORY;

	if (address.sa_len > sizeof(struct sockaddr)) {
		if (user_memcpy(*to, from, address.sa_len) < B_OK)
			return B_BAD_ADDRESS;
	} else
		memcpy(*to, &address, address.sa_len);

	return B_OK;
}


static status_t
user_copy_address(const sockaddr* from, sockaddr_storage* to)
{
	if (from == NULL)
		return B_BAD_ADDRESS;

	if (user_memcpy(to, from, sizeof(sockaddr)) < B_OK)
		return B_BAD_ADDRESS;

	if (to->ss_len > sizeof(sockaddr)) {
		if (to->ss_len > sizeof(sockaddr_storage))
			return B_BAD_VALUE;
		if (user_memcpy(to, from, to->ss_len) < B_OK)
			return B_BAD_ADDRESS;
	}

	return B_OK;
}


static net_route_private*
find_route(struct net_domain* _domain, const net_route* description)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;
	RouteList::Iterator iterator = domain->routes.GetIterator();

	while (iterator.HasNext()) {
		net_route_private* route = iterator.Next();

		if ((route->flags & RTF_DEFAULT) != 0
			&& (description->flags & RTF_DEFAULT) != 0) {
			// there can only be one default route per interface address family
			// TODO: check this better
			if (route->interface_address == description->interface_address)
				return route;

			continue;
		}

		if ((route->flags & (RTF_GATEWAY | RTF_HOST | RTF_LOCAL | RTF_DEFAULT))
				== (description->flags
					& (RTF_GATEWAY | RTF_HOST | RTF_LOCAL | RTF_DEFAULT))
			&& domain->address_module->equal_masked_addresses(
				route->destination, description->destination, description->mask)
			&& domain->address_module->equal_addresses(route->mask,
				description->mask)
			&& domain->address_module->equal_addresses(route->gateway,
				description->gateway)
			&& (description->interface_address == NULL
				|| description->interface_address == route->interface_address))
			return route;
	}

	return NULL;
}


static net_route_private*
find_route(net_domain* _domain, const sockaddr* address)
{
	net_domain_private* domain = (net_domain_private*)_domain;

	// find last matching route

	RouteList::Iterator iterator = domain->routes.GetIterator();
	net_route_private* candidate = NULL;

	TRACE("test address %s for routes...\n",
		AddressString(domain, address).Data());

	// TODO: alternate equal default routes

	while (iterator.HasNext()) {
		net_route_private* route = iterator.Next();

		if (route->mask) {
			sockaddr maskedAddress;
			domain->address_module->mask_address(address, route->mask,
				&maskedAddress);
			if (!domain->address_module->equal_addresses(&maskedAddress,
					route->destination))
				continue;
		} else if (!domain->address_module->equal_addresses(address,
				route->destination))
			continue;

		// neglect routes that point to devices that have no link
		if ((route->interface_address->interface->device->flags & IFF_LINK)
				== 0) {
			if (candidate == NULL) {
				TRACE("  found candidate: %s, flags %lx\n", AddressString(
					domain, route->destination).Data(), route->flags);
				candidate = route;
			}
			continue;
		}

		TRACE("  found route: %s, flags %lx\n",
			AddressString(domain, route->destination).Data(), route->flags);

		return route;
	}

	return candidate;
}


static void
put_route_internal(struct net_domain_private* domain, net_route* _route)
{
	ASSERT_LOCKED_RECURSIVE(&domain->lock);

	net_route_private* route = (net_route_private*)_route;
	if (route == NULL || atomic_add(&route->ref_count, -1) != 1)
		return;

	// delete route - it must already have been removed at this point
	if (route->interface_address != NULL)
		((InterfaceAddress*)route->interface_address)->ReleaseReference();

	delete route;
}


static struct net_route*
get_route_internal(struct net_domain_private* domain,
	const struct sockaddr* address)
{
	ASSERT_LOCKED_RECURSIVE(&domain->lock);
	net_route_private* route = NULL;

	if (address->sa_family == AF_LINK) {
		// special address to find an interface directly
		RouteList::Iterator iterator = domain->routes.GetIterator();
		const sockaddr_dl* link = (const sockaddr_dl*)address;

		while (iterator.HasNext()) {
			route = iterator.Next();

			net_device* device = route->interface_address->interface->device;

			if ((link->sdl_nlen > 0
					&& !strncmp(device->name, (const char*)link->sdl_data,
							IF_NAMESIZE))
				|| (link->sdl_nlen == 0 && link->sdl_alen > 0
					&& !memcmp(LLADDR(link), device->address.data,
							device->address.length)))
				break;
		}
	} else
		route = find_route(domain, address);

	if (route != NULL && atomic_add(&route->ref_count, 1) == 0) {
		// route has been deleted already
		route = NULL;
	}

	return route;
}


static void
update_route_infos(struct net_domain_private* domain)
{
	ASSERT_LOCKED_RECURSIVE(&domain->lock);
	RouteInfoList::Iterator iterator = domain->route_infos.GetIterator();

	while (iterator.HasNext()) {
		net_route_info* info = iterator.Next();

		put_route_internal(domain, info->route);
		info->route = get_route_internal(domain, &info->address);
	}
}


static sockaddr*
copy_address(UserBuffer& buffer, sockaddr* address)
{
	if (address == NULL)
		return NULL;

	return (sockaddr*)buffer.Push(address, address->sa_len);
}


static status_t
fill_route_entry(route_entry* target, void* _buffer, size_t bufferSize,
	net_route* route)
{
	UserBuffer buffer(((uint8*)_buffer) + sizeof(route_entry),
		bufferSize - sizeof(route_entry));

	target->destination = copy_address(buffer, route->destination);
	target->mask = copy_address(buffer, route->mask);
	target->gateway = copy_address(buffer, route->gateway);
	target->source = copy_address(buffer, route->interface_address->local);
	target->flags = route->flags;
	target->mtu = route->mtu;

	return buffer.Status();
}


//	#pragma mark - exported functions


/*!	Determines the size of a buffer large enough to contain the whole
	routing table.
*/
uint32
route_table_size(net_domain_private* domain)
{
	RecursiveLocker locker(domain->lock);
	uint32 size = 0;

	RouteList::Iterator iterator = domain->routes.GetIterator();
	while (iterator.HasNext()) {
		net_route_private* route = iterator.Next();
		size += IF_NAMESIZE + sizeof(route_entry);

		if (route->destination)
			size += route->destination->sa_len;
		if (route->mask)
			size += route->mask->sa_len;
		if (route->gateway)
			size += route->gateway->sa_len;
	}

	return size;
}


/*!	Dumps a list of all routes into the supplied userland buffer.
	If the routes don't fit into the buffer, an error (\c ENOBUFS) is
	returned.
*/
status_t
list_routes(net_domain_private* domain, void* buffer, size_t size)
{
	RecursiveLocker _(domain->lock);

	RouteList::Iterator iterator = domain->routes.GetIterator();
	const size_t kBaseSize = IF_NAMESIZE + sizeof(route_entry);
	size_t spaceLeft = size;

	sockaddr zeros;
	memset(&zeros, 0, sizeof(sockaddr));
	zeros.sa_family = domain->family;
	zeros.sa_len = sizeof(sockaddr);

	while (iterator.HasNext()) {
		net_route* route = iterator.Next();

		size = kBaseSize;

		sockaddr* destination = NULL;
		sockaddr* mask = NULL;
		sockaddr* gateway = NULL;
		uint8* next = (uint8*)buffer + size;

		if (route->destination != NULL) {
			destination = (sockaddr*)next;
			next += route->destination->sa_len;
			size += route->destination->sa_len;
		}
		if (route->mask != NULL) {
			mask = (sockaddr*)next;
			next += route->mask->sa_len;
			size += route->mask->sa_len;
		}
		if (route->gateway != NULL) {
			gateway = (sockaddr*)next;
			next += route->gateway->sa_len;
			size += route->gateway->sa_len;
		}

		if (spaceLeft < size)
			return ENOBUFS;

		ifreq request;
		memset(&request, 0, sizeof(request));

		strlcpy(request.ifr_name, route->interface_address->interface->name,
			IF_NAMESIZE);
		request.ifr_route.destination = destination;
		request.ifr_route.mask = mask;
		request.ifr_route.gateway = gateway;
		request.ifr_route.mtu = route->mtu;
		request.ifr_route.flags = route->flags;

		// copy data into userland buffer
		if (user_memcpy(buffer, &request, kBaseSize) < B_OK
			|| (route->destination != NULL
				&& user_memcpy(request.ifr_route.destination,
					route->destination, route->destination->sa_len) < B_OK)
			|| (route->mask != NULL && user_memcpy(request.ifr_route.mask,
					route->mask, route->mask->sa_len) < B_OK)
			|| (route->gateway != NULL && user_memcpy(request.ifr_route.gateway,
					route->gateway, route->gateway->sa_len) < B_OK))
			return B_BAD_ADDRESS;

		buffer = (void*)next;
		spaceLeft -= size;
	}

	return B_OK;
}


status_t
control_routes(struct net_interface* _interface, net_domain* domain,
	int32 option, void* argument, size_t length)
{
	TRACE("control_routes(interface %p, domain %p, option %" B_PRId32 ")\n",
		_interface, domain, option);
	Interface* interface = (Interface*)_interface;

	switch (option) {
		case SIOCADDRT:
		case SIOCDELRT:
		{
			// add or remove a route
			if (length != sizeof(struct ifreq))
				return B_BAD_VALUE;

			route_entry entry;
			if (user_memcpy(&entry, &((ifreq*)argument)->ifr_route,
					sizeof(route_entry)) != B_OK)
				return B_BAD_ADDRESS;

			net_route_private route;
			status_t status;
			if ((status = user_copy_address(entry.destination,
					&route.destination)) != B_OK
				|| (status = user_copy_address(entry.mask, &route.mask)) != B_OK
				|| (status = user_copy_address(entry.gateway, &route.gateway))
					!= B_OK)
				return status;

			InterfaceAddress* address
				= interface->FirstForFamily(domain->family);

			route.mtu = entry.mtu;
			route.flags = entry.flags;
			route.interface_address = address;

			if (option == SIOCADDRT)
				status = add_route(domain, &route);
			else
				status = remove_route(domain, &route);

			if (address != NULL)
				address->ReleaseReference();
			return status;
		}
	}
	return B_BAD_VALUE;
}


status_t
add_route(struct net_domain* _domain, const struct net_route* newRoute)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;

	TRACE("add route to domain %s: dest %s, mask %s, gw %s, flags %lx\n",
		domain->name,
		AddressString(domain, newRoute->destination
			? newRoute->destination : NULL).Data(),
		AddressString(domain, newRoute->mask ? newRoute->mask : NULL).Data(),
		AddressString(domain, newRoute->gateway
			? newRoute->gateway : NULL).Data(),
		newRoute->flags);

	if (domain == NULL || newRoute == NULL
		|| newRoute->interface_address == NULL
		|| ((newRoute->flags & RTF_HOST) != 0 && newRoute->mask != NULL)
		|| ((newRoute->flags & RTF_DEFAULT) == 0
			&& newRoute->destination == NULL)
		|| ((newRoute->flags & RTF_GATEWAY) != 0 && newRoute->gateway == NULL)
		|| !domain->address_module->check_mask(newRoute->mask))
		return B_BAD_VALUE;

	RecursiveLocker _(domain->lock);

	net_route_private* route = find_route(domain, newRoute);
	if (route != NULL)
		return B_FILE_EXISTS;

	route = new (std::nothrow) net_route_private;
	if (route == NULL)
		return B_NO_MEMORY;

	if (domain->address_module->copy_address(newRoute->destination,
			&route->destination, (newRoute->flags & RTF_DEFAULT) != 0,
			newRoute->mask) != B_OK
		|| domain->address_module->copy_address(newRoute->mask, &route->mask,
			(newRoute->flags & RTF_DEFAULT) != 0, NULL) != B_OK
		|| domain->address_module->copy_address(newRoute->gateway,
			&route->gateway, false, NULL) != B_OK) {
		delete route;
		return B_NO_MEMORY;
	}

	route->flags = newRoute->flags;
	route->interface_address = newRoute->interface_address;
	((InterfaceAddress*)route->interface_address)->AcquireReference();
	route->mtu = 0;
	route->ref_count = 1;

	// Insert the route sorted by completeness of its mask

	RouteList::Iterator iterator = domain->routes.GetIterator();
	net_route_private* before = NULL;

	while ((before = iterator.Next()) != NULL) {
		// if the before mask is less specific than the one of the route,
		// we can insert it before that route.
		if (domain->address_module->first_mask_bit(before->mask)
				> domain->address_module->first_mask_bit(route->mask))
			break;

		if ((route->flags & RTF_DEFAULT) != 0
			&& (before->flags & RTF_DEFAULT) != 0) {
			// both routes are equal - let the link speed decide the
			// order
			if (before->interface_address->interface->device->link_speed
					< route->interface_address->interface->device->link_speed)
				break;
		}
	}

	domain->routes.Insert(before, route);
	update_route_infos(domain);

	return B_OK;
}


status_t
remove_route(struct net_domain* _domain, const struct net_route* removeRoute)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;

	TRACE("remove route from domain %s: dest %s, mask %s, gw %s, flags %lx\n",
		domain->name,
		AddressString(domain, removeRoute->destination
			? removeRoute->destination : NULL).Data(),
		AddressString(domain, removeRoute->mask
			? removeRoute->mask : NULL).Data(),
		AddressString(domain, removeRoute->gateway
			? removeRoute->gateway : NULL).Data(),
		removeRoute->flags);

	RecursiveLocker locker(domain->lock);

	net_route_private* route = find_route(domain, removeRoute);
	if (route == NULL)
		return B_ENTRY_NOT_FOUND;

	domain->routes.Remove(route);

	put_route_internal(domain, route);
	update_route_infos(domain);

	return B_OK;
}


status_t
get_route_information(struct net_domain* _domain, void* value, size_t length)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;

	if (length < sizeof(route_entry))
		return B_BAD_VALUE;

	route_entry entry;
	if (user_memcpy(&entry, value, sizeof(route_entry)) < B_OK)
		return B_BAD_ADDRESS;

	sockaddr_storage destination;
	status_t status = user_copy_address(entry.destination, &destination);
	if (status != B_OK)
		return status;

	RecursiveLocker locker(domain->lock);

	net_route_private* route = find_route(domain, (sockaddr*)&destination);
	if (route == NULL)
		return B_ENTRY_NOT_FOUND;

	status = fill_route_entry(&entry, value, length, route);
	if (status != B_OK)
		return status;

	return user_memcpy(value, &entry, sizeof(route_entry));
}


void
invalidate_routes(net_domain* _domain, net_interface* interface)
{
	net_domain_private* domain = (net_domain_private*)_domain;
	RecursiveLocker locker(domain->lock);

	TRACE("invalidate_routes(%i, %s)\n", domain->family, interface->name);

	RouteList::Iterator iterator = domain->routes.GetIterator();
	while (iterator.HasNext()) {
		net_route* route = iterator.Next();

		if (route->interface_address->interface == interface)
			remove_route(domain, route);
	}
}


void
invalidate_routes(InterfaceAddress* address)
{
	net_domain_private* domain = (net_domain_private*)address->domain;

	TRACE("invalidate_routes(%s)\n",
		AddressString(domain, address->local).Data());

	RecursiveLocker locker(domain->lock);

	RouteList::Iterator iterator = domain->routes.GetIterator();
	while (iterator.HasNext()) {
		net_route* route = iterator.Next();

		if (route->interface_address == address)
			remove_route(domain, route);
	}
}


struct net_route*
get_route(struct net_domain* _domain, const struct sockaddr* address)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;
	RecursiveLocker locker(domain->lock);

	return get_route_internal(domain, address);
}


status_t
get_device_route(struct net_domain* domain, uint32 index, net_route** _route)
{
	Interface* interface = get_interface_for_device(domain, index);
	if (interface == NULL)
		return ENETUNREACH;

	net_route_private* route
		= &interface->DomainDatalink(domain->family)->direct_route;

	atomic_add(&route->ref_count, 1);
	*_route = route;

	interface->ReleaseReference();
	return B_OK;
}


status_t
get_buffer_route(net_domain* _domain, net_buffer* buffer, net_route** _route)
{
	net_domain_private* domain = (net_domain_private*)_domain;

	RecursiveLocker _(domain->lock);

	net_route* route = get_route_internal(domain, buffer->destination);
	if (route == NULL)
		return ENETUNREACH;

	status_t status = B_OK;
	sockaddr* source = buffer->source;

	// TODO: we are quite relaxed in the address checking here
	// as we might proceed with source = INADDR_ANY.

	if (route->interface_address != NULL
		&& route->interface_address->local != NULL) {
		status = domain->address_module->update_to(source,
			route->interface_address->local);
	}

	if (status != B_OK)
		put_route_internal(domain, route);
	else
		*_route = route;

	return status;
}


void
put_route(struct net_domain* _domain, net_route* route)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;
	if (domain == NULL || route == NULL)
		return;

	RecursiveLocker locker(domain->lock);

	put_route_internal(domain, (net_route*)route);
}


status_t
register_route_info(struct net_domain* _domain, struct net_route_info* info)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;
	RecursiveLocker locker(domain->lock);

	domain->route_infos.Add(info);
	info->route = get_route_internal(domain, &info->address);

	return B_OK;
}


status_t
unregister_route_info(struct net_domain* _domain, struct net_route_info* info)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;
	RecursiveLocker locker(domain->lock);

	domain->route_infos.Remove(info);
	if (info->route != NULL)
		put_route_internal(domain, info->route);

	return B_OK;
}


status_t
update_route_info(struct net_domain* _domain, struct net_route_info* info)
{
	struct net_domain_private* domain = (net_domain_private*)_domain;
	RecursiveLocker locker(domain->lock);

	put_route_internal(domain, info->route);
	info->route = get_route_internal(domain, &info->address);
	return B_OK;
}