{-# LANGUAGE OverloadedStrings #-}
module FuncTorrent.Peer
(Peer(..),
- PeerResp(..),
- mkPeerResp,
- handShakeMsg
+ handShake,
+ msgLoop
) where
import Prelude hiding (lookup, concat, replicate, splitAt)
-import Data.ByteString.Char8 (ByteString, pack, unpack, concat, replicate, splitAt)
-import Data.ByteString.Lazy (toChunks)
-import Data.Int (Int8)
-import Data.List (intercalate)
-import Data.Map as M ((!), lookup)
-import qualified Data.Binary as Bin (encode)
-import qualified Data.ByteString.Base16 as B16 (encode)
-import FuncTorrent.Bencode (BVal(..), InfoDict)
-import FuncTorrent.Tracker (infoHash)
-import FuncTorrent.Utils (splitN)
+import System.IO
+import Data.ByteString (ByteString, pack, unpack, concat, hGet, hPut, singleton, append)
+import Data.ByteString.Lazy (fromStrict)
+import qualified Data.ByteString.Char8 as BC (replicate, pack, readInt)
+import Network (connectTo, PortID(..))
+import Data.Binary (Binary(..), decode)
+import Data.Binary.Put (putWord32be, putWord16be, putWord8)
+import Data.Binary.Get (getWord32be, getWord16be, getWord8)
+import Control.Monad (replicateM, liftM, forever)
+import Control.Applicative ((<$>), liftA3)
-
-type Address = String
+type ID = String
+type IP = String
type Port = Integer
-data Peer = Peer Address Port
- deriving (Show, Eq)
-
-data PeerResp = PeerResp { interval :: Maybe Integer
- , peers :: [Peer]
- , complete :: Maybe Integer
- , incomplete :: Maybe Integer
- } deriving (Show, Eq)
-
-toInt :: String -> Integer
-toInt = read
-
-mkPeerResp :: BVal -> Either ByteString PeerResp
-mkPeerResp resp =
- case lookup "failure reason" body of
- Just (Bstr err) -> Left err
- Just _ -> Left "Unknown failure"
- Nothing ->
- let (Just (Bint i)) = lookup "interval" body
- (Bstr peersBS) = body ! "peers"
- pl = map (\peer -> let (ip', port') = splitAt 4 peer
- in Peer (toIPNum ip') (toPortNum port'))
- (splitN 6 peersBS)
- in Right PeerResp {
- interval = Just i
- , peers = pl
- , complete = Nothing
- , incomplete = Nothing
- }
- where
- (Bdict body) = resp
- toPortNum = read . ("0x" ++) . unpack . B16.encode
- toIPNum = intercalate "." .
- map (show . toInt . ("0x" ++) . unpack) .
- splitN 2 . B16.encode
-
-
-handShakeMsg :: InfoDict -> String -> ByteString
-handShakeMsg m peer_id = let pstrlen = concat $ toChunks $ Bin.encode (19 :: Int8)
- pstr = pack "BitTorrent protocol"
- reserved = replicate 8 '\0'
- infoH = infoHash m
- peerID = pack peer_id
- in concat [pstrlen, pstr, reserved, infoH, peerID]
+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
+ 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"
+
+getMsg :: Handle -> IO PeerMsg
+getMsg h = do
+ lBS <- hGet h 4
+ let (Just (l, _)) = BC.readInt lBS
+ msg <- hGet h l
+ return $ decode $ fromStrict $ append lBS msg
+
+
+-- loop1 :: shake hands with all peers, find out the pieces they have, form PieceData.
+-- recvMsg :: Peer -> Handle -> Msg
+
+msgLoop :: Handle -> IO ()
+msgLoop h = forever $ do
+ msg <- getMsg h
+ putStrLn $ "got a " ++ (show msg)
projects / functorrent.git / blobdiff