idk/sam3
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

implement UDPConn as well

Browse Source
This commit is contained in:
idk
2019-06-12 23:41:17 -04:00
parent 6f6be01fb2 7438f855cd
commit 99ad6522eb
13 changed files with 110 additions and 89 deletions
Download Patch File Download Diff File Expand all files Collapse all files

12
SAMConn.go
View File

@ -1,18 +1,20 @@
package sam3
import (
"github.com/eyedeekay/sam3/i2pkeys"
"net"
"time"
)
/*
import (
. "github.com/eyedeekay/sam3/i2pkeys"
)
*/
// Implements net.Conn
type SAMConn struct {
laddr I2PAddr
raddr I2PAddr
laddr i2pkeys.I2PAddr
raddr i2pkeys.I2PAddr
conn net.Conn
}
@ -38,7 +40,7 @@ func (sc *SAMConn) LocalAddr() net.Addr {
}
// Implements net.Conn
func (sc *SAMConn) localAddr() I2PAddr {
func (sc *SAMConn) localAddr() i2pkeys.I2PAddr {
return sc.laddr
}
@ -47,7 +49,7 @@ func (sc *SAMConn) RemoteAddr() net.Addr {
}
// Implements net.Conn
func (sc *SAMConn) remoteAddr() I2PAddr {
func (sc *SAMConn) remoteAddr() i2pkeys.I2PAddr {
return sc.raddr
}

8
config.go
View File

@ -4,10 +4,8 @@ import (
"fmt"
"net"
"strconv"
)
import (
. "github.com/eyedeekay/sam3/i2pkeys"
"github.com/eyedeekay/sam3/i2pkeys"
)
// sam config
@ -38,7 +36,7 @@ func (cfg *Config) StreamSession() (session *StreamSession, err error) {
s, err = NewSAM(cfg.Addr)
if err == nil {
// ensure keys exist
var keys I2PKeys
var keys i2pkeys.I2PKeys
keys, err = s.EnsureKeyfile(cfg.Keyfile)
if err == nil {
// create session
@ -55,7 +53,7 @@ func (cfg *Config) DatagramSession() (session *DatagramSession, err error) {
s, err = NewSAM(cfg.Addr)
if err == nil {
// ensure keys exist
var keys I2PKeys
var keys i2pkeys.I2PKeys
keys, err = s.EnsureKeyfile(cfg.Keyfile)
if err == nil {
// determine udp port

26
datagram.go
View File

@ -15,13 +15,13 @@ 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.I2PKeys // i2p destination keys
rUDPAddr *net.UDPAddr // the SAM bridge UDP-port
remoteAddr *i2pkeys.I2PAddr // optional remote I2P address
}
// Creates a new datagram session. udpPort is the UDP port SAM is listening on,
@ -68,7 +68,7 @@ func (s *DatagramSession) B32() string {
}
func (s *DatagramSession) RemoteAddr() net.Addr {
return s.remoteAddr
return s.remoteAddr
}
// Reads one datagram sent to the destination of the DatagramSession. Returns
@ -108,9 +108,9 @@ func (s *DatagramSession) ReadFrom(b []byte) (n int, addr net.Addr, err error) {
}
}
func (s *DatagramSession) Read(b []byte) (n int, err error){
rint, _, rerr := s.ReadFrom(b)
return rint, rerr
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
@ -123,8 +123,8 @@ func (s *DatagramSession) WriteTo(b []byte, addr net.Addr) (n int, err error) {
return n, err
}
func (s *DatagramSession) Write(b []byte) (int, error){
return s.WriteTo(b, s.remoteAddr)
func (s *DatagramSession) Write(b []byte) (int, error) {
return s.WriteTo(b, s.remoteAddr)
}
// Closes the DatagramSession. Implements net.PacketConn

2
datagram_test.go
View File

@ -4,6 +4,7 @@ package sam3
import (
"fmt"
"log"
"testing"
"time"
)
@ -124,6 +125,7 @@ func ExampleDatagramSession() {
fmt.Println(err.Error())
return
}
log.Println("Got message: '" + string(buf[:n]) + "'")
fmt.Println("Got message: " + string(buf[:n]))
return

18
debian/changelog vendored
View File

@ -1,3 +1,4 @@
<<<<<<< HEAD
golang-github-eyedeekay-sam3 (0.3.2.5) bionic; urgency=medium
[ idk ]
@ -6,6 +7,23 @@ golang-github-eyedeekay-sam3 (0.3.2.5) bionic; urgency=medium
* Bug fixes
-- idk <hankhill19580@gmail.com> Thu, 28 Feb 2019 21:40:35 -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
>>>>>>> stable
golang-github-eyedeekay-sam3 (0.0~git20190223.af5a3f3) bionic; urgency=medium

3
debian/control vendored
View File

@ -15,7 +15,8 @@ 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

1
debian/files vendored Normal file
View File

@ -0,0 +1 @@
golang-github-eyedeekay-sam3_0.3.2.01_source.buildinfo devel optional

10
i2pkeys/I2PAddr.go
View File

@ -21,8 +21,8 @@ var (
// a certificate. String() returns you the full content of I2PKeys and Addr()
// returns the public keys.
type I2PKeys struct {
addr I2PAddr // only the public key
both string // both public and private keys
Address I2PAddr // only the public key
Both string // both public and private keys
}
// Creates I2PKeys from an I2PAddr and a public/private keypair string (as
@ -44,19 +44,19 @@ func LoadKeysIncompat(r io.Reader) (k I2PKeys, err error) {
// store keys in non standard format
func StoreKeysIncompat(k I2PKeys, w io.Writer) (err error) {
_, err = io.WriteString(w, k.addr.Base64()+"\n"+k.both)
_, err = io.WriteString(w, k.Address.Base64()+"\n"+k.Both)
return
}
// Returns the public keys of the I2PKeys.
func (k I2PKeys) Addr() I2PAddr {
return k.addr
return k.Address
}
// 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
return k.Both
}
// I2PAddr represents an I2P destination, almost equivalent to an IP address.

22
raw.go
View File

@ -6,10 +6,8 @@ import (
"net"
"strconv"
"time"
)
import (
. "github.com/eyedeekay/sam3/i2pkeys"
"github.com/eyedeekay/sam3/i2pkeys"
)
// The RawSession provides no authentication of senders, and there is no sender
@ -19,17 +17,17 @@ 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 // 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.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, options []string, udpPort int) (*RawSession, error) {
func (s *SAM) NewRawSession(id string, keys i2pkeys.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")
}
@ -87,7 +85,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 I2PAddr) (n int, err error) {
func (s *RawSession) WriteTo(b []byte, addr i2pkeys.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)
@ -105,7 +103,7 @@ func (s *RawSession) Close() error {
}
// Returns the local I2P destination of the RawSession.
func (s *RawSession) LocalAddr() I2PAddr {
func (s *RawSession) LocalAddr() i2pkeys.I2PAddr {
return s.keys.Addr()
}

16
resolver.go
View File

@ -5,10 +5,8 @@ import (
"bytes"
"errors"
"strings"
)
import (
. "github.com/eyedeekay/sam3/i2pkeys"
"github.com/eyedeekay/sam3/i2pkeys"
)
type SAMResolver struct {
@ -33,19 +31,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) (I2PAddr, error) {
func (sam *SAMResolver) Resolve(name string) (i2pkeys.I2PAddr, error) {
if _, err := sam.conn.Write([]byte("NAMING LOOKUP NAME=" + name + "\n")); err != nil {
sam.Close()
return I2PAddr(""), err
return i2pkeys.I2PAddr(""), err
}
buf := make([]byte, 4096)
n, err := sam.conn.Read(buf)
if err != nil {
sam.Close()
return I2PAddr(""), err
return i2pkeys.I2PAddr(""), err
}
if n <= 13 || !strings.HasPrefix(string(buf[:n]), "NAMING REPLY ") {
return I2PAddr(""), errors.New("Failed to parse.")
return i2pkeys.I2PAddr(""), errors.New("Failed to parse.")
}
s := bufio.NewScanner(bytes.NewReader(buf[13:n]))
s.Split(bufio.ScanWords)
@ -62,12 +60,12 @@ func (sam *SAMResolver) Resolve(name string) (I2PAddr, error) {
} else if text == "NAME="+name {
continue
} else if strings.HasPrefix(text, "VALUE=") {
return I2PAddr(text[6:]), nil
return i2pkeys.I2PAddr(text[6:]), nil
} else if strings.HasPrefix(text, "MESSAGE=") {
errStr += " " + text[8:]
} else {
continue
}
}
return I2PAddr(""), errors.New(errStr)
return i2pkeys.I2PAddr(""), errors.New(errStr)
}

34
sam3.go
View File

@ -9,6 +9,8 @@ import (
"net"
"os"
"strings"
"github.com/eyedeekay/sam3/i2pkeys"
)
import (
@ -18,10 +20,12 @@ import (
// Used for controlling I2Ps SAMv3.
type SAM struct {
//address string
address string
conn net.Conn
resolver *SAMResolver
Config SAMEmit
keys *i2pkeys.I2PKeys
sigType int
}
const (
@ -78,7 +82,7 @@ func NewSAM(address string) (*SAM, error) {
}
}
func (sam *SAM) Keys() (k *I2PKeys) {
func (sam *SAM) Keys() (k *i2pkeys.I2PKeys) {
//TODO: copy them?
k = &sam.Config.I2PConfig.DestinationKeys
return
@ -86,8 +90,8 @@ func (sam *SAM) Keys() (k *I2PKeys) {
// read public/private keys from an io.Reader
func (sam *SAM) ReadKeys(r io.Reader) (err error) {
var keys I2PKeys
keys, err = LoadKeysIncompat(r)
var keys i2pkeys.I2PKeys
keys, err = i2pkeys.LoadKeysIncompat(r)
if err == nil {
sam.Config.I2PConfig.DestinationKeys = keys
}
@ -95,7 +99,7 @@ func (sam *SAM) ReadKeys(r io.Reader) (err error) {
}
// if keyfile fname does not exist
func (sam *SAM) EnsureKeyfile(fname string) (keys I2PKeys, err error) {
func (sam *SAM) EnsureKeyfile(fname string) (keys i2pkeys.I2PKeys, err error) {
if fname == "" {
// transient
keys, err = sam.NewKeys()
@ -114,7 +118,7 @@ func (sam *SAM) EnsureKeyfile(fname string) (keys I2PKeys, err error) {
var f io.WriteCloser
f, err = os.OpenFile(fname, os.O_WRONLY|os.O_CREATE, 0600)
if err == nil {
err = StoreKeysIncompat(keys, f)
err = i2pkeys.StoreKeysIncompat(keys, f)
f.Close()
}
}
@ -123,7 +127,7 @@ func (sam *SAM) EnsureKeyfile(fname string) (keys I2PKeys, err error) {
var f *os.File
f, err = os.Open(fname)
if err == nil {
keys, err = LoadKeysIncompat(f)
keys, err = i2pkeys.LoadKeysIncompat(f)
if err == nil {
sam.Config.I2PConfig.DestinationKeys = keys
}
@ -136,18 +140,18 @@ func (sam *SAM) EnsureKeyfile(fname string) (keys 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, error) {
func (sam *SAM) NewKeys(sigType ...string) (i2pkeys.I2PKeys, error) {
sigtmp := ""
if len(sigType) > 0 {
sigtmp = sigType[0]
}
if _, err := sam.conn.Write([]byte("DEST GENERATE " + sigtmp + "\n")); err != nil {
return I2PKeys{}, err
return i2pkeys.I2PKeys{}, err
}
buf := make([]byte, 8192)
n, err := sam.conn.Read(buf)
if err != nil {
return I2PKeys{}, err
return i2pkeys.I2PKeys{}, err
}
s := bufio.NewScanner(bytes.NewReader(buf[:n]))
s.Split(bufio.ScanWords)
@ -164,7 +168,7 @@ func (sam *SAM) NewKeys(sigType ...string) (I2PKeys, error) {
} else if strings.HasPrefix(text, "PRIV=") {
priv = text[5:]
} else {
return I2PKeys{}, errors.New("Failed to parse keys.")
return i2pkeys.I2PKeys{}, errors.New("Failed to parse keys.")
}
}
return NewKeys(I2PAddr(pub), priv), nil
@ -172,7 +176,7 @@ func (sam *SAM) NewKeys(sigType ...string) (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) (I2PAddr, error) {
func (sam *SAM) Lookup(name string) (i2pkeys.I2PAddr, error) {
return sam.resolver.Resolve(name)
}
@ -181,11 +185,11 @@ func (sam *SAM) Lookup(name string) (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, options []string, extras []string) (net.Conn, error) {
func (sam *SAM) newGenericSession(style, id string, keys i2pkeys.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, sigType string, options []string, extras []string) (net.Conn, error) {
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)
}
@ -194,7 +198,7 @@ func (sam *SAM) newGenericSessionWithSignature(style, id string, keys I2PKeys, s
// 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, sigType string, options []string, extras []string) (net.Conn, error) {
func (sam *SAM) newGenericSessionWithSignatureAndPorts(style, id, from, to string, keys i2pkeys.I2PKeys, sigType string, options []string, extras []string) (net.Conn, error) {
optStr := ""
for _, opt := range options {

38
stream.go
View File

@ -11,18 +11,16 @@ import (
"strconv"
"strings"
"time"
)
import (
. "github.com/eyedeekay/sam3/i2pkeys"
"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 // i2p destination keys
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
@ -52,18 +50,18 @@ func (ss *StreamSession) Close() error {
}
// Returns the I2P destination (the address) of the stream session
func (ss *StreamSession) Addr() I2PAddr {
func (ss *StreamSession) Addr() i2pkeys.I2PAddr {
return ss.keys.Addr()
}
// Returns the keys associated with the stream session
func (ss *StreamSession) Keys() I2PKeys {
func (ss *StreamSession) Keys() i2pkeys.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, options []string) (*StreamSession, error) {
func (sam *SAM) NewStreamSession(id string, keys i2pkeys.I2PKeys, options []string) (*StreamSession, error) {
conn, err := sam.newGenericSession("STREAM", id, keys, options, []string{})
if err != nil {
return nil, err
@ -73,7 +71,7 @@ func (sam *SAM) NewStreamSession(id string, keys I2PKeys, options []string) (*St
// 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, options []string, sigType string) (*StreamSession, error) {
func (sam *SAM) NewStreamSessionWithSignature(id string, keys i2pkeys.I2PKeys, options []string, sigType string) (*StreamSession, error) {
conn, err := sam.newGenericSessionWithSignature("STREAM", id, keys, sigType, options, []string{})
if err != nil {
return nil, err
@ -83,7 +81,7 @@ func (sam *SAM) NewStreamSessionWithSignature(id string, keys I2PKeys, options [
// 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, options []string, sigType string) (*StreamSession, error) {
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{})
if err != nil {
return nil, err
@ -92,14 +90,14 @@ func (sam *SAM) NewStreamSessionWithSignatureAndPorts(id, from, to string, keys
}
// lookup name, convienence function
func (s *StreamSession) Lookup(name string) (I2PAddr, error) {
func (s *StreamSession) Lookup(name string) (i2pkeys.I2PAddr, error) {
sam, err := NewSAM(s.samAddr)
if err == nil {
addr, err := sam.Lookup(name)
sam.Close()
return addr, err
}
return I2PAddr(""), err
return i2pkeys.I2PAddr(""), err
}
// context-aware dialer, eventually...
@ -121,7 +119,7 @@ func (s *StreamSession) DialContextI2P(ctx context.Context, n, addr string) (*SA
}
}
i2paddr, err := NewI2PAddrFromString(addr)
i2paddr, err := i2pkeys.NewI2PAddrFromString(addr)
if err != nil {
return nil, err
}
@ -163,7 +161,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 I2PAddr
var i2paddr i2pkeys.I2PAddr
var host string
host, _, err = net.SplitHostPort(addr)
if err == nil {
@ -173,7 +171,7 @@ func (s *StreamSession) Dial(n, addr string) (c net.Conn, err error) {
i2paddr, err = s.Lookup(host)
} else {
// probably a destination
i2paddr = I2PAddr(host)
i2paddr = i2pkeys.I2PAddr(host)
}
if err == nil {
return s.DialI2P(i2paddr)
@ -183,7 +181,7 @@ 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 I2PAddr) (*SAMConn, error) {
func (s *StreamSession) DialI2P(addr i2pkeys.I2PAddr) (*SAMConn, error) {
sam, err := NewSAM(s.samAddr)
if err != nil {
return nil, err
@ -248,7 +246,7 @@ type StreamListener struct {
// our session id
id string
// our local address for this sam socket
laddr I2PAddr
laddr i2pkeys.I2PAddr
}
func (l *StreamListener) From() string {
@ -325,7 +323,7 @@ func (l *StreamListener) AcceptI2P() (*SAMConn, error) {
dest = strings.Trim(dest, "\n")
return &SAMConn{
laddr: l.laddr,
raddr: I2PAddr(dest),
raddr: i2pkeys.I2PAddr(dest),
conn: s.conn,
}, nil
} else {

9
stream_test.go
View File

@ -4,12 +4,11 @@ package sam3
import (
"fmt"
"log"
"strings"
"testing"
)
import (
. "github.com/eyedeekay/sam3/i2pkeys"
"github.com/eyedeekay/sam3/i2pkeys"
)
func Test_StreamingDial(t *testing.T) {
@ -194,8 +193,10 @@ func ExampleStreamSession() {
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(zzz.i2p)? It replied %d bytes, but nothing that looked like http/html", n)
log.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 zzz.i2p")
log.Println("Read HTTP/HTML from zzz.i2p")
}
return
@ -226,7 +227,7 @@ func ExampleStreamListener() {
quit := make(chan bool)
// Client connecting to the server
go func(server I2PAddr) {
go func(server i2pkeys.I2PAddr) {
csam, err := NewSAM(samBridge)
if err != nil {
fmt.Println(err.Error())