def main(): reactor.listenTCP(8000, IPBusServerFactory()) reactor.listenUDP(8000, IPBusServerProtocol()) reactor.run() reactor.stop()
def main():
boots = (('router.bittorrent.com', 6881),)
p = BittorrentProtocol(boots)
# lc = LoopingCall(monitor, p)
# lc.start(5)
reactor.listenUDP(6881, p)
reactor.run()
def ndss_loop(doInit):
ndutil.set_timezone()
ndlCom = NdlCom('nDroid-Scheduler', '127.0.0.1', 12322)
ndlCom.do_com('Initiating')
ndlCom.do_com('Loading Configuration')
cnfManager = CnfManager()
cnfManager.load('./ndss.cnf')
cnfData = cnfManager.get_cnf_data()
if doInit:
pass
msgManager = MsgManager()
ndsCom = NdsCom('127.0.0.1', 12321)
ndaCom = NdaCom('127.0.0.1', 12323)
netManager = NetManager()
netManager.set_msgmanager(msgManager)
netManager.set_ndlcom(ndlCom)
netManager.set_ndscom(ndsCom)
netManager.set_ndacom(ndaCom)
reactor.listenUDP(cnfData['comPort'], netManager)
ndlCom.do_com('Listening Com Port %d' % cnfData['comPort'])
reactor.run()
def main():
controls_client = ControlsClient("127.0.0.1", 10301)
reactor.listenUDP(0, controls_client)
simulator_data_client = SimulatorDataClient()
reactor.listenUDP(10302, simulator_data_client)
altitude = 300.0
airspeed = 30.0
waypoints = []
with open("waypoints.csv", "r") as f:
reader = csv.reader(f, delimiter=",")
for row in reader:
waypoint = [float(row[1]), float(row[2]), altitude, airspeed]
waypoints.append(waypoint)
autopilot = Autopilot(waypoints)
autopilot_adapter = AutopilotAdapter(autopilot, controls_client)
simulator_data_client.add_simulator_data_listener(autopilot_adapter)
log_updater = task.LoopingCall(autopilot.print_log)
log_updater.start(1.0)
simulator_control = SimulatorControlClient("localhost", 8090)
simulator_control.reset()
simulator_control.resume()
reactor.run()
def nda_loop():
ndutil.setTimezone()
ndlCom = NdlCom('nDroid-Executer', '127.0.0.1', 12322)
ndlCom.doCom('Initiating')
ndlCom.doCom('Loading Config')
cnfManager = CnfManager()
cnfManager.load('./nde.cnf')
cnfData = cnfManager.getCnfData()
nsQueue = Queue()
nsLock = threading.Lock()
netManager = NetManager()
netManager.setNdlCom(ndlCom)
netManager.setNsQueue(nsQueue, nsLock)
ndlCom.doCom('Starting Threads')
scheduler = Scheduler([ndlCom, nsQueue, nsLock], 'Scheduler')
scheduler.start()
reactor.listenUDP(cnfData['comPort'], netManager)
ndlCom.doCom('Listening Com Port')
reactor.run()
scheduler.join()
def __init__(self, save_dir=".",
listen_port=6881,
enable_DHT=False,
remote_debugging=False):
"""
@param remote_degugging enables telnet login via port 9999 with a
username and password of 'admin'
"""
log.startLogging(sys.stdout) # Start logging to stdout
self.save_dir = save_dir
self.listen_port = listen_port
self.enable_DHT = enable_DHT
self.tasks = {}
self.btServer = BTServerFactories(self.listen_port)
reactor.listenTCP(self.listen_port, self.btServer)
if enable_DHT:
log.msg("Turning DHT on.")
self.dht = DHTProtocol()
reactor.listenUDP(self.listen_port, self.dht)
if remote_debugging:
log.msg("Turning remote debugging on. You may login via telnet " +\
"on port 9999 username & password are 'admin'")
import twisted.manhole.telnet
dbg = twisted.manhole.telnet.ShellFactory()
dbg.username = "******"
dbg.password = "******"
dbg.namespace['app'] = self
reactor.listenTCP(9999, dbg)
def _realise_connection(cls, async):
"""Return a configured statsd client connection."""
servers = config.statsd.servers
if servers is None:
raise LookupError('Unable to obtain the statsd configuration')
servers = map(None, [server.strip() for server in servers.split(";")])
if not servers:
raise LookupError('Unable to obtain the statsd configuration')
connections = []
for server in servers:
statsd_host, statsd_port = server.split(":")
statsd_port = int(statsd_port)
if async:
connection = TwistedStatsDClient.create(statsd_host,
statsd_port)
connection.disconnect_callback = \
lambda: cls._disconnect_connection(connection)
protocol = StatsDClientProtocol(connection)
from twisted.internet import reactor
reactor.listenUDP(0, protocol)
else:
connection = UdpStatsDClient(statsd_host, statsd_port)
connection.connect()
connections.append(connection)
if len(connections) == 1:
return connections[0]
return ConsistentHashingClient(connections)
def start(self, operations):
self.protocol.set_operations(operations)
reactor.listenUDP(0, self.protocol)
try:
reactor.run()
except twisted.internet.error.ReactorAlreadyRunning:
log.msg("Reactor already started")
def main(type):
log.startLogging(sys.stderr, setStdout=False)
if type == "1":
client_factory = client_server.Factory()
reactor.connectTCP('127.0.0.1', 8125, client_factory)
else :
client_factory = client_server.FactoryUDP()
reactor.listenUDP(0, client_factory)
def wait_for_protocol():
while len(client_factory.instances) == 0:
time.sleep(1)
return True
d = threads.deferToThread(wait_for_protocol)
def run_loop(_):
proc = CommandProcessor(client_factory.instances[0])
reactor.callInThread(proc.cmdloop)
d.addCallback(run_loop)
reactor.run()
def run(self):
if config._get(config, 'sslcert', False):
with open(config.sslcert.certificate_file, 'rb') as fp:
cert = fp.read()
certificate = ssl.PrivateCertificate.loadPEM(cert)
co = certificate.options()
ssl_cert_options = ssl.CertificateOptions(co.privateKey, co.certificate, method=SSLv23_METHOD)
tls_cert_options = co
for proto_config in config.protocols:
factory = get_class_from_string(proto_config.factory)(proto_config, tls_cert_options, ssl_cert_options)
if proto_config.ssl and factory.supports_ssl:
reactor.listenSSL(proto_config.ssl.port, factory, ssl_cert_options)
if config._get(proto_config, 'transport') and proto_config.transport.lower() == 'udp':
reactor.listenUDP(proto_config.port, factory)
elif config._get(proto_config, 'tls') and proto_config.tls.enable and factory.supports_tls:
factory.options = tls_cert_options
reactor.listenTCP(proto_config.port, factory)
else:
reactor.listenTCP(proto_config.port, factory)
reactor.run()
def run_auth(self):
"""run auth
"""
auth_protocol = RADIUSAccess(self.config)
task.LoopingCall(auth_protocol.process_delay).start(2.7)
reactor.listenUDP(int(self.config.radiusd.auth_port), auth_protocol, interface=self.config.radiusd.host)
reactor.run()
def main(reactor, argv):
opt = parseCmdLine(argv)
command = opt.subCommand
controller = midi_or_keyboard(opt)
if command == 'udp':
so = opt.subOptions
if so['multi']:
mcastUDP = MulticastClientUDP()
a = reactor.listenUDP(0, mcastUDP)
class Decoder:
def __init__(self, a):
self.a = a
def decoder(self, b):
self.a.write(str(b), ('224.0.0.1', 8005))
w = Window(reactor)
w.submitTo(controller(Decoder(a)))
d = w.go()
return d
else:
h = Helloer(so.host, so.port)
w = Window(reactor)
w.submitTo(controller(h))
d = w.go()
d.addCallback(lambda a: h.sendDone())
reactor.listenUDP(0, h)
return d
else:
w = Window(reactor)
w.submitTo(controller())
d = w.go()
return d
def setUpForATest(self,
ServerProtocol=TestProtocol, ClientProtocol=TestProtocol):
serverProto = ServerProtocol()
clientProto = ClientProtocol()
self.serverProto = serverProto
self.clientProto = clientProto
sf = protocol.ServerFactory()
sf.protocol = lambda: serverProto
cf = Django()
cf.protocol = lambda: clientProto
serverTransport = ptcp.PTCP(sf)
clientTransport = ptcp.PTCP(None)
self.serverTransport = serverTransport
self.clientTransport = clientTransport
serverPort = reactor.listenUDP(0, serverTransport)
clientPort = reactor.listenUDP(0, clientTransport)
self.clientPort = clientPort
self.serverPort = serverPort
return (
serverProto, clientProto,
sf, cf,
serverTransport, clientTransport,
serverPort, clientPort
)
def announce(self, torrent):
self.torrent = torrent
host = yield reactor.resolve(self.host, timeout=(1, 3))
self.host = host
reactor.listenUDP(self.factory.track_port, self)
peers = yield self.deferred
defer.returnValue(peers)
def connectionMade(self):
self.sms_queue = defer.DeferredQueue()
self.sip_queue = defer.DeferredQueue()
self.sms_queue.get().addCallback(self.sipClientDataReceived)
self.sip_client_factory = SIPProxyClientProtocol(self.sms_queue, self.sip_queue)
from twisted.internet import reactor
reactor.listenUDP(5062, self.sip_client_factory)
def __init__(self, *args, **kwds):
super(James, self).__init__(*args, **kwds)
self.msgNumber = 0
self.lc_getTemp = task.LoopingCall(self.getTemp)
self.lc_getTemp.start(30.0)
self.lc_watt = task.LoopingCall(self.getWatts)
self.lc_watt.start(35.0)
self.lc_get_sigasantos = task.LoopingCall(self.getSantos)
self.lc_get_sigasantos.start(300.0)
self.lc_printOnClock = task.LoopingCall(self.printOnClock)
self.lc_printOnClock.start(35.0, now=False)
#TXOSC
self.port = 8000
self.dest_port = 9000
self.receiver = dispatch.Receiver()
self.sender = async.DatagramClientProtocol()
self._sender_port = reactor.listenUDP(0, self.sender)
self._server_port = reactor.listenUDP(self.port, async.DatagramServerProtocol(self.receiver))
self.receiver.addCallback("/trunetclock/brightness", self.trunetclock_brightness_handler)
self.receiver.addCallback("/ledcube/effect", self.ledcube_effect_handler)
self.receiver.addCallback("/ledcube/turnoff", self.ledcube_turnoff_handler)
def StartUdpServer(context, identity=None, address=None,
defer_reactor_run=False, custom_functions=[], **kwargs):
"""
Helper method to start the Modbus Async Udp server
:param context: The server data context
:param identify: The server identity to use (default empty)
:param address: An optional (interface, port) to bind to.
:param ignore_missing_slaves: True to not send errors on a request \
to a missing slave
:param defer_reactor_run: True/False defer running reactor.run() as part \
of starting server, to be explictly started by the user
:param custom_functions: An optional list of custom function classes
supported by server instance.
"""
from twisted.internet import reactor
address = address or ("", Defaults.Port)
framer = kwargs.pop("framer", ModbusSocketFramer)
server = ModbusUdpProtocol(context, framer, identity, **kwargs)
for f in custom_functions:
server.decoder.register(f)
_logger.info("Starting Modbus UDP Server on %s:%s" % address)
reactor.listenUDP(address[1], server, interface=address[0])
if not defer_reactor_run:
reactor.run(installSignalHandlers=_is_main_thread())
def __init__(self, config, test_obj):
"""Initialize and configure the DNS object."""
zones = []
port = config.get('port', 10053)
pyzones = config.get('python-zones', [])
bindzones = config.get('bind-zones', [])
for pyzone in pyzones:
zones.append(authority.PySourceAuthority(
'%s/dns_zones/%s' % (test_obj.test_name, pyzone)))
LOGGER.info("Added Python zone file %s" % (pyzone))
for bindzone in bindzones:
zones.append(authority.BindAuthority(
'%s/dns_zones/%s' % (test_obj.test_name, bindzone)))
LOGGER.info("Added BIND zone file %s" % (bindzone))
factory = server.DNSServerFactory(authorities=zones)
protocol = dns.DNSDatagramProtocol(controller=factory)
reactor.listenUDP(port, protocol)
reactor.listenTCP(port, factory)
LOGGER.info("Started DNS server (UDP and TCP) on port %d" % (port))
def main():
'''
Main test function
'''
# This section is only for logging stuff
# logger = NukeboxLogger('Client FileTX')
# Test Files
# fname = "05 ELECTRICBLOOM.mp3"
fname = "01 (THE FRENCH OPEN).mp3"
# fname = "02 CASSIUS.mp3"
# fname = "03 RED SOCKS PUGIE.mp3"
# fname = "08 TWO STEPS TWICE.mp3"
# Invalid File Format
# fname = "jukebox_client.log"
filesize = os.path.getsize(fname)
if filesize == 0:
print('File has No Content! :( ')
os._exit(1)
factory = NukeBoxClientFactory(fname)
print('*** Client Running ***')
udp_protocol = NukeBoxClientBroadcastProtocol(factory)
reactor.listenUDP(0, udp_protocol)
reactor.run()
def main():
from pyo import Sine
from bl.dsp import startPYO
s = startPYO()
from twisted.internet import reactor
from txosc.dispatch import Receiver
from txosc.async import DatagramServerProtocol
receiver = Receiver()
reactor.listenUDP(17779, DatagramServerProtocol(receiver),
interface='0.0.0.0')
sineMulMul = Sine(1)
sineMul = Sine(1, mul=sineMulMul)
sine = Sine([110, 110 + (55 / 32.)], mul=sineMul)
def cb(x, y, z):
sine.freq = [x * 220, x * 220 + (55 / 32.)]
sine.mul.freq = y * 55
sine.mul.mul.freq = z * 55
ori = Ori(receiver, cb)
acc = Acc(receiver, cb)
return s, ori, acc, sine
def main(argv):
sCFGName = 'mosul.cfg'
mosulConfig = ConfigParser.RawConfigParser()
mosulConfig.read(sCFGName)
sSyntax = os.path.basename(__file__) +" -n <stand_pipe_number> [-h for help]"
try:
opts, args = getopt.getopt(argv,"hn:",["number="])
except getopt.GetoptError:
print sSyntax
sys.exit(1)
if len(opts) < 1:
print sSyntax
sys.exit(2)
for opt, arg in opts:
if opt == '-h':
print sSyntax
sys.exit()
elif opt in ("-n", "--number"):
nStandpipe = int(arg)
if nStandpipe:
export_file = mosulConfig.get('DEMODATA','export_file')
port = mosulConfig.getint('DEMODATA','port')
server_host = mosulConfig.get('DEMODATA','server_host')
protocol = Standpipe()
protocol.m_init(server_host, port, nStandpipe,export_file)
reactor.listenUDP(port+nStandpipe+1, protocol)
reactor.run()
def run( self ):
if self.args.eyetracker:
reactor.listenUDP( 5555, self.client )
self.calibrator.start( self.start )
else:
self.start( None )
reactor.run()
def listen(self):
# Listen on UDP port
logging.info('AgentListener: Trying to listen UDP on port %s',\
str(self.udp_port))
try:
reactor.listenUDP(self.udp_port, AgentDatagramProtocol(self))
logging.info('AgentListener: Listening UDP on port %s',\
str(self.udp_port))
except:
logging.error('AgentListener: Failed to listen UDP on port %s',\
str(self.udp_port))
# Make sure we have enabled SSL
if not self.ssl_enabled:
return
# Listen on SSL port
ssl_factory = Factory()
AgentSSLProtocol.agent_listener = self
ssl_factory.protocol = AgentSSLProtocol
ssl_context_factory = twisted.internet.ssl.DefaultOpenSSLContextFactory(\
self.key_file_name, self.cert_file_name)
logging.info('AgentListener: Trying to listen SSL on port %s',\
str(self.ssl_port))
try:
reactor.listenSSL(self.ssl_port, ssl_factory, ssl_context_factory)
logging.info('AgentListener: Listening SSL on port %s',\
str(self.ssl_port))
except:
logging.error('AgentListener: Failed to listen SSL on port %s',\
str(self.ssl_port))
def main():
print "AndroidProxy --- (C) Mathy Vanhoef"
print "This program comes with ABSOLUTELY NO WARRANTY."
print
print "DNS server will listen on localhost:53"
print "HTTP Proxy will listen on localhost:8007"
print
#print "Physical device: Configure your computer dns server and as router (NOT as proxy) and execute"
#print "\tiptables -t nat -A PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8007"
#print "\tiptables -t nat -A PREROUTING -p tcp --dport 443 -j REDIRECT --to-port 8007"
#print
print "Emulator: start it using: emulator @AvdName -http-proxy http://localhost:8007 -dns-server localhost"
print
print "Don't forget to start your normal proxy on localhost:8080"
print
# Setup custom DNS server
resolvers = []
resolvers.append(ProxyResolver([('8.8.8.8', 53)]))
f = server.DNSServerFactory(clients=resolvers)
p = dns.DNSDatagramProtocol(f)
reactor.listenUDP(53, p)
# Setup TCP proxy server
endpoint = TCP4ServerEndpoint(reactor, 8007)
endpoint.listen(ProxyFactory('localhost', 8080))
# Start DNS and TCP server
reactor.run();
def run_normal(self):
if self.debug:
log.startLogging(sys.stdout)
else:
log.startLogging(DailyLogFile.fromFullPath(self.logfile))
log.msg("portal server listen %s" % self.portal_host)
reactor.listenUDP(self.listen_port, self, interface=self.portal_host)
def send(self, oscmsg):
# print "send: " + str(oscmsg)
if self.transport == None:
# bij eerste keer zenden het protocol starten
reactor.listenUDP(0, self)
# OSC bericht encoderen en versturen
self.transport.write(oscmsg.getBinary()) # no need for address
def main():
global database
global port
init()
log()
# Create connection to the Mongo DB
try:
client = MongoClient('localhost', 27017)
# Creating the database for the server
db = client[serverName]
collection = db['users']
# Access the user collection from the database
database = db.users
except:
logger.error("Cannot access the Mongo database.")
raise SystemExit
try:
reactor.listenUDP(port, mySensorUDPServer())
reactor.run(installSignalHandlers=False)
except Exception, e:
tkMessageBox.showinfo("SCPP Message", "Server All Ready Started")
# logger.info(_('Switch Shut Down'))
reactor.callFromThread(reactor.stop)
pass
def test_connect_to_other():
f1 = ConnectedUDPFactory(TestProtocol)
conn_proto1 = ConnectedUDPProtocol(f1, TestDatagram())
conn_proto1_addr = ("127.0.0.1", 7778)
active_proto1 = TestProtocol()
f2 = ConnectedUDPFactory(TestProtocol)
conn_proto2 = ConnectedUDPProtocol(f2, TestDatagram())
conn_proto2_addr = ("127.0.0.1", 7779)
active_proto2 = TestProtocol()
def make_connection1():
conn_proto1.connect("127.0.0.1", conn_proto2_addr[1], active_proto1)
def send_later1():
active_proto1.write_data("sent test data")
def send_much_later1():
active_proto1.write_data("sent test data much later")
def close_connection1():
active_proto1.close_connection()
def make_connection2():
conn_proto2.connect("127.0.0.1", conn_proto1_addr[1], active_proto2)
def send_later2():
active_proto2.write_data("sent test data")
def send_much_later2():
active_proto2.write_data("sent test data much later")
def close_connection2():
active_proto2.close_connection()
from twisted.internet import reactor
def stop():
reactor.stop()
reactor.listenUDP(conn_proto1_addr[1], conn_proto1)
reactor.listenUDP(conn_proto2_addr[1], conn_proto2)
reactor.callLater(1, make_connection1)
reactor.callLater(5, send_later1)
reactor.callLater(10, send_much_later1)
reactor.callLater(15, close_connection1)
reactor.callLater(20, make_connection2)
reactor.callLater(25, send_later2)
reactor.callLater(30, send_much_later2)
reactor.callLater(35, close_connection2)
reactor.callLater(40, stop)
print "prepared for run"
reactor.run()
print "stopped"
return
def __init__(self, address = None, data_callback = None):
self.data_callback = data_callback
if address == None:
reactor.listenUDP(0, self)
else:
reactor.listenUDP(address[1], self, address[0])
filterwarnings('ignore', '^Please only pass')
def main():
log.startLogging(sys.stdout)
reactor.connectTCP('localhost', 5555, BackboneFactory())
reactor.listenUDP(9999, UDPProtocol())
reactor.run()
def main():
server = ServerProtocol(("127.0.0.1", SERVER_PORT), reactor)
reactor.listenUDP(SERVER_PORT, server, "127.0.0.1")
task.LoopingCall(printRoute, server).start(5)
reactor.run()
d = defer.maybeDeferred(self.processPacket, pkt)
d.addErrback(errback, host)
return d
class RADIUSAccess(RADIUS):
def createPacket(self, **kwargs):
return self.CreateAuthPacket(**kwargs)
def processPacket(self, pkt):
if pkt.code != packet.AccessRequest:
raise PacketError(
'non-AccessRequest packet on authentication socket')
class RADIUSAccounting(RADIUS):
def createPacket(self, **kwargs):
return self.CreateAcctPacket(**kwargs)
def processPacket(self, pkt):
if pkt.code != packet.AccountingRequest:
raise PacketError(
'non-AccountingRequest packet on authentication socket')
if __name__ == '__main__':
log.startLogging(sys.stdout, 0)
reactor.listenUDP(1812, RADIUSAccess())
reactor.listenUDP(1813, RADIUSAccounting())
reactor.run()
# http://blog.csdn.net/ren911/article/details/5313145
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class Echo(DatagramProtocol):
def datagramReceived(self, data, (host, port)):
print "received %r from %s:%d" % (data, host, port)
data = data + ' udp-scan1.py '
self.transport.write(data, (host, port))
reactor.listenUDP(9999, Echo())
reactor.run()
from twisted.internet.protocol import DatagramProtocol
from twisted.internet import reactor
class Helloer(DatagramProtocol):
def startProtocol(self):
host = "192.168.1.1"
port = 1234
self.transport.connect(host, port)
print("now we can only send to host {} port {}".format(host, port))
self.transport.write(bytes('hello server',
'utf-8')) # no need for address
def datagramReceived(self, data, host, port):
print("received {} from {}:{}".format(data, host, port))
# Possibly invoked if there is no server listening on the
# address to which we are sending.
def connectionRefused(self):
print("No one listening")
# 0 means any port, we don't care in this case
reactor.listenUDP(0, Helloer())
reactor.run()
def start(port=516, **kwargs):
log.info("Starting junos syslog engine (port %s)", port)
reactor.listenUDP(port, _SyslogServerFactory(kwargs))
reactor.run()
def listen_on_udp(self):
return reactor.listenUDP(0, self.socket_mgr)
if int(low_port) < 1024:
if display_low_port_message:
print 'Your service configuration suggests that you want to run on at least one low port!'
print 'To enable port redirection run the following ipt-kit (https://github.com/foospidy/ipt-kit) commands as root:'
print ''
display_low_port_message = False
try:
if protocol.lower() == 'tcp':
# run tcp service
service_object = reactor.listenTCP(
int(port), plugin.pluginFactory(service))
else:
# run udp service
service_object = reactor.listenUDP(
int(port),
plugin.pluginMain(service, get_ip_address(), port))
if service_object:
# stop services from listening immediately if not starting in daemon mode.
if args.d is False:
service_object.stopListening()
# save service objects to array, to be used by HoneyPy Console
services[0].append(service)
services[1].append(service_object)
except Exception as e:
print str(e) + '\n'
if str(e).find('Permission denied') != -1:
SimpleTCPReachabilityCheckFactory(
server, host, port, serverList),
timeout=5)
else:
serverList.put(server)
# TODO: Prevent datagram reordering from re-registering a server (e.g. block the server ID for a few seconds)
class GG2UnregHandler(object):
def handle(self, data, (host, origport), serverList):
if (len(data) != 32): return
serverList.remove(uuid.UUID(bytes=data[16:32]))
NewStyleReg.REG_PROTOCOLS[uuid.UUID(
"b5dae2e8-424f-9ed0-0fcb-8c21c7ca1352")] = GG2RegHandler()
NewStyleReg.REG_PROTOCOLS[uuid.UUID(
"488984ac-45dc-86e1-9901-98dd1c01c064")] = GG2UnregHandler()
serverList = GameServerList()
reactor.listenUDP(29942, GG2LobbyRegV1(serverList))
reactor.listenUDP(29944, NewStyleReg(serverList))
reactor.listenTCP(29942, GG2LobbyQueryV1Factory(serverList))
reactor.listenTCP(29944, NewStyleListFactory(serverList))
webres = twisted.web.static.File("httpdocs")
webres.putChild("status", weblist.LobbyStatusResource(serverList))
reactor.listenTCP(29950, twisted.web.server.Site(webres))
reactor.run()
# Re-Write timeslot if necessary...
if _ts == 0:
_burst_data_type = BURST_DATA_TYPE['SLOT1_VOICE']
elif _ts == 1:
_burst_data_type = BURST_DATA_TYPE['SLOT2_VOICE']
_tmp_data = _tmp_data[:30] + _burst_data_type + _tmp_data[
31:]
_tmp_data = self.hashed_packet(
NETWORK[_network]['LOCAL']['AUTH_KEY'], _tmp_data)
# Send the packet to all peers in the target IPSC
self.send_to_ipsc(_tmp_data)
time.sleep(0.06)
self.CALL_DATA = []
logger.info('(%s) Event ID: %s - Playback Completed', _network,
self.event_id)
self.event_id = self.event_id + 1
if __name__ == '__main__':
logger.info(
'DMRlink \'record.py\' (c) 2014 N0MJS & the K0USY Group - SYSTEM STARTING...'
)
for ipsc_network in NETWORK:
if NETWORK[ipsc_network]['LOCAL']['ENABLED']:
networks[ipsc_network] = playIPSC(ipsc_network)
reactor.listenUDP(NETWORK[ipsc_network]['LOCAL']['PORT'],
networks[ipsc_network],
interface=NETWORK[ipsc_network]['LOCAL']['IP'])
reactor.run()
def main():
"""
Run the server.
"""
argparser = ArgumentParser(
description='nsshell.py HOST IP\nnsshell.py localhost 127.0.0.1',
formatter_class=RawTextHelpFormatter)
argparser.add_argument(
'hostname',
default=str(subprocess.check_output(['hostname', '-f'])).strip(),
nargs='?',
help='hostname of the publicly facing server, for debugging=localhost',
type=str)
argparser.add_argument('ip',
default='',
nargs='?',
help='ip addr of publicly facing server',
type=str)
config_args = argparser.add_argument_group(title='Config Args')
config_args.add_argument('--logdir',
action='store',
default='',
dest='logdir',
help='set logging directory')
if len(sys.argv) <= 2:
argparser.print_help()
sys.exit(1)
args = vars(argparser.parse_args())
# check to see if logging has been disabled
if args['logdir'].lower() in config.CLI_NO:
config.LOG_DIR = None
elif args['logdir']:
config.LOG_DIR = os.path.realpath(args['logdir'])
if config.LOG_DIR and not os.path.exists(config.LOG_DIR):
os.makedirs(config.LOG_DIR)
hostname = args['hostname']
ip = args['ip']
if len(ip) > 15:
sys.stderr.write("Must be ipv4:" + args['ip'])
sys.exit(1)
print("Starting nsshell - DO NOT DISTRIBUTE")
print("using hostname: " + hostname)
print("using IP: " + ip)
if config.LOG_DIR:
print("logging to: " + config.LOG_DIR)
load = loader(hostname, ip)
payload_count = len(load.payloads)
#payload_count is used to prevent session IDs and payloads from sharing the same keys.
sessionhandler = session_handler(payload_count)
sr = ShellResolver(sessionhandler, ip, hostname, load)
console_handler = Console()
console_handler.setSession(sessionhandler)
#The torando DNS server will throw a harmless exception when scanned by nmap.
#We are overriding gotResolverResponse with a lambda to avoid this exception:
#File "/usr/lib/python2.7/dist-packages/twisted/names/server.py", line 263, in gotResolverResponse
# def gotResolverResponse(self, (ans, auth, add), protocol, message, address):
#exceptions.TypeError: 'NoneType' object is not iterable
server.gotResolverResponse = lambda *x: False
factory = server.DNSServerFactory(
clients=[sr]
#We don't want to be an open resolver:
#, client.Resolver(resolv='/etc/resolv.conf')]
)
protocol = dns.DNSDatagramProtocol(controller=factory)
print("binding udp/53")
reactor.listenUDP(53, protocol)
print("binding tcp/53")
reactor.listenTCP(53, factory)
with open('payloads.txt', 'w') as f:
for payload in load.build_payloads():
f.write(payload + "\n")
print("wrote connect-back payloads to:payloads.txt")
stdio.StandardIO(console_handler)
reactor.run()
def main():
reactor.listenUDP(0, ClientProtocol(sys.argv[1], sys.argv[2]))
for subscription in self.subscriptions.values():
if subscription.monitor_id == mac:
treq.post(subscription.url,
data=json.dumps(attr.asdict(payload),
default=json_serialize),
headers={b'Content-Type': [b'application/json']})
def startProtocol(self):
self.loop = LoopingCall(self.pollConnectedHostsForData)
self.loop.start(2)
def stopProtocol(self):
if self.loop is not None:
self.loop.stop()
if __name__ == '__main__':
monitors = {}
subscriptions = {}
w = web.EinsteinWebServer(monitors=monitors,
subscriptions=subscriptions).app.resource()
import os
reactor.listenTCP(int(os.getenv("PORT", 8080)), server.Site(w))
i = IntellivueInterface(monitors=monitors,
subscriptions=subscriptions,
dumpfilename=os.getenv("DUMPFILENAME"))
reactor.listenUDP(packets.PORT_CONNECTION_INDICATION, i)
log.info("Starting...")
reactor.run()
def setUp(self):
"""Start a UDP port"""
self.server = Server()
self.port = reactor.listenUDP(0, self.server, interface='127.0.0.1')
RosbridgeUdpSocket.params_glob = []
else:
RosbridgeUdpSocket.params_glob = [
element.strip().strip("'")
for element in value[1:-1].split(',')
]
else:
print(
"--params_glob argument provided without a value. (can be None or a list)"
)
sys.exit(-1)
# To be able to access the list of topics and services, you must be able to access the rosapi services.
if RosbridgeUdpSocket.services_glob:
RosbridgeUdpSocket.services_glob.append("/rosapi/*")
Subscribe.topics_glob = RosbridgeUdpSocket.topics_glob
Advertise.topics_glob = RosbridgeUdpSocket.topics_glob
Publish.topics_glob = RosbridgeUdpSocket.topics_glob
AdvertiseService.services_glob = RosbridgeUdpSocket.services_glob
UnadvertiseService.services_glob = RosbridgeUdpSocket.services_glob
CallService.services_glob = RosbridgeUdpSocket.services_glob
##################################################
# Done with parameter handling #
##################################################
rospy.loginfo("Rosbridge UDP server started on port %d", port)
reactor.listenUDP(port, RosbridgeUdpFactory(), interface=interface)
reactor.run()
def cbServerStarted(ignored):
self.port2 = reactor.listenUDP(0, client, interface="127.0.0.1")
return clientStarted
well_known = resource.CoAPResource()
root.putChild('.well-known', well_known)
core = CoreResource(root)
well_known.putChild('core', core)
counter = CounterResource(5000)
root.putChild('counter', counter)
time = TimeResource()
root.putChild('time', time)
other = resource.CoAPResource()
root.putChild('other', other)
block = BlockResource()
other.putChild('block', block)
separate = SeparateLargeResource()
other.putChild('separate', separate)
dev = resource.CoAPResource()
root.putChild('dev', dev)
button = ButtonResources()
root.putChild('button', button)
endpoint = resource.Endpoint(root)
reactor.listenUDP(coap.COAP_PORT, coap.Coap(endpoint)) #, interface="::")
reactor.run()
def cbStopped(ignored):
d = server.startedDeferred = defer.Deferred()
p = reactor.listenUDP(0, server, interface="127.0.0.1")
return d.addCallback(cbStarted, p)
def testDatagramReceivedError(self):
"""
Test that when datagramReceived raises an exception it is logged but
the port is not disconnected.
"""
finalDeferred = defer.Deferred()
def cbCompleted(ign):
"""
Flush the exceptions which the reactor should have logged and make
sure they're actually there.
"""
errs = self.flushLoggedErrors(BadClientError)
self.assertEquals(len(errs), 2, "Incorrectly found %d errors, expected 2" % (len(errs),))
finalDeferred.addCallback(cbCompleted)
client = BadClient()
port = reactor.listenUDP(0, client, interface='127.0.0.1')
def cbCleanup(result):
"""
Disconnect the port we started and pass on whatever was given to us
in case it was a Failure.
"""
return defer.maybeDeferred(port.stopListening).addBoth(lambda ign: result)
finalDeferred.addBoth(cbCleanup)
addr = port.getHost()
# UDP is not reliable. Try to send as many as 60 packets before giving
# up. Conceivably, all sixty could be lost, but they probably won't be
# unless all UDP traffic is being dropped, and then the rest of these
# UDP tests will likely fail as well. Ideally, this test (and probably
# others) wouldn't even use actual UDP traffic: instead, they would
# stub out the socket with a fake one which could be made to behave in
# whatever way the test desires. Unfortunately, this is hard because
# of differences in various reactor implementations.
attempts = range(60)
succeededAttempts = []
def makeAttempt():
"""
Send one packet to the listening BadClient. Set up a 0.1 second
timeout to do re-transmits in case the packet is dropped. When two
packets have been received by the BadClient, stop sending and let
the finalDeferred's callbacks do some assertions.
"""
if not attempts:
try:
self.fail("Not enough packets received")
except:
finalDeferred.errback()
self.failIfIdentical(client.transport, None, "UDP Protocol lost its transport")
packet = str(attempts.pop(0))
packetDeferred = defer.Deferred()
client.setDeferred(packetDeferred)
client.transport.write(packet, (addr.host, addr.port))
def cbPacketReceived(packet):
"""
A packet arrived. Cancel the timeout for it, record it, and
maybe finish the test.
"""
timeoutCall.cancel()
succeededAttempts.append(packet)
if len(succeededAttempts) == 2:
# The second error has not yet been logged, since the
# exception which causes it hasn't even been raised yet.
# Give the datagramReceived call a chance to finish, then
# let the test finish asserting things.
reactor.callLater(0, finalDeferred.callback, None)
else:
makeAttempt()
def ebPacketTimeout(err):
"""
The packet wasn't received quickly enough. Try sending another
one. It doesn't matter if the packet for which this was the
timeout eventually arrives: makeAttempt throws away the
Deferred on which this function is the errback, so when
datagramReceived callbacks, so it won't be on this Deferred, so
it won't raise an AlreadyCalledError.
"""
makeAttempt()
packetDeferred.addCallbacks(cbPacketReceived, ebPacketTimeout)
packetDeferred.addErrback(finalDeferred.errback)
timeoutCall = reactor.callLater(
0.1, packetDeferred.errback,
error.TimeoutError(
"Timed out in testDatagramReceivedError"))
makeAttempt()
return finalDeferred
from fne.fne_core import mk_id_dict
from fne.fne_core import setup_fne
# perform basic FNE setup
config, logger, act_log_file = setup_fne()
logger.info('Digital Voice Modem Parrot Service D01.00')
# setup FNE report server
report_server = config_reports(config, logger, reportFactory)
# make dictionaries
white_rids = mk_id_dict(config['Aliases']['Path'],
config['Aliases']['WhitelistRIDsFile'])
if white_rids:
logger.info('ID MAPPER: white_rids dictionary is available')
# FNE instance creation
logger.info('Parrot FNE - SYSTEM STARTING...')
for system in config['Systems']:
if config['Systems'][system]['Enabled']:
systems[system] = parrotFNE(system, config, logger, act_log_file,
report_server)
reactor.listenUDP(config['Systems'][system]['Port'],
systems[system],
interface=config['Systems'][system]['Address'])
logger.debug('%s instance created: %s, %s',
config['Systems'][system]['Mode'], system,
systems[system])
reactor.run()
def testSendPackets(self):
server = Server()
serverStarted = server.startedDeferred = defer.Deferred()
port1 = reactor.listenUDP(0, server, interface="127.0.0.1")
client = GoodClient()
clientStarted = client.startedDeferred = defer.Deferred()
def cbServerStarted(ignored):
self.port2 = reactor.listenUDP(0, client, interface="127.0.0.1")
return clientStarted
d = serverStarted.addCallback(cbServerStarted)
def cbClientStarted(ignored):
client.transport.connect("127.0.0.1",
server.transport.getHost().port)
cAddr = client.transport.getHost()
sAddr = server.transport.getHost()
serverSend = client.packetReceived = defer.Deferred()
server.transport.write("hello", (cAddr.host, cAddr.port))
clientWrites = [
("a",),
("b", None),
("c", (sAddr.host, sAddr.port))]
def cbClientSend(ignored):
if clientWrites:
nextClientWrite = server.packetReceived = defer.Deferred()
nextClientWrite.addCallback(cbClientSend)
client.transport.write(*clientWrites.pop(0))
return nextClientWrite
# No one will ever call .errback on either of these Deferreds,
# but there is a non-trivial amount of test code which might
# cause them to fail somehow. So fireOnOneErrback=True.
return defer.DeferredList([
cbClientSend(None),
serverSend],
fireOnOneErrback=True)
d.addCallback(cbClientStarted)
def cbSendsFinished(ignored):
cAddr = client.transport.getHost()
sAddr = server.transport.getHost()
self.assertEquals(
client.packets,
[("hello", (sAddr.host, sAddr.port))])
clientAddr = (cAddr.host, cAddr.port)
self.assertEquals(
server.packets,
[("a", clientAddr),
("b", clientAddr),
("c", clientAddr)])
d.addCallback(cbSendsFinished)
def cbFinished(ignored):
return defer.DeferredList([
defer.maybeDeferred(port1.stopListening),
defer.maybeDeferred(self.port2.stopListening)],
fireOnOneErrback=True)
d.addCallback(cbFinished)
return d
