File Manager

X7ROOT File Manager

Current Path: /lib64/python2.7/Demo/pdist

lib64 / python2.7 / Demo / pdist /

ðŸ“ ..
ðŸ“„ FSProxy.py(7.64 KB)
ðŸ“„ FSProxy.pyc(12.5 KB)
ðŸ“„ FSProxy.pyo(12.5 KB)
ðŸ“„ RCSProxy.py(4.61 KB)
ðŸ“„ RCSProxy.pyc(7.57 KB)
ðŸ“„ RCSProxy.pyo(7.57 KB)
ðŸ“„ README(4.16 KB)
ðŸ“„ client.py(4.6 KB)
ðŸ“„ client.pyc(6.57 KB)
ðŸ“„ client.pyo(6.57 KB)
ðŸ“„ cmdfw.py(4.53 KB)
ðŸ“„ cmdfw.pyc(5.12 KB)
ðŸ“„ cmdfw.pyo(5.12 KB)
ðŸ“„ cmptree.py(5.64 KB)
ðŸ“„ cmptree.pyc(5.98 KB)
ðŸ“„ cmptree.pyo(5.98 KB)
ðŸ“„ cvslib.py(9.94 KB)
ðŸ“„ cvslib.pyc(12.83 KB)
ðŸ“„ cvslib.pyo(12.83 KB)
ðŸ“„ cvslock.py(6.61 KB)
ðŸ“„ cvslock.pyc(8.36 KB)
ðŸ“„ cvslock.pyo(8.36 KB)
ðŸ“„ mac.py(352 B)
ðŸ“„ mac.pyc(598 B)
ðŸ“„ mac.pyo(598 B)
ðŸ“„ makechangelog.py(2.92 KB)
ðŸ“„ makechangelog.pyc(3.05 KB)
ðŸ“„ makechangelog.pyo(3.05 KB)
ðŸ“„ rcsbump(745 B)
ðŸ“„ rcsclient.py(1.76 KB)
ðŸ“„ rcsclient.pyc(2.05 KB)
ðŸ“„ rcsclient.pyo(2.05 KB)
ðŸ“„ rcslib.py(10.08 KB)
ðŸ“„ rcslib.pyc(11.28 KB)
ðŸ“„ rcslib.pyo(11.28 KB)
ðŸ“„ rcvs(117 B)
ðŸ“„ rcvs.py(13.32 KB)
ðŸ“„ rcvs.pyc(14.08 KB)
ðŸ“„ rcvs.pyo(14.08 KB)
ðŸ“„ rrcs(117 B)
ðŸ“„ rrcs.py(3.9 KB)
ðŸ“„ rrcs.pyc(5.5 KB)
ðŸ“„ rrcs.pyo(5.5 KB)
ðŸ“„ security.py(1.07 KB)
ðŸ“„ security.pyc(1.64 KB)
ðŸ“„ security.pyo(1.64 KB)
ðŸ“„ server.py(4.47 KB)
ðŸ“„ server.pyc(5.83 KB)
ðŸ“„ server.pyo(5.83 KB)
ðŸ“„ sumtree.py(518 B)
ðŸ“„ sumtree.pyc(903 B)
ðŸ“„ sumtree.pyo(903 B)

Editing: server.py

"""RPC Server module."""

import sys
import socket
import pickle
from fnmatch import fnmatch
from repr import repr

# Default verbosity (0 = silent, 1 = print connections, 2 = print requests too)
VERBOSE = 1

class Server:

"""RPC Server class.  Derive a class to implement a particular service."""

def __init__(self, address, verbose = VERBOSE):
        if type(address) == type(0):
            address = ('', address)
        self._address = address
        self._verbose = verbose
        self._socket = None
        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._socket.bind(address)
        self._socket.listen(1)
        self._listening = 1

def _setverbose(self, verbose):
        self._verbose = verbose

def __del__(self):
        self._close()

def _close(self):
        self._listening = 0
        if self._socket:
            self._socket.close()
        self._socket = None

def _serverloop(self):
        while self._listening:
            self._serve()

def _serve(self):
        if self._verbose: print "Wait for connection ..."
        conn, address = self._socket.accept()
        if self._verbose: print "Accepted connection from %s" % repr(address)
        if not self._verify(conn, address):
            print "*** Connection from %s refused" % repr(address)
            conn.close()
            return
        rf = conn.makefile('r')
        wf = conn.makefile('w')
        ok = 1
        while ok:
            wf.flush()
            if self._verbose > 1: print "Wait for next request ..."
            ok = self._dorequest(rf, wf)

_valid = ['192.16.201.*', '192.16.197.*', '132.151.1.*', '129.6.64.*']

def _verify(self, conn, address):
        host, port = address
        for pat in self._valid:
            if fnmatch(host, pat): return 1
        return 0

def _dorequest(self, rf, wf):
        rp = pickle.Unpickler(rf)
        try:
            request = rp.load()
        except EOFError:
            return 0
        if self._verbose > 1: print "Got request: %s" % repr(request)
        try:
            methodname, args, id = request
            if '.' in methodname:
                reply = (None, self._special(methodname, args), id)
            elif methodname[0] == '_':
                raise NameError, "illegal method name %s" % repr(methodname)
            else:
                method = getattr(self, methodname)
                reply = (None, apply(method, args), id)
        except:
            reply = (sys.exc_type, sys.exc_value, id)
        if id < 0 and reply[:2] == (None, None):
            if self._verbose > 1: print "Suppress reply"
            return 1
        if self._verbose > 1: print "Send reply: %s" % repr(reply)
        wp = pickle.Pickler(wf)
        wp.dump(reply)
        return 1

def _special(self, methodname, args):
        if methodname == '.methods':
            if not hasattr(self, '_methods'):
                self._methods = tuple(self._listmethods())
            return self._methods
        raise NameError, "unrecognized special method name %s" % repr(methodname)

def _listmethods(self, cl=None):
        if not cl: cl = self.__class__
        names = cl.__dict__.keys()
        names = filter(lambda x: x[0] != '_', names)
        names.sort()
        for base in cl.__bases__:
            basenames = self._listmethods(base)
            basenames = filter(lambda x, names=names: x not in names, basenames)
            names[len(names):] = basenames
        return names

from security import Security

class SecureServer(Server, Security):

def __init__(self, *args):
        apply(Server.__init__, (self,) + args)
        Security.__init__(self)

def _verify(self, conn, address):
        import string
        challenge = self._generate_challenge()
        conn.send("%d\n" % challenge)
        response = ""
        while "\n" not in response and len(response) < 100:
            data = conn.recv(100)
            if not data:
                break
            response = response + data
        try:
            response = string.atol(string.strip(response))
        except string.atol_error:
            if self._verbose > 0:
                print "Invalid response syntax", repr(response)
            return 0
        if not self._compare_challenge_response(challenge, response):
            if self._verbose > 0:
                print "Invalid response value", repr(response)
            return 0
        if self._verbose > 1:
            print "Response matches challenge.  Go ahead!"
        return 1

X7ROOT File Manager

Editing: server.py

Upload File

Create Folder