dialer

type ByteCounterDialer ¶

type ByteCounterDialer struct {
	Dialer
}

ByteCounterDialer is a byte-counting-aware dialer. To perform byte counting, you should make sure that you insert this dialer in the dialing chain.

Bug ¶

This implementation cannot properly account for the bytes that are sent by persistent connections, because they strick to the counters set when the connection was established. This typically means we miss the bytes sent and received when submitting a measurement. Such bytes are specifically not see by the experiment specific byte counter.

For this reason, this implementation may be heavily changed/removed.

func (d ByteCounterDialer) DialContext(
	ctx context.Context, network, address string) (net.Conn, error)

type DNSDialer ¶

type DNSDialer struct {
	Dialer
	Resolver Resolver
}

DNSDialer is a dialer that uses the configured Resolver to resolver a domain name to IP addresses, and the configured Dialer to connect.

func (d DNSDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

func (d DNSDialer) LookupHost(ctx context.Context, hostname string) ([]string, error)

type Dialer ¶

type Dialer interface {
	DialContext(ctx context.Context, network, address string) (net.Conn, error)
}

Dialer is the interface we expect from a dialer

type EmitterConn ¶

type EmitterConn struct {
	net.Conn
	Beginning time.Time
	Handler   modelx.Handler
	ID        int64
}

EmitterConn is a net.Conn used to emit events

func (c EmitterConn) Close() (err error)

func (c EmitterConn) Read(b []byte) (n int, err error)

func (c EmitterConn) Write(b []byte) (n int, err error)

type EmitterDialer ¶

type EmitterDialer struct {
	Dialer
}

EmitterDialer is a Dialer that emits events

func (d EmitterDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

type EmitterTLSHandshaker ¶

type EmitterTLSHandshaker struct {
	TLSHandshaker
}

EmitterTLSHandshaker emits events using the MeasurementRoot

func (h EmitterTLSHandshaker) Handshake(
	ctx context.Context, conn net.Conn, config *tls.Config,
) (net.Conn, tls.ConnectionState, error)

type ErrorWrapperConn ¶

type ErrorWrapperConn struct {
	net.Conn
	ConnID int64
	DialID int64
}

ErrorWrapperConn is a net.Conn that performs error wrapping.

func (c ErrorWrapperConn) Close() (err error)

func (c ErrorWrapperConn) Read(b []byte) (n int, err error)

func (c ErrorWrapperConn) Write(b []byte) (n int, err error)

type ErrorWrapperDialer ¶

type ErrorWrapperDialer struct {
	Dialer
}

ErrorWrapperDialer is a dialer that performs err wrapping

func (d ErrorWrapperDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

type ErrorWrapperTLSHandshaker ¶

type ErrorWrapperTLSHandshaker struct {
	TLSHandshaker
}

ErrorWrapperTLSHandshaker wraps the returned error to be an OONI error

func (h ErrorWrapperTLSHandshaker) Handshake(
	ctx context.Context, conn net.Conn, config *tls.Config,
) (net.Conn, tls.ConnectionState, error)

type Logger ¶

type Logger interface {
	Debugf(format string, v ...interface{})
	Debug(message string)
}

Logger is the logger assumed by this package

type LoggingDialer ¶

type LoggingDialer struct {
	Dialer
	Logger Logger
}

LoggingDialer is a Dialer with logging

func (d LoggingDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

type LoggingTLSHandshaker ¶

type LoggingTLSHandshaker struct {
	TLSHandshaker
	Logger Logger
}

LoggingTLSHandshaker is a TLSHandshaker with logging

func (h LoggingTLSHandshaker) Handshake(
	ctx context.Context, conn net.Conn, config *tls.Config,
) (net.Conn, tls.ConnectionState, error)

type ProxyDialer ¶

type ProxyDialer struct {
	Dialer
	ProxyURL *url.URL
}

ProxyDialer is a dialer that uses a proxy. If the ProxyURL is not configured, this dialer is a passthrough for the next Dialer in chain. Otherwise, it will internally create a SOCKS5 dialer that will connect to the proxy using the underlying Dialer.

As a special case, you can force a proxy to be used only extemporarily. To this end, you can use the WithProxyURL function, to store the proxy URL in the context. This will take precedence over any otherwise configured proxy. The use case for this functionality is when you need a tunnel to contact OONI probe services.

func (d ProxyDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

type Resolver ¶

type Resolver interface {
	LookupHost(ctx context.Context, hostname string) (addrs []string, err error)
}

Resolver is the interface we expect from a resolver

type SaverConnDialer ¶

type SaverConnDialer struct {
	Dialer
	Saver *trace.Saver
}

SaverConnDialer wraps the returned connection such that we collect all the read/write events that occur.

func (d SaverConnDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

type SaverDialer ¶

type SaverDialer struct {
	Dialer
	Saver *trace.Saver
}

SaverDialer saves events occurring during the dial

func (d SaverDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

type SaverTLSHandshaker ¶

type SaverTLSHandshaker struct {
	TLSHandshaker
	Saver *trace.Saver
}

SaverTLSHandshaker saves events occurring during the handshake

func (h SaverTLSHandshaker) Handshake(
	ctx context.Context, conn net.Conn, config *tls.Config,
) (net.Conn, tls.ConnectionState, error)

type ShapingDialer ¶

type ShapingDialer struct {
	Dialer
}

ShapingDialer ensures we don't use too much bandwidth when using integration tests at GitHub. To select the implementation with shaping use `-tags shaping`.

func (d ShapingDialer) DialContext(
	ctx context.Context, network, address string) (net.Conn, error)

type SystemTLSHandshaker ¶

type SystemTLSHandshaker struct{}

SystemTLSHandshaker is the system TLS handshaker.

func (h SystemTLSHandshaker) Handshake(
	ctx context.Context, conn net.Conn, config *tls.Config,
) (net.Conn, tls.ConnectionState, error)

type TLSDialer ¶

type TLSDialer struct {
	Config        *tls.Config
	Dialer        Dialer
	TLSHandshaker TLSHandshaker
}

TLSDialer is the TLS dialer

func (d TLSDialer) DialTLSContext(ctx context.Context, network, address string) (net.Conn, error)

type TLSHandshaker ¶

type TLSHandshaker interface {
	Handshake(ctx context.Context, conn net.Conn, config *tls.Config) (
		net.Conn, tls.ConnectionState, error)
}

TLSHandshaker is the generic TLS handshaker

type TimeoutDialer ¶

type TimeoutDialer struct {
	Dialer
	ConnectTimeout time.Duration // default: 30 seconds
}

TimeoutDialer is a Dialer that enforces a timeout

func (d TimeoutDialer) DialContext(ctx context.Context, network, address string) (net.Conn, error)

type TimeoutTLSHandshaker ¶

type TimeoutTLSHandshaker struct {
	TLSHandshaker
	HandshakeTimeout time.Duration // default: 10 second
}

TimeoutTLSHandshaker is a TLSHandshaker with timeout

func (h TimeoutTLSHandshaker) Handshake(
	ctx context.Context, conn net.Conn, config *tls.Config,
) (net.Conn, tls.ConnectionState, error)