haiku.git

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

#include <grp.h>

#include <errno.h>
#include <string.h>
#include <unistd.h>

#include <new>

#include <OS.h>

#include <errno_private.h>
#include <libroot_private.h>
#include <RegistrarDefs.h>
#include <user_group.h>

#include <util/KMessage.h>


using BPrivate::UserGroupLocker;
using BPrivate::relocate_pointer;


static KMessage sGroupDBReply;
static group** sGroupEntries = NULL;
static size_t sGroupEntryCount = 0;
static size_t sIterationIndex = 0;

static struct group sGroupBuffer;
static char sGroupStringBuffer[MAX_GROUP_BUFFER_SIZE];


static status_t
query_group_entry(const char* name, gid_t _gid, struct group *group,
	char *buffer, size_t bufferSize, struct group **_result)
{
	*_result = NULL;

	KMessage message(BPrivate::B_REG_GET_GROUP);
	if (name)
		message.AddString("name", name);
	else
		message.AddInt32("gid", _gid);

	KMessage reply;
	status_t error = BPrivate::send_authentication_request_to_registrar(message,
		reply);
	if (error != B_OK) {
		return error == ENOENT ? B_OK : error;
	}

	int32 gid;
	const char* password;

	if ((error = reply.FindInt32("gid", &gid)) != B_OK
		|| (error = reply.FindString("name", &name)) != B_OK
		|| (error = reply.FindString("password", &password)) != B_OK) {
		return error;
	}

	const char* members[MAX_GROUP_MEMBER_COUNT];
	int memberCount = 0;
	for (int32 index = 0; memberCount < MAX_GROUP_MEMBER_COUNT; index++) {
		if (reply.FindString("members", index, members + memberCount) != B_OK)
			break;
		memberCount++;
	}

	error = BPrivate::copy_group_to_buffer(name, password, gid, members,
		memberCount, group, buffer, bufferSize);
	if (error == B_OK)
		*_result = group;

	return error;
}


static status_t
init_group_db()
{
	if (sGroupEntries != NULL)
		return B_OK;

	// ask the registrar
	KMessage message(BPrivate::B_REG_GET_GROUP_DB);
	status_t error = BPrivate::send_authentication_request_to_registrar(message,
		sGroupDBReply);
	if (error != B_OK)
		return error;

	// unpack the reply
	int32 count;
	group** entries;
	int32 numBytes;
	if ((error = sGroupDBReply.FindInt32("count", &count)) != B_OK
		|| (error = sGroupDBReply.FindData("entries", B_RAW_TYPE,
				(const void**)&entries, &numBytes)) != B_OK) {
		return error;
	}

	// relocate the entries
	addr_t baseAddress = (addr_t)entries;
	for (int32 i = 0; i < count; i++) {
		group* entry = relocate_pointer(baseAddress, entries[i]);
		relocate_pointer(baseAddress, entry->gr_name);
		relocate_pointer(baseAddress, entry->gr_passwd);
		relocate_pointer(baseAddress, entry->gr_mem);
		int32 k = 0;
		for (; entry->gr_mem[k] != (void*)-1; k++)
			relocate_pointer(baseAddress, entry->gr_mem[k]);
		entry->gr_mem[k] = NULL;
	}

	sGroupEntries = entries;
	sGroupEntryCount = count;

	return B_OK;
}


// #pragma mark -


struct group*
getgrent(void)
{
	struct group* result = NULL;
	int status = getgrent_r(&sGroupBuffer, sGroupStringBuffer,
		sizeof(sGroupStringBuffer), &result);
	if (status != 0)
		__set_errno(status);
	return result;
}


int
getgrent_r(struct group* group, char* buffer, size_t bufferSize,
	struct group** _result)
{
	UserGroupLocker _;

	int status = B_NO_MEMORY;

	*_result = NULL;

	if ((status = init_group_db()) == B_OK) {
		if (sIterationIndex >= sGroupEntryCount)
			return ENOENT;

		status = BPrivate::copy_group_to_buffer(
			sGroupEntries[sIterationIndex], group, buffer, bufferSize);

		if (status == B_OK) {
			sIterationIndex++;
			*_result = group;
		}
	}

	return status;
}


void
setgrent(void)
{
	UserGroupLocker _;

	sIterationIndex = 0;
}


void
endgrent(void)
{
	UserGroupLocker locker;

	sGroupDBReply.Unset();
	sGroupEntries = NULL;
	sGroupEntryCount = 0;
	sIterationIndex = 0;
}


struct group *
getgrnam(const char *name)
{
	struct group* result = NULL;
	int status = getgrnam_r(name, &sGroupBuffer, sGroupStringBuffer,
		sizeof(sGroupStringBuffer), &result);
	if (status != 0)
		__set_errno(status);
	return result;
}


int
getgrnam_r(const char *name, struct group *group, char *buffer,
	size_t bufferSize, struct group **_result)
{
	return query_group_entry(name, 0, group, buffer, bufferSize, _result);
}


struct group *
getgrgid(gid_t gid)
{
	struct group* result = NULL;
	int status = getgrgid_r(gid, &sGroupBuffer, sGroupStringBuffer,
		sizeof(sGroupStringBuffer), &result);
	if (status != 0)
		__set_errno(status);
	return result;
}


int
getgrgid_r(gid_t gid, struct group *group, char *buffer,
	size_t bufferSize, struct group **_result)
{
	return query_group_entry(NULL, gid, group, buffer, bufferSize, _result);
}


int
getgrouplist(const char* user, gid_t baseGroup, gid_t* groupList,
	int* groupCount)
{
	int maxGroupCount = *groupCount;
	*groupCount = 0;

	status_t error = B_OK;

	// prepare request
	KMessage message(BPrivate::B_REG_GET_USER_GROUPS);
	if (message.AddString("name", user) != B_OK
		|| message.AddInt32("max count", maxGroupCount) != B_OK) {
		return -1;
	}

	// send request
	KMessage reply;
	error = BPrivate::send_authentication_request_to_registrar(message, reply);
	if (error != B_OK)
		return -1;

	// unpack reply
	int32 count;
	const int32* groups;
	int32 groupsSize;
	if (reply.FindInt32("count", &count) != B_OK
		|| reply.FindData("groups", B_INT32_TYPE, (const void**)&groups,
				&groupsSize) != B_OK) {
		return -1;
	}

	memcpy(groupList, groups, groupsSize);
	*groupCount = count;

	// add the base group
	if (*groupCount < maxGroupCount)
		groupList[*groupCount] = baseGroup;
	++*groupCount;

	return *groupCount <= maxGroupCount ? *groupCount : -1;
}


int
initgroups(const char* user, gid_t baseGroup)
{
	gid_t groups[NGROUPS_MAX + 1];
	int groupCount = NGROUPS_MAX + 1;
	if (getgrouplist(user, baseGroup, groups, &groupCount) < 0)
		return -1;

	return setgroups(groupCount, groups);
}