Disable datagram support in the dialer function until it's ready, so I can cut a release tonight.

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

.gitignore

@@ -22,3 +22,5 @@ _testmain.go
 *.exe
 itp-golang-github-eyedeekay-gosam.txt
 .pc
+deb/
+samsocks/samsocks

Makefile

@@ -0,0 +1,27 @@
+
+USER_GH=eyedeekay
+VERSION=0.32.4
+packagename=gosam
+
+echo: fmt
+	@echo "type make version to do release $(VERSION)"
+
+version:
+	gothub release -s $(GITHUB_TOKEN) -u $(USER_GH) -r $(packagename) -t v$(VERSION) -d "version $(VERSION)"
+
+del:
+	gothub delete -s $(GITHUB_TOKEN) -u $(USER_GH) -r $(packagename) -t v$(VERSION)
+
+tar:
+	tar --exclude .git \
+		--exclude .go \
+		--exclude bin \
+		--exclude examples \
+		-cJvf ../$(packagename)_$(VERSION).orig.tar.xz .
+
+link:
+	rm -f ../goSam
+	ln -sf . ../goSam
+
+fmt:
+	gofmt -w -s *.go */*.go

README.md

@@ -3,10 +3,10 @@ goSam
 
 A go library for using the [I2P](https://geti2p.net/en/) Simple Anonymous
 Messaging ([SAM version 3.0](https://geti2p.net/en/docs/api/samv3)) bridge. It
-has support for SAM version 3.1 signature types.
+has support for all streaming features SAM version 3.2.
 
-This is in an **early development stage**. I would love to hear about any
-issues or ideas for improvement.
+This is widely used and easy to use, but thusfar, mostly by me. It sees a lot of
+testing and no breaking changes to the API are expected.
 
 ## Installation
 ```
@@ -15,7 +15,7 @@ go get github.com/eyedeekay/goSam
 
 ## Using it for HTTP Transport
 
-I implemented `Client.Dial` like `net.Dial` so you can use go's library packages like http.
+`Client.Dial` implements `net.Dial` so you can use go's library packages like http.
 
 ```go
 package main
@@ -70,6 +70,52 @@ func checkErr(err error) {
 }
 ```
 
+## Using it as a SOCKS proxy
+
+`client` also implements a resolver compatible with
+[`getlantern/go-socks5`](https://github.com/getlantern/go-socks5),
+making it very easy to implement a SOCKS5 server.
+
+```go
+package main
+
+import (
+  "flag"
+
+	"github.com/eyedeekay/goSam"
+	"github.com/getlantern/go-socks5"
+	"log"
+)
+
+var (
+  samaddr = flag.String("sam", "127.0.0.1:7656", "SAM API address to use")
+  socksaddr = flag.String("socks", "127.0.0.1:7675", "SOCKS address to use")
+)
+
+func main() {
+	sam, err := goSam.NewClient(*samaddr)
+	if err != nil {
+		panic(err)
+	}
+	log.Println("Client Created")
+
+	// create a transport that uses SAM to dial TCP Connections
+	conf := &socks5.Config{
+		Dial:     sam.DialContext,
+		Resolver: sam,
+	}
+	server, err := socks5.New(conf)
+	if err != nil {
+		panic(err)
+	}
+
+	// Create SOCKS5 proxy on localhost port 8000
+	if err := server.ListenAndServe("tcp", *socksaddr); err != nil {
+		panic(err)
+	}
+}
+```
+
 ### .deb package
 
 A package for installing this on Debian is buildable, and a version for Ubuntu
@@ -85,7 +131,10 @@ to produce an unsigned deb for personal use only. For packagers,
 
 will produce a viable source package for use with Launchpad PPA's and other
 similar systems.
+
 ### TODO
 
-* Implement `STREAM ACCEPT` and `STREAM FORWARD`
+* Improve recovery on failed sockets
+* Implement `STREAM FORWARD`
 * Implement datagrams (Repliable and Anon)
+

accept.go

@@ -24,19 +24,11 @@ func (c *Client) Listen() (net.Listener, error) {
 // with Accept
 func (c *Client) ListenI2P(dest string) (net.Listener, error) {
 	var err error
-	var id int32
-	c.id = c.NewID()
-	c.destination, err = c.CreateStreamSession(id, dest)
-	if err != nil {
-		return nil, err
-	}
-
-	fmt.Println("destination:", c.destination)
-
-	c, err = c.NewClient()
+	c.destination, err = c.CreateStreamSession(dest)
 	if err != nil {
 		return nil, err
 	}
+	fmt.Println("Listening on destination:", c.Base32()+".b32.i2p")
 
 	if c.debug {
 		c.SamConn = WrapConn(c.SamConn)
@@ -52,7 +44,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,6 +11,10 @@ import (
 	"math/rand"
 	"net"
 	"strings"
+	"sync"
+	"time"
+
+	samkeys "github.com/eyedeekay/goSam/compat"
 )
 
 // A Client represents a single Connection to the SAM bridge
@@ -20,8 +24,9 @@ type Client struct {
 	fromport string
 	toport   string
 
-	SamConn net.Conn
-	rd      *bufio.Reader
+	SamConn   net.Conn
+	SamDGConn DatagramConn
+	rd        *bufio.Reader
 
 	sigType     string
 	destination string
@@ -38,6 +43,7 @@ type Client struct {
 
 	dontPublishLease bool
 	encryptLease     bool
+	leaseSetEncType  string
 
 	reduceIdle         bool
 	reduceIdleTime     uint
@@ -49,11 +55,14 @@ type Client struct {
 	compression bool
 
 	debug bool
+	mutex sync.Mutex
 	//NEVER, EVER modify lastaddr or id yourself. They are used internally only.
-	lastaddr string
-	id       int32
+	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",
@@ -62,6 +71,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")
@@ -79,7 +94,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
@@ -89,13 +108,17 @@ func (c *Client) Destination() string {
 
 // Base32 returns the base32 of the local tunnel
 func (c *Client) Base32() string {
-	hash := sha256.New()
+	//	hash := sha256.New()
 	b64, err := i2pB64enc.DecodeString(c.Base64())
 	if err != nil {
 		return ""
 	}
-	hash.Write([]byte(b64))
-	return strings.ToLower(strings.Replace(i2pB32enc.EncodeToString(hash.Sum(nil)), "=", "", -1))
+	//hash.Write([]byte(b64))
+	var s []byte
+	for _, e := range sha256.Sum256(b64) {
+		s = append(s, e)
+	}
+	return strings.ToLower(strings.Replace(i2pB32enc.EncodeToString(s), "=", "", -1))
 }
 
 func (c *Client) base64() []byte {
@@ -119,11 +142,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
@@ -135,14 +158,19 @@ func NewClientFromOptions(opts ...func(*Client) error) (*Client, error) {
 	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
 	}
@@ -154,12 +182,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
@@ -169,13 +207,13 @@ 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
 	}
 
 	if r.Topic != "HELLO" {
-		return fmt.Errorf("Unknown Reply: %+v\n", r)
+		return fmt.Errorf("Client Hello Unknown Reply: %+v\n", r)
 	}
 
 	if r.Pairs["RESULT"] != "OK" {
@@ -205,8 +243,10 @@ func (c *Client) Close() error {
 	return c.SamConn.Close()
 }
 
-// NewClient generates an exact copy of the client with the same options
-func (c *Client) NewClient() (*Client, error) {
+// NewClient generates an exact copy of the client with the same options, but
+// 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),
@@ -227,7 +267,6 @@ func (c *Client) NewClient() (*Client, error) {
 		SetCloseIdle(c.closeIdle),
 		SetCloseIdleTime(c.closeIdleTime),
 		SetCompression(c.compression),
-		setlastaddr(c.lastaddr),
-		setid(c.id),
+		setid(id),
 	)
 }

client_test.go

@@ -1,29 +1,111 @@
+//go:build nettest
 // +build nettest
 
 package goSam
 
 import "testing"
 
-var client *Client
+import (
+	"fmt"
+	"math"
+	"math/rand"
+	"time"
+	//"log"
+	"net/http"
 
-func setup(t *testing.T) {
-	var err error
+	"github.com/eyedeekay/sam3/helper"
+	"github.com/eyedeekay/sam3/i2pkeys"
+)
 
-	// these tests expect a running SAM brige on this address
-	client, err = NewClientFromOptions(SetDebug(true))
+func HelloServer(w http.ResponseWriter, r *http.Request) {
+	fmt.Fprintf(w, "Hello, %s!", r.URL.Path[1:])
+}
+
+func TestCompositeClient(t *testing.T) {
+	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("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("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)
+
+	sam, err := NewClientFromOptions(SetDebug(true))
 	if err != nil {
 		t.Fatalf("NewDefaultClient() Error: %q\n", err)
 	}
+	tr := &http.Transport{
+		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())
+		if err != nil {
+			t.Fatalf("Get Error: %q\n", err)
+		}
+		defer resp.Body.Close()
+	}()
+	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()
+	}()
+	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()
+	}()
+
+	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)
+func TestNewDestination(t *testing.T) {
+	client, err := NewClientFromOptions(SetDebug(true))
+	if err != nil {
+		t.Fatalf("NewDefaultClient() Error: %q\n", err)
+	}
 	t.Log(client.Base32())
-	teardown(t)
+	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)
+	}
 }

conn.go

@@ -0,0 +1,77 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014 Henry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+package goSam
+
+import (
+	"log"
+	"net"
+	"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,
+	}
+	wrap.Reader = NewReadLogger("<", c)
+	wrap.Writer = NewWriteLogger(">", c)
+	wrap.RWC.c = c
+	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{}
+
+
+*/

