"""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