summaryrefslogtreecommitdiffstats
path: root/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_internal_linux_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_internal_linux_test.go')
-rw-r--r--dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_internal_linux_test.go942
1 files changed, 942 insertions, 0 deletions
diff --git a/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_internal_linux_test.go b/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_internal_linux_test.go
new file mode 100644
index 0000000..fd6d219
--- /dev/null
+++ b/dependencies/pkg/mod/golang.org/x/sys@v0.1.0/unix/syscall_internal_linux_test.go
@@ -0,0 +1,942 @@
+// Copyright 2019 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.
+
+//go:build linux
+// +build linux
+
+package unix
+
+import (
+ "reflect"
+ "strings"
+ "testing"
+ "unsafe"
+)
+
+func makeProto(proto int) *int {
+ return &proto
+}
+
+func Test_anyToSockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ rsa *RawSockaddrAny
+ sa Sockaddr
+ err error
+ proto *int
+ }{
+ {
+ name: "AF_TIPC bad addrtype",
+ rsa: &RawSockaddrAny{
+ Addr: RawSockaddr{
+ Family: AF_TIPC,
+ },
+ },
+ err: EINVAL,
+ },
+ {
+ name: "AF_TIPC NameSeq",
+ rsa: sockaddrTIPCToAny(RawSockaddrTIPC{
+ Family: AF_TIPC,
+ Addrtype: TIPC_SERVICE_RANGE,
+ Scope: 1,
+ Addr: (&TIPCServiceRange{
+ Type: 1,
+ Lower: 2,
+ Upper: 3,
+ }).tipcAddr(),
+ }),
+ sa: &SockaddrTIPC{
+ Scope: 1,
+ Addr: &TIPCServiceRange{
+ Type: 1,
+ Lower: 2,
+ Upper: 3,
+ },
+ },
+ },
+ {
+ name: "AF_TIPC Name",
+ rsa: sockaddrTIPCToAny(RawSockaddrTIPC{
+ Family: AF_TIPC,
+ Addrtype: TIPC_SERVICE_ADDR,
+ Scope: 2,
+ Addr: (&TIPCServiceName{
+ Type: 1,
+ Instance: 2,
+ Domain: 3,
+ }).tipcAddr(),
+ }),
+ sa: &SockaddrTIPC{
+ Scope: 2,
+ Addr: &TIPCServiceName{
+ Type: 1,
+ Instance: 2,
+ Domain: 3,
+ },
+ },
+ },
+ {
+ name: "AF_TIPC ID",
+ rsa: sockaddrTIPCToAny(RawSockaddrTIPC{
+ Family: AF_TIPC,
+ Addrtype: TIPC_SOCKET_ADDR,
+ Scope: 3,
+ Addr: (&TIPCSocketAddr{
+ Ref: 1,
+ Node: 2,
+ }).tipcAddr(),
+ }),
+ sa: &SockaddrTIPC{
+ Scope: 3,
+ Addr: &TIPCSocketAddr{
+ Ref: 1,
+ Node: 2,
+ },
+ },
+ },
+ {
+ name: "AF_INET IPPROTO_L2TP",
+ rsa: sockaddrL2TPIPToAny(RawSockaddrL2TPIP{
+ Family: AF_INET,
+ Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
+ Conn_id: 0x1234abcd,
+ }),
+ sa: &SockaddrL2TPIP{
+ Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
+ ConnId: 0x1234abcd,
+ },
+ proto: makeProto(IPPROTO_L2TP),
+ },
+ {
+ name: "AF_INET6 IPPROTO_L2TP",
+ rsa: sockaddrL2TPIP6ToAny(RawSockaddrL2TPIP6{
+ Family: AF_INET6,
+ Flowinfo: 42,
+ Addr: [16]byte{
+ 0x20, 0x01, 0x0d, 0xb8,
+ 0x85, 0xa3, 0x00, 0x00,
+ 0x00, 0x00, 0x8a, 0x2e,
+ 0x03, 0x70, 0x73, 0x34,
+ },
+ Scope_id: 90210,
+ Conn_id: 0x1234abcd,
+ }),
+ sa: &SockaddrL2TPIP6{
+ Addr: [16]byte{
+ 0x20, 0x01, 0x0d, 0xb8,
+ 0x85, 0xa3, 0x00, 0x00,
+ 0x00, 0x00, 0x8a, 0x2e,
+ 0x03, 0x70, 0x73, 0x34,
+ },
+ ZoneId: 90210,
+ ConnId: 0x1234abcd,
+ },
+ proto: makeProto(IPPROTO_L2TP),
+ },
+ {
+ name: "AF_UNIX unnamed/abstract",
+ rsa: sockaddrUnixToAny(RawSockaddrUnix{
+ Family: AF_UNIX,
+ }),
+ sa: &SockaddrUnix{
+ Name: "@",
+ },
+ },
+ {
+ name: "AF_UNIX named",
+ rsa: sockaddrUnixToAny(RawSockaddrUnix{
+ Family: AF_UNIX,
+ Path: [108]int8{'g', 'o', 'p', 'h', 'e', 'r'},
+ }),
+ sa: &SockaddrUnix{
+ Name: "gopher",
+ },
+ },
+ {
+ name: "AF_IUCV",
+ rsa: sockaddrIUCVToAny(RawSockaddrIUCV{
+ Family: AF_IUCV,
+ User_id: [8]int8{'*', 'M', 'S', 'G', ' ', ' ', ' ', ' '},
+ Name: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
+ }),
+ sa: &SockaddrIUCV{
+ UserID: "*MSG ",
+ Name: " ",
+ },
+ },
+ {
+ name: "AF_CAN CAN_RAW",
+ rsa: sockaddrCANToAny(RawSockaddrCAN{
+ Family: AF_CAN,
+ Ifindex: 12345678,
+ Addr: [16]byte{
+ 0xAA, 0xAA, 0xAA, 0xAA,
+ 0xBB, 0xBB, 0xBB, 0xBB,
+ 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0,
+ },
+ }),
+ sa: &SockaddrCAN{
+ Ifindex: 12345678,
+ RxID: 0xAAAAAAAA,
+ TxID: 0xBBBBBBBB,
+ },
+ proto: makeProto(CAN_RAW),
+ },
+ {
+ name: "AF_CAN CAN_J1939",
+ rsa: sockaddrCANToAny(RawSockaddrCAN{
+ Family: AF_CAN,
+ Ifindex: 12345678,
+ Addr: [16]byte{
+ 0xAA, 0xAA, 0xAA, 0xAA,
+ 0xAA, 0xAA, 0xAA, 0xAA,
+ 0xBB, 0xBB, 0xBB, 0xBB,
+ 0xCC, 0x00, 0x00, 0x00,
+ },
+ }),
+ sa: &SockaddrCANJ1939{
+ Ifindex: 12345678,
+ Name: 0xAAAAAAAAAAAAAAAA,
+ PGN: 0xBBBBBBBB,
+ Addr: 0xCC,
+ },
+ proto: makeProto(CAN_J1939),
+ },
+ {
+ name: "AF_NFC RAW",
+ rsa: sockaddrNFCToAny(RawSockaddrNFC{
+ Sa_family: AF_NFC,
+ Dev_idx: 10,
+ Target_idx: 20,
+ Nfc_protocol: 30,
+ }),
+ sa: &SockaddrNFC{
+ DeviceIdx: 10,
+ TargetIdx: 20,
+ NFCProtocol: 30,
+ },
+ proto: makeProto(NFC_SOCKPROTO_RAW),
+ },
+ {
+ name: "AF_NFC LLCP",
+ rsa: sockaddrNFCLLCPToAny(RawSockaddrNFCLLCP{
+ Sa_family: AF_NFC,
+ Dev_idx: 10,
+ Target_idx: 20,
+ Nfc_protocol: 30,
+ Dsap: 40,
+ Ssap: 50,
+ Service_name: [63]uint8{'t', 'e', 's', 't'},
+ Service_name_len: 4,
+ }),
+ sa: &SockaddrNFCLLCP{
+ DeviceIdx: 10,
+ TargetIdx: 20,
+ NFCProtocol: 30,
+ DestinationSAP: 40,
+ SourceSAP: 50,
+ ServiceName: "test",
+ },
+ proto: makeProto(NFC_SOCKPROTO_LLCP),
+ },
+ {
+ name: "AF_NFC unknown",
+ rsa: sockaddrNFCToAny(RawSockaddrNFC{
+ Sa_family: AF_NFC,
+ Dev_idx: 10,
+ Target_idx: 20,
+ Nfc_protocol: 30,
+ }),
+ err: EINVAL,
+ proto: makeProto(^0),
+ },
+ {
+ name: "AF_VSOCK emtpy",
+ rsa: sockaddrVMToAny(RawSockaddrVM{}),
+ err: EAFNOSUPPORT,
+ },
+ {
+ name: "AF_VSOCK Cid and Port",
+ rsa: sockaddrVMToAny(RawSockaddrVM{
+ Family: AF_VSOCK,
+ Cid: VMADDR_CID_HOST,
+ Port: VMADDR_PORT_ANY,
+ }),
+ sa: &SockaddrVM{
+ CID: VMADDR_CID_HOST,
+ Port: VMADDR_PORT_ANY,
+ },
+ },
+ {
+ name: "AF_MAX EAFNOSUPPORT",
+ rsa: &RawSockaddrAny{
+ Addr: RawSockaddr{
+ Family: AF_MAX,
+ },
+ },
+ err: EAFNOSUPPORT,
+ },
+ // TODO: expand to support other families.
+ }
+
+ realSocketProtocol := socketProtocol
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ fd := int(0)
+ if tt.proto != nil {
+ socketProtocol = func(fd int) (int, error) { return *tt.proto, nil }
+ } else {
+ socketProtocol = realSocketProtocol
+ }
+ sa, err := anyToSockaddr(fd, tt.rsa)
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ if !reflect.DeepEqual(sa, tt.sa) {
+ t.Fatalf("unexpected Sockaddr:\n got: %#v\nwant: %#v", sa, tt.sa)
+ }
+ })
+ }
+}
+
+func TestSockaddrTIPC_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrTIPC
+ raw *RawSockaddrTIPC
+ err error
+ }{
+ {
+ name: "no fields set",
+ sa: &SockaddrTIPC{},
+ err: EINVAL,
+ },
+ {
+ name: "ID",
+ sa: &SockaddrTIPC{
+ Scope: 1,
+ Addr: &TIPCSocketAddr{
+ Ref: 1,
+ Node: 2,
+ },
+ },
+ raw: &RawSockaddrTIPC{
+ Family: AF_TIPC,
+ Addrtype: TIPC_SOCKET_ADDR,
+ Scope: 1,
+ Addr: (&TIPCSocketAddr{
+ Ref: 1,
+ Node: 2,
+ }).tipcAddr(),
+ },
+ },
+ {
+ name: "NameSeq",
+ sa: &SockaddrTIPC{
+ Scope: 2,
+ Addr: &TIPCServiceRange{
+ Type: 1,
+ Lower: 2,
+ Upper: 3,
+ },
+ },
+ raw: &RawSockaddrTIPC{
+ Family: AF_TIPC,
+ Addrtype: TIPC_SERVICE_RANGE,
+ Scope: 2,
+ Addr: (&TIPCServiceRange{
+ Type: 1,
+ Lower: 2,
+ Upper: 3,
+ }).tipcAddr(),
+ },
+ },
+ {
+ name: "Name",
+ sa: &SockaddrTIPC{
+ Scope: 3,
+ Addr: &TIPCServiceName{
+ Type: 1,
+ Instance: 2,
+ Domain: 3,
+ },
+ },
+ raw: &RawSockaddrTIPC{
+ Family: AF_TIPC,
+ Addrtype: TIPC_SERVICE_ADDR,
+ Scope: 3,
+ Addr: (&TIPCServiceName{
+ Type: 1,
+ Instance: 2,
+ Domain: 3,
+ }).tipcAddr(),
+ },
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrTIPC) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+ if out == nil {
+ // No pointer to cast, return early.
+ return
+ }
+
+ raw := (*RawSockaddrTIPC)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrTIPC:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ })
+ }
+}
+
+func TestSockaddrL2TPIP_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrL2TPIP
+ raw *RawSockaddrL2TPIP
+ err error
+ }{
+ {
+ name: "L2TPIP",
+ sa: &SockaddrL2TPIP{
+ Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
+ ConnId: 0x1234abcd,
+ },
+ raw: &RawSockaddrL2TPIP{
+ Family: AF_INET,
+ Addr: [4]byte{0xef, 0x10, 0x5b, 0xa2},
+ Conn_id: 0x1234abcd,
+ },
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrL2TPIP) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+
+ if out != nil {
+ raw := (*RawSockaddrL2TPIP)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrL2TPIP:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ }
+ })
+ }
+}
+
+func TestSockaddrL2TPIP6_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrL2TPIP6
+ raw *RawSockaddrL2TPIP6
+ err error
+ }{
+ {
+ name: "L2TPIP6",
+ sa: &SockaddrL2TPIP6{
+ Addr: [16]byte{
+ 0x20, 0x01, 0x0d, 0xb8,
+ 0x85, 0xa3, 0x00, 0x00,
+ 0x00, 0x00, 0x8a, 0x2e,
+ 0x03, 0x70, 0x73, 0x34,
+ },
+ ZoneId: 90210,
+ ConnId: 0x1234abcd,
+ },
+ raw: &RawSockaddrL2TPIP6{
+ Family: AF_INET6,
+ Addr: [16]byte{
+ 0x20, 0x01, 0x0d, 0xb8,
+ 0x85, 0xa3, 0x00, 0x00,
+ 0x00, 0x00, 0x8a, 0x2e,
+ 0x03, 0x70, 0x73, 0x34,
+ },
+ Scope_id: 90210,
+ Conn_id: 0x1234abcd,
+ },
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrL2TPIP6) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+
+ if out != nil {
+ raw := (*RawSockaddrL2TPIP6)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrL2TPIP6:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ }
+ })
+ }
+}
+
+func TestSockaddrUnix_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrUnix
+ raw *RawSockaddrUnix
+ slen _Socklen
+ err error
+ }{
+ {
+ name: "unnamed",
+ sa: &SockaddrUnix{},
+ raw: &RawSockaddrUnix{
+ Family: AF_UNIX,
+ },
+ slen: 2, // family (uint16)
+ },
+ {
+ name: "abstract",
+ sa: &SockaddrUnix{
+ Name: "@",
+ },
+ raw: &RawSockaddrUnix{
+ Family: AF_UNIX,
+ },
+ slen: 3, // family (uint16) + NULL
+ },
+ {
+ name: "named",
+ sa: &SockaddrUnix{
+ Name: "gopher",
+ },
+ raw: &RawSockaddrUnix{
+ Family: AF_UNIX,
+ Path: [108]int8{'g', 'o', 'p', 'h', 'e', 'r'},
+ },
+ slen: _Socklen(3 + len("gopher")), // family (uint16) + len(gopher)
+ },
+ {
+ name: "named too long",
+ sa: &SockaddrUnix{
+ Name: strings.Repeat("A", 108),
+ },
+ err: EINVAL,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ if l != tt.slen {
+ t.Fatalf("unexpected Socklen: %d, want %d", l, tt.slen)
+ }
+ if out == nil {
+ // No pointer to cast, return early.
+ return
+ }
+
+ raw := (*RawSockaddrUnix)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrUnix:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ })
+ }
+}
+
+func TestSockaddrIUCV_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrIUCV
+ raw *RawSockaddrIUCV
+ err error
+ }{
+ {
+ name: "no fields set",
+ sa: &SockaddrIUCV{},
+ raw: &RawSockaddrIUCV{
+ Family: AF_IUCV,
+ Nodeid: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
+ User_id: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
+ Name: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
+ },
+ },
+ {
+ name: "both fields set",
+ sa: &SockaddrIUCV{
+ UserID: "USERID",
+ Name: "NAME",
+ },
+ raw: &RawSockaddrIUCV{
+ Family: AF_IUCV,
+ Nodeid: [8]int8{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '},
+ User_id: [8]int8{'U', 'S', 'E', 'R', 'I', 'D', ' ', ' '},
+ Name: [8]int8{'N', 'A', 'M', 'E', ' ', ' ', ' ', ' '},
+ },
+ },
+ {
+ name: "too long userid",
+ sa: &SockaddrIUCV{
+ UserID: "123456789",
+ },
+ err: EINVAL,
+ },
+ {
+ name: "too long name",
+ sa: &SockaddrIUCV{
+ Name: "123456789",
+ },
+ err: EINVAL,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrIUCV) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+ if out == nil {
+ // No pointer to cast, return early.
+ return
+ }
+
+ raw := (*RawSockaddrIUCV)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrIUCV:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ })
+ }
+}
+
+func TestSockaddrCAN_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrCAN
+ raw *RawSockaddrCAN
+ err error
+ }{
+ {
+ name: "with ids",
+ sa: &SockaddrCAN{
+ Ifindex: 12345678,
+ RxID: 0xAAAAAAAA,
+ TxID: 0xBBBBBBBB,
+ },
+ raw: &RawSockaddrCAN{
+ Family: AF_CAN,
+ Ifindex: 12345678,
+ Addr: [16]byte{
+ 0xAA, 0xAA, 0xAA, 0xAA,
+ 0xBB, 0xBB, 0xBB, 0xBB,
+ 0x0, 0x0, 0x0, 0x0,
+ 0x0, 0x0, 0x0, 0x0,
+ },
+ },
+ },
+ {
+ name: "negative ifindex",
+ sa: &SockaddrCAN{
+ Ifindex: -1,
+ },
+ err: EINVAL,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrCAN) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+
+ if out != nil {
+ raw := (*RawSockaddrCAN)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrCAN:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ }
+ })
+ }
+}
+
+func TestSockaddrNFC_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrNFC
+ raw *RawSockaddrNFC
+ err error
+ }{
+ {
+ name: "NFC RAW",
+ sa: &SockaddrNFC{
+ DeviceIdx: 12345678,
+ TargetIdx: 87654321,
+ NFCProtocol: 0xBBBBBBBB,
+ },
+ raw: &RawSockaddrNFC{
+ Sa_family: AF_NFC,
+ Dev_idx: 12345678,
+ Target_idx: 87654321,
+ Nfc_protocol: 0xBBBBBBBB,
+ },
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrNFC) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+
+ if out != nil {
+ raw := (*RawSockaddrNFC)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrNFC:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ }
+ })
+ }
+}
+
+func TestSockaddrNFCLLCP_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrNFCLLCP
+ raw *RawSockaddrNFCLLCP
+ err error
+ }{
+ {
+ name: "valid",
+ sa: &SockaddrNFCLLCP{
+ DeviceIdx: 12345678,
+ TargetIdx: 87654321,
+ NFCProtocol: 0xBBBBBBBB,
+ DestinationSAP: 55,
+ SourceSAP: 56,
+ ServiceName: "test service",
+ },
+ raw: &RawSockaddrNFCLLCP{
+ Sa_family: AF_NFC,
+ Dev_idx: 12345678,
+ Target_idx: 87654321,
+ Nfc_protocol: 0xBBBBBBBB,
+ Dsap: 55,
+ Ssap: 56,
+ Service_name: [63]uint8{'t', 'e', 's', 't', ' ', 's', 'e', 'r', 'v', 'i', 'c', 'e'},
+ Service_name_len: 12,
+ },
+ },
+ {
+ name: "too long service name",
+ sa: &SockaddrNFCLLCP{
+ DeviceIdx: 12345678,
+ TargetIdx: 87654321,
+ NFCProtocol: 0xBBBBBBBB,
+ DestinationSAP: 55,
+ SourceSAP: 56,
+ ServiceName: "too long too long too long too long too long too long too long too long too long",
+ },
+ err: EINVAL,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrNFCLLCP) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+
+ if out != nil {
+ raw := (*RawSockaddrNFCLLCP)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrNFCLLCP:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ }
+ })
+ }
+}
+
+func TestSockaddrVM_sockaddr(t *testing.T) {
+ tests := []struct {
+ name string
+ sa *SockaddrVM
+ raw *RawSockaddrVM
+ err error
+ }{
+ {
+ name: "empty",
+ sa: &SockaddrVM{},
+ raw: &RawSockaddrVM{
+ Family: AF_VSOCK,
+ },
+ },
+ {
+ name: "with CID, port and flags",
+ sa: &SockaddrVM{
+ CID: VMADDR_CID_HOST,
+ Port: VMADDR_PORT_ANY,
+ Flags: VMADDR_FLAG_TO_HOST,
+ },
+ raw: &RawSockaddrVM{
+ Family: AF_VSOCK,
+ Port: VMADDR_PORT_ANY,
+ Cid: VMADDR_CID_HOST,
+ Flags: VMADDR_FLAG_TO_HOST,
+ },
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ out, l, err := tt.sa.sockaddr()
+ if err != tt.err {
+ t.Fatalf("unexpected error: %v, want: %v", err, tt.err)
+ }
+
+ // Must be 0 on error or a fixed size otherwise.
+ if (tt.err != nil && l != 0) || (tt.raw != nil && l != SizeofSockaddrVM) {
+ t.Fatalf("unexpected Socklen: %d", l)
+ }
+
+ if out != nil {
+ raw := (*RawSockaddrVM)(out)
+ if !reflect.DeepEqual(raw, tt.raw) {
+ t.Fatalf("unexpected RawSockaddrVM:\n got: %#v\nwant: %#v", raw, tt.raw)
+ }
+ }
+ })
+ }
+}
+
+// These helpers explicitly copy the contents of in into out to produce
+// the correct sockaddr structure, without relying on unsafe casting to
+// a type of a larger size.
+func sockaddrTIPCToAny(in RawSockaddrTIPC) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrTIPC]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrL2TPIPToAny(in RawSockaddrL2TPIP) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrL2TPIP]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrL2TPIP6ToAny(in RawSockaddrL2TPIP6) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrL2TPIP6]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrUnixToAny(in RawSockaddrUnix) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrUnix]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrIUCVToAny(in RawSockaddrIUCV) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrUnix]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrCANToAny(in RawSockaddrCAN) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrCAN]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrNFCToAny(in RawSockaddrNFC) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrNFC]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrNFCLLCPToAny(in RawSockaddrNFCLLCP) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrNFCLLCP]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
+
+func sockaddrVMToAny(in RawSockaddrVM) *RawSockaddrAny {
+ var out RawSockaddrAny
+ copy(
+ (*(*[SizeofSockaddrAny]byte)(unsafe.Pointer(&out)))[:],
+ (*(*[SizeofSockaddrVM]byte)(unsafe.Pointer(&in)))[:],
+ )
+ return &out
+}
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-13 17:33:57 +0000