debian/changelog

@@ -1,8 +1,60 @@
+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:40 -0500
+
+golang-github-eyedeekay-gosam (0.32.28) UNRELEASED; urgency=medium
+
+  * Maintenance updates
+
+ -- idk <hankhill19580@gmail.com>  Thu, 12 Sept 2020 22:44:27 -0500
+
+golang-github-eyedeekay-gosam (0.32.27) UNRELEASED; urgency=medium
+
+  * Add a Resolve function to fulfill SOCKS5 proxy requirements
+
+ -- idk <hankhill19580@gmail.com>  Sun, 13 Sept 2020 04:48:27 -0500
+
+golang-github-eyedeekay-gosam (0.32.26) UNRELEASED; urgency=medium
+
+  * Fix mistaken-identity issue with listeners
+
+ -- idk <hankhill19580@gmail.com>  Thu, 03 Sept 2020 08:17:40 -0500
+
+golang-github-eyedeekay-gosam (0.32.25) UNRELEASED; urgency=medium
+
+  * Support dual-keys by default in all future versions
+
+ -- idk <hankhill19580@gmail.com>  Thu, 03 Sept 2020 04:25:04 -0500
+
+golang-github-eyedeekay-gosam (0.32.24) UNRELEASED; urgency=medium
+
+  * Improve the mutex thingy
+
+ -- idk <hankhill19580@gmail.com>  Tue, 25 Aug 2020 04:52:11 -0500
+  
+golang-github-eyedeekay-gosam (0.32.23) UNRELEASED; urgency=medium
+
+  * Protect Dial with a mutex to fix a lookup bug
+
+ -- idk <hankhill19580@gmail.com>  Tue, 25 Aug 2020 10:29:26 -0500
+
 golang-github-eyedeekay-gosam (0.3.2.1) bionic; urgency=medium
 
   * Get rid of the debug directory, just move it into the source
