__  __    __   __  _____      _            _          _____ _          _ _ 
 |  \/  |   \ \ / / |  __ \    (_)          | |        / ____| |        | | |
 | \  / |_ __\ V /  | |__) | __ ___   ____ _| |_ ___  | (___ | |__   ___| | |
 | |\/| | '__|> <   |  ___/ '__| \ \ / / _` | __/ _ \  \___ \| '_ \ / _ \ | |
 | |  | | |_ / . \  | |   | |  | |\ V / (_| | ||  __/  ____) | | | |  __/ | |
 |_|  |_|_(_)_/ \_\ |_|   |_|  |_| \_/ \__,_|\__\___| |_____/|_| |_|\___V 2.1
 if you need WebShell for Seo everyday contact me on Telegram
 Telegram Address : @jackleet
        
        
For_More_Tools: Telegram: @jackleet | Bulk Smtp support mail sender | Business Mail Collector | Mail Bouncer All Mail | Bulk Office Mail Validator | Html Letter private



Upload:

Command:

[email protected]: ~ $
#!/usr/bin/python3
# Copyright (c) 2005-2018 Canonical Ltd
#
# AUTHOR:
# Michael Vogt <[email protected]>
# Balint Reczey <[email protected]>

# This file is part of unattended-upgrades
#
# unattended-upgrades is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License as published
# by the Free Software Foundation; either version 2 of the License, or (at
# your option) any later version.
#
# unattended-upgrades is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with unattended-upgrades; if not, write to the Free Software
# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
#

import atexit
import contextlib
import copy
import datetime
import errno
import email.charset
# workaround LP:2080940, email.errors changes as part of a security
# update in python itself but is lazy loaded so import early to ensure
import email.generator
from enum import Enum
import fcntl
import fnmatch
import gettext
import glob
try:
    import gi
    gi.require_version('Polkit', '1.0')
    from gi.repository import Gio, GLib, Polkit
    HAS_GDBUS = True
except (ImportError, ValueError):
    HAS_GDBUS = False
try:
    from gi.repository.Gio import NetworkMonitor
except ImportError:
    pass
import grp
import inspect
import io
from importlib.abc import Loader
import importlib.util
import locale
import logging
import logging.handlers
import re
import os
import select
import signal
import socket
import string
import subprocess
import sys
import syslog
import threading

try:
    from typing import AbstractSet, cast, DefaultDict, Dict, Iterable, List
    AbstractSet  # pyflakes
    DefaultDict  # pyflakes
    Dict  # pyflakes
    Iterable  # pyflakes
    List  # pyflakes
    from typing import Optional, Set, Tuple, Union
    Optional  # pyflakes
    Set  # pyflakes
    Tuple  # pyflakes
    Union  # pyflakes
except ImportError:
    pass

from collections import defaultdict, namedtuple
from datetime import date
from email.message import Message
from gettext import gettext as _
from io import StringIO
from optparse import (
    OptionParser,
    SUPPRESS_HELP,
)

from subprocess import (
    Popen,
    PIPE,
)
from textwrap import wrap

import apt
import apt_inst
import apt_pkg

import distro_info

# workaround debian #1076097, it's unclear why we get the warning:
# "DeprecationWarning: This process (pid=3710789) is multi-threaded,
#  use of fork() may lead to deadlocks in the child."
# because nothing u-u/pyhton-apt/apt are not using threading but
# this is not useful to our users so supress it.
if not sys.warnoptions:
    import warnings
    warnings.filterwarnings("ignore", category=DeprecationWarning)


# the reboot required flag file used by packages
REBOOT_REQUIRED_FILE = "/var/run/reboot-required"
KEPT_PACKAGES_FILE = "var/lib/unattended-upgrades/kept-back"
MAIL_BINARY = "/usr/bin/mail"
SENDMAIL_BINARY = "/usr/sbin/sendmail"
USERS = "/usr/bin/users"
DBUS_DIR = "/usr/share/dbus-1"
POSTPONE_STAMP_FILE = "unattended-upgrades-postpone-stamp"


# no py3 lsb_release in debian :/
DISTRO_CODENAME = ""  # type: str
DISTRO_DESC = ""  # type: str
DISTRO_ID = ""  # type: str


def init_distro_info():
    global DISTRO_CODENAME, DISTRO_DESC, DISTRO_ID
    DISTRO_CODENAME = subprocess.check_output(
        ["lsb_release", "-c", "-s"], universal_newlines=True).strip()
    DISTRO_DESC = subprocess.check_output(
        ["lsb_release", "-d", "-s"], universal_newlines=True).strip()
    DISTRO_ID = subprocess.check_output(
        ["lsb_release", "-i", "-s"], universal_newlines=True).strip()


# init global distro info
init_distro_info()


# Number of days before release of devel where we enable unattended
# upgrades.
DEVEL_UNTIL_RELEASE = datetime.timedelta(days=21)

# progress information is written here
PROGRESS_LOG = "/var/run/unattended-upgrades.progress"
PID_FILE = "/var/run/unattended-upgrades.pid"
LOCK_FILE = "/var/run/unattended-upgrades.lock"

# set from the sigint signal handler
SIGNAL_STOP_REQUEST = False

# messages to be logged only once
logged_msgs = set()  # type: AbstractSet[str]

NEVER_PIN = -32768


class LoggingDateTime:
    """The date/time representation for the dpkg log file timestamps"""
    LOG_DATE_TIME_FMT = "%Y-%m-%d  %H:%M:%S"

    @classmethod
    def as_string(cls):
        # type: () -> str
        """Return the current date and time as LOG_DATE_TIME_FMT string"""
        return datetime.datetime.now().strftime(cls.LOG_DATE_TIME_FMT)

    @classmethod
    def from_string(cls, logstr):
        # type: (str) -> datetime.datetime
        """Take a LOG_DATE_TIME_FMT string and return datetime object"""
        return datetime.datetime.strptime(logstr, cls.LOG_DATE_TIME_FMT)


class UnknownMatcherError(ValueError):
    pass


class NoAllowedOriginError(ValueError):
    pass


class InstallResult(Enum):
    SUCCESS = 1
    POSTPONED = 2
    FAILED = 3

    @classmethod
    def from_bool(cls, b):
        return cls.SUCCESS if b else cls.FAILED


PkgPin = namedtuple('PkgPin', ['pkg', 'priority'])
PkgFilePin = namedtuple('PkgFilePin', ['id', 'priority'])


class PluginDataPostrun(dict):
    """PluginResultData represents the result of the unattended upgrade
    operation for a plugin.

    It can be used as a dict or as a dataclass like object.
    """

    def __init__(self, dict):
        # type: (dict) -> None
        self.update(dict)

    @property
    def plugin_api(self):
        # type: () -> str
        """The API for the plugin interface.

        Major versions break compatiblity, minor versions only add fields.
        """
        return self["plugin_api"]

    @property
    def hostname(self):
        # type: () -> Optional[str]
        """The hostname of the system that u-u ran on"""
        return self["hostname"]

    @property
    def success(self):
        # type: () -> bool
        """Boolean state if u-u ran successfully"""
        return self["success"]

    @property
    def result(self):
        # type: () -> str
        """The result of the operation as a human readable string"""
        return self["result"]

    @property
    def packages_upgraded(self):
        # type () -> List[str]
        """List of strings with the package names that got upgraded"""
        return self.get("packages_upgraded")

    @property
    def packages_kept_back(self):
        # type () -> List[str]
        """List of strings with the package names that were held back"""
        return self.get("packages_kept_back")

    @property
    def packages_removed(self):
        # type () -> List[str]
        """List of strings with the package names that got removed"""
        return self.get("packages_removed")

    @property
    def packages_kept_installed(self):
        # type () -> List[str]
        """List of strings with the package names that are kept on hold"""
        return self.get("packages_kept_installed")

    @property
    def reboot_required(self):
        # type () -> boolean
        """Boolean value if a reboot is required"""
        return self.get("reboot_required")

    @property
    def log_dpkg(self):
        # type () -> str
        """The full dpkg output as a string"""
        return self.get("log_dpkg")

    @property
    def log_unattended_upgrades(self):
        # type () -> Optional[str]
        """The full unattended-upgrades log output as a string"""
        return self.get("log_unattended_upgrades")


class PluginManager:
    def __init__(self):
        # type: () -> None
        _plugin_dirs = [
            "/etc/unattended-upgrades/plugins/",
            "/usr/share/unattended-upgrades/plugins",
        ]
        cfg_plugin_paths = apt_pkg.config.value_list(
            "Unattended-Upgrade::Dirs::Plugins")
        if cfg_plugin_paths:
            _plugin_dirs.extend(cfg_plugin_paths)
        env_plugin_path = os.getenv("UNATTENDED_UPGRADES_PLUGIN_PATH")
        if env_plugin_path:
            _plugin_dirs.extend(env_plugin_path.split(":"))
        self._plugins = self._load_plugins(_plugin_dirs)

    def _load_plugins(self, paths):
        # type: (List[str]) -> AbstractSet[object]
        logging.debug("loading plugins from {}".format(paths))
        plugins = set()
        for path in paths:
            for p in glob.glob(path + "/*.py"):
                module_name = os.path.splitext(os.path.basename(p))[0]
                try:
                    plugin_spec = importlib.util.spec_from_file_location(module_name, p)
                    if plugin_spec is None:
                        raise ValueError(
                            "plugin_spec for %s returned None" % module_name)
                    mod = importlib.util.module_from_spec(plugin_spec)
                    assert isinstance(plugin_spec.loader, Loader)
                    plugin_spec.loader.exec_module(mod)
                except Exception as e:
                    logging.warn("cannot load plugin %s", e)
                    continue
                for __, member in inspect.getmembers(mod):
                    # required class name prefix
                    prefix = "UnattendedUpgradesPlugin"
                    if inspect.isclass(member) and member.__name__.startswith(prefix):
                        logging.debug("adding plugin %s %s", mod, member)
                        plugins.add(member())
        return plugins

    def _call_plugin_func(self, func_name, *args):
        # FIXME: add type annotations
        for plugin in self._plugins:
            plugin_func = getattr(plugin, func_name, None)
            if plugin_func is not None:
                try:
                    plugin_func(*args)
                except Exception as e:
                    logging.warning('cannot run "%s" in plugin %s: %s' % (
                        func_name, plugin, e))

    def postrun(self, res, uu_log, dpkg_log):
        # type: (UnattendedUpgradesResult, Optional[StringIO], str) -> None

        # this gets the current function name (e.g. "postrun")
        func_name = sys._getframe().f_code.co_name
        kept_back = set()
        # XXX: add "package-kept-back-details" only if someone asks (YAGNI)
        kept_back_details = []
        for origin, origin_pkgs in res.pkgs_kept_back.items():
            for pkg in origin_pkgs:
                kept_back.add(pkg)
                kept_back_details.append({"package": pkg, "origin": origin})
        # This is a custom dict because the expected main-use case for
        # this is webhook support so json serialization should be
        # trivial.  straightforward. The properties are there mostly
        # for documentation purposes.
        #
        # Keep in sync with the PluginResult properties
        result = PluginDataPostrun({
            # increment minor version very time something is added
            "plugin_api": "1.0",
            "hostname": host(),
            "success": res.success,
            "result": res.result_str,
            "packages_upgraded": res.pkgs,
            "packages_kept_back": sorted(list(kept_back)),
            "packages_removed": sorted(res.pkgs_removed),
            "packages_kept_installed": sorted(res.pkgs_kept_installed),
            "reboot_required": reboot_required(),
            "log_dpkg": dpkg_log,
        })
        if uu_log is not None:
            result["log_unattended_upgrades"] = uu_log.getvalue()
        self._call_plugin_func(func_name, result)


class UnattendedUpgradesCache(apt.Cache):

    def __init__(self, rootdir):
        # type: (str) -> None
        self._cached_candidate_pkgnames = set()  # type: Set[str]

        self.allowed_origins = get_allowed_origins()
        logging.info(_("Allowed origins are: %s"),
                     ", ".join(self.allowed_origins))

        self.blacklist = apt_pkg.config.value_list(
            "Unattended-Upgrade::Package-Blacklist")
        logging.info(_("Initial blacklist: %s"), " ".join(self.blacklist))

        self.whitelist = apt_pkg.config.value_list(
            "Unattended-Upgrade::Package-Whitelist")
        self.strict_whitelist = apt_pkg.config.find_b(
            "Unattended-Upgrade::Package-Whitelist-Strict", False)
        logging.info(_("Initial whitelist (%s): %s"),
                     "strict" if self.strict_whitelist else "not strict",
                     " ".join(self.whitelist))
        apt.Cache.__init__(self, rootdir=rootdir)

        # pre-heat lazy-loaded modules to avoid crash on python upgrade
        datetime.datetime.strptime("", "")

        # generate versioned_kernel_pkgs_regexp for later use
        self.versioned_kernel_pkgs_regexp = versioned_kernel_pkgs_regexp()
        self.running_kernel_pkgs_regexp = running_kernel_pkgs_regexp()
        if self.versioned_kernel_pkgs_regexp:
            logging.debug("Using %s regexp to find kernel packages",
                          self.versioned_kernel_pkgs_regexp.pattern)
        else:
            logging.debug("APT::VersionedKernelPackages is not set")
        if self.running_kernel_pkgs_regexp:
            logging.debug("Using %s regexp to find running kernel packages",
                          self.running_kernel_pkgs_regexp.pattern)

    def find_better_version(self, pkg):
        # type (apt.Package) -> apt.package.Version
        if pkg.is_installed and pkg.versions[0] > pkg.installed:
            logging.debug(
                "Package %s has a higher version available, checking if it is "
                "from an allowed origin and is not pinned down.", pkg.name)
            for v in pkg.versions:
                if pkg.installed < v \
                   and pkg.installed.policy_priority <= v.policy_priority \
                   and is_in_allowed_origin(v, self.allowed_origins):
                    return v
        return None

    def find_kept_packages(self, dry_run):
        # type: (bool) -> KeptPkgs
        """ Find kept packages not collected already """

        kept_packages = KeptPkgs(set)
        if dry_run:
            logging.info(_("The list of kept packages can't be calculated in "
                           "dry-run mode."))
            return kept_packages
        for pkg in self:
            better_version = self.find_better_version(pkg)
            if better_version:
                logging.info(self.kept_package_excuse(pkg._pkg,
                                                      self.blacklist,
                                                      self.whitelist,
                                                      self.strict_whitelist,
                                                      better_version))
                kept_packages.add(pkg, better_version, self)
        return kept_packages

    def kept_package_excuse(self, pkg,          # apt.Package
                            blacklist,          # type: List[str]
                            whitelist,          # type: List[str]
                            strict_whitelist,   # type: bool
                            better_version      # type: apt.package.Version
                            ):
        # type: (...) -> str
        """ Log the excuse the package is kept back for """
        if pkg.selected_state == apt_pkg.SELSTATE_HOLD:
            return _("Package %s is marked to be held back.") % pkg.name
        elif is_pkgname_in_blacklist(pkg.name, blacklist):
            return _("Package %s is blacklisted.") % pkg.name
        elif whitelist:
            if strict_whitelist:
                if not is_pkgname_in_whitelist(pkg.name, whitelist):
                    return (_(
                        "Package %s is not on the strict whitelist.")
                        % pkg.name)
                else:
                    if not is_pkgname_in_whitelist(pkg.name, whitelist):
                        return (_(
                            "Package %s is not whitelisted and it is not a"
                            " dependency of a whitelisted package.")
                            % pkg.name)
        elif not any([o.trusted for o in better_version.origins]):
            return _("Package %s's origin is not trusted.") % pkg.name
        return (_("Package %s is kept back because a related package"
                  " is kept back or due to local apt_preferences(5).")
                % pkg.name)

    def pinning_from_regex_list(self, regexps, priority):
        # type: (List[str], int) -> List[PkgPin]
        """ Represent blacklist as Python regexps as list of pkg pinnings"""

        pins = []  # type: List[PkgPin]
        for regex in regexps:
            if python_regex_is_posix(regex):
                pins.append(PkgPin('/^' + regex + '/', priority))
            else:
                # Python regex is not also an equivalent POSIX regexp.
                # This is expected to be rare. Go through all the package names
                # and pin all the matching ones.
                for pkg in self._cache.packages:
                    if re.match(regex, pkg.name):
                        pins.append(PkgPin(pkg.name, priority))
        return pins

    def pinning_from_config(self):
        # type: () -> List[Union[PkgPin, PkgFilePin]]
        """ Represent configuration as list of pinnings

            Assumes self.allowed_origins to be already set.
        """

        pins = []  # type: List[Union[PkgPin, PkgFilePin]]

        # mark not allowed origins with 'never' pin
        for pkg_file in self._cache.file_list:  # type: ignore
            if not is_allowed_origin(pkg_file, self.allowed_origins):
                # Set the magic 'never' pin on not allowed origins
                logging.debug("Marking not allowed %s with %s pin", pkg_file,
                              NEVER_PIN)
                pins.append(PkgFilePin(pkg_file.id, NEVER_PIN))
            # TODO(rbalint) pin not trusted origins with NEVER_PIN
            elif self.strict_whitelist:
                # set even allowed origins to -1 and set individual package
                # priorities up later
                pins.append(PkgFilePin(pkg_file.id, -1))

        # mark blacklisted packages with 'never' pin
        pins.extend(self.pinning_from_regex_list(  # type: ignore
            self.blacklist, NEVER_PIN))
        # set priority of whitelisted packages to high
        pins.extend(self.pinning_from_regex_list(  # type: ignore
            self.whitelist, 900))
        if self.strict_whitelist:
            policy = self._depcache.policy
            # pin down already pinned packages which are not on the whitelist
            # to not install locally pinned up packages accidentally
            for pkg in self._cache.packages:
                if pkg.has_versions:
                    pkg_ver = policy.get_candidate_ver(pkg)  # type: ignore
                    if pkg_ver is not None \
                       and policy.get_priority(pkg_ver) > -1:
                        # the pin is higher than set for allowed origins, thus
                        # there is extra pinning configuration
                        if not is_pkgname_in_whitelist(pkg.name,
                                                       self.whitelist):
                            pins.append(PkgPin(pkg.name, NEVER_PIN))

        return pins

    def apply_pinning(self, pins):
        # type: (List[Union[PkgPin, PkgFilePin]]) -> None
        """ Apply the list of pins """

        policy = self._depcache.policy
        pkg_files = {f.id: f for f in self._cache.file_list}  # type: ignore
        for pin in pins:
            logging.debug("Applying pinning: %s" % str(pin))
            if isinstance(pin, PkgPin):
                policy.create_pin('Version', pin.pkg, '*',  # type: ignore
                                  pin.priority)
            elif isinstance(pin, PkgFilePin):
                logging.debug("Applying pin %s to package_file: %s"
                              % (pin.priority, str(pkg_files[pin.id])))
                policy.set_priority(pkg_files[pin.id],  # type: ignore
                                    pin.priority)

    def open(self, progress=None):
        # type: (Optional[apt.progress.base.OpProgress]) -> None
        apt.Cache.open(self, progress)
        # apply pinning generated from unattended-upgrades configuration
        self.apply_pinning(self.pinning_from_config())

    def adjust_candidate(self, pkg):
        # type: (apt.Package) -> bool
        """ Adjust origin and return True if adjustment took place

            This is needed when e.g. a package is available in
            the security pocket but there is also a package in the
            updates pocket with a higher version number
        """
        try:
            new_cand = ver_in_allowed_origin(pkg, self.allowed_origins)
            # Only adjust to lower versions to avoid flipping back and forth
            # and to avoid picking a newer version, not selected by apt.
            # This helps avoiding upgrades to experimental's packages.
            if pkg.candidate is not None and new_cand < pkg.candidate:
                logging.debug(
                    "adjusting candidate to version %s in allowed "
                    "origin %s" % (new_cand, new_cand.origins))
                pkg.candidate = new_cand
                return True
            else:
                return False
        except NoAllowedOriginError:
            return False

    def call_checked(self, function, pkg, **kwargs):
        """ Call function and check if package is in the wanted state
        """
        try:
            function(pkg, **kwargs)
        except SystemError as e:
            logging.warning(
                _("package %s upgradable but fails to "
                  "be marked for upgrade (%s)"), pkg.name, e)
            self.clear()
            return False

        return ((function == apt.package.Package.mark_upgrade
                 or function == apt.package.Package.mark_install)
                and (pkg.marked_upgrade or pkg.marked_install))

    def call_adjusted(self, function, pkg, **kwargs):
        """Call function, but with adjusting
           packages in changes to come from allowed origins

           Note that as a side effect more package's candidate can be
           adjusted than only the one's in the final changes set.
        """
        new_pkgs_to_adjust = []  # List[str]

        if not is_pkg_change_allowed(pkg, self.blacklist, self.whitelist,
                                     self.strict_whitelist):
            return

        if function == apt.package.Package.mark_upgrade \
                and not pkg.is_upgradable:
            if not apt_pkg.config.find_b("Unattended-Upgrade::Allow-downgrade",
                                         False):
                return
            else:
                function = apt.package.Package.mark_install
        marking_succeeded = self.call_checked(function, pkg, **kwargs)

        if (not marking_succeeded
            or not check_changes_for_sanity(self, desired_pkg=pkg)) \
                and allow_marking_fallback():
            logging.debug("falling back to adjusting %s's dependencies"
                          % pkg.name)
            self.clear()
            # adjust candidates in advance if needed
            for pkg_name in self._cached_candidate_pkgnames:
                self.adjust_candidate(self[pkg_name])

            self.adjust_candidate(pkg)
            for dep in transitive_dependencies(pkg, self, level=1):
                try:
                    self.adjust_candidate(self[dep])
                except KeyError:
                    pass

            self.call_checked(function, pkg, **kwargs)

        for marked_pkg in self.get_changes():
            if marked_pkg.name in self._cached_candidate_pkgnames:
                continue
            if not is_in_allowed_origin(marked_pkg.candidate,
                                        self.allowed_origins):
                try:
                    ver_in_allowed_origin(marked_pkg,
                                          self.allowed_origins)
                    # important! this avoids downgrades below
                    if pkg.is_installed and not pkg.is_upgradable and \
                            apt_pkg.config.find_b("Unattended-Upgrade::Allow-"
                                                  "downgrade", False):
                        continue
                    new_pkgs_to_adjust.append(marked_pkg)
                except NoAllowedOriginError:
                    pass

        if new_pkgs_to_adjust:
            new_pkg_adjusted = False
            for pkg_to_adjust in new_pkgs_to_adjust:
                if self.adjust_candidate(pkg_to_adjust):
                    self._cached_candidate_pkgnames.add(pkg_to_adjust.name)
                    new_pkg_adjusted = True
            if new_pkg_adjusted:
                self.call_adjusted(function, pkg, **kwargs)

    def mark_upgrade_adjusted(self, pkg, **kwargs):
        self.call_adjusted(apt.package.Package.mark_upgrade, pkg, **kwargs)

    def mark_install_adjusted(self, pkg, **kwargs):
        self.call_adjusted(apt.package.Package.mark_install, pkg, **kwargs)


class LogInstallProgress(apt.progress.base.InstallProgress):
    """ Install progress that writes to self.progress_log
        (/var/run/unattended-upgrades.progress by default)
    """

    def __init__(self, logfile_dpkg, verbose=False,
                 progress_log="var/run/unattended-upgrades.progress"):
        # type: (str, bool, str) -> None
        apt.progress.base.InstallProgress.__init__(self)
        self.logfile_dpkg = logfile_dpkg
        self.progress_log = os.path.join(apt_pkg.config.find_dir("Dir"),
                                         progress_log)
        self.verbose = verbose
        self.output_logfd = None  # type: Optional[int]

    def status_change(self, pkg, percent, status):
        # type: (str, float, str) -> None
        with open(self.progress_log, "w") as f:
            f.write(_("Progress: %s %% (%s)") % (percent, pkg))

    def _fixup_fds(self):
        # () -> None
        required_fds = [0, 1, 2,  # stdin, stdout, stderr
                        self.writefd,
                        self.write_stream.fileno(),
                        self.statusfd,
                        self.status_stream.fileno()
                        ]
        # ensure that our required fds close on exec
        for fd in required_fds[3:]:
            old_flags = fcntl.fcntl(fd, fcntl.F_GETFD)
            fcntl.fcntl(fd, fcntl.F_SETFD, old_flags | fcntl.FD_CLOEXEC)
        # close all fds
        proc_fd = "/proc/self/fd"
        if os.path.exists(proc_fd):
            error_count = 0
            for fdname in os.listdir(proc_fd):
                try:
                    fd = int(fdname)
                except Exception:
                    print("ERROR: can not get fd for %s" % fdname)
                if fd in required_fds:
                    continue
                try:
                    os.close(fd)
                    # print("closed: ", fd)
                except OSError as e:
                    # there will be one fd that can not be closed
                    # as its the fd from pythons internal diropen()
                    # so its ok to ignore one close error
                    error_count += 1
                    if error_count > 1:
                        print("ERROR: os.close(%s): %s" % (fd, e))

    def _redirect_stdin(self):
        # type: () -> None
        REDIRECT_INPUT = os.devnull
        fd = os.open(REDIRECT_INPUT, os.O_RDWR)
        os.dup2(fd, 0)

    def _redirect_output(self):
        # type: () -> None
        # do not create log in dry-run mode, just output to stdout/stderr
        if not apt_pkg.config.find_b("Debug::pkgDPkgPM", False):
            logfd = self._get_logfile_dpkg_fd()
            os.dup2(logfd, 1)
            os.dup2(logfd, 2)

    def _get_logfile_dpkg_fd(self):
        # type: () -> int
        logfd = os.open(
            self.logfile_dpkg, os.O_RDWR | os.O_APPEND | os.O_CREAT, 0o640)
        try:
            adm_gid = grp.getgrnam("adm").gr_gid
            os.fchown(logfd, 0, adm_gid)
        except (KeyError, OSError):
            pass
        return logfd

    def update_interface(self):
        # type: () -> None
        # call super class first
        apt.progress.base.InstallProgress.update_interface(self)
        self._do_verbose_output_if_needed()

    def _do_verbose_output_if_needed(self):
        # type: () -> None
        # if we are in debug mode, nothing to be more verbose about
        if apt_pkg.config.find_b("Debug::pkgDPkgPM", False):
            return
        # handle verbose
        if self.verbose:
            if self.output_logfd is None:
                self.output_logfd = os.open(self.logfile_dpkg, os.O_RDONLY)
                os.lseek(self.output_logfd, 0, os.SEEK_END)
            try:
                select.select([self.output_logfd], [], [], 0)
                # FIXME: this should be OSError, but in py2.7 it is still
                #        select.error
            except select.error as e:
                if e.errno != errno.EINTR:  # type: ignore
                    logging.exception("select failed")
            # output to stdout in verbose mode only
            os.write(1, os.read(self.output_logfd, 1024))

    def _log_in_dpkg_log(self, msg):
        # type: (str) -> None
        logfd = self._get_logfile_dpkg_fd()
        os.write(logfd, msg.encode("utf-8"))
        os.close(logfd)

    def finish_update(self):
        # type: () -> None
        self._log_in_dpkg_log("Log ended: %s\n\n"
                              % LoggingDateTime.as_string())

    def __del__(self):
        # this can be removed once
        #   https://salsa.debian.org/apt-team/python-apt/-/merge_requests/64
        # is merged everywhere
        if hasattr(self, "status_stream"):
            self.status_stream.close()
        if hasattr(self, "write_stream"):
            self.write_stream.close()

    def fork(self):
        # type: () -> int
        self._log_in_dpkg_log("Log started: %s\n"
                              % LoggingDateTime.as_string())
        pid = os.fork()
        if pid == 0:
            self._fixup_fds()
            self._redirect_stdin()
            self._redirect_output()
        return pid


class Unlocked:
    """
    Context manager for unlocking the apt lock while cache.commit() is run
    """

    def __enter__(self):
        # type: () -> None
        try:
            apt_pkg.pkgsystem_unlock_inner()
        except Exception:
            # earlier python-apt used to leak lock
            logging.warning("apt_pkg.pkgsystem_unlock() failed due to not "
                            "holding the lock but trying to continue")
            pass

    def __exit__(self, exc_type, exc_value, exc_tb):
        # type: (object, object, object) -> None
        apt_pkg.pkgsystem_lock_inner()


class KeptPkgs(defaultdict):
    """
    Packages to keep by highest allowed pretty-printed origin

    """
    def add(self, pkg,  # type: apt.Package
            version,    # type: apt.package.Version
            cache       # type: UnattendedUpgradesCache
            ):
        # type: (...) -> None
        for origin in version.origins:
            if is_allowed_origin(origin, cache.allowed_origins):
                self[origin.origin + " " + origin.archive].add(pkg.name)
                return


class UnattendedUpgradesResult:
    """
    Represent the (potentially partial) results of an unattended-upgrades
    run
    """
    def __init__(self,
                 success,                 # type: bool
                 result_str="",           # type: str
                 pkgs=[],                 # type: List[str]
                 pkgs_kept_back=KeptPkgs(set),     # type: KeptPkgs
                 pkgs_removed=[],         # type: List[str]
                 pkgs_kept_installed=[],  # type: List[str]
                 update_stamp=False       # type: bool
                 ):
        # type: (...) -> None
        self.success = success
        self.result_str = result_str
        self.pkgs = pkgs
        self.pkgs_kept_back = pkgs_kept_back
        self.pkgs_removed = pkgs_removed
        self.pkgs_kept_installed = pkgs_kept_installed
        self.update_stamp = update_stamp


def is_dpkg_journal_dirty():
    # type: () -> bool
    """
    Return True if the dpkg journal is dirty
    (similar to debSystem::CheckUpdates)
    """
    d = os.path.join(
        os.path.dirname(apt_pkg.config.find_file("Dir::State::status")),
        "updates")
    for f in os.listdir(d):
        if re.match("[0-9]+", f):
            return True
    return False


def reboot_required():
    # type: () -> bool
    return os.path.isfile(REBOOT_REQUIRED_FILE)


def signal_handler(signal, frame):
    # type: (int, object) -> None
    logging.warning("SIGTERM received, will stop")
    global SIGNAL_STOP_REQUEST
    SIGNAL_STOP_REQUEST = True


def log_once(msg):
    # type: (str) -> None
    global logged_msgs
    if msg not in logged_msgs:
        logging.info(msg)
        logged_msgs.add(msg)  # type: ignore


def should_stop():
    # type: () -> bool
    """
    Return True if u-u needs to stop due to signal received or due to the
    system started to run on battery.
    """
    if SIGNAL_STOP_REQUEST:
        logging.warning("SIGNAL received, stopping")
        return True
    try:
        if apt_pkg.config.find_b("Unattended-Upgrade::OnlyOnACPower", True) \
           and subprocess.call("on_ac_power") == 1:
            logging.warning("System is on battery power, stopping")
            return True
    except FileNotFoundError:
        log_once(
            _("Checking if system is running on battery is skipped. Please "
              "install powermgmt-base package to check power status and skip "
              "installing updates when the system is running on battery."))
    if apt_pkg.config.find_b(
            "Unattended-Upgrade::Skip-Updates-On-Metered-Connections", True):
        try:
            if NetworkMonitor.get_network_metered(
                    NetworkMonitor.get_default()):
                logging.warning(_("System is on metered connection, stopping"))
                return True
        except NameError:
            log_once(_("Checking if connection is metered is skipped. Please "
                       "install python3-gi package to detect metered "
                       "connections and skip downloading updates."))
    return False


def substitute(line):
    # type: (str) -> str
    """ substitude known mappings and return a new string

    Currently supported ${distro-release}
    """
    mapping = {"distro_codename": get_distro_codename(),
               "distro_id": get_distro_id()}
    return string.Template(line).substitute(mapping)


def get_distro_codename():
    # type: () -> str
    return DISTRO_CODENAME


def get_distro_id():
    # type: () -> str
    return DISTRO_ID


def allow_marking_fallback():
    # type: () -> bool
    return apt_pkg.config.find_b(
        "Unattended-Upgrade::Allow-APT-Mark-Fallback",
        get_distro_codename() != "sid")


def versioned_kernel_pkgs_regexp():
    apt_versioned_kernel_pkgs = apt_pkg.config.value_list(
        "APT::VersionedKernelPackages")
    if apt_versioned_kernel_pkgs:
        return re.compile("(" + "|".join(
            ["^" + p + "-[1-9][0-9]*\\.[0-9]+\\.[0-9]+-[0-9]+(-.+)?$"
             for p in apt_versioned_kernel_pkgs]) + ")")
    else:
        return None


def running_kernel_pkgs_regexp():
    apt_versioned_kernel_pkgs = apt_pkg.config.value_list(
        "APT::VersionedKernelPackages")
    if apt_versioned_kernel_pkgs:
        running_kernel_version = subprocess.check_output(
            ["uname", "-r"], universal_newlines=True).rstrip()
        kernel_escaped = re.escape(running_kernel_version)
        try:
            kernel_noflavor_escaped = re.escape(
                re.match("[1-9][0-9]*\\.[0-9]+\\.[0-9]+-[0-9]+",
                         running_kernel_version)[0])
            return re.compile("(" + "|".join(
                [("^" + p + "-" + kernel_escaped + "$|^"
                  + p + "-" + kernel_noflavor_escaped + "$")
                 for p in apt_versioned_kernel_pkgs]) + ")")
        except TypeError:
            # flavor could not be cut from version
            return re.compile("(" + "|".join(
                [("^" + p + "-" + kernel_escaped + "$")
                 for p in apt_versioned_kernel_pkgs]) + ")")
    else:
        return None


def get_allowed_origins_legacy():
    # type: () -> List[str]
    """ legacy support for old Allowed-Origins var """
    allowed_origins = []  # type: List[str]
    key = "Unattended-Upgrade::Allowed-Origins"
    try:
        for s in apt_pkg.config.value_list(key):
            # if there is a ":" use that as seperator, else use spaces
            if re.findall(r'(?<!\\):', s):
                (distro_id, distro_codename) = re.split(r'(?<!\\):', s)
            else:
                (distro_id, distro_codename) = s.split()
            # unescape "\:" back to ":"
            distro_id = re.sub(r'\\:', ':', distro_id)
            # escape "," (see LP: #824856) - can this be simpler?
            distro_id = re.sub(r'([^\\]),', r'\1\\,', distro_id)
            distro_codename = re.sub(r'([^\\]),', r'\1\\,', distro_codename)
            # convert to new format
            allowed_origins.append("o=%s,a=%s" % (substitute(distro_id),
                                   substitute(distro_codename)))
    except ValueError:
        logging.error(_("Unable to parse %s." % key))
        raise
    return allowed_origins


def get_allowed_origins():
    # type: () -> List[str]
    """ return a list of allowed origins from apt.conf

    This will take substitutions (like distro_id) into account.
    """
    allowed_origins = get_allowed_origins_legacy()
    key = "Unattended-Upgrade::Origins-Pattern"
    try:
        for s in apt_pkg.config.value_list(key):
            allowed_origins.append(substitute(s))
    except ValueError:
        logging.error(_("Unable to parse %s." % key))
        raise
    return allowed_origins


def match_whitelist_string(whitelist, origin):
    # type: (str, Union[apt.package.Origin, apt_pkg.PackageFile]) -> bool
    """
    take a whitelist string in the form "origin=Debian,label=Debian-Security"
    and match against the given python-apt origin. A empty whitelist string
    never matches anything.
    """
    whitelist = whitelist.strip()
    if whitelist == "":
        logging.warning("empty match string matches nothing")
        return False
    res = True
    # make "\," the html quote equivalent
    whitelist = whitelist.replace("\\,", "%2C")
    for token in whitelist.split(","):
        # strip and unquote the "," back
        (what, value) = [s.strip().replace("%2C", ",")
                         for s in token.split("=")]
        # logging.debug("matching %s=%s against %s" % (
        #              what, value, origin))
        # support substitution here as well
        value = substitute(value)
        # first char is apt-cache policy output, send is the name
        # in the Release file
        if what in ("o", "origin"):
            match = fnmatch.fnmatch(origin.origin, value)
        elif what in ("l", "label"):
            match = fnmatch.fnmatch(origin.label, value)
        elif what in ("a", "suite", "archive"):
            match = fnmatch.fnmatch(origin.archive, value)
        elif what in ("c", "component"):
            match = fnmatch.fnmatch(origin.component, value)
        elif what in ("site",):
            match = fnmatch.fnmatch(origin.site, value)
        elif what in ("n", "codename",):
            match = fnmatch.fnmatch(origin.codename, value)
        else:
            raise UnknownMatcherError(
                "Unknown whitelist entry for matcher %s (token %s)" % (
                    what, token))
        # update res
        res = res and match
        # logging.debug("matching %s=%s against %s" % (
        #              what, value, origin))
    return res


def python_regex_is_posix(expression):
    # type: (str) -> bool
    """ Returns if the Python regex is also an equivalent POSIX regex """
    return re.match("^[-a-zA-Z0-9\\^\\$\\+\\.:]*$", expression) is not None


def cache_commit(cache,           # type: apt.Cache
                 logfile_dpkg,    # type: str
                 verbose,         # type: bool
                 iprogress=None,  # type: Optional[apt.progress.base.InstallProgress]
                 ):
    # type: (...) -> Tuple[bool, Optional[Exception]]
    """Commit the changes from the given cache to the system"""

    error = None
    res = False
    if iprogress is None:
        iprogress = LogInstallProgress(logfile_dpkg, verbose)

    try:
        res = cache.commit(install_progress=iprogress)
        cache.open()
    except SystemError as e:
        error = e
        if verbose:
            logging.exception("Exception happened during upgrade.")
        cache.clear()
    return res, error


def upgrade_normal(cache, logfile_dpkg, verbose):
    # type: (apt.Cache, str, bool) -> bool
    res, error = cache_commit(cache, logfile_dpkg, verbose)
    if res:
        logging.info(_("All upgrades installed"))
    else:
        logging.error(_("Installing the upgrades failed!"))
        logging.error(_("error message: %s"), error)
        logging.error(_("dpkg returned a error! See %s for details"),
                      logfile_dpkg)
    return res


def upgrade_in_minimal_steps(cache,            # type: UnattendedUpgradesCache
                             pkgs_to_upgrade,  # type: List[str]
                             logfile_dpkg="",  # type: str
                             verbose=False,    # type: bool
                             ):
    # type: (...) -> bool
    install_log = LogInstallProgress(logfile_dpkg, verbose)

    res = True

    # to upgrade contains the package names
    to_upgrade = set(pkgs_to_upgrade)
    for pkgname in upgrade_order(to_upgrade, cache):
        # upgrade packages and dependencies in increasing expected size of
        # package sets to upgrade/install together
        if pkgname not in to_upgrade:
            # pkg is upgraded in a previous set
            continue
        if should_stop():
            return False
        pkg = cache[pkgname]
        try:
            if pkg.is_upgradable \
               or candidate_version_changed(pkg):
                cache.mark_upgrade_adjusted(
                    pkg, from_user=not pkg.is_auto_installed)
            elif not pkg.is_installed:
                cache.mark_install_adjusted(pkg, from_user=False)
            else:
                continue
        except Exception as e:
            logging.warning(
                _("package %s upgradable but fails to "
                  "be marked for upgrade (%s)"), pkgname, e)
            cache.clear()
            res = False
            continue

        # double check that we are not running into side effects like
        # what could have been caused LP: #1020680
        if not check_changes_for_sanity(cache):
            logging.info("While building minimal partition: "
                         "cache has not allowed changes")
            cache.clear()
            continue
        changes = [p.name for p in cache.get_changes()]
        if not changes:
            continue

        # write progress log information
        if len(pkgs_to_upgrade) > 0:
            all_count = len(pkgs_to_upgrade)
            remaining_count = all_count - len(to_upgrade)
            percent = remaining_count / float(all_count * 100.0)
        else:
            percent = 100.0
        install_log.status_change(pkg=",".join(changes),
                                  percent=percent,
                                  status="")
        # apply changes
        logging.debug("applying set %s" % changes)

        res, error = cache_commit(cache, logfile_dpkg, verbose, install_log)
        if error:
            if verbose:
                logging.exception("Exception happened during upgrade.")
            logging.error(_("Installing the upgrades failed!"))
            logging.error(_("error message: %s"), error)
            logging.error(_("dpkg returned a error! See %s for details"),
                          logfile_dpkg)
            return False
        to_upgrade = to_upgrade - set(changes)
        logging.debug("left to upgrade %s" % to_upgrade)
        if len(to_upgrade) == 0:
            logging.info(_("All upgrades installed"))
            break
    return res


def is_allowed_origin(origin, allowed_origins):
    # type: (Union[apt.package.Origin, apt_pkg.PackageFile], List[str]) -> bool

    # local origin is allowed by default
    if origin.component == 'now' and origin.archive == 'now' and \
       not origin.label and not origin.site:
        return True
    for allowed in allowed_origins:
        if match_whitelist_string(allowed, origin):
            return True
    return False


def is_in_allowed_origin(ver, allowed_origins):
    # type: (apt.package.Version, List[str]) -> bool
    if not ver:
        return False
    for origin in ver.origins:
        if is_allowed_origin(origin, allowed_origins):
            return True
    return False


def ver_in_allowed_origin(pkg, allowed_origins):
    # type: (apt.Package, List[str]) -> apt.package.Version
    for ver in pkg.versions:
        if is_in_allowed_origin(ver, allowed_origins):
            # leave as soon as we have the highest new candidate
            return ver
    raise NoAllowedOriginError()


def is_pkgname_in_blacklist(pkgname, blacklist):
    # type: (str, List[str]) -> bool
    for blacklist_regexp in blacklist:
        if re.match(blacklist_regexp, pkgname):
            logging.debug("skipping blacklisted package %s" % pkgname)
            return True
    return False


def is_pkgname_in_whitelist(pkgname, whitelist):
    # type: (str, List[str]) -> bool
    # a empty whitelist means the user does not want to use this feature
    if not whitelist:
        return True
    for whitelist_regexp in whitelist:
        if re.match(whitelist_regexp, pkgname):
            logging.debug("only upgrading the following package %s" %
                          pkgname)
            return True
    return False


def is_pkg_change_allowed(pkg, blacklist, whitelist, strict_whitelist):
    # type: (apt.Package, List[str], List[str], bool) -> bool
    if is_pkgname_in_blacklist(pkg.name, blacklist):
        logging.debug("pkg %s package has been blacklisted" % pkg.name)
        return False
    # a strict whitelist will not allow any changes not in the
    # whitelist, most people will want the relaxed whitelist
    # that whitelists a package but pulls in the package
    # dependencies
    if strict_whitelist and \
       not is_pkgname_in_whitelist(pkg.name, whitelist):

        logging.debug("pkg %s package is not whitelisted" %
                      pkg.name)
        return False
    if pkg._pkg.selected_state == apt_pkg.SELSTATE_HOLD:
        logging.debug("pkg %s is on hold" % pkg.name)
        return False
    return True


def transitive_dependencies(pkg,               # type: apt.Package
                            cache,             # type: apt.Cache
                            acc=set(),         # type AbstractSet[str]
                            valid_types=None,  # type: Optional[AbstractSet[str]]
                            level=None         # type: Optional[int]
                            ):
    # type (...) -> AbstractSet[str]
    """ All (transitive) dependencies of the package

        Note that alternative (|) dependencies are collected, too
    """
    if not pkg.candidate or level is not None and level < 1:
        return acc

    for dep in pkg.candidate.dependencies:
        for base_dep in dep:
            if base_dep.name not in acc:
                if not valid_types or base_dep.rawtype in valid_types:
                    acc.add(base_dep.name)
                    try:
                        transitive_dependencies(
                            cache[base_dep.name], cache, acc, valid_types,
                            level=(level - 1 if level is not None else None))
                    except KeyError:
                        pass
    return acc


def upgrade_order(to_upgrade, cache):
    # type: (AbstractSet[str], apt.Cache) -> List[str]
    """  Sort pkg names by the expected number of other packages to be upgraded
         with it. The calculation is not 100% accurate, it is an approximation.
    """

    upgrade_set_sizes = {}
    # calculate upgrade sets
    follow_deps = {'Depends', 'PreDepends', 'Recommends'}
    for pkgname in to_upgrade:
        pkg = cache[pkgname]
        upgrade_set_sizes[pkgname] = len(transitive_dependencies(
            pkg, cache, valid_types=follow_deps).intersection(to_upgrade))
    return sorted(upgrade_set_sizes, key=upgrade_set_sizes.get)  # type: ignore


def check_changes_for_sanity(cache, desired_pkg=None):
    # type: (UnattendedUpgradesCache, Optional[apt.Package]) -> bool
    sanity_check_result = sanity_problem(cache, desired_pkg)
    if sanity_check_result is None:
        return True
    else:
        logging.debug("sanity check failed for: %s : %s"
                      % (str({str(p.candidate) for p in cache.get_changes()}),
                         sanity_check_result))
        return False


def sanity_problem(cache, desired_pkg):
    # type: (UnattendedUpgradesCache, Optional[apt.Package]) -> Optional[str]
    if cache._depcache.broken_count != 0:
        return ("there are broken packages in the cache")
    # If there are no packages to be installed they were kept back
    if cache.install_count == 0:
        return ("no package is selected to be upgraded or installed")
    changes = cache.get_changes()
    for pkg in changes:
        if pkg.marked_delete:
            return ("pkg %s is marked to be deleted" % pkg.name)
        if not pkg.candidate:
            return ("internal error: pkg %s has no candidate" % pkg.candidate)
        if pkg.marked_install or pkg.marked_upgrade:
            # apt will never fallback from a trusted to a untrusted
            # origin so its good enough if we have a single trusted one
            if not any([o.trusted for o in pkg.candidate.origins]):
                return ("pkg %s is not from a trusted origin" % pkg.name)
            if not is_in_allowed_origin(pkg.candidate, cache.allowed_origins):
                return ("pkg %s is not in an allowed origin" % pkg.name)
            if not is_pkg_change_allowed(pkg,
                                         cache.blacklist,
                                         cache.whitelist,
                                         cache.strict_whitelist):
                return ("pkg %s is blacklisted or is not whitelisted"
                        % pkg.name)
            # check if the package is unsafe to upgrade unattended
            ignore_require_restart = apt_pkg.config.find_b(
                "Unattended-Upgrade::IgnoreAppsRequireRestart", False)
            upgrade_requires = pkg.candidate.record.get("Upgrade-Requires")
            if pkg.marked_upgrade and ignore_require_restart is False \
               and upgrade_requires == "app-restart":
                return ("pkg %s requires app-restart, it is not safe to "
                        "upgrade it unattended")
    # check that the package we want to upgrade is in the change set
    if desired_pkg and desired_pkg not in changes:
        return ("pkg %s to be marked for upgrade/install is not marked "
                "accordingly" % desired_pkg.name)
    return None


def is_deb(file):
    # type: (str) -> bool
    if file.endswith(".deb"):
        return True
    else:
        return False


def pkgname_from_deb(debfile):
    # type: (str) -> str
    # FIXME: add error checking here
    try:
        control = apt_inst.DebFile(debfile).control.extractdata("control")
        sections = apt_pkg.TagSection(control)
        return sections["Package"]
    except (IOError, SystemError) as e:
        logging.error("failed to read deb file %s (%s)" % (debfile, e))
        # dumb fallback
        return debfile.split("_")[0]


def get_md5sum_for_file_in_deb(deb_file, conf_file):
    # type: (str, str) -> str
    dpkg_cmd = ["dpkg-deb", "--fsys-tarfile", deb_file]
    tar_cmd = ["tar", "-x", "-O", "-f", "-", "." + conf_file]
    md5_cmd = ["md5sum"]
    dpkg_p = Popen(dpkg_cmd, stdout=PIPE)
    tar_p = Popen(tar_cmd, stdin=dpkg_p.stdout, stdout=PIPE,
                  universal_newlines=True)
    md5_p = Popen(md5_cmd, stdin=tar_p.stdout, stdout=PIPE,
                  universal_newlines=True)
    pkg_md5sum = md5_p.communicate()[0].split()[0]
    for __p in [dpkg_p, tar_p, md5_p]:
        p = cast(Popen, __p)
        if p.stdout:
            p.stdout.close()
        p.wait()
    return pkg_md5sum


def get_md5sum_for_file_installed(conf_file, prefix):
    # type: (str, str) -> str
    try:
        with open(prefix + conf_file, 'rb') as fb:
            for hash_string in apt_pkg.Hashes(fb).hashes:  # type: ignore
                if hash_string.hashtype == 'MD5Sum':
                    return hash_string.hashvalue
            raise Exception("no MD5Sum hashtype found in apt_pkg.Hashes")
    except IsADirectoryError:
        # the package replaces a directory wih a configuration file
        #
        # if the package changed this way it is safe to assume that
        # the transition happens without showing a prompt but if the admin
        # created the directory the admin will need to resolve it after
        # being notified about the unexpected prompt
        logging.debug("found conffile %s is a directory on the system "
                      % conf_file)
        return "dir"
    except FileNotFoundError:
        # if the local file got deleted by the admin thats ok but it may still
        # trigger a conffile promp (see debian #788049)
        logging.debug("conffile %s in missing on the system" % conf_file)
        return ""


def map_conf_file(conf_file, conffiles):
    # type: (str, Union[AbstractSet[str], Dict[str, str]]) -> Optional[str]
    """Find respective conffile in a set of conffiles with some heuristics
    """
    if conf_file in conffiles:
        return conf_file
    elif os.path.join(conf_file, os.path.basename(conf_file)) in conffiles:
        # new /etc/foo may be old /etc/foo/foo, like in LP: #1822745
        return os.path.join(conf_file, os.path.basename(conf_file))
    elif os.path.dirname(conf_file) in conffiles:
        # new /etc/foo/foo may be old /etc/foo, probably by accident
        return os.path.dirname(conf_file)
    # TODO: peek into package's dpkg-maintscript-helper mv_conffile usage
    else:
        return None


# prefix is *only* needed for the build-in tests
def conffile_prompt(destFile, prefix=""):
    # type: (str, str) -> bool
    logging.debug("check_conffile_prompt(%s)" % destFile)
    pkgname = pkgname_from_deb(destFile)

    # get the conffiles for the /var/lib/dpkg/status file
    status_file = apt_pkg.config.find("Dir::State::status")
    with open(status_file, "r") as f:
        tagfile = apt_pkg.TagFile(f)
        conffiles = ""
        for section in tagfile:
            if section.get("Package") == pkgname:
                logging.debug("found pkg: %s" % pkgname)
                if "Conffiles" in section:
                    conffiles = section.get("Conffiles")
                    break

    # get conffile value from pkg, its ok if the new version
    # does not have conffiles anymore
    pkg_conffiles = set()  # type: AbstractSet[str]
    try:
        deb = apt_inst.DebFile(destFile)
        pkg_conffiles = set(deb.control.extractdata(
            "conffiles").strip().decode("utf-8").split("\n"))
    except SystemError as e:
        print(_("Apt returned an error, exiting"))
        print(_("error message: %s") % e)
        logging.error(_("Apt returned an error, exiting"))
        logging.error(_("error message: %s"), e)
        raise
    except LookupError as e:
        logging.debug("No conffiles in deb %s (%s)" % (destFile, e))
    if not pkg_conffiles:
        return False

    # Conffiles:
    #  /etc/bash_completion.d/m-a c7780fab6b14d75ca54e11e992a6c11c
    dpkg_status_conffiles = {}
    for line in conffiles.splitlines():
        # ignore empty lines
        line = line.strip()
        if not line:
            continue
        # show what we do
        logging.debug("conffile line: %s", line)
        li = line.split()
        conf_file = li[0]
        md5 = li[1]
        obs = None  # type: Optional[str]
        if len(li) > 2:
            obs = li[2]
        # ignore if conffile is obsolete
        if obs == "obsolete":
            continue
        # ignore state "newconffile" until its clearer if there
        # might be a dpkg prompt (LP: #936870)
        if md5 == "newconffile":
            continue
        new_conf_file = map_conf_file(conf_file, pkg_conffiles)
        if not new_conf_file:
            logging.debug("%s not in package conffiles %s" % (
                conf_file, pkg_conffiles))
            continue
        # record for later
        dpkg_status_conffiles[conf_file] = md5

        # test against the installed file, if the local file got deleted
        # by the admin thats ok but it may still trigger a conffile prompt
        # (see debian #788049)
        current_md5 = get_md5sum_for_file_installed(conf_file, prefix)
        logging.debug("current md5: %s" % current_md5)

        # hashes are the same, no conffile prompt
        if current_md5 == md5:
            continue
        # calculate md5sum from the deb (may take a bit)
        pkg_md5sum = get_md5sum_for_file_in_deb(destFile, new_conf_file)
        logging.debug("pkg_md5sum: %s" % pkg_md5sum)
        # the md5sum in the deb is unchanged, this will not
        # trigger a conffile prompt
        if pkg_md5sum == md5:
            continue
        # if we made it to this point:
        #  current_md5 != pkg_md5sum != md5
        # and that will trigger a conffile prompt, we can
        # stop processing at this point and just return True
        logging.debug("conffile prompt found for %s (%s)" % (conf_file, pkgname))
        return True

    # now check if there are conffiles in the pkg that where not there
    # in the previous version in the dpkg status file
    if pkg_conffiles:
        for conf_file in pkg_conffiles:
            old_conf_file = map_conf_file(conf_file, dpkg_status_conffiles)
            if not old_conf_file:
                pkg_md5sum = get_md5sum_for_file_in_deb(destFile, conf_file)
                current_md5 = get_md5sum_for_file_installed(conf_file, prefix)
                logging.debug("no old_conf_file, pkg_md5sum: %s, current_md5: %s" % (
                    pkg_md5sum, current_md5))
                if current_md5 != "" and pkg_md5sum != current_md5:
                    logging.debug("(old) conffile prompt found for %s (%s)" % (
                        conf_file, pkgname))
                    return True
    return False


def dpkg_conffile_prompt():
    # type: () -> bool
    if "DPkg::Options" not in apt_pkg.config:
        return True
    options = apt_pkg.config.value_list("DPkg::Options")
    for option in options:
        option = option.strip()
        if option in ["--force-confold", "--force-confnew"]:
            return False
    return True


def rewind_cache(cache, pkgs_to_upgrade):
    # type: (UnattendedUpgradesCache, List[apt.Package]) -> None
    """ set the cache back to the state with packages_to_upgrade """
    cache.clear()
    for pkg2 in pkgs_to_upgrade:
        cache.mark_install_adjusted(pkg2, from_user=not pkg2.is_auto_installed)
    if cache.broken_count > 0:
        raise AssertionError("rewind_cache created a broken cache")


def host():
    # type: () -> str
    return socket.getfqdn()


def wrap_indent(t, subsequent_indent=" "):
    # type: (str, str) -> str
    return "\n".join(wrap(t, break_on_hyphens=False,
                          subsequent_indent=subsequent_indent))


def setup_apt_listchanges(conf="/etc/apt/listchanges.conf"):
    # type: (str) -> None
    """ deal with apt-listchanges """
    # apt-listchanges will always send a mail if there is a mail address
    # set in the config regardless of the frontend used, so set it to
    # mail if we have a sendmail and to none if not (as it appears to
    # not check if sendmail is there or not), debian bug #579733
    if os.path.exists(SENDMAIL_BINARY):
        os.environ["APT_LISTCHANGES_FRONTEND"] = "mail"
    else:
        os.environ["APT_LISTCHANGES_FRONTEND"] = "none"


def _send_mail_using_mailx(from_address, to_address, subject, body):
    # type: (str, str, str, str) -> int
    # ensure that the body is a byte stream and that we do not
    # break on encoding errors (the default error mode is "strict")
    encoded_body = body.encode(
        locale.getpreferredencoding(False), errors="replace")
    # we use a binary pipe to stdin to ensure we do not break on
    # unicode encoding errors (e.g. because the user is running a
    # ascii only system like the buildds)
    mail = subprocess.Popen(
        [MAIL_BINARY, "-r", from_address, "-s", subject, to_address],
        stdin=subprocess.PIPE, universal_newlines=False)
    assert mail.stdin  # mypy
    mail.stdin.write(encoded_body)
    mail.stdin.close()
    ret = mail.wait()
    return ret


def _send_mail_using_sendmail(from_address, to_address, subject, body):
    # type: (str, str, str, str) -> int
    # format as a proper mail
    msg = Message()
    msg['Subject'] = subject
    msg['From'] = from_address
    msg['To'] = to_address
    msg['Auto-Submitted'] = "auto-generated"
    # order is important here, Message() first, then Charset()
    #  then msg.set_charset()
    charset = email.charset.Charset("utf-8")
    charset.body_encoding = email.charset.QP  # type: ignore
    msg.set_payload(body, charset)
    # and send it away
    sendmail = subprocess.Popen(
        [SENDMAIL_BINARY, "-oi", "-t"],
        stdin=subprocess.PIPE, universal_newlines=True)
    assert sendmail.stdin  # mypy
    sendmail.stdin.write(msg.as_string())
    sendmail.stdin.close()
    ret = sendmail.wait()
    return ret


def send_summary_mail(pkgs,                 # type: List[str]
                      res,                  # type: bool
                      result_str,           # type: str
                      pkgs_kept_back,       # type: Optional[KeptPkgs]
                      pkgs_removed,         # type: List[str]
                      pkgs_kept_installed,  # type: List[str]
                      mem_log,              # type: Optional[StringIO]
                      dpkg_log_content,     # type: str
                      ):
    # type: (...) -> None
    """ send mail (if configured in Unattended-Upgrade::Mail) """
    to_email = apt_pkg.config.find("Unattended-Upgrade::Mail", "")
    if not to_email:
        return
    if not os.path.exists(MAIL_BINARY) and not os.path.exists(SENDMAIL_BINARY):
        logging.error(_("No /usr/bin/mail or /usr/sbin/sendmail, "
                        "can not send mail. "
                        "You probably want to install the mailx package."))
        return

    # The admin may well wish to get a mail report regardless of what was done.
    # This is now set by Unattended-Upgrade::MailReport values of:
    #       "always", "only-on-error" or "on-change"
    # (you can achieve "never" by not setting Unattended-Upgrade::Mail).
    # If this is not set, then set it using any legacy MailOnlyOnError
    # setting (default True)
    #
    mail_opt = apt_pkg.config.find("Unattended-Upgrade::MailReport")
    if (mail_opt == ""):    # None set - map from legacy value
        if apt_pkg.config.find_b("Unattended-Upgrade::MailOnlyOnError", False):
            mail_opt = "only-on-error"
        else:
            mail_opt = "on-change"

    # if the operation was successful and the user has requested to get
    # mails only on errors, just exit here
    if (res and (mail_opt == "only-on-error")):
        return

    # if the run was successful but nothing had to be done skip sending email
    # unless the admin wants it anyway
    if (((mail_opt != "always") and res and not pkgs and not pkgs_kept_back
         and not pkgs_removed)):
        return

    # Check if reboot-required flag is present
    reboot_flag_str = _(
        "[reboot required]") if reboot_required() else ""
    # Check if packages are kept on hold
    hold_flag_str = (_("[package on hold]") if pkgs_kept_back
                     or pkgs_kept_installed else "")
    logging.debug("Sending mail to %s" % to_email)
    subject = _(
        "{hold_flag}{reboot_flag} unattended-upgrades result for "
        "{machine}: {result}").format(
            hold_flag=hold_flag_str, reboot_flag=reboot_flag_str,
            machine=host(), result="SUCCESS" if res else "FAILURE").strip()
    body = wrap_indent(_("Unattended upgrade result: %s") % result_str)
    body += "\n\n"
    if reboot_required():
        body += _(
            "Warning: A reboot is required to complete this upgrade, "
            "or a previous one.\n\n")
    if pkgs:
        if res:
            body += _("Packages that were upgraded:\n")
        else:
            body += _("Packages that attempted to upgrade:\n")
        body += " " + wrap_indent(" ".join(pkgs))
        body += "\n\n"
    if pkgs_kept_back:
        body += _("Packages with upgradable origin but kept back:\n")
        for origin, origin_pkgs in pkgs_kept_back.items():
            body += " " + origin + ":\n"
            body += "  " + wrap_indent(" ".join(origin_pkgs),
                                       subsequent_indent="  ") + "\n"
        body += "\n"
    if pkgs_removed:
        body += _("Packages that were auto-removed:\n")
        body += " " + wrap_indent(" ".join(pkgs_removed))
        body += "\n\n"
    if pkgs_kept_installed:
        body += _("Packages that were kept from being auto-removed:\n")
        body += " " + wrap_indent(" ".join(pkgs_kept_installed))
        body += "\n\n"
    if dpkg_log_content:
        body += _("Package installation log:") + "\n"
        body += dpkg_log_content
        body += "\n\n"
    body += _("Unattended-upgrades log:\n")
    if mem_log:
        body += mem_log.getvalue()
    else:
        body += "no log available"

    from_email = apt_pkg.config.find("Unattended-Upgrade::Sender", "root")

    if os.path.exists(SENDMAIL_BINARY):
        ret = _send_mail_using_sendmail(from_email, to_email, subject, body)
    elif os.path.exists(MAIL_BINARY):
        ret = _send_mail_using_mailx(from_email, to_email, subject, body)
    else:
        raise AssertionError(
            "This should never be reached as we previously validated that we "
            "either have sendmail or mailx. Maybe they've been removed in "
            "this right moment?")
    logging.debug("mail returned: %s", ret)


def install_or_postpone(cache,             # type: UnattendedUpgradesCache
                        pkgs_to_upgrade,   # type: List[str]
                        options,           # type: Options
                        logfile_dpkg,      # type: str
                        ):
    # type: (...) -> InstallResult

    remaining_days = get_remaining_postpone_days()

    if not HAS_GDBUS:
        # Only log a message if the feature is enabled
        if remaining_days > 0:
            logging.info(_("Skipped prompting for postponing the upgrade. "
                           "Please install python3-gi, gir1.2-glib-2.0 and "
                           "gir1.2-polkit-1.0 to enable the postponing "
                           "feature."))
        return InstallResult.from_bool(
            do_install(cache, pkgs_to_upgrade, options, logfile_dpkg))

    try:
        iface_name = "com.ubuntu.UnattendedUpgrade.Pending.xml"
        with open(os.path.join(DBUS_DIR, "interfaces", iface_name)) as f:
            iface = f.read()
        introspection_data = Gio.DBusNodeInfo.new_for_xml(iface)
    except Exception as e:
        logging.info(_("Skipped prompting for postponing the upgrade: %s"), e)
        return InstallResult.from_bool(
            do_install(cache, pkgs_to_upgrade, options, logfile_dpkg))

    BUS_NAME = "com.ubuntu.UnattendedUpgrade"
    OBJ_PATH = "/com/ubuntu/UnattendedUpgrade/Pending"
    timeout = max(0, apt_pkg.config.find_i(  # type: ignore[attr-defined]
        "Unattended-Upgrade::Postpone-Wait-Time", 300))
    registered = None
    postponed = None
    sem = threading.Semaphore(0)
    dbus_connection = None
    dbus_obj = None
    mainloop = GLib.MainLoop()
    cancellable = Gio.Cancellable()

    def run_with_auth(invocation, sender, method_name, callback):
        def on_authorization_result(authority, res):
            try:
                authorization = authority.check_authorization_finish(res)
                if authorization.get_is_authorized():
                    callback()
                else:
                    invocation.return_error_literal(
                        Gio.DBusError.quark(),
                        Gio.DBusError.ACCESS_DENIED,
                        _("Polkit returned not authorized"))
            except Exception as e:
                logging.debug(e)
                if isinstance(e, GLib.GError) and e.matches(
                        Gio.io_error_quark(), Gio.IOErrorEnum.CANCELLED):
                    invocation.return_error_literal(
                        Gio.DBusError.quark(),
                        Gio.DBusError.TIMEOUT,
                        e.message)
                else:
                    invocation.return_error_literal(
                        Gio.DBusError.quark(),
                        Gio.DBusError.AUTH_FAILED,
                        _("Failed to interrogate Polkit"))

        def on_get_authority_result(obj, res):
            try:
                authority = Polkit.Authority.get_finish(res)
                subject = Polkit.SystemBusName.new(sender)
                authority.check_authorization(
                    subject,
                    introspection_data.interfaces[0].name + "." + method_name,
                    None,
                    Polkit.CheckAuthorizationFlags.ALLOW_USER_INTERACTION,
                    cancellable,
                    on_authorization_result)
            except Exception as e:
                logging.debug(e)
                invocation.return_error_literal(
                    Gio.DBusError.quark(),
                    Gio.DBusError.AUTH_FAILED,
                    _("Failed to interrogate Polkit"))

        Polkit.Authority.get_async(cancellable, on_get_authority_result)

    def handle_method_call(connection, sender, object_path, interface_name,
                           method_name, parameters, invocation):
        if method_name == "Postpone":
            def check_can_postpone_or_fail():
                if postponed is False or remaining_days <= 0:
                    invocation.return_error_literal(
                        Gio.DBusError.quark(),
                        Gio.DBusError.FAILED,
                        _("The upgrade cannot be postponed because "
                          "it is already started"))
                    return False
                return True

            def do_postpone():
                if not check_can_postpone_or_fail():
                    return
                invocation.return_value()
                proceed(False)
                if not exists_stamp_file(POSTPONE_STAMP_FILE):
                    write_stamp_file(POSTPONE_STAMP_FILE)
                logging.info(_("Upgrade postponed"))

            if check_can_postpone_or_fail():
                run_with_auth(invocation, sender, method_name, do_postpone)

    def proceed(continue_install):
        nonlocal postponed
        postponed = not continue_install
        sem.release()

    def emit_about_to_start():
        if dbus_connection:
            info = GLib.Variant("a{sv}", {
                "postpone-timeout-time": GLib.Variant("u", timeout),
                "postpone-remaining-days": GLib.Variant("u", remaining_days),
            })
            dbus_connection.emit_signal(
                None,
                OBJ_PATH,
                introspection_data.interfaces[0].name,
                "AboutToStart",
                GLib.Variant.new_tuple(info))
        return GLib.SOURCE_REMOVE

    def emit_canceled():
        if dbus_connection:
            dbus_connection.emit_signal(
                None,
                OBJ_PATH,
                introspection_data.interfaces[0].name,
                "Canceled")
        return GLib.SOURCE_REMOVE

    def emit_started():
        if dbus_connection:
            dbus_connection.emit_signal(
                None,
                OBJ_PATH,
                introspection_data.interfaces[0].name,
                "Started")
        return GLib.SOURCE_REMOVE

    def emit_finished():
        if dbus_connection:
            dbus_connection.emit_signal(
                None,
                OBJ_PATH,
                introspection_data.interfaces[0].name,
                "Finished")
        return GLib.SOURCE_REMOVE

    def on_name_acquired(connection, name, *args):
        nonlocal registered
        registered = True
        sem.release()

    def on_name_lost(connection, name, *args):
        logging.info(_("Failed to register %s on the system bus. "
                       "Continuing..."), name)
        nonlocal registered
        registered = False
        sem.release()

    def on_bus_acquired(connection, name, *args):
        nonlocal dbus_connection, dbus_obj
        dbus_connection = connection
        dbus_obj = connection.register_object(
            OBJ_PATH,
            introspection_data.interfaces[0],
            handle_method_call)
        if dbus_obj == 0:
            proceed(True)

    def on_sigterm(signal, frame):
        proceed(False)
        cancellable.cancel()
        prev_sigterm_handler(signal, frame)

    def dbus_thread():
        owner_id = Gio.bus_own_name(
            Gio.BusType.SYSTEM,
            BUS_NAME,
            Gio.BusNameOwnerFlags.NONE,
            on_bus_acquired,
            on_name_acquired,
            on_name_lost)
        mainloop.run()
        Gio.bus_unown_name(owner_id)
        if dbus_connection and dbus_obj:
            dbus_connection.unregister_object(dbus_obj)

    t = threading.Thread(target=dbus_thread)
    t.start()
    # wait until registered on dbus or error; should never timeout
    sem.acquire(timeout=10)

    if not registered:
        mainloop.quit()
        t.join()
        return InstallResult.from_bool(
            do_install(cache, pkgs_to_upgrade, options, logfile_dpkg))

    if remaining_days > 0:
        logging.info(_("Waiting for a postpone request..."))
        GLib.idle_add(emit_about_to_start)

        # Temporarily change signal handler
        prev_sigterm_handler = signal.signal(signal.SIGTERM, on_sigterm)
        if should_stop():
            postponed = True
            cancellable.cancel()

        if not sem.acquire(timeout=timeout):
            postponed = False
            cancellable.cancel()

        # Restore signal handler
        signal.signal(signal.SIGTERM, prev_sigterm_handler)
    else:
        postponed = False

    if postponed:
        GLib.idle_add(emit_canceled)
        GLib.idle_add(lambda: mainloop.quit())
        t.join()
        return InstallResult.POSTPONED

    GLib.idle_add(emit_started)
    success = do_install(cache, pkgs_to_upgrade, options, logfile_dpkg)
    GLib.idle_add(emit_finished)
    GLib.idle_add(lambda: mainloop.quit())
    t.join()
    return InstallResult.from_bool(success)


def do_install(cache,             # type: UnattendedUpgradesCache
               pkgs_to_upgrade,   # type: List[str]
               options,           # type: Options
               logfile_dpkg,      # type: str
               ):
    # type: (...) -> bool

    reset_stamp_file(POSTPONE_STAMP_FILE)

    setup_apt_listchanges()

    logging.info(_("Writing dpkg log to %s"), logfile_dpkg)

    if cache.get_changes():
        cache.clear()

    pkg_install_success = False
    try:
        if options.minimal_upgrade_steps:
            # try upgrade all "pkgs" in minimal steps
            pkg_install_success = upgrade_in_minimal_steps(
                cache, pkgs_to_upgrade,
                logfile_dpkg,
                options.verbose or options.debug)
        else:
            mark_pkgs_to_upgrade(cache, pkgs_to_upgrade)
            pkg_install_success = upgrade_normal(
                cache, logfile_dpkg, options.verbose or options.debug)
    except Exception as e:
        # print unhandled exceptions here this way, while stderr is redirected
        os.write(2, ("Exception: %s\n" % e).encode('utf-8'))
        pkg_install_success = False

    return pkg_install_success


def _setup_alternative_rootdir(rootdir):
    # type: (str) -> None
    # clear system unattended-upgrade stuff
    apt_pkg.config.clear("Unattended-Upgrade")
    # read rootdir (taken from apt.Cache, but we need to run it
    # here before the cache gets initialized
    if os.path.exists(rootdir + "/etc/apt/apt.conf"):
        apt_pkg.read_config_file(apt_pkg.config,
                                 rootdir + "/etc/apt/apt.conf")
    if os.path.isdir(rootdir + "/etc/apt/apt.conf.d"):
        apt_pkg.read_config_dir(apt_pkg.config,
                                rootdir + "/etc/apt/apt.conf.d")
    logdir = os.path.join(rootdir, "var", "log", "unattended-upgrades")
    if not os.path.exists(logdir):
        os.makedirs(logdir)
    apt.apt_pkg.config.set("Unattended-Upgrade::LogDir", logdir)


def _get_logdir():
    # type: () -> str
    logdir = apt_pkg.config.find_dir(
        "Unattended-Upgrade::LogDir",
        # COMPAT only
        apt_pkg.config.find_dir("APT::UnattendedUpgrades::LogDir",
                                "/var/log/unattended-upgrades/"))
    return logdir


def _setup_logging(options):
    # type: (Options) -> Optional[StringIO]

    # ensure this is run only once
    if len(logging.root.handlers) > 0:
        return None

    # init the logging
    logdir = _get_logdir()
    logfile = os.path.join(
        logdir,
        apt_pkg.config.find(
            "Unattended-Upgrade::LogFile",
            # COMPAT only
            apt_pkg.config.find("APT::UnattendedUpgrades::LogFile",
                                "unattended-upgrades.log")))
    if not options.dry_run and not os.path.exists(logdir):
        os.makedirs(logdir)

    logging.basicConfig(level=logging.INFO,
                        format='%(asctime)s %(levelname)s %(message)s',
                        filename=logfile)
    # additional logging
    logger = logging.getLogger()
    mem_log = StringIO()
    if options.apt_debug:
        apt_pkg.config.set("Debug::pkgProblemResolver", "1")
        apt_pkg.config.set("Debug::pkgDepCache::AutoInstall", "1")
    if options.debug:
        logger.setLevel(logging.DEBUG)
        stdout_handler = logging.StreamHandler(sys.stdout)
        logger.addHandler(stdout_handler)
    elif options.verbose:
        logger.setLevel(logging.INFO)
        stdout_handler = logging.StreamHandler(sys.stdout)
        logger.addHandler(stdout_handler)
    # XXX: we always need memory logging if we use plugins
    # if apt_pkg.config.find("Unattended-Upgrade::Mail", ""):
    if True:
        mem_log_handler = logging.StreamHandler(mem_log)
        logger.addHandler(mem_log_handler)
    # Configure syslog if necessary
    syslogEnable = apt_pkg.config.find_b("Unattended-Upgrade::SyslogEnable",
                                         False)
    if syslogEnable:
        syslogFacility = apt_pkg.config.find(
            "Unattended-Upgrade::SyslogFacility",
            "daemon")
        syslogHandler = logging.handlers.SysLogHandler(
            address='/dev/log',
            facility=syslogFacility)  # type: ignore
        syslogHandler.setFormatter(
            logging.Formatter("unattended-upgrade: %(message)s"))
        known = syslogHandler.facility_names.keys()  # type: ignore
        if syslogFacility.lower() in known:
            logger.addHandler(syslogHandler)
            logging.info("Enabled logging to syslog via %s facility "
                         % syslogFacility)
        else:
            logging.warning("Syslog facility %s was not found"
                            % syslogFacility)
    return mem_log


def logged_in_users():
    # type: () -> AbstractSet[str]
    """Return a list of logged in users"""
    # the "users" command always returns a single line with:
    # "user1, user1, user2"
    users = subprocess.check_output(
        USERS, universal_newlines=True).rstrip('\n')
    return set(users.split())


def reboot_if_requested_and_needed():
    # type: () -> None
    """auto-reboot (if required and the config for this is set)"""
    if not os.path.exists(REBOOT_REQUIRED_FILE):
        return
    if not apt_pkg.config.find_b(
            "Unattended-Upgrade::Automatic-Reboot", False):
        return
    # see if we need to check for logged in users
    if not apt_pkg.config.find_b(
            "Unattended-Upgrade::Automatic-Reboot-WithUsers", True):
        users = logged_in_users()
        if users:
            msg = gettext.ngettext(
                "Found %s, but not rebooting because %s is logged in." % (
                    REBOOT_REQUIRED_FILE, users),
                "Found %s, but not rebooting because %s are logged in." % (
                    REBOOT_REQUIRED_FILE, users),
                len(users))
            logging.warning(msg)
            return
    # reboot at the specified time
    when = apt_pkg.config.find(
        "Unattended-Upgrade::Automatic-Reboot-Time", "now")
    logging.warning("Found %s, rebooting" % REBOOT_REQUIRED_FILE)
    cmd = ["/sbin/shutdown", "-r", when]
    try:
        shutdown_msg = subprocess.check_output(cmd, stderr=subprocess.STDOUT)
        if shutdown_msg.strip():
            logging.warning("Shutdown msg: %s", shutdown_msg.strip())
    except Exception as e:
        logging.error("Failed to issue shutdown: %s", e)


def write_stamp_file(filename):
    # type: (str) -> None
    statedir = os.path.join(apt_pkg.config.find_dir("Dir::State"), "periodic")
    if not os.path.exists(statedir):
        os.makedirs(statedir)
    with open(os.path.join(statedir, filename), "w"):
        pass


def check_stamp_file(filename):
    # type: (str) -> datetime.timedelta
    statedir = os.path.join(apt_pkg.config.find_dir("Dir::State"), "periodic")
    try:
        file_date = date.fromtimestamp(
            os.path.getmtime(os.path.join(statedir, filename)))
        return date.today() - file_date
    except OSError:
        return datetime.timedelta(days=0)


def exists_stamp_file(filename):
    # type: (str) -> bool
    statedir = os.path.join(apt_pkg.config.find_dir("Dir::State"), "periodic")
    return os.path.isfile(os.path.join(statedir, filename))


def reset_stamp_file(filename):
    # type: (str) -> None
    statedir = os.path.join(apt_pkg.config.find_dir("Dir::State"), "periodic")
    try:
        os.remove(os.path.join(statedir, filename))
    except OSError:
        pass


def try_to_upgrade(pkg,               # type: apt.Package
                   pkgs_to_upgrade,   # type: List[apt.Package]
                   cache,             # type: UnattendedUpgradesCache
                   ):
    # type: (...) -> None
    try:
        try:
            # try to adjust pkg itself first, if that throws an exception it
            # can't be upgraded on its own
            cache.adjust_candidate(pkg)
            if not pkg.is_upgradable and not apt_pkg.config.find_b(
                    "Unattended-Upgrade::Allow-downgrade", False):
                return
        except NoAllowedOriginError:
            return
        cache._cached_candidate_pkgnames.add(pkg.name)
        cache.mark_upgrade_adjusted(pkg, from_user=not pkg.is_auto_installed)
        if check_changes_for_sanity(cache, pkg):
            # add to packages to upgrade
            pkgs_to_upgrade.append(pkg)
        else:
            rewind_cache(cache, pkgs_to_upgrade)
    except (SystemError, NoAllowedOriginError) as e:
        # can't upgrade
        logging.warning(
            _("package %s upgradable but fails to "
                "be marked for upgrade (%s)"), pkg.name, e)
        rewind_cache(cache, pkgs_to_upgrade)


def candidate_version_changed(pkg,               # type: apt.Package
                              ):
    return (pkg.is_installed and pkg.candidate and pkg.installed
            and pkg.candidate.version != pkg.installed.version
            and apt_pkg.config.find_b(
                'Unattended-Upgrade::Allow-downgrade', False))


def calculate_upgradable_pkgs(cache,            # type: UnattendedUpgradesCache
                              options,          # type: Options
                              ):
    # type: (...) -> List[apt.Package]
    pkgs_to_upgrade = []  # type: List[apt.Package]

    # now do the actual upgrade
    for pkg in cache:
        if options.debug and pkg.is_upgradable \
           or candidate_version_changed(pkg):
            logging.debug("Checking: %s (%s)" % (
                getattr(pkg, "candidate", pkg.name),
                getattr(pkg.candidate, "origins", [])))

        if (pkg.is_upgradable or candidate_version_changed(pkg)
           and is_pkgname_in_whitelist(pkg.name, cache.whitelist)):
            try:
                ver_in_allowed_origin(pkg, cache.allowed_origins)
            except NoAllowedOriginError:
                continue
            try_to_upgrade(pkg,
                           pkgs_to_upgrade,
                           cache)

    if cache.get_changes():
        cache.clear()

    return pkgs_to_upgrade


def get_dpkg_log_content(logfile_dpkg, install_start_time):
    # type: (str, datetime.datetime) -> str
    logging.debug("Extracting content from %s since %s" % (
        logfile_dpkg, install_start_time))
    content = []
    found_start = False
    try:
        with io.open(logfile_dpkg, encoding='utf-8', errors='replace') as fp:
            # read until we find the last "Log started: "
            for line in fp.readlines():
                # scan for the first entry we need (minimal-step mode
                # creates a new stanza for each individual install)
                if not found_start and line.startswith("Log started: "):
                    stanza_start = LoggingDateTime.from_string(
                        line[len("Log started: "):-1])
                    if stanza_start >= install_start_time:
                        found_start = True
                if found_start:
                    # skip progress indicator until #860931 is fixed in apt
                    # and dpkg
                    if re.match(
                            "^\\(Reading database \\.\\.\\. ()|([0-9]+%)$",
                            line):
                        continue
                    content.append(line)
        return "".join(content)
    except FileNotFoundError:
        return ""


def get_auto_removable(cache):
    # type: (apt.Cache) -> AbstractSet[str]
    return {pkg.name for pkg in cache
            if pkg.is_auto_removable}


def is_autoremove_valid(cache,           # type: UnattendedUpgradesCache
                        pkgname,         # type: str
                        auto_removable,  # type: AbstractSet[str]
                        ):
    # type: (...) -> bool
    changes = cache.get_changes()
    if not changes:
        # package is already removed
        return True
    pkgnames = {pkg.name for pkg in changes}
    for pkg in changes:
        if not is_pkg_change_allowed(pkg, cache.blacklist, cache.whitelist,
                                     cache.strict_whitelist):
            logging.warning(
                _("Keeping the following auto-removable package(s) because "
                  "they include %s which is set to be kept unmodified: %s"),
                pkg.name, " ".join(sorted(pkgnames)))
            return False
    if not pkgnames.issubset(auto_removable):
        if pkgname != "":
            logging.warning(
                _("Keeping auto-removable %s package(s) because it would"
                  " also remove the following packages which should "
                  "be kept in this step: %s"), pkgname,
                " ".join(sorted(pkgnames - auto_removable)))
        else:
            logging.warning(
                _("Keeping %s auto-removable package(s) because it would"
                  " also remove the following packages which should "
                  "be kept in this step: %s"), len(auto_removable),
                " ".join(sorted(pkgnames - auto_removable)))

        return False
    for packagename in pkgnames:
        if cache.running_kernel_pkgs_regexp and \
           cache.running_kernel_pkgs_regexp.match(packagename):
            logging.warning(
                _("Keeping the following auto-removable package(s) because "
                  "they include %s which package is related to the running "
                  "kernel: %s"), packagename, " ".join(sorted(pkgnames)))
            return False
    if cache.install_count > 0:
        logging.error(
            "The following packages are marked for installation or upgrade "
            "which is not allowed when performing autoremovals: %s",
            " ".join([pkg.name for pkg in changes if not pkg.marked_delete]))
        return False
    return True


def do_auto_remove(cache,             # type: UnattendedUpgradesCache
                   auto_removable,    # type: AbstractSet[str]
                   logfile_dpkg,      # type: str
                   minimal_steps,     # type: bool
                   verbose=False,     # type: bool
                   dry_run=False      # type: bool
                   ):
    # type: (...) -> Tuple[bool, List[str], List[str]]
    res = True
    if not auto_removable:
        return (res, [], [])

    pkgs_removed = []         # type: List[str]
    pkgs_kept_installed = []  # type: List[str]
    if minimal_steps:
        for pkgname in auto_removable:
            if should_stop():
                pkgs_kept_installed = list(auto_removable - set(pkgs_removed))
                return (False, pkgs_removed, pkgs_kept_installed)
            logging.debug("marking %s for removal" % pkgname)
            if pkgname in pkgs_removed:
                continue
            cache[pkgname].mark_delete()
            if not is_autoremove_valid(cache, pkgname, auto_removable):
                # this situation can occur when removing newly unused packages
                # would also remove old unused packages which are not set
                # for removal, thus getting there is not handled as an error
                pkgs_kept_installed.append(pkgname)
                cache.clear()
                continue
            if not dry_run:
                changes = cache.get_changes()
                pkgnames = {pkg.name for pkg in changes}
                res, error = cache_commit(cache, logfile_dpkg, verbose)
                if not res:
                    break
                pkgs_removed.extend(pkgnames)
            else:
                cache.clear()
    else:
        for pkgname in auto_removable:
            cache[pkgname].mark_delete()
        if is_autoremove_valid(cache, "", auto_removable):
            # do it in one step
            if not dry_run:
                res, error = cache_commit(cache, logfile_dpkg, verbose)
            else:
                cache.clear()
        else:
            cache.clear()

    if res:
        logging.info(_("Packages that were successfully auto-removed: %s"),
                     " ".join(sorted(pkgs_removed)))
        logging.info(_("Packages that are kept back: %s"),
                     " ".join(sorted(pkgs_kept_installed)))
    if not res:
        cache.clear()
        logging.error(_("Auto-removing the packages failed!"))
        logging.error(_("Error message: %s"), error)
        logging.error(_("dpkg returned an error! See %s for details"),
                      logfile_dpkg)
    return (res, pkgs_removed, pkgs_kept_installed)


def clean_downloaded_packages(fetcher):
    # type: (apt_pkg.Acquire) -> None
    archivedir = os.path.dirname(
        apt_pkg.config.find_dir("Dir::Cache::archives"))
    for item in fetcher.items:
        if os.path.dirname(os.path.abspath(item.destfile)) == archivedir:
            try:
                os.unlink(item.destfile)
            except OSError:
                pass


def is_update_day():
    # type: () -> bool
    # check if patch days are configured
    patch_days = apt_pkg.config.value_list("Unattended-Upgrade::Update-Days")
    if not patch_days:
        return True
    # validate patch days
    today = date.today()
    # abbreviated localized dayname
    if today.strftime("%a") in patch_days:
        return True
    # full localized dayname
    if today.strftime("%A") in patch_days:
        return True
    # by number (Sun: 0, Mon: 1, ...)
    if today.strftime("%w") in patch_days:
        return True
    # today is not a patch day
    logging.info(
        "Skipping update check: today is %s,%s,%s but patch days are %s",
        today.strftime("%w"), today.strftime("%a"), today.strftime("%A"),
        ", ".join(patch_days))
    return False


def get_remaining_postpone_days():
    # type: () -> int
    postpone_for_days = apt_pkg.config.find_i(  # type: ignore[attr-defined]
        "Unattended-Upgrade::Postpone-For-Days", 0)
    elapsed = check_stamp_file(POSTPONE_STAMP_FILE)
    return max(0, (datetime.timedelta(days=postpone_for_days) - elapsed).days)


def update_kept_pkgs_file(kept_pkgs, kept_file):
    # type: (DefaultDict[str, List[str]], str) -> None
    if kept_pkgs:
        pkgs_all_origins = set()
        for origin_pkgs in kept_pkgs.values():
            pkgs_all_origins.update(origin_pkgs)
        try:
            with open(kept_file, "w") as kf:
                kf.write(" ".join(sorted(pkgs_all_origins)))
        except FileNotFoundError:
            logging.error(_("Could not open %s for saving list of packages "
                            "kept back." % kept_file))
    else:
        if os.path.exists(kept_file):
            os.remove(kept_file)


@contextlib.contextmanager
def try_nice(increment):
    old_priority = os.nice(0)
    try:
        try:
            # Check that we will be able to restore the priority
            os.nice(-1)
            os.nice(increment)
        except PermissionError:
            # So bad, we couldn't be nicier
            pass
        yield
    finally:
        os.nice(old_priority - os.nice(0))


def main(options, rootdir="/"):
    # type: (Options, str) -> int
    # useful for testing
    if not rootdir == "/":
        _setup_alternative_rootdir(rootdir)

    # see debian #776752
    install_start_time = datetime.datetime.now().replace(microsecond=0)

    # setup logging
    mem_log = _setup_logging(options)
    # get log
    logfile_dpkg = os.path.join(_get_logdir(), 'unattended-upgrades-dpkg.log')
    if not os.path.exists(logfile_dpkg):
        with open(logfile_dpkg, 'w'):
            pass

    # lock for the shutdown check
    shutdown_lock = apt_pkg.get_lock(LOCK_FILE)
    if shutdown_lock < 0:
        logging.error("Lock file is already taken, exiting")
        return 1

    plugin_manager = PluginManager()

    try:
        res = run(options, rootdir, mem_log, logfile_dpkg,
                  install_start_time)
        logging.debug("upgrade result: %s %s" % (res.success, res.result_str))

        if res.success and res.result_str:
            # complete, successful run
            update_kept_pkgs_file(res.pkgs_kept_back,
                                  os.path.join(rootdir, KEPT_PACKAGES_FILE))

        if res.result_str and not options.dry_run:
            # there is some meaningful result which is worth an email
            log_content = get_dpkg_log_content(logfile_dpkg,
                                               install_start_time)
            send_summary_mail(res.pkgs, res.success, res.result_str,
                              res.pkgs_kept_back, res.pkgs_removed,
                              res.pkgs_kept_installed, mem_log,
                              log_content)
            # report results to any plugin
            plugin_manager.postrun(res, mem_log, log_content)

        if res.update_stamp:
            # write timestamp file
            write_stamp_file("unattended-upgrades-stamp")
            if not options.dry_run:
                # check if the user wants a reboot
                reboot_if_requested_and_needed()
        os.close(shutdown_lock)
        if res.success:
            return 0
        else:
            return 1

    except Exception as e:
        logger = logging.getLogger()
        logger.exception(_("An error occurred: %s"), e)
        log_content = get_dpkg_log_content(logfile_dpkg,
                                           install_start_time)
        if not options.dry_run:
            send_summary_mail(["<unknown>"], False, _("An error occurred"),
                              None, [], [], mem_log, log_content)
        # Re-raise exceptions for apport
        raise


def mark_pkgs_to_upgrade(cache, pkgs_to_upgrade):
    # type (apt.Cache, List[str]) -> None
    for pkg_name in pkgs_to_upgrade:
        pkg = cache[pkg_name]
        if pkg.is_upgradable \
           or (pkg.is_installed
               and pkg.candidate.version != pkg.installed.version) \
            and apt_pkg.config.find_b("Unattended-Upgrade::Allow-downgrade",
                                      False):
            cache.mark_upgrade_adjusted(pkg,
                                        from_user=not pkg.is_auto_installed)
        elif not pkg.is_installed:
            cache.mark_install_adjusted(pkg, from_user=False)


def run(options,             # type: Options
        rootdir,             # type: str
        mem_log,             # type: Optional[StringIO]
        logfile_dpkg,        # type: str
        install_start_time,  # type: datetime.datetime
        ):
    # type: (...) -> UnattendedUpgradesResult

    # check if today is a patch day
    if not is_update_day():
        return UnattendedUpgradesResult(True)

    # check if u-u should be stopped already
    if should_stop():
        return UnattendedUpgradesResult(False)

    # check to see if want to auto-upgrade the devel release
    if apt_pkg.config.find("Unattended-Upgrade::DevRelease") == "auto":
        try:
            if DISTRO_ID.lower() == 'ubuntu':
                devel = (distro_info.UbuntuDistroInfo() .
                         devel(result="object"))
            elif DISTRO_ID.lower() == 'debian':
                devel = (distro_info.DebianDistroInfo() .
                         devel(result="object"))
            else:
                devel = (distro_info.DistroInfo(DISTRO_ID) .
                         devel(result="object"))
        except Exception as e:
            logging.warning("Could not figure out development release: %s" % e)
        else:
            if ((isinstance(devel, distro_info.DistroRelease)
                 and devel.series == DISTRO_CODENAME
                 and devel.release is not None
                 and devel.release - date.today() > DEVEL_UNTIL_RELEASE)):
                syslog.syslog((_("Not running on this development "
                                 "release before %s") %
                              (devel.release - DEVEL_UNTIL_RELEASE
                               - datetime.timedelta(days=1))))
                logging.warning(_("Not running on this development "
                                  "release before %s") %
                                (devel.release - DEVEL_UNTIL_RELEASE
                                 - datetime.timedelta(days=1)))
                return UnattendedUpgradesResult(True)

            logging.debug("Running on the development release")
    elif "(development branch)" in DISTRO_DESC and not\
            apt_pkg.config.find_b("Unattended-Upgrade::DevRelease", True):
        syslog.syslog(_("Not running on the development release."))
        logging.info(_("Not running on the development release."))
        return UnattendedUpgradesResult(True)

    logging.info(_("Starting unattended upgrades script"))

    # check and get lock
    try:
        apt_pkg.pkgsystem_lock()
    except SystemError:
        logging.error(_("Lock could not be acquired (another package "
                        "manager running?)"))
        print(_("Cache lock can not be acquired, exiting"))
        return UnattendedUpgradesResult(
            False, _("Lock could not be acquired"))

    # check if the journal is dirty and if so, take emergceny action
    # the alternative is to leave the system potentially unsecure until
    # the user comes in and fixes
    if is_dpkg_journal_dirty() and \
       apt_pkg.config.find_b("Unattended-Upgrade::AutoFixInterruptedDpkg",
                             True):
        logging.warning(
            _("Unclean dpkg state detected, trying to correct"))
        print(_("Unclean dpkg state detected, trying to correct"))
        env = copy.copy(os.environ)
        env["DPKG_FRONTEND_LOCKED"] = "1"
        try:
            with Unlocked():
                output = subprocess.check_output(
                    ["dpkg", "--force-confold", "--configure", "-a"],
                    env=env,
                    universal_newlines=True)
        except subprocess.CalledProcessError as e:
            output = e.output
        logging.warning(_("dpkg --configure -a output:\n%s"), output)

    # get a cache
    try:
        cache = UnattendedUpgradesCache(rootdir=rootdir)
    except SystemError as error:
        print(_("Apt returned an error, exiting"))
        print(_("error message: %s") % error)
        logging.error(_("Apt returned an error, exiting"))
        logging.error(_("error message: %s"), error)
        return UnattendedUpgradesResult(
            False, _("Apt returned an error, exiting"))

    if cache._depcache.broken_count > 0:
        print(_("Cache has broken packages, exiting"))
        logging.error(_("Cache has broken packages, exiting"))
        return UnattendedUpgradesResult(
            False, _("Cache has broken packages, exiting"))

    with try_nice(20):
        auto_removable = get_auto_removable(cache)

        # find out about the packages that are upgradable (in an
        # allowed_origin)
        pkgs_to_upgrade = calculate_upgradable_pkgs(cache, options)
        pkgs_to_upgrade.sort(key=lambda p: p.name)
        pkgs = [pkg.name for pkg in pkgs_to_upgrade]
        logging.debug("pkgs that look like they should be upgraded: %s"
                      % "\n".join(pkgs))

    # download what looks good
    mark_pkgs_to_upgrade(cache, pkgs)

    if options.debug:
        fetcher = apt_pkg.Acquire(apt.progress.text.AcquireProgress())
    else:
        fetcher = apt_pkg.Acquire()
    list = apt_pkg.SourceList()
    list.read_main_list()
    recs = cache._records
    pm = apt_pkg.PackageManager(cache._depcache)
    # don't start downloading during shutdown
    # TODO: download files one by one and check for stop request after each of
    # them
    if should_stop():
        return UnattendedUpgradesResult(False, _("Upgrade was interrupted"))
    try:
        pm.get_archives(fetcher, list, recs)
    except SystemError as e:
        logging.error(_("GetArchives() failed: %s"), e)
    try:
        res = fetcher.run()
        logging.debug("fetch.run() result: %s", res)
    except SystemError as e:
        logging.error("fetch.run() result: %s", e)

    if options.download_only:
        return UnattendedUpgradesResult(True)

    if cache.get_changes():
        cache.clear()

    pkg_conffile_prompt = False
    if dpkg_conffile_prompt():
        # now check the downloaded debs for conffile conflicts and build
        # a blacklist
        conffile_blacklist = []  # type: List[str]
        for item in fetcher.items:
            logging.debug("%s" % item)
            if item.status == item.STAT_ERROR:
                print(_("An error occurred: %s") % item.error_text)
                logging.error(_("An error occurred: %s"), item.error_text)
            if not item.complete:
                print(_("The URI %s failed to download, aborting") %
                      item.desc_uri)
                logging.error(_("The URI %s failed to download, aborting"),
                              item.desc_uri)
                return UnattendedUpgradesResult(
                    False, (_("The URI %s failed to download, aborting") %
                            item.desc_uri))
            if not os.path.exists(item.destfile):
                print(_("Download finished, but file %s not there?!?") %
                      item.destfile)
                logging.error("Download finished, but file %s not "
                              "there?!?", item.destfile)
                return UnattendedUpgradesResult(
                    False, (_("Download finished, but file %s not there?!?") %
                            item.destfile))
            if not item.is_trusted and not apt_pkg.config.find_b(
                    "APT::Get::AllowUnauthenticated", False):
                logging.debug("%s is blacklisted because it is not trusted")
                pkg_name = pkgname_from_deb(item.destfile)
                if not is_pkgname_in_blacklist(pkg_name, cache.blacklist):
                    conffile_blacklist.append("%s$" % re.escape(pkg_name))
            if not is_deb(item.destfile):
                logging.debug("%s is not a .deb file" % item)
                continue
            if conffile_prompt(item.destfile):
                # skip package (means to re-run the whole marking again
                # and making sure that the package will not be pulled in by
                # some other package again!)
                #
                # print to stdout to ensure that this message is part of
                # the cron mail (only if no summary mail is requested)
                email = apt_pkg.config.find("Unattended-Upgrade::Mail", "")
                if not email:
                    print(_("Package %s has conffile prompt and needs "
                            "to be upgraded manually") %
                          pkgname_from_deb(item.destfile))
                # log to the logfile
                logging.warning(_("Package %s has conffile prompt and "
                                  "needs to be upgraded manually"),
                                pkgname_from_deb(item.destfile))
                pkg_name = pkgname_from_deb(item.destfile)
                if not is_pkgname_in_blacklist(pkg_name, cache.blacklist):
                    conffile_blacklist.append("%s$" % re.escape(pkg_name))
                pkg_conffile_prompt = True

        # redo the selection about the packages to upgrade based on the new
        # blacklist
        logging.debug("Packages blacklist due to conffile prompts: %s"
                      % conffile_blacklist)
        # find out about the packages that are upgradable (in a allowed_origin)
        if len(conffile_blacklist) > 0:
            for regex in conffile_blacklist:
                cache.blacklist.append(regex)
            cache.apply_pinning(cache.pinning_from_regex_list(
                conffile_blacklist, NEVER_PIN))  # type: ignore
            old_pkgs_to_upgrade = pkgs_to_upgrade[:]
            pkgs_to_upgrade = []
            for pkg in old_pkgs_to_upgrade:
                logging.debug("Checking the black and whitelist: %s" %
                              (pkg.name))
                cache.mark_upgrade_adjusted(
                    pkg, from_user=not pkg.is_auto_installed)
                if check_changes_for_sanity(cache):
                    pkgs_to_upgrade.append(pkg)
                else:
                    logging.info(_("package %s not upgraded"), pkg.name)
                    cache.clear()
                    for pkg2 in pkgs_to_upgrade:
                        cache.call_adjusted(
                            apt.package.Package.mark_upgrade, pkg2,
                            from_user=not pkg2.is_auto_installed)
            if cache.get_changes():
                cache.clear()

    else:
        logging.debug("dpkg is configured not to cause conffile prompts")

    # auto-removals
    kernel_pkgs_remove_success = True  # type: bool
    kernel_pkgs_removed = []           # type: List[str]
    kernel_pkgs_kept_installed = []    # type: List[str]
    if (auto_removable and apt_pkg.config.find_b(
            "Unattended-Upgrade::Remove-Unused-Kernel-Packages", True)):
        # remove unused kernels before installing new ones because the newly
        # installed ones may fill up /boot and break the system right before
        # removing old ones could take place
        #
        # this step may also remove _auto-removable_ reverse dependencies
        # of kernel packages
        auto_removable_kernel_pkgs = {
            p for p in auto_removable
            if (cache.versioned_kernel_pkgs_regexp
                and cache.versioned_kernel_pkgs_regexp.match(p)
                and not cache.running_kernel_pkgs_regexp.match(p))}
        if auto_removable_kernel_pkgs:
            logging.info(_("Removing unused kernel packages: %s"),
                         " ".join(auto_removable_kernel_pkgs))
            (kernel_pkgs_remove_success,
             kernel_pkgs_removed,
             kernel_pkgs_kept_installed) = do_auto_remove(
                cache, auto_removable_kernel_pkgs, logfile_dpkg,
                options.minimal_upgrade_steps,
                options.verbose or options.debug, options.dry_run)
            auto_removable = get_auto_removable(cache)

    previous_autoremovals = auto_removable
    if apt_pkg.config.find_b(
            "Unattended-Upgrade::Remove-Unused-Dependencies", False):
        pending_autoremovals = previous_autoremovals
    else:
        pending_autoremovals = set()

    # exit if there is nothing to do and nothing to report
    if (len(pending_autoremovals) == 0
            and len(pkgs_to_upgrade) == 0):
        logging.info(_("No packages found that can be upgraded unattended "
                       "and no pending auto-removals"))

        pkgs_kept_back = cache.find_kept_packages(options.dry_run)
        return UnattendedUpgradesResult(
            kernel_pkgs_remove_success,
            _("No packages found that can be upgraded unattended and no "
              "pending auto-removals"),
            pkgs_removed=kernel_pkgs_removed,
            pkgs_kept_back=pkgs_kept_back,
            pkgs_kept_installed=kernel_pkgs_kept_installed,
            update_stamp=True)

    # check if its configured for install on shutdown, if so, the
    # environment UNATTENDED_UPGRADES_FORCE_INSTALL_ON_SHUTDOWN will
    # be set by the unatteded-upgrades-shutdown script
    if ("UNATTENDED_UPGRADES_FORCE_INSTALL_ON_SHUTDOWN" not in os.environ
        and apt_pkg.config.find_b(
            "Unattended-Upgrade::InstallOnShutdown", False)):
        logger = logging.getLogger()
        logger.debug("Configured to install on shutdown, so exiting now")
        return UnattendedUpgradesResult(True)

    # check if we are in dry-run mode
    if options.dry_run:
        logging.info("Option --dry-run given, *not* performing real actions")
        apt_pkg.config.set("Debug::pkgDPkgPM", "1")

    # do the install based on the new list of pkgs
    pkgs = [pkg.name for pkg in pkgs_to_upgrade]
    logging.info(_("Packages that will be upgraded: %s"), " ".join(pkgs))

    # only perform install step if we actually have packages to install
    pkg_install_success = True
    if len(pkgs_to_upgrade) > 0:
        # do install
        result = install_or_postpone(cache, pkgs, options, logfile_dpkg)
        if result == InstallResult.POSTPONED:
            return UnattendedUpgradesResult(True)
        else:
            pkg_install_success = result == InstallResult.SUCCESS

    # Was the overall run succesful: only if everything installed
    # fine and nothing was held back because of a conffile prompt.
    logging.debug("kernel_pkgs_remove_success: %s" % kernel_pkgs_remove_success)
    logging.debug("pkg_install_success: %s", pkg_install_success)
    logging.debug("pkg_conffile_prompt: %s" % pkg_conffile_prompt)
    successful_run = (kernel_pkgs_remove_success and pkg_install_success
                      and not pkg_conffile_prompt)

    # now check if any auto-removing needs to be done
    if cache._depcache.broken_count > 0:
        print(_("Cache has broken packages, exiting"))
        logging.error(_("Cache has broken packages, exiting"))
        return UnattendedUpgradesResult(
            False, _("Cache has broken packages, exiting"), pkgs=pkgs)

    # make sure we start autoremovals with a clear cache
    if cache.get_changes():
        cache.clear()

    # the user wants *all* auto-removals to be removed
    # (unless u-u got signalled to stop gracefully quickly)
    pkgs_removed = []         # type: List[str]
    pkgs_kept_installed = []  # type: List[str]
    if ((apt_pkg.config.find_b(
            "Unattended-Upgrade::Remove-Unused-Dependencies", False)
         and not SIGNAL_STOP_REQUEST)):
        auto_removals = get_auto_removable(cache)
        (pkg_remove_success,
         pkgs_removed,
         pkgs_kept_installed) = do_auto_remove(
            cache, auto_removals, logfile_dpkg, options.minimal_upgrade_steps,
            options.verbose or options.debug,
            options.dry_run)
        logging.debug("pkg_remove_success: %s" % pkg_remove_success)
        successful_run = successful_run and pkg_remove_success
    # the user wants *only new* auto-removals to be removed
    elif apt_pkg.config.find_b(
            "Unattended-Upgrade::Remove-New-Unused-Dependencies", True):
        # calculate the new auto-removals
        new_pending_autoremovals = get_auto_removable(cache)
        auto_removals = new_pending_autoremovals - previous_autoremovals
        (pkg_remove_success,
         pkgs_removed,
         pkgs_kept_installed) = do_auto_remove(
            cache, auto_removals, logfile_dpkg, options.minimal_upgrade_steps,
            options.verbose or options.debug,
            options.dry_run)
        logging.debug("pkg_remove_success: %s" % pkg_remove_success)
        successful_run = successful_run and pkg_remove_success

    logging.debug("InstCount=%i DelCount=%i BrokenCount=%i"
                  % (cache._depcache.inst_count,
                     cache._depcache.del_count,
                     cache._depcache.broken_count))

    # clean after success install (if needed)
    keep_key = "Unattended-Upgrade::Keep-Debs-After-Install"
    if (not apt_pkg.config.find_b(keep_key, False)
            and not options.dry_run
            and pkg_install_success):
        clean_downloaded_packages(fetcher)

    pkgs_kept_back = cache.find_kept_packages(options.dry_run)
    return UnattendedUpgradesResult(
        successful_run, _("All upgrades installed"), pkgs,
        pkgs_kept_back,
        kernel_pkgs_removed + pkgs_removed,
        kernel_pkgs_kept_installed + pkgs_kept_installed,
        update_stamp=True)


class Options:
    def __init__(self):
        self.download_only = False
        self.dry_run = False
        self.debug = False
        self.apt_debug = False
        self.verbose = False
        self.minimal_upgrade_steps = False


if __name__ == "__main__":
    localesApp = "unattended-upgrades"
    localesDir = "/usr/share/locale"
    gettext.bindtextdomain(localesApp, localesDir)
    gettext.textdomain(localesApp)

    # set debconf to NON_INTERACTIVE
    os.environ["DEBIAN_FRONTEND"] = "noninteractive"

    # this ensures the commandline is logged in /var/log/apt/history.log
    apt_pkg.config.set("Commandline::AsString", " ".join(sys.argv))

    # COMPAT with the mispelling
    minimal_steps_default = (
        apt_pkg.config.find_b("Unattended-Upgrades::MinimalSteps", True)
        and apt_pkg.config.find_b("Unattended-Upgrade::MinimalSteps", True))

    # init the options
    parser = OptionParser()
    parser.add_option("-d", "--debug",
                      action="store_true",
                      default=apt_pkg.config.find_b(
                          "Unattended-Upgrade::Debug", False),
                      help=_("print debug messages"))
    parser.add_option("", "--apt-debug",
                      action="store_true", default=False,
                      help=_("make apt/libapt print verbose debug messages"))
    parser.add_option("-v", "--verbose",
                      action="store_true",
                      default=apt_pkg.config.find_b(
                          "Unattended-Upgrade::Verbose", False),
                      help=_("print info messages"))
    parser.add_option("", "--dry-run",
                      action="store_true", default=False,
                      help=_("Simulation, download but do not install"))
    parser.add_option("", "--download-only",
                      action="store_true", default=False,
                      help=_("Only download, do not even try to install."))
    parser.add_option("", "--minimal-upgrade-steps",
                      action="store_true", default=minimal_steps_default,
                      help=_("Upgrade in minimal steps (and allow "
                             "interrupting with SIGTERM) (default)"))
    parser.add_option("", "--no-minimal-upgrade-steps",
                      action="store_false", default=minimal_steps_default,
                      dest="minimal_upgrade_steps",
                      help=_("Upgrade all packages together instead of in "
                             "smaller sets"))
    parser.add_option("", "--minimal_upgrade_steps",
                      action="store_true",
                      help=SUPPRESS_HELP,
                      default=minimal_steps_default)
    options = cast(Options, (parser.parse_args())[0])

    if os.getuid() != 0:
        print(_("You need to be root to run this application"))
        sys.exit(1)

    # ensure that we are not killed when the terminal goes away e.g. on
    # shutdown
    signal.signal(signal.SIGHUP, signal.SIG_IGN)

    # setup signal handler for graceful stopping
    signal.signal(signal.SIGTERM, signal_handler)

    # write pid to let other processes find this one
    pidf = os.path.join(apt_pkg.config.find_dir("Dir"),
                        "var", "run", "unattended-upgrades.pid")
    # clean up pid file on exit
    with open(pidf, "w") as fp:
        fp.write("%s" % os.getpid())
    atexit.register(os.remove, pidf)

    # run the main code
    sys.exit(main(options))

Filemanager

Name Type Size Permission Actions
X11 Folder 0755
GET File 15.87 KB 0755
HEAD File 15.87 KB 0755
POST File 15.87 KB 0755
X File 274 B 0755
Xephyr File 2.67 MB 0755
Xorg File 274 B 0755
Xwayland File 2.76 MB 0755
[ File 46.51 KB 0755
aa-enabled File 18.38 KB 0755
aa-exec File 18.38 KB 0755
aa-features-abi File 18.38 KB 0755
ab File 58.51 KB 0755
aconnect File 22.45 KB 0755
acpidbg File 1.58 KB 0755
add-apt-repository File 24.42 KB 0755
addr2line File 30.78 KB 0755
airscan-discover File 154.93 KB 0755
alsabat File 50.52 KB 0755
alsaloop File 91.41 KB 0755
alsamixer File 100.37 KB 0755
alsatplg File 86.45 KB 0755
alsaucm File 34.91 KB 0755
amidi File 30.46 KB 0755
amixer File 66.53 KB 0755
apg File 274 B 0755
apgbfm File 26.38 KB 0755
aplay File 86.5 KB 0755
aplaymidi File 26.46 KB 0755
aplaymidi2 File 22.47 KB 0755
apport-bug File 2.27 KB 0755
apport-cli File 13.56 KB 0755
apport-collect File 2.27 KB 0755
apport-unpack File 3.7 KB 0755
appres File 14.38 KB 0755
appstreamcli File 146.3 KB 0755
apropos File 47.36 KB 0755
apt File 18.46 KB 0755
apt-add-repository File 24.42 KB 0755
apt-cache File 90.54 KB 0755
apt-cdrom File 30.54 KB 0755
apt-config File 30.47 KB 0755
apt-extracttemplates File 26.53 KB 0755
apt-ftparchive File 246.55 KB 0755
apt-get File 58.54 KB 0755
apt-mark File 70.54 KB 0755
apt-sortpkgs File 42.47 KB 0755
aptdcon File 1.01 KB 0755
ar File 54.56 KB 0755
arch File 34.59 KB 0755
arecord File 86.5 KB 0755
arecordmidi File 34.47 KB 0755
arecordmidi2 File 26.48 KB 0755
arm2hpdl File 14.31 KB 0755
as File 795.52 KB 0755
aseqdump File 34.45 KB 0755
aseqnet File 22.51 KB 0755
aseqsend File 22.46 KB 0755
aspell File 162.55 KB 0755
aspell-import File 2 KB 0755
atobm File 14.3 KB 0755
awk File 190.84 KB 0755
axfer File 90.45 KB 0755
b2sum File 54.59 KB 0755
baobab File 302.52 KB 0755
base32 File 42.59 KB 0755
base64 File 42.59 KB 0755
basename File 34.59 KB 0755
basenc File 50.59 KB 0755
bash File 1.66 MB 0755
bashbug File 6.86 KB 0755
bc File 90.82 KB 0755
bdftopcf File 42.56 KB 0755
bdftruncate File 14.38 KB 0755
bitmap File 106.31 KB 0755
bluemoon File 38.45 KB 0755
bluetooth-sendto File 30.48 KB 0755
bluetoothctl File 574.27 KB 0755
bmtoa File 14.32 KB 0755
boltctl File 122.84 KB 0755
bpftrace File 4.57 MB 0755
bpftrace-aotrt File 3.2 MB 0755
brltty File 1.13 MB 0755
brltty-atb File 218.63 KB 0755
brltty-clip File 214.57 KB 0755
brltty-ctb File 330.8 KB 0755
brltty-hid File 274.84 KB 0755
brltty-ktb File 603.28 KB 0755
brltty-lscmds File 250.58 KB 0755
brltty-morse File 286.64 KB 0755
brltty-trtxt File 274.7 KB 0755
brltty-ttb File 318.88 KB 0755
brltty-tune File 302.7 KB 0755
broadwayd File 126.46 KB 0755
browse File 31.53 KB 0755
btattach File 30.45 KB 0755
btmgmt File 186.56 KB 0755
btmon File 1.16 MB 0755
btrfs File 1.49 MB 0755
btrfs-convert File 884.63 KB 0755
btrfs-find-root File 796.63 KB 0755
btrfs-image File 840.63 KB 0755
btrfs-map-logical File 796.63 KB 0755
btrfs-select-super File 792.63 KB 0755
btrfsck File 1.49 MB 0755
btrfstune File 832.63 KB 0755
bunzip2 File 38.45 KB 0755
busctl File 102.6 KB 0755
busybox File 2.34 MB 0755
bwrap File 82.54 KB 0755
bzcat File 38.45 KB 0755
bzcmp File 2.17 KB 0755
bzdiff File 2.17 KB 0755
bzegrep File 3.69 KB 0755
bzexe File 4.78 KB 0755
bzfgrep File 3.69 KB 0755
bzgrep File 3.69 KB 0755
bzip2 File 38.45 KB 0755
bzip2recover File 18.38 KB 0755
bzless File 1.27 KB 0755
bzmore File 1.27 KB 0755
c++filt File 26.34 KB 0755
c89 File 428 B 0755
c89-gcc File 428 B 0755
c99 File 454 B 0755
c99-gcc File 454 B 0755
c_rehash File 6.67 KB 0755
calibrate_ppa File 26.38 KB 0755
canberra-gtk-play File 18.3 KB 0755
cancel File 18.38 KB 0755
captoinfo File 94.49 KB 0755
cat File 42.54 KB 0755
catman File 30.84 KB 0755
cc File 1.13 MB 0755
cd-create-profile File 26.38 KB 0755
cd-fix-profile File 30.38 KB 0755
cd-iccdump File 14.38 KB 0755
cd-it8 File 26.38 KB 0755
certutil File 186.93 KB 0755
cgi-fcgi File 18.23 KB 0755
chacl File 18.3 KB 0755
chage File 83.23 KB 2755
chardet File 221 B 0755
chardetect File 221 B 0755
chattr File 14.38 KB 0755
chcon File 66.59 KB 0755
check-language-support File 2.71 KB 0755
checkgid File 14.38 KB 0755
chfn File 71.16 KB 4755
chgrp File 66.59 KB 0755
chktest File 14.38 KB 0755
chmod File 62.59 KB 0755
choom File 22.45 KB 0755
chown File 66.59 KB 0755
chrt File 30.45 KB 0755
chsh File 47.79 KB 4755
chvt File 14.45 KB 0755
cifsiostat File 26.55 KB 0755
ciptool File 38.56 KB 0755
ckbcomp File 147.14 KB 0755
cksum File 106.6 KB 0755
clear File 14.38 KB 0755
clear_console File 14.3 KB 0755
cloud-id File 972 B 0755
cloud-init File 976 B 0755
cloud-init-per File 2.06 KB 0755
cmp File 50.47 KB 0755
cmsutil File 46.47 KB 0755
codepage File 14.37 KB 0755
col File 22.46 KB 0755
colcrt File 14.46 KB 0755
colormgr File 58.45 KB 0755
colrm File 14.46 KB 0755
column File 38.46 KB 0755
comm File 38.59 KB 0755
corelist File 15.01 KB 0755
cp File 142.59 KB 0755
cpan File 8.16 KB 0755
cpan5.40-x86_64-linux-gnu File 8.18 KB 0755
cpio File 142.02 KB 0755
cpp File 1.13 MB 0755
cpp-14 File 1.13 MB 0755
cpupower File 1.58 KB 0755
crash File 13.91 MB 0755
crlutil File 98.48 KB 0755
crontab File 42.81 KB 2755
csplit File 54.59 KB 0755
ctstat File 22.73 KB 0755
cupstestppd File 74.45 KB 0755
curl File 310.48 KB 0755
cut File 42.59 KB 0755
cvt File 14.23 KB 0755
cvtsudoers File 377.3 KB 0755
dash File 146.84 KB 0755
date File 106.59 KB 0755
dbus-cleanup-sockets File 14.37 KB 0755
dbus-daemon File 242.72 KB 0755
dbus-monitor File 38.37 KB 0755
dbus-run-session File 14.37 KB 0755
dbus-send File 42.37 KB 0755
dbus-update-activation-environment File 18.37 KB 0755
dbus-uuidgen File 14.37 KB 0755
dbxtool File 22.45 KB 0755
dc File 50.24 KB 0755
dconf File 62.3 KB 0755
dd File 66.62 KB 0755
ddstdecode File 18.31 KB 0755
deallocvt File 14.45 KB 0755
deb-systemd-helper File 23.79 KB 0755
deb-systemd-invoke File 6.97 KB 0755
debconf File 2.8 KB 0755
debconf-apt-progress File 11.57 KB 0755
debconf-communicate File 623 B 0755
debconf-copydb File 1.68 KB 0755
debconf-escape File 668 B 0755
debconf-set-selections File 3.14 KB 0755
debconf-show File 1.78 KB 0755
debian-distro-info File 31.03 KB 0755
deja-dup File 402.59 KB 0755
delv File 61.4 KB 0755
derdump File 30.46 KB 0755
desktop-file-edit File 96.57 KB 0755
desktop-file-install File 96.57 KB 0755
desktop-file-validate File 80.85 KB 0755
df File 79.06 KB 0755
dh_bash-completion File 4.42 KB 0755
dh_installxmlcatalogs File 9.22 KB 0755
dh_perl_openssl File 1.53 KB 0755
diff File 154.63 KB 0755
diff3 File 66.59 KB 0755
dig File 154.95 KB 0755
dir File 155.02 KB 0755
dircolors File 46.59 KB 0755
dirmngr File 545.84 KB 0755
dirmngr-client File 55 KB 0755
dirname File 34.46 KB 0755
distro-info File 26.97 KB 0755
dmesg File 80.78 KB 0755
dnsdomainname File 22.3 KB 0755
do-release-upgrade File 9.05 KB 0755
domainname File 22.3 KB 0755
dpkg File 371.2 KB 0755
dpkg-deb File 162.66 KB 0755
dpkg-divert File 134.82 KB 0755
dpkg-maintscript-helper File 20.63 KB 0755
dpkg-query File 158.84 KB 0755
dpkg-realpath File 38.45 KB 0755
dpkg-split File 110.61 KB 0755
dpkg-statoverride File 54.63 KB 0755
dpkg-trigger File 46.61 KB 0755
driverless File 30.47 KB 0755
driverless-fax File 591 B 0755
du File 106.6 KB 0755
dumpkeys File 162.93 KB 0755
duplicity File 968 B 0755
dvipdf File 1007 B 0755
eatmydata File 2.74 KB 0755
ec2metadata File 8.38 KB 0755
echo File 34.46 KB 0755
ed File 70.63 KB 0755
editor File 328.65 KB 0755
editres File 72.77 KB 0755
efibootdump File 22.38 KB 0755
efibootmgr File 47.77 KB 0755
egrep File 41 B 0755
eject File 42.3 KB 0755
elfedit File 34.79 KB 0755
enc2xs File 40.97 KB 0755
encguess File 2.99 KB 0755
enchant-2 File 22.38 KB 0755
enchant-lsmod-2 File 14.38 KB 0755
env File 50.99 KB 0755
envsubst File 38.46 KB 0755
eog File 14.45 KB 0755
eps2eps File 639 B 0755
eqn File 204.52 KB 0755
esc-m File 14.16 KB 0755
eutp File 26.23 KB 0755
ex File 2.16 MB 0755
expand File 38.61 KB 0755
expiry File 22.63 KB 2755
expr File 46.49 KB 0755
factor File 70.59 KB 0755
fallocate File 26.45 KB 0755
false File 34.46 KB 0755
fc-cache File 22.45 KB 0755
fc-cat File 18.45 KB 0755
fc-conflist File 14.45 KB 0755
fc-list File 14.45 KB 0755
fc-match File 14.45 KB 0755
fc-pattern File 14.45 KB 0755
fc-query File 14.45 KB 0755
fc-scan File 14.45 KB 0755
fc-validate File 14.45 KB 0755
fcgistarter File 14.38 KB 0755
fgconsole File 14.45 KB 0755
fgrep File 41 B 0755
file File 30.6 KB 0755
file-roller File 562.61 KB 0755
file2brl File 26.3 KB 0755
find File 207.55 KB 0755
findmnt File 75.92 KB 0755
firefox File 2.32 KB 0755
flock File 26.56 KB 0755
fmt File 42.59 KB 0755
fold File 38.59 KB 0755
fonttosfnt File 46.48 KB 0755
foo2ddst File 34.96 KB 0755
foo2ddst-wrapper File 16.86 KB 0755
foo2hbpl2 File 30.98 KB 0755
foo2hbpl2-wrapper File 17.91 KB 0755
foo2hiperc File 42.99 KB 0755
foo2hiperc-wrapper File 18.11 KB 0755
foo2hp File 42.96 KB 0755
foo2hp2600-wrapper File 18.75 KB 0755
foo2lava File 42.99 KB 0755
foo2lava-wrapper File 19.61 KB 0755
foo2oak File 34.9 KB 0755
foo2oak-wrapper File 17.45 KB 0755
foo2qpdl File 43.02 KB 0755
foo2qpdl-wrapper File 19.06 KB 0755
foo2slx File 30.99 KB 0755
foo2slx-wrapper File 17.19 KB 0755
foo2xqx File 34.99 KB 0755
foo2xqx-wrapper File 17.16 KB 0755
foo2zjs File 43 KB 0755
foo2zjs-icc2ps File 14.39 KB 0755
foo2zjs-pstops File 2.93 KB 0755
foo2zjs-wrapper File 25.34 KB 0755
foomatic-rip File 115.48 KB 0755
fprintd-delete File 94.45 KB 0755
fprintd-enroll File 94.94 KB 0755
fprintd-list File 90.45 KB 0755
fprintd-verify File 90.45 KB 0755
free File 26.45 KB 0755
ftp File 182.9 KB 0755
funzip File 26.45 KB 0755
fuser File 43.42 KB 0755
fusermount File 38.45 KB 4755
fusermount3 File 38.45 KB 4755
fwupdmgr File 122.38 KB 0755
fwupdtool File 130.38 KB 0755
gamemoded File 166.73 KB 0755
gamma4scanimage File 14.38 KB 0755
gapplication File 22.46 KB 0755
gatttool File 126.56 KB 0755
gcalccmd File 286.46 KB 0755
gcc File 1.13 MB 0755
gcc-14 File 1.13 MB 0755
gcc-ar File 30.66 KB 0755
gcc-ar-14 File 30.66 KB 0755
gcc-nm File 30.66 KB 0755
gcc-nm-14 File 30.66 KB 0755
gcc-ranlib File 30.66 KB 0755
gcc-ranlib-14 File 30.66 KB 0755
gcore File 3.62 KB 0755
gcov File 468.19 KB 0755
gcov-14 File 468.19 KB 0755
gcov-dump File 380.14 KB 0755
gcov-dump-14 File 380.14 KB 0755
gcov-tool File 408.23 KB 0755
gcov-tool-14 File 408.23 KB 0755
gcr-viewer File 14.37 KB 0755
gcr-viewer-gtk4 File 34.45 KB 0755
gdb File 11.23 MB 0755
gdb-add-index File 4.55 KB 0755
gdbtui File 126 B 0755
gdbus File 54.46 KB 0755
gdctl File 51.15 KB 0755
gdk-pixbuf-csource File 14.4 KB 0755
gdk-pixbuf-pixdata File 14.38 KB 0755
gdk-pixbuf-thumbnailer File 18.47 KB 0755
gdm-config File 50.75 KB 0755
gdmflexiserver File 22.94 KB 0755
gencat File 34.52 KB 0755
geqn File 204.52 KB 0755
getconf File 26.44 KB 0755
getent File 38.8 KB 0755
getfacl File 30.38 KB 0755
getkeycodes File 14.45 KB 0755
getopt File 22.45 KB 0755
gettext File 38.46 KB 0755
gettext.sh File 5.05 KB 0755
ghostscript File 14.23 KB 0755
ginstall-info File 47.31 KB 0755
gio File 110.48 KB 0755
gio-querymodules File 18.38 KB 0755
gipddecode File 18.31 KB 0755
gjs File 22.71 KB 0755
gjs-console File 22.71 KB 0755
glib-compile-schemas File 54.46 KB 0755
gmake File 344.14 KB 0755
gnome-calculator File 822.91 KB 0755
gnome-calendar File 884.62 KB 0755
gnome-characters File 253 B 0755
gnome-clocks File 458.65 KB 0755
gnome-control-center File 4.28 MB 0755
gnome-disk-image-mounter File 22.46 KB 0755
gnome-disks File 687.57 KB 0755
gnome-extensions File 78.53 KB 0755
gnome-font-viewer File 82.73 KB 0755
gnome-help File 58.3 KB 0755
gnome-keyring File 22.62 KB 0755
gnome-keyring-3 File 22.62 KB 0755
gnome-keyring-daemon File 1.07 MB 0755
gnome-language-selector File 1.41 KB 0755
gnome-logs File 170.88 KB 0755
gnome-power-statistics File 66.43 KB 0755
gnome-session File 958 B 0755
gnome-session-inhibit File 22.38 KB 0755
gnome-session-properties File 66.41 KB 0755
gnome-session-quit File 14.68 KB 0755
gnome-shell File 30.8 KB 0755
gnome-shell-extension-tool File 1.67 KB 0755
gnome-shell-test-tool File 11.12 KB 0755
gnome-system-monitor File 427.49 KB 0755
gnome-terminal File 91.78 KB 0755
gnome-terminal.wrapper File 6.06 KB 0755
gnome-text-editor File 654.7 KB 0755
gnome-thumbnail-font File 26.47 KB 0755
gnome-www-browser File 2.32 KB 0755
gp-archive File 34.59 KB 0755
gp-collect-app File 54.42 KB 0755
gp-display-html File 630.35 KB 0755
gp-display-src File 30.41 KB 0755
gp-display-text File 166.42 KB 0755
gpasswd File 78.54 KB 4755
gpg File 1.3 MB 0755
gpg-agent File 397.59 KB 0755
gpg-connect-agent File 87.38 KB 0755
gpg-wks-client File 147.44 KB 0755
gpgconf File 119.44 KB 0755
gpgparsemail File 34.38 KB 0755
gpgsm File 577.44 KB 0755
gpgsplit File 26.62 KB 0755
gpgtar File 75.91 KB 0755
gpgv File 355.22 KB 0755
gpic File 228.12 KB 0755
gprof File 99.86 KB 0755
gprofng File 22.41 KB 0755
gprofng-archive File 34.59 KB 0755
gprofng-collect-app File 54.42 KB 0755
gprofng-display-html File 630.35 KB 0755
gprofng-display-src File 30.41 KB 0755
gprofng-display-text File 166.42 KB 0755
gpu-manager File 66.9 KB 0755
grdctl File 74.46 KB 0755
grep File 182.45 KB 0755
gresource File 26.38 KB 0755
groff File 102.58 KB 0755
grog File 18.75 KB 0755
grops File 202.62 KB 0755
grotty File 130.58 KB 0755
groups File 38.59 KB 0755
growpart File 29.19 KB 0755
grub-editenv File 401.24 KB 0755
grub-file File 749.96 KB 0755
grub-fstest File 871.4 KB 0755
grub-glue-efi File 102.96 KB 0755
grub-kbdcomp File 1.64 KB 0755
grub-menulst2cfg File 87.27 KB 0755
grub-mkfont File 131.52 KB 0755
grub-mkimage File 381.34 KB 0755
grub-mklayout File 107.3 KB 0755
grub-mknetdir File 437.85 KB 0755
grub-mkpasswd-pbkdf2 File 115.4 KB 0755
grub-mkrelpath File 259.87 KB 0755
grub-mkrescue File 1.01 MB 0755
grub-mkstandalone File 522.24 KB 0755
grub-mount File 694.29 KB 0755
grub-render-label File 766.3 KB 0755
grub-script-check File 126.84 KB 0755
grub-syslinux2cfg File 706.79 KB 0755
gs File 14.23 KB 0755
gsbj File 350 B 0755
gsdj File 352 B 0755
gsdj500 File 352 B 0755
gsettings File 30.38 KB 0755
gslj File 353 B 0755
gslp File 350 B 0755
gsnd File 277 B 0755
gst-device-monitor-1.0 File 22.4 KB 0755
gst-discoverer-1.0 File 38.48 KB 0755
gst-inspect-1.0 File 66.55 KB 0755
gst-launch-1.0 File 38.48 KB 0755
gst-play-1.0 File 54.48 KB 0755
gst-stats-1.0 File 34.46 KB 0755
gst-tester-1.0 File 18.38 KB 0755
gst-typefind-1.0 File 18.46 KB 0755
gstack File 2.98 KB 0755
gstreamer-codec-install File 22.23 KB 0755
gtbl File 154.55 KB 0755
gted File 654.7 KB 0755
gtf File 18.38 KB 0755
gtk-builder-tool File 34.8 KB 0755
gtk-encode-symbolic-svg File 22.48 KB 0755
gtk-launch File 18.53 KB 0755
gtk-query-settings File 14.38 KB 0755
gtk-update-icon-cache File 42.65 KB 0755
gtk4-broadwayd File 150.46 KB 0755
gtk4-builder-tool File 82.79 KB 0755
gtk4-encode-symbolic-svg File 11.71 MB 0755
gtk4-image-tool File 38.55 KB 0755
gtk4-launch File 18.53 KB 0755
gtk4-path-tool File 50.45 KB 0755
gtk4-query-settings File 14.38 KB 0755
gtk4-rendernode-tool File 46.45 KB 0755
gtk4-update-icon-cache File 42.65 KB 0755
gunzip File 2.28 KB 0755
gzexe File 6.29 KB 0755
gzip File 123.32 KB 0755
h2ph File 28.15 KB 0755
h2xs File 59.51 KB 0755
hardlink File 46.56 KB 0755
hbpldecode File 30.39 KB 0755
hciattach File 60.53 KB 0755
hciconfig File 158.56 KB 0755
hcitool File 166.16 KB 0755
hd File 54.47 KB 0755
head File 46.59 KB 0755
heif-thumbnailer File 34.4 KB 0755
helpztags File 2.46 KB 0755
hex2hcd File 18.45 KB 0755
hexdump File 54.47 KB 0755
hipercdecode File 18.31 KB 0755
host File 118.97 KB 0755
hostid File 34.59 KB 0755
hostname File 22.3 KB 0755
hostnamectl File 34.46 KB 0755
hp-align File 9.14 KB 0755
hp-check File 39.2 KB 0755
hp-clean File 7.05 KB 0755
hp-colorcal File 9.08 KB 0755
hp-config_usb_printer File 6.98 KB 0755
hp-doctor File 12.69 KB 0755
hp-firmware File 6.47 KB 0755
hp-info File 6.26 KB 0755
hp-levels File 6.85 KB 0755
hp-logcapture File 12.15 KB 0755
hp-makeuri File 5.6 KB 0755
hp-pkservice File 3.13 KB 0755
hp-plugin File 13.62 KB 0755
hp-plugin-ubuntu File 719 B 0755
hp-probe File 7.98 KB 0755
hp-query File 4.94 KB 0755
hp-scan File 88.25 KB 0755
hp-setup File 37.26 KB 0755
hp-testpage File 5.98 KB 0755
hp-timedate File 3.31 KB 0755
htcacheclean File 38.39 KB 0755
htdbm File 26.38 KB 0755
htdigest File 14.38 KB 0755
htpasswd File 30.38 KB 0755
httpserv File 38.4 KB 0755
hwe-support-status File 11.24 KB 0755
i386 File 26.73 KB 0755
ibd2sdi File 278.98 KB 0755
ibus File 86.45 KB 0755
ibus-daemon File 230.5 KB 0755
ibus-setup File 1.15 KB 0755
ibus-table-createdb File 1.11 KB 0755
iceauth File 42.5 KB 0755
ico File 50.44 KB 0755
iconv File 66.59 KB 0755
id File 42.59 KB 0755
iecset File 26.45 KB 0755
ijs_pxljr File 34.53 KB 0755
im-config File 11.03 KB 0755
im-launch File 2.07 KB 0755
inetutils-telnet File 221.9 KB 0755
info File 245.8 KB 0755
infobrowser File 245.8 KB 0755
infocmp File 70.45 KB 0755
infotocap File 94.49 KB 0755
innochecksum File 179.63 KB 0755
inputattach File 33.75 KB 0755
install File 142.59 KB 0755
install-info File 47.31 KB 0755
instmodsh File 4.27 KB 0755
intel-virtual-output File 66.31 KB 0755
ionice File 18.45 KB 0755
iostat File 58.55 KB 0755
ip File 904.97 KB 0755
ipcmk File 22.52 KB 0755
ipcrm File 18.45 KB 0755
ipcs File 38.45 KB 0755
ipod-read-sysinfo-extended File 22.38 KB 0755
ipod-time-sync File 14.38 KB 0755
ippfind File 46.48 KB 0755
ipptool File 106.38 KB 0755
iptables-xml File 105.02 KB 0755
ischroot File 14.55 KB 0755
isdv4-serial-debugger File 18.31 KB 0755
isdv4-serial-inputattach File 18.31 KB 0755
ispell-wrapper File 7.05 KB 0755
join File 54.63 KB 0755
journalctl File 91.19 KB 0755
jpgicc File 38.47 KB 0755
jq File 34.23 KB 0755
json-patch-jsondiff File 1004 B 0755
json_pp File 4.9 KB 0755
jsondiff File 1004 B 0755
jsonpatch File 3.77 KB 0755
jsonpointer File 1.79 KB 0755
jsonschema File 213 B 0755
kbd_mode File 14.74 KB 0755
kbdinfo File 18.45 KB 0755
kbxutil File 70.91 KB 0755
kernel-install File 54.71 KB 0755
kill File 22.45 KB 0755
killall File 31.42 KB 0755
kmod File 194.31 KB 0755
kmodsign File 18.45 KB 0755
l2ping File 18.38 KB 0755
l2test File 34.72 KB 0755
laptop-detect File 3.74 KB 0755
lavadecode File 22.39 KB 0755
ld File 1.78 MB 0755
ld.bfd File 1.78 MB 0755
ld.so File 245.65 KB 0755
ldapadd File 66.53 KB 0755
ldapcompare File 66.53 KB 0755
ldapdelete File 66.55 KB 0755
ldapexop File 66.53 KB 0755
ldapmodify File 66.53 KB 0755
ldapmodrdn File 62.53 KB 0755
ldappasswd File 66.53 KB 0755
ldapsearch File 102.55 KB 0755
ldapurl File 14.38 KB 0755
ldapwhoami File 62.53 KB 0755
ldd File 5.26 KB 0755
less File 216.21 KB 0755
lessecho File 14.38 KB 0755
lessfile File 8.83 KB 0755
lesskey File 23.79 KB 0755
lesspipe File 8.83 KB 0755
lexgrog File 111.59 KB 0755
libnetcfg File 15.41 KB 0755
libreoffice File 6.5 KB 0755
link File 34.59 KB 0755
linkicc File 26.45 KB 0755
linux-boot-prober File 1.54 KB 0755
linux-check-removal File 4.56 KB 0755
linux-update-symlinks File 6.35 KB 0755
linux-version File 2.63 KB 0755
linux32 File 26.73 KB 0755
linux64 File 26.73 KB 0755
listres File 14.8 KB 0755
ln File 62.59 KB 0755
lnstat File 22.73 KB 0755
loadkeys File 206.98 KB 0755
loadunimap File 34.54 KB 0755
localc File 59 B 0755
locale File 49.71 KB 0755
locale-check File 14.23 KB 0755
localectl File 30.45 KB 0755
localedef File 323.2 KB 0755
localsearch File 133.8 KB 0755
lodraw File 59 B 0755
loffice File 53 B 0755
lofromtemplate File 64 B 0755
logger File 39.05 KB 0755
login File 42.45 KB 0755
loginctl File 66.59 KB 0755
logname File 34.59 KB 0755
logresolve File 14.39 KB 0755
loimpress File 62 B 0755
lomath File 59 B 0755
look File 18.46 KB 0755
loweb File 58 B 0755
lowntfs-3g File 131.05 KB 0755
lowriter File 61 B 0755
lp File 26.38 KB 0755
lpoptions File 22.45 KB 0755
lpq File 22.45 KB 0755
lpr File 22.38 KB 0755
lprm File 14.38 KB 0755
lpstat File 38.7 KB 0755
ls File 155.02 KB 0755
lsattr File 14.38 KB 0755
lsb_release File 2.77 KB 0755
lsblk File 178.46 KB 0755
lscpu File 118.46 KB 0755
lshw File 784.49 KB 0755
lsinitramfs File 735 B 0755
lsipc File 54.45 KB 0755
lslocks File 42.88 KB 0755
lslogins File 50.45 KB 0755
lsmem File 38.45 KB 0755
lsmod File 194.31 KB 0755
lsns File 42.46 KB 0755
lsof File 203.8 KB 0755
lspci File 144.19 KB 0755
lspgpot File 1.06 KB 0755
lspower File 1.2 KB 0755
lsusb File 234.48 KB 0755
lto-dump File 31.61 MB 0755
lto-dump-14 File 31.61 MB 0755
luit File 100.88 KB 0755
lwp-download File 10.05 KB 0755
lwp-dump File 2.65 KB 0755
lwp-mirror File 2.36 KB 0755
lwp-request File 15.87 KB 0755
lzcat File 103.02 KB 0755
lzcmp File 7.41 KB 0755
lzdiff File 7.41 KB 0755
lzegrep File 10.17 KB 0755
lzfgrep File 10.17 KB 0755
lzgrep File 10.17 KB 0755
lzless File 2.33 KB 0755
lzma File 103.02 KB 0755
lzmainfo File 14.45 KB 0755
lzmore File 2.18 KB 0755
m17n-db File 3.65 KB 0755
m2300w File 28.83 KB 0755
m2300w-wrapper File 14.24 KB 0755
m2400w File 32.83 KB 0755
make File 344.14 KB 0755
make-first-existing-target File 4.79 KB 0755
makedumpfile File 415.41 KB 0755
makedumpfile-R.pl File 4.83 KB 0755
mako-render File 972 B 0755
man File 129.48 KB 0755
man-recode File 35.48 KB 0755
mandb File 155.74 KB 0755
manpath File 26.86 KB 0755
mapscrn File 34.54 KB 0755
markdown-it File 220 B 0755
mawk File 190.84 KB 0755
mbim-network File 11.08 KB 0755
mbimcli File 216.82 KB 0755
mcookie File 26.52 KB 0755
md5sum File 42.49 KB 0755
md5sum.textutils File 42.49 KB 0755
mdig File 54.48 KB 0755
memhog File 14.42 KB 0755
mesa-overlay-control.py File 5.59 KB 0755
migrate-pubring-from-classic-gpg File 3.02 KB 0755
migratepages File 14.38 KB 0755
migspeed File 14.3 KB 0755
mimeopen File 9.41 KB 0755
mimetype File 12.76 KB 0755
min12xxw File 31.45 KB 0755
mk_modmap File 15.78 KB 0755
mkdir File 70.59 KB 0755
mkfifo File 42.59 KB 0755
mkfontdir File 65 B 0755
mkfontscale File 42.9 KB 0755
mknod File 46.59 KB 0755
mksquashfs File 286.95 KB 0755
mktemp File 38.59 KB 0755
mmcli File 278.02 KB 0755
modutil File 94.49 KB 0755
mokutil File 59.48 KB 0755
monitor-sensor File 18.38 KB 0755
more File 46.46 KB 0755
mount File 50.45 KB 4755
mountpoint File 18.45 KB 0755
mousetweaks File 74.3 KB 0755
mpris-proxy File 94.67 KB 0755
mpstat File 50.55 KB 0755
mscompress File 14.3 KB 0755
msexpand File 14.3 KB 0755
mt File 75.09 KB 0755
mt-gnu File 75.09 KB 0755
mtr File 80.33 KB 0755
mtr-packet File 34.38 KB 0755
mv File 134.6 KB 0755
my_print_defaults File 179.59 KB 0755
myisam_ftdump File 6.36 MB 0755
myisamchk File 6.57 MB 0755
myisamlog File 6.39 MB 0755
myisampack File 6.42 MB 0755
mysql File 6.63 MB 0755
mysql_config_editor File 165.27 KB 0755
mysql_migrate_keyring File 6.53 MB 0755
mysql_secure_installation File 6.45 MB 0755
mysql_tzinfo_to_sql File 79.15 KB 0755
mysqladmin File 6.47 MB 0755
mysqlanalyze File 6.48 MB 0755
mysqlbinlog File 6.86 MB 0755
mysqlcheck File 6.48 MB 0755
mysqld_multi File 26.73 KB 0755
mysqld_safe File 28.45 KB 0755
mysqldump File 6.57 MB 0755
mysqldumpslow File 7.54 KB 0755
mysqlimport File 6.46 MB 0755
mysqloptimize File 6.48 MB 0755
mysqlrepair File 6.48 MB 0755
mysqlshow File 6.46 MB 0755
mysqlslap File 6.47 MB 0755
namei File 22.45 KB 0755
nano File 328.65 KB 0755
nautilus File 1.6 MB 0755
nautilus-autorun-software File 18.38 KB 0755
nautilus-sendto File 22.23 KB 0755
nawk File 190.84 KB 0755
nc File 42.71 KB 0755
nc.openbsd File 42.71 KB 0755
neqn File 913 B 0755
netaddr File 211 B 0755
netcat File 42.71 KB 0755
netstat File 166.68 KB 0755
networkctl File 130.59 KB 0755
networkd-dispatcher File 19.88 KB 0755
newgrp File 18.45 KB 4755
ngettext File 38.46 KB 0755
nhlt-dmic-info File 18.55 KB 0755
nice File 38.59 KB 0755
nisdomainname File 22.3 KB 0755
nl File 42.68 KB 0755
nm File 47.57 KB 0755
nm-connection-editor File 963.06 KB 0755
nm-online File 22.45 KB 0755
nmcli File 1.03 MB 0755
nmtui File 891.73 KB 0755
nmtui-connect File 891.73 KB 0755
nmtui-edit File 891.73 KB 0755
nmtui-hostname File 891.73 KB 0755
nohup File 38.49 KB 0755
notify-send File 26.31 KB 0755
nproc File 38.59 KB 0755
nroff File 5.58 KB 0755
nsenter File 30.71 KB 0755
nslookup File 118.98 KB 0755
nss-addbuiltin File 30.68 KB 0755
nss-dbtest File 22.47 KB 0755
nss-pp File 86.46 KB 0755
nstat File 30.45 KB 0755
nsupdate File 82.62 KB 0755
ntfs-3g File 175.09 KB 4755
ntfs-3g.probe File 14.45 KB 0755
ntfscat File 26.45 KB 0755
ntfscluster File 38.46 KB 0755
ntfscmp File 30.45 KB 0755
ntfsdecrypt File 42.46 KB 0755
ntfsfallocate File 26.46 KB 0755
ntfsfix File 34.46 KB 0755
ntfsinfo File 58.46 KB 0755
ntfsls File 27.53 KB 0755
ntfsmove File 30.46 KB 0755
ntfsrecover File 114.45 KB 0755
ntfssecaudit File 90.94 KB 0755
ntfstruncate File 26.38 KB 0755
ntfsusermap File 18.38 KB 0755
ntfswipe File 46.98 KB 0755
numactl File 35.23 KB 0755
numastat File 35.56 KB 0755
numfmt File 62.6 KB 0755
nvidia-detector File 270 B 0755
oakdecode File 18.33 KB 0755
obexctl File 110.46 KB 0755
objcopy File 166.7 KB 0755
objdump File 397.89 KB 0755
oclock File 23.41 KB 0755
ocspclnt File 70.46 KB 0755
od File 62.59 KB 0755
oem-getlogs File 8.3 KB 0755
on_ac_power File 2.45 KB 0755
oomctl File 18.45 KB 0755
open File 31.53 KB 0755
openssl File 1.08 MB 0755
openvt File 22.8 KB 0755
opldecode File 18.31 KB 0755
orca File 9.52 KB 0755
orca-dm-wrapper File 70 B 0755
os-prober File 4.42 KB 0755
osirrox File 14.15 KB 0755
p11-kit File 214.78 KB 0755
p7content File 22.39 KB 0755
p7env File 18.38 KB 0755
p7sign File 26.39 KB 0755
p7verify File 22.38 KB 0755
pager File 216.21 KB 0755
paper File 22.59 KB 0755
paperconf File 14.38 KB 0755
papers File 6.82 MB 0755
papers-previewer File 46.59 KB 0755
papers-thumbnailer File 18.46 KB 0755
partx File 62.46 KB 0755
passwd File 91.45 KB 4755
paste File 38.49 KB 0755
patch File 182.52 KB 0755
pathchk File 38.59 KB 0755
pcilmr File 50.45 KB 0755
pdb3 File 88.79 KB 0755
pdb3.13 File 88.79 KB 0755
pdf2ps File 909 B 0755
pdfattach File 22.46 KB 0755
pdfdetach File 30.57 KB 0755
pdffonts File 22.6 KB 0755
pdfimages File 42.6 KB 0755
pdfinfo File 74.58 KB 0755
pdfseparate File 22.46 KB 0755
pdfsig File 47.01 KB 0755
pdftocairo File 174.66 KB 0755
pdftohtml File 114.49 KB 0755
pdftoppm File 38.66 KB 0755
pdftops File 34.76 KB 0755
pdftotext File 58.6 KB 0755
pdfunite File 34.46 KB 0755
peekfd File 14.38 KB 0755
perf File 10.59 MB 0755
perl File 3.86 MB 0755
perl5.40-x86_64-linux-gnu File 14.38 KB 0755
perl5.40.1 File 3.86 MB 0755
perlbug File 44.52 KB 0755
perldoc File 125 B 0755
perli11ndoc File 58.17 KB 0755
perlivp File 10.61 KB 0755
perlthanks File 44.52 KB 0755
perror File 1.53 MB 0755
pf2afm File 498 B 0755
pfbtopfa File 516 B 0755
pgrep File 34.55 KB 0755
phar File 14.88 KB 0755
phar.default File 14.88 KB 0755
phar.phar File 14.88 KB 0755
phar.phar.default File 14.88 KB 0755
phar.phar8.4 File 14.88 KB 0755
phar8.4 File 14.88 KB 0755
phar8.4.phar File 14.88 KB 0755
php File 5.79 MB 0755
php.default File 5.79 MB 0755
php8.4 File 5.79 MB 0755
pic File 228.12 KB 0755
pico File 328.65 KB 0755
piconv File 8.16 KB 0755
pidof File 26.3 KB 0755
pidstat File 50.55 KB 0755
pidwait File 34.55 KB 0755
pinentry File 86.73 KB 0755
pinentry-curses File 70.72 KB 0755
pinentry-gnome3 File 86.73 KB 0755
pinentry-x11 File 86.73 KB 0755
ping File 155.74 KB 0755
ping4 File 155.74 KB 0755
ping6 File 155.74 KB 0755
pinky File 42.49 KB 0755
pipewire File 14.45 KB 0755
pipewire-aes67 File 14.45 KB 0755
pipewire-avb File 14.45 KB 0755
pipewire-pulse File 14.45 KB 0755
pk12util File 75.08 KB 0755
pk1sign File 22.52 KB 0755
pkaction File 18.45 KB 0755
pkcheck File 26.38 KB 0755
pkcon File 58.38 KB 0755
pkexec File 30.3 KB 4755
pkill File 34.55 KB 0755
pkmon File 22.38 KB 0755
pkttyagent File 22.45 KB 0755
pl2pm File 4.43 KB 0755
pldd File 22.52 KB 0755
plog File 146 B 0755
plymouth File 54.45 KB 0755
pmap File 38.48 KB 0755
pnm2ppa File 1.57 MB 0755
pod2html File 3.95 KB 0755
pod2man File 18.46 KB 0755
pod2text File 12.8 KB 0755
pod2usage File 4.01 KB 0755
podchecker File 3.64 KB 0755
poff File 2.77 KB 0755
pon File 1.33 KB 0755
powerprofilesctl File 10.49 KB 0755
ppdc File 118.55 KB 0755
ppdhtml File 82.55 KB 0755
ppdi File 106.55 KB 0755
ppdmerge File 18.45 KB 0755
ppdpo File 90.55 KB 0755
pphs File 404 B 0755
pr File 78.64 KB 0755
precat File 5.52 KB 0755
preconv File 62.55 KB 0755
preunzip File 5.52 KB 0755
prezip File 5.52 KB 0755
prezip-bin File 14.38 KB 0755
printafm File 395 B 0755
printenv File 34.46 KB 0755
printer-profile File 5.51 KB 0755
printf File 42.59 KB 0755
prlimit File 26.97 KB 0755
pro File 1003 B 0755
prove File 13.36 KB 0755
prtstat File 22.45 KB 0755
ps File 163.07 KB 0755
ps2ascii File 494 B 0755
ps2epsi File 1.27 KB 0755
ps2pdf File 272 B 0755
ps2pdf12 File 257 B 0755
ps2pdf13 File 257 B 0755
ps2pdf14 File 257 B 0755
ps2pdfwr File 1.05 KB 0755
ps2ps File 647 B 0755
ps2ps2 File 669 B 0755
ps2txt File 494 B 0755
psfaddtable File 26.45 KB 0755
psfgettable File 26.45 KB 0755
psfstriptable File 26.45 KB 0755
psfxtable File 26.45 KB 0755
psicc File 14.39 KB 0755
pslog File 14.38 KB 0755
pstree File 63.4 KB 0755
pstree.x11 File 63.4 KB 0755
ptar File 3.48 KB 0755
ptardiff File 2.58 KB 0755
ptargrep File 4.29 KB 0755
ptx File 58.62 KB 0755
pw-cat File 102.45 KB 0755
pw-cli File 154.56 KB 0755
pw-config File 22.45 KB 0755
pw-container File 22.45 KB 0755
pw-dot File 62.45 KB 0755
pw-dsdplay File 102.45 KB 0755
pw-dump File 114.54 KB 0755
pw-encplay File 102.45 KB 0755
pw-link File 34.45 KB 0755
pw-loopback File 26.45 KB 0755
pw-metadata File 14.45 KB 0755
pw-mididump File 34.45 KB 0755
pw-midiplay File 102.45 KB 0755
pw-midirecord File 102.45 KB 0755
pw-mon File 106.5 KB 0755
pw-play File 102.45 KB 0755
pw-profiler File 26.45 KB 0755
pw-record File 102.45 KB 0755
pw-reserve File 26.45 KB 0755
pw-top File 50.45 KB 0755
pwd File 38.59 KB 0755
pwdecrypt File 22.39 KB 0755
pwdx File 14.45 KB 0755
py3clean File 7.59 KB 0755
py3compile File 12.99 KB 0755
py3versions File 12.52 KB 0755
pybabel File 956 B 0755
pybabel-python3 File 956 B 0755
pydoc3 File 80 B 0755
pydoc3.13 File 80 B 0755
pygettext3 File 23.87 KB 0755
pygettext3.13 File 23.87 KB 0755
pygmentize File 215 B 0755
pyserial-miniterm File 975 B 0755
pyserial-ports File 969 B 0755
python3 File 6.51 MB 0755
python3.13 File 6.51 MB 0755
pzstd File 866.54 KB 0755
qmi-firmware-update File 180.16 KB 0755
qmi-network File 16.04 KB 0755
qmicli File 647.17 KB 0755
qpdldecode File 22.6 KB 0755
quirks-handler File 2.4 KB 0755
ranlib File 54.56 KB 0755
rbash File 1.66 MB 0755
rctest File 42.4 KB 0755
rdma File 126.6 KB 0755
readelf File 790.98 KB 0755
readlink File 42.49 KB 0755
realpath File 42.49 KB 0755
red File 89 B 0755
remmina File 969.16 KB 0755
remmina-file-wrapper File 1.3 KB 0755
remmina-gnome File 530 B 0755
rename.ul File 22.45 KB 0755
rendercheck File 59.78 KB 0755
renice File 14.45 KB 0755
reset File 30.38 KB 0755
resizecons File 30.54 KB 0755
resizepart File 22.45 KB 0755
resolvectl File 178.69 KB 0755
rev File 14.45 KB 0755
rfcomm File 30.81 KB 0755
rgrep File 30 B 0755
rhythmbox File 14.38 KB 0755
rhythmbox-client File 56.29 KB 0755
rm File 62.59 KB 0755
rmdir File 38.49 KB 0755
rnano File 328.65 KB 0755
rotatelogs File 26.46 KB 0755
routel File 1.62 KB 0755
rpcgen File 94.59 KB 0755
rrsync File 12.7 KB 0755
rsaperf File 688.82 KB 0755
rstart File 2.55 KB 0755
rstartd File 1.43 KB 0755
rsync File 594.21 KB 0755
rsync-ssl File 5.01 KB 0755
rtla File 1.58 KB 0755
rtstat File 22.73 KB 0755
run-parts File 30.89 KB 0755
run-with-aspell File 57 B 0755
run0 File 82.9 KB 0755
runcon File 38.59 KB 0755
rview File 2.16 MB 0755
rygel File 50.45 KB 0755
sadf File 396.13 KB 0755
sane-find-scanner File 103.25 KB 0755
sar File 179.1 KB 0755
sar.sysstat File 179.1 KB 0755
savelog File 10.24 KB 0755
sbattach File 22.54 KB 0755
sbkeysync File 34.74 KB 0755
sbsiglist File 14.6 KB 0755
sbsign File 34.7 KB 0755
sbvarsign File 22.73 KB 0755
sbverify File 30.61 KB 0755
scanimage File 79.19 KB 0755
scp File 162.74 KB 0755
scp-dbus-service File 90 B 0755
screendump File 18.37 KB 0755
script File 54.45 KB 0755
scriptlive File 42.45 KB 0755
scriptreplay File 34.45 KB 0755
sdiff File 58.47 KB 0755
sdptool File 148.38 KB 0755
seahorse File 1.18 MB 0755
sed File 110.57 KB 0755
select-default-iwrap File 474 B 0755
select-editor File 2.62 KB 0755
selfserv File 74.42 KB 0755
sensible-browser File 1.06 KB 0755
sensible-editor File 1.51 KB 0755
sensible-pager File 824 B 0755
sensible-terminal File 1.08 KB 0755
seq File 42.59 KB 0755
session-migration File 22.15 KB 0755
sessreg File 14.38 KB 0755
setarch File 26.73 KB 0755
setfacl File 38.38 KB 0755
setfont File 54.91 KB 0755
setkeycodes File 14.45 KB 0755
setleds File 18.51 KB 0755
setlogcons File 14.45 KB 0755
setmetamode File 14.48 KB 0755
setpci File 34.46 KB 0755
setpriv File 46.46 KB 0755
setsid File 14.45 KB 0755
setterm File 38.45 KB 0755
setupcon File 40.01 KB 0755
setxkbmap File 30.78 KB 0755
sftp File 178.73 KB 0755
sg File 18.45 KB 4755
sh File 146.84 KB 0755
sha1sum File 42.49 KB 0755
sha224sum File 42.49 KB 0755
sha256sum File 42.49 KB 0755
sha384sum File 42.49 KB 0755
sha512sum File 42.49 KB 0755
shasum File 9.75 KB 0755
shlibsign File 38.76 KB 0755
shotwell File 5.92 MB 0755
showconsolefont File 18.45 KB 0755
showkey File 18.45 KB 0755
showrgb File 14.38 KB 0755
shred File 62.59 KB 0755
shuf File 50.59 KB 0755
signtool File 122.49 KB 0755
signver File 42.76 KB 0755
simple-scan File 522.44 KB 0755
size File 30.53 KB 0755
skill File 30.49 KB 0755
slabtop File 22.52 KB 0755
sleep File 34.59 KB 0755
slogin File 1.07 MB 0755
slxdecode File 18.31 KB 0755
smproxy File 26.39 KB 0755
snap File 18.41 MB 0755
snapctl File 7.1 MB 0755
snapfuse File 42.3 KB 0755
snapshot File 4.59 MB 0755
snice File 30.49 KB 0755
soelim File 38.55 KB 0755
soffice File 6.5 KB 0755
software-properties-gtk File 4.04 KB 0755
sort File 118.84 KB 0755
spa-acp-tool File 344.34 KB 0755
spa-inspect File 110.55 KB 0755
spa-json-dump File 34.45 KB 0755
spa-monitor File 14.55 KB 0755
spa-resample File 34.8 KB 0755
spd-conf File 1003 B 0755
spd-say File 31.21 KB 0755
spdsend File 14.38 KB 0755
speaker-test File 42.52 KB 0755
speech-dispatcher File 250.48 KB 0755
spice-vdagent File 82.85 KB 0755
splain File 19 KB 0755
split File 59.02 KB 0755
splitfont File 14.37 KB 0755
sqfscat File 147.9 KB 0755
sqfstar File 286.95 KB 0755
ss File 136.93 KB 0755
ssh File 1.07 MB 0755
ssh-add File 350.5 KB 0755
ssh-agent File 366.51 KB 2755
ssh-argv0 File 1.42 KB 0755
ssh-copy-id File 13.84 KB 0755
ssh-import-id File 985 B 0755
ssh-import-id-gh File 785 B 0755
ssh-import-id-lp File 785 B 0755
ssh-keygen File 526.52 KB 0755
ssh-keyscan File 538.52 KB 0755
ssltap File 78.46 KB 0755
sss_ssh_authorizedkeys File 34.38 KB 0755
sss_ssh_knownhosts File 34.38 KB 0755
sss_ssh_knownhostsproxy File 26.38 KB 0755
startx File 5.26 KB 0755
stat File 90.59 KB 0755
static-sh File 2.34 MB 0755
stdbuf File 38.59 KB 0755
strace File 2.13 MB 0755
strace-log-merge File 1.83 KB 0755
streamzip File 7.87 KB 0755
strings File 34.69 KB 0755
strip File 166.73 KB 0755
strsclnt File 46.41 KB 0755
stty File 66.6 KB 0755
su File 54.45 KB 4755
sudo File 287.48 KB 4755
sudoedit File 287.48 KB 4755
sudoreplay File 96.03 KB 0755
sum File 38.49 KB 0755
switcherooctl File 4.77 KB 0755
symkeyutil File 39.29 KB 0755
sync File 34.49 KB 0755
sysprof File 1.2 MB 0755
sysprof-agent File 474.84 KB 0755
sysprof-cat File 322.59 KB 0755
sysprof-cli File 474.84 KB 0755
systemctl File 299 KB 0755
systemd-ac-power File 14.45 KB 0755
systemd-analyze File 218.87 KB 0755
systemd-ask-password File 18.59 KB 0755
systemd-cat File 18.45 KB 0755
systemd-cgls File 22.57 KB 0755
systemd-cgtop File 38.47 KB 0755
systemd-confext File 74.65 KB 0755
systemd-creds File 50.74 KB 0755
systemd-cryptenroll File 83 KB 0755
systemd-cryptsetup File 79.05 KB 0755
systemd-delta File 26.45 KB 0755
systemd-detect-virt File 18.45 KB 0755
systemd-escape File 22.45 KB 0755
systemd-firstboot File 58.88 KB 0755
systemd-hwdb File 14.44 KB 0755
systemd-id128 File 26.45 KB 0755
systemd-inhibit File 22.47 KB 0755
systemd-machine-id-setup File 18.63 KB 0755
systemd-mount File 54.79 KB 0755
systemd-notify File 30.73 KB 0755
systemd-path File 18.45 KB 0755
systemd-run File 82.9 KB 0755
systemd-socket-activate File 30.45 KB 0755
systemd-stdio-bridge File 22.45 KB 0755
systemd-sysext File 74.65 KB 0755
systemd-sysusers File 66.63 KB 0755
systemd-tmpfiles File 126.7 KB 0755
systemd-tty-ask-password-agent File 34.45 KB 0755
systemd-umount File 54.79 KB 0755
systemd-vpick File 26.64 KB 0755
tabs File 18.38 KB 0755
tac File 42.49 KB 0755
tail File 74.61 KB 0755
tapestat File 30.55 KB 0755
tar File 510.04 KB 0755
taskset File 30.45 KB 0755
tbl File 154.55 KB 0755
tclsh File 14.23 KB 0755
tclsh8.6 File 14.23 KB 0755
tcpdump File 1.21 MB 0755
tecla File 66.52 KB 0755
tee File 42.59 KB 0755
telnet File 221.9 KB 0755
tempfile File 14.38 KB 0755
test File 34.51 KB 0755
thunderbird File 2.4 KB 0755
tic File 94.49 KB 0755
tificc File 34.46 KB 0755
time File 26.52 KB 0755
timedatectl File 46.45 KB 0755
timeout File 43.01 KB 0755
tinysparql File 60.69 KB 0755
tload File 22.47 KB 0755
tnftp File 182.9 KB 0755
toe File 22.38 KB 0755
top File 147.77 KB 0755
totem File 22.45 KB 0755
totem-video-thumbnailer File 38.48 KB 0755
touch File 82.59 KB 0755
tput File 26.41 KB 0755
tr File 50.55 KB 0755
trace-cmd File 435.41 KB 0755
tracepath File 18.23 KB 0755
transicc File 38.39 KB 0755
transmission-gtk File 2.78 MB 0755
transset File 22.78 KB 0755
troff File 818.7 KB 0755
true File 34.46 KB 0755
truncate File 38.59 KB 0755
trust File 246.78 KB 0755
tset File 30.38 KB 0755
tsort File 42.59 KB 0755
tstclnt File 106.5 KB 0755
tty File 34.59 KB 0755
turbostat File 1.58 KB 0755
tzselect File 21.39 KB 0755
ua File 1003 B 0755
ubuntu-advantage File 1003 B 0755
ubuntu-bug File 2.27 KB 0755
ubuntu-distro-info File 26.97 KB 0755
ubuntu-drivers File 18.25 KB 0755
ubuntu-report File 7.9 MB 0755
ubuntu-security-status File 22.25 KB 0755
ucf File 35.62 KB 0755
ucfq File 18.46 KB 0755
ucfr File 9.93 KB 0755
uclampset File 30.45 KB 0755
ucs2any File 26.38 KB 0755
udevadm File 618.84 KB 0755
udisksctl File 62.45 KB 0755
ul File 26.46 KB 0755
umax_pp File 191.53 KB 0755
umount File 38.45 KB 4755
uname File 34.59 KB 0755
unattended-upgrade File 116.54 KB 0755
unattended-upgrades File 116.54 KB 0755
uncompress File 2.28 KB 0755
unexpand File 38.61 KB 0755
unicode_start File 2.71 KB 0755
unicode_stop File 528 B 0755
uniq File 46.6 KB 0755
unity-scope-loader File 14.38 KB 0755
unlink File 34.59 KB 0755
unlzma File 103.02 KB 0755
unmkinitramfs File 6.23 KB 0755
unopkg File 52 B 0755
unshare File 46.68 KB 0755
unsquashfs File 147.9 KB 0755
unxz File 103.02 KB 0755
unzip File 190.61 KB 0755
unzipsfx File 94.63 KB 0755
unzstd File 1.22 MB 0755
update-alternatives File 66.46 KB 0755
update-desktop-database File 22.46 KB 0755
update-manager File 4.65 KB 0755
update-mime-database File 90.41 KB 0755
update-notifier File 91.23 KB 0755
upower File 18.38 KB 0755
uptime File 14.45 KB 0755
usb-creator-gtk File 2.87 KB 0755
usb-devices File 4.84 KB 0755
usb_printerid File 14.31 KB 0755
usbhid-dump File 30.46 KB 0755
usbip File 1.58 KB 0755
usbipd File 1.58 KB 0755
usbreset File 14.38 KB 0755
users File 38.59 KB 0755
uuidgen File 22.45 KB 0755
uuidparse File 22.45 KB 0755
varlinkctl File 38.57 KB 0755
vcs-run File 6.75 KB 0755
vdir File 155.02 KB 0755
vfychain File 74.47 KB 0755
vfyserv File 42.47 KB 0755
vi File 2.16 MB 0755
view File 2.16 MB 0755
viewres File 31.3 KB 0755
vim.tiny File 2.16 MB 0755
vmstat File 38.86 KB 0755
vmwarectrl File 14.26 KB 0755
vsftpdwho File 54 B 0755
vstp File 26.24 KB 0755
w File 26.45 KB 0755
wall File 26.45 KB 0755
watch File 34.92 KB 0755
watchgnupg File 22.38 KB 0755
wc File 62.59 KB 0755
wcurl File 10.3 KB 0755
wdctl File 34.48 KB 0755
wget File 579.05 KB 0755
whatis File 47.36 KB 0755
whereis File 30.91 KB 0755
which File 1.05 KB 0755
which.debianutils File 1.05 KB 0755
whiptail File 30.24 KB 0755
who File 46.6 KB 0755
whoami File 34.59 KB 0755
whoopsie File 50.98 KB 0755
whoopsie-preferences File 22.23 KB 0755
wireplumber File 18.64 KB 0755
word-list-compress File 14.38 KB 0755
wpa_passphrase File 14.46 KB 0755
wpctl File 62.51 KB 0755
wpexec File 18.63 KB 0755
wsdd File 72.92 KB 0755
x-session-manager File 958 B 0755
x-terminal-emulator File 6.06 KB 0755
x-www-browser File 2.32 KB 0755
x11perf File 197.46 KB 0755
x11perfcomp File 2.74 KB 0755
x86_64 File 26.73 KB 0755
x86_64-linux-gnu-addr2line File 30.78 KB 0755
x86_64-linux-gnu-ar File 54.56 KB 0755
x86_64-linux-gnu-as File 795.52 KB 0755
x86_64-linux-gnu-c++filt File 26.34 KB 0755
x86_64-linux-gnu-cpp File 1.13 MB 0755
x86_64-linux-gnu-cpp-14 File 1.13 MB 0755
x86_64-linux-gnu-elfedit File 34.79 KB 0755
x86_64-linux-gnu-gcc File 1.13 MB 0755
x86_64-linux-gnu-gcc-14 File 1.13 MB 0755
x86_64-linux-gnu-gcc-ar File 30.66 KB 0755
x86_64-linux-gnu-gcc-ar-14 File 30.66 KB 0755
x86_64-linux-gnu-gcc-nm File 30.66 KB 0755
x86_64-linux-gnu-gcc-nm-14 File 30.66 KB 0755
x86_64-linux-gnu-gcc-ranlib File 30.66 KB 0755
x86_64-linux-gnu-gcc-ranlib-14 File 30.66 KB 0755
x86_64-linux-gnu-gcov File 468.19 KB 0755
x86_64-linux-gnu-gcov-14 File 468.19 KB 0755
x86_64-linux-gnu-gcov-dump File 380.14 KB 0755
x86_64-linux-gnu-gcov-dump-14 File 380.14 KB 0755
x86_64-linux-gnu-gcov-tool File 408.23 KB 0755
x86_64-linux-gnu-gcov-tool-14 File 408.23 KB 0755
x86_64-linux-gnu-gprof File 99.86 KB 0755
x86_64-linux-gnu-ld File 1.78 MB 0755
x86_64-linux-gnu-ld.bfd File 1.78 MB 0755
x86_64-linux-gnu-lto-dump File 31.61 MB 0755
x86_64-linux-gnu-lto-dump-14 File 31.61 MB 0755
x86_64-linux-gnu-nm File 47.57 KB 0755
x86_64-linux-gnu-objcopy File 166.7 KB 0755
x86_64-linux-gnu-objdump File 397.89 KB 0755
x86_64-linux-gnu-ranlib File 54.56 KB 0755
x86_64-linux-gnu-readelf File 790.98 KB 0755
x86_64-linux-gnu-size File 30.53 KB 0755
x86_64-linux-gnu-strings File 34.69 KB 0755
x86_64-linux-gnu-strip File 166.73 KB 0755
x86_energy_perf_policy File 1.58 KB 0755
xargs File 66.49 KB 0755
xauth File 55.03 KB 0755
xbiff File 24.16 KB 0755
xbrlapi File 238.57 KB 0755
xcalc File 51.48 KB 0755
xclipboard File 22.58 KB 0755
xclock File 53.06 KB 0755
xcmsdb File 42.46 KB 0755
xconsole File 23.2 KB 0755
xcursorgen File 22.3 KB 0755
xcutsel File 18.56 KB 0755
xdg-dbus-proxy File 58.3 KB 0755
xdg-desktop-icon File 22.29 KB 0755
xdg-desktop-menu File 43.17 KB 0755
xdg-email File 28.24 KB 0755
xdg-icon-resource File 31.47 KB 0755
xdg-mime File 46.62 KB 0755
xdg-open File 31.53 KB 0755
xdg-screensaver File 38.55 KB 0755
xdg-settings File 43.31 KB 0755
xdg-terminal-exec File 33.69 KB 0755
xdg-user-dir File 234 B 0755
xdg-user-dirs-gtk-update File 22.3 KB 0755
xdg-user-dirs-update File 26.3 KB 0755
xditview File 108.13 KB 0755
xdpyinfo File 39.13 KB 0755
xdriinfo File 14.38 KB 0755
xedit File 705.34 KB 0755
xev File 34.7 KB 0755
xeyes File 32.13 KB 0755
xfd File 40.08 KB 0755
xfontsel File 47.92 KB 0755
xgamma File 14.38 KB 0755
xgc File 70.38 KB 0755
xhost File 22.38 KB 0755
xinit File 22.38 KB 0755
xinput File 58.83 KB 0755
xkbbell File 14.39 KB 0755
xkbcomp File 212.18 KB 0755
xkbevd File 38.46 KB 0755
xkbprint File 94.42 KB 0755
xkbvleds File 23.18 KB 0755
xkbwatch File 23.24 KB 0755
xkeystone File 16.58 KB 0755
xkill File 14.38 KB 0755
xload File 22.92 KB 0755
xlogo File 23.19 KB 0755
xlsatoms File 14.38 KB 0755
xlsclients File 18.38 KB 0755
xlsfonts File 26.48 KB 0755
xmag File 44.31 KB 0755
xman File 77.2 KB 0755
xmessage File 23.27 KB 0755
xmodmap File 46.75 KB 0755
xmore File 14.53 KB 0755
xorrecord File 14.15 KB 0755
xorriso File 14.15 KB 0755
xorrisofs File 14.15 KB 0755
xprop File 48.68 KB 0755
xqxdecode File 18.31 KB 0755
xrandr File 70.48 KB 0755
xrdb File 42.48 KB 0755
xrefresh File 14.46 KB 0755
xset File 34.38 KB 0755
xsetmode File 14.38 KB 0755
xsetpointer File 14.38 KB 0755
xsetroot File 18.38 KB 0755
xsetwacom File 59.84 KB 0755
xsm File 98.71 KB 0755
xstdcmap File 18.96 KB 0755
xsubpp File 5.05 KB 0755
xvidtune File 43.84 KB 0755
xvinfo File 18.38 KB 0755
xwd File 30.31 KB 0755
xwininfo File 50.46 KB 0755
xwud File 30.3 KB 0755
xxd File 22.36 KB 0755
xz File 103.02 KB 0755
xzcat File 103.02 KB 0755
xzcmp File 7.41 KB 0755
xzdiff File 7.41 KB 0755
xzegrep File 10.17 KB 0755
xzfgrep File 10.17 KB 0755
xzgrep File 10.17 KB 0755
xzless File 2.33 KB 0755
xzmore File 2.18 KB 0755
yelp File 58.3 KB 0755
yes File 34.46 KB 0755
ypdomainname File 22.3 KB 0755
zcat File 1.93 KB 0755
zcmp File 1.64 KB 0755
zdiff File 6.3 KB 0755
zdump File 30.36 KB 0755
zegrep File 29 B 0755
zenity File 148.94 KB 0755
zfgrep File 29 B 0755
zforce File 2.03 KB 0755
zgrep File 8.01 KB 0755
zip File 223.08 KB 0755
zipcloak File 74.48 KB 0755
zipdetails File 231.06 KB 0755
zipgrep File 2.89 KB 0755
zipinfo File 190.61 KB 0755
zipnote File 66.48 KB 0755
zipsplit File 62.48 KB 0755
zjsdecode File 26.32 KB 0755
zless File 2.38 KB 0755
zmore File 1.79 KB 0755
znew File 4.46 KB 0755
zstd File 1.22 MB 0755
zstdcat File 1.22 MB 0755
zstdgrep File 3.78 KB 0755
zstdless File 197 B 0755
zstdmt File 1.22 MB 0755
Filemanager