1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
-- |
-- Copyright : (c) Sam Truzjan 2013
-- License : BSD3
-- Maintainer : pxqr.sta@gmail.com
-- Stability : experimental
-- Portability : portable
--
-- Blocks are used to transfer pieces.
--
{-# LANGUAGE FlexibleInstances #-}
{-# LANGUAGE TemplateHaskell #-}
{-# LANGUAGE DeriveFunctor #-}
{-# LANGUAGE DeriveDataTypeable #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}
module Data.Torrent.Block
( -- * Piece attributes
PieceIx
, PieceSize
-- * Block attributes
, BlockOffset
, BlockCount
, BlockSize
, defaultTransferSize
-- * Block index
, BlockIx(..)
, blockIxRange
-- * Block data
, Block(..)
, blockIx
, blockSize
, blockRange
) where
import Control.Applicative
import Data.Aeson.TH
import qualified Data.ByteString.Lazy as Lazy
import Data.Char
import Data.List as L
import Data.Serialize as S
import Data.Typeable
import Text.PrettyPrint
import Text.PrettyPrint.Class
{-----------------------------------------------------------------------
-- 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
{-----------------------------------------------------------------------
-- Block attributes
-----------------------------------------------------------------------}
-- | Offset of a block in a piece in bytes. Should be multiple of
-- the choosen block size.
type BlockOffset = Int
-- | Size of a block in bytes. Should be power of 2.
--
-- Normally block size is equal to 'defaultTransferSize'.
--
type BlockSize = Int
-- | Number of block in a piece of a torrent. Used to distinguish
-- block count from piece count.
type BlockCount = Int
-- | Widely used semi-official block size. Some clients can ignore if
-- block size of BlockIx in Request message is not equal to this
-- value.
--
defaultTransferSize :: BlockSize
defaultTransferSize = 16 * 1024
{-----------------------------------------------------------------------
Block Index
-----------------------------------------------------------------------}
-- | BlockIx correspond.
data BlockIx = BlockIx {
-- | Zero-based piece index.
ixPiece :: {-# UNPACK #-} !PieceIx
-- | Zero-based byte offset within the piece.
, ixOffset :: {-# UNPACK #-} !BlockOffset
-- | Block size starting from offset.
, ixLength :: {-# UNPACK #-} !BlockSize
} deriving (Show, Eq, Typeable)
$(deriveJSON (L.map toLower . L.dropWhile isLower) ''BlockIx)
getInt :: S.Get Int
getInt = fromIntegral <$> S.getWord32be
{-# INLINE getInt #-}
putInt :: S.Putter Int
putInt = S.putWord32be . fromIntegral
{-# INLINE putInt #-}
instance Serialize BlockIx where
{-# SPECIALIZE instance Serialize BlockIx #-}
get = BlockIx <$> getInt
<*> getInt
<*> getInt
{-# INLINE get #-}
put BlockIx {..} = do
putInt ixPiece
putInt ixOffset
putInt ixLength
{-# INLINE put #-}
instance Pretty BlockIx where
pretty BlockIx {..} =
"piece = " <> int ixPiece <> "," <+>
"offset = " <> int ixOffset <> "," <+>
"length = " <> int ixLength
-- | Get location of payload bytes in the torrent content.
blockIxRange :: (Num a, Integral a) => PieceSize -> BlockIx -> (a, a)
blockIxRange pieceSize BlockIx {..} = (offset, offset + len)
where
offset = fromIntegral pieceSize * fromIntegral ixPiece
+ fromIntegral ixOffset
len = fromIntegral ixLength
{-# INLINE blockIxRange #-}
{-----------------------------------------------------------------------
Block
-----------------------------------------------------------------------}
data Block payload = Block {
-- | Zero-based piece index.
blkPiece :: {-# UNPACK #-} !PieceIx
-- | Zero-based byte offset within the piece.
, blkOffset :: {-# UNPACK #-} !BlockOffset
-- | Payload bytes.
, blkData :: !payload
} deriving (Show, Eq, Functor, Typeable)
-- | Payload is ommitted.
instance Pretty (Block Lazy.ByteString) where
pretty = pretty . blockIx
{-# INLINE pretty #-}
-- | Get size of block /payload/ in bytes.
blockSize :: Block Lazy.ByteString -> BlockSize
blockSize blk = fromIntegral (Lazy.length (blkData blk))
{-# INLINE blockSize #-}
-- | Get block index of a block.
blockIx :: Block Lazy.ByteString -> BlockIx
blockIx = BlockIx <$> blkPiece <*> blkOffset <*> blockSize
-- | Get location of payload bytes in the torrent content.
blockRange :: (Num a, Integral a) => PieceSize -> Block Lazy.ByteString -> (a, a)
blockRange pieceSize = blockIxRange pieceSize . blockIx
{-# INLINE blockRange #-}
|
