cmd/torrent-verify/main.go

   1 package main
   2
   3 import (
   4         "bytes"
   5         "crypto/sha1"
   6         "fmt"
   7         "io"
   8         "log"
   9         "os"
  10         "path/filepath"
  11
  12         "github.com/anacrolix/tagflag"
  13         "github.com/edsrzf/mmap-go"
  14
  15         "github.com/anacrolix/torrent/metainfo"
  16         "github.com/anacrolix/torrent/mmap_span"
  17         "github.com/anacrolix/torrent/storage"
  18 )
  19
  20 func mmapFile(name string) (mm storage.FileMapping, err error) {
  21         f, err := os.Open(name)
  22         if err != nil {
  23                 return
  24         }
  25         defer func() {
  26                 if err != nil {
  27                         f.Close()
  28                 }
  29         }()
  30         fi, err := f.Stat()
  31         if err != nil {
  32                 return
  33         }
  34         if fi.Size() == 0 {
  35                 return
  36         }
  37         reg, err := mmap.MapRegion(f, -1, mmap.RDONLY, mmap.COPY, 0)
  38         if err != nil {
  39                 return
  40         }
  41         return storage.WrapFileMapping(reg, f), nil
  42 }
  43
  44 func verifyTorrent(info *metainfo.Info, root string) error {
  45         span := new(mmap_span.MMapSpan)
  46         for _, file := range info.UpvertedFiles() {
  47                 filename := filepath.Join(append([]string{root, info.Name}, file.Path...)...)
  48                 mm, err := mmapFile(filename)
  49                 if err != nil {
  50                         return err
  51                 }
  52                 if int64(len(mm.Bytes())) != file.Length {
  53                         return fmt.Errorf("file %q has wrong length", filename)
  54                 }
  55                 span.Append(mm)
  56         }
  57         span.InitIndex()
  58         for i, numPieces := 0, info.NumPieces(); i < numPieces; i += 1 {
  59                 p := info.Piece(i)
  60                 hash := sha1.New()
  61                 _, err := io.Copy(hash, io.NewSectionReader(span, p.Offset(), p.Length()))
  62                 if err != nil {
  63                         return err
  64                 }
  65                 good := bytes.Equal(hash.Sum(nil), p.Hash().Bytes())
  66                 if !good {
  67                         return fmt.Errorf("hash mismatch at piece %d", i)
  68                 }
  69                 fmt.Printf("%d: %v: %v\n", i, p.Hash(), good)
  70         }
  71         return nil
  72 }
  73
  74 func main() {
  75         log.SetFlags(log.Flags() | log.Lshortfile)
  76         flags := struct {
  77                 DataDir string
  78                 tagflag.StartPos
  79                 TorrentFile string
  80         }{}
  81         tagflag.Parse(&flags)
  82         metaInfo, err := metainfo.LoadFromFile(flags.TorrentFile)
  83         if err != nil {
  84                 log.Fatal(err)
  85         }
  86         info, err := metaInfo.UnmarshalInfo()
  87         if err != nil {
  88                 log.Fatalf("error unmarshalling info: %s", err)
  89         }
  90         err = verifyTorrent(&info, flags.DataDir)
  91         if err != nil {
  92                 log.Fatalf("torrent failed verification: %s", err)
  93         }
  94 }