container-session

#!/bin/bash

# dependencies /////////////////////////////////////////////////////////////////

if [[ -z $(command -v frobulator) ]]
then
	if [[ $(id -u -n) = "root" ]]
	then
		SUDO_HOME=/root

		USER="${SUDO_USER}"

		HOME=/home/"${USER}"
	fi

	if [[ -z $(command -v curl) ]]
	then
		yes | apt-get install curl
	fi

	if [ ! -d "${HOME}"/.local/bin ]
	then
		mkdir -p "${HOME}"/.local/bin
	fi

	curl -s -L get.frbltr.app > "${HOME}"/.local/bin/frobulator

	chmod +x "${HOME}"/.local/bin/frobulator
fi

. "${HOME}"/.local/bin/frobulator

# script ///////////////////////////////////////////////////////////////////////

script=$(basename -- "${BASH_SOURCE[0]}")

# version //////////////////////////////////////////////////////////////////////

version="12-05-2024"

# usage ////////////////////////////////////////////////////////////////////////

while (($#))
do
	case "${1}"
	in
		-o|--start)
			option="start"
		;;

		-x|--stop)
			option="stop"
		;;

		-u|--username)
			option="username"
			user_name="${2}"

			shift
		;;

		-d|--directory)
			option="directory"
			container_directory="${2}"

			shift
		;;

		-h|--help)
			echo
			echo -e "Usage: ${script} -o [Display Server] | -x | -u [User Name] | -d [Directory] | [OPTION]"
			echo
			echo -e "Options:"
			echo
			echo -e "-o, --start          Start display session."
			echo
			echo -e "-x, --stop           Stop display session."
			echo
			echo -e "-u, --username       Specify user name for session login."
			echo
			echo -e "-d, --directory      Specify container base directory as /path/to/base/directory containing /distribution/version"
			echo
			echo -e "-h, --help           Show help and usage information."
			echo
			echo -e "'${script}' [ Version // ${version} ]"
			echo

			exit
		;;

			"")
				# handle empty argument:
				# use default values specified in script

				:
			;;

		*)
			echo
			echo -e "Usage: ${script} -o [Display Server] | -x | -u [User Name] | -d [Directory] | [OPTION]"
			echo
			echo -e "${script}: Unknown option '${1}'"
			echo -e "Type './${script} --help' for help and usage information."
			echo

			exit 1
		;;

	esac

	shift

done

# prompt ///////////////////////////////////////////////////////////////////////

frobulator.script "Setting up ${script#*-}"

# variables ////////////////////////////////////////////////////////////////////

TERMUX_X11_APPLICATION="com.termux.x11"
TERMUX_X11_SERVER="termux-x11"
TERMUX_X11_DRIVER="virpipe"
TERMUX_X11_ACCELERATOR="virgl_test_server_android"

termux_x11_activity="com.termux.x11/.MainActivity"
termux_x11_activity_stop="com.termux.x11.ACTION_STOP"

termux_x11_process="app_process -Xnoimage-dextooat / com.termux.x11.Loader"

# defaults /////////////////////////////////////////////////////////////////////

if [ -z "${COLORTERM}" ]
then
	COLORTERM="truecolor"
fi

if [ -z "${TERM}" ]
then
	TERM="xterm-256color"
fi

if [ -z "${TMPDIR}" ]
then
	TMPDIR="${TMPDIR}"
fi

if [ -z "${LANG}" ]
then
	LANG="${LANG}"
fi

if [ -z "${SHELL}" ]
then
	SHELL="/bin/bash"
fi

if [ -z "${DISPLAY}" ]
then
	DISPLAY=":0"
fi

if [ -z "${user_name}" ]
then
	user_name="termux"
fi

if [ -f /etc/os-release ]
then
	. /etc/os-release

	name="${ID}"
	version="${VERSION_ID}"
fi

# exports //////////////////////////////////////////////////////////////////////

