root/handler.c

#include"main.h"

#define MAX_NAME_LEN 256
#define BUFFER 4*1024

void * handle(void * args)
{
    char * getbuffer = calloc(MAX_NAME_LEN, sizeof(char));
    char * buffer = calloc(MAX_NAME_LEN*2, sizeof(char));
    char * netbuffer = calloc(BUFFER, sizeof(char));
    size_t size = 0;
    size_t offset = 0;
    int mode = 0;       // 1 is connection established
    struct service * service = NULL;
    struct service * listservice = NULL;
    int i = 0;
    int outsock = 0;
    int waiting = 0;
    char * response;
    struct epoll_event ev, *events; //For epoll()
    int len;
    char * check = calloc(BUFFER, sizeof(char));

    struct session * s = calloc(1, sizeof(struct session));
    s->sock = (int) args;
    s->ssl = NULL;     // If this is set, we need to use SSL
    s->contxt = NULL;
    s->multiplex = 0;
    s->multiplex_xtra = 0;
    //s->header[16];
    s->ptr = (unsigned int *) &s->header;
    s->user = NULL;
    s->host = "main";

    /* Epoll Initialization */
    int epfd = epoll_create(16);
    events = calloc(16, sizeof(struct epoll_event));
    ev.events = EPOLLIN;
    ev.data.fd = s->sock;
    epoll_ctl(epfd, EPOLL_CTL_ADD, s->sock, &ev);

    while(1)
    {
        if(mode == 0)
        {
incoming:
            if(!s->ssl)  //TODO: re-write everything here to use gettalk()
            {
                if(!s->multiplex)
                    size = read(s->sock, getbuffer, MAX_NAME_LEN);
                else
                {
                    if(len > MAX_NAME_LEN)
                    {
                        size = read(s->sock, getbuffer, MAX_NAME_LEN);
                        read(s->sock, netbuffer, len - MAX_NAME_LEN); //TODO: check overflow
                    }
                    size = read(s->sock, getbuffer, len);
                }
            }
            else
            {
                if(!s->multiplex)
                    size = SSL_read(s->ssl, getbuffer, MAX_NAME_LEN);
                else
                {
                    if(len > MAX_NAME_LEN)
                    {
                        size = SSL_read(s->ssl, getbuffer, MAX_NAME_LEN);
                        SSL_read(s->ssl, netbuffer, len - MAX_NAME_LEN); //TODO: check overflow
                    }
                    size = SSL_read(s->ssl, getbuffer, len);
                }
            }
        }

        
        if(size < 1)
        {
kill:
            if(s->ssl)
            {
                SSL_shutdown(s->ssl);
                SSL_free(s->ssl);
                SSL_CTX_free(s->contxt);
            }
            close(s->sock);
            close(outsock);
            close(epfd);
            free(getbuffer);
            free(buffer);
            free(netbuffer);
            free(events);
            free(check);
            printf("Client disconnected\n");
            return NULL;
        }

        printf("Parsing\n");
        service = parse(&offset, &size, getbuffer, buffer, s);

        if(service == (void *) -1)
            continue;

        /* Catch all and access denied */
        if(service == NULL)
        {
            talkback(s, "- No Such Service\r\n");
            if(mode)
                goto process;
            else
                continue;
        }

        if(service->service_type == HELP_SERVICE || service->service_type == LIST_SERVICE)
        {
            i = 0;
            response = calloc(BUFFER, sizeof(char));
            listservice = servicelist;
            while(listservice)
            {
                if((listservice->service_type == HELP_SERVICE || listservice->service_type == LIST_SERVICE))
                {
                    listservice = listservice->next;
                    continue;
                }
                if((listservice->service_type == SSL_SERVICE && s->ssl) || (listservice->service_type == MULTIPLEX_SERVICE && s->multiplex))
                {
                    listservice = listservice->next;
                    continue;
                }
                if(listservice->restrict_user != NULL)
                {
                    if(s->user == NULL || listservice->restrict_user == NULL)
                    {
                        listservice = listservice->next;
                        continue;
                    }
                    if(strcmp(s->user, listservice->restrict_user))
                    {
                        listservice = listservice->next;
                        continue;
                    }
                }
                if(listservice->restrict_host != NULL)
                {
                    if(s->host == NULL || listservice->restrict_host == NULL)
                    {
                        listservice = listservice->next;
                        continue;
                    }
                    if(strcmp(s->host, listservice->restrict_host))
                    {
                        listservice = listservice->next;
                        continue;
                    }
                }
                i += strlen(listservice->name) + 2;
                if(i > BUFFER)
                    response = realloc(response, i);
                strcat(response+i-(strlen(listservice->name)+2), listservice->name);
                response[i-1] = '\n';
                response[i-2] = '\r';
                listservice = listservice->next;
            }
            talkback_len(s, response, i);
            free(response);
            if(service->service_type == HELP_SERVICE)
                goto kill;
            if(mode)
                goto process;
            else
                continue;
        }

        if(service->service_type == MULTIPLEX_SERVICE)
        {
            if(s->multiplex)
            {
                talkback(s, "- No Such Service\r\n");
                if(mode)
                    goto process;
                else
                    continue;
            }
            talkback(s, "+ Success\r\n");
            s->multiplex = 1;
            mode = 1;
            /* Go into multiplex mode */
            send_header(s, 0, NEW_PLEX, 0);
        }

        if(service->service_type == SSL_SERVICE)
        {
            //TODO: OpenSSL is not re-entrant, care about that.
            if(s->ssl)
            {
                talkback(s, "- No Such Service\r\n");
                if(mode)
                    goto process;
                else
                    continue;
            }
            talkback(s, "+ Success\r\n");

            s->contxt = SSL_CTX_new(SSLv23_server_method());
            if(!s->contxt)
                printf("SSL_CTX_new failed\n");

            i = SSL_CTX_use_RSAPrivateKey_file(s->contxt, "/home/djc/projects/fived/fived_key.pem", SSL_FILETYPE_PEM);
            if(!i)
                printf("RSA Key Load Failed\n");

            i = SSL_CTX_use_certificate_file(s->contxt, "/home/djc/projects/fived/fived_cert.pem", SSL_FILETYPE_PEM);
            if(!i)
                printf("Cert Load Failed\n");

            SSL_CTX_set_quiet_shutdown(s->contxt, 1);

            s->ssl = SSL_new(s->contxt);
            if(!s->ssl)
                printf("SSL_new failed\n");

            i = SSL_set_fd(s->ssl, s->sock);
            if(!i)
                printf("SSL_set_fd failed\n");

            SSL_set_accept_state(s->ssl);
            i = SSL_accept(s->ssl);
            if(i < 1)
            {
                printf("SSL_accept failed\n");
                switch(SSL_get_error(s->ssl, i))
                {
                    case SSL_ERROR_NONE:
                        printf("no error\n");
                        break;
                    case SSL_ERROR_WANT_X509_LOOKUP:
                        printf("X509 error\n");
                        break;
                    case SSL_ERROR_SSL:
                        printf("You did something wrong\n");
                        break;
                    case SSL_ERROR_SYSCALL:
                        printf("Someone else did something wrong (syscall)\n");
                        break;
                    default:
                        printf("Idunnolol\n");
                        break;
                }
            }
        }

        /* Imagine the most minimalistic demo-driven auth service you could think of... this is a hair below that */
        if(service->service_type == AUTH_SERVICE)
        {
            talkback(s, "+ Success\r\nEnter Username: ");
            gettalk(s, check, 0); // username (TODO: unsafe)
            talkback(s, "Enter Password: ");
            gettalk(s, check, 0); // password (TODO: unsafe)
            if(!strncmp("demopass", check, 8))
            {
                s->user = "demo";
                talkback(s, "Authentication as demo successful\r\n");
            }
            else
            {
                talkback(s, "Authentication failed\r\n");
            }
        }

        if(service->service_type == HOST_SERVICE)
        {
            talkback(s, "+ Success\r\nWhich VHOST? ");
            gettalk(s, check, 0); // host (TODO: unsafe);
            if(!strncmp(check, "toys", 4))
            {
                s->host = "toys";
                talkback(s, "+ Success: Host changed to toys\r\n");
            }
            else if(!strncmp(check, "main", 4))
            {
                s->host = "main";
                talkback(s, "+ Success: Host changed to main\r\n");
            }
            else
            {
                talkback(s, "- Invalid hostname\r\n");
            }
        }

        if(service->service_type == CUSTOM_SERVICE)
        {
            // TODO: access control
            outsock = socket(PF_INET6, SOCK_STREAM, 0);
            error(outsock);
            i = connect(outsock, (const struct sockaddr *) service->info, sizeof(struct sockaddr_in6));
            error(i);

            /* Add to epoll() */
            ev.data.fd = outsock;
            i = epoll_ctl(epfd, EPOLL_CTL_ADD, outsock, &ev);
            error(i);
            printf("Adding fd %d to epoll\n", outsock);

            /* For multiplexing, or not */
            if(mode != 2)
                mode = 1;
            
            talkback(s, "+ Success\r\n");

            //TODO: Much more interesting things happen here during multiplexing
            if(s->multiplex)
                send_header(s, outsock, NEW_PLEX, 0);
        }

        goto deny;  //get rid of unused label warnings.
deny:
        /* Catch all and access denied */
        if(service == NULL)
            talkback(s, "- No Such Service\r\n");

process:
        if(mode == 1)
        {
            len = 0;
            while(1)
            {
                waiting = epoll_wait(epfd, events, 16, -1);
                error(waiting);
                for(i=0;i<waiting;i++)
                {
                    if(s->multiplex)
                    {
                        //printf("fd %d has an event\n", events[i].data.fd);
                        if(events[i].data.fd != s->sock)
                        {
                            len = read(events[i].data.fd, netbuffer, BUFFER);
                            if(len < 1)
                            {
                                send_header(s, events[i].data.fd, DEL_PLEX, 0);
                                epoll_ctl(epfd, EPOLL_CTL_DEL, events[i].data.fd, NULL);
                                continue;
                            }
                            send_header(s, events[i].data.fd, 0, len);
                            if(!s->ssl)
                                write(s->sock, netbuffer, len);
                            else
                                SSL_write(s->ssl, netbuffer, len);
                            continue;
                        }
                        if(!s->ssl)
                            len = read(s->sock, &s->header, 16);
                        else
                            len = SSL_read(s->ssl, &s->header, 16);
                        //printf("%x | %x | %x | %x\n", ntohl(s->ptr[0]), ntohl(s->ptr[1]), ntohl(s->ptr[2]), ntohl(s->ptr[3]));
                        //if(len < 1)
                        if(len != 16)
                            goto kill;
                        s->multiplex_xtra = ntohl(s->ptr[3]);
                        if(ntohl(s->ptr[1]) == 0 && ntohl(s->ptr[3]) != 0) //They're talking to tcpmux
                        {
                            if(ntohl(s->ptr[2]) != 0)
                                printf("Client is sending flags about id 0, something is wrong\n");
                            len = s->multiplex_xtra;
                            s->multiplex_xtra = 0; //TODO: revise this when you refactor the incoming module
                            goto incoming;
                        }
                        if(ntohl(s->ptr[2]) == DEL_PLEX)
                        {
                            close(ntohl(s->ptr[1])); //TODO: Yeah, we should actually have our own table and be verifying
                            continue;
                        }
                        while(s->multiplex_xtra != 0)
                        {
                            if(s->multiplex_xtra > BUFFER)
                                len = BUFFER;
                            else
                                len = s->multiplex_xtra;
                            if(!s->ssl)
                                len = read(s->sock, netbuffer, len);
                            else
                                len = SSL_read(s->ssl, netbuffer, len);
                            chk_error(write(ntohl(s->ptr[1]), netbuffer, len) != len);
                            //printf("Wrote %d bytes to fd %d\n", len, ntohl(s->ptr[1]));
                            s->multiplex_xtra -= len;
                        }
                        continue;
                    }
                    if(!s->ssl || events[i].data.fd != s->sock)
                        len = read(events[i].data.fd, netbuffer, BUFFER);
                    else
                        len = SSL_read(s->ssl, netbuffer, BUFFER);
                    if(len < 1)
                        goto kill;
                    if(events[i].data.fd == s->sock)
                        write(outsock, netbuffer, len);
                    else
                    {
                        if(!s->ssl)
                            write(s->sock, netbuffer, len);
                        else
                            SSL_write(s->ssl, netbuffer, len);
                    }
                }
            }
        }
    }

err:
    perror("Error");

    return NULL;
}

