proxy: simple add socks5 and https proxy support
This commit is contained in:
Nick Peng
993
src/proxy.c
Normal file
993
src/proxy.c
Normal file
@@ -0,0 +1,993 @@
|
||||
/*************************************************************************
|
||||
*
|
||||
* Copyright (C) 2018-2023 Ruilin Peng (Nick) <pymumu@gmail.com>.
|
||||
*
|
||||
* smartdns is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 3 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* smartdns is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
||||
*/
|
||||
|
||||
#ifndef _GNU_SOURCE
|
||||
#define _GNU_SOURCE
|
||||
#endif
|
||||
#include "proxy.h"
|
||||
#include "dns_conf.h"
|
||||
#include "hashtable.h"
|
||||
#include "http_parse.h"
|
||||
#include "list.h"
|
||||
#include "tlog.h"
|
||||
#include "util.h"
|
||||
#include <arpa/inet.h>
|
||||
#include <errno.h>
|
||||
#include <pthread.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/epoll.h>
|
||||
|
||||
#define PROXY_SOCKS5_VERSION 0x05
|
||||
#define PROXY_SOCKS5_NO_AUTH 0x00
|
||||
#define PROXY_SOCKS5_AUTH_USER_PASS 0x02
|
||||
#define PROXY_SOCKS5_AUTH_NONE 0xFF
|
||||
|
||||
#define PROXY_SOCKS5_TYPE_IPV4 0x01
|
||||
#define PROXY_SOCKS5_TYPE_DOMAIN 0x03
|
||||
#define PROXY_SOCKS5_TYPE_IPV6 0x04
|
||||
|
||||
#define PROXY_SOCKS5_CONNECT_TCP 0x01
|
||||
#define PROXY_SOCKS5_CONNECT_UDP 0x03
|
||||
|
||||
#define PROXY_MAX_EVENTS 64
|
||||
#define PROXY_BUFFER_SIZE (1024 * 8)
|
||||
#define PROXY_MAX_HOSTNAME_LEN 256
|
||||
|
||||
typedef enum PROXY_CONN_STATE {
|
||||
PROXY_CONN_INIT = 0,
|
||||
PROXY_CONN_INIT_ACK = 1,
|
||||
PROXY_CONN_AUTH = 2,
|
||||
PROXY_CONN_AUTH_ACK = 3,
|
||||
PROXY_CONN_CONNECTING = 4,
|
||||
PROXY_CONN_CONNECTED = 5,
|
||||
} PROXY_CONN_STATE;
|
||||
|
||||
struct proxy_conn {
|
||||
proxy_type_t type;
|
||||
PROXY_CONN_STATE state;
|
||||
char host[DNS_MAX_CNAME_LEN];
|
||||
unsigned short port;
|
||||
int fd;
|
||||
int udp_fd;
|
||||
int buffer_len;
|
||||
int is_udp;
|
||||
struct sockaddr_storage udp_dest_addr;
|
||||
socklen_t udp_dest_addrlen;
|
||||
struct proxy_server_info *server_info;
|
||||
};
|
||||
|
||||
/* upstream server groups */
|
||||
struct proxy_server_info {
|
||||
struct hlist_node node;
|
||||
char proxy_name[PROXY_NAME_LEN];
|
||||
struct sockaddr_storage server_addr;
|
||||
socklen_t server_addrlen;
|
||||
struct proxy_info info;
|
||||
};
|
||||
|
||||
struct proxy_struct {
|
||||
int run;
|
||||
int epoll_fd;
|
||||
pthread_t tid;
|
||||
pthread_mutex_t proxy_lock;
|
||||
DECLARE_HASHTABLE(proxy_server, 4);
|
||||
};
|
||||
|
||||
static struct proxy_struct proxy;
|
||||
|
||||
const char *proxy_socks5_status_code[] = {
|
||||
"success",
|
||||
"general SOCKS server failure",
|
||||
"connection not allowed by ruleset",
|
||||
"Network unreachable",
|
||||
"Host unreachable",
|
||||
"Connection refused",
|
||||
"TTL expired",
|
||||
"Command not supported",
|
||||
"Address type not supported",
|
||||
};
|
||||
|
||||
/* get server group by name */
|
||||
static struct proxy_server_info *_proxy_get_server_info(const char *proxy_name)
|
||||
{
|
||||
unsigned long key;
|
||||
struct proxy_server_info *server_info = NULL;
|
||||
struct hlist_node *tmp = NULL;
|
||||
|
||||
if (proxy_name == NULL) {
|
||||
return NULL;
|
||||
}
|
||||
|
||||
key = hash_string(proxy_name);
|
||||
hash_for_each_possible_safe(proxy.proxy_server, server_info, tmp, node, key)
|
||||
{
|
||||
if (strncmp(server_info->proxy_name, proxy_name, DNS_GROUP_NAME_LEN) != 0) {
|
||||
continue;
|
||||
}
|
||||
|
||||
return server_info;
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
static struct addrinfo *_proxy_getaddr(const char *host, int port, int type, int protocol)
|
||||
{
|
||||
struct addrinfo hints;
|
||||
struct addrinfo *result = NULL;
|
||||
int ret = 0;
|
||||
char port_str[32];
|
||||
|
||||
snprintf(port_str, sizeof(port_str), "%d", port);
|
||||
|
||||
memset(&hints, 0, sizeof(hints));
|
||||
hints.ai_family = AF_UNSPEC;
|
||||
hints.ai_socktype = type;
|
||||
hints.ai_protocol = protocol;
|
||||
|
||||
ret = getaddrinfo(host, port_str, &hints, &result);
|
||||
if (ret != 0) {
|
||||
tlog(TLOG_ERROR, "get addr info failed. %s\n", gai_strerror(ret));
|
||||
tlog(TLOG_ERROR, "host = %s, port = %d, type = %d, protocol = %d", host, port, type, protocol);
|
||||
goto errout;
|
||||
}
|
||||
|
||||
return result;
|
||||
errout:
|
||||
if (result) {
|
||||
freeaddrinfo(result);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
int proxy_add(const char *proxy_name, struct proxy_info *info)
|
||||
{
|
||||
unsigned long key;
|
||||
char ip_str[PROXY_MAX_IPLEN];
|
||||
int port = 0;
|
||||
struct addrinfo *gai = NULL;
|
||||
struct proxy_server_info *server_info = _proxy_get_server_info(proxy_name);
|
||||
|
||||
if (server_info) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
server_info = malloc(sizeof(*server_info));
|
||||
if (server_info == NULL) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
memset(server_info, 0, sizeof(*server_info));
|
||||
memcpy(&server_info->info, info, sizeof(struct proxy_info));
|
||||
|
||||
if (parse_ip(info->server, ip_str, &port) != 0) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
port = info->port;
|
||||
gai = _proxy_getaddr(info->server, port, SOCK_STREAM, 0);
|
||||
if (gai == NULL) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
server_info->server_addrlen = gai->ai_addrlen;
|
||||
memcpy(&server_info->server_addr, gai->ai_addr, gai->ai_addrlen);
|
||||
|
||||
safe_strncpy(server_info->proxy_name, proxy_name, PROXY_NAME_LEN);
|
||||
key = hash_string(server_info->proxy_name);
|
||||
hash_add(proxy.proxy_server, &server_info->node, key);
|
||||
|
||||
freeaddrinfo(gai);
|
||||
return 0;
|
||||
errout:
|
||||
if (server_info) {
|
||||
free(server_info);
|
||||
server_info = NULL;
|
||||
}
|
||||
|
||||
if (gai) {
|
||||
freeaddrinfo(gai);
|
||||
}
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int _proxy_remove(struct proxy_server_info *server_info)
|
||||
{
|
||||
hash_del(&server_info->node);
|
||||
free(server_info);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
int proxy_remove(const char *proxy_name)
|
||||
{
|
||||
struct proxy_server_info *server_info = _proxy_get_server_info(proxy_name);
|
||||
if (server_info == NULL) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
_proxy_remove(server_info);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void _proxy_remove_all(void)
|
||||
{
|
||||
struct proxy_server_info *server_info;
|
||||
struct hlist_node *tmp = NULL;
|
||||
unsigned int i = 0;
|
||||
|
||||
hash_for_each_safe(proxy.proxy_server, i, tmp, server_info, node)
|
||||
{
|
||||
_proxy_remove(server_info);
|
||||
}
|
||||
}
|
||||
|
||||
struct proxy_conn *proxy_conn_new(const char *proxy_name, const char *host, int port, int is_udp)
|
||||
{
|
||||
struct proxy_conn *proxy_conn = NULL;
|
||||
struct proxy_server_info *server_info = NULL;
|
||||
struct addrinfo *gai = NULL;
|
||||
int fd = -1;
|
||||
|
||||
server_info = _proxy_get_server_info(proxy_name);
|
||||
if (server_info == NULL) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
if (is_udp == 1 && server_info->info.type != PROXY_SOCKS5) {
|
||||
tlog(TLOG_WARN, "only socks5 support udp");
|
||||
goto errout;
|
||||
}
|
||||
|
||||
fd = socket(server_info->server_addr.ss_family, SOCK_STREAM | SOCK_CLOEXEC, 0);
|
||||
if (fd < 0) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
proxy_conn = malloc(sizeof(*proxy_conn));
|
||||
if (proxy_conn == NULL) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
memset(proxy_conn, 0, sizeof(*proxy_conn));
|
||||
safe_strncpy(proxy_conn->host, host, DNS_MAX_CNAME_LEN);
|
||||
proxy_conn->port = port;
|
||||
proxy_conn->type = server_info->info.type;
|
||||
proxy_conn->state = PROXY_CONN_INIT;
|
||||
proxy_conn->server_info = server_info;
|
||||
proxy_conn->fd = fd;
|
||||
proxy_conn->udp_fd = -1;
|
||||
proxy_conn->is_udp = is_udp;
|
||||
|
||||
return proxy_conn;
|
||||
errout:
|
||||
if (proxy_conn) {
|
||||
free(proxy_conn);
|
||||
proxy_conn = NULL;
|
||||
}
|
||||
|
||||
if (fd >= 0) {
|
||||
close(fd);
|
||||
}
|
||||
|
||||
if (gai) {
|
||||
freeaddrinfo(gai);
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
void proxy_conn_free(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
if (proxy_conn == NULL) {
|
||||
return;
|
||||
}
|
||||
|
||||
if (proxy_conn->fd >= 0) {
|
||||
close(proxy_conn->fd);
|
||||
}
|
||||
|
||||
if (proxy_conn->udp_fd >= 0) {
|
||||
close(proxy_conn->udp_fd);
|
||||
}
|
||||
|
||||
free(proxy_conn);
|
||||
}
|
||||
|
||||
int proxy_conn_connect(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
if (proxy_conn == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return connect(proxy_conn->fd, (struct sockaddr *)&proxy_conn->server_info->server_addr,
|
||||
proxy_conn->server_info->server_addrlen);
|
||||
}
|
||||
|
||||
static int _proxy_handshake_socks5_create_udp_fd(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
int ret = 0;
|
||||
char *gai_host = NULL;
|
||||
int udp_fd = -1;
|
||||
struct addrinfo *gai = NULL;
|
||||
|
||||
switch (proxy_conn->udp_dest_addr.ss_family) {
|
||||
case AF_INET:
|
||||
gai_host = "0.0.0.0";
|
||||
break;
|
||||
case AF_INET6:
|
||||
gai_host = "::";
|
||||
break;
|
||||
default:
|
||||
goto errout;
|
||||
break;
|
||||
}
|
||||
|
||||
gai = _proxy_getaddr(gai_host, 0, SOCK_DGRAM, 0);
|
||||
udp_fd = socket(gai->ai_family, gai->ai_socktype | SOCK_CLOEXEC, 0);
|
||||
if (udp_fd < 0) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
ret = bind(udp_fd, gai->ai_addr, gai->ai_addrlen);
|
||||
if (ret < 0) {
|
||||
goto errout;
|
||||
}
|
||||
|
||||
freeaddrinfo(gai);
|
||||
return udp_fd;
|
||||
errout:
|
||||
if (gai) {
|
||||
freeaddrinfo(gai);
|
||||
}
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
static int _proxy_handshake_socks5_connect_udp(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
int udp_fd = -1;
|
||||
|
||||
if (proxy_conn->is_udp == 0) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
if (proxy_conn->udp_fd < 0) {
|
||||
udp_fd = _proxy_handshake_socks5_create_udp_fd(proxy_conn);
|
||||
if (udp_fd < 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
proxy_conn->udp_fd = udp_fd;
|
||||
}
|
||||
|
||||
return connect(proxy_conn->udp_fd, (struct sockaddr *)&proxy_conn->udp_dest_addr, proxy_conn->udp_dest_addrlen);
|
||||
}
|
||||
|
||||
static proxy_handshake_state _proxy_handshake_socks5_reply_connect_addr(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
char buff[DNS_MAX_CNAME_LEN * 2];
|
||||
int len = 0;
|
||||
memset(buff, 0, sizeof(buff));
|
||||
struct sockaddr_storage addr;
|
||||
char *ptr = buff;
|
||||
socklen_t addr_len = sizeof(addr);
|
||||
|
||||
buff[0] = PROXY_SOCKS5_VERSION;
|
||||
if (proxy_conn->is_udp) {
|
||||
buff[1] = PROXY_SOCKS5_CONNECT_UDP;
|
||||
} else {
|
||||
buff[1] = PROXY_SOCKS5_CONNECT_TCP;
|
||||
}
|
||||
|
||||
buff[2] = 0x0;
|
||||
ptr = buff + 3;
|
||||
if (proxy_conn->server_info->info.use_domain) {
|
||||
*ptr = PROXY_SOCKS5_TYPE_DOMAIN;
|
||||
ptr++;
|
||||
|
||||
int domainlen = strnlen(proxy_conn->host, DNS_MAX_CNAME_LEN);
|
||||
*ptr = domainlen;
|
||||
ptr++;
|
||||
memcpy(ptr, proxy_conn->host, domainlen);
|
||||
ptr += domainlen;
|
||||
} else {
|
||||
if (proxy_conn->is_udp) {
|
||||
memset(&addr, 0, proxy_conn->server_info->server_addrlen);
|
||||
addr_len = proxy_conn->server_info->server_addrlen;
|
||||
addr.ss_family = proxy_conn->server_info->server_addr.ss_family;
|
||||
} else {
|
||||
getaddr_by_host(proxy_conn->host, (struct sockaddr *)&addr, &addr_len);
|
||||
}
|
||||
|
||||
switch (addr.ss_family) {
|
||||
case AF_INET: {
|
||||
struct sockaddr_in *addr_in = NULL;
|
||||
addr_in = (struct sockaddr_in *)&addr;
|
||||
*ptr = PROXY_SOCKS5_TYPE_IPV4;
|
||||
ptr++;
|
||||
memcpy(ptr, &addr_in->sin_addr.s_addr, 4);
|
||||
ptr += 4;
|
||||
} break;
|
||||
case AF_INET6: {
|
||||
struct sockaddr_in6 *addr_in6 = NULL;
|
||||
addr_in6 = (struct sockaddr_in6 *)&addr;
|
||||
if (IN6_IS_ADDR_V4MAPPED(&addr_in6->sin6_addr)) {
|
||||
*ptr = PROXY_SOCKS5_TYPE_IPV4;
|
||||
ptr++;
|
||||
memcpy(ptr, addr_in6->sin6_addr.s6_addr + 12, 4);
|
||||
ptr += 4;
|
||||
} else {
|
||||
*ptr = PROXY_SOCKS5_TYPE_IPV6;
|
||||
ptr++;
|
||||
memcpy(ptr, addr_in6->sin6_addr.s6_addr, 16);
|
||||
ptr += 16;
|
||||
}
|
||||
} break;
|
||||
default:
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
}
|
||||
*((short *)(ptr)) = htons(proxy_conn->port);
|
||||
ptr += 2;
|
||||
|
||||
len = send(proxy_conn->fd, buff, ptr - buff, MSG_NOSIGNAL);
|
||||
if (len != ptr - buff) {
|
||||
tlog(TLOG_ERROR, "Send proxy request failed.");
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
proxy_conn->state = PROXY_CONN_CONNECTING;
|
||||
return PROXY_HANDSHAKE_WANT_READ;
|
||||
}
|
||||
|
||||
static proxy_handshake_state _proxy_handshake_socks5_send_auth(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
char buff[DNS_MAX_CNAME_LEN * 2];
|
||||
int len = 0;
|
||||
int offset = 0;
|
||||
memset(buff, 0, sizeof(buff));
|
||||
|
||||
buff[0] = 0x1;
|
||||
buff[1] = strnlen(proxy_conn->server_info->info.username, PROXY_MAX_NAMELEN);
|
||||
safe_strncpy(buff + 2, proxy_conn->server_info->info.username, buff[1] + 1);
|
||||
offset = buff[1] + 2;
|
||||
buff[offset] = strnlen(proxy_conn->server_info->info.password, PROXY_MAX_NAMELEN);
|
||||
safe_strncpy(buff + offset + 1, proxy_conn->server_info->info.password, buff[offset] + 1);
|
||||
offset += buff[offset] + 1;
|
||||
len = send(proxy_conn->fd, buff, offset, MSG_NOSIGNAL);
|
||||
if (len != offset) {
|
||||
tlog(TLOG_ERROR, "send auth failed, len = %d, errno = %s", len, strerror(errno));
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
proxy_conn->state = PROXY_CONN_AUTH_ACK;
|
||||
return PROXY_HANDSHAKE_WANT_READ;
|
||||
}
|
||||
|
||||
static proxy_handshake_state _proxy_handshake_socks5(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
int len = 0;
|
||||
char buff[DNS_MAX_CNAME_LEN * 2];
|
||||
memset(buff, 0, sizeof(buff));
|
||||
|
||||
switch (proxy_conn->state) {
|
||||
case PROXY_CONN_INIT: {
|
||||
buff[0] = PROXY_SOCKS5_VERSION;
|
||||
buff[1] = 0x2; // 2 auth methods
|
||||
buff[2] = PROXY_SOCKS5_NO_AUTH;
|
||||
buff[3] = PROXY_SOCKS5_AUTH_USER_PASS;
|
||||
len = send(proxy_conn->fd, buff, 4, MSG_NOSIGNAL);
|
||||
if (len != 4) {
|
||||
tlog(TLOG_ERROR, "init socks5 failed, errno = %s", strerror(errno));
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
proxy_conn->state = PROXY_CONN_INIT_ACK;
|
||||
return PROXY_HANDSHAKE_WANT_READ;
|
||||
} break;
|
||||
case PROXY_CONN_INIT_ACK:
|
||||
len = recv(proxy_conn->fd, buff, sizeof(buff), 0);
|
||||
if (len <= 0) {
|
||||
if (errno == EAGAIN || errno == EWOULDBLOCK) {
|
||||
return PROXY_HANDSHAKE_WANT_READ;
|
||||
}
|
||||
|
||||
tlog(TLOG_ERROR, "recv socks5 init ack failed, errno = %s", strerror(errno));
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (len != 2) {
|
||||
tlog(TLOG_ERROR, "recv socks5 init ack failed, len = %d", len);
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (buff[0] != PROXY_SOCKS5_VERSION) {
|
||||
tlog(TLOG_ERROR, "Server not support socks5");
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if ((unsigned char)buff[1] == PROXY_SOCKS5_AUTH_NONE) {
|
||||
tlog(TLOG_ERROR, "Server not support auth methods");
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
tlog(TLOG_INFO, "Server select auth method is %d", buff[1]);
|
||||
if (buff[1] == PROXY_SOCKS5_AUTH_USER_PASS) {
|
||||
return _proxy_handshake_socks5_send_auth(proxy_conn);
|
||||
}
|
||||
|
||||
if (buff[1] == PROXY_SOCKS5_NO_AUTH) {
|
||||
return _proxy_handshake_socks5_reply_connect_addr(proxy_conn);
|
||||
}
|
||||
|
||||
tlog(TLOG_ERROR, "Server select invalid auth method %d", buff[1]);
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
break;
|
||||
case PROXY_CONN_AUTH_ACK:
|
||||
len = recv(proxy_conn->fd, buff, sizeof(buff), 0);
|
||||
if (len <= 0) {
|
||||
if (errno == EAGAIN || errno == EWOULDBLOCK) {
|
||||
return PROXY_HANDSHAKE_WANT_READ;
|
||||
}
|
||||
|
||||
tlog(TLOG_ERROR, "recv socks5 auth ack failed, errno = %s", strerror(errno));
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (len != 2) {
|
||||
tlog(TLOG_ERROR, "recv socks5 auth ack failed, len = %d", len);
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (buff[0] != 0x1) {
|
||||
tlog(TLOG_ERROR, "Server not support socks5");
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (buff[1] != 0x0) {
|
||||
tlog(TLOG_ERROR, "Server auth failed, code = %d", buff[1]);
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
tlog(TLOG_INFO, "Server auth success");
|
||||
proxy_conn->state = PROXY_CONN_CONNECTING;
|
||||
return _proxy_handshake_socks5_reply_connect_addr(proxy_conn);
|
||||
case PROXY_CONN_CONNECTING: {
|
||||
unsigned char addr[16];
|
||||
unsigned short port = 0;
|
||||
int use_dest_ip = 0;
|
||||
|
||||
int addr_len = 0;
|
||||
len = recv(proxy_conn->fd, buff, sizeof(buff), 0);
|
||||
if (len <= 0) {
|
||||
if (errno == EAGAIN || errno == EWOULDBLOCK) {
|
||||
return PROXY_HANDSHAKE_WANT_READ;
|
||||
}
|
||||
|
||||
tlog(TLOG_ERROR, "recv socks5 connect ack failed, errno = %s", strerror(errno));
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (len < 10) {
|
||||
tlog(TLOG_ERROR, "Server reply connect addr failed, len = %d", len);
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (buff[0] != PROXY_SOCKS5_VERSION) {
|
||||
tlog(TLOG_ERROR, "Server not support socks5");
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (buff[1] != 0) {
|
||||
if ((unsigned char)buff[1] <= (sizeof(proxy_socks5_status_code) / sizeof(proxy_socks5_status_code[0]))) {
|
||||
tlog(TLOG_ERROR, "Server replay failed, error code %s", proxy_socks5_status_code[(int)buff[1]]);
|
||||
} else {
|
||||
tlog(TLOG_ERROR, "Server replay failed, error code %x", buff[1]);
|
||||
}
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
switch (buff[3]) {
|
||||
case PROXY_SOCKS5_TYPE_IPV4: {
|
||||
struct sockaddr_in *addr_in = NULL;
|
||||
addr_in = (struct sockaddr_in *)&proxy_conn->udp_dest_addr;
|
||||
proxy_conn->udp_dest_addrlen = sizeof(struct sockaddr_in);
|
||||
if (len != 10) {
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
addr_len = 4;
|
||||
memcpy(addr, buff + 4, addr_len);
|
||||
port = ntohs(*((short *)(buff + 4 + addr_len)));
|
||||
addr_in->sin_family = AF_INET;
|
||||
addr_in->sin_addr.s_addr = *((int *)addr);
|
||||
addr_in->sin_port = *((short *)(buff + 4 + addr_len));
|
||||
if (addr[0] == 0 && addr[1] == 0 && addr[2] == 0 && addr[3] == 0) {
|
||||
use_dest_ip = 1;
|
||||
}
|
||||
|
||||
tlog(TLOG_DEBUG, "proxy dest: %d.%d.%d.%d:%d\n", addr[0], addr[1], addr[2], addr[3], port);
|
||||
} break;
|
||||
case PROXY_SOCKS5_TYPE_IPV6: {
|
||||
struct sockaddr_in6 *addr_in6 = NULL;
|
||||
addr_in6 = (struct sockaddr_in6 *)&proxy_conn->udp_dest_addr;
|
||||
proxy_conn->udp_dest_addrlen = sizeof(struct sockaddr_in6);
|
||||
if (len != 22) {
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
addr_len = 16;
|
||||
memcpy(addr, buff + 4, addr_len);
|
||||
port = ntohs(*((short *)(buff + 4 + addr_len)));
|
||||
addr_in6->sin6_family = AF_INET6;
|
||||
memcpy(addr_in6->sin6_addr.s6_addr, addr, addr_len);
|
||||
addr_in6->sin6_port = *((short *)(buff + 4 + addr_len));
|
||||
|
||||
if (addr[0] == 0 && addr[1] == 0 && addr[2] == 0 && addr[3] == 0 && addr[4] == 0 && addr[5] == 0 &&
|
||||
addr[6] == 0 && addr[7] == 0 && addr[8] == 0 && addr[9] == 0 && addr[10] == 0 && addr[11] == 0 &&
|
||||
addr[12] == 0 && addr[13] == 0 && addr[14] == 0 && addr[15] == 0) {
|
||||
use_dest_ip = 1;
|
||||
}
|
||||
|
||||
tlog(TLOG_DEBUG, "proxy dest: [%x:%x:%x:%x:%x:%x:%x:%x]:%d\n", ntohs(*((short *)addr)),
|
||||
ntohs(*((short *)(addr + 2))), ntohs(*((short *)(addr + 4))), ntohs(*((short *)(addr + 6))),
|
||||
ntohs(*((short *)(addr + 8))), ntohs(*((short *)(addr + 10))), ntohs(*((short *)(addr + 12))),
|
||||
ntohs(*((short *)(addr + 14))), port);
|
||||
} break;
|
||||
default:
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
if (use_dest_ip && proxy_conn->is_udp) {
|
||||
memcpy(&proxy_conn->udp_dest_addr, &proxy_conn->server_info->server_addr,
|
||||
proxy_conn->server_info->server_addrlen);
|
||||
proxy_conn->udp_dest_addrlen = proxy_conn->server_info->server_addrlen;
|
||||
switch (proxy_conn->udp_dest_addr.ss_family) {
|
||||
case AF_INET: {
|
||||
struct sockaddr_in *addr_in = NULL;
|
||||
addr_in = (struct sockaddr_in *)&proxy_conn->udp_dest_addr;
|
||||
addr_in->sin_port = *((short *)(buff + 4 + addr_len));
|
||||
} break;
|
||||
case AF_INET6: {
|
||||
struct sockaddr_in6 *addr_in6 = NULL;
|
||||
addr_in6 = (struct sockaddr_in6 *)&proxy_conn->udp_dest_addr;
|
||||
addr_in6->sin6_port = *((short *)(buff + 4 + addr_len));
|
||||
} break;
|
||||
default:
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (_proxy_handshake_socks5_connect_udp(proxy_conn) != 0) {
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
proxy_conn->state = PROXY_CONN_CONNECTED;
|
||||
tlog(TLOG_INFO, "connected to socks proxy server.");
|
||||
return PROXY_HANDSHAKE_CONNECTED;
|
||||
} break;
|
||||
default:
|
||||
tlog(TLOG_ERROR, "client socks status %d is invalid", proxy_conn->state);
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
static int _proxy_handshake_http(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
int len = 0;
|
||||
proxy_handshake_state ret = PROXY_HANDSHAKE_ERR;
|
||||
char buff[4096];
|
||||
struct http_head *http_head = NULL;
|
||||
|
||||
switch (proxy_conn->state) {
|
||||
case PROXY_CONN_INIT: {
|
||||
char connecthost[DNS_MAX_CNAME_LEN * 2];
|
||||
struct sockaddr_storage addr;
|
||||
|
||||
socklen_t addr_len = sizeof(addr);
|
||||
getaddr_by_host(proxy_conn->host, (struct sockaddr *)&addr, &addr_len);
|
||||
|
||||
if (proxy_conn->server_info->info.use_domain) {
|
||||
snprintf(connecthost, sizeof(connecthost), "%s:%d", proxy_conn->host, proxy_conn->port);
|
||||
} else {
|
||||
struct sockaddr_in *addr_in;
|
||||
addr_in = (struct sockaddr_in *)&addr;
|
||||
unsigned char *paddr = (unsigned char *)&addr_in->sin_addr.s_addr;
|
||||
snprintf(connecthost, sizeof(connecthost), "%d.%d.%d.%d:%d", paddr[0], paddr[1], paddr[2], paddr[3],
|
||||
proxy_conn->port);
|
||||
}
|
||||
|
||||
int msglen = 0;
|
||||
|
||||
if (proxy_conn->server_info->info.username[0] == '\0') {
|
||||
msglen = snprintf(buff, sizeof(buff),
|
||||
"CONNECT %s HTTP/1.1\r\n"
|
||||
"Host: %s\r\n"
|
||||
"Proxy-Connection: Keep-Alive\r\n\r\n",
|
||||
connecthost, connecthost);
|
||||
} else {
|
||||
char auth[256];
|
||||
char base64_auth[256 * 2];
|
||||
snprintf(auth, sizeof(auth), "%s:%s", proxy_conn->server_info->info.username,
|
||||
proxy_conn->server_info->info.password);
|
||||
SSL_base64_encode(auth, strlen(auth), base64_auth);
|
||||
|
||||
msglen = snprintf(buff, sizeof(buff),
|
||||
"CONNECT %s HTTP/1.1\r\n"
|
||||
"Host: %s\r\n"
|
||||
"Proxy-Authorization: Basic %s\r\n"
|
||||
"Proxy-Connection: Keep-Alive\r\n\r\n",
|
||||
connecthost, connecthost, base64_auth);
|
||||
}
|
||||
|
||||
len = send(proxy_conn->fd, buff, msglen, MSG_NOSIGNAL);
|
||||
if (len != msglen) {
|
||||
tlog(TLOG_ERROR, "init https failed, len = %d, errno = %s", len, strerror(errno));
|
||||
goto out;
|
||||
}
|
||||
|
||||
proxy_conn->state = PROXY_CONN_CONNECTING;
|
||||
ret = PROXY_HANDSHAKE_WANT_READ;
|
||||
goto out;
|
||||
} break;
|
||||
case PROXY_CONN_CONNECTING: {
|
||||
http_head = http_head_init(4096);
|
||||
if (http_head == NULL) {
|
||||
goto out;
|
||||
}
|
||||
|
||||
len = recv(proxy_conn->fd, buff, sizeof(buff), 0);
|
||||
if (len <= 0) {
|
||||
if (len == 0) {
|
||||
tlog(TLOG_ERROR, "remote server closed.");
|
||||
} else {
|
||||
tlog(TLOG_ERROR, "recv failed, errno = %s", strerror(errno));
|
||||
}
|
||||
goto out;
|
||||
}
|
||||
|
||||
len = http_head_parse(http_head, buff, len);
|
||||
if (len < 0) {
|
||||
if (len == -1) {
|
||||
goto out;
|
||||
}
|
||||
|
||||
tlog(TLOG_DEBUG, "remote server not supported.");
|
||||
goto out;
|
||||
}
|
||||
|
||||
if (http_head_get_httpcode(http_head) != 200) {
|
||||
tlog(TLOG_WARN, "http server query failed, server return http code : %d, %s",
|
||||
http_head_get_httpcode(http_head), http_head_get_httpcode_msg(http_head));
|
||||
goto out;
|
||||
}
|
||||
|
||||
proxy_conn->state = PROXY_CONN_CONNECTED;
|
||||
ret = PROXY_HANDSHAKE_CONNECTED;
|
||||
goto out;
|
||||
} break;
|
||||
default:
|
||||
goto out;
|
||||
break;
|
||||
}
|
||||
|
||||
out:
|
||||
if (http_head) {
|
||||
http_head_destroy(http_head);
|
||||
}
|
||||
|
||||
return ret;
|
||||
}
|
||||
|
||||
proxy_handshake_state proxy_conn_handshake(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
if (proxy_conn == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (proxy_conn->state == PROXY_CONN_CONNECTED) {
|
||||
return PROXY_HANDSHAKE_OK;
|
||||
}
|
||||
|
||||
switch (proxy_conn->type) {
|
||||
case PROXY_SOCKS5:
|
||||
return _proxy_handshake_socks5(proxy_conn);
|
||||
case PROXY_HTTP:
|
||||
return _proxy_handshake_http(proxy_conn);
|
||||
default:
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
return PROXY_HANDSHAKE_ERR;
|
||||
}
|
||||
|
||||
static int _proxy_is_tcp_connected(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
char buff[1];
|
||||
int ret = 0;
|
||||
ret = recv(proxy_conn->fd, buff, 1, MSG_PEEK | MSG_DONTWAIT);
|
||||
if (ret < 0) {
|
||||
if (errno == EAGAIN || errno == EWOULDBLOCK) {
|
||||
return 1;
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
int proxy_conn_sendto(struct proxy_conn *proxy_conn, const void *buf, size_t len, int flags,
|
||||
const struct sockaddr *dest_addr, socklen_t addrlen)
|
||||
{
|
||||
char buffer[PROXY_BUFFER_SIZE];
|
||||
int buffer_len = 0;
|
||||
int ret = 0;
|
||||
|
||||
if (proxy_conn == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (_proxy_is_tcp_connected(proxy_conn) == 0) {
|
||||
errno = ECONNRESET;
|
||||
return -1;
|
||||
}
|
||||
|
||||
buffer[0] = 0x00;
|
||||
buffer[1] = 0x00;
|
||||
buffer[2] = 0x00;
|
||||
buffer_len += 3;
|
||||
|
||||
switch (dest_addr->sa_family) {
|
||||
case AF_INET:
|
||||
buffer[3] = PROXY_SOCKS5_TYPE_IPV4;
|
||||
memcpy(buffer + 4, &((struct sockaddr_in *)dest_addr)->sin_addr.s_addr, 4);
|
||||
memcpy(buffer + 8, &((struct sockaddr_in *)dest_addr)->sin_port, 2);
|
||||
buffer_len += 7;
|
||||
break;
|
||||
case AF_INET6:
|
||||
buffer[3] = PROXY_SOCKS5_TYPE_IPV6;
|
||||
memcpy(buffer + 4, &((struct sockaddr_in6 *)dest_addr)->sin6_addr.s6_addr, 16);
|
||||
memcpy(buffer + 20, &((struct sockaddr_in6 *)dest_addr)->sin6_port, 2);
|
||||
buffer_len += 19;
|
||||
break;
|
||||
default:
|
||||
return -1;
|
||||
}
|
||||
|
||||
memcpy(buffer + buffer_len, buf, len);
|
||||
buffer_len += len;
|
||||
|
||||
ret = sendto(proxy_conn->udp_fd, buffer, buffer_len, MSG_NOSIGNAL, (struct sockaddr *)&proxy_conn->udp_dest_addr,
|
||||
proxy_conn->udp_dest_addrlen);
|
||||
if (ret != buffer_len) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int proxy_conn_recvfrom(struct proxy_conn *proxy_conn, void *buf, size_t len, int flags, struct sockaddr *src_addr,
|
||||
socklen_t *addrlen)
|
||||
{
|
||||
char buffer[PROXY_BUFFER_SIZE];
|
||||
int buffer_len = 0;
|
||||
int ret = 0;
|
||||
|
||||
if (proxy_conn == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
ret = recvfrom(proxy_conn->udp_fd, buffer, sizeof(buffer), MSG_NOSIGNAL, NULL, 0);
|
||||
if (ret <= 0) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (buffer[0] != 0x00 || buffer[1] != 0x00 || buffer[2] != 0x00) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
switch (buffer[3]) {
|
||||
case PROXY_SOCKS5_TYPE_IPV4:
|
||||
if (ret < 10) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (src_addr) {
|
||||
memset(src_addr, 0, sizeof(struct sockaddr_in));
|
||||
((struct sockaddr_in *)src_addr)->sin_family = AF_INET;
|
||||
memcpy(&((struct sockaddr_in *)src_addr)->sin_addr.s_addr, buffer + 4, 4);
|
||||
memcpy(&((struct sockaddr_in *)src_addr)->sin_port, buffer + 8, 2);
|
||||
}
|
||||
|
||||
if (addrlen) {
|
||||
*addrlen = sizeof(struct sockaddr_in);
|
||||
}
|
||||
|
||||
buffer_len = 10;
|
||||
break;
|
||||
case PROXY_SOCKS5_TYPE_IPV6:
|
||||
if (ret < 22) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (src_addr) {
|
||||
memset(src_addr, 0, sizeof(struct sockaddr_in6));
|
||||
((struct sockaddr_in6 *)src_addr)->sin6_family = AF_INET6;
|
||||
memcpy(&((struct sockaddr_in6 *)src_addr)->sin6_addr.s6_addr, buffer + 4, 16);
|
||||
memcpy(&((struct sockaddr_in6 *)src_addr)->sin6_port, buffer + 20, 2);
|
||||
}
|
||||
|
||||
if (addrlen) {
|
||||
*addrlen = sizeof(struct sockaddr_in6);
|
||||
}
|
||||
|
||||
buffer_len = 22;
|
||||
break;
|
||||
default:
|
||||
|
||||
return -1;
|
||||
}
|
||||
|
||||
if (ret - buffer_len > (int)len) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
memcpy(buf, buffer + buffer_len, ret - buffer_len);
|
||||
return ret - buffer_len;
|
||||
}
|
||||
|
||||
int proxy_conn_get_fd(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
if (proxy_conn == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return proxy_conn->fd;
|
||||
}
|
||||
|
||||
int proxy_conn_get_udpfd(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
if (proxy_conn == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return proxy_conn->udp_fd;
|
||||
}
|
||||
|
||||
int proxy_conn_is_udp(struct proxy_conn *proxy_conn)
|
||||
{
|
||||
if (proxy_conn == NULL) {
|
||||
return -1;
|
||||
}
|
||||
|
||||
return proxy_conn->is_udp;
|
||||
}
|
||||
|
||||
int proxy_init()
|
||||
{
|
||||
memset(&proxy, 0, sizeof(proxy));
|
||||
hash_init(proxy.proxy_server);
|
||||
return 0;
|
||||
}
|
||||
|
||||
int proxy_exit()
|
||||
{
|
||||
_proxy_remove_all();
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user