<?php

class HardwareParser
{

	const SIZE_LOOKUP = ['T' => 1099511627776, 'G' => 1073741824, 'M' => 1048576, 'K' => 1024, '' => 1];
	const SI_LOOKUP = ['T' => 1000000000000, 'G' => 1000000000, 'M' => 1000000, 'K' => 1000, '' => 1];

	/**
	 * Convert/format size unit. Input string can be a size like
	 * 8 GB or 1024 MB and will be converted according to passed parameters.
	 * @param string $string Input string
	 * @param string $scale 'a' for auto, T/G/M/K/'' for according units
	 * @param bool $appendUnit append unit string, e.g. 'GiB'
	 * @return false|string|int Formatted result
	 */
	public static function convertSize(string $string, string $scale = 'a', bool $appendUnit = true)
	{
		if (!preg_match('/(\d+)\s*([TGMK]?)/i', $string, $out)) {
			//error_log("Not size: $string");
			return false;
		}
		$val = (int)$out[1] * self::SIZE_LOOKUP[strtoupper($out[2])];
		if (!array_key_exists($scale, self::SIZE_LOOKUP)) {
			foreach (self::SIZE_LOOKUP as $k => $v) {
				if ($k === '' || $val / 8 >= $v || abs($val - $v) < 50) {
					$scale = $k;
					break;
				}
			}
		}
		$val = (int)round($val / self::SIZE_LOOKUP[$scale]);
		if ($appendUnit) {
			$val .= ' ' . ($scale === '' ? 'Byte' : $scale . 'iB'); // NBSP!!
		}
		return $val;
	}

	/**
	 * Decode JEDEC ID to according manufacturer
	 */
	public static function decodeJedec(string $string): string
	{
		// JEDEC ID:7F 7F 9E 00 00 00 00 00
		// or the ID as 8 hex digits with no spacing and prefix
		$id = null;
		if (preg_match('/JEDEC(?:\s*ID)?\s*:?\s*([0-9a-f\s]{8,23})\s*$/i', $string, $out)
				|| preg_match('/^([0-9a-f]{14}00)$/i', $string, $out)) {
			preg_match_all('/[0-9a-f]{2}/i', $out[1], $out);
			$bank = 0;
			foreach ($out[0] as $id) {
				$bank++;
				$id = hexdec($id) & 0x7f; // Let's just ignore the parity bit, and any potential error
				if ($id !== 0x7f)
					break;
			}
			if ($id !== null) {
				$id = self::lookupJedec($bank, $id);
			}
		} elseif (preg_match('/Unknown.{0,16}[\[(](?:0x)?([0-9a-fA-F]{2,4})[\])]/', $string, $out)) {
			// First byte (big endian) is id-in-bank, low byte is bank
			$id = self::decodeBankAndId($out, false);
		} elseif (preg_match('/JEDEC(?:\s*ID)?\s*:?\s*([0-9a-f]{2}\s?[0-9a-f]{2})/i', $string, $out)
				|| (preg_match('/^([0-9A-F]{4})([0-9A-F]{4})([0-9A-F]{4})$/', $string, $out) && $out[2] === '0000')) {
			// First byte is bank, second byte is id-in-bank
			$id = self::decodeBankAndId($out, true);
		} elseif (preg_match('/^([0-9a-f]{4})$/i', $string, $out)) {
			// This one was seen with both endianesses
			$id = self::decodeBankAndId($out, true);
			if ($id === null) {
				$id = self::decodeBankAndId($out, false);
			}
		}

		if ($id !== null)
			return $id;
		return $string;
	}

	private static function decodeBankAndId(array $out, bool $bankFirst): ?string
	{
		// 16bit encoding from DDR3+: lower byte is number of 0x7f bytes, upper byte is id within bank
		$id = hexdec(str_replace(' ', '', $out[1]));
		// Our bank counting starts at one. Also ignore parity bit.
		$bank = ($id & 0x7f);
		// Shift down id, get rid of parity bit
		$id = ($id >> 8) & 0x7f;
		if ($bankFirst) {
			// Observed second case, on OptiPlex 5050, is 80AD000080AD, but here endianness is reversed
			$tmp = $id;
			$id = $bank;
			$bank = $tmp;
		}
		$bank++;
		return self::lookupJedec($bank, $id);
	}

	private static function lookupJedec(int $bank, int $id): ?string
	{
		static $data = false;
		if ($data === false) {
			$data = json_decode(file_get_contents(dirname(__FILE__) . '/jedec.json'), true);
		}
		if (array_key_exists('bank' . $bank, $data) && array_key_exists('id' . $id, $data['bank' . $bank]))
			return $data['bank' . $bank]['id' . $id];
		return null;
	}

