SpecialProxy/http.c

#include "http.h"
#include "dns.h"
#include "timeout.h"

#define SSL_RSP 270
#define SSL_RSP_CONNECT "HTTP/1.1 200 Connection established\r\nServer: SpecialProxy_CuteBi\r\nConnection: keep-alive\r\n\r\n"
#define SSL_RSP_HTTP "HTTP/1.1 200 OK\r\nContent-length: 99999999\r\nServer: SpecialProxy_CuteBi\r\nContent-Type: text/plain; charset=utf-8\r\nConnection: keep-alive\r\n\r\n"
#define SSL_RSP_WEBSOCKET "HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: SpecialProxy_CuteBi\r\n\r\n"
#define HTTP_TYPE 0
#define OTHER_TYPE 1

conn_t cts[MAX_CONNECTION];
char *local_header, *proxy_header, *ssl_proxy;
int lisFd, proxy_header_len, local_header_len, ignore_host_before_count;
uint8_t strict_spilce, sslEncodeCode;

/* 对数据进行编码 */
static void dataEncode(char *data, int data_len)
{
    if (sslEncodeCode)
        while (data_len-- > 0)
            data[data_len] ^= sslEncodeCode;
}

int8_t connectionToServer(in_addr_t ip, conn_t *server)
{
    struct sockaddr_in addr;

    server->fd = socket(AF_INET, SOCK_STREAM, 0);
    if (server->fd < 0)
        return 1;
    fcntl(server->fd, F_SETFL, O_NONBLOCK);
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = ip;
    addr.sin_port = htons(server->destPort);
    if (connect(server->fd, (struct sockaddr *)&addr, sizeof(addr)) != 0 && errno != EINPROGRESS)
        return 1;
    ev.data.ptr = server;
    ev.events = EPOLLIN|EPOLLOUT|EPOLLET;
    epoll_ctl(efd, EPOLL_CTL_ADD, server->fd, &ev);

    return 0;
}

void close_connection(conn_t *conn)
{
    epoll_ctl(efd, EPOLL_CTL_DEL, conn->fd, NULL);
    close(conn->fd);
    if ((conn - cts) & 1)
    {
        char *server_data;

        server_data = conn->ready_data;
        memset(conn, 0, sizeof(conn_t));
        conn->ready_data = server_data;
        conn-- ->fd = -1;
    }
    else
    {
        struct dns *d;

        d =  dns_list + ((conn - cts) >> 1);
        d->request_len = d->sent_len = 0;
        free(conn->ready_data);
        free(conn->incomplete_data);
        memset(conn, 0, sizeof(conn_t));
        conn++ ->fd = -1;
    }
    if (conn->fd >= 0)
        close_connection(conn);

}


/* 判断请求类型 */
static int8_t request_type(char *data)
{
    if (strncmp(data, "GET", 3) == 0 ||
    strncmp(data, "POST", 4) == 0 ||
    strncmp(data, "CONNECT", 7) == 0 ||
    strncmp(data, "HEAD", 4) == 0 ||
    strncmp(data, "PUT", 3) == 0 ||
    strncmp(data, "OPTIONS", 7) == 0 ||
    strncmp(data, "MOVE", 4) == 0 ||
    strncmp(data, "COPY", 4) == 0 ||
    strncmp(data, "TRACE", 5) == 0 ||
    strncmp(data, "DELETE", 6) == 0 ||
    strncmp(data, "LINK", 4) == 0 ||
    strncmp(data, "UNLINK", 6) == 0 ||
    strncmp(data, "PATCH", 5) == 0 ||
    strncmp(data, "WRAPPED", 7) == 0)
        return HTTP_TYPE;
    return OTHER_TYPE;
}

static char *read_data(conn_t *in, char *data, int *data_len)
{
    char *new_data;
    int read_len;

    do {
        new_data = (char *)realloc(data, *data_len + BUFFER_SIZE + 1);
        if (new_data == NULL)
        {
            free(data);
            return NULL;
        }
        data = new_data;
        read_len = read(in->fd, data + *data_len, BUFFER_SIZE);
        dataEncode(data, read_len);
        /* 判断是否关闭连接 */
        if (read_len <= 0)
        {
            if (read_len == 0 || *data_len == 0 || errno != EAGAIN)
            {
                free(data);
                return NULL;
            }
            break;
        }
        *data_len += read_len;
    } while (read_len == BUFFER_SIZE);
    *(data + *data_len) = '\0';

   return data;
}

