class DNSServer:
def __init__(self,
blacklist=[],
redirect_ip=None,
port=PORT,
addr="",
max_cache_size=2048):
self.blacklist = blacklist
self.redirect_ip = redirect_ip
self.port = port
self.dns_addr = addr
self.max_cache_size = int(max_cache_size)
self.cache = {}
handler = Handler
handler.host = self
self.server = ThreadingUDPServer((HOST_IP, self.port), Handler)
def start(self):
print("dnsruse running on {} port {} ...".format(HOST_IP, self.port))
self.server.serve_forever()
def log(self, info):
print(info)
def add_cache(self, domain, ip):
if sys.getsizeof(self.cache) < self.max_cache_size:
self.cache[domain] = ip
return "cached."
else:
return "unable to cache, full"
def main():
udp = False
if '-u' in sys.argv:
sys.argv.remove('-u')
udp = True
#end if
# Deterministic.
if len(sys.argv) > 1:
random.seed(sys.argv[1])
else:
random.seed('0x31337')
#end if
if udp:
port = 6811
addr = ('0.0.0.0', port)
server = ThreadingUDPServer(addr, M68HC11_Handler)
server.serve_forever()
else:
file_iteration = 3
while os.path.exists('test1e{0}.S'.format(file_iteration)):
file_iteration += 1
#loop
filename = 'test1e{0}.S'.format(file_iteration)
iterations = 200
source = gen_flag(get_flag(), filename, iterations)
open(filename, 'w').write(source)
print(filename)
def __init__(self, ip, port, handler):
ThreadingUDPServer.__init__(self, (ip, port), handler)
Thread.__init__(self, target=self.serve_forever)
# Set the thread name to the class name
Thread.setName(self, f'UDP-{self.__class__.__name__} Server')
self.daemon = True
def main():
global data, passwords1
udp = False
if '-u' in sys.argv:
sys.argv.remove('-u')
udp = True
#end if
# Deterministic.
if len(sys.argv) > 1:
random.seed(sys.argv[1])
else:
random.seed('0x31337')
#end if
data = get_ton_unic0de()
passwords = 'A a aa aal aalii aam Aani aardvark aardwolf Aaron Aaronic Aaronical Aaronite Aaronitic Aaru Ab aba Ababdeh Ababua abac'.split(
' ')
passwords1 = []
for password in passwords:
# add junk to it
p = data[random.randint(0, len(data) - 1)]
passwords1.append(password + p)
#next password
if udp:
port = 2044
addr = ('0.0.0.0', port)
server = ThreadingUDPServer(addr, Unic0de_Handler)
server.serve_forever()
else:
res = get_unic0de(data)
print(res.encode('utf-7'))
class service_udpserver(BaseRequestHandler):
recv_queue: msg_queue
port: int
name: str
udpserver: ThreadingUDPServer
def listen(self, recv_queue: msg_queue, port: int, name: str):
self.recv_queue = recv_queue
self.port = port
self.name = name
# Start udp server
self.udpserver = ThreadingUDPServer(('', self.port), self)
logger.info("Start udpserver, [name]: %s, [port]: %s" %
(self.name, self.port))
self.udpserver.serve_forever()
def handle(self):
ip_port = f"{self.client_address[0]}:{self.client_address[1]}"
# logger.info("[%s][%s]device connected."
# % (self.name, ip_port))
# Get message and client socket
udp_msg, sock = self.request
# Replay
sock.sendto(udp_replay_str, self.client_address)
# Packet msg
logger.debug("UDP receive data [%s] from %s" % (udp_msg, ip_port))
recv_pkt = udp_packet_item(server_port=self.port,
recv_time=datetime.now(),
recv_address=ip_port,
recv_msg=udp_msg)
# Add msg to the queue
if self.recv_queue is not None:
self.recv_queue.put(recv_pkt.to_dict())
def shutdown(self):
"""
Safely shutdown server and thread
:return: None
"""
ThreadingUDPServer.shutdown(self)
Thread.join(self)
def main():
host = '127.0.0.1'
port = 6001
try:
server = ThreadingUDPServer((host, port), StatsHandler)
server.serve_forever()
except KeyboardInterrupt:
print('Interrupted...')
def listen(self, recv_queue: msg_queue, port: int, name: str):
self.recv_queue = recv_queue
self.port = port
self.name = name
# Start udp server
self.udpserver = ThreadingUDPServer(('', self.port), self)
logger.info("Start udpserver, [name]: %s, [port]: %s" %
(self.name, self.port))
self.udpserver.serve_forever()
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 create_udp_server(self):
"""
Crea un servidor UDP en un hilo externo para recibir los mensajes punto a punto de la aplicación. Es decir,
una vez registrado en la aplicación el cliente puede recibir mensajes directamente mediante este servidor
"""
self.udp_server = ThreadingUDPServer((self.user.ip, self.user.port),
ThreadedUDPRequestHandler)
self.udp_server_thread = threading.Thread(target=self.udp_server.serve_forever)
self.udp_server_thread.daemon = True
def __init__(self, server_address, RequestHandlerClass, wrappers, sname,
sid, ttl, timeout, logger):
ThreadingUDPServer.__init__(self, server_address, RequestHandlerClass)
self.wrappers = wrappers
self.sname = sname
self.sid = sid
self.ttl = ttl
self.timeout = timeout
# Logger parameters
self.logger = logger
self._LOGGING_ = False if logger is None else True
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,
blacklist=[],
redirect_ip=None,
port=PORT,
addr="",
max_cache_size=2048):
self.blacklist = blacklist
self.redirect_ip = redirect_ip
self.port = port
self.dns_addr = addr
self.max_cache_size = int(max_cache_size)
self.cache = {}
handler = Handler
handler.host = self
self.server = ThreadingUDPServer((HOST_IP, self.port), Handler)
def __init__(
self,
server_address: Tuple[str, int],
accounts: Dict[str, SIAAccount],
func: Callable[[SIAEvent], None],
counts: Counter,
):
"""Create a SIA UDP Server.
Arguments:
server_address Tuple[string, int] -- the address the server should listen on.
accounts Dict[str, SIAAccount] -- accounts as dict with account_id as key, SIAAccount object as value.
func Callable[[SIAEvent], None] -- Function called for each valid SIA event, that can be matched to a account.
counts Counter -- counter kept by client to give insights in how many errorous events were discarded of each type.
"""
ThreadingUDPServer.__init__(self, server_address, SIAUDPHandler)
BaseSIAServer.__init__(self, accounts, func, counts)
def simulate_main(app_py: str, conf: Konfig) -> None:
from socketserver import DatagramRequestHandler, ThreadingUDPServer
from threading import Thread
class SimUDPBCastHandler(DatagramRequestHandler):
def handle(self):
data = self.request[0].strip()
socket = self.request[1]
for addr in conf.gen_all_agent_addrs():
socket.sendto(data, addr)
server = ThreadingUDPServer(conf.udp_bcast_addr, SimUDPBCastHandler)
server_thread = Thread(target=server.serve_forever)
try:
server_thread.daemon = True
server_thread.start() # Start server before all other agent processes
simulate_agents(app_py, conf)
finally:
server.shutdown()
print("Shuting down simulated broadcast server thread...")
server_thread.join(timeout=5.0)
if server_thread.is_alive():
print(
"Simulated broadcast server is still alive. Terminate with main thread."
)
server.server_close()
def main() -> None:
"""Wrapper for TCP and UDP workers"""
ThreadingTCPServer.allow_reuse_address = True
ThreadingUDPServer.allow_reuse_address = True
tcp_proxy = ThreadingTCPServer((PROXY_ADDR, PROXY_PORT), DNSoverTCP)
udp_proxy = ThreadingUDPServer((PROXY_ADDR, PROXY_PORT), DNSoverUDP)
tcp_process = multiprocessing.Process(target=tcp_proxy.serve_forever)
udp_process = multiprocessing.Process(target=udp_proxy.serve_forever)
tcp_process.start()
logging.info('DNS Proxy over TCP started and listening on port %s',
PROXY_PORT)
udp_process.start()
logging.info('DNS Proxy over UDP started and listening on port %s',
PROXY_PORT)
def udp(host, port, echo):
"""
Runs a threaded UDP server that logs all datagrams it receives. It can alos act as
an UDP echo server using the --echo flag
"""
if echo:
request_handler = EchoUdpHandler
else:
request_handler = SimpleUdpHandler
with ThreadingUDPServer((host, port), request_handler) as server:
click.secho(
f"Staring {server.__class__.__name__} on {host}:{port}",
fg="bright_yellow",
blink=True,
)
server.serve_forever()
def main() -> None:
global FSP_PASSWORD, FSP_SERVER_DIR
# check python version before running
assert version_info.major == 3 and version_info.minor >= 8, "This script requires Python 3.8 or greater!"
parser = argparse.ArgumentParser(description=__description__)
parser.add_argument("-a",
"--address",
type=parse_hostname_port,
default=("0.0.0.0", 7717),
help="The address to bind to")
parser.add_argument("-p",
"--password",
type=str,
default="",
help="The password to use")
parser.add_argument("-d",
"--directory",
type=str,
default="server",
help="The directory to serve from")
args = parser.parse_args()
assert type(args.address) == tuple, "Invalid address:port pair specified"
FSP_PASSWORD = args.password
FSP_SERVER_DIR = args.directory
assert osp.isdir(
FSP_SERVER_DIR), "The specified server directory doesn't exist"
print(f"FSP server running on {args.address[0]}:{args.address[1]}...")
print(f"Base Directory: \"{osp.abspath(FSP_SERVER_DIR)}\"")
with ThreadingUDPServer((args.address[0], args.address[1]),
FSPPacketHandler) as server:
server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF,
FSP_MAXSPACE)
server.socket.setsockopt(socket.SOL_SOCKET, socket.SO_SNDBUF,
FSP_MAXSPACE)
server.serve_forever()
from socketserver import BaseRequestHandler, ThreadingUDPServer
import time
class TimeHandler(BaseRequestHandler):
def handle(self):
print('Got connection from', self.client_address)
msg, sock = self.request
resp = time.ctime()
sock.sendto(resp.encode(), self.client_address)
if __name__ == '__main__':
serv = ThreadingUDPServer(('', 20000), TimeHandler)
serv.serve_forever()
if not msg:
return
msg = json.loads(msg.decode("utf-8"))
log.logger.info('[INPUT_{0}] {1}'.format(msg['arg01'],msg))
#num = int(random.uniform(1, 15)*10) / 10
rst = {}
ai_ret = 8.5
if isinstance(ai_ret, float):
rst['result'] = int(ai_ret * 10) / 10.0
rst['error'] = ''
else:
log.logger.error(ai_ret)
rst['result'] = ''
rst['error'] = ai_ret
rst['arg01'] = msg['arg01']
rst['patient_id'] = msg['patient_id']
rst['detect_id'] = msg['detect_id']
rst['last'] = ''
r = json.dumps(rst)
#time.sleep(10)
cost_time = time.time() - start
log.logger.info('[TOTAL_COST_TIME]: {0}'.format(cost_time))
sock.sendto(str.encode(r), self.client_address)
if __name__ == '__main__':
log.logger.info('ai api(udp) starts:')
serv = ThreadingUDPServer(('', 62000), UDPHandler)
serv.serve_forever()
def __init__(self, addr, handler, timeout=1):
ThreadingUDPServer.__init__(self, addr, LogRecordDatagramHandler)
BaseServer.__init__(self, handler, timeout)
def send_test_query_sdns(port):
req = DNSRecord.question("xyzmail.sec.mycompany.com", qtype="A")
print("\nIssuing client request (sdns)...")
send_req_and_print_resp(req.pack(), port)
def send_test_query_public(port):
# Request the v6 address of google.com
req = DNSRecord.question("google.com", qtype="A")
print("Issuing client request (public)...")
send_req_and_print_resp(req.pack(), port)
if __name__ == "__main__":
LISTEN_PORT = 1053 # TODO: change to 53 later (requires admin perms)
server = ThreadingUDPServer(("localhost", LISTEN_PORT),
LocalDNSRequestHandler)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
print("Server started on port {}".format(LISTEN_PORT))
# TODO: for testing, send a sample request, then exit... final implementation would just run serve_forever() in the
# main thread
send_test_query_sdns(LISTEN_PORT)
#send_test_query_public(LISTEN_PORT)
server.shutdown()
server.server_close()
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)
def __init__(self, addr, handler, timeout=1):
ThreadingUDPServer.__init__(self, addr, LogRecordDatagramHandler)
BaseServer.__init__(self, handler, timeout)
def send_test_query_sdns(port):
req = DNSRecord.question("xyzmail.sec.mycompany.com", qtype="A")
print("\nIssuing client request (sdns)...")
send_req_and_print_resp(req.pack(), port)
def send_test_query_public(port):
# Request the v6 address of google.com
req = DNSRecord.question("google.com", qtype="A")
print("Issuing client request (public)...")
send_req_and_print_resp(req.pack(), port)
if __name__ == "__main__":
LISTEN_PORT = 1053 # TODO: change to 53 later (requires admin perms)
server = ThreadingUDPServer(("localhost", LISTEN_PORT), LocalDNSRequestHandler)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
print("Server started on port {}".format(LISTEN_PORT))
# TODO: for testing, send a sample request, then exit... final implementation would just run serve_forever() in the
# main thread
send_test_query_sdns(LISTEN_PORT)
#send_test_query_public(LISTEN_PORT)
server.shutdown()
server.server_close()
emojiDlg.exec_()
print(emojiDlg.selectEmoji)
img = '<img src=\"%s\"></img>' % emojiDlg.selectEmoji.path
self.textEdit.append(img)
#打开图片选择界面
def onClickImage(self):
pass
if __name__ == '__main__':
app = QtWidgets.QApplication(sys.argv)
window = FeiQMainWindow()
UDPSERVER = ThreadingUDPServer((setting.IPADDRESS, setting.PORT),
UdpHandle)
UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 60000)
serverMainThread = threading.Thread(target=UDPSERVER.serve_forever,
name='后台主线程')
serverMainThread.setDaemon(True)
serverMainThread.start()
Instance.start(UDPSERVER.socket.sendto, window.onViewDispatch)
window.show()
sys.exit(app.exec_())
UDPSERVER.server_close()
Instance.stopAll()
from socketserver import ThreadingUDPServer
from socketserver import BaseRequestHandler, DatagramRequestHandler
import socket
import logging
import time, datetime
class UdpHandle(BaseRequestHandler):
COUNT = 0
def handle(self):
# t = threading.Thread(target=self.dealPacket, args=(self.client_address, self.request[0]))
# t.start()
packet = self.request[0]
# print(datetime.datetime.now().isoformat()+str(UdpHandle.COUNT))
self.server.socket.sendto(packet, self.client_address)
UdpHandle.COUNT += 1
UDPSERVER = ThreadingUDPServer(('0.0.0.0', 50001), UdpHandle)
UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, 1)
UDPSERVER.socket.setsockopt(socket.SOL_SOCKET, socket.SO_RCVBUF, 60000)
UDPSERVER.serve_forever()
传统的 send() 和 recv() 也可以，但一般用于 tcp
"""
"""
UDP天生是不可靠的（因为通信没有建立连接，消息可能丢失）
需要自行处理丢失消息的情况
如果可靠性对于你程序很重要，你需要借助于序列号、重试、超时以及一些其他方法来保证。
UDP通常被用在那些对于可靠传输要求不是很高的场合。
例如，在实时应用如多媒体流以及游戏领域， 无需返回恢复丢失的数据包（程序只需简单的忽略它并继续向前运行）。
"""
"""
UDPServer 类是单线程的，也就是说一次只能为一个客户端连接服务
并发操作，可以实例化一个 ForkingUDPServer 或 ThreadingUDPServer 对象
"""
from socketserver import ThreadingUDPServer
if __name__ == "__main__":
serv = ThreadingUDPServer(('', 20000), TimeHandler)
serv.serve_forever()
"""
直接使用 socket 来实现一个UDP服务器也不难
"""
from socket import socket, AF_INET, SOCK_DGRAM
import time
def time_server(address):
sock = socket(AF_INET, SOCK_DGRAM)
sock.bind(address)
while True:
msg, addr = sock.recvfrom(8192)
print('连接请求来自', addr)
resp = time.ctime()
def __init__( self, port,name,liveaddr, handle=handle ):
self.name=name
self.liveaddr=liveaddr
UDP.__init__( self, ('', port), handle )
def __init__(self, address, port):
self.servers = [
ThreadingUDPServer((address, port), UDPHandler),
ThreadingTCPServer((address, port), TCPHandler),
]
#-*- coding:utf-8 -*-
'''
创建UDPServer
'''
from socketserver import BaseRequestHandler,ThreadingUDPServer,UDPServer
import time
class TimeHandler(BaseRequestHandler):
def handle(self):
print('Got connection from ',self.client_address)
msg,sock=self.request
resp=time.ctime()
sock.sendto(resp.encode('ascii'),self.client_address)
if __name__=='__main__':
# #单线程模式（一次只能响应一个连接请求）
# serv=UDPServer(('',20000),TimeHandler)
#多线程模式（响应多个客户端的连接）
serv=ThreadingUDPServer(('',20000),TimeHandler)
serv.serve_forever()
encrypted_as_mandate = params['encrypted_as_mandate'].encode('utf-8')
as_mandate = simplejson.loads(
Fernet(TGS_KEY).decrypt(encrypted_as_mandate))
as_session_key = as_mandate['as_session_key']
if self.validate_mandate(as_mandate):
session_key = Fernet.generate_key()
encrypted_session_key = Fernet(as_session_key).encrypt(session_key)
client_ip, _ = self.client_address
mandate = {
'tgs_session_key': session_key,
'public_text': PUBLIC_TEXT,
'time': time(),
'client_ip': client_ip
}
encrypted_mandate = Fernet(TGS_KEY).encrypt(
simplejson.dumps(mandate).encode('utf-8'))
sock.sendto(
simplejson.dumps({
'encrypted_tgs_session_key': encrypted_session_key,
'encrypted_tgs_mandate': encrypted_mandate
}).encode('utf-8'), self.client_address)
else:
sock.close()
if __name__ == '__main__':
serv = ThreadingUDPServer(('', 20001), TGSHandler)
serv.serve_forever()
user.client_address)
except:
pass
db.close_shop(shop.owner_id)
reply += "已关闭此店"
elif header == "/users":
if user is None or user.user_id != 999:
reply += "您没有该权限"
else:
reply += "有以下用户\n"
print(db.users)
for each in db.users:
a = "用户ID: {0} 用户名: {1} \n".format(
each.user_id, each.user_name)
reply += a
print(reply)
except AssertionError:
reply += "指令参数错误！"
ans.reply = reply
self.request[1].sendto(ans.send(), self.client_address)
if __name__ == '__main__':
print("Data Version:", db["version"])
print(db)
server = ThreadingUDPServer(('0.0.0.0', 25365),
Handler) # 参数为监听地址和已建立连接的处理类
print('listening')
server.serve_forever() # 监听，建立好UCP连接后，为该连接创建新的socket和线程，并由处理类中的handle方法处理
print(server)
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()
