#!/usr/bin/python3
# Copyright (c) 2005-2018 Canonical Ltd
#
# AUTHOR:
# Michael Vogt <mvo@ubuntu.com>
# Balint Reczey <rbalint@ubuntu.com>

# 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
#

from __future__ import annotations

import atexit
import collections.abc
import contextlib
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
import fcntl
import fnmatch
import gettext
import glob
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 pwd
import select
import shlex
import signal
import socket
import string
import subprocess
import sys
import syslog

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
from typing import Any, cast

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"
KEPT_PACKAGES_MAILED_FILE = "var/lib/unattended-upgrades/kept-back-mailed"
MAIL_BINARY = "/usr/bin/mail"
SENDMAIL_BINARY = "/usr/sbin/sendmail"
USERS = "/usr/bin/users"


DISTRO_CODENAME: str = ""
DISTRO_DESC: str = ""
DISTRO_ID: str = ""
DISTRO_RELEASE: str = ""

OS_RELEASE_PATHS = ["/etc/os-release", "/usr/lib/os-release"]


def parse_os_release(paths: list[str] | None = None) -> dict[str, str]:
    """Parse the first available os-release(5) file into a dict.

    This is the same data lsb_release(1) reports on modern systems, so we
    read it directly and avoid spawning lsb_release (and depending on the
    lsb-release package being installed at all).
    """
    # TODO: drop this parser in favor of platform.freedesktop_os_release()
    # once Python >= 3.10 is our minimum version, i.e. once Ubuntu 20.04
    # (Python 3.8) is no longer supported. Note that the stdlib function
    # takes no path argument, so the tests will need to mock it instead
    # of passing "paths".
    data: dict[str, str] = {}
    for path in (paths or OS_RELEASE_PATHS):
        try:
            # os-release(5) files are UTF-8 regardless of the locale
            f = open(path, encoding="utf-8")
        except OSError:
            # not just FileNotFoundError: this runs at import time and an
            # unreadable file must not prevent u-u from starting
            continue
        with f:
            for line in f:
                line = line.strip()
                if not line or line.startswith("#") or "=" not in line:
                    continue
                key, value = line.split("=", 1)
                # values may be shell-quoted, see os-release(5)
                try:
                    tokens = shlex.split(value)
                except ValueError:
                    tokens = [value.strip("\"'")]
                data[key.strip()] = tokens[0] if tokens else ""
        break
    return data


def init_distro_info(paths: list[str] | None = None) -> None:
    global DISTRO_CODENAME, DISTRO_DESC, DISTRO_ID, DISTRO_RELEASE
    os_release = parse_os_release(paths)
    # mimic the values lsb_release(1) derives from os-release
    distro_id = os_release.get("ID", "")
    # capitalize the first letter (e.g. "ubuntu" -> "Ubuntu")
    distro_id = distro_id[:1].upper() + distro_id[1:]
    # use NAME if it only differs from ID in capitalization
    name = os_release.get("NAME", "")
    if name and distro_id.lower() == name.lower():
        distro_id = name
    DISTRO_ID = distro_id or "n/a"
    DISTRO_DESC = os_release.get("PRETTY_NAME", "n/a")
    DISTRO_RELEASE = os_release.get("VERSION_ID", "n/a")
    DISTRO_CODENAME = os_release.get("VERSION_CODENAME", "n/a")


# 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: collections.abc.Set[str] = set()

# keep the NetworkManager D-Bus query short so a slow NM never blocks long
METERED_DBUS_TIMEOUT_MSEC = 2000

POWER_SUPPLY_DIR = "/sys/class/power_supply"
DEFAULT_MIN_BATTERY_LEVEL = 40

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) -> 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: 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


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: dict) -> None:
        self.update(dict)

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

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

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

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

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

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

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

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

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

    @property
    def reboot_required(self) -> bool:
        """Boolean value if a reboot is required"""
        return self["reboot_required"]

    @property
    def log_dpkg(self) -> str:
        """The full dpkg output as a string"""
        return self["log_dpkg"]

    @property
    def log_unattended_upgrades(self) -> str | None:
        """The full unattended-upgrades log output as a string"""
        return self.get("log_unattended_upgrades")


