/*
 * Copyright 2008-2010, Ingo Weinhold, ingo_weinhold@gmx.de.
 * Distributed under the terms of the MIT License.
 */


#include <user_group.h>

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <new>

#include <errno_private.h>
#include <launch.h>
#include <libroot_private.h>
#include <locks.h>
#include <RegistrarDefs.h>

#include <util/KMessage.h>


using BPrivate::Tokenizer;


static const char* const kUserGroupLockName = "user group";

const char* BPrivate::kPasswdFile = "/etc/passwd";
const char* BPrivate::kGroupFile = "/etc/group";
const char* BPrivate::kShadowPwdFile = "/etc/shadow";

static mutex sUserGroupLock = MUTEX_INITIALIZER(kUserGroupLockName);
static port_id sRegistrarPort = -1;


status_t
BPrivate::user_group_lock()
{
        return mutex_lock(&sUserGroupLock);
}


status_t
BPrivate::user_group_unlock()
{
        mutex_unlock(&sUserGroupLock);
        return B_OK;
}


port_id
BPrivate::get_registrar_authentication_port()
{
        if (sRegistrarPort < 0) {
                BPrivate::KMessage data;
                if (BPrivate::get_launch_data(B_REGISTRAR_SIGNATURE, data)
                                == B_OK) {
                        sRegistrarPort = data.GetInt32(
                                B_REGISTRAR_AUTHENTICATION_PORT_NAME "_port", -1);
                }
        }
        return sRegistrarPort;
}


void
BPrivate::set_registrar_authentication_port(port_id port)
{
        sRegistrarPort = port;
}


status_t
BPrivate::send_authentication_request_to_registrar(KMessage& request,
        KMessage& reply)
{
        status_t error = request.SendTo(get_registrar_authentication_port(), 0,
                &reply);
        if (error != B_OK)
                return error;

        return (status_t)reply.What();
}


class BPrivate::Tokenizer {
public:
        Tokenizer(char* string)
                : fString(string)
        {
        }

        char* NextToken(char separator)
        {
                if (fString == NULL)
                        return NULL;

                char* token = fString;
                fString = strchr(fString, separator);
                if (fString != NULL) {
                        *fString = '\0';
                        fString++;
                }

                return token;
        }

        char* NextTrimmedToken(char separator)
        {
                char* token = NextToken(separator);
                if (token == NULL)
                        return NULL;

                // skip spaces at the beginning
                while (*token != '\0' && isspace(*token))
                        token++;

                // cut off spaces at the end
                char* end = token + strlen(token);
                while (end != token && isspace(end[-1]))
                        end--;
                *end = '\0';

                return token;
        }

private:
        char*           fString;
};


static char*
buffer_dup_string(const char* string, char*& buffer, size_t& bufferLen)
{
        if (string == NULL)
                return NULL;

        size_t size = strlen(string) + 1;
        if (size > bufferLen)
                return NULL;

        strcpy(buffer, string);
        char* result = buffer;
        buffer += size;
        bufferLen -= size;

        return result;
}


static void*
buffer_allocate(size_t size, size_t align, char*& buffer, size_t& bufferSize)
{
        // align padding
        addr_t pad = align - (((addr_t)buffer - 1)  & (align - 1)) - 1;
        if (pad + size > bufferSize)
                return NULL;

        char* result = buffer + pad;
        buffer = result + size;
        bufferSize -= pad + size;

        return result;
}


// #pragma mark - passwd support


status_t
BPrivate::copy_passwd_to_buffer(const char* name, const char* password,
        uid_t uid, gid_t gid, const char* home, const char* shell,
        const char* realName, passwd* entry, char* buffer, size_t bufferSize)
{
        entry->pw_uid = uid;
        entry->pw_gid = gid;

        entry->pw_name = buffer_dup_string(name, buffer, bufferSize);
        entry->pw_passwd = buffer_dup_string(password, buffer, bufferSize);
        entry->pw_dir = buffer_dup_string(home, buffer, bufferSize);
        entry->pw_shell = buffer_dup_string(shell, buffer, bufferSize);
        entry->pw_gecos = buffer_dup_string(realName, buffer, bufferSize);

        if (entry->pw_name && entry->pw_passwd && entry->pw_dir
                        && entry->pw_shell && entry->pw_gecos) {
                return 0;
        }

        return ERANGE;
}


