Force Proxy to any Windows/MacOS/Linux Application TCP and UDP traffic
C ccybersecurityhttp3httpproxylinuxlinux-proxymacosmacos-appmacos-proxyproxifierproxifier-alternativeproxyclienttcpthick-clientudpwindivertwindows
#include "pb_internal.h"
// Relay: TCP/UDP relay servers and per-connection worker threads.
DWORD WINAPI udp_relay_server(LPVOID arg)
{
WSADATA wsa_data;
struct sockaddr_in local_addr = {0}, from_addr = {0};
unsigned char recv_buf[MAXBUF];
unsigned char send_buf[MAXBUF];
int recv_len, from_len = 0;
if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0)
return 1;
udp_relay_socket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (udp_relay_socket == INVALID_SOCKET)
{
WSACleanup();
return 1;
}
int on = 1;
setsockopt(udp_relay_socket, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
configure_udp_socket(udp_relay_socket, 262144, 30000);
memset(&local_addr, 0, sizeof(local_addr));
local_addr.sin_family = AF_INET;
local_addr.sin_addr.s_addr = htonl(INADDR_ANY); // must be any WinDivert swaps src/dst IPs for
local_addr.sin_port = htons(LOCAL_UDP_RELAY_PORT);// tracked connections so packets arrive at the
// machines real ip and not 127.0.0.1
if (bind(udp_relay_socket, (struct sockaddr *)&local_addr, sizeof(local_addr)) == SOCKET_ERROR)
{
closesocket(udp_relay_socket);
udp_relay_socket = INVALID_SOCKET;
WSACleanup();
return 1;
}
// IPv6 UDP relay socket on ::1:34011
udp_relay_socket6 = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
if (udp_relay_socket6 != INVALID_SOCKET)
{
int v6only = 1;
setsockopt(udp_relay_socket6, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&v6only, sizeof(v6only));
setsockopt(udp_relay_socket6, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
configure_udp_socket(udp_relay_socket6, 262144, 30000);
struct sockaddr_in6 a6;
memset(&a6, 0, sizeof(a6));
a6.sin6_family = AF_INET6;
a6.sin6_addr = in6addr_any; // same tracked packets arrive at machines real IPv6
a6.sin6_port = htons(LOCAL_UDP_RELAY_PORT);
if (bind(udp_relay_socket6, (struct sockaddr*)&a6, sizeof(a6)) == SOCKET_ERROR)
{
closesocket(udp_relay_socket6);
udp_relay_socket6 = INVALID_SOCKET;
}
}
// Try initial UDP ASSOCIATE only for SOCKS5 configs that an enabled rule actually uses.
// Skipping unreferenced configs avoids stalling the relay on dead/unused proxies.
for (int i = 0; i < g_proxy_config_count; i++)
{
if (g_proxy_configs[i].type == PROXY_TYPE_SOCKS5 &&
is_proxy_config_referenced(g_proxy_configs[i].config_id))
{
establish_udp_associate_for_config(&g_proxy_configs[i]);
}
}
log_message("UDP relay listening on port %d", LOCAL_UDP_RELAY_PORT);
while (running)
{
// Set whenever an association's sockets are closed and recreated this iteration.
// Windows reuses closed SOCKET handle values, so the current read_fds (from the
// select() below) can falsely report the NEW socket ready -> recvfrom on it
// returns WSAEINVAL (or, on the blocking send socket, stalls ~30s). We must
// restart the loop and rebuild read_fds before inspecting the new sockets (#183).
int assoc_replaced = 0;
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(udp_relay_socket, &read_fds);
if (udp_relay_socket6 != INVALID_SOCKET)
FD_SET(udp_relay_socket6, &read_fds);
// Add all SOCKS5 configs' TCP control and UDP send sockets
for (int i = 0; i < g_proxy_config_count; i++)
{
PROXY_CONFIG *cfg = &g_proxy_configs[i];
if (cfg->type != PROXY_TYPE_SOCKS5) continue;
if (cfg->udp_connected && cfg->udp_tcp_ctrl != INVALID_SOCKET)
FD_SET(cfg->udp_tcp_ctrl, &read_fds);
if (cfg->udp_connected && cfg->udp_send_sock != INVALID_SOCKET)
FD_SET(cfg->udp_send_sock, &read_fds);
}
struct timeval timeout = {1, 0};
if (select(0, &read_fds, NULL, NULL, &timeout) <= 0)
{
// Select timed out proactively reconnect any dropped UDP ASSOCIATEs so
// the connection is ready before the next client packet arrives.
// Real time communication need real time packet transfer, a single UDP Associate connction can take 1 to 2 seconds and it break the UDP steam for client app
// fuck you udp this cause slight increase in performance but needed for udp
for (int i = 0; i < g_proxy_config_count; i++)
{
PROXY_CONFIG *rc = &g_proxy_configs[i];
if (rc->type == PROXY_TYPE_SOCKS5 && !rc->udp_connected &&
is_proxy_config_referenced(rc->config_id))
establish_udp_associate_for_config(rc);
}
continue;
}
// Check if any SOCKS5 proxy TCP control socket disconnected
for (int i = 0; i < g_proxy_config_count; i++)
{
PROXY_CONFIG *cfg = &g_proxy_configs[i];
if (cfg->type != PROXY_TYPE_SOCKS5 || !cfg->udp_connected) continue;
if (cfg->udp_tcp_ctrl != INVALID_SOCKET && FD_ISSET(cfg->udp_tcp_ctrl, &read_fds))
{
char test_buf[1];
int result = recv(cfg->udp_tcp_ctrl, test_buf, sizeof(test_buf), MSG_PEEK);
if (result == 0 || (result == SOCKET_ERROR && WSAGetLastError() != WSAEWOULDBLOCK))
{
log_message("[UDP RELAY] TCP control connection closed for proxy %s:%d - reconnecting", cfg->host, cfg->port);
closesocket(cfg->udp_tcp_ctrl);
cfg->udp_tcp_ctrl = INVALID_SOCKET;
if (cfg->udp_send_sock != INVALID_SOCKET)
{
closesocket(cfg->udp_send_sock);
cfg->udp_send_sock = INVALID_SOCKET;
}
cfg->udp_connected = FALSE;
// Reconnect immediately so the next client packet is not dropped.
establish_udp_associate_for_config(cfg);
assoc_replaced = 1; // sockets replaced - read_fds is now stale
}
}
}
if (assoc_replaced) continue; // rebuild read_fds before touching new sockets
// Check if packet is from local application
if (FD_ISSET(udp_relay_socket, &read_fds))
{
from_len = sizeof(from_addr);
recv_len = recvfrom(udp_relay_socket, (char*)recv_buf, sizeof(recv_buf), 0,
(struct sockaddr *)&from_addr, &from_len);
if (recv_len == SOCKET_ERROR)
{
// take the error unreachable so
// https://github.com/InterceptSuite/ProxyBridge/issues/89
// select() does not immediately return readable again, causing a spin.
continue;
}
if (recv_len > 0)
{
// Buffer overflow protection
if (recv_len > MAXBUF - 10) continue;
UINT16 from_port = ntohs(from_addr.sin_port);
UINT32 dest_ip;
UINT16 dest_port;
UINT32 proxy_config_id = 0;
if (get_connection_full_x(from_port, TRUE, &dest_ip, &dest_port, &proxy_config_id, NULL, NULL, (UINT32)recv_len))
{
PROXY_CONFIG *cfg = find_proxy_config(proxy_config_id);
if (cfg == NULL || cfg->type != PROXY_TYPE_SOCKS5)
{
log_message("[UDP RELAY] No SOCKS5 config for port %d", from_port);
continue;
}
// UDP ASSOCIATE is established (reconnect if dropped).
// If reconnect succeeds, fall through and send the current packet
// immediately so real-time streams lose at most one packet.
if (!cfg->udp_connected)
{
if (!establish_udp_associate_for_config(cfg))
{
log_message("[UDP RELAY] UDP ASSOCIATE unavailable for %s:%d - dropping packet", cfg->host, cfg->port);
continue;
}
assoc_replaced = 1; // new sockets created - read_fds is stale
}
send_buf[0] = 0;
send_buf[1] = 0;
send_buf[2] = 0;
send_buf[3] = SOCKS5_ATYP_IPV4;
send_buf[4] = (dest_ip >> 0) & 0xFF;
send_buf[5] = (dest_ip >> 8) & 0xFF;
send_buf[6] = (dest_ip >> 16) & 0xFF;
send_buf[7] = (dest_ip >> 24) & 0xFF;
send_buf[8] = (dest_port >> 8) & 0xFF;
send_buf[9] = (dest_port >> 0) & 0xFF;
memcpy(&send_buf[10], recv_buf, recv_len);
int sent = sendto(cfg->udp_send_sock, (char*)send_buf, 10 + recv_len, 0,
(struct sockaddr *)&cfg->udp_relay_addr, sizeof(cfg->udp_relay_addr));
if (sent == SOCKET_ERROR) {
int err = WSAGetLastError();
log_message("[UDP RELAY ERROR] sendto proxy %s:%d failed: %d - reconnecting and retrying", cfg->host, cfg->port, err);
if (cfg->udp_tcp_ctrl != INVALID_SOCKET) { closesocket(cfg->udp_tcp_ctrl); cfg->udp_tcp_ctrl = INVALID_SOCKET; }
if (cfg->udp_send_sock != INVALID_SOCKET) { closesocket(cfg->udp_send_sock); cfg->udp_send_sock = INVALID_SOCKET; }
cfg->udp_connected = FALSE;
// Reconnect and retry the current packet so real-time streams
// lose at most one packet during a proxy reconnect event.
if (establish_udp_associate_for_config(cfg))
{
sendto(cfg->udp_send_sock, (char*)send_buf, 10 + recv_len, 0,
(struct sockaddr *)&cfg->udp_relay_addr, sizeof(cfg->udp_relay_addr));
}
assoc_replaced = 1; // sockets replaced - read_fds is stale
}
}
}
}
if (assoc_replaced) continue; // rebuild read_fds before inspecting new sockets
// Check if packet is from any SOCKS5 proxy's UDP socket
for (int i = 0; i < g_proxy_config_count; i++)
{
PROXY_CONFIG *cfg = &g_proxy_configs[i];
if (cfg->type != PROXY_TYPE_SOCKS5 || !cfg->udp_connected) continue;
if (cfg->udp_send_sock == INVALID_SOCKET) continue;
// If not signalled by the outer select, do a zero-timeout check for
// sockets that were created this iteration (e.g. just after reconnect).
if (!FD_ISSET(cfg->udp_send_sock, &read_fds))
{
fd_set quick;
FD_ZERO(&quick);
FD_SET(cfg->udp_send_sock, &quick);
struct timeval zero_tv = {0, 0};
if (select(0, &quick, NULL, NULL, &zero_tv) <= 0 || !FD_ISSET(cfg->udp_send_sock, &quick))
continue;
}
from_len = sizeof(from_addr);
recv_len = recvfrom(cfg->udp_send_sock, (char*)recv_buf, sizeof(recv_buf), 0,
(struct sockaddr *)&from_addr, &from_len);
if (recv_len == SOCKET_ERROR)
{
int err = WSAGetLastError();
log_message("[UDP RELAY ERROR] Failed to receive from proxy %s:%d: %d - closing", cfg->host, cfg->port, err);
if (cfg->udp_tcp_ctrl != INVALID_SOCKET) { closesocket(cfg->udp_tcp_ctrl); cfg->udp_tcp_ctrl = INVALID_SOCKET; }
closesocket(cfg->udp_send_sock);
cfg->udp_send_sock = INVALID_SOCKET;
cfg->udp_connected = FALSE;
continue;
}
if (recv_len > 0)
{
// Packet from SOCKS5 proxy - decapsulate and forward to original sender
if (recv_len < 10) continue;
// SOCKS5 UDP: RSV(2) + FRAG(1) + ATYP(1) + DST.ADDR + DST.PORT(2) + DATA
if (recv_buf[2] != 0x00) continue; // FRAG must be 0
if (recv_buf[3] == SOCKS5_ATYP_IPV4 && recv_len >= 10)
{
UINT32 src_ip = (recv_buf[4]<<0)|(recv_buf[5]<<8)|(recv_buf[6]<<16)|(recv_buf[7]<<24);
UINT16 src_port = (recv_buf[8]<<8)|recv_buf[9];
BOOL found = FALSE;
UINT32 target_ip = 0;
UINT16 target_port = 0;
CONNECTION_INFO *winner_conn = NULL;
AcquireSRWLockShared(&lock);
ULONGLONG best_activity = 0;
// O(1): only the reverse bucket for this (dest ip, dest port) - not the
// whole table - then pick the most-recently-active matching client.
for (CONNECTION_INFO *conn = connection_rev_table[rev_hash_v4(src_ip, src_port)];
conn != NULL; conn = conn->rev_next)
{
if (conn->is_udp && !conn->is_ipv6 && conn->orig_dest_ip == src_ip && conn->orig_dest_port == src_port)
{
if (!found || conn->last_activity > best_activity)
{
target_ip = conn->src_ip;
target_port = conn->src_port;
best_activity = conn->last_activity;
found = TRUE;
winner_conn = conn;
// Do NOT update last_activity here; doing so mid-loop corrupts
// best_activity comparisons for later entries. Update after.
}
}
}
// Keep winner's session alive (update outside loop so comparisons above
// use the original, unmodified timestamps for all candidates).
if (winner_conn != NULL)
{
InterlockedExchange64((LONGLONG volatile*)&winner_conn->last_activity, (LONGLONG)GetTickCount64());
InterlockedExchangeAdd64(&winner_conn->down_bytes, (LONG64)(recv_len - 10));
}
ReleaseSRWLockShared(&lock);
if (found)
{
struct sockaddr_in target_addr;
memset(&target_addr, 0, sizeof(target_addr));
target_addr.sin_family = AF_INET;
target_addr.sin_addr.s_addr = target_ip;
target_addr.sin_port = htons(target_port);
int fwd = sendto(udp_relay_socket, (char*)&recv_buf[10], recv_len-10, 0,
(struct sockaddr*)&target_addr, sizeof(target_addr));
if (fwd == SOCKET_ERROR)
log_message("[UDP RELAY] sendto client port %d failed: %d", target_port, WSAGetLastError());
}
else
{
log_message("[UDP RELAY] No session found for proxy response from %d.%d.%d.%d:%d - dropped",
recv_buf[4], recv_buf[5], recv_buf[6], recv_buf[7], src_port);
}
}
else if (recv_buf[3] == SOCKS5_ATYP_IPV6 && recv_len >= 22)
{
UINT8 src_ip6[16];
memcpy(src_ip6, &recv_buf[4], 16);
UINT16 src_port = (recv_buf[20]<<8)|recv_buf[21];
UINT8 target_ip6[16];
UINT16 target_port = 0;
if (find_v6_udp_sender(src_ip6, src_port, target_ip6, &target_port, (UINT32)(recv_len - 22)) && udp_relay_socket6 != INVALID_SOCKET)
{
struct sockaddr_in6 t6;
memset(&t6, 0, sizeof(t6));
t6.sin6_family = AF_INET6;
memcpy(&t6.sin6_addr, target_ip6, 16);
t6.sin6_port = htons(target_port);
sendto(udp_relay_socket6, (char*)&recv_buf[22], recv_len-22, 0,
(struct sockaddr*)&t6, sizeof(t6));
}
}
}
}
// IPv6 UDP packets from application
if (udp_relay_socket6 != INVALID_SOCKET && FD_ISSET(udp_relay_socket6, &read_fds))
{
struct sockaddr_in6 from_addr6 = {0};
int fl = sizeof(from_addr6);
recv_len = recvfrom(udp_relay_socket6, (char*)recv_buf, sizeof(recv_buf), 0,
(struct sockaddr*)&from_addr6, &fl);
if (recv_len > 0 && recv_len <= MAXBUF - 22)
{
UINT16 from_port = ntohs(from_addr6.sin6_port);
UINT8 dest_ip6[16];
UINT16 dest_port = 0;
UINT32 proxy_config_id = 0;
if (get_connection_full_v6_x(from_port, TRUE, dest_ip6, &dest_port, &proxy_config_id, NULL, NULL, (UINT32)recv_len))
{
PROXY_CONFIG *cfg = find_proxy_config(proxy_config_id);
if (cfg != NULL && cfg->type == PROXY_TYPE_SOCKS5)
{
if (!cfg->udp_connected) establish_udp_associate_for_config(cfg);
if (cfg->udp_connected)
{
send_buf[0] = 0; send_buf[1] = 0; send_buf[2] = 0;
send_buf[3] = SOCKS5_ATYP_IPV6;
memcpy(&send_buf[4], dest_ip6, 16);
send_buf[20] = (dest_port>>8)&0xFF;
send_buf[21] = (dest_port>>0)&0xFF;
memcpy(&send_buf[22], recv_buf, recv_len);
sendto(cfg->udp_send_sock, (char*)send_buf, 22+recv_len, 0,
(struct sockaddr*)&cfg->udp_relay_addr, sizeof(cfg->udp_relay_addr));
}
}
}
}
}
}
// Clean up all proxy UDP sockets
for (int i = 0; i < g_proxy_config_count; i++)
{
PROXY_CONFIG *cfg = &g_proxy_configs[i];
if (cfg->udp_tcp_ctrl != INVALID_SOCKET) { closesocket(cfg->udp_tcp_ctrl); cfg->udp_tcp_ctrl = INVALID_SOCKET; }
if (cfg->udp_send_sock != INVALID_SOCKET) { closesocket(cfg->udp_send_sock); cfg->udp_send_sock = INVALID_SOCKET; }
cfg->udp_connected = FALSE;
}
closesocket(udp_relay_socket);
udp_relay_socket = INVALID_SOCKET;
if (udp_relay_socket6 != INVALID_SOCKET) { closesocket(udp_relay_socket6); udp_relay_socket6 = INVALID_SOCKET; }
WSACleanup();
return 0;
}
// The relay is reached by packets ProxyBridge turns around so they look like they come from the
// ORIGINAL destination, so the legitimate peer address of an accepted connection is exactly the
// tracked flow's original destination (or a loopback address for local-to-local flows). The flow
// used to be looked up by the peer's source PORT alone, which is only safe while a firewall keeps
// outsiders away from the relay port; now that the relay is reachable on every network profile
// (needed for VPN adapters), another host must not be able to claim a tracked flow just by
// connecting from a matching source port.
static BOOL relay_peer_ok_v4(UINT32 peer, UINT32 orig_dest)
{
return ((peer & 0xFF) == 127) || peer == orig_dest;
}
static BOOL relay_peer_ok_v6(const struct in6_addr *peer, const UINT8 orig_dest6[16])
{
static const UINT8 lb6[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1};
return memcmp(peer, lb6, 16) == 0 || memcmp(peer, orig_dest6, 16) == 0;
}
DWORD WINAPI local_proxy_server(LPVOID arg)
{
WSADATA wsa_data;
struct sockaddr_in addr;
SOCKET listen_sock;
int on = 1;
if (WSAStartup(MAKEWORD(2, 2), &wsa_data) != 0)
{
log_message("WSAStartup failed (%lu)", GetLastError());
return 1;
}
listen_sock = socket(AF_INET, SOCK_STREAM, 0);
if (listen_sock == INVALID_SOCKET)
{
log_message("Socket creation failed (%d)", WSAGetLastError());
WSACleanup();
return 1;
}
setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
int nodelay = 1;
setsockopt(listen_sock, IPPROTO_TCP, TCP_NODELAY, (char*)&nodelay, sizeof(nodelay));
memset(&addr, 0, sizeof(addr));
addr.sin_family = AF_INET;
addr.sin_addr.s_addr = htonl(INADDR_ANY); // must be ANY: WinDivert swaps src/dst IPs for
addr.sin_port = htons(g_local_relay_port); // non-loopback traffic, so redirected SYNs arrive
// at the machine's real IP, not 127.0.0.1
if (bind(listen_sock, (struct sockaddr *)&addr, sizeof(addr)) == SOCKET_ERROR)
{
log_message("Bind failed (%d)", WSAGetLastError());
closesocket(listen_sock);
WSACleanup();
return 1;
}
if (listen(listen_sock, SOMAXCONN) == SOCKET_ERROR)
{
log_message("Listen failed (%d)", WSAGetLastError());
closesocket(listen_sock);
WSACleanup();
return 1;
}
// IPv6 loopback listener for redirected IPv6 TCP
SOCKET listen_sock6 = socket(AF_INET6, SOCK_STREAM, 0);
if (listen_sock6 != INVALID_SOCKET)
{
int v6only = 1;
setsockopt(listen_sock6, IPPROTO_IPV6, IPV6_V6ONLY, (const char*)&v6only, sizeof(v6only));
setsockopt(listen_sock6, SOL_SOCKET, SO_REUSEADDR, (const char*)&on, sizeof(on));
setsockopt(listen_sock6, IPPROTO_TCP, TCP_NODELAY, (const char*)&nodelay, sizeof(nodelay));
struct sockaddr_in6 addr6;
memset(&addr6, 0, sizeof(addr6));
addr6.sin6_family = AF_INET6;
addr6.sin6_addr = in6addr_any; // same reason as IPv4: accept on any local address
addr6.sin6_port = htons(g_local_relay_port);
if (bind(listen_sock6, (struct sockaddr*)&addr6, sizeof(addr6)) == SOCKET_ERROR ||
listen(listen_sock6, SOMAXCONN) == SOCKET_ERROR)
{
log_message("IPv6 listen failed (%d)", WSAGetLastError());
closesocket(listen_sock6);
listen_sock6 = INVALID_SOCKET;
}
else
{
log_message("Local proxy IPv6 listening on [::]:%d", g_local_relay_port);
}
}
log_message("Local proxy listening on port %d", g_local_relay_port);
while (running)
{
fd_set read_fds;
FD_ZERO(&read_fds);
FD_SET(listen_sock, &read_fds);
if (listen_sock6 != INVALID_SOCKET)
FD_SET(listen_sock6, &read_fds);
struct timeval timeout = {1, 0};
if (select(0, &read_fds, NULL, NULL, &timeout) <= 0)
continue;
if (FD_ISSET(listen_sock, &read_fds))
{
struct sockaddr_in client_addr;
int addr_len = sizeof(client_addr);
SOCKET client_sock = accept(listen_sock, (struct sockaddr *)&client_addr, &addr_len);
if (client_sock != INVALID_SOCKET)
{
CONNECTION_CONFIG *conn_config = (CONNECTION_CONFIG *)malloc(sizeof(CONNECTION_CONFIG));
if (conn_config != NULL)
{
conn_config->client_socket = client_sock;
conn_config->is_ipv6 = FALSE;
UINT16 client_port = ntohs(client_addr.sin_port);
if (get_connection_full_x(client_port, FALSE, &conn_config->orig_dest_ip, &conn_config->orig_dest_port, &conn_config->proxy_config_id, &conn_config->pid, &conn_config->rule_id, 0) &&
relay_peer_ok_v4(client_addr.sin_addr.s_addr, conn_config->orig_dest_ip))
{
InterlockedIncrement(&g_handler_threads);
HANDLE conn_thread = CreateThread(NULL, 1, connection_handler, (LPVOID)conn_config, 0, NULL);
if (conn_thread != NULL) { CloseHandle(conn_thread); }
else { InterlockedDecrement(&g_handler_threads); closesocket(client_sock); free(conn_config); }
}
else { closesocket(client_sock); free(conn_config); }
}
else { closesocket(client_sock); }
}
}
if (listen_sock6 != INVALID_SOCKET && FD_ISSET(listen_sock6, &read_fds))
{
struct sockaddr_in6 client_addr6;
int addr_len6 = sizeof(client_addr6);
SOCKET client_sock6 = accept(listen_sock6, (struct sockaddr*)&client_addr6, &addr_len6);
if (client_sock6 != INVALID_SOCKET)
{
CONNECTION_CONFIG *conn_config = (CONNECTION_CONFIG *)malloc(sizeof(CONNECTION_CONFIG));
if (conn_config != NULL)
{
conn_config->client_socket = client_sock6;
conn_config->is_ipv6 = TRUE;
UINT16 client_port = ntohs(client_addr6.sin6_port);
if (get_connection_full_v6_x(client_port, FALSE, conn_config->orig_dest_ip6, &conn_config->orig_dest_port, &conn_config->proxy_config_id, &conn_config->pid, &conn_config->rule_id, 0) &&
relay_peer_ok_v6(&client_addr6.sin6_addr, conn_config->orig_dest_ip6))
{
InterlockedIncrement(&g_handler_threads);
HANDLE conn_thread = CreateThread(NULL, 1, connection_handler, (LPVOID)conn_config, 0, NULL);
if (conn_thread != NULL) { CloseHandle(conn_thread); }
else { InterlockedDecrement(&g_handler_threads); closesocket(client_sock6); free(conn_config); }
}
else { closesocket(client_sock6); free(conn_config); }
}
else { closesocket(client_sock6); }
}
}
}
closesocket(listen_sock);
if (listen_sock6 != INVALID_SOCKET) closesocket(listen_sock6);
WSACleanup();
return 0;
}
// Abortive close (RST) for the app-side socket when the upstream handshake fails. The relay
// has already completed the TCP handshake with the app, so a plain close() looks like a
// normal connection that ended with no data; an RST tells the app the connection failed
// right now, so it errors out (or retries another address) instead of waiting.
static void reset_close(SOCKET s)
{
struct linger lg = { 1, 0 };
setsockopt(s, SOL_SOCKET, SO_LINGER, (const char*)&lg, sizeof(lg));
closesocket(s);
}
volatile LONG g_handler_threads = 0;
static DWORD WINAPI connection_handler_impl(LPVOID arg);
// Every handshake thread is counted from the moment it is created until it returns, so that
// ProxyBridge_Stop() can wait for all of them. A thread still running inside the DLL when the DLL
// is unloaded (the service reloads the engine for every GUI connection) crashes the process.
DWORD WINAPI connection_handler(LPVOID arg)
{
DWORD r = connection_handler_impl(arg);
InterlockedDecrement(&g_handler_threads);
return r;
}
static DWORD WINAPI connection_handler_impl(LPVOID arg)
{
CONNECTION_CONFIG *config = (CONNECTION_CONFIG *)arg;
SOCKET client_sock = config->client_socket;
UINT32 dest_ip = config->orig_dest_ip;
UINT16 dest_port = config->orig_dest_port;
UINT32 proxy_config_id = config->proxy_config_id;
BOOL is_ipv6 = config->is_ipv6;
UINT8 dest_ip6[16];
if (is_ipv6) memcpy(dest_ip6, config->orig_dest_ip6, 16);
FLOW_META meta;
ZeroMemory(&meta, sizeof(meta));
meta.pid = config->pid; meta.proxy_id = proxy_config_id; meta.rule_id = config->rule_id; meta.port = dest_port; meta.v6 = is_ipv6;
if (is_ipv6) memcpy(meta.dest, dest_ip6, 16); else memcpy(meta.dest, &dest_ip, 4);
SOCKET socks_sock;
struct sockaddr_in socks_addr;
free(config);
// Look up the proxy config for this connection
PROXY_CONFIG *proxy = find_proxy_config(proxy_config_id);
if (proxy == NULL || proxy->host[0] == '\0' || proxy->port == 0)
{
log_message("[RELAY] No proxy config (id=%u) - dropping connection", proxy_config_id);
closesocket(client_sock);
return 1;
}
// Connect to proxy, use cached resolved IP to avoid DNS per connection
UINT32 proxy_ip = proxy->resolved_ip ? proxy->resolved_ip : resolve_hostname(proxy->host);
if (proxy_ip == 0)
{
closesocket(client_sock);
return 1;
}
socks_sock = socket(AF_INET, SOCK_STREAM, 0);
if (socks_sock == INVALID_SOCKET)
{
log_message("Socket creation failed (%d)", WSAGetLastError());
closesocket(client_sock);
return 0;
}
// 4 MB kernel socket buffers for the relay sockets.
// The upload path writes from client→proxy over a real network with non-zero
// RTT; a small (512 KB) send buffer causes send_all() to block the moment
// the proxy's receive window fills up, which stalls the relay loop and
// triggers TCP flow-control on the client side → massive upload throughput
// loss. 4 MB gives plenty of headroom even at high bitrates / high RTT.
LONG ar = g_active_relays; // socket buffers shrink as the number of live relays grows
int sockbuf = ar < 1024 ? 4194304 : 1048576;
configure_tcp_socket(socks_sock, sockbuf, 30000); // 4 MB – proxy connection
configure_tcp_socket(client_sock, sockbuf, 30000); // 4 MB – app connection
memset(&socks_addr, 0, sizeof(socks_addr));
socks_addr.sin_family = AF_INET;
socks_addr.sin_addr.s_addr = proxy_ip;
socks_addr.sin_port = htons(proxy->port);
if (connect(socks_sock, (struct sockaddr *)&socks_addr, sizeof(socks_addr)) == SOCKET_ERROR)
{
log_message("[RELAY] Failed to connect to proxy %s:%d (%d)", proxy->host, proxy->port, WSAGetLastError());
closesocket(client_sock);
closesocket(socks_sock);
return 0;
}
if (proxy->type == PROXY_TYPE_SOCKS5)
{
int rc;
char cached_domain[256];
// Per-config: only hand the hostname to the proxy (socks5h) when this config
// opts in; otherwise send the locally-resolved IP (socks5).
if (is_ipv6)
{
if (proxy->send_domain_to_proxy && dns_cache_lookup_v6(dest_ip6, cached_domain, sizeof(cached_domain)))
rc = socks5_connect_domain(socks_sock, cached_domain, dest_port, proxy);
else
rc = socks5_connect_v6(socks_sock, dest_ip6, dest_port, proxy);
}
else
{
if (proxy->send_domain_to_proxy && dns_cache_lookup(dest_ip, cached_domain, sizeof(cached_domain)))
rc = socks5_connect_domain(socks_sock, cached_domain, dest_port, proxy);
else
rc = socks5_connect(socks_sock, dest_ip, dest_port, proxy);
}
if (rc != 0)
{
reset_close(client_sock);
closesocket(socks_sock);
return 0;
}
}
else if (proxy->type == PROXY_TYPE_HTTP)
{
int rc = is_ipv6
? http_connect_v6(socks_sock, dest_ip6, dest_port, proxy)
: http_connect(socks_sock, dest_ip, dest_port, proxy);
if (rc != 0)
{
reset_close(client_sock);
closesocket(socks_sock);
return 0;
}
}
// Disable timeout for data transfer phase
DWORD zero_timeout = 0;
setsockopt(socks_sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&zero_timeout, sizeof(zero_timeout));
setsockopt(socks_sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&zero_timeout, sizeof(zero_timeout));
setsockopt(client_sock, SOL_SOCKET, SO_RCVTIMEO, (char*)&zero_timeout, sizeof(zero_timeout));
setsockopt(client_sock, SOL_SOCKET, SO_SNDTIMEO, (char*)&zero_timeout, sizeof(zero_timeout));
// Enable and configure customized TCP keep-alives
struct tcp_keepalive keepalive_settings;
keepalive_settings.onoff = 1;
keepalive_settings.keepalivetime = 300000; // 5 minutes in milliseconds
keepalive_settings.keepaliveinterval = 1000; // 1 second interval
DWORD bytes_returned = 0;
WSAIoctl(socks_sock, SIO_KEEPALIVE_VALS, &keepalive_settings, sizeof(keepalive_settings), NULL, 0, &bytes_returned, NULL, NULL);
WSAIoctl(client_sock, SIO_KEEPALIVE_VALS, &keepalive_settings, sizeof(keepalive_settings), NULL, 0, &bytes_returned, NULL, NULL);
// Preferred path: hand both sockets to the IOCP pool (no per-connection threads).
if (relay_start(client_sock, socks_sock, &meta))
return 0;
TRANSFER_CONFIG *transfer_config = (TRANSFER_CONFIG *)malloc(sizeof(TRANSFER_CONFIG));
if (transfer_config == NULL)
{
log_message("Memory allocation failed for transfer_config");
closesocket(client_sock);
closesocket(socks_sock);
return 0;
}
transfer_config->from_socket = client_sock;
transfer_config->to_socket = socks_sock;
// both transfer in current thread
transfer_handler((LPVOID)transfer_config);
// Sockets already closed in transfer_handler!
return 0;
}
// One-directional relay: reads from `from` and writes to `to`.
// Runs as a dedicated thread so upload and download never block each other.
// Uses a shared RELAY_PAIR reference count for safe socket cleanup:
// - whichever direction finishes first calls shutdown() on both sockets,
// which causes the sibling thread's recv() to return 0 and exit cleanly.
// - the last thread to exit (refs drops to 0) closes both sockets and
// frees the shared RELAY_PAIR.
DWORD WINAPI one_way_relay(LPVOID arg)
{
ONE_WAY_CONFIG *cfg = (ONE_WAY_CONFIG *)arg;
RELAY_PAIR *pair = cfg->pair;
SOCKET from = cfg->from;
SOCKET to = cfg->to;
free(cfg);
char *buf = (char *)malloc(131072); // 128 KB per-direction buffer
if (buf)
{
int len;
while ((len = recv(from, buf, 131072, 0)) > 0)
{
if (send_all(to, buf, len) == SOCKET_ERROR)
break;
}
free(buf);
}
// Signal the sibling relay to stop by shutting down both sockets.
// shutdown() is safe to call from any thread; it just drains/resets the
// socket without closing the handle, so the other thread's recv() returns 0.
shutdown(pair->sock_client, SD_BOTH);
shutdown(pair->sock_proxy, SD_BOTH);
// Last thread out closes and frees everything.
if (InterlockedDecrement(&pair->refs) == 0)
{
closesocket(pair->sock_client);
closesocket(pair->sock_proxy);
free(pair);
}
return 0;
}
// Bidirectional relay: spawns one thread for upload (client→proxy) and runs
// the download (proxy→client) direction in the calling thread. Blocks until
// both directions have finished so the caller (connection_handler) can return
// cleanly and its thread handle can be closed.
DWORD WINAPI transfer_handler(LPVOID arg)
{
TRANSFER_CONFIG *config = (TRANSFER_CONFIG *)arg;
SOCKET sock_client = config->from_socket;
SOCKET sock_proxy = config->to_socket;
free(config);
RELAY_PAIR *pair = (RELAY_PAIR *)malloc(sizeof(RELAY_PAIR));
if (!pair)
{
closesocket(sock_client);
closesocket(sock_proxy);
return 1;
}
pair->sock_client = sock_client;
pair->sock_proxy = sock_proxy;
pair->refs = 2;
// Upload: client → proxy (dedicated thread - may block on slow proxy send)
ONE_WAY_CONFIG *up = (ONE_WAY_CONFIG *)malloc(sizeof(ONE_WAY_CONFIG));
// Download: proxy → client (runs in this thread - loopback, rarely blocks)
ONE_WAY_CONFIG *dn = (ONE_WAY_CONFIG *)malloc(sizeof(ONE_WAY_CONFIG));
if (!up || !dn)
{
free(up);
free(dn);
free(pair);
closesocket(sock_client);
closesocket(sock_proxy);
return 1;
}
up->pair = pair; up->from = sock_client; up->to = sock_proxy;
dn->pair = pair; dn->from = sock_proxy; dn->to = sock_client;
// Spawn the upload relay in its own thread.
HANDLE upload_thread = CreateThread(NULL, 0, one_way_relay, up, 0, NULL);
if (!upload_thread)
{
free(up);
free(dn);
free(pair);
closesocket(sock_client);
closesocket(sock_proxy);
return 1;
}
// Run the download relay in this thread (blocks until done).
one_way_relay(dn);
// Wait for the upload relay thread to finish, then clean up its handle.
WaitForSingleObject(upload_thread, INFINITE);
CloseHandle(upload_thread);
return 0;
}
// ============================================================================================
// IOCP relay pool
//
// The data-transfer stage used to run two blocking threads (upload + download) and two 128 KB
// buffers for every proxied connection. A BitTorrent-style workload with a thousand peers meant
// 2,000+ threads, ~350 KB and ~9 handles per connection (issue #213: "over 1000 threads, machine
// sluggish despite low CPU"). Here a fixed pool of worker threads drives overlapped WSARecv /
// WSASend through an I/O completion port, so thread count no longer grows with connections.
//
// Memory also tracks *active* transfers, not open connections: an idle direction waits with a
// zero-byte receive (completes when data or a close is pending) and holds no buffer. When data
// arrives it takes a 64 KB buffer from a shared pool, reads, sends, and goes back to waiting
// unless the stream is still busy (then it keeps the buffer for the next read). Shrinking the
// per-connection buffer instead made fast transfers slow under load (measured), so buffers stay
// full size and only busy directions own one.
//
// Semantics are unchanged: each direction copies recv -> send; when either direction ends (EOF
// or error) both sockets are shut down and closed once both directions have drained.
// The blocking one_way_relay/transfer_handler path stays as the fallback if the pool cannot start.
// ============================================================================================
#define RELAY_BUF_SIZE 65536
#define RELAY_POOL_KEEP 256 // free buffers kept for reuse; more are freed
enum { RS_WAIT = 0, RS_READ, RS_SEND };
typedef struct RELAY_CONN RELAY_CONN;
typedef struct {
OVERLAPPED ov; // must stay first: the completion hands back &ov
RELAY_CONN *rc;
SOCKET src, dst;
char *buf; // NULL while waiting
DWORD len, off;
int state;
volatile LONG64 bytes; // payload bytes this direction has delivered (read by the live connections view)
} RELAY_DIR;
struct RELAY_CONN {
SOCKET s[2];
RELAY_DIR dir[2];
volatile LONG refs; // directions still alive
volatile LONG closing;
RELAY_CONN *prev, *next;
UINT64 id; // live connections view
ULONGLONG start;
FLOW_META meta;
};
volatile LONG g_active_relays = 0;
static volatile LONG64 g_flow_seq = 0;
static HANDLE g_iocp = NULL;
static HANDLE g_relay_workers[16];
static int g_relay_nworkers = 0;
static CRITICAL_SECTION g_relay_lock;
static BOOL g_relay_lock_ready = FALSE;
static RELAY_CONN *g_relay_head = NULL;
static char *g_relay_pool[RELAY_POOL_KEEP];
static int g_relay_pool_n = 0; // guarded by g_relay_lock
static char *relay_buf_get(void)
{
char *b = NULL;
EnterCriticalSection(&g_relay_lock);
if (g_relay_pool_n > 0) b = g_relay_pool[--g_relay_pool_n];
LeaveCriticalSection(&g_relay_lock);
return b ? b : (char *)malloc(RELAY_BUF_SIZE);
}
static void relay_buf_put(char *b)
{
if (b == NULL) return;
EnterCriticalSection(&g_relay_lock);
if (g_relay_pool_n < RELAY_POOL_KEEP) { g_relay_pool[g_relay_pool_n++] = b; b = NULL; }
LeaveCriticalSection(&g_relay_lock);
free(b);
}
static void relay_abort(RELAY_CONN *rc)
{
if (InterlockedCompareExchange(&rc->closing, 1, 0) == 0)
{
shutdown(rc->s[0], SD_BOTH);
shutdown(rc->s[1], SD_BOTH);
CancelIoEx((HANDLE)rc->s[0], NULL); // completes the sibling's pending recv/send with an error
CancelIoEx((HANDLE)rc->s[1], NULL);
}
}
static void relay_release(RELAY_CONN *rc)
{
if (InterlockedDecrement(&rc->refs) != 0) return;
EnterCriticalSection(&g_relay_lock);
if (rc->prev) rc->prev->next = rc->next; else g_relay_head = rc->next;
if (rc->next) rc->next->prev = rc->prev;
LeaveCriticalSection(&g_relay_lock);
closesocket(rc->s[0]);
closesocket(rc->s[1]);
relay_buf_put(rc->dir[0].buf);
relay_buf_put(rc->dir[1].buf);
free(rc);
InterlockedDecrement(&g_active_relays);
}
static void relay_dir_end(RELAY_DIR *d)
{
RELAY_CONN *rc = d->rc;
relay_abort(rc);
relay_release(rc);
}
static BOOL relay_io_ok(int rc_, int err) { return !(rc_ == SOCKET_ERROR && err != WSA_IO_PENDING); }
// Idle: give the buffer back and wait for readability with a zero-byte receive.
static BOOL relay_post_wait(RELAY_DIR *d)
{
relay_buf_put(d->buf); d->buf = NULL;
static char dummy;
WSABUF wb; wb.len = 0; wb.buf = &dummy;
DWORD flags = 0;
ZeroMemory(&d->ov, sizeof(d->ov));
d->state = RS_WAIT;
int r = WSARecv(d->src, &wb, 1, NULL, &flags, &d->ov, NULL);
return relay_io_ok(r, r == SOCKET_ERROR ? WSAGetLastError() : 0);
}
// Data is (or was) available: read it into the direction's buffer.
static BOOL relay_post_read(RELAY_DIR *d)
{
if (d->buf == NULL && (d->buf = relay_buf_get()) == NULL) return FALSE;
WSABUF wb; wb.len = RELAY_BUF_SIZE; wb.buf = d->buf;
DWORD flags = 0;
ZeroMemory(&d->ov, sizeof(d->ov));
d->state = RS_READ;
int r = WSARecv(d->src, &wb, 1, NULL, &flags, &d->ov, NULL);
return relay_io_ok(r, r == SOCKET_ERROR ? WSAGetLastError() : 0);
}
static BOOL relay_post_send(RELAY_DIR *d)
{
WSABUF wb; wb.len = d->len - d->off; wb.buf = d->buf + d->off;
ZeroMemory(&d->ov, sizeof(d->ov));
d->state = RS_SEND;
int r = WSASend(d->dst, &wb, 1, NULL, 0, &d->ov, NULL);
return relay_io_ok(r, r == SOCKET_ERROR ? WSAGetLastError() : 0);
}
static DWORD WINAPI relay_worker(LPVOID arg)
{
(void)arg;
for (;;)
{
DWORD n = 0; ULONG_PTR key = 0; OVERLAPPED *ov = NULL;
BOOL ok = GetQueuedCompletionStatus(g_iocp, &n, &key, &ov, INFINITE);
if (ov == NULL) break; // exit signal (or the port itself failed)
RELAY_DIR *d = (RELAY_DIR *)ov;
if (!ok) { relay_dir_end(d); continue; } // error / aborted
BOOL posted = TRUE;
switch (d->state)
{
case RS_WAIT: // data or a close is pending: read it for real
posted = relay_post_read(d);
break;
case RS_READ:
if (n == 0) { relay_dir_end(d); continue; } // EOF
d->len = n; d->off = 0;
posted = relay_post_send(d);
break;
default: // RS_SEND
if (n == 0) { relay_dir_end(d); continue; }
InterlockedExchangeAdd64(&d->bytes, (LONG64)n);
d->off += n;
if (d->off < d->len) posted = relay_post_send(d);
else if (d->len < RELAY_BUF_SIZE / 4) posted = relay_post_wait(d); // lightly used: drop the buffer
else posted = relay_post_read(d); // streaming: keep it
break;
}
if (!posted) relay_dir_end(d);
}
return 0;
}
BOOL relay_pool_start(void)
{
if (g_iocp != NULL) return TRUE;
if (!g_relay_lock_ready) { InitializeCriticalSection(&g_relay_lock); g_relay_lock_ready = TRUE; }
g_iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
if (g_iocp == NULL) return FALSE;
SYSTEM_INFO si; GetSystemInfo(&si);
int n = (int)si.dwNumberOfProcessors / 2;
if (n < 2) n = 2;
if (n > 8) n = 8;
g_relay_nworkers = 0;
for (int i = 0; i < n; i++)
{
g_relay_workers[g_relay_nworkers] = CreateThread(NULL, 0, relay_worker, NULL, 0, NULL);
if (g_relay_workers[g_relay_nworkers] != NULL) g_relay_nworkers++;
}
if (g_relay_nworkers == 0) { CloseHandle(g_iocp); g_iocp = NULL; return FALSE; }
return TRUE;
}
void relay_pool_stop(void)
{
if (g_iocp == NULL) return;
EnterCriticalSection(&g_relay_lock);
for (RELAY_CONN *rc = g_relay_head; rc != NULL; rc = rc->next) relay_abort(rc);
LeaveCriticalSection(&g_relay_lock);
for (int i = 0; i < 300 && g_active_relays > 0; i++) Sleep(10); // let the workers drain the aborted relays
for (int i = 0; i < g_relay_nworkers; i++) PostQueuedCompletionStatus(g_iocp, 0, 0, NULL);
WaitForMultipleObjects(g_relay_nworkers, g_relay_workers, TRUE, 3000);
for (int i = 0; i < g_relay_nworkers; i++) CloseHandle(g_relay_workers[i]);
g_relay_nworkers = 0;
CloseHandle(g_iocp);
g_iocp = NULL;
EnterCriticalSection(&g_relay_lock);
while (g_relay_pool_n > 0) free(g_relay_pool[--g_relay_pool_n]);
LeaveCriticalSection(&g_relay_lock);
}
// Takes over both (already handshaken) sockets. Returns FALSE if the pool is unavailable; the
// caller then falls back to the blocking relay and still owns the sockets.
BOOL relay_start(SOCKET client, SOCKET proxy, const FLOW_META *meta)
{
if (g_iocp == NULL || !running) return FALSE;
RELAY_CONN *rc = (RELAY_CONN *)calloc(1, sizeof(*rc));
if (rc == NULL) return FALSE;
if (CreateIoCompletionPort((HANDLE)client, g_iocp, 0, 0) != g_iocp ||
CreateIoCompletionPort((HANDLE)proxy, g_iocp, 0, 0) != g_iocp)
{
free(rc);
return FALSE;
}
rc->s[0] = client; rc->s[1] = proxy;
rc->refs = 2;
rc->id = (UINT64)InterlockedIncrement64(&g_flow_seq);
rc->start = GetTickCount64();
if (meta != NULL) rc->meta = *meta;
rc->dir[0].rc = rc; rc->dir[0].src = client; rc->dir[0].dst = proxy; // upload
rc->dir[1].rc = rc; rc->dir[1].src = proxy; rc->dir[1].dst = client; // download
EnterCriticalSection(&g_relay_lock);
rc->next = g_relay_head;
if (g_relay_head) g_relay_head->prev = rc;
g_relay_head = rc;
LeaveCriticalSection(&g_relay_lock);
InterlockedIncrement(&g_active_relays);
// Both directions start idle (no buffers); the first byte or close wakes them.
if (!relay_post_wait(&rc->dir[0])) relay_dir_end(&rc->dir[0]);
if (!relay_post_wait(&rc->dir[1])) relay_dir_end(&rc->dir[1]);
return TRUE;
}
// Live proxied TCP connections for the live connections view: raw fields copied under the relay list lock (a few
// hundred nanoseconds per entry), newest first. Names and hosts are resolved by the caller after the lock is released.
UINT32 relay_flows_snapshot(PB_FLOW *out, UINT32 max)
{
UINT32 n = 0;
if (!g_relay_lock_ready || out == NULL) return 0;
ULONGLONG now = GetTickCount64();
EnterCriticalSection(&g_relay_lock);
for (RELAY_CONN *rc = g_relay_head; rc != NULL && n < max; rc = rc->next)
{
if (rc->closing) continue; // being torn down
PB_FLOW *f = &out[n++];
ZeroMemory(f, sizeof(*f));
f->id = rc->id;
f->pid = rc->meta.pid;
f->proxy_config_id = rc->meta.proxy_id;
f->rule_id = rc->meta.rule_id;
ULONGLONG age = now - rc->start;
f->age_ms = age > 0xFFFFFFFEull ? 0xFFFFFFFEu : (UINT32)age;
f->sent = (UINT64)rc->dir[0].bytes; // client -> proxy
f->received = (UINT64)rc->dir[1].bytes; // proxy -> client
f->port = rc->meta.port;
f->is_ipv6 = rc->meta.v6 ? 1 : 0;
memcpy(f->dest, rc->meta.dest, 16);
}
LeaveCriticalSection(&g_relay_lock);
return n;
}