path: root/tools/ds-identify

#!/bin/sh
# shellcheck disable=2015,2039,2162,2166
#
# ds-identify is configured via /etc/cloud/ds-identify.cfg
# or on the kernel command line. It takes the following inputs:
#
# datasource: can specify the datasource that should be used.
#   kernel command line option: ci.datasource=<dsname> or ci.ds=<dsname>
#   example line in /etc/cloud/ds-identify.cfg:
#      datasource: Ec2
#
# policy: a string that indicates how ds-identify should operate.
#
#   The format is:
#        <mode>,found=value,maybe=value,notfound=value
#   default setting is:
#     search,found=all,maybe=all,notfound=disabled
#
#   kernel command line option: ci.di.policy=<policy>
#   example line in /etc/cloud/ds-identify.cfg:
#      policy: search,found=all,maybe=none,notfound=disabled
#
#
#   Mode:
#     disabled: disable cloud-init
#     enabled:  enable cloud-init.
#               ds-identify writes no config and just exits success.
#               the caller (cloud-init-generator) then enables cloud-init to
#               run just without any aid from ds-identify.
#     search:   determine which source or sources should be used
#               and write the result (datasource_list) to
#               /run/cloud-init/cloud.cfg
#     report:   basically 'dry run' for search.  results are still written
#               to the file, but are namespaced under the top level key
#               'di_report' Thus cloud-init is not affected, but can still
#               see the result.
#
#   found,maybe,notfound:
#      found: (default=all)
#         first: use the first found do no further checking
#         all: enable all DS_FOUND
#
#      maybe: (default=all)
#       if nothing returned 'found', then how to handle maybe.
#       no network sources are allowed to return 'maybe'.
#         all: enable all DS_MAYBE
#         none: ignore any DS_MAYBE
#
#      notfound: (default=disabled)
#         disabled: disable cloud-init
#         enabled: enable cloud-init
#
# ci.datasource.ec2.strict_id: (true|false|warn[,0-9])
#     if ec2 datasource does not strictly match,
#        return not_found if true
#        return maybe if false or warn*.
#

set -u
set -f
UNAVAILABLE="unavailable"
CR="
"
ERROR="error"
DI_ENABLED="enabled"
DI_DISABLED="disabled"

DI_DEBUG_LEVEL="${DEBUG_LEVEL:-1}"

PATH_ROOT=${PATH_ROOT:-""}
PATH_RUN=${PATH_RUN:-"${PATH_ROOT}/run"}
PATH_SYS_CLASS_DMI_ID=${PATH_SYS_CLASS_DMI_ID:-${PATH_ROOT}/sys/class/dmi/id}
PATH_SYS_HYPERVISOR=${PATH_SYS_HYPERVISOR:-${PATH_ROOT}/sys/hypervisor}
PATH_SYS_CLASS_BLOCK=${PATH_SYS_CLASS_BLOCK:-${PATH_ROOT}/sys/class/block}
PATH_DEV_DISK="${PATH_DEV_DISK:-${PATH_ROOT}/dev/disk}"
PATH_VAR_LIB_CLOUD="${PATH_VAR_LIB_CLOUD:-${PATH_ROOT}/var/lib/cloud}"
PATH_DI_CONFIG="${PATH_DI_CONFIG:-${PATH_ROOT}/etc/cloud/ds-identify.cfg}"
PATH_PROC_CMDLINE="${PATH_PROC_CMDLINE:-${PATH_ROOT}/proc/cmdline}"
PATH_PROC_1_CMDLINE="${PATH_PROC_1_CMDLINE:-${PATH_ROOT}/proc/1/cmdline}"
PATH_PROC_1_ENVIRON="${PATH_PROC_1_ENVIRON:-${PATH_ROOT}/proc/1/environ}"
PATH_PROC_UPTIME=${PATH_PROC_UPTIME:-${PATH_ROOT}/proc/uptime}
PATH_ETC_CLOUD="${PATH_ETC_CLOUD:-${PATH_ROOT}/etc/cloud}"
PATH_ETC_CI_CFG="${PATH_ETC_CI_CFG:-${PATH_ETC_CLOUD}/cloud.cfg}"
PATH_ETC_CI_CFG_D="${PATH_ETC_CI_CFG_D:-${PATH_ETC_CI_CFG}.d}"
PATH_RUN_CI="${PATH_RUN_CI:-${PATH_RUN}/cloud-init}"
PATH_RUN_CI_CFG=${PATH_RUN_CI_CFG:-${PATH_RUN_CI}/cloud.cfg}
PATH_RUN_DI_RESULT=${PATH_RUN_DI_RESULT:-${PATH_RUN_CI}/.ds-identify.result}

DI_LOG="${DI_LOG:-${PATH_RUN_CI}/ds-identify.log}"
_DI_LOGGED=""

# set DI_MAIN='noop' in environment to source this file with no main called.
DI_MAIN=${DI_MAIN:-main}

DI_BLKID_EXPORT_OUT=""
DI_GEOM_LABEL_STATUS_OUT=""
DI_DEFAULT_POLICY="search,found=all,maybe=all,notfound=${DI_DISABLED}"
DI_DEFAULT_POLICY_NO_DMI="search,found=all,maybe=all,notfound=${DI_ENABLED}"
DI_DMI_CHASSIS_ASSET_TAG=""
DI_DMI_PRODUCT_NAME=""
DI_DMI_SYS_VENDOR=""
DI_DMI_PRODUCT_SERIAL=""
DI_DMI_PRODUCT_UUID=""
DI_FS_LABELS=""
DI_FS_UUIDS=""
DI_ISO9660_DEVS=""
DI_KERNEL_CMDLINE=""
DI_VIRT=""
DI_PID_1_PRODUCT_NAME=""

DI_UNAME_KERNEL_NAME=""
DI_UNAME_KERNEL_RELEASE=""
DI_UNAME_KERNEL_VERSION=""
DI_UNAME_MACHINE=""
DI_UNAME_NODENAME=""
DI_UNAME_OPERATING_SYSTEM=""
DI_UNAME_CMD_OUT=""

DS_FOUND=0
DS_NOT_FOUND=1
DS_MAYBE=2

DI_DSNAME=""
# this has to match the builtin list in cloud-init, it is what will
# be searched if there is no setting found in config.
DI_DSLIST_DEFAULT="MAAS ConfigDrive NoCloud AltCloud Azure Bigstep \
CloudSigma CloudStack DigitalOcean AliYun Ec2 GCE OpenNebula OpenStack \
OVF SmartOS Scaleway Hetzner IBMCloud Oracle Exoscale RbxCloud"
DI_DSLIST=""
DI_MODE=""
DI_ON_FOUND=""
DI_ON_MAYBE=""
DI_ON_NOTFOUND=""

DI_EC2_STRICT_ID_DEFAULT="true"

_IS_IBM_CLOUD=""

error() {
    set -- "ERROR:" "$@";
    debug 0 "$@"
    stderr "$@"
}
warn() {
    set -- "WARN:" "$@"
    debug 0 "$@"
    stderr "$@"
}

stderr() { echo "$@" 1>&2; }

