turn gophorconn --> connwrapper, gophorconn now wraps net.conn with deadline setting

Signed-off-by: kim (grufwub) <grufwub@gmail.com>

conn.go

@@ -2,9 +2,15 @@ package main
 
 import (
     "net"
+    "time"
     "strconv"
 )
 
+const (
+    SocketReadTimeout  = time.Second
+    SocketWriteTimeout = time.Second
+)
+
 type ConnHost struct {
     /* Hold host specific details */
     HostName string
@@ -70,54 +76,61 @@ func BeginGophorListen(bindAddr, hostname, port, fwdPort, rootDir string) (*Goph
     }
 }
 
-func (l *GophorListener) Accept() (*GophorConn, error) {
+func (l *GophorListener) Accept() (*GophorConnWrapper, error) {
     conn, err := l.Listener.Accept()
     if err != nil {
         return nil, err
     }
 
-    gophorConn := new(GophorConn)
-    gophorConn.Conn = conn
+    connWrapper := new(GophorConnWrapper)
+    connWrapper.Conn = &GophorConn{ conn }
 
     /* Copy over listener host */
-    gophorConn.Host = l.Host
-    gophorConn.Root = l.Root
+    connWrapper.Host = l.Host
+    connWrapper.Root = l.Root
 
     /* Should always be ok as listener is type TCP (see above) */
     addr, _ := conn.RemoteAddr().(*net.TCPAddr)
-    gophorConn.Client = &ConnClient{
+    connWrapper.Client = &ConnClient{
         addr.IP.String(),
         strconv.Itoa(addr.Port),
     }
 
-    return gophorConn, nil
-}
-
-func (l *GophorListener) Addr() net.Addr {
-    return l.Listener.Addr()
+    return connWrapper, nil
 }
 
 type GophorConn struct {
-    /* Simple net.Conn wrapper with virtual host and client info */
-
-    Conn    net.Conn
-    Host    *ConnHost
-    Client  *ConnClient
-    Root    string
+    conn net.Conn
 }
 
 func (c *GophorConn) Read(b []byte) (int, error) {
-    return c.Conn.Read(b)
+    /* Implements reader + updates deadline */
+    c.conn.SetReadDeadline(time.Now().Add(SocketReadTimeout))
+    return c.conn.Read(b)
 }
 
 func (c *GophorConn) Write(b []byte) (int, error) {
-    return c.Conn.Write(b)
+    /* Implements writer + updates deadline */
+    c.conn.SetWriteDeadline(time.Now().Add(SocketWriteTimeout))
+    return c.conn.Write(b)
 }
 
 func (c *GophorConn) Close() error {
-    return c.Conn.Close()
+    /* Implements closer */
+
+    return c.conn.Close()
 }
 
-func (c *GophorConn) RootDir() string {
+type GophorConnWrapper struct {
+    /* Simple net.Conn wrapper with virtual host and client info */
+
+    Conn    *GophorConn
+    Host    *ConnHost
+    Client  *ConnClient
+    Root    string
+}
+
+
+func (c *GophorConnWrapper) RootDir() string {
     return c.Root
 }

gophor.go

@@ -28,10 +28,10 @@ func main() {
     /* Start accepting connections on any supplied listeners */
     for _, l := range listeners {
         go func() {
-            Config.SysLog.Info("", "Listening on: gopher://%s\n", l.Addr())
+            Config.SysLog.Info("", "Listening on: gopher://%s:%s\n", l.Host.Name(), l.Host.RealPort())
 
             for {
-                newConn, err := l.Accept()
+                connWrapper, err := l.Accept()
                 if err != nil {
                     Config.SysLog.Error("", "Error accepting connection: %s\n", err.Error())
                     continue
@@ -39,7 +39,7 @@ func main() {
 
                 /* Run this in it's own goroutine so we can go straight back to accepting */
                 go func() {
-                    worker := &Worker{ newConn }
+                    worker := &Worker{ connWrapper }
                     worker.Serve()
                 }()
             }

request.go

@@ -62,13 +62,13 @@ type Request struct {
     Parameters []string /* CGI-bin params will be 1 length slice, shell commands populate >=1 */ 
 }
 
-func NewSanitizedRequest(conn *GophorConn, requestStr string) *Request {
+func NewSanitizedRequest(connWrapper *GophorConnWrapper, requestStr string) *Request {
     /* Split dataStr into request path and parameter string (if pressent) */
     relPath, parameters := parseRequestString(requestStr)
-    relPath = sanitizeRelativePath(conn.RootDir(), relPath)
-    bufWriter := bufio.NewWriterSize(conn.Conn, SocketWriteBufSize)
-    requestPath := NewRequestPath(conn.RootDir(), relPath)
-    return NewRequest(conn.Host, conn.Client, bufWriter, requestPath, parameters)
+    relPath = sanitizeRelativePath(connWrapper.RootDir(), relPath)
+    bufWriter := bufio.NewWriterSize(connWrapper.Conn, SocketWriteBufSize)
+    requestPath := NewRequestPath(connWrapper.RootDir(), relPath)
+    return NewRequest(connWrapper.Host, connWrapper.Client, bufWriter, requestPath, parameters)
 }
 
 func NewRequest(host *ConnHost, client *ConnClient, writer *bufio.Writer, path *RequestPath, parameters []string) *Request {

worker.go

@@ -12,13 +12,13 @@ const (
 )
 
 type Worker struct {
-    Conn *GophorConn
+    ConnWrapper *GophorConnWrapper
 }
 
 func (worker *Worker) Serve() {
     defer func() {
         /* Close-up shop */
-        worker.Conn.Close()
+        worker.ConnWrapper.Conn.Close()
     }()
 
     var count int
@@ -31,16 +31,8 @@ func (worker *Worker) Serve() {
     iter := 0
     endReached := false
     for {
-        /* Buffered read from listener */
-        count, err = worker.Conn.Read(buf)
-        if err != nil {
-            if err == io.EOF {
-                break
-            }
-
-            Config.SysLog.Error("", "Error reading from socket on port %s: %s\n", worker.Conn.Host.Port(), err.Error())
-            return
-        }
+        /* Buffered read from conn */
+        count, err = worker.ConnWrapper.Conn.Read(buf)
 
         /* Copy buffer into received string, stop at first tap or CrLf */
         for i := 0; i < count; i += 1 {
@@ -54,10 +46,20 @@ func (worker *Worker) Serve() {
                 }
             }
             received += string(buf[i])
+
         }
 
-        /* Reached end of request */
-        if endReached || count < SocketReadBufSize {
+        /* Handle errors AFTER checking we didn't receive some bytes */
+        if err != nil {
+            if err == io.EOF {
+                /* EOF, break */
+                break
+            }
+
+            Config.SysLog.Error("", "Error reading from socket on port %s: %s\n", worker.ConnWrapper.Host.Port(), err.Error())
+            return
+        } else if endReached || count < SocketReadBufSize {
+            /* Reached the end of what we want, break */
             break
         }
 
@@ -77,15 +79,15 @@ func (worker *Worker) Serve() {
     switch len(received) {
         case lenBefore-4:
             /* Send an HTML redirect to supplied URL */
-            Config.AccLog.Info("("+worker.Conn.Client.Ip()+") ", "Redirecting to %s\n", received)
-            worker.Conn.Write(generateHtmlRedirect(received))
+            Config.AccLog.Info("("+worker.ConnWrapper.Client.Ip()+") ", "Redirecting to %s\n", received)
+            worker.ConnWrapper.Conn.Write(generateHtmlRedirect(received))
             return
         default:
             /* Do nothing */
     }
 
     /* Create new request from dataStr */
-    request := NewSanitizedRequest(worker.Conn, received)
+    request := NewSanitizedRequest(worker.ConnWrapper, received)
 
     /* Handle request */
     gophorErr := Config.FileSystem.HandleRequest(request)