bsck

package module
v2.0.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 19, 2020 License: GPL-3.0 Imports: 22 Imported by: 0

README

Bond Socket

bond socket provider a server/client channel like ssh tunneling, it can forward port between multi node.

Features

  • auto reconnect and keepalive betwenn client to server.
  • control forward by dynamic uri like node1->node2->tcp://xxxx:xx
  • port forward between multi node, it can be normal client -> bsck server -> normal server or normal client -> bsck server -> bsck slaver -> normal server or normal client -> bsck client -> bsck server -> bsck slaver -> normal server or ...
    • case1: ssh client -> bsck client -> bsck server -> ssh server for solving ssh connect lost frequently and ssh once to inner server.
    • case2: browser -> bsck client -> bsck server -> web server for browser to inner web server.
  • provider bash access on each node.
  • provider webdav access on each node.
  • provider remote execute command on each node.
  • provider balanced socks5 server that using node in bsck router as proxy server or multi upstream socks5 server.
  • provider gui to edit forward/channel configure.

Package Reference

  • bsck the main code to implement bond socket, it export all api to embedd bond socket in app.
  • dialer the main code to implement dial to raw socket or other useful feature like bash/webdav.
    • echo run an echo server, it always is using when using bs-ping command
    • cmd start comamnd on node and pipe standard i/o as bsck connect.
    • web start webdav server on node and pipe it as bsck connect.
    • tcp dial tcp connect to other server and pipe it as bsck connect.
  • bsrouter the app to start bond socket node, it run bsck server/client/slaver at the same time.
    • gui the gui app to start bond socket client, it can edit forward/channel.
  • bsconsole the agent app to make noraml app can using bond socket.

Install

Manual Install
  • install basic comamnd
go get github.com/sutils/bsck/bsrouter
go get github.com/sutils/bsck/bsconsole
  • install other command
cp -f $GOPATH/src/github.com/sutils/bsck/bsconsole/bs-ssh.sh $GOPATH/bin/bs-ssh
cp -f $GOPATH/src/github.com/sutils/bsck/bsconsole/bs-scp.sh $GOPATH/bin/bs-scp
cp -f $GOPATH/src/github.com/sutils/bsck/bsconsole/bs-sftp.sh $GOPATH/bin/bs-sftp
ln -sf $GOPATH/bin/bsconsole $GOPATH/bin/bs-ping
ln -sf $GOPATH/bin/bsconsole $GOPATH/bin/bs-state
ln -sf $GOPATH/bin/bsconsole $GOPATH/bin/bs-bash
ln -sf $GOPATH/bin/bsconsole $GOPATH/bin/bs-sh
Install from binary
  • download binary from releases
  • uncompress to xx
  • cd xx/bsrouter
  • ./bsrouter-install.sh -i -c for client or ./bsrouter-install.sh -i -s for service

Command Reference

  • bsrouter start bond socket server/client/slaver by configure, it will auto scan configure ordered by args,./.bsrouter.json",./bsrouter.json,HOME/.bsrouter/bsrouter.json,HOME/.bsrouter.json,/etc/bsrouter/bsrouter.json,/etc/bsrouer.json
  • bsconsole the node agent command, it will auto scan configure ordered like bsrouter
    • bsconsole 'node1->tcp://cmd?exec=bash' connect to node bash
    • bsconsole 'node1->tcp://cmd?exec=xxx' start xxx command on node1
    • bsconsole -win32 'node1->tcp://cmd?exec=cmd' start window cmd on node1
  • bs-bash <node router> connect to node bash, equal to bsconsole 'node1->tcp://cmd?exec=bash'
  • bs-sh <node router> connect to node sh, equal to bsconsole 'node1->tcp://cmd?exec=sh'
  • bs-ping <node router> ping to node
    • bs-ping node1 ping to node1
    • bs-ping 'node1->nodex' ping to nodex by router node1->nodex
  • bs-state <node router> list node state
    • bs-state node1 list node1 state
    • bs-state 'node1->nodex' list nodex state
  • bs-ssh <bsck uri> <ssh options> start ssh connect
    • bs-ssh 'node1->tcp://xxx:22' -lroot start connect ssh server which after node1
  • bs-sftp <bsck uri> <ssh options> start sftp connect
    • bs-sftp 'node1->tcp://xxx:22' -lroot start sftp to ssh server which after node1
  • bs-scp <bsck uri> <scp options> start scp connect
    • bs-scp 'node1->tcp://xxx:22' xxx root@bshost:/tmp/ copy xxx file to server after node1, the bshost will be auto repeaced.

