2017-10-27 01:10:54 -05:00
// Copyright 2017 The Gitea Authors. All rights reserved.
2022-11-27 13:20:29 -05:00
// SPDX-License-Identifier: MIT
2017-10-27 01:10:54 -05:00
package util
2019-11-10 16:33:47 -05:00
import (
2020-12-21 18:40:57 -05:00
"errors"
2023-03-21 15:02:49 -05:00
"fmt"
2021-04-08 17:25:57 -05:00
"net/url"
2019-11-10 16:33:47 -05:00
"os"
2020-12-21 18:40:57 -05:00
"path"
2019-11-10 16:33:47 -05:00
"path/filepath"
2021-04-08 17:25:57 -05:00
"regexp"
"runtime"
2023-02-13 15:01:09 -05:00
"strings"
2019-11-10 16:33:47 -05:00
)
2017-10-27 01:10:54 -05:00
2023-03-21 15:02:49 -05:00
// PathJoinRel joins the path elements into a single path, each element is cleaned by path.Clean separately.
// It only returns the following values (like path.Join), any redundant part (empty, relative dots, slashes) is removed.
// It's caller's duty to make every element not bypass its own directly level, to avoid security issues.
//
// empty => ``
// `` => ``
// `..` => `.`
// `dir` => `dir`
// `/dir/` => `dir`
// `foo\..\bar` => `foo\..\bar`
// {`foo`, ``, `bar`} => `foo/bar`
// {`foo`, `..`, `bar`} => `foo/bar`
func PathJoinRel ( elem ... string ) string {
elems := make ( [ ] string , len ( elem ) )
for i , e := range elem {
if e == "" {
continue
}
elems [ i ] = path . Clean ( "/" + e )
}
p := path . Join ( elems ... )
if p == "" {
return ""
} else if p == "/" {
return "."
2023-03-08 07:17:39 -05:00
}
2023-10-23 21:54:59 -05:00
return p [ 1 : ]
2023-03-08 07:17:39 -05:00
}
2023-03-21 15:02:49 -05:00
// PathJoinRelX joins the path elements into a single path like PathJoinRel,
2024-05-09 08:49:37 -05:00
// and convert all backslashes to slashes. (X means "extended", also means the combination of `\` and `/`).
2023-03-21 15:02:49 -05:00
// It's caller's duty to make every element not bypass its own directly level, to avoid security issues.
// It returns similar results as PathJoinRel except:
//
// `foo\..\bar` => `bar` (because it's processed as `foo/../bar`)
//
// All backslashes are handled as slashes, the result only contains slashes.
func PathJoinRelX ( elem ... string ) string {
elems := make ( [ ] string , len ( elem ) )
for i , e := range elem {
if e == "" {
continue
}
elems [ i ] = path . Clean ( "/" + strings . ReplaceAll ( e , "\\" , "/" ) )
}
return PathJoinRel ( elems ... )
}
const pathSeparator = string ( os . PathSeparator )
// FilePathJoinAbs joins the path elements into a single file path, each element is cleaned by filepath.Clean separately.
// All slashes/backslashes are converted to path separators before cleaning, the result only contains path separators.
// The first element must be an absolute path, caller should prepare the base path.
// It's caller's duty to make every element not bypass its own directly level, to avoid security issues.
// Like PathJoinRel, any redundant part (empty, relative dots, slashes) is removed.
//
// {`/foo`, ``, `bar`} => `/foo/bar`
// {`/foo`, `..`, `bar`} => `/foo/bar`
2023-04-12 05:16:45 -05:00
func FilePathJoinAbs ( base string , sub ... string ) string {
elems := make ( [ ] string , 1 , len ( sub ) + 1 )
2023-03-21 15:02:49 -05:00
2023-04-12 05:16:45 -05:00
// POSIX filesystem can have `\` in file names. Windows: `\` and `/` are both used for path separators
2023-03-21 15:02:49 -05:00
// to keep the behavior consistent, we do not allow `\` in file names, replace all `\` with `/`
if isOSWindows ( ) {
2023-04-12 05:16:45 -05:00
elems [ 0 ] = filepath . Clean ( base )
2023-03-21 15:02:49 -05:00
} else {
2023-04-12 05:16:45 -05:00
elems [ 0 ] = filepath . Clean ( strings . ReplaceAll ( base , "\\" , pathSeparator ) )
2023-03-21 15:02:49 -05:00
}
if ! filepath . IsAbs ( elems [ 0 ] ) {
// This shouldn't happen. If there is really necessary to pass in relative path, return the full path with filepath.Abs() instead
panic ( fmt . Sprintf ( "FilePathJoinAbs: %q (for path %v) is not absolute, do not guess a relative path based on current working directory" , elems [ 0 ] , elems ) )
}
2023-04-12 05:16:45 -05:00
for _ , s := range sub {
if s == "" {
2023-03-21 15:02:49 -05:00
continue
}
if isOSWindows ( ) {
2023-04-12 05:16:45 -05:00
elems = append ( elems , filepath . Clean ( pathSeparator + s ) )
2023-03-21 15:02:49 -05:00
} else {
2023-04-12 05:16:45 -05:00
elems = append ( elems , filepath . Clean ( pathSeparator + strings . ReplaceAll ( s , "\\" , pathSeparator ) ) )
2023-03-21 15:02:49 -05:00
}
2017-10-27 01:10:54 -05:00
}
2023-03-21 15:02:49 -05:00
// the elems[0] must be an absolute path, just join them together
return filepath . Join ( elems ... )
2017-10-27 01:10:54 -05:00
}
2019-11-10 16:33:47 -05:00
2020-11-27 21:42:08 -05:00
// IsDir returns true if given path is a directory,
// or returns false when it's a file or does not exist.
func IsDir ( dir string ) ( bool , error ) {
f , err := os . Stat ( dir )
if err == nil {
return f . IsDir ( ) , nil
}
if os . IsNotExist ( err ) {
return false , nil
}
return false , err
}
// IsFile returns true if given path is a file,
// or returns false when it's a directory or does not exist.
func IsFile ( filePath string ) ( bool , error ) {
f , err := os . Stat ( filePath )
if err == nil {
return ! f . IsDir ( ) , nil
}
if os . IsNotExist ( err ) {
return false , nil
}
return false , err
}
// IsExist checks whether a file or directory exists.
// It returns false when the file or directory does not exist.
func IsExist ( path string ) ( bool , error ) {
_ , err := os . Stat ( path )
if err == nil || os . IsExist ( err ) {
return true , nil
}
if os . IsNotExist ( err ) {
return false , nil
}
return false , err
}
2020-12-21 18:40:57 -05:00
func statDir ( dirPath , recPath string , includeDir , isDirOnly , followSymlinks bool ) ( [ ] string , error ) {
dir , err := os . Open ( dirPath )
if err != nil {
return nil , err
}
defer dir . Close ( )
fis , err := dir . Readdir ( 0 )
if err != nil {
return nil , err
}
statList := make ( [ ] string , 0 )
for _ , fi := range fis {
2022-08-28 04:43:25 -05:00
if CommonSkip ( fi . Name ( ) ) {
2020-12-21 18:40:57 -05:00
continue
}
relPath := path . Join ( recPath , fi . Name ( ) )
curPath := path . Join ( dirPath , fi . Name ( ) )
if fi . IsDir ( ) {
if includeDir {
statList = append ( statList , relPath + "/" )
}
s , err := statDir ( curPath , relPath , includeDir , isDirOnly , followSymlinks )
if err != nil {
return nil , err
}
statList = append ( statList , s ... )
} else if ! isDirOnly {
statList = append ( statList , relPath )
} else if followSymlinks && fi . Mode ( ) & os . ModeSymlink != 0 {
link , err := os . Readlink ( curPath )
if err != nil {
return nil , err
}
isDir , err := IsDir ( link )
if err != nil {
return nil , err
}
if isDir {
if includeDir {
statList = append ( statList , relPath + "/" )
}
s , err := statDir ( curPath , relPath , includeDir , isDirOnly , followSymlinks )
if err != nil {
return nil , err
}
statList = append ( statList , s ... )
}
}
}
return statList , nil
}
// StatDir gathers information of given directory by depth-first.
// It returns slice of file list and includes subdirectories if enabled;
// it returns error and nil slice when error occurs in underlying functions,
// or given path is not a directory or does not exist.
//
// Slice does not include given path itself.
// If subdirectories is enabled, they will have suffix '/'.
func StatDir ( rootPath string , includeDir ... bool ) ( [ ] string , error ) {
if isDir , err := IsDir ( rootPath ) ; err != nil {
return nil , err
} else if ! isDir {
return nil , errors . New ( "not a directory or does not exist: " + rootPath )
}
isIncludeDir := false
if len ( includeDir ) != 0 {
isIncludeDir = includeDir [ 0 ]
}
return statDir ( rootPath , "" , isIncludeDir , false , false )
}
2021-04-08 17:25:57 -05:00
2022-04-01 03:47:50 -05:00
func isOSWindows ( ) bool {
return runtime . GOOS == "windows"
}
2023-06-21 14:57:18 -05:00
var driveLetterRegexp = regexp . MustCompile ( "/[A-Za-z]:/" )
2021-07-08 06:38:13 -05:00
// FileURLToPath extracts the path information from a file://... url.
2023-09-18 03:40:50 -05:00
// It returns an error only if the URL is not a file URL.
2021-04-08 17:25:57 -05:00
func FileURLToPath ( u * url . URL ) ( string , error ) {
if u . Scheme != "file" {
return "" , errors . New ( "URL scheme is not 'file': " + u . String ( ) )
}
path := u . Path
2022-04-01 03:47:50 -05:00
if ! isOSWindows ( ) {
2021-04-08 17:25:57 -05:00
return path , nil
}
// If it looks like there's a Windows drive letter at the beginning, strip off the leading slash.
2023-06-21 14:57:18 -05:00
if driveLetterRegexp . MatchString ( path ) {
2021-04-08 17:25:57 -05:00
return path [ 1 : ] , nil
}
return path , nil
}
2022-04-01 03:47:50 -05:00
// HomeDir returns path of '~'(in Linux) on Windows,
// it returns error when the variable does not exist.
func HomeDir ( ) ( home string , err error ) {
// TODO: some users run Gitea with mismatched uid and "HOME=xxx" (they set HOME=xxx by environment manually)
2022-06-09 20:57:49 -05:00
// TODO: when running gitea as a sub command inside git, the HOME directory is not the user's home directory
2022-04-01 03:47:50 -05:00
// so at the moment we can not use `user.Current().HomeDir`
if isOSWindows ( ) {
home = os . Getenv ( "USERPROFILE" )
if home == "" {
home = os . Getenv ( "HOMEDRIVE" ) + os . Getenv ( "HOMEPATH" )
}
} else {
home = os . Getenv ( "HOME" )
}
if home == "" {
return "" , errors . New ( "cannot get home directory" )
}
return home , nil
}
2022-08-28 04:43:25 -05:00
// CommonSkip will check a provided name to see if it represents file or directory that should not be watched
func CommonSkip ( name string ) bool {
if name == "" {
return true
}
switch name [ 0 ] {
case '.' :
return true
case 't' , 'T' :
return name [ 1 : ] == "humbs.db"
case 'd' , 'D' :
return name [ 1 : ] == "esktop.ini"
}
return false
}
2023-02-13 15:01:09 -05:00
// IsReadmeFileName reports whether name looks like a README file
// based on its name.
func IsReadmeFileName ( name string ) bool {
name = strings . ToLower ( name )
if len ( name ) < 6 {
return false
} else if len ( name ) == 6 {
return name == "readme"
}
return name [ : 7 ] == "readme."
}
// IsReadmeFileExtension reports whether name looks like a README file
// based on its name. It will look through the provided extensions and check if the file matches
// one of the extensions and provide the index in the extension list.
// If the filename is `readme.` with an unmatched extension it will match with the index equaling
// the length of the provided extension list.
// Note that the '.' should be provided in ext, e.g ".md"
func IsReadmeFileExtension ( name string , ext ... string ) ( int , bool ) {
name = strings . ToLower ( name )
if len ( name ) < 6 || name [ : 6 ] != "readme" {
return 0 , false
}
for i , extension := range ext {
extension = strings . ToLower ( extension )
if name [ 6 : ] == extension {
return i , true
}
}
if name [ 6 ] == '.' {
return len ( ext ) , true
}
return 0 , false
}