gopher

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

type Caps interface {
	Version() int
	ExpiresAfter() time.Duration // Return -1 if the Caps don't expire

	Supports(feature Feature) FeatureStatus
	PathConfig() (*PathConfig, error)
	ServerInfo() (*ServerInfo, error)
	Software() (name, version string)

	// TLSPort for the server; returns 0 if not present or configured.
	TLSPort() int

	// Default text encoding for content types 0 and 1.
	// If this returns an empty string, UTF-8 is presumed.
	DefaultEncoding() string
}

type CapsSource interface {
	LoadCaps(ctx context.Context, host, port string) (Caps, error)
}

type CapsUpdater interface {
	UpdateFeature(ctx context.Context, host, port string, feature Feature)
}

type Client struct {
	Timeout               time.Duration
	ExtraBinaryTypes      [256]bool
	DisableErrorIntercept bool // Warning: subject to change.

	Recorder        Recorder
	CapsSource      CapsSource
	TLSClientConfig *tls.Config
	TLSMode         TLSMode

	DialContext func(ctx context.Context, network, addr string) (net.Conn, error)
}

type DirReader struct {
	Flag DirentFlag
	// contains filtered or unexported fields
}

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

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

type Dirent struct {
	ItemType ItemType `json:"type"`
	Display  string   `json:"display"`
	Selector string   `json:"selector"`
	Hostname string   `json:"host,omitempty"`
	Port     string   `json:"port,omitempty"`
	Plus     bool     `json:"plus,omitempty"`

	Raw string `json:"-"`
}

type DirentFlag int

type ErrFactory func(status Status, msg string, confidence float64) *Error

type Error struct {
	Status     Status
	URL        URL
	Message    string
	Confidence float64
	Raw        []byte
}

type Feature int

type FeatureStatus int

type Handler interface {
	ServeGopher(ctx context.Context, w ResponseWriter, r *Request)
}

type HandlerFunc func(context.Context, ResponseWriter, *Request)

type ItemType byte

type Logger interface {
	Printf(format string, v ...interface{})
}

type MetaEntry struct {
	Record string
	Value  string
}

type MetaHandler interface {
	ServeGopherMeta(ctx context.Context, w MetaWriter, r *Request)
}

type MetaHandlerFunc func(context.Context, MetaWriter, *Request)

type MetaType byte

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

type MetaWriter interface {
	// The `INFO` record is MANDATORY in every metadata listing.  It
	// contains the same data as the Gopher selector, with a plus sign at
	// the end, per GopherIIbis style. It MUST always be present, and it
	// MUST always be the first metadata record present. The `INFO` record
	// serves to separate metadata listings when more are sent at the same
	// time.
	//
	// If the Request is for a single file's metadata only ('!' rather than
	// '&'), multiple calls to Info() will result in an error.
	Info(i ItemType, disp, sel string)

	// If the Request is invalid, MetaError() should be called once and only
	// once. No other calls to write Info or Records are valid if MetaError()
	// has been called.
	MetaError(code Status, msg string)

	// Write an entire record with a string value:
	WriteRecord(record string, value string) (ok bool)

	// Begin a record and return a writer that can be used to write its value.
	// If the returned writer is nil, the record is ignored by the request.
	// Duplicate records may be written.
	BeginRecord(record string) *MetaValueWriter

	// Flush any buffered metadata and return any cached error. It is not
	// necessary to call Flush() directly; Server will call it regardless
	// at the end of the request.
	Flush() error
}

type Mux struct {
	CatchAllRequiresTrailingSlash bool
	// contains filtered or unexported fields
}

type Param struct {
	Key, Value string
}

type Params []Param

type PathConfig struct {
	// Refers to how the server separates folders from each other; Unix machines use `/`,
	// Microsoft machines use `\`, and obsolete Macs use `:`
	Delimiter string

	// Refers to the shorthand used by an operating system to mean "this directory"; UNIX
	// machines use `.`.
	Identity string

	// Refers to the shorthand for "the directory immediately above", and is `..` on UNIX
	// and Microsoft systems.
	Parent string

	// Refers to an oddball feature of obsolete Macs: two consecutive path delimiters are
	// used to refer to the parent directory. For all systems other than pre-OS X
	// Macintoshes, this should be false.
	ParentDouble bool

	// Tells the client the escape character for quoting delimiters when they appear in
	// selectors; most of the time, this is `\\`.
	EscapeCharacter byte

	// Tells the client not to cut everything up to the first path delimiter; most of the
	// time, this should be `FALSE`.
	KeepPreDelimiter bool
}

type Recorder interface {
	BeginRecording(rq *Request, at time.Time) Recording
}

type Recording interface {
	RequestWriter() io.Writer
	ResponseWriter() io.Writer
	SetStatus(status Status, msg string)
	Done(at time.Time)
}

type Request struct {

	// Server only. When a server accepts an actual connection, this will be set to the
	// remote address.  This field is ignored by the Gopher client.
	RemoteAddr *net.TCPAddr

	// Server only. Params is free to be set by your Server's Mux implementation. If you
	// have requirements that this can't satisfy, use the dreaded context.WithValue() to
	// add what you need.
	Params Params

	// Server only. SelectorPrefix is added to all generated selectors which are internal
	// to this server. Comes from the Server struct. Useful for things like configurable
	// sites deployable at different selector bases.
	SelectorPrefix string
	// contains filtered or unexported fields
}

type Response interface {
	Reader() io.ReadCloser
	Info() *ResponseInfo
	Class() ResponseClass
	Close() error
}

type ResponseClass int

type ResponseInfo struct {
	Request *Request

	// TLS contains information about the TLS connection on which the
	// response was received. It is nil for unencrypted responses.
	// The pointer is shared between responses and should not be
	// modified.
	TLS *tls.ConnectionState
}

type ResponseWriter interface {
	Write([]byte) (int, error)
}

type Server struct {
	Handler     Handler
	MetaHandler MetaHandler
	ErrorLog    Logger
	Info        *ServerInfo

	// If false, the server will not intercept request for caps.txt
	DisableCaps bool

	// Maximum number of bytes
	RequestSizeLimit int

	ReadTimeout         time.Duration
	ReadSelectorTimeout time.Duration
	TLSConfig           *tls.Config

	// This will be set in the Request so that writers like DirWriter can build prefixed
	// selectors with zero extra config.
	SelectorPrefix string
	// contains filtered or unexported fields
}

type ServerInfo struct {
	Software     string
	Version      string
	Architecture string
	Description  string
	Geolocation  string
	AdminEmail   string
}

type Status int

type TLSMode int

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

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

type URL struct {
	Scheme   string
	Hostname string
	Port     string
	Root     bool

	// For server requests, this will always be Text ('0') as there is no
	// way to tell the ItemType from what the client sends:
	ItemType ItemType

	Selector string
	Search   string
}

type URLVar URL

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