idan/sshwifty-udp-telnet-http
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Configuration: 1) Add scheme syntax support to Preset Meta; 2) Some wrong defaults has now been fixed

Browse Source
This commit is contained in:
NI
2020-08-13 22:37:53 +08:00
parent 1c018ce560
commit d86c92867c
7 changed files with 271 additions and 48 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
application/configuration/common.go Normal file
View File

@@ -0,0 +1,9 @@
package configuration
func durationAtLeast(current, min int) int {
if current > min {
return current
}
return min
}

21
application/configuration/config.go
View File

@@ -120,6 +120,27 @@ func (s Server) Verify() error {
return nil
}
// Meta contains data of a Key -> Value map which can be use to store
// dynamically structured configuration options
type Meta map[string]String
// Concretize returns an concretized Meta as a `map[string]string`
func (m Meta) Concretize() (map[string]string, error) {
mm := make(map[string]string, len(m))
for k, v := range m {
result, err := v.Parse()
if err != nil {
return nil, fmt.Errorf("Unable to parse Meta \"%s\": %s", k, err)
}
mm[k] = result
}
return mm, nil
}
// Preset contains data of a static remote host
type Preset struct {
Title string

63
application/configuration/loader_enviro.go
View File

@@ -32,7 +32,7 @@ const (
enviroTypeName = "Environment Variable"
)
func parseEviro(name string) string {
func parseEnv(name string) string {
v := os.Getenv(name)
if !strings.HasPrefix(v, "SSHWIFTY_ENV_RENAMED:") {
@@ -42,25 +42,35 @@ func parseEviro(name string) string {
return os.Getenv(v[21:])
}
func parseEnvDef(name string, def string) string {
v := parseEnv(name)
if len(v) > 0 {
return v
}
return def
}
// Enviro creates an environment variable based configuration loader
func Enviro() Loader {
return func(log log.Logger) (string, Configuration, error) {
log.Info("Loading configuration from environment variables ...")
dialTimeout, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_DIALTIMEOUT"), 10, 32)
parseEnv("SSHWIFTY_DIALTIMEOUT"), 10, 32)
cfg, cfgErr := fileCfgCommon{
HostName: parseEviro("SSHWIFTY_HOSTNAME"),
SharedKey: parseEviro("SSHWIFTY_SHAREDKEY"),
HostName: parseEnv("SSHWIFTY_HOSTNAME"),
SharedKey: parseEnv("SSHWIFTY_SHAREDKEY"),
DialTimeout: int(dialTimeout),
Socks5: parseEviro("SSHWIFTY_SOCKS5"),
Socks5User: parseEviro("SSHWIFTY_SOCKS5_USER"),
Socks5Password: parseEviro("SSHWIFTY_SOCKS5_PASSWORD"),
Socks5: parseEnv("SSHWIFTY_SOCKS5"),
Socks5User: parseEnv("SSHWIFTY_SOCKS5_USER"),
Socks5Password: parseEnv("SSHWIFTY_SOCKS5_PASSWORD"),
Servers: nil,
Presets: nil,
OnlyAllowPresetRemotes: len(
parseEviro("SSHWIFTY_ONLYALLOWPRESETREMOTES")) > 0,
parseEnv("SSHWIFTY_ONLYALLOWPRESETREMOTES")) > 0,
}.build()
if cfgErr != nil {
@@ -68,32 +78,28 @@ func Enviro() Loader {
"Failed to build the configuration: %s", cfgErr)
}
listenIface := parseEviro("SSHWIFTY_LISTENINTERFACE")
if len(listenIface) <= 0 {
listenIface = "127.0.0.1"
}
listenIface := parseEnv("SSHWIFTY_LISTENINTERFACE")
listenPort, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_LISTENPORT"), 10, 16)
parseEnv("SSHWIFTY_LISTENPORT"), 10, 16)
initialTimeout, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_INITIALTIMEOUT"), 10, 32)
parseEnv("SSHWIFTY_INITIALTIMEOUT"), 10, 32)
readTimeout, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_READTIMEOUT"), 10, 32)
parseEnv("SSHWIFTY_READTIMEOUT"), 10, 32)
writeTimeout, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_WRITETIMEOUT"), 10, 32)
parseEnv("SSHWIFTY_WRITETIMEOUT"), 10, 32)
heartbeatTimeout, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_HEARTBEATTIMEOUT"), 10, 32)
parseEnv("SSHWIFTY_HEARTBEATTIMEOUT"), 10, 32)
readDelay, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_READDELAY"), 10, 32)
parseEnv("SSHWIFTY_READDELAY"), 10, 32)
writeDelay, _ := strconv.ParseUint(
parseEviro("SSHWIFTY_WRITEELAY"), 10, 32)
parseEnv("SSHWIFTY_WRITEELAY"), 10, 32)
cfgSer := fileCfgServer{
ListenInterface: listenIface,
@@ -104,12 +110,12 @@ func Enviro() Loader {
HeartbeatTimeout: int(heartbeatTimeout),
ReadDelay: int(readDelay),
WriteDelay: int(writeDelay),
TLSCertificateFile: parseEviro("SSHWIFTY_TLSCERTIFICATEFILE"),
TLSCertificateKeyFile: parseEviro("SSHWIFTY_TLSCERTIFICATEKEYFILE"),
TLSCertificateFile: parseEnv("SSHWIFTY_TLSCERTIFICATEFILE"),
TLSCertificateKeyFile: parseEnv("SSHWIFTY_TLSCERTIFICATEKEYFILE"),
}
presets := make([]Preset, 0, 16)
presetStr := strings.TrimSpace(parseEviro("SSHWIFTY_PRESETS"))
presets := make(fileCfgPresets, 0, 16)
presetStr := strings.TrimSpace(parseEnv("SSHWIFTY_PRESETS"))
if len(presetStr) > 0 {
jErr := json.Unmarshal([]byte(presetStr), &presets)
@@ -120,6 +126,13 @@ func Enviro() Loader {
}
}
concretizePresets, err := presets.concretize()
if err != nil {
return enviroTypeName, Configuration{}, fmt.Errorf(
"Unable to parse Preset data: %s", err)
}
return enviroTypeName, Configuration{
HostName: cfg.HostName,
SharedKey: cfg.SharedKey,
@@ -128,7 +141,7 @@ func Enviro() Loader {
Socks5User: cfg.Socks5User,
Socks5Password: cfg.Socks5Password,
Servers: []Server{cfgSer.build()},
Presets: presets,
Presets: concretizePresets,
OnlyAllowPresetRemotes: cfg.OnlyAllowPresetRemotes,
}, nil
}

68
application/configuration/loader_file.go
View File

@@ -47,30 +47,28 @@ type fileCfgServer struct {
TLSCertificateKeyFile string // Location of TLS certificate key
}
func (f fileCfgServer) durationAtLeast(current, min int) int {
if current > min {
return current
func (f *fileCfgServer) build() Server {
iface := f.ListenInterface
if len(iface) <= 0 {
iface = "127.0.0.1"
}
return min
}
func (f *fileCfgServer) build() Server {
return Server{
ListenInterface: f.ListenInterface,
ListenInterface: iface,
ListenPort: f.ListenPort,
InitialTimeout: time.Duration(
f.durationAtLeast(f.InitialTimeout, 5)) * time.Second,
durationAtLeast(f.InitialTimeout, 5)) * time.Second,
ReadTimeout: time.Duration(
f.durationAtLeast(f.ReadTimeout, 30)) * time.Second,
durationAtLeast(f.ReadTimeout, 30)) * time.Second,
WriteTimeout: time.Duration(
f.durationAtLeast(f.WriteTimeout, 30)) * time.Second,
durationAtLeast(f.WriteTimeout, 30)) * time.Second,
HeartbeatTimeout: time.Duration(
f.durationAtLeast(f.HeartbeatTimeout, 10)) * time.Second,
durationAtLeast(f.HeartbeatTimeout, 10)) * time.Second,
ReadDelay: time.Duration(
f.durationAtLeast(f.ReadDelay, 0)) * time.Millisecond,
durationAtLeast(f.ReadDelay, 0)) * time.Millisecond,
WriteDelay: time.Duration(
f.durationAtLeast(f.WriteDelay, 0)) * time.Millisecond,
durationAtLeast(f.WriteDelay, 0)) * time.Millisecond,
TLSCertificateFile: f.TLSCertificateFile,
TLSCertificateKeyFile: f.TLSCertificateKeyFile,
}
@@ -80,16 +78,42 @@ type fileCfgPreset struct {
Title string
Type string
Host string
Meta map[string]string
Meta Meta
}
func (f fileCfgPreset) build() Preset {
func (f fileCfgPreset) concretize() (Preset, error) {
m, err := f.Meta.Concretize()
if err != nil {
return Preset{}, err
}
return Preset{
Title: f.Title,
Type: strings.TrimSpace(f.Type),
Host: f.Host,
Meta: f.Meta,
Meta: m,
}, nil
}
type fileCfgPresets []fileCfgPreset
func (f fileCfgPresets) concretize() ([]Preset, error) {
ps := make([]Preset, 0, len(f))
for i, p := range f {
pp, err := p.concretize()
if err != nil {
return nil, fmt.Errorf(
"Unable to concretize Preset %d (titled \"%s\"): %s",
i+1, p.Title, err)
}
ps = append(ps, pp)
}
return ps, nil
}
type fileCfgCommon struct {
@@ -115,7 +139,7 @@ type fileCfgCommon struct {
Servers []*fileCfgServer
// Remotes
Presets []*fileCfgPreset
Presets fileCfgPresets
// Allow predefined remotes only
OnlyAllowPresetRemotes bool
@@ -125,7 +149,7 @@ func (f fileCfgCommon) build() (fileCfgCommon, error) {
return fileCfgCommon{
HostName: f.HostName,
SharedKey: f.SharedKey,
DialTimeout: f.DialTimeout,
DialTimeout: durationAtLeast(f.DialTimeout, 5),
Socks5: f.Socks5,
Socks5User: f.Socks5User,
Socks5Password: f.Socks5Password,
@@ -165,10 +189,10 @@ func loadFile(filePath string) (string, Configuration, error) {
servers[i] = finalCfg.Servers[i].build()
}
presets := make([]Preset, len(finalCfg.Presets))
presets, err := finalCfg.Presets.concretize()
for i := range presets {
presets[i] = finalCfg.Presets[i].build()
if err != nil {
return fileTypeName, Configuration{}, err
}
return fileTypeName, Configuration{

60
application/configuration/string.go Normal file
View File

@@ -0,0 +1,60 @@
package configuration
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
)
// String represents a config string
type String string
// Parse parses current string and return the parsed result
func (s String) Parse() (string, error) {
ss := string(s)
sSchemeLeadIdx := strings.Index(ss, "://")
if sSchemeLeadIdx < 0 {
return ss, nil
}
sSchemeLeadEnd := sSchemeLeadIdx + 3
switch strings.ToLower(ss[:sSchemeLeadIdx]) {
case "file":
fPath, e := filepath.Abs(ss[sSchemeLeadEnd:])
if e != nil {
return ss, e
}
f, e := os.Open(fPath)
if e != nil {
return "", fmt.Errorf("Unable to open %s: %s", fPath, e)
}
defer f.Close()
fData, e := ioutil.ReadAll(f)
if e != nil {
return "", fmt.Errorf("Unable to read from %s: %s", fPath, e)
}
return string(fData), nil
case "enviroment":
return os.Getenv(ss[sSchemeLeadEnd:]), nil
case "literal":
return ss[sSchemeLeadEnd:], nil
default:
return "", fmt.Errorf(
"Scheme \"%s\" was unsupported", ss[:sSchemeLeadIdx])
}
}

77
application/configuration/string_test.go Normal file
View File

@@ -0,0 +1,77 @@
package configuration
import (
"os"
"testing"
)
func TestStringString(t *testing.T) {
ss := String("aaaaaaaaaaaaa")
result, err := ss.Parse()
if err != nil {
t.Error("Unable to parse:", err)
return
}
if result != "aaaaaaaaaaaaa" {
t.Errorf(
"Expecting the result to be %s, got %s instead",
"aaaaaaaaaaaaa",
result,
)
return
}
}
func TestStringFile(t *testing.T) {
const testFilename = "sshwifty.configuration.test.string.file.tmp"
filePath := os.TempDir() + string(os.PathSeparator) + testFilename
f, err := os.Create(filePath)
if err != nil {
t.Error("Unable to create file:", err)
return
}
defer os.Remove(filePath)
f.WriteString("TestAAAA")
f.Close()
ss := String("file://" + filePath)
result, err := ss.Parse()
if err != nil {
t.Error("Unable to parse:", err)
return
}
if result != "TestAAAA" {
t.Errorf(
"Expecting the result to be %s, got %s instead",
"TestAAAA",
result,
)
return
}
ss = String("file://" + filePath + ".notexist")
result, err = ss.Parse()
if err == nil {
t.Error("Parsing an non-existing file should result an error")
return
}
}