uws_http.c

#include <dirent.h>
#include <sys/stat.h>
#include <time.h>
#include "uws.h"
#include "uws_memory.h"
#include "uws_http.h"
#include "uws_utils.h"
#include "uws_config.h"
#include "uws_mime.h"
#include "uws_header.h"
#include "uws_status.h"
#include "uws_router.h"

struct response header_body;
static char* mime;

static char*
get_mime(const char* path)
{
    int i = 0;
    i = strlen(path);
    i--;
    while(*(path + i) != '.') {
        if(i == 0) {
            return uws_strdup("text/html");
            break;
        }
        i--;
    }
    if(i != 0){
        return mimebyext(path + i + 1);
    }
    return uws_strdup("text/html");
}
static void
set_header(pConnInfo conn_info) {
    char *time_string = get_time_string(NULL);
    conn_info->response_header->http_ver = "HTTP/1.1";
    conn_info->response_header->status_code = 200;
    conn_info->response_header->status = "OK";
    add_header_param("Cache-Control", "private", conn_info->response_header);
    add_header_param("Connection", "Keep-Alive", conn_info->response_header);
    add_header_param("Vary", "Accept-Encoding", conn_info->response_header);
    add_header_param("Server", UWS_SERVER, conn_info->response_header);
    add_header_param("Date", time_string, conn_info->response_header);

    char *len = itoa(header_body.content_len);
    add_header_param("Content-Length", len, conn_info->response_header);
    uws_free(len);

    add_header_param("Content-Type", mime, conn_info->response_header);
    header_body.header = conn_info->response_header;
    uws_free(time_string);
}

int
comparestr(const void *p1, const void *p2)
{
    return strcmp(* (char * const *)p1, * (char * const *) p2);
}
static void
printdir(const char *fpath, pConnInfo conn_info) {//打印目录项排序
    if(!conn_info->running_server->autoindex) {
        /*
         * error response
        conn_info->status_code = 403;
        apply_next_router(conn_info);
        return;
        */
    }

    DIR *dp = opendir(fpath);
    struct dirent *dir_entry;
    int dir_len = 0;
    char **entries;
    struct stat stat_buff;

    while((dir_entry = readdir(dp)) != NULL)
        dir_len++;

    header_body.content_len = dir_len * 64;//Max filename Length
    header_body.content = (char*) uws_malloc (header_body.content_len * sizeof(char));
    header_body.content[0] = 0;

    rewinddir(dp);
    entries = (char**) uws_malloc ((dir_len + 5) * sizeof(char*));
    dir_len = 0;
    //
    //判断是否是目录
    //
    
    while((dir_entry = readdir(dp)) != NULL) {
        char *newpath = (char*) uws_malloc(PATH_LEN * sizeof(char));//max filename length
        strcpy(newpath, fpath);

        entries[dir_len++] = dir_entry->d_name;

        //strcat(newpath, "/");
        strcat(newpath, dir_entry->d_name);
        lstat(newpath, &stat_buff);
        if(S_ISDIR(stat_buff.st_mode)) {
            strcat(entries[dir_len - 1], "/");
        }
        uws_free(newpath);
    }
    entries[dir_len] = NULL;
    qsort(entries, dir_len, sizeof(char*), comparestr);

    while(*(entries)!= NULL) {
        strcat(header_body.content, "<a href=\"");
        strcat(header_body.content, *entries);
        strcat(header_body.content, "\">");
        strcat(header_body.content, *(entries++));
        strcat(header_body.content, "</a><br/>\n");
    }
    header_body.content_len = strlen(header_body.content);
    closedir(dp);
}
static void
printfile(const char *path, pConnInfo conn_info)
{
    char *mod_time_str ;
    char *file_mod_time = get_file_time(path);
    if((mod_time_str = get_header_param("If-Modified-Since", conn_info->request_header))) {
        if(!is_expire(mod_time_str, file_mod_time)) {
            conn_info->status_code = 304;
            send_error_response(conn_info);
            return;
        }
    }

    FILE* file = fopen(path, "r");
    fseek(file, 0, SEEK_END);
    header_body.content_len = ftell(file);
    rewind(file);

    add_header_param("Last-Modified", file_mod_time, conn_info->response_header);
    uws_free(file_mod_time);

    header_body.content = (char*) uws_malloc (header_body.content_len * sizeof(char));
    size_t read_size = fread(header_body.content, sizeof(char), header_body.content_len, file);
    fclose(file);

}

int
http_router(pConnInfo conn_info) 
{
    if(conn_info->status_code != 0) send_error_response(conn_info);
    int sockfd = conn_info->clientfd;
    char path[PATH_LEN];
    struct stat stat_buff;
    int i = 0; 
    strcpy(path, conn_info->request_header->path);
    while(path[i] != 0) {
        if(path[i] == '?' || path[i] == '#') {
            path[i] = 0;
            break;
        }
        i++;
    }
    if(lstat(path, &stat_buff) != -1) {
        if( S_ISDIR(stat_buff.st_mode) ) {
            mime = uws_strdup("text/html");
            printdir(path, conn_info);
        }
        else
        {
            mime = get_mime(path);
            printfile(path, conn_info);
        }
    }
    else {
        conn_info->status_code = 404;
        send_error_response(conn_info);
        return;
    }

    set_header(conn_info);
    write_response(conn_info, &header_body);
    //uws_free(header_body.header);  sorry, reponse_header will be freed at the end of request
    uws_free(header_body.content);
    free_header_params(conn_info->response_header);
}


