snapshot of https://github.com/mattermost/mattermost.git (master, 2026-09-16; blobs > 131072B omitted)

server/channels/utils/fileutils/fileutils.go

@@ -0,0 +1,155 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package fileutils
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/mattermost/mattermost/server/v8"
+)
+
+func CommonBaseSearchPaths() []string {
+	paths := []string{
+		".",
+		"..",
+		"../..",
+		"../../..",
+		"../../../..",
+	}
+
+	// this enables the server to be used in tests from a different repository
+	paths = append(paths, server.GetPackagePath())
+	return paths
+}
+
+func findPath(path string, baseSearchPaths []string, workingDirFirst bool, filter func(os.FileInfo) bool) string {
+	if filepath.IsAbs(path) {
+		if _, err := os.Stat(path); err == nil {
+			return path
+		}
+
+		return ""
+	}
+
+	searchPaths := []string{}
+	if workingDirFirst {
+		searchPaths = append(searchPaths, baseSearchPaths...)
+	}
+
+	// Attempt to search relative to the location of the running binary either before
+	// or after searching relative to the working directory, depending on `workingDirFirst`.
+	var binaryDir string
+	if exe, err := os.Executable(); err == nil {
+		if exe, err = filepath.EvalSymlinks(exe); err == nil {
+			if exe, err = filepath.Abs(exe); err == nil {
+				binaryDir = filepath.Dir(exe)
+			}
+		}
+	}
+	if binaryDir != "" {
+		for _, baseSearchPath := range baseSearchPaths {
+			searchPaths = append(
+				searchPaths,
+				filepath.Join(binaryDir, baseSearchPath),
+			)
+		}
+	}
+
+	if !workingDirFirst {
+		searchPaths = append(searchPaths, baseSearchPaths...)
+	}
+
+	for _, parent := range searchPaths {
+		found, err := filepath.Abs(filepath.Join(parent, path))
+		if err != nil {
+			continue
+		} else if fileInfo, err := os.Stat(found); err == nil {
+			if filter != nil {
+				if filter(fileInfo) {
+					return found
+				}
+			} else {
+				return found
+			}
+		}
+	}
+
+	return ""
+}
+
+func FindPath(path string, baseSearchPaths []string, filter func(os.FileInfo) bool) string {
+	return findPath(path, baseSearchPaths, true, filter)
+}
+
+// FindFile looks for the given file in nearby ancestors relative to the current working
+// directory as well as the directory of the executable.
+func FindFile(path string) string {
+	return FindPath(path, CommonBaseSearchPaths(), func(fileInfo os.FileInfo) bool {
+		return !fileInfo.IsDir()
+	})
+}
+
+// fileutils.FindDir looks for the given directory in nearby ancestors relative to the current working
+// directory as well as the directory of the executable, falling back to `./` if not found.
+func FindDir(dir string) (string, bool) {
+	found := FindPath(dir, CommonBaseSearchPaths(), func(fileInfo os.FileInfo) bool {
+		return fileInfo.IsDir()
+	})
+	if found == "" {
+		return "./", false
+	}
+
+	return found, true
+}
+
+// FindDirRelBinary looks for the given directory in nearby ancestors relative to the
+// directory of the executable, then relative to the working directory, falling back to `./` if not found.
+func FindDirRelBinary(dir string) (string, bool) {
+	found := findPath(dir, CommonBaseSearchPaths(), false, func(fileInfo os.FileInfo) bool {
+		return fileInfo.IsDir()
+	})
+	if found == "" {
+		return "./", false
+	}
+	return found, true
+}
+
+// CheckDirectoryConflict checks if either directory is a subdirectory of the other.
+// Returns true if there is a conflict (one is a subdirectory of the other or they are the same).
+// Returns an error if the directory paths cannot be resolved.
+// If a directory does not exist, the absolute path is used without symlink resolution.
+func CheckDirectoryConflict(dir1, dir2 string) (bool, error) {
+	absDir1, err := filepath.Abs(dir1)
+	if err != nil {
+		return false, fmt.Errorf("failed to resolve absolute path for %q: %w", dir1, err)
+	}
+	absDir2, err := filepath.Abs(dir2)
+	if err != nil {
+		return false, fmt.Errorf("failed to resolve absolute path for %q: %w", dir2, err)
+	}
+
+	if resolved, err := filepath.EvalSymlinks(absDir1); err == nil {
+		absDir1 = resolved
+	} else if !os.IsNotExist(err) {
+		return false, fmt.Errorf("failed to evaluate symlinks for %q: %w", dir1, err)
+	}
+
+	if resolved, err := filepath.EvalSymlinks(absDir2); err == nil {
+		absDir2 = resolved
+	} else if !os.IsNotExist(err) {
+		return false, fmt.Errorf("failed to evaluate symlinks for %q: %w", dir2, err)
+	}
+
+	if !strings.HasSuffix(absDir1, string(filepath.Separator)) {
+		absDir1 += string(filepath.Separator)
+	}
+	if !strings.HasSuffix(absDir2, string(filepath.Separator)) {
+		absDir2 += string(filepath.Separator)
+	}
+
+	return strings.HasPrefix(absDir1, absDir2) || strings.HasPrefix(absDir2, absDir1), nil
+}

