# using stream 3 (defined in the beginning) to not interfere with stdout of functions

# which may be used as return value

printf "%b\n" "${cyan:-}dotnet-install:${normal:-} $1" >&3

if [ "$verbose" = true ]; then

say "$1"

fi

eval $invocation

platform="$1"

case "$platform" in

"centos.7")

echo "centos"

return 0

;;

"debian.8")

echo "debian"

return 0

;;

"debian.9")

echo "debian.9"

return 0

;;

"fedora.23")

echo "fedora.23"

return 0

;;

"fedora.24")

echo "fedora.24"

return 0

;;

"fedora.27")

echo "fedora.27"

return 0

;;

"fedora.28")

echo "fedora.28"

return 0

;;

"opensuse.13.2")

echo "opensuse.13.2"

return 0

;;

"opensuse.42.1")

echo "opensuse.42.1"

return 0

;;

"opensuse.42.3")

echo "opensuse.42.3"

return 0

;;

"rhel.7"*)

echo "rhel"

return 0

;;

"ubuntu.14.04")

echo "ubuntu"

return 0

;;

"ubuntu.16.04")

echo "ubuntu.16.04"

return 0

;;

"ubuntu.16.10")

echo "ubuntu.16.10"

return 0

;;

"ubuntu.18.04")

echo "ubuntu.18.04"

return 0

;;

"alpine.3.4.3")

echo "alpine"

return 0

;;

esac

return 1

eval $invocation

local uname=$(uname)

if [ "$uname" = "Darwin" ]; then

echo "osx"

return 0

elif [ -n "$runtime_id" ]; then

echo $(get_legacy_os_name_from_platform "${runtime_id%-*}" || echo "${runtime_id%-*}")

return 0

else

if [ -e /etc/os-release ]; then

. /etc/os-release

os=$(get_legacy_os_name_from_platform "$ID${VERSION_ID:+.${VERSION_ID}}" || echo "")

if [ -n "$os" ]; then

echo "$os"

return 0

fi

fi

fi

say_verbose "Distribution specific OS name and version could not be detected: UName = $uname"

return 1

eval $invocation

if [ -n "$runtime_id" ]; then

echo "${runtime_id%-*}"

return 0

else

if [ -e /etc/os-release ]; then

. /etc/os-release

echo "$ID${VERSION_ID:+.${VERSION_ID}}"

return 0

elif [ -e /etc/redhat-release ]; then

local redhatRelease=$(</etc/redhat-release)

if [[ $redhatRelease == "CentOS release 6."* || $redhatRelease == "Red Hat Enterprise Linux "*" release 6."* ]]; then

echo "rhel.6"

return 0

fi

fi

fi

say_verbose "Linux specific platform name and version could not be detected: UName = $uname"

return 1

eval $invocation

local uname=$(uname)

if [ "$uname" = "Darwin" ]; then

echo "osx"

return 0

elif [ "$uname" = "FreeBSD" ]; then

echo "freebsd"

return 0

elif [ "$uname" = "Linux" ]; then

local linux_platform_name=""

linux_platform_name="$(get_linux_platform_name)" || true

if [ "$linux_platform_name" = "rhel.6" ]; then

echo $linux_platform_name

return 0

elif is_musl_based_distro; then

echo "linux-musl"

return 0

elif [ "$linux_platform_name" = "linux-musl" ]; then

echo "linux-musl"

return 0

else

echo "linux"

return 0

fi

fi

say_err "OS name could not be detected: UName = $uname"

return 1

eval $invocation

command -v "$1" > /dev/null 2>&1

return $?

local hasMinimum=false

if machine_has "curl"; then

hasMinimum=true

elif machine_has "wget"; then

hasMinimum=true

fi

if [ "$hasMinimum" = "false" ]; then

say_err "curl (recommended) or wget are required to download dotnet. Install missing prerequisite to proceed."

return 1

fi

return 0

#eval $invocation

echo "$1" | tr '[:upper:]' '[:lower:]'

return 0

#eval $invocation

local input="${1:-}"

