def test_env_log(self):
packet_encoding.init_all()
assert packet_encoding.get_packet_encoding_caps()
assert packet_encoding.get_enabled_encoders()
for x in packet_encoding.get_enabled_encoders():
e = packet_encoding.get_encoder(x)
for packet_data in (["hello", {
"foo": 1,
"bar": True
}],
#b"foo",
):
assert e
v, flag = e(packet_data)
assert v
if x == "none":
#'none' cannot decode back
continue
try:
r = packet_encoding.decode(v, flag)
assert r
except Exception:
print("error calling decode(%s, %s) for encoder %s" %
(v, flag, x))
raise
#one-shot function:
assert packet_encoding.pack_one_packet(["hello", {}])
def get_control_commands_caps(self):
caps = ["show_session_info", "show_bug_report", "debug"]
for x in compression.get_enabled_compressors():
caps.append("enable_" + x)
for x in packet_encoding.get_enabled_encoders():
caps.append("enable_" + x)
log("get_control_commands_caps()=%s", caps)
return {"": caps}
def enable_encoder_from_caps(self, caps):
opts = packet_encoding.get_enabled_encoders(
order=packet_encoding.PERFORMANCE_ORDER)
for e in opts:
if caps.boolget(e):
self.enable_encoder(e)
return True
log.error("no matching packet encoder found!")
return False
def enable_encoder_from_caps(self, caps):
opts = packet_encoding.get_enabled_encoders(order=packet_encoding.PERFORMANCE_ORDER)
log("enable_encoder_from_caps(..) options=%s", opts)
for e in opts:
if caps.boolget(e, e == "bencode"):
self.enable_encoder(e)
return True
log.error("no matching packet encoder found!")
return False
def control_command_encoder(self, encoder):
e = encoder.lower()
from xpra.net import packet_encoding
opts = packet_encoding.get_enabled_encoders() #ie: [rencode, bencode, yaml]
if e not in opts:
raise ControlError("encoder argument must be one of: %s" % csv(opts))
for cproto in tuple(self._server_sources.keys()):
cproto.enable_encoder(e)
self.all_send_client_command("enable_%s" % e)
return "encoders set to %s" % encoder
def setup_fastencoder_nocompression(protocol):
from xpra.net.packet_encoding import get_enabled_encoders, PERFORMANCE_ORDER
encoders = get_enabled_encoders(PERFORMANCE_ORDER)
assert len(encoders)>0, "no packet encoders available!?"
for encoder in encoders:
try:
protocol.enable_encoder(encoder)
log("protocol using %s", encoder)
break
except Exception as e:
log("failed to enable %s: %s", encoder, e)
#we assume this is local, so no compression:
protocol.enable_compressor("none")
def setup_fastencoder_nocompression(protocol):
from xpra.net.packet_encoding import get_enabled_encoders, PERFORMANCE_ORDER
encoders = get_enabled_encoders(PERFORMANCE_ORDER)
assert len(encoders)>0, "no packet encoders available!?"
for encoder in encoders:
try:
protocol.enable_encoder(encoder)
log("protocol using %s", encoder)
break
except Exception as e:
log("failed to enable %s: %s", encoder, e)
#we assume this is local, so no compression:
protocol.enable_compressor("none")
def _process_control(self, packet):
command = packet[1]
if command == "show_session_info":
args = packet[2:]
log("calling show_session_info%s on server request", args)
self.show_session_info(*args)
elif command == "show_bug_report":
self.show_bug_report()
elif command in ("enable_%s" % x
for x in compression.get_enabled_compressors()):
compressor = command.split("_")[1]
log.info("switching to %s on server request", compressor)
self._protocol.enable_compressor(compressor)
elif command in ("enable_%s" % x
for x in packet_encoding.get_enabled_encoders()):
pe = command.split("_")[1]
log.info("switching to %s on server request", pe)
self._protocol.enable_encoder(pe)
elif command == "name":
assert len(args) >= 3
self.server_session_name = args[2]
log.info("session name updated from server: %s",
self.server_session_name)
#TODO: reset tray tooltip, session info title, etc..
elif command == "debug":
args = packet[2:]
if len(args) < 2:
log.warn("not enough arguments for debug control command")
return
log_cmd = args[0]
if log_cmd not in ("enable", "disable"):
log.warn(
"invalid debug control mode: '%s' (must be 'enable' or 'disable')",
log_cmd)
return
categories = args[1:]
from xpra.log import add_debug_category, add_disabled_category, enable_debug_for, disable_debug_for
if log_cmd == "enable":
add_debug_category(*categories)
loggers = enable_debug_for(*categories)
else:
assert log_cmd == "disable"
add_disabled_category(*categories)
loggers = disable_debug_for(*categories)
log.info("%sd debugging for: %s", log_cmd, loggers)
return
else:
log.warn("received invalid control command from server: %s",
command)
def get_network_caps():
try:
from xpra.net.mmap_pipe import can_use_mmap
mmap = can_use_mmap()
except:
mmap = False
caps = {
"digest": ("hmac", "xor"),
"compressors": compression.get_enabled_compressors(),
"encoders": packet_encoding.get_enabled_encoders(),
"mmap": mmap,
}
caps.update(get_crypto_caps())
caps.update(get_compression_caps())
caps.update(get_packet_encoding_caps())
return caps
def get_network_caps():
try:
from xpra.net.mmap_pipe import can_use_mmap
mmap = can_use_mmap()
except:
mmap = False
caps = {
"digest" : ("hmac", "xor"),
"compressors" : compression.get_enabled_compressors(),
"encoders" : packet_encoding.get_enabled_encoders(),
"mmap" : mmap,
}
caps.update(get_crypto_caps())
caps.update(get_compression_caps())
caps.update(get_packet_encoding_caps())
return caps
def get_network_caps() -> dict:
from xpra.net.digest import get_digests
from xpra.net.crypto import get_crypto_caps
from xpra.net.compression import get_enabled_compressors, get_compression_caps
from xpra.net.packet_encoding import get_enabled_encoders, get_packet_encoding_caps
digests = get_digests()
#"hmac" is the legacy name, "xor" and "des" should not be used for salt:
salt_digests = tuple(x for x in digests if x not in ("hmac", "xor", "des"))
caps = {
"digest": digests,
"salt-digest": salt_digests,
"compressors": get_enabled_compressors(),
"encoders": get_enabled_encoders(),
}
caps.update(get_crypto_caps())
caps.update(get_compression_caps())
caps.update(get_packet_encoding_caps())
return caps
def get_network_caps(legacy=True):
try:
from xpra.net.mmap_pipe import can_use_mmap
mmap = can_use_mmap()
except:
mmap = False
caps = {
"digest": ("hmac", "xor"),
"compressors": compression.get_enabled_compressors(),
"encoders": packet_encoding.get_enabled_encoders(),
"mmap": mmap,
}
if legacy:
#for backwards compatibility only:
caps.update({"raw_packets": True, "chunked_compression": True})
caps.update(get_crypto_caps())
caps.update(get_compression_caps())
caps.update(get_packet_encoding_caps())
return caps
def get_network_caps():
try:
from xpra.net.mmap_pipe import can_use_mmap
mmap = can_use_mmap()
except:
mmap = False
digests = get_digests()
#"hmac" is the legacy name, "xor" should not be used for salt:
salt_digests = [x for x in digests if x not in ("hmac", "xor")]
caps = {
"digest": digests,
"salt-digest": salt_digests,
"compressors": compression.get_enabled_compressors(),
"encoders": packet_encoding.get_enabled_encoders(),
"mmap": mmap,
}
caps.update(get_crypto_caps())
caps.update(get_compression_caps())
caps.update(get_packet_encoding_caps())
return caps
def get_network_caps(legacy=True):
try:
from xpra.net.mmap_pipe import can_use_mmap
mmap = can_use_mmap()
except:
mmap = False
caps = {
"digest": ("hmac", "xor"),
"compressors": compression.get_enabled_compressors(),
"encoders": packet_encoding.get_enabled_encoders(),
"mmap": mmap,
}
if legacy:
# for backwards compatibility only:
caps.update({"raw_packets": True, "chunked_compression": True})
caps.update(get_crypto_caps())
caps.update(get_compression_caps())
caps.update(get_packet_encoding_caps())
return caps
def get_network_caps():
try:
from xpra.platform.features import MMAP_SUPPORTED
except:
MMAP_SUPPORTED = False
from xpra.net.crypto import get_digests, get_crypto_caps
from xpra.net.compression import get_enabled_compressors, get_compression_caps
from xpra.net.packet_encoding import get_enabled_encoders, get_packet_encoding_caps
digests = get_digests()
#"hmac" is the legacy name, "xor" and "des" should not be used for salt:
salt_digests = [x for x in digests if x not in ("hmac", "xor", "des")]
caps = {
"digest": digests,
"salt-digest": salt_digests,
"compressors": get_enabled_compressors(),
"encoders": get_enabled_encoders(),
"mmap": MMAP_SUPPORTED,
}
caps.update(get_crypto_caps())
caps.update(get_compression_caps())
caps.update(get_packet_encoding_caps())
return caps
def enable_default_encoder(self):
opts = packet_encoding.get_enabled_encoders()
assert len(opts) > 0, "no packet encoders available!"
self.enable_encoder(opts[0])
def _process_control(self, packet):
command = bytestostr(packet[1])
if command == "show_session_info":
args = packet[2:]
log("calling %s%s on server request", self.show_session_info, args)
self.show_session_info(*args)
elif command == "show_bug_report":
self.show_bug_report()
elif command in ("enable_%s" % x
for x in compression.get_enabled_compressors()):
compressor = command.split("_")[1]
log.info("switching to %s on server request", compressor)
self._protocol.enable_compressor(compressor)
elif command in ("enable_%s" % x
for x in packet_encoding.get_enabled_encoders()):
pe = command.split("_")[1]
log.info("switching to %s on server request", pe)
self._protocol.enable_encoder(pe)
elif command == "name":
assert len(args) >= 3
self.server_session_name = args[2]
log.info("session name updated from server: %s",
self.server_session_name)
#TODO: reset tray tooltip, session info title, etc..
elif command == "debug":
args = packet[2:]
if not args:
log.warn("not enough arguments for debug control command")
return
from xpra.log import (
add_debug_category,
add_disabled_category,
enable_debug_for,
disable_debug_for,
get_all_loggers,
)
log_cmd = bytestostr(args[0])
if log_cmd == "status":
dloggers = [
x for x in get_all_loggers() if x.is_debug_enabled()
]
if dloggers:
log.info("logging is enabled for:")
for l in dloggers:
log.info(" - %s", l)
else:
log.info("logging is not enabled for any loggers")
return
log_cmd = bytestostr(args[0])
if log_cmd not in ("enable", "disable"):
log.warn(
"invalid debug control mode: '%s' (must be 'enable' or 'disable')",
log_cmd)
return
if len(args) < 2:
log.warn(
"not enough arguments for '%s' debug control command" %
log_cmd)
return
loggers = []
#each argument is a group
groups = [bytestostr(x) for x in args[1:]]
for group in groups:
#and each group is a list of categories
#preferably separated by "+",
#but we support "," for backwards compatibility:
categories = [
v.strip() for v in group.replace("+", ",").split(",")
]
if log_cmd == "enable":
add_debug_category(*categories)
loggers += enable_debug_for(*categories)
else:
assert log_cmd == "disable"
add_disabled_category(*categories)
loggers += disable_debug_for(*categories)
if not loggers:
log.info("%s debugging, no new loggers matching: %s", log_cmd,
csv(groups))
else:
log.info("%sd debugging for:", log_cmd)
for l in loggers:
log.info(" - %s", l)
else:
log.warn("received invalid control command from server: %s",
command)
def enable_default_encoder(self):
opts = packet_encoding.get_enabled_encoders()
assert len(opts) > 0, "no packet encoders available!"
self.enable_encoder(opts[0])
