// Accept wraps syscall.Accept.
func (sw *Switch) Accept(s int) (ns int, sa syscall.Sockaddr, err error) {
so := sw.sockso(s)
if so == nil {
return syscall.Accept(s)
}
sw.fmu.RLock()
f, _ := sw.fltab[FilterAccept]
sw.fmu.RUnlock()
af, err := f.apply(so)
if err != nil {
return -1, nil, err
}
ns, sa, so.Err = syscall.Accept(s)
if err = af.apply(so); err != nil {
if so.Err == nil {
syscall.Close(ns)
}
return -1, nil, err
}
if so.Err != nil {
return -1, nil, so.Err
}
sw.smu.Lock()
nso := sw.addLocked(ns, so.Cookie.Family(), so.Cookie.Type(), so.Cookie.Protocol())
sw.stats.getLocked(nso.Cookie).Accepted++
sw.smu.Unlock()
return ns, sa, nil
}
func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err os.Error) {
if fd == nil || fd.file == nil {
return nil, os.EINVAL
}
// See ../syscall/exec.go for description of ForkLock.
// It is okay to hold the lock across syscall.Accept
// because we have put fd.fd into non-blocking mode.
syscall.ForkLock.RLock()
var s, e int
var sa syscall.Sockaddr
for {
s, sa, e = syscall.Accept(fd.fd)
if e != syscall.EAGAIN {
break
}
syscall.ForkLock.RUnlock()
pollserver.WaitRead(fd)
syscall.ForkLock.RLock()
}
if e != 0 {
syscall.ForkLock.RUnlock()
return nil, &OpError{"accept", fd.net, fd.laddr, os.Errno(e)}
}
syscall.CloseOnExec(s)
syscall.ForkLock.RUnlock()
if nfd, err = newFD(s, fd.family, fd.proto, fd.net, fd.laddr, toAddr(sa)); err != nil {
syscall.Close(s)
return nil, err
}
return nfd, nil
}
func main() {
acceptingFd, err := syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM, 0)
check(err)
addr := &syscall.SockaddrInet4{Port: 3000, Addr: [4]byte{0, 0, 0, 0}}
err = syscall.Bind(acceptingFd, addr)
check(err)
err = syscall.Listen(acceptingFd, 100)
check(err)
for {
connectionFd, _, err := syscall.Accept(acceptingFd)
check(err)
fmt.Println("Accepted new connectrion")
data := make([]byte, 1024)
_, err = syscall.Read(connectionFd, data)
check(err)
fmt.Printf("Received: %s\n", string(data))
_, err = syscall.Write(connectionFd, data)
check(err)
err = syscall.Close(connectionFd)
check(err)
}
}
// Wrapper around the accept system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
func accept(fd int) (int, syscall.Sockaddr, error) {
nfd, sa, err := syscall.Accept4(fd, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC)
// The accept4 system call was introduced in Linux 2.6.28. If
// we get an ENOSYS error, fall back to using accept.
if err == nil || err != syscall.ENOSYS {
return nfd, sa, err
}
// See ../syscall/exec_unix.go for description of ForkLock.
// It is okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
syscall.ForkLock.RLock()
nfd, sa, err = syscall.Accept(fd)
if err == nil {
syscall.CloseOnExec(nfd)
}
syscall.ForkLock.RUnlock()
if err != nil {
return -1, nil, err
}
if err = syscall.SetNonblock(nfd, true); err != nil {
syscall.Close(nfd)
return -1, nil, err
}
return nfd, sa, nil
}
// Wrapper around the accept system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
func accept(s int) (int, syscall.Sockaddr, error) {
ns, sa, err := syscall.Accept4(s, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC)
// On Linux the accept4 system call was introduced in 2.6.28
// kernel and on FreeBSD it was introduced in 10 kernel. If we
// get an ENOSYS error on both Linux and FreeBSD, or EINVAL
// error on Linux, fall back to using accept.
if err == nil || (err != syscall.ENOSYS && err != syscall.EINVAL) {
return ns, sa, err
}
// See ../syscall/exec_unix.go for description of ForkLock.
// It is probably okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
// However, a call to the File method will put it back into
// blocking mode. We can't take that risk, so no use of ForkLock here.
ns, sa, err = syscall.Accept(s)
if err == nil {
syscall.CloseOnExec(ns)
}
if err != nil {
return -1, nil, err
}
if err = syscall.SetNonblock(ns, true); err != nil {
syscall.Close(ns)
return -1, nil, err
}
return ns, sa, nil
}
// Wrapper around the accept system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
func accept(fd int) (int, syscall.Sockaddr, error) {
nfd, sa, err := syscall.Accept4(fd, syscall.SOCK_NONBLOCK|syscall.SOCK_CLOEXEC)
// The accept4 system call was introduced in Linux 2.6.28. If
// we get an ENOSYS error, fall back to using accept.
if err == nil || err != syscall.ENOSYS {
return nfd, sa, err
}
// See ../syscall/exec_unix.go for description of ForkLock.
// It is probably okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
// However, a call to the File method will put it back into
// blocking mode. We can't take that risk, so no use of ForkLock here.
nfd, sa, err = syscall.Accept(fd)
if err == nil {
syscall.CloseOnExec(nfd)
}
if err != nil {
return -1, nil, err
}
if err = syscall.SetNonblock(nfd, true); err != nil {
syscall.Close(nfd)
return -1, nil, err
}
return nfd, sa, nil
}
func (io *NetIOManager) ProxyNetAccept(serverinfo syscall.Sockaddr) (sa syscall.Sockaddr, err error) {
var clientfd, serverfd int
// accpet mongodb client connection request
clientfd, clientinfo, err := syscall.Accept(io.proxy_server_fd)
if err != nil {
goto ClientError
}
err = syscall.SetNonblock(clientfd, true)
if err != nil {
goto ClientCleanup
}
err = syscall.EpollCtl(io.epoll_fd, syscall.EPOLL_CTL_ADD, clientfd,
&syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLOUT |
syscall.EPOLLRDHUP, Fd: int32(clientfd)})
if err != nil {
goto ClientCleanup
}
// establish connection with mongodb server
serverfd, err = syscall.Socket(syscall.AF_INET, syscall.SOCK_STREAM,
syscall.IPPROTO_TCP)
if err != nil {
goto ServerError
}
err = syscall.Connect(serverfd, serverinfo)
if err != nil {
goto ServerCleanup
}
err = syscall.SetNonblock(serverfd, true)
if err != nil {
goto ServerCleanup
}
err = syscall.EpollCtl(io.epoll_fd, syscall.EPOLL_CTL_ADD, serverfd,
&syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLOUT |
syscall.EPOLLRDHUP, Fd: int32(serverfd)})
if err != nil {
goto ServerCleanup
}
// now proxy server becomes a bridge between client <-> server
add_sock_peer(io, clientfd, clientinfo, serverfd, serverinfo)
return clientinfo, nil
ServerCleanup:
syscall.Close(serverfd)
ServerError:
syscall.EpollCtl(io.epoll_fd, syscall.EPOLL_CTL_DEL, clientfd,
&syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLOUT |
syscall.EPOLLRDHUP, Fd: int32(clientfd)})
ClientCleanup:
syscall.Close(clientfd)
ClientError:
return nil, err
}
// Accept blocks until a new connection is available on our fd
// returns a fileConn as a net.Conn for Listener interface
func (l *fdListener) Accept() (c net.Conn, err os.Error) {
if nfd, _, errno := syscall.Accept(l.fd); errno == 0 {
c = fileConn{os.NewFile(nfd, "<fd:"+strconv.Itoa(l.fd)+">")}
} else {
err = os.Errno(errno)
}
return
}
/*-----------------------------------------------------------------------------
-- FUNCTION: newConnection
--
-- DATE: February 6, 2016
--
-- REVISIONS: February 10, 2016 - modified for EPoll
-- February 11, 2016 - fixed blocking issues
-- February 12, 2016 - factored out hostString()
--
--
-- DESIGNER: Marc Vouve
--
-- PROGRAMMER: Marc Vouve
--
-- INTERFACE: func newConnection(listenFd int) (connectionInfo, error)
-- listenFd: the listener file descriptor with the new connection
--
-- RETURNS:
-- connectionInfo: A structor to store data over the life of the connection
-- error: If an error occurs
--
-- NOTES: this function sets the port into non blocking mode.
------------------------------------------------------------------------------*/
func newConnection(listenFd int) (connectionInfo, error) {
newFileDescriptor, socketAddr, err := syscall.Accept(int(listenFd))
if err != nil {
return connectionInfo{}, err
}
syscall.SetNonblock(newFileDescriptor, true)
hostName := hostString(socketAddr)
return connectionInfo{FileDescriptor: newFileDescriptor, HostName: hostName}, nil
}
func (control *Control) Serve() {
// Bind our rpc server.
server := rpc.NewServer()
server.Register(control.rpc)
for {
// Accept clients.
nfd, _, err := syscall.Accept(control.control_fd)
if err == nil {
go control.handle(nfd, server)
}
}
}
func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (nfd *netFD, err error) {
if fd == nil || fd.sysfile == nil {
return nil, os.EINVAL
}
fd.incref()
defer fd.decref()
if fd.rdeadline_delta > 0 {
fd.rdeadline = pollserver.Now() + fd.rdeadline_delta
} else {
fd.rdeadline = 0
}
// See ../syscall/exec.go for description of ForkLock.
// It is okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
syscall.ForkLock.RLock()
var s, e int
var rsa syscall.Sockaddr
for {
if fd.closing {
syscall.ForkLock.RUnlock()
return nil, os.EINVAL
}
s, rsa, e = syscall.Accept(fd.sysfd)
if e != syscall.EAGAIN || fd.rdeadline < 0 {
break
}
syscall.ForkLock.RUnlock()
pollserver.WaitRead(fd)
syscall.ForkLock.RLock()
}
if e != 0 {
syscall.ForkLock.RUnlock()
return nil, &OpError{"accept", fd.net, fd.laddr, os.Errno(e)}
}
syscall.CloseOnExec(s)
syscall.ForkLock.RUnlock()
if nfd, err = newFD(s, fd.family, fd.proto, fd.net); err != nil {
syscall.Close(s)
return nil, err
}
lsa, _ := syscall.Getsockname(nfd.sysfd)
nfd.setAddr(toAddr(lsa), toAddr(rsa))
return nfd, nil
}
// Wrapper around the accept system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
func accept(fd int) (int, syscall.Sockaddr, error) {
// See ../syscall/exec_unix.go for description of ForkLock.
// It is okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
syscall.ForkLock.RLock()
nfd, sa, err := syscall.Accept(fd)
if err == nil {
syscall.CloseOnExec(nfd)
}
syscall.ForkLock.RUnlock()
if err != nil {
return -1, nil, err
}
if err = syscall.SetNonblock(nfd, true); err != nil {
syscall.Close(nfd)
return -1, nil, err
}
return nfd, sa, nil
}
func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (netfd *netFD, err error) {
if err := fd.incref(false); err != nil {
return nil, err
}
defer fd.decref()
// See ../syscall/exec_unix.go for description of ForkLock.
// It is okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
var s int
var rsa syscall.Sockaddr
for {
syscall.ForkLock.RLock()
s, rsa, err = syscall.Accept(fd.sysfd)
if err != nil {
syscall.ForkLock.RUnlock()
if err == syscall.EAGAIN {
err = errTimeout
if fd.rdeadline >= 0 {
if err = fd.pollServer.WaitRead(fd); 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.
continue
}
return nil, &OpError{"accept", fd.net, fd.laddr, err}
}
break
}
syscall.CloseOnExec(s)
syscall.ForkLock.RUnlock()
if netfd, err = newFD(s, fd.family, fd.sotype, fd.net); err != nil {
closesocket(s)
return nil, err
}
lsa, _ := syscall.Getsockname(netfd.sysfd)
netfd.setAddr(toAddr(lsa), toAddr(rsa))
return netfd, nil
}
func (fd *netFD) accept(toAddr func(syscall.Sockaddr) Addr) (netfd *netFD, err error) {
if fd == nil || fd.sysfile == nil {
return nil, os.EINVAL
}
fd.incref()
defer fd.decref()
// See ../syscall/exec.go for description of ForkLock.
// It is okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
var s int
var rsa syscall.Sockaddr
for {
if fd.closing {
return nil, os.EINVAL
}
syscall.ForkLock.RLock()
s, rsa, err = syscall.Accept(fd.sysfd)
if err != nil {
syscall.ForkLock.RUnlock()
if err == syscall.EAGAIN {
if fd.rdeadline >= 0 {
pollserver.WaitRead(fd)
continue
}
err = errTimeout
}
return nil, &OpError{"accept", fd.net, fd.laddr, err}
}
break
}
syscall.CloseOnExec(s)
syscall.ForkLock.RUnlock()
if netfd, err = newFD(s, fd.family, fd.sotype, fd.net); err != nil {
syscall.Close(s)
return nil, err
}
lsa, _ := syscall.Getsockname(netfd.sysfd)
netfd.setAddr(toAddr(lsa), toAddr(rsa))
return netfd, nil
}
// Wrapper around the accept system call that marks the returned file
// descriptor as nonblocking and close-on-exec.
func accept(fd int) (int, syscall.Sockaddr, error) {
// See ../syscall/exec_unix.go for description of ForkLock.
// It is probably okay to hold the lock across syscall.Accept
// because we have put fd.sysfd into non-blocking mode.
// However, a call to the File method will put it back into
// blocking mode. We can't take that risk, so no use of ForkLock here.
nfd, sa, err := syscall.Accept(fd)
if err == nil {
syscall.CloseOnExec(nfd)
}
if err != nil {
return -1, nil, err
}
if err = syscall.SetNonblock(nfd, true); err != nil {
syscall.Close(nfd)
return -1, nil, err
}
return nfd, sa, nil
}
/*******************************************************************************
* Author Marc Vouve
*
* Designer Marc Vouve
*
* Date: February 6 2016
*
* Params: listenFd: The file descriptor of the listening host
*
* Return: connectionInfo of the new connection made
*
* Notes: This is a helper function for when a new connection is detected by the
* observer loop
*
******************************************************************************/
func newConnection(listenFd int) (connectionInfo, error) {
newFileDescriptor, socketAddr, err := syscall.Accept(int(listenFd))
if err != nil {
return connectionInfo{}, err
}
var hostname string
switch socketAddr := socketAddr.(type) {
default:
return connectionInfo{}, err
case *syscall.SockaddrInet4:
hostname = net.IPv4(socketAddr.Addr[0], socketAddr.Addr[1], socketAddr.Addr[2], socketAddr.Addr[3]).String()
hostname += ":" + strconv.FormatInt(int64(socketAddr.Port), 10)
case *syscall.SockaddrInet6:
hostname = net.IP(socketAddr.Addr[0:16]).String()
hostname += ":" + string(socketAddr.Port)
}
return connectionInfo{FileDescriptor: newFileDescriptor, HostName: hostname}, nil
}
// Block, waiting for connections, handling each connection in its own go
// routine
func (s *TFOServer) Accept() {
log.Println("Server: Waiting for connections")
defer syscall.Close(s.fd)
for {
fd, sockaddr, err := syscall.Accept(s.fd)
if err != nil {
log.Fatalln("Failed to accept(): ", err)
}
cxn := TFOServerConn{fd: fd, sockaddr: sockaddr.(*syscall.SockaddrInet4)}
go cxn.Handle()
}
}
func main() {
check(os.MkdirAll(FOLDER, 0777))
// Initialisation des variables serveur
lastUpdate = time.Date(1994, time.April, 2, 2, 0, 0, 0, time.UTC)
dat, err := ioutil.ReadFile(LASTUPFOLDER)
if err == nil {
err = json.Unmarshal(dat, &lastUpdate)
check(err)
}
envoi = &sync.Mutex{}
err = util.ScanDir(FOLDER, &mainFolder)
check(err)
// création du socket d'écoute
fd, err := s.Socket(s.AF_INET, s.SOCK_STREAM, 0)
if err != nil {
check(err)
}
defer s.Close(fd)
if err := s.Bind(fd, &s.SockaddrInet4{Port: PORT, Addr: [4]byte{0, 0, 0, 0}}); err != nil {
check(err)
}
if err := s.Listen(fd, 5); err != nil {
check(err)
}
// Lancement de l'écoute du serveur
fmt.Println("Serveur lancé !")
for {
nfd, sa, err := s.Accept(fd)
if err != nil {
check(err)
}
envoi.Lock()
go app(nfd, sa)
envoi.Unlock()
}
}
ErrFmt: "Listen fd error [%s]\n",
Action: func(t *Tunnel) error {
return syscall.Listen(t.LFd, 10)
}},
{
ErrFmt: "Add fd to epoll error [%s]\n",
Action: func(t *Tunnel) error {
return syscall.EpollCtl(epollFd, syscall.EPOLL_CTL_ADD, t.LFd, &syscall.EpollEvent{Events: syscall.EPOLLIN, Fd: int32(t.LFd)})
}},
}
var pathAddStep = [...]TunnelStep{
{
ErrFmt: "Port [%d] accept error [%s]",
Action: func(tc *TunnelConn) (err error) {
tc.EFd, _, err = syscall.Accept(tc.RelTunnel.LFd)
return
}},
{
ErrFmt: "Port [%d] set fd nonblock error [%s]",
Action: func(tc *TunnelConn) (err error) {
return syscall.SetNonblock(tc.EFd, true)
}},
{
ErrFmt: "Port [%d] add fd to epoll error [%s]",
Action: func(tc *TunnelConn) (err error) {
return syscall.EpollCtl(epollFd, syscall.EPOLL_CTL_ADD, tc.EFd, &syscall.EpollEvent{Events: syscall.EPOLLIN | syscall.EPOLLOUT, Fd: int32(tc.EFd)})
}},
{
ErrFmt: "Port [%d] create new socket error [%s]",
Action: func(tc *TunnelConn) (err error) {