part out sam3

2025-07-19 10:35:42 -04:00 · 2025-02-17 21:46:19 -05:00
commit 5a1b4e14d9
40 changed files with 3220 additions and 0 deletions
--- a/primary/const.go
+++ b/primary/const.go
@@ -0,0 +1,3 @@
+package primary
+
+const SESSION_ADDOK = "SESSION STATUS RESULT=OK"
--- a/primary/datagram.go
+++ b/primary/datagram.go
@@ -0,0 +1,73 @@
+package primary
+
+import (
+	"errors"
+	"net"
+	"strconv"
+
+	"github.com/go-i2p/go-sam-go/common"
+	"github.com/go-i2p/go-sam-go/datagram"
+	"github.com/sirupsen/logrus"
+)
+
+// 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) (*datagram.DatagramSession, error) {
+	log.WithFields(logrus.Fields{"id": id, "udpPort": udpPort}).Debug("NewDatagramSubSession called")
+	if udpPort > 65335 || udpPort < 0 {
+		log.WithField("udpPort", udpPort).Error("Invalid UDP port")
+		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
+	}
+	if udpPort == 0 {
+		udpPort = 7655
+		log.Debug("Using default UDP port 7655")
+	}
+	lhost, _, err := common.SplitHostPort(s.conn.LocalAddr().String())
+	if err != nil {
+		log.WithError(err).Error("Failed to split local host port")
+		s.Close()
+		return nil, err
+	}
+	lUDPAddr, err := net.ResolveUDPAddr("udp4", lhost+":0")
+	if err != nil {
+		log.WithError(err).Error("Failed to resolve local UDP address")
+		return nil, err
+	}
+	udpconn, err := net.ListenUDP("udp4", lUDPAddr)
+	if err != nil {
+		log.WithError(err).Error("Failed to listen on UDP")
+		return nil, err
+	}
+	rhost, _, err := common.SplitHostPort(s.conn.RemoteAddr().String())
+	if err != nil {
+		log.WithError(err).Error("Failed to split remote host port")
+		s.Close()
+		return nil, err
+	}
+	rUDPAddr, err := net.ResolveUDPAddr("udp4", rhost+":"+strconv.Itoa(udpPort))
+	if err != nil {
+		log.WithError(err).Error("Failed to resolve remote UDP address")
+		return nil, err
+	}
+	_, lport, err := net.SplitHostPort(udpconn.LocalAddr().String())
+	if err != nil {
+		log.WithError(err).Error("Failed to get local port")
+		s.Close()
+		return nil, err
+	}
+	conn, err := s.NewGenericSubSession("DATAGRAM", id, []string{"PORT=" + lport})
+	if err != nil {
+		log.WithError(err).Error("Failed to create new generic sub-session")
+		return nil, err
+	}
+
+	log.WithFields(logrus.Fields{"id": id, "localPort": lport}).Debug("Created new datagram sub-session")
+	datagramSession := &datagram.DatagramSession{
+		SAM:           (*datagram.SAM)(s.SAM),
+		SAMUDPAddress: rUDPAddr,
+		UDPConn:       udpconn,
+		RemoteI2PAddr: nil,
+	}
+	datagramSession.Conn = conn
+	return datagramSession, nil
+}
--- a/primary/dialers.go
+++ b/primary/dialers.go
@@ -0,0 +1,105 @@
+package primary
+
+import (
+	"fmt"
+	"net"
+	"strings"
+
+	"github.com/go-i2p/go-sam-go/common"
+	"github.com/go-i2p/go-sam-go/datagram"
+	"github.com/sirupsen/logrus"
+)
+
+func (sam *PrimarySession) Dial(network, addr string) (net.Conn, error) {
+	log.WithFields(logrus.Fields{"network": network, "addr": addr}).Debug("Dial() called")
+	if network == "udp" || network == "udp4" || network == "udp6" {
+		//return sam.DialUDPI2P(network, network+addr[0:4], addr)
+		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 sam.DialTCPI2P(network, network+addr[0:4], addr)
+	}
+	log.WithField("network", network).Error("Invalid network type")
+	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) {
+	log.WithFields(logrus.Fields{"network": network, "laddr": laddr, "raddr": raddr}).Debug("DialTCP() called")
+	ts, ok := sam.stsess[network+raddr.String()[0:4]]
+	var err error
+	if !ok {
+		ts, err = sam.NewUniqueStreamSubSession(network + raddr.String()[0:4])
+		if err != nil {
+			log.WithError(err).Error("Failed to create new unique stream sub-session")
+			return nil, err
+		}
+		sam.stsess[network+raddr.String()[0:4]] = ts
+		ts, _ = sam.stsess[network+raddr.String()[0:4]]
+	}
+	return ts.Dial(network, raddr.String())
+}
+
+func (sam *PrimarySession) DialTCPI2P(network string, laddr, raddr string) (net.Conn, error) {
+	log.WithFields(logrus.Fields{"network": network, "laddr": laddr, "raddr": raddr}).Debug("DialTCPI2P() called")
+	ts, ok := sam.stsess[network+raddr[0:4]]
+	var err error
+	if !ok {
+		ts, err = sam.NewUniqueStreamSubSession(network + laddr)
+		if err != nil {
+			log.WithError(err).Error("Failed to create new unique stream sub-session")
+			return nil, err
+		}
+		sam.stsess[network+raddr[0:4]] = ts
+		ts, _ = sam.stsess[network+raddr[0:4]]
+	}
+	return ts.Dial(network, raddr)
+}
+
+// DialUDP implements x/dialer
+func (sam *PrimarySession) DialUDP(network string, laddr, raddr net.Addr) (net.PacketConn, error) {
+	log.WithFields(logrus.Fields{"network": network, "laddr": laddr, "raddr": raddr}).Debug("DialUDP() called")
+	ds, ok := sam.dgsess[network+raddr.String()[0:4]]
+	var err error
+	if !ok {
+		ds, err = sam.NewDatagramSubSession(network+raddr.String()[0:4], 0)
+		if err != nil {
+			log.WithError(err).Error("Failed to create new datagram sub-session")
+			return nil, err
+		}
+		sam.dgsess[network+raddr.String()[0:4]] = ds
+		ds, _ = sam.dgsess[network+raddr.String()[0:4]]
+	}
+	return ds.Dial(network, raddr.String())
+}
+
+func (sam *PrimarySession) DialUDPI2P(network, laddr, raddr string) (*datagram.DatagramSession, error) {
+	log.WithFields(logrus.Fields{"network": network, "laddr": laddr, "raddr": raddr}).Debug("DialUDPI2P() called")
+	ds, ok := sam.dgsess[network+raddr[0:4]]
+	var err error
+	if !ok {
+		ds, err = sam.NewDatagramSubSession(network+laddr, 0)
+		if err != nil {
+			log.WithError(err).Error("Failed to create new datagram sub-session")
+			return nil, err
+		}
+		sam.dgsess[network+raddr[0:4]] = ds
+		ds, _ = sam.dgsess[network+raddr[0:4]]
+	}
+	return ds.Dial(network, raddr)
+}
+
+func (s *PrimarySession) Lookup(name string) (a net.Addr, err error) {
+	log.WithField("name", name).Debug("Lookup() called")
+	var sam *common.SAM
+	name = strings.Split(name, ":")[0]
+	sam, err = common.NewSAM(s.samAddr)
+	if err == nil {
+		log.WithField("addr", a).Debug("Lookup successful")
+		defer sam.Close()
+		a, err = sam.Lookup(name)
+	}
+	log.WithError(err).Error("Lookup failed")
+	return
+}
--- a/primary/generic.go
+++ b/primary/generic.go
@@ -0,0 +1,101 @@
+package primary
+
+import (
+	"errors"
+	"net"
+	"strings"
+
+	"github.com/sirupsen/logrus"
+
+	"github.com/go-i2p/go-sam-go/common"
+)
+
+// 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) {
+	log.WithFields(logrus.Fields{"style": style, "id": id, "extras": extras}).Debug("newGenericSubSession called")
+	return sam.NewGenericSubSessionWithSignature(style, id, extras)
+}
+
+func (sam *PrimarySession) NewGenericSubSessionWithSignature(style, id string, extras []string) (net.Conn, error) {
+	log.WithFields(logrus.Fields{"style": style, "id": id, "extras": extras}).Debug("newGenericSubSessionWithSignature called")
+	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) {
+	log.WithFields(logrus.Fields{"style": style, "id": id, "from": from, "to": to, "extras": extras}).Debug("newGenericSubSessionWithSignatureAndPorts called")
+
+	conn := sam.conn
+	fp := ""
+	tp := ""
+	if from != "0" && from != "" {
+		fp = " FROM_PORT=" + from
+	}
+	if to != "0" && to != "" {
+		tp = " TO_PORT=" + to
+	}
+	scmsg := []byte("SESSION ADD STYLE=" + style + " ID=" + id + fp + tp + " " + strings.Join(extras, " ") + "\n")
+
+	log.WithField("message", string(scmsg)).Debug("Sending SESSION ADD message")
+
+	for m, i := 0, 0; m != len(scmsg); i++ {
+		if i == 15 {
+			conn.Close()
+			log.Error("Writing to SAM failed after 15 attempts")
+			return nil, errors.New("writing to SAM failed")
+		}
+		n, err := conn.Write(scmsg[m:])
+		if err != nil {
+			log.WithError(err).Error("Failed to write to SAM connection")
+			conn.Close()
+			return nil, err
+		}
+		m += n
+	}
+	buf := make([]byte, 4096)
+	n, err := conn.Read(buf)
+	if err != nil {
+		log.WithError(err).Error("Failed to read from SAM connection")
+		conn.Close()
+		return nil, err
+	}
+	text := string(buf[:n])
+	log.WithField("response", text).Debug("Received response from SAM")
+	//log.Println("SAM:", text)
+	if strings.HasPrefix(text, SESSION_ADDOK) {
+		//if sam.keys.String() != text[len(common.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")
+		//}
+		log.Debug("Session added successfully")
+		return conn, nil //&StreamSession{id, conn, keys, nil, sync.RWMutex{}, nil}, nil
+	} else if text == common.SESSION_DUPLICATE_ID {
+		log.Error("Duplicate tunnel name")
+		conn.Close()
+		return nil, errors.New("Duplicate tunnel name")
+	} else if text == common.SESSION_DUPLICATE_DEST {
+		log.Error("Duplicate destination")
+		conn.Close()
+		return nil, errors.New("Duplicate destination")
+	} else if text == common.SESSION_INVALID_KEY {
+		log.Error("Invalid key - Primary Session")
+		conn.Close()
+		return nil, errors.New("Invalid key - Primary Session")
+	} else if strings.HasPrefix(text, common.SESSION_I2P_ERROR) {
+		log.WithField("error", text[len(common.SESSION_I2P_ERROR):]).Error("I2P error")
+		conn.Close()
+		return nil, errors.New("I2P error " + text[len(common.SESSION_I2P_ERROR):])
+	} else {
+		log.WithField("reply", text).Error("Unable to parse SAMv3 reply")
+		conn.Close()
+		return nil, errors.New("Unable to parse SAMv3 reply: " + text)
+	}
+}
--- a/primary/log.go
+++ b/primary/log.go
@@ -0,0 +1,10 @@
+package primary
+
+import logger "github.com/go-i2p/go-sam-go/log"
+
+var log = logger.GetSAM3Logger()
+
+func init() {
+	logger.InitializeSAM3Logger()
+	log = logger.GetSAM3Logger()
+}
--- a/primary/primary.go
+++ b/primary/primary.go
@@ -0,0 +1,46 @@
+package primary
+
+/*
+// 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) {
+	log.WithFields(logrus.Fields{"id": id, "options": options}).Debug("NewPrimarySession() called")
+	return sam.newPrimarySession(PrimarySessionSwitch, id, keys, options)
+}
+
+func (sam *SAM) newPrimarySession(primarySessionSwitch string, id string, keys i2pkeys.I2PKeys, options []string) (*PrimarySession, error) {
+	log.WithFields(logrus.Fields{
+		"primarySessionSwitch": primarySessionSwitch,
+		"id":                   id,
+		"options":              options,
+	}).Debug("newPrimarySession() called")
+
+	conn, err := sam.newGenericSession(primarySessionSwitch, id, keys, options, []string{})
+	if err != nil {
+		log.WithError(err).Error("Failed to create new generic session")
+		return nil, err
+	}
+	ssesss := make(map[string]*StreamSession)
+	dsesss := make(map[string]*DatagramSession)
+	return &PrimarySession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), Sig_NONE, sam.Config, ssesss, dsesss}, 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) {
+	log.WithFields(logrus.Fields{
+		"id":      id,
+		"options": options,
+		"sigType": sigType,
+	}).Debug("NewPrimarySessionWithSignature() called")
+
+	conn, err := sam.newGenericSessionWithSignature(PrimarySessionSwitch, id, keys, sigType, options, []string{})
+	if err != nil {
+		log.WithError(err).Error("Failed to create new generic session with signature")
+		return nil, err
+	}
+	ssesss := make(map[string]*stream.StreamSession)
+	dsesss := make(map[string]*datagram.DatagramSession)
+	return &PrimarySession{sam.Config.I2PConfig.Sam(), id, conn, keys, time.Duration(600 * time.Second), time.Now(), sigType, sam.Config, ssesss, dsesss}, nil
+}
+*/
--- a/primary/raw.go
+++ b/primary/raw.go
@@ -0,0 +1,74 @@
+package primary
+
+import (
+	"errors"
+	"net"
+	"strconv"
+
+	"github.com/go-i2p/go-sam-go/common"
+	"github.com/go-i2p/go-sam-go/raw"
+	"github.com/sirupsen/logrus"
+)
+
+// 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) (*raw.RawSession, error) {
+	log.WithFields(logrus.Fields{"id": id, "udpPort": udpPort}).Debug("NewRawSubSession called")
+
+	if udpPort > 65335 || udpPort < 0 {
+		log.WithField("udpPort", udpPort).Error("Invalid UDP port")
+		return nil, errors.New("udpPort needs to be in the intervall 0-65335")
+	}
+	if udpPort == 0 {
+		udpPort = 7655
+		log.Debug("Using default UDP port 7655")
+	}
+	lhost, _, err := common.SplitHostPort(s.conn.LocalAddr().String())
+	if err != nil {
+		log.WithError(err).Error("Failed to split local host port")
+		s.Close()
+		return nil, err
+	}
+	lUDPAddr, err := net.ResolveUDPAddr("udp4", lhost+":0")
+	if err != nil {
+		log.WithError(err).Error("Failed to resolve local UDP address")
+		return nil, err
+	}
+	udpconn, err := net.ListenUDP("udp4", lUDPAddr)
+	if err != nil {
+		log.WithError(err).Error("Failed to listen on UDP")
+		return nil, err
+	}
+	rhost, _, err := common.SplitHostPort(s.conn.RemoteAddr().String())
+	if err != nil {
+		log.WithError(err).Error("Failed to split remote host port")
+		s.Close()
+		return nil, err
+	}
+	rUDPAddr, err := net.ResolveUDPAddr("udp4", rhost+":"+strconv.Itoa(udpPort))
+	if err != nil {
+		log.WithError(err).Error("Failed to resolve remote UDP address")
+		return nil, err
+	}
+	_, lport, err := net.SplitHostPort(udpconn.LocalAddr().String())
+	if err != nil {
+		log.WithError(err).Error("Failed to get local port")
+		s.Close()
+		return nil, err
+	}
+	//	conn, err := s.newGenericSubSession("RAW", id, s.keys, options, []string{"PORT=" + lport})
+	conn, err := s.NewGenericSubSession("RAW", id, []string{"PORT=" + lport})
+	if err != nil {
+		log.WithError(err).Error("Failed to create new generic sub-session")
+		return nil, err
+	}
+
+	log.WithFields(logrus.Fields{"id": id, "localPort": lport}).Debug("Created new raw sub-session")
+	rawSession := &raw.RawSession{
+		SAM:        (*raw.SAM)(s.SAM),
+		SAMUDPConn: udpconn,
+		SAMUDPAddr: rUDPAddr,
+	}
+	rawSession.Conn = conn
+	return rawSession, nil
+}
--- a/primary/stream.go
+++ b/primary/stream.go
@@ -0,0 +1,57 @@
+package primary
+
+import (
+	"github.com/go-i2p/go-sam-go/common"
+	"github.com/go-i2p/go-sam-go/stream"
+	"github.com/sirupsen/logrus"
+)
+
+// Creates a new stream.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) (*stream.StreamSession, error) {
+	log.WithField("id", id).Debug("NewStreamSubSession called")
+	conn, err := sam.NewGenericSubSession("STREAM", id, []string{})
+	if err != nil {
+		log.WithError(err).Error("Failed to create new generic sub-session")
+		return nil, err
+	}
+	streamSession := &stream.StreamSession{
+		SAM: (*stream.SAM)(sam.SAM),
+	}
+	streamSession.Conn = conn
+	return streamSession, nil
+}
+
+// Creates a new stream.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) (*stream.StreamSession, error) {
+	log.WithField("id", id).Debug("NewUniqueStreamSubSession called")
+	conn, err := sam.NewGenericSubSession("STREAM", id, []string{})
+	if err != nil {
+		log.WithError(err).Error("Failed to create new generic sub-session")
+		return nil, err
+	}
+	fromPort, toPort := common.RandPort(), common.RandPort()
+	log.WithFields(logrus.Fields{"fromPort": fromPort, "toPort": toPort}).Debug("Generated random ports")
+	streamSession := &stream.StreamSession{
+		SAM: (*stream.SAM)(sam.SAM),
+	}
+	streamSession.Conn = conn
+	return streamSession, nil
+}
+
+// Creates a new stream.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) (*stream.StreamSession, error) {
+	log.WithFields(logrus.Fields{"id": id, "from": from, "to": to}).Debug("NewStreamSubSessionWithPorts called")
+	conn, err := sam.NewGenericSubSessionWithSignatureAndPorts("STREAM", id, from, to, []string{})
+	if err != nil {
+		log.WithError(err).Error("Failed to create new generic sub-session with signature and ports")
+		return nil, err
+	}
+	streamSession := &stream.StreamSession{
+		SAM: (*stream.SAM)(sam.SAM),
+	}
+	streamSession.Conn = conn
+	return streamSession, nil
+}
--- a/primary/types.go
+++ b/primary/types.go
@@ -0,0 +1,30 @@
+package primary
+
+import (
+	"net"
+	"time"
+
+	"github.com/go-i2p/go-sam-go/common"
+	"github.com/go-i2p/go-sam-go/datagram"
+	"github.com/go-i2p/go-sam-go/stream"
+	"github.com/go-i2p/i2pkeys"
+)
+
+type SAM common.SAM
+
+// Represents a primary session.
+type PrimarySession struct {
+	*SAM
+	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   common.SAMEmit
+	stsess   map[string]*stream.StreamSession
+	dgsess   map[string]*datagram.DatagramSession
+	//	from     string
+	//	to       string
+}