kp-torrent
2 | 3 |
4 |
5 | 
7 |
8 |
9 |
10 |
7 |
8 |
11 | Bittorrent Client
12 |
13 | 14 | 15 |
16 |
17 | [](https://opensource.org/licenses/MIT)
18 | [](https://www.python.org/)
19 | 
20 |
21 |
22 |
23 | Built by
24 | Kishan Patel and
25 |
26 |
27 | ## Installation and Build :hammer_and_wrench:
28 |
29 | * Clone is repository on your local unix machine and step in the main directory
30 | ```
31 | $ git clone https://github.com/kishanpatel22/bittorrent.git
32 | $ cd bittorrent
33 | ```
34 |
35 | * If you don't have pipenv package then install it using command, else ignore below command
36 | ```
37 | $ pip3 install pipenv
38 | ```
39 |
40 | * Enter the virtual enviornment and install all dependencies
41 | ```
42 | $ pipenv shell
43 | $ pipenv install --dev
44 | ```
45 |
46 | ## Run :computer:
47 |
48 | * Change directory to source in bittorrent folder and inorder to display help options
49 | ```
50 | $ cd src
51 | $ python3 main.py --help
52 | ```
53 |
54 | * Example for downloading torrent file given destination path for downloading file
55 | ```
56 | $ python3 main.py input_file.torrent -d destination_path/
57 | ```
58 |
59 | * Example for seeding torrent file given given destination path of existing file
60 | ```
61 | $ python3 main.py input_file.torrent -s existing_file_path/
62 | ```
63 |
64 |
65 | ## Motivation
66 |
67 | * Downloading movie, music perhaps game or very large size software if pretty
68 | fun activity using **Bittorrent communication protocol** which helps in
69 | distributing large chunks of data over Internet. Fact is that **one third of
70 | internet traffic contains Bittorrent data packets**, which makes it one of
71 | most interesting and trending topics.
72 |
73 | ## Peer-to-Peer(P2P) Architecture
74 |
75 | * Traditional client-server model is obviously not scalable when many clients
76 | are requesting single server, this leads us to P2P architecture in which instead
77 | of centrailzed server, peers or clients or end hosts itself participate in
78 | distributing data among themself.
79 |
80 | Peer-to-Peer Architecture |
81 | :----------------------------------------------------:|
82 |  |
83 |
84 | * Bittorrent is protocol defined for sharing/exchange of data in peer to peer
85 | architecture designed by designed by **Bram Cohen**. The purpose of Bittorrent
86 | Protocol or BTP/1.0 was to achieve **advantage over plain HTTP when multiple
87 | downloads are possible**. I would recommend reading this page which gives
88 | details about [BTP/1.0](https://wiki.theory.org/index.php/BitTorrentSpecification)
89 |
90 | ## Applications of Bittorrent
91 |
92 | * Amazon Web Services(AWS) **Simple Storage Service**(S3) is scalable internet
93 | based storage service with interface equipped with built-in Bittorrent.
94 |
95 | * Facebook uses BitTorrent to distribute updates to Facebook servers.
96 |
97 | * Open-source free software support their file sharing using Bittorrent
98 | inorder to reduce load on servers. Example - ubantu-iso files.
99 |
100 | * Government of UK used Bittorrent to distribute the details of the tax money
101 | spend by the cittizens.
102 |
103 | **Fun Fact** - In 2011, BitTorrent had 100 million users and a greater share
104 | of network bandwidth than Netflix and Hulu combined.
105 |
106 | ## [Bittorrent Client](https://en.wikipedia.org/wiki/BitTorrent)
107 |
108 | * **Bittorrent protocol is application layer protocol**, since it replies on the
109 | services provided by the lower 4 levels of TCP/IP Internet model for sharing
110 | the data. It is the application layer where the Bittorrent Client is written
111 | such that following a set of rules or protocols it will exchange the data
112 | among the peers(ends hosts).
113 |
114 | * In the project, I have made bittorrent client application program in
115 | python3, which follows the Bittorrent protocols for downloading and
116 | uploading files among serveral peers.
117 |
118 | ## Bittorrent File distribution process entities
119 |
120 | | Entity Names | Significance |
121 | |-------------------|-----------------------------------------------------------------------------------------------------------|
122 | | **.torrent file** | contains details of trackers, file name, size, info hash, etc regarding file being distributed |
123 | | **Tracker** | It keeps state of the peers which are active in swarm and what part of files each peer has |
124 | | **peers** | End systems which may or may not have compelete file but are participating the file distribution |
125 | | **PWP** | protocol that end system need to follow inorder to distribute the file among other peers |
126 |
127 | * Peers participating in file sharing lead into dense graph like structure
128 | called **swarm**. The peers are classified into two types leechers(one who
129 | download only) and seeders(one who upload only).
130 |
131 | * The large file being distributed is **divided into number of pieces** which
132 | inturn is divided into number of different chunks/blocks. The data chunks/blocks
133 | are actually shared among the peers by which the whole file gets downloaded.
134 |
135 | Distribution of large file in pieces |
136 | :------------------------------------------------------------:|
137 |  |
138 |
139 | ### Bittorrent tasks
140 |
141 | * [**Parising .torrent**](#reading-torrent-files) : Get .torrent file after that
142 | read the .torrent file and decode the bencoded information. From the extracted
143 | information get Tracker URLs, file size, name, piece length, info hash,
144 | files(if any), etc.
145 |
146 | * [**Tracker**](#tracker) : Communicate with the trackers inorder to know which
147 | peers are participating in the download. The tracker response contains the peer
148 | information which are currently in the swarm.
149 |
150 | * [**PWP**](#peer-wire-protocol) : Peer wire Protocol (PWP) is used to communicate
151 | with all the peers and using peer wire messages(PWM) and download file pieces
152 | from the peers.
153 |
154 | ### [Reading torrent files](https://wiki.theory.org/index.php/BitTorrentSpecification#Metainfo_File_Structure)
155 |
156 | * Files have extention .torrent and contain data about trackers URL, file name,
157 | file size, piece length, info hash and some additional information about
158 | file being distributed.
159 |
160 | * Torrent files are bencoded thus one requires to parse the torrent file and
161 | extract the information about the orginal file being download. Thus
162 | bittorrent client needs write parser for decoding torrent files.
163 |
164 | * Torrent files can be generated for single/multiple files being distributed.
165 | The given below image is output of the torrent parser, however note the
166 | torrent file may contain much more data value than as displayed in image.
167 |
168 | Torrent file bencoded data | Torrent file decoded data
169 | :----------------------------------------:|:-------------------------:
170 |  | 
171 |
172 |
173 | ### [Tracker](http://jonas.nitro.dk/bittorrent/bittorrent-rfc.html#anchor17)
174 |
175 | * Bittorrent client needs to know which all peers are participating in swarm
176 | for distributing the file. The Tracker is server which keeps the track of all
177 | the peers joining, leaving or currently active in the swarm.
178 |
179 | * Tracker also knows how many seeders and leetchers are prenent in the swarm
180 | for distributing a pariticular torrnet file. However note that the tracker
181 | doesn't actual have the torrent file.
182 |
183 | Centrailized Tracker |
184 | :------------------------------------:|
185 |  |
186 |
187 | + [**HTTP/HTTPS trackers**](https://wiki.theory.org/index.php/BitTorrentSpecification#Tracker_HTTP.2FHTTPS_Protocol)
188 | * Trackers which speak the HTTP protocol for responding the swarm(all the
189 | peers) information.
190 | * Client needs to do HTTP get request to the tracker and recieved HTTP
191 | response containing information about the swarm.
192 | * Such type of tracker introduces significant overhead when dealing with
193 | multiple clients at time.
194 |
195 | + [**UDP trackers**](https://libtorrent.org/udp_tracker_protocol.html)
196 | * Trackers which speak UDP protocol, such type of trackers are optimized
197 | and provide less load on tracker severs.
198 | * Since UDP is stateless and provides unreliable service to clients we need
199 | to make multiple request to tracker.
200 | * Client needs to communicate twice to the UDP tracker, once for connection
201 | ID and subsequently using that connectionID recieved for annouce request
202 | for getting swarm information.
203 |
204 | * Trackers urls in torrent files can be absoulte, so client needs to communicate
205 | with all trackers unless it recieves swarm data.
206 |
207 | * A typical tracker response contains random 50 or less peers in the swarm along
208 | with some additional parametes as given below.
209 |
210 | Tracker Response |
211 | :----------------------------------------------------:|
212 |  |
213 |
214 |
215 | ## [Peer Wire Protocol(PWP)](https://wiki.theory.org/BitTorrentSpecification#Peer_wire_protocol_.28TCP.29)
216 |
217 | * According to BTP/1.0 PWP facilitates the exchange of pieces of the file. The
218 | Bittorrent Client maintains the **state information** for each connection
219 | that it has with a remote peer.
220 |
221 | States | Signifance
222 | :----------------:|:-------------------------:
223 | am choking | client is choking the peer
224 | peer choking | peer is choking the client
225 | am interested | client interested in peer
226 | peer interested | peer interested in client
227 |
228 | * Choking here means peer or client being choked will not recieve messages for
229 | their request until unchoke message is recieved.
230 |
231 | peer choking | peer unchoking
232 | :-----------------------------------------------------------:|:-------------------------:
233 | 
| 
234 |
235 | * Initial state of client for **downloading** will be **peer choking = 1** and
236 | **client interested = 0**, similarly for **uploading** the state will be
237 | **client choking = 1** and **peer interested = 0**. Now we start
238 | communicating with peer with these states using **Peer Wire Messages** (PWM)
239 |
240 | #### [Peer Wire Messages](http://jonas.nitro.dk/bittorrent/bittorrent-rfc.html#anchor20)
241 |
242 | * All the peer wire message are send over TCP connection which provides inorder
243 | and reliable bidirectional data communication.
244 |
245 | * **Question : The peer IP and port addresses recieved from tracker will be
246 | behind the NATED gateway how are you going to establish TCP connection ?**
247 |
248 |
249 | Message | Signifance
250 | :----------------:|:-------------------------:
251 | handshake | Initial message to be shared after TCP connection
252 | keep alive | message indicating that the peer connection is still active
253 | choke | peer is choking client
254 | unchoke | peer is unchoking client
255 | interested | peer is interested in client
256 | uninterested | peer is uninterested in client
257 | bitfield | pieces that peer has
258 | have | piece that peer has
259 | request | request for piece to peer
260 | piece | piece data response from peer
261 |
262 | * Along with these there are few more PWM which are not discussed since they
263 | are not implemented in the code. The ideal sequence or exchange of message
264 | after establishing successful TCP connection are given below
265 |
266 | |Message Sequnece | Client side | to/from | Peer side |
267 | |-----------------|-------------------|------------------|---------------------|
268 | |1 | Handshake request | ---> | |
269 | |2 | | <--- | Handshake response |
270 | |3 | | <--- | Bitfield |
271 | |4 | | <--- | Have(optional) |
272 | |5 | Interested | ---> | |
273 | |6 | | <--- | Unchoke/Choke |
274 | |7 | Request1 | ---> | |
275 | |8 | | <--- | Piece1 |
276 | |9 | Request2 | ---> | |
277 | |10 | | <--- | Piece2 |
278 | |k | ... | ---> | |
279 | |k + 1 | | <--- | ... |
280 |
281 |
282 | * However this is ideal case where all the validation of peer wire message is
283 | successful and peer TCP connection is not closed. Example peer could send
284 | choke message in that case subsequent message will get not reply, and
285 | sometimes even handshake message are invalid !
286 |
287 | * Inorder to solve such issues Downloading Finite State Machine is designed
288 | taken into consideration the order in which the messages are exchanged and
289 | client state. The Finite state machine with each state having timeout is
290 | implemented as given below
291 |
292 | Finite State Machine for downloading |
293 | :------------------------------------------------------------:|
294 |  |
295 |
296 | * Typical sequence of event for the downloading woudl look like as given below.
297 |
298 | Sequence of messages in Downloading |
299 | :------------------------------------------------------------:|
300 |  |
301 |
302 | * **Question : How to write into file after receiving the piece message ?**
303 | The solution is initialize the file with the size with null values and as and
304 | when you recieve any of the pieces from the peers write at the proper
305 | location in the file. What to generate is file with many holes.
306 |
307 | #### Downloading torrent file demo
308 |
309 | [](https://asciinema.org/a/yVvtbuvsPJc0tVQYPkwNVVXY9)
310 |
311 |
312 | ## Legal issues with BitTorrent
313 |
314 | * Firstly torrenting is Legal ! It is the protocol used in peer to peer
315 | architecture, but the problem is in the content that we share on torrent that
316 | needs to monitored and must hold permission to share by owner.
317 |
318 | * Copyrighted contents like any new NetFlix web series, any new movie, songs,
319 | some gamming softwares, etc generate many legal issues since first of all
320 | downloading such copyrighted content is illegal (owner can sue you). And it
321 | is actually very hard to monitor over internet the copyrighted bittorrent
322 | traffic, there is even no way to know which people have copy righted content.
323 |
324 | * Make sure whatever you download by Bittorrent doesn't have such issues, and
325 | lastly **enjoy torrenting !**.
326 |
327 |
--------------------------------------------------------------------------------
/src/peer_wire_messages.py:
--------------------------------------------------------------------------------
1 | import struct
2 | from torrent_error import *
3 |
4 | """
5 | As per Peer Wire Protocol all the messages exchanged in between
6 | any two peers are of format given below
7 |
8 | -----------------------------------------
9 | | Message Length | Message ID | Payload |
10 | -----------------------------------------
11 |
12 | Message Lenght (4 bytes) : length of message, excluding length part itself.
13 | Message ID (1 bytes) : defines the 9 different types of messages
14 | Payload : variable length stream of bytes
15 |
16 | """
17 |
18 | # constants indicating ID's for each message
19 | KEEP_ALIVE = None
20 | CHOKE = 0
21 | UNCHOKE = 1
22 | INTERESTED = 2
23 | UNINTERESTED = 3
24 | HAVE = 4
25 | BITFIELD = 5
26 | REQUEST = 6
27 | PIECE = 7
28 | CANCEL = 8
29 | PORT = 9
30 |
31 |
32 | # constant handshake message length
33 | HANDSHAKE_MESSAGE_LENGTH = 68
34 |
35 | # constants indicating the message sizes in PWM
36 | MESSAGE_LENGTH_SIZE = 4
37 | MESSAGE_ID_SIZE = 1
38 |
39 |
40 | """ class for general peer message exchange in P2P bittorrent """
41 | class peer_wire_message():
42 |
43 | # initalizes the attributes of peer wire message
44 | def __init__(self, message_length, message_id, payload):
45 | self.message_length = message_length
46 | self.message_id = message_id
47 | self.payload = payload
48 |
49 | # returns raw bytes as peer message
50 | def message(self):
51 | # pack the message length
52 | message = struct.pack("!I", self.message_length)
53 | # pack the message ID if present in message
54 | if self.message_id != None:
55 | message += struct.pack("!B", self.message_id)
56 | # pack the paylaod is specified
57 | if self.payload != None:
58 | message += self.payload
59 | return message
60 |
61 | # printing the peer wire message
62 | def __str__(self):
63 | message = 'PEER WIRE MESSAGE : '
64 | message += '(message length : ' + str(self.message_length) + '), '
65 | if self.message_id is None:
66 | message += '(message id : None), '
67 | else:
68 | message += '(message id : ' + str(self.message_id) + '), '
69 | if self.payload is None:
70 | message += '(protocol length : None)'
71 | else:
72 | message += '(payload length : ' + str(len(self.payload)) + ')'
73 | return message
74 |
75 |
76 |
77 | """ class for creating handshake messages between the peers """
78 | class handshake():
79 | # initialize the handshake with the paylaod
80 | def __init__(self, info_hash, client_peer_id):
81 | # protocol name : BTP
82 | self.protocol_name = "BitTorrent protocol"
83 | # client peer info hash
84 | self.info_hash = info_hash
85 | # client peer id
86 | self.client_peer_id = client_peer_id
87 |
88 |
89 | # creates the handshake payload for peer wire protocol handshake
90 | def message(self):
91 | # first bytes the length of protocol name default - 19
92 | handshake_message = struct.pack("!B", len(self.protocol_name))
93 | # protocol name 19 bytes
94 | handshake_message += struct.pack("!19s", self.protocol_name.encode())
95 | # next 8 bytes reserved
96 | handshake_message += struct.pack("!Q", 0x0)
97 | # next 20 bytes info hash
98 | handshake_message += struct.pack("!20s", self.info_hash)
99 | # next 20 bytes peer id
100 | handshake_message += struct.pack("!20s", self.client_peer_id)
101 | # returns the handshake payload
102 | return handshake_message
103 |
104 |
105 | # validate the response handshake on success returns validated handshake
106 | # else raise the error that occured in handshake validation
107 | def validate_handshake(self, response_handshake):
108 |
109 | # compare the handshake length
110 | response_handshake_length = len(response_handshake)
111 | if(response_handshake_length != HANDSHAKE_MESSAGE_LENGTH):
112 | err_msg = 'invalid handshake length ( ' + str(response_handshake_length) + 'B )'
113 | torrent_error(err_msg)
114 |
115 | # extract the info hash of torrent
116 | peer_info_hash = response_handshake[28:48]
117 | # extract the peer id
118 | peer_id = response_handshake[48:68]
119 |
120 | # check if the info hash is equal
121 | if(peer_info_hash != self.info_hash):
122 | err_msg = 'info hash with peer of torrnet do not match !'
123 | torrent_error(err_msg)
124 | # check if peer has got a unique id associated with it
125 | if(peer_id == self.client_peer_id):
126 | err_msg = 'peer ID and client ID both match drop connection !'
127 | torrent_error(err_msg)
128 |
129 | # succesfully validating returns the handshake response
130 | return handshake(peer_info_hash, peer_id)
131 |
132 | """
133 | =========================================================================
134 | PEER WIRE PROTOCOL MESSAGES
135 | =========================================================================
136 | """
137 |
138 |
139 | """
140 | This message is send to remote peer to indicate that
141 | it is still alive and participating in file sharing.
142 | """
143 | class keep_alive(peer_wire_message):
144 | def __init__(self):
145 | message_length = 0 # 4 bytes message length
146 | message_id = KEEP_ALIVE # no message ID
147 | payload = None # no payload
148 | super().__init__(message_length, message_id, payload)
149 |
150 | def __str__(self):
151 | message = 'KEEP ALIVE : '
152 | message += '(message length : ' + str(self.message_length) + '), '
153 | message += '(message id : None), '
154 | message += '(message paylaod : None)'
155 | return message
156 |
157 |
158 |
159 |
160 | """ This message is send to remote peer informing
161 | remote peer is begin choked
162 | """
163 | class choke(peer_wire_message):
164 | def __init__(self):
165 | message_length = 1 # 4 bytes message length
166 | message_id = CHOKE # 1 byte message ID
167 | payload = None # no payload
168 | super().__init__(message_length, message_id, payload)
169 |
170 | def __str__(self):
171 | message = 'CHOKE : '
172 | message += '(message length : ' + str(self.message_length) + '), '
173 | message += '(message id : ' + str(self.message_id) + '), '
174 | message += '(message paylaod : None)'
175 | return message
176 |
177 |
178 |
179 |
180 | """ This message is send to remote peer informing
181 | remote peer is no longer being choked
182 | """
183 | class unchoke(peer_wire_message):
184 | def __init__(self):
185 | message_length = 1 # 4 bytes message length
186 | message_id = UNCHOKE # 1 byte message ID
187 | payload = None # no payload
188 | super().__init__(message_length, message_id, payload)
189 |
190 | def __str__(self):
191 | message = 'UNCHOKE : '
192 | message += '(message length : ' + str(self.message_length) + '), '
193 | message += '(message id : ' + str(self.message_id) + '), '
194 | message += '(message paylaod : None)'
195 | return message
196 |
197 |
198 |
199 | """
200 | This message is send to remote peer informing
201 | remote peer its desire to request data
202 | """
203 | class interested(peer_wire_message):
204 | def __init__(self):
205 | message_length = 1 # 4 bytes message length
206 | message_id = INTERESTED # 1 byte message ID
207 | payload = None # no payload
208 | super().__init__(message_length, message_id, payload)
209 |
210 | def __str__(self):
211 | message = 'INTERESTED : '
212 | message += '(message length : ' + str(self.message_length) + '), '
213 | message += '(message id : ' + str(self.message_id) + '), '
214 | message += '(message paylaod : None)'
215 | return message
216 |
217 |
218 |
219 | """
220 | This message is send to remote peer informing remote
221 | peer it's not interested in any pieces from it
222 | """
223 | class uninterested(peer_wire_message):
224 | def __init__(self):
225 | message_length = 1 # 4 bytes message length
226 | message_id = UNINTERESTED # 1 byte message ID
227 | payload = None # no payload
228 | super().__init__(message_length, message_id, payload)
229 |
230 | def __str__(self):
231 | message = 'UNINTERESTED : '
232 | message += '(message length : ' + str(self.message_length) + '), '
233 | message += '(message id : ' + str(self.message_id) + '), '
234 | message += '(message paylaod : None)'
235 | return message
236 |
237 |
238 |
239 | """
240 | This message tells the remote peers what pieces
241 | does the client peer has succesfully downloaded
242 | """
243 | class have(peer_wire_message):
244 | # initializes the message with given paylaod
245 | def __init__(self, piece_index):
246 | message_length = 5 # 4 bytes message length
247 | message_id = HAVE # 1 byte message ID
248 | payload = struct.pack("!I", piece_index) # 4 bytes payload
249 | super().__init__(message_length, message_id, payload)
250 | # actual payload data to be associated with object
251 | self.piece_index = piece_index
252 |
253 | def __str__(self):
254 | message = 'HAVE : '
255 | message += '(message length : ' + str(self.message_length) + '), '
256 | message += '(message id : ' + str(self.message_id) + '), '
257 | message += '(message paylaod : [piece index : ' + str(self.piece_index) + '])'
258 | return message
259 |
260 |
261 |
262 | """
263 | This message must be send immediately after handshake, telling the client
264 | peer what peicies does the remote peer has. However the client peer may
265 | avoid replying this message in case if doesn't have any pieces downloaded
266 | """
267 | class bitfield(peer_wire_message):
268 | # initialize the message with pieces information
269 | def __init__(self, pieces_info):
270 | message_length = 1 + len(pieces_info) # 4 bytes message length
271 | message_id = BITFIELD # 1 byte message id
272 | payload = pieces_info # variable length payload
273 | super().__init__(message_length, message_id, payload)
274 | # actual payload data to be associated with object
275 | self.pieces_info = pieces_info
276 |
277 |
278 | # extract downloaded pieces from bitfield send by peer
279 | def extract_pieces(self):
280 | bitfield_pieces = set([])
281 | # for every bytes value in payload check for its bits
282 | for i, byte_value in enumerate(self.payload):
283 | for j in range(8):
284 | # check if jth bit is set
285 | if((byte_value >> j) & 1):
286 | piece_number = i * 8 + 7 - j
287 | bitfield_pieces.add(piece_number)
288 | # return the extracted bitfield pieces
289 | return bitfield_pieces
290 |
291 |
292 | def __str__(self):
293 | message = 'BITFIELD : '
294 | message += '(message paylaod : [bitfield length : ' + str(len(self.pieces_info)) + '])'
295 | return message
296 |
297 |
298 |
299 | """
300 | This message is send inorder to request a piece of block for the remote peer
301 | The payload is defined as given below
302 | | Piece Index(4 bytes) | Block Offset(4 bytes) | Block Length(4 bytes) |
303 | """
304 | class request(peer_wire_message):
305 | # request message for any given block from any piece
306 | def __init__(self, piece_index, block_offset, block_length):
307 | message_length = 13 # 4 bytes message length
308 | message_id = REQUEST # 1 byte message id
309 | payload = struct.pack("!I", piece_index) # 12 bytes payload
310 | payload += struct.pack("!I", block_offset)
311 | payload += struct.pack("!I", block_length)
312 | super().__init__(message_length, message_id, payload)
313 | # actual payload data to be associated with object
314 | self.piece_index = piece_index
315 | self.block_offset = block_offset
316 | self.block_length = block_length
317 |
318 |
319 | def __str__(self):
320 | message = 'REQUEST : '
321 | message += '(message paylaod : [ '
322 | message += 'piece index : ' + str(self.piece_index) + ', '
323 | message += 'block offest : ' + str(self.block_offset) + ', '
324 | message += 'block length : ' + str(self.block_length) + ' ])'
325 | return message
326 |
327 |
328 | """
329 | This message is used to exchange the data among the peers. The payload for
330 | the message as given below
331 | | index(index of piece) | begin(offest within piece) | block(actual data) |
332 | """
333 | class piece(peer_wire_message):
334 | # the piece message for any block data from file
335 | def __init__(self, piece_index, block_offset, block):
336 | message_length = 9 + len(block) # 4 bytes message length
337 | message_id = PIECE # 1 byte message id
338 | payload = struct.pack("!I", piece_index) # variable length payload
339 | payload += struct.pack("!I", block_offset)
340 | payload += block
341 | super().__init__(message_length, message_id, payload)
342 | # actual payload data to be associated with object
343 | self.piece_index = piece_index
344 | self.block_offset = block_offset
345 | self.block = block
346 |
347 | def __str__(self):
348 | message = 'PIECE : '
349 | message += '(message paylaod : [ '
350 | message += 'piece index : ' + str(self.piece_index) + ', '
351 | message += 'block offest : ' + str(self.block_offset) + ', '
352 | message += 'block length : ' + str(len(self.block)) + ' ])'
353 | return message
354 |
355 | """
356 | function helps in creating the bitfield message given the bitfield set
357 | """
358 | def create_bitfield_message(bitfield_pieces, total_pieces):
359 | bitfield_payload = b''
360 | piece_byte = 0
361 | # check for every torrent piece in bitfield
362 | for i in range(total_pieces):
363 | if i in bitfield_pieces:
364 | piece_byte = piece_byte | (2 ** 8)
365 | piece_byte = piece_byte >> 1
366 | if (i + 1) % 8 == 0:
367 | bitfield_payload += struct.pack("!B", piece_byte)
368 | piece_byte = 0
369 |
370 | # adding the last piece_bytes
371 | if total_pieces % 8 != 0:
372 | bitfield_payload += struct.pack("!B", piece_byte)
373 |
374 | return bitfield(bitfield_payload)
375 |
376 |
377 | """
378 | The class helps in decoding any general peer wire message into its
379 | appropriate message type object instance
380 | """
381 | class peer_message_decoder():
382 |
383 | # initialize peer_message_decoder with given peer wire message instance
384 | def decode(self, peer_message):
385 |
386 | # deocdes the given peer_message
387 | if peer_message.message_id == KEEP_ALIVE :
388 | self.peer_decoded_message = keep_alive()
389 |
390 | elif peer_message.message_id == CHOKE :
391 | self.peer_decoded_message = choke()
392 |
393 | elif peer_message.message_id == UNCHOKE :
394 | self.peer_decoded_message = unchoke()
395 |
396 | elif peer_message.message_id == INTERESTED :
397 | self.peer_decoded_message = interested()
398 |
399 | elif peer_message.message_id == UNINTERESTED :
400 | self.peer_decoded_message = uninterested()
401 |
402 | elif peer_message.message_id == HAVE :
403 | piece_index = struct.unpack_from("!I", peer_message.payload)[0]
404 | self.peer_decoded_message = have(piece_index)
405 |
406 | elif peer_message.message_id == BITFIELD :
407 | self.peer_decoded_message = bitfield(peer_message.payload)
408 |
409 | elif peer_message.message_id == REQUEST :
410 | piece_index = struct.unpack_from("!I", peer_message.payload, 0)[0]
411 | block_offset = struct.unpack_from("!I", peer_message.payload, 4)[0]
412 | block_length = struct.unpack_from("!I", peer_message.payload, 8)[0]
413 | self.peer_decoded_message = request(piece_index, block_offset, block_length)
414 |
415 | elif peer_message.message_id == PIECE :
416 | piece_index = struct.unpack_from("!I", peer_message.payload, 0)[0]
417 | begin_offset = struct.unpack_from("!I", peer_message.payload, 4)[0]
418 | block = peer_message.payload[8:]
419 | self.peer_decoded_message = piece(piece_index, begin_offset, block)
420 |
421 | # TODO : implement cancel and port
422 | elif peer_message.message_id == CANCEL :
423 | self.peer_decoded_message = None
424 |
425 | elif peer_message.message_id == PORT :
426 | self.peer_decoded_message = None
427 | else:
428 | self.peer_decoded_message = None
429 |
430 | # returns the peer decoded message
431 | return self.peer_decoded_message
432 |
433 |
434 | # creating object instance of type decoder
435 | PEER_MESSAGE_DECODER = peer_message_decoder()
436 |
437 |
438 |
--------------------------------------------------------------------------------
/src/tracker.py:
--------------------------------------------------------------------------------
1 | import sys
2 | import time
3 | import requests
4 | import bencodepy
5 | import random as rd
6 | import struct
7 |
8 |
9 | # torrent logger module for execution logging
10 | from torrent_logger import *
11 |
12 | # torrent error module for handling the exception
13 | from torrent_error import *
14 |
15 | # module for printing data in Tabular format
16 | from beautifultable import BeautifulTable
17 |
18 | # socket module for tracker requests
19 | from socket import *
20 |
21 | """
22 | Trackers are required to obtain the list of peers currently participating
23 | in the file sharing process and client must know how to communicate with
24 | the list of trackers provided in the torrent file
25 | """
26 |
27 |
28 | """
29 | Tracker class stores the information that is needed for communicating with
30 | the tracker URL servers. The request paramters are included as given below
31 | """
32 | class tracker_data():
33 | # contructs the tracker request data
34 | def __init__(self, torrent):
35 | self.compact = 1
36 | # the request parameters of the torrent
37 | self.request_parameters = {
38 | 'info_hash' : torrent.torrent_metadata.info_hash,
39 | 'peer_id' : torrent.peer_id,
40 | 'port' : torrent.client_port,
41 | 'uploaded' : torrent.statistics.num_pieces_uploaded,
42 | 'downloaded': torrent.statistics.num_pieces_downloaded,
43 | 'left' : torrent.statistics.num_pieces_left,
44 | 'compact' : self.compact
45 | }
46 | self.interval = None
47 | self.complete = None
48 | self.incomplete = None
49 | self.peers_list = []
50 |
51 |
52 |
53 | """
54 | Class HTTP torrent tracker helps the client communicate to any HTTP torrent
55 | tracker. However the base class containing data of torrent remains the
56 | same only way to communicate changes
57 | """
58 | class http_torrent_tracker(tracker_data):
59 |
60 | # contructor : initializes the torrent information
61 | def __init__(self, torrent, tracker_url):
62 | super().__init__(torrent)
63 | self.tracker_url = tracker_url
64 | # tracker logger
65 | self.tracker_logger = torrent_logger(self.tracker_url, TRACKER_LOG_FILE, DEBUG)
66 |
67 | # attempts to connect to HTTP tracker
68 | # returns true if conncetion is established false otherwise
69 | def request_torrent_information(self):
70 | # try establishing a connection to the tracker
71 | try:
72 | # the reponse from HTTP tracker is an bencoded dictionary
73 | bencoded_response = requests.get(self.tracker_url, self.request_parameters, timeout=5)
74 | # decode the bencoded dictionary to python ordered dictionary
75 | raw_response_dict = bencodepy.decode(bencoded_response.content)
76 | # parse the dictionary containing raw data
77 | self.parse_http_tracker_response(raw_response_dict)
78 | return True
79 | except Exception as error_msg:
80 | # cannont establish a connection with the tracker
81 | self.tracker_logger.log(self.tracker_url + ' connection failed !' + FAILURE)
82 | return False
83 |
84 | # extract the important information for the HTTP response dictionary
85 | def parse_http_tracker_response(self, raw_response_dict):
86 |
87 | # interval : specifies minimum time client show wait for sending next request
88 | if b'interval' in raw_response_dict:
89 | self.interval = raw_response_dict[b'interval']
90 |
91 | # list of peers form the participating the torrent
92 | if b'peers' in raw_response_dict:
93 | self.peers_list = []
94 | # extract the raw peers data
95 | raw_peers_data = raw_response_dict[b'peers']
96 | # create a list of each peer information which is of 6 bytes
97 | raw_peers_list = [raw_peers_data[i : 6 + i] for i in range(0, len(raw_peers_data), 6)]
98 | # extract all the peer id, peer IP and peer port
99 | for raw_peer_data in raw_peers_list:
100 | # extract the peer IP address
101 | peer_IP = ".".join(str(int(a)) for a in raw_peer_data[0:4])
102 | # extract the peer port number
103 | peer_port = raw_peer_data[4] * 256 + raw_peer_data[5]
104 | # append the (peer IP, peer port)
105 | self.peers_list.append((peer_IP, peer_port))
106 |
107 | # number of peers with the entire file aka seeders
108 | if b'complete' in raw_response_dict:
109 | self.complete = raw_response_dict[b'complete']
110 |
111 | # number of non-seeder peers, aka "leechers"
112 | if b'incomplete' in raw_response_dict:
113 | self.incomplete = raw_response_dict[b'incomplete']
114 |
115 | # tracker id must be sent back by the user on announcement
116 | if b'tracker id' in raw_response_dict:
117 | self.tracker_id = raw_response_dict[b'tracker id']
118 |
119 | # API function for creating the getting the peer data recivied by HTTP tracker
120 | def get_peers_data(self):
121 | peer_data = {'interval' : self.interval, 'peers' : self.peers_list,
122 | 'leechers' : self.incomplete, 'seeders' : self.complete}
123 | return peer_data
124 |
125 | # logs the information obtained by the HTTP tracker
126 | def __str__(self):
127 | tracker_table = BeautifulTable()
128 | tracker_table.columns.header = ["HTTP TRACKER RESPONSE DATA", "DATA VALUE"]
129 |
130 | # http tracker URL
131 | tracker_table.rows.append(['HTTP tracker URL', self.tracker_url])
132 | # interval
133 | tracker_table.rows.append(['Interval', str(self.interval)])
134 | # number of leeachers
135 | tracker_table.rows.append(['Number of leechers', str(self.incomplete)])
136 | # number of seeders
137 | tracker_table.rows.append(['Number of seeders', str(self.complete)])
138 | # number of peers recieved
139 | peer_data = '(' + self.peers_list[0][0] + ' : '
140 | peer_data += str(self.peers_list[0][1]) + ')\n'
141 | peer_data += '... ' + str(len(self.peers_list) - 1) + ' more peers'
142 | tracker_table.rows.append(['Peers in swarm', peer_data])
143 |
144 | return str(tracker_table)
145 |
146 |
147 | """
148 | Class UDP torrent tracker helps the client communicate to any UDP torrent
149 | tracker. However the base class data of torrent remains the same only way
150 | to communicate will change. Note that given below class implements the
151 | UDP Tracker Protcol mentioned at "https://libtorrent.org/udp_tracker_protocol.html"
152 | """
153 | class udp_torrent_tracker(tracker_data):
154 |
155 | # contructor : initializes the torrent information
156 | def __init__(self, torrent, tracker_url):
157 | super().__init__(torrent)
158 | # extract the tracker hostname and tracker port number
159 | self.tracker_url, self.tracker_port = self.parse_udp_tracker_url(tracker_url)
160 | # tracker logger
161 | self.tracker_logger = torrent_logger(self.tracker_url, TRACKER_LOG_FILE, DEBUG)
162 |
163 | # connection id : initially a magic number
164 | self.connection_id = 0x41727101980
165 | # action : initially set to connection request action
166 | self.action = 0x0
167 | # transaction id : random id to be set by the client
168 | self.transaction_id = int(rd.randrange(0, 255))
169 |
170 |
171 | # parse the UDP tracker URL : the function returns (hostname, port)
172 | def parse_udp_tracker_url(self, tracker_url):
173 | domain_url = tracker_url[6:].split(':')
174 | udp_tracker_url = domain_url[0]
175 | udp_tracker_port = int(domain_url[1].split('/')[0])
176 | return (udp_tracker_url, udp_tracker_port)
177 |
178 |
179 | # attempts to connect to UDP tracker
180 | # returns true if conncetion is established false otherwise
181 | def request_torrent_information(self):
182 |
183 | # create a socket for sending request and recieving responses
184 | self.tracker_sock = socket(AF_INET, SOCK_DGRAM)
185 | self.tracker_sock.settimeout(5)
186 |
187 | # connection payload for UDP tracker connection request
188 | connection_payload = self.build_connection_payload()
189 |
190 | # attempt connecting and announcing the UDP tracker
191 | try:
192 | # get the connection id from the connection request
193 | self.connection_id = self.udp_connection_request(connection_payload)
194 |
195 | # annouce payload for UDP tracker
196 | announce_payload = self.build_announce_payload()
197 | self.raw_announce_reponse = self.udp_announce_request(announce_payload)
198 |
199 | # extract the peers IP, peer port from the announce response
200 | self.parse_udp_tracker_response(self.raw_announce_reponse)
201 |
202 | # close the socket once the reponse is obtained
203 | self.tracker_sock.close()
204 |
205 | if self.peers_list and len(self.peers_list) != 0:
206 | return True
207 | else:
208 | return False
209 | except Exception as error_msg:
210 | self.tracker_logger.log(self.tracker_url + str(error_msg) + FAILURE)
211 | # close the socket if the response is not obtained
212 | self.tracker_sock.close()
213 | return False
214 |
215 |
216 | # creates the connection payload for the UDP tracker
217 | def build_connection_payload(self):
218 | req_buffer = struct.pack("!q", self.connection_id) # first 8 bytes : connection_id
219 | req_buffer += struct.pack("!i", self.action) # next 4 bytes : action
220 | req_buffer += struct.pack("!i", self.transaction_id) # next 4 bytes : transaction_id
221 | return req_buffer
222 |
223 |
224 | # recieves the connection reponse from the tracker
225 | def udp_connection_request(self, connection_payload):
226 | # send the connection payload to the tracker
227 | self.tracker_sock.sendto(connection_payload, (self.tracker_url, self.tracker_port))
228 | # recieve the raw connection data
229 | try:
230 | raw_connection_data, conn = self.tracker_sock.recvfrom(2048)
231 | except :
232 | raise torrent_error('UDP tracker connection request failed')
233 |
234 | return self.parse_connection_response(raw_connection_data)
235 |
236 |
237 | # extracts the reponse connection id send by UDP tracker
238 | # function also check if tracker not send appropriate response
239 | def parse_connection_response(self, raw_connection_data):
240 | # check if it is less than 16 bytes
241 | if(len(raw_connection_data) < 16):
242 | raise torrent_error('UDP tracker wrong reponse length of connection ID !')
243 |
244 | # extract the reponse action : first 4 bytes
245 | response_action = struct.unpack_from("!i", raw_connection_data)[0]
246 | # error reponse from tracker
247 | if response_action == 0x3:
248 | error_msg = struct.unpack_from("!s", raw_connection_data, 8)
249 | raise torrent_error('UDP tracker reponse error : ' + error_msg)
250 |
251 | # extract the reponse transaction id : next 4 bytes
252 | response_transaction_id = struct.unpack_from("!i", raw_connection_data, 4)[0]
253 | # compare the request and response transaction id
254 | if(response_transaction_id != self.transaction_id):
255 | raise torrent_error('UDP tracker wrong response transaction ID !')
256 |
257 | # extract the response connection id : next 8 bytes
258 | reponse_connection_id = struct.unpack_from("!q", raw_connection_data, 8)[0]
259 | return reponse_connection_id
260 |
261 |
262 | # returns the annouce request payload
263 | def build_announce_payload(self):
264 | # action = 1 (annouce)
265 | self.action = 0x1
266 | # first 8 bytes connection_id
267 | announce_payload = struct.pack("!q", self.connection_id)
268 | # next 4 bytes is action
269 | announce_payload += struct.pack("!i", self.action)
270 | # next 4 bytes is transaction id
271 | announce_payload += struct.pack("!i", self.transaction_id)
272 | # next 20 bytes the info hash string of the torrent
273 | announce_payload += struct.pack("!20s", self.request_parameters['info_hash'])
274 | # next 20 bytes the peer_id
275 | announce_payload += struct.pack("!20s", self.request_parameters['peer_id'])
276 | # next 8 bytes the number of bytes downloaded
277 | announce_payload += struct.pack("!q", self.request_parameters['downloaded'])
278 | # next 8 bytes the left bytes
279 | announce_payload += struct.pack("!q", self.request_parameters['left'])
280 | # next 8 bytes the number of bytes uploaded
281 | announce_payload += struct.pack("!q", self.request_parameters['uploaded'])
282 | # event 2 denotes start of downloading
283 | announce_payload += struct.pack("!i", 0x2)
284 | # your IP address, set this to 0 if you want the tracker to use the sender
285 | announce_payload += struct.pack("!i", 0x0)
286 | # some random key
287 | announce_payload += struct.pack("!i", int(rd.randrange(0, 255)))
288 | # number of peers require, set this to -1 by defualt
289 | announce_payload += struct.pack("!i", -1)
290 | # port on which response will be sent
291 | announce_payload += struct.pack("!H", self.request_parameters['port'])
292 | # extension is by default 0x2 which is request string
293 | # announce_payload += struct.pack("!H", 0x2)
294 | return announce_payload
295 |
296 |
297 | # recieves the announce reponse from the tracker
298 | # UDP beign an unreliable protocol the function attemps
299 | # some trails for requests the annouce response
300 | def udp_announce_request(self, announce_payload):
301 | raw_announce_data = None
302 | trails = 0
303 | while(trails < 8):
304 | # try connection request after some interval of time
305 | try:
306 | self.tracker_sock.sendto(announce_payload, (self.tracker_url, self.tracker_port))
307 | # recieve the raw announce data
308 | raw_announce_data, conn = self.tracker_sock.recvfrom(2048)
309 | break
310 | except:
311 | error_log = self.tracker_url + ' failed announce request attempt ' + str(trails + 1)
312 | self.tracker_logger.log(error_log + FAILURE)
313 | trails = trails + 1
314 | return raw_announce_data
315 |
316 |
317 | # parses the UDP tracker annouce response
318 | def parse_udp_tracker_response(self, raw_announce_reponse):
319 | if(len(raw_announce_reponse) < 20):
320 | raise torrent_error('Invalid response length in announcing!')
321 |
322 | # first 4 bytes is action
323 | response_action = struct.unpack_from("!i", raw_announce_reponse)[0]
324 | # next 4 bytes is transaction id
325 | response_transaction_id = struct.unpack_from("!i", raw_announce_reponse, 4)[0]
326 | # compare for the transaction id
327 | if response_transaction_id != self.transaction_id:
328 | raise torrent_error('The transaction id in annouce response do not match')
329 |
330 | # check if the response contains any error message
331 | if response_action != 0x1:
332 | error_msg = struct.unpack_from("!s", raw_announce_reponse, 8)
333 | raise torrent_error("Error while annoucing: %s" % error_msg)
334 |
335 | offset = 8
336 | # interval : specifies minimum time client show wait for sending next request
337 | self.interval = struct.unpack_from("!i", raw_announce_reponse, offset)[0]
338 |
339 | offset = offset + 4
340 | # leechers : the peers not uploading anything
341 | self.leechers = struct.unpack_from("!i", raw_announce_reponse, offset)[0]
342 |
343 | offset = offset + 4
344 | # seeders : the peers uploading the file
345 | self.seeders = struct.unpack_from("!i", raw_announce_reponse, offset)[0]
346 |
347 | offset = offset + 4
348 | # obtains the peers list of (peer IP, peer port)
349 | self.peers_list = []
350 | while(offset != len(raw_announce_reponse)):
351 | # raw data of peer IP, peer port
352 | raw_peer_data = raw_announce_reponse[offset : offset + 6]
353 |
354 | # extract the peer IP address
355 | peer_IP = ".".join(str(int(a)) for a in raw_peer_data[0:4])
356 | # extract the peer port number
357 | peer_port = raw_peer_data[4] * 256 + raw_peer_data[5]
358 |
359 | # append to IP, port tuple to peer list
360 | self.peers_list.append((peer_IP, peer_port))
361 | offset = offset + 6
362 |
363 |
364 | # API function for creating the getting the peer data recivied by UDP tracker
365 | def get_peers_data(self):
366 | peer_data = {'interval' : self.interval, 'peers' : self.peers_list,
367 | 'leechers' : self.leechers, 'seeders' : self.seeders}
368 | return peer_data
369 |
370 |
371 | # ensure that socket used for tracker request is closed
372 | def __exit__(self):
373 | self.tracker_sock.close()
374 |
375 |
376 | # logs the information obtained by the HTTP tracker
377 | def __str__(self):
378 | tracker_table = BeautifulTable()
379 | tracker_table.columns.header = ["UDP TRACKER RESPONSE DATA", "DATA VALUE"]
380 |
381 | # http tracker URL
382 | tracker_table.rows.append(['UDP tracker URL', self.tracker_url])
383 | # interval
384 | tracker_table.rows.append(['Interval', str(self.interval)])
385 | # number of leeachers
386 | tracker_table.rows.append(['Number of leechers', str(self.leechers)])
387 | # number of seeders
388 | tracker_table.rows.append(['Number of seeders', str(self.seeders)])
389 | # number of peers recieved
390 | peer_data = '(' + self.peers_list[0][0] + ' : '
391 | peer_data += str(self.peers_list[0][1]) + ')\n'
392 | peer_data += '... ' + str(len(self.peers_list) - 1) + ' more peers'
393 | tracker_table.rows.append(['Peers in swarm', peer_data])
394 |
395 | return str(tracker_table)
396 |
397 |
398 |
399 | """
400 | Torrent tracker class helps then client to connect to any of the trackers
401 | provided. Note it will identify http or udp trackers and will communicate
402 | with them accordingly
403 | """
404 | class torrent_tracker():
405 |
406 | # contructors initializes a torernt tracker connection given
407 | # the tracker urls from the torrent metadata file
408 | def __init__(self, torrent):
409 | # the responding tracker instance for client
410 | self.client_tracker = None
411 |
412 | # connection status of the trackers
413 | self.connection_success = 1
414 | self.connection_failure = 2
415 | self.connection_not_attempted = 3
416 |
417 | # trackers loggers object
418 | self.trackers_logger = torrent_logger('trackers', TRACKER_LOG_FILE, DEBUG)
419 |
420 | # get all the trackers list of the torrent data
421 | self.trackers_list = []
422 | self.trackers_connection_status = []
423 |
424 | for tracker_url in torrent.torrent_metadata.trackers_url_list:
425 | # classify HTTP and UDP torrent trackers
426 | if 'http' in tracker_url[:4]:
427 | tracker = http_torrent_tracker(torrent, tracker_url)
428 | if 'udp' in tracker_url[:4]:
429 | tracker = udp_torrent_tracker(torrent, tracker_url)
430 | # append the tracker class instance
431 | self.trackers_list.append(tracker)
432 | # append the connection status
433 | self.trackers_connection_status.append(self.connection_not_attempted)
434 |
435 | # the torrent tracker requests for the list of peers
436 | # Note : function attempts to connect to tracker for given all the tracker
437 | # instances and any tracker url reponse is recieved that is retunred
438 | def request_connection(self):
439 | # attempts connecting with any of the tracker obtained in the list
440 | for i, tracker in enumerate(self.trackers_list):
441 | # check if you can request for torrent information
442 | if(tracker.request_torrent_information()):
443 | self.trackers_connection_status[i] = self.connection_success
444 | self.client_tracker = tracker
445 | break
446 | else:
447 | self.trackers_connection_status[i] = self.connection_failure
448 |
449 | # log the information about connecting to trackers
450 | self.trackers_logger.log(str(self))
451 |
452 | # returns tracker instance for which successful connection was established
453 | return self.client_tracker
454 |
455 |
456 |
457 | # logs the tracker connections information
458 | def __str__(self):
459 | trackers_table = BeautifulTable()
460 | trackers_table.columns.header = ["TRACKERS LIST", "CONNECTION STATUS"]
461 |
462 | successful_tracker_url = None
463 |
464 | unsuccessful_tracker_url = None
465 | unsuccessful_tracker_url_count = 0
466 |
467 | not_attempted_tracker_url = None
468 | not_attempted_tracker_url_count = 0
469 |
470 | # trackers and corresponding status connection
471 | for i, status in enumerate(self.trackers_connection_status):
472 | if(status == self.connection_success):
473 | successful_tracker_url = self.trackers_list[i].tracker_url
474 | elif(status == self.connection_failure):
475 | unsuccessful_tracker_url = self.trackers_list[i].tracker_url
476 | unsuccessful_tracker_url_count += 1
477 | else:
478 | not_attempted_tracker_url = self.trackers_list[i].tracker_url
479 | not_attempted_tracker_url_count += 1
480 |
481 | successful_log = successful_tracker_url
482 | trackers_table.rows.append([successful_log, 'successful connection ' + SUCCESS])
483 |
484 | if unsuccessful_tracker_url:
485 | unsuccessful_log = unsuccessful_tracker_url
486 | if unsuccessful_tracker_url_count > 1:
487 | unsuccessful_log += '\n ... ' + str(unsuccessful_tracker_url_count)
488 | unsuccessful_log += ' connections '
489 | trackers_table.rows.append([unsuccessful_log, 'failed connection ' + FAILURE])
490 |
491 | if not_attempted_tracker_url:
492 | not_attempted_log = not_attempted_tracker_url
493 | if not_attempted_tracker_url_count > 1:
494 | not_attempted_log += '\n ... ' + str(not_attempted_tracker_url_count)
495 | not_attempted_log += ' connections '
496 | trackers_table.rows.append([not_attempted_log, 'not attempted connection '])
497 |
498 | return str(trackers_table)
499 |
500 |
501 |
--------------------------------------------------------------------------------
/src/peer.py:
--------------------------------------------------------------------------------
1 | import sys
2 | import time
3 | import struct
4 | import hashlib
5 | from threading import *
6 | from copy import deepcopy
7 |
8 | # user defined libraries
9 | from torrent_error import torrent_error
10 | from torrent_logger import *
11 | from peer_wire_messages import *
12 | from shared_file_handler import torrent_shared_file_handler
13 | from peer_socket import *
14 | from peer_state import *
15 |
16 | """
17 | peer class instance maintains the information about the peer participating
18 | in the file sharing. The class provides function like handshake, request
19 | chunk, etc and also keeps track of upload and download speed.
20 | """
21 | class peer():
22 | # parameterized constructor does the peer class initialization
23 | def __init__(self, peer_IP, peer_port, torrent, init_peer_socket = None):
24 | # peer IP, port and torrent instance
25 | self.IP = peer_IP
26 | self.port = peer_port
27 | self.torrent = deepcopy(torrent)
28 |
29 | # initialize the peer_state
30 | self.state = peer_state()
31 |
32 | # string used for idenfiying the peer
33 | self.unique_id = '(' + self.IP + ' : ' + str(self.port) + ')'
34 |
35 | # unique peer ID recieved from peer
36 | self.peer_id = None
37 |
38 | # maximum download block message length
39 | self.max_block_length = torrent.block_length
40 |
41 | # handshake flag with peer
42 | self.handshake_flag = False
43 |
44 | # bitfield representing which data file pieces peer has
45 | self.bitfield_pieces = set([])
46 |
47 | # peer socket for communication
48 | self.peer_sock = peer_socket(self.IP, self.port, init_peer_socket)
49 |
50 | # file handler used for reading/writing the file file
51 | self.file_handler = None
52 |
53 | # peer logger object with unique ID
54 | logger_name = 'peer' + self.unique_id
55 | self.peer_logger = torrent_logger(logger_name, PEER_LOG_FILE, DEBUG)
56 | if torrent.client_request['seeding'] != None:
57 | self.peer_logger.set_console_logging()
58 |
59 | # response message handler for recieved message
60 | self.response_handler = { KEEP_ALIVE : self.recieved_keep_alive,
61 | CHOKE : self.recieved_choke,
62 | UNCHOKE : self.recieved_unchoke,
63 | INTERESTED : self.recieved_interested,
64 | UNINTERESTED : self.recieved_uninterested,
65 | HAVE : self.recieved_have,
66 | BITFIELD : self.recieved_bitfield,
67 | REQUEST : self.recieved_request,
68 | PIECE : self.recieved_piece,
69 | CANCEL : self.recieved_cancel,
70 | PORT : self.recieved_port }
71 |
72 | # keep alive timeout : 10 second
73 | self.keep_alive_timeout = 10
74 | # keep alive timer
75 | self.keep_alive_timer = None
76 |
77 |
78 | """
79 | initializes the socket for seeding the torrent
80 | """
81 | def initialize_seeding(self):
82 | # first make the socket start seeding
83 | self.peer_sock.start_seeding()
84 |
85 | """
86 | sets all the bitfield values
87 | """
88 | def set_bitfield(self):
89 | for i in range(self.torrent.pieces_count):
90 | self.bitfield_pieces.add(i)
91 |
92 | """
93 | function attempts to recieve any external TCP connection
94 | returns the connection socket and address if connection
95 | if recieved else returns None
96 | """
97 | def recieve_connection(self):
98 | return self.peer_sock.accept_connection()
99 |
100 | """
101 | attempts to connect the peer using TCP connection
102 | returns success/failure for the peer connection
103 | """
104 | def send_connection(self):
105 | connection_log = 'SEND CONNECTION STATUS : ' + self.unique_id + ' '
106 | connection_status = None
107 | if self.peer_sock.request_connection():
108 | # user for EXCECUTION LOGGING
109 | connection_log += SUCCESS
110 | connection_status = True
111 | else:
112 | # user for EXCECUTION LOGGING
113 | connection_log += FAILURE
114 | connection_status = False
115 |
116 | self.peer_logger.log(connection_log)
117 | return connection_status
118 |
119 | """
120 | disconnects the peer socket connection
121 | """
122 | def close_peer_connection(self):
123 | self.state.set_null()
124 | self.peer_sock.disconnect()
125 |
126 | """
127 | function helps in recieving data from peers
128 | """
129 | def recieve(self, data_size):
130 | return self.peer_sock.recieve_data(data_size)
131 |
132 | """
133 | function helps send raw data to the peer connection
134 | function sends the complete message to peer
135 | """
136 | def send(self, raw_data):
137 | if not self.peer_sock.send_data(raw_data):
138 | send_log = self.unique_id + ' peer connection closed ! ' + FAILURE
139 | self.peer_logger.log(send_log)
140 | self.close_peer_connection()
141 |
142 | """
143 | function helps in sending peer messgae given peer wire message
144 | class object as an argument to the function
145 | """
146 | def send_message(self, peer_request):
147 | if self.handshake_flag:
148 | # used for EXCECUTION LOGGING
149 | peer_request_log = 'sending message -----> ' + peer_request.__str__()
150 | self.peer_logger.log(peer_request_log)
151 | # send the message
152 | self.send(peer_request.message())
153 |
154 | """
155 | functions helpes in recieving peer wire protocol messages. Note that
156 | function uses low level function to recieve data and creates peer
157 | wire message class object as return value is no had no error and also
158 | only one message is recieved by the given function at any time.
159 | """
160 | def recieve_message(self):
161 | # extract the peer wire message information by receiving chunks of data
162 | # recieve the message length
163 | raw_message_length = self.recieve(MESSAGE_LENGTH_SIZE)
164 | if raw_message_length is None or len(raw_message_length) < MESSAGE_LENGTH_SIZE:
165 | return None
166 |
167 | # unpack the message length which is 4 bytes long
168 | message_length = struct.unpack_from("!I", raw_message_length)[0]
169 | # keep alive messages have no message ID and payload
170 | if message_length == 0:
171 | return peer_wire_message(message_length, None, None)
172 |
173 | # attempt to recieve the message ID from message
174 | raw_message_ID = self.recieve(MESSAGE_ID_SIZE)
175 | if raw_message_ID is None:
176 | return None
177 |
178 | # unpack the message length which is 4 bytes long
179 | message_id = struct.unpack_from("!B", raw_message_ID)[0]
180 | # messages having no payload
181 | if message_length == 1:
182 | return peer_wire_message(message_length, message_id, None)
183 |
184 | # extract all the payload
185 | payload_length = message_length - 1
186 |
187 | # extract the message payload
188 | message_payload = self.recieve(payload_length)
189 | if message_payload is None:
190 | return None
191 |
192 | # keep alive timer updated
193 | self.keep_alive_timer = time.time()
194 | # return peer wire message object given the three parameters
195 | return peer_wire_message(message_length, message_id, message_payload)
196 |
197 | """
198 | functions helps in initiating handshake with peer connection
199 | functions returns success/failure result of handshake
200 | """
201 | def initiate_handshake(self):
202 | # only do handshake if not earlier and established TCP connection
203 | if not self.handshake_flag and self.send_connection():
204 | # send handshake message
205 | handshake_request = self.send_handshake()
206 | # recieve handshake message
207 | raw_handshake_response = self.recieve_handshake()
208 | if raw_handshake_response is None:
209 | return False
210 | # validate the hanshake message recieved obtained
211 | handshake_response = self.handshake_validation(raw_handshake_response)
212 | if handshake_response is None:
213 | return False
214 | # get the client peer id for the handshake response
215 | self.peer_id = handshake_response.client_peer_id
216 | self.handshake_flag = True
217 | # handshake success
218 | return True
219 | # already attempted handshake with the peer
220 | return False
221 |
222 | """
223 | function helps in responding to incoming handshakes
224 | """
225 | def respond_handshake(self):
226 | # if handshake already done then return True
227 | if self.handshake_flag:
228 | return True
229 | # keep alive timer
230 | self.keep_alive_timer = time.time()
231 | # check if you recieve any handshake message from the peer
232 | while not self.check_keep_alive_timeout():
233 | raw_handshake_response = self.recieve_handshake()
234 | if raw_handshake_response is not None:
235 | break
236 | # case where timeout occured and couldn't recieved message
237 | if raw_handshake_response is None:
238 | return False
239 | # validate the hanshake message response
240 | handshake_response = self.handshake_validation(raw_handshake_response)
241 | if handshake_response is None:
242 | return False
243 | # extract the peer id
244 | self.peer_id = handshake_response.client_peer_id
245 | # send handshake message after validation
246 | self.send_handshake()
247 | self.handshake_flag = True
248 | # handshake done successfully
249 | return True
250 |
251 | """
252 | the function helps in building the handshake message
253 | """
254 | def build_handshake_message(self):
255 | info_hash = self.torrent.torrent_metadata.info_hash
256 | peer_id = self.torrent.peer_id
257 | # create a handshake object instance
258 | return handshake(info_hash, peer_id)
259 |
260 | """
261 | function helps in sending the handshake message to the peer
262 | function returns the handshake request that is made
263 | """
264 | def send_handshake(self):
265 | # create a handshake object instance for request
266 | handshake_request = self.build_handshake_message()
267 | # send the handshake message
268 | self.send(handshake_request.message())
269 |
270 | # used for EXCECUTION LOGGING
271 | handshake_req_log = 'Handshake initiated -----> ' + self.unique_id
272 | self.peer_logger.log(handshake_req_log)
273 |
274 | # handshake request that is made
275 | return handshake_request
276 |
277 | """
278 | function helps in recieving the hanshake message from peer
279 | function returns handshake recieved on success else returns None
280 | """
281 | def recieve_handshake(self):
282 | # recieve message for the peer
283 | raw_handshake_response = self.recieve(HANDSHAKE_MESSAGE_LENGTH)
284 | if raw_handshake_response is None:
285 | # used for EXCECUTION LOGGING
286 | handshake_res_log = 'Handshake not recived from ' + self.unique_id
287 | self.peer_logger.log(handshake_res_log)
288 | return None
289 |
290 | # used for EXCECUTION LOGGING
291 | handshake_res_log = 'Handshake recived <----- ' + self.unique_id
292 | self.peer_logger.log(handshake_res_log)
293 |
294 | # raw handshake message recieved
295 | return raw_handshake_response
296 |
297 | """
298 | function helps in performing handshake validation of recieved
299 | handshake response with the handshake request that is made
300 | """
301 | def handshake_validation(self, raw_handshake_response):
302 | # attempt validation of raw handshake response with handshake request
303 | validation_log = 'Handshake validation : '
304 | try:
305 | handshake_request = self.build_handshake_message()
306 | handshake_response = handshake_request.validate_handshake(raw_handshake_response)
307 | validation_log += SUCCESS
308 | # used for EXCECUTION LOGGING
309 | self.peer_logger.log(validation_log)
310 | return handshake_response
311 | except Exception as err_msg:
312 | validation_log += FAILURE + ' ' + err_msg.__str__()
313 | # used for EXCECUTION LOGGING
314 | self.peer_logger.log(validation_log)
315 | return None
316 |
317 | """
318 | function helps in initializing the bitfield values obtained from
319 | peer note that his function must be immediately be called after
320 | the handshake is done successfully.
321 | Note : some peer actaully even sends multiple have requests, unchoke,
322 | have messages in any order that condition is below implementation
323 | """
324 | def initialize_bitfield(self):
325 | # peer connection not established
326 | if not self.peer_sock.peer_connection_active():
327 | return self.bitfield_pieces
328 | # recieve only if handshake is done successfully
329 | if not self.handshake_flag:
330 | return self.bitfield_pieces
331 | # loop for all the message that are recieved by the peer
332 | messages_begin_recieved = True
333 | while(messages_begin_recieved):
334 | # handle responses recieved
335 | response_message = self.handle_response()
336 | # if you no respone message is recieved
337 | if response_message is None:
338 | messages_begin_recieved = False
339 | # returns bitfield obtained by the peer
340 | return self.bitfield_pieces
341 |
342 | """
343 | returns the string format information about the handshake process
344 | """
345 | def get_handshake_log(self):
346 | log = 'HANDSHAKE with ' + self.unique_id + ' : '
347 | if self.handshake_flag:
348 | log += SUCCESS + '\n'
349 | else:
350 | log += FAILURE + '\n'
351 | peer_bitfield_count = len(self.bitfield_pieces)
352 | log += 'COUNT BITFIELDs with ' + self.unique_id + ' : '
353 | if peer_bitfield_count == 0:
354 | log += 'did not recieved !'
355 | else:
356 | log += str(peer_bitfield_count) + ' pieces'
357 | return log
358 |
359 |
360 | """
361 | function handles any peer message that is recieved on the port
362 | function manages -> recieving, decoding and reacting to recieved message
363 | function returns decoded message if successfully recieved, decoded
364 | and reacted, else returns None
365 | """
366 | def handle_response(self):
367 | # recieve messages from the peer
368 | peer_response_message = self.recieve_message()
369 | # if there is no response from the peer
370 | if peer_response_message is None:
371 | return None
372 |
373 | # DECODE the peer wire message into appropriate peer wire message type type
374 | decoded_message = PEER_MESSAGE_DECODER.decode(peer_response_message)
375 | if decoded_message is None:
376 | return None
377 |
378 | # used for EXCECUTION LOGGING
379 | recieved_message_log = 'recieved message <----- ' + decoded_message.__str__()
380 | self.peer_logger.log(recieved_message_log)
381 |
382 | # REACT to the message accordingly
383 | self.handle_message(decoded_message)
384 | return decoded_message
385 |
386 | """
387 | The function is used to handle the decoded message.
388 | The function reacts to the message recieved by the peer
389 | """
390 | def handle_message(self, decoded_message):
391 | # select the respective message handler
392 | message_handler = self.response_handler[decoded_message.message_id]
393 | # handle the deocode response message
394 | return message_handler(decoded_message)
395 |
396 |
397 | """
398 | ======================================================================
399 | RECIVED MESSAGES HADNLER FUNCTIONS
400 | ======================================================================
401 | """
402 |
403 | """
404 | recieved keepalive : indicates peer is still alive in file sharing
405 | """
406 | def recieved_keep_alive(self, keep_alive_message):
407 | # reset the timer when keep alive is recieved
408 | self.keep_alive_timer = time.time()
409 |
410 |
411 | """
412 | recieved choke : client is choked by the peer
413 | peer will not response to clinet requests
414 | """
415 | def recieved_choke(self, choke_message):
416 | # peer is choking the client
417 | self.state.set_peer_choking()
418 | # client will also be not interested if peer is choking
419 | self.state.set_client_not_interested()
420 |
421 |
422 | """
423 | recieved unchoke : client is unchoked by the peer
424 | peer will respond to client requests
425 | """
426 | def recieved_unchoke(self, unchoke_message):
427 | # the peer is unchoking the client
428 | self.state.set_peer_unchoking()
429 | # the peer in also interested in the client
430 | self.state.set_client_interested()
431 |
432 | """
433 | recieved interested : peer is interested in downloading from client
434 | """
435 | def recieved_interested(self, interested_message):
436 | # the peer is interested in client
437 | self.state.set_peer_interested()
438 |
439 | """
440 | recieved uninterested : peer is not interested in downloading from client
441 | """
442 | def recieved_uninterested(self, uninterested_message):
443 | # the peer is not interested in client
444 | self.state.set_peer_not_interested()
445 | # closing the connection
446 | self.close_peer_connection()
447 |
448 | """
449 | recieved bitfields : peer sends the bitfiled values to client
450 | after recieving the bitfields make client interested
451 | """
452 | def recieved_bitfield(self, bitfield_message):
453 | # extract the bitfield piece information from the message
454 | self.bitfield_pieces = bitfield_message.extract_pieces()
455 |
456 |
457 | """
458 | recieved have : peer sends information of piece that it has
459 | """
460 | def recieved_have(self, have_message):
461 | # update the piece information in the peer bitfiled
462 | self.bitfield_pieces.add(have_message.piece_index)
463 |
464 |
465 | """
466 | recieved request : peer has requested some piece from client
467 | """
468 | def recieved_request(self, request_message):
469 | # extract block requested
470 | piece_index = request_message.piece_index
471 | block_offset = request_message.block_offset
472 | block_length = request_message.block_length
473 | # validate the block requested exits in file
474 | if self.torrent.validate_piece_length(piece_index, block_offset, block_length):
475 | # read the datablock
476 | data_block = self.file_handler.read_block(piece_index, block_offset, block_length)
477 | # create response piece message and send it the peer
478 | response_message = piece(piece_index, block_offset, data_block)
479 | self.send_message(response_message)
480 | else:
481 | request_log = self.unique_id + ' dropping request since invalid block requested !'
482 | self.peer_logger.log(request_log)
483 |
484 | """
485 | recieved piece : peer has responed with the piece to client
486 | after recieving any piece, it is written into file
487 | """
488 | def recieved_piece(self, piece_message):
489 | # write the block of piece into the file
490 | self.file_handler.write_block(piece_message)
491 |
492 | """
493 | recieved cancel : message to cancel a block request from client
494 | """
495 | def recieved_cancel(self, cancel_message):
496 | # TODO : implementation coming soon
497 | pass
498 |
499 | """
500 | recieved port :
501 | """
502 | def recieved_port(self, cancel_message):
503 | # TODO : implementation coming soon
504 | pass
505 |
506 |
507 | """
508 | ======================================================================
509 | SEND MESSAGES HADNLER FUNCTIONS
510 | ======================================================================
511 | """
512 |
513 | """
514 | send keep alive : client message to keep the peer connection alive
515 | """
516 | def send_keep_alive(self):
517 | self.send_message(keep_alive())
518 |
519 |
520 | """
521 | send choke : peer is choked by the client
522 | client will not response to peer requests
523 | """
524 | def send_choke(self):
525 | self.send_message(choke())
526 | self.state.set_client_choking()
527 |
528 |
529 | """
530 | send unchoke : client is unchoked by the peer
531 | peer will respond to client requests
532 | """
533 | def send_unchoke(self):
534 | self.send_message(unchoke())
535 | self.state.set_client_unchoking()
536 |
537 |
538 | """
539 | send interested : client is interested in the peer
540 | """
541 | def send_interested(self):
542 | self.send_message(interested())
543 | self.state.set_client_interested()
544 |
545 | """
546 | send uninterested : client is not interested in the peer
547 | """
548 | def send_uninterested(self):
549 | self.send_message(uninterested())
550 | self.state.set_client_not_interested()
551 |
552 | """
553 | send have : client has the given piece to offer the peer
554 | """
555 | def send_have(self, piece_index):
556 | self.send_message(have(piece_index))
557 |
558 | """
559 | send bitfield : client sends the bitfield message of pieces
560 | """
561 | def send_bitfield(self):
562 | bitfield_payload = create_bitfield_message(self.bitfield_pieces, self.torrent.pieces_count)
563 | self.send_message(bitfield(bitfield_payload))
564 |
565 |
566 | """
567 | send request : client sends request to the peer for piece
568 | """
569 | def send_request(self, piece_index, block_offset, block_length):
570 | self.send_message(request(piece_index, block_offset, block_length))
571 |
572 |
573 | """
574 | send piece : client sends file's piece data to the peer
575 | """
576 | def send_piece(self, piece_index, block_offset, block_data):
577 | self.send_message(piece(piece_index, block_offset, block_data))
578 |
579 |
580 | """
581 | downloading finite state machine(FSM) for bittorrent client
582 | the below function implements the FSM for downloading piece from peer
583 | """
584 | def piece_downlaod_FSM(self, piece_index):
585 | # if the peer doesn't have the piece
586 | if not self.have_piece(piece_index):
587 | return False
588 | # initializing keep alive timer
589 | self.keep_alive_timer = time.time()
590 | # download status of piece
591 | download_status = False
592 | # exchanges message with
593 | exchange_messages = True
594 | while exchange_messages:
595 | # checking for timeouts in states
596 | if(self.check_keep_alive_timeout()):
597 | self.state.set_null()
598 | # client state 0 : (client = not interested, peer = choking)
599 | if(self.state == DSTATE0):
600 | self.send_interested()
601 | # client state 1 : (client = interested, peer = choking)
602 | elif(self.state == DSTATE1):
603 | response_message = self.handle_response()
604 | # client state 2 : (client = interested, peer = not choking)
605 | elif(self.state == DSTATE2):
606 | download_status = self.download_piece(piece_index)
607 | exchange_messages = False
608 | # client state 3 : (client = None, peer = None)
609 | elif(self.state == DSTATE3):
610 | exchange_messages = False
611 | return download_status
612 |
613 |
614 | """
615 | function helps in downloading the given piece from the peer
616 | function returns success/failure depending upon that piece is
617 | downloaed successfully and validated successfully
618 | """
619 | def download_piece(self, piece_index):
620 | if not self.have_piece(piece_index) or not self.download_possible():
621 | return False
622 |
623 | # recieved piece data from the peer
624 | recieved_piece = b''
625 | # block offset for downloading the piece
626 | block_offset = 0
627 | # block length
628 | block_length = 0
629 | # piece length for torrent
630 | piece_length = self.torrent.get_piece_length(piece_index)
631 |
632 | # loop untill you download all the blocks in the piece
633 | while self.download_possible() and block_offset < piece_length:
634 | # find out how much max length of block that can be requested
635 | if piece_length - block_offset >= self.max_block_length:
636 | block_length = self.max_block_length
637 | else:
638 | block_length = piece_length - block_offset
639 |
640 | block_data = self.download_block(piece_index, block_offset, block_length)
641 | if block_data:
642 | # increament offset according to size of data block recieved
643 | recieved_piece += block_data
644 | block_offset += block_length
645 |
646 | # check for connection timeout
647 | if self.check_keep_alive_timeout():
648 | return False
649 |
650 | # validate the piece and update the peer downloaded bitfield
651 | if(not self.validate_piece(recieved_piece, piece_index)):
652 | return False
653 |
654 | # used for EXCECUTION LOGGING
655 | download_log = self.unique_id + ' downloaded piece : '
656 | download_log += str(piece_index) + ' ' + SUCCESS
657 | self.peer_logger.log(download_log)
658 |
659 | # successfully downloaded and validated piece
660 | return True
661 |
662 |
663 | """
664 | function helps in downlaoding given block of the piece from peer
665 | function returns block of data if requested block is successfully
666 | downloaded else returns None
667 | """
668 | def download_block(self, piece_index, block_offset, block_length):
669 | # create a request message for given piece index and block offset
670 | request_message = request(piece_index, block_offset, block_length)
671 | # send request message to peer
672 | self.send_message(request_message)
673 |
674 | # torrent statistics starting the timer
675 | self.torrent.statistics.start_time()
676 | # recieve response message and handle the response
677 | response_message = self.handle_response()
678 | # torrent statistics stopping the timer
679 | self.torrent.statistics.stop_time()
680 |
681 | # if the message recieved was a piece message
682 | if not response_message or response_message.message_id != PIECE:
683 | return None
684 | # validate if correct response is recieved for the piece message
685 | if not self.validate_request_piece_messages(request_message, response_message):
686 | return None
687 |
688 | # update the torrent statistics for downloading
689 | self.torrent.statistics.update_download_rate(piece_index, block_length)
690 |
691 | # successfully downloaded and validated block of piece
692 | return response_message.block
693 |
694 | """
695 | piece can be only downloaded only upon given conditions
696 | -> the connection still exits
697 | -> handshake done by peer and client successfully
698 | -> state of client can download the file
699 | -> timeout has not occured
700 | function returns true if all above condition are satisfied else false
701 | """
702 | def download_possible(self):
703 | # socket connection still active to recieve/send
704 | if not self.peer_sock.peer_connection_active():
705 | return False
706 | # if peer has not done handshake piece will never be downloaded
707 | if not self.handshake_flag:
708 | return False
709 | # finally check if peer is interested and peer is not choking
710 | if self.state != DSTATE2:
711 | return False
712 | if self.check_keep_alive_timeout():
713 | return False
714 | # all conditions satisfied
715 | return True
716 |
717 | """
718 | function returns true or false depending upon peer has piece or not
719 | """
720 | def have_piece(self, piece_index):
721 | if piece_index in self.bitfield_pieces:
722 | return True
723 | else:
724 | return False
725 |
726 | """
727 | function adds file handler abstraction object by which client
728 | can read / write block into file which file handler will deal
729 | """
730 | def add_file_handler(self, file_handler):
731 | self.file_handler = file_handler
732 |
733 |
734 | """
735 | function validates if correct block was recieved from peer for the request
736 | """
737 | def validate_request_piece_messages(self, request, piece):
738 | if request.piece_index != piece.piece_index:
739 | return False
740 | if request.block_offset != piece.block_offset:
741 | return False
742 | if request.block_length != len(piece.block):
743 | return False
744 | return True
745 |
746 | """
747 | function validates piece recieved and given the piece index.
748 | validation is comparing the sha1 hash of the recieved piece
749 | with the torrent file pieces value at particular index.
750 | """
751 | def validate_piece(self, piece, piece_index):
752 | # compare the length of the piece recieved
753 | piece_length = self.torrent.get_piece_length(piece_index)
754 | if (len(piece) != piece_length):
755 | # used for EXCECUTION LOGGING
756 | download_log = self.unique_id + 'unable to downloaded piece '
757 | download_log += str(piece_index) + ' due to validation failure : '
758 | download_log += 'incorrect lenght ' + str(len(piece)) + ' piece recieved '
759 | download_log += FAILURE
760 | self.peer_logger.log(download_log)
761 | return False
762 |
763 | piece_hash = hashlib.sha1(piece).digest()
764 | index = piece_index * 20
765 | torrent_piece_hash = self.torrent.torrent_metadata.pieces[index : index + 20]
766 |
767 | # compare the pieces hash with torrent file piece hash
768 | if piece_hash != torrent_piece_hash:
769 | # used for EXCECUTION LOGGING
770 | download_log = self.unique_id + 'unable to downloaded piece '
771 | download_log += str(piece_index) + ' due to validation failure : '
772 | download_log += 'info hash of piece not matched ' + FAILURE
773 | self.peer_logger.log(download_log)
774 | return False
775 | # return true if valid
776 | return True
777 |
778 | """
779 | function does initial handshake and immediately sends bitfields to peer
780 | """
781 | def initial_seeding_messages(self):
782 | if not self.respond_handshake():
783 | return False
784 | # after handshake immediately send the bitfield response
785 | bitfield = create_bitfield_message(self.bitfield_pieces, self.torrent.pieces_count)
786 | self.send_message(bitfield)
787 | return True
788 |
789 | """
790 | uploading finite state machine(FSM) for bittorrent client (seeding)
791 | the below function implements the FSM for uploading pieces to peer
792 | """
793 | def piece_upload_FSM(self):
794 | # initializing keep alive timer
795 | self.keep_alive_timer = time.time()
796 | # download status of piece
797 | download_status = False
798 | # exchanges message with
799 | exchange_messages = True
800 | while exchange_messages:
801 | # checking for timeouts in states
802 | if(self.check_keep_alive_timeout()):
803 | self.state.set_null()
804 | # client state 0 : (client = not interested, peer = choking)
805 | if(self.state == USTATE0):
806 | response_message = self.handle_response()
807 | # client state 1 : (client = interested, peer = choking)
808 | elif(self.state == USTATE1):
809 | self.send_unchoke()
810 | # client state 2 : (client = interested, peer = not choking)
811 | elif(self.state == USTATE2):
812 | self.upload_pieces()
813 | exchange_messages = False
814 | # client state 3 : (client = None, peer = None)
815 | elif(self.state == USTATE3):
816 | exchange_messages = False
817 |
818 | """
819 | function helps in uploading the torrent file with peer, the function
820 | exchanges the request/piece messages with peer and helps peer get the
821 | pieces of the file that client has in the seeding file
822 | """
823 | def upload_pieces(self):
824 | while self.upload_possible():
825 | # torrent statistics starting the timer
826 | self.torrent.statistics.start_time()
827 | # handle all the request messages
828 | request_message = self.handle_response()
829 | # torrent statistics starting the timer
830 | self.torrent.statistics.stop_time()
831 | if request_message and request_message.message_id == REQUEST:
832 | piece_index = request_message.piece_index
833 | block_length = request_message.block_length
834 | self.torrent.statistics.update_upload_rate(piece_index, block_length)
835 | self.peer_logger.log(self.torrent.statistics.get_upload_statistics())
836 |
837 | """
838 | piece can be only uploaded only upon given conditions
839 | -> the connection still exits
840 | -> handshake done by client and peer successfully
841 | -> state of client can download the file
842 | -> timeout has not occured
843 | function returns true if all above condition are satisfied else false
844 | """
845 | def upload_possible(self):
846 | # socket connection still active to recieve/send
847 | if not self.peer_sock.peer_connection_active():
848 | return False
849 | # if peer has not done handshake piece will never be downloaded
850 | if not self.handshake_flag:
851 | return False
852 | # finally check if peer is interested and peer is not choking
853 | if self.state != USTATE2:
854 | return False
855 | if self.check_keep_alive_timeout():
856 | return False
857 | # all conditions satisfied
858 | return True
859 |
860 | """
861 | function checks for timeouts incase of no keep alive recieved from peer
862 | """
863 | def check_keep_alive_timeout(self):
864 | if(time.time() - self.keep_alive_timer >= self.keep_alive_timeout):
865 | keep_alive_log = self.unique_id + ' peer keep alive timeout ! ' + FAILURE
866 | keep_alive_log += ' disconnecting the peer connection!'
867 | self.close_peer_connection()
868 | self.peer_logger.log(keep_alive_log)
869 | return True
870 | else:
871 | return False
872 |
873 |
--------------------------------------------------------------------------------