Configure

configure file reference

  • name the node name

  • listen the node listen port.

  • cert,key the ssl cert

  • dialer the raw connect dialer configure.

    • std enable all standard dialer by 1, it container cmd,echo,web,tcp dialer. if only want enable some dialer, can be
    {
  "dialer": {
      "cmd": {
          "PS1": "xxx"
      },
      "echo":{

      }
  }
}

  • acl the access control on bsck server

  • web listen web and websocket on address, it always is used by bsconsole

  • socks5 listen socks5 on address, it always is used by bsconsole or socks5 balance server.

bsck server
  • generate ssl cert by
openssl req -new -nodes -x509 -out "/etc/bsrouter/bsrouter.pem" -keyout "/etc/bsrouter/bsrouter.key" -days 3650 -subj "/C=CN/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=xxx/emailAddress=cert@xxxx"
  • edit configure on /etc/bsrouter/bsrouter.json
{
    "name": "server1",
    "listen": ":12023",
    "cert": "/etc/bsrouter/bsrouter.pem",
    "key": "/etc/bsrouter/bsrouter.key",
    "dialer": {
        "std": 1
    },
    "acl": {
        "slave1": "1111",
        "client1": "2222"
    },
    "showlog": 0,
    "logflags": 16
}
bsck slaver
  • generate ssl cert by
openssl req -new -nodes -x509 -out "/etc/bsrouter/bsrouter.pem" -keyout "/etc/bsrouter/bsrouter.key" -days 3650 -subj "/C=CN/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=xxx/emailAddress=cert@xxxx"
  • edit configure on /etc/bsrouter/bsrouter.json
{
    "name": "slave1",
    "cert": "/etc/bsrouter/bsrouter.pem",
    "key": "/etc/bsrouter/bsrouter.key",
    "dialer": {
        "std": 1
    },
    "channels": [
        {
            "enable": true,
            "token": "1111",
            "local": "",
            "remote": "xxx:12023",
            "index": 0
        }
    ],
    "showlog": 0,
    "logflags": 16
}
bsck client
  • generate ssl cert by
openssl req -new -nodes -x509 -out "$HOME/.bsrouter/bsrouter.pem" -keyout "$HOME/.bsrouter/bsrouter.key" -days 3650 -subj "/C=CN/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=xxx/emailAddress=cert@xxxx"
  • edit configure on $HOME/.bsrouter/bsrouter.json
{
    "name": "client1",
    "cert": "/xx/.bsrouter/bsrouter.pem",
    "key": "/xx/.bsrouter/bsrouter.key",
    "web": {
        "auth": "",
        "listen": ":12024",
        "suffix": ""
    },
    "channels": [
        {
            "enable": true,
            "token": "2222",
            "local": "",
            "remote": "xxx:12023",
            "index": 0
        }
    ],
    "showlog": 0,
    "logflags": 16
}
testing (optional)
  • bs-ping server1 test connect to server1 (optional)
bsconsole using config /xxx/.bsrouter/bsrouter.json
64 Bytes from server1->tcp://echo time=9.600463ms
64 Bytes from server1->tcp://echo time=5.248072ms
  • bs-ping 'server1->slaver1' test connect to slaver1 (optional)
bsconsole using config /xxx/.bsrouter/bsrouter.json
64 Bytes from server1->slaver1->tcp://echo time=11.600463ms
64 Bytes from server1->slaver1->tcp://echo time=12.248072ms
  • bs-state get client1 state when do ping (optional)
