Added a new way to parse transport options that allows for nested JSON

2 files changed, 171 insertions, 0 deletions

diff --git a/common/options.go b/common/options.go
new file mode 100644
index 0000000..9c73616
--- /dev/null
+++ b/common/options.go
@@ -0,0 +1,24 @@
+package options
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+)
+
+func ParseOptions(s string) (map[string]interface{}, error) {
+	var result map[string]interface{}
+
+	if len(s) == 0 {
+		return nil, errors.New("Empty options")
+	}
+
+	decoder := json.NewDecoder(strings.NewReader(s))
+	if err := decoder.Decode(&result); err != nil {
+		fmt.Errorf("Error decoding JSON %q", err)
+		return nil, err
+	}
+
+	return result, nil
+}
diff --git a/transports/transports.go b/transports/transports.go
index e435423..df05d33 100644
--- a/transports/transports.go
+++ b/transports/transports.go
@@ -29,7 +29,154 @@
 // transports.
 package transports
 
+import (
+	"errors"
+	"github.com/OperatorFoundation/shapeshifter-transports/transports/obfs4"
+	"github.com/OperatorFoundation/shapeshifter-transports/transports/shadow"
+	"github.com/mufti1/interconv/package"
+	"strconv"
+)
+
 // Transports returns the list of registered transport protocols.
 func Transports() []string {
 	return []string{"obfs2", "shadow", "obfs4", "Optimizer"}
 }
+
+func ParseArgsObfs4(args map[string]interface{}, target string) (*obfs4.Transport, error) {
+	var cert string
+	var iatMode int
+
+	untypedCert, ok := args["cert"]
+	if !ok {
+		return nil, errors.New("obfs4 transport missing cert argument")
+	}
+
+	switch untypedCert.(type) {
+	case string:
+		var icerr error
+		cert, icerr = interconv.ParseString(untypedCert)
+		if icerr != nil {
+			return nil, icerr
+		}
+	default:
+		return nil, errors.New("Unsupported type for obfs4 cert option")
+	}
+
+	untypedIatMode, ok2 := args["iatMode"]
+	if !ok2 {
+		return nil, errors.New("obfs4 transport missing iatMode argument")
+	}
+
+	switch untypedCert.(type) {
+	case string:
+		iatModeStr, icerr := interconv.ParseString(untypedIatMode)
+		if icerr != nil {
+			return nil, icerr
+		}
+		iatModeInt, scerr := strconv.Atoi(iatModeStr)
+		if scerr != nil {
+			return nil, errors.New("obfs4 transport bad iatMode value")
+		}
+		switch iatModeInt {
+		case 0:
+			iatMode = iatModeInt
+		case 1:
+			iatMode = iatModeInt
+		default:
+			return nil, errors.New("Unsupported value for obfs4 iatMode option")
+		}
+	case float64:
+		iatModeFloat, icerr := interconv.ParseFloat64(untypedIatMode)
+		if icerr != nil {
+			return nil, icerr
+		}
+		iatModeInt := int(iatModeFloat)
+		switch iatModeInt {
+		case 0:
+			iatMode = iatModeInt
+		case 1:
+			iatMode = iatModeInt
+		default:
+			return nil, errors.New("Unsupported value for obfs4 iatMode option")
+		}
+	case int:
+		iatModeInt, icerr := interconv.ParseInt(untypedIatMode)
+		if icerr != nil {
+			return nil, icerr
+		}
+		switch iatModeInt {
+		case 0:
+			iatMode = iatModeInt
+		case 1:
+			iatMode = iatModeInt
+		default:
+			return nil, errors.New("Unsupported value for obfs4 iatMode option")
+		}
+	case bool:
+		iatModeBool, icerr := interconv.ParseBoolean(untypedCert)
+		if icerr != nil {
+			return nil, icerr
+		}
+		switch iatModeBool {
+		case true:
+			iatMode = 1
+		case false:
+			iatMode = 0
+		}
+	default:
+		return nil, errors.New("Unsupported type for obfs4 iatMode option")
+	}
+
+	transport := obfs4.Transport{
+		CertString: cert,
+		IatMode:    iatMode,
+		Address:    target,
+	}
+
+	return &transport, nil
+}
+
+func ParseArgsShadow(args map[string]interface{}, target string) (*shadow.Transport, error) {
+	var password string
+	var cipherName string
+
+	untypedPassword, ok := args["password"]
+	if !ok {
+		return nil, errors.New("shadow transport missing password argument")
+	}
+
+	switch untypedPassword.(type) {
+	case string:
+		var icerr error
+		password, icerr = interconv.ParseString(untypedPassword)
+		if icerr != nil {
+			return nil, icerr
+		}
+	default:
+		return nil, errors.New("Unsupported type for shadow password option")
+	}
+
+	untypedCipherName, ok2 := args["cipherName"]
+	if !ok2 {
+		return nil, errors.New("shadow transport missing cipherName argument")
+	}
+
+	switch untypedCipherName.(type) {
+	case string:
+		var icerr error
+		cipherName, icerr = interconv.ParseString(untypedCipherName)
+		if icerr != nil {
+			return nil, icerr
+		}
+	default:
+		return nil, errors.New("Unsupported type for shadow cipherName option")
+	}
+
+	transport := shadow.Transport{
+		Password:   password,
+		CipherName: cipherName,
+		Address:    target,
+	}
+
+	return &transport, nil
+}