refactor(serverHandler/aliasHandler): extract hierarchy availability

marjune163 · marjune163 · commit 0997d0e588a9 · 2024-05-28T17:05:22.000+08:00
diff --git a/src/serverHandler/aliasHandler.go b/src/serverHandler/aliasHandler.go
@@ -40,43 +40,13 @@ type aliasHandler struct {
 	dirIndexes []string
 	aliases    aliases
 
-	globalAuth    bool
-	authUrls      []string
-	authUrlsUsers pathIntsList
-	authDirs      []string
-	authDirsUsers pathIntsList
-
-	globalIndex    bool
-	indexUrls      []string
-	indexUrlsUsers pathIntsList
-	indexDirs      []string
-	indexDirsUsers pathIntsList
-
-	globalUpload    bool
-	uploadUrls      []string
-	uploadUrlsUsers pathIntsList
-	uploadDirs      []string
-	uploadDirsUsers pathIntsList
-
-	globalMkdir    bool
-	mkdirUrls      []string
-	mkdirUrlsUsers pathIntsList
-	mkdirDirs      []string
-	mkdirDirsUsers pathIntsList
-
-	globalDelete    bool
-	deleteUrls      []string
-	deleteUrlsUsers pathIntsList
-	deleteDirs      []string
-	deleteDirsUsers pathIntsList
-
-	globalArchive bool
-	archiveUrls   []string
-	archiveDirs   []string
-
-	globalCors bool
-	corsUrls   []string
-	corsDirs   []string
+	auth    *hierarchyAvailability
+	index   *hierarchyAvailability
+	upload  *hierarchyAvailability
+	mkdir   *hierarchyAvailability
+	delete  *hierarchyAvailability
+	archive *hierarchyAvailability
+	cors    *hierarchyAvailability
 
 	globalRestrictAccess []string
 	restrictAccessUrls   pathStringsList
@@ -217,43 +187,13 @@ func newAliasHandler(
 		dirIndexes: p.DirIndexes,
 		aliases:    allAliases.filterSuccessor(currentAlias.url),
 
-		globalAuth:    p.GlobalAuth || prefixMatched(p.AuthUrls, util.HasUrlPrefixDir, currentAlias.url) || prefixMatched(p.AuthDirs, util.HasFsPrefixDir, currentAlias.fs),
-		authUrls:      filterSuccessor(p.AuthUrls, util.HasUrlPrefixDir, currentAlias.url),
-		authUrlsUsers: vhostCtx.authUrlsUsers.filterSuccessor(true, util.HasUrlPrefixDir, currentAlias.url),
-		authDirs:      filterSuccessor(p.AuthDirs, util.HasFsPrefixDir, currentAlias.fs),
-		authDirsUsers: vhostCtx.authDirsUsers.filterSuccessor(true, util.HasFsPrefixDir, currentAlias.fs),
-
-		globalIndex:    prefixMatched(p.IndexUrls, util.HasUrlPrefixDir, currentAlias.url) || prefixMatched(p.IndexDirs, util.HasFsPrefixDir, currentAlias.fs),
-		indexUrls:      filterSuccessor(p.IndexUrls, util.HasUrlPrefixDir, currentAlias.url),
-		indexUrlsUsers: vhostCtx.indexUrlsUsers.filterSuccessor(true, util.HasUrlPrefixDir, currentAlias.url),
-		indexDirs:      filterSuccessor(p.IndexDirs, util.HasFsPrefixDir, currentAlias.fs),
-		indexDirsUsers: vhostCtx.indexDirsUsers.filterSuccessor(true, util.HasFsPrefixDir, currentAlias.fs),
-
-		globalUpload:    p.GlobalUpload || prefixMatched(p.UploadUrls, util.HasUrlPrefixDir, currentAlias.url) || prefixMatched(p.UploadDirs, util.HasFsPrefixDir, currentAlias.fs),
-		uploadUrls:      filterSuccessor(p.UploadUrls, util.HasUrlPrefixDir, currentAlias.url),
-		uploadUrlsUsers: vhostCtx.uploadUrlsUsers.filterSuccessor(true, util.HasUrlPrefixDir, currentAlias.url),
-		uploadDirs:      filterSuccessor(p.UploadDirs, util.HasFsPrefixDir, currentAlias.fs),
-		uploadDirsUsers: vhostCtx.uploadDirsUsers.filterSuccessor(true, util.HasFsPrefixDir, currentAlias.fs),
-
-		globalMkdir:    p.GlobalMkdir || prefixMatched(p.MkdirUrls, util.HasUrlPrefixDir, currentAlias.url) || prefixMatched(p.MkdirDirs, util.HasFsPrefixDir, currentAlias.fs),
-		mkdirUrls:      filterSuccessor(p.MkdirUrls, util.HasUrlPrefixDir, currentAlias.url),
-		mkdirUrlsUsers: vhostCtx.mkdirUrlsUsers.filterSuccessor(true, util.HasUrlPrefixDir, currentAlias.url),
-		mkdirDirs:      filterSuccessor(p.MkdirDirs, util.HasFsPrefixDir, currentAlias.fs),
-		mkdirDirsUsers: vhostCtx.mkdirDirsUsers.filterSuccessor(true, util.HasFsPrefixDir, currentAlias.fs),
-
-		globalDelete:    p.GlobalDelete || prefixMatched(p.DeleteUrls, util.HasUrlPrefixDir, currentAlias.url) || prefixMatched(p.DeleteDirs, util.HasFsPrefixDir, currentAlias.fs),
-		deleteUrls:      filterSuccessor(p.DeleteUrls, util.HasUrlPrefixDir, currentAlias.url),
-		deleteUrlsUsers: vhostCtx.deleteUrlsUsers.filterSuccessor(true, util.HasUrlPrefixDir, currentAlias.url),
-		deleteDirs:      filterSuccessor(p.DeleteDirs, util.HasFsPrefixDir, currentAlias.fs),
-		deleteDirsUsers: vhostCtx.deleteDirsUsers.filterSuccessor(true, util.HasFsPrefixDir, currentAlias.fs),
-
-		globalArchive: p.GlobalArchive || prefixMatched(p.ArchiveUrls, util.HasUrlPrefixDir, currentAlias.url) || prefixMatched(p.ArchiveDirs, util.HasFsPrefixDir, currentAlias.fs),
-		archiveUrls:   filterSuccessor(p.ArchiveUrls, util.HasUrlPrefixDir, currentAlias.url),
-		archiveDirs:   filterSuccessor(p.ArchiveDirs, util.HasFsPrefixDir, currentAlias.fs),
-
-		globalCors: p.GlobalCors || prefixMatched(p.CorsUrls, util.HasUrlPrefixDir, currentAlias.url) || prefixMatched(p.CorsDirs, util.HasFsPrefixDir, currentAlias.fs),
-		corsUrls:   filterSuccessor(p.CorsUrls, util.HasUrlPrefixDir, currentAlias.url),
-		corsDirs:   filterSuccessor(p.CorsDirs, util.HasFsPrefixDir, currentAlias.fs),
+		auth:    newHierarchyAvailability(currentAlias.url, currentAlias.fs, p.GlobalAuth, p.AuthUrls, vhostCtx.authUrlsUsers, p.AuthDirs, vhostCtx.authDirsUsers),
+		index:   newHierarchyAvailability(currentAlias.url, currentAlias.fs, false, p.IndexUrls, vhostCtx.indexUrlsUsers, p.IndexDirs, vhostCtx.indexDirsUsers),
+		upload:  newHierarchyAvailability(currentAlias.url, currentAlias.fs, p.GlobalUpload, p.UploadUrls, vhostCtx.uploadUrlsUsers, p.UploadDirs, vhostCtx.uploadDirsUsers),
+		mkdir:   newHierarchyAvailability(currentAlias.url, currentAlias.fs, p.GlobalMkdir, p.MkdirUrls, vhostCtx.mkdirUrlsUsers, p.MkdirDirs, vhostCtx.mkdirDirsUsers),
+		delete:  newHierarchyAvailability(currentAlias.url, currentAlias.fs, p.GlobalDelete, p.DeleteUrls, vhostCtx.deleteUrlsUsers, p.DeleteDirs, vhostCtx.deleteDirsUsers),
+		archive: newHierarchyAvailability(currentAlias.url, currentAlias.fs, p.GlobalArchive, p.ArchiveUrls, nil, p.ArchiveDirs, nil),
+		cors:    newHierarchyAvailability(currentAlias.url, currentAlias.fs, p.GlobalCors, p.CorsUrls, nil, p.CorsDirs, nil),
 
 		globalRestrictAccess: globalRestrictAccess,
 		restrictAccessUrls:   vhostCtx.restrictAccessUrls.filterSuccessor(false, util.HasUrlPrefixDir, currentAlias.url),
diff --git a/src/serverHandler/archive.go b/src/serverHandler/archive.go
@@ -129,7 +129,7 @@ func (h *aliasHandler) visitTreeNode(
 	}
 }
 
-func (h *aliasHandler) archive(
+func (h *aliasHandler) archiveFiles(
 	w http.ResponseWriter,
 	r *http.Request,
 	session *sessionContext,
diff --git a/src/serverHandler/archiveTar.go b/src/serverHandler/archiveTar.go
@@ -69,7 +69,7 @@ func (h *aliasHandler) tar(w http.ResponseWriter, r *http.Request, session *sess
 		h.logError(err)
 	}()
 
-	h.archive(
+	h.archiveFiles(
 		w,
 		r,
 		session,
@@ -109,7 +109,7 @@ func (h *aliasHandler) tgz(w http.ResponseWriter, r *http.Request, session *sess
 		h.logError(err)
 	}()
 
-	h.archive(
+	h.archiveFiles(
 		w,
 		r,
 		session,
diff --git a/src/serverHandler/archiveZip.go b/src/serverHandler/archiveZip.go
@@ -54,7 +54,7 @@ func (h *aliasHandler) zip(w http.ResponseWriter, r *http.Request, session *sess
 		h.logError(err)
 	}()
 
-	h.archive(
+	h.archiveFiles(
 		w,
 		r,
 		session,
diff --git a/src/serverHandler/auth.go b/src/serverHandler/auth.go
@@ -14,15 +14,15 @@ func (h *aliasHandler) needAuth(rawQuery, vhostReqPath, reqFsPath string) (needA
 		return true, true
 	}
 
-	if h.globalAuth {
+	if h.auth.global {
 		return true, false
 	}
 
-	if hasUrlOrDirPrefix(h.authUrls, vhostReqPath, h.authDirs, reqFsPath) {
+	if hasUrlOrDirPrefix(h.auth.urls, vhostReqPath, h.auth.dirs, reqFsPath) {
 		return true, false
 	}
 
-	if matchPath, _ := hasUrlOrDirPrefixUsers(h.authUrlsUsers, vhostReqPath, h.authDirsUsers, reqFsPath, -1); matchPath {
+	if matchPath, _ := hasUrlOrDirPrefixUsers(h.auth.urlsUsers, vhostReqPath, h.auth.dirsUsers, reqFsPath, -1); matchPath {
 		return true, false
 	}
 
@@ -38,8 +38,8 @@ func (h *aliasHandler) verifyAuth(r *http.Request, vhostReqPath, reqFsPath strin
 
 	if hasAuthReq {
 		userid, username, success := h.users.Auth(inputUser, inputPass)
-		if success && userid >= 0 && (len(h.authUrlsUsers) > 0 || len(h.authDirsUsers) > 0) {
-			if matchPrefix, match := hasUrlOrDirPrefixUsers(h.authUrlsUsers, vhostReqPath, h.authDirsUsers, reqFsPath, userid); matchPrefix {
+		if success && userid >= 0 && (len(h.auth.urlsUsers) > 0 || len(h.auth.dirsUsers) > 0) {
+			if matchPrefix, match := hasUrlOrDirPrefixUsers(h.auth.urlsUsers, vhostReqPath, h.auth.dirsUsers, reqFsPath, userid); matchPrefix {
 				success = match
 			}
 		}
diff --git a/src/serverHandler/perm.go b/src/serverHandler/perm.go
@@ -5,6 +5,29 @@ import (
 	"os"
 )
 
+type hierarchyAvailability struct {
+	global    bool
+	urls      []string
+	urlsUsers pathIntsList
+	dirs      []string
+	dirsUsers pathIntsList
+}
+
+func newHierarchyAvailability(
+	baseUrl, baseDir string,
+	global bool,
+	allUrls []string, allUrlsUsers pathIntsList,
+	allDirs []string, allDirsUsers pathIntsList,
+) *hierarchyAvailability {
+	return &hierarchyAvailability{
+		global:    global || prefixMatched(allUrls, util.HasUrlPrefixDir, baseUrl) || prefixMatched(allDirs, util.HasFsPrefixDir, baseDir),
+		urls:      filterSuccessor(allUrls, util.HasUrlPrefixDir, baseUrl),
+		urlsUsers: allUrlsUsers.filterSuccessor(true, util.HasUrlPrefixDir, baseUrl),
+		dirs:      filterSuccessor(allDirs, util.HasFsPrefixDir, baseDir),
+		dirsUsers: allDirsUsers.filterSuccessor(true, util.HasFsPrefixDir, baseDir),
+	}
+}
+
 func hasUrlOrDirPrefix(urls []string, reqUrl string, dirs []string, reqDir string) bool {
 	for _, url := range urls {
 		if util.HasUrlPrefixDir(reqUrl, url) {
@@ -58,16 +81,16 @@ func hasUrlOrDirPrefixUsers(urlsUsers pathIntsList, reqUrl string, dirsUsers pat
 }
 
 func (h *aliasHandler) getCanIndex(rawReqPath, reqFsPath string, userId int) bool {
-	if h.globalIndex {
+	if h.index.global {
 		return true
 	}
 
-	if hasUrlOrDirPrefix(h.indexUrls, rawReqPath, h.indexDirs, reqFsPath) {
+	if hasUrlOrDirPrefix(h.index.urls, rawReqPath, h.index.dirs, reqFsPath) {
 		return true
 	}
 
 	if userId >= 0 {
-		if _, match := hasUrlOrDirPrefixUsers(h.indexUrlsUsers, rawReqPath, h.indexDirsUsers, reqFsPath, userId); match {
+		if _, match := hasUrlOrDirPrefixUsers(h.index.urlsUsers, rawReqPath, h.index.dirsUsers, reqFsPath, userId); match {
 			return true
 		}
 	}
@@ -80,16 +103,16 @@ func (h *aliasHandler) getCanUpload(info os.FileInfo, rawReqPath, reqFsPath stri
 		return false
 	}
 
-	if h.globalUpload {
+	if h.upload.global {
 		return true
 	}
 
-	if hasUrlOrDirPrefix(h.uploadUrls, rawReqPath, h.uploadDirs, reqFsPath) {
+	if hasUrlOrDirPrefix(h.upload.urls, rawReqPath, h.upload.dirs, reqFsPath) {
 		return true
 	}
 
 	if userId >= 0 {
-		if _, match := hasUrlOrDirPrefixUsers(h.uploadUrlsUsers, rawReqPath, h.uploadDirsUsers, reqFsPath, userId); match {
+		if _, match := hasUrlOrDirPrefixUsers(h.upload.urlsUsers, rawReqPath, h.upload.dirsUsers, reqFsPath, userId); match {
 			return true
 		}
 	}
@@ -102,16 +125,16 @@ func (h *aliasHandler) getCanMkdir(info os.FileInfo, rawReqPath, reqFsPath strin
 		return false
 	}
 
-	if h.globalMkdir {
+	if h.mkdir.global {
 		return true
 	}
 
-	if hasUrlOrDirPrefix(h.mkdirUrls, rawReqPath, h.mkdirDirs, reqFsPath) {
+	if hasUrlOrDirPrefix(h.mkdir.urls, rawReqPath, h.mkdir.dirs, reqFsPath) {
 		return true
 	}
 
 	if userId >= 0 {
-		if _, match := hasUrlOrDirPrefixUsers(h.mkdirUrlsUsers, rawReqPath, h.mkdirDirsUsers, reqFsPath, userId); match {
+		if _, match := hasUrlOrDirPrefixUsers(h.mkdir.urlsUsers, rawReqPath, h.mkdir.dirsUsers, reqFsPath, userId); match {
 			return true
 		}
 	}
@@ -124,16 +147,16 @@ func (h *aliasHandler) getCanDelete(info os.FileInfo, rawReqPath, reqFsPath stri
 		return false
 	}
 
-	if h.globalDelete {
+	if h.delete.global {
 		return true
 	}
 
-	if hasUrlOrDirPrefix(h.deleteUrls, rawReqPath, h.deleteDirs, reqFsPath) {
+	if hasUrlOrDirPrefix(h.delete.urls, rawReqPath, h.delete.dirs, reqFsPath) {
 		return true
 	}
 
 	if userId >= 0 {
-		if _, match := hasUrlOrDirPrefixUsers(h.deleteUrlsUsers, rawReqPath, h.deleteDirsUsers, reqFsPath, userId); match {
+		if _, match := hasUrlOrDirPrefixUsers(h.delete.urlsUsers, rawReqPath, h.delete.dirsUsers, reqFsPath, userId); match {
 			return true
 		}
 	}
@@ -146,17 +169,17 @@ func (h *aliasHandler) getCanArchive(subInfos []os.FileInfo, rawReqPath, reqFsPa
 		return false
 	}
 
-	if h.globalArchive {
+	if h.archive.global {
 		return true
 	}
 
-	return hasUrlOrDirPrefix(h.archiveUrls, rawReqPath, h.archiveDirs, reqFsPath)
+	return hasUrlOrDirPrefix(h.archive.urls, rawReqPath, h.archive.dirs, reqFsPath)
 }
 
 func (h *aliasHandler) getCanCors(rawReqPath, reqFsPath string) bool {
-	if h.globalCors {
+	if h.cors.global {
 		return true
 	}
 
-	return hasUrlOrDirPrefix(h.corsUrls, rawReqPath, h.corsDirs, reqFsPath)
+	return hasUrlOrDirPrefix(h.cors.urls, rawReqPath, h.cors.dirs, reqFsPath)
 }

Original file line number	Diff line number	Diff line change
`@@ -129,7 +129,7 @@ func (h *aliasHandler) visitTreeNode(`
`129`	`129`	`}`
`130`	`130`	`}`
`131`	`131`
`132`		`-func (h *aliasHandler) archive(`
	`132`	`+func (h *aliasHandler) archiveFiles(`
`133`	`133`	`w http.ResponseWriter,`
`134`	`134`	`r *http.Request,`
`135`	`135`	`session *sessionContext,`
Original file line number	Diff line number	Diff line change
`@@ -14,15 +14,15 @@ func (h *aliasHandler) needAuth(rawQuery, vhostReqPath, reqFsPath string) (needA`
`14`	`14`	`return true, true`
`15`	`15`	`}`
`16`	`16`
`17`		`- if h.globalAuth {`
	`17`	`+ if h.auth.global {`
`18`	`18`	`return true, false`
`19`	`19`	`}`
`20`	`20`
`21`		`- if hasUrlOrDirPrefix(h.authUrls, vhostReqPath, h.authDirs, reqFsPath) {`
	`21`	`+ if hasUrlOrDirPrefix(h.auth.urls, vhostReqPath, h.auth.dirs, reqFsPath) {`
`22`	`22`	`return true, false`
`23`	`23`	`}`
`24`	`24`
`25`		`- if matchPath, _ := hasUrlOrDirPrefixUsers(h.authUrlsUsers, vhostReqPath, h.authDirsUsers, reqFsPath, -1); matchPath {`
	`25`	`+ if matchPath, _ := hasUrlOrDirPrefixUsers(h.auth.urlsUsers, vhostReqPath, h.auth.dirsUsers, reqFsPath, -1); matchPath {`
`26`	`26`	`return true, false`
`27`	`27`	`}`
`28`	`28`
`@@ -38,8 +38,8 @@ func (h aliasHandler) verifyAuth(r http.Request, vhostReqPath, reqFsPath strin`
`38`	`38`
`39`	`39`	`if hasAuthReq {`
`40`	`40`	`userid, username, success := h.users.Auth(inputUser, inputPass)`
`41`		`- if success && userid >= 0 && (len(h.authUrlsUsers) > 0 \|\| len(h.authDirsUsers) > 0) {`
`42`		`- if matchPrefix, match := hasUrlOrDirPrefixUsers(h.authUrlsUsers, vhostReqPath, h.authDirsUsers, reqFsPath, userid); matchPrefix {`
	`41`	`+ if success && userid >= 0 && (len(h.auth.urlsUsers) > 0 \|\| len(h.auth.dirsUsers) > 0) {`
	`42`	`+ if matchPrefix, match := hasUrlOrDirPrefixUsers(h.auth.urlsUsers, vhostReqPath, h.auth.dirsUsers, reqFsPath, userid); matchPrefix {`
`43`	`43`	`success = match`
`44`	`44`	`}`
`45`	`45`	`}`
Original file line number	Diff line number	Diff line change
`@@ -5,6 +5,29 @@ import (`
`5`	`5`	`"os"`
`6`	`6`	`)`
`7`	`7`
	`8`	`+type hierarchyAvailability struct {`
	`9`	`+ global bool`
	`10`	`+ urls []string`
	`11`	`+ urlsUsers pathIntsList`
	`12`	`+ dirs []string`
	`13`	`+ dirsUsers pathIntsList`
	`14`	`+}`
	`15`	`+`
	`16`	`+func newHierarchyAvailability(`
	`17`	`+ baseUrl, baseDir string,`
	`18`	`+ global bool,`
	`19`	`+ allUrls []string, allUrlsUsers pathIntsList,`
	`20`	`+ allDirs []string, allDirsUsers pathIntsList,`
	`21`	`+) *hierarchyAvailability {`
	`22`	`+ return &hierarchyAvailability{`
	`23`	`+ global: global \|\| prefixMatched(allUrls, util.HasUrlPrefixDir, baseUrl) \|\| prefixMatched(allDirs, util.HasFsPrefixDir, baseDir),`
	`24`	`+ urls: filterSuccessor(allUrls, util.HasUrlPrefixDir, baseUrl),`
	`25`	`+ urlsUsers: allUrlsUsers.filterSuccessor(true, util.HasUrlPrefixDir, baseUrl),`
	`26`	`+ dirs: filterSuccessor(allDirs, util.HasFsPrefixDir, baseDir),`
	`27`	`+ dirsUsers: allDirsUsers.filterSuccessor(true, util.HasFsPrefixDir, baseDir),`
	`28`	`+ }`
	`29`	`+}`
	`30`	`+`
`8`	`31`	`func hasUrlOrDirPrefix(urls []string, reqUrl string, dirs []string, reqDir string) bool {`
`9`	`32`	`for _, url := range urls {`
`10`	`33`	`if util.HasUrlPrefixDir(reqUrl, url) {`
`@@ -58,16 +81,16 @@ func hasUrlOrDirPrefixUsers(urlsUsers pathIntsList, reqUrl string, dirsUsers pat`
`58`	`81`	`}`
`59`	`82`
`60`	`83`	`func (h *aliasHandler) getCanIndex(rawReqPath, reqFsPath string, userId int) bool {`
`61`		`- if h.globalIndex {`
	`84`	`+ if h.index.global {`
`62`	`85`	`return true`
`63`	`86`	`}`
`64`	`87`
`65`		`- if hasUrlOrDirPrefix(h.indexUrls, rawReqPath, h.indexDirs, reqFsPath) {`
	`88`	`+ if hasUrlOrDirPrefix(h.index.urls, rawReqPath, h.index.dirs, reqFsPath) {`
`66`	`89`	`return true`
`67`	`90`	`}`
`68`	`91`
`69`	`92`	`if userId >= 0 {`
`70`		`- if _, match := hasUrlOrDirPrefixUsers(h.indexUrlsUsers, rawReqPath, h.indexDirsUsers, reqFsPath, userId); match {`
	`93`	`+ if _, match := hasUrlOrDirPrefixUsers(h.index.urlsUsers, rawReqPath, h.index.dirsUsers, reqFsPath, userId); match {`
`71`	`94`	`return true`
`72`	`95`	`}`
`73`	`96`	`}`
`@@ -80,16 +103,16 @@ func (h *aliasHandler) getCanUpload(info os.FileInfo, rawReqPath, reqFsPath stri`
`80`	`103`	`return false`
`81`	`104`	`}`
`82`	`105`
`83`		`- if h.globalUpload {`
	`106`	`+ if h.upload.global {`
`84`	`107`	`return true`
`85`	`108`	`}`
`86`	`109`
`87`		`- if hasUrlOrDirPrefix(h.uploadUrls, rawReqPath, h.uploadDirs, reqFsPath) {`
	`110`	`+ if hasUrlOrDirPrefix(h.upload.urls, rawReqPath, h.upload.dirs, reqFsPath) {`
`88`	`111`	`return true`
`89`	`112`	`}`
`90`	`113`
`91`	`114`	`if userId >= 0 {`
`92`		`- if _, match := hasUrlOrDirPrefixUsers(h.uploadUrlsUsers, rawReqPath, h.uploadDirsUsers, reqFsPath, userId); match {`
	`115`	`+ if _, match := hasUrlOrDirPrefixUsers(h.upload.urlsUsers, rawReqPath, h.upload.dirsUsers, reqFsPath, userId); match {`
`93`	`116`	`return true`
`94`	`117`	`}`
`95`	`118`	`}`
`@@ -102,16 +125,16 @@ func (h *aliasHandler) getCanMkdir(info os.FileInfo, rawReqPath, reqFsPath strin`
`102`	`125`	`return false`
`103`	`126`	`}`
`104`	`127`
`105`		`- if h.globalMkdir {`
	`128`	`+ if h.mkdir.global {`
`106`	`129`	`return true`
`107`	`130`	`}`
`108`	`131`
`109`		`- if hasUrlOrDirPrefix(h.mkdirUrls, rawReqPath, h.mkdirDirs, reqFsPath) {`
	`132`	`+ if hasUrlOrDirPrefix(h.mkdir.urls, rawReqPath, h.mkdir.dirs, reqFsPath) {`
`110`	`133`	`return true`
`111`	`134`	`}`
`112`	`135`
`113`	`136`	`if userId >= 0 {`
`114`		`- if _, match := hasUrlOrDirPrefixUsers(h.mkdirUrlsUsers, rawReqPath, h.mkdirDirsUsers, reqFsPath, userId); match {`
	`137`	`+ if _, match := hasUrlOrDirPrefixUsers(h.mkdir.urlsUsers, rawReqPath, h.mkdir.dirsUsers, reqFsPath, userId); match {`
`115`	`138`	`return true`
`116`	`139`	`}`
`117`	`140`	`}`
`@@ -124,16 +147,16 @@ func (h *aliasHandler) getCanDelete(info os.FileInfo, rawReqPath, reqFsPath stri`
`124`	`147`	`return false`
`125`	`148`	`}`
`126`	`149`
`127`		`- if h.globalDelete {`
	`150`	`+ if h.delete.global {`
`128`	`151`	`return true`
`129`	`152`	`}`
`130`	`153`
`131`		`- if hasUrlOrDirPrefix(h.deleteUrls, rawReqPath, h.deleteDirs, reqFsPath) {`
	`154`	`+ if hasUrlOrDirPrefix(h.delete.urls, rawReqPath, h.delete.dirs, reqFsPath) {`
`132`	`155`	`return true`
`133`	`156`	`}`
`134`	`157`
`135`	`158`	`if userId >= 0 {`
`136`		`- if _, match := hasUrlOrDirPrefixUsers(h.deleteUrlsUsers, rawReqPath, h.deleteDirsUsers, reqFsPath, userId); match {`
	`159`	`+ if _, match := hasUrlOrDirPrefixUsers(h.delete.urlsUsers, rawReqPath, h.delete.dirsUsers, reqFsPath, userId); match {`
`137`	`160`	`return true`
`138`	`161`	`}`
`139`	`162`	`}`
`@@ -146,17 +169,17 @@ func (h *aliasHandler) getCanArchive(subInfos []os.FileInfo, rawReqPath, reqFsPa`
`146`	`169`	`return false`
`147`	`170`	`}`
`148`	`171`
`149`		`- if h.globalArchive {`
	`172`	`+ if h.archive.global {`
`150`	`173`	`return true`
`151`	`174`	`}`
`152`	`175`
`153`		`- return hasUrlOrDirPrefix(h.archiveUrls, rawReqPath, h.archiveDirs, reqFsPath)`
	`176`	`+ return hasUrlOrDirPrefix(h.archive.urls, rawReqPath, h.archive.dirs, reqFsPath)`
`154`	`177`	`}`
`155`	`178`
`156`	`179`	`func (h *aliasHandler) getCanCors(rawReqPath, reqFsPath string) bool {`
`157`		`- if h.globalCors {`
	`180`	`+ if h.cors.global {`
`158`	`181`	`return true`
`159`	`182`	`}`
`160`	`183`
`161`		`- return hasUrlOrDirPrefix(h.corsUrls, rawReqPath, h.corsDirs, reqFsPath)`
	`184`	`+ return hasUrlOrDirPrefix(h.cors.urls, rawReqPath, h.cors.dirs, reqFsPath)`
`162`	`185`	`}`