def listenudp_server(udpport, bind_interface):
if not udpport == "":
port = int(udpport)
bindsuccess = False
errormsg = ""
nrattempts = 0
while nrattempts < 5 and not bindsuccess:
nrattempts += 1
bindsuccess = True
try:
if bind_interface == "":
server = SocketServer.ThreadingUDPServer(
('', port), SocketListener)
else:
server = SocketServer.ThreadingUDPServer(
('%s' % bind_interface, port), SocketListener)
open_sesame("udp", port)
server.serve_forever()
# if theres already something listening on this port
except Exception as err:
errormsg += socket.gethostname() + " | %s | Artillery error - unable to bind to UDP port %s\n" % (grab_time(), port)
errormsg += str(err)
errormsg += "\n"
bindsuccess = False
time.sleep(2)
continue
if not bindsuccess:
binderror = ''
bind_error = "Artillery was unable to bind to UDP port %s. This could be due to an active port in use.\n" % (port)
subject = socket.gethostname() + " | Artillery error - unable to bind to UDP port %s" % port
binderror += errormsg
write_log(binderror, 2)
send_mail(subject, binderror)
def __init__(self, name, port, handler, socktype, config):
self.name = name
self.port = port
self.socktype = socktype
self.server = None
globalconf = Config()
if socktype.upper() == 'UDP':
self.server = SocketServer.ThreadingUDPServer(('', port), handler)
elif socktype.upper() == 'TCP':
self.server = SocketServer.ThreadingTCPServer(('', port), handler)
elif socktype.upper() == 'SSL':
if not get_data_file(globalconf.certfile) or not get_data_file(
globalconf.keyfile):
log.warn("Cannot find certfile: %s or keyfile: %s for ssl",
globalconf.certfile, globalconf.keyfile)
else:
self.server = SocketServer.ThreadingTCPServer(('', port),
handler)
self.server.socket = ssl.wrap_socket(
self.server.socket,
keyfile=get_data_file(globalconf.keyfile),
certfile=get_data_file(globalconf.certfile),
server_side=True)
else:
log.warn("Unsupported or invalid socket type: %s for config '%s'",
socktype, name)
if self.server:
self.server.cfg = ModuleConfig(config).cfg
def negotiatedServe(self):
setFileName()
if not os.path.isdir(LOOT_PATH):
os.makedirs(LOOT_PATH)
self.servers = [
SocketServer.ThreadingUDPServer(('', 53), UDPRequestHandler),
]
for s in self.servers:
# that thread will start one more thread for each request
thread = threading.Thread(target=s.serve_forever)
# exit the server thread when the main thread terminates
thread.daemon = True
thread.start()
try:
while 1:
time.sleep(0.5)
sys.stderr.flush()
sys.stdout.flush()
except KeyboardInterrupt:
pass
finally:
for s in self.servers:
s.shutdown()
def receiveThread(self):
SocketServer.ThreadingUDPServer.allow_reuse_address = True
self.SS = SocketServer.ThreadingUDPServer(("", self.port), SimbaRequestHandler)
self.SS.dispatch = self.dispatch
self.SS.parser = ACLParser.ACLParser()
#print "SIMBA SS listening on port " + str(self.port)
self.SS.serve_forever()
def __init__(self):
super(ReceiveDataUDPServer, self).__init__()
self.daemon = True
# Setup threading UDP server
host, port = "", 9767
self.server = SocketServer.ThreadingUDPServer((host, port),
ReceiveDataUDPHandler)
def start_master(cls):
"""
Start up the master server and put its details into the options
namespace.
"""
logging.basicConfig(level=logging.INFO)
# Start up the logging server
cls.logging_server = SocketServer.ThreadingUDPServer(
("0.0.0.0", 0), LoggingDatagramHandler)
# Set up a thread to do all the serving in the background and exit when we
# do
cls.server_thread = threading.Thread(
target=cls.logging_server.serve_forever)
cls.server_thread.daemon = True
cls.server_thread.start()
# Set options for logging in the class and the options namespace
# Save them in the environment so they get sent out to jobs
os.environ["RT_LOGGING_HOST"] = socket.getfqdn()
os.environ["RT_LOGGING_PORT"] = str(
cls.logging_server.server_address[1])
def startDnsServers(self):
self.servers = [
SocketServer.ThreadingUDPServer(('', 53), UDPRequestHandler),
]
for s in self.servers:
# that thread will start one more thread for each request
thread = threading.Thread(target=s.serve_forever)
# exit the server thread when the main thread terminates
thread.daemon = True
thread.start()
print "%s server loop running in thread: %s" % (s.RequestHandlerClass.__name__[:3], thread.name)
def discover(waitfor=MY_NUMBER_UNITS,
timeout=5,
listen_address="0.0.0.0",
listen_port=0,
probe_port=30050,
probe_address='255.255.255.255',
probe_attempts=10,
probe_interval=0.2):
discovered = {}
class UDPRequestHandler(SocketServer.BaseRequestHandler):
def handle(self):
log.debug("Discovery: received response from {} - '{}'".format(
self.client_address[0], self.request[0]))
resp = process_response(self.request[0])
host = self.client_address[0]
discovered[host] = resp
sckt = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sckt.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
sckt.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
server = SocketServer.ThreadingUDPServer((listen_address, listen_port),
UDPRequestHandler)
server.socket = sckt
srv_addr, srv_port = server.server_address
server_thread = threading.Thread(target=server.serve_forever)
# Exit the server thread when the main thread terminates
server_thread.daemon = True
log.debug("Discovery: starting UDP server on {}:{}".format(
srv_addr, srv_port))
server_thread.start()
for i in range(0, probe_attempts):
log.debug("Discovery: probe attempt {} on {}:{}".format(
i, probe_address, probe_port))
sckt.sendto(DSCV_TXT.encode(), (probe_address, probe_port))
log.debug("Discovery: sleeping for {}s".format(probe_interval))
time.sleep(probe_interval)
if len(discovered) >= waitfor:
break
remaining_time = timeout - (probe_interval * probe_attempts)
if (remaining_time > 0) and (len(discovered) < waitfor):
log.debug(
"Discovery: waiting responses for {}s more".format(remaining_time))
time.sleep(remaining_time)
server.shutdown()
server.server_close()
return discovered
def listenudp_server(udpport, bind_interface):
try:
port = int(udpport)
if bind_interface == "":
server = SocketServer.ThreadingUDPServer(
('', port), SocketListener)
else:
server = SocketServer.ThreadingUDPServer(
('%s' % bind_interface, port), SocketListener)
if honeypot_autoaccept:
ban_check = read_config("HONEYPOT_BAN").lower()
if ban_check == "on":
subprocess.Popen(
"iptables -A ARTILLERY -p udp --dport %s -j ACCEPT" % port, shell=True).wait()
server.serve_forever()
# if theres already something listening on this port
except Exception:
# write a log if we are unable to bind to an interface
write_log("[!] %s: Artillery was unable to bind to UDP port: %s. This could be to an active port in use." % (
grab_time(), port))
pass
def main():
server = SocketServer.ThreadingUDPServer(
(os.environ.get('LISTEN_HOSTNAME')
or 'localhost', int(os.environ.get('LISTEN_PORT') or '53')),
BaseRequestHandler,
bind_and_activate=False)
server.allow_reuse_address = True
try:
server.server_bind()
os.setgroups([])
os.setegid(pwd.getpwnam('nobody').pw_gid)
os.seteuid(pwd.getpwnam('nobody').pw_uid)
server.server_activate()
server.serve_forever()
except KeyboardInterrupt:
server.shutdown()
def run(self, host, port):
class ThreadedUDPRequestHandler(SocketServer.BaseRequestHandler):
def handle(sub_self):
message = sub_self.request[0]
try:
self.handle_message(message, sub_self.client_address)
except:
logger.error('exc occur.', exc_info=True)
server = SocketServer.ThreadingUDPServer((host, port),
ThreadedUDPRequestHandler)
try:
server.serve_forever()
except KeyboardInterrupt:
pass
except:
logger.error('exc occur.', exc_info=True)
def init_event_server():
utils.setup_logger()
utils.load_all()
port = utils.get_config("port")
if port is None:
sys.stderr.write("Unable to get Port details from Config\n")
sys.exit(1)
# Start the Eventing Server, UDP Server
try:
server = SocketServer.ThreadingUDPServer((SERVER_ADDRESS, port),
GlusterEventsRequestHandler)
except socket.error as e:
sys.stderr.write("Failed to start Eventsd: {0}\n".format(e))
sys.exit(1)
server.serve_forever()
def main():
parser = argparse.ArgumentParser(description='Start a DNS implemented in Python.')
parser = argparse.ArgumentParser(description='Start a DNS implemented in Python. Usually DNSs use UDP on port 53.')
parser.add_argument('--port', default=53, type=int, help='The port to listen on.')
parser.add_argument('--tcp', action='store_true', help='Listen to TCP connections.')
parser.add_argument('--udp', action='store_true', help='Listen to UDP datagrams.')
parser.add_argument('--DNS', type=str, help='DNS address for the server.')
if not args.DNS: parser.error("Please add a DNS")
DOMAN_NAME = args.DNS
parser.add_argument('--IP', type=str, help='IP address for the server.')
if not args.IP: parser.error("Please add an IP")
IP = args.IP
parser.add_argument('--NS', type=str, help='NS address for the server.')
if not args.NS: parser.error("Please add a NS")
NS = args.NS
args = parser.parse_args()
if not (args.udp or args.tcp): parser.error("Please select at least one of --udp or --tcp.")
logging.info("Starting nameserver...")
servers = []
if args.udp: servers.append(SocketServer.ThreadingUDPServer(('', args.port), UDPRequestHandler))
if args.tcp: servers.append(SocketServer.ThreadingTCPServer(('', args.port), TCPRequestHandler))
for s in servers:
thread = threading.Thread(target=s.serve_forever) # that thread will start one more thread for each request
thread.daemon = True # exit the server thread when the main thread terminates
thread.start()
logging.info("%s server loop running in thread: %s" % (s.RequestHandlerClass.__name__[:3], thread.name))
try:
while 1:
time.sleep(1)
sys.stderr.flush()
sys.stdout.flush()
except KeyboardInterrupt:
pass
finally:
for s in servers:
s.shutdown()
def _startLeader(cls, batchSystem, level=defaultLevel):
with cls.lock:
if cls.initialized == 0:
cls.initialized += 1
if level:
log.info('Starting real-time logging.')
# Start up the logging server
cls.loggingServer = SocketServer.ThreadingUDPServer(
server_address=('0.0.0.0', 0),
RequestHandlerClass=LoggingDatagramHandler)
# Set up a thread to do all the serving in the background and exit when we do
cls.serverThread = threading.Thread(
target=cls.loggingServer.serve_forever)
cls.serverThread.daemon = True
cls.serverThread.start()
# Set options for logging in the environment so they get sent out to jobs
fqdn = socket.getfqdn()
try:
ip = socket.gethostbyname(fqdn)
except socket.gaierror:
# FIXME: Does this only happen for me? Should we librarize the work-around?
import platform
if platform.system() == 'Darwin' and '.' not in fqdn:
ip = socket.gethostbyname(fqdn + '.local')
else:
raise
port = cls.loggingServer.server_address[1]
def _setEnv(name, value):
name = cls.envPrefix + name
os.environ[name] = value
batchSystem.setEnv(name)
_setEnv('ADDRESS', '%s:%i' % (ip, port))
_setEnv('LEVEL', level)
else:
log.info('Real-time logging disabled')
else:
if level:
log.warn(
'Ignoring nested request to start real-time logging')
def main(penc, WebRequestFile=None,single=None):
global cmd,cmds,cr,rcvtime,newCommand,recvConn,client_ip
UDP_PORT = 53
s = SocketServer.ThreadingUDPServer(('',UDP_PORT),UDPRequestHandler)
thread = threading.Thread(target=s.serve_forever)
thread.daemon = True # exit the server thread when the main thread terminates
try:
thread.start()
if WebRequestFile:
thread2 = threading.Thread(target=send_reqT, args=(penc,))
thread2.daemon = True
thread2.start()
else:
print "[+] Generated Payload:\n%s" % penc
while thread.isAlive():
time.sleep(1)
sys.stdout.flush()
sys.stderr.flush()
if recvConn:
if len(cmds) >= 1 and cmds[-1] == 'END' or newCommand:
newCommand = 0
print "\n\n%s" % ''.join(cr)
print "[+] Command Completed Successfully."
cmds = []
cr = []
if single:
s.shutdown()
sys.exit()
else:
cmd = raw_input('SensePost-DNS-Shell::$ ')
if cmd == 'exit':
time.sleep(5)
s.shutdown()
sys.exit()
except KeyboardInterrupt:
print "%s" % ''.join(cr)
cmd = 'exit'
time.sleep(5)
#print("[+] 1st packet: %s seconds" % (time.time()-rcvtime))
s.shutdown()
sys.exit()
except:
raise
def run(self):
if self._protocol == "tcp":
try:
self._server = SocketServer.ThreadingTCPServer(
('', self._port), TCPHandler)
if self._use_ssl:
self._server.socket = ssl.wrap_socket(
self._server.socket,
keyfile="honeypoke_key.pem",
certfile="honeypoke_cert.pem",
do_handshake_on_connect=False,
cert_reqs=ssl.CERT_NONE)
self._server.allow_reuse_address = True
self._server.on_handle = self.on_handle
self._server.server_activate()
self._server.use_ssl = self._use_ssl
self.ready()
while os.geteuid() == 0 or os.getegid() == 0:
pass
print "Starting TCP server at " + str(self._port) + "\n"
self._server.serve_forever()
except Exception as e:
print "!- Error at starting TCP thread for port " + str(
self._port) + ", Error: " + str(e) + str(
sys.exc_info()) + traceback.format_exc()
elif self._protocol == "udp":
try:
self._server = SocketServer.ThreadingUDPServer(
('', self._port), UDPHandler)
self._server.allow_reuse_address = True
self._server.on_handle = self.on_handle
self._server.server_activate()
self.ready()
while os.geteuid() == 0 or os.getegid() == 0:
pass
print "Starting UDP server at " + str(self._port) + "\n"
self._server.serve_forever()
except Exception as e:
print "!- Error at starting UDP thread for port " + str(
self._port) + ", Error: " + str(e)
else:
print("Invalid protocol")
def main():
options = parse_args(
sys.argv) # This holds the nicely-parsed options object
logging.basicConfig(level=logging.DEBUG)
# Start up the logging server
logging_server = SocketServer.ThreadingUDPServer(("0.0.0.0", 0),
LoggingDatagramHandler)
print("Starting server")
# Set up a thread to do all the serving in the background and exit when we
# do
server_thread = threading.Thread(target=logging_server.serve_forever)
server_thread.daemon = True
server_thread.start()
print("Server started")
# HACK: Set options for logging and pass the options to every target
options.log_host = socket.getfqdn()
options.log_port = logging_server.server_address[1]
RealTimeLogger.set_master(options)
logger = RealTimeLogger.get()
# Make the root job
root_job = Job.wrapJobFn(downloadAllReads,
options,
cores=1,
memory="1G",
disk="4G")
print("Sending log from master")
logger.info("This is the master")
# Run Toil
Job.Runner.startToil(root_job, options)
logging_server.shutdown()
server_thread.join()
def main(args):
global PORT, CDN_SPECIFIC_NAME, HOST, DEPLOYED, DNS_RECORDS_DICT
signal.signal(signal.SIGINT, signal_handler)
# intialize things
setGlobalVariables(args)
#DNS_RECORDS_DICT = getHostnamesAndIPDict()
# populate DNS records
# start DNS Server
server = SocketServer.ThreadingUDPServer((HOST, PORT), DNSUDPHandler)
HOST, PORT = server.server_address
if not DEPLOYED:
print DNS_RECORDS_DICT
print HOST + ":" + str(PORT)
# spawn a thread to manage the active measurement dictionary
amu = threading.Thread(target=ACTIVE_MEASUREMENT_UPDATE)
amu.daemon = True
amu.start()
# handle requests
server.serve_forever()
def start_server(port=PORT):
logging.info("Starting nameserver...")
servers = [
SocketServer.ThreadingUDPServer(('127.0.0.1', port),
UDPRequestHandler),
SocketServer.ThreadingTCPServer(('127.0.0.1', port),
TCPRequestHandler),
]
routines = [
threading.Thread(name='CacheManager', target=cache_manager, args=())
]
for s in servers:
thread = threading.Thread(target=s.serve_forever)
# that thread will start one more thread for each request
thread.daemon = True
# exit the server thread when the main thread terminates
thread.start()
logging.info("%s server loop running in thread: %s",\
s.RequestHandlerClass.__name__[:3], thread.name)
for r in routines:
r.daemon = True
r.start()
logging.info("Routine %s started", r.name)
try:
while 1:
time.sleep(1)
sys.stderr.flush()
sys.stdout.flush()
except KeyboardInterrupt:
pass
finally:
logging.warning('Shutting down servers')
for s in servers:
s.shutdown()
def main():
port = 53
servers = [
SocketServer.ThreadingUDPServer(('', port),
UDPRequestHandler).serve_forever,
SocketServer.ThreadingTCPServer(('', port),
TCPRequestHandler).serve_forever,
lambda: app.run(host='0.0.0.0', port=80)
]
for s in servers:
thread = threading.Thread(target=s)
thread.daemon = True
thread.start()
try:
while True:
time.sleep(0.1)
sys.stderr.flush()
sys.stdout.flush()
except KeyboardInterrupt:
pass
finally:
sys.exit()
server.sendto(fdata,client_addr)
print "forward status ok"
print "-------------"
def checkdmkey(self,dm):
'''
判断 domainkey.conf 中的关键词 是否在 要求解析的 域名里面
例如 domainkey.conf 有 baidu.com ,那么 如果解析的域名是 xxx.baidu.com ,则返回True
'''
for i in domainkey:
if i in dm :
return True
return False
if __name__ == '__main__':
pwd=os.path.split(os.path.realpath(__file__))[0]
dk=open(pwd+"/domainkey.conf",'r')
domainkey=dk.read().split()
dk.close()
print domainkey
forwardserver=forwardto()
ip_port =('0.0.0.0',53)
obj =SocketServer.ThreadingUDPServer(ip_port,My_server)
obj.serve_forever()
except Exception as e:
print e
class UDPRQH(RQHandler):
def get_data(self):
return self.request[0]
def send_data(self, data):
# print data
return self.request[1].sendto(data, self.client_address)
if __name__ == '__main__':
print "Server starting..."
server = [SocketServer.ThreadingUDPServer(('', port), UDPRQH)]
for s in server:
thread = threading.Thread(target=s.serve_forever)
thread.daemon = True
thread.start()
print "Server is ready to recieve"
try:
while 1:
time.sleep(1)
sys.stderr.flush()
sys.stdout.flush()
except KeyboardInterrupt:
pass
finally:
for s in server:
s.shutdown()
def __init__(self, ctx):
super(DNSListener, self).__init__(ctx)
class DNSRequestHandler(SocketServer.BaseRequestHandler):
def get_data(self):
raise NotImplementedError
def send_data(self, data):
raise NotImplementedError
def dns_response(self, data):
request = DNSRecord.parse(data)
reply = DNSRecord(DNSHeader(id=request.header.id,
qr=1,
aa=1,
ra=1),
q=request.q)
qname = request.q.qname
qn = str(qname)
qtype = request.q.qtype
qt = QTYPE[qtype]
log.debug("Request {} {}".format(qt, qn))
ctx.report.report_dns(qn, qt)
if qt == '*':
log.debug("* -> A")
qt = "A"
if qt == "A":
log.debug("Reply -> 127.0.0.1")
reply.add_answer(
RR(rname=qname, ttl=60 * 5, rdata=A("127.0.0.1")))
else:
log.warning("Unsupported query: {} {}".format(qt, qn))
return reply.pack()
def handle(self):
try:
data = self.get_data()
self.send_data(self.dns_response(data))
except Exception:
import traceback
log.exception(traceback.format_exc())
class TCPRequestHandler(DNSRequestHandler):
def get_data(self):
data = self.request.recv(8192).strip()
sz = int(data[:2].encode('hex'), 16)
if sz < len(data) - 2:
log.error("Wrong size of TCP packet")
return
elif sz > len(data) - 2:
log.error("Too big TCP packet")
return
return data[2:]
def send_data(self, data):
sz = hex(len(data))[2:].zfill(4).decode('hex')
return self.request.sendall(sz + data)
class UDPRequestHandler(DNSRequestHandler):
def get_data(self):
return self.request[0].strip()
def send_data(self, data):
return self.request[1].sendto(data, self.client_address)
self.servers = [
SocketServer.ThreadingUDPServer(('127.0.0.1', 53),
UDPRequestHandler),
SocketServer.ThreadingTCPServer(('127.0.0.1', 53),
TCPRequestHandler),
]
print "[%s] - %s" % (now, debugstring)
class UDPRequestHandler(BaseRequestHandler):
def get_data(self):
return self.request[0].strip()
def send_data(self, data):
return self.request[1].sendto(data, self.client_address)
if __name__ == '__main__':
print "Starting nameserver..."
servers = [
SocketServer.ThreadingUDPServer(('', int(args.port)),
UDPRequestHandler),
]
for s in servers:
thread = threading.Thread(
target=s.serve_forever
) # that thread will start one more thread for each request
thread.daemon = True # exit the server thread when the main thread terminates
thread.start()
print "%s server loop running in thread: %s" % (
s.RequestHandlerClass.__name__[:3], thread.name)
while 1:
inputs = []
outputs = []
for sess in SESSIONS:
def run(host, port):
server = SocketServer.ThreadingUDPServer( (host, port), AiUDPServer)
server.serve_forever()
def connect(self):
share = self
# run UDP server
class UDPHandler(SocketServer.BaseRequestHandler):
def handle(self):
data = self.request[0].strip()
logging.debug("{0}: {1}".format(self.client_address[0], data))
cmd = data[4:8]
if cmd == "HEY?": # response to HEY!-request
send_broadcast(
options["UDP_PORT"],
"LNS:HEY!:{0}".format(options["SELF_ADDRESS"]))
elif cmd == "HEY!":
share.attach(data[9:])
else:
logging.error("unexpected command={0} in {1}".format(
cmd, data))
self.__udp_server = SocketServer.ThreadingUDPServer(
('', options["UDP_PORT"]), UDPHandler)
thread.start_new_thread(
lambda *args: self.__udp_server.serve_forever(), ('UDPServer', ))
logging.info("share udp server started")
# run timer (UDP-broadcasting, share updating)
class Timer:
def __init__(self):
self.__interval = 5
self.__terminate_interval = 0.5
self.__terminate = False
def run(self):
ts = self.__interval
while not self.__terminate:
if ts > self.__interval:
share.update(self.__interval)
send_broadcast(options["UDP_PORT"], "LNS:HEY?")
ts = 0
time.sleep(self.__terminate_interval)
ts += self.__terminate_interval
logging.info("share timer terminated; OK")
def terminate(self):
logging.info("terminating share timer")
self.__terminate = True
self.__timer = Timer()
thread.start_new_thread(lambda *args: self.__timer.run(), ("Timer", ))
logging.info("share timer started")
# run HTTP server
class HTTPHandler(BaseHTTPRequestHandler):
def do_GET_entry(self, name):
entry = share.get_local_entry(name)
if not entry:
logging.warn("entry \"{0}\" NOT FOUND".format(name))
self.send_error(404)
return
path = entry.path
if os.path.isdir(path):
path = options["TEMP"] + os.sep + name + '.tar'
http_serve(self, path)
def do_GET(self):
if self.path == "/":
self.path = "/static/index.html"
response = ""
if self.path == "/ls":
logging.debug("/js; querying all share-points")
total_list = {}
for addr in share.get_points().iterkeys():
# list files at given address
response = http_get("http://{0}:{1}/local".format(
addr, options["HTTP_PORT"]))
total_list[addr] = json.loads(response)
response = json.dumps(total_list)
elif self.path == "/local": # list local entries
logging.debug("/local; listing local entries")
entries = share.get_local_entries()
class EntryJSONEncoder(json.JSONEncoder):
def default(self, obj):
if isinstance(obj, Share.Entry):
return {"size": obj.size, "isdir": obj.isdir}
else:
return json.JSONEncoder.default(self, obj)
response = json.dumps(entries, cls=EntryJSONEncoder)
elif self.path.startswith("/entry/"):
self.do_GET_entry(self.path[7:])
return
elif self.path.startswith("/static/"):
http_serve(self, self.path[1:])
return
else:
self.send_error(404)
return
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write(response)
def do_POST(self):
if self.path == "/share":
length = int(self.headers['Content-Length'])
content = self.rfile.read(length)
path_list = json.loads(content)
result = share.share(path_list)
elif self.path == "/rm":
length = int(self.headers['Content-Length'])
content = u'' + self.rfile.read(length)
result = share.remove(content)
else:
self.send_error(404)
return
self.send_response(200)
self.send_header("Content-type", "text/plain")
self.end_headers()
self.wfile.write(result)
class ThreadingHTTPServer(SocketServer.ThreadingMixIn, HTTPServer):
pass
self.__http_server = ThreadingHTTPServer(('', options["HTTP_PORT"]),
HTTPHandler)
thread.start_new_thread(
lambda *args: self.__http_server.serve_forever(), ('HTTPServer', ))
logging.info("http server started")
return self.request.sendall(sz + data)
class UDPRequestHandler(BaseRequestHandler):
def get_data(self):
return self.request[0].strip()
def send_data(self, data):
return self.request[1].sendto(data, self.client_address)
if __name__ == '__main__':
print "Starting nameserver..."
servers = [
SocketServer.ThreadingUDPServer((BIND_HOST, BIND_PORT),
UDPRequestHandler),
SocketServer.ThreadingTCPServer((BIND_HOST, BIND_PORT),
TCPRequestHandler),
]
for s in servers:
thread = threading.Thread(
target=s.serve_forever
) # that thread will start one more thread for each request
thread.daemon = True # exit the server thread when the main thread terminates
thread.start()
print "%s server loop running in thread: %s" % (
s.RequestHandlerClass.__name__[:3], thread.name)
try:
while 1:
time.sleep(1)
#print(self.client_address,self.request[1])
#self.request[1].sendto('bbb'.encode('utf-8'), self.client_address)
try:
setMessage(data.decode('utf-8'))
except socket.error:
print '\r\nsocket error occur '
reConnect(data.decode('utf-8'))
except:
print '\r\nother error occur '
def doConnect(host,port):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
try :
sock.connect((host,port))
except :
pass
return sock
if __name__=='__main__':
try:
print getip('eth0')
host = getip('eth0')
except:
print 'Not net connect!'
print 'server is running....'
sockLocal = doConnect('127.0.0.1', 60001)
server = SocketServer.ThreadingUDPServer(addr,Servers)
server.serve_forever()
class UDPRequestHandler(BaseRequestHandler):
def get_data(self):
return self.request[0].strip()
def send_data(self, data):
return self.request[1].sendto(data, self.client_address)
if __name__ == '__main__':
print "Starting nameserver..."
servers = [
SocketServer.ThreadingUDPServer(('', PORT), UDPRequestHandler),
SocketServer.ThreadingTCPServer(('', PORT), TCPRequestHandler),
]
for s in servers:
thread = threading.Thread(target=s.serve_forever) # that thread will start one more thread for each request
thread.daemon = True # exit the server thread when the main thread terminates
thread.start()
print "%s server loop running in thread: %s" % (s.RequestHandlerClass.__name__[:3], thread.name)
try:
while 1:
time.sleep(1)
sys.stderr.flush()
sys.stdout.flush()
except KeyboardInterrupt:
query = DnsParser.parseQuery(data)
address = self.client_address
print("get dns query from %s,query:%s" %(str(address),str(query.qname)))
find = False
if query.qname in Hosts:
find = True
ip = Hosts[query.qname]
print("Find a Hint: %s:%s"%(query.qname, ip))
if find and query.qtype == "0x0001": #only handle A record
print('domain:%s in hosts' % query.qname)
response = DnsParser.generateReqponse(data,ip)
self.socket.sendto(response,address)
else:
print('transfer for %s' % query.qname)
sock = socket.socket(type=socket.SOCK_DGRAM)
socket.setdefaulttimeout(5)
sock.connect(LOCALDNS)
sock.send(data)
response, serveraddress = sock.recvfrom(8192*4)
self.socket.sendto(response,address)
if __name__ == "__main__":
HOST = "0.0.0.0"
PORT = 53
server = None
try:
server = SocketServer.ForkingUDPServer((HOST, PORT), DNSHandler)
except:
server = SocketServer.ThreadingUDPServer((HOST, PORT), DNSHandler)
server.serve_forever()
