#include "http_request.h"

void errors(const char *error_info)

{

fprintf(stderr, "%s\n\n", error_info);

exit(1);

}

int8_t copy_new_mem(char *src, int src_len, char **dest)

{

*dest = (char *)malloc(src_len + 1);

if (*dest == NULL)

return 1;

memcpy(*dest, src, src_len);

*((*dest) + src_len) = '\0';

return 0;

}

char *replace(char *replace_memory, int *replace_memory_len, const char *src, const int src_len, const char *dest, const int dest_len)

{

if (!replace_memory || !src || !dest)

return replace_memory;

char *p;

int diff;

if (src_len == dest_len) {

for (p = memmem(replace_memory, *replace_memory_len, src, src_len); p; p = memmem(p, *replace_memory_len - (p - replace_memory), src, src_len)) {

memcpy(p, dest, dest_len);

p += dest_len;

}

} else if (src_len < dest_len) {

int before_len;

char *before_end, *new_replace_memory;

diff = dest_len - src_len;

for (p = memmem(replace_memory, *replace_memory_len, src, src_len); p; p = memmem(p, *replace_memory_len - (p - replace_memory), src, src_len)) {

*replace_memory_len += diff;

before_len = p - replace_memory;

new_replace_memory = (char *)realloc(replace_memory, *replace_memory_len + 1);

if (new_replace_memory == NULL) {

free(replace_memory);

return NULL;

}

replace_memory = new_replace_memory;

before_end = replace_memory + before_len;

p = before_end + dest_len;

memmove(p, p - diff, *replace_memory_len - (p - replace_memory));

memcpy(before_end, dest, dest_len);

}

} else if (src_len > dest_len) {

diff = src_len - dest_len;

for (p = memmem(replace_memory, *replace_memory_len, src, src_len); p; p = memmem(p, *replace_memory_len - (p - replace_memory), src, src_len)) {

*replace_memory_len -= diff;

memcpy(p, dest, dest_len);

p += dest_len;

memmove(p, p + diff, *replace_memory_len - (p - replace_memory));

}

}

replace_memory[*replace_memory_len] = '\0';

return replace_memory;

}

static char *regrep(char *str, int *str_len, const char *src, char *dest, int dest_len)

{

if (!str || !src || !dest)

return NULL;

regmatch_t pm[10];

regex_t reg;

char child_num[2] = { '\\', '0' }, *p, *real_dest;

int match_len, real_dest_len, i;

p = str;

regcomp(&reg, src, REG_NEWLINE | REG_ICASE | REG_EXTENDED);

while (regexec(&reg, p, 10, pm, 0) == 0) {

real_dest = (char *)malloc(dest_len);

if (real_dest == NULL) {

regfree(&reg);

free(str);

return NULL;

}

memcpy(real_dest, dest, dest_len);

real_dest_len = dest_len;

//不进行不必要的字符串操作

if (pm[1].rm_so >= 0) {

/* 替换目标字符串中的子表达式 */

for (i = 1; i < 10 && pm[i].rm_so > -1; i++) {

child_num[1] = i + 48;

real_dest = replace(real_dest, &real_dest_len, child_num, 2, p + pm[i].rm_so, pm[i].rm_eo - pm[i].rm_so);

if (real_dest == NULL) {

regfree(&reg);

free(str);

return NULL;

}

}

}

match_len = pm[0].rm_eo - pm[0].rm_so;

p += pm[0].rm_so;

//目标字符串不大于匹配字符串则不用分配新内存

if (match_len >= real_dest_len) {

memcpy(p, real_dest, real_dest_len);

if (match_len > real_dest_len)

//strcpy(p + real_dest_len, p + match_len);

memmove(p + real_dest_len, p + match_len, *str_len - (p + match_len - str));

p += real_dest_len;

*str_len -= match_len - real_dest_len;

} else {

int diff;

char *before_end, *new_str;

diff = real_dest_len - match_len;

*str_len += diff;

new_str = (char *)realloc(str, *str_len + 1);

if (new_str == NULL) {

free(str);

free(real_dest);

regfree(&reg);

return NULL;

}

str = new_str;

before_end = str + pm[0].rm_so;

p = before_end + real_dest_len;

memmove(p, p - diff, *str_len - (p - str) + 1);

memcpy(before_end, real_dest, real_dest_len);

}

free(real_dest);

}

regfree(&reg);

return str;

}