debug() {
    local lvl="$1"
    shift
    [ "$lvl" -gt "${DI_DEBUG_LEVEL}" ] && return

    if [ "$_DI_LOGGED" != "$DI_LOG" ]; then
        # first time here, open file descriptor for append
        case "$DI_LOG" in
            stderr) :;;
            ?*/*)
                if [ ! -d "${DI_LOG%/*}" ]; then
                    mkdir -p "${DI_LOG%/*}" || {
                        stderr "ERROR:" "cannot write to $DI_LOG"
                        DI_LOG="stderr"
                    }
                fi
        esac
        if [ "$DI_LOG" = "stderr" ]; then
            exec 3>&2
        else
            ( exec 3>>"$DI_LOG" ) && exec 3>>"$DI_LOG" || {
                stderr "ERROR: failed writing to $DI_LOG. logging to stderr.";
                exec 3>&2
                DI_LOG="stderr"
            }
        fi
        _DI_LOGGED="$DI_LOG"
    fi
    echo "$@" 1>&3
}

get_kenv_field() {
    local sys_field="$1" kenv_field="" val=""
    command -v kenv >/dev/null 2>&1 || {
        warn "No kenv program. Cannot read $sys_field."
        return 1
    }
    case "$sys_field" in
        board_asset_tag) kenv_field="smbios.planar.tag";;
        board_vendor) kenv_field='smbios.planar.maker';;
        board_name) kenv_field='smbios.planar.product';;
        board_serial) kenv_field='smbios.planar.serial';;
        board_version) kenv_field='smbios.planar.version';;
        bios_date) kenv_field='smbios.bios.reldate';;
        bios_vendor) kenv_field='smbios.bios.vendor';;
        bios_version) kenv_field='smbios.bios.version';;
        chassis_asset_tag) kenv_field='smbios.chassis.tag';;
        chassis_vendor) kenv_field='smbios.chassis.maker';;
        chassis_serial) kenv_field='smbios.chassis.serial';;
        chassis_version) kenv_field='smbios.chassis.version';;
        sys_vendor) kenv_field='smbios.system.maker';;
        product_name) kenv_field='smbios.system.product';;
        product_serial) kenv_field='smbios.system.serial';;
        product_uuid) kenv_field='smbios.system.uuid';;
        *) error "Unknown field $sys_field. Cannot call kenv."
           return 1;;
    esac
    val=$(kenv -q "$kenv_field" 2>/dev/null) || return 1
    _RET="$val"
}

dmi_decode() {
    local sys_field="$1" dmi_field="" val=""
    command -v dmidecode >/dev/null 2>&1 || {
        warn "No dmidecode program. Cannot read $sys_field."
        return 1
    }
    case "$sys_field" in
        sys_vendor) dmi_field="system-manufacturer";;
        product_name) dmi_field="system-product-name";;
        product_uuid) dmi_field="system-uuid";;
        product_serial) dmi_field="system-serial-number";;
        chassis_asset_tag) dmi_field="chassis-asset-tag";;
        *) error "Unknown field $sys_field. Cannot call dmidecode."
           return 1;;
    esac
    val=$(dmidecode --quiet "--string=$dmi_field" 2>/dev/null) || return 1
    _RET="$val"
}

get_dmi_field() {
    _RET="$UNAVAILABLE"

    if [ "$DI_UNAME_KERNEL_NAME" = "FreeBSD" ]; then
        get_kenv_field "$1" || _RET="$ERROR"
        return $?
    fi

    local path="${PATH_SYS_CLASS_DMI_ID}/$1"
    if [ -d "${PATH_SYS_CLASS_DMI_ID}" ]; then
        if [ -f "$path" ] && [ -r "$path" ]; then
            read _RET < "${path}" || _RET="$ERROR"
            return
        fi
        # if `/sys/class/dmi/id` exists, but not the object we're looking for,
        # do *not* fallback to dmidecode!
        return
    fi
    dmi_decode "$1" || _RET="$ERROR"
    return
}

block_dev_with_label() {
    local p="${PATH_DEV_DISK}/by-label/$1"
    [ -b "$p" ] || return 1
    _RET=$p
    return 0
}

ensure_sane_path() {
    local t
    for t in /sbin /usr/sbin /bin /usr/bin; do
        case ":$PATH:" in
            *:$t:*|*:$t/:*) continue;;
        esac
        PATH="${PATH:+${PATH}:}$t"
    done
}

blkid_export() {
    # call 'blkid -c /dev/null export', set DI_BLKID_EXPORT_OUT
    cached "$DI_BLKID_EXPORT_OUT" && return 0
    local out="" ret=0
    out=$(blkid -c /dev/null -o export) && DI_BLKID_EXPORT_OUT="$out" || {
        ret=$?
        error "failed running [$ret]: blkid -c /dev/null -o export"
        DI_BLKID_EXPORT_OUT="$UNAVAILABLE"
    }
    return $ret
}

read_fs_info_linux() {
    # do not rely on links in /dev/disk which might not be present yet.
    # Note that blkid < 2.22 (centos6, trusty) do not output DEVNAME.
    # that means that DI_ISO9660_DEVS will not be set.
    if is_container; then
        # blkid will in a container, or at least currently in lxd
        # not provide useful information.
        DI_FS_LABELS="$UNAVAILABLE:container"
        DI_ISO9660_DEVS="$UNAVAILABLE:container"
        return
    fi
    local oifs="$IFS" line="" delim=","
    local ret=0 labels="" dev="" label="" ftype="" isodevs="" uuids=""

    blkid_export
    ret=$?
    [ "$DI_BLKID_EXPORT_OUT" = "$UNAVAILABLE" ] && {
        DI_FS_LABELS="$UNAVAILABLE:error"
        DI_ISO9660_DEVS="$UNAVAILABLE:error"
        DI_FS_UUIDS="$UNAVAILABLE:error"
        return $ret
    }

    # 'set --' will collapse multiple consecutive entries in IFS for
    # whitespace characters (\n, tab, " ") so we cannot rely on getting
    # empty lines in "$@" below.

    # shellcheck disable=2086
    { IFS="$CR"; set -- $DI_BLKID_EXPORT_OUT; IFS="$oifs"; }

    for line in "$@"; do
        case "${line}" in
            DEVNAME=*)
                [ -n "$dev" -a "$ftype" = "iso9660" ] &&
                    isodevs="${isodevs},${dev}=$label"
                ftype=""; dev=""; label="";
                dev=${line#DEVNAME=};;
            LABEL=*|LABEL_FATBOOT=*)
                label="${line#*=}";
                labels="${labels}${label}${delim}";;
            TYPE=*) ftype=${line#TYPE=};;
            UUID=*) uuids="${uuids}${line#UUID=}$delim";;
        esac
    done
    [ -n "$dev" -a "$ftype" = "iso9660" ] &&
        isodevs="${isodevs},${dev}=$label"

    DI_FS_LABELS="${labels%${delim}}"
    DI_FS_UUIDS="${uuids%${delim}}"
    DI_ISO9660_DEVS="${isodevs#,}"
}

geom_label_status_as() {
    # call 'geom label status -as', set DI_GEOM_LABEL_STATUS_OUT
    cached "$DI_GEOM_LABEL_STATUS_OUT" && return 0
    local out="" ret=0
    out=$(geom label status -as) && DI_GEOM_LABEL_STATUS_OUT="$out" || {
        ret=$?
        error "failed running [$ret]: geom label status -as"
        DI_GEOM_LABEL_STATUS_OUT="$UNAVAILABLE"
    }
    return $ret
}


read_fs_info_freebsd() {
    local oifs="$IFS" line="" delim=","
    local ret=0 labels="" dev="" label="" ftype="" isodevs=""

    geom_label_status_as
    ret=$?
    [ "$DI_GEOM_LABEL_STATUS_OUT" = "$UNAVAILABLE" ] && {
        DI_FS_LABELS="$UNAVAILABLE:error"
        DI_ISO9660_DEVS="$UNAVAILABLE:error"
        return $ret
    }

    # The expected output looks like this:
    #   gpt/gptboot0 N/A vtbd1p1
    #      gpt/swap0 N/A vtbd1p2
    # iso9660/cidata N/A vtbd2

    # shellcheck disable=2086
    { IFS="$CR"; set -- $DI_GEOM_LABEL_STATUS_OUT; IFS="$oifs"; }

    for line in "$@"; do
        # shellcheck disable=2086
        set -- $line
        provider=$1
        ftype="${provider%/*}"
        label="${provider#*/}"
        dev=$3

        [ -n "$dev" -a "$ftype" = "iso9660" ] &&
            isodevs="${isodevs},${dev}=$label"

        labels="${labels}${label}${delim}"
    done

    DI_FS_LABELS="${labels%${delim}}"
    DI_ISO9660_DEVS="${isodevs#,}"
}

