revdial

Documentation

Overview

Package revdial implements a Dialer and Listener which work together to turn an accepted connection (for instance, a Hijacked HTTP request) into a Dialer which can then create net.Conns connecting back to the original dialer, which then gets a net.Listener accepting those conns.

This is basically a very minimal SOCKS5 client & server.

The motivation is that sometimes you want to run a server on a machine deep inside a NAT. Rather than connecting to the machine directly (which you can't, because of the NAT), you have the sequestered machine connect out to a public machine. Both sides then use revdial and the public machine can become a client for the NATed machine.

Index

• Variables
• func ConnHandler(upgrader websocket.Upgrader) http.Handler
• type Dialer
  • func NewDialer(c net.Conn, connPath string) *Dialer
  • func (d *Dialer) Close() error
  • func (d *Dialer) Dial(ctx context.Context) (net.Conn, error)
  • func (d *Dialer) Done() <-chan struct{}
• type Listener
  • func NewListener(serverConn net.Conn, ...) *Listener
  • func (ln *Listener) Accept() (net.Conn, error)
  • func (ln *Listener) Addr() net.Addr
  • func (ln *Listener) Close() error
  • func (ln *Listener) Closed() bool

Variables

var ErrDialerClosed = errors.New("revdial.Dialer closed")

var ErrListenerClosed = errors.New("revdial: Listener closed")

ErrListenerClosed is returned by Accept after Close has been called.

Functions

func ConnHandler

func ConnHandler(upgrader websocket.Upgrader) http.Handler

ConnHandler returns the HTTP handler that needs to be mounted somewhere that the Listeners can dial out and get to. A dialer to connect to it is given to NewListener and the path to reach it is given to NewDialer to use in messages to the listener.

Types

type Dialer

type Dialer struct {
	// contains filtered or unexported fields
}

The Dialer can create new connections.

func NewDialer

func NewDialer(c net.Conn, connPath string) *Dialer

NewDialer returns the side of the connection which will initiate new connections. This will typically be the side which did the HTTP Hijack. The connection is (typically) the hijacked HTTP client connection. The connPath is the HTTP path and optional query (but without scheme or host) on the dialer where the ConnHandler is mounted.

func (*Dialer) Close

func (d *Dialer) Close() error

Close closes the Dialer.

func (*Dialer) Dial

func (d *Dialer) Dial(ctx context.Context) (net.Conn, error)

Dial creates a new connection back to the Listener.

func (*Dialer) Done

func (d *Dialer) Done() <-chan struct{}

Done returns a channel which is closed when d is closed (either by this process on purpose, by a local error, or close or error from the peer).

type Listener

type Listener struct {
	// contains filtered or unexported fields
}

Listener is a net.Listener, returning new connections which arrive from a corresponding Dialer.

func NewListener

func NewListener(serverConn net.Conn, dialServer func(context.Context, string) (*websocket.Conn, *http.Response, error)) *Listener

NewListener returns a new Listener, accepting connections which arrive from the provided server connection, which should be after any necessary authentication (usually after an HTTP exchange).

The provided dialServer func is responsible for connecting back to the server and doing TLS setup.

func (*Listener) Accept

func (ln *Listener) Accept() (net.Conn, error)

Accept blocks and returns a new connection, or an error.

func (*Listener) Addr

func (ln *Listener) Addr() net.Addr

Addr returns a dummy address. This exists only to conform to the net.Listener interface.

func (*Listener) Close

func (ln *Listener) Close() error

Close closes the Listener, making future Accept calls return an error.

func (*Listener) Closed

func (ln *Listener) Closed() bool

Closed reports whether the listener has been closed.