[thirdparty/util-linux.git] / tests / functions.sh

#
# Copyright (C) 2007 Karel Zak <kzak@redhat.com>
#
# This file is part of util-linux.
#
# This file is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This file is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#


function ts_abspath {
	cd $1
	pwd
}

function ts_canonicalize {
	P="$1"
	C=$(readlink -f $P)

	if [ -n "$C" ]; then
		echo "$C"
	else
		echo "$P"
	fi
}

function ts_cd {
	if [ $# -eq 0 ]; then
		ts_failed "ul_cd: not enough arguments"
	fi
	DEST=$(readlink -f "$1" 2>/dev/null)
	if [ "x$DEST" = "x" ] || [ ! -d "$DEST" ]; then
		ts_failed "ul_cd: $1: no such directory"
	fi
	cd "$DEST" 2>/dev/null || ts_failed "ul_cd: $1: cannot change directory"
	if [ "$PWD" != "$DEST" ]; then
		ts_failed "ul_cd: $PWD is not $DEST"
	fi
}

function ts_report {
	if [ "$TS_PARALLEL" == "yes" ]; then
		echo "$TS_TITLE $1"
	else
		echo "$1"
	fi
}

function ts_check_test_command {
	if [ ! -x "$1" ]; then
		ts_skip "${1##*/} not found"
	fi
}

function ts_check_prog {
	local cmd=$1
	type "$cmd" >/dev/null 2>&1 || ts_skip "missing in PATH: $cmd"
}

function ts_check_losetup {
	local tmp
	ts_check_test_command "$TS_CMD_LOSETUP"

	if [ "$TS_SKIP_LOOPDEVS" = "yes" ]; then
		ts_skip "loop-device tests disabled"
	fi

	# assuming that losetup -f works ... to be checked somewhere else
	tmp=$($TS_CMD_LOSETUP -f 2>/dev/null)
	if test -b "$tmp"; then
		return 0
	fi
	ts_skip "no loop-device support"
}

function ts_skip_subtest {
	ts_report " SKIPPED ($1)"
}

function ts_skip {
	ts_skip_subtest "$1"

	ts_cleanup_on_exit
	exit 0
}

function ts_skip_nonroot {
	if [ $UID -ne 0 ]; then
		ts_skip "no root permissions"
	fi
}

function ts_failed_subtest {
	local msg="FAILED"
	local ret=1
	if [ "$TS_KNOWN_FAIL" = "yes" ]; then
		msg="KNOWN FAILED"
		ret=0
	fi

	if [ x"$1" == x"" ]; then
		ts_report " $msg ($TS_NS)"
	else
		ts_report " $msg ($1)"
	fi

	return $ret
}

function ts_failed {
	ts_failed_subtest "$1"
	exit $?
}

function ts_ok_subtest {
	if [ x"$1" == x"" ]; then
		ts_report " OK"
	else
		ts_report " OK ($1)"
	fi
}

function ts_ok {
	ts_ok_subtest "$1"
	exit 0
}

function ts_log {
	echo "$1" >> $TS_OUTPUT
	[ "$TS_VERBOSE" == "yes" ] && echo "$1"
}

function ts_has_option {
	NAME="$1"
	ALL="$2"

	# user may set options by env for a single test or whole component
	# e.g. TS_OPT_ipcs_limits2_fake="yes" or TS_OPT_ipcs_fake="yes"
	local v_test=${TS_TESTNAME//[-.]/_}
	local v_comp=${TS_COMPONENT//[-.]/_}
	local v_name=${NAME//[-.]/_}
	eval local env_opt_test=\$TS_OPT_${v_comp}_${v_test}_${v_name}
	eval local env_opt_comp=\$TS_OPT_${v_comp}_${v_name}
	if [ "$env_opt_test" = "yes" \
		-o "$env_opt_comp" = "yes" -a "$env_opt_test" != "no" ]; then
		echo "yes"
		return
	elif [ "$env_opt_test" = "no" \
		-o "$env_opt_comp" = "no" -a "$env_opt_test" != "yes" ]; then
		return
	fi

	# or just check the global command line options
	if [[ $ALL =~ ([$' \t\n']|^)--$NAME([$'= \t\n']|$) ]]; then echo yes; fi
}

function ts_option_argument {
	NAME="$1"
	ALL="$2"

	# last option wins!
	echo "$ALL" | sed -n "s/.*[ \t\n]--$NAME=\([^ \t\n]*\).*/\1/p" | tail -n 1
}

function ts_init_core_env {
	TS_NS="$TS_COMPONENT/$TS_TESTNAME"
	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME"
	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME.vgdump"
	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME"
	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-mnt"
}

function ts_init_core_subtest_env {
	TS_NS="$TS_COMPONENT/$TS_TESTNAME-$TS_SUBNAME"
	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME"
	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME.vgdump"
	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME-$TS_SUBNAME"
	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-${TS_SUBNAME}-mnt"

	rm -f $TS_OUTPUT $TS_VGDUMP
	[ -d "$TS_OUTDIR" ]  || mkdir -p "$TS_OUTDIR"

	touch $TS_OUTPUT
	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
}

function ts_init_env {
	local mydir=$(ts_abspath ${0%/*})
	local tmp

	LANG="POSIX"
	LANGUAGE="POSIX"
	LC_ALL="POSIX"
	CHARSET="UTF-8"

	export LANG LANGUAGE LC_ALL CHARSET

	mydir=$(ts_canonicalize "$mydir")

	# automake directories
	top_srcdir=$(ts_option_argument "srcdir" "$*")
	top_builddir=$(ts_option_argument "builddir" "$*")

	# where is this script
	TS_TOPDIR=$(ts_abspath $mydir/../../)

	# default
	if [ -z "$top_srcdir" ]; then
		top_srcdir="$TS_TOPDIR/.."
	fi
	if [ -z "$top_builddir" ]; then
		top_builddir="$TS_TOPDIR/.."
	fi

	top_srcdir=$(ts_abspath $top_srcdir)
	top_builddir=$(ts_abspath $top_builddir)

	# some ul commands search other ul commands in $PATH
	export PATH="$top_builddir:$PATH"

	TS_SCRIPT="$mydir/$(basename $0)"
	TS_SUBDIR=$(dirname $TS_SCRIPT)
	TS_TESTNAME=$(basename $TS_SCRIPT)
	TS_COMPONENT=$(basename $TS_SUBDIR)
	TS_DESC=${TS_DESC:-$TS_TESTNAME}

	TS_NSUBTESTS=0
	TS_NSUBFAILED=0

	TS_SELF="$TS_SUBDIR"

	TS_OUTDIR="$top_builddir/tests/output/$TS_COMPONENT"
	TS_DIFFDIR="$top_builddir/tests/diff/$TS_COMPONENT"

	ts_init_core_env

	TS_VERBOSE=$(ts_has_option "verbose" "$*")
	TS_PARALLEL=$(ts_has_option "parallel" "$*")
	TS_KNOWN_FAIL=$(ts_has_option "known-fail" "$*")
	TS_SKIP_LOOPDEVS=$(ts_has_option "skip-loopdevs" "$*")

	tmp=$( ts_has_option "memcheck" "$*")
	if [ "$tmp" == "yes" -a -f /usr/bin/valgrind ]; then
		TS_VALGRIND_CMD="/usr/bin/valgrind"
	fi

	BLKID_FILE="$TS_OUTDIR/${TS_TESTNAME}.blkidtab"

	declare -a TS_SUID_PROGS
	declare -a TS_SUID_USER
	declare -a TS_SUID_GROUP
	declare -a TS_LOOP_DEVS

	if [ -f $TS_TOPDIR/commands.sh ]; then
		. $TS_TOPDIR/commands.sh
	fi

	export BLKID_FILE

	rm -f $TS_OUTPUT $TS_VGDUMP
	[ -d "$TS_OUTDIR" ]  || mkdir -p "$TS_OUTDIR"

	touch $TS_OUTPUT
	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP

	if [ "$TS_VERBOSE" == "yes" ]; then
		echo
		echo "     script: $TS_SCRIPT"
		echo "    sub dir: $TS_SUBDIR"
		echo "    top dir: $TS_TOPDIR"
		echo "       self: $TS_SELF"
		echo "  test name: $TS_TESTNAME"
		echo "  test desc: $TS_DESC"
		echo "  component: $TS_COMPONENT"
		echo "  namespace: $TS_NS"
		echo "    verbose: $TS_VERBOSE"
		echo "     output: $TS_OUTPUT"
		echo "   valgrind: $TS_VGDUMP"
		echo "   expected: $TS_EXPECTED"
		echo " mountpoint: $TS_MOUNTPOINT"
		echo
	fi
}

function ts_init_subtest {

	TS_SUBNAME="$1"

	ts_init_core_subtest_env

	[ $TS_NSUBTESTS -eq 0 ] && echo
	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))

	if [ "$TS_PARALLEL" == "yes" ]; then
		TS_TITLE=$(printf "%13s: %-30s ...\n%16s: %-27s ..." "$TS_COMPONENT" "$TS_DESC" "" "$TS_SUBNAME")
	else
		TS_TITLE=$(printf "%16s: %-27s ..." "" "$TS_SUBNAME")
		echo -n "$TS_TITLE"
	fi
}

function ts_init {
	ts_init_env "$*"

	local is_fake=$( ts_has_option "fake" "$*")
	local is_force=$( ts_has_option "force" "$*")

	if [ "$TS_PARALLEL" == "yes" ]; then
		TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
	else
		TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
		echo -n "$TS_TITLE"
	fi

	[ "$is_fake" == "yes" ] && ts_skip "fake mode"
	[ "$TS_OPTIONAL" == "yes" -a "$is_force" != "yes" ] && ts_skip "optional"
}

function ts_init_suid {
	PROG="$1"
	ct=${#TS_SUID_PROGS[*]}

	# Save info about original setting
	TS_SUID_PROGS[$ct]=$PROG
	TS_SUID_USER[$ct]=$(stat --printf="%U" $PROG)
	TS_SUID_GROUP[$ct]=$(stat --printf="%G" $PROG)

	chown root.root $PROG &> /dev/null
	chmod u+s $PROG &> /dev/null
}

function ts_init_py {
	LIBNAME="$1"

	[ -f "$top_builddir/py${LIBNAME}.la" ] || ts_skip "py${LIBNAME} not compiled"

	export LD_LIBRARY_PATH="$top_builddir/.libs:$LD_LIBRARY_PATH"
	export PYTHONPATH="$top_builddir/$LIBNAME/python:$top_builddir/.libs:$PYTHONPATH"

	export PYTHON_VERSION=$(awk '/^PYTHON_VERSION/ { print $3 }' $top_builddir/Makefile)
	export PYTHON_MAJOR_VERSION=$(echo $PYTHON_VERSION | sed 's/\..*//')

	export PYTHON="python${PYTHON_MAJOR_VERSION}"
}

function ts_valgrind {
	if [ -z "$TS_VALGRIND_CMD" ]; then
		$*
	else
		$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
				 --leak-resolution=high --num-callers=20 \
				 --log-file="$TS_VGDUMP" $*
	fi
}

function ts_gen_diff {
	local res=0

	if [ -s "$TS_OUTPUT" ]; then

		# remove libtool lt- prefixes
		sed --in-place 's/^lt\-\(.*\: \)/\1/g' $TS_OUTPUT

		[ -d "$TS_DIFFDIR" ] || mkdir -p "$TS_DIFFDIR"
		diff -u $TS_EXPECTED $TS_OUTPUT > $TS_DIFF

		if [ -s $TS_DIFF ]; then
			res=1
		else
			rm -f $TS_DIFF;
		fi
	else
		res=1
	fi
	return $res
}

function tt_gen_mem_report {
	[ -z "$TS_VALGRIND_CMD" ] && echo "$1"

	grep -q -E 'ERROR SUMMARY: [1-9]' $TS_VGDUMP &> /dev/null
	if [ $? -eq 0 ]; then
		echo "mem-error detected!"
	fi
}

function ts_finalize_subtest {
	local res=0

	if [ -s "$TS_EXPECTED" ]; then
		ts_gen_diff
		if [ $? -eq 1 ]; then
			ts_failed_subtest "$1"
			res=1
		else
			ts_ok_subtest "$(tt_gen_mem_report "$1")"
		fi
	else
		ts_skip_subtest "output undefined"
	fi

	[ $res -ne 0 ] && TS_NSUBFAILED=$(( $TS_NSUBFAILED + 1 ))

	# reset environment back to parental test
	ts_init_core_env

	return $res
}

function ts_finalize {
	ts_cleanup_on_exit

	if [ $TS_NSUBTESTS -ne 0 ]; then
		printf "%11s..."
		if [ $TS_NSUBFAILED -ne 0 ]; then
			ts_failed "$TS_NSUBFAILED from $TS_NSUBTESTS sub-tests"
		else
			ts_ok "all $TS_NSUBTESTS sub-tests PASSED"
		fi
	fi

	if [ -s $TS_EXPECTED ]; then
		ts_gen_diff
		if [ $? -eq 1 ]; then
			ts_failed "$1"
		fi
		ts_ok "$1"
	fi

	ts_skip "output undefined"
}

function ts_die {
	ts_log "$1"
	ts_finalize
}

function ts_cleanup_on_exit {

	for idx in $(seq 0 $((${#TS_SUID_PROGS[*]} - 1))); do
		PROG=${TS_SUID_PROGS[$idx]}
		chmod a-s $PROG &> /dev/null
		chown ${TS_SUID_USER[$idx]}.${TS_SUID_GROUP[$idx]} $PROG &> /dev/null
	done

	for dev in "${TS_LOOP_DEVS[@]}"; do
		ts_device_deinit "$dev"
	done
	unset TS_LOOP_DEVS
}

function ts_image_md5sum {
	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	echo $(md5sum "$img" | awk '{printf $1}') $(basename "$img")
}

function ts_image_init {
	local mib=${1:-"5"}	# size in MiBs
	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}

	rm -f $img
	truncate -s "${mib}M" "$img"
	echo "$img"
	return 0
}

function ts_register_loop_device {
	local ct=${#TS_LOOP_DEVS[*]}
	TS_LOOP_DEVS[$ct]=$1
}

function ts_device_init {
	local img
	local dev

	img=$(ts_image_init $1 $2)
	dev=$($TS_CMD_LOSETUP --show -f "$img")
	if [ "$?" != "0" -o "$dev" = "" ]; then
		ts_die "Cannot init device"
	fi

	ts_register_loop_device "$dev"
	TS_LODEV=$dev
}

# call from ts_cleanup_on_exit() only because of TS_LOOP_DEVS maintenance
function ts_device_deinit {
	local DEV="$1"

	if [ -b "$DEV" ]; then
		$TS_CMD_UMOUNT "$DEV" &> /dev/null
		$TS_CMD_LOSETUP -d "$DEV" &> /dev/null
	fi
}

function ts_uuid_by_devname {
	echo $($TS_CMD_BLKID -p -s UUID -o value $1)
}

function ts_label_by_devname {
	echo $($TS_CMD_BLKID -p -s LABEL -o value $1)
}

function ts_fstype_by_devname {
	echo $($TS_CMD_BLKID -p -s TYPE -o value $1)
}

function ts_device_has {
	local TAG="$1"
	local VAL="$2"
	local DEV="$3"
	local vl=""

	case $TAG in
		"TYPE") vl=$(ts_fstype_by_devname $DEV);;
		"LABEL") vl=$(ts_label_by_devname $DEV);;
		"UUID") vl=$(ts_uuid_by_devname $DEV);;
		*) return 1;;
	esac

	if [ "$vl" == "$VAL" ]; then
		return 0
	fi
	return 1
}

function ts_device_has_uuid {
	ts_uuid_by_devname "$1" | egrep -q '^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$'
	return $?
}

function ts_mount {
	local out
	local result
	local msg
	local fs
	local fs_exp=$1
	shift

	out=$($TS_CMD_MOUNT "$@" 2>&1)
	result=$?
	echo -n "$out" >> $TS_OUTPUT

	if [ $result != 0 ] \
		&& msg=$(echo "$out" | grep -m1 "unknown filesystem type")
	then
		# skip only if reported fs correctly and if it's not available
		fs=$(echo "$msg" | sed -n "s/.*type '\(.*\)'$/\1/p")
		[ "$fs" = "fs_exp" ] \
		 && grep -qe "[[:space:]]${fs}$" /proc/filesystems &>/dev/null \
		 || ts_skip "$msg"
	fi
	return $result
}

function ts_is_mounted {
	local DEV=$(ts_canonicalize "$1")

	grep -q $DEV /proc/mounts && return 0

	if [ "${DEV#/dev/loop/}" != "$DEV" ]; then
		grep -q "/dev/loop${DEV#/dev/loop/}" /proc/mounts && return 0
	fi
	return 1
}

function ts_fstab_open {
	echo "# <!-- util-linux test entry" >> /etc/fstab
}

function ts_fstab_close {
	echo "# -->" >> /etc/fstab
}

function ts_fstab_addline {
	local SPEC="$1"
	local MNT=${2:-"$TS_MOUNTPOINT"}
	local FS=${3:-"auto"}
	local OPT=${4:-"defaults"}

	echo "$SPEC   $MNT   $FS   $OPT   0   0" >> /etc/fstab
}

function ts_fstab_add {
	ts_fstab_open
	ts_fstab_addline $*
	ts_fstab_close
}

function ts_fstab_clean {
	sed --in-place "
/# <!-- util-linux/!b
:a
/# -->/!{
  N
  ba
}
s/# <!-- util-linux.*-->//;
/^$/d" /etc/fstab
}

function ts_fdisk_clean {
	local DEVNAME=$1

	# remove non comparable parts of fdisk output
	if [ -n "${DEVNAME}" ]; then
		sed -i -e "s@${DEVNAME}@<removed>@;" $TS_OUTPUT
	fi

	sed -i \
		-e 's/Disk identifier:.*/Disk identifier: <removed>/' \
		-e 's/Created a new.*/Created a new <removed>./' \
		-e 's/^Device[[:blank:]]*Start/Device             Start/' \
		-e 's/^Device[[:blank:]]*Boot/Device     Boot/' \
		-e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./' \
		-e 's/typescript file.*/typescript file <removed>./' \
		-e 's@^\(I/O size (minimum/op.* bytes /\) [1-9][0-9]* @\1 <removed> @' \
		$TS_OUTPUT
}

function ts_scsi_debug_init {
	local devname
	TS_DEVICE="none"

	# dry run is not really reliable, real modprobe may still fail
	modprobe --dry-run --quiet scsi_debug &>/dev/null \
		|| ts_skip "missing scsi_debug module (dry-run)"

	# skip if still in use or removal of modules not supported at all
	modprobe -r scsi_debug &>/dev/null \
		|| ts_skip "cannot remove scsi_debug module (rmmod)"

	modprobe -b scsi_debug "$@" &>/dev/null \
		|| ts_skip "cannot load scsi_debug module (modprobe)"

	# it might be still not loaded, modprobe.conf or whatever
	lsmod | grep -q "^scsi_debug " \
		|| ts_skip "scsi_debug module not loaded (lsmod)"

	udevadm settle

	devname=$(grep --with-filename scsi_debug /sys/block/*/device/model | awk -F '/' '{print $4}')
	[ "x${devname}" == "x" ] && ts_die "cannot find scsi_debug device"

	TS_DEVICE="/dev/${devname}"
}

function ts_resolve_host {
	local host="$1"
	local tmp

	# currently we just resolve default records (might be "A", ipv4 only)
	if type "dig" >/dev/null 2>&1; then
		tmp=$(dig "$host" +short 2>/dev/null) || return 1
	elif type "nslookup" >/dev/null 2>&1; then
		tmp=$(nslookup "$host" 2>/dev/null) || return 1
		tmp=$(echo "$tmp"| grep -A1 "^Name:"| grep "^Address:"| cut -d" " -f2)
	elif type "host" >/dev/null 2>&1; then
		tmp=$(host "$host" 2>/dev/null) || return 1
		tmp=$(echo "$tmp" | grep " has address " | cut -d " " -f4)
	elif type "getent" >/dev/null 2>&1; then
		tmp=$(getent ahosts "$host" 2>/dev/null) || return 1
		tmp=$(echo "$tmp" | cut -d " " -f 1 | sort -u)
	fi

	# we return 1 if tmp is empty
	test -n "$tmp" || return 1
	echo "$tmp" | sort -R | head -n 1
}

# listen to unix socket (background socat)
function ts_init_socket_to_file {
	local socket=$1
	local outfile=$2
	local pid="0"

	ts_check_prog "socat"
	rm -f "$socket" "$outfile"

	socat -u UNIX-LISTEN:$socket,fork,max-children=1,backlog=128 \
		STDOUT > "$outfile" &
	pid=$!

	# check for running background process
	if [ "$pid" -le "0" ] || ! kill -s 0 "$pid"; then
		ts_skip "unable to run socat"
	fi
	# wait for the socket listener
	if ! socat -u /dev/null UNIX-CONNECT:$socket,retry=30,interval=0.1; then
		kill -9 "$pid"
		ts_skip "timeout waiting for socket"
	fi
	# check socket again
	if ! socat -u /dev/null UNIX-CONNECT:$socket; then
		kill -9 "$pid"
		ts_skip "socket stopped listening"
	fi
}
Commit	Line	Data
92f2c23e KZ	1	#
	2	# Copyright (C) 2007 Karel Zak <kzak@redhat.com>
	3	#
601d12fb	4	# This file is part of util-linux.
92f2c23e KZ	5	#
	6	# This file is free software; you can redistribute it and/or modify
	7	# it under the terms of the GNU General Public License as published by
	8	# the Free Software Foundation; either version 2 of the License, or
	9	# (at your option) any later version.
	10	#
	11	# This file is distributed in the hope that it will be useful,
	12	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	# GNU General Public License for more details.
	15	#
e83446da	16
e83446da	17
a02f320d KZ	18	function ts_abspath {
	19	cd $1
	20	pwd
	21	}
d42bbae5	22
6dfe6f0e KZ	23	function ts_canonicalize {
	24	P="$1"
	25	C=$(readlink -f $P)
	26
	27	if [ -n "$C" ]; then
	28	echo "$C"
	29	else
	30	echo "$P"
	31	fi
	32	}
	33
723c7043 SK	34	function ts_cd {
	35	if [ $# -eq 0 ]; then
	36	ts_failed "ul_cd: not enough arguments"
	37	fi
	38	DEST=$(readlink -f "$1" 2>/dev/null)
	39	if [ "x$DEST" = "x" ] \|\| [ ! -d "$DEST" ]; then
	40	ts_failed "ul_cd: $1: no such directory"
	41	fi
	42	cd "$DEST" 2>/dev/null \|\| ts_failed "ul_cd: $1: cannot change directory"
	43	if [ "$PWD" != "$DEST" ]; then
	44	ts_failed "ul_cd: $PWD is not $DEST"
	45	fi
	46	}
	47
40e6f7a0 SK	48	function ts_report {
	49	if [ "$TS_PARALLEL" == "yes" ]; then
	50	echo "$TS_TITLE $1"
	51	else
	52	echo "$1"
	53	fi
2f791546	54	}
40e6f7a0	55
2f791546 SK	56	function ts_check_test_command {
	57	if [ ! -x "$1" ]; then
	58	ts_skip "${1##*/} not found"
	59	fi
40e6f7a0 SK	60	}
40e6f7a0 SK	61
d1962aae RM	62	function ts_check_prog {
	63	local cmd=$1
	64	type "$cmd" >/dev/null 2>&1 \|\| ts_skip "missing in PATH: $cmd"
	65	}
	66
5ec15aef RM	67	function ts_check_losetup {
	68	local tmp
	69	ts_check_test_command "$TS_CMD_LOSETUP"
	70
d995c2f0	71	if [ "$TS_SKIP_LOOPDEVS" = "yes" ]; then
5f708381 RM	72	ts_skip "loop-device tests disabled"
	73	fi
	74
5ec15aef RM	75	# assuming that losetup -f works ... to be checked somewhere else
	76	tmp=$($TS_CMD_LOSETUP -f 2>/dev/null)
	77	if test -b "$tmp"; then
	78	return 0
	79	fi
0209a128	80	ts_skip "no loop-device support"
5ec15aef RM	81	}
5ec15aef RM	82
09888efe	83	function ts_skip_subtest {
0209a128	84	ts_report " SKIPPED ($1)"
09888efe KZ	85	}
	86
	87	function ts_skip {
	88	ts_skip_subtest "$1"
cbae7931	89
caf31605	90	ts_cleanup_on_exit
b30cd7ee KZ	91	exit 0
	92	}
	93
09892fb6	94	function ts_skip_nonroot {
f0b561b6	95	if [ $UID -ne 0 ]; then
0209a128	96	ts_skip "no root permissions"
09892fb6 KZ	97	fi
	98	}
	99
09888efe	100	function ts_failed_subtest {
733094a8 RM	101	local msg="FAILED"
	102	local ret=1
	103	if [ "$TS_KNOWN_FAIL" = "yes" ]; then
	104	msg="KNOWN FAILED"
	105	ret=0
	106	fi
	107
05de8126	108	if [ x"$1" == x"" ]; then
733094a8	109	ts_report " $msg ($TS_NS)"
05de8126	110	else
733094a8	111	ts_report " $msg ($1)"
05de8126	112	fi
733094a8 RM	113
733094a8 RM	114	return $ret
05de8126 KZ	115	}
05de8126 KZ	116
09888efe KZ	117	function ts_failed {
09888efe KZ	118	ts_failed_subtest "$1"
733094a8	119	exit $?
7641ccec RM	120	}
7641ccec RM	121
09888efe	122	function ts_ok_subtest {
05de8126	123	if [ x"$1" == x"" ]; then
40e6f7a0	124	ts_report " OK"
05de8126	125	else
40e6f7a0	126	ts_report " OK ($1)"
05de8126	127	fi
09888efe KZ	128	}
	129
	130	function ts_ok {
	131	ts_ok_subtest "$1"
05de8126 KZ	132	exit 0
	133	}
	134
57a917d6 KZ	135	function ts_log {
	136	echo "$1" >> $TS_OUTPUT
	137	[ "$TS_VERBOSE" == "yes" ] && echo "$1"
	138	}
	139
1d9acab1 KZ	140	function ts_has_option {
	141	NAME="$1"
	142	ALL="$2"
eac40eb0 RM	143
	144	# user may set options by env for a single test or whole component
	145	# e.g. TS_OPT_ipcs_limits2_fake="yes" or TS_OPT_ipcs_fake="yes"
c08863ff RM	146	local v_test=${TS_TESTNAME//[-.]/_}
	147	local v_comp=${TS_COMPONENT//[-.]/_}
	148	local v_name=${NAME//[-.]/_}
	149	eval local env_opt_test=\$TS_OPT_${v_comp}_${v_test}_${v_name}
	150	eval local env_opt_comp=\$TS_OPT_${v_comp}_${v_name}
eac40eb0 RM	151	if [ "$env_opt_test" = "yes" \
	152	-o "$env_opt_comp" = "yes" -a "$env_opt_test" != "no" ]; then
	153	echo "yes"
	154	return
	155	elif [ "$env_opt_test" = "no" \
	156	-o "$env_opt_comp" = "no" -a "$env_opt_test" != "yes" ]; then
	157	return
	158	fi
	159
	160	# or just check the global command line options
4303124a	161	if [[ $ALL =~ ([$' \t\n']\|^)--$NAME([$'= \t\n']\|$) ]]; then echo yes; fi
1d9acab1 KZ	162	}
1d9acab1 KZ	163
1b03e2cd KZ	164	function ts_option_argument {
	165	NAME="$1"
	166	ALL="$2"
4303124a RM	167
	168	# last option wins!
	169	echo "$ALL" \| sed -n "s/.[ \t\n]--$NAME=\([^ \t\n]\).*/\1/p" \| tail -n 1
1b03e2cd KZ	170	}
1b03e2cd KZ	171
db17c74b KZ	172	function ts_init_core_env {
	173	TS_NS="$TS_COMPONENT/$TS_TESTNAME"
	174	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME"
495674f8	175	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME.vgdump"
db17c74b KZ	176	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME"
	177	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
	178	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-mnt"
	179	}
	180
	181	function ts_init_core_subtest_env {
	182	TS_NS="$TS_COMPONENT/$TS_TESTNAME-$TS_SUBNAME"
	183	TS_OUTPUT="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME"
495674f8	184	TS_VGDUMP="$TS_OUTDIR/$TS_TESTNAME-$TS_SUBNAME.vgdump"
db17c74b KZ	185	TS_DIFF="$TS_DIFFDIR/$TS_TESTNAME-$TS_SUBNAME"
db17c74b KZ	186	TS_EXPECTED="$TS_TOPDIR/expected/$TS_NS"
64a2331f	187	TS_MOUNTPOINT="$TS_OUTDIR/${TS_TESTNAME}-${TS_SUBNAME}-mnt"
495674f8 KZ	188
495674f8 KZ	189	rm -f $TS_OUTPUT $TS_VGDUMP
4210c47a KZ	190	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"
4210c47a KZ	191
495674f8 KZ	192	touch $TS_OUTPUT
495674f8 KZ	193	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
db17c74b KZ	194	}
db17c74b KZ	195
905d0b9b	196	function ts_init_env {
e130ce53	197	local mydir=$(ts_abspath ${0%/*})
d9a9ff09	198	local tmp
d42bbae5	199
08b825db YD	200	LANG="POSIX"
	201	LANGUAGE="POSIX"
	202	LC_ALL="POSIX"
	203	CHARSET="UTF-8"
	204
1b03e2cd KZ	205	export LANG LANGUAGE LC_ALL CHARSET
1b03e2cd KZ	206
6dfe6f0e KZ	207	mydir=$(ts_canonicalize "$mydir")
6dfe6f0e KZ	208
1b03e2cd KZ	209	# automake directories
	210	top_srcdir=$(ts_option_argument "srcdir" "$*")
	211	top_builddir=$(ts_option_argument "builddir" "$*")
d42bbae5	212
1b03e2cd	213	# where is this script
a02f320d	214	TS_TOPDIR=$(ts_abspath $mydir/../../)
1b03e2cd KZ	215
	216	# default
	217	if [ -z "$top_srcdir" ]; then
	218	top_srcdir="$TS_TOPDIR/.."
	219	fi
	220	if [ -z "$top_builddir" ]; then
	221	top_builddir="$TS_TOPDIR/.."
	222	fi
	223
	224	top_srcdir=$(ts_abspath $top_srcdir)
	225	top_builddir=$(ts_abspath $top_builddir)
	226
4ba0bfbb RM	227	# some ul commands search other ul commands in $PATH
	228	export PATH="$top_builddir:$PATH"
	229
a02f320d	230	TS_SCRIPT="$mydir/$(basename $0)"
d42bbae5 KZ	231	TS_SUBDIR=$(dirname $TS_SCRIPT)
	232	TS_TESTNAME=$(basename $TS_SCRIPT)
	233	TS_COMPONENT=$(basename $TS_SUBDIR)
98604ef9	234	TS_DESC=${TS_DESC:-$TS_TESTNAME}
d42bbae5	235
09888efe KZ	236	TS_NSUBTESTS=0
	237	TS_NSUBFAILED=0
	238
d42bbae5 KZ	239	TS_SELF="$TS_SUBDIR"
d42bbae5 KZ	240
1b03e2cd KZ	241	TS_OUTDIR="$top_builddir/tests/output/$TS_COMPONENT"
1b03e2cd KZ	242	TS_DIFFDIR="$top_builddir/tests/diff/$TS_COMPONENT"
db17c74b KZ	243
db17c74b KZ	244	ts_init_core_env
d42bbae5	245
cbac71bd	246	TS_VERBOSE=$(ts_has_option "verbose" "$*")
40e6f7a0	247	TS_PARALLEL=$(ts_has_option "parallel" "$*")
7641ccec	248	TS_KNOWN_FAIL=$(ts_has_option "known-fail" "$*")
d995c2f0	249	TS_SKIP_LOOPDEVS=$(ts_has_option "skip-loopdevs" "$*")
d42bbae5	250
d9a9ff09 RM	251	tmp=$( ts_has_option "memcheck" "$*")
	252	if [ "$tmp" == "yes" -a -f /usr/bin/valgrind ]; then
	253	TS_VALGRIND_CMD="/usr/bin/valgrind"
	254	fi
	255
632830cc	256	BLKID_FILE="$TS_OUTDIR/${TS_TESTNAME}.blkidtab"
d42bbae5	257
1b5417ac KZ	258	declare -a TS_SUID_PROGS
	259	declare -a TS_SUID_USER
	260	declare -a TS_SUID_GROUP
cbae7931	261	declare -a TS_LOOP_DEVS
1b5417ac	262
adc8c80f KZ	263	if [ -f $TS_TOPDIR/commands.sh ]; then
	264	. $TS_TOPDIR/commands.sh
	265	fi
a02f320d	266
b7ea07e0	267	export BLKID_FILE
66822df3	268
495674f8	269	rm -f $TS_OUTPUT $TS_VGDUMP
4210c47a KZ	270	[ -d "$TS_OUTDIR" ] \|\| mkdir -p "$TS_OUTDIR"
4210c47a KZ	271
3dfa278e	272	touch $TS_OUTPUT
495674f8	273	[ -n "$TS_VALGRIND_CMD" ] && touch $TS_VGDUMP
97cdb3cb	274
d42bbae5 KZ	275	if [ "$TS_VERBOSE" == "yes" ]; then
	276	echo
	277	echo " script: $TS_SCRIPT"
d42bbae5	278	echo " sub dir: $TS_SUBDIR"
a02f320d	279	echo " top dir: $TS_TOPDIR"
d42bbae5 KZ	280	echo " self: $TS_SELF"
	281	echo " test name: $TS_TESTNAME"
	282	echo " test desc: $TS_DESC"
	283	echo " component: $TS_COMPONENT"
	284	echo " namespace: $TS_NS"
	285	echo " verbose: $TS_VERBOSE"
	286	echo " output: $TS_OUTPUT"
495674f8	287	echo " valgrind: $TS_VGDUMP"
d42bbae5 KZ	288	echo " expected: $TS_EXPECTED"
	289	echo " mountpoint: $TS_MOUNTPOINT"
	290	echo
	291	fi
905d0b9b KZ	292	}
905d0b9b KZ	293
09888efe KZ	294	function ts_init_subtest {
	295
	296	TS_SUBNAME="$1"
	297
db17c74b	298	ts_init_core_subtest_env
09888efe KZ	299
	300	[ $TS_NSUBTESTS -eq 0 ] && echo
	301	TS_NSUBTESTS=$(( $TS_NSUBTESTS + 1 ))
	302
40e6f7a0 SK	303	if [ "$TS_PARALLEL" == "yes" ]; then
	304	TS_TITLE=$(printf "%13s: %-30s ...\n%16s: %-27s ..." "$TS_COMPONENT" "$TS_DESC" "" "$TS_SUBNAME")
	305	else
	306	TS_TITLE=$(printf "%16s: %-27s ..." "" "$TS_SUBNAME")
	307	echo -n "$TS_TITLE"
	308	fi
09888efe KZ	309	}
09888efe KZ	310
905d0b9b	311	function ts_init {
d9a9ff09 RM	312	ts_init_env "$*"
d9a9ff09 RM	313
905d0b9b	314	local is_fake=$( ts_has_option "fake" "$*")
949cf64b	315	local is_force=$( ts_has_option "force" "$*")
905d0b9b	316
40e6f7a0 SK	317	if [ "$TS_PARALLEL" == "yes" ]; then
	318	TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
	319	else
	320	TS_TITLE=$(printf "%13s: %-30s ..." "$TS_COMPONENT" "$TS_DESC")
	321	echo -n "$TS_TITLE"
	322	fi
d42bbae5 KZ	323
d42bbae5 KZ	324	[ "$is_fake" == "yes" ] && ts_skip "fake mode"
949cf64b	325	[ "$TS_OPTIONAL" == "yes" -a "$is_force" != "yes" ] && ts_skip "optional"
e83446da KZ	326	}
e83446da KZ	327
1b5417ac KZ	328	function ts_init_suid {
	329	PROG="$1"
	330	ct=${#TS_SUID_PROGS[*]}
	331
	332	# Save info about original setting
	333	TS_SUID_PROGS[$ct]=$PROG
	334	TS_SUID_USER[$ct]=$(stat --printf="%U" $PROG)
	335	TS_SUID_GROUP[$ct]=$(stat --printf="%G" $PROG)
	336
	337	chown root.root $PROG &> /dev/null
	338	chmod u+s $PROG &> /dev/null
	339	}
	340
a731b541 KZ	341	function ts_init_py {
	342	LIBNAME="$1"
	343
15b2606c	344	[ -f "$top_builddir/py${LIBNAME}.la" ] \|\| ts_skip "py${LIBNAME} not compiled"
a731b541	345
fa8f8b74 RM	346	export LD_LIBRARY_PATH="$top_builddir/.libs:$LD_LIBRARY_PATH"
fa8f8b74 RM	347	export PYTHONPATH="$top_builddir/$LIBNAME/python:$top_builddir/.libs:$PYTHONPATH"
46407453 OO	348
	349	export PYTHON_VERSION=$(awk '/^PYTHON_VERSION/ { print $3 }' $top_builddir/Makefile)
	350	export PYTHON_MAJOR_VERSION=$(echo $PYTHON_VERSION \| sed 's/\..*//')
	351
	352	export PYTHON="python${PYTHON_MAJOR_VERSION}"
a731b541 KZ	353	}
a731b541 KZ	354
495674f8 KZ	355	function ts_valgrind {
	356	if [ -z "$TS_VALGRIND_CMD" ]; then
	357	$*
	358	else
	359	$TS_VALGRIND_CMD --tool=memcheck --leak-check=full \
	360	--leak-resolution=high --num-callers=20 \
	361	--log-file="$TS_VGDUMP" $*
	362	fi
	363	}
	364
09888efe KZ	365	function ts_gen_diff {
	366	local res=0
	367
64a2331f	368	if [ -s "$TS_OUTPUT" ]; then
4210c47a	369
46949388 KZ	370	# remove libtool lt- prefixes
	371	sed --in-place 's/^lt\-\(.*\: \)/\1/g' $TS_OUTPUT
	372
4210c47a	373	[ -d "$TS_DIFFDIR" ] \|\| mkdir -p "$TS_DIFFDIR"
09888efe	374	diff -u $TS_EXPECTED $TS_OUTPUT > $TS_DIFF
4210c47a KZ	375
	376	if [ -s $TS_DIFF ]; then
	377	res=1
	378	else
	379	rm -f $TS_DIFF;
	380	fi
09888efe KZ	381	else
	382	res=1
	383	fi
	384	return $res
	385	}
	386
495674f8 KZ	387	function tt_gen_mem_report {
	388	[ -z "$TS_VALGRIND_CMD" ] && echo "$1"
	389
	390	grep -q -E 'ERROR SUMMARY: [1-9]' $TS_VGDUMP &> /dev/null
	391	if [ $? -eq 0 ]; then
	392	echo "mem-error detected!"
	393	fi
	394	}
	395
09888efe	396	function ts_finalize_subtest {
e83446da KZ	397	local res=0
e83446da KZ	398
64a2331f	399	if [ -s "$TS_EXPECTED" ]; then
09888efe KZ	400	ts_gen_diff
	401	if [ $? -eq 1 ]; then
	402	ts_failed_subtest "$1"
	403	res=1
	404	else
495674f8	405	ts_ok_subtest "$(tt_gen_mem_report "$1")"
09888efe KZ	406	fi
	407	else
	408	ts_skip_subtest "output undefined"
	409	fi
	410
	411	[ $res -ne 0 ] && TS_NSUBFAILED=$(( $TS_NSUBFAILED + 1 ))
db17c74b KZ	412
	413	# reset environment back to parental test
	414	ts_init_core_env
	415
09888efe KZ	416	return $res
	417	}
	418
	419	function ts_finalize {
caf31605	420	ts_cleanup_on_exit
1b5417ac	421
09888efe	422	if [ $TS_NSUBTESTS -ne 0 ]; then
b8ab3744	423	printf "%11s..."
09888efe KZ	424	if [ $TS_NSUBFAILED -ne 0 ]; then
	425	ts_failed "$TS_NSUBFAILED from $TS_NSUBTESTS sub-tests"
	426	else
	427	ts_ok "all $TS_NSUBTESTS sub-tests PASSED"
	428	fi
e83446da	429	fi
425ca40a KZ	430
	431	if [ -s $TS_EXPECTED ]; then
	432	ts_gen_diff
	433	if [ $? -eq 1 ]; then
	434	ts_failed "$1"
	435	fi
	436	ts_ok "$1"
	437	fi
	438
09888efe	439	ts_skip "output undefined"
e83446da KZ	440	}
e83446da KZ	441
3dfa278e	442	function ts_die {
57a917d6	443	ts_log "$1"
3dfa278e KZ	444	ts_finalize
	445	}
	446
caf31605 RM	447	function ts_cleanup_on_exit {
	448
	449	for idx in $(seq 0 $((${#TS_SUID_PROGS[*]} - 1))); do
	450	PROG=${TS_SUID_PROGS[$idx]}
	451	chmod a-s $PROG &> /dev/null
	452	chown ${TS_SUID_USER[$idx]}.${TS_SUID_GROUP[$idx]} $PROG &> /dev/null
	453	done
cbae7931 RM	454
	455	for dev in "${TS_LOOP_DEVS[@]}"; do
	456	ts_device_deinit "$dev"
	457	done
	458	unset TS_LOOP_DEVS
caf31605 RM	459	}
caf31605 RM	460
35c636e1 KZ	461	function ts_image_md5sum {
	462	local img=${1:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
	463	echo $(md5sum "$img" \| awk '{printf $1}') $(basename "$img")
	464	}
05de8126	465
35c636e1 KZ	466	function ts_image_init {
	467	local mib=${1:-"5"} # size in MiBs
	468	local img=${2:-"$TS_OUTDIR/${TS_TESTNAME}.img"}
2f791546	469
1cb10736 RM	470	rm -f $img
1cb10736 RM	471	truncate -s "${mib}M" "$img"
35c636e1 KZ	472	echo "$img"
	473	return 0
	474	}
05de8126	475
cbae7931 RM	476	function ts_register_loop_device {
	477	local ct=${#TS_LOOP_DEVS[*]}
	478	TS_LOOP_DEVS[$ct]=$1
	479	}
	480
35c636e1	481	function ts_device_init {
b5eb5097 RM	482	local img
b5eb5097 RM	483	local dev
df7e52d7	484
b5eb5097 RM	485	img=$(ts_image_init $1 $2)
b5eb5097 RM	486	dev=$($TS_CMD_LOSETUP --show -f "$img")
cbae7931 RM	487	if [ "$?" != "0" -o "$dev" = "" ]; then
	488	ts_die "Cannot init device"
	489	fi
df7e52d7	490
cbae7931 RM	491	ts_register_loop_device "$dev"
cbae7931 RM	492	TS_LODEV=$dev
df7e52d7 KZ	493	}
df7e52d7 KZ	494
cbae7931	495	# call from ts_cleanup_on_exit() only because of TS_LOOP_DEVS maintenance
df7e52d7	496	function ts_device_deinit {
3dfa278e KZ	497	local DEV="$1"
	498
	499	if [ -b "$DEV" ]; then
	500	$TS_CMD_UMOUNT "$DEV" &> /dev/null
	501	$TS_CMD_LOSETUP -d "$DEV" &> /dev/null
df7e52d7 KZ	502	fi
df7e52d7 KZ	503	}
064b8c38	504
3f5bda01	505	function ts_uuid_by_devname {
283a8c15	506	echo $($TS_CMD_BLKID -p -s UUID -o value $1)
3f5bda01 KZ	507	}
	508
	509	function ts_label_by_devname {
283a8c15	510	echo $($TS_CMD_BLKID -p -s LABEL -o value $1)
3f5bda01 KZ	511	}
	512
	513	function ts_fstype_by_devname {
283a8c15	514	echo $($TS_CMD_BLKID -p -s TYPE -o value $1)
3f5bda01 KZ	515	}
	516
	517	function ts_device_has {
	518	local TAG="$1"
	519	local VAL="$2"
	520	local DEV="$3"
3dfa278e	521	local vl=""
3f5bda01 KZ	522
	523	case $TAG in
	524	"TYPE") vl=$(ts_fstype_by_devname $DEV);;
	525	"LABEL") vl=$(ts_label_by_devname $DEV);;
	526	"UUID") vl=$(ts_uuid_by_devname $DEV);;
	527	*) return 1;;
	528	esac
	529
	530	if [ "$vl" == "$VAL" ]; then
	531	return 0
	532	fi
	533	return 1
	534	}
3dfa278e KZ	535
	536	function ts_device_has_uuid {
	537	ts_uuid_by_devname "$1" \| egrep -q '^[0-9a-z]{8}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{4}-[0-9a-z]{12}$'
	538	return $?
	539	}
	540
2f954947 RM	541	function ts_mount {
	542	local out
	543	local result
	544	local msg
a23c435e	545	local fs
d2cc2ba7 RM	546	local fs_exp=$1
d2cc2ba7 RM	547	shift
2f954947 RM	548
	549	out=$($TS_CMD_MOUNT "$@" 2>&1)
	550	result=$?
	551	echo -n "$out" >> $TS_OUTPUT
	552
a23c435e RM	553	if [ $result != 0 ] \
	554	&& msg=$(echo "$out" \| grep -m1 "unknown filesystem type")
	555	then
	556	# skip only if reported fs correctly and if it's not available
	557	fs=$(echo "$msg" \| sed -n "s/.type '\(.\)'$/\1/p")
d2cc2ba7	558	[ "$fs" = "fs_exp" ] \
a23c435e RM	559	&& grep -qe "[[:space:]]${fs}$" /proc/filesystems &>/dev/null \
a23c435e RM	560	\|\| ts_skip "$msg"
2f954947 RM	561	fi
	562	return $result
	563	}
	564
3ff2557c	565	function ts_is_mounted {
6dfe6f0e	566	local DEV=$(ts_canonicalize "$1")
3ff2557c KZ	567
	568	grep -q $DEV /proc/mounts && return 0
	569
	570	if [ "${DEV#/dev/loop/}" != "$DEV" ]; then
866372c6	571	grep -q "/dev/loop${DEV#/dev/loop/}" /proc/mounts && return 0
3ff2557c KZ	572	fi
	573	return 1
	574	}
	575
c98825ac	576	function ts_fstab_open {
601d12fb	577	echo "# <!-- util-linux test entry" >> /etc/fstab
c98825ac KZ	578	}
	579
	580	function ts_fstab_close {
	581	echo "# -->" >> /etc/fstab
	582	}
	583
	584	function ts_fstab_addline {
	585	local SPEC="$1"
	586	local MNT=${2:-"$TS_MOUNTPOINT"}
	587	local FS=${3:-"auto"}
b002d021	588	local OPT=${4:-"defaults"}
c98825ac	589
b002d021	590	echo "$SPEC $MNT $FS $OPT 0 0" >> /etc/fstab
c98825ac KZ	591	}
	592
	593	function ts_fstab_add {
	594	ts_fstab_open
b002d021	595	ts_fstab_addline $*
c98825ac KZ	596	ts_fstab_close
	597	}
	598
	599	function ts_fstab_clean {
	600	sed --in-place "
601d12fb	601	/# <!-- util-linux/!b
c98825ac KZ	602	:a
	603	/# -->/!{
	604	N
	605	ba
	606	}
601d12fb	607	s/# <!-- util-linux.*-->//;
c98825ac KZ	608	/^$/d" /etc/fstab
	609	}
	610
d0bcd9b3	611	function ts_fdisk_clean {
e1fe1815	612	local DEVNAME=$1
618ec053	613
d0bcd9b3	614	# remove non comparable parts of fdisk output
23d8c556 RM	615	if [ -n "${DEVNAME}" ]; then
	616	sed -i -e "s@${DEVNAME}@<removed>@;" $TS_OUTPUT
	617	fi
	618
	619	sed -i \
	620	-e 's/Disk identifier:.*/Disk identifier: <removed>/' \
	621	-e 's/Created a new.*/Created a new <removed>./' \
	622	-e 's/^Device[[:blank:]]*Start/Device Start/' \
	623	-e 's/^Device[[:blank:]]*Boot/Device Boot/' \
	624	-e 's/Welcome to fdisk.*/Welcome to fdisk <removed>./' \
	625	-e 's/typescript file.*/typescript file <removed>./' \
01e8c90c	626	-e 's@^\(I/O size (minimum/op.* bytes /\) [1-9][0-9]* @\1 <removed> @' \
23d8c556	627	$TS_OUTPUT
d0bcd9b3	628	}
618ec053 KZ	629
618ec053 KZ	630	function ts_scsi_debug_init {
dd761f79 RM	631	local devname
dd761f79 RM	632	TS_DEVICE="none"
618ec053	633
9779f598	634	# dry run is not really reliable, real modprobe may still fail
f80c0d38 RM	635	modprobe --dry-run --quiet scsi_debug &>/dev/null \
f80c0d38 RM	636	\|\| ts_skip "missing scsi_debug module (dry-run)"
618ec053	637
f80c0d38 RM	638	# skip if still in use or removal of modules not supported at all
	639	modprobe -r scsi_debug &>/dev/null \
	640	\|\| ts_skip "cannot remove scsi_debug module (rmmod)"
	641
85fca7e5	642	modprobe -b scsi_debug "$@" &>/dev/null \
f80c0d38 RM	643	\|\| ts_skip "cannot load scsi_debug module (modprobe)"
	644
	645	# it might be still not loaded, modprobe.conf or whatever
	646	lsmod \| grep -q "^scsi_debug " \
	647	\|\| ts_skip "scsi_debug module not loaded (lsmod)"
618ec053	648
618ec053 KZ	649	udevadm settle
618ec053 KZ	650
85fca7e5 RM	651	devname=$(grep --with-filename scsi_debug /sys/block/*/device/model \| awk -F '/' '{print $4}')
	652	[ "x${devname}" == "x" ] && ts_die "cannot find scsi_debug device"
	653
dd761f79	654	TS_DEVICE="/dev/${devname}"
618ec053	655	}
a98de969 RM	656
	657	function ts_resolve_host {
	658	local host="$1"
	659	local tmp
	660
	661	# currently we just resolve default records (might be "A", ipv4 only)
	662	if type "dig" >/dev/null 2>&1; then
	663	tmp=$(dig "$host" +short 2>/dev/null) \|\| return 1
	664	elif type "nslookup" >/dev/null 2>&1; then
	665	tmp=$(nslookup "$host" 2>/dev/null) \|\| return 1
	666	tmp=$(echo "$tmp"\| grep -A1 "^Name:"\| grep "^Address:"\| cut -d" " -f2)
eee79f28 AH	667	elif type "host" >/dev/null 2>&1; then
	668	tmp=$(host "$host" 2>/dev/null) \|\| return 1
	669	tmp=$(echo "$tmp" \| grep " has address " \| cut -d " " -f4)
	670	elif type "getent" >/dev/null 2>&1; then
	671	tmp=$(getent ahosts "$host" 2>/dev/null) \|\| return 1
	672	tmp=$(echo "$tmp" \| cut -d " " -f 1 \| sort -u)
a98de969 RM	673	fi
	674
	675	# we return 1 if tmp is empty
	676	test -n "$tmp" \|\| return 1
	677	echo "$tmp" \| sort -R \| head -n 1
	678	}
c9813f2c RM	679
	680	# listen to unix socket (background socat)
	681	function ts_init_socket_to_file {
	682	local socket=$1
	683	local outfile=$2
	684	local pid="0"
	685
	686	ts_check_prog "socat"
	687	rm -f "$socket" "$outfile"
	688
	689	socat -u UNIX-LISTEN:$socket,fork,max-children=1,backlog=128 \
	690	STDOUT > "$outfile" &
	691	pid=$!
	692
	693	# check for running background process
	694	if [ "$pid" -le "0" ] \|\| ! kill -s 0 "$pid"; then
	695	ts_skip "unable to run socat"
	696	fi
	697	# wait for the socket listener
	698	if ! socat -u /dev/null UNIX-CONNECT:$socket,retry=30,interval=0.1; then
	699	kill -9 "$pid"
	700	ts_skip "timeout waiting for socket"
	701	fi
	702	# check socket again
	703	if ! socat -u /dev/null UNIX-CONNECT:$socket; then
	704	kill -9 "$pid"
	705	ts_skip "socket stopped listening"
	706	fi
	707	}