	/**
	 * Turn several numeric measurements like Size, Speed, Voltage into a unitless
	 * base representation, meant for comparison. For example, Voltages are converted
	 * to Millivolts, Anything measured in [KMGT]Bytes (per second) to bytes, GHz to
	 * Hz, and so on.
	 * @return ?int value, or null if not numeric
	 */
	private static function toNumeric(string $key, string $val): ?int
	{
		$key = strtolower($key);
		// Normalize voltage to mV
		if ((strpos($key, 'volt') !== false || strpos($key, 'current') !== false)
			&& preg_match('/^([0-9]+(?:\.[0-9]+)?)\s+(m?)V/', $val, $out)) {
			return (int)($out[1] * ($out[2] === 'm' ? 1 : 1000));
		}
		if (preg_match('/speed|width|size|capacity/', $key)
			&& preg_match('#^([0-9]+(?:\.[0-9]+)?)\s*([TGMK]?)i?([BT](?:it|yte|))s?(?:/s)?#i',
				$val, $out)) {
			// Matched (T/G/M) Bits, Bytes, etc...
			// For bits, use SI
			if ($out[3] !== 'B' && strtolower($out[3]) !== 'byte')
				return (int)($out[1] * self::SI_LOOKUP[strtoupper($out[2])]);
			// For bytes, use 1024
			return (int)($out[1] * self::SIZE_LOOKUP[strtoupper($out[2])]);
		}
		// Speed in Hz
		if (preg_match('#^([0-9]+(?:\.[0-9]+)?)\s*([TGMK]?)Hz#i',
			$val, $out)) {
			return (int)($out[1] * self::SI_LOOKUP[strtoupper($out[2])]);
		}
		// Count, size (unitless)
		if (is_numeric($val) && preg_match('/^-?[0-9]+$/', $val)
			&& preg_match('/used|occupied|count|number|speed|width|size|capacity|temperature|_start|_value|_thresh|_worst|_time|_rate/', $key)) {
			return (int)$val;
		}
		// Date
		if (preg_match('#^(?:[0-9]{2}/[0-9]{2}/[0-9]{4}|[0-9]{4}-[0-9]{2}-[0-9]{2})$#', $val)) {
			return (int)strtotime($val);
		}
		return null;
	}

	/**
	 * Takes hwinfo json, then looks up and returns all sections from the
	 * dmidecode subtree that represent the given dmi table entry type,
	 * e.g. 17 for memory. It will then return an array of 'props' subtrees.
	 *
	 * @param array $data hwinfo tree
	 * @param int $type dmi type
	 * @return array [ <props>, <props>, ... ]
	 */
	public static function getDmiHandles(array $data, int $type): array
	{
		if (empty($data['dmidecode']))
			return [];
		$ret = [];
		foreach ($data['dmidecode'] as $section) {
			if ($section['handle']['type'] == $type) {
				$ret[] = $section['props'];
			}
		}
		return $ret;
	}

	/**
	 * Takes key-value-array, returns a concatenated string of all the values with the keys given in $fields.
	 * The items are separated by spaces, and returned in the order they were given in $fields. Missing keys
	 * are silently omitted.
    */
	private static function idFromArray(array $array, string ...$fields): string
	{
		$out = '';
		foreach ($fields as $field) {
			if (!isset($array[$field]))
				continue;
			if (empty($out)) {
				$out = $array[$field];
			} else {
				$out .= ' ' . $array[$field];
			}
		}
		return $out;
	}

