exact file-path exclusion support via --exclude-file (#1174)

Co-authored-by: Zack <zack.scholl@gmail.com>

Author: SSameer20

src/cli/cli.go

@@ -79,6 +79,7 @@ func Run() (err error) {
 				&cli.IntFlag{Name: "transfers", Value: 4, Usage: "number of ports to use for transfers"},
 				&cli.BoolFlag{Name: "qrcode", Aliases: []string{"qr"}, Usage: "show receive code as a qrcode"},
 				&cli.StringFlag{Name: "exclude", Value: "", Usage: "exclude files if they contain any of the comma separated strings"},
+				&cli.StringFlag{Name: "exclude-file", Value: "", Usage: "exclude files matching any of the comma separated relative paths exactly"},
 				&cli.StringFlag{Name: "socks5", Value: "", Usage: "add a socks5 proxy", EnvVars: []string{"SOCKS5_PROXY"}},
 				&cli.StringFlag{Name: "connect", Value: "", Usage: "add a http proxy", EnvVars: []string{"HTTP_PROXY"}},
 			},
@@ -327,6 +328,13 @@ func send(c *cli.Context) (err error) {
 			excludeStrings = append(excludeStrings, v)
 		}
 	}
+	excludeFiles := []string{}
+	for _, v := range strings.Split(c.String("exclude-file"), ",") {
+		v = utils.NormalizeRelativePath(strings.TrimSpace(v))
+		if v != "" && v != "." {
+			excludeFiles = append(excludeFiles, v)
+		}
+	}
 
 	ports := make([]string, transfersParam+1)
 	for i := 0; i <= transfersParam; i++ {
@@ -359,6 +367,7 @@ func send(c *cli.Context) (err error) {
 		ShowQrCode:        c.Bool("qrcode"),
 		MulticastAddress:  c.String("multicast"),
 		Exclude:           excludeStrings,
+		ExcludeFile:       excludeFiles,
 		Quiet:             c.Bool("quiet"),
 		DisableClipboard:  c.Bool("disable-clipboard"),
 		ExtendedClipboard: c.Bool("extended-clipboard"),
@@ -475,7 +484,7 @@ Or you can go back to the classic croc behavior by enabling classic mode:
 		// generate code phrase
 		crocOptions.SharedSecret = utils.GetRandomName()
 	}
-	minimalFileInfos, emptyFoldersToTransfer, totalNumberFolders, err := croc.GetFilesInfo(fnames, crocOptions.ZipFolder, crocOptions.GitIgnore, crocOptions.Exclude)
+	minimalFileInfos, emptyFoldersToTransfer, totalNumberFolders, err := croc.GetFilesInfoWithExactExclusions(fnames, crocOptions.ZipFolder, crocOptions.GitIgnore, crocOptions.Exclude, crocOptions.ExcludeFile)
 	if err != nil {
 		return
 	}

src/croc/croc.go

@@ -99,6 +99,7 @@ type Options struct {
 	MulticastAddress  string
 	ShowQrCode        bool
 	Exclude           []string
+	ExcludeFile       []string
 	Quiet             bool
 	DisableClipboard  bool
 	ExtendedClipboard bool
@@ -770,6 +771,12 @@ func isChild(parentPath, childPath string) bool {
 // This function retrieves the important file information
 // for every file that will be transferred
 func GetFilesInfo(fnames []string, zipfolder bool, ignoreGit bool, exclusions []string) (filesInfo []FileInfo, emptyFolders []FileInfo, totalNumberFolders int, err error) {
+	return GetFilesInfoWithExactExclusions(fnames, zipfolder, ignoreGit, exclusions, nil)
+}
+
+// GetFilesInfoWithExactExclusions retrieves file information while applying
+// both the legacy substring exclusions and exact relative-path exclusions.
+func GetFilesInfoWithExactExclusions(fnames []string, zipfolder bool, ignoreGit bool, exclusions, exactExclusions []string) (filesInfo []FileInfo, emptyFolders []FileInfo, totalNumberFolders int, err error) {
 	// fnames: the relative/absolute paths of files/folders that will be transferred
 	totalNumberFolders = 0
 	var paths []string
@@ -845,7 +852,7 @@ func GetFilesInfo(fnames []string, zipfolder bool, ignoreGit bool, exclusions []
 			}
 			fpath = filepath.Dir(fpath)
 			dest := filepath.Base(fpath) + ".zip"
-			err = utils.ZipDirectory(dest, fpath, ignoredPaths, exclusions)
+			err = utils.ZipDirectoryWithExactExclusions(dest, fpath, ignoredPaths, exclusions, exactExclusions)
 			if err != nil {
 				return
 			}
@@ -891,6 +898,13 @@ func GetFilesInfo(fnames []string, zipfolder bool, ignoreGit bool, exclusions []
 					if strings.HasSuffix(absPathWithSeparator, string(os.PathSeparator)+string(os.PathSeparator)) {
 						absPathWithSeparator = strings.TrimSuffix(absPathWithSeparator, string(os.PathSeparator))
 					}
+					relPath, relErr := filepath.Rel(absPath, pathName)
+					if relErr == nil && exactPathExcluded(exactExclusions, relPath) {
+						if info.IsDir() {
+							return filepath.SkipDir
+						}
+						return nil
+					}
 					remoteFolder := strings.TrimPrefix(filepath.Dir(pathName), absPathWithSeparator)
 					if !info.IsDir() {
 						fInfo := FileInfo{
@@ -929,6 +943,9 @@ func GetFilesInfo(fnames []string, zipfolder bool, ignoreGit bool, exclusions []
 			}
 
 		} else {
+			if exactPathExcluded(exactExclusions, stat.Name()) {
+				continue
+			}
 			fInfo := FileInfo{
 				Name:         stat.Name(),
 				FolderRemote: "./",
@@ -949,6 +966,16 @@ func GetFilesInfo(fnames []string, zipfolder bool, ignoreGit bool, exclusions []
 	return
 }
 
+func exactPathExcluded(exclusions []string, candidate string) bool {
+	candidate = utils.NormalizeRelativePath(candidate)
+	for _, exclusion := range exclusions {
+		if candidate == utils.NormalizeRelativePath(exclusion) {
+			return true
+		}
+	}
+	return false
+}
+
 func (c *Client) sendCollectFiles(filesInfo []FileInfo) (err error) {
 	c.FilesToTransfer = filesInfo
 	totalFilesSize := int64(0)

src/croc/croc_test.go

@@ -768,6 +768,40 @@ func TestGetFilesInfoZipFolderHonoursFilters(t *testing.T) {
 	}
 }
 
+func TestGetFilesInfoExactFileExclusion(t *testing.T) {
+	root := filepath.Join(t.TempDir(), "root")
+	for _, rel := range []string{"a/image.jpg", "b/a/image.jpg", "photo.png"} {
+		file := filepath.Join(root, rel)
+		if err := os.MkdirAll(filepath.Dir(file), 0o755); err != nil {
+			t.Fatalf("mkdir: %v", err)
+		}
+		if err := os.WriteFile(file, []byte(rel), 0o644); err != nil {
+			t.Fatalf("write %s: %v", rel, err)
+		}
+	}
+
+	files, _, _, err := GetFilesInfoWithExactExclusions([]string{root}, false, false, nil, []string{"a/image.jpg"})
+	if err != nil {
+		t.Fatalf("GetFilesInfoWithExactExclusions: %v", err)
+	}
+	got := make(map[string]bool)
+	for _, file := range files {
+		rel, err := filepath.Rel(root, filepath.Join(file.FolderSource, file.Name))
+		if err != nil {
+			t.Fatalf("relative path: %v", err)
+		}
+		got[filepath.ToSlash(rel)] = true
+	}
+	if got["a/image.jpg"] {
+		t.Fatal("exactly excluded file was returned")
+	}
+	for _, want := range []string{"b/a/image.jpg", "photo.png"} {
+		if !got[want] {
+			t.Errorf("expected %q to be returned; got %v", want, got)
+		}
+	}
+}
+
 // TestIsChild guards the gitignore walk helper. A directory or file whose
 // base name merely starts with ".." (e.g. "..cache") is still a legitimate
 // child of its parent and must be reported as such, otherwise it escapes the

src/utils/utils.go

@@ -508,6 +508,13 @@ func IsLocalIP(ipaddress string) bool {
 // any string in exclusions (case-insensitive) are also skipped, mirroring
 // the post-walk filter in cli.go for non-zip transfers.
 func ZipDirectory(destination string, source string, ignoredPaths map[string]bool, exclusions []string) (err error) {
+	return ZipDirectoryWithExactExclusions(destination, source, ignoredPaths, exclusions, nil)
+}
+
+// ZipDirectoryWithExactExclusions is ZipDirectory with support for exact
+// paths relative to source. Legacy exclusions remain case-insensitive
+// substring matches.
+func ZipDirectoryWithExactExclusions(destination string, source string, ignoredPaths map[string]bool, exclusions, exactExclusions []string) (err error) {
 	if _, err = os.Stat(destination); err == nil {
 		log.Errorf("%s file already exists!\n", destination)
 		return fmt.Errorf("file already exists: %s", destination)
@@ -618,6 +625,7 @@ func ZipDirectory(destination string, source string, ignoredPaths map[string]boo
 		// Create zip path with base name structure
 		zipPath := filepath.Join(baseName, relPath)
 		zipPath = filepath.ToSlash(zipPath)
+		relPath = NormalizeRelativePath(relPath)
 
 		// Honour --exclude: case-insensitive substring match against the zip
 		// path, mirroring the post-walk filter in cli.go.
@@ -632,6 +640,16 @@ func ZipDirectory(destination string, source string, ignoredPaths map[string]boo
 				}
 			}
 		}
+		if len(exactExclusions) > 0 {
+			for _, exclusion := range exactExclusions {
+				if relPath == NormalizeRelativePath(exclusion) {
+					if info.IsDir() {
+						return filepath.SkipDir
+					}
+					return nil
+				}
+			}
+		}
 
 		if info.IsDir() {
 			// Add directory entry to zip with original modification time
@@ -698,6 +716,14 @@ func ZipDirectory(destination string, source string, ignoredPaths map[string]boo
 	return nil
 }
 
+// NormalizeRelativePath converts a path to a portable, clean relative-path
+// representation suitable for exact comparisons.
+func NormalizeRelativePath(p string) string {
+	p = filepath.ToSlash(filepath.Clean(p))
+	p = strings.TrimPrefix(p, "./")
+	return p
+}
+
 func pathWithin(parent string, child string) bool {
 	rel, err := filepath.Rel(filepath.Clean(parent), filepath.Clean(child))
 	if err != nil {