18 网络编程 UDP

[TOC]

网络编程 UDP

用户数据报协议（User Datagram Protocol，缩写为UDP），又称用户数据报文协议，是一个简单的面向数据报(package-oriented)的传输层协议，正式规范为RFC 768。UDP只提供数据的不可靠传递，它一旦把应用程序发给网络层的数据发送出去，就不保留数据备份（所以UDP有时候也被认为是不可靠的数据报协议）。UDP在IP数据报的头部仅仅加入了复用和数据校验。

由于缺乏可靠性且属于非连接导向协议，UDP应用一般必须允许一定量的丢包、出错。但有些应用，比如TFTP，如果需要则必须在应用层增加根本的可靠机制。但是绝大多数UDP应用都不需要可靠机制，甚至可能因为引入可靠机制而降低性能。流媒体（流技术）、即时多媒体游戏和IP电话（VoIP）一定就是典型的UDP应用。如果某个应用需要很高的可靠性，那么可以用传输控制协议（TCP协议）来代替UDP。

由于缺乏拥塞控制（congestion control），需要基于网络的机制来减少因失控和高速UDP流量负荷而导致的拥塞崩溃效应。换句话说，因为UDP发送者不能够检测拥塞，所以像使用包队列和丢弃技术的路由器这样的网络基本设备往往就成为降低UDP过大通信量的有效工具。数据报拥塞控制协议（DCCP）设计成通过在诸如流媒体类型的高速率UDP流中，增加主机拥塞控制，来减小这个潜在的问题。

典型网络上的众多使用UDP协议的关键应用一定程度上是相似的。这些应用包括域名系统（DNS）、简单网络管理协议（SNMP）、动态主机配置协议（DHCP）、路由信息协议（RIP）和某些影音流服务等等。

UDP协议的全称是用户数据报协议，在网络中它与TCP协议一样用于处理数据包，是一种无连接的协议。在OSI模型中，在第四层——传输层，处于IP协议的上一层。UDP有不提供数据包分组、组装和不能对数据包进行排序的缺点，也就是说，当报文发送之后，是无法得知其是否安全完整到达的。UDP用来支持那些需要在计算机之间传输数据的网络应用。包括网络视频会议系统在内的众多的客户/服务器模式的网络应用都需要使用UDP协议。UDP协议从问世至今已经被使用了很多年，虽然其最初的光彩已经被一些类似协议所掩盖，但是即使是在今天UDP仍然不失为一项非常实用和可行的网络传输层协议。

与TCP（传输控制协议）协议一样，UDP协议直接位于IP（网际协议）协议的顶层。根据OSI（开放系统互连）参考模型，UDP和TCP都属于传输层协议。

UDP首部字段由4个部分组成，其中两个是可选的。各16bit的来源端口和目的端口用来标记发送和接受的应用进程。因为UDP不需要应答，所以来源端口是可选的，如果来源端口不用，那么置为零。在目的端口后面是长度固定的以字节为单位的长度域，用来指定UDP数据报包括数据部分的长度，长度最小值为8byte。首部剩下地16bit是用来对首部和数据部分一起做校验和（Checksum）的，这部分是可选的，但在实际应用中一般都使用这一功能。

TCP 和 UDP 的区别

• | TCP(传输控制协议) | UDP(用户数据报协议)

• | ------- | ------ 是否连接 | 面向连接 | 面向非连接 传输可靠性 | 可靠的 | 不可靠的 应用场合 | 传输大量的数据 | 少量数据 速度 | 慢 | 快

UDP通信

• 单播(unicast): 是指封包在计算机网络的传输中，目的地址为单一目标的一种传输方式。它是现今网络应用最为广泛，通常所使用的网络协议或服务大多采用单播传输，例如一切基于TCP的协议。

• 组播(multicast): 也叫多播， 多点广播或群播。 指把信息同时传递给一组目的地址。它使用策略是最高效的，因为消息在每条网络链路上只需传递一次，而且只有在链路分叉的时候，消息才会被复制。

• 广播(broadcast):是指封包在计算机网络中传输时，目的地址为网络中所有设备的一种传输方式。实际上，这里所说的“所有设备”也是限定在一个范围之中，称为“广播域”。

