chore: version v2.0.12

Check if keys exist in map. Fixes: #736

.circleci/config.yml

@@ -34,7 +34,7 @@ jobs:
           at: '~/project'
       - run:
           name: "Compile"
-          command: ./wizard.sh -c
+          command: GOOS=linux GOARCH=amd64 ./wizard.sh -c
       - run:
           name: "Cleanup"
           command: |
@@ -44,21 +44,6 @@ jobs:
           root: .
           paths:
             - '*'
-  docker-latest:
-    docker:
-      - image: docker
-    steps:
-      - attach_workspace:
-          at: '~/project'
-      - setup_remote_docker
-      - run: docker build -t filebrowser/filebrowser .
-      - run: docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD
-      - run: docker push filebrowser/filebrowser
-      - run: docker logout
-      - persist_to_workspace:
-          root: .
-          paths:
-            - '*'
   release:
     docker:
       - image: circleci/golang:1.12
@@ -96,13 +81,4 @@ workflows:
             tags:
               only: /^v.*/
             branches:
-              ignore: /.*/
-      - docker-latest:
-          context: deploy
-          requires:
-            - build-go
-          filters:
-            branches:
-              only: master
-            tags:
-              ignore: /.*/
+              ignore: /.*/

cmd/config.go

@@ -44,15 +44,37 @@ func addConfigFlags(flags *pflag.FlagSet) {
 	flags.Bool("branding.disableExternal", false, "disable external links such as GitHub links")
 }
 
