libgo/go/net/packetconn_test.go

   1 // Copyright 2012 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 package net_test
   6
   7 import (
   8         "net"
   9         "os"
  10         "runtime"
  11         "strings"
  12         "testing"
  13         "time"
  14 )
  15
  16 var packetConnTests = []struct {
  17         net   string
  18         addr1 string
  19         addr2 string
  20 }{
  21         {"udp", "127.0.0.1:0", "127.0.0.1:0"},
  22         {"ip:icmp", "127.0.0.1", "127.0.0.1"},
  23         {"unixgram", "/tmp/gotest.net1", "/tmp/gotest.net2"},
  24 }
  25
  26 func TestPacketConn(t *testing.T) {
  27         closer := func(c net.PacketConn, net, addr1, addr2 string) {
  28                 c.Close()
  29                 switch net {
  30                 case "unixgram":
  31                         os.Remove(addr1)
  32                         os.Remove(addr2)
  33                 }
  34         }
  35
  36         for _, tt := range packetConnTests {
  37                 var wb []byte
  38                 netstr := strings.Split(tt.net, ":")
  39                 switch netstr[0] {
  40                 case "udp":
  41                         wb = []byte("UDP PACKETCONN TEST")
  42                 case "ip":
  43                         switch runtime.GOOS {
  44                         case "plan9":
  45                                 continue
  46                         }
  47                         if os.Getuid() != 0 {
  48                                 continue
  49                         }
  50                         id := os.Getpid() & 0xffff
  51                         wb = newICMPEchoRequest(id, 1, 128, []byte("IP PACKETCONN TEST"))
  52                 case "unixgram":
  53                         switch runtime.GOOS {
  54                         case "plan9", "windows":
  55                                 continue
  56                         }
  57                         os.Remove(tt.addr1)
  58                         os.Remove(tt.addr2)
  59                         wb = []byte("UNIXGRAM PACKETCONN TEST")
  60                 default:
  61                         continue
  62                 }
  63
  64                 c1, err := net.ListenPacket(tt.net, tt.addr1)
  65                 if err != nil {
  66                         t.Fatalf("net.ListenPacket failed: %v", err)
  67                 }
  68                 c1.LocalAddr()
  69                 c1.SetDeadline(time.Now().Add(100 * time.Millisecond))
  70                 c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
  71                 c1.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
  72                 defer closer(c1, netstr[0], tt.addr1, tt.addr2)
  73
  74                 c2, err := net.ListenPacket(tt.net, tt.addr2)
  75                 if err != nil {
  76                         t.Fatalf("net.ListenPacket failed: %v", err)
  77                 }
  78                 c2.LocalAddr()
  79                 c2.SetDeadline(time.Now().Add(100 * time.Millisecond))
  80                 c2.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
  81                 c2.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
  82                 defer closer(c2, netstr[0], tt.addr1, tt.addr2)
  83
  84                 if _, err := c1.WriteTo(wb, c2.LocalAddr()); err != nil {
  85                         t.Fatalf("net.PacketConn.WriteTo failed: %v", err)
  86                 }
  87                 rb2 := make([]byte, 128)
  88                 if _, _, err := c2.ReadFrom(rb2); err != nil {
  89                         t.Fatalf("net.PacketConn.ReadFrom failed: %v", err)
  90                 }
  91                 if _, err := c2.WriteTo(wb, c1.LocalAddr()); err != nil {
  92                         t.Fatalf("net.PacketConn.WriteTo failed: %v", err)
  93                 }
  94                 rb1 := make([]byte, 128)
  95                 if _, _, err := c1.ReadFrom(rb1); err != nil {
  96                         t.Fatalf("net.PacketConn.ReadFrom failed: %v", err)
  97                 }
  98         }
  99 }
 100
 101 func TestConnAndPacketConn(t *testing.T) {
 102         for _, tt := range packetConnTests {
 103                 var wb []byte
 104                 netstr := strings.Split(tt.net, ":")
 105                 switch netstr[0] {
 106                 case "udp":
 107                         wb = []byte("UDP PACKETCONN TEST")
 108                 case "ip":
 109                         switch runtime.GOOS {
 110                         case "plan9":
 111                                 continue
 112                         }
 113                         if os.Getuid() != 0 {
 114                                 continue
 115                         }
 116                         id := os.Getpid() & 0xffff
 117                         wb = newICMPEchoRequest(id, 1, 128, []byte("IP PACKETCONN TEST"))
 118                 default:
 119                         continue
 120                 }
 121
 122                 c1, err := net.ListenPacket(tt.net, tt.addr1)
 123                 if err != nil {
 124                         t.Fatalf("net.ListenPacket failed: %v", err)
 125                 }
 126                 c1.LocalAddr()
 127                 c1.SetDeadline(time.Now().Add(100 * time.Millisecond))
 128                 c1.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
 129                 c1.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
 130                 defer c1.Close()
 131
 132                 c2, err := net.Dial(tt.net, c1.LocalAddr().String())
 133                 if err != nil {
 134                         t.Fatalf("net.Dial failed: %v", err)
 135                 }
 136                 c2.LocalAddr()
 137                 c2.RemoteAddr()
 138                 c2.SetDeadline(time.Now().Add(100 * time.Millisecond))
 139                 c2.SetReadDeadline(time.Now().Add(100 * time.Millisecond))
 140                 c2.SetWriteDeadline(time.Now().Add(100 * time.Millisecond))
 141                 defer c2.Close()
 142
 143                 if _, err := c2.Write(wb); err != nil {
 144                         t.Fatalf("net.Conn.Write failed: %v", err)
 145                 }
 146                 rb1 := make([]byte, 128)
 147                 if _, _, err := c1.ReadFrom(rb1); err != nil {
 148                         t.Fatalf("net.PacetConn.ReadFrom failed: %v", err)
 149                 }
 150                 var dst net.Addr
 151                 if netstr[0] == "ip" {
 152                         dst = &net.IPAddr{IP: net.IPv4(127, 0, 0, 1)}
 153                 } else {
 154                         dst = c2.LocalAddr()
 155                 }
 156                 if _, err := c1.WriteTo(wb, dst); err != nil {
 157                         t.Fatalf("net.PacketConn.WriteTo failed: %v", err)
 158                 }
 159                 rb2 := make([]byte, 128)
 160                 if _, err := c2.Read(rb2); err != nil {
 161                         t.Fatalf("net.Conn.Read failed: %v", err)
 162                 }
 163         }
 164 }