utils

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

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

type AddrCtx struct {
	net.Addr
	Ctx interface{}
}

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

type AtomicFlag uint32

type CheckCallback func(key, value interface{}) (ok bool)

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

type CipherStream interface {
	io.ReadWriter

	GetIV() []byte
}

type ClientHelloMsg struct {
	Raw                          []byte
	Vers                         uint16
	Random                       []byte
	SessionId                    []byte
	CipherSuites                 []uint16
	CompressionMethods           []uint8
	NextProtoNeg                 bool
	ServerName                   string
	OcspStapling                 bool
	Scts                         bool
	SupportedCurves              []CurveID
	SupportedPoints              []uint8
	TicketSupported              bool
	SessionTicket                []uint8
	SignatureAndHashes           []signatureAndHash
	SecureRenegotiation          []byte
	SecureRenegotiationSupported bool
	AlpnProtocols                []string
}

type Conn interface {
	net.Conn
	WriteBuffers([][]byte) (int, error)
}

type CopyConn struct {
	net.Conn
}

type CurveID uint16

type DeleteCallback func(key, value interface{})

type Die struct {
	RWLock
	// contains filtered or unexported fields
}

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

type DupConn struct {
	net.Conn
	// contains filtered or unexported fields
}

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

type Expires struct {
	E time.Time
	L RWLock
}

type Extension struct {
	Type   uint16
	Length uint16
	Data   []byte
}

type FecConn struct {
	net.Conn
	// contains filtered or unexported fields
}

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

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

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

type Lock struct {
	sync.Mutex
}

type Locker interface {
	RunInLock(f func())
}

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

type RWLock struct {
	sync.RWMutex
}

type RWLocker interface {
	Locker
	RunInRLock(f func())
}

type RandomDropConn struct {
	net.Conn
	// contains filtered or unexported fields
}

type RateLogConn struct {
	net.Conn
	// contains filtered or unexported fields
}

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

type ServerHelloMsg struct {
	Raw                          []byte
	Vers                         uint16
	Random                       []byte
	SessionId                    []byte
	CipherSuite                  uint16
	CompressionMethod            uint8
	NextProtoNeg                 bool
	NextProtos                   []string
	OcspStapling                 bool
	Scts                         [][]byte
	TicketSupported              bool
	SecureRenegotiation          []byte
	SecureRenegotiationSupported bool
	AlpnProtocol                 string
	OtherExtensions              []Extension
}

type SliceConn struct {
	net.Conn
	// contains filtered or unexported fields
}

type SubConn struct {
	net.PacketConn
	// contains filtered or unexported fields
}

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

type UDPConn interface {
	// Read reads data from the connection.
	// Read can be made to time out and return an Error with Timeout() == true
	// after a fixed time limit; see SetDeadline and SetReadDeadline.
	Read(b []byte) (n int, err error)

	// Write writes data to the connection.
	// Write can be made to time out and return an Error with Timeout() == true
	// after a fixed time limit; see SetDeadline and SetWriteDeadline.
	Write(b []byte) (n int, err error)

	// Close closes the connection.
	// Any blocked Read or Write operations will be unblocked and return errors.
	Close() error

	// LocalAddr returns the local network address.
	LocalAddr() net.Addr

	// RemoteAddr returns the remote network address.
	RemoteAddr() net.Addr

	// SetDeadline sets the read and write deadlines associated
	// with the connection. It is equivalent to calling both
	// SetReadDeadline and SetWriteDeadline.
	//
	// A deadline is an absolute time after which I/O operations
	// fail with a timeout (see type Error) instead of
	// blocking. The deadline applies to all future and pending
	// I/O, not just the immediately following call to Read or
	// Write. After a deadline has been exceeded, the connection
	// can be refreshed by setting a deadline in the future.
	//
	// An idle timeout can be implemented by repeatedly extending
	// the deadline after successful Read or Write calls.
	//
	// A zero value for t means I/O operations will not time out.
	SetDeadline(t time.Time) error

	// SetReadDeadline sets the deadline for future Read calls
	// and any currently-blocked Read call.
	// A zero value for t means Read will not time out.
	SetReadDeadline(t time.Time) error

	// SetWriteDeadline sets the deadline for future Write calls
	// and any currently-blocked Write call.
	// Even if write times out, it may return n > 0, indicating that
	// some of the data was successfully written.
	// A zero value for t means Write will not time out.
	SetWriteDeadline(t time.Time) error

	// ReadFrom reads a packet from the connection,
	// copying the payload into b. It returns the number of
	// bytes copied into b and the return address that
	// was on the packet.
	// ReadFrom can be made to time out and return
	// an Error with Timeout() == true after a fixed time limit;
	// see SetDeadline and SetReadDeadline.
	ReadFrom(b []byte) (n int, addr net.Addr, err error)

	// WriteTo writes a packet with payload b to addr.
	// WriteTo can be made to time out and return
	// an Error with Timeout() == true after a fixed time limit;
	// see SetDeadline and SetWriteDeadline.
	// On packet-oriented connections, write timeouts are rare.
	WriteTo(b []byte, addr net.Addr) (n int, err error)
}

type UDPServerCtx struct {
	Mtu     int
	Expires int
	// contains filtered or unexported fields
}

type UtilsConn struct {
	net.Conn
}

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