← Back to branch summary

~malept/ubuntu/lucid/python2.6/dev-dependency-fix

« back to all changes in this revision

Viewing changes to Demo/pdist/server.py

  • Committer: Bazaar Package Importer
  • Author(s): Matthias Klose
  • Date: 2009-02-13 12:51:00 UTC
  • Revision ID: james.westby@ubuntu.com-20090213125100-uufgcb9yeqzujpqw
Tags: upstream-2.6.1
Import upstream version 2.6.1

Show diffs side-by-side

added added

removed removed

Lines of Context:
Demo/pdist/server.py
 
1
"""RPC Server module."""
 
2
 
 
3
import sys
 
4
import socket
 
5
import pickle
 
6
from fnmatch import fnmatch
 
7
from repr import repr
 
8
 
 
9
 
 
10
# Default verbosity (0 = silent, 1 = print connections, 2 = print requests too)
 
11
VERBOSE = 1
 
12
 
 
13
 
 
14
class Server:
 
15
 
 
16
    """RPC Server class.  Derive a class to implement a particular service."""
 
17
 
 
18
    def __init__(self, address, verbose = VERBOSE):
 
19
        if type(address) == type(0):
 
20
            address = ('', address)
 
21
        self._address = address
 
22
        self._verbose = verbose
 
23
        self._socket = None
 
24
        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
 
25
        self._socket.bind(address)
 
26
        self._socket.listen(1)
 
27
        self._listening = 1
 
28
 
 
29
    def _setverbose(self, verbose):
 
30
        self._verbose = verbose
 
31
 
 
32
    def __del__(self):
 
33
        self._close()
 
34
 
 
35
    def _close(self):
 
36
        self._listening = 0
 
37
        if self._socket:
 
38
            self._socket.close()
 
39
        self._socket = None
 
40
 
 
41
    def _serverloop(self):
 
42
        while self._listening:
 
43
            self._serve()
 
44
 
 
45
    def _serve(self):
 
46
        if self._verbose: print "Wait for connection ..."
 
47
        conn, address = self._socket.accept()
 
48
        if self._verbose: print "Accepted connection from %s" % repr(address)
 
49
        if not self._verify(conn, address):
 
50
            print "*** Connection from %s refused" % repr(address)
 
51
            conn.close()
 
52
            return
 
53
        rf = conn.makefile('r')
 
54
        wf = conn.makefile('w')
 
55
        ok = 1
 
56
        while ok:
 
57
            wf.flush()
 
58
            if self._verbose > 1: print "Wait for next request ..."
 
59
            ok = self._dorequest(rf, wf)
 
60
 
 
61
    _valid = ['192.16.201.*', '192.16.197.*', '132.151.1.*', '129.6.64.*']
 
62
 
 
63
    def _verify(self, conn, address):
 
64
        host, port = address
 
65
        for pat in self._valid:
 
66
            if fnmatch(host, pat): return 1
 
67
        return 0
 
68
 
 
69
    def _dorequest(self, rf, wf):
 
70
        rp = pickle.Unpickler(rf)
 
71
        try:
 
72
            request = rp.load()
 
73
        except EOFError:
 
74
            return 0
 
75
        if self._verbose > 1: print "Got request: %s" % repr(request)
 
76
        try:
 
77
            methodname, args, id = request
 
78
            if '.' in methodname:
 
79
                reply = (None, self._special(methodname, args), id)
 
80
            elif methodname[0] == '_':
 
81
                raise NameError, "illegal method name %s" % repr(methodname)
 
82
            else:
 
83
                method = getattr(self, methodname)
 
84
                reply = (None, apply(method, args), id)
 
85
        except:
 
86
            reply = (sys.exc_type, sys.exc_value, id)
 
87
        if id < 0 and reply[:2] == (None, None):
 
88
            if self._verbose > 1: print "Suppress reply"
 
89
            return 1
 
90
        if self._verbose > 1: print "Send reply: %s" % repr(reply)
 
91
        wp = pickle.Pickler(wf)
 
92
        wp.dump(reply)
 
93
        return 1
 
94
 
 
95
    def _special(self, methodname, args):
 
96
        if methodname == '.methods':
 
97
            if not hasattr(self, '_methods'):
 
98
                self._methods = tuple(self._listmethods())
 
99
            return self._methods
 
100
        raise NameError, "unrecognized special method name %s" % repr(methodname)
 
101
 
 
102
    def _listmethods(self, cl=None):
 
103
        if not cl: cl = self.__class__
 
104
        names = cl.__dict__.keys()
 
105
        names = filter(lambda x: x[0] != '_', names)
 
106
        names.sort()
 
107
        for base in cl.__bases__:
 
108
            basenames = self._listmethods(base)
 
109
            basenames = filter(lambda x, names=names: x not in names, basenames)
 
110
            names[len(names):] = basenames
 
111
        return names
 
112
 
 
113
 
 
114
from security import Security
 
115
 
 
116
 
 
117
class SecureServer(Server, Security):
 
118
 
 
119
    def __init__(self, *args):
 
120
        apply(Server.__init__, (self,) + args)
 
121
        Security.__init__(self)
 
122
 
 
123
    def _verify(self, conn, address):
 
124
        import string
 
125
        challenge = self._generate_challenge()
 
126
        conn.send("%d\n" % challenge)
 
127
        response = ""
 
128
        while "\n" not in response and len(response) < 100:
 
129
            data = conn.recv(100)
 
130
            if not data:
 
131
                break
 
132
            response = response + data
 
133
        try:
 
134
            response = string.atol(string.strip(response))
 
135
        except string.atol_error:
 
136
            if self._verbose > 0:
 
137
                print "Invalid response syntax", repr(response)
 
138
            return 0
 
139
        if not self._compare_challenge_response(challenge, response):
 
140
            if self._verbose > 0:
 
141
                print "Invalid response value", repr(response)
 
142
            return 0
 
143
        if self._verbose > 1:
 
144
            print "Response matches challenge.  Go ahead!"
 
145
        return 1