[rbdr/mobius] / internal / mobius / friendship_quest_file_extensions.go

package mobius

import (
        "bytes"
        "encoding/binary"
        "fmt"
        "os"
        "path/filepath"
        "strings"

        "github.com/jhalter/mobius/hotline"
)

// ResolveUserPath processes paths for the special `~` directory.
func ResolveUserPath(cc *hotline.ClientConn, requestedPath string) (string, error) {
        if !strings.HasPrefix(requestedPath, "~") {
                return requestedPath, nil
        }

        userFolder := filepath.Join("~", cc.Account.Login)
        actualUserFolder := filepath.Join(cc.FileRoot(), userFolder)
        if stat, err := os.Stat(actualUserFolder); err == nil && stat.IsDir() {
                return strings.Replace(requestedPath, "~", userFolder, 1), nil
        }

        return "", fmt.Errorf("user folder does not exist")
}

// updateTransactionPath updates the FieldFilePath in a transaction in-place.
func updateTransactionPath(t *hotline.Transaction, newPath string) {
        for i, field := range t.Fields {
                if field.Type == hotline.FieldFilePath {
                        if encodedPath, err := txtEncoder.String(newPath); err == nil {
                                if fpBytes, err := encodeFilePath(encodedPath); err == nil {
                                        t.Fields[i].Data = fpBytes
                                }
                        }
                        return
                }
        }
}

// encodeFilePath encodes a string path into hotline.FilePath binary format.
func encodeFilePath(path string) ([]byte, error) {
        components := strings.Split(path, string(filepath.Separator))
        var fp hotline.FilePath
        binary.BigEndian.PutUint16(fp.ItemCount[:], uint16(len(components)))

        var buffer bytes.Buffer
        if err := binary.Write(&buffer, binary.BigEndian, fp.ItemCount); err != nil {
                return nil, err
        }

        for _, component := range components {
                if component == "" || len(component) > 255 {
                        return nil, fmt.Errorf("invalid file path component")
                }
                encodedComponent, err := txtEncoder.String(component)
                if err != nil {
                        return nil, err
                }
                buffer.Write([]byte{0x00, 0x00, byte(len(encodedComponent))})
                buffer.Write([]byte(encodedComponent))
        }

        return buffer.Bytes(), nil
}

// handleFileTransaction handles various file operations that require resolving `~`
func handleFileTransaction(cc *hotline.ClientConn, t *hotline.Transaction, handler func(*hotline.ClientConn, *hotline.Transaction) []hotline.Transaction, errMsg string) []hotline.Transaction {
        requestedPath, err := hotline.ReadPath(cc.FileRoot(), t.GetField(hotline.FieldFilePath).Data, nil)
        if err != nil {
                return nil
        }

        sliceLen := min(len(cc.FileRoot()) + 1, len(requestedPath))
        resolvedPath, err := ResolveUserPath(cc, requestedPath[sliceLen:])
        if err != nil {
                return cc.NewErrReply(t, errMsg)
        }

        updateTransactionPath(t, resolvedPath)
        return handler(cc, t)
}

// File operation handlers
func HandleUploadFileWithUserFolders(cc *hotline.ClientConn, t *hotline.Transaction) []hotline.Transaction {
        return handleFileTransaction(cc, t, HandleUploadFile, "Cannot upload to non-existent user folder.")
}

func HandleUploadFolderWithUserFolders(cc *hotline.ClientConn, t *hotline.Transaction) []hotline.Transaction {
        return handleFileTransaction(cc, t, HandleUploadFolder, "Cannot upload to non-existent user folder.")
}

func HandleDeleteFileWithUserFolders(cc *hotline.ClientConn, t *hotline.Transaction) []hotline.Transaction {
        return handleFileTransaction(cc, t, HandleDeleteFile, "Cannot delete non-existent file.")
}

func HandleDownloadFileWithUserFolders(cc *hotline.ClientConn, t *hotline.Transaction) []hotline.Transaction {
        return handleFileTransaction(cc, t, HandleDownloadFile, "Cannot download non-existent user file.")
}

func HandleDownloadFolderWithUserFolders(cc *hotline.ClientConn, t *hotline.Transaction) []hotline.Transaction {
        return handleFileTransaction(cc, t, HandleDownloadFolder, "Cannot download non-existent user folder.")
}

// HandleGetFileNameListWithUserFolders modifies the file listing behavior for `~`
func HandleGetFileNameListWithUserFolders(cc *hotline.ClientConn, t *hotline.Transaction) []hotline.Transaction {
        requestedPath, err := hotline.ReadPath(cc.FileRoot(), t.GetField(hotline.FieldFilePath).Data, nil)
        if err != nil {
                return nil
        }

        if requestedPath == cc.FileRoot() {
                fileNames, err := hotline.GetFileNameList(cc.FileRoot(), cc.Server.Config.IgnoreFiles)
                if err != nil {
                        return nil
                }

                userFolder := filepath.Join(cc.FileRoot(), "~", cc.Account.Login)
                if stat, err := os.Stat(userFolder); err != nil || !stat.IsDir() {
                        filteredFiles := make([]hotline.Field, 0, len(fileNames))
                        for _, file := range fileNames {
                                if !strings.Contains(string(file.Data), "~") {
                                        filteredFiles = append(filteredFiles, file)
                                }
                        }
                        return []hotline.Transaction{cc.NewReply(t, filteredFiles...)}
                }
                return []hotline.Transaction{cc.NewReply(t, fileNames...)}
        }

        if strings.HasPrefix(requestedPath, filepath.Join(cc.FileRoot(), "~")) {
                resolvedPath, err := ResolveUserPath(cc, requestedPath[len(cc.FileRoot())+1:])
                if err != nil {
                        return nil
                }
                updateTransactionPath(t, resolvedPath)
                return HandleGetFileNameList(cc, t)
        }

        return HandleGetFileNameList(cc, t)
}