标签: hole-punching

问题如下.这是我目前的测试代码没有成功.

static void Main(string[] args)
{
    if (args.Count() != 3)
    {
        Console.WriteLine("Bad args");
    }
    var ep = new IPEndPoint(IPAddress.Parse(args[0]), int.Parse(args[1]));
    var lp = new IPEndPoint(IPAddress.Any, int.Parse(args[2]));

    var s = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    s.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
    s.Bind(lp);

    var c = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    c.SetSocketOption(SocketOptionLevel.Socket, SocketOptionName.ReuseAddress, true);
    c.Bind(lp);

    Task.Run(() => { try { c.Connect(ep); } catch { } });
    s.Listen(10);
    var v = s.Accept();
    v.Close();
}

我该怎么做TCP打孔？我正在使用远程服务器进行测试.我跑wget local_public_ip:port/test.我的端口80的路由器设置,所以它不需要打孔.我的代码得到了连接.现在我尝试其他端口,我无法弄清楚如何打孔.

我所做的是(C#代码)

var l = new TcpListener(8090);
l.Start();
try { var …

我正在使用Magento Enterprise 1.10.1.1,需要在我们的产品页面上获取一些动态内容.我在块中插入当前时间以快速查看它是否正常工作,但似乎无法通过整页缓存.

我尝试过各种各样的实现:

http://tweetorials.tumblr.com/post/10160075026/ee-full-page-cache-hole-punching http://oggettoweb.com/blog/customizations-compatible-magento-full-page-cache/ http:/ /magentophp.blogspot.com/2011/02/magento-enterprise-full-page-caching.html

欢迎任何解决方案,想法,评论和建议.

这是我的代码:

应用程序/代码/本地/菲/示例/ etc/config.xml中

<?xml version="1.0"?>
<config>
    <modules>
        <Fido_Example>
            <version>0.1.0</version>
        </Fido_Example>
    </modules>
    <global>
        <blocks>
            <fido_example>
                <class>Fido_Example_Block</class>
            </fido_example>     
        </blocks>
    </global>
</config>

应用程序/代码/本地/菲/示例/ etc/cache.xml

<?xml version="1.0" encoding="UTF-8"?>
<config>
    <placeholders>
        <fido_example>
            <block>fido_example/view</block>
            <name>example</name>
            <placeholder>CACHE_TEST</placeholder>
            <container>Fido_Example_Model_Container_Cachetest</container>
            <cache_lifetime>86400</cache_lifetime>
        </fido_example>
    </placeholders>
</config>

应用程序/代码/本地/菲/实施例/块/ View.php

<?php

class Fido_Example_Block_View extends Mage_Core_Block_Template
{
    private $message;
    private $att;

    protected function createMessage($msg) {
        $this->message = $msg;
    }

    public function receiveMessage() {
        if($this->message != '') {
            return $this->message;
        } 
        else {
            $this->createMessage('Hello World');
            return …

对于我的学术项目,我正在努力实现这一目标.一个Web服务器节点JS应用程序侦听端口3000.所以,如果curl http://localhost:3000你将获得Hello World!.(一个简单的网页.

现在我在本地机器上运行webserver.我的调制解调器支持NAT.假设如果我在调制解调器中向前移动,myip:3000那么它向世界开放.但这是我遇到的最大问题 - 我不想使用调制解调器进行端口转发,相反,我将使用第三方服务器进行UDP打孔.

现在我的要求是来自net的任何人都应该能够访问我的网络服务器curl http://third-party-server-ip:3000.

我正在尝试的是编写另一个客户端 - 它打开与第三方服务器的连接.说它在港口打了一个洞41234.那个港口是开放的.第三方主机可以向该端口发送内容.

现在,互联网上的任何人都会curl http://third-party-ip:3000向第三方主机发起此命令.所以第三方返回myip:udpPunchHolePort即myip:41234.

任何人将再次卷曲myip:41234它将被节点js UDP打孔应用程序接收,因此它将重定向到localhost:3000.最后,anyone将收到来自的回复localhost:3000.

我的两个问题 -

1. 有没有比我在这里提出的更好的方式？
2. 对于这种东西,有没有任何着名的node-js lib,我看,我可以使用 UDP打孔.或者我正在考虑写一个Lib来做这个 - 这听起来像重新发明轮子？

注 - 在这个学术项目中,我们正在尝试学习如何在调制解调器中没有端口转发的情况下向世界开放任何本地应用程序.

我们阅读了skype协议分析,这也是我们的灵感.

我试图使用本文中概述的原理为Python 3中的防火墙编写基本的TCP打孔器.但是我无法连接任何东西.这是代码:

#!/usr/bin/python3

import sys
import socket
import _thread as thread

def client():
    c = socket.socket()

    c.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    c.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)

    c.bind((socket.gethostbyname(socket.gethostname()), int(sys.argv[3])))
    while(c.connect_ex((sys.argv[1], int(sys.argv[2])))):
        pass
    print("connected!")
    thread.interrupt_main()

def server():
    c = socket.socket()

    c.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
    c.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)

    c.bind((socket.gethostbyname(socket.gethostname()), int(sys.argv[3])))
    c.listen(5)
    c.accept()
    print("connected!")
    thread.interrupt_main()

def main():
    thread.start_new_thread(client, ())
    thread.start_new_thread(server, ())

    while True:
        pass

if __name__ == '__main__':
    main()

我决定在我的本地计算机上尝试打孔器,这样我就可以捕获两个实例发送的所有流量.我首先建立了一个环回防火墙:

iptables -A INPUT -i lo -m state --state RELATED,ESTABLISHED -j ACCEPT
iptables -A INPUT -i lo -j …

我知道这个话题并不新鲜。尽管有各种信息，但没有提供可靠的解决方案（至少我没有找到）。我有一个用 python3 编写的 P2P 守护进程，最后一个元素是通过 TCP 连接 NAT 后面的两个客户端。我对这个主题的参考：

https://bford.info/pub/net/p2pnat/

在两个客户端都连接了会议点服务器后，如何使两个客户端直接相互连接？

TCP打孔问题

到目前为止我所做的：

服务器：

#!/usr/bin/env python3

import threading
import socket

MY_AS_SERVER_PORT = 9001

TIMEOUT = 120.0
BUFFER_SIZE = 4096

def get_my_local_ip():
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # doesn't even have to be reachable
        s.connect(('10.255.255.255', 1))
        IP = s.getsockname()[0]
    except Exception:
        IP = '127.0.0.1'
    finally:
        s.close()
    return bytes(IP, encoding='utf-8')

def wait_for_msg(new_connection, client_address):
    while True:
        try:
            packet = new_connection.recv(BUFFER_SIZE)
            if packet:
                msg_from_client = packet.decode('utf-8')
                client_connected_from_ip = client_address[0]
                client_connected_from_port = client_address[1]

                print("We have …

我正在尝试了解 UDP 打洞，但我不太明白。从概念上看，这似乎很简单，但当我付诸实践时，我却无法做到这一点。据我了解，有一个公共服务器，我们称之为打孔服务器。客户端向打孔服务器发出请求（这是公开的）。打孔服务器会输出刚刚发出请求的客户端的公共 IP 和端口。只要该端口打开，那么基本上任何随机客户端都可以使用该特定端口和 IP 向该客户端发出请求？

我想我遇到的问题是，客户端能够向服务器发出请求。服务器能够在该公共端口和 IP 上将数据发送回客户端，但是当另一个客户端尝试使用相同的端口和 IP 向该客户端发送请求时，它不会通过，这就是让我困惑的地方。如果服务器可以发出请求，为什么另一个随机客户端不能发出该请求？

我试图用一个打孔的protocole制作一个服务器客户端.所以我发送到我的服务器我的客户端IP和客户端端口,当连接第二个用户时,服务器向客户端发送Ip和另一个客户端的端口.所以,当我有这个,我试图在我的两个客户端之间建立连接,我有一个错误与boost :: asio

terminate called after throwing an instance of 'boost::exception_detail::clone_impl<boost::exception_detail::error_info_injector<boost::system::system_error> >'

what():未找到服务已中止

这是我的代码

std::vector<std::string> response;

response = split(reply, ':');
std::cout << "name : " << response[0] << std::endl;
std::cout << "adresse : " << response[1] << std::endl;
std::cout << "port : " << response[2] << std::endl;

udp::resolver::query query(udp::v4(), response[0], response[1]);

std::cout << "resolved - - -  -" << std::endl;

struct client *cl = new struct client();

cl->endpoint_iterator = resolver.resolve(query);
// It Crash HERE

cl->sender_endpoint = *endpoint_iterator;
cl->name = response[0]; …

我需要实现UDP协议.PC必须在专用的UDP端口侦听传入的数据包.它还发送数据包(答案).该应用程序在Windows XP,7,8,....上运行

Windows防火墙阻止传入的数据包.这可以通过UDP打孔来规避.所以我必须发送一些不应该受伤的东西.但我想尽可能少打扰.

• 如何在防火墙关闭之前确定超时？
• 我可以检测到防火墙已关闭防火墙,以便我必须重新发送到打开数据包吗？当然,当防火墙关闭时我不会收到任何东西,但这可能还有其他原因.

所以，我一直在阅读 NAT-Punchthrough。我似乎明白了这个想法，但我很难实现它，而且我觉得我在这里错过了一步。测试此功能有点困难，因为当涉及到基于 Internet 的连接时，我几乎无法控制环境。

我有一个 SQL 服务器作为我的“协助者”运行，它保留服务器和客户端的外部地址，以及外部看到的端口。

以下是到目前为止的步骤： - 我通过存储服务器/客户端 IP/PORT 的 Web 请求（PHP 脚本）连接到我的 SQL 服务器 - 当两者都已知时，客户端和服务器都尝试连接（服务器主机在设置的端口上，客户端通过设置的端口连接） - 没有任何重大的事情发生

这里有 2 个未知数，我想和你核对一个。NAT-Punchthrough 是否真的要求我使用我计划在之后的步骤中连接的确切（内部/LAN）端口执行第一步？

如果是这样，我不知道我的服务器在水下究竟是如何工作的，所以它可能需要比我最初给定的静态端口更多的端口来连接，但这至少给了我一个提示。

如果有人对此有更多文档，请告诉我。

来源：
P2P 应用程序编程
http://www.mindcontrol.org/~hplus/nat-punch.html

我正在写一个玩具会议点/中继服务器,在端口5555上监听两个客户端"A"和"B".

它的工作原理如下:服务器从第一个连接的客户端A接收的每个字节都将被发送到第二个连接的客户端B,即使A和B不知道它们各自的IP:

A -----------> server <----------- B     # they both connect the server first
A --"hello"--> server                    # A sends a message to server
               server --"hello"--> B     # the server sends the message to B

此代码目前正在运行:

# server.py
import socket, time
from threading import Thread
socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
socket.bind(('', 5555))
socket.listen(5)
buf = ''
i = 0

def handler(client, i):
    global buf
    print 'Hello!', client, i 
    if i == 0:  # client A, who sends data to …