server/channels/utils/fileutils/fileutils_test.go

@@ -0,0 +1,295 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+
+package fileutils
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestFindFile(t *testing.T) {
+	t.Run("files from various paths", func(t *testing.T) {
+		// Create the following directory structure:
+		// tmpDir1/
+		//   file1.json
+		//   file2.xml
+		//   other.txt
+		//   tmpDir2/
+		//     other.txt/ [directory]
+		//     tmpDir3/
+		//       tmpDir4/
+		//         tmpDir5/
+		tmpDir1, err := os.MkdirTemp("", "")
+		require.NoError(t, err)
+		defer func() {
+			err = os.RemoveAll(tmpDir1)
+			require.NoError(t, err)
+		}()
+
+		tmpDir2, err := os.MkdirTemp(tmpDir1, "")
+		require.NoError(t, err)
+
+		err = os.Mkdir(filepath.Join(tmpDir2, "other.txt"), 0700)
+		require.NoError(t, err)
+
+		tmpDir3, err := os.MkdirTemp(tmpDir2, "")
+		require.NoError(t, err)
+
+		tmpDir4, err := os.MkdirTemp(tmpDir3, "")
+		require.NoError(t, err)
+
+		tmpDir5, err := os.MkdirTemp(tmpDir4, "")
+		require.NoError(t, err)
+
+		type testCase struct {
+			Description string
+			Cwd         *string
+			FileName    string
+			Expected    string
+		}
+
+		testCases := []testCase{}
+		for _, fileName := range []string{"file1.json", "file2.xml", "other.txt"} {
+			filePath := filepath.Join(tmpDir1, fileName)
+			err = os.WriteFile(filePath, []byte("{}"), 0600)
+			require.NoError(t, err)
+
+			// Relative paths end up getting symlinks fully resolved, so use this below as necessary.
+			filePathResolved, err := filepath.EvalSymlinks(filePath)
+			require.NoError(t, err)
+
+			testCases = append(testCases, []testCase{
+				{
+					fmt.Sprintf("absolute path to %s", fileName),
+					nil,
+					filePath,
+					filePath,
+				},
+				{
+					fmt.Sprintf("absolute path to %s from containing directory", fileName),
+					&tmpDir1,
+					filePath,
+					filePath,
+				},
+				{
+					fmt.Sprintf("relative path to %s from containing directory", fileName),
+					&tmpDir1,
+					fileName,
+					filePathResolved,
+				},
+				{
+					fmt.Sprintf("%s: subdirectory of containing directory", fileName),
+					&tmpDir2,
+					fileName,
+					filePathResolved,
+				},
+				{
+					fmt.Sprintf("%s: twice-nested subdirectory of containing directory", fileName),
+					&tmpDir3,
+					fileName,
+					filePathResolved,
+				},
+				{
+					fmt.Sprintf("%s: thrice-nested subdirectory of containing directory", fileName),
+					&tmpDir4,
+					fileName,
+					filePathResolved,
+				},
+				{
+					fmt.Sprintf("%s: quadruple-nested subdirectory of containing directory", fileName),
+					&tmpDir5,
+					fileName,
+					filePathResolved,
+				},
+			}...)
+		}
+
+		for _, testCase := range testCases {
+			t.Run(testCase.Description, func(t *testing.T) {
+				if testCase.Cwd != nil {
+					t.Chdir(*testCase.Cwd)
+				}
+				assert.Equal(t, testCase.Expected, FindFile(testCase.FileName))
+			})
+		}
+	})
+}
+
+func TestCheckDirectoryConflict(t *testing.T) {
+	t.Run("separate directories", func(t *testing.T) {
+		tmpDir1, err := os.MkdirTemp("", "dir1")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir1)
+
+		tmpDir2, err := os.MkdirTemp("", "dir2")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir2)
+
+		conflict, err := CheckDirectoryConflict(tmpDir1, tmpDir2)
+		require.NoError(t, err)
+		assert.False(t, conflict)
+	})
+
+	t.Run("same directory", func(t *testing.T) {
+		tmpDir, err := os.MkdirTemp("", "samedir")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir)
+
+		conflict, err := CheckDirectoryConflict(tmpDir, tmpDir)
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("first is subdirectory of second", func(t *testing.T) {
+		tmpDir1, err := os.MkdirTemp("", "parent")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir1)
+
+		tmpDir2 := filepath.Join(tmpDir1, "child")
+		err = os.MkdirAll(tmpDir2, 0700)
+		require.NoError(t, err)
+
+		conflict, err := CheckDirectoryConflict(tmpDir2, tmpDir1)
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("second is subdirectory of first", func(t *testing.T) {
+		tmpDir1, err := os.MkdirTemp("", "parent")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir1)
+
+		tmpDir2 := filepath.Join(tmpDir1, "child")
+		err = os.MkdirAll(tmpDir2, 0700)
+		require.NoError(t, err)
+
+		conflict, err := CheckDirectoryConflict(tmpDir1, tmpDir2)
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("deeply nested subdirectory", func(t *testing.T) {
+		tmpDir1, err := os.MkdirTemp("", "parent")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir1)
+
+		tmpDir2 := filepath.Join(tmpDir1, "a", "b", "c")
+		err = os.MkdirAll(tmpDir2, 0700)
+		require.NoError(t, err)
+
+		conflict, err := CheckDirectoryConflict(tmpDir1, tmpDir2)
+		require.NoError(t, err)
+		assert.True(t, conflict)
+
+		conflict, err = CheckDirectoryConflict(tmpDir2, tmpDir1)
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("symlinked directory", func(t *testing.T) {
+		tmpDir1, err := os.MkdirTemp("", "real")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir1)
+
+		tmpDir2, err := os.MkdirTemp("", "symlinks")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir2)
+
+		symlink := filepath.Join(tmpDir2, "link")
+		err = os.Symlink(tmpDir1, symlink)
+		require.NoError(t, err)
+
+		conflict, err := CheckDirectoryConflict(tmpDir1, symlink)
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("relative paths", func(t *testing.T) {
+		tmpDir := t.TempDir()
+
+		subDir := filepath.Join(tmpDir, "subdir")
+		err := os.MkdirAll(subDir, 0700)
+		require.NoError(t, err)
+
+		t.Chdir(tmpDir)
+
+		conflict, err := CheckDirectoryConflict(".", ".")
+		require.NoError(t, err)
+		assert.True(t, conflict)
+
+		conflict, err = CheckDirectoryConflict(".", "./subdir")
+		require.NoError(t, err)
+		assert.True(t, conflict)
+
+		conflict, err = CheckDirectoryConflict("./subdir", ".")
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("similar prefix but not subdirectory", func(t *testing.T) {
+		tmpDir1, err := os.MkdirTemp("", "dir")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir1)
+
+		tmpDir2, err := os.MkdirTemp("", "dir")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir2)
+
+		conflict, err := CheckDirectoryConflict(tmpDir1, tmpDir2)
+		require.NoError(t, err)
+		assert.False(t, conflict)
+	})
+
+	t.Run("non-existent directories are handled", func(t *testing.T) {
+		// Both directories non-existent but separate - no error, no conflict
+		conflict, err := CheckDirectoryConflict("/nonexistent/path1", "/nonexistent/path2")
+		require.NoError(t, err)
+		assert.False(t, conflict)
+
+		// Both directories non-existent, one nested in the other
+		conflict, err = CheckDirectoryConflict("/nonexistent/parent", "/nonexistent/parent/child")
+		require.NoError(t, err)
+		assert.True(t, conflict)
+
+		// Same non-existent directory
+		conflict, err = CheckDirectoryConflict("/nonexistent/same", "/nonexistent/same")
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("root directory", func(t *testing.T) {
+		tmpDir, err := os.MkdirTemp("", "dir")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir)
+
+		// Root directory handled as a conflict with a subdirectory of the root
+		conflict, err := CheckDirectoryConflict("/", tmpDir)
+		require.NoError(t, err)
+		assert.True(t, conflict)
+	})
+
+	t.Run("overlap but not path prefix", func(t *testing.T) {
+		tmpDir, err := os.MkdirTemp("", "dir")
+		require.NoError(t, err)
+		defer os.RemoveAll(tmpDir)
+
+		subDir1 := filepath.Join(tmpDir, "prefix")
+		subDir2 := filepath.Join(tmpDir, "prefix-but-different-folder")
+
+		err = os.Mkdir(subDir1, 0700)
+		require.NoError(t, err)
+		err = os.Mkdir(subDir2, 0700)
+		require.NoError(t, err)
+
+		// Two paths, one a string prefix but not an actual path prefix
+		conflict, err := CheckDirectoryConflict(subDir1, subDir2)
+		require.NoError(t, err)
+		assert.False(t, conflict)
+	})
+}