-func getAuthentication(flags *pflag.FlagSet) (settings.AuthMethod, auth.Auther) {
+func getAuthentication(flags *pflag.FlagSet, defaults ...interface{}) (settings.AuthMethod, auth.Auther) {
 	method := settings.AuthMethod(mustGetString(flags, "auth.method"))
 
+	var defaultAuther map[string]interface{}
+	if len(defaults) > 0 {
+		if hasAuth := defaults[0]; hasAuth != true {
+			for _, arg := range defaults {
+				switch def := arg.(type) {
+				case *settings.Settings:
+					method = settings.AuthMethod(def.AuthMethod)
+				case auth.Auther:
+					ms, err := json.Marshal(def)
+					checkErr(err)
+					json.Unmarshal(ms, &defaultAuther)
+				}
+			}
+		}
+	}
+
 	var auther auth.Auther
 	if method == auth.MethodProxyAuth {
 		header := mustGetString(flags, "auth.header")
+
 		if header == "" {
-			panic(nerrors.New("you must set the flag 'auth.header' for method 'proxy'"))
+			header = defaultAuther["header"].(string)
 		}
+
+		if header == "" {
+			checkErr(nerrors.New("you must set the flag 'auth.header' for method 'proxy'"))
+		}
+
 		auther = &auth.ProxyAuth{Header: header}
 	}
 
@@ -62,11 +84,22 @@ func getAuthentication(flags *pflag.FlagSet) (settings.AuthMethod, auth.Auther)
 
 	if method == auth.MethodJSONAuth {
 		jsonAuth := &auth.JSONAuth{}
-
 		host := mustGetString(flags, "recaptcha.host")
 		key := mustGetString(flags, "recaptcha.key")
 		secret := mustGetString(flags, "recaptcha.secret")
 
+		if key == "" {
+			if kmap, ok := defaultAuther["recaptcha"].(map[string]interface{}); ok {
+				key = kmap["key"].(string)
+			}
+		}
+
+		if secret == "" {
+			if smap, ok := defaultAuther["recaptcha"].(map[string]interface{}); ok {
+				secret = smap["secret"].(string)
+			}
+		}
+
 		if key != "" && secret != "" {
 			jsonAuth.ReCaptcha = &auth.ReCaptcha{
 				Host:   host,
@@ -74,7 +107,6 @@ func getAuthentication(flags *pflag.FlagSet) (settings.AuthMethod, auth.Auther)
 				Secret: secret,
 			}
 		}
-
 		auther = jsonAuth
 	}
 
@@ -101,6 +133,7 @@ func printSettings(ser *settings.Server, set *settings.Settings, auther auth.Aut
 	fmt.Fprintf(w, "\tPort:\t%s\n", ser.Port)
 	fmt.Fprintf(w, "\tBase URL:\t%s\n", ser.BaseURL)
 	fmt.Fprintf(w, "\tRoot:\t%s\n", ser.Root)
+	fmt.Fprintf(w, "\tSocket:\t%s\n", ser.Socket)
 	fmt.Fprintf(w, "\tAddress:\t%s\n", ser.Address)
 	fmt.Fprintf(w, "\tTLS Cert:\t%s\n", ser.TLSCert)
 	fmt.Fprintf(w, "\tTLS Key:\t%s\n", ser.TLSKey)

cmd/config_init.go

@@ -43,6 +43,7 @@ override the options.`,
 
 		ser := &settings.Server{
 			Address: mustGetString(flags, "address"),
+			Socket:  mustGetString(flags, "socket"),
 			Root:    mustGetString(flags, "root"),
 			BaseURL: mustGetString(flags, "baseurl"),
 			TLSKey:  mustGetString(flags, "key"),

cmd/config_set.go

@@ -3,7 +3,6 @@ package cmd
 import (
 	"strings"
 
-	"github.com/filebrowser/filebrowser/v2/auth"
 	"github.com/spf13/cobra"
 	"github.com/spf13/pflag"
 )
@@ -34,6 +33,8 @@ you want to change. Other options will remain unchanged.`,
 				ser.BaseURL = mustGetString(flags, flag.Name)
 			case "root":
 				ser.Root = mustGetString(flags, flag.Name)
+			case "socket":
+				ser.Socket = mustGetString(flags, flag.Name)
 			case "cert":
 				ser.TLSCert = mustGetString(flags, flag.Name)
 			case "key":
@@ -61,16 +62,15 @@ you want to change. Other options will remain unchanged.`,
 
 		getUserDefaults(flags, &set.Defaults, false)
 
-		var auther auth.Auther
-		if hasAuth {
-			set.AuthMethod, auther = getAuthentication(flags)
-			err = d.store.Auth.Save(auther)
-			checkErr(err)
-		} else {
-			auther, err = d.store.Auth.Get(set.AuthMethod)
-			checkErr(err)
-		}
+		// read the defaults
+		auther, err := d.store.Auth.Get(set.AuthMethod)
+		checkErr(err)
 
+		// check if there are new flags for existing auth method
+		set.AuthMethod, auther = getAuthentication(flags, hasAuth, set, auther)
+
+		err = d.store.Auth.Save(auther)
+		checkErr(err)
 		err = d.store.Settings.Save(set)
 		checkErr(err)
 		err = d.store.Settings.SaveServer(ser)

cmd/root.go

@@ -2,13 +2,16 @@ package cmd
 
 import (
 	"crypto/tls"
+	"errors"
 	"io/ioutil"
 	"log"
 	"net"
 	"net/http"
 	"os"
+	"os/signal"
 	"path/filepath"
 	"strings"
+	"syscall"
 
 	"github.com/filebrowser/filebrowser/v2/auth"
 	fbhttp "github.com/filebrowser/filebrowser/v2/http"
@@ -50,6 +53,7 @@ func addServerFlags(flags *pflag.FlagSet) {
 	flags.StringP("cert", "t", "", "tls certificate")
 	flags.StringP("key", "k", "", "tls key")
 	flags.StringP("root", "r", ".", "root to prepend to relative paths")
+	flags.String("socket", "", "socket to listen to (cannot be used with address, port, cert nor key flags)")
 	flags.StringP("baseurl", "b", "", "base url")
 }
 
@@ -109,7 +113,10 @@ user created with the credentials from options "username" and "password".`,
 
 		var listener net.Listener
 
-		if server.TLSKey != "" && server.TLSCert != "" {
+		if server.Socket != "" {
+			listener, err = net.Listen("unix", server.Socket)
+			checkErr(err)
+		} else if server.TLSKey != "" && server.TLSCert != "" {
 			cer, err := tls.LoadX509KeyPair(server.TLSCert, server.TLSKey)
 			checkErr(err)
 			listener, err = tls.Listen("tcp", adr, &tls.Config{Certificates: []tls.Certificate{cer}})
@@ -119,9 +126,15 @@ user created with the credentials from options "username" and "password".`,
 			checkErr(err)
 		}
 
+		sigc := make(chan os.Signal, 1)
+		signal.Notify(sigc, os.Interrupt, syscall.SIGTERM)
+		go cleanupHandler(listener, sigc)
+
 		handler, err := fbhttp.NewHandler(d.store, server)
 		checkErr(err)
 
+		defer listener.Close()
+
 		log.Println("Listening on", listener.Addr().String())
 		if err := http.Serve(listener, handler); err != nil {
 			log.Fatal(err)
@@ -129,6 +142,13 @@ user created with the credentials from options "username" and "password".`,
 	}, pythonConfig{allowNoDB: true}),
 }
 
+func cleanupHandler(listener net.Listener, c chan os.Signal) {
+	sig := <-c
+	log.Printf("Caught signal %s: shutting down.", sig)
+	listener.Close()
+	os.Exit(0)
+}
+
 func getRunParams(flags *pflag.FlagSet, st *storage.Storage) *settings.Server {
 	server, err := st.Settings.GetServer()
 	checkErr(err)
@@ -141,24 +161,45 @@ func getRunParams(flags *pflag.FlagSet, st *storage.Storage) *settings.Server {
 		server.BaseURL = val
 	}
 
-	if val, set := getParamB(flags, "address"); set {
-		server.Address = val
-	}
-
-	if val, set := getParamB(flags, "port"); set {
-		server.Port = val
-	}
-
 	if val, set := getParamB(flags, "log"); set {
 		server.Log = val
 	}
 
+	isSocketSet := false
+	isAddrSet := false
+
+	if val, set := getParamB(flags, "address"); set {
+		server.Address = val
+		isAddrSet = isAddrSet || set
+	}
+
+	if val, set := getParamB(flags, "port"); set {
+		server.Port = val
+		isAddrSet = isAddrSet || set
+	}
+
 	if val, set := getParamB(flags, "key"); set {
 		server.TLSKey = val
+		isAddrSet = isAddrSet || set
 	}
 
 	if val, set := getParamB(flags, "cert"); set {
 		server.TLSCert = val
+		isAddrSet = isAddrSet || set
+	}
+
+	if val, set := getParamB(flags, "socket"); set {
+		server.Socket = val
+		isSocketSet = isSocketSet || set
+	}
+
+	if isAddrSet && isSocketSet {
+		checkErr(errors.New("--socket flag cannot be used with --address, --port, --key nor --cert"))
+	}
+
+	// Do not use saved Socket if address was manually set.
+	if isAddrSet && server.Socket != "" {
+		server.Socket = ""
 	}
 
 	return server

http/public.go

@@ -2,6 +2,7 @@ package http
 
 import (
 	"net/http"
+	"strings"
 
 	"github.com/filebrowser/filebrowser/v2/files"
 )
@@ -10,7 +11,10 @@ var withHashFile = func(fn handleFunc) handleFunc {
 	return func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
 		link, err := d.store.Share.GetByHash(r.URL.Path)
 		if err != nil {
-			return errToStatus(err), err
+			link, err = d.store.Share.GetByHash(ifPathWithName(r))
+			if err != nil {
+				return errToStatus(err), err
+			}
 		}
 
 		user, err := d.store.Users.Get(d.server.Root, link.UserID)
@@ -36,6 +40,12 @@ var withHashFile = func(fn handleFunc) handleFunc {
 	}
 }
 
+func ifPathWithName(r *http.Request) string {
+	pathElements := strings.Split(r.URL.Path, "/")
+	id := pathElements[len(pathElements)-2]
+	return id
+}
+
 var publicShareHandler = withHashFile(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
 	return renderJSON(w, r, d.raw)
 })

settings/settings.go

@@ -32,6 +32,7 @@ func (s *Settings) GetRules() []rules.Rule {
 type Server struct {
 	Root    string `json:"root"`
 	BaseURL string `json:"baseURL"`
+	Socket  string `json:"socket"`
 	TLSKey  string `json:"tlsKey"`
 	TLSCert string `json:"tlsCert"`
 	Port    string `json:"port"`