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



Upload:

Command:

www-data@216.73.216.10: ~ $
#!/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
#

import atexit
import copy
import datetime
import errno
import email.charset
import fcntl
import fnmatch
import gettext
try:
    from gi.repository.Gio import NetworkMonitor
except ImportError:
    pass
import grp
import io
import locale
import logging
import logging.handlers
import re
import os
import select
import signal
import socket
import string
import subprocess
import sys
import syslog

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

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

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

import apt
import apt_inst
import apt_pkg

import distro_info


# the reboot required flag file used by packages
REBOOT_REQUIRED_FILE = "/var/run/reboot-required"
KEPT_PACKAGES_FILE = "var/lib/unattended-upgrades/kept-back"
MAIL_BINARY = "/usr/bin/mail"
SENDMAIL_BINARY = "/usr/sbin/sendmail"
USERS = "/usr/bin/users"
# no py3 lsb_release in debian :/
DISTRO_CODENAME = subprocess.check_output(
    ["lsb_release", "-c", "-s"], universal_newlines=True).strip()  # type: str
DISTRO_DESC = subprocess.check_output(
    ["lsb_release", "-d", "-s"], universal_newlines=True).strip()  # type: str
DISTRO_ID = subprocess.check_output(
    ["lsb_release", "-i", "-s"], universal_newlines=True).strip()  # type: str

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

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

# set from the sigint signal handler
SIGNAL_STOP_REQUEST = False

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

NEVER_PIN = -32768


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

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

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


class UnknownMatcherError(ValueError):
    pass


class NoAllowedOriginError(ValueError):
    pass


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


class UnattendedUpgradesCache(apt.Cache):

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        return pins

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

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

    def open(self, progress=None):
        apt.Cache.open(self, progress)
        # apply pinning generated from unattended-upgrades configuration
        self.apply_pinning(self.pinning_from_config())

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

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

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

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

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


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

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

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


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

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


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


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


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


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


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


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

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


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


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


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


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


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


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


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

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


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


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


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

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

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


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


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

    res = True

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

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

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

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


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

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


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


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


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


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


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

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


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

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

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


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

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


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


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


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


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


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


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


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


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

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

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

    # Conffiles:
    #  /etc/bash_completion.d/m-a c7780fab6b14d75ca54e11e992a6c11c
    dpkg_status_conffiles = {}
    for line in conffiles.splitlines():
        # ignore empty lines
        line = line.strip()
        if not line:
            continue
        # show what we do
        logging.debug("conffile line: %s", line)
        li = line.split()
        conf_file = li[0]
        md5 = li[1]
        if len(li) > 2:
            obs = li[2]
        else:
            obs = None
        # 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
        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)
                if current_md5 != "" and pkg_md5sum != current_md5:
                    return True
    return False


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


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


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


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


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


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


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


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

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

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

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

    # Check if reboot-required flag is present
    reboot_flag_str = _(
        "[reboot required]") if os.path.isfile(REBOOT_REQUIRED_FILE) 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 os.path.isfile(REBOOT_REQUIRED_FILE):
        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")
    body += mem_log.getvalue()

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

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


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

    setup_apt_listchanges()

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

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

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

    return pkg_install_success


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


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


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

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

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

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


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


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


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


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


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

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

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

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

    return pkgs_to_upgrade


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


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


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

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


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

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

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


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


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


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


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

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

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

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

    try:
        res = run(options, rootdir, mem_log, logfile_dpkg,
                  install_start_time)

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

        if res.result_str and not options.dry_run:
            # there is some meaningful result which is worth an email
            log_content = get_dpkg_log_content(logfile_dpkg,
                                               install_start_time)
            send_summary_mail(res.pkgs, res.success, res.result_str,
                              res.pkgs_kept_back, res.pkgs_removed,
                              res.pkgs_kept_installed, mem_log,
                              log_content)
        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)
        # Re-raise exceptions for apport
        raise


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


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

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

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

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

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

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

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

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

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

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

    # FIXME: make this into a ContextManager
    # be nice when calculating the upgrade as its pretty CPU intensive
    old_priority = os.nice(0)
    try:
        # Check that we will be able to restore the priority
        os.nice(-1)
        os.nice(20)
    except OSError as e:
        if e.errno in (errno.EPERM, errno.EACCES):
            pass
        else:
            raise

    auto_removable = get_auto_removable(cache)

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

    # FIXME: make this into a ContextManager
    # stop being nice
    os.nice(old_priority - os.nice(0))

    # download what looks good
    mark_pkgs_to_upgrade(cache, pkgs)

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

    if options.download_only:
        return UnattendedUpgradesResult(True)

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

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

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

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

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

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

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

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

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

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

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

    # only perform install step if we actually have packages to install
    pkg_install_success = True
    if len(pkgs_to_upgrade) > 0:
        # do install
        pkg_install_success = do_install(cache,
                                         pkgs,
                                         options,
                                         logfile_dpkg)
    # Was the overall run succesful: only if everything installed
    # fine and nothing was held back because of a conffile prompt.
    successful_run = (kernel_pkgs_remove_success and pkg_install_success
                      and not pkg_conffile_prompt)

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

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

    # the user wants *all* auto-removals to be removed
    # (unless u-u got signalled to stop gracefully quickly)
    pkgs_removed = []         # type: List[str]
    pkgs_kept_installed = []  # type: List[str]
    if ((apt_pkg.config.find_b(
            "Unattended-Upgrade::Remove-Unused-Dependencies", False)
         and not SIGNAL_STOP_REQUEST)):
        auto_removals = get_auto_removable(cache)
        (pkg_remove_success,
         pkgs_removed,
         pkgs_kept_installed) = do_auto_remove(
            cache, auto_removals, logfile_dpkg, options.minimal_upgrade_steps,
            options.verbose or options.debug,
            options.dry_run)
        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)
        successful_run = successful_run and pkg_remove_success

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

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

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


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


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

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

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

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

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

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

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

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

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

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

Filemanager

