system.subr

# if is_mounted /tmp; then ...mounted..
# - check for dir is mountpoint
is_mounted()
{
    local tst
    [ ! -d "${1}" ] && return 1
    tst=`df -l ${1} | tail +2 | awk '{ print $6 }'`
    [ "${tst}" = "${1}" ]
    return $?
}

# if on_mounted /usr/src/base; then ...mounted..
# - check if dir mounted to other place
on_mounted()
{
    [ ! -d "${1}" ] && return 1
    mount |grep " on " | while read _device on _mountpt; do
	[ "$_device" != "$1" ] || exit 2
    done

    [ $? -eq 2 ] && return 0

    return 1
}

# check for base dir existance
# if not exist - ask and try to fetch from repository
# exit when no base and repo failure
# $BASE_DIR - alternative (prefered) path to base dir
# or
# $arch and $ver (opt: $basename) must be set
get_base()
{
    [ "${ver}" = "empty" ] && return 0

    # fill $BASE_DIR
    init_basedir

    # check for $BASE_DIR existance
    if [ ! -d "${BASE_DIR}" ]; then
            getyesno "No ${arch}-${target_arch}-${ver} base. Try to fetch from remote repository?"
            [ $? -eq 1 -o $? -eq 3 ] && err 1 "${MAGENTA}No base data on: ${GREEN}${BASE_DIR}${NORMAL}"
            cbsd repo action=get sources=base arch=${arch} ver=${ver} target_arch=${target_arch}
    fi

    [ ! -d "${BASE_DIR}" ] && err 1 "${MAGENTA}No base data on: ${GREEN}${BASE_DIR}${NORMAL}"
}

# Mount base -b or default  to destination dir $path
# -b base path
# -k kernel path
# -s source path
# -o obj path
# -p ports path
# -d distfiles path
# -c /var/db/ports dbportspath
# -x additional mount, fstab format record, eg: "linsys /compat/linux/sys linsysfs rw 0 0"
# -t target (override path param)
# -v ver
# -a arch
mountbase()
{
    local basepath kernelpath sourcepath objpath portspath distfilespath dbportspath MNTCODE
    local _base_mounted=0

    xfstab="${ftmpdir}/mountbase.$$"
    MNTCODE=0

    while getopts "b:k:s:o:p:d:c:x:t:v:a:" opt; do
	case "$opt" in
	    b) basepath="${OPTARG}" ;;
	    k) kernelpath="${OPTARG}" ;;
	    s) sourcepath="${OPTARG}" ;;
	    o) objpath="${OPTARG}" ;;
	    p) portspath="${OPTARG}" ;;
	    d) distfilespath="${OPTARG}" ;;
	    c) dbportspath="${OPTARG}" ;;
	    x) echo "${OPTARG}" >> "${xfstab}" ;;
	    t) path="${OPTARG}" ;;
	    v) ver="${OPTARG}" ;;
	    a) arch="${OPTARG}" ;;
        esac
	shift $(($OPTIND - 1))
    done

    #already mounted?
    is_mounted ${path} && _base_mounted=1

    if [ ${_base_mounted} -eq 0 ]; then
	#test for zfs mounted & mount if not
	case $zfsfeat in
	    1) . $zfstool
		[ $baserw -eq 1 ] && path=$data
		zfsmnt ${path}
		[ $? -eq 2 ] && zfs mount "${ZPOOL}"
		;;
	esac

	if [ "${baserw}" = "0" ]; then
	    get_base
	else
	    [ ! -f "${path}/bin/sh" ] && get_base
	fi

	[ ! -d "${path}" ] && mkdir -p ${path}

	if [ "${baserw}" = "0" ]; then
	    #check for md-based base location (postfix -md)
	    if [ -f "${BASE_DIR}-md/bin/sh" ]; then
		echo "Mount MD-based base location as base..."
		mount -t nullfs -oro "${BASE_DIR}-md" ${path}
		MNTCODE=$?
	    else
		mount -t nullfs -oro ${BASE_DIR} ${path}
		MNTCODE=$?
	    fi
	fi

    #	[ ! -d "${path}/var/cache/pkg" ] && mkdir -p "${path}/var/cache/pkg"
    fi # is _base_mounted=0

    # Other part
    if [ -n "${kernelpath}" -a -d "${kernelpath}" ]; then
	[ ! -d "${path}/boot/kernel" ] && mkdir -p ${path}/boot/kernel
	mount -t nullfs -oro ${kernelpath}  ${path}/boot/kernel
    fi

    if [ -n "${sourcepath}" -a -d "${sourcepath}" ]; then
	[ ! -d "${path}/usr/src" ] && mkdir -p ${path}/usr/src
	mount -t nullfs -oro ${sourcepath} ${path}/usr/src
    fi

    if [ -n "${objpath}" -a -d "${objpath}" ]; then
	[ ! -d "${path}/usr/obj" ] && mkdir -p ${path}/usr/obj
	 mount -t nullfs -orw ${objpath} ${path}/usr/obj
    fi

    if [ -n "${portspath}" -a -d "${portspath}" ]; then
	[ ! -d "${path}/usr/ports" ] && mkdir -p ${path}/usr/ports
	mount -t nullfs -orw ${portspath} ${path}/usr/ports
    fi

    if [ -n "${distfilespath}" -a -z "${portspath}" -a -d "${distfilespath}" ]; then
	[ ! -d "${path}/usr/ports/distfiles" ] && mkdir -p ${path}/usr/ports/distfiles
	mount -t nullfs -orw ${path}/usr/ports/distfiles
    fi

    # Finally mount devfs
    #/sbin/mount -t devfs devfs ${path}/dev

    #if [ -n "$devfs_ruleset" ]; then
    #    . /etc/rc.subr
    #    devfs_rulesets_from_file ${etcdir}/devfs.rules
    #    devfs -m ${path}/dev rule -s ${devfsrules} applyset
    #fi

    if [ -f "${xfstab}" ]; then
	cbsd mountfstab jroot="${path}" fstab="${xfstab}" jname="${jname}"
	rm -f "${xfstab}"
    fi

    return $MNTCODE
}


