import (
"encoding/binary"
"errors"
+ "io"
"io/fs"
- "io/ioutil"
"os"
"path/filepath"
+ "regexp"
"strings"
)
-const incompleteFileSuffix = ".incomplete"
-
-func downcaseFileExtension(filename string) string {
- splitStr := strings.Split(filename, ".")
- ext := strings.ToLower(
- splitStr[len(splitStr)-1],
- )
-
- return ext
-}
-
-func fileTypeFromFilename(fn string) fileType {
- ft, ok := fileTypes[downcaseFileExtension(fn)]
+func fileTypeFromFilename(filename string) fileType {
+ fileExt := strings.ToLower(filepath.Ext(filename))
+ ft, ok := fileTypes[fileExt]
if ok {
return ft
}
return defaultFileType
}
-func fileTypeFromInfo(info os.FileInfo) (ft fileType, err error) {
+func fileTypeFromInfo(info fs.FileInfo) (ft fileType, err error) {
if info.IsDir() {
ft.CreatorCode = "n/a "
ft.TypeCode = "fldr"
return ft, nil
}
-func getFileNameList(filePath string) (fields []Field, err error) {
- files, err := ioutil.ReadDir(filePath)
+const maxFileSize = 4294967296
+
+func getFileNameList(path string, ignoreList []string) (fields []Field, err error) {
+ files, err := os.ReadDir(path)
if err != nil {
return fields, nil
}
for _, file := range files {
var fnwi FileNameWithInfo
+ if ignoreFile(file.Name(), ignoreList) {
+ continue
+ }
+
fileCreator := make([]byte, 4)
- if file.Mode()&os.ModeSymlink != 0 {
- resolvedPath, err := os.Readlink(filePath + "/" + file.Name())
+ fileInfo, err := file.Info()
+ if err != nil {
+ return fields, err
+ }
+
+ // Check if path is a symlink. If so, follow it.
+ if fileInfo.Mode()&os.ModeSymlink != 0 {
+ resolvedPath, err := os.Readlink(filepath.Join(path, file.Name()))
if err != nil {
return fields, err
}
- rFile, err := os.Stat(filePath + "/" + resolvedPath)
+ rFile, err := os.Stat(resolvedPath)
if errors.Is(err, os.ErrNotExist) {
continue
}
}
if rFile.IsDir() {
- dir, err := ioutil.ReadDir(filePath + "/" + file.Name())
+ dir, err := os.ReadDir(filepath.Join(path, file.Name()))
if err != nil {
return fields, err
}
- binary.BigEndian.PutUint32(fnwi.FileSize[:], uint32(len(dir)))
- copy(fnwi.Type[:], []byte("fldr")[:])
- copy(fnwi.Creator[:], fileCreator[:])
+
+ var c uint32
+ for _, f := range dir {
+ if !ignoreFile(f.Name(), ignoreList) {
+ c += 1
+ }
+ }
+
+ binary.BigEndian.PutUint32(fnwi.FileSize[:], c)
+ copy(fnwi.Type[:], "fldr")
+ copy(fnwi.Creator[:], fileCreator)
} else {
binary.BigEndian.PutUint32(fnwi.FileSize[:], uint32(rFile.Size()))
- copy(fnwi.Type[:], []byte(fileTypeFromFilename(rFile.Name()).TypeCode)[:])
- copy(fnwi.Creator[:], []byte(fileTypeFromFilename(rFile.Name()).CreatorCode)[:])
+ copy(fnwi.Type[:], fileTypeFromFilename(rFile.Name()).TypeCode)
+ copy(fnwi.Creator[:], fileTypeFromFilename(rFile.Name()).CreatorCode)
}
-
} else if file.IsDir() {
- dir, err := ioutil.ReadDir(filePath + "/" + file.Name())
+ dir, err := os.ReadDir(filepath.Join(path, file.Name()))
if err != nil {
return fields, err
}
- binary.BigEndian.PutUint32(fnwi.FileSize[:], uint32(len(dir)))
- copy(fnwi.Type[:], []byte("fldr")[:])
- copy(fnwi.Creator[:], fileCreator[:])
+
+ var c uint32
+ for _, f := range dir {
+ if !ignoreFile(f.Name(), ignoreList) {
+ c += 1
+ }
+ }
+
+ binary.BigEndian.PutUint32(fnwi.FileSize[:], c)
+ copy(fnwi.Type[:], "fldr")
+ copy(fnwi.Creator[:], fileCreator)
} else {
// the Hotline protocol does not support file sizes > 4GiB due to the 4 byte field size, so skip them
- if file.Size() > 4294967296 {
+ if fileInfo.Size() > maxFileSize {
continue
}
- binary.BigEndian.PutUint32(fnwi.FileSize[:], uint32(file.Size()))
- copy(fnwi.Type[:], []byte(fileTypeFromFilename(file.Name()).TypeCode)[:])
- copy(fnwi.Creator[:], []byte(fileTypeFromFilename(file.Name()).CreatorCode)[:])
+
+ hlFile, err := newFileWrapper(&OSFileStore{}, path+"/"+file.Name(), 0)
+ if err != nil {
+ return nil, err
+ }
+
+ copy(fnwi.FileSize[:], hlFile.totalSize())
+ copy(fnwi.Type[:], hlFile.ffo.FlatFileInformationFork.TypeSignature)
+ copy(fnwi.Creator[:], hlFile.ffo.FlatFileInformationFork.CreatorSignature)
}
- strippedName := strings.Replace(file.Name(), ".incomplete", "", -1)
+ strippedName := strings.ReplaceAll(file.Name(), ".incomplete", "")
+ strippedName, err = txtEncoder.String(strippedName)
+ if err != nil {
+ continue
+ }
nameSize := make([]byte, 2)
binary.BigEndian.PutUint16(nameSize, uint16(len(strippedName)))
- copy(fnwi.NameSize[:], nameSize[:])
+ copy(fnwi.NameSize[:], nameSize)
fnwi.name = []byte(strippedName)
- b, err := fnwi.MarshalBinary()
+ b, err := io.ReadAll(&fnwi)
if err != nil {
return nil, err
}
- fields = append(fields, NewField(fieldFileNameWithInfo, b))
+ fields = append(fields, NewField(FieldFileNameWithInfo, b))
}
return fields, nil
func CalcItemCount(filePath string) ([]byte, error) {
var itemcount uint16
err := filepath.Walk(filePath, func(path string, info os.FileInfo, err error) error {
- itemcount += 1
-
if err != nil {
return err
}
+ if !strings.HasPrefix(info.Name(), ".") {
+ itemcount += 1
+ }
+
return nil
})
if err != nil {
return bytes
}
-// effectiveFile wraps os.Open to check for the presence of a partial file transfer as a fallback
-func effectiveFile(filePath string) (*os.File, error) {
- file, err := os.Open(filePath)
- if err != nil && !errors.Is(err, fs.ErrNotExist) {
- return nil, err
- }
-
- if errors.Is(err, fs.ErrNotExist) {
- file, err = os.OpenFile(filePath+incompleteFileSuffix, os.O_APPEND|os.O_WRONLY, 0644)
- if err != nil {
- return nil, err
+func ignoreFile(fileName string, ignoreList []string) bool {
+ // skip files that match any regular expression present in the IgnoreFiles list
+ matchIgnoreFilter := 0
+ for _, pattern := range ignoreList {
+ if match, _ := regexp.MatchString(pattern, fileName); match {
+ matchIgnoreFilter += 1
}
}
- return file, nil
+ return matchIgnoreFilter > 0
}
git.r.bdr.sh / rbdr / mobius / blobdiff