← Back to branch summary

~nskaggs/+junk/xenial-test

« back to all changes in this revision

Viewing changes to src/golang.org/x/net/ipv4/unicast_test.go

  • Committer: Nicholas Skaggs
  • Date: 2016-10-24 20:56:05 UTC
  • Revision ID: nicholas.skaggs@canonical.com-20161024205605-z8lta0uvuhtxwzwl
Initi with beta15

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/golang.org/x/net/ipv4/unicast_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 ipv4_test
 
6
 
 
7
import (
 
8
        "bytes"
 
9
        "net"
 
10
        "os"
 
11
        "runtime"
 
12
        "testing"
 
13
        "time"
 
14
 
 
15
        "golang.org/x/net/icmp"
 
16
        "golang.org/x/net/internal/iana"
 
17
        "golang.org/x/net/internal/nettest"
 
18
        "golang.org/x/net/ipv4"
 
19
)
 
20
 
 
21
func TestPacketConnReadWriteUnicastUDP(t *testing.T) {
 
22
        switch runtime.GOOS {
 
23
        case "nacl", "plan9", "solaris", "windows":
 
24
                t.Skipf("not supported on %s", runtime.GOOS)
 
25
        }
 
26
        ifi := nettest.RoutedInterface("ip4", net.FlagUp|net.FlagLoopback)
 
27
        if ifi == nil {
 
28
                t.Skipf("not available on %s", runtime.GOOS)
 
29
        }
 
30
 
 
31
        c, err := net.ListenPacket("udp4", "127.0.0.1:0")
 
32
        if err != nil {
 
33
                t.Fatal(err)
 
34
        }
 
35
        defer c.Close()
 
36
 
 
37
        dst, err := net.ResolveUDPAddr("udp4", c.LocalAddr().String())
 
38
        if err != nil {
 
39
                t.Fatal(err)
 
40
        }
 
41
        p := ipv4.NewPacketConn(c)
 
42
        defer p.Close()
 
43
        cf := ipv4.FlagTTL | ipv4.FlagDst | ipv4.FlagInterface
 
44
        wb := []byte("HELLO-R-U-THERE")
 
45
 
 
46
        for i, toggle := range []bool{true, false, true} {
 
47
                if err := p.SetControlMessage(cf, toggle); err != nil {
 
48
                        if nettest.ProtocolNotSupported(err) {
 
49
                                t.Logf("not supported on %s", runtime.GOOS)
 
50
                                continue
 
51
                        }
 
52
                        t.Fatal(err)
 
53
                }
 
54
                p.SetTTL(i + 1)
 
55
                if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
 
56
                        t.Fatal(err)
 
57
                }
 
58
                if n, err := p.WriteTo(wb, nil, dst); err != nil {
 
59
                        t.Fatal(err)
 
60
                } else if n != len(wb) {
 
61
                        t.Fatalf("got %v; want %v", n, len(wb))
 
62
                }
 
63
                rb := make([]byte, 128)
 
64
                if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
 
65
                        t.Fatal(err)
 
66
                }
 
67
                if n, cm, _, err := p.ReadFrom(rb); err != nil {
 
68
                        t.Fatal(err)
 
69
                } else if !bytes.Equal(rb[:n], wb) {
 
70
                        t.Fatalf("got %v; want %v", rb[:n], wb)
 
71
                } else {
 
72
                        t.Logf("rcvd cmsg: %v", cm)
 
73
                }
 
74
        }
 
75
}
 
