libgo/go/net/multicast_posix_test.go

   1 // Copyright 2011 The Go Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style
   3 // license that can be found in the LICENSE file.
   4
   5 // +build !plan9
   6
   7 package net
   8
   9 import (
  10         "errors"
  11         "os"
  12         "runtime"
  13         "testing"
  14 )
  15
  16 var multicastListenerTests = []struct {
  17         net   string
  18         gaddr *UDPAddr
  19         flags Flags
  20         ipv6  bool // test with underlying AF_INET6 socket
  21 }{
  22         // cf. RFC 4727: Experimental Values in IPv4, IPv6, ICMPv4, ICMPv6, UDP, and TCP Headers
  23
  24         {"udp", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}, FlagUp | FlagLoopback, false},
  25         {"udp", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}, 0, false},
  26         {"udp", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}, FlagUp | FlagLoopback, true},
  27         {"udp", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}, 0, true},
  28
  29         {"udp4", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}, FlagUp | FlagLoopback, false},
  30         {"udp4", &UDPAddr{IP: IPv4(224, 0, 0, 254), Port: 12345}, 0, false},
  31
  32         {"udp6", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}, FlagUp | FlagLoopback, true},
  33         {"udp6", &UDPAddr{IP: ParseIP("ff01::114"), Port: 12345}, 0, true},
  34         {"udp6", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}, FlagUp | FlagLoopback, true},
  35         {"udp6", &UDPAddr{IP: ParseIP("ff02::114"), Port: 12345}, 0, true},
  36         {"udp6", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}, FlagUp | FlagLoopback, true},
  37         {"udp6", &UDPAddr{IP: ParseIP("ff04::114"), Port: 12345}, 0, true},
  38         {"udp6", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}, FlagUp | FlagLoopback, true},
  39         {"udp6", &UDPAddr{IP: ParseIP("ff05::114"), Port: 12345}, 0, true},
  40         {"udp6", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}, FlagUp | FlagLoopback, true},
  41         {"udp6", &UDPAddr{IP: ParseIP("ff08::114"), Port: 12345}, 0, true},
  42         {"udp6", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}, FlagUp | FlagLoopback, true},
  43         {"udp6", &UDPAddr{IP: ParseIP("ff0e::114"), Port: 12345}, 0, true},
  44 }
  45
  46 // TestMulticastListener tests both single and double listen to a test
  47 // listener with same address family, same group address and same port.
  48 func TestMulticastListener(t *testing.T) {
  49         switch runtime.GOOS {
  50         case "netbsd", "openbsd", "plan9", "solaris", "windows":
  51                 t.Skipf("skipping test on %q", runtime.GOOS)
  52         case "linux":
  53                 if runtime.GOARCH == "arm" || runtime.GOARCH == "alpha" {
  54                         t.Skipf("skipping test on %q/%q", runtime.GOOS, runtime.GOARCH)
  55                 }
  56         }
  57
  58         for _, tt := range multicastListenerTests {
  59                 if tt.ipv6 && (!*testIPv6 || !supportsIPv6 || os.Getuid() != 0) {
  60                         continue
  61                 }
  62                 ifi, err := availMulticastInterface(t, tt.flags)
  63                 if err != nil {
  64                         continue
  65                 }
  66                 c1, err := ListenMulticastUDP(tt.net, ifi, tt.gaddr)
  67                 if err != nil {
  68                         t.Fatalf("First ListenMulticastUDP failed: %v", err)
  69                 }
  70                 checkMulticastListener(t, err, c1, tt.gaddr)
  71                 c2, err := ListenMulticastUDP(tt.net, ifi, tt.gaddr)
  72                 if err != nil {
  73                         t.Fatalf("Second ListenMulticastUDP failed: %v", err)
  74                 }
  75                 checkMulticastListener(t, err, c2, tt.gaddr)
  76                 c2.Close()
  77                 c1.Close()
  78         }
  79 }
  80
  81 func TestSimpleMulticastListener(t *testing.T) {
  82         switch runtime.GOOS {
  83         case "plan9":
  84                 t.Skipf("skipping test on %q", runtime.GOOS)
  85         case "windows":
  86                 if testing.Short() || !*testExternal {
  87                         t.Skip("skipping test on windows to avoid firewall")
  88                 }
  89         }
  90
  91         for _, tt := range multicastListenerTests {
  92                 if tt.ipv6 {
  93                         continue
  94                 }
  95                 tt.flags = FlagUp | FlagMulticast // for windows testing
  96                 ifi, err := availMulticastInterface(t, tt.flags)
  97                 if err != nil {
  98                         continue
  99                 }
 100                 c1, err := ListenMulticastUDP(tt.net, ifi, tt.gaddr)
 101                 if err != nil {
 102                         t.Fatalf("First ListenMulticastUDP failed: %v", err)
 103                 }
 104                 checkSimpleMulticastListener(t, err, c1, tt.gaddr)
 105                 c2, err := ListenMulticastUDP(tt.net, ifi, tt.gaddr)
 106                 if err != nil {
 107                         t.Fatalf("Second ListenMulticastUDP failed: %v", err)
 108                 }
 109                 checkSimpleMulticastListener(t, err, c2, tt.gaddr)
 110                 c2.Close()
 111                 c1.Close()
 112         }
 113 }
 114
 115 func checkMulticastListener(t *testing.T, err error, c *UDPConn, gaddr *UDPAddr) {
 116         if !multicastRIBContains(t, gaddr.IP) {
 117                 t.Errorf("%q not found in RIB", gaddr.String())
 118                 return
 119         }
 120         la := c.LocalAddr()
 121         if la == nil {
 122                 t.Error("LocalAddr failed")
 123                 return
 124         }
 125         if a, ok := la.(*UDPAddr); !ok || a.Port == 0 {
 126                 t.Errorf("got %v; expected a proper address with non-zero port number", la)
 127                 return
 128         }
 129 }
 130
 131 func checkSimpleMulticastListener(t *testing.T, err error, c *UDPConn, gaddr *UDPAddr) {
 132         la := c.LocalAddr()
 133         if la == nil {
 134                 t.Error("LocalAddr failed")
 135                 return
 136         }
 137         if a, ok := la.(*UDPAddr); !ok || a.Port == 0 {
 138                 t.Errorf("got %v; expected a proper address with non-zero port number", la)
 139                 return
 140         }
 141 }
 142
 143 func availMulticastInterface(t *testing.T, flags Flags) (*Interface, error) {
 144         var ifi *Interface
 145         if flags != Flags(0) {
 146                 ift, err := Interfaces()
 147                 if err != nil {
 148                         t.Fatalf("Interfaces failed: %v", err)
 149                 }
 150                 for _, x := range ift {
 151                         if x.Flags&flags == flags {
 152                                 ifi = &x
 153                                 break
 154                         }
 155                 }
 156                 if ifi == nil {
 157                         return nil, errors.New("an appropriate multicast interface not found")
 158                 }
 159         }
 160         return ifi, nil
 161 }
 162
 163 func multicastRIBContains(t *testing.T, ip IP) bool {
 164         ift, err := Interfaces()
 165         if err != nil {
 166                 t.Fatalf("Interfaces failed: %v", err)
 167         }
 168         for _, ifi := range ift {
 169                 ifmat, err := ifi.MulticastAddrs()
 170                 if err != nil {
 171                         t.Fatalf("MulticastAddrs failed: %v", err)
 172                 }
 173                 for _, ifma := range ifmat {
 174                         if ifma.(*IPAddr).IP.Equal(ip) {
 175                                 return true
 176                         }
 177                 }
 178         }
 179         return false
 180 }