class PluginManager:
    def __init__(self) -> 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: list[str]) -> collections.abc.Set[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: UnattendedUpgradesResult,
                uu_log: StringIO | None,
                dpkg_log: 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: str) -> None:
        self._cached_candidate_pkgnames: set[str] = set()

        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: apt.Package
                            ) -> apt.package.Version | None:
        installed = pkg.installed
        if installed and pkg.versions[0] > 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 installed < v \
                   and 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: 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_pkg.Package,
                            blacklist: list[str],
                            whitelist: list[str],
                            strict_whitelist: bool,
                            better_version: apt.package.Version
                            ) -> 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 and not is_pkgname_in_whitelist(pkg.name, whitelist):
            if strict_whitelist:
                return (_(
                    "Package %s is not on the strict whitelist.")
                    % pkg.name)
            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: list[str],
                                priority: int) -> list[PkgPin]:
        """ Represent blacklist as Python regexps as list of pkg pinnings"""

        pins: 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) -> list[PkgPin | PkgFilePin]:
        """ Represent configuration as list of pinnings

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

        pins: list[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: list[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: apt.progress.base.OpProgress | None = None) -> 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: 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: str, verbose: bool = False,
                 progress_log: str = "var/run/unattended-upgrades.progress") -> 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: int | None = None

    def status_change(self, pkg: str, percent: float, status: 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) -> None:
        REDIRECT_INPUT = os.devnull
        fd = os.open(REDIRECT_INPUT, os.O_RDWR)
        os.dup2(fd, 0)

    def _redirect_output(self) -> 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) -> 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) -> 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) -> 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: str) -> None:
        logfd = self._get_logfile_dpkg_fd()
        os.write(logfd, msg.encode("utf-8"))
        os.close(logfd)

    def finish_update(self) -> 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) -> 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 KeptPkgs(defaultdict):
    """
    Packages to keep by highest allowed pretty-printed origin

    """
    def __init__(self, *args: Any, **kwargs: Any) -> None:
        super().__init__(*args, **kwargs)
        # the version kept back for each package
        self.versions: dict[str, str] = {}

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

    def versions_set(self) -> set[str]:
        """ Return the kept back packages as "name=version" strings """
        return set("%s=%s" % (pkg, self.versions.get(pkg, ""))
                   for origin_pkgs in self.values() for pkg in origin_pkgs)


class UnattendedUpgradesResult:
    """
    Represent the (potentially partial) results of an unattended-upgrades
    run
    """
    def __init__(self,
                 success: bool,
                 result_str: str = "",
                 pkgs: list[str] = [],
                 pkgs_kept_back: KeptPkgs = KeptPkgs(set),
                 pkgs_removed: list[str] = [],
                 pkgs_kept_installed: list[str] = [],
                 update_stamp: bool = False
                 ) -> 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() -> 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 fix_interrupted_dpkg(options: Options, install_on_shutdown: bool) -> None:
    """
    Run "dpkg --configure -a" on a dirty dpkg journal, this has to happen
    before apt_pkg.pkgsystem_lock() as apt refuses to lock in that case
    """
    if options.dry_run or options.download_only:
        logging.debug("Unclean dpkg state, but not trying to correct it "
                      "in dry-run or download-only mode")
        return
    if install_on_shutdown:
        logging.debug("Unclean dpkg state, but not trying to correct it "
                      "before the install on shutdown")
        return
    # a running package manager leaves entries in the journal as well
    # (LP: #754330), hold the frontend lock like apt does while dpkg runs
    admindir = os.path.dirname(apt_pkg.config.find_file("Dir::State::status"))
    lockfd = apt_pkg.get_lock(os.path.join(admindir, "lock-frontend"), False)
    if lockfd < 0:
        logging.debug("Unclean dpkg state, but locked, another package "
                      "manager working?")
        return
    logging.warning(_("Unclean dpkg state detected, trying to correct"))
    print(_("Unclean dpkg state detected, trying to correct"))
    env = os.environ.copy()
    env["DPKG_FRONTEND_LOCKED"] = "1"
    try:
        output = subprocess.check_output(
            ["dpkg", "--force-confold", "--configure", "-a"],
            env=env,
            stderr=subprocess.STDOUT,
            universal_newlines=True)
    except subprocess.CalledProcessError as e:
        output = e.output
    finally:
        os.close(lockfd)
    logging.warning(_("dpkg --configure -a output:\n%s"), output)


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


def signal_handler(signum: int, frame: object) -> None:
    logging.warning("Signal %s received, will stop", signum)
    global SIGNAL_STOP_REQUEST
    SIGNAL_STOP_REQUEST = True


def log_once(msg: str, level: int = logging.INFO) -> None:
    if msg not in logged_msgs:
        logging.log(level, msg)
        logged_msgs.add(msg)  # type: ignore


def is_metered_connection() -> bool | None:
    """Return whether the active network connection is metered.

    Returns True/False, or None when it cannot be determined (python3-gi
    missing or NetworkManager not reachable on the system bus).

    Queries NetworkManager's "Metered" D-Bus property directly rather than via
    Gio.NetworkMonitor.get_default(), which on hosts without NetworkManager
    dumps the entire kernel route table -- prohibitively expensive on machines
    carrying a full BGP table (LP: #2157046, GH: #404).
    """
    try:
        from gi.repository import Gio, GLib
    except ImportError:
        log_once(_("Checking if connection is metered is skipped. Please "
                   "install python3-gi package to detect metered "
                   "connections and skip downloading updates."))
        return None
    try:
        bus = Gio.bus_get_sync(Gio.BusType.SYSTEM, None)
        ret = bus.call_sync(
            "org.freedesktop.NetworkManager",
            "/org/freedesktop/NetworkManager",
            "org.freedesktop.DBus.Properties",
            "Get",
            GLib.Variant("(ss)",
                         ("org.freedesktop.NetworkManager", "Metered")),
            GLib.VariantType("(v)"),
            Gio.DBusCallFlags.NO_AUTO_START,
            METERED_DBUS_TIMEOUT_MSEC,
            None)
    except GLib.Error as e:
        log_once(_("Checking if connection is metered is skipped because "
                   "NetworkManager could not be queried: %s") % str(e))
        return None
    # NMMetered enum: 1 = YES, 3 = GUESS_YES are metered
    return ret.unpack()[0] in (1, 3)


def read_power_supply_attr(supply: str, attr: str) -> str | None:
    try:
        with open(os.path.join(supply, attr)) as f:
            return f.read().strip()
    except OSError:
        return None


def get_battery_level() -> int | None:
    """
    Return the average charge in percent of the system batteries, or None
    if any of them can not be read.
    """
    levels: list[int] = []
    for supply in glob.glob(os.path.join(POWER_SUPPLY_DIR, "*")):
        if read_power_supply_attr(supply, "type") != "Battery":
            continue
        # skip batteries of peripherals like mice and keyboards
        if read_power_supply_attr(supply, "scope") == "Device":
            continue
        # skip empty battery bays
        if read_power_supply_attr(supply, "present") == "0":
            continue
        capacity = read_power_supply_attr(supply, "capacity")
        if capacity is None or not capacity.isdigit():
            return None
        levels.append(int(capacity))
    if not levels:
        return None
    return sum(levels) // len(levels)


def get_min_battery_level() -> int | None:
    """
    Return the battery charge in percent needed to upgrade on battery, or
    None if upgrades should only run on AC power.
    """
    value = apt_pkg.config.find("Unattended-Upgrade::MinBatteryLevel")
    if not value:
        if not apt_pkg.config.find("Unattended-Upgrade::OnlyOnACPower"):
            return DEFAULT_MIN_BATTERY_LEVEL
        if apt_pkg.config.find_b("Unattended-Upgrade::OnlyOnACPower", True):
            return None
        return 0
    if apt_pkg.config.find("Unattended-Upgrade::OnlyOnACPower"):
        log_once(_("Both MinBatteryLevel and OnlyOnACPower are set, "
                   "ignoring OnlyOnACPower"), logging.WARNING)
    if value == "ac-only":
        return None
    try:
        if 0 <= int(value) <= 100:
            return int(value)
    except ValueError:
        pass
    log_once(_("Invalid MinBatteryLevel \"%s\", upgrading only on AC power")
             % value, logging.WARNING)
    return None


def battery_charged_enough(min_level: int | None) -> bool:
    """
    Return True if the batteries are charged at least min_level percent.
    None means only on AC power, so never.
    """
    if min_level is None:
        return False
    level = get_battery_level()
    if level is None:
        log_once(_("Battery charge level could not be read"),
                 logging.WARNING)
        return False
    if level < min_level:
        logging.info(_("Battery charge is %d%%, below %d%%") % (
            level, min_level))
        return False
    log_once(_("On battery power, charge is %d%%, at least %d%%") % (
        level, min_level))
    return True


def should_stop() -> 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:
        min_level = get_min_battery_level()
        if min_level != 0 \
           and subprocess.call("on_ac_power") == 1 \
           and not battery_charged_enough(min_level):
            logging.warning("System is on battery power, stopping")
            return True
    except (FileNotFoundError, PermissionError):
        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):
        if is_metered_connection():
            logging.warning(_("System is on metered connection, stopping"))
            return True
    return False


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

    Currently supported: ${distro_id}, ${distro_codename} and
    ${distro_release}
    """
    mapping = {"distro_codename": get_distro_codename(),
               "distro_id": get_distro_id(),
               "distro_release": get_distro_release()}
    return string.Template(line).substitute(mapping)


def get_distro_codename() -> str:
    return DISTRO_CODENAME


def get_distro_id() -> str:
    return DISTRO_ID


def get_distro_release() -> str:
    return DISTRO_RELEASE


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


# The version part of a versioned kernel package name (or of "uname -r"),
# i.e. everything up to but excluding the trailing "-<flavour>".  It is the
# upstream "X.Y.Z" followed by either the classic "-<ABI>" number used by
# Debian/Ubuntu (e.g. linux-image-6.1.0-9-amd64, linux-image-5.15.0-1021-kvm)
# or the Debian revision baked into the package name of newer (trixie+)
# kernels (e.g. linux-image-6.12.90+deb13.1-amd64, +deb13, +deb13+1). See #395.
# Note that "[0-9]" is used on purpose instead of "\d", the latter also
# matches non-ASCII digits.
KERNEL_VERSION_REGEXP = (r"[1-9][0-9]*\.[0-9]+\.[0-9]+"
                         r"(-[0-9]+|\+deb[0-9]+([+.][0-9]+)?)")


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(
            [f"^{p}-{KERNEL_VERSION_REGEXP}(-.+)?$"
             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(KERNEL_VERSION_REGEXP,
                         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() -> list[str]:
    """ legacy support for old Allowed-Origins var """
    allowed_origins: 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() -> 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: str,
                           origin: 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: 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: apt.Cache,
                 logfile_dpkg: str,
                 verbose: bool,
                 iprogress: apt.progress.base.InstallProgress | None = None,
                 ) -> tuple[bool, Exception | None]:
    """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: apt.Cache, logfile_dpkg: str, verbose: 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 fetch_archives(cache: apt.Cache, debug: bool = False) -> apt_pkg.Acquire:
    """Download the archives for the marked changes, raises on failure"""
    if debug:
        fetcher = apt_pkg.Acquire(apt.progress.text.AcquireProgress())
    else:
        fetcher = apt_pkg.Acquire()
    cache.fetch_archives(fetcher=fetcher)
    return fetcher


def conffile_prompt_blacklist(fetcher: apt_pkg.Acquire,
                              cache: UnattendedUpgradesCache,
                              ) -> list[str]:
    """Regexps for the fetched packages that would cause a conffile prompt"""
    if not dpkg_conffile_prompt():
        logging.debug("dpkg is configured not to cause conffile prompts")
        return []
    blacklist: list[str] = []
    for item in fetcher.items:
        if not is_deb(item.destfile):
            logging.debug("%s is not a .deb file" % item)
            continue
        if not conffile_prompt(item.destfile):
            continue
        pkg_name = pkgname_from_deb(item.destfile)
        # print to stdout to ensure that this message is part of
        # the cron mail (only if no summary mail is requested)
        if not apt_pkg.config.find("Unattended-Upgrade::Mail", ""):
            print(_("Package %s has conffile prompt and needs "
                    "to be upgraded manually") % pkg_name)
        logging.warning(_("Package %s has conffile prompt and "
                          "needs to be upgraded manually"), pkg_name)
        if not is_pkgname_in_blacklist(pkg_name, cache.blacklist):
            blacklist.append("%s$" % re.escape(pkg_name))
    logging.debug("Packages blacklist due to conffile prompts: %s"
                  % blacklist)
    return blacklist


def upgrade_in_minimal_steps(cache: UnattendedUpgradesCache,
                             pkgs_to_upgrade: list[str],
                             logfile_dpkg: str = "",
                             verbose: bool = False,
                             dry_run: bool = False,
                             *,
                             debug: bool = False,
                             ) -> tuple[bool, list[str], bool]:
    """Mark, download, check and install one package set at a time

    This way the first upgrade starts right away and an interrupted run
    keeps the finished steps. Returns (success, pkgs_upgraded,
    conffile_prompt).
    """
    install_log = LogInstallProgress(logfile_dpkg, verbose)
    keep_debs = apt_pkg.config.find_b(
        "Unattended-Upgrade::Keep-Debs-After-Install", False)

    success = True
    pkgs_upgraded: list[str] = []
    conffile_prompt_found = False
    retried_fetchers: list[apt_pkg.Acquire] = []

    # to upgrade contains the package names
    to_upgrade = set(pkgs_to_upgrade)
    # upgrade packages and dependencies in increasing expected size of
    # package sets to upgrade/install together
    order = upgrade_order(to_upgrade, cache)
    while order:
        pkgname = order.pop(0)
        if pkgname not in to_upgrade:
            # pkg is upgraded in a previous set
            continue
        if should_stop():
            return (False, pkgs_upgraded, conffile_prompt_found)
        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()
            success = 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

        try:
            fetcher = fetch_archives(cache, debug)
        except (apt.cache.FetchFailedException,
                apt.cache.FetchCancelledException,
                apt.cache.LockFailedException, SystemError) as e:
            print(_("Fetching the archives failed: %s") % e)
            logging.error(_("Fetching the archives failed: %s"), e)
            cache.clear()
            success = False
            continue
        blacklist = conffile_prompt_blacklist(fetcher, cache)
        if blacklist:
            # retry the step with the blacklisted packages pinned down
            conffile_prompt_found = True
            cache.blacklist.extend(blacklist)
            cache.apply_pinning(cache.pinning_from_regex_list(
                blacklist, NEVER_PIN))  # type: ignore
            cache.clear()
            # a later step may still need some of these debs
            retried_fetchers.append(fetcher)
            order.insert(0, pkgname)
            continue

        # a stop request may have arrived during the download
        if should_stop():
            cache.clear()
            return (False, pkgs_upgraded, conffile_prompt_found)

        # 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 * 100.0 / all_count
        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, pkgs_upgraded, conffile_prompt_found)
        success = success and res
        if not keep_debs and not dry_run:
            clean_downloaded_packages(fetcher)
        pkgs_upgraded.extend(p for p in changes if p in to_upgrade)
        to_upgrade = to_upgrade - set(changes)
        logging.debug("left to upgrade %s" % to_upgrade)
        if len(to_upgrade) == 0:
            break
    if not keep_debs and not dry_run:
        for fetcher in retried_fetchers:
            clean_downloaded_packages(fetcher)
    # the candidates that can not be upgraded are left in to_upgrade
    if pkgs_upgraded and (success or not to_upgrade):
        logging.info(_("All upgrades installed"))
    return (success, pkgs_upgraded, conffile_prompt_found)


def is_allowed_origin(origin: apt.package.Origin | apt_pkg.PackageFile,
                      allowed_origins: 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: apt.package.Version, allowed_origins: 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: apt.Package,
                          allowed_origins: 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: str, blacklist: 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: str, whitelist: 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: apt.Package,
                          blacklist: list[str],
                          whitelist: list[str],
                          strict_whitelist: 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: apt.Package,
                            cache: apt.Cache,
                            acc: set[str] | None = None,
                            valid_types: collections.abc.Set[str] | None = None,
                            level: int | None = None
                            ) -> set[str]:
    """ All (transitive) dependencies of the package

        Note that alternative (|) dependencies are collected, too
    """
    if acc is None:
        acc = set()

    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: collections.abc.Set[str], cache: 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.
    """

    follow_deps = {'Depends', 'PreDepends', 'Recommends'}

    def upgrade_set_size(pkgname: str) -> int:
        return len(transitive_dependencies(
            cache[pkgname], cache,
            valid_types=follow_deps).intersection(to_upgrade))
    # the name make the order reproducible for identical upgrade set sizes
    return sorted(to_upgrade, key=lambda name: (upgrade_set_size(name), name))


def check_changes_for_sanity(cache: UnattendedUpgradesCache,
                             desired_pkg: apt.Package | None = None) -> 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: UnattendedUpgradesCache,
                   desired_pkg: apt.Package | None) -> str | None:
    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: str) -> bool:
    if file.endswith(".deb"):
        return True
    else:
        return False


def pkgname_from_deb(debfile: 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: str, conf_file: 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: str, prefix: 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: str,
                  conffiles: collections.abc.Set[str] | dict[str, str]) -> str | None:
    """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: str, prefix: 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: collections.abc.Set[str] = set()
    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: str | None = None
        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() -> 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: UnattendedUpgradesCache,
                 pkgs_to_upgrade: 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() -> str:
    return socket.getfqdn()


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


def setup_apt_listchanges(conf: str = "/etc/apt/listchanges.conf") -> 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: str,
                           to_address: str,
                           subject: str,
                           body: 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)
    mail.communicate(encoded_body)
    return mail.returncode


def _send_mail_using_sendmail(from_address: str,
                              to_address: str,
                              subject: str,
                              body: 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)
    sendmail.communicate(msg.as_string())
    return sendmail.returncode


def get_mail_report_option() -> str:
    """ Return the Unattended-Upgrade::MailReport value

    The admin may well wish to get a mail report regardless of what was done.
    This is set by Unattended-Upgrade::MailReport values of:
        "always", "only-on-error", "on-change", "on-new-change" or
        "on-upgrade"
    (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"
    return mail_opt


def send_summary_mail(pkgs: list[str],
                      res: bool,
                      result_str: str,
                      pkgs_kept_back: KeptPkgs | None,
                      pkgs_removed: list[str],
                      pkgs_kept_installed: list[str],
                      mem_log: StringIO | None,
                      dpkg_log_content: str,
                      rootdir: str = "/",
                      ) -> 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

    mail_opt = get_mail_report_option()
    # whether the kept back packages are worth a mail depends on mail_opt
    kept_back = KeptBackMailState(pkgs_kept_back, mail_opt, rootdir)

    # 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 kept_back.is_news and not pkgs_removed)):
        kept_back.record_mailed(False)
        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)
    if res:
        # failed runs do not know the kept back packages
        kept_back.record_mailed(ret == 0)


def do_install(cache: UnattendedUpgradesCache,
               pkgs_to_upgrade: list[str],
               options: Options,
               logfile_dpkg: str,
               ) -> tuple[bool, list[str], bool]:
    """Returns (success, pkgs_upgraded, conffile_prompt)"""
    setup_apt_listchanges()

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

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

    pkg_install_success = False
    pkgs_upgraded: list[str] = []
    conffile_prompt_found = False
    try:
        if options.minimal_upgrade_steps:
            # try upgrade all "pkgs" in minimal steps
            (pkg_install_success,
             pkgs_upgraded,
             conffile_prompt_found) = upgrade_in_minimal_steps(
                cache, pkgs_to_upgrade,
                logfile_dpkg,
                options.verbose or options.debug,
                options.dry_run,
                debug=options.debug)
        else:
            mark_pkgs_to_upgrade(cache, pkgs_to_upgrade)
            pkg_install_success = upgrade_normal(
                cache, logfile_dpkg, options.verbose or options.debug)
            pkgs_upgraded = pkgs_to_upgrade
    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, pkgs_upgraded, conffile_prompt_found)