• 任播(anycast):是一种网络寻址和路由的策略，使得资料可以根据路由拓朴来决定送到“最近”或“最好”的目的地。

UDP是无连接的，可靠性不如TCP，传递的是报文。不保证准确性，不保证数据顺序，通讯速度更快

• UDP报文最大65535字节，包头8字节，IP包头20字节，实际可用65507。

• 对数据传输安全性、稳定性有更高要求的使用TCP，实时传输要求高的使用UDP。

• adr,err := net.ResolveUDPAddr("udp","ip:port")

• udpconn,err := net.ListenUDP("udp",adr)

• defer udpconn.close()

• n,clientAddr,err := udpconn.ReadFromUDP([]byte)

• n为读到的字节数，客户端ip地址，错误。

• writeToUDP([] byte, ip:port)

单播通信

单播通信每次只有两个实体相互通信，发送端和接收端都是唯一确定的。在IPv4网络中，0.0.0.0到223.255.255.255属于单播地址。

单播有UDP和TCP两种方式。

通信接收端案例：

package main

import (
	"fmt"
	"net"
)

func main() {
	count := 0
	listener, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.ParseIP("0.0.0.0"), Port: 11080})
	if err != nil {
		fmt.Println("UDP监听异常：",err)
		return
	}
	data := make([]byte, 1024)
	for {
		n, remoteAddr, err := listener.ReadFromUDP(data)
		if err != nil {
			fmt.Println("读取数据包出现异常：", err)
		}
		fmt.Printf("收到%s的数据：%s \n", remoteAddr, data[:n])
		count++
		_, err = listener.WriteToUDP([]byte(fmt.Sprintf("回应客户端%d",count)), remoteAddr)
		if err != nil {
			fmt.Printf(err.Error())
		}
	}
}

通信发送端案例：

package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	ip := net.ParseIP("127.0.0.1")
	srcAddr := &net.UDPAddr{IP: net.IPv4zero, Port: 0}
	dstAddr := &net.UDPAddr{IP: ip, Port: 11080}
	conn, err := net.DialUDP("udp", srcAddr, dstAddr)
	if err != nil {
		fmt.Println(err)
	}
	defer conn.Close()
	b := make([]byte, 1024)
	//	监听键盘输入
	n,_ := os.Stdin.Read(b)
	conn.Write(b[:n])

	buf := make([]byte, 1024)
	n,_ = conn.Read(buf)
	fmt.Println("收到响应数据：",string(buf[:n]))
}

组播（多播）通信

组播与单播区别

• 与单播相比，没有纠错机制，丢包后难以弥补。

• 当需要向多个主机发送报文时，单播时主机必须重复产生多个相同的报文来进行发送，对于一些实时性要求高的数据，在源主机要产生多个相同的数据报文后，再产生第二个数据报文，这通常是无法容忍的，并且对主机照成很大负担。组播则只需要一个报文即可。

• 组播的目的是把信息发送给一组设备，同时避免发送重复的数据流，因此它节省了宝贵的网络资源，比如带宽利用率。

组播与广播区别

• 广播是把报文传送到局域网内每个主机上，不管这个主机是否对报文感兴趣，造成了带宽的浪费和主机的资源浪费。而组播有一套对组员和组之间关系维护的机制，可以明确的知道在某个子网中，是否有主机对这类组播报文感兴趣。

实际情况下，经常需要对一组特定的主机进行通信，而不是所有局域网上的主机。

• IP组播（也称多址广播或多播），是一种允许一台或多台主机发送数据包到多台主机的TCP/IP网络技术。

• 多播是 IPv6 数据包的3种基本目的地址类型之一，多播是一点对多点的通信,　IPv6 没有采用 IPv4 中的组播术语，而是将广播看成是多播的一个特殊例子。

• 多播组只能用UDP 或者原始套接字实现，不能用TCP。

“组播”通常用来指代IP组播。IP组播是一种通过使用一个组播地址将数据在同一时间以高效的方式发往处于TCP/IP网络上的多个接收者的协议。此外，它还常用来与RTP等音视频协议相结合。组播报文的目的地址使用D类IP地址，D类地址不能出现在IP报文的源IP地址字段。

