autorandr.py

   1 #!/usr/bin/env python3
   2 # encoding: utf-8
   3 #
   4 # autorandr.py
   5 # Copyright (c) 2015, Phillip Berndt
   6 #
   7 # Autorandr rewrite in Python
   8 #
   9 # This script aims to be fully compatible with the original autorandr.
  10 #
  11 # This program is free software: you can redistribute it and/or modify
  12 # it under the terms of the GNU General Public License as published by
  13 # the Free Software Foundation, either version 3 of the License, or
  14 # (at your option) any later version.
  15 #
  16 # This program is distributed in the hope that it will be useful,
  17 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  18 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  19 # GNU General Public License for more details.
  20 #
  21 # You should have received a copy of the GNU General Public License
  22 # along with this program. If not, see <http://www.gnu.org/licenses/>.
  23 #
  24
  25 from __future__ import print_function
  26
  27 import binascii
  28 import copy
  29 import getopt
  30 import hashlib
  31 import os
  32 import posix
  33 import pwd
  34 import re
  35 import shlex
  36 import subprocess
  37 import sys
  38 import shutil
  39 import time
  40 import glob
  41
  42 from collections import OrderedDict
  43 from functools import reduce
  44 from itertools import chain
  45
  46 try:
  47     from packaging.version import Version
  48 except ModuleNotFoundError:
  49     from distutils.version import LooseVersion as Version
  50
  51 if sys.version_info.major == 2:
  52     import ConfigParser as configparser
  53 else:
  54     import configparser
  55
  56 __version__ = "1.12.1"
  57
  58 try:
  59     input = raw_input
  60 except NameError:
  61     pass
  62
  63 virtual_profiles = [
  64     # (name, description, callback)
  65     ("off", "Disable all outputs", None),
  66     ("common", "Clone all connected outputs at the largest common resolution", None),
  67     ("clone-largest", "Clone all connected outputs with the largest resolution (scaled down if necessary)", None),
  68     ("horizontal", "Stack all connected outputs horizontally at their largest resolution", None),
  69     ("vertical", "Stack all connected outputs vertically at their largest resolution", None),
  70 ]
  71
  72 properties = [
  73     "Colorspace",
  74     "max bpc",
  75     "aspect ratio",
  76     "Broadcast RGB",
  77     "audio",
  78     "non-desktop",
  79     "TearFree",
  80     "underscan vborder",
  81     "underscan hborder",
  82     "underscan",
  83     "scaling mode",
  84 ]
  85
  86 help_text = """
  87 Usage: autorandr [options]
  88
  89 -h, --help              get this small help
  90 -c, --change            automatically load the first detected profile
  91 -d, --default <profile> make profile <profile> the default profile
  92 -l, --load <profile>    load profile <profile>
  93 -s, --save <profile>    save your current setup to profile <profile>
  94 -r, --remove <profile>  remove profile <profile>
  95 --batch                 run autorandr for all users with active X11 sessions
  96 --current               only list current (active) configuration(s)
  97 --config                dump your current xrandr setup
  98 --cycle                 automatically load the next detected profile
  99 --debug                 enable verbose output
 100 --detected              only list detected (available) configuration(s)
 101 --dry-run               don't change anything, only print the xrandr commands
 102 --fingerprint           fingerprint your current hardware setup
 103 --ignore-lid            treat outputs as connected even if their lids are closed
 104 --match-edid            match diplays based on edid instead of name
 105 --force                 force (re)loading of a profile / overwrite exiting files
 106 --list                  list configurations
 107 --skip-options <option> comma separated list of xrandr arguments (e.g. "gamma")
 108                         to skip both in detecting changes and applying a profile
 109 --version               show version information and exit
 110
 111  If no suitable profile can be identified, the current configuration is kept.
 112  To change this behaviour and switch to a fallback configuration, specify
 113  --default <profile>.
 114
 115  autorandr supports a set of per-profile and global hooks. See the documentation
 116  for details.
 117
 118  The following virtual configurations are available:
 119 """.strip()
 120
 121
 122 def is_closed_lid(output):
 123     if not re.match(r'(eDP(-?[0-9]\+)*|LVDS(-?[0-9]\+)*)', output):
 124         return False
 125     lids = glob.glob("/proc/acpi/button/lid/*/state")
 126     if len(lids) == 1:
 127         state_file = lids[0]
 128         with open(state_file) as f:
 129             content = f.read()
 130             return "close" in content
 131     return False
 132
 133
 134 class AutorandrException(Exception):
 135     def __init__(self, message, original_exception=None, report_bug=False):
 136         self.message = message
 137         self.report_bug = report_bug
 138         if original_exception:
 139             self.original_exception = original_exception
 140             trace = sys.exc_info()[2]
 141             while trace.tb_next:
 142                 trace = trace.tb_next
 143             self.line = trace.tb_lineno
 144             self.file_name = trace.tb_frame.f_code.co_filename
 145         else:
 146             try:
 147                 import inspect
 148                 frame = inspect.currentframe().f_back
 149                 self.line = frame.f_lineno
 150                 self.file_name = frame.f_code.co_filename
 151             except:
 152                 self.line = None
 153                 self.file_name = None
 154             self.original_exception = None
 155
 156         if os.path.abspath(self.file_name) == os.path.abspath(sys.argv[0]):
 157             self.file_name = None
 158
 159     def __str__(self):
 160         retval = [self.message]
 161         if self.line:
 162             retval.append(" (line %d%s)" % (self.line, ("; %s" % self.file_name) if self.file_name else ""))
 163         if self.original_exception:
 164             retval.append(":\n  ")
 165             retval.append(str(self.original_exception).replace("\n", "\n  "))
 166         if self.report_bug:
 167             retval.append("\nThis appears to be a bug. Please help improving autorandr by reporting it upstream:"
 168                           "\nhttps://github.com/phillipberndt/autorandr/issues"
 169                           "\nPlease attach the output of `xrandr --verbose` to your bug report if appropriate.")
 170         return "".join(retval)
 171
 172
 173 class XrandrOutput(object):
 174     "Represents an XRandR output"
 175
 176     XRANDR_PROPERTIES_REGEXP = "|".join(
 177         [r"{}:\s*(?P<{}>[\S ]*\S+)"
 178          .format(re.sub(r"\s", r"\\\g<0>", p), re.sub(r"\W+", "_", p.lower()))
 179             for p in properties])
 180
 181     # This regular expression is used to parse an output in `xrandr --verbose'
 182     XRANDR_OUTPUT_REGEXP = """(?x)
 183         ^\s*(?P<output>\S[^ ]*)\s+                                                      # Line starts with output name
 184         (?:                                                                             # Differentiate disconnected and connected
 185             disconnected |                                                              # in first line
 186             unknown\ connection |
 187             (?P<connected>connected)
 188         )
 189         \s*
 190         (?P<primary>primary\ )?                                                         # Might be primary screen
 191         (?:\s*
 192             (?P<width>[0-9]+)x(?P<height>[0-9]+)                                        # Resolution (might be overridden below!)
 193             \+(?P<x>-?[0-9]+)\+(?P<y>-?[0-9]+)\s+                                       # Position
 194             (?:\(0x[0-9a-fA-F]+\)\s+)?                                                  # XID
 195             (?P<rotate>(?:normal|left|right|inverted))\s+                               # Rotation
 196             (?:(?P<reflect>X\ and\ Y|X|Y)\ axis)?                                       # Reflection
 197         )?                                                                              # .. but only if the screen is in use.
 198         (?:[\ \t]*\([^\)]+\))(?:\s*[0-9]+mm\sx\s[0-9]+mm)?
 199         (?:[\ \t]*panning\ (?P<panning>[0-9]+x[0-9]+\+[0-9]+\+[0-9]+))?                 # Panning information
 200         (?:[\ \t]*tracking\ (?P<tracking>[0-9]+x[0-9]+\+[0-9]+\+[0-9]+))?               # Tracking information
 201         (?:[\ \t]*border\ (?P<border>(?:[0-9]+/){3}[0-9]+))?                            # Border information
 202         (?:\s*(?:                                                                       # Properties of the output
 203             Gamma: (?P<gamma>(?:inf|-?[0-9\.\-: e])+) |                                 # Gamma value
 204             CRTC:\s*(?P<crtc>[0-9]) |                                                   # CRTC value
 205             Transform: (?P<transform>(?:[\-0-9\. ]+\s+){3}) |                           # Transformation matrix
 206             EDID: (?P<edid>\s*?(?:\\n\\t\\t[0-9a-f]+)+) |                               # EDID of the output
 207             """ + XRANDR_PROPERTIES_REGEXP + """ |                                      # Properties to include in the profile
 208             (?![0-9])[^:\s][^:\n]+:.*(?:\s\\t[\\t ].+)*                                 # Other properties
 209         ))+
 210         \s*
 211         (?P<modes>(?:
 212             (?P<mode_name>\S+).+?\*current.*\s+                                         # Interesting (current) resolution:
 213              h:\s+width\s+(?P<mode_width>[0-9]+).+\s+                                   # Extract rate
 214              v:\s+height\s+(?P<mode_height>[0-9]+).+clock\s+(?P<rate>[0-9\.]+)Hz\s* |
 215             \S+(?:(?!\*current).)+\s+h:.+\s+v:.+\s*                                     # Other resolutions
 216         )*)
 217     """
 218
 219     XRANDR_OUTPUT_MODES_REGEXP = """(?x)
 220         (?P<name>\S+).+?(?P<preferred>\+preferred)?\s+
 221          h:\s+width\s+(?P<width>[0-9]+).+\s+
 222          v:\s+height\s+(?P<height>[0-9]+).+clock\s+(?P<rate>[0-9\.]+)Hz\s* |
 223     """
 224
 225     XRANDR_13_DEFAULTS = {
 226         "transform": "1,0,0,0,1,0,0,0,1",
 227         "panning": "0x0",
 228     }
 229
 230     XRANDR_12_DEFAULTS = {
 231         "reflect": "normal",
 232         "rotate": "normal",
 233         "gamma": "1.0:1.0:1.0",
 234     }
 235
 236     XRANDR_DEFAULTS = dict(list(XRANDR_13_DEFAULTS.items()) + list(XRANDR_12_DEFAULTS.items()))
 237
 238     EDID_UNAVAILABLE = "--CONNECTED-BUT-EDID-UNAVAILABLE-"
 239
 240     def __repr__(self):
 241         return "<%s%s %s>" % (self.output, self.fingerprint, " ".join(self.option_vector))
 242
 243     @property
 244     def short_edid(self):
 245         return ("%s..%s" % (self.edid[:5], self.edid[-5:])) if self.edid else ""
 246
 247     @property
 248     def options_with_defaults(self):
 249         "Return the options dictionary, augmented with the default values that weren't set"
 250         if "off" in self.options:
 251             return self.options
 252         options = {}
 253         if xrandr_version() >= Version("1.3"):
 254             options.update(self.XRANDR_13_DEFAULTS)
 255         if xrandr_version() >= Version("1.2"):
 256             options.update(self.XRANDR_12_DEFAULTS)
 257         options.update(self.options)
 258         return {a: b for a, b in options.items() if a not in self.ignored_options}
 259
 260     @property
 261     def filtered_options(self):
 262         "Return a dictionary of options without ignored options"
 263         return {a: b for a, b in self.options.items() if a not in self.ignored_options}
 264
 265     @property
 266     def option_vector(self):
 267         "Return the command line parameters for XRandR for this instance"
 268         args = ["--output", self.output]
 269         for option, arg in sorted(self.options_with_defaults.items()):
 270             if option.startswith("x-prop-"):
 271                 prop_found = False
 272                 for prop, xrandr_prop in [(re.sub(r"\W+", "_", p.lower()), p) for p in properties]:
 273                     if prop == option[7:]:
 274                         args.append("--set")
 275                         args.append(xrandr_prop)
 276                         prop_found = True
 277                         break
 278                 if not prop_found:
 279                     print("Warning: Unknown property `%s' in config file. Skipping." % option[7:], file=sys.stderr)
 280                     continue
 281             elif option.startswith("x-"):
 282                 print("Warning: Unknown option `%s' in config file. Skipping." % option, file=sys.stderr)
 283                 continue
 284             else:
 285                 args.append("--%s" % option)
 286             if arg:
 287                 args.append(arg)
 288         return args
 289
 290     @property
 291     def option_string(self):
 292         "Return the command line parameters in the configuration file format"
 293         options = ["output %s" % self.output]
 294         for option, arg in sorted(self.filtered_options.items()):
 295             if arg:
 296                 options.append("%s %s" % (option, arg))
 297             else:
 298                 options.append(option)
 299         return "\n".join(options)
 300
 301     @property
 302     def sort_key(self):
 303         "Return a key to sort the outputs for xrandr invocation"
 304         if not self.edid:
 305             return -2
 306         if "off" in self.options:
 307             return -1
 308         if "pos" in self.options:
 309             x, y = map(float, self.options["pos"].split("x"))
 310         else:
 311             x, y = 0, 0
 312         return x + 10000 * y
 313
 314     def __init__(self, output, edid, options):
 315         "Instanciate using output name, edid and a dictionary of XRandR command line parameters"
 316         self.output = output
 317         self.edid = edid
 318         self.options = options
 319         self.ignored_options = []
 320         self.parse_serial_from_edid()
 321         self.remove_default_option_values()
 322
 323     def parse_serial_from_edid(self):
 324         self.serial = None
 325         if self.edid:
 326             # Thx to pyedid project, the following code was
 327             # copied (and modified) from pyedid/__init__py:21 [parse_edid()]
 328             raw = bytes.fromhex(self.edid)
 329             # Check EDID header, and checksum
 330             if raw[:8] != b'\x00\xff\xff\xff\xff\xff\xff\x00' or sum(raw) % 256 != 0:
 331                 return
 332             serial_no = int.from_bytes(raw[15:11:-1], byteorder='little')
 333
 334             serial_text = None
 335             # Offsets of standard timing information descriptors 1-4
 336             # (see https://en.wikipedia.org/wiki/Extended_Display_Identification_Data#EDID_1.4_data_format)
 337             for timing_bytes in (raw[54:72], raw[72:90], raw[90:108], raw[108:126]):
 338                 if timing_bytes[0:2] == b'\x00\x00':
 339                     timing_type = timing_bytes[3]
 340                     if timing_type == 0xFF:
 341                         buffer = timing_bytes[5:]
 342                         buffer = buffer.partition(b'\x0a')[0]
 343                         serial_text = buffer.decode('cp437')
 344             self.serial = serial_text if serial_text else "0x{:x}".format(serial_no) if serial_no != 0 else None
 345
 346     def set_ignored_options(self, options):
 347         "Set a list of xrandr options that are never used (neither when comparing configurations nor when applying them)"
 348         self.ignored_options = list(options)
 349
 350     def remove_default_option_values(self):
 351         "Remove values from the options dictionary that are superflous"
 352         if "off" in self.options and len(self.options.keys()) > 1:
 353             self.options = {"off": None}
 354             return
 355         for option, default_value in self.XRANDR_DEFAULTS.items():
 356             if option in self.options and self.options[option] == default_value:
 357                 del self.options[option]
 358
 359     @classmethod
 360     def from_xrandr_output(cls, xrandr_output):
 361         """Instanciate an XrandrOutput from the output of `xrandr --verbose'
 362
 363         This method also returns a list of modes supported by the output.
 364         """
 365         try:
 366             xrandr_output = xrandr_output.replace("\r\n", "\n")
 367             match_object = re.search(XrandrOutput.XRANDR_OUTPUT_REGEXP, xrandr_output)
 368         except:
 369             raise AutorandrException("Parsing XRandR output failed, there is an error in the regular expression.",
 370                                      report_bug=True)
 371         if not match_object:
 372             debug = debug_regexp(XrandrOutput.XRANDR_OUTPUT_REGEXP, xrandr_output)
 373             raise AutorandrException("Parsing XRandR output failed, the regular expression did not match: %s" % debug,
 374                                      report_bug=True)
 375         remainder = xrandr_output[len(match_object.group(0)):]
 376         if remainder:
 377             raise AutorandrException("Parsing XRandR output failed, %d bytes left unmatched after "
 378                                      "regular expression, starting at byte %d with ..'%s'." %
 379                                      (len(remainder), len(match_object.group(0)), remainder[:10]),
 380                                      report_bug=True)
 381
 382         match = match_object.groupdict()
 383
 384         modes = []
 385         if match["modes"]:
 386             modes = []
 387             for mode_match in re.finditer(XrandrOutput.XRANDR_OUTPUT_MODES_REGEXP, match["modes"]):
 388                 if mode_match.group("name"):
 389                     modes.append(mode_match.groupdict())
 390             if not modes:
 391                 raise AutorandrException("Parsing XRandR output failed, couldn't find any display modes", report_bug=True)
 392
 393         options = {}
 394         if not match["connected"]:
 395             edid = None
 396         elif match["edid"]:
 397             edid = "".join(match["edid"].strip().split())
 398         else:
 399             edid = "%s-%s" % (XrandrOutput.EDID_UNAVAILABLE, match["output"])
 400
 401         # An output can be disconnected but still have a mode configured. This can only happen
 402         # as a residual situation after a disconnect, you cannot associate a mode with an disconnected
 403         # output.
 404         #
 405         # This code needs to be careful not to mix the two. An output should only be configured to
 406         # "off" if it doesn't have a mode associated with it, which is modelled as "not a width" here.
 407         if not match["width"]:
 408             options["off"] = None
 409         else:
 410             if match["mode_name"]:
 411                 options["mode"] = match["mode_name"]
 412             elif match["mode_width"]:
 413                 options["mode"] = "%sx%s" % (match["mode_width"], match["mode_height"])
 414             else:
 415                 if match["rotate"] not in ("left", "right"):
 416                     options["mode"] = "%sx%s" % (match["width"] or 0, match["height"] or 0)
 417                 else:
 418                     options["mode"] = "%sx%s" % (match["height"] or 0, match["width"] or 0)
 419             if match["rotate"]:
 420                 options["rotate"] = match["rotate"]
 421             if match["primary"]:
 422                 options["primary"] = None
 423             if match["reflect"] == "X":
 424                 options["reflect"] = "x"
 425             elif match["reflect"] == "Y":
 426                 options["reflect"] = "y"
 427             elif match["reflect"] == "X and Y":
 428                 options["reflect"] = "xy"
 429             if match["x"] or match["y"]:
 430                 options["pos"] = "%sx%s" % (match["x"] or "0", match["y"] or "0")
 431             if match["panning"]:
 432                 panning = [match["panning"]]
 433                 if match["tracking"]:
 434                     panning += ["/", match["tracking"]]
 435                     if match["border"]:
 436                         panning += ["/", match["border"]]
 437                 options["panning"] = "".join(panning)
 438             if match["transform"]:
 439                 transformation = ",".join(match["transform"].strip().split())
 440                 if transformation != "1.000000,0.000000,0.000000,0.000000,1.000000,0.000000,0.000000,0.000000,1.000000":
 441                     options["transform"] = transformation
 442                     if not match["mode_name"]:
 443                         # TODO We'd need to apply the reverse transformation here. Let's see if someone complains,
 444                         # I doubt that this special case is actually required.
 445                         print("Warning: Output %s has a transformation applied. Could not determine correct mode! "
 446                               "Using `%s'." % (match["output"], options["mode"]), file=sys.stderr)
 447             if match["gamma"]:
 448                 gamma = match["gamma"].strip()
 449                 # xrandr prints different values in --verbose than it accepts as a parameter value for --gamma
 450                 # Also, it is not able to work with non-standard gamma ramps. Finally, it auto-corrects 0 to 1,
 451                 # so we approximate by 1e-10.
 452                 gamma = ":".join([str(max(1e-10, round(1. / float(x), 3))) for x in gamma.split(":")])
 453                 options["gamma"] = gamma
 454             if match["crtc"]:
 455                 options["crtc"] = match["crtc"]
 456             if match["rate"]:
 457                 options["rate"] = match["rate"]
 458             for prop in [re.sub(r"\W+", "_", p.lower()) for p in properties]:
 459                 if match[prop]:
 460                     options["x-prop-" + prop] = match[prop]
 461
 462         return XrandrOutput(match["output"], edid, options), modes
 463
 464     @classmethod
 465     def from_config_file(cls, edid_map, configuration):
 466         "Instanciate an XrandrOutput from the contents of a configuration file"
 467         options = {}
 468         for line in configuration.split("\n"):
 469             if line:
 470                 line = line.split(None, 1)
 471                 if line and line[0].startswith("#"):
 472                     continue
 473                 options[line[0]] = line[1] if len(line) > 1 else None
 474
 475         edid = None
 476
 477         if options["output"] in edid_map:
 478             edid = edid_map[options["output"]]
 479         else:
 480             # This fuzzy matching is for legacy autorandr that used sysfs output names
 481             fuzzy_edid_map = [re.sub("(card[0-9]+|-)", "", x) for x in edid_map.keys()]
 482             fuzzy_output = re.sub("(card[0-9]+|-)", "", options["output"])
 483             if fuzzy_output in fuzzy_edid_map:
 484                 edid = edid_map[list(edid_map.keys())[fuzzy_edid_map.index(fuzzy_output)]]
 485             elif "off" not in options:
 486                 raise AutorandrException("Failed to find an EDID for output `%s' in setup file, required as `%s' "
 487                                          "is not off in config file." % (options["output"], options["output"]))
 488         output = options["output"]
 489         del options["output"]
 490
 491         return XrandrOutput(output, edid, options)
 492
 493     @property
 494     def fingerprint(self):
 495         return str(self.serial) if self.serial else self.short_edid
 496
 497     def fingerprint_equals(self, other):
 498         if self.serial and other.serial:
 499            return self.serial == other.serial
 500         else:
 501            return self.edid_equals(other)
 502
 503     def edid_equals(self, other):
 504         "Compare to another XrandrOutput's edid and on/off-state, taking legacy autorandr behaviour (md5sum'ing) into account"
 505         if self.edid and other.edid:
 506             if len(self.edid) == 32 and len(other.edid) != 32 and not other.edid.startswith(XrandrOutput.EDID_UNAVAILABLE):
 507                 return hashlib.md5(binascii.unhexlify(other.edid)).hexdigest() == self.edid
 508             if len(self.edid) != 32 and len(other.edid) == 32 and not self.edid.startswith(XrandrOutput.EDID_UNAVAILABLE):
 509                 return hashlib.md5(binascii.unhexlify(self.edid)).hexdigest() == other.edid
 510             if "*" in self.edid:
 511                 return match_asterisk(self.edid, other.edid) > 0
 512             elif "*" in other.edid:
 513                 return match_asterisk(other.edid, self.edid) > 0
 514         return self.edid == other.edid
 515
 516     def __ne__(self, other):
 517         return not (self == other)
 518
 519     def __eq__(self, other):
 520         return self.fingerprint_equals(other) and self.output == other.output and self.filtered_options == other.filtered_options
 521
 522     def verbose_diff(self, other):
 523         "Compare to another XrandrOutput and return a list of human readable differences"
 524         diffs = []
 525         if not self.fingerprint_equals(other):
 526             diffs.append("EDID `%s' differs from `%s'" % (self.fingerprint, other.fingerprint))
 527         if self.output != other.output:
 528             diffs.append("Output name `%s' differs from `%s'" % (self.output, other.output))
 529         if "off" in self.options and "off" not in other.options:
 530             diffs.append("The output is disabled currently, but active in the new configuration")
 531         elif "off" in other.options and "off" not in self.options:
 532             diffs.append("The output is currently enabled, but inactive in the new configuration")
 533         else:
 534             for name in set(chain.from_iterable((self.options.keys(), other.options.keys()))):
 535                 if name not in other.options:
 536                     diffs.append("Option --%s %sis not present in the new configuration" %
 537                                  (name, "(= `%s') " % self.options[name] if self.options[name] else ""))
 538                 elif name not in self.options:
 539                     diffs.append("Option --%s (`%s' in the new configuration) is not present currently" %
 540                                  (name, other.options[name]))
 541                 elif self.options[name] != other.options[name]:
 542                     diffs.append("Option --%s %sis `%s' in the new configuration" %
 543                                  (name, "(= `%s') " % self.options[name] if self.options[name] else "", other.options[name]))
 544         return diffs
 545
 546
 547 def xrandr_version():
 548     "Return the version of XRandR that this system uses"
 549     if getattr(xrandr_version, "version", False) is False:
 550         version_string = os.popen("xrandr -v").read()
 551         try:
 552             version = re.search("xrandr program version\s+([0-9\.]+)", version_string).group(1)
 553             xrandr_version.version = Version(version)
 554         except AttributeError:
 555             xrandr_version.version = Version("1.3.0")
 556
 557     return xrandr_version.version
 558
 559
 560 def debug_regexp(pattern, string):
 561     "Use the partial matching functionality of the regex module to display debug info on a non-matching regular expression"
 562     try:
 563         import regex
 564         bounds = (0, len(string))
 565         while bounds[0] != bounds[1]:
 566             half = int((bounds[0] + bounds[1]) / 2)
 567             if half == bounds[0]:
 568                 break
 569             bounds = (half, bounds[1]) if regex.search(pattern, string[:half], partial=True) else (bounds[0], half - 1)
 570         partial_length = bounds[0]
 571         return ("Regular expression matched until position %d, ..'%s', and did not match from '%s'.." %
 572                 (partial_length, string[max(0, partial_length - 20):partial_length],
 573                  string[partial_length:partial_length + 10]))
 574     except ImportError:
 575         pass
 576     return "Debug information would be available if the `regex' module was installed."
 577
 578
 579 def parse_xrandr_output(
 580     *,
 581     ignore_lid,
 582 ):
 583     "Parse the output of `xrandr --verbose' into a list of outputs"
 584     xrandr_output = os.popen("xrandr -q --verbose").read()
 585     if not xrandr_output:
 586         raise AutorandrException("Failed to run xrandr")
 587
 588     # We are not interested in screens
 589     xrandr_output = re.sub("(?m)^Screen [0-9].+", "", xrandr_output).strip()
 590
 591     # Split at output boundaries and instanciate an XrandrOutput per output
 592     split_xrandr_output = re.split("(?m)^([^ ]+ (?:(?:dis)?connected|unknown connection).*)$", xrandr_output)
 593     if len(split_xrandr_output) < 2:
 594         raise AutorandrException("No output boundaries found", report_bug=True)
 595     outputs = OrderedDict()
 596     modes = OrderedDict()
 597     for i in range(1, len(split_xrandr_output), 2):
 598         output_name = split_xrandr_output[i].split()[0]
 599         output, output_modes = XrandrOutput.from_xrandr_output("".join(split_xrandr_output[i:i + 2]))
 600         outputs[output_name] = output
 601         if output_modes:
 602             modes[output_name] = output_modes
 603
 604     # consider a closed lid as disconnected if other outputs are connected
 605     if not ignore_lid and sum(
 606         o.edid != None
 607         for o
 608         in outputs.values()
 609     ) > 1:
 610         for output_name in outputs.keys():
 611             if is_closed_lid(output_name):
 612                 outputs[output_name].edid = None
 613
 614     return outputs, modes
 615
 616
 617 def load_profiles(profile_path):
 618     "Load the stored profiles"
 619
 620     profiles = {}
 621     for profile in os.listdir(profile_path):
 622         config_name = os.path.join(profile_path, profile, "config")
 623         setup_name = os.path.join(profile_path, profile, "setup")
 624         if not os.path.isfile(config_name) or not os.path.isfile(setup_name):
 625             continue
 626
 627         edids = dict([x.split() for x in (y.strip() for y in open(setup_name).readlines()) if x and x[0] != "#"])
 628
 629         config = {}
 630         buffer = []
 631         for line in chain(open(config_name).readlines(), ["output"]):
 632             if line[:6] == "output" and buffer:
 633                 config[buffer[0].strip().split()[-1]] = XrandrOutput.from_config_file(edids, "".join(buffer))
 634                 buffer = [line]
 635             else:
 636                 buffer.append(line)
 637
 638         for output_name in list(config.keys()):
 639             if config[output_name].edid is None:
 640                 del config[output_name]
 641
 642         profiles[profile] = {
 643             "config": config,
 644             "path": os.path.join(profile_path, profile),
 645             "config-mtime": os.stat(config_name).st_mtime,
 646         }
 647
 648     return profiles
 649
 650
 651 def get_symlinks(profile_path):
 652     "Load all symlinks from a directory"
 653
 654     symlinks = {}
 655     for link in os.listdir(profile_path):
 656         file_name = os.path.join(profile_path, link)
 657         if os.path.islink(file_name):
 658             symlinks[link] = os.readlink(file_name)
 659
 660     return symlinks
 661
 662
 663 def match_asterisk(pattern, data):
 664     """Match data against a pattern
 665
 666     The difference to fnmatch is that this function only accepts patterns with a single
 667     asterisk and that it returns a "closeness" number, which is larger the better the match.
 668     Zero indicates no match at all.
 669     """
 670     if "*" not in pattern:
 671         return 1 if pattern == data else 0
 672     parts = pattern.split("*")
 673     if len(parts) > 2:
 674         raise ValueError("Only patterns with a single asterisk are supported, %s is invalid" % pattern)
 675     if not data.startswith(parts[0]):
 676         return 0
 677     if not data.endswith(parts[1]):
 678         return 0
 679     matched = len(pattern)
 680     total = len(data) + 1
 681     return matched * 1. / total
 682
 683
 684 def update_profiles_edid(profiles, config):
 685     fp_map = {}
 686     for c in config:
 687         if config[c].fingerprint is not None:
 688             fp_map[config[c].fingerprint] = c
 689
 690     for p in profiles:
 691         profile_config = profiles[p]["config"]
 692
 693         for fingerprint in fp_map:
 694             for c in list(profile_config.keys()):
 695                 if profile_config[c].fingerprint != fingerprint or c == fp_map[fingerprint]:
 696                     continue
 697
 698                 print("%s: renaming display %s to %s" % (p, c, fp_map[fingerprint]))
 699
 700                 tmp_disp = profile_config[c]
 701
 702                 if fp_map[fingerprint] in profile_config:
 703                     # Swap the two entries
 704                     profile_config[c] = profile_config[fp_map[fingerprint]]
 705                     profile_config[c].output = c
 706                 else:
 707                     # Object is reassigned to another key, drop this one
 708                     del profile_config[c]
 709
 710                 profile_config[fp_map[fingerprint]] = tmp_disp
 711                 profile_config[fp_map[fingerprint]].output = fp_map[fingerprint]
 712
 713
 714 def find_profiles(current_config, profiles):
 715     "Find profiles matching the currently connected outputs, sorting asterisk matches to the back"
 716     detected_profiles = []
 717     for profile_name, profile in profiles.items():
 718         config = profile["config"]
 719         matches = True
 720         for name, output in config.items():
 721             if not output.fingerprint:
 722                 continue
 723             if name not in current_config or not output.fingerprint_equals(current_config[name]):
 724                 matches = False
 725                 break
 726         if not matches or any((name not in config.keys() for name in current_config.keys() if current_config[name].fingerprint)):
 727             continue
 728         if matches:
 729             closeness = max(match_asterisk(output.edid, current_config[name].edid), match_asterisk(
 730                 current_config[name].edid, output.edid))
 731             detected_profiles.append((closeness, profile_name))
 732     detected_profiles = [o[1] for o in sorted(detected_profiles, key=lambda x: -x[0])]
 733     return detected_profiles
 734
 735
 736 def profile_blocked(profile_path, meta_information=None):
 737     """Check if a profile is blocked.
 738
 739     meta_information is expected to be an dictionary. It will be passed to the block scripts
 740     in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
 741     """
 742     return not exec_scripts(profile_path, "block", meta_information)
 743
 744
 745 def check_configuration_pre_save(configuration):
 746     "Check that a configuration is safe for saving."
 747     outputs = sorted(configuration.keys(), key=lambda x: configuration[x].sort_key)
 748     for output in outputs:
 749         if "off" not in configuration[output].options and not configuration[output].edid:
 750             return ("`%(o)s' is not off (has a mode configured) but is disconnected (does not have an EDID).\n"
 751                     "This typically means that it has been recently unplugged and then not properly disabled\n"
 752                     "by the user. Please disable it (e.g. using `xrandr --output %(o)s --off`) and then rerun\n"
 753                     "this command.") % {"o": output}
 754
 755
 756 def output_configuration(configuration, config):
 757     "Write a configuration file"
 758     outputs = sorted(configuration.keys(), key=lambda x: configuration[x].sort_key)
 759     for output in outputs:
 760         print(configuration[output].option_string, file=config)
 761
 762
 763 def output_setup(configuration, setup):
 764     "Write a setup (fingerprint) file"
 765     outputs = sorted(configuration.keys())
 766     for output in outputs:
 767         if configuration[output].edid:
 768             print(output, configuration[output].edid, file=setup)
 769
 770
 771 def save_configuration(profile_path, profile_name, configuration, forced=False):
 772     "Save a configuration into a profile"
 773     if not os.path.isdir(profile_path):
 774         os.makedirs(profile_path)
 775     config_path = os.path.join(profile_path, "config")
 776     setup_path = os.path.join(profile_path, "setup")
 777     if os.path.isfile(config_path) and not forced:
 778         raise AutorandrException('Refusing to overwrite config "{}" without passing "--force"!'.format(profile_name))
 779     if os.path.isfile(setup_path) and not forced:
 780         raise AutorandrException('Refusing to overwrite config "{}" without passing "--force"!'.format(profile_name))
 781
 782     with open(config_path, "w") as config:
 783         output_configuration(configuration, config)
 784     with open(setup_path, "w") as setup:
 785         output_setup(configuration, setup)
 786
 787
 788 def update_mtime(filename):
 789     "Update a file's mtime"
 790     try:
 791         os.utime(filename, None)
 792         return True
 793     except:
 794         return False
 795
 796
 797 def call_and_retry(*args, **kwargs):
 798     """Wrapper around subprocess.call that retries failed calls.
 799
 800     This function calls subprocess.call and on non-zero exit states,
 801     waits a second and then retries once. This mitigates #47,
 802     a timing issue with some drivers.
 803     """
 804     if kwargs.pop("dry_run", False):
 805         for arg in args[0]:
 806             print(shlex.quote(arg), end=" ")
 807         print()
 808         return 0
 809     else:
 810         if hasattr(subprocess, "DEVNULL"):
 811             kwargs["stdout"] = getattr(subprocess, "DEVNULL")
 812         else:
 813             kwargs["stdout"] = open(os.devnull, "w")
 814         kwargs["stderr"] = kwargs["stdout"]
 815         retval = subprocess.call(*args, **kwargs)
 816         if retval != 0:
 817             time.sleep(1)
 818             retval = subprocess.call(*args, **kwargs)
 819         return retval
 820
 821
 822 def get_fb_dimensions(configuration):
 823     width = 0
 824     height = 0
 825     for output in configuration.values():
 826         if "off" in output.options or not output.edid:
 827             continue
 828         # This won't work with all modes -- but it's a best effort.
 829         match = re.search("[0-9]{3,}x[0-9]{3,}", output.options["mode"])
 830         if not match:
 831             return None
 832         o_mode = match.group(0)
 833         o_width, o_height = map(int, o_mode.split("x"))
 834         if "transform" in output.options:
 835             a, b, c, d, e, f, g, h, i = map(float, output.options["transform"].split(","))
 836             w = (g * o_width + h * o_height + i)
 837             x = (a * o_width + b * o_height + c) / w
 838             y = (d * o_width + e * o_height + f) / w
 839             o_width, o_height = x, y
 840         if "rotate" in output.options:
 841             if output.options["rotate"] in ("left", "right"):
 842                 o_width, o_height = o_height, o_width
 843         if "pos" in output.options:
 844             o_left, o_top = map(int, output.options["pos"].split("x"))
 845             o_width += o_left
 846             o_height += o_top
 847         if "panning" in output.options:
 848             match = re.match("(?P<w>[0-9]+)x(?P<h>[0-9]+)(?:\+(?P<x>[0-9]+))?(?:\+(?P<y>[0-9]+))?.*", output.options["panning"])
 849             if match:
 850                 detail = match.groupdict(default="0")
 851                 o_width = int(detail.get("w")) + int(detail.get("x"))
 852                 o_height = int(detail.get("h")) + int(detail.get("y"))
 853         width = max(width, o_width)
 854         height = max(height, o_height)
 855     return int(width), int(height)
 856
 857
 858 def apply_configuration(new_configuration, current_configuration, dry_run=False):
 859     "Apply a configuration"
 860     found_top_left_monitor = False
 861     found_left_monitor = False
 862     found_top_monitor = False
 863     outputs = sorted(new_configuration.keys(), key=lambda x: new_configuration[x].sort_key)
 864     base_argv = ["xrandr"]
 865
 866     # There are several xrandr / driver bugs we need to take care of here:
 867     # - We cannot enable more than two screens at the same time
 868     #   See https://github.com/phillipberndt/autorandr/pull/6
 869     #   and commits f4cce4d and 8429886.
 870     # - We cannot disable all screens
 871     #   See https://github.com/phillipberndt/autorandr/pull/20
 872     # - We should disable screens before enabling others, because there's
 873     #   a limit on the number of enabled screens
 874     # - We must make sure that the screen at 0x0 is activated first,
 875     #   or the other (first) screen to be activated would be moved there.
 876     # - If an active screen already has a transformation and remains active,
 877     #   the xrandr call fails with an invalid RRSetScreenSize parameter error.
 878     #   Update the configuration in 3 passes in that case.  (On Haswell graphics,
 879     #   at least.)
 880     # - Some implementations can not handle --transform at all, so avoid it unless
 881     #   necessary. (See https://github.com/phillipberndt/autorandr/issues/37)
 882     # - Some implementations can not handle --panning without specifying --fb
 883     #   explicitly, so avoid it unless necessary.
 884     #   (See https://github.com/phillipberndt/autorandr/issues/72)
 885
 886     fb_dimensions = get_fb_dimensions(new_configuration)
 887     try:
 888         base_argv += ["--fb", "%dx%d" % fb_dimensions]
 889     except:
 890         # Failed to obtain frame-buffer size. Doesn't matter, xrandr will choose for the user.
 891         pass
 892
 893     auxiliary_changes_pre = []
 894     disable_outputs = []
 895     enable_outputs = []
 896     remain_active_count = 0
 897     for output in outputs:
 898         if not new_configuration[output].edid or "off" in new_configuration[output].options:
 899             disable_outputs.append(new_configuration[output].option_vector)
 900         else:
 901             if output not in current_configuration:
 902                 raise AutorandrException("New profile configures output %s which does not exist in current xrandr --verbose output. "
 903                                          "Don't know how to proceed." % output)
 904             if "off" not in current_configuration[output].options:
 905                 remain_active_count += 1
 906
 907             option_vector = new_configuration[output].option_vector
 908             if xrandr_version() >= Version("1.3.0"):
 909                 for option, off_value in (("transform", "none"), ("panning", "0x0")):
 910                     if option in current_configuration[output].options:
 911                         auxiliary_changes_pre.append(["--output", output, "--%s" % option, off_value])
 912                     else:
 913                         try:
 914                             option_index = option_vector.index("--%s" % option)
 915                             if option_vector[option_index + 1] == XrandrOutput.XRANDR_DEFAULTS[option]:
 916                                 option_vector = option_vector[:option_index] + option_vector[option_index + 2:]
 917                         except ValueError:
 918                             pass
 919             if not found_top_left_monitor:
 920                 position = new_configuration[output].options.get("pos", "0x0")
 921                 if position == "0x0":
 922                     found_top_left_monitor = True
 923                     enable_outputs.insert(0, option_vector)
 924                 elif not found_left_monitor and position.startswith("0x"):
 925                     found_left_monitor = True
 926                     enable_outputs.insert(0, option_vector)
 927                 elif not found_top_monitor and position.endswith("x0"):
 928                     found_top_monitor = True
 929                     enable_outputs.insert(0, option_vector)
 930                 else:
 931                     enable_outputs.append(option_vector)
 932             else:
 933                 enable_outputs.append(option_vector)
 934
 935     # Perform pe-change auxiliary changes
 936     if auxiliary_changes_pre:
 937         argv = base_argv + list(chain.from_iterable(auxiliary_changes_pre))
 938         if call_and_retry(argv, dry_run=dry_run) != 0:
 939             raise AutorandrException("Command failed: %s" % " ".join(argv))
 940
 941     # Disable unused outputs, but make sure that there always is at least one active screen
 942     disable_keep = 0 if remain_active_count else 1
 943     if len(disable_outputs) > disable_keep:
 944         argv = base_argv + list(chain.from_iterable(disable_outputs[:-1] if disable_keep else disable_outputs))
 945         if call_and_retry(argv, dry_run=dry_run) != 0:
 946             # Disabling the outputs failed. Retry with the next command:
 947             # Sometimes disabling of outputs fails due to an invalid RRSetScreenSize.
 948             # This does not occur if simultaneously the primary screen is reset.
 949             pass
 950         else:
 951             disable_outputs = disable_outputs[-1:] if disable_keep else []
 952
 953     # If disable_outputs still has more than one output in it, one of the xrandr-calls below would
 954     # disable the last two screens. This is a problem, so if this would happen, instead disable only
 955     # one screen in the first call below.
 956     if len(disable_outputs) > 0 and len(disable_outputs) % 2 == 0:
 957         # In the context of a xrandr call that changes the display state, `--query' should do nothing
 958         disable_outputs.insert(0, ['--query'])
 959
 960     # If we did not find a candidate, we might need to inject a call
 961     # If there is no output to disable, we will enable 0x and x0 at the same time
 962     if not found_top_left_monitor and len(disable_outputs) > 0:
 963         # If the call to 0x and x0 is splitted, inject one of them
 964         if found_top_monitor and found_left_monitor:
 965             enable_outputs.insert(0, enable_outputs[0])
 966
 967     # Enable the remaining outputs in pairs of two operations
 968     operations = disable_outputs + enable_outputs
 969     for index in range(0, len(operations), 2):
 970         argv = base_argv + list(chain.from_iterable(operations[index:index + 2]))
 971         if call_and_retry(argv, dry_run=dry_run) != 0:
 972             raise AutorandrException("Command failed: %s" % " ".join(argv))
 973
 974
 975 def is_equal_configuration(source_configuration, target_configuration):
 976     """
 977         Check if all outputs from target are already configured correctly in source and
 978         that no other outputs are active.
 979     """
 980     for output in target_configuration.keys():
 981         if "off" in target_configuration[output].options:
 982             if (output in source_configuration and "off" not in source_configuration[output].options):
 983                 return False
 984         else:
 985             if (output not in source_configuration) or (source_configuration[output] != target_configuration[output]):
 986                 return False
 987     for output in source_configuration.keys():
 988         if "off" in source_configuration[output].options:
 989             if output in target_configuration and "off" not in target_configuration[output].options:
 990                 return False
 991         else:
 992             if output not in target_configuration:
 993                 return False
 994     return True
 995
 996
 997 def add_unused_outputs(source_configuration, target_configuration):
 998     "Add outputs that are missing in target to target, in 'off' state"
 999     for output_name, output in source_configuration.items():
