change the package name

.dockerignore

@@ -0,0 +1 @@
+.go

Makefile

@@ -10,8 +10,7 @@ test:
 	killall ephsite
 
 deps:
-	go get -u github.com/eyedeekay/ephemeral-eepSite-SAM
-	go get -u github.com/eyedeekay/i2pasta/convert
+	go get -u github.com/eyedeekay/sam-forwarder
 	go get -u github.com/kpetku/sam3
 
 build: clean

README.md.asc

@@ -21,12 +21,12 @@ So, to serve an eepSite version of a local service on port 8080 -
         ./bin/ephsite -addr=127.0.0.1:8080
 -----BEGIN PGP SIGNATURE-----
 
-iQEzBAEBCAAdFiEEcNIGBzi++AUjrK/311wDs5teFOEFAltaRagACgkQ11wDs5te
-FOHsAAgAqalsr1wUf8q/0KvUVbhvjvPqlVT53FFlegmzncvTQw5astcmzThYE4QO
-V9wf6/wd5C8Zr0MOfW28HKSGvTKn6iJPc4PviUtC1XsLT3eTlgTbd9eq4lHKfa94
-+oRJKViKx9Xp8XObK1G6jW+4+x1K1GrcWs8XzrSchu7Jp0O22x8lAwi+B+EhUnGi
-VKZPtvBDjo35r1Qa1erA2p1fpj1DQ1askdgu5SSiMYonngjIETrVKC5P1cA//DOM
-qBr+Pq9AmktNqco8IofuzaErT5u45XNvRL7TO9YSlpCNPozlmPHIQyBlVnwQdVJB
-iFi+8ROKdnYY+mkcVboRooLlS6oUJg==
-=w4Ip
+iQEzBAEBCAAdFiEEcNIGBzi++AUjrK/311wDs5teFOEFAltaXE0ACgkQ11wDs5te
+FOG9jQgApdowtDBLoE+BJNj3QUjmddMqzkWtV6/3wtoOC/8sgGQ+0ZA3QyP2swXq
+9QXCG9RpdJ/UNSGCzhTP5FJi0YstODkvRs39rbkcCyp34tcTsM2gDXszvgs9+krR
+sqX7sbDA10H1B/4+tUiiiPKwA8En8Ato6x6v8eS9lRG1AeS0obVWWmZcGV/DS4Tk
+LO4mFnVdGg1PGjFFdDI3rOGVBPotrd//XPjoNxyzbdJbYfONf+yq5Gxk2Vi4qXy6
+a/KUd5KTUbpa96GcryHav/m4JZvmCxoGwFZ4ik9R6AgCy6M64qbza2F4ooJV0BZ0
+4zmmfEEc4fSRjbJyHlhC38X2U5jDUg==
+=ekZM
 -----END PGP SIGNATURE-----

forwarder-options.go

@@ -0,0 +1,63 @@
+package samforwarder
+
+import (
+	"fmt"
+	"strconv"
+)
+
+//Option is a SAMForwarder Option
+type Option func(*SAMForwarder) error
+
+//SetHost sets the host of the SAMForwarder's SAM bridge
+func SetHost(s string) func(*SAMForwarder) error {
+	return func(c *SAMForwarder) error {
+		c.TargetHost = s
+		return nil
+	}
+}
+
+//SetPort sets the port of the SAMForwarder's SAM bridge using a string
+func SetPort(s string) func(*SAMForwarder) error {
+	return func(c *SAMForwarder) error {
+		port, err := strconv.Atoi(s)
+		if err != nil {
+			return fmt.Errorf("Invalid port; non-number")
+		}
+		if port < 65536 && port > -1 {
+			c.TargetPort = s
+			return nil
+		}
+		return fmt.Errorf("Invalid port")
+	}
+}
+
+//SetSAMHost sets the host of the SAMForwarder's SAM bridge
+func SetSAMHost(s string) func(*SAMForwarder) error {
+	return func(c *SAMForwarder) error {
+		c.SamHost = s
+		return nil
+	}
+}
+
+//SetSAMPort sets the port of the SAMForwarder's SAM bridge using a string
+func SetSAMPort(s string) func(*SAMForwarder) error {
+	return func(c *SAMForwarder) error {
+		port, err := strconv.Atoi(s)
+		if err != nil {
+			return fmt.Errorf("Invalid port; non-number")
+		}
+		if port < 65536 && port > -1 {
+			c.SamPort = s
+			return nil
+		}
+		return fmt.Errorf("Invalid port")
+	}
+}
+
+//SetName sets the host of the SAMForwarder's SAM bridge
+func SetName(s string) func(*SAMForwarder) error {
+	return func(c *SAMForwarder) error {
+		c.TunName = s
+		return nil
+	}
+}

forwarder.go

@@ -10,23 +10,39 @@ import (
 	"github.com/kpetku/sam3"
 )
 
-var SamHost = "127.0.0.1"
-var SamPort = "7656"
-var TunName = "ephtun"
+//SAMForwarder is a structure which automatically configured the forwarding of
+//a local service to i2p over the SAM API.
+type SAMForwarder struct {
+    SamHost string
+    SamPort string
+    TunName string
 
-var samConn *sam3.SAM
-var samKeys sam3.I2PKeys
+    TargetHost string
+    TargetPort string
 
-var publishStream *sam3.StreamSession
-var publishListen *sam3.StreamListener
-var publishConnection net.Conn
+    samConn *sam3.SAM
+    samKeys sam3.I2PKeys
+    publishStream *sam3.StreamSession
+    publishListen *sam3.StreamListener
+    publishConnection net.Conn
 
-var Target = "127.0.0.1:8081"
+    //
+    savePath string
+    save bool
+}
 
 var err error
 