struct service * parse(size_t * offset, size_t * size, char * getbuffer, char * buffer, struct session * s)
{
    unsigned int i = 0;
    char * name;
    memcpy(buffer+(*offset), getbuffer, *size);
    *size += *offset;
    for(i = 0; i < *size; ++i)
    {
        if(buffer[i] == '\r' || buffer[i] == '\n')
            break;
    }
    
    /* So there's no newline in the entire message */
    if(i == *size)
    {
        *offset += *size - *offset;
        if(*offset > MAX_NAME_LEN)
            *offset = 0;
        return (struct service *) -1;  //Presumably not a value a pointer can have.
    }

    /* There's a valid name of some sort */
    name = calloc(i+1, sizeof(char));
    memcpy(name, buffer, i+1);
    name[i] = '\0'; //Replace \n or \r with null terminator
    if(i == *size - 1 || (i == *size - 2 && buffer[i+1] == '\n'))
        *offset = 0;
    else //There is remaining data left to parse.
    {
        if(i != *size-1)
        {
            if(buffer[i] == '\r' && buffer[i+1] == '\n')
            {
                *offset = i+2;
                memmove(buffer, buffer + i+2, *size - i+2);
            }
            else
            {
                *offset = i+1;
                memmove(buffer, buffer + i+1, *size - i+1);
            }
        }
        else
        {
            *offset = i+1;
            memmove(buffer, buffer + i+1, *size - i+1);
        }
    }

