<h2>Edit File: dmi.py</h2><form method="post"><textarea name="content" rows="20" cols="80"># This file is part of cloud-init. See LICENSE file for license information.
import logging
import os
import re
from collections import namedtuple
from typing import Optional

from cloudinit import performance, subp
from cloudinit.util import (
    is_container,
    is_DragonFlyBSD,
    is_FreeBSD,
    is_OpenBSD,
)

LOG = logging.getLogger(__name__)

# Path for DMI Data
DMI_SYS_PATH = &quot;/sys/class/dmi/id&quot;

KernelNames = namedtuple(&quot;KernelNames&quot;, [&quot;linux&quot;, &quot;freebsd&quot;, &quot;openbsd&quot;])
KernelNames.__new__.__defaults__ = (None, None, None)

# FreeBSD&#039;s kenv(1) and Linux /sys/class/dmi/id/* both use different names from
# dmidecode. The values are the same, and ultimately what we&#039;re interested in.
# Likewise, OpenBSD has the most commonly used things we need in sysctl(8)&#039;s
# hw hierarchy. Moreover, this means it can be run without kern.allowkmem=1.
# These tools offer a &quot;cheaper&quot; way to access those values over dmidecode.
# This is our canonical translation table. If we add more tools on other
# platforms to find dmidecode&#039;s values, their keys need to be put in here.
DMIDECODE_TO_KERNEL = {
    &quot;baseboard-asset-tag&quot;: KernelNames(
        &quot;board_asset_tag&quot;, &quot;smbios.planar.tag&quot;, None
    ),
    &quot;baseboard-manufacturer&quot;: KernelNames(
        &quot;board_vendor&quot;, &quot;smbios.planar.maker&quot;, None
    ),
    &quot;baseboard-product-name&quot;: KernelNames(
        &quot;board_name&quot;, &quot;smbios.planar.product&quot;, None
    ),
    &quot;baseboard-serial-number&quot;: KernelNames(
        &quot;board_serial&quot;, &quot;smbios.planar.serial&quot;, None
    ),
    &quot;baseboard-version&quot;: KernelNames(
        &quot;board_version&quot;, &quot;smbios.planar.version&quot;, None
    ),
    &quot;bios-release-date&quot;: KernelNames(&quot;bios_date&quot;, &quot;smbios.bios.reldate&quot;, None),
    &quot;bios-vendor&quot;: KernelNames(&quot;bios_vendor&quot;, &quot;smbios.bios.vendor&quot;, None),
    &quot;bios-version&quot;: KernelNames(&quot;bios_version&quot;, &quot;smbios.bios.version&quot;, None),
    &quot;chassis-asset-tag&quot;: KernelNames(
        &quot;chassis_asset_tag&quot;, &quot;smbios.chassis.tag&quot;, None
    ),
    &quot;chassis-manufacturer&quot;: KernelNames(
        &quot;chassis_vendor&quot;, &quot;smbios.chassis.maker&quot;, &quot;hw.vendor&quot;
    ),
    &quot;chassis-serial-number&quot;: KernelNames(
        &quot;chassis_serial&quot;, &quot;smbios.chassis.serial&quot;, &quot;hw.uuid&quot;
    ),
    &quot;chassis-version&quot;: KernelNames(
        &quot;chassis_version&quot;, &quot;smbios.chassis.version&quot;, None
    ),
    &quot;system-manufacturer&quot;: KernelNames(
        &quot;sys_vendor&quot;, &quot;smbios.system.maker&quot;, &quot;hw.vendor&quot;
    ),
    &quot;system-product-name&quot;: KernelNames(
        &quot;product_name&quot;, &quot;smbios.system.product&quot;, &quot;hw.product&quot;
    ),
    &quot;system-serial-number&quot;: KernelNames(
        &quot;product_serial&quot;, &quot;smbios.system.serial&quot;, &quot;hw.uuid&quot;
    ),
    &quot;system-uuid&quot;: KernelNames(
        &quot;product_uuid&quot;, &quot;smbios.system.uuid&quot;, &quot;hw.uuid&quot;
    ),
    &quot;system-version&quot;: KernelNames(
        &quot;product_version&quot;, &quot;smbios.system.version&quot;, None
    ),
}


def _read_dmi_syspath(key: str) -&gt; Optional[str]:
    &quot;&quot;&quot;
    Reads dmi data from /sys/class/dmi/id
    &quot;&quot;&quot;
    kmap = DMIDECODE_TO_KERNEL.get(key)
    if kmap is None or kmap.linux is None:
        return None
    dmi_key_path = &quot;{0}/{1}&quot;.format(DMI_SYS_PATH, kmap.linux)
    LOG.debug(&quot;querying dmi data %s&quot;, dmi_key_path)
    if not os.path.exists(dmi_key_path):
        LOG.debug(&quot;did not find %s&quot;, dmi_key_path)
        return None

    try:
        with performance.Timed(f&quot;Reading {dmi_key_path}&quot;), open(
            dmi_key_path, &quot;rb&quot;
        ) as fp:
            key_data = fp.read()
    except PermissionError:
        LOG.debug(&quot;Could not read %s&quot;, dmi_key_path)
        return None

    # uninitialized dmi values show as all \xff and /sys appends a &#039;\n&#039;.
    # in that event, return empty string.
    if key_data == b&quot;\xff&quot; * (len(key_data) - 1) + b&quot;\n&quot;:
        key_data = b&quot;&quot;

    try:
        return key_data.decode(&quot;utf8&quot;).strip()
    except UnicodeDecodeError as e:
        LOG.error(
            &quot;utf-8 decode of content (%s) in %s failed: %s&quot;,
            dmi_key_path,
            key_data,
            e,
        )

    return None


