def parse_client_caps(self, c: typedict): #general features: self.info_namespace = c.boolget("info-namespace") self.share = c.boolget("share") self.lock = c.boolget("lock") self.control_commands = c.strtupleget("control_commands") self.xdg_menu = c.boolget("xdg-menu", True) self.xdg_menu_update = c.boolget("xdg-menu-update") bandwidth_limit = c.intget("bandwidth-limit", 0) server_bandwidth_limit = self.server_bandwidth_limit if self.server_bandwidth_limit is None: server_bandwidth_limit = self.get_socket_bandwidth_limit( ) or bandwidth_limit self.bandwidth_limit = min(server_bandwidth_limit, bandwidth_limit) if self.bandwidth_detection: self.bandwidth_detection = c.boolget("bandwidth-detection", True) self.client_connection_data = c.dictget("connection-data", {}) ccd = typedict(self.client_connection_data) self.adapter_type = ccd.strget("adapter-type", "") self.jitter = ccd.intget("jitter", 0) bandwidthlog( "server bandwidth-limit=%s, client bandwidth-limit=%s, value=%s, detection=%s", server_bandwidth_limit, bandwidth_limit, self.bandwidth_limit, self.bandwidth_detection) if getattr(self, "mmap_size", 0) > 0: log("mmap enabled, ignoring bandwidth-limit") self.bandwidth_limit = 0
def parse_client_caps(self, c: typedict): self.uuid = c.strget("uuid") self.session_id = c.strget("session-id") self.machine_id = c.strget("machine_id") self.hostname = c.strget("hostname") self.username = c.strget("username") self.name = c.strget("name") self.argv = c.strtupleget("argv") self.sharing = c.boolget("share") self.client_type = c.strget("client_type", "PyGTK") self.client_platform = c.strget("platform") self.client_machine = c.strget("platform.machine") self.client_processor = c.strget("platform.processor") self.client_release = c.strget("platform.sysrelease") self.client_linux_distribution = c.strtupleget( "platform.linux_distribution") self.client_version = c.strget("version") self.client_revision = c.strget("build.revision") self.client_bits = c.intget("python.bits") self.client_proxy = c.boolget("proxy") self.client_wm_name = c.strget("wm_name") self.client_session_type = c.strget("session-type") self.client_session_type_full = c.strget("session-type.full", "") self.client_setting_change = c.boolget("setting-change") self.client_opengl = typedict(c.dictget("opengl") or {}) self.proxy_hostname = c.strget("proxy.hostname") self.proxy_platform = c.strget("proxy.platform") self.proxy_release = c.strget("proxy.platform.sysrelease") self.proxy_version = c.strget("proxy.version") self.proxy_version = c.strget("proxy.build.version", self.proxy_version) log("client uuid %s", self.uuid)
def parse_client_caps(self, c: typedict): self.randr_notify = c.boolget("randr_notify") self.desktop_size = c.intpair("desktop_size") if self.desktop_size is not None: w, h = self.desktop_size if w <= 0 or h <= 0 or w >= 32768 or h >= 32768: log.warn("ignoring invalid desktop dimensions: %sx%s", w, h) self.desktop_size = None self.desktop_mode_size = c.intpair("desktop_mode_size") self.desktop_size_unscaled = c.intpair("desktop_size.unscaled") self.screen_resize_bigger = c.boolget("screen-resize-bigger", True) self.set_screen_sizes(c.tupleget("screen_sizes")) self.set_desktops(c.intget("desktops", 1), c.strtupleget("desktop.names")) self.show_desktop_allowed = c.boolget("show-desktop") self.icc = c.dictget("icc", {}) self.display_icc = c.dictget("display-icc", {}) self.opengl_props = c.dictget("opengl", {})
def parse_server_capabilities(self, c : typedict) -> bool: self.server_display = c.strget("display") self.server_desktop_size = c.intpair("desktop_size") log("server desktop size=%s", self.server_desktop_size) self.server_max_desktop_size = c.intpair("max_desktop_size", (2**15, 2**15)) self.server_actual_desktop_size = c.intpair("actual_desktop_size") log("server actual desktop size=%s", self.server_actual_desktop_size) self.server_randr = c.boolget("resize_screen") log("server has randr: %s", self.server_randr) self.server_opengl = c.dictget("opengl") return True
def process_ui_capabilities(self, caps : typedict): for c in CLIENT_BASES: if c!=XpraClientBase: c.process_ui_capabilities(self, caps) #keyboard: if self.keyboard_helper: modifier_keycodes = caps.dictget("modifier_keycodes", {}) if modifier_keycodes: self.keyboard_helper.set_modifier_mappings(modifier_keycodes) self.key_repeat_delay, self.key_repeat_interval = caps.intpair("key_repeat", (-1,-1)) self.handshake_complete()
def parse_server_capabilities(self, c: typedict) -> bool: try: from xpra import clipboard assert clipboard except ImportError: log.warn("Warning: clipboard module is missing") self.clipboard_enabled = False return True self.server_clipboard = c.boolget("clipboard") self.server_clipboard_loop_uuids = c.dictget("clipboard.loop-uuids", {}) self.server_clipboard_direction = c.strget("clipboard-direction", "both") if self.server_clipboard_direction != self.client_clipboard_direction and self.server_clipboard_direction != "both": if self.client_clipboard_direction == "disabled": pass elif self.server_clipboard_direction == "disabled": log.warn( "Warning: server clipboard synchronization is currently disabled" ) self.client_clipboard_direction = "disabled" elif self.client_clipboard_direction == "both": log.warn( "Warning: server only supports '%s' clipboard transfers", self.server_clipboard_direction) self.client_clipboard_direction = self.server_clipboard_direction else: log.warn("Warning: incompatible clipboard direction settings") log.warn(" server setting: %s, client setting: %s", self.server_clipboard_direction, self.client_clipboard_direction) try: from xpra.clipboard.clipboard_core import ALL_CLIPBOARDS except ImportError: ALL_CLIPBOARDS = [] self.server_clipboards = c.strtupleget("clipboards", ALL_CLIPBOARDS) log("server clipboard: supported=%s, direction=%s", self.server_clipboard, self.server_clipboard_direction) log("client clipboard: supported=%s, direction=%s", self.client_supports_clipboard, self.client_clipboard_direction) self.clipboard_enabled = self.client_supports_clipboard and self.server_clipboard log("parse_clipboard_caps() clipboard enabled=%s", self.clipboard_enabled) self.server_clipboard_contents_slice_fix = c.boolget( "clipboard.contents-slice-fix") self.server_clipboard_preferred_targets = c.strtupleget( "clipboard.preferred-targets", ()) if not self.server_clipboard_contents_slice_fix: log.info("server clipboard does not include contents slice fix") return True
def parse_client_caps(self, c: typedict): #general features: self.info_namespace = c.boolget("info-namespace") self.send_notifications = c.boolget("notifications") self.send_notifications_actions = c.boolget("notifications.actions") log("notifications=%s, actions=%s", self.send_notifications, self.send_notifications_actions) self.share = c.boolget("share") self.lock = c.boolget("lock") self.control_commands = c.strtupleget("control_commands") self.xdg_menu_update = c.boolget("xdg-menu-update") bandwidth_limit = c.intget("bandwidth-limit", 0) server_bandwidth_limit = self.server_bandwidth_limit if self.server_bandwidth_limit is None: server_bandwidth_limit = self.get_socket_bandwidth_limit( ) or bandwidth_limit self.bandwidth_limit = min(server_bandwidth_limit, bandwidth_limit) if self.bandwidth_detection: self.bandwidth_detection = c.boolget("bandwidth-detection", True) self.client_connection_data = c.dictget("connection-data", {}) self.jitter = typedict(self.client_connection_data).intget("jitter", 0) bandwidthlog( "server bandwidth-limit=%s, client bandwidth-limit=%s, value=%s, detection=%s", server_bandwidth_limit, bandwidth_limit, self.bandwidth_limit, self.bandwidth_detection) if getattr(self, "mmap_size", 0) > 0: log("mmap enabled, ignoring bandwidth-limit") self.bandwidth_limit = 0 #adjust max packet size if file transfers are enabled: #TODO: belongs in mixin: file_transfer = getattr(self, "file_transfer", None) if file_transfer: self.protocol.max_packet_size = max( self.protocol.max_packet_size, self.file_size_limit * 1024 * 1024)
def parse_server_capabilities(self, c: typedict) -> bool: for cb in CLIENT_BASES: if not cb.parse_server_capabilities(self, c): log.info("failed to parse server capabilities in %s", cb) return False self.server_session_name = strtobytes(c.rawget("session_name", b"")).decode("utf-8") set_name("Xpra", self.session_name or self.server_session_name or "Xpra") self.server_platform = c.strget("platform") self.server_sharing = c.boolget("sharing") self.server_sharing_toggle = c.boolget("sharing-toggle") self.server_lock = c.boolget("lock") self.server_lock_toggle = c.boolget("lock-toggle") self.server_keyboard = c.boolget("keyboard", True) self.server_pointer = c.boolget("pointer", True) self.server_start_new_commands = c.boolget("start-new-commands") if self.server_start_new_commands: self.server_xdg_menu = c.dictget("xdg-menu", None) if self.start_new_commands or self.start_child_new_commands: if self.server_start_new_commands: self.after_handshake(self.send_start_new_commands) else: log.warn("Warning: cannot start new commands") log.warn(" the feature is currently disabled on the server") self.server_commands_info = c.boolget("server-commands-info") self.server_commands_signals = c.strtupleget("server-commands-signals") self.server_readonly = c.boolget("readonly") if self.server_readonly and not self.readonly: log.info("server is read only") self.readonly = True if not self.server_keyboard and self.keyboard_helper: #swallow packets: def nosend(*_args): pass self.keyboard_helper.send = nosend i = platform_name( self._remote_platform, c.strtupleget("platform.linux_distribution") or c.strget("platform.release", "")) r = self._remote_version if self._remote_revision: r += "-r%s" % self._remote_revision mode = c.strget("server.mode", "server") bits = c.intget("python.bits", 32) log.info("Xpra %s server version %s %i-bit", mode, std(r), bits) if i: log.info(" running on %s", std(i)) if c.boolget("desktop") or c.boolget("shadow"): v = c.intpair("actual_desktop_size") if v: w, h = v ss = c.tupleget("screen_sizes") if ss: log.info(" remote desktop size is %sx%s with %s screen%s:", w, h, len(ss), engs(ss)) log_screen_sizes(w, h, ss) else: log.info(" remote desktop size is %sx%s", w, h) if c.boolget("proxy"): proxy_hostname = c.strget("proxy.hostname") proxy_platform = c.strget("proxy.platform") proxy_release = c.strget("proxy.platform.release") proxy_version = c.strget("proxy.version") proxy_version = c.strget("proxy.build.version", proxy_version) proxy_distro = c.strget("proxy.linux_distribution") msg = "via: %s proxy version %s" % (platform_name( proxy_platform, proxy_distro or proxy_release), std(proxy_version or "unknown")) if proxy_hostname: msg += " on '%s'" % std(proxy_hostname) log.info(msg) return True