在 Go 中写入客户端 UDP 套接字答案

【问题标题】：Write to Client UDP Socket in Go在 Go 中写入客户端 UDP 套接字
【发布时间】：2014-11-19 15:26:18
【问题描述】：

我正在为使用 Go 语言的 UDP 套接字进行客户端/服务器通信寻找一个好的解决方案。

我在 Internet 上找到的示例向我展示了如何将数据发送到服务器，但没有教如何将它们发送回客户端。

为了演示，我的程序执行以下操作：

我的客户端程序在 4444 端口上创建一个套接字，如下所示：

con, err := net.Dial("udp", "127.0.0.1:4444")

我向服务器发送了一个字符串和本地地址，因此它可以打印该字符串并发送一个 OK 消息。我为此使用 gob：

enc := gob.NewEncoder(con)
enc.Encode(Data{"test", con.LocalAddr().String()})

我的数据结构如下所示：

type Data struct{
    Msg string
    Addr string
}

我的服务器侦听 4444 端口并正确解码 Gob，但我怎样才能将 OK 消息发回？我正在使用客户端地址来执行此操作（在服务器 .go 文件上）：

con, err := net.Dial("udp", data.Addr)

然后，我得到一个错误代码：

write udp 127.0.0.1:35290: connection refused

当客户端尝试连接到服务器的 4444 端口时，客户端会创建一个带有随机数（在本例中为 35290）的端口，以便它们可以通信。我知道我不应该将客户端的地址传递给服务器，但是 conn.RemoteAddress() 不起作用。发现客户地址的解决方案将不胜感激。

Obs.：我知道有 ReadFromUDP，所以我可以读取包。我应该阅读它，发现客户端的地址，然后将数据发送到 Gob 以便它可以解码吗？

【问题讨论】：

使用ReadFromUDP读取数据包。使用从 ReadFromUDP 返回的地址使用WriteToUDP 进行回复。
我在考虑这个问题，但是 Gob 应该如何适应这种情况？
使用 var b bytes.Buffer; err := gob.NewEncoder(&b).Encode(v) 将 gob 编码到缓冲区并将 b.Bytes() 写入连接。使用 err := gob.NewDecoder(bytes.NewReader(p)).Decode(&v) 解码 gobs，其中 p 是从连接中读取的数据。

标签： sockets go udp gob

【解决方案1】：

检查以下示例以了解通过 UDP 进行的客户端/服务器通信。 sendResponse 例程用于将响应发送回客户端。

udpclient.go

package main
import (
    "fmt"
    "net"
    "bufio"
)

func main() {
    p :=  make([]byte, 2048)
    conn, err := net.Dial("udp", "127.0.0.1:1234")
    if err != nil {
        fmt.Printf("Some error %v", err)
        return
    }
    fmt.Fprintf(conn, "Hi UDP Server, How are you doing?")
    _, err = bufio.NewReader(conn).Read(p)
    if err == nil {
        fmt.Printf("%s\n", p)
    } else {
        fmt.Printf("Some error %v\n", err)
    }
    conn.Close()
}

udpserver.go

package main
import (
    "fmt" 
    "net"  
)


func sendResponse(conn *net.UDPConn, addr *net.UDPAddr) {
    _,err := conn.WriteToUDP([]byte("From server: Hello I got your message "), addr)
    if err != nil {
        fmt.Printf("Couldn't send response %v", err)
    }
}


func main() {
    p := make([]byte, 2048)
    addr := net.UDPAddr{
        Port: 1234,
        IP: net.ParseIP("127.0.0.1"),
    }
    ser, err := net.ListenUDP("udp", &addr)
    if err != nil {
        fmt.Printf("Some error %v\n", err)
        return
    }
    for {
        _,remoteaddr,err := ser.ReadFromUDP(p)
        fmt.Printf("Read a message from %v %s \n", remoteaddr, p)
        if err !=  nil {
            fmt.Printf("Some error  %v", err)
            continue
        }
        go sendResponse(ser, remoteaddr)
    }
}

【讨论】：

