WestGravity, CenterGravity, EastGravity, SouthWestGravity, SouthGravity, SouthEastGravity, StaticGravity, GRAVITY_STR, ) from xpra.codecs.xor.cyxor import xor_str #@UnresolvedImport from xpra.log import Logger log = Logger("paint") deltalog = Logger("delta") DELTA_BUCKETS = envint("XPRA_DELTA_BUCKETS", 5) INTEGRITY_HASH = envbool("XPRA_INTEGRITY_HASH", False) PAINT_BOX = envint("XPRA_PAINT_BOX", 0) or envint("XPRA_OPENGL_PAINT_BOX", 0) WEBP_PILLOW = envbool("XPRA_WEBP_PILLOW", False) SCROLL_ENCODING = envbool("XPRA_SCROLL_ENCODING", True) REPAINT_ALL = envbool("XPRA_REPAINT_ALL", False) #ie: #CSC_OPTIONS = { "YUV420P" : {"RGBX" : [swscale.spec], "BGRX" : ...} } CSC_OPTIONS = None def load_csc_options(): global CSC_OPTIONS if CSC_OPTIONS is None: CSC_OPTIONS = {}
# 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 win32api #@UnresolvedImport import win32con #@UnresolvedImport import win32gui #@UnresolvedImport from xpra.platform.keyboard_base import KeyboardBase from xpra.keyboard.layouts import WIN32_LAYOUTS from xpra.gtk_common.keymap import KEY_TRANSLATIONS from xpra.util import csv, envint, envbool from xpra.log import Logger log = Logger("keyboard") EMULATE_ALTGR = envbool("XPRA_EMULATE_ALTGR", True) EMULATE_ALTGR_CONTROL_KEY_DELAY = envint("XPRA_EMULATE_ALTGR_CONTROL_KEY_DELAY", 50) if EMULATE_ALTGR: #needed for altgr emulation timeouts: from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() class Keyboard(KeyboardBase): """ This is for getting keys from the keyboard on the client side. Deals with GTK bugs and oddities: * missing 'Num_Lock' * simulate 'Alt_Gr' """ def __init__(self): KeyboardBase.__init__(self)
#!/usr/bin/env python # This file is part of Xpra. # Copyright (C) 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 sys import unittest from xpra.util import envint from xpra.os_util import load_binary_file, pollwait from unit.client.x11_client_test_util import X11ClientTestUtil, log CLIENT_TIMEOUT = envint("XPRA_TEST_CLIENT_TIMEOUT", 5) class X11ClientTest(X11ClientTestUtil): def do_test_connect(self, sharing=False, *client_args): display = self.find_free_display() log("starting test server on %s", display) server = self.check_start_server(display, "--start=xterm", "--sharing=%s" % sharing) xvfb1, client1 = self.run_client(display, "--sharing=%s" % sharing, *client_args) assert pollwait(client1, CLIENT_TIMEOUT) is None xvfb2, client2 = self.run_client(display, "--sharing=%s" % sharing, *client_args) assert pollwait(client2, CLIENT_TIMEOUT) is None if not sharing: #starting a second client should disconnect the first when not sharing assert pollwait(client1, 2) is not None, "the first client should have been disconnected (sharing off)" #killing the Xvfb should kill the client xvfb1.terminate()
import time import sys import os import errno import socket import types from xpra.log import Logger log = Logger("network", "protocol") from xpra.net import ConnectionClosedException from xpra.util import envint, envbool from xpra.os_util import WIN32 TCP_NODELAY = envbool("XPRA_TCP_NODELAY", True) VSOCK_TIMEOUT = envint("XPRA_VSOCK_TIMEOUT", 5) SOCKET_TIMEOUT = envint("XPRA_SOCKET_TIMEOUT", 10) #on some platforms (ie: OpenBSD), reading and writing from sockets #raises an IOError but we should continue if the error code is EINTR #this wrapper takes care of it. #EWOULDBLOCK can also be hit with the proxy server when we handover the socket CONTINUE = { errno.EINTR : "EINTR", errno.EWOULDBLOCK : "EWOULDBLOCK" } ABORT = { errno.ENXIO : "ENXIO", errno.ECONNRESET : "ECONNRESET", errno.EPIPE : "EPIPE",
from xpra.sound.gstreamer_util import parse_sound_source, get_source_plugins, format_element_options, \ can_decode, can_encode, get_muxers, get_demuxers, get_all_plugin_names from xpra.net.subprocess_wrapper import subprocess_caller, subprocess_callee, exec_kwargs, exec_env from xpra.platform.paths import get_sound_command from xpra.util import AdHocStruct, typedict, parse_simple_dict, envint, envbool from xpra.scripts.config import InitExit, InitException from xpra.log import Logger log = Logger("sound") DEBUG_SOUND = envbool("XPRA_SOUND_DEBUG", False) SUBPROCESS_DEBUG = [x.strip() for x in os.environ.get("XPRA_SOUND_SUBPROCESS_DEBUG", "").split(",") if x.strip()] FAKE_START_FAILURE = envbool("XPRA_SOUND_FAKE_START_FAILURE", False) FAKE_EXIT = envbool("XPRA_SOUND_FAKE_EXIT", False) FAKE_CRASH = envbool("XPRA_SOUND_FAKE_CRASH", False) SOUND_START_TIMEOUT = envint("XPRA_SOUND_START_TIMEOUT", 3000) BUNDLE_METADATA = envbool("XPRA_SOUND_BUNDLE_METADATA", True) def get_sound_wrapper_env(): env = {} if sys.platform.startswith("win"): #disable bencoder to skip warnings with the py3k Sound subapp env["XPRA_USE_BENCODER"] = "0" elif os.name=="posix" and not sys.platform.startswith("darwin"): try: from xpra.sound.pulseaudio.pulseaudio_util import add_audio_tagging_env add_audio_tagging_env(env) except ImportError as e: log.warn("Warning: failed to set pulseaudio tagging:") log.warn(" %s", e)
from xpra.log import Logger log = Logger("sound") gstlog = Logger("gstreamer") #must be done before importing gobject! from xpra.sound.gstreamer_util import import_gst gst = import_gst() MESSAGE_ELEMENT = getattr(gst, "MESSAGE_ELEMENT", None) from xpra.sound.gstreamer_util import gst_version #must be done after import_gst() from xpra.util import csv, envint from xpra.gtk_common.gobject_compat import import_glib from xpra.gtk_common.gobject_util import one_arg_signal, gobject FAULT_RATE = envint("XPRA_SOUND_FAULT_INJECTION_RATE") _counter = 0 def inject_fault(): global FAULT_RATE if FAULT_RATE<=0: return False global _counter _counter += 1 return (_counter % FAULT_RATE)==0 class SoundPipeline(gobject.GObject): __generic_signals__ = { "state-changed" : one_arg_signal, "error" : one_arg_signal,
# 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 time import math from xpra.util import MutableInteger, envint, envbool from xpra.server.window.region import rectangle, add_rectangle, remove_rectangle, merge_all #@UnresolvedImport from xpra.log import Logger sslog = Logger("regiondetect") refreshlog = Logger("regionrefresh") VIDEO_SUBREGION = envbool("XPRA_VIDEO_SUBREGION", True) MAX_TIME = envint("XPRA_VIDEO_DETECT_MAX_TIME", 5) MIN_EVENTS = envint("XPRA_VIDEO_DETECT_MIN_EVENTS", 20) MIN_W = envint("XPRA_VIDEO_DETECT_MIN_WIDTH", 128) MIN_H = envint("XPRA_VIDEO_DETECT_MIN_HEIGHT", 96) RATIO_WEIGHT = envint("XPRA_VIDEO_DETECT_RATIO_WEIGHT", 80) KEEP_SCORE = envint("XPRA_VIDEO_DETECT_KEEP_SCORE", 160) def scoreinout(ww, wh, region, incount, outcount): total = incount+outcount assert total>0 #proportion of damage events that are within this region: inregion = float(incount)/total #devaluate by taking into account the number of pixels in the area #so that a large video region only wins if it really
# -*- coding: utf-8 -*- # This file is part of Xpra. # Copyright (C) 2010-2018 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("av-sync") from xpra.util import envint from xpra.server.source.stub_source_mixin import StubSourceMixin AV_SYNC_DELTA = envint("XPRA_AV_SYNC_DELTA", 0) class AVSyncMixin(StubSourceMixin): def __init__(self, av_sync): self.av_sync = av_sync def cleanup(self): self.init_state() def init_state(self): self.av_sync_enabled = False self.av_sync_delay = 0 self.av_sync_delay_total = 0 self.av_sync_delta = AV_SYNC_DELTA def get_info(self): return { "av-sync": {
from xpra.client.client_base import XpraClientBase, EXTRA_TIMEOUT from xpra.exit_codes import ( EXIT_OK, EXIT_CONNECTION_LOST, EXIT_TIMEOUT, EXIT_INTERNAL_ERROR, EXIT_FAILURE, EXIT_UNSUPPORTED, EXIT_REMOTE_ERROR, EXIT_FILE_TOO_BIG, ) from xpra.log import Logger log = Logger("gobject", "client") FLATTEN_INFO = envint("XPRA_FLATTEN_INFO", 1) def errwrite(msg): try: sys.stderr.write(msg) sys.stderr.flush() except (OSError, AttributeError): pass class GObjectXpraClient(GObject.GObject, XpraClientBase): """ Utility superclass for GObject clients """ COMMAND_TIMEOUT = EXTRA_TIMEOUT
from queue import Queue from xpra.make_thread import start_thread from xpra.os_util import monotonic_time from xpra.util import notypedict, envbool, envint, typedict, AtomicInteger from xpra.net.compression import compressed_wrapper, Compressed from xpra.server.source.source_stats import GlobalPerformanceStatistics from xpra.server.source.stub_source_mixin import StubSourceMixin from xpra.log import Logger log = Logger("server") notifylog = Logger("notify") bandwidthlog = Logger("bandwidth") BANDWIDTH_DETECTION = envbool("XPRA_BANDWIDTH_DETECTION", True) MIN_BANDWIDTH = envint("XPRA_MIN_BANDWIDTH", 5 * 1024 * 1024) AUTO_BANDWIDTH_PCT = envint("XPRA_AUTO_BANDWIDTH_PCT", 80) assert 1 < AUTO_BANDWIDTH_PCT <= 100, "invalid value for XPRA_AUTO_BANDWIDTH_PCT: %i" % AUTO_BANDWIDTH_PCT YIELD = envbool("XPRA_YIELD", False) counter = AtomicInteger() """ This class mediates between the server class (which only knows about actual window objects and display server events) and the client specific WindowSource instances (which only know about window ids and manage window pixel compression). It sends messages to the client via its 'protocol' instance (the network connection), directly for a number of cases (cursor, sound, notifications, etc) or on behalf of the window sources for pixel data. Strategy: if we have 'ordinary_packets' to send, send those. When we don't, then send packets from the 'packet_queue'. (compressed pixels or clipboard data)
# This file is part of Xpra. # Copyright (C) 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 os.path import socket from xpra.scripts.config import InitException from xpra.os_util import getuid, get_username_for_uid, get_groups, get_group_id, path_permission_info, monotonic_time, WIN32, OSX, POSIX from xpra.util import envint, envbool, csv, DEFAULT_PORT from xpra.platform.dotxpra import DotXpra, norm_makepath #what timeout value to use on the socket probe attempt: WAIT_PROBE_TIMEOUT = envint("XPRA_WAIT_PROBE_TIMEOUT", 6) def add_cleanup(f): from xpra.scripts import server server.add_cleanup(f) network_logger = None def get_network_logger(): global network_logger if not network_logger: from xpra.log import Logger network_logger = Logger("network") return network_logger
# Copyright (C) 2012-2016 Antoine Martin <*****@*****.**> # Copyright (C) 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 threading import binascii from xpra.log import Logger log = Logger("proxy") from xpra.net.bytestreams import untilConcludes from xpra.util import repr_ellipsized, envint, envbool SHOW_DATA = envbool("XPRA_PROXY_SHOW_DATA") PROXY_BUFFER_SIZE = envint("XPRA_PROXY_BUFFER_SIZE", 65536) class XpraProxy(object): """ This is the proxy command that runs when one uses the hidden subcommand "xpra _proxy" or when forwarding data using the tcp-proxy option. It simply forwards stdin/stdout to the server socket. """ def __repr__(self): return "XpraProxy(%s: %s - %s)" % (self._name, self._client_conn, self._server_conn)
from xpra.log import Logger log = Logger("paint") deltalog = Logger("delta") from threading import Lock from xpra.net.mmap_pipe import mmap_read from xpra.net import compression from xpra.util import typedict, csv, envint, envbool from xpra.codecs.loader import get_codec from xpra.codecs.video_helper import getVideoHelper from xpra.os_util import BytesIOClass, bytestostr, _buffer from xpra.codecs.xor.cyxor import xor_str # @UnresolvedImport from xpra.codecs.argb.argb import unpremultiply_argb, unpremultiply_argb_in_place # @UnresolvedImport DELTA_BUCKETS = envint("XPRA_DELTA_BUCKETS", 5) INTEGRITY_HASH = envbool("XPRA_INTEGRITY_HASH", False) WEBP_PILLOW = envbool("XPRA_WEBP_PILLOW", False) # ie: # CSC_OPTIONS = { "YUV420P" : {"RGBX" : [opencl.spec, swscale.spec], "BGRX" : ...} } CSC_OPTIONS = None def load_csc_options(): global CSC_OPTIONS if CSC_OPTIONS is None: CSC_OPTIONS = {} vh = getVideoHelper() for csc_in in vh.get_csc_inputs(): CSC_OPTIONS[csc_in] = vh.get_csc_specs(csc_in)
gui_init() from xpra.gtk_common.gobject_compat import import_gtk, import_gdk, import_pango, is_gtk3 gtk = import_gtk() gdk = import_gdk() pango = import_pango() from xpra.gtk_common.gtk_util import gtk_main, add_close_accel, scaled_image, pixbuf_new_from_file, get_display_info, \ JUSTIFY_LEFT, WIN_POS_CENTER, STATE_NORMAL, FILE_CHOOSER_ACTION_SAVE, choose_file, get_gtk_version_info from xpra.util import nonl, envint from xpra.os_util import strtobytes from xpra.log import Logger log = Logger("util") STEP_DELAY = envint("XPRA_BUG_REPORT_STEP_DELAY", 0) class BugReport(object): def init(self, show_about=True, get_server_info=None, opengl_info=None, includes={}): self.show_about = show_about self.get_server_info = get_server_info self.opengl_info = opengl_info self.includes = includes self.setup_window() def setup_window(self): self.window = gtk.Window() self.window.connect("destroy", self.close) self.window.set_default_size(400, 300)
from xpra.version_util import local_version from xpra.make_thread import start_thread from xpra.scripts.config import parse_number, parse_bool from xpra.scripts.server import create_unix_domain_socket from xpra.platform.dotxpra import DotXpra from xpra.net.bytestreams import SocketConnection, SOCKET_TIMEOUT from multiprocessing import Process try: from xpra.codecs.xor.cyxor import xor_str #@UnresolvedImport xor = xor_str except: pass PROXY_QUEUE_SIZE = envint("XPRA_PROXY_QUEUE_SIZE", 10) #for testing only: passthrough as RGB: PASSTHROUGH = envbool("XPRA_PROXY_PASSTHROUGH", False) MAX_CONCURRENT_CONNECTIONS = 20 VIDEO_TIMEOUT = 5 #destroy video encoder after N seconds of idle state def set_blocking(conn): #Note: importing set_socket_timeout from xpra.net.bytestreams #fails in mysterious ways, so we duplicate the code here instead log("set_blocking(%s)", conn) try: log("calling %s.setblocking(1)", conn._socket) conn._socket.setblocking(1) except: log("cannot set %s to blocking mode", conn)
import os import time import subprocess, shlex import hashlib import uuid from xpra.log import Logger printlog = Logger("printing") filelog = Logger("file") from xpra.child_reaper import getChildReaper from xpra.util import typedict, csv, nonl, envint, envbool from xpra.simple_stats import std_unit DELETE_PRINTER_FILE = envbool("XPRA_DELETE_PRINTER_FILE", True) FILE_CHUNKS_SIZE = max(0, envint("XPRA_FILE_CHUNKS_SIZE", 65536)) MAX_CONCURRENT_FILES = max(1, envint("XPRA_MAX_CONCURRENT_FILES", 10)) CHUNK_TIMEOUT = 10 * 1000 MIMETYPE_EXTS = { "application/postscript": "ps", "application/pdf": "pdf", "raw": "raw", } def safe_open_download_file(basefilename, mimetype): from xpra.platform.paths import get_download_dir #make sure we use a filename that does not exist already: dd = os.path.expanduser(get_download_dir()) wanted_filename = os.path.abspath(
#default implementation using pycups import sys import os import cups import time import subprocess import shlex import urllib from threading import Lock from xpra.util import engs, envint, envbool from xpra.log import Logger log = Logger("printing") SIMULATE_PRINT_FAILURE = envint("XPRA_SIMULATE_PRINT_FAILURE") RAW_MODE = envbool("XPRA_PRINTER_RAW", False) GENERIC = envbool("XPRA_PRINTERS_GENERIC", True) FORWARDER_TMPDIR = os.environ.get("XPRA_FORWARDER_TMPDIR", os.environ.get("TMPDIR", "/tmp")) #the mimetype to use for clients that do not specify one #(older clients just assumed postscript) DEFAULT_MIMETYPE = os.environ.get("XPRA_PRINTER_DEFAULT_MIMETYPE", "application/postscript") LPADMIN = "lpadmin" LPINFO = "lpinfo" ADD_OPTIONS = ["-E", "-o printer-is-shared=false", "-u allow:$USER"] FORWARDER_BACKEND = "xpraforwarder" SKIPPED_PRINTERS = os.environ.get("XPRA_SKIPPED_PRINTERS", "Cups-PDF").split(",")
WestGravity, CenterGravity, EastGravity, SouthWestGravity, SouthGravity, SouthEastGravity, StaticGravity, GRAVITY_STR, ) from xpra.log import Logger log = Logger("paint") videolog = Logger("video", "paint") INTEGRITY_HASH = envbool("XPRA_INTEGRITY_HASH", False) PAINT_BOX = envint("XPRA_PAINT_BOX", 0) or envint("XPRA_OPENGL_PAINT_BOX", 0) WEBP_PILLOW = envbool("XPRA_WEBP_PILLOW", False) SCROLL_ENCODING = envbool("XPRA_SCROLL_ENCODING", True) REPAINT_ALL = envbool("XPRA_REPAINT_ALL", False) #ie: #CSC_OPTIONS = { "YUV420P" : {"RGBX" : [swscale.spec], "BGRX" : ...} } CSC_OPTIONS = None def load_csc_options(): global CSC_OPTIONS if CSC_OPTIONS is None: CSC_OPTIONS = {} vh = getVideoHelper() for csc_in in vh.get_csc_inputs():
import os import time import subprocess, shlex import hashlib import uuid from xpra.log import Logger printlog = Logger("printing") filelog = Logger("file") from xpra.child_reaper import getChildReaper from xpra.util import typedict, csv, nonl, envint, envbool from xpra.simple_stats import std_unit DELETE_PRINTER_FILE = envbool("XPRA_DELETE_PRINTER_FILE", True) FILE_CHUNKS_SIZE = max(0, envint("XPRA_FILE_CHUNKS_SIZE", 65536)) MAX_CONCURRENT_FILES = max(1, envint("XPRA_MAX_CONCURRENT_FILES", 10)) CHUNK_TIMEOUT = 10*1000 MIMETYPE_EXTS = { "application/postscript" : "ps", "application/pdf" : "pdf", "raw" : "raw", } def safe_open_download_file(basefilename, mimetype): from xpra.platform.paths import get_download_dir #make sure we use a filename that does not exist already: dd = os.path.expanduser(get_download_dir()) wanted_filename = os.path.abspath(os.path.join(dd, os.path.basename(basefilename)))
from xpra.os_util import WIN32, POSIX, monotonic_time from xpra.util import csv, envint, envbool, repr_ellipsized from xpra.platform.features import CLIPBOARD_GREEDY MIN_CLIPBOARD_COMPRESSION_SIZE = 512 MAX_CLIPBOARD_PACKET_SIZE = 4 * 1024 * 1024 from xpra.platform.features import CLIPBOARDS as PLATFORM_CLIPBOARDS ALL_CLIPBOARDS = PLATFORM_CLIPBOARDS CLIPBOARDS = PLATFORM_CLIPBOARDS CLIPBOARDS_ENV = os.environ.get("XPRA_CLIPBOARDS") if CLIPBOARDS_ENV is not None: CLIPBOARDS = CLIPBOARDS_ENV.split(",") CLIPBOARDS = [x.upper().strip() for x in CLIPBOARDS] TEST_DROP_CLIPBOARD_REQUESTS = envint("XPRA_TEST_DROP_CLIPBOARD") STORE_ON_EXIT = envbool("XPRA_CLIPBOARD_STORE_ON_EXIT", True) DELAY_SEND_TOKEN = envint("XPRA_DELAY_SEND_TOKEN", 100) _discard_target_strs_ = os.environ.get("XPRA_DISCARD_TARGETS") if _discard_target_strs_ is not None: DISCARD_TARGETS = _discard_target_strs_.split(",") else: #default: DISCARD_TARGETS = [ "^SAVE_TARGETS$", "^COMPOUND_TEXT", "^NeXT", "^com\.apple\.", "^CorePasteboardFlavorType", "^dyn\." ] log("DISCARD_TARGETS=%s", csv(DISCARD_TARGETS)) DISCARD_TARGETS = [re.compile(x) for x in DISCARD_TARGETS]
# This file is part of Xpra. # Copyright (C) 2013 Serviware (Arthur Huillet, <*****@*****.**>) # Copyright (C) 2012-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 time, math from xpra.util import envint, envbool from xpra.log import Logger log = Logger("opengl", "paint") fpslog = Logger("opengl", "fps") OPENGL_DEBUG = envbool("XPRA_OPENGL_DEBUG", False) OPENGL_PAINT_BOX = envint("XPRA_OPENGL_PAINT_BOX", 0) SCROLL_ENCODING = envbool("XPRA_SCROLL_ENCODING", True) PAINT_FLUSH = envbool("XPRA_PAINT_FLUSH", True) SAVE_BUFFERS = os.environ.get("XPRA_OPENGL_SAVE_BUFFERS") if SAVE_BUFFERS not in ("png", "jpeg", None): log.warn("invalid value for XPRA_OPENGL_SAVE_BUFFERS: must be 'png' or 'jpeg'") SAVE_BUFFERS = None from xpra.gtk_common.gtk_util import color_parse, is_realized _DEFAULT_BOX_COLORS = { "png" : "yellow", "h264" : "blue", "vp8" : "green",
# 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 from xpra.log import Logger log = Logger("clipboard") from xpra.net.compression import Compressible from xpra.server.source.stub_source_mixin import StubSourceMixin from xpra.platform.features import CLIPBOARDS from xpra.util import envint, XPRA_CLIPBOARD_NOTIFICATION_ID from xpra.os_util import monotonic_time MAX_CLIPBOARD_LIMIT = envint("XPRA_CLIPBOARD_LIMIT", 30) MAX_CLIPBOARD_LIMIT_DURATION = envint("XPRA_CLIPBOARD_LIMIT_DURATION", 3) class ClipboardConnection(StubSourceMixin): def init_from(self, _protocol, _server): pass def init_state(self): self.clipboard_enabled = False self.clipboard_notifications = False self.clipboard_notifications_current = 0 self.clipboard_notifications_pending = 0 self.clipboard_set_enabled = False self.clipboard_progress_timer = None self.clipboard_stats = deque(maxlen=MAX_CLIPBOARD_LIMIT *
if sys.version > '3': unicode = str #@ReservedAssignment #used on the server (reversed): XPRA_PULSE_SOURCE_DEVICE_NAME = "Speaker" XPRA_PULSE_SINK_DEVICE_NAME = "Microphone" GST_QUEUE_NO_LEAK = 0 GST_QUEUE_LEAK_UPSTREAM = 1 GST_QUEUE_LEAK_DOWNSTREAM = 2 GST_QUEUE_LEAK_DEFAULT = GST_QUEUE_LEAK_DOWNSTREAM MS_TO_NS = 1000000 QUEUE_LEAK = envint("XPRA_SOUND_QUEUE_LEAK", GST_QUEUE_LEAK_DEFAULT) if QUEUE_LEAK not in (GST_QUEUE_NO_LEAK, GST_QUEUE_LEAK_UPSTREAM, GST_QUEUE_LEAK_DOWNSTREAM): log.error("invalid leak option %s", QUEUE_LEAK) QUEUE_LEAK = GST_QUEUE_LEAK_DEFAULT def get_queue_time(default_value=450, prefix=""): queue_time = int(os.environ.get("XPRA_SOUND_QUEUE_%sTIME" % prefix, default_value))*MS_TO_NS queue_time = max(0, queue_time) return queue_time ALLOW_SOUND_LOOP = envbool("XPRA_ALLOW_SOUND_LOOP", False) PULSEAUDIO_DEVICE_NAME = os.environ.get("XPRA_PULSEAUDIO_DEVICE_NAME", "") USE_DEFAULT_DEVICE = envbool("XPRA_USE_DEFAULT_DEVICE", True) def force_enabled(codec_name): return os.environ.get("XPRA_SOUND_CODEC_ENABLE_%s" % codec_name.upper(), "0")=="1"
#!/usr/bin/env python # This file is part of Xpra. # 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. import os import sys import socket from xpra.util import envint, obsc, typedict from xpra.os_util import bytestostr from xpra.server.auth.sys_auth_base import SysAuthenticatorBase, log, parse_uid, parse_gid from xpra.log import is_debug_enabled, enable_debug_for LDAP_REFERRALS = envint("XPRA_LDAP_REFERRALS", 0) LDAP_PROTOCOL_VERSION = envint("XPRA_LDAP_PROTOCOL_VERSION", 3) LDAP_TRACE_LEVEL = envint("XPRA_LDAP_TRACE_LEVEL") LDAP_CACERTFILE = os.environ.get("XPRA_LDAP_CACERTFILE") LDAP_ENCODING = os.environ.get("XPRA_LDAP_ENCODING", "utf-8") class Authenticator(SysAuthenticatorBase): def __init__(self, username, **kwargs): self.tls = bool(int(kwargs.pop("tls", "0"))) self.host = kwargs.pop("host", "localhost") self.cacert = kwargs.pop("cacert", LDAP_CACERTFILE) self.encoding = kwargs.pop("encoding", LDAP_ENCODING) self.uid = parse_uid(kwargs.pop("uid", None)) self.gid = parse_gid(kwargs.pop("gid", None))
log = Logger("window") plog = Logger("paint") focuslog = Logger("focus") mouselog = Logger("mouse") workspacelog = Logger("workspace") keylog = Logger("keyboard") metalog = Logger("metadata") geomlog = Logger("geometry") iconlog = Logger("icon") alphalog = Logger("alpha") SIMULATE_MOUSE_DOWN = envbool("XPRA_SIMULATE_MOUSE_DOWN", True) PROPERTIES_DEBUG = [x.strip() for x in os.environ.get("XPRA_WINDOW_PROPERTIES_DEBUG", "").split(",")] SET_SIZE_CONSTRAINTS = envbool("XPRA_SET_SIZE_CONSTRAINTS", True) DEFAULT_GRAVITY = envint("XPRA_DEFAULT_GRAVITY", 0) OVERRIDE_GRAVITY = envint("XPRA_OVERRIDE_GRAVITY", 0) FORCE_FLUSH = envbool("XPRA_FORCE_FLUSH", False) class ClientWindowBase(ClientWidgetBase): def __init__(self, client, group_leader, watcher_pid, wid, wx, wy, ww, wh, bw, bh, metadata, override_redirect, client_properties, border, max_window_size, default_cursor_data, pixel_depth, headerbar="no"): log("%s%s", type(self), (client, group_leader, watcher_pid, wid, wx, wy, ww, wh, bw, bh, metadata, override_redirect, client_properties,
#so that we can interact with it using a standard xpra protocol layer #there is a wrapper for the caller #and one for the class #they talk to each other through stdin / stdout, #using the protocol for encoding the data DEBUG_WRAPPER = envbool("XPRA_WRAPPER_DEBUG", False) #to make it possible to inspect files (more human readable): HEXLIFY_PACKETS = envbool("XPRA_HEXLIFY_PACKETS", False) #avoids showing a new console window on win32: WIN32_SHOWWINDOW = envbool("XPRA_WIN32_SHOWWINDOW", False) #this used to cause problems with py3k / gi bindings? HANDLE_SIGINT = envbool("XPRA_WRAPPER_SIGINT", True) FAULT_RATE = envint("XPRA_WRAPPER_FAULT_INJECTION_RATE") if FAULT_RATE>0: _counter = 0 def INJECT_FAULT(p): global _counter _counter += 1 if (_counter % FAULT_RATE)==0: log.warn("injecting fault in %s", p) p.raw_write("Wrapper JUNK! added by fault injection code") else: def INJECT_FAULT(p): pass def setup_fastencoder_nocompression(protocol): from xpra.net.packet_encoding import get_enabled_encoders, PERFORMANCE_ORDER
# This file is part of Xpra. # Copyright (C) 2010-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. #pylint: disable-msg=E1101 from xpra.platform.gui import get_native_tray_classes, get_native_tray_menu_helper_class from xpra.os_util import bytestostr, strtobytes from xpra.util import nonl, envint, make_instance, CLIENT_EXIT, XPRA_APP_ID from xpra.client.mixins.stub_client_mixin import StubClientMixin from xpra.log import Logger log = Logger("tray") TRAY_DELAY = envint("XPRA_TRAY_DELAY", 0) """ Mixin for supporting our system tray (not forwarding other application's trays - that's handled in WindowClient) """ class TrayClient(StubClientMixin): def __init__(self): StubClientMixin.__init__(self) #settings: self.tray_enabled = False self.delay_tray = False self.tray_icon = None #state: self.tray = None self.menu_helper = None
import binascii from subprocess import Popen, PIPE from threading import Event from time import monotonic import paramiko from xpra.net.ssh import SSHSocketConnection from xpra.net.bytestreams import pretty_socket from xpra.util import csv, envint, first_time, decode_str from xpra.os_util import osexpand, getuid, WIN32, POSIX from xpra.platform.paths import get_ssh_conf_dirs from xpra.log import Logger log = Logger("network", "ssh") SERVER_WAIT = envint("XPRA_SSH_SERVER_WAIT", 20) AUTHORIZED_KEYS = "~/.ssh/authorized_keys" AUTHORIZED_KEYS_HASHES = os.environ.get( "XPRA_AUTHORIZED_KEYS_HASHES", "md5,sha1,sha224,sha256,sha384,sha512").split(",") class SSHServer(paramiko.ServerInterface): def __init__(self, none_auth=False, pubkey_auth=True, password_auth=None): self.event = Event() self.none_auth = none_auth self.pubkey_auth = pubkey_auth self.password_auth = password_auth self.proxy_channel = None def get_allowed_auths(self, username):
import os from xpra.codecs.codec_constants import PREFERRED_ENCODING_ORDER, PROBLEMATIC_ENCODINGS 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(",") """ Mixin for adding encodings to a client """ class Encodings(StubClientMixin):
glib = import_glib() SINK_SHARED_DEFAULT_ATTRIBUTES = {"sync" : False, "async" : True, "qos" : True } SINK_DEFAULT_ATTRIBUTES = { "pulsesink" : {"client-name" : "Xpra"}, } QUEUE_SILENT = envbool("XPRA_QUEUE_SILENT", False) QUEUE_TIME = get_queue_time(450) UNMUTE_DELAY = envint("XPRA_UNMUTE_DELAY", 1000) GRACE_PERIOD = envint("XPRA_SOUND_GRACE_PERIOD", 2000) #percentage: from 0 for no margin, to 200% which triples the buffer target MARGIN = max(0, min(200, envint("XPRA_SOUND_MARGIN", 50))) #how high we push up the min-level to prevent underruns: UNDERRUN_MIN_LEVEL = max(0, envint("XPRA_SOUND_UNDERRUN_MIN_LEVEL", 150)) GST_FORMAT_BYTES = 2 GST_FORMAT_TIME = 3 GST_FORMAT_BUFFERS = 4 BUFFER_FORMAT = GST_FORMAT_BUFFERS GST_APP_STREAM_TYPE_STREAM = 0 STREAM_TYPE = GST_APP_STREAM_TYPE_STREAM
# later version. See the file COPYING for details. import os import time import subprocess from unit.process_test_util import ProcessTestUtil from xpra.util import envint from xpra.os_util import pollwait, WIN32 from xpra.exit_codes import EXIT_STR from xpra.platform.dotxpra import DotXpra, DISPLAY_PREFIX from xpra.log import Logger log = Logger("test") SERVER_TIMEOUT = envint("XPRA_TEST_SERVER_TIMEOUT", 8) STOP_WAIT_TIMEOUT = envint("XPRA_STOP_WAIT_TIMEOUT", 20) def estr(r): s = EXIT_STR.get(r) if s: return "%s : %s" % (r, s) return str(r) class ServerTestUtil(ProcessTestUtil): @classmethod def displays(cls): return cls.dotxpra.displays()
#to make it possible to inspect files (more human readable): HEXLIFY_PACKETS = envbool("XPRA_HEXLIFY_PACKETS", False) #avoids showing a new console window on win32: WIN32_SHOWWINDOW = envbool("XPRA_WIN32_SHOWWINDOW", False) #assume that the subprocess is running the same version of xpra, #so we can set the packet aliases without exchanging and parsing caps: #(this can break, ie: if both python2 and python3 builds are installed # and the python2 builds are from an older version) LOCAL_ALIASES = envbool("XPRA_LOCAL_ALIASES", False) LOCAL_SEND_ALIASES = dict((v, i) for i, v in enumerate(PACKET_TYPES)) LOCAL_RECEIVE_ALIASES = dict(enumerate(PACKET_TYPES)) FLUSH = envbool("XPRA_SUBPROCESS_FLUSH", False) FAULT_RATE = envint("XPRA_WRAPPER_FAULT_INJECTION_RATE") def nofault(_p): """ by default, don't inject any errors """ INJECT_FAULT = nofault if FAULT_RATE > 0: _counter = 0 def DO_INJECT_FAULT(p): global _counter _counter += 1 if (_counter % FAULT_RATE) == 0: log.warn("injecting fault in %s", p)
# later version. See the file COPYING for details. import os import re from collections import deque from xpra.log import Logger log = Logger("network") bandwidthlog = Logger("bandwidth") from xpra.os_util import monotonic_time, get_user_uuid, POSIX from xpra.util import envint, csv from xpra.exit_codes import EXIT_TIMEOUT from xpra.client.mixins.stub_client_mixin import StubClientMixin FAKE_BROKEN_CONNECTION = envint("XPRA_FAKE_BROKEN_CONNECTION") PING_TIMEOUT = envint("XPRA_PING_TIMEOUT", 60) #LOG_INFO_RESPONSE = ("^window.*position", "^window.*size$") LOG_INFO_RESPONSE = os.environ.get("XPRA_LOG_INFO_RESPONSE", "") """ Mixin for adding server / network state monitoring functions: - ping and echo - info request and response """ class NetworkState(StubClientMixin): def __init__(self): StubClientMixin.__init__(self) self.uuid = get_user_uuid()
# 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. import os from xpra.net.compression import Compressed from xpra.server.source.stub_source_mixin import StubSourceMixin from xpra.os_util import get_machine_id, get_user_uuid, bytestostr, POSIX from xpra.util import csv, envbool, envint, flatten_dict, typedict, XPRA_AUDIO_NOTIFICATION_ID from xpra.log import Logger log = Logger("sound") NEW_STREAM_SOUND = envbool("XPRA_NEW_STREAM_SOUND", True) NEW_STREAM_SOUND_STOP = envint("XPRA_NEW_STREAM_SOUND_STOP", 20) class AudioMixin(StubSourceMixin): @classmethod def is_needed(cls, caps: typedict) -> bool: return caps.boolget("sound.send") or caps.boolget("sound.receive") def __init__(self): self.sound_properties = {} self.sound_source_plugin = "" self.supports_speaker = False self.speaker_codecs = [] self.supports_microphone = False self.microphone_codecs = []
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) LOG_TIMEOUTS = envint("XPRA_LOG_TIMEOUTS", 1) #on some platforms (ie: OpenBSD), reading and writing from sockets #raises an IOError but we should continue if the error code is EINTR #this wrapper takes care of it. #EWOULDBLOCK can also be hit with the proxy server when we handover the socket CONTINUE_ERRNO = {errno.EINTR: "EINTR", errno.EWOULDBLOCK: "EWOULDBLOCK"} ABORT = { errno.ENXIO: "ENXIO", errno.ECONNRESET: "ECONNRESET", errno.EPIPE: "EPIPE",
#allows us to skip some printers we don't want to export SKIPPED_PRINTERS = os.environ.get("XPRA_SKIPPED_PRINTERS", "Microsoft XPS Document Writer,Fax").split(",") PRINTER_ENUM_VALUES = {} PRINTER_ENUM_NAMES = {} for k in ("LOCAL", "NAME", "SHARED", "CONNECTIONS", "NETWORK", "REMOTE", "CATEGORY_3D", "CATEGORY_ALL"): v = getattr(win32print, "PRINTER_ENUM_%s" % k, None) if v is not None: PRINTER_ENUM_VALUES[k] = v PRINTER_ENUM_NAMES[v] = k log("PRINTER_ENUM_VALUES: %s", PRINTER_ENUM_VALUES) PRINTER_LEVEL = envint("XPRA_WIN32_PRINTER_LEVEL", 1) #DEFAULT_PRINTER_FLAGS = "LOCAL" DEFAULT_PRINTER_FLAGS = "LOCAL,SHARED+NETWORK+CONNECTIONS" PRINTER_FLAGS = [x.strip() for x in os.environ.get("XPRA_WIN32_PRINTER_FLAGS", DEFAULT_PRINTER_FLAGS).split(",")] log("PRINTER_FLAGS=%s", csv(PRINTER_FLAGS)) VALID_PRINTER_FLAGS = ("LOCAL", "SHARED", "CONNECTIONS", "NETWORK", "REMOTE") PRINTER_ENUMS = [] for v in PRINTER_FLAGS: #ie: "SHARED+NETWORK+CONNECTIONS" flags = v.replace('|','+').split("+") #ie: ["SHARED", "NETWORK", "CONNECTIONS"] values = [] for flag in flags: #ie: "SHARED" if flag not in VALID_PRINTER_FLAGS: log.warn("Warning: the following printer flag is invalid and will be ignored: %s", flag) else: values.append(flag) #ie: "SHARED" PRINTER_ENUMS.append(values)
TRAY_ORIENTATION_HORZ = 0 TRAY_ORIENTATION_VERT = 1 XPRA_TRAY_WINDOW_PROPERTY = "_xpra_tray_window_" SYSTEM_TRAY_REQUEST_DOCK = 0 SYSTEM_TRAY_BEGIN_MESSAGE = 1 SYSTEM_TRAY_CANCEL_MESSAGE = 2 #TRANSPARENCY = False TRANSPARENCY = True #Java can send this message to the tray (no idea why): IGNORED_MESSAGE_TYPES = ("_GTK_LOAD_ICONTHEMES", ) MAX_TRAY_SIZE = envint("XPRA_MAX_TRAY_SIZE", 64) def get_tray_window(tray_window): return getattr(tray_window, XPRA_TRAY_WINDOW_PROPERTY, None) def set_tray_window(tray_window, window): setattr(tray_window, XPRA_TRAY_WINDOW_PROPERTY, window.get_xid()) def set_tray_visual(tray_window, gdk_visual): prop_set(tray_window, TRAY_VISUAL, "visual", gdk_visual) def set_tray_orientation(tray_window, orientation):
# Copyright (C) 2008 Nathaniel Smith <*****@*****.**> # Copyright (C) 2012-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. #pygtk3 vs pygtk2 (sigh) from xpra.gtk_common.gobject_compat import import_glib glib = import_glib() from xpra.client.window_backing_base import fire_paint_callbacks from xpra.util import envint from xpra.log import Logger log = Logger("window", "fake") FAKE_BACKING_DELAY = envint("XPRA_FAKE_BACKING_DELAY", 5) class FakeBacking(object): HAS_ALPHA = True def __init__(self, wid, *args): self.wid = wid self.fake_delay = FAKE_BACKING_DELAY self._video_encoder, self._video_encoder_lock, self._video_encoder_speed, self._video_encoder_quality = None, None, [], [] def close(self): pass def draw_region(self, x, y, width, height, coding, img_data, rowstride, options, callbacks):
# -*- coding: utf-8 -*- # This file is part of Xpra. # Copyright (C) 2010-2018 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("webcam") from xpra.os_util import BytesIOClass, POSIX, OSX from xpra.util import envint, csv from xpra.server.source.stub_source_mixin import StubSourceMixin MAX_WEBCAM_DEVICES = envint("XPRA_MAX_WEBCAM_DEVICES", 1) """ Handle webcam forwarding. """ class WebcamMixin(StubSourceMixin): def __init__(self): self.webcam_enabled = False self.webcam_device = None self.webcam_encodings = [] def init_from(self, _protocol, server): self.webcam_enabled = server.webcam_enabled self.webcam_device = server.webcam_device self.webcam_encodings = server.webcam_encodings log("WebcamMixin: enabled=%s, device=%s, encodings=%s", self.webcam_enabled, self.webcam_device, self.webcam_encodings)
# This file is part of Xpra. # Copyright (C) 2013-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 time import threading from threading import Event from xpra.make_thread import start_thread from xpra.log import Logger from xpra.util import envint log = Logger("util") from xpra.platform.features import UI_THREAD_POLLING FAKE_UI_LOCKUPS = envint("XPRA_FAKE_UI_LOCKUPS") if FAKE_UI_LOCKUPS>0 and UI_THREAD_POLLING<=0: #even if the platform normally disables UI thread polling, #we need it for testing: UI_THREAD_POLLING = 1000 POLLING = envint("XPRA_UI_THREAD_POLLING", UI_THREAD_POLLING) class UI_thread_watcher(object): """ Allows us to register callbacks to fire when the UI thread fails to run or when it resumes. We run a dedicated thread to verify that the UI thread has run since the last time it was scheduled to run. Beware that the callbacks (fail, resume and alive)
get_encoder_default_options, normv, get_encoders, get_queue_time, has_plugins, MP3, CODEC_ORDER, MUXER_DEFAULT_OPTIONS, ENCODER_NEEDS_AUDIOCONVERT, SOURCE_NEEDS_AUDIOCONVERT, ENCODER_CANNOT_USE_CUTTER, CUTTER_NEEDS_CONVERT, CUTTER_NEEDS_RESAMPLE, MS_TO_NS, GST_QUEUE_LEAK_DOWNSTREAM, GST_FLOW_OK, ) from xpra.net.compression import compressed_wrapper from xpra.scripts.config import InitExit from xpra.log import Logger log = Logger("sound") gstlog = Logger("gstreamer") APPSINK = os.environ.get("XPRA_SOURCE_APPSINK", "appsink name=sink emit-signals=true max-buffers=10 drop=true sync=false async=false qos=false") JITTER = envint("XPRA_SOUND_SOURCE_JITTER", 0) SOURCE_QUEUE_TIME = get_queue_time(50, "SOURCE_") BUFFER_TIME = envint("XPRA_SOUND_SOURCE_BUFFER_TIME", 0) #ie: 64 LATENCY_TIME = envint("XPRA_SOUND_SOURCE_LATENCY_TIME", 0) #ie: 32 BUNDLE_METADATA = envbool("XPRA_SOUND_BUNDLE_METADATA", True) LOG_CUTTER = envbool("XPRA_SOUND_LOG_CUTTER", False) SAVE_TO_FILE = os.environ.get("XPRA_SAVE_TO_FILE") CUTTER_THRESHOLD = envfloat("XPRA_CUTTER_THRESHOLD", "0.0001") CUTTER_PRE_LENGTH = envint("XPRA_CUTTER_PRE_LENGTH", 100) CUTTER_RUN_LENGTH = envint("XPRA_CUTTER_RUN_LENGTH", 1000) generation = AtomicInteger() class SoundSource(SoundPipeline):
import time from xpra.os_util import SIGNAMES, Queue from xpra.util import csv, envint, envbool, AtomicInteger from xpra.sound.sound_pipeline import SoundPipeline from xpra.gtk_common.gobject_util import n_arg_signal, gobject from xpra.sound.gstreamer_util import get_source_plugins, plugin_str, get_encoder_elements, get_encoder_default_options, normv, get_encoders, get_queue_time, \ MP3, CODEC_ORDER, MUXER_DEFAULT_OPTIONS, ENCODER_NEEDS_AUDIOCONVERT, SOURCE_NEEDS_AUDIOCONVERT, MS_TO_NS, GST_QUEUE_LEAK_DOWNSTREAM from xpra.net.compression import compressed_wrapper from xpra.scripts.config import InitExit from xpra.log import Logger log = Logger("sound") gstlog = Logger("gstreamer") APPSINK = os.environ.get("XPRA_SOURCE_APPSINK", "appsink name=sink emit-signals=true max-buffers=10 drop=true sync=false async=false qos=false") JITTER = envint("XPRA_SOUND_SOURCE_JITTER", 0) SOURCE_QUEUE_TIME = get_queue_time(50, "SOURCE_") BUFFER_TIME = envint("XPRA_SOUND_SOURCE_BUFFER_TIME", 0) #ie: 64 LATENCY_TIME = envint("XPRA_SOUND_SOURCE_LATENCY_TIME", 0) #ie: 32 BUNDLE_METADATA = envbool("XPRA_SOUND_BUNDLE_METADATA", True) SAVE_TO_FILE = os.environ.get("XPRA_SAVE_TO_FILE") generation = AtomicInteger() class SoundSource(SoundPipeline): __gsignals__ = SoundPipeline.__generic_signals__.copy() __gsignals__.update({ "new-buffer" : n_arg_signal(3),
import os from time import monotonic from threading import RLock from xpra.log import Logger from xpra.scripts.config import FALSE_OPTIONS from xpra.net import compression from xpra.os_util import OSEnvContext, WIN32 from xpra.util import envint, envbool, csv, typedict, XPRA_WEBCAM_NOTIFICATION_ID from xpra.client.mixins.stub_client_mixin import StubClientMixin log = Logger("webcam") WEBCAM_ALLOW_VIRTUAL = envbool("XPRA_WEBCAM_ALLOW_VIRTUAL", False) WEBCAM_TARGET_FPS = max(1, min(50, envint("XPRA_WEBCAM_FPS", 20))) class WebcamForwarder(StubClientMixin): """ Mixin for clients that forward webcams """ __signals__ = ["webcam-changed"] def __init__(self): super().__init__() #webcam: self.webcam_option = "" self.webcam_forwarding = False self.webcam_device = None
glib = import_glib() SINK_SHARED_DEFAULT_ATTRIBUTES = {"sync" : False, "async" : True, "qos" : True } SINK_DEFAULT_ATTRIBUTES = { "pulsesink" : {"client-name" : "Xpra"}, } QUEUE_SILENT = envbool("XPRA_QUEUE_SILENT", False) QUEUE_TIME = get_queue_time(450) UNMUTE_DELAY = envint("XPRA_UNMUTE_DELAY", 1000) GRACE_PERIOD = envint("XPRA_SOUND_GRACE_PERIOD", 2000) #percentage: from 0 for no margin, to 200% which triples the buffer target MARGIN = max(0, min(200, envint("XPRA_SOUND_MARGIN", 50))) #how high we push up the min-level to prevent underruns: UNDERRUN_MIN_LEVEL = max(0, envint("XPRA_SOUND_UNDERRUN_MIN_LEVEL", 50)) GST_FORMAT_BYTES = 2 GST_FORMAT_TIME = 3 GST_FORMAT_BUFFERS = 4 BUFFER_FORMAT = GST_FORMAT_BUFFERS GST_APP_STREAM_TYPE_STREAM = 0 STREAM_TYPE = GST_APP_STREAM_TYPE_STREAM
# Copyright (C) 2016-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 os import time import uuid import unittest from xpra.util import envint from xpra.exit_codes import EXIT_STR from xpra.os_util import load_binary_file, pollwait, OSX, POSIX from xpra.platform.paths import get_download_dir from unit.client.x11_client_test_util import X11ClientTestUtil, log CLIENT_TIMEOUT = envint("XPRA_TEST_CLIENT_TIMEOUT", 20) class X11ClientTest(X11ClientTestUtil): def do_test_connect(self, disconnect=True, client_args=(), server_args=()): display = self.find_free_display() log("starting test server on %s", display) server_args = ["--start=xterm"] + list(server_args) server = self.check_start_server(display, *server_args) xvfb1, client1 = self.run_client(display, *client_args) r = pollwait(client1, CLIENT_TIMEOUT) assert r is None, "client1 exited with code %s" % EXIT_STR.get(r, r) xvfb2, client2 = self.run_client(display, *client_args) r = pollwait(client2, CLIENT_TIMEOUT) assert r is None, "client2 exited with code %s" % EXIT_STR.get(r, r) if disconnect:
from xpra.log import Logger log = Logger("x11", "server") keylog = Logger("x11", "server", "keyboard") mouselog = Logger("x11", "server", "mouse") grablog = Logger("server", "grab") cursorlog = Logger("server", "cursor") screenlog = Logger("server", "screen") gllog = Logger("screen", "opengl") from xpra.util import iround, envbool, envint from xpra.server.gtk_server_base import GTKServerBase from xpra.x11.xkbhelper import clean_keyboard_state from xpra.x11.server_keyboard_config import KeyboardConfig MAX_CONCURRENT_CONNECTIONS = envint("XPRA_MAX_CONCURRENT_CONNECTIONS", 20) ALWAYS_NOTIFY_MOTION = envbool("XPRA_ALWAYS_NOTIFY_MOTION", False) def window_name(window): from xpra.x11.gtk_x11.prop import prop_get return prop_get(window, "_NET_WM_NAME", "utf8", True) or "unknown" def window_info(window): from xpra.x11.gtk_x11.prop import prop_get net_wm_name = prop_get(window, "_NET_WM_NAME", "utf8", True) return "%s %s (%s / %s)" % (net_wm_name, window, window.get_geometry(), window.is_visible()) from xpra.x11.gtk2.gdk_bindings import get_children #@UnresolvedImport def dump_windows():
CWWidth: "Width", CWHeight: "Height", CWBorderWidth: "BorderWidth", CWSibling: "Sibling", CWStackMode: "StackMode", CWBorderWidth: "BorderWidth", } def configure_bits(value_mask): return "|".join( (v for k, v in CW_MASK_TO_NAME.items() if (k & value_mask))) VALIDATE_CONFIGURE_REQUEST = envbool("XPRA_VALIDATE_CONFIGURE_REQUEST", False) CLAMP_OVERLAP = envint("XPRA_WINDOW_CLAMP_OVERLAP", 20) assert CLAMP_OVERLAP >= 0 class WindowModel(BaseWindowModel): """This represents a managed client window. It allows one to produce widgets that view that client window in various ways.""" _NET_WM_ALLOWED_ACTIONS = [ "_NET_WM_ACTION_%s" % x for x in ("CLOSE", "MOVE", "RESIZE", "FULLSCREEN", "MINIMIZE", "SHADE", "STICK", "MAXIMIZE_HORZ", "MAXIMIZE_VERT", "CHANGE_DESKTOP", "ABOVE", "BELOW") ] __gproperties__ = dict(BaseWindowModel.__common_properties__)
import win32con #@UnresolvedImport import win32api #@UnresolvedImport import win32gui #@UnresolvedImport WINDOW_HOOKS = envbool("XPRA_WIN32_WINDOW_HOOKS", True) GROUP_LEADER = WINDOW_HOOKS and envbool("XPRA_WIN32_GROUP_LEADER", True) UNDECORATED_STYLE = WINDOW_HOOKS and envbool("XPRA_WIN32_UNDECORATED_STYLE", True) CLIP_CURSOR = WINDOW_HOOKS and envbool("XPRA_WIN32_CLIP_CURSOR", True) #GTK3 is fixed, so we don't need this hook: DEFAULT_MAX_SIZE_HINT = sys.version_info[0]<3 MAX_SIZE_HINT = WINDOW_HOOKS and envbool("XPRA_WIN32_MAX_SIZE_HINT", DEFAULT_MAX_SIZE_HINT) GEOMETRY = WINDOW_HOOKS and envbool("XPRA_WIN32_GEOMETRY", True) LANGCHANGE = WINDOW_HOOKS and envbool("XPRA_WIN32_LANGCHANGE", True) DPI_AWARE = envbool("XPRA_DPI_AWARE", True) DPI_AWARENESS = envint("XPRA_DPI_AWARENESS", 1) FORWARD_WINDOWS_KEY = envbool("XPRA_FORWARD_WINDOWS_KEY", True) WHEEL = envbool("XPRA_WHEEL", True) WHEEL_DELTA = envint("XPRA_WHEEL_DELTA", 120) assert WHEEL_DELTA>0 KNOWN_EVENTS = {} POWER_EVENTS = {} try: for x in dir(win32con): if x.endswith("_EVENT"): v = getattr(win32con, x) KNOWN_EVENTS[v] = x if x.startswith("PBT_"): v = getattr(win32con, x)
from xpra.gtk_common.gtk_util import ( add_close_accel, scaled_image, get_display_info, get_default_root_window, choose_file, get_gtk_version_info, ) from xpra.os_util import hexstr from xpra.platform.gui import force_focus from xpra.util import nonl, envint, repr_ellipsized from xpra.log import Logger log = Logger("util") STEP_DELAY = envint("XPRA_BUG_REPORT_STEP_DELAY", 0) class BugReport: def init(self, show_about=True, get_server_info=None, opengl_info=None, includes=None): self.show_about = show_about self.get_server_info = get_server_info self.opengl_info = opengl_info self.includes = includes or {} self.setup_window() def setup_window(self):
from xpra.platform.features import CLIPBOARD_GREEDY MIN_CLIPBOARD_COMPRESSION_SIZE = 512 MAX_CLIPBOARD_PACKET_SIZE = 4*1024*1024 from xpra.platform.features import CLIPBOARDS as PLATFORM_CLIPBOARDS ALL_CLIPBOARDS = PLATFORM_CLIPBOARDS CLIPBOARDS = PLATFORM_CLIPBOARDS CLIPBOARDS_ENV = os.environ.get("XPRA_CLIPBOARDS") if CLIPBOARDS_ENV is not None: CLIPBOARDS = CLIPBOARDS_ENV.split(",") CLIPBOARDS = [x.upper().strip() for x in CLIPBOARDS] TEST_DROP_CLIPBOARD_REQUESTS = envint("XPRA_TEST_DROP_CLIPBOARD") STORE_ON_EXIT = envbool("XPRA_CLIPBOARD_STORE_ON_EXIT", True) _discard_target_strs_ = os.environ.get("XPRA_DISCARD_TARGETS") if _discard_target_strs_ is not None: DISCARD_TARGETS = _discard_target_strs_.split(",") else: #default: DISCARD_TARGETS = [ "^SAVE_TARGETS$", "^COMPOUND_TEXT", "^NeXT", "^com\.apple\.", "^CorePasteboardFlavorType", "^dyn\."] log("DISCARD_TARGETS=%s", csv(DISCARD_TARGETS))
#default implementation using pycups import sys import os import time from subprocess import PIPE, Popen import shlex from threading import Lock import cups from xpra.os_util import OSX, bytestostr from xpra.util import engs, envint, envbool, parse_simple_dict from xpra.log import Logger log = Logger("printing") SIMULATE_PRINT_FAILURE = envint("XPRA_SIMULATE_PRINT_FAILURE") RAW_MODE = envbool("XPRA_PRINTER_RAW", False) GENERIC = envbool("XPRA_PRINTERS_GENERIC", True) FORWARDER_TMPDIR = os.environ.get("XPRA_FORWARDER_TMPDIR", os.environ.get("TMPDIR", "/tmp")) #the mimetype to use for clients that do not specify one #(older clients just assumed postscript) DEFAULT_MIMETYPE = os.environ.get("XPRA_PRINTER_DEFAULT_MIMETYPE", "application/postscript") LPADMIN = "lpadmin" LPINFO = "lpinfo" ADD_OPTIONS = ["-E", "-o printer-is-shared=false", "-u allow:$USER"] FORWARDER_BACKEND = "xpraforwarder"
# we reap the dead pids so that they don't become zombies, # also used for implementing --exit-with-children import os, sys import signal from xpra.util import envint, envbool from xpra.log import Logger log = Logger("server", "util") # use process polling with python versions older than 2.7 and 3.0, (because SIGCHLD support is broken) # or when the user requests it with the env var: USE_PROCESS_POLLING = os.name != "posix" or envbool("XPRA_USE_PROCESS_POLLING") POLL_DELAY = envint("XPRA_POLL_DELAY", 2) singleton = None def getChildReaper(): global singleton if singleton is None: singleton = ChildReaper() return singleton def reaper_cleanup(): global singleton s = singleton
import os import sys import subprocess from xpra.platform.win32 import constants as win32con from xpra.util import csv, envint, envbool, reverse_dict from xpra.os_util import bytestostr from xpra.platform.paths import get_app_dir from xpra.log import Logger log = Logger("printing") #allows us to skip some printers we don't want to export WINSPOOL_LISTENER = envbool("XPRA_WINSPOOL_LISTENER", True) SKIPPED_PRINTERS = os.environ.get("XPRA_SKIPPED_PRINTERS", "Microsoft XPS Document Writer,Fax").split(",") PRINTER_LEVEL = envint("XPRA_WIN32_PRINTER_LEVEL", 1) DEFAULT_PRINTER_FLAGS = "LOCAL,SHARED+NETWORK+CONNECTIONS" PRINTER_FLAGS = [x.strip() for x in os.environ.get("XPRA_WIN32_PRINTER_FLAGS", DEFAULT_PRINTER_FLAGS).split(",")] DEFAULT_MIMETYPES = ["application/pdf", ] PRINTER_ENUM_VALUES = { "DEFAULT" : 1, "LOCAL" : 2, "CONNECTIONS" : 4, "NAME" : 8, "REMOTE" : 16, "SHARED" : 32, "NETWORK" : 64, "EXPAND" : 16384,
# Copyright (C) 2011-2016 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. import os from xpra.util import envint, envbool from xpra.log import Logger log = Logger("network", "crypto") ENABLE_CRYPTO = envbool("XPRA_ENABLE_CRYPTO", True) ENCRYPT_FIRST_PACKET = envbool("XPRA_ENCRYPT_FIRST_PACKET", False) DEFAULT_IV = os.environ.get("XPRA_CRYPTO_DEFAULT_IV", "0000000000000000") DEFAULT_SALT = os.environ.get("XPRA_CRYPTO_DEFAULT_SALT", "0000000000000000") DEFAULT_ITERATIONS = envint("XPRA_CRYPTO_DEFAULT_ITERATIONS", 1000) DEFAULT_BLOCKSIZE = envint("XPRA_CRYPTO_BLOCKSIZE", 32) #fixme: can we derive this? #other option "PKCS#7", "legacy" PADDING_LEGACY = "legacy" PADDING_PKCS7 = "PKCS#7" ALL_PADDING_OPTIONS = (PADDING_LEGACY, PADDING_PKCS7) INITIAL_PADDING = os.environ.get("XPRA_CRYPTO_INITIAL_PADDING", PADDING_LEGACY) DEFAULT_PADDING = PADDING_LEGACY PREFERRED_PADDING = os.environ.get("XPRA_CRYPTO_PREFERRED_PADDING", PADDING_PKCS7) assert PREFERRED_PADDING in ALL_PADDING_OPTIONS, "invalid preferred padding: %s" % PREFERRED_PADDING assert INITIAL_PADDING in ALL_PADDING_OPTIONS, "invalid padding: %s" % INITIAL_PADDING #make sure the preferred one is first in the list: PADDING_OPTIONS = [PREFERRED_PADDING] for x in ALL_PADDING_OPTIONS: if x not in PADDING_OPTIONS:
# This file is part of Xpra. # Copyright (C) 2012-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 from xpra.log import Logger log = Logger("shadow") from xpra.net.compression import Compressed from xpra.server.window.batch_config import DamageBatchConfig from xpra.server.shadow.root_window_model import RootWindowModel from xpra.util import envint, DONE REFRESH_DELAY = envint("XPRA_SHADOW_REFRESH_DELAY", 50) class ShadowServerBase(object): def __init__(self, root_window): self.root = root_window self.mapped = False self.pulseaudio = False self.sharing = False self.refresh_delay = REFRESH_DELAY self.timer = None DamageBatchConfig.ALWAYS = True #always batch DamageBatchConfig.MIN_DELAY = 50 #never lower than 50ms def get_server_mode(self):