使反向 TCP 连接接受任意数量的连接（就像普通的 TCP 服务器一样）

对于一个Golang开发者来说，牢固扎实的基础是十分重要的，golang学习网就来带大家一点点的掌握基础知识点。今天本篇文章带大家了解《使反向 TCP 连接接受任意数量的连接（就像普通的 TCP 服务器一样）》，主要介绍了，希望对大家的知识积累有所帮助，快点收藏起来吧，否则需要时就找不到了！

我正在尝试为基于 connect 的 http 代理创建反向代理。想要使用代理的用户只需将machine a视为http代理即可。它的工作原理如下：

1. machine b 打开到 machine a 的 tcp 套接字。
2. 在 machine a 上，tcp 套接字在端口上公开，所有传入数据都通过隧道传输到 machine b (io.copy)。
3. 在 machine b 上，所有数据均通过隧道传输至本地 http 服务器以及至 machine a 的套接字。

本质上，这是 http 代理背后的反向代理。之所以如此复杂，是因为 http 代理位于 nat 之后（在 machine b 上），因此无法直接访问。该用例能够在 nat 后面托管 http 代理。

机器a隧道（go）：

package main

import (
    "log"
    "net"
)

func conn(c *net.tcpconn) string {
    return c.remoteaddr().string() + " (" + c.localaddr().string() + ")"
}

func proxifyconns(recipientconn, donorconn *net.tcpconn) {
    log.println("proxying", connrecipientconn), "and", conn(donorconn))
    go func() {
        _, err := io.copy(recipientconn, donorconn)
        if err != nil {
            utils.stacktraceerror(err)
        }
        recipientconn.close()
    }()
    go func() {
        _, err := io.copy(donorconn, recipientconn)
        if err != nil {
            utils.stacktraceerror(err)
        }
        recipientconn.close()
    }()
}


func main() {
    // open the donor listener
    donorsaddr, err := net.resolvetcpaddr("tcp4", ":11000")
    if err != nil {
        utils.stacktraceerrorandexit(err)
    }
    listenerdonors, err := net.listentcp("tcp", donorsaddr)
    if err != nil {
        utils.stacktraceerrorandexit(err)
    }
    defer listenerdonors.close()
    log.println("listening for donors on", listenerdonors.addr())

    // open the recipient listener
    recipientsaddr, err := net.resolvetcpaddr("tcp4", ":10000")
    if err != nil {
        utils.stacktraceerrorandexit(err)
    }
    listenerrecipients, err := net.listentcp("tcp", recipientsaddr)
    if err != nil {
        utils.stacktraceerrorandexit(err)
    }
    defer listenerrecipients.close()
    log.println("listening for recipients on", listenerrecipients.addr())

    //  handle donor connections
    donorconns := make(chan *net.tcpconn)
    go func() {
        for {
            donorconn, err := listenerdonors.accepttcp()
            donorconn.setkeepalive(true)
            if err != nil {
                utils.stacktraceerrorandexit(err)
                return
            }
            log.println("new donor connection from", conn(donorconn))
            donorconns <- donorconn
        }
    }()

    // handle recipient connections
    for {
        recipientconn, err := listenerrecipients.accepttcp()
        recipientconn.setkeepalive(true)
        if err != nil {
            utils.stacktraceerrorandexit(err)
            return
        }
        log.println("new recipient connection from", conn(recipientconn))
        donorconn := <-donorconns
        proxy.proxifyconns(recipientconn, donorconn)
    }
}

机器 b 隧道 (node.js)：

import net, { AddressInfo } from 'net';
import http from 'http';
import golgi from 'golgi';

export const startHttpProxy = () => {
  const server = http.createServer();
  let proxyServer: http.Server = golgi(server);
  // Listening to 0 assigns a random OS-assigned port
  proxyServer = proxyServer.listen(0);
  return proxyServer;
};

export const startDonorSocket = () => {
  const proxyServer = startHttpProxy();
  const proxyServerSocket = new net.Socket();
  proxyServerSocket.connect(
    (proxyServer.address() as AddressInfo).port,
    '127.0.0.1'
  );

  const donorSocket = new net.Socket();
  donorSocket.setKeepAlive(true);
  donorSocket.connect(11000, '2.226.102.14', () => {
    proxyServerSocket.pipe(donorSocket);
    donorSocket.pipe(proxyServerSocket);
  });
};

不幸的是，这在通过隧道传输到一个 tcp 地址时有效，但在通过隧道传输到多个 tcp 地址时则无效。如果我打开许多机器 b 隧道（node.js 代码），它就可以工作。我的意思是，每当接收者（http 代理用户）获取捐赠者连接 (node.js) 时，就会“消耗”该连接，因为在其上建立了持久的 tcp 隧道。

我想知道是否有一种方法可以使其适用于任意数量的 tcp 连接，而不仅仅是一个。我现在唯一的想法是每次消耗连接时创建更多的 tcp 捐赠者连接，但我想知道是否有更简单的解决方案。

正确答案

当你这样做时

go func() {
    for {
        donorconn, err := listenerdonors.accepttcp()
        donorconn.setkeepalive(true)
        if err != nil {
            utils.stacktraceerrorandexit(err)
            return
        }
        log.println("new donor connection from", conn(donorconn))
        donorconns <- donorconn
    }
}()

您开始处理第一个 tcp 连接。此代码在 donorconns <-donorconn 上阻塞。在发送到通道完成之前，循环不会进入第二次迭代（并且不会接受下一个 tcp 连接）。

你做了一个非常相似的第二个循环

// Handle recipient connections
for {
    recipientConn, err := listenerRecipients.AcceptTCP()
    recipientConn.SetKeepAlive(true)
    if err != nil {
        utils.StacktraceErrorAndExit(err)
        return
    }
    log.Println("New recipient connection from", Conn(recipientConn))
    donorConn := <-donorConns
    proxy.ProxifyConns(recipientConn, donorConn)
}

这需要 donorconn := <-donorconns 来完成（从第一个循环开始），并且需要 proxy.proxifyconns(recipientconn, donorconn) 来完成。

我不确定你打算如何让整个事情进行，但是，最有可能的是，你需要一个非常小的改变：
go proxy.proxifyconns（recipientconn，donorconn）

今天关于《使反向 TCP 连接接受任意数量的连接（就像普通的 TCP 服务器一样）》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！