sfa/util/server.py

   1 ##
   2 # This module implements a general-purpose server layer for sfa.
   3 # The same basic server should be usable on the registry, component, or
   4 # other interfaces.
   5 #
   6 # TODO: investigate ways to combine this with existing PLC server?
   7 ##
   8
   9 ### $Id$
  10 ### $URL$
  11
  12 import sys
  13 import traceback
  14 import threading
  15 import socket, os
  16 import SocketServer
  17 import BaseHTTPServer
  18 import SimpleHTTPServer
  19 import SimpleXMLRPCServer
  20 from OpenSSL import SSL
  21 from Queue import Queue
  22
  23 #import sfa.util.sfalogging
  24 from sfa.trust.certificate import Keypair, Certificate
  25 from sfa.trust.credential import *
  26 from sfa.util.faults import *
  27 from sfa.plc.api import SfaAPI
  28 from sfa.util.cache import Cache
  29 #from sfa.util.debug import log
  30 ##
  31 # Verification callback for pyOpenSSL. We do our own checking of keys because
  32 # we have our own authentication spec. Thus we disable several of the normal
  33 # prohibitions that OpenSSL places on certificates
  34
  35 def verify_callback(conn, x509, err, depth, preverify):
  36     # if the cert has been preverified, then it is ok
  37     if preverify:
  38        #print "  preverified"
  39        return 1
  40
  41
  42     # the certificate verification done by openssl checks a number of things
  43     # that we aren't interested in, so we look out for those error messages
  44     # and ignore them
  45
  46     # XXX SMBAKER: I don't know what this error is, but it's being returned
  47     # by newer pl nodes.
  48     if err == 9:
  49        #print "  X509_V_ERR_CERT_NOT_YET_VALID"
  50        return 1
  51
  52     # allow self-signed certificates
  53     if err == 18:
  54        #print "  X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT"
  55        return 1
  56
  57     # allow certs that don't have an issuer
  58     if err == 20:
  59        #print "  X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT_LOCALLY"
  60        return 1
  61
  62     # allow chained certs with self-signed roots
  63     if err == 19:
  64         return 1
  65
  66     # allow certs that are untrusted
  67     if err == 21:
  68        #print "  X509_V_ERR_UNABLE_TO_VERIFY_LEAF_SIGNATURE"
  69        return 1
  70
  71     # allow certs that are untrusted
  72     if err == 27:
  73        #print "  X509_V_ERR_CERT_UNTRUSTED"
  74        return 1
  75
  76     print "  error", err, "in verify_callback"
  77
  78     return 0
  79
  80 ##
  81 # taken from the web (XXX find reference). Implents HTTPS xmlrpc request handler
  82 class SecureXMLRpcRequestHandler(SimpleXMLRPCServer.SimpleXMLRPCRequestHandler):
  83     """Secure XML-RPC request handler class.
  84
  85     It it very similar to SimpleXMLRPCRequestHandler but it uses HTTPS for transporting XML data.
  86     """
  87     def setup(self):
  88         self.connection = self.request
  89         self.rfile = socket._fileobject(self.request, "rb", self.rbufsize)
  90         self.wfile = socket._fileobject(self.request, "wb", self.wbufsize)
  91
  92     def do_POST(self):
  93         """Handles the HTTPS POST request.
  94
  95         It was copied out from SimpleXMLRPCServer.py and modified to shutdown
  96         the socket cleanly.
  97         """
  98         try:
  99             peer_cert = Certificate()
 100             peer_cert.load_from_pyopenssl_x509(self.connection.get_peer_certificate())
 101             self.api = SfaAPI(peer_cert = peer_cert,
 102                               interface = self.server.interface,
 103                               key_file = self.server.key_file,
 104                               cert_file = self.server.cert_file,
 105                               cache = self.cache)
 106             # get arguments
 107             request = self.rfile.read(int(self.headers["content-length"]))
 108             remote_addr = (remote_ip, remote_port) = self.connection.getpeername()
 109             self.api.remote_addr = remote_addr
 110             response = self.api.handle(remote_addr, request, self.server.method_map)
 111         except Exception, fault:
 112             # This should only happen if the module is buggy
 113             # internal error, report as HTTP server error
 114             traceback.print_exc()
 115             response = self.api.prepare_response(fault)
 116             #self.send_response(500)
 117             #self.end_headers()
 118
 119         # got a valid response
 120         self.send_response(200)
 121         self.send_header("Content-type", "text/xml")
 122         self.send_header("Content-length", str(len(response)))
 123         self.end_headers()
 124         self.wfile.write(response)
 125
 126         # shut down the connection
 127         self.wfile.flush()
 128         self.connection.shutdown() # Modified here!
 129
 130 ##
 131 # Taken from the web (XXX find reference). Implements an HTTPS xmlrpc server
 132 class SecureXMLRPCServer(BaseHTTPServer.HTTPServer,SimpleXMLRPCServer.SimpleXMLRPCDispatcher):
 133     def __init__(self, server_address, HandlerClass, key_file, cert_file, logRequests=True):
 134         """Secure XML-RPC server.
 135
 136         It it very similar to SimpleXMLRPCServer but it uses HTTPS for transporting XML data.
 137         """
 138         self.logRequests = logRequests
 139         self.interface = None
 140         self.key_file = key_file
 141         self.cert_file = cert_file
 142         self.method_map = {}
 143         # add cache to the request handler
 144         HandlerClass.cache = Cache()
 145         #for compatibility with python 2.4 (centos53)
 146         if sys.version_info < (2, 5):
 147             SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self)
 148         else:
 149            SimpleXMLRPCServer.SimpleXMLRPCDispatcher.__init__(self, True, None)
 150         SocketServer.BaseServer.__init__(self, server_address, HandlerClass)
 151         ctx = SSL.Context(SSL.SSLv23_METHOD)
 152         ctx.use_privatekey_file(key_file)
 153         ctx.use_certificate_file(cert_file)
 154         # If you wanted to verify certs against known CAs.. this is how you would do it
 155         #ctx.load_verify_locations('/etc/sfa/trusted_roots/plc.gpo.gid')
 156         ctx.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT, verify_callback)
 157         ctx.set_verify_depth(5)
 158         ctx.set_app_data(self)
 159         self.socket = SSL.Connection(ctx, socket.socket(self.address_family,
 160                                                         self.socket_type))
 161         self.server_bind()
 162         self.server_activate()
 163
 164     # _dispatch
 165     #
 166     # Convert an exception on the server to a full stack trace and send it to
 167     # the client.
 168
 169     def _dispatch(self, method, params):
 170         try:
 171             return SimpleXMLRPCServer.SimpleXMLRPCDispatcher._dispatch(self, method, params)
 172         except:
 173             # can't use format_exc() as it is not available in jython yet
 174             # (evein in trunk).
 175             type, value, tb = sys.exc_info()
 176             raise xmlrpclib.Fault(1,''.join(traceback.format_exception(type, value, tb)))
 177
 178 ## From Active State code: http://code.activestate.com/recipes/574454/
 179 # This is intended as a drop-in replacement for the ThreadingMixIn class in
 180 # module SocketServer of the standard lib. Instead of spawning a new thread
 181 # for each request, requests are processed by of pool of reusable threads.
 182 class ThreadPoolMixIn(SocketServer.ThreadingMixIn):
 183     """
 184     use a thread pool instead of a new thread on every request
 185     """
 186     # XX TODO: Make this configurable
 187     # config = Config()
 188     # numThreads = config.SFA_SERVER_NUM_THREADS
 189     numThreads = 25
 190     allow_reuse_address = True  # seems to fix socket.error on server restart
 191
 192     def serve_forever(self):
 193         """
 194         Handle one request at a time until doomsday.
 195         """
 196         # set up the threadpool
 197         self.requests = Queue()
 198
 199         for x in range(self.numThreads):
 200             t = threading.Thread(target = self.process_request_thread)
 201             t.setDaemon(1)
 202             t.start()
 203
 204         # server main loop
 205         while True:
 206             self.handle_request()
 207
 208         self.server_close()
 209
 210
 211     def process_request_thread(self):
 212         """
 213         obtain request from queue instead of directly from server socket
 214         """
 215         while True:
 216             SocketServer.ThreadingMixIn.process_request_thread(self, *self.requests.get())
 217
 218
 219     def handle_request(self):
 220         """
 221         simply collect requests and put them on the queue for the workers.
 222         """
 223         try:
 224             request, client_address = self.get_request()
 225         except socket.error:
 226             return
 227         if self.verify_request(request, client_address):
 228             self.requests.put((request, client_address))
 229
 230 class ThreadedServer(ThreadPoolMixIn, SecureXMLRPCServer):
 231     pass
 232 ##
 233 # Implements an HTTPS XML-RPC server. Generally it is expected that SFA
 234 # functions will take a credential string, which is passed to
 235 # decode_authentication. Decode_authentication() will verify the validity of
 236 # the credential, and verify that the user is using the key that matches the
 237 # GID supplied in the credential.
 238
 239 class SfaServer(threading.Thread):
 240
 241     ##
 242     # Create a new SfaServer object.
 243     #
 244     # @param ip the ip address to listen on
 245     # @param port the port to listen on
 246     # @param key_file private key filename of registry
 247     # @param cert_file certificate filename containing public key
 248     #   (could be a GID file)
 249
 250     def __init__(self, ip, port, key_file, cert_file):
 251         threading.Thread.__init__(self)
 252         self.key = Keypair(filename = key_file)
 253         self.cert = Certificate(filename = cert_file)
 254         #self.server = SecureXMLRPCServer((ip, port), SecureXMLRpcRequestHandler, key_file, cert_file)
 255         self.server = ThreadedServer((ip, port), SecureXMLRpcRequestHandler, key_file, cert_file)
 256         self.trusted_cert_list = None
 257         self.register_functions()
 258
 259
 260     ##
 261     # Register functions that will be served by the XMLRPC server. This
 262     # function should be overridden by each descendant class.
 263
 264     def register_functions(self):
 265         self.server.register_function(self.noop)
 266
 267     ##
 268     # Sample no-op server function. The no-op function decodes the credential
 269     # that was passed to it.
 270
 271     def noop(self, cred, anything):
 272         self.decode_authentication(cred)
 273         return anything
 274
 275     ##
 276     # Execute the server, serving requests forever.
 277
 278     def run(self):
 279         self.server.serve_forever()
 280
 281