export TERMUX_X11_APPLICATION="${TERMUX_X11_APPLICATION}"
export TERMUX_X11_SERVER="${TERMUX_X11_SERVER}"
export TERMUX_X11_DRIVER="${TERMUX_X11_DRIVER}"
export TERMUX_X11_ACCELERATOR="${TERMUX_X11_ACCELERATOR}"

# functions ////////////////////////////////////////////////////////////////////

container_parse () {

	# parse container directories

	for distribution in "${CONTAINER_BASE}"/*
	do
		for version in "${distribution}"/*
		do
			distribution_name=$(basename ${distribution})

			distribution_version=$(basename ${version})

			containers+=(${distribution_name} ${distribution_version})
		done
	done

	if [[ ${#CONTAINER_ROOT[@]} -eq 1 ]]
	then
		distribution_name="${distribution_name}"
		distribution_version="${distribution_version}"

		frobulator.inf "Single container found" "[ ${distribution_name} // ${distribution_version} ]"
		echo

		frobulator.fwd "Proceeding${marker_elp}"
		echo
	fi

	if [[ ${#CONTAINER_ROOT[@]} -ge 2 ]]
	then
		frobulator.ipt "Select one of the following containers:"
		echo

		# set padding for uniform output

		pad_length=10

		# normalize output

		echo

		# continue list using array selection of suppported values

		for (( i=0 ; i<${#containers[@]} ; i+=2 ))
		do
			number=$((($i/2) + 1))

			name="${containers[$i]}"
			version="${containers[$i+1]}"

			indent="${marker_tab}"

			if [ ${#version} -le 2 ]
			then
				indent+="${marker_tab}"
			fi

			if (( $i/2 >= 0 && $i/2 <= 8 ))
			then
				# handle number spacing for entries 1-9

				number=" ${number}"
			else
				# handle number spacing for entries 10+

				number="${number}"
			fi

			# list container entries

			echo "${marker_nul}" "[ ${number} ]" "${name}" "${version}"

		done

		echo

		# values #

		values_list=(
			selection
		)

		# handle user input for values_list

		eval ${frobulator_return[@]}

		frobulator.ipt "Selection:"

		frobulator.read selection

		# integer check:
		# handle numerical selection

		while [[ "${selection}" -lt 1         ]] || \
			[[ "${selection}" -gt "${number}" ]] || \
			[[ ! "${selection}" =~ ^[0-9]+$   ]]
		do
			echo
			frobulator.err "Invalid selection:"
			echo

			frobulator.wrn "Select container [ 1 - ${number} ]"
			echo

			frobulator.ipt "Selection:"

			frobulator.read selection

		done

		# parse selection parameters

		i=$(( ${selection} ))
		i=$(( $i * 2 ))

		name="${containers[i-2]}"
		version="${containers[i-1]}"

		distribution_name="${name}"
		distribution_version="${version}"

	fi

	# unset array

	containers=()

	# specify distribution selection variables

	distribution_name="${name}"
	distribution_version="${version}"

	CONTAINER_ROOT="${CONTAINER_BASE}"/"${distribution_name}"/"${distribution_version}"

	# specify container_directory for container input handling

	container_directory="${CONTAINER_BASE}"
}

container_input () {

	# no container root specified

	if [ -z "${container_directory}" ]
	then
		CONTAINER_BASE="${PREFIX}"/cnt
		CONTAINER_ROOT=("${CONTAINER_BASE}"/*/*)

		container_directory=("${CONTAINER_ROOT}")

		frobulator.wrn "Container directory not specified."
		echo

		container_parse
	fi

	# user specified invalid container root

	if [ ! -e "${container_directory}" ]
	then
		CONTAINER_BASE="${PREFIX}"/cnt
		CONTAINER_ROOT=("${CONTAINER_BASE}"/*/*)

		frobulator.err "Container directory not found."
		echo

		container_parse
	fi

	# user specified container root exists

	if [ -d "${container_directory}" ]
	then
		CONTAINER_BASE="${container_directory}"
		CONTAINER_ROOT=("${CONTAINER_BASE}"/*/*)

		frobulator.scs "Container directory found."
		echo
	fi
}

