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

#include <pwd.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 sPasswdDBReply;
static passwd** sPasswdEntries = NULL;
static size_t sPasswdEntryCount = 0;
static size_t sIterationIndex = 0;

static struct passwd sPasswdBuffer;
static char sPasswdStringBuffer[MAX_PASSWD_BUFFER_SIZE];


static status_t
query_passwd_entry(const char* name, uid_t _uid, struct passwd *passwd,
        char *buffer, size_t bufferSize, struct passwd **_result)
{
        *_result = NULL;

        KMessage message(BPrivate::B_REG_GET_USER);
        if (name)
                message.AddString("name", name);
        else
                message.AddInt32("uid", _uid);

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

        int32 uid;
        int32 gid;
        const char* password;
        const char* home;
        const char* shell;
        const char* realName;

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

        error = BPrivate::copy_passwd_to_buffer(name, password, uid, gid, home,
                shell, realName, passwd, buffer, bufferSize);
        if (error == B_OK)
                *_result = passwd;

        return error;
}


static status_t
init_passwd_db()
{
        if (sPasswdEntries != NULL)
                return B_OK;

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

        // unpack the reply
        int32 count;
        passwd** entries;
        int32 numBytes;
        if ((error = sPasswdDBReply.FindInt32("count", &count)) != B_OK
                || (error = sPasswdDBReply.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++) {
                passwd* entry = relocate_pointer(baseAddress, entries[i]);
                relocate_pointer(baseAddress, entry->pw_name);
                relocate_pointer(baseAddress, entry->pw_passwd);
                relocate_pointer(baseAddress, entry->pw_dir);
                relocate_pointer(baseAddress, entry->pw_shell);
                relocate_pointer(baseAddress, entry->pw_gecos);
        }

        sPasswdEntries = entries;
        sPasswdEntryCount = count;

        return B_OK;
}


// #pragma mark -


struct passwd*
getpwent(void)
{
        struct passwd* result = NULL;
        int status = getpwent_r(&sPasswdBuffer, sPasswdStringBuffer,
                sizeof(sPasswdStringBuffer), &result);
        if (status != 0)
                __set_errno(status);
        return result;
}


int
getpwent_r(struct passwd* passwd, char* buffer, size_t bufferSize,
        struct passwd** _result)
{
        UserGroupLocker _;

        int status = B_NO_MEMORY;

        *_result = NULL;

        if ((status = init_passwd_db()) == B_OK) {
                if (sIterationIndex >= sPasswdEntryCount)
                        return ENOENT;

                status = BPrivate::copy_passwd_to_buffer(
                        sPasswdEntries[sIterationIndex], passwd, buffer, bufferSize);

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

        return status;
}


void
setpwent(void)
{
        UserGroupLocker _;

        sIterationIndex = 0;
}


void
endpwent(void)
{
        UserGroupLocker locker;

        sPasswdDBReply.Unset();
        sPasswdEntries = NULL;
        sPasswdEntryCount = 0;
        sIterationIndex = 0;
}


struct passwd *
getpwnam(const char *name)
{
        struct passwd* result = NULL;
        int status = getpwnam_r(name, &sPasswdBuffer, sPasswdStringBuffer,
                sizeof(sPasswdStringBuffer), &result);
        if (status != 0)
                __set_errno(status);
        return result;
}


int
getpwnam_r(const char *name, struct passwd *passwd, char *buffer,
        size_t bufferSize, struct passwd **_result)
{
        return query_passwd_entry(name, 0, passwd, buffer, bufferSize, _result);
}


struct passwd *
getpwuid(uid_t uid)
{
        struct passwd* result = NULL;
        int status = getpwuid_r(uid, &sPasswdBuffer, sPasswdStringBuffer,
                sizeof(sPasswdStringBuffer), &result);
        if (status != 0)
                __set_errno(status);
        return result;
}


int
getpwuid_r(uid_t uid, struct passwd *passwd, char *buffer,
        size_t bufferSize, struct passwd **_result)
{
        return query_passwd_entry(NULL, uid, passwd, buffer, bufferSize, _result);
}