(1 . 10)(1 . 9)
VERSION = "9986"
VERSION = "9985"

import os
import select
import socket
import sys
import sys
import tempfile
import time
import string
(12 . 11)(11 . 13)
import sqlite3
from datetime import datetime
from funcs import *
from lib.client import Client 
from lib.channel import Channel
from lib.station import Station
from lib.message import Message
from lib.infosec import PACKET_SIZE
from client import Client 
from channel import Channel
from station import Station
from station import EMBARGO_INTERVAL
from station import RUBBISH_INTERVAL
from message import Message
from infosec import PACKET_SIZE
import imp
import pprint
import logging
(28 . 7)(29 . 6)
        self.channel_name = options.channel_name
        self.password = options.password
        self.motdfile = options.motd
        self.verbose = options.verbose
        self.logdir = options.logdir
        self.chroot = options.chroot
        self.setuid = options.setuid
(37 . 13)(37 . 14)
        self.pp = pprint.PrettyPrinter(indent=4)
        self.db_path = options.db_path
        self.address_table_path = options.address_table_path
        self.irc_server_address = "127.0.0.1"

        if options.listen:
            self.address = socket.gethostbyname(options.listen)
            self.udp_address = socket.gethostbyname(options.listen)
        else:
            self.address = ""
            self.udp_address = ""
        server_name_limit = 63  # From the RFC.
        self.name = socket.getfqdn(self.address)[:server_name_limit]
        self.name = socket.getfqdn(self.udp_address)[:server_name_limit]

        self.channels = {}  # irc_lower(Channel name) --> Channel instance.
        self.client = None
(124 . 13)(125 . 11)
    def start(self):
        # 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.udp_server_socket.bind((self.udp_address, self.udp_port))
        self.station = Station({ "socket": self.udp_server_socket,
                                 "db_path": self.db_path,
                                 "address_table_path": self.address_table_path
                                 })
        self.station.start_embargo_queue_checking()
        self.station.start_rubbish()
        logging.info("Listening for Pest packets on udp port %d." % self.udp_port)

        serversockets = []
(138 . 7)(137 . 7)
            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
            s.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
            try:
                s.bind((self.address, port))
                s.bind((self.irc_server_address, port))
            except socket.error as e:
                logging.error("Could not bind port %s: %s." % (port, e))
                sys.exit(1)
(155 . 36)(154 . 62)
            os.setuid(self.setuid[0])
            logging.info("Setting uid:gid to %s:%s"
                            % (self.setuid[0], self.setuid[1]))

        # event loop setup
        last_aliveness_check = time.time()
        last_embargo_queue_check = time.time()
        last_rubbish_dispatch = time.time()
        while True:
            (inputready,outputready,exceptready) = select.select([self.udp_server_socket],[],[],0)
            (iwtd, owtd, ewtd) = select.select(
                serversockets + ([self.client.socket] if self.client else []),
                [self.client.socket] if self.client and self.client.write_queue_size() > 0 else [],
                [],
                .2)
            for x in inputready:
                if x == self.udp_server_socket:
                    bytes_address_pair = self.udp_server_socket.recvfrom(PACKET_SIZE)
                    self.station.handle_udp_data(bytes_address_pair)
            # we don't want to be listening for client connections if there's already a client connected
            if self.client == None:
                input_sockets = serversockets
            else:
                input_sockets = [self.client.socket]
            output_sockets = ([self.client.socket]
                if self.client and self.client.write_queue_size() > 0 else [])

            # handle tcp socket events
            (iwtd, owtd, ewtd) = select.select(input_sockets, output_sockets, [], .2)
            for x in iwtd:
                if self.client != None:
                    self.client.socket_readable_notification()
                else:
                    (conn, addr) = x.accept()
                    self.client = Client(self, conn)
                    self.station.client = self.client
                    logging.info("Accepted connection from %s:%s." % (
                        addr[0], addr[1]))
                    try:
                        (conn, addr) = x.accept()
                        self.client = Client(self, conn)
                        self.station.client = self.client
                        logging.info("Accepted connection from %s:%s." % (
                            addr[0], addr[1]))
                    except socket.error as e:
                        logging.error("Failed to accept new client connection: %s" % e)
            for x in owtd:
                if self.client and x == self.client.socket:  # client may have been disconnected
                    self.client.socket_writable_notification()

            # handle udp socket events
            (inputready,outputready,exceptready) = select.select([self.udp_server_socket],[],[],0)
            for x in inputready:
                if x == self.udp_server_socket:
                    bytes_address_pair = self.udp_server_socket.recvfrom(PACKET_SIZE)
                    self.station.handle_udp_data(bytes_address_pair)

            # ping pong 
            now = time.time()
            if last_aliveness_check + 10 < now:
		if self.client:
	            self.client.check_aliveness()
                if self.client:
                    self.client.check_aliveness()
                    last_aliveness_check = now

            # clear embargo queue if enough time has elapsed
            if last_embargo_queue_check + EMBARGO_INTERVAL < now:
                self.station.check_embargo_queue()
                last_embargo_queue_check = now

            # spray rubbish
            if last_rubbish_dispatch + RUBBISH_INTERVAL < now:
                self.station.send_rubbish()
                last_rubbish_dispatch = now

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