kubernetes/vendor/github.com/soheilhy/cmux/cmux.go

type Matcher

type MatchWriter

type ErrorHandler

var _

type ErrNotMatched

func (e ErrNotMatched) Error() string {}

// Temporary implements the net.Error interface.
func (e ErrNotMatched) Temporary() bool {}

// Timeout implements the net.Error interface.
func (e ErrNotMatched) Timeout() bool {}

type errListenerClosed

func (e errListenerClosed) Error() string   {}

func (e errListenerClosed) Temporary() bool {}

func (e errListenerClosed) Timeout() bool   {}

var ErrListenerClosed

var ErrServerClosed

var noTimeout

// New instantiates a new connection multiplexer.
func New(l net.Listener) CMux {}

type CMux

type matchersListener

type cMux

func matchersToMatchWriters(matchers []Matcher) []MatchWriter {}

func (m *cMux) Match(matchers ...Matcher) net.Listener {}

func (m *cMux) MatchWithWriters(matchers ...MatchWriter) net.Listener {}

func (m *cMux) SetReadTimeout(t time.Duration) {}

func (m *cMux) Serve() error {}

func (m *cMux) serve(c net.Conn, donec <-chan struct{}

func (m *cMux) Close() {}

func (m *cMux) closeDoneChans() {}

func (m *cMux) HandleError(h ErrorHandler) {}

func (m *cMux) handleErr(err error) bool {}

type muxListener

func (l muxListener) Accept() (net.Conn, error) {}

type MuxConn

func newMuxConn(c net.Conn) *MuxConn {}

// From the io.Reader documentation:
//
// When Read encounters an error or end-of-file condition after
// successfully reading n > 0 bytes, it returns the number of
// bytes read.  It may return the (non-nil) error from the same call
// or return the error (and n == 0) from a subsequent call.
// An instance of this general case is that a Reader returning
// a non-zero number of bytes at the end of the input stream may
// return either err == EOF or err == nil.  The next Read should
// return 0, EOF.
func (m *MuxConn) Read(p []byte) (int, error) {}

func (m *MuxConn) startSniffing() io.Reader {}

func (m *MuxConn) doneSniffing() {}