int extract_host(char *header, char *host, char *port)

{

char *_p = strstr(header, "CONNECT"); // 在 CONNECT 方法中解析 隧道主机名称及端口号

if (_p) {

if (strchr(header, '[') || strchr(header, ']')) { // IPv6

char *_p1 = strchr(header, '[');

char *_p2 = strchr(_p1 + 1, ']');

memcpy(host, _p1 + 1, (int)(_p2 - _p1) - 1);

char *_p3 = strchr(_p2 + 1, ' ');

memcpy(port, _p2 + 2, (int)(_p3 - _p2) - 1);

return 0;

}

char *_p1 = strchr(_p, ' ');

char *_p2 = strchr(_p1 + 1, ':');

char *_p3 = strchr(_p1 + 1, ' ');

if (_p2) {

memcpy(host, _p1 + 1, (int)(_p2 - _p1) - 1);

memcpy(port, _p2 + 1, (int)(_p3 - _p2) - 1);

} else { // 如果_p2等于空就返回-1

return -1;

}

return 0;

} else {

char *_p = strstr(header, "Host:");

if (_p == NULL) {

_p = strstr(header, "host:");

}

if (_p == NULL) { // 都为空时

return -1;

}

char *_p1 = strchr(_p, '\n'); // 指向末尾'\n'

if (!_p1) {

return -1;

}

char *_p2 = strchr(_p + 5, ':'); // 5是指'Host:'的长度

int h_len = (int)(_p1 - _p - 6);

char s_host[h_len];

memcpy(s_host, _p + 6, _p1 - _p - 6);

s_host[h_len] = '\0';

char *_p3 = strchr(s_host, ':');

char *_p4 = NULL;

if (_p3)

_p4 = strchr(_p3 + 1, ':'); // 二次确认':'

{ // IPV6

if (_p4 != NULL) {

char *_p5 = NULL;

char *_p6 = NULL;

_p5 = strchr(header, ' ');

if (_p5)

_p6 = strchr(_p5 + 1, ' ');

char url[_p6 - _p5 - 1];

memset(url, 0, _p6 - _p5 - 1);

memcpy(url, _p5 + 1, _p6 - _p5 - 1);

url[_p6 - _p5 - 1] = '\0';

if (strstr(url, "http") != NULL) { // 去除 'http://'

memcpy(url, url + 7, (_p6 - _p5 - 1) - 7);

url[(_p6 - _p5 - 1) - 7] = '\0';

char *_p7 = strchr(url, '/');

if (_p7) // 去除 uri

url[_p7 - url] = '\0';

char *_p8 = strchr(url, ']');

char *_p9 = strchr(url, '\0');

if (_p8) {

if ((_p9 - _p8) == 1) { // 如果不带端口就默认80, 并结束

memcpy(port, "80", 2);

memcpy(host, url + 1, _p8 - (url + 1));

return 0;

}

memcpy(port, _p8 + 2, _p9 - (_p8 + 2));

memcpy(host, url + 1, _p8 - (url + 1));

}

return 0;

} else { // HTTP头为不规范的url时处理Host, 主要Proxifier转发url为'/'时

//printf("s_host: %s\n", s_host);

char *_p1 = strchr(s_host, '[');

if (_p1 == NULL) // 涉及到自定义的Host, 不带'['、']'时, 默认截取最后为端口

{

char *_p2 = strrchr(s_host, ':');

remote_port = atoi(_p2 + 1);

memcpy(remote_host, s_host, _p2 - s_host);

return 0;

}

char *_p2 = strchr(_p1 + 1, ']');

char *_p3 = strchr(s_host, '\0');

if (_p1 && _p2) {

memcpy(host, _p1 + 1, _p2 - _p1 - 1);

if ((_p3-(_p2+1)) < 2) {

memcpy(port, "80", 2);

} else {

memcpy(port, _p2 + 2, _p3 - (_p2 + 2));

}

}

return 0;

}

return -1;

}

}

// HTTP 非 CONNECT 方法

{

if (_p2 && _p2 < _p1) { // 带端口, p2指向':', p1指向末尾'\n', _p指向Host

memcpy(port, _p2 + 1, (int)(_p1 - _p2 - 1));

memcpy(host, _p + 5 + 1, (int)(_p2 - _p - 5 - 1));

} else { // 不带端口

if (0 < (int)(_p1 - _p - 5 - 1 - 1)) {

memcpy(host, _p + 5 + 1, (_p1 - _p - 5 - 1 - 1));

memcpy(port, "80", 2);

} else {

memcpy(host, _p + 5 + 1, (_p1 - _p) - 6);

memcpy(port, "80", 2);

}

}

}

return 0;

}

return 0;

}

