tolerate FROM_PORT and TO_PORT on datagrams

go fmt
use more retainable configs
2019-04-29 17:04:13 -04:00 · 2019-04-29 16:17:24 -04:00 · 2019-04-29 16:16:24 -04:00 · 2019-04-29 11:47:38 -04:00 · 2019-04-29 11:10:25 -04:00 · 2019-04-20 14:53:50 -04:00
25 changed files with 153 additions and 2394 deletions
--- a/29
+++ b/29
@@ -1,29 +0,0 @@
-
-USER_GH=eyedeekay
-VERSION=0.33.001
-packagename=sam3
-
-echo:
-	@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 \
-		-cJvf ../$(packagename)_$(VERSION).orig.tar.xz .
-
-copier:
-	echo '#! /usr/bin/env sh' > deb/copy.sh
-	echo 'for f in $$(ls); do scp $$f/*.deb user@192.168.99.106:~/DEBIAN_PKGS/$$f/main/; done' >> deb/copy.sh
-
-fmt:
-	find . -name '*.go' -exec gofmt -w -s {} \;
-
-upload-linux:
-	gothub upload -R -u $(USER_GH) -r "$(packagename)" -t $(VERSION) -l `sha256sum ` -n "$(packagename)" -f "$(packagename)"
--- a/README.md
+++ b/README.md
@@ -57,8 +57,6 @@ func client(server I2PAddr) {
 func main() {
 	sam, _ := NewSAM(yoursam)
 	keys, _ := sam.NewKeys()
-	stream, _ := sam.NewStreamSession("serverTun", keys, Options_Medium)
-	listener, _ := stream.Listen()
 	go client(keys.Addr())
 	stream, _ := sam.NewStreamSession("serverTun", keys, Options_Medium)
 	listener, _ := stream.Listen()
@@ -80,7 +78,7 @@ Error handling was omitted in the above code for readability.

 ## Testing ##

-* `go test -tags=nettest` runs the whole suite (takes 90+ sec to perform!)
+* `go test` runs the whole suite (takes 90+ sec to perform!)
 * `go test -short` runs the shorter variant, does not connect to anything

 ## License ##
@@ -90,6 +88,4 @@ Public domain.
 ## Author ##

 * Kalle Vedin `kalle.vedin@fripost.org`
-* Unknown Name (majestrate)
-* idk
-* qiwenmin
+* Unknown Name (majestrate)
--- a/SAMConn.go
+++ b/SAMConn.go
@@ -1,20 +1,18 @@
 package sam3

 import (
-	"github.com/eyedeekay/sam3/i2pkeys"
 	"net"
 	"time"
 )

-/*
 import (
 	. "github.com/eyedeekay/sam3/i2pkeys"
 )
-*/
+
 // Implements net.Conn
 type SAMConn struct {
-	laddr i2pkeys.I2PAddr
-	raddr i2pkeys.I2PAddr
+	laddr I2PAddr
+	raddr I2PAddr
 	conn  net.Conn
 }

@@ -40,7 +38,7 @@ func (sc *SAMConn) LocalAddr() net.Addr {
 }

 // Implements net.Conn
-func (sc *SAMConn) localAddr() i2pkeys.I2PAddr {
+func (sc *SAMConn) localAddr() I2PAddr {
 	return sc.laddr
 }

@@ -49,7 +47,7 @@ func (sc *SAMConn) RemoteAddr() net.Addr {
 }

 // Implements net.Conn
-func (sc *SAMConn) remoteAddr() i2pkeys.I2PAddr {
+func (sc *SAMConn) remoteAddr() I2PAddr {
 	return sc.raddr
 }

--- a/config.go
+++ b/config.go
@@ -2,301 +2,15 @@ package sam3

 import (
 	"fmt"
-	"math/rand"
 	"net"
 	"strconv"
-	"strings"
-
-	"github.com/eyedeekay/sam3/i2pkeys"
 )

-// I2PConfig is a struct which manages I2P configuration options
-type I2PConfig struct {
-	SamHost string
-	SamPort string
-	TunName string
+import (
+	. "github.com/eyedeekay/sam3/i2pkeys"
+)

-	SamMin string
-	SamMax string
-
-	Fromport string
-	Toport   string
-
-	Style   string
-	TunType string
-
-	DestinationKeys i2pkeys.I2PKeys
-
-	SigType                   string
-	EncryptLeaseSet           string
-	LeaseSetKey               string
-	LeaseSetPrivateKey        string
-	LeaseSetPrivateSigningKey string
-	LeaseSetKeys              i2pkeys.I2PKeys
-	InAllowZeroHop            string
-	OutAllowZeroHop           string
-	InLength                  string
-	OutLength                 string
-	InQuantity                string
-	OutQuantity               string
-	InVariance                string
-	OutVariance               string
-	InBackupQuantity          string
-	OutBackupQuantity         string
-	FastRecieve               string
-	UseCompression            string
-	MessageReliability        string
-	CloseIdle                 string
-	CloseIdleTime             string
-	ReduceIdle                string
-	ReduceIdleTime            string
-	ReduceIdleQuantity        string
-	//Streaming Library options
-	AccessListType string
-	AccessList     []string
-}
-
-func (f *I2PConfig) Sam() string {
-	host := "127.0.0.1"
-	port := "7656"
-	if f.SamHost != "" {
-		host = f.SamHost
-	}
-	if f.SamPort != "" {
-		port = f.SamPort
-	}
-	return host + ":" + port
-}
-
-func (f *I2PConfig) SetSAMAddress(addr string) {
-	hp := strings.Split(addr, ":")
-	if len(hp) == 1 {
-		f.SamHost = hp[0]
-	} else if len(hp) == 2 {
-		f.SamPort = hp[1]
-		f.SamHost = hp[0]
-	}
-	f.SamPort = "7656"
-	f.SamHost = "127.0.0.1"
-}
-
-func (f *I2PConfig) ID() string {
-	if f.TunName == "" {
-		b := make([]byte, 12)
-		for i := range b {
-			b[i] = "abcdefghijklmnopqrstuvwxyz"[rand.Intn(len("abcdefghijklmnopqrstuvwxyz"))]
-		}
-		f.TunName = string(b)
-	}
-	return " ID=" + f.TunName + " "
-}
-
-func (f *I2PConfig) Leasesetsettings() (string, string, string) {
-	var r, s, t string
-	if f.LeaseSetKey != "" {
-		r = " i2cp.leaseSetKey=" + f.LeaseSetKey + " "
-	}
-	if f.LeaseSetPrivateKey != "" {
-		s = " i2cp.leaseSetPrivateKey=" + f.LeaseSetPrivateKey + " "
-	}
-	if f.LeaseSetPrivateSigningKey != "" {
-		t = " i2cp.leaseSetPrivateSigningKey=" + f.LeaseSetPrivateSigningKey + " "
-	}
-	return r, s, t
-}
-
-func (f *I2PConfig) FromPort() string {
-	if f.samMax() < 3.1 {
-		return ""
-	}
-	if f.Fromport != "0" {
-		return " FROM_PORT=" + f.Fromport + " "
-	}
-	return ""
-}
-
-func (f *I2PConfig) ToPort() string {
-	if f.samMax() < 3.1 {
-		return ""
-	}
-	if f.Toport != "0" {
-		return " TO_PORT=" + f.Toport + " "
-	}
-	return ""
-}
-
-func (f *I2PConfig) SessionStyle() string {
-	if f.Style != "" {
-		return " STYLE=" + f.Style + " "
-	}
-	return " STYLE=STREAM "
-}
-
-func (f *I2PConfig) samMax() float64 {
-	i, err := strconv.Atoi(f.SamMax)
-	if err != nil {
-		return 3.1
-	}
-	return float64(i)
-}
-
-func (f *I2PConfig) MinSAM() string {
-	if f.SamMin == "" {
-		return "3.0"
-	}
-	return f.SamMin
-}
-
-func (f *I2PConfig) MaxSAM() string {
-	if f.SamMax == "" {
-		return "3.1"
-	}
-	return f.SamMax
-}
-
-func (f *I2PConfig) DestinationKey() string {
-	if &f.DestinationKeys != nil {
-		return " DESTINATION=" + f.DestinationKeys.String() + " "
-	}
-	return " DESTINATION=TRANSIENT "
-}
-
-func (f *I2PConfig) SignatureType() string {
-	if f.samMax() < 3.1 {
-		return ""
-	}
-	if f.SigType != "" {
-		return " SIGNATURE_TYPE=" + f.SigType + " "
-	}
-	return ""
-}
-
-func (f *I2PConfig) EncryptLease() string {
-	if f.EncryptLeaseSet == "true" {
-		return " i2cp.encryptLeaseSet=true "
-	}
-	return ""
-}
-
-func (f *I2PConfig) Reliability() string {
-	if f.MessageReliability != "" {
-		return " i2cp.messageReliability=" + f.MessageReliability + " "
-	}
-	return ""
-}
-
-func (f *I2PConfig) Reduce() string {
-	if f.ReduceIdle == "true" {
-		return "i2cp.reduceOnIdle=" + f.ReduceIdle + "i2cp.reduceIdleTime=" + f.ReduceIdleTime + "i2cp.reduceQuantity=" + f.ReduceIdleQuantity
-	}
-	return ""
-}
-
-func (f *I2PConfig) Close() string {
-	if f.CloseIdle == "true" {
-		return "i2cp.closeOnIdle=" + f.CloseIdle + "i2cp.closeIdleTime=" + f.CloseIdleTime
-	}
-	return ""
-}
-
-func (f *I2PConfig) DoZero() string {
-	r := ""
-	if f.InAllowZeroHop == "true" {
-		r += " inbound.allowZeroHop=" + f.InAllowZeroHop + " "
-	}
-	if f.OutAllowZeroHop == "true" {
-		r += " outbound.allowZeroHop= " + f.OutAllowZeroHop + " "
-	}
-	if f.FastRecieve == "true" {
-		r += " " + f.FastRecieve + " "
-	}
-	return r
-}
-func (f *I2PConfig) Print() []string {
-	lsk, lspk, lspsk := f.Leasesetsettings()
-	return []string{
-		//f.targetForPort443(),
-		"inbound.length=" + f.InLength,
-		"outbound.length=" + f.OutLength,
-		"inbound.lengthVariance=" + f.InVariance,
-		"outbound.lengthVariance=" + f.OutVariance,
-		"inbound.backupQuantity=" + f.InBackupQuantity,
-		"outbound.backupQuantity=" + f.OutBackupQuantity,
-		"inbound.quantity=" + f.InQuantity,
-		"outbound.quantity=" + f.OutQuantity,
-		f.DoZero(),
-		//"i2cp.fastRecieve=" + f.FastRecieve,
-		"i2cp.gzip=" + f.UseCompression,
-		f.Reduce(),
-		f.Close(),
-		f.Reliability(),
-		f.EncryptLease(),
-		lsk, lspk, lspsk,
-		f.Accesslisttype(),
-		f.Accesslist(),
-	}
-}
-
-func (f *I2PConfig) Accesslisttype() string {
-	if f.AccessListType == "whitelist" {
-		return "i2cp.enableAccessList=true"
-	} else if f.AccessListType == "blacklist" {
-		return "i2cp.enableBlackList=true"
-	} else if f.AccessListType == "none" {
-		return ""
-	}
-	return ""
-}
-
-func (f *I2PConfig) Accesslist() string {
-	if f.AccessListType != "" && len(f.AccessList) > 0 {
-		r := ""
-		for _, s := range f.AccessList {
-			r += s + ","
-		}
-		return "i2cp.accessList=" + strings.TrimSuffix(r, ",")
-	}
-	return ""
-}
-
-func NewConfig(opts ...func(*I2PConfig) error) (*I2PConfig, error) {
-	var config I2PConfig
-	config.SamHost = "127.0.0.1"
-	config.SamPort = "7656"
-	config.SamMin = "3.0"
-	config.SamMax = "3.2"
-	config.TunName = ""
-	config.TunType = "server"
-	config.Style = "STREAM"
-	config.InLength = "3"
-	config.OutLength = "3"
-	config.InQuantity = "2"
-	config.OutQuantity = "2"
-	config.InVariance = "1"
-	config.OutVariance = "1"
-	config.InBackupQuantity = "3"
-	config.OutBackupQuantity = "3"
-	config.InAllowZeroHop = "false"
-	config.OutAllowZeroHop = "false"
-	config.EncryptLeaseSet = "false"
-	config.LeaseSetKey = ""
-	config.LeaseSetPrivateKey = ""
-	config.LeaseSetPrivateSigningKey = ""
-	config.FastRecieve = "false"
-	config.UseCompression = "true"
-	config.ReduceIdle = "false"
-	config.ReduceIdleTime = "15"
-	config.ReduceIdleQuantity = "4"
-	config.CloseIdle = "false"
-	config.CloseIdleTime = "300000"
-	config.MessageReliability = "none"
-	for _, o := range opts {
-		if err := o(&config); err != nil {
-			return nil, err
-		}
-	}
-	return &config, nil
-}
+// sam config

 // options map
 type Options map[string]string
@@ -324,7 +38,7 @@ func (cfg *Config) StreamSession() (session *StreamSession, err error) {
 	s, err = NewSAM(cfg.Addr)
 	if err == nil {
 		// ensure keys exist
-		var keys i2pkeys.I2PKeys
+		var keys I2PKeys
 		keys, err = s.EnsureKeyfile(cfg.Keyfile)
 		if err == nil {
 			// create session
@@ -341,7 +55,7 @@ func (cfg *Config) DatagramSession() (session *DatagramSession, err error) {
 	s, err = NewSAM(cfg.Addr)
 	if err == nil {
 		// ensure keys exist
-		var keys i2pkeys.I2PKeys
+		var keys I2PKeys
 		keys, err = s.EnsureKeyfile(cfg.Keyfile)
 		if err == nil {
 			// determine udp port
--- a/datagram.go
+++ b/datagram.go
@@ -6,8 +6,10 @@ import (
 	"net"
 	"strconv"
 	"time"
+)

-	"github.com/eyedeekay/sam3/i2pkeys"
+import (
+	. "github.com/eyedeekay/sam3/i2pkeys"
 )

 // The DatagramSession implements net.PacketConn. It works almost like ordinary
@@ -15,25 +17,24 @@ import (
 // also end-to-end encrypted, signed and includes replay-protection. And they
 // are also built to be surveillance-resistant (yey!).
 type DatagramSession struct {
-	samAddr    string           // address to the sam bridge (ipv4:port)
-	id         string           // tunnel name
-	conn       net.Conn         // connection to sam bridge
-	udpconn    *net.UDPConn     // used to deliver datagrams
-	keys       i2pkeys.I2PKeys  // i2p destination keys
-	rUDPAddr   *net.UDPAddr     // the SAM bridge UDP-port
-	remoteAddr *i2pkeys.I2PAddr // optional remote I2P address
+	samAddr  string       // address to the sam bridge (ipv4:port)
+	id       string       // tunnel name
+	conn     net.Conn     // connection to sam bridge
+	udpconn  *net.UDPConn // used to deliver datagrams
+	keys     I2PKeys      // i2p destination keys
+	rUDPAddr *net.UDPAddr // the SAM bridge UDP-port
 }

 // Creates a new datagram session. udpPort is the UDP port SAM is listening on,
 // and if you set it to zero, it will use SAMs standard UDP port.
-func (s *SAM) NewDatagramSession(id string, keys i2pkeys.I2PKeys, options []string, udpPort int) (*DatagramSession, error) {
+func (s *SAM) NewDatagramSession(id string, keys I2PKeys, options []string, udpPort int) (*DatagramSession, error) {
 	if udpPort > 65335 || udpPort < 0 {
 		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
 	}
 	if udpPort == 0 {
 		udpPort = 7655
 	}
-	lhost, _, err := net.SplitHostPort(s.conn.LocalAddr().String())
+	lhost, _, err := net.SplitHostPort(s.Conn.LocalAddr().String())
 	if err != nil {
 		s.Close()
 		return nil, err
@@ -46,7 +47,7 @@ func (s *SAM) NewDatagramSession(id string, keys i2pkeys.I2PKeys, options []stri
 	if err != nil {
 		return nil, err
 	}
-	rhost, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
+	rhost, _, err := net.SplitHostPort(s.Conn.RemoteAddr().String())
 	if err != nil {
 		s.Close()
 		return nil, err
@@ -60,38 +61,13 @@ func (s *SAM) NewDatagramSession(id string, keys i2pkeys.I2PKeys, options []stri
 	if err != nil {
 		return nil, err
 	}
-	return &DatagramSession{s.address, id, conn, udpconn, keys, rUDPAddr, nil}, nil
+	return &DatagramSession{s.Config.I2PConfig.Sam(), id, conn, udpconn, keys, rUDPAddr}, nil
 }

 func (s *DatagramSession) B32() string {
 	return s.keys.Addr().Base32()
 }

-func (s *DatagramSession) Dial(net string, addr string) (*DatagramSession, error) {
-	netaddr, err := s.Lookup(addr)
-	if err != nil {
-		return nil, err
-	}
-	return s.DialI2PRemote(net, netaddr)
-}
-
-func (s *DatagramSession) DialRemote(net, addr string) (net.PacketConn, error) {
-	netaddr, err := s.Lookup(addr)
-	if err != nil {
-		return nil, err
-	}
-	return s.DialI2PRemote(net, netaddr)
-}
-
-func (s *DatagramSession) DialI2PRemote(net string, addr net.Addr) (*DatagramSession, error) {
-	s.remoteAddr = addr.(*i2pkeys.I2PAddr)
-	return s, nil
-}
-
-func (s *DatagramSession) RemoteAddr() net.Addr {
-	return s.remoteAddr
-}
-
 // Reads one datagram sent to the destination of the DatagramSession. Returns
 // the number of bytes read, from what address it was sent, or an error.
 // implements net.PacketConn
@@ -104,20 +80,20 @@ func (s *DatagramSession) ReadFrom(b []byte) (n int, addr net.Addr, err error) {
 		var saddr *net.UDPAddr
 		n, saddr, err = s.udpconn.ReadFromUDP(buf)
 		if err != nil {
-			return 0, i2pkeys.I2PAddr(""), err
+			return 0, I2PAddr(""), err
 		}
 		if bytes.Equal(saddr.IP, s.rUDPAddr.IP) {
 			continue
 		}
 		break
 	}
-	i := bytes.IndexByte(buf, byte('\n'))
+	i := bytes.IndexByte(buf, byte(' '))
 	if i > 4096 || i > n {
-		return 0, i2pkeys.I2PAddr(""), errors.New("Could not parse incomming message remote address.")
+		return 0, I2PAddr(""), errors.New("Could not parse incomming message remote address.")
 	}
-	raddr, err := i2pkeys.NewI2PAddrFromString(string(buf[:i]))
+	raddr, err := NewI2PAddrFromString(string(buf[:i]))
 	if err != nil {
-		return 0, i2pkeys.I2PAddr(""), errors.New("Could not parse incomming message remote address: " + err.Error())
+		return 0, I2PAddr(""), errors.New("Could not parse incomming message remote address: " + string(buf[:i]) + err.Error())
 	}
 	// shift out the incomming address to contain only the data received
 	if (n - i + 1) > len(b) {
@@ -129,29 +105,16 @@ func (s *DatagramSession) ReadFrom(b []byte) (n int, addr net.Addr, err error) {
 	}
 }

-func (s *DatagramSession) Accept() (net.Conn, error) {
-	return s, nil
-}
-
-func (s *DatagramSession) Read(b []byte) (n int, err error) {
-	rint, _, rerr := s.ReadFrom(b)
-	return rint, rerr
-}
-
 // Sends one signed datagram to the destination specified. At the time of
 // writing, maximum size is 31 kilobyte, but this may change in the future.
 // Implements net.PacketConn.
 func (s *DatagramSession) WriteTo(b []byte, addr net.Addr) (n int, err error) {
-	header := []byte("3.1 " + s.id + " " + addr.String() + "\n")
+	header := []byte("3.0 " + s.id + " " + addr.String() + "\n")
 	msg := append(header, b...)
 	n, err = s.udpconn.WriteToUDP(msg, s.rUDPAddr)
 	return n, err
 }

-func (s *DatagramSession) Write(b []byte) (int, error) {
-	return s.WriteTo(b, s.remoteAddr)
-}
-
 // Closes the DatagramSession. Implements net.PacketConn
 func (s *DatagramSession) Close() error {
 	err := s.conn.Close()
@@ -163,7 +126,7 @@ func (s *DatagramSession) Close() error {
 }

 // Returns the I2P destination of the DatagramSession.
-func (s *DatagramSession) LocalI2PAddr() i2pkeys.I2PAddr {
+func (s *DatagramSession) LocalI2PAddr() I2PAddr {
 	return s.keys.Addr()
 }

@@ -172,10 +135,6 @@ func (s *DatagramSession) LocalAddr() net.Addr {
 	return s.LocalI2PAddr()
 }

-func (s *DatagramSession) Addr() net.Addr {
-	return s.LocalI2PAddr()
-}
-
 func (s *DatagramSession) Lookup(name string) (a net.Addr, err error) {
 	var sam *SAM
 	sam, err = NewSAM(s.samAddr)
@@ -202,7 +161,3 @@ func (s *DatagramSession) SetReadDeadline(t time.Time) error {
 func (s *DatagramSession) SetWriteDeadline(t time.Time) error {
 	return s.udpconn.SetWriteDeadline(t)
 }
-
-func (s *DatagramSession) SetWriteBuffer(bytes int) error {
-	return s.udpconn.SetWriteBuffer(bytes)
-}
--- a/datagram_test.go
+++ b/datagram_test.go
@@ -4,7 +4,6 @@ package sam3

 import (
 	"fmt"
-	"log"
 	"testing"
 	"time"
 )
@@ -28,7 +27,7 @@ func Test_DatagramServerClient(t *testing.T) {
 	}
 	//	fmt.Println("\tServer: My address: " + keys.Addr().Base32())
 	fmt.Println("\tServer: Creating tunnel")
-	ds, err := sam.NewDatagramSession("DGserverTun", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"}, 0)
+	ds, err := sam.NewDatagramSession("DGserverTun", keys, []string{"inbound.length=1", "outbound.length=1", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"}, 0)
 	if err != nil {
 		fmt.Println("Server: Failed to create tunnel: " + err.Error())
 		t.Fail()
@@ -48,14 +47,14 @@ func Test_DatagramServerClient(t *testing.T) {
 			return
 		}
 		fmt.Println("\tClient: Creating tunnel")
-		ds2, err := sam2.NewDatagramSession("DGclientTun", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"}, 0)
+		ds2, err := sam2.NewDatagramSession("DGclientTun", keys, []string{"inbound.length=1", "outbound.length=1", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"}, 0)
 		if err != nil {
 			c <- false
 			return
 		}
 		defer ds2.Close()
-		//		fmt.Println("\tClient: Servers address: " + ds.LocalAddr().Base32())
-		//		fmt.Println("\tClient: Clients address: " + ds2.LocalAddr().Base32())
+		fmt.Println("\tClient: Servers address: " + ds.B32())
+		fmt.Println("\tClient: Clients address: " + ds2.B32())
 		fmt.Println("\tClient: Tries to send datagram to server")
 		for {
 			select {
@@ -125,58 +124,6 @@ func ExampleDatagramSession() {
 		fmt.Println(err.Error())
 		return
 	}
-	log.Println("Got message: '" + string(buf[:n]) + "'")
-	fmt.Println("Got message: " + string(buf[:n]))
-
-	return
-	// Output:
-	//Got message: Hello myself!
-}
-
-func ExampleMiniDatagramSession() {
-	// Creates a new DatagramSession, which behaves just like a net.PacketConn.
-
-	const samBridge = "127.0.0.1:7656"
-
-	sam, err := NewSAM(samBridge)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	keys, err := sam.NewKeys()
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	myself := keys.Addr()
-
-	// See the example Option_* variables.
-	dg, err := sam.NewDatagramSession("MINIDGTUN", keys, Options_Small, 0)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	someone, err := sam.Lookup("zzz.i2p")
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	err = dg.SetWriteBuffer(14 * 1024)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-
-	dg.WriteTo([]byte("Hello stranger!"), someone)
-	dg.WriteTo([]byte("Hello myself!"), myself)
-
-	buf := make([]byte, 31*1024)
-	n, _, err := dg.ReadFrom(buf)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	log.Println("Got message: '" + string(buf[:n]) + "'")
 	fmt.Println("Got message: " + string(buf[:n]))

 	return
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,56 +1,3 @@
-golang-github-eyedeekay-sam3 (0.3.2.32) unreleased; urgency=medium
-
-  [ idk ]
-  * Include "Convenience Functions" in /helper
-
- -- idk <hankhill19580@gmail.com>  Sun, 22 Nov 2020 12:49:13 -0500
-
-golang-github-eyedeekay-sam3 (0.3.2.31) unreleased; urgency=medium
-
-  [ idk ]
-  * Incorporate address fix from qiwenmin
-  * Shortcut for saving keys to text file
-
- -- idk <hankhill19580@gmail.com>  Sun, 18 Oct 2020 1:01:03 -0500
-
-golang-github-eyedeekay-sam3 (0.3.2.3) unreleased; urgency=medium
-
-  [ idk ]
-  * Purge ramp, re-release
-
- -- idk <hankhill19580@gmail.com>  Mon, 22 Jun 2020 17:55:03 -0500
-
-golang-github-eyedeekay-sam3 (0.3.2.2) bionic; urgency=medium
-
-  [ idk ]
-  * Purge ramp
-
- -- idk <hankhill19580@gmail.com>  Sat, 7 Dec 2019 22:05:34 -0500
-
-
-golang-github-eyedeekay-sam3 (0.3.2.1) bionic; urgency=medium
-
-  [ idk ]
-  * Add support for 44-character destination hashes.
-
- -- idk <hankhill19580@gmail.com>  Sat, 7 Dec 2019 17:30:30 -0500
-
-
-golang-github-eyedeekay-sam3 (0.3.2.01) bionic; urgency=medium
-
-  [ idk ]
-  * completely remove the old i2pkeys version and replace it with the new one.
-
- -- idk <hankhill19580@gmail.com>  Sat, 25 May 2019 14:38:11 -0500
-
-golang-github-eyedeekay-sam3 (0.3.2.0) bionic; urgency=medium
-
-  [ idk ]
-  * Bug fixes, create stable branch
-  * Move i2pkeys
-
- -- idk <hankhill19580@gmail.com>  Sat, 18 May 2019 18:32:51 -0500
-
 golang-github-eyedeekay-sam3 (0.0~git20190223.af5a3f3) bionic; urgency=medium

  [ idk ]
--- a/debian/control
+++ b/debian/control
@@ -5,8 +5,7 @@ Maintainer: Debian Go Packaging Team <team+pkg-go@tracker.debian.org>
 Uploaders: idk <hankhill19580@gmail.com>
 Build-Depends: debhelper (>= 11),
               dh-golang,
-               git,
-               golang-any | golang-go,
+               golang-any
 Standards-Version: 4.2.1
 Homepage: https://github.com/eyedeekay/sam3
 Vcs-Browser: https://github.com/eyedeekay/sam3
@@ -16,8 +15,7 @@ Testsuite: autopkgtest-pkg-go

 Package: golang-github-eyedeekay-sam3-dev
 Architecture: all
-Depends: ${misc:Depends},
-    i2p | i2pd
+Depends: ${misc:Depends}, (i2p | i2pd)
 Description: Go library for the I2P SAMv3.0 bridge,
 used to build anonymous/pseudonymous end-to-end encrypted sockets.
 README go library for the I2P SAMv3.0
--- a/debian/files
+++ b/debian/files
@@ -1 +0,0 @@
-golang-github-eyedeekay-sam3_0.3.2.32_source.buildinfo devel optional
--- a/emit-options.go
+++ b/emit-options.go
@@ -1,369 +0,0 @@
-package sam3
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-)
-
-//Option is a SAMEmit Option
-type Option func(*SAMEmit) error
-
-//SetType sets the type of the forwarder server
-func SetType(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if s == "STREAM" {
-			c.Style = s
-			return nil
-		} else if s == "DATAGRAM" {
-			c.Style = s
-			return nil
-		} else if s == "RAW" {
-			c.Style = s
-			return nil
-		}
-		return fmt.Errorf("Invalid session STYLE=%s, must be STREAM, DATAGRAM, or RAW", s)
-	}
-}
-
-// SetSAMAddress sets the SAM address all-at-once
-func SetSAMAddress(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		sp := strings.Split(s, ":")
-		if len(sp) > 2 {
-			return fmt.Errorf("Invalid address string: %s", sp)
-		}
-		if len(sp) == 2 {
-			c.I2PConfig.SamPort = sp[1]
-		}
-		c.I2PConfig.SamHost = sp[0]
-		return nil
-	}
-}
-
-//SetSAMHost sets the host of the SAMEmit's SAM bridge
-func SetSAMHost(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.SamHost = s
-		return nil
-	}
-}
-
-//SetSAMPort sets the port of the SAMEmit's SAM bridge using a string
-func SetSAMPort(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		port, err := strconv.Atoi(s)
-		if err != nil {
-			return fmt.Errorf("Invalid SAM Port %s; non-number", s)
-		}
-		if port < 65536 && port > -1 {
-			c.I2PConfig.SamPort = s
-			return nil
-		}
-		return fmt.Errorf("Invalid port")
-	}
-}
-
-//SetName sets the host of the SAMEmit's SAM bridge
-func SetName(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.TunName = s
-		return nil
-	}
-}
-
-//SetInLength sets the number of hops inbound
-func SetInLength(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if u < 7 && u >= 0 {
-			c.I2PConfig.InLength = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid inbound tunnel length")
-	}
-}
-
-//SetOutLength sets the number of hops outbound
-func SetOutLength(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if u < 7 && u >= 0 {
-			c.I2PConfig.OutLength = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid outbound tunnel length")
-	}
-}
-
-//SetInVariance sets the variance of a number of hops inbound
-func SetInVariance(i int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if i < 7 && i > -7 {
-			c.I2PConfig.InVariance = strconv.Itoa(i)
-			return nil
-		}
-		return fmt.Errorf("Invalid inbound tunnel length")
-	}
-}
-
-//SetOutVariance sets the variance of a number of hops outbound
-func SetOutVariance(i int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if i < 7 && i > -7 {
-			c.I2PConfig.OutVariance = strconv.Itoa(i)
-			return nil
-		}
-		return fmt.Errorf("Invalid outbound tunnel variance")
-	}
-}
-
-//SetInQuantity sets the inbound tunnel quantity
-func SetInQuantity(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if u <= 16 && u > 0 {
-			c.I2PConfig.InQuantity = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid inbound tunnel quantity")
-	}
-}
-
-//SetOutQuantity sets the outbound tunnel quantity
-func SetOutQuantity(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if u <= 16 && u > 0 {
-			c.I2PConfig.OutQuantity = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid outbound tunnel quantity")
-	}
-}
-
-//SetInBackups sets the inbound tunnel backups
-func SetInBackups(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if u < 6 && u >= 0 {
-			c.I2PConfig.InBackupQuantity = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid inbound tunnel backup quantity")
-	}
-}
-
-//SetOutBackups sets the inbound tunnel backups
-func SetOutBackups(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if u < 6 && u >= 0 {
-			c.I2PConfig.OutBackupQuantity = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid outbound tunnel backup quantity")
-	}
-}
-
-//SetEncrypt tells the router to use an encrypted leaseset
-func SetEncrypt(b bool) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if b {
-			c.I2PConfig.EncryptLeaseSet = "true"
-			return nil
-		}
-		c.I2PConfig.EncryptLeaseSet = "false"
-		return nil
-	}
-}
-
-//SetLeaseSetKey sets the host of the SAMEmit's SAM bridge
-func SetLeaseSetKey(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.LeaseSetKey = s
-		return nil
-	}
-}
-
-//SetLeaseSetPrivateKey sets the host of the SAMEmit's SAM bridge
-func SetLeaseSetPrivateKey(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.LeaseSetPrivateKey = s
-		return nil
-	}
-}
-
-//SetLeaseSetPrivateSigningKey sets the host of the SAMEmit's SAM bridge
-func SetLeaseSetPrivateSigningKey(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.LeaseSetPrivateSigningKey = s
-		return nil
-	}
-}
-
-//SetMessageReliability sets the host of the SAMEmit's SAM bridge
-func SetMessageReliability(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.MessageReliability = s
-		return nil
-	}
-}
-
-//SetAllowZeroIn tells the tunnel to accept zero-hop peers
-func SetAllowZeroIn(b bool) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if b {
-			c.I2PConfig.InAllowZeroHop = "true"
-			return nil
-		}
-		c.I2PConfig.InAllowZeroHop = "false"
-		return nil
-	}
-}
-
-//SetAllowZeroOut tells the tunnel to accept zero-hop peers
-func SetAllowZeroOut(b bool) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if b {
-			c.I2PConfig.OutAllowZeroHop = "true"
-			return nil
-		}
-		c.I2PConfig.OutAllowZeroHop = "false"
-		return nil
-	}
-}
-
-//SetCompress tells clients to use compression
-func SetCompress(b bool) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if b {
-			c.I2PConfig.UseCompression = "true"
-			return nil
-		}
-		c.I2PConfig.UseCompression = "false"
-		return nil
-	}
-}
-
-//SetFastRecieve tells clients to use compression
-func SetFastRecieve(b bool) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if b {
-			c.I2PConfig.FastRecieve = "true"
-			return nil
-		}
-		c.I2PConfig.FastRecieve = "false"
-		return nil
-	}
-}
-
-//SetReduceIdle tells the connection to reduce it's tunnels during extended idle time.
-func SetReduceIdle(b bool) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if b {
-			c.I2PConfig.ReduceIdle = "true"
-			return nil
-		}
-		c.I2PConfig.ReduceIdle = "false"
-		return nil
-	}
-}
-
-//SetReduceIdleTime sets the time to wait before reducing tunnels to idle levels
-func SetReduceIdleTime(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.ReduceIdleTime = "300000"
-		if u >= 6 {
-			c.I2PConfig.ReduceIdleTime = strconv.Itoa((u * 60) * 1000)
-			return nil
-		}
-		return fmt.Errorf("Invalid reduce idle timeout(Measured in minutes) %v", u)
-	}
-}
-
-//SetReduceIdleTimeMs sets the time to wait before reducing tunnels to idle levels in milliseconds
-func SetReduceIdleTimeMs(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.ReduceIdleTime = "300000"
-		if u >= 300000 {
-			c.I2PConfig.ReduceIdleTime = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid reduce idle timeout(Measured in milliseconds) %v", u)
-	}
-}
-
-//SetReduceIdleQuantity sets minimum number of tunnels to reduce to during idle time
-func SetReduceIdleQuantity(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if u < 5 {
-			c.I2PConfig.ReduceIdleQuantity = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid reduce tunnel quantity")
-	}
-}
-
-//SetCloseIdle tells the connection to close it's tunnels during extended idle time.
-func SetCloseIdle(b bool) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if b {
-			c.I2PConfig.CloseIdle = "true"
-			return nil
-		}
-		c.I2PConfig.CloseIdle = "false"
-		return nil
-	}
-}
-
-//SetCloseIdleTime sets the time to wait before closing tunnels to idle levels
-func SetCloseIdleTime(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.CloseIdleTime = "300000"
-		if u >= 6 {
-			c.I2PConfig.CloseIdleTime = strconv.Itoa((u * 60) * 1000)
-			return nil
-		}
-		return fmt.Errorf("Invalid close idle timeout(Measured in minutes) %v", u)
-	}
-}
-
-//SetCloseIdleTimeMs sets the time to wait before closing tunnels to idle levels in milliseconds
-func SetCloseIdleTimeMs(u int) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		c.I2PConfig.CloseIdleTime = "300000"
-		if u >= 300000 {
-			c.I2PConfig.CloseIdleTime = strconv.Itoa(u)
-			return nil
-		}
-		return fmt.Errorf("Invalid close idle timeout(Measured in milliseconds) %v", u)
-	}
-}
-
-//SetAccessListType tells the system to treat the AccessList as a whitelist
-func SetAccessListType(s string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if s == "whitelist" {
-			c.I2PConfig.AccessListType = "whitelist"
-			return nil
-		} else if s == "blacklist" {
-			c.I2PConfig.AccessListType = "blacklist"
-			return nil
-		} else if s == "none" {
-			c.I2PConfig.AccessListType = ""
-			return nil
-		} else if s == "" {
-			c.I2PConfig.AccessListType = ""
-			return nil
-		}
-		return fmt.Errorf("Invalid Access list type(whitelist, blacklist, none)")
-	}
-}
-
-//SetAccessList tells the system to treat the AccessList as a whitelist
-func SetAccessList(s []string) func(*SAMEmit) error {
-	return func(c *SAMEmit) error {
-		if len(s) > 0 {
-			for _, a := range s {
-				c.I2PConfig.AccessList = append(c.I2PConfig.AccessList, a)
-			}
-			return nil
-		}
-		return nil
-	}
-}
--- a/emit.go
+++ b/emit.go
@@ -1,98 +0,0 @@
-package sam3
-
-import (
-	"fmt"
-	"log"
-)
-
-type SAMEmit struct {
-	I2PConfig
-}
-
-func (e *SAMEmit) OptStr() string {
-	optStr := ""
-	for _, opt := range e.I2PConfig.Print() {
-		optStr += opt + " "
-	}
-	return optStr
-}
-
-func (e *SAMEmit) Hello() string {
-	return fmt.Sprintf("HELLO VERSION MIN=%s MAX=%s \n", e.I2PConfig.MinSAM(), e.I2PConfig.MaxSAM())
-}
-
-func (e *SAMEmit) HelloBytes() []byte {
-	return []byte(e.Hello())
-}
-
-func (e *SAMEmit) GenerateDestination() string {
-	return fmt.Sprintf("DEST GENERATE %s \n", e.I2PConfig.SignatureType())
-}
-
-func (e *SAMEmit) GenerateDestinationBytes() []byte {
-	return []byte(e.GenerateDestination())
-}
-
-func (e *SAMEmit) Lookup(name string) string {
-	return fmt.Sprintf("NAMING LOOKUP NAME=%s \n", name)
-}
-
-func (e *SAMEmit) LookupBytes(name string) []byte {
-	return []byte(e.Lookup(name))
-}
-
-func (e *SAMEmit) Create() string {
-	return fmt.Sprintf(
-		//             //1 2 3 4 5 6 7
-		"SESSION CREATE %s%s%s%s%s%s%s \n",
-		e.I2PConfig.SessionStyle(),   //1
-		e.I2PConfig.FromPort(),       //2
-		e.I2PConfig.ToPort(),         //3
-		e.I2PConfig.ID(),             //4
-		e.I2PConfig.DestinationKey(), // 5
-		e.I2PConfig.SignatureType(),  // 6
-		e.OptStr(),                   // 7
-	)
-}
-
-func (e *SAMEmit) CreateBytes() []byte {
-	log.Println("sam command: " + e.Create())
-	return []byte(e.Create())
-}
-
-func (e *SAMEmit) Connect(dest string) string {
-	return fmt.Sprintf(
-		"STREAM CONNECT ID=%s %s %s DESTINATION=%s \n",
-		e.I2PConfig.ID(),
-		e.I2PConfig.FromPort(),
-		e.I2PConfig.ToPort(),
-		dest,
-	)
-}
-
-func (e *SAMEmit) ConnectBytes(dest string) []byte {
-	return []byte(e.Connect(dest))
-}
-
-func (e *SAMEmit) Accept() string {
-	return fmt.Sprintf(
-		"STREAM ACCEPT ID=%s %s %s",
-		e.I2PConfig.ID(),
-		e.I2PConfig.FromPort(),
-		e.I2PConfig.ToPort(),
-	)
-}
-
-func (e *SAMEmit) AcceptBytes() []byte {
-	return []byte(e.Accept())
-}
-
-func NewEmit(opts ...func(*SAMEmit) error) (*SAMEmit, error) {
-	var emit SAMEmit
-	for _, o := range opts {
-		if err := o(&emit); err != nil {
-			return nil, err
-		}
-	}
-	return &emit, nil
-}
--- a/go.mod
+++ b/go.mod
@@ -1,12 +0,0 @@
-module github.com/eyedeekay/sam3
-
-go 1.12
-
-require (
-	github.com/eyedeekay/goSam v0.32.31-0.20210122211817-f97683379f23
-	github.com/google/renameio v1.0.0 // indirect
-	github.com/riobard/go-x25519 v0.0.0-20190716001027-10cc4d8d0b33
-	github.com/rogpeppe/go-internal v1.6.2 // indirect
-	golang.org/x/tools v0.0.0-20201125231158-b5590deeca9b // indirect
-	honnef.co/go/tools v0.0.1-2020.1.6 // indirect
-)
--- a/go.sum
+++ b/go.sum
@@ -1,88 +0,0 @@
-github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
-github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
-github.com/agl/ed25519 v0.0.0-20200225211852-fd4d107ace12 h1:iPf1jQ8yKTms6k6L5vYSE7RZJpjEe5vLTOmzRZdpnKc=
-github.com/cryptix/go v1.3.1 h1:I9opbROgEpldI0PwkMku0UY2DLFYgelZd9u0uaxmMgY=
-github.com/cryptix/go v1.3.1/go.mod h1:mFQotm9rTzptzvNjJM+1vSIDa/rVOVqMu0889GIXg70=
-github.com/cryptix/goSam v0.1.0 h1:lKXtrTv3Kd6+eIuNtcq3zPShJEVRqw+lQwmh49HmC7k=
-github.com/cryptix/goSam v0.1.0/go.mod h1:7ewkjhXT8V5RG07pvWUOHHtMahvGbeKlEv8ukUyRiTA=
-github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/eyedeekay/goSam v0.32.30 h1:mMlZNE2oISdjjjpgfN17W56tn9F8rD/Jc2tsjTDDFYg=
-github.com/eyedeekay/goSam v0.32.30/go.mod h1:UgJnih/LpotwKriwVPOEa6yPDM2NDdVrKfLtS5DOLPE=
-github.com/eyedeekay/goSam v0.32.31-0.20210122211024-dddd8ea916d6 h1:seMFdfTWvmAsyj9jYPZATBJiJu5gHPsvJJk4Ruo2npQ=
-github.com/eyedeekay/goSam v0.32.31-0.20210122211024-dddd8ea916d6/go.mod h1:UgJnih/LpotwKriwVPOEa6yPDM2NDdVrKfLtS5DOLPE=
-github.com/eyedeekay/goSam v0.32.31-0.20210122211817-f97683379f23 h1:AHm/EzBilSQH+RFgEuslnlCpVQd88MQWx7KHW/VIQlc=
-github.com/eyedeekay/goSam v0.32.31-0.20210122211817-f97683379f23/go.mod h1:UgJnih/LpotwKriwVPOEa6yPDM2NDdVrKfLtS5DOLPE=
-github.com/eyedeekay/sam3 v0.32.32/go.mod h1:qRA9KIIVxbrHlkj+ZB+OoxFGFgdKeGp1vSgPw26eOVU=
-github.com/getlantern/context v0.0.0-20190109183933-c447772a6520/go.mod h1:L+mq6/vvYHKjCX2oez0CgEAJmbq1fbb/oNJIWQkBybY=
-github.com/getlantern/errors v1.0.1/go.mod h1:l+xpFBrCtDLpK9qNjxs+cHU6+BAdlBaxHqikB6Lku3A=
-github.com/getlantern/go-socks5 v0.0.0-20171114193258-79d4dd3e2db5/go.mod h1:kGHRXch95rnGLHjER/GhhFiHvfnqNz7KqWD9kGfATHY=
-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/go.mod h1:dD3CgOrwlzca8ed61CsZouQS5h5jIzkK9ZWrTcf0s+o=
-github.com/getlantern/hidden v0.0.0-20190325191715-f02dbb02be55/go.mod h1:6mmzY2kW1TOOrVy+r41Za2MxXM+hhqTtY3oBKd2AgFA=
-github.com/getlantern/netx v0.0.0-20190110220209-9912de6f94fd/go.mod h1:wKdY0ikOgzrWSeB9UyBVKPRhjXQ+vTb+BPeJuypUuNE=
-github.com/getlantern/ops v0.0.0-20190325191751-d70cb0d6f85f/go.mod h1:D5ao98qkA6pxftxoqzibIBBrLSUli+kYnJqrgBf9cIA=
-github.com/getlantern/ops v0.0.0-20200403153110-8476b16edcd6/go.mod h1:D5ao98qkA6pxftxoqzibIBBrLSUli+kYnJqrgBf9cIA=
-github.com/go-kit/kit v0.6.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
-github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
-github.com/go-stack/stack v1.7.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
-github.com/google/renameio v0.1.0 h1:GOZbcHa3HfsPKPlmyPyN2KEohoMXOhdMbHrvbpl2QaA=
-github.com/google/renameio v0.1.0/go.mod h1:KWCgfxg9yswjAJkECMjeO8J8rahYeXnNhOm40UhjYkI=
-github.com/google/renameio v1.0.0 h1:xhp2CnJmgQmpJU4RY8chagahUq5mbPPAbiSQstKpVMA=
-github.com/google/renameio v1.0.0/go.mod h1:t/HQoYBZSsWSNK35C6CO/TpPLDVWvxOHboWUAweKUpk=
-github.com/kisielk/gotool v1.0.0 h1:AV2c/EiW3KqPNT9ZKl07ehoAGi4C5/01Cfbblndcapg=
-github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
-github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
-github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
-github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
-github.com/miolini/datacounter v0.0.0-20171104152933-fd4e42a1d5e0 h1:clkDYGefEWUCwyCrwYn900sOaVGDpinPJgD0W6ebEjs=
-github.com/miolini/datacounter v0.0.0-20171104152933-fd4e42a1d5e0/go.mod h1:P6fDJzlxN+cWYR09KbE9/ta+Y6JofX9tAUhJpWkWPaM=
-github.com/oxtoacart/bpool v0.0.0-20190530202638-03653db5a59c/go.mod h1:X07ZCGwUbLaax7L0S3Tw4hpejzu63ZrrQiUe6W0hcy0=
-github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
-github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
-github.com/riobard/go-x25519 v0.0.0-20190716001027-10cc4d8d0b33 h1:dyyWDK0yzlZ8ay89Oe5ZIRtscacUjFyPUFGChrgMXRg=
-github.com/riobard/go-x25519 v0.0.0-20190716001027-10cc4d8d0b33/go.mod h1:BjmVxzAnkLeoEbqHEerI4eSw6ua+RaIB0S4jMV21RAs=
-github.com/rogpeppe/go-internal v1.3.0 h1:RR9dF3JtopPvtkroDZuVD7qquD0bnHlKSqaQhgwt8yk=
-github.com/rogpeppe/go-internal v1.3.0/go.mod h1:M8bDsm7K2OlrFYOpmOWEs/qY81heoFRclV5y23lUDJ4=
-github.com/rogpeppe/go-internal v1.6.2 h1:aIihoIOHCiLZHxyoNQ+ABL4NKhFTgKLBdMLyEAh98m0=
-github.com/rogpeppe/go-internal v1.6.2/go.mod h1:xXDCJY+GAPziupqXw64V24skbSoqbTEfhy4qGm1nDQc=
-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=
-github.com/yuin/goldmark v1.1.27/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-github.com/yuin/goldmark v1.2.1/go.mod h1:3hX8gzYuyVAZsxl0MRgGTJEmQBFcNTphYh9decYSb74=
-golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
-golang.org/x/crypto v0.0.0-20191011191535-87dc89f01550/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9 h1:psW17arqaxU48Z5kZ0CQnkZWQJsqcURM6tKiBApRjXI=
-golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
-golang.org/x/mod v0.2.0 h1:KU7oHjnv3XNWfa5COkzUifxZmxp1TyI7ImMXqFxLwvQ=
-golang.org/x/mod v0.2.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/mod v0.3.0 h1:RM4zey1++hCTbCVQfnWeKs9/IEsaBLA8vTkd0WVtmH4=
-golang.org/x/mod v0.3.0/go.mod h1:s0Qsj1ACt9ePp/hMypM3fl4fZqREWJwdYDEqhRiZZUA=
-golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20200226121028-0de0cce0169b/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
-golang.org/x/net v0.0.0-20201021035429-f5854403a974/go.mod h1:sp8m0HH+o8qH0wwXwYZr8TS3Oi6o0r6Gce1SSxlDquU=
-golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20190911185100-cd5d95a43a6e/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sync v0.0.0-20201020160332-67f06af15bc9/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
-golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
-golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/sys v0.0.0-20200930185726-fdedc70b468f/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
-golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
-golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
-golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
-golang.org/x/tools v0.0.0-20200410194907-79a7a3126eef h1:RHORRhs540cYZYrzgU2CPUyykkwZM78hGdzocOo9P8A=
-golang.org/x/tools v0.0.0-20200410194907-79a7a3126eef/go.mod h1:EkVYQZoAsY45+roYkvgYkIh4xh/qjgUK9TdY2XT94GE=
-golang.org/x/tools v0.0.0-20201125231158-b5590deeca9b h1:Lq5JUTFhiybGVf28jB6QRpqd13/JPOaCnET17PVzYJE=
-golang.org/x/tools v0.0.0-20201125231158-b5590deeca9b/go.mod h1:emZCQorbCU4vsT4fOWvOPXz4eW1wZW4PmDk9uLelYpA=
-golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543 h1:E7g+9GITq07hpfrRu66IVDexMakfv52eLZ2CXBWiKr4=
-golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1 h1:go1bK/D/BFZV2I8cIQd1NKEZ+0owSTG1fDTci4IqFcE=
-golang.org/x/xerrors v0.0.0-20200804184101-5ec99f83aff1/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=
-gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
-gopkg.in/errgo.v2 v2.1.0/go.mod h1:hNsd1EY+bozCKY1Ytp96fpM3vjJbqLJn88ws8XvfDNI=
-honnef.co/go/tools v0.0.1-2020.1.6 h1:W18jzjh8mfPez+AwGLxmOImucz/IFjpNlrKVnaj2YVc=
-honnef.co/go/tools v0.0.1-2020.1.6/go.mod h1:pyyisuGw24ruLjrr1ddx39WE0y9OooInRzEYLhQB2YY=
--- a/helper/helper.go
+++ b/helper/helper.go
@@ -1,162 +0,0 @@
-package sam
-
-import (
-	"fmt"
-	"io/ioutil"
-	"log"
-	"net"
-	"os"
-
-	"github.com/eyedeekay/sam3"
-	"github.com/eyedeekay/sam3/i2pkeys"
-)
-
-func NetListener(name, samaddr, keyspath string) (net.Listener, error) {
-	return I2PListener(name, samaddr, keyspath)
-}
-
-// I2PListener is a convenience function which takes a SAM tunnel name, a SAM address and a filename.
-// If the file contains I2P keys, it will create a service using that address. If the file does not
-// exist, keys will be generated and stored in that file.
-func I2PListener(name, samaddr, keyspath string) (*sam3.StreamListener, error) {
-	log.Printf("Starting and registering I2P service, please wait a couple of minutes...")
-	listener, err := I2PStreamSession(name, samaddr, keyspath)
-
-	if keyspath != "" {
-		err = ioutil.WriteFile(keyspath+".i2p.public.txt", []byte(listener.Keys().Addr().Base32()), 0644)
-		if err != nil {
-			return nil, fmt.Errorf("error storing I2P base32 address in adjacent text file, %s", err)
-		}
-	}
-	return listener.Listen() //, err
-}
-
-// I2PStreamSession is a convenience function which returns a sam3.StreamSession instead
-// of a sam3.StreamListener. It also takes care of setting a persisitent key on behalf
-// of the user.
-func I2PStreamSession(name, samaddr, keyspath string) (*sam3.StreamSession, error) {
-	log.Printf("Starting and registering I2P session...")
-	sam, err := sam3.NewSAM(samaddr)
-	if err != nil {
-		return nil, fmt.Errorf("error connecting to SAM to %s: %s", samaddr, err)
-	}
-	var keys *i2pkeys.I2PKeys
-	if keyspath != "" {
-		if _, err := os.Stat(keyspath + ".i2p.private"); os.IsNotExist(err) {
-			f, err := os.Create(keyspath + ".i2p.private")
-			if err != nil {
-				return nil, fmt.Errorf("unable to open I2P keyfile for writing: %s", err)
-			}
-			defer f.Close()
-			tkeys, err := sam.NewKeys()
-			if err != nil {
-				return nil, fmt.Errorf("unable to generate I2P Keys, %s", err)
-			}
-			keys = &tkeys
-			err = i2pkeys.StoreKeysIncompat(*keys, f)
-			if err != nil {
-				return nil, fmt.Errorf("unable to save newly generated I2P Keys, %s", err)
-			}
-		} else {
-			tkeys, err := i2pkeys.LoadKeys(keyspath + ".i2p.private")
-			if err != nil {
-				return nil, fmt.Errorf("unable to load I2P Keys: %e", err)
-			}
-			keys = &tkeys
-		}
-	} else {
-		tkeys, err := sam.NewKeys()
-		if err != nil {
-			return nil, fmt.Errorf("unable to generate I2P Keys, %s", err)
-		}
-		keys = &tkeys
-	}
-	stream, err := sam.NewStreamSession(name, *keys, sam3.Options_Medium)
-	return stream, err
-}
-
-// I2PDataGramsession is a convenience function which returns a sam3.DatagramSession.
-// It also takes care of setting a persisitent key on behalf of the user.
-func I2PDatagramSession(name, samaddr, keyspath string) (*sam3.DatagramSession, error) {
-	log.Printf("Starting and registering I2P session...")
-	sam, err := sam3.NewSAM(samaddr)
-	if err != nil {
-		return nil, fmt.Errorf("error connecting to SAM to %s: %s", samaddr, err)
-	}
-	var keys *i2pkeys.I2PKeys
-	if keyspath != "" {
-		if _, err := os.Stat(keyspath + ".i2p.private"); os.IsNotExist(err) {
-			f, err := os.Create(keyspath + ".i2p.private")
-			if err != nil {
-				return nil, fmt.Errorf("unable to open I2P keyfile for writing: %s", err)
-			}
-			defer f.Close()
-			tkeys, err := sam.NewKeys()
-			if err != nil {
-				return nil, fmt.Errorf("unable to generate I2P Keys, %s", err)
-			}
-			keys = &tkeys
-			err = i2pkeys.StoreKeysIncompat(*keys, f)
-			if err != nil {
-				return nil, fmt.Errorf("unable to save newly generated I2P Keys, %s", err)
-			}
-		} else {
-			tkeys, err := i2pkeys.LoadKeys(keyspath + ".i2p.private")
-			if err != nil {
-				return nil, fmt.Errorf("unable to load I2P Keys: %e", err)
-			}
-			keys = &tkeys
-		}
-	} else {
-		tkeys, err := sam.NewKeys()
-		if err != nil {
-			return nil, fmt.Errorf("unable to generate I2P Keys, %s", err)
-		}
-		keys = &tkeys
-	}
-	gram, err := sam.NewDatagramSession(name, *keys, sam3.Options_Medium, 0)
-	return gram, err
-}
-
-// I2PPrimarySession is a convenience function which returns a sam3.PrimarySession.
-// It also takes care of setting a persisitent key on behalf of the user.
-func I2PPrimarySession(name, samaddr, keyspath string) (*sam3.PrimarySession, error) {
-	log.Printf("Starting and registering I2P session...")
-	sam, err := sam3.NewSAM(samaddr)
-	if err != nil {
-		return nil, fmt.Errorf("error connecting to SAM to %s: %s", samaddr, err)
-	}
-	var keys *i2pkeys.I2PKeys
-	if keyspath != "" {
-		if _, err := os.Stat(keyspath + ".i2p.private"); os.IsNotExist(err) {
-			f, err := os.Create(keyspath + ".i2p.private")
-			if err != nil {
-				return nil, fmt.Errorf("unable to open I2P keyfile for writing: %s", err)
-			}
-			defer f.Close()
-			tkeys, err := sam.NewKeys()
-			if err != nil {
-				return nil, fmt.Errorf("unable to generate I2P Keys, %s", err)
-			}
-			keys = &tkeys
-			err = i2pkeys.StoreKeysIncompat(*keys, f)
-			if err != nil {
-				return nil, fmt.Errorf("unable to save newly generated I2P Keys, %s", err)
-			}
-		} else {
-			tkeys, err := i2pkeys.LoadKeys(keyspath + ".i2p.private")
-			if err != nil {
-				return nil, fmt.Errorf("unable to load I2P Keys: %e", err)
-			}
-			keys = &tkeys
-		}
-	} else {
-		tkeys, err := sam.NewKeys()
-		if err != nil {
-			return nil, fmt.Errorf("unable to generate I2P Keys, %s", err)
-		}
-		keys = &tkeys
-	}
-	gram, err := sam.NewPrimarySession(name, *keys, sam3.Options_Medium)
-	return gram, err
-}
--- a/i2pkeys/I2PAddr.go
+++ b/i2pkeys/I2PAddr.go
@@ -2,18 +2,12 @@ package i2pkeys

 import (
 	"bytes"
-	"crypto"
-	"crypto/ed25519"
-	"crypto/rand"
 	"crypto/sha256"
 	"encoding/base32"
 	"encoding/base64"
 	"errors"
 	"io"
-	"os"
 	"strings"
-
-	"github.com/eyedeekay/goSam"
 )

 var (
@@ -21,16 +15,14 @@ var (
 	i2pB32enc *base32.Encoding = base32.NewEncoding("abcdefghijklmnopqrstuvwxyz234567")
 )

-var FakePort = false
-
 // The public and private keys associated with an I2P destination. I2P hides the
 // details of exactly what this is, so treat them as blobs, but generally: One
 // pair of DSA keys, one pair of ElGamal keys, and sometimes (almost never) also
 // a certificate. String() returns you the full content of I2PKeys and Addr()
 // returns the public keys.
 type I2PKeys struct {
-	Address I2PAddr // only the public key
-	Both    string  // both public and private keys
+	addr I2PAddr // only the public key
+	both string  // both public and private keys
 }

 // Creates I2PKeys from an I2PAddr and a public/private keypair string (as
@@ -39,18 +31,6 @@ func NewKeys(addr I2PAddr, both string) I2PKeys {
 	return I2PKeys{addr, both}
 }

-// fileExists checks if a file exists and is not a directory before we
-// try using it to prevent further errors.
-func fileExists(filename string) (bool, error) {
-	info, err := os.Stat(filename)
-	if os.IsNotExist(err) {
-		return false, nil
-	} else if err != nil {
-		return false, err
-	}
-	return !info.IsDir(), nil
-}
-
 // load keys from non standard format
 func LoadKeysIncompat(r io.Reader) (k I2PKeys, err error) {
 	var buff bytes.Buffer
@@ -62,107 +42,21 @@ func LoadKeysIncompat(r io.Reader) (k I2PKeys, err error) {
 	return
 }

-// load keys from non-standard format by specifying a text file.
-// If the file does not exist, generate keys, otherwise, fail
-// closed.
-func LoadKeys(r string) (I2PKeys, error) {
-	exists, err := fileExists(r)
-	if err != nil {
-		return I2PKeys{}, err
-	}
-	if exists {
-		fi, err := os.Open(r)
-		if err != nil {
-			return I2PKeys{}, err
-		}
-		defer fi.Close()
-		return LoadKeysIncompat(fi)
-	}
-	return I2PKeys{}, err
-}
-
 // store keys in non standard format
 func StoreKeysIncompat(k I2PKeys, w io.Writer) (err error) {
-	_, err = io.WriteString(w, k.Address.Base64()+"\n"+k.Both)
+	_, err = io.WriteString(w, k.addr.Base64()+"\n"+k.both)
 	return
 }

-func StoreKeys(k I2PKeys, r string) error {
-	fi, err := os.Open(r)
-	if err != nil {
-		return err
-	}
-	defer fi.Close()
-	return StoreKeysIncompat(k, fi)
-}
-
-func (k I2PKeys) Network() string {
-	return k.Address.Network()
-}
-
 // Returns the public keys of the I2PKeys.
 func (k I2PKeys) Addr() I2PAddr {
-	return k.Address
-}
-
-func (k I2PKeys) Public() crypto.PublicKey {
-	return k.Address
-}
-
-func (k I2PKeys) Private() []byte {
-	src := strings.Split(k.String(), k.Addr().String())[0]
-	var dest []byte
-	_, err := i2pB64enc.Decode(dest, []byte(src))
-	panic(err)
-	return dest
-}
-
-type SecretKey interface {
-	Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error)
-}
-
-func (k I2PKeys) SecretKey() SecretKey {
-	var pk ed25519.PrivateKey = k.Private()
-	return pk
-}
-
-func (k I2PKeys) PrivateKey() crypto.PrivateKey {
-	var pk ed25519.PrivateKey = k.Private()
-	_, err := pk.Sign(rand.Reader, []byte("nonsense"), crypto.Hash(0))
-	if err != nil {
-		//TODO: Elgamal, P256, P384, P512, GOST? keys?
-	}
-	return pk
-}
-
-func (k I2PKeys) Ed25519PrivateKey() *ed25519.PrivateKey {
-	return k.SecretKey().(*ed25519.PrivateKey)
-}
-
-/*func (k I2PKeys) ElgamalPrivateKey() *ed25519.PrivateKey {
-	return k.SecretKey().(*ed25519.PrivateKey)
-}*/
-
-//func (k I2PKeys) Decrypt(rand io.Reader, msg []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
-//return k.SecretKey().(*ed25519.PrivateKey).Decrypt(rand, msg, opts)
-//}
-
-func (k I2PKeys) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) (signature []byte, err error) {
-	return k.SecretKey().(*ed25519.PrivateKey).Sign(rand, digest, opts)
+	return k.addr
 }

 // Returns the keys (both public and private), in I2Ps base64 format. Use this
 // when you create sessions.
 func (k I2PKeys) String() string {
-	return k.Both
-}
-
-func (k I2PKeys) HostnameEntry(hostname string, opts crypto.SignerOpts) (string, error) {
-	sig, err := k.Sign(rand.Reader, []byte(hostname), opts)
-	if err != nil {
-		return "", err
-	}
-	return string(sig), nil
+	return k.both
 }

 // I2PAddr represents an I2P destination, almost equivalent to an IP address.
