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


#include "IdMapper.h"

#include <grp.h>
#include <pwd.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>

#include <File.h>
#include <FindDirectory.h>
#include <OS.h>
#include <Path.h>


port_id		gRequestPort;
port_id		gReplyPort;

const char*	kNobodyName		= "nobody";
uid_t		gNobodyId;

const char*	kNogroupName	= "nobody";
uid_t		gNogroupId;

const char* gDomainName		= "localdomain";


status_t
SendError(status_t error)
{
	return write_port(gReplyPort, MsgError, &error, sizeof(error));
}


status_t
MatchDomain(char* name)
{
	char* domain = strchr(name, '@');
	if (domain == NULL)
		return B_MISMATCHED_VALUES;

	if (strcmp(domain + 1, gDomainName) != 0)
		return B_BAD_VALUE;

	*domain = '\0';

	return B_OK;
}


char*
AddDomain(const char* name)
{
	uint32 fullLength = strlen(name) + strlen(gDomainName) + 2;
	char* fullName = reinterpret_cast<char*>(malloc(fullLength));
	if (fullName == NULL)
		return NULL;

	strcpy(fullName, name);
	strcat(fullName, "@");
	strcat(fullName, gDomainName);

	return fullName;
}


status_t
NameToUID(void* buffer)
{
	char* userName = reinterpret_cast<char*>(buffer);

	struct passwd* userInfo = NULL;

	if (MatchDomain(userName) == B_OK)
		userInfo = getpwnam(userName);

	if (userInfo == NULL)
		return write_port(gReplyPort, MsgReply, &gNobodyId, sizeof(gNobodyId));

	return write_port(gReplyPort, MsgReply, &userInfo->pw_uid, sizeof(uid_t));
}


status_t
UIDToName(void* buffer)
{
	uid_t userId = *reinterpret_cast<uid_t*>(buffer);

	const char* name = NULL;

	struct passwd* userInfo = getpwuid(userId);
	if (userInfo != NULL) {
		name = userInfo->pw_name;
		name = AddDomain(name);
	}

	status_t result;

	if (name != NULL) {
		result = write_port(gReplyPort, MsgReply, name, strlen(name) + 1);
		free(const_cast<char*>(name));
	} else {
		result = write_port(gReplyPort, MsgReply, kNobodyName,
			strlen(kNobodyName) + 1);
	}

	return result;
}


status_t
NameToGID(void* buffer)
{
	char* groupName = reinterpret_cast<char*>(buffer);
	
	struct group* groupInfo = NULL;

	if (MatchDomain(groupName) == B_OK)
		groupInfo = getgrnam(groupName);

	if (groupInfo == NULL) {
		return write_port(gReplyPort, MsgReply, &gNogroupId,
			sizeof(gNogroupId));
	}

	return write_port(gReplyPort, MsgReply, &groupInfo->gr_gid, sizeof(gid_t));
}


status_t
GIDToName(void* buffer)
{
	gid_t groupId = *reinterpret_cast<gid_t*>(buffer);

	const char* name = NULL;

	struct group* groupInfo = getgrgid(groupId);
	if (groupInfo != NULL) {
		name = groupInfo->gr_name;
		name = AddDomain(name);
	}

	status_t result;

	if (name != NULL) {
		result = write_port(gReplyPort, MsgReply, name, strlen(name) + 1);
		free(const_cast<char*>(name));
	} else {
		result = write_port(gReplyPort, MsgReply, kNogroupName,
			strlen(kNogroupName) + 1);
	}

	return result;
}


status_t
ParseRequest(int32 code, void* buffer)
{
	switch (code) {
		case MsgNameToUID:
			return NameToUID(buffer);

		case MsgUIDToName:
			return UIDToName(buffer);

		case MsgNameToGID:
			return NameToGID(buffer);

		case MsgGIDToName:
			return GIDToName(buffer);

		default:
			return SendError(B_BAD_VALUE);
	}
}


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;

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

		status_t result = ParseRequest(code, buffer);
		free(buffer);

		if (result != B_OK)
			return 0;

	} while (true);
}


status_t
ReadSettings()
{
	BPath path;
	status_t result = find_directory(B_SYSTEM_SETTINGS_DIRECTORY, &path);
	if (result != B_OK)
		return result;
	result = path.Append("nfs4_idmapper.conf");
	if (result != B_OK)
		return result;

	BFile file(path.Path(), B_READ_ONLY);
	if (file.InitCheck() != B_OK)
		return file.InitCheck();

	off_t size;
	result = file.GetSize(&size);
	if (result != B_OK)
		return result;

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

	file.Read(buffer, size);

	gDomainName = reinterpret_cast<char*>(buffer);

	return B_OK;
}


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

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

	ReadSettings();

	struct passwd* userInfo = getpwnam(kNobodyName);
	if (userInfo != NULL)
		gNobodyId = userInfo->pw_uid;
	else
		gNobodyId = 0;

	struct group* groupInfo = getgrnam(kNogroupName);
	if (groupInfo != NULL)
		gNogroupId = groupInfo->gr_gid;
	else
		gNogroupId = 0;

	return MainLoop();
}