(1 . 23)(1 . 23)
import time
import threading
import binascii
import logging
import os
from lib.state import State
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 IGNORED 
from lib.infosec import Infosec
from state import State
from infosec import MAX_BOUNCES
from infosec import STALE_PACKET 
from infosec import DUPLICATE_PACKET 
from infosec import MALFORMED_PACKET 
from infosec import INVALID_SIGNATURE 
from infosec import IGNORED 
from infosec import Infosec
from commands import IGNORE 
from lib.message import Message
from message import Message
from commands import BROADCAST
from commands import DIRECT 
from lib.peer import Peer
from peer import Peer

RUBBISH_INTERVAL = 10 
EMBARGO_INTERVAL = 1

class Station(object):
    def __init__(self, options):
(27 . 14)(27 . 6)
            self.state.import_at_and_wot(options.get("address_table_path"))
        self.infosec = Infosec(self.state)
        self.embargo_queue = {} 
        self.embargo_queue_lock = threading.Lock()

    def start_embargo_queue_checking(self):
        threading.Thread(target=self.check_embargo_queue).start()
    
    def start_rubbish(self):
        pass
        threading.Thread(target=self.send_rubbish).start()

    def handle_udp_data(self, bytes_address_pair):
        data = bytes_address_pair[0]
(47 . 7)(39 . 12)
            message = self.infosec.unpack(peer, data)
            error_code = message.error_code
            if(error_code == None):
                logging.debug("%s(%s) -> %s bounces: %d" % (message.speaker, peer.handles[0], message.body, message.bounces))
                logging.info("[%s:%d %s] -> %s %d %s" % (peer.address,
                    peer.port,
                    peer.handles[0],
                    message.body,
                    message.bounces,
                    message.message_hash))
                self.conditionally_update_at(peer, message, address)

                # if this is a direct message, just deliver it and return
(87 . 22)(84 . 14)
    def embargo(self, message):
        # initialize the key/value to empty array if not in the hash
        # append message to array
        with self.embargo_queue_lock:
            if not message.message_hash in self.embargo_queue.keys():
                self.embargo_queue[message.message_hash] = []
            self.embargo_queue[message.message_hash].append(message)
        if not message.message_hash in self.embargo_queue.keys():
            self.embargo_queue[message.message_hash] = []
        self.embargo_queue[message.message_hash].append(message)

    def check_embargo_queue(self):
        # get a lock so other threads can't mess with the db or the queue
        with self.embargo_queue_lock:
            self.check_for_immediate_messages()
            self.flush_hearsay_messages()

            # release the lock

        # continue the thread loop after interval 
        time.sleep(1)
        threading.Thread(target=self.check_embargo_queue).start()
        self.check_for_immediate_messages()
        self.flush_hearsay_messages()

    def check_for_immediate_messages(self):
        for key in dict(self.embargo_queue).keys():
(169 . 18)(158 . 14)
            message.bounces = message.bounces + 1
            self.infosec.message(message) 
        else:
            logging.debug("[%s:%d] -> packet TTL expired: %s" % packet_info)
            logging.debug("message TTL expired: %s" % message.message_hash)


    def send_rubbish(self):
        logging.debug("sending rubbish...")
        with self.embargo_queue_lock:
            if self.client:
                self.infosec.message(Message({
                    "speaker": self.client.nickname,
                    "command": IGNORE,
                    "bounces": 0,
                    "body": self.infosec.gen_rubbish_body()
                }))
        time.sleep(RUBBISH_INTERVAL)
        threading.Thread(target=self.send_rubbish).start()
        if self.client:
            self.infosec.message(Message({
                "speaker": self.client.nickname,
                "command": IGNORE,
                "bounces": 0,
                "body": self.infosec.gen_rubbish_body()
            }))