char *get_http_path(char *url, int url_len, char *path)

{

char *_p0, *_p1;

_p0 = _p1 = NULL;

_p1 = strchr(url, '\0');

if (url_len > 7) {

if (url) {

_p0 = strstr(url + 7, "/");

if (_p0)

return memcpy(path, _p0, _p1 - _p0);

else

return memcpy(path, "/", 1); // 如果没有资源路径就默认"/"

}

} else {

return memcpy(path, "/", 1);

}

return NULL;

}

void get_http_host_port_len(char *head, int *host_len, int *port_len)

{

*host_len = 0;

*port_len = 0;

char *_p1 = strstr(head, "Host"); // 判断Host行

if (_p1) { // 为真时

char *_p2 = strstr(_p1, "\n");

*host_len = (int)(_p2 - _p1);

char host[*host_len + 1];

memcpy(host, _p1, *host_len);

host[*host_len] = '\0';

char *_p3 = strrchr(host, ':');

char *_p4 = strchr(host, '\0');

if (_p3) {

*port_len = _p4 - (_p3 + 1);

} else {

*port_len = *host_len;

}

} else { // 为假时

char *_p1 = strstr(head, "host");

if (_p1) {

char *_p2 = strstr(_p1, "\n");

*host_len = (int)(_p2 - _p1);

char host[*host_len + 1];

memcpy(host, _p1, *host_len);

host[*host_len] = '\0';

char *_p3 = strrchr(host, ':');

char *_p4 = strchr(host, '\0');

if (_p3) {

*port_len = _p4 - (_p3 + 1);

} else {

*port_len = *host_len;

}

} else { // 未找到时使用HTTP_HEAD_CACHE_SIZE大小

*host_len = HTTP_HEAD_HOST_CACHE_SIZE;

*port_len = HTTP_HEAD_HOST_CACHE_SIZE / 10;

}

}

return;

}

void free_http_request(struct http_request *http_request)

{

if (http_request->method)

free(http_request->method);

if (http_request->U)

free(http_request->U);

if (http_request->version)

free(http_request->version);

if (http_request->host)

free(http_request->host);

if (http_request->port)

free(http_request->port);

if (http_request->H)

free(http_request->H);

if (http_request->url)

free(http_request->url);

if (http_request->uri)

free(http_request->uri);

}

void parse_request_head(char *http_request_line, struct http_request *http_request)