void send_error_response(pConnInfo conn_info) {/*{{{*/
    int status_code = conn_info->status_code;
    bool with_page;
    int return_page_status[4] = {404, 502, 500, 403};
    if(in_int_array(return_page_status, status_code, 4) != -1) {
        with_page = true;
    } else {
        with_page = false;
    }
    char** error_pages = conn_info->running_server->error_page;
    int i;
    char *error_path = NULL;
    char *error_file_path;
    conn_info->status_code = status_code;
    while(*error_pages != NULL) {
        for(i = 0; i < strlen(*error_pages); i++) {
            if((*error_pages)[i] == '=') {
                (*error_pages)[i] = '\0';
                if(atoi(*error_pages) == status_code) {
                    error_path = uws_strdup(*error_pages + i + 1);
                    (*error_pages)[i] = '=';
                    break;
                }
                (*error_pages)[i] = '=';
            }
        }
        if(error_path != NULL) break;
        error_pages++;
    }
    int content_len;
    char *content;
    if(with_page) {
        error_file_path  = uws_strdup("/dev/null"); //just for test
        if(error_path != NULL) {
            char *tmp_path = strlcat(conn_info->running_server->root, error_path);
            if(access(tmp_path, F_OK) == 0) {
                uws_free(error_file_path);
                error_file_path = tmp_path;
                uws_free(error_path);
            } else {
                uws_free(tmp_path);
            }
        }
        FILE* file = fopen(error_file_path, "r");
        fseek(file, 0, SEEK_END);
        content_len = ftell(file);
        rewind(file);
        content = (char*) uws_malloc (content_len * sizeof(char));

        size_t read_size = fread(content, sizeof(char), content_len, file);
        fclose(file);
    } else {
        content_len = 0;
        content = uws_strdup("");
    }

    //go here
    char *time_string = get_time_string(NULL);

    conn_info->response_header->http_ver = "HTTP/1.1";
    conn_info->response_header->status_code = status_code;
    conn_info->response_header->status = get_by_code(status_code);
    add_header_param("Cache-Control", "private", conn_info->response_header);
    add_header_param("Connection", "Keep-Alive", conn_info->response_header);
    add_header_param("Server", UWS_SERVER, conn_info->response_header);
    add_header_param("Date", time_string, conn_info->response_header);
    add_header_param("Content-Type", "text/html", conn_info->response_header);


    if(with_page) {
        char *content_len_str = itoa(content_len);
        add_header_param("Content-Length", content_len_str, conn_info->response_header);
        uws_free(content_len_str);
    }


    struct response header_body;

    header_body.header = conn_info->response_header;
    header_body.content = content;
    header_body.content_len = content_len;

    uws_free(time_string);
    write_response(conn_info, &header_body);
    free_header_params(header_body.header);
    //uws_free(header_body.header); don't free this!!
    uws_free(header_body.content);
    //longjmp(conn_info->error_jmp_buf, 1);
}/*}}}*/

char *get_by_code(int code) {
    int i = 0;
    for(; http_status[i].code != -1; ++i) {
        if(http_status[i].code == code) return http_status[i].message;
    }
    return http_status[i].message;
}

int write_response(pConnInfo conn_info, struct response* header_body) {/*{{{*/
    int res;
    setblocking(conn_info->clientfd);

    char *accept_encoding; 
    //compress--start--

    if((header_body->content_len > 0) &&
        uws_config.http.gzip && 
        in_str_array(uws_config.http.gzip_types, get_header_param("Content-Type", header_body->header)) >= 0 &&
        (accept_encoding = get_header_param("Accept-Encoding", conn_info->request_header)) &&
        strstr(accept_encoding, "gzip") != NULL
        ) {

        size_t src_len = header_body->content_len;
        size_t dst_len;
        char *dst_buff;
        gzcompress(&dst_buff, &dst_len, header_body->content, src_len);

        char *content_len = itoa(dst_len);
        add_header_param("Content-Length", content_len, header_body->header);
        uws_free(content_len);
        add_header_param("Content-Encoding", "gzip", header_body->header);
        uws_free(header_body->content);
        header_body->content = dst_buff;
        header_body->content_len = dst_len;
    }

    char* header_str = str_response_header(header_body->header);
    size_t header_len = strlen(header_str);

    res = write(conn_info->clientfd, header_str, header_len);
    uws_free(header_str);

    if(res == -1) return -1;
    res = write(conn_info->clientfd, HEADER_SEP, strlen(HEADER_SEP));
    if(res == -1) return -1;
    res = writen(conn_info->clientfd, header_body->content, header_body->content_len);
    if(res == -1) {return -1;}
    return 0;
}/*}}}*/