コード例 #1
0
ファイル: ipbus.py プロジェクト: kratsg/ironman
def main():
  reactor.listenTCP(8000, IPBusServerFactory())
  reactor.listenUDP(8000, IPBusServerProtocol())

  reactor.run()

  reactor.stop()
コード例 #2
0
ファイル: test.py プロジェクト: wjianwei126/btcrawler
def main():
    boots = (('router.bittorrent.com', 6881),)
    p = BittorrentProtocol(boots)
    # lc = LoopingCall(monitor, p)
    # lc.start(5)
    reactor.listenUDP(6881, p)
    reactor.run()
コード例 #3
0
ファイル: ndss.py プロジェクト: jovistar/nDroid-Scheduler
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()
コード例 #4
0
ファイル: start_autopilot.py プロジェクト: pmatigakis/Huginn
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()
コード例 #5
0
ファイル: nde.py プロジェクト: jovistar/nDroid-Executer
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()
コード例 #6
0
ファイル: BTApp.py プロジェクト: jakesyl/AutonomoTorrent
    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)
コード例 #7
0
    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)
コード例 #8
0
ファイル: coap_protocol.py プロジェクト: azyuqian/CoAPthon
 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")
コード例 #9
0
ファイル: client.py プロジェクト: danielkza/mac0448-chat
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()
コード例 #10
0
ファイル: listener.py プロジェクト: spuriousdata/slim
    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()
コード例 #11
0
ファイル: radiusd.py プロジェクト: actcms/toughwlan
 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()
コード例 #12
0
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
コード例 #13
0
ファイル: test_ptcp.py プロジェクト: derwolfe/vertex
    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
            )
コード例 #14
0
ファイル: tracker.py プロジェクト: jschneier/TwistedTorrent
 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)
コード例 #15
0
ファイル: sms-proxy.py プロジェクト: kluchnikov/sms-proxy
 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)
コード例 #16
0
ファイル: main.py プロジェクト: trunet/james
	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)
コード例 #17
0
ファイル: asynchronous.py プロジェクト: bashwork/pymodbus
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())
コード例 #18
0
    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))
コード例 #19
0
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()
コード例 #20
0
ファイル: andosc.py プロジェクト: csv/beatlounge
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
コード例 #21
0
ファイル: standpipe_client.py プロジェクト: andreadanzi/epbm
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()
コード例 #22
0
 def run( self ):
     if self.args.eyetracker:
         reactor.listenUDP( 5555, self.client )
         self.calibrator.start( self.start )
     else:
         self.start( None )
     reactor.run()
コード例 #23
0
    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))
コード例 #24
0
ファイル: main.py プロジェクト: divdby0/androidproxy
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();
コード例 #25
0
ファイル: cmcc_server.py プロジェクト: simudream/toughportal
 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)
コード例 #26
0
    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
コード例 #27
0
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
コード例 #28
0
ファイル: connected_udp.py プロジェクト: imatsko/BitTalks
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
コード例 #29
0
ファイル: Udp_server.py プロジェクト: gtkiller/b2bua
 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')
コード例 #30
0
ファイル: nexusDummy.py プロジェクト: NetFalcon/2013
def main():
    log.startLogging(sys.stdout)

    reactor.connectTCP('localhost', 5555, BackboneFactory())
    reactor.listenUDP(9999, UDPProtocol())

    reactor.run()
コード例 #31
0
ファイル: Server.py プロジェクト: Leo-xh/Virtual-Routing
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()
コード例 #32
0
        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()
コード例 #33
0
ファイル: udp-scan1.py プロジェクト: zhangyuyan/github
# 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()
コード例 #34
0
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()
コード例 #35
0
def start(port=516, **kwargs):

    log.info("Starting junos syslog engine (port %s)", port)
    reactor.listenUDP(port, _SyslogServerFactory(kwargs))
    reactor.run()
コード例 #36
0
ファイル: torrent_checker.py プロジェクト: xemasiv/tribler
 def listen_on_udp(self):
     return reactor.listenUDP(0, self.socket_mgr)
コード例 #37
0
ファイル: Honey.py プロジェクト: zfleharty/cs499HoneyPot
            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:
コード例 #38
0
ファイル: lobby.py プロジェクト: Medo42/Faucet-Lobby
                                      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()
コード例 #39
0
                    # 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()
コード例 #40
0
ファイル: __init__.py プロジェクト: skim-milk/nsshell
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()
コード例 #41
0
def main():
    reactor.listenUDP(0, ClientProtocol(sys.argv[1], sys.argv[2]))
コード例 #42
0
        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()
コード例 #43
0
 def setUp(self):
     """Start a UDP port"""
     self.server = Server()
     self.port = reactor.listenUDP(0, self.server, interface='127.0.0.1')
コード例 #44
0
                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()
コード例 #45
0
 def cbServerStarted(ignored):
     self.port2 = reactor.listenUDP(0, client, interface="127.0.0.1")
     return clientStarted
コード例 #46
0
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()
コード例 #47
0
 def cbStopped(ignored):
     d = server.startedDeferred = defer.Deferred()
     p = reactor.listenUDP(0, server, interface="127.0.0.1")
     return d.addCallback(cbStarted, p)
コード例 #48
0
    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
コード例 #49
0
ファイル: fne_parrot.py プロジェクト: gatekeep/dvmfne
    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()
コード例 #50
0
    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