{

char *p, *head, *m, *u;

size_t head_len;

int host_len, port_len, uri_len;

host_len = port_len = uri_len = 0;

p = strstr(http_request_line, "\r\n"); // 查找"\r\n"

if (p == NULL) {

return;

}

head_len = p - http_request_line;

head = (char *)malloc(sizeof(char) * head_len + 1);

if (head == NULL)

free(head);

memset(head, 0, sizeof(char) * head_len + 1);

memcpy(head, http_request_line, head_len);

http_request->method = (char *)malloc(sizeof(char) * 8);

http_request->U = (char *)malloc(sizeof(char) * head_len);

http_request->version = (char *)malloc(10);

if (http_request->method == NULL)

perror("malloc");

if (http_request->U == NULL)

perror("malloc");

if (http_request->version == NULL)

perror("malloc");

memset(http_request->method, 0, 8);

memset(http_request->U, 0, sizeof(char) * head_len);

memset(http_request->version, 0, 10);

m = strchr(head, ' ');

http_request->method_len = m - head;

memmove(http_request->method, head, http_request->method_len);

u = strchr(m + 1, ' ');

memmove(http_request->U, m + 1, u - (m + 1));

http_request->U_len = u - (m + 1);

memmove(http_request->version, u + 1, 8);

http_request->version_len = 8;

// 获取Host、Port长度

get_http_host_port_len(http_request_line, &host_len, &port_len);

// URI LENGTH

char *_p0 = strstr(http_request->U, "http://");

if (_p0) { // 标准头

char *_p1 = strchr(http_request->U + 7, '/');

char *_p2 = strchr(http_request->U + 7, '\0');

if (_p1) {

uri_len = _p2 - _p1;

}

} else { // 非标准头

char *_p1 = strchr(http_request->U, '/');

char *_p2 = strchr(http_request->U, '\0');

if (_p1) {

uri_len = _p2 - _p1;

} else {

uri_len = 1; // 没有uri时

}

}

http_request->host = (char *)malloc(sizeof(char) * host_len + 1);

if (http_request->host == NULL)

perror("malloc");

http_request->port = (char *)malloc(sizeof(char) * port_len + 1);

if (http_request->port == NULL)

perror("malloc");

http_request->url = (char *)malloc(sizeof(char) * http_request->U_len + 1);

if (http_request->url == NULL)

perror("malloc");

http_request->uri = (char *)malloc(sizeof(char) * uri_len + 1);

if (http_request->uri == NULL)

perror("malloc");

http_request->H = (char *)malloc(sizeof(char) * host_len + port_len + 1);

if (http_request->H == NULL)

perror("malloc");

memset(http_request->host, 0, host_len + 1);

memset(http_request->port, 0, port_len + 1);

memset(http_request->url, 0, http_request->U_len + 1);

memset(http_request->uri, 0, uri_len + 1);

memset(http_request->H, 0, host_len + port_len + 1);

if (extract_host(http_request_line, http_request->host, http_request->port) == -1)

return;

http_request->host_len = (int)strlen(http_request->host);

http_request->port_len = (int)strlen(http_request->port);

memcpy(http_request->H, http_request->host, http_request->host_len);

strncat(http_request->H, ":", 2);

strncat(http_request->H, http_request->port, http_request->port_len);

memcpy(http_request->url, http_request->U, http_request->U_len);

http_request->url_len = http_request->U_len;

if (get_http_path(http_request->url, http_request->url_len, http_request->uri) == NULL)

return;

http_request->uri_len = uri_len;

http_request->H_len = http_request->host_len + http_request->port_len + 1;

free(head);

return;

}

static char *splice_head(char *head, int *head_len, const char *needle, char *string, int string_len)

{

char *tail_head;

char *_p0;

char *_p1;

_p1 = strstr(head, needle);

if (_p1 == NULL) {

return head;

}

_p1 = _p1 + 1;

_p0 = strchr(_p1, '\0');

tail_head = (char *)alloca((_p0 - _p1) + 1);

if (tail_head == NULL) {

perror("alloca");

return head;

}

memset(tail_head, 0, (_p0 - _p1) + 1);

memcpy(tail_head, _p1, (_p0 - _p1));

memset(head, 0, *head_len);

memcpy(head, string, string_len);

strncat(head, tail_head, (_p0 - _p1));

*head_len = string_len + (_p0 - _p1);

return head;

}

static char *delete_head(char *head, int *head_len, const char *needle, int string)

