/**
 * Copyright (c) 2013 Larisa Grigore<larisagrigore@gmail.com>.
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 * 3. The name of the author may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "namespace.h"
#include <sys/param.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <sys/ioctl.h>
#include <pthread.h>
#include <stdlib.h>
#include <unistd.h>
#include <fcntl.h>
#include "un-namespace.h"

#include <stdio.h>

#include "sysvipc_ipc.h"
#include "sysvipc_sockets.h"
#include "sysvipc_sem.h"
#include "sysvipc_shm.h"
#include "sysvipc_hash.h"
#include "sysvipc_lock.h"
#include "sysvipc_lock_generic.h"

#define SYSV_MUTEX_LOCK(x)      if (__isthreaded) _pthread_mutex_lock(x)
#define SYSV_MUTEX_UNLOCK(x)    if (__isthreaded) _pthread_mutex_unlock(x)
#define SYSV_MUTEX_DESTROY(x)   if (__isthreaded) _pthread_mutex_destroy(x)

int daemon_fd = -1;

extern pthread_mutex_t lock_resources;
//extern pthread_rwlock_t rwlock_addrs;
extern pthread_mutex_t lock_undo;
extern struct hashtable *shmaddrs;

/* Send the type of the message followed by data. */
int
send_message(int fd, int type, char *data, int size)
{
        _write(fd, &type, sizeof(type));
        return (send_msg_with_cred(fd, data, size));
}

/* Receive the type of the message that will follow. */
int
receive_type_message(int fd)
{
        int type;
        int r = _read(fd, &type, sizeof(type));
        return (r == 0 ? 0 : type);
}

/* Receive data. */
int
receive_message(int fd, char *data, int size)
{
        _read(fd, data, size);
        return (0);
}

int
is_sysvinit(void)
{
        return (daemon_fd == -1 ? 0:1);
}

static int
register_to_daemon(void)
{
        int flags;
        char test = 't';

        daemon_fd = connect_to_daemon(LISTEN_SOCKET_FILE);

        flags = _fcntl(daemon_fd, F_GETFD, 0);
        if (_fcntl(daemon_fd, F_SETFD, flags & FD_CLOEXEC) == -1) {
                sysv_print_err("fcntl error\n");
                return (-1);
        }

        /* Send a message such that daemon can obtain process credentials.*/
        send_msg_with_cred(daemon_fd, &test, sizeof(test));

        sysv_print("register to daemon: sock fd = %d\n", daemon_fd);

        return (0);
}

/* Used in fork case, to avoid deadlocks.
 * The fork caller acquires all locks before fork and release them
 * after because the child will have only a thread. If one lock is
 * taken by another thread than, in the child process, nobody will
 * release it.
 */
static void
acquire_locks(void)
{
        struct entries_list *list;
        struct hashentry *tmp;
        struct shm_data *data;
        struct semid_pool *semaptr;
        int i;

        SYSV_MUTEX_LOCK(&lock_undo);
        SYSV_MUTEX_LOCK(&lock_resources);
        //pthread_rwlock_wrlock(&rwlock_addrs);

        for (i=0; i<get_hash_size(MAXSIZE); i++) {
                list = &shmaddrs->entries[i];
                if (LIST_EMPTY(list))
                        continue;
                LIST_FOREACH(tmp, list, entry_link) {
                        data = (struct shm_data*)tmp->value;
                        if (data->type == SEMGET) {
                                semaptr = (struct semid_pool *)data->internal;
#ifdef SYSV_RWLOCK
#ifdef SYSV_SEMS
                                /* There is no need to acquire the mutexes from
                                 * each semaphore in the group. It is enough
                                 * to acquire the group lock in write mode.
                                 */
#endif
                                sysv_rwlock_wrlock(&semaptr->rwlock);
#else
                                sysv_mutex_lock(&semaptr->mutex);
#endif
                        }
                }
        }
}

/* Function called by parent after fork to release locks
 * acquired before fork.
 */
static void
parent_release_locks(void)
{
        struct entries_list *list;
        struct hashentry *tmp;
        struct shm_data *data;
        struct semid_pool *semaptr;
        int i;

        SYSV_MUTEX_UNLOCK(&lock_undo);
        SYSV_MUTEX_UNLOCK(&lock_resources);
        //pthread_rwlock_unlock(&rwlock_addrs);

        for (i=0; i<get_hash_size(MAXSIZE); i++) {
                list = &shmaddrs->entries[i];
                if (LIST_EMPTY(list))
                        continue;
                LIST_FOREACH(tmp, list, entry_link) {
                        data = (struct shm_data*)tmp->value;
                        if (data->type == SEMGET) {
                                semaptr = (struct semid_pool *)data->internal;
#ifdef SYSV_RWLOCK
                                sysv_rwlock_unlock(&semaptr->rwlock);
#else
                                sysv_mutex_unlock(&semaptr->mutex);
#endif
                        }
                }
        }
}

/* Function called by child after fork to release locks
 * acquired before fork by the parent.
 * Only locks specific to the address space are released.
 * Those created in the shared memory are released by the
 * parent.
 */
static void
child_release_locks(void)
{
        SYSV_MUTEX_UNLOCK(&lock_undo);
        SYSV_MUTEX_UNLOCK(&lock_resources);
        //pthread_rwlock_unlock(&rwlock_addrs);
}

static void
prepare_parent_atfork(void)
{
        /* Function called only if the process has
         * sysv ipc structures initialized.
         */
        if (!is_sysvinit())
                return;

        /* Acquire all locks to be sure that neither one is
         * held by another thread.
         */
        acquire_locks();
}

static void
parent_atfork(void)
{
        if (!is_sysvinit())
                return;

        /* Release locks acquired before fork. */
        parent_release_locks();
}

static void
child_atfork(void)
{
        if (!is_sysvinit())
                return;

        /* Release locks acquired before fork. */
        child_release_locks();
        /* Close the file descriptor used by parent. */
        _close(daemon_fd);

        /* Register it to daemon too. */
        if (register_to_daemon() < 0) {
                sysv_print_err("register to daemon error\n");
                exit(-1);
        }

        /* Inform the daemon about each shared memory segment used. */
        shmchild();
}

/* The function is called only once, when the process uses for
 * the first time sysv ipc resources.
 */
int
sysvinit(void)
{
        if (is_sysvinit()) {
                return (IPC_INITIALIZED);
        }

        if (register_to_daemon() < 0)
                return (-1);

        /* Add handlers for parent and child when fork is called. */
        if (_pthread_atfork(prepare_parent_atfork, parent_atfork,
                                child_atfork) < 0) {
                sysv_print_err("pthread_atfork error\n");
                return (-1);
        }
        return 0;
}

int
sysvexit(void)
{
        if (!is_sysvinit())
                return (-1);

        return (0);
}