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

#include <shadow.h>

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

#include <new>

#include <OS.h>

#include <AutoDeleter.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 sShadowPwdDBReply;
static spwd** sShadowPwdEntries = NULL;
static size_t sShadowPwdEntryCount = 0;
static size_t sIterationIndex = 0;

static struct spwd sShadowPwdBuffer;
static char sShadowPwdStringBuffer[MAX_SHADOW_PWD_BUFFER_SIZE];


static status_t
init_shadow_pwd_db()
{
        if (sShadowPwdEntries != NULL)
                return B_OK;

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

        // unpack the reply
        int32 count;
        spwd** entries;
        int32 numBytes;
        if ((error = sShadowPwdDBReply.FindInt32("count", &count)) != B_OK
                || (error = sShadowPwdDBReply.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++) {
                spwd* entry = relocate_pointer(baseAddress, entries[i]);
                relocate_pointer(baseAddress, entry->sp_namp);
                relocate_pointer(baseAddress, entry->sp_pwdp);
        }

        sShadowPwdEntries = entries;
        sShadowPwdEntryCount = count;

        return B_OK;
}


// #pragma mark -


struct spwd*
getspent(void)
{
        struct spwd* result = NULL;
        int status = getspent_r(&sShadowPwdBuffer, sShadowPwdStringBuffer,
                sizeof(sShadowPwdStringBuffer), &result);
        if (status != 0)
                __set_errno(status);
        return result;
}


int
getspent_r(struct spwd* spwd, char* buffer, size_t bufferSize,
        struct spwd** _result)
{
        UserGroupLocker _;

        int status = B_NO_MEMORY;

        *_result = NULL;

        if ((status = init_shadow_pwd_db()) == B_OK) {
                if (sIterationIndex >= sShadowPwdEntryCount)
                        return ENOENT;

                status = BPrivate::copy_shadow_pwd_to_buffer(
                        sShadowPwdEntries[sIterationIndex], spwd, buffer, bufferSize);

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

        return status;
}


void
setspent(void)
{
        UserGroupLocker _;

        sIterationIndex = 0;
}


void
endspent(void)
{
        UserGroupLocker locker;

        sShadowPwdDBReply.Unset();
        sShadowPwdEntries = NULL;
        sShadowPwdEntryCount = 0;
        sIterationIndex = 0;
}


struct spwd *
getspnam(const char *name)
{
        struct spwd* result = NULL;
        int status = getspnam_r(name, &sShadowPwdBuffer, sShadowPwdStringBuffer,
                sizeof(sShadowPwdStringBuffer), &result);
        if (status != 0)
                __set_errno(status);
        return result;
}


int
getspnam_r(const char *name, struct spwd *spwd, char *buffer,
        size_t bufferSize, struct spwd **_result)
{
        *_result = NULL;

        KMessage message(BPrivate::B_REG_GET_USER);
        message.AddString("name", name);
        message.AddBool("shadow", true);

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

        const char* password;
        int32 lastChanged;
        int32 min;
        int32 max;
        int32 warn;
        int32 inactive;
        int32 expiration;
        int32 flags;

        if ((error = reply.FindString("name", &name)) != B_OK
                || (error = reply.FindString("shadow password", &password)) != B_OK
                || (error = reply.FindInt32("last changed", &lastChanged)) != B_OK
                || (error = reply.FindInt32("min", &min)) != B_OK
                || (error = reply.FindInt32("max", &max)) != B_OK
                || (error = reply.FindInt32("warn", &warn)) != B_OK
                || (error = reply.FindInt32("inactive", &inactive)) != B_OK
                || (error = reply.FindInt32("expiration", &expiration)) != B_OK
                || (error = reply.FindInt32("flags", &flags)) != B_OK) {
                return error;
        }

        error = BPrivate::copy_shadow_pwd_to_buffer(name, password, lastChanged,
                min, max, warn, inactive, expiration, flags, spwd, buffer, bufferSize);
        if (error == B_OK)
                *_result = spwd;

        return error;
}


struct spwd*
sgetspent(const char* line)
{
        struct spwd* result = NULL;
        int status = sgetspent_r(line, &sShadowPwdBuffer, sShadowPwdStringBuffer,
                sizeof(sShadowPwdStringBuffer), &result);
        if (status != 0)
                __set_errno(status);
        return result;
}


int
sgetspent_r(const char* _line, struct spwd *spwd, char *buffer,
        size_t bufferSize, struct spwd** _result)
{
        *_result = NULL;

        if (_line == NULL)
                return B_BAD_VALUE;

        // we need a mutable copy of the line
        char* line = strdup(_line);
        if (line == NULL)
                return B_NO_MEMORY;
        MemoryDeleter _(line);

        char* name;
        char* password;
        int lastChanged;
        int min;
        int max;
        int warn;
        int inactive;
        int expiration;
        int flags;

        status_t status = BPrivate::parse_shadow_pwd_line(line, name, password,
                lastChanged, min, max, warn, inactive, expiration, flags);
        if (status != B_OK)
                return status;

        status = BPrivate::copy_shadow_pwd_to_buffer(name, password, lastChanged,
                min, max, warn, inactive, expiration, flags, spwd, buffer, bufferSize);
        if (status != B_OK)
                return status;

        *_result = spwd;
        return 0;
}


struct spwd*
fgetspent(FILE* file)
{
        struct spwd* result = NULL;
        int status = fgetspent_r(file, &sShadowPwdBuffer, sShadowPwdStringBuffer,
                sizeof(sShadowPwdStringBuffer), &result);
        if (status != 0)
                __set_errno(status);
        return result;
}


int
fgetspent_r(FILE* file, struct spwd* spwd, char* buffer, size_t bufferSize,
        struct spwd** _result)
{
        *_result = NULL;

        // read a line
        char lineBuffer[LINE_MAX + 1];
        __set_errno(0);
        char* line = fgets(lineBuffer, sizeof(lineBuffer), file);
        if (line == NULL) {
                if (errno != 0)
                        return errno;
                return ENOENT;
        }

        return sgetspent_r(line, spwd, buffer, bufferSize, _result);
}