git.r.bdr.sh - rbdr/mobius/blob - hotline/file_path.go

   1 package hotline
   2
   3 import (
   4         "bufio"
   5         "bytes"
   6         "encoding/binary"
   7         "errors"
   8         "io"
   9         "path/filepath"
  10         "strings"
  11 )
  12
  13 // FilePathItem represents the file or directory portion of a delimited file path (e.g. foo and bar in "/foo/bar")
  14 // Example bytes:
  15 // 00 00
  16 // 09
  17 // 73 75 62 66 6f 6c 64 65 72  "subfolder"
  18 type FilePathItem struct {
  19         Len  byte
  20         Name []byte
  21 }
  22
  23 const fileItemMinLen = 3
  24
  25 // fileItemScanner implements bufio.SplitFunc for parsing incoming byte slices into complete tokens
  26 func fileItemScanner(data []byte, _ bool) (advance int, token []byte, err error) {
  27         if len(data) < fileItemMinLen {
  28                 return 0, nil, nil
  29         }
  30
  31         advance = fileItemMinLen + int(data[2])
  32         return advance, data[0:advance], nil
  33 }
  34
  35 // Write implements the io.Writer interface for FilePathItem
  36 func (fpi *FilePathItem) Write(b []byte) (n int, err error) {
  37         if len(b) < 3 {
  38                 return n, errors.New("buflen too small")
  39         }
  40         fpi.Len = b[2]
  41         fpi.Name = b[fileItemMinLen : fpi.Len+fileItemMinLen]
  42
  43         return int(fpi.Len) + fileItemMinLen, nil
  44 }
  45
  46 type FilePath struct {
  47         ItemCount [2]byte
  48         Items     []FilePathItem
  49 }
  50
  51 // Write implements io.Writer interface for FilePath
  52 func (fp *FilePath) Write(b []byte) (n int, err error) {
  53         reader := bytes.NewReader(b)
  54         err = binary.Read(reader, binary.BigEndian, &fp.ItemCount)
  55         if err != nil && !errors.Is(err, io.EOF) {
  56                 return n, err
  57         }
  58         if errors.Is(err, io.EOF) {
  59                 return n, nil
  60         }
  61
  62         scanner := bufio.NewScanner(reader)
  63         scanner.Split(fileItemScanner)
  64
  65         for i := 0; i < int(binary.BigEndian.Uint16(fp.ItemCount[:])); i++ {
  66                 var fpi FilePathItem
  67                 scanner.Scan()
  68
  69                 // Make a new []byte slice and copy the scanner bytes to it.  This is critical to avoid a data race as the
  70                 // scanner re-uses the buffer for subsequent scans.
  71                 buf := make([]byte, len(scanner.Bytes()))
  72                 copy(buf, scanner.Bytes())
  73
  74                 if _, err := fpi.Write(buf); err != nil {
  75                         return n, err
  76                 }
  77                 fp.Items = append(fp.Items, fpi)
  78         }
  79
  80         return n, nil
  81 }
  82
  83 // IsDropbox checks if a FilePath matches the special drop box folder type
  84 func (fp *FilePath) IsDropbox() bool {
  85         if fp.Len() == 0 {
  86                 return false
  87         }
  88
  89         return strings.Contains(strings.ToLower(string(fp.Items[fp.Len()-1].Name)), "drop box")
  90 }
  91
  92 func (fp *FilePath) IsUploadDir() bool {
  93         if fp.Len() == 0 {
  94                 return false
  95         }
  96
  97         return strings.Contains(strings.ToLower(string(fp.Items[fp.Len()-1].Name)), "upload")
  98 }
  99
 100 func (fp *FilePath) Len() uint16 {
 101         return binary.BigEndian.Uint16(fp.ItemCount[:])
 102 }
 103
 104 func readPath(fileRoot string, filePath, fileName []byte) (fullPath string, err error) {
 105         var fp FilePath
 106         if filePath != nil {
 107                 if _, err = fp.Write(filePath); err != nil {
 108                         return "", err
 109                 }
 110         }
 111
 112         var subPath string
 113         for _, pathItem := range fp.Items {
 114                 subPath = filepath.Join("/", subPath, string(pathItem.Name))
 115         }
 116
 117         fullPath = filepath.Join(
 118                 fileRoot,
 119                 subPath,
 120                 filepath.Join("/", string(fileName)),
 121         )
 122
 123         return fullPath, nil
 124 }