- (TrackerResponse(..),
- mkArgs,
- getTrackerResponse,
- urlEncodeHash
- ) where
-
-import Prelude hiding (lookup, splitAt)
-
-import Control.Monad.IO.Class (liftIO)
-import Control.Monad.Reader (ReaderT, ask, runReaderT)
-import Data.ByteString (ByteString)
-import Data.ByteString.Char8 as BC (pack, unpack, splitAt)
-import Data.Char (chr)
-import Data.List (intercalate)
-import Data.Map as M (lookup)
-import Network.HTTP.Base (urlEncode)
-import qualified Data.ByteString.Base16 as B16 (encode)
-
-import FuncTorrent.Bencode (BVal(..), decode)
-import FuncTorrent.Metainfo (Info(..), Metainfo(..))
-import FuncTorrent.Network (get)
-import FuncTorrent.Peer (Peer(..))
-import FuncTorrent.Utils (splitN)
-
--- | Tracker response
-data TrackerResponse = TrackerResponse {
- interval :: Maybe Integer
- , peers :: [Peer]
- , complete :: Maybe Integer
- , incomplete :: Maybe Integer
- } deriving (Show, Eq)
-
--- | Deserialize tracker response
-mkTrackerResponse :: BVal -> Either ByteString TrackerResponse
-mkTrackerResponse resp =
- case lookup "failure reason" body of
- Just (Bstr err) -> Left err
- Just _ -> Left "Unknown failure"
- Nothing ->
- let (Just (Bint i)) = lookup "interval" body
- (Just (Bstr peersBS)) = lookup "peers" body
- pl = map makePeer (splitN 6 peersBS)
- in Right TrackerResponse {
- interval = Just i
- , peers = pl
- , complete = Nothing
- , incomplete = Nothing
- }
+ (runTracker
+ , getConnectedPeers
+ , newTracker
+ ) where
+
+import Control.Concurrent(forkIO)
+import Control.Concurrent.Chan (Chan, newChan, readChan, writeChan)
+import Control.Concurrent.MVar (newEmptyMVar, putMVar, readMVar)
+import Control.Monad.State (StateT, liftIO, get, runStateT)
+import Control.Monad (forever)
+import Data.ByteString.Char8 (ByteString, pack, unpack)
+import Data.List (isPrefixOf)
+import Network (PortNumber)
+
+import qualified FuncTorrent.Tracker.Http as HT (trackerLoop)
+import qualified FuncTorrent.Tracker.Udp as UT (trackerLoop)
+import FuncTorrent.Tracker.Types (TState(..), TrackerEventState(..), TrackerProtocol(..), TrackerMsg(..))
+import FuncTorrent.Utils (Port, toPort, getHostname)
+import qualified FuncTorrent.FileSystem as FS (MsgChannel)
+import FuncTorrent.Peer (Peer)
+
+type MsgChannel = Chan TrackerMsg
+
+newTracker :: IO MsgChannel
+newTracker = newChan
+
+runTracker :: MsgChannel -> FS.MsgChannel -> ByteString -> PortNumber
+ -> String -> [String] -> Integer -> IO ()
+runTracker msgChannel fsChan infohash port peerId announceList sz = do
+ ps <- newEmptyMVar
+ let initialTState = TState { currentState = None
+ , connectedPeers = ps
+ , left = sz }
+ turl = head announceList
+ host = getHostname turl
+ case getTrackerType turl of
+ Http -> do
+ _ <- forkIO $ HT.trackerLoop turl port peerId infohash fsChan initialTState
+ runStateT (msgHandler msgChannel) initialTState
+ return ()
+ Udp -> do
+ _ <- forkIO $ UT.trackerLoop turl (fromIntegral port) peerId infohash fsChan initialTState
+ return ()
+ _ ->
+ error "Tracker Protocol unimplemented"
+
+getTrackerType :: String -> TrackerProtocol
+getTrackerType url | "http://" `isPrefixOf` url = Http
+ | "udp://" `isPrefixOf` url = Udp
+ | otherwise = UnknownProtocol
+
+
+msgHandler :: MsgChannel -> StateT TState IO ()
+msgHandler c = forever $ do
+ st <- get
+ peers <- liftIO $ readMVar (connectedPeers st)
+ msg <- liftIO recvMsg
+ liftIO $ sendResponse msg peers