Merge branch 'tidy' into dev

8 files changed, 955 insertions, 1685 deletions

diff --git a/src/Data/Torrent.hs b/src/Data/Torrent.hs
index b233937b..cfc26453 100644
--- a/src/Data/Torrent.hs
+++ b/src/Data/Torrent.hs
@@ -17,23 +17,91 @@
 --   <https://wiki.theory.org/BitTorrentSpecification#Metainfo_File_Structure>
 --
 {-# LANGUAGE CPP                        #-}
+{-# LANGUAGE NamedFieldPuns             #-}
 {-# LANGUAGE FlexibleInstances          #-}
 {-# LANGUAGE OverlappingInstances       #-}
+{-# LANGUAGE MultiParamTypeClasses      #-}
 {-# LANGUAGE BangPatterns               #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE StandaloneDeriving         #-}
 {-# LANGUAGE DeriveDataTypeable         #-}
+{-# LANGUAGE DeriveFunctor              #-}
+{-# LANGUAGE DeriveFoldable             #-}
+{-# LANGUAGE DeriveTraversable          #-}
 {-# LANGUAGE TemplateHaskell            #-}
 {-# OPTIONS -fno-warn-orphans           #-}
 module Data.Torrent
-       ( -- * Info dictionary
-         InfoDict (..)
-       , infoDictionary
+       ( -- * InfoHash
+         -- $infohash
+         InfoHash
+       , textToInfoHash
+       , longHex
+       , shortHex
 
-         -- ** Lenses
+         -- * File layout
+         -- ** FileInfo
+       , FileOffset
+       , FileSize
+       , FileInfo (..)
+       , fileLength
+       , filePath
+       , fileMD5Sum
+
+         -- ** Layout info
+       , LayoutInfo (..)
+       , singleFile
+       , multiFile
+       , rootDirName
+       , joinFilePath
+       , isSingleFile
+       , isMultiFile
+       , suggestedName
+       , contentLength
+       , fileCount
+       , blockCount
+
+         -- ** Flat layout info
+       , FileLayout
+       , flatLayout
+       , accumPositions
+       , fileOffset
+
+         -- ** Internal
+       , sizeInBase
+
+         -- * Pieces
+         -- ** Attributes
+       , PieceIx
+       , PieceCount
+       , PieceSize
+       , minPieceSize
+       , maxPieceSize
+       , defaultPieceSize
+       , PieceHash
+
+         -- ** Piece data
+       , Piece (..)
+       , pieceSize
+       , hashPiece
+
+         -- ** Piece control
+       , HashList (..)
+       , PieceInfo (..)
+       , pieceLength
+       , pieceHashes
+       , pieceCount
+
+         -- ** Validation
+       , pieceHash
+       , checkPieceLazy
+
+         -- * Info dictionary
+       , InfoDict (..)
        , infohash
        , layoutInfo
        , pieceInfo
        , isPrivate
+       , infoDictionary
 
          -- * Torrent file
        , Torrent(..)
@@ -50,50 +118,598 @@ module Data.Torrent
        , publisherURL
        , signature
 
-         -- * Construction
+         -- ** Utils
        , nullTorrent
-
-         -- * Mime types
        , typeTorrent
-
-         -- * File paths
        , torrentExt
        , isTorrentPath
-
-         -- * IO
        , fromFile
        , toFile
+
+         -- * Magnet
+         -- $magnet-link
+       , Magnet(..)
+       , nullMagnet
+       , simpleMagnet
+       , detailedMagnet
+       , parseMagnet
+       , renderMagnet
+
+         -- ** URN
+       , URN (..)
+       , NamespaceId
+       , btih
+       , infohashURN
+       , parseURN
+       , renderURN
        ) where
 
-import Prelude hiding (sum)
+import Prelude
 import Control.Applicative
-import qualified Crypto.Hash.SHA1 as C
 import Control.DeepSeq
 import Control.Exception
 import Control.Lens
+import Control.Monad
+import Crypto.Hash.SHA1 as SHA1
 import Data.BEncode as BE
 import Data.BEncode.Types as BE
-import           Data.ByteString as BS
-import qualified Data.ByteString.Char8 as BC (pack, unpack)
-import qualified Data.ByteString.Lazy  as BL
-import           Data.Convertible
-import           Data.Default
-import           Data.Hashable   as Hashable
-import qualified Data.List as L
-import           Data.Text as T
-import Data.Time
+import Data.Bits
+import Data.Bits.Extras
+import Data.ByteString as BS
+import Data.ByteString.Base16 as Base16
+import Data.ByteString.Base32 as Base32
+import Data.ByteString.Base64 as Base64
+import Data.ByteString.Char8 as BC (pack, unpack)
+import Data.ByteString.Lazy  as BL
+import Data.Char
+import Data.Convertible
+import Data.Default
+import Data.Foldable as F
+import Data.Hashable   as Hashable
+import Data.Int
+import Data.List as L
+import Data.Map as M
+import Data.Maybe
+import Data.Serialize as S
+import Data.String
+import Data.Text as T
+import Data.Text.Encoding as T
+import Data.Text.Read
 import Data.Time.Clock.POSIX
 import Data.Typeable
 import Network (HostName)
+import Network.HTTP.Types.QueryLike
+import Network.HTTP.Types.URI
 import Network.URI
+import Text.ParserCombinators.ReadP as P
 import Text.PrettyPrint as PP
 import Text.PrettyPrint.Class
 import System.FilePath
+import System.Posix.Types
+
+import Network.BitTorrent.Address
+
+
+{-----------------------------------------------------------------------
+--  Info hash
+-----------------------------------------------------------------------}
+-- TODO
+--
+-- data Word160 = Word160 {-# UNPACK #-} !Word64
+--                        {-# UNPACK #-} !Word64
+--                        {-# UNPACK #-} !Word32
+--
+-- newtype InfoHash = InfoHash Word160
+--
+-- reason: bytestring have overhead = 8 words, while infohash have length 20 bytes
+
+-- $infohash
+--
+-- Infohash is a unique identifier of torrent.
+
+-- | Exactly 20 bytes long SHA1 hash of the info part of torrent file.
+newtype InfoHash = InfoHash { getInfoHash :: BS.ByteString }
+  deriving (Eq, Ord, Typeable)
+
+infoHashLen :: Int
+infoHashLen = 20
+
+-- | Meaningless placeholder value.
+instance Default InfoHash where
+  def = "0123456789012345678901234567890123456789"
+
+-- | Hash raw bytes. (no encoding)
+instance Hashable InfoHash where
+  hashWithSalt s (InfoHash ih) = hashWithSalt s ih
+  {-# INLINE hashWithSalt #-}
+
+-- | Convert to\/from raw bencoded string. (no encoding)
+instance BEncode InfoHash where
+  toBEncode = toBEncode . getInfoHash
+  fromBEncode be = InfoHash <$> fromBEncode be
+
+-- | Convert to\/from raw bytestring. (no encoding)
+instance Serialize InfoHash where
+  put (InfoHash ih) = putByteString ih
+  {-# INLINE put #-}
+
+  get = InfoHash <$> getBytes infoHashLen
+  {-# INLINE get #-}
+
+-- | Convert to raw query value. (no encoding)
+instance QueryValueLike InfoHash where
+  toQueryValue (InfoHash ih) = Just ih
+  {-# INLINE toQueryValue #-}
+
+-- | Convert to base16 encoded string.
+instance Show InfoHash where
+  show (InfoHash ih) = BC.unpack (Base16.encode ih)
+
+-- | Convert to base16 encoded Doc string.
+instance Pretty InfoHash where
+  pretty = text . show
+
+-- | Read base16 encoded string.
+instance Read InfoHash where
+  readsPrec _ = readP_to_S $ do
+      str <- replicateM (infoHashLen * 2) (satisfy isHexDigit)
+      return $ InfoHash $ decodeIH str
+    where
+      decodeIH       = BS.pack . L.map fromHex . pair
+      fromHex (a, b) = read $ '0' : 'x' : a : b : []
+
+      pair (a : b : xs) = (a, b) : pair xs
+      pair _            = []
+
+-- | Convert raw bytes to info hash.
+instance Convertible BS.ByteString InfoHash where
+  safeConvert bs
+    | BS.length bs == infoHashLen = pure (InfoHash bs)
+    |          otherwise          = convError "invalid length" bs
+
+-- | Parse infohash from base16\/base32\/base64 encoded string.
+instance Convertible Text InfoHash where
+  safeConvert t
+      | 20 == hashLen = pure (InfoHash hashStr)
+      | 26 <= hashLen && hashLen <= 28 =
+        case Base64.decode hashStr of
+          Left  msg   -> convError ("invalid base64 encoding " ++ msg) t
+          Right ihStr -> safeConvert ihStr
+
+      |      hashLen == 32   =
+        case Base32.decode hashStr of
+          Left  msg   -> convError msg t
+          Right ihStr -> safeConvert ihStr
+
+      |      hashLen == 40   =
+        let (ihStr, inv) = Base16.decode hashStr
+        in if BS.length inv /= 0
+           then convError "invalid base16 encoding" t
+           else safeConvert ihStr
+
+      |        otherwise     = convError "invalid length" t
+    where
+      hashLen = BS.length hashStr
+      hashStr = T.encodeUtf8 t
+
+-- | Decode from base16\/base32\/base64 encoded string.
+instance IsString InfoHash where
+  fromString = either (error . prettyConvertError) id . safeConvert . T.pack
+
+ignoreErrorMsg :: Either a b -> Maybe b
+ignoreErrorMsg = either (const Nothing) Just
+
+-- | Tries both base16 and base32 while decoding info hash.
+--
+--  Use 'safeConvert' for detailed error messages.
+--
+textToInfoHash :: Text -> Maybe InfoHash
+textToInfoHash = ignoreErrorMsg . safeConvert
 
-import Data.Torrent.InfoHash as IH
-import Data.Torrent.Layout
-import Data.Torrent.Piece
-import Network.BitTorrent.Core.NodeInfo
+-- | Hex encode infohash to text, full length.
+longHex :: InfoHash -> Text
+longHex = T.decodeUtf8 . Base16.encode . getInfoHash
+
+-- | The same as 'longHex', but only first 7 characters.
+shortHex :: InfoHash -> Text
+shortHex = T.take 7 . longHex
+
+{-----------------------------------------------------------------------
+--  File info
+-----------------------------------------------------------------------}
+
+-- | Size of a file in bytes.
+type FileSize = FileOffset
+
+deriving instance BEncode  FileOffset
+
+-- | Contain metainfo about one single file.
+data FileInfo a = FileInfo {
+      fiLength      :: {-# UNPACK #-} !FileSize
+      -- ^ Length of the file in bytes.
+
+      -- TODO unpacked MD5 sum
+    , fiMD5Sum      :: !(Maybe BS.ByteString)
+      -- ^ 32 character long MD5 sum of the file.  Used by third-party
+      -- tools, not by bittorrent protocol itself.
+
+    , fiName        :: !a
+      -- ^ One or more string elements that together represent the
+      -- path and filename. Each element in the list corresponds to
+      -- either a directory name or (in the case of the last element)
+      -- the filename.  For example, the file:
+      --
+      --   > "dir1/dir2/file.ext"
+      --
+      --   would consist of three string elements:
+      --
+      --   > ["dir1", "dir2", "file.ext"]
+      --
+    } deriving (Show, Read, Eq, Typeable
+               , Functor, Foldable
+               )
+
+makeLensesFor
+  [ ("fiLength", "fileLength")
+  , ("fiMD5Sum", "fileMD5Sum")
+  , ("fiName"  , "filePath"  )
+  ]
+  ''FileInfo
+
+instance NFData a => NFData (FileInfo a) where
+  rnf FileInfo {..} = rnf fiName
+  {-# INLINE rnf #-}
+
+instance BEncode (FileInfo [BS.ByteString]) where
+  toBEncode FileInfo {..} = toDict $
+       "length" .=! fiLength
+    .: "md5sum" .=? fiMD5Sum
+    .: "path"   .=! fiName
+    .: endDict
+  {-# INLINE toBEncode #-}
+
+  fromBEncode = fromDict $ do
+    FileInfo <$>! "length"
+             <*>? "md5sum"
+             <*>! "path"
+  {-# INLINE fromBEncode #-}
+
+type Put a = a -> BDict -> BDict
+
+putFileInfoSingle :: Data.Torrent.Put (FileInfo BS.ByteString)
+putFileInfoSingle FileInfo {..} cont =
+       "length" .=! fiLength
+    .: "md5sum" .=? fiMD5Sum
+    .: "name"   .=! fiName
+    .: cont
+
+getFileInfoSingle :: BE.Get (FileInfo BS.ByteString)
+getFileInfoSingle = do
+    FileInfo <$>! "length"
+             <*>? "md5sum"
+             <*>! "name"
+
+instance BEncode (FileInfo BS.ByteString) where
+  toBEncode = toDict . (`putFileInfoSingle` endDict)
+  {-# INLINE toBEncode #-}
+
+  fromBEncode = fromDict getFileInfoSingle
+  {-# INLINE fromBEncode #-}
+
+instance Pretty (FileInfo BS.ByteString) where
+  pretty FileInfo {..} =
+       "Path: " <> text (T.unpack (T.decodeUtf8 fiName))
+    $$ "Size: " <> text (show fiLength)
+    $$ maybe PP.empty ppMD5 fiMD5Sum
+   where
+    ppMD5 md5 = "MD5 : " <> text (show (Base16.encode md5))
+
+-- | Join file path.
+joinFilePath :: FileInfo [BS.ByteString] -> FileInfo BS.ByteString
+joinFilePath = fmap (BS.intercalate "/")
+
+{-----------------------------------------------------------------------
+--  Layout info
+-----------------------------------------------------------------------}
+
+-- | Original (found in torrent file) layout info is either:
+--
+--     * Single file with its /name/.
+--
+--     * Multiple files with its relative file /paths/.
+--
+data LayoutInfo
+  = SingleFile
+    { -- | Single file info.
+      liFile     :: !(FileInfo BS.ByteString)
+    }
+  | MultiFile
+    { -- | List of the all files that torrent contains.
+      liFiles    :: ![FileInfo [BS.ByteString]]
+
+      -- | The /suggested/ name of the root directory in which to
+      -- store all the files.
+    , liDirName  :: !BS.ByteString
+    } deriving (Show, Read, Eq, Typeable)
+
+makeLensesFor
+  [ ("liFile"   , "singleFile" )
+  , ("liFiles"  , "multiFile"  )
+  , ("liDirName", "rootDirName")
+  ]
+  ''LayoutInfo
+
+instance NFData LayoutInfo where
+  rnf SingleFile {..} = ()
+  rnf MultiFile  {..} = rnf liFiles
+
+-- | Empty multifile layout.
+instance Default LayoutInfo where
+  def = MultiFile [] ""
+
+getLayoutInfo :: BE.Get LayoutInfo
+getLayoutInfo = single <|> multi
+  where
+    single = SingleFile <$>  getFileInfoSingle
+    multi  = MultiFile  <$>! "files" <*>! "name"
+
+putLayoutInfo :: Data.Torrent.Put LayoutInfo
+putLayoutInfo SingleFile {..} = putFileInfoSingle liFile
+putLayoutInfo MultiFile  {..} = \ cont ->
+     "files" .=! liFiles
+  .: "name"  .=! liDirName
+  .: cont
+
+instance BEncode LayoutInfo where
+  toBEncode   = toDict . (`putLayoutInfo` endDict)
+  fromBEncode = fromDict getLayoutInfo
+
+instance Pretty LayoutInfo where
+  pretty SingleFile {..} = pretty liFile
+  pretty MultiFile  {..} = vcat $ L.map (pretty . joinFilePath) liFiles
+
+-- | Test if this is single file torrent.
+isSingleFile :: LayoutInfo -> Bool
+isSingleFile SingleFile {} = True
+isSingleFile _             = False
+{-# INLINE isSingleFile #-}
+
+-- | Test if this is multifile torrent.
+isMultiFile :: LayoutInfo -> Bool
+isMultiFile MultiFile {} = True
+isMultiFile _            = False
+{-# INLINE isMultiFile #-}
+
+-- | Get name of the torrent based on the root path piece.
+suggestedName :: LayoutInfo -> BS.ByteString
+suggestedName (SingleFile FileInfo {..}) = fiName
+suggestedName  MultiFile           {..}  = liDirName
+{-# INLINE suggestedName #-}
+
+-- | Find sum of sizes of the all torrent files.
+contentLength :: LayoutInfo -> FileSize
+contentLength SingleFile { liFile  = FileInfo {..} } = fiLength
+contentLength MultiFile  { liFiles = tfs           } = L.sum (L.map fiLength tfs)
+
+-- | Get number of all files in torrent.
+fileCount :: LayoutInfo -> Int
+fileCount SingleFile {..} = 1
+fileCount MultiFile  {..} = L.length liFiles
+
+-- | Find number of blocks of the specified size. If torrent size is
+-- not a multiple of block size then the count is rounded up.
+blockCount :: Int -> LayoutInfo -> Int
+blockCount blkSize ci = contentLength ci `sizeInBase` blkSize
+
+------------------------------------------------------------------------
+
+-- | File layout specifies the order and the size of each file in the
+--   storage. Note that order of files is highly important since we
+--   coalesce all the files in the given order to get the linear block
+--   address space.
+--
+type FileLayout a = [(FilePath, a)]
+
+-- | Extract files layout from torrent info with the given root path.
+flatLayout
+  :: FilePath            -- ^ Root path for the all torrent files.
+  -> LayoutInfo          -- ^ Torrent content information.
+  -> FileLayout FileSize -- ^ The all file paths prefixed with the given root.
+flatLayout prefixPath SingleFile { liFile = FileInfo {..} }
+    = [(prefixPath </> BC.unpack fiName, fiLength)]
+flatLayout prefixPath MultiFile  {..}     = L.map mkPath liFiles
+  where   -- TODO use utf8 encoding in name
+    mkPath FileInfo {..} = (_path, fiLength)
+      where
+        _path = prefixPath </> BC.unpack liDirName
+           </> joinPath (L.map BC.unpack fiName)
+
+-- | Calculate offset of each file based on its length, incrementally.
+accumPositions :: FileLayout FileSize -> FileLayout (FileOffset, FileSize)
+accumPositions = go 0
+  where
+    go !_ [] = []
+    go !offset ((n, s) : xs) = (n, (offset, s)) : go (offset + s) xs
+
+-- | Gives global offset of a content file for a given full path.
+fileOffset :: FilePath -> FileLayout FileOffset -> Maybe FileOffset
+fileOffset = L.lookup
+{-# INLINE fileOffset #-}
+
+------------------------------------------------------------------------
+
+-- | Divide and round up.
+sizeInBase :: Integral a => a -> Int -> Int
+sizeInBase n b = fromIntegral (n `div` fromIntegral b) + align
+  where
+    align = if n `mod` fromIntegral b == 0 then 0 else 1
+{-# SPECIALIZE sizeInBase :: Int -> Int -> Int #-}
+{-# SPECIALIZE sizeInBase :: Integer -> Int -> Int #-}
+
+{-----------------------------------------------------------------------
+-- Piece attributes
+-----------------------------------------------------------------------}
+
+-- | Zero-based index of piece in torrent content.
+type PieceIx   = Int
+
+-- | Size of piece in bytes. Should be a power of 2.
+--
+--   NOTE: Have max and min size constrained to wide used
+--   semi-standard values. This bounds should be used to make decision
+--   about piece size for new torrents.
+--
+type PieceSize = Int
+
+-- | Number of pieces in torrent or a part of torrent.
+type PieceCount = Int
+
+defaultBlockSize :: Int
+defaultBlockSize = 16 * 1024
+
+-- | Optimal number of pieces in torrent.
+optimalPieceCount :: PieceCount
+optimalPieceCount = 1000
+{-# INLINE optimalPieceCount #-}
+
+-- | Piece size should not be less than this value.
+minPieceSize :: Int
+minPieceSize = defaultBlockSize * 4
+{-# INLINE minPieceSize #-}
+
+-- | To prevent transfer degradation piece size should not exceed this
+-- value.
+maxPieceSize :: Int
+maxPieceSize = 4 * 1024 * 1024
+{-# INLINE maxPieceSize #-}
+
+toPow2 :: Int -> Int
+toPow2 x = bit $ fromIntegral (leadingZeros (0 :: Int) - leadingZeros x)
+
+-- | Find the optimal piece size for a given torrent size.
+defaultPieceSize :: Int64 -> Int
+defaultPieceSize x = max minPieceSize $ min maxPieceSize $ toPow2 pc
+  where
+    pc = fromIntegral (x `div` fromIntegral optimalPieceCount)
+
+{-----------------------------------------------------------------------
+-- Piece data
+-----------------------------------------------------------------------}
+
+type PieceHash = BS.ByteString
+
+hashsize :: Int
+hashsize = 20
+{-# INLINE hashsize #-}
+
+-- TODO check if pieceLength is power of 2
+-- | Piece payload should be strict or lazy bytestring.
+data Piece a = Piece
+  { -- | Zero-based piece index in torrent.
+    pieceIndex :: {-# UNPACK #-} !PieceIx
+
+    -- | Payload.
+  , pieceData  :: !a
+  } deriving (Show, Read, Eq, Functor, Typeable)
+
+instance NFData (Piece a)
+
+-- | Payload bytes are omitted.
+instance Pretty (Piece a) where
+  pretty Piece {..} = "Piece" <+> braces ("index" <+> "=" <+> int pieceIndex)
+
+-- | Get size of piece in bytes.
+pieceSize :: Piece BL.ByteString -> PieceSize
+pieceSize Piece {..} = fromIntegral (BL.length pieceData)
+
+-- | Get piece hash.
+hashPiece :: Piece BL.ByteString -> PieceHash
+hashPiece Piece {..} = SHA1.hashlazy pieceData
+
+{-----------------------------------------------------------------------
+-- Piece control
+-----------------------------------------------------------------------}
+
+-- | A flat array of SHA1 hash for each piece.
+newtype HashList = HashList { unHashList :: BS.ByteString }
+  deriving (Show, Read, Eq, BEncode, Typeable)
+
+-- | Empty hash list.
+instance Default HashList where
+  def = HashList ""
+
+-- | Part of torrent file used for torrent content validation.
+data PieceInfo = PieceInfo
+  { piPieceLength  :: {-# UNPACK #-} !PieceSize
+    -- ^ Number of bytes in each piece.
+
+  , piPieceHashes  :: !HashList
+    -- ^ Concatenation of all 20-byte SHA1 hash values.
+  } deriving (Show, Read, Eq, Typeable)
+
+-- | Number of bytes in each piece.
+makeLensesFor [("piPieceLength", "pieceLength")] ''PieceInfo
+
+-- | Concatenation of all 20-byte SHA1 hash values.
+makeLensesFor [("piPieceHashes", "pieceHashes")] ''PieceInfo
+
+instance NFData PieceInfo
+
+instance Default PieceInfo where
+  def = PieceInfo 1 def
+
+class Lint a where
+   lint :: a -> Either String a
+
+instance Lint PieceInfo where
+  lint pinfo @ PieceInfo {..}
+    | BS.length (unHashList piPieceHashes) `rem` hashsize == 0
+    , piPieceLength >= 0 = return pinfo
+    |       otherwise    = Left undefined
+
+
+putPieceInfo :: Data.Torrent.Put PieceInfo
+putPieceInfo PieceInfo {..} cont =
+       "piece length" .=! piPieceLength
+    .: "pieces"       .=! piPieceHashes
+    .: cont
+
+getPieceInfo :: BE.Get PieceInfo
+getPieceInfo = do
+    PieceInfo <$>! "piece length"
+              <*>! "pieces"
+
+instance BEncode PieceInfo where
+  toBEncode   = toDict . (`putPieceInfo` endDict)
+  fromBEncode = fromDict getPieceInfo
+
+-- | Hashes are omitted.
+instance Pretty PieceInfo where
+  pretty  PieceInfo {..} = "Piece size: " <> int piPieceLength
+
+slice :: Int -> Int -> BS.ByteString -> BS.ByteString
+slice start len = BS.take len . BS.drop start
+{-# INLINE slice #-}
+
+-- | Extract validation hash by specified piece index.
+pieceHash :: PieceInfo -> PieceIx -> PieceHash
+pieceHash PieceInfo {..} i = slice (hashsize * i) hashsize (unHashList piPieceHashes)
+
+-- | Find count of pieces in the torrent. If torrent size is not a
+-- multiple of piece size then the count is rounded up.
+pieceCount :: PieceInfo -> PieceCount
+pieceCount PieceInfo {..} = BS.length (unHashList piPieceHashes) `quot` hashsize
+
+-- | Test if this is last piece in torrent content.
+isLastPiece :: PieceInfo -> PieceIx -> Bool
+isLastPiece ci i = pieceCount ci == succ i
+
+-- | Validate piece with metainfo hash.
+checkPieceLazy :: PieceInfo -> Piece BL.ByteString -> Bool
+checkPieceLazy pinfo @ PieceInfo {..} Piece {..}
+  = (fromIntegral (BL.length pieceData) == piPieceLength
+     || isLastPiece pinfo pieceIndex)
+  && SHA1.hashlazy pieceData == pieceHash pinfo pieceIndex
 
 {-----------------------------------------------------------------------
 --  Info dictionary
@@ -145,9 +761,9 @@ instance Default InfoDict where
 infoDictionary :: LayoutInfo -> PieceInfo -> Bool -> InfoDict
 infoDictionary li pinfo private = InfoDict ih li pinfo private
   where
-    ih = hashLazyIH $ encode $ InfoDict def li pinfo private
+    ih = hashLazyIH $ BE.encode $ InfoDict def li pinfo private
 
-getPrivate :: Get Bool
+getPrivate :: BE.Get Bool
 getPrivate = (Just True ==) <$>? "private"
 
 putPrivate :: Bool -> BDict -> BDict
@@ -156,7 +772,7 @@ putPrivate True  = \ cont -> "private" .=! True .: cont
 
 -- | Hash lazy bytestring using SHA1 algorithm.
 hashLazyIH :: BL.ByteString -> InfoHash
-hashLazyIH = either (const (error msg)) id . safeConvert . C.hashlazy
+hashLazyIH = either (const (error msg)) id . safeConvert . SHA1.hashlazy
   where
     msg = "Infohash.hash: impossible: SHA1 is always 20 bytes long"
 
@@ -172,7 +788,7 @@ instance BEncode InfoDict where
                   <*> getPieceInfo
                   <*> getPrivate
     where
-      ih = hashLazyIH (encode dict)
+      ih = hashLazyIH (BE.encode dict)
 
 ppPrivacy :: Bool -> Doc
 ppPrivacy privacy = "Privacy: " <> if privacy then "private" else "public"
@@ -189,6 +805,7 @@ instance Pretty InfoDict where
 {-----------------------------------------------------------------------
 --  Torrent info
 -----------------------------------------------------------------------}
+-- TODO add torrent file validation
 
 -- | Metainfo about particular torrent.
 data Torrent = Torrent
@@ -219,7 +836,7 @@ data Torrent = Torrent
   , tNodes        :: !(Maybe [NodeAddr HostName])
     -- ^ This key should be set to the /K closest/ nodes in the
     -- torrent generating client's routing table. Alternatively, the
-    -- key could be set to a known good 'Network.BitTorrent.Core.Node'
+    -- key could be set to a known good 'Network.BitTorrent.Address.Node'
     -- such as one operated by the person generating the torrent.
     --
     -- Please do not automatically add \"router.bittorrent.com\" to
@@ -232,7 +849,7 @@ data Torrent = Torrent
     -- authority to allow new peers onto the swarm.
 
   , tPublisherURL :: !(Maybe URI)
-  , tSignature    :: !(Maybe ByteString)
+  , tSignature    :: !(Maybe BS.ByteString)
     -- ^ The RSA signature of the info dictionary (specifically, the
     --   encrypted SHA-1 hash of the info dictionary).
     } deriving (Show, Eq, Typeable)
@@ -361,10 +978,314 @@ isTorrentPath filepath = takeExtension filepath == extSeparator : torrentExt
 fromFile :: FilePath -> IO Torrent
 fromFile filepath = do
   contents <- BS.readFile filepath
-  case decode contents of
+  case BE.decode contents of
     Right !t -> return t
     Left msg -> throwIO $ userError $ msg ++ " while reading torrent file"
 
 -- | Encode and write a .torrent file.
 toFile :: FilePath -> Torrent -> IO ()
-toFile filepath = BL.writeFile filepath . encode
+toFile filepath = BL.writeFile filepath . BE.encode
+
+{-----------------------------------------------------------------------
+--  URN
+-----------------------------------------------------------------------}
+
+-- | Namespace identifier determines the syntactic interpretation of
+-- namespace-specific string.
+type NamespaceId = [Text]
+
+-- | BitTorrent Info Hash (hence the name) namespace
+-- identifier. Namespace-specific string /should/ be a base16\/base32
+-- encoded SHA1 hash of the corresponding torrent /info/ dictionary.
+--
+btih :: NamespaceId
+btih  = ["btih"]
+
+-- | URN is pesistent location-independent identifier for
+--   resources. In particular, URNs are used represent torrent names
+--   as a part of magnet link, see 'Data.Torrent.Magnet.Magnet' for
+--   more info.
+--
+data URN = URN
+  { urnNamespace :: NamespaceId -- ^ a namespace identifier;
+  , urnString    :: Text        -- ^ a corresponding
+                                -- namespace-specific string.
+  } deriving (Eq, Ord, Typeable)
+
+-----------------------------------------------------------------------
+
+instance Convertible URN InfoHash where
+  safeConvert u @ URN {..}
+    | urnNamespace /= btih = convError "invalid namespace" u
+    |       otherwise      = safeConvert urnString
+
+-- | Make resource name for torrent with corresponding
+-- infohash. Infohash is base16 (hex) encoded.
+--
+infohashURN :: InfoHash -> URN
+infohashURN = URN btih . longHex
+
+-- | Meaningless placeholder value.
+instance Default URN where
+  def = infohashURN def
+
+------------------------------------------------------------------------
+
+-- | Render URN to its text representation.
+renderURN :: URN -> Text
+renderURN URN {..}
+  = T.intercalate ":" $ "urn" : urnNamespace ++ [urnString]
+
+instance Pretty URN where
+  pretty = text . T.unpack . renderURN
+
+instance Show URN where
+  showsPrec n = showsPrec n . T.unpack . renderURN
+
+instance QueryValueLike URN where
+  toQueryValue = toQueryValue . renderURN
+  {-# INLINE toQueryValue #-}
+
+-----------------------------------------------------------------------
+
+_unsnoc :: [a] -> Maybe ([a], a)
+_unsnoc [] = Nothing
+_unsnoc xs = Just (L.init xs, L.last xs)
+
+instance Convertible Text URN where
+  safeConvert t = case T.split (== ':') t of
+    uriScheme : body
+      | T.toLower uriScheme == "urn" ->
+        case _unsnoc body of
+          Just (namespace, val) -> pure URN
+            { urnNamespace = namespace
+            , urnString    = val
+            }
+          Nothing -> convError "missing URN string" body
+      | otherwise -> convError "invalid URN scheme" uriScheme
+    []            -> convError "missing URN scheme" t
+
+instance IsString URN where
+  fromString = either (error . prettyConvertError) id
+             . safeConvert . T.pack
+
+-- | Try to parse an URN from its text representation.
+--
+--  Use 'safeConvert' for detailed error messages.
+--
+parseURN :: Text -> Maybe URN
+parseURN = either (const Nothing) pure . safeConvert
+
+{-----------------------------------------------------------------------
+--  Magnet
+-----------------------------------------------------------------------}
+-- $magnet-link
+--
+--   Magnet URI scheme is an standard defining Magnet links. Magnet
+--   links are refer to resources by hash, in particular magnet links
+--   can refer to torrent using corresponding infohash. In this way,
+--   magnet links can be used instead of torrent files.
+--
+--   This module provides bittorrent specific implementation of magnet
+--   links.
+--
+--   For generic magnet uri scheme see:
+--   <http://magnet-uri.sourceforge.net/magnet-draft-overview.txt>,
+--   <http://www.iana.org/assignments/uri-schemes/prov/magnet>
+--
+--   Bittorrent specific details:
+--   <http://www.bittorrent.org/beps/bep_0009.html>
+--
+
+-- TODO multiple exact topics
+-- TODO render/parse supplement for URI/query
+
+-- | An URI used to identify torrent.
+data Magnet = Magnet
+  { -- | Torrent infohash hash. Can be used in DHT queries if no
+    -- 'tracker' provided.
+    exactTopic  :: !InfoHash -- TODO InfoHash -> URN?
+
+    -- | A filename for the file to download. Can be used to
+    -- display name while waiting for metadata.
+  , displayName :: Maybe Text
+
+    -- | Size of the resource in bytes.
+  , exactLength :: Maybe Integer
+
+    -- | URI pointing to manifest, e.g. a list of further items.
+  , manifest :: Maybe Text
+
+    -- | Search string.
+  , keywordTopic :: Maybe Text
+
+    -- | A source to be queried after not being able to find and
+    -- download the file in the bittorrent network in a defined
+    -- amount of time.
+  , acceptableSource :: Maybe URI
+
+    -- | Direct link to the resource.
+  , exactSource      :: Maybe URI
+
+    -- | URI to the tracker.
+  , tracker :: Maybe URI
+
+    -- | Additional or experimental parameters.
+  , supplement :: Map Text Text
+  } deriving (Eq, Ord, Typeable)
+
+instance QueryValueLike Integer where
+  toQueryValue = toQueryValue . show
+
+instance QueryValueLike URI where
+  toQueryValue = toQueryValue . show
+
+instance QueryLike Magnet where
+  toQuery Magnet {..} =
+    [ ("xt", toQueryValue $ infohashURN exactTopic)
+    , ("dn", toQueryValue displayName)
+    , ("xl", toQueryValue exactLength)
+    , ("mt", toQueryValue manifest)
+    , ("kt", toQueryValue keywordTopic)
+    , ("as", toQueryValue acceptableSource)
+    , ("xs", toQueryValue exactSource)
+    , ("tr", toQueryValue tracker)
+    ]
+
+instance QueryValueLike Magnet where
+  toQueryValue = toQueryValue . renderMagnet
+
+instance Convertible QueryText Magnet where
+  safeConvert xs = do
+      urnStr   <- getTextMsg "xt" "exact topic not defined" xs
+      infoHash <- convertVia (error "safeConvert" :: URN)  urnStr
+      return Magnet
+        { exactTopic       = infoHash
+        , displayName      = getText "dn" xs
+        , exactLength      = getText "xl" xs >>= getInt
+        , manifest         = getText "mt" xs
+        , keywordTopic     = getText "kt" xs
+        , acceptableSource = getText "as" xs >>= getURI
+        , exactSource      = getText "xs" xs >>= getURI
+        , tracker          = getText "tr" xs >>= getURI
+        , supplement       = M.empty
+        }
+    where
+      getInt    = either (const Nothing) (Just . fst) . signed decimal
+      getURI    = parseURI . T.unpack
+      getText p = join . L.lookup p
+      getTextMsg p msg ps = maybe (convError msg xs) pure $ getText p ps
+
+magnetScheme :: URI
+magnetScheme = URI
+    { uriScheme    = "magnet:"
+    , uriAuthority = Nothing
+    , uriPath      = ""
+    , uriQuery     = ""
+    , uriFragment  = ""
+    }
+
+isMagnetURI :: URI -> Bool
+isMagnetURI u = u { uriQuery = "" } == magnetScheme
+
+-- | Can be used instead of 'parseMagnet'.
+instance Convertible URI Magnet where
+  safeConvert u @ URI {..}
+    | not (isMagnetURI u) = convError "this is not a magnet link" u
+    |      otherwise      = safeConvert $ parseQueryText $ BC.pack uriQuery
+
+-- | Can be used instead of 'renderMagnet'.
+instance Convertible Magnet URI where
+  safeConvert m = pure $ magnetScheme
+    { uriQuery = BC.unpack $ renderQuery True $ toQuery m }
+
+instance Convertible String Magnet where
+  safeConvert str
+    | Just uri <- parseURI str = safeConvert uri
+    |        otherwise         = convError "unable to parse uri" str
+
+------------------------------------------------------------------------
+
+-- | Meaningless placeholder value.
+instance Default Magnet where
+  def = Magnet
+    { exactTopic       = def
+    , displayName      = Nothing
+    , exactLength      = Nothing
+    , manifest         = Nothing
+    , keywordTopic     = Nothing
+    , acceptableSource = Nothing
+    , exactSource      = Nothing
+    , tracker          = Nothing
+    , supplement       = M.empty
+    }
+
+-- | Set 'exactTopic' ('xt' param) only, other params are empty.
+nullMagnet :: InfoHash -> Magnet
+nullMagnet u = Magnet
+    { exactTopic   = u
+    , displayName  = Nothing
+    , exactLength  = Nothing
+    , manifest     = Nothing
+    , keywordTopic = Nothing
+    , acceptableSource = Nothing
+    , exactSource      = Nothing
+    , tracker    = Nothing
+    , supplement = M.empty
+    }
+
+-- | Like 'nullMagnet' but also include 'displayName' ('dn' param).
+simpleMagnet :: Torrent -> Magnet
+simpleMagnet Torrent {tInfoDict = InfoDict {..}}
+  = (nullMagnet idInfoHash)
+    { displayName = Just $ T.decodeUtf8 $ suggestedName idLayoutInfo
+    }
+
+-- | Like 'simpleMagnet' but also include 'exactLength' ('xl' param) and
+-- 'tracker' ('tr' param).
+--
+detailedMagnet :: Torrent -> Magnet
+detailedMagnet t @ Torrent {tInfoDict = InfoDict {..}, tAnnounce}
+  = (simpleMagnet t)
+    { exactLength = Just $ fromIntegral $ contentLength idLayoutInfo
+    , tracker     = tAnnounce
+    }
+
+-----------------------------------------------------------------------
+
+parseMagnetStr :: String -> Maybe Magnet
+parseMagnetStr = either (const Nothing) Just . safeConvert
+
+renderMagnetStr :: Magnet -> String
+renderMagnetStr = show . (convert :: Magnet -> URI)
+
+instance Pretty Magnet where
+  pretty = PP.text . renderMagnetStr
+
+instance Show Magnet where
+  show = renderMagnetStr
+  {-# INLINE show #-}
+
+instance Read Magnet where
+  readsPrec _ xs
+      | Just m <- parseMagnetStr mstr = [(m, rest)]
+      | otherwise = []
+    where
+      (mstr, rest) = L.break (== ' ') xs
+
+instance IsString Magnet where
+  fromString str = fromMaybe (error msg) $ parseMagnetStr str
+    where
+      msg = "unable to parse magnet: " ++ str
+
+-- | Try to parse magnet link from urlencoded string. Use
+-- 'safeConvert' to find out error location.
+--
+parseMagnet :: Text -> Maybe Magnet
+parseMagnet = parseMagnetStr . T.unpack
+{-# INLINE parseMagnet #-}
+
+-- | Render magnet link to urlencoded string
+renderMagnet :: Magnet -> Text
+renderMagnet = T.pack . renderMagnetStr
+{-# INLINE renderMagnet #-}
diff --git a/src/Data/Torrent/Bitfield.hs b/src/Data/Torrent/Bitfield.hs
deleted file mode 100644
index b65f058b..00000000
--- a/src/Data/Torrent/Bitfield.hs
+++ /dev/null
@@ -1,324 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   This modules provides all necessary machinery to work with
---   bitfields. Bitfields are used to keep track indices of complete
---   pieces either peer have or client have.
---
---   There are also commonly used piece seletion algorithms
---   which used to find out which one next piece to download.
---   Selectors considered to be used in the following order:
---
---     * Random first - at the start.
---
---     * Rarest first selection - performed to avoid situation when
---     rarest piece is unaccessible.
---
---     * /End game/ seletion - performed after a peer has requested all
---     the subpieces of the content.
---
---   Note that BitTorrent applies the strict priority policy for
---   /subpiece/ or /blocks/ selection.
---
-{-# LANGUAGE CPP #-}
-{-# LANGUAGE BangPatterns #-}
-{-# LANGUAGE RecordWildCards #-}
-module Data.Torrent.Bitfield
-       ( -- * Bitfield
-         PieceIx
-       , PieceCount
-       , Bitfield
-
-         -- * Construction
-       , haveAll
-       , haveNone
-       , have
-       , singleton
-       , interval
-       , adjustSize
-
-         -- * Query
-         -- ** Cardinality
-       , Data.Torrent.Bitfield.null
-       , Data.Torrent.Bitfield.full
-       , haveCount
-       , totalCount
-       , completeness
-
-         -- ** Membership
-       , member
-       , notMember
-       , findMin
-       , findMax
-       , isSubsetOf
-
-         -- ** Availability
-       , complement
-       , Frequency
-       , frequencies
-       , rarest
-
-         -- * Combine
-       , insert
-       , union
-       , intersection
-       , difference
-
-         -- * Conversion
-       , toList
-       , fromList
-
-         -- * Serialization
-       , fromBitmap
-       , toBitmap
-       ) where
-
-import Control.Monad
-import Control.Monad.ST
-import           Data.ByteString (ByteString)
-import qualified Data.ByteString as B
-import qualified Data.ByteString.Lazy as Lazy
-import           Data.Vector.Unboxed (Vector)
-import qualified Data.Vector.Unboxed as V
-import qualified Data.Vector.Unboxed.Mutable as VM
-import           Data.IntervalSet (IntSet)
-import qualified Data.IntervalSet as S
-import qualified Data.IntervalSet.ByteString as S
-import           Data.List (foldl')
-import           Data.Monoid
-import           Data.Ratio
-
-import Data.Torrent.Piece
-
--- TODO cache some operations
-
--- | Bitfields are represented just as integer sets but with
--- restriction: the each set should be within given interval (or
--- subset of the specified interval). Size is used to specify
--- interval, so bitfield of size 10 might contain only indices in
--- interval [0..9].
---
-data Bitfield = Bitfield {
-    bfSize :: !PieceCount
-  , bfSet  :: !IntSet
-  } deriving (Show, Read, Eq)
-
--- Invariants: all elements of bfSet lie in [0..bfSize - 1];
-
-instance Monoid Bitfield where
-  {-# SPECIALIZE instance Monoid Bitfield #-}
-  mempty  = haveNone 0
-  mappend = union
-  mconcat = unions
-
-{-----------------------------------------------------------------------
-    Construction
------------------------------------------------------------------------}
-
--- | The empty bitfield of the given size.
-haveNone :: PieceCount -> Bitfield
-haveNone s = Bitfield s S.empty
-
--- | The full bitfield containing all piece indices for the given size.
-haveAll :: PieceCount -> Bitfield
-haveAll s = Bitfield s (S.interval 0 (s - 1))
-
--- | Insert the index in the set ignoring out of range indices.
-have :: PieceIx -> Bitfield -> Bitfield
-have ix Bitfield {..}
-  | 0 <= ix && ix < bfSize = Bitfield bfSize (S.insert ix bfSet)
-  |      otherwise         = Bitfield bfSize bfSet
-
-singleton :: PieceIx -> PieceCount -> Bitfield
-singleton ix pc = have ix (haveNone pc)
-
--- | Assign new size to bitfield. FIXME Normally, size should be only
--- decreased, otherwise exception raised.
-adjustSize :: PieceCount -> Bitfield -> Bitfield
-adjustSize s Bitfield {..} = Bitfield s bfSet
-
--- | NOTE: for internal use only
-interval :: PieceCount -> PieceIx -> PieceIx -> Bitfield
-interval pc a b = Bitfield pc (S.interval a b)
-
-{-----------------------------------------------------------------------
-    Query
------------------------------------------------------------------------}
-
--- | Test if bitifield have no one index: peer do not have anything.
-null :: Bitfield -> Bool
-null Bitfield {..} = S.null bfSet
-
--- | Test if bitfield have all pieces.
-full :: Bitfield -> Bool
-full Bitfield {..} = S.size bfSet == bfSize
-
--- | Count of peer have pieces.
-haveCount :: Bitfield -> PieceCount
-haveCount = S.size . bfSet
-
--- | Total count of pieces and its indices.
-totalCount :: Bitfield -> PieceCount
-totalCount = bfSize
-
--- | Ratio of /have/ piece count to the /total/ piece count.
---
---   > forall bf. 0 <= completeness bf <= 1
---
-completeness :: Bitfield -> Ratio PieceCount
-completeness b = haveCount b % totalCount b
-
-inRange :: PieceIx -> Bitfield -> Bool
-inRange ix Bitfield {..} = 0 <= ix && ix < bfSize
-
-member :: PieceIx -> Bitfield -> Bool
-member ix bf @ Bitfield {..}
-  | ix `inRange` bf = ix `S.member` bfSet
-  |     otherwise   = False
-
-notMember :: PieceIx -> Bitfield -> Bool
-notMember ix bf @ Bitfield {..}
-  | ix `inRange` bf = ix `S.notMember` bfSet
-  |     otherwise   = True
-
--- | Find first available piece index.
-findMin :: Bitfield -> PieceIx
-findMin = S.findMin . bfSet
-{-# INLINE findMin #-}
-
--- | Find last available piece index.
-findMax :: Bitfield -> PieceIx
-findMax = S.findMax . bfSet
-{-# INLINE findMax #-}
-
--- | Check if all pieces from first bitfield present if the second bitfield
-isSubsetOf :: Bitfield -> Bitfield -> Bool
-isSubsetOf a b = bfSet a `S.isSubsetOf` bfSet b
-{-# INLINE isSubsetOf #-}
-
--- | Resulting bitfield includes only missing pieces.
-complement :: Bitfield -> Bitfield
-complement Bitfield {..} = Bitfield
-  { bfSet  = uni `S.difference` bfSet
-  , bfSize = bfSize
-  }
-  where
-    Bitfield _ uni = haveAll bfSize
-{-# INLINE complement #-}
-
-{-----------------------------------------------------------------------
--- Availability
------------------------------------------------------------------------}
-
--- | Frequencies are needed in piece selection startegies which use
--- availability quantity to find out the optimal next piece index to
--- download.
-type Frequency = Int
-
--- TODO rename to availability
--- | How many times each piece index occur in the given bitfield set.
-frequencies :: [Bitfield] -> Vector Frequency
-frequencies [] = V.fromList []
-frequencies xs = runST $ do
-    v <- VM.new size
-    VM.set v 0
-    forM_ xs $ \ Bitfield {..} -> do
-      forM_ (S.toList bfSet) $ \ x -> do
-        fr <- VM.read v x
-        VM.write v x (succ fr)
-    V.unsafeFreeze v
-  where
-    size = maximum (map bfSize xs)
-
--- TODO it seems like this operation is veeery slow
-
--- | Find least available piece index. If no piece available return
--- 'Nothing'.
-rarest :: [Bitfield] -> Maybe PieceIx
-rarest xs
-    | V.null freqMap = Nothing
-    |     otherwise
-    = Just $ fst $ V.ifoldr' minIx (0, freqMap V.! 0) freqMap
-  where
-    freqMap = frequencies xs
-
-    minIx ::  PieceIx -> Frequency
-          -> (PieceIx,   Frequency)
-          -> (PieceIx,   Frequency)
-    minIx ix fr acc@(_, fra)
-      | fr < fra && fr > 0 = (ix, fr)
-      |     otherwise      = acc
-
-
-{-----------------------------------------------------------------------
-    Combine
------------------------------------------------------------------------}
-
-insert :: PieceIx -> Bitfield -> Bitfield
-insert pix bf @ Bitfield {..}
-  | 0 <= pix && pix < bfSize = Bitfield
-    { bfSet  = S.insert pix bfSet
-    , bfSize = bfSize
-    }
-  | otherwise = bf
-
--- | Find indices at least one peer have.
-union :: Bitfield -> Bitfield -> Bitfield
-union a b = {-# SCC union #-} Bitfield {
-    bfSize = bfSize a `max` bfSize b
-  , bfSet  = bfSet a `S.union` bfSet b
-  }
-
--- | Find indices both peers have.
-intersection :: Bitfield -> Bitfield -> Bitfield
-intersection a b = {-# SCC intersection #-} Bitfield {
-    bfSize = bfSize a `min` bfSize b
-  , bfSet  = bfSet a `S.intersection` bfSet b
-  }
-
--- | Find indices which have first peer but do not have the second peer.
-difference :: Bitfield -> Bitfield -> Bitfield
-difference a b = {-# SCC difference #-} Bitfield {
-    bfSize = bfSize a -- FIXME is it reasonable?
-  , bfSet  = bfSet a `S.difference` bfSet b
-  }
-
--- | Find indices the any of the peers have.
-unions :: [Bitfield] -> Bitfield
-unions = {-# SCC unions #-} foldl' union (haveNone 0)
-
-{-----------------------------------------------------------------------
-    Serialization
------------------------------------------------------------------------}
-
--- | List all /have/ indexes.
-toList :: Bitfield -> [PieceIx]
-toList Bitfield {..} = S.toList bfSet
-
--- | Make bitfield from list of /have/ indexes.
-fromList :: PieceCount -> [PieceIx] -> Bitfield
-fromList s ixs = Bitfield {
-    bfSize = s
-  , bfSet  = S.splitGT (-1) $ S.splitLT s $ S.fromList ixs
-  }
-
--- | Unpack 'Bitfield' from tightly packed bit array. Note resulting
--- size might be more than real bitfield size, use 'adjustSize'.
-fromBitmap :: ByteString -> Bitfield
-fromBitmap bs = {-# SCC fromBitmap #-} Bitfield {
-    bfSize = B.length bs * 8
-  , bfSet  = S.fromByteString bs
-  }
-{-# INLINE fromBitmap #-}
-
--- | Pack a 'Bitfield' to tightly packed bit array.
-toBitmap :: Bitfield -> Lazy.ByteString
-toBitmap Bitfield {..} = {-# SCC toBitmap #-} Lazy.fromChunks [intsetBM, alignment]
-  where
-    byteSize  = bfSize `div` 8 + if bfSize `mod` 8 == 0 then 0 else 1
-    alignment = B.replicate (byteSize - B.length intsetBM) 0
-    intsetBM  = S.toByteString bfSet
diff --git a/src/Data/Torrent/InfoHash.hs b/src/Data/Torrent/InfoHash.hs
deleted file mode 100644
index f322ac6f..00000000
--- a/src/Data/Torrent/InfoHash.hs
+++ /dev/null
@@ -1,164 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  provisional
---   Portability :  portable
---
---   Infohash is a unique identifier of torrent.
---
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE MultiParamTypeClasses      #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-module Data.Torrent.InfoHash
-       ( InfoHash
-
-         -- * Parsing
-       , textToInfoHash
-
-         -- * Rendering
-       , longHex
-       , shortHex
-       ) where
-
-import Control.Applicative
-import Control.Monad
-import Data.BEncode
-import Data.ByteString as BS
-import Data.ByteString.Char8 as BC
-import Data.ByteString.Base16 as Base16
-import Data.ByteString.Base32 as Base32
-import Data.ByteString.Base64 as Base64
-import Data.Char
-import Data.Convertible.Base
-import Data.Default
-import Data.List       as L
-import Data.Hashable   as Hashable
-import Data.Serialize
-import Data.String
-import Data.Text as T
-import Data.Text.Encoding as T
-import Data.Typeable
-import Network.HTTP.Types.QueryLike
-import Text.ParserCombinators.ReadP as P
-import Text.PrettyPrint
-import Text.PrettyPrint.Class
-
-
--- TODO
---
--- data Word160 = Word160 {-# UNPACK #-} !Word64
---                        {-# UNPACK #-} !Word64
---                        {-# UNPACK #-} !Word32
---
--- newtype InfoHash = InfoHash Word160
---
--- reason: bytestring have overhead = 8 words, while infohash have length 20 bytes
-
--- | Exactly 20 bytes long SHA1 hash of the info part of torrent file.
-newtype InfoHash = InfoHash { getInfoHash :: BS.ByteString }
-                   deriving (Eq, Ord, Typeable)
-
-infoHashLen :: Int
-infoHashLen = 20
-
--- | Meaningless placeholder value.
-instance Default InfoHash where
-  def = "0123456789012345678901234567890123456789"
-
--- | Hash raw bytes. (no encoding)
-instance Hashable InfoHash where
-  hashWithSalt s (InfoHash ih) = hashWithSalt s ih
-  {-# INLINE hashWithSalt #-}
-
--- | Convert to\/from raw bencoded string. (no encoding)
-instance BEncode InfoHash where
-  toBEncode = toBEncode . getInfoHash
-  fromBEncode be = InfoHash <$> fromBEncode be
-
--- | Convert to\/from raw bytestring. (no encoding)
-instance Serialize InfoHash where
-  put (InfoHash ih) = putByteString ih
-  {-# INLINE put #-}
-
-  get = InfoHash <$> getBytes infoHashLen
-  {-# INLINE get #-}
-
--- | Convert to raw query value. (no encoding)
-instance QueryValueLike InfoHash where
-  toQueryValue (InfoHash ih) = Just ih
-  {-# INLINE toQueryValue #-}
-
--- | Convert to base16 encoded string.
-instance Show InfoHash where
-  show (InfoHash ih) = BC.unpack (Base16.encode ih)
-
--- | Convert to base16 encoded Doc string.
-instance Pretty InfoHash where
-  pretty = text . show
-
--- | Read base16 encoded string.
-instance Read InfoHash where
-  readsPrec _ = readP_to_S $ do
-      str <- replicateM (infoHashLen * 2) (satisfy isHexDigit)
-      return $ InfoHash $ decodeIH str
-    where
-      decodeIH       = BS.pack . L.map fromHex . pair
-      fromHex (a, b) = read $ '0' : 'x' : a : b : []
-
-      pair (a : b : xs) = (a, b) : pair xs
-      pair _            = []
-
--- | Convert raw bytes to info hash.
-instance Convertible BS.ByteString InfoHash where
-  safeConvert bs
-    | BS.length bs == infoHashLen = pure (InfoHash bs)
-    |          otherwise          = convError "invalid length" bs
-
--- | Parse infohash from base16\/base32\/base64 encoded string.
-instance Convertible Text InfoHash where
-  safeConvert t
-      | 20 == hashLen = pure (InfoHash hashStr)
-      | 26 <= hashLen && hashLen <= 28 =
-        case Base64.decode hashStr of
-          Left  msg   -> convError ("invalid base64 encoding " ++ msg) t
-          Right ihStr -> safeConvert ihStr
-
-      |      hashLen == 32   =
-        case Base32.decode hashStr of
-          Left  msg   -> convError msg t
-          Right ihStr -> safeConvert ihStr
-
-      |      hashLen == 40   =
-        let (ihStr, inv) = Base16.decode hashStr
-        in if BS.length inv /= 0
-           then convError "invalid base16 encoding" t
-           else safeConvert ihStr
-
-      |        otherwise     = convError "invalid length" t
-    where
-      hashLen = BS.length hashStr
-      hashStr = T.encodeUtf8 t
-
--- | Decode from base16\/base32\/base64 encoded string.
-instance IsString InfoHash where
-  fromString = either (error . prettyConvertError) id . safeConvert . T.pack
-
-ignoreErrorMsg :: Either a b -> Maybe b
-ignoreErrorMsg = either (const Nothing) Just
-
--- | Tries both base16 and base32 while decoding info hash.
---
---  Use 'safeConvert' for detailed error messages.
---
-textToInfoHash :: Text -> Maybe InfoHash
-textToInfoHash = ignoreErrorMsg . safeConvert
-
--- | Hex encode infohash to text, full length.
-longHex :: InfoHash -> Text
-longHex = T.decodeUtf8 . Base16.encode . getInfoHash
-
--- | The same as 'longHex', but only first 7 characters.
-shortHex :: InfoHash -> Text
-shortHex = T.take 7 . longHex
diff --git a/src/Data/Torrent/Layout.hs b/src/Data/Torrent/Layout.hs
deleted file mode 100644
index cc529840..00000000
--- a/src/Data/Torrent/Layout.hs
+++ /dev/null
@@ -1,321 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Layout of files in torrent.
---
-{-# LANGUAGE BangPatterns               #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE StandaloneDeriving         #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE DeriveFunctor              #-}
-{-# LANGUAGE DeriveFoldable             #-}
-{-# LANGUAGE DeriveTraversable          #-}
-{-# LANGUAGE TemplateHaskell            #-}
-{-# OPTIONS  -fno-warn-orphans          #-}
-module Data.Torrent.Layout
-       ( -- * File attributes
-         FileOffset
-       , FileSize
-
-         -- * Single file info
-       , FileInfo (..)
-
-         -- ** Lens
-       , fileLength
-       , filePath
-       , fileMD5Sum
-
-         -- * File layout
-       , LayoutInfo (..)
-       , joinFilePath
-
-         -- ** Lens
-       , singleFile
-       , multiFile
-       , rootDirName
-
-         -- ** Predicates
-       , isSingleFile
-       , isMultiFile
-
-         -- ** Query
-       , suggestedName
-       , contentLength
-       , fileCount
-       , blockCount
-
-         -- * Flat file layout
-       , FileLayout
-       , flatLayout
-       , accumPositions
-       , fileOffset
-
-         -- * Internal
-       , sizeInBase
-       , getLayoutInfo
-       , putLayoutInfo
-       ) where
-
-import Control.Applicative
-import Control.DeepSeq
-import Control.Lens
-import Data.BEncode
-import Data.BEncode.Types
-import Data.ByteString as BS
-import Data.ByteString.Base16 as Base16
-import Data.ByteString.Char8 as BC
-import Data.Default
-import Data.Foldable as F
-import Data.List as L
-import Data.Text as T
-import Data.Text.Encoding as T
-import Data.Typeable
-import Text.PrettyPrint as PP
-import Text.PrettyPrint.Class
-import System.FilePath
-import System.Posix.Types
-
-{-----------------------------------------------------------------------
---  File attribytes
------------------------------------------------------------------------}
-
--- | Size of a file in bytes.
-type FileSize = FileOffset
-
-deriving instance BEncode  FileOffset
-
-{-----------------------------------------------------------------------
---  File info both either from info dict or file list
------------------------------------------------------------------------}
-
--- | Contain metainfo about one single file.
-data FileInfo a = FileInfo {
-      fiLength      :: {-# UNPACK #-} !FileSize
-      -- ^ Length of the file in bytes.
-
-      -- TODO unpacked MD5 sum
-    , fiMD5Sum      :: !(Maybe ByteString)
-      -- ^ 32 character long MD5 sum of the file.  Used by third-party
-      -- tools, not by bittorrent protocol itself.
-
-    , fiName        :: !a
-      -- ^ One or more string elements that together represent the
-      -- path and filename. Each element in the list corresponds to
-      -- either a directory name or (in the case of the last element)
-      -- the filename.  For example, the file:
-      --
-      --   > "dir1/dir2/file.ext"
-      --
-      --   would consist of three string elements:
-      --
-      --   > ["dir1", "dir2", "file.ext"]
-      --
-    } deriving (Show, Read, Eq, Typeable
-               , Functor, Foldable
-               )
-
-makeLensesFor
-  [ ("fiLength", "fileLength")
-  , ("fiMD5Sum", "fileMD5Sum")
-  , ("fiName"  , "filePath"  )
-  ]
-  ''FileInfo
-
-instance NFData a => NFData (FileInfo a) where
-  rnf FileInfo {..} = rnf fiName
-  {-# INLINE rnf #-}
-
-instance BEncode (FileInfo [ByteString]) where
-  toBEncode FileInfo {..} = toDict $
-       "length" .=! fiLength
-    .: "md5sum" .=? fiMD5Sum
-    .: "path"   .=! fiName
-    .: endDict
-  {-# INLINE toBEncode #-}
-
-  fromBEncode = fromDict $ do
-    FileInfo <$>! "length"
-             <*>? "md5sum"
-             <*>! "path"
-  {-# INLINE fromBEncode #-}
-
-type Put a = a -> BDict -> BDict
-
-putFileInfoSingle :: Put (FileInfo ByteString)
-putFileInfoSingle FileInfo {..} cont =
-       "length" .=! fiLength
-    .: "md5sum" .=? fiMD5Sum
-    .: "name"   .=! fiName
-    .: cont
-
-getFileInfoSingle :: Get (FileInfo ByteString)
-getFileInfoSingle = do
-    FileInfo <$>! "length"
-             <*>? "md5sum"
-             <*>! "name"
-
-instance BEncode (FileInfo ByteString) where
-  toBEncode = toDict . (`putFileInfoSingle` endDict)
-  {-# INLINE toBEncode #-}
-
-  fromBEncode = fromDict getFileInfoSingle
-  {-# INLINE fromBEncode #-}
-
-instance Pretty (FileInfo BS.ByteString) where
-  pretty FileInfo {..} =
-       "Path: " <> text (T.unpack (T.decodeUtf8 fiName))
-    $$ "Size: " <> text (show fiLength)
-    $$ maybe PP.empty ppMD5 fiMD5Sum
-   where
-    ppMD5 md5 = "MD5 : " <> text (show (Base16.encode md5))
-
--- | Join file path.
-joinFilePath :: FileInfo [ByteString] -> FileInfo ByteString
-joinFilePath = fmap (BS.intercalate "/")
-
-{-----------------------------------------------------------------------
---  Original torrent file layout info
------------------------------------------------------------------------}
-
--- | Original (found in torrent file) layout info is either:
---
---     * Single file with its /name/.
---
---     * Multiple files with its relative file /paths/.
---
-data LayoutInfo
-  = SingleFile
-    { -- | Single file info.
-      liFile     :: !(FileInfo ByteString)
-    }
-  | MultiFile
-    { -- | List of the all files that torrent contains.
-      liFiles    :: ![FileInfo [ByteString]]
-
-      -- | The /suggested/ name of the root directory in which to
-      -- store all the files.
-    , liDirName  :: !ByteString
-    } deriving (Show, Read, Eq, Typeable)
-
-makeLensesFor
-  [ ("liFile"   , "singleFile" )
-  , ("liFiles"  , "multiFile"  )
-  , ("liDirName", "rootDirName")
-  ]
-  ''LayoutInfo
-
-instance NFData LayoutInfo where
-  rnf SingleFile {..} = ()
-  rnf MultiFile  {..} = rnf liFiles
-
--- | Empty multifile layout.
-instance Default LayoutInfo where
-  def = MultiFile [] ""
-
-getLayoutInfo :: Get LayoutInfo
-getLayoutInfo = single <|> multi
-  where
-    single = SingleFile <$>  getFileInfoSingle
-    multi  = MultiFile  <$>! "files" <*>! "name"
-
-putLayoutInfo :: Put LayoutInfo
-putLayoutInfo SingleFile {..} = putFileInfoSingle liFile
-putLayoutInfo MultiFile  {..} = \ cont ->
-     "files" .=! liFiles
-  .: "name"  .=! liDirName
-  .: cont
-
-instance BEncode LayoutInfo where
-  toBEncode   = toDict . (`putLayoutInfo` endDict)
-  fromBEncode = fromDict getLayoutInfo
-
-instance Pretty LayoutInfo where
-  pretty SingleFile {..} = pretty liFile
-  pretty MultiFile  {..} = vcat $ L.map (pretty . joinFilePath) liFiles
-
--- | Test if this is single file torrent.
-isSingleFile :: LayoutInfo -> Bool
-isSingleFile SingleFile {} = True
-isSingleFile _             = False
-{-# INLINE isSingleFile #-}
-
--- | Test if this is multifile torrent.
-isMultiFile :: LayoutInfo -> Bool
-isMultiFile MultiFile {} = True
-isMultiFile _            = False
-{-# INLINE isMultiFile #-}
-
--- | Get name of the torrent based on the root path piece.
-suggestedName :: LayoutInfo -> ByteString
-suggestedName (SingleFile FileInfo {..}) = fiName
-suggestedName  MultiFile           {..}  = liDirName
-{-# INLINE suggestedName #-}
-
--- | Find sum of sizes of the all torrent files.
-contentLength :: LayoutInfo -> FileSize
-contentLength SingleFile { liFile  = FileInfo {..} } = fiLength
-contentLength MultiFile  { liFiles = tfs           } = L.sum (L.map fiLength tfs)
-
--- | Get number of all files in torrent.
-fileCount :: LayoutInfo -> Int
-fileCount SingleFile {..} = 1
-fileCount MultiFile  {..} = L.length liFiles
-
--- | Find number of blocks of the specified size. If torrent size is
--- not a multiple of block size then the count is rounded up.
-blockCount :: Int -> LayoutInfo -> Int
-blockCount blkSize ci = contentLength ci `sizeInBase` blkSize
-
-{-----------------------------------------------------------------------
---  Flat layout
------------------------------------------------------------------------}
-
--- | File layout specifies the order and the size of each file in the
---   storage. Note that order of files is highly important since we
---   coalesce all the files in the given order to get the linear block
---   address space.
---
-type FileLayout a = [(FilePath, a)]
-
--- | Extract files layout from torrent info with the given root path.
-flatLayout
-  :: FilePath            -- ^ Root path for the all torrent files.
-  -> LayoutInfo          -- ^ Torrent content information.
-  -> FileLayout FileSize -- ^ The all file paths prefixed with the given root.
-flatLayout prefixPath SingleFile { liFile = FileInfo {..} }
-    = [(prefixPath </> BC.unpack fiName, fiLength)]
-flatLayout prefixPath MultiFile  {..}     = L.map mkPath liFiles
-  where   -- TODO use utf8 encoding in name
-    mkPath FileInfo {..} = (path, fiLength)
-      where
-        path = prefixPath </> BC.unpack liDirName
-           </> joinPath (L.map BC.unpack fiName)
-
--- | Calculate offset of each file based on its length, incrementally.
-accumPositions :: FileLayout FileSize -> FileLayout (FileOffset, FileSize)
-accumPositions = go 0
-  where
-    go !_ [] = []
-    go !offset ((n, s) : xs) = (n, (offset, s)) : go (offset + s) xs
-
--- | Gives global offset of a content file for a given full path.
-fileOffset :: FilePath -> FileLayout FileOffset -> Maybe FileOffset
-fileOffset = lookup
-{-# INLINE fileOffset #-}
-
-{-----------------------------------------------------------------------
--- Internal utilities
------------------------------------------------------------------------}
-
--- | Divide and round up.
-sizeInBase :: Integral a => a -> Int -> Int
-sizeInBase n b = fromIntegral (n `div` fromIntegral b) + align
-  where
-    align = if n `mod` fromIntegral b == 0 then 0 else 1
-{-# SPECIALIZE sizeInBase :: Int -> Int -> Int #-}
-{-# SPECIALIZE sizeInBase :: Integer -> Int -> Int #-}
diff --git a/src/Data/Torrent/Magnet.hs b/src/Data/Torrent/Magnet.hs
deleted file mode 100644
index aad0debe..00000000
--- a/src/Data/Torrent/Magnet.hs
+++ /dev/null
@@ -1,372 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  provisional
---   Portability :  portable
---
---   Magnet URI scheme is an standard defining Magnet links. Magnet
---   links are refer to resources by hash, in particular magnet links
---   can refer to torrent using corresponding infohash. In this way,
---   magnet links can be used instead of torrent files.
---
---   This module provides bittorrent specific implementation of magnet
---   links.
---
---   For generic magnet uri scheme see:
---   <http://magnet-uri.sourceforge.net/magnet-draft-overview.txt>,
---   <http://www.iana.org/assignments/uri-schemes/prov/magnet>
---
---   Bittorrent specific details:
---   <http://www.bittorrent.org/beps/bep_0009.html>
---
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE TypeSynonymInstances  #-}
-{-# LANGUAGE DeriveDataTypeable    #-}
-{-# OPTIONS -fno-warn-orphans      #-}
-module Data.Torrent.Magnet
-       ( -- * Magnet
-         Magnet(..)
-
-         -- ** Construction
-       , nullMagnet
-       , simpleMagnet
-       , detailedMagnet
-
-         -- ** Conversion
-       , parseMagnet
-       , renderMagnet
-
-         -- * URN
-       , URN (..)
-
-         -- ** Namespaces
-       , NamespaceId
-       , btih
-
-         -- ** Construction
-       , infohashURN
-
-         -- ** Conversion
-       , parseURN
-       , renderURN
-       ) where
-
-import Control.Applicative
-import Control.Monad
-import Data.ByteString.Char8 as BC
-import Data.Convertible
-import Data.Default
-import Data.Map as M
-import Data.Maybe
-import Data.List as L
-import Data.String
-import Data.Text as T
-import Data.Text.Encoding as T
-import Data.Text.Read
-import Data.Typeable
-import Network.HTTP.Types.QueryLike
-import Network.HTTP.Types.URI
-import Network.URI
-import Text.PrettyPrint as PP
-import Text.PrettyPrint.Class
-
-import Data.Torrent
-import Data.Torrent.InfoHash
-import Data.Torrent.Layout
-
-
--- | Namespace identifier determines the syntactic interpretation of
--- namespace-specific string.
-type NamespaceId = [Text]
-
--- | BitTorrent Info Hash (hence the name) namespace
--- identifier. Namespace-specific string /should/ be a base16\/base32
--- encoded SHA1 hash of the corresponding torrent /info/ dictionary.
---
-btih :: NamespaceId
-btih  = ["btih"]
-
--- | URN is pesistent location-independent identifier for
---   resources. In particular, URNs are used represent torrent names
---   as a part of magnet link, see 'Data.Torrent.Magnet.Magnet' for
---   more info.
---
-data URN = URN
-  { urnNamespace :: NamespaceId -- ^ a namespace identifier;
-  , urnString    :: Text        -- ^ a corresponding
-                                -- namespace-specific string.
-  } deriving (Eq, Ord, Typeable)
-
-{-----------------------------------------------------------------------
---  URN to infohash convertion
------------------------------------------------------------------------}
-
-instance Convertible URN InfoHash where
-  safeConvert u @ URN {..}
-    | urnNamespace /= btih = convError "invalid namespace" u
-    |       otherwise      = safeConvert urnString
-
--- | Make resource name for torrent with corresponding
--- infohash. Infohash is base16 (hex) encoded.
---
-infohashURN :: InfoHash -> URN
-infohashURN = URN btih . longHex
-
--- | Meaningless placeholder value.
-instance Default URN where
-  def = infohashURN def
-
-{-----------------------------------------------------------------------
---  URN Rendering
------------------------------------------------------------------------}
-
--- | Render URN to its text representation.
-renderURN :: URN -> Text
-renderURN URN {..}
-  = T.intercalate ":" $ "urn" : urnNamespace ++ [urnString]
-
-instance Pretty URN where
-  pretty = text . T.unpack . renderURN
-
-instance Show URN where
-  showsPrec n = showsPrec n . T.unpack . renderURN
-
-instance QueryValueLike URN where
-  toQueryValue = toQueryValue . renderURN
-  {-# INLINE toQueryValue #-}
-
-{-----------------------------------------------------------------------
---  URN Parsing
------------------------------------------------------------------------}
-
-unsnoc :: [a] -> Maybe ([a], a)
-unsnoc [] = Nothing
-unsnoc xs = Just (L.init xs, L.last xs)
-
-instance Convertible Text URN where
-  safeConvert t = case T.split (== ':') t of
-    uriScheme : body
-      | T.toLower uriScheme == "urn" ->
-        case unsnoc body of
-          Just (namespace, val) -> pure URN
-            { urnNamespace = namespace
-            , urnString    = val
-            }
-          Nothing -> convError "missing URN string" body
-      | otherwise -> convError "invalid URN scheme" uriScheme
-    []            -> convError "missing URN scheme" t
-
-instance IsString URN where
-  fromString = either (error . prettyConvertError) id
-             . safeConvert . T.pack
-
--- | Try to parse an URN from its text representation.
---
---  Use 'safeConvert' for detailed error messages.
---
-parseURN :: Text -> Maybe URN
-parseURN = either (const Nothing) pure . safeConvert
-
-{-----------------------------------------------------------------------
---  Magnet
------------------------------------------------------------------------}
-
--- TODO multiple exact topics
--- TODO render/parse supplement for URI/query
-
--- | An URI used to identify torrent.
-data Magnet = Magnet
-  { -- | Torrent infohash hash. Can be used in DHT queries if no
-    -- 'tracker' provided.
-    exactTopic  :: !InfoHash -- TODO InfoHash -> URN?
-
-    -- | A filename for the file to download. Can be used to
-    -- display name while waiting for metadata.
-  , displayName :: Maybe Text
-
-    -- | Size of the resource in bytes.
-  , exactLength :: Maybe Integer
-
-    -- | URI pointing to manifest, e.g. a list of further items.
-  , manifest :: Maybe Text
-
-    -- | Search string.
-  , keywordTopic :: Maybe Text
-
-    -- | A source to be queried after not being able to find and
-    -- download the file in the bittorrent network in a defined
-    -- amount of time.
-  , acceptableSource :: Maybe URI
-
-    -- | Direct link to the resource.
-  , exactSource      :: Maybe URI
-
-    -- | URI to the tracker.
-  , tracker :: Maybe URI
-
-    -- | Additional or experimental parameters.
-  , supplement :: Map Text Text
-  } deriving (Eq, Ord, Typeable)
-
-instance QueryValueLike Integer where
-  toQueryValue = toQueryValue . show
-
-instance QueryValueLike URI where
-  toQueryValue = toQueryValue . show
-
-instance QueryLike Magnet where
-  toQuery Magnet {..} =
-    [ ("xt", toQueryValue $ infohashURN exactTopic)
-    , ("dn", toQueryValue displayName)
-    , ("xl", toQueryValue exactLength)
-    , ("mt", toQueryValue manifest)
-    , ("kt", toQueryValue keywordTopic)
-    , ("as", toQueryValue acceptableSource)
-    , ("xs", toQueryValue exactSource)
-    , ("tr", toQueryValue tracker)
-    ]
-
-instance QueryValueLike Magnet where
-  toQueryValue = toQueryValue . renderMagnet
-
-instance Convertible QueryText Magnet where
-  safeConvert xs = do
-      urnStr   <- getTextMsg "xt" "exact topic not defined" xs
-      infoHash <- convertVia (error "safeConvert" :: URN)  urnStr
-      return Magnet
-        { exactTopic       = infoHash
-        , displayName      = getText "dn" xs
-        , exactLength      = getText "xl" xs >>= getInt
-        , manifest         = getText "mt" xs
-        , keywordTopic     = getText "kt" xs
-        , acceptableSource = getText "as" xs >>= getURI
-        , exactSource      = getText "xs" xs >>= getURI
-        , tracker          = getText "tr" xs >>= getURI
-        , supplement       = M.empty
-        }
-    where
-      getInt    = either (const Nothing) (Just . fst) . signed decimal
-      getURI    = parseURI . T.unpack
-      getText p = join . L.lookup p
-      getTextMsg p msg ps = maybe (convError msg xs) pure $ getText p ps
-
-magnetScheme :: URI
-magnetScheme = URI
-    { uriScheme    = "magnet:"
-    , uriAuthority = Nothing
-    , uriPath      = ""
-    , uriQuery     = ""
-    , uriFragment  = ""
-    }
-
-isMagnetURI :: URI -> Bool
-isMagnetURI u = u { uriQuery = "" } == magnetScheme
-
--- | Can be used instead of 'parseMagnet'.
-instance Convertible URI Magnet where
-  safeConvert u @ URI {..}
-    | not (isMagnetURI u) = convError "this is not a magnet link" u
-    |      otherwise      = safeConvert $ parseQueryText $ BC.pack uriQuery
-
--- | Can be used instead of 'renderMagnet'.
-instance Convertible Magnet URI where
-  safeConvert m = pure $ magnetScheme
-    { uriQuery = BC.unpack $ renderQuery True $ toQuery m }
-
-instance Convertible String Magnet where
-  safeConvert str
-    | Just uri <- parseURI str = safeConvert uri
-    |        otherwise         = convError "unable to parse uri" str
-
-{-----------------------------------------------------------------------
---  Magnet Construction
------------------------------------------------------------------------}
-
--- | Meaningless placeholder value.
-instance Default Magnet where
-  def = Magnet
-    { exactTopic       = def
-    , displayName      = Nothing
-    , exactLength      = Nothing
-    , manifest         = Nothing
-    , keywordTopic     = Nothing
-    , acceptableSource = Nothing
-    , exactSource      = Nothing
-    , tracker          = Nothing
-    , supplement       = M.empty
-    }
-
--- | Set 'exactTopic' ('xt' param) only, other params are empty.
-nullMagnet :: InfoHash -> Magnet
-nullMagnet u = Magnet
-    { exactTopic   = u
-    , displayName  = Nothing
-    , exactLength  = Nothing
-    , manifest     = Nothing
-    , keywordTopic = Nothing
-    , acceptableSource = Nothing
-    , exactSource      = Nothing
-    , tracker    = Nothing
-    , supplement = M.empty
-    }
-
--- | Like 'nullMagnet' but also include 'displayName' ('dn' param).
-simpleMagnet :: Torrent -> Magnet
-simpleMagnet Torrent {tInfoDict = InfoDict {..}}
-  = (nullMagnet idInfoHash)
-    { displayName = Just $ T.decodeUtf8 $ suggestedName idLayoutInfo
-    }
-
--- | Like 'simpleMagnet' but also include 'exactLength' ('xl' param) and
--- 'tracker' ('tr' param).
---
-detailedMagnet :: Torrent -> Magnet
-detailedMagnet t @ Torrent {tInfoDict = InfoDict {..}, tAnnounce}
-  = (simpleMagnet t)
-    { exactLength = Just $ fromIntegral $ contentLength idLayoutInfo
-    , tracker     = tAnnounce
-    }
-
-{-----------------------------------------------------------------------
---  Magnet Conversion
------------------------------------------------------------------------}
-
-parseMagnetStr :: String -> Maybe Magnet
-parseMagnetStr = either (const Nothing) Just . safeConvert
-
-renderMagnetStr :: Magnet -> String
-renderMagnetStr = show . (convert :: Magnet -> URI)
-
-instance Pretty Magnet where
-  pretty = PP.text . renderMagnetStr
-
-instance Show Magnet where
-  show = renderMagnetStr
-  {-# INLINE show #-}
-
-instance Read Magnet where
-  readsPrec _ xs
-      | Just m <- parseMagnetStr mstr = [(m, rest)]
-      | otherwise = []
-    where
-      (mstr, rest) = L.break (== ' ') xs
-
-instance IsString Magnet where
-  fromString str = fromMaybe (error msg) $ parseMagnetStr str
-    where
-      msg = "unable to parse magnet: " ++ str
-
--- | Try to parse magnet link from urlencoded string. Use
--- 'safeConvert' to find out error location.
---
-parseMagnet :: Text -> Maybe Magnet
-parseMagnet = parseMagnetStr . T.unpack
-{-# INLINE parseMagnet #-}
-
--- | Render magnet link to urlencoded string
-renderMagnet :: Magnet -> Text
-renderMagnet = T.pack . renderMagnetStr
-{-# INLINE renderMagnet #-}
diff --git a/src/Data/Torrent/Piece.hs b/src/Data/Torrent/Piece.hs
deleted file mode 100644
index d4b2c399..00000000
--- a/src/Data/Torrent/Piece.hs
+++ /dev/null
@@ -1,232 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Pieces are used to validate torrent content.
---
-{-# LANGUAGE TemplateHaskell            #-}
-{-# LANGUAGE DeriveDataTypeable         #-}
-{-# LANGUAGE DeriveFunctor              #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-module Data.Torrent.Piece
-       ( -- * Piece attributes
-         PieceIx
-       , PieceCount
-       , PieceSize
-       , minPieceSize
-       , maxPieceSize
-       , defaultPieceSize
-       , PieceHash
-
-         -- * Piece data
-       , Piece (..)
-       , pieceSize
-       , hashPiece
-
-         -- * Piece control
-       , HashList (..)
-       , PieceInfo (..)
-       , pieceCount
-
-         -- * Lens
-       , pieceLength
-       , pieceHashes
-
-         -- * Validation
-       , pieceHash
-       , checkPieceLazy
-
-         -- * Internal
-       , getPieceInfo
-       , putPieceInfo
-       ) where
-
-import Control.DeepSeq
-import Control.Lens
-import qualified Crypto.Hash.SHA1 as SHA1
-import Data.BEncode
-import Data.BEncode.Types
-import Data.Bits
-import Data.Bits.Extras
-import           Data.ByteString as BS
-import qualified Data.ByteString.Lazy as BL
-import qualified Data.ByteString.Base64 as Base64
-import Data.Default
-import Data.Int
-import Data.Text.Encoding as T
-import Data.Typeable
-import Text.PrettyPrint
-import Text.PrettyPrint.Class
-
-
--- TODO add torrent file validation
-class Lint a where
-   lint :: a -> Either String a
-
---class Validation a where
---  validate :: PieceInfo -> Piece a -> Bool
-
-{-----------------------------------------------------------------------
--- Piece attributes
------------------------------------------------------------------------}
-
--- | Zero-based index of piece in torrent content.
-type PieceIx   = Int
-
--- | Size of piece in bytes. Should be a power of 2.
---
---   NOTE: Have max and min size constrained to wide used
---   semi-standard values. This bounds should be used to make decision
---   about piece size for new torrents.
---
-type PieceSize = Int
-
--- | Number of pieces in torrent or a part of torrent.
-type PieceCount = Int
-
-defaultBlockSize :: Int
-defaultBlockSize = 16 * 1024
-
--- | Optimal number of pieces in torrent.
-optimalPieceCount :: PieceCount
-optimalPieceCount = 1000
-{-# INLINE optimalPieceCount #-}
-
--- | Piece size should not be less than this value.
-minPieceSize :: Int
-minPieceSize = defaultBlockSize * 4
-{-# INLINE minPieceSize #-}
-
--- | To prevent transfer degradation piece size should not exceed this
--- value.
-maxPieceSize :: Int
-maxPieceSize = 4 * 1024 * 1024
-{-# INLINE maxPieceSize #-}
-
-toPow2 :: Int -> Int
-toPow2 x = bit $ fromIntegral (leadingZeros (0 :: Int) - leadingZeros x)
-
--- | Find the optimal piece size for a given torrent size.
-defaultPieceSize :: Int64 -> Int
-defaultPieceSize x = max minPieceSize $ min maxPieceSize $ toPow2 pc
-  where
-    pc = fromIntegral (x `div` fromIntegral optimalPieceCount)
-
-{-----------------------------------------------------------------------
--- Piece data
------------------------------------------------------------------------}
-
-type PieceHash = ByteString
-
-hashsize :: Int
-hashsize = 20
-{-# INLINE hashsize #-}
-
--- TODO check if pieceLength is power of 2
--- | Piece payload should be strict or lazy bytestring.
-data Piece a = Piece
-  { -- | Zero-based piece index in torrent.
-    pieceIndex :: {-# UNPACK #-} !PieceIx
-
-    -- | Payload.
-  , pieceData  :: !a
-  } deriving (Show, Read, Eq, Functor, Typeable)
-
-instance NFData (Piece a)
-
--- | Payload bytes are omitted.
-instance Pretty (Piece a) where
-  pretty Piece {..} = "Piece" <+> braces ("index" <+> "=" <+> int pieceIndex)
-
--- | Get size of piece in bytes.
-pieceSize :: Piece BL.ByteString -> PieceSize
-pieceSize Piece {..} = fromIntegral (BL.length pieceData)
-
--- | Get piece hash.
-hashPiece :: Piece BL.ByteString -> PieceHash
-hashPiece Piece {..} = SHA1.hashlazy pieceData
-
-{-----------------------------------------------------------------------
--- Piece control
------------------------------------------------------------------------}
-
--- | A flat array of SHA1 hash for each piece.
-newtype HashList = HashList { unHashList :: ByteString }
-  deriving (Show, Read, Eq, BEncode, Typeable)
-
--- | Empty hash list.
-instance Default HashList where
-  def = HashList ""
-
--- | Part of torrent file used for torrent content validation.
-data PieceInfo = PieceInfo
-  { piPieceLength  :: {-# UNPACK #-} !PieceSize
-    -- ^ Number of bytes in each piece.
-
-  , piPieceHashes  :: !HashList
-    -- ^ Concatenation of all 20-byte SHA1 hash values.
-  } deriving (Show, Read, Eq, Typeable)
-
--- | Number of bytes in each piece.
-makeLensesFor [("piPieceLength", "pieceLength")] ''PieceInfo
-
--- | Concatenation of all 20-byte SHA1 hash values.
-makeLensesFor [("piPieceHashes", "pieceHashes")] ''PieceInfo
-
-instance NFData PieceInfo
-
-instance Default PieceInfo where
-  def = PieceInfo 1 def
-
-instance Lint PieceInfo where
-  lint pinfo @ PieceInfo {..}
-    | BS.length (unHashList piPieceHashes) `rem` hashsize == 0
-    , piPieceLength >= 0 = return pinfo
-    |       otherwise    = Left undefined
-
-
-putPieceInfo :: PieceInfo -> BDict -> BDict
-putPieceInfo PieceInfo {..} cont =
-       "piece length" .=! piPieceLength
-    .: "pieces"       .=! piPieceHashes
-    .: cont
-
-getPieceInfo :: Get PieceInfo
-getPieceInfo = do
-    PieceInfo <$>! "piece length"
-              <*>! "pieces"
-
-instance BEncode PieceInfo where
-  toBEncode   = toDict . (`putPieceInfo` endDict)
-  fromBEncode = fromDict getPieceInfo
-
--- | Hashes are omitted.
-instance Pretty PieceInfo where
-  pretty  PieceInfo {..} = "Piece size: " <> int piPieceLength
-
-slice :: Int -> Int -> ByteString -> ByteString
-slice start len = BS.take len . BS.drop start
-{-# INLINE slice #-}
-
--- | Extract validation hash by specified piece index.
-pieceHash :: PieceInfo -> PieceIx -> PieceHash
-pieceHash PieceInfo {..} i = slice (hashsize * i) hashsize (unHashList piPieceHashes)
-
--- | Find count of pieces in the torrent. If torrent size is not a
--- multiple of piece size then the count is rounded up.
-pieceCount :: PieceInfo -> PieceCount
-pieceCount PieceInfo {..} = BS.length (unHashList piPieceHashes) `quot` hashsize
-
--- | Test if this is last piece in torrent content.
-isLastPiece :: PieceInfo -> PieceIx -> Bool
-isLastPiece ci i = pieceCount ci == succ i
-
--- | Validate piece with metainfo hash.
-checkPieceLazy :: PieceInfo -> Piece BL.ByteString -> Bool
-checkPieceLazy pinfo @ PieceInfo {..} Piece {..}
-  = (fromIntegral (BL.length pieceData) == piPieceLength
-     || isLastPiece pinfo pieceIndex)
-  && SHA1.hashlazy pieceData == pieceHash pinfo pieceIndex
diff --git a/src/Data/Torrent/Progress.hs b/src/Data/Torrent/Progress.hs
deleted file mode 100644
index 4719020a..00000000
--- a/src/Data/Torrent/Progress.hs
+++ /dev/null
@@ -1,155 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   'Progress' used to track amount downloaded\/left\/upload bytes
---   either on per client or per torrent basis. This value is used to
---   notify the tracker and usually shown to the user. To aggregate
---   total progress you can use the Monoid instance.
---
-{-# LANGUAGE TemplateHaskell #-}
-{-# LANGUAGE ViewPatterns    #-}
-{-# OPTIONS -fno-warn-orphans #-}
-module Data.Torrent.Progress
-       ( -- * Progress
-         Progress (..)
-
-         -- * Lens
-       , left
-       , uploaded
-       , downloaded
-
-         -- * Construction
-       , startProgress
-       , downloadedProgress
-       , enqueuedProgress
-       , uploadedProgress
-       , dequeuedProgress
-
-         -- * Query
-       , canDownload
-       , canUpload
-       ) where
-
-import Control.Applicative
-import Control.Lens hiding ((%=))
-import Data.ByteString.Lazy.Builder  as BS
-import Data.ByteString.Lazy.Builder.ASCII as BS
-import Data.Default
-import Data.List as L
-import Data.Monoid
-import Data.Serialize as S
-import Data.Ratio
-import Data.Word
-import Network.HTTP.Types.QueryLike
-import Text.PrettyPrint as PP
-import Text.PrettyPrint.Class
-
-
--- | Progress data is considered as dynamic within one client
--- session. This data also should be shared across client application
--- sessions (e.g. files), otherwise use 'startProgress' to get initial
--- 'Progress' value.
---
-data Progress = Progress
-  { _downloaded :: {-# UNPACK #-} !Word64 -- ^ Total amount of bytes downloaded;
-  , _left       :: {-# UNPACK #-} !Word64 -- ^ Total amount of bytes left;
-  , _uploaded   :: {-# UNPACK #-} !Word64 -- ^ Total amount of bytes uploaded.
-  } deriving (Show, Read, Eq)
-
-$(makeLenses ''Progress)
-
--- | UDP tracker compatible encoding.
-instance Serialize Progress where
-  put Progress {..} = do
-    putWord64be $ fromIntegral _downloaded
-    putWord64be $ fromIntegral _left
-    putWord64be $ fromIntegral _uploaded
-
-  get = Progress
-    <$> (fromIntegral <$> getWord64be)
-    <*> (fromIntegral <$> getWord64be)
-    <*> (fromIntegral <$> getWord64be)
-
-instance Default Progress where
-  def = Progress 0 0 0
-  {-# INLINE def #-}
-
--- | Can be used to aggregate total progress.
-instance Monoid Progress where
-  mempty  = def
-  {-# INLINE mempty #-}
-
-  mappend (Progress da la ua) (Progress db lb ub) = Progress
-    { _downloaded = da + db
-    , _left       = la + lb
-    , _uploaded   = ua + ub
-    }
-  {-# INLINE mappend #-}
-
-instance QueryValueLike Builder where
-  toQueryValue = toQueryValue . BS.toLazyByteString
-
-instance QueryValueLike Word64 where
-  toQueryValue = toQueryValue . BS.word64Dec
-
--- | HTTP Tracker protocol compatible encoding.
-instance QueryLike Progress where
-  toQuery Progress {..} =
-    [ ("uploaded"  , toQueryValue _uploaded)
-    , ("left"      , toQueryValue _left)
-    , ("downloaded", toQueryValue _downloaded)
-    ]
-
-instance Pretty Progress where
-  pretty Progress {..} =
-    "/\\"  <+> PP.text (show _uploaded)   $$
-    "\\/"  <+> PP.text (show _downloaded) $$
-    "left" <+> PP.text (show _left)
-
--- | Initial progress is used when there are no session before.
---
--- Please note that tracker might penalize client some way if the do
--- not accumulate progress. If possible and save 'Progress' between
--- client sessions to avoid that.
---
-startProgress :: Integer -> Progress
-startProgress = Progress 0 0 . fromIntegral
-{-# INLINE startProgress #-}
-
--- | Used when the client download some data from /any/ peer.
-downloadedProgress :: Int -> Progress -> Progress
-downloadedProgress (fromIntegral -> amount)
-                 = (left         -~ amount)
-                 . (downloaded   +~ amount)
-{-# INLINE downloadedProgress #-}
-
--- | Used when the client upload some data to /any/ peer.
-uploadedProgress :: Int -> Progress -> Progress
-uploadedProgress (fromIntegral -> amount) = uploaded +~ amount
-{-# INLINE uploadedProgress #-}
-
--- | Used when leecher join client session.
-enqueuedProgress :: Integer -> Progress -> Progress
-enqueuedProgress amount = left +~ fromIntegral amount
-{-# INLINE enqueuedProgress #-}
-
--- | Used when leecher leave client session.
---   (e.g. user deletes not completed torrent)
-dequeuedProgress :: Integer -> Progress -> Progress
-dequeuedProgress amount = left -~ fromIntegral amount
-{-# INLINE dequeuedProgress #-}
-
-ri2rw64 :: Ratio Int -> Ratio Word64
-ri2rw64 x = fromIntegral (numerator x) % fromIntegral (denominator x)
-
--- | Check global /download/ limit by uploaded \/ downloaded ratio.
-canDownload :: Ratio Int -> Progress -> Bool
-canDownload limit Progress {..} = _uploaded % _downloaded > ri2rw64 limit
-
--- | Check global /upload/ limit by downloaded \/ uploaded ratio.
-canUpload :: Ratio Int -> Progress -> Bool
-canUpload limit Progress {..} = _downloaded % _uploaded > ri2rw64 limit
diff --git a/src/Data/Torrent/Tree.hs b/src/Data/Torrent/Tree.hs
deleted file mode 100644
index 102f4dff..00000000
--- a/src/Data/Torrent/Tree.hs
+++ /dev/null
@@ -1,83 +0,0 @@
--- |
---   Copyright   :  (c) Sam Truzjan 2013
---   License     :  BSD3
---   Maintainer  :  pxqr.sta@gmail.com
---   Stability   :  experimental
---   Portability :  portable
---
---   Directory tree can be used to easily manipulate file layout info.
---
-{-# LANGUAGE FlexibleInstances  #-}
-{-# LANGUAGE TemplateHaskell    #-}
-{-# LANGUAGE DeriveDataTypeable #-}
-module Data.Torrent.Tree
-       ( -- * Directory tree
-         DirTree (..)
-
-         -- * Construction
-       , build
-
-         -- * Query
-       , Data.Torrent.Tree.lookup
-       , lookupDir
-       , fileNumber
-       , dirNumber
-       ) where
-
-import Data.ByteString as BS
-import Data.ByteString.Char8 as BC
-import Data.Foldable
-import Data.List as L
-import Data.Map  as M
-import Data.Monoid
-
-import Data.Torrent.Layout
-
-
--- | 'DirTree' is more convenient form of 'LayoutInfo'.
-data DirTree a = Dir  { children :: Map ByteString (DirTree a) }
-               | File { node     :: FileInfo a                 }
-                 deriving Show
-
--- | Build directory tree from a list of files.
-build :: LayoutInfo -> DirTree ()
-build SingleFile {liFile = FileInfo {..}} = Dir
-    { children = M.singleton fiName (File fi) }
-  where
-    fi = FileInfo fiLength fiMD5Sum ()
-build MultiFile {..} = Dir $ M.singleton liDirName files
-  where
-    files = Dir $ M.fromList $ L.map mkFileEntry liFiles
-    mkFileEntry FileInfo {..} = (L.head fiName, ent) -- TODO FIXME
-      where
-        ent = File $ FileInfo fiLength fiMD5Sum ()
-
---decompress :: DirTree () -> [FileInfo ()]
---decompress = undefined
-
--- TODO pretty print
-
--- | Lookup file by path.
-lookup :: [FilePath] -> DirTree a -> Maybe (DirTree a)
-lookup []        t      = Just t
-lookup (p : ps) (Dir m) | Just subTree <- M.lookup (BC.pack p) m
-                        = Data.Torrent.Tree.lookup ps subTree
-lookup _         _      = Nothing
-
--- | Lookup directory by path.
-lookupDir :: [FilePath] -> DirTree a -> Maybe [(ByteString, DirTree a)]
-lookupDir ps d = do
-  subTree <- Data.Torrent.Tree.lookup ps d
-  case subTree of
-    File _  -> Nothing
-    Dir  es -> Just $ M.toList es
-
--- | Get total count of files in directory and subdirectories.
-fileNumber :: DirTree a -> Sum Int
-fileNumber File {..} = Sum 1
-fileNumber Dir  {..} = foldMap fileNumber children
-
--- | Get total count of directories in the directory and subdirectories.
-dirNumber :: DirTree a -> Sum Int
-dirNumber File {..} = Sum 0
-dirNumber Dir  {..} = Sum 1 <> foldMap dirNumber children