/*
 * Copyright (c) 2013 Larisa Grigore <larisagrigore@gmail.com>.
 *
 * 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. All advertising materials mentioning features or use of this software
 *    must display the following acknowledgement:
 *      This product includes software developed by Adam Glass and Charles
 *      Hannum.
 * 4. The names of the authors may not be used to endorse or promote products
 *    derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``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 AUTHORS 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/queue.h>
#include <sys/mman.h>
#include <sys/shm.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <fcntl.h>
#include <err.h>
#include <pthread.h>
#include <unistd.h>
#include "un-namespace.h"

#include "sysvipc_lock.h"
#include "sysvipc_ipc.h"
#include "sysvipc_sockets.h"
#include "sysvipc_shm.h"
#include "sysvipc_hash.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)

struct hashtable *shmres = NULL;
struct hashtable *shmaddrs = NULL;
pthread_mutex_t lock_resources = PTHREAD_MUTEX_INITIALIZER;

/* File descriptor used to communicate with the daemon. */
extern int daemon_fd;
/* Structure used to save semaphore operation with SEMUNDO flag. */
extern struct sem_undo *undos;

static int
shminit(void)
{
        if (shmres) {
                errno = EPERM;
                return (-1);
        }

        shmres = _hash_init(MAXSIZE);
        if (!shmres)
                goto out_resources;

        shmaddrs = _hash_init(MAXSIZE);
        if (!shmaddrs)
                goto out_addrs;

        return 0;

out_addrs:
        _hash_destroy(shmres);
out_resources:
        return -1;
}

/*static int
shmexit(void)
{
        if (!shmres)
                return -EPERM;

        _hash_destroy(shmres);
        _hash_destroy(shmaddrs);
        SYSV_MUTEX_DESTROY(lock_resources);

        return 0;
}*/

/* Init sysv ipc resources and those used for shared memory. */
static int
shmcheck(void)
{
        int ret;

        /* Init sysv resources. */
        if ((ret = sysvinit()) != 0)
                return (ret);
        /* Init resorces used for shared memory. */
        if ((ret = shminit()) < 0)
                return (ret);
        return (0);
}

/* Check if sysv ipc resources are initialized. */
static int
is_shm_started(void)
{
        if (!is_sysvinit())
                return (0);
        if (!shmres)
                return (0);
        return (1);
}

/* OBS: It is used only a rwlock for both hashtables and
 * socket. I've made that choice because is I considered to
 * be much expensive to acquire/release more than one especially
 * as the daemon is not multithreading.
 */

/* This function has another parameter apart from shmget.
 * The parameter has information about the type of sysv
 * ipc resource (shm, sem, msg, undo).
 * The undo segment is used for sem ops with UNDO flag set.
 */
int
_shmget(key_t key, size_t size, int shmflg, int type)
{
        struct shmget_msg msg;
        struct shm_data *data;
        int shmid, fd;
        int flags;

        SYSV_MUTEX_LOCK(&lock_resources);
        if (shmcheck() < 0) {
                sysv_print_err("init sysv ipc\n");
                goto done;
        }

        msg.key = key;
        msg.size = size;
        msg.shmflg = shmflg;
        msg.type = type;

        send_message(daemon_fd, type, (char *)&msg, sizeof(msg));

        /* Accept a file installed by the daemon.
         * The file is used as shared memory. */
        fd = receive_fd(daemon_fd);
        if (fd < 0) {
                shmid = -1;
                goto done;
        }

        flags = _fcntl(fd, F_GETFD, 0);
        if (_fcntl(fd, F_SETFD, flags & FD_CLOEXEC) == -1) {
                sysv_print_err("fcntl error\n");
                shmid = -1;
                goto done;
        }

        /* Receive the resource id or error. */
        receive_message(daemon_fd, (char *)&shmid, sizeof(shmid));

        if (shmid < 0) {
                errno = -shmid;
                shmid = -1;
                goto done;
        }

        /* Do we already have an entry for this resource? */
        data = _hash_lookup(shmres, shmid);
        if (data)
                goto done;

        /* If not, add necessary data about it. */
        data = malloc(sizeof(struct shm_data));
        data->fd = fd;
        data->size = size;
        data->shmid = shmid;
        data->type = type;
        data->used = 0;
        data->removed = 0;
        data->access = 0; /* Used for sems. */

        /* Insert data in hashtable using the shmid. */
        _hash_insert(shmres, shmid, data);
done:
        SYSV_MUTEX_UNLOCK(&lock_resources);
        return (shmid);
}

int
sysvipc_shmget(key_t key, size_t size, int shmflg)
{
        return (_shmget(key, size, shmflg, SHMGET));
}

