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


#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/socket.h>
#include <netdb.h>

#include <AutoDeleter.h>
#include <OS.h>
#include <SupportDefs.h>

#include "Definitions.h"


port_id		gRequestPort;
port_id		gReplyPort;


status_t
Serialize(char** _reply, uint32* _totalSize, const struct addrinfo* ai)
{
	uint32 addrsSize = ai == NULL ? 0 : sizeof(addrinfo);
	uint32 namesSize = 0;
	uint32 socksSize = 0;

	const struct addrinfo* current = ai;
	while (current != NULL) {
		if (current->ai_canonname != NULL)
			namesSize += strlen(current->ai_canonname) + 1;
		if (current->ai_addr != NULL) {
			if (current->ai_family == AF_INET)
				socksSize += sizeof(sockaddr_in);
			else
				socksSize += sizeof(sockaddr_in6);
		}
		if (current->ai_next != NULL)
			addrsSize += sizeof(addrinfo);
		current = current->ai_next;
	}

	uint32 totalSize = addrsSize + namesSize + socksSize;
	char* reply = reinterpret_cast<char*>(malloc(totalSize));
	if (reply == NULL)
		return B_NO_MEMORY;

	uint32 addrPos = 0;
	uint32 namePos = addrsSize;
	uint32 sockPos = addrsSize + namesSize;

	struct addrinfo temp;

	current = ai;
	while (current != NULL) {
		memcpy(&temp, current, sizeof(addrinfo));

		if (current->ai_canonname != NULL) {
			strcpy(reply + namePos, current->ai_canonname);
			uint32 nSize = strlen(current->ai_canonname) + 1;
			temp.ai_canonname = reinterpret_cast<char*>(namePos);
			namePos += nSize;
		}
		if (current->ai_addr != NULL) {
			if (current->ai_family == AF_INET) {
				memcpy(reply + sockPos, current->ai_addr, sizeof(sockaddr_in));
				temp.ai_addr = reinterpret_cast<sockaddr*>(sockPos);
				sockPos += sizeof(sockaddr_in);
			} else {
				memcpy(reply + sockPos, current->ai_addr, sizeof(sockaddr_in6));
				temp.ai_addr = reinterpret_cast<sockaddr*>(sockPos);
				sockPos += sizeof(sockaddr_in6);
			}
		}

		addrinfo* next = current->ai_next;
		if (next != NULL)
			temp.ai_next = reinterpret_cast<addrinfo*>(addrPos) + 1;
		else
			temp.ai_next = NULL;

		memcpy(reply + addrPos, &temp, sizeof(addrinfo));
		addrPos += sizeof(addrinfo);

		current = next;
	}

	*_reply = reply;
	*_totalSize = totalSize;
	return B_OK;
}


status_t
GetAddrInfo(const char* buffer)
{
	const char* node = buffer[0] == '\0' ? NULL : buffer;
	uint32 nodeSize = node != NULL ? strlen(node) + 1 : 1;

	const char* service = buffer[nodeSize] == '\0' ? NULL : buffer + nodeSize;
	uint32 serviceSize = service != NULL ? strlen(service) + 1 : 1;

	const struct addrinfo* hints
		= reinterpret_cast<const addrinfo*>(buffer + nodeSize + serviceSize);

	struct addrinfo* ai;
	status_t result = getaddrinfo(node, service, hints, &ai);
	if (result != B_OK)
		return write_port(gReplyPort, MsgError, &result, sizeof(result));

	uint32 totalSize;
	char* reply;
	result = Serialize(&reply, &totalSize, ai);
	freeaddrinfo(ai);
	if (result != B_OK)
		return write_port(gReplyPort, MsgError, &result, sizeof(result));
	result = write_port(gReplyPort, MsgReply, reply, totalSize);
	free(reply);
	return result;
}


status_t
MainLoop()
{
	do {
		ssize_t size = port_buffer_size(gRequestPort);
		if (size < B_OK)
			return 0;

		void* buffer = malloc(size);
		if (buffer == NULL)
			return B_NO_MEMORY;
		MemoryDeleter _(buffer);

		int32 code;
		size = read_port(gRequestPort, &code, buffer, size);
		if (size < B_OK)
			return 0;

		status_t result;
		switch (code) {
			case MsgGetAddrInfo:
				result = GetAddrInfo(reinterpret_cast<char*>(buffer));
				break;

			default:
				result = B_BAD_VALUE;
				write_port(gReplyPort, MsgError, &result, sizeof(result));
				result = B_OK;
		}

		if (result != B_OK)
			return 0;
	} while (true);
}


int
main(int argc, char** argv)
{
	gRequestPort = find_port(kPortNameReq);
	if (gRequestPort < B_OK) {
		fprintf(stderr, "%s\n", strerror(gRequestPort));
		return gRequestPort;
	}

	gReplyPort = find_port(kPortNameRpl);
	if (gReplyPort < B_OK) {
		fprintf(stderr, "%s\n", strerror(gReplyPort));
		return gReplyPort;
	}

	return MainLoop();
}