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 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 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 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 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 __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 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 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 __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 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 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, 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 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):
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): 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, 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 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 __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, 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)
