path: root/net-fs/autofs/files/autofs.rc12

#!/sbin/runscript
# Copyright 1999-2004 Gentoo Foundation
# Distributed under the terms of the GNU General Public License v2
# $Header: /var/cvsroot/gentoo-x86/net-fs/autofs/files/autofs.rc12,v 1.1 2005/03/15 04:18:38 robbat2 Exp $

# rc file for automount using a Sun-style "master map".
# We first look for a local /etc/autofs/auto.master, then a YP
# map with that name

DAEMON=/usr/sbin/automount
SYSCONFDIR=/etc/autofs

depend() {
	need localmount	
	use ypbind nfs slapd portmap net
}

opts="start stop status stats reload restart"

# this file is used to avoid the subshell-die problem
TMPSRC=/var/run/autofs.tmp

#
# Check for all maps that are to be loaded
#
function getschemes() {
	schemes="$(awk '/^automount:/{ $1="" ; gsub("\\[.*\\]","") ; print $0 }' /etc/nsswitch.conf)"
	# have a default entry
	[ -z "$schemes" ] && echo 'files' || echo $schemes
}

function getfilemounts() {
	if [ -f /etc/autofs/auto.master ] ; then
		sed -e '/^#/d' -e '/^$/d' < /etc/autofs/auto.master
	fi
}

function catnismap() {
	[ -z "$1" ] && map="auto_master" || map="$1"
	/usr/bin/ypcat -k ${map} 2> /dev/null | sed -e '/^#/d' -e '/^$/d'
}

function getnismounts() {
        YPMAP="$(catnismap auto.master)"
        if [ -z "$YPMAP" ]; then
                catnismap
        else
                catnismap auto.master
        fi
}

function getldapmounts() {
	autofs_lam=/usr/lib/autofs/autofs-ldap-auto-master
	if [ -f $autofs_lam -a -x $autofs_lam ]; then
		${autofs_lam} \
		-m ${ldap_map_oc} -e ${ldap_entry_oc} \
		-n ${ldap_map_key} -k ${ldap_entry_key} \
		-v ${ldap_value} 2> /dev/null
	fi
}

function getrawmounts()
{
	for scheme in `getschemes` ; do
		case "$scheme" in
			files)
				getfilemounts
				;;
			nis*)
				getnismounts
				;;
			ldap*)
				getldapmounts
				;;
		esac
	done
}


#
# This function will build a list of automount commands to execute in
# order to activate all the mount points. It is used to figure out
# the difference of automount points in case of a reload
#
function getmounts()
{
	knownmaps=" "
	# seperate storage variable to avoid clobbering the other $TMPSRC
	TMPSRC_mounts="$TMPSRC.mounts"
	getrawmounts >$TMPSRC_mounts
	while read dir map options
	do
		# These checks screen out duplicates and skip over directories
		# where the map is '-'.
		if [ ! -z "$dir" -a ! -z "$map" \
			-a "x${map:0:1}" != "x-" \
			-a "`echo "$knownmaps" | grep -w $dir/`" = "" ]; then
		# If the options include a -t or --timeout parameter, then
		# pull those particular options out.
		# echo DAEMONOPTIONS OPTIONS $daemonoptions $options
		startupoptions=""
		opt_timeout=""
		opt_pidfile=""
		opt_verbose=""
		opt_debug=""
		opt_ghost=""

		# use getopt to parse all of it
		#getopteval="$(getopt -q -o -t:p:vdg --long timeout:,pid-file:,verbose,debug,ghost -- "$daemonoptions $options") "
		getopt_input="$daemonoptions $options"
		getopt_eval="$(getopt -q -o -t:vdg --long timeout:,verbose,debug,ghost -- $getopt_input) "
		eval set -- "${getopt_eval}"
		while [ -n "$1" ]; do
			#-p|--pid-file) opt_pidfile="$2" ; shift 2 ;;
			case $1 in
				-t|--timeout) opt_timeout="$2" ; shift 2 ;;
				-v|--verbose) opt_verbose="--verbose" ; shift ;;
				-d|--debug) opt_debug="--debug" ; shift ;;
				-g|--ghost) opt_ghost="--ghost" ; shift ;;
				--) shift ; break ;;
				*) shift ;; # just ignore other params for now
			esac
		done
		# build the parameters	
		[ -n "${opt_timeout}" ] && startupoptions="${startupoptions} --timeout ${opt_timeout}"
		#[ -n "${opt_pidfile}" ] && startupoptions="${startupoptions} --pid-file ${opt_pidfile}"
		startupoptions="${startupoptions} ${opt_ghost} ${opt_verbose} ${opt_debug}"

		# Other option flags are intended for maps.
		# unfortuntely this can't be integrated with the above getopt(1)
		mapoptions="$(echo $daemonoptions $options | sed  \
			-e '/-t/{s/--*t\(imeout\)*[[:space:]=]*\([0-9][0-9]*\)//g }' \
			-e '/-v/{s/--*v\(erbose\)*//g }' \
			-e '/-d/{s/--*d\(ebug\)*//g }' \
			-e '/-g/{s/--*g\(host\)*//g }' \
			-e 's/^[[:space:]]*//g' \
			-e 's/[[:space:]]*$//g')"
			#-e '/-p/{s/--*p\(id-file\)*[[:space:]=]*\([^[:space:]]*\)//g }' \

		# Break up the maptype and map, if the map type is specified
		maptype="${map/:*}"
		# Handle degenerate map specifiers
		if [ "$maptype" = "$map" ] ; then
			if [ -x "$map" ]; then
				maptype="program"
			elif [ -x "/etc/$map" ]; then
				maptype="program"
				map="/etc/$map"
				map="${map//\/\//\/}" # strip doubles
			elif [ -f "$map" ]; then
				maptype="file"
			elif [ -f "/etc/$map" ]; then
				maptype="file"
				map="/etc/$map"
				map="${map//\/\//\/}" # strip doubles
			elif [ "$map" = "hesiod" -o "$map" = "userhome" ] ; then
				maptype="$map"
				map=
			elif [ "$map" = "multi" ] ; then
				maptype="$map"
				map=
			else
				maptype=yp
				map="${map/*\/}" # same as "basename $map"
				map="${map/#auto_/auto.}" # echo $map | sed -e 's/^auto_home/auto.home/' -e 's/^auto_mnt/auto.mnt/'
			fi
		fi
		map="${map#*:}"

		#echo >>/tmp/debug
		#date >>/tmp/debug
		#echo STARTUPOPTIONS $startupoptions >> /tmp/debug
		#echo DIR $dir >> /tmp/debug
		#echo MAPTYPE $maptype >> /tmp/debug
		#echo MAP $map >> /tmp/debug
		#echo MAPOPTIONS $mapoptions >> /tmp/debug
		#echo LOCALOPTIONS $localoptions >> /tmp/debug
		#echo OPTIONS $options >>/tmp/debug
		#echo GETOPT_INPUT $getopt_input >>/tmp/debug

		[ -z "${startupoptions}" ] && startupoptions=" " # to make life easier later
		# protect startupoptions with _X_ to use it later
		cmdline="$DAEMON ${startupoptions// /_X_} $dir $maptype $map ${mapoptions} ${localoptions}"
		# leave out the " so that white space gets compressed
		echo ${cmdline}

		# echo ------------------------
		fi
		knownmaps=" $dir/ $knownmaps"
	done <$TMPSRC_mounts
	rm -f $TMPSRC_mounts
}