echo "${input%/}"

return 0

#eval $invocation

local input="${1:-}"

echo "${input#/}"

return 0

eval $invocation

# TODO: Consider making it work with any number of paths. For now:

if [ ! -z "${3:-}" ]; then

say_err "combine_paths: Function takes two parameters."

return 1

fi

local root_path="$(remove_trailing_slash "$1")"

local child_path="$(remove_beginning_slash "${2:-}")"

say_verbose "combine_paths: root_path=$root_path"

say_verbose "combine_paths: child_path=$child_path"

echo "$root_path/$child_path"

return 0

eval $invocation

if command -v uname > /dev/null; then

CPUName=$(uname -m)

case $CPUName in

armv1*|armv2*|armv3*|armv4*|armv5*|armv6*)

echo "armv6-or-below"

return 0

;;

armv*l)

echo "arm"

return 0

;;

aarch64|arm64)

if [ "$(getconf LONG_BIT)" -lt 64 ]; then

# This is 32-bit OS running on 64-bit CPU (for example Raspberry Pi OS)

echo "arm"

return 0

fi

echo "arm64"

return 0

;;

s390x)

echo "s390x"

return 0

;;

ppc64le)

echo "ppc64le"

return 0

;;

loongarch64)

echo "loongarch64"

return 0

;;

riscv64)

echo "riscv64"

return 0

;;

powerpc|ppc)

echo "ppc"

return 0

;;

esac

fi

# Always default to 'x64'

echo "x64"

return 0

eval $invocation

local architecture="$(to_lowercase "$1")"

if [[ $architecture == \<auto\> ]]; then

machine_architecture="$(get_machine_architecture)"

if [[ "$machine_architecture" == "armv6-or-below" ]]; then

say_err "Architecture \`$machine_architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues"

return 1

fi

echo $machine_architecture

return 0

fi

case "$architecture" in

amd64|x64)

echo "x64"

return 0

;;

arm)

echo "arm"

return 0

;;

arm64)

echo "arm64"

return 0

;;

s390x)

echo "s390x"

return 0

;;

ppc64le)

echo "ppc64le"

return 0

;;

loongarch64)

echo "loongarch64"

return 0

;;

esac

say_err "Architecture \`$architecture\` not supported. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues"

return 1

eval $invocation

local is_version_support_arm64="$(is_arm64_supported "$1")"

local is_channel_support_arm64="$(is_arm64_supported "$2")"

local architecture="$3";

local osname="$(get_current_os_name)"

if [ "$osname" == "osx" ] && [ "$architecture" == "arm64" ] && { [ "$is_version_support_arm64" = false ] || [ "$is_channel_support_arm64" = false ]; }; then

#check if rosetta is installed

if [ "$(/usr/bin/pgrep oahd >/dev/null 2>&1;echo $?)" -eq 0 ]; then

say_verbose "Changing user architecture from '$architecture' to 'x64' because .NET SDKs prior to version 6.0 do not support arm64."

echo "x64"

return 0;

else

say_err "Architecture \`$architecture\` is not supported for .NET SDK version \`$version\`. Please install Rosetta to allow emulation of the \`$architecture\` .NET SDK on this platform"

return 1

fi

fi

echo "$architecture"

return 0

# Extract the major version by splitting on the dot

major_version="${1%%.*}"

# Check if the major version is a valid number and less than 6

case "$major_version" in

[0-9]*)

if [ "$major_version" -lt 6 ]; then

echo false

return 0

fi

;;

esac

echo true

return 0

eval $invocation

local osname="$(to_lowercase "$1")"

if [ ! -z "$osname" ]; then

case "$osname" in

osx | freebsd | rhel.6 | linux-musl | linux)

echo "$osname"

return 0

;;

macos)

osname='osx'

echo "$osname"

return 0

;;

*)

say_err "'$user_defined_os' is not a supported value for --os option, supported values are: osx, macos, linux, linux-musl, freebsd, rhel.6. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues."

return 1

;;

esac

else

