bagas/tunnel-please
Public Access
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: improve encapsulation
All checks were successful
renovate / renovate (push) Successful in 20s
Details
Docker Build and Push / build-and-push (push) Successful in 3m25s
Details

Browse Source
This commit is contained in:
bagas
2025-12-29 12:37:03 +07:00
parent b5862bd7a0
commit 2644b4521c
13 changed files with 338 additions and 223 deletions
Download Patch File Download Diff File Expand all files Collapse all files

38
session/forwarder/forwarder.go
View File

@@ -31,11 +31,21 @@ func copyWithBuffer(dst io.Writer, src io.Reader) (written int64, err error) {
}
type Forwarder struct {
Listener net.Listener
TunnelType types.TunnelType
ForwardedPort uint16
SlugManager slug.Manager
Lifecycle Lifecycle
listener net.Listener
tunnelType types.TunnelType
forwardedPort uint16
slugManager slug.Manager
lifecycle Lifecycle
}
func NewForwarder(slugManager slug.Manager) *Forwarder {
return &Forwarder{
listener: nil,
tunnelType: "",
forwardedPort: 0,
slugManager: slugManager,
lifecycle: nil,
}
}
type Lifecycle interface {
@@ -58,7 +68,7 @@ type ForwardingController interface {
}
func (f *Forwarder) SetLifecycle(lifecycle Lifecycle) {
f.Lifecycle = lifecycle
f.lifecycle = lifecycle
}
func (f *Forwarder) AcceptTCPConnections() {
@@ -90,7 +100,7 @@ func (f *Forwarder) AcceptTCPConnections() {
resultChan := make(chan channelResult, 1)
go func() {
channel, reqs, err := f.Lifecycle.GetConnection().OpenChannel("forwarded-tcpip", payload)
channel, reqs, err := f.lifecycle.GetConnection().OpenChannel("forwarded-tcpip", payload)
resultChan <- channelResult{channel, reqs, err}
}()
@@ -164,27 +174,27 @@ func (f *Forwarder) HandleConnection(dst io.ReadWriter, src ssh.Channel, remoteA
}
func (f *Forwarder) SetType(tunnelType types.TunnelType) {
f.TunnelType = tunnelType
f.tunnelType = tunnelType
}
func (f *Forwarder) GetTunnelType() types.TunnelType {
return f.TunnelType
return f.tunnelType
}
func (f *Forwarder) GetForwardedPort() uint16 {
return f.ForwardedPort
return f.forwardedPort
}
func (f *Forwarder) SetForwardedPort(port uint16) {
f.ForwardedPort = port
f.forwardedPort = port
}
func (f *Forwarder) SetListener(listener net.Listener) {
f.Listener = listener
f.listener = listener
}
func (f *Forwarder) GetListener() net.Listener {
return f.Listener
return f.listener
}
func (f *Forwarder) WriteBadGatewayResponse(dst io.Writer) {
@@ -197,7 +207,7 @@ func (f *Forwarder) WriteBadGatewayResponse(dst io.Writer) {
func (f *Forwarder) Close() error {
if f.GetListener() != nil {
return f.Listener.Close()
return f.listener.Close()
}
return nil
}

60
session/handler.go
View File

@@ -49,7 +49,7 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
log.Println("Failed to reply to request:", err)
return
}
err = s.Lifecycle.Close()
err = s.lifecycle.Close()
if err != nil {
log.Printf("failed to close session: %v", err)
}
@@ -59,13 +59,13 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
var rawPortToBind uint32
if err := binary.Read(reader, binary.BigEndian, &rawPortToBind); err != nil {
log.Println("Failed to read port from payload:", err)
s.Interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port. (02) \r\n", rawPortToBind))
s.interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port. (02) \r\n", rawPortToBind))
err := req.Reply(false, nil)
if err != nil {
log.Println("Failed to reply to request:", err)
return
}
err = s.Lifecycle.Close()
err = s.lifecycle.Close()
if err != nil {
log.Printf("failed to close session: %v", err)
}
@@ -73,13 +73,13 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
}
if rawPortToBind > 65535 {
s.Interaction.SendMessage(fmt.Sprintf("Port %d is larger then allowed port of 65535. (02)\r\n", rawPortToBind))
s.interaction.SendMessage(fmt.Sprintf("Port %d is larger then allowed port of 65535. (02)\r\n", rawPortToBind))
err := req.Reply(false, nil)
if err != nil {
log.Println("Failed to reply to request:", err)
return
}
err = s.Lifecycle.Close()
err = s.lifecycle.Close()
if err != nil {
log.Printf("failed to close session: %v", err)
}
@@ -89,13 +89,13 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
portToBind := uint16(rawPortToBind)
if isBlockedPort(portToBind) {
s.Interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port. (02)\r\n", portToBind))
s.interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port. (02)\r\n", portToBind))
err := req.Reply(false, nil)
if err != nil {
log.Println("Failed to reply to request:", err)
return
}
err = s.Lifecycle.Close()
err = s.lifecycle.Close()
if err != nil {
log.Printf("failed to close session: %v", err)
}
@@ -110,26 +110,26 @@ func (s *SSHSession) HandleTCPIPForward(req *ssh.Request) {
unassign, success := portUtil.Default.GetUnassignedPort()
portToBind = unassign
if !success {
s.Interaction.SendMessage("No available port\r\n")
s.interaction.SendMessage("No available port\r\n")
err := req.Reply(false, nil)
if err != nil {
log.Println("Failed to reply to request:", err)
return
}
err = s.Lifecycle.Close()
err = s.lifecycle.Close()
if err != nil {
log.Printf("failed to close session: %v", err)
}
return
}
} else if isUse, isExist := portUtil.Default.GetPortStatus(portToBind); isExist && isUse {
s.Interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port. (03)\r\n", portToBind))
s.interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port. (03)\r\n", portToBind))
err := req.Reply(false, nil)
if err != nil {
log.Println("Failed to reply to request:", err)
return
}
err = s.Lifecycle.Close()
err = s.lifecycle.Close()
if err != nil {
log.Printf("failed to close session: %v", err)
}
@@ -193,21 +193,21 @@ func (s *SSHSession) HandleHTTPForward(req *ssh.Request, portToBind uint16) {
return
}
s.Forwarder.SetType(types.HTTP)
s.Forwarder.SetForwardedPort(portToBind)
s.SlugManager.Set(slug)
s.Interaction.SendMessage("\033[H\033[2J")
s.Interaction.ShowWelcomeMessage()
s.Interaction.SendMessage(fmt.Sprintf("Forwarding your traffic to %s://%s.%s\r\n", protocol, slug, domain))
s.Lifecycle.SetStatus(types.RUNNING)
s.Interaction.HandleUserInput()
s.forwarder.SetType(types.HTTP)
s.forwarder.SetForwardedPort(portToBind)
s.slugManager.Set(slug)
s.interaction.SendMessage("\033[H\033[2J")
s.interaction.ShowWelcomeMessage()
s.interaction.SendMessage(fmt.Sprintf("Forwarding your traffic to %s://%s.%s\r\n", protocol, slug, domain))
s.lifecycle.SetStatus(types.RUNNING)
s.interaction.HandleUserInput()
}
func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind uint16) {
log.Printf("Requested forwarding on %s:%d", addr, portToBind)
listener, err := net.Listen("tcp", fmt.Sprintf("0.0.0.0:%d", portToBind))
if err != nil {
s.Interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port.\r\n", portToBind))
s.interaction.SendMessage(fmt.Sprintf("Port %d is already in use or restricted. Please choose a different port.\r\n", portToBind))
if setErr := portUtil.Default.SetPortStatus(portToBind, false); setErr != nil {
log.Printf("Failed to reset port status: %v", setErr)
}
@@ -216,7 +216,7 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
log.Println("Failed to reply to request:", err)
return
}
err = s.Lifecycle.Close()
err = s.lifecycle.Close()
if err != nil {
log.Printf("failed to close session: %v", err)
}
@@ -253,15 +253,15 @@ func (s *SSHSession) HandleTCPForward(req *ssh.Request, addr string, portToBind
return
}
s.Forwarder.SetType(types.TCP)
s.Forwarder.SetListener(listener)
s.Forwarder.SetForwardedPort(portToBind)
s.Interaction.SendMessage("\033[H\033[2J")
s.Interaction.ShowWelcomeMessage()
s.Interaction.SendMessage(fmt.Sprintf("Forwarding your traffic to tcp://%s:%d \r\n", utils.Getenv("DOMAIN", "localhost"), s.Forwarder.GetForwardedPort()))
s.Lifecycle.SetStatus(types.RUNNING)
go s.Forwarder.AcceptTCPConnections()
s.Interaction.HandleUserInput()
s.forwarder.SetType(types.TCP)
s.forwarder.SetListener(listener)
s.forwarder.SetForwardedPort(portToBind)
s.interaction.SendMessage("\033[H\033[2J")
s.interaction.ShowWelcomeMessage()
s.interaction.SendMessage(fmt.Sprintf("Forwarding your traffic to tcp://%s:%d \r\n", utils.Getenv("DOMAIN", "localhost"), s.forwarder.GetForwardedPort()))
s.lifecycle.SetStatus(types.RUNNING)
go s.forwarder.AcceptTCPConnections()
s.interaction.HandleUserInput()
}
func generateUniqueSlug() string {

114
session/interaction/interaction.go
View File

@@ -42,21 +42,37 @@ type Forwarder interface {
}
type Interaction struct {
InputLength int
CommandBuffer *bytes.Buffer
InteractiveMode bool
InteractionType types.InteractionType
EditSlug string
inputLength int
commandBuffer *bytes.Buffer
interactiveMode bool
interactionType types.InteractionType
editSlug string
channel ssh.Channel
SlugManager slug.Manager
Forwarder Forwarder
Lifecycle Lifecycle
slugManager slug.Manager
forwarder Forwarder
lifecycle Lifecycle
pendingExit bool
updateClientSlug func(oldSlug, newSlug string) bool
}
func NewInteraction(slugManager slug.Manager, forwarder Forwarder) *Interaction {
return &Interaction{
inputLength: 0,
commandBuffer: bytes.NewBuffer(make([]byte, 0, 20)),
interactiveMode: false,
interactionType: "",
editSlug: "",
channel: nil,
slugManager: slugManager,
forwarder: forwarder,
lifecycle: nil,
pendingExit: false,
updateClientSlug: nil,
}
}
func (i *Interaction) SetLifecycle(lifecycle Lifecycle) {
i.Lifecycle = lifecycle
i.lifecycle = lifecycle
}
func (i *Interaction) SetChannel(channel ssh.Channel) {
@@ -77,7 +93,7 @@ func (i *Interaction) SendMessage(message string) {
func (i *Interaction) HandleUserInput() {
buf := make([]byte, 1)
i.InteractiveMode = false
i.interactiveMode = false
for {
n, err := i.channel.Read(buf)
@@ -99,7 +115,7 @@ func (i *Interaction) handleReadError(err error) {
}
func (i *Interaction) processCharacter(char byte) {
if i.InteractiveMode {
if i.interactiveMode {
i.handleInteractiveMode(char)
return
}
@@ -113,7 +129,7 @@ func (i *Interaction) processCharacter(char byte) {
}
func (i *Interaction) handleInteractiveMode(char byte) {
switch i.InteractionType {
switch i.interactionType {
case types.Slug:
i.HandleSlugEditMode(char)
}
@@ -123,7 +139,7 @@ func (i *Interaction) handleExitSequence(char byte) bool {
if char == ctrlC {
if i.pendingExit {
i.SendMessage("Closing connection...\r\n")
if err := i.Lifecycle.Close(); err != nil {
if err := i.lifecycle.Close(); err != nil {
log.Printf("failed to close session: %v", err)
}
return true
@@ -147,37 +163,37 @@ func (i *Interaction) handleNonInteractiveInput(char byte) {
i.handleBackspace()
case char == forwardSlash:
i.handleCommandStart()
case i.CommandBuffer.Len() > 0:
case i.commandBuffer.Len() > 0:
i.handleCommandInput(char)
case char == enterChar:
i.SendMessage(clearLine)
default:
i.InputLength++
i.inputLength++
}
}
func (i *Interaction) handleBackspace() {
if i.InputLength > 0 {
if i.inputLength > 0 {
i.SendMessage(backspaceSeq)
}
if i.CommandBuffer.Len() > 0 {
i.CommandBuffer.Truncate(i.CommandBuffer.Len() - 1)
if i.commandBuffer.Len() > 0 {
i.commandBuffer.Truncate(i.commandBuffer.Len() - 1)
}
}
func (i *Interaction) handleCommandStart() {
i.CommandBuffer.Reset()
i.CommandBuffer.WriteByte(forwardSlash)
i.commandBuffer.Reset()
i.commandBuffer.WriteByte(forwardSlash)
}
func (i *Interaction) handleCommandInput(char byte) {
if char == enterChar {
i.SendMessage(clearLine)
i.HandleCommand(i.CommandBuffer.String())
i.HandleCommand(i.commandBuffer.String())
return
}
i.CommandBuffer.WriteByte(char)
i.InputLength++
i.commandBuffer.WriteByte(char)
i.inputLength++
}
func (i *Interaction) HandleSlugEditMode(char byte) {
@@ -194,15 +210,15 @@ func (i *Interaction) HandleSlugEditMode(char byte) {
}
func (i *Interaction) handleSlugBackspace() {
if len(i.EditSlug) > 0 {
i.EditSlug = i.EditSlug[:len(i.EditSlug)-1]
if len(i.editSlug) > 0 {
i.editSlug = i.editSlug[:len(i.editSlug)-1]
i.refreshSlugDisplay()
}
}
func (i *Interaction) appendToSlug(char byte) {
if isValidSlugChar(char) {
i.EditSlug += string(char)
if len(i.editSlug) < maxSlugLength {
i.editSlug += string(char)
i.refreshSlugDisplay()
}
}
@@ -210,16 +226,16 @@ func (i *Interaction) appendToSlug(char byte) {
func (i *Interaction) refreshSlugDisplay() {
domain := utils.Getenv("DOMAIN", "localhost")
i.SendMessage(clearToLineEnd)
i.SendMessage("➤ " + i.EditSlug + "." + domain)
i.SendMessage("➤ " + i.editSlug + "." + domain)
}
func (i *Interaction) HandleSlugSave() {
i.SendMessage(clearScreen)
switch {
case isForbiddenSlug(i.EditSlug):
case isForbiddenSlug(i.editSlug):
i.showForbiddenSlugMessage()
case !isValidSlug(i.EditSlug):
case !isValidSlug(i.editSlug):
i.showInvalidSlugMessage()
default:
i.updateSlug()
@@ -230,8 +246,8 @@ func (i *Interaction) HandleSlugSave() {
}
func (i *Interaction) updateSlug() {
oldSlug := i.SlugManager.Get()
newSlug := i.EditSlug
oldSlug := i.slugManager.Get()
newSlug := i.editSlug
if !i.updateClientSlug(oldSlug, newSlug) {
i.HandleSlugUpdateError()
@@ -262,8 +278,8 @@ func (i *Interaction) returnToMainScreen() {
i.SendMessage(clearScreen)
i.ShowWelcomeMessage()
i.ShowForwardingMessage()
i.InteractiveMode = false
i.CommandBuffer.Reset()
i.interactiveMode = false
i.commandBuffer.Reset()
}
func (i *Interaction) HandleSlugCancel() {
@@ -271,8 +287,8 @@ func (i *Interaction) HandleSlugCancel() {
i.SendMessage("\r\n\r\n⚠️ SUBDOMAIN EDIT CANCELLED ⚠️\r\n\r\n")
i.SendMessage("Press any key to continue...\r\n")
i.InteractiveMode = false
i.InteractionType = ""
i.interactiveMode = false
i.interactionType = ""
i.WaitForKeyPress()
i.SendMessage(clearScreen)
@@ -289,7 +305,7 @@ func (i *Interaction) HandleSlugUpdateError() {
time.Sleep(1 * time.Second)
}
if err := i.Lifecycle.Close(); err != nil {
if err := i.lifecycle.Close(); err != nil {
log.Printf("failed to close session: %v", err)
}
}
@@ -308,12 +324,12 @@ func (i *Interaction) HandleCommand(command string) {
i.SendMessage("Unknown command\r\n")
}
i.CommandBuffer.Reset()
i.commandBuffer.Reset()
}
func (i *Interaction) handleByeCommand() {
i.SendMessage("Closing connection...\r\n")
if err := i.Lifecycle.Close(); err != nil {
if err := i.lifecycle.Close(); err != nil {
log.Printf("failed to close session: %v", err)
}
}
@@ -329,32 +345,32 @@ func (i *Interaction) handleClearCommand() {
}
func (i *Interaction) handleSlugCommand() {
if i.Forwarder.GetTunnelType() != types.HTTP {
i.SendMessage(fmt.Sprintf("\r\n%s tunnels cannot have custom subdomains\r\n", i.Forwarder.GetTunnelType()))
if i.forwarder.GetTunnelType() != types.HTTP {
i.SendMessage(fmt.Sprintf("\r\n%s tunnels cannot have custom subdomains\r\n", i.forwarder.GetTunnelType()))
return
}
i.InteractiveMode = true
i.InteractionType = types.Slug
i.EditSlug = i.SlugManager.Get()
i.interactiveMode = true
i.interactionType = types.Slug
i.editSlug = i.slugManager.Get()
i.SendMessage(clearScreen)
i.DisplaySlugEditor()
domain := utils.Getenv("DOMAIN", "localhost")
i.SendMessage("➤ " + i.EditSlug + "." + domain)
i.SendMessage("➤ " + i.editSlug + "." + domain)
}
func (i *Interaction) ShowForwardingMessage() {
domain := utils.Getenv("DOMAIN", "localhost")
if i.Forwarder.GetTunnelType() == types.HTTP {
if i.forwarder.GetTunnelType() == types.HTTP {
protocol := "http"
if utils.Getenv("TLS_ENABLED", "false") == "true" {
protocol = "https"
}
i.SendMessage(fmt.Sprintf("Forwarding your traffic to %s://%s.%s \r\n", protocol, i.SlugManager.Get(), domain))
i.SendMessage(fmt.Sprintf("Forwarding your traffic to %s://%s.%s \r\n", protocol, i.slugManager.Get(), domain))
} else {
i.SendMessage(fmt.Sprintf("Forwarding your traffic to tcp://%s:%d \r\n", domain, i.Forwarder.GetForwardedPort()))
i.SendMessage(fmt.Sprintf("Forwarding your traffic to tcp://%s:%d \r\n", domain, i.forwarder.GetForwardedPort()))
}
}
@@ -385,7 +401,7 @@ func (i *Interaction) ShowWelcomeMessage() {
func (i *Interaction) DisplaySlugEditor() {
domain := utils.Getenv("DOMAIN", "localhost")
fullDomain := i.SlugManager.Get() + "." + domain
fullDomain := i.slugManager.Get() + "." + domain
contentLine := " ║ Current: " + fullDomain
boxWidth := calculateBoxWidth(contentLine)

49
session/lifecycle/lifecycle.go
View File

@@ -22,16 +22,27 @@ type Forwarder interface {
}
type Lifecycle struct {
Status types.Status
Conn ssh.Conn
Channel ssh.Channel
Interaction Interaction
Forwarder Forwarder
SlugManager slug.Manager
status types.Status
conn ssh.Conn
channel ssh.Channel
interaction Interaction
forwarder Forwarder
slugManager slug.Manager
unregisterClient func(slug string)
}
func NewLifecycle(conn ssh.Conn, interaction Interaction, forwarder Forwarder, slugManager slug.Manager) *Lifecycle {
return &Lifecycle{
status: "",
conn: conn,
channel: nil,
interaction: interaction,
forwarder: forwarder,
slugManager: slugManager,
unregisterClient: nil,
}
}
func (l *Lifecycle) SetUnregisterClient(unregisterClient func(slug string)) {
l.unregisterClient = unregisterClient
}
@@ -46,46 +57,46 @@ type SessionLifecycle interface {
}
func (l *Lifecycle) GetChannel() ssh.Channel {
return l.Channel
return l.channel
}
func (l *Lifecycle) SetChannel(channel ssh.Channel) {
l.Channel = channel
l.channel = channel
}
func (l *Lifecycle) GetConnection() ssh.Conn {
return l.Conn
return l.conn
}
func (l *Lifecycle) SetStatus(status types.Status) {
l.Status = status
l.status = status
}
func (l *Lifecycle) Close() error {
err := l.Forwarder.Close()
err := l.forwarder.Close()
if err != nil && !errors.Is(err, net.ErrClosed) {
return err
}
if l.Channel != nil {
err := l.Channel.Close()
if l.channel != nil {
err := l.channel.Close()
if err != nil && !errors.Is(err, io.EOF) {
return err
}
}
if l.Conn != nil {
err := l.Conn.Close()
if l.conn != nil {
err := l.conn.Close()
if err != nil && !errors.Is(err, net.ErrClosed) {
return err
}
}
clientSlug := l.SlugManager.Get()
clientSlug := l.slugManager.Get()
if clientSlug != "" {
l.unregisterClient(clientSlug)
}
if l.Forwarder.GetTunnelType() == types.TCP {
err := portUtil.Default.SetPortStatus(l.Forwarder.GetForwardedPort(), false)
if l.forwarder.GetTunnelType() == types.TCP {
err := portUtil.Default.SetPortStatus(l.forwarder.GetForwardedPort(), false)
if err != nil {
return err
}

70
session/session.go
View File

@@ -1,7 +1,6 @@
package session
import (
"bytes"
"fmt"
"log"
"sync"
@@ -28,36 +27,33 @@ type Session interface {
}
type SSHSession struct {
Lifecycle lifecycle.SessionLifecycle
Interaction interaction.Controller
Forwarder forwarder.ForwardingController
SlugManager slug.Manager
lifecycle lifecycle.SessionLifecycle
interaction interaction.Controller
forwarder forwarder.ForwardingController
slugManager slug.Manager
}
func (s *SSHSession) GetLifecycle() lifecycle.SessionLifecycle {
return s.lifecycle
}
func (s *SSHSession) GetInteraction() interaction.Controller {
return s.interaction
}
func (s *SSHSession) GetForwarder() forwarder.ForwardingController {
return s.forwarder
}
func (s *SSHSession) GetSlugManager() slug.Manager {
return s.slugManager
}
func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan ssh.NewChannel) {
slugManager := slug.NewManager()
forwarderManager := &forwarder.Forwarder{
Listener: nil,
TunnelType: "",
ForwardedPort: 0,
SlugManager: slugManager,
}
interactionManager := &interaction.Interaction{
CommandBuffer: bytes.NewBuffer(make([]byte, 0, 20)),
InteractiveMode: false,
EditSlug: "",
SlugManager: slugManager,
Forwarder: forwarderManager,
Lifecycle: nil,
}
lifecycleManager := &lifecycle.Lifecycle{
Status: "",
Conn: conn,
Channel: nil,
Interaction: interactionManager,
Forwarder: forwarderManager,
SlugManager: slugManager,
}
forwarderManager := forwarder.NewForwarder(slugManager)
interactionManager := interaction.NewInteraction(slugManager, forwarderManager)
lifecycleManager := lifecycle.NewLifecycle(conn, interactionManager, forwarderManager, slugManager)
interactionManager.SetLifecycle(lifecycleManager)
interactionManager.SetSlugModificator(updateClientSlug)
@@ -65,10 +61,10 @@ func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan
lifecycleManager.SetUnregisterClient(unregisterClient)
session := &SSHSession{
Lifecycle: lifecycleManager,
Interaction: interactionManager,
Forwarder: forwarderManager,
SlugManager: slugManager,
lifecycle: lifecycleManager,
interaction: interactionManager,
forwarder: forwarderManager,
slugManager: slugManager,
}
var once sync.Once
@@ -79,13 +75,13 @@ func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan
continue
}
once.Do(func() {
session.Lifecycle.SetChannel(ch)
session.Interaction.SetChannel(ch)
session.lifecycle.SetChannel(ch)
session.interaction.SetChannel(ch)
tcpipReq := session.waitForTCPIPForward(forwardingReq)
if tcpipReq == nil {
session.Interaction.SendMessage(fmt.Sprintf("Port forwarding request not received.\r\nEnsure you ran the correct command with -R flag.\r\nExample: ssh %s -p %s -R 80:localhost:3000\r\nFor more details, visit https://tunnl.live.\r\n\r\n", utils.Getenv("DOMAIN", "localhost"), utils.Getenv("PORT", "2200")))
if err := session.Lifecycle.Close(); err != nil {
session.interaction.SendMessage(fmt.Sprintf("Port forwarding request not received.\r\nEnsure you ran the correct command with -R flag.\r\nExample: ssh %s -p %s -R 80:localhost:3000\r\nFor more details, visit https://tunnl.live.\r\n\r\n", utils.Getenv("DOMAIN", "localhost"), utils.Getenv("PORT", "2200")))
if err := session.lifecycle.Close(); err != nil {
log.Printf("failed to close session: %v", err)
}
return
@@ -94,7 +90,7 @@ func New(conn *ssh.ServerConn, forwardingReq <-chan *ssh.Request, sshChan <-chan
})
go session.HandleGlobalRequest(reqs)
}
if err := session.Lifecycle.Close(); err != nil {
if err := session.lifecycle.Close(); err != nil {
log.Printf("failed to close session: %v", err)
}
}
@@ -134,7 +130,7 @@ func updateClientSlug(oldSlug, newSlug string) bool {
}
delete(Clients, oldSlug)
client.SlugManager.Set(newSlug)
client.slugManager.Set(newSlug)
Clients[newSlug] = client
return true
}