{

char *temp_stack;

char *_p1, *_p2, *_p3;

_p1 = _p2 = _p3 = NULL;

int temp_stack_len;

_p1 = strstr(head, needle); // _p1指向head字符串中的"needle"字符处(needle字符串的第一个字符)

if (_p1 == NULL) {

//perror("_p1 HEAD NULL");

return head;

}

_p2 = strchr(_p1, string); // _p2指向head字符串中"string"字符到末尾中的'\0'

if (_p2 == NULL) {

//perror("_p2 HEAD NULL");

return head;

}

_p3 = strchr(_p1, '\0'); // _p3指向head字符串末尾的'\0'

if (_p3 == NULL) {

//perror("_p3 HEAD NULL");

return head;

}

temp_stack_len = (_p1 - head) + (_p3 - _p2);

temp_stack = (char *)alloca(temp_stack_len + 1); // 分配临时栈内存，长度是去除needle到string处

if (temp_stack == NULL) {

perror("alloca");

return head;

}

memset(temp_stack, 0, temp_stack_len + 1);

memmove(temp_stack, head, (_p1 - head) - 1);

strncat(temp_stack, _p2, _p3 - _p2);

memset(head, 0, *head_len);

*head_len = temp_stack_len;

return memmove(head, temp_stack, temp_stack_len);

}

static char *conf_handle_strrep(char *str, int *str_len, tcp * temp)

{

tcp *p = temp;

while (p) {

if (p->strrep) {

str = replace(str, str_len, p->strrep_s, p->strrep_s_len, p->strrep_t, p->strrep_t_len);

}

p = p->next;

}

return str;

}

static char *conf_handle_regrep(char *str, int *str_len, tcp * temp)

{

tcp *p = temp;

while (p) {

if (p->regrep) {

str = regrep(str, str_len, p->regrep_s, p->regrep_t, p->regrep_t_len);

}

p = p->next;

}

return str;

}

char *request_head(conn_t * in, conf * configure)

{

char *result = NULL;

char *delim = ",";

char *saveptr = NULL;

char *incomplete_head = NULL;

int incomplete_head_len = 0;

int return_val = 0;

struct http_request *http_request;

http_request = (struct http_request *)malloc(sizeof(struct http_request));

memset(http_request, 0, sizeof(struct http_request));

parse_request_head(in->incomplete_data, http_request);

if ((return_val = strncmp(in->incomplete_data, "CONNECT", 7)) == 0) {

sslEncodeCode = configure->https_encode;

char https_del_copy[configure->https_del_len + 1];

memset(remote_host, 0, CACHE_SIZE);

if (configure->https_port > 0) {

remote_port = configure->https_port;

}

if (configure->https_ip != NULL) {

memcpy(remote_host, configure->https_ip, configure->https_ip_len);

}

incomplete_head = (char *)malloc(sizeof(char) * (BUFFER_SIZE));

if (incomplete_head == NULL) {

free(incomplete_head);

perror("malloc");

}

memset(incomplete_head, 0, sizeof(char) * (BUFFER_SIZE));

memmove(incomplete_head, in->incomplete_data, in->incomplete_data_len);

memmove(https_del_copy, configure->https_del, configure->https_del_len + 1);

result = strtok_r(https_del_copy, delim, &saveptr);

while (result != NULL) {

delete_head(incomplete_head, &in->incomplete_data_len, result, '\n');

result = strtok_r(NULL, delim, &saveptr);

}

splice_head(incomplete_head, &in->incomplete_data_len, "\n", configure->https_first, configure->https_first_len);

incomplete_head_len = in->incomplete_data_len; // 更新HTTPS HEADER长度

incomplete_head = conf_handle_strrep(incomplete_head, &incomplete_head_len, https_head_strrep);

incomplete_head = conf_handle_regrep(incomplete_head, &incomplete_head_len, https_head_regrep);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[M]", 3, http_request->method, http_request->method_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[method]", 8, http_request->method, http_request->method_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[U]", 3, http_request->U, http_request->U_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[V]", 3, http_request->version, http_request->version_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[version]", 9, http_request->version, http_request->version_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[host]", 6, http_request->host, http_request->host_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[port]", 6, http_request->port, http_request->port_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[H]", 3, http_request->H, http_request->H_len);

printf("%s", incomplete_head); // 打印HTTPS HEADER

char *new_incomplete_data;

new_incomplete_data = (char *)realloc(in->incomplete_data, incomplete_head_len + 1);

if (new_incomplete_data == NULL) {

free(in->incomplete_data);

perror("realloc");

return in->incomplete_data;

}

in->incomplete_data = new_incomplete_data;

memset(in->incomplete_data, 0, incomplete_head_len + 1); // 清空incomplete_data数据

memmove(in->incomplete_data, incomplete_head, incomplete_head_len); // 更新incomplete_data数据

in->incomplete_data_len = incomplete_head_len; // 更新incomplete_data长度

free(incomplete_head); // 释放incomplete_head内存

}

