autorandr.py

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