go-i2p/go-sam-go
1
0
Fork 0
mirror of https://github.com/go-i2p/go-sam-go.git synced 2025-06-16 13:54:42 -04:00
Code Issues Packages Projects Releases Wiki Activity

fix conflicts

Browse Source
This commit is contained in:
eyedeekay
2025-05-26 23:30:26 -04:00
parent 9a62a09f40 11110ed5a2
commit a325a30b06
13 changed files with 131 additions and 108 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
common/SAM.go
View File

@ -226,6 +226,9 @@ func (sam *SAM) NewGenericSessionWithSignatureAndPorts(style, id, from, to strin
// close this sam session
func (sam *SAM) Close() error {
if sam.Conn != nil {
log.Debug("Closing SAM session")
return sam.Conn.Close()
}
return nil
}

26
common/config.go
View File

@ -237,9 +237,9 @@ func (f *I2PConfig) SignatureType() string {
// EncryptLease returns the lease set encryption configuration string
// Returns "i2cp.encryptLeaseSet=true" if encryption is enabled, empty string otherwise
func (f *I2PConfig) EncryptLease() string {
if f.EncryptLeaseSet == true {
if f.EncryptLeaseSet {
log.Debug("Lease set encryption enabled")
return fmt.Sprintf(" i2cp.encryptLeaseSet=true ")
return " i2cp.encryptLeaseSet=true "
}
log.Debug("Lease set encryption not enabled")
return ""
@ -262,7 +262,7 @@ func (f *I2PConfig) Reliability() string {
// Reduce returns I2CP reduce-on-idle configuration settings as a string if enabled
func (f *I2PConfig) Reduce() string {
// If reduce idle is enabled, return formatted configuration string
if f.ReduceIdle == true {
if f.ReduceIdle {
// Log the reduce idle settings being applied
log.WithFields(logrus.Fields{
"reduceIdle": f.ReduceIdle,
@ -287,7 +287,7 @@ func (f *I2PConfig) Reduce() string {
// Close returns I2CP close-on-idle configuration settings as a string if enabled
func (f *I2PConfig) Close() string {
// If close idle is enabled, return formatted configuration string
if f.CloseIdle == true {
if f.CloseIdle {
// Log the close idle settings being applied
log.WithFields(logrus.Fields{
"closeIdle": f.CloseIdle,
@ -312,17 +312,17 @@ func (f *I2PConfig) DoZero() string {
var settings []string
// Add inbound zero hop setting if enabled
if f.InAllowZeroHop == true {
if f.InAllowZeroHop {
settings = append(settings, fmt.Sprintf("inbound.allowZeroHop=%t", f.InAllowZeroHop))
}
// Add outbound zero hop setting if enabled
if f.OutAllowZeroHop == true {
if f.OutAllowZeroHop {
settings = append(settings, fmt.Sprintf("outbound.allowZeroHop=%t", f.OutAllowZeroHop))
}
// Add fast receive setting if enabled
if f.FastRecieve == true {
if f.FastRecieve {
settings = append(settings, fmt.Sprintf("i2cp.fastRecieve=%t", f.FastRecieve))
}
@ -404,13 +404,13 @@ func (f *I2PConfig) Print() []string {
// Accesslisttype returns the I2CP access list configuration string based on the AccessListType setting
func (f *I2PConfig) Accesslisttype() string {
switch f.AccessListType {
case "whitelist":
case ACCESS_TYPE_WHITELIST:
log.Debug("Access list type set to whitelist")
return fmt.Sprintf("i2cp.enableAccessList=true")
case "blacklist":
return "i2cp.enableAccessList=true"
case ACCESS_TYPE_BLACKLIST:
log.Debug("Access list type set to blacklist")
return fmt.Sprintf("i2cp.enableBlackList=true")
case "none":
return "i2cp.enableBlackList=true"
case ACCESS_TYPE_NONE:
log.Debug("Access list type set to none")
return ""
default:
@ -469,7 +469,7 @@ func NewConfig(opts ...func(*I2PConfig) error) (*I2PConfig, error) {
config.SamMax = DEFAULT_SAM_MAX
config.TunName = ""
config.TunType = "server"
config.Style = "STREAM"
config.Style = SESSION_STYLE_STREAM
config.InLength = 3
config.OutLength = 3
config.InQuantity = 2

12
common/const.go
View File

@ -32,3 +32,15 @@ const (
HELLO_REPLY_OK = "HELLO REPLY RESULT=OK"
HELLO_REPLY_NOVERSION = "HELLO REPLY RESULT=NOVERSION\n"
)
const (
SESSION_STYLE_STREAM = "STREAM"
SESSION_STYLE_DATAGRAM = "DATAGRAM"
SESSION_STYLE_RAW = "RAW"
)
const (
ACCESS_TYPE_WHITELIST = "whitelist"
ACCESS_TYPE_BLACKLIST = "blacklist"
ACCESS_TYPE_NONE = "none"
)

26
common/emit-options.go
View File

@ -14,15 +14,9 @@ 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
log.WithField("style", s).Debug("Set session style")
return nil
} else if s == "DATAGRAM" {
c.Style = s
log.WithField("style", s).Debug("Set session style")
return nil
} else if s == "RAW" {
if s == SESSION_STYLE_STREAM ||
s == SESSION_STYLE_DATAGRAM ||
s == SESSION_STYLE_RAW {
c.Style = s
log.WithField("style", s).Debug("Set session style")
return nil
@ -399,19 +393,15 @@ func SetCloseIdleTimeMs(u int) func(*SAMEmit) error {
// 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"
if s == ACCESS_TYPE_WHITELIST {
c.I2PConfig.AccessListType = ACCESS_TYPE_WHITELIST
log.Debug("Set access list type to whitelist")
return nil
} else if s == "blacklist" {
c.I2PConfig.AccessListType = "blacklist"
} else if s == ACCESS_TYPE_BLACKLIST {
c.I2PConfig.AccessListType = ACCESS_TYPE_BLACKLIST
log.Debug("Set access list type to blacklist")
return nil
} else if s == "none" {
c.I2PConfig.AccessListType = ""
log.Debug("Set access list type to none")
return nil
} else if s == "" {
} else if s == ACCESS_TYPE_NONE || s == "" {
c.I2PConfig.AccessListType = ""
log.Debug("Set access list type to none")
return nil

10
common/util.go
View File

@ -1,6 +1,7 @@
package common
import (
"fmt"
"math/rand"
"net"
"strconv"
@ -76,8 +77,9 @@ var (
randGen = rand.New(randSource)
)
func RandPort() string {
for {
func RandPort() (portNumber string, err error) {
maxAttempts := 30
for range maxAttempts {
p := randGen.Intn(55534) + 10000
port := strconv.Itoa(p)
if l, e := net.Listen("tcp", net.JoinHostPort("localhost", port)); e != nil {
@ -88,8 +90,10 @@ func RandPort() string {
continue
} else {
defer l.Close()
return strconv.Itoa(l.Addr().(*net.UDPAddr).Port)
return strconv.Itoa(l.Addr().(*net.UDPAddr).Port), nil
}
}
}
return "", fmt.Errorf("unable to find a pair of available tcp and udp ports in %v attempts", maxAttempts)
}

6
config.go
View File

@ -16,11 +16,11 @@ 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.SamMin = common.DEFAULT_SAM_MIN
config.SamMax = common.DEFAULT_SAM_MAX
config.TunName = ""
config.TunType = "server"
config.Style = "STREAM"
config.Style = common.SESSION_STYLE_STREAM
config.InLength = 3
config.OutLength = 3
config.InQuantity = 2

61
log.go
View File

@ -1,7 +1,68 @@
package sam3
<<<<<<< HEAD
import (
"github.com/go-i2p/logger"
)
var log = logger.GetGoI2PLogger()
||||||| a681ab3
import (
"io/ioutil"
"os"
"strings"
"sync"
"github.com/sirupsen/logrus"
)
var (
log *logrus.Logger
once sync.Once
)
func InitializeSAM3Logger() {
once.Do(func() {
log = logrus.New()
// We do not want to log by default
log.SetOutput(ioutil.Discard)
log.SetLevel(logrus.PanicLevel)
// Check if DEBUG_I2P is set
if logLevel := os.Getenv("DEBUG_I2P"); logLevel != "" {
log.SetOutput(os.Stdout)
switch strings.ToLower(logLevel) {
case "debug":
log.SetLevel(logrus.DebugLevel)
case "warn":
log.SetLevel(logrus.WarnLevel)
case "error":
log.SetLevel(logrus.ErrorLevel)
default:
log.SetLevel(logrus.DebugLevel)
}
log.WithField("level", log.GetLevel()).Debug("Logging enabled.")
}
})
}
// GetSAM3Logger returns the initialized logger
func GetSAM3Logger() *logrus.Logger {
if log == nil {
InitializeSAM3Logger()
}
return log
}
func init() {
InitializeSAM3Logger()
}
=======
import "github.com/go-i2p/go-sam-go/logger"
var log = logger.GetSAM3Logger()
func init() {
logger.InitializeSAM3Logger()
log = logger.GetSAM3Logger()
}
>>>>>>> 11110ed5a2ac9ad702c0278886c0418c8cd95a16

1
log/log.go
View File

@ -1 +0,0 @@
package log

13
primary.go
View File

@ -2,10 +2,6 @@
package sam3
import (
"math/rand"
"strconv"
"time"
"github.com/go-i2p/go-sam-go/primary"
)
@ -13,15 +9,6 @@ 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
port := strconv.Itoa(p)
log.WithField("port", port).Debug("Generated random port")
return strconv.Itoa(p)
}
// Represents a primary session.
type PrimarySession struct {
*primary.PrimarySession

28
primary/stream.go
View File

@ -1,6 +1,8 @@
package primary
import (
"net"
"github.com/go-i2p/go-sam-go/common"
"github.com/go-i2p/go-sam-go/stream"
"github.com/sirupsen/logrus"
@ -15,11 +17,7 @@ func (sam *PrimarySession) NewStreamSubSession(id string) (*stream.StreamSession
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
return newFromPrimary(sam, conn), nil
}
// Creates a new stream.StreamSession with the I2CP- and streaminglib options as
@ -31,13 +29,7 @@ func (sam *PrimarySession) NewUniqueStreamSubSession(id string) (*stream.StreamS
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
return newFromPrimary(sam, conn), nil
}
// Creates a new stream.StreamSession with the I2CP- and streaminglib options as
@ -49,9 +41,17 @@ func (sam *PrimarySession) NewStreamSubSessionWithPorts(id, from, to string) (*s
log.WithError(err).Error("Failed to create new generic sub-session with signature and ports")
return nil, err
}
return newFromPrimary(sam, conn), nil
}
func newFromPrimary(sam *PrimarySession, conn net.Conn) *stream.StreamSession {
streamSession := &stream.StreamSession{
SAM: (*stream.SAM)(sam.SAM),
SAM: &stream.SAM{
SAM: (*common.SAM)(sam.SAM),
},
}
streamSession.Conn = conn
return streamSession, nil
return streamSession
}

11
raw/log.go
View File

@ -1,10 +1,7 @@
package raw
import logger "github.com/go-i2p/go-sam-go/log"
import (
"github.com/go-i2p/logger"
)
var log = logger.GetSAM3Logger()
func init() {
logger.InitializeSAM3Logger()
log = logger.GetSAM3Logger()
}
var log = logger.GetGoI2PLogger()

24
sam3.go
View File

@ -17,11 +17,11 @@ type SAM struct {
}
// Creates a new stream session by wrapping stream.NewStreamSession
func (s *SAM) NewStreamSession(param1 string, keys i2pkeys.I2PKeys, param3 []string) (*StreamSession, error) {
func (s *SAM) NewStreamSession(id string, keys i2pkeys.I2PKeys, options []string) (*StreamSession, error) {
sam := &stream.SAM{
SAM: s.SAM,
}
ss, err := sam.NewStreamSession(param1, keys, param3)
ss, err := sam.NewStreamSession(id, keys, options)
if err != nil {
return nil, err
}
@ -56,26 +56,8 @@ func (s *SAM) NewPrimarySession(id string, keys i2pkeys.I2PKeys, options []strin
return &primarySession, nil
}
const (
session_OK = "SESSION STATUS RESULT=OK DESTINATION="
session_DUPLICATE_ID = "SESSION STATUS RESULT=DUPLICATED_ID\n"
session_DUPLICATE_DEST = "SESSION STATUS RESULT=DUPLICATED_DEST\n"
session_INVALID_KEY = "SESSION STATUS RESULT=INVALID_KEY\n"
session_I2P_ERROR = "SESSION STATUS RESULT=I2P_ERROR MESSAGE="
)
const (
Sig_NONE = "SIGNATURE_TYPE=EdDSA_SHA512_Ed25519"
Sig_DSA_SHA1 = "SIGNATURE_TYPE=DSA_SHA1"
Sig_ECDSA_SHA256_P256 = "SIGNATURE_TYPE=ECDSA_SHA256_P256"
Sig_ECDSA_SHA384_P384 = "SIGNATURE_TYPE=ECDSA_SHA384_P384"
Sig_ECDSA_SHA512_P521 = "SIGNATURE_TYPE=ECDSA_SHA512_P521"
Sig_EdDSA_SHA512_Ed25519 = "SIGNATURE_TYPE=EdDSA_SHA512_Ed25519"
)
var letters = []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
func RandString() string {
letters := []rune("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")
n := 4
b := make([]rune, n)
for i := range b {

12
stream.go
View File

@ -2,8 +2,6 @@
package sam3
import (
"time"
"github.com/go-i2p/go-sam-go/stream"
)
@ -18,13 +16,3 @@ func (s *StreamSession) Cancel() chan *StreamSession {
ch <- s
return ch
}*/
func minNonzeroTime(a, b time.Time) time.Time {
if a.IsZero() {
return b
}
if b.IsZero() || a.Before(b) {
return a
}
return b
}