status_t
BPrivate::copy_passwd_to_buffer(const passwd* from, passwd* entry, char* buffer,
        size_t bufferSize)
{
        return copy_passwd_to_buffer(from->pw_name, from->pw_passwd, from->pw_uid,
                from->pw_gid, from->pw_dir, from->pw_shell, from->pw_gecos, entry,
                buffer, bufferSize);
}


status_t
BPrivate::parse_passwd_line(char* line, char*& name, char*& password,
        uid_t& uid, gid_t& gid, char*& home, char*& shell, char*& realName)
{
        Tokenizer tokenizer(line);

        name = tokenizer.NextTrimmedToken(':');
        password = tokenizer.NextTrimmedToken(':');
        char* userID = tokenizer.NextTrimmedToken(':');
        char* groupID = tokenizer.NextTrimmedToken(':');
        realName = tokenizer.NextTrimmedToken(':');
        home = tokenizer.NextTrimmedToken(':');
        shell = tokenizer.NextTrimmedToken(':');

        // skip if invalid
        size_t nameLen;
        if (shell == NULL || (nameLen = strlen(name)) == 0
                        || !isdigit(*userID) || !isdigit(*groupID)
                || nameLen >= MAX_PASSWD_NAME_LEN
                || strlen(password) >= MAX_PASSWD_PASSWORD_LEN
                || strlen(realName) >= MAX_PASSWD_REAL_NAME_LEN
                || strlen(home) >= MAX_PASSWD_HOME_DIR_LEN
                || strlen(shell) >= MAX_PASSWD_SHELL_LEN) {
                return B_BAD_VALUE;
        }

        uid = atoi(userID);
        gid = atoi(groupID);

        return B_OK;
}


// #pragma mark - group support


status_t
BPrivate::copy_group_to_buffer(const char* name, const char* password,
        gid_t gid, const char* const* members, int memberCount, group* entry,
        char* buffer, size_t bufferSize)
{
        entry->gr_gid = gid;

        // allocate member array (do that first for alignment reasons)
        entry->gr_mem = (char**)buffer_allocate(sizeof(char*) * (memberCount + 1),
                sizeof(char*), buffer, bufferSize);
        if (entry->gr_mem == NULL)
                return ERANGE;

        // copy name and password
        entry->gr_name = buffer_dup_string(name, buffer, bufferSize);
        entry->gr_passwd = buffer_dup_string(password, buffer, bufferSize);
        if (entry->gr_name == NULL || entry->gr_passwd == NULL)
                return ERANGE;

        // copy member array
        for (int i = 0; i < memberCount; i++) {
                entry->gr_mem[i] = buffer_dup_string(members[i], buffer, bufferSize);
                if (entry->gr_mem[i] == NULL)
                        return ERANGE;
        }
        entry->gr_mem[memberCount] = NULL;

        return 0;
}


status_t
BPrivate::copy_group_to_buffer(const group* from, group* entry, char* buffer,
        size_t bufferSize)
{
        int memberCount = 0;
        while (from->gr_mem[memberCount] != NULL)
                memberCount++;

        return copy_group_to_buffer(from->gr_name, from->gr_passwd,
                from->gr_gid, from->gr_mem, memberCount, entry, buffer, bufferSize);
}


