mirror of
https://github.com/kovidgoyal/kitty.git
synced 2026-02-01 11:34:59 +01:00
115 lines
2.8 KiB
Go
115 lines
2.8 KiB
Go
// License: GPLv3 Copyright: 2023, Kovid Goyal, <kovid at kovidgoyal.net>
|
|
|
|
package transfer
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
|
|
"kitty/tools/crypto"
|
|
"kitty/tools/utils"
|
|
"kitty/tools/utils/humanize"
|
|
)
|
|
|
|
var _ = fmt.Print
|
|
|
|
var global_cwd, global_home string
|
|
|
|
func cwd_path() string {
|
|
if global_cwd == "" {
|
|
ans, _ := os.Getwd()
|
|
return ans
|
|
}
|
|
return global_cwd
|
|
}
|
|
|
|
func home_path() string {
|
|
if global_home == "" {
|
|
return utils.Expanduser("~")
|
|
}
|
|
return global_home
|
|
}
|
|
|
|
func encode_bypass(request_id string, bypass string) (string, error) {
|
|
q := request_id + ";" + bypass
|
|
if pkey_encoded := os.Getenv("KITTY_PUBLIC_KEY"); pkey_encoded != "" {
|
|
encryption_protocol, pubkey, err := crypto.DecodePublicKey(pkey_encoded)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
encrypted, err := crypto.Encrypt_data(utils.UnsafeStringToBytes(q), pubkey, encryption_protocol)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
return fmt.Sprintf("kitty-1:%s", utils.UnsafeBytesToString(encrypted)), nil
|
|
}
|
|
return "", fmt.Errorf("KITTY_PUBLIC_KEY env var not set, cannot transmit password securely")
|
|
}
|
|
|
|
func abspath(path string, use_home ...bool) string {
|
|
if filepath.IsAbs(path) {
|
|
return path
|
|
}
|
|
var base string
|
|
if len(use_home) > 0 && use_home[0] {
|
|
base = home_path()
|
|
} else {
|
|
base = cwd_path()
|
|
}
|
|
return filepath.Join(base, path)
|
|
}
|
|
|
|
func expand_home(path string) string {
|
|
if strings.HasPrefix(path, "~"+string(os.PathSeparator)) {
|
|
path = strings.TrimLeft(path[2:], string(os.PathSeparator))
|
|
path = filepath.Join(home_path(), path)
|
|
} else if path == "~" {
|
|
path = home_path()
|
|
}
|
|
return path
|
|
}
|
|
|
|
func random_id() string {
|
|
bytes := []byte{0, 0}
|
|
rand.Read(bytes)
|
|
return fmt.Sprintf("%x%s", os.Getpid(), hex.EncodeToString(bytes))
|
|
}
|
|
|
|
func run_with_paths(cwd, home string, f func()) {
|
|
global_cwd, global_home = cwd, home
|
|
defer func() { global_cwd, global_home = "", "" }()
|
|
f()
|
|
}
|
|
|
|
func should_be_compressed(path, strategy string) bool {
|
|
if strategy == "always" {
|
|
return true
|
|
}
|
|
if strategy == "never" {
|
|
return false
|
|
}
|
|
ext := strings.ToLower(filepath.Ext(path))
|
|
if ext != "" {
|
|
switch ext[1:] {
|
|
case "zip", "odt", "odp", "pptx", "docx", "gz", "bz2", "xz", "svgz":
|
|
return false
|
|
}
|
|
}
|
|
mt := utils.GuessMimeType(path)
|
|
if strings.HasSuffix(mt, "+zip") || (strings.HasPrefix(mt, "image/") && mt != "image/svg+xml") || strings.HasPrefix(mt, "video/") {
|
|
return false
|
|
}
|
|
return true
|
|
}
|
|
|
|
func print_rsync_stats(total_bytes, delta_bytes, signature_bytes int64) {
|
|
fmt.Println("Rsync stats:")
|
|
fmt.Printf(" Delta size: %s Signature size: %s\n", humanize.Size(delta_bytes), humanize.Size(signature_bytes))
|
|
frac := float64(delta_bytes+signature_bytes) / float64(utils.Max(1, total_bytes))
|
|
fmt.Printf(" Transmitted: %s of a total of %s (%.1f%%)\n", humanize.Size(delta_bytes+signature_bytes), humanize.Size(total_bytes), frac*100)
|
|
}
|