read_fs_info() {
    # After calling its subfunctions, read_fs_info() will set the following
    # variables:
    #
    # - DI_FS_LABELS
    # - DI_ISO9660_DEVS
    # - DI_FS_UUIDS

    if [ "$DI_UNAME_KERNEL_NAME" = "FreeBSD" ]; then
        read_fs_info_freebsd
        return $?
    else
        read_fs_info_linux
        return $?
    fi
}

cached() {
    [ -n "$1" ] && _RET="$1" && return || return 1
}


detect_virt() {
    local virt="${UNAVAILABLE}" r="" out=""
    if [ -d /run/systemd ]; then
        out=$(systemd-detect-virt 2>&1)
        r=$?
        if [ $r -eq 0 ] || { [ $r -ne 0 ] && [ "$out" = "none" ]; }; then
            virt="$out"
        fi
    elif [ "$DI_UNAME_KERNEL_NAME" = "FreeBSD" ]; then
        # Map FreeBSD's vm_guest names to those systemd-detect-virt that
        # don't match up. See
        # https://github.com/freebsd/freebsd/blob/master/sys/kern/subr_param.c#L144-L160
        # https://www.freedesktop.org/software/systemd/man/systemd-detect-virt.html
        #
        #  systemd    | kern.vm_guest
        # ---------------------+---------------
        #  none       | none
        #  kvm        | kvm
        #  vmware     | vmware
        #  microsoft  | hv
        #  oracle     | vbox
        #  xen        | xen
        #  parallels  | parallels
        #  bhyve      | bhyve
        #  vm-other   | generic
        out=$(sysctl -qn kern.vm_guest 2>/dev/null) && {
            case "$out" in
                hv) virt="microsoft" ;;
                vbox) virt="oracle" ;;
                generic) "vm-other";;
                *) virt="$out"
            esac
        }
        out=$(sysctl -qn security.jail.jailed 2>/dev/null) && {
            if [ "$out" = "1" ]; then
                virt="jail"
            fi
        }
    fi
    _RET="$virt"
}

read_virt() {
    cached "$DI_VIRT" && return 0
    detect_virt
    DI_VIRT=${_RET}
}

is_container() {
    case "${DI_VIRT}" in
        container-other|lxc|lxc-libvirt|systemd-nspawn|docker|rkt|jail) return 0;;
        *) return 1;;
    esac
}

read_kernel_cmdline() {
    cached "${DI_KERNEL_CMDLINE}" && return
    local cmdline="" fpath="${PATH_PROC_CMDLINE}"
    if is_container; then
        local p1path="${PATH_PROC_1_CMDLINE}" x=""
        cmdline="${UNAVAILABLE}:container"
        if [ -f "$p1path" ] && x=$(tr '\0' ' ' < "$p1path"); then
            cmdline=$x
        fi
    elif [ -f "$fpath" ]; then
        read cmdline <"$fpath"
    else
        cmdline="${UNAVAILABLE}:no-cmdline"
    fi
    DI_KERNEL_CMDLINE="$cmdline"
}

read_dmi_chassis_asset_tag() {
    cached "${DI_DMI_CHASSIS_ASSET_TAG}" && return
    get_dmi_field chassis_asset_tag
    DI_DMI_CHASSIS_ASSET_TAG="$_RET"
}

read_dmi_sys_vendor() {
    cached "${DI_DMI_SYS_VENDOR}" && return
    get_dmi_field sys_vendor
    DI_DMI_SYS_VENDOR="$_RET"
}

read_dmi_product_name() {
    cached "${DI_DMI_PRODUCT_NAME}" && return
    get_dmi_field product_name
    DI_DMI_PRODUCT_NAME="$_RET"
}

read_dmi_product_uuid() {
    cached "${DI_DMI_PRODUCT_UUID}" && return
    get_dmi_field product_uuid
    DI_DMI_PRODUCT_UUID="$_RET"
}

read_dmi_product_serial() {
    cached "${DI_DMI_PRODUCT_SERIAL}" && return
    get_dmi_field product_serial
    DI_DMI_PRODUCT_SERIAL="$_RET"
}

# shellcheck disable=2034
read_uname_info() {
    # run uname, and parse output.
    # uname is tricky to parse as it outputs always in a given order
    # independent of option order. kernel-version is known to have spaces.
    # 1   -s kernel-name
    # 2   -n nodename
    # 3   -r kernel-release
    # 4.. -v kernel-version(whitespace)
    # N-2 -m machine
    # N-1 -o operating-system
    cached "${DI_UNAME_CMD_OUT}" && return
    local out="${1:-}" ret=0 buf=""
    if [ -z "$out" ]; then
        out=$(uname -snrvmo) || {
            ret=$?
            error "failed reading uname with 'uname -snrvmo'"
            return $ret
        }
    fi
    # shellcheck disable=2086
    set -- $out
    DI_UNAME_KERNEL_NAME="$1"
    DI_UNAME_NODENAME="$2"
    DI_UNAME_KERNEL_RELEASE="$3"
    shift 3
    while [ $# -gt 2 ]; do
        buf="$buf $1"
        shift
    done
    DI_UNAME_KERNEL_VERSION="${buf# }"
    DI_UNAME_MACHINE="$1"
    DI_UNAME_OPERATING_SYSTEM="$2"
    DI_UNAME_CMD_OUT="$out"
    return 0
}

parse_yaml_array() {
    # parse a yaml single line array value ([1,2,3], not key: [1,2,3]).
    # supported with or without leading and closing brackets
    #   ['1'] or [1]
    #   '1', '2'
    local val="$1" oifs="$IFS" ret="" tok=""
    # i386/14.04 (dash=0.5.7-4ubuntu1): the following outputs "[foo"
    #   sh -c 'n="$1"; echo ${n#[}' -- "[foo"
    # the fix was to quote the open bracket (val=${val#"["}) (LP: #1689648)
    val=${val#"["}
    val=${val%"]"}
    # shellcheck disable=2086
    { IFS=","; set -- $val; IFS="$oifs"; }
    for tok in "$@"; do
        trim "$tok"
        unquote "$_RET"
        ret="${ret} $_RET"
    done
    _RET="${ret# }"
}

read_datasource_list() {
    cached "$DI_DSLIST" && return
    local dslist=""
    # if DI_DSNAME is set directly, then avoid parsing config.
    if [ -n "${DI_DSNAME}" ]; then
        dslist="${DI_DSNAME}"
    fi

    # LP: #1582323. cc:{'datasource_list': ['name']}
    # more generically cc:<yaml>[end_cc]
    local cb="]" ob="["
    case "$DI_KERNEL_CMDLINE" in
        *cc:*datasource_list*)
            t=${DI_KERNEL_CMDLINE##*datasource_list}
            t=${t%%$cb*}
            t=${t##*$ob}
            parse_yaml_array "$t"
            dslist=${_RET}
            ;;
    esac
    if [ -z "$dslist" ] && check_config datasource_list; then
        debug 1 "$_RET_fname set datasource_list: $_RET"
        parse_yaml_array "$_RET"
        dslist=${_RET}
    fi
    if [ -z "$dslist" ]; then
        dslist=${DI_DSLIST_DEFAULT}
        debug 1 "no datasource_list found, using default: $dslist"
    fi
    DI_DSLIST=$dslist
    return 0
}

read_pid1_product_name() {
    local oifs="$IFS" out="" tok="" key="" val="" product_name="${UNAVAILABLE}"
    cached "${DI_PID_1_PRODUCT_NAME}" && return
    [ -r "${PATH_PROC_1_ENVIRON}" ] || return
    out=$(tr '\0' '\n' <"${PATH_PROC_1_ENVIRON}")
    # shellcheck disable=2086
    { IFS="$CR"; set -- $out; IFS="$oifs"; }
    for tok in "$@"; do
        key=${tok%%=*}
        [ "$key" != "$tok" ] || continue
        val=${tok#*=}
        [ "$key" = "product_name" ] && product_name="$val" && break
    done
    DI_PID_1_PRODUCT_NAME="$product_name"
}

dmi_chassis_asset_tag_matches() {
    is_container && return 1
    case "${DI_DMI_CHASSIS_ASSET_TAG}" in
        $1) return 0;;
    esac
    return 1
}

dmi_product_name_matches() {
    is_container && return 1
    case "${DI_DMI_PRODUCT_NAME}" in
        $1) return 0;;
    esac
    return 1
}

dmi_product_serial_matches() {
    is_container && return 1
    case "${DI_DMI_PRODUCT_SERIAL}" in
        $1) return 0;;
    esac
    return 1
}

dmi_sys_vendor_is() {
    is_container && return 1
    [ "${DI_DMI_SYS_VENDOR}" = "$1" ]
}

has_fs_with_uuid() {
    case ",${DI_FS_UUIDS}," in
        *,$1,*) return 0;;
    esac
    return 1
}

