def __init__(self): class logObserver: def __init__(self, con): self.con = con def emit(self, eventDict): edm = eventDict['message'] if not edm: if eventDict['isError'] and 'failure' in eventDict: text = ((eventDict.get('why') or 'Unhandled Error') + '\n' + eventDict['failure'].getTraceback()) elif 'format' in eventDict: text = eventDict['format'] % eventDict else: text = str(eventDict) else: text = ' '.join(map(reflect.safe_str, edm)) self.con.addLine(text) stdscr = curses.initscr() # initialize curses self.screen = Screen(stdscr) # create Screen object log.addObserver(logObserver(self.screen).emit) stdscr.refresh() reactor.addReader(self.screen) # add screen object as a reader to the reactor task.LoopingCall(self.screen.updateDisplay).start(.25)
def __init__(self, device_rd, device_wr, protocol): self.log = logging.getLogger('dr2dp.dr') self.buff = '' self.dp_interface = protocol self.dp_interface.register_click_interface(self) self.optype_req2handler = { DR2DPMessage1.OP_TYPE_PING: self.ping, DR2DPMessage1.OP_TYPE_FORWARD_IP: self.forward_ip, DR2DPMessage1.OP_TYPE_REDIRECT_FLOW: self.redirect_flow, DR2DPMessage1.OP_TYPE_TLS_FLOW_ESTABLISHED: self.tls_flow, } try: self.rd_fd = os.open(device_rd, os.O_RDONLY | os.O_NONBLOCK) # Note: blocking write, assume this devicewon't block self.wr_fd = os.open(device_wr, os.O_WRONLY) print "Connected to kernel" except os.error: print "Failed to connect to kernel" self.rd_fd = -1 self.wr_fd = -1 self.log.warn("failed to open click device") return reactor.addReader(self)
def startService(self): self.tunDevice = pytun.TunTapDevice(flags=pytun.IFF_TUN|pytun.IFF_NO_PI) self.tunDevice.addr = self.tun_local_ip self.tunDevice.dstaddr = self.tun_remote_ip self.tunDevice.netmask = self.tun_netmask self.tunDevice.mtu = self.tun_mtu # TODO: drop priveleges after bringing up interface self.tunDevice.up() # UDP <-> TUN tun_consumer = TUNPacketConsumer(self.tunDevice) udp_ConsumerProducerProxy = UDP_ConsumerProducerProxy( consumer = tun_consumer, local_ip = self.udp_local_ip, local_port = self.udp_local_port, remote_ip = self.udp_remote_ip, remote_port = self.udp_remote_port) tun_producer = TUNPacketProducer(self.tunDevice, consumer = udp_ConsumerProducerProxy) reactor.listenUDP(self.udp_local_port, udp_ConsumerProducerProxy) reactor.addReader(tun_producer)
def __init__(self, socket, callback=None, hosts=[]): self.socket = socket self.callback = callback self.hosts = hosts from twisted.internet import reactor reactor.addReader(self)
def main(stdscr): parser = argparse.ArgumentParser() parser.add_argument("user", type=str) parser.add_argument("-v", "--verbose", action="count") args = parser.parse_args() user = args.user server_name = origin_from_ucid(user) ## Set up logging ## root_logger = logging.getLogger() formatter = logging.Formatter( "%(asctime)s - %(name)s - %(lineno)d - " "%(levelname)s - %(message)s" ) if not os.path.exists("logs"): os.makedirs("logs") fh = logging.FileHandler("logs/%s" % user) fh.setFormatter(formatter) root_logger.addHandler(fh) root_logger.setLevel(logging.DEBUG) # Hack: The only way to get it to stop logging to sys.stderr :( log.theLogPublisher.observers = [] observer = log.PythonLoggingObserver() observer.start() ## Set up synapse server curses_stdio = cursesio.CursesStdIO(stdscr) input_output = InputOutput(curses_stdio, user) curses_stdio.set_callback(input_output) app_hs = SynapseHomeServer(server_name, db_name="dbs/%s" % user) replication = app_hs.get_replication_layer() hs = HomeServer(server_name, replication, curses_stdio) input_output.set_home_server(hs) ## Add input_output logger io_logger = IOLoggerHandler(input_output) io_logger.setFormatter(formatter) root_logger.addHandler(io_logger) ## Start! ## try: port = int(server_name.split(":")[1]) except: port = 12345 app_hs.get_http_server().start_listening(port) reactor.addReader(curses_stdio) reactor.run()
def __init__(self, target, **settings): self.target = target self.settings = settings self.verbose = settings.get("verbose") self.proto = settings.get("proto") self.rfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP) if self.proto == "icmp": self.sfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP) elif self.proto == "udp": self.sfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_UDP) elif self.proto == "tcp": self.sfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP) self.rfd.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) self.sfd.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) self.hops = [] self.out_queue = [] self.waiting = True self.deferred = defer.Deferred() reactor.addReader(self) reactor.addWriter(self) # send 1st probe packet self.out_queue.append(Hop(self.target, 1, settings.get("proto"), self.settings.get("dport"), self.settings.get("sport")))
def afterChannelDownload(self, result, filename, deleteFile=True): print("[EPGImport] afterChannelDownload", filename, file=log) if filename: try: if not os.path.getsize(filename): raise Exception("File is empty") except Exception as e: self.channelDownloadFail(e) return if twisted.python.runtime.platform.supportsThreads(): print("[EPGImport] Using twisted thread", file=log) threads.deferToThread( self.doThreadRead, filename).addCallback(lambda ignore: self.nextImport()) deleteFile = False # Thread will delete it else: self.iterator = self.createIterator(filename) reactor.addReader(self) if deleteFile and filename: try: os.unlink(filename) except Exception as e: print( "[EPGImport] warning: Could not remove '%s' intermediate" % filename, e, file=log)
def main(): # parse options parser = optparse.OptionParser() parser.add_option("-p", "--port", dest="port", help="Webserver port.", metavar="<port>", default=8080) (options, args) = parser.parse_args() twisted_client = Client() #register Bionet callbacks pybionet_register_callback_new_hab(cb_new_hab) pybionet_register_callback_lost_hab(cb_lost_hab); pybionet_register_callback_new_node(cb_new_node); pybionet_register_callback_lost_node(cb_lost_node); pybionet_register_callback_datapoint(cb_datapoint); data = DataServer() full = Datapoints() root = Resource() root.putChild('plot', File("plot.html")) root.putChild('flot', File("flot")) root.putChild('data', data) root.putChild('full', full) factory = Site(root) reactor.listenTCP(options.port, factory) reactor.addReader(twisted_client) reactor.run()
def start_dns_queue(self): self.q = nfqueue.queue() self.q.set_callback(self.nfqueue_callback) self.q.fast_open(0, socket.AF_INET) self.q.set_queue_maxlen(5000) reactor.addReader(self) self.q.set_mode(nfqueue.NFQNL_COPY_PACKET)
def __init__(self, callback, interface='tun0', ip_addr=None, netmask='255.255.255.0', logname='cb.tcphijack', tunowner=1000): """ Constructor Creates the TUN device, sets the file descriptor, and registers itself with the Twisted reactor Parameters: callback: The callback function (that takes a single pkt argument) to call when a packet has been read interface: The name of the TUN interface to create. If specified as '', then the system will find an available device or create a new device. ip_addr: The IP address to give the interface netmask: The netmask to configure for the interface logname: The name of the logger for this instance tunowner: The uid of the tun owner (?) """ self.interface = interface (self.fdesc, self.iface) = self.open_tun(tunowner, interface, ip_addr, netmask) self.callback = callback self.log = logging.getLogger(logname) reactor.addReader(self)
def __init__(self, identity=None, default_recipient=None): """ Prepares ZMQ socket. You can supply an identity to be able to bootstrap communication by sending messages to well-known participants. Participants sending most messages to a single recipient can set it as default as ommit it's name when calling the send method. Every message contains a timestamp that is checked by recipient. If the time difference is larger than 15 seconds, message is dropped. Make sure your machines use NTP to synchronize their clocks. """ # Create the 0MQ socket. self.socket = zmq.Context.instance().socket(zmq.ROUTER) # Assume either user-specified identity or generate our own. if identity is not None: self.socket.setsockopt(zmq.IDENTITY, identity) else: self.socket.setsockopt(zmq.IDENTITY, uuidgen()) # Remember the default recipient. self.default_recipient = default_recipient # Register ourselves with Twisted reactor loop. reactor.addReader(self)
def run(self, stdscr): """ This method is called by the curses.wrapper to start the mainloop and screen. :param stdscr: curses screen passed in from curses.wrapper """ # We want to do an interactive session, so start up the curses screen and # pass it the function that handles commands colors.init_colors() self.screen = screen.Screen(stdscr, self.do_command, self.tab_completer, self.encoding) self.statusbars = StatusBars() self.eventlog = EventLog() self.screen.topbar = "{!status!}Deluge " + deluge.common.get_version() + " Console" self.screen.bottombar = "{!status!}" self.screen.refresh() # The Screen object is designed to run as a twisted reader so that it # can use twisted's select poll for non-blocking user input. reactor.addReader(self.screen) # Start the twisted mainloop reactor.run()
def main(): parser = argparse.ArgumentParser(description="WaterRower monitor") parser.add_argument("-p", "--port", dest="serial_port", default="/dev/ttyUSB0") parser.add_argument("-s", "--speed", dest="speed", default=1200) parser.add_argument("-n", "--nodatalog", dest="record_datalog", action='store_false') parser.add_argument("-c", "--creds_filename", help="Name of Google credentials file") parser.add_argument("-g", "--name", help="Name of Google Spreadsheet") parser.add_argument("-b", "--bucket", help="Name of Google Cloud Storage bucket") opts = parser.parse_args() log.startLogging(file( "collector-{}.log".format( datetime.datetime.now().replace(microsecond=0).isoformat()), 'w')) stdscr = curses.initscr() session = InternetWaterRower( record_datalog=opts.record_datalog, creds_filename=opts.creds_filename, spreadsheet_name=opts.name, bucket_name=opts.bucket) cons = InternetWaterRowerConsole(stdscr, session) stdscr.refresh() reactor.addReader(cons) SerialPort(session, opts.serial_port, reactor, baudrate=opts.speed) reactor.run() cons.close()
def __init__(self, target, **settings): self.target = target self.settings = settings self.verbose = settings.get("verbose") self.proto = settings.get("proto") self.rfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP) if self.proto == "icmp": self.sfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_ICMP) elif self.proto == "udp": self.sfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_UDP) elif self.proto == "tcp": self.sfd = socket.socket(socket.AF_INET, socket.SOCK_RAW, socket.IPPROTO_TCP) self.rfd.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) self.sfd.setsockopt(socket.IPPROTO_IP, socket.IP_HDRINCL, 1) self.hops = [] self.out_queue = [] self.waiting = True self.deferred = defer.Deferred() reactor.addReader(self) reactor.addWriter(self) # send 1st probe packet self.out_queue.append( Hop(self.target, 1, settings.get("proto"), self.settings.get("dport"), self.settings.get("sport")))
def __init__(self, name, port): self.rsock = pybonjour.DNSServiceRegister(name=name, regtype="_hopper._tcp", port=port, callBack=self.register_callback, domain="local.") reactor.addReader(self)
def start(): from twisted.internet import reactor global WATCHER if not WATCHER: WATCHER = FileWatcher() reactor.addReader(FileWatcher()) return WATCHER
def afterDownload(self, result, filename, deleteFile=False): if os.path.getsize(filename) > 0: print>>log, "[EPGImport] afterDownload", filename if self.source.parser == 'epg.dat': if twisted.python.runtime.platform.supportsThreads(): print>>log, "[EPGImport] Using twisted thread for DAT file" threads.deferToThread(self.readEpgDatFile, filename, deleteFile).addCallback(lambda ignore: self.nextImport()) else: self.readEpgDatFile(filename, deleteFile) return if filename.endswith('.gz'): self.fd = gzip.open(filename, 'rb') else: self.fd = open(filename, 'rb') if twisted.python.runtime.platform.supportsThreads(): print>>log, "[EPGImport] Using twisted thread!" threads.deferToThread(self.doThreadRead).addCallback(lambda ignore: self.nextImport()) else: self.iterator = self.createIterator() reactor.addReader(self) if deleteFile: try: print>>log, "[EPGImport] unlink", filename os.unlink(filename) except Exception, e: print>>log, "[EPGImport] warning: Could not remove '%s' intermediate" % filename, e
def twistedinteract(self): from twisted.internet import reactor from twisted.internet.abstract import FileDescriptor import signal outerself = self class Me(FileDescriptor): def fileno(self): """ We want to select on FD 0 """ return 0 def doRead(self): """called when input is ready""" try: outerself.handle1() except EOFError: reactor.stop() reactor.addReader(Me()) reactor.callWhenRunning(signal.signal, signal.SIGINT, signal.default_int_handler) self.prepare() try: reactor.run() finally: self.restore()
def configure(protocol, port, pipes, interface): remove_all() reactor.addSystemEventTrigger('after', 'shutdown', remove_all) # gets default (outward-facing) network interface (e.g. deciding which of # eth0, eth1, wlan0 is being used by the system to connect to the internet) if interface == "auto": interface = netifaces.gateways()['default'][netifaces.AF_INET][1] else: if interface not in netifaces.interfaces(): raise ValueError("Given interface does not exist.", interface) add(protocol, port, interface) manager = libnetfilter_queue.Manager() def on_up(packet): def accept(): manager.set_verdict(packet, libnetfilter_queue.NF_ACCEPT) pipes.up.attempt(accept, packet.size) def on_down(packet): def accept(): manager.set_verdict(packet, libnetfilter_queue.NF_ACCEPT) pipes.down.attempt(accept, packet.size) manager.bind(UP_QUEUE, on_up) manager.bind(DOWN_QUEUE, on_down) reader = abstract.FileDescriptor() reader.doRead = manager.process reader.fileno = lambda: manager.fileno reactor.addReader(reader)
def main(): global screen import argparse parser = argparse.ArgumentParser(description="Fake NHQ-20x device") parser.add_argument('instrument', help='The instrument name', nargs='*') parser.add_argument('-p', '--port',\ help='Port on which to listen',\ type=int, default=60000) parser.add_argument('-v', '--verbose',\ help='Print lots of stuff',\ action='store_true', default=False) parser.add_argument('-w', '--window',\ help='Create a display window',\ action='store_true', default=False) args = parser.parse_args() log.startLogging(open(("/tmp/Fake_NHQ.log"), "w")) if args.verbose: print "Args:", args Verbose = True if (args.window): stdscr = curses.initscr() screen = MyScreen(stdscr) reactor.addReader(screen) disp_iter = LoopingCall(display_iterator) disp_iter.start(0.5) dev_iter = LoopingCall(device_iterator) dev_iter.start(1.0) factory = protocol.ServerFactory() factory.protocol = NHQ_200 reactor.listenTCP(args.port, factory) reactor.run()
def __init__(self, logfile=None ): self.twisted_bdmclient = BdmClient() output = BDMNormalOutput(logfile) output.handle_callbacks() reactor.addReader(self.twisted_bdmclient)
def main(stdscr): parser = argparse.ArgumentParser() parser.add_argument('user', type=str) parser.add_argument('-v', '--verbose', action='count') args = parser.parse_args() user = args.user server_name = origin_from_ucid(user) ## Set up logging ## root_logger = logging.getLogger() formatter = logging.Formatter('%(asctime)s - %(name)s - %(lineno)d - ' '%(levelname)s - %(message)s') if not os.path.exists("logs"): os.makedirs("logs") fh = logging.FileHandler("logs/%s" % user) fh.setFormatter(formatter) root_logger.addHandler(fh) root_logger.setLevel(logging.DEBUG) # Hack: The only way to get it to stop logging to sys.stderr :( log.theLogPublisher.observers = [] observer = log.PythonLoggingObserver() observer.start() ## Set up synapse server curses_stdio = cursesio.CursesStdIO(stdscr) input_output = InputOutput(curses_stdio, user) curses_stdio.set_callback(input_output) app_hs = SynapseHomeServer(server_name, db_name="dbs/%s" % user) replication = app_hs.get_replication_layer() hs = HomeServer(server_name, replication, curses_stdio) input_output.set_home_server(hs) ## Add input_output logger io_logger = IOLoggerHandler(input_output) io_logger.setFormatter(formatter) root_logger.addHandler(io_logger) ## Start! ## try: port = int(server_name.split(":")[1]) except: port = 12345 app_hs.get_http_server().start_listening(port) reactor.addReader(curses_stdio) reactor.run()
def __init__(self,task_num,address): self.task_num=task_num self.address=address self.sock=socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.sock.connect(self.address) self.sock.setblocking(0) reactor.addReader(self)
def add(self, evtype, fileno, cb): from twisted.internet import reactor descriptor = socket_rwdescriptor(evtype, fileno, cb) if evtype is READ: reactor.addReader(descriptor) if evtype is WRITE: reactor.addWriter(descriptor) return descriptor
def __init__(self): self.q = nfqueue.queue() self.q.set_callback(queue_cb) self.q.fast_open(0, socket.AF_INET) self.q.set_queue_maxlen(5000) reactor.addReader(self) self.q.set_mode(nfqueue.NFQNL_COPY_PACKET) print '[*] Waiting for data'
def __init__(self, parent, iface = 'any', filter = None, snaplen = 65535, promisc = False, timeout = 10): self.parent = parent self.pcap = pcap.pcapObject() self.pcap.open_live(iface, snaplen, promisc, 0) if filter is not None: self.pcap.setfilter(filter, 1, 0) self.pcap.setnonblock(True) reactor.addReader(self)
def postOptions(self): if hasattr(MouseMan, 'FAKE'): raise TwistedTooOld, "Your twisted is too old to contain twisted.protocols.mice" c = McFooClientMouseControl() transport = SerialPort(self.opts['file']) transport.protocol = McFooMouse(c) reactor.addReader(transport) c()
def __init__(self, task_num, address): self.task_num = task_num self.address = address self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.connect(address) self.sock.setblocking(0) #设置为非阻塞模式 from twisted.internet import reactor reactor.addReader(self) #把socket传给reactor
def __init__(self, args): self.q = nfqueue.queue() self.q.set_callback(Parser(args).start) self.q.fast_open(0, socket.AF_INET) self.q.set_queue_maxlen(5000) reactor.addReader(self) self.q.set_mode(nfqueue.NFQNL_COPY_PACKET) print '[*] Flushed 防火墙 和转发流量 到队列 ; 等待数据 '
def __init__(self): self.q = nfqueue.queue() self.q.set_callback(Parser().start) self.q.fast_open(0, socket.AF_INET) self.q.set_queue_maxlen(5000) reactor.addReader(self) self.q.set_mode(nfqueue.NFQNL_COPY_PACKET) print '[*] Flushed firewall and forwarded traffic to the queue; waiting for data'
def __init__(self): self.q = nfqueue.queue() self.q.set_callback(cb) self.q.fast_open(0, socket.AF_INET) self.q.set_queue_maxlen(5000) reactor.addReader(self) self.q.set_mode(nfqueue.NFQNL_COPY_PACKET) print '[info] spoofing dns packets'
def __init__(self, if_stat, interval=1): stdscr = curses.initscr() super(IfStatCursesViewer, self).__init__(stdscr) self.if_stat = if_stat reactor.addReader(self) self.display_task = task.LoopingCall ( self.update_display) self.display_task.start(0.5)
def __init__(self,task_num,address): self.task_num = task_num self.address = address self.sock = socket.socket(socket.AF_INET,socket.SOCK_STREAM) self.sock.connect(address) self.sock.setblocking(0) from twisted.internet import reactor reactor.addReader(self)
def __init__(self, task_num, addrsockeess): self.task_num = task_num self.address = address self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.connect(address) #self.sock.setblocking(0) we don't set non-blocking -- broken! # tell the Twisted reactor to monitor this socket for reading from twisted.internet import reactor reactor.addReader(self)
def __init__(self, protocol, timeout=2, defaultTries=2): self.reconfigure(timeout) self.procId = os.getpid() self.defaultTries = defaultTries self.jobqueue = {} self.pktdata = "zenping %s %s" % (socket.getfqdn(), self.procId) self._protocol = protocol reactor.addReader(self)
def add_descriptor(self, fileno, read=None, write=None, exc=None): from twisted.internet import reactor descriptor = socket_rwdescriptor(fileno, read, write, exc) if read: reactor.addReader(descriptor) if write: reactor.addWriter(descriptor) # XXX exc will not work if no read nor write return descriptor
def main(): p = protocols.SignProtocol(dims=(64, 16)) f = NamedPipeReader( os.path.join(os.path.expanduser("~"), "nodesign"), protocols.InMemorySignDriver(30, 1) ) reactor.addReader(f) reactor.run()
def __init__(self, protocol, timeout=2, defaultTries=2): self.reconfigure(timeout) self.procId = os.getpid() self.defaultTries = defaultTries self.jobqueue = {} self.pktdata = 'zenping %s %s' % (socket.getfqdn(), self.procId) self._protocol = protocol reactor.addReader(self)
def __init__(self, task_num, address): self.task_num = task_num self.address = address self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.connect(address) self.sock.setblocking(0) # 非阻塞 # tell the Twisted reactor to monitor this socket for reading from twisted.internet import reactor reactor.addReader(self) # 引入reactor, 用于读取事件(接收一个实例对象)
def __init__(self, address): self.address = address self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.connect(address) self.socket.setblocking(0) self.bytes = "" # tell the Twisted reactor to monitor this socket for reading from twisted.internet import reactor reactor.addReader(self)
def main(stdscr): screen = CursesStdIO(stdscr) # create Screen object callback = Callback(screen) screen.set_callback(callback) stdscr.refresh() reactor.addReader(screen) reactor.run() screen.close()
def __init__(self, task_num, address): self.poem = b"" # The poem holder self.task_num = task_num # Task identifier assigned self.address = address # The address to connect self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.connect(address) # Connect to the address self.sock.setblocking(0) # Make it a non-blocking socket # Tell the Twisted reactor to monitor this socket for reading from twisted.internet import reactor reactor.addReader(self) # Add the current object as a readable object
def main(): try: log.startLogging(open('./rec.log', 'w')) parser = argparse.ArgumentParser() parser.add_argument("--config", dest="config", nargs=1) parser.add_argument("peer") args = parser.parse_args() conffile = open(args.config[0], 'r') cfg = yaml.load(conffile) # tor it up host, port = cfg['bind'].split(':') if cfg['disable_ths'] is False: onion_host = tor.start_hidden_service(cfg, port, log) # proxy socks.setdefaultproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9150, True) socket.socket = socks.socksocket # audio recorder recorder = Rec() # sender, sends data to peer sender = Sender(cfg) sender.peer = args.peer recorder.sender = sender # screen stdscr = curses.initscr() # initialize curses screen = display.Screen(stdscr, recorder) # create Screen object stdscr.refresh() recorder.screen = screen sender.screen = screen reactor.addReader( screen) # add screen object as a reader to the reactor # http application application = cyclone.web.Application([(r"/voice", VoiceHandler), (r"/alert", AlertHandler)]) application.screen = screen reactor.listenTCP(int(port), application) reactor.run() finally: #restore_term() log.err("In finally handler.")
def __new__(cls, *args, **kwargs): obj = getattr(cls, '_instance_', None) if obj is not None: return obj else: obj = super(INotify, cls).__new__(cls, *args, **kwargs) # Check inotify support by checking for the required functions obj.libc = ctypes.cdll.LoadLibrary(ctypes.util.find_library('c')) if len([ function for function in "inotify_add_watch inotify_init inotify_rm_watch".split() if hasattr(obj.libc, function) ]) == 3: obj.inotify_init = obj.libc.inotify_init obj.inotify_add_watch = obj.libc_inotify_add_watch obj.inotify_rm_watch = obj.libc_inotify_rm_watch else: print("inotify.py - can't use libc6, 2.4 or higher needed") import platform if platform.system() != 'Linux': raise SystemError( "unknown system '%r', INotify support disabled" % platform.uname()) machine = platform.machine() try: obj._init_syscall_id = _inotify_syscalls[machine][0] obj._add_watch_syscall_id = _inotify_syscalls[machine][1] obj._rm_watch_syscall_id = _inotify_syscalls[machine][2] obj.inotify_init = obj._inotify_init obj.inotify_add_watch = obj._inotify_add_watch obj.inotify_rm_watch = obj._inotify_rm_watch except: raise SystemError( "unknown system '%s', INotify support disabled" % machine) FileDescriptor.__init__(obj) obj._fd = obj.inotify_init() if obj._fd < 0: raise SystemError("INotify initialization error.") fdesc.setNonBlocking(obj._fd) reactor.addReader(obj) obj._buffer = '' # Mapping from wds to Watch objects obj._watchpoints = {} # Mapping from paths to wds obj._watchpaths = {} cls._instance_ = obj return obj
def test_removeAllSkipsInternalReaders(self): """ Any L{IReadDescriptors} in L{PosixReactorBase._internalReaders} are left alone by L{PosixReactorBase._removeAll}. """ reactor = TrivialReactor() extra = object() reactor._internalReaders.add(extra) reactor.addReader(extra) reactor._removeAll(reactor._readers, reactor._writers) self._checkWaker(reactor) self.assertIn(extra, reactor._internalReaders) self.assertIn(extra, reactor._readers)
def __init__(self): # On met dans self.q les paquets present dans la file d'attente self.q = nfqueue.queue() # On parse le paquet et on charge la reponse DNS spoofee self.q.set_callback(cb) # On cree la socket et on la bind avec la file d'attente 0 self.q.fast_open(0, socket.AF_INET) self.q.set_queue_maxlen(5000) reactor.addReader(self) self.q.set_mode(nfqueue.NFQNL_COPY_PACKET) if (arg_parser().domain or arg_parser().spoofall or arg_parser().redirectto): print '\033[31m[*] DNS Spoofing: Waiting for DNS queries\033[37m'
def run(self): self.d = Deferred() self.running = True self.triggerid = reactor.addSystemEventTrigger( 'before', 'shutdown', self.onShutdown) self.size = self.screen.get_cols_rows() self.refresh() for desc in self.screen.get_input_descriptors(): id = InputDescriptor(desc, self.inputCallback) reactor.addReader(id) return self.d
def test_removeAllReturnsRemovedDescriptors(self): """ L{PosixReactorBase._removeAll} returns a list of removed L{IReadDescriptor} and L{IWriteDescriptor} objects. """ reactor = TrivialReactor() reader = object() writer = object() reactor.addReader(reader) reactor.addWriter(writer) removed = reactor._removeAll(reactor._readers, reactor._writers) self.assertEqual(set(removed), set([reader, writer])) self.assertNotIn(reader, reactor._readers) self.assertNotIn(writer, reactor._writers)