(1 . 4)(1 . 4)
VERSION = "9991"
VERSION = "9990"

import os
import select
(20 . 12)(20 . 15)
from lib.infosec import DUPLICATE_PACKET 
from lib.infosec import MALFORMED_PACKET 
from lib.infosec import INVALID_SIGNATURE 
from lib.infosec import IGNORED 
from lib.infosec import Infosec
from lib.peer import Peer
from lib.message import Message
from lib.ringbuffer import Ringbuffer
from funcs import *
from commands import BROADCAST
from commands import DIRECT 
from commands import IGNORE 
import imp
import pprint

(156 . 29)(159 . 28)
        for peer in self.state.get_peers():
            if peer.get_key() != None:
                message = self.infosec.unpack(peer, data)
                error_code = message["error_code"]
                error_code = message.error_code
                if(error_code == None):
                    self.print_debug("[%s] -> %s" % (peer.handles[0], message["body"]))
                    self.print_debug("[%s] -> %s" % (peer.handles[0], message.body))

                    # we only update the address table if the speaker is same as peer

                    try: 
                        idx = peer.handles.index(message["speaker"])
                        idx = peer.handles.index(message.speaker)
                    except:
                        idx = None

                    if idx != None:
                        self.state.update_address_table({"handle": message["speaker"],
                        self.state.update_address_table({"handle": message.speaker,
                                                         "address": address[0],
                                                         "port": address[1]
                                                        })
                    # send the message to all clients
                    for c in self.clients:
                        # self.clients[c].udp_socket_readable_notification(message)
                        if (self.clients[c].is_addressed_to_me(message["body"])):
                            self.clients[c].message(message["body"])
                        if (self.clients[c].is_addressed_to_me(message.body)):
                            self.clients[c].message(message.body)
                    # send the message to all other peers if it should be propagated
                    if(message["command"] == BROADCAST) and message["bounces"] < MAX_BOUNCES:
                    if(message.command == BROADCAST) and message.bounces < MAX_BOUNCES:
                       self.rebroadcast(peer, message)           
                    return 
                elif error_code == STALE_PACKET:
(190 . 34)(192 . 47)
                elif error_code == MALFORMED_PACKET:
                    self.print_debug("[%s:%d] -> malformed packet: %s" % packet_info)
                    return 
                elif error_code == IGNORED:
                    self.print_debug("[%s:%d] -> ignoring packet: %s" % packet_info)
                    return 
                elif error_code == INVALID_SIGNATURE:
                    pass 
        self.print_debug("[%s:%d] -> martian packet: %s" % packet_info)
    
    def peer_message(self, message):
        message["original"] = True
        if message["command"] == DIRECT:
            peer = self.state.get_peer_by_handle(message["handle"])
        message.original = True
        if message.command == DIRECT:
            peer = self.state.get_peer_by_handle(message.handle)
            if peer and (peer.get_key() != None):
                peer.send(message)
            else:
                self.print_debug("Discarding message to unknown handle or handle with no key: %s" % message["handle"])
                self.print_debug("Discarding message to unknown handle or handle with no key: %s" % message.handle)
        else:
            for peer in self.state.get_peers():
                if peer.get_key() != None:
                    peer.send(message)
                else:
                    self.print_debug("Discarding message to handle with no key: %s" % message["handle"])
                    self.print_debug("Discarding message to handle with no key: %s" % message.handle)

    def rebroadcast(self, source_peer, message):
        message["original"] = False
        message.original = False
        for peer in self.state.get_peers():
            if(peer.peer_id != source_peer.peer_id):
                message["command"] = BROADCAST
                message["bounces"] = message["bounces"] + 1
                message.command = BROADCAST
                message.bounces = message.bounces + 1
                peer.send(message) 


    def sendrubbish(self):
        for peer in self.state.get_peers():
            for socket in self.clients:
                self.peer_message(Message({
                    "speaker": self.clients[socket].nickname,
                    "command": IGNORE,
                    "bounces": 0,
                    "body": self.infosec.gen_rubbish_body()
                }, self))
     
    def start(self):
        # Setup UDP first
        self.udp_server_socket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
(254 . 7)(269 . 7)
                [x.socket for x in self.clients.values()
                 if x.write_queue_size() > 0],
                [],
                1)
                .2)
            for x in inputready:
               if x == self.udp_server_socket:
                   bytes_address_pair = self.udp_server_socket.recvfrom(PACKET_SIZE)
(275 . 7)(290 . 7)
               for client in self.clients.values():
                   client.check_aliveness()
               last_aliveness_check = now

               self.sendrubbish() # Kludge to keep ephemeral port open when NATed

def create_directory(path):
    if not os.path.isdir(path):