def do_command(self, caps : typedict):
def print_fn(s):
sys.stdout.write("%s\n" % (s,))
if not caps:
self.quit(EXIT_NO_DATA)
return
exit_code = EXIT_OK
try:
if FLATTEN_INFO<2:
#compatibility mode:
c = flatten_dict(caps)
for k in sorted_nicely(c.keys()):
v = c.get(k)
#FIXME: this is a nasty and horrible python3 workaround (yet again)
#we want to print bytes as strings without the ugly 'b' prefix..
#it assumes that all the strings are raw or in (possibly nested) lists or tuples only
#we assume that all strings we get are utf-8,
#and fallback to the bytestostr hack if that fails
def fixvalue(w):
if isinstance(w, bytes):
if k.endswith(".data"):
return hexstr(w)
return u(w)
elif isinstance(w, (tuple,list)):
return type(w)([fixvalue(x) for x in w])
return w
v = fixvalue(v)
k = fixvalue(k)
print_fn("%s=%s" % (k, nonl(v)))
else:
print_nested_dict(caps, print_fn=print_fn)
except OSError:
exit_code = EXIT_IO_ERROR
self.quit(exit_code)
def main(force_enable=False):
from xpra.platform import program_context
from xpra.platform.gui import init as gui_init
from xpra.util import print_nested_dict
from xpra.log import enable_color
with program_context("OpenGL-Check"):
gui_init()
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
from xpra.client.gl.gtk_compat import log as clog
clog.enable_debug()
# replace ImportError with a log message:
global gl_check_error
errors = []
def log_error(msg):
log.error("ERROR: %s", msg)
errors.append(msg)
gl_check_error = log_error
props = check_support(force_enable, verbose)
log.info("")
if len(errors) > 0:
log.info("OpenGL errors:")
for e in errors:
log.info(" %s", e)
log.info("")
log.info("OpenGL properties:")
print_nested_dict(props)
return len(errors)
def main(force_enable=False):
from xpra.platform import program_context
from xpra.platform.gui import init as gui_init
from xpra.util import print_nested_dict
from xpra.log import enable_color
with program_context("OpenGL-Check"):
gui_init()
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
from xpra.client.gl.gtk_base.gtk_compat import log as clog
clog.enable_debug()
#replace ImportError with a log message:
global gl_check_error
errors = []
def log_error(msg):
log.error("ERROR: %s", msg)
errors.append(msg)
gl_check_error = log_error
props = check_support(force_enable, verbose)
log.info("")
if len(errors) > 0:
log.info("OpenGL errors:")
for e in errors:
log.info(" %s", e)
log.info("")
log.info("OpenGL properties:")
print_nested_dict(props)
return len(errors)
def _process_input_devices(self, _proto, packet):
self.input_devices_format = packet[1]
self.input_devices_data = packet[2]
from xpra.util import print_nested_dict
mouselog("client %s input devices:", self.input_devices_format)
print_nested_dict(self.input_devices_data, print_fn=mouselog)
self.setup_input_devices()
def do_command(self):
if self.server_capabilities:
if FLATTEN_INFO<2:
#compatibility mode:
c = flatten_dict(self.server_capabilities)
for k in sorted_nicely(c.keys()):
v = c.get(k)
if PYTHON3:
#FIXME: this is a nasty and horrible python3 workaround (yet again)
#we want to print bytes as strings without the ugly 'b' prefix..
#it assumes that all the strings are raw or in (possibly nested) lists or tuples only
#we assume that all strings we get are utf-8,
#and fallback to the bytestostr hack if that fails
def fixvalue(w):
if type(w)==bytes:
try:
return w.decode("utf-8")
except:
return bytestostr(w)
elif type(w) in (tuple,list):
return type(w)([fixvalue(x) for x in w])
return w
v = fixvalue(v)
k = fixvalue(k)
log.info("%s=%s", k, nonl(v))
else:
print_nested_dict(self.server_capabilities)
self.quit(EXIT_OK)
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
from xpra.platform import program_context
with program_context("Nvidia-Info", "Nvidia Info"):
#this will log the version number:
get_nvidia_module_version()
if is_blacklisted():
log.warn("Warning: this driver version is blacklisted")
log.info("NVENC license keys:")
for v in (0, 8):
keys = get_license_keys(v)
log.info("* version %s: %s key(s)", v or "common", len(keys))
for k in keys:
log.info(" %s", k)
try:
import pynvml
assert pynvml
except ImportError:
log.warn("Warning: the pynvml library is missing")
log.warn(" cannot identify the GPUs installed")
else:
cards = get_cards()
if cards:
log.info("")
log.info("%i card%s:", len(cards), engs(cards))
print_nested_dict(cards, print_fn=log.info)
def main():
from xpra.platform import program_context #pylint: disable=import-outside-toplevel
with program_context("XDG-Menu-Helper", "XDG Menu Helper"):
for x in list(sys.argv):
if x in ("-v", "--verbose"):
sys.argv.remove(x)
add_debug_category("menu")
log.enable_debug()
def icon_fmt(icondata):
return "%i bytes" % len(icondata)
if len(sys.argv) > 1:
for x in sys.argv[1:]:
if os.path.isabs(x):
v = icon_util.load_icon_from_file(x)
print("load_icon_from_file(%s)=%s" % (x, v))
else:
menu = load_xdg_menu_data()
if menu:
print()
print("application menu:")
print_nested_dict(menu, vformat={"IconData": icon_fmt})
else:
print("no application menu data found")
#try desktop sessions:
sessions = load_desktop_sessions()
if sessions:
print()
print("session menu:")
print_nested_dict(sessions, vformat={"IconData": icon_fmt})
else:
print("no session menu data found")
return 0
def main():
from xpra.platform import program_context
from xpra.util import print_nested_dict
from xpra.log import enable_color
with program_context("GUI-Properties"):
enable_color()
init()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
from xpra.log import get_all_loggers
for x in get_all_loggers():
x.enable_debug()
# naughty, but how else can I hook this up?
import os
if os.name == "posix":
try:
from xpra.x11.bindings import posix_display_source # @UnusedImport
except:
pass # maybe running on OSX? hope for the best..
i = get_info()
print_nested_dict(i)
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Features-Info", "Features Info"):
d = {}
for k in _features_list_:
d[k] = globals()[k]
print_nested_dict(d)
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Features-Info", "Features Info"):
d = {}
for k in _features_list_:
d[k] = globals()[k]
print_nested_dict(d)
def main(args):
from xpra.platform import program_context
from xpra.log import enable_color, LOG_FORMAT, NOPREFIX_FORMAT
from xpra.util import print_nested_dict, pver
with program_context("Loader", "Encoding Info"):
verbose = "-v" in args or "--verbose" in args
args = [x for x in args if x not in ("-v", "--verbose")]
format_string = NOPREFIX_FORMAT
if verbose:
format_string = LOG_FORMAT
log.enable_debug()
enable_color(format_string)
if len(args)>1:
for x in args[1:]:
load_codec(x)
list_codecs = args[1:]
else:
load_codecs()
list_codecs = ALL_CODECS
#not really a codec, but gets used by codecs, so include version info:
add_codec_version("numpy", "numpy")
print("codecs and csc modules found:")
#print("codec_status=%s" % codecs)
for name in sorted(list_codecs):
mod = codecs.get(name, "")
f = mod
if mod and hasattr(mod, "__file__"):
f = mod.__file__
if f.startswith(os.getcwd()):
f = f[len(os.getcwd()):]
if f.startswith(os.path.sep):
f = f[1:]
print("* %s : %s" % (name.ljust(20), f))
if mod and verbose:
try:
if name.find("csc")>=0:
cs = list(mod.get_input_colorspaces())
for c in list(cs):
cs += list(mod.get_output_colorspaces(c))
print(" colorspaces: %s" % csv(list(set(cs))))
elif name.find("enc")>=0 or name.find("dec")>=0:
encodings = mod.get_encodings()
print(" encodings: %s" % csv(encodings))
try:
i = mod.get_info()
for k,v in sorted(i.items()):
print(" %s = %s" % (k,v))
except Exception:
pass
except Exception as e:
print("error getting extra information on %s: %s" % (name, e))
print("")
print("codecs versions:")
def forcever(v):
return pver(v, numsep=".", strsep=".").lstrip("v")
print_nested_dict(codec_versions, vformat=forcever)
return 0
def main():
from xpra.util import print_nested_dict
crypto_backend_init()
from xpra.platform import program_context
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
with program_context("Encryption Properties"):
print_nested_dict(get_crypto_caps())
def main():
from xpra.util import print_nested_dict
crypto_backend_init()
from xpra.platform import program_context
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
with program_context("Encryption Properties"):
print_nested_dict(get_crypto_caps())
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.log import add_debug_category
add_debug_category("util")
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Path-Info", "Path Info"):
print_nested_dict(get_info())
def main():
import sys
from xpra.platform.win32.common import WTSGetActiveConsoleSessionId
csid = WTSGetActiveConsoleSessionId()
print("WTSGetActiveConsoleSessionId()=%s" % csid)
print_nested_dict(get_sessions())
if len(sys.argv)>1:
for x in sys.argv[1:]:
print("find_session(%s)=%s" % (x, find_session(x)))
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
add_debug_category("nvfbc")
from xpra.platform import program_context
with program_context("NvFBC-Capture", "NvFBC Capture"):
from xpra.platform.paths import get_download_dir
from xpra.util import print_nested_dict
from xpra.os_util import WIN32, LINUX
if WIN32:
from xpra.codecs.nvfbc import fbc_capture_win as fbc_capture #@UnresolvedImport @UnusedImport
elif LINUX:
from xpra.codecs.nvfbc import fbc_capture_linux as fbc_capture #@UnresolvedImport @Reimport
else:
raise Exception("nvfbc is not support on %s" % sys.platform)
fbc_capture.init_module()
log.info("Info:")
print_nested_dict(fbc_capture.get_info(), print_fn=log.info)
log.info("Status:")
print_nested_dict(fbc_capture.get_status(), print_fn=log.info)
try:
log("creating test capture class")
if USE_NVFBC_CUDA:
c = fbc_capture.NvFBC_CUDACapture() #@UndefinedVariable
else:
c = fbc_capture.NvFBC_SysCapture() #@UndefinedVariable
log("Capture=%s", c)
c.init_context()
assert c.refresh()
except Exception as e:
log("Capture()", exc_info=True)
log.error("Error: failed to create test capture instance:")
log.error(" %s", e)
return 1
image = c.get_image()
assert image
from PIL import Image
w = image.get_width()
h = image.get_height()
pixels = memoryview_to_bytes(image.get_pixels())
stride = image.get_rowstride()
rgb_format = image.get_pixel_format()
try:
img = Image.frombuffer("RGB", (w, h), pixels, "raw", rgb_format,
stride, 1)
filename = os.path.join(
os.path.expanduser(get_download_dir()),
"screenshot-%s-%i.png" % (rgb_format, time.time()))
img.save(filename, "png")
log.info("screenshot saved to %s", filename)
return 0
except Exception as e:
log.warn("Error: failed to save %s:", rgb_format)
log.warn(" %s", e)
return 1
def main():
#use gtk as display source:
from xpra.x11.gtk2 import gdk_display_source
assert gdk_display_source
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("GTK-Keyboard", "GTK Keyboard"):
x = GTKKeyboardHelper(None, True, "")
x.query_xkbmap()
print_nested_dict(x.get_keymap_properties())
def main():
#use gtk as display source:
from xpra.x11.gtk2 import gdk_display_source
assert gdk_display_source
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("GTK-Keyboard", "GTK Keyboard"):
x = GTKKeyboardHelper(None, True, "")
x.query_xkbmap()
print_nested_dict(x.get_keymap_properties())
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.util import print_nested_dict
with program_context("Pulseaudio-Info"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
i = get_info()
print_nested_dict(i)
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.util import print_nested_dict
with program_context("Pulseaudio-Info"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
i = get_info()
print_nested_dict(i)
def main():
import sys
from xpra.os_util import WIN32, OSX, POSIX, bytestostr
from xpra.util import print_nested_dict, csv
from xpra.platform import program_context
from xpra.log import Logger, enable_color
with program_context("Keyboard-Tool", "Keyboard Tool"):
#use the logger for the platform module we import from
global log
log = None
platform_import(globals(), "keyboard", True, "log")
if log is None:
log = Logger("keyboard")
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv or \
(WIN32 and not ("-q" in sys.argv or "--quiet"))
if verbose:
log.enable_debug()
#naughty, but how else can I hook this up?
if POSIX and not OSX:
try:
from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport
init_posix_display_source()
except Exception as e:
print("failed to connect to the X11 server:")
print(" %s" % e)
#hope for the best..
keyboard = Keyboard()
mod_meanings, mod_managed, mod_pointermissing = keyboard.get_keymap_modifiers(
)
print("Modifiers:")
print_nested_dict(mod_meanings)
print("")
print("Server Managed : %s" %
(csv(mod_managed) or "None"))
print("Missing from pointer events : %s" %
(csv(mod_pointermissing) or "None"))
print("")
layout, layouts, variant, variants, options = keyboard.get_layout_spec(
)
print("Layout: '%s'" % bytestostr(layout or b""))
print("Layouts: %s" % csv("'%s'" % x for x in (layouts or [])))
print("Variant: '%s'" % bytestostr(variant or b""))
print("Variants: %s" % csv("'%s'" % x for x in (variants or [])))
print("Options: %s" % (options))
print("")
print("Repeat: %s" % csv(keyboard.get_keyboard_repeat()))
if verbose and POSIX:
keysyms = keyboard.get_x11_keymap()
if keysyms:
print("Keysyms:")
for keycode, keysyms in keysyms.items():
print(" %3i : %s" % (keycode, csv(keysyms)))
def main():
#use gtk as display source:
from xpra.os_util import POSIX, OSX
if POSIX and not OSX:
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
init_gdk_display_source()
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("GTK-Keyboard", "GTK Keyboard"):
x = GTKKeyboardHelper(None, True, "")
x.query_xkbmap()
print_nested_dict(x.get_keymap_properties())
def main():
import sys
import socket
from xpra.os_util import POSIX
from xpra.util import print_nested_dict
from xpra.net.net_util import import_netifaces, get_interfaces, if_nametoindex
from xpra.platform import program_context
from xpra.log import Logger, enable_color, add_debug_category, enable_debug_for
log = Logger("network")
with program_context("Network-Device-Info", "Network Device Info"):
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
enable_debug_for("network")
add_debug_category("network")
log.enable_debug()
print("Network interfaces found:")
netifaces = import_netifaces()
for iface in get_interfaces():
if if_nametoindex:
print("* %s (index=%s)" %
(iface.ljust(20), if_nametoindex(iface)))
else:
print("* %s" % iface)
addresses = netifaces.ifaddresses(iface) #@UndefinedVariable
for addr, defs in addresses.items():
if addr in (socket.AF_INET, socket.AF_INET6):
for d in defs:
ip = d.get("addr")
if ip:
stype = {
socket.AF_INET: "IPv4",
socket.AF_INET6: "IPv6",
}[addr]
print(" * %s: %s" % (stype, ip))
if POSIX:
from xpra.net.socket_util import create_tcp_socket
try:
sock = create_tcp_socket(ip, 0)
sockfd = sock.fileno()
info = get_interface_info(sockfd, iface)
if info:
print_nested_dict(info,
prefix=" ",
lchar="-")
finally:
sock.close()
if not POSIX:
info = get_interface_info(0, iface)
if info:
print(" %s" % info)
def main():
from xpra.platform import program_context
from xpra.log import enable_color
with program_context("GTK-Version-Info", "GTK Version Info"):
enable_color()
print("%s" % get_gtk_version_info())
if POSIX and not OSX:
from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport
init_posix_display_source()
import warnings
warnings.simplefilter("ignore")
print(get_screen_sizes()[0])
print_nested_dict(get_screens_info()[0])
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.util import print_nested_dict, pver
with program_context("Loader", "Encoding Info"):
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
load_codecs()
print("codecs and csc modules found:")
#print("codec_status=%s" % codecs)
for name in sorted(ALL_CODECS):
mod = codecs.get(name, "")
f = mod
if mod and hasattr(mod, "__file__"):
f = mod.__file__
if f.startswith(os.getcwd()):
f = f[len(os.getcwd()):]
if f.startswith(os.path.sep):
f = f[1:]
print("* %s : %s" % (name.ljust(20), f))
if mod and verbose:
try:
if name.find("csc") >= 0:
cs = list(mod.get_input_colorspaces())
for c in list(cs):
cs += list(mod.get_output_colorspaces(c))
print(" colorspaces: %s" %
", ".join(list(set(cs))))
elif name.find("enc") >= 0 or name.find("dec") >= 0:
encodings = mod.get_encodings()
print(" encodings: %s" %
", ".join(encodings))
try:
i = mod.get_info()
for k, v in sorted(i.items()):
print(" %s = %s" % (k, v))
except:
pass
except Exception as e:
print("error getting extra information on %s: %s" %
(name, e))
print("")
print("codecs versions:")
def forcever(v):
return pver(v, numsep=".", strsep=".").lstrip("v")
print_nested_dict(codec_versions, vformat=forcever)
def log_ssl_info(ssl_sock):
from xpra.log import Logger
ssllog = Logger("ssl")
ssllog("server_hostname=%s", ssl_sock.server_hostname)
cipher = ssl_sock.cipher()
if cipher:
ssllog.info(" %s, %s bits", cipher[0], cipher[2])
try:
cert = ssl_sock.getpeercert()
except ValueError:
pass
else:
if cert:
ssllog("certificate:")
print_nested_dict(ssl_sock.getpeercert(), prefix=" ", print_fn=ssllog)
def main():
from xpra.platform import program_context
with program_context("XDG-Menu-Helper", "XDG Menu Helper"):
for x in list(sys.argv):
if x in ("-v", "--verbose"):
sys.argv.remove(x)
add_debug_category("menu")
log.enable_debug()
def icon_fmt(icondata):
return "%i bytes" % len(icondata)
menu = load_xdg_menu_data()
print_nested_dict(menu, vformat={"IconData": icon_fmt})
return 0
def main():
from xpra.codecs.loader import log as loader_log, load_codecs
from xpra.util import print_nested_dict
from xpra.log import enable_color
from xpra.platform import program_context
with program_context("Video Helper"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
loader_log.enable_debug()
log.enable_debug()
load_codecs()
vh = getVideoHelper()
vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS)
vh.init()
info = vh.get_info()
print_nested_dict(info)
def main():
from xpra.codecs.loader import log as loader_log, load_codecs
from xpra.util import print_nested_dict
from xpra.log import enable_color
from xpra.platform import program_context
with program_context("Video Helper"):
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv:
loader_log.enable_debug()
log.enable_debug()
load_codecs()
vh = getVideoHelper()
vh.set_modules(ALL_VIDEO_ENCODER_OPTIONS, ALL_CSC_MODULE_OPTIONS, ALL_VIDEO_DECODER_OPTIONS)
vh.init()
log.info("VideoHelper.get_info():")
info = vh.get_info()
print_nested_dict(info)
def main():
from xpra.platform import program_context
from xpra.log import enable_color
from xpra.util import print_nested_dict, pver
with program_context("Loader", "Encoding Info"):
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
load_codecs()
print("codecs and csc modules found:")
#print("codec_status=%s" % codecs)
for name in sorted(ALL_CODECS):
mod = codecs.get(name, "")
f = mod
if mod and hasattr(mod, "__file__"):
f = mod.__file__
if f.startswith(os.getcwd()):
f = f[len(os.getcwd()):]
if f.startswith(os.path.sep):
f = f[1:]
print("* %s : %s" % (name.ljust(20), f))
if mod and verbose:
try:
if name.find("csc")>=0:
cs = list(mod.get_input_colorspaces())
for c in list(cs):
cs += list(mod.get_output_colorspaces(c))
print(" colorspaces: %s" % ", ".join(list(set(cs))))
elif name.find("enc")>=0 or name.find("dec")>=0:
encodings = mod.get_encodings()
print(" encodings: %s" % ", ".join(encodings))
try:
i = mod.get_info()
for k,v in sorted(i.items()):
print(" %s = %s" % (k,v))
except:
pass
except Exception as e:
print("error getting extra information on %s: %s" % (name, e))
print("")
print("codecs versions:")
def forcever(v):
return pver(v, numsep=".", strsep=".").lstrip("v")
print_nested_dict(codec_versions, vformat=forcever)
def main():
from xpra.platform import program_context
from xpra.platform.gui import init as gui_init
from xpra.util import print_nested_dict
from xpra.log import enable_color
with program_context("OpenGL-Check"):
gui_init()
enable_color()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
log.enable_debug()
if POSIX and not OSX:
from xpra.x11.gtk_x11.gdk_display_source import init_gdk_display_source
init_gdk_display_source()
force_enable = "-f" in sys.argv or "--force" in sys.argv
from xpra.platform.gl_context import GLContext
log("testing %s", GLContext)
gl_context = GLContext()
log("GLContext=%s", gl_context)
#replace ImportError with a log message:
global gl_check_error, raise_fatal_error
errors = []
def log_error(msg):
log.error("ERROR: %s", msg)
errors.append(msg)
gl_check_error = log_error
raise_fatal_error = log_error
try:
props = gl_context.check_support(force_enable)
except Exception as e:
props = {}
log("check_support", exc_info=True)
errors.append(e)
log.info("")
if len(errors) > 0:
log.info("OpenGL errors:")
for e in errors:
log.info(" %s", e)
if props:
log.info("")
log.info("OpenGL properties:")
print_nested_dict(props)
return len(errors)
def main():
from xpra.os_util import load_binary_file
if "-v" in sys.argv:
log.enable_debug()
sys.argv.remove("-v")
if len(sys.argv)>1:
for filename in sys.argv[1:]:
if not os.path.exists(filename):
log.warn("file argument '%s' does not exist, ignoring", filename)
continue
data = load_binary_file(filename)
devices = do_get_pa_device_options(data, True, False)
log.info("%s devices found in '%s'", len(devices), filename)
print_nested_dict(devices)
return
i = get_info()
print_nested_dict(i)
def main():
from xpra.os_util import load_binary_file
if "-v" in sys.argv:
log.enable_debug()
sys.argv.remove("-v")
if len(sys.argv)>1:
for filename in sys.argv[1:]:
if not os.path.exists(filename):
log.warn("file argument '%s' does not exist, ignoring", filename)
continue
data = load_binary_file(filename)
devices = do_get_pa_device_options(data, True, False)
log.info("%s devices found in '%s'", len(devices), filename)
print_nested_dict(devices)
return
i = get_info()
print_nested_dict(i)
def main():
from xpra.util import nonl, pver, flatten_dict, print_nested_dict
def print_version_dict(d, vformat=pver):
for k in sorted(d.keys()):
v = d[k]
print("* %-48s : %s" % (str(k).replace(".version", "").ljust(12), nonl(vformat(v))))
from xpra.platform import program_context
with program_context("GTK-Version-Info", "GTK Version Info"):
from xpra.platform.gui import init as gui_init, ready
gui_init()
ready()
from xpra.gtk_common import gtk_util
if "-v" in sys.argv or "--verbose" in sys.argv:
gtk_util.SHOW_ALL_VISUALS = True
print("GTK Version:")
print_version_dict(flatten_dict(gtk_util.get_gtk_version_info()))
print("Display:")
print_nested_dict(gtk_util.get_display_info(), vformat=str)
def main():
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.log import add_debug_category, enable_debug_for
enable_debug_for("webcam")
add_debug_category("webcam")
run = "-r" in sys.argv or "--run" in sys.argv
if run:
from xpra.gtk_common.gobject_compat import import_glib, import_gobject
glib = import_glib()
gobject = import_gobject()
gobject.threads_init()
from xpra.util import engs, print_nested_dict
from xpra.platform import program_context
with program_context("Webcam Info", "Webcam Info"):
devices = get_virtual_video_devices() or {}
log.info("Found %i virtual video device%s:", len(devices),
engs(devices))
print_nested_dict(devices)
all_devices = get_all_video_devices() or {}
log.info("Found %i video device%s in total:", len(all_devices),
engs(all_devices))
print_nested_dict(all_devices)
if run:
log.info("add watch for video device changes")
def callback(added=None, device=None):
if added is not None or device:
log.info("video device %s: %s", ["removed",
"added"][added], device)
else:
log.info("device change")
log.info("starting main loop")
main_loop = glib.MainLoop()
glib.idle_add(add_video_device_change_callback, callback)
try:
main_loop.run()
except KeyboardInterrupt:
pass
log.info("terminating, removing callback")
remove_video_device_change_callback(callback)
def main():
import sys
from xpra.util import print_nested_dict, csv
from xpra.platform import program_context
from xpra.log import Logger, enable_color
with program_context("Keyboard-Tool", "Keyboard Tool"):
#use the logger for the platform module we import from
global log
log = None
platform_import(globals(), "keyboard", True, "log")
if log is None:
log = Logger("keyboard")
enable_color()
if "-v" in sys.argv or "--verbose" in sys.argv or \
(sys.platform.startswith("win") and not ("-q" in sys.argv or "--quiet")):
log.enable_debug()
#naughty, but how else can I hook this up?
import os
if os.name == "posix":
try:
from xpra.x11.bindings import posix_display_source #@UnusedImport
except:
pass #maybe running on OSX? hope for the best..
keyboard = Keyboard()
mod_meanings, mod_managed, mod_pointermissing = keyboard.get_keymap_modifiers(
)
print("Modifiers:")
print_nested_dict(mod_meanings)
print("")
print("Server Managed : %s" %
(csv(mod_managed) or "None"))
print("Missing from pointer events : %s" %
(csv(mod_pointermissing) or "None"))
print("")
layout, layouts, variant, variants = keyboard.get_layout_spec()
print("Layout: '%s'" % (layout))
print("Layouts: %s" % (layouts, ))
print("Variant: '%s'" % (variant or ""))
print("Variants: %s" % (variants, ))
print("")
print("Repeat: %s" % csv(keyboard.get_keyboard_repeat()))
def main():
from xpra.platform import program_context
from xpra.util import print_nested_dict
from xpra.os_util import OSX, POSIX
from xpra.log import enable_color
with program_context("GUI-Properties"):
enable_color()
init()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
from xpra.log import get_all_loggers
for x in get_all_loggers():
x.enable_debug()
#naughty, but how else can I hook this up?
if POSIX and not OSX:
from xpra.x11.bindings.posix_display_source import init_posix_display_source #@UnresolvedImport
init_posix_display_source()
i = get_info()
print_nested_dict(i, hex_keys=("data", "icc-data", "icc-profile"))
return 0
def do_command(self):
if self.server_capabilities:
if FLATTEN_INFO<2:
#compatibility mode:
for k in sorted_nicely(self.server_capabilities.keys()):
v = self.server_capabilities.get(k)
if sys.version_info[0]>=3:
#FIXME: this is a nasty and horrible python3 workaround (yet again)
#we want to print bytes as strings without the ugly 'b' prefix..
#it assumes that all the strings are raw or in (possibly nested) lists or tuples only
def fixvalue(w):
if type(w)==bytes:
return bytestostr(w)
elif type(w) in (tuple,list):
return type(w)([fixvalue(x) for x in w])
return w
v = fixvalue(v)
log.info("%s=%s", bytestostr(k), nonl(v))
else:
print_nested_dict(self.server_capabilities)
self.quit(EXIT_OK)
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
from xpra.platform import program_context
with program_context("Nvidia-Info", "Nvidia Info"):
#this will log the version number:
get_nvidia_module_version()
if is_blacklisted():
log.warn("Warning: this driver version is blacklisted")
log.info("NVENC license keys:")
for v in (0, 7):
keys = get_nvenc_license_keys(v)
log.info("* version %s: %s key(s)", v or "common", len(keys))
for k in keys:
log.info(" %s", k)
cards = get_cards()
if cards:
log.info("")
log.info("%i card%s:", len(cards), engs(cards))
print_nested_dict(cards, print_fn=log.info)
def main():
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
from xpra.platform import program_context
with program_context("Nvidia-Info", "Nvidia Info"):
#this will log the version number:
get_nvidia_module_version()
if is_blacklisted():
log.warn("Warning: this driver version is blacklisted")
log.info("NVENC license keys:")
for v in (0, 7):
keys = get_nvenc_license_keys(v)
log.info("* version %s: %s key(s)", v or "common", len(keys))
for k in keys:
log.info(" %s", k)
cards = get_cards()
if cards:
log.info("")
log.info("%i card%s:", len(cards), engs(cards))
print_nested_dict(cards, print_fn=log.info)
def main():
from xpra.platform import program_context
from xpra.util import print_nested_dict
from xpra.log import enable_color
with program_context("GUI-Properties"):
enable_color()
init()
verbose = "-v" in sys.argv or "--verbose" in sys.argv
if verbose:
from xpra.log import get_all_loggers
for x in get_all_loggers():
x.enable_debug()
#naughty, but how else can I hook this up?
if os.name == "posix":
try:
from xpra.x11.bindings import posix_display_source #@UnusedImport
except:
pass #maybe running on OSX? hope for the best..
i = get_info()
print_nested_dict(i, hex_keys=("data", "icc-data", "icc-profile"))
def main():
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
from xpra.log import add_debug_category
add_debug_category("webcam")
run = "-r" in sys.argv or "--run" in sys.argv
if run:
from xpra.gtk_common.gobject_compat import import_glib, import_gobject
glib = import_glib()
gobject = import_gobject()
gobject.threads_init()
from xpra.util import engs, print_nested_dict
from xpra.platform import program_context
with program_context("Webcam Info", "Webcam Info"):
devices = get_virtual_video_devices() or {}
log.info("Found %i virtual video device%s:", len(devices), engs(devices))
print_nested_dict(devices)
all_devices = get_all_video_devices() or {}
log.info("Found %i video device%s in total:", len(all_devices), engs(all_devices))
print_nested_dict(all_devices)
if run:
log.info("add watch for video device changes")
def callback(added=None, device=None):
if added is not None or device:
log.info("video device %s: %s", ["removed", "added"][added], device)
else:
log.info("device change")
log.info("starting main loop")
main_loop = glib.MainLoop()
glib.idle_add(add_video_device_change_callback, callback)
try:
main_loop.run()
except KeyboardInterrupt:
pass
log.info("terminating, removing callback")
remove_video_device_change_callback(callback)
def main():
import sys
if "-v" in sys.argv or "--verbose" in sys.argv:
log.enable_debug()
from xpra.platform import program_context
with program_context("CUDA-Info", "CUDA Info"):
log.info("pycuda_info")
print_nested_dict(get_pycuda_info(), print_fn=log.info)
log.info("cuda_info")
print_nested_dict(get_cuda_info(), print_fn=log.info)
log.info("preferences:")
print_nested_dict(get_prefs())
def main():
from xpra.platform import program_context
with program_context("Version-Info", "Version Info"):
print("Build:")
print_nested_dict(get_version_info())
print("")
print("Platform:")
pi = get_platform_info()
#ugly workaround for the fact that "sys.platform" has no key..
if "" in pi:
pi["sys"] = pi[""]
del pi[""]
print_nested_dict(pi)
print("")
print("Host:")
d = get_host_info()
#add os specific version info:
try:
from xpra.platform.info import get_version_info as pvinfo
d.update(pvinfo())
except:
pass
print_nested_dict(d)
"BGRA" : ("YUV2BGRA_I420", "BGRA2YUV_I420"),
"BGRX" : ("YUV2BGRA_I420", "BGRA2YUV_I420"),
}.items():
fromyuv, toyuv = conv
for src_fmt, dst_fmt, conv_const in (
("YUV420P", rgb_fmt, fromyuv),
(rgb_fmt, "YUV420P", toyuv),
):
f = "COLOR_%s" % conv_const
v = getattr(cv2, f, None)
if v is not None:
FLAG_STR[int(v)] = conv_const
CONVERSIONS.setdefault(src_fmt, {})[dst_fmt] = int(v)
log("csc_opencv FLAGS: %s", FLAG_STR)
log("csc_opencv CONVERSIONS:")
print_nested_dict(CONVERSIONS, print_fn=log)
def get_input_colorspaces():
#we don't handle planar input yet:
return [x for x in CONVERSIONS.keys() if x!="YUV420P"]
def get_output_colorspaces(input_colorspace):
return CONVERSIONS[input_colorspace]
def get_spec(in_colorspace, out_colorspace):
assert in_colorspace in CONVERSIONS, "invalid input colorspace: %s (must be one of %s)" % (in_colorspace, get_input_colorspaces())
out_cs = CONVERSIONS[in_colorspace]
assert out_colorspace in out_cs, "invalid output colorspace: %s (must be one of %s)" % (out_colorspace, out_cs)
#low score as this should be used as fallback only:
return csc_spec(ColorspaceConverter, codec_type=get_type(), quality=50, speed=0, setup_cost=40, min_w=2, min_h=2, max_w=16*1024, max_h=16*1024, can_scale=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 start_proxy(self, client_proto, c, auth_caps):
def disconnect(reason, *extras):
log("disconnect(%s, %s)", reason, extras)
self.send_disconnect(client_proto, reason, *extras)
#find the target server session:
if not client_proto.authenticator:
log.error("Error: the proxy server requires an authentication mode,")
try:
log.error(" client connection '%s' does not specify one", client_proto._conn.socktype)
except:
pass
log.error(" use 'none' to disable authentication")
disconnect(SESSION_NOT_FOUND, "no sessions found")
return
try:
sessions = client_proto.authenticator.get_sessions()
except Exception as e:
authlog("failed to get the list of sessions", exc_info=True)
authlog.error("Error: failed to get the list of sessions using '%s' authenticator", client_proto.authenticator)
authlog.error(" %s", e)
disconnect(AUTHENTICATION_ERROR, "cannot access sessions")
return
authlog("start_proxy(%s, {..}, %s) found sessions: %s", client_proto, auth_caps, sessions)
if sessions is None:
disconnect(SESSION_NOT_FOUND, "no sessions found")
return
uid, gid, displays, env_options, session_options = sessions
if os.name=="posix":
if uid==0 or gid==0:
log.error("Error: proxy instances should not run as root")
log.error(" use a different uid and gid (ie: nobody)")
disconnect(AUTHENTICATION_ERROR, "cannot run proxy instances as root")
return
username = get_username_for_uid(uid)
groups = get_groups(username)
if "xpra" not in groups:
log.error("Error: user '%s' (uid=%i) is not in the xpra group", username, uid)
log.error(" it belongs to: %s", csv(groups) or None)
disconnect(PERMISSION_ERROR, "user missing 'xpra' group membership")
return
#ensure we don't loop back to the proxy:
proxy_virtual_display = os.environ.get("DISPLAY")
if proxy_virtual_display in displays:
displays.remove(proxy_virtual_display)
#remove proxy instance virtual displays:
displays = [x for x in displays if not x.startswith(":proxy-")]
#log("unused options: %s, %s", env_options, session_options)
opts = make_defaults_struct()
display = None
proc = None
sns = c.dictget("start-new-session")
authlog("start_proxy: displays=%s, start-new-session=%s", displays, bool(sns))
if len(displays)==0 or sns:
if self._start_sessions:
#start a new session
mode = sns.get("mode", "start")
assert mode in ("start", "start-desktop", "shadow"), "invalid start-new-session mode '%s'" % mode
sns = typedict(sns)
display = sns.get("display")
args = []
if display:
args = [display]
start = sns.strlistget("start")
start_child = sns.strlistget("start-child")
exit_with_children = sns.boolget("exit-with-children")
exit_with_client = sns.boolget("exit-with-client")
log("starting new server subprocess: mode=%s, socket-dir=%s, socket-dirs=%s, start=%s, start-child=%s, exit-with-children=%s, exit-with-client=%s, uid=%s, gid=%s",
mode, opts.socket_dir, opts.socket_dirs, start, start_child, exit_with_children, exit_with_client, uid, gid)
try:
proc, socket_path = start_server_subprocess(sys.argv[0], args, mode, opts,
opts.socket_dir, opts.socket_dirs,
start, start_child,
exit_with_children, exit_with_client,
uid=uid, gid=gid)
display = "socket:%s" % socket_path
except Exception as e:
log("start_server_subprocess failed", exc_info=True)
log.error("Error: failed to start server subprocess:")
log.error(" %s", e)
disconnect(SERVER_ERROR, "failed to start a new session")
return
if proc:
self.child_reaper.add_process(proc, "server-%s" % display, "xpra start", True, True)
else:
disconnect(SESSION_NOT_FOUND, "no displays found")
return
if display is None:
display = c.strget("display")
authlog("start_proxy: proxy-virtual-display=%s (ignored), user specified display=%s, found displays=%s", proxy_virtual_display, display, displays)
if display==proxy_virtual_display:
disconnect(SESSION_NOT_FOUND, "invalid display")
return
if display:
if display not in displays:
disconnect(SESSION_NOT_FOUND, "display '%s' not found" % display)
return
else:
if len(displays)!=1:
disconnect(SESSION_NOT_FOUND, "please specify a display, more than one is available: %s" % csv(displays))
return
display = displays[0]
def stop_server_subprocess():
if proc:
proc.terminate()
log("start_proxy(%s, {..}, %s) using server display at: %s", client_proto, auth_caps, display)
def parse_error(*args):
stop_server_subprocess()
disconnect(SESSION_NOT_FOUND, "invalid display string")
log.warn("Error: parsing failed for display string '%s':", display)
for arg in args:
log.warn(" %s", arg)
raise Exception("parse error on %s: %s" % (display, args))
opts.username = client_proto.authenticator.username
disp_desc = parse_display_name(parse_error, opts, display)
if uid or gid:
disp_desc["uid"] = uid
disp_desc["gid"] = gid
log("display description(%s) = %s", display, disp_desc)
try:
server_conn = connect_to(disp_desc, opts)
except Exception as e:
log("cannot connect", exc_info=True)
log.error("Error: cannot start proxy connection:")
log.error(" %s", e)
log.error(" connection definition:")
print_nested_dict(disp_desc, prefix=" ", lchar="*", pad=20, print_fn=log.error)
disconnect(SESSION_NOT_FOUND, "failed to connect to display")
stop_server_subprocess()
return
log("server connection=%s", server_conn)
#no other packets should be arriving until the proxy instance responds to the initial hello packet
def unexpected_packet(packet):
if packet:
log.warn("Warning: received an unexpected packet on the proxy connection %s:", client_proto)
log.warn(" %s", repr_ellipsized(packet))
client_conn = client_proto.steal_connection(unexpected_packet)
client_state = client_proto.save_state()
cipher = None
encryption_key = None
if auth_caps:
cipher = auth_caps.get("cipher")
if cipher:
encryption_key = self.get_encryption_key(client_proto.authenticator, client_proto.keyfile)
log("start_proxy(..) client connection=%s", client_conn)
log("start_proxy(..) client state=%s", client_state)
#this may block, so run it in a thread:
def do_start_proxy():
log("do_start_proxy()")
message_queue = MQueue()
try:
ioe = client_proto.wait_for_io_threads_exit(5+self._socket_timeout)
if not ioe:
log.error("Error: some network IO threads have failed to terminate")
return
client_conn.set_active(True)
process = ProxyInstanceProcess(uid, gid, env_options, session_options, self._socket_dir,
self.video_encoders, self.csc_modules,
client_conn, client_state, cipher, encryption_key, server_conn, c, message_queue)
log("starting %s from pid=%s", process, os.getpid())
self.processes[process] = (display, message_queue)
process.start()
log("process started")
popen = process._popen
assert popen
#when this process dies, run reap to update our list of proxy processes:
self.child_reaper.add_process(popen, "xpra-proxy-%s" % display, "xpra-proxy-instance", True, True, self.reap)
finally:
#now we can close our handle on the connection:
client_conn.close()
server_conn.close()
message_queue.put("socket-handover-complete")
start_thread(do_start_proxy, "start_proxy(%s)" % client_conn)
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Compression", "Compression Info"):
print_nested_dict(get_compression_caps())
def main():
from xpra.util import print_nested_dict
from xpra.platform import program_context
with program_context("Packet Encoding", "Packet Encoding Info"):
print_nested_dict(get_packet_encoding_caps())
def parse_shortcuts(self, strs):
#TODO: maybe parse with re instead?
if len(strs)==0:
""" if none are defined, add this as default
it would be nicer to specify it via OptionParser in main
but then it would always have to be there with no way of removing it
whereas now it is enough to define one (any shortcut)
"""
strs = ["meta+shift+F4:quit"]
log("parse_shortcuts(%s)" % str(strs))
shortcuts = {}
#modifier names contains the internal modifiers list, ie: "mod1", "control", ...
#but the user expects the name of the key to be used, ie: "alt" or "super"
#whereas at best, we keep "Alt_L" : "mod1" mappings... (xposix)
#so generate a map from one to the other:
modifier_names = {}
meanings = self.xkbmap_mod_meanings or DEFAULT_MODIFIER_MEANINGS
DEFAULT_MODIFIER_IGNORE_KEYNAMES = ["Caps_Lock", "Num_Lock", "Scroll_Lock"]
for pub_name,mod_name in meanings.items():
if mod_name in DEFAULT_MODIFIER_NUISANCE or pub_name in DEFAULT_MODIFIER_IGNORE_KEYNAMES:
continue
#just hope that xxx_L is mapped to the same modifier as xxx_R!
if pub_name.endswith("_L") or pub_name.endswith("_R"):
pub_name = pub_name[:-2]
elif pub_name=="ISO_Level3_Shift":
pub_name = "AltGr"
if pub_name not in modifier_names:
modifier_names[pub_name.lower()] = mod_name
if pub_name.lower()=="control":
#alias "control" to "ctrl" as it is often used:
modifier_names["ctrl"] = mod_name
for s in strs:
#example for s: Control+F8:some_action()
parts = s.split(":", 1)
if len(parts)!=2:
log.error("Error: invalid key shortcut '%s'", s)
continue
#example for action: "quit"
action = parts[1]
args = ()
if action.find("(")>0 and action.endswith(")"):
try:
action, all_args = action[:-1].split("(", 1)
args = []
for x in all_args.split(","):
x = x.strip()
if len(x)==0:
continue
if (x[0]=='"' and x[-1]=='"') or (x[0]=="'" and x[-1]=="'"):
args.append(x[1:-1])
elif x=="None":
args.append(None)
elif x.find("."):
args.append(float(x))
else:
args.append(int(x))
args = tuple(args)
except Exception as e:
log.warn("failed to parse arguments of shortcut '%s': %s", s, e)
continue
log("action(%s)=%s%s", s, action, args)
#example for keyspec: ["Alt", "F8"]
keyspec = parts[0].split("+")
modifiers = []
if len(keyspec)>1:
valid = True
#ie: ["Alt"]
for mod in keyspec[:len(keyspec)-1]:
#ie: "alt_l" -> "mod1"
imod = modifier_names.get(mod.lower())
if not imod:
log.error("Error: invalid modifier '%s' in keyboard shortcut '%s'", mod, s)
log.error(" the modifiers must be one of: %s", csv(modifier_names.keys()))
valid = False
break
modifiers.append(imod)
if not valid:
continue
#TODO: validate keyname
keyname = keyspec[len(keyspec)-1]
shortcuts.setdefault(keyname, []).append((modifiers, action, args))
log("shortcut(%s)=%s", keyname, (modifiers, action, args))
log("parse_shortcuts(%s)=%s" % (str(strs), shortcuts))
print_nested_dict(shortcuts, print_fn=log)
return shortcuts