void *
sysvipc_shmat(int shmid, const void *shmaddr, int shmflg)
{
        struct shmat_msg msg;
        void *addr = NULL;
        int error;
        int flags, prot;
        size_t size;
        struct shm_data *data;

        SYSV_MUTEX_LOCK(&lock_resources);
        if (!is_shm_started()) {
                errno = EINVAL;
                goto done;
        }

        /* Get data using shmid. */
        data = _hash_lookup(shmres, shmid);
        if (data == NULL) {
                errno = EINVAL;
                goto done;
        }

        size = round_page(data->size);

#ifdef VM_PROT_READ_IS_EXEC
        prot = PROT_READ | PROT_EXECUTE;
#else
        prot = PROT_READ;
#endif
        if ((shmflg & SHM_RDONLY) == 0)
                prot |= PROT_WRITE;

        flags = MAP_SHARED;
        if (shmaddr) {
                if (shmflg & SHM_RND) {
                        addr = (void *)(rounddown2((uintptr_t)shmaddr, SHMLBA));
                } else if (((uintptr_t)shmaddr & (SHMLBA-1)) == 0) {
                        addr = __DECONST(void *, shmaddr);
                } else {
                        errno = EINVAL;
                        goto done;
                }
        }

        msg.shmid = shmid;
        msg.shmaddr = shmaddr;
        msg.shmflg = shmflg;
        msg.size = data->size; /* For undo segment. */

        send_message(daemon_fd, SHMAT, (char *)&msg, sizeof(msg));
        receive_message(daemon_fd, (char *)&error, sizeof(error));
        if (error) {
                errno = error;
                goto done;
        }

        addr = mmap(addr, size, prot, flags, data->fd, 0);
        if (!addr) {
                sysv_print_err("mmap\n");
                /* Detach ourselves from the segment. */
                send_message(daemon_fd, SHMDT, (char *)&shmid, sizeof(shmid));
                goto done;
        }

        /* Necessary for SEMGET, MSGGET, UNDOGET. */
        data->internal = addr;

        /* Save the mapped address for munmap call. */
        _hash_insert(shmaddrs, (u_long)addr, data);
done:
        SYSV_MUTEX_UNLOCK(&lock_resources);
        return (addr);
}

/* Remove a sysv ipc resource. */
static
void shmremove(int shmid)
{
        struct shm_data *data;
        data = _hash_remove(shmres, shmid);

        //TODO nu trebuie demapat?
        _close(data->fd);
        free(data);
        data = NULL;
}

int
sysvipc_shmctl(int shmid, int cmd, struct shmid_ds *buf)
{
        int size, ret;
        struct shmctl_msg *msg;

/*      if (cmd == IPC_SET)
                size = sizeof(struct shmctl_msg) + sizeof(struct shmid_ds);
        else
                size = sizeof(struct shmctl_msg);
*/
        SYSV_MUTEX_LOCK(&lock_resources);

        ret = -1;

        if (!is_shm_started()) {
                errno = EINVAL;
                goto done;
        }

        size = sizeof(struct shmctl_msg);
        msg = malloc(size);
        msg->shmid = shmid;
        msg->cmd = cmd;

        if (cmd == IPC_SET)
                msg->buf = *buf;

        send_message(daemon_fd, SHMCTL, (char *)msg, sizeof(*msg));

        receive_message(daemon_fd, (char *)&ret, sizeof(ret));

        /* Get data in IPC_STAT case. */
        if (ret == 0 && cmd == IPC_STAT)
                receive_message(daemon_fd, (char *)buf, sizeof(*buf));

        /* Free all resources specific to a shmid in IPC_RMID case. */
        if (ret == 0 && cmd == IPC_RMID)
                shmremove(shmid);

        errno = ret;
done:
        SYSV_MUTEX_UNLOCK(&lock_resources);
        return (ret == 0 ? 0 : -1);
}

/* Functionality of shmdt with the possibility to inform or not
 * the daemon.
 * Inform the daemon when shmdt is called and not when an error
 * occurs and the daemon doesn't know that the process is attaced.
 */
static int
_shmdt(const void *shmaddr, int send_to_daemon)
{
        int ret;
        size_t size;
        struct shm_data *data;

        ret = -1;

        SYSV_MUTEX_LOCK(&lock_resources);
        if (!is_shm_started()) {
                errno = EINVAL;
                goto done;
        }

        /* Verify if shmaddr was returned from a shmat call. */
        data = _hash_remove(shmaddrs, (u_long)shmaddr);
        if (data == NULL) {
                errno = EINVAL;
                goto done;
        }

        size = round_page(data->size);

        ret = munmap(__DECONST(void *, shmaddr), size);
        if (ret)
                goto done;

        if (send_to_daemon)
                send_message(daemon_fd, SHMDT, (char *)&data->shmid, sizeof(int));

        shmaddr = NULL;
        free(data);
        data = NULL;
done:
        SYSV_MUTEX_UNLOCK(&lock_resources);
        return (ret);
}