container_user () {

	# authentication

	frobulator.fwd "Authenticating${marker_elp}"
	echo

	# verify user existence:
	# loop through container's /etc/passwd file and make sure 'user' exists
	# source environment variables when 'user' corresponds to 'username'
	# default to 'root' if 'username' is invalid, is not specified or does not exist

	last_entry="$(tail -n 1 "${CONTAINER_ROOT}"/etc/passwd)"

	while read -r entry
	do
		IFS=':'

		read USER _ USER_ID GROUP_ID GECOS HOME SHELL <<< "${entry}"

		IFS=','

		read FULL_NAME ROOM_NUMBER WORK_PHONE HOME_PHONE USER_EMAIL <<< "${GECOS}"

		# reset IFS

		IFS=' '

		# verify login options and parameters

		# no user name specified

		if [[ -z "${user_name}" ]]
		then
			user_name="root"

			USER="root"

			USER_ID="0"
			GROUP_ID="0"

			UID="${USER_ID}"
			GID="${GROUP_ID}"

			if [ -d "${CONTAINER_ROOT}"/root ]
			then
				HOME="/root"
			else
				HOME="/"
			fi

			frobulator.wrn "No user name - Defaulting" "[ '${user_name}' ]"
			echo

			break
		fi

		# valid user name found

		if [[ "${user_name}" == "${USER}" ]]
		then
			USER="${user_name}"

			if [[ "${user_name}" == "root" ]]
			then
				frobulator.wrn "Valid user name - Superuser" "[ '${user_name}' ]"
				echo
			else
				frobulator.scs "Valid user name - Accessing" "[ '${user_name}' ]"
				echo
			fi

			break
		fi

		# user naem not found

		if [[ "${entry}" == "${last_entry}" ]]
		then

			frobulator.err "Invalid user name - Aborting" "[ '${user_name}' ]"
			echo

			exit 1
		fi

	done < "${CONTAINER_ROOT}"/etc/passwd
}

container_environment () {

	# generate container environment

	# set path:
	# in order of retreival

	CONTAINER_PATH=""

	# container

	[ -d "${CONTAINER_ROOT}"/usr/local/sbin ] && CONTAINER_PATH+="/usr/local/sbin:"
	[ -d "${CONTAINER_ROOT}"/usr/local/bin ]  && CONTAINER_PATH+="/usr/local/bin:"
	[ -d "${CONTAINER_ROOT}"/usr/sbin ]       && CONTAINER_PATH+="/usr/sbin:"
	[ -d "${CONTAINER_ROOT}"/usr/sbin ]       && CONTAINER_PATH+="/usr/bin:"
	[ -d "${CONTAINER_ROOT}"/sbin ]           && CONTAINER_PATH+="/sbin:"
	[ -d "${CONTAINER_ROOT}"/bin ]            && CONTAINER_PATH+="/bin:"

	# termux

	[ -d "${HOME}"/.local/bin ]               && CONTAINER_PATH+="${HOME}/.local/bin:"

	[ -d "${PREFIX}"/sbin ]                   && CONTAINER_PATH+="${PREFIX}/sbin:"
	[ -d "${PREFIX}"/bin ]                    && CONTAINER_PATH+="${PREFIX}/bin:"

	# android

	[ -d /system/sbin ]                       && CONTAINER_PATH+="/system/sbin:"
	[ -d /system/bin ]                        && CONTAINER_PATH+="/system/bin:"

	CONTAINER_PATH="${CONTAINER_PATH}"

	export CONTAINER_PATH="${CONTAINER_PATH}"

	return
}

