print("send msg", send_msg)
sock.sendto(send_msg, address)
battle_manager.dispatch_receive_data(data, send_func)
# # 如果没有需要发的，就什么都不发
# if len(msg_datas) == 0:
# return
# client_manager.broadcast_to_clients(send_func)
# for address in all_clients:
# for send_msg in send_msgs:
# send_msg = send_msg.encode()
# print("send msg", send_msg)
# sock.sendto(send_msg, address)
battle_manager = BattleManager()
queue_manager = QueueManager()
client_manager = ClientManager()
frame_manager = FrameManager()
if __name__ == '__main__':
from socketserver import ThreadingUDPServer
from test_package.demo import test_import
test_import()
frame_manager.start_step()
server = ThreadingUDPServer(('', 20000), TimeHandler)
server.serve_forever()
def __init__(self, port=53, lib={}, debug_mode=0, dns_addr=''):
DNSServer.lib = lib
self.port = port
DNSServer.debug_mode = debug_mode
DNSServer.dns_addr = dns_addr
self.server = ThreadingUDPServer((HOST_IP, self.port), DNSHandler)
FileType TEXT NOT NULL
);''')
conn.execute(
'INSERT INTO FILES (FileName, FileType) VALUES (:file_name, :file_type)',
{
"file_name": 'test_text.txt',
"file_type": 'text'
})
conn.commit()
conn.execute(
'INSERT INTO FILES (FileName, FileType) VALUES (:file_name, :file_type)',
{
"file_name": 'hello.bin',
"file_type": 'binary'
})
conn.commit()
conn.close()
ThreadingUDPServer.allow_reuse_address = True
ThreadingUDPServer.daemon_threads = True
with ThreadingUDPServer((host, port), ThreadedServerHandler) as server:
try:
print(
f'\n{datetime.now()}',
f'\nStarting UDP server at {host}:{port}\nQuit the server with CONTROL-C.\n'
)
server.serve_forever()
except KeyboardInterrupt:
print('')
server.shutdown()
default="Empty")
parser.add_argument("--port",
help="set listen port",
action="store",
type=int,
default=53)
parser.add_argument("--debug",
help="enable debug logging",
action="store_true")
args = parser.parse_args()
if str(args.ip).upper() == "ENV":
args.ip = environ.get("PUB_IP")
if args.debug:
print('IP: %s Port: %s' % (args.ip, args.port))
if environ.get("DNS_ALLOW_ALL") == "YES" or args.whitelist == "ALL":
allow_all = True
else:
if args.whitelist != "Empty":
with open(args.whitelist) as f:
w_list.extend(f.read().splitlines())
try:
udp_sock = ThreadingUDPServer(("0.0.0.0", args.port), PacketHandler)
udp_sock.serve_forever()
except KeyboardInterrupt:
if args.debug:
print("done.")
def init_udp(self):
"""Init and start UDP server"""
server = ThreadingUDPServer(('0.0.0.0', self.conf['port']),
ServerSearchHandler)
server.app = self
return server
self.rcode = bitslice(byte2, 4, 4)
self.qdcount = recvData[4:6]
self.ancount = recvData[6:8]
self.nscount = recvData[8:10]
self.arcount = recvData[10:12]
class question(object):
def parse(self, recvData):
length = len(recvData)
self.qname = recvData[12:length - 4]
self.qtype = recvData[length - 4:length - 2]
self.qclass = recvData[length - 2:]
class answer(object):
def response(self, qname, ip):
self.name = qname
self.type = 1
self.aclass = 1
self.ttl = 600
self.rdlength = 4
ip = ip.split('.', 3)
self.rdata = int(ip[0]) * (1 << 24) + int(ip[1]) * (1 << 16) + int(
ip[2]) * (1 << 8) + int(ip[3])
if __name__ == '__main__':
serv = ThreadingUDPServer(('127.0.0.1', 53), myserver)
serv.serve_forever()
from socketserver import BaseRequestHandler, ThreadingUDPServer
from base_datos import clientes
from sys import argv, exit
if len(argv) != 2:
print("you are idiot")
exit(1)
class QueHacerUdp(BaseRequestHandler):
def handle(self):
#print("Conexion de {}".format(self.client_address))
data, conn = self.request
conn.sendto("501\n".encode(), self.client_address)
data = data.decode().split(";")
cuenta = int(data[0]) - 3
cobro = int(data[1]) + 3
user = clientes.obtener_key(cuenta)
if clientes.retire_saldo(user, cobro):
conn.sendto("True\n".encode(), self.client_address)
else:
conn.sendto("False\n".encode(), self.client_address)
#def decodificar(self)
ip = str(argv[1])
udp = ThreadingUDPServer((ip, 6689), QueHacerUdp)
udp.serve_forever()
def __init__(self, ip, port):
self.server = ThreadingUDPServer((ip, port), UdpHandler)
with sqlite3.connect('botnet.sqlite3') as db:
db.execute("""
CREATE TABLE IF NOT EXISTS ping (
id INTEGER PRIMARY KEY AUTOINCREMENT,
datetime DATETIME,
host TEXT,
port INTEGER)""")
class UDPHandler(BaseRequestHandler):
def handle(self):
host, port = self.client_address
data = json.loads(self.request[0])
log.info(f'Received ping from {host}:{port}/UDP')
with sqlite3.connect('botnet.sqlite3') as db:
db.execute(
'INSERT INTO ping VALUES (NULL, :datetime, :host, :port)', {
'datetime': datetime.now(tz=timezone.utc),
'host': data['host'],
'port': data['port'],
})
if __name__ == '__main__':
log.info(f'Listening for pings on {HOST}:{PORT}/UDP...')
listener = ThreadingUDPServer((HOST, PORT), UDPHandler)
listener.serve_forever()
def run_server() -> None:
"""
Run a threaded UDP server that logs DNS packets with detail
"""
server = ThreadingUDPServer(HOST_PORT, DNSUDPHandler)
server.serve_forever()
To do so the socketserver library can be used
"""
from socketserver import BaseRequestHandler, UDPServer, ThreadingUDPServer
import time
class TimeHandler(BaseRequestHandler):
def handle(self) -> None:
print("Got connection from", self.client_address)
# Get message and client socket
msg, sock = self.request
resp = time.ctime()
sock.sendto(resp.encode("ascii"), self.client_address)
"""
if __name__ == "__main__":
serv = UDPServer(("", 20000), TimeHandler)
serv.serve_forever()
A typical UDP server receives an incoming datagram (message) + client address.
If the server responds it sends a datagram back - for this sendto() and
recvfrom() should be used. """
# Create a ThreadingUDPServer
if __name__ == "__main__":
serv = ThreadingUDPServer(("", 20000), TimeHandler)
serv.serve_forever()
import sys
import time
from socketserver import DatagramRequestHandler, ThreadingUDPServer
def upper(msg):
time.sleep(1) # simulates a complex job
return msg.upper()
class UpperHandler(DatagramRequestHandler):
def __init__(self, *args):
self.n = 0
DatagramRequestHandler.__init__(self, *args)
def handle(self):
self.n += 1
print("New request: {} {}".format(self.n, self.client_address))
msg = self.rfile.read()
self.wfile.write(upper(msg))
if len(sys.argv) != 2:
print(__doc__.format(sys.argv[0]))
sys.exit(1)
server = ThreadingUDPServer(('', int(sys.argv[1])),
UpperHandler)
server.serve_forever()
if request_type == 'gen_key':
encrypted_tgs_mandate = params['encrypted_tgs_mandate']
tgs_mandate = simplejson.loads(Fernet(TGS_KEY).decrypt(encrypted_tgs_mandate.encode('utf-8')))
tgs_session_key = tgs_mandate['tgs_session_key']
if self.validate_mandate(tgs_mandate):
session_key = Fernet.generate_key()
DATABASE[username] = (session_key, time())
encrypted_session_key = Fernet(tgs_session_key).encrypt(session_key)
sock.sendto(simplejson.dumps({'encrypted_ts_session_key': encrypted_session_key}).encode('utf-8'),
self.client_address)
else:
sock.close()
elif request_type == 'basic':
key, key_creation_time = DATABASE[username]
if time() - key_creation_time < 86400:
encrypted_data = params['encrypted_data'].encode('utf-8')
data = Fernet(key).decrypt(encrypted_data)
user_ip, _ = self.client_address
print('Request from {ip}: {data}'.format(ip=user_ip, data=data))
sock.sendto(simplejson.dumps({'result': 'data is recieved'}).encode('utf-8'),
self.client_address)
else:
sock.close()
if __name__ == '__main__':
serv = ThreadingUDPServer(('', 20002), TSHandler)
serv.serve_forever()
# -*- coding: utf-8 -*-
from socketserver import BaseRequestHandler, UDPServer, ThreadingUDPServer
import time
class TimeHandler(BaseRequestHandler):
def handle(self):
print("connected to", self.client_address)
msg, sock = self.request
resp = time.ctime()
sock.sendto(resp.encode('ascii'), self.client_address)
if __name__ == '__main__':
#serv = UDPServer(('localhost', 8086), TimeHandler)
serv = ThreadingUDPServer(('localhost', 8086), TimeHandler)
serv.serve_forever()
