dfd, err := syscall.Dup(int(f.Fd()), -1)
syscall.ForkLock.RUnlock()
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("dup", err)
}
return os.NewFile(uintptr(dfd), s), nil
}
}
fallthrough
default:
- return err
+ return os.NewSyscallError("connect", err)
}
if err := fd.init(); err != nil {
return err
}
nerr, err := getsockoptIntFunc(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_ERROR)
if err != nil {
- return err
+ return os.NewSyscallError("getsockopt", err)
}
switch err := syscall.Errno(nerr); err {
case syscall.EINPROGRESS, syscall.EALREADY, syscall.EINTR:
case syscall.Errno(0), syscall.EISCONN:
return nil
default:
- return err
+ return os.NewSyscallError("getsockopt", err)
}
}
}
return err
}
defer fd.decref()
- return syscall.Shutdown(fd.sysfd, how)
+ return os.NewSyscallError("shutdown", syscall.Shutdown(fd.sysfd, how))
}
func (fd *netFD) closeRead() error {
err = fd.eofError(n, err)
break
}
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("read", err)
+ }
return
}
err = fd.eofError(n, err)
break
}
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("recvfrom", err)
+ }
return
}
err = fd.eofError(n, err)
break
}
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("recvmsg", err)
+ }
return
}
break
}
}
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("write", err)
+ }
return nn, err
}
if err == nil {
n = len(p)
}
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("sendto", err)
+ }
return
}
if err == nil {
oobn = len(oob)
}
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("sendmsg", err)
+ }
return
}
for {
s, rsa, err = accept(fd.sysfd)
if err != nil {
- if err == syscall.EAGAIN {
+ nerr, ok := err.(*os.SyscallError)
+ if !ok {
+ return nil, err
+ }
+ switch nerr.Err {
+ case syscall.EAGAIN:
if err = fd.pd.WaitRead(); err == nil {
continue
}
- } else if err == syscall.ECONNABORTED {
- // This means that a socket on the listen queue was closed
- // before we Accept()ed it; it's a silly error, so try again.
+ case syscall.ECONNABORTED:
+ // This means that a socket on the
+ // listen queue was closed before we
+ // Accept()ed it; it's a silly error,
+ // so try again.
continue
}
return nil, err
// from now on.
atomic.StoreInt32(&tryDupCloexec, 0)
default:
- return -1, e1
+ return -1, os.NewSyscallError("fcntl", e1)
}
}
return dupCloseOnExecOld(fd)
defer syscall.ForkLock.RUnlock()
newfd, err = syscall.Dup(fd)
if err != nil {
- return -1, err
+ return -1, os.NewSyscallError("dup", err)
}
syscall.CloseOnExec(newfd)
return
// I/O will block the thread instead of letting us use the epoll server.
// Everything will still work, just with more threads.
if err = syscall.SetNonblock(ns, false); err != nil {
- return nil, err
+ return nil, os.NewSyscallError("setnonblock", err)
}
return os.NewFile(uintptr(ns), fd.name()), nil
var d syscall.WSAData
e := syscall.WSAStartup(uint32(0x202), &d)
if e != nil {
- initErr = os.NewSyscallError("WSAStartup", e)
+ initErr = os.NewSyscallError("wsastartup", e)
}
canCancelIO = syscall.LoadCancelIoEx() == nil
if syscall.LoadGetAddrInfo() == nil {
size := uint32(unsafe.Sizeof(flag))
err := syscall.WSAIoctl(fd.sysfd, syscall.SIO_UDP_CONNRESET, (*byte)(unsafe.Pointer(&flag)), size, nil, 0, &ret, nil, 0)
if err != nil {
- return os.NewSyscallError("WSAIoctl", err)
+ return os.NewSyscallError("wsaioctl", err)
}
}
fd.rop.mode = 'r'
defer fd.setWriteDeadline(noDeadline)
}
if !canUseConnectEx(fd.net) {
- return connectFunc(fd.sysfd, ra)
+ return os.NewSyscallError("connect", connectFunc(fd.sysfd, ra))
}
// ConnectEx windows API requires an unconnected, previously bound socket.
if la == nil {
panic("unexpected type in connect")
}
if err := syscall.Bind(fd.sysfd, la); err != nil {
- return err
+ return os.NewSyscallError("bind", err)
}
}
// Call ConnectEx API.
return connectExFunc(o.fd.sysfd, o.sa, nil, 0, nil, &o.o)
})
if err != nil {
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("connectex", err)
+ }
return err
}
// Refresh socket properties.
- return syscall.Setsockopt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_UPDATE_CONNECT_CONTEXT, (*byte)(unsafe.Pointer(&fd.sysfd)), int32(unsafe.Sizeof(fd.sysfd)))
+ return os.NewSyscallError("setsockopt", syscall.Setsockopt(fd.sysfd, syscall.SOL_SOCKET, syscall.SO_UPDATE_CONNECT_CONTEXT, (*byte)(unsafe.Pointer(&fd.sysfd)), int32(unsafe.Sizeof(fd.sysfd))))
}
func (fd *netFD) destroy() {
if raceenabled {
raceAcquire(unsafe.Pointer(&ioSync))
}
- return n, fd.eofError(n, err)
+ err = fd.eofError(n, err)
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("wsarecv", err)
+ }
+ return n, err
}
func (fd *netFD) readFrom(buf []byte) (int, syscall.Sockaddr, error) {
return syscall.WSARecvFrom(o.fd.sysfd, &o.buf, 1, &o.qty, &o.flags, o.rsa, &o.rsan, &o.o, nil)
})
err = fd.eofError(n, err)
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("wsarecvfrom", err)
+ }
if err != nil {
return n, nil, err
}
sa, _ := o.rsa.Sockaddr()
- return n, sa, err
+ return n, sa, nil
}
func (fd *netFD) Write(buf []byte) (int, error) {
n, err := wsrv.ExecIO(o, "WSASend", func(o *operation) error {
return syscall.WSASend(o.fd.sysfd, &o.buf, 1, &o.qty, 0, &o.o, nil)
})
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("wsasend", err)
+ }
return n, err
}
n, err := wsrv.ExecIO(o, "WSASendto", func(o *operation) error {
return syscall.WSASendto(o.fd.sysfd, &o.buf, 1, &o.qty, 0, o.sa, &o.o, nil)
})
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("wsasendto", err)
+ }
return n, err
}
})
if err != nil {
netfd.Close()
+ if _, ok := err.(syscall.Errno); ok {
+ err = os.NewSyscallError("acceptex", err)
+ }
return nil, err
}
err = syscall.Setsockopt(s, syscall.SOL_SOCKET, syscall.SO_UPDATE_ACCEPT_CONTEXT, (*byte)(unsafe.Pointer(&fd.sysfd)), int32(unsafe.Sizeof(fd.sysfd)))
if err != nil {
netfd.Close()
- return nil, err
+ return nil, os.NewSyscallError("setsockopt", err)
}
return netfd, nil
// before AcceptEx could complete. These errors relate to new
// connection, not to AcceptEx, so ignore broken connection and
// try AcceptEx again for more connections.
- errno, ok := err.(syscall.Errno)
+ nerr, ok := err.(*os.SyscallError)
+ if !ok {
+ return nil, err
+ }
+ errno, ok := nerr.Err.(syscall.Errno)
if !ok {
return nil, err
}
path, err := syscall.Fd2path(int(f.Fd()))
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("fd2path", err)
}
comp := splitAtBytes(path, "/")
n := len(comp)
fd, err := syscall.Dup(int(f.Fd()), -1)
syscall.ForkLock.RUnlock()
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("dup", err)
}
defer close(fd)
if err = syscall.SetNonblock(fd, true); err != nil {
closeFunc(fd)
- return nil, err
+ return nil, os.NewSyscallError("setnonblock", err)
}
sotype, err := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_TYPE)
if err != nil {
closeFunc(fd)
- return nil, err
+ return nil, os.NewSyscallError("getsockopt", err)
}
family := syscall.AF_UNSPEC
package net
import (
+ "os"
"syscall"
"unsafe"
)
func interfaceTable(ifindex int) ([]Interface, error) {
tab, err := syscall.RouteRIB(syscall.NET_RT_IFLIST, ifindex)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("routerib", err)
}
msgs, err := syscall.ParseRoutingMessage(tab)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingmessage", err)
}
return parseInterfaceTable(ifindex, msgs)
}
func newLink(m *syscall.InterfaceMessage) (*Interface, error) {
sas, err := syscall.ParseRoutingSockaddr(m)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingsockaddr", err)
}
ifi := &Interface{Index: int(m.Header.Index), Flags: linkFlags(m.Header.Flags)}
sa, _ := sas[syscall.RTAX_IFP].(*syscall.SockaddrDatalink)
}
tab, err := syscall.RouteRIB(syscall.NET_RT_IFLIST, index)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("routerib", err)
}
msgs, err := syscall.ParseRoutingMessage(tab)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingmessage", err)
}
var ift []Interface
if index == 0 {
func newAddr(ifi *Interface, m *syscall.InterfaceAddrMessage) (*IPNet, error) {
sas, err := syscall.ParseRoutingSockaddr(m)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingsockaddr", err)
}
ifa := &IPNet{}
switch sa := sas[syscall.RTAX_NETMASK].(type) {
package net
-import "syscall"
+import (
+ "os"
+ "syscall"
+)
// interfaceMulticastAddrTable returns addresses for a specific
// interface.
func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error) {
tab, err := syscall.RouteRIB(syscall.NET_RT_IFLIST2, ifi.Index)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("routerib", err)
}
msgs, err := syscall.ParseRoutingMessage(tab)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingmessage", err)
}
var ifmat []Addr
for _, m := range msgs {
func newMulticastAddr(ifi *Interface, m *syscall.InterfaceMulticastAddrMessage) (*IPAddr, error) {
sas, err := syscall.ParseRoutingSockaddr(m)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingsockaddr", err)
}
switch sa := sas[syscall.RTAX_IFA].(type) {
case *syscall.SockaddrInet4:
package net
-import "syscall"
+import (
+ "os"
+ "syscall"
+)
// interfaceMulticastAddrTable returns addresses for a specific
// interface.
func interfaceMulticastAddrTable(ifi *Interface) ([]Addr, error) {
tab, err := syscall.RouteRIB(syscall.NET_RT_IFMALIST, ifi.Index)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("routerib", err)
}
msgs, err := syscall.ParseRoutingMessage(tab)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingmessage", err)
}
var ifmat []Addr
for _, m := range msgs {
func newMulticastAddr(ifi *Interface, m *syscall.InterfaceMulticastAddrMessage) (*IPAddr, error) {
sas, err := syscall.ParseRoutingSockaddr(m)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parseroutingsockaddr", err)
}
switch sa := sas[syscall.RTAX_IFA].(type) {
case *syscall.SockaddrInet4:
package net
import (
+ "os"
"syscall"
"unsafe"
)
func interfaceTable(ifindex int) ([]Interface, error) {
tab, err := syscall.NetlinkRIB(syscall.RTM_GETLINK, syscall.AF_UNSPEC)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("netlinkrib", err)
}
msgs, err := syscall.ParseNetlinkMessage(tab)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parsenetlinkmessage", err)
}
var ift []Interface
loop:
if ifindex == 0 || ifindex == int(ifim.Index) {
attrs, err := syscall.ParseNetlinkRouteAttr(&m)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parsenetlinkrouteattr", err)
}
ift = append(ift, *newLink(ifim, attrs))
if ifindex == int(ifim.Index) {
func interfaceAddrTable(ifi *Interface) ([]Addr, error) {
tab, err := syscall.NetlinkRIB(syscall.RTM_GETADDR, syscall.AF_UNSPEC)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("netlinkrib", err)
}
msgs, err := syscall.ParseNetlinkMessage(tab)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parsenetlinkmessage", err)
}
var ift []Interface
if ifi == nil {
}
attrs, err := syscall.ParseNetlinkRouteAttr(&m)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("parsenetlinkrouteattr", err)
}
ifa := newAddr(ifi, ifam, attrs)
if ifa != nil {
import (
"internal/syscall/windows"
+ "os"
"syscall"
"unsafe"
)
break
}
if err.(syscall.Errno) != syscall.ERROR_BUFFER_OVERFLOW {
- return nil, err
+ return nil, os.NewSyscallError("getadaptersaddresses", err)
}
}
return &addrs[0], nil
size := uint32(unsafe.Sizeof(iia))
err = syscall.WSAIoctl(s, syscall.SIO_GET_INTERFACE_LIST, nil, 0, (*byte)(unsafe.Pointer(&iia[0])), size, &ret, nil, 0)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("wsaioctl", err)
}
iilen := ret / uint32(unsafe.Sizeof(iia[0]))
return iia[:iilen-1], nil
package net
-import "errors"
-
// IP address lengths (bytes).
const (
IPv4len = 4
return []byte(""), nil
}
if len(ip) != IPv4len && len(ip) != IPv6len {
- return nil, errors.New("invalid IP address")
+ return nil, &AddrError{Err: "invalid IP address", Addr: ip.String()}
}
return []byte(ip.String()), nil
}
s := string(text)
x := ParseIP(s)
if x == nil {
- return &ParseError{"IP address", s}
+ return &ParseError{Type: "IP address", Text: s}
}
*ip = x
return nil
return ip, zone
}
-// A ParseError represents a malformed text string and the type of string that was expected.
-type ParseError struct {
- Type string
- Text string
-}
-
-func (e *ParseError) Error() string {
- return "invalid " + e.Type + ": " + e.Text
-}
-
// ParseIP parses s as an IP address, returning the result.
// The string s can be in dotted decimal ("74.125.19.99")
// or IPv6 ("2001:4860:0:2001::68") form.
func ParseCIDR(s string) (IP, *IPNet, error) {
i := byteIndex(s, '/')
if i < 0 {
- return nil, nil, &ParseError{"CIDR address", s}
+ return nil, nil, &ParseError{Type: "CIDR address", Text: s}
}
addr, mask := s[:i], s[i+1:]
iplen := IPv4len
}
n, i, ok := dtoi(mask, 0)
if ip == nil || !ok || i != len(mask) || n < 0 || n > 8*iplen {
- return nil, nil, &ParseError{"CIDR address", s}
+ return nil, nil, &ParseError{Type: "CIDR address", Text: s}
}
m := CIDRMask(n, 8*iplen)
return ip, &IPNet{IP: ip.Mask(m), Mask: m}, nil
{"abcd:2345::/24", ParseIP("abcd:2345::"), &IPNet{IP: ParseIP("abcd:2300::"), Mask: IPMask(ParseIP("ffff:ff00::"))}, nil},
{"2001:DB8::/48", ParseIP("2001:DB8::"), &IPNet{IP: ParseIP("2001:DB8::"), Mask: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
{"2001:DB8::1/48", ParseIP("2001:DB8::1"), &IPNet{IP: ParseIP("2001:DB8::"), Mask: IPMask(ParseIP("ffff:ffff:ffff::"))}, nil},
- {"192.168.1.1/255.255.255.0", nil, nil, &ParseError{"CIDR address", "192.168.1.1/255.255.255.0"}},
- {"192.168.1.1/35", nil, nil, &ParseError{"CIDR address", "192.168.1.1/35"}},
- {"2001:db8::1/-1", nil, nil, &ParseError{"CIDR address", "2001:db8::1/-1"}},
- {"", nil, nil, &ParseError{"CIDR address", ""}},
+ {"192.168.1.1/255.255.255.0", nil, nil, &ParseError{Type: "CIDR address", Text: "192.168.1.1/255.255.255.0"}},
+ {"192.168.1.1/35", nil, nil, &ParseError{Type: "CIDR address", Text: "192.168.1.1/35"}},
+ {"2001:db8::1/-1", nil, nil, &ParseError{Type: "CIDR address", Text: "2001:db8::1/-1"}},
+ {"", nil, nil, &ParseError{Type: "CIDR address", Text: ""}},
}
func TestParseCIDR(t *testing.T) {
// Expect the first ']' just before the last ':'.
end := byteIndex(hostport, ']')
if end < 0 {
- err = &AddrError{"missing ']' in address", hostport}
+ err = &AddrError{Err: "missing ']' in address", Addr: hostport}
return
}
switch end + 1 {
}
}
if byteIndex(hostport[j:], '[') >= 0 {
- err = &AddrError{"unexpected '[' in address", hostport}
+ err = &AddrError{Err: "unexpected '[' in address", Addr: hostport}
return
}
if byteIndex(hostport[k:], ']') >= 0 {
- err = &AddrError{"unexpected ']' in address", hostport}
+ err = &AddrError{Err: "unexpected ']' in address", Addr: hostport}
return
}
return
missingPort:
- err = &AddrError{"missing port in address", hostport}
+ err = &AddrError{Err: "missing port in address", Addr: hostport}
return
tooManyColons:
- err = &AddrError{"too many colons in address", hostport}
+ err = &AddrError{Err: "too many colons in address", Addr: hostport}
return
missingBrackets:
- err = &AddrError{"missing brackets in address", hostport}
+ err = &AddrError{Err: "missing brackets in address", Addr: hostport}
return
}
package net
import (
- "errors"
"os"
"syscall"
)
if i >= 0 {
addr = ParseIP(s[:i])
if addr == nil {
- return nil, 0, errors.New("parsing IP failed")
+ return nil, 0, &ParseError{Type: "IP address", Text: s}
}
}
p, _, ok := dtoi(s[i+1:], 0)
if !ok {
- return nil, 0, errors.New("parsing port failed")
+ return nil, 0, &ParseError{Type: "port", Text: s}
}
if p < 0 || p > 0xFFFF {
- return nil, 0, &AddrError{"invalid port", string(p)}
+ return nil, 0, &AddrError{Err: "invalid port", Addr: string(p)}
}
return addr, p, nil
}
case "udp":
addr = &UDPAddr{IP: ip, Port: port}
default:
- return nil, errors.New("unknown protocol " + proto)
+ return nil, UnknownNetworkError(proto)
}
return addr, nil
}
ip = IPv4zero
}
if ip = ip.To4(); ip == nil {
- return nil, InvalidAddrError("non-IPv4 address")
+ return nil, &AddrError{Err: "non-IPv4 address", Addr: ip.String()}
}
sa := new(syscall.SockaddrInet4)
for i := 0; i < IPv4len; i++ {
ip = IPv6zero
}
if ip = ip.To16(); ip == nil {
- return nil, InvalidAddrError("non-IPv6 address")
+ return nil, &AddrError{Err: "non-IPv6 address", Addr: ip.String()}
}
sa := new(syscall.SockaddrInet6)
for i := 0; i < IPv6len; i++ {
sa.ZoneId = uint32(zoneToInt(zone))
return sa, nil
}
- return nil, InvalidAddrError("unexpected socket family")
+ return nil, &AddrError{Err: "invalid address family", Addr: ip.String()}
}
if err != nil {
return 0, err
}
- unknownProtoError := errors.New("unknown IP protocol specified: " + name)
if len(lines) == 0 {
- return 0, unknownProtoError
+ return 0, UnknownNetworkError(name)
}
f := getFields(lines[0])
if len(f) < 2 {
- return 0, unknownProtoError
+ return 0, UnknownNetworkError(name)
}
s := f[1]
if n, _, ok := dtoi(s, byteIndex(s, '=')+1); ok {
return n, nil
}
- return 0, unknownProtoError
+ return 0, UnknownNetworkError(name)
}
func lookupHost(host string) (addrs []string, err error) {
if err != nil {
return
}
- unknownPortError := &AddrError{"unknown port", network + "/" + service}
+ unknownPortError := &AddrError{Err: "unknown port", Addr: network + "/" + service}
if len(lines) == 0 {
return 0, unknownPortError
}
package net
import (
+ "os"
"runtime"
"syscall"
"unsafe"
func getprotobyname(name string) (proto int, err error) {
p, err := syscall.GetProtoByName(name)
if err != nil {
- return 0, err
+ return 0, os.NewSyscallError("getorotobyname", err)
}
return int(p.Proto), nil
}
// caller already acquired thread
h, err := syscall.GetHostByName(name)
if err != nil {
- return nil, err
+ return nil, os.NewSyscallError("gethostbyname", err)
}
switch h.AddrType {
case syscall.AF_INET:
var result *syscall.AddrinfoW
e := syscall.GetAddrInfoW(syscall.StringToUTF16Ptr(name), nil, &hints, &result)
if e != nil {
- return nil, &DNSError{Err: e.Error(), Name: name}
+ return nil, &DNSError{Err: os.NewSyscallError("getaddrinfow", e).Error(), Name: name}
}
defer syscall.FreeAddrInfoW(result)
addrs := make([]IPAddr, 0, 5)
}
s, err := syscall.GetServByName(service, network)
if err != nil {
- return 0, err
+ return 0, os.NewSyscallError("getservbyname", err)
}
return int(syscall.Ntohs(s.Port)), nil
}
var result *syscall.AddrinfoW
e := syscall.GetAddrInfoW(nil, syscall.StringToUTF16Ptr(service), &hints, &result)
if e != nil {
- return 0, &DNSError{Err: e.Error(), Name: network + "/" + service}
+ return 0, &DNSError{Err: os.NewSyscallError("getaddrinfow", e).Error(), Name: network + "/" + service}
}
defer syscall.FreeAddrInfoW(result)
if result == nil {
return name, nil
}
if e != nil {
- return "", &DNSError{Err: e.Error(), Name: name}
+ return "", &DNSError{Err: os.NewSyscallError("dnsquery", e).Error(), Name: name}
}
defer syscall.DnsRecordListFree(r, 1)
var r *syscall.DNSRecord
e := syscall.DnsQuery(target, syscall.DNS_TYPE_SRV, 0, nil, &r, nil)
if e != nil {
- return "", nil, &DNSError{Err: e.Error(), Name: target}
+ return "", nil, &DNSError{Err: os.NewSyscallError("dnsquery", e).Error(), Name: target}
}
defer syscall.DnsRecordListFree(r, 1)
var r *syscall.DNSRecord
e := syscall.DnsQuery(name, syscall.DNS_TYPE_MX, 0, nil, &r, nil)
if e != nil {
- return nil, &DNSError{Err: e.Error(), Name: name}
+ return nil, &DNSError{Err: os.NewSyscallError("dnsquery", e).Error(), Name: name}
}
defer syscall.DnsRecordListFree(r, 1)
var r *syscall.DNSRecord
e := syscall.DnsQuery(name, syscall.DNS_TYPE_NS, 0, nil, &r, nil)
if e != nil {
- return nil, &DNSError{Err: e.Error(), Name: name}
+ return nil, &DNSError{Err: os.NewSyscallError("dnsquery", e).Error(), Name: name}
}
defer syscall.DnsRecordListFree(r, 1)
var r *syscall.DNSRecord
e := syscall.DnsQuery(name, syscall.DNS_TYPE_TEXT, 0, nil, &r, nil)
if e != nil {
- return nil, &DNSError{Err: e.Error(), Name: name}
+ return nil, &DNSError{Err: os.NewSyscallError("dnsquery", e).Error(), Name: name}
}
defer syscall.DnsRecordListFree(r, 1)
var r *syscall.DNSRecord
e := syscall.DnsQuery(arpa, syscall.DNS_TYPE_PTR, 0, nil, &r, nil)
if e != nil {
- return nil, &DNSError{Err: e.Error(), Name: addr}
+ return nil, &DNSError{Err: os.NewSyscallError("dnsquery", e).Error(), Name: addr}
}
defer syscall.DnsRecordListFree(r, 1)
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
-// MAC address manipulations
-
package net
-import "errors"
-
const hexDigit = "0123456789abcdef"
// A HardwareAddr represents a physical hardware address.
return hw, nil
error:
- return nil, errors.New("invalid MAC address: " + s)
+ return nil, &AddrError{Err: "invalid MAC address", Addr: s}
}
return
}
-// An Error represents a network error.
-type Error interface {
- error
- Timeout() bool // Is the error a timeout?
- Temporary() bool // Is the error temporary?
-}
-
// PacketConn is a generic packet-oriented network connection.
//
// Multiple goroutines may invoke methods on a PacketConn simultaneously.
Addr() Addr
}
+// An Error represents a network error.
+type Error interface {
+ error
+ Timeout() bool // Is the error a timeout?
+ Temporary() bool // Is the error temporary?
+}
+
// Various errors contained in OpError.
var (
// For connection setup and write operations.
return s
}
-type temporary interface {
- Temporary() bool
-}
-
-func (e *OpError) Temporary() bool {
- t, ok := e.Err.(temporary)
- return ok && t.Temporary()
-}
-
var noDeadline = time.Time{}
type timeout interface {
}
func (e *OpError) Timeout() bool {
+ if ne, ok := e.Err.(*os.SyscallError); ok {
+ t, ok := ne.Err.(timeout)
+ return ok && t.Timeout()
+ }
t, ok := e.Err.(timeout)
return ok && t.Timeout()
}
+type temporary interface {
+ Temporary() bool
+}
+
+func (e *OpError) Temporary() bool {
+ if ne, ok := e.Err.(*os.SyscallError); ok {
+ t, ok := ne.Err.(temporary)
+ return ok && t.Temporary()
+ }
+ t, ok := e.Err.(temporary)
+ return ok && t.Temporary()
+}
+
type timeoutError struct{}
func (e *timeoutError) Error() string { return "i/o timeout" }
func (e *timeoutError) Timeout() bool { return true }
func (e *timeoutError) Temporary() bool { return true }
+// A ParseError is the error type of literal network address parsers.
+type ParseError struct {
+ // Type is the type of string that was expected, such as
+ // "IP address", "CIDR address".
+ Type string
+
+ // Text is the malformed text string.
+ Text string
+}
+
+func (e *ParseError) Error() string { return "invalid " + e.Type + ": " + e.Text }
+
type AddrError struct {
Err string
Addr string
return s
}
-func (e *AddrError) Temporary() bool { return false }
func (e *AddrError) Timeout() bool { return false }
+func (e *AddrError) Temporary() bool { return false }
type UnknownNetworkError string
func (e UnknownNetworkError) Error() string { return "unknown network " + string(e) }
-func (e UnknownNetworkError) Temporary() bool { return false }
func (e UnknownNetworkError) Timeout() bool { return false }
+func (e UnknownNetworkError) Temporary() bool { return false }
type InvalidAddrError string
if lr != nil {
lr.N = remain
}
+ if err != nil {
+ err = os.NewSyscallError("sendfile", err)
+ }
return written, err, written > 0
}
if lr != nil {
lr.N = remain
}
+ if err != nil {
+ err = os.NewSyscallError("sendfile", err)
+ }
return written, err, written > 0
}
if lr != nil {
lr.N = remain
}
+ if err != nil {
+ err = os.NewSyscallError("sendfile", err)
+ }
return written, err, written > 0
}
return syscall.TransmitFile(o.fd.sysfd, o.handle, o.qty, 0, &o.o, nil, syscall.TF_WRITE_BEHIND)
})
if err != nil {
- return 0, err, false
+ return 0, os.NewSyscallError("transmitfile", err), false
}
if lr != nil {
lr.N -= int64(done)
package net
-import "syscall"
+import (
+ "os"
+ "syscall"
+)
// Wrapper around the socket system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
// introduced in 10 kernel. If we get an EINVAL error on Linux
// or EPROTONOSUPPORT error on FreeBSD, fall back to using
// socket without them.
- if err == nil || (err != syscall.EPROTONOSUPPORT && err != syscall.EINVAL) {
- return s, err
+ switch err {
+ case nil:
+ return s, nil
+ default:
+ return -1, os.NewSyscallError("socket", err)
+ case syscall.EPROTONOSUPPORT, syscall.EINVAL:
}
// See ../syscall/exec_unix.go for description of ForkLock.
}
syscall.ForkLock.RUnlock()
if err != nil {
- return -1, err
+ return -1, os.NewSyscallError("socket", err)
}
if err = syscall.SetNonblock(s, true); err != nil {
closeFunc(s)
- return -1, err
+ return -1, os.NewSyscallError("setnonblock", err)
}
return s, nil
}
// get an ENOSYS error on both Linux and FreeBSD, or EINVAL
// error on Linux, fall back to using accept.
switch err {
- default: // nil and errors other than the ones listed
- return ns, sa, err
+ case nil:
+ return ns, sa, nil
+ default: // errors other than the ones listed
+ return -1, sa, os.NewSyscallError("accept4", err)
case syscall.ENOSYS: // syscall missing
case syscall.EINVAL: // some Linux use this instead of ENOSYS
case syscall.EACCES: // some Linux use this instead of ENOSYS
syscall.CloseOnExec(ns)
}
if err != nil {
- return -1, nil, err
+ return -1, nil, os.NewSyscallError("accept", err)
}
if err = syscall.SetNonblock(ns, true); err != nil {
closeFunc(ns)
- return -1, nil, err
+ return -1, nil, os.NewSyscallError("setnonblock", err)
}
return ns, sa, nil
}
package net
-import "syscall"
+import (
+ "os"
+ "syscall"
+)
func maxListenerBacklog() int {
// TODO: Implement this
syscall.CloseOnExec(s)
}
syscall.ForkLock.RUnlock()
- return s, err
+ if err != nil {
+ return syscall.InvalidHandle, os.NewSyscallError("socket", err)
+ }
+ return s, nil
}
package net
-import "syscall"
+import (
+ "os"
+ "syscall"
+)
// Wrapper around the socket system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
}
syscall.ForkLock.RUnlock()
if err != nil {
- return -1, err
+ return -1, os.NewSyscallError("socket", err)
}
if err = syscall.SetNonblock(s, true); err != nil {
closeFunc(s)
- return -1, err
+ return -1, os.NewSyscallError("setnonblock", err)
}
return s, nil
}
syscall.CloseOnExec(ns)
}
if err != nil {
- return -1, nil, err
+ return -1, nil, os.NewSyscallError("accept", err)
}
if err = syscall.SetNonblock(ns, true); err != nil {
closeFunc(ns)
- return -1, nil, err
+ return -1, nil, os.NewSyscallError("setnonblock", err)
}
return ns, sa, nil
}
ret := uint32(0)
size := uint32(unsafe.Sizeof(ka))
err := syscall.WSAIoctl(fd.sysfd, syscall.SIO_KEEPALIVE_VALS, (*byte)(unsafe.Pointer(&ka)), size, nil, 0, &ret, nil, 0)
- return os.NewSyscallError("WSAIoctl", err)
+ return os.NewSyscallError("wsaioctl", err)
}