-func forward(conn net.Conn) {
-	client, err := net.Dial("tcp", Target)
+func (f *SAMForwarder) target() string {
+    return f.TargetHost+":"+f.TargetPort
+}
+
+func (f *SAMForwarder) sam() string {
+    return f.SamHost+":"+f.SamPort
+}
+
+func (f *SAMForwarder) forward(conn net.Conn) {
+	client, err := net.Dial("tcp", f.target())
 	if err != nil {
 		log.Fatalf("Dial failed: %v", err)
 	}
@@ -43,16 +59,22 @@ func forward(conn net.Conn) {
 	}()
 }
 
-func Serve() error {
-	if samConn, err = sam3.NewSAM(SamHost + ":" + SamPort); err != nil {
+//Base32 returns the base32 address where the local service is being forwarded
+func (f *SAMForwarder) Base32() string {
+    return f.samKeys.Addr().Base32()
+}
+
+//Serve starts the SAM connection and and forwards the local host:port to i2p
+func (f *SAMForwarder) Serve() error {
+	if f.samConn, err = sam3.NewSAM(f.sam()); err != nil {
 		return err
 	}
 	log.Println("SAM Bridge connection established.")
-	if samKeys, err = samConn.NewKeys(); err != nil {
+	if f.samKeys, err = f.samConn.NewKeys(); err != nil {
 		return err
 	}
-	log.Println("Destination keys generated, tunnel name:", TunName, ".")
-	if publishStream, err = samConn.NewStreamSession(TunName, samKeys,
+	log.Println("Destination keys generated, tunnel name:", f.TunName, ".")
+	if f.publishStream, err = f.samConn.NewStreamSession(f.TunName, f.samKeys,
         []string{"inbound.length=3", "outbound.length=3",
 		"inbound.lengthVariance=1", "outbound.lengthVariance=1",
 		"inbound.backupQuantity=3", "outbound.backupQuantity=3",
@@ -61,19 +83,40 @@ func Serve() error {
 		return err
 	}
 	log.Println("SAM stream session established.")
-	if publishListen, err = publishStream.Listen(); err != nil {
+	if f.publishListen, err = f.publishStream.Listen(); err != nil {
 		return err
 	}
 	log.Println("Starting Listener.")
-	b := string(samKeys.Addr().Base32())
+	b := string(f.samKeys.Addr().Base32())
 	log.Println("SAM Listener created,", b+".b32.i2p")
 
 	for {
-		conn, err := publishListen.Accept()
+		conn, err := f.publishListen.Accept()
 		if err != nil {
 			log.Fatalf("ERROR: failed to accept listener: %v", err)
 		}
 		log.Printf("Accepted connection %v\n", conn)
-		go forward(conn)
+		go f.forward(conn)
 	}
 }
+
+//NewSAMForwarder makes a new SAM forwarder with default options, accepts host:port arguments
+func NewSAMForwarder(host, port string) (*SAMForwarder, error) {
+    return NewSAMForwarderFromOptions(SetHost(host), SetPort(port))
+}
+
+//NewSAMForwarderFromOptions makes a new SAM forwarder with default options, accepts host:port arguments
+func NewSAMForwarderFromOptions(opts ...func(*SAMForwarder) error) (*SAMForwarder, error) {
+    var s SAMForwarder
+    s.SamHost = "127.0.0.1"
+    s.SamPort = "7656"
+    s.TargetHost = "127.0.0.1"
+    s.TargetPort = "8081"
+    s.TunName = "samForwarder"
+    for _, o := range opts {
+		if err := o(&s); err != nil {
+			return nil, err
+		}
+	}
+    return &s, nil
+}

main/main.go

@@ -5,11 +5,22 @@ import (
 	"log"
 )
 
-import "github.com/eyedeekay/ephemeral-eepSite-SAM"
+import "github.com/eyedeekay/sam-forwarder"
 
 func main() {
-	samlistener.Target = *flag.String("addr", "127.0.0.1:8081", "Target host:port")
+	TargetHost := *flag.String("host", "127.0.0.1", "Target host")
+    TargetPort := *flag.String("port", "8081", "Target port")
+    SamHost := *flag.String("samhost", "127.0.0.1", "SAM host")
+    SamPort := *flag.String("samport", "7656", "SAM port")
+    TunName := *flag.String("name", "forwarder", "Tunnel name")
 	flag.Parse()
-	log.Println("Redirecting", samlistener.Target, "to i2p")
-	samlistener.Serve()
+	log.Println("Redirecting", TargetHost+":"+TargetPort, "to i2p")
+    forwarder := samforwarder.NewSAMForwarderFromOptions(
+        samforwarder.SetHost(TargetHost),
+        samforwarder.SetPort(TargetPort),
+        samforwarder.SetSAMHost(SamHost),
+        samforwarder.SetSAMPort(SamPort),
+        samforwarder.SetName(TunName),
+    )
+	forwarder.Serve()
 }