76
 
 
77
func TestPacketConnReadWriteUnicastICMP(t *testing.T) {
 
78
        switch runtime.GOOS {
 
79
        case "nacl", "plan9", "solaris", "windows":
 
80
                t.Skipf("not supported on %s", runtime.GOOS)
 
81
        }
 
82
        if m, ok := nettest.SupportsRawIPSocket(); !ok {
 
83
                t.Skip(m)
 
84
        }
 
85
        ifi := nettest.RoutedInterface("ip4", net.FlagUp|net.FlagLoopback)
 
86
        if ifi == nil {
 
87
                t.Skipf("not available on %s", runtime.GOOS)
 
88
        }
 
89
 
 
90
        c, err := net.ListenPacket("ip4:icmp", "0.0.0.0")
 
91
        if err != nil {
 
92
                t.Fatal(err)
 
93
        }
 
94
        defer c.Close()
 
95
 
 
96
        dst, err := net.ResolveIPAddr("ip4", "127.0.0.1")
 
97
        if err != nil {
 
98
                t.Fatal(err)
 
99
        }
 
100
        p := ipv4.NewPacketConn(c)
 
101
        defer p.Close()
 
102
        cf := ipv4.FlagTTL | ipv4.FlagDst | ipv4.FlagInterface
 
103
 
 
104
        for i, toggle := range []bool{true, false, true} {
 
105
                wb, err := (&icmp.Message{
 
106
                        Type: ipv4.ICMPTypeEcho, Code: 0,
 
107
                        Body: &icmp.Echo{
 
108
                                ID: os.Getpid() & 0xffff, Seq: i + 1,
 
109
                                Data: []byte("HELLO-R-U-THERE"),
 
110
                        },
 
111
                }).Marshal(nil)
 
112
                if err != nil {
 
113
                        t.Fatal(err)
 
114
                }
 
115
                if err := p.SetControlMessage(cf, toggle); err != nil {
 
116
                        if nettest.ProtocolNotSupported(err) {
 
117
                                t.Logf("not supported on %s", runtime.GOOS)
 
118
                                continue
 
119
                        }
 
120
                        t.Fatal(err)
 
121
                }
 
122
                p.SetTTL(i + 1)
 
123
                if err := p.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
 
124
                        t.Fatal(err)
 
125
                }
 
126
                if n, err := p.WriteTo(wb, nil, dst); err != nil {
 
127
                        t.Fatal(err)
 
128
                } else if n != len(wb) {
 
129
                        t.Fatalf("got %v; want %v", n, len(wb))
 
130
                }
 
131
                rb := make([]byte, 128)
 
132
        loop:
 
133
                if err := p.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
 
134
                        t.Fatal(err)
 
135
                }
 
136
                if n, cm, _, err := p.ReadFrom(rb); err != nil {
 
137
                        switch runtime.GOOS {
 
138
                        case "darwin": // older darwin kernels have some limitation on receiving icmp packet through raw socket
 
139
                                t.Logf("not supported on %s", runtime.GOOS)
 
140
                                continue
 
141
                        }
 
142
                        t.Fatal(err)
 
143
                } else {
 
144
                        t.Logf("rcvd cmsg: %v", cm)
 
145
                        m, err := icmp.ParseMessage(iana.ProtocolICMP, rb[:n])
 
146
                        if err != nil {
 
147
                                t.Fatal(err)
 
148
                        }
 
149
                        if runtime.GOOS == "linux" && m.Type == ipv4.ICMPTypeEcho {
 
150
                                // On Linux we must handle own sent packets.
 
151
                                goto loop
 
152
                        }
 
153
                        if m.Type != ipv4.ICMPTypeEchoReply || m.Code != 0 {
 
154
                                t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
 
155
                        }
 
156
                }
 
157
        }
 
158
}
 