组播组可以是永久的也可以是临时的。组播组地址中，有一部分由官方分配的，称为永久组播组。永久组播组保持不变的是它的ip地址，组中的成员构成可以发生变化。永久组播组中成员的数量都可以是任意的，甚至可以为零。那些没有保留下来供永久组播组使用的ip组播地址，可以被临时组播组利用。

224.0.0.0～224.0.0.255为预留的组播地址（永久组地址），地址224.0.0.0保留不做分配，其它地址供路由协议使用； 224.0.1.0～224.0.1.255是公用组播地址，Internetwork Control Block； 224.0.2.0～238.255.255.255为用户可用的组播地址（临时组地址），全网范围内有效； 239.0.0.0～239.255.255.255为本地管理组播地址，仅在特定的本地范围内有效。 永久的组播地址：参考。

以太网传输单播ip报文的时候，目的mac地址使用的是接收者的mac地址。但是在传输组播报文时，传输目的不再是一个具体的接收者，而是一个成员不确定的组，所以使用的是组播mac地址。组播mac地址是和组播ip地址对应的。iana（internet assigned number authority）规定，组播mac地址的高24bit为0x01005e，mac 地址的低23bit为组播ip地址的低23bit。 由于ip组播地址的后28位中只有23位被映射到mac地址，这样就会有32个ip组播地址映射到同一mac地址上。

组播常见应用

• IP组播消息可以跨越三层边界，从一台设备发给多台设备、从多台设备发给多台设备/或从多台设备发给一台设备。目的节点（接收方）通过发送加入和离开消息，创建出一个按需接收组播流的设备团体。即使需要接收消息的接收方数量庞大，组播也要求发送方只发送一条数据包流，从而优化了网络资源。网络节点或三层设备负责复制消息，并将其引导给接收方。很多应用层程序都利用了组播对于消息流的优化。这些应用层程序也是推动组播在网络架构中发展的主要动力。一些依赖于组播的常见应用：

