File Manager

Hackfut Security File Manager

Current Path: /usr/lib/python2.6/site-packages/supervisor/medusa

usr / lib / python2.6 / site-packages / supervisor / medusa /

📁 ..
📄 __init__.py(128 B)
📄 __init__.pyc(277 B)
📄 __init__.pyo(277 B)
📄 auth_handler.py(4.63 KB)
📄 auth_handler.pyc(4.41 KB)
📄 auth_handler.pyo(4.41 KB)
📄 chat_server.py(4.43 KB)
📄 chat_server.pyc(6.28 KB)
📄 chat_server.pyo(6.28 KB)
📄 counter.py(1.41 KB)
📄 counter.pyc(1.99 KB)
📄 counter.pyo(1.99 KB)
📄 default_handler.py(6.18 KB)
📄 default_handler.pyc(4.92 KB)
📄 default_handler.pyo(4.92 KB)
📄 event_loop.py(2.91 KB)
📄 event_loop.pyc(3.43 KB)
📄 event_loop.pyo(3.43 KB)
📄 filesys.py(10.94 KB)
📄 filesys.pyc(13.28 KB)
📄 filesys.pyo(13.28 KB)
📄 ftp_server.py(39.6 KB)
📄 ftp_server.pyc(33.91 KB)
📄 ftp_server.pyo(33.91 KB)
📄 http_date.py(3.33 KB)
📄 http_date.pyc(3.39 KB)
📄 http_date.pyo(3.39 KB)
📄 http_server.py(24.63 KB)
📄 http_server.pyc(20.96 KB)
📄 http_server.pyo(20.96 KB)
📄 logger.py(7.81 KB)
📄 logger.pyc(10.73 KB)
📄 logger.pyo(10.73 KB)
📄 m_syslog.py(7.18 KB)
📄 m_syslog.pyc(3.91 KB)
📄 m_syslog.pyo(3.91 KB)
📄 medusa_gif.py(2.71 KB)
📄 medusa_gif.pyc(1.13 KB)
📄 medusa_gif.pyo(1.13 KB)
📄 monitor.py(10.79 KB)
📄 monitor.pyc(12 KB)
📄 monitor.pyo(12 KB)
📄 monitor_client.py(3.2 KB)
📄 monitor_client.pyc(5.26 KB)
📄 monitor_client.pyo(5.26 KB)
📄 monitor_client_win32.py(1.3 KB)
📄 monitor_client_win32.pyc(2.04 KB)
📄 monitor_client_win32.pyo(2.04 KB)
📄 producers.py(9.22 KB)
📄 producers.pyc(11.36 KB)
📄 producers.pyo(11.36 KB)
📄 put_handler.py(3.25 KB)
📄 put_handler.pyc(3.43 KB)
📄 put_handler.pyo(3.43 KB)
📄 redirecting_handler.py(1.37 KB)
📄 redirecting_handler.pyc(2.11 KB)
📄 redirecting_handler.pyo(2.11 KB)
📄 resolver.py(15.19 KB)
📄 resolver.pyc(12.11 KB)
📄 resolver.pyo(12.11 KB)
📄 rpc_client.py(9.45 KB)
📄 rpc_client.pyc(10.1 KB)
📄 rpc_client.pyo(10.1 KB)
📄 rpc_server.py(9.72 KB)
📄 rpc_server.pyc(9.31 KB)
📄 rpc_server.pyo(9.31 KB)
📄 script_handler.py(6.4 KB)
📄 script_handler.pyc(6.5 KB)
📄 script_handler.pyo(6.5 KB)
📄 setup.py(496 B)
📄 setup.pyc(729 B)
📄 setup.pyo(729 B)
📄 status_handler.py(9.13 KB)
📄 status_handler.pyc(9.45 KB)
📄 status_handler.pyo(9.45 KB)
📄 unix_user_handler.py(2.26 KB)
📄 unix_user_handler.pyc(2.31 KB)
📄 unix_user_handler.pyo(2.31 KB)
📄 virtual_handler.py(1.68 KB)
📄 virtual_handler.pyc(3.09 KB)
📄 virtual_handler.pyo(3.09 KB)
📄 xmlrpc_handler.py(2.88 KB)
📄 xmlrpc_handler.pyc(3.7 KB)
📄 xmlrpc_handler.pyo(3.7 KB)

Editing: event_loop.py

# -*- Mode: Python -*-

# This is an alternative event loop that supports 'schedulable events'.
# You can specify an event callback to take place after <n> seconds.

# Important usage note: The granularity of the time-check is limited
# by the <timeout> argument to 'go()'; if there is little or no
# activity and you specify a 30-second timeout interval, then the
# schedule of events may only be checked at those 30-second intervals.
# In other words, if you need 1-second resolution, you will have to
# poll at 1-second intervals.  This facility is more useful for longer
# timeouts ("if the channel doesn't close in 5 minutes, then forcibly
# close it" would be a typical usage).

import asyncore
import bisect
import time

socket_map = asyncore.socket_map

class event_loop:

def __init__ (self):
        self.events = []
        self.num_channels = 0
        self.max_channels = 0

def go (self, timeout=30.0, granularity=15):
        global socket_map
        last_event_check = 0
        while socket_map:
            now = int(time.time())
            if (now - last_event_check) >= granularity:
                last_event_check = now
                fired = []
                # yuck. i want my lisp.
                i = j = 0
                while i < len(self.events):
                    when, what = self.events[i]
                    if now >= when:
                        fired.append (what)
                        j = i + 1
                    else:
                        break
                    i = i + 1
                if fired:
                    self.events = self.events[j:]
                    for what in fired:
                        what (self, now)
            # sample the number of channels
            n = len(asyncore.socket_map)
            self.num_channels = n
            if n > self.max_channels:
                self.max_channels = n
            asyncore.poll (timeout)

def schedule (self, delta, callback):
        now = int (time.time())
        bisect.insort (self.events, (now + delta, callback))

def __len__ (self):
        return len(self.events)

class test (asyncore.dispatcher):

def __init__ (self):
        asyncore.dispatcher.__init__ (self)

def handle_connect (self):
        print 'Connected!'

def writable (self):
        return not self.connected

def connect_timeout_callback (self, event_loop, when):
        if not self.connected:
            print 'Timeout on connect'
            self.close()

def periodic_thing_callback (self, event_loop, when):
        print 'A Periodic Event has Occurred!'
        # re-schedule it.
        event_loop.schedule (self, 15, self.periodic_thing_callback)

if __name__ == '__main__':
    import socket
    el = event_loop()
    t = test ()
    t.create_socket (socket.AF_INET, socket.SOCK_STREAM)
    el.schedule (10, t.connect_timeout_callback)
    el.schedule (15, t.periodic_thing_callback)
    t.connect (('squirl', 80))
    el.go(1.0)

Hackfut Security File Manager

Editing: event_loop.py

Upload File

Create Folder