clientcore

type BroflakeConn ¶

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

func (c BroflakeConn) Close() error

func (c BroflakeConn) LocalAddr() net.Addr

func (c BroflakeConn) ReadFrom(p []byte) (n int, addr net.Addr, err error)

func (c BroflakeConn) SetDeadline(t time.Time) error

func (c BroflakeConn) SetReadDeadline(t time.Time) error

func (c BroflakeConn) SetWriteDeadline(t time.Time) error

func (c BroflakeConn) WriteTo(p []byte, addr net.Addr) (n int, err error)

type BroflakeEngine ¶

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

func NewBroflakeEngine(cTable, pTable *WorkerTable, ui UI, wg *sync.WaitGroup, netstated, tag string) *BroflakeEngine

type BroflakeOptions ¶

type BroflakeOptions struct {
	ClientType  string
	CTableSize  int
	PTableSize  int
	BusBufferSz int
	Netstated   string
}

func NewDefaultBroflakeOptions() *BroflakeOptions

type EgressOptions ¶

type EgressOptions struct {
	Addr           string
	Endpoint       string
	ConnectTimeout time.Duration
	ErrorBackoff   time.Duration
}

func NewDefaultEgressOptions() *EgressOptions

type FSMstate ¶

type FSMstate func(ctx context.Context, com *ipcChan, input []interface{}) (int, []interface{})

FSMstate encapsulates logic for one state in a WorkerFSM. An FSMstate must return an int corresponding to the next state and a list of any inputs to propagate to the next state. TODO: a state's number simply corresponds to its index in WorkerFSM.state, but we perform no sanity checking of state indices.

type IPCMsg ¶

type IPCMsg struct {
	IpcType msgType
	Data    interface{}
	Wid     workerID
}

type QUICLayer ¶

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

func NewQUICLayer(bfconn *BroflakeConn, tlsConfig *tls.Config) (*QUICLayer, error)

func (c *QUICLayer) Close()

func (c *QUICLayer) DialContext(ctx context.Context) (net.Conn, error)

func (c *QUICLayer) ListenAndMaintainQUICConnection()

type ReliableStreamLayer ¶

type ReliableStreamLayer interface {
	DialContext(ctx context.Context) (net.Conn, error)
}

type SOCKS5Dialer ¶

type SOCKS5Dialer func(ctx context.Context, network, addr string) (net.Conn, error)

func CreateSOCKS5Dialer(c ReliableStreamLayer) SOCKS5Dialer

type STUNCache ¶

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

STUNCache implements the operations which support our strategy for evading STUN server blocking in-country. That is: populate the cache with the largest set of currently known STUN servers and shuffle it; select a cohort of the first N servers in the list to use in parallel; if any of those servers work, continue using that cohort; if all of those servers fail, delete the cohort from the list; when the list is empty, repeat the steps.

type TableRouter ¶

type TableRouter interface {
	Init()
	// contains filtered or unexported methods
}

A tableRouter is a multiplexer/demultiplexer which functions as the interface to a WorkerTable, abstracting the complexity of connecting a WorkerTable of arbitrary size to the message bus. An upstream tableRouter, in managing a WorkerTable consisting of workers which handle egress traffic, decides how to best utilize those connections (ie, in serial, in parallel, 1:1, multipath, etc.)

type UI ¶

type UI interface {
	Init(bf *BroflakeEngine)

	Start()

	Stop()

	Debug()

	OnReady()

	OnStartup()

	OnDownstreamChunk(size int, workerIdx int)

	OnDownstreamThroughput(bytesPerSec int)

	OnConsumerConnectionChange(state int, workerIdx int, addr net.IP)
}

type UIImpl ¶

type UIImpl struct {
	UI
	BroflakeEngine *BroflakeEngine
}

func (ui UIImpl) Debug()

func (ui *UIImpl) Init(bf *BroflakeEngine)

func (ui UIImpl) OnConsumerConnectionChange(state int, workerIdx int, addr net.IP)

func (ui UIImpl) OnDownstreamChunk(size int, workerIdx int)

func (ui UIImpl) OnDownstreamThroughput(bytesPerSec int)

func (ui UIImpl) OnReady()

func (ui UIImpl) OnStartup()

func (ui UIImpl) Start()

func (ui UIImpl) Stop()

type WebRTCOptions ¶

type WebRTCOptions struct {
	DiscoverySrv      string
	Endpoint          string
	GenesisAddr       string
	NATFailTimeout    time.Duration
	STUNBatch         func(size uint32) (batch []string, err error)
	STUNBatchSize     uint32
	Tag               string
	HTTPClient        *http.Client
	Patience          time.Duration
	ErrorBackoff      time.Duration
	ConsumerSessionID string
}

func NewDefaultWebRTCOptions() *WebRTCOptions

type WorkerFSM ¶

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

WorkerFSM implements a Mealy machine: https://en.wikipedia.org/wiki/Mealy_machine A WorkerFSM independently manages the lifetime of a single connection slot. A client maintains two pools of WorkerFSMs - one for upstream channels and one for downstream channels.

func NewConsumerWebRTC(options *WebRTCOptions, wg *sync.WaitGroup) *WorkerFSM

func NewEgressConsumerWebSocket(options *EgressOptions, wg *sync.WaitGroup) *WorkerFSM

func NewJITEgressConsumer(options *EgressOptions, wg *sync.WaitGroup) *WorkerFSM

func NewProducerWebRTC(options *WebRTCOptions, wg *sync.WaitGroup) *WorkerFSM

func NewWorkerFSM(wg *sync.WaitGroup, states []FSMstate) *WorkerFSM

func (fsm *WorkerFSM) Start()

func (fsm *WorkerFSM) Stop()

type WorkerTable ¶

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

WorkerTable ts the structure we use to represent the producer and consumer tables

func NewWorkerTable(list []WorkerFSM) *WorkerTable

func (t WorkerTable) Size() int

func (t WorkerTable) Start()

func (t WorkerTable) Stop()