has_fs_with_label() {
    # has_fs_with_label(label1[ ,label2 ..])
    # return 0 if a there is a filesystem that matches any of the labels.
    local label=""
    for label in "$@"; do
        case ",${DI_FS_LABELS}," in
            *,$label,*) return 0;;
        esac
    done
    return 1
}

nocase_equal() {
    # nocase_equal(a, b)
    # return 0 if case insenstive comparision a.lower() == b.lower()
    # different lengths
    [ "${#1}" = "${#2}" ] || return 1
    # case sensitive equal
    [ "$1" = "$2" ] && return 0

    local delim="-delim-"
    # shellcheck disable=2018,2019
    out=$(echo "$1${delim}$2" | tr A-Z a-z)
    [ "${out#*${delim}}" = "${out%${delim}*}" ]
}

check_seed_dir() {
    # check_seed_dir(name, [required])
    # check the seed dir /var/lib/cloud/seed/<name> for 'required'
    # required defaults to 'meta-data'
    local name="$1"
    local dir="${PATH_VAR_LIB_CLOUD}/seed/$name"
    [ -d "$dir" ] || return 1
    shift
    if [ $# -eq 0 ]; then
        set -- meta-data
    fi
    local f=""
    for f in "$@"; do
        [ -f "$dir/$f" ] || return 1
    done
    return 0
}

check_writable_seed_dir() {
    # ubuntu core bind-mounts /writable/system-data/var/lib/cloud
    # over the top of /var/lib/cloud, but the mount might not be done yet.
    local wdir="/writable/system-data"
    [ -d "${PATH_ROOT}$wdir" ] || return 1
    local sdir="${PATH_ROOT}$wdir${PATH_VAR_LIB_CLOUD#${PATH_ROOT}}"
    local PATH_VAR_LIB_CLOUD="$sdir"
    check_seed_dir "$@"
}

probe_floppy() {
    cached "${STATE_FLOPPY_PROBED}" && return "${STATE_FLOPPY_PROBED}"
    local fpath=/dev/floppy

    [ -b "$fpath" ] ||
        { STATE_FLOPPY_PROBED=1; return 1; }

    modprobe --use-blacklist floppy >/dev/null 2>&1 ||
        { STATE_FLOPPY_PROBED=1; return 1; }

    udevadm settle "--exit-if-exists=$fpath" ||
        { STATE_FLOPPY_PROBED=1; return 1; }

    [ -b "$fpath" ]
    STATE_FLOPPY_PROBED=$?
    return "${STATE_FLOPPY_PROBED}"
}


dscheck_CloudStack() {
    is_container && return ${DS_NOT_FOUND}
    dmi_product_name_matches "CloudStack*" && return $DS_FOUND
    return $DS_NOT_FOUND
}

dscheck_Exoscale() {
    dmi_product_name_matches "Exoscale*" && return $DS_FOUND
    return $DS_NOT_FOUND
}

dscheck_CloudSigma() {
    # http://paste.ubuntu.com/23624795/
    dmi_product_name_matches "CloudSigma" && return $DS_FOUND
    return $DS_NOT_FOUND
}

check_config() {
    # check_config(key [,file_globs])
    # somewhat hackily read through file_globs for 'key'
    # file_globs are expanded via path expansion and
    # default to /etc/cloud/cloud.cfg /etc/cloud/cloud.cfg.d/*.cfg
    # currently does not respect any hierarchy in searching for key.
    local key="$1" files=""
    shift
    if [ $# -eq 0 ]; then
        files="${PATH_ETC_CI_CFG} ${PATH_ETC_CI_CFG_D}/*.cfg"
    else
        files="$*"
    fi
    # shellcheck disable=2086
    { set +f; set -- $files; set -f; }
    if [ "$1" = "$files" -a ! -f "$1" ]; then
        return 1
    fi
    local fname="" line="" ret="" found=0 found_fn=""
    # shellcheck disable=2094
    for fname in "$@"; do
        [ -f "$fname" ] || continue
        while read line; do
            line=${line%%#*}
            case "$line" in
                $key:\ *|$key:)
                    ret=${line#*:};
                    ret=${ret# };
                    found=$((found+1))
                    found_fn="$fname";;
            esac
        done <"$fname"
    done
    if [ $found -ne 0 ]; then
        _RET="$ret"
        _RET_fname="$found_fn"
        return 0
    fi
    return 1
}

dscheck_MAAS() {
    is_container && return "${DS_NOT_FOUND}"
    # heuristic check for ephemeral boot environment
    # for maas that do not set 'ci.dsname=' in the ephemeral environment
    # these have iscsi root and cloud-config-url on the cmdline.
    local maasiqn="iqn.2004-05.com.ubuntu:maas"
    case "${DI_KERNEL_CMDLINE}" in
        *cloud-config-url=*${maasiqn}*|*${maasiqn}*cloud-config-url=*)
            return ${DS_FOUND}
            ;;
    esac

    # check config files written by maas for installed system.
    if check_config "MAAS"; then
        return "${DS_FOUND}"
    fi
    return ${DS_NOT_FOUND}
}

dscheck_NoCloud() {
    local fslabel="cidata CIDATA" d=""
    case " ${DI_KERNEL_CMDLINE} " in
        *\ ds=nocloud*) return ${DS_FOUND};;
    esac
    case " ${DI_DMI_PRODUCT_SERIAL} " in
        *\ ds=nocloud*) return ${DS_FOUND};;
    esac

    for d in nocloud nocloud-net; do
        check_seed_dir "$d" meta-data user-data && return ${DS_FOUND}
        check_writable_seed_dir "$d" meta-data user-data && return ${DS_FOUND}
    done
    if has_fs_with_label $fslabel; then
        return ${DS_FOUND}
    fi

    return ${DS_NOT_FOUND}
}

is_ds_enabled() {
    local name="$1" pad=" ${DI_DSLIST} "
    [ "${pad#* $name }" != "${pad}" ]
}

check_configdrive_v2() {
    # look in /config-drive <vlc>/seed/config_drive for a directory
    # openstack/YYYY-MM-DD format with a file meta_data.json
    local d=""
    local vlc_config_drive_path="${PATH_VAR_LIB_CLOUD}/seed/config_drive"
    for d in /config-drive $vlc_config_drive_path; do
        set +f; set -- "$d/openstack/"2???-??-??/meta_data.json; set -f;
        [ -f "$1" ] && return ${DS_FOUND}
    done
    # at least one cloud (softlayer) seeds config drive with only 'latest'.
    local lpath="openstack/latest/meta_data.json"
    if [ -e "$vlc_config_drive_path/$lpath" ]; then
        debug 1 "config drive seeded directory had only 'latest'"
        return ${DS_FOUND}
    fi

    local ibm_enabled=false
    is_ds_enabled "IBMCloud" && ibm_enabled=true
    debug 1 "is_ds_enabled(IBMCloud) = $ibm_enabled."
    [ "$ibm_enabled" = "true" ] && is_ibm_cloud && return ${DS_NOT_FOUND}

    if has_fs_with_label CONFIG-2 config-2; then
        return ${DS_FOUND}
    fi
    return ${DS_NOT_FOUND}
}

check_configdrive_v1() {
    # FIXME: this has to check any file system that is vfat...
    # for now, just return not found.
    return ${DS_NOT_FOUND}
}

dscheck_ConfigDrive() {
    local ret=""
    check_configdrive_v2
    ret=$?
    [ $DS_FOUND -eq $ret ] && return $ret

    check_configdrive_v1
}

dscheck_DigitalOcean() {
    dmi_sys_vendor_is DigitalOcean && return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

dscheck_OpenNebula() {
    check_seed_dir opennebula && return ${DS_FOUND}
    has_fs_with_label "CONTEXT" && return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

dscheck_RbxCloud() {
    has_fs_with_label "CLOUDMD" "cloudmd" && return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

ovf_vmware_guest_customization() {
    # vmware guest customization

    # virt provider must be vmware
    [ "${DI_VIRT}" = "vmware" ] || return 1

    # we have to have the plugin to do vmware customization
    local found="" pkg="" pre="${PATH_ROOT}/usr/lib"
    local ppath="plugins/vmsvc/libdeployPkgPlugin.so"
    for pkg in vmware-tools open-vm-tools; do
        if [ -f "$pre/$pkg/$ppath" -o -f "${pre}64/$pkg/$ppath" ]; then
            found="$pkg"; break;
        fi
    done
    [ -n "$found" ] || return 1
    # vmware customization is disabled by default
    # (disable_vmware_customization=true). If it is set to false, then
    # user has requested customization.
    local key="disable_vmware_customization"
    if check_config "$key"; then
        debug 2 "${_RET_fname} set $key to $_RET"
        case "$_RET" in
            0|false|False) return 0;;
            *) return 1;;
        esac
    fi

    return 1
}

ovf_vmware_transport_guestinfo() {
    [ "${DI_VIRT}" = "vmware" ] || return 1
    command -v vmware-rpctool >/dev/null 2>&1 || return 1
    local out="" ret=""
    out=$(vmware-rpctool "info-get guestinfo.ovfEnv" 2>&1)
    ret=$?
    if [ $ret -ne 0 ]; then
        debug 1 "Running on vmware but rpctool query returned $ret: $out"
        return 1
    fi
    case "$out" in
        "<?xml"*|"<?XML"*) :;;
        *) debug 1 "guestinfo.ovfEnv had non-xml content: $out";
           return 1;;
    esac
    debug 1 "Found guestinfo transport."
    return 0
}

