X-Git-Url: http://www.git.stargrave.org/?a=blobdiff_plain;f=misc.go;h=7d3007ecee74eb92f58eee434dfb9431a86f9098;hb=050e5cbab8e26a9b28e57a7bc2a964b6d2ceb899;hp=784ecf4d8a018a30f742ecf830ce14081f3a88ea;hpb=74f05db2ead5cc6d06703996152d4c919fffd41f;p=btrtrc.git diff --git a/misc.go b/misc.go index 784ecf4d..7d3007ec 100644 --- a/misc.go +++ b/misc.go @@ -1,155 +1,194 @@ 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" -) + "net" -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 - dialTimeout = time.Second * 15 + "github.com/RoaringBitmap/roaring" + "github.com/anacrolix/missinggo/v2" + "golang.org/x/time/rate" + + "github.com/anacrolix/torrent/metainfo" + pp "github.com/anacrolix/torrent/peer_protocol" + "github.com/anacrolix/torrent/types" + "github.com/anacrolix/torrent/types/infohash" ) type ( - InfoHash [20]byte - pieceSum [20]byte + Request = types.Request + ChunkSpec = types.ChunkSpec + piecePriority = types.PiecePriority ) -type piece struct { - Hash pieceSum - PendingChunkSpecs map[chunkSpec]struct{} - Hashing bool - QueuedForHash bool - EverHashed bool +const ( + PiecePriorityNormal = types.PiecePriorityNormal + PiecePriorityNone = types.PiecePriorityNone + PiecePriorityNow = types.PiecePriorityNow + PiecePriorityReadahead = types.PiecePriorityReadahead + PiecePriorityNext = types.PiecePriorityNext + PiecePriorityHigh = types.PiecePriorityHigh +) + +func newRequest(index, begin, length pp.Integer) Request { + return Request{index, ChunkSpec{begin, length}} } -func (p *piece) shuffledPendingChunkSpecs() (css []chunkSpec) { - css = make([]chunkSpec, 0, len(p.PendingChunkSpecs)) - for cs := range p.PendingChunkSpecs { - css = append(css, cs) - } - for i := range css { - j := rand.Intn(i + 1) - css[i], css[j] = css[j], css[i] +func newRequestFromMessage(msg *pp.Message) Request { + switch msg.Type { + case pp.Request, pp.Cancel, pp.Reject: + return newRequest(msg.Index, msg.Begin, msg.Length) + case pp.Piece: + return newRequest(msg.Index, msg.Begin, pp.Integer(len(msg.Piece))) + default: + panic(msg.Type) } - return } -func (p *piece) Complete() bool { - return len(p.PendingChunkSpecs) == 0 && p.EverHashed +// The size in bytes of a metadata extension piece. +func metadataPieceSize(totalSize, piece int) int { + ret := totalSize - piece*(1<<14) + if ret > 1<<14 { + ret = 1 << 14 + } + return ret } -func lastChunkSpec(pieceLength peer_protocol.Integer) (cs chunkSpec) { - cs.Begin = (pieceLength - 1) / chunkSize * chunkSize - cs.Length = pieceLength - cs.Begin +// Return the request that would include the given offset into the torrent data. +func torrentOffsetRequest( + torrentLength, pieceSize, chunkSize, offset int64, +) ( + r Request, ok bool, +) { + if offset < 0 || offset >= torrentLength { + return + } + r.Index = pp.Integer(offset / pieceSize) + r.Begin = pp.Integer(offset % pieceSize / chunkSize * chunkSize) + r.Length = pp.Integer(chunkSize) + pieceLeft := pp.Integer(pieceSize - int64(r.Begin)) + if r.Length > pieceLeft { + r.Length = pieceLeft + } + torrentLeft := torrentLength - int64(r.Index)*pieceSize - int64(r.Begin) + if int64(r.Length) > torrentLeft { + r.Length = pp.Integer(torrentLeft) + } + ok = true return } -type chunkSpec struct { - Begin, Length peer_protocol.Integer +func torrentRequestOffset(torrentLength, pieceSize int64, r Request) (off int64) { + off = int64(r.Index)*pieceSize + int64(r.Begin) + if off < 0 || off >= torrentLength { + panic("invalid Request") + } + return } -type request struct { - Index peer_protocol.Integer - chunkSpec +func validateInfo(info *metainfo.Info) error { + if len(info.Pieces)%20 != 0 { + return errors.New("pieces has invalid length") + } + if info.PieceLength == 0 { + if info.TotalLength() != 0 { + return errors.New("zero piece length") + } + } else { + if int((info.TotalLength()+info.PieceLength-1)/info.PieceLength) != info.NumPieces() { + return errors.New("piece count and file lengths are at odds") + } + } + return nil } -func newRequest(index, begin, length peer_protocol.Integer) request { - return request{index, chunkSpec{begin, length}} +func chunkIndexSpec(index, pieceLength, chunkSize pp.Integer) ChunkSpec { + ret := ChunkSpec{pp.Integer(index) * chunkSize, chunkSize} + if ret.Begin+ret.Length > pieceLength { + ret.Length = pieceLength - ret.Begin + } + return ret } -type pieceByBytesPendingSlice struct { - Pending, Indices []peer_protocol.Integer +func connLessTrusted(l, r *Peer) bool { + return l.trust().Less(r.trust()) } -func (pcs pieceByBytesPendingSlice) Len() int { - return len(pcs.Indices) +func connIsIpv6(nc interface { + LocalAddr() net.Addr +}, +) bool { + ra := nc.LocalAddr() + rip := addrIpOrNil(ra) + return rip.To4() == nil && rip.To16() != nil } -func (me pieceByBytesPendingSlice) Less(i, j int) bool { - return me.Pending[me.Indices[i]] < me.Pending[me.Indices[j]] +func clamp(min, value, max int64) int64 { + if min > max { + panic("harumph") + } + if value < min { + value = min + } + if value > max { + value = max + } + return value } -func (me pieceByBytesPendingSlice) Swap(i, j int) { - me.Indices[i], me.Indices[j] = me.Indices[j], me.Indices[i] +func max(as ...int64) int64 { + ret := as[0] + for _, a := range as[1:] { + if a > ret { + ret = a + } + } + return ret } -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 +func maxInt(as ...int) int { + ret := as[0] + for _, a := range as[1:] { + if a > ret { + ret = a + } } - return []metainfo.FileInfo{{Length: info.Length, Path: nil}} + return ret } -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 +func min(as ...int64) int64 { + ret := as[0] + for _, a := range as[1:] { + if a < ret { + ret = a } } - return + return ret } -func metadataPieceSize(totalSize int, piece int) int { - ret := totalSize - piece*(1<<14) - if ret > 1<<14 { - ret = 1 << 14 +func minInt(as ...int) int { + ret := as[0] + for _, a := range as[1:] { + if a < ret { + ret = a + } } return ret } + +var unlimited = rate.NewLimiter(rate.Inf, 0) + +type ( + pieceIndex = int + // Deprecated: Use infohash.T directly to avoid unnecessary imports. + InfoHash = infohash.T + IpPort = missinggo.IpPort +) + +func boolSliceToBitmap(slice []bool) (rb roaring.Bitmap) { + for i, b := range slice { + if b { + rb.AddInt(i) + } + } + return +}