Fix issue where the control socket should not be used as a streamsession

Don't rely on sam3 for key generation. Cleanup API issues. Improve Stability. Begin to add DG, RAW support.

Makefile

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

accept.go

@@ -24,25 +24,25 @@ 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(c.id, dest)
-	d := c.destination
+	c.destination, err = c.CreateStreamSession(dest)
 	if err != nil {
 		return nil, err
 	}
-	fmt.Println("Listening on destination:", c.Base32()+".b32.i2p")
 
-	c, err = c.NewClient(c.id)
-	if err != nil {
-		return nil, err
+	if c.d == nil {
+		c.d, err = c.NewClient(c.NewID())
+		if err != nil {
+			return nil, err
+		}
 	}
-	c.destination = d
+
+	fmt.Println("Listening on destination:", c.Base32()+".b32.i2p")
 
 	if c.debug {
 		c.SamConn = WrapConn(c.SamConn)
 	}
 
-	return c, nil
+	return c.d, nil
 }
 
 // Accept accepts a connection on a listening goSam.Client(Implements net.Listener)
@@ -52,7 +52,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,8 +11,10 @@ import (
 	"math/rand"
 	"net"
 	"strings"
-	//	"sync"
+	"sync"
 	"time"
+
+	samkeys "github.com/eyedeekay/goSam/compat"
 )
 
 // A Client represents a single Connection to the SAM bridge