mountfstab()
{
    local _res=$(/usr/local/bin/cbsd mountfstab jroot=${path} fstab=${mount_fstab} jname="${jname}" )

    if [ $? -ne 0 ]; then
	# force unmount it better then..
	echo "Invalid fstab file: ${_res}"   
	_res=`cbsd jcleanup jname=${jname}`
	continue
    fi

    if [ -f "${mount_fstab}.local" ]; then
	cbsd mountfstab jroot=${path} fstab=${mount_fstab}.local jname="${jname}"
    # cleanup for local?
    fi
}

unmountbase()
{
    [ $baserw -eq 0 ] && umount -f ${path}
    cbsd unmountfstab jroot=${path} fstab=${mount_fstab} > /dev/null 2>&1
    cbsd jcleanup jname=${jname} > /dev/null 2>&1
}

# Unmount all in $path or $1
# if exist $2 - do not unmount root of $1
umount_cdirs()
{
    local _unmount_root=1
    [ -n "${1}" ] && path="$1"
    [ -n "${2}" ] && _unmount_root=0

    # when error before path, we do not have any mounts by scripts
    [ -z "${path}" ] && return 0

    MOUNT_LIST=`mount |sort -r| awk -F" on " '{print $2}'`

    MPATH=""
    for mount_point in $MOUNT_LIST; do
	case $mount_point in
    	    ${path}/*)
        	[ -n "${mount_point}" ] && MPATH="${MPATH} $path${mount_point#$path}"
	    ;;
	esac
    done

    [ -n "${MPATH}" ] && umount -f ${MPATH}
    #finaly unmount cdir
    if [ ${_unmount_root} -eq 1 ]; then
	is_mounted ${path} && umount -f ${path}
    fi
}

# populate $2 chroot dir from $1 base directory
# when baserw set to 0, just create default hier
populate_cdir()
{
    local _dir _dst _i

    [ -d "${1}" -a -d "${2}" ] || err 1 "No such base version on ${1}"

    _dir=$1
    _dst=$2

#JAILNODATA sample
#[ -z "${JAILNODATA}" -a "${baserw}" = "0" ] && JAILNODATA="${_dir}/.cshrc.*|\
#${_dir}/dev.*|\
#${_dir}/bin.*|\
#${_dir}/media.*|\
#${_dir}/rescue.*|\
#${_dir}/sys.*|\
#${_dir}/.profile.*|\
#${_dir}/boot.*|\
#${_dir}/lib.*|\
#${_dir}/mnt.*|\
#${_dir}/COPYRIGHT.*|\
#${_dir}/libexec.*|\
#${_dir}/proc.*|\
#${_dir}/sbin.*|\
#${_dir}/usr/bin.*|\
#${_dir}/usr/games.*|\
#${_dir}/usr/include.*|\
#${_dir}/usr/lib.*|\
#${_dir}/usr/lib32.*|\
#${_dir}/usr/libdata.*|\
#${_dir}/usr/libexec.*|\
#${_dir}/usr/local.*|\
#${_dir}/usr/sbin.*|\
#${_dir}/usr/share.*|"

JAILDATA="${_dir}/compat \
${_dir}/dev \
${_dir}/etc \
${_dir}/home \
${_dir}/root \
${_dir}/tmp \
${_dir}/usr \
${_dir}/var \
${_dir}/.cshrc \
${_dir}/.profile \
${_dir}/COPYRIGHT"

    if [ "$baserw" = "1" ]; then
	cd ${_dir} && pax -p eme -X -rw . ${_dst}
    else
	if [ -n "${JAILNODATA}" ]; then
		cd ${_dir} && find -E ${_dir} \( -type f -or -type d -or -type l \) -and -not -regex \"$JAILNODATA\" -print |sed s:${_dir}:./:g |cpio -pdmu ${_dst}
	elif [ -n "${JAILDATA}" ]; then
		for _i in ${JAILDATA}; do
		    cp -a ${_i} ${_dst}
		done
	fi
    fi

    [ "${applytpl}" = "1" ] && truncate -s0 ${_dst}/etc/motd
    return 0
}

# populate or remove system files from jail data dir
# $1 - jail data dir
# $2 - mode: 1 - write (populate), 2 - readonly (remove)
switch_baserw()
{
    [ ! -d "${1}" ] && return 0
    get_base

# populate
    if [ "${2}" = "1" ]; then
JAILNODATA="${_dir}/|\
${BASE_DIR}/dev.*|\
${BASE_DIR}/etc.*|\
${BASE_DIR}/sys.*|\
${BASE_DIR}/proc.*|\
${BASE_DIR}/root.*|"

	${ECHO} "${MAGENTA}Populate jail data from: ${GREEN}${BASE_DIR}${NORMAL}"
	cd $BASE_DIR && find -E ${BASE_DIR} \( -type f -or -type d -or -type l \) -and -not -regex \"$JAILNODATA\" -print |sed s:${BASE_DIR}:./:g |cpio -pdmu ${1}
	[ ! -d "${1}/dev" ] && mkdir "${1}/dev"
	#remove system fstab
	[ -f "${jailfstabdir}/${jailfstabpref}${jname}" ] && rm -f "${jailfstabdir}/${jailfstabpref}${jname}"
    elif [ "$2" = "2" ]; then
# switch to basero
# create system fstab

cat > ${mount_fstab} << EOF
# Please do not edit this file for additional fstabs
# Use ${jailfstabdir}/${jailfstabpref}local instead
${data}/etc /etc nullfs rw 0 0
${data}/root /root nullfs rw 0 0
${data}/tmp /tmp nullfs rw 0 0
${data}/usr/home /usr/home nullfs rw 0 0
${data}/usr/local /usr/local nullfs rw 0 0
${data}/usr/compat /usr/compat nullfs rw 0 0
${data}/var /var nullfs rw 0 0
#
EOF

#todo: remove file from data listed in base jail
REMOVEDIR="bin \
lib \
libexec \
rescue \
sbin \
usr/bin \
usr/games \
usr/include \
usr/lib \
usr/lib32 \
usr/libdata \
usr/libexec \
usr/sbin \
usr/share"

    [ -z "${data}" ] && return 0

    ${ECHO} "${MAGENTA}Reduce jail data by switching from baserw -> basero: ${GREEN}${data}${NORMAL}"
    for i in ${REMOVEDIR}; do
	[ -d "${data}/${i}" ] && chflags -R noschg ${data}/${i} && rm -rf ${data}/${i}
    done

    fi
# populate
}