def get_info(self, proto, *args):
# this function is for non UI thread info
info = {}
def up(prefix, d):
updict(info, prefix, d)
filtered_env = os.environ.copy()
if filtered_env.get("XPRA_PASSWORD"):
filtered_env["XPRA_PASSWORD"] = "******"
if filtered_env.get("XPRA_ENCRYPTION_KEY"):
filtered_env["XPRA_ENCRYPTION_KEY"] = "*****"
up("network", get_network_caps())
up("server", get_server_info())
up("threads", self.get_thread_info(proto))
up("env", filtered_env)
up(
"server",
{
"mode": self.get_server_mode(),
"type": "Python",
"start_time": int(self.start_time),
"authenticator": str((self.auth_class or str)("")),
"argv": sys.argv,
"path": sys.path,
"exec_prefix": sys.exec_prefix,
"executable": sys.executable,
},
)
if self.session_name:
info["session.name"] = self.session_name
if self.child_reaper:
info.update(self.child_reaper.get_info())
return info
def get_info(self, proto, *args):
#this function is for non UI thread info
info = {}
def up(prefix, d):
updict(info, prefix, d)
filtered_env = os.environ.copy()
if filtered_env.get('XPRA_PASSWORD'):
filtered_env['XPRA_PASSWORD'] = "******"
if filtered_env.get('XPRA_ENCRYPTION_KEY'):
filtered_env['XPRA_ENCRYPTION_KEY'] = "*****"
up("network", get_network_caps())
up("server", get_server_info())
up("threads", self.get_thread_info(proto))
up("env", filtered_env)
up(
"server", {
"mode": self.get_server_mode(),
"type": "Python",
"start_time": int(self.start_time),
"authenticator": str((self.auth_class or str)("")),
"argv": sys.argv,
"path": sys.path,
"exec_prefix": sys.exec_prefix,
"executable": sys.executable,
})
if self.session_name:
info["session.name"] = self.session_name
if self.child_reaper:
info.update(self.child_reaper.get_info())
return info
def make_hello_base(self):
capabilities = flatten_dict(get_network_caps())
import struct
bits = struct.calcsize("P") * 8
capabilities.update(
{
"version": local_version,
"encoding.generic": True,
"namespace": True,
"hostname": socket.gethostname(),
"uuid": self.uuid,
"username": self.username,
"name": get_name(),
"client_type": self.client_type(),
"python.version": sys.version_info[:3],
"python.bits": bits,
"compression_level": self.compression_level,
"argv": sys.argv,
}
)
capabilities.update(self.get_file_transfer_features())
if self.display:
capabilities["display"] = self.display
def up(prefix, d):
updict(capabilities, prefix, d)
up("build", self.get_version_info())
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.encryption:
assert self.encryption in ENCRYPTION_CIPHERS
iv = get_iv()
key_salt = get_salt()
iterations = get_iterations()
padding = choose_padding(self.server_padding_options)
up(
"cipher",
{
"": self.encryption,
"iv": iv,
"key_salt": key_salt,
"key_stretch_iterations": iterations,
"padding": padding,
"padding.options": PADDING_OPTIONS,
},
)
key = self.get_encryption_key()
if key is None:
self.warn_and_quit(EXIT_ENCRYPTION, "encryption key is missing")
return
self._protocol.set_cipher_in(self.encryption, iv, key, key_salt, iterations, padding)
netlog(
"encryption capabilities: %s", dict((k, v) for k, v in capabilities.items() if k.startswith("cipher"))
)
capabilities.update(self.hello_extra)
return capabilities
def make_hello_base(self):
capabilities = flatten_dict(get_network_caps())
import struct
bits = struct.calcsize("P") * 8
capabilities.update({
"version": XPRA_VERSION,
"encoding.generic": True,
"namespace": True,
"hostname": socket.gethostname(),
"uuid": self.uuid,
"username": self.username,
"name": get_name(),
"client_type": self.client_type(),
"python.version": sys.version_info[:3],
"python.bits": bits,
"compression_level": self.compression_level,
"argv": sys.argv,
})
capabilities.update(self.get_file_transfer_features())
if self.display:
capabilities["display"] = self.display
def up(prefix, d):
updict(capabilities, prefix, d)
up("build", self.get_version_info())
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.encryption:
assert self.encryption in ENCRYPTION_CIPHERS
iv = get_iv()
key_salt = get_salt()
iterations = get_iterations()
padding = choose_padding(self.server_padding_options)
up(
"cipher", {
"": self.encryption,
"iv": iv,
"key_salt": key_salt,
"key_stretch_iterations": iterations,
"padding": padding,
"padding.options": PADDING_OPTIONS,
})
key = self.get_encryption_key()
if key is None:
self.warn_and_quit(EXIT_ENCRYPTION,
"encryption key is missing")
return
self._protocol.set_cipher_in(self.encryption, iv, key, key_salt,
iterations, padding)
netlog(
"encryption capabilities: %s",
dict((k, v) for k, v in capabilities.items()
if k.startswith("cipher")))
capabilities.update(self.hello_extra)
return capabilities
def get_info():
from xpra.net.protocol import get_network_caps
i = get_network_caps()
if has_netifaces:
i["interfaces"] = get_interfaces()
i["gateways"] = get_gateways()
s = get_net_sys_config()
if s:
i["system"] = s
return i
def enclabel(label, cipher):
if not cipher:
info = "None"
else:
info = str(cipher)
if c.info.lower()=="ssh":
info += " (%s)" % c.info
if get_network_caps().get("pycrypto.fastmath", False):
info += " (fastmath available)"
label.set_text(info)
def enclabel(label, cipher):
if not cipher:
info = "None"
else:
info = str(cipher)
if c.info.lower()=="ssh":
info += " (%s)" % c.info
if get_network_caps().get("pycrypto.fastmath", False):
info += " (fastmath available)"
label.set_text(info)
def get_info(): from xpra.net.protocol import get_network_caps i = get_network_caps() if has_netifaces: i["interfaces"] = get_interfaces() i["gateways"] = get_gateways() s = get_net_sys_config() if s: i["system"] = s i["config"] = get_net_config() return i
def make_hello_base(self):
capabilities = get_network_caps()
capabilities.update({
"version": local_version,
"encoding.generic": True,
"namespace": True,
"file-transfer": self.file_transfer,
"file-size-limit": self.file_size_limit,
"printing": self.printing,
"hostname": socket.gethostname(),
"uuid": self.uuid,
"username": self.username,
"name": get_name(),
"client_type": self.client_type(),
"python.version": sys.version_info[:3],
"compression_level": self.compression_level,
})
if self.display:
capabilities["display"] = self.display
def up(prefix, d):
updict(capabilities, prefix, d)
up("platform", get_platform_info())
up("build", get_version_info())
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.encryption:
assert self.encryption in ENCRYPTION_CIPHERS
iv = get_hex_uuid()[:16]
key_salt = get_hex_uuid() + get_hex_uuid()
iterations = 1000
capabilities.update({
"cipher": self.encryption,
"cipher.iv": iv,
"cipher.key_salt": key_salt,
"cipher.key_stretch_iterations": iterations,
})
key = self.get_encryption_key()
if key is None:
self.warn_and_quit(EXIT_ENCRYPTION,
"encryption key is missing")
return
self._protocol.set_cipher_in(self.encryption, iv, key, key_salt,
iterations)
log("encryption capabilities: %s",
[(k, v)
for k, v in capabilities.items() if k.startswith("cipher")])
return capabilities
def get_info(): from xpra.net.protocol import get_network_caps i = get_network_caps() if has_netifaces: i["interfaces"] = get_interfaces() i["gateways"] = get_gateways() if "ssl" in sys.modules: ssli = get_ssl_info() ssli[""] = True i["ssl"] = ssli s = get_net_sys_config() if s: i["system"] = s i["config"] = get_net_config() return i
def get_info(self, proto, *args):
#this function is for non UI thread info
info = get_server_info("server.")
info.update({
"server.mode" : self.get_server_mode(),
"server.type" : "Python",
"server.start_time" : int(self.start_time),
"server.authenticator" : str((self.auth_class or str)("")),
})
if self.session_name:
info["session.name"] = self.session_name
info.update(self.get_thread_info(proto))
for k,v in get_network_caps().items():
info["network."+k] = v
return info
def get_info(self, proto, *args):
#this function is for non UI thread info
info = get_server_info("server.")
info.update({
"server.mode": self.get_server_mode(),
"server.type": "Python",
"server.start_time": int(self.start_time),
"server.authenticator": str((self.auth_class or str)("")),
})
if self.session_name:
info["session.name"] = self.session_name
info.update(self.get_thread_info(proto))
for k, v in get_network_caps().items():
info["network." + k] = v
return info
def get_info():
from xpra.net.protocol import get_network_caps
i = get_network_caps()
if has_netifaces:
i["interfaces"] = get_interfaces()
i["gateways"] = get_gateways()
if "ssl" in sys.modules:
ssli = get_ssl_info()
ssli[""] = True
i["ssl"] = ssli
s = get_net_sys_config()
if s:
i["system"] = s
i["config"] = get_net_config()
return i
def main():
from xpra.platform import init, clean
from xpra.log import enable_color
try:
init("Network-Info", "Network Info")
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
print("Network interfaces found:")
for iface in get_interfaces():
if if_nametoindex:
print("* %s (index=%s)" %
(iface.ljust(20), if_nametoindex(iface)))
else:
print("* %s" % iface)
def pver(v):
if type(v) in (tuple, list):
s = ""
for i in range(len(v)):
if i > 0:
#dot seperated numbers
if type(v[i - 1]) == int:
s += "."
else:
s += ", "
s += str(v[i])
return s
elif type(v) == str and v.startswith("v"):
return v[1:]
return str(v)
print("")
print("Protocol Capabilities:")
from xpra.net.protocol import get_network_caps
netcaps = get_network_caps()
if netifaces_version:
netcaps["netifaces.version"] = netifaces_version
for k in sorted(netcaps.keys()):
print("* %s : %s" % (str(k).ljust(20), pver(netcaps[k])))
finally:
#this will wait for input on win32:
clean()
def main():
from xpra.platform import init, clean
from xpra.log import enable_color
try:
init("Network-Info", "Network Info")
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
print("Network interfaces found:")
for iface in get_interfaces():
if if_nametoindex:
print("* %s (index=%s)" % (iface.ljust(20), if_nametoindex(iface)))
else:
print("* %s" % iface)
def pver(v):
if type(v) in (tuple, list):
s = ""
for i in range(len(v)):
if i>0:
#dot seperated numbers
if type(v[i-1])==int:
s += "."
else:
s += ", "
s += str(v[i])
return s
elif type(v)==str and v.startswith("v"):
return v[1:]
return str(v)
print("")
print("Protocol Capabilities:")
from xpra.net.protocol import get_network_caps
netcaps = get_network_caps()
if netifaces_version:
netcaps["netifaces.version"] = netifaces_version
for k in sorted(netcaps.keys()):
print("* %s : %s" % (str(k).ljust(20), pver(netcaps[k])))
finally:
#this will wait for input on win32:
clean()
def make_hello_base(self):
capabilities = get_network_caps()
capabilities.update({
"version" : local_version,
"encoding.generic" : True,
"namespace" : True,
"file-transfer" : self.file_transfer,
"file-size-limit" : self.file_size_limit,
"printing" : self.printing,
"hostname" : socket.gethostname(),
"uuid" : self.uuid,
"username" : self.username,
"name" : get_name(),
"client_type" : self.client_type(),
"python.version" : sys.version_info[:3],
"compression_level" : self.compression_level,
})
if self.display:
capabilities["display"] = self.display
def up(prefix, d):
updict(capabilities, prefix, d)
up("platform", get_platform_info())
up("build", get_version_info())
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.encryption:
assert self.encryption in ENCRYPTION_CIPHERS
iv = get_hex_uuid()[:16]
key_salt = get_hex_uuid()+get_hex_uuid()
iterations = 1000
capabilities.update({
"cipher" : self.encryption,
"cipher.iv" : iv,
"cipher.key_salt" : key_salt,
"cipher.key_stretch_iterations": iterations,
})
key = self.get_encryption_key()
if key is None:
self.warn_and_quit(EXIT_ENCRYPTION, "encryption key is missing")
return
self._protocol.set_cipher_in(self.encryption, iv, key, key_salt, iterations)
log("encryption capabilities: %s", [(k,v) for k,v in capabilities.items() if k.startswith("cipher")])
return capabilities
def filter_caps(self, caps, prefixes):
#removes caps that the proxy overrides / does not use:
#(not very pythonic!)
pcaps = {}
removed = []
for k in caps.keys():
skip = len([e for e in prefixes if k.startswith(e)])
if skip==0:
pcaps[k] = caps[k]
else:
removed.append(k)
log("filtered out %s matching %s", removed, prefixes)
#replace the network caps with the proxy's own:
pcaps.update(flatten_dict(get_network_caps()))
#then add the proxy info:
updict(pcaps, "proxy", get_server_info(), flatten_dicts=True)
pcaps["proxy"] = True
pcaps["proxy.hostname"] = socket.gethostname()
return pcaps
def filter_caps(self, caps, prefixes):
#removes caps that the proxy overrides / does not use:
#(not very pythonic!)
pcaps = {}
removed = []
for k in caps.keys():
skip = len([e for e in prefixes if k.startswith(e)])
if skip==0:
pcaps[k] = caps[k]
else:
removed.append(k)
log("filtered out %s matching %s", removed, prefixes)
#replace the network caps with the proxy's own:
pcaps.update(get_network_caps())
#then add the proxy info:
pcaps.update(get_server_info("proxy."))
pcaps["proxy"] = True
pcaps["proxy.hostname"] = socket.gethostname()
return pcaps
def make_hello(self):
now = time.time()
capabilities = get_network_caps()
capabilities.update(get_server_info())
capabilities.update({
"start_time": int(self.start_time),
"current_time": int(now),
"elapsed_time": int(now - self.start_time),
"server_type": "core",
"info-request": True,
"uuid": get_user_uuid(),
})
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.session_name:
capabilities["session_name"] = self.session_name
if self._reverse_aliases:
capabilities["aliases"] = self._reverse_aliases
add_version_info(capabilities)
return capabilities
def make_hello(self):
now = time.time()
capabilities = get_network_caps()
capabilities.update(get_server_info())
capabilities.update({
"start_time" : int(self.start_time),
"current_time" : int(now),
"elapsed_time" : int(now - self.start_time),
"server_type" : "core",
"info-request" : True,
"uuid" : get_user_uuid(),
})
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.session_name:
capabilities["session_name"] = self.session_name
if self._reverse_aliases:
capabilities["aliases"] = self._reverse_aliases
add_version_info(capabilities)
return capabilities
def get_info(self, proto, *args):
#this function is for non UI thread info
info = {}
def up(prefix, d):
updict(info, prefix, d)
up("network", get_network_caps())
up("server", get_server_info())
up("threads", get_thread_info(proto))
up("env", os.environ)
up("server", {
"mode" : self.get_server_mode(),
"type" : "Python",
"start_time" : int(self.start_time),
"authenticator" : str((self.auth_class or str)("")),
})
if self.session_name:
info["session.name"] = self.session_name
if self.child_reaper:
info.update(self.child_reaper.get_info())
return info
def make_hello(self, source):
now = time.time()
capabilities = get_network_caps()
if source.wants_versions:
capabilities.update(get_server_info())
capabilities.update({
"version": xpra.__version__,
"start_time": int(self.start_time),
"current_time": int(now),
"elapsed_time": int(now - self.start_time),
"server_type": "core",
})
if source.wants_features:
capabilities["info-request"] = True
if source.wants_versions:
capabilities["uuid"] = get_user_uuid()
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.session_name:
capabilities["session_name"] = self.session_name
return capabilities
def make_hello(self, source):
now = time.time()
capabilities = get_network_caps()
if source.wants_versions:
capabilities.update(get_server_info())
capabilities.update({
"version" : xpra.__version__,
"start_time" : int(self.start_time),
"current_time" : int(now),
"elapsed_time" : int(now - self.start_time),
"server_type" : "core",
})
if source.wants_features:
capabilities["info-request"] = True
if source.wants_versions:
capabilities["uuid"] = get_user_uuid()
mid = get_machine_id()
if mid:
capabilities["machine_id"] = mid
if self.session_name:
capabilities["session_name"] = self.session_name
return capabilities
def get_info(self, proto, *args):
#this function is for non UI thread info
info = {}
def up(prefix, d):
updict(info, prefix, d)
up("network", get_network_caps())
up("server", get_server_info())
up("threads", get_thread_info(proto))
up("env", os.environ)
up(
"server", {
"mode": self.get_server_mode(),
"type": "Python",
"start_time": int(self.start_time),
"authenticator": str((self.auth_class or str)("")),
})
if self.session_name:
info["session.name"] = self.session_name
if self.child_reaper:
info.update(self.child_reaper.get_info())
return info
def get_info():
from xpra.net.protocol import get_network_caps
i = get_network_caps()
i["interfaces"] = get_interfaces()
return i
def get_info(): from xpra.net.protocol import get_network_caps i = get_network_caps() i["interfaces"] = get_interfaces() return i
def populate_features(self):
size_info = ""
if self.client.server_actual_desktop_size:
w,h = self.client.server_actual_desktop_size
size_info = "%s*%s" % (w,h)
if self.client.server_randr and self.client.server_max_desktop_size:
size_info += " (max %s)" % ("x".join([str(x) for x in self.client.server_max_desktop_size]))
self.bool_icon(self.server_randr_icon, self.client.server_randr)
self.server_randr_label.set_text("%s" % size_info)
self.bool_icon(self.client_opengl_icon, self.client.client_supports_opengl)
buffering = "n/a"
if self.client.opengl_enabled:
glinfo = "%s / %s" % (self.client.opengl_props.get("vendor", ""), self.client.opengl_props.get("renderer", ""))
display_mode = self.client.opengl_props.get("display_mode", [])
if "DOUBLE" in display_mode:
buffering = "double buffering"
elif "SINGLE" in display_mode:
buffering = "single buffering"
else:
buffering = "unknown"
else:
glinfo = self.client.opengl_props.get("info", "disabled")
self.client_opengl_label.set_text(glinfo)
self.opengl_buffering.set_text(buffering)
scaps = self.client.server_capabilities
self.bool_icon(self.server_mmap_icon, self.client.mmap_enabled)
self.bool_icon(self.server_clipboard_icon, scaps.boolget("clipboard", False))
self.bool_icon(self.server_notifications_icon, scaps.boolget("notifications", False))
self.bool_icon(self.server_bell_icon, scaps.boolget("bell", False))
self.bool_icon(self.server_cursors_icon, scaps.boolget("cursors", False))
def pipeline_info(can_use, sound_pipeline):
if not can_use:
return "" #the icon shows this is not available, status is irrelevant so leave it empty
if sound_pipeline is None or sound_pipeline.codec is None:
return "inactive"
state = sound_pipeline.get_state()
if state!="active":
return state
s = "%s: %s" % (state, sound_pipeline.codec_description)
try:
pid = sound_pipeline.get_info().get("pid")
if pid:
s += " (pid=%s)" % pid
except:
pass
#if sound_pipeline.bitrate>0:
# s += " / %sbit/s" % std_unit(sound_pipeline.bitrate)
return s
def codec_info(enabled, codecs):
if not enabled:
return "n/a"
return ", ".join(codecs or [])
def populate_speaker_info(*args):
can = scaps.boolget("sound.send", False) and self.client.speaker_allowed
self.bool_icon(self.server_speaker_icon, can)
self.speaker_codec_label.set_text(bytestostr(pipeline_info(can, self.client.sound_sink)))
populate_speaker_info()
self.client.connect("speaker-changed", populate_speaker_info)
def populate_microphone_info(*args):
can = scaps.boolget("sound.receive", False) and self.client.microphone_allowed
self.bool_icon(self.server_microphone_icon, can)
self.microphone_codec_label.set_text(bytestostr(pipeline_info(can, self.client.sound_source)))
populate_microphone_info()
self.client.connect("microphone-changed", populate_microphone_info)
#sound/video codec table:
self.server_speaker_codecs_label.set_text(codec_info(scaps.boolget("sound.send", False), scaps.strlistget("sound.encoders", [])))
self.client_speaker_codecs_label.set_text(codec_info(self.client.speaker_allowed, self.client.speaker_codecs))
self.server_microphone_codecs_label.set_text(codec_info(scaps.boolget("sound.receive", False), scaps.strlistget("sound.decoders", [])))
self.client_microphone_codecs_label.set_text(codec_info(self.client.microphone_allowed, self.client.microphone_codecs))
se = scaps.strlistget("encodings.core", scaps.strlistget("encodings"))
self.server_encodings_label.set_text(", ".join(sorted(se)))
self.client_encodings_label.set_text(", ".join(sorted(self.client.get_core_encodings())))
def get_encoder_list(caps):
from xpra.net import packet_encoding
return [x for x in packet_encoding.ALL_ENCODERS if caps.get(x)]
self.client_packet_encoders_label.set_text(", ".join(get_encoder_list(get_network_caps())))
self.server_packet_encoders_label.set_text(", ".join(get_encoder_list(self.client.server_capabilities)))
def get_compressor_list(caps):
from xpra.net import compression
return [x for x in compression.ALL_COMPRESSORS if caps.get(x)]
self.client_packet_compressors_label.set_text(", ".join(get_compressor_list(get_network_caps())))
self.server_packet_compressors_label.set_text(", ".join(get_compressor_list(self.client.server_capabilities)))
return False
def populate_features(self):
size_info = ""
if self.client.server_actual_desktop_size:
w,h = self.client.server_actual_desktop_size
size_info = "%s*%s" % (w,h)
if self.client.server_randr and self.client.server_max_desktop_size:
size_info += " (max %s)" % ("x".join([str(x) for x in self.client.server_max_desktop_size]))
self.bool_icon(self.server_randr_icon, self.client.server_randr)
self.server_randr_label.set_text("%s" % size_info)
self.bool_icon(self.client_opengl_icon, self.client.client_supports_opengl)
buffering = "n/a"
if self.client.opengl_enabled:
glinfo = "%s / %s" % (self.client.opengl_props.get("vendor", ""), self.client.opengl_props.get("renderer", ""))
display_mode = self.client.opengl_props.get("display_mode", [])
if "DOUBLE" in display_mode:
buffering = "double buffering"
elif "SINGLE" in display_mode:
buffering = "single buffering"
else:
buffering = "unknown"
else:
glinfo = self.client.opengl_props.get("info", "")
self.client_opengl_label.set_text(glinfo)
self.opengl_buffering.set_text(buffering)
scaps = self.client.server_capabilities
self.bool_icon(self.server_mmap_icon, self.client.mmap_enabled)
self.bool_icon(self.server_clipboard_icon, scaps.boolget("clipboard", False))
self.bool_icon(self.server_notifications_icon, scaps.boolget("notifications", False))
self.bool_icon(self.server_bell_icon, scaps.boolget("bell", False))
self.bool_icon(self.server_cursors_icon, scaps.boolget("cursors", False))
def pipeline_info(can_use, sound_pipeline):
if not can_use:
return "" #the icon shows this is not available, status is irrelevant so leave it empty
if sound_pipeline is None or sound_pipeline.codec is None:
return "inactive"
state = sound_pipeline.get_state()
if state!="active":
return state
s = "%s: %s" % (state, sound_pipeline.codec_description)
#if sound_pipeline.bitrate>0:
# s += " / %sbit/s" % std_unit(sound_pipeline.bitrate)
return s
def codec_info(enabled, codecs):
if not enabled:
return "n/a"
return ", ".join(codecs or [])
def populate_speaker_info(*args):
can = scaps.boolget("sound.send", False) and self.client.speaker_allowed
self.bool_icon(self.server_speaker_icon, can)
self.speaker_codec_label.set_text(pipeline_info(can, self.client.sound_sink))
populate_speaker_info()
self.client.connect("speaker-changed", populate_speaker_info)
def populate_microphone_info(*args):
can = scaps.boolget("sound.receive", False) and self.client.microphone_allowed
self.bool_icon(self.server_microphone_icon, can)
self.microphone_codec_label.set_text(pipeline_info(can, self.client.sound_source))
populate_microphone_info()
self.client.connect("microphone-changed", populate_microphone_info)
#sound/video codec table:
self.server_speaker_codecs_label.set_text(codec_info(scaps.boolget("sound.send", False), scaps.strlistget("sound.encoders", [])))
self.client_speaker_codecs_label.set_text(codec_info(self.client.speaker_allowed, self.client.speaker_codecs))
self.server_microphone_codecs_label.set_text(codec_info(scaps.boolget("sound.receive", False), scaps.strlistget("sound.decoders", [])))
self.client_microphone_codecs_label.set_text(codec_info(self.client.microphone_allowed, self.client.microphone_codecs))
se = scaps.strlistget("encodings.core", scaps.strlistget("encodings"))
self.server_encodings_label.set_text(", ".join(sorted(se)))
self.client_encodings_label.set_text(", ".join(sorted(self.client.get_core_encodings())))
def get_encoder_list(caps):
from xpra.net import packet_encoding
return [x for x in packet_encoding.ALL_ENCODERS if caps.get(x)]
self.client_packet_encoders_label.set_text(", ".join(get_encoder_list(get_network_caps())))
self.server_packet_encoders_label.set_text(", ".join(get_encoder_list(self.client.server_capabilities)))
def get_compressor_list(caps):
from xpra.net import compression
return [x for x in compression.ALL_COMPRESSORS if caps.get(x)]
self.client_packet_compressors_label.set_text(", ".join(get_compressor_list(get_network_caps())))
self.server_packet_compressors_label.set_text(", ".join(get_compressor_list(self.client.server_capabilities)))
return False
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Network-Info", "Network Info"):
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
print("Network interfaces found:")
for iface in get_interfaces():
if if_nametoindex:
print("* %s (index=%s)" % (iface.ljust(20), if_nametoindex(iface)))
else:
print("* %s" % iface)
def pver(v):
if type(v) in (tuple, list):
s = ""
for i in range(len(v)):
if i>0:
#dot seperated numbers
if type(v[i-1])==int:
s += "."
else:
s += ", "
s += str(v[i])
return s
if type(v)==bytes:
from xpra.os_util import bytestostr
v = bytestostr(v)
if type(v)==str and v.startswith("v"):
return v[1:]
return str(v)
print("Gateways found:")
print_nested_dict(get_gateways())
print("")
print("Protocol Capabilities:")
from xpra.net.protocol import get_network_caps
netcaps = get_network_caps()
netif = {"" : has_netifaces}
if netifaces_version:
netif["version"] = netifaces_version
netcaps["netifaces"] = netif
print_nested_dict(netcaps)
print("")
print("Network Config:")
print_nested_dict(get_net_config())
net_sys = get_net_sys_config()
if net_sys:
print("")
print("Network System Config:")
print_nested_dict(net_sys)
print("")
print("SSL:")
print_nested_dict(get_ssl_info())
try:
from xpra.net.crypto import crypto_backend_init, get_crypto_caps
crypto_backend_init()
ccaps = get_crypto_caps()
if ccaps:
print("")
print("Crypto Capabilities:")
print_nested_dict(ccaps)
except Exception as e:
print("No Crypto:")
print(" %s" % e)
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("Network-Info", "Network Info"):
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
print("Network interfaces found:")
for iface in get_interfaces():
if if_nametoindex:
print("* %s (index=%s)" %
(iface.ljust(20), if_nametoindex(iface)))
else:
print("* %s" % iface)
def pver(v):
if type(v) in (tuple, list):
s = ""
for i in range(len(v)):
if i > 0:
#dot seperated numbers
if type(v[i - 1]) == int:
s += "."
else:
s += ", "
s += str(v[i])
return s
if type(v) == bytes:
from xpra.os_util import bytestostr
v = bytestostr(v)
if type(v) == str and v.startswith("v"):
return v[1:]
return str(v)
print("Gateways found:")
print_nested_dict(get_gateways())
print("")
print("Protocol Capabilities:")
from xpra.net.protocol import get_network_caps
netcaps = get_network_caps()
netif = {"": has_netifaces}
if netifaces_version:
netif["version"] = netifaces_version
netcaps["netifaces"] = netif
print_nested_dict(netcaps)
print("")
print("Network Config:")
print_nested_dict(get_net_config())
net_sys = get_net_sys_config()
if net_sys:
print("")
print("Network System Config:")
print_nested_dict(net_sys)
print("")
print("SSL:")
print_nested_dict(get_ssl_info())
from xpra.net.crypto import crypto_backend_init, get_crypto_caps
crypto_backend_init()
ccaps = get_crypto_caps()
if ccaps:
print("")
print("Crypto Capabilities:")
print_nested_dict(ccaps)
