pollserver = p
}
-func newFD(fd, family, sotype int, net string) (f *netFD, err error) {
+func newFD(fd, family, sotype int, net string) (*netFD, error) {
onceStartServer.Do(startServer)
- if e := syscall.SetNonblock(fd, true); e != nil {
- return nil, e
+ if err := syscall.SetNonblock(fd, true); err != nil {
+ return nil, err
}
- f = &netFD{
+ netfd := &netFD{
sysfd: fd,
family: family,
sotype: sotype,
net: net,
}
- f.cr = make(chan bool, 1)
- f.cw = make(chan bool, 1)
- return f, nil
+ netfd.cr = make(chan bool, 1)
+ netfd.cw = make(chan bool, 1)
+ return netfd, nil
}
func (fd *netFD) setAddr(laddr, raddr Addr) {
fd.sysfile = os.NewFile(fd.sysfd, fd.net+":"+ls+"->"+rs)
}
-func (fd *netFD) connect(ra syscall.Sockaddr) (err error) {
- err = syscall.Connect(fd.sysfd, ra)
+func (fd *netFD) connect(ra syscall.Sockaddr) error {
+ err := syscall.Connect(fd.sysfd, ra)
if err == syscall.EINPROGRESS {
pollserver.WaitWrite(fd)
var e int
return
}
-func (fd *netFD) Write(p []byte) (n int, err error) {
+func (fd *netFD) Write(p []byte) (int, error) {
if fd == nil {
return 0, os.EINVAL
}
if fd.sysfile == nil {
return 0, os.EINVAL
}
- nn := 0
+ var err error
+ nn := 0
for {
var n int
n, err = syscall.Write(fd.sysfile.Fd(), p[nn:])
return
}
-func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err error) {
+func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (netfd *netFD, err error) {
if fd == nil || fd.sysfile == nil {
return nil, os.EINVAL
}
syscall.CloseOnExec(s)
syscall.ForkLock.RUnlock()
- if nfd, err = newFD(s, fd.family, fd.sotype, fd.net); err != nil {
+ if netfd, err = newFD(s, fd.family, fd.sotype, fd.net); err != nil {
syscall.Close(s)
return nil, err
}
- lsa, _ := syscall.Getsockname(nfd.sysfd)
- nfd.setAddr(toAddr(lsa), toAddr(rsa))
- return nfd, nil
+ lsa, _ := syscall.Getsockname(netfd.sysfd)
+ netfd.setAddr(toAddr(lsa), toAddr(rsa))
+ return netfd, nil
}
func (fd *netFD) dup() (f *os.File, err error) {
}
syscall.SetKevent(ev, fd, kmode, flags)
- n, err := syscall.Kevent(p.kq, p.kbuf[0:], p.kbuf[0:], nil)
+ n, err := syscall.Kevent(p.kq, p.kbuf[:], p.kbuf[:], nil)
if err != nil {
return false, os.NewSyscallError("kevent", err)
}
}
s.Unlock()
- nn, e := syscall.Kevent(p.kq, nil, p.eventbuf[0:], t)
+ n, err := syscall.Kevent(p.kq, nil, p.eventbuf[:], t)
s.Lock()
- if e != nil {
- if e == syscall.EINTR {
+ if err != nil {
+ if err == syscall.EINTR {
continue
}
return -1, 0, os.NewSyscallError("kevent", nil)
}
- if nn == 0 {
+ if n == 0 {
return -1, 0, nil
}
- p.events = p.eventbuf[0:nn]
+ p.events = p.eventbuf[:n]
}
ev := &p.events[0]
p.events = p.events[1:]
}
syscall.SetKevent(ev, fd, kmode, flags)
- n, e := syscall.Kevent(p.kq, p.kbuf[:], nil, nil)
- if e != nil {
- return false, os.NewSyscallError("kevent", e)
+ n, err := syscall.Kevent(p.kq, p.kbuf[:], nil, nil)
+ if err != nil {
+ return false, os.NewSyscallError("kevent", err)
}
if n != 1 || (ev.Flags&syscall.EV_ERROR) == 0 || int(ev.Ident) != fd || int(ev.Filter) != kmode {
- return false, os.NewSyscallError("kqueue phase error", e)
+ return false, os.NewSyscallError("kqueue phase error", err)
}
if ev.Data != 0 {
return false, syscall.Errno(int(ev.Data))
}
s.Unlock()
- nn, e := syscall.Kevent(p.kq, nil, p.eventbuf[:], t)
+ n, err := syscall.Kevent(p.kq, nil, p.eventbuf[:], t)
s.Lock()
- if e != nil {
- if e == syscall.EINTR {
+ if err != nil {
+ if err == syscall.EINTR {
continue
}
- return -1, 0, os.NewSyscallError("kevent", e)
+ return -1, 0, os.NewSyscallError("kevent", err)
}
- if nn == 0 {
+ if n == 0 {
return -1, 0, nil
}
- p.events = p.eventbuf[0:nn]
+ p.events = p.eventbuf[:n]
}
ev := &p.events[0]
p.events = p.events[1:]
func newpollster() (p *pollster, err error) {
p = new(pollster)
- var e error
-
- if p.epfd, e = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC); e != nil {
- if e != syscall.ENOSYS {
- return nil, os.NewSyscallError("epoll_create1", e)
+ if p.epfd, err = syscall.EpollCreate1(syscall.EPOLL_CLOEXEC); err != nil {
+ if err != syscall.ENOSYS {
+ return nil, os.NewSyscallError("epoll_create1", err)
}
// The arg to epoll_create is a hint to the kernel
// about the number of FDs we will care about.
// We don't know, and since 2.6.8 the kernel ignores it anyhow.
- if p.epfd, e = syscall.EpollCreate(16); e != nil {
- return nil, os.NewSyscallError("epoll_create", e)
+ if p.epfd, err = syscall.EpollCreate(16); err != nil {
+ return nil, os.NewSyscallError("epoll_create", err)
}
syscall.CloseOnExec(p.epfd)
}
} else {
op = syscall.EPOLL_CTL_ADD
}
- if e := syscall.EpollCtl(p.epfd, op, fd, &p.ctlEvent); e != nil {
- return false, os.NewSyscallError("epoll_ctl", e)
+ if err := syscall.EpollCtl(p.epfd, op, fd, &p.ctlEvent); err != nil {
+ return false, os.NewSyscallError("epoll_ctl", err)
}
p.events[fd] = p.ctlEvent.Events
return false, nil
if int32(events)&^syscall.EPOLLONESHOT != 0 {
p.ctlEvent.Fd = int32(fd)
p.ctlEvent.Events = events
- if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_MOD, fd, &p.ctlEvent); e != nil {
- print("Epoll modify fd=", fd, ": ", e.Error(), "\n")
+ if err := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_MOD, fd, &p.ctlEvent); err != nil {
+ print("Epoll modify fd=", fd, ": ", err.Error(), "\n")
}
p.events[fd] = events
} else {
- if e := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_DEL, fd, nil); e != nil {
- print("Epoll delete fd=", fd, ": ", e.Error(), "\n")
+ if err := syscall.EpollCtl(p.epfd, syscall.EPOLL_CTL_DEL, fd, nil); err != nil {
+ print("Epoll delete fd=", fd, ": ", err.Error(), "\n")
}
delete(p.events, fd)
}
}
s.Unlock()
- n, e := syscall.EpollWait(p.epfd, p.waitEventBuf[0:], msec)
+ n, err := syscall.EpollWait(p.epfd, p.waitEventBuf[0:], msec)
s.Lock()
- if e != nil {
- if e == syscall.EAGAIN || e == syscall.EINTR {
+ if err != nil {
+ if err == syscall.EAGAIN || err == syscall.EINTR {
continue
}
- return -1, 0, os.NewSyscallError("epoll_wait", e)
+ return -1, 0, os.NewSyscallError("epoll_wait", err)
}
if n == 0 {
return -1, 0, nil
}
syscall.SetKevent(ev, fd, kmode, flags)
- n, e := syscall.Kevent(p.kq, p.kbuf[:], nil, nil)
- if e != nil {
- return false, os.NewSyscallError("kevent", e)
+ n, err := syscall.Kevent(p.kq, p.kbuf[:], nil, nil)
+ if err != nil {
+ return false, os.NewSyscallError("kevent", err)
}
if n != 1 || (ev.Flags&syscall.EV_ERROR) == 0 || int(ev.Ident) != fd || int(ev.Filter) != kmode {
- return false, os.NewSyscallError("kqueue phase error", e)
+ return false, os.NewSyscallError("kqueue phase error", err)
}
if ev.Data != 0 {
return false, syscall.Errno(int(ev.Data))
}
s.Unlock()
- nn, e := syscall.Kevent(p.kq, nil, p.eventbuf[:], t)
+ n, err := syscall.Kevent(p.kq, nil, p.eventbuf[:], t)
s.Lock()
- if e != nil {
- if e == syscall.EINTR {
+ if err != nil {
+ if err == syscall.EINTR {
continue
}
- return -1, 0, os.NewSyscallError("kevent", e)
+ return -1, 0, os.NewSyscallError("kevent", err)
}
- if nn == 0 {
+ if n == 0 {
return -1, 0, nil
}
- p.events = p.eventbuf[0:nn]
+ p.events = p.eventbuf[:n]
}
ev := &p.events[0]
p.events = p.events[1:]
}
syscall.SetKevent(ev, fd, kmode, flags)
- n, e := syscall.Kevent(p.kq, p.kbuf[:], nil, nil)
- if e != nil {
- return false, os.NewSyscallError("kevent", e)
+ n, err := syscall.Kevent(p.kq, p.kbuf[:], nil, nil)
+ if err != nil {
+ return false, os.NewSyscallError("kevent", err)
}
if n != 1 || (ev.Flags&syscall.EV_ERROR) == 0 || int(ev.Ident) != fd || int(ev.Filter) != kmode {
- return false, os.NewSyscallError("kqueue phase error", e)
+ return false, os.NewSyscallError("kqueue phase error", err)
}
if ev.Data != 0 {
return false, syscall.Errno(int(ev.Data))
}
s.Unlock()
- nn, e := syscall.Kevent(p.kq, nil, p.eventbuf[:], t)
+ n, err := syscall.Kevent(p.kq, nil, p.eventbuf[:], t)
s.Lock()
- if e != nil {
- if e == syscall.EINTR {
+ if err != nil {
+ if err == syscall.EINTR {
continue
}
- return -1, 0, os.NewSyscallError("kevent", e)
+ return -1, 0, os.NewSyscallError("kevent", err)
}
- if nn == 0 {
+ if n == 0 {
return -1, 0, nil
}
- p.events = p.eventbuf[0:nn]
+ p.events = p.eventbuf[:n]
}
ev := &p.events[0]
p.events = p.events[1:]
}
}
-func closesocket(s syscall.Handle) (err error) {
+func closesocket(s syscall.Handle) error {
return syscall.Closesocket(s)
}
type anOpIface interface {
Op() *anOp
Name() string
- Submit() (err error)
+ Submit() error
}
// IO completion result parameters.
// inline, or, if a deadline is employed, passes the request onto
// a special goroutine and waits for completion or cancels request.
// deadline is unix nanos.
-func (s *ioSrv) ExecIO(oi anOpIface, deadline int64) (n int, err error) {
- var e error
+func (s *ioSrv) ExecIO(oi anOpIface, deadline int64) (int, error) {
+ var err error
o := oi.Op()
if deadline != 0 {
// Send request to a special dedicated thread,
// so it can stop the io with CancelIO later.
s.submchan <- oi
- e = <-o.errnoc
+ err = <-o.errnoc
} else {
- e = oi.Submit()
+ err = oi.Submit()
}
- switch e {
+ switch err {
case nil:
// IO completed immediately, but we need to get our completion message anyway.
case syscall.ERROR_IO_PENDING:
// IO started, and we have to wait for its completion.
default:
- return 0, &OpError{oi.Name(), o.fd.net, o.fd.laddr, e}
+ return 0, &OpError{oi.Name(), o.fd.net, o.fd.laddr, err}
}
// Wait for our request to complete.
var r ioResult
wio sync.Mutex
}
-func allocFD(fd syscall.Handle, family, sotype int, net string) (f *netFD) {
- f = &netFD{
+func allocFD(fd syscall.Handle, family, sotype int, net string) *netFD {
+ netfd := &netFD{
sysfd: fd,
family: family,
sotype: sotype,
net: net,
}
- runtime.SetFinalizer(f, (*netFD).Close)
- return f
+ runtime.SetFinalizer(netfd, (*netFD).Close)
+ return netfd
}
-func newFD(fd syscall.Handle, family, proto int, net string) (f *netFD, err error) {
+func newFD(fd syscall.Handle, family, proto int, net string) (*netFD, error) {
if initErr != nil {
return nil, initErr
}
onceStartServer.Do(startServer)
// Associate our socket with resultsrv.iocp.
- if _, e := syscall.CreateIoCompletionPort(syscall.Handle(fd), resultsrv.iocp, 0, 0); e != nil {
- return nil, e
+ if _, err := syscall.CreateIoCompletionPort(syscall.Handle(fd), resultsrv.iocp, 0, 0); err != nil {
+ return nil, err
}
return allocFD(fd, family, proto, net), nil
}
fd.raddr = raddr
}
-func (fd *netFD) connect(ra syscall.Sockaddr) (err error) {
+func (fd *netFD) connect(ra syscall.Sockaddr) error {
return syscall.Connect(fd.sysfd, ra)
}
bufOp
}
-func (o *readOp) Submit() (err error) {
+func (o *readOp) Submit() error {
var d, f uint32
return syscall.WSARecv(syscall.Handle(o.fd.sysfd), &o.buf, 1, &d, &f, &o.o, nil)
}
return "WSARecv"
}
-func (fd *netFD) Read(buf []byte) (n int, err error) {
+func (fd *netFD) Read(buf []byte) (int, error) {
if fd == nil {
return 0, os.EINVAL
}
}
var o readOp
o.Init(fd, buf, 'r')
- n, err = iosrv.ExecIO(&o, fd.rdeadline)
+ n, err := iosrv.ExecIO(&o, fd.rdeadline)
if err == nil && n == 0 {
err = io.EOF
}
- return
+ return n, err
}
// ReadFrom from network.
rsan int32
}
-func (o *readFromOp) Submit() (err error) {
+func (o *readFromOp) Submit() error {
var d, f uint32
return syscall.WSARecvFrom(o.fd.sysfd, &o.buf, 1, &d, &f, &o.rsa, &o.rsan, &o.o, nil)
}
bufOp
}
-func (o *writeOp) Submit() (err error) {
+func (o *writeOp) Submit() error {
var d uint32
return syscall.WSASend(o.fd.sysfd, &o.buf, 1, &d, 0, &o.o, nil)
}
return "WSASend"
}
-func (fd *netFD) Write(buf []byte) (n int, err error) {
+func (fd *netFD) Write(buf []byte) (int, error) {
if fd == nil {
return 0, os.EINVAL
}
sa syscall.Sockaddr
}
-func (o *writeToOp) Submit() (err error) {
+func (o *writeToOp) Submit() error {
var d uint32
return syscall.WSASendto(o.fd.sysfd, &o.buf, 1, &d, 0, o.sa, &o.o, nil)
}
return "WSASendto"
}
-func (fd *netFD) WriteTo(buf []byte, sa syscall.Sockaddr) (n int, err error) {
+func (fd *netFD) WriteTo(buf []byte, sa syscall.Sockaddr) (int, error) {
if fd == nil {
return 0, os.EINVAL
}
attrs [2]syscall.RawSockaddrAny // space for local and remote address only
}
-func (o *acceptOp) Submit() (err error) {
+func (o *acceptOp) Submit() error {
var d uint32
l := uint32(unsafe.Sizeof(o.attrs[0]))
return syscall.AcceptEx(o.fd.sysfd, o.newsock,
return "AcceptEx"
}
-func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err error) {
+func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (*netFD, error) {
if fd == nil || fd.sysfd == syscall.InvalidHandle {
return nil, os.EINVAL
}
// Get new socket.
// See ../syscall/exec.go for description of ForkLock.
syscall.ForkLock.RLock()
- s, e := syscall.Socket(fd.family, fd.sotype, 0)
- if e != nil {
+ s, err := syscall.Socket(fd.family, fd.sotype, 0)
+ if err != nil {
syscall.ForkLock.RUnlock()
- return nil, e
+ return nil, err
}
syscall.CloseOnExec(s)
syscall.ForkLock.RUnlock()
// Associate our new socket with IOCP.
onceStartServer.Do(startServer)
- if _, e = syscall.CreateIoCompletionPort(s, resultsrv.iocp, 0, 0); e != nil {
- return nil, &OpError{"CreateIoCompletionPort", fd.net, fd.laddr, e}
+ if _, err := syscall.CreateIoCompletionPort(s, resultsrv.iocp, 0, 0); err != nil {
+ return nil, &OpError{"CreateIoCompletionPort", fd.net, fd.laddr, err}
}
// Submit accept request.
}
// Inherit properties of the listening socket.
- e = syscall.Setsockopt(s, syscall.SOL_SOCKET, syscall.SO_UPDATE_ACCEPT_CONTEXT, (*byte)(unsafe.Pointer(&fd.sysfd)), int32(unsafe.Sizeof(fd.sysfd)))
- if e != nil {
+ 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 {
closesocket(s)
- return nil, e
+ return nil, err
}
// Get local and peer addr out of AcceptEx buffer.
lsa, _ := lrsa.Sockaddr()
rsa, _ := rrsa.Sockaddr()
- nfd = allocFD(s, fd.family, fd.sotype, fd.net)
- nfd.setAddr(toAddr(lsa), toAddr(rsa))
- return nfd, nil
+ netfd := allocFD(s, fd.family, fd.sotype, fd.net)
+ netfd.setAddr(toAddr(lsa), toAddr(rsa))
+ return netfd, nil
}
// Unimplemented functions.
-func (fd *netFD) dup() (f *os.File, err error) {
+func (fd *netFD) dup() (*os.File, error) {
// TODO: Implement this
return nil, os.NewSyscallError("dup", syscall.EWINDOWS)
}
"syscall"
)
-func newFileFD(f *os.File) (nfd *netFD, err error) {
- fd, errno := syscall.Dup(f.Fd())
- if errno != nil {
- return nil, os.NewSyscallError("dup", errno)
+func newFileFD(f *os.File) (*netFD, error) {
+ fd, err := syscall.Dup(f.Fd())
+ if err != nil {
+ return nil, os.NewSyscallError("dup", err)
}
- proto, errno := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_TYPE)
- if errno != nil {
- return nil, os.NewSyscallError("getsockopt", errno)
+ proto, err := syscall.GetsockoptInt(fd, syscall.SOL_SOCKET, syscall.SO_TYPE)
+ if err != nil {
+ return nil, os.NewSyscallError("getsockopt", err)
}
family := syscall.AF_UNSPEC
sa, _ = syscall.Getpeername(fd)
raddr := toAddr(sa)
- if nfd, err = newFD(fd, family, proto, laddr.Network()); err != nil {
+ netfd, err := newFD(fd, family, proto, laddr.Network())
+ if err != nil {
return nil, err
}
- nfd.setAddr(laddr, raddr)
- return nfd, nil
+ netfd.setAddr(laddr, raddr)
+ return netfd, nil
}
// FileConn returns a copy of the network connection corresponding to
// addresses for all network interfaces. Otherwise it returns
// addresses for a specific interface.
func interfaceMulticastAddrTable(ifindex int) ([]Addr, error) {
- var (
- tab []byte
- e error
- msgs []syscall.RoutingMessage
- ifmat []Addr
- )
-
- tab, e = syscall.RouteRIB(syscall.NET_RT_IFLIST2, ifindex)
- if e != nil {
- return nil, os.NewSyscallError("route rib", e)
+ tab, err := syscall.RouteRIB(syscall.NET_RT_IFLIST2, ifindex)
+ if err != nil {
+ return nil, os.NewSyscallError("route rib", err)
}
- msgs, e = syscall.ParseRoutingMessage(tab)
- if e != nil {
- return nil, os.NewSyscallError("route message", e)
+ msgs, err := syscall.ParseRoutingMessage(tab)
+ if err != nil {
+ return nil, os.NewSyscallError("route message", err)
}
+ var ifmat []Addr
for _, m := range msgs {
switch v := m.(type) {
case *syscall.InterfaceMulticastAddrMessage:
}
}
}
-
return ifmat, nil
}
func newMulticastAddr(m *syscall.InterfaceMulticastAddrMessage) ([]Addr, error) {
- var ifmat []Addr
-
- sas, e := syscall.ParseRoutingSockaddr(m)
- if e != nil {
- return nil, os.NewSyscallError("route sockaddr", e)
+ sas, err := syscall.ParseRoutingSockaddr(m)
+ if err != nil {
+ return nil, os.NewSyscallError("route sockaddr", err)
}
+ var ifmat []Addr
for _, s := range sas {
switch v := s.(type) {
case *syscall.SockaddrInet4:
ifmat = append(ifmat, ifma.toAddr())
}
}
-
return ifmat, nil
}
// addresses for all network interfaces. Otherwise it returns
// addresses for a specific interface.
func interfaceMulticastAddrTable(ifindex int) ([]Addr, error) {
- var (
- tab []byte
- e error
- msgs []syscall.RoutingMessage
- ifmat []Addr
- )
-
- tab, e = syscall.RouteRIB(syscall.NET_RT_IFMALIST, ifindex)
- if e != nil {
- return nil, os.NewSyscallError("route rib", e)
+ tab, err := syscall.RouteRIB(syscall.NET_RT_IFMALIST, ifindex)
+ if err != nil {
+ return nil, os.NewSyscallError("route rib", err)
}
- msgs, e = syscall.ParseRoutingMessage(tab)
- if e != nil {
- return nil, os.NewSyscallError("route message", e)
+ msgs, err := syscall.ParseRoutingMessage(tab)
+ if err != nil {
+ return nil, os.NewSyscallError("route message", err)
}
+ var ifmat []Addr
for _, m := range msgs {
switch v := m.(type) {
case *syscall.InterfaceMulticastAddrMessage:
}
}
}
-
return ifmat, nil
}
func newMulticastAddr(m *syscall.InterfaceMulticastAddrMessage) ([]Addr, error) {
- var ifmat []Addr
-
- sas, e := syscall.ParseRoutingSockaddr(m)
- if e != nil {
- return nil, os.NewSyscallError("route sockaddr", e)
+ sas, err := syscall.ParseRoutingSockaddr(m)
+ if err != nil {
+ return nil, os.NewSyscallError("route sockaddr", err)
}
+ var ifmat []Addr
for _, s := range sas {
switch v := s.(type) {
case *syscall.SockaddrInet4:
ifmat = append(ifmat, ifma.toAddr())
}
}
-
return ifmat, nil
}
// network interfaces. Otheriwse it returns a mapping of a specific
// interface.
func interfaceTable(ifindex int) ([]Interface, error) {
- var ift []Interface
-
tab, err := syscall.NetlinkRIB(syscall.RTM_GETLINK, syscall.AF_UNSPEC)
if err != nil {
return nil, os.NewSyscallError("netlink rib", err)
return nil, os.NewSyscallError("netlink message", err)
}
+ var ift []Interface
for _, m := range msgs {
switch m.Header.Type {
case syscall.NLMSG_DONE:
}
}
}
-
done:
return ift, nil
}
if err != nil {
return nil, err
}
-
return ifat, nil
}
func addrTable(msgs []syscall.NetlinkMessage, ifindex int) ([]Addr, error) {
var ifat []Addr
-
for _, m := range msgs {
switch m.Header.Type {
case syscall.NLMSG_DONE:
}
}
}
-
done:
return ifat, nil
}
err error
ifi *Interface
)
-
if ifindex > 0 {
ifi, err = InterfaceByIndex(ifindex)
if err != nil {
return nil, err
}
}
-
ifmat4 := parseProcNetIGMP(ifi)
ifmat6 := parseProcNetIGMP6(ifi)
-
return append(ifmat4, ifmat6...), nil
}
func parseProcNetIGMP(ifi *Interface) []Addr {
- var (
- ifmat []Addr
- name string
- )
-
fd, err := open("/proc/net/igmp")
if err != nil {
return nil
}
defer fd.close()
+ var (
+ ifmat []Addr
+ name string
+ )
fd.readLine() // skip first line
b := make([]byte, IPv4len)
for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
name = f[1]
}
}
-
return ifmat
}
func parseProcNetIGMP6(ifi *Interface) []Addr {
- var ifmat []Addr
-
fd, err := open("/proc/net/igmp6")
if err != nil {
return nil
}
defer fd.close()
+ var ifmat []Addr
b := make([]byte, IPv6len)
for l, ok := fd.readLine(); ok; l, ok = fd.readLine() {
f := getFields(l)
}
}
-
return ifmat
}
b := make([]byte, 1000)
l := uint32(len(b))
a := (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
- e := syscall.GetAdaptersInfo(a, &l)
- if e == syscall.ERROR_BUFFER_OVERFLOW {
+ err := syscall.GetAdaptersInfo(a, &l)
+ if err == syscall.ERROR_BUFFER_OVERFLOW {
b = make([]byte, l)
a = (*syscall.IpAdapterInfo)(unsafe.Pointer(&b[0]))
- e = syscall.GetAdaptersInfo(a, &l)
+ err = syscall.GetAdaptersInfo(a, &l)
}
- if e != nil {
- return nil, os.NewSyscallError("GetAdaptersInfo", e)
+ if err != nil {
+ return nil, os.NewSyscallError("GetAdaptersInfo", err)
}
return a, nil
}
func getInterfaceList() ([]syscall.InterfaceInfo, error) {
- s, e := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
- if e != nil {
- return nil, os.NewSyscallError("Socket", e)
+ s, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_DGRAM, syscall.IPPROTO_UDP)
+ if err != nil {
+ return nil, os.NewSyscallError("Socket", err)
}
defer syscall.Closesocket(s)
ii := [20]syscall.InterfaceInfo{}
ret := uint32(0)
size := uint32(unsafe.Sizeof(ii))
- e = syscall.WSAIoctl(s, syscall.SIO_GET_INTERFACE_LIST, nil, 0, (*byte)(unsafe.Pointer(&ii[0])), size, &ret, nil, 0)
- if e != nil {
- return nil, os.NewSyscallError("WSAIoctl", e)
+ err = syscall.WSAIoctl(s, syscall.SIO_GET_INTERFACE_LIST, nil, 0, (*byte)(unsafe.Pointer(&ii[0])), size, &ret, nil, 0)
+ if err != nil {
+ return nil, os.NewSyscallError("WSAIoctl", err)
}
c := ret / uint32(unsafe.Sizeof(ii[0]))
return ii[:c-1], nil
// network interfaces. Otheriwse it returns a mapping of a specific
// interface.
func interfaceTable(ifindex int) ([]Interface, error) {
- ai, e := getAdapterList()
- if e != nil {
- return nil, e
+ ai, err := getAdapterList()
+ if err != nil {
+ return nil, err
}
- ii, e := getInterfaceList()
- if e != nil {
- return nil, e
+ ii, err := getInterfaceList()
+ if err != nil {
+ return nil, err
}
var ift []Interface
// for all network interfaces. Otherwise it returns addresses
// for a specific interface.
func interfaceAddrTable(ifindex int) ([]Addr, error) {
- ai, e := getAdapterList()
- if e != nil {
- return nil, e
+ ai, err := getAdapterList()
+ if err != nil {
+ return nil, err
}
var ifat []Addr
// Convert "host:port" into IP address and port.
func hostPortToIP(net, hostport string) (ip IP, iport int, err error) {
- var (
- addr IP
- p, i int
- ok bool
- )
host, port, err := SplitHostPort(hostport)
if err != nil {
- goto Error
+ return nil, 0, err
}
+ var addr IP
if host != "" {
// Try as an IP address.
addr = ParseIP(host)
filter = ipv6only
}
// Not an IP address. Try as a DNS name.
- addrs, err1 := LookupHost(host)
- if err1 != nil {
- err = err1
- goto Error
+ addrs, err := LookupHost(host)
+ if err != nil {
+ return nil, 0, err
}
addr = firstFavoriteAddr(filter, addrs)
if addr == nil {
// should not happen
- err = &AddrError{"LookupHost returned no suitable address", addrs[0]}
- goto Error
+ return nil, 0, &AddrError{"LookupHost returned no suitable address", addrs[0]}
}
}
}
- p, i, ok = dtoi(port, 0)
+ p, i, ok := dtoi(port, 0)
if !ok || i != len(port) {
p, err = LookupPort(net, port)
if err != nil {
- goto Error
+ return nil, 0, err
}
}
if p < 0 || p > 0xFFFF {
- err = &AddrError{"invalid port", port}
- goto Error
+ return nil, 0, &AddrError{"invalid port", port}
}
return addr, p, nil
-Error:
- return nil, 0, err
}
// parsePlan9Addr parses address of the form [ip!]port (e.g. 127.0.0.1!80).
func parsePlan9Addr(s string) (ip IP, iport int, err error) {
- var (
- addr IP
- p, i int
- ok bool
- )
- addr = IPv4zero // address contains port only
+ addr := IPv4zero // address contains port only
i = byteIndex(s, '!')
if i >= 0 {
addr = ParseIP(s[:i])
if addr == nil {
- err = errors.New("net: parsing IP failed")
- goto Error
+ return nil, 0, errors.New("net: parsing IP failed")
}
}
- p, _, ok = dtoi(s[i+1:], 0)
+ p, _, ok := dtoi(s[i+1:], 0)
if !ok {
- err = errors.New("net: parsing port failed")
- goto Error
+ return nil, 0, errors.New("net: parsing port failed")
}
if p < 0 || p > 0xFFFF {
- err = &AddrError{"invalid port", string(p)}
- goto Error
+ return nil, 0, &AddrError{"invalid port", string(p)}
}
return addr, p, nil
-
-Error:
- return nil, 0, err
}
func readPlan9Addr(proto, filename string) (addr Addr, err error) {
func lookupProtocol(name string) (proto int, err error) {
protoentLock.Lock()
defer protoentLock.Unlock()
- p, e := syscall.GetProtoByName(name)
- if e != nil {
- return 0, os.NewSyscallError("GetProtoByName", e)
+ p, err := syscall.GetProtoByName(name)
+ if err != nil {
+ return 0, os.NewSyscallError("GetProtoByName", err)
}
return int(p.Proto), nil
}
func lookupIP(name string) (addrs []IP, err error) {
hostentLock.Lock()
defer hostentLock.Unlock()
- h, e := syscall.GetHostByName(name)
- if e != nil {
- return nil, os.NewSyscallError("GetHostByName", e)
+ h, err := syscall.GetHostByName(name)
+ if err != nil {
+ return nil, os.NewSyscallError("GetHostByName", err)
}
switch h.AddrType {
case syscall.AF_INET:
}
serventLock.Lock()
defer serventLock.Unlock()
- s, e := syscall.GetServByName(service, network)
- if e != nil {
- return 0, os.NewSyscallError("GetServByName", e)
+ s, err := syscall.GetServByName(service, network)
+ if err != nil {
+ return 0, os.NewSyscallError("GetServByName", err)
}
return int(syscall.Ntohs(s.Port)), nil
}
}
for _, tt := range multicastUDPTests {
- var (
- ifi *Interface
- found bool
- )
if tt.ipv6 && (!supportsIPv6 || os.Getuid() != 0) {
continue
}
if err != nil {
t.Fatalf("Interfaces failed: %v", err)
}
+ var ifi *Interface
for _, x := range ift {
if x.Flags&tt.flags == tt.flags {
ifi = &x
if err != nil {
t.Fatalf("MulticastAddrs failed: %v", err)
}
+ var found bool
for _, ifma := range ifmat {
if ifma.(*IPAddr).IP.Equal(tt.gaddr) {
found = true
return
}
for i, tt := range dialErrorTests {
- c, e := Dial(tt.Net, tt.Raddr)
+ c, err := Dial(tt.Net, tt.Raddr)
if c != nil {
c.Close()
}
- if e == nil {
+ if err == nil {
t.Errorf("#%d: nil error, want match for %#q", i, tt.Pattern)
continue
}
- s := e.Error()
+ s := err.Error()
match, _ := regexp.MatchString(tt.Pattern, s)
if !match {
t.Errorf("#%d: %q, want match for %#q", i, s, tt.Pattern)
func TestReverseAddress(t *testing.T) {
for i, tt := range revAddrTests {
- a, e := reverseaddr(tt.Addr)
- if len(tt.ErrPrefix) > 0 && e == nil {
+ a, err := reverseaddr(tt.Addr)
+ if len(tt.ErrPrefix) > 0 && err == nil {
t.Errorf("#%d: expected %q, got <nil> (error)", i, tt.ErrPrefix)
continue
}
- if len(tt.ErrPrefix) == 0 && e != nil {
- t.Errorf("#%d: expected <nil>, got %q (error)", i, e)
+ if len(tt.ErrPrefix) == 0 && err != nil {
+ t.Errorf("#%d: expected <nil>, got %q (error)", i, err)
}
- if e != nil && e.(*DNSError).Err != tt.ErrPrefix {
- t.Errorf("#%d: expected %q, got %q (mismatched error)", i, tt.ErrPrefix, e.(*DNSError).Err)
+ if err != nil && err.(*DNSError).Err != tt.ErrPrefix {
+ t.Errorf("#%d: expected %q, got %q (mismatched error)", i, tt.ErrPrefix, err.(*DNSError).Err)
}
if a != tt.Reverse {
t.Errorf("#%d: expected %q, got %q (reverse address)", i, tt.Reverse, a)
if int64(n) > remain {
n = int(remain)
}
- n, errno := syscall.Sendfile(dst, src, nil, n)
+ n, err1 := syscall.Sendfile(dst, src, nil, n)
if n > 0 {
written += int64(n)
remain -= int64(n)
}
- if n == 0 && errno == nil {
+ if n == 0 && err1 == nil {
break
}
- if errno == syscall.EAGAIN && c.wdeadline >= 0 {
+ if err1 == syscall.EAGAIN && c.wdeadline >= 0 {
pollserver.WaitWrite(c)
continue
}
- if errno != nil {
+ if err1 != nil {
// This includes syscall.ENOSYS (no kernel
// support) and syscall.EINVAL (fd types which
// don't implement sendfile together)
- err = &OpError{"sendfile", c.net, c.raddr, errno}
+ err = &OpError{"sendfile", c.net, c.raddr, err1}
break
}
}
}
func setDeadline(fd *netFD, t time.Time) error {
- if e := setReadDeadline(fd, t); e != nil {
- return e
+ if err := setReadDeadline(fd, t); err != nil {
+ return err
}
return setWriteDeadline(fd, t)
}
// DialTCP connects to the remote address raddr on the network net,
// which must be "tcp", "tcp4", or "tcp6". If laddr is not nil, it is used
// as the local address for the connection.
-func DialTCP(net string, laddr, raddr *TCPAddr) (c *TCPConn, err error) {
+func DialTCP(net string, laddr, raddr *TCPAddr) (*TCPConn, error) {
if raddr == nil {
return nil, &OpError{"dial", net, nil, errMissingAddress}
}
- fd, e := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_STREAM, 0, "dial", sockaddrToTCP)
- if e != nil {
- return nil, e
+ fd, err := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_STREAM, 0, "dial", sockaddrToTCP)
+ if err != nil {
+ return nil, err
}
return newTCPConn(fd), nil
}
// Net must be "tcp", "tcp4", or "tcp6".
// If laddr has a port of 0, it means to listen on some available port.
// The caller can use l.Addr() to retrieve the chosen address.
-func ListenTCP(net string, laddr *TCPAddr) (l *TCPListener, err error) {
+func ListenTCP(net string, laddr *TCPAddr) (*TCPListener, error) {
fd, err := internetSocket(net, laddr.toAddr(), nil, syscall.SOCK_STREAM, 0, "listen", sockaddrToTCP)
if err != nil {
return nil, err
closesocket(fd.sysfd)
return nil, &OpError{"listen", net, laddr, err}
}
- l = new(TCPListener)
+ l := new(TCPListener)
l.fd = fd
return l, nil
}
// DialUDP connects to the remote address raddr on the network net,
// which must be "udp", "udp4", or "udp6". If laddr is not nil, it is used
// as the local address for the connection.
-func DialUDP(net string, laddr, raddr *UDPAddr) (c *UDPConn, err error) {
+func DialUDP(net string, laddr, raddr *UDPAddr) (*UDPConn, error) {
switch net {
case "udp", "udp4", "udp6":
default:
if raddr == nil {
return nil, &OpError{"dial", net, nil, errMissingAddress}
}
- fd, e := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_DGRAM, 0, "dial", sockaddrToUDP)
- if e != nil {
- return nil, e
+ fd, err := internetSocket(net, laddr.toAddr(), raddr.toAddr(), syscall.SOCK_DGRAM, 0, "dial", sockaddrToUDP)
+ if err != nil {
+ return nil, err
}
return newUDPConn(fd), nil
}
// DialUnix connects to the remote address raddr on the network net,
// which must be "unix" or "unixgram". If laddr is not nil, it is used
// as the local address for the connection.
-func DialUnix(net string, laddr, raddr *UnixAddr) (c *UnixConn, err error) {
- fd, e := unixSocket(net, laddr, raddr, "dial")
- if e != nil {
- return nil, e
+func DialUnix(net string, laddr, raddr *UnixAddr) (*UnixConn, error) {
+ fd, err := unixSocket(net, laddr, raddr, "dial")
+ if err != nil {
+ return nil, err
}
return newUnixConn(fd), nil
}
// AcceptUnix accepts the next incoming call and returns the new connection
// and the remote address.
-func (l *UnixListener) AcceptUnix() (c *UnixConn, err error) {
+func (l *UnixListener) AcceptUnix() (*UnixConn, error) {
if l == nil || l.fd == nil {
return nil, os.EINVAL
}
- fd, e := l.fd.accept(sockaddrToUnix)
- if e != nil {
- return nil, e
+ fd, err := l.fd.accept(sockaddrToUnix)
+ if err != nil {
+ return nil, err
}
- c = newUnixConn(fd)
+ c := newUnixConn(fd)
return c, nil
}
// local address laddr. The returned connection c's ReadFrom
// and WriteTo methods can be used to receive and send UDP
// packets with per-packet addressing. The network net must be "unixgram".
-func ListenUnixgram(net string, laddr *UnixAddr) (c *UDPConn, err error) {
+func ListenUnixgram(net string, laddr *UnixAddr) (*UDPConn, error) {
switch net {
case "unixgram":
default:
if laddr == nil {
return nil, &OpError{"listen", net, nil, errMissingAddress}
}
- fd, e := unixSocket(net, laddr, nil, "listen")
- if e != nil {
- return nil, e
+ fd, err := unixSocket(net, laddr, nil, "listen")
+ if err != nil {
+ return nil, err
}
return newUDPConn(fd), nil
}