def __init__(self, dns_server, disable_cache=False, host='127.0.0.1', port=53, hosts_file='/etc/hosts'):
self.dns_server = dns_server
self.hosts_file = hosts_file
self.host_lines = load_hosts(hosts_file)
self.disable_cache = disable_cache
self.cache = {}
ThreadingUDPServer.__init__(self, (host, port), DNSProxyHandler)
def __init__(self, ip_str, port_num, handler):
"""Constructor fills in the ip and port numbers, and sets up the response handler."""
self.SMPCentralNodeServerAddress = (ip_str, port_num)
self.Handler = handler;
# RQ 1
# RQ 3
ThreadingUDPServer.__init__(self, self.SMPCentralNodeServerAddress, self.Handler)
class upper_socket_server(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.server = ThreadingUDPServer(('192.168.20.136', 20000), Handler)
def run(self):
self.server.serve_forever()
def __init__(
self, host="localhost", port=logging.handlers.DEFAULT_UDP_LOGGING_PORT, handler=LogRecordDatagramHandler
):
ThreadingUDPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
self.logname = None
def __init__(self, dns_server, disable_cache=False, host='127.0.0.1', port=53, hosts_file='/etc/hosts'):
self.dns_server = dns_server
self.hosts_file = hosts_file
self.host_lines = load_hosts(hosts_file)
self.disable_cache = disable_cache
self.cache = {}
ThreadingUDPServer.__init__(self, (host, port), DNSProxyHandler)
def __init__(self, addr, handler, poll_interval=0.5, bind_and_activate=True):
class DelegatingUDPRequestHandler(DatagramRequestHandler):
def handle(self):
self.server._handler(self)
ThreadingUDPServer.__init__(self, addr, DelegatingUDPRequestHandler,
bind_and_activate)
ControlMixin.__init__(self, handler, poll_interval)
def __init__(self,racelistserver):
log(Log.INFO,"init broadcast server on port %s:%d" % (config.servername, config.broadcastport))
StopableThread.__init__(self)
self._racelistserver = racelistserver
self.allow_reuse_address = 1
ThreadingUDPServer.__init__(self,("",config.broadcastport),BroadCastServerRequestHandler)
def __init__(self,
host='localhost',
port=logging.handlers.DEFAULT_UDP_LOGGING_PORT,
handler=LogRecordDatagramHandler):
ThreadingUDPServer.__init__(self, (host, port), handler)
self.abort = 0
self.timeout = 1
self.logname = None
def __init__(self, ip_str, port_num, handler):
"""Constructor fills in the ip and port numbers, and sets up the response handler."""
self.SMPCentralNodeServerAddress = (ip_str, port_num)
self.Handler = handler
# RQ 1
# RQ 3
ThreadingUDPServer.__init__(self, self.SMPCentralNodeServerAddress,
self.Handler)
def __init__(self, addr, handler, poll_interval=0.5, bind_and_activate=True, interfaces=None):
ThreadingUDPServer.__init__(self, ('', addr[1]),
handler,
bind_and_activate)
ControlMixin.__init__(self, handler, poll_interval)
self._multicast_address = addr
self._listen_interfaces = interfaces
self.set_loopback_mode(1) # localhost
self.set_ttl(2) # localhost and local network
self.handle_membership(socket.IP_ADD_MEMBERSHIP)
def __init__(self, addr, handler, poll_interval=0.5, bind_and_activate=True, iface=None):
ThreadingUDPServer.__init__(self, ('', addr[1]),
handler,
bind_and_activate)
ControlMixin.__init__(self, handler, poll_interval)
self._multicast_address = addr
self._listen_interfaces = iface
self.setLoopbackMode(1) # localhost
self.setTTL(2) # localhost and local network
self.handle_membership(socket.IP_ADD_MEMBERSHIP)
def __init__(self,
dns_server,
disable_cache=False,
host='127.0.0.1',
port=53,
hooks=None):
self.dns_server = dns_server
self.cache = Cache()
self.cache.enabled = not disable_cache
self.hooks = hooks
ThreadingUDPServer.__init__(self, (host, port), DNSProxyHandler)
class upper_socket_server(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.server = ThreadingUDPServer(('', 20000), Handler)
def run(self):
self.server.serve_forever()
def go(self):
self.setDaemon(True)
self.start()
def __init__(self,
file_name,
port,
level=logging.INFO,
format_pattern=DEFAULT_FORMAT_PATTERN):
self.file_name = file_name
self.level = level
self.format_pattern = format_pattern
ThreadingUDPServer.__init__(self, ('127.0.0.1', port),
LogRecordHandler)
self.abort = 0
self.timeout = 1
def __init__(self,
addr,
handler,
poll_interval=0.5,
bind_and_activate=True):
class DelegatingUDPRequestHandler(DatagramRequestHandler):
def handle(self):
self.server._handler(self)
ThreadingUDPServer.__init__(self, addr, DelegatingUDPRequestHandler,
bind_and_activate)
ControlMixin.__init__(self, handler, poll_interval)
def __init__(self):
log = open(DNS_LOCAL_PATH+'switch.log','w')
log.write('This file will be clear up when restar !\nUnswitched DNS query :\n')
log.close()
self.hostslist = lodehosts()
self.switchlist = loadswitchfile()
self.servers,self.Log_all = loadconf()
if not self.servers:
print 'Loding ',DNS_CONFIG_FILE,' false '
sys.exit(0)
print 'z.DNS is running now ! \nUsing DNS : ' + self.servers[0] + ' ' + self.servers[1]
ThreadingUDPServer.__init__(self, ('127.0.0.1', 53), DNSProxyHandler)
def server_bind(self):
' Use ioctl signal to resolve address from interface. '
''' Set our socket to accept broadcast messages and limit down our
multicasting interfaces to the selected one. '''
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
self.socket.setsockopt(socket.IPPROTO_IP, socket.IP_MULTICAST_IF,
self.server_address[0])
' When binding we actually want _every_ address, for broadcasting. '
self.server_address = ('', self.server_address[1])
ThreadingUDPServer.server_bind(self)
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 start_malware_center(ip="localhost", port=56565):
'''Starts Malware Center.
Args:
ip: IP address of Malware Center server.
port: port of Malware Center server.
'''
server = ThreadingUDPServer((ip, port), Malware_request_handler)
server.allow_reuse_address = True
print("Malware Center started")
print("IP: " + ip)
print("PORT: " + str(port))
#print("new worm instance h3-eth0:77.77.77.77")
server.serve_forever()
def server_bind(self):
try:
if hasattr(socket, "SO_REUSEADDR"):
self.socket.setsockopt(
socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
except Exception as e:
logging.log(e)
try:
if hasattr(socket, "SO_REUSEPORT"):
self.socket.setsockopt(
socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
except Exception as e:
logging.log(e)
ThreadingUDPServer.server_bind(self)
def server_bind(self):
try:
if hasattr(socket, "SO_REUSEADDR"):
self.socket.setsockopt(
socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
except Exception as e:
logger.error(e)
try:
if hasattr(socket, "SO_REUSEPORT"):
self.socket.setsockopt(
socket.SOL_SOCKET, socket.SO_REUSEPORT, 1)
except Exception as e:
logger.error(e)
ThreadingUDPServer.server_bind(self)
def __init__(
self,
dns_server,
backup_server=None,
disable_cache=False,
host="127.0.0.1",
port=53,
hosts_file=DEFAULT_FILE,
):
self.dns_server = dns_server
self.backup_server = backup_server
self.hosts_file = hosts_file
self.host_lines = load_hosts(hosts_file)
self.disable_cache = disable_cache
self.cache = {}
ThreadingUDPServer.__init__(self, (host, port), DNSProxyHandler)
def __init__(self, addr, clients):
self.clients = clients
broadcast = inet_iton(clients.subnet + clients.hosts + 1)
# Set static options
self.server_opts = {
1 : clients.mask, # Subnet mask
3 : clients.addr, # Router address
6 : clients.addr, # Domain Name Server address
28 : broadcast, # Broadcast address
51 : 60 * 60, # IP address lease time
54 : clients.addr, # DHCP Server identifier
58 : 60 * 30, # Renewal time
59 : 60 * 50 # Rebinding time
}
ThreadingUDPServer.__init__(self, (addr, 67), self.handle_message)
class ReceiveDataUDPServer(threading.Thread):
"""Thread the runs the main UDP Server"""
def __init__(self):
super(ReceiveDataUDPServer, self).__init__()
self.daemon = True
# Setup threading UDP server
host, port = "", 9767
self.server = ThreadingUDPServer((host, port), ReceiveDataUDPHandler)
def run(self):
"""Run method"""
self.server.serve_forever()
def stop(self):
"""Stop the UDP server"""
LOG.info('UDP server stop called')
self.server.shutdown()
while self.isAlive():
time.sleep(0.01)
LOG.info('UDP server stopped')
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 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 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 __init__(self, local, master, hosts):
self.local = local
self.master = master
self.hosts = hosts
ThreadingUDPServer.__init__(self, local, ProxyDnsHandler)
def __init__(self, disable_cache=False, host='127.0.0.1', port=53000):
self.disable_cache = disable_cache
self.cache = {}
ThreadingUDPServer.__init__(self, (host, port), DNSHandler)
def __init__(self, port_num):
ThreadingUDPServer.__init__(self, ('', port_num), DNS_Handler_class)
return
def __init__(self, server_address, data_store_handler,
RequestHandlerClass=DRRequestHandler,
bind_and_activate=True):
ThreadingUDPServer.__init__(self, server_address, RequestHandlerClass)
self.data_store_handler = data_store_handler
def __init__(self, port_num):
ThreadingUDPServer.__init__(self, ('',port_num), DNS_Handler_class)
return
def start_malware_center(self, ip="1.2.3.254", port=56565):
server = ThreadingUDPServer((ip, port), Malware_request_handler)
server.allow_reuse_address = True
print("server started")
server.serve_forever()
return server
def __init__(self):
super(ReceiveDataUDPServer, self).__init__()
self.daemon = True
# Setup threading UDP server
host, port = "", 9767
self.server = ThreadingUDPServer((host, port), ReceiveDataUDPHandler)
stream_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
from logging import getLogger
log = getLogger(__name__)
log.addHandler(file_handler)
# log.addHandler(stream_handler)
# f**k = getLogger("{}_stream_logger".format(__name__))
# f**k.addHandler(stream_handler)
from logging import INFO
log.setLevel(INFO)
# f**k.setLevel(INFO)
intercept_domain, intercept_rr = [], []
with open(args.intercept) as zonefile:
for zone in zonefile:
intercept_domain.append(zone.split(" ")[0])
intercept_rr.append(zone)
intercept_domain = list(set(intercept_domain))
server = ThreadingUDPServer((args.host, args.port), CleanDNSHandler)
# server_thread = Thread(target=server.serve_forever)
# server_thread.daemon = False
try:
# server_thread.start()
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
server.server_close()
def __init__(self, local_server, dns_server, hosts='/ets/hosts'):
self.local_server = local_server
self.dns_server = dns_server
self.hosts = Hosts(hosts)
ThreadingUDPServer.__init__(self, local_server, DnsProxyHandler)
def __init__(self, local_server, dns_server):
self.local_server = local_server
self.dns_server = dns_server
ThreadingUDPServer.__init__(self, local_server, DnsProxyHandler)
def __init__(self, addr, handler, timeout=1):
ThreadingUDPServer.__init__(self, addr, LogRecordDatagramHandler)
BaseServer.__init__(self, handler, timeout)
class DNSFlowServer(ThreadingUDPServer):
"""Central threading UDP server (central console) class."""
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 _pad_pkcs7_block(self, msg, blocksize):
"""PKCS#7 padding. Returns string."""
nrpad = blocksize - (len(msg) % blocksize)
return msg + chr(nrpad) * nrpad
def process_flow(self):
"""Process received flow with registered IDS filters. Returns
nothing.
"""
while True:
addr, pkt = self.server.queue.get()
self.pktcount += 1
# dump debug info
logging.debug('Current time: %s | Packet number: %d \
| Received from: %s | Packet dump: %s' % (time.asctime(), self.pktcount,
addr, pkt))
# process IDS filters
for i in self.filterlist:
logging.debug('Calling IDS filter: %s', i)
i(pkt)
class DNSFlowServer(ThreadingUDPServer):
"""Central threading UDP server (central console) class."""
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 _pad_pkcs7_block(self, msg, blocksize):
"""PKCS#7 padding. Returns string."""
nrpad = blocksize - (len(msg) % blocksize)
return msg + chr(nrpad) * nrpad
def process_flow(self):
"""Process received flow with registered IDS filters. Returns
nothing.
"""
while True:
addr, pkt = self.server.queue.get()
self.pktcount += 1
# dump debug info
logging.debug('Current time: %s | Packet number: %d \
| Received from: %s | Packet dump: %s' %
(time.asctime(), self.pktcount, addr, pkt))
# process IDS filters
for i in self.filterlist:
logging.debug('Calling IDS filter: %s', i)
i(pkt)
def __init__(self, local_server, dns_server, hosts='/ets/hosts'):
self.local_server = local_server
self.dns_server = dns_server
self.hosts = Hosts(hosts)
ThreadingUDPServer.__init__(self, local_server, DnsProxyHandler)
def __init__(self, disable_cache=False, host='127.0.0.1', port=53000):
self.disable_cache = disable_cache
self.cache = {}
ThreadingUDPServer.__init__(self, (host, port), DNSHandler)
def __init__(self, server, hosts, proxy_dns):
self.hosts = hosts
self.proxy_dns = proxy_dns
ThreadingUDPServer.__init__(self, server, CmdHandler)
server_port = int(cf["server_port"])
server_address = (server_ip,server_port)
class listener(DRH):
def handle(self):
gqueue.put((self.request[0],self.client_address))
if __name__ == '__main__':
print("begin to listen")
num = int(cf["num_threads"])
for i in range(num):
p = Process(target=handle,args=(tuple()))
p.start()
try :
server = UDP(server_address,listener)
except Exception as err:
logging.error(err)
logging.error("no server has been built")
logger.error("不能建立server，建立server有问题，err为%s"%(err))
server.serve_forever()
print("end listen")
def __init__(self):
threading.Thread.__init__(self)
self.server = ThreadingUDPServer(('', 20000), Handler)
def __init__(self, server_addr, reqhandler, log_dirname): ThreadingUDPServer.__init__(self, server_addr, reqhandler); self.log_dirname = log_dirname;
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)
from logging import Formatter
formatter = Formatter(
fmt='%(asctime)s %(lineno)d %(message)s',
datefmt='%Y-%m-%d %H:%M:%S')
stream_handler.setFormatter(formatter)
file_handler.setFormatter(formatter)
from logging import getLogger
log = getLogger(__name__)
log.addHandler(file_handler)
f**k = getLogger("{}_stream_logger".format(__name__))
f**k.addHandler(stream_handler)
from logging import INFO
log.setLevel(INFO)
f**k.setLevel(INFO)
frequency_db = StrictRedis(db=FREQUENCY_DB_NO)
cache_db = StrictRedis(db=CACHE_DB_NO)
setup_domain_db = StrictRedis(db=SETUP_DOMAIN_DB_NO)
gray_domain_db = StrictRedis(db=GRAY_DOMAIN_DB_NO)
server = ThreadingUDPServer(("0.0.0.0", 5353), CleanDNSHandler)
server_thread = Thread(target=server.serve_forever)
server_thread.daemon = True
try:
f**k.info("threading DNS server start at 0.0.0.0:53")
server_thread.start()
except KeyboardInterrupt:
f**k.info("keyborad interrupt!")
server.shutdown()
server.server_close()
def __init__(self, addr, handler, timeout=1):
ThreadingUDPServer.__init__(self, addr, LogRecordDatagramHandler)
BaseServer.__init__(self, handler, timeout)
def __init__(self, local, master, hosts):
self.local = local
self.master = master
self.hosts = hosts
ThreadingUDPServer.__init__(self, local, ProxyDnsHandler)
server_ip = cf["server_ip"]
server_port = int(cf["server_port"])
server_address = (server_ip, server_port)
class listener(DRH):
def handle(self):
gqueue.put((self.request[0], self.client_address))
if __name__ == '__main__':
print("begin to listen")
num = int(cf["num_threads"])
for i in range(num):
p = Process(target=handle, args=(tuple()))
p.start()
try:
server = UDP(server_address, listener)
except Exception as err:
logging.error(err)
logging.error("no server has been built")
logger.error("不能建立server，建立server有问题，err为%s" % (err))
server.serve_forever()
print("end listen")
def __init__( self, port,name,liveaddr, handle=handle ):
self.name=name
self.liveaddr=liveaddr
UDP.__init__( self, ('', port), handle )
def __init__(self, port):
ThreadingUDPServer.__init__(self, ('', port), RequestHandler)
def __init__(self):
threading.Thread.__init__(self)
self.server = ThreadingUDPServer(('192.168.20.136', 20000), Handler)
self.is_server = False
self.translate_table = {}
self.security_belt = []
BaseRequestHandler.__init__(self, *args, **kwargs)
def handle(self):
self.address = self.server.server_address[0]
data = self.request[0]
socket = self.request[1]
sender_address = self.client_address
if "search" in data.split(" "):
key = data.split(" ")[-1]
if self.is_server:
if key in self.translate_table:
socket.sendto(json.dumps(self.translate_table[key]), sender_address)
elif self.security_belt:
#TODO: ask other servers
pass
else:
socket.sendto(json.dumps([None]), sender_address)
elif key == self.server.name:
socket.sendto(json.dumps([self.address]), sender_address)
if __name__ == "__main__":
HOST, PORT = "localhost", 5000
server = ThreadingUDPServer((HOST, PORT), Node)
server.name = "test"
ip, port = server.server_address
server.serve_forever()
