example_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  	"context"
     9  	"fmt"
    10  	"io"
    11  	"log"
    12  	"net"
    13  	"time"
    14  )
    15  
    16  func ExampleListener() {
    17  	// Listen on TCP port 2000 on all available unicast and
    18  	// anycast IP addresses of the local system.
    19  	l, err := net.Listen("tcp", ":2000")
    20  	if err != nil {
    21  		log.Fatal(err)
    22  	}
    23  	defer l.Close()
    24  	for {
    25  		// Wait for a connection.
    26  		conn, err := l.Accept()
    27  		if err != nil {
    28  			log.Fatal(err)
    29  		}
    30  		// Handle the connection in a new goroutine.
    31  		// The loop then returns to accepting, so that
    32  		// multiple connections may be served concurrently.
    33  		go func(c net.Conn) {
    34  			// Echo all incoming data.
    35  			io.Copy(c, c)
    36  			// Shut down the connection.
    37  			c.Close()
    38  		}(conn)
    39  	}
    40  }
    41  
    42  func ExampleDialer() {
    43  	var d net.Dialer
    44  	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
    45  	defer cancel()
    46  
    47  	conn, err := d.DialContext(ctx, "tcp", "localhost:12345")
    48  	if err != nil {
    49  		log.Fatalf("Failed to dial: %v", err)
    50  	}
    51  	defer conn.Close()
    52  
    53  	if _, err := conn.Write([]byte("Hello, World!")); err != nil {
    54  		log.Fatal(err)
    55  	}
    56  }
    57  
    58  func ExampleDialer_unix() {
    59  	// DialUnix does not take a context.Context parameter. This example shows
    60  	// how to dial a Unix socket with a Context. Note that the Context only
    61  	// applies to the dial operation; it does not apply to the connection once
    62  	// it has been established.
    63  	var d net.Dialer
    64  	ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
    65  	defer cancel()
    66  
    67  	d.LocalAddr = nil // if you have a local addr, add it here
    68  	raddr := net.UnixAddr{Name: "/path/to/unix.sock", Net: "unix"}
    69  	conn, err := d.DialContext(ctx, "unix", raddr.String())
    70  	if err != nil {
    71  		log.Fatalf("Failed to dial: %v", err)
    72  	}
    73  	defer conn.Close()
    74  	if _, err := conn.Write([]byte("Hello, socket!")); err != nil {
    75  		log.Fatal(err)
    76  	}
    77  }
    78  
    79  func ExampleIPv4() {
    80  	fmt.Println(net.IPv4(8, 8, 8, 8))
    81  
    82  	// Output:
    83  	// 8.8.8.8
    84  }
    85  
    86  func ExampleParseCIDR() {
    87  	ipv4Addr, ipv4Net, err := net.ParseCIDR("192.0.2.1/24")
    88  	if err != nil {
    89  		log.Fatal(err)
    90  	}
    91  	fmt.Println(ipv4Addr)
    92  	fmt.Println(ipv4Net)
    93  
    94  	ipv6Addr, ipv6Net, err := net.ParseCIDR("2001:db8:a0b:12f0::1/32")
    95  	if err != nil {
    96  		log.Fatal(err)
    97  	}
    98  	fmt.Println(ipv6Addr)
    99  	fmt.Println(ipv6Net)
   100  
   101  	// Output:
   102  	// 192.0.2.1
   103  	// 192.0.2.0/24
   104  	// 2001:db8:a0b:12f0::1
   105  	// 2001:db8::/32
   106  }
   107  
   108  func ExampleParseIP() {
   109  	fmt.Println(net.ParseIP("192.0.2.1"))
   110  	fmt.Println(net.ParseIP("2001:db8::68"))
   111  	fmt.Println(net.ParseIP("192.0.2"))
   112  
   113  	// Output:
   114  	// 192.0.2.1
   115  	// 2001:db8::68
   116  	// <nil>
   117  }
   118  
   119  func ExampleIP_DefaultMask() {
   120  	ip := net.ParseIP("192.0.2.1")
   121  	fmt.Println(ip.DefaultMask())
   122  
   123  	// Output:
   124  	// ffffff00
   125  }
   126  
   127  func ExampleIP_Equal() {
   128  	ipv4DNS := net.ParseIP("8.8.8.8")
   129  	ipv4Lo := net.ParseIP("127.0.0.1")
   130  	ipv6DNS := net.ParseIP("0:0:0:0:0:FFFF:0808:0808")
   131  
   132  	fmt.Println(ipv4DNS.Equal(ipv4DNS))
   133  	fmt.Println(ipv4DNS.Equal(ipv4Lo))
   134  	fmt.Println(ipv4DNS.Equal(ipv6DNS))
   135  
   136  	// Output:
   137  	// true
   138  	// false
   139  	// true
   140  }
   141  
   142  func ExampleIP_IsGlobalUnicast() {
   143  	ipv6Global := net.ParseIP("2000::")
   144  	ipv6UniqLocal := net.ParseIP("2000::")
   145  	ipv6Multi := net.ParseIP("FF00::")
   146  
   147  	ipv4Private := net.ParseIP("10.255.0.0")
   148  	ipv4Public := net.ParseIP("8.8.8.8")
   149  	ipv4Broadcast := net.ParseIP("255.255.255.255")
   150  
   151  	fmt.Println(ipv6Global.IsGlobalUnicast())
   152  	fmt.Println(ipv6UniqLocal.IsGlobalUnicast())
   153  	fmt.Println(ipv6Multi.IsGlobalUnicast())
   154  
   155  	fmt.Println(ipv4Private.IsGlobalUnicast())
   156  	fmt.Println(ipv4Public.IsGlobalUnicast())
   157  	fmt.Println(ipv4Broadcast.IsGlobalUnicast())
   158  
   159  	// Output:
   160  	// true
   161  	// true
   162  	// false
   163  	// true
   164  	// true
   165  	// false
   166  }
   167  
   168  func ExampleIP_IsInterfaceLocalMulticast() {
   169  	ipv6InterfaceLocalMulti := net.ParseIP("ff01::1")
   170  	ipv6Global := net.ParseIP("2000::")
   171  	ipv4 := net.ParseIP("255.0.0.0")
   172  
   173  	fmt.Println(ipv6InterfaceLocalMulti.IsInterfaceLocalMulticast())
   174  	fmt.Println(ipv6Global.IsInterfaceLocalMulticast())
   175  	fmt.Println(ipv4.IsInterfaceLocalMulticast())
   176  
   177  	// Output:
   178  	// true
   179  	// false
   180  	// false
   181  }
   182  
   183  func ExampleIP_IsLinkLocalMulticast() {
   184  	ipv6LinkLocalMulti := net.ParseIP("ff02::2")
   185  	ipv6LinkLocalUni := net.ParseIP("fe80::")
   186  	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
   187  	ipv4LinkLocalUni := net.ParseIP("169.254.0.0")
   188  
   189  	fmt.Println(ipv6LinkLocalMulti.IsLinkLocalMulticast())
   190  	fmt.Println(ipv6LinkLocalUni.IsLinkLocalMulticast())
   191  	fmt.Println(ipv4LinkLocalMulti.IsLinkLocalMulticast())
   192  	fmt.Println(ipv4LinkLocalUni.IsLinkLocalMulticast())
   193  
   194  	// Output:
   195  	// true
   196  	// false
   197  	// true
   198  	// false
   199  }
   200  
   201  func ExampleIP_IsLinkLocalUnicast() {
   202  	ipv6LinkLocalUni := net.ParseIP("fe80::")
   203  	ipv6Global := net.ParseIP("2000::")
   204  	ipv4LinkLocalUni := net.ParseIP("169.254.0.0")
   205  	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
   206  
   207  	fmt.Println(ipv6LinkLocalUni.IsLinkLocalUnicast())
   208  	fmt.Println(ipv6Global.IsLinkLocalUnicast())
   209  	fmt.Println(ipv4LinkLocalUni.IsLinkLocalUnicast())
   210  	fmt.Println(ipv4LinkLocalMulti.IsLinkLocalUnicast())
   211  
   212  	// Output:
   213  	// true
   214  	// false
   215  	// true
   216  	// false
   217  }
   218  
   219  func ExampleIP_IsLoopback() {
   220  	ipv6Lo := net.ParseIP("::1")
   221  	ipv6 := net.ParseIP("ff02::1")
   222  	ipv4Lo := net.ParseIP("127.0.0.0")
   223  	ipv4 := net.ParseIP("128.0.0.0")
   224  
   225  	fmt.Println(ipv6Lo.IsLoopback())
   226  	fmt.Println(ipv6.IsLoopback())
   227  	fmt.Println(ipv4Lo.IsLoopback())
   228  	fmt.Println(ipv4.IsLoopback())
   229  
   230  	// Output:
   231  	// true
   232  	// false
   233  	// true
   234  	// false
   235  }
   236  
   237  func ExampleIP_IsMulticast() {
   238  	ipv6Multi := net.ParseIP("FF00::")
   239  	ipv6LinkLocalMulti := net.ParseIP("ff02::1")
   240  	ipv6Lo := net.ParseIP("::1")
   241  	ipv4Multi := net.ParseIP("239.0.0.0")
   242  	ipv4LinkLocalMulti := net.ParseIP("224.0.0.0")
   243  	ipv4Lo := net.ParseIP("127.0.0.0")
   244  
   245  	fmt.Println(ipv6Multi.IsMulticast())
   246  	fmt.Println(ipv6LinkLocalMulti.IsMulticast())
   247  	fmt.Println(ipv6Lo.IsMulticast())
   248  	fmt.Println(ipv4Multi.IsMulticast())
   249  	fmt.Println(ipv4LinkLocalMulti.IsMulticast())
   250  	fmt.Println(ipv4Lo.IsMulticast())
   251  
   252  	// Output:
   253  	// true
   254  	// true
   255  	// false
   256  	// true
   257  	// true
   258  	// false
   259  }
   260  
   261  func ExampleIP_IsPrivate() {
   262  	ipv6Private := net.ParseIP("fc00::")
   263  	ipv6Public := net.ParseIP("fe00::")
   264  	ipv4Private := net.ParseIP("10.255.0.0")
   265  	ipv4Public := net.ParseIP("11.0.0.0")
   266  
   267  	fmt.Println(ipv6Private.IsPrivate())
   268  	fmt.Println(ipv6Public.IsPrivate())
   269  	fmt.Println(ipv4Private.IsPrivate())
   270  	fmt.Println(ipv4Public.IsPrivate())
   271  
   272  	// Output:
   273  	// true
   274  	// false
   275  	// true
   276  	// false
   277  }
   278  
   279  func ExampleIP_IsUnspecified() {
   280  	ipv6Unspecified := net.ParseIP("::")
   281  	ipv6Specified := net.ParseIP("fe00::")
   282  	ipv4Unspecified := net.ParseIP("0.0.0.0")
   283  	ipv4Specified := net.ParseIP("8.8.8.8")
   284  
   285  	fmt.Println(ipv6Unspecified.IsUnspecified())
   286  	fmt.Println(ipv6Specified.IsUnspecified())
   287  	fmt.Println(ipv4Unspecified.IsUnspecified())
   288  	fmt.Println(ipv4Specified.IsUnspecified())
   289  
   290  	// Output:
   291  	// true
   292  	// false
   293  	// true
   294  	// false
   295  }
   296  
   297  func ExampleIP_Mask() {
   298  	ipv4Addr := net.ParseIP("192.0.2.1")
   299  	// This mask corresponds to a /24 subnet for IPv4.
   300  	ipv4Mask := net.CIDRMask(24, 32)
   301  	fmt.Println(ipv4Addr.Mask(ipv4Mask))
   302  
   303  	ipv6Addr := net.ParseIP("2001:db8:a0b:12f0::1")
   304  	// This mask corresponds to a /32 subnet for IPv6.
   305  	ipv6Mask := net.CIDRMask(32, 128)
   306  	fmt.Println(ipv6Addr.Mask(ipv6Mask))
   307  
   308  	// Output:
   309  	// 192.0.2.0
   310  	// 2001:db8::
   311  }
   312  
   313  func ExampleIP_String() {
   314  	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
   315  	ipv4 := net.IPv4(10, 255, 0, 0)
   316  
   317  	fmt.Println(ipv6.String())
   318  	fmt.Println(ipv4.String())
   319  
   320  	// Output:
   321  	// fc00::
   322  	// 10.255.0.0
   323  }
   324  
   325  func ExampleIP_To16() {
   326  	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
   327  	ipv4 := net.IPv4(10, 255, 0, 0)
   328  
   329  	fmt.Println(ipv6.To16())
   330  	fmt.Println(ipv4.To16())
   331  
   332  	// Output:
   333  	// fc00::
   334  	// 10.255.0.0
   335  }
   336  
   337  func ExampleIP_to4() {
   338  	ipv6 := net.IP{0xfc, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}
   339  	ipv4 := net.IPv4(10, 255, 0, 0)
   340  
   341  	fmt.Println(ipv6.To4())
   342  	fmt.Println(ipv4.To4())
   343  
   344  	// Output:
   345  	// <nil>
   346  	// 10.255.0.0
   347  }
   348  
   349  func ExampleCIDRMask() {
   350  	// This mask corresponds to a /31 subnet for IPv4.
   351  	fmt.Println(net.CIDRMask(31, 32))
   352  
   353  	// This mask corresponds to a /64 subnet for IPv6.
   354  	fmt.Println(net.CIDRMask(64, 128))
   355  
   356  	// Output:
   357  	// fffffffe
   358  	// ffffffffffffffff0000000000000000
   359  }
   360  
   361  func ExampleIPv4Mask() {
   362  	fmt.Println(net.IPv4Mask(255, 255, 255, 0))
   363  
   364  	// Output:
   365  	// ffffff00
   366  }
   367  
   368  func ExampleUDPConn_WriteTo() {
   369  	// Unlike Dial, ListenPacket creates a connection without any
   370  	// association with peers.
   371  	conn, err := net.ListenPacket("udp", ":0")
   372  	if err != nil {
   373  		log.Fatal(err)
   374  	}
   375  	defer conn.Close()
   376  
   377  	dst, err := net.ResolveUDPAddr("udp", "192.0.2.1:2000")
   378  	if err != nil {
   379  		log.Fatal(err)
   380  	}
   381  
   382  	// The connection can write data to the desired address.
   383  	_, err = conn.WriteTo([]byte("data"), dst)
   384  	if err != nil {
   385  		log.Fatal(err)
   386  	}
   387  }
   388
View as plain text