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