start on a wrapper for sam3

Author: eyedeekay

.gitignore

@@ -1,2 +1,4 @@
 review.md
 SAMv3.md
+testplan.md
+err

SAMConn.go

@@ -0,0 +1,10 @@
+package sam3
+
+import (
+	"github.com/go-i2p/go-sam-go/stream"
+)
+
+// Implements net.Conn
+type SAMConn struct {
+	*stream.StreamConn
+}

common/emitter_test.go

@@ -0,0 +1,132 @@
+package common
+
+import (
+	"bytes"
+	"testing"
+)
+
+var (
+	from = RandPort()
+	to   = RandPort()
+)
+
+func setupTestEmit() *SAMEmit {
+	return &SAMEmit{
+		I2PConfig: I2PConfig{
+			SamHost:  "127.0.0.1",
+			SamPort:  7656,
+			SamMin:   "3.0",
+			SamMax:   "3.1",
+			Style:    "STREAM",
+			TunName:  "testid",
+			Fromport: from,
+			Toport:   to,
+			SigType:  "ED25519",
+		},
+	}
+}
+
+func TestSAMEmit_Hello(t *testing.T) {
+	emit := setupTestEmit()
+	want := "HELLO VERSION MIN=3.0 MAX=3.1 \n"
+
+	t.Run("string output", func(t *testing.T) {
+		if got := emit.Hello(); got != want {
+			t.Errorf("Hello() = %v, want %v", got, want)
+		}
+	})
+
+	t.Run("byte output", func(t *testing.T) {
+		if got := emit.HelloBytes(); !bytes.Equal(got, []byte(want)) {
+			t.Errorf("HelloBytes() = %v, want %v", got, []byte(want))
+		}
+	})
+}
+
+func TestSAMEmit_GenerateDestination(t *testing.T) {
+	emit := setupTestEmit()
+	want := "DEST GENERATE ED25519 \n"
+
+	t.Run("string output", func(t *testing.T) {
+		if got := emit.GenerateDestination(); got != want {
+			t.Errorf("GenerateDestination() = %v, want %v", got, want)
+		}
+	})
+
+	t.Run("byte output", func(t *testing.T) {
+		if got := emit.GenerateDestinationBytes(); !bytes.Equal(got, []byte(want)) {
+			t.Errorf("GenerateDestinationBytes() = %v, want %v", got, []byte(want))
+		}
+	})
+}
+
+func TestSAMEmit_Lookup(t *testing.T) {
+	tests := []struct {
+		name   string
+		lookup string
+		want   string
+	}{
+		{"basic lookup", "test.i2p", "NAMING LOOKUP NAME=test.i2p \n"},
+		{"empty lookup", "", "NAMING LOOKUP NAME= \n"},
+	}
+
+	emit := setupTestEmit()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := emit.Lookup(tt.lookup); got != tt.want {
+				t.Errorf("Lookup() = %v, want %v", got, tt.want)
+			}
+			if got := emit.LookupBytes(tt.lookup); !bytes.Equal(got, []byte(tt.want)) {
+				t.Errorf("LookupBytes() = %v, want %v", got, []byte(tt.want))
+			}
+		})
+	}
+}
+
+func TestSAMEmit_Connect(t *testing.T) {
+	tests := []struct {
+		name string
+		dest string
+		want string
+	}{
+		{
+			"basic connect",
+			"destination123",
+			"STREAM CONNECT ID=testid " + from + " " + to + " DESTINATION=destination123 \n",
+		},
+		{
+			"empty destination",
+			"",
+			"STREAM CONNECT ID=testid " + from + " " + to + " DESTINATION= \n",
+		},
+	}
+
+	emit := setupTestEmit()
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := emit.Connect(tt.dest); got != tt.want {
+				t.Errorf("Connect() = %v, want %v", got, tt.want)
+			}
+			if got := emit.ConnectBytes(tt.dest); !bytes.Equal(got, []byte(tt.want)) {
+				t.Errorf("ConnectBytes() = %v, want %v", got, []byte(tt.want))
+			}
+		})
+	}
+}
+
+func TestSAMEmit_Accept(t *testing.T) {
+	emit := setupTestEmit()
+	want := "STREAM ACCEPT ID=testid " + from + " " + to + ""
+
+	t.Run("string output", func(t *testing.T) {
+		if got := emit.Accept(); got != want {
+			t.Errorf("Accept() = %v, want %v", got, want)
+		}
+	})
+
+	t.Run("byte output", func(t *testing.T) {
+		if got := emit.AcceptBytes(); !bytes.Equal(got, []byte(want)) {
+			t.Errorf("AcceptBytes() = %v, want %v", got, []byte(want))
+		}
+	})
+}

common/util.go

@@ -71,8 +71,10 @@ func ExtractDest(input string) string {
 	return strings.Split(input, " ")[0]
 }
 
-var randSource = rand.NewSource(time.Now().UnixNano())
-var randGen = rand.New(randSource)
+var (
+	randSource = rand.NewSource(time.Now().UnixNano())
+	randGen    = rand.New(randSource)
+)
 
 func RandPort() string {
 	for {

config.go

@@ -0,0 +1,62 @@
+package sam3
+
+import (
+	"fmt"
+
+	"github.com/go-i2p/go-sam-go/common"
+)
+
+// I2PConfig is a struct which manages I2P configuration options
+type I2PConfig struct {
+	common.I2PConfig
+}
+
+func NewConfig(opts ...func(*I2PConfig) error) (*I2PConfig, error) {
+	var config I2PConfig
+	config.SamHost = "127.0.0.1"
+	config.SamPort = 7656
+	config.SamMin = "3.0"
+	config.SamMax = "3.2"
+	config.TunName = ""
+	config.TunType = "server"
+	config.Style = "STREAM"
+	config.InLength = 3
+	config.OutLength = 3
+	config.InQuantity = 2
+	config.OutQuantity = 2
+	config.InVariance = 1
+	config.OutVariance = 1
+	config.InBackupQuantity = 3
+	config.OutBackupQuantity = 3
+	config.InAllowZeroHop = false
+	config.OutAllowZeroHop = false
+	config.EncryptLeaseSet = false
+	config.LeaseSetKey = ""
+	config.LeaseSetPrivateKey = ""
+	config.LeaseSetPrivateSigningKey = ""
+	config.FastRecieve = false
+	config.UseCompression = true
+	config.ReduceIdle = false
+	config.ReduceIdleTime = 15
+	config.ReduceIdleQuantity = 4
+	config.CloseIdle = false
+	config.CloseIdleTime = 300000
+	config.MessageReliability = "none"
+	for _, o := range opts {
+		if err := o(&config); err != nil {
+			return nil, err
+		}
+	}
+	return &config, nil
+}
+
+// options map
+type Options map[string]string
+
+// obtain sam options as list of strings
+func (opts Options) AsList() (ls []string) {
+	for k, v := range opts {
+		ls = append(ls, fmt.Sprintf("%s=%s", k, v))
+	}
+	return
+}

datagram.go

@@ -0,0 +1,13 @@
+package sam3
+
+import (
+	"github.com/go-i2p/go-sam-go/datagram"
+)
+
+// The DatagramSession implements net.PacketConn. It works almost like ordinary
+// UDP, except that datagrams may be at most 31kB large. These datagrams are
+// also end-to-end encrypted, signed and includes replay-protection. And they
+// are also built to be surveillance-resistant (yey!).
+type DatagramSession struct {
+	datagram.DatagramSession
+}