服务器中转C++源码与成品

是永乐哟 · 发表于昨天 16:56

我今天需要服务器中转，不想要frp，所以弄了这

成品.zip (245.67 KB, 下载次数: 9)

[C++] 纯文本查看 复制代码

#define _WIN32_WINNT 0x0600
#include <winsock2.h>
#include <ws2tcpip.h>
#include <iostream>
#include <thread>
#include <mutex>
#include <string>
#include <cstring>
#include <vector>
#include <atomic>
#pragma comment(lib, "ws2_32.lib")

const int BUFFER_SIZE = 8192;

// ---------- 工具函数 ----------
void closesocket_safe(SOCKET& s) {
    if (s != INVALID_SOCKET) {
        closesocket(s);
        s = INVALID_SOCKET;
    }
}

// 双向转发：从 src 读到 dst，任意一端出错即关闭两端
void forward_pipe(SOCKET src, SOCKET dst) {
    char buffer[BUFFER_SIZE];
    int n;
    while (true) {
        n = recv(src, buffer, sizeof(buffer), 0);
        if (n <= 0) break;
        int sent = 0;
        while (sent < n) {
            int ret = send(dst, buffer + sent, n - sent, 0);
            if (ret <= 0) {
                closesocket_safe(src);
                closesocket_safe(dst);
                return;
            }
            sent += ret;
        }
    }
    closesocket_safe(src);
    closesocket_safe(dst);
}

// ---------- 正向代理（服务端模式） ----------
// 监听 listen_port，转发到 target_ip:target_port
void run_forward_server(int listen_port, const std::string& target_ip, int target_port) {
    SOCKET listen_sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (listen_sock == INVALID_SOCKET) {
        std::cerr << "创建监听socket失败" << std::endl;
        return;
    }
    int opt = 1;
    setsockopt(listen_sock, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));

    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(listen_port);
    addr.sin_addr.s_addr = INADDR_ANY;
    if (bind(listen_sock, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
        std::cerr << "绑定端口 " << listen_port << " 失败" << std::endl;
        closesocket(listen_sock);
        return;
    }
    listen(listen_sock, SOMAXCONN);
    std::cout << "[正向代理] 监听端口 " << listen_port << " -> 转发到 " << target_ip << ":" << target_port << std::endl;

    while (true) {
        SOCKET client = accept(listen_sock, nullptr, nullptr);
        if (client == INVALID_SOCKET) continue;

        SOCKET target = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
        sockaddr_in taddr{};
        taddr.sin_family = AF_INET;
        taddr.sin_port = htons(target_port);
        inet_pton(AF_INET, target_ip.c_str(), &taddr.sin_addr);
        if (connect(target, (sockaddr*)&taddr, sizeof(taddr)) == SOCKET_ERROR) {
            std::cerr << "连接目标失败" << std::endl;
            closesocket(client);
            continue;
        }
        std::cout << "[+] 新连接建立" << std::endl;
        std::thread t1(forward_pipe, client, target);
        std::thread t2(forward_pipe, target, client);
        t1.detach();
        t2.detach();
    }
}