int
sysvipc_shmdt(const void *shmaddr)
{
        return (_shmdt(shmaddr, 1));
}

void
shmchild(void)
{
        int i;
        struct entries_list *list;
        struct hashentry *tmp, *ttmp;
        struct shmat_msg msg;
        struct shm_data *data;
        int error;

/* OBS: no locking is necessary because this function is called
 * after the child is created and at that moment only one thread
 * exists in the process.
 */
        for (i=0; i<get_hash_size(MAXSIZE); i++) {
                list = &shmaddrs->entries[i];
                if (LIST_EMPTY(list))
                        continue;
                LIST_FOREACH_MUTABLE(tmp, list, entry_link, ttmp) {
                        data = (struct shm_data*)tmp->value;
                        /* Inform daemon that we are attached. */

                        if (data->type == UNDOGET) {
                                continue;
                        }

                        msg.shmid = data->shmid;
                        msg.shmaddr = data->internal;
                        msg.shmflg = 0; /* This is enough at this moment. */
                        msg.size = data->size;
                        /* Last field is not necessary because it is used only
                         * for undo segments.
                         */

                        send_message(daemon_fd, SHMAT, (char *)&msg, sizeof(msg));
                        receive_message(daemon_fd, (char *)&error, sizeof(error));

                        /* If the daemon returned error munmap the region. */
                        if (error) {
                                errno = error;
                                _shmdt(data->internal, 0);
                                shmremove(data->shmid);
                                sysv_print_err(" %d shmchild\n", error);
                                sleep(20);
                        }
                        
                }
        }

        /* Remove semundo structures. Those are specific only for the parent.
         * The child must create for itself a new one.
         */
        data = _hash_remove(shmaddrs, (u_long)undos);
        if (undos) {
                munmap(undos, round_page(data->size));
                undos = NULL;
        }
}

/* Called each time a thread tries to access the sem/msg.
 * It is used in order to protect data against its removal
 * by another thread.
 */
struct shm_data *
get_shmdata(int id, int to_remove, int shm_access)
{
        struct shm_data *data = NULL;

        SYSV_MUTEX_LOCK(&lock_resources);
        if (!is_shm_started()) {
                errno = EINVAL;
                goto done;
        }

        data = _hash_lookup(shmres, id);
        if (!data) {
                errno = EINVAL;
                goto done;
        }

        /* If segment was removed by another thread we can't use it. */
        if (data->removed) {
                sysv_print("segment already removed\n");
                errno = EINVAL;
                data = NULL;
                goto done;
        }

        /* Mark for removal. Inform the other threads from the
         * same address space. */
        if (to_remove) {
                sysv_print("segment is removed\n");
                data->removed = to_remove; /* 1 if it is removed by
                the current process and 2 if it was removed by
                another one. */

                /* No need for any rights check because this is
                 * done by daemon if this is the process that removes
                 * the sem/msg.
                 * If not, there is no need for any right to clean
                 * internal resources.
                 */
                goto done2;
        }

        /* Avoid segmentation fault if the memory zone
         * is accessed without necessary permissions
         * (it was mapped according to them).
         */
        if (!(data->access & shm_access)) {
#if 0
                sysv_print("no access rights has %o and wants %o\n",
                                data->access, shm_access);
                errno = EACCES;
                data = NULL;
                goto done;
#endif
        }

done2:
        data->used++;
done:
        SYSV_MUTEX_UNLOCK(&lock_resources);
        return (data);
}

/* Set the shm_access type (IPC_R, IPC_W) for sem/msg. */
int
set_shmdata_access(int id, int shm_access)
{
        struct shm_data *data;
        int ret = -1;

        SYSV_MUTEX_LOCK(&lock_resources);
        if (!is_shm_started()) {
                errno = EINVAL;
                goto done;
        }

        data = _hash_lookup(shmres, id);
        if (!data) {
                errno = EINVAL;
                goto done;
        }

        /* If segment was removed by another thread we can't use it. */
        if (data->removed) {
                errno = EINVAL;
                goto done;
        }

        data->access = shm_access;
        ret = 0;
done:
        SYSV_MUTEX_UNLOCK(&lock_resources);

        return (ret);
}