• 适用于多接收者期望收取相同流量的场景、适用于接收者地址(或位置)未知的场景、多媒体直播(如IPTV)、培训、联合作业场合的通信、数据仓库、金融应用(股票；其他“单到多”数据发布应用。

• 对组播技术细微差别的理解能够有效地部署那些将组播作为传输机制的应用和服务。

组播的组成

• 组播源(Source)：组播流的发送者,例如多媒体服务器。组播源无需运行任何组播协议，只需简单地将组播数据发送出来即可。

• 组播路由器(Multicast Router):支持组播、运行组播协议的网络设备。实际上不仅仅路由器能够支持组播，交换机，防火墙等设备也能够支持组播(取决于设备型号) , 路由器仅是一个代表。

• 组播接收者(Receiver):也被称为组播组成员,是期望接收特定组播组流量的设备，例如运行多媒体直播客户端软件的PC。

常用术语

• 组播组( Multicast Group) : 一个使用组播IP地址标识的群组。例如224.1.1.1便是一 个IPv4组播地址，该地址标识了一组接收者，组播源可以向这个地址发送组播数据，而需要该数据的设备则需加入组播组224.1.1.1 ,以便从组播网络中获得源发往该组播组的数据；

• 第一跳路由器( First-Hop Router) :直连Source的组播路由器。 该路由器负责将Source发送出来的组播报文转发到组播网络中；

• 最后一跳路由器( Last-Hop Router) :直连组播成员的组播路由器。该路由器负责将组播流量转发到直连网络(接收者) ,也负责管理及维护直连网段中的组播组的成员关系；

• 组播分发树（Muticast distribution tree）：由组播路由协议构建，是组播流量的转发路径；

组播接收者(Receiver)：

• 接收者要向 组播路由器(Multicast Router) 订阅消息。

package main

import (
	"fmt"
	"net"
)

func main() {
	// 订阅 224.0.0.1:21080 的 Multicast Router
	addr, err := net.ResolveUDPAddr("udp", "224.0.0.1:21080")
	if err != nil {
		fmt.Println("ResolveUDPAddr 出现异常：",err)
	}
	no1,_ := net.InterfaceByName("no1")
	listener, errL := net.ListenMulticastUDP("udp", no1, addr)
	if errL != nil {
		fmt.Println("ListenMulticastUDP 出现异常：",errL)
		return
	}
	buf := make([]byte, 1024)
	for {
		n, remoteAddr, errR := listener.ReadFromUDP(buf)
		if errR != nil {
			fmt.Println("读取消息出现异常：", errR)
		}
		fmt.Printf("收到%s的消息： %s \n", remoteAddr, buf[:n])
	}
}

组播源(Source)：

package main

import (
	"fmt"
	"net"
	"time"
)

func main() {
	ip := net.ParseIP("224.0.0.1")
	rAddr := &net.UDPAddr{IP: ip, Port: 21080}
	conn, err := net.DialUDP("udp", nil, rAddr)
	if err != nil {
		fmt.Println("消息发送异常：",err)
	}
	defer conn.Close()
	conn.Write([]byte("阿弥陀佛，妈咪妈咪哄。"))
	time.Sleep(1 * time.Second)
}

广播通信

单播和广播是两个极端，单播对一个主机进行通信，广播对整个局域网的主机进行通信。

并非所有的计算机网络都支持广播，例如X.25网络和帧中继都不支持广播，而且也没有在“整个互联网范围中”的广播。IPv6亦不支持广播，广播相应的功能由任播(anycast)代替。 通常，广播都是限制在局域网中的，比如以太网或令牌环网络。因为广播在局域网中造成的影响远比在广域网中小得多。

以太网和IPv4网都用全1的地址表示广播，分别是ff:ff:ff:ff:ff:ff和255.255.255.255。令牌环网络使用IEEE 802.2控制域中的一个特殊值来表示广播。

广播地址(Broadcast Address)是专门用于同时向网络中所有工作站进行发送的一个地址。在使用TCP/IP 协议的网络中，主机标识段host ID 为全1 的IP 地址为广播地址，广播的分组传送给host ID段所涉及的所有计算机。例如，对于10.1.1.0 （255.255.255.0 ）网段，其广播地址为10.1.1.255 （255 即为2 进制的11111111 ），当发出一个目的地址为10.1.1.255 的分组（封包）时，它将被分发给该网段上的所有计算机。 本地广播地址为255.255.255.255。

广播接收端：

package main

import (
	"fmt"
	"net"
)

func main() {
	listener, err := net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: 38080})
	if err != nil {
		fmt.Println(err)
		return
	}
	count := 0
	for {
		buf := make([]byte, 1024)
		n, remoteAddr, errR := listener.ReadFromUDP(buf)
		if errR != nil {
			fmt.Println("读取广播数据出现异常：", errR)
		}
		fmt.Printf("收到来自%s的广播数据：%s \n", remoteAddr, buf[:n])
		count++
		_, errW := listener.WriteToUDP([]byte(fmt.Sprintf("广播接收者响应：%d",count)), remoteAddr)
		if errW != nil {
			fmt.Println("响应时出现异常：",errW)
		}
	}
}

广播发送端：

• IP地址要当前局域网ip最后一位改为x.x.x.255

package main

import (
	"fmt"
	"net"
	"os"
)

func main() {
	ip := net.ParseIP("192.168.0.255")
	srcAddr := &net.UDPAddr{IP: net.IPv4zero, Port: 0}
	dstAddr := &net.UDPAddr{IP: ip, Port: 38080}
	conn, err := net.ListenUDP("udp", srcAddr)
	if err != nil {
		fmt.Println(err)
	}
	_, errW := conn.WriteToUDP([]byte("死道友不死贫道"), dstAddr)
	if errW != nil {
		fmt.Println("发送数据出现异常：",errW)
	}
	buf := make([]byte, 1024)
	n, _,errR := conn.ReadFrom(buf)
	if errR != nil {
		fmt.Println("读取响应数据出现异常：",errR)
	}
	fmt.Printf("收到广播者的响应：%s \n", buf[:n])
	b := make([]byte, 1)
	os.Stdin.Read(b)
}

任播通信

任播是与单播、广播和组播不同的方式。

• 在单播中，网络位址和网络节点之间存在一一对应的关系。

• 在广播和组播中，网络位址和网络节点之间存在一对多的关系：每一个目的位址对应一群接收可以复制资讯的节点。

