112 lines
2.9 KiB
Go
Executable File
112 lines
2.9 KiB
Go
Executable File
///bin/true && exec /usr/bin/env gosh "$0" "$@"
|
|
// vim:set ft=go:
|
|
package main
|
|
|
|
// SimpleHTTPServer is a simple Go static file server, similar to the Python
|
|
// module of the same name, but which supports high concurrency and all the
|
|
// other niceties that you get from Go out of the box.
|
|
//
|
|
// It runs via my `gosh` wrapper for treating simple Go programs as shell
|
|
// scripts. See my `gosh` script, or just remove the shebang line at the top
|
|
// of this file to `go build` your own version.
|
|
|
|
import (
|
|
"encoding/base64"
|
|
"flag"
|
|
"fmt"
|
|
"log"
|
|
"net/http"
|
|
"regexp"
|
|
"strings"
|
|
)
|
|
|
|
// Regular expression for the user:passwd format for HTTP Basic Auth (-auth)
|
|
var HTTPAuthRegexp = regexp.MustCompile(`^([A-Za-z0-9_]+?):(.+?)$`)
|
|
|
|
// If using HTTP Basic Auth, the username and password.
|
|
var HTTPAuthUsername string
|
|
var HTTPAuthPassword string
|
|
|
|
// LogMiddleware logs all HTTP requests.
|
|
func LogMiddleware(next http.Handler) http.Handler {
|
|
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
|
|
// Using HTTP Basic Auth?
|
|
if len(HTTPAuthUsername) > 0 {
|
|
if !checkAuth(w, r) {
|
|
w.Header().Set("WWW-Authenticate", `Basic realm="SimpleHTTPServer"`)
|
|
w.WriteHeader(401)
|
|
w.Write([]byte("401 Unauthorized\n"))
|
|
return
|
|
}
|
|
}
|
|
|
|
res := &ResponseWriter{w, 200}
|
|
next.ServeHTTP(res, r)
|
|
log.Printf("%s %d %s %s\n",
|
|
r.RemoteAddr,
|
|
res.Status,
|
|
r.Method,
|
|
r.RequestURI,
|
|
)
|
|
})
|
|
}
|
|
|
|
// checkAuth handles HTTP Basic Auth checking.
|
|
func checkAuth(w http.ResponseWriter, r *http.Request) bool {
|
|
s := strings.SplitN(r.Header.Get("Authorization"), " ", 2)
|
|
if len(s) != 2 {
|
|
return false
|
|
}
|
|
|
|
b, err := base64.StdEncoding.DecodeString(s[1])
|
|
if err != nil {
|
|
return false
|
|
}
|
|
|
|
pair := strings.SplitN(string(b), ":", 2)
|
|
if len(pair) != 2 {
|
|
return false
|
|
}
|
|
|
|
return pair[0] == HTTPAuthUsername && pair[1] == HTTPAuthPassword
|
|
}
|
|
|
|
// ResponseWriter is my own wrapper around http.ResponseWriter that lets me
|
|
// capture its status code, for logging purposes.
|
|
type ResponseWriter struct {
|
|
http.ResponseWriter
|
|
Status int
|
|
}
|
|
|
|
// WriteHeader wraps http.WriteHeader to also capture the status code.
|
|
func (w *ResponseWriter) WriteHeader(code int) {
|
|
w.ResponseWriter.WriteHeader(code)
|
|
w.Status = code
|
|
}
|
|
|
|
func main() {
|
|
// Command line flag: the port number to listen on.
|
|
host := flag.String("host", "0.0.0.0", "The host address to listen on.")
|
|
port := flag.Int("port", 8000, "The port number to listen on.")
|
|
auth := flag.String("auth", "", "Use HTTP Basic Authentication. The "+
|
|
"auth string should be in `user:passwd` format.")
|
|
flag.Parse()
|
|
|
|
// If using HTTP authentication...
|
|
if len(*auth) > 0 {
|
|
m := HTTPAuthRegexp.FindStringSubmatch(*auth)
|
|
if len(m) == 0 {
|
|
log.Panicf("The -auth parameter must be in user:passwd format.")
|
|
}
|
|
HTTPAuthUsername = m[1]
|
|
HTTPAuthPassword = m[2]
|
|
}
|
|
|
|
fmt.Printf("Serving at http://%s:%d/\n", *host, *port)
|
|
err := http.ListenAndServe(
|
|
fmt.Sprintf("%s:%d", *host, *port),
|
|
LogMiddleware(http.FileServer(http.Dir("."))),
|
|
)
|
|
panic(err)
|
|
}
|