libgo/go/net/server_test.go

   1 // Copyright 2009 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
   6
   7 import (
   8         "flag"
   9         "io"
  10         "os"
  11         "runtime"
  12         "testing"
  13         "time"
  14 )
  15
  16 func skipServerTest(net, unixsotype, addr string, ipv6, ipv4map, linuxonly bool) bool {
  17         switch runtime.GOOS {
  18         case "linux":
  19         case "plan9", "windows":
  20                 // "unix" sockets are not supported on Windows and Plan 9.
  21                 if net == unixsotype {
  22                         return true
  23                 }
  24         default:
  25                 if net == unixsotype && linuxonly {
  26                         return true
  27                 }
  28         }
  29         switch addr {
  30         case "", "0.0.0.0", "[::ffff:0.0.0.0]", "[::]":
  31                 if testing.Short() || !*testExternal {
  32                         return true
  33                 }
  34         }
  35         if ipv6 && !supportsIPv6 {
  36                 return true
  37         }
  38         if ipv4map && !supportsIPv4map {
  39                 return true
  40         }
  41         return false
  42 }
  43
  44 var streamConnServerTests = []struct {
  45         snet    string // server side
  46         saddr   string
  47         cnet    string // client side
  48         caddr   string
  49         ipv6    bool // test with underlying AF_INET6 socket
  50         ipv4map bool // test with IPv6 IPv4-mapping functionality
  51         empty   bool // test with empty data
  52         linux   bool // test with abstract unix domain socket, a Linux-ism
  53 }{
  54         {snet: "tcp", saddr: "", cnet: "tcp", caddr: "127.0.0.1"},
  55         {snet: "tcp", saddr: "0.0.0.0", cnet: "tcp", caddr: "127.0.0.1"},
  56         {snet: "tcp", saddr: "[::ffff:0.0.0.0]", cnet: "tcp", caddr: "127.0.0.1"},
  57         {snet: "tcp", saddr: "[::]", cnet: "tcp", caddr: "[::1]", ipv6: true},
  58
  59         {snet: "tcp", saddr: "", cnet: "tcp", caddr: "[::1]", ipv4map: true},
  60         {snet: "tcp", saddr: "0.0.0.0", cnet: "tcp", caddr: "[::1]", ipv4map: true},
  61         {snet: "tcp", saddr: "[::ffff:0.0.0.0]", cnet: "tcp", caddr: "[::1]", ipv4map: true},
  62         {snet: "tcp", saddr: "[::]", cnet: "tcp", caddr: "127.0.0.1", ipv4map: true},
  63
  64         {snet: "tcp", saddr: "", cnet: "tcp4", caddr: "127.0.0.1"},
  65         {snet: "tcp", saddr: "0.0.0.0", cnet: "tcp4", caddr: "127.0.0.1"},
  66         {snet: "tcp", saddr: "[::ffff:0.0.0.0]", cnet: "tcp4", caddr: "127.0.0.1"},
  67         {snet: "tcp", saddr: "[::]", cnet: "tcp6", caddr: "[::1]", ipv6: true},
  68
  69         {snet: "tcp", saddr: "", cnet: "tcp6", caddr: "[::1]", ipv4map: true},
  70         {snet: "tcp", saddr: "0.0.0.0", cnet: "tcp6", caddr: "[::1]", ipv4map: true},
  71         {snet: "tcp", saddr: "[::ffff:0.0.0.0]", cnet: "tcp6", caddr: "[::1]", ipv4map: true},
  72         {snet: "tcp", saddr: "[::]", cnet: "tcp4", caddr: "127.0.0.1", ipv4map: true},
  73
  74         {snet: "tcp", saddr: "127.0.0.1", cnet: "tcp", caddr: "127.0.0.1"},
  75         {snet: "tcp", saddr: "[::ffff:127.0.0.1]", cnet: "tcp", caddr: "127.0.0.1"},
  76         {snet: "tcp", saddr: "[::1]", cnet: "tcp", caddr: "[::1]", ipv6: true},
  77
  78         {snet: "tcp4", saddr: "", cnet: "tcp4", caddr: "127.0.0.1"},
  79         {snet: "tcp4", saddr: "0.0.0.0", cnet: "tcp4", caddr: "127.0.0.1"},
  80         {snet: "tcp4", saddr: "[::ffff:0.0.0.0]", cnet: "tcp4", caddr: "127.0.0.1"},
  81
  82         {snet: "tcp4", saddr: "127.0.0.1", cnet: "tcp4", caddr: "127.0.0.1"},
  83
  84         {snet: "tcp6", saddr: "", cnet: "tcp6", caddr: "[::1]", ipv6: true},
  85         {snet: "tcp6", saddr: "[::]", cnet: "tcp6", caddr: "[::1]", ipv6: true},
  86
  87         {snet: "tcp6", saddr: "[::1]", cnet: "tcp6", caddr: "[::1]", ipv6: true},
  88
  89         {snet: "unix", saddr: "/tmp/gotest1.net", cnet: "unix", caddr: "/tmp/gotest1.net.local"},
  90         {snet: "unix", saddr: "@gotest2/net", cnet: "unix", caddr: "@gotest2/net.local", linux: true},
  91 }
  92
  93 func TestStreamConnServer(t *testing.T) {
  94         for _, tt := range streamConnServerTests {
  95                 if skipServerTest(tt.snet, "unix", tt.saddr, tt.ipv6, tt.ipv4map, tt.linux) {
  96                         continue
  97                 }
  98
  99                 listening := make(chan string)
 100                 done := make(chan int)
 101                 switch tt.snet {
 102                 case "tcp", "tcp4", "tcp6":
 103                         tt.saddr += ":0"
 104                 case "unix":
 105                         os.Remove(tt.saddr)
 106                         os.Remove(tt.caddr)
 107                 }
 108
 109                 go runStreamConnServer(t, tt.snet, tt.saddr, listening, done)
 110                 taddr := <-listening // wait for server to start
 111
 112                 switch tt.cnet {
 113                 case "tcp", "tcp4", "tcp6":
 114                         _, port, err := SplitHostPort(taddr)
 115                         if err != nil {
 116                                 t.Errorf("SplitHostPort(%q) failed: %v", taddr, err)
 117                                 return
 118                         }
 119                         taddr = tt.caddr + ":" + port
 120                 }
 121
 122                 runStreamConnClient(t, tt.cnet, taddr, tt.empty)
 123                 <-done // make sure server stopped
 124
 125                 switch tt.snet {
 126                 case "unix":
 127                         os.Remove(tt.saddr)
 128                         os.Remove(tt.caddr)
 129                 }
 130         }
 131 }
 132
 133 var seqpacketConnServerTests = []struct {
 134         net   string
 135         saddr string // server address
 136         caddr string // client address
 137         empty bool   // test with empty data
 138 }{
 139         {net: "unixpacket", saddr: "/tmp/gotest3.net", caddr: "/tmp/gotest3.net.local"},
 140         {net: "unixpacket", saddr: "@gotest4/net", caddr: "@gotest4/net.local"},
 141 }
 142
 143 func TestSeqpacketConnServer(t *testing.T) {
 144         if runtime.GOOS != "linux" {
 145                 t.Logf("skipping test on %q", runtime.GOOS)
 146                 return
 147         }
 148
 149         for _, tt := range seqpacketConnServerTests {
 150                 listening := make(chan string)
 151                 done := make(chan int)
 152                 switch tt.net {
 153                 case "unixpacket":
 154                         os.Remove(tt.saddr)
 155                         os.Remove(tt.caddr)
 156                 }
 157
 158                 go runStreamConnServer(t, tt.net, tt.saddr, listening, done)
 159                 taddr := <-listening // wait for server to start
 160
 161                 runStreamConnClient(t, tt.net, taddr, tt.empty)
 162                 <-done // make sure server stopped
 163
 164                 switch tt.net {
 165                 case "unixpacket":
 166                         os.Remove(tt.saddr)
 167                         os.Remove(tt.caddr)
 168                 }
 169         }
 170 }
 171
 172 func runStreamConnServer(t *testing.T, net, laddr string, listening chan<- string, done chan<- int) {
 173         l, err := Listen(net, laddr)
 174         if err != nil {
 175                 t.Errorf("Listen(%q, %q) failed: %v", net, laddr, err)
 176                 listening <- "<nil>"
 177                 done <- 1
 178                 return
 179         }
 180         defer l.Close()
 181         listening <- l.Addr().String()
 182
 183         echo := func(rw io.ReadWriter, done chan<- int) {
 184                 buf := make([]byte, 1024)
 185                 for {
 186                         n, err := rw.Read(buf[0:])
 187                         if err != nil || n == 0 || string(buf[:n]) == "END" {
 188                                 break
 189                         }
 190                         rw.Write(buf[0:n])
 191                 }
 192                 done <- 1
 193         }
 194
 195 run:
 196         for {
 197                 c, err := l.Accept()
 198                 if err != nil {
 199                         continue run
 200                 }
 201                 echodone := make(chan int)
 202                 go echo(c, echodone)
 203                 <-echodone // make sure echo stopped
 204                 c.Close()
 205                 break run
 206         }
 207         done <- 1
 208 }
 209
 210 func runStreamConnClient(t *testing.T, net, taddr string, isEmpty bool) {
 211         c, err := Dial(net, taddr)
 212         if err != nil {
 213                 t.Errorf("Dial(%q, %q) failed: %v", net, taddr, err)
 214                 return
 215         }
 216         defer c.Close()
 217         c.SetReadDeadline(time.Now().Add(1 * time.Second))
 218
 219         var wb []byte
 220         if !isEmpty {
 221                 wb = []byte("StreamConnClient by Dial\n")
 222         }
 223         if n, err := c.Write(wb); err != nil || n != len(wb) {
 224                 t.Errorf("Write failed: %v, %v; want %v, <nil>", n, err, len(wb))
 225                 return
 226         }
 227
 228         rb := make([]byte, 1024)
 229         if n, err := c.Read(rb[0:]); err != nil || n != len(wb) {
 230                 t.Errorf("Read failed: %v, %v; want %v, <nil>", n, err, len(wb))
 231                 return
 232         }
 233
 234         // Send explicit ending for unixpacket.
 235         // Older Linux kernels do not stop reads on close.
 236         switch net {
 237         case "unixpacket":
 238                 c.Write([]byte("END"))
 239         }
 240 }
 241
 242 // Do not test empty datagrams by default.
 243 // It causes unexplained timeouts on some systems,
 244 // including Snow Leopard.  I think that the kernel
 245 // doesn't quite expect them.
 246 var testDatagram = flag.Bool("datagram", false, "whether to test udp and unixgram")
 247
 248 var datagramPacketConnServerTests = []struct {
 249         snet    string // server side
 250         saddr   string
 251         cnet    string // client side
 252         caddr   string
 253         ipv6    bool // test with underlying AF_INET6 socket
 254         ipv4map bool // test with IPv6 IPv4-mapping functionality
 255         dial    bool // test with Dial or DialUnix
 256         empty   bool // test with empty data
 257         linux   bool // test with abstract unix domain socket, a Linux-ism
 258 }{
 259         {snet: "udp", saddr: "", cnet: "udp", caddr: "127.0.0.1"},
 260         {snet: "udp", saddr: "0.0.0.0", cnet: "udp", caddr: "127.0.0.1"},
 261         {snet: "udp", saddr: "[::ffff:0.0.0.0]", cnet: "udp", caddr: "127.0.0.1"},
 262         {snet: "udp", saddr: "[::]", cnet: "udp", caddr: "[::1]", ipv6: true},
 263
 264         {snet: "udp", saddr: "", cnet: "udp", caddr: "[::1]", ipv4map: true},
 265         {snet: "udp", saddr: "0.0.0.0", cnet: "udp", caddr: "[::1]", ipv4map: true},
 266         {snet: "udp", saddr: "[::ffff:0.0.0.0]", cnet: "udp", caddr: "[::1]", ipv4map: true},
 267         {snet: "udp", saddr: "[::]", cnet: "udp", caddr: "127.0.0.1", ipv4map: true},
 268
 269         {snet: "udp", saddr: "", cnet: "udp4", caddr: "127.0.0.1"},
 270         {snet: "udp", saddr: "0.0.0.0", cnet: "udp4", caddr: "127.0.0.1"},
 271         {snet: "udp", saddr: "[::ffff:0.0.0.0]", cnet: "udp4", caddr: "127.0.0.1"},
 272         {snet: "udp", saddr: "[::]", cnet: "udp6", caddr: "[::1]", ipv6: true},
 273
 274         {snet: "udp", saddr: "", cnet: "udp6", caddr: "[::1]", ipv4map: true},
 275         {snet: "udp", saddr: "0.0.0.0", cnet: "udp6", caddr: "[::1]", ipv4map: true},
 276         {snet: "udp", saddr: "[::ffff:0.0.0.0]", cnet: "udp6", caddr: "[::1]", ipv4map: true},
 277         {snet: "udp", saddr: "[::]", cnet: "udp4", caddr: "127.0.0.1", ipv4map: true},
 278
 279         {snet: "udp", saddr: "127.0.0.1", cnet: "udp", caddr: "127.0.0.1"},
 280         {snet: "udp", saddr: "[::ffff:127.0.0.1]", cnet: "udp", caddr: "127.0.0.1"},
 281         {snet: "udp", saddr: "[::1]", cnet: "udp", caddr: "[::1]", ipv6: true},
 282
 283         {snet: "udp4", saddr: "", cnet: "udp4", caddr: "127.0.0.1"},
 284         {snet: "udp4", saddr: "0.0.0.0", cnet: "udp4", caddr: "127.0.0.1"},
 285         {snet: "udp4", saddr: "[::ffff:0.0.0.0]", cnet: "udp4", caddr: "127.0.0.1"},
 286
 287         {snet: "udp4", saddr: "127.0.0.1", cnet: "udp4", caddr: "127.0.0.1"},
 288
 289         {snet: "udp6", saddr: "", cnet: "udp6", caddr: "[::1]", ipv6: true},
 290         {snet: "udp6", saddr: "[::]", cnet: "udp6", caddr: "[::1]", ipv6: true},
 291
 292         {snet: "udp6", saddr: "[::1]", cnet: "udp6", caddr: "[::1]", ipv6: true},
 293
 294         {snet: "udp", saddr: "127.0.0.1", cnet: "udp", caddr: "127.0.0.1", dial: true},
 295         {snet: "udp", saddr: "127.0.0.1", cnet: "udp", caddr: "127.0.0.1", empty: true},
 296         {snet: "udp", saddr: "127.0.0.1", cnet: "udp", caddr: "127.0.0.1", dial: true, empty: true},
 297
 298         {snet: "udp", saddr: "[::1]", cnet: "udp", caddr: "[::1]", ipv6: true, dial: true},
 299         {snet: "udp", saddr: "[::1]", cnet: "udp", caddr: "[::1]", ipv6: true, empty: true},
 300         {snet: "udp", saddr: "[::1]", cnet: "udp", caddr: "[::1]", ipv6: true, dial: true, empty: true},
 301
 302         {snet: "unixgram", saddr: "/tmp/gotest5.net", cnet: "unixgram", caddr: "/tmp/gotest5.net.local"},
 303         {snet: "unixgram", saddr: "/tmp/gotest5.net", cnet: "unixgram", caddr: "/tmp/gotest5.net.local", dial: true},
 304         {snet: "unixgram", saddr: "/tmp/gotest5.net", cnet: "unixgram", caddr: "/tmp/gotest5.net.local", empty: true},
 305         {snet: "unixgram", saddr: "/tmp/gotest5.net", cnet: "unixgram", caddr: "/tmp/gotest5.net.local", dial: true, empty: true},
 306
 307         {snet: "unixgram", saddr: "@gotest6/net", cnet: "unixgram", caddr: "@gotest6/net.local", linux: true},
 308 }
 309
 310 func TestDatagramPacketConnServer(t *testing.T) {
 311         if !*testDatagram {
 312                 return
 313         }
 314
 315         for _, tt := range datagramPacketConnServerTests {
 316                 if skipServerTest(tt.snet, "unixgram", tt.saddr, tt.ipv6, tt.ipv4map, tt.linux) {
 317                         continue
 318                 }
 319
 320                 listening := make(chan string)
 321                 done := make(chan int)
 322                 switch tt.snet {
 323                 case "udp", "udp4", "udp6":
 324                         tt.saddr += ":0"
 325                 case "unixgram":
 326                         os.Remove(tt.saddr)
 327                         os.Remove(tt.caddr)
 328                 }
 329
 330                 go runDatagramPacketConnServer(t, tt.snet, tt.saddr, listening, done)
 331                 taddr := <-listening // wait for server to start
 332
 333                 switch tt.cnet {
 334                 case "udp", "udp4", "udp6":
 335                         _, port, err := SplitHostPort(taddr)
 336                         if err != nil {
 337                                 t.Errorf("SplitHostPort(%q) failed: %v", taddr, err)
 338                                 return
 339                         }
 340                         taddr = tt.caddr + ":" + port
 341                         tt.caddr += ":0"
 342                 }
 343                 if tt.dial {
 344                         runDatagramConnClient(t, tt.cnet, tt.caddr, taddr, tt.empty)
 345                 } else {
 346                         runDatagramPacketConnClient(t, tt.cnet, tt.caddr, taddr, tt.empty)
 347                 }
 348                 <-done // tell server to stop
 349                 <-done // make sure server stopped
 350
 351                 switch tt.snet {
 352                 case "unixgram":
 353                         os.Remove(tt.saddr)
 354                         os.Remove(tt.caddr)
 355                 }
 356         }
 357 }
 358
 359 func runDatagramPacketConnServer(t *testing.T, net, laddr string, listening chan<- string, done chan<- int) {
 360         c, err := ListenPacket(net, laddr)
 361         if err != nil {
 362                 t.Errorf("ListenPacket(%q, %q) failed: %v", net, laddr, err)
 363                 listening <- "<nil>"
 364                 done <- 1
 365                 return
 366         }
 367         defer c.Close()
 368         listening <- c.LocalAddr().String()
 369
 370         buf := make([]byte, 1024)
 371 run:
 372         for {
 373                 c.SetReadDeadline(time.Now().Add(10 * time.Millisecond))
 374                 n, ra, err := c.ReadFrom(buf[0:])
 375                 if nerr, ok := err.(Error); ok && nerr.Timeout() {
 376                         select {
 377                         case done <- 1:
 378                                 break run
 379                         default:
 380                                 continue run
 381                         }
 382                 }
 383                 if err != nil {
 384                         break run
 385                 }
 386                 if _, err = c.WriteTo(buf[0:n], ra); err != nil {
 387                         t.Errorf("WriteTo(%v) failed: %v", ra, err)
 388                         break run
 389                 }
 390         }
 391         done <- 1
 392 }
 393
 394 func runDatagramConnClient(t *testing.T, net, laddr, taddr string, isEmpty bool) {
 395         var c Conn
 396         var err error
 397         switch net {
 398         case "udp", "udp4", "udp6":
 399                 c, err = Dial(net, taddr)
 400                 if err != nil {
 401                         t.Errorf("Dial(%q, %q) failed: %v", net, taddr, err)
 402                         return
 403                 }
 404         case "unixgram":
 405                 c, err = DialUnix(net, &UnixAddr{laddr, net}, &UnixAddr{taddr, net})
 406                 if err != nil {
 407                         t.Errorf("DialUnix(%q, {%q, %q}) failed: %v", net, laddr, taddr, err)
 408                         return
 409                 }
 410         }
 411         defer c.Close()
 412         c.SetReadDeadline(time.Now().Add(1 * time.Second))
 413
 414         var wb []byte
 415         if !isEmpty {
 416                 wb = []byte("DatagramConnClient by Dial\n")
 417         }
 418         if n, err := c.Write(wb[0:]); err != nil || n != len(wb) {
 419                 t.Errorf("Write failed: %v, %v; want %v, <nil>", n, err, len(wb))
 420                 return
 421         }
 422
 423         rb := make([]byte, 1024)
 424         if n, err := c.Read(rb[0:]); err != nil || n != len(wb) {
 425                 t.Errorf("Read failed: %v, %v; want %v, <nil>", n, err, len(wb))
 426                 return
 427         }
 428 }
 429
 430 func runDatagramPacketConnClient(t *testing.T, net, laddr, taddr string, isEmpty bool) {
 431         var ra Addr
 432         var err error
 433         switch net {
 434         case "udp", "udp4", "udp6":
 435                 ra, err = ResolveUDPAddr(net, taddr)
 436                 if err != nil {
 437                         t.Errorf("ResolveUDPAddr(%q, %q) failed: %v", net, taddr, err)
 438                         return
 439                 }
 440         case "unixgram":
 441                 ra, err = ResolveUnixAddr(net, taddr)
 442                 if err != nil {
 443                         t.Errorf("ResolveUxixAddr(%q, %q) failed: %v", net, taddr, err)
 444                         return
 445                 }
 446         }
 447         c, err := ListenPacket(net, laddr)
 448         if err != nil {
 449                 t.Errorf("ListenPacket(%q, %q) faild: %v", net, laddr, err)
 450                 return
 451         }
 452         defer c.Close()
 453         c.SetReadDeadline(time.Now().Add(1 * time.Second))
 454
 455         var wb []byte
 456         if !isEmpty {
 457                 wb = []byte("DatagramPacketConnClient by ListenPacket\n")
 458         }
 459         if n, err := c.WriteTo(wb[0:], ra); err != nil || n != len(wb) {
 460                 t.Errorf("WriteTo(%v) failed: %v, %v; want %v, <nil>", ra, n, err, len(wb))
 461                 return
 462         }
 463
 464         rb := make([]byte, 1024)
 465         if n, _, err := c.ReadFrom(rb[0:]); err != nil || n != len(wb) {
 466                 t.Errorf("ReadFrom failed: %v, %v; want %v, <nil>", n, err, len(wb))
 467                 return
 468         }
 469 }