static char *get_host(char *data)
{
    char *hostEnd, *host;
    int i;

    host = strstr(data, local_header);
    if (host != NULL)
    {
        char *local_host;

        host += local_header_len;
        while (*host == ' ' || *host == '\t')
            host++;
        for (hostEnd = host; *hostEnd < 58 && *hostEnd > 48; hostEnd++);
        //判断该头域是否正确使用
        if (hostEnd - host > 5 || *hostEnd != '\r')
            return NULL;
        local_host = (char *)malloc(16);
        if (local_host == NULL)
            return NULL;
        strcpy(local_host, "127.0.0.1:");
        memcpy(local_host + 10, host, hostEnd - host);
        local_host[10 + (hostEnd - host)] = '\0';
        return local_host;
    }
    host= strstr(data, proxy_header);
    if (host == NULL)
        return NULL;
    host += proxy_header_len;
    while (*host == ' ' || *host == '\t')
        host++;
    for (i = 0; i < ignore_host_before_count; i++)
        if (host[i] == '\0')  //防止越界
            break;
    host += i;
    hostEnd = strchr(host, '\r');
    return hostEnd ? strndup(host, hostEnd - host) : strdup(host);
}

/* 删除请求头中的头域 */
static void del_hdr(char *header, int *header_len)
{
    char *line_begin, *line_end;

    for (line_begin = strchr(header, '\n'); line_begin++ && *line_begin != '\r'; line_begin = line_end)
    {
        line_end = strchr(line_begin, '\n');
        if (strncasecmp(line_begin, "host:", 5) == 0 || strncasecmp(line_begin, local_header + 1, local_header_len - 1) == 0 || strncasecmp(line_begin, proxy_header + 1, proxy_header_len - 1) == 0)
        {
            if (line_end++)
            {
                memmove(line_begin, line_end, *header_len - (line_end - header) + 1);
                (*header_len) -= line_end - line_begin;
                line_end = line_begin - 1;  //新行前一个字符
            }
            else
            {
                *line_begin = '\0';
                *header_len = line_begin - header;
                return;
            }
        }
    }
}

/* 构建新请求头 */
static char *build_request(char *client_data, int *data_len, char *host)
{
    char *uri, *url, *p, *lf, *header, *new_data, *proxy_host;
    int len;

    header = client_data;
    proxy_host = host;
    do {
        del_hdr(client_data, data_len);
        /* 将完整url转换为uri */
        url = strchr(header, ' ');
        lf = strchr(header, '\n');
        if (url == NULL || lf == NULL || lf - 10 <= header)
            return client_data;
        if (url < lf && *(++url) != '/')
        {
            uri = strchr(url + 7, '/');
            p = lf - 10;  //指向HTTP版本前面的空格
            if (uri != NULL && uri < p)
            {
                memmove(url, uri, *data_len - (uri - client_data) + 1);
                *data_len -= uri - url;
                lf -= uri - url;
            }
            else
            {
                *url++ = '/';
                memmove(url, p, *data_len - (p - client_data) + 1);
                *data_len -= p - url;
                lf -= p - url;
            }
        }

        *data_len += strlen(proxy_host) + 8;  //8为 "Host: " + "\r\n"的长度
        new_data = (char *)malloc(*data_len  + 1);
        if (new_data == NULL)
        {
            if (proxy_host != host)
                free(proxy_host);
            free(client_data);
            return NULL;
        }
        /* 请求行后面添加Host行 */
        len = lf + 1 - client_data;
        memcpy(new_data, client_data, len);  //复制请求行
        strcpy(new_data + len, "Host: ");
        strcpy(new_data + len + 6, proxy_host);
        len += strlen(proxy_host) + 6;
        new_data[len++] = '\r';
        new_data[len++] = '\n';
        //len += sprintf(new_data + len, "Host: %s\r\n", proxy_host);
        memcpy(new_data + len, lf + 1, *data_len - len + 1);
        free(client_data);
        if (proxy_host != host)
            free(proxy_host);
        if (strict_spilce == 0)
            return new_data;
        client_data = new_data;
        //如果请求头只有一个头域，则必须-1才能搜索到\n\r
        header = strstr(client_data + len - 1, "\n\r");
        //如果是连续的多个请求头，则全部修改
        if (header == NULL || request_type(header + 3) == OTHER_TYPE)
            return client_data;
        header += 3;
        proxy_host = get_host(header);
        if (proxy_host == NULL)
            proxy_host = host;
    } while (1);
}

/* 解析Host */
static int8_t parse_host(conn_t *server, char *host)
{
    char *port, *p;

    port = strchr(host, ':');
    if (port)
    {
        server->destPort = atoi(port+1);
        *port = '\0';
    }
    else
        server->destPort = 80;  //默认80端口
    for (p = host; (*p > 47 && *p < 58) || *p == '.'; p++);
    if (*p == '\0')
    {
        if (connectionToServer(inet_addr(host), server) != 0)
            return 1;
    }
    else if (build_dns_req(dns_list + ((server - cts) >> 1), host) == -1)
        return 1;
    if (port)
        *port = ':';

    return 0;
}

