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))
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)
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):
