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

import os
import select
(8 . 12)(8 . 18)
import tempfile
import time
import string
import binascii
import datetime
from datetime import datetime
from lib.client import Client 
from lib.state import State
from lib.channel import Channel
from lib.infosec import PACKET_SIZE
from lib.infosec import MAX_BOUNCES
from lib.infosec import STALE_PACKET 
from lib.infosec import DUPLICATE_PACKET 
from lib.infosec import MALFORMED_PACKET 
from lib.infosec import INVALID_SIGNATURE 
from lib.infosec import Infosec
from lib.peer import Peer
from lib.ringbuffer import Ringbuffer
(25 . 10)(31 . 9)

class Server(object):
    def __init__(self, options):
        self.ports = options.ports
        self.irc_ports = options.irc_ports
        self.udp_port = options.udp_port
        self.password = options.password
        self.ssl_pem_file = options.ssl_pem_file
        self.motdfile = options.motd
        self.verbose = options.verbose
        self.debug = options.debug
(112 . 7)(117 . 7)

    def print_debug(self, msg):
        if self.debug:
            print(msg)
            print("%s %s" % (datetime.now(), msg))
            sys.stdout.flush()

    def print_error(self, msg):
(144 . 11)(149 . 16)
    def handle_udp_data(self, bytes_address_pair):
        data = bytes_address_pair[0]
        address = bytes_address_pair[1] 
        packet_info = (address[0],
                       address[1], 
                       binascii.hexlify(data)[0:16])
        self.print_debug("[%s:%d] -> %s" % packet_info)
        for peer in self.state.get_peers():
            if peer.get_key() != None:
                message = self.infosec.unpack(peer, data)
                if(message != None):
                    self.print_debug("valid message from peer: %s" % peer.handles[0])
                error_code = message["error_code"]
                if(error_code == None):
                    self.print_debug("[%s] -> %s" % (peer.handles[0], message["body"]))

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

(159 . 8)(169 . 8)

                    if idx != None:
                        self.state.update_address_table({"handle": message["speaker"],
                                                        "address": address[0],
                                                        "port": address[1]
                                                         "address": address[0],
                                                         "port": address[1]
                                                        })
                    # send the message to all clients
                    for c in self.clients:
(171 . 7)(181 . 18)
                    if(message["command"] == BROADCAST) and message["bounces"] < MAX_BOUNCES:
                       self.rebroadcast(peer, message)           
                    return 
        self.print_debug("Unknown peer: %s %d" % (address[0], address[1]))
                elif error_code == STALE_PACKET:
                    self.print_debug("[%s:%d] -> stale packet: %s" % packet_info)
                    return 
                elif error_code == DUPLICATE_PACKET:
                    self.print_debug("[%s:%d] -> duplicate packet: %s" % packet_info)
                    return 
                elif error_code == MALFORMED_PACKET:
                    self.print_debug("[%s:%d] -> malformed 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
(201 . 9)(222 . 10)
        # Setup UDP first
        self.udp_server_socket = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
        self.udp_server_socket.bind((self.address, self.udp_port))
        self.print_info("Listening for Pest packets on udp port %d." % self.udp_port)

        serversockets = []
        for port in self.ports:
        for port in self.irc_ports:
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            try:
(214 . 7)(236 . 7)
            s.listen(5)
            serversockets.append(s)
            del s
            self.print_info("Listening on port %d." % port)
            self.print_info("Listening for IRC connections on port %d." % port)
        if self.chroot:
            os.chdir(self.chroot)
            os.chroot(self.chroot)
(232 . 7)(254 . 7)
                [x.socket for x in self.clients.values()
                 if x.write_queue_size() > 0],
                [],
                0)
                1)
            for x in inputready:
               if x == self.udp_server_socket:
                   bytes_address_pair = self.udp_server_socket.recvfrom(PACKET_SIZE)
(242 . 19)(264 . 6)
                    self.clients[x].socket_readable_notification()
                else:
                    (conn, addr) = x.accept()
                    if self.ssl_pem_file:
                        import ssl
                        try:
                            conn = ssl.wrap_socket(
                                conn,
                                server_side=True,
                                certfile=self.ssl_pem_file,
                                keyfile=self.ssl_pem_file)
                        except ssl.SSLError as e:
                            self.print_error(
                                "SSL error for connection from %s:%s: %s" % (
                                    addr[0], addr[1], e))
                            continue
                    self.clients[conn] = Client(self, conn)
                    self.print_info("Accepted connection from %s:%s." % (
                        addr[0], addr[1]))