fix hlint suggestions

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

diff --git a/src/FuncTorrent/Tracker.hs b/src/FuncTorrent/Tracker.hs
index 178aa9719bbb870d0d2f5dbcf26f174a6d10b67a..5cd6aeaa686dcd6b45bec0e18037054a7fb80fa8 100644 (file)
--- a/src/FuncTorrent/Tracker.hs
+++ b/src/FuncTorrent/Tracker.hs
@@ -1,31 +1,90 @@
+{-# LANGUAGE OverloadedStrings #-}
 module FuncTorrent.Tracker
-    (connect,
-     infoHash,
-     prepareRequest,
+    (TrackerResponse(..),
+     mkArgs,
+     getTrackerResponse,
      urlEncodeHash
     ) where
 
-import Prelude hiding (lookup)
-import Crypto.Hash.SHA1 (hash)
-import Data.ByteString.Char8 (ByteString, pack, unpack)
+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.Maybe (fromJust)
-import Data.Map as M (Map, (!))
-import Network.HTTP (simpleHTTP, defaultGETRequest_, getResponseBody)
+import Data.Map as M (lookup)
 import Network.HTTP.Base (urlEncode)
-import Network.URI (parseURI)
 import qualified Data.ByteString.Base16 as B16 (encode)
 
-import FuncTorrent.Bencode (BVal(..), InfoDict, encode)
+import FuncTorrent.Bencode (BVal(..), decode)
+import FuncTorrent.Metainfo (Info(..), Metainfo(..))
+import FuncTorrent.Network (get)
+import FuncTorrent.Peer (Peer(..))
 import FuncTorrent.Utils (splitN)
 
-type Url = String
+-- | 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
+                 }
+    where
+      (Bdict body) = resp
+
+      toInt :: String -> Integer
+      toInt = read
+
+      toPort :: ByteString -> Integer
+      toPort = read . ("0x" ++) . unpack . B16.encode
+
+      toIP :: ByteString -> String
+      toIP = Data.List.intercalate "." .
+             map (show . toInt . ("0x" ++) . unpack) .
+                 splitN 2 . B16.encode
 
--- | urlEncodeHash
---
--- >>> urlEncodeHash $ pack "123456789abcdef123456789abcdef123456789a"
--- "%124Vx%9a%bc%de%f1%23Eg%89%ab%cd%ef%124Vx%9a"
+      makePeer :: ByteString -> Peer
+      makePeer peer = Peer "" (toIP ip') (toPort port')
+          where (ip', port') = splitAt 4 peer
+
+-- | Connect to a tracker and get peer info
+tracker :: String -> ReaderT Metainfo IO ByteString
+tracker peer_id = do
+  m <- ask
+  let args = mkArgs peer_id m
+  liftIO $ get (head . announceList $ m) args
+
+getTrackerResponse ::  String -> ReaderT Metainfo IO (Either ByteString TrackerResponse)
+getTrackerResponse peerId = do
+  m <- ask
+  resp <- liftIO $ runReaderT (tracker peerId) m
+  case decode resp of
+   Right trackerInfo -> liftIO $ return $ mkTrackerResponse trackerInfo
+   Left e -> return $ Left (pack (show e))
+
+--- | URL encode hash as per RFC1738
+--- TODO: Add tests
+--- REVIEW: Why is this not written in terms of `Network.HTTP.Base.urlEncode` or
+--- equivalent library function?
 urlEncodeHash :: ByteString -> String
 urlEncodeHash bs = concatMap (encode' . unpack) (splitN 2 bs)
   where encode' b@[c1, c2] = let c =  chr (read ("0x" ++ b))
@@ -36,22 +95,16 @@ urlEncodeHash bs = concatMap (encode' . unpack) (splitN 2 bs)
 
         nonSpecialChars = ['A'..'Z'] ++ ['a'..'z'] ++ ['0'..'9'] ++ "-_.~"
 
-infoHash :: Map BVal BVal -> ByteString
-infoHash m = let info = m ! Bstr (pack "info")
-             in (hash . pack . encode) info
-
-prepareRequest :: InfoDict -> String -> Integer -> String
-prepareRequest d peer_id len =
-  let p = [("info_hash", urlEncodeHash ((B16.encode . infoHash) d)),
-           ("peer_id", urlEncode peer_id),
-           ("port", "6881"),
-           ("uploaded", "0"),
-           ("downloaded", "0"),
-           ("left", show len),
-           ("compact", "1"),
-           ("event", "started")]
-  in intercalate "&" [f ++ "=" ++ s | (f,s) <- p]
-
-connect :: Url -> String -> IO ByteString
-connect baseurl qstr = simpleHTTP (defaultGETRequest_ url) >>= getResponseBody
-    where url = fromJust . parseURI $ (baseurl ++ "?" ++ qstr)
+-- | Make arguments that should be posted to tracker.
+-- This is a separate pure function for testability.
+mkArgs :: String -> Metainfo -> [(String, ByteString)]
+mkArgs peer_id m = [("info_hash", pack . urlEncodeHash . B16.encode . infoHash $ m),
+                    ("peer_id", pack . urlEncode $ peer_id),
+                    ("port", "6881"),
+                    ("uploaded", "0"),
+                    ("downloaded", "0"),
+                    ("left", pack . show . lengthInBytes $ info m),
+                    ("compact", "1"),
+                    ("event", "started")]
+
+