CProxy/httpdns.c

607 lines
19 KiB
C
Executable File
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

#include <sys/wait.h>
#include <sys/stat.h>
#include "httpdns.h"
#include "http_request.h"
#define DNS_MAX_CONCURRENT 512
#define DNS_REQUEST_MAX_SIZE 512+2 //2是TCPDNS头部用于指定dns的长度
#define HTTP_RSP_SIZE 2048
/*
缓存结构: (dns查询请求长度-2)(2字节) + dns原查询请求(删除2字节的dnsID) + dns回应长度(2字节) + dns回应
*/
struct dns_cache {
char *dns_cache;
struct dns_cache *next;
};
typedef struct dns_connection {
char dns_req[DNS_REQUEST_MAX_SIZE + 1];
struct sockaddr_in src_addr;
char *out_request;
char *host;
int out_request_len, fd, timer;
/*
sent_CONNECT_len:
在使用SSL代理的情况下与httpDNS的CONNECT请求长度对比
小于表示需要发送CONNECT请求并且还没有发送完成
等于表示已经完成CONNECT连接
大于表示已发送完成CONNECT连接但是没有读取CONNECT的回应包
*/
int sent_CONNECT_len;
uint16_t dns_req_len;
char query_type;
unsigned host_len:7;
} dns_t;
static dns_t dns_list[DNS_MAX_CONCURRENT];
static struct epoll_event dns_evs[DNS_MAX_CONCURRENT + 1], dns_ev;
struct httpdns httpdns;
static int dns_efd;
/* 缓存变量 */
FILE *cfp = NULL;
static struct dns_cache *cache = NULL;
static int cache_using;
//子进程先写入缓存,再到父进程写入,否则可能导致缓存文件错乱
pid_t child_pid = 0;
/* 读取缓存文件 */
int8_t read_cache_file()
{
char *buff, *cache_ptr;
struct dns_cache *cache_temp;
long file_size;
int len, fl=0;
cache_temp = NULL;
cache_using = 0;
if ((cfp = fopen(httpdns.cachePath, "r+")) == NULL) {
//创建文件并设置权限
if ((cfp = fopen(httpdns.cachePath, "w")) != NULL) {
chmod(httpdns.cachePath, S_IWOTH | S_IROTH | S_IWGRP | S_IRGRP | S_IWUSR | S_IRUSR);
fclose(cfp);
return 0;
}
return 1;
}
//读取文件内容
fseek(cfp, 0, SEEK_END);
file_size = ftell(cfp);
if ((buff = (char *)alloca(file_size)) == NULL)
return 1;
rewind(cfp);
if ((fl = fread(buff, file_size, 1, cfp)) != 1)
;
fclose(cfp);
for (cache_ptr = buff; cache_ptr - buff < file_size; cache_ptr += len) {
cache_temp = (struct dns_cache *)malloc(sizeof(struct dns_cache));
if (cache_temp == NULL)
return 1;
cache_temp->next = cache;
cache = cache_temp;
cache_using++;
len = *(uint16_t *) cache_ptr + *(uint16_t *) (cache_ptr + *(uint16_t *) cache_ptr + 2) + 4;
copy_new_mem(cache_ptr, len, &cache->dns_cache);
if (cache->dns_cache == NULL)
return 1;
}
/* 删除重复记录 */
struct dns_cache *before, *after;
for (; cache_temp; cache_temp = cache_temp->next) {
for (before = cache_temp; before && (after = before->next) != NULL; before = before->next) {
if (*(uint16_t *) after->dns_cache == *(uint16_t *) cache_temp->dns_cache && memcmp(after->dns_cache + 2, cache_temp->dns_cache + 2, *(uint16_t *) after->dns_cache) == 0) {
before->next = after->next;
free(after->dns_cache);
free(after);
cache_using--;
}
}
}
chmod(httpdns.cachePath, S_IWOTH | S_IROTH | S_IWGRP | S_IRGRP | S_IWUSR | S_IRUSR);
return 0;
}
/* 程序结束时将缓存写入文件 */
static void write_dns_cache(int sig)
{
//子进程先写入缓存
if (child_pid) {
wait(NULL);
cfp = fopen(httpdns.cachePath, "a");
} else {
cfp = fopen(httpdns.cachePath, "w");
}
while (cache) {
fwrite(cache->dns_cache, *(uint16_t *) cache->dns_cache + *(uint16_t *) (cache->dns_cache + *(uint16_t *) cache->dns_cache + 2) + 4, 1, cfp);
cache = cache->next;
}
exit(0);
}
static void dnsProxyStop(dns_t * dns)
{
epoll_ctl(dns_efd, EPOLL_CTL_DEL, dns->fd, NULL);
close(dns->fd);
if (httpdns.tcpDNS_mode == 0)
free(dns->out_request);
memset(((char *)dns) + DNS_REQUEST_MAX_SIZE + sizeof(struct sockaddr_in), 0, sizeof(dns_t) - DNS_REQUEST_MAX_SIZE + -sizeof(struct sockaddr_in));
dns->fd = -1;
}
/* 查询缓存 */
static uint8_t cache_lookup(dns_t * dns)
{
struct dns_cache *c;
char *rsp;
for (c = cache; c; c = c->next) {
//不匹配dnsID
if (dns->dns_req_len - 2 == *(uint16_t *) c->dns_cache && memcmp(dns->dns_req + 2, c->dns_cache + 2, dns->dns_req_len - 2) == 0) {
rsp = c->dns_cache + *(uint16_t *) c->dns_cache + 2;
*(uint16_t *) (rsp + 2) = *(uint16_t *) dns->dns_req; //设置dns id
sendto(global.dns_listen_fd, rsp + 2, *(uint16_t *) rsp, 0, (struct sockaddr *)&dns->src_addr, sizeof(struct sockaddr_in));
return 0;
}
}
return 1;
}
/* 记录缓存 */
static void cache_record(char *request, uint16_t request_len, char *response, uint16_t response_len)
{
struct dns_cache *cache_temp;
cache_temp = (struct dns_cache *)malloc(sizeof(struct dns_cache));
if (cache_temp == NULL)
return;
cache_temp->dns_cache = (char *)malloc(request_len + response_len + 2);
if (cache_temp->dns_cache == NULL) {
free(cache_temp);
return;
}
cache_temp->next = cache;
cache = cache_temp;
//不缓存dnsid
request += 2;
request_len -= 2;
memcpy(cache_temp->dns_cache, &request_len, 2);
memcpy(cache_temp->dns_cache + 2, request, request_len);
memcpy(cache_temp->dns_cache + request_len + 2, &response_len, 2);
memcpy(cache_temp->dns_cache + request_len + 4, response, response_len);
if (httpdns.cacheLimit) {
//到达缓存记录条目限制则释放前一半缓存
if (cache_using >= httpdns.cacheLimit) {
struct dns_cache *free_c;
int i;
for (i = cache_using = httpdns.cacheLimit >> 1; i--; cache_temp = cache_temp->next) ;
for (free_c = cache_temp->next, cache_temp->next = NULL; free_c; free_c = cache_temp) {
cache_temp = free_c->next;
free(free_c->dns_cache);
free(free_c);
}
}
cache_using++;
}
}
/* 分析DNS请求 */
static int8_t parse_dns_request(char *dns_req, dns_t * dns)
{
int len;
dns_req += 13; //跳到域名部分
dns->host_len = strlen(dns_req);
dns->query_type = *(dns_req + 2 + dns->host_len);
//tcpdns不需要解析域名
if (httpdns.tcpDNS_mode == 1)
return 0;
//httpdns只支持域名查询ipv4
if (dns->query_type != 1 || (dns->host = strdup(dns_req)) == NULL)
return 1;
for (len = *(--dns_req); dns_req[len + 1] != 0; len += dns_req[len]) {
//防止数组越界
if (len > dns->host_len) {
free(dns->host);
return 1;
}
dns->host[len++] = '.';
}
return 0;
}
/* 回应dns客户端 */
static int8_t httpDNS_respond_client(dns_t * dns, char *rspIp)
{
static char rsp[DNS_REQUEST_MAX_SIZE + 16];
char *p;
int rsp_len;
//18: 查询资源的前(12字节)后(6字节)部分
rsp_len = 18 + dns->host_len + (rspIp ? 16 : 0);
//判断是否超出缓冲大小
if (rsp_len > DNS_REQUEST_MAX_SIZE) {
dns->query_type = 0;
return 1;
}
/* dns ID */
memcpy(rsp, dns->dns_req, 2);
/* 问题数 */
rsp[4] = 0;
rsp[5] = 1;
/* 资源记录数 */
rsp[6] = 0;
rsp[7] = 0;
/* 授权资源记录数 */
rsp[8] = 0;
rsp[9] = 0;
/* 额外资源记录数 */
rsp[10] = 0;
rsp[11] = 0;
memcpy(rsp + 12, dns->dns_req + 12, dns->host_len + 6);
/* 如果有回应内容(资源记录) */
if (rspIp) {
p = rsp + 18 + dns->host_len;
/* 资源记录数+1 */
rsp[7]++;
/* 成功标志 */
rsp[2] = (char)133;
rsp[3] = (char)128;
/* 指向主机域名 */
p[0] = (char)192;
p[1] = 12;
/* 回应类型 */
p[2] = 0;
p[3] = dns->query_type;
/* 区域类别 */
p[4] = 0;
p[5] = 1;
/* 生存时间 (1 ora) */
p[6] = 0;
p[7] = 0;
p[8] = 14;
p[9] = 16;
/* 回应长度 */
p[10] = 0;
p[11] = 4;
memcpy(p + 12, rspIp, 4);
} else {
/* 失败标志 */
rsp[2] = (char)129;
rsp[3] = (char)130;
}
//因为UDP是无连接协议所以不做返回值判断
sendto(global.dns_listen_fd, rsp, rsp_len, 0, (struct sockaddr *)&dns->src_addr, sizeof(struct sockaddr_in));
dns->query_type = 0; //表示结构体空闲
if (cfp && rspIp)
cache_record(dns->dns_req, dns->dns_req_len, rsp, rsp_len);
return 0;
}
void dns_timeout_check()
{
int i;
for (i = 0; i < DNS_MAX_CONCURRENT; i++) {
if (dns_list[i].fd > -1) {
if (dns_list[i].timer >= global.timeout_m) {
dnsProxyStop(dns_list + i);
} else {
dns_list[i].timer++;
}
}
}
}
static void http_out(dns_t * out)
{
int write_len;
out->timer = 0;
if (httpdns.connect_request && out->sent_CONNECT_len < httpdns.connect_request_len) {
write_len = write(out->fd, httpdns.connect_request + out->sent_CONNECT_len, httpdns.connect_request_len - out->sent_CONNECT_len);
if (write_len == -1) {
dnsProxyStop(out);
} else {
out->sent_CONNECT_len += write_len;
if (out->sent_CONNECT_len == httpdns.connect_request_len) {
out->sent_CONNECT_len++; //表示已完全发送CONNECT请求等待HTTP回应
dns_ev.events = EPOLLIN | EPOLLET;
dns_ev.data.ptr = out;
epoll_ctl(dns_efd, EPOLL_CTL_MOD, out->fd, &dns_ev);
}
}
return;
}
write_len = write(out->fd, out->out_request, out->out_request_len);
if (write_len == out->out_request_len) {
dns_ev.events = EPOLLIN | EPOLLET;
dns_ev.data.ptr = out;
epoll_ctl(dns_efd, EPOLL_CTL_MOD, out->fd, &dns_ev);
} else if (write_len > 0) {
out->out_request_len -= write_len;
memmove(out->out_request, out->out_request + write_len, out->out_request_len);
} else {
epoll_ctl(dns_efd, EPOLL_CTL_DEL, out->fd, NULL);
close(out->fd);
out->query_type = 0;
}
}
static void handle_httpDNS_rsp(dns_t * dns, char *rsp, int rsp_len)
{
char *ip_ptr, *p, ip[4];
int i;
p = strstr(rsp, "\n\r");
if (p) {
p += 3;
rsp_len -= p - rsp;
//部分代理服务器使用长连接第二次读取数据才读到域名的IP
if (rsp_len <= 0)
return;
rsp = p;
}
if (httpdns.encodeCode)
dataEncode(rsp, rsp_len, httpdns.encodeCode);
do {
if (*rsp == '\n')
rsp++;
/* 匹配IP */
while ((*rsp > 57 || *rsp < 49) && *rsp != '\0')
rsp++;
for (i = 0, ip_ptr = rsp, rsp = strchr(ip_ptr, '.');; ip_ptr = rsp + 1, rsp = strchr(ip_ptr, '.')) {
if (i < 3) {
if (rsp == NULL) {
httpDNS_respond_client(dns, NULL);
return;
}
//查找下一行
if (rsp - ip_ptr > 3)
break;
ip[i++] = atoi(ip_ptr);
} else {
ip[3] = atoi(ip_ptr);
httpDNS_respond_client(dns, ip);
return;
}
}
} while ((rsp = strchr(rsp, '\n')) != NULL);
}
static void handle_tcpDNS_rsp(dns_t * dns, char *rsp, int rsp_len)
{
/* 转换为UDPdns请求(为什么不做长度判断?因为懒) */
rsp += 2;
rsp_len -= 2;
//回应客户端
sendto(global.dns_listen_fd, rsp, rsp_len, 0, (struct sockaddr *)&dns->src_addr, sizeof(struct sockaddr_in));
if (cfp && (unsigned char)rsp[3] == 128) {
//如果使用编码则需要还原dns请求
if (httpdns.httpsProxy_encodeCode)
dataEncode(dns->dns_req + 2 /* 换成TCPDNS请求时原本请求后移动了2字节 */ , dns->dns_req_len, httpdns.httpsProxy_encodeCode);
cache_record(dns->dns_req + 2, dns->dns_req_len, rsp, (uint16_t) rsp_len);
}
}
static void http_in(dns_t * in)
{
static char http_rsp[HTTP_RSP_SIZE + 1];
int len;
in->timer = 0;
if (httpdns.connect_request && in->sent_CONNECT_len > httpdns.connect_request_len) {
in->sent_CONNECT_len--;
do {
len = read(in->fd, http_rsp, HTTP_RSP_SIZE);
//没有数据读取CONNECT代理连接完成
if (len < 0 && errno == EAGAIN)
break;
if (len <= 0) {
dnsProxyStop(in);
return;
}
} while (len == HTTP_RSP_SIZE);
dns_ev.events = EPOLLIN | EPOLLOUT | EPOLLET;
dns_ev.data.ptr = in;
epoll_ctl(dns_efd, EPOLL_CTL_MOD, in->fd, &dns_ev);
return;
}
len = read(in->fd, http_rsp, HTTP_RSP_SIZE);
if (len <= 0) {
if (len == 0 || errno != EAGAIN)
dnsProxyStop(in);
return;
}
http_rsp[len] = '\0';
if (httpdns.httpsProxy_encodeCode)
dataEncode(http_rsp, len, httpdns.httpsProxy_encodeCode);
if (httpdns.tcpDNS_mode == 1) {
handle_tcpDNS_rsp(in, http_rsp, len);
} else {
handle_httpDNS_rsp(in, http_rsp, len);
}
dnsProxyStop(in);
}
static int8_t create_outRequest(dns_t * dns)
{
if (parse_dns_request(dns->dns_req, dns) != 0) {
dns->out_request = NULL;
return 1;
}
if (httpdns.tcpDNS_mode == 1) {
memmove(dns->dns_req + 2, dns->dns_req, dns->dns_req_len);
dns->dns_req[0] = *((char *)(&dns->dns_req_len) + 1);
dns->dns_req[1] = *((char *)&dns->dns_req_len);
dns->out_request = dns->dns_req;
dns->out_request_len = dns->dns_req_len + 2;
dns->host = NULL;
/*
//调试用
int i;
printf("(");
for (i=0;i<dns->out_request_len;i++)
printf("%u ", dns->out_request[i]);
puts(")");
*/
} else {
if (httpdns.encodeCode)
dataEncode(dns->host, dns->host_len, httpdns.encodeCode);
dns->out_request_len = httpdns.http_req_len;
copy_new_mem(httpdns.http_req, httpdns.http_req_len, &dns->out_request);
dns->out_request = replace(dns->out_request, &dns->out_request_len, "[D]", 3, dns->host, dns->host_len);
free(dns->host);
if (dns->out_request == NULL)
return 1;
}
if (httpdns.httpsProxy_encodeCode)
dataEncode(dns->out_request, dns->out_request_len, httpdns.httpsProxy_encodeCode);
dns->sent_CONNECT_len = 0;
return 0;
}
/* 连接到dns服务器 */
static int connectToDnsServer(dns_t * dns)
{
dns->fd = socket(AF_INET, SOCK_STREAM, 0);
if (dns->fd < 0)
return 1;
dns->timer = 0; //超时计时器设为0
fcntl(dns->fd, F_SETFL, O_NONBLOCK);
dns_ev.events = EPOLLERR | EPOLLOUT | EPOLLET;
dns_ev.data.ptr = dns;
if (epoll_ctl(dns_efd, EPOLL_CTL_ADD, dns->fd, &dns_ev) != 0) {
close(dns->fd);
return 1;
}
if (connect(dns->fd, (struct sockaddr *)&httpdns.dst, sizeof(httpdns.dst)) != 0 && errno != EINPROGRESS) {
epoll_ctl(dns_efd, EPOLL_CTL_DEL, dns->fd, NULL);
close(dns->fd);
return 1;
}
return 0;
}
static void new_client()
{
dns_t *dns;
socklen_t addr_len = sizeof(struct sockaddr_in);
int i, len;
for (i = 0; i < DNS_MAX_CONCURRENT; i++) {
if (dns_list[i].query_type == 0) {
dns = &dns_list[i];
break;
}
}
if (i == DNS_MAX_CONCURRENT)
return;
len = recvfrom(global.dns_listen_fd, dns->dns_req, DNS_REQUEST_MAX_SIZE - 2, 0, (struct sockaddr *)&dns->src_addr, &addr_len);
//dns请求必须大于18
if (len <= 18)
return;
dns->dns_req_len = (uint16_t) len;
/* 查询缓存 */
if (cfp && cache_lookup(dns) == 0)
return;
if (create_outRequest(dns) != 0 || connectToDnsServer(dns) != 0) {
if (dns->out_request != dns->dns_req)
free(dns->out_request);
httpDNS_respond_client(dns, NULL);
}
}
static void httpRequest_init()
{
char dest[22];
uint16_t port;
port = ntohs(httpdns.dst.sin_port);
sprintf(dest, "%s:%u", inet_ntoa(httpdns.dst.sin_addr), port);
//如果设置http_req = "";则不创建请求头
if (httpdns.http_req_len > 0) {
httpdns.http_req_len = strlen(httpdns.http_req);
httpdns.http_req_len += 2;
httpdns.http_req = (char *)realloc(httpdns.http_req, httpdns.http_req_len + 1);
if (httpdns.http_req == NULL)
printf("out of memory.\n");
strcat(httpdns.http_req, "\r\n");
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[V]", 3, "HTTP/1.1", 8);
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[H]", 3, dest, strlen(dest));
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "\\0", 2, "\0", 1);
if (httpdns.tcpDNS_mode == 0) {
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[M]", 3, "GET", 3);
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[url]", 5, "/d?dn=[D]", 9);
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[U]", 3, "/d?dn=[D]", 9);
if (httpdns.http_req == NULL)
printf("out of memory.\n");
} else {
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[M]", 3, "CONNECT", 7);
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[url]", 5, "/", 1);
httpdns.http_req = replace(httpdns.http_req, &httpdns.http_req_len, "[U]", 3, "/", 1);
if (httpdns.http_req == NULL)
printf("out of memory.\n");
httpdns.connect_request = httpdns.http_req;
httpdns.connect_request_len = httpdns.http_req_len;
httpdns.http_req = NULL;
}
}
}
void dns_init()
{
httpRequest_init();
dns_efd = epoll_create(DNS_MAX_CONCURRENT + 1);
if (dns_efd < 0) {
perror("epoll_create");
exit(1);
}
fcntl(global.dns_listen_fd, F_SETFL, O_NONBLOCK);
dns_ev.data.fd = global.dns_listen_fd;
dns_ev.events = EPOLLIN;
epoll_ctl(dns_efd, EPOLL_CTL_ADD, global.dns_listen_fd, &dns_ev);
memset(dns_list, 0, sizeof(dns_list));
//程序关闭时写入dns缓存
if (cfp) {
signal(SIGTERM, write_dns_cache);
signal(SIGHUP, write_dns_cache);
signal(SIGINT, write_dns_cache);
signal(SIGABRT, write_dns_cache);
signal(SIGILL, write_dns_cache);
signal(SIGSEGV, write_dns_cache);
}
}
void *dns_loop(void *nullPtr)
{
int n;
while (1) {
n = epoll_wait(dns_efd, dns_evs, DNS_MAX_CONCURRENT + 1, -1);
while (n-- > 0) {
if (dns_evs[n].data.fd == global.dns_listen_fd) {
new_client();
} else {
if (dns_evs[n].events & EPOLLIN) {
http_in((dns_t *) dns_evs[n].data.ptr);
}
if (dns_evs[n].events & EPOLLOUT) {
http_out((dns_t *) dns_evs[n].data.ptr);
}
}
}
}
return NULL; //消除编译警告
}