/*

    Task Spooler - a task queue system for the unix user

    Copyright (C) 2007-2009  Lluís Batlle i Rossell

    Please find the license in the provided COPYING file.

*/

#include <unistd.h>

#include <string.h>

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/un.h>

#include <errno.h>

#include <stdlib.h>

#include <stdio.h>

#include <sys/time.h>

#include <sys/stat.h>

#include <signal.h>

#include "main.h"

extern int server_socket;

static char *socket_path;

static int should_check_owner = 0;

static int fork_server(int ls);

void create_socket_path(char **path)

{

    char *tmpdir;

    char userid[20];

    int size;

    /* As a priority, TS_SOCKET mandates over the path creation */

    *path = getenv("TS_SOCKET");

    if (*path != 0)

    {

        /* We need this in our memory, for forks and future 'free'. */

        size = strlen(*path) + 1;

        *path = (char *) malloc(size);

        strcpy(*path, getenv("TS_SOCKET"));

        /* We don't want to check ownership of the socket here,

         * as the user may have thought of some shared queue */

        should_check_owner = 0;

        return;

    }

    /* ... if the $TS_SOCKET doesn't exist ... */

    /* Create the path */

    tmpdir = getenv("TMPDIR");

    if (tmpdir == NULL)

        tmpdir = "/tmp";

    sprintf(userid, "%u", (unsigned int) getuid());

    /* Calculate the size */

    size = strlen(tmpdir) + strlen("/socket-ts.") + strlen(userid) + 1;

    /* Freed after preparing the socket address */

    *path = (char *) malloc(size);

    sprintf(*path, "%s/socket-ts.%s", tmpdir, userid);

    should_check_owner = 1;

}

int try_connect(int s)

{

    struct sockaddr_un addr;

    int res;

    memset(&addr, 0, sizeof(addr));

    addr.sun_family = AF_UNIX;

    strncpy(addr.sun_path, socket_path, sizeof(addr.sun_path) - 1);

    if (strcmp(socket_path, addr.sun_path))

        error("Cannot create the socket '%s'. Probably, the name is too long.", socket_path);

    res = connect(s, (struct sockaddr *) &addr, sizeof(addr));

    return res;

}

static void

try_check_ownership()

{

    int res;

    struct stat socketstat;

    if (!should_check_owner)

        return;

    res = stat(socket_path, &socketstat);

    if (res != 0)

        error("Cannot state the socket %s.", socket_path);

    if (socketstat.st_uid != getuid())

        error("The uid %i does not own the socket %s.", getuid(), socket_path);

}

void wait_server_up(int fd)

{

    char a;

    read(fd, &a, 1);

    close(fd);

}

/* Returns the fd where to wait for the parent notification */

static int fork_server(int ls)

{

    int pid;

    int p[2];

    /* !!! stdin/stdout */

    pipe(p);

    pid = fork();

    switch (pid)

    {

        case 0: /* Child */

            close(p[0]);

            close(server_socket);

            /* Close all std handles for the server */

            close(0);

            close(1);

            close(2);

            setsid();

            server_main(p[1], socket_path, ls);

            exit(0);

            break;

        case -1: /* Error */

            return -1;

        default: /* Parent */

            close(ls);

            close(p[1]);

    }

    /* Return the read fd */

    return p[0];

}

void notify_parent(int fd)

{

    char a = 'a';

    write(fd, &a, 1);

    close(fd);

}

static int is_path_unixsocket(const char *path)

{

    int res;

    struct stat socketstat;

    res = stat(path, &socketstat);

    if (res == 0 && S_ISSOCK(socketstat.st_mode))

        return 1;

    return 0;

}

static int open_server_socket()

{

    int res;

    int ls;

    struct sockaddr_un addr;

    ls = socket(AF_UNIX, SOCK_STREAM, 0);

    if(ls == -1)

        error("cannot create the listen socket in the server");

    addr.sun_family = AF_UNIX;

    strcpy(addr.sun_path, socket_path);

    res = bind(ls, (struct sockaddr *) &addr, sizeof(addr));

    if (res == -1)

    {

        warning("Error binding.");

        close(ls);

        return -1;

    }

    res = listen(ls, 0);

    if (res == -1)

    {

        /* If bind succeeded, can this fail? */

        warning("Error listening.");

        close(ls);

        return -1;

    }

    return ls;

}

int ensure_server_up()

{

    int res;

    int notify_fd;

    int server_bind_fd = -1;

    server_socket = socket(AF_UNIX, SOCK_STREAM, 0);

    if (server_socket == -1)

        error("getting the server socket");

    create_socket_path(&socket_path);

    res = try_connect(server_socket);

    /* Good connection */

    if (res == 0)

    {

        try_check_ownership();

        return 1;

    }

    /* If error other than "No one listens on the other end"... */

    if (!(errno == ENOENT || errno == ECONNREFUSED))

        error("c: cannot connect to the server at '%s': %s",

                socket_path, strerror(errno));

    if (errno == ECONNREFUSED)

    {

        if (!is_path_unixsocket(socket_path))

            error("The socket path exists and it is not a unix socket: %s",

                    socket_path);

        unlink(socket_path);

    }

    /* Try to start a server. It may fail if multiple clients try to do this at oncei. */

    server_bind_fd = open_server_socket();

    if (server_bind_fd != -1)

    {

        /* If it worked, wait for server to start. Otherwise, repeat connect */

        notify_fd = fork_server(server_bind_fd);

        wait_server_up(notify_fd);

    }

    /* Connect after either server start or reattempt because of clash at start */

    res = try_connect(server_socket);

    /* The second time didn't work. Abort. */

    if (res == -1)

    {

        fprintf(stderr, "The server didn't come up.\n");

        exit(-1);

    }

    try_check_ownership();

    free(socket_path);

    /* Good connection on the second time */

    return 1;

}