{-# LANGUAGE OverloadedStrings #-}
module FuncTorrent.Peer
(Peer(..),
- handShake
+ PieceMap,
+ handlePeerMsgs,
+ bytesDownloaded,
+ initPieceMap,
+ pieceMapFromFile
) where
-import Prelude hiding (lookup, concat, replicate, splitAt)
+import Prelude hiding (lookup, concat, replicate, splitAt, take, drop, filter)
-import System.IO
-import Data.ByteString (ByteString, pack, unpack, concat, hGet, hPut, singleton)
-import qualified Data.ByteString.Char8 as BC (replicate, pack)
+import System.IO (Handle, BufferMode(..), hSetBuffering, hClose)
+import Data.ByteString (ByteString, unpack, concat, hGet, hPut, take, drop, empty)
+import qualified Data.ByteString.Char8 as BC (length)
import Network (connectTo, PortID(..))
-import Data.Binary (Binary(..))
-import Data.Binary.Put (putWord32be, putWord16be, putWord8)
-import Data.Binary.Get (getWord32be, getWord16be, getWord8)
-import Control.Monad (replicateM, liftM)
-import Control.Applicative ((<$>), liftA3)
-
-type ID = String
-type IP = String
-type Port = Integer
-
-data PeerState = PeerState { handle :: Handle
- , am_choking :: Bool
- , am_interested :: Bool
- , peer_choking :: Bool
- , peer_interested :: Bool }
-
--- Maintain info on every piece and the current state of it.
--- should probably be a TVar.
-type Pieces = [PieceData]
-
-data PieceState = Pending
- | InProgress
- | Have
- deriving (Show)
-
-data PieceData = PieceData { index :: Int -- ^ Piece number
- , peers :: [Peer] -- ^ list of peers who have this piece
- , state :: PieceState } -- ^ state of the piece from download perspective.
-
--- | Peer is a PeerID, IP address, port tuple
-data Peer = Peer ID IP Port
- deriving (Show, Eq)
-
-data PeerMsg = KeepAliveMsg
- | ChokeMsg
- | UnChokeMsg
- | InterestedMsg
- | NotInterestedMsg
- | HaveMsg Integer
- | BitFieldMsg ByteString
- | RequestMsg Integer Integer Integer
- | PieceMsg Integer Integer ByteString
- | CancelMsg Integer Integer Integer
- | PortMsg Port
- deriving (Show)
-
-genHandShakeMsg :: ByteString -> String -> ByteString
-genHandShakeMsg infoHash peer_id = concat [pstrlen, pstr, reserved, infoHash, peerID]
- where pstrlen = singleton 19
- pstr = BC.pack "BitTorrent protocol"
- reserved = BC.replicate 8 '\0'
- peerID = BC.pack peer_id
-
-handShake :: Peer -> ByteString -> String -> IO Handle
-handShake (Peer _ ip port) infoHash peerid = do
- let hs = genHandShakeMsg infoHash peerid
+import Control.Monad.State
+import Data.Bits
+import Data.Word (Word8)
+import Data.Map (Map, fromList, toList, (!), mapWithKey, traverseWithKey, adjust, filter)
+import Safe (headMay)
+
+import FuncTorrent.Metainfo (Info(..), Metainfo(..))
+import FuncTorrent.Utils (splitN, splitNum, writeFileAtOffset, readFileAtOffset, verifyHash)
+import FuncTorrent.PeerMsgs (Peer(..), PeerMsg(..), sendMsg, getMsg, genHandshakeMsg)
+
+data PState = PState { handle :: Handle
+ , peer :: Peer
+ , meChoking :: Bool
+ , meInterested :: Bool
+ , heChoking :: Bool
+ , heInterested :: Bool}
+
+type PeerState = State PState
+
+data PieceDlState = Pending
+ | Downloading
+ | Have
+ deriving (Show, Eq)
+
+-- todo - map with index to a new data structure (peers who have that piece and state)
+data PieceData = PieceData { peers :: [Peer] -- ^ list of peers who have this piece
+ , dlstate :: PieceDlState -- ^ state of the piece from download perspective.
+ , hash :: ByteString -- ^ piece hash
+ , len :: Integer } -- ^ piece length
+
+-- which piece is with which peers
+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.
+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 =
+ dlstate (pm ! index) == Have
+
+connectToPeer :: Peer -> IO Handle
+connectToPeer (Peer _ ip port) = do
h <- connectTo ip (PortNumber (fromIntegral port))
hSetBuffering h LineBuffering
- hPut h hs
- rlenBS <- hGet h 1
- let rlen = fromIntegral $ (unpack rlenBS) !! 0
- hGet h rlen
return h
-instance Binary PeerMsg where
- put msg = case msg of
- KeepAliveMsg -> putWord32be 0
- ChokeMsg -> do putWord32be 1
- putWord8 0
- UnChokeMsg -> do putWord32be 1
- putWord8 1
- InterestedMsg -> do putWord32be 1
- putWord8 2
- NotInterestedMsg -> do putWord32be 1
- putWord8 3
- HaveMsg i -> do putWord32be 5
- putWord8 4
- putWord32be (fromIntegral i)
- BitFieldMsg bf -> do putWord32be $ fromIntegral (1 + bfListLen)
- putWord8 5
- mapM_ putWord8 bfList
- where bfList = unpack bf
- bfListLen = length bfList
- RequestMsg i o l -> do putWord32be 13
- putWord8 6
- putWord32be (fromIntegral i)
- putWord32be (fromIntegral o)
- putWord32be (fromIntegral l)
- PieceMsg i o b -> do putWord32be $ fromIntegral (9 + blocklen)
- putWord8 7
- putWord32be (fromIntegral i)
- putWord32be (fromIntegral o)
- mapM_ putWord8 blockList
- where blockList = unpack b
- blocklen = length blockList
- CancelMsg i o l -> do putWord32be 13
- putWord8 8
- putWord32be (fromIntegral i)
- putWord32be (fromIntegral o)
- putWord32be (fromIntegral l)
- PortMsg p -> do putWord32be 3
- putWord8 9
- putWord16be (fromIntegral p)
- get = do
- l <- getWord32be
- msgid <- getWord8
- case msgid of
- 0 -> return ChokeMsg
- 1 -> return UnChokeMsg
- 2 -> return InterestedMsg
- 3 -> return NotInterestedMsg
- 4 -> liftM (HaveMsg . fromIntegral) getWord32be
- 5 -> liftM (BitFieldMsg . pack) (replicateM (fromIntegral l - 1) getWord8)
- 6 -> liftA3 RequestMsg getInteger getInteger getInteger
- where getInteger = fromIntegral <$> getWord32be
- 7 -> liftA3 PieceMsg getInteger getInteger (pack <$> replicateM (fromIntegral l - 9) getWord8)
- where getInteger = fromIntegral <$> getWord32be
- 8 -> liftA3 CancelMsg getInteger getInteger getInteger
- where getInteger = fromIntegral <$> getWord32be
- 9 -> liftM (PortMsg . fromIntegral) getWord16be
- _ -> error "unknown message ID"
-
--- loop1 :: shake hands with all peers, find out the pieces they have, form PieceData.
--- recvMsg :: Peer -> Handle -> Msg
+doHandshake :: Bool -> Handle -> Peer -> ByteString -> String -> IO ()
+doHandshake True h peer infoHash peerid = do
+ let hs = genHandshakeMsg infoHash peerid
+ hPut h hs
+ putStrLn $ "--> handhake to peer: " ++ show peer
+ _ <- hGet h (length (unpack hs))
+ putStrLn $ "<-- handshake from peer: " ++ show peer
+ return ()
+doHandshake False h peer infoHash peerid = do
+ let hs = genHandshakeMsg infoHash peerid
+ putStrLn $ "waiting for a handshake"
+ hsMsg <- hGet h (length (unpack hs))
+ putStrLn $ "<-- handshake from peer: " ++ show peer
+ let rxInfoHash = take 20 $ drop 28 hsMsg
+ if rxInfoHash /= infoHash
+ then do
+ putStrLn $ "infoHashes does not match"
+ hClose h
+ return ()
+ else do
+ _ <- hPut h hs
+ putStrLn $ "--> handhake to peer: " ++ show peer
+ return ()
+
+bitfieldToList :: [Word8] -> [Integer]
+bitfieldToList bs = go bs 0
+ where go [] _ = []
+ go (b:bs') pos =
+ let setBits = [pos*8 + toInteger i | i <- [0..8], testBit b i]
+ in
+ setBits ++ go bs' (pos + 1)
+
+-- helper functions to manipulate PeerState
+toPeerState :: Handle
+ -> Peer
+ -> Bool -- ^ meChoking
+ -> Bool -- ^ meInterested
+ -> Bool -- ^ heChoking
+ -> Bool -- ^ heInterested
+ -> PState
+toPeerState h p meCh meIn heCh heIn =
+ PState { handle = h
+ , peer = p
+ , heChoking = heCh
+ , heInterested = heIn
+ , meChoking = meCh
+ , meInterested = meIn }
+
+-- simple algorithm to pick piece.
+-- pick the first piece from 0 that is not downloaded yet.
+pickPiece :: PieceMap -> Maybe Integer
+pickPiece =
+ (fst `liftM`) . headMay . toList . filter (\v -> dlstate v == Pending)
+
+bytesDownloaded :: PieceMap -> Integer
+bytesDownloaded =
+ sum . map (len . snd) . toList . filter (\v -> dlstate v == Have)
+
+updatePieceAvailability :: PieceMap -> Peer -> [Integer] -> PieceMap
+updatePieceAvailability pieceStatus p pieceList =
+ mapWithKey (\k pd -> if k `elem` pieceList
+ then (pd { peers = p : peers pd })
+ else pd) pieceStatus
+
+handlePeerMsgs :: Peer -> String -> Metainfo -> PieceMap -> Bool -> IO ()
+handlePeerMsgs p peerId m pieceMap isClient = do
+ h <- connectToPeer p
+ doHandshake isClient h p (infoHash m) peerId
+ let pstate = toPeerState h p False False True True
+ filePath = name (info m)
+ _ <- runStateT (msgLoop pieceMap filePath) pstate
+ return ()
+
+msgLoop :: PieceMap -> FilePath -> StateT PState IO ()
+msgLoop pieceStatus file = do
+ h <- gets handle
+ st <- get
+ case st of
+ PState { meInterested = False, heChoking = True } -> do
+ liftIO $ sendMsg h InterestedMsg
+ gets peer >>= (\p -> liftIO $ putStrLn $ "--> InterestedMsg to peer: " ++ show p)
+ modify (\st -> st { meInterested = True })
+ msgLoop pieceStatus file
+ PState { meInterested = True, heChoking = False } ->
+ case pickPiece pieceStatus of
+ Nothing -> liftIO $ putStrLn "Nothing to download"
+ Just workPiece -> do
+ let pLen = len (pieceStatus ! workPiece)
+ liftIO $ putStrLn $ "piece length = " ++ show pLen
+ pBS <- liftIO $ downloadPiece h workPiece pLen
+ if not $ verifyHash pBS (hash (pieceStatus ! workPiece))
+ then
+ liftIO $ putStrLn $ "Hash mismatch"
+ else do
+ let fileOffset = if workPiece == 0 then 0 else workPiece * len (pieceStatus ! (workPiece - 1))
+ liftIO $ putStrLn $ "Write into file at offset: " ++ show fileOffset
+ liftIO $ writeFileAtOffset file fileOffset pBS
+ msgLoop (adjust (\pieceData -> pieceData { dlstate = Have }) workPiece pieceStatus) file
+ _ -> do
+ msg <- liftIO $ getMsg h
+ gets peer >>= (\p -> liftIO $ putStrLn $ "<-- " ++ show msg ++ "from peer: " ++ show p)
+ case msg of
+ KeepAliveMsg -> do
+ liftIO $ sendMsg h KeepAliveMsg
+ gets peer >>= (\p -> liftIO $ putStrLn $ "--> " ++ "KeepAliveMsg to peer: " ++ show p)
+ msgLoop pieceStatus file
+ BitFieldMsg bss -> do
+ p <- gets peer
+ let pieceList = bitfieldToList (unpack bss)
+ pieceStatus' = updatePieceAvailability pieceStatus p pieceList
+ liftIO $ putStrLn $ show (length pieceList) ++ " Pieces"
+ -- for each pieceIndex in pieceList, make an entry in the pieceStatus
+ -- map with pieceIndex as the key and modify the value to add the peer.
+ -- download each of the piece in order
+ msgLoop pieceStatus' file
+ UnChokeMsg -> do
+ modify (\st -> st {heChoking = False })
+ msgLoop pieceStatus file
+ ChokeMsg -> do
+ modify (\st -> st {heChoking = True })
+ msgLoop pieceStatus file
+ InterestedMsg -> do
+ modify (\st -> st {heInterested = True})
+ msgLoop pieceStatus file
+ NotInterestedMsg -> do
+ modify (\st -> st {heInterested = False})
+ msgLoop pieceStatus file
+ CancelMsg _ _ _ -> do -- check if valid index, begin, length
+ msgLoop pieceStatus file
+ PortMsg _ -> do
+ msgLoop pieceStatus file
+ -- handle RequestMsg, HaveMsg. No need to handle PieceMsg here.
+ -- also BitFieldMsg
+
+
+downloadPiece :: Handle -> Integer -> Integer -> IO ByteString
+downloadPiece h index pieceLength = do
+ let chunks = splitNum pieceLength 16384
+ concat `liftM` forM (zip [0..] chunks) (\(i, pLen) -> do
+ sendMsg h (RequestMsg index (i*pLen) pLen)
+ putStrLn $ "--> " ++ "RequestMsg for Piece "
+ ++ show index ++ ", part: " ++ show i ++ " of length: "
+ ++ show pLen
+ msg <- getMsg h
+ case msg of
+ PieceMsg index begin block -> do
+ putStrLn $ " <-- PieceMsg for Piece: "
+ ++ show index
+ ++ ", offset: "
+ ++ show begin
+ return block
+ _ -> do
+ putStrLn "ignoring irrelevant msg"
+ return empty)
+
projects / functorrent.git / blobdiff