start() {
	ebegin "Starting automounter"
	# ensure autofs support is loaded
	grep -q autofs /proc/filesystems || modprobe -q autofs4 || modprobe -q autofs
	if [ $? -ne 0 ]; then
		eend 1 "No autofs support available"
		return 1
	fi
	
	getmounts >$TMPSRC

	# Check that maps exist
	if [ ! -s $TMPSRC ]; then
		eend 1 "No automount maps defined"
		return 1
	fi
	
	while read cmd startupopts mnt rest ; do
		pidfile=/var/run/autofs${mnt//\//.}.pid
		startupopts="$(echo ${startupopts//_X_/ } --pid-file ${pidfile} )"
		bin="/usr/sbin/automount"
		params="$(echo $startupopts $mnt $rest)"

		echo -n " $mnt"
		#echo " $mnt ($params)"

		start-stop-daemon --start --pidfile $pidfile --quiet \
			--exec ${bin} -- ${params}
		#ps ax | grep "[0-9]:[0-9][0-9] ${bin} ${params}" | (
		#	read pid rest
		#	echo $pid > $pidfile
		#	echo "$mnt $rest" >> $pidfile
		#)
		if [ $? -ne 0 ]; then
			eerror "Failure on $mnt"
		else
			echo "${params}" >> $pidfile
		fi
	done < $TMPSRC
	# clean up
	rm -f $TMPSRC

	echo

	eend $?
}

stop() {
	ebegin "Stopping automounter"
	start-stop-daemon --stop --quiet --signal USR2 --exec /usr/sbin/automount
	eend $?
}

stats() {
	echo "Configured Mount Points:"
	echo "------------------------"
	getmounts >$TMPSRC
	while read cmd startupopts mnt rest ; do
		pidfile=/var/run/autofs${mnt//\//.}.pid
		startupopts="$(echo ${startupopts//_X_/ } --pid-file ${pidfile} )"
		params="$(echo $startupopts $mnt $rest)"
		echo $cmd $params
	done <$TMPSRC
	rm -f $TMPSRC
	echo ""
	echo "Active Mount Points:"
	echo "--------------------"
	ps ax|grep "[0-9]:[0-9][0-9] /usr/sbin/automount " | (
		while read pid tt stat time command; do echo $command; done
	)
}

reload() {
	echo "Reloading automounter: checking for changes ... "
	getmounts >$TMPSRC
	for i in /var/run/autofs.*.pid
	do
		pid=`head -n 1 $i 2>/dev/null`
		[ -z "$pid" ] && continue
		command=`tail -n +2 $i`
		if ! grep -q "^$command" $TMPSRC
		then
			echo "Stopping automounter: $command"
			kill -USR2 $pid
		fi
	done
	rm -f $TMPSRC
	svc_start
}

restart() {
	svc_stop
	svc_start
}