146 lines
3.7 KiB
Python
Executable File
146 lines
3.7 KiB
Python
Executable File
"""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", `response`
|
|
return 0
|
|
if not self._compare_challenge_response(challenge, response):
|
|
if self._verbose > 0:
|
|
print "Invalid response value", `response`
|
|
return 0
|
|
if self._verbose > 1:
|
|
print "Response matches challenge. Go ahead!"
|
|
return 1
|