def __init__(self, server_address, RequestHandlerClass, maxthreads=100, pemfile=None, rest_handlers=None, userpass=None): try: if pemfile: #HTTPS server BaseServer.__init__(self, server_address, RequestHandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(pemfile) ctx.use_certificate_file(pemfile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() self.httpstyle = "HTTPS" else: #HTTP server BaseHTTPServer.__init__(self, server_address, RequestHandlerClass) self.httpstyle = "HTTP" except socket.error as e: if e.errno == 98: logging.log(logging.ERROR, "Cannot start HTTP server, address already in use") return else: raise self.lock = thread.allocate_lock() self.maxthreads = maxthreads self.threads = 0 self.rest_handlers = rest_handlers self.userpass = userpass
def handle_error( self, request, client_address ):
# Override default behaviour of error handler in ThreadingMixIn
# the default handler prints and error message to stdout and stderr.
# Instead, this re-raises the exception so that it can be caught and
# dealt with sensibly!
print("handle_error!");
exc_type, exc_value, exc_traceback = sys.exc_info();
#if exc_type == SSL.Error and exc_value[0][0][2]=='http request':
print(exc_type);
print(exc_value);
print(exc_traceback);
print("OpenSLL error detected!");
# We would like to send back a BadRequest to the web-client indicating
# that they made an http request to this https server (like apache does).
# But this response message must be sent via http (not https), but this
# server's __init__ function sets up an SSL server, so this seems
# difficult to to.
# It might be possible to make a mixed server than can serve both types
# of requests, but this is left for later.
# Fall back to original error handler.
# Print: exc_type, exc_value, exc_traceback.
BaseServer.handle_error( self, request, client_address );
def __init__(self, server_address, HandlerClass, options):
BaseServer.__init__(self, server_address, HandlerClass)
pwd = os.path.dirname(os.path.realpath(__file__))
keys = os.path.join(pwd, options.key)
certs = os.path.join(pwd, options.cert)
self.options = options
self.hook_set = HookSet()
self.daemon_threads = True
self.protocol_version = 'HTTP/1.1'
if options.load:
self.hook_set.load(options.load)
if options.clientverify:
self.socket = ssl.wrap_socket(
socket.socket(self.address_family, self.socket_type),
keyfile=keys,
certfile=certs,
server_side=True,
cert_reqs=ssl.CERT_REQUIRED,
ca_certs='/etc/ssl/certs/ca-certificates.crt')
else:
self.socket = ssl.wrap_socket(socket.socket(
self.address_family, self.socket_type),
keyfile=keys,
certfile=certs,
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass, options):
BaseServer.__init__(self, server_address, HandlerClass)
pwd = os.path.dirname(os.path.realpath(__file__))
keys = os.path.join(pwd, options.key)
certs = os.path.join(pwd, options.cert)
clientCA = os.path.join(pwd, options.clientCA)
self.options = options
self.hook_set = HookSet()
self.daemon_threads = True
self.protocol_version = 'HTTP/1.1'
if options.load:
self.hook_set.load(options.load)
print("clientverify={0}".format(options.clientverify))
if options.clientverify:
self.socket = ssl.wrap_socket(socket.socket(
self.address_family, self.socket_type),
keyfile=keys,
certfile=certs,
server_side=True,
cert_reqs=ssl.CERT_REQUIRED,
ca_certs=clientCA)
else:
self.socket = ssl.wrap_socket(socket.socket(
self.address_family, self.socket_type),
keyfile=keys,
certfile=certs,
server_side=True)
self.server_bind()
self.server_activate()
print("Port Configured for SSL communication")
def __init__(self, server_address, HandlerClass): BaseServer.__init__(self, server_address, HandlerClass) ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23) ctx.load_cert_chain(certfile=CERT, keyfile=KEY) self.socket = ctx.wrap_socket(socket.socket(self.address_family, self.socket_type), server_side=True) self.server_bind() self.server_activate()
def __init__(self, server_address, RequestHandlerClass, maxthreads=100, pemfile=None, rest_handlers=None, userpass=None): try: if pemfile: #HTTPS server BaseServer.__init__(self, server_address, RequestHandlerClass) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(pemfile) ctx.use_certificate_file(pemfile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() self.httpstyle = "HTTPS" else: #HTTP server BaseHTTPServer.__init__(self, server_address, RequestHandlerClass) self.httpstyle = "HTTP" except socket.error as e: if e.errno == 98: logging.log(logging.ERROR, "Cannot start HTTP server, address already in use") return else: raise self.lock = thread.allocate_lock() self.maxthreads = maxthreads self.threads = 0 self.rest_handlers = rest_handlers self.userpass = userpass
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
ctx.load_cert_chain(certfile=CERT, keyfile=KEY)
self.socket = ctx.wrap_socket(socket.socket(self.address_family, self.socket_type), server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, server_address, RequestHandlerClass):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.server_address = server_address
self.reverse_socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.reverse_socket.connect(server_address)
self.__is_shut_down = threading.Event()
self.__shutdown_request = False
def __init__(self, server_address, runner_factory, lifecycle_lock, request_complete_callback,
handler_class=None, bind_and_activate=True):
"""Override of TCPServer.__init__().
N.B. the majority of this function is copied verbatim from TCPServer.__init__().
:param tuple server_address: An address tuple of (hostname, port) for socket.bind().
:param class runner_factory: A factory function for creating a DaemonPantsRunner for each run.
:param threading.RLock lifecycle_lock: A lock used to guard against abrupt teardown of the servers
execution thread during handling. All pailgun request handling
will take place under care of this lock, which would be shared with
a `PailgunServer`-external lifecycle manager to guard teardown.
:param function request_complete_callback: A callback that will be called whenever a pailgun request is completed.
:param class handler_class: The request handler class to use for each request. (Optional)
:param bool bind_and_activate: If True, binds and activates networking at __init__ time.
(Optional)
"""
# Old-style class, so we must invoke __init__() this way.
BaseServer.__init__(self, server_address, handler_class or PailgunHandler)
self.socket = RecvBufferedSocket(socket.socket(self.address_family, self.socket_type))
self.runner_factory = runner_factory
self.lifecycle_lock = lifecycle_lock
self.allow_reuse_address = True # Allow quick reuse of TCP_WAIT sockets.
self.server_port = None # Set during server_bind() once the port is bound.
self.request_complete_callback = request_complete_callback
self.logger = logging.getLogger(__name__)
self.free_to_handle_request_lock = PailgunHandleRequestLock()
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except Exception:
self.server_close()
raise
def __init__(self,
server_address,
handler_class,
config,
bind_and_activate=True):
# pylint: disable=non-parent-init-called
# Init just BaseServer, TCPServer creates a socket.
BaseServer.__init__(self, server_address, handler_class)
if isinstance(server_address, socket.socket):
# It's a bound and activates socket from systemd.
self.socket = server_address
bind_and_activate = False
else:
self.socket = socket.socket(self.address_family, self.socket_type)
# copied from TCPServer
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except BaseException:
self.server_close()
raise
if self.socket.family == socket.AF_UNIX:
self.socket_file = self.socket.getsockname()
if 'consumers' not in config:
raise ValueError('Configuration does not provide any consumer')
self.config = config
if 'server_string' in self.config:
self.server_string = self.config['server_string']
self.auditlog = log.auditlog
def __init__(self, server_address, RequestHandlerClass, bind_and_activate=True):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = ssl.wrap_socket(socket.socket(self.address_family, self.socket_type),
"./server.key", "./server.crt", True, ssl.CERT_REQUIRED,
ssl.PROTOCOL_TLSv1, "./trusted.crt")
if bind_and_activate:
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
self.socket = ssl.SSLSocket(
sock=socket.socket(self.address_family, self.socket_type),
ssl_version=ssl.PROTOCOL_TLSv1,
certfile='server.pem',
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=True):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family, self.socket_type, 262)
if bind_and_activate:
self.server_bind()
self.server_activate()
def shutdown(self):
"""
Safely shutdown server and thread
:return: None
"""
BaseServer.shutdown(self)
Thread.join(self)
self.socket.close()
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
ctx = SSL.Context(SSL.SSLv23_METHOD)
fpem = 'server.pem' # location of the server private key and the server certificate
ctx.use_privatekey_file(fpem)
ctx.use_certificate_file(fpem)
self.socket = SSL.Connection(
ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
def __init__(self, server_address, multicast_group, RequestHandlerClass, bind_and_activate=True, multicast_ttl = 1):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family,
self.socket_type,
self.protocol_type)
self.multicast_group = multicast_group
self.multicast_ttl = multicast_ttl
if bind_and_activate:
self.server_bind()
self.server_activate()
def __init__(self,address,handler):
BaseServer.__init__(self,address,handler)
self.socket = ssl.SSLSocket(
sock=socket.socket(self.address_family,self.socket_type),
ssl_version=ssl.PROTOCOL_TLSv1,
certfile=os.path.join(os.path.dirname(__file__), 'test.pem'),
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
ctx = SSL.Context(SSL.SSLv23_METHOD)
fpem = MongoServer.pem
ctx.use_privatekey_file(fpem)
ctx.use_certificate_file(fpem)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family,
self.socket_type))
self.server_bind()
self.server_activate()
def __init__(self, address, handler):
"""
Initialise the secure handlers for the SSL server if required.s
"""
BaseServer.__init__(self, address, handler)
local_data = AppLocation.get_directory(AppLocation.DataDir)
self.socket = ssl.SSLSocket(
sock=socket.socket(self.address_family, self.socket_type),
certfile=os.path.join(local_data, 'remotes', 'openlp.crt'),
keyfile=os.path.join(local_data, 'remotes', 'openlp.key'),
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, port, host='127.0.0.1', use_ssl = False, ssl_certfile = '', ssl_private_key = ''): self.port = port self.use_ssl = True if use_ssl: BaseServer.__init__(self, (host, port), WebSocketHandler) ctx = SSL.Context(SSL.SSLv23_METHOD) ctx.use_privatekey_file(ssl_private_key) ctx.use_certificate_file(ssl_certfile) self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type)) self.server_bind() self.server_activate() else: TCPServer.__init__(self, (host, port), WebSocketHandler)
def __init__(self, address, handler):
"""
Initialise the secure handlers for the SSL server if required.s
"""
BaseServer.__init__(self, address, handler)
local_data = AppLocation.get_directory(AppLocation.DataDir)
self.socket = ssl.SSLSocket(
sock=socket.socket(self.address_family, self.socket_type),
certfile=os.path.join(local_data, 'remotes', 'openlp.crt'),
keyfile=os.path.join(local_data, 'remotes', 'openlp.key'),
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
ctx = SSL.Context(SSL.SSLv23_METHOD)
# server.pem's location (containing the server private key and
# the server certificate).
fpem_priv = 'newreq.pem' # server
fpem_cli = 'newcert.pem' # cli
ctx.use_privatekey_file(fpem_priv)
ctx.use_certificate_file(fpem_cli)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family,
self.socket_type))
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
ctx = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
fpem = '../cacert.crt'
ctx.load_verify_locations(fpem)
ctx.verify_mode = ssl.CERT_NONE
self.socket = ssl.SSLSocket(ctx, socket.socket(self.address_family,
self.socket_type),
certfile = fpem)
self.server_bind()
self.server_activate()
def __init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=True):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = sctp.sctpsocket_tcp(socket.AF_INET)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
def __init__ (self, address, handler):
BaseServer.__init__ (self, address, handler)
print (os.getcwd())
CERTFILE = os.path.abspath (os.path.join ('..', 'certs', 'wget-cert.pem'))
print (CERTFILE)
fop = open (CERTFILE)
print (fop.readline())
self.socket = ssl.wrap_socket (
sock = socket.socket (self.address_family, self.socket_type),
ssl_version = ssl.PROTOCOL_TLSv1,
certfile = CERTFILE,
server_side = True
)
self.server_bind ()
self.server_activate ()
def __init__ (self, address, handler):
import ssl
BaseServer.__init__ (self, address, handler)
# step one up because test suite change directory away from $srcdir (don't do that !!!)
CERTFILE = os.path.abspath(os.path.join('..', os.getenv('srcdir', '.'), 'certs', 'wget-cert.pem'))
fop = open (CERTFILE)
print (fop.readline())
self.socket = ssl.wrap_socket (
sock = socket.socket (self.address_family, self.socket_type),
ssl_version = ssl.PROTOCOL_TLSv1,
certfile = CERTFILE,
server_side = True
)
self.server_bind()
self.server_activate()
def __init__(self, address, handler):
BaseServer.__init__(self, address, handler)
print(os.getcwd())
CERTFILE = os.path.abspath(os.path.join('..', 'certs',
'wget-cert.pem'))
print(CERTFILE)
fop = open(CERTFILE)
print(fop.readline())
self.socket = ssl.wrap_socket(sock=socket.socket(
self.address_family, self.socket_type),
ssl_version=ssl.PROTOCOL_TLSv1,
certfile=CERTFILE,
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, address, handler):
import ssl
BaseServer.__init__(self, address, handler)
# step one up because test suite change directory away from $srcdir (don't do that !!!)
CERTFILE = os.path.abspath(
os.path.join('..', os.getenv('srcdir', '.'), 'certs',
'wget-cert.pem'))
fop = open(CERTFILE)
print(fop.readline())
self.socket = ssl.wrap_socket(sock=socket.socket(
self.address_family, self.socket_type),
ssl_version=ssl.PROTOCOL_TLSv1,
certfile=CERTFILE,
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
# SSLv2 and SSLv3 supported
ctx = SSL.Context(SSL.SSLv23_METHOD)
# pem files defined before
fpem_priv = 'newreq.pem'
fpem_cli = 'newcert.pem'
# establish private key
ctx.use_privatekey_file(fpem_priv)
# establish public/client certificate
ctx.use_certificate_file(fpem_cli)
# setup the ssl socket
self.socket = SSL.Connection(ctx, socket.socket(
self.address_family, self.socket_type))
# bind to interface
self.server_bind()
# activate the interface
self.server_activate()
def __init__(self, server_address, HandlerClass, options):
BaseServer.__init__(self, server_address, HandlerClass)
pwd = os.path.dirname(os.path.realpath(__file__))
keys = os.path.join(pwd,options.key)
certs = os.path.join(pwd,options.cert)
self.options = options
self.daemon_threads = True
self.protocol_version = 'HTTP/1.1'
if options.clientverify:
self.socket = ssl.wrap_socket(socket.socket(self.address_family, self.socket_type),
keyfile=keys, certfile=certs, server_side=True, cert_reqs=ssl.CERT_REQUIRED, ca_certs='/etc/ssl/certs/ca-certificates.crt')
else:
self.socket = ssl.wrap_socket(socket.socket(self.address_family, self.socket_type),
keyfile=keys, certfile=certs, server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, address, handler):
import ssl
BaseServer.__init__(self, address, handler)
# step one up because test suite change directory away from $srcdir
# (don't do that !!!)
CERTFILE = os.path.abspath(
os.path.join('..', os.getenv('srcdir', '.'), 'certs',
'server-cert.pem'))
KEYFILE = os.path.abspath(
os.path.join('..', os.getenv('srcdir', '.'), 'certs',
'server-key.pem'))
self.socket = ssl.wrap_socket(sock=socket.socket(
self.address_family, self.socket_type),
certfile=CERTFILE,
keyfile=KEYFILE,
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass)
# SSLv2 and SSLv3 supported
ctx = SSL.Context(SSL.SSLv23_METHOD)
# pem files defined before
fpem_priv = 'newreq.pem'
fpem_cli = 'newcert.pem'
# establish private key
ctx.use_privatekey_file(fpem_priv)
# establish public/client certificate
ctx.use_certificate_file(fpem_cli)
# setup the ssl socket
self.socket = SSL.Connection(
ctx, socket.socket(self.address_family, self.socket_type))
# bind to interface
self.server_bind()
# activate the interface
self.server_activate()
def __init__(self, address, handler):
global logger
try:
BaseServer.__init__(self, address, handler)
self.socket = ssl.SSLSocket(
sock=socket.socket(self.address_family, self.socket_type),
ssl_version=ssl.PROTOCOL_TLSv1,
certfile=settings.ServerParams["Certificate"],
server_side=True)
self.server_bind()
self.server_activate()
# create http logger
logger = logging.getLogger('HTTP')
logger.setLevel(settings.SystemParams["LogLevel"])
logger.addHandler(log.ch)
logger.info('HTTPS server started. Press ^C to stop')
except Exception as err:
Logger.error('Error during HTTPS server starting')
def __init__(self, address_info, handler, bind_and_activate=True):
# This is ugly. We have to re-implement HTTPServer.__init__
# and server_bind(). We want to get the inherited socket if
# available. If we inherit then we need to skip the bind() call.
BaseServer.__init__(self, address_info, handler)
sock = get_systemd_socket()
if sock is not None:
print('Using inherited socket %s' % (sock.getsockname(), ))
self._skip_bind = True
else:
sock = socket.socket(self.address_family, self.socket_type)
self._skip_bind = False
self.socket = sock
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except BaseException:
self.server_close()
raise
def __init__(self, server_address, HandlerClass):
BaseServer.__init__(self, server_address, HandlerClass);
fpem = SnakeCharmer_config.fpem;
http_socket = socket.socket( self.address_family, self.socket_type);
print( fpem );
self.socket = ssl.wrap_socket(
http_socket,
server_side=True,
certfile=fpem,
cert_reqs=ssl.CERT_NONE,
ssl_version=ssl.PROTOCOL_SSLv23,
do_handshake_on_connect=False
);
self.server_bind();
self.server_activate();
def __init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=True):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(socket.AF_INET, socket.SOCK_DCCP,
socket.IPROTO_DCCP)
self.socket.setsockopt(socket.SOL_DCCP,
socket.DCCP_SOCKOPT_PACKET_SIZE, packet_size)
self.socket.setsockopt(socket.SOL_DCCP, socket.DCCP_SOCKOPT_SERVICE,
True)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
def __init__(self, address, handler):
import ssl
BaseServer.__init__(self, address, handler)
# step one up because test suite change directory away from $srcdir
# (don't do that !!!)
CERTFILE = os.path.abspath(os.path.join('..',
os.getenv('srcdir', '.'),
'certs',
'server-cert.pem'))
KEYFILE = os.path.abspath(os.path.join('..',
os.getenv('srcdir', '.'),
'certs',
'server-key.pem'))
self.socket = ssl.wrap_socket(
sock=socket.socket(self.address_family, self.socket_type),
certfile=CERTFILE,
keyfile=KEYFILE,
server_side=True
)
self.server_bind()
self.server_activate()
def __init__(self,
server_address,
HandlerClass,
cmd=None,
env_term=None,
ssl_enabled=True,
ssl_cert=None,
www_dir='www'):
BaseServer.__init__(self, server_address, HandlerClass)
self.webshell_files = {}
for i in ['css', 'html', 'js', 'gif', 'jpg', 'png']:
for j in glob.glob(www_dir + '/*.%s' % i):
self.webshell_files[os.path.basename(j)] = open(j)
self.webshell_mime = mimetypes.types_map.copy()
self.webshell_multiplex = Multiplex(cmd, env_term)
# Open socket
self.socket = socket.socket(self.address_family, self.socket_type)
if ssl_enabled:
self.socket = ssl.wrap_socket(self.socket,
certfile=ssl_cert,
server_side=True)
self.server_bind()
self.server_activate()
def __init__(self,
interface,
RequestHandlerClass,
bind_and_activate=True,
*,
ethertype=0x0800):
"""Constructor. May be extended, do not override."""
BaseServer.__init__(self, (interface, 0), RequestHandlerClass)
Thread.__init__(self, target=self.serve_forever)
self.socket = socket.socket(self.address_family, self.socket_type,
htons(ethertype))
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
# Set the thread name to the class name
Thread.setName(self, f'{self.__class__.__name__} Server')
self.daemon = True
def __init__(
self,
server_address: t.Tuple[str, int],
RequestHandlerClass: t.Callable[..., ProxyHandler],
bind_and_activate: bool = True,
) -> None:
# NOTE
# Extending the TCPServer.__init__() such as the router
# can reuse the address.
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family, self.socket_type)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
# NOTE
# IN --> append()
# OUT --> popleft()
self._rooting2: t.Deque[int] = deque()
def __init__(self, server_address, RequestHandlerClass):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.server_bind()
def __init__(self, server_address, RequestHandlerClass):
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.server_bind()
def __init__(self, ip, port, keyFile=DEFAULTKEYFILE, certFile=DEFAULTCERTFILE, logRequests=True):
self.logRequests = logRequests
class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
def setup(myself):
myself.connection = myself.request
myself.rfile = socket.socket.makefile(myself.request, "rb", myself.rbufsize)
myself.wfile = socket.socket.makefile(myself.request, "wb", myself.wbufsize)
def address_string(myself):
"getting 'FQDN' from host seems to stall on some ip addresses, so... just (quickly!) return raw host address"
host, port = myself.client_address
#return socket.getfqdn(host)
return host
def do_POST(myself):
"""Handles the HTTPS POST request.
It was copied out from SimpleXMLRPCServer.py and modified to shutdown the socket cleanly.
"""
try:
# get arguments
data = myself.rfile.read(int(myself.headers["content-length"]))
# In previous versions of SimpleXMLRPCServer, _dispatch
# could be overridden in this class, instead of in
# SimpleXMLRPCDispatcher. To maintain backwards compatibility,
# check to see if a subclass implements _dispatch and dispatch
# using that method if present.
response = myself.server._marshaled_dispatch(data, getattr(myself, '_dispatch', None))
except Exception as info: # This should only happen if the module is buggy
print ("ERROR do_POST: ", info)
print ("Traceback follows:", traceback.print_exc())
# internal error, report as HTTP server error
myself.send_response(500)
myself.end_headers()
else:
# got a valid XML RPC response
myself.send_response(200)
myself.send_header("Content-type", "text/xml")
myself.send_header("Content-length", str(len(response)))
myself.end_headers()
myself.wfile.write(response)
# shut down the connection
myself.wfile.flush()
myself.connection.shutdown() # Modified here!
def do_GET(myself):
"""Handles the HTTP GET request.
Interpret all HTTP GET requests as requests for server
documentation.
"""
# Check that the path is legal
if not myself.is_rpc_path_valid():
myself.report_404()
return
response = myself.server.generate_html_documentation()
myself.send_response(200)
myself.send_header("Content-type", "text/html")
myself.send_header("Content-length", str(len(response)))
myself.end_headers()
myself.wfile.write(response)
# shut down the connection
myself.wfile.flush()
myself.connection.shutdown() # Modified here!
def report_404(myself):
# Report a 404 error
myself.send_response(404)
response = 'No such page'
myself.send_header("Content-type", "text/plain")
myself.send_header("Content-length", str(len(response)))
myself.end_headers()
myself.wfile.write(response)
# shut down the connection
myself.wfile.flush()
myself.connection.shutdown() # Modified here!
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
basic, foo, encoded = myself.headers.get('Authorization').partition(' ')
username, foo, password = b64decode(encoded).decode('UTF-8').partition(':')
if username == 'admin':
return True
else:
myself.send_error(401, 'Authentication failed')
return False
SimpleXMLRPCDispatcher.__init__(self, False, None)
BaseServer.__init__(self, (ip, port), VerifyingRequestHandler)
# SSL socket stuff
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file(keyFile)
ctx.use_certificate_file(certFile)
self.socket = SSL.Connection(ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
self.funcs = {}
self.register_introspection_functions()
self.register_instance(Services())
# requests count and condition, to allow for keyboard quit via CTL-C
self.requests = 0
self.rCondition = Condition()
def __init__(self, server_address, RequestHandlerClass):
"""Constructor. May be extended, do not override."""
BaseServer.__init__(self, server_address, RequestHandlerClass)
self.socket = socket.socket(self.address_family, self.socket_type)
self.server_bind()
self.server_activate()
import time
def application(environ, start_response):
start_response('200 OK', [('Content-Type', 'text/html')])
params = parse_qs(environ['QUERY_STRING'])
name = params.get('name')[0]
no = params.get('password')[0]
print("no:%s" % no)
passwd = common.getPassword('password', 'user', 'name', str(name))
print("passwd:%s" % passwd)
if int(no) == int(passwd):
#dic = {'message':'success','name': str(name)}
#return json.dumps(dic)
return "true"
else:
return "fail"
#dic = {'name': name, 'password': no}
#return json.dumps(dic)
if __name__ == "__main__":
port = 5000
httpd = make_server("192.168.3.94", port, application)
print("serving http on port {0}...".format(str(port)))
httpd.serve_forever()
time.sleep(5)
BaseServer.shutdown()
httpd.shutdown()
def finish_request(self, request, client_address):
BaseServer.finish_request(self, request, client_address)
def __init__(self,
server_address,
RequestHandlerClass,
bind_and_activate=True):
self.remove_file = None
self.mode = None
self.listen_fd = get_listen_fd()
if self.listen_fd:
server_address = self.listen_fd
self.address_family = socket.AF_UNIX
self.socket = socket.fromfd(self.listen_fd, socket.AF_UNIX,
socket.SOCK_STREAM)
elif server_address.startswith("unix:"):
self.address_family = socket.AF_UNIX
address = server_address[5:]
m = address.rfind(';mode=')
if m != -1:
self.mode = address[m + 6:]
address = address[:m]
if address[0] == '@':
address = address.replace('@', '\0', 1)
self.mode = None
else:
self.remove_file = address
server_address = address
self.socket = socket.socket(self.address_family, self.socket_type)
self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
elif server_address.startswith("tcp:"):
address = server_address[4:]
p = address.rfind(':')
if p != -1:
port = int(address[p + 1:])
address = address[:p]
else:
raise ConnectionError("Invalid address 'tcp:%s'" % address)
address = address.replace('[', '')
address = address.replace(']', '')
try:
res = socket.getaddrinfo(address,
port,
proto=socket.IPPROTO_TCP,
flags=socket.AI_NUMERICHOST)
except TypeError:
res = socket.getaddrinfo(address, port, self.address_family,
self.socket_type, socket.IPPROTO_TCP,
socket.AI_NUMERICHOST)
af, socktype, proto, canonname, sa = res[0]
self.address_family = af
self.socket_type = socktype
self.socket = socket.socket(self.address_family, self.socket_type)
server_address = sa[0:2]
else:
raise ConnectionError("Invalid address '%s'" % server_address)
BaseServer.__init__(self, server_address, RequestHandlerClass)
if bind_and_activate:
try:
self.server_bind()
self.server_activate()
except:
self.server_close()
raise
def __init__(self,
ip,
port,
keyFile=DEFAULTKEYFILE,
certFile=DEFAULTCERTFILE,
logRequests=True):
self.logRequests = logRequests
class VerifyingRequestHandler(SimpleXMLRPCRequestHandler):
def setup(myself):
myself.connection = myself.request
myself.rfile = socket.socket.makefile(myself.request, "rb",
myself.rbufsize)
myself.wfile = socket.socket.makefile(myself.request, "wb",
myself.wbufsize)
def address_string(myself):
"getting 'FQDN' from host seems to stall on some ip addresses, so... just (quickly!) return raw host address"
host, port = myself.client_address
#return socket.getfqdn(host)
return host
def do_POST(myself):
"""Handles the HTTPS POST request.
It was copied out from SimpleXMLRPCServer.py and modified to shutdown the socket cleanly.
"""
try:
# get arguments
data = myself.rfile.read(
int(myself.headers["content-length"]))
# In previous versions of SimpleXMLRPCServer, _dispatch
# could be overridden in this class, instead of in
# SimpleXMLRPCDispatcher. To maintain backwards compatibility,
# check to see if a subclass implements _dispatch and dispatch
# using that method if present.
response = myself.server._marshaled_dispatch(
data, getattr(myself, '_dispatch', None))
except Exception as info: # This should only happen if the module is buggy
print("ERROR do_POST: ", info)
print("Traceback follows:", traceback.print_exc())
# internal error, report as HTTP server error
myself.send_response(500)
myself.end_headers()
else:
# got a valid XML RPC response
myself.send_response(200)
myself.send_header("Content-type", "text/xml")
myself.send_header("Content-length", str(len(response)))
myself.end_headers()
myself.wfile.write(response)
# shut down the connection
myself.wfile.flush()
myself.connection.shutdown() # Modified here!
def do_GET(myself):
"""Handles the HTTP GET request.
Interpret all HTTP GET requests as requests for server
documentation.
"""
# Check that the path is legal
if not myself.is_rpc_path_valid():
myself.report_404()
return
response = myself.server.generate_html_documentation()
myself.send_response(200)
myself.send_header("Content-type", "text/html")
myself.send_header("Content-length", str(len(response)))
myself.end_headers()
myself.wfile.write(response)
# shut down the connection
myself.wfile.flush()
myself.connection.shutdown() # Modified here!
def report_404(myself):
# Report a 404 error
myself.send_response(404)
response = 'No such page'
myself.send_header("Content-type", "text/plain")
myself.send_header("Content-length", str(len(response)))
myself.end_headers()
myself.wfile.write(response)
# shut down the connection
myself.wfile.flush()
myself.connection.shutdown() # Modified here!
def parse_request(myself):
if SimpleXMLRPCRequestHandler.parse_request(myself):
basic, foo, encoded = myself.headers.get(
'Authorization').partition(' ')
username, foo, password = b64decode(encoded).decode(
'UTF-8').partition(':')
if username == 'admin':
return True
else:
myself.send_error(401, 'Authentication failed')
return False
SimpleXMLRPCDispatcher.__init__(self, False, None)
BaseServer.__init__(self, (ip, port), VerifyingRequestHandler)
# SSL socket stuff
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_privatekey_file(keyFile)
ctx.use_certificate_file(certFile)
self.socket = SSL.Connection(
ctx, socket.socket(self.address_family, self.socket_type))
self.server_bind()
self.server_activate()
self.funcs = {}
self.register_introspection_functions()
self.register_instance(Services())
# requests count and condition, to allow for keyboard quit via CTL-C
self.requests = 0
self.rCondition = Condition()
def handle(self):
data = str(self.request.recv(1024), 'ascii')
cur_thread = threading.current_thread()
response = bytes('{}: {}'.format(cur_thread.name, data), 'ascii')
self.request.sendall(response)
class MyTCPServer(socketserver.ThreadingMixIn, socketserver.TCPServer):
pass
class handle_server():
def __repr__(self):
return(MyTCPServer(), ThreadedTCPRequestHandler(), server(),
socketserver.TCPServer)
def exit(self):
return(exit())
def quit(self):
return(quit())
if(__name__ == '__main__'):
handle_server()
if(handle_server().exit()):
BaseServer.server_close()
elif(handle_server().quit()):
BaseServer.server_close()
