interface_unix_test.go

Documentation: net

     1  // Copyright 2013 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  //go:build darwin || dragonfly || freebsd || linux || netbsd || openbsd
     6  // +build darwin dragonfly freebsd linux netbsd openbsd
     7  
     8  package net
     9  
    10  import (
    11  	"fmt"
    12  	"os"
    13  	"os/exec"
    14  	"runtime"
    15  	"strings"
    16  	"testing"
    17  	"time"
    18  )
    19  
    20  type testInterface struct {
    21  	name         string
    22  	local        string
    23  	remote       string
    24  	setupCmds    []*exec.Cmd
    25  	teardownCmds []*exec.Cmd
    26  }
    27  
    28  func (ti *testInterface) setup() error {
    29  	for _, cmd := range ti.setupCmds {
    30  		if out, err := cmd.CombinedOutput(); err != nil {
    31  			return fmt.Errorf("args=%v out=%q err=%v", cmd.Args, string(out), err)
    32  		}
    33  	}
    34  	return nil
    35  }
    36  
    37  func (ti *testInterface) teardown() error {
    38  	for _, cmd := range ti.teardownCmds {
    39  		if out, err := cmd.CombinedOutput(); err != nil {
    40  			return fmt.Errorf("args=%v out=%q err=%v ", cmd.Args, string(out), err)
    41  		}
    42  	}
    43  	return nil
    44  }
    45  
    46  func TestPointToPointInterface(t *testing.T) {
    47  	if testing.Short() {
    48  		t.Skip("avoid external network")
    49  	}
    50  	if runtime.GOOS == "darwin" || runtime.GOOS == "ios" {
    51  		t.Skipf("not supported on %s", runtime.GOOS)
    52  	}
    53  	if os.Getuid() != 0 {
    54  		t.Skip("must be root")
    55  	}
    56  
    57  	// We suppose that using IPv4 link-local addresses doesn't
    58  	// harm anyone.
    59  	local, remote := "169.254.0.1", "169.254.0.254"
    60  	ip := ParseIP(remote)
    61  	for i := 0; i < 3; i++ {
    62  		ti := &testInterface{local: local, remote: remote}
    63  		if err := ti.setPointToPoint(5963 + i); err != nil {
    64  			t.Skipf("test requires external command: %v", err)
    65  		}
    66  		if err := ti.setup(); err != nil {
    67  			if e := err.Error(); strings.Contains(e, "No such device") && strings.Contains(e, "gre0") {
    68  				t.Skip("skipping test; no gre0 device. likely running in container?")
    69  			}
    70  			t.Fatal(err)
    71  		} else {
    72  			time.Sleep(3 * time.Millisecond)
    73  		}
    74  		ift, err := Interfaces()
    75  		if err != nil {
    76  			ti.teardown()
    77  			t.Fatal(err)
    78  		}
    79  		for _, ifi := range ift {
    80  			if ti.name != ifi.Name {
    81  				continue
    82  			}
    83  			ifat, err := ifi.Addrs()
    84  			if err != nil {
    85  				ti.teardown()
    86  				t.Fatal(err)
    87  			}
    88  			for _, ifa := range ifat {
    89  				if ip.Equal(ifa.(*IPNet).IP) {
    90  					ti.teardown()
    91  					t.Fatalf("got %v", ifa)
    92  				}
    93  			}
    94  		}
    95  		if err := ti.teardown(); err != nil {
    96  			t.Fatal(err)
    97  		} else {
    98  			time.Sleep(3 * time.Millisecond)
    99  		}
   100  	}
   101  }
   102  
   103  func TestInterfaceArrivalAndDeparture(t *testing.T) {
   104  	if testing.Short() {
   105  		t.Skip("avoid external network")
   106  	}
   107  	if os.Getuid() != 0 {
   108  		t.Skip("must be root")
   109  	}
   110  
   111  	// We suppose that using IPv4 link-local addresses and the
   112  	// dot1Q ID for Token Ring and FDDI doesn't harm anyone.
   113  	local, remote := "169.254.0.1", "169.254.0.254"
   114  	ip := ParseIP(remote)
   115  	for _, vid := range []int{1002, 1003, 1004, 1005} {
   116  		ift1, err := Interfaces()
   117  		if err != nil {
   118  			t.Fatal(err)
   119  		}
   120  		ti := &testInterface{local: local, remote: remote}
   121  		if err := ti.setBroadcast(vid); err != nil {
   122  			t.Skipf("test requires external command: %v", err)
   123  		}
   124  		if err := ti.setup(); err != nil {
   125  			t.Fatal(err)
   126  		} else {
   127  			time.Sleep(3 * time.Millisecond)
   128  		}
   129  		ift2, err := Interfaces()
   130  		if err != nil {
   131  			ti.teardown()
   132  			t.Fatal(err)
   133  		}
   134  		if len(ift2) <= len(ift1) {
   135  			for _, ifi := range ift1 {
   136  				t.Logf("before: %v", ifi)
   137  			}
   138  			for _, ifi := range ift2 {
   139  				t.Logf("after: %v", ifi)
   140  			}
   141  			ti.teardown()
   142  			t.Fatalf("got %v; want gt %v", len(ift2), len(ift1))
   143  		}
   144  		for _, ifi := range ift2 {
   145  			if ti.name != ifi.Name {
   146  				continue
   147  			}
   148  			ifat, err := ifi.Addrs()
   149  			if err != nil {
   150  				ti.teardown()
   151  				t.Fatal(err)
   152  			}
   153  			for _, ifa := range ifat {
   154  				if ip.Equal(ifa.(*IPNet).IP) {
   155  					ti.teardown()
   156  					t.Fatalf("got %v", ifa)
   157  				}
   158  			}
   159  		}
   160  		if err := ti.teardown(); err != nil {
   161  			t.Fatal(err)
   162  		} else {
   163  			time.Sleep(3 * time.Millisecond)
   164  		}
   165  		ift3, err := Interfaces()
   166  		if err != nil {
   167  			t.Fatal(err)
   168  		}
   169  		if len(ift3) >= len(ift2) {
   170  			for _, ifi := range ift2 {
   171  				t.Logf("before: %v", ifi)
   172  			}
   173  			for _, ifi := range ift3 {
   174  				t.Logf("after: %v", ifi)
   175  			}
   176  			t.Fatalf("got %v; want lt %v", len(ift3), len(ift2))
   177  		}
   178  	}
   179  }
   180  
   181  func TestInterfaceArrivalAndDepartureZoneCache(t *testing.T) {
   182  	if testing.Short() {
   183  		t.Skip("avoid external network")
   184  	}
   185  	if os.Getuid() != 0 {
   186  		t.Skip("must be root")
   187  	}
   188  
   189  	// Ensure zoneCache is filled:
   190  	_, _ = Listen("tcp", "[fe80::1%nonexistent]:0")
   191  
   192  	ti := &testInterface{local: "fe80::1"}
   193  	if err := ti.setLinkLocal(0); err != nil {
   194  		t.Skipf("test requires external command: %v", err)
   195  	}
   196  	if err := ti.setup(); err != nil {
   197  		t.Fatal(err)
   198  	}
   199  	defer ti.teardown()
   200  
   201  	time.Sleep(3 * time.Millisecond)
   202  
   203  	// If Listen fails (on Linux with “bind: invalid argument”), zoneCache was
   204  	// not updated when encountering a nonexistent interface:
   205  	ln, err := Listen("tcp", "[fe80::1%"+ti.name+"]:0")
   206  	if err != nil {
   207  		t.Fatal(err)
   208  	}
   209  	ln.Close()
   210  	if err := ti.teardown(); err != nil {
   211  		t.Fatal(err)
   212  	}
   213  }
   214
View as plain text