package torrent import ( "crypto" "errors" "math/rand" "os" "path/filepath" "time" "bitbucket.org/anacrolix/go.torrent/mmap_span" "bitbucket.org/anacrolix/go.torrent/peer_protocol" "github.com/anacrolix/libtorgo/metainfo" "launchpad.net/gommap" ) const ( pieceHash = crypto.SHA1 maxRequests = 250 // Maximum pending requests we allow peers to send us. chunkSize = 0x4000 // 16KiB BEP20 = "-GT0000-" // Peer ID client identifier prefix nominalDialTimeout = time.Second * 30 minDialTimeout = 5 * time.Second ) type ( InfoHash [20]byte pieceSum [20]byte ) func (ih *InfoHash) AsString() string { return string(ih[:]) } type piece struct { Hash pieceSum PendingChunkSpecs map[chunkSpec]struct{} Hashing bool QueuedForHash bool EverHashed bool } func (p *piece) shuffledPendingChunkSpecs() (css []chunkSpec) { if len(p.PendingChunkSpecs) == 0 { return } css = make([]chunkSpec, 0, len(p.PendingChunkSpecs)) for cs := range p.PendingChunkSpecs { css = append(css, cs) } if len(css) <= 1 { return } for i := range css { j := rand.Intn(i + 1) css[i], css[j] = css[j], css[i] } return } func (p *piece) Complete() bool { return len(p.PendingChunkSpecs) == 0 && p.EverHashed } func lastChunkSpec(pieceLength peer_protocol.Integer) (cs chunkSpec) { cs.Begin = (pieceLength - 1) / chunkSize * chunkSize cs.Length = pieceLength - cs.Begin return } type chunkSpec struct { Begin, Length peer_protocol.Integer } type request struct { Index peer_protocol.Integer chunkSpec } func newRequest(index, begin, length peer_protocol.Integer) request { return request{index, chunkSpec{begin, length}} } type pieceByBytesPendingSlice struct { Pending, Indices []peer_protocol.Integer } func (pcs pieceByBytesPendingSlice) Len() int { return len(pcs.Indices) } func (me pieceByBytesPendingSlice) Less(i, j int) bool { return me.Pending[me.Indices[i]] < me.Pending[me.Indices[j]] } func (me pieceByBytesPendingSlice) Swap(i, j int) { me.Indices[i], me.Indices[j] = me.Indices[j], me.Indices[i] } var ( // Requested data not yet available. ErrDataNotReady = errors.New("data not ready") ) func upvertedSingleFileInfoFiles(info *metainfo.Info) []metainfo.FileInfo { if len(info.Files) != 0 { return info.Files } return []metainfo.FileInfo{{Length: info.Length, Path: nil}} } func mmapTorrentData(md *metainfo.Info, location string) (mms mmap_span.MMapSpan, err error) { defer func() { if err != nil { mms.Close() mms = nil } }() for _, miFile := range upvertedSingleFileInfoFiles(md) { fileName := filepath.Join(append([]string{location, md.Name}, miFile.Path...)...) err = os.MkdirAll(filepath.Dir(fileName), 0777) if err != nil { return } var file *os.File file, err = os.OpenFile(fileName, os.O_CREATE|os.O_RDWR, 0666) if err != nil { return } func() { defer file.Close() var fi os.FileInfo fi, err = file.Stat() if err != nil { return } if fi.Size() < miFile.Length { err = file.Truncate(miFile.Length) if err != nil { return } } var mMap gommap.MMap mMap, err = gommap.MapRegion(file.Fd(), 0, miFile.Length, gommap.PROT_READ|gommap.PROT_WRITE, gommap.MAP_SHARED) if err != nil { return } if int64(len(mMap)) != miFile.Length { panic("mmap has wrong length") } mms = append(mms, mMap) }() if err != nil { return } } return } // The size in bytes of a metadata extension piece. func metadataPieceSize(totalSize int, piece int) int { ret := totalSize - piece*(1<<14) if ret > 1<<14 { ret = 1 << 14 } return ret }