2008-09-29 14:37:00 -06:00
|
|
|
// Copyright 2009 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.
|
|
|
|
|
|
|
|
// TODO(rsc): All the prints in this file should go to standard error.
|
|
|
|
|
|
|
|
package net
|
|
|
|
|
|
|
|
import (
|
2009-12-15 16:35:38 -07:00
|
|
|
"once"
|
|
|
|
"os"
|
|
|
|
"sync"
|
|
|
|
"syscall"
|
2008-09-29 14:37:00 -06:00
|
|
|
)
|
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
// Network file descriptor.
|
|
|
|
type netFD struct {
|
2009-12-02 00:28:57 -07:00
|
|
|
// locking/lifetime of sysfd
|
2009-12-15 16:35:38 -07:00
|
|
|
sysmu sync.Mutex
|
|
|
|
sysref int
|
|
|
|
closing bool
|
2009-12-02 00:28:57 -07:00
|
|
|
|
2008-09-29 14:37:00 -06:00
|
|
|
// immutable until Close
|
2009-12-15 16:35:38 -07:00
|
|
|
sysfd int
|
|
|
|
family int
|
|
|
|
proto int
|
|
|
|
sysfile *os.File
|
|
|
|
cr chan *netFD
|
|
|
|
cw chan *netFD
|
|
|
|
net string
|
|
|
|
laddr Addr
|
|
|
|
raddr Addr
|
2008-09-29 14:37:00 -06:00
|
|
|
|
2009-03-06 18:51:31 -07:00
|
|
|
// owned by client
|
2009-12-15 16:35:38 -07:00
|
|
|
rdeadline_delta int64
|
|
|
|
rdeadline int64
|
|
|
|
rio sync.Mutex
|
|
|
|
wdeadline_delta int64
|
|
|
|
wdeadline int64
|
|
|
|
wio sync.Mutex
|
2009-03-06 18:51:31 -07:00
|
|
|
|
2008-09-29 14:37:00 -06:00
|
|
|
// owned by fd wait server
|
2009-12-15 16:35:38 -07:00
|
|
|
ncr, ncw int
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
// A pollServer helps FDs determine when to retry a non-blocking
|
2008-09-29 14:37:00 -06:00
|
|
|
// read or write after they get EAGAIN. When an FD needs to wait,
|
|
|
|
// send the fd on s.cr (for a read) or s.cw (for a write) to pass the
|
|
|
|
// request to the poll server. Then receive on fd.cr/fd.cw.
|
2009-02-15 15:18:39 -07:00
|
|
|
// When the pollServer finds that i/o on FD should be possible
|
2008-09-29 14:37:00 -06:00
|
|
|
// again, it will send fd on fd.cr/fd.cw to wake any waiting processes.
|
|
|
|
// This protocol is implemented as s.WaitRead() and s.WaitWrite().
|
|
|
|
//
|
|
|
|
// There is one subtlety: when sending on s.cr/s.cw, the
|
|
|
|
// poll server is probably in a system call, waiting for an fd
|
|
|
|
// to become ready. It's not looking at the request channels.
|
|
|
|
// To resolve this, the poll server waits not just on the FDs it has
|
|
|
|
// been given but also its own pipe. After sending on the
|
|
|
|
// buffered channel s.cr/s.cw, WaitRead/WaitWrite writes a
|
2009-02-15 15:18:39 -07:00
|
|
|
// byte to the pipe, causing the pollServer's poll system call to
|
|
|
|
// return. In response to the pipe being readable, the pollServer
|
2008-09-29 14:37:00 -06:00
|
|
|
// re-polls its request channels.
|
|
|
|
//
|
|
|
|
// Note that the ordering is "send request" and then "wake up server".
|
|
|
|
// If the operations were reversed, there would be a race: the poll
|
|
|
|
// server might wake up and look at the request channel, see that it
|
|
|
|
// was empty, and go back to sleep, all before the requester managed
|
|
|
|
// to send the request. Because the send must complete before the wakeup,
|
|
|
|
// the request channel must be buffered. A buffer of size 1 is sufficient
|
|
|
|
// for any request load. If many processes are trying to submit requests,
|
2009-02-15 15:18:39 -07:00
|
|
|
// one will succeed, the pollServer will read the request, and then the
|
2008-09-29 14:37:00 -06:00
|
|
|
// channel will be empty for the next process's request. A larger buffer
|
|
|
|
// might help batch requests.
|
2009-11-18 14:18:34 -07:00
|
|
|
//
|
2009-12-02 00:28:57 -07:00
|
|
|
// To avoid races in closing, all fd operations are locked and
|
|
|
|
// refcounted. when netFD.Close() is called, it calls syscall.Shutdown
|
|
|
|
// and sets a closing flag. Only when the last reference is removed
|
|
|
|
// will the fd be closed.
|
2008-09-29 14:37:00 -06:00
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
type pollServer struct {
|
2009-12-15 16:35:38 -07:00
|
|
|
cr, cw chan *netFD // buffered >= 1
|
|
|
|
pr, pw *os.File
|
|
|
|
pending map[int]*netFD
|
|
|
|
poll *pollster // low-level OS hooks
|
|
|
|
deadline int64 // next deadline (nsec since 1970)
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-04-17 01:08:24 -06:00
|
|
|
func newPollServer() (s *pollServer, err os.Error) {
|
2009-12-15 16:35:38 -07:00
|
|
|
s = new(pollServer)
|
|
|
|
s.cr = make(chan *netFD, 1)
|
|
|
|
s.cw = make(chan *netFD, 1)
|
2008-09-29 14:37:00 -06:00
|
|
|
if s.pr, s.pw, err = os.Pipe(); err != nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
return nil, err
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
var e int
|
2009-06-01 23:14:39 -06:00
|
|
|
if e = syscall.SetNonblock(s.pr.Fd(), true); e != 0 {
|
|
|
|
Errno:
|
2009-12-15 16:35:38 -07:00
|
|
|
err = &os.PathError{"setnonblock", s.pr.Name(), os.Errno(e)}
|
2008-09-29 14:37:00 -06:00
|
|
|
Error:
|
2009-12-15 16:35:38 -07:00
|
|
|
s.pr.Close()
|
|
|
|
s.pw.Close()
|
|
|
|
return nil, err
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-06-01 23:14:39 -06:00
|
|
|
if e = syscall.SetNonblock(s.pw.Fd(), true); e != 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
goto Errno
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-03-05 16:48:12 -07:00
|
|
|
if s.poll, err = newpollster(); err != nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
goto Error
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-02-06 18:54:26 -07:00
|
|
|
if err = s.poll.AddFD(s.pr.Fd(), 'r', true); err != nil {
|
2009-12-15 16:35:38 -07:00
|
|
|
s.poll.Close()
|
|
|
|
goto Error
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
s.pending = make(map[int]*netFD)
|
|
|
|
go s.Run()
|
|
|
|
return s, nil
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
func (s *pollServer) AddFD(fd *netFD, mode int) {
|
2009-12-15 16:35:38 -07:00
|
|
|
intfd := fd.sysfd
|
2009-04-15 20:01:48 -06:00
|
|
|
if intfd < 0 {
|
|
|
|
// fd closed underfoot
|
|
|
|
if mode == 'r' {
|
2009-11-09 13:07:39 -07:00
|
|
|
fd.cr <- fd
|
2009-04-15 20:01:48 -06:00
|
|
|
} else {
|
2009-11-09 13:07:39 -07:00
|
|
|
fd.cw <- fd
|
2009-04-15 20:01:48 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return
|
2009-04-15 20:01:48 -06:00
|
|
|
}
|
|
|
|
if err := s.poll.AddFD(intfd, mode, false); err != nil {
|
2009-12-15 16:35:38 -07:00
|
|
|
panicln("pollServer AddFD ", intfd, ": ", err.String(), "\n")
|
|
|
|
return
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-12-15 16:35:38 -07:00
|
|
|
var t int64
|
|
|
|
key := intfd << 1
|
2008-09-29 14:37:00 -06:00
|
|
|
if mode == 'r' {
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.ncr++
|
|
|
|
t = fd.rdeadline
|
2008-09-29 14:37:00 -06:00
|
|
|
} else {
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.ncw++
|
|
|
|
key++
|
|
|
|
t = fd.wdeadline
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
s.pending[key] = fd
|
2009-03-06 18:51:31 -07:00
|
|
|
if t > 0 && (s.deadline == 0 || t < s.deadline) {
|
2009-11-09 13:07:39 -07:00
|
|
|
s.deadline = t
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-06-01 23:14:39 -06:00
|
|
|
func (s *pollServer) LookupFD(fd int, mode int) *netFD {
|
2009-12-15 16:35:38 -07:00
|
|
|
key := fd << 1
|
2008-09-29 14:37:00 -06:00
|
|
|
if mode == 'w' {
|
2009-11-09 13:07:39 -07:00
|
|
|
key++
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
netfd, ok := s.pending[key]
|
2008-09-29 14:37:00 -06:00
|
|
|
if !ok {
|
2009-11-09 13:07:39 -07:00
|
|
|
return nil
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
s.pending[key] = nil, false
|
|
|
|
return netfd
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-03-06 18:51:31 -07:00
|
|
|
func (s *pollServer) WakeFD(fd *netFD, mode int) {
|
|
|
|
if mode == 'r' {
|
|
|
|
for fd.ncr > 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.ncr--
|
|
|
|
fd.cr <- fd
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
} else {
|
|
|
|
for fd.ncw > 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.ncw--
|
|
|
|
fd.cw <- fd
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *pollServer) Now() int64 {
|
2009-12-15 16:35:38 -07:00
|
|
|
sec, nsec, err := os.Time()
|
2009-03-06 18:51:31 -07:00
|
|
|
if err != nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
panic("net: os.Time: ", err.String())
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
nsec += sec * 1e9
|
|
|
|
return nsec
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
func (s *pollServer) CheckDeadlines() {
|
2009-12-15 16:35:38 -07:00
|
|
|
now := s.Now()
|
2009-03-06 18:51:31 -07:00
|
|
|
// TODO(rsc): This will need to be handled more efficiently,
|
|
|
|
// probably with a heap indexed by wakeup time.
|
|
|
|
|
2009-12-15 16:35:38 -07:00
|
|
|
var next_deadline int64
|
2009-03-06 18:51:31 -07:00
|
|
|
for key, fd := range s.pending {
|
2009-12-15 16:35:38 -07:00
|
|
|
var t int64
|
|
|
|
var mode int
|
2009-03-06 18:51:31 -07:00
|
|
|
if key&1 == 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
mode = 'r'
|
2009-03-06 18:51:31 -07:00
|
|
|
} else {
|
2009-11-09 13:07:39 -07:00
|
|
|
mode = 'w'
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
if mode == 'r' {
|
2009-11-09 13:07:39 -07:00
|
|
|
t = fd.rdeadline
|
2009-03-06 18:51:31 -07:00
|
|
|
} else {
|
2009-11-09 13:07:39 -07:00
|
|
|
t = fd.wdeadline
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
if t > 0 {
|
|
|
|
if t <= now {
|
2009-12-15 16:35:38 -07:00
|
|
|
s.pending[key] = nil, false
|
2009-03-06 18:51:31 -07:00
|
|
|
if mode == 'r' {
|
2009-12-15 16:35:38 -07:00
|
|
|
s.poll.DelFD(fd.sysfd, mode)
|
|
|
|
fd.rdeadline = -1
|
2009-03-06 18:51:31 -07:00
|
|
|
} else {
|
2009-12-15 16:35:38 -07:00
|
|
|
s.poll.DelFD(fd.sysfd, mode)
|
|
|
|
fd.wdeadline = -1
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
s.WakeFD(fd, mode)
|
2009-03-06 18:51:31 -07:00
|
|
|
} else if next_deadline == 0 || t < next_deadline {
|
2009-11-09 13:07:39 -07:00
|
|
|
next_deadline = t
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
s.deadline = next_deadline
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
func (s *pollServer) Run() {
|
2009-12-15 16:35:38 -07:00
|
|
|
var scratch [100]byte
|
2008-09-29 14:37:00 -06:00
|
|
|
for {
|
2009-12-15 16:35:38 -07:00
|
|
|
var t = s.deadline
|
2009-03-06 18:51:31 -07:00
|
|
|
if t > 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
t = t - s.Now()
|
2009-03-06 18:51:31 -07:00
|
|
|
if t < 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
s.CheckDeadlines()
|
|
|
|
continue
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
fd, mode, err := s.poll.WaitFD(t)
|
2008-09-29 14:37:00 -06:00
|
|
|
if err != nil {
|
2009-12-15 16:35:38 -07:00
|
|
|
print("pollServer WaitFD: ", err.String(), "\n")
|
|
|
|
return
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-03-06 18:51:31 -07:00
|
|
|
if fd < 0 {
|
|
|
|
// Timeout happened.
|
2009-12-15 16:35:38 -07:00
|
|
|
s.CheckDeadlines()
|
|
|
|
continue
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
2009-02-06 18:54:26 -07:00
|
|
|
if fd == s.pr.Fd() {
|
2008-09-29 14:37:00 -06:00
|
|
|
// Drain our wakeup pipe.
|
2009-09-15 10:41:59 -06:00
|
|
|
for nn, _ := s.pr.Read(&scratch); nn > 0; {
|
2009-11-09 13:07:39 -07:00
|
|
|
nn, _ = s.pr.Read(&scratch)
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
// Read from channels
|
|
|
|
for fd, ok := <-s.cr; ok; fd, ok = <-s.cr {
|
2009-11-09 13:07:39 -07:00
|
|
|
s.AddFD(fd, 'r')
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
for fd, ok := <-s.cw; ok; fd, ok = <-s.cw {
|
2009-11-09 13:07:39 -07:00
|
|
|
s.AddFD(fd, 'w')
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
} else {
|
2009-12-15 16:35:38 -07:00
|
|
|
netfd := s.LookupFD(fd, mode)
|
2008-09-29 14:37:00 -06:00
|
|
|
if netfd == nil {
|
2009-12-15 16:35:38 -07:00
|
|
|
print("pollServer: unexpected wakeup for fd=", netfd, " mode=", string(mode), "\n")
|
|
|
|
continue
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
s.WakeFD(netfd, mode)
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-11-05 00:16:46 -07:00
|
|
|
var wakeupbuf [1]byte
|
|
|
|
|
2009-12-15 16:35:38 -07:00
|
|
|
func (s *pollServer) Wakeup() { s.pw.Write(&wakeupbuf) }
|
2008-09-29 14:37:00 -06:00
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
func (s *pollServer) WaitRead(fd *netFD) {
|
2009-12-15 16:35:38 -07:00
|
|
|
s.cr <- fd
|
|
|
|
s.Wakeup()
|
|
|
|
<-fd.cr
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
func (s *pollServer) WaitWrite(fd *netFD) {
|
2009-12-15 16:35:38 -07:00
|
|
|
s.cw <- fd
|
|
|
|
s.Wakeup()
|
|
|
|
<-fd.cw
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
// Network FD methods.
|
2009-02-15 15:18:39 -07:00
|
|
|
// All the network FDs use a single pollServer.
|
2008-09-29 14:37:00 -06:00
|
|
|
|
2009-02-15 15:18:39 -07:00
|
|
|
var pollserver *pollServer
|
2008-09-29 14:37:00 -06:00
|
|
|
|
2009-11-02 19:37:30 -07:00
|
|
|
func startServer() {
|
2009-12-15 16:35:38 -07:00
|
|
|
p, err := newPollServer()
|
2008-09-29 14:37:00 -06:00
|
|
|
if err != nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
print("Start pollServer: ", err.String(), "\n")
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
pollserver = p
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-11-02 19:37:30 -07:00
|
|
|
func newFD(fd, family, proto int, net string, laddr, raddr Addr) (f *netFD, err os.Error) {
|
2009-12-15 16:35:38 -07:00
|
|
|
once.Do(startServer)
|
2009-06-01 23:14:39 -06:00
|
|
|
if e := syscall.SetNonblock(fd, true); e != 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
return nil, &OpError{"setnonblock", net, laddr, os.Errno(e)}
|
2009-11-02 19:37:30 -07:00
|
|
|
}
|
|
|
|
f = &netFD{
|
2009-12-02 00:28:57 -07:00
|
|
|
sysfd: fd,
|
2009-11-02 19:37:30 -07:00
|
|
|
family: family,
|
|
|
|
proto: proto,
|
|
|
|
net: net,
|
|
|
|
laddr: laddr,
|
|
|
|
raddr: raddr,
|
2009-12-15 16:35:38 -07:00
|
|
|
}
|
|
|
|
var ls, rs string
|
2009-11-02 19:37:30 -07:00
|
|
|
if laddr != nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
ls = laddr.String()
|
2009-11-02 19:37:30 -07:00
|
|
|
}
|
|
|
|
if raddr != nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
rs = raddr.String()
|
2009-11-02 19:37:30 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
f.sysfile = os.NewFile(fd, net+":"+ls+"->"+rs)
|
|
|
|
f.cr = make(chan *netFD, 1)
|
|
|
|
f.cw = make(chan *netFD, 1)
|
|
|
|
return f, nil
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-12-02 00:28:57 -07:00
|
|
|
// Add a reference to this fd.
|
|
|
|
func (fd *netFD) incref() {
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.sysmu.Lock()
|
|
|
|
fd.sysref++
|
|
|
|
fd.sysmu.Unlock()
|
2009-12-02 00:28:57 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
// Remove a reference to this FD and close if we've been asked to do so (and
|
|
|
|
// there are no references left.
|
|
|
|
func (fd *netFD) decref() {
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.sysmu.Lock()
|
|
|
|
fd.sysref--
|
2009-12-02 00:28:57 -07:00
|
|
|
if fd.closing && fd.sysref == 0 && fd.sysfd >= 0 {
|
|
|
|
// In case the user has set linger, switch to blocking mode so
|
|
|
|
// the close blocks. As long as this doesn't happen often, we
|
|
|
|
// can handle the extra OS processes. Otherwise we'll need to
|
|
|
|
// use the pollserver for Close too. Sigh.
|
2009-12-15 16:35:38 -07:00
|
|
|
syscall.SetNonblock(fd.sysfd, false)
|
|
|
|
fd.sysfile.Close()
|
|
|
|
fd.sysfile = nil
|
|
|
|
fd.sysfd = -1
|
2009-12-02 00:28:57 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.sysmu.Unlock()
|
2009-12-02 00:28:57 -07:00
|
|
|
}
|
|
|
|
|
2009-06-25 21:24:55 -06:00
|
|
|
func isEAGAIN(e os.Error) bool {
|
|
|
|
if e1, ok := e.(*os.PathError); ok {
|
2009-11-09 13:07:39 -07:00
|
|
|
return e1.Error == os.EAGAIN
|
2009-06-25 21:24:55 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return e == os.EAGAIN
|
2009-06-25 21:24:55 -06:00
|
|
|
}
|
|
|
|
|
2009-04-17 01:08:24 -06:00
|
|
|
func (fd *netFD) Close() os.Error {
|
2009-12-02 00:28:57 -07:00
|
|
|
if fd == nil || fd.sysfile == nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
return os.EINVAL
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-03-06 18:51:31 -07:00
|
|
|
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.incref()
|
|
|
|
syscall.Shutdown(fd.sysfd, syscall.SHUT_RDWR)
|
|
|
|
fd.closing = true
|
|
|
|
fd.decref()
|
|
|
|
return nil
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-04-17 01:08:24 -06:00
|
|
|
func (fd *netFD) Read(p []byte) (n int, err os.Error) {
|
2009-12-02 00:28:57 -07:00
|
|
|
if fd == nil || fd.sysfile == nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
return 0, os.EINVAL
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.rio.Lock()
|
|
|
|
defer fd.rio.Unlock()
|
|
|
|
fd.incref()
|
|
|
|
defer fd.decref()
|
2009-03-06 18:51:31 -07:00
|
|
|
if fd.rdeadline_delta > 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
fd.rdeadline = pollserver.Now() + fd.rdeadline_delta
|
2009-03-06 18:51:31 -07:00
|
|
|
} else {
|
2009-11-09 13:07:39 -07:00
|
|
|
fd.rdeadline = 0
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
2009-06-25 21:24:55 -06:00
|
|
|
for {
|
2009-12-15 16:35:38 -07:00
|
|
|
n, err = fd.sysfile.Read(p)
|
2009-06-25 21:24:55 -06:00
|
|
|
if isEAGAIN(err) && fd.rdeadline >= 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
pollserver.WaitRead(fd)
|
|
|
|
continue
|
2009-06-25 21:24:55 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
break
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-02 16:17:49 -07:00
|
|
|
if fd.proto == syscall.SOCK_DGRAM && err == os.EOF {
|
|
|
|
// 0 in datagram protocol just means 0-length packet
|
|
|
|
err = nil
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-11-17 09:39:17 -07:00
|
|
|
func (fd *netFD) ReadFrom(p []byte) (n int, sa syscall.Sockaddr, err os.Error) {
|
2009-12-02 00:28:57 -07:00
|
|
|
if fd == nil || fd.sysfile == nil {
|
2009-11-17 09:39:17 -07:00
|
|
|
return 0, nil, os.EINVAL
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.rio.Lock()
|
|
|
|
defer fd.rio.Unlock()
|
|
|
|
fd.incref()
|
|
|
|
defer fd.decref()
|
2009-11-17 09:39:17 -07:00
|
|
|
if fd.rdeadline_delta > 0 {
|
|
|
|
fd.rdeadline = pollserver.Now() + fd.rdeadline_delta
|
|
|
|
} else {
|
|
|
|
fd.rdeadline = 0
|
|
|
|
}
|
|
|
|
for {
|
2009-12-15 16:35:38 -07:00
|
|
|
var errno int
|
|
|
|
n, sa, errno = syscall.Recvfrom(fd.sysfd, p, 0)
|
2009-11-17 09:39:17 -07:00
|
|
|
if errno == syscall.EAGAIN && fd.rdeadline >= 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
pollserver.WaitRead(fd)
|
|
|
|
continue
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
|
|
|
if errno != 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
n = 0
|
|
|
|
err = &os.PathError{"recvfrom", fd.sysfile.Name(), os.Errno(errno)}
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
break
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
|
|
|
|
2009-04-17 01:08:24 -06:00
|
|
|
func (fd *netFD) Write(p []byte) (n int, err os.Error) {
|
2009-12-02 00:28:57 -07:00
|
|
|
if fd == nil || fd.sysfile == nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
return 0, os.EINVAL
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.wio.Lock()
|
|
|
|
defer fd.wio.Unlock()
|
|
|
|
fd.incref()
|
|
|
|
defer fd.decref()
|
2009-03-06 18:51:31 -07:00
|
|
|
if fd.wdeadline_delta > 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
fd.wdeadline = pollserver.Now() + fd.wdeadline_delta
|
2009-03-06 18:51:31 -07:00
|
|
|
} else {
|
2009-11-09 13:07:39 -07:00
|
|
|
fd.wdeadline = 0
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
err = nil
|
|
|
|
nn := 0
|
|
|
|
first := true // force at least one Write, to send 0-length datagram packets
|
2009-12-02 16:17:49 -07:00
|
|
|
for nn < len(p) || first {
|
2009-12-15 16:35:38 -07:00
|
|
|
first = false
|
|
|
|
n, err = fd.sysfile.Write(p[nn:])
|
2008-09-29 14:37:00 -06:00
|
|
|
if n > 0 {
|
2009-11-09 13:07:39 -07:00
|
|
|
nn += n
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-03-06 18:51:31 -07:00
|
|
|
if nn == len(p) {
|
2009-11-09 13:07:39 -07:00
|
|
|
break
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
2009-06-25 21:24:55 -06:00
|
|
|
if isEAGAIN(err) && fd.wdeadline >= 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
pollserver.WaitWrite(fd)
|
|
|
|
continue
|
2009-03-06 18:51:31 -07:00
|
|
|
}
|
|
|
|
if n == 0 || err != nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
break
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return nn, err
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
|
2009-11-17 09:39:17 -07:00
|
|
|
func (fd *netFD) WriteTo(p []byte, sa syscall.Sockaddr) (n int, err os.Error) {
|
2009-12-02 00:28:57 -07:00
|
|
|
if fd == nil || fd.sysfile == nil {
|
2009-11-17 09:39:17 -07:00
|
|
|
return 0, os.EINVAL
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.wio.Lock()
|
|
|
|
defer fd.wio.Unlock()
|
|
|
|
fd.incref()
|
|
|
|
defer fd.decref()
|
2009-11-17 09:39:17 -07:00
|
|
|
if fd.wdeadline_delta > 0 {
|
|
|
|
fd.wdeadline = pollserver.Now() + fd.wdeadline_delta
|
|
|
|
} else {
|
|
|
|
fd.wdeadline = 0
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
err = nil
|
2009-11-17 09:39:17 -07:00
|
|
|
for {
|
2009-12-15 16:35:38 -07:00
|
|
|
errno := syscall.Sendto(fd.sysfd, p, 0, sa)
|
2009-11-17 09:39:17 -07:00
|
|
|
if errno == syscall.EAGAIN && fd.wdeadline >= 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
pollserver.WaitWrite(fd)
|
|
|
|
continue
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
|
|
|
if errno != 0 {
|
2009-12-02 00:28:57 -07:00
|
|
|
err = &os.PathError{"sendto", fd.sysfile.Name(), os.Errno(errno)}
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
break
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
|
|
|
if err == nil {
|
|
|
|
n = len(p)
|
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return
|
2009-11-17 09:39:17 -07:00
|
|
|
}
|
|
|
|
|
2009-11-05 00:16:46 -07:00
|
|
|
func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err os.Error) {
|
2009-12-02 00:28:57 -07:00
|
|
|
if fd == nil || fd.sysfile == nil {
|
2009-11-09 13:07:39 -07:00
|
|
|
return nil, os.EINVAL
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-02-15 15:18:39 -07:00
|
|
|
|
2009-12-15 16:35:38 -07:00
|
|
|
fd.incref()
|
|
|
|
defer fd.decref()
|
2009-12-02 00:28:57 -07:00
|
|
|
|
2009-02-15 20:35:52 -07:00
|
|
|
// See ../syscall/exec.go for description of ForkLock.
|
|
|
|
// It is okay to hold the lock across syscall.Accept
|
2009-12-02 00:28:57 -07:00
|
|
|
// because we have put fd.sysfd into non-blocking mode.
|
2009-12-15 16:35:38 -07:00
|
|
|
syscall.ForkLock.RLock()
|
|
|
|
var s, e int
|
|
|
|
var sa syscall.Sockaddr
|
2009-02-15 15:18:39 -07:00
|
|
|
for {
|
2009-12-15 16:35:38 -07:00
|
|
|
s, sa, e = syscall.Accept(fd.sysfd)
|
2009-02-15 15:18:39 -07:00
|
|
|
if e != syscall.EAGAIN {
|
2009-11-09 13:07:39 -07:00
|
|
|
break
|
2009-02-15 15:18:39 -07:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
syscall.ForkLock.RUnlock()
|
|
|
|
pollserver.WaitRead(fd)
|
|
|
|
syscall.ForkLock.RLock()
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
|
|
|
if e != 0 {
|
2009-12-15 16:35:38 -07:00
|
|
|
syscall.ForkLock.RUnlock()
|
|
|
|
return nil, &OpError{"accept", fd.net, fd.laddr, os.Errno(e)}
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
syscall.CloseOnExec(s)
|
|
|
|
syscall.ForkLock.RUnlock()
|
2009-02-15 15:18:39 -07:00
|
|
|
|
2009-11-02 19:37:30 -07:00
|
|
|
if nfd, err = newFD(s, fd.family, fd.proto, fd.net, fd.laddr, toAddr(sa)); err != nil {
|
2009-12-15 16:35:38 -07:00
|
|
|
syscall.Close(s)
|
|
|
|
return nil, err
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|
2009-12-15 16:35:38 -07:00
|
|
|
return nfd, nil
|
2008-09-29 14:37:00 -06:00
|
|
|
}
|