    //TODO, make syslog "attempt to request service x"
    printf("Service name is %s\n", name);

    struct service * current = servicelist;
    while(current)
    {
        if(current ->restrict_user != NULL)
        {
            if(s->user == NULL || current->restrict_user == NULL)
            {
                current = current->next;
                continue;
            }
            if(strcmp(s->user, current->restrict_user))
            {
                current = current->next;
                continue;
            }
        }
        if(current->restrict_host != NULL)
        {
            if(s->host == NULL || current->restrict_host == NULL)
            {
                current = current->next;
                continue;
            }
            if(strcmp(s->host, current->restrict_host))
            {
                current = current->next;
                continue;
            }
        }
        if(strncmp(current->name,name,MAX_NAME_LEN) == 0)
            return current;
        current = current->next;
    }

    return NULL;
}

void send_header(struct session * s, int id, int flags, int len)
{
    //printf("Sending to id %d len %d with flags %d\n", id, len, flags);
    char header[16];
    int * ptr = (int *) &header;
    ptr[0] = htonl(0);      //Version 0
    ptr[1] = htonl(id);     //Id
    ptr[2] = htonl(flags);  //Flags (1 for new, 2 for del, 0 for normal)  Rest reserved.
    ptr[3] = htonl(len);    //Next header
    if(s->ssl)
        SSL_write(s->ssl, &header, 16);
    else
        write(s->sock, &header, 16);
}

void talkback_len(struct session * s, char * msg, int length)
{
    if(s->multiplex)
        send_header(s, 0, 0, length);
    if(!s->ssl)
        write(s->sock, msg, length);
    else
        SSL_write(s->ssl, msg, length);
}

void talkback(struct session * s, char * msg)
{
    talkback_len(s, msg, strlen(msg));
}

int gettalk(struct session * s, char * buffer, int length)
{
    int len = 0;
    if(length == 0 || length > BUFFER)
        len = BUFFER;
    else
        len = length;

    if(s->multiplex && !s->multiplex_xtra)
    {
        if(!s->ssl)
        {
            chk_error(read(s->sock, &s->header, 16) != 16);
        }
        else
        {
            chk_error(SSL_read(s->ssl, &s->header, 16) != 16);
        }
        s->multiplex_xtra = ntohl(s->ptr[3]);
        if(s->multiplex_xtra <= len)
        {
            len = s->multiplex_xtra;
            s->multiplex_xtra = 0;
        }
        else
            s->multiplex_xtra = s->multiplex_xtra - len;
    }
    if(s->ssl)
        return SSL_read(s->ssl, buffer, len);
    else
        return read(s->sock, buffer, len);

err:
    printf("Failed get multiplexing header");
    return -1;
}