Re: [T(A)ILS-dev] GSoC application: tails-greeter

>  * we have enough time to answer your questions
>  * you'll be forced to participate into our development community,
>    we'll be forced to speak to each other, to get to know each other a
>    bit, which is the whole point of the "community diving" month.

> 1. One week seems *very* short to me to do all this stuff, unless you
>    already are really at ease with code testing and Debian packaging.

> 2. I'd be much more comfortable with this schedule if you included (at
>    least unit-) testing as part of your code writing process.

> 3. The best way to have Tails developers (and users!) review and test
>    your work would be to have a branch in Tails Git repository where
>    you push your work; depending on how it presents itself, it may
>    deserve a Debian package (in this case, a dedicated repository
>    would be setup for tails-greeter, and a Debian package would be
>    pushed at least at milestone time to the Tails repository) or not
>    (in this case, you'd only work in the Tails Git repository).
>    In either case, you'll need to do some packaging/glue-ing work from
>    the very beginning and all along I think, rather than late in the
>    coding process as you are suggesting.

#define SERVER_CMD_NOP            0
#define SERVER_CMD_QUIT            1
#define SERVER_CMD_FREE_SD        2
#define SERVER_CMD_ADD_SESSION        3
#define SERVER_SESSIONS_MAX        16

server_cmd_t     server_cmd         = SERVER_CMD_NOP;
int         server_cmd_arg;
pthread_mutex_t    server_cmd_mutex    = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t    server_cmd_cv;
pthread_mutex_t server_cmd_send_mutex    = PTHREAD_MUTEX_INITIALIZER;
pthread_cond_t     server_cmd_send_cv;
pthread_mutex_t    server_cmd_cv_mutex    = PTHREAD_MUTEX_INITIALIZER;
int         server_exists        = 0;
pthread_mutex_t server_exists_mutex    = PTHREAD_MUTEX_INITIALIZER;

struct server_session_t 
{
    pthread_t thread;
    int socket;
    int sn;
    void (*session_proc) (int);
};

/*______________________________
    server_cmd_send(): 
         send command to server

    IN:
         cmd         command
        cmd_arg        command args

    OUT:
         <nothing>
________________________________*/
void
server_cmd_send(server_cmd_t cmd, int cmd_arg)
{
    int old_cancel_state, retval;

    DLOG("<!-- begin of critical section --!>");
    retval = pthread_setcancelstate(PTHREAD_CANCEL_DISABLE, &old_cancel_state);
    assert(retval == 0);

    DLOG("lock server_send_cmd mutex (queueing commands)");
    retval = pthread_mutex_lock(&server_cmd_send_mutex);
    assert(retval == 0);

    DLOG("test server existence");
    retval = pthread_mutex_lock(&server_exists_mutex);
    assert(retval == 0);
    if(!server_exists) 
    {
    retval = pthread_mutex_unlock(&server_cmd_send_mutex);
    assert(retval == 0);
    retval = pthread_mutex_unlock(&server_exists_mutex);
    assert(retval == 0);
    return;
    }
    retval = pthread_mutex_unlock(&server_exists_mutex);
    assert(retval == 0);

    DLOG("lock server_cmd mutex");
    retval = pthread_mutex_lock(&server_cmd_mutex);
    assert(retval == 0);

    DLOG("fill server_cmd variables");
    server_cmd = cmd;
    server_cmd_arg = cmd_arg;

    DLOG("lock server_cmd_cv mutex");
    retval = pthread_mutex_lock(&server_cmd_cv_mutex);
    assert(retval == 0);

    DLOG("send signal to server and unlock server_cmd mutex");
    retval = pthread_cond_signal(&server_cmd_cv);
    assert(retval == 0);
    retval = pthread_mutex_unlock(&server_cmd_mutex);
    assert(retval == 0);

    DLOG("wait for server");
    retval = pthread_cond_wait(&server_cmd_send_cv, &server_cmd_cv_mutex);
    assert(retval == 0);
    retval = pthread_mutex_unlock(&server_cmd_cv_mutex);
    assert(retval == 0);

    DLOG("unlock next server_send_cmd");
    retval = pthread_mutex_unlock(&server_cmd_send_mutex);
    assert(retval == 0);

    DLOG("<!-- end of critical section --!>");
    retval = pthread_setcancelstate(old_cancel_state, NULL);
    assert(retval == 0);

    DLOG("done.");
}

void *
clients_thread(void *arg)
{
    int retval, server_socket_fd = (int) arg;

    DLOG("enable async cancellation");
    retval = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    assert(retval == 0);

    DLOG("goto infinity loop");
    while(1) 
    {
    struct sockaddr name;
    socklen_t len;
    int socket_fd;

    DLOG("waiting for client...");
    socket_fd = accept(server_socket_fd, &name, &len);

    DLOG("client accepted, send signal to server...");
    server_cmd_send(SERVER_CMD_ADD_SESSION, socket_fd);

    DLOG("done");
    }

inline void 
server_session_cleanup(void *arg)
{
    DLOG("send SERVER_CMD_FREE_SD");
    server_cmd_send(SERVER_CMD_FREE_SD, (int) arg);
}

void *
server_session(void *arg) 
{
    int retval;
    struct server_session_t *p = (struct server_session_t *) arg;

    DLOG("set cleanup func");
    pthread_cleanup_push(&server_session_cleanup, (void *) p->sn);

    DLOG("set asynchronous cancel type");
    retval = pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, NULL);
    assert(retval == 0);

    DLOG("run session");
    p->session_proc(p->socket);

    DLOG("run cleanup func");
    pthread_cleanup_pop(1);

    DLOG("done.");
    return NULL;
}

void
server_quit()
{
    server_cmd_send(SERVER_CMD_QUIT, 0);
}

int
server(int server_socket_fd, void (*session_proc)(int))
{
    struct server_session_t sessions[SERVER_SESSIONS_MAX];
    int pool[SERVER_SESSIONS_MAX];
    pthread_t clients;
    int t, cmd_arg, retval, sessions_count = 0, server_run = 1, server_quit = 0;
    struct server_session_t * p = NULL;
    server_cmd_t cmd;

    DLOG("check server existence");
    retval = pthread_mutex_lock(&server_exists_mutex);    
    assert(retval == 0);

    if(server_exists) 
    {
    DLOG("server already exists");
    retval = pthread_mutex_unlock(&server_exists_mutex);
    assert(retval == 0);
    return 1;
    }

    server_exists = 1;

    retval = pthread_mutex_unlock(&server_exists_mutex);
    assert(retval == 0);

    DLOG("init server_cmd_cv");
    retval = pthread_cond_init(&server_cmd_cv, NULL);
    assert(retval == 0);
    retval = pthread_cond_init(&server_cmd_send_cv, NULL);
    assert(retval == 0);

    DLOG("filling pool of session numbers");
    for(t = 0; t < SERVER_SESSIONS_MAX; ++t)
    pool[t] = t;

    DLOG("lock server_cmd mutex");
    retval = pthread_mutex_lock(&server_cmd_mutex);
    assert(retval == 0);

    DLOG("starting thread for accepting clients");
    if(pthread_create(&clients, NULL, &clients_thread, (void *) server_socket_fd)) 
    {
    DLOG("ERR: can't start thread for accepting clients");
    retval = pthread_mutex_unlock(&server_cmd_mutex);
    assert(retval == 0);

    return ENOMEM;
    }

    DLOG("starting main loop");
    while(server_run) 
    {
    DLOG("waiting for command...");
    retval = pthread_cond_wait(&server_cmd_cv, &server_cmd_mutex);
    assert(retval == 0);

    DLOG("save command and it's argument to local variables");
    cmd = server_cmd;
    cmd_arg = server_cmd_arg;

    DLOG("send signal to server_send_cmd that command is recieved");
    retval = pthread_mutex_lock(&server_cmd_cv_mutex);
    assert(retval == 0);
    retval = pthread_cond_signal(&server_cmd_send_cv);
    assert(retval == 0);
    retval = pthread_mutex_unlock(&server_cmd_cv_mutex);
    assert(retval == 0);

    DLOG("command recieved");
    switch(cmd) 
    {
        case SERVER_CMD_NOP:
        DLOG("cmd == SERVER_CMD_NOP");
        /* do nothing */
        break;

        case SERVER_CMD_ADD_SESSION:
        DLOG("cmd == SERVER_CMD_ADD_SESSION");

        if(server_quit)
            break;

        assert(sessions_count <= SERVER_SESSIONS_MAX);
        if(sessions_count == SERVER_SESSIONS_MAX) 
        {
            DLOG("sessions counter == max");    
            break;
        }

        t = pool[sessions_count];
        p = &(sessions[t]);

        DLOG("fill server_session_t fields");
        p->socket = (int) cmd_arg;
        p->sn = t;
        p->session_proc = session_proc;

        DLOG("add session");
        if(pthread_create(&(p->thread), NULL, &server_session, (void *) p)) 
        {
            DLOG("session add failed");
        } 
        else 
        {
            DLOG("session added");
            ++sessions_count;
        }
        break;

        case SERVER_CMD_FREE_SD: 
        DLOG("cmd == SERVER_CMD_FREE_SD");

        assert(sessions_count);
        t = cmd_arg;
        assert(t >=0 && t < SERVER_SESSIONS_MAX);

        DLOG("join session");
        retval = pthread_join(sessions[pool[t]].thread, NULL);
        assert(retval == 0);

        DLOG("close socket");
        close(sessions[pool[t]].socket);

        DLOG("free session's pool entry");
        --sessions_count;
        pool[sessions_count] = t;

        if(sessions_count == 0 && server_quit)
            server_run = 0;
        break;

        case SERVER_CMD_QUIT:
        DLOG("cmd == SERVER_CMD_QUIT");

        if(server_quit)
            break;

        DLOG("cancel accepting thread"); 
        retval = pthread_cancel(clients);
        assert(retval == 0);

        DLOG("cancel sessions");
        for(t = 0; t < sessions_count; ++t)
        {
            retval = pthread_cancel(sessions[pool[t]].thread);
            assert(retval == 0);
        }

        server_quit = 1;
        break;
    }
    }

    DLOG("unlock server_cmd mutex");
    retval = pthread_mutex_unlock(&server_cmd_mutex);
    assert(retval == 0);

    DLOG("join clients' accepting thread");
    retval = pthread_join(clients, NULL);
    assert(retval == 0);

    DLOG("server_exists -> 0");
    retval = pthread_mutex_lock(&server_exists_mutex);
    assert(retval == 0);

    server_exists = 0;

    retval = pthread_mutex_unlock(&server_exists_mutex);
    assert(retval == 0);

    DLOG("done.");
    return 0;
}