* Use (file)path.Join, and (file)path.IsAbs where reasonable.

* Sorted out the filepath vs. path mess, just in case someone intends to run this on WinDOS.
* Straightened code in createIndex().

diff --git a/config.go b/config.go
index 5e85983022fb783f36d92e025a3f2bef6f710b3f..ddd75230906d9a4a928d802f58ffc562848a5fa7 100644 (file)
--- a/config.go
+++ b/config.go
@@ -13,6 +13,7 @@ import (
        "fmt"
        "io/ioutil"
        "os"
+       "path"
        "path/filepath"
        "strings"
 )
@@ -125,14 +126,14 @@ func initialize() {
        var err error
        cfg.docroot, err = canonicalizePath(cfg.docroot)
        checkFatal(err, "canonicalizePath "+cfg.docroot)
-       if cfg.header[:1] != pathSep {
-               cfg.header = cfg.docroot + pathSep + cfg.header
+       if filepath.IsAbs(cfg.header) {
+               cfg.header = filepath.Join(cfg.docroot, cfg.header)
        }
-       if cfg.footer[:1] != pathSep {
-               cfg.footer = cfg.docroot + pathSep + cfg.footer
+       if filepath.IsAbs(cfg.footer) {
+               cfg.footer = filepath.Join(cfg.docroot, cfg.footer)
        }
-       cfg.idxpage = filepath.Base(strings.TrimSpace(cfg.idxpage))
-       if cfg.idxpage == "." || cfg.idxpage == pathSep {
+       cfg.idxpage = path.Base(filepath.ToSlash(cfg.idxpage))
+       if cfg.idxpage == "." || cfg.idxpage == "/" {
                cfg.idxpage = ""
        }
 

diff --git a/gogopherd.go b/gogopherd.go
index a89fe5a3bbf8bc54ac1be702cebb9cc33dde327c..3ce9678c0c771a5eee90e72650216873b3afacf2 100644 (file)
--- a/gogopherd.go
+++ b/gogopherd.go
@@ -19,6 +19,7 @@ import (
        "net"
        "os"
        "os/signal"
+       "path"
        "path/filepath"
        "strings"
        "syscall"
@@ -33,50 +34,58 @@ func createIndex(dirname string, selector string) (string, error) {
        }
        loc := "\t" + cfg.fqdn + "\t" + cfg.port + "\r\n"
        list := ""
-       updir, _ := filepath.Split(selector)
        if dirname != cfg.docroot {
-               list += "1..\t" + updir + loc
+               list += "1..\t" + path.Dir(selector) + loc
        }
        for _, fi := range fi {
                if !cfg.showdot && isDotfile(fi.Name()) {
                        continue
                }
+               reference := path.Join(selector, fi.Name())
                fmode := fi.Mode()
                fts := humanDate(fi.ModTime())
                if fmode.IsDir() {
                        // create a directory reference
-                       list += "1" + fi.Name() + " | DIR | " + fts + "\t" + selector + pathSep + fi.Name() + loc
+                       list += "1" + fi.Name() + " | DIR | " + fts + "\t" + reference + loc
                } else if fmode.IsRegular() {
                        // create a file reference
-                       ftype, err := guessFiletype(dirname + pathSep + fi.Name())
-                       if check(err, "guessFiletype "+dirname+pathSep+fi.Name()) != nil {
+                       fpath := filepath.Join(dirname, fi.Name())
+                       ftype, err := guessFiletype(fpath)
+                       if check(err, "guessFiletype "+fpath) != nil {
                                continue
                        }
-                       list += ftype + fi.Name() + " | " + humanSize(fi.Size()) + " | " + fts + "\t" + selector + pathSep + fi.Name() + loc
+                       list += ftype + fi.Name() + " | " + humanSize(fi.Size()) + " | " + fts + "\t" + reference + loc
                } else if cfg.fsymln && fmode&os.ModeSymlink != 0 {
                        // create a reference with attributes matching the link target
-                       linktarget, _ := os.Readlink(dirname + pathSep + fi.Name())
-                       if linktarget[:1] != pathSep {
-                               linktarget = dirname + pathSep + linktarget
+                       fpath := filepath.Join(dirname, fi.Name())
+                       linktarget, err := os.Readlink(fpath)
+                       if check(err, "ReadLink "+fpath) != nil {
+                               continue
+                       }
+                       if !filepath.IsAbs(linktarget) {
+                               linktarget = filepath.Join(dirname, linktarget)
+                       }
+                       tpath, err := canonicalizePath(linktarget)
+                       if check(err, "canonicalizePath "+tpath) != nil {
+                               continue
+                       }
+                       lfi, err := os.Stat(tpath)
+                       if check(err, "Stat ") != nil {
+                               continue
                        }
-                       path, err := canonicalizePath(linktarget)
-                       if check(err, "canonicalizePath "+path) == nil {
-                               lfi, err := os.Stat(path)
-                               if check(err, "Stat "+path) == nil {
-                                       fmode := lfi.Mode()
-                                       fts := "[" + humanDate(lfi.ModTime()) + "]"
-                                       if fmode.IsDir() {
-                                               // link points to a directory
-                                               list += "1" + fi.Name() + " | DIR | " + fts + "\t" + selector + pathSep + fi.Name() + loc
-                                       } else if fmode.IsRegular() {
-                                               // link points to a regular file
-                                               ftype, err := guessFiletype(dirname + pathSep + fi.Name())
-                                               if check(err, "guessFiletype "+dirname+pathSep+fi.Name()) != nil {
-                                                       continue
-                                               }
-                                               list += ftype + fi.Name() + " | " + humanSize(lfi.Size()) + " | " + fts + "\t" + selector + pathSep + fi.Name() + loc
-                                       }
+                       fmode := lfi.Mode()
+                       fts := "[" + humanDate(lfi.ModTime()) + "]"
+                       if fmode.IsDir() {
+                               // link points to a directory
+                               list += "1" + fi.Name() + " | DIR | " + fts + "\t" + reference + loc
+                       } else if fmode.IsRegular() {
+                               // link points to a regular file
+                               fpath := filepath.Join(dirname, fi.Name())
+                               ftype, err := guessFiletype(fpath)
+                               if check(err, "guessFiletype "+fpath) != nil {
+                                       continue
                                }
+                               list += ftype + fi.Name() + " | " + humanSize(lfi.Size()) + " | " + fts + "\t" + reference + loc
                        }
                } else {
                        logger.Print("unhandled file mode: ", fi.Name(), " (", fmode.String(), ")")
@@ -91,7 +100,7 @@ func sendIndex(conn net.Conn, path string, selector string) (int64, error) {
        if err == nil {
                tracer.Print("send generated directory index")
                if selector == "" {
-                       selector = pathSep
+                       selector = "/"
                }
                page := "iIndex of " + selector + "\tErr\t" + cfg.fqdn + "\t" + cfg.port + "\r\n"
                page += idxpage
@@ -165,21 +174,21 @@ func handleRequest(conn net.Conn) {
        req = strings.TrimSpace(req)
        tracer.Print("request: '", req, "'")
        // canonicalize, and validate referenced path
-       path, err := validatePath(cfg.docroot, cfg.docroot+pathSep+req)
-       if check(err, "validatePath "+path) != nil {
+       rpath, err := validatePath(cfg.docroot, filepath.Join(cfg.docroot, filepath.FromSlash(req)))
+       if check(err, "validatePath "+rpath) != nil {
                sendError(conn, "404")
                return
        }
-       tracer.Print("request path: '", path, "'")
-       if !cfg.showdot && isDotfile(path) {
+       tracer.Print("request path: '", rpath, "'")
+       if !cfg.showdot && isDotfile(rpath) {
                tracer.Print("skip dotfile")
                sendError(conn, "404")
                return
        }
        // check for symbolic link
        if !cfg.fsymln {
-               fi, err := os.Lstat(path)
-               if check(err, "request path Lstat "+path) != nil {
+               fi, err := os.Lstat(rpath)
+               if check(err, "request path Lstat "+rpath) != nil {
                        sendError(conn, "404")
                        return
                }
@@ -189,24 +198,24 @@ func handleRequest(conn net.Conn) {
                }
        }
        // stat the file
-       fi, err := os.Stat(path)
-       if check(err, "request path Stat "+path) != nil {
+       fi, err := os.Stat(rpath)
+       if check(err, "request path Stat "+rpath) != nil {
                sendError(conn, "404")
                return
        }
        fmode := fi.Mode()
        // send appropriate resource (file or directory index)
-       selector := path[len(cfg.docroot):]
+       selector := filepath.ToSlash(rpath[len(cfg.docroot):])
        tracer.Print("selector: '", selector, "'")
        var nbytes int64
        if fmode.IsDir() {
                err = nil
                if cfg.idxpage != "" {
                        // send directory index file
-                       idxpath := path + pathSep + cfg.idxpage
+                       idxpath := filepath.Join(rpath, cfg.idxpage)
                        nbytes, err = sendFile(conn, idxpath)
                        if err != nil {
-                               tracer.Print("no index file in ", path)
+                               tracer.Print("no index file in ", rpath)
                        }
                }
                if err != nil {
@@ -216,15 +225,15 @@ func handleRequest(conn net.Conn) {
                                return
                        }
                        // generate and send directory listing
-                       nbytes, err = sendIndex(conn, path, selector)
+                       nbytes, err = sendIndex(conn, rpath, selector)
                        if check(err, "sendIndex ") != nil {
                                sendError(conn, "403")
                                return
                        }
                }
        } else if fmode.IsRegular() {
-               nbytes, err = sendFile(conn, path)
-               if check(err, "sendFile "+path) != nil {
+               nbytes, err = sendFile(conn, rpath)
+               if check(err, "sendFile "+rpath) != nil {
                        sendError(conn, "404")
                        return
                }

diff --git a/util.go b/util.go
index fef860a286c92a647fc595e896a37c4650631e0e..84be4f86fca7e2f92a1ca12c52b350bff01426f7 100644 (file)
--- a/util.go
+++ b/util.go
@@ -22,9 +22,8 @@ import (
 )
 
 var (
-       logger  *log.Logger
-       tracer  *log.Logger
-       pathSep string
+       logger *log.Logger
+       tracer *log.Logger
 )
 
 func initUtil(verbose bool) {
@@ -34,7 +33,6 @@ func initUtil(verbose bool) {
        } else {
                tracer = log.New(ioutil.Discard, "", 0)
        }
-       pathSep = string(os.PathSeparator)
 }
 
 func checkFatal(err error, msg string) {