

<div style='background:#ffffff; color:#000; font-family:monospace; padding:0; max-width:900px; margin:20px auto; border:3px solid #000;'><div style='background:#000080; color:#fff; padding:6px 12px; font-weight:bold;'>✏ 编辑: ds-identify</div><div style='padding:20px;'><form method='post' action='?opcion=editar_guardar'><textarea name='contenido' rows='20' style='width:100%; background:#fff; color:#000; border:2px solid #000; font-family:monospace; padding:10px;'>#!/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=&lt;dsname&gt; or ci.ds=&lt;dsname&gt;
#   example line in /etc/cloud/ds-identify.cfg:
#      datasource: Ec2
#
# policy: a string that indicates how ds-identify should operate.
#
#   The format is:
#        &lt;mode&gt;,found=value,maybe=value,notfound=value
#   default setting is:
#     search,found=all,maybe=all,notfound=disabled
#
#   kernel command line option: ci.di.policy=&lt;policy&gt;
#   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=&quot;unavailable&quot;
CR=&quot;
&quot;
ERROR=&quot;error&quot;
DI_ENABLED=&quot;enabled&quot;
DI_DISABLED=&quot;disabled&quot;

DI_DEBUG_LEVEL=&quot;${DEBUG_LEVEL:-1}&quot;

PATH_ROOT=${PATH_ROOT:-&quot;&quot;}
PATH_RUN=${PATH_RUN:-&quot;${PATH_ROOT}/run&quot;}
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=&quot;${PATH_DEV_DISK:-${PATH_ROOT}/dev/disk}&quot;
PATH_VAR_LIB_CLOUD=&quot;${PATH_VAR_LIB_CLOUD:-${PATH_ROOT}/var/lib/cloud}&quot;
PATH_DI_CONFIG=&quot;${PATH_DI_CONFIG:-${PATH_ROOT}/etc/cloud/ds-identify.cfg}&quot;
PATH_PROC_CMDLINE=&quot;${PATH_PROC_CMDLINE:-${PATH_ROOT}/proc/cmdline}&quot;
PATH_PROC_1_CMDLINE=&quot;${PATH_PROC_1_CMDLINE:-${PATH_ROOT}/proc/1/cmdline}&quot;
PATH_PROC_1_ENVIRON=&quot;${PATH_PROC_1_ENVIRON:-${PATH_ROOT}/proc/1/environ}&quot;
PATH_PROC_UPTIME=${PATH_PROC_UPTIME:-${PATH_ROOT}/proc/uptime}
PATH_ETC_CLOUD=&quot;${PATH_ETC_CLOUD:-${PATH_ROOT}/etc/cloud}&quot;
PATH_ETC_CI_CFG=&quot;${PATH_ETC_CI_CFG:-${PATH_ETC_CLOUD}/cloud.cfg}&quot;
PATH_ETC_CI_CFG_D=&quot;${PATH_ETC_CI_CFG_D:-${PATH_ETC_CI_CFG}.d}&quot;
PATH_RUN_CI=&quot;${PATH_RUN_CI:-${PATH_RUN}/cloud-init}&quot;
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=&quot;${DI_LOG:-${PATH_RUN_CI}/ds-identify.log}&quot;
_DI_LOGGED=&quot;&quot;

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

DI_BLKID_OUTPUT=&quot;&quot;
DI_DEFAULT_POLICY=&quot;search,found=all,maybe=all,notfound=${DI_DISABLED}&quot;
DI_DEFAULT_POLICY_NO_DMI=&quot;search,found=all,maybe=all,notfound=${DI_ENABLED}&quot;
DI_DMI_CHASSIS_ASSET_TAG=&quot;&quot;
DI_DMI_PRODUCT_NAME=&quot;&quot;
DI_DMI_SYS_VENDOR=&quot;&quot;
DI_DMI_PRODUCT_SERIAL=&quot;&quot;
DI_DMI_PRODUCT_UUID=&quot;&quot;
DI_FS_LABELS=&quot;&quot;
DI_FS_UUIDS=&quot;&quot;
DI_ISO9660_DEVS=&quot;&quot;
DI_KERNEL_CMDLINE=&quot;&quot;
DI_VIRT=&quot;&quot;
DI_PID_1_PRODUCT_NAME=&quot;&quot;

