def PIL_logging_workaround():
import logging
PIL_DEBUG = os.environ.get("XPRA_PIL_DEBUG", "0") == "1"
if PIL_DEBUG:
from xpra.log import Logger
log = Logger("util")
log.info("enabling PIL.DEBUG")
level = logging.DEBUG
else:
level = logging.INFO
# newer versions use this logger,
# we must initialize it before we load the class:
for x in ("Image", "PngImagePlugin", "WebPImagePlugin", "JpegImagePlugin"):
logger = logging.getLogger("PIL.%s" % x)
logger.setLevel(level)
import PIL
from PIL import Image
assert PIL and Image
if hasattr(Image, "DEBUG"):
# for older versions (pre 3.0), use Image.DEBUG flag:
Image.DEBUG = int(PIL_DEBUG)
def log_screen_sizes(root_w, root_h, sizes):
try:
do_log_screen_sizes(root_w, root_h, sizes)
except Exception as e:
from xpra.log import Logger
log = Logger("screen")
log.warn("failed to parse screen size information: %s", e, exc_info=True)
class ChildReaper(object):
def __init__(self, quit_cb, children_pids={}):
self._quit = quit_cb
self._children_pids = children_pids
self._dead_pids = set()
from xpra.log import Logger
self._logger = Logger()
def check(self):
if self._children_pids:
pids = set(self._children_pids.keys())
if pids.issubset(self._dead_pids):
self._quit()
def sigchld(self, signum, frame):
self.reap()
def add_dead_pid(self, pid):
if pid not in self._dead_pids:
cmd = self._children_pids.get(pid)
if cmd:
self._logger.info("child '%s' with pid %s has terminated", cmd, pid)
self._dead_pids.add(pid)
self.check()
def reap(self):
while True:
try:
pid, _ = os.waitpid(-1, os.WNOHANG)
except OSError:
break
if pid == 0:
break
self.add_dead_pid(pid)
def start_children(child_reaper, cwd, commands, fake_xinerama):
assert os.name == "posix"
from xpra.log import Logger
log = Logger("server")
env = os.environ.copy()
# add fake xinerama:
if fake_xinerama:
libfakeXinerama_so = find_fakeXinerama()
if libfakeXinerama_so:
env["LD_PRELOAD"] = libfakeXinerama_so
# disable ubuntu's global menu using env vars:
env.update(
{
"UBUNTU_MENUPROXY": "",
"QT_X11_NO_NATIVE_MENUBAR": "1",
"MWNOCAPTURE": "true",
"MWNO_RIT": "true",
"MWWM": "allwm",
}
)
for child_cmd in commands:
if not child_cmd:
continue
try:
proc = subprocess.Popen(child_cmd, stdin=subprocess.PIPE, env=env, cwd=cwd, shell=True, close_fds=True)
child_reaper.add_process(proc, child_cmd)
log.info("started child '%s' with pid %s", child_cmd, proc.pid)
except OSError, e:
sys.stderr.write("Error spawning child '%s': %s\n" % (child_cmd, e))
def do_get_resources_dir():
rsc = None
RESOURCES = "/Resources/"
#FUGLY warning: importing gtkosx_application causes the dock to appear,
#and in some cases we don't want that.. so use the env var XPRA_SKIP_UI as workaround for such cases:
if os.environ.get("XPRA_SKIP_UI", "0")=="0":
try:
import gtkosx_application #@UnresolvedImport
try:
rsc = gtkosx_application.gtkosx_application_get_resource_path()
debug("get_resources_dir() gtkosx_application_get_resource_path=%s", rsc)
except:
#maybe we're not running from an app bundle?
pass
except:
#delayed import to prevent cycles:
from xpra.log import Logger
log = Logger("util")
log.error("ERROR: gtkosx_application module is missing - trying to continue anyway")
else:
debug("XPRA_SKIP_UI is set, not importing gtkosx_application")
if rsc is None:
#try using the path to this file to find the resource path:
rsc = __file__
i = rsc.rfind(RESOURCES)
if i<=0:
#last fallback: try the default app dir
from xpra.platform.paths import default_get_app_dir
rsc = default_get_app_dir()
debug("get_resources_dir() default_get_app_dir()=%s", rsc)
i = rsc.rfind(RESOURCES)
if i>0:
rsc = rsc[:i+len(RESOURCES)]
debug("get_resources_dir()=%s", rsc)
return rsc
def start_children(child_reaper, commands, fake_xinerama):
assert os.name=="posix"
from xpra.log import Logger
log = Logger()
env = os.environ.copy()
#add fake xinerama:
if fake_xinerama:
#locate the fakeXinerama lib:
#it would be better to rely on dlopen to find the paths
#but I cannot find a way of getting ctypes to tell us the path
#it found the library in
libpaths = os.environ.get("LD_LIBRARY_PATH", "").split(":")
libpaths.append("/usr/lib64")
libpaths.append("/usr/lib")
for libpath in libpaths:
if not libpath or not os.path.exists(libpath):
continue
libfakeXinerama_so = "%s/%s" % (libpath, "libfakeXinerama.so.1")
if os.path.exists(libfakeXinerama_so):
env["LD_PRELOAD"] = libfakeXinerama_so
#disable ubuntu's global menu using env vars:
env.update({
"UBUNTU_MENUPROXY" : "",
"QT_X11_NO_NATIVE_MENUBAR" : "1"})
for child_cmd in commands:
if not child_cmd:
continue
try:
proc = subprocess.Popen(child_cmd, stdin=subprocess.PIPE, env=env, shell=True, close_fds=True)
child_reaper.add_process(proc, child_cmd)
log.info("started child '%s' with pid %s", child_cmd, proc.pid)
except OSError, e:
sys.stderr.write("Error spawning child '%s': %s\n" % (child_cmd, e))
def err(*msg):
""" log an error message and return None """
from xpra.log import Logger
log = Logger("icon")
log.error(*msg)
return None
def log_screen_sizes(root_w, root_h, ss):
try:
do_log_screen_sizes(root_w, root_h, ss)
except Exception, e:
from xpra.log import Logger
log = Logger()
log.warn("failed to parse screen size information: %s", e)
def get_sys_info():
info = {}
try:
import resource
for k, constant in {"server" : "RUSAGE_SELF",
"children" : "RUSAGE_CHILDREN",
"total" : "RUSAGE_BOTH"}.items():
try:
v = getattr(resource, constant)
except (NameError, AttributeError):
continue
stats = resource.getrusage(v)
prefix = "memory.%s." % k
for var in ("utime", "stime", "maxrss",
"ixrss", "idrss", "isrss",
"minflt", "majflt", "nswap",
"inblock", "oublock",
"msgsnd", "msgrcv",
"nsignals", "nvcsw", "nivcsw"):
value = getattr(stats, "ru_%s" % var)
if type(value)==float:
value = int(value)
info[prefix+var] = value
except:
from xpra.log import Logger
log = Logger()
log.error("error getting memory usage info", exc_info=True)
return info
def log_screen_sizes(root_w, root_h, sizes):
try:
do_log_screen_sizes(root_w, root_h, sizes)
except Exception:
from xpra.log import Logger
log = Logger("util")
log.warn("failed to parse screen size information: %s", sys.exc_info()[1])
def get_sys_info():
try:
from xpra.platform.xposix.info import get_sys_info as xposix_get_sys_info
return xposix_get_sys_info()
except:
from xpra.log import Logger
log = Logger("osx")
log.error("error getting memory usage info", exc_info=True)
return {}
def setbinarymode(fd):
if WIN32:
#turn on binary mode:
try:
import msvcrt
msvcrt.setmode(fd, os.O_BINARY) #@UndefinedVariable
except:
from xpra.log import Logger
log = Logger("util")
log.error("setting stdin to binary mode failed", exc_info=True)
def get_icc_info():
from xpra.log import Logger
log = Logger("platform")
info = {}
try:
from PIL.ImageCms import (
get_display_profile,
getProfileName,
getProfileInfo,
getProfileCopyright,
getProfileManufacturer,
getProfileModel,
getProfileDescription,
getDefaultIntent,
INTENT_PERCEPTUAL,
INTENT_RELATIVE_COLORIMETRIC,
INTENT_SATURATION,
INTENT_ABSOLUTE_COLORIMETRIC,
)
INTENT_STR = {
INTENT_PERCEPTUAL: "perceptual",
INTENT_RELATIVE_COLORIMETRIC: "relative-colorimetric",
INTENT_SATURATION: "saturation",
INTENT_ABSOLUTE_COLORIMETRIC: "absolute-colorimetric",
}
def getDefaultIntentStr(_p):
return INTENT_STR.get(getDefaultIntent(_p), "unknown")
def getData(_p):
return _p.tobytes()
p = get_display_profile()
if p:
for (k, fn) in {
"name": getProfileName,
"info": getProfileInfo,
"copyright": getProfileCopyright,
"manufacturer": getProfileManufacturer,
"model": getProfileModel,
"description": getProfileDescription,
"default-intent": getDefaultIntentStr,
"data": getData,
}.items():
try:
v = fn(p)
info[k] = v
except Exception as e:
log("ICC profile error on %s using %s: %s", k, fn, e)
except Exception as e:
log.warn("Warning: cannot query ICC profiles:")
log.warn(" %s", e)
return info
def mdns_publish(display_name, mode, listen_on, text_dict={}):
try:
from xpra.net.avahi_publisher import AvahiPublishers
except Exception, e:
global MDNS_WARNING
if not MDNS_WARNING:
MDNS_WARNING = True
from xpra.log import Logger
log = Logger("mdns")
log.error("failed to load the mdns avahi publisher: %s", e)
log.error("either fix your installation or use the '--no-mdns' flag")
return
def get_icc_info():
from xpra.log import Logger
log = Logger("platform")
ENV_ICC_DATA = os.environ.get("XPRA_ICC_DATA")
if ENV_ICC_DATA:
import binascii
return {
"source" : "environment-override",
"data" : binascii.unhexlify(ENV_ICC_DATA),
}
info = {}
try:
from PIL import ImageCms
from PIL.ImageCms import get_display_profile, getDefaultIntent
INTENT_STR = {}
for x in ("PERCEPTUAL", "RELATIVE_COLORIMETRIC", "SATURATION", "ABSOLUTE_COLORIMETRIC"):
v = getattr(ImageCms, "INTENT_%s" % x, None)
if v:
INTENT_STR[v] = x.lower().replace("_", "-")
log("get_icc_info() intents=%s", INTENT_STR)
def getDefaultIntentStr(_p):
return INTENT_STR.get(getDefaultIntent(_p), "unknown")
def getData(_p):
return _p.tobytes()
p = get_display_profile()
log("get_icc_info() display_profile=%s", p)
if p:
for (k, fn) in {
"name" : "getProfileName",
"info" : "getProfileInfo",
"copyright" : "getProfileCopyright",
"manufacturer" : "getProfileManufacturer",
"model" : "getProfileModel",
"description" : "getProfileDescription",
"default-intent": "getDefaultIntentStr",
"data" : "getData",
}.items():
m = getattr(ImageCms, fn, None)
if not m:
log("%s lacks %s", ImageCms, fn)
continue
try:
v = m(p)
info[k] = v
except Exception as e:
log("ICC profile error on %s using %s: %s", k, fn, e)
except Exception as e:
log("get_icc_info()", exc_info=True)
log.warn("Warning: cannot query ICC profiles:")
log.warn(" %s", e)
return info
def do_log_screen_sizes(root_w, root_h, sizes):
from xpra.log import Logger
log = Logger()
# old format, used by some clients (android):
if type(sizes) not in (tuple, list):
return
if any(True for x in sizes if type(x) not in (tuple, list)):
return
def dpi(size_pixels, size_mm):
if size_mm == 0:
return 0
return int(size_pixels * 254 / size_mm / 10)
for s in sizes:
if len(s) < 10:
log.info(" %s", s)
continue
# more detailed output:
display_name, width, height, width_mm, height_mm, monitors, work_x, work_y, work_width, work_height = s[:10]
# always log plug name:
info = ["'%s'" % prettify_plug_name(display_name)]
if width != root_w or height != root_h:
# log plug dimensions if not the same as display (root):
info.append("%sx%s" % (width, height))
info.append("(%sx%s mm - DPI: %sx%s)" % (width_mm, height_mm, dpi(width, width_mm), dpi(height, height_mm)))
def add_workarea(wx, wy, ww, wh):
info.append("workarea: %sx%s" % (ww, wh))
if wx != 0 or wy != 0:
# log position if not (0, 0)
info.append("at %sx%s" % (wx, wy))
if work_width != width or work_height != height or work_x != 0 or work_y != 0:
add_workarea(work_x, work_y, work_width, work_height)
log.info(" " + " ".join(info))
for i, m in enumerate(monitors, start=1):
if len(m) < 7:
log.info(" %s", m)
continue
plug_name, plug_x, plug_y, plug_width, plug_height, plug_width_mm, plug_height_mm = m[:7]
info = ["%s" % prettify_plug_name(plug_name, "monitor %s" % i)]
if plug_width != width or plug_height != height or plug_x != 0 or plug_y != 0:
info.append("%sx%s" % (plug_width, plug_height))
if plug_x != 0 or plug_y != 0:
info.append("at %sx%s" % (plug_x, plug_y))
if (plug_width_mm != width_mm or plug_height_mm != height_mm) and (plug_width_mm > 0 or plug_height_mm > 0):
info.append(
"(%sx%s mm - DPI: %sx%s)"
% (plug_width_mm, plug_height_mm, dpi(plug_width, plug_width_mm), dpi(plug_height, plug_height_mm))
)
if len(m) >= 11:
work_x, work_y, work_width, work_height = m[7:11]
add_workarea(work_x, work_y, work_width, work_height)
log.info(" " + " ".join(info))
def ival(key, default, minv=0, maxv=None):
try:
v = os.environ.get("XPRA_BATCH_%s" % key)
if v is None:
return default
iv = int(v)
assert minv is None or minv<=iv, "value for %s is too small: %s (minimum is %s)" % (key, iv, minv)
assert maxv is None or maxv>=iv, "value for %s is too high: %s (maximum is %s)" % (key, iv, maxv)
return iv
except Exception as e:
from xpra.log import Logger
log = Logger("util")
log.warn("failed to parse value '%s' for %s: %s", v, key, e)
return default
def set_application_name(name):
global NAME_SET
if NAME_SET:
return
NAME_SET = True
from xpra.log import Logger
log = Logger()
if sys.version_info[:2]<(2,5):
log.warn("Python %s is too old!", sys.version_info)
return
try:
import glib
glib.set_application_name(name or "Xpra")
except ImportError, e:
log.warn("glib is missing, cannot set the application name, please install glib's python bindings: %s", e)
def parse_simple_dict(s="", sep=","):
#parse the options string and add the pairs:
d = {}
for s in s.split(sep):
if not s:
continue
try:
k,v = s.split("=", 1)
d[k] = v
except Exception as e:
from xpra.log import Logger
log = Logger("util")
log.warn("Warning: failed to parse dictionary option '%s':", s)
log.warn(" %s", e)
return d
def __init__(self, event_cb, events=CONSOLE_EXIT_EVENTS):
self.event_cb = event_cb
self.events = events
self.result = 0
from xpra.log import Logger
self.log = Logger("win32")
def mdns_publish(display_name, mode, listen_on, text_dict={}):
try:
from xpra.net.avahi_publisher import AvahiPublishers
except Exception as e:
global MDNS_WARNING
if not MDNS_WARNING:
MDNS_WARNING = True
from xpra.log import Logger
log = Logger("mdns")
log.error("failed to load the mdns avahi publisher: %s", e)
log.error("either fix your installation or use the '--no-mdns' flag")
return
d = text_dict.copy()
d["mode"] = mode
ap = AvahiPublishers(listen_on, "Xpra %s %s" % (mode, display_name), text_dict=d)
_when_ready.append(ap.start)
_cleanups.append(ap.stop)
def main():
log = Logger("client")
from xpra.client.gtk2.tray_menu import GTK2TrayMenu
client = FakeClient()
log.info("creating tray menu")
tray = GTK2TrayMenu(client)
client.menu = tray.build()
client.fire_handshake_callbacks()
log.info("creating tray widget")
def tray_click(button, pressed, time=0):
log.info("tray_click(%s, %s, %s)", button, pressed, time)
if button==1 and pressed:
glib.idle_add(tray.activate, button, time)
elif button==3 and not pressed:
glib.idle_add(tray.popup, button, time)
def tray_mouseover(*args):
log.info("tray_mouseover(%s)", args)
def tray_exit(*args):
log.info("tray_exit(%s)", args)
gtk.main_quit()
def tray_geometry(*args):
log.info("tray_geometry%s", args)
GTKStatusIconTray(client, client.menu, "test", None, size_changed_cb=tray_geometry(), click_cb=tray_click, mouseover_cb=tray_mouseover, exit_cb=tray_exit)
log.info("running main loop")
gtk.main()
def start_children(child_reaper, commands):
assert os.name=="posix"
from xpra.log import Logger
log = Logger()
#disable ubuntu's global menu using env vars:
env = os.environ.copy()
env.update({
"UBUNTU_MENUPROXY" : "",
"QT_X11_NO_NATIVE_MENUBAR" : "1"})
for child_cmd in commands:
if not child_cmd:
continue
try:
proc = subprocess.Popen(child_cmd, stdin=subprocess.PIPE, env=env, shell=True, close_fds=True)
child_reaper.add_process(proc, child_cmd)
log.info("started child '%s' with pid %s", child_cmd, proc.pid)
except OSError, e:
sys.stderr.write("Error spawning child '%s': %s\n" % (child_cmd, e))
def main():
from xpra.log import Logger
log = Logger("util")
sp = sys.platform
log.info("platform_name(%s)=%s", sp, platform_name(sp, ""))
log.info("get_machine_id()=%s", get_machine_id())
log.info("get_hex_uuid()=%s", get_hex_uuid())
log.info("get_int_uuid()=%s", get_int_uuid())
def start_pulseaudio(child_reaper, pulseaudio_command):
from xpra.log import Logger
log = Logger("sound")
log("pulseaudio_command=%s", pulseaudio_command)
pa_proc = subprocess.Popen(pulseaudio_command, stdin=subprocess.PIPE, shell=True, close_fds=True)
child_reaper.add_process(pa_proc, "pulseaudio", ignore=True)
log.info("pulseaudio server started with pid %s", pa_proc.pid)
def check_pa_start():
if pa_proc.poll() is not None or pa_proc.pid in child_reaper._dead_pids:
log.warn(
"Warning: pulseaudio has terminated. Either fix the pulseaudio command line or use --no-pulseaudio to avoid this warning."
)
log.warn(
" usually, only a single pulseaudio instance can be running for each user account, and one may be running already"
)
return False
gobject.timeout_add(1000 * 2, check_pa_start)
def cleanup_pa():
log(
"cleanup_pa() process.poll()=%s, pid=%s, dead_pids=%s", pa_proc.poll(), pa_proc.pid, child_reaper._dead_pids
)
if pa_proc.poll() is None and pa_proc.pid not in child_reaper._dead_pids:
log.info("stopping pulseaudio with pid %s", pa_proc.pid)
try:
# first we try pactl (required on Ubuntu):
from xpra.scripts.exec_util import safe_exec
r, _, _ = safe_exec(["pactl", "exit"])
# warning: pactl will return 0 whether it succeeds or not...
# but we can't kill the process because Ubuntu starts a new one
if r != 0:
# fallback to using SIGINT:
pa_proc.terminate()
except:
log.warn("error trying to stop pulseaudio", exc_info=True)
_cleanups.append(cleanup_pa)
class console_event_catcher(object):
def __init__(self, event_cb, events=CONSOLE_EXIT_EVENTS):
self.event_cb = event_cb
self.events = events
self.result = 0
from xpra.log import Logger
self.log = Logger("win32")
def __enter__(self):
try:
self.result = win32api.SetConsoleCtrlHandler(self.handle_console_event, 1)
if self.result == 0:
self.log.error("could not SetConsoleCtrlHandler (error %r)", win32api.GetLastError())
except Exception as e:
self.log.error("SetConsoleCtrlHandler error: %s", e)
def __exit__(self, exc_type, exc_val, exc_tb):
try:
win32api.SetConsoleCtrlHandler(None, 0)
except:
pass
def __repr__(self):
return "console_event_catcher(%s, %s)" % (self.event_cb, self.events)
def handle_console_event(self, event):
self.log("handle_console_event(%s)", event)
if event in self.events:
self.log.info("received console event %s", event)
self.event_cb(event)
def main():
import logging
logging.basicConfig(format="%(asctime)s %(message)s")
logging.root.setLevel(logging.INFO)
from xpra.log import Logger
log = Logger("")
sp = sys.platform
log.info("platform_name(%s)=%s", sp, platform_name(sp, ""))
log.info("get_machine_id()=%s", get_machine_id())
log.info("get_hex_uuid()=%s", get_hex_uuid())
log.info("get_int_uuid()=%s", get_int_uuid())
def start_pulseaudio(child_reaper, pulseaudio_command):
from xpra.log import Logger
log = Logger("sound")
log("pulseaudio_command=%s", pulseaudio_command)
pa_proc = subprocess.Popen(pulseaudio_command, stdin=subprocess.PIPE, shell=True, close_fds=True)
child_reaper.add_process(pa_proc, "pulseaudio", ignore=True)
log.info("pulseaudio server started with pid %s", pa_proc.pid)
def check_pa_start():
if pa_proc.poll() is not None or pa_proc.pid in child_reaper._dead_pids:
log.warn("Warning: pulseaudio has terminated. Either fix the pulseaudio command line or use --no-pulseaudio to avoid this warning.")
log.warn(" usually, only a single pulseaudio instance can be running for each user account, and one may be running already")
return False
gobject.timeout_add(1000*2, check_pa_start)
def cleanup_pa():
log("cleanup_pa() process.poll()=%s, pid=%s, dead_pids=%s", pa_proc.poll(), pa_proc.pid, child_reaper._dead_pids)
if pa_proc.poll() is None and pa_proc.pid not in child_reaper._dead_pids:
log.info("stopping pulseaudio with pid %s", pa_proc.pid)
try:
pa_proc.terminate()
except:
log.warn("error trying to stop pulseaudio", exc_info=True)
_cleanups.append(cleanup_pa)
def abort_test(action):
""" if ssh dies, we don't need to try to read/write from its sockets """
e = child.poll()
if e is not None:
error_message = "cannot %s using %s: the SSH process has terminated with exit code=%s" % (action, display_desc["full_ssh"], e)
if debug_cb:
debug_cb(error_message)
if ssh_fail_cb:
ssh_fail_cb(error_message)
if "ssh_abort" not in display_desc:
display_desc["ssh_abort"] = True
from xpra.log import Logger
log = Logger()
log.error("The SSH process has terminated with exit code %s", e)
if conn.input_bytecount==0 and conn.output_bytecount==0:
log.error("Connection to the xpra server via SSH failed for: %s", display_name)
log.error(" the command line used was: %s", cmd)
log.error(" check your username, hostname, display number, etc")
raise ConnectionClosedException(error_message)
def main():
import sys
from xpra.platform import program_context, command_error
with program_context("Webcam", "Webcam"):
from xpra.log import Logger, add_debug_category
log = Logger("webcam")
if "-v" in sys.argv or "--verbose" in sys.argv:
add_debug_category("webcam")
log.enable_debug()
try:
import cv2
except ImportError as e:
command_error("Error: no opencv support module: %s" % e)
return 1
device = 0
if len(sys.argv)==2:
try:
device = int(sys.argv[1])
except:
command_error("Warning: failed to parse value as a device number: '%s'" % sys.argv[1])
try:
cap = cv2.VideoCapture(device)
except Exception as e:
command_error("Error: failed to capture video using device %s:\n%s" % (device, e))
return 1
log.info("capture device for %i: %s", device, cap)
while True:
ret, frame = cap.read()
if not ret:
command_error("Error: frame capture failed using device %s" % device)
return 1
cv2.imshow('frame', frame)
if cv2.waitKey(10) & 0xFF in (ord('q'), 27):
break
cap.release()
cv2.destroyAllWindows()
return 0
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import sys
import os
import time
import errno
import socket
from xpra.net.common import ConnectionClosedException
from xpra.util import envint, envbool, csv
from xpra.os_util import WIN32, PYTHON2, POSIX, LINUX
from xpra.platform.features import TCP_OPTIONS, IP_OPTIONS, SOCKET_OPTIONS
from xpra.log import Logger
log = Logger("network", "protocol")
SOCKET_CORK = envbool("XPRA_SOCKET_CORK", LINUX)
if SOCKET_CORK:
try:
assert socket.TCP_CORK > 0
except (AttributeError, AssertionError) as cork_e:
log.warn("Warning: unable to use TCP_CORK on %s", sys.platform)
log.warn(" %s", cork_e)
SOCKET_CORK = False
SOCKET_NODELAY = envbool("XPRA_SOCKET_NODELAY", None)
VSOCK_TIMEOUT = envint("XPRA_VSOCK_TIMEOUT", 5)
SOCKET_TIMEOUT = envint("XPRA_SOCKET_TIMEOUT", 20)
SSL_PEEK = envbool("XPRA_SSL_PEEK", True)
#this is more proper but would break the proxy server:
SOCKET_SHUTDOWN = envbool("XPRA_SOCKET_SHUTDOWN", False)
# This file is part of Xpra.
# Copyright (C) 2008 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2012-2014 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import cairo
from xpra.client.gtk_base.cairo_backing_base import CairoBackingBase
from xpra.gtk_common.gtk_util import pixbuf_new_from_data, COLORSPACE_RGB
from xpra.os_util import memoryview_to_bytes
from xpra.log import Logger
log = Logger("paint", "cairo")
"""
With python2 / gtk2, we can create an ImageSurface using either:
* cairo.ImageSurface.create_for_data
* pixbuf_new_from_data
Failing that, we use the horrible roundtrip via PNG using PIL.
"""
class CairoBacking(CairoBackingBase):
#with gtk2 we can convert these directly to a cairo image surface:
RGB_MODES = ["ARGB", "RGBA", "RGBX", "RGB"]
def __repr__(self):
return "gtk2.CairoBacking(%s)" % self._backing
# This file is part of Xpra.
# Copyright (C) 2010 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2017 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
# Ubuntu re-invents the wheel, and it's a broken one
import os
from xpra.log import Logger
log = Logger("tray", "posix")
from xpra.util import envbool
from xpra.os_util import is_unity
from xpra.client.tray_base import TrayBase
from xpra.platform.paths import get_icon_dir, get_icon_filename
DELETE_TEMP_FILE = envbool("XPRA_APPINDICATOR_DELETE_TEMP_FILE", True)
_appindicator = False
def get_appindicator():
global _appindicator
if _appindicator is False:
try:
import sys
if "gi" in sys.modules:
import gi
gi.require_version('AppIndicator3', '0.1')
# Copyright (C) 2010-2021 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import os
from xpra.codecs.codec_constants import PREFERRED_ENCODING_ORDER
from xpra.codecs.loader import load_codec, codec_versions, has_codec, get_codec
from xpra.codecs.video_helper import getVideoHelper, NO_GFX_CSC_OPTIONS
from xpra.scripts.config import parse_bool_or_int
from xpra.net import compression
from xpra.util import envint, envbool, updict, csv, typedict
from xpra.client.mixins.stub_client_mixin import StubClientMixin
from xpra.log import Logger
log = Logger("client", "encoding")
B_FRAMES = envbool("XPRA_B_FRAMES", True)
PAINT_FLUSH = envbool("XPRA_PAINT_FLUSH", True)
MAX_SOFT_EXPIRED = envint("XPRA_MAX_SOFT_EXPIRED", 5)
SEND_TIMESTAMPS = envbool("XPRA_SEND_TIMESTAMPS", False)
VIDEO_MAX_SIZE = tuple(int(x) for x in os.environ.get("XPRA_VIDEO_MAX_SIZE", "4096,4096").replace("x", ",").split(","))
SCROLL_ENCODING = envbool("XPRA_SCROLL_ENCODING", True)
#we assume that any server will support at least those:
DEFAULT_ENCODINGS = os.environ.get("XPRA_DEFAULT_ENCODINGS", "rgb32,rgb24,jpeg,png").split(",")
def get_core_encodings():
"""
This method returns the actual encodings supported.
# This file is part of Xpra.
# Copyright (C) 2010-2018 Antoine Martin <*****@*****.**>
# Copyright (C) 2008, 2010 Nathaniel Smith <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import signal
import os
import sys
import socket
import string
from collections import OrderedDict
from xpra.log import Logger, is_debug_enabled
log = Logger("client")
netlog = Logger("network")
authlog = Logger("auth")
mouselog = Logger("mouse")
cryptolog = Logger("crypto")
bandwidthlog = Logger("bandwidth")
from xpra.scripts.config import InitExit, parse_with_unit
from xpra.child_reaper import getChildReaper, reaper_cleanup
from xpra.net import compression
from xpra.net.protocol import Protocol, sanity_checks
from xpra.net.net_util import get_network_caps
from xpra.net.crypto import crypto_backend_init, get_iterations, get_iv, get_salt, choose_padding, gendigest, \
ENCRYPTION_CIPHERS, ENCRYPT_FIRST_PACKET, DEFAULT_IV, DEFAULT_SALT, DEFAULT_ITERATIONS, INITIAL_PADDING, DEFAULT_PADDING, ALL_PADDING_OPTIONS, PADDING_OPTIONS
from xpra.version_util import get_version_info, XPRA_VERSION
from xpra.platform.info import get_name
from xpra.os_util import get_machine_id, get_user_uuid, load_binary_file, SIGNAMES, PYTHON3, strtobytes, bytestostr, hexstr, monotonic_time, osexpand, BITS, WIN32, OSX
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2008 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2013 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
from xpra.log import Logger
log = Logger("keyboard")
#this allows platforms to inject keyname workarounds
# the key is a tuple (keyname, keyval, keycode)
# the value is the keyname override
KEY_TRANSLATIONS = {}
def get_gtk_keymap(ignore_keys=[None, "VoidSymbol"]):
"""
Augment the keymap we get from gtk.gdk.keymap_get_default()
by adding the keyval_name.
We can also ignore some keys
"""
from xpra.gtk_common.gtk_util import get_default_keymap, import_gdk, is_gtk3
gdk = import_gdk()
keymap = get_default_keymap()
keycodes=[]
for i in range(0, 2**8):
entries = keymap.get_entries_for_keycode(i)
log("%s.get_entries_for_keycode(%s)=%s", keymap, i, entries)
if not entries:
continue
# This file is part of Xpra.
# Copyright (C) 2016-2019 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
from xpra.util import envbool
from xpra.net.websockets.common import make_websocket_accept_hash
from xpra.server.http_handler import HTTPRequestHandler
from xpra.log import Logger
log = Logger("network", "websocket")
WEBSOCKET_ONLY_UPGRADE = envbool("XPRA_WEBSOCKET_ONLY_UPGRADE", False)
# HyBi-07 report version 7
# HyBi-08 - HyBi-12 report version 8
# HyBi-13 reports version 13
SUPPORT_HyBi_PROTOCOLS = ("7", "8", "13")
class WebSocketRequestHandler(HTTPRequestHandler):
server_version = "Xpra-WebSocket-Server"
def __init__(self, sock, addr, new_websocket_client,
web_root="/usr/share/xpra/www/",
http_headers_dir="/usr/share/xpra/http-headers", script_paths=None):
self.new_websocket_client = new_websocket_client
self.only_upgrade = WEBSOCKET_ONLY_UPGRADE
super().__init__(sock, addr, web_root, http_headers_dir, script_paths)
class typedict(dict):
from xpra.log import Logger
log = Logger("util")
def capsget(self, key, default=None):
v = self.get(key)
#py3k and bytes as keys...
if v is None and type(key) == str:
v = self.get(strtobytes(key), default)
if sys.version >= '3' and type(v) == bytes:
v = bytestostr(v)
return v
def strget(self, k, default=None):
v = self.capsget(k, default)
if v is None:
return None
return bytestostr(v)
def intget(self, k, d=0):
v = self.capsget(k)
if v is None:
return d
try:
return int(v)
except Exception as e:
typedict.log.warn("error on %s: %s", k, e)
return d
def boolget(self, k, default_value=False):
return bool(self.capsget(k, default_value))
def dictget(self, k, default_value={}):
v = self.capsget(k, default_value)
if v is None:
return None
if type(v) != dict:
typedict.log.warn("expected a dict value for %s but got %s", k,
type(v))
return default_value
return v
def intpair(self, k, default_value=None):
v = self.intlistget(k, default_value)
if v is None:
return default_value
if len(v) != 2:
#"%s is not a pair of numbers: %s" % (k, len(v))
return default_value
try:
return int(v[0]), int(v[1])
except:
return default_value
def strlistget(self, k, default_value=[]):
return self.listget(k, default_value, str)
def intlistget(self, k, default_value=[]):
return self.listget(k, default_value, int)
def listget(self, k, default_value=[], item_type=None, max_items=None):
v = self.capsget(k, default_value)
if v is None:
return default_value
if type(v) not in (list, tuple):
typedict.log.warn(
"expected a list or tuple value for %s but got %s", k, type(v))
return default_value
aslist = list(v)
if item_type:
for i in range(len(aslist)):
x = aslist[i]
if sys.version > '3' and type(x) == bytes and item_type == str:
x = bytestostr(x)
aslist[i] = x
elif type(x) == unicode and item_type == str:
x = str(x)
aslist[i] = x
if type(x) != item_type:
typedict.log.warn(
"invalid item type for %s %s: expected %s but got %s",
type(v), k, item_type, type(x))
return default_value
if max_items is not None:
if len(v) > max_items:
typedict.log.warn(
"too many items in %s %s: maximum %s allowed, but got %s",
type(v), k, max_items, len(v))
return default_value
return aslist
# -*- coding: utf-8 -*-
# This file is part of Xpra.
# Copyright (C) 2010-2020 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
from xpra.os_util import strtobytes
from xpra.util import engs, csv, iround
from xpra.util import log_screen_sizes
from xpra.os_util import bytestostr, get_loaded_kernel_modules
from xpra.server.mixins.stub_server_mixin import StubServerMixin
from xpra.log import Logger
log = Logger("screen")
gllog = Logger("opengl")
"""
Mixin for servers that handle displays.
"""
class DisplayManager(StubServerMixin):
def __init__(self):
self.randr = False
self.bell = False
self.cursors = False
self.default_dpi = 96
self.dpi = 0
self.xdpi = 0
self.ydpi = 0
self.antialias = {}
self.cursor_size = 0
# -*- coding: utf-8 -*-
# This file is part of Xpra.
# Copyright (C) 2011 Serviware (Arthur Huillet, <*****@*****.**>)
# Copyright (C) 2010-2018 Antoine Martin <*****@*****.**>
# Copyright (C) 2008 Nathaniel Smith <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import os.path
import hashlib
from xpra.log import Logger
printlog = Logger("printing")
filelog = Logger("file")
from xpra.simple_stats import to_std_unit
from xpra.os_util import bytestostr, WIN32
from xpra.util import engs, repr_ellipsized
from xpra.net.file_transfer import FileTransferAttributes
from xpra.server.mixins.stub_server_mixin import StubServerMixin
SAVE_PRINT_JOBS = os.environ.get("XPRA_SAVE_PRINT_JOBS", None)
"""
Mixin for servers that can handle file transfers and forwarded printers.
Printer forwarding is only supported on Posix servers with the cups backend script.
"""
class FilePrintServer(StubServerMixin):
def __init__(self):
self.lpadmin = ""
def do_log_screen_sizes(root_w, root_h, sizes):
from xpra.log import Logger
log = Logger("util")
#old format, used by some clients (android):
if type(sizes) not in (tuple, list):
return
if any(True for x in sizes if type(x) not in (tuple, list)):
return
def dpi(size_pixels, size_mm):
if size_mm == 0:
return 0
return int(size_pixels * 254 / size_mm / 10)
for s in sizes:
if len(s) < 10:
log.info(" %s", s)
continue
#more detailed output:
display_name, width, height, width_mm, height_mm, \
monitors, work_x, work_y, work_width, work_height = s[:10]
#always log plug name:
info = ["%s" % prettify_plug_name(display_name)]
if width != root_w or height != root_h:
#log plug dimensions if not the same as display (root):
info.append("%ix%i" % (width, height))
info.append("(%ix%i mm - DPI: %ix%i)" %
(width_mm, height_mm, dpi(
width, width_mm), dpi(height, height_mm)))
def add_workarea(wx, wy, ww, wh):
info.append("workarea: %ix%i" % (ww, wh))
if wx != 0 or wy != 0:
#log position if not (0, 0)
info.append("at %ix%i" % (wx, wy))
if work_width != width or work_height != height or work_x != 0 or work_y != 0:
add_workarea(work_x, work_y, work_width, work_height)
log.info(" " + " ".join(info))
for i, m in enumerate(monitors, start=1):
if len(m) < 7:
log.info(" %s", m)
continue
plug_name, plug_x, plug_y, plug_width, plug_height, plug_width_mm, plug_height_mm = m[:
7]
info = ['%s' % prettify_plug_name(plug_name, "monitor %i" % i)]
if plug_width != width or plug_height != height or plug_x != 0 or plug_y != 0:
info.append("%ix%i" % (plug_width, plug_height))
if plug_x != 0 or plug_y != 0:
info.append("at %ix%i" % (plug_x, plug_y))
if (plug_width_mm != width_mm or plug_height_mm != height_mm) and (
plug_width_mm > 0 or plug_height_mm > 0):
info.append("(%ix%i mm - DPI: %ix%i)" %
(plug_width_mm, plug_height_mm,
dpi(plug_width, plug_width_mm),
dpi(plug_height, plug_height_mm)))
if len(m) >= 11:
dwork_x, dwork_y, dwork_width, dwork_height = m[7:11]
#only show it again if different from the screen workarea
if dwork_x != work_x or dwork_y != work_y or dwork_width != work_width or dwork_height != work_height:
add_workarea(dwork_x, dwork_y, dwork_width, dwork_height)
log.info(" " + " ".join(info))
# Copyright (C) 2011-2013 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import os
import re
#ensure that we use gtk as display source:
from xpra.x11.gtk_x11 import gdk_display_source
assert gdk_display_source
from xpra.x11.gtk_x11.error import trap
from xpra.x11.bindings.keyboard_bindings import X11KeyboardBindings #@UnresolvedImport
X11Keyboard = X11KeyboardBindings()
from xpra.log import Logger
log = Logger()
KEYBOARD_DEBUG = os.environ.get("XPRA_KEYBOARD_DEBUG", "0")=="1"
if KEYBOARD_DEBUG:
debug = log.info
else:
debug = log.debug
KEYBOARD_VERBOSE = os.environ.get("XPRA_KEYBOARD_DEBUG", "0")=="2"
if KEYBOARD_VERBOSE:
verbose = log.info
else:
verbose = log.debug
def exec_keymap_command(args, stdin=None):
# This file is part of Xpra.
# Copyright (C) 2008, 2009 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2016 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import os
import gobject
from xpra.gtk_common.gobject_util import AutoPropGObjectMixin
from xpra.log import Logger
log = Logger("x11", "window")
metalog = Logger("x11", "window", "metadata")
PROPERTIES_DEBUG = [x.strip() for x in os.environ.get("XPRA_WINDOW_PROPERTIES_DEBUG", "").split(",")]
class WindowModelStub(AutoPropGObjectMixin, gobject.GObject):
"""
Stub for all window models
"""
#things that we expose:
_property_names = []
#exposed and changing (should be watched for notify signals):
_dynamic_property_names = []
_internal_property_names = []
_MODELTYPE = "Stub"
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2014 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
from collections import deque
import gobject #@UnresolvedImport
import gtk #@UnresolvedImport
from xpra.client.gobject_client_base import CommandConnectClient
from xpra.log import Logger
log = Logger()
class gobject_loop_adapter(object):
def quit(self):
gtk.main_quit()
def run(self):
gtk.main()
class ServerMessenger(CommandConnectClient):
def run(self):
self._protocol.start()
#override so we can use the gtk main loop here:
self.gobject_mainloop = gobject_loop_adapter()
self.gobject_mainloop.run()
return self.exit_code
# Copyright (C) 2010-2020 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
#pylint: disable-msg=E1101
import os
from time import sleep
from xpra.server.mixins.stub_server_mixin import StubServerMixin
from xpra.scripts.config import parse_with_unit
from xpra.simple_stats import std_unit
from xpra.os_util import livefds, POSIX
from xpra.util import envbool, envint, detect_leaks, typedict
from xpra.log import Logger
log = Logger("network")
bandwidthlog = Logger("bandwidth")
DETECT_MEMLEAKS = envint("XPRA_DETECT_MEMLEAKS", 0)
DETECT_FDLEAKS = envbool("XPRA_DETECT_FDLEAKS", False)
MIN_BANDWIDTH_LIMIT = envint("XPRA_MIN_BANDWIDTH_LIMIT", 1024 * 1024)
MAX_BANDWIDTH_LIMIT = envint("XPRA_MAX_BANDWIDTH_LIMIT",
10 * 1024 * 1024 * 1024)
CPUINFO = envbool("XPRA_CPUINFO", False)
class NetworkStateServer(StubServerMixin):
"""
Mixin for adding client / network state monitoring functions:
- ping and echo
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2014-2017 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import sys, os
#default implementation uses pycups
from xpra.util import envbool, print_nested_dict
from xpra.os_util import WIN32, PYTHON3
from xpra.log import Logger
log = Logger("printing")
RAW_MODE = envbool("XPRA_PRINTER_RAW", False)
if PYTHON3:
unicode = str #@ReservedAssignment
def err(*args, **kwargs):
log.error(*args, **kwargs)
def get_printers():
return {}
def get_printer_attributes(_name):
return []
# but it works on win32, for whatever that's worth.
import time
import sys
from socket import error as socket_error
import struct
import os
import threading
import binascii
from threading import Lock
ZLIB_FLAG = 0x00
LZ4_FLAG = 0x10
from xpra.log import Logger
log = Logger("network", "protocol")
debug = log.debug
from xpra.os_util import Queue, strtobytes, get_hex_uuid
from xpra.daemon_thread import make_daemon_thread
from xpra.simple_stats import std_unit, std_unit_dec
from xpra.net.bytestreams import ABORT
try:
from Crypto.Cipher import AES
from Crypto.Protocol.KDF import PBKDF2
except Exception, e:
AES = None
PBKDF2 = None
log("pycrypto is missing: %s", e)
from zlib import compress, decompress
def get_util_logger():
global util_logger
if not util_logger:
from xpra.log import Logger
util_logger = Logger("util")
return util_logger
# This file is part of Xpra.
# Copyright (C) 2008, 2009 Nathaniel Smith <*****@*****.**>
# Copyright (C) 2011-2015 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import os
from xpra.util import WORKSPACE_UNSET, WORKSPACE_ALL
from xpra.x11.gtk_x11.prop import prop_set, prop_get
from xpra.x11.gtk2.models.core import CoreX11WindowModel, gobject, xswallow, gdk
from xpra.x11.bindings.window_bindings import X11WindowBindings, constants #@UnresolvedImport
from xpra.x11.gtk2.gdk_bindings import get_pywindow, get_pyatom #@UnresolvedImport
from xpra.log import Logger
log = Logger("x11", "window")
workspacelog = Logger("x11", "window", "workspace")
metalog = Logger("x11", "window", "metadata")
geomlog = Logger("x11", "window", "geometry")
menulog = Logger("x11", "window", "menu")
dbus_helper = None
MENU_FORWARDING = os.environ.get("XPRA_MENU_FORWARDING", "1")=="1"
if MENU_FORWARDING:
try:
from xpra import dbus
assert dbus
except ImportError as e:
log("this build does not include the dbus module, no menu forwarding")
del e
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2015-2020 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import dbus.service
from xpra.server.dbus.dbus_server import DBUS_Server, INTERFACE, ni
from xpra.log import Logger
log = Logger("dbus", "server")
class Shadow_DBUS_Server(DBUS_Server):
@dbus.service.method(INTERFACE, in_signature='i')
def SetRefreshDelay(self, milliseconds):
log("SetRefreshDelay(%i)", milliseconds)
return self.server.set_refresh_delay(ni(milliseconds))
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2011-2014 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
#tricky: use xpra.scripts.config to get to the python "platform" module
from xpra.scripts.config import python_platform
import sys
import os
from xpra.util import updict
from xpra.os_util import get_linux_distribution
from xpra import __version__ as local_version
from xpra.log import Logger
log = Logger("util")
def version_as_numbers(version):
return [int(x) for x in version.split(".")]
def version_compat_check(remote_version):
if remote_version is None:
msg = "remote version not available!"
log(msg)
return msg
rv = version_as_numbers(remote_version)
lv = version_as_numbers(local_version)
if rv == lv:
log("identical remote version: %s", remote_version)
return None
PostMessageA,
CreateWindowExA, CreatePopupMenu, AppendMenu,
LoadIconA,
DefWindowProcA, RegisterWindowMessageA, RegisterClassExA,
ICONINFO, BITMAPV5HEADER,
LoadImageW, CreateIconIndirect, DestroyIcon,
GetDC, ReleaseDC,
CreateBitmap, CreateDIBSection,
UpdateWindow, DestroyWindow,
PostQuitMessage,
GetModuleHandleA,
GetStockObject, DeleteObject,
)
from xpra.log import Logger
log = Logger("tray", "win32")
log("loading ctypes NotifyIcon functions")
sprintf = ctypes.cdll.msvcrt.sprintf
TRAY_ALPHA = envbool("XPRA_TRAY_ALPHA", True)
def GetProductInfo(dwOSMajorVersion=5, dwOSMinorVersion=0, dwSpMajorVersion=0, dwSpMinorVersion=0):
product_type = DWORD(0)
from xpra.platform.win32.common import GetProductInfo as k32GetProductInfo
v = k32GetProductInfo(dwOSMajorVersion, dwOSMinorVersion, dwSpMajorVersion, dwSpMinorVersion, byref(product_type))
log("GetProductInfo(%i, %i, %i, %i)=%i product_type=%s", dwOSMajorVersion, dwOSMinorVersion, dwSpMajorVersion, dwSpMinorVersion, v, hex(product_type.value))
return bool(v)
#win7 is actually 6.1:
# This file is part of Xpra.
# Copyright (C) 2011-2015 Antoine Martin <*****@*****.**>
# Copyright (C) 2008, 2009, 2010 Nathaniel Smith <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
from xpra.os_util import strtobytes
from xpra.log import Logger
log = Logger("network", "crypto")
__all__ = ("get_info", "get_key", "get_encryptor", "get_decryptor", "ENCRYPTION_CIPHERS")
ENCRYPTION_CIPHERS = []
backend = None
def patch_crypto_be_discovery():
"""
Monkey patches cryptography's backend detection.
Objective: support pyinstaller / cx_freeze / pyexe / py2app freezing.
"""
from cryptography.hazmat import backends
try:
from cryptography.hazmat.backends.commoncrypto.backend import backend as be_cc
except ImportError:
log("failed to import commoncrypto", exc_info=True)
be_cc = None
try:
import _ssl
log("loaded _ssl=%s", _ssl)
except ImportError:
from gi.repository import GLib, Gdk, Gtk
from xpra.util import flatten_dict, envbool
from xpra.os_util import monotonic_time
from xpra.gtk_common.gobject_compat import register_os_signals
from xpra.server import server_features
from xpra.server.server_base import ServerBase
from xpra.gtk_common.gtk_util import (
get_gtk_version_info,
get_root_size,
)
from xpra.log import Logger
UI_THREAD_WATCHER = envbool("XPRA_UI_THREAD_WATCHER")
log = Logger("server", "gtk")
screenlog = Logger("server", "screen")
cursorlog = Logger("server", "cursor")
notifylog = Logger("notify")
class GTKServerBase(ServerBase):
"""
This is the base class for servers.
It provides all the generic functions but is not tied
to a specific backend (X11 or otherwise).
See X11ServerBase, XpraServer and XpraX11ShadowServer
"""
def __init__(self):
log("GTKServerBase.__init__()")
self.idle_add = GLib.idle_add
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
# taken from the code I wrote for winswitch
import avahi
import dbus
try:
from dbus.exceptions import DBusException
except:
#not available in all versions of the bindings?
DBusException = Exception
from xpra.net.mdns import XPRA_MDNS_TYPE, SHOW_INTERFACE
from xpra.log import Logger
log = Logger("network", "mdns")
from xpra.dbus.common import init_system_bus
from xpra.net.net_util import get_iface, if_nametoindex, if_indextoname
def get_interface_index(host):
log("get_interface_index(%s)", host)
if host == "0.0.0.0" or host == "" or host == "*" or host == "::":
return avahi.IF_UNSPEC
if not if_nametoindex:
log.error(
"cannot convert interface to index (if_nametoindex is missing), so returning 'IF_UNSPEC', avahi will publish on ALL interfaces"
)
return avahi.IF_UNSPEC
import os.path
import subprocess
from xpra.gtk_common.gobject_compat import import_gtk, import_gdk, import_pango, import_glib
gtk = import_gtk()
gdk = import_gdk()
pango = import_pango()
glib = import_glib()
glib.threads_init()
from xpra.platform.paths import get_icon_dir, get_xpra_command
from xpra.os_util import OSX, WIN32
from xpra.gtk_common.gtk_util import gtk_main, set_tooltip_text, add_close_accel, pixbuf_new_from_file, add_window_accel, imagebutton, window_defaults, scaled_image, WIN_POS_CENTER
from xpra.log import Logger
log = Logger("client", "util")
try:
from xpra import client
has_client = bool(client)
except ImportError:
has_client = False
try:
from xpra.server import server_util
has_server = bool(server_util)
except ImportError:
has_server = False
try:
from xpra.server import shadow
has_shadow = bool(shadow)
except ImportError:
from xpra.os_util import monotonic_time
from xpra.util import (
iround,
envint,
envfloat,
envbool,
log_screen_sizes,
engs,
flatten_dict,
typedict,
XPRA_SCALING_NOTIFICATION_ID,
)
from xpra.client.mixins.stub_client_mixin import StubClientMixin
from xpra.log import Logger
log = Logger("screen")
workspacelog = Logger("client", "workspace")
scalinglog = Logger("scaling")
MONITOR_CHANGE_REINIT = envint("XPRA_MONITOR_CHANGE_REINIT")
MIN_SCALING = envfloat("XPRA_MIN_SCALING", "0.1")
MAX_SCALING = envfloat("XPRA_MAX_SCALING", "8")
SCALING_OPTIONS = [
float(x) for x in os.environ.get(
"XPRA_TRAY_SCALING_OPTIONS",
"0.25,0.5,0.666,1,1.25,1.5,2.0,3.0,4.0,5.0").split(",")
if float(x) >= MIN_SCALING and float(x) <= MAX_SCALING
]
SCALING_EMBARGO_TIME = int(os.environ.get("XPRA_SCALING_EMBARGO_TIME",
"1000")) / 1000.0
from math import sqrt
from collections import deque
from xpra.simple_stats import get_list_stats, get_weighted_list_stats
from xpra.os_util import monotonic_time
from xpra.util import engs, csv, envint
from xpra.server.cystats import (
logp, #@UnresolvedImport
calculate_time_weighted_average, #@UnresolvedImport
calculate_size_weighted_average, #@UnresolvedImport
calculate_timesize_weighted_average, #@UnresolvedImport
calculate_for_average, #@UnresolvedImport
)
from xpra.log import Logger
log = Logger("stats")
#how many historical records to keep
#for the various statistics we collect:
#(cannot be lower than DamageBatchConfig.MAX_EVENTS)
NRECS = 100
TARGET_LATENCY_TOLERANCE = envint("XPRA_TARGET_LATENCY_TOLERANCE", 20) / 1000.0
class WindowPerformanceStatistics:
"""
Statistics which belong to a specific WindowSource
"""
def __init__(self):
self.reset()
#!/usr/bin/env python
# This file is part of Xpra.
# Copyright (C) 2010-2015 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
import sys
import os.path
from xpra.log import Logger
log = Logger("codec", "loader")
try:
#this makes py2exe do the right thing:
from xpra.codecs import codec_checks
assert codec_checks
except:
pass
if sys.version > '3':
unicode = str #@ReservedAssignment
#these codecs may well not load because we
#do not require the libraries to be installed
NOWARN = ["nvenc4", "nvenc5", "nvenc6", "opencl", "opencv"]
SELFTEST = os.environ.get("XPRA_CODEC_SELFTEST", "1") == "1"
FULL_SELFTEST = os.environ.get("XPRA_CODEC_FULL_SELFTEST", "0") == "1"
CODEC_FAIL_IMPORT = os.environ.get("XPRA_CODEC_FAIL_IMPORT", "").split(",")
CODEC_FAIL_SELFTEST = os.environ.get("XPRA_CODEC_FAIL_SELFTEST", "").split(",")
log(
# Copyright (C) 2018-2021 Antoine Martin <*****@*****.**>
# Xpra is released under the terms of the GNU GPL v2, or, at your option, any
# later version. See the file COPYING for details.
from xpra.platform import program_context
from xpra.platform.gui import get_native_tray_menu_helper_class, get_native_tray_classes
from xpra.platform.paths import get_icon_filename
from xpra.gtk_common.gtk_util import scaled_image
from xpra.log import Logger
import gi
gi.require_version("Gtk", "3.0")
from gi.repository import GLib, Gtk, GdkPixbuf
log = Logger("client")
class FakeApplication:
def __init__(self):
self.idle_add = GLib.idle_add
self.timeout_add = GLib.timeout_add
self.source_remove = GLib.source_remove
self.display_desc = {}
self.session_name = "Test System Tray"
self.mmap_enabled = False
self.windows_enabled = True
self.readonly = False
self.opengl_enabled = False
self.modal_windows = False
self.server_bell = False