bsconsole using config /Users/vty/.bsrouter/bsrouter.json
[Channels]
 ->server1
   0    5   2018-10-24 11:30:33   channel{name:server1,index:0,cid:44,info:x.x.x.x:12023}


[Table]
 channel{name:server1,index:0,cid:44,info:x.x.x.x:12023} 52 <-> raw{uri:tcp://echo,router:server1->tcp://echo,info:ws://:12024} 52
  • bsconsole server1 start bash on server1 (optional)
bsconsole using config /xxx/.bsrouter/bsrouter.json
[bsrouter@xx ~]$
  • bs-ssh 'server1->slaver1->tcp://x.x.x.x:22' -lroot test connect to ssh server (optional)
configure port forward permanent
  • edit /xx/.bsrouter/bsrouter.json and add forwards configure.
{
    "name": "client1",
    "cert": "/xx/.bsrouter/bsrouter.pem",
    "key": "/xx/.bsrouter/bsrouter.key",
    "web": {
        "auth": "",
        "listen": ":12024",
        "suffix": ""
    },
    "channels": [
        {
            "enable": true,
            "token": "2222",
            "local": "",
            "remote": "xxx:12023",
            "index": 0
        }
    ],
    "forwards": {
        "test1~ws://": "server1->tcp://host1:22",
        "test1-1~tcp://localhost:10022": "server1->slaver1->tcp://host1:22",
        "test2~vnc://localhost": "server1->slaver1->tcp://host2:5900",
        "test2-1~tcp://localhost:15900": "server1->slaver1->tcp://host2:5900",
        "test3~rdp://localhost": "server1->slaver1->tcp://host3:3389"
        "test3-1~tcp://localhost:13389": "server1->slaver1->tcp://host3:3389"
        "test4~ws://": "server1->slaver1->tcp://cmd?exec=ping www.google.com"
    },
    "rdp_dir": "/tmp/bsrouter/",
    "vnc_dir": "/tmp/bsrouter/",
    "showlog": 0,
    "logflags": 16
}

  • in this case, bsck foward ssh/vnc/rdp

    • bs-ssh test1 -lroot to ssh connect host1
    • ssh -p 10022 localhost -lroot to ssh connect host1
    • connect host2 by vnc client: open vnc client then open test2.vnc file on /tmp/bsrouter/
    • connect host2 by vnc client: open vnc client then using localhost:15900 to connect
    • connect host3 by rdp client: open rdp client then open test3.rdp file on /tmp/bsrouter/
    • connect host3 by rdp client: open rdp client then using localhost:13389 to connect
    • bsconsole test4 execute ping on slaver1

  • more for forward configure, see Forward Reference

configure balance socks5 proxy
  • edit /xx/.bsrouter/bsrouter.json and add proxy configure.
{
    "name": "client1",
    "cert": "/xx/.bsrouter/bsrouter.pem",
    "key": "/xx/.bsrouter/bsrouter.key",
    "web": {
        "auth": "",
        "listen": ":12024",
        "suffix": ""
    },
    "socks5": ":11081",
    "channels": [
        {
            "enable": true,
            "token": "2222",
            "local": "",
            "remote": "xxx:12023",
            "index": 0
        }
    ],
    "proxy": {
        "id": "proxy",
        "type": "balance",
        "matcher": "^.*://.*$",
        "dialers": [
            {
                "id": "r1",
                "type": "router",
                "router": "server1->${URI}"
            },
            {
                "id": "r2",
                "type": "router",
                "router": "server1->slaver1->${URI}"
            },
            ,
            {
                "id": "r3",
                "type": "socks",
                "address": "xxx:xxx"
            }
        ],
        "filter": [
            {
                "matcher": "^.*x1.*$",
                "access": 1
            },
            {
                "matcher": "^.*x2.*$",
                "access": 1
            },
            {
                "matcher": "^.*$",
                "access": 0
            }
        ],
        "policy": [
            {
                "matcher": "^.*x1.*$",
                "limit": [
                    3000,
                    10
                ]
            },
            {
                "matcher": "^.*x2.*$",
                "limit": [
                    3000,
                    10
                ]
            }
        ]
    },
    "showlog": 0,
    "logflags": 16
}
  • in this case, havin two proxy dialer in two router server,slaver1 and one upstream proxy, only host contain x1,x2 can connect, and limit x1,x2 connect count by 10 time per 3000ms. this case is always used on crawler.

Dialer Reference

cmd
{
    "dialer": {
        "cmd": {
            "PS1": "bsrouter",
            "Dir": "/tmp",
            "Env":{
                "a": 1,
                "b": 2
            }
        }
    }
}
  • PS1 the shell ps1
  • Dir the start directroy
  • LC the i/o encoding.
  • Env the enviroment values
  • reuse_timeout the reuse session timeout.
echo
{
    "dialer": {
        "echo": {}
    }
}
socks
{
    "dialer": {
        "socks": {
            "id": "s1",
            "address": "xxx:xx",
            "matcher": "^.*$"
        }
    }
}
  • id the dialer id (required)
  • address the socks5 server address (required)
  • matcher match uri to access to connect. (optional)
web
{
    "dialer": {
        "web": {}
    }
}
tcp
{
    "dialer": {
        "tcp": {
            "bind": "xxxx:xx"
        }
    }
}
  • bind bind to local address before connect to remote.

Forward Reference

remote uri

the remote uri scheme is node1->node1->..->nodex->protocol://host:port?arg=val

supported protocol

  • tcp://host:port?arg=val normal tcp dialer, the arguments
    • bind bind to local address before connect to remote (optional)
  • tcp://cmd?arg=val execute command on node
    • exec the command and command argument to exec (required)
    • LC the i/o encoding
    • reuse enable/disable reuse session, 1 is enable, 0 is disable.
  • tcp://echo start echo server
  • http://web start web server on node
    • dir the webdav work directory.
local uri

the local uri scheme is alias~protocol://user:password@host:port, the alias can be used on bsconsole,bs-sftp,bs-scp,bs-ssh

supported protocol

  • alias~tcp://host:port listen tcp by host:port
  • alias~socks://host:port listen socks5 by host:port,
  • alias~rdp://user@host:port listen tcp by host:port, and generate rdp file on rdp_dir by alias.rdp, password is not supported by rdp file
  • alias~vnc://:passwrod@host:port listen tcp by host:port, and generate rdp file on vnc_dir by alias.vnc, user is not needed, password is encrypted
  • alias~web:// foward web by http://localhost:port/dav/alias to uri when web configure is enabled.
  • alias~ws:// foward websocekt by ws://localhost:port/ws/alias to uri when web configure is enabled.

GUI Reference

  • generate ssl cert by
openssl req -new -nodes -x509 -out "./bsrouter.pem" -keyout "./bsrouter.key" -days 3650 -subj "/C=CN/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=xxx/emailAddress=cert@xxxx"

  • copy bsrouter.pem,bsrouter.key to ~/.bsrouter/

  • open GUI program and edit basic,channels,forwards

Documentation

Overview

Package bsck provider tcp socket proxy router

the supported router is client->(slaver->master->slaver)*-server,

the channel of slaver to master can be multi physical tcp connect by different router

Index

Constants

View Source 
const (
	//CmdLogin is the command of login to master
	CmdLogin = 10
	//CmdLoginBack is the command of login return from master
	CmdLoginBack = 11
	//CmdDial is the command of tcp dial by router
	CmdDial = 100
	//CmdDialBack is the command of tcp dial back from master/slaver
	CmdDialBack = 101
	//CmdData is the command of transfter tcp data
	CmdData = 110
	//CmdClosed is the command of tcp closed.
	CmdClosed = 120
	//CmdHeartbeat is the command of heartbeat on slaver/master
	CmdHeartbeat = 130
)
View Source 
const (
	//ConnTypeRaw is the type of raw connection
	ConnTypeRaw = 100
	//ConnTypeChannel is the type of channel connection
	ConnTypeChannel = 200
)
View Source 
const (
	SocksUriTypeNormal = 0
	SocksUriTypeBS     = 1
)

Variables

View Source 
var Log = log.New(os.Stdout, "", log.Ldate|log.Lmicroseconds|log.Lshortfile)

Log is the bsck package default log

View Source 
var LogLevel int = 3

LogLevel is log leveo config

View Source 
var ShowLog = 0

ShowLog will show more log.

Functions

func DebugLog 

func DebugLog(format string, args ...interface{})

DebugLog is log by debug level

func ErrorLog 

func ErrorLog(format string, args ...interface{})

ErrorLog is log by error level

func InfoLog 

func InfoLog(format string, args ...interface{})

InfoLog is log by info level

func WarnLog 

func WarnLog(format string, args ...interface{})

WarnLog is log by warn level

Types

type AuthOption 

type AuthOption struct {
	//the channel index
	Index int `json:"index"`
	//the chnnale name
	Name string `json:"name"`
	//the auth token
	Token string `json:"token"`
}

AuthOption is a pojo struct to login auth.

type Channel 

type Channel struct {
	frame.ReadWriteCloser //the raw connection

	Heartbeat int64
	// contains filtered or unexported fields
}

Channel is an implementation of the Conn interface for channel network connections.

func (*Channel) Context 

func (c *Channel) Context() interface{}

Context is conn context getter

func (*Channel) ID 

func (c *Channel) ID() uint64

ID is an implementation of Conn

func (*Channel) Index 

func (c *Channel) Index() int

Index is an implementation of Conn

func (*Channel) Name 

func (c *Channel) Name() string

Name is an implementation of Conn

func (*Channel) SetContext 

func (c *Channel) SetContext(v interface{})

SetContext is conn context setter

func (*Channel) String 

func (c *Channel) String() string

func (*Channel) Type 

func (c *Channel) Type() int

Type is an implementation of Conn

type ChannelOption 

type ChannelOption struct {
	//enable
	Enable bool `json:"enable"`
	//the auth token
	Token string `json:"token"`
	//local tcp address to connection master
	Local string `json:"local"`
	//the remote address to login
	Remote string `json:"remote"`
	//the channel index
	Index int `json:"index"`
}

ChannelOption is a pojo struct for adding channel to Router

type Codable 

type Codable interface {
	Code() byte
}

Codable is interface for get current code

type Conn 

type Conn interface {
	//the basic ReadWriteCloser
	frame.ReadWriteCloser
	//the connection id
	ID() uint64
	//the channel name
	Name() string
	//the channel index.
	Index() int
	//the connection type
	Type() int
	//conn context getter
	Context() interface{}
	//conn context setter
	SetContext(v interface{})
}

Conn is the interface that wraps the connection will be running on Router.

ID is the unique of connection

Name is the channel name, it will be used when join current connection to channel

Index is the channel index, it will be used when join current connection to channel.

Type is the connection type by ConnTypeRaw/ConnTypeChannel

type ConnectedWaiter 

type ConnectedWaiter interface {
	Wait() bool
	Ready()
}

ConnectedWaiter interface for connected waiter

type DialRawF 

type DialRawF func(sid uint64, uri string) (raw Conn, err error)

DialRawF is a function type to dial raw connection.

func (DialRawF) DialRaw 

func (d DialRawF) DialRaw(sid uint64, uri string) (raw Conn, err error)

DialRaw will dial raw connection

type Forward 

type Forward struct {
	WebSuffix string
	WebAuth   string
	Dialer    func(uri string, raw io.ReadWriteCloser) (sid uint64, err error)
	// contains filtered or unexported fields
}

func NewForward 

func NewForward() *Forward

func (*Forward) AddForward 

func (f *Forward) AddForward(loc, uri string) (err error)

AddForward by local uri and remote uri

func (*Forward) FindForward 

func (f *Forward) FindForward(name string) (uri ForwardUri)

FindForward will return the forward

func (*Forward) HostForwardF 

func (f *Forward) HostForwardF(w http.ResponseWriter, req *http.Request)

func (*Forward) ProcName 

func (f *Forward) ProcName(name string, w http.ResponseWriter, req *http.Request)

func (*Forward) ProcRouter 

func (f *Forward) ProcRouter(router ForwardUri, w http.ResponseWriter, req *http.Request)

func (*Forward) ProcWebSubsH 

func (f *Forward) ProcWebSubsH(w http.ResponseWriter, req *http.Request)

func (*Forward) RemoveForward 

func (f *Forward) RemoveForward(name string) (err error)

RemoveForward by alias name

type ForwardEntry 

type ForwardEntry []interface{}

ForwardEntry is the forward entry

type ForwardUri 

type ForwardUri []string

func (ForwardUri) String 

func (f ForwardUri) String() string

func (ForwardUri) URL 

func (f ForwardUri) URL() (local *url.URL, remote *url.URL, err error)

type Handler 

type Handler interface {
	//dial raw connection
	DialRaw(sid uint64, uri string) (raw Conn, err error)
	//on connection dial uri
	OnConnDialURI(channel Conn, conn string, parts []string) (err error)
	//on connection login
	OnConnLogin(channel Conn, args string) (name string, index int, err error)
	//on connection close
	OnConnClose(raw Conn) error
}

Handler is the interface that wraps the handler of Router.

type InfoRWC 

type InfoRWC struct {
	frame.ReadWriteCloser
	Info string
}

InfoRWC is external ReadWriteCloser to get info to String

func NewInfoRWC 

func NewInfoRWC(raw frame.ReadWriteCloser, info string) *InfoRWC

NewInfoRWC will return new nfoRWC

func (*InfoRWC) String 

func (i *InfoRWC) String() string

type NormalAcessHandler 

type NormalAcessHandler struct {
	Name        string            //the access name
	LoginAccess map[string]string //the access control

	DialAccess [][]string
	Dialer     RawDialer
	// contains filtered or unexported fields
}

NormalAcessHandler is normal access handler for proxy handler

func NewNormalAcessHandler 

func NewNormalAcessHandler(name string, dialer RawDialer) (handler *NormalAcessHandler)

NewNormalAcessHandler will return new handler

func (*NormalAcessHandler) DialRaw 

func (n *NormalAcessHandler) DialRaw(sid uint64, uri string) (raw Conn, err error)

DialRaw is proxy handler to dail remove

func (*NormalAcessHandler) OnConnClose 

func (n *NormalAcessHandler) OnConnClose(conn Conn) (err error)

OnConnClose is proxy handler when connection is closed

func (*NormalAcessHandler) OnConnDialURI 

func (n *NormalAcessHandler) OnConnDialURI(channel Conn, conn string, parts []string) (err error)

OnConnDialURI is proxy handler to handle dial uri

func (*NormalAcessHandler) OnConnLogin 

func (n *NormalAcessHandler) OnConnLogin(channel Conn, args string) (name string, index int, err error)

OnConnLogin is proxy handler to handle login

type PendingConn 

type PendingConn struct {
	Raw io.ReadWriteCloser
	// contains filtered or unexported fields
}

PendingConn is an implementation of io.ReadWriteCloser

func NewPendingConn 

func NewPendingConn(raw io.ReadWriteCloser) (conn *PendingConn)

NewPendingConn will return new endingConn

func (*PendingConn) Close 

func (p *PendingConn) Close() (err error)

Close pending connection.

func (*PendingConn) Read 

func (p *PendingConn) Read(b []byte) (n int, err error)

func (*PendingConn) Start 

func (p *PendingConn) Start()

Start pending connection

func (*PendingConn) Write 

func (p *PendingConn) Write(b []byte) (n int, err error)

type Proxy 

type Proxy struct {
	*Router                      //the router
	Running        bool          //proxy is running.
	ReconnectDelay time.Duration //reconnect delay
	Cert           string        //the tls cert
	Key            string        //the tls key

	Handler ProxyHandler
	// contains filtered or unexported fields
}

Proxy is an implementation of proxy router

func NewProxy 

func NewProxy(name string, handler Handler) (proxy *Proxy)

NewProxy will return new Proxy by name

func (*Proxy) Close 

func (p *Proxy) Close() (err error)

Close will close the tcp listen

func (*Proxy) DialRaw 

func (p *Proxy) DialRaw(sid uint64, uri string) (raw Conn, err error)

DialRaw will dial raw connection

func (*Proxy) ListenMaster 

func (p *Proxy) ListenMaster(addr string) (err error)

ListenMaster will listen master router on address

func (*Proxy) Login 

func (p *Proxy) Login(option *ChannelOption) (channel *Channel, err error)

Login will add channel by local address, master address, auth token, channel index.

func (*Proxy) LoginChannel 

func (p *Proxy) LoginChannel(reconnect bool, channels ...*ChannelOption) (err error)

LoginChannel will login all channel by options.

func (*Proxy) OnConnClose 

func (p *Proxy) OnConnClose(conn Conn) (err error)

OnConnClose will be called when connection is closed

func (*Proxy) OnConnDialURI 

func (p *Proxy) OnConnDialURI(channel Conn, conn string, parts []string) (err error)

OnConnDialURI is on connection dial uri

func (*Proxy) OnConnLogin 

func (p *Proxy) OnConnLogin(channel Conn, args string) (name string, index int, err error)

OnConnLogin is on connection login

func (*Proxy) StartForward 

func (p *Proxy) StartForward(name string, listen *url.URL, router string) (listener net.Listener, err error)

StartForward will forward address to uri

func (*Proxy) StopForward 

func (p *Proxy) StopForward(name string) (err error)

StopForward will forward address to uri

type ProxyHandler 

type ProxyHandler interface {
	//DialRaw will dial raw connection by uri
	DialRaw(sid uint64, uri string) (raw Conn, err error)
	//OnConnLogin is event on connection login
	OnConnLogin(channel Conn, args string) (name string, index int, err error)
	//OnConnDialURI is event on connection dial to remote
	OnConnDialURI(channel Conn, conn string, parts []string) (err error)
	//OnConnLogin is event on connection close
	OnConnClose(conn Conn) (err error)
}

ProxyHandler is proxy handler

type RawConn 

type RawConn struct {
	//the raw connection
	io.ReadWriteCloser
	// contains filtered or unexported fields
}

RawConn is an implementation of the Conn interface for raw network connections.

func NewRawConn 

func NewRawConn(raw io.ReadWriteCloser, bufferSize int, sid uint64, uri string) (conn *RawConn)

NewRawConn returns a new RawConn by raw connection/session id/uri

func (*RawConn) Close 

func (r *RawConn) Close() (err error)

Close will close the raw connection

func (*RawConn) Context 

func (r *RawConn) Context() interface{}

Context is conn context getter

func (*RawConn) ID 

func (r *RawConn) ID() uint64

ID is an implementation of Conn

func (*RawConn) Index 

func (r *RawConn) Index() int

Index is an implementation of Conn

func (*RawConn) Name 

func (r *RawConn) Name() string

Name is an implementation of Conn

func (*RawConn) Read 

func (r *RawConn) Read(b []byte) (n int, err error)

func (*RawConn) ReadFrame 

func (r *RawConn) ReadFrame() (frame []byte, err error)

ReadFrame will read frame from raw

func (*RawConn) Ready 

func (r *RawConn) Ready()

Ready is ConnectedWaiter impl

func (*RawConn) SetContext 

func (r *RawConn) SetContext(v interface{})

SetContext is conn context setter

func (*RawConn) SetReadTimeout 

func (r *RawConn) SetReadTimeout(timeout time.Duration)

SetReadTimeout is read timeout setter

func (*RawConn) SetTimeout 

func (r *RawConn) SetTimeout(timeout time.Duration)

SetTimeout is read/write timeout setter

func (*RawConn) SetWriteTimeout 

func (r *RawConn) SetWriteTimeout(timeout time.Duration)

SetWriteTimeout is write timeout setter

func (*RawConn) String 

func (r *RawConn) String() string

func (*RawConn) Type 

func (r *RawConn) Type() int

Type is an implementation of Conn

func (*RawConn) Wait 

func (r *RawConn) Wait() bool

Wait is ConnectedWaiter impl

func (*RawConn) Write 

func (r *RawConn) Write(p []byte) (n int, err error)

func (*RawConn) WriteFrame 

func (r *RawConn) WriteFrame(buffer []byte) (n int, err error)

WriteFrame will write frame to raw

type RawDialer 

type RawDialer interface {
	DialRaw(sid uint64, uri string) (raw Conn, err error)
}

RawDialer is dialer to dial raw by uri

type Router 

type Router struct {
	Name       string        //current router name
	BufferSize int           //buffer size of connection runner
	Heartbeat  time.Duration //the delay of heartbeat
	Handler    Handler       //the router handler
	// contains filtered or unexported fields
}

Router is an implementation of the router control

func NewRouter 

func NewRouter(name string) (router *Router)

NewRouter will return new Router by name

func (*Router) Accept 

func (r *Router) Accept(raw frame.ReadWriteCloser)

Accept one raw connecton as channel, it will auth the raw connecton by ACL.

func (*Router) Bind 

func (r *Router) Bind(src Conn, srcSid uint64, dst Conn, dstSid uint64)

Bind one raw connection to channel by session.

func (*Router) Close 

func (r *Router) Close() (err error)

Close all channel

func (*Router) Dial 

func (r *Router) Dial(uri string, raw io.ReadWriteCloser) (sid uint64, err error)

Dial to remote by uri and bind channel to raw connection.

return the session id

func (*Router) DialConn 

func (r *Router) DialConn(uri string, raw io.ReadWriteCloser) (sid uint64, conn *RawConn, err error)

DialConn will dial to remote by uri and bind channel to raw connection and return raw connection

func (*Router) JoinConn 

func (r *Router) JoinConn(conn frame.ReadWriteCloser, index int, args interface{}) (channel *Channel, err error)

JoinConn will add channel by the connected connection

func (*Router) Register 

func (r *Router) Register(channel Conn)

Register one logined raw connecton to channel,

func (*Router) SelectChannel 

func (r *Router) SelectChannel(name string) (dst Conn, err error)

SelectChannel will pick one channel by name.

func (*Router) StartHeartbeat 

func (r *Router) StartHeartbeat()

StartHeartbeat will start the hearbeat on slaver/master

func (*Router) State 

func (r *Router) State() (state xmap.M)

State return the current state of router

func (*Router) SyncDial 

func (r *Router) SyncDial(uri string, raw io.ReadWriteCloser) (sid uint64, err error)

SyncDial will dial to remote by uri and wait dial successs

func (*Router) UniqueSid 

func (r *Router) UniqueSid() (sid uint64)

UniqueSid will return new session id

type SocksProxy 

type SocksProxy struct {
	net.Listener
	Dialer func(utype int, uri string, raw io.ReadWriteCloser) (sid uint64, err error)
}

SocksProxy is an implementation of socks5 proxy

func NewSocksProxy 

func NewSocksProxy() (socks *SocksProxy)

NewSocksProxy will return new SocksProxy

func (*SocksProxy) Start 

func (s *SocksProxy) Start(addr string) (err error)

Start proxy listener

type TableRouter 

type TableRouter []interface{}

TableRouter is the router table item

func (TableRouter) Next 

func (t TableRouter) Next(conn Conn) (target Conn, rsid uint64)

Next will return next connection and session id

func (TableRouter) String 

func (t TableRouter) String() string

type WaitReadWriteCloser 

type WaitReadWriteCloser struct {
	io.ReadWriteCloser
	// contains filtered or unexported fields
}

func NewWaitReadWriteCloser 

func NewWaitReadWriteCloser(raw io.ReadWriteCloser) *WaitReadWriteCloser

func (*WaitReadWriteCloser) Close 

func (w *WaitReadWriteCloser) Close() (err error)

func (*WaitReadWriteCloser) String 

func (w *WaitReadWriteCloser) String() string

func (*WaitReadWriteCloser) Wait 

func (w *WaitReadWriteCloser) Wait()

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.