Issue #396 Circular Symlinks Bug (#694)

* Added a duplicate file check case into file.go

* Created an automated test to ensure the program can detect broken symlinks and stop the program rather than hanging indefinitely

* Test: Created a Circular symlink test, verifies that scc detects symlink loops, and skips instead of running indefinitely (Michael)

* Added an if-statement to TestNewFileJobBrokenSymLink to skip the test on Windows machines, because Windows requires administrator mode or developer mode to be enabled to create symlinks.

* Test: Created a Circular symlink test, verifies that scc detects symlink loops, and skips instead of running indefinitely (Michael) this is a recommit, the other commit by Richard, possibly might have overwritten it? overall very weird that both our code dissapered

* Added an if-statement to TestNewFileJobBrokenSymLink to skip the test on Windows machines, because Windows requires administrator mode or developer mode to be enabled to create symlinks.

* Added test to check for duplicate file counting via symlinks.
The function TestNewFileJobDuplicateCounting checks that the same file is not processed twice when accessed through multiple paths with symLink. This should skip duplicate files and prevents double counting.

* Updated test functions: Used Brokensymlink window check, made an check for fist link created in my test, and used BrokenSymlink check window check in the Duplicate test

---------

Co-authored-by: Rayze-B <vrajpatel0615@gmail.com>
Co-authored-by: m39johnsonm <m39johnsonm@student.bridgew.edu>

Author: 3 people

processor/file.go

@@ -13,6 +13,9 @@ import (
 // needs to be sync.Map as it potentially could be called by many GoRoutines
 var extensionCache sync.Map
 
+// Added as a way to track files per run.
+var visitedPaths sync.Map
+
 // A custom version of extracting extensions for a file
 // which also has a case-insensitive cache in order to save
 // some needless processing
@@ -78,6 +81,19 @@ func newFileJob(path, name string, fileInfo os.FileInfo) *FileJob {
 		return nil
 	}
 
+	// This determines the real path
+	realPath := path
+	if symPath != "" {
+		realPath = symPath
+	}
+
+	// Prevent duplicate processing and loops
+	if _, exists := visitedPaths.Load(realPath); exists {
+		printWarnF("skipping already processed file: %s", realPath)
+		return nil
+	}
+	visitedPaths.Store(realPath, true)
+
 	language, extension := DetectLanguage(name)
 
 	if len(language) != 0 {

processor/file_test.go

@@ -5,6 +5,9 @@ package processor
 import (
 	"math/rand/v2"
 	"os"
+	"path/filepath"
+	"runtime"
+	"sync"
 	"testing"
 )
 
@@ -183,6 +186,38 @@ func TestNewFileJobSize(t *testing.T) {
 	LargeByteCount = 1000000
 }
 
+func TestNewFileJobBrokenSymlink(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("skipping symlink test on Windows due to privilege requirements")
+	}
+
+	ProcessConstants()
+	IncludeSymLinks = true
+
+	// Create a temp directory to work in
+	dir, err := os.MkdirTemp("", "scc-broken-symlink-test")
+	if err != nil {
+		t.Fatal("Failed to create temp dir:", err)
+	}
+	defer os.RemoveAll(dir)
+
+	// Create a symlink that points to a path that doesn't exist
+	symPath := dir + "/broken.go"
+	err = os.Symlink("/this/path/does/not/exist.go", symPath)
+	if err != nil {
+		t.Fatal("Failed to create broken symlink:", err)
+	}
+
+	fi, _ := os.Lstat(symPath)
+	job := newFileJob(symPath, "broken.go", fi)
+
+	if job != nil {
+		t.Error("Expected nil for broken symlink got", job)
+	}
+
+	IncludeSymLinks = false
+}
+
 func BenchmarkGetExtensionDifferent(b *testing.B) {
 	for i := 0; i < b.N; i++ {
 
@@ -211,3 +246,77 @@ func randStringBytes(n int) string {
 	}
 	return string(b)
 }
+
+func TestNewFileJobCircularSymlink(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("skipping symlink test on Windows due to privilege requirements")
+	}
+	ProcessConstants()
+	IncludeSymLinks = true
+	defer func() { IncludeSymLinks = false }()
+	visitedPaths = sync.Map{}
+	// Create a temp directory to work in
+	dir := t.TempDir()
+	link1 := filepath.Join(dir, "link1.go")
+	link2 := filepath.Join(dir, "link2.go")
+	// Create a loop: link1 -> link2 and link2 -> link1
+	if err := os.Symlink(link2, link1); err != nil {
+		t.Fatal("Failed to create first link:", err)
+	}
+	if err := os.Symlink(link1, link2); err != nil {
+		t.Fatal("Failed to create circular link:", err)
+	}
+
+	fi, err := os.Lstat(link1)
+	if err != nil {
+		t.Fatal(err)
+	}
+	// It should return the 'too many links' error.
+	job := newFileJob(link1, "link1.go", fi)
+
+	if job != nil {
+		t.Error("Expected nil for circular symlink, but got a FileJob")
+	}
+}
+
+func TestNewFileJobDuplicateCounting(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("skipping symlink test on Windows due to privilege requirements")
+	}
+	ProcessConstants()
+	IncludeSymLinks = true
+	defer func() { IncludeSymLinks = false }()
+	visitedPaths = sync.Map{}
+
+	// Create Temp directory
+	dir := t.TempDir()
+	// Create a test file
+	testFile := filepath.Join(dir, "file.go")
+
+	if err := os.WriteFile(testFile, []byte("package main"), 0644); err != nil {
+		t.Fatal(err)
+	}
+
+	// Create a symlink to the same file
+	linkFile := filepath.Join(dir, "link.go")
+	if err := os.Symlink(testFile, linkFile); err != nil {
+		t.Skip("Symlinks not supported:", err)
+	}
+	// Process the test file
+	fi1, _ := os.Lstat(testFile)
+	job1 := newFileJob(testFile, "file.go", fi1)
+
+	// Process the symlink (same target)
+	fi2, _ := os.Lstat(linkFile)
+	job2 := newFileJob(linkFile, "link.go", fi2)
+
+	// First count should go through
+	if job1 == nil {
+		t.Fatal("Expected first file job to be created")
+	}
+
+	// Second count should be skipped
+	if job2 != nil {
+		t.Error("Expected nil for duplicate file through symlink, but got a FileJob")
+	}
+}