1、打洞解决了什么问题？
我们平常使用的一般都为私有ip，但是私有ip之间是不能直接通信的，如果要进行通信只能通过公网上的服务器进行数据的转发，难道我们每次发送数据都要经过公网上的服务器转发吗？也不是不可以，但是服务器的承受能力就会大大增加。此时就需要我们的打洞技术的出现了，打洞的出现解决了私有ip之间直接通信的问题（还是需要经过一次公网服务器）
例如：QQ中的聊天就广泛的使用到了打洞技术
<!-- more -->
2、打洞的实现过程与原理
私有ip的数据都要经过路由器的转发，路由器上有一张NAPT表（IP端口映射表），NAPT表记录的是【私有IP：端口】与【公有IP：端口】的映射关系（就是一一对应关系），本文讲到的路由均是以NAPT为工作模式，这并不影响对打洞。实际中的数据实际发送给的都是路由器的【公有IP：端口】，然后经过路由器进过查询路由表后再转发给【私有的IP：端口】的。
举个示例：
用户A
电脑IP：192.168.1.101
桌面上有个客户端程序采用的网络端口：10000
路由器的公有IP：120.78.201.201（实际中常常为多级路由，这里以最简单的一层路由举例）
NAPT路由器的NAPT表的其中一条记录为：【120.78.201.201：20202】-【192.168.1.101：10000】
用户B
电脑IP：192.168.2.202
桌面上有个客户端程序采用的网络端口：22222
路由器的公有IP：120.78.202.202
NAPT路由器的NAPT表的其中一条记录为：【120.78.202.202：20000】-【192.168.2.202：22222】
打洞服务器P2Pserver
IP：120.78.202.100
port：20000
此时用户A的电脑发给了服务器一条数据，服务器收到用户A的IP与端口是多少呢？当然为120.78.201.201：20202，数据包经过路由的时候进行了重新的封包。如果服务器此时发一条数据给用户A，发往的IP与端口是什么呢？当然为120.78.201.201：20202，此时路由器收到这个数据包后，进行查询NAPT表中120.78.201.201：20202对应的IP与端口信息，发现是192.168.1.101：10000，然后路由器就转发给IP为192.168.1.101：10000的电脑，然后电脑上的应用程序就收到这条信息了。
既然如此，我们私有IP虽然不能直接通信，但是我们能够发给公有IP！如果用户B需要给用户A发一条信息时，用户B直接将数据发往目的IP、端口为120.78.201.201：20202的地方不就行了？
这里有两个问题：
第一，用户B怎么知道用户A在路由上映射的IP与端口；
第二，用户B直接将数据包发往120.78.201.201：20202，路由器是会将用户B的数据包丢弃的，因为路由器里面没有关于用户B120.78.202.202的路由信息（路由器里面还有个路由表，用于路由），无法进行路由，所以将会进行丢弃。
如何解决第一个问题？
通过打洞服务器，将用户A映射的IP、端口信息告诉用户B即可。
如何解决第二个问题？
如果打洞服务器首先告诉用户A先发一条信息给用户B（用户A得知用户B的地址信息也是通过打洞服务器），注意此时用户B是收不到的，用户B的路由同样会进行丢弃，但是这并不要紧，因为用户A发了这条信息后，用户A的路由就会记录关于用户B的路由信息（该信息记录的是将用户B的IP信息路由到用户A电脑），然后此时用户B再发给用户A一条信息，就不会进行丢弃了，因为用户A的路由里面有用户B的路由信息。
代码：https://github.com/xiazemin/udpNAT
server.go
代码语言：javascript复制package main
import (
"fmt"
"log"
"net"
"time"
)
func main() {
listener, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 9981})
if err != nil {
fmt.Println(err)
return
}
log.Printf("本地地址: <%s> n", listener.LocalAddr().String())
peers := make([]net.UDPAddr, 0, 2)
data := make([]byte, 1024)
for {
n, remoteAddr, err := listener.ReadFromUDP(data)
if err != nil {
fmt.Printf("error during read: %s", err)
}
log.Printf("<%s> %sn", remoteAddr.String(), data[:n])
peers = append(peers, *remoteAddr)
if len(peers) == 2 {
log.Printf("进行UDP打洞,建立 %s <--> %s 的连接n", peers[0].String(), peers[1].String())
listener.WriteToUDP([]byte(peers[1].String()), &peers[0])
listener.WriteToUDP([]byte(peers[0].String()), &peers[1])
time.Sleep(time.Second * 8)
log.Println("中转服务器退出,仍不影响peers间通信")
return
}
}
}
client.go
代码语言：javascript复制package main
import (
"fmt"
"log"
"net"
"os"
"strconv"
"strings"
"time"
)
var tag string
const HAND_SHAKE_MSG = "我是打洞消息"
func main() {
// 当前进程标记字符串,便于显示
tag = os.Args[1]
srcAddr := &net.UDPAddr{IP: net.IPv4zero, Port: 9982} // 注意端口必须固定
dstAddr := &net.UDPAddr{IP: net.ParseIP("207.148.70.129"), Port: 9981}
conn, err := net.DialUDP("udp", srcAddr, dstAddr)
if err != nil {
fmt.Println(err)
}
if _, err = conn.Write([]byte("hello, I'm new peer:" tag)); err != nil {
log.Panic(err)
}
data := make([]byte, 1024)
n, remoteAddr, err := conn.ReadFromUDP(data)
if err != nil {
fmt.Printf("error during read: %s", err)
}
conn.Close()
anotherPeer := parseAddr(string(data[:n]))
fmt.Printf("local:%s server:%s another:%sn", srcAddr, remoteAddr, anotherPeer.String())
// 开始打洞
bidirectionHole(srcAddr, &anotherPeer)
}
func parseAddr(addr string) net.UDPAddr {
t := strings.Split(addr, ":")
port, _ := strconv.Atoi(t[1])
return net.UDPAddr{
IP: net.ParseIP(t[0]),
Port: port,
}
}
func bidirectionHole(srcAddr *net.UDPAddr, anotherAddr *net.UDPAddr) {
conn, err := net.DialUDP("udp", srcAddr, anotherAddr)
if err != nil {
fmt.Println(err)
}
defer conn.Close()
// 向另一个peer发送一条udp消息(对方peer的nat设备会丢弃该消息,非法来源),用意是在自身的nat设备打开一条可进入的通道,这样对方peer就可以发过来udp消息
if _, err = conn.Write([]byte(HAND_SHAKE_MSG)); err != nil {
log.Println("send handshake:", err)
}
go func() {
for {
time.Sleep(10 * time.Second)
if _, err = conn.Write([]byte("from [" tag "]")); err != nil {
log.Println("send msg fail", err)
}
}
}()
for {
data := make([]byte, 1024)
n, _, err := conn.ReadFromUDP(data)
if err != nil {
log.Printf("error during read: %sn", err)
} else {
log.Printf("收到数据:%sn", data[:n])
}
}
}