is_cdrom_ovf() {
    local dev="$1" label="$2"
    # skip devices that don't look like cdrom paths.
    case "$dev" in
        /dev/sr[0-9]|/dev/hd[a-z]) :;;
        *) debug 1 "skipping iso dev $dev"
           return 1;;
    esac

    debug 1 "got label=$label"
    # fast path known 'OVF' labels
    case "$label" in
        OVF-TRANSPORT|ovf-transport|OVFENV|ovfenv|OVF\ ENV|ovf\ env) return 0;;
    esac

    # explicitly skip known labels of other types. rd_rdfe is azure.
    case "$label" in
        config-2|CONFIG-2|rd_rdfe_stable*|cidata|CIDATA) return 1;;
    esac

    # skip device which size is 10MB or larger
    local size="" sfile="${PATH_SYS_CLASS_BLOCK}/${dev##*/}/size"
    [ -f "$sfile" ] || return 1
    read size <"$sfile" || { warn "failed reading from $sfile"; return 1; }
    # size is in 512 byte units. so convert to MB (integer division)
    if [ $((size/2048)) -ge 10 ]; then
        debug 2 "$dev: size $((size/2048))MB is considered too large for OVF"
        return 1
    fi

    local idstr="http://schemas.dmtf.org/ovf/environment/1"
    grep --quiet --ignore-case "$idstr" "${PATH_ROOT}$dev"
}

has_ovf_cdrom() {
    # DI_ISO9660_DEVS is <device>=label,<device>=label2
    # like /dev/sr0=OVF-TRANSPORT,/dev/other=with spaces
    if [ "${DI_ISO9660_DEVS#${UNAVAILABLE}:}" = "${DI_ISO9660_DEVS}" ]; then
        local oifs="$IFS"
        # shellcheck disable=2086
        { IFS=","; set -- ${DI_ISO9660_DEVS}; IFS="$oifs"; }
        for tok in "$@"; do
            is_cdrom_ovf "${tok%%=*}" "${tok#*=}" && return 0
        done
    fi
    return 1
}

dscheck_OVF() {
    check_seed_dir ovf ovf-env.xml && return "${DS_FOUND}"

    [ "${DI_VIRT}" = "none" ] && return ${DS_NOT_FOUND}

    # Azure provides ovf. Skip false positive by dis-allowing.
    is_azure_chassis && return $DS_NOT_FOUND

    ovf_vmware_transport_guestinfo && return "${DS_FOUND}"

    has_ovf_cdrom && return "${DS_FOUND}"

    ovf_vmware_guest_customization && return "${DS_FOUND}"

    return ${DS_NOT_FOUND}
}

is_azure_chassis() {
    local azure_chassis="7783-7084-3265-9085-8269-3286-77"
    dmi_chassis_asset_tag_matches "${azure_chassis}"
}

dscheck_Azure() {
    # http://paste.ubuntu.com/23630873/
    # $ grep /sr0 /run/blkid/blkid.tab
    # <device DEVNO="0x0b00" TIME="1481737655.543841"
    #  UUID="112D211272645f72" LABEL="rd_rdfe_stable.161212-1209"
    #  TYPE="udf">/dev/sr0</device>
    #
    is_azure_chassis && return $DS_FOUND
    check_seed_dir azure ovf-env.xml && return ${DS_FOUND}

    [ "${DI_VIRT}" = "microsoft" ] || return ${DS_NOT_FOUND}

    has_fs_with_label "rd_rdfe_*" && return ${DS_FOUND}

    return ${DS_NOT_FOUND}
}