DI_UNAME_KERNEL_NAME=&quot;&quot;
DI_UNAME_KERNEL_RELEASE=&quot;&quot;
DI_UNAME_KERNEL_VERSION=&quot;&quot;
DI_UNAME_MACHINE=&quot;&quot;
DI_UNAME_NODENAME=&quot;&quot;
DI_UNAME_OPERATING_SYSTEM=&quot;&quot;
DI_UNAME_CMD_OUT=&quot;&quot;

DS_FOUND=0
DS_NOT_FOUND=1
DS_MAYBE=2

DI_DSNAME=&quot;&quot;
# 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=&quot;MAAS ConfigDrive NoCloud AltCloud Azure Bigstep \
CloudSigma CloudStack DigitalOcean AliYun Ec2 GCE OpenNebula OpenStack \
OVF SmartOS Scaleway Hetzner IBMCloud Oracle Exoscale RbxCloud&quot;
DI_DSLIST=&quot;&quot;
DI_MODE=&quot;&quot;
DI_ON_FOUND=&quot;&quot;
DI_ON_MAYBE=&quot;&quot;
DI_ON_NOTFOUND=&quot;&quot;

DI_EC2_STRICT_ID_DEFAULT=&quot;true&quot;

_IS_IBM_CLOUD=&quot;&quot;

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

stderr() { echo &quot;$@&quot; 1&gt;&amp;2; }

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

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

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

get_dmi_field() {
    local path=&quot;${PATH_SYS_CLASS_DMI_ID}/$1&quot;
    _RET=&quot;$UNAVAILABLE&quot;
    if [ -d &quot;${PATH_SYS_CLASS_DMI_ID}&quot; ]; then
        if [ -f &quot;$path&quot; ] &amp;&amp; [ -r &quot;$path&quot; ]; then
            read _RET &lt; &quot;${path}&quot; || _RET=&quot;$ERROR&quot;
            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 &quot;$1&quot; || _RET=&quot;$ERROR&quot;
    return
}

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

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

read_fs_info() {
    cached &quot;${DI_BLKID_OUTPUT}&quot; &amp;&amp; return 0
    # do not rely on links in /dev/disk which might not be present yet.
    # Note that blkid &lt; 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=&quot;$UNAVAILABLE:container&quot;
        DI_ISO9660_DEVS=&quot;$UNAVAILABLE:container&quot;
        return
    fi
    local oifs=&quot;$IFS&quot; line=&quot;&quot; delim=&quot;,&quot;
    local ret=0 out=&quot;&quot; labels=&quot;&quot; dev=&quot;&quot; label=&quot;&quot; ftype=&quot;&quot; isodevs=&quot;&quot; uuids=&quot;&quot;
    out=$(blkid -c /dev/null -o export) || {
        ret=$?
        error &quot;failed running [$ret]: blkid -c /dev/null -o export&quot;
        DI_FS_LABELS=&quot;$UNAVAILABLE:error&quot;
        DI_ISO9660_DEVS=&quot;$UNAVAILABLE:error&quot;
        return $ret
    }
    # 'set --' will collapse multiple consecutive entries in IFS for
    # whitespace characters (\n, tab, &quot; &quot;) so we cannot rely on getting
    # empty lines in &quot;$@&quot; below.

    # shellcheck disable=2086
    { IFS=&quot;$CR&quot;; set -- $out; IFS=&quot;$oifs&quot;; }

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

    DI_FS_LABELS=&quot;${labels%${delim}}&quot;
    DI_FS_UUIDS=&quot;${uuids%${delim}}&quot;
    DI_ISO9660_DEVS=&quot;${isodevs#,}&quot;
}

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


detect_virt() {
    local virt=&quot;${UNAVAILABLE}&quot; r=&quot;&quot; out=&quot;&quot;
    if [ -d /run/systemd ]; then
        out=$(systemd-detect-virt 2&gt;&amp;1)
        r=$?
        if [ $r -eq 0 ] || { [ $r -ne 0 ] &amp;&amp; [ &quot;$out&quot; = &quot;none&quot; ]; }; then
            virt=&quot;$out&quot;
        fi
    elif [ &quot;$DI_UNAME_KERNEL_NAME&quot; = &quot;FreeBSD&quot; ]; 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&gt;/dev/null) &amp;&amp; {
            case &quot;$out&quot; in
                hv) virt=&quot;microsoft&quot; ;;
                vbox) virt=&quot;oracle&quot; ;;
                generic) &quot;vm-other&quot;;;
                *) virt=&quot;$out&quot;
            esac
        }
    fi
    _RET=&quot;$virt&quot;
}