+  * Get rid of the old example, just use the one in the README
 
- -- idk <hankhill19580@gmail.com>  Fri, 18 May 2019 18:12:21 -0500
+ -- idk <hankhill19580@gmail.com>  Sat, 08 Dec 2019 19:11:41 -0500
 
 golang-github-eyedeekay-gosam (0.3.2.0) bionic; urgency=medium
 

debian/control

@@ -6,7 +6,8 @@ Uploaders: idk <hankhill19580@gmail.com>
 Build-Depends: debhelper (>= 11),
                dh-golang,
                golang-any,
-               i2pd | i2p
+               i2pd | i2p,
+               git,
 Standards-Version: 4.2.1
 Homepage: https://github.com/eyedeekay/gosam
 Vcs-Browser: https:/github.com/eyedeekay/gosam

dial.go

@@ -3,19 +3,23 @@ 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.mutex.Lock()
+	defer c.mutex.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 {
-			conn.Close()
+			log.Println(ctx)
+			errCh <- ctx.Err()
 		} else {
 			connCh <- conn
 		}
@@ -28,41 +32,52 @@ func (c *Client) DialContext(ctx context.Context, network, addr string) (net.Con
 	case <-ctx.Done():
 		return nil, ctx.Err()
 	}
+
 }
 
-func (c Client) dialCheck(addr string) (int32, bool) {
-	if c.lastaddr == "invalid" {
-		fmt.Println("Preparing to dial new address.")
-		return c.NewID(), true
-	}
-	return c.id, false
+func (c *Client) Dial(network, addr string) (net.Conn, error) {
+	return c.DialContext(context.TODO(), network, addr)
 }
 
 // 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) {
+	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]
 	}
 	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.id, test = c.dialCheck(addr); test == true {
-		c.destination, err = c.CreateStreamSession(c.id, c.destination)
+	if c.destination == "" {
+		c.destination, err = c.CreateStreamSession(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)
+	err = c.StreamConnect(addr)
 	if err != nil {
 		return nil, err
 	}

example/httpTest.go

@@ -1,53 +0,0 @@
-package main
-
-import (
-	"io"
-	"log"
-	"net/http"
-	"os"
-
-	"github.com/eyedeekay/goSam"
-)
-
-func main() {
-	//In order to enable debugging, pass the SetDebug(true) option.
-	//sam, err := goSam.NewClientFromOptions(SetDebug(true))
-
-	// create a default sam client
-	sam, err := goSam.NewDefaultClient()
-	checkErr(err)
-
-	log.Println("Client Created")
-
-	// create a transport that uses SAM to dial TCP Connections
-	tr := &http.Transport{
-		Dial: sam.Dial,
-	}
-
-	// create  a client using this transport
-	client := &http.Client{Transport: tr}
-
-	// send a get request
-	resp, err := client.Get("http://stats.i2p/")
-	checkErr(err)
-	defer resp.Body.Close()
-
-	log.Printf("Get returned %+v\n", resp)
-
-	// create a file for the response
-	file, err := os.Create("stats.html")
-	checkErr(err)
-	defer file.Close()
-
-	// copy the response to the file
-	_, err = io.Copy(file, resp.Body)
-	checkErr(err)
-
-	log.Println("Done.")
-}
-
-func checkErr(err error) {
-	if err != nil {
-		log.Fatal(err)
-	}
-}

go.mod

@@ -1,11 +1,17 @@
 module github.com/eyedeekay/goSam
 
-require github.com/eyedeekay/sam3 v0.32.2
+require (
+	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 ./
 
-replace github.com/eyedeekay/gosam v0.1.1-0.20190814195658-27e786578944 => ./
+replace github.com/eyedeekay/gosam v0.32.1 => ./
 
-replace github.com/eyedeekay/goSam v0.1.0 => ./
+replace github.com/eyedeekay/goSam v0.32.1 => ./
 
 go 1.13

go.sum

@@ -0,0 +1,35 @@
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/eyedeekay/ramp v0.0.0-20190429201811-305b382042ab h1:EfTRHxGSbiaEyxNzvKRBWVIDw3mD8xXGxj4gvwFzY7Q=
+github.com/eyedeekay/ramp v0.0.0-20190429201811-305b382042ab/go.mod h1:h7mvUAMgZ/rtRDUOkvKTK+8LnDMeUhJSoa5EPdB51fc=
+github.com/eyedeekay/sam3 v0.32.2 h1:xODDY5nBVg0oK7KaYk7ofkXFoHPsmI1umhSv1TZlS7s=
+github.com/eyedeekay/sam3 v0.32.2/go.mod h1:Y3igFVzN4ybqkkpfUWULGhw7WRp8lieq0ORXbLBbcZM=
+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=
+github.com/getlantern/errors v1.0.1/go.mod h1:l+xpFBrCtDLpK9qNjxs+cHU6+BAdlBaxHqikB6Lku3A=
+github.com/getlantern/go-socks5 v0.0.0-20171114193258-79d4dd3e2db5 h1:RBKofGGMt2k6eGBwX8mky9qunjL+KnAp9JdzXjiRkRw=
+github.com/getlantern/go-socks5 v0.0.0-20171114193258-79d4dd3e2db5/go.mod h1:kGHRXch95rnGLHjER/GhhFiHvfnqNz7KqWD9kGfATHY=
+github.com/getlantern/golog v0.0.0-20201105130739-9586b8bde3a9 h1:8MYJU90rB1bsavemKSAuDKBjtAKo5xq95bEPOnzV7CE=
+github.com/getlantern/golog v0.0.0-20201105130739-9586b8bde3a9/go.mod h1:ZyIjgH/1wTCl+B+7yH1DqrWp6MPJqESmwmEQ89ZfhvA=
+github.com/getlantern/hex v0.0.0-20190417191902-c6586a6fe0b7 h1:micT5vkcr9tOVk1FiH8SWKID8ultN44Z+yzd2y/Vyb0=
+github.com/getlantern/hex v0.0.0-20190417191902-c6586a6fe0b7/go.mod h1:dD3CgOrwlzca8ed61CsZouQS5h5jIzkK9ZWrTcf0s+o=
+github.com/getlantern/hidden v0.0.0-20190325191715-f02dbb02be55 h1:XYzSdCbkzOC0FDNrgJqGRo8PCMFOBFL9py72DRs7bmc=
+github.com/getlantern/hidden v0.0.0-20190325191715-f02dbb02be55/go.mod h1:6mmzY2kW1TOOrVy+r41Za2MxXM+hhqTtY3oBKd2AgFA=
+github.com/getlantern/netx v0.0.0-20190110220209-9912de6f94fd h1:mn98vs69Kqw56iKhR82mjk16Q1q5aDFFW0E89/QbXkQ=
+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=
+github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c/go.mod h1:X07ZCGwUbLaax7L0S3Tw4hpejzu63ZrrQiUe6W0hcy0=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=

i2pkeys.go

@@ -0,0 +1,32 @@
+package goSam
+
+import (
+	"errors"
+)
+
+// 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) (string, string, error) {
+	var (
+		sigtmp string
+	)
+	if len(sigType) > 0 {
+		sigtmp = sigType[0]
+	}
+	r, err := c.sendCmd(
+		"DEST GENERATE %s\n",
+		sigtmp,
+	)
+	if err != nil {
+		return "", "", err
+	}
+	var pub, priv string
+	if priv = r.Pairs["PRIV"]; priv == "" {
+		return "", "", errors.New("failed to generate private destination key")
+	}
+	if pub = r.Pairs["PUB"]; pub == "" {
+		return priv, "", errors.New("failed to generate public destination key")
+	}
+	return priv, pub, nil
+}

naming.go

@@ -1,7 +1,10 @@
 package goSam
 
 import (
+	"context"
 	"fmt"
+	"io"
+	"net"
 	"os"
 )
 
@@ -14,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("Unknown Reply: %+v\n", r)
+		return "", fmt.Errorf("Naming Unknown Reply: %s, %s\n", r.Topic, r.Type)
 	}
 
 	result := r.Pairs["RESULT"]
@@ -32,3 +35,41 @@ func (c *Client) Lookup(name string) (string, error) {
 
 	return r.Pairs["VALUE"], nil
 }
+
+func (c *Client) forward(client, conn net.Conn) {
+	defer client.Close()
+	defer conn.Close()
+	go func() {
+		//		defer client.Close()
+		//		defer conn.Close()
+		io.Copy(client, conn)
+	}()
+	go func() {
+		//		defer client.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 {
+	client, err := c.DialContext(ctx, "", name)
+	if err != nil {
+		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)
+		}
+	}()
+	//	}
+	return ctx, nil, nil
+}

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 {
@@ -22,12 +25,15 @@ func TestClientLookupInvalid(t *testing.T) {
 	if !ok {
 		t.Fatalf("client.Lookup() should return a ReplyError")
 	}
-	if repErr.Result != ResultInvalidKey {
-		t.Errorf("client.Lookup() should throw an ResultKeyNotFound error.\nGot:%+v\n", repErr)
+	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 ExampleClient_Lookup() {
+func TestClientLookupValid(t *testing.T) {
 	client, err := NewDefaultClient()
 	if err != nil {
 		fmt.Printf("NewDefaultClient() should not throw an error.\n%s\n", err)
@@ -40,11 +46,17 @@ func ExampleClient_Lookup() {
 		return
 	}
 
+	if addr == `GKapJ8koUcBj~jmQzHsTYxDg2tpfWj0xjQTzd8BhfC9c3OS5fwPBNajgF-eOD6eCjFTqTlorlh7Hnd8kXj1qblUGXT-tDoR9~YV8dmXl51cJn9MVTRrEqRWSJVXbUUz9t5Po6Xa247Vr0sJn27R4KoKP8QVj1GuH6dB3b6wTPbOamC3dkO18vkQkfZWUdRMDXk0d8AdjB0E0864nOT~J9Fpnd2pQE5uoFT6P0DqtQR2jsFvf9ME61aqLvKPPWpkgdn4z6Zkm-NJOcDz2Nv8Si7hli94E9SghMYRsdjU-knObKvxiagn84FIwcOpepxuG~kFXdD5NfsH0v6Uri3usE3XWD7Pw6P8qVYF39jUIq4OiNMwPnNYzy2N4mDMQdsdHO3LUVh~DEppOy9AAmEoHDjjJxt2BFBbGxfdpZCpENkwvmZeYUyNCCzASqTOOlNzdpne8cuesn3NDXIpNnqEE6Oe5Qm5YOJykrX~Vx~cFFT3QzDGkIjjxlFBsjUJyYkFjBQAEAAcAAA==` {
+		t.Log("Success")
+	} else {
+		t.Errorf("Address of zzz.i2p != \nGKapJ8koUcBj~jmQzHsTYxDg2tpfWj0xjQTzd8BhfC9c3OS5fwPBNajgF-eOD6eCjFTqTlorlh7Hnd8kXj1qblUGXT-tDoR9~YV8dmXl51cJn9MVTRrEqRWSJVXbUUz9t5Po6Xa247Vr0sJn27R4KoKP8QVj1GuH6dB3b6wTPbOamC3dkO18vkQkfZWUdRMDXk0d8AdjB0E0864nOT~J9Fpnd2pQE5uoFT6P0DqtQR2jsFvf9ME61aqLvKPPWpkgdn4z6Zkm-NJOcDz2Nv8Si7hli94E9SghMYRsdjU-knObKvxiagn84FIwcOpepxuG~kFXdD5NfsH0v6Uri3usE3XWD7Pw6P8qVYF39jUIq4OiNMwPnNYzy2N4mDMQdsdHO3LUVh~DEppOy9AAmEoHDjjJxt2BFBbGxfdpZCpENkwvmZeYUyNCCzASqTOOlNzdpne8cuesn3NDXIpNnqEE6Oe5Qm5YOJykrX~Vx~cFFT3QzDGkIjjxlFBsjUJyYkFjBQAEAAcAAA==\n, check to see if it changed, %s", addr)
+	}
+
 	fmt.Println("Address of zzz.i2p:")
 	// Addresses change all the time
 	fmt.Println(addr)
 
 	// Output:
 	//Address of zzz.i2p:
-	//GKapJ8koUcBj~jmQzHsTYxDg2tpfWj0xjQTzd8BhfC9c3OS5fwPBNajgF-eOD6eCjFTqTlorlh7Hnd8kXj1qblUGXT-tDoR9~YV8dmXl51cJn9MVTRrEqRWSJVXbUUz9t5Po6Xa247Vr0sJn27R4KoKP8QVj1GuH6dB3b6wTPbOamC3dkO18vkQkfZWUdRMDXk0d8AdjB0E0864nOT~J9Fpnd2pQE5uoFT6P0DqtQR2jsFvf9ME61aqLvKPPWpkgdn4z6Zkm-NJOcDz2Nv8Si7hli94E9SghMYRsdjU-knObKvxiagn84FIwcOpepxuG~kFXdD5NfsH0v6Uri3usE3uSzpWS0EHmrlfoLr5uGGd9ZHwwCIcgfOATaPRMUEQxiK9q48PS0V3EXXO4-YLT0vIfk4xO~XqZpn8~PW1kFe2mQMHd7oO89yCk-3yizRG3UyFtI7-mO~eCI6-m1spYoigStgoupnC3G85gJkqEjMm49gUjbhfWKWI-6NwTj0ZnAAAA
+	//
 }

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
@@ -275,6 +294,15 @@ func SetEncrypt(b bool) func(*Client) error {
 	}
 }
 
+//SetLeaseSetEncType tells the router to use an encrypted leaseset of a specific type.
+//defaults to 4,0
+func SetLeaseSetEncType(b string) func(*Client) error {
+	return func(c *Client) error {
+		c.leaseSetEncType = b
+		return nil
+	}
+}
+
 //SetReduceIdle sets the created tunnels to be reduced during extended idle time to avoid excessive resource usage
 func SetReduceIdle(b bool) func(*Client) error {
 	return func(c *Client) error {
@@ -360,6 +388,12 @@ func SetSignatureType(s string) func(*Client) error {
 
 //return the from port as a string.
 func (c *Client) from() string {
+	if c.fromport == "FROM_PORT=0" {
+		return ""
+	}
+	if c.fromport == "0" {
+		return ""
+	}
 	if c.fromport == "" {
 		return ""
 	}
@@ -368,6 +402,12 @@ func (c *Client) from() string {
 
 //return the to port as a string.
 func (c *Client) to() string {
+	if c.fromport == "TO_PORT=0" {
+		return ""
+	}
+	if c.fromport == "0" {
+		return ""
+	}
 	if c.toport == "" {
 		return ""
 	}
@@ -426,6 +466,13 @@ func (c *Client) encryptlease() string {
 	return " i2cp.encryptLeaseSet=false "
 }
 
+func (c *Client) leasesetenctype() string {
+	if c.encryptLease {
+		return fmt.Sprintf(" i2cp.leaseSetEncType=%s ", c.leaseSetEncType)
+	}
+	return " i2cp.leaseSetEncType=4,0 "
+}
+
 func (c *Client) dontpublishlease() string {
 	if c.dontPublishLease {
 		return " i2cp.dontPublishLeaseSet=true "
@@ -478,6 +525,7 @@ func (c *Client) allOptions() string {
 		c.outbackups() +
 		c.dontpublishlease() +
 		c.encryptlease() +
+		c.leasesetenctype() +
 		c.reduceonidle() +
 		c.reduceidletime() +
 		c.reduceidlecount() +
@@ -498,6 +546,7 @@ func (c *Client) Print() string {
 		c.outbackups() +
 		c.dontpublishlease() +
 		c.encryptlease() +
+		c.leasesetenctype() +
 		c.reduceonidle() +
 		c.reduceidletime() +
 		c.reduceidlecount() +

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

replyParser.go

@@ -32,6 +32,8 @@ func (r ReplyError) Error() string {
 type Reply struct {
 	Topic string
 	Type  string
+	From  string
+	To    string
 
 	Pairs map[string]string
 }
@@ -42,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],
@@ -50,14 +71,23 @@ func parseReply(line string) (*Reply, error) {
 	}
 
 	for _, v := range parts[2:] {
-		kvPair := strings.SplitN(v, "=", 2)
-		if kvPair != nil {
-			if len(kvPair) != 2 {
-				return nil, fmt.Errorf("Malformed key-value-pair.\n%s\n", kvPair)
+		if strings.Contains(v, "FROM_PORT") {
+			if v != "FROM_PORT=0" {
+				r.From = v
 			}
+		} else if strings.Contains(v, "TO_PORT") {
+			if v != "TO_PORT=0" {
+				r.To = v
+			}
+		} else {
+			kvPair := strings.SplitN(v, "=", 2)
+			if kvPair != nil {
+				if len(kvPair) != 2 {
+					return nil, fmt.Errorf("Malformed key-value-pair len != 2.\n%s\n", kvPair)
+				}
+			}
+			r.Pairs[kvPair[0]] = kvPair[len(kvPair)-1]
 		}
-
-		r.Pairs[kvPair[0]] = kvPair[len(kvPair)-1]
 	}
 
 	return r, nil

rw.go

@@ -0,0 +1,101 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014 Henry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+package goSam
+
+import (
+	"encoding/hex"
+	"io"
+	"log"
+)
+
+/*
+Copy of testing/iotest Read- and WriteLogger, but using %q instead of %x for printing
+*/
+
+type writeLogger struct {
+	prefix string
+	w      io.Writer
+}
+
+func (l *writeLogger) Write(p []byte) (n int, err error) {
+	n, err = l.w.Write(p)
+	if err != nil {
+		log.Printf("%s %q: %v", l.prefix, string(p[0:n]), err)
+	} else {
+		log.Printf("%s %q", l.prefix, string(p[0:n]))
+	}
+	return
+}
+
+// NewWriteLogger returns a writer that behaves like w except
+// that it logs (using log.Printf) each write to standard error,
+// printing the prefix and the hexadecimal data written.
+func NewWriteLogger(prefix string, w io.Writer) io.Writer {
+	return &writeLogger{prefix, w}
+}
+
+type readLogger struct {
+	prefix string
+	r      io.Reader
+}
+
+func (l *readLogger) Read(p []byte) (n int, err error) {
+	n, err = l.r.Read(p)
+	if err != nil {
+		log.Printf("%s %q: %v", l.prefix, string(p[0:n]), err)
+	} else {
+		log.Printf("%s %q", l.prefix, string(p[0:n]))
+	}
+	return
+}
+
+// NewReadLogger returns a reader that behaves like r except
+// that it logs (using log.Print) each read to standard error,
+// printing the prefix and the hexadecimal data written.
+func NewReadLogger(prefix string, r io.Reader) io.Reader {
+	return &readLogger{prefix, r}
+}
+
+type readHexLogger struct {
+	prefix string
+	r      io.Reader
+}
+
+func (l *readHexLogger) Read(p []byte) (n int, err error) {
+	n, err = l.r.Read(p)
+	if err != nil {
+		log.Printf("%s (%d bytes) Error: %v", l.prefix, n, err)
+	} else {
+		log.Printf("%s (%d bytes)", l.prefix, n)
+	}
+	log.Print("\n" + hex.Dump(p[:n]))
+	return
+}
+
+// NewReadHexLogger returns a reader that behaves like r except
+// that it logs to stderr using ecoding/hex.
+func NewReadHexLogger(prefix string, r io.Reader) io.Reader {
+	return &readHexLogger{prefix, r}
+}

rwc.go

@@ -0,0 +1,80 @@
+/*
+The MIT License (MIT)
+
+Copyright (c) 2014 Henry
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+*/
+
+package goSam
+
+import (
+	"io"
+	//"github.com/miolini/datacounter"
+)
+
+type RWC struct {
+	io.Reader
+	io.Writer
+	c io.Closer
+}
+
+func WrapRWC(c io.ReadWriteCloser) io.ReadWriteCloser {
+	rl := NewReadLogger("<", c)
+	wl := NewWriteLogger(">", c)
+
+	return &RWC{
+		Reader: rl,
+		Writer: wl,
+		c:      c,
+	}
+}
+
+func (c *RWC) Close() error {
+	return c.c.Close()
+}
+
+/*
+type Counter struct {
+	io.Reader
+	io.Writer
+	c io.Closer
+
+	Cr *datacounter.ReaderCounter
+	Cw *datacounter.WriterCounter
+}
+
+func WrapCounter(c io.ReadWriteCloser) *Counter {
+	rc := datacounter.NewReaderCounter(c)
+	wc := datacounter.NewWriterCounter(c)
+
+	return &Counter{
+		Reader: rc,
+		Writer: wc,
+		c:      c,
+
+		Cr: rc,
+		Cw: wc,
+	}
+}
+
+func (c *Counter) Close() error {
+	return c.c.Close()
+}
+*/

samsocks/main.go

@@ -0,0 +1,37 @@
+package main
+
+import (
+	"flag"
+
+	"github.com/eyedeekay/goSam"
+	"github.com/getlantern/go-socks5"
+	"log"
+)
+
+var (
+	samaddr   = flag.String("sam", "127.0.0.1:7656", "SAM API address to use")
+	socksaddr = flag.String("socks", "127.0.0.1:7675", "SOCKS address to use")
+)
+
+func main() {
+	sam, err := goSam.NewClient(*samaddr)
+	if err != nil {
+		panic(err)
+	}
+	log.Println("Client Created")
+
+	// create a transport that uses SAM to dial TCP Connections
+	conf := &socks5.Config{
+		Dial:     sam.DialContext,
+		Resolver: sam,
+	}
+	server, err := socks5.New(conf)
+	if err != nil {
+		panic(err)
+	}
+
+	// Create SOCKS5 proxy on localhost port 8000
+	if err := server.ListenAndServe("tcp", *socksaddr); err != nil {
+		panic(err)
+	}
+}

sessions.go

@@ -11,19 +11,21 @@ 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 %s %s DESTINATION=%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(),
-		dest,
 		c.sigtype(),
 		c.allOptions(),
 	)
@@ -33,7 +35,7 @@ func (c *Client) CreateStreamSession(id int32, dest string) (string, error) {
 
 	// TODO: move check into sendCmd()
 	if r.Topic != "SESSION" || r.Type != "STATUS" {
-		return "", fmt.Errorf("Unknown Reply: %+v\n", r)
+		return "", fmt.Errorf("Session Unknown Reply: %+v\n", r)
 	}
 
 	result := r.Pairs["RESULT"]
@@ -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,15 +5,18 @@ 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 {
-	r, err := c.sendCmd("STREAM CONNECT ID=%d %s %s DESTINATION=%s\n", id, c.from(), c.to(), dest)
+func (c *Client) StreamConnect(dest string) error {
+	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
 	}
 
 	// TODO: move check into sendCmd()
 	if r.Topic != "STREAM" || r.Type != "STATUS" {
-		return fmt.Errorf("Unknown Reply: %+v\n", r)
+		return fmt.Errorf("Stream Connect Unknown Reply: %+v\n", r)
 	}
 
 	result := r.Pairs["RESULT"]
@@ -25,15 +28,15 @@ 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
 	}
 
 	// TODO: move check into sendCmd()
 	if r.Topic != "STREAM" || r.Type != "STATUS" {
-		return nil, fmt.Errorf("Unknown Reply: %+v\n", r)
+		return nil, fmt.Errorf("Stream Accept Unknown Reply: %+v\n", r)
 	}
 
 	result := r.Pairs["RESULT"]