import System.IO (Handle, BufferMode(..), hSetBuffering)
import Data.ByteString (ByteString, pack, unpack, concat, hGet, hPut, singleton, writeFile)
-import Data.ByteString.Lazy (fromStrict, fromChunks)
+import Data.ByteString.Lazy (fromStrict, fromChunks, toStrict)
import qualified Data.ByteString.Char8 as BC (replicate, pack, length)
import Network (connectTo, PortID(..))
-import Data.Binary (Binary(..), decode)
+import Data.Binary (Binary(..), decode, encode)
import Data.Binary.Put (putWord32be, putWord16be, putWord8)
import Data.Binary.Get (getWord32be, getWord16be, getWord8, runGet)
import Control.Monad (replicateM, liftM, forever)
import Control.Applicative ((<$>), liftA3)
import Data.Bits
import Data.Word (Word8)
-import Data.Map (Map(..), fromList)
+import Data.Map (Map(..), fromList, (!))
import FuncTorrent.Metainfo (Info(..), Metainfo(..))
import FuncTorrent.Utils (splitN)
type IP = String
type Port = Integer
+-- PeerState is a misnomer
data PeerState = PeerState { handle :: Handle
- , am_choking :: Bool
- , am_interested :: Bool
- , peer_choking :: Bool
- , peer_interested :: Bool}
+ , peer :: Peer
+ , meChoking :: Bool
+ , meInterested :: Bool
+ , heChoking :: Bool
+ , heInterested :: Bool}
-- Maintain info on every piece and the current state of it.
-- should probably be a TVar.
data PieceDlState = Pending
| InProgress
| Have
- deriving (Show)
+ deriving (Show, Eq)
-- todo - map with index to a new data structure (peers who have that piece amd state)
data PieceData = PieceData { peers :: [Peer] -- ^ list of peers who have this piece
-- Make the initial Piece map, with the assumption that no peer has the
-- piece and that every piece is pending download.
-mkPieceMap :: Integer -> ByteString -> Map Integer PieceData
+mkPieceMap :: Integer -> ByteString -> PieceMap
mkPieceMap numPieces pieceHash = fromList kvs
where kvs = [(i, PieceData { peers = []
, state = Pending
, hash = h }) | (i, h) <- zip [0..numPieces] hashes]
hashes = splitN (fromIntegral numPieces) pieceHash
+havePiece :: PieceMap -> Integer -> Bool
+havePiece pm index =
+ state (pm ! index) == Have
+
genHandShakeMsg :: ByteString -> String -> ByteString
genHandShakeMsg infoHash peer_id = concat [pstrlen, pstr, reserved, infoHash, peerID]
where pstrlen = singleton 19
peerID = BC.pack peer_id
handShake :: Peer -> ByteString -> String -> IO Handle
-handShake (Peer _ ip port) infoHash peerid = do
+handShake peer@(Peer _ ip port) infoHash peerid = do
let hs = genHandShakeMsg infoHash peerid
h <- connectTo ip (PortNumber (fromIntegral port))
hSetBuffering h LineBuffering
hPut h hs
+ putStrLn $ "--> handhake to peer: " ++ show peer
rlenBS <- hGet h (length (unpack hs))
- putStrLn $ "got handshake from peer: " ++ show rlenBS
+ putStrLn $ "<-- handshake from peer: " ++ show peer
return h
instance Binary PeerMsg where
msg <- hGet h l
return $ decode $ fromStrict $ concat [lBS, msg]
+sendMsg :: Handle -> PeerMsg -> IO ()
+sendMsg h msg =
+ let bsMsg = toStrict $ encode msg
+ in
+ hPut h bsMsg
bsToInt :: ByteString -> Int
bsToInt x = fromIntegral (runGet getWord32be (fromChunks (return x)))
bitfieldToList bs = go bs 0
where go [] _ = []
go (b:bs') pos =
- let setBits = [pos*8 + (toInteger i) | i <- [0..8], testBit b i]
+ let setBits = [pos*8 + toInteger i | i <- [0..8], testBit b i]
in
- setBits ++ (go bs' (pos + 1))
+ setBits ++ go bs' (pos + 1)
-- downloadPiece :: Integer -> Handle -> IO ()
createDummyFile :: FilePath -> Int -> IO ()
-createDummyFile path size = do
+createDummyFile path size =
writeFile path (BC.replicate size '\0')
-- loop1 :: shake hands with all peers, find out the pieces they have, form PieceData.
-- recvMsg :: Peer -> Handle -> Msg
-msgLoop :: Handle -> ByteString -> IO ()
-msgLoop h pieceHash =
- let numPieces = (toInteger . (`quot` 20) . BC.length) pieceHash
- pieceStatus = mkPieceMap numPieces pieceHash
- in
- forever $ do
- msg <- getMsg h
- putStrLn $ "got a " ++ show msg
- case msg of
- BitFieldMsg bss -> do
- let pieceList = bitfieldToList (unpack bss)
- putStrLn (show pieceList)
- -- download each of the piece in order
- _ -> putStrLn (show msg)
+msgLoop :: PeerState -> PieceMap -> IO ()
+msgLoop state pieceStatus = do
+ -- if meInterested and he NOT Choking, pick a piece to download
+ -- and send a requestmsg.
+ let isMeInterested = meInterested state
+ isHeChoking = heChoking state
+ if (isMeInterested && isHeChoking)
+ then
+ do
+ let h = handle state
+ sendMsg h InterestedMsg
+ putStrLn $ "--> InterestedMsg to peer: " ++ show (peer state)
+ msgLoop state pieceStatus
+ else
+ do
+ msg <- getMsg (handle state)
+ putStrLn $ "<-- " ++ show msg ++ "from peer: " ++ show (peer state)
+ case msg of
+ KeepAliveMsg -> do
+ sendMsg (handle state) KeepAliveMsg
+ msgLoop state pieceStatus
+ BitFieldMsg bss -> do
+ let pieceList = bitfieldToList (unpack bss)
+ print pieceList
+ -- 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 state pieceStatus
+ UnChokeMsg -> do
+ msgLoop (state {heChoking = False}) pieceStatus
+ _ -> do
+ msgLoop state pieceStatus
handlePeerMsgs :: Peer -> Metainfo -> String -> (String -> IO ()) -> IO ()
handlePeerMsgs p m peerId logFn = do
h <- handShake p (infoHash m) peerId
- logFn $ "handShake"
- msgLoop h (pieces (info m))
+ -- logFn "handShake"
+ let state = PeerState { handle = h
+ , peer = p
+ , heInterested = False
+ , heChoking = False
+ , meInterested = True
+ , meChoking = False }
+ pieceHash = (pieces (info m))
+ numPieces = (toInteger . (`quot` 20) . BC.length) pieceHash
+ pieceStatus = mkPieceMap numPieces pieceHash
+ msgLoop state pieceStatus
projects / functorrent.git / blobdiff