Fix a bunch of errors that could potentially happen because of changes I made to the Dialer

Makefile

@@ -1,6 +1,6 @@
 
 USER_GH=eyedeekay
-VERSION=0.32.29
+VERSION=0.32.30
 packagename=gosam
 
 echo: fmt

accept.go

@@ -24,15 +24,14 @@ func (c *Client) Listen() (net.Listener, error) {
 // with Accept
 func (c *Client) ListenI2P(dest string) (net.Listener, error) {
 	var err error
-	c.id = c.NewID()
+	c.destination, err = c.CreateStreamSession(dest)
-	c.destination, err = c.CreateStreamSession(c.id, dest)
 	d := c.destination
 	if err != nil {
 		return nil, err
 	}
 	fmt.Println("Listening on destination:", c.Base32()+".b32.i2p")
 
-	c, err = c.NewClient()
+	c, err = c.NewClient(c.id)
 	if err != nil {
 		return nil, err
 	}
@@ -52,7 +51,7 @@ func (c *Client) Accept() (net.Conn, error) {
 	if c.id == 0 {
 		return c.AcceptI2P()
 	}
-	resp, err := c.StreamAccept(c.id)
+	resp, err := c.StreamAccept()
 	if err != nil {
 		return nil, err
 	}

client.go

@@ -11,7 +11,8 @@ import (
 	"math/rand"
 	"net"
 	"strings"
-	"sync"
+	//	"sync"
+	"time"
 )
 
 // A Client represents a single Connection to the SAM bridge
@@ -21,8 +22,9 @@ type Client struct {
 	fromport string
 	toport   string
 
-	SamConn net.Conn
+	SamConn   net.Conn
-	rd      *bufio.Reader
+	SamDGConn DatagramConn
+	rd        *bufio.Reader
 
 	sigType     string
 	destination string
@@ -52,10 +54,9 @@ type Client struct {
 
 	debug bool
 	//NEVER, EVER modify lastaddr or id yourself. They are used internally only.
-	lastaddr string
+	id     int32
-	id       int32
+	sammin int
-	ml       sync.Mutex
+	sammax int
-	oml      sync.Mutex
 }
 
 var SAMsigTypes = []string{
@@ -66,6 +67,12 @@ var SAMsigTypes = []string{
 	"SIGNATURE_TYPE=EdDSA_SHA512_Ed25519",
 }
 
+var ValidSAMCommands = []string{
+	"HELLO",
+	"SESSION",
+	"STREAM",
+}
+
 var (
 	i2pB64enc *base64.Encoding = base64.NewEncoding("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-~")
 	i2pB32enc *base32.Encoding = base32.NewEncoding("abcdefghijklmnopqrstuvwxyz234567")
@@ -83,7 +90,11 @@ func NewClient(addr string) (*Client, error) {
 
 // NewID generates a random number to use as an tunnel name
 func (c *Client) NewID() int32 {
-	return rand.Int31n(math.MaxInt32)
+	if c.id == 0 {
+		c.id = rand.Int31n(math.MaxInt32)
+		fmt.Printf("Initializing new ID: %d\n", c.id)
+	}
+	return c.id
 }
 
 // Destination returns the full destination of the local tunnel
@@ -127,11 +138,11 @@ func NewClientFromOptions(opts ...func(*Client) error) (*Client, error) {
 	c.port = "7656"
 	c.inLength = 3
 	c.inVariance = 0
-	c.inQuantity = 1
+	c.inQuantity = 3
 	c.inBackups = 1
 	c.outLength = 3
 	c.outVariance = 0
-	c.outQuantity = 1
+	c.outQuantity = 3
 	c.outBackups = 1
 	c.dontPublishLease = true
 	c.encryptLease = false
@@ -140,20 +151,22 @@ func NewClientFromOptions(opts ...func(*Client) error) (*Client, error) {
 	c.reduceIdleQuantity = 1
 	c.closeIdle = true
 	c.closeIdleTime = 600000
-	c.debug = true
+	c.debug = false
 	c.sigType = SAMsigTypes[4]
 	c.id = 0
-	c.lastaddr = "invalid"
 	c.destination = ""
 	c.leaseSetEncType = "4,0"
 	c.fromport = ""
 	c.toport = ""
+	c.sammin = 0
+	c.sammax = 1
 	for _, o := range opts {
 		if err := o(&c); err != nil {
 			return nil, err
 		}
 	}
-	conn, err := net.Dial("tcp", c.samaddr())
+	c.id = c.NewID()
+	conn, err := net.DialTimeout("tcp", c.samaddr(), 15*time.Minute)
 	if err != nil {
 		return nil, err
 	}
@@ -166,7 +179,7 @@ func NewClientFromOptions(opts ...func(*Client) error) (*Client, error) {
 }
 
 func (p *Client) ID() string {
-	return fmt.Sprintf("%d", p.id)
+	return fmt.Sprintf("%d", p.NewID())
 }
 
 func (p *Client) Addr() net.Addr {
@@ -180,7 +193,7 @@ func (c *Client) samaddr() string {
 
 // send the initial handshake command and check that the reply is ok
 func (c *Client) hello() error {
-	r, err := c.sendCmd("HELLO VERSION MIN=3.0 MAX=3.2\n")
+	r, err := c.sendCmd("HELLO VERSION MIN=3.%d MAX=3.%d\n", c.sammin, c.sammax)
 	if err != nil {
 		return err
 	}
@@ -216,8 +229,10 @@ func (c *Client) Close() error {
 	return c.SamConn.Close()
 }
 
-// NewClient generates an exact copy of the client with the same options
+// NewClient generates an exact copy of the client with the same options, but
-func (c *Client) NewClient() (*Client, error) {
+// re-does all the handshaky business so that Dial can pick up right where it
+// left off, should the need arise.
+func (c *Client) NewClient(id int32) (*Client, error) {
 	return NewClientFromOptions(
 		SetHost(c.host),
 		SetPort(c.port),
@@ -238,7 +253,6 @@ func (c *Client) NewClient() (*Client, error) {
 		SetCloseIdle(c.closeIdle),
 		SetCloseIdleTime(c.closeIdleTime),
 		SetCompression(c.compression),
-		setlastaddr(c.lastaddr),
+		setid(id),
-		setid(c.id),
 	)
 }

client_test.go

@@ -6,6 +6,8 @@ import "testing"
 
 import (
 	"fmt"
+	"math"
+	"math/rand"
 	"time"
 	//"log"
 	"net/http"
@@ -18,48 +20,40 @@ func HelloServer(w http.ResponseWriter, r *http.Request) {
 	fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
 }
 
-var client *Client
-
-func setup(t *testing.T) {
-	var err error
-
-	// these tests expect a running SAM brige on this address
-	client, err = NewClientFromOptions(SetDebug(true))
-	if err != nil {
-		t.Fatalf("NewDefaultClient() Error: %q\n", err)
-	}
-}
-
 func TestCompositeClient(t *testing.T) {
-	listener, err := sam.I2PListener("testservice", "127.0.0.1:7656", "testkeys")
+	listener, err := sam.I2PListener("testservice"+fmt.Sprintf("%d", rand.Int31n(math.MaxInt32)), "127.0.0.1:7656", "testkeys")
 	if err != nil {
 		t.Fatalf("Listener() Error: %q\n", err)
 	}
+	defer listener.Close()
 	http.HandleFunc("/", HelloServer)
 	go http.Serve(listener, nil)
 
-	listener2, err := sam.I2PListener("testservice2", "127.0.0.1:7656", "testkeys2")
+	listener2, err := sam.I2PListener("testservice"+fmt.Sprintf("%d", rand.Int31n(math.MaxInt32)), "127.0.0.1:7656", "testkeys2")
 	if err != nil {
 		t.Fatalf("Listener() Error: %q\n", err)
 	}
+	defer listener2.Close()
 	//	http.HandleFunc("/", HelloServer)
 	go http.Serve(listener2, nil)
 
-	listener3, err := sam.I2PListener("testservice3", "127.0.0.1:7656", "testkeys3")
+	listener3, err := sam.I2PListener("testservice"+fmt.Sprintf("%d", rand.Int31n(math.MaxInt32)), "127.0.0.1:7656", "testkeys3")
 	if err != nil {
 		t.Fatalf("Listener() Error: %q\n", err)
 	}
+	defer listener3.Close()
 	//	http.HandleFunc("/", HelloServer)
 	go http.Serve(listener3, nil)
 
-	client, err = NewClientFromOptions(SetDebug(true))
+	sam, err := NewClientFromOptions(SetDebug(false))
 	if err != nil {
 		t.Fatalf("NewDefaultClient() Error: %q\n", err)
 	}
 	tr := &http.Transport{
-		Dial: client.Dial,
+		Dial: sam.Dial,
 	}
 	client := &http.Client{Transport: tr}
+	defer sam.Close()
 	time.Sleep(time.Second * 30)
 	go func() {
 		resp, err := client.Get("http://" + listener.Addr().(i2pkeys.I2PAddr).Base32())
@@ -67,45 +61,50 @@ func TestCompositeClient(t *testing.T) {
 			t.Fatalf("Get Error: %q\n", err)
 		}
 		defer resp.Body.Close()
-		t.Log("Get returned ", resp)
 	}()
+	time.Sleep(time.Second * 15)
 	go func() {
 		resp, err := client.Get("http://" + listener2.Addr().(i2pkeys.I2PAddr).Base32())
 		if err != nil {
 			t.Fatalf("Get Error: %q\n", err)
 		}
 		defer resp.Body.Close()
-		t.Log("Get returned ", resp)
 	}()
+	time.Sleep(time.Second * 15)
 	go func() {
 		resp, err := client.Get("http://" + listener3.Addr().(i2pkeys.I2PAddr).Base32())
 		if err != nil {
 			t.Fatalf("Get Error: %q\n", err)
 		}
 		defer resp.Body.Close()
-		t.Log("Get returned ", resp)
 	}()
 
-	time.Sleep(time.Second * 15)
+	time.Sleep(time.Second * 45)
 }
 
-func teardown(t *testing.T) {
+func TestClientHello(t *testing.T) {
+	client, err := NewClientFromOptions(SetDebug(false))
+	if err != nil {
+		t.Fatalf("NewDefaultClient() Error: %q\n", err)
+	}
+	t.Log(client.Base32())
 	if err := client.Close(); err != nil {
 		t.Fatalf("client.Close() Error: %q\n", err)
 	}
 }
 
-func TestClientHello(t *testing.T) {
-	setup(t)
-	t.Log(client.Base32())
-	teardown(t)
-}
-
 func TestNewDestination(t *testing.T) {
-	setup(t)
+	client, err := NewClientFromOptions(SetDebug(false))
-	t.Log(client.Base32())
+	if err != nil {
-	if _, err := client.NewDestination(SAMsigTypes[3]); err != nil {
+		t.Fatalf("NewDefaultClient() Error: %q\n", err)
-		t.Error(err)
+	}
+	t.Log(client.Base32())
+	if s, p, err := client.NewDestination(SAMsigTypes[3]); err != nil {
+		t.Error(err)
+	} else {
+		t.Log(s, p)
+	}
+	if err := client.Close(); err != nil {
+		t.Fatalf("client.Close() Error: %q\n", err)
 	}
-	teardown(t)
 }

datagram.go

@@ -0,0 +1,19 @@
+package goSam
+
+import (
+	"net"
+	"time"
+)
+
+type DatagramConn interface {
+	ReadFrom(p []byte) (n int, addr net.Addr, err error)
+	Read(b []byte) (n int, err error)
+	WriteTo(p []byte, addr net.Addr) (n int, err error)
+	Write(b []byte) (n int, err error)
+	Close() error
+	LocalAddr() net.Addr
+	RemoteAddr() net.Addr
+	SetDeadline(t time.Time) error
+	SetReadDeadline(t time.Time) error
+	SetWriteDeadline(t time.Time) error
+}

debian/changelog

@@ -1,10 +1,19 @@
+golang-github-eyedeekay-gosam (0.32.30) UNRELEASED; urgency=medium
+
+  * Improve the defaults
+  * Handle errors more correctly
+  * Gracefully handle hangups by creating a new session
+  * Set empty destinations to TRANSIENT when dialing
+
+ -- idk <hankhill19580@gmail.com>  Sun, 03 Nov 2020 16:12:04 -0500
+
 golang-github-eyedeekay-gosam (0.32.29) UNRELEASED; urgency=medium
 
   * Maintenance updates
 
- -- idk <hankhill19580@gmail.com>  Mon, 23 Nov 2020 20:40:4 -0500
+ -- idk <hankhill19580@gmail.com>  Mon, 23 Nov 2020 20:40:40 -0500
 
-golang-github-eyedeekay-gosam (0.32.27) UNRELEASED; urgency=medium
+golang-github-eyedeekay-gosam (0.32.28) UNRELEASED; urgency=medium
 
   * Maintenance updates
 

dial.go

@@ -2,35 +2,28 @@ package goSam
 
 import (
 	"context"
-	"fmt"
+	"log"
 	"net"
 	"strings"
 )
 
 // DialContext implements the net.DialContext function and can be used for http.Transport
 func (c *Client) DialContext(ctx context.Context, network, addr string) (net.Conn, error) {
-	c.oml.Lock()
-	defer c.oml.Unlock()
 	errCh := make(chan error, 1)
 	connCh := make(chan net.Conn, 1)
 	go func() {
-		if conn, err := c.Dial(network, addr); err != nil {
+		if conn, err := c.DialContextFree(network, addr); err != nil {
 			errCh <- err
 		} else if ctx.Err() != nil {
-			var err error
+			log.Println(ctx)
-			c, err = c.NewClient()
+			errCh <- ctx.Err()
-			if err != nil {
-				conn.Close()
-			}
 		} else {
 			connCh <- conn
 		}
 	}()
 	select {
 	case err := <-errCh:
-		//		var err error
+		return nil, err
-		c, err = c.NewClient()
-		return c.SamConn, err
 	case conn := <-connCh:
 		return conn, nil
 	case <-ctx.Done():
@@ -38,45 +31,53 @@ func (c *Client) DialContext(ctx context.Context, network, addr string) (net.Con
 	}
 }
 
-func (c *Client) dialCheck(addr string) (int32, bool) {
+func (c *Client) Dial(network, addr string) (net.Conn, error) {
-	if c.lastaddr == "invalid" {
+	return c.DialContext(context.TODO(), network, addr)
-		fmt.Println("Preparing to dial new address.")
-		return c.NewID(), true
-	} else if c.lastaddr != addr {
-		fmt.Println("Preparing to dial next new address.")
-	}
-	return c.id, false
 }
 
 // Dial implements the net.Dial function and can be used for http.Transport
-func (c *Client) Dial(network, addr string) (net.Conn, error) {
+func (c *Client) DialContextFree(network, addr string) (net.Conn, error) {
-	c.ml.Lock()
+	if network == "tcp" || network == "tcp6" || network == "tcp4" {
-	defer c.ml.Unlock()
+		return c.DialStreamingContextFree(addr)
+	}
+	if network == "udp" || network == "udp6" || network == "udp4" {
+		return c.DialDatagramContextFree(addr)
+	}
+	if network == "raw" || network == "ip" {
+		return c.DialDatagramContextFree(addr)
+	}
+	return c.DialStreamingContextFree(addr)
+}
+
+func (c *Client) DialDatagramContextFree(addr string) (DatagramConn, error) {
+	return c.SamDGConn, nil
+}
+
+func (c *Client) DialStreamingContextFree(addr string) (net.Conn, error) {
 	portIdx := strings.Index(addr, ":")
 	if portIdx >= 0 {
 		addr = addr[:portIdx]
 	}
 	addr, err := c.Lookup(addr)
 	if err != nil {
+		log.Printf("LOOKUP DIALER ERROR %s %s", addr, err)
 		return nil, err
 	}
 
-	var test bool
+	if c.destination == "" {
-	if c.id, test = c.dialCheck(addr); test == true {
+		c.destination, err = c.CreateStreamSession(c.destination)
-		c.destination, err = c.CreateStreamSession(c.id, c.destination)
 		if err != nil {
 			return nil, err
 		}
-		c.lastaddr = addr
-	}
-	c, err = c.NewClient()
-	if err != nil {
-		return nil, err
 	}
 
-	err = c.StreamConnect(c.id, addr)
+	d, err := c.NewClient(c.NewID())
 	if err != nil {
 		return nil, err
 	}
-	return c.SamConn, nil
+	err = d.StreamConnect(addr)
+	if err != nil {
+		return nil, err
+	}
+	return d.SamConn, nil
 }

go.mod

@@ -1,10 +1,11 @@
 module github.com/eyedeekay/goSam
 
 require (
-	github.com/eyedeekay/sam3 v0.32.32-0.20201122050855-f464873c9350
+	github.com/eyedeekay/sam3 v0.32.32
 	github.com/getlantern/go-socks5 v0.0.0-20171114193258-79d4dd3e2db5
 	github.com/getlantern/golog v0.0.0-20201105130739-9586b8bde3a9 // indirect
 	github.com/getlantern/netx v0.0.0-20190110220209-9912de6f94fd // indirect
+	github.com/getlantern/ops v0.0.0-20200403153110-8476b16edcd6 // indirect
 )
 
 //replace github.com/eyedeekay/gosam v0.1.1-0.20190814195658-27e786578944 => github.com/eyedeekay/goSam ./

go.sum

@@ -6,6 +6,8 @@ github.com/eyedeekay/sam3 v0.32.2/go.mod h1:Y3igFVzN4ybqkkpfUWULGhw7WRp8lieq0ORX
 github.com/eyedeekay/sam3 v0.32.31 h1:0fdDAupEQZSETHcyVQAsnFgpYArGJzU+lC2qN6f0GDk=
 github.com/eyedeekay/sam3 v0.32.32-0.20201122050855-f464873c9350 h1:8R4zcaWsgANiZ4MKKBPUf9Isct2M1IFVUVZdAMqPCmU=
 github.com/eyedeekay/sam3 v0.32.32-0.20201122050855-f464873c9350/go.mod h1:qRA9KIIVxbrHlkj+ZB+OoxFGFgdKeGp1vSgPw26eOVU=
+github.com/eyedeekay/sam3 v0.32.32 h1:9Ea1Ere5O8Clx8zYxKnvhrWy7R96Q4FvxlPskYf8VW0=
+github.com/eyedeekay/sam3 v0.32.32/go.mod h1:qRA9KIIVxbrHlkj+ZB+OoxFGFgdKeGp1vSgPw26eOVU=
 github.com/getlantern/context v0.0.0-20190109183933-c447772a6520 h1:NRUJuo3v3WGC/g5YiyF790gut6oQr5f3FBI88Wv0dx4=
 github.com/getlantern/context v0.0.0-20190109183933-c447772a6520/go.mod h1:L+mq6/vvYHKjCX2oez0CgEAJmbq1fbb/oNJIWQkBybY=
 github.com/getlantern/errors v1.0.1 h1:XukU2whlh7OdpxnkXhNH9VTLVz0EVPGKDV5K0oWhvzw=
@@ -22,6 +24,8 @@ github.com/getlantern/netx v0.0.0-20190110220209-9912de6f94fd h1:mn98vs69Kqw56iK
 github.com/getlantern/netx v0.0.0-20190110220209-9912de6f94fd/go.mod h1:wKdY0ikOgzrWSeB9UyBVKPRhjXQ+vTb+BPeJuypUuNE=
 github.com/getlantern/ops v0.0.0-20190325191751-d70cb0d6f85f h1:wrYrQttPS8FHIRSlsrcuKazukx/xqO/PpLZzZXsF+EA=
 github.com/getlantern/ops v0.0.0-20190325191751-d70cb0d6f85f/go.mod h1:D5ao98qkA6pxftxoqzibIBBrLSUli+kYnJqrgBf9cIA=
+github.com/getlantern/ops v0.0.0-20200403153110-8476b16edcd6 h1:QthAQCekS1YOeYWSvoHI6ZatlG4B+GBDLxV/2ZkBsTA=
+github.com/getlantern/ops v0.0.0-20200403153110-8476b16edcd6/go.mod h1:D5ao98qkA6pxftxoqzibIBBrLSUli+kYnJqrgBf9cIA=
 github.com/go-stack/stack v1.8.0 h1:5SgMzNM5HxrEjV0ww2lTmX6E2Izsfxas4+YHWRs3Lsk=
 github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
 github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c h1:rp5dCmg/yLR3mgFuSOe4oEnDDmGLROTvMragMUXpTQw=

i2pkeys.go

@@ -2,17 +2,14 @@ package goSam
 
 import (
 	"errors"
-
-	"github.com/eyedeekay/sam3/i2pkeys"
 )
 
 // NewDestination generates a new I2P destination, creating the underlying
 // public/private keys in the process. The public key can be used to send messages
 // to the destination, while the private key can be used to reply to messages
-func (c *Client) NewDestination(sigType ...string) (i2pkeys.I2PKeys, error) {
+func (c *Client) NewDestination(sigType ...string) (string, string, error) {
 	var (
 		sigtmp string
-		keys   i2pkeys.I2PKeys
 	)
 	if len(sigType) > 0 {
 		sigtmp = sigType[0]
@@ -22,14 +19,14 @@ func (c *Client) NewDestination(sigType ...string) (i2pkeys.I2PKeys, error) {
 		sigtmp,
 	)
 	if err != nil {
-		return keys, err
+		return "", "", err
 	}
 	var pub, priv string
 	if priv = r.Pairs["PRIV"]; priv == "" {
-		return keys, errors.New("failed to generate private destination key")
+		return "", "", errors.New("failed to generate private destination key")
 	}
 	if pub = r.Pairs["PUB"]; pub == "" {
-		return keys, errors.New("failed to generate public destination key")
+		return priv, "", errors.New("failed to generate public destination key")
 	}
-	return i2pkeys.NewKeys(i2pkeys.I2PAddr(pub), priv), nil
+	return priv, pub, nil
 }

naming.go

@@ -17,7 +17,7 @@ func (c *Client) Lookup(name string) (string, error) {
 
 	// TODO: move check into sendCmd()
 	if r.Topic != "NAMING" || r.Type != "REPLY" {
-		return "", fmt.Errorf("Naming Unknown Reply: %+v\n", r)
+		return "", fmt.Errorf("Naming Unknown Reply: %s, %s\n", r.Topic, r.Type)
 	}
 
 	result := r.Pairs["RESULT"]
@@ -37,37 +37,39 @@ func (c *Client) Lookup(name string) (string, error) {
 }
 
 func (c *Client) forward(client, conn net.Conn) {
+	defer client.Close()
+	defer conn.Close()
 	go func() {
-		defer client.Close()
+		//		defer client.Close()
-		defer conn.Close()
+		//		defer conn.Close()
 		io.Copy(client, conn)
 	}()
 	go func() {
-		defer client.Close()
+		//		defer client.Close()
-		defer conn.Close()
+		//		defer conn.Close()
 		io.Copy(conn, client)
 	}()
 }
 
 func (c *Client) Resolve(ctx context.Context, name string) (context.Context, net.IP, error) {
-	if c.lastaddr == "invalid" || c.lastaddr != name {
+	//	if c.lastaddr == "invalid" || c.lastaddr != name {
-		client, err := c.DialContext(ctx, "", name)
+	client, err := c.DialContext(ctx, "", name)
-		if err != nil {
+	if err != nil {
-			return ctx, nil, err
+		return ctx, nil, err
-		}
-		ln, err := net.Listen("tcp", "127.0.0.1:")
-		if err != nil {
-			return ctx, nil, err
-		}
-		go func() {
-			for {
-				conn, err := ln.Accept()
-				if err != nil {
-					fmt.Println(err.Error())
-				}
-				go c.forward(client, conn)
-			}
-		}()
 	}
+	ln, err := net.Listen("tcp", "127.0.0.1:")
+	if err != nil {
+		return ctx, nil, err
+	}
+	go func() {
+		for {
+			conn, err := ln.Accept()
+			if err != nil {
+				fmt.Println(err.Error())
+			}
+			go c.forward(client, conn)
+		}
+	}()
+	//	}
 	return ctx, nil, nil
 }

naming_test.go

@@ -10,8 +10,10 @@ import (
 func TestClientLookupInvalid(t *testing.T) {
 	var err error
 
-	setup(t)
+	client, err := NewClientFromOptions(SetDebug(false))
-	defer teardown(t)
+	if err != nil {
+		t.Fatalf("NewDefaultClient() Error: %q\n", err)
+	}
 
 	addr, err := client.Lookup(`!(@#)`)
 	if addr != "" || err == nil {
@@ -25,6 +27,9 @@ func TestClientLookupInvalid(t *testing.T) {
 	if repErr.Result != ResultKeyNotFound {
 		t.Errorf("client.Lookup() should throw an ResultKeyNotFound error.\nGot:%+v%s%s\n", repErr, "!=", ResultKeyNotFound)
 	}
+	if err := client.Close(); err != nil {
+		t.Fatalf("client.Close() Error: %q\n", err)
+	}
 }
 
 func TestClientLookupValid(t *testing.T) {

options.go

@@ -62,6 +62,32 @@ func SetHost(s string) func(*Client) error {
 	}
 }
 
+func SetSAMMinVersion(i int) func(*Client) error {
+	return func(c *Client) error {
+		if i < 0 {
+			return fmt.Errorf("SAM version must be greater than or equal to 0")
+		}
+		if i > 3 {
+			return fmt.Errorf("SAM version must be less than or equal to 3")
+		}
+		c.sammin = i
+		return nil
+	}
+}
+
+func SetSAMMaxVersion(i int) func(*Client) error {
+	return func(c *Client) error {
+		if i < 0 {
+			return fmt.Errorf("SAM version must be greater than or equal to 0")
+		}
+		if i > 3 {
+			return fmt.Errorf("SAM version must be less than or equal to 3")
+		}
+		c.sammin = i
+		return nil
+	}
+}
+
 //SetLocalDestination sets the local destination of the tunnel from a private
 //key
 func SetLocalDestination(s string) func(*Client) error {
@@ -71,13 +97,6 @@ func SetLocalDestination(s string) func(*Client) error {
 	}
 }
 
-func setlastaddr(s string) func(*Client) error {
-	return func(c *Client) error {
-		c.lastaddr = s
-		return nil
-	}
-}
-
 func setid(s int32) func(*Client) error {
 	return func(c *Client) error {
 		c.id = s

options_test.go

@@ -2,8 +2,6 @@
 
 package goSam
 
-/*
-
 import (
 	"fmt"
 	"math"
@@ -33,12 +31,12 @@ func (c *Client) validCmd(str string, args ...interface{}) (string, error) {
 
 func (c *Client) validCreate() (string, error) {
 	id := rand.Int31n(math.MaxInt32)
-	result, err := c.validCmd("SESSION CREATE STYLE=STREAM ID=%d DESTINATION=%s %s\n", id, "abc.i2p", client.allOptions())
+	result, err := c.validCmd("SESSION CREATE STYLE=STREAM ID=%d DESTINATION=%s %s\n", id, "abc.i2p", c.allOptions())
 	return result, err
 }
 
 func TestOptionAddrString(t *testing.T) {
-	client, err := NewClientFromOptions(SetAddr("127.0.0.1:7656"), SetDebug(true))
+	client, err := NewClientFromOptions(SetAddr("127.0.0.1:7656"), SetDebug(false))
 	if err != nil {
 		t.Fatalf("NewClientFromOptions() Error: %q\n", err)
 	}
@@ -47,17 +45,17 @@ func TestOptionAddrString(t *testing.T) {
 	} else {
 		t.Log(result)
 	}
-	dest, _ := client.CreateStreamSession(client.NewID(), "")
+	_, err = client.CreateStreamSession("")
 	if err := client.Close(); err != nil {
 		t.Fatalf("client.Close() Error: %q\n", err)
 	}
-	fmt.Printf("\t destination- %s \n", dest)
+	/*	fmt.Printf("\t destination- %s \n", dest)
-	fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionAddrStringLh(t *testing.T) {
-	client, err := NewClientFromOptions(SetAddr("localhost:7656"), SetDebug(true))
+	client, err := NewClientFromOptions(SetAddr("localhost:7656"), SetDebug(false))
 	if err != nil {
 		t.Fatalf("NewClientFromOptions() Error: %q\n", err)
 	}
@@ -66,17 +64,17 @@ func TestOptionAddrStringLh(t *testing.T) {
 	} else {
 		t.Log(result)
 	}
-	dest, _ := client.CreateStreamSession(client.NewID(), "")
+	_, err = client.CreateStreamSession("")
 	if err := client.Close(); err != nil {
 		t.Fatalf("client.Close() Error: %q\n", err)
 	}
-	fmt.Printf("\t destination- %s \n", dest)
+	/*	fmt.Printf("\t destination- %s \n", dest)
-	fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionAddrSlice(t *testing.T) {
-	client, err := NewClientFromOptions(SetAddr("127.0.0.1", "7656"), SetDebug(true))
+	client, err := NewClientFromOptions(SetAddr("127.0.0.1", "7656"), SetDebug(false))
 	if err != nil {
 		t.Fatalf("NewClientFromOptions() Error: %q\n", err)
 	}
@@ -85,17 +83,17 @@ func TestOptionAddrSlice(t *testing.T) {
 	} else {
 		t.Log(result)
 	}
-	dest, _ := client.CreateStreamSession(client.NewID(), "")
+	_, err = client.CreateStreamSession("")
 	if err := client.Close(); err != nil {
 		t.Fatalf("client.Close() Error: %q\n", err)
 	}
-	fmt.Printf("\t destination- %s \n", dest)
+	/*	fmt.Printf("\t destination- %s \n", dest)
-	fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionAddrMixedSlice(t *testing.T) {
-	client, err := NewClientFromOptions(SetAddrMixed("127.0.0.1", 7656), SetDebug(true))
+	client, err := NewClientFromOptions(SetAddrMixed("127.0.0.1", 7656), SetDebug(false))
 	if err != nil {
 		t.Fatalf("NewClientFromOptions() Error: %q\n", err)
 	}
@@ -104,13 +102,13 @@ func TestOptionAddrMixedSlice(t *testing.T) {
 	} else {
 		t.Log(result)
 	}
-	dest, _ := client.CreateStreamSession(client.NewID(), "")
+	_, err = client.CreateStreamSession("")
 	if err := client.Close(); err != nil {
 		t.Fatalf("client.Close() Error: %q\n", err)
 	}
-	fmt.Printf("\t destination- %s \n", dest)
+	/*	fmt.Printf("\t destination- %s \n", dest)
-	fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionHost(t *testing.T) {
@@ -126,7 +124,7 @@ func TestOptionHost(t *testing.T) {
 		SetInBackups(2),
 		SetOutBackups(2),
 		SetEncrypt(true),
-		SetDebug(true),
+		SetDebug(false),
 		SetUnpublished(true),
 		SetReduceIdle(true),
 		SetReduceIdleTime(300001),
@@ -142,13 +140,13 @@ func TestOptionHost(t *testing.T) {
 	} else {
 		t.Log(result)
 	}
-	dest, _ := client.CreateStreamSession(client.NewID(), "")
+	_, err = client.CreateStreamSession("")
 	if err := client.Close(); err != nil {
 		t.Fatalf("client.Close() Error: %q\n", err)
 	}
-	fmt.Printf("\t destination- %s \n", dest)
+	/*	fmt.Printf("\t destination- %s \n", dest)
-	fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionPortInt(t *testing.T) {
@@ -164,7 +162,7 @@ func TestOptionPortInt(t *testing.T) {
 		SetInBackups(2),
 		SetOutBackups(2),
 		SetEncrypt(true),
-		SetDebug(true),
+		SetDebug(false),
 		SetUnpublished(true),
 		SetReduceIdle(true),
 		SetReduceIdleTime(300001),
@@ -180,12 +178,11 @@ func TestOptionPortInt(t *testing.T) {
 	} else {
 		t.Log(result)
 	}
-	dest, _ := client.CreateStreamSession(client.NewID(), "")
+	_, err = client.CreateStreamSession("")
 	if err := client.Close(); err != nil {
 		t.Fatalf("client.Close() Error: %q\n", err)
 	}
-	fmt.Printf("\t destination- %s \n", dest)
+	/*	fmt.Printf("\t destination- %s \n", dest)
-	fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
-*/

raw.go

@@ -0,0 +1 @@
+package goSam

replyParser.go

@@ -44,6 +44,25 @@ func parseReply(line string) (*Reply, error) {
 	if len(parts) < 3 {
 		return nil, fmt.Errorf("Malformed Reply.\n%s\n", line)
 	}
+	preParseReply := func() []string {
+		val := ""
+		quote := false
+		for _, v := range parts {
+			if strings.Contains(v, "=\"") {
+				quote = true
+			}
+			if strings.Contains(v, "\"\n") || strings.Contains(v, "\" ") {
+				quote = false
+			}
+			if quote {
+				val += v + "_"
+			} else {
+				val += v + " "
+			}
+		}
+		return strings.Split(strings.TrimSuffix(strings.TrimSpace(val), "_"), " ")
+	}
+	parts = preParseReply()
 
 	r := &Reply{
 		Topic: parts[0],
@@ -63,9 +82,8 @@ func parseReply(line string) (*Reply, error) {
 		} else {
 			kvPair := strings.SplitN(v, "=", 2)
 			if kvPair != nil {
-				if len(kvPair) == 1 {
+				if len(kvPair) != 2 {
-				} else if len(kvPair) != 2 {
+					return nil, fmt.Errorf("Malformed key-value-pair len != 2.\n%s\n", kvPair)
-					return nil, fmt.Errorf("Malformed key-value-pair.\n%s\n", kvPair)
 				}
 			}
 			r.Pairs[kvPair[0]] = kvPair[len(kvPair)-1]

sessions.go

@@ -11,16 +11,17 @@ func init() {
 	rand.Seed(time.Now().UnixNano())
 }
 
-// CreateStreamSession creates a new STREAM Session.
+// CreateSession creates a new STREAM Session.
 // Returns the Id for the new Client.
-func (c *Client) CreateStreamSession(id int32, dest string) (string, error) {
+func (c *Client) CreateSession(style, dest string) (string, error) {
 	if dest == "" {
 		dest = "TRANSIENT"
 	}
-	c.id = id
+	//	c.id = id
 	r, err := c.sendCmd(
-		"SESSION CREATE STYLE=STREAM ID=%d DESTINATION=%s %s %s %s %s \n",
+		"SESSION CREATE STYLE=%s ID=%s DESTINATION=%s %s %s %s %s \n",
-		c.id,
+		style,
+		c.ID(),
 		dest,
 		c.from(),
 		c.to(),
@@ -43,3 +44,21 @@ func (c *Client) CreateStreamSession(id int32, dest string) (string, error) {
 	c.destination = r.Pairs["DESTINATION"]
 	return c.destination, nil
 }
+
+// CreateStreamSession creates a new STREAM Session.
+// Returns the Id for the new Client.
+func (c *Client) CreateStreamSession(dest string) (string, error) {
+	return c.CreateSession("STREAM", dest)
+}
+
+// CreateDatagramSession creates a new DATAGRAM Session.
+// Returns the Id for the new Client.
+func (c *Client) CreateDatagramSession(dest string) (string, error) {
+	return c.CreateSession("DATAGRAM", dest)
+}
+
+// CreateRawSession creates a new RAW Session.
+// Returns the Id for the new Client.
+func (c *Client) CreateRawSession(dest string) (string, error) {
+	return c.CreateSession("RAW", dest)
+}

stream.go

@@ -5,8 +5,11 @@ import (
 )
 
 // StreamConnect asks SAM for a TCP-Like connection to dest, has to be called on a new Client
-func (c *Client) StreamConnect(id int32, dest string) error {
+func (c *Client) StreamConnect(dest string) error {
-	r, err := c.sendCmd("STREAM CONNECT ID=%d DESTINATION=%s %s %s\n", id, dest, c.from(), c.to())
+	if dest == "" {
+		return nil
+	}
+	r, err := c.sendCmd("STREAM CONNECT ID=%s DESTINATION=%s %s %s\n", c.ID(), dest, c.from(), c.to())
 	if err != nil {
 		return err
 	}
@@ -25,8 +28,8 @@ func (c *Client) StreamConnect(id int32, dest string) error {
 }
 
 // StreamAccept asks SAM to accept a TCP-Like connection
-func (c *Client) StreamAccept(id int32) (*Reply, error) {
+func (c *Client) StreamAccept() (*Reply, error) {
-	r, err := c.sendCmd("STREAM ACCEPT ID=%d SILENT=false\n", id)
+	r, err := c.sendCmd("STREAM ACCEPT ID=%s SILENT=false\n", c.ID())
 	if err != nil {
 		return nil, err
 	}