@@ -22,8 +24,10 @@ type Client struct {
 	fromport string
 	toport   string
 
-	SamConn net.Conn
-	rd      *bufio.Reader
+	SamConn   net.Conn     // Control socket
+	SamDGConn DatagramConn // Datagram socket
+	rd        *bufio.Reader
+	d         *Client
 
 	sigType     string
 	destination string
@@ -52,12 +56,14 @@ type Client struct {
 	compression bool
 
 	debug bool
+	mutex sync.Mutex
 	//NEVER, EVER modify lastaddr or id yourself. They are used internally only.
 	id     int32
 	sammin int
 	sammax int
 }
 
+// SAMsigTypes is a slice of the available signature types
 var SAMsigTypes = []string{
 	"SIGNATURE_TYPE=DSA_SHA1",
 	"SIGNATURE_TYPE=ECDSA_SHA256_P256",
@@ -91,6 +97,7 @@ func NewClient(addr string) (*Client, error) {
 func (c *Client) NewID() int32 {
 	if c.id == 0 {
 		c.id = rand.Int31n(math.MaxInt32)
+		fmt.Printf("Initializing new ID: %d\n", c.id)
 	}
 	return c.id
 }
@@ -176,12 +183,22 @@ func NewClientFromOptions(opts ...func(*Client) error) (*Client, error) {
 	return &c, c.hello()
 }
 
+// ID returns a the current ID of the client as a string
 func (p *Client) ID() string {
-	return fmt.Sprintf("%d", p.id)
+	return fmt.Sprintf("%d", p.NewID())
 }
 
+// Addr returns the address of the client as a net.Addr
 func (p *Client) Addr() net.Addr {
-	return nil
+	keys, err := samkeys.DestToKeys(p.Destination())
+	if err != nil {
+		return nil
+	}
+	return keys.Addr()
+}
+
+func (p *Client) LocalAddr() net.Addr {
+	return p.Addr()
 }
 
 //return the combined host:port of the SAM bridge

client_test.go

@@ -1,3 +1,4 @@
+//go:build nettest
 // +build nettest
 
 package goSam
@@ -6,6 +7,8 @@ import "testing"
 
 import (
 	"fmt"
+	"math"
+	"math/rand"
 	"time"
 	//"log"
 	"net/http"
@@ -18,48 +21,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(true))
 	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 +62,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(true))
+	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)
-	t.Log(client.Base32())
-	if _, err := client.NewDestination(SAMsigTypes[3]); err != nil {
-		t.Error(err)
+	client, err := NewClientFromOptions(SetDebug(true))
+	if err != nil {
+		t.Fatalf("NewDefaultClient() Error: %q\n", 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)
 }

conn.go

@@ -30,11 +30,14 @@ import (
 	"time"
 )
 
+// Conn Read data from the connection, writes data to te connection
+// and logs the data in-between.
 type Conn struct {
 	RWC
 	conn net.Conn
 }
 
+// WrapConn wraps a net.Conn in a Conn.
 func WrapConn(c net.Conn) *Conn {
 	wrap := Conn{
 		conn: c,
@@ -45,23 +48,29 @@ func WrapConn(c net.Conn) *Conn {
 	return &wrap
 }
 
+// LocalAddr returns the local address of the connection.
 func (c *Conn) LocalAddr() net.Addr {
 	return c.conn.LocalAddr()
 }
 
+// RemoteAddr returns the remote address of the connection.
 func (c *Conn) RemoteAddr() net.Addr {
 	return c.conn.RemoteAddr()
 }
 
+// SetDeadline sets the read and write deadlines associated with the connection
 func (c *Conn) SetDeadline(t time.Time) error {
 	log.Println("WARNING: SetDeadline() not sure this works")
 	return c.conn.SetDeadline(t)
 }
 
+// SetReadDeadline sets the read deadline associated with the connection
 func (c *Conn) SetReadDeadline(t time.Time) error {
 	log.Println("WARNING: SetReadDeadline() not sure this works")
 	return c.conn.SetReadDeadline(t)
 }
+
+// SetWriteDeadline sets the write deadline associated with the connection
 func (c *Conn) SetWriteDeadline(t time.Time) error {
 	log.Println("WARNING: SetWriteDeadline() not sure this works")
 	return c.conn.SetWriteDeadline(t)

datagram.go

@@ -0,0 +1,26 @@
+package goSam
+
+import (
+	"net"
+	"time"
+)
+
+// DatagramConn
+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
+}
+
+/**
+var conn DatagramConn = &Client{}
+
+
+*/

dial.go

@@ -2,6 +2,7 @@ package goSam
 
 import (
 	"context"
+	"fmt"
 	"log"
 	"net"
 	"strings"
@@ -9,6 +10,8 @@ import (
 
 // 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.mutex.Lock()
+	defer c.mutex.Unlock()
 	errCh := make(chan error, 1)
 	connCh := make(chan net.Conn, 1)
 	go func() {
@@ -29,6 +32,7 @@ func (c *Client) DialContext(ctx context.Context, network, addr string) (net.Con
 	case <-ctx.Done():
 		return nil, ctx.Err()
 	}
+
 }
 
 func (c *Client) Dial(network, addr string) (net.Conn, error) {
@@ -37,6 +41,25 @@ func (c *Client) Dial(network, addr string) (net.Conn, error) {
 
 // Dial implements the net.Dial function and can be used for http.Transport
 func (c *Client) DialContextFree(network, addr string) (net.Conn, error) {
+	if network == "tcp" || network == "tcp6" || network == "tcp4" {
+		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)
+}
+
+// DialDatagramContextFree is a "Dialer" for "Client-Like" Datagram connections.
+// It is also not finished. If you need datagram support right now, use sam3.
+func (c *Client) DialDatagramContextFree(addr string) (DatagramConn, error) {
+	return nil, fmt.Errorf("Datagram support is not finished yet, come back later`")
+}
+
+func (c *Client) DialStreamingContextFree(addr string) (net.Conn, error) {
 	portIdx := strings.Index(addr, ":")
 	if portIdx >= 0 {
 		addr = addr[:portIdx]
@@ -47,36 +70,22 @@ func (c *Client) DialContextFree(network, addr string) (net.Conn, error) {
 		return nil, err
 	}
 
-	c.destination, err = c.CreateStreamSession(c.id, c.destination)
-	if err != nil {
-		c.Close()
-		d, err := c.NewClient(c.id + 1) /**/
+	if c.destination == "" {
+		c.destination, err = c.CreateStreamSession(c.destination)
 		if err != nil {
 			return nil, err
 		}
-		d.destination, err = d.CreateStreamSession(d.id, c.destination)
-		if err != nil {
-			return nil, err
-		}
-		d, err = d.NewClient(d.id)
-		if err != nil {
-			return nil, err
-		}
-		//	  d.lastaddr = addr
-		err = d.StreamConnect(d.id, addr)
-		if err != nil {
-			return nil, err
-		}
-		c = d
-		return d.SamConn, nil
 	}
-	c, err = c.NewClient(c.id)
+	if c.d == nil {
+		c.d, err = c.NewClient(c.NewID())
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	err = c.d.StreamConnect(addr)
 	if err != nil {
 		return nil, err
 	}
-	err = c.StreamConnect(c.id, addr)
-	if err != nil {
-		return nil, err
-	}
-	return c.SamConn, nil
+	return c.d.SamConn, nil
 }

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"]

naming_test.go

@@ -1,3 +1,4 @@
+//go:build nettest
 // +build nettest
 
 package goSam
@@ -10,8 +11,10 @@ import (
 func TestClientLookupInvalid(t *testing.T) {
 	var err error
 
-	setup(t)
-	defer teardown(t)
+	client, err := NewClientFromOptions(SetDebug(true))
+	if err != nil {
+		t.Fatalf("NewDefaultClient() Error: %q\n", err)
+	}
 
 	addr, err := client.Lookup(`!(@#)`)
 	if addr != "" || err == nil {
@@ -25,6 +28,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_test.go

@@ -1,3 +1,4 @@
+//go:build nettest
 // +build nettest
 
 package goSam
@@ -31,7 +32,7 @@ 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
 }
 
@@ -45,13 +46,13 @@ 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 address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+	/*	fmt.Printf("\t destination- %s \n", dest)
+		fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionAddrStringLh(t *testing.T) {
@@ -64,13 +65,13 @@ 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 address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+	/*	fmt.Printf("\t destination- %s \n", dest)
+		fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionAddrSlice(t *testing.T) {
@@ -83,13 +84,13 @@ 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 address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+	/*	fmt.Printf("\t destination- %s \n", dest)
+		fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionAddrMixedSlice(t *testing.T) {
@@ -102,13 +103,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 address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+	/*	fmt.Printf("\t destination- %s \n", dest)
+		fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionHost(t *testing.T) {
@@ -140,13 +141,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 address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+	/*	fmt.Printf("\t destination- %s \n", dest)
+		fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }
 
 func TestOptionPortInt(t *testing.T) {
@@ -178,11 +179,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 address64- %s \t", client.Base64())
-	fmt.Printf("\t address- %s \t", client.Base32())
+	/*	fmt.Printf("\t destination- %s \n", dest)
+		fmt.Printf("\t address64- %s \t", client.Base64())
+		fmt.Printf("\t address- %s \t", client.Base32())*/
 }

raw.go

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

sessions.go

@@ -11,16 +11,18 @@ func init() {
 	rand.Seed(time.Now().UnixNano())
 }
 
-// CreateStreamSession creates a new STREAM Session.
-// Returns the Id for the new Client.
-func (c *Client) CreateStreamSession(id int32, dest string) (string, error) {
+// CreateSession creates a new Session of type style, with an optional destination.
+// an empty destination is interpreted as "TRANSIENT"
+// Returns the destination for the new Client or an 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",
-		c.id,
+		"SESSION CREATE STYLE=%s ID=%s DESTINATION=%s %s %s %s %s \n",
+		style,
+		c.ID(),
 		dest,
 		c.from(),
 		c.to(),
@@ -43,3 +45,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,11 +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 {
 	if dest == "" {
 		return nil
 	}
-	r, err := c.sendCmd("STREAM CONNECT ID=%d DESTINATION=%s %s %s\n", id, dest, c.from(), c.to())
+	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
 	}
@@ -28,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) {
-	r, err := c.sendCmd("STREAM ACCEPT ID=%d SILENT=false\n", id)
+func (c *Client) StreamAccept() (*Reply, error) {
+	r, err := c.sendCmd("STREAM ACCEPT ID=%s SILENT=false\n", c.ID())
 	if err != nil {
 		return nil, err
 	}