source: neercs/trunk/src/attach.c @ 2474 Tweet

#include <errno.h>
#include <fcntl.h>
#include <glob.h>
#include <limits.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/un.h>
#include <sys/types.h>
#include <sys/stat.h>

#include "neercs.h"

static char * build_socket_path(char *socket_dir)
{
    char *path, *dir;
    path = (char *)malloc(PATH_MAX+1);
    dir = socket_dir;
    if(!dir)
        dir = getenv("NEERCSDIR");
    if(!dir)
        dir = getenv("TMPDIR");
    if(!dir)
        dir = "/tmp";
    if(path)
        snprintf(path, PATH_MAX+1, "%s/neercs.%d.sock", dir, getpid());
    return path;
}

int create_socket(struct screen_list* screen_list)
{
    int sock;
    struct sockaddr_un myaddr;

    sock = socket(AF_UNIX, SOCK_DGRAM, 0);

    if(sock < 0)
    {
        perror("create_socket:socket");
        return errno;
    }

    memset(&myaddr, 0, sizeof(struct sockaddr_un));

    myaddr.sun_family = AF_UNIX;
    screen_list->socket_path = build_socket_path(screen_list->socket_path);
    strncpy(myaddr.sun_path, screen_list->socket_path, sizeof(myaddr.sun_path) - 1);
    unlink(myaddr.sun_path);

    if(bind(sock, (struct sockaddr *)&myaddr, sizeof(struct sockaddr_un)) < 0)
    {
        free(screen_list->socket_path);
        screen_list->socket_path = NULL;
        close(sock);
        perror("create_socket:bind");
        return errno;
    }
    fcntl(sock, F_SETFL, O_NONBLOCK);

    debug("Listening on %s (%d)", screen_list->socket_path, sock);

    screen_list->socket = sock;

    return 0;
}

int detach(struct screen_list* screen_list, caca_display_t * dp)
{
    int fd;
    int pid;

    screen_list->attached = 0;
    caca_free_display(dp);

    close(0);
    close(1);
    close(2);

    fd = open("/tmp/log.txt", O_RDWR|O_CREAT, S_IRUSR|S_IWUSR);
    dup2(fd, 0);
    dup2(fd, 1);
    dup2(fd, 2);
    if (fd > 2)
        close(fd);

    if(!screen_list->socket)
    {
        pid = fork();
        if (pid < 0)
            return 1;
        if (pid > 0)
            exit(0);

        create_socket(screen_list);
        setsid();
    }

    return 0;
}

/* FIXME Is this really not defined anywhere ? */
#define MIN(X,Y) ((X) < (Y) ? (X) : (Y))

static int handle_command(char * cmd, struct screen_list* screen_list, cucul_canvas_t * cv, caca_display_t ** dp)
{
    int refresh = 0;
    debug("Received command %s", cmd);
    if(!strncmp("ENV ", cmd, MIN(4, strlen(cmd))))
    {
        putenv(strdup(cmd+4));
    }
    else if(!strncmp("ATTACH ", cmd, MIN(7, strlen(cmd))))
    {
        int fd;
        screen_list->attached = 1;
        close(screen_list->socket);
        screen_list->socket= 0;
        unlink(screen_list->socket_path);
        screen_list->socket_path = NULL;
        close(0);
        fd=open(cmd+7, O_RDWR);
        dup2(fd, 0);
        close(1);
        fd=open(cmd+7, O_RDWR);
        dup2(fd, 1);
        close(2);
        fd=open(cmd+7, O_RDWR);
        dup2(fd, 2);
        *dp = caca_create_display(cv);
        if(*dp)
        {
            caca_set_cursor(*dp, 1);
            refresh = 1;
        }
    }
    else
    {
        fprintf(stderr, "Unknown command received: %s\n", cmd);
    }
    return refresh;
}

int read_socket(struct screen_list* screen_list, cucul_canvas_t * cv, caca_display_t ** dp) {
    ssize_t n;
    char buf[4097];
    int refresh = 0;

    if(!screen_list->socket)
        return 0;

    while (screen_list->socket && (n = read(screen_list->socket, buf, sizeof(buf)-1)) > 0)
    {
        buf[n] = 0;
        refresh |= handle_command(buf, screen_list, cv, dp);
    }
    return refresh;
}

char ** list_sockets(char *socket_dir)
{
    char *pattern, *dir;
    glob_t globbuf;

    globbuf.gl_pathv = NULL;

    pattern = (char *)malloc(PATH_MAX+1);

    dir = socket_dir;
    if(!dir)
        dir = getenv("NEERCSDIR");
    if(!dir)
        dir = getenv("TMPDIR");
    if(!dir)
        dir = "/tmp";

    if(!pattern)
        return globbuf.gl_pathv;

    snprintf(pattern, PATH_MAX, "%s/neercs.*.sock", dir);
    pattern[PATH_MAX] = '\0';

    debug("Looking for sockets in the form %s", pattern);

    glob(pattern, 0, NULL, &globbuf);

    return globbuf.gl_pathv;
}


/* FIXME Is this really not defined anywhere ? */
extern char **environ;

int request_attach(char *socket_path)
{
    int i;
    int sock;
    char fdstr[PATH_MAX], lnk[PATH_MAX];
    char buf[4096];
    struct sockaddr_un addr;

    debug("Connecting to %s", socket_path);

    /* Open the socket */
    if ((sock = socket(AF_UNIX, SOCK_DGRAM, 0)) < 0) {
        perror("request_attach:socket");
        return 1;
    }

    memset(&addr,0,sizeof(addr));
    addr.sun_family = AF_UNIX;
    strcpy(addr.sun_path,socket_path);
    if (connect(sock, &addr, sizeof(addr)) < 0)
    {
        perror("request_attach:connect");
        return 1;
    }

    debug("Sending environment", 0);

    /* Send our environment */
    for(i=0; environ[i]; i++)
    {
        snprintf(buf, 4096, "ENV %s", environ[i]);
        write(sock, buf, strlen(buf));
    }

    snprintf(fdstr, sizeof(fdstr), "/proc/%d/fd/0", getpid());
    readlink(fdstr, lnk, sizeof(lnk)-1);
    lnk[PATH_MAX-1] = '\0';

    close(0);

    debug("Requesting attach to %s", lnk);

    /* Request attaching */
    snprintf(buf, 4096, "ATTACH %s", lnk);
    write(sock, buf, strlen(buf));
    close(sock);

    debug("Exiting", 0);
    exit(0);
}