@@ -186,23 +80,13 @@ func DestHashFromString(str string) (dhash I2PDestHash, err error) {
 	return
 }

-// get string representation of i2p dest hash(base32 version)
+// get string representation of i2p dest hash
 func (h I2PDestHash) String() string {
 	b32addr := make([]byte, 56)
 	i2pB32enc.Encode(b32addr, h[:])
 	return string(b32addr[:52]) + ".b32.i2p"
 }

-// get base64 representation of i2p dest sha256 hash(the 44-character one)
-func (h I2PDestHash) Hash() string {
-	hash := sha256.New()
-	hash.Write(h[:])
-	digest := hash.Sum(nil)
-	buf := make([]byte, 44)
-	i2pB64enc.Encode(buf, digest)
-	return string(buf)
-}
-
 // Returns "I2P"
 func (h *I2PDestHash) Network() string {
 	return "I2P"
@@ -213,9 +97,9 @@ func (a I2PAddr) Base64() string {
 	return string(a)
 }

-// Returns the I2P destination (base32-encoded)
+// Returns the I2P destination (base64-encoded)
 func (a I2PAddr) String() string {
-	return string(a.Base32())
+	return string(a)
 }

 // Returns "I2P"
@@ -266,7 +150,11 @@ func NewI2PAddrFromBytes(addr []byte) (I2PAddr, error) {

 // Turns an I2P address to a byte array. The inverse of NewI2PAddrFromBytes().
 func (addr I2PAddr) ToBytes() ([]byte, error) {
-	return i2pB64enc.DecodeString(string(addr))
+	buf := make([]byte, i2pB64enc.DecodedLen(len(addr)))
+	if _, err := i2pB64enc.Decode(buf, []byte(addr)); err != nil {
+		return buf, errors.New("Address is not base64-encoded")
+	}
+	return buf, nil
 }

 func (addr I2PAddr) Bytes() []byte {
@@ -281,14 +169,7 @@ func (addr I2PAddr) Bytes() []byte {
 // performing a Lookup(). Lookup only works if you are using the I2PAddr from
 // which the b32 address was generated.
 func (addr I2PAddr) Base32() (str string) {
-	return addr.DestHash().String() + addr.Port()
-}
-
-func (addr I2PAddr) Port() (str string) {
-	if FakePort {
-		return ":8080"
-	}
-	return ""
+	return addr.DestHash().String()
 }

 func (addr I2PAddr) DestHash() (h I2PDestHash) {
@@ -305,30 +186,3 @@ func (addr I2PAddr) DestHash() (h I2PDestHash) {
 func Base32(anything string) string {
 	return I2PAddr(anything).Base32()
 }
-
-func NewDestination(samaddr string, sigType ...string) (I2PKeys, error) {
-	if samaddr == "" {
-		samaddr = "127.0.0.1:7656"
-	}
-	client, err := goSam.NewClient(samaddr)
-	if err != nil {
-		return I2PKeys{}, err
-	}
-	var sigtmp string
-	if len(sigType) > 0 {
-		sigtmp = sigType[0]
-	}
-	pub, priv, err := client.NewDestination(sigtmp)
-	if err != nil {
-		return I2PKeys{}, err
-	}
-	addr, err := NewI2PAddrFromBytes([]byte(pub))
-	if err != nil {
-		return I2PKeys{}, err
-	}
-	keys := NewKeys(addr, priv+pub)
-	if err != nil {
-		return I2PKeys{}, err
-	}
-	return keys, nil
-}
--- a/i2pkeys/I2PAddr_test.go
+++ b/i2pkeys/I2PAddr_test.go
@@ -1,21 +0,0 @@
-package i2pkeys
-
-import (
-	"fmt"
-	"testing"
-	//	"time"
-)
-
-const yoursam = "127.0.0.1:7656"
-
-func Test_Basic(t *testing.T) {
-	fmt.Println("Test_Basic")
-	fmt.Println("\tAttaching to SAM at " + yoursam)
-	keys, err := NewDestination("")
-	if err != nil {
-		fmt.Println(err.Error())
-		t.Fail()
-		return
-	}
-	fmt.Println(keys.String())
-}
--- a/primary.go
+++ b/primary.go
@@ -1,380 +0,0 @@
-package sam3
-
-import (
-	"errors"
-	"fmt"
-	"math/rand"
-	"net"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/eyedeekay/sam3/i2pkeys"
-)
-
-const (
-	session_ADDOK = "SESSION STATUS RESULT=OK"
-)
-
-func randport() string {
-	s := rand.NewSource(time.Now().UnixNano())
-	r := rand.New(s)
-	p := r.Intn(55534) + 10000
-	return strconv.Itoa(p)
-}
-
-// Represents a primary session.
-type PrimarySession struct {
-	samAddr  string          // address to the sam bridge (ipv4:port)
-	id       string          // tunnel name
-	conn     net.Conn        // connection to sam
-	keys     i2pkeys.I2PKeys // i2p destination keys
-	Timeout  time.Duration
-	Deadline time.Time
-	sigType  string
-	Config   SAMEmit
-	stsess   *StreamSession
-	dgsess   *DatagramSession
-	//	from     string
-	//	to       string
-}
-
-func (ss *PrimarySession) From() string {
-	return "0"
-}
-
-func (ss *PrimarySession) To() string {
-	return "0"
-}
-
-func (ss *PrimarySession) SignatureType() string {
-	return ss.sigType
-}
-
-// Returns the local tunnel name of the I2P tunnel used for the stream session
-func (ss *PrimarySession) ID() string {
-	return ss.id
-}
-
-func (ss *PrimarySession) Close() error {
-	return ss.conn.Close()
-}
-
-// Returns the I2P destination (the address) of the stream session
-func (ss *PrimarySession) Addr() i2pkeys.I2PAddr {
-	//	fmt.Println("LOCAL ADDR")
-	return ss.keys.Addr()
-}
-
-func (ss *PrimarySession) LocalAddr() net.Addr {
-	//	fmt.Println("LOCAL ADDR")
-	aa := ss.keys.Addr()
-	return &aa
-}
-
-// Returns the keys associated with the stream session
-func (ss *PrimarySession) Keys() i2pkeys.I2PKeys {
-	return ss.keys
-}
-
-func (sam *PrimarySession) Dial(network, addr string) (net.Conn, error) {
-	if network == "udp" || network == "udp4" || network == "udp6" {
-		return sam.DialUDPI2P(network, network+addr[0:4], addr)
-	}
-	if network == "tcp" || network == "tcp4" || network == "tcp6" {
-		return sam.DialTCPI2P(network, network+addr[0:4], addr)
-	}
-	return nil, fmt.Errorf("Error: Must specify a valid network type")
-}
-
-// DialTCP implements x/dialer
-func (sam *PrimarySession) DialTCP(network string, laddr, raddr net.Addr) (net.Conn, error) {
-	var err error
-	if sam.stsess == nil {
-		sam.stsess, err = sam.NewUniqueStreamSubSession(network + RandString())
-		if err != nil {
-			return nil, err
-		}
-	}
-	return sam.stsess.Dial(network, raddr.String())
-}
-
-func (sam *PrimarySession) DialTCPI2P(network string, laddr, raddr string) (*SAMConn, error) {
-	var err error
-	if sam.stsess == nil {
-		sam.stsess, err = sam.NewUniqueStreamSubSession(network + RandString())
-		if err != nil {
-			return nil, err
-		}
-	}
-	c, err := sam.stsess.Dial(network, raddr)
-	if err != nil {
-		return nil, err
-	}
-	return c.(*SAMConn), nil
-}
-
-// DialUDP implements x/dialer
-func (sam *PrimarySession) DialUDP(network string, laddr, raddr net.Addr) (net.PacketConn, error) {
-	var err error
-	if sam.dgsess == nil {
-		sam.dgsess, err = sam.NewDatagramSubSession(network+raddr.String()[0:4], 0)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return sam.dgsess.Dial(network, raddr.String())
-}
-
-func (sam *PrimarySession) DialUDPI2P(network, laddr, raddr string) (*DatagramSession, error) {
-	var err error
-	if sam.dgsess == nil {
-		sam.dgsess, err = sam.NewDatagramSubSession(network+raddr[0:4], 0)
-		if err != nil {
-			return nil, err
-		}
-	}
-	return sam.dgsess.Dial(network, raddr)
-}
-
-func (s *PrimarySession) Lookup(name string) (a net.Addr, err error) {
-	var sam *SAM
-	if len(strings.Split(name, ":")) <= 1 {
-		name += ":80"
-	}
-	sam, err = NewSAM(s.samAddr)
-	if err == nil {
-		defer sam.Close()
-		a, err = sam.Lookup(name)
-	}
-	return
-}
-
-func (sam *PrimarySession) Resolve(network, addr string) (net.Addr, error) {
-	fmt.Println("LOGGING RESOLUTION", network, addr)
-	return sam.Lookup(addr)
-}
-
-func (sam *PrimarySession) ResolveTCPAddr(network, dest string) (net.Addr, error) {
-	fmt.Println("LOGGING RESOLUTION", network, dest)
-	return sam.Lookup(dest)
-}
-
-func (sam *PrimarySession) ResolveUDPAddr(network, dest string) (net.Addr, error) {
-	fmt.Println("LOGGING RESOLUTION", network, dest)
-	return sam.Lookup(dest)
-}
-
-// Creates a new PrimarySession with the I2CP- and streaminglib options as
-// specified. See the I2P documentation for a full list of options.
-func (sam *SAM) NewPrimarySession(id string, keys i2pkeys.I2PKeys, options []string) (*PrimarySession, error) {
-	conn, err := sam.newGenericSession("PRIMARY", id, keys, options, []string{})
-	if err != nil {
-		return nil, err
-	}
-	return &PrimarySession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, sam.Config, nil, nil}, nil
-}
-
-// Creates a new PrimarySession with the I2CP- and PRIMARYinglib options as
-// specified. See the I2P documentation for a full list of options.
-func (sam *SAM) NewPrimarySessionWithSignature(id string, keys i2pkeys.I2PKeys, options []string, sigType string) (*PrimarySession, error) {
-	conn, err := sam.newGenericSessionWithSignature("PRIMARY", id, keys, sigType, options, []string{})
-	if err != nil {
-		return nil, err
-	}
-	return &PrimarySession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), sigType, sam.Config, nil, nil}, nil
-}
-
-// Creates a new session with the style of either "STREAM", "DATAGRAM" or "RAW",
-// for a new I2P tunnel with name id, using the cypher keys specified, with the
-// I2CP/streaminglib-options as specified. Extra arguments can be specified by
-// setting extra to something else than []string{}.
-// This sam3 instance is now a session
-func (sam *PrimarySession) newGenericSubSession(style, id string, extras []string) (net.Conn, error) {
-	return sam.newGenericSubSessionWithSignature(style, id, extras)
-}
-
-func (sam *PrimarySession) newGenericSubSessionWithSignature(style, id string, extras []string) (net.Conn, error) {
-	return sam.newGenericSubSessionWithSignatureAndPorts(style, id, "0", "0", extras)
-}
-
-// Creates a new session with the style of either "STREAM", "DATAGRAM" or "RAW",
-// for a new I2P tunnel with name id, using the cypher keys specified, with the
-// I2CP/streaminglib-options as specified. Extra arguments can be specified by
-// setting extra to something else than []string{}.
-// This sam3 instance is now a session
-func (sam *PrimarySession) newGenericSubSessionWithSignatureAndPorts(style, id, from, to string, extras []string) (net.Conn, error) {
-
-	conn := sam.conn
-	fp := ""
-	tp := ""
-	if from != "0" {
-		fp = " FROM_PORT=" + from
-	}
-	if to != "0" {
-		tp = " TO_PORT=" + to
-	}
-	scmsg := []byte("SESSION ADD STYLE=" + style + fp + tp + " ID=" + id + " " + strings.Join(extras, " ") + "\n")
-	for m, i := 0, 0; m != len(scmsg); i++ {
-		if i == 15 {
-			conn.Close()
-			return nil, errors.New("writing to SAM failed")
-		}
-		n, err := conn.Write(scmsg[m:])
-		if err != nil {
-			conn.Close()
-			return nil, err
-		}
-		m += n
-	}
-	buf := make([]byte, 4096)
-	n, err := conn.Read(buf)
-	if err != nil {
-		conn.Close()
-		return nil, err
-	}
-	text := string(buf[:n])
-	if strings.HasPrefix(text, session_ADDOK) {
-		//if sam.keys.String() != text[len(session_ADDOK):len(text)-1] {
-		//conn.Close()
-		//return nil, errors.New("SAMv3 created a tunnel with keys other than the ones we asked it for")
-		//}
-		return conn, nil //&StreamSession{id, conn, keys, nil, sync.RWMutex{}, nil}, nil
-	} else if text == session_DUPLICATE_ID {
-		conn.Close()
-		return nil, errors.New("Duplicate tunnel name")
-	} else if text == session_DUPLICATE_DEST {
-		conn.Close()
-		return nil, errors.New("Duplicate destination")
-	} else if text == session_INVALID_KEY {
-		conn.Close()
-		return nil, errors.New("Invalid key")
-	} else if strings.HasPrefix(text, session_I2P_ERROR) {
-		conn.Close()
-		return nil, errors.New("I2P error " + text[len(session_I2P_ERROR):])
-	} else {
-		conn.Close()
-		return nil, errors.New("Unable to parse SAMv3 reply: " + text)
-	}
-}
-
-// Creates a new StreamSession with the I2CP- and streaminglib options as
-// specified. See the I2P documentation for a full list of options.
-func (sam *PrimarySession) NewStreamSubSession(id string) (*StreamSession, error) {
-	s := RandString()
-	conn, err := sam.newGenericSubSession("STREAM", id+s, []string{})
-	if err != nil {
-		return nil, err
-	}
-	return &StreamSession{sam.Config.I2PConfig.Sam(), id + s, conn, sam.keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, "0", "0"}, nil
-}
-
-// Creates a new StreamSession with the I2CP- and streaminglib options as
-// specified. See the I2P documentation for a full list of options.
-func (sam *PrimarySession) NewUniqueStreamSubSession(id string) (*StreamSession, error) {
-	s := RandString()
-	conn, err := sam.newGenericSubSession("STREAM", id+s, []string{})
-	if err != nil {
-		return nil, err
-	}
-	return &StreamSession{sam.Config.I2PConfig.Sam(), id + s, conn, sam.keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, randport(), "0"}, nil
-}
-
-// Creates a new StreamSession with the I2CP- and streaminglib options as
-// specified. See the I2P documentation for a full list of options.
-func (sam *PrimarySession) NewStreamSubSessionWithPorts(id, from, to string) (*StreamSession, error) {
-	conn, err := sam.newGenericSubSessionWithSignatureAndPorts("STREAM", id, from, to, []string{})
-	if err != nil {
-		return nil, err
-	}
-	return &StreamSession{sam.Config.I2PConfig.Sam(), id, conn, sam.keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, from, to}, nil
-}
-
-/*
-func (s *PrimarySession) I2PListener(name string) (*StreamListener, error) {
-	listener, err := s.NewStreamSubSession(name)
-	if err != nil {
-		return nil, err
-	}
-	return listener.Listen()
-}
-*/
-
-// Creates a new datagram session. udpPort is the UDP port SAM is listening on,
-// and if you set it to zero, it will use SAMs standard UDP port.
-func (s *PrimarySession) NewDatagramSubSession(id string, udpPort int) (*DatagramSession, error) {
-	if udpPort > 65335 || udpPort < 0 {
-		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
-	}
-	if udpPort == 0 {
-		udpPort = 7655
-	}
-	lhost, _, err := net.SplitHostPort(s.conn.LocalAddr().String())
-	if err != nil {
-		s.Close()
-		return nil, err
-	}
-	lUDPAddr, err := net.ResolveUDPAddr("udp4", lhost+":0")
-	if err != nil {
-		return nil, err
-	}
-	udpconn, err := net.ListenUDP("udp4", lUDPAddr)
-	if err != nil {
-		return nil, err
-	}
-	rhost, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
-	if err != nil {
-		s.Close()
-		return nil, err
-	}
-	rUDPAddr, err := net.ResolveUDPAddr("udp4", rhost+":"+strconv.Itoa(udpPort))
-	if err != nil {
-		return nil, err
-	}
-	_, lport, err := net.SplitHostPort(udpconn.LocalAddr().String())
-	conn, err := s.newGenericSubSession("DATAGRAM", id, []string{"PORT=" + lport})
-	if err != nil {
-		return nil, err
-	}
-	return &DatagramSession{s.Config.I2PConfig.Sam(), id, conn, udpconn, s.keys, rUDPAddr, nil}, nil
-}
-
-// Creates a new raw session. udpPort is the UDP port SAM is listening on,
-// and if you set it to zero, it will use SAMs standard UDP port.
-func (s *PrimarySession) NewRawSubSession(id string, udpPort int) (*RawSession, error) {
-	if udpPort > 65335 || udpPort < 0 {
-		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
-	}
-	if udpPort == 0 {
-		udpPort = 7655
-	}
-	lhost, _, err := net.SplitHostPort(s.conn.LocalAddr().String())
-	if err != nil {
-		s.Close()
-		return nil, err
-	}
-	lUDPAddr, err := net.ResolveUDPAddr("udp4", lhost+":0")
-	if err != nil {
-		return nil, err
-	}
-	udpconn, err := net.ListenUDP("udp4", lUDPAddr)
-	if err != nil {
-		return nil, err
-	}
-	rhost, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
-	if err != nil {
-		s.Close()
-		return nil, err
-	}
-	rUDPAddr, err := net.ResolveUDPAddr("udp4", rhost+":"+strconv.Itoa(udpPort))
-	if err != nil {
-		return nil, err
-	}
-	_, lport, err := net.SplitHostPort(udpconn.LocalAddr().String())
-	//	conn, err := s.newGenericSubSession("RAW", id, s.keys, options, []string{"PORT=" + lport})
-	conn, err := s.newGenericSubSession("RAW", id, []string{"PORT=" + lport})
-	if err != nil {
-		return nil, err
-	}
-	return &RawSession{s.Config.I2PConfig.Sam(), id, conn, udpconn, s.keys, rUDPAddr}, nil
-}
--- a/primary_datagram_test.go
+++ b/primary_datagram_test.go
@@ -1,151 +0,0 @@
-// +build nettest
-
-package sam3
-
-import (
-	"fmt"
-	"log"
-	"testing"
-	"time"
-)
-
-func Test_PrimaryDatagramServerClient(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	fmt.Println("Test_PrimaryDatagramServerClient")
-	earlysam, err := NewSAM(yoursam)
-	if err != nil {
-		t.Fail()
-		return
-	}
-	defer earlysam.Close()
-	keys, err := earlysam.NewKeys()
-	if err != nil {
-		t.Fail()
-		return
-	}
-
-	sam, err := earlysam.NewPrimarySession("PrimaryTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
-	if err != nil {
-		t.Fail()
-		return
-	}
-	defer sam.Close()
-	//	fmt.Println("\tServer: My address: " + keys.Addr().Base32())
-	fmt.Println("\tServer: Creating tunnel")
-	ds, err := sam.NewDatagramSubSession("PrimaryTunnel"+RandString(), 0)
-	if err != nil {
-		fmt.Println("Server: Failed to create tunnel: " + err.Error())
-		t.Fail()
-		return
-	}
-	defer ds.Close()
-	c, w := make(chan bool), make(chan bool)
-	go func(c, w chan (bool)) {
-		sam2, err := NewSAM(yoursam)
-		if err != nil {
-			c <- false
-			return
-		}
-		defer sam2.Close()
-		keys, err := sam2.NewKeys()
-		if err != nil {
-			c <- false
-			return
-		}
-		fmt.Println("\tClient: Creating tunnel")
-		ds2, err := sam2.NewDatagramSession("PRIMARYClientTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"}, 0)
-		if err != nil {
-			c <- false
-			return
-		}
-		defer ds2.Close()
-		//		fmt.Println("\tClient: Servers address: " + ds.LocalAddr().Base32())
-		//		fmt.Println("\tClient: Clients address: " + ds2.LocalAddr().Base32())
-		fmt.Println("\tClient: Tries to send primary to server")
-		for {
-			select {
-			default:
-				_, err = ds2.WriteTo([]byte("Hello primary-world! <3 <3 <3 <3 <3 <3"), ds.LocalAddr())
-				if err != nil {
-					fmt.Println("\tClient: Failed to send primary: " + err.Error())
-					c <- false
-					return
-				}
-				time.Sleep(5 * time.Second)
-			case <-w:
-				fmt.Println("\tClient: Sent primary, quitting.")
-				return
-			}
-		}
-		c <- true
-	}(c, w)
-	buf := make([]byte, 512)
-	fmt.Println("\tServer: ReadFrom() waiting...")
-	n, _, err := ds.ReadFrom(buf)
-	w <- true
-	if err != nil {
-		fmt.Println("\tServer: Failed to ReadFrom(): " + err.Error())
-		t.Fail()
-		return
-	}
-	fmt.Println("\tServer: Received primary: " + string(buf[:n]))
-	//	fmt.Println("\tServer: Senders address was: " + saddr.Base32())
-}
-
-func ExamplePrimaryDatagramSession() {
-	// Creates a new PrimarySession, then creates a Datagram subsession on top of it
-
-	const samBridge = "127.0.0.1:7656"
-
-	earlysam, err := NewSAM(samBridge)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	defer earlysam.Close()
-	keys, err := earlysam.NewKeys()
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	myself := keys.Addr()
-
-	sam, err := earlysam.NewPrimarySession("PrimaryTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	defer sam.Close()
-
-	// See the example Option_* variables.
-	dg, err := sam.NewDatagramSubSession("DGTUN"+RandString(), 0)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	defer dg.Close()
-	someone, err := earlysam.Lookup("zzz.i2p")
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-
-	dg.WriteTo([]byte("Hello stranger!"), someone)
-	dg.WriteTo([]byte("Hello myself!"), myself)
-
-	buf := make([]byte, 31*1024)
-	n, _, err := dg.ReadFrom(buf)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	log.Println("Got message: '" + string(buf[:n]) + "'")
-	fmt.Println("Got message: " + string(buf[:n]))
-
-	return
-	// Output:
-	//Got message: Hello myself!
-}
--- a/primary_stream_test.go
+++ b/primary_stream_test.go
@@ -1,307 +0,0 @@
-// +build nettest
-
-package sam3
-
-import (
-	"fmt"
-	"log"
-	"strings"
-	"testing"
-
-	"github.com/eyedeekay/sam3/i2pkeys"
-)
-
-func Test_PrimaryStreamingDial(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-	fmt.Println("Test_PrimaryStreamingDial")
-	earlysam, err := NewSAM(yoursam)
-	if err != nil {
-		t.Fail()
-		return
-	}
-	defer earlysam.Close()
-	keys, err := earlysam.NewKeys()
-	if err != nil {
-		t.Fail()
-		return
-	}
-
-	sam, err := earlysam.NewPrimarySession("PrimaryTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
-	if err != nil {
-		t.Fail()
-		return
-	}
-	defer sam.Close()
-	fmt.Println("\tBuilding tunnel")
-	ss, err := sam.NewStreamSubSession("primaryStreamTunnel")
-	if err != nil {
-		fmt.Println(err.Error())
-		t.Fail()
-		return
-	}
-	defer ss.Close()
-	fmt.Println("\tNotice: This may fail if your I2P node is not well integrated in the I2P network.")
-	fmt.Println("\tLooking up i2p-projekt.i2p")
-	forumAddr, err := earlysam.Lookup("i2p-projekt.i2p")
-	if err != nil {
-		fmt.Println(err.Error())
-		t.Fail()
-		return
-	}
-	fmt.Println("\tDialing i2p-projekt.i2p(", forumAddr.Base32(), forumAddr.DestHash().Hash(), ")")
-	conn, err := ss.DialI2P(forumAddr)
-	if err != nil {
-		fmt.Println(err.Error())
-		t.Fail()
-		return
-	}
-	defer conn.Close()
-	fmt.Println("\tSending HTTP GET /")
-	if _, err := conn.Write([]byte("GET /\n")); err != nil {
-		fmt.Println(err.Error())
-		t.Fail()
-		return
-	}
-	buf := make([]byte, 4096)
-	n, err := conn.Read(buf)
-	if !strings.Contains(strings.ToLower(string(buf[:n])), "http") && !strings.Contains(strings.ToLower(string(buf[:n])), "html") {
-		fmt.Printf("\tProbably failed to StreamSession.DialI2P(i2p-projekt.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
-	} else {
-		fmt.Println("\tRead HTTP/HTML from i2p-projekt.i2p")
-	}
-}
-
-func Test_PrimaryStreamingServerClient(t *testing.T) {
-	if testing.Short() {
-		return
-	}
-
-	fmt.Println("Test_StreamingServerClient")
-	earlysam, err := NewSAM(yoursam)
-	if err != nil {
-		t.Fail()
-		return
-	}
-	defer earlysam.Close()
-	keys, err := earlysam.NewKeys()
-	if err != nil {
-		t.Fail()
-		return
-	}
-
-	sam, err := earlysam.NewPrimarySession("PrimaryServerClientTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
-	if err != nil {
-		t.Fail()
-		return
-	}
-	defer sam.Close()
-	fmt.Println("\tServer: Creating tunnel")
-	ss, err := sam.NewStreamSubSession("primaryExampleServerTun")
-	if err != nil {
-		return
-	}
-	defer ss.Close()
-	c, w := make(chan bool), make(chan bool)
-	go func(c, w chan (bool)) {
-		if !(<-w) {
-			return
-		}
-		/*sam2, err := NewSAM(yoursam)
-		if err != nil {
-			c <- false
-			return
-		}
-		defer sam2.Close()
-		keys, err := sam2.NewKeys()
-		if err != nil {
-			c <- false
-			return
-		}*/
-		fmt.Println("\tClient: Creating tunnel")
-		ss2, err := sam.NewStreamSubSession("primaryExampleClientTun")
-		if err != nil {
-			c <- false
-			return
-		}
-		defer ss2.Close()
-		fmt.Println("\tClient: Connecting to server")
-		conn, err := ss2.DialI2P(ss.Addr())
-		if err != nil {
-			c <- false
-			return
-		}
-		fmt.Println("\tClient: Connected to tunnel")
-		defer conn.Close()
-		_, err = conn.Write([]byte("Hello world <3 <3 <3 <3 <3 <3"))
-		if err != nil {
-			c <- false
-			return
-		}
-		c <- true
-	}(c, w)
-	l, err := ss.Listen()
-	if err != nil {
-		fmt.Println("ss.Listen(): " + err.Error())
-		t.Fail()
-		w <- false
-		return
-	}
-	defer l.Close()
-	w <- true
-	fmt.Println("\tServer: Accept()ing on tunnel")
-	conn, err := l.Accept()
-	if err != nil {
-		t.Fail()
-		fmt.Println("Failed to Accept(): " + err.Error())
-		return
-	}
-	defer conn.Close()
-	buf := make([]byte, 512)
-	n, err := conn.Read(buf)
-	fmt.Printf("\tClient exited successfully: %t\n", <-c)
-	fmt.Println("\tServer: received from Client: " + string(buf[:n]))
-}
-
-func ExamplePrimaryStreamSession() {
-	// Creates a new StreamingSession, dials to idk.i2p and gets a SAMConn
-	// which behaves just like a normal net.Conn.
-
-	const samBridge = "127.0.0.1:7656"
-
-	earlysam, err := NewSAM(yoursam)
-	if err != nil {
-		log.Fatal(err.Error())
-		return
-	}
-	defer earlysam.Close()
-	keys, err := earlysam.NewKeys()
-	if err != nil {
-		log.Fatal(err.Error())
-		return
-	}
-
-	sam, err := earlysam.NewPrimarySession("PrimaryServerClientTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
-	if err != nil {
-		log.Fatal(err.Error())
-		return
-	}
-	defer sam.Close()
-	// See the example Option_* variables.
-	ss, err := sam.NewStreamSubSession("stream_example")
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	ss.Close()
-	someone, err := earlysam.Lookup("idk.i2p")
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-
-	conn, err := ss.DialI2P(someone)
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	defer conn.Close()
-	fmt.Println("Sending HTTP GET /")
-	if _, err := conn.Write([]byte("GET /\n")); err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	buf := make([]byte, 4096)
-	n, err := conn.Read(buf)
-	if !strings.Contains(strings.ToLower(string(buf[:n])), "http") && !strings.Contains(strings.ToLower(string(buf[:n])), "html") {
-		fmt.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
-		log.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
-	} else {
-		fmt.Println("Read HTTP/HTML from idk.i2p")
-		log.Println("Read HTTP/HTML from idk.i2p")
-	}
-	return
-
-	// Output:
-	//Sending HTTP GET /
-	//Read HTTP/HTML from idk.i2p
-}
-
-func ExamplePrimaryStreamListener() {
-	// One server Accept()ing on a StreamListener, and one client that Dials
-	// through I2P to the server. Server writes "Hello world!" through a SAMConn
-	// (which implements net.Conn) and the client prints the message.
-
-	const samBridge = "127.0.0.1:7656"
-
-	earlysam, err := NewSAM(yoursam)
-	if err != nil {
-		log.Fatal(err.Error())
-		return
-	}
-	defer earlysam.Close()
-	keys, err := earlysam.NewKeys()
-	if err != nil {
-		log.Fatal(err.Error())
-		return
-	}
-
-	sam, err := earlysam.NewPrimarySession("PrimaryListenerTunnel", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
-	if err != nil {
-		log.Fatal(err.Error())
-		return
-	}
-	defer sam.Close()
-
-	quit := make(chan bool)
-
-	// Client connecting to the server
-	go func(server i2pkeys.I2PAddr) {
-		cs, err := sam.NewStreamSubSession("client_example")
-		if err != nil {
-			fmt.Println(err.Error())
-			quit <- false
-			return
-		}
-		defer cs.Close()
-		conn, err := cs.DialI2P(server)
-		if err != nil {
-			fmt.Println(err.Error())
-			quit <- false
-			return
-		}
-		buf := make([]byte, 256)
-		n, err := conn.Read(buf)
-		if err != nil {
-			fmt.Println(err.Error())
-			quit <- false
-			return
-		}
-		fmt.Println(string(buf[:n]))
-		quit <- true
-	}(keys.Addr()) // end of client
-
-	ss, err := sam.NewStreamSubSession("server_example")
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	defer ss.Close()
-	l, err := ss.Listen()
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	conn, err := l.Accept()
-	if err != nil {
-		fmt.Println(err.Error())
-		return
-	}
-	conn.Write([]byte("Hello world!"))
-
-	<-quit // waits for client to die, for example only
-
-	// Output:
-	//Hello world!
-}
--- a/raw.go
+++ b/raw.go
@@ -6,8 +6,10 @@ import (
 	"net"
 	"strconv"
 	"time"
+)

-	"github.com/eyedeekay/sam3/i2pkeys"
+import (
+	. "github.com/eyedeekay/sam3/i2pkeys"
 )

 // The RawSession provides no authentication of senders, and there is no sender
@@ -17,24 +19,24 @@ import (
 // that is needed. Raw datagrams may be at most 32 kB in size. There is no
 // overhead of authentication, which is the reason to use this..
 type RawSession struct {
-	samAddr  string          // address to the sam bridge (ipv4:port)
-	id       string          // tunnel name
-	conn     net.Conn        // connection to sam bridge
-	udpconn  *net.UDPConn    // used to deliver datagrams
-	keys     i2pkeys.I2PKeys // i2p destination keys
-	rUDPAddr *net.UDPAddr    // the SAM bridge UDP-port
+	samAddr  string       // address to the sam bridge (ipv4:port)
+	id       string       // tunnel name
+	conn     net.Conn     // connection to sam bridge
+	udpconn  *net.UDPConn // used to deliver datagrams
+	keys     I2PKeys      // i2p destination keys
+	rUDPAddr *net.UDPAddr // the SAM bridge UDP-port
 }

 // Creates a new raw session. udpPort is the UDP port SAM is listening on,
 // and if you set it to zero, it will use SAMs standard UDP port.
-func (s *SAM) NewRawSession(id string, keys i2pkeys.I2PKeys, options []string, udpPort int) (*RawSession, error) {
+func (s *SAM) NewRawSession(id string, keys I2PKeys, options []string, udpPort int) (*RawSession, error) {
 	if udpPort > 65335 || udpPort < 0 {
 		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
 	}
 	if udpPort == 0 {
 		udpPort = 7655
 	}
-	lhost, _, err := net.SplitHostPort(s.conn.LocalAddr().String())
+	lhost, _, err := net.SplitHostPort(s.Conn.LocalAddr().String())
 	if err != nil {
 		s.Close()
 		return nil, err
@@ -47,7 +49,7 @@ func (s *SAM) NewRawSession(id string, keys i2pkeys.I2PKeys, options []string, u
 	if err != nil {
 		return nil, err
 	}
-	rhost, _, err := net.SplitHostPort(s.conn.RemoteAddr().String())
+	rhost, _, err := net.SplitHostPort(s.Conn.RemoteAddr().String())
 	if err != nil {
 		s.Close()
 		return nil, err
@@ -85,7 +87,7 @@ func (s *RawSession) Read(b []byte) (n int, err error) {

 // Sends one raw datagram to the destination specified. At the time of writing,
 // maximum size is 32 kilobyte, but this may change in the future.
-func (s *RawSession) WriteTo(b []byte, addr i2pkeys.I2PAddr) (n int, err error) {
+func (s *RawSession) WriteTo(b []byte, addr I2PAddr) (n int, err error) {
 	header := []byte("3.0 " + s.id + " " + addr.String() + "\n")
 	msg := append(header, b...)
 	n, err = s.udpconn.WriteToUDP(msg, s.rUDPAddr)
@@ -103,7 +105,7 @@ func (s *RawSession) Close() error {
 }

 // Returns the local I2P destination of the RawSession.
-func (s *RawSession) LocalAddr() i2pkeys.I2PAddr {
+func (s *RawSession) LocalAddr() I2PAddr {
 	return s.keys.Addr()
 }

--- a/resolver.go
+++ b/resolver.go
@@ -5,8 +5,10 @@ import (
 	"bytes"
 	"errors"
 	"strings"
+)

-	"github.com/eyedeekay/sam3/i2pkeys"
+import (
+	. "github.com/eyedeekay/sam3/i2pkeys"
 )

 type SAMResolver struct {
@@ -31,19 +33,19 @@ func NewFullSAMResolver(address string) (*SAMResolver, error) {

 // Performs a lookup, probably this order: 1) routers known addresses, cached
 // addresses, 3) by asking peers in the I2P network.
-func (sam *SAMResolver) Resolve(name string) (i2pkeys.I2PAddr, error) {
-	if _, err := sam.conn.Write([]byte("NAMING LOOKUP NAME=" + name + "\r\n")); err != nil {
+func (sam *SAMResolver) Resolve(name string) (I2PAddr, error) {
+	if _, err := sam.Conn.Write([]byte("NAMING LOOKUP NAME=" + name + "\n")); err != nil {
 		sam.Close()
-		return i2pkeys.I2PAddr(""), err
+		return I2PAddr(""), err
 	}
 	buf := make([]byte, 4096)
-	n, err := sam.conn.Read(buf)
+	n, err := sam.Conn.Read(buf)
 	if err != nil {
 		sam.Close()
-		return i2pkeys.I2PAddr(""), err
+		return I2PAddr(""), err
 	}
 	if n <= 13 || !strings.HasPrefix(string(buf[:n]), "NAMING REPLY ") {
-		return i2pkeys.I2PAddr(""), errors.New("Failed to parse.")
+		return I2PAddr(""), errors.New("Failed to parse.")
 	}
 	s := bufio.NewScanner(bytes.NewReader(buf[13:n]))
 	s.Split(bufio.ScanWords)
@@ -51,7 +53,6 @@ func (sam *SAMResolver) Resolve(name string) (i2pkeys.I2PAddr, error) {
 	errStr := ""
 	for s.Scan() {
 		text := s.Text()
-		//log.Println("SAM3", text)
 		if text == "RESULT=OK" {
 			continue
 		} else if text == "RESULT=INVALID_KEY" {
@@ -61,12 +62,12 @@ func (sam *SAMResolver) Resolve(name string) (i2pkeys.I2PAddr, error) {
 		} else if text == "NAME="+name {
 			continue
 		} else if strings.HasPrefix(text, "VALUE=") {
-			return i2pkeys.I2PAddr(text[6:]), nil
+			return I2PAddr(text[6:]), nil
 		} else if strings.HasPrefix(text, "MESSAGE=") {
 			errStr += " " + text[8:]
 		} else {
 			continue
 		}
 	}
-	return i2pkeys.I2PAddr(""), errors.New(errStr)
+	return I2PAddr(""), errors.New(errStr)
 }
--- a/sam3.go
+++ b/sam3.go
@@ -6,26 +6,23 @@ import (
 	"bytes"
 	"errors"
 	"io"
-	"math/rand"
 	"net"
 	"os"
 	"strings"
-
-	"github.com/eyedeekay/sam3/i2pkeys"
 )

 import (
+	"github.com/eyedeekay/ramp/config"
+	. "github.com/eyedeekay/ramp/emit"
 	. "github.com/eyedeekay/sam3/i2pkeys"
 )

 // Used for controlling I2Ps SAMv3.
 type SAM struct {
-	address  string
-	conn     net.Conn
-	resolver *SAMResolver
+	//address  string
+	Conn     net.Conn
+	Resolver *SAMResolver
 	Config   SAMEmit
-	keys     *i2pkeys.I2PKeys
-	sigType  int
 }

 const (
@@ -45,22 +42,13 @@ const (
 	Sig_EdDSA_SHA512_Ed25519 = "SIGNATURE_TYPE=EdDSA_SHA512_Ed25519"
 )

-var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
-
-func RandString() string {
-	n := 4
-	b := make([]rune, n)
-	for i := range b {
-		b[i] = letters[rand.Intn(len(letters))]
-	}
-	return string(b)
-}
-
 // Creates a new controller for the I2P routers SAM bridge.
 func NewSAM(address string) (*SAM, error) {
 	var s SAM
 	// TODO: clean this up
-	conn, err := net.Dial("tcp", address)
+	s.Config.I2PConfig.SetSAMAddress(address)
+    s.Config.SamMax = "3.2"
+	conn, err := net.Dial("tcp", s.Config.I2PConfig.Sam())
 	if err != nil {
 		return nil, err
 	}
@@ -75,10 +63,9 @@ func NewSAM(address string) (*SAM, error) {
 		return nil, err
 	}
 	if strings.Contains(string(buf[:n]), "HELLO REPLY RESULT=OK") {
-		s.Config.I2PConfig.SetSAMAddress(address)
-		s.conn = conn
+		s.Conn = conn
 		//s.Config.I2PConfig.DestinationKeys = nil
-		s.resolver, err = NewSAMResolver(&s)
+		s.Resolver, err = NewSAMResolver(&s)
 		if err != nil {
 			return nil, err
 		}
@@ -93,7 +80,7 @@ func NewSAM(address string) (*SAM, error) {
 	}
 }

-func (sam *SAM) Keys() (k *i2pkeys.I2PKeys) {
+func (sam *SAM) Keys() (k *I2PKeys) {
 	//TODO: copy them?
 	k = &sam.Config.I2PConfig.DestinationKeys
 	return
@@ -101,8 +88,8 @@ func (sam *SAM) Keys() (k *i2pkeys.I2PKeys) {

 // read public/private keys from an io.Reader
 func (sam *SAM) ReadKeys(r io.Reader) (err error) {
-	var keys i2pkeys.I2PKeys
-	keys, err = i2pkeys.LoadKeysIncompat(r)
+	var keys I2PKeys
+	keys, err = LoadKeysIncompat(r)
 	if err == nil {
 		sam.Config.I2PConfig.DestinationKeys = keys
 	}
@@ -110,7 +97,7 @@ func (sam *SAM) ReadKeys(r io.Reader) (err error) {
 }

 // if keyfile fname does not exist
-func (sam *SAM) EnsureKeyfile(fname string) (keys i2pkeys.I2PKeys, err error) {
+func (sam *SAM) EnsureKeyfile(fname string) (keys I2PKeys, err error) {
 	if fname == "" {
 		// transient
 		keys, err = sam.NewKeys()
@@ -129,7 +116,7 @@ func (sam *SAM) EnsureKeyfile(fname string) (keys i2pkeys.I2PKeys, err error) {
 				var f io.WriteCloser
 				f, err = os.OpenFile(fname, os.O_WRONLY|os.O_CREATE, 0600)
 				if err == nil {
-					err = i2pkeys.StoreKeysIncompat(keys, f)
+					err = StoreKeysIncompat(keys, f)
 					f.Close()
 				}
 			}
@@ -138,7 +125,7 @@ func (sam *SAM) EnsureKeyfile(fname string) (keys i2pkeys.I2PKeys, err error) {
 			var f *os.File
 			f, err = os.Open(fname)
 			if err == nil {
-				keys, err = i2pkeys.LoadKeysIncompat(f)
+				keys, err = LoadKeysIncompat(f)
 				if err == nil {
 					sam.Config.I2PConfig.DestinationKeys = keys
 				}
@@ -151,18 +138,18 @@ func (sam *SAM) EnsureKeyfile(fname string) (keys i2pkeys.I2PKeys, err error) {
 // Creates the I2P-equivalent of an IP address, that is unique and only the one
 // who has the private keys can send messages from. The public keys are the I2P
 // desination (the address) that anyone can send messages to.
-func (sam *SAM) NewKeys(sigType ...string) (i2pkeys.I2PKeys, error) {
+func (sam *SAM) NewKeys(sigType ...string) (I2PKeys, error) {
 	sigtmp := ""
 	if len(sigType) > 0 {
 		sigtmp = sigType[0]
 	}
-	if _, err := sam.conn.Write([]byte("DEST GENERATE " + sigtmp + "\n")); err != nil {
-		return i2pkeys.I2PKeys{}, err
+	if _, err := sam.Conn.Write([]byte("DEST GENERATE " + sigtmp + "\n")); err != nil {
+		return I2PKeys{}, err
 	}
 	buf := make([]byte, 8192)
-	n, err := sam.conn.Read(buf)
+	n, err := sam.Conn.Read(buf)
 	if err != nil {
-		return i2pkeys.I2PKeys{}, err
+		return I2PKeys{}, err
 	}
 	s := bufio.NewScanner(bytes.NewReader(buf[:n]))
 	s.Split(bufio.ScanWords)
@@ -179,7 +166,7 @@ func (sam *SAM) NewKeys(sigType ...string) (i2pkeys.I2PKeys, error) {
 		} else if strings.HasPrefix(text, "PRIV=") {
 			priv = text[5:]
 		} else {
-			return i2pkeys.I2PKeys{}, errors.New("Failed to parse keys.")
+			return I2PKeys{}, errors.New("Failed to parse keys.")
 		}
 	}
 	return NewKeys(I2PAddr(pub), priv), nil
@@ -187,8 +174,8 @@ func (sam *SAM) NewKeys(sigType ...string) (i2pkeys.I2PKeys, error) {

 // Performs a lookup, probably this order: 1) routers known addresses, cached
 // addresses, 3) by asking peers in the I2P network.
-func (sam *SAM) Lookup(name string) (i2pkeys.I2PAddr, error) {
-	return sam.resolver.Resolve(name)
+func (sam *SAM) Lookup(name string) (I2PAddr, error) {
+	return sam.Resolver.Resolve(name)
 }

 // Creates a new session with the style of either "STREAM", "DATAGRAM" or "RAW",
@@ -196,36 +183,25 @@ func (sam *SAM) Lookup(name string) (i2pkeys.I2PAddr, error) {
 // I2CP/streaminglib-options as specified. Extra arguments can be specified by
 // setting extra to something else than []string{}.
 // This sam3 instance is now a session
-func (sam *SAM) newGenericSession(style, id string, keys i2pkeys.I2PKeys, options []string, extras []string) (net.Conn, error) {
+func (sam *SAM) newGenericSession(style, id string, keys I2PKeys, options []string, extras []string) (net.Conn, error) {
 	return sam.newGenericSessionWithSignature(style, id, keys, Sig_NONE, options, extras)
 }

-func (sam *SAM) newGenericSessionWithSignature(style, id string, keys i2pkeys.I2PKeys, sigType string, options []string, extras []string) (net.Conn, error) {
-	return sam.newGenericSessionWithSignatureAndPorts(style, id, "0", "0", keys, sigType, options, extras)
-}
-
 // Creates a new session with the style of either "STREAM", "DATAGRAM" or "RAW",
 // for a new I2P tunnel with name id, using the cypher keys specified, with the
 // I2CP/streaminglib-options as specified. Extra arguments can be specified by
 // setting extra to something else than []string{}.
 // This sam3 instance is now a session
-func (sam *SAM) newGenericSessionWithSignatureAndPorts(style, id, from, to string, keys i2pkeys.I2PKeys, sigType string, options []string, extras []string) (net.Conn, error) {
+func (sam *SAM) newGenericSessionWithSignature(style, id string, keys I2PKeys, sigType string, options []string, extras []string) (net.Conn, error) {
+	conf, _ := i2pconfig.ConstructEqualsConfig(append(options))
+	sam.Config.I2PConfig = *conf
+	sam.Config.SigType = sigType
+	sam.Config.Style = style
+	sam.Config.DestinationKeys = keys
+	sam.Config.TunName = id

-	optStr := ""
-	for _, opt := range options {
-		optStr += opt + " "
-	}
-
-	conn := sam.conn
-	fp := ""
-	tp := ""
-	if from != "0" {
-		fp = " FROM_PORT=" + from
-	}
-	if to != "0" {
-		tp = " TO_PORT=" + to
-	}
-	scmsg := []byte("SESSION CREATE STYLE=" + style + fp + tp + " ID=" + id + " DESTINATION=" + keys.String() + " " + optStr + strings.Join(extras, " ") + "\n")
+	conn := sam.Conn
+	scmsg := []byte("SESSION CREATE " + sam.Config.SessionStyle() +  sam.Config.ID() + sam.Config.DestinationKey() + sam.Config.SignatureType() + sam.Config.FromPort() + sam.Config.ToPort() + sam.Config.OptStr() + strings.Join(extras, " ") + "\n")
 	for m, i := 0, 0; m != len(scmsg); i++ {
 		if i == 15 {
 			conn.Close()
@@ -271,5 +247,5 @@ func (sam *SAM) newGenericSessionWithSignatureAndPorts(style, id, from, to strin

 // close this sam session
 func (sam *SAM) Close() error {
-	return sam.conn.Close()
+	return sam.Conn.Close()
 }
--- a/stream.go
+++ b/stream.go
@@ -11,16 +11,18 @@ import (
 	"strconv"
 	"strings"
 	"time"
+)

-	"github.com/eyedeekay/sam3/i2pkeys"
+import (
+	. "github.com/eyedeekay/sam3/i2pkeys"
 )

 // Represents a streaming session.
 type StreamSession struct {
-	samAddr  string          // address to the sam bridge (ipv4:port)
-	id       string          // tunnel name
-	conn     net.Conn        // connection to sam
-	keys     i2pkeys.I2PKeys // i2p destination keys
+	samAddr  string   // address to the sam bridge (ipv4:port)
+	id       string   // tunnel name
+	conn     net.Conn // connection to sam
+	keys     I2PKeys  // i2p destination keys
 	Timeout  time.Duration
 	Deadline time.Time
 	sigType  string
@@ -50,18 +52,18 @@ func (ss *StreamSession) Close() error {
 }

 // Returns the I2P destination (the address) of the stream session
-func (ss *StreamSession) Addr() i2pkeys.I2PAddr {
+func (ss *StreamSession) Addr() I2PAddr {
 	return ss.keys.Addr()
 }

 // Returns the keys associated with the stream session
-func (ss *StreamSession) Keys() i2pkeys.I2PKeys {
+func (ss *StreamSession) Keys() I2PKeys {
 	return ss.keys
 }

 // Creates a new StreamSession with the I2CP- and streaminglib options as
 // specified. See the I2P documentation for a full list of options.
-func (sam *SAM) NewStreamSession(id string, keys i2pkeys.I2PKeys, options []string) (*StreamSession, error) {
+func (sam *SAM) NewStreamSession(id string, keys I2PKeys, options []string) (*StreamSession, error) {
 	conn, err := sam.newGenericSession("STREAM", id, keys, options, []string{})
 	if err != nil {
 		return nil, err
@@ -71,7 +73,7 @@ func (sam *SAM) NewStreamSession(id string, keys i2pkeys.I2PKeys, options []stri

 // Creates a new StreamSession with the I2CP- and streaminglib options as
 // specified. See the I2P documentation for a full list of options.
-func (sam *SAM) NewStreamSessionWithSignature(id string, keys i2pkeys.I2PKeys, options []string, sigType string) (*StreamSession, error) {
+func (sam *SAM) NewStreamSessionWithSignature(id string, keys I2PKeys, options []string, sigType string) (*StreamSession, error) {
 	conn, err := sam.newGenericSessionWithSignature("STREAM", id, keys, sigType, options, []string{})
 	if err != nil {
 		return nil, err
@@ -81,23 +83,23 @@ func (sam *SAM) NewStreamSessionWithSignature(id string, keys i2pkeys.I2PKeys, o

 // Creates a new StreamSession with the I2CP- and streaminglib options as
 // specified. See the I2P documentation for a full list of options.
-func (sam *SAM) NewStreamSessionWithSignatureAndPorts(id, from, to string, keys i2pkeys.I2PKeys, options []string, sigType string) (*StreamSession, error) {
-	conn, err := sam.newGenericSessionWithSignatureAndPorts("STREAM", id, from, to, keys, sigType, options, []string{})
+func (sam *SAM) NewStreamSessionWithSignatureAndPorts(id string, keys I2PKeys, options []string, sigType string) (*StreamSession, error) {
+	conn, err := sam.newGenericSessionWithSignature("STREAM", id, keys, sigType, options, []string{})
 	if err != nil {
 		return nil, err
 	}
-	return &StreamSession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), sigType, from, to}, nil
+	return &StreamSession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), sigType, sam.Config.Fromport, sam.Config.Toport}, nil
 }

 // lookup name, convienence function
-func (s *StreamSession) Lookup(name string) (i2pkeys.I2PAddr, error) {
+func (s *StreamSession) Lookup(name string) (I2PAddr, error) {
 	sam, err := NewSAM(s.samAddr)
 	if err == nil {
 		addr, err := sam.Lookup(name)
 		sam.Close()
 		return addr, err
 	}
-	return i2pkeys.I2PAddr(""), err
+	return I2PAddr(""), err
 }

 // context-aware dialer, eventually...
@@ -119,7 +121,7 @@ func (s *StreamSession) DialContextI2P(ctx context.Context, n, addr string) (*SA
 		}
 	}

-	i2paddr, err := i2pkeys.NewI2PAddrFromString(addr)
+	i2paddr, err := NewI2PAddrFromString(addr)
 	if err != nil {
 		return nil, err
 	}
@@ -161,7 +163,7 @@ func (s *StreamSession) deadline(ctx context.Context, now time.Time) (earliest t
 // implement net.Dialer
 func (s *StreamSession) Dial(n, addr string) (c net.Conn, err error) {

-	var i2paddr i2pkeys.I2PAddr
+	var i2paddr I2PAddr
 	var host string
 	host, _, err = net.SplitHostPort(addr)
 	if err == nil {
@@ -171,7 +173,7 @@ func (s *StreamSession) Dial(n, addr string) (c net.Conn, err error) {
 			i2paddr, err = s.Lookup(host)
 		} else {
 			// probably a destination
-			i2paddr = i2pkeys.I2PAddr(host)
+			i2paddr = I2PAddr(host)
 		}
 		if err == nil {
 			return s.DialI2P(i2paddr)
@@ -181,13 +183,14 @@ func (s *StreamSession) Dial(n, addr string) (c net.Conn, err error) {
 }

 // Dials to an I2P destination and returns a SAMConn, which implements a net.Conn.
-func (s *StreamSession) DialI2P(addr i2pkeys.I2PAddr) (*SAMConn, error) {
+func (s *StreamSession) DialI2P(addr I2PAddr) (*SAMConn, error) {
 	sam, err := NewSAM(s.samAddr)
 	if err != nil {
 		return nil, err
 	}
-	conn := sam.conn
-	_, err = conn.Write([]byte("STREAM CONNECT ID=" + s.id + " FROM_PORT=" + s.from + " TO_PORT=" + s.to + " DESTINATION=" + addr.Base64() + " SILENT=false\n"))
+	conn := sam.Conn
+    // + sam.Config.ID()
+	_, err = conn.Write([]byte("STREAM CONNECT ID=" + s.id + sam.Config.FromPort() + sam.Config.ToPort() + " DESTINATION=" + addr.Base64() + " SILENT=false\n"))
 	if err != nil {
 		conn.Close()
 		return nil, err
@@ -246,7 +249,7 @@ type StreamListener struct {
 	// our session id
 	id string
 	// our local address for this sam socket
-	laddr i2pkeys.I2PAddr
+	laddr I2PAddr
 }

 func (l *StreamListener) From() string {
@@ -304,9 +307,9 @@ func (l *StreamListener) AcceptI2P() (*SAMConn, error) {
 	if err == nil {
 		// we connected to sam
 		// send accept() command
-		_, err = io.WriteString(s.conn, "STREAM ACCEPT ID="+l.id+" SILENT=false\n")
+		_, err = io.WriteString(s.Conn, "STREAM ACCEPT ID="+l.id+" SILENT=false\n")
 		// read reply
-		rd := bufio.NewReader(s.conn)
+		rd := bufio.NewReader(s.Conn)
 		// read first line
 		line, err := rd.ReadString(10)
 		log.Println(line)
@@ -323,8 +326,8 @@ func (l *StreamListener) AcceptI2P() (*SAMConn, error) {
 					dest = strings.Trim(dest, "\n")
 					return &SAMConn{
 						laddr: l.laddr,
-						raddr: i2pkeys.I2PAddr(dest),
-						conn:  s.conn,
+						raddr: I2PAddr(dest),
+						conn:  s.Conn,
 					}, nil
 				} else {
 					s.Close()
--- a/stream_test.go
+++ b/stream_test.go
@@ -4,11 +4,12 @@ package sam3

 import (
 	"fmt"
-	"log"
 	"strings"
 	"testing"
+)

-	"github.com/eyedeekay/sam3/i2pkeys"
+import (
+	. "github.com/eyedeekay/sam3/i2pkeys"
 )

 func Test_StreamingDial(t *testing.T) {
@@ -30,7 +31,7 @@ func Test_StreamingDial(t *testing.T) {
 		return
 	}
 	fmt.Println("\tBuilding tunnel")
-	ss, err := sam.NewStreamSession("streamTun", keys, []string{"inbound.length=1", "outbound.length=1", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
+	ss, err := sam.NewStreamSession("streamTun", keys, []string{"inbound.length=0", "outbound.length=0", "inbound.lengthVariance=0", "outbound.lengthVariance=0", "inbound.quantity=1", "outbound.quantity=1"})
 	if err != nil {
 		fmt.Println(err.Error())
 		t.Fail()
@@ -44,7 +45,7 @@ func Test_StreamingDial(t *testing.T) {
 		t.Fail()
 		return
 	}
-	fmt.Println("\tDialing i2p-projekt.i2p(", forumAddr.Base32(), forumAddr.DestHash().Hash(), ")")
+	fmt.Println("\tDialing i2p-projekt.i2p")
 	conn, err := ss.DialI2P(forumAddr)
 	if err != nil {
 		fmt.Println(err.Error())
@@ -150,7 +151,7 @@ func Test_StreamingServerClient(t *testing.T) {
 }

 func ExampleStreamSession() {
-	// Creates a new StreamingSession, dials to idk.i2p and gets a SAMConn
+	// Creates a new StreamingSession, dials to zzz.i2p and gets a SAMConn
 	// which behaves just like a normal net.Conn.

 	const samBridge = "127.0.0.1:7656"
@@ -172,7 +173,7 @@ func ExampleStreamSession() {
 		fmt.Println(err.Error())
 		return
 	}
-	someone, err := sam.Lookup("idk.i2p")
+	someone, err := sam.Lookup("zzz.i2p")
 	if err != nil {
 		fmt.Println(err.Error())
 		return
@@ -192,17 +193,15 @@ func ExampleStreamSession() {
 	buf := make([]byte, 4096)
 	n, err := conn.Read(buf)
 	if !strings.Contains(strings.ToLower(string(buf[:n])), "http") && !strings.Contains(strings.ToLower(string(buf[:n])), "html") {
-		fmt.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
-		log.Printf("Probably failed to StreamSession.DialI2P(idk.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
+		fmt.Printf("Probably failed to StreamSession.DialI2P(zzz.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
 	} else {
-		fmt.Println("Read HTTP/HTML from idk.i2p")
-		log.Println("Read HTTP/HTML from idk.i2p")
+		fmt.Println("Read HTTP/HTML from zzz.i2p")
 	}
 	return

 	// Output:
 	//Sending HTTP GET /
-	//Read HTTP/HTML from idk.i2p
+	//Read HTTP/HTML from zzz.i2p
 }

 func ExampleStreamListener() {
@@ -227,7 +226,7 @@ func ExampleStreamListener() {
 	quit := make(chan bool)

 	// Client connecting to the server
-	go func(server i2pkeys.I2PAddr) {
+	go func(server I2PAddr) {
 		csam, err := NewSAM(samBridge)
 		if err != nil {
 			fmt.Println(err.Error())
--- a/suggestedOptions.go
+++ b/suggestedOptions.go
@@ -10,30 +10,17 @@ var (
 		"inbound.quantity=6", "outbound.quantity=6"}

 	// Suitable for shuffling a lot of traffic.
-	Options_Large = []string{"inbound.length=3", "outbound.length=3",
+	Options_Fat = []string{"inbound.length=3", "outbound.length=3",
 		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
 		"inbound.backupQuantity=1", "outbound.backupQuantity=1",
 		"inbound.quantity=4", "outbound.quantity=4"}

-	// Suitable for shuffling a lot of traffic quickly with minimum
-	// anonymity. Uses 1 hop and multiple tunnels.
-	Options_Wide = []string{"inbound.length=1", "outbound.length=1",
-		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
-		"inbound.backupQuantity=2", "outbound.backupQuantity=2",
-		"inbound.quantity=3", "outbound.quantity=3"}
-
 	// Suitable for shuffling medium amounts of traffic.
 	Options_Medium = []string{"inbound.length=3", "outbound.length=3",
 		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
 		"inbound.backupQuantity=0", "outbound.backupQuantity=0",
 		"inbound.quantity=2", "outbound.quantity=2"}

-	// Sensible defaults for most people
-	Options_Default = []string{"inbound.length=3", "outbound.length=3",
-		"inbound.lengthVariance=0", "outbound.lengthVariance=0",
-		"inbound.backupQuantity=1", "outbound.backupQuantity=1",
-		"inbound.quantity=1", "outbound.quantity=1"}
-
 	// Suitable only for small dataflows, and very short lasting connections:
 	// You only have one tunnel in each direction, so if any of the nodes
 	// through which any of your two tunnels pass through go offline, there will
Author	SHA1	Message	Date
idk	6026a5bc5f	tolerate FROM_PORT and TO_PORT on datagrams	2019-04-29 17:04:13 -04:00
idk	15b139ea53	go fmt	2019-04-29 16:17:24 -04:00
idk	cbcc989bf6	use more retainable configs	2019-04-29 16:16:24 -04:00
idk	9e6b5e1031	further use of ramp	2019-04-29 11:47:38 -04:00
idk	cfcbc666ad	try and reduce some complexity with ramp	2019-04-29 11:10:25 -04:00
idk	d4bff7e8c4	forgot to add moved i2pkeys dir	2019-04-20 14:53:50 -04:00
idk	f34c6f2619	export Conn and Resolver	2019-04-11 18:40:05 -04:00
				`@@ -1 +0,0 @@`
				`golang-github-eyedeekay-sam3_0.3.2.32_source.buildinfo devel optional`