refactor the piecemap initialization

[functorrent.git] / src / FuncTorrent / Peer.hs

diff --git a/src/FuncTorrent/Peer.hs b/src/FuncTorrent/Peer.hs
index a7ce781ae5c5139fc34bb81f1e7f715c34e8e0ce..157dab0c021e7d5155169fdc638f200c29b48a3d 100644 (file)
--- a/src/FuncTorrent/Peer.hs
+++ b/src/FuncTorrent/Peer.hs
@@ -1,8 +1,11 @@
 {-# LANGUAGE OverloadedStrings #-}
 module FuncTorrent.Peer
     (Peer(..),
+     PieceMap,
      handlePeerMsgs,
-     bytesDownloaded
+     bytesDownloaded,
+     initPieceMap,
+     pieceMapFromFile
     ) where
 
 import Prelude hiding (lookup, concat, replicate, splitAt, take, filter)
@@ -14,13 +17,12 @@ import Network (connectTo, PortID(..))
 import Control.Monad.State
 import Data.Bits
 import Data.Word (Word8)
-import Data.Map (Map, fromList, toList, (!), mapWithKey, adjust, filter)
+import Data.Map (Map, fromList, toList, (!), mapWithKey, traverseWithKey, adjust, filter)
 import qualified Crypto.Hash.SHA1 as SHA1 (hash)
 import Safe (headMay)
 
 import FuncTorrent.Metainfo (Info(..), Metainfo(..))
-import FuncTorrent.Utils (splitN, splitNum)
-import FuncTorrent.Fileops (createDummyFile, writeFileAtOffset)
+import FuncTorrent.Utils (splitN, splitNum, writeFileAtOffset, readFileAtOffset)
 import FuncTorrent.PeerMsgs (Peer(..), PeerMsg(..), sendMsg, getMsg, genHandshakeMsg)
 
 data PState = PState { handle :: Handle
@@ -49,14 +51,28 @@ type PieceMap = Map Integer PieceData
 
 -- Make the initial Piece map, with the assumption that no peer has the
 -- piece and that every piece is pending download.
-mkPieceMap :: Integer -> ByteString -> [Integer] -> PieceMap
-mkPieceMap numPieces pieceHash pLengths = fromList kvs
-  where kvs = [(i, PieceData { peers = []
-                             , dlstate = Pending
-                             , hash = h
-                             , len = pLen })
-              | (i, h, pLen) <- zip3 [0..numPieces] hashes pLengths]
-        hashes = splitN 20 pieceHash
+initPieceMap :: ByteString  -> Integer -> Integer -> PieceMap
+initPieceMap pieceHash fileLen pieceLen = fromList kvs
+  where
+    numPieces = (toInteger . (`quot` 20) . BC.length) pieceHash
+    kvs = [(i, PieceData { peers = []
+                         , dlstate = Pending
+                         , hash = h
+                         , len = pLen })
+          | (i, h, pLen) <- zip3 [0..numPieces] hashes pLengths]
+    hashes = splitN 20 pieceHash
+    pLengths = (splitNum fileLen pieceLen)
+
+pieceMapFromFile :: FilePath -> PieceMap -> IO PieceMap
+pieceMapFromFile filePath pieceMap = do
+  traverseWithKey f pieceMap
+    where
+      f k v = do
+        let offset = if k == 0 then 0 else k * len (pieceMap ! (k - 1))
+        isHashValid <- (flip verifyHash) (hash v) <$> (readFileAtOffset filePath offset (len v))
+        if isHashValid
+          then return $ v { dlstate = Have }
+          else return $ v
 
 havePiece :: PieceMap -> Integer -> Bool
 havePiece pm index =
@@ -109,7 +125,7 @@ pickPiece =
 
 bytesDownloaded :: PieceMap -> Integer
 bytesDownloaded =
-  sum . (map (len . snd)) . toList . filter (\v -> dlstate v == Have)
+  sum . map (len . snd) . toList . filter (\v -> dlstate v == Have)
 
 updatePieceAvailability :: PieceMap -> Peer -> [Integer] -> PieceMap
 updatePieceAvailability pieceStatus p pieceList =
@@ -117,19 +133,13 @@ updatePieceAvailability pieceStatus p pieceList =
                        then (pd { peers = p : peers pd })
                        else pd) pieceStatus
 
-handlePeerMsgs :: Peer -> String -> Metainfo -> IO ()
-handlePeerMsgs p peerId m = do
+handlePeerMsgs :: Peer -> String -> Metainfo -> PieceMap -> IO ()
+handlePeerMsgs p peerId m pieceMap = do
   h <- connectToPeer p
   doHandshake h p (infoHash m) peerId
   let pstate = toPeerState h p False False True True
-      pieceHash = pieces (info m)
-      numPieces = (toInteger . (`quot` 20) . BC.length) pieceHash
-      pLen = pieceLength (info m)
-      fileLen = lengthInBytes (info m)
-      fileName = name (info m)
-      pieceStatus = mkPieceMap numPieces pieceHash (splitNum fileLen pLen)
-  createDummyFile fileName (fromIntegral fileLen)
-  _ <- runStateT (msgLoop pieceStatus fileName) pstate
+      filePath = name (info m)
+  _ <- runStateT (msgLoop pieceMap filePath) pstate
   return ()
 
 msgLoop :: PieceMap -> FilePath -> StateT PState IO ()