/* 读取到的数据全部就绪，将incomplete_data复制到ready_data */
static int8_t copy_data(conn_t *ct)
{
    //dataEncode(ct->incomplete_data, ct->incomplete_data_len);
    if (ct->ready_data)
    {
        char *new_data;

        new_data = (char *)realloc(ct->ready_data, ct->ready_data_len + ct->incomplete_data_len);
        if (new_data == NULL)
            return 1;
        ct->ready_data = new_data;
        memcpy(new_data + ct->ready_data_len, ct->incomplete_data, ct->incomplete_data_len);
        ct->ready_data_len += ct->incomplete_data_len;
        free(ct->incomplete_data);
    }
    else
    {
        ct->ready_data = ct->incomplete_data;
        ct->ready_data_len = ct->incomplete_data_len;
    }
    ct->incomplete_data = NULL;
    ct->incomplete_data_len = 0;

    return 0;
}

static void serverToClient(conn_t *server)
{
    conn_t *client;
    int write_len;

    client = server - 1;
    while ((server->ready_data_len = read(server->fd, server->ready_data, BUFFER_SIZE)) > 0)
    {
        dataEncode(server->ready_data, server->ready_data_len);
        write_len = write(client->fd, server->ready_data, server->ready_data_len);
        if (write_len <= 0)
        {
            if (write_len == 0 || errno != EAGAIN)
                close_connection(server);
            else
                server->sent_len = 0;
            return;
        }
        else if (write_len < server->ready_data_len)
        {
            server->sent_len = write_len;
            ev.events = EPOLLIN|EPOLLOUT|EPOLLET;
            ev.data.ptr = client;
            epoll_ctl(efd, EPOLL_CTL_MOD, client->fd, &ev);
            return;
        }
        if (server->ready_data_len < BUFFER_SIZE)
            break;
    }
    //判断是否关闭连接
    if (server->ready_data_len == 0 || (server->ready_data_len == -1 && errno != EAGAIN))
        close_connection(server);
    else
        server->ready_data_len = server->sent_len = 0;
}

/* ssl代理回应 */
static int respond_sslStatus(conn_t *in)
{
    /*
        可能客户端使用http请求伪装CONNECT代理
        这时候即使fd是非阻塞也只需要判断返回值是否小于0
        正常情况非阻塞也可以全部发送，懒得写代码了
    */
    char buffer[SSL_RSP];
    
    if (memcmp(in->incomplete_data, "CON", 3) == 0)
    {
        memset(buffer, 0, SSL_RSP);
        memcpy(buffer, SSL_RSP_CONNECT, sizeof(SSL_RSP_CONNECT)-1);
        dataEncode(buffer, sizeof(SSL_RSP_CONNECT)-1);
        return (write(in->fd, buffer, sizeof(SSL_RSP_CONNECT)-1) <= 0);
    }
    else if (*in->incomplete_data == 'G' && (strstr(in->incomplete_data, "websocket") || strstr(in->incomplete_data, "WebSocket")))
    {
        memset(buffer, 0, SSL_RSP);
        memcpy(buffer, SSL_RSP_WEBSOCKET, sizeof(SSL_RSP_WEBSOCKET)-1);
        return (write(in->fd, buffer, sizeof(SSL_RSP_WEBSOCKET)-1) <= 0);
    }
    
    memset(buffer, 0, SSL_RSP);
    memcpy(buffer, SSL_RSP_HTTP, sizeof(SSL_RSP_HTTP)-1);
    return (write(in->fd, SSL_RSP_HTTP, sizeof(SSL_RSP_HTTP)-1) <= 0);
}

