3 |
5 |
6 |
7 |
20 |
21 |
24 |
--------------------------------------------------------------------------------
/cmd/rules_ls.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "github.com/spf13/cobra"
5 | )
6 |
7 | func init() {
8 | rulesCmd.AddCommand(rulesLsCommand)
9 | }
10 |
11 | var rulesLsCommand = &cobra.Command{
12 | Use: "ls",
13 | Short: "List global rules or user specific rules",
14 | Long: `List global rules or user specific rules.`,
15 | Args: cobra.NoArgs,
16 | Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
17 | runRules(d.store, cmd, nil, nil)
18 | }, pythonConfig{}),
19 | }
20 |
--------------------------------------------------------------------------------
/frontend/src/components/buttons/Move.vue:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
18 |
--------------------------------------------------------------------------------
/frontend/src/components/buttons/Copy.vue:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
18 |
--------------------------------------------------------------------------------
/frontend/src/components/buttons/Delete.vue:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
18 |
--------------------------------------------------------------------------------
/users/password.go:
--------------------------------------------------------------------------------
1 | package users
2 |
3 | import (
4 | "golang.org/x/crypto/bcrypt"
5 | )
6 |
7 | // HashPwd hashes a password.
8 | func HashPwd(password string) (string, error) {
9 | bytes, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
10 | return string(bytes), err
11 | }
12 |
13 | // CheckPwd checks if a password is correct.
14 | func CheckPwd(password, hash string) bool {
15 | err := bcrypt.CompareHashAndPassword([]byte(hash), []byte(password))
16 | return err == nil
17 | }
18 |
--------------------------------------------------------------------------------
/frontend/src/components/buttons/Rename.vue:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
18 |
--------------------------------------------------------------------------------
/frontend/src/components/buttons/Upload.vue:
--------------------------------------------------------------------------------
1 |
2 |
6 |
7 |
8 |
18 |
--------------------------------------------------------------------------------
/cmd/cmds.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/spf13/cobra"
7 | )
8 |
9 | func init() {
10 | rootCmd.AddCommand(cmdsCmd)
11 | }
12 |
13 | var cmdsCmd = &cobra.Command{
14 | Use: "cmds",
15 | Short: "Command runner management utility",
16 | Long: `Command runner management utility.`,
17 | Args: cobra.NoArgs,
18 | }
19 |
20 | func printEvents(m map[string][]string) {
21 | for evt, cmds := range m {
22 | for i, cmd := range cmds {
23 | fmt.Printf("%s(%d): %s\n", evt, i, cmd)
24 | }
25 | }
26 | }
27 |
--------------------------------------------------------------------------------
/frontend/public/manifest.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "File Browser",
3 | "short_name": "File Browser",
4 | "icons": [
5 | {
6 | "src": "./img/icons/android-chrome-192x192.png",
7 | "sizes": "192x192",
8 | "type": "image/png"
9 | },
10 | {
11 | "src": "./static/img/icons/android-chrome-512x512.png",
12 | "sizes": "512x512",
13 | "type": "image/png"
14 | }
15 | ],
16 | "start_url": "./",
17 | "display": "standalone",
18 | "background_color": "#ffffff",
19 | "theme_color": "#455a64"
20 | }
21 |
--------------------------------------------------------------------------------
/cmd/hash.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/filebrowser/filebrowser/v2/users"
7 | "github.com/spf13/cobra"
8 | )
9 |
10 | func init() {
11 | rootCmd.AddCommand(hashCmd)
12 | }
13 |
14 | var hashCmd = &cobra.Command{
15 | Use: "hash
3 |
7 |
8 |
9 |
25 |
--------------------------------------------------------------------------------
/cmd/users_export.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "github.com/spf13/cobra"
5 | )
6 |
7 | func init() {
8 | usersCmd.AddCommand(usersExportCmd)
9 | }
10 |
11 | var usersExportCmd = &cobra.Command{
12 | Use: "export {{ $t('settings.userCommands') }}
4 |{{ $t('settings.userCommandsHelp') }} git svn hg.
5 | 6 |
3 |
8 |
9 |
11 |
12 |
13 |
21 |
--------------------------------------------------------------------------------
/storage/bolt/auth.go:
--------------------------------------------------------------------------------
1 | package bolt
2 |
3 | import (
4 | "github.com/asdine/storm"
5 | "github.com/filebrowser/filebrowser/v2/auth"
6 | "github.com/filebrowser/filebrowser/v2/errors"
7 | "github.com/filebrowser/filebrowser/v2/settings"
8 | )
9 |
10 | type authBackend struct {
11 | db *storm.DB
12 | }
13 |
14 | func (s authBackend) Get(t settings.AuthMethod) (auth.Auther, error) {
15 | var auther auth.Auther
16 |
17 | switch t {
18 | case auth.MethodJSONAuth:
19 | auther = &auth.JSONAuth{}
20 | case auth.MethodProxyAuth:
21 | auther = &auth.ProxyAuth{}
22 | case auth.MethodNoAuth:
23 | auther = &auth.NoAuth{}
24 | default:
25 | return nil, errors.ErrInvalidAuthMethod
26 | }
27 |
28 | return auther, get(s.db, "auther", auther)
29 | }
30 |
31 | func (s authBackend) Save(a auth.Auther) error {
32 | return save(s.db, "auther", a)
33 | }
34 |
--------------------------------------------------------------------------------
/runner/parser.go:
--------------------------------------------------------------------------------
1 | package runner
2 |
3 | import (
4 | "os/exec"
5 |
6 | "github.com/filebrowser/filebrowser/v2/settings"
7 | "github.com/caddyserver/caddy"
8 | )
9 |
10 | // ParseCommand parses the command taking in account if the current
11 | // instance uses a shell to run the commands or just calls the binary
12 | // directyly.
13 | func ParseCommand(s *settings.Settings, raw string) ([]string, error) {
14 | command := []string{}
15 |
16 | if len(s.Shell) == 0 {
17 | cmd, args, err := caddy.SplitCommandAndArgs(raw)
18 | if err != nil {
19 | return nil, err
20 | }
21 |
22 | _, err = exec.LookPath(cmd)
23 | if err != nil {
24 | return nil, err
25 | }
26 |
27 | command = append(command, cmd)
28 | command = append(command, args...)
29 | } else {
30 | command = append(s.Shell, raw)
31 | }
32 |
33 | return command, nil
34 | }
35 |
--------------------------------------------------------------------------------
/settings/defaults.go:
--------------------------------------------------------------------------------
1 | package settings
2 |
3 | import (
4 | "github.com/filebrowser/filebrowser/v2/files"
5 | "github.com/filebrowser/filebrowser/v2/users"
6 | )
7 |
8 | // UserDefaults is a type that holds the default values
9 | // for some fields on User.
10 | type UserDefaults struct {
11 | Scope string `json:"scope"`
12 | Locale string `json:"locale"`
13 | ViewMode users.ViewMode `json:"viewMode"`
14 | Sorting files.Sorting `json:"sorting"`
15 | Perm users.Permissions `json:"perm"`
16 | Commands []string `json:"commands"`
17 | }
18 |
19 | // Apply applies the default options to a user.
20 | func (d *UserDefaults) Apply(u *users.User) {
21 | u.Scope = d.Scope
22 | u.Locale = d.Locale
23 | u.ViewMode = d.ViewMode
24 | u.Perm = d.Perm
25 | u.Sorting = d.Sorting
26 | u.Commands = d.Commands
27 | }
28 |
--------------------------------------------------------------------------------
/cmd/cmds_ls.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "github.com/spf13/cobra"
5 | )
6 |
7 | func init() {
8 | cmdsCmd.AddCommand(cmdsLsCmd)
9 | cmdsLsCmd.Flags().StringP("event", "e", "", "event name, without 'before' or 'after'")
10 | }
11 |
12 | var cmdsLsCmd = &cobra.Command{
13 | Use: "ls",
14 | Short: "List all commands for each event",
15 | Long: `List all commands for each event.`,
16 | Args: cobra.NoArgs,
17 | Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
18 | s, err := d.store.Settings.Get()
19 | checkErr(err)
20 | evt := mustGetString(cmd.Flags(), "event")
21 |
22 | if evt == "" {
23 | printEvents(s.Commands)
24 | } else {
25 | show := map[string][]string{}
26 | show["before_"+evt] = s.Commands["before_"+evt]
27 | show["after_"+evt] = s.Commands["after_"+evt]
28 | printEvents(show)
29 | }
30 | }, pythonConfig{}),
31 | }
32 |
--------------------------------------------------------------------------------
/auth/storage.go:
--------------------------------------------------------------------------------
1 | package auth
2 |
3 | import (
4 | "github.com/filebrowser/filebrowser/v2/settings"
5 | "github.com/filebrowser/filebrowser/v2/users"
6 | )
7 |
8 | // StorageBackend is a storage backend for auth storage.
9 | type StorageBackend interface {
10 | Get(settings.AuthMethod) (Auther, error)
11 | Save(Auther) error
12 | }
13 |
14 | // Storage is a auth storage.
15 | type Storage struct {
16 | back StorageBackend
17 | users *users.Storage
18 | }
19 |
20 | // NewStorage creates a auth storage from a backend.
21 | func NewStorage(back StorageBackend, users *users.Storage) *Storage {
22 | return &Storage{back: back, users: users}
23 | }
24 |
25 | // Get wraps a StorageBackend.Get.
26 | func (s *Storage) Get(t settings.AuthMethod) (Auther, error) {
27 | return s.back.Get(t)
28 | }
29 |
30 | // Save wraps a StorageBackend.Save.
31 | func (s *Storage) Save(a Auther) error {
32 | return s.back.Save(a)
33 | }
34 |
--------------------------------------------------------------------------------
/storage/bolt/bolt.go:
--------------------------------------------------------------------------------
1 | package bolt
2 |
3 | import (
4 | "github.com/asdine/storm"
5 | "github.com/filebrowser/filebrowser/v2/auth"
6 | "github.com/filebrowser/filebrowser/v2/settings"
7 | "github.com/filebrowser/filebrowser/v2/share"
8 | "github.com/filebrowser/filebrowser/v2/storage"
9 | "github.com/filebrowser/filebrowser/v2/users"
10 | )
11 |
12 | // NewStorage creates a storage.Storage based on Bolt DB.
13 | func NewStorage(db *storm.DB) (*storage.Storage, error) {
14 | users := users.NewStorage(usersBackend{db: db})
15 | share := share.NewStorage(shareBackend{db: db})
16 | settings := settings.NewStorage(settingsBackend{db: db})
17 | auth := auth.NewStorage(authBackend{db: db}, users)
18 |
19 | err := save(db, "version", 2)
20 | if err != nil {
21 | return nil, err
22 | }
23 |
24 | return &storage.Storage{
25 | Auth: auth,
26 | Users: users,
27 | Share: share,
28 | Settings: settings,
29 | }, nil
30 | }
31 |
--------------------------------------------------------------------------------
/cmd/upgrade.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "github.com/filebrowser/filebrowser/v2/storage/bolt/importer"
5 | "github.com/spf13/cobra"
6 | )
7 |
8 | func init() {
9 | rootCmd.AddCommand(upgradeCmd)
10 |
11 | upgradeCmd.Flags().String("old.database", "", "")
12 | upgradeCmd.Flags().String("old.config", "", "")
13 | upgradeCmd.MarkFlagRequired("old.database")
14 | }
15 |
16 | var upgradeCmd = &cobra.Command{
17 | Use: "upgrade",
18 | Short: "Upgrades an old configuration",
19 | Long: `Upgrades an old configuration. This command DOES NOT
20 | import share links because they are incompatible with
21 | this version.`,
22 | Args: cobra.NoArgs,
23 | Run: func(cmd *cobra.Command, args []string) {
24 | flags := cmd.Flags()
25 | oldDB := mustGetString(flags, "old.database")
26 | oldConf := mustGetString(flags, "old.config")
27 | err := importer.Import(oldDB, oldConf, getParam(flags, "database"))
28 | checkErr(err)
29 | },
30 | }
31 |
--------------------------------------------------------------------------------
/frontend/src/utils/url.js:
--------------------------------------------------------------------------------
1 | function removeLastDir (url) {
2 | var arr = url.split('/')
3 | if (arr.pop() === '') {
4 | arr.pop()
5 | }
6 |
7 | return arr.join('/')
8 | }
9 |
10 | // this code borrow from mozilla
11 | // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/encodeURIComponent#Examples
12 | function encodeRFC5987ValueChars(str) {
13 | return encodeURIComponent(str).
14 | // Note that although RFC3986 reserves "!", RFC5987 does not,
15 | // so we do not need to escape it
16 | replace(/['()]/g, escape). // i.e., %27 %28 %29
17 | replace(/\*/g, '%2A').
18 | // The following are not required for percent-encoding per RFC5987,
19 | // so we can allow for a little better readability over the wire: |`^
20 | replace(/%(?:7C|60|5E)/g, unescape);
21 | }
22 |
23 | export default {
24 | encodeRFC5987ValueChars: encodeRFC5987ValueChars,
25 | removeLastDir: removeLastDir
26 | }
27 |
--------------------------------------------------------------------------------
/auth/proxy.go:
--------------------------------------------------------------------------------
1 | package auth
2 |
3 | import (
4 | "net/http"
5 | "os"
6 |
7 | "github.com/filebrowser/filebrowser/v2/errors"
8 | "github.com/filebrowser/filebrowser/v2/settings"
9 | "github.com/filebrowser/filebrowser/v2/users"
10 | )
11 |
12 | // MethodProxyAuth is used to identify no auth.
13 | const MethodProxyAuth settings.AuthMethod = "proxy"
14 |
15 | // ProxyAuth is a proxy implementation of an auther.
16 | type ProxyAuth struct {
17 | Header string `json:"header"`
18 | }
19 |
20 | // Auth authenticates the user via an HTTP header.
21 | func (a ProxyAuth) Auth(r *http.Request, sto *users.Storage, root string) (*users.User, error) {
22 | username := r.Header.Get(a.Header)
23 | user, err := sto.Get(root, username)
24 | if err == errors.ErrNotExist {
25 | return nil, os.ErrPermission
26 | }
27 |
28 | return user, err
29 | }
30 |
31 | // LoginPage tells that proxy auth doesn't require a login page.
32 | func (a ProxyAuth) LoginPage() bool {
33 | return false
34 | }
35 |
--------------------------------------------------------------------------------
/frontend/src/components/prompts/Replace.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
22 |
23 |
24 |
32 |
--------------------------------------------------------------------------------
/frontend/src/main.js:
--------------------------------------------------------------------------------
1 | import { sync } from 'vuex-router-sync'
2 | import store from '@/store'
3 | import router from '@/router'
4 | import i18n from '@/i18n'
5 | import Vue from '@/utils/vue'
6 | import { recaptcha, loginPage } from '@/utils/constants'
7 | import { login, validateLogin } from '@/utils/auth'
8 | import App from '@/App'
9 |
10 | sync(store, router)
11 |
12 | async function start () {
13 | if (loginPage) {
14 | await validateLogin()
15 | } else {
16 | await login('', '', '')
17 | }
18 |
19 | if (recaptcha) {
20 | await new Promise (resolve => {
21 | const check = () => {
22 | if (typeof window.grecaptcha === 'undefined') {
23 | setTimeout(check, 100)
24 | } else {
25 | resolve()
26 | }
27 | }
28 |
29 | check()
30 | })
31 | }
32 |
33 | new Vue({
34 | el: '#app',
35 | store,
36 | router,
37 | i18n,
38 | template: '
4 |
6 |
7 | {{ $t('prompts.replace') }}
5 |
8 |
10 |
11 | {{ $t('prompts.replaceMessage') }}
9 |
12 |
16 |
20 |
21 |
3 |
9 |
12 |
14 |
15 |
16 |
44 |
--------------------------------------------------------------------------------
/frontend/src/api/users.js:
--------------------------------------------------------------------------------
1 | import { fetchURL, fetchJSON } from './utils'
2 |
3 | export async function getAll () {
4 | return fetchJSON(`/api/users`, {})
5 | }
6 |
7 | export async function get (id) {
8 | return fetchJSON(`/api/users/${id}`, {})
9 | }
10 |
11 | export async function create (user) {
12 | const res = await fetchURL(`/api/users`, {
13 | method: 'POST',
14 | body: JSON.stringify({
15 | what: 'user',
16 | which: [],
17 | data: user
18 | })
19 | })
20 |
21 | if (res.status === 201) {
22 | return res.headers.get('Location')
23 | } else {
24 | throw new Error(res.status)
25 | }
26 |
27 | }
28 |
29 | export async function update (user, which = ['all']) {
30 | const res = await fetchURL(`/api/users/${user.id}`, {
31 | method: 'PUT',
32 | body: JSON.stringify({
33 | what: 'user',
34 | which: which,
35 | data: user
36 | })
37 | })
38 |
39 | if (res.status !== 200) {
40 | throw new Error(res.status)
41 | }
42 | }
43 |
44 | export async function remove (id) {
45 | const res = await fetchURL(`/api/users/${id}`, {
46 | method: 'DELETE'
47 | })
48 |
49 | if (res.status !== 200) {
50 | throw new Error(res.status)
51 | }
52 | }
53 |
--------------------------------------------------------------------------------
/cmd/users_find.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "github.com/filebrowser/filebrowser/v2/users"
5 | "github.com/spf13/cobra"
6 | )
7 |
8 | func init() {
9 | usersCmd.AddCommand(usersFindCmd)
10 | usersCmd.AddCommand(usersLsCmd)
11 | }
12 |
13 | var usersFindCmd = &cobra.Command{
14 | Use: "find
4 |
5 |
6 |
3 |
29 |
30 |
31 |
34 |
35 |
--------------------------------------------------------------------------------
/frontend/src/utils/vue.js:
--------------------------------------------------------------------------------
1 | import Vue from 'vue'
2 | import Noty from 'noty'
3 | import i18n from '@/i18n'
4 | import { disableExternal } from '@/utils/constants'
5 |
6 | Vue.config.productionTip = true
7 |
8 | const notyDefault = {
9 | type: 'info',
10 | layout: 'bottomRight',
11 | timeout: 1000,
12 | progressBar: true
13 | }
14 |
15 | Vue.prototype.$noty = (opts) => {
16 | new Noty(Object.assign({}, notyDefault, opts)).show()
17 | }
18 |
19 | Vue.prototype.$showSuccess = (message) => {
20 | new Noty(Object.assign({}, notyDefault, {
21 | text: message,
22 | type: 'success'
23 | })).show()
24 | }
25 |
26 | Vue.prototype.$showError = (error) => {
27 | let btns = [
28 | Noty.button(i18n.t('buttons.close'), '', function () {
29 | n.close()
30 | })
31 | ]
32 |
33 | if (!disableExternal) {
34 | btns.unshift(Noty.button(i18n.t('buttons.reportIssue'), '', function () {
35 | window.open('https://github.com/filebrowser/filebrowser/issues/new/choose')
36 | }))
37 | }
38 |
39 | let n = new Noty(Object.assign({}, notyDefault, {
40 | text: error.message || error,
41 | type: 'error',
42 | timeout: null,
43 | buttons: btns
44 | }))
45 |
46 | n.show()
47 | }
48 |
49 | Vue.directive('focus', {
50 | inserted: function (el) {
51 | el.focus()
52 | }
53 | })
54 |
55 | export default Vue
56 |
--------------------------------------------------------------------------------
/storage/bolt/share.go:
--------------------------------------------------------------------------------
1 | package bolt
2 |
3 | import (
4 | "github.com/asdine/storm"
5 | "github.com/asdine/storm/q"
6 | "github.com/filebrowser/filebrowser/v2/errors"
7 | "github.com/filebrowser/filebrowser/v2/share"
8 | )
9 |
10 | type shareBackend struct {
11 | db *storm.DB
12 | }
13 |
14 | func (s shareBackend) GetByHash(hash string) (*share.Link, error) {
15 | var v share.Link
16 | err := s.db.One("Hash", hash, &v)
17 | if err == storm.ErrNotFound {
18 | return nil, errors.ErrNotExist
19 | }
20 |
21 | return &v, err
22 | }
23 |
24 | func (s shareBackend) GetPermanent(path string, id uint) (*share.Link, error) {
25 | var v share.Link
26 | err := s.db.Select(q.Eq("Path", path), q.Eq("Expire", 0), q.Eq("UserID", id)).First(&v)
27 | if err == storm.ErrNotFound {
28 | return nil, errors.ErrNotExist
29 | }
30 |
31 | return &v, err
32 | }
33 |
34 | func (s shareBackend) Gets(path string, id uint) ([]*share.Link, error) {
35 | var v []*share.Link
36 | err := s.db.Select(q.Eq("Path", path), q.Eq("UserID", id)).Find(&v)
37 | if err == storm.ErrNotFound {
38 | return v, errors.ErrNotExist
39 | }
40 |
41 | return v, err
42 | }
43 |
44 | func (s shareBackend) Save(l *share.Link) error {
45 | return s.db.Save(l)
46 | }
47 |
48 | func (s shareBackend) Delete(hash string) error {
49 | return s.db.DeleteStruct(&share.Link{Hash: hash})
50 | }
51 |
--------------------------------------------------------------------------------
/files/utils.go:
--------------------------------------------------------------------------------
1 | package files
2 |
3 | import (
4 | "unicode/utf8"
5 | )
6 |
7 | func isBinary(content []byte, n int) bool {
8 | maybeStr := string(content)
9 | runeCnt := utf8.RuneCount(content)
10 | runeIndex := 0
11 | gotRuneErrCnt := 0
12 | firstRuneErrIndex := -1
13 |
14 | for _, b := range maybeStr {
15 | // 8 and below are control chars (e.g. backspace, null, eof, etc)
16 | if b <= 8 {
17 | return true
18 | }
19 |
20 | // 0xFFFD(65533) is the "error" Rune or "Unicode replacement character"
21 | // see https://golang.org/pkg/unicode/utf8/#pkg-constants
22 | if b == 0xFFFD {
23 | //if it is not the last (utf8.UTFMax - x) rune
24 | if runeCnt > utf8.UTFMax && runeIndex < runeCnt-utf8.UTFMax {
25 | return true
26 | } else {
27 | //else it is the last (utf8.UTFMax - x) rune
28 | //there maybe Vxxx, VVxx, VVVx, thus, we may got max 3 0xFFFD rune (asume V is the byte we got)
29 | //for Chinese, it can only be Vxx, VVx, we may got max 2 0xFFFD rune
30 | gotRuneErrCnt++
31 |
32 | //mark the first time
33 | if firstRuneErrIndex == -1 {
34 | firstRuneErrIndex = runeIndex
35 | }
36 | }
37 | }
38 | runeIndex++
39 | }
40 |
41 | //if last (utf8.UTFMax - x ) rune has the "error" Rune, but not all
42 | if firstRuneErrIndex != -1 && gotRuneErrCnt != runeCnt-firstRuneErrIndex {
43 | return true
44 | }
45 | return false
46 | }
47 |
--------------------------------------------------------------------------------
/.github/PULL_REQUEST_TEMPLATE.md:
--------------------------------------------------------------------------------
1 | **Description**
2 | Please explain the changes you made here.
3 | If the feature changes current behaviour, explain why your solution is better.
4 |
5 | :rotating_light: Before submitting your PR, please read [community](https://github.com/filebrowser/community), and indicate which issues (in any of the repos) are either fixed or closed by this PR. See [GitHub Help: Closing issues using keywords](https://help.github.com/articles/closing-issues-via-commit-messages/).
6 |
7 | - [ ] DO make sure you are requesting to **pull a topic/feature/bugfix branch** (right side). Don't request your master!
8 | - [ ] DO make sure you are making a pull request against the **master branch** (left side). Also you should start *your branch* off *our master*.
9 | - [ ] DO make sure that File Browser can be successfully built. See [builds](https://github.com/filebrowser/community/blob/master/builds.md) and [development](https://github.com/filebrowser/community/blob/master/development.md).
10 | - [ ] DO make sure that related issues are opened in other repositories. I.e., the frontend, caddy plugins or the web page need to be updated accordingly.
11 | - [ ] AVOID breaking the continuous integration build.
12 |
13 | **Further comments**
14 | If this is a relatively large or complex change, kick off the discussion by explaining why you chose the solution you did, what alternatives you considered, etc.
15 |
16 | :heart: Thank you!
17 |
--------------------------------------------------------------------------------
/frontend/src/views/settings/Users.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 | {{ $t('help.help') }}
5 |
8 |
20 |
21 | -
9 |
- F1 - {{ $t('help.f1') }} 10 |
- F2 - {{ $t('help.f2') }} 11 |
- DEL - {{ $t('help.del') }} 12 |
- ESC - {{ $t('help.esc') }} 13 |
- CTRL + S - {{ $t('help.ctrl.s') }} 14 |
- CTRL + F - {{ $t('help.ctrl.f') }} 15 |
- CTRL + Click - {{ $t('help.ctrl.click') }} 16 |
- Click - {{ $t('help.click') }} 17 |
- Double click - {{ $t('help.doubleClick') }} 18 |
22 |
27 |
28 |
3 |
28 |
29 |
30 |
49 |
--------------------------------------------------------------------------------
/fileutils/dir.go:
--------------------------------------------------------------------------------
1 | package fileutils
2 |
3 | import (
4 | "errors"
5 |
6 | "github.com/spf13/afero"
7 | )
8 |
9 | // CopyDir copies a directory from source to dest and all
10 | // of its sub-directories. It doesn't stop if it finds an error
11 | // during the copy. Returns an error if any.
12 | func CopyDir(fs afero.Fs, source string, dest string) error {
13 | // Get properties of source.
14 | srcinfo, err := fs.Stat(source)
15 | if err != nil {
16 | return err
17 | }
18 |
19 | // Create the destination directory.
20 | err = fs.MkdirAll(dest, srcinfo.Mode())
21 | if err != nil {
22 | return err
23 | }
24 |
25 | dir, _ := fs.Open(source)
26 | obs, err := dir.Readdir(-1)
27 | if err != nil {
28 | return err
29 | }
30 |
31 | var errs []error
32 |
33 | for _, obj := range obs {
34 | fsource := source + "/" + obj.Name()
35 | fdest := dest + "/" + obj.Name()
36 |
37 | if obj.IsDir() {
38 | // Create sub-directories, recursively.
39 | err = CopyDir(fs, fsource, fdest)
40 | if err != nil {
41 | errs = append(errs, err)
42 | }
43 | } else {
44 | // Perform the file copy.
45 | err = CopyFile(fs, fsource, fdest)
46 | if err != nil {
47 | errs = append(errs, err)
48 | }
49 | }
50 | }
51 |
52 | var errString string
53 | for _, err := range errs {
54 | errString += err.Error() + "\n"
55 | }
56 |
57 | if errString != "" {
58 | return errors.New(errString)
59 | }
60 |
61 | return nil
62 | }
63 |
--------------------------------------------------------------------------------
/.goreleaser.yml:
--------------------------------------------------------------------------------
1 | project_name: filebrowser
2 |
3 | env:
4 | - GO111MODULE=on
5 |
6 | before:
7 | hooks:
8 | - go mod download
9 |
10 | build:
11 | env:
12 | - CGO_ENABLED=0
13 | ldflags:
14 | - -s -w -X github.com/filebrowser/filebrowser/v2/version.Version={{ .Version }} -X github.com/filebrowser/filebrowser/v2/version.CommitSHA={{ .ShortCommit }}
15 | main: main.go
16 | binary: filebrowser
17 | goos:
18 | - darwin
19 | - linux
20 | - windows
21 | - freebsd
22 | - netbsd
23 | - openbsd
24 | - dragonfly
25 | - solaris
26 | goarch:
27 | - amd64
28 | - 386
29 | - arm
30 | - arm64
31 | goarm:
32 | - 5
33 | - 6
34 | - 7
35 | ignore:
36 | - goos: darwin
37 | goarch: 386
38 | - goos: openbsd
39 | goarch: arm
40 | - goos: freebsd
41 | goarch: arm
42 | - goos: netbsd
43 | goarch: arm
44 | - goos: solaris
45 | goarch: arm
46 |
47 | archives:
48 | -
49 | name_template: "{{.Os}}-{{.Arch}}{{if .Arm}}v{{.Arm}}{{end}}-{{ .ProjectName }}"
50 | format: tar.gz
51 | format_overrides:
52 | - goos: windows
53 | format: zip
54 |
55 | dockers:
56 | -
57 | goos: linux
58 | goarch: amd64
59 | goarm: ''
60 | image_templates:
61 | - "filebrowser/filebrowser:latest"
62 | - "filebrowser/filebrowser:{{ .Tag }}"
63 | - "filebrowser/filebrowser:v{{ .Major }}"
64 | extra_files:
65 | - .docker.json
66 |
--------------------------------------------------------------------------------
/cmd/users_add.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "github.com/filebrowser/filebrowser/v2/users"
5 | "github.com/spf13/cobra"
6 | )
7 |
8 | func init() {
9 | usersCmd.AddCommand(usersAddCmd)
10 | addUserFlags(usersAddCmd.Flags())
11 | }
12 |
13 | var usersAddCmd = &cobra.Command{
14 | Use: "add
4 |
7 |
8 | {{ $t('settings.users') }}
5 |
9 |
10 |
26 |
27 | | {{ $t('settings.username') }} | 12 |{{ $t('settings.admin') }} | 13 |{{ $t('settings.scope') }} | 14 |15 | |
|---|---|---|---|
| {{ user.username }} | 19 |doneclose | 20 |{{ user.scope }} | 21 |
22 | |
24 |
3 |
16 |
17 |
18 |
40 |
--------------------------------------------------------------------------------
/cmd/cmds_rm.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "strconv"
5 |
6 | "github.com/spf13/cobra"
7 | )
8 |
9 | func init() {
10 | cmdsCmd.AddCommand(cmdsRmCmd)
11 | }
12 |
13 | var cmdsRmCmd = &cobra.Command{
14 | Use: "rm {{ $t('settings.permissions') }}
4 |{{ $t('settings.permissionsHelp') }}
5 | 6 |{{ $t('settings.administrator') }}
7 | 8 |{{ $t('settings.perm.create') }}
9 |{{ $t('settings.perm.delete') }}
10 |{{ $t('settings.perm.download') }}
11 |{{ $t('settings.perm.modify') }}
12 |{{ $t('settings.perm.execute') }}
13 |{{ $t('settings.perm.rename') }}
14 |{{ $t('settings.perm.share') }}
15 |
3 |
19 |
20 |
21 |
50 |
--------------------------------------------------------------------------------
/http/settings.go:
--------------------------------------------------------------------------------
1 | package http
2 |
3 | import (
4 | "encoding/json"
5 | "net/http"
6 |
7 | "github.com/filebrowser/filebrowser/v2/rules"
8 | "github.com/filebrowser/filebrowser/v2/settings"
9 | )
10 |
11 | type settingsData struct {
12 | Signup bool `json:"signup"`
13 | CreateUserDir bool `json:"createUserDir"`
14 | Defaults settings.UserDefaults `json:"defaults"`
15 | Rules []rules.Rule `json:"rules"`
16 | Branding settings.Branding `json:"branding"`
17 | Shell []string `json:"shell"`
18 | Commands map[string][]string `json:"commands"`
19 | }
20 |
21 | var settingsGetHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
22 | data := &settingsData{
23 | Signup: d.settings.Signup,
24 | CreateUserDir: d.settings.CreateUserDir,
25 | Defaults: d.settings.Defaults,
26 | Rules: d.settings.Rules,
27 | Branding: d.settings.Branding,
28 | Shell: d.settings.Shell,
29 | Commands: d.settings.Commands,
30 | }
31 |
32 | return renderJSON(w, r, data)
33 | })
34 |
35 | var settingsPutHandler = withAdmin(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
36 | req := &settingsData{}
37 | err := json.NewDecoder(r.Body).Decode(req)
38 | if err != nil {
39 | return http.StatusBadRequest, err
40 | }
41 |
42 | d.settings.Signup = req.Signup
43 | d.settings.CreateUserDir = req.CreateUserDir
44 | d.settings.Defaults = req.Defaults
45 | d.settings.Rules = req.Rules
46 | d.settings.Branding = req.Branding
47 | d.settings.Shell = req.Shell
48 | d.settings.Commands = req.Commands
49 |
50 | err = d.store.Settings.Save(d.settings)
51 | return errToStatus(err), err
52 | })
53 |
--------------------------------------------------------------------------------
/settings/settings.go:
--------------------------------------------------------------------------------
1 | package settings
2 |
3 | import (
4 | "crypto/rand"
5 | "strings"
6 |
7 | "github.com/filebrowser/filebrowser/v2/rules"
8 | )
9 |
10 | // AuthMethod describes an authentication method.
11 | type AuthMethod string
12 |
13 | // Settings contain the main settings of the application.
14 | type Settings struct {
15 | Key []byte `json:"key"`
16 | Signup bool `json:"signup"`
17 | CreateUserDir bool `json:"createUserDir"`
18 | Defaults UserDefaults `json:"defaults"`
19 | AuthMethod AuthMethod `json:"authMethod"`
20 | Branding Branding `json:"branding"`
21 | Commands map[string][]string `json:"commands"`
22 | Shell []string `json:"shell"`
23 | Rules []rules.Rule `json:"rules"`
24 | }
25 |
26 | // GetRules implements rules.Provider.
27 | func (s *Settings) GetRules() []rules.Rule {
28 | return s.Rules
29 | }
30 |
31 | // Server specific settings.
32 | type Server struct {
33 | Root string `json:"root"`
34 | BaseURL string `json:"baseURL"`
35 | Socket string `json:"socket"`
36 | TLSKey string `json:"tlsKey"`
37 | TLSCert string `json:"tlsCert"`
38 | Port string `json:"port"`
39 | Address string `json:"address"`
40 | Log string `json:"log"`
41 | }
42 |
43 | // Clean cleans any variables that might need cleaning.
44 | func (s *Server) Clean() {
45 | s.BaseURL = strings.TrimSuffix(s.BaseURL, "/")
46 | }
47 |
48 | // GenerateKey generates a key of 256 bits.
49 | func GenerateKey() ([]byte, error) {
50 | b := make([]byte, 64)
51 | _, err := rand.Read(b)
52 | // Note that err == nil only if we read len(b) bytes.
53 | if err != nil {
54 | return nil, err
55 | }
56 |
57 | return b, nil
58 | }
59 |
--------------------------------------------------------------------------------
/http/data.go:
--------------------------------------------------------------------------------
1 | package http
2 |
3 | import (
4 | "log"
5 | "net/http"
6 | "strconv"
7 |
8 | "github.com/filebrowser/filebrowser/v2/runner"
9 | "github.com/filebrowser/filebrowser/v2/settings"
10 | "github.com/filebrowser/filebrowser/v2/storage"
11 | "github.com/filebrowser/filebrowser/v2/users"
12 | )
13 |
14 | type handleFunc func(w http.ResponseWriter, r *http.Request, d *data) (int, error)
15 |
16 | type data struct {
17 | *runner.Runner
18 | settings *settings.Settings
19 | server *settings.Server
20 | store *storage.Storage
21 | user *users.User
22 | raw interface{}
23 | }
24 |
25 | // Check implements rules.Checker.
26 | func (d *data) Check(path string) bool {
27 | for _, rule := range d.user.Rules {
28 | if rule.Matches(path) {
29 | return rule.Allow
30 | }
31 | }
32 |
33 | for _, rule := range d.settings.Rules {
34 | if rule.Matches(path) {
35 | return rule.Allow
36 | }
37 | }
38 |
39 | return true
40 | }
41 |
42 | func handle(fn handleFunc, prefix string, storage *storage.Storage, server *settings.Server) http.Handler {
43 | handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
44 | settings, err := storage.Settings.Get()
45 | if err != nil {
46 | log.Fatalln("ERROR: couldn't get settings")
47 | return
48 | }
49 |
50 | status, err := fn(w, r, &data{
51 | Runner: &runner.Runner{Settings: settings},
52 | store: storage,
53 | settings: settings,
54 | server: server,
55 | })
56 |
57 | if status != 0 {
58 | txt := http.StatusText(status)
59 | http.Error(w, strconv.Itoa(status)+" "+txt, status)
60 | }
61 |
62 | if status >= 400 || err != nil {
63 | log.Printf("%s: %v %s %v", r.URL.Path, status, r.RemoteAddr, err)
64 | }
65 | })
66 |
67 | return http.StripPrefix(prefix, handler)
68 | }
69 |
--------------------------------------------------------------------------------
/cmd/rule_rm.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "strconv"
5 |
6 | "github.com/filebrowser/filebrowser/v2/settings"
7 | "github.com/filebrowser/filebrowser/v2/users"
8 | "github.com/spf13/cobra"
9 | )
10 |
11 | func init() {
12 | rulesCmd.AddCommand(rulesRmCommand)
13 | rulesRmCommand.Flags().Uint("index", 0, "index of rule to remove")
14 | rulesRmCommand.MarkFlagRequired("index")
15 | }
16 |
17 | var rulesRmCommand = &cobra.Command{
18 | Use: "rm
4 |
6 |
7 | {{ $t('prompts.download') }}
5 |
8 |
18 | {{ $t('prompts.downloadMessage') }}
9 | 10 | 11 | 12 | 13 | 14 | 15 | 16 | 17 |
3 |
23 |
24 |
25 |
68 |
--------------------------------------------------------------------------------
/storage/bolt/users.go:
--------------------------------------------------------------------------------
1 | package bolt
2 |
3 | import (
4 | "reflect"
5 |
6 | "github.com/asdine/storm"
7 | "github.com/filebrowser/filebrowser/v2/errors"
8 | "github.com/filebrowser/filebrowser/v2/users"
9 | )
10 |
11 | type usersBackend struct {
12 | db *storm.DB
13 | }
14 |
15 | func (st usersBackend) GetBy(i interface{}) (user *users.User, err error) {
16 | user = &users.User{}
17 |
18 | var arg string
19 | switch i.(type) {
20 | case uint:
21 | arg = "ID"
22 | case string:
23 | arg = "Username"
24 | default:
25 | return nil, errors.ErrInvalidDataType
26 | }
27 |
28 | err = st.db.One(arg, i, user)
29 |
30 | if err != nil {
31 | if err == storm.ErrNotFound {
32 | return nil, errors.ErrNotExist
33 | }
34 | return nil, err
35 | }
36 |
37 | return
38 | }
39 |
40 | func (st usersBackend) Gets() ([]*users.User, error) {
41 | users := []*users.User{}
42 | err := st.db.All(&users)
43 | if err == storm.ErrNotFound {
44 | return nil, errors.ErrNotExist
45 | }
46 |
47 | if err != nil {
48 | return users, err
49 | }
50 |
51 | return users, err
52 | }
53 |
54 | func (st usersBackend) Update(user *users.User, fields ...string) error {
55 | if len(fields) == 0 {
56 | return st.Save(user)
57 | }
58 |
59 | for _, field := range fields {
60 | val := reflect.ValueOf(user).Elem().FieldByName(field).Interface()
61 | if err := st.db.UpdateField(user, field, val); err != nil {
62 | return err
63 | }
64 | }
65 |
66 | return nil
67 | }
68 |
69 | func (st usersBackend) Save(user *users.User) error {
70 | err := st.db.Save(user)
71 | if err == storm.ErrAlreadyExists {
72 | return errors.ErrExist
73 | }
74 | return err
75 | }
76 |
77 | func (st usersBackend) DeleteByID(id uint) error {
78 | return st.db.DeleteStruct(&users.User{ID: id})
79 | }
80 |
81 | func (st usersBackend) DeleteByUsername(username string) error {
82 | user, err := st.GetBy(username)
83 | if err != nil {
84 | return err
85 | }
86 |
87 | return st.db.DeleteStruct(user)
88 | }
89 |
--------------------------------------------------------------------------------
/frontend/src/components/prompts/NewFile.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 | {{ $t('prompts.move') }}
5 |
8 |
10 |
11 |
12 |
16 |
21 |
22 |
3 |
27 |
28 |
29 |
71 |
72 |
--------------------------------------------------------------------------------
/frontend/src/components/prompts/NewDir.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 | {{ $t('prompts.newFile') }}
5 |
8 |
11 |
12 | {{ $t('prompts.newFileMessage') }}
9 | 10 |
13 |
19 |
25 |
26 |
3 |
27 |
28 |
29 |
71 |
72 |
--------------------------------------------------------------------------------
/http/public.go:
--------------------------------------------------------------------------------
1 | package http
2 |
3 | import (
4 | "net/http"
5 | "strings"
6 |
7 | "github.com/filebrowser/filebrowser/v2/files"
8 | )
9 |
10 | var withHashFile = func(fn handleFunc) handleFunc {
11 | return func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
12 | link, err := d.store.Share.GetByHash(r.URL.Path)
13 | if err != nil {
14 | link, err = d.store.Share.GetByHash(ifPathWithName(r))
15 | if err != nil {
16 | return errToStatus(err), err
17 | }
18 | }
19 |
20 | user, err := d.store.Users.Get(d.server.Root, link.UserID)
21 | if err != nil {
22 | return errToStatus(err), err
23 | }
24 |
25 | d.user = user
26 |
27 | file, err := files.NewFileInfo(files.FileOptions{
28 | Fs: d.user.Fs,
29 | Path: link.Path,
30 | Modify: d.user.Perm.Modify,
31 | Expand: false,
32 | Checker: d,
33 | })
34 | if err != nil {
35 | return errToStatus(err), err
36 | }
37 |
38 | d.raw = file
39 | return fn(w, r, d)
40 | }
41 | }
42 |
43 | // ref to https://github.com/filebrowser/filebrowser/pull/727
44 | // `/api/public/dl/MEEuZK-v/file-name.txt` for old browsers to save file with correct name
45 | func ifPathWithName(r *http.Request) string {
46 | pathElements := strings.Split(r.URL.Path, "/")
47 | // prevent maliciously constructed parameters like `/api/public/dl/XZzCDnK2_not_exists_hash_name`
48 | // len(pathElements) will be 1, and golang will panic `runtime error: index out of range`
49 | if len(pathElements) < 2 {
50 | return r.URL.Path
51 | }
52 | id := pathElements[len(pathElements)-2]
53 | return id
54 | }
55 |
56 | var publicShareHandler = withHashFile(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
57 | return renderJSON(w, r, d.raw)
58 | })
59 |
60 | var publicDlHandler = withHashFile(func(w http.ResponseWriter, r *http.Request, d *data) (int, error) {
61 | file := d.raw.(*files.FileInfo)
62 | if !file.IsDir {
63 | return rawFileHandler(w, r, file)
64 | }
65 |
66 | return rawDirHandler(w, r, d, file)
67 | })
68 |
--------------------------------------------------------------------------------
/frontend/src/components/prompts/Copy.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
6 |
7 | {{ $t('prompts.newDir') }}
5 |
8 |
11 |
12 | {{ $t('prompts.newDirMessage') }}
9 | 10 |
13 |
19 |
25 |
26 |
3 |
24 |
25 |
26 |
68 |
--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
1 |
4 |
6 |
7 | {{ $t('prompts.copy') }}
5 |
8 |
11 |
12 | {{ $t('prompts.copyMessage') }}
9 |
13 |
17 |
22 |
23 |
2 | 
3 |
3 |
36 |
37 |
38 |
66 |
--------------------------------------------------------------------------------
/.circleci/config.yml:
--------------------------------------------------------------------------------
1 | version: 2
2 | jobs:
3 | lint:
4 | docker:
5 | - image: golangci/golangci-lint:v1.16
6 | steps:
7 | - checkout
8 | - run: golangci-lint run -v -D errcheck
9 | build-node:
10 | docker:
11 | - image: circleci/node
12 | steps:
13 | - checkout
14 | - run:
15 | name: "Build"
16 | command: ./wizard.sh -a
17 | - run:
18 | name: "Cleanup"
19 | command: rm -rf frontend/node_modules
20 | - persist_to_workspace:
21 | root: .
22 | paths:
23 | - '*'
24 | build-go:
25 | docker:
26 | - image: circleci/golang:1.12
27 | steps:
28 | - attach_workspace:
29 | at: '~/project'
30 | - run:
31 | name: "Compile"
32 | command: GOOS=linux GOARCH=amd64 ./wizard.sh -c
33 | - run:
34 | name: "Cleanup"
35 | command: |
36 | rm -rf frontend/build
37 | git checkout -- go.sum # TODO: why is it being changed?
38 | - persist_to_workspace:
39 | root: .
40 | paths:
41 | - '*'
42 | release:
43 | docker:
44 | - image: circleci/golang:1.12
45 | steps:
46 | - attach_workspace:
47 | at: '~/project'
48 | - setup_remote_docker
49 | - run: docker login -u $DOCKER_USERNAME -p $DOCKER_PASSWORD
50 | - run: curl -sL https://git.io/goreleaser | bash
51 | - run: docker logout
52 | workflows:
53 | version: 2
54 | build-workflow:
55 | jobs:
56 | - lint:
57 | filters:
58 | tags:
59 | only: /.*/
60 | - build-node:
61 | filters:
62 | tags:
63 | only: /.*/
64 | - build-go:
65 | filters:
66 | tags:
67 | only: /.*/
68 | requires:
69 | - build-node
70 | - lint
71 | - release:
72 | context: deploy
73 | requires:
74 | - build-go
75 | filters:
76 | tags:
77 | only: /^v.*/
78 | branches:
79 | ignore: /.*/
--------------------------------------------------------------------------------
/frontend/src/components/files/Editor.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
76 |
--------------------------------------------------------------------------------
/runner/runner.go:
--------------------------------------------------------------------------------
1 | package runner
2 |
3 | import (
4 | "fmt"
5 | "log"
6 | "os"
7 | "os/exec"
8 | "strings"
9 |
10 | "github.com/filebrowser/filebrowser/v2/settings"
11 | "github.com/filebrowser/filebrowser/v2/users"
12 | )
13 |
14 | // Runner is a commands runner.
15 | type Runner struct {
16 | *settings.Settings
17 | }
18 |
19 | // RunHook runs the hooks for the before and after event.
20 | func (r *Runner) RunHook(fn func() error, evt, path, dst string, user *users.User) error {
21 | path = user.FullPath(path)
22 | dst = user.FullPath(dst)
23 |
24 | if val, ok := r.Commands["before_"+evt]; ok {
25 | for _, command := range val {
26 | err := r.exec(command, "before_"+evt, path, dst, user)
27 | if err != nil {
28 | return err
29 | }
30 | }
31 | }
32 |
33 | err := fn()
34 | if err != nil {
35 | return err
36 | }
37 |
38 | if val, ok := r.Commands["after_"+evt]; ok {
39 | for _, command := range val {
40 | err := r.exec(command, "after_"+evt, path, dst, user)
41 | if err != nil {
42 | return err
43 | }
44 | }
45 | }
46 |
47 | return nil
48 | }
49 |
50 | func (r *Runner) exec(raw, evt, path, dst string, user *users.User) error {
51 | blocking := true
52 |
53 | if strings.HasSuffix(raw, "&") {
54 | blocking = false
55 | raw = strings.TrimSpace(strings.TrimSuffix(raw, "&"))
56 | }
57 |
58 | command, err := ParseCommand(r.Settings, raw)
59 | if err != nil {
60 | return err
61 | }
62 |
63 | cmd := exec.Command(command[0], command[1:]...)
64 | cmd.Env = append(os.Environ(), fmt.Sprintf("FILE=%s", path))
65 | cmd.Env = append(cmd.Env, fmt.Sprintf("SCOPE=%s", user.Scope))
66 | cmd.Env = append(cmd.Env, fmt.Sprintf("TRIGGER=%s", evt))
67 | cmd.Env = append(cmd.Env, fmt.Sprintf("USERNAME=%s", user.Username))
68 | cmd.Env = append(cmd.Env, fmt.Sprintf("DESTINATION=%s", dst))
69 |
70 | cmd.Stdin = os.Stdin
71 | cmd.Stdout = os.Stdout
72 | cmd.Stderr = os.Stderr
73 |
74 | if !blocking {
75 | log.Printf("[INFO] Nonblocking Command: \"%s\"", strings.Join(command, " "))
76 | return cmd.Start()
77 | }
78 |
79 | log.Printf("[INFO] Blocking Command: \"%s\"", strings.Join(command, " "))
80 | return cmd.Run()
81 | }
82 |
--------------------------------------------------------------------------------
/frontend/src/components/prompts/Delete.vue:
--------------------------------------------------------------------------------
1 |
2 | 4 | 5 | 6 |
7 | 8 |9 | 10 | 11 |
12 | 13 |14 | 15 | 16 |
17 | 18 |
19 |
20 |
24 | {{ $t('settings.lockPassword') }} 25 |
26 | 27 |
31 |
35 | {{ $t('settings.rules') }}
32 |{{ $t('settings.rulesHelp') }}
33 |
3 |
18 |
19 |
20 |
67 |
--------------------------------------------------------------------------------
/frontend/src/css/base.css:
--------------------------------------------------------------------------------
1 | body {
2 | font-family: 'Roboto', sans-serif;
3 | padding-top: 4em;
4 | background-color: #fafafa;
5 | color: #333333;
6 | }
7 |
8 | * {
9 | box-sizing: border-box;
10 | }
11 |
12 | *,
13 | *:hover,
14 | *:active,
15 | *:focus {
16 | outline: 0
17 | }
18 |
19 | a {
20 | text-decoration: none;
21 | }
22 |
23 | img {
24 | max-width: 100%;
25 | }
26 |
27 | audio,
28 | video {
29 | width: 100%;
30 | }
31 |
32 | .mobile-only {
33 | display: none !important;
34 | }
35 |
36 | .container {
37 | width: 95%;
38 | max-width: 960px;
39 | margin: 1em auto 0;
40 | }
41 |
42 | i.spin {
43 | animation: 1s spin linear infinite;
44 | }
45 |
46 | #app {
47 | transition: .2s ease padding;
48 | }
49 |
50 | #app.multiple {
51 | padding-bottom: 4em;
52 | }
53 |
54 | nav {
55 | width: 16em;
56 | position: fixed;
57 | top: 4em;
58 | left: 0;
59 | }
60 |
61 | nav .action {
62 | width: 100%;
63 | display: block;
64 | border-radius: 0;
65 | font-size: 1.1em;
66 | padding: .5em;
67 | white-space: nowrap;
68 | overflow: hidden;
69 | text-overflow: ellipsis;
70 | }
71 |
72 | nav>div {
73 | border-top: 1px solid rgba(0, 0, 0, 0.05);
74 | }
75 |
76 | nav .action>* {
77 | vertical-align: middle;
78 | }
79 |
80 | main {
81 | min-height: 1em;
82 | margin: 0 1em 1em auto;
83 | width: calc(100% - 19em);
84 | }
85 |
86 | #breadcrumbs {
87 | height: 3em;
88 | border-bottom: 1px solid rgba(0, 0, 0, 0.05);
89 | }
90 |
91 | #breadcrumbs span,
92 | #breadcrumbs {
93 | display: flex;
94 | align-items: center;
95 | color: #6f6f6f;
96 | }
97 |
98 | #breadcrumbs a {
99 | color: inherit;
100 | transition: .1s ease-in;
101 | border-radius: .125em;
102 | }
103 |
104 | #breadcrumbs a:hover {
105 | background-color: rgba(0,0,0, 0.05);
106 | }
107 |
108 | #breadcrumbs span a {
109 | padding: .2em;
110 | }
111 |
112 | #progress {
113 | position: fixed;
114 | top: 0;
115 | left: 0;
116 | width: 100%;
117 | height: 3px;
118 | z-index: 9999999999;
119 | }
120 |
121 | #progress div {
122 | height: 100%;
123 | background-color: #40c4ff;
124 | width: 0;
125 | transition: .2s ease width;
126 | }
127 |
--------------------------------------------------------------------------------
/frontend/src/views/Share.vue:
--------------------------------------------------------------------------------
1 |
2 |
22 |
23 |
24 |
68 |
--------------------------------------------------------------------------------
/cmd/config_init.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "fmt"
5 | "strings"
6 |
7 | "github.com/filebrowser/filebrowser/v2/settings"
8 | "github.com/spf13/cobra"
9 | )
10 |
11 | func init() {
12 | configCmd.AddCommand(configInitCmd)
13 | addConfigFlags(configInitCmd.Flags())
14 | }
15 |
16 | var configInitCmd = &cobra.Command{
17 | Use: "init",
18 | Short: "Initialize a new database",
19 | Long: `Initialize a new database to use with File Browser. All of
20 | this options can be changed in the future with the command
21 | 'filebrowser config set'. The user related flags apply
22 | to the defaults when creating new users and you don't
23 | override the options.`,
24 | Args: cobra.NoArgs,
25 | Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
26 | defaults := settings.UserDefaults{}
27 | flags := cmd.Flags()
28 | getUserDefaults(flags, &defaults, true)
29 | authMethod, auther := getAuthentication(flags)
30 |
31 | s := &settings.Settings{
32 | Key: generateKey(),
33 | Signup: mustGetBool(flags, "signup"),
34 | Shell: strings.Split(strings.TrimSpace(mustGetString(flags, "shell")), " "),
35 | AuthMethod: authMethod,
36 | Defaults: defaults,
37 | Branding: settings.Branding{
38 | Name: mustGetString(flags, "branding.name"),
39 | DisableExternal: mustGetBool(flags, "branding.disableExternal"),
40 | Files: mustGetString(flags, "branding.files"),
41 | },
42 | }
43 |
44 | ser := &settings.Server{
45 | Address: mustGetString(flags, "address"),
46 | Socket: mustGetString(flags, "socket"),
47 | Root: mustGetString(flags, "root"),
48 | BaseURL: mustGetString(flags, "baseurl"),
49 | TLSKey: mustGetString(flags, "key"),
50 | TLSCert: mustGetString(flags, "cert"),
51 | Port: mustGetString(flags, "port"),
52 | Log: mustGetString(flags, "log"),
53 | }
54 |
55 | err := d.store.Settings.Save(s)
56 | checkErr(err)
57 | err = d.store.Settings.SaveServer(ser)
58 | checkErr(err)
59 | err = d.store.Auth.Save(auther)
60 | checkErr(err)
61 |
62 | fmt.Printf(`
63 | Congratulations! You've set up your database to use with File Browser.
64 | Now add your first user via 'filebrowser users new' and then you just
65 | need to call the main command to boot up the server.
66 | `)
67 | printSettings(ser, s, auther)
68 | }, pythonConfig{noDB: true}),
69 | }
70 |
--------------------------------------------------------------------------------
/frontend/src/utils/auth.js:
--------------------------------------------------------------------------------
1 | import store from '@/store'
2 | import router from '@/router'
3 | import { Base64 } from 'js-base64'
4 | import { baseURL } from '@/utils/constants'
5 |
6 | export function parseToken (token) {
7 | const parts = token.split('.')
8 |
9 | if (parts.length !== 3) {
10 | throw new Error('token malformed')
11 | }
12 |
13 | const data = JSON.parse(Base64.decode(parts[1]))
14 |
15 | if (Math.round(new Date().getTime() / 1000) > data.exp) {
16 | throw new Error('token expired')
17 | }
18 |
19 | localStorage.setItem('jwt', token)
20 | store.commit('setJWT', token)
21 | store.commit('setUser', data.user)
22 | }
23 |
24 | export async function validateLogin () {
25 | try {
26 | if (localStorage.getItem('jwt')) {
27 | await renew(localStorage.getItem('jwt'))
28 | }
29 | } catch (_) {
30 | console.warn('Invalid JWT token in storage') // eslint-disable-line
31 | }
32 | }
33 |
34 | export async function login (username, password, recaptcha) {
35 | const data = { username, password, recaptcha }
36 |
37 | const res = await fetch(`${baseURL}/api/login`, {
38 | method: 'POST',
39 | headers: {
40 | 'Content-Type': 'application/json'
41 | },
42 | body: JSON.stringify(data)
43 | })
44 |
45 | const body = await res.text()
46 |
47 | if (res.status === 200) {
48 | parseToken(body)
49 | } else {
50 | throw new Error(body)
51 | }
52 | }
53 |
54 | export async function renew (jwt) {
55 | const res = await fetch(`${baseURL}/api/renew`, {
56 | method: 'POST',
57 | headers: {
58 | 'X-Auth': jwt,
59 | }
60 | })
61 |
62 | const body = await res.text()
63 |
64 | if (res.status === 200) {
65 | parseToken(body)
66 | } else {
67 | throw new Error(body)
68 | }
69 | }
70 |
71 | export async function signup (username, password) {
72 | const data = { username, password }
73 |
74 | const res = await fetch(`${baseURL}/api/signup`, {
75 | method: 'POST',
76 | headers: {
77 | 'Content-Type': 'application/json'
78 | },
79 | body: JSON.stringify(data)
80 | })
81 |
82 | if (res.status !== 200) {
83 | throw new Error(res.status)
84 | }
85 | }
86 |
87 | export function logout () {
88 | store.commit('setJWT', '')
89 | store.commit('setUser', null)
90 | localStorage.setItem('jwt', null)
91 | router.push({path: '/login'})
92 | }
93 |
--------------------------------------------------------------------------------
/settings/storage.go:
--------------------------------------------------------------------------------
1 | package settings
2 |
3 | import (
4 | "github.com/filebrowser/filebrowser/v2/errors"
5 | "github.com/filebrowser/filebrowser/v2/rules"
6 | "github.com/filebrowser/filebrowser/v2/users"
7 | )
8 |
9 | // StorageBackend is a settings storage backend.
10 | type StorageBackend interface {
11 | Get() (*Settings, error)
12 | Save(*Settings) error
13 | GetServer() (*Server, error)
14 | SaveServer(*Server) error
15 | }
16 |
17 | // Storage is a settings storage.
18 | type Storage struct {
19 | back StorageBackend
20 | }
21 |
22 | // NewStorage creates a settings storage from a backend.
23 | func NewStorage(back StorageBackend) *Storage {
24 | return &Storage{back: back}
25 | }
26 |
27 | // Get returns the settings for the current instance.
28 | func (s *Storage) Get() (*Settings, error) {
29 | return s.back.Get()
30 | }
31 |
32 | var defaultEvents = []string{
33 | "save",
34 | "copy",
35 | "rename",
36 | "upload",
37 | "delete",
38 | }
39 |
40 | // Save saves the settings for the current instance.
41 | func (s *Storage) Save(set *Settings) error {
42 | if len(set.Key) == 0 {
43 | return errors.ErrEmptyKey
44 | }
45 |
46 | if set.Defaults.Locale == "" {
47 | set.Defaults.Locale = "en"
48 | }
49 |
50 | if set.Defaults.Commands == nil {
51 | set.Defaults.Commands = []string{}
52 | }
53 |
54 | if set.Defaults.ViewMode == "" {
55 | set.Defaults.ViewMode = users.MosaicViewMode
56 | }
57 |
58 | if set.Rules == nil {
59 | set.Rules = []rules.Rule{}
60 | }
61 |
62 | if set.Shell == nil {
63 | set.Shell = []string{}
64 | }
65 |
66 | if set.Commands == nil {
67 | set.Commands = map[string][]string{}
68 | }
69 |
70 | for _, event := range defaultEvents {
71 | if _, ok := set.Commands["before_"+event]; !ok {
72 | set.Commands["before_"+event] = []string{}
73 | }
74 |
75 | if _, ok := set.Commands["after_"+event]; !ok {
76 | set.Commands["after_"+event] = []string{}
77 | }
78 | }
79 |
80 | err := s.back.Save(set)
81 | if err != nil {
82 | return err
83 | }
84 |
85 | return nil
86 | }
87 |
88 | // GetServer wraps StorageBackend.GetServer.
89 | func (s *Storage) GetServer() (*Server, error) {
90 | return s.back.GetServer()
91 | }
92 |
93 | // SaveServer wraps StorageBackend.SaveServer and adds some verification.
94 | func (s *Storage) SaveServer(ser *Server) error {
95 | ser.Clean()
96 | return s.back.SaveServer(ser)
97 | }
98 |
--------------------------------------------------------------------------------
/settings/dir.go:
--------------------------------------------------------------------------------
1 | package settings
2 |
3 | import (
4 | "errors"
5 | "log"
6 | "os"
7 | "regexp"
8 | "strings"
9 |
10 | "github.com/spf13/afero"
11 | )
12 |
13 | var (
14 | invalidFilenameChars = regexp.MustCompile(`[^0-9A-Za-z@_\-.]`)
15 |
16 | dashes = regexp.MustCompile(`[\-]+`)
17 | )
18 |
19 | // MakeUserDir makes the user directory according to settings.
20 | func (settings *Settings) MakeUserDir(username, userScope, serverRoot string) (string, error) {
21 | var err error
22 | userScope = strings.TrimSpace(userScope)
23 | if userScope == "" || userScope == "./" {
24 | userScope = "."
25 | }
26 |
27 | if !settings.CreateUserDir {
28 | return userScope, nil
29 | }
30 |
31 | fs := afero.NewBasePathFs(afero.NewOsFs(), serverRoot)
32 |
33 | // Use the default auto create logic only if specific scope is not the default scope
34 | if userScope != settings.Defaults.Scope {
35 | // Try create the dir, for example: settings.Defaults.Scope == "." and userScope == "./foo"
36 | if userScope != "." {
37 | err = fs.MkdirAll(userScope, os.ModePerm)
38 | if err != nil {
39 | log.Printf("create user: failed to mkdir user home dir: [%s]", userScope)
40 | }
41 | }
42 | return userScope, err
43 | }
44 |
45 | // Clean username first
46 | username = cleanUsername(username)
47 | if username == "" || username == "-" || username == "." {
48 | log.Printf("create user: invalid user for home dir creation: [%s]", username)
49 | return "", errors.New("invalid user for home dir creation")
50 | }
51 |
52 | // Create default user dir
53 | userHomeBase := settings.Defaults.Scope + string(os.PathSeparator) + "users"
54 | userHome := userHomeBase + string(os.PathSeparator) + username
55 | err = fs.MkdirAll(userHome, os.ModePerm)
56 | if err != nil {
57 | log.Printf("create user: failed to mkdir user home dir: [%s]", userHome)
58 | } else {
59 | log.Printf("create user: mkdir user home dir: [%s] successfully.", userHome)
60 | }
61 | return userHome, err
62 | }
63 |
64 | func cleanUsername(s string) string {
65 | // Remove any trailing space to avoid ending on -
66 | s = strings.Trim(s, " ")
67 | s = strings.Replace(s, "..", "", -1)
68 |
69 | // Replace all characters which not in the list `0-9A-Za-z@_\-.` with a dash
70 | s = invalidFilenameChars.ReplaceAllString(s, "-")
71 |
72 | // Remove any multiple dashes caused by replacements above
73 | s = dashes.ReplaceAllString(s, "-")
74 | return s
75 | }
76 |
--------------------------------------------------------------------------------
/cmd/rules.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "fmt"
5 |
6 | "github.com/filebrowser/filebrowser/v2/rules"
7 | "github.com/filebrowser/filebrowser/v2/settings"
8 | "github.com/filebrowser/filebrowser/v2/storage"
9 | "github.com/filebrowser/filebrowser/v2/users"
10 | "github.com/spf13/cobra"
11 | "github.com/spf13/pflag"
12 | )
13 |
14 | func init() {
15 | rootCmd.AddCommand(rulesCmd)
16 | rulesCmd.PersistentFlags().StringP("username", "u", "", "username of user to which the rules apply")
17 | rulesCmd.PersistentFlags().UintP("id", "i", 0, "id of user to which the rules apply")
18 | }
19 |
20 | var rulesCmd = &cobra.Command{
21 | Use: "rules",
22 | Short: "Rules management utility",
23 | Long: `On each subcommand you'll have available at least two flags:
24 | "username" and "id". You must either set only one of them
25 | or none. If you set one of them, the command will apply to
26 | an user, otherwise it will be applied to the global set or
27 | rules.`,
28 | Args: cobra.NoArgs,
29 | }
30 |
31 | func runRules(st *storage.Storage, cmd *cobra.Command, users func(*users.User), global func(*settings.Settings)) {
32 | id := getUserIdentifier(cmd.Flags())
33 | if id != nil {
34 | user, err := st.Users.Get("", id)
35 | checkErr(err)
36 |
37 | if users != nil {
38 | users(user)
39 | }
40 |
41 | printRules(user.Rules, id)
42 | return
43 | }
44 |
45 | s, err := st.Settings.Get()
46 | checkErr(err)
47 |
48 | if global != nil {
49 | global(s)
50 | }
51 |
52 | printRules(s.Rules, id)
53 | }
54 |
55 | func getUserIdentifier(flags *pflag.FlagSet) interface{} {
56 | id := mustGetUint(flags, "id")
57 | username := mustGetString(flags, "username")
58 |
59 | if id != 0 {
60 | return id
61 | } else if username != "" {
62 | return username
63 | }
64 |
65 | return nil
66 | }
67 |
68 | func printRules(rules []rules.Rule, id interface{}) {
69 | if id == nil {
70 | fmt.Printf("Global Rules:\n\n")
71 | } else {
72 | fmt.Printf("Rules for user %v:\n\n", id)
73 | }
74 |
75 | for id, rule := range rules {
76 | fmt.Printf("(%d) ", id)
77 | if rule.Regex {
78 | if rule.Allow {
79 | fmt.Printf("Allow Regex: \t%s\n", rule.Regexp.Raw)
80 | } else {
81 | fmt.Printf("Disallow Regex: \t%s\n", rule.Regexp.Raw)
82 | }
83 | } else {
84 | if rule.Allow {
85 | fmt.Printf("Allow Path: \t%s\n", rule.Path)
86 | } else {
87 | fmt.Printf("Disallow Path: \t%s\n", rule.Path)
88 | }
89 | }
90 | }
91 | }
92 |
--------------------------------------------------------------------------------
/cmd/config_set.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "strings"
5 |
6 | "github.com/spf13/cobra"
7 | "github.com/spf13/pflag"
8 | )
9 |
10 | func init() {
11 | configCmd.AddCommand(configSetCmd)
12 | addConfigFlags(configSetCmd.Flags())
13 | }
14 |
15 | var configSetCmd = &cobra.Command{
16 | Use: "set",
17 | Short: "Updates the configuration",
18 | Long: `Updates the configuration. Set the flags for the options
19 | you want to change. Other options will remain unchanged.`,
20 | Args: cobra.NoArgs,
21 | Run: python(func(cmd *cobra.Command, args []string, d pythonData) {
22 | flags := cmd.Flags()
23 | set, err := d.store.Settings.Get()
24 | checkErr(err)
25 |
26 | ser, err := d.store.Settings.GetServer()
27 | checkErr(err)
28 |
29 | hasAuth := false
30 | flags.Visit(func(flag *pflag.Flag) {
31 | switch flag.Name {
32 | case "baseurl":
33 | ser.BaseURL = mustGetString(flags, flag.Name)
34 | case "root":
35 | ser.Root = mustGetString(flags, flag.Name)
36 | case "socket":
37 | ser.Socket = mustGetString(flags, flag.Name)
38 | case "cert":
39 | ser.TLSCert = mustGetString(flags, flag.Name)
40 | case "key":
41 | ser.TLSKey = mustGetString(flags, flag.Name)
42 | case "address":
43 | ser.Address = mustGetString(flags, flag.Name)
44 | case "port":
45 | ser.Port = mustGetString(flags, flag.Name)
46 | case "log":
47 | ser.Log = mustGetString(flags, flag.Name)
48 | case "signup":
49 | set.Signup = mustGetBool(flags, flag.Name)
50 | case "auth.method":
51 | hasAuth = true
52 | case "shell":
53 | set.Shell = strings.Split(strings.TrimSpace(mustGetString(flags, flag.Name)), " ")
54 | case "branding.name":
55 | set.Branding.Name = mustGetString(flags, flag.Name)
56 | case "branding.disableExternal":
57 | set.Branding.DisableExternal = mustGetBool(flags, flag.Name)
58 | case "branding.files":
59 | set.Branding.Files = mustGetString(flags, flag.Name)
60 | }
61 | })
62 |
63 | getUserDefaults(flags, &set.Defaults, false)
64 |
65 | // read the defaults
66 | auther, err := d.store.Auth.Get(set.AuthMethod)
67 | checkErr(err)
68 |
69 | // check if there are new flags for existing auth method
70 | set.AuthMethod, auther = getAuthentication(flags, hasAuth, set, auther)
71 |
72 | err = d.store.Auth.Save(auther)
73 | checkErr(err)
74 | err = d.store.Settings.Save(set)
75 | checkErr(err)
76 | err = d.store.Settings.SaveServer(ser)
77 | checkErr(err)
78 | printSettings(ser, set, auther)
79 | }, pythonConfig{}),
80 | }
81 |
--------------------------------------------------------------------------------
/frontend/src/store/mutations.js:
--------------------------------------------------------------------------------
1 | import * as i18n from '@/i18n'
2 | import moment from 'moment'
3 |
4 | const mutations = {
5 | closeHovers: state => {
6 | state.show = null
7 | state.showMessage = null
8 | },
9 | toggleShell: (state) => {
10 | state.showShell = !state.showShell
11 | },
12 | showHover: (state, value) => {
13 | if (typeof value !== 'object') {
14 | state.show = value
15 | return
16 | }
17 |
18 | state.show = value.prompt
19 | state.showMessage = value.message
20 | state.showConfirm = value.confirm
21 | },
22 | showError: (state, value) => {
23 | state.show = 'error'
24 | state.showMessage = value
25 | },
26 | showSuccess: (state, value) => {
27 | state.show = 'success'
28 | state.showMessage = value
29 | },
30 | setLoading: (state, value) => { state.loading = value },
31 | setReload: (state, value) => { state.reload = value },
32 | setUser: (state, value) => {
33 | if (value === null) {
34 | state.user = null
35 | return
36 | }
37 |
38 | let locale = value.locale
39 |
40 | if (locale === '') {
41 | locale = i18n.detectLocale()
42 | }
43 |
44 | moment.locale(locale)
45 | i18n.default.locale = locale
46 | state.user = value
47 | },
48 | setJWT: (state, value) => (state.jwt = value),
49 | multiple: (state, value) => (state.multiple = value),
50 | addSelected: (state, value) => (state.selected.push(value)),
51 | addPlugin: (state, value) => {
52 | state.plugins.push(value)
53 | },
54 | removeSelected: (state, value) => {
55 | let i = state.selected.indexOf(value)
56 | if (i === -1) return
57 | state.selected.splice(i, 1)
58 | },
59 | resetSelected: (state) => {
60 | state.selected = []
61 | },
62 | updateUser: (state, value) => {
63 | if (typeof value !== 'object') return
64 |
65 | for (let field in value) {
66 | if (field === 'locale') {
67 | moment.locale(value[field])
68 | i18n.default.locale = value[field]
69 | }
70 |
71 | state.user[field] = value[field]
72 | }
73 | },
74 | updateRequest: (state, value) => {
75 | state.oldReq = state.req
76 | state.req = value
77 | },
78 | updateClipboard: (state, value) => {
79 | state.clipboard.key = value.key
80 | state.clipboard.items = value.items
81 | },
82 | resetClipboard: (state) => {
83 | state.clipboard.key = ''
84 | state.clipboard.items = []
85 | },
86 | setProgress: (state, value) => {
87 | state.progress = value
88 | }
89 | }
90 |
91 | export default mutations
92 |
--------------------------------------------------------------------------------
/frontend/src/components/prompts/Prompts.vue:
--------------------------------------------------------------------------------
1 |
2 |
4 |
7 | {{ $t('prompts.deleteMessageSingle') }}
5 |{{ $t('prompts.deleteMessageMultiple', { count: selectedCount}) }}
6 |
8 |
12 |
16 |
17 |
3 |
16 |
17 |
18 |
80 |
--------------------------------------------------------------------------------
/frontend/src/components/prompts/Rename.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
24 |
25 |
26 |
90 |
--------------------------------------------------------------------------------
/frontend/public/img/icons/safari-pinned-tab.svg:
--------------------------------------------------------------------------------
1 |
2 |
4 |
43 |
--------------------------------------------------------------------------------
/cmd/config_import.go:
--------------------------------------------------------------------------------
1 | package cmd
2 |
3 | import (
4 | "encoding/json"
5 | "errors"
6 | "path/filepath"
7 | "reflect"
8 |
9 | "github.com/filebrowser/filebrowser/v2/auth"
10 | "github.com/filebrowser/filebrowser/v2/settings"
11 | "github.com/spf13/cobra"
12 | )
13 |
14 | func init() {
15 | configCmd.AddCommand(configImportCmd)
16 | }
17 |
18 | type settingsFile struct {
19 | Settings *settings.Settings `json:"settings"`
20 | Server *settings.Server `json:"server"`
21 | Auther interface{} `json:"auther"`
22 | }
23 |
24 | var configImportCmd = &cobra.Command{
25 | Use: "import
4 |
6 |
7 | {{ $t('prompts.rename') }}
5 |
8 |
11 |
12 | {{ $t('prompts.renameMessage') }} {{ oldName() }}:
13 |
17 |
22 |
23 |
3 |
17 |
18 |
19 |
20 |
96 |
--------------------------------------------------------------------------------
/users/users.go:
--------------------------------------------------------------------------------
1 | package users
2 |
3 | import (
4 | "path/filepath"
5 | "regexp"
6 |
7 | "github.com/filebrowser/filebrowser/v2/errors"
8 |
9 | "github.com/filebrowser/filebrowser/v2/files"
10 | "github.com/filebrowser/filebrowser/v2/rules"
11 | "github.com/spf13/afero"
12 | )
13 |
14 | // ViewMode describes a view mode.
15 | type ViewMode string
16 |
17 | const (
18 | ListViewMode ViewMode = "list"
19 | MosaicViewMode ViewMode = "mosaic"
20 | )
21 |
22 | // User describes a user.
23 | type User struct {
24 | ID uint `storm:"id,increment" json:"id"`
25 | Username string `storm:"unique" json:"username"`
26 | Password string `json:"password"`
27 | Scope string `json:"scope"`
28 | Locale string `json:"locale"`
29 | LockPassword bool `json:"lockPassword"`
30 | ViewMode ViewMode `json:"viewMode"`
31 | Perm Permissions `json:"perm"`
32 | Commands []string `json:"commands"`
33 | Sorting files.Sorting `json:"sorting"`
34 | Fs afero.Fs `json:"-" yaml:"-"`
35 | Rules []rules.Rule `json:"rules"`
36 | }
37 |
38 | // GetRules implements rules.Provider.
39 | func (u *User) GetRules() []rules.Rule {
40 | return u.Rules
41 | }
42 |
43 | var checkableFields = []string{
44 | "Username",
45 | "Password",
46 | "Scope",
47 | "ViewMode",
48 | "Commands",
49 | "Sorting",
50 | "Rules",
51 | }
52 |
53 | // Clean cleans up a user and verifies if all its fields
54 | // are alright to be saved.
55 | func (u *User) Clean(baseScope string, fields ...string) error {
56 | if len(fields) == 0 {
57 | fields = checkableFields
58 | }
59 |
60 | for _, field := range fields {
61 | switch field {
62 | case "Username":
63 | if u.Username == "" {
64 | return errors.ErrEmptyUsername
65 | }
66 | case "Password":
67 | if u.Password == "" {
68 | return errors.ErrEmptyPassword
69 | }
70 | case "ViewMode":
71 | if u.ViewMode == "" {
72 | u.ViewMode = ListViewMode
73 | }
74 | case "Commands":
75 | if u.Commands == nil {
76 | u.Commands = []string{}
77 | }
78 | case "Sorting":
79 | if u.Sorting.By == "" {
80 | u.Sorting.By = "name"
81 | }
82 | case "Rules":
83 | if u.Rules == nil {
84 | u.Rules = []rules.Rule{}
85 | }
86 | }
87 | }
88 |
89 | if u.Fs == nil {
90 | scope := u.Scope
91 |
92 | if !filepath.IsAbs(scope) {
93 | scope = filepath.Join(baseScope, scope)
94 | }
95 |
96 | u.Fs = afero.NewBasePathFs(afero.NewOsFs(), scope)
97 | }
98 |
99 | return nil
100 | }
101 |
102 | // FullPath gets the full path for a user's relative path.
103 | func (u *User) FullPath(path string) string {
104 | return afero.FullBaseFsPath(u.Fs.(*afero.BasePathFs), path)
105 | }
106 |
107 | // CanExecute checks if an user can execute a specific command.
108 | func (u *User) CanExecute(command string) bool {
109 | if !u.Perm.Execute {
110 | return false
111 | }
112 |
113 | for _, cmd := range u.Commands {
114 | if regexp.MustCompile(cmd).MatchString(command) {
115 | return true
116 | }
117 | }
118 |
119 | return false
120 | }
121 |
--------------------------------------------------------------------------------
/http/http.go:
--------------------------------------------------------------------------------
1 | package http
2 |
3 | import (
4 | "net/http"
5 |
6 | "github.com/filebrowser/filebrowser/v2/settings"
7 | "github.com/filebrowser/filebrowser/v2/storage"
8 | "github.com/gorilla/mux"
9 | )
10 |
11 | type modifyRequest struct {
12 | What string `json:"what"` // Answer to: what data type?
13 | Which []string `json:"which"` // Answer to: which fields?
14 | }
15 |
16 | func NewHandler(storage *storage.Storage, server *settings.Server) (http.Handler, error) {
17 | server.Clean()
18 |
19 | r := mux.NewRouter()
20 | index, static := getStaticHandlers(storage, server)
21 |
22 | // NOTE: This fixes the issue where it would redirect if people did not put a
23 | // trailing slash in the end. I hate this decision since this allows some awful
24 | // URLs https://www.gorillatoolkit.org/pkg/mux#Router.SkipClean
25 | r = r.SkipClean(true)
26 |
27 | monkey := func(fn handleFunc, prefix string) http.Handler {
28 | return handle(fn, prefix, storage, server)
29 | }
30 |
31 | r.PathPrefix("/static").Handler(static)
32 | r.NotFoundHandler = index
33 |
34 | api := r.PathPrefix("/api").Subrouter()
35 |
36 | api.Handle("/login", monkey(loginHandler, ""))
37 | api.Handle("/signup", monkey(signupHandler, ""))
38 | api.Handle("/renew", monkey(renewHandler, ""))
39 |
40 | users := api.PathPrefix("/users").Subrouter()
41 | users.Handle("", monkey(usersGetHandler, "")).Methods("GET")
42 | users.Handle("", monkey(userPostHandler, "")).Methods("POST")
43 | users.Handle("/{id:[0-9]+}", monkey(userPutHandler, "")).Methods("PUT")
44 | users.Handle("/{id:[0-9]+}", monkey(userGetHandler, "")).Methods("GET")
45 | users.Handle("/{id:[0-9]+}", monkey(userDeleteHandler, "")).Methods("DELETE")
46 |
47 | api.PathPrefix("/resources").Handler(monkey(resourceGetHandler, "/api/resources")).Methods("GET")
48 | api.PathPrefix("/resources").Handler(monkey(resourceDeleteHandler, "/api/resources")).Methods("DELETE")
49 | api.PathPrefix("/resources").Handler(monkey(resourcePostPutHandler, "/api/resources")).Methods("POST")
50 | api.PathPrefix("/resources").Handler(monkey(resourcePostPutHandler, "/api/resources")).Methods("PUT")
51 | api.PathPrefix("/resources").Handler(monkey(resourcePatchHandler, "/api/resources")).Methods("PATCH")
52 |
53 | api.PathPrefix("/share").Handler(monkey(shareGetsHandler, "/api/share")).Methods("GET")
54 | api.PathPrefix("/share").Handler(monkey(sharePostHandler, "/api/share")).Methods("POST")
55 | api.PathPrefix("/share").Handler(monkey(shareDeleteHandler, "/api/share")).Methods("DELETE")
56 |
57 | api.Handle("/settings", monkey(settingsGetHandler, "")).Methods("GET")
58 | api.Handle("/settings", monkey(settingsPutHandler, "")).Methods("PUT")
59 |
60 | api.PathPrefix("/raw").Handler(monkey(rawHandler, "/api/raw")).Methods("GET")
61 | api.PathPrefix("/command").Handler(monkey(commandsHandler, "/api/command")).Methods("GET")
62 | api.PathPrefix("/search").Handler(monkey(searchHandler, "/api/search")).Methods("GET")
63 |
64 | public := api.PathPrefix("/public").Subrouter()
65 | public.PathPrefix("/dl").Handler(monkey(publicDlHandler, "/api/public/dl/")).Methods("GET")
66 | public.PathPrefix("/share").Handler(monkey(publicShareHandler, "/api/public/share/")).Methods("GET")
67 |
68 | return stripPrefix(server.BaseURL, r), nil
69 | }
70 |
--------------------------------------------------------------------------------
/frontend/src/components/Sidebar.vue:
--------------------------------------------------------------------------------
1 |
2 |
54 |
55 |
56 |
82 |
--------------------------------------------------------------------------------
/frontend/src/views/settings/Profile.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
17 |
18 |
32 |
33 |
34 |
35 |
104 |
--------------------------------------------------------------------------------
/frontend/src/components/Shell.vue:
--------------------------------------------------------------------------------
1 |
2 |
3 |
20 |
21 |
22 |
116 |
--------------------------------------------------------------------------------
/storage/bolt/importer/users.go:
--------------------------------------------------------------------------------
1 | package importer
2 |
3 | import (
4 | "encoding/json"
5 | "fmt"
6 |
7 | "github.com/asdine/storm"
8 | "github.com/filebrowser/filebrowser/v2/rules"
9 | "github.com/filebrowser/filebrowser/v2/storage"
10 | "github.com/filebrowser/filebrowser/v2/users"
11 | bolt "go.etcd.io/bbolt"
12 | )
13 |
14 | type oldUser struct {
15 | ID int `storm:"id,increment"`
16 | Admin bool `json:"admin"`
17 | AllowCommands bool `json:"allowCommands"` // Execute commands
18 | AllowEdit bool `json:"allowEdit"` // Edit/rename files
19 | AllowNew bool `json:"allowNew"` // Create files and folders
20 | AllowPublish bool `json:"allowPublish"` // Publish content (to use with static gen)
21 | LockPassword bool `json:"lockPassword"`
22 | Commands []string `json:"commands"`
23 | Locale string `json:"locale"`
24 | Password string `json:"password"`
25 | Rules []*rules.Rule `json:"rules"`
26 | Scope string `json:"filesystem"`
27 | Username string `json:"username" storm:"index,unique"`
28 | ViewMode string `json:"viewMode"`
29 | }
30 |
31 | func readOldUsers(db *storm.DB) ([]*oldUser, error) {
32 | users := []*oldUser{}
33 | err := db.Bolt.View(func(tx *bolt.Tx) error {
34 | return tx.Bucket([]byte("User")).ForEach(func(k []byte, v []byte) error {
35 | if len(v) > 0 && string(v)[0] == '{' {
36 | user := &oldUser{}
37 | err := json.Unmarshal(v, user)
38 |
39 | if err != nil {
40 | return err
41 | }
42 |
43 | users = append(users, user)
44 | }
45 |
46 | return nil
47 | })
48 | })
49 |
50 | return users, err
51 | }
52 |
53 | func convertUsersToNew(old []*oldUser) ([]*users.User, error) {
54 | list := []*users.User{}
55 |
56 | for _, oldUser := range old {
57 | user := &users.User{
58 | Username: oldUser.Username,
59 | Password: oldUser.Password,
60 | Scope: oldUser.Scope,
61 | Locale: oldUser.Locale,
62 | LockPassword: oldUser.LockPassword,
63 | ViewMode: users.ViewMode(oldUser.ViewMode),
64 | Commands: oldUser.Commands,
65 | Rules: []rules.Rule{},
66 | Perm: users.Permissions{
67 | Admin: oldUser.Admin,
68 | Execute: oldUser.AllowCommands,
69 | Create: oldUser.AllowNew,
70 | Rename: oldUser.AllowEdit,
71 | Modify: oldUser.AllowEdit,
72 | Delete: oldUser.AllowEdit,
73 | Share: true,
74 | Download: true,
75 | },
76 | }
77 |
78 | for _, rule := range oldUser.Rules {
79 | user.Rules = append(user.Rules, *rule)
80 | }
81 |
82 | err := user.Clean("")
83 | if err != nil {
84 | return nil, err
85 | }
86 |
87 | list = append(list, user)
88 | }
89 |
90 | return list, nil
91 | }
92 |
93 | func importUsers(old *storm.DB, sto *storage.Storage) error {
94 | oldUsers, err := readOldUsers(old)
95 | if err != nil {
96 | return err
97 | }
98 |
99 | newUsers, err := convertUsersToNew(oldUsers)
100 | if err != nil {
101 | return err
102 | }
103 |
104 | for _, user := range newUsers {
105 | err = sto.Users.Save(user)
106 | if err != nil {
107 | return err
108 | }
109 | }
110 |
111 | fmt.Printf("%d users successfully imported into the new DB.\n", len(newUsers))
112 | return nil
113 | }
114 |
--------------------------------------------------------------------------------
4 |
7 |
8 | chevron_right
5 | {{ c.text }}
6 |
9 |
19 | chevron_right
10 |
18 |