def ssl_connect(host,
port,
keyfile=None,
certfile=None,
ca_certs=None,
ssl_version=None,
service=VoidService,
config={}):
"""creates an SSL-wrapped connection to the given host (encrypted and
authenticated).
host - the hostname to connect to
port - the TCP port to use
service - the local service to expose (defaults to Void)
config - configuration dict
keyfile, certfile, ca_certs, ssl_version -- arguments to ssl.wrap_socket.
see that module's documentation for further info."""
kwargs = {"server_side": False}
if keyfile:
kwargs["keyfile"] = keyfile
if certfile:
kwargs["certfile"] = certfile
if ca_certs:
kwargs["ca_certs"] = ca_certs
if ssl_version:
kwargs["ssl_version"] = ssl_version
else:
kwargs["ssl_version"] = ssl.PROTOCOL_TLSv1
s = SocketStream.ssl_connect(host, port, kwargs)
return Connection(service, Channel(s), config=config)
def connect(host, port, service=VoidService, config={}):
"""creates a socket-connection to the given host
host - the hostname to connect to
port - the TCP port to use
service - the local service to expose (defaults to Void)
config - configuration dict"""
return Connection(service, Channel(SocketStream.connect(host, port)), config=config)
def ssl_connect(host,
port,
keyfile=None,
certfile=None,
ca_certs=None,
cert_reqs=None,
ssl_version=None,
ciphers=None,
service=VoidService,
config={},
ipv6=False,
keepalive=False):
"""
creates an SSL-wrapped connection to the given host (encrypted and
authenticated).
:param host: the hostname to connect to
:param port: the TCP port to use
:param service: the local service to expose (defaults to Void)
:param config: configuration dict
:param ipv6: whether to create an IPv6 socket or an IPv4 one
The following arguments are passed directly to
`ssl.wrap_socket <http://docs.python.org/dev/library/ssl.html#ssl.wrap_socket>`_:
:param keyfile: see ``ssl.wrap_socket``. May be ``None``
:param certfile: see ``ssl.wrap_socket``. May be ``None``
:param ca_certs: see ``ssl.wrap_socket``. May be ``None``
:param cert_reqs: see ``ssl.wrap_socket``. By default, if ``ca_cert`` is specified,
the requirement is set to ``CERT_REQUIRED``; otherwise it is
set to ``CERT_NONE``
:param ssl_version: see ``ssl.wrap_socket``. The default is ``PROTOCOL_TLSv1``
:param ciphers: see ``ssl.wrap_socket``. May be ``None``. New in Python 2.7/3.2
:returns: an RPyC connection
"""
ssl_kwargs = {"server_side": False}
if keyfile is not None:
ssl_kwargs["keyfile"] = keyfile
if certfile is not None:
ssl_kwargs["certfile"] = certfile
if ca_certs is not None:
ssl_kwargs["ca_certs"] = ca_certs
ssl_kwargs["cert_reqs"] = ssl.CERT_REQUIRED
if cert_reqs is not None:
ssl_kwargs["cert_reqs"] = cert_reqs
if ssl_version is None:
ssl_kwargs["ssl_version"] = ssl.PROTOCOL_TLSv1
else:
ssl_kwargs["ssl_version"] = ssl_version
if ciphers is not None:
ssl_kwargs["ciphers"] = ciphers
s = SocketStream.ssl_connect(host,
port,
ssl_kwargs,
ipv6=ipv6,
keepalive=keepalive)
return connect_stream(s, service, config)
def connect(host, port, service=VoidService, config={}):
"""creates a socket-connection to the given host
host - the hostname to connect to
port - the TCP port to use
service - the local service to expose (defaults to Void)
config - configuration dict"""
return Connection(service,
Channel(SocketStream.connect(host, port)),
config=config)
def server(listener = listener):
client = listener.accept()[0]
listener.close()
conn = connect_stream(SocketStream(client), service = remote_service,
config = remote_config)
try:
conn.serve_all()
except KeyboardInterrupt:
interrupt_main()
def tlslite_connect(host, port, username, password, service = VoidService, config = {}):
"""creates a TLS-connection to the given host (encrypted and authenticated)
username - the username used to authenticate the client
password - the password used to authenticate the client
host - the hostname to connect to
port - the TCP port to use
service - the local service to expose (defaults to Void)
config - configuration dict"""
s = SocketStream.tlslite_connect(host, port, username, password)
return Connection(service, Channel(s), config=config)
def server(listener=listener, args=args):
client = listener.accept()[0]
listener.close()
conn = connect_stream(SocketStream(client), service = remote_service, config = remote_config)
try:
for k in args:
conn._local_root.exposed_namespace[k] = args[k]
conn.serve_all()
except KeyboardInterrupt:
interrupt_main()
def ssl_connect(
host,
port,
keyfile=None,
certfile=None,
ca_certs=None,
cert_reqs=None,
ssl_version=None,
ciphers=None,
service=VoidService,
config={},
ipv6=False,
):
"""
creates an SSL-wrapped connection to the given host (encrypted and
authenticated).
:param host: the hostname to connect to
:param port: the TCP port to use
:param service: the local service to expose (defaults to Void)
:param config: configuration dict
:param ipv6: whether to create an IPv6 socket or an IPv4 one
The following arguments are passed directly to
`ssl.wrap_socket <http://docs.python.org/dev/library/ssl.html#ssl.wrap_socket>`_:
:param keyfile: see ``ssl.wrap_socket``. May be ``None``
:param certfile: see ``ssl.wrap_socket``. May be ``None``
:param ca_certs: see ``ssl.wrap_socket``. May be ``None``
:param cert_reqs: see ``ssl.wrap_socket``. By default, if ``ca_cert`` is specified,
the requirement is set to ``CERT_REQUIRED``; otherwise it is
set to ``CERT_NONE``
:param ssl_version: see ``ssl.wrap_socket``. The default is ``PROTOCOL_TLSv1``
:param ciphers: see ``ssl.wrap_socket``. May be ``None``. New in Python 2.7/3.2
:returns: an RPyC connection
"""
ssl_kwargs = {"server_side": False}
if keyfile is not None:
ssl_kwargs["keyfile"] = keyfile
if certfile is not None:
ssl_kwargs["certfile"] = certfile
if ca_certs is not None:
ssl_kwargs["ca_certs"] = ca_certs
ssl_kwargs["cert_reqs"] = ssl.CERT_REQUIRED
if cert_reqs is not None:
ssl_kwargs["cert_reqs"] = cert_reqs
if ssl_version is None:
ssl_kwargs["ssl_version"] = ssl.PROTOCOL_TLSv1
else:
ssl_kwargs["ssl_version"] = ssl_version
if ciphers is not None:
ssl_kwargs["ciphers"] = ciphers
s = SocketStream.ssl_connect(host, port, ssl_kwargs, ipv6=ipv6)
return connect_stream(s, service, config)
def unix_connect(path, service=VoidService, config={}):
"""
creates a socket-connection to the given host and port
:param path: the path to the unix domain socket
:param service: the local service to expose (defaults to Void)
:param config: configuration dict
:returns: an RPyC connection
"""
s = SocketStream.unix_connect(path)
return connect_stream(s, service, config)
def unix_connect(path, service = VoidService, config = {}):
"""
creates a socket-connection to the given host and port
:param path: the path to the unix domain socket
:param service: the local service to expose (defaults to Void)
:param config: configuration dict
:returns: an RPyC connection
"""
s = SocketStream.unix_connect(path)
return connect_stream(s, service, config)
def connect(host, port, service = VoidService, config = {}, ipv6 = False, keepalive = None):
"""
creates a socket-connection to the given host and port
:param host: the hostname to connect to
:param port: the TCP port to use
:param service: the local service to expose (defaults to Void)
:param config: configuration dict
:param ipv6: whether to use IPv6 or not
:returns: an RPyC connection
"""
s = SocketStream.connect(host, port, ipv6 = ipv6, keepalive = keepalive)
return connect_stream(s, service, config)
def connect(host, port, service=VoidService, config={}, ipv6=False):
"""
creates a socket-connection to the given host and port
:param host: the hostname to connect to
:param port: the TCP port to use
:param service: the local service to expose (defaults to Void)
:param config: configuration dict
:param ipv6: whether to use IPv6 or not
:returns: an RPyC connection
"""
s = SocketStream.connect(host, port, ipv6=ipv6)
return connect_stream(s, service, config)
def tls_connect(host,
port,
username,
password,
service=VoidService,
config={}):
"""creates a TLS-connection to the given host (encrypted and authenticated)
username - the username used to authenticate the client
password - the password used to authenticate the client
host - the hostname to connect to
port - the TCP port to use
service - the local service to expose (defaults to Void)
config - configuration dict"""
s = SocketStream.tls_connect(host, port, username, password)
return Connection(service, Channel(s), config=config)
def ssl_connect(host, port, keyfile = None, certfile = None, ca_certs = None,
ssl_version = None, service = VoidService, config = {}):
"""creates an SSL-wrapped connection to the given host (encrypted and
authenticated).
host - the hostname to connect to
port - the TCP port to use
service - the local service to expose (defaults to Void)
config - configuration dict
keyfile, certfile, ca_certs, ssl_version -- arguments to ssl.wrap_socket.
see that module's documentation for further info."""
kwargs = {"server_side" : False}
if keyfile:
kwargs["keyfile"] = keyfile
if certfile:
kwargs["certfile"] = certfile
if ca_certs:
kwargs["ca_certs"] = ca_certs
if ssl_version:
kwargs["ssl_version"] = ssl_version
else:
kwargs["ssl_version"] = ssl.PROTOCOL_TLSv1
s = SocketStream.ssl_connect(host, port, kwargs)
return Connection(service, Channel(s), config = config)