void tcp_in(conn_t *in)
{
    conn_t *server;
    char *host, *headerEnd;

    if (in->fd < 0)
        return;
    //如果in - cts是奇数，那么是服务端触发事件
    if ((in - cts) & 1)
    {
        in->timer = (in-1)->timer = 0;
        if (in->ready_data_len <= 0)
            serverToClient(in);
        return;
    }

    in->timer = (in+1)->timer = 0;
    in->incomplete_data = read_data(in, in->incomplete_data, &in->incomplete_data_len);
    if (in->incomplete_data == NULL)
    {
        close_connection(in);
        return;
    }
    server = in + 1;
    server->request_type = in->request_type = request_type(in->incomplete_data);
    if (in->request_type == OTHER_TYPE)
    {
        //如果是第一次读取数据，并且不是HTTP请求的，关闭连接。复制数据失败的也关闭连接
        if (in->reread_data == 0 || copy_data(in) != 0)
        {
            close_connection(in);
            return;
        }
        goto handle_data_complete;
    }
    headerEnd = strstr(in->incomplete_data, "\n\r");
    //请求头不完整，等待下次读取
    if (headerEnd == NULL)
        return;
    host = get_host(in->incomplete_data);
    if (host == NULL)
    {
        close_connection(in);
        return;
    }

    //dataEncode(host, strlen(host));
    // 第一次读取数据
    if (in->reread_data == 0)
    {
        // 打印HTTP HEAD
        //printf("%s", in->incomplete_data);
        in->reread_data = 1;
        if (parse_host(server, host) != 0)
        {
            free(host);
            close_connection(in);
            return;
        }
        if (strstr(in->incomplete_data, ssl_proxy))
        {
            if (respond_sslStatus(in) != 0)
            {
                free(host);
                close_connection(in);
                return;
            }
            headerEnd += 3;
            if (headerEnd - in->incomplete_data < in->incomplete_data_len)
            {
                in->incomplete_data_len -= headerEnd - in->incomplete_data;
                memmove(in->incomplete_data, headerEnd, in->incomplete_data_len + 1);
                if (request_type(in->incomplete_data) == OTHER_TYPE)
                {
                    copy_data(in);
                    free(host);
                    return;
                }
            }
            else
            {
                free(in->incomplete_data);
                in->incomplete_data = NULL;
                in->incomplete_data_len = 0;
                free(host);
                return;
            }
        }
    }
    in->incomplete_data = build_request(in->incomplete_data, &in->incomplete_data_len, host);
    free(host);
    
    if (in->incomplete_data == NULL || copy_data(in) != 0)
    {
        close_connection(in);
        return;
    }
    // 数据处理完毕，可以发送
    handle_data_complete:
    // 这个判断是防止 多次读取客户端数据，但是没有和服务端建立连接，导致报错
    if (server->fd >= 0)
        tcp_out(server);
}

void tcp_out(conn_t *to)
{
    conn_t *from;
    int write_len;

    if (to->fd == -1)
        return;
    else if ((to - cts) & 1)
        from = to - 1;
    else
        from = to + 1;
    from->timer = to->timer = 0;
    write_len = write(to->fd, from->ready_data + from->sent_len, from->ready_data_len - from->sent_len);
    if (write_len == from->ready_data_len - from->sent_len)
    {
        //服务端的数据可能没全部写入到客户端
        if ((from - cts) & 1)
        {
            serverToClient(from);
            if (from->fd >= 0 && from->ready_data_len == 0)
            {
                ev.events = EPOLLIN|EPOLLET;
                ev.data.ptr = to;
                epoll_ctl(efd, EPOLL_CTL_MOD, to->fd, &ev);
            }
        }
        else
        {
            ev.events = EPOLLIN|EPOLLET;
            ev.data.ptr = to;
            epoll_ctl(efd, EPOLL_CTL_MOD, to->fd, &ev);
            free(from->ready_data);
            from->ready_data = NULL;
            from->ready_data_len = 0;
        }
    }
    else if (write_len > 0)
    {
        from->sent_len += write_len;
        ev.events = EPOLLIN|EPOLLOUT|EPOLLET;
        ev.data.ptr = to;
        epoll_ctl(efd, EPOLL_CTL_MOD, to->fd, &ev);
    }
    else if (errno != EAGAIN)
    {
        close_connection(to);
    }
}

void accept_client()
{
    struct epoll_event epollEvent;
    struct sockaddr_in addr;
    conn_t *client;
    socklen_t addr_len = sizeof(addr);

    /* 偶数为客户端，奇数为服务端 */
    for (client = cts; client - cts < MAX_CONNECTION; client += 2)
        if (client->fd < 0)
            break;
    if (client - cts >= MAX_CONNECTION)
        return;
    client->timer = (client+1)->timer = 0;
    client->fd = accept(lisFd, (struct sockaddr *)&addr, &addr_len);
    if (client->fd < 0)
        return;
    fcntl(client->fd, F_SETFL, O_NONBLOCK);
    epollEvent.events = EPOLLIN|EPOLLET;
    epollEvent.data.ptr = client;
    epoll_ctl(efd, EPOLL_CTL_ADD, client->fd, &epollEvent);
}

void create_listen(char *ip, int port)
{
    struct sockaddr_in addr;
    int optval = 1;

    if ((lisFd = socket(AF_INET, SOCK_STREAM, 0)) < 0)
    {
        perror("socket");
        exit(1);
    }
    addr.sin_family = AF_INET;
    addr.sin_port = htons(port);
    addr.sin_addr.s_addr = inet_addr(ip);
    if (setsockopt(lisFd, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(optval)) < 0)
    {
        perror("setsockopt");
        exit(1);
    }
    if (bind(lisFd, (struct sockaddr *)&addr, sizeof(addr)) != 0)
    {
        perror("bind");
        exit(1);
    }
    if (listen(lisFd, 500) != 0)
    {
        perror("listen");
        exit(1);
    }
}