// listen for gui client to connect to our socket
func accept(listener *net.UnixListener, ch chan []byte) {
for {
// we are going to eat the serial data until
// we get a socket connection so we don't block the channel
select {
case <-ch:
log.Println("eating serial data")
default:
}
// set timeout to fall through so we can check the channel for
// serial data
listener.SetDeadline(time.Now().Add(100 * time.Millisecond))
conn, err := listener.AcceptUnix()
if nil != err {
if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() {
continue
}
log.Println(err)
} else {
// we have connection, call handle, we only handle one connection
// so no goroutine here
handleSocket(conn, ch)
}
}
}
// NewServerFromListener creates a server struct using a UnixListener specified
// by ln. cb is the callback function which will get called for any authentication
// request.
func NewServerFromListener(ln *net.UnixListener, cb AuthCB) (s *Server, err error) {
s = &Server{}
s.sockPath = ln.Addr().String()
s.cb = cb
s.ln = net.Listener(ln)
return
}
// Utility to open a tcp[46]? or fd
func ListenFile(rawurl string) (file *os.File, err error) {
if socketMasterFd := os.Getenv("SOCKETMASTER_FD"); socketMasterFd != "" {
os.Setenv("SOCKETMASTER_FD", "")
rawurl = fmt.Sprintf("fd://%s", socketMasterFd)
}
u, err := url.Parse(rawurl)
if err != nil {
return
}
switch u.Scheme {
case "fd":
var fd uint64
fd, err = strconv.ParseUint(u.Host, 10, 8)
if err != nil {
return
}
// NOTE: The name argument doesn't really matter apparently
file = os.NewFile(uintptr(fd), fmt.Sprintf("fd://%d", fd))
case "unix": //, "unixpacket", "unixgram":
var laddr *net.UnixAddr
var listener *net.UnixListener
laddr, err = net.ResolveUnixAddr(u.Scheme, u.Path)
if err != nil {
return
}
listener, err = net.ListenUnix(u.Scheme, laddr)
if err != nil {
return
}
file, err = listener.File()
case "tcp", "tcp4", "tcp6":
var laddr *net.TCPAddr
var listener *net.TCPListener
laddr, err = net.ResolveTCPAddr(u.Scheme, u.Host)
if err != nil {
return
}
listener, err = net.ListenTCP(u.Scheme, laddr)
if err != nil {
return
}
// Closing the listener doesn't affect the file and reversely.
// http://golang.org/pkg/net/#TCPListener.File
file, err = listener.File()
default:
err = fmt.Errorf("Unsupported scheme: %s", u.Scheme)
}
return
}
func NewAuthenticatedFileSocket(sock *net.UnixListener) error {
sockFile, err := sock.File()
if err != nil {
return err
}
sockFile.Close()
return nil
}
func acceptConnections(in chan net.Conn, listener *net.UnixListener) {
for {
c, err := listener.Accept()
if err != nil {
panic(err.String())
}
in <- c
}
}
func connListener(conn chan net.Conn, listener *net.UnixListener) {
for {
c, err := listener.Accept()
if err != nil {
panic("Accept: ", err.String())
}
conn <- c
}
}
func NewAuthenticatedFileSocket(sock *net.UnixListener) error {
sockFile, err := sock.File()
if err != nil {
return err
}
err = syscall.SetsockoptInt(int(sockFile.Fd()), syscall.SOL_SOCKET, syscall.SO_PASSCRED, 1)
sockFile.Close()
return err
}
func (us *UnixSock) Accept(l *net.UnixListener) {
// Why doesn't this get called on ctrl + c
defer l.Close()
for {
fd, err := l.Accept()
if err != nil {
break
}
us.processBuffer(fd)
}
}
// Serve listens on sock for new connections and services them.
func (server LinuxHostAdminServer) Serve(sock *net.UnixListener) error {
defer RecoverTPMResources()
// Set the socket to allow peer credentials to be passed
sockFile, err := sock.File()
if err != nil {
return err
}
err = syscall.SetsockoptInt(int(sockFile.Fd()), syscall.SOL_SOCKET, syscall.SO_PASSCRED, 1 /* true */)
sockFile.Close()
if err != nil {
return err
}
connections := make(chan *net.UnixConn, 1)
errors := make(chan error, 1)
go func() {
defer RecoverTPMResources()
for {
conn, err := sock.AcceptUnix()
if err != nil {
errors <- err
break
}
connections <- conn
}
}()
for {
var conn *net.UnixConn
select {
case conn = <-connections:
break
case err = <-errors:
return err
case <-server.Done:
return nil
}
s := rpc.NewServer()
oob := util.NewOOBUnixConn(conn)
err = s.RegisterName("LinuxHost", linuxHostAdminServerStub{oob, server.lh, server.Done})
if err != nil {
return err
}
go func() {
defer RecoverTPMResources()
s.ServeCodec(protorpc.NewServerCodec(oob))
}()
}
}
func runSaslAuthSocketListener(listener *net.UnixListener, store *StoreChan) error {
path := listener.Addr().String()
s, err := sasl.NewServerFromListener(listener, func(log string, pwd string, srv string, rlm string) (bool, string, error) {
return callback(log, pwd, srv, rlm, path, store)
})
if err != nil {
return err
}
wl.Printf("listening on '%s'", path)
if err := s.Run(); err != nil {
wl.Printf("error on sasl socket '%s': %s", path, err)
}
return nil
}
func (e *Euclid) lstn(l *net.UnixListener, loop *loop) {
for {
conn, err := l.AcceptUnix()
if err != nil {
panic(err)
}
var buf [1024]byte
n, err := conn.Read(buf[:])
if err != nil {
panic(err)
}
r := bytes.Trim(buf[:n], " ")
resp := e.processMsg(r, loop.comm)
conn.Write(resp)
conn.Close()
}
}
func (srv *Server) run(listener *net.UnixListener) {
defer os.Remove(SOCKET)
for {
conn, err := listener.AcceptUnix()
if err != nil {
select {
case srv.errors <- err:
case <-srv.closed:
}
break
}
go srv.handleConn(conn)
}
close(srv.finished)
}
func handleUnixConnection(listener *net.UnixListener, unix UnixHandler) {
for {
data := make([]byte, 512)
conn, err := listener.AcceptUnix()
if err != nil {
fmt.Println(err)
continue
}
read_length, err := conn.Read(data[0:])
if err != nil { // EOF, or worse
fmt.Println(err)
continue
}
if read_length > 0 {
go panicWrapping(func() {
unix.UnixReceived(data[0:read_length], conn)
})
}
}
}
// Serve listens on sock for new connections and services them.
func (server LinuxHostAdminServer) Serve(sock *net.UnixListener) error {
// Set the socket to allow peer credentials to be passed
err := NewAuthenticatedFileSocket(sock)
if err != nil {
return err
}
connections := make(chan *net.UnixConn, 1)
errors := make(chan error, 1)
go func() {
for {
conn, err := sock.AcceptUnix()
if err != nil {
errors <- err
break
}
connections <- conn
}
}()
for {
var conn *net.UnixConn
select {
case conn = <-connections:
break
case err = <-errors:
return err
case <-server.Done:
return nil
}
s := rpc.NewServer()
oob := util.NewOOBUnixConn(conn)
err = s.RegisterName("LinuxHost", linuxHostAdminServerStub{oob, server.lh, server.Done})
if err != nil {
return err
}
go s.ServeCodec(protorpc.NewServerCodec(oob))
}
}
// Run the server's accept loop, waiting for connections from l.
// Correct shutdown procedure is:
// set slots to a number such that no new processes will run
// wait for all running processes to finish
// set shittingDown to true
// close the listening socket
func Run(v *viper.Viper, l *net.UnixListener) {
i := newInstance(v)
i.listener = l
for {
c, err := l.AcceptUnix()
i.m.Lock()
sdc := i.shutdownComplete
i.m.Unlock()
if sdc {
glog.Infoln("Shutdown complete. closing listener.")
if c != nil {
c.Close()
}
l.Close()
return
} else if err != nil {
glog.Errorln("Accept() failed on unix socket:", err)
return
}
go i.connectionHandler(c)
}
}
func listen(sock *net.UnixListener, logChan chan []byte) {
defer sock.Close()
defer wg.Done()
// Timeout after 2 seconds
sock.SetDeadline(time.Now().Add((2 * time.Second)))
for run {
client, err := sock.Accept()
if err != nil {
ne, ok := err.(net.Error)
if !ok || !ne.Temporary() {
// Non-temporary (fatal) error
log.Printf("Error accepting client:\n%v", err)
break
}
} else {
wg.Add(1)
go handle(client, logChan)
}
}
}