1000         if output_name not in target_configuration:
1001             target_configuration[output_name] = XrandrOutput(output_name, output.edid, {"off": None})
1002
1003
1004 def remove_irrelevant_outputs(source_configuration, target_configuration):
1005     "Remove outputs from target that ought to be 'off' and already are"
1006     for output_name, output in source_configuration.items():
1007         if "off" in output.options:
1008             if output_name in target_configuration:
1009                 if "off" in target_configuration[output_name].options:
1010                     del target_configuration[output_name]
1011
1012
1013 def generate_virtual_profile(configuration, modes, profile_name):
1014     "Generate one of the virtual profiles"
1015     configuration = copy.deepcopy(configuration)
1016     if profile_name == "common":
1017         mode_sets = []
1018         for output, output_modes in modes.items():
1019             mode_set = set()
1020             if configuration[output].edid:
1021                 for mode in output_modes:
1022                     mode_set.add((mode["width"], mode["height"]))
1023             mode_sets.append(mode_set)
1024         common_resolution = reduce(lambda a, b: a & b, mode_sets[1:], mode_sets[0])
1025         common_resolution = sorted(common_resolution, key=lambda a: int(a[0]) * int(a[1]))
1026         if common_resolution:
1027             for output in configuration:
1028                 configuration[output].options = {}
1029                 if output in modes and configuration[output].edid:
1030                     modes_sorted = sorted(modes[output], key=lambda x: 0 if x["preferred"] else 1)
1031                     modes_filtered = [x for x in modes_sorted if (x["width"], x["height"]) == common_resolution[-1]]
1032                     mode = modes_filtered[0]
1033                     configuration[output].options["mode"] = mode['name']
1034                     configuration[output].options["pos"] = "0x0"
1035                 else:
1036                     configuration[output].options["off"] = None
1037     elif profile_name in ("horizontal", "vertical"):
1038         shift = 0
1039         if profile_name == "horizontal":
1040             shift_index = "width"
1041             pos_specifier = "%sx0"
1042         else:
1043             shift_index = "height"
1044             pos_specifier = "0x%s"
1045
1046         for output in configuration:
1047             configuration[output].options = {}
1048             if output in modes and configuration[output].edid:
1049                 def key(a):
1050                     score = int(a["width"]) * int(a["height"])
1051                     if a["preferred"]:
1052                         score += 10**6
1053                     return score
1054                 output_modes = sorted(modes[output], key=key)
1055                 mode = output_modes[-1]
1056                 configuration[output].options["mode"] = mode["name"]
1057                 configuration[output].options["rate"] = mode["rate"]
1058                 configuration[output].options["pos"] = pos_specifier % shift
1059                 shift += int(mode[shift_index])
1060             else:
1061                 configuration[output].options["off"] = None
1062     elif profile_name == "clone-largest":
1063         modes_unsorted = [output_modes[0] for output, output_modes in modes.items()]
1064         modes_sorted = sorted(modes_unsorted, key=lambda x: int(x["width"]) * int(x["height"]), reverse=True)
1065         biggest_resolution = modes_sorted[0]
1066         for output in configuration:
1067             configuration[output].options = {}
1068             if output in modes and configuration[output].edid:
1069                 def key(a):
1070                     score = int(a["width"]) * int(a["height"])
1071                     if a["preferred"]:
1072                         score += 10**6
1073                     return score
1074                 output_modes = sorted(modes[output], key=key)
1075                 mode = output_modes[-1]
1076                 configuration[output].options["mode"] = mode["name"]
1077                 configuration[output].options["rate"] = mode["rate"]
1078                 configuration[output].options["pos"] = "0x0"
1079                 scale = max(float(biggest_resolution["width"]) / float(mode["width"]),
1080                             float(biggest_resolution["height"]) / float(mode["height"]))
1081                 mov_x = (float(mode["width"]) * scale - float(biggest_resolution["width"])) / -2
1082                 mov_y = (float(mode["height"]) * scale - float(biggest_resolution["height"])) / -2
1083                 configuration[output].options["transform"] = "{},0,{},0,{},{},0,0,1".format(scale, mov_x, scale, mov_y)
1084             else:
1085                 configuration[output].options["off"] = None
1086     elif profile_name == "off":
1087         for output in configuration:
1088             for key in list(configuration[output].options.keys()):
1089                 del configuration[output].options[key]
1090             configuration[output].options["off"] = None
1091     return configuration
1092
1093
1094 def print_profile_differences(one, another):
1095     "Print the differences between two profiles for debugging"
1096     if one == another:
1097         return
1098     print("| Differences between the two profiles:")
1099     for output in set(chain.from_iterable((one.keys(), another.keys()))):
1100         if output not in one:
1101             if "off" not in another[output].options:
1102                 print("| Output `%s' is missing from the active configuration" % output)
1103         elif output not in another:
1104             if "off" not in one[output].options:
1105                 print("| Output `%s' is missing from the new configuration" % output)
1106         else:
1107             for line in one[output].verbose_diff(another[output]):
1108                 print("| [Output %s] %s" % (output, line))
1109     print("\\-")
1110
1111
1112 def exit_help():
1113     "Print help and exit"
1114     print(help_text)
1115     for profile in virtual_profiles:
1116         name, description = profile[:2]
1117         description = [description]
1118         max_width = 78 - 18
1119         while len(description[0]) > max_width + 1:
1120             left_over = description[0][max_width:]
1121             description[0] = description[0][:max_width] + "-"
1122             description.insert(1, "  %-15s %s" % ("", left_over))
1123         description = "\n".join(description)
1124         print("  %-15s %s" % (name, description))
1125     sys.exit(0)
1126
1127
1128 def exec_scripts(profile_path, script_name, meta_information=None):
1129     """"Run userscripts
1130
1131     This will run all executables from the profile folder, and global per-user
1132     and system-wide configuration folders, named script_name or residing in
1133     subdirectories named script_name.d.
1134
1135     If profile_path is None, only global scripts will be invoked.
1136
1137     meta_information is expected to be an dictionary. It will be passed to the block scripts
1138     in the environment, as variables called AUTORANDR_<CAPITALIZED_KEY_HERE>.
1139
1140     Returns True unless any of the scripts exited with non-zero exit status.
1141     """
1142     all_ok = True
1143     env = os.environ.copy()
1144     if meta_information:
1145         for key, value in meta_information.items():
1146             env["AUTORANDR_{}".format(key.upper())] = str(value)
1147
1148     # If there are multiple candidates, the XDG spec tells to only use the first one.
1149     ran_scripts = set()
1150
1151     user_profile_path = os.path.expanduser("~/.autorandr")
1152     if not os.path.isdir(user_profile_path):
1153         user_profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
1154
1155     candidate_directories = []
1156     if profile_path:
1157         candidate_directories.append(profile_path)
1158     candidate_directories.append(user_profile_path)
1159     for config_dir in os.environ.get("XDG_CONFIG_DIRS", "/etc/xdg").split(":"):
1160         candidate_directories.append(os.path.join(config_dir, "autorandr"))
1161
1162     for folder in candidate_directories:
1163         if script_name not in ran_scripts:
1164             script = os.path.join(folder, script_name)
1165             if os.access(script, os.X_OK | os.F_OK):
1166                 try:
1167                     all_ok &= subprocess.call(script, env=env) != 0
1168                 except:
1169                     raise AutorandrException("Failed to execute user command: %s" % (script,))
1170                 ran_scripts.add(script_name)
1171
1172         script_folder = os.path.join(folder, "%s.d" % script_name)
1173         if os.access(script_folder, os.R_OK | os.X_OK) and os.path.isdir(script_folder):
1174             for file_name in os.listdir(script_folder):
1175                 check_name = "d/%s" % (file_name,)
1176                 if check_name not in ran_scripts:
1177                     script = os.path.join(script_folder, file_name)
1178                     if os.access(script, os.X_OK | os.F_OK):
1179                         try:
1180                             all_ok &= subprocess.call(script, env=env) != 0
1181                         except:
1182                             raise AutorandrException("Failed to execute user command: %s" % (script,))
1183                         ran_scripts.add(check_name)
1184
1185     return all_ok
1186
1187
1188 def dispatch_call_to_sessions(argv):
1189     """Invoke autorandr for each open local X11 session with the given options.
1190
1191     The function iterates over all processes not owned by root and checks
1192     whether they have DISPLAY and XAUTHORITY variables set. It strips the
1193     screen from any variable it finds (i.e. :0.0 becomes :0) and checks whether
1194     this display has been handled already. If it has not, it forks, changes
1195     uid/gid to the user owning the process, reuses the process's environment
1196     and runs autorandr with the parameters from argv.
1197
1198     This function requires root permissions. It only works for X11 servers that
1199     have at least one non-root process running. It is susceptible for attacks
1200     where one user runs a process with another user's DISPLAY variable - in
1201     this case, it might happen that autorandr is invoked for the other user,
1202     which won't work. Since no other harm than prevention of automated
1203     execution of autorandr can be done this way, the assumption is that in this
1204     situation, the local administrator will handle the situation."""
1205
1206     X11_displays_done = set()
1207
1208     autorandr_binary = os.path.abspath(argv[0])
1209     backup_candidates = {}
1210
1211     def fork_child_autorandr(pwent, process_environ):
1212         print("Running autorandr as %s for display %s" % (pwent.pw_name, process_environ["DISPLAY"]))
1213         child_pid = os.fork()
1214         if child_pid == 0:
1215             # This will throw an exception if any of the privilege changes fails,
1216             # so it should be safe. Also, note that since the environment
1217             # is taken from a process owned by the user, reusing it should
1218             # not leak any information.
1219             try:
1220                 os.setgroups(os.getgrouplist(pwent.pw_name, pwent.pw_gid))
1221             except AttributeError:
1222                 # Python 2 doesn't have getgrouplist
1223                 os.setgroups([])
1224             os.setresgid(pwent.pw_gid, pwent.pw_gid, pwent.pw_gid)
1225             os.setresuid(pwent.pw_uid, pwent.pw_uid, pwent.pw_uid)
1226             os.chdir(pwent.pw_dir)
1227             os.environ.clear()
1228             os.environ.update(process_environ)
1229             if sys.executable != "" and sys.executable != None:
1230                 os.execl(sys.executable, sys.executable, autorandr_binary, *argv[1:])
1231             else:
1232                 os.execl(autorandr_binary, autorandr_binary, *argv[1:])
1233             sys.exit(1)
1234         os.waitpid(child_pid, 0)
1235
1236     # The following line assumes that user accounts start at 1000 and that no
1237     # one works using the root or another system account. This is rather
1238     # restrictive, but de facto default. If this breaks your use case, set the
1239     # env var AUTORANDR_UID_MIN as appropriate. (Alternatives would be to use
1240     # the UID_MIN from /etc/login.defs or FIRST_UID from /etc/adduser.conf; but
1241     # effectively, both values aren't binding in any way.)
1242     uid_min = 1000
1243     if 'AUTORANDR_UID_MIN' in os.environ:
1244       uid_min = int(os.environ['AUTORANDR_UID_MIN'])
1245
1246     for directory in os.listdir("/proc"):
1247         directory = os.path.join("/proc/", directory)
1248         if not os.path.isdir(directory):
1249             continue
1250         environ_file = os.path.join(directory, "environ")
1251         if not os.path.isfile(environ_file):
1252             continue
1253         uid = os.stat(environ_file).st_uid
1254
1255         if uid < uid_min:
1256             continue
1257
1258         process_environ = {}
1259         for environ_entry in open(environ_file, 'rb').read().split(b"\0"):
1260             try:
1261                 environ_entry = environ_entry.decode("ascii")
1262             except UnicodeDecodeError:
1263                 continue
1264             name, sep, value = environ_entry.partition("=")
1265             if name and sep:
1266                 if name == "DISPLAY" and "." in value:
1267                     value = value[:value.find(".")]
1268                 process_environ[name] = value
1269
1270         if "DISPLAY" not in process_environ:
1271             # Cannot work with this environment, skip.
1272             continue
1273
1274         # To allow scripts to detect batch invocation (especially useful for predetect)
1275         process_environ["AUTORANDR_BATCH_PID"] = str(os.getpid())
1276         process_environ["UID"] = str(uid)
1277
1278         display = process_environ["DISPLAY"]
1279
1280         if "XAUTHORITY" not in process_environ:
1281             # It's very likely that we cannot work with this environment either,
1282             # but keep it as a backup just in case we don't find anything else.
1283             backup_candidates[display] = process_environ
1284             continue
1285
1286         if display not in X11_displays_done:
1287             try:
1288                 pwent = pwd.getpwuid(uid)
1289             except KeyError:
1290                 # User has no pwd entry
1291                 continue
1292
1293             fork_child_autorandr(pwent, process_environ)
1294             X11_displays_done.add(display)
1295
1296     # Run autorandr for any users/displays which didn't have a process with
1297     # XAUTHORITY set.
1298     for display, process_environ in backup_candidates.items():
1299         if display not in X11_displays_done:
1300             try:
1301                 pwent = pwd.getpwuid(int(process_environ["UID"]))
1302             except KeyError:
1303                 # User has no pwd entry
1304                 continue
1305
1306             fork_child_autorandr(pwent, process_environ)
1307             X11_displays_done.add(display)
1308
1309
1310 def enabled_monitors(config):
1311     monitors = []
1312     for monitor in config:
1313         if "--off" in config[monitor].option_vector:
1314             continue
1315         monitors.append(monitor)
1316     return monitors
1317
1318
1319 def read_config(options, directory):
1320     """Parse a configuration config.ini from directory and merge it into
1321     the options dictionary"""
1322     config = configparser.ConfigParser()
1323     config.read(os.path.join(directory, "settings.ini"))
1324     if config.has_section("config"):
1325         for key, value in config.items("config"):
1326             options.setdefault("--%s" % key, value)
1327
1328 def main(argv):
1329     try:
1330         opts, args = getopt.getopt(
1331             argv[1:],
1332             "s:r:l:d:cfh",
1333             [
1334                 "batch",
1335                 "dry-run",
1336                 "change",
1337                 "cycle",
1338                 "default=",
1339                 "save=",
1340                 "remove=",
1341                 "load=",
1342                 "force",
1343                 "fingerprint",
1344                 "config",
1345                 "debug",
1346                 "skip-options=",
1347                 "help",
1348                 "list",
1349                 "current",
1350                 "detected",
1351                 "version",
1352                 "match-edid",
1353                 "ignore-lid"
1354             ]
1355         )
1356     except getopt.GetoptError as e:
1357         print("Failed to parse options: {0}.\n"
1358               "Use --help to get usage information.".format(str(e)),
1359               file=sys.stderr)
1360         sys.exit(posix.EX_USAGE)
1361
1362     options = dict(opts)
1363
1364     if "-h" in options or "--help" in options:
1365         exit_help()
1366
1367     if "--version" in options:
1368         print("autorandr " + __version__)
1369         sys.exit(0)
1370
1371     if "--current" in options and "--detected" in options:
1372         print("--current and --detected are mutually exclusive.", file=sys.stderr)
1373         sys.exit(posix.EX_USAGE)
1374
1375     # Batch mode
1376     if "--batch" in options:
1377         if ("DISPLAY" not in os.environ or not os.environ["DISPLAY"]) and os.getuid() == 0:
1378             dispatch_call_to_sessions([x for x in argv if x != "--batch"])
1379         else:
1380             print("--batch mode can only be used by root and if $DISPLAY is unset")
1381         return
1382     if "AUTORANDR_BATCH_PID" in os.environ:
1383         user = pwd.getpwuid(os.getuid())
1384         user = user.pw_name if user else "#%d" % os.getuid()
1385         print("autorandr running as user %s (started from batch instance)" % user)
1386
1387     profiles = {}
1388     profile_symlinks = {}
1389     try:
1390         # Load profiles from each XDG config directory
1391         # The XDG spec says that earlier entries should take precedence, so reverse the order
1392         for directory in reversed(os.environ.get("XDG_CONFIG_DIRS", "/etc/xdg").split(":")):
1393             system_profile_path = os.path.join(directory, "autorandr")
1394             if os.path.isdir(system_profile_path):
1395                 profiles.update(load_profiles(system_profile_path))
1396                 profile_symlinks.update(get_symlinks(system_profile_path))
1397                 read_config(options, system_profile_path)
1398         # For the user's profiles, prefer the legacy ~/.autorandr if it already exists
1399         # profile_path is also used later on to store configurations
1400         profile_path = os.path.expanduser("~/.autorandr")
1401         if not os.path.isdir(profile_path):
1402             # Elsewise, follow the XDG specification
1403             profile_path = os.path.join(os.environ.get("XDG_CONFIG_HOME", os.path.expanduser("~/.config")), "autorandr")
1404         if os.path.isdir(profile_path):
1405             profiles.update(load_profiles(profile_path))
1406             profile_symlinks.update(get_symlinks(profile_path))
1407             read_config(options, profile_path)
1408     except Exception as e:
1409         raise AutorandrException("Failed to load profiles", e)
1410
1411     exec_scripts(None, "predetect")
1412
1413     ignore_lid = "--ignore-lid" in options
1414
1415     config, modes = parse_xrandr_output(
1416         ignore_lid=ignore_lid,
1417     )
1418
1419     if "--match-edid" in options:
1420         update_profiles_edid(profiles, config)
1421
1422     # Sort by mtime
1423     sort_direction = -1
1424     if "--cycle" in options:
1425         # When cycling through profiles, put the profile least recently used to the top of the list
1426         sort_direction = 1
1427     profiles = OrderedDict(sorted(profiles.items(), key=lambda x: sort_direction * x[1]["config-mtime"]))
1428     profile_symlinks = {k: v for k, v in profile_symlinks.items() if v in (x[0] for x in virtual_profiles) or v in profiles}
1429
1430     if "--fingerprint" in options:
1431         output_setup(config, sys.stdout)
1432         sys.exit(0)
1433
1434     if "--config" in options:
1435         output_configuration(config, sys.stdout)
1436         sys.exit(0)
1437
1438     if "--skip-options" in options:
1439         skip_options = [y[2:] if y[:2] == "--" else y for y in (x.strip() for x in options["--skip-options"].split(","))]
1440         for profile in profiles.values():
1441             for output in profile["config"].values():
1442                 output.set_ignored_options(skip_options)
1443         for output in config.values():
1444             output.set_ignored_options(skip_options)
1445
1446     if "-s" in options:
1447         options["--save"] = options["-s"]
1448     if "--save" in options:
1449         if options["--save"] in (x[0] for x in virtual_profiles):
1450             raise AutorandrException("Cannot save current configuration as profile '%s':\n"
1451                                      "This configuration name is a reserved virtual configuration." % options["--save"])
1452         error = check_configuration_pre_save(config)
1453         if error:
1454             print("Cannot save current configuration as profile '%s':" % options["--save"])
1455             print(error)
1456             sys.exit(1)
1457         try:
1458             profile_folder = os.path.join(profile_path, options["--save"])
1459             save_configuration(profile_folder, options['--save'], config, forced="--force" in options)
1460             exec_scripts(profile_folder, "postsave", {
1461                 "CURRENT_PROFILE": options["--save"],
1462                 "PROFILE_FOLDER": profile_folder,
1463                 "MONITORS": ":".join(enabled_monitors(config)),
1464             })
1465         except AutorandrException as e:
1466             raise e
1467         except Exception as e:
1468             raise AutorandrException("Failed to save current configuration as profile '%s'" % (options["--save"],), e)
1469         print("Saved current configuration as profile '%s'" % options["--save"])
1470         sys.exit(0)
1471
1472     if "-r" in options:
1473         options["--remove"] = options["-r"]
1474     if "--remove" in options:
1475         if options["--remove"] in (x[0] for x in virtual_profiles):
1476             raise AutorandrException("Cannot remove profile '%s':\n"
1477                                      "This configuration name is a reserved virtual configuration." % options["--remove"])
1478         if options["--remove"] not in profiles.keys():
1479             raise AutorandrException("Cannot remove profile '%s':\n"
1480                                      "This profile does not exist." % options["--remove"])
1481         try:
1482             remove = True
1483             profile_folder = os.path.join(profile_path, options["--remove"])
1484             profile_dirlist = os.listdir(profile_folder)
1485             profile_dirlist.remove("config")
1486             profile_dirlist.remove("setup")
1487             if profile_dirlist:
1488                 print("Profile folder '%s' contains the following additional files:\n"
1489                       "---\n%s\n---" % (options["--remove"], "\n".join(profile_dirlist)))
1490                 response = input("Do you really want to remove profile '%s'? If so, type 'yes': " % options["--remove"]).strip()
1491                 if response != "yes":
1492                     remove = False
1493             if remove is True:
1494                 shutil.rmtree(profile_folder)
1495                 print("Removed profile '%s'" % options["--remove"])
1496             else:
1497                 print("Profile '%s' was not removed" % options["--remove"])
1498         except Exception as e:
1499             raise AutorandrException("Failed to remove profile '%s'" % (options["--remove"],), e)
1500         sys.exit(0)
1501
1502     detected_profiles = find_profiles(config, profiles)
1503     load_profile = False
1504
1505     if "-l" in options:
1506         options["--load"] = options["-l"]
1507     if "--load" in options:
1508         load_profile = options["--load"]
1509     elif len(args) == 1:
1510         load_profile = args[0]
1511     else:
1512         # Find the active profile(s) first, for the block script (See #42)
1513         current_profiles = []
1514         for profile_name in profiles.keys():
1515             configs_are_equal = is_equal_configuration(config, profiles[profile_name]["config"])
1516             if configs_are_equal:
1517                 current_profiles.append(profile_name)
1518         block_script_metadata = {
1519             "CURRENT_PROFILE": "".join(current_profiles[:1]),
1520             "CURRENT_PROFILES": ":".join(current_profiles)
1521         }
1522
1523         best_index = 9999
1524         for profile_name in profiles.keys():
1525             if profile_blocked(os.path.join(profile_path, profile_name), block_script_metadata):
1526                 if not any(opt in options for opt in ("--current", "--detected", "--list")):
1527                     print("%s (blocked)" % profile_name)
1528                 continue
1529             props = []
1530             is_current_profile = profile_name in current_profiles
1531             if profile_name in detected_profiles:
1532                 if len(detected_profiles) == 1:
1533                     index = 1
1534                     props.append("(detected)")
1535                 else:
1536                     index = detected_profiles.index(profile_name) + 1
1537                     props.append("(detected) (%d%s match)" % (index, ["st", "nd", "rd"][index - 1] if index < 4 else "th"))
1538                 if index < best_index:
1539                     if "-c" in options or "--change" in options or ("--cycle" in options and not is_current_profile):
1540                         load_profile = profile_name
1541                         best_index = index
1542             elif "--detected" in options:
1543                 continue
1544             if is_current_profile:
1545                 props.append("(current)")
1546             elif "--current" in options:
1547                 continue
1548             if any(opt in options for opt in ("--current", "--detected", "--list")):
1549                 print("%s" % (profile_name, ))
1550             else:
1551                 print("%s%s%s" % (profile_name, " " if props else "", " ".join(props)))
1552             if not configs_are_equal and "--debug" in options and profile_name in detected_profiles:
1553                 print_profile_differences(config, profiles[profile_name]["config"])
1554
1555     if "-d" in options:
1556         options["--default"] = options["-d"]
1557     if not load_profile and "--default" in options and ("-c" in options or "--change" in options or "--cycle" in options):
1558         load_profile = options["--default"]
1559
1560     if load_profile:
1561         if load_profile in profile_symlinks:
1562             if "--debug" in options:
1563                 print("'%s' symlinked to '%s'" % (load_profile, profile_symlinks[load_profile]))
1564             load_profile = profile_symlinks[load_profile]
1565
1566         if load_profile in (x[0] for x in virtual_profiles):
1567             load_config = generate_virtual_profile(config, modes, load_profile)
1568             scripts_path = os.path.join(profile_path, load_profile)
1569         else:
1570             try:
1571                 profile = profiles[load_profile]
1572                 load_config = profile["config"]
1573                 scripts_path = profile["path"]
1574             except KeyError:
1575                 raise AutorandrException("Failed to load profile '%s': Profile not found" % load_profile)
1576             if "--dry-run" not in options:
1577                 update_mtime(os.path.join(scripts_path, "config"))
1578         add_unused_outputs(config, load_config)
1579         if load_config == dict(config) and "-f" not in options and "--force" not in options:
1580             print("Config already loaded", file=sys.stderr)
1581             sys.exit(0)
1582         if "--debug" in options and load_config != dict(config):
1583             print("Loading profile '%s'" % load_profile)
1584             print_profile_differences(config, load_config)
1585
1586         remove_irrelevant_outputs(config, load_config)
1587
1588         try:
1589             if "--dry-run" in options:
1590                 apply_configuration(load_config, config, True)
1591             else:
1592                 script_metadata = {
1593                     "CURRENT_PROFILE": load_profile,
1594                     "PROFILE_FOLDER": scripts_path,
1595                     "MONITORS": ":".join(enabled_monitors(load_config)),
1596                 }
1597                 exec_scripts(scripts_path, "preswitch", script_metadata)
1598                 if "--debug" in options:
1599                     print("Going to run:")
1600                     apply_configuration(load_config, config, True)
1601                 apply_configuration(load_config, config, False)
1602                 exec_scripts(scripts_path, "postswitch", script_metadata)
1603         except AutorandrException as e:
1604             raise AutorandrException("Failed to apply profile '%s'" % load_profile, e, e.report_bug)
1605         except Exception as e:
1606             raise AutorandrException("Failed to apply profile '%s'" % load_profile, e, True)
1607
1608         if "--dry-run" not in options and "--debug" in options:
1609             new_config, _ = parse_xrandr_output(
1610                 ignore_lid=ignore_lid,
1611             )
1612             if not is_equal_configuration(new_config, load_config):
1613                 print("The configuration change did not go as expected:")
1614                 print_profile_differences(new_config, load_config)
1615
1616     sys.exit(0)
1617
1618
1619 def exception_handled_main(argv=sys.argv):
1620     try:
1621         main(sys.argv)
1622     except AutorandrException as e:
1623         print(e, file=sys.stderr)
1624         sys.exit(1)
1625     except Exception as e:
1626         if not len(str(e)):  # BdbQuit
1627             print("Exception: {0}".format(e.__class__.__name__))
1628             sys.exit(2)
1629
1630         print("Unhandled exception ({0}). Please report this as a bug at "
1631               "https://github.com/phillipberndt/autorandr/issues.".format(e),
1632               file=sys.stderr)
1633         raise
1634
1635
1636 if __name__ == '__main__':
1637     exception_handled_main()