#include "http.h" #include "dns.h" #define SSL_RSP "HTTP/1.1 200 Connection established\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; uint8_t strict_spilce; /* 有时候由于程序代码原因glibc的memcpy不能src + len > dst,调试起来比较麻烦 这个函数正是为了解决这样的问题,但是效率会比memcpy低 */ #ifdef XMEMCPY typedef struct byte256 {char data[256];} byte256_t; typedef struct byte64 {char data[64];} byte64_t; typedef struct byte16 {char data[16];} byte16_t; static void xmemcpy(char *src, const char *dst, size_t len) { static byte256_t *to256, *from256; static byte64_t *to64, *from64; static byte16_t *to16, *from16; to256 = (byte256_t *)src; from256 = (byte256_t *)dst; while (len >= sizeof(byte256_t)) { *to256++ = *from256++; len -= sizeof(byte256_t); } to64 = (byte64_t *)to256; from64 = (byte64_t *)from256; while (len >= sizeof(byte64_t)) { *to64++ = *from64++; len -= sizeof(byte64_t); } to16 = (byte16_t *)to64; from16 = (byte16_t *)from64; while (len >= sizeof(byte16_t)) { *to16++ = *from16++; len -= sizeof(byte16_t); } src = (char *)to16; dst = (char *)from16; while (len--) *src++ = *dst++; } #else #define xmemcpy memcpy #endif int8_t connectionToServer(char *ip, conn_t *server) { server->fd = socket(AF_INET, SOCK_STREAM, 0); if (server->fd < 0) return 1; fcntl(server->fd, F_SETFL, fcntl(server->fd, F_GETFL)|O_NONBLOCK); addr.sin_addr.s_addr = inet_addr(ip); addr.sin_port = htons(server->destPort); connect(server->fd, (struct sockaddr *)&addr, sizeof(addr)); 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) { static char *server_data; server_data = conn->ready_data; memset(conn, 0, sizeof(conn_t)); conn->ready_data = server_data; conn-- ->fd = -1; } else { static 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) { static char *new_data; static 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); /* 判断是否关闭连接 */ 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) { static char *hostEnd, *host; host = strstr(data, local_header); if (host != NULL) { static char *local_host; host += local_header_len; while (*host == ' ') 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:"); strncpy(local_host + 10, host, hostEnd - host); local_host[10 + (hostEnd - host)] = '\0'; puts(local_host); return local_host; } host= strstr(data, proxy_header); if (host == NULL) return NULL; host += proxy_header_len; while (*host == ' ') host++; hostEnd = strchr(host, '\r'); if (hostEnd) return strndup(host, hostEnd - host); else return strdup(host); } /* 删除请求头中的头域 */ static void del_hdr(char *header, int *header_len) { static char *key_end, *line_begin, *line_end; static int key_len; for (line_begin = strchr(header, '\n'); line_begin++ && *line_begin != '\r'; line_begin = line_end) { key_end = strchr(line_begin, ':'); if (key_end == NULL) return; key_len = key_end - line_begin; line_end = strchr(key_end, '\n'); if (strncasecmp(line_begin, "host", key_len) == 0 || strncmp(line_begin, local_header + 1, key_len) == 0 || strncmp(line_begin, proxy_header + 1, key_len) == 0) { if (line_end++) { xmemcpy(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) { static char *uri, *url, *p, *lf, *header, *new_data, *proxy_host; static 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) { xmemcpy(url, uri, *data_len - (uri - client_data) + 1); *data_len -= uri - url; lf -= uri - url; } else { *url++ = '/'; xmemcpy(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 */ int8_t parse_host(conn_t *server, char *host) { static 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(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) { if (ct->ready_data) { static 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) { static conn_t *client; static int write_len; client = server - 1; while ((server->ready_data_len = read(server->fd, server->ready_data, BUFFER_SIZE)) > 0) { write_len = write(client->fd, server->ready_data, server->ready_data_len); if (write_len == -1) { if (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 == 0 || errno != EAGAIN) close_connection(server); else server->ready_data_len = server->sent_len = 0; } void tcp_out(conn_t *to) { static conn_t *from; static int write_len; if (to->fd == -1) return; else if ((to - cts) & 1) from = to - 1; else from = to + 1; 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); } return; } 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 tcp_in(conn_t *in) { static int write_len; static conn_t *server; static char *host, *headerEnd; if (in->fd < 0) return; //如果in - cts是奇数,那么是服务端触发事件 if ((in - cts) & 1) { if (in->ready_data_len == 0) serverToClient(in); return; } 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; if (request_type(in->incomplete_data) == 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; } /* 第一次读取数据 */ if (in->reread_data == 0) { in->reread_data = 1; if (parse_host(server, host) != 0) { free(host); close_connection(in); return; } if (strstr(in->incomplete_data, ssl_proxy)) { write_len = write(in->fd, SSL_RSP, 39); if (write_len == 39) { ; } else if (write_len > 0) { memcpy(server->ready_data, SSL_RSP + write_len, 39 - write_len); } else { 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; xmemcpy(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 *accept_loop(void *ptr) { conn_t *client; while (1) { /* 偶数为客户端,奇数为服务端 */ for (client = cts; client - cts < MAX_CONNECTION; client += 2) if (client->fd < 0) break; if (client - cts >= MAX_CONNECTION) { sleep(3); continue; } client->fd = accept(lisFd, (struct sockaddr *)&addr, &addr_len); if (client->fd >= 0) { fcntl(client->fd, F_SETFL, fcntl(client->fd, F_GETFL)|O_NONBLOCK); ev.data.ptr = client; ev.events = EPOLLIN|EPOLLET; epoll_ctl(efd, EPOLL_CTL_ADD, client->fd, &ev); } } return NULL; } void create_listen(char *ip, int port) { int optval = 1; if ((lisFd = socket(AF_INET, SOCK_STREAM, 0)) < 0) { perror("socket"); exit(1); } 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); } }