import sys
if sys.version_info[0] != 3 or sys.version_info[1] < 3:
print("This script requires Python version 3.3")
sys.exit(1)
import abc
import argparse
import atexit
import errno
import fcntl
import getpass
import grp
import hashlib
import json
import logging
import os
import platform
import psutil
import pwd
import re
import shlex
import shutil
import signal
import socket
import struct
import subprocess
import syslog
import tempfile
import threading
import time
import uuid
HOST_EXTRA_PARAMS_ENV_VAR = "CHROME_REMOTE_DESKTOP_HOST_EXTRA_PARAMS"
DEFAULT_SIZES_ENV_VAR = "CHROME_REMOTE_DESKTOP_DEFAULT_DESKTOP_SIZES"
USE_XVFB_ENV_VAR = "CHROME_REMOTE_DESKTOP_USE_XVFB"
XORG_DUMMY_VIDEO_RAM = 1048576
DEFAULT_SIZES = "1600x1200,3840x2560"
WAYLAND_DESKTOP_SIZES_ENV = "CHROME_REMOTE_DESKTOP_WAYLAND_DESKTOP_SIZES"
DEFAULT_WAYLAND_DESKTOP_SIZES = "1280x720"
SCRIPT_PATH = os.path.abspath(sys.argv[0])
SCRIPT_DIR = os.path.dirname(SCRIPT_PATH)
if (os.path.basename(sys.argv[0]) == 'linux_me2me_host.py'):
HOST_BINARY_PATH = os.path.join(SCRIPT_DIR,
"../../../out/Release/remoting_me2me_host")
else:
HOST_BINARY_PATH = os.path.join(SCRIPT_DIR, "chrome-remote-desktop-host")
USER_SESSION_PATH = os.path.join(SCRIPT_DIR, "user-session")
CHROME_REMOTING_GROUP_NAME = "chrome-remote-desktop"
HOME_DIR = os.environ["HOME"]
CONFIG_DIR = os.path.join(HOME_DIR, ".config/chrome-remote-desktop")
SESSION_FILE_PATH = os.path.join(HOME_DIR, ".chrome-remote-desktop-session")
SYSTEM_SESSION_FILE_PATH = "/etc/chrome-remote-desktop-session"
SYSTEM_PRE_SESSION_FILE_PATH = "/etc/chrome-remote-desktop-pre-session"
DEBIAN_XSESSION_PATH = "/etc/X11/Xsession"
X_LOCK_FILE_TEMPLATE = "/tmp/.X%d-lock"
FIRST_X_DISPLAY_NUMBER = 20
SHORT_BACKOFF_TIME = 5
LONG_BACKOFF_TIME = 60
MINIMUM_PROCESS_LIFETIME = 60
SHORT_BACKOFF_THRESHOLD = 5
MAX_LAUNCH_FAILURES = SHORT_BACKOFF_THRESHOLD + 10
SESSION_OUTPUT_TIME_LIMIT_SECONDS = 300
SERVER_OUTPUT_TIME_LIMIT_SECONDS = 300
HOST_OFFLINE_REASON_X_SERVER_RETRIES_EXCEEDED = "X_SERVER_RETRIES_EXCEEDED"
HOST_OFFLINE_REASON_WAYLAND_SERVER_RETRIES_EXCEEDED = (
"WAYLAND_SERVER_RETRIES_EXCEEDED")
HOST_OFFLINE_REASON_SESSION_RETRIES_EXCEEDED = "SESSION_RETRIES_EXCEEDED"
HOST_OFFLINE_REASON_HOST_RETRIES_EXCEEDED = "HOST_RETRIES_EXCEEDED"
USER_SESSION_MESSAGE_FD = 202
RELAUNCH_EXIT_CODE = 41
COMMAND_NOT_FOUND_EXIT_CODE = 127
COMMAND_NOT_EXECUTABLE_EXIT_CODE = 126
RUNTIME_DIR_TEMPLATE = "/run/user/%s"
GNOME_SESSION = "gnome-session"
GNOME_SESSION_QUIT = "gnome-session-quit"
g_desktop = None
g_host_hash = hashlib.md5(socket.gethostname().encode()).hexdigest()
def gen_xorg_config():
return (
'Section "Files"\n'
' ModulePath "/usr/lib/xorg/modules"\n'
'EndSection\n'
'\n'
'Section "ServerFlags"\n'
' Option "AutoAddDevices" "false"\n'
' Option "AutoEnableDevices" "false"\n'
' Option "DontVTSwitch" "true"\n'
' Option "PciForceNone" "true"\n'
'EndSection\n'
'\n'
'Section "InputDevice"\n'
' Identifier "Chrome Remote Desktop Input"\n'
' Option "CoreKeyboard" "true"\n'
' Option "CorePointer" "true"\n'
' Driver "void"\n'
'EndSection\n'
'\n'
'Section "Device"\n'
' Identifier "Chrome Remote Desktop Videocard"\n'
' Driver "dummy"\n'
' VideoRam {video_ram}\n'
'EndSection\n'
'\n'
'Section "Monitor"\n'
' Identifier "Chrome Remote Desktop Monitor"\n'
'EndSection\n'
'\n'
'Section "Screen"\n'
' Identifier "Chrome Remote Desktop Screen"\n'
' Device "Chrome Remote Desktop Videocard"\n'
' Monitor "Chrome Remote Desktop Monitor"\n'
' DefaultDepth 24\n'
' SubSection "Display"\n'
' Viewport 0 0\n'
' Depth 24\n'
' EndSubSection\n'
'EndSection\n'
'\n'
'Section "ServerLayout"\n'
' Identifier "Chrome Remote Desktop Layout"\n'
' Screen "Chrome Remote Desktop Screen"\n'
' InputDevice "Chrome Remote Desktop Input"\n'
'EndSection\n'.format(
video_ram=XORG_DUMMY_VIDEO_RAM))
def display_manager_is_gdm():
try:
with open('/etc/X11/default-display-manager', 'rb') as file:
if file.read().strip() in [b'/usr/sbin/gdm', b'/usr/sbin/gdm3']:
return True
except:
pass
for process in psutil.process_iter():
if process.name() in ['gdm', 'gdm3']:
return True
return False
def is_supported_platform():
if (os.path.isdir(CONFIG_DIR) or os.path.isfile(SESSION_FILE_PATH) or
os.path.isfile(SYSTEM_SESSION_FILE_PATH)):
return True
if display_manager_is_gdm():
return False;
return os.path.isfile(DEBIAN_XSESSION_PATH);
class Config:
def __init__(self, path):
self.path = path
self.data = {}
self.changed = False
def load(self):
"""Loads the config from file.
Raises:
IOError: Error reading data
ValueError: Error parsing JSON
"""
settings_file = open(self.path, 'r')
self.data = json.load(settings_file)
self.changed = False
settings_file.close()
def save(self):
"""Saves the config to file.
Raises:
IOError: Error writing data
TypeError: Error serialising JSON
"""
if not self.changed:
return
old_umask = os.umask(0o066)
try:
settings_file = open(self.path, 'w')
settings_file.write(json.dumps(self.data, indent=2))
settings_file.close()
self.changed = False
finally:
os.umask(old_umask)
def save_and_log_errors(self):
"""Calls self.save(), trapping and logging any errors."""
try:
self.save()
except (IOError, TypeError) as e:
logging.error("Failed to save config: " + str(e))
def get(self, key):
return self.data.get(key)
def __getitem__(self, key):
return self.data[key]
def __setitem__(self, key, value):
self.data[key] = value
self.changed = True
def clear(self):
self.data = {}
self.changed = True
class Authentication:
"""Manage authentication tokens for Chromoting/xmpp"""
def __init__(self):
self.login = None
self.oauth_refresh_token = None
def copy_from(self, config):
"""Loads the config and returns false if the config is invalid."""
try:
self.login = config["xmpp_login"]
self.oauth_refresh_token = config["oauth_refresh_token"]
except KeyError:
return False
return True
def copy_to(self, config):
config["xmpp_login"] = self.login
config["oauth_refresh_token"] = self.oauth_refresh_token
class Host:
"""This manages the configuration for a host."""
def __init__(self):
self.host_id = None
self.host_name = None
self.host_secret_hash = None
self.private_key = None
def copy_from(self, config):
try:
self.host_id = config.get("host_id")
self.host_name = config["host_name"]
self.host_secret_hash = config.get("host_secret_hash")
self.private_key = config["private_key"]
except KeyError:
return False
return bool(self.host_id)
def copy_to(self, config):
if self.host_id:
config["host_id"] = self.host_id
config["host_name"] = self.host_name
config["host_secret_hash"] = self.host_secret_hash
config["private_key"] = self.private_key
class SessionOutputFilterThread(threading.Thread):
"""Reads session log from a pipe and logs the output with the provided prefix
for amount of time defined by time_limit, or indefinitely if time_limit is
None."""
def __init__(self, stream, prefix, time_limit):
threading.Thread.__init__(self)
self.stream = stream
self.daemon = True
self.prefix = prefix
self.time_limit = time_limit
def run(self):
started_time = time.time()
is_logging = True
while True:
try:
line = self.stream.readline();
except IOError as e:
print("IOError when reading session output: ", e)
return
if line == b"":
return
if not is_logging:
continue
if self.time_limit and time.time() - started_time >= self.time_limit:
is_logging = False
print("Suppressing rest of the session output.", flush=True)
else:
sys.stdout.buffer.write(self.prefix.encode(sys.stdout.encoding) + line);
sys.stdout.flush()
class Desktop(abc.ABC):
"""Manage a single virtual desktop"""
def __init__(self, sizes, server_inhibitor=None, session_inhibitor=None,
host_inhibitor=None):
self.sizes = sizes
self.server_proc = None
self.pre_session_proc = None
self.session_proc = None
self.host_proc = None
self.child_env = None
self.host_ready = False
self.server_inhibitor = server_inhibitor
self.session_inhibitor = session_inhibitor
self.host_inhibitor = host_inhibitor
if self.server_inhibitor is None:
self.server_inhibitor = RelaunchInhibitor("Display server")
if self.session_inhibitor is None:
self.session_inhibitor = RelaunchInhibitor("session")
if self.host_inhibitor is None:
self.host_inhibitor = RelaunchInhibitor("host")
self.inhibitors = {
self.server_inhibitor: HOST_OFFLINE_REASON_X_SERVER_RETRIES_EXCEEDED,
self.session_inhibitor: HOST_OFFLINE_REASON_SESSION_RETRIES_EXCEEDED,
self.host_inhibitor: HOST_OFFLINE_REASON_HOST_RETRIES_EXCEEDED
}
def _init_child_env(self):
self.child_env = dict(os.environ)
library_path = (
"/usr/lib/mesa-diverted/%(arch)s-linux-gnu:"
"/usr/lib/%(arch)s-linux-gnu/mesa:"
"/usr/lib/%(arch)s-linux-gnu/dri:"
"/usr/lib/%(arch)s-linux-gnu/gallium-pipe" %
{ "arch": platform.machine() })
if "LD_LIBRARY_PATH" in self.child_env:
library_path += ":" + self.child_env["LD_LIBRARY_PATH"]
self.child_env["LD_LIBRARY_PATH"] = library_path
def _setup_gnubby(self):
self.ssh_auth_sockname = ("/tmp/chromoting.%s.ssh_auth_sock" %
os.environ["USER"])
def _launch_pre_session(self):
if os.path.exists(SYSTEM_PRE_SESSION_FILE_PATH):
pre_session_command = bash_invocation_for_script(
SYSTEM_PRE_SESSION_FILE_PATH)
logging.info("Launching pre-session: %s" % pre_session_command)
self.pre_session_proc = subprocess.Popen(pre_session_command,
stdin=subprocess.DEVNULL,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=HOME_DIR,
env=self.child_env)
if not self.pre_session_proc.pid:
raise Exception("Could not start pre-session")
output_filter_thread = SessionOutputFilterThread(
self.pre_session_proc.stdout, "Pre-session output: ", None)
output_filter_thread.start()
return True
return False
def launch_session(self, server_args, backoff_time):
"""Launches process required for session and records the backoff time
for inhibitors so that process restarts are not attempted again until
that time has passed."""
logging.info("Setting up and launching session")
self._init_child_env()
self.setup_audio()
self._setup_gnubby()
self._launch_server(server_args)
if not self._launch_pre_session():
self.launch_desktop_session()
self.server_inhibitor.record_started(MINIMUM_PROCESS_LIFETIME,
backoff_time)
self.session_inhibitor.record_started(MINIMUM_PROCESS_LIFETIME,
backoff_time)
def _wait_for_setup_before_host_launch(self):
"""
If a virtual desktop needs to do some setup before launching the host
process, it can override this method and ensure that the required setup is
done before returning from this process.
"""
pass
def launch_host(self, host_config, extra_start_host_args, backoff_time):
self._wait_for_setup_before_host_launch()
logging.info("Launching host process")
args = [HOST_BINARY_PATH, "--host-config=-"]
if self.audio_pipe:
args.append("--audio-pipe-name=%s" % self.audio_pipe)
if self.ssh_auth_sockname:
args.append("--ssh-auth-sockname=%s" % self.ssh_auth_sockname)
args.extend(extra_start_host_args)
def sigusr1_handler(signum, frame):
_ = signum, frame
logging.info("Host ready to receive connections.")
self.host_ready = True
ParentProcessLogger.release_parent_if_connected(True)
signal.signal(signal.SIGUSR1, sigusr1_handler)
args.append("--signal-parent")
logging.info(args)
self.host_proc = subprocess.Popen(args, env=self.child_env,
stdin=subprocess.PIPE)
if not self.host_proc.pid:
raise Exception("Could not start Chrome Remote Desktop host")
try:
self.host_proc.stdin.write(json.dumps(host_config.data).encode('UTF-8'))
self.host_proc.stdin.flush()
except IOError as e:
logging.error("Failed writing to host's stdin: " + str(e))
finally:
self.host_proc.stdin.close()
self.host_inhibitor.record_started(MINIMUM_PROCESS_LIFETIME, backoff_time)
def cleanup(self):
"""Send SIGTERM to all procs and wait for them to exit. Will fallback to
SIGKILL if a process doesn't exit within 10 seconds.
"""
for proc, name in [(self.host_proc, "host"),
(self.session_proc, "session"),
(self.pre_session_proc, "pre-session"),
(self.server_proc, "display server")]:
if proc is not None:
logging.info("Sending SIGTERM to %s proc (pid=%s)",
name, proc and proc.pid)
try:
psutil_proc = psutil.Process(proc.pid)
psutil_proc.terminate()
psutil_proc.wait(timeout=10)
except psutil.TimeoutExpired:
logging.error("Timed out - sending SIGKILL")
psutil_proc.kill()
except psutil.Error:
logging.error("Error terminating process")
self.server_proc = None
self.pre_session_proc = None
self.session_proc = None
self.host_proc = None
def report_offline_reason(self, host_config, reason):
"""Attempt to report the specified offline reason to the registry. This
is best effort, and requires a valid host config.
"""
logging.info("Attempting to report offline reason: " + reason)
args = [HOST_BINARY_PATH, "--host-config=-",
"--report-offline-reason=" + reason]
proc = subprocess.Popen(args, env=self.child_env, stdin=subprocess.PIPE)
proc.communicate(json.dumps(host_config.data).encode('UTF-8'))
def on_process_exit(self, pid, status):
"""Checks for which process has exited and whether or not the exit was
expected. Returns a boolean indicating whether or not tear down of the
processes is needed."""
tear_down = False
if self.server_proc is not None and pid == self.server_proc.pid:
logging.info("Display server process terminated")
self.server_proc = None
self.server_inhibitor.record_stopped(expected=False)
tear_down = True
if (self.pre_session_proc is not None and
pid == self.pre_session_proc.pid):
self.pre_session_proc = None
if status == 0:
logging.info("Pre-session terminated successfully. Starting session.")
self.launch_desktop_session()
else:
logging.info("Pre-session failed. Tearing down.")
if self.check_server_responding():
self.session_inhibitor.record_stopped(expected=False)
else:
self.server_inhibitor.record_stopped(expected=False)
tear_down = True
if self.session_proc is not None and pid == self.session_proc.pid:
logging.info("Session process terminated")
self.session_proc = None
if self.check_server_responding():
self.session_inhibitor.record_stopped(expected=False)
else:
self.server_inhibitor.record_stopped(expected=False)
tear_down = True
if self.host_proc is not None and pid == self.host_proc.pid:
logging.info("Host process terminated")
self.host_proc = None
self.host_ready = False
if os.WIFEXITED(status):
if os.WEXITSTATUS(status) == 100:
logging.info("Host configuration is invalid - exiting.")
return 0
elif os.WEXITSTATUS(status) == 101:
logging.info("Host ID has been deleted - exiting.")
host_config.clear()
host_config.save_and_log_errors()
return 0
elif os.WEXITSTATUS(status) == 102:
logging.info("OAuth credentials are invalid - exiting.")
return 0
elif os.WEXITSTATUS(status) == 103:
logging.info("Host domain is blocked by policy - exiting.")
return 0
elif os.WEXITSTATUS(status) == 105:
logging.info("Username is blocked by policy - exiting.")
return 0
elif os.WEXITSTATUS(status) == 106:
logging.info("Host has been deleted - exiting.")
return 0
elif os.WEXITSTATUS(status) == 107:
logging.info("Remote access is disallowed by policy - exiting.")
return 0
elif os.WEXITSTATUS(status) == 108:
logging.info("This CPU is not supported - exiting.")
return 0
else:
logging.info("Host exited with status %s." % os.WEXITSTATUS(status))
elif os.WIFSIGNALED(status):
logging.info("Host terminated by signal %s." % os.WTERMSIG(status))
if self.check_server_responding():
self.host_inhibitor.record_stopped(expected=False)
else:
self.server_inhibitor.record_stopped(expected=False)
tear_down = True
return tear_down
def aggregate_failure_count(self):
failure_count = 0
for inhibitor in self.inhibitors:
if inhibitor.running:
inhibitor.record_stopped(True)
failure_count += inhibitor.failures
return failure_count
def setup_audio(self):
self.audio_pipe = None
pulse_path = os.path.join(CONFIG_DIR,
"pulseaudio#%s" % g_host_hash[0:10])
if len(pulse_path) + len("/native") >= 108:
logging.error("Audio will not be enabled because pulseaudio UNIX " +
"socket path is too long.")
return False
sink_name = "chrome_remote_desktop_session"
pipe_name = os.path.join(pulse_path, "fifo_output")
try:
if not os.path.exists(pulse_path):
os.mkdir(pulse_path)
except IOError as e:
logging.error("Failed to create pulseaudio pipe: " + str(e))
return False
try:
pulse_config = open(os.path.join(pulse_path, "daemon.conf"), "w")
pulse_config.write("default-sample-format = s16le\n")
pulse_config.write("default-sample-rate = 48000\n")
pulse_config.write("default-sample-channels = 2\n")
pulse_config.close()
pulse_script = open(os.path.join(pulse_path, "default.pa"), "w")
pulse_script.write("load-module module-native-protocol-unix\n")
pulse_script.write(
("load-module module-pipe-sink sink_name=%s file=\"%s\" " +
"rate=48000 channels=2 format=s16le\n") %
(sink_name, pipe_name))
pulse_script.close()
except IOError as e:
logging.error("Failed to write pulseaudio config: " + str(e))
return False
self.child_env["PULSE_CONFIG_PATH"] = pulse_path
self.child_env["PULSE_RUNTIME_PATH"] = pulse_path
self.child_env["PULSE_STATE_PATH"] = pulse_path
self.child_env["PULSE_SINK"] = sink_name
self.audio_pipe = pipe_name
return True
@abc.abstractmethod
def launch_desktop_session(self):
"""Start desktop session."""
pass
@abc.abstractmethod
def check_server_responding(self):
"""Checks if the display server is responding to connections."""
return False
class WaylandDesktop(Desktop):
"""Manage a single virtual wayland based desktop"""
WL_SOCKET_CHECK_DELAY_SECONDS = 1
WL_SOCKET_CHECK_TIMEOUT_SECONDS = 5
WL_SERVER_REPLY_TIMEOUT_SECONDS = 1
MAX_WAYLAND_SOCKET_NUM = 100
def __init__(self, sizes):
super(WaylandDesktop, self).__init__(sizes)
self.debug = False
self._wayland_socket = None
self._runtime_dir = None
self.inhibitors = {
self.server_inhibitor:
HOST_OFFLINE_REASON_WAYLAND_SERVER_RETRIES_EXCEEDED,
self.host_inhibitor: HOST_OFFLINE_REASON_HOST_RETRIES_EXCEEDED
}
global g_desktop
assert(g_desktop is None)
g_desktop = self
@property
def runtime_dir(self):
if not self._runtime_dir:
self._runtime_dir = RUNTIME_DIR_TEMPLATE % os.getuid()
return self._runtime_dir
def _init_child_env(self):
super(WaylandDesktop, self)._init_child_env()
self.child_env["GDK_BACKEND"] = "wayland,x11"
self.child_env["XDG_SESSION_TYPE"] = "wayland"
self.child_env["XDG_RUNTIME_DIR"] = self.runtime_dir
self._wayland_socket = self._get_unused_wayland_socket()
if self._wayland_socket is None:
logging.error("Unable to find unused wayland socket, running compositor "
"is going to fail")
sys.exit(1)
else:
self.child_env["WAYLAND_DISPLAY"] = self._wayland_socket
self.child_env["CHROME_REMOTE_DESKTOP_SESSION"] = "1"
chrome_profile = os.path.join(CONFIG_DIR, "chrome-profile")
chrome_config_home = os.path.join(CONFIG_DIR, "chrome-config")
if (os.path.exists(chrome_profile)
and not os.path.exists(chrome_config_home)):
self.child_env["CHROME_USER_DATA_DIR"] = chrome_profile
elif os.path.exists(chrome_config_home):
self.child_env["CHROME_CONFIG_HOME"] = chrome_config_home
if self.debug:
self.child_env["G_MESSAGES_DEBUG"] = "all"
self.child_env["GDK_DEBUG"] = "all"
self.child_env["G_DEBUG"] = "fatal-criticals"
self.child_env["WAYLAND_DEBUG"] = "1"
def _get_unused_wayland_socket(self):
"""
Return a candidate wayland socket that is not already taken by another
compositor.
"""
socket_num = starting_socket_num = 0
full_sock_path = os.path.join(self.runtime_dir, "wayland-%s" % socket_num)
while ((os.path.exists(full_sock_path)) and
socket_num <= self.MAX_WAYLAND_SOCKET_NUM):
socket_num += 1
full_sock_path = os.path.join(self.runtime_dir, "wayland-%s" % socket_num)
if socket_num > self.MAX_WAYLAND_SOCKET_NUM:
logging.error("Unable to find an unused wayland socket (searched between "
"'wayland-%s' to 'wayland-%s' under runtime directory",
starting_socket_num,
self.MAX_WAYLAND_SOCKET_NUM, self.runtime_dir)
return None
return "wayland-%s" % socket_num
@staticmethod
def _is_gnome_session_present():
if not shutil.which(GNOME_SESSION):
logging.warning("Unable to find '%s' on the host" % GNOME_SESSION)
return False
return True
def _launch_server(self, *args, **kwargs):
if not self._is_gnome_session_present():
logging.error("Only GNOME based wayland hosts are supported currently. "
"If the host is a GNOME host, please ensure that "
"'gnome-shell' is installed on it")
sys.exit(1)
logging.info("Launching wayland server.")
if self.ssh_auth_sockname:
self.child_env["SSH_AUTH_SOCK"] = self.ssh_auth_sockname
self.server_proc = subprocess.Popen([GNOME_SESSION],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
env=self.child_env)
if not self.server_proc.pid:
raise Exception("Could not start wayland session")
output_filter_thread = SessionOutputFilterThread(self.server_proc.stdout,
"Wayland server output: ", SERVER_OUTPUT_TIME_LIMIT_SECONDS)
output_filter_thread.start()
def _wait_for_wayland_compositor_running(self):
"""
Waits for wayland socket to be created by the wayland compositor. Returns
true if socket is created within the allowed timeout, else false.
"""
full_socket_path = os.path.join(self.runtime_dir, self._wayland_socket)
start_time = time.time()
while not os.path.exists(full_socket_path):
time_passed = time.time() - start_time
if time_passed >= self.WL_SOCKET_CHECK_TIMEOUT_SECONDS:
break
logging.info("Wayland socket not yet present. Will wait for %s seconds "
"for compositor to create it (remaining wait time: %s "
"seconds)" %
(self.WL_SOCKET_CHECK_DELAY_SECONDS,
int(self.WL_SOCKET_CHECK_TIMEOUT_SECONDS - time_passed)))
time.sleep(self.WL_SOCKET_CHECK_DELAY_SECONDS)
if not os.path.exists(full_socket_path):
logging.error("Waited for wayland compositor to create wayland "
"socket: %s, but it didn't happen in %s seconds" %
(full_socket_path, self.WL_SOCKET_CHECK_TIMEOUT_SECONDS))
return False
logging.info("Wayland socket detected in %s seconds: " %
str(time.time() - start_time))
return True
def launch_desktop_session(self):
"""
Restarts the portal services so that they can connect to the wayland socket.
This helps host process to talk to call into the the xdg-desktop-portal
APIs.
"""
if not self._wait_for_wayland_compositor_running():
logging.error("Aborting wayland session since compositor isn't running")
sys.exit(1)
logging.info("Wayland compositor is running, restarting the portal "
"services now")
try:
subprocess.check_output(["systemctl", "--user", "import-environment"],
stderr=subprocess.STDOUT,
env=self.child_env)
except subprocess.CalledProcessError as err:
logging.error("Unable to import env vars into systemd, "
"returncode: %s, output: %s" % (err.returncode,
err.output))
sys.exit(1)
try:
subprocess.check_output(["systemctl", "--user", "restart",
"xdg-desktop-portal",
"xdg-desktop-portal-gnome",
"xdg-desktop-portal-gtk"],
stderr=subprocess.STDOUT, env=self.child_env)
except subprocess.CalledProcessError as err:
logging.error("Unable to restart portal services on the host, "
"returncode: %s, output: %s" % (err.returncode, err.output))
sys.exit(1)
logging.info("Done restarting the portal services")
def _wait_for_setup_before_host_launch(self):
return self._wait_for_wayland_compositor_running()
def cleanup(self):
if self.host_proc is not None:
logging.info("Sending SIGTERM to host proc (pid=%s)", self.host_proc.pid)
try:
psutil_proc = psutil.Process(self.host_proc.pid)
psutil_proc.terminate()
psutil_proc.wait(timeout=10)
except psutil.TimeoutExpired:
logging.error("Timed out - sending SIGKILL")
psutil_proc.kill()
except psutil.Error:
logging.error("Error terminating process")
self.host_proc = None
logging.info("Executing %s" % GNOME_SESSION_QUIT)
if shutil.which(GNOME_SESSION_QUIT):
cleanup_proc = subprocess.Popen(
[GNOME_SESSION_QUIT, "--force", "--no-prompt"],
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
env=self.child_env)
stdout, stderr = cleanup_proc.communicate()
if stderr:
logging.error("Failed to execute %s:\n%s" %
(GNOME_SESSION_QUIT, stderr))
self.session_proc = None
else:
logging.warning("No %s found on the system" % GNOME_SESSION_QUIT)
super(WaylandDesktop, self).cleanup()
if self._wayland_socket:
full_socket_path = os.path.join(self.runtime_dir, self._wayland_socket)
for to_remove in (full_socket_path, "%s.lock" % full_socket_path):
try:
os.remove(to_remove)
except FileNotFoundError:
pass
self._wayland_socket = None
def check_server_responding(self):
"""
Connects to the server that is listening on the wayland socket.
If the connection succeeds, it means that the server is still up and
running.
"""
try:
with socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) as sock:
sock.connect(os.path.join(self.runtime_dir, self._wayland_socket))
sock.sendall(struct.pack("<III", 0x00000001, 0x000C0001, 0x00000002))
num_bytes_received = 0
NUM_BYTES_EXPECTED = 32
sock.settimeout(self.WL_SERVER_REPLY_TIMEOUT_SECONDS)
while num_bytes_received < NUM_BYTES_EXPECTED:
data = sock.recv(NUM_BYTES_EXPECTED)
if len(data) == 0:
break
num_bytes_received += len(data)
logging.debug("Wayland server replied with: %s" % data)
if not num_bytes_received:
return False
except socket.error as err:
logging.error("Wayland server is not responding: %s" % err)
return False
return True
class XDesktop(Desktop):
"""Manage a single virtual X desktop"""
def __init__(self, sizes):
super(XDesktop, self).__init__(sizes)
self.xorg_conf = None
self.audio_pipe = None
self.server_supports_randr = False
self.randr_add_sizes = False
self.ssh_auth_sockname = None
self.use_xvfb = self.should_use_xvfb()
global g_desktop
assert(g_desktop is None)
g_desktop = self
@staticmethod
def should_use_xvfb():
"""Return whether XVFB should be used. This will be true if USE_XVFB_ENV_VAR
is set, or if installed dependencies can't support Xorg+Dummy. Note that
this method performs expensive IO so the output should be cached."""
if USE_XVFB_ENV_VAR in os.environ:
return True
try:
video_dummy_info = subprocess.check_output(
['dpkg-query', '-s', 'xserver-xorg-video-dummy'])
matches = re.search(
br'^Version: (\S+)$', video_dummy_info, re.MULTILINE)
if not matches:
logging.error('Version line is not found')
return False
version = matches[1]
retcode = subprocess.call(
['dpkg', '--compare-versions', version, 'ge', '1:0.4.0'])
if retcode != 0:
logging.info('xserver-xorg-video-dummy is not up-to-date')
return True
except subprocess.CalledProcessError:
logging.info('xserver-xorg-video-dummy is not installed')
return True
except Exception as e:
logging.warning(
'Failed to get xserver-xorg-video-dummy version: ' + str(e))
return False
@staticmethod
def get_unused_display_number():
"""Return a candidate display number for which there is currently no
X Server lock file"""
display = FIRST_X_DISPLAY_NUMBER
while os.path.exists(X_LOCK_FILE_TEMPLATE % display):
display += 1
return display
def _init_child_env(self):
super(XDesktop, self)._init_child_env()
self.child_env["GDK_BACKEND"] = "x11"
self.child_env["XDG_SESSION_TYPE"] = "x11"
def launch_session(self, *args, **kwargs):
logging.info("Launching X server and X session.")
super(XDesktop, self).launch_session(*args, **kwargs)
def _x_env(self):
if "TMPDIR" not in self.child_env:
return self.child_env
else:
env_copy = dict(self.child_env)
del env_copy["TMPDIR"]
return env_copy
def check_server_responding(self):
"""Checks if the X server is responding to connections."""
exit_code = subprocess.call("xdpyinfo", env=self.child_env,
stdout=subprocess.DEVNULL)
return exit_code == 0
def _wait_for_x(self):
for _test in range(20):
if self.check_server_responding():
logging.info("X server is active.")
return
time.sleep(0.5)
raise Exception("Could not connect to X server.")
def _launch_xvfb(self, display, x_auth_file, extra_x_args):
max_width = max([width for width, height in self.sizes])
max_height = max([height for width, height in self.sizes])
logging.info("Starting Xvfb on display :%d" % display)
screen_option = "%dx%dx24" % (max_width, max_height)
self.server_proc = subprocess.Popen(
["Xvfb", ":%d" % display,
"-auth", x_auth_file,
"-nolisten", "tcp",
"-noreset",
"-screen", "0", screen_option
] + extra_x_args, env=self._x_env())
if not self.server_proc.pid:
raise Exception("Could not start Xvfb.")
self._wait_for_x()
exit_code = subprocess.call("xrandr", env=self.child_env,
stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
if exit_code == 0:
self.server_supports_randr = True
self.randr_add_sizes = True
def _launch_xorg(self, display, x_auth_file, extra_x_args):
with tempfile.NamedTemporaryFile(
prefix="chrome_remote_desktop_",
suffix=".conf", delete=False) as config_file:
config_file.write(gen_xorg_config().encode())
self.server_supports_randr = True
self.randr_add_sizes = True
self.xorg_conf = config_file.name
xorg_binary = "/usr/lib/xorg/Xorg";
if not os.access(xorg_binary, os.X_OK):
xorg_binary = "Xorg";
logging.info("Starting %s on display :%d" % (xorg_binary, display))
self.server_proc = subprocess.Popen(
[xorg_binary, ":%d" % display,
"-auth", x_auth_file,
"-nolisten", "tcp",
"-noreset",
"-logfile", "/dev/null",
"-verbose", "3",
"-config", config_file.name
] + extra_x_args, env=self._x_env())
if not self.server_proc.pid:
raise Exception("Could not start Xorg.")
self._wait_for_x()
def _launch_server(self, extra_x_args):
x_auth_file = os.path.expanduser("~/.Xauthority")
self.child_env["XAUTHORITY"] = x_auth_file
display = self.get_unused_display_number()
exit_code = subprocess.call("xauth add :%d . `mcookie`" % display,
env=self.child_env, shell=True)
if exit_code != 0:
raise Exception("xauth failed with code %d" % exit_code)
x_session = choose_x_session()
if (len(x_session) == 2 and
x_session[1] == "/usr/bin/gnome-session --session=ubuntu-2d"):
extra_x_args.extend(["-extension", "Composite"])
self.child_env["DISPLAY"] = ":%d" % display
self.child_env["CHROME_REMOTE_DESKTOP_SESSION"] = "1"
chrome_profile = os.path.join(CONFIG_DIR, "chrome-profile")
chrome_config_home = os.path.join(CONFIG_DIR, "chrome-config")
if (os.path.exists(chrome_profile)
and not os.path.exists(chrome_config_home)):
self.child_env["CHROME_USER_DATA_DIR"] = chrome_profile
elif os.path.exists(chrome_config_home):
self.child_env["CHROME_CONFIG_HOME"] = chrome_config_home
if self.ssh_auth_sockname:
self.child_env["SSH_AUTH_SOCK"] = self.ssh_auth_sockname
if self.use_xvfb:
self._launch_xvfb(display, x_auth_file, extra_x_args)
else:
self._launch_xorg(display, x_auth_file, extra_x_args)
exit_code = subprocess.call(["setxkbmap", "-rules", "evdev"],
env=self.child_env)
if exit_code != 0:
logging.error("Failed to set XKB to 'evdev'")
if not self.server_supports_randr:
return
if self.randr_add_sizes:
refresh_rates = ["60"]
try:
proc_num = subprocess.check_output("nproc", universal_newlines=True)
if (int(proc_num) > 16):
refresh_rates.append("120")
except (ValueError, OSError, subprocess.CalledProcessError) as e:
logging.error("Failed to retrieve processor count: " + str(e))
output_names = (
["screen"]
if self.use_xvfb
else ["DUMMY0","DUMMY1","DUMMY2","DUMMY3"])
for output_name in output_names:
for refresh_rate in refresh_rates:
for width, height in self.sizes:
label = "%dx%d_%s" % (width, height, refresh_rate)
args = ["xrandr", "--newmode", label, refresh_rate, str(width), "0",
"0", "1000", str(height), "0", "0", "1000"]
subprocess.call(args, env=self.child_env, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
args = ["xrandr", "--addmode", output_name, label]
subprocess.call(args, env=self.child_env, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
initial_size = self.sizes[0]
label = "%dx%d" % initial_size
args = ["xrandr", "-s", label]
subprocess.call(args, env=self.child_env, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
args = ["xrandr", "--dpi", "96"]
subprocess.call(args, env=self.child_env, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
if self.use_xvfb:
args = [SCRIPT_PATH, "--watch-resolution", str(initial_size[0]),
str(initial_size[1])]
subprocess.Popen(args, env=self.child_env, stdout=subprocess.DEVNULL,
stderr=subprocess.DEVNULL)
def launch_desktop_session(self):
xsession_command = choose_x_session()
if xsession_command is None:
raise Exception("Unable to choose suitable X session command.")
logging.info("Launching X session: %s" % xsession_command)
self.session_proc = subprocess.Popen(xsession_command,
stdin=subprocess.DEVNULL,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT,
cwd=HOME_DIR,
env=self.child_env)
if not self.session_proc.pid:
raise Exception("Could not start X session")
output_filter_thread = SessionOutputFilterThread(self.session_proc.stdout,
"Session output: ", SESSION_OUTPUT_TIME_LIMIT_SECONDS)
output_filter_thread.start()
def parse_config_arg(args):
"""Parses only the --config option from a given command-line.
Returns:
A two-tuple. The first element is the value of the --config option (or None
if it is not specified), and the second is a list containing the remaining
arguments
"""
class ArgumentParserError(Exception):
pass
class ThrowingArgumentParser(argparse.ArgumentParser):
def error(self, message):
raise ArgumentParserError(message)
parser = ThrowingArgumentParser()
parser.add_argument("--config", nargs='?', action="store")
try:
result = parser.parse_known_args(args)
return (result[0].config, result[1])
except ArgumentParserError:
return (None, list(args))
def get_daemon_proc(config_file, require_child_process=False):
"""Checks if there is already an instance of this script running against
|config_file|, and returns a psutil.Process instance for it. If
|require_child_process| is true, only check for an instance with the
--child-process flag specified.
If a process is found without --config in the command line, get_daemon_proc
will fall back to the old behavior of checking whether the script path matches
the current script. This is to facilitate upgrades from previous versions.
Returns:
A Process instance for the existing daemon process, or None if the daemon
is not running.
"""
uid = os.getuid()
this_pid = os.getpid()
non_child_process = None
if psutil.version_info >= (2, 0):
psget = lambda x: x()
else:
psget = lambda x: x
for process in psutil.process_iter():
try:
if psget(process.uids).real != uid:
continue
if process.pid == this_pid:
continue
cmdline = psget(process.cmdline)
if len(cmdline) < 2:
continue
if (os.path.basename(cmdline[0]).startswith('python') and
os.path.basename(cmdline[1]) == os.path.basename(sys.argv[0]) and
"--start" in cmdline):
process_config = parse_config_arg(cmdline[2:])[0]
if process_config == config_file or (process_config is None and
cmdline[1] == sys.argv[0]):
if "--child-process" in cmdline:
return process
else:
non_child_process = process
except (psutil.NoSuchProcess, psutil.AccessDenied):
continue
return non_child_process if not require_child_process else None
def bash_invocation_for_script(script):
"""Chooses the appropriate bash command to run the provided script."""
if os.path.exists(script):
if os.access(script, os.X_OK):
return ["/bin/sh", "-c", shlex.quote(script)]
else:
return ["/bin/sh", script]
def choose_x_session():
"""Chooses the most appropriate X session command for this system.
Returns:
A string containing the command to run, or a list of strings containing
the executable program and its arguments, which is suitable for passing as
the first parameter of subprocess.Popen(). If a suitable session cannot
be found, returns None.
"""
XSESSION_FILES = [
SESSION_FILE_PATH,
SYSTEM_SESSION_FILE_PATH ]
for startup_file in XSESSION_FILES:
startup_file = os.path.expanduser(startup_file)
if os.path.exists(startup_file):
return bash_invocation_for_script(startup_file)
return [HOST_BINARY_PATH, "--type=xsession_chooser"]
class ParentProcessLogger(object):
"""Redirects logs to the parent process, until the host is ready or quits.
This class creates a pipe to allow logging from the daemon process to be
copied to the parent process. The daemon process adds a log-handler that
directs logging output to the pipe. The parent process reads from this pipe
and writes the content to stderr. When the pipe is no longer needed (for
example, the host signals successful launch or permanent failure), the daemon
removes the log-handler and closes the pipe, causing the the parent process
to reach end-of-file while reading the pipe and exit.
The file descriptor for the pipe to the parent process should be passed to
the constructor. The (grand-)child process should call start_logging() when
it starts, and then use logging.* to issue log statements, as usual. When the
child has either succesfully started the host or terminated, it must call
release_parent() to allow the parent to exit.
"""
__instance = None
def __init__(self, write_fd):
"""Constructor.
Constructs the singleton instance of ParentProcessLogger. This should be
called at most once.
write_fd: The write end of the pipe created by the parent process. If
write_fd is not a valid file descriptor, the constructor will
throw either IOError or OSError.
"""
old_flags = fcntl.fcntl(write_fd, fcntl.F_GETFD)
fcntl.fcntl(write_fd, fcntl.F_SETFD, old_flags | fcntl.FD_CLOEXEC)
self._write_file = os.fdopen(write_fd, 'w')
self._logging_handler = None
ParentProcessLogger.__instance = self
def _start_logging(self):
"""Installs a logging handler that sends log entries to a pipe, prefixed
with the string 'MSG:'. This allows them to be distinguished by the parent
process from commands sent over the same pipe.
Must be called by the child process.
"""
self._logging_handler = logging.StreamHandler(self._write_file)
self._logging_handler.setFormatter(logging.Formatter(fmt='MSG:%(message)s'))
logging.getLogger().addHandler(self._logging_handler)
def _release_parent(self, success):
"""Uninstalls logging handler and closes the pipe, releasing the parent.
Must be called by the child process.
success: If true, write a "host ready" message to the parent process before
closing the pipe.
"""
if self._logging_handler:
logging.getLogger().removeHandler(self._logging_handler)
self._logging_handler = None
if not self._write_file.closed:
if success:
try:
self._write_file.write("READY\n")
self._write_file.flush()
except IOError:
logging.info("Caught IOError writing READY message.")
try:
self._write_file.close()
except IOError:
pass
@staticmethod
def try_start_logging(write_fd):
"""Attempt to initialize ParentProcessLogger and start forwarding log
messages.
Returns False if the file descriptor was invalid (safe to ignore).
"""
try:
ParentProcessLogger(USER_SESSION_MESSAGE_FD)._start_logging()
return True
except (IOError, OSError):
return False
@staticmethod
def release_parent_if_connected(success):
"""If ParentProcessLogger is active, stop logging and release the parent.
success: If true, signal to the parent that the script was successful.
"""
instance = ParentProcessLogger.__instance
if instance is not None:
ParentProcessLogger.__instance = None
instance._release_parent(success)
def run_command_with_group(command, group):
"""Run a command with a different primary group."""
def pre_exec(read_fd, write_fd):
os.close(read_fd)
if (write_fd != 6):
os.dup2(write_fd, 6)
os.close(write_fd)
os.dup2(0, 7)
os.dup2(1, 8)
os.dup2(2, 9)
devnull = os.open(os.devnull, os.O_RDWR)
os.dup2(devnull, 0)
os.dup2(devnull, 1)
os.dup2(devnull, 2)
os.close(devnull)
os.setsid()
read_fd, write_fd = os.pipe()
try:
process = subprocess.Popen(
["sg", group,
"echo success >&6; exec {command} "
"0<&7 1>&8 2>&9 "
"6>&- 7<&- 8>&- 9>&-"
.format(command=" ".join(map(shlex.quote, command)))],
close_fds=False, preexec_fn=lambda: pre_exec(read_fd, write_fd))
result = process.wait()
except OSError as e:
logging.error("Failed to execute sg: {}".format(e.strerror))
if e.errno == errno.ENOENT:
result = COMMAND_NOT_FOUND_EXIT_CODE
else:
result = COMMAND_NOT_EXECUTABLE_EXIT_CODE
os.close(read_fd)
return result
except KeyboardInterrupt:
try:
os.killpg(os.getpgid(process.pid), signal.SIGINT)
result = process.wait()
except OSError:
logging.warning("Command may still be running")
result = 1
finally:
os.close(write_fd)
with os.fdopen(read_fd) as read_file:
contents = read_file.read()
if contents != "success\n":
logging.error("Failed to access {} group. Is the user a member?"
.format(group))
result = COMMAND_NOT_EXECUTABLE_EXIT_CODE
return result
def run_command_as_root(command):
if os.getenv("DISPLAY"):
command = ["/usr/bin/pkexec"] + command
else:
command = ["/usr/bin/sudo", "-k", "--"] + command
return subprocess.call(command)
def exec_self_via_login_shell():
"""Attempt to run the user's login shell and run this script under it. This
will allow the user's ~/.profile or similar to be processed, which may set
environment variables to configure Chrome Remote Desktop."""
args = [sys.argv[0], "--child-process"] + [arg for arg in sys.argv[1:]
if arg != "--new-session"]
try:
shell = os.getenv("SHELL")
if shell is not None:
shell_arg0 = "-" + os.path.basename(shell)
output = subprocess.check_output(
[shell_arg0], executable=shell,
input=b"exec echo CRD_SHELL_TEST_OUTPUT",
timeout=15)
if b"CRD_SHELL_TEST_OUTPUT" in output:
read_fd, write_fd = os.pipe()
os.write(
write_fd,
b"exec " + os.fsencode(" ".join(map(shlex.quote, args))))
os.close(write_fd)
os.dup2(read_fd, 0)
os.close(read_fd)
os.execv(shell, [shell_arg0])
else:
logging.warning("Login shell doesn't execute standard input.")
else:
logging.warning("SHELL envirionment variable not set.")
except Exception as e:
logging.warning(str(e))
logging.warning(
"Failed to run via login shell; continuing without. Environment "
"variables set via ~/.profile or similar won't be processed.")
os.execv(args[0], args)
def start_via_user_session(foreground):
command = [USER_SESSION_PATH, "start"]
if foreground:
command += ["--foreground"]
command += ["--"] + sys.argv[1:]
try:
process = subprocess.Popen(command)
result = process.wait()
except OSError as e:
if e.errno == errno.EACCES:
result = run_command_with_group(command, CHROME_REMOTING_GROUP_NAME)
else:
logging.error("Could not execute {}: {}"
.format(USER_SESSION_PATH, e.strerror))
if e.errno == errno.ENOENT:
result = COMMAND_NOT_FOUND_EXIT_CODE
else:
result = COMMAND_NOT_EXECUTABLE_EXIT_CODE
except KeyboardInterrupt:
result = process.wait()
return result
def cleanup():
logging.info("Cleanup.")
global g_desktop
if g_desktop is not None:
g_desktop.cleanup()
if getattr(g_desktop, 'xorg_conf', None) is not None:
os.remove(g_desktop.xorg_conf)
g_desktop = None
ParentProcessLogger.release_parent_if_connected(False)
class SignalHandler:
"""Reload the config file on SIGHUP. Since we pass the configuration to the
host processes via stdin, they can't reload it, so terminate them. They will
be relaunched automatically with the new config."""
def __init__(self, host_config):
self.host_config = host_config
def __call__(self, signum, _stackframe):
if signum == signal.SIGHUP:
logging.info("SIGHUP caught, restarting host.")
try:
self.host_config.load()
except (IOError, ValueError) as e:
logging.error("Failed to load config: " + str(e))
if g_desktop is not None and g_desktop.host_proc:
g_desktop.host_proc.send_signal(signal.SIGTERM)
else:
raise SystemExit
class RelaunchInhibitor:
"""Helper class for inhibiting launch of a child process before a timeout has
elapsed.
A managed process can be in one of these states:
running, not inhibited (running == True)
stopped and inhibited (running == False and is_inhibited() == True)
stopped but not inhibited (running == False and is_inhibited() == False)
Attributes:
label: Name of the tracked process. Only used for logging.
running: Whether the process is currently running.
earliest_relaunch_time: Time before which the process should not be
relaunched, or 0 if there is no limit.
failures: The number of times that the process ran for less than a
specified timeout, and had to be inhibited. This count is reset to 0
whenever the process has run for longer than the timeout.
"""
def __init__(self, label):
self.label = label
self.running = False
self.earliest_relaunch_time = 0
self.earliest_successful_termination = 0
self.failures = 0
def is_inhibited(self):
return (not self.running) and (time.time() < self.earliest_relaunch_time)
def record_started(self, minimum_lifetime, relaunch_delay):
"""Record that the process was launched, and set the inhibit time to
|timeout| seconds in the future."""
self.earliest_relaunch_time = time.time() + relaunch_delay
self.earliest_successful_termination = time.time() + minimum_lifetime
self.running = True
def record_stopped(self, expected):
"""Record that the process was stopped, and adjust the failure count
depending on whether the process ran long enough. If the process was
intentionally stopped (expected is True), the failure count will not be
incremented."""
self.running = False
if time.time() >= self.earliest_successful_termination:
self.failures = 0
elif not expected:
self.failures += 1
logging.info("Failure count for '%s' is now %d", self.label, self.failures)
def relaunch_self():
"""Relaunches the session to pick up any changes to the session logic in case
Chrome Remote Desktop has been upgraded. We return a special exit code to
inform user-session that it should relaunch.
"""
sys.exit(RELAUNCH_EXIT_CODE)
def waitpid_with_timeout(pid, deadline):
"""Wrapper around os.waitpid() which waits until either a child process dies
or the deadline elapses.
Args:
pid: Process ID to wait for, or -1 to wait for any child process.
deadline: Waiting stops when time.time() exceeds this value.
Returns:
(pid, status): Same as for os.waitpid(), except that |pid| is 0 if no child
changed state within the timeout.
Raises:
Same as for os.waitpid().
"""
while time.time() < deadline:
pid, status = os.waitpid(pid, os.WNOHANG)
if pid != 0:
return (pid, status)
time.sleep(1)
return (0, 0)
def waitpid_handle_exceptions(pid, deadline):
"""Wrapper around os.waitpid()/waitpid_with_timeout(), which waits until
either a child process exits or the deadline elapses, and retries if certain
exceptions occur.
Args:
pid: Process ID to wait for, or -1 to wait for any child process.
deadline: If non-zero, waiting stops when time.time() exceeds this value.
If zero, waiting stops when a child process exits.
Returns:
(pid, status): Same as for waitpid_with_timeout(). |pid| is non-zero if and
only if a child exited during the wait.
Raises:
Same as for os.waitpid(), except:
OSError with errno==EINTR causes the wait to be retried (this can happen,
for example, if this parent process receives SIGHUP).
OSError with errno==ECHILD means there are no child processes, and so
this function sleeps until |deadline|. If |deadline| is zero, this is an
error and the OSError exception is raised in this case.
"""
while True:
try:
if deadline == 0:
pid_result, status = os.waitpid(pid, 0)
else:
pid_result, status = waitpid_with_timeout(pid, deadline)
return (pid_result, status)
except OSError as e:
if e.errno == errno.EINTR:
continue
elif e.errno == errno.ECHILD:
now = time.time()
if deadline == 0:
raise
elif deadline > now:
time.sleep(deadline - now)
return (0, 0)
else:
raise
def watch_for_resolution_changes(initial_size):
"""Watches for any resolution-changes which set the maximum screen resolution,
and resets the initial size if this happens.
The Ubuntu desktop has a component (the 'xrandr' plugin of
unity-settings-daemon) which often changes the screen resolution to the
first listed mode. This is the built-in mode for the maximum screen size,
which can trigger excessive CPU usage in some situations. So this is a hack
which waits for any such events, and undoes the change if it occurs.
Sometimes, the user might legitimately want to use the maximum available
resolution, so this monitoring is limited to a short time-period.
"""
for _ in range(30):
time.sleep(1)
xrandr_output = subprocess.Popen(["xrandr"],
stdout=subprocess.PIPE).communicate()[0]
matches = re.search(br'current (\d+) x (\d+), maximum (\d+) x (\d+)',
xrandr_output)
current_size = (int(matches.group(1)), int(matches.group(2)))
maximum_size = (int(matches.group(3)), int(matches.group(4)))
if current_size != initial_size:
if current_size == maximum_size:
label = "%dx%d" % initial_size
args = ["xrandr", "-s", label]
subprocess.call(args)
args = ["xrandr", "--dpi", "96"]
subprocess.call(args)
break
def setup_argument_parser():
EPILOG = """This script is not intended for use by end-users. To configure
Chrome Remote Desktop, please install the app from the Chrome
Web Store: https://chrome.google.com/remotedesktop"""
parser = argparse.ArgumentParser(
usage="Usage: %(prog)s [options] [ -- [ X server options ] ]",
epilog=EPILOG)
parser.add_argument("-s", "--size", dest="size", action="append",
help="Dimensions of virtual desktop. This can be "
"specified multiple times to make multiple screen "
"resolutions available (if the X server supports this).")
parser.add_argument("-f", "--foreground", dest="foreground", default=False,
action="store_true",
help="Don't run as a background daemon.")
parser.add_argument("--start", dest="start", default=False,
action="store_true",
help="Start the host.")
parser.add_argument("-k", "--stop", dest="stop", default=False,
action="store_true",
help="Stop the daemon currently running.")
parser.add_argument("--get-status", dest="get_status", default=False,
action="store_true",
help="Prints host status")
parser.add_argument("--check-running", dest="check_running",
default=False, action="store_true",
help="Return 0 if the daemon is running, or 1 otherwise.")
parser.add_argument("--config", dest="config", action="store",
help="Use the specified configuration file.")
parser.add_argument("--reload", dest="reload", default=False,
action="store_true",
help="Signal currently running host to reload the "
"config.")
parser.add_argument("--enable-and-start", dest="enable_and_start",
default=False, action="store_true",
help="Enable and start chrome-remote-desktop for the "
"current user.")
parser.add_argument("--add-user-as-root", dest="add_user_as_root",
action="store", metavar="USER",
help="Adds the specified user to the "
"chrome-remote-desktop group (must be run as root).")
parser.add_argument("--child-process", dest="child_process", default=False,
action="store_true",
help=argparse.SUPPRESS)
parser.add_argument("--new-session", dest="new_session", default=False,
action="store_true",
help=argparse.SUPPRESS)
parser.add_argument("--watch-resolution", dest="watch_resolution",
type=int, nargs=2, default=False, action="store",
help=argparse.SUPPRESS)
parser.add_argument(dest="args", nargs="*", help=argparse.SUPPRESS)
return parser
def main():
parser = setup_argument_parser()
options = parser.parse_args()
if options.config:
config_file = options.config
else:
config_file = os.path.join(CONFIG_DIR, "host#%s.json" % g_host_hash)
config_file = os.path.realpath(config_file)
if options.get_status:
proc = get_daemon_proc(config_file)
if proc is not None:
print("STARTED")
elif is_supported_platform():
print("STOPPED")
else:
print("NOT_IMPLEMENTED")
return 0
if options.check_running:
proc = get_daemon_proc(config_file)
return 1 if proc is None else 0
if options.stop:
proc = get_daemon_proc(config_file)
if proc is None:
print("The daemon is not currently running")
else:
print("Killing process %s" % proc.pid)
proc.terminate()
try:
proc.wait(timeout=30)
except psutil.TimeoutExpired:
print("Timed out trying to kill daemon process")
return 1
return 0
if options.reload:
proc = get_daemon_proc(config_file)
if proc is None:
return 1
proc.send_signal(signal.SIGHUP)
return 0
if options.enable_and_start:
user = getpass.getuser()
if os.path.isdir("/run/systemd/system"):
return run_command_as_root(["systemctl", "enable", "--now",
"chrome-remote-desktop@" + user])
else:
try:
if user in grp.getgrnam(CHROME_REMOTING_GROUP_NAME).gr_mem:
logging.info("User '%s' is already a member of '%s'." %
(user, CHROME_REMOTING_GROUP_NAME))
return 0
except KeyError:
logging.info("Group '%s' not found." % CHROME_REMOTING_GROUP_NAME)
if run_command_as_root([SCRIPT_PATH, '--add-user-as-root', user]) != 0:
logging.error("Failed to add user to group")
return 1
sys.argv = [arg if arg != "--enable-and-start" else "--start"
for arg in sys.argv]
options.start = True
if options.add_user_as_root is not None:
if os.getuid() != 0:
logging.error("--add-user-as-root can only be specified as root.")
return 1;
user = options.add_user_as_root
try:
pwd.getpwnam(user)
except KeyError:
logging.error("user '%s' does not exist." % user)
return 1
try:
subprocess.check_call(["/usr/sbin/groupadd", "-f",
CHROME_REMOTING_GROUP_NAME])
subprocess.check_call(["/usr/bin/gpasswd", "--add", user,
CHROME_REMOTING_GROUP_NAME])
except (ValueError, OSError, subprocess.CalledProcessError) as e:
logging.error("Command failed: " + str(e))
return 1
return 0
if options.watch_resolution:
watch_for_resolution_changes(tuple(options.watch_resolution))
return 0
if not options.start:
print(EPILOG, file=sys.stderr)
return 1
if get_daemon_proc(config_file, options.child_process) is not None:
if options.child_process:
ParentProcessLogger.try_start_logging(USER_SESSION_MESSAGE_FD)
logging.info("Service already running.")
ParentProcessLogger.release_parent_if_connected(True)
return 0
if config_file != options.config:
sys.argv = ([sys.argv[0], "--config=" + config_file] +
parse_config_arg(sys.argv[1:])[1])
if options.child_process:
os.execvp(sys.argv[0], sys.argv)
if options.new_session:
exec_self_via_login_shell()
if not options.child_process:
if os.path.isdir("/run/systemd/system"):
return run_command_as_root(["systemctl", "start",
"chrome-remote-desktop@" + getpass.getuser()])
else:
return start_via_user_session(options.foreground)
ParentProcessLogger.try_start_logging(USER_SESSION_MESSAGE_FD)
if display_manager_is_gdm():
gdm_message = (
"WARNING: This system uses GDM. Some GDM versions have a bug that "
"prevents local login while Chrome Remote Desktop is running. If you "
"run into this issue, you can stop Chrome Remote Desktop by visiting "
"https://remotedesktop.google.com/access on another machine and "
"clicking the delete icon next to this machine. It may take up to five "
"minutes for the Chrome Remote Desktop to exit on this machine and for "
"local login to start working again.")
logging.warning(gdm_message)
syslog.syslog(syslog.LOG_WARNING | syslog.LOG_DAEMON, gdm_message)
default_sizes = DEFAULT_SIZES
if not options.size:
if DEFAULT_SIZES_ENV_VAR in os.environ:
default_sizes = os.environ[DEFAULT_SIZES_ENV_VAR]
options.size = default_sizes.split(",")
sizes = []
for size in options.size:
size_components = size.split("x")
if len(size_components) != 2:
parser.error("Incorrect size format '%s', should be WIDTHxHEIGHT" % size)
try:
width = int(size_components[0])
height = int(size_components[1])
if width < 100 or height < 100:
raise ValueError
except ValueError:
parser.error("Width and height should be 100 pixels or greater")
sizes.append((width, height))
atexit.register(cleanup)
host_config = Config(config_file)
try:
host_config.load()
except (IOError, ValueError) as e:
print("Failed to load config: " + str(e), file=sys.stderr)
return 1
for s in [signal.SIGHUP, signal.SIGINT, signal.SIGTERM]:
signal.signal(s, SignalHandler(host_config))
auth = Authentication()
auth_config_valid = auth.copy_from(host_config)
host = Host()
host_config_valid = host.copy_from(host_config)
if not host_config_valid or not auth_config_valid:
logging.error("Failed to load host configuration.")
return 1
if host.host_id:
logging.info("Using host_id: " + host.host_id)
extra_start_host_args = []
if HOST_EXTRA_PARAMS_ENV_VAR in os.environ:
extra_start_host_args = \
re.split('\s+', os.environ[HOST_EXTRA_PARAMS_ENV_VAR].strip())
is_wayland = any([opt == '--enable-wayland' for opt in extra_start_host_args])
if is_wayland:
desktop = WaylandDesktop(sizes)
else:
desktop = XDesktop(sizes)
tear_down = False
while True:
if tear_down:
desktop.cleanup()
failure_count = desktop.aggregate_failure_count()
tear_down = False
if (failure_count == 0):
logging.info("Relaunching self")
relaunch_self()
else:
pass
relaunch_times = []
backoff_time = SHORT_BACKOFF_TIME
for inhibitor, offline_reason in desktop.inhibitors.items():
if inhibitor.failures >= MAX_LAUNCH_FAILURES:
logging.error("Too many launch failures of '%s', exiting."
% inhibitor.label)
desktop.report_offline_reason(host_config, offline_reason)
return 1
elif inhibitor.failures >= SHORT_BACKOFF_THRESHOLD:
backoff_time = LONG_BACKOFF_TIME
if inhibitor.is_inhibited():
relaunch_times.append(inhibitor.earliest_relaunch_time)
if relaunch_times:
logging.info("Waiting before relaunching")
else:
if (desktop.server_proc is None and desktop.pre_session_proc is None and
desktop.session_proc is None):
desktop.launch_session(options.args, backoff_time)
if desktop.host_proc is None:
desktop.launch_host(host_config, extra_start_host_args, backoff_time)
deadline = max(relaunch_times) if relaunch_times else 0
pid, status = waitpid_handle_exceptions(-1, deadline)
if pid == 0:
continue
logging.info("wait() returned (%s,%s)" % (pid, status))
tear_down = desktop.on_process_exit(pid, status)
if __name__ == "__main__":
logging.basicConfig(level=logging.DEBUG,
format="%(asctime)s:%(levelname)s:%(message)s")
sys.exit(main())
