def __init__(self):
# read configuration from file (defaults included)
config = ConfigParser({
'loglevel': 'INFO',
'logfile': APPNAME + 'log',
'addr': '127.0.0.1',
'port': 5000,
'cryptokey': 'default'
})
config.read([CONFFILE])
# set tunables
self.loglevel = config.get(APPNAME, 'loglevel')
self.logfile = config.get(APPNAME, 'logfile')
self.addr = config.get(APPNAME, 'addr')
self.port = config.getint(APPNAME, 'port')
self.cryptokey = config.get(APPNAME, 'cryptokey')
# set local variables
self.filterlist = ()
self.pktcount = 0
self.handler = DNSFlowHandler
self.server = ThreadingUDPServer((self.addr, self.port), self.handler)
self.server.queue = Queue()
# initialize and setup logging
logging.basicConfig(filename=self.logfile, format=LOGFMT)
self.log = logging.getLogger(APPNAME)
if self.loglevel in LOGLEVELS:
self.log.setLevel(LOGLEVELS[self.loglevel])
# crypto stuff -- choose AES128 CBC
self.server.cryptocipher = AES.new
self.server.cryptomode = AES.MODE_CBC
self.server.cryptoblocksize = AES.block_size
self.server.cryptokey = self._pad_pkcs7_block(
self.cryptokey, self.server.cryptoblocksize)
# build a list of DNS IDS filter functions
callable = lambda i: hasattr(i, '__call__')
isfilter = lambda o, i: callable(getattr(o, i)) \
and i[:7] == 'filter_'
self.filterlist = [
getattr(sniff_filters, i) for i in dir(sniff_filters)
if isfilter(sniff_filters, i)
]
# start listening/analysing service
self.log.info('Started %s @ %s' % (APPNAME, time.asctime()))
thread.start_new_thread(self.process_flow, ())
self.server.serve_forever()
def main():
server = ThreadingUDPServer((HOST, PORT), ThreadedUDPRequestHandler)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
try:
server_thread.start()
logger = logging.getLogger("app")
logger.info("Server started at {} port {}".format(HOST, PORT))
# 一个死循环
while True:
time.sleep(100)
except (KeyboardInterrupt, SystemExit):
server.shutdown()
server.server_close()
exit()
def start_udp(self, port):
"""Create a UDP server and start listening for data. Put any input data
on the inq for listen to read, and send any data on the outq. The
drvAsynIPPortConfigure should connect to localhost:port if the
simulation is on the same machine as the IOC."""
if self.started:
self.diagnostic("Server already started")
else:
self.inq, self.outq = Queue.Queue(), Queue.Queue()
self.started = True
self.udp = True
# store the request to respond to
self.outreq = None
def MakeHandler(device):
# make a basic tcp handler that puts messages on a queue
class ProxyHandler(BaseRequestHandler):
def setup(self):
BaseRequestHandler.setup(self)
device.onHandlerSetup(self)
def finish(self):
BaseRequestHandler.finish(self)
device.onHandlerFinish(self)
def handle(self):
if self.request != None:
data = "nothing yet"
device.outreq = (self.request[1],
self.client_address)
device.inq.put(self.request[0])
return ProxyHandler
self.server = ThreadingUDPServer(("", port), MakeHandler(self))
# start to listen on the master port
self.__daemon(self.server.serve_forever)
# start to respond to any messages put on the outq
self.__daemon(self.__ip_out)
# start the worker thread
self.__daemon(self.__process)
def __init__(self):
threading.Thread.__init__(self)
self.server = ThreadingUDPServer(('192.168.20.136', 20000), Handler)
def __init__(self):
threading.Thread.__init__(self)
self.server = ThreadingUDPServer(('', 20000), Handler)
else:
conf = mwconf.dbpc
dbpc_sender = dbpc(conf.host,
int(conf.port),
conf.service,
conf.component_prefix + MODULE_NAME,
logger,
int(conf.heartbeat_interval))
dbpc_sender.start()
logger.info('dbpc thread started. host is %s, port is %s' % (conf.host, conf.port))
try:
saver = threading.Thread(target=event_saver)
saver.setDaemon(True)
saver.start()
logger.info('cache saver thread running....')
logger.info("UDP Server start, host is %s, port is %d" %
(bind_host, bind_port))
server = ThreadingUDPServer((bind_host, bind_port), RequestHandler)
server.serve_forever()
saver.join()
except:
logger.error(
"catch unhandler exception, I will exit", exc_info=True)
# program exit. It's easy to be found
time.sleep(1)
os._exit(1)
def __init__(self):
super(ReceiveDataUDPServer, self).__init__()
self.daemon = True
# Setup threading UDP server
host, port = "", 9767
self.server = ThreadingUDPServer((host, port), ReceiveDataUDPHandler)
