def udp_packet_recv(threadName, server_ip, server_port):
""" This function will receive packet stream from mbed device
"""
server = UDPServer((server_ip, server_port), UDPEchoClient_Handler)
print "[UDP_COUNTER] Listening for connections... %s:%d" % (server_ip,
server_port)
server.serve_forever()
def __init__(self, interval):
"""
init the DPM
:param interval: the time interval of sending data (ms)
:return:
"""
self.__interval = interval / 1000.0
self.__ip = socket.gethostbyname(socket.gethostname())
self.__udpServer = UDPServer(('0.0.0.0', DPM_PORT), DataRecvServer)
def run_server():
# port 0 will choose a random free port
server = UDPServer(('localhost', 0), RequestHandler)
port = server.socket.getsockname()[1]
thr = Thread(target=server.serve_forever)
thr.daemon = True
thr.start()
return port
def setup_udp_server(self):
"""
sets up a UDP server for target to connect and send test data.
:return:
"""
# !NOTE: There should mechanism to assert in the host test
if self.SERVER_IP is None:
self.log("setup_udp_server() called before determining server IP!")
self.notify_complete(False)
# Returning none will suppress host test from printing success code
self.server = UDPServer((self.SERVER_IP, self.SERVER_PORT), UDPEchoClientHandler)
ip, port = self.server.server_address
self.SERVER_PORT = port
self.server.allow_reuse_address = True
self.log("HOST: Listening for UDP packets: " + self.SERVER_IP + ":" + str(self.SERVER_PORT))
self.server_thread = Thread(target=UDPEchoClientTest.server_thread_func, args=(self,))
self.server_thread.start()
def test(self, selftest):
# We need to discover SERVEP_IP and set up SERVER_PORT
# Note: Port 7 is Echo Protocol:
#
# Port number rationale:
#
# The Echo Protocol is a service in the Internet Protocol Suite defined
# in RFC 862. It was originally proposed for testing and measurement
# of round-trip times[citation needed] in IP networks.
#
# A host may connect to a server that supports the Echo Protocol using
# the Transmission Control Protocol (TCP) or the User Datagram Protocol
# (UDP) on the well-known port number 7. The server sends back an
# identical copy of the data it received.
SERVER_IP = str(socket.gethostbyname(socket.getfqdn()))
SERVER_PORT = 7
# Returning none will suppress host test from printing success code
server = UDPServer((SERVER_IP, SERVER_PORT), UDPEchoClient_Handler)
print("HOST: Listening for UDP connections...")
self.send_server_ip_port(selftest, SERVER_IP, SERVER_PORT)
server.serve_forever()
c = self.mbed.serial_readline(
) # 'UDPCllient waiting for server IP and port...'
if c is None:
self.print_result("ioerr_serial")
return
print c.strip()
stdout.flush()
class UDPEchoClient_Handler(BaseRequestHandler):
def handle(self):
""" One handle per connection
"""
data, socket = self.request
socket.sendto(data, self.client_address)
if '{{end}}' in data:
print
print data
else:
sys.stdout.write('.')
stdout.flush()
server = UDPServer((SERVER_IP, SERVER_PORT), UDPEchoClient_Handler)
print "HOST: Listening for connections..."
mbed_test = UDPEchoClientTest()
mbed_test.send_server_ip_port(SERVER_IP, SERVER_PORT)
server.serve_forever()
def main():
server = UDPServer(('0.0.0.0', 41724), UDPRequestHandler)
print 'Server accepting UDP connections {}...'.format(server.server_address)
server.serve_forever()
def start(self):
UDPServer.allow_reuse_address = True
self.server = UDPServer((self.ip_address, self.port), SyslogUDPHandler)
th = Thread(target=self.server.serve_forever)
th.daemon = True
th.start()
#!/usr/bin/env python
"USAGE: %s <port>"
from SocketServer import DatagramRequestHandler, UDPServer
from sys import argv
class EchoHandler (DatagramRequestHandler):
def handle(self):
print "Client connected:", self.client_address
message = self.rfile.read()
self.wfile.write(message)
if len(argv) !=2:
print __doc__ % argv[0]
else:
UDPServer(('',int(argv[1])), EchoHandler).serve_forever()
mbed SDK
Copyright (c) 2011-2013 ARM Limited
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
"""
from SocketServer import BaseRequestHandler, UDPServer
from private_settings import SERVER_ADDRESS
class UDP_EchoHandler(BaseRequestHandler):
def handle(self):
data, socket = self.request
print "client:", self.client_address
print "data:", data
socket.sendto(data, self.client_address)
server = UDPServer((SERVER_ADDRESS, 7195), UDP_EchoHandler)
print "listening for connections"
server.serve_forever()
yield out_flow
def write_log(self, formatted_flows):
for flow in formatted_flows:
self.logger.info(dumps(flow, sort_keys=True))
def handle_message(self, data):
# Populate self.known_templates and self.parsed_flows and then
# write the formatted flows to disk
try:
self.update_from_message(data)
self.write_log(self.get_formatted_flows())
# Don't crash on bad input
except Exception:
logger.exception('Could not read request')
# Clean up stored flows
finally:
self.parsed_flows = []
# Global reader is set when running as a module
nvzflow_reader = None
if __name__ == '__main__':
receive_host = environ.get('OBSRVBL_NVZFLOW_RECEIVE_HOST', '0.0.0.0')
receive_port = int(environ.get('OBSRVBL_NVZFLOW_RECEIVE_PORT', '2055'))
logger.info('Listening on %s:%s', receive_host, receive_port)
nvzflow_reader = NVZFlowReader(known_templates=NVZFLOW_TEMPLATE)
server = UDPServer((receive_host, receive_port), NVZFlowHandler)
server.serve_forever()
from SocketServer import UDPServer, BaseRequestHandler
class myHandler(BaseRequestHandler):
def handle(self):
print "Connection from ", str(self.client_address)
data, conn = self.request
data_oper = data.split(" ")
if data_oper[1] == "+":
res = int(data_oper[0]) + int(data_oper[2])
elif data_oper[1] == "-":
res = int(data_oper[0]) - int(data_oper[2])
elif data_oper[1] == "*":
res = int(data_oper[0]) * int(data_oper[2])
if data_oper[1] == "/":
res = int(data_oper[0]) / int(data_oper[2])
conn.sendto(str(res)+"\n", self.client_address)
myServer = UDPServer(("127.0.0.1", 5555), myHandler)
myServer.serve_forever()
class RobotHandler(BaseRequestHandler):
def handle(self):
print("Client {} connected....".format(self.client_address))
try:
while True:
data = self.request.recv(BUFSIZ).strip()
print("{} wrote: {}".format(self.client_address[0], data))
self.request.sendall(process_request(data) or 'OK')
# self.request.sendall(self.data.upper())
except Exception as e:
print("Connection closed from {} ({})".format(
self.client_address, str(e)))
pass
if __name__ == "__main__":
parser = argparse.ArgumentParser(
description='Start robot command server to listen and obey.')
parser.add_argument('--udp', dest='udp', action='store_const',
const=True, default=False, help='Listen on UDP (default TCP)')
args = parser.parse_args()
if args.udp:
server = UDPServer((HOST, PORT), RobotHandler)
else:
server = TCPServer((HOST, PORT), RobotHandler)
server.serve_forever()
#!/usr/bin/python
from SocketServer import BaseRequestHandler, 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.serve_forever()
def run(self):
addr = ("", PORT)
log("UDP server listening on : " + str(addr), "debug")
server = UDPServer(addr, Handler)
server.serve_forever()
cmd = "@" + base64.standard_b64encode(f.readlines()[int(name.label[1])-1]) + "@"
except:
cmd = ''
return RR(name, QTYPE.TXT, rdata=TXT(cmd), ttl=0)
def _A(self, name):
if name.label[0] == "data":
print base64.b64decode(name.label[1]),
else:
print name
return RR(name, QTYPE.A, rdata=A(IP_ADDRESS), ttl=0)
def _MX(self, name):
print name
return RR(name, QTYPE.MX, rdata=MX(DOMAIN_NAME), ttl=0)
def handle(self):
request = DNSRecord.parse(self.request[0])
socket = self.request[1]
reply = request.reply()
answer = self.q_processors[reply.q.qtype](reply.q.qname)
reply.add_answer(answer)
socket.sendto(reply.pack(), self.client_address)
if __name__ == '__main__':
HOST, PORT = '0.0.0.0', 53
server = UDPServer((HOST, PORT), Exfiltrator)
server.serve_forever()
except (IOError, TypeError, OSError, ValueError, IndexError), err:
print "Error parsing request data: %s" % err
return "ERR"
class UDPHandle(BaseRequestHandler):
def handle(self):
addr = self.client_address
sock = self.request[1]
resp = ""
try:
raw_data = str(self.request[0]).strip().replace('\n', '')
if EOF not in raw_data or SOF not in raw_data:
print "Failed to pull entire stream..."
sock.sendto(ON_FAIL, addr)
return
print "From (%s): %s" % (str(addr), raw_data)
resp = data_handle(raw_data)
sock.sendto(SOF + resp + EOF, addr)
except (OSError, ValueError, TypeError, IOError), err:
print "UDP handle error: %s" % err
sock.sendto(SOF + resp + EOF, addr)
if __name__ == "__main__":
worx.set_thing(worx_thing)
server = UDPServer((BIND_ADDR, BIND_PORT), UDPHandle)
server.allow_reuse_address = True
print "Starting server...\nwaiting for data..."
server.serve_forever()