• 在任播中，网络位址和网络节点之间存在一对多的关系：每一个位址对应一群接收节点，但在任何给定时间，只有其中之一可以接收到传送端来的资讯。

• 在互联网中，通常使用边界网关协议来实现任播，任播往往有特殊用途。

在互联网中，通常使用边界网关协议来实现任播。比如域名根服务器就是通过任播的方式提供。13台根服务器使用13个任播地址，但是有500多台实际服务器。

• 可以通过单播的方式发送数据包，只有最快的(最近的)的一个UDP服务器接收到。

Anycasting最初是在RFC1546中提出并定义的，它的最初语义是，在IP网络上通过一个Anycast地址标识一组提供特定服务的主机，同时服务访问方并不关心提供服务的具体是哪一台主机(比如DNS或者镜像服务)，访问该地址的报文可以被IP网络路由到这一组目标中的任何一台主机上，它提供的是一种无状态的、尽力而为的服务。

RFC2373(IP Version 6 Addressing Architecture, July 1998)提供了较新的说明和动机：任播地址的一个期望应用是标识属于某个提供互联网服务的机构的路由器集合。这种地址可以用作IPv6路由标题的中间地址,使数据分组通过某一聚合或聚合序列传递。其他可能的用途是标识属于某一子网的路由器组或提供进入某一路由范围入口的路由器组。

RFC2373标准对任播的定义是，当一个单播地址被分配到多于一个的接口上时，发到该接口的报文被网络路由到由路由协议度量的“最近”的目标接口上。与Unicast和Multicast类似，Anycast也是IP网络的一种通信模式。Unicast允许源结点向单一目标结点发送数据报，Multicast允许源结点向一组目标结点发送数据报，而Anycast则允许源结点向一组目标结点中的一个结点发送数据报，而这个结点由路由系统选择，对源结点透明；同时，路由系统选择“最近”的结点为源结点提供服务，从而在一定程序上为源结点提供了更好的服务也减轻了网络负载。

P2P 网络

P2P全称Peer-to-Peer，是一种分布式网络，网络的参与者共享他们所拥有的一部分硬件资源（处理能力、存储能力、网络连接能力、打印机等），这些共享资源需要由网络提供服务和内容，能被其它对等节点(Peer)直接访问而无需经过中间实体。在此网络中的参与者既是资源（服务和内容）提供者（Server），又是资源（服务和内容）获取者（Client）。

P2P打破了传统的Client/Server (C/S)模式，在网络中的每个结点的地位都是对等的。每个结点既充当服务器，为其他结点提供服务，同时也享用其他结点提供的服务。

与传统的分布式系统相比，P2P技术具有无可比拟的优势。同时，P2P技术具有广阔的应用前景。Internt上各种P2P应用软件层出不穷，用户数量急剧增加，给Internet带宽带来巨大冲击。P2P计算技术正不断应用到军事领域，商业领域，政府信息，通讯等领域。

P2P技术的特点：

• 非中心化（Decentralization）：网络中的资源和服务分散在所有结点上，信息的传输和服务的实现都直接在结点之间进行，可以无需中间环节和服务器的介入，避免了可能的瓶颈。P2P的非中心化基本特点，带来了其在可扩展性、健壮性等方面的优势。

• 可扩展性：在P2P网络中，随着用户的加入，不仅服务的需求增加了，系统整体的资源和服务能力也在同步地扩充，始终能较容易地满足用户的需要。整个体系是全分布的，不存在瓶颈。理论上其可扩展性几乎可以认为是无限的。

• 健壮性：P2P架构天生具有耐攻击、高容错的优点。由于服务是分散在各个结点之间进行的，部分结点或网络遭到破坏对其它部分的影响很小。P2P网络一般在部分结点失效时能够自动调整整体拓扑，保持其它结点的连通性。P2P网络通常都是以自组织的方式建立起来的，并允许结点自由地加入和离开。P2P网络还能够根据网络带宽、结点数、负载等变化不断地做自适应式的调整。