159
 
 
160
func TestRawConnReadWriteUnicastICMP(t *testing.T) {
 
161
        switch runtime.GOOS {
 
162
        case "nacl", "plan9", "solaris", "windows":
 
163
                t.Skipf("not supported on %s", runtime.GOOS)
 
164
        }
 
165
        if m, ok := nettest.SupportsRawIPSocket(); !ok {
 
166
                t.Skip(m)
 
167
        }
 
168
        ifi := nettest.RoutedInterface("ip4", net.FlagUp|net.FlagLoopback)
 
169
        if ifi == nil {
 
170
                t.Skipf("not available on %s", runtime.GOOS)
 
171
        }
 
172
 
 
173
        c, err := net.ListenPacket("ip4:icmp", "0.0.0.0")
 
174
        if err != nil {
 
175
                t.Fatal(err)
 
176
        }
 
177
        defer c.Close()
 
178
 
 
179
        dst, err := net.ResolveIPAddr("ip4", "127.0.0.1")
 
180
        if err != nil {
 
181
                t.Fatal(err)
 
182
        }
 
183
        r, err := ipv4.NewRawConn(c)
 
184
        if err != nil {
 
185
                t.Fatal(err)
 
186
        }
 
187
        defer r.Close()
 
188
        cf := ipv4.FlagTTL | ipv4.FlagDst | ipv4.FlagInterface
 
189
 
 
190
        for i, toggle := range []bool{true, false, true} {
 
191
                wb, err := (&icmp.Message{
 
192
                        Type: ipv4.ICMPTypeEcho, Code: 0,
 
193
                        Body: &icmp.Echo{
 
194
                                ID: os.Getpid() & 0xffff, Seq: i + 1,
 
195
                                Data: []byte("HELLO-R-U-THERE"),
 
196
                        },
 
197
                }).Marshal(nil)
 
198
                if err != nil {
 
199
                        t.Fatal(err)
 
200
                }
 
201
                wh := &ipv4.Header{
 
202
                        Version:  ipv4.Version,
 
203
                        Len:      ipv4.HeaderLen,
 
204
                        TOS:      i + 1,
 
205
                        TotalLen: ipv4.HeaderLen + len(wb),
 
206
                        TTL:      i + 1,
 
207
                        Protocol: 1,
 
208
                        Dst:      dst.IP,
 
209
                }
 
210
                if err := r.SetControlMessage(cf, toggle); err != nil {
 
211
                        if nettest.ProtocolNotSupported(err) {
 
212
                                t.Logf("not supported on %s", runtime.GOOS)
 
213
                                continue
 
214
                        }
 
215
                        t.Fatal(err)
 
216
                }
 
217
                if err := r.SetWriteDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
 
218
                        t.Fatal(err)
 
219
                }
 
220
                if err := r.WriteTo(wh, wb, nil); err != nil {
 
221
                        t.Fatal(err)
 
222
                }
 
223
                rb := make([]byte, ipv4.HeaderLen+128)
 
224
        loop:
 
225
                if err := r.SetReadDeadline(time.Now().Add(100 * time.Millisecond)); err != nil {
 
226
                        t.Fatal(err)
 
227
                }
 
228
                if _, b, cm, err := r.ReadFrom(rb); err != nil {
 
229
                        switch runtime.GOOS {
 
230
                        case "darwin": // older darwin kernels have some limitation on receiving icmp packet through raw socket
 
231
                                t.Logf("not supported on %s", runtime.GOOS)
 
232
                                continue
 
233
                        }
 
234
                        t.Fatal(err)
 
235
                } else {
 
236
                        t.Logf("rcvd cmsg: %v", cm)
 
237
                        m, err := icmp.ParseMessage(iana.ProtocolICMP, b)
 
238
                        if err != nil {
 
239
                                t.Fatal(err)
 
240
                        }
 
241
                        if runtime.GOOS == "linux" && m.Type == ipv4.ICMPTypeEcho {
 
242
                                // On Linux we must handle own sent packets.
 
243
                                goto loop
 
244
                        }
 
245
                        if m.Type != ipv4.ICMPTypeEchoReply || m.Code != 0 {
 
246
                                t.Fatalf("got type=%v, code=%v; want type=%v, code=%v", m.Type, m.Code, ipv4.ICMPTypeEchoReply, 0)
 
247
                        }
 
248
                }
 
249
        }
 
250
}