torrent

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

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

type Announce struct {
	Peer     string
	Infohash string
}

type Announcer struct {
	Announces chan *Announce
	// contains filtered or unexported fields
}

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

type BtConn struct {
	RemoteAddr net.Addr

	Infohash string
	// contains filtered or unexported fields
}

type ByDownloadBPS []Choker

type CacheProvider interface {
	NewCache(infohash string, numPieces int, pieceLength int64, totalSize int64, undelying FileStore) FileStore
}

type ChokePolicy interface {
	// Only pass in interested peers.
	// mutate the chokers into a list where the first N are to be unchoked.
	Choke(chokers []Choker) (unchokeCount int, err error)
}

type Choker interface {
	DownloadBPS() float32 // bps
	UploadBPS() float32   // bps
}

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

type ClientStatusReport struct {
	Event      string
	InfoHash   string
	PeerID     string
	Port       uint16
	Uploaded   uint64
	Downloaded uint64
	Left       uint64
}

type DeficitBPS []Choker

type Device struct {
	XMLName     xml.Name    `xml:"device"`
	DeviceType  string      `xml:"deviceType"`
	DeviceList  DeviceList  `xml:"deviceList"`
	ServiceList ServiceList `xml:"serviceList"`
}

type DeviceList struct {
	Device []Device `xml:"device"`
}

type Envelope struct {
	XMLName xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Envelope"`
	Soap    *SoapBody
}

type ExtensionHandshake struct {
	M      map[string]int `bencode:"m"`
	P      uint16         `bencode:"p"`
	V      string         `bencode:"v"`
	Yourip string         `bencode:"yourip"`
	Ipv6   string         `bencode:"ipv6"`
	Ipv4   string         `bencode:"ipv4"`
	Reqq   uint16         `bencode:"reqq"`

	MetadataSize uint `bencode:"metadata_size"`
}

type ExternalIPAddress struct {
	XMLName xml.Name `xml:"NewExternalIPAddress"`
	IP      string
}

type ExternalIPAddressResponse struct {
	XMLName   xml.Name `xml:"GetExternalIPAddressResponse"`
	IPAddress string   `xml:"NewExternalIPAddress"`
}

type FairChokePolicy struct{}

type File interface {
	io.ReaderAt
	io.WriterAt
	io.Closer
}

type FileDict struct {
	Length int64
	Path   []string
	Md5sum string
}

type FileStore interface {
	io.ReaderAt
	io.Closer
	WritePiece(buffer []byte, piece int) (written int, err error)
}

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

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

type FileSystem interface {
	Open(name []string, length int64) (file File, err error)
	io.Closer
}

type FsProvider interface {
	NewFS(directory string) (FileSystem, error)
}

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

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

type InfoDict struct {
	PieceLength int64 `bencode:"piece length"`
	Pieces      string
	Private     int64
	Name        string
	// Single File Mode
	Length int64
	Md5sum string
	// Multiple File mode
	Files []FileDict
}

type Magnet struct {
	InfoHashes []string
	Names      []string
	Trackers   [][]string
}

type MetaDataExchange struct {
	Transferring bool
	Pieces       [][]byte
}

type MetaInfo struct {
	Info         InfoDict
	InfoHash     string
	Announce     string
	AnnounceList [][]string `bencode:"announce-list"`
	CreationDate string     `bencode:"creation date"`
	Comment      string
	CreatedBy    string `bencode:"created by"`
	Encoding     string
}

type MetaInfoFile interface {
	io.Closer
	io.Reader
	io.ReaderAt
	Readdirnames(n int) (names []string, err error)
	Stat() (os.FileInfo, error)
}

type MetaInfoFileSystem interface {
	Open(name string) (MetaInfoFile, error)
	Stat(name string) (os.FileInfo, error)
}

type MetadataMessage struct {
	MsgType   uint8 `bencode:"msg_type"`
	Piece     uint  `bencode:"piece"`
	TotalSize uint  `bencode:"total_size"`
}

type Msg struct {
	Content, RealTimestamp string
}

type NAT interface {
	GetExternalAddress() (addr net.IP, err error)
	AddPortMapping(protocol string, externalPort, internalPort int, description string, timeout int) (mappedExternalPort int, err error)
	DeletePortMapping(protocol string, externalPort, internalPort int) (err error)
}

type NeverChokePolicy struct{}

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

type OsFsProvider struct{}

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

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

type RandomChokePolicy struct{}

type Root struct {
	Device Device
}

type Service struct {
	ServiceType string `xml:"serviceType"`
	ControlURL  string `xml:"controlURL"`
}

type ServiceList struct {
	Service []Service `xml:"service"`
}

type SessionInfo struct {
	PeerID       string
	Port         uint16
	OurAddresses map[string]bool //List of addresses that resolve to ourselves.
	Uploaded     uint64
	Downloaded   uint64
	Left         uint64

	UseDHT      bool
	FromMagnet  bool
	HaveTorrent bool

	OurExtensions map[int]string
	ME            *MetaDataExchange
}

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

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

type SftpFsProvider struct {
	Server     string
	Username   string
	Password   string
	ServerPath string
}

type SoapBody struct {
	XMLName    xml.Name `xml:"http://schemas.xmlsoap.org/soap/envelope/ Body"`
	ExternalIP *ExternalIPAddressResponse
}

type TorrentFlags struct {
	Port                int
	FileDir             string
	SeedRatio           float64
	UseDeadlockDetector bool
	UseLPD              bool
	UseDHT              bool
	UseUPnP             bool
	UseNATPMP           bool
	TrackerlessMode     bool
	ExecOnSeeding       string

	// The dial function to use. Nil means use net.Dial
	Dial proxy.Dialer

	// IP address of gateway used for NAT-PMP
	Gateway string

	//Provides the filesystems added torrents are saved to
	FileSystemProvider FsProvider

	//Whether to check file hashes when adding torrents
	InitialCheck bool

	//Provides cache to each torrent
	Cacher CacheProvider

	//Whether to write and use *.haveBitset resume data
	QuickResume bool

	//How many torrents should be active at a time
	MaxActive int

	//The address of the logger server to send results to
	LoggerService *rpc.Client

	//Shiviz Policy
	ShivizPort string

	//Choke Policy
	ChokingPolicy ChokePolicy
}

type TorrentSession struct {
	M       *MetaInfo
	Session SessionInfo
	// contains filtered or unexported fields
}

type TrackerResponse struct {
	FailureReason  string `bencode:"failure reason"`
	WarningMessage string `bencode:"warning message"`
	Interval       uint
	MinInterval    uint   `bencode:"min interval"`
	TrackerId      string `bencode:"tracker id"`
	Complete       uint
	Incomplete     uint
	Peers          string
	Peers6         string
}