• 高性能/价格比：性能优势是P2P被广泛关注的一个重要原因。随着硬件技术的发展，个人计算机的计算和存储能力以及网络带宽等性能依照摩尔定理高速增长。采用P2P架构可以有效地利用互联网中散布的大量普通结点，将计算任务或存储资料分布到所有结点上。利用其中闲置的计算能力或存储空间，达到高性能计算和海量存储的目的。通过利用网络中的大量空闲资源，可以用更低的成本提供更高的计算和存储能力。

• 隐私保护: 在P2P网络中，由于信息的传输分散在各节点之间进行而无需经过某个集中环节，用户的隐私信息被窃听和泄漏的可能性大大缩小。此外，目前解决Internet隐私问题主要采用中继转发的技术方法，从而将通信的参与者隐藏在众多的网络实体之中。在传统的一些匿名通信系统中，实现这一机制依赖于某些中继服务器节点。而在P2P中，所有参与者都可以提供中继转发的功能，因而大大提高了匿名通讯的灵活性和可靠性，能够为用户提供更好的隐私保护。

• 负载均衡: P2P 网络环境下由于每个节点既是服务器又是客户机，减少了对传统C/S结构服务器计算能力、存储能力的要求，同时因为资源分布在多个节点，更好的实现了整个网络的负载均衡。

P2P 网络应用

• P2P 现如今被用到很多领域：文件共享，计算能力存储共享，即时通讯等等。

• 区块链类应用，如 Bitcoin(比特币)。

• 文件分享类应用，例如BitTorrent，如果用迅雷下载，留意一下下载链接的后缀名。

Go 实现 P2P 网络

建立通信

• 通信的两个节点在两个独立的网络内部，在不清楚对方公网IP的情况下要建立通信需要一个中间人。

• A和B处在两个局域网中，二者访问公网都是通过路由器NAT技术映射一个公网地址（IP:PORT），A和B默认情况下并不知道对方的公网地址，所以双放想要点对点通信时必须借助一个拥有公网IP的服务器做中间人S。

• A和B都向中间人服务器S发送一次请求，S记录下A和B的公网地址，S再把A和B的公网地址分别发送给对方，A和B就知道彼此的地址了。

路由器的安全策略

• A和B通过S都知道对方的地址后可以向对方发送数据了，但是路由器出于安全考虑会拦截一方第一次的数据。

• 当有一个陌生的地址发消息给内部主机时，路由器会丢弃数据包，但是会记录这个陌生的地址。

通信过程

• A 向 中间人S 发送 数据，S记录A的公网地址。

• B 向 中间人S 发送 数据，S记录B的公网地址。

• S 将 A和B的地址发送给对方。

• A 向 B 发送数据，A所在路由器会记录B地址，B所在路由器会丢弃这个数据，但是会记录A的地址。

• B 向 A 发送数据，由于A向B发送数据时A所在路由器已经记录B地址，可以发送成功，而B所在路由器也会记录下A的地址，此后双方可以正常通信。

P2P 服务器

服务器仅仅维护一个地址列表，通讯双方将自己的地址记录到服务器。

• 需要和谁通讯就向服务器索要对方地址，然后双方直接建立联系。

package main

import (
	"encoding/json"
	"fmt"
	"net"
)

func main() {
	//	udpAddrList map[昵称]UDP地址
	var udpAddrList = make(map[string]*net.UDPAddr)

	port := 25180
	listener,err := net.ListenUDP("udp",&net.UDPAddr{Port: port})
	if nil != err {
		fmt.Println(err)
		return
	}
	defer listener.Close()
	fmt.Printf("开始监听%s...\n",listener.LocalAddr().String())
	for {
		buf := make([]byte,1024)
		n,addr,errR := listener.ReadFromUDP(buf)
		fmt.Printf("来自%s数据包 \n",addr.String())
		if nil != errR {
			fmt.Println("读取数据包出现异常：",errR)
			continue
		}
		fmt.Println(string(buf[:n]))
		reqData := make(map[string]string)
		errUn := json.Unmarshal(buf[:n],&reqData)
		if nil != errUn {
			fmt.Println(errUn)
			continue
		}
		cmd := reqData["cmd"]
		switch cmd {
			case "reg":
				udpAddrList[reqData["name"]] = addr
				_,er := listener.WriteToUDP([]byte("SUCCESS"),addr)
				if nil != er {
					fmt.Println(er)
				}
			case "get":
				tmpAddr := udpAddrList[reqData["name"]]
				if nil == tmpAddr {
					listener.WriteToUDP([]byte("NIL"),addr)
				}else{
					_,errW := listener.WriteToUDP([]byte(tmpAddr.String()),addr)
					if nil != errW{
						fmt.Println(errW)
						continue
					}
				}
			default:
				fmt.Printf("命令%s未找到处理方法\n",cmd)
		}
		fmt.Printf("%s,命令%s处理完毕\n",addr,cmd)
	}
}