if (strncmp(in->incomplete_data, "GET", 3) == 0 || strncmp(in->incomplete_data, "POST", 4) == 0) {

sslEncodeCode = configure->http_encode;

char http_del_copy[configure->http_del_len + 1];

memset(remote_host, 0, CACHE_SIZE);

if (configure->http_port > 0) {

remote_port = configure->http_port;

}

if (configure->http_ip != NULL) {

memcpy(remote_host, configure->http_ip, configure->http_ip_len);

}

incomplete_head = (char *)malloc(sizeof(char) * (BUFFER_SIZE));

if (incomplete_head == NULL) {

perror("malloc");

free(incomplete_head);

}

memset(incomplete_head, 0, sizeof(char) * (BUFFER_SIZE));

memmove(incomplete_head, in->incomplete_data, in->incomplete_data_len);

memmove(http_del_copy, configure->http_del, configure->http_del_len + 1);

result = strtok_r(http_del_copy, delim, &saveptr);

while (result != NULL) {

delete_head(incomplete_head, &in->incomplete_data_len, result, '\n');

result = strtok_r(NULL, delim, &saveptr);

}

splice_head(incomplete_head, &in->incomplete_data_len, "\n", configure->http_first, configure->http_first_len);

incomplete_head_len = in->incomplete_data_len; // 更新HTTP HEADER长度

incomplete_head = conf_handle_strrep(incomplete_head, &incomplete_head_len, http_head_strrep);

incomplete_head = conf_handle_regrep(incomplete_head, &incomplete_head_len, http_head_regrep);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[M]", 3, http_request->method, http_request->method_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[method]", 8, http_request->method, http_request->method_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[U]", 3, http_request->U, http_request->U_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[V]", 3, http_request->version, http_request->version_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[version]", 9, http_request->version, http_request->version_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[url]", 5, http_request->url, http_request->url_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[uri]", 5, http_request->uri, http_request->uri_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[host]", 6, http_request->host, http_request->host_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[port]", 6, http_request->port, http_request->port_len);

incomplete_head = replace(incomplete_head, &incomplete_head_len, "[H]", 3, http_request->H, http_request->H_len);

printf("%s", incomplete_head); // 打印HTTP HEADER

char *new_incomplete_data;

new_incomplete_data = (char *)realloc(in->incomplete_data, incomplete_head_len + 1);

if (new_incomplete_data == NULL) {

free(in->incomplete_data);

perror("realloc");

return in->incomplete_data;

}

in->incomplete_data = new_incomplete_data;

memset(in->incomplete_data, 0, incomplete_head_len + 1); // 清空incomplete_data数据

memmove(in->incomplete_data, incomplete_head, incomplete_head_len); // 更新incomplete_data数据

in->incomplete_data_len = incomplete_head_len; // 更新incomplete_data长度

free(incomplete_head); // 释放incomplete_head内存

}

free_http_request(http_request);

free(http_request);

return in->incomplete_data;

}