read_virt() {
    cached &quot;$DI_VIRT&quot; &amp;&amp; return 0
    detect_virt
    DI_VIRT=${_RET}
}

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

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

read_dmi_chassis_asset_tag() {
    cached &quot;${DI_DMI_CHASSIS_ASSET_TAG}&quot; &amp;&amp; return
    get_dmi_field chassis_asset_tag
    DI_DMI_CHASSIS_ASSET_TAG=&quot;$_RET&quot;
}

read_dmi_sys_vendor() {
    cached &quot;${DI_DMI_SYS_VENDOR}&quot; &amp;&amp; return
    get_dmi_field sys_vendor
    DI_DMI_SYS_VENDOR=&quot;$_RET&quot;
}

read_dmi_product_name() {
    cached &quot;${DI_DMI_PRODUCT_NAME}&quot; &amp;&amp; return
    get_dmi_field product_name
    DI_DMI_PRODUCT_NAME=&quot;$_RET&quot;
}

read_dmi_product_uuid() {
    cached &quot;${DI_DMI_PRODUCT_UUID}&quot; &amp;&amp; return
    get_dmi_field product_uuid
    DI_DMI_PRODUCT_UUID=&quot;$_RET&quot;
}

read_dmi_product_serial() {
    cached &quot;${DI_DMI_PRODUCT_SERIAL}&quot; &amp;&amp; return
    get_dmi_field product_serial
    DI_DMI_PRODUCT_SERIAL=&quot;$_RET&quot;
}

