xmdhs
本帖最后由 xmdhs 于 2022-6-29 16:30 编辑

获取和增加局域网服务器列表

众所周知，如果有局域网内有了对局域网开放的游戏，就会显示在多人游戏菜单中，服务器列表里的最底部。



原理

这种点了对局域网开放，就能让局域网内所有其他客户端都能看到的技术，是用到了名为组播的东西。通过加入组播组，所有发向这个组播地址的消息，都会接收到。这样就能做到自动发现对局域网开放的游戏。

而通过从组中监听，和向组发送信息，就能做到不少有趣的事情。

比如说，自动的获取游戏对局域网开放的端口，然后自动的进行端口映射。亦或是向服务器列表中自动的添加内容。

接收

minecraft 对局域网开放后，会每隔 1.5 秒向组播地址 224.0.2.60:4445 发送数据包，数据包内容为 utf-8 格式的字符串，内容如下

  1. [MOTD]motd[/MOTD][AD]port[/AD]

  3. 例子：
  4. [MOTD]新的世界[/MOTD][AD]6432[/AD]
复制代码

通过解析这个数据包，即可获知对局域网开放的游戏。

具体需要做的，是加入组播，然后接收消息，具体需要做的不同的编程语言也不同，可以自行搜索，这里给出 Go 的示例代码。

相关的代码示例

  1. package main

  3. import (
  4.         "context"
  5.         "errors"
  6.         "fmt"
  7.         "net"

  9.         "golang.org/x/net/ipv4"
  10. )

  12. func main() {
  13.         err := Listen(context.TODO(), "224.0.2.60:4445", "0.0.0.0", func(u *net.UDPAddr, b []byte) {
  14.                 fmt.Println(string(b), u.String())
  15.         })
  16.         if err != nil {
  17.                 panic(err)
  18.         }
  19. }

  21. const maxDatagramSize = 8024

  23. func Listen(cxt context.Context, address, laddress string, handler func(*net.UDPAddr, []byte)) error {
  24.         msgCh := make(chan readMsg, 10)
  25.         errCh := make(chan error, 10)

  27.         addr, err := net.ResolveUDPAddr("udp4", address)
  28.         if err != nil {
  29.                 return fmt.Errorf("Listen: %w", err)
  30.         }
  31.         il, err := net.Interfaces()
  32.         if err != nil {
  33.                 return fmt.Errorf("Listen: %w", err)
  34.         }
  35.         if laddress != "0.0.0.0" {
  36.                 lip := net.ParseIP(laddress)
  37.                 var itf *net.Interface
  38.         B:
  39.                 for _, v := range il {
  40.                         addr, _ := v.Addrs()
  41.                         for _, vv := range addr {
  42.                                 if ipnet, ok := vv.(*net.IPNet); ok && ipnet.IP.Equal(lip) {
  43.                                         itf = &v
  44.                                         break B
  45.                                 }
  46.                         }
  47.                 }
  48.                 if itf == nil {
  49.                         return fmt.Errorf("Listen: %w", ErrNotItf)
  50.                 }
  51.                 il = []net.Interface{*itf}
  52.         }

  54.         cxt, cancel := context.WithCancel(cxt)
  55.         defer cancel()

  57.         for _, v := range il {
  58.                 if v.Flags&net.FlagMulticast != net.FlagMulticast || v.Flags&net.FlagUp != net.FlagUp {
  59.                         continue
  60.                 }
  61.                 v := v
  62.                 go read(cxt, &v, addr, errCh, msgCh)
  63.         }
  64.         for {
  65.                 select {
  66.                 case err := <-errCh:
  67.                         return fmt.Errorf("Listen: %w", err)
  68.                 case msg := <-msgCh:
  69.                         handler(msg.addr, msg.msg)
  70.                 case <-cxt.Done():
  71.                         return nil
  72.                 }
  73.         }
  74. }

  76. var ErrNotItf = errors.New("not find interface")

  78. func read(cxt context.Context, itf *net.Interface, addr *net.UDPAddr, eCh chan<- error, msgCh chan<- readMsg) {
  79.         cxt, cancel := context.WithCancel(cxt)
  80.         defer cancel()
  81.         conn, err := net.ListenMulticastUDP("udp", itf, addr)
  82.         doErr := func(err error) {
  83.                 select {
  84.                 case <-cxt.Done():
  85.                 case eCh <- fmt.Errorf("read: %w", err):
  86.                 }
  87.         }
  88.         if err != nil {
  89.                 doErr(err)
  90.                 return
  91.         }
  92.         defer conn.Close()
  93.         go func() {
  94.                 <-cxt.Done()
  95.                 conn.Close()
  96.         }()
  97.         conn.SetReadBuffer(maxDatagramSize)
  98.         pc := ipv4.NewPacketConn(conn)
  99.         if err := pc.SetMulticastLoopback(true); err != nil {
  100.                 doErr(err)
  101.                 return
  102.         }
  103.         for {
  104.                 buffer := make([]byte, maxDatagramSize)
  105.                 numBytes, src, err := conn.ReadFromUDP(buffer)
  106.                 if err != nil {
  107.                         doErr(err)
  108.                         return
  109.                 }
  110.                 select {
  111.                 case msgCh <- readMsg{
  112.                         addr: src,
  113.                         msg:  buffer[:numBytes],
  114.                 }:
  115.                 case <-cxt.Done():
  116.                         return
  117.                 }
  118.         }
  119. }

  121. type readMsg struct {
  122.         addr *net.UDPAddr
  123.         msg  []byte
  124. }