udpclient.go 中的 conn.Close() 行最好放在一个延迟语句中，例如：defer conn.Close()
我正在尝试使用在远程机器上运行的服务器和在本地运行的客户端。如果我将 server.go 中的地址更改为 0.0.0.0，并将 client.go 中的地址更改为该服务器的 IP，则客户端返回 Some error read udp 127.0.0.1:58464->127.0.0.1:1234: read: connection refused。有人会建议一种方法来让它工作吗？谢谢！

【解决方案2】：

hello_echo.go

 package main                                                                                                          

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

 const proto, addr = "udp", ":8888"                                                                                    

 func main() {  

     go func() {                                                                                                       
         conn, _ := net.ListenPacket(proto, addr)                                                                      
         buf := make([]byte, 1024)                                                                                     
         n, dst, _ := conn.ReadFrom(buf)                                                                               
         fmt.Println("serv recv", string(buf[:n]))                                                                     
         conn.WriteTo(buf, dst)                                                                                        
     }()        

     time.Sleep(1 * time.Second)   

     conn, _ := net.Dial(proto, addr)                                                                                  
     conn.Write([]byte("hello\n"))                                                                                     
     buf, _, _ := bufio.NewReader(conn).ReadLine()                                                                     
     fmt.Println("clnt recv", string(buf))                                                                             
 }

【讨论】：

【解决方案3】：

要点在这里：

https://gist.github.com/winlinvip/e8665ba888e2fd489ccd5a449fadfa73

server.go

/*
Usage:
    go run server.go
See https://gist.github.com/winlinvip/e8665ba888e2fd489ccd5a449fadfa73
See https://stackoverflow.com/a/70576851/17679565
See https://github.com/ossrs/srs/issues/2843
 */
package main

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

func main() {
    serverPort := 8000
    if len(os.Args) > 1 {
        if v,err := strconv.Atoi(os.Args[1]); err != nil {
            fmt.Printf("Invalid port %v, err %v", os.Args[1], err)
            os.Exit(-1)
        } else {
            serverPort = v
        }
    }

    addr := net.UDPAddr{
        Port: serverPort,
        IP:   net.ParseIP("0.0.0.0"),
    }
    server, err := net.ListenUDP("udp", &addr)
    if err != nil {
        fmt.Printf("Listen err %v\n", err)
        os.Exit(-1)
    }
    fmt.Printf("Listen at %v\n", addr.String())

    for {
        p := make([]byte, 1024)
        nn, raddr, err := server.ReadFromUDP(p)
        if err != nil {
            fmt.Printf("Read err  %v", err)
            continue
        }

        msg := p[:nn]
        fmt.Printf("Received %v %s\n", raddr, msg)

        go func(conn *net.UDPConn, raddr *net.UDPAddr, msg []byte) {
            _, err := conn.WriteToUDP([]byte(fmt.Sprintf("Pong: %s", msg)), raddr)
            if err != nil {
                fmt.Printf("Response err %v", err)
            }
        }(server, raddr, msg)
    }
}

client.go

/*
Usage:
    go run client.go
    go run client.go 101.201.77.240
See https://gist.github.com/winlinvip/e8665ba888e2fd489ccd5a449fadfa73
See https://stackoverflow.com/a/70576851/17679565
See https://github.com/ossrs/srs/issues/2843
*/
package main

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

func main() {
    serverEP := "127.0.0.1"
    if len(os.Args) > 1 {
        serverEP = os.Args[1]
    }
    if !strings.Contains(serverEP, ":") {
        serverEP = fmt.Sprintf("%v:8000", serverEP)
    }

    conn, err := net.Dial("udp", serverEP)
    if err != nil {
        fmt.Printf("Dial err %v", err)
        os.Exit(-1)
    }
    defer conn.Close()

    msg := "Hello, UDP server"
    fmt.Printf("Ping: %v\n", msg)
    if _, err = conn.Write([]byte(msg)); err != nil {
        fmt.Printf("Write err %v", err)
        os.Exit(-1)
    }

    p := make([]byte, 1024)
    nn, err := conn.Read(p)
    if err != nil {
        fmt.Printf("Read err %v\n", err)
        os.Exit(-1)
    }

    fmt.Printf("%v\n", string(p[:nn]))
}

【讨论】：