container_intent () {

	# load session settings

	# assume 'termux-exec' is installed

	unset LD_PRELOAD

	# generate container environment

	container_environment

	# setup 'proot' command arguments

	unset session_command

	session_command+="proot"
	session_command+=" --kill-on-exit"
	session_command+=" --link2symlink"
	session_command+=" --rootfs=${CONTAINER_ROOT}"
	session_command+=" --change-id=${USER_ID}:${GROUP_ID}"
	session_command+=" --pwd=${HOME}"

    [ -d "/apex" ]                                && session_command+=" --bind=/apex:/apex"
    [ -e "/linkerconfig/ld.config.txt" ]          && session_command+=" --bind=/linkerconfig/ld.config.txt:/linkerconfig/ld.config.txt"

	# system directories

    [ -d "/data" ]                                && session_command+=" --bind=/data:/data"
    [ -d "/dev" ]                                 && session_command+=" --bind=/dev:/dev"
    [ -e "/dev/urandom" ]                         && session_command+=" --bind=/dev/urandom:/dev/random"
    [ -d "/proc" ]                                && session_command+=" --bind=/proc:/proc"
    [ -d "/proc/self/fd" ]                        && session_command+=" --bind=/proc/self/fd:/dev/fd"
    [ -e "/proc/self/fd/0" ]                      && session_command+=" --bind=/proc/self/fd/0:/dev/stdin"
    [ -e "/proc/self/fd/1" ]                      && session_command+=" --bind=/proc/self/fd/1:/dev/stdout"
    [ -e "/proc/self/fd/2" ]                      && session_command+=" --bind=/proc/self/fd/2:/dev/stderr"
    [ -d "/storage" ]                             && session_command+=" --bind=/storage:/storage"
    [ -d "/sys" ]                                 && session_command+=" --bind=/sys:/sys"
    [ -d "/system" ]                              && session_command+=" --bind=/system:/system"
    [ -d "/vendor" ]                              && session_command+=" --bind=/vendor:/vendor"

	[ -d "${PREFIX%/*}"/home ]                    && session_command+=" --bind=${PREFIX%/*}/home:${HOME}"
	[ -d "${PREFIX}"/media ]                      && session_command+=" --bind=${PREFIX}/media:/media"
	[ -d "${PREFIX}"/tmp ]                        && session_command+=" --bind=${PREFIX}/tmp:/tmp"

	# environment

    session_command+=" env"
    session_command+=" --ignore-environment"

    # android

	session_command+=" ANDROID_ART_ROOT=${ANDROID_ART_ROOT}"
	session_command+=" ANDROID_DATA=${ANDROID_DATA}"
	session_command+=" ANDROID_I18N_ROOT=${ANDROID_I18N_ROOT}"
	session_command+=" ANDROID_ROOT=${ANDROID_ROOT}"
	session_command+=" ANDROID_RUNTIME_ROOT=${ANDROID_RUNTIME_ROOT}"
	session_command+=" ANDROID_TZDATA_ROOT=${ANDROID_TZDATA_ROOT}"
	session_command+=" BOOTCLASSPATH=${BOOTCLASSPATH}"
	session_command+=" DEX2OATBOOTCLASSPATH=${DEX2OATBOOTCLASSPATH}"

	# termux

	session_command+=" PREFIX=${PREFIX}"
	session_command+=" TERMUX_BINARIES=${PREFIX}/bin"
	session_command+=" TERMUX_VERSION=${TERMUX_VERSION}"

	# container

	session_command+=" PATH=${PATH}:${CONTAINER_PATH}"
	session_command+=" COLORTERM=${COLORTERM}"
	session_command+=" DISPLAY=${DISPLAY}"
	session_command+=" DISPLAY_DRIVER=${DISPLAY_DRIVER}"
	session_command+=" HOME=${HOME}"
	session_command+=" LANG=${LANG}"
	session_command+=" SHELL=${SHELL}"
	session_command+=" TERM=${TERM}"
	session_command+=" TMPDIR=${TMPDIR}"
	session_command+=" USER=${USER}"
	session_command+=" XDG_CACHE_HOME=${HOME}/.cache"
	session_command+=" XDG_CONFIG_DIRS=/etc/xdg"
	session_command+=" XDG_CONFIG_HOME=${HOME}/.config"
	session_command+=" XDG_DATA_DIRS=/usr/local/share:/usr/share"
	session_command+=" XDG_DATA_HOME=${HOME}/.local/share"
	session_command+=" XDG_RUNTIME_DIR=/run/user/${USER_ID}"
	session_command+=" XDG_STATE_HOME=${HOME}/.local/state"
	session_command+=" XAUTHORITY=${XDG_RUNTIME_DIR}/Xauthority"

	# command

	session_command+=" ${@}"

	# execute 'proot' login

	${session_command}
}

