// Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package net_test import ( "context" "fmt" "io" "log" "net" "time" ) func ExampleListener() { // Listen on TCP port 2000 on all available unicast and // anycast IP addresses of the local system. l, err := net.Listen("tcp", ":2000") if err != nil { log.Fatal(err) } defer l.Close() for { // Wait for a connection. conn, err := l.Accept() if err != nil { log.Fatal(err) } // Handle the connection in a new goroutine. // The loop then returns to accepting, so that // multiple connections may be served concurrently. go func(c net.Conn) { // Echo all incoming data. io.Copy(c, c) // Shut down the connection. c.Close() }(conn) } } func ExampleDialer() { var d net.Dialer ctx, cancel := context.WithTimeout(context.Background(), time.Minute) defer cancel() conn, err := d.DialContext(ctx, "tcp", "localhost:12345") if err != nil { log.Fatalf("Failed to dial: %v", err) } defer conn.Close() if _, err := conn.Write([]byte("Hello, World!")); err != nil { log.Fatal(err) } } func ExampleIPv4() { fmt.Println(net.IPv4(8, 8, 8, 8)) // Output: // 8.8.8.8 } func ExampleParseCIDR() { ipv4Addr, ipv4Net, err := net.ParseCIDR("192.0.2.1/24") if err != nil { log.Fatal(err) } fmt.Println(ipv4Addr) fmt.Println(ipv4Net) ipv6Addr, ipv6Net, err := net.ParseCIDR("2001:db8:a0b:12f0::1/32") if err != nil { log.Fatal(err) } fmt.Println(ipv6Addr) fmt.Println(ipv6Net) // Output: // 192.0.2.1 // 192.0.2.0/24 // 2001:db8:a0b:12f0::1 // 2001:db8::/32 } func ExampleParseIP() { fmt.Println(net.ParseIP("192.0.2.1")) fmt.Println(net.ParseIP("2001:db8::68")) fmt.Println(net.ParseIP("192.0.2")) // Output: // 192.0.2.1 // 2001:db8::68 // } func ExampleIP_DefaultMask() { ip := net.ParseIP("192.0.2.1") fmt.Println(ip.DefaultMask()) // Output: // ffffff00 } func ExampleIP_Mask() { ipv4Addr := net.ParseIP("192.0.2.1") // This mask corresponds to a /24 subnet for IPv4. ipv4Mask := net.CIDRMask(24, 32) fmt.Println(ipv4Addr.Mask(ipv4Mask)) ipv6Addr := net.ParseIP("2001:db8:a0b:12f0::1") // This mask corresponds to a /32 subnet for IPv6. ipv6Mask := net.CIDRMask(32, 128) fmt.Println(ipv6Addr.Mask(ipv6Mask)) // Output: // 192.0.2.0 // 2001:db8:: } func ExampleCIDRMask() { // This mask corresponds to a /31 subnet for IPv4. fmt.Println(net.CIDRMask(31, 32)) // This mask corresponds to a /64 subnet for IPv6. fmt.Println(net.CIDRMask(64, 128)) // Output: // fffffffe // ffffffffffffffff0000000000000000 } func ExampleIPv4Mask() { fmt.Println(net.IPv4Mask(255, 255, 255, 0)) // Output: // ffffff00 } func ExampleUDPConn_WriteTo() { // Unlike Dial, ListenPacket creates a connection without any // association with peers. conn, err := net.ListenPacket("udp", ":0") if err != nil { log.Fatal(err) } defer conn.Close() dst, err := net.ResolveUDPAddr("udp", "192.0.2.1:2000") if err != nil { log.Fatal(err) } // The connection can write data to the desired address. _, err = conn.WriteTo([]byte("data"), dst) if err != nil { log.Fatal(err) } }