#!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# Copyright 2011-2022 Univention GmbH
#
# https://www.univention.de/
#
# All rights reserved.
#
# The source code of this program is made available
# under the terms of the GNU Affero General Public License version 3
# (GNU AGPL V3) as published by the Free Software Foundation.
#
# Binary versions of this program provided by Univention to you as
# well as other copyrighted, protected or trademarked materials like
# Logos, graphics, fonts, specific documentations and configurations,
# cryptographic keys etc. are subject to a license agreement between
# you and Univention and not subject to the GNU AGPL V3.
#
# In the case you use this program under the terms of the GNU AGPL V3,
# the program is provided 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 Affero General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public
# License with the Debian GNU/Linux or Univention distribution in file
# /usr/share/common-licenses/AGPL-3; if not, see
# .
"""
collects information about the system's configuration.
The information is stored in a temporary tar archive, the path of which is printed to stdout.
"""
from __future__ import absolute_import, print_function, unicode_literals
import argparse
import glob
import gzip
import logging
import os
import re
import shutil
import socket
import stat
import struct
import subprocess
import sys
import tarfile
import tempfile
import threading
import time
import warnings
from contextlib import contextmanager
from io import BytesIO, StringIO
from os.path import join
from pipes import quote
try:
from typing import IO, Dict, Iterator, Optional, Sequence, Tuple, Union, cast # noqa: F401
except ImportError:
def cast(typ, val): # type: ignore
return val
try:
from urllib.error import URLError
from urllib.request import urlopen
except ImportError:
from urllib2 import URLError, urlopen # type: ignore
from univention.config_registry import ConfigRegistry
# ignore apt's "API not stable yet" warning
warnings.filterwarnings("ignore", category=FutureWarning, append=True)
import apt # noqa: E402
usiVersion = '68'
logger = logging.getLogger('USI_DEBUG')
ucr = ConfigRegistry()
ucr.load()
timeString = time.strftime('%Y-%m-%d_%H-%M-%SZ', time.gmtime())
hostname = socket.gethostname()
try:
ucsrel = tuple(int(v) for v in ("%(version/version)s.%(version/patchlevel)s" % ucr).split("."))
except (LookupError, ValueError) as ex:
logger.critical("Invalid UCS version in UCR: %s", ex)
ucsrel = (0, 0, 0)
usilog = StringIO()
sambaDomainVersion = 0
env = {} # type: Dict[str, str]
class Command(object):
def __init__(self, cmd, stdin):
# type: (Sequence[str], Optional[bytes]) -> None
self.cmd = cmd
self.stdin = stdin
self.process = None # type: Optional[subprocess.Popen[bytes]]
self.stdout = ""
self.stderr = ""
def run(self, timeout):
# type: (int) -> Tuple[int, str, str]
def target():
# type: () -> None
try:
self.process = subprocess.Popen(self.cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE, stderr=subprocess.PIPE, close_fds=True, env=env)
stdout, stderr = self.process.communicate(input=self.stdin)
self.stdout, self.stderr = stdout.decode("UTF-8", "replace"), stderr.decode("UTF-8", "replace")
except EnvironmentError as ex:
self.stdout = "Could not execute %s: %r" % (qsh(self.cmd), ' '.join(map(str, ex.args)))
thread = threading.Thread(target=target)
thread.start()
thread.join(timeout)
if thread.is_alive():
assert self.process
self.process.terminate()
thread.join()
if self.process:
return (self.process.returncode, self.stdout, self.stderr)
else:
return (1, self.stdout, self.stderr)
def Popen(CommandTuple, stdin=None, timeout=30):
# type: (Sequence[str], Optional[bytes], int) -> Tuple[int, str, str]
command = Command(CommandTuple, stdin)
logger.debug("running Command %s...", qsh(CommandTuple))
result = command.run(timeout)
if result[0] != 0:
print("Command: %s\nResult: %r" % (qsh(CommandTuple), result), file=usilog)
if result[0] == -15:
print("Process has been terminated [timeout]", file=usilog)
print("", file=usilog)
return result
def qsh(cmd):
# type: (Sequence[str]) -> str
return " ".join(quote(arg) for arg in cmd)
@contextmanager
def build_archive(flat, output=None):
# type: (bool, Optional[str]) -> Iterator[Archive]
archive = Archive(flat, output)
yield archive
archive.tar.close()
class Archive(object):
def __init__(self, flat=False, output=None):
# type: (bool, Optional[str]) -> None
self.flat = flat
self.name = output or tempfile.mkstemp(prefix='univention-support-info-%s.' % hostname, suffix='.tar.bz2')[1]
self.tar = tarfile.open(self.name, 'w:bz2')
def _info(self, prefix, name, suffix=""):
# type: (str, str, str) -> tarfile.TarInfo
name = name.strip()
if self.flat:
name = name.replace("/", "_")
info = tarfile.TarInfo(
'univention-support-info-%s-%s/%s%s%s%s' % (
hostname,
timeString,
prefix.strip("/"),
"/" if name else "",
name,
suffix,
)
)
info.mode = stat.S_IRUSR
return info
def add_text(self, text, prefix, name="", suffix=""):
# type: (str, str, str, str) -> None
data = text.encode("UTF-8")
info = self._info(prefix, name)
info.size = len(data)
try:
logger.debug("adding file %r", info.name)
assert self.tar
self.tar.addfile(info, BytesIO(data))
except EnvironmentError as exc:
print('WARNING: failed to add %r: error=%s' % (name, exc))
def add_file(self, fileobj, prefix, name="", suffix="", size=None):
# type: (IO[bytes], str, str, str, Optional[int]) -> None
if size is None:
fileobj.seek(0, os.SEEK_END)
size = fileobj.tell()
if fileobj.tell() > 0:
fileobj.seek(0)
info = self._info(prefix, name, suffix)
info.size = size
try:
logger.debug("adding file %r", info.name)
assert self.tar
self.tar.addfile(info, fileobj)
except EnvironmentError as exc:
print('WARNING: failed to add %r: error=%s' % (name, exc))
def add_path(self, filename, prefix="files", name="", suffix=""):
# type: (str, str, str, str) -> None
name = name or filename
try:
with open(os.path.realpath(filename), "rb") as stream:
if stream.name.startswith("/proc/"):
stream.read()
self.add_file(stream, prefix, name, suffix, size=stream.tell())
else:
self.add_file(stream, prefix, name, suffix)
except EnvironmentError as exc:
error = '\n'.join(map(str, exc.args))
self.add_text(error, prefix, name, ".ERROR")
def certificateValidity(archive, CertificatePath):
# type: (Archive, str) -> None
try:
import M2Crypto
except ImportError as exc:
error = '\n'.join(map(str, exc.args))
archive.add_text(error, "info/ssl", CertificatePath, ".ERROR")
return
try:
cert = M2Crypto.X509.load_cert(CertificatePath)
validity = '%s\nNot Before: %s\nNot After : %s\n' % (CertificatePath, cert.get_not_before(), cert.get_not_after())
archive.add_text(validity, "info/ssl", CertificatePath)
except (EnvironmentError, M2Crypto.X509.X509Error) as exc:
error = '\n'.join(map(str, exc.args))
archive.add_text(error, "info/ssl", CertificatePath, ".ERROR")
def certificateValidities(archive):
# type: (Archive) -> None
print('Checking certificate validity: ', end='')
sys.stdout.flush()
CertificatePatterns = [
'/etc/univention/ssl/*.*/cert.pem',
'/etc/univention/ssl/ucsCA/CAcert.pem',
]
for CertificatePattern in CertificatePatterns:
for CertificatePath in glob.glob(CertificatePattern):
certificateValidity(archive, CertificatePath)
print('done.')
def simpleFiles(archive):
# type: (Archive) -> None
FilePatterns = [
'/etc/apache2/*',
'/etc/apache2/*/*',
'/etc/apt/*',
'/etc/apt/*/*',
'/etc/cron*/*',
'/etc/crontab',
'/etc/fstab',
'/etc/imapd/*',
'/etc/mtab',
'/etc/passwd',
'/etc/procmailrc',
'/etc/spamassassin/*',
'/etc/univention/connector/ad/mapping.py',
'/etc/univention/connector/s4/mapping',
'/etc/univention/connector/s4/mapping.py',
'/etc/univention/connector/s4/mapping',
'/etc/univention/installation_profile',
'/etc/ox-secrets/*',
'/opt/open-xchange/etc/*',
'/opt/open-xchange/etc/*/*',
'/opt/open-xchange/etc/*/*/*',
'/proc/mounts*',
'/proc/mdstat',
'/proc/modules',
'/proc/drbd',
'/proc/cmdline',
'/var/lib/univention-directory-listener/bad_cache',
'/var/lib/univention-directory-replication/failed.ldif',
'/var/lib/univention-connector/s4/*',
'/var/lib/samba/private/.adtakeover/*',
'/var/spool/cron/**',
'/etc/postfix/*',
'/etc/samba/shares.conf.d/*',
'/etc/imapd/*',
'/var/univention-backup/ad-takeover/*',
'/etc/*/local.conf*',
'/root/.bash_history',
'/etc/ldap/slapd.conf',
]
FileExcludePatterns = [
'/etc/apache2/conf-available/*',
'/etc/apache2/mods-available/*',
'/etc/apache2/sites-available/*',
]
excluded = {
filename
for pattern in FileExcludePatterns
for filename in glob.glob(pattern)
}
included = {
filename
for pattern in FilePatterns
for filename in glob.glob(pattern)
}
print('Collecting files: ', end='')
sys.stdout.flush()
for Filename in sorted(included - excluded):
if os.path.isfile(Filename):
archive.add_path(Filename)
print('.', end='')
sys.stdout.flush()
print('done.')
def licenseObject(archive):
# type: (Archive) -> None
''' Get license object from ldap (cn=license) '''
stdout = executeCommand(archive, 'univention-license-object', ("univention-ldapsearch", '-b', 'cn=license,cn=univention,%(ldap/base)s' % ucr))
archive.add_text(stdout, 'info/univention-license-object')
def checkMaintenance(archive):
# type: (Archive) -> None
''' Check if UCS-Version is in maintenance '''
ucs_ver = "%d.%d-%d" % ucsrel
try:
if ucsrel < (5,):
maint_url = "https://updates.software-univention.de/download/ucs-maintenance/%s.yaml" % (ucs_ver,)
# check depending on License
data = urlopen(maint_url).read().decode('UTF-8')
maint_info = {
k.strip(): v.strip()
for k, v in (
line.split(':', 1)
for line in data.split("\n")
if line
)
}
maint = maint_info['maintained'].lower()
maintained = maint in ['true', '1'] or (maint == 'extended' and ucr['license/base'] == ucr['ldap/base'])
else:
maint_url = "https://updates.software-univention.de/ucs-releases.json"
import json
data = urlopen(maint_url).read().decode('UTF-8')
info = json.loads(data)
status, = (
patch["status"]
for major in info["releases"]
if major["major"] == ucsrel[0]
for minor in major["minors"]
if minor["minor"] == ucsrel[1]
for patch in minor["patchlevels"]
if patch["patchlevel"] == ucsrel[2]
)
maintained = status == "maintained"
if maintained:
text = "maintenance ok\ncurrent UCS Version %s\n" % (ucs_ver,)
else:
text = "Please note, system is no longer maintained, security updates are no longer available for current UCS Version %s" % (ucs_ver,)
print("\033[93m%s\033[0m" % (text,))
sys.stdout.flush()
except (URLError, EnvironmentError, TypeError, ValueError) as innerex:
print("Warn: Can't reach univention server %s - product maintenance undetermined [%s]" % (maint_url, innerex))
sys.stdout.flush()
text = "Failed to check maintenance (%s)\ncurrent UCS Version %s\n" % (innerex, ucs_ver)
finally:
archive.add_text(text, 'info/maintenance')
def checkEntryUUID(archive):
# type: (Archive) -> None
''' Check if ldap base is searchable by its entryUUID '''
entryuuid = ""
basedn = ""
exitcode, stdout, stderr = Popen(("univention-ldapsearch", '-LLL', '-sbase', 'entryUUID'))
if exitcode == 0:
entryuuid = stdout.split()[3]
else:
text = "ERROR: ldapsearch for base failed: %s\n" % (stderr,)
archive.add_text(text, 'info/entryUUID.stderr')
return
exitcode, stdout, stderr = Popen(("univention-ldapsearch", '-LLL', 'entryUUID=' + entryuuid, 'dn'))
if exitcode == 0:
basedn = stdout.split()[1]
else:
text = "ERROR: ldapsearch by entryUUID failed: %s\n" % (stderr,)
archive.add_text(text, 'info/entryUUID.stderr')
return
if ucr.get('ldap/base') == basedn:
text = "OK: ldap base found by entryUUID\n"
else:
text = "ERROR: ldap base not found by entryUUID, check ldap index\n"
archive.add_text(text, 'info/entryUUID')
def aptPackageList(archive):
# type: (Archive) -> None
"""List installed packages and their source repository."""
print('Collecting package lists: ', end='')
sys.stdout.flush()
cache = apt.Cache()
packagesAll = StringIO()
packagesUnknownSource = StringIO()
packages = (_ for _ in cache if _.is_installed)
for pkg in packages:
version = pkg.installed.version
package = pkg.versions[version]
try:
uri = package.uri
except StopIteration:
print("%s\tUNKNOWN" % (pkg.name,), file=packagesUnknownSource)
continue
print("%s\t%s" % (pkg.name, uri), file=packagesAll)
archive.add_text(packagesAll.getvalue(), 'info/packages_all')
archive.add_text(packagesUnknownSource.getvalue(), 'info/packages_unknown-source')
print('done.')
def executeCommand(archive, commandName, command, log_stderr=False):
# type: (Archive, str, Sequence[str], bool) -> str
exitcode, stdout, stderr = Popen(command)
if exitcode or log_stderr:
if isinstance(exitcode, int):
stderr += '\nExitcode was %d\n' % exitcode
else:
stderr += exitcode + '\n'
archive.add_text(stderr, 'info', commandName, '.stderr')
return stdout
def templateFiles(archive):
# type: (Archive) -> None
print('Searching for changed template files: ', end='')
sys.stdout.flush()
stdout = executeCommand(archive, 'check-templates', ('find', '/etc/univention/templates/files/', '(', '-name', '*.dpkg-new', '-o', '-name', '*.dpkg-dist', ')', '-print0'))
files = [templatefile for templatefile in stdout.split('\0') if templatefile]
message = ('Found %d:\n' % len(files)) + '\n'.join(files) + '\n'
archive.add_text(message, 'info/check-templates')
for templatefile in files:
archive.add_path(templatefile)
if templatefile.endswith('.dpkg-new'):
archive.add_path(templatefile[:-len('.dpkg-new')])
elif templatefile.endswith('.dpkg-dist'):
archive.add_path(templatefile[:-len('.dpkg-dist')])
print('.', end='')
sys.stdout.flush()
print('done.')
def checkTransactionFile(archive):
# type: (Archive) -> None
print('Collecting output transaction-file-check: ', end='')
sys.stdout.flush()
try:
with open('/var/lib/univention-ldap/notify/transaction', 'r') as transaction, tempfile.NamedTemporaryFile("w+", prefix='univention-support-info.') as transactionCheck:
tac = 1 # transaction id counter
for tlc, line in enumerate(transaction, start=1):
trans = line.strip().split(' ', 1)[0]
try:
tid = int(trans)
except ValueError:
print('ERROR at line %d: "%s"' % (tlc, ' '.join(line)), file=transactionCheck)
continue
if tid == tac: # ok
tac += 1
else:
print('Line %s: \t ID:%s should be %s' % (tlc, tid, tac), end=' ', file=transactionCheck)
if tid < tac: # id repeat
print(' REPEATED (%s)' % (tac - tid,), file=transactionCheck)
else: # id skip
print(' SKIPPED (%s)' % (tid - tac,), file=transactionCheck)
tac = (tid + 1)
transactionCheck.flush()
archive.add_path(transactionCheck.name, 'info/transaction-file-check')
print('done.')
except EnvironmentError:
archive.add_text('ERROR: NO TRANSACTION FILE!', "info/transaction-file-check.ERROR")
print('FAIL')
def collectCommandData(archive):
# type: (Archive) -> None
commands = {
'hostname-f':
('hostname', '--fqdn'),
'ifconfig-a':
('ifconfig', '-v', '-a'),
'iptables-L_filter':
('iptables', '-L', '-n', '-v', '-t', 'filter'),
'iptables-L_nat':
('iptables', '-L', '-n', '-v', '-t', 'nat'),
'iptables-L_mangle':
('iptables', '-L', '-n', '-v', '-t', 'mangle'),
'iptables-L_raw':
('iptables', '-L', '-n', '-v', '-t', 'raw'),
'iptables-save':
('iptables-save', '-c'),
'route-4':
('route', '-v', '-ee', '-n', '-A', 'inet'),
'route-6':
('route', '-v', '-ee', '-n', '-A', 'inet6'),
'netstat':
('netstat', '--tcp', '--udp', '--listening', '--program', '--extend', '--extend', '--verbose', '--timers', '--numeric', '--wide'),
'dpkg-l':
('dpkg-query', '--show', '--showformat=${Status}\t${Package}\t${Version}\n'),
'dpkg--audit':
('dpkg', '--audit'),
'uname':
('uname', '-a'),
'ps':
('ps', '-AHFly'),
'ps-full':
('ps', '-ALwwo', 'stat,pid,ppid,sid,tty,nlwp,lwp,pri,ni,sched,wchan,vsz,rss,sz,pcpu,pmem,cmd,blocked,caught,ignored,pending,lstart,cls,time,flags,uid,user,ruid,ruser,suid,suser,gid,group,rgid,rgroup,sgid,sgroup'),
'ucr-dump':
('univention-config-registry', 'dump'),
'df-full':
('df', '--portability', '--print-type'),
'df-i-full':
('df', '--portability', '--print-type', '--inodes'),
'df':
('df', '-h'),
'df-i':
('df', '-h', '-i'),
'join-status':
('univention-check-join-status',),
'virsh-qemu':
('virsh', '-c', 'qemu:///system', 'capabilities'),
'virsh-xen':
('virsh', '-c', 'xen:///', 'capabilities'),
'pvdisplay':
('pvdisplay',),
'vgdisplay':
('vgdisplay',),
'lvdisplay':
('lvdisplay',),
'top':
('top', '-b', '-n2'),
'testparm':
(('testparm', '-s', '-vvv'), True),
'listenerID':
('cat', '/var/lib/univention-directory-listener/notifier_id'),
'notifierID':
('/usr/share/univention-directory-listener/get_notifier_id.py',),
'mailq':
('mailq',),
'univention-license-check':
('univention-license-check',),
'hostaccount-id':
('id', "%(hostname)s$" % ucr),
'dig_AXFR':
('dig', '@%(nameserver1)s' % ucr, "%(domainname)s" % ucr, '-t', 'AXFR'),
'univention-connector-list-rejected':
('univention-connector-list-rejected',),
'sharesec':
('sharesec', '--view-all'),
'adtakeover':
('sh', '-c', 'ls -1d /var/lib/samba*/private.before-ad-takeover-*'),
'univentionService':
('univention-ldapsearch', '-LLL', '(|(univentionService=S4-Connector)(univentionService=Samba 4))', 'univentionService'),
} # type: Dict[str, Union[Sequence[str], Tuple[Sequence[str], bool]]]
# Commands depending on samba version
if sambaDomainVersion == 3:
commands.update({
'test-join':
('net', 'rpc', 'testjoin'),
})
elif sambaDomainVersion == 4:
commands.update({
'net-ads-info':
('net', 'ads', 'info'),
'net-ads-lookup':
('net', 'ads', 'lookup'),
})
if ucr.get('samba4/role'):
# Run only S4
commands.update({
'samba-tool-drs-showrepl':
('samba-tool', 'drs', 'showrepl'),
'samba-tool-domain-level-show':
('samba-tool', 'domain', 'level', 'show'),
'samba-tool-domain-passwordsettings':
('samba-tool', 'domain', 'passwordsettings', 'show'),
'testparm-samba4':
(('testparm.samba4', '-s', '-vvv'), True),
'samba-tool-fsmo-show':
('samba-tool', 'fsmo', 'show'),
'univention-s4connector-list-rejected':
('univention-s4connector-list-rejected',),
'samba-tool-processes':
('samba-tool', 'processes'),
'check-essential-dns-records':
('/usr/share/univention-samba4/scripts/check_essential_samba4_dns_records.sh',),
})
# >= Samba4 RC (UCS 3.1)
if ucsrel >= (3, 1):
commands.update({
'samba-tool-domain-info':
('samba-tool', 'domain', 'info', '127.0.0.1'),
})
else:
# Run only on S3 member in S4 domain
commands.update({
'test-join':
('net', 'ads', 'testjoin'),
})
# Commands depending on UCS-Version >= UCS 4.1-3
if ucsrel >= (4, 1, 3) or ucsrel >= (4, 2, 0):
commands.update({
'univention-directory-listener-ctrl':
('univention-directory-listener-ctrl', 'status'),
})
# Commands depending on UCS-Version → UCS 4.2
if ucsrel >= (4, 2):
commands.update({
'journalctl':
('journalctl', '--since=yesterday'),
'hostnamectl-status':
('hostnamectl', 'status'),
'univention-app-info':
('univention-app', 'info'),
})
print('Collecting command output: ', end='')
sys.stdout.flush()
for commandName, command in sorted(commands.items()):
if isinstance(command[0], tuple):
stdout = executeCommand(archive, commandName, command[0], cast(bool, command[1]))
else:
stdout = executeCommand(archive, commandName, cast(Sequence[str], command))
archive.add_text(stdout, "info/" + commandName)
print('.', end='')
sys.stdout.flush()
print('done.')
def univentionSystemInfo(archive):
# type: (Archive) -> None
print('Collecting hardware information: ', end='')
sys.stdout.flush()
manu = executeCommand(archive, 'dmidecode', ('dmidecode', '-s', 'system-manufacturer'))
product = executeCommand(archive, 'dmidecode', ('dmidecode', '-s', 'system-product-name'))
if not manu:
manu = 'Unknown'
if not product:
product = 'Unknown'
stdout = executeCommand(archive, 'univention-system-info', ('univention-system-info', '-u', '-m', manu, '-t', product, '-c', 'Created by univention-support-info', '-s', '-'))
for line in stdout.split('\n'):
if line.startswith('archive'):
path = line.split(':', 1)[1]
break
else:
error = 'No archive returned!'
error += '\nunivention-system-info stdout:\n%s' % (stdout,)
archive.add_text(error, 'info/univention-system-info.ERROR')
return
filename = os.path.join('/var/www/univention-management-console/system-info/', path)
# If UMC is not installed /var/www/univention-management-console/system-info/ does not exist and archive stays in /tmp
if not os.path.isfile(filename):
filename = os.path.join('/tmp/', path)
try:
sys_info_archive = tarfile.open(name=filename, mode='r:*')
for member in sys_info_archive:
if member.isfile():
fileobj = sys_info_archive.extractfile(member)
assert fileobj
archive.add_file(fileobj, 'info/univention-system-info/' + member.name, size=member.size)
fileobj.close()
sys_info_archive.close()
except (EnvironmentError, tarfile.TarError) as exc:
error = '\n'.join(map(str, exc.args))
error += '\nunivention-system-info stdout:\n%s' % (stdout,)
archive.add_text(error, 'info/univention-system-info.ERROR')
print('done.')
def rotatedLogs(archive, full, DefaultMaxLineCount=1000, count=2):
# type: (Archive, bool, int, int) -> None
DirectoryList = [
('/var/log/auth.log', DefaultMaxLineCount),
('/var/log/boot.log', DefaultMaxLineCount),
('/var/log/daemon.log', DefaultMaxLineCount),
('/var/log/debug.log', DefaultMaxLineCount),
('/var/log/dpkg.log', DefaultMaxLineCount),
('/var/log/heimdal-kdc.log', DefaultMaxLineCount),
('/var/log/kern.log', DefaultMaxLineCount),
('/var/log/mail.log', DefaultMaxLineCount),
('/var/log/messages', DefaultMaxLineCount),
('/var/log/syslog', 2000000),
('/var/log/apt/term.log', DefaultMaxLineCount),
('/var/log/univention/ucs-school-import/', DefaultMaxLineCount),
('/var/log/univention/directory-manager-rest.log', DefaultMaxLineCount),
('/var/log/univention/ucsschool-apis/', DefaultMaxLineCount),
('/var/log/univention/ucsschool-id-connector/', DefaultMaxLineCount),
('/var/log/univention/ucsschool-kelvin-rest-api/', DefaultMaxLineCount),
('/var/log/univention/config-registry.replog', DefaultMaxLineCount),
('/var/log/univention/connector-s4.log', 2000000),
('/var/log/univention/system-stats.log', 5000000),
('/var/log/apache/', DefaultMaxLineCount),
('/var/log/apache2/', DefaultMaxLineCount),
('/var/log/cups/', DefaultMaxLineCount),
('/var/log/dansguardian/', DefaultMaxLineCount),
('/var/log/freeradius/', DefaultMaxLineCount),
('/var/log/installer/', 2000000),
('/var/log/kopano/', 100000),
('/var/log/libvirt/', DefaultMaxLineCount),
('/var/log/open-xchange/', DefaultMaxLineCount),
('/var/log/samba/', DefaultMaxLineCount),
('/var/log/squid/', DefaultMaxLineCount),
('/var/log/squidguard/', DefaultMaxLineCount),
('/var/log/univention/', DefaultMaxLineCount),
('/var/log/univention/ucc-clients/', DefaultMaxLineCount),
('/var/log/zarafa/', 100000),
]
FullLogs = { # for these every available log-file shall be included
'/var/log/daemon.log',
'/var/log/dpkg.log',
'/var/log/kern.log',
'/var/log/apt/term.log',
'/var/log/univention/updater.log',
'/var/log/univention/ad-takeover.log',
}
RE = re.compile(
r"""
(.+?) # stem
(?:\.([0-9]+))? # age
(\.gz)? # compression
$""", re.VERBOSE)
def match(filename):
# type: (str) -> Tuple[str, int, bool]
m = RE.match(filename)
assert m
stem, age, compressed = m.groups()
return (stem, int(age or -1), bool(compressed))
GzipSuffix = '.gz'
logs = {} # type: Dict[str, Dict[int, bool]]
for Entry in (fp[0] for fp in DirectoryList):
if os.path.isdir(Entry):
FileList = [
join(Entry, f)
for f in os.listdir(Entry)
if full or match(f)[1] <= count
]
logger.debug("Dir.Entry: %r has Files %r", Entry, FileList)
elif os.path.isfile(Entry):
head, tail = os.path.split(Entry)
FileList = [
join(head, f)
for f in os.listdir(head)
if full or match(f)[0] == tail
]
else:
FileList = []
for filename in FileList:
if os.stat(filename).st_size <= 0 or os.path.isdir(filename):
continue
stem, age, compressed = match(filename)
logs.setdefault(stem, {})[age] = compressed
print('Collecting logfiles: ', end='')
sys.stdout.flush()
for logname, numbers in sorted(logs.items()):
logLinecount = 0
nonemptyNumber = 0
for number, gzipped in sorted(numbers.items()):
path = logname
if number != -1:
path += '.%d' % number
if gzipped:
try:
logfile = cast(IO[bytes], open(path + GzipSuffix, 'rb'))
except EnvironmentError as exc:
error = '\n'.join(map(str, exc.args))
archive.add_text(error, 'files', logname, '_%d.stderr' % (number,))
continue
# calc bytes and linecount of logfile
# last 4 bytes of a gzip file contain the size of the original (uncompressed) input data modulo 2^32.
try:
logfile.seek(-4, os.SEEK_END)
except EnvironmentError as exc:
print('\n\nFilename: %s%s: %s' % (path, GzipSuffix, exc), end='')
sys.stdout.flush()
raise
fileBytes = read32(logfile)
logfile.close()
proc = subprocess.Popen('zcat -f %s%s | wc -l' % (path, GzipSuffix), stdout=subprocess.PIPE, shell=True)
assert proc.stdout
fileLinecount = int(proc.stdout.read().decode('ASCII').strip())
else:
# addFile may calculate the size for us
fileBytes = None
proc = subprocess.Popen(('wc', '-l', path), stdout=subprocess.PIPE)
assert proc.stdout
fileLinecount = int(proc.stdout.read().strip().split()[0].decode('ASCII'))
logLinecount += fileLinecount
if fileLinecount <= 0:
continue
nonemptyNumber += 1
try:
if gzipped:
logfile = cast(IO[bytes], gzip.GzipFile(path + GzipSuffix, 'rb'))
else:
logfile = open(path, 'rb')
except EnvironmentError as exc:
error = '\n'.join(map(str, exc.args))
archive.add_text(error, 'files', logname, '_%d.stderr' % (nonemptyNumber,))
continue
# Add file to archive ...
archive.add_file(logfile, 'files', logname, '_%d' % (nonemptyNumber,), size=fileBytes)
logfile.close()
if full:
pass
elif logname in FullLogs:
pass
else:
logger.debug("*** LN: %r ***", logname)
logger.debug("*** DL: %r ***", DirectoryList)
try:
if logLinecount > [x for x in DirectoryList if logname.startswith(x[0].replace('*', ''))][0][1]:
break
except Exception as ex:
logger.debug("EXCEPTION: %s", ex, exc_info=True)
continue
print('.', end='')
sys.stdout.flush()
print('done.')
def read32(input):
# type: (IO[bytes]) -> int
return cast(int, struct.unpack(" None
'''
Generate a list of at-Jobs (usefull for UCS@school)
'''
try:
from univention.lib import atjobs as at
except ImportError as exc:
error = str(exc)
archive.add_text(error, 'info/at-jobs.ERROR')
return
jobs = ''
try:
for job in at.list(extended=True):
jobs += '\n'.join(str(job))
except EnvironmentError as exc:
error = str(exc)
archive.add_text(error, 'info/at-jobs.ERROR')
archive.add_text(jobs, 'info/at-jobs')
def tryDelete(filename):
# type: (str) -> None
try:
os.remove(filename)
except EnvironmentError:
pass
def gpg(archiveFileName):
# type: (str) -> str
print("Encrypting file...", end=''),
sys.stdout.flush()
keyringFileName = tempfile.mkstemp(prefix='univention-support-info-keyring.', suffix='.gpg')[1]
secringFileName = tempfile.mkstemp(prefix='univention-support-info-secring.', suffix='.gpg')[1]
trustdbFileName = tempfile.mkstemp(prefix='univention-support-info-trustdb.', suffix='.gpg')[1]
tryDelete(trustdbFileName) # HACK: file must not exist for gpg to work
gpgFileName = archiveFileName + '.gpg'
gpgBase = (
'gpg',
'--batch', '--quiet', '--no-tty',
'--with-colons', '--utf8-strings',
'--no-auto-check-trustdb', '--no-auto-key-locate',
'--no-options',
'--no-random-seed-file',
'--trust-model', 'always',
'--trustdb-name', trustdbFileName,
'--secret-keyring', secringFileName,
'--no-default-keyring', '--keyring', keyringFileName,
)
gpgImport = gpgBase + ('--import',)
gpgEncrypt = gpgBase + ('--recipient', FINGERPRINT, '--encrypt', archiveFileName)
# Popen is a function above which injects the input to the called process as "human" input
exitcode, stdout, stderr = Popen(gpgImport, KEY_DATA)
if exitcode:
print("gpg-import failed with %s" % (exitcode,), end='')
if stdout:
print("stdout: %r" % (stdout,), end='')
if stderr:
print("stderr: %r" % (stderr,), end='')
sys.stdout.flush()
tryDelete(keyringFileName)
tryDelete(keyringFileName + '~')
tryDelete(secringFileName)
tryDelete(trustdbFileName)
tryDelete(gpgFileName)
return ""
exitcode, stdout, stderr = Popen(gpgEncrypt)
if exitcode:
print("gpg-encrypt failed with %s" % (exitcode,), end='')
if stdout:
print("stdout: %r" % (stdout,), end='')
if stderr:
print("stderr: %r" % (stderr,), end='')
sys.stdout.flush()
tryDelete(keyringFileName)
tryDelete(keyringFileName + '~')
tryDelete(secringFileName)
tryDelete(trustdbFileName)
tryDelete(gpgFileName)
return ""
tryDelete(keyringFileName)
tryDelete(keyringFileName + '~')
tryDelete(secringFileName)
tryDelete(trustdbFileName)
os.chmod(gpgFileName, stat.S_IWUSR | stat.S_IRUSR | stat.S_IRGRP | stat.S_IROTH)
print("done.", end='')
return gpgFileName
def checkForRoot():
# type: () -> None
if os.geteuid() != 0:
print('Please run this program as root!')
sys.exit(3)
@contextmanager
def prepareEnvironment():
# type: () -> Iterator[Dict[str, str]]
env = os.environ.copy()
env['LC_ALL'] = 'C'
env['COLUMNS'] = '250'
env['HOME'] = home = tempfile.mkdtemp(prefix='univention-support-info_')
try:
shutil.copy('/etc/skel/.bashrc', env['HOME'])
shutil.copy('/etc/skel/.profile', env['HOME'])
with open(os.path.join(env['HOME'], '.toprc'), 'w') as f:
f.write(TOPRC)
os.mkdir("%s/.gnupg" % (env['HOME'],))
except EnvironmentError:
pass
yield env
shutil.rmtree(home, True)
def main():
# type: () -> None
options = parse_args()
setup_logging(options)
checkForRoot()
global env
with prepareEnvironment() as env:
with build_archive(options.flatStruct, options.output) as archive:
fill_archive(archive, options)
print("Data collection completed.\n", end='')
sys.stdout.flush()
encrypt_archive(options.encrypt, archive.name)
print("\t%s" % (archive.name,))
sys.stdout.flush()
def setup_logging(options):
# type: (argparse.Namespace) -> None
stdlog = logging.StreamHandler() # log to console
stdlog.setFormatter(logging.Formatter('%(asctime)s - %(filename)s [%(levelname)s] <%(funcName)s()>: %(message)s'))
logger.addHandler(stdlog)
if options.debug:
logger.setLevel(logging.DEBUG)
elif options.verbose:
logger.setLevel(logging.INFO)
else:
logger.setLevel(logging.WARNING)
def fill_archive(archive, options):
# type: (Archive, argparse.Namespace) -> None
archive.add_text(usiVersion, 'info', 'usi_version')
print("USI Archiver Version \033[1m%s\033[0m\n" % (usiVersion,), end='')
# Check Samba Version
global sambaDomainVersion
sambaDomainVersion = 4 if executeCommand(archive, 'samba4-pdc-dn', ("univention-ldapsearch", '-LLL', '(&(univentionService=Samba 4)(objectClass=univentionDomainController))', 'dn')) else 3
checkMaintenance(archive)
collectCommandData(archive)
simpleFiles(archive)
licenseObject(archive)
templateFiles(archive)
aptPackageList(archive)
checkTransactionFile(archive)
atJobs(archive)
certificateValidities(archive)
univentionSystemInfo(archive)
rotatedLogs(archive, options.fullLogs)
checkEntryUUID(archive)
# Place new calls above this line
archive.add_text(usilog.getvalue(), 'info/usi_runtime.log')
def encrypt_archive(encrypt, archiveFileName):
# type: (bool, str) -> None
if encrypt:
gpgArchiveFileName = gpg(archiveFileName)
if gpgArchiveFileName:
print("The encrypted data can be found here:\n\t%s\n" % (gpgArchiveFileName,), end='')
else:
print("WARNING: The data could not be encrypted!", end='')
print()
print("The unencrypted data can be found here:", end='')
else:
print("The data can be found here:", end='')
def parse_args():
# type: () -> argparse.Namespace
parser = argparse.ArgumentParser(description=__doc__)
group = parser.add_argument_group("Internal developer options")
group.add_argument('--debug', action='store_true', help="Show debug level DEBUG and above")
group.add_argument('--verbose', action='store_true', help="Show debug level INFO and above")
parser.add_argument('--encrypt', action='store_true', help='encrypt data (can only be decrypted by Univention support)')
parser.add_argument('--full-logs', action='store_true', dest='fullLogs', help='collect also rotated logfiles')
parser.add_argument('--flat', action='store_true', dest='flatStruct', help='flatten the directory structure')
parser.add_argument('--version', action='version', version="%(prog)s {}".format(usiVersion))
parser.add_argument("--output", "-o", metavar="FILE", help="Output file or USI")
return parser.parse_args()
FINGERPRINT = '1EB89EEB365A84A65F95FB28CD78CD3C8F91B44F'
# create with: gpg2 --armor --export --export-options export-minimal $FINGERPRINT
KEY_DATA = b"""\
-----BEGIN PGP PUBLIC KEY BLOCK-----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=S8To
-----END PGP PUBLIC KEY BLOCK-----"""
TOPRC = """\
RCfile for "top with windows" # shameless braggin'
Id:a, Mode_altscr=0, Mode_irixps=1, Delay_time=3.000, Curwin=0
Def fieldscur=AEHIOQTWKNMbcdfgjplrsuvyzX
winflags=62905, sortindx=10, maxtasks=0
summclr=1, msgsclr=1, headclr=3, taskclr=1
Job fieldscur=ABcefgjlrstuvyzMKNHIWOPQDX
winflags=62777, sortindx=0, maxtasks=0
summclr=6, msgsclr=6, headclr=7, taskclr=6
Mem fieldscur=ANOPQRSTUVbcdefgjlmyzWHIKX
winflags=62777, sortindx=13, maxtasks=0
summclr=5, msgsclr=5, headclr=4, taskclr=5
Usr fieldscur=ABDECGfhijlopqrstuvyzMKNWX
winflags=62777, sortindx=4, maxtasks=0
summclr=3, msgsclr=3, headclr=2, taskclr=3
"""
if __name__ == "__main__":
main()