1 files changed, 145 insertions, 0 deletions
diff --git a/AppPkg/Applications/Python/Python-2.7.2/Demo/pdist/server.py b/AppPkg/Applications/Python/Python-2.7.2/Demo/pdist/server.py
new file mode 100644
index 0000000000..c7a4491eb3
--- /dev/null
+++ b/AppPkg/Applications/Python/Python-2.7.2/Demo/pdist/server.py
@@ -0,0 +1,145 @@
+"""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