container_display () {

	display_activity="${termux_x11_activity}"

	unset intent_command

	intent_command+="am start"
	intent_command+=" --user 0"
	intent_command+=" -n ${display_activity}"

	frobulator.silence "${intent_command}"
}

container_session () {

	# load session

	frobulator.fwd "Loading desktop interface${marker_elp}"
	echo

	if [ -z "${environment}" ]
	then
		environment="$(cat ${HOME}/.dextop/dextop-environment)"
	fi

	if [ -z "${session}" ]
	then
		session="$(cat ${HOME}/.dextop/dextop-session)"
	fi

	# pause:
	# required to let session loader through messaging system
	# and load graphical interface

	sleep 2

	# load desktop environment

	frobulator.silence "dbus-launch --exit-with-session ${session}" &
}

display_start () {

	# start display server and activity

	GALLIUM_DRIVER="${TERMUX_X11_DRIVER}"

	export GALLIUM_DRIVER="${GALLIUM_DRIVER}"

	if [[ $(pgrep -f dbus) ]]
	then
		pkill -f dbus
	fi

	if [[ $(pgrep -f "${TERMUX_X11_ACCELERATOR}") ]]
	then
		pkill -f "${TERMUX_X11_ACCELERATOR}"
	fi

	frobulator.silence "${TERMUX_X11_ACCELERATOR}" &

	if [[ $(pgrep -f "${TERMUX_X11_APPLICATION}") ]]
	then
		:
	else
		frobulator.silence "${TERMUX_X11_SERVER} ${DISPLAY}" &
	fi

	frobulator.fwd "Opening display${marker_elp}"
	echo

	display_activity="${termux_x11_activity}"

	unset intent_command

	intent_command+="am start"
	intent_command+=" --user 0"
	intent_command+=" -n ${display_activity}"

	frobulator.silence "${intent_command}" &
}

display_stop () {

	# handle and stop display server and activity

	if [[ $(pgrep -f "${TERMUX_X11_APPLICATION}") ]]
	then
		pkill -f "${TERMUX_X11_APPLICATION}"

		display_activity="${termux_x11_activity_stop}"

		unset intent_command

		intent_command+="am broadcast"
		intent_command+=" --user 0"
		intent_command+=" -a ${display_activity}"

		frobulator.silence "${intent_command}" &

		frobulator.process "Stopping display viewer"
	else
		frobulator.wrn "No active display process detected."
		echo

		frobulator.fwd "Exiting${marker_elp}"
		echo
	fi
}

if [ "${option}" = "start" ]
then
	# start display session

	display_start

	# load session

	container_session
fi

if [ "${option}" = "stop" ]
then
	# stop display session

	display_stop
fi

if [ "${option}" = "username" ]
then
	# handle manual container directory input

	container_input

	# validate username

	container_user

	# start container session

	container_intent "${SHELL}"
fi

if [ "${option}" = "directory" ]
then
	# handle manual container directory input

	container_input

	# validate username

	container_user

	# start container session

	container_intent "${SHELL}"
fi