tux/trok
1
0
Fork 0
mirror of https://github.com/tuxdotrs/trok.git synced 2025-07-06 03:56:33 +05:30
Code Issues Packages Projects Releases Wiki Activity

feat: setup serverAddr and localAddr args

Browse Source
This commit is contained in:
tux
2025-02-27 22:44:26 +05:30
parent b5756cf429
commit b1fac5c28f
4 changed files with 45 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files

14
cmd/client.go
View File

@ -15,17 +15,23 @@ var clientCmd = &cobra.Command{
Short: "Initiates a local proxy to the remote server",
Long: "Initiates a local proxy to the remote server",
Run: func(cmd *cobra.Command, args []string) {
port, err := cmd.Flags().GetUint16("port")
serverAddr, err := cmd.Flags().GetString("serverAddr")
if err != nil {
panic(err)
}
client.Start(port)
localAddr, err := cmd.Flags().GetString("localAddr")
if err != nil {
panic(err)
}
client.Start(serverAddr, localAddr)
},
}
func init() {
rootCmd.AddCommand(clientCmd)
clientCmd.Flags().Uint16P("port", "p", 0, "Local port to expose")
clientCmd.MarkFlagRequired("port")
clientCmd.Flags().StringP("serverAddr", "s", "trok.tux.rs:1337", "Remote server address")
clientCmd.Flags().StringP("localAddr", "a", "0.0.0.0:80", "Local addr to expose")
}

6
internal/client/init.go
View File

@ -11,9 +11,9 @@ import (
"github.com/rs/zerolog/log"
)
func Start(port uint16) {
var trok Trok
if err := trok.Init(port); err != nil {
func Start(serverAddr, localAddr string) {
trok, err := NewTrokClient(serverAddr, localAddr)
if err != nil {
log.Fatal().Msgf("failed init trok %v", err)
}

24
internal/client/tcp.go
View File

@ -5,7 +5,6 @@ Copyright © 2024 tux <0xtux@pm.me>
package client
import (
"fmt"
"net"
)
@ -14,16 +13,13 @@ type TCPClient struct {
conn net.Conn
}
func (c *TCPClient) Init(port uint16, title string) error {
address := fmt.Sprintf(":%d", port)
conn, err := net.Dial("tcp", address)
if err != nil {
return err
}
func NewTCPClient(addr, title string) (*TCPClient, error) {
conn, err := net.Dial("tcp", addr)
c.title = title
c.conn = conn
return nil
return &TCPClient{
title: title,
conn: conn,
}, err
}
func (c *TCPClient) Start(handler func(conn net.Conn)) {
@ -34,6 +30,14 @@ func (c *TCPClient) Stop() error {
return c.conn.Close()
}
func (s *TCPClient) Addr() string {
return s.conn.RemoteAddr().String()
}
func (c *TCPClient) Host() string {
return c.conn.RemoteAddr().(*net.TCPAddr).IP.String()
}
func (c *TCPClient) Port() uint16 {
return uint16(c.conn.RemoteAddr().(*net.TCPAddr).Port)
}

32
internal/client/trok.go
View File

@ -14,22 +14,29 @@ import (
)
type Trok struct {
controlClient TCPClient
controlClient *TCPClient
serverAddr string
localAddr string
}
func (t *Trok) Init(port uint16) error {
err := t.controlClient.Init(port, "Controller")
return err
func NewTrokClient(serverAddr, localAddr string) (*Trok, error) {
controlClient, err := NewTCPClient(serverAddr, "Controller")
return &Trok{
controlClient: controlClient,
serverAddr: serverAddr,
localAddr: localAddr,
}, err
}
func (t *Trok) Start() {
go t.controlClient.Start(t.ControlConnHandler)
log.Info().Msgf("started Trok client on port %d", t.controlClient.Port())
log.Info().Msgf("started Trok client on %s", t.controlClient.Addr())
}
func (t *Trok) Stop() {
t.controlClient.Stop()
log.Info().Msgf("stopped Trok client on port %d", t.controlClient.Port())
log.Info().Msgf("stopped Trok client on %s", t.controlClient.Addr())
}
func (t *Trok) ControlConnHandler(conn net.Conn) {
@ -69,22 +76,19 @@ func (t *Trok) hanldeCMDEHLO(m *lib.Message) {
func (t *Trok) handleCMDCNCT(m *lib.Message) {
log.Info().Msgf("[CMD] %s [ARG] %s", m.CMD, m.ARG)
var upstream TCPClient
var downstream TCPClient
err := upstream.Init(3000, "UpStream")
upStream, err := NewTCPClient(t.localAddr, "UpStream")
if err != nil {
log.Error().Msgf("can't connect to upstream socket: %v", err)
return
}
err = downstream.Init(1421, "DownStream")
downStream, err := NewTCPClient(t.serverAddr, "DownStream")
if err != nil {
log.Error().Msgf("can't connect to downstream socket: %v", err)
return
}
downstream.conn.Write([]byte(fmt.Sprintf("ACPT %s\n", m.ARG)))
go io.Copy(upstream.conn, downstream.conn)
io.Copy(downstream.conn, upstream.conn)
downStream.conn.Write([]byte(fmt.Sprintf("ACPT %s\n", m.ARG)))
go io.Copy(upStream.conn, downStream.conn)
io.Copy(downStream.conn, upStream.conn)
}