dscheck_Bigstep() {
    # bigstep is activated by presense of seed file 'url'
    [ -f "${PATH_VAR_LIB_CLOUD}/data/seed/bigstep/url" ] &&
        return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

ec2_read_strict_setting() {
    # the 'strict_id' setting for Ec2 controls behavior when
    # the platform does not identify itself directly as Ec2.
    # order of precedence is:
    #  1. builtin setting here cloud-init/ds-identify builtin
    #  2. ds-identify config
    #  3. system config (/etc/cloud/cloud.cfg.d/*Ec2*.cfg)
    #  4. kernel command line (undocumented)
    #  5. user-data or vendor-data (not available here)
    local default="$1" key="ci.datasource.ec2.strict_id" val=""

    # 4. kernel command line
    case " ${DI_KERNEL_CMDLINE} " in
        *\ $key=*\ )
            val=${DI_KERNEL_CMDLINE##*$key=}
            val=${val%% *};
            _RET=${val:-$default}
            return 0
    esac

    # 3. look for the key 'strict_id' (datasource/Ec2/strict_id)
    # only in cloud.cfg or cloud.cfg.d/EC2.cfg (case insensitive)
    local cfg="${PATH_ETC_CI_CFG}" cfg_d="${PATH_ETC_CI_CFG_D}"
    if check_config strict_id "$cfg" "$cfg_d/*[Ee][Cc]2*.cfg"; then
        debug 2 "${_RET_fname} set strict_id to $_RET"
        return 0
    fi

    # 2. ds-identify config (datasource.ec2.strict)
    local config="${PATH_DI_CONFIG}"
    if [ -f "$config" ]; then
        if _read_config "$key" < "$config"; then
            _RET=${_RET:-$default}
            return 0
        fi
    fi

    # 1. Default
    _RET=$default
    return 0
}

ec2_identify_platform() {
    local default="$1"
    local serial="${DI_DMI_PRODUCT_SERIAL}"

    case "$serial" in
        *.brightbox.com) _RET="Brightbox"; return 0;;
    esac

    local asset_tag="${DI_DMI_CHASSIS_ASSET_TAG}"
    case "$asset_tag" in
        *.zstack.io) _RET="ZStack"; return 0;;
    esac

    local vendor="${DI_DMI_SYS_VENDOR}"
    case "$vendor" in
        e24cloud) _RET="E24cloud"; return 0;;
    esac

    # AWS http://docs.aws.amazon.com/AWSEC2/
    #     latest/UserGuide/identify_ec2_instances.html
    local uuid="" hvuuid="${PATH_SYS_HYPERVISOR}/uuid"
    # if the (basically) xen specific /sys/hypervisor/uuid starts with 'ec2'
    if [ -r "$hvuuid" ] && read uuid < "$hvuuid" &&
        [ "${uuid#ec2}" != "$uuid" ]; then
        _RET="AWS"
        return 0
    fi

    # product uuid and product serial start with case insensitive
    local uuid="${DI_DMI_PRODUCT_UUID}"
    case "$uuid:$serial" in
        [Ee][Cc]2*:[Ee][Cc]2*)
            # both start with ec2, now check for case insenstive equal
            nocase_equal "$uuid" "$serial" &&
                { _RET="AWS"; return 0; };;
    esac

    _RET="$default"
    return 0;
}

dscheck_Ec2() {
    check_seed_dir "ec2" meta-data user-data && return ${DS_FOUND}
    is_container && return ${DS_NOT_FOUND}

    local unknown="Unknown" platform=""
    if ec2_identify_platform "$unknown"; then
        platform="$_RET"
    else
        warn "Failed to identify ec2 platform. Using '$unknown'."
        platform=$unknown
    fi

    debug 1 "ec2 platform is '$platform'."
    if [ "$platform" != "$unknown" ]; then
        return $DS_FOUND
    fi

    local default="${DI_EC2_STRICT_ID_DEFAULT}"
    if ec2_read_strict_setting "$default"; then
        strict="$_RET"
    else
        debug 1 "ec2_read_strict returned non-zero: $?. using '$default'."
        strict="$default"
    fi

    local key="datasource/Ec2/strict_id"
    case "$strict" in
        true|false|warn|warn,[0-9]*) :;;
        *)
            warn "$key was set to invalid '$strict'. using '$default'"
            strict="$default";;
    esac

    _RET_excfg="datasource: {Ec2: {strict_id: \"$strict\"}}"
    if [ "$strict" = "true" ]; then
        return $DS_NOT_FOUND
    else
        return $DS_MAYBE
    fi
}

dscheck_GCE() {
    if dmi_product_name_matches "Google Compute Engine"; then
        return ${DS_FOUND}
    fi
    # product name is not guaranteed (LP: #1674861)
    if dmi_product_serial_matches "GoogleCloud-*"; then
        return ${DS_FOUND}
    fi
    return ${DS_NOT_FOUND}
}

dscheck_OpenStack() {
    # the openstack metadata http service

    # if there is a config drive, then do not check metadata
    # FIXME: if config drive not in the search list, then we should not
    # do this check.
    check_configdrive_v2
    if [ $? -eq ${DS_FOUND} ]; then
        return ${DS_NOT_FOUND}
    fi
    local nova="OpenStack Nova" compute="OpenStack Compute"
    if dmi_product_name_matches "$nova"; then
        return ${DS_FOUND}
    fi
    if dmi_product_name_matches "$compute"; then
        # RDO installed nova (LP: #1675349).
        return ${DS_FOUND}
    fi
    if [ "${DI_PID_1_PRODUCT_NAME}" = "$nova" ]; then
        return ${DS_FOUND}
    fi

    if dmi_chassis_asset_tag_matches "OpenTelekomCloud"; then
        return ${DS_FOUND}
    fi

    if dmi_chassis_asset_tag_matches "SAP CCloud VM"; then
        return ${DS_FOUND}
    fi

    # LP: #1669875 : allow identification of OpenStack by asset tag
    if dmi_chassis_asset_tag_matches "$nova"; then
        return ${DS_FOUND}
    fi
    if dmi_chassis_asset_tag_matches "$compute"; then
        return ${DS_FOUND}
    fi

    # LP: #1715241 : arch other than intel are not identified properly.
    case "$DI_UNAME_MACHINE" in
        i?86|x86_64) :;;
        *) return ${DS_MAYBE};;
    esac

    return ${DS_NOT_FOUND}
}

dscheck_AliYun() {
    check_seed_dir "AliYun" meta-data user-data && return ${DS_FOUND}
    if dmi_product_name_matches "Alibaba Cloud ECS"; then
        return $DS_FOUND
    fi
    return $DS_NOT_FOUND
}

dscheck_AltCloud() {
    # ctype: either the dmi product name, or contents of
    #        /etc/sysconfig/cloud-info
    # if ctype == "vsphere"
    #    device = device with label 'CDROM'
    # elif ctype == "rhev"
    #    device = /dev/floppy
    # then, filesystem on that device must have
    #    user-data.txt or deltacloud-user-data.txt
    local ctype="" dev=""
    local match_rhev="[Rr][Hh][Ee][Vv]"
    local match_vsphere="[Vv][Ss][Pp][Hh][Ee][Rr][Ee]"
    local cinfo="${PATH_ROOT}/etc/sysconfig/cloud-info"
    if [ -f "$cinfo" ]; then
        read ctype < "$cinfo"
    else
        ctype="${DI_DMI_PRODUCT_NAME}"
    fi
    case "$ctype" in
        ${match_rhev})
            probe_floppy || return ${DS_NOT_FOUND}
            dev="/dev/floppy"
            ;;
        ${match_vsphere})
            block_dev_with_label CDROM || return ${DS_NOT_FOUND}
            dev="$_RET"
            ;;
        *) return ${DS_NOT_FOUND};;
    esac

    # FIXME: need to check $dev for user-data.txt or deltacloud-user-data.txt
    : "$dev"
    return $DS_MAYBE
}

dscheck_SmartOS() {
    # joyent cloud has two virt types: kvm and container
    # on kvm, product name on joyent public cloud shows 'SmartDC HVM'
    # on the container platform, uname's version has: BrandZ virtual linux
    # for container, we also verify that the socketfile exists to protect
    # against embedded containers (lxd running on brandz)
    local smartdc_kver="BrandZ virtual linux"
    local metadata_sockfile="${PATH_ROOT}/native/.zonecontrol/metadata.sock"
    dmi_product_name_matches "SmartDC*" && return $DS_FOUND
    [ "${DI_UNAME_KERNEL_VERSION}" = "${smartdc_kver}" ] &&
        [ -e "${metadata_sockfile}" ] &&
        return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

dscheck_None() {
    return ${DS_NOT_FOUND}
}

dscheck_Scaleway() {
    if [ "${DI_DMI_SYS_VENDOR}" = "Scaleway" ]; then
        return $DS_FOUND
    fi

    case " ${DI_KERNEL_CMDLINE} " in
        *\ scaleway\ *) return ${DS_FOUND};;
    esac

    if [ -f "${PATH_ROOT}/var/run/scaleway" ]; then
        return ${DS_FOUND}
    fi

    return ${DS_NOT_FOUND}
}