	/**
	 * Establish a mapping between a client and some hardware device.
	 * Optionally writes hardware properties specific to a hardware instance of a client
	 *
	 * @param string $uuid client
	 * @param int $hwid hw global hw id
	 * @param string $pathId unique identifier for the local instance of this hw, e.q. PCI slot, /dev path, something that handles the case that there are multiple instances of the same hardware in one machine
	 * @param array $props KV-pairs of properties to write for this instance; can be empty
	 * @return int ID of mapping in DB
	 */
	private static function writeLocalHardwareData(string $uuid, int $hwid, string $pathId, array $props): int
	{
		// Add mapping between hw entity and machine
		$pathId = iconv('UTF-8', 'ASCII//TRANSLIT//IGNORE', $pathId);
		$mappingId = Database::insertIgnore('machine_x_hw', 'machinehwid',
			['hwid' => $hwid, 'machineuuid' => $uuid, 'devpath' => $pathId],
			['disconnecttime' => 0]);
		// And all the properties specific to this entity instance (e.g. serial number)
		if (!empty($props)) {
			$vals = [];
			foreach ($props as $k => $v) {
				$vals[] = [$mappingId, $k, $v, self::toNumeric($k, $v)];
			}
			Database::exec("INSERT INTO machine_x_hw_prop (machinehwid, prop, `value`, `numeric`)
					VALUES :vals
					ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `numeric` = VALUES(`numeric`)", ['vals' => $vals]);
		}
		return $mappingId;
	}

	/**
	 * Takes an array of type [ key1 => [ 'values' => [ <val1.1>, <val1.2>, ... ] ], key2 => ... ]
	 * and turns it into [ key1 => <val1.1>, key2 => <val2.1>, ... ]
	 *
	 * Along the way:
	 * 1) any fields with bogus values, or values analogous to empty will get removed
	 */
	public static function prepareDmiProperties(array $data): array
	{
		$ret = [];
		foreach ($data as $key => $vals) {
			$val = trim($vals['values'][0] ?? 'NULL');
			if ($val === '[Empty]' || $val === 'NULL')
				continue;
			$val = preg_replace('/[^a-z0-9]/', '', strtolower($val));
			if ($val === '' || $val === 'notspecified' || $val === 'tobefilledbyoem' || $val === 'unknown'
				|| $val === 'chassismanufacture' || $val === 'chassismanufacturer' || $val === 'chassisversion'
				|| $val === 'chassisserialnumber' || $val === 'defaultstring' || $val === 'productname'
				|| $val === 'manufacturer' || $val === 'systemmodel' || $val === 'fillbyoem' || $val === 'none') {
				continue;
			}
			$val = trim($vals['values'][0] ?? '');
			if ($key === 'Manufacturer') {
				$val = self::fixManufacturer($val);
			}
			$ret[$key] = $val;
		}
		return $ret;
	}

	/**
	 * Mark all devices of a given type disconnected from the given machine, with an optional
	 * exclude list of machine-client-mapping IDs
	 *
	 * @param string $uuid client
	 * @param string $dbType type, eg HDD
	 * @param array $excludedHwIds mappingIDs to exclude, ie. devices that are still connected
	 */
	private static function markDisconnected(string $uuid, string $dbType, array $excludedHwIds)
	{
		//error_log("Marking disconnected for $dbType except " . implode(', ', $excludedHwIds));
		if (empty($excludedHwIds)) {
			Database::exec("UPDATE machine_x_hw mxh, statistic_hw h
				SET mxh.disconnecttime = UNIX_TIMESTAMP()
				WHERE h.hwtype = :type AND h.hwid = mxh.hwid AND mxh.machineuuid = :uuid
				AND mxh.disconnecttime = 0",
				['type' => $dbType, 'uuid' => $uuid]);
		} else {
			Database::exec("UPDATE machine_x_hw mxh, statistic_hw h
				SET mxh.disconnecttime = UNIX_TIMESTAMP()
				WHERE h.hwtype = :type AND h.hwid = mxh.hwid AND mxh.machineuuid = :uuid
				AND mxh.disconnecttime = 0 AND mxh.machinehwid NOT IN (:hwids)",
				['type' => $dbType, 'uuid' => $uuid, 'hwids' => $excludedHwIds]);
		}
	}

	/**
	 * Insert some hardware into database. $global is supposed to contain key-value-pairs of properties
	 * this hardware has that is the same for every instance of this hardware, like model number, speed
	 * or size. Individual properties, like a serial number, are considered local properties, and go
	 * into a different table, that would contain a row for each client that has this hardware.
	 * @param string $dbType Hardware typ (HDD, RAM, ...)
	 * @param array $global associative array of properties this hardware has
	 * @return int id of this hardware; primary key of row in statistic_hw_prop
	 */
	private static function writeGlobalHardwareData(string $dbType, array $global, array $globalExtra = []): int
	{
		static $cache = [];
		// Since the global properties are supposed to be unique for a specific piece of hardware, use them all
		// to generate a combined ID for this hardware entity, as opposed to $localProps, which should differ
		// between instances of the same hardware entity, e.g. one specific HDD model has different serial numbers.
		$id = md5(implode(' ', $global));
		// But don't include our "fake" fields in this as we might add more there later, which would
		// change the ID then.
		$global += $globalExtra;
		if (!isset($cache[$id])) {
			// Cache lookup, make sure we insert this only once for every run, as this is supposed to be general
			// information about the hardware, e.g. model number, max. resolution, capacity, ...
			$hwid = Database::insertIgnore('statistic_hw', 'hwid', ['hwtype' => $dbType, 'hwname' => $id]);
			$vals = [];
			foreach ($global as $k => $v) {
				$vals[] = [$hwid, $k, $v, self::toNumeric($k, $v)];
			}
			if (!empty($vals)) {
				Database::exec("INSERT INTO statistic_hw_prop (hwid, prop, `value`, `numeric`)
						VALUES :vals
						ON DUPLICATE KEY UPDATE `value` = VALUES(`value`), `numeric` = VALUES(`numeric`)",
					['vals' => $vals]);
			}
			$cache[$id] = $hwid;
		}
		return $cache[$id];
	}

	/**
	 * Process hardware info for given client.
	 * @param string $uuid System-UUID of client
	 * @param array $data Hardware info, deserialized assoc array.
	 * @return ?array id44mb and id45mb as calculated from given HDD data
	 */
	public static function parseMachine(string $uuid, array $data): ?array
	{
		$version = $data['version'] ?? 0;
		if ($version != 2) {
			error_log("Received unsupported hw json v$version");
			return null;
		}
		// determine misc stuff first
		$globalCpuExtra = [];
		$globalMainboardExtra = [];
		$localMainboardExtra = [];
		// physical memory array
		$memArrays = self::getDmiHandles($data, 16);
		// We mostly have a seprate hardware type for all the dmi types, but not for memory arrays.
		// These get added to the mainboard hw-type as it's practically a property of the mainboard.
		// While we can have multiple physical memory arrays, we only ever have one mainboard per
		// client. Add up the data from all arrays.
		$globalMainboardExtra['Memory Slot Count'] = 0;
		$globalMainboardExtra['Memory Maximum Capacity'] = 0;
		foreach ($memArrays as $mem) {
			$mem = self::prepareDmiProperties($mem);
			// Not all memory arrays are for RAM....
			if (($mem['Use'] ?? 0) !== 'System Memory')
				continue;
			if (isset($mem['Number Of Devices'])) {
				$globalMainboardExtra['Memory Slot Count'] += $mem['Number Of Devices'];
			}
			if (isset($mem['Maximum Capacity'])) {
				// Temporary unit is MB
				$globalMainboardExtra['Memory Maximum Capacity']
					+= self::convertSize($mem['Maximum Capacity'], 'M', false);
			}
		}
		// Now finally convert to GB
		$globalMainboardExtra['Memory Maximum Capacity']
			= self::convertSize($globalMainboardExtra['Memory Maximum Capacity'] . ' MB', 'G');
		// BIOS section - need to combine this with mainboard or system model, as it doesn't have a meaningful
		// identifier on its own. So again like above, we add this to the mainboard data.
		$bios = self::prepareDmiProperties(self::getDmiHandles($data, 0)[0] ?? []);
		foreach (['Version', 'Release Date', 'Firmware Revision'] as $k) {
			if (isset($bios[$k])) {
				// Prefix with "BIOS" to clarify, since it's added to the mainboard meta-data
				$localMainboardExtra['BIOS ' . $k] = $bios[$k];
			}
		}
		if (isset($bios['BIOS Revision'])) { // This one already has the BIOS prefix
			$localMainboardExtra['BIOS Revision'] = $bios['BIOS Revision'];
		}
		// Vendor and ROM size of BIOS *should* always be the same for a specific mainboard
		foreach (['Vendor', 'ROM Size'] as $k) {
			if (isset($bios[$k])) {
				$globalMainboardExtra['BIOS ' . $k] = $bios[$k];
			}
		}
		// "Normal" dmi entries - these map directly to one of our hardware types
		// RAM modules
		$capa = 0;
		$ramModCount = self::updateHwTypeFromDmi($uuid, $data, 17, HardwareInfo::RAM_MODULE,
			// Filter callback - we can modify the entry, or return false to ignore it
			function (array $flat) use (&$capa): bool {
				$size = self::convertSize(($flat['Size'] ?? 0), '', false);
				// Let's assume we're never running on old HW with <=128MB modules, so this
				// might be a hint that this is some other kind of memory. The proper way would be
				// to check if the related physical memory array (16) has "Use" = "System Memory"
				if ($size > 129 * 1024 * 1024) {
					$capa += $size;
					return true;
				}
				return false;
			},
			['Locator'],
			['Data Width',
				'Size',
				'Form Factor',
				'Type',
				'Type Detail',
				'Speed',
				'Manufacturer',
				'Part Number',
				'Minimum Voltage',
				'Maximum Voltage'],
			['Locator', 'Bank Locator', 'Serial Number', 'Asset Tag', 'Configured Memory Speed', 'Configured Voltage']
		);
		// Put RAM slots used/total etc. into mainboard data
		$localMainboardExtra['Memory Slot Occupied'] = $ramModCount;
		$localMainboardExtra['Memory Installed Capacity'] = self::convertSize($capa, 'G', true);
		// Also add generic socket, core and thread count to mainboard data. This doesn't seem to make too much sense
		// at first since it's not a property of the mainboard. But we can get away with it since we make it a local
		// property, i.e. specific to a client. This is just aggregated, so it's not super well suited for the CPU
		// hardware type, referenced below. In fact, on some systems the dmi/smbios tables don't contain all that much
		// information about the CPU at all, so we have at least this.
		foreach (['sockets', 'cores', 'threads'] as $key) {
			if (!isset($data['cpu'][$key]))
				continue;
			$localMainboardExtra['cpu-' . $key] = $data['cpu'][$key];
		}
		if ($data['cpu']['vmx-legacy'] ?? false) {
			$globalCpuExtra['vmx-legacy'] = 1;
		}
		// Do the same hack with the primary NIC's speed and duplex. Even if it's not an onboard NIC, we only have one
		// primary boot interface
		$bootNic = $data['net']['boot0'] ?? $data['net']['eth0'] ?? null;
		if ($bootNic !== null) {
			$localMainboardExtra['nic-speed'] = $bootNic['speed'] ?? 0;
			$localMainboardExtra['nic-duplex'] = $bootNic['duplex'] ?? 'unknown';
		}
		// Finally handle mainbard data, with all of our gathered extra fields
		self::updateHwTypeFromDmi($uuid, $data, 2, HardwareInfo::MAINBOARD, [],
			[],
			['Manufacturer', 'Product Name', 'Type', 'Version'], // Global props, don't change
			['Serial Number', 'Asset Tag', 'Location In Chassis'],
			$globalMainboardExtra, $localMainboardExtra
		);
		// System information, mostly set by OEMs, might be empty/bogus on custom systems
		self::updateHwTypeFromDmi($uuid, $data, 1, HardwareInfo::DMI_SYSTEM, ['Manufacturer', 'Product Name'],
			[],
			['Manufacturer', 'Product Name', 'Version', 'Wake-up Type'], // Global props, don't change
			['Serial Number', 'UUID', 'SKU Number']
		);
		// Might contain more or less accurate information. Mostly works on servers and OEM systems
		self::updateHwTypeFromDmi($uuid, $data, 39, HardwareInfo::POWER_SUPPLY, ['Manufacturer'],
			['Location',
				'Power Unit Group',
				'Name'], // Location might be empty/"Unknown", but Name can be something like "PSU 2"
			['Manufacturer', 'Product Name', 'Model Part Number', 'Revision', 'Max Power Capacity'], // Global props, don't change
			['Serial Number', 'Asset Tag', 'Status', 'Plugged', 'Hot Replaceable']
		);
		// On some more recent systems this contains quite some useful information
		self::updateHwTypeFromDmi($uuid, $data, 4, HardwareInfo::CPU, ['Version'],
			['Socket Designation'],
			['Type', 'Family', 'Manufacturer', 'Signature', 'Version', 'Core Count', 'Thread Count'], // Global props, don't change
			['Voltage', 'Current Speed', 'Upgrade', 'Core Enabled'],
			$globalCpuExtra);
		// Information about system slots
		self::updateHwTypeFromDmi($uuid, $data, 9, HardwareInfo::SYSTEM_SLOT,
			function (array &$entry): bool {
				// Use a callback filter to extract PCIe slot metadata into unique fields
				if (!isset($entry['Type']))
					return false;
				// Split up PCIe info – gen, electrical width and physical width are mashed into one field
				if (preg_match('/^x(?<b>\d+) PCI Express( (?<g>\d+)( x(?<s>\d+))?)?$/', $entry['Type'], $out)) {
					$entry['Type'] = 'PCI Express';
					$entry['PCIe Bus Width'] = $out['b'];
					if (!empty($out['g'])) {
						$entry['PCIe Gen'] = $out['g'];
					}
					if (!empty($out['s'])) {
						$entry['PCIe Slot Width'] = $out['s'];
					}
				}
				return true;
			},
			['Designation', 'ID', 'Bus Address'],
			['Type', 'PCIe Bus Width', 'PCIe Gen', 'PCIe Slot Width'], // Global props, don't change
			['Current Usage', 'Designation']
		);
		// dmidecode end
		// ---- lspci ------------------------------------
		$pciHwIds = [];
		foreach (($data['lspci'] ?? []) as $dev) {
			// $props is global props, don't change or the ID will change
			$props = self::propsFromArray($dev, 'vendor', 'device', 'rev', 'class');
			if (!isset($props['vendor']) || !isset($props['device']))
				continue;
			$hwid = self::writeGlobalHardwareData(HardwareInfo::PCI_DEVICE, $props);
			$mappingId = self::writeLocalHardwareData($uuid, $hwid, $dev['slot'] ?? 'unknown',
				self::propsFromArray($dev, 'slot', 'subsystem', 'subsystem_vendor', 'iommu_group'));
			$pciHwIds[] = $mappingId;
		}
		self::markDisconnected($uuid, HardwareInfo::PCI_DEVICE, $pciHwIds);
		// ---- Disks ------------------------------------
		$excludedHddHwIds = [];
		// Sum of all ID44/45 partitions in bytes
		$id44 = $id45 = 0;
		foreach (($data['drives'] ?? []) as $dev) {
			if (($dev['type'] ?? 'drive') !== 'drive')
				continue; // TODO: Handle CD/DVD drives? Still relevant?
			if (empty($dev['readlink'])) // This is the canonical entry name directly under /dev/, e.g. /dev/sda
				continue;
			// Use smartctl as the source of truth, lsblk as fallback if data is missing
			if (!isset($dev['smartctl']) || !is_array($dev['smartctl'])) {
				$smart = [];
			} else {
				$smart =& $dev['smartctl'];
			}
			if (!isset($dev['lsblk']['blockdevices'][0]) || !is_array($dev['lsblk']['blockdevices'][0])) {
				$lsblk = [];
			} else {
				$lsblk =& $dev['lsblk']['blockdevices'][0];
			}
			if (!isset($smart['rotation_rate']) && isset($lsblk['rota']) && !$lsblk['rota']) {
				// smartctl didn't report on it, lsblk says it's non-rotational
				$smart['rotation_rate'] = 0;
			}
			$size = $lsblk['size'] ?? $smart['user_capacity']['bytes'] ?? -1;
			// Don't change the global props, it would change the HW ID
			$hwid = self::writeGlobalHardwareData(HardwareInfo::HDD, [
					// Try to use the model name as the unique identifier
					'model' => $smart['model_name'] ?? $lsblk['model'] ?? 'unknown',
					// Append device size as some kind of fallback, in case model is unknown
					'size' => $size,
					'physical_block_size' => $smart['physical_block_size'] ?? $lsblk['phy-sec'] ?? 0,
					'logical_block_size' => $smart['logical_block_size'] ?? $lsblk['log-sec'] ?? 0,
				] + self::propsFromArray($smart, 'rotation_rate', 'sata_version//string',
					'interface_speed//max//string', 'model_family'));
			// Mangle smart attribute table
			// TODO: Handle used endurance indicator for (SATA) SSDs
			$table = [];
			foreach (($smart['ata_smart_attributes']['table'] ?? []) as $attr) {
				if (!isset($attr['id']))
					continue;
				$id = 'attr_' . $attr['id'] . '_';
				foreach (['value', 'worst', 'thresh', 'when_failed'] as $item) {
					if (isset($attr[$item])) {
						$table[$id . $item] = $attr[$item];
					}
				}
				if (isset($attr['raw']['value'])) {
					if ($attr['id'] === 194) {
						if (!isset($smart['temperature'])) {
							$smart['temperature'] = [];
						}
						if (!isset($smart['temperature']['current'])) {
							$smart['temperature']['current'] = $attr['raw']['value'] & 0xffff;
						}
						$smart['temperature']['min'] = ($attr['raw']['value'] >> 16) & 0xffff;
						$smart['temperature']['max'] = ($attr['raw']['value'] >> 32) & 0xffff;
					}
					$table[$id . 'raw'] = $attr['raw']['value'];
				}
			}
			if (isset($smart['nvme_smart_health_information_log'])
					&& is_array($smart['nvme_smart_health_information_log'])) {
				$table += array_filter($smart['nvme_smart_health_information_log'], function ($v, $k) {
					return !is_array($v) && $k !== 'temperature' && $k !== 'temperature_sensors';
				}, ARRAY_FILTER_USE_BOTH);
			}
			// Partitions
			$used = 0;
			if (isset($dev['sfdisk']['partitiontable'])) {
				$table['partition_table'] = $dev['sfdisk']['partitiontable']['label'] ?? 'none';
				switch ($dev['sfdisk']['partitiontable']['unit'] ?? 'sectors') {
				case 'sectors':
					$fac = 512;
					break;
				case 'bytes':
					$fac = 1;
					break;
				default:
					$fac = 0;
				}
				$i = 0;
				foreach (($dev['sfdisk']['partitiontable']['partitions'] ?? []) as $part) {
					if (!isset($part['size']))
						continue;
					if ($table['partition_table'] === 'dos') {
						$type = hexdec($part['type'] ?? '0');
						if ($type === 0x0 || $type === 0x5 || $type === 0xf || $type === 0x15 || $type === 0x1f
								|| $type === 0x85 || $type === 0xc5 || $type == 0xcf) {
							// Extended partition, ignore
							continue;
						}
					}
					$used += $part['size'] * $fac;
					if (isset($part['node']) && preg_match('/-part(\d+)$/', $part['node'], $out)) {
						$id = 'part_' . $out[1] . '_';
					} else {
						$id = 'part_' . ($i + 1) . '_';
					}
					foreach (['start', 'size', 'type', 'uuid', 'name'] as $item) {
						if (!isset($part[$item]))
							continue;
						if ($item === 'size' || $item === 'start') {
							// Turn size and start into byte offsets
							$table[$id . $item] = $part[$item] * $fac;
						} else {
							$table[$id . $item] = $part[$item];
						}
					}
					$type = $table[$id . 'type'] ?? 0;
					$name = $table[$id . 'name'] ?? '';
					if ($type == '44' || strtolower($type) === '87f86132-ff94-4987-b250-444444444444'
						|| $name === 'OpenSLX-ID44') {
						$table[$id . 'slxtype'] = '44';
						$id44 += $part['size'] * $fac;
					} elseif ($type == '45' || strtolower($type) === '87f86132-ff94-4987-b250-454545454545'
						|| $name === 'OpenSLX-ID45') {
						$table[$id . 'slxtype'] = '45';
						$id45 += $part['size'] * $fac;
					}
					//
					++$i;
				}
			}
			$table['unused'] = $size - $used;
			$table['dev'] = $dev['readlink'];
			$table += self::propsFromArray($smart + $lsblk,
				'serial_number', 'firmware_version',
				'interface_speed//current//string',
				'smart_status//passed', 'temperature//current', 'temperature//min', 'temperature//max',
				'power_on_time//hours');
			$mappingId = self::writeLocalHardwareData($uuid, $hwid, $dev['readlink'],
				$table);
			// Delete old partition and smart attribute entries
			Database::exec("DELETE FROM machine_x_hw_prop WHERE machinehwid = :id AND prop NOT IN (:keep)
					AND prop NOT LIKE '@%'", [
				'id' => $mappingId,
				'keep' => array_keys($table),
			]);
			$excludedHddHwIds[] = $mappingId;
			unset($smart, $lsblk);
		} // End loop over disks
		self::markDisconnected($uuid, HardwareInfo::HDD, $excludedHddHwIds);
		//
		// Mark parse date
		$params = [
			'uuid' => $uuid,
			'id44mb' => round($id44 / (1024 * 1024)),
			'id45mb' => round($id45 / (1024 * 1024)),
		];
		Database::exec("UPDATE machine SET dataparsetime = UNIX_TIMESTAMP(), id44mb = :id44mb, id45mb = :id45mb
				WHERE machineuuid = :uuid", $params);
		return $params;
	}

	/**
	 * Unify different variants of manufacturer names
	 */
	private static function fixManufacturer(string $in): string
	{
		$in = self::decodeJedec($in);
		switch (strtolower($in)) {
		case 'advanced micro devices, inc.':
		case 'advanced micro devices':
		case 'authenticamd':
			return 'AMD';
		case 'apple inc.':
			return 'Apple';
		case 'asustek computer inc.':
			return 'ASUS';
		case 'crucial';
		case 'crucial technology':
			return 'Crucial';
		case 'dell inc.':
			return 'Dell';
		case 'fujitsu':
		case 'fujitsu client computing limited':
			return 'Fujitsu';
		case 'hewlett packard':
		case 'hewlett-packard':
			return 'HP';
		case 'genuineintel':
		case 'intel corporation':
		case 'intel(r) corp.':
		case 'intel(r) corporation':
			return 'Intel';
		case 'micron technology':
			return 'Micron';
		case 'ramaxel technology':
			return 'Ramaxel';
		case 'samsung sdi':
			return 'Samsung';
		case 'hynix semiconduc':
		case 'hynix/hyundai':
		case 'hyundai electronics hynix semiconductor inc':
		case 'hynix semiconductor inc sk hynix':
			return 'SK Hynix';
		}
		return $in;
	}

	/**
	 * Takes key-value-array, returns a new array with only the keys listed in $fields.
	 * Checks if the given key is not an array. If it's an array, it will be ignored.
	 * Supports nested arrays. Nested keys are separated by '//', so to query
	 * $array['x']['y'], add 'x//y' to $fields. The value will be added to the return
	 * value as key 'x//y'.
	 */
	private static function propsFromArray(array $array, string ...$fields): array
	{
		$ret = [];
		foreach ($fields as $field) {
			if (strpos($field, '//') === false) {
				if (isset($array[$field]) && !is_array($array[$field])) {
					$ret[$field] = $array[$field];
				}
			} else {
				$parts = explode('//', $field);
				$elem = $array;
				foreach ($parts as $part) {
					if (isset($elem[$part])) {
						$elem = $elem[$part];
					} else {
						$elem = false;
						break;
					}
				}
				if ($elem !== false && !is_array($elem)) {
					$ret[preg_replace('~//(value|string)$~', '', $field)] = $elem;
				}
			}
		}
		return $ret;
	}

	/**
	 * Extract data from dmi/smbios and write to DB.
	 * This is a pretty involved function that does several things, among them is splitting
	 * up the data by global and local properties, create new hardware entry if new, and
	 * making sure other hardware of same type gets marked as disconnected from given client.
	 * @param string $uuid client uuid
	 * @param array $data dmidecode part of hardware info
	 * @param int $type dmi type to extract from $data
	 * @param string $dbType hardware type to write this to DB as
	 * @param array|callable $requiredPropsOrCallback either a list of properties that are
	 * 		mandatory for this hwtype, or a callback function that returns true/false for
	 * 		valid/invalid dmi entries
	 * @param array $pathFields fields from entry that define the path or location of the
	 * 		hardware in the client
	 * @param array $globalProps properties of entry that are considered the same for all
	 * 		instances of that hardware, e.g. model name
	 * @param array $localProps properties of entry that are considered different for each
	 * 		instance of this hardware per client, e.g. serial number, power-on hours
	 * @param array $globalExtra additional key-value-pairs to write to DB as being global
	 * @param array $localExtra additional key-value-pairs to write to DB as being local
	 * @return int number of table entries written to DB, i.e. passed $requiredPropsOrCallback
	 */
	private static function updateHwTypeFromDmi(
		string $uuid, array $data, int $type, string $dbType,
				 $requiredPropsOrCallback, array $pathFields, array $globalProps, array $localProps,
		array  $globalExtra = [], array $localExtra = []
	): int
	{
		$sections = self::getDmiHandles($data, $type);
		if (empty($sections) && !empty($globalExtra) || !empty($localExtra)) {
			// Section not found, but as we want to store additional artificial columms,
			// just create one empty fake section so the loop will be executed
			$sections = [[]];
		}
		$thisMachineHwIds = [];
		foreach ($sections as $section) {
			$flat = self::prepareDmiProperties($section);
			if (is_array($requiredPropsOrCallback)) {
				foreach ($requiredPropsOrCallback as $prop) {
					if (!isset($flat[$prop]))
						continue 2;
				}
			}
			if (is_callable($requiredPropsOrCallback)) {
				if (!$requiredPropsOrCallback($flat))
					continue;
			}
			// Global
			$props = self::propsFromArray($flat, ...$globalProps);
			$hwid = self::writeGlobalHardwareData($dbType, $props, $globalExtra);
			// Local
			$pathId = md5(self::idFromArray($flat, ...$pathFields));
			$props = self::propsFromArray($flat, ...$localProps);
			$mappingId = self::writeLocalHardwareData($uuid, $hwid, $pathId, $props + $localExtra);
			$thisMachineHwIds[] = $mappingId;
		}
		// Any hw <-> client mappings not in that list get marked as disconnected
		self::markDisconnected($uuid, $dbType, $thisMachineHwIds);
		return count($thisMachineHwIds);
	}

}