def _encode_decode(self, encode, decode, message):
result = encode(message)
try:
decode(None, 0, result[0])
except DropPacket:
raise
except:
pass
return result
def _encode_decode(self, encode, decode, message):
result = encode(message)
try:
decode(None, 0, result[0])
except DropPacket:
raise
except:
pass
return result
def _decode_encr_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the encr-payload")
str_identifier, str_prefs, str_hprefs = payload
identifier, = unpack_from('!H', str_identifier)
length = len(str_prefs)
if length % 128 != 0:
raise DropPacket("Invalid number of bytes available (encr_res)")
if length:
hashpack = '128s' * (length/128)
hashes = unpack_from('!'+hashpack, str_prefs)
hashes = [bytes_to_long(hash) for hash in hashes]
length = len(str_hprefs)
if length % 20 != 0:
raise DropPacket("Invalid number of bytes available (encr_res)")
if length:
hashpack = '20s' * (length/20)
his_hashes = list(unpack_from('!'+hashpack, str_hprefs))
else:
his_hashes = []
return offset, placeholder.meta.payload.implement(identifier, hashes, his_hashes)
def _decode_comment(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "text" in dic:
raise DropPacket("Missing 'text'")
text = dic["text"]
if not (isinstance(text, unicode) and len(text) < 1024):
raise DropPacket("Invalid 'text' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
reply_to_mid = dic.get("reply-to-mid", None)
if reply_to_mid and not (isinstance(reply_to_mid, str) and len(reply_to_mid) == 20):
raise DropPacket("Invalid 'reply-to-mid' type or value")
reply_to_global_time = dic.get("reply-to-global-time", None)
if reply_to_global_time and not isinstance(reply_to_global_time, (int, long)):
raise DropPacket("Invalid 'reply-to-global-time' type")
reply_after_mid = dic.get("reply-after-mid", None)
if reply_after_mid and not (isinstance(reply_after_mid, str) and len(reply_after_mid) == 20):
raise DropPacket("Invalid 'reply-after-mid' type or value")
reply_after_global_time = dic.get("reply-after-global-time", None)
if reply_after_global_time and not isinstance(reply_after_global_time, (int, long)):
raise DropPacket("Invalid 'reply-after-global-time' type")
playlist_mid = dic.get("playlist-mid", None)
if playlist_mid and not (isinstance(playlist_mid, str) and len(playlist_mid) == 20):
raise DropPacket("Invalid 'playlist-mid' type or value")
playlist_global_time = dic.get("playlist-global-time", None)
if playlist_global_time and not isinstance(playlist_global_time, (int, long)):
raise DropPacket("Invalid 'playlist-global-time' type")
if playlist_mid and playlist_global_time:
try:
packet_id, packet, message_name = self._get_message(playlist_global_time, playlist_mid)
playlist = Packet(self._community.get_meta_message(message_name), packet, packet_id)
except DropPacket:
members = self._community.dispersy.get_members_from_id(playlist_mid)
if not members:
raise DelayPacketByMissingMember(self._community, playlist_mid)
member = members[0]
raise DelayPacketByMissingMessage(self._community, member, playlist_global_time)
else:
playlist = None
infohash = dic.get("infohash", None)
if infohash and not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
return offset, placeholder.meta.payload.implement(text, timestamp, reply_to_mid, reply_to_global_time, reply_after_mid, reply_after_global_time, playlist, infohash)
def _decode_encr_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the encr-payload")
str_identifier, str_prefs, str_hprefs = payload
identifier, = unpack_from('!H', str_identifier)
length = len(str_prefs)
if length % 128 != 0:
raise DropPacket("Invalid number of bytes available (encr_res)")
if length:
hashpack = '128s' * (length / 128)
hashes = unpack_from('!' + hashpack, str_prefs)
hashes = [bytes_to_long(hash) for hash in hashes]
length = len(str_hprefs)
if length % 20 != 0:
raise DropPacket("Invalid number of bytes available (encr_res)")
if length:
hashpack = '20s' * (length / 20)
his_hashes = list(unpack_from('!' + hashpack, str_hprefs))
else:
his_hashes = []
return offset, placeholder.meta.payload.implement(
identifier, hashes, his_hashes)
def handle_crawler_reply(self, permid, selversion, channel_id, channel_data, error, message, request_callback):
"""
Received a CRAWLER_USEREVENTLOG_QUERY reply.
@param permid The Crawler permid
@param selversion The overlay protocol version
@param channel_id Identifies a CRAWLER_REQUEST/CRAWLER_REPLY pair
@param error The error value. 0 indicates success.
@param message The message payload
@param request_callback Call this function one or more times to send the requests: request_callback(message_id, payload)
"""
if error:
if DEBUG:
print >> sys.stderr, "usereventlogcrawler: handle_crawler_reply", error, message
msg = "; ".join(['REPLY', show_permid(permid), str(error), str(message)])
self.__log(msg)
else:
if DEBUG:
print >> sys.stderr, "usereventlogcrawler: handle_crawler_reply", show_permid_short(permid), len(message), "bytes"
try:
loaded_message = decode(message)
except:
print_exc()
loaded_message = cPickle.loads(message)
msg = "; ".join(['REPLY', show_permid(permid), str(error), str(loaded_message)])
self.__log(msg)
def _decode_mark_torrent(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "infohash" in dic:
raise DropPacket("Missing 'infohash'")
infohash = dic["infohash"]
if not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
if not "type" in dic:
raise DropPacket("Missing 'type'")
type = dic["type"]
if not (isinstance(type, unicode) and len(type) < 25):
raise DropPacket("Invalid 'type' type or value")
return offset, placeholder.meta.payload.implement(infohash, type, timestamp)
def _decode_mark_torrent(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "infohash" in dic:
raise DropPacket("Missing 'infohash'")
infohash = dic["infohash"]
if not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
if not "type" in dic:
raise DropPacket("Missing 'type'")
type = dic["type"]
if not (isinstance(type, unicode) and len(type) < 25):
raise DropPacket("Invalid 'type' type or value")
return offset, placeholder.meta.payload.implement(
infohash, type, timestamp)
def _decode_channelsearch(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the channelcast-payload")
if not isinstance(payload, list):
raise DropPacket("Invalid payload type")
for keyword in payload:
if not isinstance(keyword, unicode):
raise DropPacket("Invalid 'keyword' type")
return offset, placeholder.meta.payload.implement(payload)
def _decode_channelsearch(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the channelcast-payload")
if not isinstance(payload, list):
raise DropPacket("Invalid payload type")
for keyword in payload:
if not isinstance(keyword, unicode):
raise DropPacket("Invalid 'keyword' type")
return offset, placeholder.meta.payload.implement(payload)
def _decode_moderation(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "text" in dic:
raise DropPacket("Missing 'text'")
text = dic["text"]
if not (isinstance(text, unicode) and len(text) < 1024):
raise DropPacket("Invalid 'text' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
if not "severity" in dic:
raise DropPacket("Missing 'severity'")
severity = dic["severity"]
if not isinstance(severity, (int, long)):
raise DropPacket("Invalid 'severity' type or value")
cause_mid = dic.get("cause-mid", None)
if not (isinstance(cause_mid, str) and len(cause_mid) == 20):
raise DropPacket("Invalid 'cause-mid' type or value")
cause_global_time = dic.get("cause-global-time", None)
if not isinstance(cause_global_time, (int, long)):
raise DropPacket("Invalid 'cause-global-time' type")
try:
packet_id, packet, message_name = self._get_message(
cause_global_time, cause_mid)
cause_packet = Packet(
self._community.get_meta_message(message_name), packet,
packet_id)
except DropPacket:
members = self._community.dispersy.get_members_from_id(cause_mid)
if not members:
raise DelayPacketByMissingMember(self._community, cause_mid)
member = members[0]
raise DelayPacketByMissingMessage(self._community, member,
cause_global_time)
return offset, placeholder.meta.payload.implement(
text, timestamp, severity, cause_packet)
def _decode_search_request(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decodr 21, 2012 e the search-payload")
if len(payload) < 2:
raise DropPacket("Invalid payload length")
identifier, keywords = payload[:2]
if len(identifier) != 2:
raise DropPacket(
"Unable to decode the search-payload, got %d bytes expected 2"
% (len(identifier)))
identifier, = unpack_from('!H', identifier)
if not isinstance(keywords, list):
raise DropPacket("Invalid 'keywords' type")
for keyword in keywords:
if not isinstance(keyword, unicode):
raise DropPacket("Invalid 'keyword' type")
if len(payload) > 5:
functions, prefix, bytes_ = payload[2:6]
if not isinstance(functions, int):
raise DropPacket("Invalid functions type")
if not 0 < functions:
raise DropPacket("Invalid functions value")
size = len(bytes_)
if not 0 < size:
raise DropPacket("Invalid size of bloomfilter")
if not size % 8 == 0:
raise DropPacket(
"Invalid size of bloomfilter, must be a multiple of eight")
if not isinstance(prefix, str):
raise DropPacket("Invalid prefix type")
if not 0 <= len(prefix) < 256:
raise DropPacket("Invalid prefix length")
bloom_filter = BloomFilter(bytes_, functions, prefix=prefix)
else:
bloom_filter = None
return offset, placeholder.meta.payload.implement(
identifier, keywords, bloom_filter)
def _decode_channelcast(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the channelcast-payload")
if not isinstance(payload, dict):
raise DropPacket("Invalid payload type")
for cid, infohashes in payload.iteritems():
if not (isinstance(cid, str) and len(cid) == 20):
raise DropPacket("Invalid 'cid' type or value")
for infohash in infohashes:
if not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
return offset, placeholder.meta.payload.implement(payload)
def _decode_channel(self, placeholder, offset, data):
try:
offset, values = decode(data, offset)
if len(values) != 2:
raise ValueError
except ValueError:
raise DropPacket("Unable to decode the channel-payload")
name = values[0]
if not (isinstance(name, unicode) and len(name) < 256):
raise DropPacket("Invalid 'name' type or value")
description = values[1]
if not (isinstance(description, unicode) and len(description) < 1024):
raise DropPacket("Invalid 'description' type or value")
return offset, placeholder.meta.payload.implement(name, description)
def _decode_channel(self, placeholder, offset, data):
try:
offset, values = decode(data, offset)
if len(values) != 2:
raise ValueError
except ValueError:
raise DropPacket("Unable to decode the channel-payload")
name = values[0]
if not (isinstance(name, unicode) and len(name) < 256):
raise DropPacket("Invalid 'name' type or value")
description = values[1]
if not (isinstance(description, unicode) and len(description) < 1024):
raise DropPacket("Invalid 'description' type or value")
return offset, placeholder.meta.payload.implement(name, description)
def _decode_torrent_request(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the torrent-request")
if not isinstance(payload, dict):
raise DropPacket("Invalid payload type")
for cid, infohashes in payload.iteritems():
if not (isinstance(cid, str) and len(cid) == 20):
raise DropPacket("Invalid 'cid' type or value")
for infohash in infohashes:
if not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
return offset, placeholder.meta.payload.implement(payload)
def _decode_moderation(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "text" in dic:
raise DropPacket("Missing 'text'")
text = dic["text"]
if not (isinstance(text, unicode) and len(text) < 1024):
raise DropPacket("Invalid 'text' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
if not "severity" in dic:
raise DropPacket("Missing 'severity'")
severity = dic["severity"]
if not isinstance(severity, (int, long)):
raise DropPacket("Invalid 'severity' type or value")
cause_mid = dic.get("cause-mid", None)
if not (isinstance(cause_mid, str) and len(cause_mid) == 20):
raise DropPacket("Invalid 'cause-mid' type or value")
cause_global_time = dic.get("cause-global-time", None)
if not isinstance(cause_global_time, (int, long)):
raise DropPacket("Invalid 'cause-global-time' type")
try:
packet_id, packet, message_name = self._get_message(cause_global_time, cause_mid)
cause_packet = Packet(self._community.get_meta_message(message_name), packet, packet_id)
except DropPacket:
members = self._community.dispersy.get_members_from_id(cause_mid)
if not members:
raise DelayPacketByMissingMember(self._community, cause_mid)
member = members[0]
raise DelayPacketByMissingMessage(self._community, member, cause_global_time)
return offset, placeholder.meta.payload.implement(text, timestamp, severity, cause_packet)
def _decode_search_request(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decodr 21, 2012 e the search-payload")
if len(payload) < 2:
raise DropPacket("Invalid payload length")
identifier, keywords = payload[:2]
if len(identifier) != 2:
raise DropPacket("Unable to decode the search-payload, got %d bytes expected 2"%(len(identifier)))
identifier, = unpack_from('!H', identifier)
if not isinstance(keywords, list):
raise DropPacket("Invalid 'keywords' type")
for keyword in keywords:
if not isinstance(keyword, unicode):
raise DropPacket("Invalid 'keyword' type")
if len(payload) > 5:
functions, prefix, bytes_ = payload[2:6]
if not isinstance(functions, int):
raise DropPacket("Invalid functions type")
if not 0 < functions:
raise DropPacket("Invalid functions value")
size = len(bytes_)
if not 0 < size:
raise DropPacket("Invalid size of bloomfilter")
if not size % 8 == 0:
raise DropPacket("Invalid size of bloomfilter, must be a multiple of eight")
if not isinstance(prefix, str):
raise DropPacket("Invalid prefix type")
if not 0 <= len(prefix) < 256:
raise DropPacket("Invalid prefix length")
bloom_filter = BloomFilter(bytes_, functions, prefix=prefix)
else:
bloom_filter = None
return offset, placeholder.meta.payload.implement(identifier, keywords, bloom_filter)
def _decode_simi_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the simi-payload")
identifier, responses = payload[:2]
if len(identifier) != 2:
raise DropPacket(
"Unable to decode the search-response-payload, got %d bytes expected 2"
% (len(identifier)))
identifier, = unpack_from('!H', identifier)
prefs = hprefs = None
bundled_responses = []
for str_mid, str_prefs, str_hprefs in responses:
length = len(str_prefs)
if length % 128 != 0:
raise DropPacket(
"Invalid number of bytes available (encr_res)")
if length:
hashpack = '128s' * (length / 128)
hashes = unpack_from('!' + hashpack, str_prefs)
hashes = [bytes_to_long(hash) for hash in hashes]
length = len(str_hprefs)
if length % 20 != 0:
raise DropPacket(
"Invalid number of bytes available (encr_res)")
if length:
hashpack = '20s' * (length / 20)
his_hashes = list(unpack_from('!' + hashpack, str_hprefs))
else:
his_hashes = []
if str_mid:
str_mid, = unpack_from("!20s", str_mid)
bundled_responses.append((str_mid, (hashes, his_hashes)))
else:
prefs = hashes
hprefs = his_hashes
return offset, placeholder.meta.payload.implement(
identifier, prefs, hprefs, bundled_responses)
def _decode_torrent(self, placeholder, offset, data):
uncompressed_data = zlib.decompress(data[offset:])
offset = len(data)
try:
_, values = decode(uncompressed_data)
except ValueError:
raise DropPacket("Unable to decode the torrent-payload")
infohash_time, name, files, trackers = values
if len(infohash_time) != 28:
raise DropPacket(
"Unable to decode the torrent-payload, got %d bytes expected 28"
% (len(infohash_time)))
infohash, timestamp = unpack_from('!20sQ', infohash_time)
if not isinstance(name, unicode):
raise DropPacket("Invalid 'name' type")
if not isinstance(files, tuple):
raise DropPacket("Invalid 'files' type")
if len(files) == 0:
raise DropPacket("Should have at least one file")
for file in files:
if len(file) != 2:
raise DropPacket("Invalid 'file_len' type")
path, length = file
if not isinstance(path, unicode):
raise DropPacket("Invalid 'files_path' type is %s" %
type(path))
if not isinstance(length, (int, long)):
raise DropPacket("Invalid 'files_length' type is %s" %
type(length))
if not isinstance(trackers, tuple):
raise DropPacket("Invalid 'trackers' type")
for tracker in trackers:
if not isinstance(tracker, str):
raise DropPacket("Invalid 'tracker' type")
return offset, placeholder.meta.payload.implement(
infohash, timestamp, name, files, trackers)
def _decode_torrent(self, placeholder, offset, data):
uncompressed_data = zlib.decompress(data[offset:])
offset = len(data)
try:
_, values = decode(uncompressed_data)
except ValueError:
raise DropPacket("Unable to decode the torrent-payload")
infohash_time, name, files, trackers = values
if len(infohash_time) != 28:
raise DropPacket("Unable to decode the torrent-payload, got %d bytes expected 28"%(len(infohash_time)))
infohash, timestamp = unpack_from('!20sQ', infohash_time)
if not isinstance(name, unicode):
raise DropPacket("Invalid 'name' type")
if not isinstance(files, tuple):
raise DropPacket("Invalid 'files' type")
if len(files) == 0:
raise DropPacket("Should have at least one file")
for file in files:
if len(file) != 2:
raise DropPacket("Invalid 'file_len' type")
path, length = file
if not isinstance(path, unicode):
raise DropPacket("Invalid 'files_path' type is %s"%type(path))
if not isinstance(length, (int, long)):
raise DropPacket("Invalid 'files_length' type is %s"%type(length))
if not isinstance(trackers, tuple):
raise DropPacket("Invalid 'trackers' type")
for tracker in trackers:
if not isinstance(tracker, str):
raise DropPacket("Invalid 'tracker' type")
return offset, placeholder.meta.payload.implement(infohash, timestamp, name, files, trackers)
def _decode_simi_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the simi-payload")
identifier, responses = payload[:2]
if len(identifier) != 2:
raise DropPacket("Unable to decode the search-response-payload, got %d bytes expected 2"%(len(identifier)))
identifier, = unpack_from('!H', identifier)
prefs = hprefs = None
bundled_responses = []
for str_mid, str_prefs, str_hprefs in responses:
length = len(str_prefs)
if length % 128 != 0:
raise DropPacket("Invalid number of bytes available (encr_res)")
if length:
hashpack = '128s' * (length/128)
hashes = unpack_from('!'+hashpack, str_prefs)
hashes = [bytes_to_long(hash) for hash in hashes]
length = len(str_hprefs)
if length % 20 != 0:
raise DropPacket("Invalid number of bytes available (encr_res)")
if length:
hashpack = '20s' * (length/20)
his_hashes = list(unpack_from('!'+hashpack, str_hprefs))
else:
his_hashes = []
if str_mid:
str_mid, = unpack_from("!20s",str_mid)
bundled_responses.append((str_mid, (hashes, his_hashes)))
else:
prefs = hashes
hprefs = his_hashes
return offset, placeholder.meta.payload.implement(identifier, prefs, hprefs, bundled_responses)
def handle_crawler_reply(self, permid, selversion, channel_id,
channel_data, error, message, request_callback):
"""
Received a CRAWLER_USEREVENTLOG_QUERY reply.
@param permid The Crawler permid
@param selversion The overlay protocol version
@param channel_id Identifies a CRAWLER_REQUEST/CRAWLER_REPLY pair
@param error The error value. 0 indicates success.
@param message The message payload
@param request_callback Call this function one or more times to send the requests: request_callback(message_id, payload)
"""
if error:
if DEBUG:
print >> sys.stderr, "usereventlogcrawler: handle_crawler_reply", error, message
msg = "; ".join(
['REPLY',
show_permid(permid),
str(error),
str(message)])
self.__log(msg)
else:
if DEBUG:
print >> sys.stderr, "usereventlogcrawler: handle_crawler_reply", show_permid_short(
permid), len(message), "bytes"
try:
loaded_message = decode(message)
except:
print_exc()
loaded_message = cPickle.loads(message)
msg = "; ".join([
'REPLY',
show_permid(permid),
str(error),
str(loaded_message)
])
self.__log(msg)
def _decode_channelsearch_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the channelcast-payload")
if not isinstance(payload, tuple):
raise DropPacket("Invalid payload type")
keywords, torrents = payload
for keyword in keywords:
if not isinstance(keyword, unicode):
raise DropPacket("Invalid 'keyword' type")
for cid, infohashes in torrents.iteritems():
if not (isinstance(cid, str) and len(cid) == 20):
raise DropPacket("Invalid 'cid' type or value")
for infohash in infohashes:
if not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
return offset, placeholder.meta.payload.implement(keywords, torrents)
def _decode_channelsearch_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the channelcast-payload")
if not isinstance(payload, tuple):
raise DropPacket("Invalid payload type")
keywords, torrents = payload
for keyword in keywords:
if not isinstance(keyword, unicode):
raise DropPacket("Invalid 'keyword' type")
for cid, infohashes in torrents.iteritems():
if not (isinstance(cid, str) and len(cid) == 20):
raise DropPacket("Invalid 'cid' type or value")
for infohash in infohashes:
if not (isinstance(infohash, str) and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
return offset, placeholder.meta.payload.implement(keywords, torrents)
def _decode_comment(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "text" in dic:
raise DropPacket("Missing 'text'")
text = dic["text"]
if not (isinstance(text, unicode) and len(text) < 1024):
raise DropPacket("Invalid 'text' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
reply_to_mid = dic.get("reply-to-mid", None)
if reply_to_mid and not (isinstance(reply_to_mid, str)
and len(reply_to_mid) == 20):
raise DropPacket("Invalid 'reply-to-mid' type or value")
reply_to_global_time = dic.get("reply-to-global-time", None)
if reply_to_global_time and not isinstance(reply_to_global_time,
(int, long)):
raise DropPacket("Invalid 'reply-to-global-time' type")
reply_after_mid = dic.get("reply-after-mid", None)
if reply_after_mid and not (isinstance(reply_after_mid, str)
and len(reply_after_mid) == 20):
raise DropPacket("Invalid 'reply-after-mid' type or value")
reply_after_global_time = dic.get("reply-after-global-time", None)
if reply_after_global_time and not isinstance(reply_after_global_time,
(int, long)):
raise DropPacket("Invalid 'reply-after-global-time' type")
playlist_mid = dic.get("playlist-mid", None)
if playlist_mid and not (isinstance(playlist_mid, str)
and len(playlist_mid) == 20):
raise DropPacket("Invalid 'playlist-mid' type or value")
playlist_global_time = dic.get("playlist-global-time", None)
if playlist_global_time and not isinstance(playlist_global_time,
(int, long)):
raise DropPacket("Invalid 'playlist-global-time' type")
if playlist_mid and playlist_global_time:
try:
packet_id, packet, message_name = self._get_message(
playlist_global_time, playlist_mid)
playlist = Packet(
self._community.get_meta_message(message_name), packet,
packet_id)
except DropPacket:
members = self._community.dispersy.get_members_from_id(
playlist_mid)
if not members:
raise DelayPacketByMissingMember(self._community,
playlist_mid)
member = members[0]
raise DelayPacketByMissingMessage(self._community, member,
playlist_global_time)
else:
playlist = None
infohash = dic.get("infohash", None)
if infohash and not (isinstance(infohash, str)
and len(infohash) == 20):
raise DropPacket("Invalid 'infohash' type or value")
return offset, placeholder.meta.payload.implement(
text, timestamp, reply_to_mid, reply_to_global_time,
reply_after_mid, reply_after_global_time, playlist, infohash)
def _decode_modification(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "modification-type" in dic:
raise DropPacket("Missing 'modification-type'")
modification_type = dic["modification-type"]
if not isinstance(modification_type, unicode):
raise DropPacket("Invalid 'modification_type' type")
if not "modification-value" in dic:
raise DropPacket("Missing 'modification-value'")
modification_value = dic["modification-value"]
if not (isinstance(modification_value, unicode)
and len(modification_value) < 1024):
raise DropPacket("Invalid 'modification_value' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
if not "modification-on-mid" in dic:
raise DropPacket("Missing 'modification-on-mid'")
modification_on_mid = dic["modification-on-mid"]
if not (isinstance(modification_on_mid, str)
and len(modification_on_mid) == 20):
raise DropPacket("Invalid 'modification-on-mid' type or value")
if not "modification-on-global-time" in dic:
raise DropPacket("Missing 'modification-on-global-time'")
modification_on_global_time = dic["modification-on-global-time"]
if not isinstance(modification_on_global_time, (int, long)):
raise DropPacket("Invalid 'modification-on-global-time' type")
try:
packet_id, packet, message_name = self._get_message(
modification_on_global_time, modification_on_mid)
modification_on = Packet(
self._community.get_meta_message(message_name), packet,
packet_id)
except DropPacket:
members = self._community.dispersy.get_members_from_id(
modification_on_mid)
if not members:
raise DelayPacketByMissingMember(self._community,
modification_on_mid)
member = members[0]
raise DelayPacketByMissingMessage(self._community, member,
modification_on_global_time)
prev_modification_mid = dic.get("prev-modification-mid", None)
if prev_modification_mid and not (
isinstance(prev_modification_mid, str)
and len(prev_modification_mid) == 20):
raise DropPacket("Invalid 'prev-modification-mid' type or value")
prev_modification_global_time = dic.get(
"prev-modification-global-time", None)
if prev_modification_global_time and not isinstance(
prev_modification_global_time, (int, long)):
raise DropPacket("Invalid 'prev-modification-global-time' type")
try:
packet_id, packet, message_name = self._get_message(
prev_modification_global_time, prev_modification_mid)
prev_modification_packet = Packet(
self._community.get_meta_message(message_name), packet,
packet_id)
except:
prev_modification_packet = None
return offset, placeholder.meta.payload.implement(
modification_type, modification_value, timestamp, modification_on,
prev_modification_packet, prev_modification_mid,
prev_modification_global_time)
def _decode_search_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the search-reponse-payload")
if len(payload) < 2:
raise DropPacket("Invalid payload length")
identifier, results = payload[:2]
if len(identifier) != 2:
raise DropPacket("Unable to decode the search-response-payload, got %d bytes expected 2"%(len(identifier)))
identifier, = unpack_from('!H', identifier)
if not isinstance(results, list):
raise DropPacket("Invalid 'results' type")
for result in results:
if not isinstance(result, tuple):
raise DropPacket("Invalid result type")
if len(result) < 11:
raise DropPacket("Invalid result length")
infohash, swarmname, length, nrfiles, categorykeys, creation_date, seeders, leechers, swift_hash, swift_torrent_hash, cid = result[:11]
if not isinstance(infohash, str):
raise DropPacket("Invalid infohash type")
if len(infohash) != 20:
raise DropPacket("Invalid infohash length")
if not isinstance(swarmname, unicode):
raise DropPacket("Invalid swarmname type")
if not isinstance(length, long):
raise DropPacket("Invalid length type '%s'"%type(length))
if not isinstance(nrfiles, int):
raise DropPacket("Invalid nrfiles type")
if not isinstance(categorykeys, list):
raise DropPacket("Invalid categorykeys type")
if not all(isinstance(key, unicode) for key in categorykeys):
raise DropPacket("Invalid categorykey type")
if not isinstance(creation_date, long):
raise DropPacket("Invalid creation_date type")
if not isinstance(seeders, int):
raise DropPacket("Invalid seeders type")
if not isinstance(leechers, int):
raise DropPacket("Invalid leechers type")
if swift_hash:
if not isinstance(swift_hash, str):
raise DropPacket("Invalid swift_hash type '%s'"%type(swift_hash))
if len(swift_hash) != 20:
raise DropPacket("Invalid swift_hash length")
if swift_torrent_hash:
if not isinstance(swift_torrent_hash, str):
raise DropPacket("Invalid swift_torrent_hash type")
if len(swift_torrent_hash) != 20:
raise DropPacket("Invalid swift_torrent_hash length")
if cid:
if not isinstance(cid, str):
raise DropPacket("Invalid cid type")
if len(cid) != 20:
raise DropPacket("Invalid cid length")
return offset, placeholder.meta.payload.implement(identifier, results)
def _decode_modification(self, placeholder, offset, data):
try:
offset, dic = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the payload")
if not "modification-type" in dic:
raise DropPacket("Missing 'modification-type'")
modification_type = dic["modification-type"]
if not isinstance(modification_type, unicode):
raise DropPacket("Invalid 'modification_type' type")
if not "modification-value" in dic:
raise DropPacket("Missing 'modification-value'")
modification_value = dic["modification-value"]
if not (isinstance(modification_value, unicode) and len(modification_value) < 1024):
raise DropPacket("Invalid 'modification_value' type or value")
if not "timestamp" in dic:
raise DropPacket("Missing 'timestamp'")
timestamp = dic["timestamp"]
if not isinstance(timestamp, (int, long)):
raise DropPacket("Invalid 'timestamp' type or value")
if not "modification-on-mid" in dic:
raise DropPacket("Missing 'modification-on-mid'")
modification_on_mid = dic["modification-on-mid"]
if not (isinstance(modification_on_mid, str) and len(modification_on_mid) == 20):
raise DropPacket("Invalid 'modification-on-mid' type or value")
if not "modification-on-global-time" in dic:
raise DropPacket("Missing 'modification-on-global-time'")
modification_on_global_time = dic["modification-on-global-time"]
if not isinstance(modification_on_global_time, (int, long)):
raise DropPacket("Invalid 'modification-on-global-time' type")
try:
packet_id, packet, message_name = self._get_message(modification_on_global_time, modification_on_mid)
modification_on = Packet(self._community.get_meta_message(message_name), packet, packet_id)
except DropPacket:
members = self._community.dispersy.get_members_from_id(modification_on_mid)
if not members:
raise DelayPacketByMissingMember(self._community, modification_on_mid)
member = members[0]
raise DelayPacketByMissingMessage(self._community, member, modification_on_global_time)
prev_modification_mid = dic.get("prev-modification-mid", None)
if prev_modification_mid and not (isinstance(prev_modification_mid, str) and len(prev_modification_mid) == 20):
raise DropPacket("Invalid 'prev-modification-mid' type or value")
prev_modification_global_time = dic.get("prev-modification-global-time", None)
if prev_modification_global_time and not isinstance(prev_modification_global_time, (int, long)):
raise DropPacket("Invalid 'prev-modification-global-time' type")
try:
packet_id, packet, message_name = self._get_message(prev_modification_global_time, prev_modification_mid)
prev_modification_packet = Packet(self._community.get_meta_message(message_name), packet, packet_id)
except:
prev_modification_packet = None
return offset, placeholder.meta.payload.implement(modification_type, modification_value, timestamp, modification_on, prev_modification_packet, prev_modification_mid, prev_modification_global_time)
def _decode_search_response(self, placeholder, offset, data):
try:
offset, payload = decode(data, offset)
except ValueError:
raise DropPacket("Unable to decode the search-reponse-payload")
if len(payload) < 2:
raise DropPacket("Invalid payload length")
identifier, results = payload[:2]
if len(identifier) != 2:
raise DropPacket(
"Unable to decode the search-response-payload, got %d bytes expected 2"
% (len(identifier)))
identifier, = unpack_from('!H', identifier)
if not isinstance(results, list):
raise DropPacket("Invalid 'results' type")
for result in results:
if not isinstance(result, tuple):
raise DropPacket("Invalid result type")
if len(result) < 11:
raise DropPacket("Invalid result length")
infohash, swarmname, length, nrfiles, categorykeys, creation_date, seeders, leechers, swift_hash, swift_torrent_hash, cid = result[:
11]
if not isinstance(infohash, str):
raise DropPacket("Invalid infohash type")
if len(infohash) != 20:
raise DropPacket("Invalid infohash length")
if not isinstance(swarmname, unicode):
raise DropPacket("Invalid swarmname type")
if not isinstance(length, long):
raise DropPacket("Invalid length type '%s'" % type(length))
if not isinstance(nrfiles, int):
raise DropPacket("Invalid nrfiles type")
if not isinstance(categorykeys, list):
raise DropPacket("Invalid categorykeys type")
if not all(isinstance(key, unicode) for key in categorykeys):
raise DropPacket("Invalid categorykey type")
if not isinstance(creation_date, long):
raise DropPacket("Invalid creation_date type")
if not isinstance(seeders, int):
raise DropPacket("Invalid seeders type '%s'" % type(seeders))
if not isinstance(leechers, int):
raise DropPacket("Invalid leechers type '%s'" % type(leechers))
if swift_hash:
if not isinstance(swift_hash, str):
raise DropPacket("Invalid swift_hash type '%s'" %
type(swift_hash))
if len(swift_hash) != 20:
raise DropPacket("Invalid swift_hash length")
if swift_torrent_hash:
if not isinstance(swift_torrent_hash, str):
raise DropPacket("Invalid swift_torrent_hash type")
if len(swift_torrent_hash) != 20:
raise DropPacket("Invalid swift_torrent_hash length")
if cid:
if not isinstance(cid, str):
raise DropPacket("Invalid cid type")
if len(cid) != 20:
raise DropPacket("Invalid cid length")
return offset, placeholder.meta.payload.implement(identifier, results)
