Gecko [ lemon-casino1.com ]

Name	Size	Permission	Date
X11	[ DIR ]	drwxr-xr-x	2024-07-29 11:47
Mail	110.4 KB	-rwxr-xr-x	2024-04-08 17:54
[	54.44 KB	-rwxr-xr-x	2024-04-05 16:36
aa-enabled	18.3 KB	-rwxr-xr-x	2024-07-15 00:25
aa-exec	18.3 KB	-rwxr-xr-x	2024-07-15 00:25
aa-features-abi	18.3 KB	-rwxr-xr-x	2024-07-15 00:25
ab	58.43 KB	-rwxr-xr-x	2024-07-17 20:55
acpidbg	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
add-apt-repository	16.04 KB	-rwxr-xr-x	2024-04-18 09:17
addpart	14.38 KB	-rwxr-xr-x	2024-04-09 16:02
addr2line	30.7 KB	-rwxr-xr-x	2024-03-29 20:49
apport-bug	2.27 KB	-rwxr-xr-x	2024-04-18 14:31
apport-cli	13.31 KB	-rwxr-xr-x	2024-04-23 13:30
apport-collect	2.27 KB	-rwxr-xr-x	2024-04-18 14:31
apport-unpack	3.7 KB	-rwxr-xr-x	2024-04-23 13:30
appstreamcli	138.23 KB	-rwxr-xr-x	2024-04-08 16:37
apt	18.38 KB	-rwxr-xr-x	2024-03-31 19:01
apt-add-repository	16.04 KB	-rwxr-xr-x	2024-04-18 09:17
apt-cache	86.47 KB	-rwxr-xr-x	2024-03-31 19:01
apt-cdrom	26.47 KB	-rwxr-xr-x	2024-03-31 19:01
apt-config	30.39 KB	-rwxr-xr-x	2024-03-31 19:01
apt-get	50.47 KB	-rwxr-xr-x	2024-03-31 19:01
apt-key	27.99 KB	-rwxr-xr-x	2024-03-31 19:01
apt-mark	54.47 KB	-rwxr-xr-x	2024-03-31 19:01
apt-show-versions	34.79 KB	-rwxr-xr-x	2023-08-29 13:43
ar	54.48 KB	-rwxr-xr-x	2024-03-29 20:49
arch	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
as	728.29 KB	-rwxr-xr-x	2024-03-29 20:49
awk	722.5 KB	-rwxr-xr-x	2024-03-31 07:33
b2sum	54.51 KB	-rwxr-xr-x	2024-04-05 16:36
base32	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
base64	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
basename	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
basenc	46.51 KB	-rwxr-xr-x	2024-04-05 16:36
bash	1.38 MB	-rwxr-xr-x	2024-03-31 10:41
bashbug	6.82 KB	-rwxr-xr-x	2024-03-31 10:41
bdftopcf	42.26 KB	-rwxr-xr-x	2024-04-08 18:22
bdftruncate	14.15 KB	-rwxr-xr-x	2024-04-08 18:22
bpftrace	2.15 MB	-rwxr-xr-x	2024-04-10 13:36
bpftrace-aotrt	985.37 KB	-rwxr-xr-x	2024-04-10 13:36
bsd-mailx	110.4 KB	-rwxr-xr-x	2024-04-08 17:54
bsdcat	14.45 KB	-rwxr-xr-x	2024-05-30 16:57
bsdcpio	46.45 KB	-rwxr-xr-x	2024-05-30 16:57
bsdtar	74.45 KB	-rwxr-xr-x	2024-05-30 16:57
bsdunzip	34.41 KB	-rwxr-xr-x	2024-05-30 16:57
btrfs	1001.25 KB	-rwxr-xr-x	2024-03-31 10:43
btrfs-convert	576.3 KB	-rwxr-xr-x	2024-03-31 10:43
btrfs-find-root	520.3 KB	-rwxr-xr-x	2024-03-31 10:43
btrfs-image	552.3 KB	-rwxr-xr-x	2024-03-31 10:43
btrfs-map-logical	520.3 KB	-rwxr-xr-x	2024-03-31 10:43
btrfs-select-super	516.3 KB	-rwxr-xr-x	2024-03-31 10:43
btrfsck	1001.25 KB	-rwxr-xr-x	2024-03-31 10:43
btrfstune	544.3 KB	-rwxr-xr-x	2024-03-31 10:43
bunzip2	38.38 KB	-rwxr-xr-x	2024-03-09 18:31
busctl	94.59 KB	-rwxr-xr-x	2024-06-14 23:03
bzcat	38.38 KB	-rwxr-xr-x	2024-03-09 18:31
bzcmp	2.17 KB	-rwxr-xr-x	2024-03-09 18:31
bzdiff	2.17 KB	-rwxr-xr-x	2024-03-09 18:31
bzegrep	3.69 KB	-rwxr-xr-x	2024-03-09 18:31
bzexe	4.78 KB	-rwxr-xr-x	2021-11-27 13:25
bzfgrep	3.69 KB	-rwxr-xr-x	2024-03-09 18:31
bzgrep	3.69 KB	-rwxr-xr-x	2024-03-09 18:31
bzip2	38.38 KB	-rwxr-xr-x	2024-03-09 18:31
bzip2recover	18.3 KB	-rwxr-xr-x	2024-03-09 18:31
bzless	1.27 KB	-rwxr-xr-x	2024-03-09 18:31
bzmore	1.27 KB	-rwxr-xr-x	2024-03-09 18:31
c++	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
c++filt	22.27 KB	-rwxr-xr-x	2024-03-29 20:49
c89	428 B	-rwxr-xr-x	2020-11-17 19:53
c89-gcc	428 B	-rwxr-xr-x	2020-11-17 19:53
c99	454 B	-rwxr-xr-x	2020-11-17 19:53
c99-gcc	454 B	-rwxr-xr-x	2020-11-17 19:53
c_rehash	6.68 KB	-rwxr-xr-x	2024-05-14 11:06
captoinfo	90.41 KB	-rwxr-xr-x	2024-04-08 18:14
cat	38.46 KB	-rwxr-xr-x	2024-04-05 16:36
cc	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
chage	70.49 KB	-rwxr-sr-x	2024-04-09 09:01
chardet	221 B	-rwxr-xr-x	2023-08-20 14:12
chardetect	221 B	-rwxr-xr-x	2023-08-20 14:12
chattr	14.31 KB	-rwxr-xr-x	2024-04-08 16:38
chcon	58.51 KB	-rwxr-xr-x	2024-04-05 16:36
checkgid	14.3 KB	-rwxr-xr-x	2024-07-17 20:55
chfn	71.09 KB	-rwsr-xr-x	2024-04-09 09:01
chgrp	58.51 KB	-rwxr-xr-x	2024-04-05 16:36
chmod	54.51 KB	-rwxr-xr-x	2024-04-05 16:36
choom	22.38 KB	-rwxr-xr-x	2024-04-09 16:02
chown	58.51 KB	-rwxr-xr-x	2024-04-05 16:36
chronyc	91.2 KB	-rwxr-xr-x	2024-07-02 22:22
chrt	30.38 KB	-rwxr-xr-x	2024-04-09 16:02
chsh	43.71 KB	-rwsr-xr-x	2024-04-09 09:01
chvt	14.37 KB	-rwxr-xr-x	2024-03-31 11:02
cifsiostat	26.45 KB	-rwxr-xr-x	2024-01-09 21:31
ckbcomp	147.14 KB	-rwxr-xr-x	2024-02-26 13:58
cksum	102.52 KB	-rwxr-xr-x	2024-04-05 16:36
clear	14.31 KB	-rwxr-xr-x	2024-04-08 18:14
clear_console	14.23 KB	-rwxr-xr-x	2024-03-31 10:41
cloud-id	972 B	-rwxr-xr-x	2024-06-05 19:37
cloud-init	976 B	-rwxr-xr-x	2024-06-05 19:37
cloud-init-per	2.06 KB	-rwxr-xr-x	2024-03-27 14:14
clp-update	170 B	-rwx------	2024-05-28 10:08
clpctl	151 B	-rwxr-xr-x	2024-05-28 10:08
clpctlWrapper	565 B	-rwx------	2024-05-28 10:08
cmp	42.39 KB	-rwxr-xr-x	2024-04-08 17:55
codepage	14.3 KB	-rwxr-xr-x	2024-03-31 11:02
comm	38.52 KB	-rwxr-xr-x	2024-04-05 16:36
comp_err	6.34 MB	-rwxr-xr-x	2024-05-09 09:08
corelist	15.01 KB	-rwxr-xr-x	2024-04-05 21:57
cp	138.52 KB	-rwxr-xr-x	2024-04-05 16:36
cpan	8.16 KB	-rwxr-xr-x	2024-04-05 21:57
cpan5.38-x86_64-linux-gnu	8.18 KB	-rwxr-xr-x	2024-04-05 21:57
cpio	137.67 KB	-rwxr-xr-x	2024-04-08 17:55
cpp	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
cpp-13	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
cpupower	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
crontab	38.73 KB	-rwxr-sr-x	2024-03-31 01:06
csplit	50.51 KB	-rwxr-xr-x	2024-04-05 16:36
ctstat	22.66 KB	-rwxr-xr-x	2024-03-31 11:00
curl	290.32 KB	-rwxr-xr-x	2024-04-22 18:00
cut	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
cvtsudoers	321.13 KB	-rwxr-xr-x	2024-04-08 16:50
dash	126.74 KB	-rwxr-xr-x	2024-03-31 10:47
date	106.51 KB	-rwxr-xr-x	2024-04-05 16:36
dbus-cleanup-sockets	14.29 KB	-rwxr-xr-x	2024-04-08 16:38
dbus-daemon	230.64 KB	-rwxr-xr-x	2024-04-08 16:38
dbus-monitor	26.3 KB	-rwxr-xr-x	2024-04-08 16:38
dbus-run-session	14.3 KB	-rwxr-xr-x	2024-04-08 16:38
dbus-send	30.29 KB	-rwxr-xr-x	2024-04-08 16:38
dbus-update-activation-environment	14.29 KB	-rwxr-xr-x	2024-04-08 16:38
dbus-uuidgen	14.29 KB	-rwxr-xr-x	2024-04-08 16:38
dc	50.24 KB	-rwxr-xr-x	2024-04-08 16:37
dd	70.54 KB	-rwxr-xr-x	2024-04-05 16:36
deallocvt	14.37 KB	-rwxr-xr-x	2024-03-31 11:02
deb-systemd-helper	23.79 KB	-rwxr-xr-x	2023-12-06 08:46
deb-systemd-invoke	6.97 KB	-rwxr-xr-x	2023-12-06 08:47
debconf	2.8 KB	-rwxr-xr-x	2024-04-12 14:40
debconf-apt-progress	11.57 KB	-rwxr-xr-x	2024-04-12 14:40
debconf-communicate	623 B	-rwxr-xr-x	2024-04-12 14:40
debconf-copydb	1.68 KB	-rwxr-xr-x	2024-04-12 14:40
debconf-escape	668 B	-rwxr-xr-x	2024-04-12 14:40
debconf-set-selections	3.14 KB	-rwxr-xr-x	2024-04-12 14:40
debconf-show	1.78 KB	-rwxr-xr-x	2024-04-12 14:40
debsums	24.86 KB	-rwxr-xr-x	2023-05-08 01:50
delpart	14.38 KB	-rwxr-xr-x	2024-04-09 16:02
df	87.08 KB	-rwxr-xr-x	2024-04-05 16:36
dh_installxmlcatalogs	9.22 KB	-rwxr-xr-x	2023-12-12 03:01
diff	134.55 KB	-rwxr-xr-x	2024-04-08 17:55
diff3	58.52 KB	-rwxr-xr-x	2024-04-08 17:55
dir	138.98 KB	-rwxr-xr-x	2024-04-05 16:36
dircolors	46.52 KB	-rwxr-xr-x	2024-04-05 16:36
dirmngr	473.77 KB	-rwxr-xr-x	2024-04-06 18:25
dirmngr-client	54.92 KB	-rwxr-xr-x	2024-04-06 18:25
dirname	34.38 KB	-rwxr-xr-x	2024-04-05 16:36
dmesg	68.64 KB	-rwxr-xr-x	2024-04-09 16:02
dnsdomainname	22.23 KB	-rwxr-xr-x	2024-04-08 17:59
do-release-upgrade	10.42 KB	-rwxr-xr-x	2024-06-04 17:55
domainname	22.23 KB	-rwxr-xr-x	2024-04-08 17:59
dotlockfile	22.15 KB	-rwxr-sr-x	2024-04-08 18:05
dpkg	310.72 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-architecture	14.85 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-buildapi	1.79 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-buildflags	8.14 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-buildpackage	34.2 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-buildtree	1.88 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-checkbuilddeps	7.45 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-deb	142.58 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-distaddfile	2.72 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-divert	118.57 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-genbuildinfo	18.54 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-genchanges	17.92 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-gencontrol	14.29 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-gensymbols	10.66 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-maintscript-helper	20.71 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-mergechangelogs	8.87 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-name	6.61 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-parsechangelog	4.83 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-query	134.56 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-realpath	4.09 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-scanpackages	8.45 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-scansources	9.1 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-shlibdeps	31.46 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-source	23.05 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-split	98.53 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-statoverride	50.38 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-trigger	42.53 KB	-rwxr-xr-x	2024-03-31 00:51
dpkg-vendor	3.18 KB	-rwxr-xr-x	2024-03-31 00:51
du	98.51 KB	-rwxr-xr-x	2024-04-05 16:36
dumpkeys	162.85 KB	-rwxr-xr-x	2024-03-31 11:02
dvipdf	1007 B	-rwxr-xr-x	2024-07-11 18:07
dwp	1.87 MB	-rwxr-xr-x	2024-03-29 20:49
eatmydata	2.74 KB	-rwxr-xr-x	2024-04-08 19:00
ec2metadata	8.38 KB	-rwxr-xr-x	2022-06-03 12:51
echo	34.38 KB	-rwxr-xr-x	2024-04-05 16:36
editor	272.5 KB	-rwxr-xr-x	2024-04-08 18:13
egrep	41 B	-rwxr-xr-x	2024-04-08 17:58
elfedit	34.72 KB	-rwxr-xr-x	2024-03-29 20:49
enc2xs	40.96 KB	-rwxr-xr-x	2024-04-05 21:57
encguess	3 KB	-rwxr-xr-x	2024-04-05 21:57
env	46.95 KB	-rwxr-xr-x	2024-04-05 16:36
envsubst	34.38 KB	-rwxr-xr-x	2024-04-08 17:58
eps2eps	639 B	-rwxr-xr-x	2024-07-11 18:07
eqn	188.45 KB	-rwxr-xr-x	2024-03-31 10:54
ex	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
expand	34.53 KB	-rwxr-xr-x	2024-04-05 16:36
expiry	26.52 KB	-rwxr-sr-x	2024-04-09 09:01
expr	42.41 KB	-rwxr-xr-x	2024-04-05 16:36
factor	62.51 KB	-rwxr-xr-x	2024-04-05 16:36
fail2ban-client	1.39 KB	-rwxr-xr-x	2024-06-10 23:27
fail2ban-python	7.65 MB	-rwxr-xr-x	2024-04-10 07:33
fail2ban-regex	1.25 KB	-rwxr-xr-x	2024-06-10 23:27
fail2ban-server	1.38 KB	-rwxr-xr-x	2024-06-10 23:27
fail2ban-testcases	2.23 KB	-rwxr-xr-x	2024-06-10 23:27
faillog	22.63 KB	-rwxr-xr-x	2024-04-09 09:01
faked-sysv	30.39 KB	-rwxr-xr-x	2024-01-21 17:56
faked-tcp	34.38 KB	-rwxr-xr-x	2024-01-21 17:56
fakeroot	3.9 KB	-rwxr-xr-x	2024-01-21 17:56
fakeroot-sysv	3.9 KB	-rwxr-xr-x	2024-01-21 17:56
fakeroot-tcp	3.9 KB	-rwxr-xr-x	2024-01-21 17:56
fallocate	26.38 KB	-rwxr-xr-x	2024-04-09 16:02
false	26.3 KB	-rwxr-xr-x	2024-04-05 16:36
fcgistarter	14.3 KB	-rwxr-xr-x	2024-07-17 20:55
fgconsole	14.37 KB	-rwxr-xr-x	2024-03-31 11:02
fgrep	41 B	-rwxr-xr-x	2024-04-08 17:58
finalrd	2.06 KB	-rwxr-xr-x	2022-02-16 17:56
find	199.48 KB	-rwxr-xr-x	2024-04-08 17:57
findmnt	67.66 KB	-rwxr-xr-x	2024-04-09 16:02
flock	22.48 KB	-rwxr-xr-x	2024-04-09 16:02
fmt	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
fold	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
fonttosfnt	38.16 KB	-rwxr-xr-x	2024-04-08 18:22
free	26.38 KB	-rwxr-xr-x	2024-03-31 10:16
ftpcount	23.66 KB	-rwxr-xr-x	2024-05-09 09:08
ftpdctl	98.36 KB	-rwxr-xr-x	2024-05-09 09:08
ftptop	27.33 KB	-rwxr-xr-x	2024-05-09 09:08
ftpwho	43.8 KB	-rwxr-xr-x	2024-05-09 09:08
funzip	26.3 KB	-rwxr-xr-x	2024-04-08 18:21
fuser	39.34 KB	-rwxr-xr-x	2024-03-31 19:02
fusermount	38.38 KB	-rwsr-xr-x	2024-04-08 17:57
fusermount3	38.38 KB	-rwsr-xr-x	2024-04-08 17:57
g++	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
g++-13	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
gapplication	22.38 KB	-rwxr-xr-x	2024-05-07 19:30
gawk	722.5 KB	-rwxr-xr-x	2024-03-31 07:33
gawkbug	6.74 KB	-rwxr-xr-x	2024-03-31 07:33
gcc	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
gcc-13	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
gcc-ar	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
gcc-ar-13	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
gcc-nm	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
gcc-nm-13	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
gcc-ranlib	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
gcc-ranlib-13	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
gcov	1.06 MB	-rwxr-xr-x	2024-04-14 09:31
gcov-13	1.06 MB	-rwxr-xr-x	2024-04-14 09:31
gcov-dump	992.3 KB	-rwxr-xr-x	2024-04-14 09:31
gcov-dump-13	992.3 KB	-rwxr-xr-x	2024-04-14 09:31
gcov-tool	948.3 KB	-rwxr-xr-x	2024-04-14 09:31
gcov-tool-13	948.3 KB	-rwxr-xr-x	2024-04-14 09:31
gdbus	50.38 KB	-rwxr-xr-x	2024-05-07 19:30
gencat	26.44 KB	-rwxr-xr-x	2024-04-30 20:02
geqn	188.45 KB	-rwxr-xr-x	2024-03-31 10:54
getconf	26.36 KB	-rwxr-xr-x	2024-04-30 20:02
getent	38.72 KB	-rwxr-xr-x	2024-04-30 20:02
getkeycodes	14.37 KB	-rwxr-xr-x	2024-03-31 11:02
getopt	22.38 KB	-rwxr-xr-x	2024-04-09 16:02
gettext	34.38 KB	-rwxr-xr-x	2024-04-08 17:58
gettext.sh	5.07 KB	-rwxr-xr-x	2024-04-08 17:58
ghostscript	14.15 KB	-rwxr-xr-x	2024-07-11 18:07
gifdiff	54.38 KB	-rwxr-xr-x	2023-06-24 19:46
gifsicle	190.66 KB	-rwxr-xr-x	2023-06-24 19:46
gifview	66.4 KB	-rwxr-xr-x	2023-06-24 19:46
gio	102.4 KB	-rwxr-xr-x	2024-05-07 19:30
gio-querymodules	18.3 KB	-rwxr-xr-x	2024-05-07 19:30
git	3.88 MB	-rwxr-xr-x	2024-05-20 13:15
git-receive-pack	3.88 MB	-rwxr-xr-x	2024-05-20 13:15
git-shell	624.81 KB	-rwxr-xr-x	2024-05-20 13:15
git-upload-archive	3.88 MB	-rwxr-xr-x	2024-05-20 13:15
git-upload-pack	3.88 MB	-rwxr-xr-x	2024-05-20 13:15
glib-compile-schemas	54.3 KB	-rwxr-xr-x	2024-05-07 19:30
gmake	253.72 KB	-rwxr-xr-x	2024-04-08 18:12
gold	3.08 MB	-rwxr-xr-x	2024-03-29 20:49
gp-archive	158.53 KB	-rwxr-xr-x	2024-03-29 20:49
gp-collect-app	174.37 KB	-rwxr-xr-x	2024-03-29 20:49
gp-display-html	626.89 KB	-rwxr-xr-x	2024-03-29 20:49
gp-display-src	150.35 KB	-rwxr-xr-x	2024-03-29 20:49
gp-display-text	286.37 KB	-rwxr-xr-x	2024-03-29 20:49
gpasswd	74.46 KB	-rwsr-xr-x	2024-04-09 09:01
gpg	1.09 MB	-rwxr-xr-x	2024-04-06 18:25
gpg-agent	357.52 KB	-rwxr-xr-x	2024-04-06 18:25
gpg-connect-agent	87.3 KB	-rwxr-xr-x	2024-04-06 18:25
gpg-wks-client	139.37 KB	-rwxr-xr-x	2024-04-06 18:25
gpgconf	115.36 KB	-rwxr-xr-x	2024-04-06 18:25
gpgparsemail	34.38 KB	-rwxr-xr-x	2024-04-06 18:25
gpgsm	501.37 KB	-rwxr-xr-x	2024-04-06 18:25
gpgsplit	26.62 KB	-rwxr-xr-x	2024-04-06 18:25
gpgtar	67.83 KB	-rwxr-xr-x	2024-04-06 18:25
gpgv	303.14 KB	-rwxr-xr-x	2024-04-06 18:25
gpic	196.06 KB	-rwxr-xr-x	2024-03-31 10:54
gprof	99.79 KB	-rwxr-xr-x	2024-03-29 20:49
gprofng	138.35 KB	-rwxr-xr-x	2024-03-29 20:49
gpu-manager	78.82 KB	-rwxr-xr-x	2024-04-03 11:11
grep	182.45 KB	-rwxr-xr-x	2024-04-08 17:58
gresource	22.3 KB	-rwxr-xr-x	2024-05-07 19:30
groff	94.51 KB	-rwxr-xr-x	2024-03-31 10:54
grog	18.75 KB	-rwxr-xr-x	2024-03-31 10:54
grops	162.55 KB	-rwxr-xr-x	2024-03-31 10:54
grotty	118.51 KB	-rwxr-xr-x	2024-03-31 10:54
groups	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
growpart	29.19 KB	-rwxr-xr-x	2022-06-03 12:51
grub-editenv	393.13 KB	-rwxr-xr-x	2024-04-04 12:12
grub-file	732.6 KB	-rwxr-xr-x	2024-04-04 12:12
grub-fstest	858.1 KB	-rwxr-xr-x	2024-04-04 12:12
grub-glue-efi	102.88 KB	-rwxr-xr-x	2024-04-04 12:12
grub-kbdcomp	1.64 KB	-rwxr-xr-x	2024-04-04 12:12
grub-menulst2cfg	83.2 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mkfont	131.45 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mkimage	377.23 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mklayout	103.23 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mknetdir	429.74 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mkpasswd-pbkdf2	111.32 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mkrelpath	259.73 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mkrescue	1014.55 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mkstandalone	510.07 KB	-rwxr-xr-x	2024-04-04 12:12
grub-mount	672.99 KB	-rwxr-xr-x	2024-04-04 12:12
grub-ntldr-img	38.39 KB	-rwxr-xr-x	2024-04-04 12:12
grub-render-label	744.95 KB	-rwxr-xr-x	2024-04-04 12:12
grub-script-check	126.76 KB	-rwxr-xr-x	2024-04-04 12:12
grub-syslinux2cfg	697.46 KB	-rwxr-xr-x	2024-04-04 12:12
gs	14.15 KB	-rwxr-xr-x	2024-07-11 18:07
gsbj	350 B	-rwxr-xr-x	2024-07-11 18:07
gsdj	352 B	-rwxr-xr-x	2024-07-11 18:07
gsdj500	352 B	-rwxr-xr-x	2024-07-11 18:07
gsettings	30.3 KB	-rwxr-xr-x	2024-05-07 19:30
gslj	353 B	-rwxr-xr-x	2024-07-11 18:07
gslp	350 B	-rwxr-xr-x	2024-07-11 18:07
gsnd	277 B	-rwxr-xr-x	2024-07-11 18:07
gtbl	134.48 KB	-rwxr-xr-x	2024-03-31 10:54
gunzip	2.29 KB	-rwxr-xr-x	2024-04-08 17:58
gzexe	6.3 KB	-rwxr-xr-x	2024-04-08 17:58
gzip	91.23 KB	-rwxr-xr-x	2024-04-08 17:58
h2ph	28.54 KB	-rwxr-xr-x	2024-04-05 21:57
h2xs	59.51 KB	-rwxr-xr-x	2024-04-05 21:57
hardlink	46.48 KB	-rwxr-xr-x	2024-04-09 16:02
head	42.51 KB	-rwxr-xr-x	2024-04-05 16:36
helpztags	2.46 KB	-rwxr-xr-x	2023-11-28 20:12
hostid	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
hostname	22.23 KB	-rwxr-xr-x	2024-04-08 17:59
hostnamectl	30.45 KB	-rwxr-xr-x	2024-06-14 23:03
htcacheclean	34.31 KB	-rwxr-xr-x	2024-07-17 20:55
htdbm	26.3 KB	-rwxr-xr-x	2024-07-17 20:55
htdigest	14.3 KB	-rwxr-xr-x	2024-07-17 20:55
htop	370.33 KB	-rwxr-xr-x	2024-04-08 17:59
htpasswd	26.3 KB	-rwxr-xr-x	2024-07-17 20:55
i386	26.65 KB	-rwxr-xr-x	2024-04-09 16:02
ibd2sdi	6.48 MB	-rwxr-xr-x	2024-05-09 09:08
iconv	66.48 KB	-rwxr-xr-x	2024-04-30 20:02
id	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
inetutils-telnet	177.85 KB	-rwxr-xr-x	2024-03-31 01:08
infocmp	66.38 KB	-rwxr-xr-x	2024-04-08 18:14
infotocap	90.41 KB	-rwxr-xr-x	2024-04-08 18:14
innochecksum	6.43 MB	-rwxr-xr-x	2024-05-09 09:08
install	142.52 KB	-rwxr-xr-x	2024-04-05 16:36
instmodsh	4.27 KB	-rwxr-xr-x	2024-04-05 21:57
ionice	18.38 KB	-rwxr-xr-x	2024-04-09 16:02
iostat	54.44 KB	-rwxr-xr-x	2024-01-09 21:31
ip	754.74 KB	-rwxr-xr-x	2024-03-31 11:00
ipcmk	22.45 KB	-rwxr-xr-x	2024-04-09 16:02
ipcrm	18.38 KB	-rwxr-xr-x	2024-04-09 16:02
ipcs	38.38 KB	-rwxr-xr-x	2024-04-09 16:02
iptables-xml	92.95 KB	-rwxr-xr-x	2024-04-08 17:59
ischroot	14.48 KB	-rwxr-xr-x	2024-03-31 10:47
iscsiadm	370.43 KB	-rwxr-xr-x	2024-04-08 16:46
join	50.55 KB	-rwxr-xr-x	2024-04-05 16:36
journalctl	78.91 KB	-rwxr-xr-x	2024-06-14 23:03
jpegoptim	39.35 KB	-rwxr-xr-x	2022-06-20 16:40
json-patch-jsondiff	1004 B	-rwxr-xr-x	2023-08-21 15:10
json_pp	4.88 KB	-rwxr-xr-x	2024-04-05 21:57
jsondiff	1004 B	-rwxr-xr-x	2023-08-21 15:10
jsonpatch	3.77 KB	-rwxr-xr-x	2023-08-21 15:10
jsonpointer	1.79 KB	-rwxr-xr-x	2020-01-24 04:25
jsonschema	213 B	-rwxr-xr-x	2023-08-14 23:45
kbd_mode	14.66 KB	-rwxr-xr-x	2024-03-31 11:02
kbdinfo	18.37 KB	-rwxr-xr-x	2024-03-31 11:02
kbxutil	62.83 KB	-rwxr-xr-x	2024-04-06 18:25
kernel-install	54.67 KB	-rwxr-xr-x	2024-06-14 23:03
kill	22.38 KB	-rwxr-xr-x	2024-03-31 10:16
killall	31.34 KB	-rwxr-xr-x	2024-03-31 19:02
kmod	170.24 KB	-rwxr-xr-x	2024-04-18 12:06
last	34.38 KB	-rwxr-xr-x	2024-04-09 16:02
lastb	34.38 KB	-rwxr-xr-x	2024-04-09 16:02
lastlog	27.79 KB	-rwxr-xr-x	2024-04-09 09:01
lcf	7.6 KB	-rwxr-xr-x	2023-01-27 14:29
ld	1.3 MB	-rwxr-xr-x	2024-03-29 20:49
ld.bfd	1.3 MB	-rwxr-xr-x	2024-03-29 20:49
ld.gold	3.08 MB	-rwxr-xr-x	2024-03-29 20:49
ld.so	231.07 KB	-rwxr-xr-x	2024-04-30 20:02
ldd	5.26 KB	-rwxr-xr-x	2024-04-30 20:02
less	190.38 KB	-rwxr-xr-x	2024-04-28 13:44
lessecho	14.31 KB	-rwxr-xr-x	2024-04-28 13:44
lessfile	8.83 KB	-rwxr-xr-x	2023-02-12 11:17
lesskey	23.7 KB	-rwxr-xr-x	2024-04-28 13:44
lesspipe	8.83 KB	-rwxr-xr-x	2023-02-12 11:17
libnetcfg	15.41 KB	-rwxr-xr-x	2024-04-05 21:57
link	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
linux-boot-prober	1.54 KB	-rwxr-xr-x	2023-03-07 14:24
linux-check-removal	3.99 KB	-rwxr-xr-x	2020-06-25 19:23
linux-update-symlinks	6.17 KB	-rwxr-xr-x	2020-06-25 19:23
linux-version	2.63 KB	-rwxr-xr-x	2021-05-03 18:16
linux32	26.65 KB	-rwxr-xr-x	2024-04-09 16:02
linux64	26.65 KB	-rwxr-xr-x	2024-04-09 16:02
ln	54.51 KB	-rwxr-xr-x	2024-04-05 16:36
lnstat	22.66 KB	-rwxr-xr-x	2024-03-31 11:00
loadkeys	202.9 KB	-rwxr-xr-x	2024-03-31 11:02
loadunimap	34.46 KB	-rwxr-xr-x	2024-03-31 11:02
locale	49.63 KB	-rwxr-xr-x	2024-04-30 20:02
locale-check	14.15 KB	-rwxr-xr-x	2024-04-22 15:08
localectl	26.45 KB	-rwxr-xr-x	2024-06-14 23:03
localedef	319.09 KB	-rwxr-xr-x	2024-04-30 20:02
logger	38.97 KB	-rwxr-xr-x	2024-04-09 16:02
login	51.81 KB	-rwxr-xr-x	2024-04-09 09:01
loginctl	66.58 KB	-rwxr-xr-x	2024-06-14 23:03
logname	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
logresolve	14.31 KB	-rwxr-xr-x	2024-07-17 20:55
ls	138.98 KB	-rwxr-xr-x	2024-04-05 16:36
lsattr	14.31 KB	-rwxr-xr-x	2024-04-08 16:38
lsb_release	2.59 KB	-rwxr-xr-x	2023-07-05 17:34
lsblk	146.38 KB	-rwxr-xr-x	2024-04-09 16:02
lscpu	110.38 KB	-rwxr-xr-x	2024-04-09 16:02
lsinitramfs	735 B	-rwxr-xr-x	2023-07-31 20:14
lsipc	50.38 KB	-rwxr-xr-x	2024-04-09 16:02
lslocks	30.77 KB	-rwxr-xr-x	2024-04-09 16:02
lslogins	50.38 KB	-rwxr-xr-x	2024-04-09 16:02
lsmem	38.38 KB	-rwxr-xr-x	2024-04-09 16:02
lsmod	170.24 KB	-rwxr-xr-x	2024-04-18 12:06
lsns	42.38 KB	-rwxr-xr-x	2024-04-09 16:02
lsof	171.66 KB	-rwxr-xr-x	2024-03-31 11:13
lspci	100.11 KB	-rwxr-xr-x	2024-04-08 18:15
lspgpot	1.06 KB	-rwxr-xr-x	2023-04-04 10:28
lsusb	246.52 KB	-rwxr-xr-x	2024-04-08 18:21
lto-dump	31.31 MB	-rwxr-xr-x	2024-04-14 09:31
lto-dump-13	31.31 MB	-rwxr-xr-x	2024-04-14 09:31
lz4_decompress	6.35 MB	-rwxr-xr-x	2024-05-09 09:08
lzcat	86.92 KB	-rwxr-xr-x	2024-03-28 15:59
lzcmp	7.25 KB	-rwxr-xr-x	2024-03-28 15:59
lzdiff	7.25 KB	-rwxr-xr-x	2024-03-28 15:59
lzegrep	10.09 KB	-rwxr-xr-x	2024-03-28 15:59
lzfgrep	10.09 KB	-rwxr-xr-x	2024-03-28 15:59
lzgrep	10.09 KB	-rwxr-xr-x	2024-03-28 15:59
lzless	1.77 KB	-rwxr-xr-x	2024-03-28 15:59
lzma	86.92 KB	-rwxr-xr-x	2024-03-28 15:59
lzmainfo	14.38 KB	-rwxr-xr-x	2024-03-28 15:59
lzmore	2.14 KB	-rwxr-xr-x	2024-03-28 15:59
mail	110.4 KB	-rwxr-xr-x	2024-04-08 17:54
mailq	30.45 KB	-rwxr-xr-x	2024-04-08 16:48
mailx	110.4 KB	-rwxr-xr-x	2024-04-08 17:54
make	253.72 KB	-rwxr-xr-x	2024-04-08 18:12
make-first-existing-target	4.79 KB	-rwxr-xr-x	2024-04-08 18:12
man	320 B	-rwxr-xr-x	2024-04-23 11:40
mapscrn	30.46 KB	-rwxr-xr-x	2024-03-31 11:02
markdown-it	220 B	-rwxr-xr-x	2023-06-19 15:24
mawk	166.77 KB	-rwxr-xr-x	2024-04-08 18:12
mcookie	26.45 KB	-rwxr-xr-x	2024-04-09 16:02
md5sum	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
md5sum.textutils	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
memcached	256.2 KB	-rwxr-xr-x	2024-04-01 08:55
memusage	7.32 KB	-rwxr-xr-x	2024-04-30 20:02
memusagestat	22.44 KB	-rwxr-xr-x	2024-04-30 20:02
mesg	14.38 KB	-rwxr-xr-x	2024-04-09 16:02
migrate-pubring-from-classic-gpg	3.02 KB	-rwxr-xr-x	2024-03-01 09:25
mk_modmap	15.78 KB	-rwxr-xr-x	2024-03-31 11:02
mkdir	74.51 KB	-rwxr-xr-x	2024-04-05 16:36
mkfifo	42.51 KB	-rwxr-xr-x	2024-04-05 16:36
mkfontdir	65 B	-rwxr-xr-x	2024-04-08 18:22
mkfontscale	42.67 KB	-rwxr-xr-x	2024-04-08 18:22
mknod	42.51 KB	-rwxr-xr-x	2024-04-05 16:36
mkpasswd	26.38 KB	-rwxr-xr-x	2024-04-01 20:14
mksquashfs	286.95 KB	-rwxr-xr-x	2024-04-08 18:20
mktemp	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
mlock	14.15 KB	-rwxr-sr-x	2024-04-01 07:20
more	46.38 KB	-rwxr-xr-x	2024-04-09 16:02
mount	50.38 KB	-rwsr-xr-x	2024-04-09 16:02
mountpoint	18.38 KB	-rwxr-xr-x	2024-04-09 16:02
mpstat	50.45 KB	-rwxr-xr-x	2024-01-09 21:31
mt	70.73 KB	-rwxr-xr-x	2024-04-08 17:55
mt-gnu	70.73 KB	-rwxr-xr-x	2024-04-08 17:55
mtrace	6.37 KB	-rwxr-xr-x	2024-04-30 20:02
mv	134.52 KB	-rwxr-xr-x	2024-04-05 16:36
my_print_defaults	6.3 MB	-rwxr-xr-x	2024-05-09 09:08
myisam_ftdump	6.58 MB	-rwxr-xr-x	2024-05-09 09:08
myisamchk	6.69 MB	-rwxr-xr-x	2024-05-09 09:08
myisamlog	6.53 MB	-rwxr-xr-x	2024-05-09 09:08
myisampack	6.61 MB	-rwxr-xr-x	2024-05-09 09:08
mysql	7.51 MB	-rwxr-xr-x	2024-05-09 09:08
mysql_migrate_keyring	7.24 MB	-rwxr-xr-x	2024-05-09 09:08
mysql_secure_installation	7.15 MB	-rwxr-xr-x	2024-05-09 09:08
mysql_ssl_rsa_setup	6.34 MB	-rwxr-xr-x	2024-05-09 09:08
mysql_tzinfo_to_sql	6.24 MB	-rwxr-xr-x	2024-05-09 09:08
mysql_upgrade	7.27 MB	-rwxr-xr-x	2024-05-09 09:08
mysqladmin	7.17 MB	-rwxr-xr-x	2024-05-09 09:08
mysqlanalyze	7.18 MB	-rwxr-xr-x	2024-05-09 09:08
mysqlbinlog	7.68 MB	-rwxr-xr-x	2024-05-09 09:08
mysqlcheck	7.18 MB	-rwxr-xr-x	2024-05-09 09:08
mysqld_multi	26.85 KB	-rwxr-xr-x	2024-05-09 09:08
mysqld_safe	33.24 KB	-rwxr-xr-x	2024-05-09 09:08
mysqldump	7.26 MB	-rwxr-xr-x	2024-05-09 09:08
mysqldumpslow	1.68 KB	-rwxr-xr-x	2024-05-09 09:08
mysqlimport	7.17 MB	-rwxr-xr-x	2024-05-09 09:08
mysqloptimize	7.18 MB	-rwxr-xr-x	2024-05-09 09:08
mysqlpump	7.77 MB	-rwxr-xr-x	2024-05-09 09:08
mysqlrepair	7.18 MB	-rwxr-xr-x	2024-05-09 09:08
mysqlshow	7.16 MB	-rwxr-xr-x	2024-05-09 09:08
mysqlslap	7.18 MB	-rwxr-xr-x	2024-05-09 09:08
namei	22.38 KB	-rwxr-xr-x	2024-04-09 16:02
nano	272.5 KB	-rwxr-xr-x	2024-04-08 18:13
nawk	722.5 KB	-rwxr-xr-x	2024-03-31 07:33
neqn	913 B	-rwxr-xr-x	2024-03-31 10:54
netaddr	959 B	-rwxr-xr-x	2023-09-21 19:43
netstat	154.59 KB	-rwxr-xr-x	2024-04-08 18:14
networkctl	122.58 KB	-rwxr-xr-x	2024-06-14 23:03
networkd-dispatcher	19.88 KB	-rwxr-xr-x	2023-04-24 17:32
newaliases	30.45 KB	-rwxr-xr-x	2024-04-08 16:48
newgrp	39.71 KB	-rwsr-xr-x	2024-04-09 09:01
ngettext	34.38 KB	-rwxr-xr-x	2024-04-08 17:58
nice	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
nisdomainname	22.23 KB	-rwxr-xr-x	2024-04-08 17:59
nl	38.6 KB	-rwxr-xr-x	2024-04-05 16:36
nm	43.5 KB	-rwxr-xr-x	2024-03-29 20:49
nohup	34.41 KB	-rwxr-xr-x	2024-04-05 16:36
nproc	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
nroff	5.58 KB	-rwxr-xr-x	2024-03-31 10:54
nsenter	30.6 KB	-rwxr-xr-x	2024-04-09 16:02
nstat	30.38 KB	-rwxr-xr-x	2024-03-31 11:00
numfmt	58.54 KB	-rwxr-xr-x	2024-04-05 16:36
nvidia-detector	270 B	-rwxr-xr-x	2024-04-03 11:11
objcopy	166.63 KB	-rwxr-xr-x	2024-03-29 20:49
objdump	389.69 KB	-rwxr-xr-x	2024-03-29 20:49
od	70.51 KB	-rwxr-xr-x	2024-04-05 16:36
oem-getlogs	8.3 KB	-rwxr-xr-x	2024-04-23 13:30
openssl	981.8 KB	-rwxr-xr-x	2024-05-14 11:06
openvt	22.73 KB	-rwxr-xr-x	2024-03-31 11:02
optipng	90.27 KB	-rwxr-xr-x	2024-03-31 11:23
os-prober	4.42 KB	-rwxr-xr-x	2023-03-07 14:24
pager	190.38 KB	-rwxr-xr-x	2024-04-28 13:44
paperconf	14.15 KB	-rwxr-xr-x	2024-04-08 18:06
partx	62.38 KB	-rwxr-xr-x	2024-04-09 16:02
passwd	62.65 KB	-rwsr-xr-x	2024-04-09 09:01
paste	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
patch	182.52 KB	-rwxr-xr-x	2024-04-08 18:15
pathchk	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
pdb3	67.83 KB	-rwxr-xr-x	2024-04-10 07:33
pdb3.12	67.83 KB	-rwxr-xr-x	2024-04-10 07:33
pdf2dsc	698 B	-rwxr-xr-x	2024-07-11 18:07
pdf2ps	909 B	-rwxr-xr-x	2024-07-11 18:07
peekfd	14.3 KB	-rwxr-xr-x	2024-03-31 19:02
perf	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
perl	3.83 MB	-rwxr-xr-x	2024-04-05 21:57
perl5.38-x86_64-linux-gnu	14.3 KB	-rwxr-xr-x	2024-04-05 21:57
perl5.38.2	3.83 MB	-rwxr-xr-x	2024-04-05 21:57
perlbug	44.52 KB	-rwxr-xr-x	2024-04-05 21:57
perldoc	125 B	-rwxr-xr-x	2024-04-05 21:56
perlivp	10.61 KB	-rwxr-xr-x	2024-04-05 21:57
perlthanks	44.52 KB	-rwxr-xr-x	2024-04-05 21:57
perror	7.66 MB	-rwxr-xr-x	2024-05-09 09:08
pf2afm	498 B	-rwxr-xr-x	2024-07-11 18:07
pfbtopfa	516 B	-rwxr-xr-x	2024-07-11 18:07
pgrep	34.47 KB	-rwxr-xr-x	2024-03-31 10:16
phar	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
phar.phar	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
phar.phar7.1	14.47 KB	-rwxr-xr-x	2024-05-09 09:08
phar.phar7.2	14.47 KB	-rwxr-xr-x	2024-05-08 09:08
phar.phar7.3	14.47 KB	-rwxr-xr-x	2024-05-08 09:08
phar.phar7.4	14.54 KB	-rwxr-xr-x	2024-05-08 09:08
phar.phar8.0	15.02 KB	-rwxr-xr-x	2024-05-08 09:08
phar.phar8.1	14.89 KB	-rwxr-xr-x	2024-06-11 09:08
phar.phar8.2	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
phar.phar8.3	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
phar7.1	14.47 KB	-rwxr-xr-x	2024-05-09 09:08
phar7.2	14.47 KB	-rwxr-xr-x	2024-05-08 09:08
phar7.3	14.47 KB	-rwxr-xr-x	2024-05-08 09:08
phar7.4	14.54 KB	-rwxr-xr-x	2024-05-08 09:08
phar7.4.phar	14.54 KB	-rwxr-xr-x	2024-05-08 09:08
phar8.0	15.02 KB	-rwxr-xr-x	2024-05-08 09:08
phar8.0.phar	15.02 KB	-rwxr-xr-x	2024-05-08 09:08
phar8.1	14.89 KB	-rwxr-xr-x	2024-06-11 09:08
phar8.1.phar	14.89 KB	-rwxr-xr-x	2024-06-11 09:08
phar8.2	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
phar8.2.phar	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
phar8.3	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
phar8.3.phar	14.88 KB	-rwxr-xr-x	2024-07-12 09:08
php	5.51 MB	-rwxr-xr-x	2024-07-12 09:08
php7.1	4.42 MB	-rwxr-xr-x	2024-05-09 09:08
php7.2	4.7 MB	-rwxr-xr-x	2024-05-08 09:08
php7.3	4.62 MB	-rwxr-xr-x	2024-05-08 09:08
php7.4	4.62 MB	-rwxr-xr-x	2024-05-08 09:08
php8.0	4.81 MB	-rwxr-xr-x	2024-05-08 09:08
php8.1	5.31 MB	-rwxr-xr-x	2024-06-11 09:08
php8.2	5.42 MB	-rwxr-xr-x	2024-07-12 09:08
php8.3	5.51 MB	-rwxr-xr-x	2024-07-12 09:08
pic	196.06 KB	-rwxr-xr-x	2024-03-31 10:54
pico	272.5 KB	-rwxr-xr-x	2024-04-08 18:13
piconv	8.16 KB	-rwxr-xr-x	2024-04-05 21:57
pidof	26.23 KB	-rwxr-xr-x	2024-04-08 18:20
pidstat	50.45 KB	-rwxr-xr-x	2024-01-09 21:31
pidwait	34.47 KB	-rwxr-xr-x	2024-03-31 10:16
pinentry	58.65 KB	-rwxr-xr-x	2024-03-31 18:59
pinentry-curses	58.65 KB	-rwxr-xr-x	2024-03-31 18:59
ping	87.66 KB	-rwxr-xr-x	2024-04-08 18:00
ping4	87.66 KB	-rwxr-xr-x	2024-04-08 18:00
ping6	87.66 KB	-rwxr-xr-x	2024-04-08 18:00
pinky	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
pkaction	18.3 KB	-rwxr-xr-x	2024-04-03 20:26
pkcheck	22.3 KB	-rwxr-xr-x	2024-04-03 20:26
pkcon	54.3 KB	-rwxr-xr-x	2024-03-31 10:13
pkill	34.47 KB	-rwxr-xr-x	2024-03-31 10:16
pkmon	22.3 KB	-rwxr-xr-x	2024-03-31 10:13
pkttyagent	22.3 KB	-rwxr-xr-x	2024-04-03 20:26
pl2pm	4.43 KB	-rwxr-xr-x	2024-04-05 21:57
pldd	22.44 KB	-rwxr-xr-x	2024-04-30 20:02
plymouth	46.3 KB	-rwxr-xr-x	2024-03-31 10:14
pmap	34.4 KB	-rwxr-xr-x	2024-03-31 10:16
pod2html	3.95 KB	-rwxr-xr-x	2024-04-05 21:57
pod2man	18.46 KB	-rwxr-xr-x	2024-04-05 21:57
pod2text	12.8 KB	-rwxr-xr-x	2024-04-05 21:57
pod2usage	4.01 KB	-rwxr-xr-x	2024-04-05 21:57
podchecker	3.57 KB	-rwxr-xr-x	2024-04-05 21:57
pollinate	8.54 KB	-rwxr-xr-x	2018-05-29 22:13
pphs	404 B	-rwxr-xr-x	2024-07-11 18:07
pr	70.58 KB	-rwxr-xr-x	2024-04-05 16:36
preconv	58.48 KB	-rwxr-xr-x	2024-03-31 10:54
printafm	395 B	-rwxr-xr-x	2024-07-11 18:07
printenv	34.38 KB	-rwxr-xr-x	2024-04-05 16:36
printf	54.44 KB	-rwxr-xr-x	2024-04-05 16:36
prlimit	26.89 KB	-rwxr-xr-x	2024-04-09 16:02
prove	13.34 KB	-rwxr-xr-x	2024-04-05 21:57
prtstat	18.38 KB	-rwxr-xr-x	2024-03-31 19:02
ps	142.99 KB	-rwxr-xr-x	2024-03-31 10:16
ps-admin	16.15 KB	-rwxr-xr-x	2024-05-09 09:08
ps2ascii	631 B	-rwxr-xr-x	2024-07-11 18:07
ps2epsi	1.23 KB	-rwxr-xr-x	2024-07-11 18:07
ps2pdf	272 B	-rwxr-xr-x	2024-07-11 18:07
ps2pdf12	215 B	-rwxr-xr-x	2024-07-11 18:07
ps2pdf13	215 B	-rwxr-xr-x	2024-07-11 18:07
ps2pdf14	215 B	-rwxr-xr-x	2024-07-11 18:07
ps2pdfwr	1.05 KB	-rwxr-xr-x	2024-07-11 18:07
ps2ps	647 B	-rwxr-xr-x	2024-07-11 18:07
ps2ps2	669 B	-rwxr-xr-x	2024-07-11 18:07
ps2txt	631 B	-rwxr-xr-x	2024-07-11 18:07
ps_mysqld_helper	1.55 KB	-rwxr-xr-x	2024-05-09 09:08
psfaddtable	22.37 KB	-rwxr-xr-x	2024-03-31 11:02
psfgettable	22.37 KB	-rwxr-xr-x	2024-03-31 11:02
psfstriptable	22.37 KB	-rwxr-xr-x	2024-03-31 11:02
psfxtable	22.37 KB	-rwxr-xr-x	2024-03-31 11:02
pslog	14.3 KB	-rwxr-xr-x	2024-03-31 19:02
pstree	35.32 KB	-rwxr-xr-x	2024-03-31 19:02
pstree.x11	35.32 KB	-rwxr-xr-x	2024-03-31 19:02
ptar	3.48 KB	-rwxr-xr-x	2024-04-05 21:57
ptardiff	2.58 KB	-rwxr-xr-x	2024-04-05 21:57
ptargrep	4.29 KB	-rwxr-xr-x	2024-04-05 21:57
ptx	54.54 KB	-rwxr-xr-x	2024-04-05 16:36
pwd	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
pwdx	14.38 KB	-rwxr-xr-x	2024-03-31 10:16
pwgen	34.77 KB	-rwxr-xr-x	2024-04-18 20:03
py3clean	7.63 KB	-rwxr-xr-x	2024-04-12 15:29
py3compile	13 KB	-rwxr-xr-x	2024-04-12 15:29
py3versions	12.52 KB	-rwxr-xr-x	2024-04-12 15:29
pybabel	956 B	-rwxr-xr-x	2023-11-24 11:19
pybabel-python3	956 B	-rwxr-xr-x	2023-11-24 11:19
pydoc3	80 B	-rwxr-xr-x	2024-04-10 07:33
pydoc3.12	80 B	-rwxr-xr-x	2024-04-10 07:33
pygettext3	23.66 KB	-rwxr-xr-x	2024-04-10 07:33
pygettext3.12	23.66 KB	-rwxr-xr-x	2024-04-10 07:33
pygmentize	215 B	-rwxr-xr-x	2024-02-02 14:26
pyserial-miniterm	975 B	-rwxr-xr-x	2023-11-24 11:38
pyserial-ports	969 B	-rwxr-xr-x	2023-11-24 11:38
python3	7.65 MB	-rwxr-xr-x	2024-04-10 07:33
python3.12	7.65 MB	-rwxr-xr-x	2024-04-10 07:33
pzstd	686.54 KB	-rwxr-xr-x	2024-04-08 18:10
quirks-handler	2.4 KB	-rwxr-xr-x	2024-04-03 11:11
ranlib	54.48 KB	-rwxr-xr-x	2024-03-29 20:49
rbash	1.38 MB	-rwxr-xr-x	2024-03-31 10:41
rclone	55.55 MB	-rwxr-xr-x	2024-07-15 07:34
rdebsums	2.61 KB	-rwxr-xr-x	2016-05-09 17:04
rdma	102.52 KB	-rwxr-xr-x	2024-03-31 11:00
readelf	770.78 KB	-rwxr-xr-x	2024-03-29 20:49
readlink	42.41 KB	-rwxr-xr-x	2024-04-05 16:36
realpath	42.41 KB	-rwxr-xr-x	2024-04-05 16:36
redis-benchmark	750.7 KB	-rwxr-xr-x	2024-04-01 09:33
redis-check-aof	2.5 MB	-rwxr-xr-x	2024-04-01 09:33
redis-check-rdb	2.5 MB	-rwxr-xr-x	2024-04-01 09:33
redis-cli	386.45 KB	-rwxr-xr-x	2024-04-01 09:33
redis-server	2.5 MB	-rwxr-xr-x	2024-04-01 09:33
rename.ul	22.38 KB	-rwxr-xr-x	2024-04-09 16:02
renice	14.38 KB	-rwxr-xr-x	2024-04-09 16:02
rescan-scsi-bus.sh	38.05 KB	-rwxr-xr-x	2024-04-08 18:19
reset	26.31 KB	-rwxr-xr-x	2024-04-08 18:14
resizecons	26.46 KB	-rwxr-xr-x	2024-03-31 11:02
resizepart	22.38 KB	-rwxr-xr-x	2024-04-09 16:02
resolvectl	158.67 KB	-rwxr-xr-x	2024-06-14 23:03
rev	14.38 KB	-rwxr-xr-x	2024-04-09 16:02
rgrep	30 B	-rwxr-xr-x	2023-07-21 16:47
rm	58.51 KB	-rwxr-xr-x	2024-04-05 16:36
rmail	18.38 KB	-rwxr-xr-x	2024-04-08 16:48
rmdir	46.41 KB	-rwxr-xr-x	2024-04-05 16:36
rnano	272.5 KB	-rwxr-xr-x	2024-04-08 18:13
rotatelogs	26.38 KB	-rwxr-xr-x	2024-07-17 20:55
routel	1.62 KB	-rwxr-xr-x	2024-03-31 11:00
rpcgen	94.59 KB	-rwxr-xr-x	2024-04-08 18:18
rrsync	12.34 KB	-rwxr-xr-x	2024-04-12 19:09
rsync	502.13 KB	-rwxr-xr-x	2024-04-12 19:09
rsync-ssl	5.02 KB	-rwxr-xr-x	2024-04-12 19:09
rtla	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
rtstat	22.66 KB	-rwxr-xr-x	2024-03-31 11:00
run-parts	26.82 KB	-rwxr-xr-x	2024-03-31 10:47
runcon	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
rview	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
rvim	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
sadf	382.31 KB	-rwxr-xr-x	2024-01-09 21:31
sar	137.38 KB	-rwxr-xr-x	2024-01-09 21:31
sar.sysstat	137.38 KB	-rwxr-xr-x	2024-01-09 21:31
savelog	10.24 KB	-rwxr-xr-x	2024-03-31 10:47
scalar	668.94 KB	-rwxr-xr-x	2024-05-20 13:15
scandeps	6.47 KB	-rwxr-xr-x	2023-11-10 00:40
scp	134.59 KB	-rwxr-xr-x	2024-07-09 13:31
screen	478.24 KB	-rwxr-xr-x	2024-04-08 18:18
screendump	14.3 KB	-rwxr-xr-x	2024-03-31 11:02
script	54.38 KB	-rwxr-xr-x	2024-04-09 16:02
scriptlive	42.38 KB	-rwxr-xr-x	2024-04-09 16:02
scriptreplay	34.38 KB	-rwxr-xr-x	2024-04-09 16:02
scsi_logging_level	8.38 KB	-rwxr-xr-x	2024-04-08 18:19
scsi_mandat	3.52 KB	-rwxr-xr-x	2024-04-08 18:19
scsi_readcap	1.3 KB	-rwxr-xr-x	2024-04-08 18:19
scsi_ready	1.09 KB	-rwxr-xr-x	2024-04-08 18:19
scsi_satl	3.74 KB	-rwxr-xr-x	2024-04-08 18:19
scsi_start	1.25 KB	-rwxr-xr-x	2024-04-08 18:19
scsi_stop	1.44 KB	-rwxr-xr-x	2024-04-08 18:19
scsi_temperature	936 B	-rwxr-xr-x	2024-04-08 18:19
sdiff	50.39 KB	-rwxr-xr-x	2024-04-08 17:55
sed	110.57 KB	-rwxr-xr-x	2024-04-08 18:19
select-editor	2.39 KB	-rwxr-xr-x	2024-02-04 19:05
sensible-browser	1.55 KB	-rwxr-xr-x	2024-02-04 19:05
sensible-editor	1.52 KB	-rwxr-xr-x	2024-02-04 19:05
sensible-pager	921 B	-rwxr-xr-x	2024-02-04 19:05
sensible-terminal	1.15 KB	-rwxr-xr-x	2024-02-04 19:05
seq	50.51 KB	-rwxr-xr-x	2024-04-05 16:36
setarch	26.65 KB	-rwxr-xr-x	2024-04-09 16:02
setfont	54.46 KB	-rwxr-xr-x	2024-03-31 11:02
setkeycodes	14.37 KB	-rwxr-xr-x	2024-03-31 11:02
setleds	18.43 KB	-rwxr-xr-x	2024-03-31 11:02
setlogcons	14.37 KB	-rwxr-xr-x	2024-03-31 11:02
setmetamode	14.41 KB	-rwxr-xr-x	2024-03-31 11:02
setpci	30.38 KB	-rwxr-xr-x	2024-04-08 18:15
setpriv	38.38 KB	-rwxr-xr-x	2024-04-09 16:02
setsid	14.38 KB	-rwxr-xr-x	2024-04-09 16:02
setterm	34.38 KB	-rwxr-xr-x	2024-04-09 16:02
setupcon	40.06 KB	-rwxr-xr-x	2024-02-26 13:58
sftp	150.66 KB	-rwxr-xr-x	2024-07-09 13:31
sg	39.71 KB	-rwsr-xr-x	2024-04-09 09:01
sg_bg_ctl	14.51 KB	-rwxr-xr-x	2024-04-08 18:19
sg_compare_and_write	26.91 KB	-rwxr-xr-x	2024-04-08 18:19
sg_copy_results	23.3 KB	-rwxr-xr-x	2024-04-08 18:19
sg_dd	54.33 KB	-rwxr-xr-x	2024-04-08 18:19
sg_decode_sense	14.76 KB	-rwxr-xr-x	2024-04-08 18:19
sg_emc_trespass	14.3 KB	-rwxr-xr-x	2024-04-08 18:19
sg_format	39.35 KB	-rwxr-xr-x	2024-04-08 18:19
sg_get_config	35.38 KB	-rwxr-xr-x	2024-04-08 18:19
sg_get_elem_status	26.79 KB	-rwxr-xr-x	2024-04-08 18:19
sg_get_lba_status	22.95 KB	-rwxr-xr-x	2024-04-08 18:19
sg_ident	14.6 KB	-rwxr-xr-x	2024-04-08 18:19
sg_inq	115.61 KB	-rwxr-xr-x	2024-04-08 18:19
sg_logs	146.93 KB	-rwxr-xr-x	2024-04-08 18:19
sg_luns	22.79 KB	-rwxr-xr-x	2024-04-08 18:19
sg_map	18.3 KB	-rwxr-xr-x	2024-04-08 18:19
sg_map26	26.7 KB	-rwxr-xr-x	2024-04-08 18:19
sg_modes	46.08 KB	-rwxr-xr-x	2024-04-08 18:19
sg_opcodes	35.01 KB	-rwxr-xr-x	2024-04-08 18:19
sg_persist	36.08 KB	-rwxr-xr-x	2024-04-08 18:19
sg_prevent	14.51 KB	-rwxr-xr-x	2024-04-08 18:19
sg_raw	26.91 KB	-rwxr-xr-x	2024-04-08 18:19
sg_rbuf	22.73 KB	-rwxr-xr-x	2024-04-08 18:19
sg_rdac	18.3 KB	-rwxr-xr-x	2024-04-08 18:19
sg_read	26.31 KB	-rwxr-xr-x	2024-04-08 18:19
sg_read_attr	36.65 KB	-rwxr-xr-x	2024-04-08 18:19
sg_read_block_limits	14.54 KB	-rwxr-xr-x	2024-04-08 18:19
sg_read_buffer	27.56 KB	-rwxr-xr-x	2024-04-08 18:19
sg_read_long	14.7 KB	-rwxr-xr-x	2024-04-08 18:19
sg_readcap	22.79 KB	-rwxr-xr-x	2024-04-08 18:19
sg_reassign	18.66 KB	-rwxr-xr-x	2024-04-08 18:19
sg_referrals	14.66 KB	-rwxr-xr-x	2024-04-08 18:19
sg_rep_pip	14.57 KB	-rwxr-xr-x	2024-04-08 18:19
sg_rep_zones	26.8 KB	-rwxr-xr-x	2024-04-08 18:19
sg_requests	22.76 KB	-rwxr-xr-x	2024-04-08 18:19
sg_reset	14.66 KB	-rwxr-xr-x	2024-04-08 18:19
sg_reset_wp	14.6 KB	-rwxr-xr-x	2024-04-08 18:19
sg_rmsn	14.51 KB	-rwxr-xr-x	2024-04-08 18:19
sg_rtpg	14.6 KB	-rwxr-xr-x	2024-04-08 18:19
sg_safte	22.7 KB	-rwxr-xr-x	2024-04-08 18:19
sg_sanitize	27.01 KB	-rwxr-xr-x	2024-04-08 18:19
sg_sat_identify	18.73 KB	-rwxr-xr-x	2024-04-08 18:19
sg_sat_phy_event	19.01 KB	-rwxr-xr-x	2024-04-08 18:19
sg_sat_read_gplog	18.73 KB	-rwxr-xr-x	2024-04-08 18:19
sg_sat_set_features	18.7 KB	-rwxr-xr-x	2024-04-08 18:19
sg_scan	18.38 KB	-rwxr-xr-x	2024-04-08 18:19
sg_seek	18.88 KB	-rwxr-xr-x	2024-04-08 18:19
sg_senddiag	27.2 KB	-rwxr-xr-x	2024-04-08 18:19
sg_ses	119.97 KB	-rwxr-xr-x	2024-04-08 18:19
sg_ses_microcode	27.36 KB	-rwxr-xr-x	2024-04-08 18:19
sg_start	18.85 KB	-rwxr-xr-x	2024-04-08 18:19
sg_stpg	22.73 KB	-rwxr-xr-x	2024-04-08 18:19
sg_stream_ctl	18.7 KB	-rwxr-xr-x	2024-04-08 18:19
sg_sync	14.66 KB	-rwxr-xr-x	2024-04-08 18:19
sg_test_rwbuf	18.6 KB	-rwxr-xr-x	2024-04-08 18:19
sg_timestamp	22.83 KB	-rwxr-xr-x	2024-04-08 18:19
sg_turs	26.7 KB	-rwxr-xr-x	2024-04-08 18:19
sg_unmap	22.76 KB	-rwxr-xr-x	2024-04-08 18:19
sg_verify	22.91 KB	-rwxr-xr-x	2024-04-08 18:19
sg_vpd	118.42 KB	-rwxr-xr-x	2024-04-08 18:19
sg_wr_mode	22.73 KB	-rwxr-xr-x	2024-04-08 18:19
sg_write_buffer	27.23 KB	-rwxr-xr-x	2024-04-08 18:19
sg_write_long	14.76 KB	-rwxr-xr-x	2024-04-08 18:19
sg_write_same	26.95 KB	-rwxr-xr-x	2024-04-08 18:19
sg_write_verify	26.79 KB	-rwxr-xr-x	2024-04-08 18:19
sg_write_x	55.6 KB	-rwxr-xr-x	2024-04-08 18:19
sg_xcopy	42.32 KB	-rwxr-xr-x	2024-04-08 18:19
sg_zone	14.86 KB	-rwxr-xr-x	2024-04-08 18:19
sginfo	76.01 KB	-rwxr-xr-x	2024-04-08 18:19
sgm_dd	34.31 KB	-rwxr-xr-x	2024-04-08 18:19
sgp_dd	46.31 KB	-rwxr-xr-x	2024-04-08 18:19
sh	126.74 KB	-rwxr-xr-x	2024-03-31 10:47
sha1sum	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
sha224sum	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
sha256sum	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
sha384sum	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
sha512sum	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
shasum	9.75 KB	-rwxr-xr-x	2024-04-05 21:57
showconsolefont	18.37 KB	-rwxr-xr-x	2024-03-31 11:02
showkey	18.37 KB	-rwxr-xr-x	2024-03-31 11:02
shred	54.51 KB	-rwxr-xr-x	2024-04-05 16:36
shuf	46.51 KB	-rwxr-xr-x	2024-04-05 16:36
size	30.45 KB	-rwxr-xr-x	2024-03-29 20:49
skill	26.41 KB	-rwxr-xr-x	2024-03-31 10:16
slabtop	22.44 KB	-rwxr-xr-x	2024-03-31 10:16
sleep	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
slogin	827.04 KB	-rwxr-xr-x	2024-07-09 13:31
snap	17.32 MB	-rwxr-xr-x	2024-04-24 02:00
snapctl	6.65 MB	-rwxr-xr-x	2024-04-24 02:00
snapfuse	38.23 KB	-rwxr-xr-x	2024-04-24 02:00
snice	26.41 KB	-rwxr-xr-x	2024-03-31 10:16
soelim	34.48 KB	-rwxr-xr-x	2024-03-31 10:54
sort	102.8 KB	-rwxr-xr-x	2024-04-05 16:36
sotruss	4.21 KB	-rwxr-xr-x	2024-04-30 20:02
splain	18.99 KB	-rwxr-xr-x	2024-04-05 21:57
split	54.94 KB	-rwxr-xr-x	2024-04-05 16:36
splitfont	14.3 KB	-rwxr-xr-x	2024-03-31 11:02
sprof	34.44 KB	-rwxr-xr-x	2024-04-30 20:02
sqfscat	147.9 KB	-rwxr-xr-x	2024-04-08 18:20
sqfstar	286.95 KB	-rwxr-xr-x	2024-04-08 18:20
sqlite3	320.19 KB	-rwxr-xr-x	2024-03-31 10:24
ss	129.07 KB	-rwxr-xr-x	2024-03-31 11:00
ssh	827.04 KB	-rwxr-xr-x	2024-07-09 13:31
ssh-add	294.42 KB	-rwxr-xr-x	2024-07-09 13:31
ssh-agent	302.43 KB	-rwxr-sr-x	2024-07-09 13:31
ssh-argv0	1.42 KB	-rwxr-xr-x	2024-04-04 00:09
ssh-copy-id	12.77 KB	-rwxr-xr-x	2023-12-18 15:59
ssh-import-id	985 B	-rwxr-xr-x	2024-02-28 17:19
ssh-import-id-gh	785 B	-rwxr-xr-x	2020-12-07 20:19
ssh-import-id-lp	785 B	-rwxr-xr-x	2020-12-07 20:19
ssh-keygen	442.44 KB	-rwxr-xr-x	2024-07-09 13:31
ssh-keyscan	330.44 KB	-rwxr-xr-x	2024-07-09 13:31
stat	86.52 KB	-rwxr-xr-x	2024-04-05 16:36
stdbuf	50.51 KB	-rwxr-xr-x	2024-04-05 16:36
streamzip	7.87 KB	-rwxr-xr-x	2024-04-05 21:57
strings	30.61 KB	-rwxr-xr-x	2024-03-29 20:49
strip	166.66 KB	-rwxr-xr-x	2024-03-29 20:49
stty	78.52 KB	-rwxr-xr-x	2024-04-05 16:36
su	54.38 KB	-rwsr-xr--	2024-04-09 16:02
sudo	271.42 KB	-rwsr-xr-x	2024-04-08 16:50
sudoedit	271.42 KB	-rwsr-xr-x	2024-04-08 16:50
sudoreplay	95.95 KB	-rwxr-xr-x	2024-04-08 16:50
sum	34.41 KB	-rwxr-xr-x	2024-04-05 16:36
sync	34.41 KB	-rwxr-xr-x	2024-04-05 16:36
systemctl	1.43 MB	-rwxr-xr-x	2024-06-14 23:03
systemd	98.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-ac-power	14.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-analyze	198.85 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-ask-password	18.58 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-cat	18.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-cgls	22.57 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-cgtop	38.47 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-confext	54.64 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-creds	42.72 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-cryptenroll	70.92 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-cryptsetup	78.95 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-delta	26.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-detect-virt	18.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-escape	22.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-firstboot	58.82 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-hwdb	154.74 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-id128	22.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-inhibit	22.47 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-machine-id-setup	18.63 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-mount	50.78 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-notify	26.66 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-path	18.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-repart	195.23 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-run	66.79 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-socket-activate	30.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-stdio-bridge	22.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-sysext	54.64 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-sysusers	66.63 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-tmpfiles	114.7 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-tty-ask-password-agent	34.45 KB	-rwxr-xr-x	2024-06-14 23:03
systemd-umount	50.78 KB	-rwxr-xr-x	2024-06-14 23:03
tabs	18.3 KB	-rwxr-xr-x	2024-04-08 18:14
tac	38.41 KB	-rwxr-xr-x	2024-04-05 16:36
tail	62.53 KB	-rwxr-xr-x	2024-04-05 16:36
tapestat	26.44 KB	-rwxr-xr-x	2024-01-09 21:31
tar	421.92 KB	-rwxr-xr-x	2024-04-08 18:20
taskset	30.38 KB	-rwxr-xr-x	2024-04-09 16:02
tbl	134.48 KB	-rwxr-xr-x	2024-03-31 10:54
tcpdump	1.21 MB	-rwxr-xr-x	2024-04-08 16:50
tee	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
telnet	177.85 KB	-rwxr-xr-x	2024-03-31 01:08
tempfile	14.3 KB	-rwxr-xr-x	2024-03-31 10:47
test	46.44 KB	-rwxr-xr-x	2024-04-05 16:36
tic	90.41 KB	-rwxr-xr-x	2024-04-08 18:14
timedatectl	46.45 KB	-rwxr-xr-x	2024-06-14 23:03
timeout	38.95 KB	-rwxr-xr-x	2024-04-05 16:36
tload	22.39 KB	-rwxr-xr-x	2024-03-31 10:16
toe	22.3 KB	-rwxr-xr-x	2024-04-08 18:14
top	131.7 KB	-rwxr-xr-x	2024-03-31 10:16
touch	94.51 KB	-rwxr-xr-x	2024-04-05 16:36
tput	26.34 KB	-rwxr-xr-x	2024-04-08 18:14
tr	46.51 KB	-rwxr-xr-x	2024-04-05 16:36
troff	726.62 KB	-rwxr-xr-x	2024-03-31 10:54
true	26.3 KB	-rwxr-xr-x	2024-04-05 16:36
truncate	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
tset	26.31 KB	-rwxr-xr-x	2024-04-08 18:14
tsort	46.51 KB	-rwxr-xr-x	2024-04-05 16:36
tty	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
turbostat	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
tzselect	15.02 KB	-rwxr-xr-x	2024-04-30 20:02
ubuntu-bug	2.27 KB	-rwxr-xr-x	2024-04-18 14:31
ubuntu-core-launcher	151.2 KB	-rwsr-xr-x	2024-04-24 02:00
ubuntu-drivers	16.64 KB	-rwxr-xr-x	2024-04-03 11:11
ucf	40.68 KB	-rwxr-xr-x	2023-01-27 14:29
ucfq	18.91 KB	-rwxr-xr-x	2023-01-27 14:29
ucfr	10.85 KB	-rwxr-xr-x	2023-01-27 14:29
uclampset	30.38 KB	-rwxr-xr-x	2024-04-09 16:02
ucs2any	26.15 KB	-rwxr-xr-x	2024-04-08 18:22
udevadm	1.37 MB	-rwxr-xr-x	2024-06-14 23:03
umount	38.38 KB	-rwsr-xr-x	2024-04-09 16:02
uname	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
unattended-upgrade	97.21 KB	-rwxr-xr-x	2024-02-12 18:50
unattended-upgrades	97.21 KB	-rwxr-xr-x	2024-02-12 18:50
uncompress	2.29 KB	-rwxr-xr-x	2024-04-08 17:58
unexpand	38.53 KB	-rwxr-xr-x	2024-04-05 16:36
unicode_start	2.71 KB	-rwxr-xr-x	2024-03-31 11:02
unicode_stop	528 B	-rwxr-xr-x	2024-03-31 11:02
uniq	38.51 KB	-rwxr-xr-x	2024-04-05 16:36
unlink	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
unlzma	86.92 KB	-rwxr-xr-x	2024-03-28 15:59
unmkinitramfs	3.7 KB	-rwxr-xr-x	2024-05-06 14:55
unshare	42.6 KB	-rwxr-xr-x	2024-04-09 16:02
unsquashfs	147.9 KB	-rwxr-xr-x	2024-04-08 18:20
unxz	86.92 KB	-rwxr-xr-x	2024-03-28 15:59
unzip	174.42 KB	-rwxr-xr-x	2024-04-08 18:21
unzipsfx	74.42 KB	-rwxr-xr-x	2024-04-08 18:21
unzstd	998.79 KB	-rwxr-xr-x	2024-04-08 18:10
update-alternatives	58.38 KB	-rwxr-xr-x	2024-03-31 00:51
update-mime-database	74.33 KB	-rwxr-xr-x	2024-04-01 13:58
upower	14.3 KB	-rwxr-xr-x	2024-04-08 09:42
uptime	14.38 KB	-rwxr-xr-x	2024-03-31 10:16
usb-devices	4.83 KB	-rwxr-xr-x	2024-04-08 18:21
usbhid-dump	30.38 KB	-rwxr-xr-x	2024-04-08 18:21
usbip	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
usbipd	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
usbreset	14.3 KB	-rwxr-xr-x	2024-04-08 18:21
users	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
utmpdump	22.38 KB	-rwxr-xr-x	2024-04-09 16:02
uuid	18.02 KB	-rwxr-xr-x	2024-04-01 07:10
uwsgi	945.65 KB	-rwxr-xr-x	2024-04-17 18:23
uwsgi-core	945.65 KB	-rwxr-xr-x	2024-04-17 18:23
uwsgi_python3	945.65 KB	-rwxr-xr-x	2024-04-17 18:23
uwsgi_python312	945.65 KB	-rwxr-xr-x	2024-04-17 18:23
varlinkctl	30.45 KB	-rwxr-xr-x	2024-06-14 23:03
varnishadm	169.15 KB	-rwxr-xr-x	2024-05-09 12:06
varnishhist	71.89 KB	-rwxr-xr-x	2024-05-09 12:06
varnishlog	40.34 KB	-rwxr-xr-x	2024-05-09 12:06
varnishncsa	104.67 KB	-rwxr-xr-x	2024-05-09 12:06
varnishstat	112.4 KB	-rwxr-xr-x	2024-05-09 12:06
varnishstat_help_gen	51.76 KB	-rwxr-xr-x	2024-05-09 12:06
varnishstatdiff	4.58 KB	-rwxr-xr-x	2024-05-09 12:06
varnishtest	1.54 MB	-rwxr-xr-x	2024-05-09 12:06
varnishtop	70.63 KB	-rwxr-xr-x	2024-05-09 12:06
vcs-run	6.75 KB	-rwxr-xr-x	2022-06-03 12:51
vdir	138.98 KB	-rwxr-xr-x	2024-04-05 16:36
vi	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
view	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
vim	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
vim.basic	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
vimdiff	3.94 MB	-rwxr-xr-x	2024-05-03 04:45
vimtutor	2.1 KB	-rwxr-xr-x	2024-05-03 04:45
vmstat	38.78 KB	-rwxr-xr-x	2024-03-31 10:16
vpsresize	261 B	-rwxr-xr-x	2024-05-08 23:22
w	26.38 KB	-rwxr-xr-x	2024-03-31 10:16
wall	22.38 KB	-rwxr-xr-x	2024-04-09 16:02
watch	30.84 KB	-rwxr-xr-x	2024-03-31 10:16
watchgnupg	22.3 KB	-rwxr-xr-x	2024-04-06 18:25
wc	54.52 KB	-rwxr-xr-x	2024-04-05 16:36
wdctl	34.4 KB	-rwxr-xr-x	2024-04-09 16:02
wget	459.02 KB	-rwxr-xr-x	2024-06-19 14:14
whereis	30.84 KB	-rwxr-xr-x	2024-04-09 16:02
which	1.05 KB	-rwxr-xr-x	2024-03-31 10:47
which.debianutils	1.05 KB	-rwxr-xr-x	2024-03-31 10:47
who	58.52 KB	-rwxr-xr-x	2024-04-05 16:36
whoami	34.51 KB	-rwxr-xr-x	2024-04-05 16:36
whois	155.66 KB	-rwxr-xr-x	2024-04-01 20:14
wp	6.19 MB	-rwxr-xr-x	2024-05-28 10:08
x86_64	26.65 KB	-rwxr-xr-x	2024-04-09 16:02
x86_64-linux-gnu-addr2line	30.7 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-ar	54.48 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-as	728.29 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-c++filt	22.27 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-cpp	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-cpp-13	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-dwp	1.87 MB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-elfedit	34.72 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-g++	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-g++-13	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc-13	1.68 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc-ar	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc-ar-13	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc-nm	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc-nm-13	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc-ranlib	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcc-ranlib-13	34.62 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcov	1.06 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcov-13	1.06 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcov-dump	992.3 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcov-dump-13	992.3 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcov-tool	948.3 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gcov-tool-13	948.3 KB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-gold	3.08 MB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-gp-archive	158.53 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-gp-collect-app	174.37 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-gp-display-html	626.89 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-gp-display-src	150.35 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-gp-display-text	286.37 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-gprof	99.79 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-gprofng	138.35 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-ld	1.3 MB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-ld.bfd	1.3 MB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-ld.gold	3.08 MB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-lto-dump	31.31 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-lto-dump-13	31.31 MB	-rwxr-xr-x	2024-04-14 09:31
x86_64-linux-gnu-nm	43.5 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-objcopy	166.63 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-objdump	389.69 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-ranlib	54.48 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-readelf	770.78 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-size	30.45 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-strings	30.61 KB	-rwxr-xr-x	2024-03-29 20:49
x86_64-linux-gnu-strip	166.66 KB	-rwxr-xr-x	2024-03-29 20:49
x86_energy_perf_policy	1.58 KB	-rwxr-xr-x	2024-07-05 17:04
xargs	62.41 KB	-rwxr-xr-x	2024-04-08 17:57
xauth	54.96 KB	-rwxr-xr-x	2024-04-08 18:22
xdg-user-dir	234 B	-rwxr-xr-x	2024-04-08 18:22
xdg-user-dirs-update	26.23 KB	-rwxr-xr-x	2024-04-08 18:22
xsubpp	5.05 KB	-rwxr-xr-x	2024-04-05 21:57
xxd	22.28 KB	-rwxr-xr-x	2024-05-03 04:45
xz	86.92 KB	-rwxr-xr-x	2024-03-28 15:59
xzcat	86.92 KB	-rwxr-xr-x	2024-03-28 15:59
xzcmp	7.25 KB	-rwxr-xr-x	2024-03-28 15:59
xzdiff	7.25 KB	-rwxr-xr-x	2024-03-28 15:59
xzegrep	10.09 KB	-rwxr-xr-x	2024-03-28 15:59
xzfgrep	10.09 KB	-rwxr-xr-x	2024-03-28 15:59
xzgrep	10.09 KB	-rwxr-xr-x	2024-03-28 15:59
xzless	1.77 KB	-rwxr-xr-x	2024-03-28 15:59
xzmore	2.14 KB	-rwxr-xr-x	2024-03-28 15:59
yes	34.38 KB	-rwxr-xr-x	2024-04-05 16:36
ypdomainname	22.23 KB	-rwxr-xr-x	2024-04-08 17:59
zcat	1.94 KB	-rwxr-xr-x	2024-04-08 17:58
zcmp	1.64 KB	-rwxr-xr-x	2024-04-08 17:58
zdiff	6.31 KB	-rwxr-xr-x	2024-04-08 17:58
zdump	30.28 KB	-rwxr-xr-x	2024-04-30 20:02
zegrep	29 B	-rwxr-xr-x	2024-04-08 17:58
zfgrep	29 B	-rwxr-xr-x	2024-04-08 17:58
zforce	2.03 KB	-rwxr-xr-x	2024-04-08 17:58
zgrep	7.91 KB	-rwxr-xr-x	2024-04-08 17:58
zip	206.98 KB	-rwxr-xr-x	2024-04-08 18:24
zipcloak	70.4 KB	-rwxr-xr-x	2024-04-08 18:24
zipdetails	68.55 KB	-rwxr-xr-x	2024-04-05 21:57
zipgrep	2.89 KB	-rwxr-xr-x	2024-04-08 18:21
zipinfo	174.42 KB	-rwxr-xr-x	2024-04-08 18:21
zipnote	62.4 KB	-rwxr-xr-x	2024-04-08 18:24
zipsplit	58.4 KB	-rwxr-xr-x	2024-04-08 18:24
zless	2.15 KB	-rwxr-xr-x	2024-04-08 17:58
zlib_decompress	6.26 MB	-rwxr-xr-x	2024-05-09 09:08
zmore	1.8 KB	-rwxr-xr-x	2024-04-08 17:58
znew	4.47 KB	-rwxr-xr-x	2024-04-08 17:58
zstd	998.79 KB	-rwxr-xr-x	2024-04-08 18:10
zstdcat	998.79 KB	-rwxr-xr-x	2024-04-08 18:10
zstdgrep	3.78 KB	-rwxr-xr-x	2024-04-08 18:10
zstdless	197 B	-rwxr-xr-x	2024-04-08 18:10
zstdmt	998.79 KB	-rwxr-xr-x	2024-04-08 18:10

Rename

#!/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))