复制代码

二进制

windows server.zip (741.36 KB, 下载次数: 7)

运行后，打开游戏，进入存档，点对局域网开放，就能在这个程序中看到相应的内容了。

发送

如果需要给服务器列表添加内容，需要做的事就简单不少，只需要向 224.0.2.60:4445 发送 udp 数据包即可，内容和上面提到的一样。

演示代码

  1. package main

  3. import (
  4.     "fmt"
  5.     "math/rand"
  6.     "net"
  7.     "os"
  8.     "strconv"
  9.     "sync"
  10.     "time"
  11. )

  13. func main() {
  14.     for i := 0; i < 100; i++ {
  15.         port := r.Intn(9999) + 1
  16.         go sendPing(randStr(10, []byte(atext)), strconv.Itoa(port))
  17.     }
  18.     os.Stdin.Read(make([]byte, 1))
  19. }

  21. type arand struct {
  22.     *rand.Rand
  23.     *sync.Mutex
  24. }

  26. var r = arand{
  27.     Rand:  rand.New(rand.NewSource(time.Now().Unix())),
  28.     Mutex: &sync.Mutex{},
  29. }

  31. const atext = `abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%`

  33. func randStr(n int, words []byte) string {
  34.     b := make([]byte, n)
  35.     r.Lock()
  36.     for i := range b {
  37.         b[i] = words[r.Intn(len(words))]
  38.     }
  39.     r.Unlock()
  40.     return string(b)
  41. }

  43. func sendPing(motd, port string) {
  44.     dstAddr, err := net.ResolveUDPAddr("udp", "224.0.2.60:4445")
  45.     if err != nil {
  46.         panic(err)
  47.     }
  48.     srcAddr := &net.UDPAddr{IP: net.IPv4zero, Port: 0}
  49.     conn, err := net.ListenUDP("udp", srcAddr)
  50.     if err != nil {
  51.         fmt.Println(err)
  52.     }
  53.     msg := []byte(fmt.Sprintf(`[MOTD]%s[/MOTD][AD]%s[/AD]`, motd, port))
  54.     for {
  55.         _, err := conn.WriteToUDP(msg, dstAddr)
  56.         if err != nil {
  57.             panic(err)
  58.         }
  59.         time.Sleep(2 * time.Second)
  60.     }
  61. }
复制代码

二进制

windows client.zip (696.73 KB, 下载次数: 2)

运行后，打开游戏，点击多人联机，底部就会有一堆虚假的局域网服务器了。

紫熙
我看不懂，但我大受震撼.jpg
TheSmiler_Zuny
确实大受震撼，一个都看不懂但我觉得很牛逼