Name Type Size Permission Actions
X11 Folder 0755
411toppm File 14.3 KB 0755
JxrDecApp File 26.38 KB 0755
JxrEncApp File 27.77 KB 0755
NF File 963 B 0755
VGAuthService File 130.54 KB 0755
[ File 54.44 KB 0755
aa-enabled File 18.3 KB 0755
aa-exec File 18.3 KB 0755
aa-features-abi File 18.3 KB 0755
ab File 58.43 KB 0755
acpidbg File 1.58 KB 0755
add-apt-repository File 16.04 KB 0755
addpart File 14.38 KB 0755
animate File 14.31 KB 0755
animate-im6 File 14.31 KB 0755
animate-im6.q16 File 14.31 KB 0755
anytopnm File 12.26 KB 0755
apport-bug File 2.27 KB 0755
apport-cli File 13.31 KB 0755
apport-collect File 2.27 KB 0755
apport-unpack File 3.7 KB 0755
appstreamcli File 138.23 KB 0755
apropos File 47.28 KB 0755
apt File 18.38 KB 0755
apt-add-repository File 16.04 KB 0755
apt-cache File 86.47 KB 0755
apt-cdrom File 26.47 KB 0755
apt-config File 30.39 KB 0755
apt-extracttemplates File 22.47 KB 0755
apt-ftparchive File 222.48 KB 0755
apt-get File 50.47 KB 0755
apt-key File 27.99 KB 0755
apt-mark File 54.47 KB 0755
apt-sortpkgs File 50.4 KB 0755
arch File 34.51 KB 0755
aria_chk File 5.52 MB 0755
aria_dump_log File 5.31 MB 0755
aria_ftdump File 5.32 MB 0755
aria_pack File 5.35 MB 0755
aria_read_log File 5.48 MB 0755
arpaname File 14.3 KB 0755
asciitopgm File 14.3 KB 0755
atktopbm File 14.3 KB 0755
automat-visualize3 File 984 B 0755
avstopam File 14.3 KB 0755
awk File 722.5 KB 0755
b2sum File 54.51 KB 0755
base32 File 38.51 KB 0755
base64 File 38.51 KB 0755
basename File 34.51 KB 0755
basenc File 46.51 KB 0755
bash File 1.38 MB 0755
bashbug File 6.82 KB 0755
bc File 90.82 KB 0755
bdftopcf File 42.26 KB 0755
bdftruncate File 14.15 KB 0755
bioradtopgm File 14.3 KB 0755
bmptopnm File 26.3 KB 0755
bmptoppm File 26.3 KB 0755
boltctl File 122.84 KB 0755
bpftrace File 2.15 MB 0755
bpftrace-aotrt File 985.37 KB 0755
brushtopbm File 14.3 KB 0755
btrfs File 1001.25 KB 0755
btrfs-convert File 576.3 KB 0755
btrfs-find-root File 520.3 KB 0755
btrfs-image File 552.3 KB 0755
btrfs-map-logical File 520.3 KB 0755
btrfs-select-super File 516.3 KB 0755
btrfsck File 1001.25 KB 0755
btrfstune File 544.3 KB 0755
busctl File 94.59 KB 0755
busybox File 2.03 MB 0755
byobu File 8.5 KB 0755
byobu-config File 996 B 0755
byobu-ctrl-a File 4.66 KB 0755
byobu-disable File 1.26 KB 0755
byobu-disable-prompt File 1.31 KB 0755
byobu-enable File 1.15 KB 0755
byobu-enable-prompt File 1.42 KB 0755
byobu-export File 1.39 KB 0755
byobu-janitor File 7.04 KB 0755
byobu-keybindings File 1.47 KB 0755
byobu-launch File 3.25 KB 0755
byobu-launcher File 1.87 KB 0755
byobu-launcher-install File 2.47 KB 0755
byobu-launcher-uninstall File 1.52 KB 0755
byobu-layout File 3.27 KB 0755
byobu-prompt File 1.13 KB 0755
byobu-quiet File 1.38 KB 0755
byobu-reconnect-sockets File 3.22 KB 0755
byobu-screen File 8.5 KB 0755
byobu-select-backend File 1.42 KB 0755
byobu-select-profile File 5.06 KB 0755
byobu-select-session File 1012 B 0755
byobu-shell File 1.66 KB 0755
byobu-silent File 1.28 KB 0755
byobu-status File 5.87 KB 0755
byobu-status-detail File 1.18 KB 0755
byobu-tmux File 8.5 KB 0755
byobu-ugraph File 4.56 KB 0755
byobu-ulevel File 11.71 KB 0755
c_rehash File 6.68 KB 0755
cacaclock File 14.45 KB 0755
cacademo File 278.39 KB 0755
cacafire File 18.3 KB 0755
cacaplay File 14.3 KB 0755
cacaserver File 18.3 KB 0755
cacaview File 22.39 KB 0755
cameratopam File 110.38 KB 0755
captoinfo File 90.41 KB 0755
cat File 38.46 KB 0755
catman File 30.77 KB 0755
certbot File 958 B 0755
cftp3 File 224 B 0755
cgi-fcgi File 18.15 KB 0755
chafa File 170.23 KB 0755
chage File 70.49 KB 2755
chardet File 221 B 0755
chardetect File 221 B 0755
chattr File 14.31 KB 0755
chcon File 58.51 KB 0755
checkgid File 14.3 KB 0755
chfn File 71.09 KB 4755
chgrp File 58.51 KB 0755
chmod File 54.51 KB 0755
choom File 22.38 KB 0755
chown File 58.51 KB 0755
chrt File 30.38 KB 0755
chsh File 43.71 KB 4755
chvt File 14.37 KB 0755
cifsiostat File 26.45 KB 0755
cistopbm File 14.3 KB 0755
ckbcomp File 147.14 KB 0755
ckeygen3 File 227 B 0755
cksum File 102.52 KB 0755
clear File 14.31 KB 0755
clear_console File 14.23 KB 0755
cmp File 42.39 KB 0755
cmuwmtopbm File 14.3 KB 0755
codepage File 14.3 KB 0755
col File 22.38 KB 0755
col1 File 963 B 0755
col2 File 963 B 0755
col3 File 963 B 0755
col4 File 963 B 0755
col5 File 963 B 0755
col6 File 963 B 0755
col7 File 963 B 0755
col8 File 963 B 0755
col9 File 963 B 0755
colcrt File 14.38 KB 0755
colrm File 14.38 KB 0755
column File 38.38 KB 0755
comm File 38.52 KB 0755
compare File 14.31 KB 0755
compare-im6 File 14.31 KB 0755
compare-im6.q16 File 14.31 KB 0755
composite File 14.31 KB 0755
composite-im6 File 14.31 KB 0755
composite-im6.q16 File 14.31 KB 0755
conch3 File 225 B 0755
conjure File 14.31 KB 0755
conjure-im6 File 14.31 KB 0755
conjure-im6.q16 File 14.31 KB 0755
convert File 14.31 KB 0755
convert-im6 File 14.31 KB 0755
convert-im6.q16 File 14.31 KB 0755
corelist File 15.01 KB 0755
cp File 138.52 KB 0755
cpan File 8.16 KB 0755
cpan5.38-x86_64-linux-gnu File 8.18 KB 0755
cpio File 137.67 KB 0755
cpupower File 1.58 KB 0755
crontab File 38.73 KB 2755
csplit File 50.51 KB 0755
ctail File 960 B 0755
ctstat File 22.66 KB 0755
curl File 290.32 KB 0755
cut File 38.51 KB 0755
cvtsudoers File 321.1 KB 0755
dash File 126.74 KB 0755
date File 106.51 KB 0755
dbilogstrip File 1.35 KB 0755
dbiprof File 6.06 KB 0755
dbiproxy File 5.27 KB 0755
dbus-cleanup-sockets File 14.29 KB 0755
dbus-daemon File 230.64 KB 0755
dbus-monitor File 26.3 KB 0755
dbus-run-session File 14.3 KB 0755
dbus-send File 30.29 KB 0755
dbus-update-activation-environment File 14.29 KB 0755
dbus-uuidgen File 14.29 KB 0755
dbxtool File 30.3 KB 0755
dd File 70.54 KB 0755
ddbugtopbm File 14.3 KB 0755
deallocvt File 14.37 KB 0755
deb-systemd-helper File 23.79 KB 0755
deb-systemd-invoke File 6.97 KB 0755
debconf File 2.8 KB 0755
debconf-apt-progress File 11.57 KB 0755
debconf-communicate File 623 B 0755
debconf-copydb File 1.68 KB 0755
debconf-escape File 668 B 0755
debconf-set-selections File 3.14 KB 0755
debconf-show File 1.78 KB 0755
debian-distro-info File 30.95 KB 0755
delpart File 14.38 KB 0755
delv File 45.32 KB 0755
df File 87.08 KB 0755
dh_bash-completion File 4.42 KB 0755
dh_installxmlcatalogs File 9.22 KB 0755
dh_perl_dbi File 1.17 KB 0755
diff File 134.55 KB 0755
diff3 File 58.52 KB 0755
dig File 150.83 KB 0755
dir File 138.98 KB 0755
dircolors File 46.52 KB 0755
dirmngr File 473.77 KB 0755
dirmngr-client File 54.92 KB 0755
dirname File 34.38 KB 0755
display File 14.31 KB 0755
display-im6 File 14.31 KB 0755
display-im6.q16 File 14.31 KB 0755
distro-info File 26.89 KB 0755
dmesg File 68.64 KB 0755
dnsdomainname File 22.23 KB 0755
dnssec-cds File 51.39 KB 0755
dnssec-dsfromkey File 38.38 KB 0755
dnssec-importkey File 38.38 KB 0755
dnssec-keyfromlabel File 42.38 KB 0755
dnssec-keygen File 46.38 KB 0755
dnssec-revoke File 30.38 KB 0755
dnssec-settime File 46.38 KB 0755
dnssec-signzone File 90.41 KB 0755
dnssec-verify File 30.39 KB 0755
do-release-upgrade File 10.42 KB 0755
domainname File 22.23 KB 0755
dpkg File 310.72 KB 0755
dpkg-deb File 142.58 KB 0755
dpkg-divert File 118.57 KB 0755
dpkg-maintscript-helper File 20.71 KB 0755
dpkg-query File 134.56 KB 0755
dpkg-realpath File 4.09 KB 0755
dpkg-split File 98.53 KB 0755
dpkg-statoverride File 50.38 KB 0755
dpkg-trigger File 42.53 KB 0755
du File 98.51 KB 0755
dumpkeys File 162.85 KB 0755
dvipdf File 1007 B 0755
ec2metadata File 8.38 KB 0755
echo File 34.38 KB 0755
ed File 58.55 KB 0755
editor File 272.5 KB 0755
egrep File 41 B 0755
eject File 42.23 KB 0755
enc2xs File 40.96 KB 0755
encguess File 3 KB 0755
env File 46.95 KB 0755
envsubst File 34.38 KB 0755
eps2eps File 639 B 0755
eqn File 188.45 KB 0755
escp2topbm File 14.3 KB 0755
ex File 3.94 MB 0755
expand File 34.53 KB 0755
expiry File 26.52 KB 2755
expr File 42.41 KB 0755
eyuvtoppm File 14.3 KB 0755
factor File 62.51 KB 0755
fail2ban-client File 1.39 KB 0755
fail2ban-python File 7.65 MB 0755
fail2ban-regex File 1.25 KB 0755
fail2ban-server File 1.38 KB 0755
fail2ban-testcases File 2.23 KB 0755
faillog File 22.63 KB 0755
fallocate File 26.38 KB 0755
false File 26.3 KB 0755
fc-cache File 22.38 KB 0755
fc-cat File 18.38 KB 0755
fc-conflist File 14.38 KB 0755
fc-list File 14.38 KB 0755
fc-match File 14.38 KB 0755
fc-pattern File 14.38 KB 0755
fc-query File 14.38 KB 0755
fc-scan File 14.38 KB 0755
fc-validate File 14.38 KB 0755
fcgistarter File 14.3 KB 0755
fgconsole File 14.37 KB 0755
fgrep File 41 B 0755
fiascotopnm File 95.15 KB 0755
figlet File 26.68 KB 0755
figlet-toilet File 26.68 KB 0755
filan File 50.48 KB 0755
file File 30.6 KB 0755
finalrd File 2.06 KB 0755
find File 199.48 KB 0755
findmnt File 67.66 KB 0755
fitstopnm File 18.3 KB 0755
flock File 22.48 KB 0755
fmt File 38.51 KB 0755
fold File 34.51 KB 0755
fonttosfnt File 38.16 KB 0755
free File 26.38 KB 0755
fstopgm File 14.3 KB 0755
ftp File 182.9 KB 0755
funzip File 26.3 KB 0755
fuser File 39.34 KB 0755
fusermount File 38.38 KB 4755
fusermount3 File 38.38 KB 4755
fwupdmgr File 118.3 KB 0755
fwupdtool File 110.3 KB 0755
g3topbm File 19.13 KB 0755
galera_new_cluster File 917 B 0755
galera_recovery File 3.29 KB 0755
gapplication File 22.38 KB 0755
gawk File 722.5 KB 0755
gawkbug File 6.74 KB 0755
gdbus File 50.38 KB 0755
gdk-pixbuf-csource File 14.33 KB 0755
gdk-pixbuf-pixdata File 14.31 KB 0755
gdk-pixbuf-thumbnailer File 18.39 KB 0755
gemtopbm File 14.3 KB 0755
gemtopnm File 14.3 KB 0755
gencat File 26.44 KB 0755
geoiplookup File 18.3 KB 0755
geoiplookup6 File 14.3 KB 0755
geqn File 188.45 KB 0755
getconf File 26.36 KB 0755
getent File 38.72 KB 0755
getkeycodes File 14.37 KB 0755
getopt File 22.38 KB 0755
gettext File 34.38 KB 0755
gettext.sh File 5.07 KB 0755
ghostscript File 14.15 KB 0755
giftopnm File 26.3 KB 0755
ginstall-info File 47.24 KB 0755
gio File 102.4 KB 0755
gio-querymodules File 18.3 KB 0755
git File 3.88 MB 0755
git-receive-pack File 3.88 MB 0755
git-shell File 624.81 KB 0755
git-upload-archive File 3.88 MB 0755
git-upload-pack File 3.88 MB 0755
glib-compile-schemas File 54.3 KB 0755
gouldtoppm File 14.3 KB 0755
gpasswd File 74.46 KB 4755
gpg File 1.09 MB 0755
gpg-agent File 357.52 KB 0755
gpg-connect-agent File 87.3 KB 0755
gpg-wks-client File 139.37 KB 0755
gpgconf File 115.36 KB 0755
gpgparsemail File 34.38 KB 0755
gpgsm File 501.37 KB 0755
gpgsplit File 26.62 KB 0755
gpgtar File 67.83 KB 0755
gpgv File 303.14 KB 0755
gpic File 196.06 KB 0755
gpu-manager File 78.82 KB 0755
grep File 182.45 KB 0755
gresource File 22.3 KB 0755
groff File 94.51 KB 0755
grog File 18.75 KB 0755
grops File 162.55 KB 0755
grotty File 118.51 KB 0755
groups File 34.51 KB 0755
growpart File 29.19 KB 0755
grub-editenv File 393.16 KB 0755
grub-file File 741.88 KB 0755
grub-fstest File 863.32 KB 0755
grub-glue-efi File 102.88 KB 0755
grub-kbdcomp File 1.64 KB 0755
grub-menulst2cfg File 83.2 KB 0755
grub-mkfont File 131.45 KB 0755
grub-mkimage File 377.26 KB 0755
grub-mklayout File 103.23 KB 0755
grub-mknetdir File 429.77 KB 0755
grub-mkpasswd-pbkdf2 File 111.32 KB 0755
grub-mkrelpath File 259.79 KB 0755
grub-mkrescue File 1019.84 KB 0755
grub-mkstandalone File 510.16 KB 0755
grub-mount File 682.21 KB 0755
grub-ntldr-img File 38.39 KB 0755
grub-render-label File 750.23 KB 0755
grub-script-check File 126.76 KB 0755
grub-syslinux2cfg File 698.71 KB 0755
gs File 14.15 KB 0755
gsbj File 350 B 0755
gsdj File 352 B 0755
gsdj500 File 352 B 0755
gsettings File 30.3 KB 0755
gslj File 353 B 0755
gslp File 350 B 0755
gsnd File 277 B 0755
gtbl File 134.48 KB 0755
gunzip File 2.29 KB 0755
gzexe File 6.3 KB 0755
gzip File 91.23 KB 0755
h2ph File 28.54 KB 0755
h2xs File 59.51 KB 0755
hardlink File 46.48 KB 0755
hd File 46.39 KB 0755
hdifftopam File 14.3 KB 0755
head File 42.51 KB 0755
helpztags File 2.46 KB 0755
hexdump File 46.39 KB 0755
hipstopgm File 14.3 KB 0755
host File 118.82 KB 0755
hostid File 34.51 KB 0755
hostname File 22.23 KB 0755
hostnamectl File 30.45 KB 0755
hpcdtoppm File 798 B 0755
htcacheclean File 34.31 KB 0755
htdbm File 26.3 KB 0755
htdigest File 14.3 KB 0755
htop File 370.33 KB 0755
htpasswd File 26.3 KB 0755
hwe-support-status File 11.24 KB 0755
i386 File 26.65 KB 0755
icontopbm File 14.3 KB 0755
iconv File 66.48 KB 0755
id File 38.51 KB 0755
identify File 14.31 KB 0755
identify-im6 File 14.31 KB 0755
identify-im6.q16 File 14.31 KB 0755
ilbmtoppm File 38.38 KB 0755
imagetops File 1.21 KB 0755
img2sixel File 26.3 KB 0755
img2txt File 18.66 KB 0755
imgtoppm File 14.3 KB 0755
import File 14.31 KB 0755
import-im6 File 14.31 KB 0755
import-im6.q16 File 14.31 KB 0755
inetutils-telnet File 177.85 KB 0755
info File 241.73 KB 0755
infobrowser File 241.73 KB 0755
infocmp File 66.38 KB 0755
infotocap File 90.41 KB 0755
infotopam File 18.3 KB 0755
innochecksum File 4.57 MB 0755
innotop File 445.71 KB 0755
install File 142.52 KB 0755
install-info File 47.24 KB 0755
instmodsh File 4.27 KB 0755
ionice File 18.38 KB 0755
iostat File 54.44 KB 0755
ip File 754.8 KB 0755
ipcmk File 22.45 KB 0755
ipcrm File 18.38 KB 0755
ipcs File 38.38 KB 0755
iptables-xml File 92.95 KB 0755
ischroot File 14.48 KB 0755
iscsiadm File 370.43 KB 0755
jbigtopnm File 57.14 KB 0755
join File 50.55 KB 0755
journalctl File 78.91 KB 0755
jp2a File 50.75 KB 0755
jpeg2ktopam File 208.82 KB 0755
jpegtopnm File 38.38 KB 0755
jq File 30.15 KB 0755
json_pp File 4.88 KB 0755
kbd_mode File 14.66 KB 0755
kbdinfo File 18.37 KB 0755
kbxutil File 62.83 KB 0755
keep-one-running File 3.51 KB 0755
kernel-install File 54.67 KB 0755
kill File 22.38 KB 0755
killall File 31.34 KB 0755
kmod File 170.24 KB 0755
kmodsign File 18.45 KB 0755
landscape-sysinfo File 646 B 0755
last File 34.38 KB 0755
lastb File 34.38 KB 0755
lastlog File 27.79 KB 0755
lcf File 7.6 KB 0755
ld.so File 231.07 KB 0755
ldd File 5.26 KB 0755
leaftoppm File 14.3 KB 0755
less File 190.38 KB 0755
lessecho File 14.31 KB 0755
lessfile File 8.83 KB 0755
lesskey File 23.7 KB 0755
lesspipe File 8.83 KB 0755
letsencrypt File 958 B 0755
lexgrog File 99.51 KB 0755
libnetcfg File 15.41 KB 0755
libsixel-config File 1.81 KB 0755
link File 34.51 KB 0755
linux-boot-prober File 1.54 KB 0755
linux-check-removal File 3.99 KB 0755
linux-update-symlinks File 6.17 KB 0755
linux-version File 2.63 KB 0755
linux32 File 26.65 KB 0755
linux64 File 26.65 KB 0755
lispmtopgm File 14.3 KB 0755
ln File 54.51 KB 0755
lnstat File 22.66 KB 0755
loadkeys File 202.9 KB 0755
loadunimap File 34.46 KB 0755
locale File 49.63 KB 0755
locale-check File 14.15 KB 0755
localectl File 26.45 KB 0755
localedef File 319.09 KB 0755
logger File 38.97 KB 0755
login File 51.81 KB 0755
loginctl File 66.58 KB 0755
logname File 34.51 KB 0755
logresolve File 14.31 KB 0755
look File 18.38 KB 0755
lowntfs-3g File 118.98 KB 0755
ls File 138.98 KB 0755
lsattr File 14.31 KB 0755
lsb_release File 2.59 KB 0755
lsblk File 146.38 KB 0755
lscpu File 110.38 KB 0755
lshw File 957.2 KB 0755
lsinitramfs File 735 B 0755
lsipc File 50.38 KB 0755
lslocks File 30.77 KB 0755
lslogins File 50.38 KB 0755
lsmem File 38.38 KB 0755
lsmod File 170.24 KB 0755
lsns File 42.38 KB 0755
lsof File 171.66 KB 0755
lspci File 100.11 KB 0755
lspgpot File 1.06 KB 0755
lspower File 1.18 KB 0755
lsusb File 246.52 KB 0755
lzcat File 86.92 KB 0755
lzcmp File 7.25 KB 0755
lzdiff File 7.25 KB 0755
lzegrep File 10.09 KB 0755
lzfgrep File 10.09 KB 0755
lzgrep File 10.09 KB 0755
lzless File 1.77 KB 0755
lzma File 86.92 KB 0755
lzmainfo File 14.38 KB 0755
lzmore File 2.14 KB 0755
macptopbm File 14.3 KB 0755
mailmail3 File 227 B 0755
man File 125.41 KB 0755
man-recode File 35.4 KB 0755
mandb File 143.67 KB 0755
manifest File 1.9 KB 0755
manpath File 26.78 KB 0755
mapscrn File 30.46 KB 0755
mariadb File 5.07 MB 0755
mariadb-access File 109.31 KB 0755
mariadb-admin File 4.85 MB 0755
mariadb-analyze File 4.84 MB 0755
mariadb-binlog File 5.13 MB 0755
mariadb-check File 4.84 MB 0755
mariadb-conv File 4.56 MB 0755
mariadb-convert-table-format File 4.12 KB 0755
mariadb-dump File 4.93 MB 0755
mariadb-dumpslow File 8.05 KB 0755
mariadb-find-rows File 3.21 KB 0755
mariadb-fix-extensions File 1.22 KB 0755
mariadb-hotcopy File 34.53 KB 0755
mariadb-import File 4.83 MB 0755
mariadb-install-db File 22.13 KB 0755
mariadb-optimize File 4.84 MB 0755
mariadb-plugin File 4.54 MB 0755
mariadb-repair File 4.84 MB 0755
mariadb-report File 49.02 KB 0755
mariadb-secure-installation File 13.49 KB 0755
mariadb-service-convert File 2.45 KB 0755
mariadb-setpermission File 17.56 KB 0755
mariadb-show File 4.83 MB 0755
mariadb-slap File 4.85 MB 0755
mariadb-tzinfo-to-sql File 4.53 MB 0755
mariadb-upgrade File 4.97 MB 0755
mariadb-waitpid File 4.53 MB 0755
mariadbcheck File 4.84 MB 0755
mariadbd-multi File 26.69 KB 0755
mariadbd-safe File 30.42 KB 0755
mariadbd-safe-helper File 4.49 MB 0755
markdown-it File 220 B 0755
mawk File 166.77 KB 0755
mbim-network File 11.08 KB 0755
mbimcli File 216.74 KB 0755
mcookie File 26.45 KB 0755
md5sum File 38.41 KB 0755
md5sum.textutils File 38.41 KB 0755
mdatopbm File 14.3 KB 0755
mdig File 50.4 KB 0755
memhog File 14.42 KB 0755
memusage File 7.32 KB 0755
memusagestat File 22.44 KB 0755
mesg File 14.38 KB 0755
mgrtopbm File 14.3 KB 0755
migrate-pubring-from-classic-gpg File 3.02 KB 0755
migratepages File 14.38 KB 0755
migspeed File 14.3 KB 0755
mk_modmap File 15.78 KB 0755
mkdir File 74.51 KB 0755
mkfifo File 42.51 KB 0755
mkfontdir File 65 B 0755
mkfontscale File 42.67 KB 0755
mknod File 42.51 KB 0755
mkpasswd File 26.38 KB 0755
mksquashfs File 286.95 KB 0755
mktemp File 34.51 KB 0755
mmcli File 273.94 KB 0755
mogrify File 14.31 KB 0755
mogrify-im6 File 14.31 KB 0755
mogrify-im6.q16 File 14.31 KB 0755
montage File 14.31 KB 0755
montage-im6 File 14.31 KB 0755
montage-im6.q16 File 14.31 KB 0755
more File 46.38 KB 0755
mount File 50.38 KB 4755
mountpoint File 18.38 KB 0755
mpstat File 50.45 KB 0755
mrftopbm File 14.3 KB 0755
msql2mysql File 1.41 KB 0755
mt File 70.73 KB 0755
mt-gnu File 70.73 KB 0755
mtr File 76.25 KB 0755
mtr-packet File 34.3 KB 0755
mtrace File 6.37 KB 0755
mtvtoppm File 14.3 KB 0755
mv File 134.52 KB 0755
my_print_defaults File 4.53 MB 0755
myisam_ftdump File 4.87 MB 0755
myisamchk File 4.99 MB 0755
myisamlog File 4.85 MB 0755
myisampack File 4.9 MB 0755
mysql File 5.07 MB 0755
mysql_convert_table_format File 4.12 KB 0755
mysql_find_rows File 3.21 KB 0755
mysql_fix_extensions File 1.22 KB 0755
mysql_install_db File 22.13 KB 0755
mysql_plugin File 4.54 MB 0755
mysql_secure_installation File 13.49 KB 0755
mysql_setpermission File 17.56 KB 0755
mysql_tzinfo_to_sql File 4.53 MB 0755
mysql_upgrade File 4.97 MB 0755
mysql_waitpid File 4.53 MB 0755
mysqlaccess File 109.31 KB 0755
mysqladmin File 4.85 MB 0755
mysqlanalyze File 4.84 MB 0755
mysqlbinlog File 5.13 MB 0755
mysqlcheck File 4.84 MB 0755
mysqld_multi File 26.69 KB 0755
mysqld_safe File 30.42 KB 0755
mysqld_safe_helper File 4.49 MB 0755
mysqldump File 4.93 MB 0755
mysqldumpslow File 8.05 KB 0755
mysqlhotcopy File 34.53 KB 0755
mysqlimport File 4.83 MB 0755
mysqloptimize File 4.84 MB 0755
mysqlrepair File 4.84 MB 0755
mysqlreport File 49.02 KB 0755
mysqlshow File 4.83 MB 0755
mysqlslap File 4.85 MB 0755
mytop File 71.95 KB 0755
named-checkconf File 38.4 KB 0755
named-checkzone File 30.4 KB 0755
named-compilezone File 30.4 KB 0755
named-journalprint File 14.3 KB 0755
named-nzd2nzf File 14.3 KB 0755
named-rrchecker File 22.3 KB 0755
namei File 22.38 KB 0755
nano File 272.5 KB 0755
nawk File 722.5 KB 0755
nc File 38.63 KB 0755
nc.openbsd File 38.63 KB 0755
neofetch File 333.58 KB 0755
neotoppm File 14.3 KB 0755
neqn File 913 B 0755
netaddr File 959 B 0755
netcat File 38.63 KB 0755
networkctl File 122.58 KB 0755
networkd-dispatcher File 19.88 KB 0755
newgrp File 39.71 KB 4755
ngettext File 34.38 KB 0755
nice File 34.51 KB 0755
nisdomainname File 22.23 KB 0755
nl File 38.6 KB 0755
nohup File 34.41 KB 0755
nproc File 34.51 KB 0755
nroff File 5.58 KB 0755
nsec3hash File 14.3 KB 0755
nsenter File 30.6 KB 0755
nslookup File 122.82 KB 0755
nstat File 30.38 KB 0755
nsupdate File 74.55 KB 0755
ntfs-3g File 159.01 KB 0755
ntfs-3g.probe File 14.38 KB 0755
ntfscat File 26.38 KB 0755
ntfscluster File 38.38 KB 0755
ntfscmp File 30.38 KB 0755
ntfsdecrypt File 42.38 KB 0755
ntfsfallocate File 26.38 KB 0755
ntfsfix File 34.38 KB 0755
ntfsinfo File 54.38 KB 0755
ntfsls File 27.45 KB 0755
ntfsmove File 30.38 KB 0755
ntfsrecover File 102.38 KB 0755
ntfssecaudit File 78.86 KB 0755
ntfstruncate File 26.3 KB 0755
ntfsusermap File 18.3 KB 0755
ntfswipe File 46.91 KB 0755
numactl File 35.23 KB 0755
numastat File 35.56 KB 0755
numfmt File 58.54 KB 0755
nvidia-detector File 270 B 0755
od File 70.51 KB 0755
oem-getlogs File 8.3 KB 0755
on_ac_power File 3.7 KB 0755
openssl File 981.8 KB 0755
openvt File 22.73 KB 0755
os-prober File 4.42 KB 0755
pager File 190.38 KB 0755
palmtopnm File 26.3 KB 0755
pamaddnoise File 18.3 KB 0755
pamaltsat File 14.34 KB 0755
pamarith File 22.3 KB 0755
pambackground File 18.3 KB 0755
pambayer File 14.38 KB 0755
pambrighten File 14.3 KB 0755
pamcat File 22.3 KB 0755
pamchannel File 14.3 KB 0755
pamcomp File 18.3 KB 0755
pamcrater File 18.3 KB 0755
pamcut File 18.3 KB 0755
pamdeinterlace File 14.3 KB 0755
pamdepth File 14.3 KB 0755
pamdice File 18.3 KB 0755
pamditherbw File 26.3 KB 0755
pamedge File 14.3 KB 0755
pamendian File 14.3 KB 0755
pamenlarge File 18.38 KB 0755
pamexec File 14.3 KB 0755
pamfile File 14.3 KB 0755
pamfind File 14.3 KB 0755
pamfix File 14.3 KB 0755
pamfixtrunc File 2.01 KB 0755
pamflip File 22.3 KB 0755
pamfunc File 18.3 KB 0755
pamgauss File 14.3 KB 0755
pamgetcolor File 18.38 KB 0755
pamgradient File 14.3 KB 0755
pamhomography File 18.3 KB 0755
pamhue File 14.3 KB 0755
pamlevels File 18.3 KB 0755
pamlookup File 14.3 KB 0755
pammasksharpen File 14.3 KB 0755
pammixinterlace File 14.38 KB 0755
pammixmulti File 18.3 KB 0755
pammosaicknit File 14.3 KB 0755
pamoil File 14.3 KB 0755
pampaintspill File 18.3 KB 0755
pamperspective File 30.38 KB 0755
pampick File 14.3 KB 0755
pampop9 File 14.3 KB 0755
pamrecolor File 18.3 KB 0755
pamrestack File 14.3 KB 0755
pamrgbatopng File 34.3 KB 0755
pamrubber File 34.3 KB 0755
pamscale File 34.38 KB 0755
pamseq File 14.3 KB 0755
pamshadedrelief File 14.3 KB 0755
pamsharpmap File 14.3 KB 0755
pamsharpness File 14.3 KB 0755
pamshuffle File 14.3 KB 0755
pamsistoaglyph File 14.3 KB 0755
pamslice File 14.3 KB 0755
pamsplit File 14.3 KB 0755
pamstack File 14.3 KB 0755
pamstereogram File 30.3 KB 0755
pamstretch File 14.3 KB 0755
pamstretch-gen File 3.83 KB 0755
pamsumm File 14.3 KB 0755
pamsummcol File 14.3 KB 0755
pamtable File 14.3 KB 0755
pamthreshold File 18.3 KB 0755
pamtilt File 18.3 KB 0755
pamtoavs File 14.3 KB 0755
pamtodjvurle File 14.3 KB 0755
pamtofits File 14.3 KB 0755
pamtogif File 26.3 KB 0755
pamtohdiff File 14.3 KB 0755
pamtohtmltbl File 14.3 KB 0755
pamtojpeg2k File 212.82 KB 0755
pamtompfont File 14.3 KB 0755
pamtooctaveimg File 14.3 KB 0755
pamtopam File 14.3 KB 0755
pamtopdbimg File 18.38 KB 0755
pamtopfm File 14.3 KB 0755
pamtopng File 34.3 KB 0755
pamtopnm File 14.3 KB 0755
pamtoqoi File 18.3 KB 0755
pamtosrf File 18.3 KB 0755
pamtosvg File 70.15 KB 0755
pamtotga File 18.3 KB 0755
pamtotiff File 46.38 KB 0755
pamtouil File 14.3 KB 0755
pamtowinicon File 18.3 KB 0755
pamtoxvmini File 14.3 KB 0755
pamtris File 26.3 KB 0755
pamundice File 18.3 KB 0755
pamunlookup File 14.3 KB 0755
pamvalidate File 14.3 KB 0755
pamwipeout File 14.3 KB 0755
pamx File 42.38 KB 0755
paperconf File 14.15 KB 0755
partx File 62.38 KB 0755
passwd File 62.65 KB 4755
paste File 38.41 KB 0755
pastebinit File 16.31 KB 0755
patch File 182.52 KB 0755
pathchk File 34.51 KB 0755
pbget File 2.51 KB 0755
pbmclean File 18.3 KB 0755
pbmlife File 14.3 KB 0755
pbmmake File 14.3 KB 0755
pbmmask File 14.3 KB 0755
pbmminkowski File 14.3 KB 0755
pbmnoise File 14.3 KB 0755
pbmpage File 14.3 KB 0755
pbmpscale File 14.3 KB 0755
pbmreduce File 14.3 KB 0755
pbmtext File 30.48 KB 0755
pbmtextps File 22.3 KB 0755
pbmto10x File 14.3 KB 0755
pbmto4425 File 14.3 KB 0755
pbmtoascii File 14.3 KB 0755
pbmtoatk File 14.3 KB 0755
pbmtobbnbg File 14.3 KB 0755
pbmtocis File 14.3 KB 0755
pbmtocmuwm File 14.3 KB 0755
pbmtodjvurle File 14.3 KB 0755
pbmtoepsi File 14.3 KB 0755
pbmtoepson File 14.3 KB 0755
pbmtoescp2 File 14.3 KB 0755
pbmtog3 File 19.13 KB 0755
pbmtogem File 14.3 KB 0755
pbmtogo File 14.3 KB 0755
pbmtoibm23xx File 14.3 KB 0755
pbmtoicon File 14.3 KB 0755
pbmtolj File 18.3 KB 0755
pbmtoln03 File 14.3 KB 0755
pbmtolps File 14.3 KB 0755
pbmtomacp File 14.3 KB 0755
pbmtomatrixorbital File 14.3 KB 0755
pbmtomda File 14.3 KB 0755
pbmtomgr File 14.3 KB 0755
pbmtomrf File 14.3 KB 0755
pbmtonokia File 14.3 KB 0755
pbmtopgm File 14.3 KB 0755
pbmtopi3 File 14.3 KB 0755
pbmtopk File 26.6 KB 0755
pbmtoplot File 14.3 KB 0755
pbmtoppa File 30.38 KB 0755
pbmtopsg3 File 15.94 KB 0755
pbmtoptx File 14.3 KB 0755
pbmtosunicon File 14.3 KB 0755
pbmtowbmp File 14.3 KB 0755
pbmtox10bm File 2.83 KB 0755
pbmtoxbm File 14.3 KB 0755
pbmtoybm File 14.3 KB 0755
pbmtozinc File 14.3 KB 0755
pbmupc File 22.3 KB 0755
pbput File 2.51 KB 0755
pbputs File 2.51 KB 0755
pc1toppm File 14.3 KB 0755
pcdindex File 6.56 KB 0755
pcdovtoppm File 6.56 KB 0755
pcxtoppm File 18.3 KB 0755
pdb3 File 67.83 KB 0755
pdb3.12 File 67.83 KB 0755
pdbimgtopam File 18.38 KB 0755
pdf2dsc File 698 B 0755
pdf2ps File 909 B 0755
pear File 793 B 0755
peardev File 814 B 0755
pecl File 727 B 0755
peekfd File 14.3 KB 0755
perf File 1.58 KB 0755
perl File 3.83 MB 0755
perl5.38-x86_64-linux-gnu File 14.3 KB 0755
perl5.38.2 File 3.83 MB 0755
perlbug File 44.52 KB 0755
perldoc File 125 B 0755
perlivp File 10.61 KB 0755
perlthanks File 44.52 KB 0755
perror File 4.72 MB 0755
pf2afm File 498 B 0755
pfbtopfa File 516 B 0755
pfmtopam File 14.3 KB 0755
pgmabel File 18.3 KB 0755
pgmbentley File 14.3 KB 0755
pgmcrater File 3.49 KB 0755
pgmdeshadow File 14.3 KB 0755
pgmedge File 14.3 KB 0755
pgmenhance File 14.3 KB 0755
pgmhist File 18.3 KB 0755
pgmkernel File 14.3 KB 0755
pgmmake File 14.3 KB 0755
pgmmedian File 18.3 KB 0755
pgmminkowski File 14.3 KB 0755
pgmmorphconv File 14.3 KB 0755
pgmnoise File 14.3 KB 0755
pgmnorm File 18.3 KB 0755
pgmoil File 14.3 KB 0755
pgmramp File 14.3 KB 0755
pgmslice File 14.3 KB 0755
pgmtexture File 26.3 KB 0755
pgmtofs File 14.3 KB 0755
pgmtolispm File 14.3 KB 0755
pgmtopbm File 22.3 KB 0755
pgmtopgm File 14.3 KB 0755
pgmtoppm File 14.3 KB 0755
pgmtosbig File 14.3 KB 0755
pgmtost4 File 14.3 KB 0755
pgrep File 34.47 KB 0755
phar File 14.84 KB 0755
phar.phar File 14.84 KB 0755
phar.phar8.3 File 14.84 KB 0755
phar8.3 File 14.84 KB 0755
phar8.3.phar File 14.84 KB 0755
php File 5.52 MB 0755
php8.3 File 5.52 MB 0755
pi1toppm File 14.3 KB 0755
pi3topbm File 14.3 KB 0755
pic File 196.06 KB 0755
pico File 272.5 KB 0755
piconv File 8.16 KB 0755
pidof File 26.23 KB 0755
pidstat File 50.45 KB 0755
pidwait File 34.47 KB 0755
pinentry File 58.65 KB 0755
pinentry-curses File 58.65 KB 0755
ping File 87.7 KB 0755
ping4 File 87.7 KB 0755
ping6 File 87.7 KB 0755
pinky File 38.41 KB 0755
pjtoppm File 18.3 KB 0755
pkaction File 18.3 KB 0755
pkcheck File 22.3 KB 0755
pkcon File 54.3 KB 0755
pkill File 34.47 KB 0755
pkmon File 22.3 KB 0755
pktopbm File 18.3 KB 0755
pkttyagent File 22.3 KB 0755
pl2pm File 4.43 KB 0755
pldd File 22.44 KB 0755
plymouth File 46.3 KB 0755
pmap File 34.4 KB 0755
pngtopam File 34.38 KB 0755
pngtopnm File 34.38 KB 0755
pnmalias File 18.3 KB 0755
pnmarith File 22.3 KB 0755
pnmcat File 22.3 KB 0755
pnmcolormap File 18.3 KB 0755
pnmcomp File 18.3 KB 0755
pnmconvol File 34.3 KB 0755
pnmcrop File 26.38 KB 0755
pnmcut File 18.3 KB 0755
pnmdepth File 14.3 KB 0755
pnmenlarge File 18.38 KB 0755
pnmfile File 14.3 KB 0755
pnmflip File 3.63 KB 0755
pnmgamma File 18.3 KB 0755
pnmhisteq File 14.3 KB 0755
pnmhistmap File 18.3 KB 0755
pnmindex File 18.3 KB 0755
pnminterp File 14.3 KB 0755
pnminterp-gen File 3.83 KB 0755
pnminvert File 14.3 KB 0755
pnmmargin File 2.42 KB 0755
pnmmercator File 14.3 KB 0755
pnmmontage File 18.3 KB 0755
pnmnlfilt File 22.36 KB 0755
pnmnoraw File 31 B 0755
pnmnorm File 18.3 KB 0755
pnmpad File 22.3 KB 0755
pnmpaste File 18.3 KB 0755
pnmpsnr File 18.3 KB 0755
pnmquant File 10.63 KB 0755
pnmquantall File 6.84 KB 0755
pnmremap File 18.3 KB 0755
pnmrotate File 18.3 KB 0755
pnmscale File 34.38 KB 0755
pnmscalefixed File 18.3 KB 0755
pnmshear File 14.3 KB 0755
pnmsmooth File 14.3 KB 0755
pnmsplit File 14.3 KB 0755
pnmstitch File 34.97 KB 0755
pnmtile File 14.3 KB 0755
pnmtoddif File 18.3 KB 0755
pnmtofiasco File 164.21 KB 0755
pnmtofits File 14.3 KB 0755
pnmtojbig File 61.14 KB 0755
pnmtojpeg File 26.3 KB 0755
pnmtopalm File 26.3 KB 0755
pnmtopclxl File 22.81 KB 0755
pnmtoplainpnm File 31 B 0755
pnmtopng File 54.3 KB 0755
pnmtopnm File 14.3 KB 0755
pnmtops File 34.3 KB 0755
pnmtorast File 18.3 KB 0755
pnmtorle File 34.55 KB 0755
pnmtosgi File 14.3 KB 0755
pnmtosir File 14.3 KB 0755
pnmtotiff File 46.38 KB 0755
pnmtotiffcmyk File 38.38 KB 0755
pnmtoxwd File 18.3 KB 0755
pod2html File 3.95 KB 0755
pod2man File 18.46 KB 0755
pod2text File 12.8 KB 0755
pod2usage File 4.01 KB 0755
podchecker File 3.57 KB 0755
pollinate File 8.54 KB 0755
pphs File 404 B 0755
ppm3d File 18.3 KB 0755
ppmbrighten File 2 KB 0755
ppmchange File 14.3 KB 0755
ppmcie File 26.47 KB 0755
ppmcolormask File 14.3 KB 0755
ppmcolors File 14.3 KB 0755
ppmdcfont File 14.3 KB 0755
ppmddumpfont File 14.3 KB 0755
ppmdim File 14.3 KB 0755
ppmdist File 14.3 KB 0755
ppmdither File 14.3 KB 0755
ppmdmkfont File 22.02 KB 0755
ppmdraw File 22.3 KB 0755
ppmfade File 14.76 KB 0755
ppmflash File 14.3 KB 0755
ppmforge File 22.3 KB 0755
ppmglobe File 14.3 KB 0755
ppmhist File 18.3 KB 0755
ppmlabel File 14.3 KB 0755
ppmmake File 14.3 KB 0755
ppmmix File 14.3 KB 0755
ppmnorm File 18.3 KB 0755
ppmntsc File 14.3 KB 0755
ppmpat File 30.3 KB 0755
ppmquant File 2.3 KB 0755
ppmquantall File 6.84 KB 0755
ppmrainbow File 3.48 KB 0755
ppmrelief File 14.3 KB 0755
ppmrough File 18.3 KB 0755
ppmshadow File 10.85 KB 0755
ppmshift File 14.3 KB 0755
ppmspread File 14.3 KB 0755
ppmtoacad File 19.15 KB 0755
ppmtoapplevol File 14.3 KB 0755
ppmtoarbtxt File 18.3 KB 0755
ppmtoascii File 14.38 KB 0755
ppmtobmp File 18.3 KB 0755
ppmtoeyuv File 18.3 KB 0755
ppmtogif File 14.3 KB 0755
ppmtoicr File 14.3 KB 0755
ppmtoilbm File 42.39 KB 0755
ppmtojpeg File 26.3 KB 0755
ppmtoleaf File 14.3 KB 0755
ppmtolj File 14.3 KB 0755
ppmtomap File 82 B 0755
ppmtomitsu File 22.3 KB 0755
ppmtompeg File 494.09 KB 0755
ppmtoneo File 14.3 KB 0755
ppmtopcx File 18.3 KB 0755
ppmtopgm File 18.3 KB 0755
ppmtopi1 File 14.3 KB 0755
ppmtopict File 14.3 KB 0755
ppmtopj File 14.38 KB 0755
ppmtopjxl File 18.38 KB 0755
ppmtoppm File 14.3 KB 0755
ppmtopuzz File 14.3 KB 0755
ppmtorgb3 File 14.3 KB 0755
ppmtosixel File 14.3 KB 0755
ppmtospu File 14.3 KB 0755
ppmtoterm File 14.3 KB 0755
ppmtotga File 18.3 KB 0755
ppmtouil File 14.3 KB 0755
ppmtowinicon File 18.3 KB 0755
ppmtoxpm File 18.3 KB 0755
ppmtoyuv File 14.3 KB 0755
ppmtoyuvsplit File 14.3 KB 0755
ppmtv File 14.3 KB 0755
ppmwheel File 14.3 KB 0755
pr File 70.58 KB 0755
preconv File 58.48 KB 0755
printafm File 395 B 0755
printenv File 34.38 KB 0755
printf File 54.44 KB 0755
prlimit File 26.89 KB 0755
pro File 1003 B 0755
procan File 42.41 KB 0755
prove File 13.34 KB 0755
prtstat File 18.38 KB 0755
ps File 142.99 KB 0755
ps2ascii File 631 B 0755
ps2epsi File 1.23 KB 0755
ps2pdf File 272 B 0755
ps2pdf12 File 215 B 0755
ps2pdf13 File 215 B 0755
ps2pdf14 File 215 B 0755
ps2pdfwr File 1.05 KB 0755
ps2ps File 647 B 0755
ps2ps2 File 669 B 0755
ps2txt File 631 B 0755
psfaddtable File 22.37 KB 0755
psfgettable File 22.37 KB 0755
psfstriptable File 22.37 KB 0755
psfxtable File 22.37 KB 0755
psidtopgm File 14.3 KB 0755
pslog File 14.3 KB 0755
pstopnm File 22.38 KB 0755
pstree File 35.32 KB 0755
pstree.x11 File 35.32 KB 0755
ptar File 3.48 KB 0755
ptardiff File 2.58 KB 0755
ptargrep File 4.29 KB 0755
ptx File 54.54 KB 0755
purge-old-kernels File 1.12 KB 0755
pv File 79.41 KB 0755
pwd File 34.51 KB 0755
pwdx File 14.38 KB 0755
py3clean File 7.63 KB 0755
py3compile File 13 KB 0755
py3versions File 12.52 KB 0755
pydoc3 File 80 B 0755
pydoc3.12 File 80 B 0755
pygettext3 File 23.66 KB 0755
pygettext3.12 File 23.66 KB 0755
pygmentize File 215 B 0755
pyhtmlizer3 File 222 B 0755
pyserial-miniterm File 975 B 0755
pyserial-ports File 969 B 0755
python3 File 7.65 MB 0755
python3.12 File 7.65 MB 0755
pzstd File 690.54 KB 0755
qmi-firmware-update File 168.09 KB 0755
qmi-network File 16.04 KB 0755
qmicli File 586.84 KB 0755
qoitopam File 14.3 KB 0755
qrttoppm File 14.3 KB 0755
quirks-handler File 2.4 KB 0755
rasttopnm File 18.3 KB 0755
rawtopgm File 14.3 KB 0755
rawtoppm File 14.3 KB 0755
rbash File 1.38 MB 0755
rdma File 102.52 KB 0755
readlink File 42.41 KB 0755
realpath File 42.41 KB 0755
red File 89 B 0755
rename.ul File 22.38 KB 0755
renice File 14.38 KB 0755
replace File 4.51 MB 0755
rescan-scsi-bus.sh File 38.05 KB 0755
reset File 26.31 KB 0755
resizecons File 26.46 KB 0755
resizepart File 22.38 KB 0755
resolve_stack_dump File 4.53 MB 0755
resolvectl File 158.67 KB 0755
resolveip File 4.53 MB 0755
rev File 14.38 KB 0755
rgb3toppm File 14.3 KB 0755
rgrep File 30 B 0755
rlatopam File 14.3 KB 0755
rletopnm File 38.55 KB 0755
rm File 58.51 KB 0755
rmdir File 46.41 KB 0755
rnano File 272.5 KB 0755
rotatelogs File 26.38 KB 0755
routel File 1.62 KB 0755
rpcgen File 94.59 KB 0755
rrsync File 12.34 KB 0755
rsync File 502.13 KB 0755
rsync-ssl File 5.02 KB 0755
rtla File 1.58 KB 0755
rtstat File 22.66 KB 0755
run-one File 3.51 KB 0755
run-one-constantly File 3.51 KB 0755
run-one-until-failure File 3.51 KB 0755
run-one-until-success File 3.51 KB 0755
run-parts File 26.82 KB 0755
run-this-one File 3.51 KB 0755
runcon File 34.51 KB 0755
rview File 3.94 MB 0755
rvim File 3.94 MB 0755
sadf File 382.31 KB 0755
sar File 137.38 KB 0755
sar.sysstat File 137.38 KB 0755
savelog File 10.24 KB 0755
sbattach File 22.54 KB 0755
sbigtopgm File 14.3 KB 0755
sbkeysync File 34.74 KB 0755
sbsiglist File 14.6 KB 0755
sbsign File 34.7 KB 0755
sbvarsign File 22.73 KB 0755
sbverify File 30.61 KB 0755
scalar File 668.94 KB 0755
scandeps File 6.47 KB 0755
scp File 134.59 KB 0755
screen File 478.24 KB 0755
screendump File 14.3 KB 0755
script File 54.38 KB 0755
scriptlive File 42.38 KB 0755
scriptreplay File 34.38 KB 0755
scsi_logging_level File 8.38 KB 0755
scsi_mandat File 3.52 KB 0755
scsi_readcap File 1.3 KB 0755
scsi_ready File 1.09 KB 0755
scsi_satl File 3.74 KB 0755
scsi_start File 1.25 KB 0755
scsi_stop File 1.44 KB 0755
scsi_temperature File 936 B 0755
sdiff File 50.39 KB 0755
sed File 110.57 KB 0755
select-editor File 2.39 KB 0755
sensible-browser File 1.55 KB 0755
sensible-editor File 1.52 KB 0755
sensible-pager File 921 B 0755
sensible-terminal File 1.15 KB 0755
seq File 50.51 KB 0755
setarch File 26.65 KB 0755
setfont File 54.46 KB 0755
setkeycodes File 14.37 KB 0755
setleds File 18.43 KB 0755
setlogcons File 14.37 KB 0755
setmetamode File 14.41 KB 0755
setpci File 30.38 KB 0755
setpriv File 38.38 KB 0755
setsid File 14.38 KB 0755
setterm File 34.38 KB 0755
setupcon File 40.06 KB 0755
sftp File 150.66 KB 0755
sg File 39.71 KB 4755
sg_bg_ctl File 14.51 KB 0755
sg_compare_and_write File 26.91 KB 0755
sg_copy_results File 23.3 KB 0755
sg_dd File 54.33 KB 0755
sg_decode_sense File 14.76 KB 0755
sg_emc_trespass File 14.3 KB 0755
sg_format File 39.35 KB 0755
sg_get_config File 35.38 KB 0755
sg_get_elem_status File 26.79 KB 0755
sg_get_lba_status File 22.95 KB 0755
sg_ident File 14.6 KB 0755
sg_inq File 115.61 KB 0755
sg_logs File 146.93 KB 0755
sg_luns File 22.79 KB 0755
sg_map File 18.3 KB 0755
sg_map26 File 26.7 KB 0755
sg_modes File 46.08 KB 0755
sg_opcodes File 35.01 KB 0755
sg_persist File 36.08 KB 0755
sg_prevent File 14.51 KB 0755
sg_raw File 26.91 KB 0755
sg_rbuf File 22.73 KB 0755
sg_rdac File 18.3 KB 0755
sg_read File 26.31 KB 0755
sg_read_attr File 36.65 KB 0755
sg_read_block_limits File 14.54 KB 0755
sg_read_buffer File 27.56 KB 0755
sg_read_long File 14.7 KB 0755
sg_readcap File 22.79 KB 0755
sg_reassign File 18.66 KB 0755
sg_referrals File 14.66 KB 0755
sg_rep_pip File 14.57 KB 0755
sg_rep_zones File 26.8 KB 0755
sg_requests File 22.76 KB 0755
sg_reset File 14.66 KB 0755
sg_reset_wp File 14.6 KB 0755
sg_rmsn File 14.51 KB 0755
sg_rtpg File 14.6 KB 0755
sg_safte File 22.7 KB 0755
sg_sanitize File 27.01 KB 0755
sg_sat_identify File 18.73 KB 0755
sg_sat_phy_event File 19.01 KB 0755
sg_sat_read_gplog File 18.73 KB 0755
sg_sat_set_features File 18.7 KB 0755
sg_scan File 18.38 KB 0755
sg_seek File 18.88 KB 0755
sg_senddiag File 27.2 KB 0755
sg_ses File 119.97 KB 0755
sg_ses_microcode File 27.36 KB 0755
sg_start File 18.85 KB 0755
sg_stpg File 22.73 KB 0755
sg_stream_ctl File 18.7 KB 0755
sg_sync File 14.66 KB 0755
sg_test_rwbuf File 18.6 KB 0755
sg_timestamp File 22.83 KB 0755
sg_turs File 26.7 KB 0755
sg_unmap File 22.76 KB 0755
sg_verify File 22.91 KB 0755
sg_vpd File 118.42 KB 0755
sg_wr_mode File 22.73 KB 0755
sg_write_buffer File 27.23 KB 0755
sg_write_long File 14.76 KB 0755
sg_write_same File 26.95 KB 0755
sg_write_verify File 26.79 KB 0755
sg_write_x File 55.6 KB 0755
sg_xcopy File 42.32 KB 0755
sg_zone File 14.86 KB 0755
sginfo File 76.01 KB 0755
sgitopnm File 18.3 KB 0755
sgm_dd File 34.31 KB 0755
sgp_dd File 46.31 KB 0755
sh File 126.74 KB 0755
sha1sum File 38.41 KB 0755
sha224sum File 38.41 KB 0755
sha256sum File 38.41 KB 0755
sha384sum File 38.41 KB 0755
sha512sum File 38.41 KB 0755
shasum File 9.75 KB 0755
showconsolefont File 18.37 KB 0755
showkey File 18.37 KB 0755
shred File 54.51 KB 0755
shuf File 46.51 KB 0755
sirtopnm File 14.3 KB 0755
sixel2png File 14.3 KB 0755
skill File 26.41 KB 0755
slabtop File 22.44 KB 0755
sldtoppm File 18.35 KB 0755
sleep File 34.51 KB 0755
slogin File 827.04 KB 0755
snap File 20.84 MB 0755
snapctl File 7.37 MB 0755
snapfuse File 38.23 KB 0755
snice File 26.41 KB 0755
socat File 447.68 KB 0755
socat-broker.sh File 2.24 KB 0755
socat-chain.sh File 7.86 KB 0755
socat-mux.sh File 3.47 KB 0755
socat1 File 447.68 KB 0755
soelim File 34.48 KB 0755
sort File 102.8 KB 0755
sos File 612 B 0755
sos-collector File 1.04 KB 0755
sosreport File 1.03 KB 0755
sotruss File 4.21 KB 0755
spctoppm File 14.3 KB 0755
splain File 18.99 KB 0755
split File 54.94 KB 0755
splitfont File 14.3 KB 0755
spottopgm File 14.31 KB 0755
sprof File 34.44 KB 0755
sputoppm File 14.3 KB 0755
sqfscat File 147.9 KB 0755
sqfstar File 286.95 KB 0755
srftopam File 18.3 KB 0755
ss File 129.07 KB 0755
ssh File 827.04 KB 0755
ssh-add File 294.42 KB 0755
ssh-agent File 302.43 KB 2755
ssh-argv0 File 1.42 KB 0755
ssh-copy-id File 12.77 KB 0755
ssh-import-id File 985 B 0755
ssh-import-id-gh File 785 B 0755
ssh-import-id-lp File 785 B 0755
ssh-keygen File 442.44 KB 0755
ssh-keyscan File 330.44 KB 0755
st4topgm File 14.3 KB 0755
stat File 86.52 KB 0755
static-sh File 2.03 MB 0755
stdbuf File 50.51 KB 0755
strace File 1.99 MB 0755
strace-log-merge File 1.78 KB 0755
stream File 14.31 KB 0755
stream-im6 File 14.31 KB 0755
stream-im6.q16 File 14.31 KB 0755
streamzip File 7.87 KB 0755
stty File 78.52 KB 0755
su File 54.38 KB 4755
sudo File 271.42 KB 4755
sudoedit File 271.42 KB 4755
sudoreplay File 95.95 KB 0755
sum File 34.41 KB 0755
sunicontopnm File 14.3 KB 0755
svgtopam File 22.3 KB 0755
sync File 34.41 KB 0755
systemctl File 1.43 MB 0755
systemd File 98.45 KB 0755
systemd-ac-power File 14.45 KB 0755
systemd-analyze File 198.85 KB 0755
systemd-ask-password File 18.58 KB 0755
systemd-cat File 18.45 KB 0755
systemd-cgls File 22.57 KB 0755
systemd-cgtop File 38.47 KB 0755
systemd-confext File 54.64 KB 0755
systemd-creds File 42.72 KB 0755
systemd-cryptenroll File 70.92 KB 0755
systemd-cryptsetup File 78.95 KB 0755
systemd-delta File 26.45 KB 0755
systemd-detect-virt File 18.45 KB 0755
systemd-escape File 22.45 KB 0755
systemd-firstboot File 58.82 KB 0755
systemd-hwdb File 154.74 KB 0755
systemd-id128 File 22.45 KB 0755
systemd-inhibit File 22.47 KB 0755
systemd-machine-id-setup File 18.63 KB 0755
systemd-mount File 50.78 KB 0755
systemd-notify File 26.66 KB 0755
systemd-path File 18.45 KB 0755
systemd-repart File 195.23 KB 0755
systemd-run File 66.79 KB 0755
systemd-socket-activate File 30.45 KB 0755
systemd-stdio-bridge File 22.45 KB 0755
systemd-sysext File 54.64 KB 0755
systemd-sysusers File 66.63 KB 0755
systemd-tmpfiles File 114.7 KB 0755
systemd-tty-ask-password-agent File 34.45 KB 0755
systemd-umount File 50.78 KB 0755
tabs File 18.3 KB 0755
tac File 38.41 KB 0755
tail File 62.53 KB 0755
tapestat File 26.44 KB 0755
tar File 421.92 KB 0755
taskset File 30.38 KB 0755
tbl File 134.48 KB 0755
tclsh File 14.15 KB 0755
tclsh8.6 File 14.15 KB 0755
tcpdump File 1.21 MB 0755
tee File 38.51 KB 0755
telnet File 177.85 KB 0755
tempfile File 14.3 KB 0755
test File 46.44 KB 0755
tgatoppm File 18.3 KB 0755
thinkjettopbm File 18.3 KB 0755
tic File 90.41 KB 0755
tifftopnm File 42.38 KB 0755
time File 26.52 KB 0755
timedatectl File 46.45 KB 0755
timeout File 38.95 KB 0755
tkconch3 File 227 B 0755
tload File 22.39 KB 0755
tmux File 1.05 MB 0755
tnftp File 182.9 KB 0755
toe File 22.3 KB 0755
toilet File 26.68 KB 0755
top File 131.7 KB 0755
touch File 94.51 KB 0755
tput File 26.34 KB 0755
tr File 46.51 KB 0755
trace-cmd File 435.41 KB 0755
tracepath File 18.15 KB 0755
trial3 File 219 B 0755
troff File 726.62 KB 0755
true File 26.3 KB 0755
truncate File 38.51 KB 0755
tset File 26.31 KB 0755
tsort File 46.51 KB 0755
tty File 34.51 KB 0755
turbostat File 1.58 KB 0755
twist3 File 239 B 0755
twistd3 File 220 B 0755
tzselect File 15.02 KB 0755
ua File 1003 B 0755
ubuntu-advantage File 1003 B 0755
ubuntu-bug File 2.27 KB 0755
ubuntu-distro-info File 26.89 KB 0755
ubuntu-drivers File 18.97 KB 0755
ubuntu-security-status File 22.25 KB 0755
ucf File 40.68 KB 0755
ucfq File 18.91 KB 0755
ucfr File 10.85 KB 0755
uclampset File 30.38 KB 0755
ucs2any File 26.15 KB 0755
udevadm File 1.37 MB 0755
udisksctl File 62.38 KB 0755
ul File 22.38 KB 0755
umount File 38.38 KB 4755
uname File 34.51 KB 0755
unattended-upgrade File 97.21 KB 0755
unattended-upgrades File 97.21 KB 0755
uncompress File 2.29 KB 0755
unexpand File 38.53 KB 0755
unicode_start File 2.71 KB 0755
unicode_stop File 528 B 0755
uniq File 38.51 KB 0755
unlink File 34.51 KB 0755
unlzma File 86.92 KB 0755
unminimize File 5.59 KB 0755
unmkinitramfs File 3.7 KB 0755
unshare File 42.6 KB 0755
unsquashfs File 147.9 KB 0755
unxz File 86.92 KB 0755
unzip File 174.42 KB 0755
unzipsfx File 74.42 KB 0755
unzstd File 998.79 KB 0755
update-alternatives File 58.38 KB 0755
update-mime-database File 74.33 KB 0755
upower File 14.3 KB 0755
uptime File 14.38 KB 0755
usb-devices File 4.83 KB 0755
usbhid-dump File 30.38 KB 0755
usbip File 1.58 KB 0755
usbipd File 1.58 KB 0755
usbreset File 14.3 KB 0755
users File 34.51 KB 0755
utmpdump File 22.38 KB 0755
uuidgen File 18.38 KB 0755
uuidparse File 22.38 KB 0755
varlinkctl File 30.45 KB 0755
vcs-run File 6.75 KB 0755
vdir File 138.98 KB 0755
vi File 3.94 MB 0755
view File 3.94 MB 0755
vigpg File 2.58 KB 0755
vim File 3.94 MB 0755
vim.basic File 3.94 MB 0755
vim.tiny File 1.66 MB 0755
vimdiff File 3.94 MB 0755
vimtutor File 2.1 KB 0755
vm-support File 9.83 KB 0755
vmhgfs-fuse File 46.73 KB 0755
vmstat File 38.78 KB 0755
vmtoolsd File 74.56 KB 0755
vmware-alias-import File 42.52 KB 0755
vmware-checkvm File 14.38 KB 0755
vmware-hgfsclient File 14.38 KB 0755
vmware-namespace-cmd File 22.3 KB 0755
vmware-rpctool File 18.3 KB 0755
vmware-toolbox-cmd File 54.59 KB 0755
vmware-vgauth-cmd File 18.3 KB 0755
vmware-vmblock-fuse File 22.78 KB 0755
vmware-xferlogs File 32.33 KB 0755
w File 26.38 KB 0755
w3m File 1.58 MB 0755
w3mman File 1.37 KB 0755
wall File 22.38 KB 0755
watch File 30.84 KB 0755
watchgnupg File 22.3 KB 0755
wbmptopbm File 14.3 KB 0755
wc File 54.52 KB 0755
wcmgr File 26.2 KB 0755
wdctl File 34.4 KB 0755
webalizer File 212.35 KB 0755
webazolver File 212.35 KB 0755
wget File 459.02 KB 0755
whatis File 47.28 KB 0755
whereis File 30.84 KB 0755
which File 1.05 KB 0755
which.debianutils File 1.05 KB 0755
whiptail File 30.16 KB 0755
who File 58.52 KB 0755
whoami File 34.51 KB 0755
whois File 155.66 KB 0755
wifi-status File 2.06 KB 0755
winicontopam File 22.3 KB 0755
winicontoppm File 18.3 KB 0755
write File 22.38 KB 0755
wsrep_sst_backup File 2.39 KB 0755
wsrep_sst_common File 66.86 KB 0755
wsrep_sst_mariabackup File 49.23 KB 0755
wsrep_sst_mysqldump File 8.11 KB 0755
wsrep_sst_rsync File 29.72 KB 0755
wsrep_sst_rsync_wan File 29.72 KB 0755
www-browser File 1.58 MB 0755
x86_64 File 26.65 KB 0755
x86_energy_perf_policy File 1.58 KB 0755
xargs File 62.41 KB 0755
xauth File 54.96 KB 0755
xbmtopbm File 14.3 KB 0755
xdg-user-dir File 234 B 0755
xdg-user-dirs-update File 26.23 KB 0755
ximtoppm File 14.3 KB 0755
xpmtoppm File 18.35 KB 0755
xsubpp File 5.05 KB 0755
xvminitoppm File 14.3 KB 0755
xwdtopnm File 26.3 KB 0755
xxd File 22.28 KB 0755
xz File 86.92 KB 0755
xzcat File 86.92 KB 0755
xzcmp File 7.25 KB 0755
xzdiff File 7.25 KB 0755
xzegrep File 10.09 KB 0755
xzfgrep File 10.09 KB 0755
xzgrep File 10.09 KB 0755
xzless File 1.77 KB 0755
xzmore File 2.14 KB 0755
ybmtopbm File 14.3 KB 0755
yes File 34.38 KB 0755
ypdomainname File 22.23 KB 0755
yuvsplittoppm File 14.3 KB 0755
yuvtoppm File 14.3 KB 0755
yuy2topam File 14.3 KB 0755
zcat File 1.94 KB 0755
zcmp File 1.64 KB 0755
zdiff File 6.31 KB 0755
zdump File 30.28 KB 0755
zegrep File 29 B 0755
zeisstopnm File 14.3 KB 0755
zfgrep File 29 B 0755
zforce File 2.03 KB 0755
zgrep File 7.91 KB 0755
zip File 206.98 KB 0755
zipcloak File 70.4 KB 0755
zipdetails File 68.55 KB 0755
zipgrep File 2.89 KB 0755
zipinfo File 174.42 KB 0755
zipnote File 62.4 KB 0755
zipsplit File 58.4 KB 0755
zless File 2.15 KB 0755
zmore File 1.8 KB 0755
znew File 4.47 KB 0755
zstd File 998.79 KB 0755
zstdcat File 998.79 KB 0755
zstdgrep File 3.78 KB 0755
zstdless File 197 B 0755
zstdmt File 998.79 KB 0755
Filemanager