rename module to hook

10 files changed, 142 insertions, 130 deletions

diff --git a/pkg/server/module/aes.go b/pkg/server/hook/aes.go
index 13153bc..b461a34 100644
--- a/pkg/server/module/aes.go
+++ b/pkg/server/hook/aes.go
@@ -1,4 +1,4 @@
-package module
+package hook
 
 import (
 	"crypto/aes"
@@ -11,7 +11,7 @@ import (
 	"tunnel/pkg/server/queue"
 )
 
-type aesModule struct{}
+type aesHook struct{}
 
 type aesPipe struct {
 	key []byte
@@ -74,12 +74,14 @@ func newAes(env env.Env) *aesPipe {
 	return a
 }
 
-func (m aesModule) Open(env env.Env) (interface{}, error) {
+func (h aesHook) Open(env env.Env) (interface{}, error) {
 	return newAes(env), nil
 }
 
+func newAesHook(opts.Opts, env.Env) (hook, error) {
+	return aesHook{}, nil
+}
+
 func init() {
-	register("aes", func(opts.Opts, env.Env) (module, error) {
-		return aesModule{}, nil
-	})
+	register("aes", newAesHook)
 }
diff --git a/pkg/server/module/alpha.go b/pkg/server/hook/alpha.go
index 8174b25..d1fefcc 100644
--- a/pkg/server/module/alpha.go
+++ b/pkg/server/hook/alpha.go
@@ -1,4 +1,4 @@
-package module
+package hook
 
 import (
 	"bufio"
diff --git a/pkg/server/module/auth.go b/pkg/server/hook/auth.go
index 5e5caeb..fc19c2a 100644
--- a/pkg/server/module/auth.go
+++ b/pkg/server/hook/auth.go
@@ -1,4 +1,4 @@
-package module
+package hook
 
 import (
 	"crypto/md5"
@@ -33,7 +33,7 @@ type auth struct {
 var errDupChallenge = errors.New("peer duplicates challenge")
 var errAuthFail = errors.New("peer auth fail")
 
-type authModule struct{}
+type authHook struct{}
 
 func (a *auth) generateChallenge() error {
 	b := make([]byte, ChallengeLen)
@@ -130,7 +130,7 @@ func getAuthSecret(env env.Env) string {
 	return env.Get("secret")
 }
 
-func (m authModule) Open(env env.Env) (interface{}, error) {
+func (h authHook) Open(env env.Env) (interface{}, error) {
 	a := &auth{
 		secret:        getAuthSecret(env),
 		recvChallenge: make(chan struct{}),
@@ -141,8 +141,10 @@ func (m authModule) Open(env env.Env) (interface{}, error) {
 	return a, nil
 }
 
+func newAuthHook(opts.Opts, env.Env) (hook, error) {
+	return authHook{}, nil
+}
+
 func init() {
-	register("auth", func(opts.Opts, env.Env) (module, error) {
-		return authModule{}, nil
-	})
+	register("auth", newAuthHook)
 }
diff --git a/pkg/server/hook/hex.go b/pkg/server/hook/hex.go
new file mode 100644
index 0000000..beaadeb
--- /dev/null
+++ b/pkg/server/hook/hex.go
@@ -0,0 +1,37 @@
+package hook
+
+import (
+	"encoding/hex"
+	"tunnel/pkg/server/env"
+	"tunnel/pkg/server/opts"
+	"tunnel/pkg/server/queue"
+)
+
+type hexHook struct{}
+
+func (h hexHook) Send(rq, wq queue.Q) error {
+	enc := hex.NewEncoder(wq.Writer())
+
+	for b := range rq {
+		enc.Write(b)
+	}
+
+	return nil
+}
+
+func (h hexHook) Recv(rq, wq queue.Q) error {
+	r := hex.NewDecoder(rq.Reader())
+	return queue.IoCopy(r, wq.Writer())
+}
+
+func (h hexHook) Open(env.Env) (interface{}, error) {
+	return h, nil
+}
+
+func newHexHook(opts.Opts, env.Env) (hook, error) {
+	return hexHook{}, nil
+}
+
+func init() {
+	register("hex", newHexHook)
+}
diff --git a/pkg/server/module/module.go b/pkg/server/hook/hook.go
index c638299..b2970ac 100644
--- a/pkg/server/module/module.go
+++ b/pkg/server/hook/hook.go
@@ -1,4 +1,4 @@
-package module
+package hook
 
 import (
 	"fmt"
@@ -10,16 +10,16 @@ import (
 	"tunnel/pkg/server/queue"
 )
 
-type moduleInitFunc func(opts.Opts, env.Env) (module, error)
+type hookInitFunc func(opts.Opts, env.Env) (hook, error)
 
-var modules = map[string]moduleInitFunc{}
+var hooks = map[string]hookInitFunc{}
 
-type module interface {
+type hook interface {
 	Open(env env.Env) (interface{}, error)
 }
 
-type M interface {
-	module
+type H interface {
+	hook
 	String() string
 }
 
@@ -42,21 +42,21 @@ func (f Func) Open(env env.Env) (interface{}, error) {
 }
 
 type wrapper struct {
-	module
+	hook
 	name    string
 	reverse bool
 }
 
 func (w *wrapper) String() string {
-	return fmt.Sprintf("module:%s", w.name)
+	return fmt.Sprintf("hook:%s", w.name)
 }
 
-func Open(m M, env env.Env) (Func, Func, error) {
+func Open(h H, env env.Env) (Func, Func, error) {
 	var send, recv Func
 
-	w := m.(*wrapper)
+	w := h.(*wrapper)
 
-	it, err := m.Open(env)
+	it, err := h.Open(env)
 	if err != nil {
 		return nil, nil, err
 	}
@@ -76,7 +76,7 @@ func Open(m M, env env.Env) (Func, Func, error) {
 	return send, recv, nil
 }
 
-func New(desc string, env env.Env) (M, error) {
+func New(desc string, env env.Env) (H, error) {
 	name, opts := opts.Parse(desc)
 	reverse := false
 
@@ -85,13 +85,13 @@ func New(desc string, env env.Env) (M, error) {
 		reverse = true
 	}
 
-	if f, ok := modules[name]; !ok {
-		return nil, fmt.Errorf("unknown module '%s'", name)
-	} else if m, err := f(opts, env); err != nil {
+	if f, ok := hooks[name]; !ok {
+		return nil, fmt.Errorf("unknown hook '%s'", name)
+	} else if h, err := f(opts, env); err != nil {
 		return nil, err
 	} else {
 		w := &wrapper{
-			module:  m,
+			hook:    h,
 			name:    name,
 			reverse: reverse,
 		}
@@ -99,16 +99,16 @@ func New(desc string, env env.Env) (M, error) {
 	}
 }
 
-func register(name string, f moduleInitFunc) {
-	if _, ok := modules[name]; ok {
-		log.Panicf("duplicate module name '%s'", name)
+func register(name string, f hookInitFunc) {
+	if _, ok := hooks[name]; ok {
+		log.Panicf("duplicate hook name '%s'", name)
 	}
 
-	modules[name] = f
+	hooks[name] = f
 }
 
 func registerFunc(name string, p Func) {
-	register(name, func(opts.Opts, env.Env) (module, error) {
+	register(name, func(opts.Opts, env.Env) (hook, error) {
 		return p, nil
 	})
 }
@@ -116,7 +116,7 @@ func registerFunc(name string, p Func) {
 func GetList() []string {
 	var list []string
 
-	for k := range modules {
+	for k := range hooks {
 		list = append(list, k)
 	}
 
diff --git a/pkg/server/module/split.go b/pkg/server/hook/split.go
index 139d062..75faf48 100644
--- a/pkg/server/module/split.go
+++ b/pkg/server/hook/split.go
@@ -1,4 +1,4 @@
-package module
+package hook
 
 import (
 	"errors"
@@ -12,16 +12,16 @@ const splitDefaultSize = 1024
 
 var errBadSize = errors.New("bad size value")
 
-type splitModule struct {
+type splitHook struct {
 	size int
 }
 
-func (m *splitModule) Send(rq, wq queue.Q) error {
+func (h *splitHook) Send(rq, wq queue.Q) error {
 	for b := range rq {
 		var upto int
 
 		for n := 0; n < len(b); n = upto {
-			upto += m.size
+			upto += h.size
 
 			if upto > len(b) {
 				upto = len(b)
@@ -34,11 +34,11 @@ func (m *splitModule) Send(rq, wq queue.Q) error {
 	return nil
 }
 
-func (m *splitModule) Open(env.Env) (interface{}, error) {
-	return m, nil
+func (h *splitHook) Open(env.Env) (interface{}, error) {
+	return h, nil
 }
 
-func newSplitModule(opts opts.Opts, env env.Env) (module, error) {
+func newSplitHook(opts opts.Opts, env env.Env) (hook, error) {
 	size := splitDefaultSize
 
 	if s, ok := opts["size"]; ok {
@@ -49,9 +49,9 @@ func newSplitModule(opts opts.Opts, env env.Env) (module, error) {
 		}
 	}
 
-	return &splitModule{size: size}, nil
+	return &splitHook{size: size}, nil
 }
 
 func init() {
-	register("split", newSplitModule)
+	register("split", newSplitHook)
 }
diff --git a/pkg/server/module/tee.go b/pkg/server/hook/tee.go
index 7953247..6591e33 100644
--- a/pkg/server/module/tee.go
+++ b/pkg/server/hook/tee.go
@@ -1,26 +1,27 @@
-package module
+package hook
 
 import (
 	"bytes"
+	"encoding/hex"
 	"fmt"
 	"os"
-	"encoding/hex"
+	"path"
 	"sync"
 	"tunnel/pkg/server/env"
 	"tunnel/pkg/server/opts"
 	"tunnel/pkg/server/queue"
 )
 
-const teeDefaultPath = "/tmp/tunnel.dump"
+const teeDefaultFile = "/tmp/tunnel/dump"
 
 type tee struct {
-	f *os.File
+	f  *os.File
 	mu sync.Mutex
 	wg sync.WaitGroup
 }
 
-type teeModule struct {
-	path string
+type teeHook struct {
+	file string
 }
 
 func (t *tee) dump(s string, p []byte) error {
@@ -61,25 +62,32 @@ func (t *tee) Recv(rq, wq queue.Q) error {
 	return nil
 }
 
-func (m *teeModule) where(env env.Env) string {
-	if m.path != "" {
-		return m.path
+func (h *teeHook) where(env env.Env) string {
+	if h.file != "" {
+		return h.file
 	}
 
-	if v := env.Eval("@{tunnel.@{tunnel}.tee.path}"); v != "" {
+	if v := env.Eval("@{tunnel.@{tunnel}.tee.file}"); v != "" {
 		return v
 	}
 
-	if v, ok := env.Find("module.tee.path"); ok {
+	if v, ok := env.Find("hook.tee.file"); ok {
 		return v
 	}
 
-	return teeDefaultPath
+	return teeDefaultFile
 }
 
-func (m *teeModule) Open(env env.Env) (interface{}, error) {
+func (h *teeHook) Open(env env.Env) (interface{}, error) {
+	file := h.where(env)
+	dir := path.Dir(file)
+
+	if err := os.MkdirAll(dir, 0755); err != nil {
+		return nil, err
+	}
+
 	tid, sid := env.Get("tunnel"), env.Get("stream")
-	name := fmt.Sprintf("%s.%s.%s", m.where(env), tid, sid)
+	name := fmt.Sprintf("%s.%s.%s", file, tid, sid)
 
 	var t tee
 
@@ -99,14 +107,14 @@ func (m *teeModule) Open(env env.Env) (interface{}, error) {
 	return &t, nil
 }
 
-func newTeeModule(opts opts.Opts, env env.Env) (module, error) {
-	m := &teeModule{}
-	if path, ok := opts["path"]; ok {
-		m.path = path
+func newTeeHook(opts opts.Opts, env env.Env) (hook, error) {
+	h := &teeHook{}
+	if file, ok := opts["file"]; ok {
+		h.file = file
 	}
-	return m, nil
+	return h, nil
 }
 
 func init() {
-	register("tee", newTeeModule)
+	register("tee", newTeeHook)
 }
diff --git a/pkg/server/module/zip.go b/pkg/server/hook/zip.go
index b0abb38..61264c9 100644
--- a/pkg/server/module/zip.go
+++ b/pkg/server/hook/zip.go
@@ -1,4 +1,4 @@
-package module
+package hook
 
 import (
 	"compress/flate"
@@ -8,9 +8,9 @@ import (
 	"tunnel/pkg/server/queue"
 )
 
-type zipModule struct{}
+type zipHook struct{}
 
-func (m zipModule) Send(rq, wq queue.Q) error {
+func (m zipHook) Send(rq, wq queue.Q) error {
 	w, err := flate.NewWriter(wq.Writer(), flate.BestCompression)
 	if err != nil {
 		return err
@@ -28,7 +28,7 @@ func (m zipModule) Send(rq, wq queue.Q) error {
 	return w.Close()
 }
 
-func (m zipModule) Recv(rq, wq queue.Q) error {
+func (m zipHook) Recv(rq, wq queue.Q) error {
 	r := flate.NewReader(rq.Reader())
 
 	// FIXME: not received ending due to ultimate conn.Close
@@ -42,14 +42,14 @@ func (m zipModule) Recv(rq, wq queue.Q) error {
 	return r.Close()
 }
 
-func (m zipModule) Open(env.Env) (interface{}, error) {
+func (m zipHook) Open(env.Env) (interface{}, error) {
 	return m, nil
 }
 
-func newZipModule(opts.Opts, env.Env) (module, error) {
-	return zipModule{}, nil
+func newZipHook(opts.Opts, env.Env) (hook, error) {
+	return zipHook{}, nil
 }
 
 func init() {
-	register("zip", newZipModule)
+	register("zip", newZipHook)
 }
diff --git a/pkg/server/module/hex.go b/pkg/server/module/hex.go
deleted file mode 100644
index ef4ff37..0000000
--- a/pkg/server/module/hex.go
+++ /dev/null
@@ -1,37 +0,0 @@
-package module
-
-import (
-	"encoding/hex"
-	"tunnel/pkg/server/env"
-	"tunnel/pkg/server/opts"
-	"tunnel/pkg/server/queue"
-)
-
-type hexModule struct{}
-
-func (m hexModule) Send(rq, wq queue.Q) error {
-	enc := hex.NewEncoder(wq.Writer())
-
-	for b := range rq {
-		enc.Write(b)
-	}
-
-	return nil
-}
-
-func (m hexModule) Recv(rq, wq queue.Q) error {
-	r := hex.NewDecoder(rq.Reader())
-	return queue.IoCopy(r, wq.Writer())
-}
-
-func (m hexModule) Open(env.Env) (interface{}, error) {
-	return m, nil
-}
-
-func newHexModule(opts.Opts, env.Env) (module, error) {
-	return hexModule{}, nil
-}
-
-func init() {
-	register("hex", newHexModule)
-}
diff --git a/pkg/server/tunnel.go b/pkg/server/tunnel.go
index 91d7533..e00db6c 100644
--- a/pkg/server/tunnel.go
+++ b/pkg/server/tunnel.go
@@ -12,7 +12,7 @@ import (
 	"time"
 	"tunnel/pkg/config"
 	"tunnel/pkg/server/env"
-	"tunnel/pkg/server/module"
+	"tunnel/pkg/server/hook"
 	"tunnel/pkg/server/queue"
 	"tunnel/pkg/server/socket"
 )
@@ -41,7 +41,7 @@ type tunnel struct {
 	done chan struct{}
 
 	in, out socket.S
-	m       []module.M
+	hooks   []hook.H
 
 	env env.Env
 }
@@ -187,14 +187,14 @@ func (s *stream) channel(c socket.Channel, rq, wq queue.Q) {
 	}()
 }
 
-func (s *stream) pipe(m module.M, f module.Func, rq, wq queue.Q) {
+func (s *stream) pipe(h hook.H, f hook.Func, rq, wq queue.Q) {
 	s.wg.Add(1)
 
 	go func() {
 		defer s.wg.Done()
 
 		if err := f(rq, wq); err != nil && !errors.Is(err, io.EOF) {
-			log.Println(s.t, s, m, err)
+			log.Println(s.t, s, h, err)
 		}
 
 		close(wq)
@@ -209,23 +209,23 @@ func (s *stream) run() {
 
 	s.channel(s.in, rq, wq)
 
-	for _, m := range s.t.m {
-		send, recv, err := module.Open(m, s.env)
+	for _, h := range s.t.hooks {
+		send, recv, err := hook.Open(h, s.env)
 		if err != nil {
 			// FIXME: abort stream on error
-			log.Println(s.t, s, m, err)
+			log.Println(s.t, s, h, err)
 			continue
 		}
 
 		if send != nil {
 			q := queue.New()
-			s.pipe(m, send, wq, q)
+			s.pipe(h, send, wq, q)
 			wq = q
 		}
 
 		if recv != nil {
 			q := queue.New()
-			s.pipe(m, recv, q, rq)
+			s.pipe(h, recv, q, rq)
 			rq = q
 		}
 	}
@@ -238,23 +238,23 @@ func (s *stream) stop() {
 	s.out.Close()
 }
 
-func parseModules(args []string, env env.Env) ([]module.M, error) {
-	var mm []module.M
+func parseHooks(args []string, env env.Env) ([]hook.H, error) {
+	var hooks []hook.H
 
 	for _, arg := range args {
-		if m, err := module.New(arg, env); err != nil {
+		if h, err := hook.New(arg, env); err != nil {
 			return nil, err
 		} else {
-			mm = append(mm, m)
+			hooks = append(hooks, h)
 		}
 	}
 
-	return mm, nil
+	return hooks, nil
 }
 
 func newTunnel(args []string, env env.Env) (*tunnel, error) {
 	var in, out socket.S
-	var mm []module.M
+	var hooks []hook.H
 	var err error
 
 	n := len(args) - 1
@@ -268,7 +268,7 @@ func newTunnel(args []string, env env.Env) (*tunnel, error) {
 		return nil, err
 	}
 
-	if mm, err = parseModules(args[1:n], env); err != nil {
+	if hooks, err = parseHooks(args[1:n], env); err != nil {
 		in.Close()
 		out.Close()
 		return nil, err
@@ -278,7 +278,7 @@ func newTunnel(args []string, env env.Env) (*tunnel, error) {
 		args:    strings.Join(args, " "),
 		quit:    make(chan struct{}),
 		done:    make(chan struct{}),
-		m:       mm,
+		hooks:   hooks,
 		in:      in,
 		out:     out,
 		env:     env,
@@ -410,9 +410,9 @@ func showStreams(r *request) {
 	})
 }
 
-func showModules(r *request) {
-	for _, m := range module.GetList() {
-		r.Println(m)
+func showHooks(r *request) {
+	for _, h := range hook.GetList() {
+		r.Println(h)
 	}
 }
 
@@ -422,7 +422,7 @@ func init() {
 
 	newCmd(tunnelRename, "rename")
 
-	newCmd(showModules, "modules")
+	newCmd(showHooks, "hooks")
 	newCmd(showStreams, "streams")
 	newCmd(showTunnels, "show")
 }