summaryrefslogtreecommitdiffstats
path: root/src/net/example_test.go
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-28 13:14:23 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-28 13:14:23 +0000
commit73df946d56c74384511a194dd01dbe099584fd1a (patch)
treefd0bcea490dd81327ddfbb31e215439672c9a068 /src/net/example_test.go
parentInitial commit. (diff)
downloadgolang-1.16-73df946d56c74384511a194dd01dbe099584fd1a.tar.xz
golang-1.16-73df946d56c74384511a194dd01dbe099584fd1a.zip
Adding upstream version 1.16.10.upstream/1.16.10upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'src/net/example_test.go')
-rw-r--r--src/net/example_test.go181
1 files changed, 181 insertions, 0 deletions
diff --git a/src/net/example_test.go b/src/net/example_test.go
new file mode 100644
index 0000000..72c7183
--- /dev/null
+++ b/src/net/example_test.go
@@ -0,0 +1,181 @@
+// 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 ExampleDialer_unix() {
+ // DialUnix does not take a context.Context parameter. This example shows
+ // how to dial a Unix socket with a Context. Note that the Context only
+ // applies to the dial operation; it does not apply to the connection once
+ // it has been established.
+ var d net.Dialer
+ ctx, cancel := context.WithTimeout(context.Background(), time.Minute)
+ defer cancel()
+
+ d.LocalAddr = nil // if you have a local addr, add it here
+ raddr := net.UnixAddr{Name: "/path/to/unix.sock", Net: "unix"}
+ conn, err := d.DialContext(ctx, "unix", raddr.String())
+ if err != nil {
+ log.Fatalf("Failed to dial: %v", err)
+ }
+ defer conn.Close()
+ if _, err := conn.Write([]byte("Hello, socket!")); 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
+ // <nil>
+}
+
+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)
+ }
+}