1 // Copyright 2019 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.
16 func makeProto(proto int) *int {
20 func Test_anyToSockaddr(t *testing.T) {
29 name: "AF_TIPC bad addrtype",
38 name: "AF_TIPC NameSeq",
39 rsa: sockaddrTIPCToAny(RawSockaddrTIPC{
41 Addrtype: TIPC_SERVICE_RANGE,
43 Addr: (&TIPCServiceRange{
51 Addr: &TIPCServiceRange{
60 rsa: sockaddrTIPCToAny(RawSockaddrTIPC{
62 Addrtype: TIPC_SERVICE_ADDR,
64 Addr: (&TIPCServiceName{
72 Addr: &TIPCServiceName{
81 rsa: sockaddrTIPCToAny(RawSockaddrTIPC{
83 Addrtype: TIPC_SOCKET_ADDR,
85 Addr: (&TIPCSocketAddr{
92 Addr: &TIPCSocketAddr{
99 name: "AF_INET IPPROTO_L2TP",
100 rsa: sockaddrL2TPIPToAny(RawSockaddrL2TPIP{
102 Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
106 Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
109 proto: makeProto(IPPROTO_L2TP),
112 name: "AF_INET6 IPPROTO_L2TP",
113 rsa: sockaddrL2TPIP6ToAny(RawSockaddrL2TPIP6{
117 0x20, 0x01, 0x0d, 0xb8,
118 0x85, 0xa3, 0x00, 0x00,
119 0x00, 0x00, 0x8a, 0x2e,
120 0x03, 0x70, 0x73, 0x34,
125 sa: &SockaddrL2TPIP6{
127 0x20, 0x01, 0x0d, 0xb8,
128 0x85, 0xa3, 0x00, 0x00,
129 0x00, 0x00, 0x8a, 0x2e,
130 0x03, 0x70, 0x73, 0x34,
135 proto: makeProto(IPPROTO_L2TP),
138 name: "AF_UNIX unnamed/abstract",
139 rsa: sockaddrUnixToAny(RawSockaddrUnix{
147 name: "AF_UNIX named",
148 rsa: sockaddrUnixToAny(RawSockaddrUnix{
150 Path: [108]int8{'g', 'o', 'p', 'h', 'e', 'r'},
158 rsa: sockaddrIUCVToAny(RawSockaddrIUCV{
160 User_id: [8]int8{'*', 'M', 'S', 'G', ' ', ' ', ' ', ' '},
161 Name: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
169 name: "AF_CAN CAN_RAW",
170 rsa: sockaddrCANToAny(RawSockaddrCAN{
174 0xAA, 0xAA, 0xAA, 0xAA,
175 0xBB, 0xBB, 0xBB, 0xBB,
185 proto: makeProto(CAN_RAW),
188 name: "AF_CAN CAN_J1939",
189 rsa: sockaddrCANToAny(RawSockaddrCAN{
193 0xAA, 0xAA, 0xAA, 0xAA,
194 0xAA, 0xAA, 0xAA, 0xAA,
195 0xBB, 0xBB, 0xBB, 0xBB,
196 0xCC, 0x00, 0x00, 0x00,
199 sa: &SockaddrCANJ1939{
201 Name: 0xAAAAAAAAAAAAAAAA,
205 proto: makeProto(CAN_J1939),
208 name: "AF_MAX EAFNOSUPPORT",
209 rsa: &RawSockaddrAny{
216 // TODO: expand to support other families.
219 realSocketProtocol := socketProtocol
221 for _, tt := range tests {
222 t.Run(tt.name, func(t *testing.T) {
225 socketProtocol = func(fd int) (int, error) { return *tt.proto, nil }
227 socketProtocol = realSocketProtocol
229 sa, err := anyToSockaddr(fd, tt.rsa)
231 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
234 if !reflect.DeepEqual(sa, tt.sa) {
235 t.Fatalf("unexpected Sockaddr:\n got: %#v\nwant: %#v", sa, tt.sa)
241 func TestSockaddrTIPC_sockaddr(t *testing.T) {
249 name: "no fields set",
257 Addr: &TIPCSocketAddr{
262 raw: &RawSockaddrTIPC{
264 Addrtype: TIPC_SOCKET_ADDR,
266 Addr: (&TIPCSocketAddr{
276 Addr: &TIPCServiceRange{
282 raw: &RawSockaddrTIPC{
284 Addrtype: TIPC_SERVICE_RANGE,
286 Addr: (&TIPCServiceRange{
297 Addr: &TIPCServiceName{
303 raw: &RawSockaddrTIPC{
305 Addrtype: TIPC_SERVICE_ADDR,
307 Addr: (&TIPCServiceName{
316 for _, tt := range tests {
317 t.Run(tt.name, func(t *testing.T) {
318 out, l, err := tt.sa.sockaddr()
320 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
323 // Must be 0 on error or a fixed size otherwise.
324 if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrTIPC) {
325 t.Fatalf("unexpected Socklen: %d", l)
328 // No pointer to cast, return early.
332 raw := (*RawSockaddrTIPC)(out)
333 if !reflect.DeepEqual(raw, tt.raw) {
334 t.Fatalf("unexpected RawSockaddrTIPC:\n got: %#v\nwant: %#v", raw, tt.raw)
340 func TestSockaddrL2TPIP_sockaddr(t *testing.T) {
344 raw *RawSockaddrL2TPIP
350 Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
353 raw: &RawSockaddrL2TPIP{
355 Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
361 for _, tt := range tests {
362 t.Run(tt.name, func(t *testing.T) {
363 out, l, err := tt.sa.sockaddr()
365 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
368 // Must be 0 on error or a fixed size otherwise.
369 if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrL2TPIP) {
370 t.Fatalf("unexpected Socklen: %d", l)
374 raw := (*RawSockaddrL2TPIP)(out)
375 if !reflect.DeepEqual(raw, tt.raw) {
376 t.Fatalf("unexpected RawSockaddrL2TPIP:\n got: %#v\nwant: %#v", raw, tt.raw)
383 func TestSockaddrL2TPIP6_sockaddr(t *testing.T) {
387 raw *RawSockaddrL2TPIP6
392 sa: &SockaddrL2TPIP6{
394 0x20, 0x01, 0x0d, 0xb8,
395 0x85, 0xa3, 0x00, 0x00,
396 0x00, 0x00, 0x8a, 0x2e,
397 0x03, 0x70, 0x73, 0x34,
402 raw: &RawSockaddrL2TPIP6{
405 0x20, 0x01, 0x0d, 0xb8,
406 0x85, 0xa3, 0x00, 0x00,
407 0x00, 0x00, 0x8a, 0x2e,
408 0x03, 0x70, 0x73, 0x34,
416 for _, tt := range tests {
417 t.Run(tt.name, func(t *testing.T) {
418 out, l, err := tt.sa.sockaddr()
420 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
423 // Must be 0 on error or a fixed size otherwise.
424 if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrL2TPIP6) {
425 t.Fatalf("unexpected Socklen: %d", l)
429 raw := (*RawSockaddrL2TPIP6)(out)
430 if !reflect.DeepEqual(raw, tt.raw) {
431 t.Fatalf("unexpected RawSockaddrL2TPIP6:\n got: %#v\nwant: %#v", raw, tt.raw)
438 func TestSockaddrUnix_sockaddr(t *testing.T) {
449 raw: &RawSockaddrUnix{
452 slen: 2, // family (uint16)
459 raw: &RawSockaddrUnix{
462 slen: 3, // family (uint16) + NULL
469 raw: &RawSockaddrUnix{
471 Path: [108]int8{'g', 'o', 'p', 'h', 'e', 'r'},
473 slen: _Socklen(3 + len("gopher")), // family (uint16) + len(gopher)
476 name: "named too long",
478 Name: strings.Repeat("A", 108),
484 for _, tt := range tests {
485 t.Run(tt.name, func(t *testing.T) {
486 out, l, err := tt.sa.sockaddr()
488 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
492 t.Fatalf("unexpected Socklen: %d, want %d", l, tt.slen)
495 // No pointer to cast, return early.
499 raw := (*RawSockaddrUnix)(out)
500 if !reflect.DeepEqual(raw, tt.raw) {
501 t.Fatalf("unexpected RawSockaddrUnix:\n got: %#v\nwant: %#v", raw, tt.raw)
507 func TestSockaddrIUCV_sockaddr(t *testing.T) {
515 name: "no fields set",
517 raw: &RawSockaddrIUCV{
519 Nodeid: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
520 User_id: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
521 Name: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
525 name: "both fields set",
530 raw: &RawSockaddrIUCV{
532 Nodeid: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
533 User_id: [8]int8{'U', 'S', 'E', 'R', 'I', 'D', ' ', ' '},
534 Name: [8]int8{'N', 'A', 'M', 'E', ' ', ' ', ' ', ' '},
538 name: "too long userid",
545 name: "too long name",
553 for _, tt := range tests {
554 t.Run(tt.name, func(t *testing.T) {
555 out, l, err := tt.sa.sockaddr()
557 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
560 // Must be 0 on error or a fixed size otherwise.
561 if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrIUCV) {
562 t.Fatalf("unexpected Socklen: %d", l)
565 // No pointer to cast, return early.
569 raw := (*RawSockaddrIUCV)(out)
570 if !reflect.DeepEqual(raw, tt.raw) {
571 t.Fatalf("unexpected RawSockaddrIUCV:\n got: %#v\nwant: %#v", raw, tt.raw)
577 func TestSockaddrCAN_sockaddr(t *testing.T) {
591 raw: &RawSockaddrCAN{
595 0xAA, 0xAA, 0xAA, 0xAA,
596 0xBB, 0xBB, 0xBB, 0xBB,
603 name: "negative ifindex",
611 for _, tt := range tests {
612 t.Run(tt.name, func(t *testing.T) {
613 out, l, err := tt.sa.sockaddr()
615 t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
618 // Must be 0 on error or a fixed size otherwise.
619 if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrCAN) {
620 t.Fatalf("unexpected Socklen: %d", l)
624 raw := (*RawSockaddrCAN)(out)
625 if !reflect.DeepEqual(raw, tt.raw) {
626 t.Fatalf("unexpected RawSockaddrCAN:\n got: %#v\nwant: %#v", raw, tt.raw)
633 // These helpers explicitly copy the contents of in into out to produce
634 // the correct sockaddr structure, without relying on unsafe casting to
635 // a type of a larger size.
636 func sockaddrTIPCToAny(in RawSockaddrTIPC) *RawSockaddrAny {
637 var out RawSockaddrAny
639 (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
640 (*(*[SizeofSockaddrTIPC]byte)(unsafe.Pointer(&in)))[:],
645 func sockaddrL2TPIPToAny(in RawSockaddrL2TPIP) *RawSockaddrAny {
646 var out RawSockaddrAny
648 (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
649 (*(*[SizeofSockaddrL2TPIP]byte)(unsafe.Pointer(&in)))[:],
654 func sockaddrL2TPIP6ToAny(in RawSockaddrL2TPIP6) *RawSockaddrAny {
655 var out RawSockaddrAny
657 (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
658 (*(*[SizeofSockaddrL2TPIP6]byte)(unsafe.Pointer(&in)))[:],
663 func sockaddrUnixToAny(in RawSockaddrUnix) *RawSockaddrAny {
664 var out RawSockaddrAny
666 (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
667 (*(*[SizeofSockaddrUnix]byte)(unsafe.Pointer(&in)))[:],
672 func sockaddrIUCVToAny(in RawSockaddrIUCV) *RawSockaddrAny {
673 var out RawSockaddrAny
675 (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
676 (*(*[SizeofSockaddrUnix]byte)(unsafe.Pointer(&in)))[:],
681 func sockaddrCANToAny(in RawSockaddrCAN) *RawSockaddrAny {
682 var out RawSockaddrAny
684 (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
685 (*(*[SizeofSockaddrCAN]byte)(unsafe.Pointer(&in)))[:],