/*
 * Copyright 2012 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *		Paweł Dziepak, pdziepak@quarnos.org
 */


#include <net/dns_resolver.h>

#include <AutoDeleter.h>
#include <FindDirectory.h>
#include <lock.h>
#include <port.h>
#include <team.h>
#include <util/AutoLock.h>

#include "Definitions.h"


static 	mutex		gPortLock;
static	port_id		gPortRequest		= -1;
static	port_id		gPortReply			= -1;

static	const int32	kQueueLength		= 1;


static status_t
dns_resolver_repair()
{
	status_t result = B_OK;

	gPortRequest = create_port(kQueueLength, kPortNameReq);
	if (gPortRequest < B_OK)
		return gPortRequest;

	gPortReply = create_port(kQueueLength, kPortNameRpl);
	if (gPortReply < B_OK) {
		delete_port(gPortRequest);
		return gPortReply;
	}

	char path[256];
	if (find_directory(B_SYSTEM_SERVERS_DIRECTORY, static_cast<dev_t>(-1),
		false, path, sizeof(path)) != B_OK) {
		delete_port(gPortReply);
		delete_port(gPortRequest);
		return B_NAME_NOT_FOUND;
	}
	strlcat(path, "/dns_resolver_server", sizeof(path));

	const char* args[] = { path, NULL };
	thread_id thread = load_image_etc(1, args, NULL, B_NORMAL_PRIORITY,
		B_SYSTEM_TEAM, 0);
	if (thread < B_OK) {
		delete_port(gPortReply);
		delete_port(gPortRequest);
		return thread;
	}

	set_port_owner(gPortRequest, thread);
	set_port_owner(gPortReply, thread);

	result = resume_thread(thread);
	if (result != B_OK) {
		kill_thread(thread);
		delete_port(gPortReply);
		delete_port(gPortRequest);
		return result;
	}

	return B_OK;
}


static status_t
dns_resolver_init()
{
	mutex_init(&gPortLock, NULL);
	return dns_resolver_repair();
}


static status_t
dns_resolver_uninit()
{
	delete_port(gPortRequest);
	delete_port(gPortReply);
	mutex_destroy(&gPortLock);

	return B_OK;
}


static void
RelocateEntries(struct addrinfo* addr)
{
	char* generalOffset = reinterpret_cast<char*>(addr);

	struct addrinfo* current = addr;
	while (current != NULL) {
		uint64 addrOffset = reinterpret_cast<uint64>(current->ai_addr);
		uint64 nameOffset = reinterpret_cast<uint64>(current->ai_canonname);
		uint64 nextOffset = reinterpret_cast<uint64>(current->ai_next);

		if (current->ai_addr != NULL) {
			current->ai_addr
				= reinterpret_cast<sockaddr*>(generalOffset + addrOffset);
		}

		if (current->ai_canonname != NULL)
			current->ai_canonname = generalOffset + nameOffset;

		if (current->ai_next != NULL) {
			current->ai_next
				= reinterpret_cast<addrinfo*>(generalOffset + nextOffset);
		}

		current = current->ai_next;
	}
}


static status_t
GetAddrInfo(const char* node, const char* service,
	const struct addrinfo* hints, struct addrinfo** res)
{
	uint32 nodeSize = node != NULL ? strlen(node) + 1 : 1;
	uint32 serviceSize = service != NULL ? strlen(service) + 1 : 1;
	uint32 size = nodeSize + serviceSize + sizeof(*hints);
	char* buffer = reinterpret_cast<char*>(malloc(size));
	if (buffer == NULL)
		return B_NO_MEMORY;
	MemoryDeleter _(buffer);

	off_t off = 0;
	if (node != NULL)
		strcpy(buffer + off, node);
	else
		buffer[off] = '\0';
	off += nodeSize;

	if (service != NULL)
		strcpy(buffer + off, service);
	else
		buffer[off] = '\0';
	off += serviceSize;

	if (hints != NULL)
		memcpy(buffer + off, hints, sizeof(*hints));
	else {
		struct addrinfo *nullHints
			= reinterpret_cast<struct addrinfo*>(buffer + off);
		memset(nullHints, 0, sizeof(*nullHints));
		nullHints->ai_family = AF_UNSPEC;
	}

	MutexLocker locker(gPortLock);
	do {
		status_t result = write_port(gPortRequest, MsgGetAddrInfo, buffer,
			size);
		if (result != B_OK) {
			result = dns_resolver_repair();
			if (result != B_OK)
				return result;
			continue;
		}

		ssize_t replySize = port_buffer_size(gPortReply);
		if (replySize < B_OK) {
			result = dns_resolver_repair();
			if (result != B_OK)
				return result;
			continue;
		}

		void* reply = malloc(replySize);
		if (reply == NULL)
			return B_NO_MEMORY;

		int32 code;
		replySize = read_port(gPortReply, &code, reply, replySize);
		if (replySize < B_OK) {
			free(reply);
			result = dns_resolver_repair();
			if (result != B_OK)
				return result;
			continue;
		}

		struct addrinfo* addr;
		switch (code) {
			case MsgReply:
				addr = reinterpret_cast<struct addrinfo*>(reply);
				RelocateEntries(addr);
				*res = addr;
				return B_OK;
			case MsgError:
				result = *reinterpret_cast<status_t*>(reply);
				free(reply);
				return result;
			default:
				free(reply);
				return B_BAD_VALUE;
		}

	} while (true);
}


static status_t
dns_resolver_std_ops(int32 op, ...)
{
	switch (op) {
		case B_MODULE_INIT:
			return dns_resolver_init();
		case B_MODULE_UNINIT:
			return dns_resolver_uninit();
		default:
			return B_ERROR;
	}
}


static dns_resolver_module sDNSResolverModule = {
	{
		DNS_RESOLVER_MODULE_NAME,
		0,
		dns_resolver_std_ops,
	},

	GetAddrInfo,
};

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