dscheck_Hetzner() {
    dmi_sys_vendor_is Hetzner && return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

dscheck_Oracle() {
    local asset_tag="OracleCloud.com"
    dmi_chassis_asset_tag_matches "${asset_tag}" && return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

is_ibm_provisioning() {
    local pcfg="${PATH_ROOT}/root/provisioningConfiguration.cfg"
    local logf="${PATH_ROOT}/root/swinstall.log"
    local is_prov=false msg="config '$pcfg' did not exist."
    if [ -f "$pcfg" ]; then
        msg="config '$pcfg' exists."
        is_prov=true
        if [ -f "$logf" ]; then
            if [ "$logf" -nt "$PATH_PROC_1_ENVIRON" ]; then
                msg="$msg log '$logf' from current boot."
            else
                is_prov=false
                msg="$msg log '$logf' from previous boot."
            fi
        else
            msg="$msg log '$logf' did not exist."
        fi
    fi
    debug 2 "ibm_provisioning=$is_prov: $msg"
    [ "$is_prov" = "true" ]
}

is_ibm_cloud() {
    cached "${_IS_IBM_CLOUD}" && return ${_IS_IBM_CLOUD}
    local ret=1
    if [ "$DI_VIRT" = "xen" ]; then
        if is_ibm_provisioning; then
            ret=0
        elif has_fs_with_label METADATA metadata; then
            ret=0
        elif has_fs_with_uuid 9796-932E &&
            has_fs_with_label CONFIG-2 config-2; then
            ret=0
        fi
    fi
    _IS_IBM_CLOUD=$ret
    return $ret
}

dscheck_IBMCloud() {
    if is_ibm_provisioning; then
        debug 1 "cloud-init disabled during provisioning on IBMCloud"
        return ${DS_NOT_FOUND}
    fi
    is_ibm_cloud && return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

collect_info() {
    read_uname_info
    read_virt
    read_pid1_product_name
    read_kernel_cmdline
    read_config
    read_datasource_list
    read_dmi_sys_vendor
    read_dmi_chassis_asset_tag
    read_dmi_product_name
    read_dmi_product_serial
    read_dmi_product_uuid
    read_fs_info
}

print_info() {
    collect_info
    _print_info
}

_print_info() {
    local n="" v="" vars=""
    vars="DMI_PRODUCT_NAME DMI_SYS_VENDOR DMI_PRODUCT_SERIAL"
    vars="$vars DMI_PRODUCT_UUID PID_1_PRODUCT_NAME DMI_CHASSIS_ASSET_TAG"
    vars="$vars FS_LABELS ISO9660_DEVS KERNEL_CMDLINE VIRT"
    vars="$vars UNAME_KERNEL_NAME UNAME_KERNEL_RELEASE UNAME_KERNEL_VERSION"
    vars="$vars UNAME_MACHINE UNAME_NODENAME UNAME_OPERATING_SYSTEM"
    vars="$vars DSNAME DSLIST"
    vars="$vars MODE ON_FOUND ON_MAYBE ON_NOTFOUND"
    for v in ${vars}; do
        eval n='${DI_'"$v"'}'
        echo "$v=$n"
    done
    echo "pid=$$ ppid=$PPID"
    is_container && echo "is_container=true" || echo "is_container=false"
}

write_result() {
    local runcfg="${PATH_RUN_CI_CFG}" ret="" line="" pre=""
    {
        if [ "$DI_MODE" = "report" ]; then
            echo "di_report:"
            pre="  "
        fi
        for line in "$@"; do
            echo "${pre}$line";
        done
    } > "$runcfg"
    ret=$?
    [ $ret -eq 0 ] || {
        error "failed to write to ${runcfg}"
        return $ret
    }
    return 0
}

record_notfound() {
    # in report mode, report nothing was found.
    # if not report mode: only report the negative result.
    #   reporting an empty list would mean cloud-init would not search
    #   any datasources.
    if [ "$DI_MODE" = "report" ]; then
        found --
    elif [ "$DI_MODE" = "search" ]; then
        local msg="# reporting not found result. notfound=${DI_ON_NOTFOUND}."
        local DI_MODE="report"
        found -- "$msg"
    fi
}

found() {
    # found(ds1, [ds2 ...], [-- [extra lines]])
    local list="" ds=""
    while [ $# -ne 0 ]; do
        if [ "$1" = "--" ]; then
            shift
            break
        fi
        list="${list:+${list}, }$1"
        shift
    done
    if [ $# -eq 1 ] && [ -z "$1" ]; then
        # do not pass an empty line through.
        shift
    fi
    # if None is not already in the list, then add it last.
    case " $list " in
        *\ None,\ *|*\ None\ ) :;;
        *) list=${list:+${list}, None};;
    esac
    write_result "datasource_list: [ $list ]" "$@"
    return
}

trim() {
    # shellcheck disable=2048,2086
    set -- $*
    _RET="$*"
}

unquote() {
    # remove quotes from quoted value
    local quote='"' tick="'"
    local val="$1"
    case "$val" in
        ${quote}*${quote}|${tick}*${tick})
            val=${val#?}; val=${val%?};;
    esac
    _RET="$val"
}

_read_config() {
    # reads config from stdin,
    # if no parameters are set, modifies _rc scoped environment vars.
    # if keyname is provided, then returns found value of that key.
    local keyname="${1:-_unset}"
    local line="" hash="#" key="" val=""
    while read line; do
        line=${line%%${hash}*}
        key="${line%%:*}"

        # no : in the line.
        [ "$key" = "$line" ] && continue
        trim "$key"
        key=${_RET}

        [ "$keyname" != "_unset" ] && [ "$keyname" != "$key" ] &&
            continue

        val="${line#*:}"
        trim "$val"
        unquote "${_RET}"
        val=${_RET}

        if [ "$keyname" = "$key" ]; then
            _RET="$val"
            return 0
        fi

        case "$key" in
            datasource) _rc_dsname="$val";;
            policy) _rc_policy="$val";;
        esac
    done
    if [ "$keyname" = "_unset" ]; then
        return 1
    fi
    _RET=""
    return 0
}

parse_warn() {
    echo "WARN: invalid value '$2' for key '$1'. Using $1=$3." 1>&2
}

parse_def_policy() {
    local _rc_mode="" _rc_report="" _rc_found="" _rc_maybe="" _rc_notfound=""
    local ret=""
    parse_policy "$@"
    ret=$?
    _def_mode=$_rc_mode
    _def_report=$_rc_report
    _def_found=$_rc_found
    _def_maybe=$_rc_maybe
    _def_notfound=$_rc_notfound
    return $ret
}

parse_policy() {
    # parse_policy(policy, default)
    # parse a policy string.  sets
    #   _rc_mode (enabled|disabled|search|report)
    #   _rc_report true|false
    #   _rc_found first|all
    #   _rc_maybe all|none
    #   _rc_notfound enabled|disabled
    local def=""
    case "$DI_UNAME_MACHINE" in
        # these have dmi data
        i?86|x86_64) def=${DI_DEFAULT_POLICY};;
        # aarch64 has dmi, but not currently used (LP: #1663304)
        aarch64) def=${DI_DEFAULT_POLICY_NO_DMI};;
        *) def=${DI_DEFAULT_POLICY_NO_DMI};;
    esac
    local policy="$1"
    local _def_mode="" _def_report="" _def_found="" _def_maybe=""
    local _def_notfound=""
    if [ $# -eq 1 ] || [ "$2" != "-" ]; then
        def=${2:-${def}}
        parse_def_policy "$def" -
    fi

    local mode="" report="" found="" maybe="" notfound=""
    local oifs="$IFS" tok="" val=""
    # shellcheck disable=2086
    { IFS=","; set -- $policy; IFS="$oifs"; }
    for tok in "$@"; do
        val=${tok#*=}
        case "$tok" in
            $DI_ENABLED|$DI_DISABLED|search|report) mode=$tok;;
            found=all|found=first) found=$val;;
            maybe=all|maybe=none) maybe=$val;;
            notfound=$DI_ENABLED|notfound=$DI_DISABLED) notfound=$val;;
            found=*)
               parse_warn found "$val" "${_def_found}"
               found=${_def_found};;
            maybe=*)
               parse_warn maybe "$val" "${_def_maybe}"
               maybe=${_def_maybe};;
            notfound=*)
               parse_warn notfound "$val" "${_def_notfound}"
               notfound=${_def_notfound};;
        esac
    done
    report=${report:-${_def_report:-false}}
    _rc_report=${report}
    _rc_mode=${mode:-${_def_mode}}
    _rc_found=${found:-${_def_found}}
    _rc_maybe=${maybe:-${_def_maybe}}
    _rc_notfound=${notfound:-${_def_notfound}}
}