def _setup_alternative_rootdir(rootdir: 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() -> 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: Options) -> StringIO | None:

    # 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() -> tuple[collections.abc.Set[str], collections.abc.Set[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')
    allusers = set(users.split())
    sysusers = set()
    for user in allusers:
        try:
            uid = pwd.getpwnam(user).pw_uid
            if 0 < uid < 1000:
                sysusers.add(user)
        except KeyError:
            pass
    return allusers, sysusers


def schedule_shutdown() -> None:
    """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 reboot_if_requested_and_needed() -> 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
    reboot_with_users = apt_pkg.config.find_b(
        "Unattended-Upgrade::Automatic-Reboot-WithUsers", True)

    # If we ignore logged in users for reboots, we can exit early after
    # scheduling a reboot
    if reboot_with_users:
        schedule_shutdown()
        return

    reboot_with_sysusers = apt_pkg.config.find_b(
        "Unattended-Upgrade::Automatic-Reboot-WithSystemUsers", True)

    users, sysusers = logged_in_users()

    # Filter out non-blocking users from both sets
    nonblocking_users = set(apt_pkg.config.find(
        "Unattended-Upgrade::Automatic-Reboot-IgnoredUsers", "").split(","))
    users -= nonblocking_users
    sysusers -= nonblocking_users

    real_users = users - sysusers

    # Reboots with logged in users are disallowed at this point, but check
    # whether system users block reboot
    if reboot_with_sysusers:
        if not real_users:
            schedule_shutdown()
        else:
            msg = gettext.ngettext(
                "Found %s, but not rebooting because non-system user %s is logged in." % (  # noqa: E501
                    REBOOT_REQUIRED_FILE, real_users),
                "Found %s, but not rebooting because non-system user %s are logged in." % (  # noqa: E501
                    REBOOT_REQUIRED_FILE, real_users),
                len(real_users))
            logging.warning(msg)
        return

    if not users:
        schedule_shutdown()
        return

    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)


def write_stamp_file() -> 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, "unattended-upgrades-stamp"), "w"):
        pass


def try_to_upgrade(pkg: apt.Package,
                   pkgs_to_upgrade: list[apt.Package],
                   cache: UnattendedUpgradesCache,
                   ) -> 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: 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 find_upgrade_candidates(cache: UnattendedUpgradesCache,
                            debug: bool = False,
                            ) -> list[apt.Package]:
    """Packages with a newer version in an allowed origin, not yet checked
       if they can be upgraded (see calculate_upgradable_pkgs())
    """
    candidates: list[apt.Package] = []
    for pkg in cache:
        # check the signal directly rather than should_stop() which spawns
        # on_ac_power per call, too expensive in this per-package loop
        if SIGNAL_STOP_REQUEST:
            logging.warning(_("SIGNAL received, stopping package check"))
            break
        if 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
            candidates.append(pkg)
    return candidates


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

    # now do the actual upgrade
    for pkg in find_upgrade_candidates(cache, options.debug):
        # trying the candidates is the slow part, so check here as well
        if SIGNAL_STOP_REQUEST:
            logging.warning(_("SIGNAL received, stopping package check"))
            break
        try_to_upgrade(pkg,
                       pkgs_to_upgrade,
                       cache)

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

    return pkgs_to_upgrade


def get_dpkg_progress_prefixes() -> tuple[str, ...]:
    """Return the text dpkg starts its "Reading database" progress lines with

    dpkg translates it, and since dpkg 1.23 even its English catalog does
    (with an ellipsis character instead of "..."), so also look it up in
    dpkg's catalog for the locale dpkg runs with.
    """
    text = "(Reading database ... "
    return (text, gettext.dgettext("dpkg", text))


def get_dpkg_log_content(logfile_dpkg: str,
                         install_start_time: datetime.datetime) -> str:
    logging.debug("Extracting content from %s since %s" % (
        logfile_dpkg, install_start_time))
    progress_prefixes = get_dpkg_progress_prefixes()
    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 (line.startswith(progress_prefixes)
                            or re.match("[0-9]+%$", line)):
                        continue
                    content.append(line)
        return "".join(content)
    except FileNotFoundError:
        return ""


def get_auto_removable(cache: apt.Cache) -> collections.abc.Set[str]:
    return {pkg.name for pkg in cache
            if pkg.is_auto_removable}


def is_autoremove_valid(cache: UnattendedUpgradesCache,
                        pkgname: str,
                        auto_removable: collections.abc.Set[str],
                        ) -> 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 _commit_auto_removals(cache: UnattendedUpgradesCache,
                          logfile_dpkg: str,
                          verbose: bool,
                          dry_run: bool
                          ) -> tuple[bool, Exception | None, list[str]]:
    """Commit the pending removals marked in the cache.

    Returns a (success, error, pkgs_removed) tuple where pkgs_removed
    holds the names of the packages that were actually removed (empty on
    a dry-run or a failed commit).
    """
    if dry_run:
        cache.clear()
        return (True, None, [])
    pkgnames = [pkg.name for pkg in cache.get_changes()]
    res, error = cache_commit(cache, logfile_dpkg, verbose)
    return (res, error, pkgnames if res else [])


def do_auto_remove(cache: UnattendedUpgradesCache,
                   auto_removable: collections.abc.Set[str],
                   logfile_dpkg: str,
                   minimal_steps: bool,
                   verbose: bool = False,
                   dry_run: bool = False
                   ) -> tuple[bool, list[str], list[str]]:
    res = True
    error: Exception | None = None
    if not auto_removable:
        return (res, [], [])

    pkgs_removed: list[str] = []
    pkgs_kept_installed: list[str] = []
    purge = apt_pkg.config.find_b("APT::Get::Purge", False)
    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(purge=purge)
            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
            res, error, removed = _commit_auto_removals(
                cache, logfile_dpkg, verbose, dry_run)
            if not res:
                break
            pkgs_removed.extend(removed)
    else:
        for pkgname in auto_removable:
            cache[pkgname].mark_delete(purge=purge)
        if is_autoremove_valid(cache, "", auto_removable):
            # do it in one step
            res, error, removed = _commit_auto_removals(
                cache, logfile_dpkg, verbose, dry_run)
            pkgs_removed.extend(removed)
        else:
            # removing the auto-removable packages would also remove
            # packages that are not set for removal, so keep them installed
            pkgs_kept_installed = list(auto_removable)
            cache.clear()

    if res:
        logging.info(_("Packages that were successfully auto-removed: %s"),
                     " ".join(sorted(pkgs_removed)))
        logging.info(_("Packages that were kept from being auto-removed: %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: 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() -> 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


class KeptBackMailState:
    """
    Which kept back packages the admin was already told about by mail,
    see the "on-new-change" and "on-upgrade" values of
    Unattended-Upgrade::MailReport
    """
    def __init__(self, kept_pkgs: KeptPkgs | None, mode: str,
                 rootdir: str) -> None:
        self.mode = mode
        self.path = os.path.join(rootdir, KEPT_PACKAGES_MAILED_FILE)
        self.versions = kept_pkgs.versions_set() if kept_pkgs else set()
        self.mailed: set[str] = set()
        if self.mode == "on-new-change":
            self.mailed = self._read_mailed()

    def _read_mailed(self) -> set[str]:
        try:
            with open(self.path) as f:
                return set(f.read().split())
        except FileNotFoundError:
            pass
        except OSError as e:
            logging.error(_("Could not read %s: %s"), self.path, e)
        return set()

    @property
    def is_news(self) -> bool:
        """ True if the kept back packages alone are worth a mail """
        if not self.versions or self.mode == "on-upgrade":
            return False
        if self.mode == "on-new-change":
            return not self.versions <= self.mailed
        return True

    def record_mailed(self, mail_sent: bool) -> None:
        """ Remember the kept back packages once the admin knows them """
        if self.mode != "on-new-change" or (self.is_news and not mail_sent):
            return
        try:
            if self.versions:
                with open(self.path, "w") as f:
                    f.write("\n".join(sorted(self.versions)) + "\n")
            elif os.path.exists(self.path):
                os.remove(self.path)
        except OSError as e:
            logging.error(_("Could not save the list of kept back packages "
                            "already mailed to %s: %s"), self.path, e)


def update_kept_pkgs_file(kept_pkgs: defaultdict[str, list[str]],
                          kept_file: 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: Options, rootdir: 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.update_stamp and not options.dry_run:
            # the run got far enough to know the kept back packages, even
            # if it failed, e.g. because of a conffile prompt
            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, rootdir)
            # report results to any plugin
            plugin_manager.postrun(res, mem_log, log_content)

        if res.update_stamp:
            # write timestamp file
            write_stamp_file()
            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, rootdir)
        # Re-raise exceptions for apport
        raise


def mark_pkgs_to_upgrade(cache: UnattendedUpgradesCache,
                         pkgs_to_upgrade: list[str]) -> None:
    for pkg_name in pkgs_to_upgrade:
        pkg = cache[pkg_name]
        installed = pkg.installed
        candidate = pkg.candidate
        if pkg.is_upgradable \
           or (installed and candidate
               and candidate.version != 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: Options,
        rootdir: str,
        mem_log: StringIO | None,
        logfile_dpkg: str,
        install_start_time: datetime.datetime,
        ) -> 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)

            if (isinstance(devel, distro_info.DistroRelease)
                    and devel.series == DISTRO_CODENAME):
                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 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
    install_on_shutdown = (
        "UNATTENDED_UPGRADES_FORCE_INSTALL_ON_SHUTDOWN" not in os.environ
        and apt_pkg.config.find_b(
            "Unattended-Upgrade::InstallOnShutdown", False))

    # check if the journal is dirty and if so, take emergency 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):
        fix_interrupted_dpkg(options, install_on_shutdown)

    # 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"))

    # 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"))

    # in minimal steps mode each step is checked, downloaded and installed
    # in do_install() so that the first upgrade starts right away, unless
    # this run only downloads for --download-only or the install on shutdown
    greedy = (options.minimal_upgrade_steps
              and not options.download_only
              and not install_on_shutdown)

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

        # find out about the packages that are upgradable (in an
        # allowed_origin)
        if greedy:
            pkgs_to_upgrade = [
                pkg for pkg in find_upgrade_candidates(cache, options.debug)
                if is_pkg_change_allowed(pkg, cache.blacklist,
                                         cache.whitelist,
                                         cache.strict_whitelist)]
        else:
            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))

    pkg_conffile_prompt = False
    fetcher: apt_pkg.Acquire | None = None
    if not greedy:
        # download what looks good
        mark_pkgs_to_upgrade(cache, pkgs)

        # 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:
            fetcher = fetch_archives(cache, options.debug)
        except (apt.cache.FetchFailedException,
                apt.cache.FetchCancelledException,
                apt.cache.LockFailedException, SystemError) as e:
            print(_("Fetching the archives failed: %s") % e)
            logging.error(_("Fetching the archives failed: %s"), e)
            return UnattendedUpgradesResult(
                False, _("Fetching the archives failed: %s") % e)

        if options.download_only:
            return UnattendedUpgradesResult(True)

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

        conffile_blacklist = conffile_prompt_blacklist(fetcher, cache)
        pkg_conffile_prompt = len(conffile_blacklist) > 0

        # redo the selection about the packages to upgrade based on the new
        # blacklist
        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()

    # auto-removals
    kernel_pkgs_remove_success: bool = True
    kernel_pkgs_removed: list[str] = []
    kernel_pkgs_kept_installed: 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()

    def nothing_to_do_result() -> UnattendedUpgradesResult:
        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 and not pkg_conffile_prompt,
            _("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)

    # exit if there is nothing to do and nothing to report
    if (len(pending_autoremovals) == 0
            and len(pkgs_to_upgrade) == 0):
        return nothing_to_do_result()

    if install_on_shutdown:
        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]
    if greedy:
        # the candidates are only checked step by step in do_install()
        logging.info(_("Packages that may be upgraded: %s"), " ".join(pkgs))
    else:
        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
        (pkg_install_success,
         pkgs_upgraded,
         install_conffile_prompt) = do_install(cache,
                                               pkgs,
                                               options,
                                               logfile_dpkg)
        if not pkg_install_success and should_stop():
            # the install was cut short by a signal, low battery or a
            # metered connection: the packages not reached yet are not
            # kept back, so leave the kept-back list and the stamp alone
            if greedy and pkgs_upgraded:
                logging.info(_("Packages that were upgraded: %s"),
                             " ".join(sorted(pkgs_upgraded)))
            return UnattendedUpgradesResult(
                False, _("Upgrade was interrupted"),
                pkgs=sorted(pkgs_upgraded),
                pkgs_removed=kernel_pkgs_removed,
                pkgs_kept_installed=kernel_pkgs_kept_installed)
        pkg_conffile_prompt = pkg_conffile_prompt or install_conffile_prompt
        if greedy:
            pkgs = sorted(pkgs_upgraded)
            if (not pkgs and pkg_install_success
                    and len(pending_autoremovals) == 0):
                # none of the candidates could be upgraded, report it
                # like the non-greedy mode does
                return nothing_to_do_result()
            logging.info(_("Packages that were upgraded: %s"),
                         " ".join(pkgs))
    # 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: list[str] = []
    pkgs_kept_installed: 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 (fetcher is not None
            and 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)
    signal.signal(signal.SIGINT, 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))
