Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified
📁 ..	-	2025-05-25 12:27
📄 cmsghdr.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package socket func (h cmsghdr) len() int { return int(h.Len) } func (h cmsghdr) lvl() int { return int(h.Level) } func (h *cmsghdr) typ() int { return int(h.Type) }	427 B	2025-05-25 12:27
📄 cmsghdr_bsd.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| netbsd \|\| openbsd package socket func (h *cmsghdr) set(l, lvl, typ int) { h.Len = uint32(l) h.Level = int32(lvl) h.Type = int32(typ) }	352 B	2025-05-25 12:27
📄 cmsghdr_linux_32bit.go // Copyright 2017 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 (arm \|\| mips \|\| mipsle \|\| 386 \|\| ppc) && linux package socket func (h *cmsghdr) set(l, lvl, typ int) { h.Len = uint32(l) h.Level = int32(lvl) h.Type = int32(typ) }	340 B	2025-05-25 12:27
📄 cmsghdr_linux_64bit.go // Copyright 2017 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 (arm64 \|\| amd64 \|\| loong64 \|\| ppc64 \|\| ppc64le \|\| mips64 \|\| mips64le \|\| riscv64 \|\| s390x) && linux package socket func (h *cmsghdr) set(l, lvl, typ int) { h.Len = uint64(l) h.Level = int32(lvl) h.Type = int32(typ) }	392 B	2025-05-25 12:27
📄 cmsghdr_solaris_64bit.go // Copyright 2017 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 amd64 && solaris package socket func (h *cmsghdr) set(l, lvl, typ int) { h.Len = uint32(l) h.Level = int32(lvl) h.Type = int32(typ) }	310 B	2025-05-25 12:27
📄 cmsghdr_stub.go // Copyright 2017 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 !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !zos package socket func controlHeaderLen() int { return 0 } func controlMessageLen(dataLen int) int { return 0 } func controlMessageSpace(dataLen int) int { return 0 } type cmsghdr struct{} func (h cmsghdr) len() int { return 0 } func (h cmsghdr) lvl() int { return 0 } func (h cmsghdr) typ() int { return 0 } func (h cmsghdr) set(l, lvl, typ int) {}	627 B	2025-05-25 12:27
📄 cmsghdr_unix.go // Copyright 2020 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package socket import "golang.org/x/sys/unix" func controlHeaderLen() int { return unix.CmsgLen(0) } func controlMessageLen(dataLen int) int { return unix.CmsgLen(dataLen) } func controlMessageSpace(dataLen int) int { return unix.CmsgSpace(dataLen) }	516 B	2025-05-25 12:27
📄 cmsghdr_zos_s390x.go // Copyright 2020 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 socket func (h *cmsghdr) set(l, lvl, typ int) { h.Len = int32(l) h.Level = int32(lvl) h.Type = int32(typ) }	280 B	2025-05-25 12:27
📄 complete_dontwait.go // Copyright 2021 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 darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris package socket import ( "syscall" ) // ioComplete checks the flags and result of a syscall, to be used as return // value in a syscall.RawConn.Read or Write callback. func ioComplete(flags int, operr error) bool { if flags&syscall.MSG_DONTWAIT != 0 { // Caller explicitly said don't wait, so always return immediately. return true } if operr == syscall.EAGAIN \|\| operr == syscall.EWOULDBLOCK { // No data available, block for I/O and try again. return false } return true }	734 B	2025-05-25 12:27
📄 complete_nodontwait.go // Copyright 2021 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 aix \|\| windows \|\| zos package socket import ( "syscall" ) // ioComplete checks the flags and result of a syscall, to be used as return // value in a syscall.RawConn.Read or Write callback. func ioComplete(flags int, operr error) bool { if operr == syscall.EAGAIN \|\| operr == syscall.EWOULDBLOCK { // No data available, block for I/O and try again. return false } return true }	559 B	2025-05-25 12:27
📄 defs_aix.go // 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 ignore package socket /* #include <sys/socket.h> #include <netinet/in.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type mmsghdr C.struct_mmsghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	467 B	2025-05-25 12:27
📄 defs_darwin.go // Copyright 2017 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 ignore package socket /* #include <sys/socket.h> #include <netinet/in.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	436 B	2025-05-25 12:27
📄 defs_dragonfly.go // Copyright 2017 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 ignore package socket /* #include <sys/socket.h> #include <netinet/in.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	436 B	2025-05-25 12:27
📄 defs_freebsd.go // Copyright 2017 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 ignore package socket /* #include <sys/socket.h> #include <netinet/in.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	436 B	2025-05-25 12:27
📄 defs_linux.go // Copyright 2017 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 ignore package socket /* #include <linux/in.h> #include <linux/in6.h> #define _GNU_SOURCE #include <sys/socket.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type mmsghdr C.struct_mmsghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	508 B	2025-05-25 12:27
📄 defs_netbsd.go // Copyright 2017 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 ignore package socket /* #include <sys/socket.h> #include <netinet/in.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type mmsghdr C.struct_mmsghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	467 B	2025-05-25 12:27
📄 defs_openbsd.go // Copyright 2017 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 ignore package socket /* #include <sys/socket.h> #include <netinet/in.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	436 B	2025-05-25 12:27
📄 defs_solaris.go // Copyright 2017 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 ignore package socket /* #include <sys/socket.h> #include <netinet/in.h> */ import "C" type iovec C.struct_iovec type msghdr C.struct_msghdr type cmsghdr C.struct_cmsghdr const ( sizeofIovec = C.sizeof_struct_iovec sizeofMsghdr = C.sizeof_struct_msghdr )	436 B	2025-05-25 12:27
📄 empty.s // Copyright 2018 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 darwin && go1.12 // This exists solely so we can linkname in symbols from syscall.	255 B	2025-05-25 12:27
📄 error_unix.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package socket import "syscall" var ( errEAGAIN error = syscall.EAGAIN errEINVAL error = syscall.EINVAL errENOENT error = syscall.ENOENT ) // errnoErr returns common boxed Errno values, to prevent allocations // at runtime. func errnoErr(errno syscall.Errno) error { switch errno { case 0: return nil case syscall.EAGAIN: return errEAGAIN case syscall.EINVAL: return errEINVAL case syscall.ENOENT: return errENOENT } return errno }	711 B	2025-05-25 12:27
📄 error_windows.go // Copyright 2017 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 socket import "syscall" var ( errERROR_IO_PENDING error = syscall.ERROR_IO_PENDING errEINVAL error = syscall.EINVAL ) // errnoErr returns common boxed Errno values, to prevent allocations // at runtime. func errnoErr(errno syscall.Errno) error { switch errno { case 0: return nil case syscall.ERROR_IO_PENDING: return errERROR_IO_PENDING case syscall.EINVAL: return errEINVAL } return errno }	588 B	2025-05-25 12:27
📄 iovec_32bit.go // Copyright 2017 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 (arm \|\| mips \|\| mipsle \|\| 386 \|\| ppc) && (darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd) package socket import "unsafe" func (v iovec) set(b []byte) { l := len(b) if l == 0 { return } v.Base = (byte)(unsafe.Pointer(&b[0])) v.Len = uint32(l) }	441 B	2025-05-25 12:27
📄 iovec_64bit.go // Copyright 2017 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 (arm64 \|\| amd64 \|\| loong64 \|\| ppc64 \|\| ppc64le \|\| mips64 \|\| mips64le \|\| riscv64 \|\| s390x) && (aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| zos) package socket import "unsafe" func (v iovec) set(b []byte) { l := len(b) if l == 0 { return } v.Base = (byte)(unsafe.Pointer(&b[0])) v.Len = uint64(l) }	507 B	2025-05-25 12:27
📄 iovec_solaris_64bit.go // Copyright 2017 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 amd64 && solaris package socket import "unsafe" func (v iovec) set(b []byte) { l := len(b) if l == 0 { return } v.Base = (int8)(unsafe.Pointer(&b[0])) v.Len = uint64(l) }	354 B	2025-05-25 12:27
📄 iovec_stub.go // Copyright 2017 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 !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !zos package socket type iovec struct{} func (v *iovec) set(b []byte) {}	337 B	2025-05-25 12:27
📄 mmsghdr_stub.go // Copyright 2017 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 !aix && !linux && !netbsd package socket import "net" type mmsghdr struct{} type mmsghdrs []mmsghdr func (hs mmsghdrs) pack(ms []Message, parseFn func([]byte, string) (net.Addr, error), marshalFn func(net.Addr) []byte) error { return nil } func (hs mmsghdrs) unpack(ms []Message, parseFn func([]byte, string) (net.Addr, error), hint string) error { return nil }	541 B	2025-05-25 12:27
📄 mmsghdr_unix.go // Copyright 2017 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 aix \|\| linux \|\| netbsd package socket import ( "net" "os" "sync" "syscall" ) type mmsghdrs []mmsghdr func (hs mmsghdrs) unpack(ms []Message, parseFn func([]byte, string) (net.Addr, error), hint string) error { for i := range hs { ms[i].N = int(hs[i].Len) ms[i].NN = hs[i].Hdr.controllen() ms[i].Flags = hs[i].Hdr.flags() if parseFn != nil { var err error ms[i].Addr, err = parseFn(hs[i].Hdr.name(), hint) if err != nil { return err } } } return nil } // mmsghdrsPacker packs Message-slices into mmsghdrs (re-)using pre-allocated buffers. type mmsghdrsPacker struct { // hs are the pre-allocated mmsghdrs. hs mmsghdrs // sockaddrs is the pre-allocated buffer for the Hdr.Name buffers. // We use one large buffer for all messages and slice it up. sockaddrs []byte // vs are the pre-allocated iovecs. // We allocate one large buffer for all messages and slice it up. This allows to reuse the buffer // if the number of buffers per message is distributed differently between calls. vs []iovec } func (p mmsghdrsPacker) prepare(ms []Message) { n := len(ms) if n <= cap(p.hs) { p.hs = p.hs[:n] } else { p.hs = make(mmsghdrs, n) } if nsizeofSockaddrInet6 <= cap(p.sockaddrs) { p.sockaddrs = p.sockaddrs[:nsizeofSockaddrInet6] } else { p.sockaddrs = make([]byte, nsizeofSockaddrInet6) } nb := 0 for _, m := range ms { nb += len(m.Buffers) } if nb <= cap(p.vs) { p.vs = p.vs[:nb] } else { p.vs = make([]iovec, nb) } } func (p mmsghdrsPacker) pack(ms []Message, parseFn func([]byte, string) (net.Addr, error), marshalFn func(net.Addr, []byte) int) mmsghdrs { p.prepare(ms) hs := p.hs vsRest := p.vs saRest := p.sockaddrs for i := range hs { nvs := len(ms[i].Buffers) vs := vsRest[:nvs] vsRest = vsRest[nvs:] var sa []byte if parseFn != nil { sa = saRest[:sizeofSockaddrInet6] saRest = saRest[sizeofSockaddrInet6:] } else if marshalFn != nil { n := marshalFn(ms[i].Addr, saRest) if n > 0 { sa = saRest[:n] saRest = saRest[n:] } } hs[i].Hdr.pack(vs, ms[i].Buffers, ms[i].OOB, sa) } return hs } // syscaller is a helper to invoke recvmmsg and sendmmsg via the RawConn.Read/Write interface. // It is reusable, to amortize the overhead of allocating a closure for the function passed to // RawConn.Read/Write. type syscaller struct { n int operr error hs mmsghdrs flags int boundRecvmmsgF func(uintptr) bool boundSendmmsgF func(uintptr) bool } func (r syscaller) init() { r.boundRecvmmsgF = r.recvmmsgF r.boundSendmmsgF = r.sendmmsgF } func (r syscaller) recvmmsg(c syscall.RawConn, hs mmsghdrs, flags int) (int, error) { r.n = 0 r.operr = nil r.hs = hs r.flags = flags if err := c.Read(r.boundRecvmmsgF); err != nil { return r.n, err } if r.operr != nil { return r.n, os.NewSyscallError("recvmmsg", r.operr) } return r.n, nil } func (r syscaller) recvmmsgF(s uintptr) bool { r.n, r.operr = recvmmsg(s, r.hs, r.flags) return ioComplete(r.flags, r.operr) } func (r syscaller) sendmmsg(c syscall.RawConn, hs mmsghdrs, flags int) (int, error) { r.n = 0 r.operr = nil r.hs = hs r.flags = flags if err := c.Write(r.boundSendmmsgF); err != nil { return r.n, err } if r.operr != nil { return r.n, os.NewSyscallError("sendmmsg", r.operr) } return r.n, nil } func (r syscaller) sendmmsgF(s uintptr) bool { r.n, r.operr = sendmmsg(s, r.hs, r.flags) return ioComplete(r.flags, r.operr) } // mmsgTmps holds reusable temporary helpers for recvmmsg and sendmmsg. type mmsgTmps struct { packer mmsghdrsPacker syscaller syscaller } var defaultMmsgTmpsPool = mmsgTmpsPool{ p: sync.Pool{ New: func() interface{} { tmps := new(mmsgTmps) tmps.syscaller.init() return tmps }, }, } type mmsgTmpsPool struct { p sync.Pool } func (p mmsgTmpsPool) Get() mmsgTmps { m := p.p.Get().(mmsgTmps) // Clear fields up to the len (not the cap) of the slice, // assuming that the previous caller only used that many elements. for i := range m.packer.sockaddrs { m.packer.sockaddrs[i] = 0 } m.packer.sockaddrs = m.packer.sockaddrs[:0] for i := range m.packer.vs { m.packer.vs[i] = iovec{} } m.packer.vs = m.packer.vs[:0] for i := range m.packer.hs { m.packer.hs[i].Len = 0 m.packer.hs[i].Hdr = msghdr{} } m.packer.hs = m.packer.hs[:0] return m } func (p mmsgTmpsPool) Put(tmps *mmsgTmps) { p.p.Put(tmps) }	4.46 KB	2025-05-25 12:27
📄 msghdr_bsd.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| netbsd \|\| openbsd package socket import "unsafe" func (h msghdr) pack(vs []iovec, bs [][]byte, oob []byte, sa []byte) { for i := range vs { vs[i].set(bs[i]) } h.setIov(vs) if len(oob) > 0 { h.Control = (byte)(unsafe.Pointer(&oob[0])) h.Controllen = uint32(len(oob)) } if sa != nil { h.Name = (byte)(unsafe.Pointer(&sa[0])) h.Namelen = uint32(len(sa)) } } func (h msghdr) name() []byte { if h.Name != nil && h.Namelen > 0 { return ([sizeofSockaddrInet6]byte)(unsafe.Pointer(h.Name))[:h.Namelen] } return nil } func (h msghdr) controllen() int { return int(h.Controllen) } func (h *msghdr) flags() int { return int(h.Flags) }	872 B	2025-05-25 12:27
📄 msghdr_bsdvar.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| netbsd package socket func (h *msghdr) setIov(vs []iovec) { l := len(vs) if l == 0 { return } h.Iov = &vs[0] h.Iovlen = int32(l) }	352 B	2025-05-25 12:27
📄 msghdr_linux.go // Copyright 2017 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 socket import "unsafe" func (h msghdr) pack(vs []iovec, bs [][]byte, oob []byte, sa []byte) { for i := range vs { vs[i].set(bs[i]) } h.setIov(vs) if len(oob) > 0 { h.setControl(oob) } if sa != nil { h.Name = (byte)(unsafe.Pointer(&sa[0])) h.Namelen = uint32(len(sa)) } } func (h msghdr) name() []byte { if h.Name != nil && h.Namelen > 0 { return ([sizeofSockaddrInet6]byte)(unsafe.Pointer(h.Name))[:h.Namelen] } return nil } func (h msghdr) controllen() int { return int(h.Controllen) } func (h msghdr) flags() int { return int(h.Flags) }	740 B	2025-05-25 12:27
📄 msghdr_linux_32bit.go // Copyright 2017 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 (arm \|\| mips \|\| mipsle \|\| 386 \|\| ppc) && linux package socket import "unsafe" func (h msghdr) setIov(vs []iovec) { l := len(vs) if l == 0 { return } h.Iov = &vs[0] h.Iovlen = uint32(l) } func (h msghdr) setControl(b []byte) { h.Control = (*byte)(unsafe.Pointer(&b[0])) h.Controllen = uint32(len(b)) }	487 B	2025-05-25 12:27
📄 msghdr_linux_64bit.go // Copyright 2017 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 (arm64 \|\| amd64 \|\| loong64 \|\| ppc64 \|\| ppc64le \|\| mips64 \|\| mips64le \|\| riscv64 \|\| s390x) && linux package socket import "unsafe" func (h msghdr) setIov(vs []iovec) { l := len(vs) if l == 0 { return } h.Iov = &vs[0] h.Iovlen = uint64(l) } func (h msghdr) setControl(b []byte) { h.Control = (*byte)(unsafe.Pointer(&b[0])) h.Controllen = uint64(len(b)) }	539 B	2025-05-25 12:27
📄 msghdr_openbsd.go // Copyright 2017 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 socket func (h *msghdr) setIov(vs []iovec) { l := len(vs) if l == 0 { return } h.Iov = &vs[0] h.Iovlen = uint32(l) }	293 B	2025-05-25 12:27
📄 msghdr_solaris_64bit.go // Copyright 2017 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 amd64 && solaris package socket import "unsafe" func (h msghdr) pack(vs []iovec, bs [][]byte, oob []byte, sa []byte) { for i := range vs { vs[i].set(bs[i]) } if len(vs) > 0 { h.Iov = &vs[0] h.Iovlen = int32(len(vs)) } if len(oob) > 0 { h.Accrights = (int8)(unsafe.Pointer(&oob[0])) h.Accrightslen = int32(len(oob)) } if sa != nil { h.Name = (byte)(unsafe.Pointer(&sa[0])) h.Namelen = uint32(len(sa)) } } func (h msghdr) controllen() int { return int(h.Accrightslen) } func (h *msghdr) flags() int { return int(NativeEndian.Uint32(h.Pad_cgo_2[:])) }	753 B	2025-05-25 12:27
📄 msghdr_stub.go // Copyright 2017 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 !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !zos package socket type msghdr struct{} func (h msghdr) pack(vs []iovec, bs [][]byte, oob []byte, sa []byte) {} func (h msghdr) name() []byte { return nil } func (h msghdr) controllen() int { return 0 } func (h msghdr) flags() int { return 0 }	629 B	2025-05-25 12:27
📄 msghdr_zos_s390x.go // Copyright 2020 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 s390x && zos package socket import "unsafe" func (h msghdr) pack(vs []iovec, bs [][]byte, oob []byte, sa []byte) { for i := range vs { vs[i].set(bs[i]) } if len(vs) > 0 { h.Iov = &vs[0] h.Iovlen = int32(len(vs)) } if len(oob) > 0 { h.Control = (byte)(unsafe.Pointer(&oob[0])) h.Controllen = uint32(len(oob)) } if sa != nil { h.Name = (byte)(unsafe.Pointer(&sa[0])) h.Namelen = uint32(len(sa)) } } func (h msghdr) controllen() int { return int(h.Controllen) } func (h *msghdr) flags() int { return int(h.Flags) }	716 B	2025-05-25 12:27
📄 norace.go // 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 !race package socket func (m Message) raceRead() { } func (m Message) raceWrite() { }	261 B	2025-05-25 12:27
📄 race.go // 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 race package socket import ( "runtime" "unsafe" ) // This package reads and writes the Message buffers using a // direct system call, which the race detector can't see. // These functions tell the race detector what is going on during the syscall. func (m Message) raceRead() { for _, b := range m.Buffers { if len(b) > 0 { runtime.RaceReadRange(unsafe.Pointer(&b[0]), len(b)) } } if b := m.OOB; len(b) > 0 { runtime.RaceReadRange(unsafe.Pointer(&b[0]), len(b)) } } func (m Message) raceWrite() { for _, b := range m.Buffers { if len(b) > 0 { runtime.RaceWriteRange(unsafe.Pointer(&b[0]), len(b)) } } if b := m.OOB; len(b) > 0 { runtime.RaceWriteRange(unsafe.Pointer(&b[0]), len(b)) } }	892 B	2025-05-25 12:27
📄 rawconn.go // Copyright 2017 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 socket import ( "errors" "net" "os" "syscall" ) // A Conn represents a raw connection. type Conn struct { network string c syscall.RawConn } // tcpConn is an interface implemented by net.TCPConn. // It can be used for interface assertions to check if a net.Conn is a TCP connection. type tcpConn interface { SyscallConn() (syscall.RawConn, error) SetLinger(int) error } var _ tcpConn = (net.TCPConn)(nil) // udpConn is an interface implemented by net.UDPConn. // It can be used for interface assertions to check if a net.Conn is a UDP connection. type udpConn interface { SyscallConn() (syscall.RawConn, error) ReadMsgUDP(b, oob []byte) (n, oobn, flags int, addr net.UDPAddr, err error) } var _ udpConn = (net.UDPConn)(nil) // ipConn is an interface implemented by net.IPConn. // It can be used for interface assertions to check if a net.Conn is an IP connection. type ipConn interface { SyscallConn() (syscall.RawConn, error) ReadMsgIP(b, oob []byte) (n, oobn, flags int, addr net.IPAddr, err error) } var _ ipConn = (net.IPConn)(nil) // NewConn returns a new raw connection. func NewConn(c net.Conn) (Conn, error) { var err error var cc Conn switch c := c.(type) { case tcpConn: cc.network = "tcp" cc.c, err = c.SyscallConn() case udpConn: cc.network = "udp" cc.c, err = c.SyscallConn() case ipConn: cc.network = "ip" cc.c, err = c.SyscallConn() default: return nil, errors.New("unknown connection type") } if err != nil { return nil, err } return &cc, nil } func (o Option) get(c Conn, b []byte) (int, error) { var operr error var n int fn := func(s uintptr) { n, operr = getsockopt(s, o.Level, o.Name, b) } if err := c.c.Control(fn); err != nil { return 0, err } return n, os.NewSyscallError("getsockopt", operr) } func (o Option) set(c Conn, b []byte) error { var operr error fn := func(s uintptr) { operr = setsockopt(s, o.Level, o.Name, b) } if err := c.c.Control(fn); err != nil { return err } return os.NewSyscallError("setsockopt", operr) }	2.15 KB	2025-05-25 12:27
📄 rawconn_mmsg.go // Copyright 2017 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 package socket import ( "net" ) func (c Conn) recvMsgs(ms []Message, flags int) (int, error) { for i := range ms { ms[i].raceWrite() } tmps := defaultMmsgTmpsPool.Get() defer defaultMmsgTmpsPool.Put(tmps) var parseFn func([]byte, string) (net.Addr, error) if c.network != "tcp" { parseFn = parseInetAddr } hs := tmps.packer.pack(ms, parseFn, nil) n, err := tmps.syscaller.recvmmsg(c.c, hs, flags) if err != nil { return n, err } if err := hs[:n].unpack(ms[:n], parseFn, c.network); err != nil { return n, err } return n, nil } func (c Conn) sendMsgs(ms []Message, flags int) (int, error) { for i := range ms { ms[i].raceRead() } tmps := defaultMmsgTmpsPool.Get() defer defaultMmsgTmpsPool.Put(tmps) var marshalFn func(net.Addr, []byte) int if c.network != "tcp" { marshalFn = marshalInetAddr } hs := tmps.packer.pack(ms, nil, marshalFn) n, err := tmps.syscaller.sendmmsg(c.c, hs, flags) if err != nil { return n, err } if err := hs[:n].unpack(ms[:n], nil, ""); err != nil { return n, err } return n, nil }	1.21 KB	2025-05-25 12:27
📄 rawconn_msg.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| windows \|\| zos package socket import ( "net" "os" ) func (c Conn) recvMsg(m Message, flags int) error { m.raceWrite() var ( operr error n int oobn int recvflags int from net.Addr ) fn := func(s uintptr) bool { n, oobn, recvflags, from, operr = recvmsg(s, m.Buffers, m.OOB, flags, c.network) return ioComplete(flags, operr) } if err := c.c.Read(fn); err != nil { return err } if operr != nil { return os.NewSyscallError("recvmsg", operr) } m.Addr = from m.N = n m.NN = oobn m.Flags = recvflags return nil } func (c Conn) sendMsg(m Message, flags int) error { m.raceRead() var ( operr error n int ) fn := func(s uintptr) bool { n, operr = sendmsg(s, m.Buffers, m.OOB, m.Addr, flags) return ioComplete(flags, operr) } if err := c.c.Write(fn); err != nil { return err } if operr != nil { return os.NewSyscallError("sendmsg", operr) } m.N = n m.NN = len(m.OOB) return nil }	1.19 KB	2025-05-25 12:27
📄 rawconn_nommsg.go // Copyright 2017 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 package socket func (c Conn) recvMsgs(ms []Message, flags int) (int, error) { return 0, errNotImplemented } func (c Conn) sendMsgs(ms []Message, flags int) (int, error) { return 0, errNotImplemented }	386 B	2025-05-25 12:27
📄 rawconn_nomsg.go // Copyright 2017 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 !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos package socket func (c Conn) recvMsg(m Message, flags int) error { return errNotImplemented } func (c Conn) sendMsg(m Message, flags int) error { return errNotImplemented }	460 B	2025-05-25 12:27
📄 socket.go // Copyright 2017 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 socket provides a portable interface for socket system // calls. package socket // import "golang.org/x/net/internal/socket" import ( "errors" "net" "runtime" "unsafe" ) var errNotImplemented = errors.New("not implemented on " + runtime.GOOS + "/" + runtime.GOARCH) // An Option represents a sticky socket option. type Option struct { Level int // level Name int // name; must be equal or greater than 1 Len int // length of value in bytes; must be equal or greater than 1 } // Get reads a value for the option from the kernel. // It returns the number of bytes written into b. func (o Option) Get(c Conn, b []byte) (int, error) { if o.Name < 1 \|\| o.Len < 1 { return 0, errors.New("invalid option") } if len(b) < o.Len { return 0, errors.New("short buffer") } return o.get(c, b) } // GetInt returns an integer value for the option. // // The Len field of Option must be either 1 or 4. func (o Option) GetInt(c Conn) (int, error) { if o.Len != 1 && o.Len != 4 { return 0, errors.New("invalid option") } var b []byte var bb [4]byte if o.Len == 1 { b = bb[:1] } else { b = bb[:4] } n, err := o.get(c, b) if err != nil { return 0, err } if n != o.Len { return 0, errors.New("invalid option length") } if o.Len == 1 { return int(b[0]), nil } return int(NativeEndian.Uint32(b[:4])), nil } // Set writes the option and value to the kernel. func (o Option) Set(c Conn, b []byte) error { if o.Name < 1 \|\| o.Len < 1 { return errors.New("invalid option") } if len(b) < o.Len { return errors.New("short buffer") } return o.set(c, b) } // SetInt writes the option and value to the kernel. // // The Len field of Option must be either 1 or 4. func (o Option) SetInt(c Conn, v int) error { if o.Len != 1 && o.Len != 4 { return errors.New("invalid option") } var b []byte if o.Len == 1 { b = []byte{byte(v)} } else { var bb [4]byte NativeEndian.PutUint32(bb[:o.Len], uint32(v)) b = bb[:4] } return o.set(c, b) } // ControlMessageSpace returns the whole length of control message. func ControlMessageSpace(dataLen int) int { return controlMessageSpace(dataLen) } // A ControlMessage represents the head message in a stream of control // messages. // // A control message comprises of a header, data and a few padding // fields to conform to the interface to the kernel. // // See RFC 3542 for further information. type ControlMessage []byte // Data returns the data field of the control message at the head on // m. func (m ControlMessage) Data(dataLen int) []byte { l := controlHeaderLen() if len(m) < l \|\| len(m) < l+dataLen { return nil } return m[l : l+dataLen] } // Next returns the control message at the next on m. // // Next works only for standard control messages. func (m ControlMessage) Next(dataLen int) ControlMessage { l := ControlMessageSpace(dataLen) if len(m) < l { return nil } return m[l:] } // MarshalHeader marshals the header fields of the control message at // the head on m. func (m ControlMessage) MarshalHeader(lvl, typ, dataLen int) error { if len(m) < controlHeaderLen() { return errors.New("short message") } h := (cmsghdr)(unsafe.Pointer(&m[0])) h.set(controlMessageLen(dataLen), lvl, typ) return nil } // ParseHeader parses and returns the header fields of the control // message at the head on m. func (m ControlMessage) ParseHeader() (lvl, typ, dataLen int, err error) { l := controlHeaderLen() if len(m) < l { return 0, 0, 0, errors.New("short message") } h := (cmsghdr)(unsafe.Pointer(&m[0])) return h.lvl(), h.typ(), int(uint64(h.len()) - uint64(l)), nil } // Marshal marshals the control message at the head on m, and returns // the next control message. func (m ControlMessage) Marshal(lvl, typ int, data []byte) (ControlMessage, error) { l := len(data) if len(m) < ControlMessageSpace(l) { return nil, errors.New("short message") } h := (cmsghdr)(unsafe.Pointer(&m[0])) h.set(controlMessageLen(l), lvl, typ) if l > 0 { copy(m.Data(l), data) } return m.Next(l), nil } // Parse parses m as a single or multiple control messages. // // Parse works for both standard and compatible messages. func (m ControlMessage) Parse() ([]ControlMessage, error) { var ms []ControlMessage for len(m) >= controlHeaderLen() { h := (cmsghdr)(unsafe.Pointer(&m[0])) l := h.len() if l <= 0 { return nil, errors.New("invalid header length") } if uint64(l) < uint64(controlHeaderLen()) { return nil, errors.New("invalid message length") } if uint64(l) > uint64(len(m)) { return nil, errors.New("short buffer") } // On message reception: // // \|<- ControlMessageSpace --------------->\| // \|<- controlMessageLen ---------->\| \| // \|<- controlHeaderLen ->\| \| \| // +---------------+------+---------+------+ // \| Header \| PadH \| Data \| PadD \| // +---------------+------+---------+------+ // // On compatible message reception: // // \| ... \|<- controlMessageLen ----------->\| // \| ... \|<- controlHeaderLen ->\| \| // +-----+---------------+------+----------+ // \| ... \| Header \| PadH \| Data \| // +-----+---------------+------+----------+ ms = append(ms, ControlMessage(m[:l])) ll := l - controlHeaderLen() if len(m) >= ControlMessageSpace(ll) { m = m[ControlMessageSpace(ll):] } else { m = m[controlMessageLen(ll):] } } return ms, nil } // NewControlMessage returns a new stream of control messages. func NewControlMessage(dataLen []int) ControlMessage { var l int for i := range dataLen { l += ControlMessageSpace(dataLen[i]) } return make([]byte, l) } // A Message represents an IO message. type Message struct { // When writing, the Buffers field must contain at least one // byte to write. // When reading, the Buffers field will always contain a byte // to read. Buffers [][]byte // OOB contains protocol-specific control or miscellaneous // ancillary data known as out-of-band data. OOB []byte // Addr specifies a destination address when writing. // It can be nil when the underlying protocol of the raw // connection uses connection-oriented communication. // After a successful read, it may contain the source address // on the received packet. Addr net.Addr N int // # of bytes read or written from/to Buffers NN int // # of bytes read or written from/to OOB Flags int // protocol-specific information on the received message } // RecvMsg wraps recvmsg system call. // // The provided flags is a set of platform-dependent flags, such as // syscall.MSG_PEEK. func (c Conn) RecvMsg(m Message, flags int) error { return c.recvMsg(m, flags) } // SendMsg wraps sendmsg system call. // // The provided flags is a set of platform-dependent flags, such as // syscall.MSG_DONTROUTE. func (c Conn) SendMsg(m Message, flags int) error { return c.sendMsg(m, flags) } // RecvMsgs wraps recvmmsg system call. // // It returns the number of processed messages. // // The provided flags is a set of platform-dependent flags, such as // syscall.MSG_PEEK. // // Only Linux supports this. func (c Conn) RecvMsgs(ms []Message, flags int) (int, error) { return c.recvMsgs(ms, flags) } // SendMsgs wraps sendmmsg system call. // // It returns the number of processed messages. // // The provided flags is a set of platform-dependent flags, such as // syscall.MSG_DONTROUTE. // // Only Linux supports this. func (c Conn) SendMsgs(ms []Message, flags int) (int, error) { return c.sendMsgs(ms, flags) }	7.48 KB	2025-05-25 12:27
📄 socket_dontwait_test.go // Copyright 2021 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 darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris package socket_test import ( "bytes" "errors" "net" "runtime" "syscall" "testing" "golang.org/x/net/internal/socket" "golang.org/x/net/nettest" ) func TestUDPDontwait(t testing.T) { c, err := nettest.NewLocalPacketListener("udp") if err != nil { t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() cc, err := socket.NewConn(c.(net.UDPConn)) if err != nil { t.Fatal(err) } isErrWouldblock := func(err error) bool { var errno syscall.Errno return errors.As(err, &errno) && (errno == syscall.EAGAIN \|\| errno == syscall.EWOULDBLOCK) } t.Run("Message-dontwait", func(t testing.T) { // Read before something was sent; expect EWOULDBLOCK b := make([]byte, 32) rm := socket.Message{ Buffers: [][]byte{b}, } if err := cc.RecvMsg(&rm, syscall.MSG_DONTWAIT); !isErrWouldblock(err) { t.Fatal(err) } // To trigger EWOULDBLOCK by SendMsg, we have to send faster than what the // system/network is able to process. Whether or not we can trigger this // depends on the system, specifically on write buffer sizes and the speed // of the network interface. // We cannot expect to quickly and reliably trigger this, especially not // because this test sends data over a (fast) loopback. Consequently, we // only check that sending with MSG_DONTWAIT works at all and don't attempt // testing that we would eventually get EWOULDBLOCK here. data := []byte("HELLO-R-U-THERE") wm := socket.Message{ Buffers: [][]byte{data}, Addr: c.LocalAddr(), } // Send one message, repeat until we don't get EWOULDBLOCK. This will likely succeed at the first attempt. for { err := cc.SendMsg(&wm, syscall.MSG_DONTWAIT) if err == nil { break } else if !isErrWouldblock(err) { t.Fatal(err) } } // Read the message now available; again, this will likely succeed at the first attempt. for { err := cc.RecvMsg(&rm, syscall.MSG_DONTWAIT) if err == nil { break } else if !isErrWouldblock(err) { t.Fatal(err) } } if !bytes.Equal(b[:rm.N], data) { t.Fatalf("got %#v; want %#v", b[:rm.N], data) } }) switch runtime.GOOS { case "android", "linux": t.Run("Messages", func(t testing.T) { data := []byte("HELLO-R-U-THERE") wmbs := bytes.SplitAfter(data, []byte("-")) wms := []socket.Message{ {Buffers: wmbs[:1], Addr: c.LocalAddr()}, {Buffers: wmbs[1:], Addr: c.LocalAddr()}, } b := make([]byte, 32) rmbs := [][][]byte{{b[:len(wmbs[0])]}, {b[len(wmbs[0]):]}} rms := []socket.Message{ {Buffers: rmbs[0]}, {Buffers: rmbs[1]}, } _, err := cc.RecvMsgs(rms, syscall.MSG_DONTWAIT) if !isErrWouldblock(err) { t.Fatal(err) } for ntot := 0; ntot < len(wms); { n, err := cc.SendMsgs(wms[ntot:], syscall.MSG_DONTWAIT) if err == nil { ntot += n } else if !isErrWouldblock(err) { t.Fatal(err) } } for ntot := 0; ntot < len(rms); { n, err := cc.RecvMsgs(rms[ntot:], syscall.MSG_DONTWAIT) if err == nil { ntot += n } else if !isErrWouldblock(err) { t.Fatal(err) } } nn := 0 for i := 0; i < len(rms); i++ { nn += rms[i].N } if !bytes.Equal(b[:nn], data) { t.Fatalf("got %#v; want %#v", b[:nn], data) } }) } }	3.43 KB	2025-05-25 12:27
📄 socket_test.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| windows \|\| zos package socket_test import ( "bytes" "fmt" "net" "os" "os/exec" "path/filepath" "runtime" "strings" "syscall" "testing" "golang.org/x/net/internal/socket" "golang.org/x/net/nettest" ) func TestSocket(t testing.T) { t.Run("Option", func(t testing.T) { testSocketOption(t, &socket.Option{Level: syscall.SOL_SOCKET, Name: syscall.SO_RCVBUF, Len: 4}) }) } func testSocketOption(t testing.T, so socket.Option) { c, err := nettest.NewLocalPacketListener("udp") if err != nil { t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() cc, err := socket.NewConn(c.(net.Conn)) if err != nil { t.Fatal(err) } const N = 2048 if err := so.SetInt(cc, N); err != nil { t.Fatal(err) } n, err := so.GetInt(cc) if err != nil { t.Fatal(err) } if n < N { t.Fatalf("got %d; want greater than or equal to %d", n, N) } } type mockControl struct { Level int Type int Data []byte } func TestControlMessage(t testing.T) { switch runtime.GOOS { case "windows": t.Skipf("not supported on %s", runtime.GOOS) } for _, tt := range []struct { cs []mockControl }{ { []mockControl{ {Level: 1, Type: 1}, }, }, { []mockControl{ {Level: 2, Type: 2, Data: []byte{0xfe}}, }, }, { []mockControl{ {Level: 3, Type: 3, Data: []byte{0xfe, 0xff, 0xff, 0xfe}}, }, }, { []mockControl{ {Level: 4, Type: 4, Data: []byte{0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xfe}}, }, }, { []mockControl{ {Level: 4, Type: 4, Data: []byte{0xfe, 0xff, 0xff, 0xfe, 0xfe, 0xff, 0xff, 0xfe}}, {Level: 2, Type: 2, Data: []byte{0xfe}}, }, }, } { var w []byte var tailPadLen int mm := socket.NewControlMessage([]int{0}) for i, c := range tt.cs { m := socket.NewControlMessage([]int{len(c.Data)}) l := len(m) - len(mm) if i == len(tt.cs)-1 && l > len(c.Data) { tailPadLen = l - len(c.Data) } w = append(w, m...) } var err error ww := make([]byte, len(w)) copy(ww, w) m := socket.ControlMessage(ww) for _, c := range tt.cs { if err = m.MarshalHeader(c.Level, c.Type, len(c.Data)); err != nil { t.Fatalf("(%v).MarshalHeader() = %v", tt.cs, err) } copy(m.Data(len(c.Data)), c.Data) m = m.Next(len(c.Data)) } m = socket.ControlMessage(w) for _, c := range tt.cs { m, err = m.Marshal(c.Level, c.Type, c.Data) if err != nil { t.Fatalf("(%v).Marshal() = %v", tt.cs, err) } } if !bytes.Equal(ww, w) { t.Fatalf("got %#v; want %#v", ww, w) } ws := [][]byte{w} if tailPadLen > 0 { // Test a message with no tail padding. nopad := w[:len(w)-tailPadLen] ws = append(ws, [][]byte{nopad}...) } for _, w := range ws { ms, err := socket.ControlMessage(w).Parse() if err != nil { t.Fatalf("(%v).Parse() = %v", tt.cs, err) } for i, m := range ms { lvl, typ, dataLen, err := m.ParseHeader() if err != nil { t.Fatalf("(%v).ParseHeader() = %v", tt.cs, err) } if lvl != tt.cs[i].Level \|\| typ != tt.cs[i].Type \|\| dataLen != len(tt.cs[i].Data) { t.Fatalf("%v: got %d, %d, %d; want %d, %d, %d", tt.cs[i], lvl, typ, dataLen, tt.cs[i].Level, tt.cs[i].Type, len(tt.cs[i].Data)) } } } } } func TestUDP(t testing.T) { switch runtime.GOOS { case "windows": t.Skipf("not supported on %s", runtime.GOOS) } c, err := nettest.NewLocalPacketListener("udp") if err != nil { t.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() // test that wrapped connections work with NewConn too type wrappedConn struct{ net.UDPConn } cc, err := socket.NewConn(&wrappedConn{c.(net.UDPConn)}) if err != nil { t.Fatal(err) } // create a dialed connection talking (only) to c/cc cDialed, err := net.Dial("udp", c.LocalAddr().String()) if err != nil { t.Fatal(err) } ccDialed, err := socket.NewConn(cDialed) if err != nil { t.Fatal(err) } const data = "HELLO-R-U-THERE" messageTests := []struct { name string conn socket.Conn dest net.Addr }{ { name: "Message", conn: cc, dest: c.LocalAddr(), }, { name: "Message-dialed", conn: ccDialed, dest: nil, }, } for _, tt := range messageTests { t.Run(tt.name, func(t testing.T) { wm := socket.Message{ Buffers: bytes.SplitAfter([]byte(data), []byte("-")), Addr: tt.dest, } if err := tt.conn.SendMsg(&wm, 0); err != nil { t.Fatal(err) } b := make([]byte, 32) rm := socket.Message{ Buffers: [][]byte{b[:1], b[1:3], b[3:7], b[7:11], b[11:]}, } if err := cc.RecvMsg(&rm, 0); err != nil { t.Fatal(err) } received := string(b[:rm.N]) if received != data { t.Fatalf("Roundtrip SendMsg/RecvMsg got %q; want %q", received, data) } }) } switch runtime.GOOS { case "android", "linux": messagesTests := []struct { name string conn socket.Conn dest net.Addr }{ { name: "Messages", conn: cc, dest: c.LocalAddr(), }, { name: "Messages-dialed", conn: ccDialed, dest: nil, }, } for _, tt := range messagesTests { t.Run(tt.name, func(t testing.T) { wmbs := bytes.SplitAfter([]byte(data), []byte("-")) wms := []socket.Message{ {Buffers: wmbs[:1], Addr: tt.dest}, {Buffers: wmbs[1:], Addr: tt.dest}, } n, err := tt.conn.SendMsgs(wms, 0) if err != nil { t.Fatal(err) } if n != len(wms) { t.Fatalf("SendMsgs(%#v) != %d; want %d", wms, n, len(wms)) } rmbs := [][]byte{make([]byte, 32), make([]byte, 32)} rms := []socket.Message{ {Buffers: [][]byte{rmbs[0]}}, {Buffers: [][]byte{rmbs[1][:1], rmbs[1][1:3], rmbs[1][3:7], rmbs[1][7:11], rmbs[1][11:]}}, } nrecv := 0 for nrecv < len(rms) { n, err := cc.RecvMsgs(rms[nrecv:], 0) if err != nil { t.Fatal(err) } nrecv += n } received0, received1 := string(rmbs[0][:rms[0].N]), string(rmbs[1][:rms[1].N]) assembled := received0 + received1 assembledReordered := received1 + received0 if assembled != data && assembledReordered != data { t.Fatalf("Roundtrip SendMsgs/RecvMsgs got %q / %q; want %q", assembled, assembledReordered, data) } }) } t.Run("Messages-undialed-no-dst", func(t testing.T) { // sending without destination address should fail. // This checks that the internally recycled buffers are reset correctly. data := []byte("HELLO-R-U-THERE") wmbs := bytes.SplitAfter(data, []byte("-")) wms := []socket.Message{ {Buffers: wmbs[:1], Addr: nil}, {Buffers: wmbs[1:], Addr: nil}, } n, err := cc.SendMsgs(wms, 0) if n != 0 && err == nil { t.Fatal("expected error, destination address required") } }) } // The behavior of transmission for zero byte paylaod depends // on each platform implementation. Some may transmit only // protocol header and options, other may transmit nothing. // We test only that SendMsg and SendMsgs will not crash with // empty buffers. wm := socket.Message{ Buffers: [][]byte{{}}, Addr: c.LocalAddr(), } cc.SendMsg(&wm, 0) wms := []socket.Message{ {Buffers: [][]byte{{}}, Addr: c.LocalAddr()}, } cc.SendMsgs(wms, 0) } func BenchmarkUDP(b testing.B) { c, err := nettest.NewLocalPacketListener("udp") if err != nil { b.Skipf("not supported on %s/%s: %v", runtime.GOOS, runtime.GOARCH, err) } defer c.Close() cc, err := socket.NewConn(c.(net.Conn)) if err != nil { b.Fatal(err) } data := []byte("HELLO-R-U-THERE") wm := socket.Message{ Buffers: [][]byte{data}, Addr: c.LocalAddr(), } rm := socket.Message{ Buffers: [][]byte{make([]byte, 128)}, OOB: make([]byte, 128), } for M := 1; M <= 1<<9; M = M << 1 { b.Run(fmt.Sprintf("Iter-%d", M), func(b testing.B) { for i := 0; i < b.N; i++ { for j := 0; j < M; j++ { if err := cc.SendMsg(&wm, 0); err != nil { b.Fatal(err) } if err := cc.RecvMsg(&rm, 0); err != nil { b.Fatal(err) } } } }) switch runtime.GOOS { case "android", "linux": wms := make([]socket.Message, M) for i := range wms { wms[i].Buffers = [][]byte{data} wms[i].Addr = c.LocalAddr() } rms := make([]socket.Message, M) for i := range rms { rms[i].Buffers = [][]byte{make([]byte, 128)} rms[i].OOB = make([]byte, 128) } b.Run(fmt.Sprintf("Batch-%d", M), func(b testing.B) { for i := 0; i < b.N; i++ { if _, err := cc.SendMsgs(wms, 0); err != nil { b.Fatal(err) } if _, err := cc.RecvMsgs(rms, 0); err != nil { b.Fatal(err) } } }) } } } func TestRace(t testing.T) { tests := []string{ ` package main import ( "log" "net" "golang.org/x/net/ipv4" ) var g byte func main() { c, err := net.ListenPacket("udp", "127.0.0.1:0") if err != nil { log.Fatalf("ListenPacket: %v", err) } cc := ipv4.NewPacketConn(c) sync := make(chan bool) src := make([]byte, 100) dst := make([]byte, 100) go func() { if _, err := cc.WriteTo(src, nil, c.LocalAddr()); err != nil { log.Fatalf("WriteTo: %v", err) } }() go func() { if _, _, _, err := cc.ReadFrom(dst); err != nil { log.Fatalf("ReadFrom: %v", err) } sync <- true }() g = dst[0] <-sync } `, ` package main import ( "log" "net" "golang.org/x/net/ipv4" ) func main() { c, err := net.ListenPacket("udp", "127.0.0.1:0") if err != nil { log.Fatalf("ListenPacket: %v", err) } cc := ipv4.NewPacketConn(c) sync := make(chan bool) src := make([]byte, 100) dst := make([]byte, 100) go func() { if _, err := cc.WriteTo(src, nil, c.LocalAddr()); err != nil { log.Fatalf("WriteTo: %v", err) } sync <- true }() src[0] = 0 go func() { if _, _, _, err := cc.ReadFrom(dst); err != nil { log.Fatalf("ReadFrom: %v", err) } }() <-sync } `, } platforms := map[string]bool{ "linux/amd64": true, "linux/ppc64le": true, "linux/arm64": true, } if !platforms[runtime.GOOS+"/"+runtime.GOARCH] { t.Skip("skipping test on non-race-enabled host.") } if runtime.Compiler == "gccgo" { t.Skip("skipping race test when built with gccgo") } dir, err := os.MkdirTemp("", "testrace") if err != nil { t.Fatalf("failed to create temp directory: %v", err) } defer os.RemoveAll(dir) goBinary := filepath.Join(runtime.GOROOT(), "bin", "go") t.Logf("%s version", goBinary) got, err := exec.Command(goBinary, "version").CombinedOutput() if len(got) > 0 { t.Logf("%s", got) } if err != nil { t.Fatalf("go version failed: %v", err) } for i, test := range tests { t.Run(fmt.Sprintf("test %d", i), func(t testing.T) { src := filepath.Join(dir, fmt.Sprintf("test%d.go", i)) if err := os.WriteFile(src, []byte(test), 0644); err != nil { t.Fatalf("failed to write file: %v", err) } t.Logf("%s run -race %s", goBinary, src) got, err := exec.Command(goBinary, "run", "-race", src).CombinedOutput() if len(got) > 0 { t.Logf("%s", got) } if strings.Contains(string(got), "-race requires cgo") { t.Log("CGO is not enabled so can't use -race") } else if !strings.Contains(string(got), "WARNING: DATA RACE") { t.Errorf("race not detected for test %d: err:%v", i, err) } }) } }	11.16 KB	2025-05-25 12:27
📄 sys.go // Copyright 2017 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 socket import ( "encoding/binary" "unsafe" ) // NativeEndian is the machine native endian implementation of ByteOrder. var NativeEndian binary.ByteOrder func init() { i := uint32(1) b := (*[4]byte)(unsafe.Pointer(&i)) if b[0] == 1 { NativeEndian = binary.LittleEndian } else { NativeEndian = binary.BigEndian } }	495 B	2025-05-25 12:27
📄 sys_bsd.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| openbsd \|\| solaris package socket func recvmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { return 0, errNotImplemented } func sendmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { return 0, errNotImplemented }	441 B	2025-05-25 12:27
📄 sys_const_unix.go // 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| zos package socket import "golang.org/x/sys/unix" const ( sysAF_UNSPEC = unix.AF_UNSPEC sysAF_INET = unix.AF_INET sysAF_INET6 = unix.AF_INET6 sysSOCK_RAW = unix.SOCK_RAW sizeofSockaddrInet4 = unix.SizeofSockaddrInet4 sizeofSockaddrInet6 = unix.SizeofSockaddrInet6 )	533 B	2025-05-25 12:27
📄 sys_linux.go // Copyright 2017 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 && !s390x && !386 package socket import ( "syscall" "unsafe" ) func recvmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, _, errno := syscall.Syscall6(sysRECVMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) } func sendmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, _, errno := syscall.Syscall6(sysSENDMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) }	688 B	2025-05-25 12:27
📄 sys_linux_386.go // Copyright 2017 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 socket import ( "syscall" "unsafe" ) const ( sysRECVMMSG = 0x13 sysSENDMMSG = 0x14 ) func socketcall(call, a0, a1, a2, a3, a4, a5 uintptr) (uintptr, syscall.Errno) func rawsocketcall(call, a0, a1, a2, a3, a4, a5 uintptr) (uintptr, syscall.Errno) func recvmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, errno := socketcall(sysRECVMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) } func sendmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, errno := socketcall(sysSENDMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) }	847 B	2025-05-25 12:27
📄 sys_linux_386.s // Copyright 2014 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. #include "textflag.h" TEXT ·socketcall(SB),NOSPLIT,$0-36 JMP syscall·socketcall(SB) TEXT ·rawsocketcall(SB),NOSPLIT,$0-36 JMP syscall·rawsocketcall(SB)	320 B	2025-05-25 12:27
📄 sys_linux_amd64.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x12b sysSENDMMSG = 0x133 )	228 B	2025-05-25 12:27
📄 sys_linux_arm.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x16d sysSENDMMSG = 0x176 )	228 B	2025-05-25 12:27
📄 sys_linux_arm64.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0xf3 sysSENDMMSG = 0x10d )	227 B	2025-05-25 12:27
📄 sys_linux_loong64.go // Copyright 2021 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 loong64 package socket const ( sysRECVMMSG = 0xf3 sysSENDMMSG = 0x10d )	247 B	2025-05-25 12:27
📄 sys_linux_mips.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x10ef sysSENDMMSG = 0x10f7 )	230 B	2025-05-25 12:27
📄 sys_linux_mips64.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x14ae sysSENDMMSG = 0x14b6 )	230 B	2025-05-25 12:27
📄 sys_linux_mips64le.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x14ae sysSENDMMSG = 0x14b6 )	230 B	2025-05-25 12:27
📄 sys_linux_mipsle.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x10ef sysSENDMMSG = 0x10f7 )	230 B	2025-05-25 12:27
📄 sys_linux_ppc.go // Copyright 2021 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 socket const ( sysRECVMMSG = 0x157 sysSENDMMSG = 0x15d )	228 B	2025-05-25 12:27
📄 sys_linux_ppc64.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x157 sysSENDMMSG = 0x15d )	228 B	2025-05-25 12:27
📄 sys_linux_ppc64le.go // Copyright 2017 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 socket const ( sysRECVMMSG = 0x157 sysSENDMMSG = 0x15d )	228 B	2025-05-25 12:27
📄 sys_linux_riscv64.go // 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 riscv64 package socket const ( sysRECVMMSG = 0xf3 sysSENDMMSG = 0x10d )	247 B	2025-05-25 12:27
📄 sys_linux_s390x.go // Copyright 2017 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 socket import ( "syscall" "unsafe" ) const ( sysRECVMMSG = 0x13 sysSENDMMSG = 0x14 ) func socketcall(call, a0, a1, a2, a3, a4, a5 uintptr) (uintptr, syscall.Errno) func rawsocketcall(call, a0, a1, a2, a3, a4, a5 uintptr) (uintptr, syscall.Errno) func recvmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, errno := socketcall(sysRECVMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) } func sendmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, errno := socketcall(sysSENDMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) }	847 B	2025-05-25 12:27
📄 sys_linux_s390x.s // Copyright 2017 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. #include "textflag.h" TEXT ·socketcall(SB),NOSPLIT,$0-72 JMP syscall·socketcall(SB) TEXT ·rawsocketcall(SB),NOSPLIT,$0-72 JMP syscall·rawsocketcall(SB)	320 B	2025-05-25 12:27
📄 sys_netbsd.go // Copyright 2017 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 socket import ( "syscall" "unsafe" ) const ( sysRECVMMSG = 0x1db sysSENDMMSG = 0x1dc ) func recvmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, _, errno := syscall.Syscall6(sysRECVMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) } func sendmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { n, _, errno := syscall.Syscall6(sysSENDMMSG, s, uintptr(unsafe.Pointer(&hs[0])), uintptr(len(hs)), uintptr(flags), 0, 0) return int(n), errnoErr(errno) }	705 B	2025-05-25 12:27
📄 sys_posix.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris \|\| windows \|\| zos package socket import ( "encoding/binary" "errors" "net" "runtime" "strconv" "sync" "time" ) // marshalInetAddr writes a in sockaddr format into the buffer b. // The buffer must be sufficiently large (sizeofSockaddrInet4/6). // Returns the number of bytes written. func marshalInetAddr(a net.Addr, b []byte) int { switch a := a.(type) { case net.TCPAddr: return marshalSockaddr(a.IP, a.Port, a.Zone, b) case net.UDPAddr: return marshalSockaddr(a.IP, a.Port, a.Zone, b) case net.IPAddr: return marshalSockaddr(a.IP, 0, a.Zone, b) default: return 0 } } func marshalSockaddr(ip net.IP, port int, zone string, b []byte) int { if ip4 := ip.To4(); ip4 != nil { switch runtime.GOOS { case "android", "illumos", "linux", "solaris", "windows": NativeEndian.PutUint16(b[:2], uint16(sysAF_INET)) default: b[0] = sizeofSockaddrInet4 b[1] = sysAF_INET } binary.BigEndian.PutUint16(b[2:4], uint16(port)) copy(b[4:8], ip4) return sizeofSockaddrInet4 } if ip6 := ip.To16(); ip6 != nil && ip.To4() == nil { switch runtime.GOOS { case "android", "illumos", "linux", "solaris", "windows": NativeEndian.PutUint16(b[:2], uint16(sysAF_INET6)) default: b[0] = sizeofSockaddrInet6 b[1] = sysAF_INET6 } binary.BigEndian.PutUint16(b[2:4], uint16(port)) copy(b[8:24], ip6) if zone != "" { NativeEndian.PutUint32(b[24:28], uint32(zoneCache.index(zone))) } return sizeofSockaddrInet6 } return 0 } func parseInetAddr(b []byte, network string) (net.Addr, error) { if len(b) < 2 { return nil, errors.New("invalid address") } var af int switch runtime.GOOS { case "android", "illumos", "linux", "solaris", "windows": af = int(NativeEndian.Uint16(b[:2])) default: af = int(b[1]) } var ip net.IP var zone string if af == sysAF_INET { if len(b) < sizeofSockaddrInet4 { return nil, errors.New("short address") } ip = make(net.IP, net.IPv4len) copy(ip, b[4:8]) } if af == sysAF_INET6 { if len(b) < sizeofSockaddrInet6 { return nil, errors.New("short address") } ip = make(net.IP, net.IPv6len) copy(ip, b[8:24]) if id := int(NativeEndian.Uint32(b[24:28])); id > 0 { zone = zoneCache.name(id) } } switch network { case "tcp", "tcp4", "tcp6": return &net.TCPAddr{IP: ip, Port: int(binary.BigEndian.Uint16(b[2:4])), Zone: zone}, nil case "udp", "udp4", "udp6": return &net.UDPAddr{IP: ip, Port: int(binary.BigEndian.Uint16(b[2:4])), Zone: zone}, nil default: return &net.IPAddr{IP: ip, Zone: zone}, nil } } // An ipv6ZoneCache represents a cache holding partial network // interface information. It is used for reducing the cost of IPv6 // addressing scope zone resolution. // // Multiple names sharing the index are managed by first-come // first-served basis for consistency. type ipv6ZoneCache struct { sync.RWMutex // guard the following lastFetched time.Time // last time routing information was fetched toIndex map[string]int // interface name to its index toName map[int]string // interface index to its name } var zoneCache = ipv6ZoneCache{ toIndex: make(map[string]int), toName: make(map[int]string), } // update refreshes the network interface information if the cache was last // updated more than 1 minute ago, or if force is set. It returns whether the // cache was updated. func (zc ipv6ZoneCache) update(ift []net.Interface, force bool) (updated bool) { zc.Lock() defer zc.Unlock() now := time.Now() if !force && zc.lastFetched.After(now.Add(-60time.Second)) { return false } zc.lastFetched = now if len(ift) == 0 { var err error if ift, err = net.Interfaces(); err != nil { return false } } zc.toIndex = make(map[string]int, len(ift)) zc.toName = make(map[int]string, len(ift)) for _, ifi := range ift { zc.toIndex[ifi.Name] = ifi.Index if _, ok := zc.toName[ifi.Index]; !ok { zc.toName[ifi.Index] = ifi.Name } } return true } func (zc ipv6ZoneCache) name(zone int) string { updated := zoneCache.update(nil, false) zoneCache.RLock() name, ok := zoneCache.toName[zone] zoneCache.RUnlock() if !ok && !updated { zoneCache.update(nil, true) zoneCache.RLock() name, ok = zoneCache.toName[zone] zoneCache.RUnlock() } if !ok { // last resort name = strconv.Itoa(zone) } return name } func (zc *ipv6ZoneCache) index(zone string) int { updated := zoneCache.update(nil, false) zoneCache.RLock() index, ok := zoneCache.toIndex[zone] zoneCache.RUnlock() if !ok && !updated { zoneCache.update(nil, true) zoneCache.RLock() index, ok = zoneCache.toIndex[zone] zoneCache.RUnlock() } if !ok { // last resort index, _ = strconv.Atoi(zone) } return index }	4.83 KB	2025-05-25 12:27
📄 sys_stub.go // Copyright 2017 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 !aix && !darwin && !dragonfly && !freebsd && !linux && !netbsd && !openbsd && !solaris && !windows && !zos package socket import "net" const ( sysAF_UNSPEC = 0x0 sysAF_INET = 0x2 sysAF_INET6 = 0xa sysSOCK_RAW = 0x3 sizeofSockaddrInet4 = 0x10 sizeofSockaddrInet6 = 0x1c ) func marshalInetAddr(ip net.IP, port int, zone string) []byte { return nil } func parseInetAddr(b []byte, network string) (net.Addr, error) { return nil, errNotImplemented } func getsockopt(s uintptr, level, name int, b []byte) (int, error) { return 0, errNotImplemented } func setsockopt(s uintptr, level, name int, b []byte) error { return errNotImplemented } func recvmsg(s uintptr, buffers [][]byte, oob []byte, flags int, network string) (n, oobn int, recvflags int, from net.Addr, err error) { return 0, 0, 0, nil, errNotImplemented } func sendmsg(s uintptr, buffers [][]byte, oob []byte, to net.Addr, flags int) (int, error) { return 0, errNotImplemented } func recvmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { return 0, errNotImplemented } func sendmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { return 0, errNotImplemented }	1.29 KB	2025-05-25 12:27
📄 sys_unix.go // Copyright 2017 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 aix \|\| darwin \|\| dragonfly \|\| freebsd \|\| linux \|\| netbsd \|\| openbsd \|\| solaris package socket import ( "net" "unsafe" "golang.org/x/sys/unix" ) //go:linkname syscall_getsockopt syscall.getsockopt func syscall_getsockopt(s, level, name int, val unsafe.Pointer, vallen uint32) error //go:linkname syscall_setsockopt syscall.setsockopt func syscall_setsockopt(s, level, name int, val unsafe.Pointer, vallen uintptr) error func getsockopt(s uintptr, level, name int, b []byte) (int, error) { l := uint32(len(b)) err := syscall_getsockopt(int(s), level, name, unsafe.Pointer(&b[0]), &l) return int(l), err } func setsockopt(s uintptr, level, name int, b []byte) error { return syscall_setsockopt(int(s), level, name, unsafe.Pointer(&b[0]), uintptr(len(b))) } func recvmsg(s uintptr, buffers [][]byte, oob []byte, flags int, network string) (n, oobn int, recvflags int, from net.Addr, err error) { var unixFrom unix.Sockaddr n, oobn, recvflags, unixFrom, err = unix.RecvmsgBuffers(int(s), buffers, oob, flags) if unixFrom != nil { from = sockaddrToAddr(unixFrom, network) } return } func sendmsg(s uintptr, buffers [][]byte, oob []byte, to net.Addr, flags int) (int, error) { var unixTo unix.Sockaddr if to != nil { unixTo = addrToSockaddr(to) } return unix.SendmsgBuffers(int(s), buffers, oob, unixTo, flags) } // addrToSockaddr converts a net.Addr to a unix.Sockaddr. func addrToSockaddr(a net.Addr) unix.Sockaddr { var ( ip net.IP port int zone string ) switch a := a.(type) { case net.TCPAddr: ip = a.IP port = a.Port zone = a.Zone case net.UDPAddr: ip = a.IP port = a.Port zone = a.Zone case net.IPAddr: ip = a.IP zone = a.Zone default: return nil } if ip4 := ip.To4(); ip4 != nil { sa := unix.SockaddrInet4{Port: port} copy(sa.Addr[:], ip4) return &sa } if ip6 := ip.To16(); ip6 != nil && ip.To4() == nil { sa := unix.SockaddrInet6{Port: port} copy(sa.Addr[:], ip6) if zone != "" { sa.ZoneId = uint32(zoneCache.index(zone)) } return &sa } return nil } // sockaddrToAddr converts a unix.Sockaddr to a net.Addr. func sockaddrToAddr(sa unix.Sockaddr, network string) net.Addr { var ( ip net.IP port int zone string ) switch sa := sa.(type) { case unix.SockaddrInet4: ip = make(net.IP, net.IPv4len) copy(ip, sa.Addr[:]) port = sa.Port case unix.SockaddrInet6: ip = make(net.IP, net.IPv6len) copy(ip, sa.Addr[:]) port = sa.Port if sa.ZoneId > 0 { zone = zoneCache.name(int(sa.ZoneId)) } default: return nil } switch network { case "tcp", "tcp4", "tcp6": return &net.TCPAddr{IP: ip, Port: port, Zone: zone} case "udp", "udp4", "udp6": return &net.UDPAddr{IP: ip, Port: port, Zone: zone} default: return &net.IPAddr{IP: ip, Zone: zone} } }	2.88 KB	2025-05-25 12:27
📄 sys_windows.go // Copyright 2017 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 socket import ( "net" "syscall" "unsafe" "golang.org/x/sys/windows" ) func probeProtocolStack() int { var p uintptr return int(unsafe.Sizeof(p)) } const ( sysAF_UNSPEC = windows.AF_UNSPEC sysAF_INET = windows.AF_INET sysAF_INET6 = windows.AF_INET6 sysSOCK_RAW = windows.SOCK_RAW sizeofSockaddrInet4 = 0x10 sizeofSockaddrInet6 = 0x1c ) func getsockopt(s uintptr, level, name int, b []byte) (int, error) { l := uint32(len(b)) err := syscall.Getsockopt(syscall.Handle(s), int32(level), int32(name), (byte)(unsafe.Pointer(&b[0])), (int32)(unsafe.Pointer(&l))) return int(l), err } func setsockopt(s uintptr, level, name int, b []byte) error { return syscall.Setsockopt(syscall.Handle(s), int32(level), int32(name), (*byte)(unsafe.Pointer(&b[0])), int32(len(b))) } func recvmsg(s uintptr, buffers [][]byte, oob []byte, flags int, network string) (n, oobn int, recvflags int, from net.Addr, err error) { return 0, 0, 0, nil, errNotImplemented } func sendmsg(s uintptr, buffers [][]byte, oob []byte, to net.Addr, flags int) (int, error) { return 0, errNotImplemented } func recvmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { return 0, errNotImplemented } func sendmmsg(s uintptr, hs []mmsghdr, flags int) (int, error) { return 0, errNotImplemented }	1.42 KB	2025-05-25 12:27
📄 sys_zos_s390x.go // Copyright 2020 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 socket import ( "net" "syscall" "unsafe" ) func syscall_syscall(trap, a1, a2, a3 uintptr) (r1, r2 uintptr, err syscall.Errno) func syscall_syscall6(trap, a1, a2, a3, a4, a5, a6 uintptr) (r1, r2 uintptr, err syscall.Errno) func probeProtocolStack() int { return 4 // sizeof(int) on GOOS=zos GOARCH=s390x } func getsockopt(s uintptr, level, name int, b []byte) (int, error) { l := uint32(len(b)) _, _, errno := syscall_syscall6(syscall.SYS_GETSOCKOPT, s, uintptr(level), uintptr(name), uintptr(unsafe.Pointer(&b[0])), uintptr(unsafe.Pointer(&l)), 0) return int(l), errnoErr(errno) } func setsockopt(s uintptr, level, name int, b []byte) error { _, _, errno := syscall_syscall6(syscall.SYS_SETSOCKOPT, s, uintptr(level), uintptr(name), uintptr(unsafe.Pointer(&b[0])), uintptr(len(b)), 0) return errnoErr(errno) } func recvmsg(s uintptr, buffers [][]byte, oob []byte, flags int, network string) (n, oobn int, recvflags int, from net.Addr, err error) { var h msghdr vs := make([]iovec, len(buffers)) var sa []byte if network != "tcp" { sa = make([]byte, sizeofSockaddrInet6) } h.pack(vs, buffers, oob, sa) sn, _, errno := syscall_syscall(syscall.SYS___RECVMSG_A, s, uintptr(unsafe.Pointer(&h)), uintptr(flags)) n = int(sn) oobn = h.controllen() recvflags = h.flags() err = errnoErr(errno) if network != "tcp" { var err2 error from, err2 = parseInetAddr(sa, network) if err2 != nil && err == nil { err = err2 } } return } func sendmsg(s uintptr, buffers [][]byte, oob []byte, to net.Addr, flags int) (int, error) { var h msghdr vs := make([]iovec, len(buffers)) var sa []byte if to != nil { var a [sizeofSockaddrInet6]byte n := marshalInetAddr(to, a[:]) sa = a[:n] } h.pack(vs, buffers, oob, sa) n, _, errno := syscall_syscall(syscall.SYS___SENDMSG_A, s, uintptr(unsafe.Pointer(&h)), uintptr(flags)) return int(n), errnoErr(errno) }	2 KB	2025-05-25 12:27
📄 sys_zos_s390x.s // Copyright 2020 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. #include "textflag.h" TEXT ·syscall_syscall(SB),NOSPLIT,$0 JMP syscall·_syscall(SB) TEXT ·syscall_syscall6(SB),NOSPLIT,$0 JMP syscall·_syscall6(SB)	338 B	2025-05-25 12:27
📄 zsys_aix_ppc64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_aix.go // Added for go1.11 compatibility //go:build aix package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen int32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	543 B	2025-05-25 12:27
📄 zsys_darwin_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_darwin.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	456 B	2025-05-25 12:27
📄 zsys_darwin_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_darwin.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	456 B	2025-05-25 12:27
📄 zsys_dragonfly_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_dragonfly.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	459 B	2025-05-25 12:27
📄 zsys_freebsd_386.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen int32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	416 B	2025-05-25 12:27
📄 zsys_freebsd_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	457 B	2025-05-25 12:27
📄 zsys_freebsd_arm.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen int32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	416 B	2025-05-25 12:27
📄 zsys_freebsd_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	457 B	2025-05-25 12:27
📄 zsys_freebsd_riscv64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_freebsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen int32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	417 B	2025-05-25 12:27
📄 zsys_linux_386.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	464 B	2025-05-25 12:27
📄 zsys_linux_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_1 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_arm.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	464 B	2025-05-25 12:27
📄 zsys_linux_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_1 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_loong64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go //go:build loong64 package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_0 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_mips.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	464 B	2025-05-25 12:27
📄 zsys_linux_mips64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_1 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_mips64le.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_1 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_mipsle.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	464 B	2025-05-25 12:27
📄 zsys_linux_ppc.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	464 B	2025-05-25 12:27
📄 zsys_linux_ppc64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_1 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_ppc64le.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_1 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_riscv64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go //go:build riscv64 package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_0 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_linux_s390x.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_linux.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint64 Control byte Controllen uint64 Flags int32 Pad_cgo_1 [4]byte } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint64 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x38 )	536 B	2025-05-25 12:27
📄 zsys_netbsd_386.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_netbsd.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen int32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	464 B	2025-05-25 12:27
📄 zsys_netbsd_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_netbsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	536 B	2025-05-25 12:27
📄 zsys_netbsd_arm.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_netbsd.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen int32 Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	464 B	2025-05-25 12:27
📄 zsys_netbsd_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_netbsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type mmsghdr struct { Hdr msghdr Len uint32 Pad_cgo_0 [4]byte } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	536 B	2025-05-25 12:27
📄 zsys_openbsd_386.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	417 B	2025-05-25 12:27
📄 zsys_openbsd_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	458 B	2025-05-25 12:27
📄 zsys_openbsd_arm.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package socket type iovec struct { Base byte Len uint32 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x8 sizeofMsghdr = 0x1c )	417 B	2025-05-25 12:27
📄 zsys_openbsd_arm64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen uint32 Pad_cgo_1 [4]byte Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	458 B	2025-05-25 12:27
📄 zsys_openbsd_mips64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	418 B	2025-05-25 12:27
📄 zsys_openbsd_ppc64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	418 B	2025-05-25 12:27
📄 zsys_openbsd_riscv64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_openbsd.go package socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Namelen uint32 Iov iovec Iovlen uint32 Control byte Controllen uint32 Flags int32 } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	418 B	2025-05-25 12:27
📄 zsys_solaris_amd64.go // Code generated by cmd/cgo -godefs; DO NOT EDIT. // cgo -godefs defs_solaris.go package socket type iovec struct { Base int8 Len uint64 } type msghdr struct { Name byte Namelen uint32 Pad_cgo_0 [4]byte Iov iovec Iovlen int32 Pad_cgo_1 [4]byte Accrights int8 Accrightslen int32 Pad_cgo_2 [4]byte } type cmsghdr struct { Len uint32 Level int32 Type int32 } const ( sizeofIovec = 0x10 sizeofMsghdr = 0x30 )	476 B	2025-05-25 12:27
📄 zsys_zos_s390x.go // Copyright 2020 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 socket type iovec struct { Base byte Len uint64 } type msghdr struct { Name byte Iov iovec Control byte Flags int32 Namelen uint32 Iovlen int32 Controllen uint32 } type cmsghdr struct { Len int32 Level int32 Type int32 } const sizeofCmsghdr = 12	466 B	2025-05-25 12:27

Edit File:

Terminal