read_config() {
    local config="${PATH_DI_CONFIG}"
    local _rc_dsname="" _rc_policy="" ret=""
    if [ -f "$config" ]; then
        _read_config < "$config"
        ret=$?
    elif [ -e "$config" ]; then
        error "$config exists but is not a file!"
        ret=1
    fi
    local tok="" key="" val=""
    for tok in ${DI_KERNEL_CMDLINE}; do
        key=${tok%%=*}
        val=${tok#*=}
        case "$key" in
            ci.ds) _rc_dsname="$val";;
            ci.datasource) _rc_dsname="$val";;
            ci.di.policy) _rc_policy="$val";;
        esac
    done

    local _rc_mode _rc_report _rc_found _rc_maybe _rc_notfound
    parse_policy "${_rc_policy}"
    debug 1 "policy loaded: mode=${_rc_mode} report=${_rc_report}" \
            "found=${_rc_found} maybe=${_rc_maybe} notfound=${_rc_notfound}"
    DI_MODE=${_rc_mode}
    DI_ON_FOUND=${_rc_found}
    DI_ON_MAYBE=${_rc_maybe}
    DI_ON_NOTFOUND=${_rc_notfound}

    DI_DSNAME="${_rc_dsname}"
    return $ret
}


manual_clean_and_existing() {
    [ -f "${PATH_VAR_LIB_CLOUD}/instance/manual-clean" ]
}

read_uptime() {
    local up _
    _RET="${UNAVAILABLE}"
    [ -f "$PATH_PROC_UPTIME" ] && read up _ < "$PATH_PROC_UPTIME" &&
        _RET="$up"
    return
}

_main() {
    local dscheck_fn="" ret_dis=1 ret_en=0

    read_uptime
    debug 1 "[up ${_RET}s]" "ds-identify $*"
    collect_info

    if [ "$DI_LOG" = "stderr" ]; then
        _print_info 1>&2
    else
        _print_info >> "$DI_LOG"
    fi

    case "$DI_MODE" in
        $DI_DISABLED)
            debug 1 "mode=$DI_DISABLED. returning $ret_dis"
            return $ret_dis
            ;;
        $DI_ENABLED)
            debug 1 "mode=$DI_ENABLED. returning $ret_en"
            return $ret_en;;
        search|report) :;;
    esac

    if [ -n "${DI_DSNAME}" ]; then
        debug 1 "datasource '$DI_DSNAME' specified."
        found "$DI_DSNAME"
        return
    fi

    if manual_clean_and_existing; then
        debug 1 "manual_cache_clean enabled. Not writing datasource_list."
        write_result "# manual_cache_clean."
        return
    fi

    # shellcheck disable=2086
    set -- $DI_DSLIST
    # if there is only a single entry in $DI_DSLIST
    if [ $# -eq 1 ] || [ $# -eq 2 -a "$2" = "None" ] ; then
        debug 1 "single entry in datasource_list ($DI_DSLIST) use that."
        found "$@"
        return
    fi

    local found="" ret="" ds="" maybe="" _RET_excfg=""
    local exfound_cfg="" exmaybe_cfg=""
    for ds in ${DI_DSLIST}; do
        dscheck_fn="dscheck_${ds}"
        debug 2 "Checking for datasource '$ds' via '$dscheck_fn'"
        if ! type "$dscheck_fn" >/dev/null 2>&1; then
            warn "No check method '$dscheck_fn' for datasource '$ds'"
            continue
        fi
        _RET_excfg=""
        $dscheck_fn
        ret="$?"
        case "$ret" in
            $DS_FOUND)
                debug 1 "check for '$ds' returned found";
                exfound_cfg="${exfound_cfg:+${exfound_cfg}${CR}}${_RET_excfg}"
                found="${found} $ds";;
            $DS_MAYBE)
                debug 1 "check for '$ds' returned maybe";
                exmaybe_cfg="${exmaybe_cfg:+${exmaybe_cfg}${CR}}${_RET_excfg}"
                maybe="${maybe} $ds";;
            *) debug 2 "check for '$ds' returned not-found[$ret]";;
        esac
    done

    debug 2 "found=${found# } maybe=${maybe# }"
    # shellcheck disable=2086
    set -- $found
    if [ $# -ne 0 ]; then
        if [ $# -eq 1 ]; then
            debug 1 "Found single datasource: $1"
        else
            # found=all
            debug 1 "Found $# datasources found=${DI_ON_FOUND}: $*"
            if [ "${DI_ON_FOUND}" = "first" ]; then
                set -- "$1"
            fi
        fi
        found "$@" -- "${exfound_cfg}"
        return
    fi

    # shellcheck disable=2086
    set -- $maybe
    if [ $# -ne 0 -a "${DI_ON_MAYBE}" != "none" ]; then
        debug 1 "$# datasources returned maybe: $*"
        found "$@" -- "${exmaybe_cfg}"
        return
    fi

    # record the empty result.
    record_notfound

    local basemsg="No ds found [mode=$DI_MODE, notfound=$DI_ON_NOTFOUND]."
    local msg="" ret=3
    case "$DI_MODE:$DI_ON_NOTFOUND" in
        report:$DI_DISABLED)
            msg="$basemsg Would disable cloud-init [$ret_dis]"
            ret=$ret_en;;
        report:$DI_ENABLED)
            msg="$basemsg Would enable cloud-init [$ret_en]"
            ret=$ret_en;;
        search:$DI_DISABLED)
            msg="$basemsg Disabled cloud-init [$ret_dis]"
            ret=$ret_dis;;
        search:$DI_ENABLED)
            msg="$basemsg Enabled cloud-init [$ret_en]"
            ret=$ret_en;;
        *) error "Unexpected result";;
    esac
    debug 1 "$msg"
    return "$ret"
}

main() {
    local ret=""
    ensure_sane_path
    [ -d "$PATH_RUN_CI" ] || mkdir -p "$PATH_RUN_CI"
    if [ "${1:+$1}" != "--force" ] && [ -f "$PATH_RUN_CI_CFG" ] &&
        [ -f "$PATH_RUN_DI_RESULT" ]; then
        if read ret < "$PATH_RUN_DI_RESULT"; then
            if [ "$ret" = "0" ] || [ "$ret" = "1" ]; then
                debug 2 "used cached result $ret. pass --force to re-run."
                return "$ret";
            fi
            debug 1 "previous run returned unexpected '$ret'. Re-running."
        else
            error "failed to read result from $PATH_RUN_DI_RESULT!"
        fi
    fi
    _main "$@"
    ret=$?
    echo "$ret" > "$PATH_RUN_DI_RESULT"
    read_uptime
    debug 1 "[up ${_RET}s]" "returning $ret"
    return "$ret"
}

noop() {
    :
}

case "${DI_MAIN}" in
    main|print_info|noop) "${DI_MAIN}" "$@";;
    *) error "unexpected value for DI_MAIN"; exit 1;;
esac

# vi: syntax=sh ts=4 expandtab