torrent

type Binder interface {
	// Bind to the given client if err is nil.
	Bind(cl *Client, err error) (*Client, error)
	Close() error
}

type BinderOption func(v *binder)

type BitmapStore interface {
	Delete(id int160.T) error
	Read(id int160.T) (*roaring.Bitmap, error)
	Write(id int160.T, bm *roaring.Bitmap) error
}

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

type ClientConfig struct {
	UpnpID string

	// Upload even after there's nothing in it for us.
	Seed bool `long:"seed"`

	// Only applies to chunks uploaded to peers, to maintain responsiveness
	// communicating local Client state to peers. Each limiter token
	// represents one byte. The Limiter's burst must be large enough to fit a
	// whole chunk, which is usually 16 KiB (see TorrentSpec.ChunkSize).
	UploadRateLimiter *rate.Limiter
	// Rate limits all reads from connections to peers. Each limiter token
	// represents one byte. The Limiter's burst must be bigger than the
	// largest Read performed on a the underlying rate-limiting io.Reader
	// minus one. This is likely to be the larger of the main read loop buffer
	// (~4096), and the requested chunk size (~16KiB, see
	// TorrentSpec.ChunkSize).
	DownloadRateLimiter *rate.Limiter

	HeaderObfuscationPolicy HeaderObfuscationPolicy

	// The crypto methods to offer when initiating connections with header obfuscation.
	CryptoProvides mse.CryptoMethod
	// Chooses the crypto method to use when receiving connections with header obfuscation.
	CryptoSelector mse.CryptoSelector

	Error  logging // standard logging for errors, defaults to stderr
	Warn   logging // warn logging
	Logger logging // informational logging
	Debug  logging // debug logging, defaults to discard

	// HTTPProxy defines proxy for HTTP requests.
	// Format: func(*Request) (*url.URL, error),
	// or result of http.ProxyURL(HTTPProxy).
	// By default, it is composed from ClientConfig.ProxyURL,
	// if not set explicitly in ClientConfig struct
	HTTPProxy func(*http.Request) (*url.URL, error)
	// HTTPUserAgent changes default UserAgent for HTTP requests
	HTTPUserAgent string

	// Peer dial timeout to use when there are limited peers.
	NominalDialTimeout time.Duration
	// Minimum peer dial timeout to use (even if we have lots of peers).
	MinDialTimeout time.Duration

	// Maximum number of peer addresses in reserve.
	TorrentPeersHighWater int
	// Minumum number of peers before effort is made to obtain more peers.
	TorrentPeersLowWater int

	ConnTracker *conntrack.Instance

	Handshaker connections.Handshaker

	ConnectionClosed func(ih int160.T, stats ConnStats, remaining int)
	// contains filtered or unexported fields
}

type ClientConfigOption func(*ClientConfig)

type ClientOperation func(*Client) error

type ConnStats struct {
	// Total bytes on the wire. Includes handshakes and encryption.
	BytesWritten     count
	BytesWrittenData count

	BytesRead           count
	BytesReadData       count
	BytesReadUsefulData count

	ChunksWritten count

	ChunksRead       count
	ChunksReadUseful count
	ChunksReadWasted count

	MetadataChunksRead count

	// Number of pieces data was written to, that subsequently passed verification.
	PiecesDirtiedGood count
	// Number of pieces data was written to, that subsequently failed
	// verification. Note that a connection may not have been the sole dirtier
	// of a piece.
	PiecesDirtiedBad count

	DHTAnnounce count
}

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

type Handle interface {
	io.Reader
	io.Seeker
	io.Closer
	io.ReaderAt
}

type HeaderObfuscationPolicy struct {
	Required  bool // Whether the value of Preferred is a strict requirement.
	Preferred bool // Whether header obfuscation is preferred.
}

type Metadata struct {
	// The tiered tracker URIs.
	Trackers  []string
	ID        int160.T
	InfoBytes []byte
	// The name to use if the Name field from the Info isn't available.
	DisplayName string
	Webseeds    []string
	DHTNodes    []string
	// The chunk size to use for outbound requests. Defaults to 16KiB if not
	// set.
	ChunkSize uint64
	Storage   storage.ClientImpl
}

type MetadataStore interface {
	Read(id int160.T) (Metadata, error)
	Write(md Metadata) error
	Each() iter.Seq[int160.T]
}

type Option func(*Metadata)

type Peer struct {
	ID int160.T
	netip.AddrPort
	btprotocol.PexPeerFlags
	LastAttempt        time.Time
	Attempts           uint64
	Source             peerSource
	SupportsEncryption bool // Peer is known to support encryption.
	Trusted            bool // Whether we can ignore poor or bad behaviour from the peer.
}

type PeerOption func(*Peer)

type Peers []Peer

type Reader interface {
	io.Reader
	io.Seeker
	io.Closer
}

type Stats struct {
	// Aggregates stats over all connections past and present. Some values may
	// not have much meaning in the aggregate context.
	ConnStats

	// metrics marking the progress of the torrent
	// these are in chunks.
	Missing     int
	Outstanding int
	Unverified  int
	Failed      int
	Completed   int

	// Ordered by expected descending quantities (if all is well).
	MaximumAllowedPeers int
	TotalPeers          int
	PendingPeers        int
	ActivePeers         int
	HalfOpenPeers       int
	Seeders             int

	Seeding        bool
	LastConnection time.Time
}

type Torrent interface {
	Metadata() Metadata
	Tune(...Tuner) error
	Stats() Stats
	BytesCompleted() int64        // TODO: maybe should be pulled from torrent, it has a reference to the storage implementation. or maybe part of the Stats call?
	Info() *metainfo.Info         // TODO: remove, this should be pulled from Metadata()
	GotInfo() <-chan struct{}     // TODO: remove, torrents should never be returned if they don't have the meta info.
	Storage() storage.TorrentImpl // temporary replacement for reader.
}

type Tuner func(*torrent) error