osname="$(get_current_os_name)" || return 1

fi

echo "$osname"

return 0

eval $invocation

local quality="$(to_lowercase "$1")"

if [ ! -z "$quality" ]; then

case "$quality" in

daily | preview)

echo "$quality"

return 0

;;

ga)

#ga quality is available without specifying quality, so normalizing it to empty

return 0

;;

*)

say_err "'$quality' is not a supported value for --quality option. Supported values are: daily, preview, ga. If you think this is a bug, report it at https://github.com/dotnet/install-scripts/issues."

return 1

;;

esac

fi

return 0

eval $invocation

local channel="$(to_lowercase "$1")"

if [[ $channel == current ]]; then

say_warning 'Value "Current" is deprecated for -Channel option. Use "STS" instead.'

fi

if [[ $channel == release/* ]]; then

say_warning 'Using branch name with -Channel option is no longer supported with newer releases. Use -Quality option with a channel in X.Y format instead.';

fi

if [ ! -z "$channel" ]; then

case "$channel" in

lts)

echo "LTS"

return 0

;;

sts)

echo "STS"

return 0

;;

current)

echo "STS"

return 0

;;

*)

echo "$channel"

return 0

;;

esac

fi

return 0

eval $invocation

local product=""

local runtime="$(to_lowercase "$1")"

if [[ "$runtime" == "dotnet" ]]; then

product="dotnet-runtime"

elif [[ "$runtime" == "aspnetcore" ]]; then

product="aspnetcore-runtime"

elif [ -z "$runtime" ]; then

product="dotnet-sdk"

fi

echo "$product"

return 0

eval $invocation

cat | tail -n 1 | sed 's/\r$//'

return 0

eval $invocation

local install_root="$1"

local relative_path_to_package="$2"

local specific_version="${3//[$'\t\r\n']}"

local dotnet_package_path="$(combine_paths "$(combine_paths "$install_root" "$relative_path_to_package")" "$specific_version")"

say_verbose "is_dotnet_package_installed: dotnet_package_path=$dotnet_package_path"

if [ -d "$dotnet_package_path" ]; then

return 0

else

return 1

fi

{

eval $invocation

local downloaded_file="$1"

local remote_file_size="$2"

local file_size=''

if [[ "$OSTYPE" == "linux-gnu"* ]]; then

file_size="$(stat -c '%s' "$downloaded_file")"

elif [[ "$OSTYPE" == "darwin"* ]]; then

# hardcode in order to avoid conflicts with GNU stat

file_size="$(/usr/bin/stat -f '%z' "$downloaded_file")"

fi

if [ -n "$file_size" ]; then

say "Downloaded file size is $file_size bytes."

if [ -n "$remote_file_size" ] && [ -n "$file_size" ]; then

if [ "$remote_file_size" -ne "$file_size" ]; then

say "The remote and local file sizes are not equal. The remote file size is $remote_file_size bytes and the local size is $file_size bytes. The local package may be corrupted."

else

say "The remote and local file sizes are equal."

fi

fi

else

say "Either downloaded or local package size can not be measured. One of them may be corrupted."

fi

eval $invocation

local azure_feed="$1"

local channel="$2"

local normalized_architecture="$3"

local version_file_url=null

if [[ "$runtime" == "dotnet" ]]; then

version_file_url="$azure_feed/Runtime/$channel/latest.version"

elif [[ "$runtime" == "aspnetcore" ]]; then

version_file_url="$azure_feed/aspnetcore/Runtime/$channel/latest.version"

elif [ -z "$runtime" ]; then

version_file_url="$azure_feed/Sdk/$channel/latest.version"

else

say_err "Invalid value for \$runtime"

return 1

fi

say_verbose "get_version_from_latestversion_file: latest url: $version_file_url"

download "$version_file_url" || return $?

return 0

eval $invocation

local json_file="$1"

if [ ! -f "$json_file" ]; then

say_err "Unable to find \`$json_file\`"

return 1

fi

sdk_section=$(cat "$json_file" | tr -d "\r" | awk '/"sdk"/,/}/')

if [ -z "$sdk_section" ]; then

say_err "Unable to parse the SDK node in \`$json_file\`"

return 1

fi

sdk_list=$(echo $sdk_section | awk -F"[{}]" '{print $2}')

sdk_list=${sdk_list//[\" ]/}

sdk_list=${sdk_list//,/$'\n'}

local version_info=""

while read -r line; do

IFS=:

while read -r key value; do

if [[ "$key" == "version" ]]; then

version_info=$value

fi

done <<< "$line"

done <<< "$sdk_list"

if [ -z "$version_info" ]; then

say_err "Unable to find the SDK:version node in \`$json_file\`"

return 1

fi

unset IFS;

echo "$version_info"

return 0

eval $invocation

local azure_feed="$1"

local channel="$2"

local normalized_architecture="$3"

local version="$(to_lowercase "$4")"

local json_file="$5"

if [ -z "$json_file" ]; then

if [[ "$version" == "latest" ]]; then

local version_info

version_info="$(get_version_from_latestversion_file "$azure_feed" "$channel" "$normalized_architecture" false)" || return 1

say_verbose "get_specific_version_from_version: version_info=$version_info"

echo "$version_info" | get_version_from_latestversion_file_content

return 0

else

echo "$version"

return 0

fi

else

local version_info

version_info="$(parse_globaljson_file_for_version "$json_file")" || return 1

echo "$version_info"

return 0

fi

eval $invocation

local azure_feed="$1"

local channel="$2"

local normalized_architecture="$3"

local specific_version="${4//[$'\t\r\n']}"

local specific_product_version="$(get_specific_product_version "$1" "$4")"

local osname="$5"

local download_link=null

if [[ "$runtime" == "dotnet" ]]; then

download_link="$azure_feed/Runtime/$specific_version/dotnet-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"

elif [[ "$runtime" == "aspnetcore" ]]; then

download_link="$azure_feed/aspnetcore/Runtime/$specific_version/aspnetcore-runtime-$specific_product_version-$osname-$normalized_architecture.tar.gz"

elif [ -z "$runtime" ]; then

download_link="$azure_feed/Sdk/$specific_version/dotnet-sdk-$specific_product_version-$osname-$normalized_architecture.tar.gz"

else

return 1

fi

echo "$download_link"

return 0

# If we find a 'productVersion.txt' at the root of any folder, we'll use its contents

# to resolve the version of what's in the folder, superseding the specified version.

# if 'productVersion.txt' is missing but download link is already available, product version will be taken from download link

eval $invocation

local azure_feed="$1"

local specific_version="${2//[$'\t\r\n']}"

local package_download_link=""

if [ $# -gt 2 ]; then

local package_download_link="$3"

fi

local specific_product_version=null

# Try to get the version number, using the productVersion.txt file located next to the installer file.

local download_links=($(get_specific_product_version_url "$azure_feed" "$specific_version" true "$package_download_link")

$(get_specific_product_version_url "$azure_feed" "$specific_version" false "$package_download_link"))

for download_link in "${download_links[@]}"

do

say_verbose "Checking for the existence of $download_link"

if machine_has "curl"

then

if ! specific_product_version=$(curl -sL --fail "${download_link}${feed_credential}" 2>&1); then

continue

else

echo "${specific_product_version//[$'\t\r\n']}"

return 0

fi

elif machine_has "wget"

then

specific_product_version=$(wget -qO- "${download_link}${feed_credential}" 2>&1)

if [ $? = 0 ]; then

echo "${specific_product_version//[$'\t\r\n']}"

return 0

fi

fi

done

# Getting the version number with productVersion.txt has failed. Try parsing the download link for a version number.

say_verbose "Failed to get the version using productVersion.txt file. Download link will be parsed instead."

specific_product_version="$(get_product_specific_version_from_download_link "$package_download_link" "$specific_version")"

echo "${specific_product_version//[$'\t\r\n']}"

return 0

eval $invocation

local azure_feed="$1"

local specific_version="$2"

local is_flattened="$3"

local package_download_link=""

if [ $# -gt 3 ]; then

local package_download_link="$4"

fi

local pvFileName="productVersion.txt"

if [ "$is_flattened" = true ]; then

if [ -z "$runtime" ]; then

pvFileName="sdk-productVersion.txt"

elif [[ "$runtime" == "dotnet" ]]; then

pvFileName="runtime-productVersion.txt"

else

pvFileName="$runtime-productVersion.txt"

fi

fi

local download_link=null

if [ -z "$package_download_link" ]; then

if [[ "$runtime" == "dotnet" ]]; then

download_link="$azure_feed/Runtime/$specific_version/${pvFileName}"

elif [[ "$runtime" == "aspnetcore" ]]; then

download_link="$azure_feed/aspnetcore/Runtime/$specific_version/${pvFileName}"

elif [ -z "$runtime" ]; then

download_link="$azure_feed/Sdk/$specific_version/${pvFileName}"

else

return 1

fi

else

download_link="${package_download_link%/*}/${pvFileName}"

fi

say_verbose "Constructed productVersion link: $download_link"

echo "$download_link"

return 0

{

eval $invocation

local download_link="$1"

local specific_version="$2"

local specific_product_version=""

if [ -z "$download_link" ]; then

echo "$specific_version"

return 0

fi

#get filename

filename="${download_link##*/}"

#product specific version follows the product name

#for filename 'dotnet-sdk-3.1.404-linux-x64.tar.gz': the product version is 3.1.404

IFS='-'

read -ra filename_elems <<< "$filename"

count=${#filename_elems[@]}

if [[ "$count" -gt 2 ]]; then

specific_product_version="${filename_elems[2]}"

else

specific_product_version=$specific_version

fi

unset IFS;

echo "$specific_product_version"

return 0

eval $invocation

local azure_feed="$1"

local channel="$2"

local normalized_architecture="$3"

local specific_version="${4//[$'\t\r\n']}"

local distro_specific_osname

distro_specific_osname="$(get_legacy_os_name)" || return 1

local legacy_download_link=null

if [[ "$runtime" == "dotnet" ]]; then

legacy_download_link="$azure_feed/Runtime/$specific_version/dotnet-$distro_specific_osname-$normalized_architecture.$specific_version.tar.gz"

elif [ -z "$runtime" ]; then

legacy_download_link="$azure_feed/Sdk/$specific_version/dotnet-dev-$distro_specific_osname-$normalized_architecture.$specific_version.tar.gz"

else

return 1

fi

echo "$legacy_download_link"

return 0

eval $invocation

if [ ! -z "${DOTNET_INSTALL_DIR:-}" ]; then

echo "$DOTNET_INSTALL_DIR"

else

echo "$HOME/.dotnet"

fi

return 0

eval $invocation

local install_dir=$1

if [ "$install_dir" = "<auto>" ]; then

local user_install_path="$(get_user_install_path)"

say_verbose "resolve_installation_path: user_install_path=$user_install_path"

echo "$user_install_path"

return 0

fi

echo "$install_dir"

return 0

eval $invocation

local relative_or_absolute_path=$1

echo "$(cd "$(dirname "$1")" && pwd -P)/$(basename "$1")"

return 0

eval $invocation

local override="$1"

local override_switch=""

if [ "$override" = false ]; then

override_switch="-n"

# create temporary files to check if 'cp -u' is supported

tmp_dir="$(mktemp -d)"

tmp_file="$tmp_dir/testfile"

tmp_file2="$tmp_dir/testfile2"

touch "$tmp_file"

# use -u instead of -n if it's available

if cp -u "$tmp_file" "$tmp_file2" 2>/dev/null; then

override_switch="-u"

fi

# clean up

rm -f "$tmp_file" "$tmp_file2"

rm -rf "$tmp_dir"

fi

echo "$override_switch"

eval $invocation

local root_path="$(remove_trailing_slash "$1")"

local out_path="$(remove_trailing_slash "$2")"

local override="$3"