status_t
BPrivate::parse_group_line(char* line, char*& name, char*& password, gid_t& gid,
        char** members, int& memberCount)
{
        Tokenizer tokenizer(line);

        name = tokenizer.NextTrimmedToken(':');
        password = tokenizer.NextTrimmedToken(':');
        char* groupID = tokenizer.NextTrimmedToken(':');

        // skip if invalid
        size_t nameLen;
        if (groupID == NULL || (nameLen = strlen(name)) == 0 || !isdigit(*groupID)
                || nameLen >= MAX_GROUP_NAME_LEN
                || strlen(password) >= MAX_GROUP_PASSWORD_LEN) {
                return B_BAD_VALUE;
        }

        gid = atol(groupID);

        memberCount = 0;

        while (char* groupUser = tokenizer.NextTrimmedToken(',')) {
                // ignore invalid members
                if (*groupUser == '\0' || strlen(groupUser) >= MAX_PASSWD_NAME_LEN)
                        continue;

                members[memberCount++] = groupUser;

                // ignore excess members
                if (memberCount == MAX_GROUP_MEMBER_COUNT)
                        break;
        }

        return B_OK;
}


// #pragma mark - shadow password support


status_t
BPrivate::copy_shadow_pwd_to_buffer(const char* name, const char* password,
        int lastChanged, int min, int max, int warn, int inactive, int expiration,
        int flags, spwd* entry, char* buffer, size_t bufferSize)
{
        entry->sp_lstchg = lastChanged;
        entry->sp_min = min;
        entry->sp_max = max;
        entry->sp_warn = warn;
        entry->sp_inact = inactive;
        entry->sp_expire = expiration;
        entry->sp_flag = flags;

        entry->sp_namp = buffer_dup_string(name, buffer, bufferSize);
        entry->sp_pwdp = buffer_dup_string(password, buffer, bufferSize);

        if (entry->sp_namp && entry->sp_pwdp)
                return 0;

        return ERANGE;
}


status_t
BPrivate::copy_shadow_pwd_to_buffer(const spwd* from, spwd* entry,
        char* buffer, size_t bufferSize)
{
        return copy_shadow_pwd_to_buffer(from->sp_namp, from->sp_pwdp,
                from->sp_lstchg, from->sp_min, from->sp_max, from->sp_warn,
                from->sp_inact, from->sp_expire, from->sp_flag, entry, buffer,
                bufferSize);
}


status_t
BPrivate::parse_shadow_pwd_line(char* line, char*& name, char*& password,
        int& lastChanged, int& min, int& max, int& warn, int& inactive,
        int& expiration, int& flags)
{
        Tokenizer tokenizer(line);

        name = tokenizer.NextTrimmedToken(':');
        password = tokenizer.NextTrimmedToken(':');
        char* lastChangedString = tokenizer.NextTrimmedToken(':');
        char* minString = tokenizer.NextTrimmedToken(':');
        char* maxString = tokenizer.NextTrimmedToken(':');
        char* warnString = tokenizer.NextTrimmedToken(':');
        char* inactiveString = tokenizer.NextTrimmedToken(':');
        char* expirationString = tokenizer.NextTrimmedToken(':');
        char* flagsString = tokenizer.NextTrimmedToken(':');

        // skip if invalid
        size_t nameLen;
        if (flagsString == NULL || (nameLen = strlen(name)) == 0
                || nameLen >= MAX_SHADOW_PWD_NAME_LEN
                || strlen(password) >= MAX_SHADOW_PWD_PASSWORD_LEN) {
                return B_BAD_VALUE;
        }

        lastChanged = atoi(lastChangedString);
        min = minString[0] != '\0' ? atoi(minString) : -1;
        max = maxString[0] != '\0' ? atoi(maxString) : -1;
        warn = warnString[0] != '\0' ? atoi(warnString) : -1;
        inactive = inactiveString[0] != '\0' ? atoi(inactiveString) : -1;
        expiration = expirationString[0] != '\0' ? atoi(expirationString) : -1;
        flags = atoi(flagsString);

        return B_OK;
}


// #pragma mark -


void
__init_pwd_backend(void)
{
}


void
__reinit_pwd_backend_after_fork(void)
{
        mutex_init(&sUserGroupLock, kUserGroupLockName);
}