def start(self, is_udp, cport, tport):
assert is_udp
self.cport = cport
self.tport = tport
self.dserver = SocketServer.UDPServer(('', 0), AirTunesRTPDataHandler)
self.cserver = SocketServer.UDPServer(('', 0),
AirTunesRTPControlHandler)
self.tserver = SocketServer.UDPServer(('', 0),
AirTunesRTPTimingHandler)
self.eserver = SocketServer.TCPServer(('', 0), AirTunesRTPEventHandler)
self.dserver.rtp = self
self.cserver.rtp = self
self.tserver.rtp = self
self.eserver.rtp = self
self.dthread = threading.Thread(target=self.dserver.serve_forever)
self.cthread = threading.Thread(target=self.cserver.serve_forever)
self.tthread = threading.Thread(target=self.tserver.serve_forever)
self.ethread = threading.Thread(target=self.eserver.serve_forever)
self.dthread.start()
self.cthread.start()
self.tthread.start()
self.ethread.start()
def __init__(self):
self.listener = None
self.clientAddress = None
CommandHandler.rf433 = RF433(self.context)
CommandHandler.context = self.context
if TelldusZWave is not None:
self.zwave = TelldusZWave(self.context)
Application().registerShutdown(self.__stop)
self.autoDiscovery = SocketServer.UDPServer(('0.0.0.0', 30303), AutoDiscoveryHandler)
self.commandSocket = SocketServer.UDPServer(('0.0.0.0', 42314), CommandHandler)
Thread(target=self.__autoDiscoveryStart).start()
Thread(target=self.__commandSocketStart).start()
def proxy_session(self, client_ip, sumo_ip, sumo_c2d_port,
client_d2c_port, prox_c2d_port, prox_d2c_port):
""" Proxy a UDP session between client and sumo.
"""
data_queue = collections.deque([True], maxlen=1)
send_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
repeaters = self._repeaters
class C2DHandler(SocketServer.BaseRequestHandler):
""" Handle client to sumo comms.
"""
def handle(self):
data_queue.append(True)
data = self.request[0]
send_socket.sendto(data, (sumo_ip, sumo_c2d_port))
# Tee-off the data to another hosts
for target in repeaters:
send_socket.sendto('>'+data, target)
class D2CHandler(SocketServer.BaseRequestHandler):
""" Handle sumo to client comms.
"""
def handle(self):
data_queue.append(True)
data = self.request[0]
send_socket.sendto(data, (client_ip, client_d2c_port))
# Tee-off the data to another hosts
for target in repeaters:
send_socket.sendto('<'+data, target)
c2d_server = SocketServer.UDPServer(('', prox_c2d_port), C2DHandler)
d2c_server = SocketServer.UDPServer(('', prox_d2c_port), D2CHandler)
t1 = threading.Thread(target=c2d_server.serve_forever)
t1.daemon = True
t1.start()
t2 = threading.Thread(target=d2c_server.serve_forever)
t2.daemon = True
t2.start()
comms_time = 1
while True:
try:
data_queue.pop()
except IndexError:
raise Exception(
'No comms for more than {} seconds'.format(comms_time)
)
time.sleep(comms_time)
def handle(self, *args, **options):
if options['verbosity'] > 1:
verbose = True
else:
verbose = False
if options['stdin']:
log_parser = GoonPugParser(verbose=verbose)
self.stdout.write("goonpugd: Reading from STDIN")
while True:
try:
for line in sys.stdin.readlines():
log_parser.parse_line(line)
except KeyboardInterrupt:
sys.exit()
except EOFError:
sys.exit()
else:
port = int(options['port'])
self.stdout.write('goonpugd: Listening for HL log'
' connections on port %d' % port)
GoonPugLogHandler.verbose = verbose
server = SocketServer.UDPServer(('0.0.0.0', port),
GoonPugLogHandler)
server.timeout = 30
try:
server.serve_forever()
except KeyboardInterrupt:
self.stdout.write('goonpugd: exiting')
sys.exit()
def __init__(self,
owner,
name,
bindip=None,
bindport=None,
forwardip=None,
forwardport=None):
self.IN = True
self.OUT = False
self.transmit_delay = 0.001
self.name = name
if (bindip != None and bindport != None):
self.receives = True
self.bind_ip = bindip
self.bind_port = bindport
UdpInterfaceHandler.interface = self
self.owner = owner
address = (self.bind_ip, self.bind_port)
self.server = SocketServer.UDPServer(address, UdpInterfaceHandler)
thread = threading.Thread(target=self.server.serve_forever)
thread.setDaemon(True)
thread.start()
if (forwardip != None and forwardport != None):
self.forwards = True
self.forward_ip = forwardip
self.forward_port = forwardport
def main():
if not common.validate_server_argv():
return -1
HOST = "0.0.0.0"
server = SocketServer.UDPServer((HOST, common.SOCKET_PORT), UDPEchoHandler)
server.serve_forever()
def register():
# TODO this whole thing could be a GUI
pk, sk, _ = get_key()
qrencode = Popen(['qrencode', '-8', '-t', 'ANSIUTF8'], stdin=PIPE)
qrencode.communicate(pk)
click.echo()
click.echo('Please scan the above QR code with the app to continue')
packets = []
class MyUDPHandler(SocketServer.BaseRequestHandler):
def handle(self):
data, socket = self.request
unsealed = pysodium.crypto_box_seal_open(data, pk, sk)
ap = unsealed[:pysodium.crypto_box_PUBLICKEYBYTES]
challenge = unsealed[pysodium.crypto_box_PUBLICKEYBYTES:]
packets.append(ap)
nonce = pysodium.randombytes(pysodium.crypto_box_NONCEBYTES)
response = pysodium.crypto_box(challenge, nonce, ap, sk)
dst = (src2dst(self.client_address[0]), REG_PORT)
socket.setsockopt(SOL_SOCKET, SO_BROADCAST, 1)
socket.sendto(nonce + response, dst)
server = SocketServer.UDPServer((HOST, REG_PORT), MyUDPHandler)
while not packets:
server.handle_request()
unsealed = packets[0]
s = QtCore.QSettings(SETTINGS_ORG, SETTINGS_APP)
s.setValue(SETTINGS_APP_KEY, QtCore.QByteArray(unsealed))
s.sync()
click.echo(
'The app has been associated with this machine, its public key got stored'
)
def setUp(self):
HOST, PORT = "localhost", 9999
# Creating Transductor Model and Energy Transductor
t_model = TransductorModel()
t_model.name = "TR 4020"
t_model.transport_protocol = "UDP"
t_model.serial_protocol = "Modbus RTU"
t_model.register_addresses = [[4, 0], [68, 1]]
t_model.save()
transductor = EnergyTransductor()
transductor.serie_number = "1"
transductor.description = "Test"
transductor.model = t_model
transductor.ip_address = HOST
transductor.save()
# Setting instance attributes
self.t_model = t_model
self.transductor = transductor
self.modbus_rtu = ModbusRTU(self.transductor)
self.udp_protocol = UdpProtocol(serial_protocol=self.modbus_rtu,
timeout=0.5,
port=9999)
# Starting UDP server via thread
self.server = SocketServer.UDPServer((HOST, PORT), UDPHandler)
self.server_thread = threading.Thread(target=self.server.serve_forever)
self.server_thread.start()
def get_server(cls, shost, sport):
try:
logging.debug("starting the syslog listener")
server = SocketServer.UDPServer((shost, sport), cls)
return server
except:
raise
def serve_thread_udp(host, port, handler):
server = SocketServer.UDPServer((host, port), handler)
server_thread = threading.Thread(target=server.serve_forever)
server_thread.daemon = True
server_thread.start()
time.sleep(30)
server.shutdown()
def start_logd(address=None, port=None, join=False):
class ThreadingUDPServer(SocketServer.ThreadingMixIn,
SocketServer.UDPServer):
pass
class UDPHandler(SocketServer.BaseRequestHandler):
def handle(self):
try:
data, _ = self.request
sec, event = data.split(" ", 1)
handle = get_log_handle(int(sec))
os.write(handle, event)
except:
if config.SHOW_DEBUG:
traceback.print_exc()
server = SocketServer.UDPServer((address, port), UDPHandler)
print "[i] running UDP server at '%s:%d'" % (server.server_address[0],
server.server_address[1])
if join:
server.serve_forever()
else:
thread = threading.Thread(target=server.serve_forever)
thread.daemon = True
thread.start()
def start():
PORXY_DNS.deq_cache = Queue(maxsize=deq_size) if deq_size > 0 else Queue()
PORXY_DNS.dns_cache = pylru.lrucache(lru_size)
gevent.spawn(_init_cache_queue)
print 'Start DNS server at %s:%d\n' % (server_ip, server_port)
dns_server = SocketServer.UDPServer((server_ip, server_port), DNSHandler)
dns_server.serve_forever()
def __init__(self,
iface,
root,
port=_PTFTPD_DEFAULT_PORT,
strict_rfc1350=False,
notification_callbacks=None):
if notification_callbacks is None:
notification_callbacks = {}
self.iface, self.root, self.port, self.strict_rfc1350 = \
iface, root, port, strict_rfc1350
self.client_registry = {}
if not os.path.isdir(self.root):
raise TFTPServerConfigurationError(
"The specified TFTP root does not exist")
self.ip, self.netmask = get_ip_config_for_iface(self.iface)
self.server = socketserver.UDPServer((self.ip, port),
TFTPServerHandler)
self.server.root = self.root
self.server.strict_rfc1350 = self.strict_rfc1350
self.server.clients = self.client_registry
self.cleanup_thread = TFTPServerGarbageCollector(self.client_registry)
# Add callback notifications
notify.CallbackEngine.install(l, notification_callbacks)
def initialize_udp_server(self):
UDP_HOST = "0.0.0.0"
server = SocketServer.UDPServer((UDP_HOST, UDP_PORT),
Communicator.UDPMessageHandler)
Communicator.udpSocket = server.socket
Communicator.udpSocket.settimeout(0.2)
ttl = struct.pack('b', 1)
Communicator.udpSocket.setsockopt(socket.IPPROTO_IP,
socket.IP_MULTICAST_TTL, ttl)
udp_listener = threading.Thread(target=server.serve_forever)
udp_listener.daemon = True
udp_listener.start()
def send_broadcast():
while True:
multicast_dest = (UDP_MULTICAST_IP, UDP_PORT)
#sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
msg = Message(BlockyTalkyID(), "announce", "Message")
Communicator.udpSocket.sendto(Message.encode(msg),
multicast_dest)
#logger.info("Sending UDP broadcast")
time.sleep(UDP_MULTICAST_DELAY)
udp_broadcast = threading.Thread(target=send_broadcast)
udp_broadcast.daemon = True
udp_broadcast.start()
def main():
parser = optparse.OptionParser()
parser.add_option('-u',
'--udp',
action="store_true",
dest="udp",
help="Use UDP in stead of TCP",
default=False)
parser.add_option("-k",
"--keepalive",
action="store_true",
dest="keepalive",
help="Keep connection open",
default=False)
parser.add_option("-P",
"--port",
action="store",
type="int",
dest="port",
help="Port to use",
default=PORT)
options, args = parser.parse_args()
if args:
parser.error("Too many arguments")
if options.keepalive:
klass = MyKeepAliveHandler
else:
klass = MyHandler
if options.udp:
server = SocketServer.UDPServer(('', options.port), MyUDPHandler)
else:
server = SocketServer.TCPServer(('', options.port), klass)
server.serve_forever()
def main():
global beginFlag
global udp_mess2 #Need to be able to modify the value of this variable
if drone.ASY:
print("Beginning Asyncore UDP server on ") + str(udp_ip)
AsyncoreServerUDP()
loop_thread = threading.Thread(target=asyncore.loop,
name="Asyncore Loop")
loop_thread.start()
if drone.SCK:
print("Beginning regular UDP server on ") + str(udp_ip)
sock.bind((udp_ip, udp_port))
if drone.SCKSRV:
print("Beginning UDP socketserver on ") + str(udp_ip)
server = SocketServer.UDPServer((udp_ip, udp_port),
SocketServerHandler)
loop_thread = threading.Thread(target=server.serve_forever,
name="SocketServer Loop")
loop_thread.start()
print("Beginning Multiwii - wait " + str(wakeUp) + " seconds...")
try:
ser.open() # Opens the MultiWii serial port
except Exception, e: # catches any errors with opening serial ports
print("Error open serial port: " + str(e))
exit()
def main():
port_number = 27017
coder_ip = '127.0.0.1'
coder_port = 55555
print 'HELLO'
try:
#with open("../test/measured/dynamic_actuator.txt", "w") as text_file:
# ts= time.time()
# text_file.write("%f,0,0,0,0,0,0\n"%(ts))
server = SocketServer.UDPServer(('', port_number), UDPHandler)
connHTTP = httplib.HTTPConnection("192.168.1.102:5050")
server.level = 0
server.flag_p_size = True
server.flag_Continuity = False
server.QoSlevel = 0
server.packet_size = 2
server.coder_direction = (coder_ip, coder_port)
print('INFO: Started UDP server on port ', port_number)
server.serve_forever()
except KeyboardInterrupt:
print('INFO: ^C received, shutting down UDP server')
server.shutdown()
return
def start(self):
# 启动协程，循环处理缓存队列
ProcessQueue(self.qcache, self.processor)
# 启动DNS服务器
print 'Start DNS server at %s:%d\n' % (self.ip, self.port)
dns_server = SocketServer.UDPServer((self.ip, self.port), DNSHandler)
dns_server.serve_forever()
def run(self):
try:
server = SocketServer.UDPServer((self.data['address'],self.data['port']), UDPHandler)
server.should_connect = self.data['should_connect']
print "Starting UDP server at " + str(self.data['port']) + "\n"
server.serve_forever()
except Exception as e:
print "!- Error at starting UDP thread " + self.data['address'] + ":" + str(self.data['port']) + ", Error: " + str(e)
def start_server():
global player_list, address_list
player_list = {}
address_list = {}
#new= MyUDPHandler()
HOST, PORT = "localhost", 8080
server = SocketServer.UDPServer((HOST, PORT), serverUDP)
server.serve_forever()
def run1():
try:
server = SocketServer.UDPServer((HOST, PORT), SyslogUDPHandler)
server.serve_forever()
except (IOError, SystemExit):
pass
except KeyboardInterrupt:
print("Crtl+C Pressed. Shutting down.")
def ipmiserver():
context = IpmiServerContext()
server = socketserver.UDPServer(('0.0.0.0', 9999), IpmiServer)
t = Thread(target=server.serve_forever)
t.daemon = True
t.start()
yield server.server_address, context.bmc
server.shutdown()
def __init__(self):
threading.Thread.__init__(self)
self.isAlive = True
# Default port of STUN server over UDP
self.UDPPort = 3478
self.handler = StunHandler
SocketServer.UDPServer.allow_reuse_address = True
self.stunServer = SocketServer.UDPServer(('', self.UDPPort),
self.handler)
def main():
"""Begins a socketserver listening on port 67"""
# s = socket.socket(family=socket.AF_INET, type=socket.SOCK_DGRAM)
# s.bind(('', 67))
# m = s.recvfrom(1024)
# print(m)
host, port = "", 67
server = SocketServer.UDPServer((host, port), DHCPHandler)
server.serve_forever()
def main():
args = parse_args()
fd = open(args.output_fname, 'a') if args.output_fname else None
StatsdMessageHandler._output_fd = fd
server = SocketServer.UDPServer(
(args.addr, args.port),
StatsdMessageHandler,
)
server.serve_forever()
def startUDPServerThread():
try:
logging.info("Starting UDP receiver")
server = SocketServer.UDPServer((HOST, GSMPORT), MyUDPHandler)
udp_thread = threading.Thread(target=server.serve_forever)
udp_thread.start()
except Exception, e:
logging.info("Failed to start UDP receiver " + e)
def run(self):
global SortieAnticipe
#global isRunning
remoteKeyBorgServer = SocketServer.UDPServer(('', portListen),
PicoBorgHandler)
print "reception en cours"
while SortieAnticipe == False and self.Terminated == False:
remoteKeyBorgServer.handle_request()
print 'Reception Terminée'
def init():
#OpenCV setup
cam = cv2.VideoCapture(0)
camThread = videoThread(cam)
camThread.daemon = True
camThread.start()
sockSer = SocketServer.UDPServer((HOST, PORT), UDPHandler)
sockThread = threading.Thread(target=sockSer.serve_forever)
sockThread.daemon = True
sockThread.start()
def init_server():
import socket
s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
s.connect(("gmail.com", 80))
# todo: improve ip finding method, currently it fails when no internet connection is available
HOST, PORT = str(s.getsockname()[0]), 9999
s.close()
# HOST, PORT = "192.168.1.239", 9999
logging.info("Remote joystick server started {} port {}".format(HOST, PORT))
server = SocketServer.UDPServer((HOST, PORT), RemoteJoystickUDPHandler)
server.serve_forever()
def _serve_socket(self, host, port):
""" utility function to read socket and send to destinations
"""
mqueue = self.message_queue
class UDPHandler(SocketServer.BaseRequestHandler):
def handle(self):
data = self.request[0].strip()
mqueue.put(('%s:%d' % (host, port), data))
server = SocketServer.UDPServer((host, port), UDPHandler)
server.serve_forever()
