(8 . 6)(8 . 7)
import traceback
import logging
from state import State
from state import KNOBS
from message import Message
from server import VERSION
from funcs import *
(529 . 6)(530 . 26)
            else:
                self.pest_reply("no results")

        def knob_handler():
            if len(arguments) == 0:
                knobs = self.state.get_knobs() 
                if len(knobs) > 0:
                    for key in knobs.keys():
                        self.pest_reply("%s %s" % (key, knobs[key]))
                else:
                    self.pest_reply("no knobs configured")
            elif len(arguments) == 1:
                knob_value = self.state.get_knob(arguments[0])
                if knob:
                    self.pest_reply("%s %s" % (arguments[0], knob_value))
                else:
                    self.pest_reply("no such knob")
            elif len(arguments) == 2:
                self.state.set_knob(arguments[0], arguments[1])
                self.pest_reply("set %s to %s" % (arguments[0], arguments[1]))
            else:
                self.pest_reply("Usage: KNOB [<NAME>] [<VALUE>]")

        handler_table = {
            "AWAY": away_handler,
            "AT": at_handler,
(554 . 7)(575 . 8)
            "WALLOPS": wallops_handler,
            "WHO": who_handler,
            "WHOIS": whois_handler,
            "WOT":  wot_handler
            "WOT":  wot_handler,
            "KNOB":  knob_handler
        }
        server = self.server
        valid_channel_re = self.__valid_channelname_regexp

(27 . 7)(27 . 6)
RED_PACKET_LENGTH_WITH_PADDING = 448
MESSAGE_PACKET_FORMAT = "<q32s32s32s324s"
MAX_MESSAGE_LENGTH = 428
MAX_BOUNCES = 3
STALE_PACKET = 0
DUPLICATE_PACKET = 1
MALFORMED_PACKET = 2

(1 . 4)(1 . 4)
VERSION = "9984"
VERSION = "9983"

import os
import select
(14 . 8)(14 . 6)
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
(201 . 12)(199 . 12)
                    last_aliveness_check = now

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

            # spray rubbish
            if last_rubbish_dispatch + RUBBISH_INTERVAL < now:
            if last_rubbish_dispatch + int(self.station.state.get_knob('rubbish_interval')) < now:
                self.station.send_rubbish()
                last_rubbish_dispatch = now

(6 . 6)(6 . 10)
import datetime
from itertools import chain

KNOBS=({'max_bounces': 3,
        'embargo_interval': 1,
        'rubbish_interval': 10})

class State(object):
    __instance = None
    @staticmethod
(48 . 11)(52 . 43)
            cursor.execute("create table if not exists dedup_queue(\
                                 hash text not null,\
                                 created_at datetime default current_timestamp)")
            cursor.execute("create table if not exists knobs(\
                                 name text not null,\
                                 value text not null)")
            State.__instance = self

    def cursor(self):
        return self.conn.cursor()

    def get_knobs(self):
        cursor = self.cursor()
        results = cursor.execute("select name, value from knobs order by name asc").fetchall()
        knobs = {} 
        for result in results:
            knobs[result[0]] = result[1]
        for key in KNOBS.keys():
            if not knobs.get(key):
                knobs[key] = KNOBS[key]
        return knobs
        
    def get_knob(self, knob_name):
        cursor = self.cursor()
        result = cursor.execute("select value from knobs where name=?", (knob_name,)).fetchone()
        if result:
            return result[0]
        elif KNOBS.get(knob_name):
            return KNOBS.get(knob_name)
        else:
            return None

    def set_knob(self, knob_name, knob_value):
        cursor = self.cursor()
        result = cursor.execute("select value from knobs where name=?", (knob_name,)).fetchone()
        if result:
            cursor.execute("update knobs set value=? where name=?", (knob_value, knob_name,))
        else:
            cursor.execute("insert into knobs(name, value) values(?, ?)", (knob_name, knob_value,))
        
    def get_at(self, handle=None):
        cursor = self.cursor()
        at = []

(3 . 7)(3 . 6)
import logging
import os
from state import State
from infosec import MAX_BOUNCES
from infosec import STALE_PACKET 
from infosec import DUPLICATE_PACKET 
from infosec import MALFORMED_PACKET 
(16 . 9)(15 . 6)
from commands import DIRECT 
from peer import Peer

RUBBISH_INTERVAL = 10 
EMBARGO_INTERVAL = 1

class Station(object):
    def __init__(self, options):
        self.client = None
(153 . 7)(149 . 7)
            })

    def rebroadcast(self, message):
        if message.bounces < MAX_BOUNCES:
        if message.bounces < int(self.state.get_knob("max_bounces")):
            message.command = BROADCAST
            message.bounces = message.bounces + 1
            self.infosec.message(message)