// ---------- 反向代理（服务端模式，需要配合客户Duan） ----------
// 监听控制端口（等待客户Duan连接）和外部端口（公网访问），将两者绑定转发
// 注意：当前版本只支持单个客户Duan连接，且一次只处理一个外部连接（串行）
void run_reverse_server(int data_port, int control_port) {
    // 创建数据监听socket
    SOCKET data_listen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    SOCKET ctrl_listen = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (data_listen == INVALID_SOCKET || ctrl_listen == INVALID_SOCKET) {
        std::cerr << "创建socket失败" << std::endl;
        return;
    }
    int opt = 1;
    setsockopt(data_listen, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));
    setsockopt(ctrl_listen, SOL_SOCKET, SO_REUSEADDR, (char*)&opt, sizeof(opt));

    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = INADDR_ANY;

    addr.sin_port = htons(data_port);
    if (bind(data_listen, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
        std::cerr << "绑定数据端口 " << data_port << " 失败" << std::endl;
        closesocket(data_listen);
        closesocket(ctrl_listen);
        return;
    }
    listen(data_listen, SOMAXCONN);

    addr.sin_port = htons(control_port);
    if (bind(ctrl_listen, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
        std::cerr << "绑定控制端口 " << control_port << " 失败" << std::endl;
        closesocket(data_listen);
        closesocket(ctrl_listen);
        return;
    }
    listen(ctrl_listen, SOMAXCONN);

    std::cout << "[反向代理] 数据端口 " << data_port << "，控制端口 " << control_port << std::endl;
    std::cout << " 等待客户Duan连接..." << std::endl;

    // 接受一个客户Duan连接
    SOCKET client_sock = accept(ctrl_listen, nullptr, nullptr);
    if (client_sock == INVALID_SOCKET) {
        std::cerr << "接受客户Duan连接失败" << std::endl;
        closesocket(data_listen);
        closesocket(ctrl_listen);
        return;
    }
    std::cout << "[+] 客户Duan已连接" << std::endl;
    // 关闭控制监听，不再接受新客户Duan（简化）
    closesocket(ctrl_listen);

    // 循环处理外部连接（每次一个）
    while (true) {
        std::cout << "
 等待外部连接..." << std::endl;
        SOCKET external = accept(data_listen, nullptr, nullptr);
        if (external == INVALID_SOCKET) {
            std::cerr << "accept外部连接失败" << std::endl;
            break;
        }
        std::cout << "[+] 外部连接到来，开始转发" << std::endl;
        // 启动两个转发线程，将 external 与 client_sock 绑定
        std::thread t1(forward_pipe, external, client_sock);
        std::thread t2(forward_pipe, client_sock, external);
        t1.join();  // 等待转发结束（任一端断开）
        t2.join();
        // 转发结束后，外部socket已关闭，client_sock可能已关闭（若客户Duan断开）
        if (client_sock == INVALID_SOCKET) {
            std::cerr << "[!] 客户Duan断开，退出" << std::endl;
            break;
        }
        std::cout << "[-] 转发结束，准备接受下一个外部连接" << std::endl;
    }
    closesocket(data_listen);
    closesocket(client_sock);
}

// ---------- 客户Duan模式（反向代理的客户Duan） ----------
// 连接服务器的控制端口，然后将该socket与本地服务（target_ip:target_port）双向转发
void run_client(const std::string& server_ip, int control_port,
    const std::string& target_ip, int target_port) {
    SOCKET sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (sock == INVALID_SOCKET) {
        std::cerr << "创建socket失败" << std::endl;
        return;
    }
    sockaddr_in addr{};
    addr.sin_family = AF_INET;
    addr.sin_port = htons(control_port);
    inet_pton(AF_INET, server_ip.c_str(), &addr.sin_addr);
    if (connect(sock, (sockaddr*)&addr, sizeof(addr)) == SOCKET_ERROR) {
        std::cerr << "连接服务器 " << server_ip << ":" << control_port << " 失败" << std::endl;
        closesocket(sock);
        return;
    }
    std::cout << "[+] 已连接到服务器" << std::endl;

    // 连接到本地服务
    SOCKET local = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if (local == INVALID_SOCKET) {
        std::cerr << "创建本地socket失败" << std::endl;
        closesocket(sock);
        return;
    }
    sockaddr_in laddr{};
    laddr.sin_family = AF_INET;
    laddr.sin_port = htons(target_port);
    inet_pton(AF_INET, target_ip.c_str(), &laddr.sin_addr);
    if (connect(local, (sockaddr*)&laddr, sizeof(laddr)) == SOCKET_ERROR) {
        std::cerr << "连接本地服务 " << target_ip << ":" << target_port << " 失败" << std::endl;
        closesocket(sock);
        closesocket(local);
        return;
    }
    std::cout << "[+] 已连接到本地服务" << std::endl;
    std::cout << "
 开始双向转发 (服务器 <-> 本地服务)" << std::endl;

    std::thread t1(forward_pipe, sock, local);
    std::thread t2(forward_pipe, local, sock);
    t1.join();
    t2.join();
    closesocket(sock);
    closesocket(local);
    std::cout << "[-] 客户Duan退出" << std::endl;
}

// ---------- 主菜单 ----------
int main() {
    WSADATA wsa;
    if (WSAStartup(MAKEWORD(2, 2), &wsa) != 0) {
        std::cerr << "WSAStartup失败" << std::endl;
        return 1;
    }

    while (true) {
        std::cout << "\n========== TCP 转发器 ==========\n";
        std::cout << "1. 服务端 - 正向代理（转发本机端口）\n";
        std::cout << "2. 服务端 - 反向代理（等待客户Duan，暴露nei网服务）\n";
        std::cout << "3. 客户Duan - 连接到反向代理服务器\n";
        std::cout << "0. 退出\n";
        std::cout << "请选择: ";
        int choice;
        std::cin >> choice;

        if (choice == 0) break;

        if (choice == 1) {
            int listen_port, target_port;
            std::string target_ip;
            std::cout << "输入监听端口（外部访问端口）: ";
            std::cin >> listen_port;
            std::cout << "输入目标IP（如127.0.0.1）: ";
            std::cin >> target_ip;
            std::cout << "输入目标端口: ";
            std::cin >> target_port;
            std::cout << "
 启动正向代理...\n";
            run_forward_server(listen_port, target_ip, target_port);
        }
        else if (choice == 2) {
            int data_port, control_port;
            std::cout << "输入数据端口（外部访问端口，如5001）: ";
            std::cin >> data_port;
            std::cout << "输入控制端口（客户Duan连接端口，如7000）: ";
            std::cin >> control_port;
            std::cout << "
 启动反向代理服务端...\n";
            run_reverse_server(data_port, control_port);
        }
        else if (choice == 3) {
            std::string server_ip, target_ip;
            int control_port, target_port;
            std::cout << "输入服务器公网IP: ";
            std::cin >> server_ip;
            std::cout << "输入服务器控制端口: ";
            std::cin >> control_port;
            std::cout << "输入本地目标IP（如127.0.0.1）: ";
            std::cin >> target_ip;
            std::cout << "输入本地目标端口（如5000）: ";
            std::cin >> target_port;
            std::cout << "
 启动客户Duan...\n";
            run_client(server_ip, control_port, target_ip, target_port);
        }
        else {
            std::cout << "无效选项\n";
        }
    }

    WSACleanup();
    return 0;
}

wh1234567 · 发表于 2 小时前

感谢分享

是永乐哟 · 发表于 3 小时前

抱抱你发表于 2026-7-2 19:54
你说我可以服务器加载某雷加速器然后国外节点中转到服务器让我的飞机连接呢 ...

理论可行，但我感觉这个会很麻烦
加速器的代理必须是全局的那种虚拟网卡
这样飞机的流量才能走
然后还有就是封号的问题，这些加速器我不知道会不会检测封号，还有宽带限速这些问题

bianyuan456 · 发表于 4 小时前

已经顶贴，感谢您对论坛的支持！

rensheng2021 · 发表于昨天 23:40

抱抱你发表于 2026-7-2 19:54
你说我可以服务器加载某雷加速器然后国外节点中转到服务器让我的飞机连接呢 ...

自己的服务器可以，某雷的需要知道端口，认证用户名+密码，或许是可以的

抱抱你 · 发表于昨天 19:54

你说我可以服务器加载某雷加速器然后国外节点中转到服务器让我的飞机连接呢

yxl2008 · 发表于昨天 18:30

谢谢分享楼主这个好东西

凌云啊 · 发表于昨天 18:01

谢谢分享楼主这个好东西

wgqxj · 发表于昨天 17:07

谢谢分享

		自动登录	找回密码
密码			注册

[其它源码] 服务器中转C++源码与成品

浏览过的版块