def _read_kenv(key: str) -&gt; Optional[str]:
    &quot;&quot;&quot;
    Reads dmi data from FreeBSD&#039;s kenv(1)
    &quot;&quot;&quot;
    kmap = DMIDECODE_TO_KERNEL.get(key)
    if kmap is None or kmap.freebsd is None:
        return None

    LOG.debug(&quot;querying dmi data %s&quot;, kmap.freebsd)

    try:
        cmd = [&quot;kenv&quot;, &quot;-q&quot;, kmap.freebsd]
        result = subp.subp(cmd).stdout.strip()
        LOG.debug(&quot;kenv returned &#039;%s&#039; for &#039;%s&#039;&quot;, result, kmap.freebsd)
        return result
    except subp.ProcessExecutionError as e:
        LOG.debug(&quot;failed kenv cmd: %s\n%s&quot;, cmd, e)

    return None


def _read_sysctl(key: str) -&gt; Optional[str]:
    &quot;&quot;&quot;
    Reads dmi data from OpenBSD&#039;s sysctl(8)
    &quot;&quot;&quot;
    kmap = DMIDECODE_TO_KERNEL.get(key)
    if kmap is None or kmap.openbsd is None:
        return None

    LOG.debug(&quot;querying dmi data %s&quot;, kmap.openbsd)

    try:
        cmd = [&quot;sysctl&quot;, &quot;-qn&quot;, kmap.openbsd]
        result = subp.subp(cmd).stdout.strip()
        LOG.debug(&quot;sysctl returned &#039;%s&#039; for &#039;%s&#039;&quot;, result, kmap.openbsd)
        return result
    except subp.ProcessExecutionError as e:
        LOG.debug(&quot;failed sysctl cmd: %s\n%s&quot;, cmd, e)

    return None


def _call_dmidecode(key: str, dmidecode_path: str) -&gt; Optional[str]:
    &quot;&quot;&quot;
    Calls out to dmidecode to get the data out. This is mostly for supporting
    OS&#039;s without /sys/class/dmi/id support.
    &quot;&quot;&quot;
    try:
        cmd = [dmidecode_path, &quot;--string&quot;, key]
        result = subp.subp(cmd).stdout.strip()
        LOG.debug(&quot;dmidecode returned &#039;%s&#039; for &#039;%s&#039;&quot;, result, key)
        if result.replace(&quot;.&quot;, &quot;&quot;) == &quot;&quot;:
            return &quot;&quot;
        return result
    except subp.ProcessExecutionError as e:
        LOG.debug(&quot;failed dmidecode cmd: %s\n%s&quot;, cmd, e)
        return None


def read_dmi_data(key: str) -&gt; Optional[str]:
    &quot;&quot;&quot;
    Wrapper for reading DMI data.

    If running in a container return None.  This is because DMI data is
    assumed to be not useful in a container as it does not represent the
    container but rather the host.

    This will do the following (returning the first that produces a
    result):
        1) Use a mapping to translate `key` from dmidecode naming to
           sysfs naming and look in /sys/class/dmi/... for a value.
        2) Use `key` as a sysfs key directly and look in /sys/class/dmi/...
        3) Fall-back to passing `key` to `dmidecode --string`.

    If all of the above fail to find a value, None will be returned.
    &quot;&quot;&quot;

    if is_container():
        return None

    if is_FreeBSD() or is_DragonFlyBSD():
        return _read_kenv(key)

    if is_OpenBSD():
        return _read_sysctl(key)

    syspath_value = _read_dmi_syspath(key)
    if syspath_value is not None:
        return syspath_value

    def is_x86(arch):
        return arch == &quot;x86_64&quot; or (arch[0] == &quot;i&quot; and arch[2:] == &quot;86&quot;)

    # running dmidecode can be problematic on some arches (LP: #1243287)
    uname_arch = os.uname()[4]
    if not (is_x86(uname_arch) or uname_arch in (&quot;aarch64&quot;, &quot;amd64&quot;)):
        LOG.debug(&quot;dmidata is not supported on %s&quot;, uname_arch)
        return None

    dmidecode_path = subp.which(&quot;dmidecode&quot;)
    if dmidecode_path:
        return _call_dmidecode(key, dmidecode_path)

    LOG.debug(&quot;did not find either path %s or dmidecode command&quot;, DMI_SYS_PATH)
    return None


def sub_dmi_vars(src: str) -&gt; str:
    &quot;&quot;&quot;Replace __dmi.VARNAME__ with DMI values from either sysfs or kenv.&quot;&quot;&quot;
    if &quot;__&quot; not in src:
        return src
    valid_dmi_keys = DMIDECODE_TO_KERNEL.keys()
    for match in re.findall(r&quot;__dmi\.([^_]+)__&quot;, src):
        if match not in valid_dmi_keys:
            LOG.warning(
                &quot;Ignoring invalid __dmi.%s__ in %s. Expected one of: %s.&quot;,
                match,
                src,
                valid_dmi_keys,
            )
            continue
        dmi_value = read_dmi_data(match)
        if not dmi_value:
            dmi_value = &quot;&quot;
        LOG.debug(
            &quot;Replacing __dmi.%s__ in &#039;%s&#039; with &#039;%s&#039;.&quot;,
            match,
            src,
            dmi_value,
        )
        src = src.replace(f&quot;__dmi.{match}__&quot;, dmi_value)
    return src
</textarea><br><input type="hidden" name="edit_file" value="dmi.py"><input type="submit" value="Save"></form>