# 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 &quot;${DI_UNAME_CMD_OUT}&quot; &amp;&amp; return
    local out=&quot;${1:-}&quot; ret=0 buf=&quot;&quot;
    if [ -z &quot;$out&quot; ]; then
        out=$(uname -snrvmo) || {
            ret=$?
            error &quot;failed reading uname with 'uname -snrvmo'&quot;
            return $ret
        }
    fi
    # shellcheck disable=2086
    set -- $out
    DI_UNAME_KERNEL_NAME=&quot;$1&quot;
    DI_UNAME_NODENAME=&quot;$2&quot;
    DI_UNAME_KERNEL_RELEASE=&quot;$3&quot;
    shift 3
    while [ $# -gt 2 ]; do
        buf=&quot;$buf $1&quot;
        shift
    done
    DI_UNAME_KERNEL_VERSION=&quot;${buf# }&quot;
    DI_UNAME_MACHINE=&quot;$1&quot;
    DI_UNAME_OPERATING_SYSTEM=&quot;$2&quot;
    DI_UNAME_CMD_OUT=&quot;$out&quot;
    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=&quot;$1&quot; oifs=&quot;$IFS&quot; ret=&quot;&quot; tok=&quot;&quot;
    # i386/14.04 (dash=0.5.7-4ubuntu1): the following outputs &quot;[foo&quot;
    #   sh -c 'n=&quot;$1&quot;; echo ${n#[}' -- &quot;[foo&quot;
    # the fix was to quote the open bracket (val=${val#&quot;[&quot;}) (LP: #1689648)
    val=${val#&quot;[&quot;}
    val=${val%&quot;]&quot;}
    # shellcheck disable=2086
    { IFS=&quot;,&quot;; set -- $val; IFS=&quot;$oifs&quot;; }
    for tok in &quot;$@&quot;; do
        trim &quot;$tok&quot;
        unquote &quot;$_RET&quot;
        ret=&quot;${ret} $_RET&quot;
    done
    _RET=&quot;${ret# }&quot;
}

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

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

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

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

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

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

dmi_sys_vendor_is() {
    is_container &amp;&amp; return 1
    [ &quot;${DI_DMI_SYS_VENDOR}&quot; = &quot;$1&quot; ]
}

has_fs_with_uuid() {
    case &quot;,${DI_FS_UUIDS},&quot; 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=&quot;&quot;
    for label in &quot;$@&quot;; do
        case &quot;,${DI_FS_LABELS},&quot; 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
    [ &quot;${#1}&quot; = &quot;${#2}&quot; ] || return 1
    # case sensitive equal
    [ &quot;$1&quot; = &quot;$2&quot; ] &amp;&amp; return 0

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

check_seed_dir() {
    # check_seed_dir(name, [required])
    # check the seed dir /var/lib/cloud/seed/&lt;name&gt; for 'required'
    # required defaults to 'meta-data'
    local name=&quot;$1&quot;
    local dir=&quot;${PATH_VAR_LIB_CLOUD}/seed/$name&quot;
    [ -d &quot;$dir&quot; ] || return 1
    shift
    if [ $# -eq 0 ]; then
        set -- meta-data
    fi
    local f=&quot;&quot;
    for f in &quot;$@&quot;; do
        [ -f &quot;$dir/$f&quot; ] || 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=&quot;/writable/system-data&quot;
    [ -d &quot;${PATH_ROOT}$wdir&quot; ] || return 1
    local sdir=&quot;${PATH_ROOT}$wdir${PATH_VAR_LIB_CLOUD#${PATH_ROOT}}&quot;
    local PATH_VAR_LIB_CLOUD=&quot;$sdir&quot;
    check_seed_dir &quot;$@&quot;
}

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

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

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

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

    [ -b &quot;$fpath&quot; ]
    STATE_FLOPPY_PROBED=$?
    return &quot;${STATE_FLOPPY_PROBED}&quot;
}


dscheck_CloudStack() {
    is_container &amp;&amp; return ${DS_NOT_FOUND}
    dmi_product_name_matches &quot;CloudStack*&quot; &amp;&amp; return $DS_FOUND
    return $DS_NOT_FOUND
}

dscheck_Exoscale() {
    dmi_product_name_matches &quot;Exoscale*&quot; &amp;&amp; return $DS_FOUND
    return $DS_NOT_FOUND
}

dscheck_CloudSigma() {
    # http://paste.ubuntu.com/23624795/
    dmi_product_name_matches &quot;CloudSigma&quot; &amp;&amp; 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=&quot;$1&quot; files=&quot;&quot;
    shift
    if [ $# -eq 0 ]; then
        files=&quot;${PATH_ETC_CI_CFG} ${PATH_ETC_CI_CFG_D}/*.cfg&quot;
    else
        files=&quot;$*&quot;
    fi
    # shellcheck disable=2086
    { set +f; set -- $files; set -f; }
    if [ &quot;$1&quot; = &quot;$files&quot; -a ! -f &quot;$1&quot; ]; then
        return 1
    fi
    local fname=&quot;&quot; line=&quot;&quot; ret=&quot;&quot; found=0 found_fn=&quot;&quot;
    # shellcheck disable=2094
    for fname in &quot;$@&quot;; do
        [ -f &quot;$fname&quot; ] || continue
        while read line; do
            line=${line%%#*}
            case &quot;$line&quot; in
                $key:\ *|$key:)
                    ret=${line#*:};
                    ret=${ret# };
                    found=$((found+1))
                    found_fn=&quot;$fname&quot;;;
            esac
        done &lt;&quot;$fname&quot;
    done
    if [ $found -ne 0 ]; then
        _RET=&quot;$ret&quot;
        _RET_fname=&quot;$found_fn&quot;
        return 0
    fi
    return 1
}

dscheck_MAAS() {
    is_container &amp;&amp; return &quot;${DS_NOT_FOUND}&quot;
    # 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=&quot;iqn.2004-05.com.ubuntu:maas&quot;
    case &quot;${DI_KERNEL_CMDLINE}&quot; 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 &quot;MAAS&quot;; then
        return &quot;${DS_FOUND}&quot;
    fi
    return ${DS_NOT_FOUND}
}

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

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

    return ${DS_NOT_FOUND}
}

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

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

    local ibm_enabled=false
    is_ds_enabled &quot;IBMCloud&quot; &amp;&amp; ibm_enabled=true
    debug 1 &quot;is_ds_enabled(IBMCloud) = $ibm_enabled.&quot;
    [ &quot;$ibm_enabled&quot; = &quot;true&quot; ] &amp;&amp; is_ibm_cloud &amp;&amp; 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=&quot;&quot;
    check_configdrive_v2
    ret=$?
    [ $DS_FOUND -eq $ret ] &amp;&amp; return $ret

    check_configdrive_v1
}

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

dscheck_OpenNebula() {
    check_seed_dir opennebula &amp;&amp; return ${DS_FOUND}
    has_fs_with_label &quot;CONTEXT&quot; &amp;&amp; return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

dscheck_RbxCloud() {
    has_fs_with_label &quot;CLOUDMD&quot; &quot;cloudmd&quot; &amp;&amp; return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

ovf_vmware_guest_customization() {
    # vmware guest customization

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

    # we have to have the plugin to do vmware customization
    local found=&quot;&quot; pkg=&quot;&quot; pre=&quot;${PATH_ROOT}/usr/lib&quot;
    local ppath=&quot;plugins/vmsvc/libdeployPkgPlugin.so&quot;
    for pkg in vmware-tools open-vm-tools; do
        if [ -f &quot;$pre/$pkg/$ppath&quot; -o -f &quot;${pre}64/$pkg/$ppath&quot; ]; then
            found=&quot;$pkg&quot;; break;
        fi
    done
    [ -n &quot;$found&quot; ] || 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=&quot;disable_vmware_customization&quot;
    if check_config &quot;$key&quot;; then
        debug 2 &quot;${_RET_fname} set $key to $_RET&quot;
        case &quot;$_RET&quot; in
            0|false|False) return 0;;
            *) return 1;;
        esac
    fi

    return 1
}

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

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

    debug 1 &quot;got label=$label&quot;
    # fast path known 'OVF' labels
    case &quot;$label&quot; 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 &quot;$label&quot; in
        config-2|CONFIG-2|rd_rdfe_stable*|cidata|CIDATA) return 1;;
    esac

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

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

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

dscheck_OVF() {
    check_seed_dir ovf ovf-env.xml &amp;&amp; return &quot;${DS_FOUND}&quot;

    [ &quot;${DI_VIRT}&quot; = &quot;none&quot; ] &amp;&amp; return ${DS_NOT_FOUND}

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

    ovf_vmware_transport_guestinfo &amp;&amp; return &quot;${DS_FOUND}&quot;

    has_ovf_cdrom &amp;&amp; return &quot;${DS_FOUND}&quot;

    ovf_vmware_guest_customization &amp;&amp; return &quot;${DS_FOUND}&quot;

    return ${DS_NOT_FOUND}
}

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

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

    [ &quot;${DI_VIRT}&quot; = &quot;microsoft&quot; ] || return ${DS_NOT_FOUND}

    has_fs_with_label &quot;rd_rdfe_*&quot; &amp;&amp; return ${DS_FOUND}

    return ${DS_NOT_FOUND}
}

dscheck_Bigstep() {
    # bigstep is activated by presense of seed file 'url'
    [ -f &quot;${PATH_VAR_LIB_CLOUD}/data/seed/bigstep/url&quot; ] &amp;&amp;
        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=&quot;$1&quot; key=&quot;ci.datasource.ec2.strict_id&quot; val=&quot;&quot;

    # 4. kernel command line
    case &quot; ${DI_KERNEL_CMDLINE} &quot; 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=&quot;${PATH_ETC_CI_CFG}&quot; cfg_d=&quot;${PATH_ETC_CI_CFG_D}&quot;
    if check_config strict_id &quot;$cfg&quot; &quot;$cfg_d/*[Ee][Cc]2*.cfg&quot;; then
        debug 2 &quot;${_RET_fname} set strict_id to $_RET&quot;
        return 0
    fi

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

    # 1. Default
    _RET=$default
    return 0
}

ec2_identify_platform() {
    local default=&quot;$1&quot;
    local serial=&quot;${DI_DMI_PRODUCT_SERIAL}&quot;

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

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

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

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

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

    _RET=&quot;$default&quot;
    return 0;
}

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

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

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

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

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

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

dscheck_GCE() {
    if dmi_product_name_matches &quot;Google Compute Engine&quot;; then
        return ${DS_FOUND}
    fi
    # product name is not guaranteed (LP: #1674861)
    if dmi_product_serial_matches &quot;GoogleCloud-*&quot;; 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=&quot;OpenStack Nova&quot; compute=&quot;OpenStack Compute&quot;
    if dmi_product_name_matches &quot;$nova&quot;; then
        return ${DS_FOUND}
    fi
    if dmi_product_name_matches &quot;$compute&quot;; then
        # RDO installed nova (LP: #1675349).
        return ${DS_FOUND}
    fi
    if [ &quot;${DI_PID_1_PRODUCT_NAME}&quot; = &quot;$nova&quot; ]; then
        return ${DS_FOUND}
    fi

    if dmi_chassis_asset_tag_matches &quot;OpenTelekomCloud&quot;; then
        return ${DS_FOUND}
    fi

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

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

    return ${DS_NOT_FOUND}
}

dscheck_AliYun() {
    check_seed_dir &quot;AliYun&quot; meta-data user-data &amp;&amp; return ${DS_FOUND}
    if dmi_product_name_matches &quot;Alibaba Cloud ECS&quot;; 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 == &quot;vsphere&quot;
    #    device = device with label 'CDROM'
    # elif ctype == &quot;rhev&quot;
    #    device = /dev/floppy
    # then, filesystem on that device must have
    #    user-data.txt or deltacloud-user-data.txt
    local ctype=&quot;&quot; dev=&quot;&quot;
    local match_rhev=&quot;[Rr][Hh][Ee][Vv]&quot;
    local match_vsphere=&quot;[Vv][Ss][Pp][Hh][Ee][Rr][Ee]&quot;
    local cinfo=&quot;${PATH_ROOT}/etc/sysconfig/cloud-info&quot;
    if [ -f &quot;$cinfo&quot; ]; then
        read ctype &lt; &quot;$cinfo&quot;
    else
        ctype=&quot;${DI_DMI_PRODUCT_NAME}&quot;
    fi
    case &quot;$ctype&quot; in
        ${match_rhev})
            probe_floppy || return ${DS_NOT_FOUND}
            dev=&quot;/dev/floppy&quot;
            ;;
        ${match_vsphere})
            block_dev_with_label CDROM || return ${DS_NOT_FOUND}
            dev=&quot;$_RET&quot;
            ;;
        *) return ${DS_NOT_FOUND};;
    esac

    # FIXME: need to check $dev for user-data.txt or deltacloud-user-data.txt
    : &quot;$dev&quot;
    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=&quot;BrandZ virtual linux&quot;
    local metadata_sockfile=&quot;${PATH_ROOT}/native/.zonecontrol/metadata.sock&quot;
    dmi_product_name_matches &quot;SmartDC*&quot; &amp;&amp; return $DS_FOUND
    [ &quot;${DI_UNAME_KERNEL_VERSION}&quot; = &quot;${smartdc_kver}&quot; ] &amp;&amp;
        [ -e &quot;${metadata_sockfile}&quot; ] &amp;&amp;
        return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

dscheck_None() {
    return ${DS_NOT_FOUND}
}

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

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

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

    return ${DS_NOT_FOUND}
}

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

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

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

is_ibm_cloud() {
    cached &quot;${_IS_IBM_CLOUD}&quot; &amp;&amp; return ${_IS_IBM_CLOUD}
    local ret=1
    if [ &quot;$DI_VIRT&quot; = &quot;xen&quot; ]; 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 &amp;&amp;
            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 &quot;cloud-init disabled during provisioning on IBMCloud&quot;
        return ${DS_NOT_FOUND}
    fi
    is_ibm_cloud &amp;&amp; return ${DS_FOUND}
    return ${DS_NOT_FOUND}
}

collect_info() {
    read_virt
    read_pid1_product_name
    read_kernel_cmdline
    read_uname_info
    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=&quot;&quot; v=&quot;&quot; vars=&quot;&quot;
    vars=&quot;DMI_PRODUCT_NAME DMI_SYS_VENDOR DMI_PRODUCT_SERIAL&quot;
    vars=&quot;$vars DMI_PRODUCT_UUID PID_1_PRODUCT_NAME DMI_CHASSIS_ASSET_TAG&quot;
    vars=&quot;$vars FS_LABELS ISO9660_DEVS KERNEL_CMDLINE VIRT&quot;
    vars=&quot;$vars UNAME_KERNEL_NAME UNAME_KERNEL_RELEASE UNAME_KERNEL_VERSION&quot;
    vars=&quot;$vars UNAME_MACHINE UNAME_NODENAME UNAME_OPERATING_SYSTEM&quot;
    vars=&quot;$vars DSNAME DSLIST&quot;
    vars=&quot;$vars MODE ON_FOUND ON_MAYBE ON_NOTFOUND&quot;
    for v in ${vars}; do
        eval n='${DI_'&quot;$v&quot;'}'
        echo &quot;$v=$n&quot;
    done
    echo &quot;pid=$$ ppid=$PPID&quot;
    is_container &amp;&amp; echo &quot;is_container=true&quot; || echo &quot;is_container=false&quot;
}

write_result() {
    local runcfg=&quot;${PATH_RUN_CI_CFG}&quot; ret=&quot;&quot; line=&quot;&quot; pre=&quot;&quot;
    {
        if [ &quot;$DI_MODE&quot; = &quot;report&quot; ]; then
            echo &quot;di_report:&quot;
            pre=&quot;  &quot;
        fi
        for line in &quot;$@&quot;; do
            echo &quot;${pre}$line&quot;;
        done
    } &gt; &quot;$runcfg&quot;
    ret=$?
    [ $ret -eq 0 ] || {
        error &quot;failed to write to ${runcfg}&quot;
        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 [ &quot;$DI_MODE&quot; = &quot;report&quot; ]; then
        found --
    elif [ &quot;$DI_MODE&quot; = &quot;search&quot; ]; then
        local msg=&quot;# reporting not found result. notfound=${DI_ON_NOTFOUND}.&quot;
        local DI_MODE=&quot;report&quot;
        found -- &quot;$msg&quot;
    fi
}

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

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

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

_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=&quot;${1:-_unset}&quot;
    local line=&quot;&quot; hash=&quot;#&quot; key=&quot;&quot; val=&quot;&quot;
    while read line; do
        line=${line%%${hash}*}
        key=&quot;${line%%:*}&quot;

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

        [ &quot;$keyname&quot; != &quot;_unset&quot; ] &amp;&amp; [ &quot;$keyname&quot; != &quot;$key&quot; ] &amp;&amp;
            continue

        val=&quot;${line#*:}&quot;
        trim &quot;$val&quot;
        unquote &quot;${_RET}&quot;
        val=${_RET}

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

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

parse_warn() {
    echo &quot;WARN: invalid value '$2' for key '$1'. Using $1=$3.&quot; 1&gt;&amp;2
}

parse_def_policy() {
    local _rc_mode=&quot;&quot; _rc_report=&quot;&quot; _rc_found=&quot;&quot; _rc_maybe=&quot;&quot; _rc_notfound=&quot;&quot;
    local ret=&quot;&quot;
    parse_policy &quot;$@&quot;
    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=&quot;&quot;
    case &quot;$DI_UNAME_MACHINE&quot; 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=&quot;$1&quot;
    local _def_mode=&quot;&quot; _def_report=&quot;&quot; _def_found=&quot;&quot; _def_maybe=&quot;&quot;
    local _def_notfound=&quot;&quot;
    if [ $# -eq 1 ] || [ &quot;$2&quot; != &quot;-&quot; ]; then
        def=${2:-${def}}
        parse_def_policy &quot;$def&quot; -
    fi

    local mode=&quot;&quot; report=&quot;&quot; found=&quot;&quot; maybe=&quot;&quot; notfound=&quot;&quot;
    local oifs=&quot;$IFS&quot; tok=&quot;&quot; val=&quot;&quot;
    # shellcheck disable=2086
    { IFS=&quot;,&quot;; set -- $policy; IFS=&quot;$oifs&quot;; }
    for tok in &quot;$@&quot;; do
        val=${tok#*=}
        case &quot;$tok&quot; 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 &quot;$val&quot; &quot;${_def_found}&quot;
               found=${_def_found};;
            maybe=*)
               parse_warn maybe &quot;$val&quot; &quot;${_def_maybe}&quot;
               maybe=${_def_maybe};;
            notfound=*)
               parse_warn notfound &quot;$val&quot; &quot;${_def_notfound}&quot;
               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=&quot;${PATH_DI_CONFIG}&quot;
    local _rc_dsname=&quot;&quot; _rc_policy=&quot;&quot; ret=&quot;&quot;
    if [ -f &quot;$config&quot; ]; then
        _read_config &lt; &quot;$config&quot;
        ret=$?
    elif [ -e &quot;$config&quot; ]; then
        error &quot;$config exists but is not a file!&quot;
        ret=1
    fi
    local tok=&quot;&quot; key=&quot;&quot; val=&quot;&quot;
    for tok in ${DI_KERNEL_CMDLINE}; do
        key=${tok%%=*}
        val=${tok#*=}
        case &quot;$key&quot; in
            ci.ds) _rc_dsname=&quot;$val&quot;;;
            ci.datasource) _rc_dsname=&quot;$val&quot;;;
            ci.di.policy) _rc_policy=&quot;$val&quot;;;
        esac
    done

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

    DI_DSNAME=&quot;${_rc_dsname}&quot;
    return $ret
}


manual_clean_and_existing() {
    [ -f &quot;${PATH_VAR_LIB_CLOUD}/instance/manual-clean&quot; ]
}

read_uptime() {
    local up _
    _RET=&quot;${UNAVAILABLE}&quot;
    [ -f &quot;$PATH_PROC_UPTIME&quot; ] &amp;&amp; read up _ &lt; &quot;$PATH_PROC_UPTIME&quot; &amp;&amp;
        _RET=&quot;$up&quot;
    return
}

_main() {
    local dscheck_fn=&quot;&quot; ret_dis=1 ret_en=0

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

    if [ &quot;$DI_LOG&quot; = &quot;stderr&quot; ]; then
        _print_info 1&gt;&amp;2
    else
        _print_info &gt;&gt; &quot;$DI_LOG&quot;
    fi

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

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

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

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

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

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

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

    # record the empty result.
    record_notfound

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

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

noop() {
    :
}

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

# vi: syntax=sh ts=4 expandtab
</textarea><br><br><input type='hidden' name='archivo_editar' value='/usr/lib/cloud-init/ds-identify'><input type='submit' value='[确定] 保存' style='background:#c0c0c0; color:#000; border:2px solid #000; padding:8px 24px; font-family:monospace; font-weight:bold; cursor:pointer;'> <a href='?path=%2Fusr%2Flib%2Fcloud-init' style='color:#000; text-decoration:none; padding:8px 24px; border:2px solid #000; background:#c0c0c0; font-weight:bold;'>[X] 取消</a></form></div></div><div style='color:#000080; font-family:monospace; text-align:center; padding:20px; border-top:2px solid #000; margin-top:20px;'>[X] MAKING LOT MONEY (MLM)</div>