P2P 客户端

P2P客户端向服务器注册自己的地址，然后向服务器索要对方的通讯地址建立联系，建立联系以后就可以发送数据。

package main

import (
	"bufio"
	"encoding/json"
	"fmt"
	"net"
	"os"
	"strconv"
	"strings"
)

func register(name string) string{
	mp := make(map[string]string)
	mp["cmd"] = "reg"
	mp["name"] = name
	buf,_ := json.Marshal(mp)
	return string(buf)
}

func getAddr(name string) string{
	mp := make(map[string]string)
	mp["cmd"] = "get"
	mp["name"] = name
	buf,_ := json.Marshal(mp)
	return string(buf)
}

func readStdin() string {
	red := bufio.NewReader(os.Stdin)
	line,_ := red.ReadString('\n')
	line = strings.Replace(line,"\n","",-1)
	line = strings.Replace(line,"\r","",-1)
	return line
}

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 main() {
	//remoteIP := "127.0.0.1"
	serverIP := "101.43.60.74"
	serverPort := 25180
	localAddr := net.UDPAddr{Port: 23900}
	fmt.Println("本地：",localAddr)
	conn,errD := net.DialUDP("udp",&localAddr,&net.UDPAddr{IP: net.ParseIP(serverIP),Port: serverPort})
	if nil != errD {
		fmt.Println(errD)
		return
	}
	defer conn.Close()
	// 将地址注册到服务器
	fmt.Println("请输入注册的Name：")
	clientName := readStdin()
	conn.Write([]byte(register(clientName)))
	buf := make([]byte,1024)
	n,_,errR := conn.ReadFromUDP(buf)
	if nil != errR {
		fmt.Println(errR)
		return
	}
	res := string(buf[:n])
	fmt.Println(res)

	//	向服务器索取name对应的一个地址
	fmt.Println("请输入要通信的Name：")
	reqName := readStdin()
	fmt.Printf(reqName)
	conn.Write([]byte(getAddr(reqName)))
	buf = make([]byte,1024)
	n,_,errR = conn.ReadFromUDP(buf)
	if nil != errR {
		fmt.Println(errR)
		return
	}
	reqAddr := string(buf[:n])
	if "NIL" == reqAddr {
		fmt.Printf("未找到%s \n",reqName)
		return
	}
	fmt.Printf("找到%s的地址：%s开始建立联系 \n",reqName,reqAddr)

	//	进行P2P通信：关闭和服务器的关联，与获得的地址进行通信
	conn.Close()
	toAddr := parseAddr(reqAddr)
	p2p(&localAddr,&toAddr)
}

func p2p(addr *net.UDPAddr, toAddr *net.UDPAddr) {
	conn,err := net.DialUDP("udp",addr,toAddr)
	if nil != err {
		fmt.Println(err)
		return
	}
	defer conn.Close()
	fmt.Printf("与%s建立联系\n",toAddr)
	go readP2pMsg(conn)
	//	先发送一个打洞消息,这个大概率会被路由器拦截。
	conn.Write([]byte("建立通讯..."))
	for {
		msg := readStdin()
		if "EXIT" == msg {
			fmt.Println("EXIT 退出程序...")
			return
		}
		conn.Write([]byte(msg))
	}
}

//	readP2pMsg 读取P2P信息
func readP2pMsg(conn *net.UDPConn) {
	for {
		buf := make([]byte,1024)
		n,addr,err := conn.ReadFrom(buf)
		if nil != err{
			fmt.Println(err)
		}
		fmt.Printf("收到来自%s的消息:%s\n",addr,string(buf[:n]))
	}
}