Diff of /trunk/mage/usr/lib/mage/mage4.functions.sh

Parent Directory | Revision Log | Patch

	revision 258 by niro, Tue Oct 4 14:35:21 2005 UTC	revision 2867 by niro, Thu Mar 19 15:28:54 2015 UTC
#	Line 1	Line 1
1	#!/bin/bash	#!/bin/bash
2	# Magellan Linux Installer Functions (mage.functions.sh)	# Magellan Linux Installer Functions (mage.functions.sh)
3	# $Header: /home/cvsd/magellan-cvs/magellan-src/mage/usr/lib/mage/mage4.functions.sh,v 1.7 2005-10-04 14:35:21 niro Exp $	# $Id$
4
5		COLRED="\033[1;6m\033[31m"
6		COLGREEN="\033[1;6m\033[32m"
7		COLYELLOW="\033[1;6m\033[33m"
8		COLBLUE="\033[1;6m\033[34m"
9		COLMAGENTA="\033[1;6m\033[35m"
10		COLWHITE="\033[1;6m\033[37m"
11		COLGRAY="\033[0;6m\033[37m"
12		COLBOLD="\033[1m"
13		COLDEFAULT="\033[0m"
14
15		if [[ ${NOCOLORS} = true ]]
16		then
17		COLRED=""
18		COLGREEN=""
19		COLYELLOW=""
20		COLBLUE=""
21		COLMAGENTA=""
22		COLWHITE=""
23		COLGRAY=""
24		COLBOLD=""
25		COLDEFAULT=""
26		fi
27
28	mage_setup()	mage_setup()
29	{	{
#	Line 15  mage_setup()	Line 38  mage_setup()
38	return 0	return 0
39	}	}
40
41		mchecksum()
42		{
43		local i
44		local rundir
45		local file
46		local method
47		local cmd
48		local retval
49		local sum
50		local dest
51
52		# very basic getops
53		for i in $*
54		do
55		case $1 in
56		--rundir|-r) shift; rundir="$1" ;;
57		--file|-f) shift; file="$1" ;;
58		--method|-m) shift; method="$1" ;;
59		esac
60		shift
61		done
62
63		# sanity checks
64		[[ -z ${rundir} ]] && die "mchecksum(): rundir missing"
65		[[ -z ${file} ]] && die "mchecksum(): file missing"
66		[[ -z ${method} ]] && die "mchecksum(): method missing"
67
68		case ${method} in
69		md5) cmd="md5sum" ;;
70		sha256) cmd="sha256sum" ;;
71		*) die "mchecksum(): unknown method '${method}'" ;;
72		esac
73
74		if [[ -d ${rundir} ]]
75		then
76		pushd ${rundir} &> /dev/null
77
78		# all file must be non-zero
79		retval=0
80		while read sum dest
81		do
82		if [ ! -s ${dest} ]
83		then
84		echo "${dest}: file is empty ;("
85		retval=127
86		fi
87		done < ${file}
88		if [[ ${retval} != 127 ]]
89		then
90		# be verbose here
91		${cmd} -c ${file} #&> /dev/null
92		retval="$?"
93		fi
94
95		popd &> /dev/null
96		else
97		retval=1
98		fi
99
100		return "${retval}"
101		}
102
103		mcheckemptydir()
104		{
105		local dir="$1"
106		local retval=1
107
108		if [[ ! -d ${dir} ]]
109		then
110		echo "mcheckemptydir(): '${dir}' is not a directory!"
111		retval=3
112		else
113		shopt -s nullglob dotglob
114		files=( ${dir}/* )
115		(( ${#files[*]} )) || retval=0
116		shopt -u nullglob dotglob
117		fi
118
119		return ${retval}
120		}
121
122		unpack_package()
123		{
124		local magefile="$1"
125		local pkgname
126		local pkgfile
127		local pkgtype
128		local tar_opts
129
130		pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
131		pkgfile="${pkgname}.${PKGSUFFIX}"
132		pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
133
134		xtitle "[ Unpacking ${pkg} ]"
135
136		# abort on virtual pkg
137		if [[ ${pkgtype} = virtual ]]
138		then
139		echo -ne " ${COLBLUE}---${COLDEFAULT}"
140		echo " !unpack virtual ${pkgname} ... "
141		continue
142		fi
143
144		# abort on sources pkg
145		if [[ ${pkgtype} = sources ]]
146		then
147		echo -ne " ${COLBLUE}---${COLDEFAULT}"
148		echo " !unpack sources ${pkgname} ... "
149		continue
150		fi
151
152		# busybox?
153		if need_busybox_support tar
154		then
155		tar_opts="xjf"
156		else
157		tar_opts="xjmf"
158		fi
159
160		echo -e " ${COLBLUE}***${COLDEFAULT} unpacking ${pkgfile} ... "
161		tar ${tar_opts} ${PKGDIR}/${pkgfile} -C ${BUILDDIR} || die "Unpacking package ${pkgfile}"
162		}
163
164	unpack_packages()	unpack_packages()
165	{	{
166	local list="$@"	local list="$@"
167	local magefile	local magefile
	local pkg
	local pkgtype
168	local count_current	local count_current
169	local count_total	local count_total
170		local tar_opts
171
172	# get count of total packages	# get count of total packages
173	declare -i count_current=0	declare -i count_current=0
#	Line 32  unpack_packages()	Line 177  unpack_packages()
177
178	for magefile in ${list}	for magefile in ${list}
179	do	do
180	pkg="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	unpack_package "${magefile}"
	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
181	(( count_current++ ))	(( count_current++ ))
	xtitle "[ (${count_current}/${count_total}) Unpacking ${pkg} ]"
	# abort on virtual pkg
	if [[ ${pkgtype} = virtual ]]
	then
	echo -ne " ${COLBLUE}---${COLDEFAULT}"
	echo " !unpack virtual (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "
	continue
	fi
	# abort on sources pkg
	if [[ ${pkgtype} = sources ]]
	then
	echo -ne " ${COLBLUE}---${COLDEFAULT}"
	echo " !unpack sources (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "
	continue
	fi
	echo -e " ${COLBLUE}***${COLDEFAULT} unpacking (${count_current}/${count_total}): ${pkg} ... "
	tar xjmf ${PKGDIR}/${pkg} -C ${BUILDDIR} || die "Unpacking package ${pkg}"
182	done	done
183
184	# add a crlf for a better view	# add a crlf for a better view
#	Line 75  fix_mtime()	Line 198  fix_mtime()
198	mtime=$(stat -c %Y "${reference}")	mtime=$(stat -c %Y "${reference}")
199	touch \	touch \
200	--no-create \	--no-create \
201		--no-dereference \
202	--time=mtime \	--time=mtime \
203	--reference "${reference}" \	--reference="${reference}" \
204	"${pathto}"	"${pathto}"
205
206	echo "${mtime}"	echo "${mtime}"
#	Line 130  install_directories()	Line 254  install_directories()
254	while read pathto posix user group	while read pathto posix user group
255	do	do
256	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
257	[[ ${VERBOSE} = on ]] && echo -e "\t>>> DIR:  ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> DIR:  ${MROOT}${pathto}"
258
259	# monitors /etc/env.d -> env-rebuild	# monitors /etc/env.d -> env-rebuild
260	[[ ${pathto} = /etc/env.d ]] && export MAGE_ENV_REBUILD=true	[[ ${pathto} = /etc/env.d ]] && export MAGE_ENV_REBUILD=true
#	Line 198  install_files()	Line 321  install_files()
321	is_config_protected "${pathto}"	is_config_protected "${pathto}"
322	retval="$?"	retval="$?"
323
324	# 0 - not protected        #	# 0 - not protected         #
325	# 1 - error                #	# 1 - error                 #
326	# 2 - protected            #	# 2 - protected             #
327	# 3 - protected but masked #	# 3 - protected but masked  #
328		# 4 - protected but ignored #
329
330	case ${retval} in	case ${retval} in
331	# file is not protected - (over)write it	# file is not protected - (over)write it
332	0|3)	0|3)
333	[[ ${VERBOSE} = on ]] && echo -e "\t>>> FILE: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> FILE: ${MROOT}${pathto}"
334	install -m "${posix}" -o "${user}" -g "${group}" \	install -m "${posix}" -o "${user}" -g "${group}" \
335	${BUILDDIR}/${pkgname}/binfiles/"${pathto}" \	${BUILDDIR}/${pkgname}/binfiles/"${pathto}" \
336	"${MROOT}${pathto}"	"${MROOT}${pathto}"
#	Line 218  install_files()	Line 342  install_files()
342	"${user}" \	"${user}" \
343	"${group}" \	"${group}" \
344	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
345	"${MROOT}${pathto}")" \	"${MROOT}${pathto}")" \
346	"${md5sum}"	"${md5sum}"
347	;;	;;
348
349	# file is protected, write backup file	# file is protected, write backup file
350	2)	2)
351	if [[ ${VERBOSE} = on ]]	if mqueryfeature "verbose"
352	then	then
353	echo -en "${COLRED}"	echo -en "${COLRED}"
354	echo -n "! prot "	echo -n "! prot "
#	Line 245  install_files()	Line 369  install_files()
369	"${user}" \	"${user}" \
370	"${group}" \	"${group}" \
371	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
372	"${dest_protected}")" \	"${dest_protected}")" \
373	"${md5sum}"	"${md5sum}"
374
375	# update global MAGE_PROTECT_COUNTER	# update global MAGE_PROTECT_COUNTER
376	(( MAGE_PROTECT_COUNTER++ ))	(( MAGE_PROTECT_COUNTER++ ))
377	export MAGE_PROTECT_COUNTER	export MAGE_PROTECT_COUNTER
378	;;	;;
379
380		# file is protected but ignored, delete the update/do nothing
381		4)
382		if mqueryfeature "verbose"
383		then
384		echo -en "${COLRED}"
385		echo -n "! ignr "
386		echo -en "${COLDEFAULT}"
387		echo " === FILE: ${MROOT}${pathto}"
388		fi
389		# simply do nothing here - only fix mtime
390		fix_descriptor ${pkgname}/.files \
391		"${pathto}" \
392		"${posix}" \
393		"${user}" \
394		"${group}" \
395		"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
396		"${MROOT}${pathto}")" \
397		"${md5sum}"
398		;;
399	esac	esac
400	done < ${BUILDDIR}/${pkgname}/.files	done < ${BUILDDIR}/${pkgname}/.files
401
#	Line 294  install_symlinks()	Line 438  install_symlinks()
438	while read pathto posix link mtime	while read pathto posix link mtime
439	do	do
440	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
441	[[ ${VERBOSE} = on ]] && echo -e "\t>>> LINK: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> LINK: ${MROOT}${pathto}"
442
443	ln -snf "${link}" "${MROOT}${pathto}"	ln -snf "${link}" "${MROOT}${pathto}"
444
445	# fix mtime and db	# fix mtime and db
446	fix_descriptor ${pkgname}/.symlinks \	fix_descriptor ${pkgname}/.symlinks \
447	"${pathto}" \	"${pathto}" \
448	"${posix}" \	"${posix}" \
449	"${link}" \	"${link}" \
450	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
451	"${MROOT}${pathto}")"	"${MROOT}${pathto}")"
452
453	done < ${BUILDDIR}/${pkgname}/.symlinks	done < ${BUILDDIR}/${pkgname}/.symlinks
454
455	# now copy the fixed file over the old one	# # now copy the fixed file over the old one
456	[ -f ${BUILDDIR}/${pkgname}/.symlinks_fixed ] && \	# [ -f ${BUILDDIR}/${pkgname}/.symlinks_fixed ] && \
457	cp -f ${BUILDDIR}/${pkgname}/.symlinks{_fixed,}	# cp -f ${BUILDDIR}/${pkgname}/.symlinks{_fixed,}
458
459	# very important: unsetting the '§' fieldseperator	# very important: unsetting the '§' fieldseperator
460	IFS=$'\n'	IFS=$'\n'
#	Line 326  install_blockdevices()	Line 470  install_blockdevices()
470	local pkgname="$1"	local pkgname="$1"
471	local pathto	local pathto
472	local posix	local posix
473		local user
474		local group
475	local IFS	local IFS
476
477	# sanity checks; abort if not given	# sanity checks; abort if not given
#	Line 339  install_blockdevices()	Line 485  install_blockdevices()
485	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
486	IFS=§	IFS=§
487
488	while read pathto posix	while read pathto posix major minor user group
489	do	do
490	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
491	[[ ${VERBOSE} = on ]] && echo -e "\t>>> PIPE: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> PIPE: ${MROOT}${pathto}"
492
493	mkfifo -m "${posix}" "${MROOT}$pathto"	mknod -m "${posix}" "${MROOT}${pathto}"
494		# make it optional atm !!
495		if [[ ! -z ${user} ]] && [[ ! -z ${group} ]]
496		then
497		chown "${user}:${group}" "${MROOT}${pathto}" b "${major}" "${minor}"
498		fi
499	done < ${BUILDDIR}/${pkgname}/.pipes	done < ${BUILDDIR}/${pkgname}/.pipes
500
501	# very important: unsetting the '§' fieldseperator	# very important: unsetting the '§' fieldseperator
#	Line 361  install_characterdevices()	Line 512  install_characterdevices()
512	local pkgname="$1"	local pkgname="$1"
513	local pathto	local pathto
514	local posix	local posix
515		local major
516		local minor
517		local user
518		local group
519	local IFS	local IFS
520
521	# sanity checks; abort if not given	# sanity checks; abort if not given
#	Line 374  install_characterdevices()	Line 529  install_characterdevices()
529	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
530	IFS=§	IFS=§
531
532	while read pathto posix	while read pathto posix major minor user group
533	do	do
534	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
535	[[ ${VERBOSE} = on ]] && echo -e "\t>>> CHAR: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> CHAR: ${MROOT}${pathto}"
536
537	mknode -m ${posix} -c "${MROOT}${pathto}"	mknod -m ${posix} "${MROOT}${pathto}" b "${major}" "${minor}"
538
539		# make it optional atm !!
540		if [[ ! -z ${user} ]] && [[ ! -z ${group} ]]
541		then
542		chown "${user}:${group}" "${MROOT}${pathto}"
543		fi
544	done < ${BUILDDIR}/${pkgname}/.char	done < ${BUILDDIR}/${pkgname}/.char
545
546	# very important: unsetting the '§' fieldseperator	# very important: unsetting the '§' fieldseperator
547	IFS=$'\n'	IFS=$'\n'
548	}	}
549
550		###################################################
551		# function install_fifos                          #
552		# install_fifos $PKGNAME                    #
553		###################################################
554		install_fifos()
555		{
556		local pkgname="$1"
557		local pathto
558		local posix
559		local user
560		local group
561		local IFS
562
563		# sanity checks; abort if not given
564		[ -z "${pkgname}" ] && die "install_fifos() \$pkgname not given."
565
566		# check needed global vars
567		[ -z "${BUILDDIR}" ] && die "install_fifos() \$BUILDDIR not set."
568
569		# make it optional atm !!
570		#[ ! -f ${BUILDDIR}/${pkgname}/.fifo ] && die "install_fifos() .fifo not found"
571		[ ! -f ${BUILDDIR}/${pkgname}/.fifo ] && return
572
573		# sets fieldseperator to "§" instead of " "
574		IFS=§
575
576		while read pathto posix user group
577		do
578		[ -z "${pathto}" ] && continue
579		mqueryfeature "verbose" && echo -e "\t>>> FIFO: ${MROOT}${pathto}"
580
581		mkfifo -m "${posix}" "${MROOT}${pathto}"
582		chown "${user}:${group}" "${MROOT}${pathto}"
583		done < ${BUILDDIR}/${pkgname}/.fifo
584
585		# very important: unsetting the '§' fieldseperator
586		IFS=$'\n'
587		}
588
589
590	###################################################	###################################################
591	# function build_doinstall                        #	# function build_doinstall                        #
592	# build_doinstall $PKGNAME                  #	# build_doinstall $PKGNAME                  #
593	# NOTE: this is an wrapper do install packages    #	# NOTE: this is an wrapper to install packages    #
594	###################################################	###################################################
595	build_doinstall()	build_doinstall()
596	{	{
#	Line 398  build_doinstall()	Line 598  build_doinstall()
598
599	# sanity checks; abort if not given	# sanity checks; abort if not given
600	[ -z "${pkgname}" ] && die "build_doinstall() \$pkgname not given."	[ -z "${pkgname}" ] && die "build_doinstall() \$pkgname not given."
601
602	# this is only a wrapper	# this is only a wrapper
603
604	# NOTE:	# NOTE:
#	Line 413  build_doinstall()	Line 613  build_doinstall()
613	install_symlinks ${pkgname} || die "install symlinks ${pkgname}"	install_symlinks ${pkgname} || die "install symlinks ${pkgname}"
614	install_blockdevices ${pkgname} || die "install blockdevices ${pkgname}"	install_blockdevices ${pkgname} || die "install blockdevices ${pkgname}"
615	install_characterdevices ${pkgname} || die "install chardevices ${pkgname}"	install_characterdevices ${pkgname} || die "install chardevices ${pkgname}"
616		install_fifos ${pkgname} || die "install fifos ${pkgname}"
617	}	}
618
619
#	Line 432  install_database_entry()	Line 633  install_database_entry()
633	local magefile	local magefile
634	local dbrecorddir	local dbrecorddir
635	local provide	local provide
636		local i
637
638	# very basic getops	# very basic getops
639	for i in $*	for i in $*
#	Line 473  install_database_entry()	Line 675  install_database_entry()
675
676	# create fake file descriptors	# create fake file descriptors
677	# used by virtual and source packages	# used by virtual and source packages
678	local i	for i in .dirs .symlinks .files .pipes .char .fifo
	for i in .dirs .symlinks .files .pipes .char
679	do	do
680	touch ${dbrecorddir}/${i}	touch ${dbrecorddir}/${i}
681	done	done
#	Line 492  install_database_entry()	Line 693  install_database_entry()
693
694	# normal packages needs these files	# normal packages needs these files
695	local i	local i
696	for i in .char .dirs .files .pipes .symlinks	for i in .char .dirs .files .pipes .symlinks .fifo
697	do	do
698	install -m 0644 ${BUILDDIR}/${pkgname}/${i} \	# make .fifo optional atm
699	${dbrecorddir}/${i}	if [[ -f ${BUILDDIR}/${pkgname}/${i} ]]
700		then
701		install -m 0644 ${BUILDDIR}/${pkgname}/${i} ${dbrecorddir}/${i}
702		fi
703	done	done
704	;;	;;
705	esac	esac
#	Line 504  install_database_entry()	Line 708  install_database_entry()
708	provide="$(get_value_from_magefile PROVIDE ${magefile})"	provide="$(get_value_from_magefile PROVIDE ${magefile})"
709	if [ -n "${provide}" ]	if [ -n "${provide}" ]
710	then	then
711	virtuals_add "${provide}" "${pcat}/${pname}"	for i in ${provide}
712		do
713		virtuals_add "${i}" "${pcat}/${pname}"
714		done
715	fi	fi
716	}	}
717
#	Line 523  remove_database_entry()	Line 730  remove_database_entry()
730	local magefile	local magefile
731	local dbrecorddir	local dbrecorddir
732	local provide	local provide
733		local i
734
735	# very basic getops	# very basic getops
736	for i in $*	for i in $*
#	Line 552  remove_database_entry()	Line 760  remove_database_entry()
760	# abort if mage file not exists	# abort if mage file not exists
761	[ ! -f ${magefile} ] && die "remove_database_entry() ${magefile} not exist."	[ ! -f ${magefile} ] && die "remove_database_entry() ${magefile} not exist."
762
763	# first unregister virtuals	# remove virtuals only if no other exist
764	provide="$(get_value_from_magefile PROVIDE ${magefile})"	if [[ $(count_installed_pkgs --pcat=${pcat} --pname=${pname}) -le 1 ]]
	if [ -n "${provide}" ]
765	then	then
766	virtuals_del "${provide}" "${pcat}/${pname}"	# first unregister virtuals
767		provide="$(get_value_from_magefile PROVIDE ${magefile})"
768		if [ -n "${provide}" ]
769		then
770		for i in ${provide}
771		do
772		virtuals_del "${i}" "${pcat}/${pname}"
773		done
774		fi
775	fi	fi
776
777	# removes database entry	# removes database entry
#	Line 566  remove_database_entry()	Line 781  remove_database_entry()
781	fi	fi
782	}	}
783
784		# get the number of installed packages
785		count_installed_pkgs()
786		{
787		local pcat
788		local pname
789		local pkg
790		local i
791
792		# very basic getops
793		for i in $@
794		do
795		case ${i} in
796		--pcat*) pcat="${i#*=}" ;;
797		--pname*) pname="${i#*=}" ;;
798		esac
799		done
800
801		# sanity checks; abort if not given
802		[ -z "${pcat}" ] && die "pkg_count() \$pcat not given."
803		[ -z "${pname}" ] && die "pkg_count() \$pname not given."
804
805		declare -i i=0
806		for pkg in $(get_uninstall_candidates --pcat ${pcat} --pname ${pname})
807		do
808		(( i++ ))
809		#echo "$i ${pkg}"
810		done
811
812		# return the value
813		echo "${i}"
814		}
815
816
817	###################################################	###################################################
818	# function compare_mtime                          #	# function compare_mtime                          #
#	Line 587  compare_mtime()	Line 834  compare_mtime()
834
835	mtime="$(stat -c %Y ${MROOT}${INSTALLDB}/${pfull}/.mtime)"	mtime="$(stat -c %Y ${MROOT}${INSTALLDB}/${pfull}/.mtime)"
836
837	# if $pathto is a symlink than compare linked binary	# no extra handlink for symlinks anymore as fix_mtime
838	if [ -L "${MROOT}${pathto}" ]	# uses --no-dereference, compare directly
839	then	x=$(stat -c %Y "${MROOT}${pathto}")
	# readlink -f resolves full path of linked file
	x="$(readlink -f "${MROOT}${pathto}")"
	# abort if target does not exists
	# we keep safe here, theoretically the link can removed
	[ ! -e "${x}" ] && return 1
	x=$(stat -c %Y "${x}")
	else
	x=$(stat -c %Y "${MROOT}${pathto}")
	fi
840
841	[[ ${mtime} = ${x} ]] && return 0	[[ ${mtime} = ${x} ]] && return 0
842
#	Line 662  remove_symlinks()	Line 898  remove_symlinks()
898	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
899	if [ ! -L "${MROOT}${pathto}" ]	if [ ! -L "${MROOT}${pathto}" ]
900	then	then
901	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
902	echo -e "${COLRED}! exist${COLDEFAULT} === LINK: ${MROOT}${pathto}"	echo -e "${COLRED}! exist${COLDEFAULT} === LINK: ${MROOT}${pathto}"
903	continue	continue
904	fi	fi
#	Line 674  remove_symlinks()	Line 910  remove_symlinks()
910	# 1=keep me   #	# 1=keep me   #
911	case ${retval} in	case ${retval} in
912	0)	0)
913	[[ ${VERBOSE} = on ]] && echo -e "\t<<< LINK: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< LINK: ${MROOT}${pathto}"
914	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
915	;;	;;
916
917	1)	1)
918	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
919	echo -e "${COLRED}! mtime${COLDEFAULT} === LINK: ${MROOT}${pathto}"	echo -e "${COLRED}! mtime${COLDEFAULT} === LINK: ${MROOT}${pathto}"
920	;;	;;
921	esac	esac
#	Line 726  remove_files()	Line 962  remove_files()
962	done	done
963
964	# sanity checks; abort if not given	# sanity checks; abort if not given
965	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_files() \$pcat not given."
966	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_files() \$pname not given."
967	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_files() \$pver not given."
968	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_files() \$pbuild not given."
969	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
970
971	# check needed global vars	# check needed global vars
#	Line 746  remove_files()	Line 982  remove_files()
982
983	if [ ! -e "${MROOT}${pathto}" ]	if [ ! -e "${MROOT}${pathto}" ]
984	then	then
985	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
986	echo -e "${COLRED}! exist${COLDEFAULT} === FILE: ${MROOT}${pathto}"	echo -e "${COLRED}! exist${COLDEFAULT} === FILE: ${MROOT}${pathto}"
987	continue	continue
988	fi	fi
#	Line 758  remove_files()	Line 994  remove_files()
994	# 1=keep me   #	# 1=keep me   #
995	case ${retval} in	case ${retval} in
996	0)	0)
997	[[ ${VERBOSE} = on ]] && echo -e "\t<<< FILE: ${MROOT}${pathto}"	# check if the file is config_protected
998	rm "${MROOT}${pathto}"	# ${MROOT} will automatically added if set !!
999	;;	is_config_protected "${pathto}"
1000		retval="$?"
1001
1002		# 0 - not protected         #
1003		# 1 - error                 #
1004		# 2 - protected             #
1005		# 3 - protected but masked  #
1006		# 4 - protected but ignored #
1007
1008		case ${retval} in
1009		# file is not protected - delete it
1010		0|3)
1011		mqueryfeature "verbose" && echo -e "\t<<< FILE: ${MROOT}${pathto}"
1012		rm "${MROOT}${pathto}"
1013		;;
1014
1015		# file is protected, do not delete
1016		2)
1017		if mqueryfeature "verbose"
1018		then
1019		echo -en "${COLRED}"
1020		echo -n "! prot "
1021		echo -en "${COLDEFAULT}"
1022		echo " === FILE: ${MROOT}${pathto}"
1023		fi
1024		;;
1025
1026		# file is protected but ignored, delete the update/do nothing
1027		4)
1028		if mqueryfeature "verbose"
1029		then
1030		echo -en "${COLRED}"
1031		echo -n "! ignr "
1032		echo -en "${COLDEFAULT}"
1033		echo " === FILE: ${MROOT}${pathto}"
1034		fi
1035		# simply do nothing here
1036		;;
1037		esac
1038		;;
1039	1)	1)
1040	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1041	echo -e "${COLRED}! mtime${COLDEFAULT} === FILE: ${MROOT}${pathto}"	echo -e "${COLRED}! mtime${COLDEFAULT} === FILE: ${MROOT}${pathto}"
1042	;;	;;
1043	esac	esac
#	Line 782  remove_blockdevices()	Line 1056  remove_blockdevices()
1056	{	{
1057	local pathto	local pathto
1058	local posix	local posix
1059		local user
1060		local group
1061	local IFS	local IFS
1062	local pcat	local pcat
1063	local pname	local pname
#	Line 805  remove_blockdevices()	Line 1081  remove_blockdevices()
1081	done	done
1082
1083	# sanity checks; abort if not given	# sanity checks; abort if not given
1084	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_blockdevices() \$pcat not given."
1085	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_blockdevices() \$pname not given."
1086	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_blockdevices() \$pver not given."
1087	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_blockdevices() \$pbuild not given."
1088	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
1089
1090	# check needed global vars	# check needed global vars
#	Line 819  remove_blockdevices()	Line 1095  remove_blockdevices()
1095	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
1096	IFS=§	IFS=§
1097
1098	while read pathto posix	while read pathto posix user group
1099	do	do
1100	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
1101
1102	[[ ${VERBOSE} = on ]] && echo -e "\t<<< PIPE: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< PIPE: ${MROOT}${pathto}"
1103	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
1104	done < ${MROOT}${INSTALLDB}/${pfull}/.pipes	done < ${MROOT}${INSTALLDB}/${pfull}/.pipes
1105
#	Line 840  remove_characterdevices()	Line 1116  remove_characterdevices()
1116	{	{
1117	local pathto	local pathto
1118	local posix	local posix
1119		local user
1120		local group
1121	local IFS	local IFS
1122	local pcat	local pcat
1123	local pname	local pname
#	Line 863  remove_characterdevices()	Line 1141  remove_characterdevices()
1141	done	done
1142
1143	# sanity checks; abort if not given	# sanity checks; abort if not given
1144	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_characterdevices() \$pcat not given."
1145	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_characterdevices() \$pname not given."
1146	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_characterdevices() \$pver not given."
1147	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_characterdevices() \$pbuild not given."
1148	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
1149
1150	# check needed global vars	# check needed global vars
#	Line 877  remove_characterdevices()	Line 1155  remove_characterdevices()
1155	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
1156	IFS=§	IFS=§
1157
1158	while read pathto posix	while read pathto posix user group
1159	do	do
1160	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
1161
1162	[[ ${VERBOSE} = on ]] && echo -e "\t<<< CHAR: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< CHAR: ${MROOT}${pathto}"
1163	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
1164	done < ${MROOT}${INSTALLDB}/${pfull}/.char	done < ${MROOT}${INSTALLDB}/${pfull}/.char
1165
#	Line 891  remove_characterdevices()	Line 1169  remove_characterdevices()
1169
1170
1171	###################################################	###################################################
1172		# function remove_fifos                           #
1173		# remove_fifos $PKGNAME                     #
1174		###################################################
1175		remove_fifos()
1176		{
1177		local pathto
1178		local posix
1179		local user
1180		local group
1181		local IFS
1182		local pcat
1183		local pname
1184		local pver
1185		local pbuild
1186		local i
1187		local pfull
1188
1189		IFS=$'\n'
1190
1191		# very basic getops
1192		for i in $*
1193		do
1194		case $1 in
1195		--pcat|-c) shift; pcat="$1" ;;
1196		--pname|-n) shift; pname="$1" ;;
1197		--pver|-v) shift; pver="$1" ;;
1198		--pbuild|-b) shift; pbuild="$1" ;;
1199		esac
1200		shift
1201		done
1202
1203		# sanity checks; abort if not given
1204		[ -z "${pcat}" ] && die "remove_fifos() \$pcat not given."
1205		[ -z "${pname}" ] && die "remove_fifos() \$pname not given."
1206		[ -z "${pver}" ] && die "remove_fifos() \$pver not given."
1207		[ -z "${pbuild}" ] && die "remove_fifos() \$pbuild not given."
1208		pfull="${pcat}/${pname}-${pver}-${pbuild}"
1209
1210		# check needed global vars
1211		[ -z "${BUILDDIR}" ] && die "remove_fifos() \$BUILDDIR not set."
1212
1213		# make it optional atm !!
1214		#[ ! -f ${MROOT}${INSTALLDB}/${pfull}/.fifo ] && die "remove_fifos() .fifo not found"
1215		[ ! -f ${MROOT}${INSTALLDB}/${pfull}/.fifo ] && return
1216
1217		# sets fieldseperator to "§" instead of " "
1218		IFS=§
1219
1220		while read pathto posix user group
1221		do
1222		[ -z "${pathto}" ] && continue
1223
1224		mqueryfeature "verbose" && echo -e "\t<<< FIFO: ${MROOT}${pathto}"
1225		rm "${MROOT}${pathto}"
1226		done < ${MROOT}${INSTALLDB}/${pfull}/.fifo
1227
1228		# very important: unsetting the '§' fieldseperator
1229		IFS=$'\n'
1230		}
1231
1232
1233		###################################################
1234	# function remove_direcories                      #	# function remove_direcories                      #
1235	# remove_direcories $PKGNAME                #	# remove_direcories $PKGNAME                #
1236	###################################################	###################################################
#	Line 921  remove_directories()	Line 1261  remove_directories()
1261	done	done
1262
1263	# sanity checks; abort if not given	# sanity checks; abort if not given
1264	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_directories() \$pcat not given."
1265	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_directories() \$pname not given."
1266	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_directories() \$pver not given."
1267	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_directories() \$pbuild not given."
1268	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
1269
1270	# check needed global vars	# check needed global vars
#	Line 942  remove_directories()	Line 1282  remove_directories()
1282
1283	if [ ! -d "${MROOT}${pathto}" ]	if [ ! -d "${MROOT}${pathto}" ]
1284	then	then
1285	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1286	echo -e "${COLRED}! exist${COLDEFAULT} === DIR:  ${MROOT}${pathto}"	echo -e "${COLRED}! exist${COLDEFAULT} === DIR:  ${MROOT}${pathto}"
1287	continue	continue
1288	fi	fi
#	Line 950  remove_directories()	Line 1290  remove_directories()
1290	# exclude .keep directories	# exclude .keep directories
1291	if [ -f "${MROOT}${pathto}/.keep" ]	if [ -f "${MROOT}${pathto}/.keep" ]
1292	then	then
1293	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1294	echo -e "${COLRED}! .keep${COLDEFAULT} === DIR:  ${MROOT}${pathto}"	echo -e "${COLRED}! .keep${COLDEFAULT} === DIR:  ${MROOT}${pathto}"
1295	continue	continue
1296	fi	fi
#	Line 963  remove_directories()	Line 1303  remove_directories()
1303
1304	if rmdir "${MROOT}${pathto}" &> /dev/null	if rmdir "${MROOT}${pathto}" &> /dev/null
1305	then	then
1306	[[ ${VERBOSE} = on ]] && echo -e "\t<<< DIR:  ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< DIR:  ${MROOT}${pathto}"
1307	else	else
1308	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1309	echo -e "${COLRED}! empty${COLDEFAULT} === DIR:  ${MROOT}${pathto}"	echo -e "${COLRED}! empty${COLDEFAULT} === DIR:  ${MROOT}${pathto}"
1310	fi	fi
1311	done	done
#	Line 978  remove_directories()	Line 1318  remove_directories()
1318	###################################################	###################################################
1319	# function build_douninstall                      #	# function build_douninstall                      #
1320	# build_douninstall $PKGNAME                #	# build_douninstall $PKGNAME                #
1321	# NOTE: this is an wrapper do remove packages     #	# NOTE: this is an wrapper to remove packages     #
1322	###################################################	###################################################
1323	build_douninstall()	build_douninstall()
1324	{	{
#	Line 1012  build_douninstall()	Line 1352  build_douninstall()
1352	# !! we use § as field seperator !!	# !! we use § as field seperator !!
1353	# doing so prevent us to get errors by filenames with spaces	# doing so prevent us to get errors by filenames with spaces
1354
1355	for i in symlinks files blockdevices characterdevices directories	for i in symlinks files blockdevices characterdevices directories fifos
1356	do	do
1357	remove_${i} \	remove_${i} \
1358	--pcat "${pcat}" \	--pcat "${pcat}" \
#	Line 1023  build_douninstall()	Line 1363  build_douninstall()
1363	done	done
1364	}	}
1365
1366		# convertmirrors [uri]
1367		convertmirrors()
1368		{
1369		local uri="$1"
1370		local scheme
1371		local mirror
1372		local mirrors
1373		local addon
1374		local real_uri
1375		local output
1376
1377		# needs
1378		[[ -z ${MIRRORS} ]] && die "convertmirrors(): no mirrors defined!"
1379		[[ -z ${SOURCEFORGE_MIRRORS} ]] && die "convertmirrors(): no sourceforge mirrors defined!"
1380		[[ -z ${GNU_MIRRORS} ]] && die "convertmirrors(): no gnu mirrors defined!"
1381		[[ -z ${GNOME_MIRRORS} ]] && die "convertmirrors(): no gnome mirrors defined!"
1382		[[ -z ${KDE_MIRRORS} ]] && die "convertmirrors(): no kde mirrors defined!"
1383
1384		# check known uri schemes
1385		case ${uri} in
1386		http://*|https://*|ftp://*|ftps://*|file://*) mirrors="" ;;
1387		mirror://*) mirrors="${MIRRORS}"; scheme="mirror://"; addon="/sources" ;;
1388		package://*) mirrors="${MIRRORS}"; scheme="package://"; addon="/${PACKAGES_SERVER_PATH}" ;;
1389		gnu://*) mirrors="${GNU_MIRRORS}"; scheme="gnu://" ;;
1390		sourceforge://*) mirrors="${SOURCEFORGE_MIRRORS}"; scheme="sourceforge://" ;;
1391		gnome://*) mirrors="${GNOME_MIRRORS}"; scheme="gnome://" ;;
1392		kde://*) mirrors="${KDE_MIRRORS}"; scheme="kde://" ;;
1393		*) die "convertmirror(): unsupported uri scheme in '${uri}'!" ;;
1394		esac
1395
1396		if [[ ! -z ${mirrors} ]]
1397		then
1398		for mirror in ${mirrors}
1399		do
1400		# add a whitespace to the output
1401		[[ -z ${output} ]] || output+=" "
1402		output+="${mirror}${addon}/${uri/${scheme}/}"
1403		done
1404		else
1405		output="${uri}"
1406		fi
1407
1408		echo "${output}"
1409		}
1410
1411		mdownload()
1412		{
1413		local i
1414		local uri
1415		local real_uris
1416		local mirror
1417		local outputfile
1418		local outputdir
1419		local retval
1420		local wget_opts
1421
1422		# very basic getops
1423		for i in $*
1424		do
1425		case $1 in
1426		--uri|-u) shift; uri="$1" ;;
1427		--dir|-d) shift; outputdir="$1" ;;
1428		esac
1429		shift
1430		done
1431
1432		# sanity checks; abort if not given
1433		[[ -z ${uri} ]] && die "mdownload(): no uri given!"
1434		[[ -z ${outputdir} ]] && die "mdownload(): no dir given!"
1435
1436		# convert mirrored uris to the real ones
1437		real_uris="$(convertmirrors ${uri})"
1438
1439		# verbose or not
1440		mqueryfeature "!verbose" && wget_opts+=" --quiet"
1441
1442		# filter wget options if busybox was found
1443		wget_opts+=" $(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1444
1445		# create outputdir
1446		[[ ! -d ${outputdir} ]] && install -d "${outputdir}"
1447
1448		for mirror in ${real_uris}
1449		do
1450		# get the name of the output file
1451		outputfile="${mirror##*/}"
1452
1453		case ${mirror} in
1454		file://*)
1455		cp -v "${mirror//file:\/\/}" "${outputdir}/${outputfile}"
1456		retval="$?"
1457		;;
1458		*)
1459		wget ${wget_opts} --output-document="${outputdir}/${outputfile}" "${mirror}"
1460		retval="$?"
1461		;;
1462		esac
1463
1464		if [[ ${retval} = 0 ]]
1465		then
1466		break
1467		else
1468		continue
1469		fi
1470		done
1471
1472		# return wget retval
1473		return "${retval}"
1474		}
1475
1476	# fetch_packages /path/to/mage/file1 /path/to/mage/file2	# fetch_packages /path/to/mage/file1 /path/to/mage/file2
1477	fetch_packages()	fetch_packages()
1478	{	{
1479		local i
1480	local list="$@"	local list="$@"
1481	local pkg	local pkgname
1482		local pkgfile
1483		local pcat
1484		local pname
1485	local mirr	local mirr
1486	local magefile	local magefile
1487	local md5file	local md5file
1488	local opt	local opt
1489	local count_current	local count_current
1490	local count_total	local count_total
1491		local wget_opts
1492		local fetching
1493
1494	[ -z "${MIRRORS}" ] && die "You have no mirrors defined. Please edit your /etc/mage.rc."	[ -z "${MIRRORS}" ] && die "You have no mirrors defined. Please edit your ${MAGERC}."
1495
1496		# filter wget command if busybox was found
1497		wget_opts="$(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1498
1499	# get count of total packages	# get count of total packages
1500	declare -i count_current=0	declare -i count_current=0
#	Line 1045  fetch_packages()	Line 1504  fetch_packages()
1504
1505	for magefile in ${list}	for magefile in ${list}
1506	do	do
1507	pkg="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
1508		pkgfile="${pkgname}.${PKGSUFFIX}"
1509	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
1510
1511		pcat=$(magename2pcat ${magefile})
1512		pname=$(magename2pname ${magefile})
1513		md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
1514
1515	(( count_current++ ))	(( count_current++ ))
1516	xtitle "[ (${count_current}/${count_total}) Fetching ${pkg} ]"	xtitle "[ (${count_current}/${count_total}) Fetching ${pkgfile} ]"
1517
1518	# abort on virtual pkg	# abort on virtual pkg
1519	if [[ ${pkgtype} = virtual ]]	if [[ ${pkgtype} = virtual ]]
1520	then	then
1521	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
1522	echo " !fetch virtual (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "	echo " !fetch virtual (${count_current}/${count_total}): ${pkgname} ... "
1523	continue	continue
1524	fi	fi
1525
#	Line 1063  fetch_packages()	Line 1527  fetch_packages()
1527	if [[ ${pkgtype} = sources ]]	if [[ ${pkgtype} = sources ]]
1528	then	then
1529	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
1530	echo " !fetch sources (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "	echo " !fetch sources (${count_current}/${count_total}): ${pkgname} ... "
1531	continue	continue
1532	fi	fi
1533
1534	# abort if already exist	# check if FETCHING is required
1535	if [ -f ${PKGDIR}/${pkg} ]	if [ ! -f "${md5file}" ]
1536	then	then
1537	echo -ne " ${COLBLUE}***${COLDEFAULT}"	fetching=true
1538	echo " fetch complete (${count_current}/${count_total}): ${pkg} ... "	else
1539	continue	if mchecksum --rundir "${PKGDIR}" --file "${md5file}" --method md5 &> /dev/null
	fi
	for mirr in ${MIRRORS}
	do
	echo -ne " ${COLBLUE}***${COLDEFAULT}"
	#echo -e " fetching (${count_current}/${count_total}): ${mirr}/${pkg} ... "
	echo -e " fetching (${count_current}/${count_total}): ${pkg} ... "
	[[ ${VERBOSE} = off ]] && opt="--quiet"
	wget \
	--passive-ftp \
	--tries 3 \
	--continue \
	--progress bar \
	--directory-prefix=${PKGDIR} \
	${opt} ${mirr}/packages/${pkg}
	if [[ $? = 0 ]]
1540	then	then
1541	break	# md5's ok, no fetching required
1542		fetching=false
1543	else	else
1544	continue	fetching=true
1545	fi	fi
1546	done	fi
1547
1548	if [ ! -f ${PKGDIR}/${pkg} ]	if [[ ${fetching} = false ]]
1549	then	then
1550	die "Could not download ${pkg}"	echo -ne " ${COLBLUE}***${COLDEFAULT}"
1551		echo " fetch complete (${count_current}/${count_total}): ${pkgfile} ... "
1552		continue
1553		else
1554		echo -ne " ${COLBLUE}***${COLDEFAULT}"
1555		echo -e " fetching (${count_current}/${count_total}): ${pkgfile} ... "
1556		mdownload --uri "package://${pkgfile}" --dir "${PKGDIR}" || die "Could not download ${pkgfile}"
1557		fi
1558
1559		# sanity check, not really needed but to be sure
1560		if [ ! -f ${PKGDIR}/${pkgfile} ]
1561		then
1562		die "Package '${pkgfile}' after download not found in '${PKGDIR}'"
1563	fi	fi
1564	done	done
1565
#	Line 1110  syncmage()	Line 1571  syncmage()
1571	{	{
1572	if [ -z "${RSYNC}" ]	if [ -z "${RSYNC}" ]
1573	then	then
1574	die "You have no rsync-mirrors defined. Please edit your /etc/mage.rc."	die "You have no rsync-mirrors defined. Please edit your ${MAGERC}."
1575	fi	fi
1576
1577	local i	local i
1578	for i in ${RSYNC}	for i in ${RSYNC}
1579	do	do
1580	rsync \	rsync ${RSYNC_FETCH_OPTIONS} ${i} ${MAGEDIR}
	--recursive \
	--links \
	--perms \
	--times \
	--devices \
	--timeout=600 \
	--verbose \
	--compress \
	--progress \
	--stats \
	--delete \
	--delete-after \
	${i} ${MAGEDIR}
1581	if [[ $? = 0 ]]	if [[ $? = 0 ]]
1582	then	then
1583	break	break
#	Line 1139  syncmage()	Line 1587  syncmage()
1587	done	done
1588
1589	# clean up backup files (foo~)	# clean up backup files (foo~)
1590	find ${MAGEDIR} -name *~ -exec rm '{}' ';'	find ${MAGEDIR} -name \*~ -exec rm '{}' ';'
1591
1592	# check if an newer mage version is available	# check if a newer mage version is available
1593	is_newer_mage_version_available	is_newer_mage_version_available
1594	}	}
1595
1596		syncmage_tarball()
1597		{
1598		local latest_tarball
1599		local latest_md5
1600		local temp="$(mktemp -d)"
1601		local mirr mymirr
1602		local opt
1603		local tar_opts
1604		local wget_opts
1605
1606		# try to get the md5 marked as latest on the server
1607		latest_md5="mage-latest.md5"
1608
1609		# try to get the tarball marked as latest on the server
1610		latest_tarball="mage-latest.tar.bz2"
1611
1612		# filter wget command if busybox was found
1613		wget_opts="$(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1614
1615		for mirr in ${MIRRORS}
1616		do
1617		# path without distribution
1618		# (only for stable|testing|unstable and not DISTROTAG)
1619		case ${mirr##*/} in
1620		stable|testing|unstable) mymirr="${mirr%/*}";;
1621		*) mymirr="${mirr}";;
1622		esac
1623
1624		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1625		echo "fetching latest md5 from ${mymirr} ..."
1626		mqueryfeature "!verbose" && opt="--quiet"
1627		wget \
1628		${wget_opts} \
1629		--directory-prefix=${temp} \
1630		${opt} ${mymirr}/rsync/tarballs/${latest_md5}
1631
1632		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1633		echo "fetching latest tarball from ${mymirr} ..."
1634		wget \
1635		${wget_opts} \
1636		--directory-prefix=${temp} \
1637		${opt} ${mymirr}/rsync/tarballs/${latest_tarball}
1638		if [[ $? = 0 ]]
1639		then
1640		break
1641		else
1642		continue
1643		fi
1644		done
1645
1646		if [[ -f ${temp}/${latest_tarball} ]]
1647		then
1648		# check md5
1649		if [[ ! -f ${temp}/${latest_md5} ]]
1650		then
1651		die "md5 is missing ... aborting"
1652		else
1653		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1654		echo -n "checking md5sum... "
1655		mchecksum --rundir "${temp}" --file "${latest_md5}" --method md5 || die "md5 for ${latest_tarball} failed"
1656		fi
1657
1658		if [[ -d ${MAGEDIR} ]]
1659		then
1660		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1661		echo "cleaning old mage-tree ${MAGEDIR}..."
1662		# honor mountpoints and empty dirs
1663		if mountpoint -q ${MAGEDIR}
1664		then
1665		if ! mcheckemptydir ${MAGEDIR}
1666		then
1667		find ${MAGEDIR} -mindepth 1 -maxdepth 1 | xargs --no-run-if-empty rm -r
1668		fi
1669		else
1670		rm -rf ${MAGEDIR}
1671		fi
1672		fi
1673
1674		if need_busybox_support tar
1675		then
1676		tar_opts="xjf"
1677		else
1678		tar_opts="xjmf"
1679		fi
1680
1681		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1682		echo "updating mage-tree from tarball ..."
1683		# unpack in dirname of MAGEDIR, as the tarball has already the mage
1684		tar ${tar_opts} ${temp}/${latest_tarball} -C ${MAGEDIR%/*} || die "Unpacking tarball"
1685
1686		if [[ -d ${temp} ]]
1687		then
1688		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1689		echo "cleaning temp-files ..."
1690		rm -rf ${temp}
1691		fi
1692
1693		# check if a newer mage version is available
1694		is_newer_mage_version_available
1695		else
1696		die "Could not fetch the latest tarball ... aborting"
1697		fi
1698		}
1699
1700	cleanpkg()	cleanpkg()
1701	{	{
1702	if [ -d "${PKGDIR}" ]	if [ -d "${PKGDIR}" ]
#	Line 1175  xtitleclean()	Line 1727  xtitleclean()
1727	}	}
1728
1729
1730	# cuts full pathnames or versioniezed names down to basename	# unused?
1731	choppkgname()	#
1732	{	# # cuts full pathnames or versionized names down to basename
1733	#we want this only if full name was used	# choppkgname()
1734	if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]	# {
1735	then	# #we want this only if full name was used
1736	#cuts ARCH and PBUILD	# if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]
1737	#ARCH comes from /etc/mage.rc	# then
1738	MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}-r*.::g")	# #cuts ARCH and PBUILD
1739		# #ARCH comes from ${MAGERC}
1740		# MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}$(print_distrotag)-r*.::g")
1741		#
1742		# #cuts version number
1743		# MAGENAME=$(basename ${MAGENAME%-*} .mage)
1744		# fi
1745		# }
1746
	#cuts version number
	MAGENAME=$(basename ${MAGENAME%-*} .mage)
	fi
	}
1747
1748	# get_categorie $PNAME, returns CATEGORIE	# get_categorie $PNAME, returns CATEGORIE
1749	# $1=pname	# $1=pname
#	Line 1215  pname2pcat()	Line 1770  pname2pcat()
1770	# returns 0=stable 1=unstable	# returns 0=stable 1=unstable
1771	check_stable_package()	check_stable_package()
1772	{	{
1773		# first check if this magefile is not blacklisted
1774		blacklisted "$1" || return 1
1775
1776	local STATE	local STATE
1777	STATE="$(get_value_from_magefile STATE "$1")"	STATE="$(get_value_from_magefile STATE "$1")"
1778
1779	# state testing	# state testing
1780	if [[ ${USE_TESTING} = true ]]	if [[ ${USE_TESTING} = true ]] || [[ ${MAGE_DISTRIBUTION} = testing ]]
1781	then	then
1782	case ${STATE} in	case ${STATE} in
1783	testing|stable) return 0 ;;	testing|stable) return 0 ;;
#	Line 1228  check_stable_package()	Line 1786  check_stable_package()
1786	fi	fi
1787
1788	# state unstable	# state unstable
1789	if [[ ${USE_UNSTABLE} = true ]]	if [[ ${USE_UNSTABLE} = true ]] || [[ ${MAGE_DISTRIBUTION} = unstable ]]
1790	then	then
1791	case ${STATE} in	case ${STATE} in
1792	unstable|testing|stable) return 0 ;;	unstable|testing|stable) return 0 ;;
#	Line 1254  get_highest_magefile()	Line 1812  get_highest_magefile()
1812	local PNAME="$2"	local PNAME="$2"
1813	local magefile	local magefile
1814
1815	for magefile in $(ls --format=single-column -v ${MAGEDIR}/${PCAT}/${PNAME}/*)	# do not list the content of a directory, only the name (-d)
1816		for magefile in $(ls --format=single-column -v -d ${MAGEDIR}/${PCAT}/${PNAME}/* 2> /dev/null)
1817	do	do
1818		[[ -z ${magefile} ]] && continue
1819	# we exclude subdirs (for stuff like a md5sum dir)	# we exclude subdirs (for stuff like a md5sum dir)
1820	[ -d ${magefile} ] && continue	[[ -d ${magefile} ]] && continue
1821	if check_stable_package ${magefile}	if check_stable_package ${magefile}
1822	then	then
1823	HIGHEST_MAGEFILE=${magefile}	HIGHEST_MAGEFILE=${magefile}
1824	#for debug only	#for debug only
1825	[[ ${MAGEDEBUG} = on ]] && echo "HIGHEST_MAGEFILE=${HIGHEST_MAGEFILE}"	mqueryfeature "debug" && echo "HIGHEST_MAGEFILE=${HIGHEST_MAGEFILE}" >&2
1826	fi	fi
1827	done	done
1828
	# stop here if HIGHEST_MAGEFILE is zero
	# this package must be unstable or old
	if [ -z "${HIGHEST_MAGEFILE}" ]
	then
	echo
	echo -n "All packages named "
	echo -en ${COLRED}\""${PKGNAME%-*-*-*}\""${COLDEFAULT}
	echo -n " are marked "
	echo -en ${COLRED}"*UNSTABLE*"${COLDEFAULT}
	echo "."
	echo "You need to declare USE_UNSTABLE=true to install this."
	echo
	echo "Example:"
	echo "         USE_UNSTABLE=true mage install ${PKGNAME%-*-*-*}"
	echo
	echo "Be warned that these packages are not stable and may cause serious problems."
	echo "You should know what you are doing, so don't complain about any damage."
	echo
	return 1
	fi
1829	echo "${HIGHEST_MAGEFILE}"	echo "${HIGHEST_MAGEFILE}"
1830	return 0	return 0
1831	}	}
#	Line 1301  get_highest_magefile()	Line 1840  get_highest_magefile()
1840	#        1 - error                                #	#        1 - error                                #
1841	#        2 - protected                            #	#        2 - protected                            #
1842	#        3 - protected but masked                 #	#        3 - protected but masked                 #
1843		#        4 - protected but ignored                #
1844	#                                                 #	#                                                 #
1845	###################################################	###################################################
1846	is_config_protected()	is_config_protected()
#	Line 1309  is_config_protected()	Line 1849  is_config_protected()
1849	local TEST	local TEST
1850	local PROTECTED	local PROTECTED
1851	local IFS	local IFS
1852		local i
1853		local x
1854
1855	EXPFILE="${MROOT}$1"	EXPFILE="${MROOT}$1"
1856
1857	# file does not exist; it can be written	# file does not exist; it can be written
1858	[ ! -e ${EXPFILE} ] && return 0	[[ ! -e ${EXPFILE} ]] && return 0
1859
1860	# to be safe; it may be '§'	# to be safe; it may be '§'
1861	IFS=' '	IFS=' '
1862
1863	# check ob in config protect	# check if config protected
1864	for i in ${CONFIG_PROTECT}	for i in ${CONFIG_PROTECT}
1865	do	do
1866	# ersetzen von $i nur wenn am anfang der variable	# only replace $i in the beginning of the variable
1867	TEST="${EXPFILE/#${MROOT}${i}/Protected}"	TEST="${EXPFILE/#${MROOT}${i}/Protected}"
1868	if [ "${TEST}" != "${EXPFILE}" ]	if [[ ${TEST} != ${EXPFILE} ]]
1869	then	then
1870	# setzen das es protected ist	# file is config proteced
1871	PROTECTED=TRUE	PROTECTED=TRUE
1872
1873	# check ob nicht doch maskiert	# check if not masked
1874	for x in ${CONFIG_PROTECT_MASK}	for x in ${CONFIG_PROTECT_MASK}
1875	do	do
1876	TEST="${EXPFILE/#${MROOT}${x}/Protect_Masked}"	TEST="${EXPFILE/#${MROOT}${x}/Protect_Masked}"
1877	if [ "${TEST}" != "${EXPFILE}" ]	if [[ ${TEST} != ${EXPFILE} ]]
1878	then	then
1879	PROTECTED=MASKED	PROTECTED=MASKED
1880	fi	fi
1881	done	done
1882
1883		# check if not ignored
1884		for x in ${CONFIG_PROTECT_IGNORE}
1885		do
1886		TEST="${EXPFILE/#${MROOT}${x}/Protect_Ignored}"
1887		if [[ ${TEST} != ${EXPFILE} ]]
1888		then
1889		PROTECTED=IGNORED
1890		fi
1891		done
1892	fi	fi
1893	done	done
1894
#	Line 1351  is_config_protected()	Line 1903  is_config_protected()
1903	#echo "I'm protected, but masked - delete me"	#echo "I'm protected, but masked - delete me"
1904	return 3	return 3
1905	;;	;;
1906		IGNORED)
1907		#echo "I'm protected, but ignored - keep me, del update"
1908		return 4
1909		;;
1910	*)	*)
1911	#echo "delete me"	#echo "delete me"
1912	return 0	return 0
#	Line 1368  is_config_protected()	Line 1924  is_config_protected()
1924	###################################################	###################################################
1925	count_protected_files()	count_protected_files()
1926	{	{
1927	${MLIBDIR}/writeprotected "$1"	local file="$1"
1928		local dirname="${file%/*}"
1929		local filename="${file##*/}"
1930		local count
1931		local output
1932		local oldprotected
1933		local i
1934		local x
1935
1936		# hack; do not honor a global set IFS like '§'
1937		local IFS
1938
1939		count=0
1940
1941		# check if there are already protected files
1942		for oldprotected in $(find ${dirname} -iname "._cfg????_${filename}" |
1943		sed -e "s:\(^.*/\)\(._cfg*_\)\(/.*$\):\1\2\3\%\2\%\3:" |
1944		sort -t'%' -k3 -k2 | cut -f1 -d'%')
1945		do
1946		count="$(echo ${oldprotected} | sed 's:.*\/._cfg\(.*\)_.*:\1:')"
1947		done
1948
1949		# convert 0001 -> 1; 0120 -> 120 etc
1950		# use bash internal base functions to this task
1951		x="$((10#${count}))"
1952		for (( i=0; i<x; i++ ))
1953		do
1954		if [[ ${count:${i}:1} != 0 ]]
1955		then
1956		count="${count:${i}}"
1957		break
1958		fi
1959		done
1960
1961		count="$(( ${count}+1 ))"
1962
1963		# fill output up with zeros
1964		for (( i=${#count}; i < 4; i++ )); do output="${output}0"; done
1965		output="${output}${count}"
1966
1967		echo "${output}"
1968	}	}
1969
1970	# call with	# call with
#	Line 1385  get_uninstall_candidates()	Line 1981  get_uninstall_candidates()
1981	local list	local list
1982	local pcatdir	local pcatdir
1983	local protected	local protected
1984		local i
1985
1986	# very basic getops	# very basic getops
1987	for i in $*	for i in $*
#	Line 1397  get_uninstall_candidates()	Line 1994  get_uninstall_candidates()
1994	shift	shift
1995	done	done
1996
1997	# sanity checks; abort if not given	# it's not good to complain here about empty pnames; better to continue later anyway
1998	[ -z "${search_pname}" ] && die "get_uninstall_candidates() \$search_pname not given."	# # sanity checks; abort if not given
1999		# [ -z "${search_pname}" ] && die "get_uninstall_candidates() \$search_pname not given."
2000
2001
2002	# check needed global vars	# check needed global vars
2003	[ -z "${INSTALLDB}" ] && die "get_uninstall_candidates() \$INSTALLDB not set."	[ -z "${INSTALLDB}" ] && die "get_uninstall_candidates() \$INSTALLDB not set."
2004
2005	# set pcatdir to '*' if empty	# set pcatdir to '*' if empty
2006	[ -z "${pcatdir}" ] && pcatdir=*	[ -z "${pcatdir}" ] && pcatdir='*'
2007
2008	for pkg in ${MROOT}${INSTALLDB}/${pcatdir}/*	for pkg in ${MROOT}${INSTALLDB}/${pcatdir}/*
2009	do	do
#	Line 1490  virtuals_add()	Line 2088  virtuals_add()
2088	local oldline	local oldline
2089	local line i	local line i
2090	local installed_file	local installed_file
2091		local OLDIFS
2092
2093	if virtuals_read ${virtualname}	if virtuals_read ${virtualname}
2094	then	then
2095	# make shure ${PKG_NAME} is *not* in ${VIRTUAL_NAME} already	# make sure ${PKG_NAME} is *not* in ${VIRTUAL_NAME} already
2096	for i in $(virtuals_read ${virtualname} showpkgs)	for i in $(virtuals_read ${virtualname} showpkgs)
2097	do	do
2098	if [[ ${i} = ${pkgname} ]]	if [[ ${i} = ${pkgname} ]]
#	Line 1512  virtuals_add()	Line 2111  virtuals_add()
2111	# make a backup	# make a backup
2112	mv ${MROOT}${VIRTUALDB_FILE} ${MROOT}${VIRTUALDB_FILE}.old	mv ${MROOT}${VIRTUALDB_FILE} ${MROOT}${VIRTUALDB_FILE}.old
2113
2114		OLDIFS="${IFS}"
2115	IFS=$'\n'	IFS=$'\n'
2116	for line in $(< ${MROOT}${VIRTUALDB_FILE}.old)	for line in $(< ${MROOT}${VIRTUALDB_FILE}.old)
2117	do	do
#	Line 1523  virtuals_add()	Line 2123  virtuals_add()
2123	echo "${line}" >> ${MROOT}${VIRTUALDB_FILE}	echo "${line}" >> ${MROOT}${VIRTUALDB_FILE}
2124	fi	fi
2125	done	done
2126		# unset IFS
2127	#unset IFS	IFS="${OLDIFS}"
2128	else	else
2129	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
2130	echo "register ${pkgname} as ${virtualname} ..."	echo "register ${pkgname} as ${virtualname} ..."
2131	echo "${virtualname} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}	echo "${virtualname} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
2132	fi	fi
#	Line 1536  virtuals_add()	Line 2136  virtuals_add()
2136
2137	#deletes pakages from virtual database	#deletes pakages from virtual database
2138	#$1 virtualname; $2 pkgname	#$1 virtualname; $2 pkgname
2139	virtuals_del() {	virtuals_del()
2140		{
2141
2142	local VIRTUAL_NAME PKG_NAME OLD_LINE METHOD line i x PKG_INSTALLED	local virtualname="$1"
2143		local pkgname="$2"
2144	VIRTUAL_NAME=$1	local oldline
2145	PKG_NAME=$2	local method
2146		local line i x
2147	#first check if exists	local pkg_installed
2148	if virtuals_read ${VIRTUAL_NAME}	local OLDIFS
2149
2150		# first check if exists
2151		if virtuals_read ${virtualname}
2152	then	then
2153	#get method -> delall or update and check if ${PKG_NAME} exists in ${VIRTUAL_NAME}	# get method -> delall or update and check if ${PKG_NAME} exists in ${VIRTUAL_NAME}
2154	declare -i x=0	declare -i x=0
2155	for i in $(virtuals_read ${VIRTUAL_NAME} showpkgs)	for i in $(virtuals_read ${virtualname} showpkgs)
2156	do	do
2157	if [ "${i}" == "${PKG_NAME}" ]	if [[ ${i} = ${pkgname} ]]
2158	then	then
2159	PKG_INSTALLED=true	pkg_installed=true
2160	fi	fi
2161	((x++))	((x++))
2162	done	done
2163
2164	#abort if not installed	# abort if not installed
2165	if [ "${PKG_INSTALLED}" != "true" ]	if [[ ${pkg_installed} != true ]]
2166	then	then
2167	echo "!!!! ${PKG_NAME} does not exists in ${VIRTUAL_NAME}."	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2168		echo "${pkgname} does not exists in ${virtualname}."
2169	return 0	return 0
2170	fi	fi
2171
2172	if [ ${x} -ge 2 ]	if [ ${x} -ge 2 ]
2173	then	then
2174	METHOD=update	method=update
2175	else	else
2176	METHOD=delall	method=delall
2177	fi	fi
2178
2179	#get the complete line	# get the complete line
2180	OLD_LINE="$(virtuals_read ${VIRTUAL_NAME} showline)"	oldline="$(virtuals_read ${virtualname} showline)"
2181
2182	#make a backup	# make a backup of the db
2183	mv ${VIRTUALDB_FILE} ${VIRTUALDB_FILE}.old	mv ${VIRTUALDB_FILE} ${VIRTUALDB_FILE}.old
2184
2185	#parse virtualdb	# parse virtualdb
2186		OLDIFS="${IFS}"
2187	IFS=$'\n'	IFS=$'\n'
2188	for line in $(< ${VIRTUALDB_FILE}.old)	for line in $(< ${VIRTUALDB_FILE}.old)
2189	do	do
2190	if [ "${line}" == "${OLD_LINE}" ]	if [[ ${line} = ${oldline} ]]
2191	then	then
2192	#delall or update?	#delall or update?
2193	case ${METHOD} in	case ${method} in
2194	update)	update)
2195	echo "<<<< Unlinking ${PKG_NAME} from ${VIRTUAL_NAME} in virtual database ..."	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2196	#del PKG_NAME from line	echo "Unlinking ${pkgname} from ${virtualname} in virtual database ..."
2197	echo "${line/ ${PKG_NAME}/}" >> ${VIRTUALDB_FILE}	# del PKG_NAME from line
2198		echo "${line/ ${pkgname}/}" >> ${VIRTUALDB_FILE}
2199	;;	;;
2200	delall)	delall)
2201	echo "<<<< Deleting ${VIRTUAL_NAME} in virtual database ..."	echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
2202	#continue; do not write anything	echo "Deleting ${virtualname} in virtual database ..."
2203		# continue; do not write anything
2204	continue	continue
2205	;;	;;
2206	esac	esac
#	Line 1600  virtuals_del() {	Line 2208  virtuals_del() {
2208	echo "${line}" >> ${VIRTUALDB_FILE}	echo "${line}" >> ${VIRTUALDB_FILE}
2209	fi	fi
2210	done	done
2211	unset IFS	# unset IFS
2212		IFS="${OLDIFS}"
2213	else	else
2214	echo "!!!! ${VIRTUAL_NAME} does not exists in virtual database."	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2215		echo "${virtualname} does not exists in virtual database."
2216	fi	fi
2217	}	}
2218
#	Line 1634  minclude()	Line 2244  minclude()
2244	{	{
2245	local i	local i
2246
2247	if [ -n "$@" ]	if [[ -n $* ]]
2248	then	then
2249	for i in $@	for i in $*
2250	do	do
2251	[[ ${MAGEDEBUG} = on ]] && \	mqueryfeature "debug" && \
2252	echo "--- Including ${MAGEDIR}/include/${i}.minc"	echo "--- Including ${MAGEDIR}/include/${i}.minc"
2253	source ${MAGEDIR}/include/${i}.minc	source ${MAGEDIR}/include/${i}.minc
2254	done	done
2255	[[ ${MAGEDEBUG} = on ]] && echo	mqueryfeature "debug" && echo
2256	fi	fi
2257	}	}
2258
#	Line 1650  sminclude()	Line 2260  sminclude()
2260	{	{
2261	local i	local i
2262
2263	if [ -n "$@" ]	if [[ -n $* ]]
2264	then	then
2265	for i in $@	for i in $*
2266	do	do
2267	echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"	[[ ${SILENT} = 1 ]] || echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
2268	source ${SMAGESCRIPTSDIR}/include/${i}.sminc	source ${SMAGESCRIPTSDIR}/include/${i}.sminc
2269	done	done
2270	echo	[[ ${SILENT} = 1 ]] || echo
2271	fi	fi
2272	}	}
2273
#	Line 1676  is_newer_mage_version_available()	Line 2286  is_newer_mage_version_available()
2286	echo -en ${COLRED}"An update for your packetmanager is available. "${COLDEFAULT}	echo -en ${COLRED}"An update for your packetmanager is available. "${COLDEFAULT}
2287	echo -e ${COLBLUE}"[ ${newest_mage} ]"${COLDEFAULT}	echo -e ${COLBLUE}"[ ${newest_mage} ]"${COLDEFAULT}
2288	echo "It is recommened to install this newer version"	echo "It is recommened to install this newer version"
2289	echo "or your current system installation may brake."	echo "or your current system installation may break."
2290	echo	echo
2291	echo -en "Please update mage by running "	echo -en "Please update mage by running "
2292	echo -e ${COLGREEN}"'mage install mage'"${COLDEFAULT}	echo -e ${COLGREEN}"'mage install mage'"${COLDEFAULT}
#	Line 1948  get_value_from_magefile()	Line 2558  get_value_from_magefile()
2558	local magefile="$2"	local magefile="$2"
2559	local value	local value
2560
2561		[[ -z ${var} ]] && return 1
2562		[[ -z ${magefile} ]] && return 1
2563
2564	# local all possible vars of a mage file	# local all possible vars of a mage file
2565	# to prevent bad issues	# to prevent bad issues
2566	local PKGNAME	local PKGNAME
#	Line 1958  get_value_from_magefile()	Line 2571  get_value_from_magefile()
2571	local SDEPEND	local SDEPEND
2572	local PROVIDE	local PROVIDE
2573	local PKGTYPE	local PKGTYPE
2574		local SPLIT_PACKAGE_BASE
2575	local preinstall	local preinstall
2576	local postinstall	local postinstall
2577	local preremove	local preremove
#	Line 2004  mage_install()	Line 2618  mage_install()
2618	local count_current	local count_current
2619	local magefile	local magefile
2620	local src_install	local src_install
2621		local i
2622
2623	# very basic getops	# very basic getops
2624	for i in $*	for i in $*
#	Line 2077  mage_install()	Line 2692  mage_install()
2692	echo B:${pbuild}	echo B:${pbuild}
2693	fi	fi
2694
2695	smage2file=${SMAGESCRIPTSDIR}/${pname}/${pname}-${pver}-${pbuild}.smage2	if [[ -n ${SPLIT_PACKAGE_BASE} ]]
2696		then
2697		# basic svn compat
2698		if [[ -d ${SMAGESCRIPTSDIR}/.svn ]]
2699		then
2700		for i in ${SMAGESCRIPTSDIR}/*/${SPLIT_PACKAGE_BASE}/${SPLIT_PACKAGE_BASE}-${pver}-${pbuild}.smage2
2701		do
2702		smage2file="${i}"
2703		done
2704		else
2705		smage2file=${SMAGESCRIPTSDIR}/${SPLIT_PACKAGE_BASE}/${SPLIT_PACKAGE_BASE}-${pver}-${pbuild}.smage2
2706		fi
2707
2708		else
2709		# basic svn compat
2710		if [[ -d ${SMAGESCRIPTSDIR}/.svn ]]
2711		then
2712		for i in ${SMAGESCRIPTSDIR}/*/${pname}/${pname}-${pver}-${pbuild}.smage2
2713		do
2714		smage2file="${i}"
2715		done
2716		else
2717		smage2file=${SMAGESCRIPTSDIR}/${pname}/${pname}-${pver}-${pbuild}.smage2
2718		fi
2719		fi
2720
2721	if [ -f "${smage2file}" ]	if [ -f "${smage2file}" ]
2722	then	then
2723		echo -e " ${COLBLUE}***${COLDEFAULT} building package from source ... "
2724	smage2 ${smage2file} || die "compile failed"	smage2 ${smage2file} || die "compile failed"
2725	else	else
2726	echo	echo
#	Line 2093  mage_install()	Line 2734  mage_install()
2734	if [[ ${PKGTYPE} != virtual ]] && \	if [[ ${PKGTYPE} != virtual ]] && \
2735	[[ ${PKGTYPE} != sources ]]	[[ ${PKGTYPE} != sources ]]
2736	then	then
2737	# show a verbose message on src-install	unpack_package "${magefile}"
2738	if [[ ${src_install} = true ]]	echo -e " ${COLBLUE}***${COLDEFAULT} merging files into system ... "
	then
	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
	echo -ne "merging files: "
	echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
	echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"
	fi
2739	build_doinstall ${PKGNAME}	build_doinstall ${PKGNAME}
2740	fi	fi
2741
#	Line 2188  md5sum_packages()	Line 2823  md5sum_packages()
2823	pname=$(magename2pname ${magefile})	pname=$(magename2pname ${magefile})
2824	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
2825	md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"	md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
2826	pkgfile="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	pkgfile="${pkgname}.${PKGSUFFIX}"
2827	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
2828
2829	(( count_current++ ))	(( count_current++ ))
#	Line 2198  md5sum_packages()	Line 2833  md5sum_packages()
2833	if [[ ${pkgtype} = virtual ]]	if [[ ${pkgtype} = virtual ]]
2834	then	then
2835	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
2836	echo " !md5sum virtual (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "	echo " !md5sum virtual (${count_current}/${count_total}): ${pkgname} ... "
2837	continue	continue
2838	fi	fi
2839
#	Line 2206  md5sum_packages()	Line 2841  md5sum_packages()
2841	if [[ ${pkgtype} = sources ]]	if [[ ${pkgtype} = sources ]]
2842	then	then
2843	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
2844	echo " !md5sum sources (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "	echo " !md5sum sources (${count_current}/${count_total}): ${pkgname} ... "
2845	continue	continue
2846	fi	fi
2847
#	Line 2214  md5sum_packages()	Line 2849  md5sum_packages()
2849	then	then
2850	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2851	echo -ne "checking md5sum (${count_current}/${count_total}): "	echo -ne "checking md5sum (${count_current}/${count_total}): "
2852	( cd ${PKGDIR}; md5sum --check ${md5file}) || die "md5 for ${pkgfile} failed"	mchecksum --rundir "${PKGDIR}" --file "${md5file}" --method md5 || die "md5 for ${pkgfile} failed"
2853	else	else
2854	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2855	echo -e "!! no md5sum file found for ${pkgfile} :("	echo -e "!! no md5sum file found for ${pkgfile} :("
#	Line 2254  uninstall_packages()	Line 2889  uninstall_packages()
2889	pbuild=$(magename2pbuild ${pkg})	pbuild=$(magename2pbuild ${pkg})
2890	can_pcat="${pcat}"	can_pcat="${pcat}"
2891	can_pname="${pname}"	can_pname="${pname}"
2892
2893	if [ -z "${can_ver_list}" ]	if [ -z "${can_ver_list}" ]
2894	then	then
2895	can_ver_list=" ${pver}-${pbuild}"	can_ver_list=" ${pver}-${pbuild}"
#	Line 2357  mage_uninstall()	Line 2992  mage_uninstall()
2992	echo -ne "${COLBLUE} <<< ${COLDEFAULT}"	echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
2993	echo -n "removing: "	echo -n "removing: "
2994	echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"	echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
2995	echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"	echo -e "${COLRED}${pname}-${pver}-${pbuild}${COLDEFAULT}"
2996
2997	magefile="${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"	magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
2998	source ${magefile}	source ${magefile}
2999
3000	## preremove scripts	## preremove scripts
#	Line 2427  mage_uninstall()	Line 3062  mage_uninstall()
3062	unset -f postremove	unset -f postremove
3063	}	}
3064
3065	show_etc_update_mesg() {	# rerun_pkgfunctions [method] pkg1 pkg2 pkg3
3066		rerun_pkgfunctions()
3067		{
3068		local method
3069		local list
3070		local pcat
3071		local pname
3072		local pver
3073		local pbuild
3074		local magefile
3075		local i
3076
3077		# very basic getops
3078		case $1 in
3079		--method) shift; method="$1" ;;
3080		esac
3081		shift
3082		local list="$@"
3083
3084		# sanity check
3085		case ${method} in
3086		preinstall|postinstall) ;;
3087		preremove|postremove) ;;
3088		*) die "rerun_pkgfunctions(): Unknown method '${method}'." ;;
3089		esac
3090
3091		if [[ -n ${MROOT} ]]
3092		then
3093		echo -ne ${COLRED}
3094		echo "!! running in MROOT=${MROOT}"
3095		echo -ne ${COLDEFAULT}
3096		echo
3097		fi
3098
3099		for pkg in ${list}
3100		do
3101		pcat=$(dep2pcat ${pkg})
3102		pname=$(magename2pname ${pkg})
3103		pver=$(magename2pver ${pkg})
3104		pbuild=$(magename2pbuild ${pkg})
3105		magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
3106
3107		if [ -e ${magefile} ]
3108		then
3109		source ${magefile}
3110		if [ -n "$(typeset -f ${method})" ]
3111		then
3112		echo -e " ${COLBLUE}***${COLDEFAULT} running ${method} for ${pkg} ... "
3113		${method}
3114		else
3115		echo "No ${method}() for pkg '${pkg}' defined. Doing nothing."
3116		fi
3117		unset -f preinstall postinstall preremove postremove
3118		else
3119		die "Magefile '${magefile}' does not exist."
3120		fi
3121		done
3122		}
3123
3124		show_etc_update_mesg()
3125		{
3126	[ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0	[ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0
3127
3128	echo	echo
#	Line 2453  pkgsearch()	Line 3148  pkgsearch()
3148	local state	local state
3149	local descriptiom	local descriptiom
3150	local homepage	local homepage
3151		local license
3152	local i	local i
3153	local all_installed	local all_installed
3154	local ipver	local ipver
3155	local ipbuild	local ipbuild
3156		local latest_available
3157		local depsfull
3158		local sdepsfull
3159		local deps
3160		local sdeps
3161		local dep
3162		local sign
3163
3164	# only names no versions	# only names no versions
3165	result="$(find ${MAGEDIR} -mindepth 2 -maxdepth 2 -type d -name *${string}*)"	result="$(find ${MAGEDIR} -mindepth 2 -maxdepth 2 -type d -name '*'${string}'*'| sed '/profiles/d' | sed '/includes/d')"
3166	#result="$(find ${MAGEDIR} -type f -name *${string}*.mage | sort)"	#result="$(find ${MAGEDIR} -type f -name '*'${string}'*'.mage | sort)"
3167
3168	# nothing found	# nothing found
3169	[[ -z ${result} ]] && die "No package found containing '${string}' in the name."	[[ -z ${result} ]] && die "No package found containing '${string}' in the name."
#	Line 2474  pkgsearch()	Line 3177  pkgsearch()
3177	# get highest version available	# get highest version available
3178	magefile=$(get_highest_magefile ${pcat} ${pname})	magefile=$(get_highest_magefile ${pcat} ${pname})
3179
3180	# now get all needed infos to print a nice output	if [[ ! -z ${magefile} ]]
3181	pver="$(magename2pver ${magefile})"	then
3182	pbuild="$(magename2pbuild ${magefile})"	# now get all needed infos to print a nice output
3183	state="$(get_value_from_magefile STATE ${magefile})"	pver="$(magename2pver ${magefile})"
3184	description="$(get_value_from_magefile DESCRIPTION ${magefile})"	pbuild="$(magename2pbuild ${magefile})"
3185	homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"	state="$(get_value_from_magefile STATE ${magefile})"
3186		description="$(get_value_from_magefile DESCRIPTION ${magefile})"
3187		homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"
3188		license="$(get_value_from_magefile LICENSE ${magefile})"
3189
3190		# all installed
3191		for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})
3192		do
3193		ipver="$(magename2pver ${i})"
3194		ipbuild="$(magename2pbuild ${i})"
3195
3196		if [[ -z ${all_installed} ]]
3197		then
3198		all_installed="${ipver}-${ipbuild}"
3199		else
3200		all_installed="${all_installed} ${ipver}-${ipbuild}"
3201		fi
3202		done
3203		[[ -z ${all_installed} ]] && all_installed="none"
3204
3205		case ${state} in
3206		stable) state=${COLGREEN}"[s] ";;
3207		testing) state=${COLYELLOW}"[t] ";;
3208		unstable) state=${COLRED}"[u] ";;
3209		old) state=${COLGRAY}"[o] ";;
3210		esac
3211
3212		latest_available="${pver}-${pbuild}"
3213		else
3214		# package is masked
3215		state="${COLRED}[m] "
3216		latest_available="${COLRED}masked for this distribution.${COLDEFAULT}"
3217		fi
3218
3219	# all installed	depsfull="$(get_value_from_magefile DEPEND ${magefile})"
3220	for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})	sdepsfull="$(get_value_from_magefile SDEPEND ${magefile})"
3221
3222		while read sign dep
3223	do	do
3224	ipver="$(magename2pver ${i})"	case ${dep} in
3225	ipbuild="$(magename2pbuild ${i})"	"") continue;;
3226		esac
3227
3228	if [[ -z ${all_installed} ]]	if [[ -z ${deps} ]]
3229	then	then
3230	all_installed="${ipver}-${ipbuild}"	deps="$(basename ${dep%-*})"
3231	else	else
3232	all_installed="${all_installed} ${ipver}-${ipbuild}"	deps="${deps} $(basename ${dep%-*})"
3233	fi	fi
3234	done	done << EOF
3235	[[ -z ${all_installed} ]] && all_installed="none"	${depsfull}
3236		EOF
3237
3238	case ${state} in	while read sign dep
3239	stable) state=${COLGREEN}"[s] ";;	do
3240	testing) state=${COLYELLOW}"[t] ";;	case ${dep} in
3241	unstable) state=${COLRED}"[u] ";;	"") continue;;
3242	old) state=${COLGRAY}"[o] ";;	esac
3243	esac
3244		if [[ -z ${sdeps} ]]
3245		then
3246		sdeps="$(basename ${dep%-*})"
3247		else
3248		sdeps="${sdeps} $(basename ${dep%-*})"
3249		fi
3250		done << EOF
3251		${sdepsfull}
3252		EOF
3253
3254	echo -e "${state}${pcat}/${pname}"${COLDEFAULT}	echo -e "${state}${pcat}/${pname}"${COLDEFAULT}
3255	echo "      Latest available:   ${pver}-${pbuild}"	echo -e "      Latest available:   ${latest_available}"
3256	echo "      Installed versions: ${all_installed}"	echo "      Installed versions: ${all_installed}"
3257	echo "      Description: ${description}"	echo "      Description: ${description}"
3258	echo "      Homepage: ${homepage}"	echo "      Homepage: ${homepage}"
3259		if [[ ! -z ${license} ]]
3260		then
3261		echo "      License:  ${license}"
3262		fi
3263		echo "      Depends:  ${deps}"
3264		echo "      SDepends: ${sdeps}"
3265	echo	echo
3266
3267	unset pcat	unset pcat
#	Line 2521  pkgsearch()	Line 3275  pkgsearch()
3275	unset all_installed	unset all_installed
3276	unset ipver	unset ipver
3277	unset ipbuild	unset ipbuild
3278		unset depsfull
3279		unset sdepsfull
3280		unset deps
3281		unset sdeps
3282		unset dep
3283		unset sign
3284	done	done
3285	}	}
3286
#	Line 2540  export_inherits()	Line 3300  export_inherits()
3300	eval "${functions}() { ${include}_${functions} ; }"	eval "${functions}() { ${include}_${functions} ; }"
3301
3302	# debug	# debug
3303	[[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"	mqueryfeature "debug" && typeset -f "${functions}"
3304
3305	shift	shift
3306	done	done
3307	}	}
3308
3309		mlibdir()
3310		{
3311		local libdir=lib
3312		[[ ${ARCH} = x86_64 ]] && libdir=lib64
3313
3314		echo "${libdir}"
3315		}
3316
3317		## blacklisted ${magefile}
3318		blacklisted()
3319		{
3320		[[ -z ${MAGE_DISTRIBUTION} ]] && local MAGE_DISTRIBUTION=stable
3321
3322		# compat
3323		[[ ${USE_UNSTABLE} = true ]] && local MAGE_DISTRIBUTION=unstable
3324		[[ ${USE_TESTING} = true ]] && local MAGE_DISTRIBUTION=testing
3325
3326		# support both types for the moment
3327		if [[ -f /etc/mage-profile/package.blacklist-${ARCH}-${MAGE_DISTRIBUTION} ]]
3328		then
3329		local EXCLUDED="/etc/mage-profile/package.blacklist-${ARCH}-${MAGE_DISTRIBUTION}"
3330		else
3331		local EXCLUDED="/etc/mage-profile/package.blacklist-${ARCH}"
3332		fi
3333
3334		# return 0 if the list not exist; nothin is masked
3335		[[ ! -f ${EXCLUDED} ]] && return 0
3336
3337		local MAGEFILE="$1"
3338
3339		local PCAT="$(magename2pcat ${MAGEFILE})"
3340		local PNAME="$(magename2pname ${MAGEFILE})"
3341		local PVER="$(magename2pver ${MAGEFILE})"
3342		local PBUILD="$(magename2pbuild ${MAGEFILE})"
3343
3344		local EXPCAT EXPNAME EXPVER EXPBUILD
3345		while read EXPCAT EXPNAME EXPVER EXPBUILD
3346		do
3347		# ignore spaces and comments
3348		case "${EXPCAT}" in
3349		\#*|"") continue ;;
3350		esac
3351
3352		# exclude full pver
3353		if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
3354		[[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
3355		[[ -n ${PVER} ]] && [[ -n ${PBUILD} ]] &&
3356		[[ -n ${EXPVER} ]] && [[ -n ${EXPBUILD} ]]
3357		then
3358		[[ ${EXPCAT}/${EXPNAME}-${EXPVER}-${EXPBUILD} = ${PCAT}/${PNAME}-${PVER}-${PBUILD} ]] && return 1
3359		fi
3360
3361		# exclude pcat/pname only
3362		if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
3363		[[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
3364		[[ -z ${EXPVER} ]] && [[ -z ${EXPBUILD} ]]
3365		then
3366		[[ ${EXPCAT}/${EXPNAME} = ${PCAT}/${PNAME} ]] && return 1
3367		fi
3368		done << EOF
3369		$( cat ${EXCLUDED}; echo)
3370		EOF
3371
3372		return 0
3373		}
3374
3375		# need_busybox_support ${cmd}
3376		# return 0 (no error = needs busybox support) or return 1 (error = no busybox support required)
3377		need_busybox_support()
3378		{
3379		local cmd
3380		local busybox
3381		cmd="$1"
3382
3383		for busybox in {,/usr}/bin/busybox
3384		do
3385		if [[ -x ${busybox} ]]
3386		then
3387		if [[ $(readlink $(type -P ${cmd})) = ${busybox} ]]
3388		then
3389		# needs busybox support
3390		return 0
3391		fi
3392		fi
3393		done
3394
3395		# no busybox
3396		return 1
3397		}
3398
3399		# busybox_filter_wget_options ${wget_opts}
3400		busybox_filter_wget_options()
3401		{
3402		local opts="$@"
3403		local i
3404		local fixed_opts
3405
3406		if need_busybox_support wget
3407		then
3408		for i in ${opts}
3409		do
3410		# show only the allowed ones
3411		case ${i} in
3412		-c|--continue) fixed_opts+=" -c" ;;
3413		-s|--spider) fixed_opts+=" -s" ;;
3414		-q|--quiet) fixed_opts+=" -q" ;;
3415		-O|--output-document) shift; fixed_opts+=" -O $1" ;;
3416		--header) shift; fixed_opts+=" --header $1" ;;
3417		-Y|--proxy) shift; fixed_opts+=" -Y $1" ;;
3418		-P) shift; fixed_opts+=" -P $1" ;;
3419		--no-check-certificate) fixed_opts+=" --no-check-certificate ${i}" ;;
3420		-U|--user-agent) shift; fixed_opts+=" -U ${i}" ;;
3421		# simply drop all other opts
3422		*) continue ;;
3423		esac
3424		done
3425
3426		echo "${fixed_opts}"
3427		else
3428		echo "${opts}"
3429		fi
3430		}
3431
3432		have_root_privileges()
3433		{
3434		local retval
3435
3436		if [[ $(id -u) = 0 ]]
3437		then
3438		retval=0
3439		else
3440		retval=1
3441		fi
3442
3443		return ${retval}
3444		}
3445
3446		known_mage_feature()
3447		{
3448		local feature="$1"
3449		local retval
3450
3451		case "${feature}" in
3452		autosvc|!autosvc) retval=0 ;;
3453		buildlog|!buildlog) retval=0 ;;
3454		ccache|!ccache) retval=0 ;;
3455		check|!check) retval=0 ;;
3456		compressdoc|!compressdoc) retval=0 ;;
3457		debug|!debug) retval=0 ;;
3458		distcc|!distcc) retval=0 ;;
3459		icecc|!icecc) retval=0 ;;
3460		kernelsrcunpack|!kernelsrcunpack) retval=0 ;;
3461		libtool|!libtool) retval=0 ;;
3462		linuxsymlink|!linuxsymlink) retval=0 ;;
3463		pkgbuild|!pkgbuild) retval=0 ;;
3464		pkgdistrotag|!pkgdistrotag) retval=0 ;;
3465		purge|!purge) retval=0 ;;
3466		qalint|!qalint) retval=0 ;;
3467		regentree|!regentree) retval=0 ;;
3468		resume|!resume) retval=0 ;;
3469		srcpkgbuild|!srcpkgbuild) retval=0 ;;
3470		srcpkgtarball|!srcpkgtarball) retval=0 ;;
3471		static|!static) retval=0 ;;
3472		stepbystep|!stepbystep) retval=0 ;;
3473		strip|!strip) retval=0 ;;
3474		verbose|!verbose) retval=0 ;;
3475		*) retval=1 ;;
3476		esac
3477
3478		return "${retval}"
3479		}
3480
3481		load_mage_features()
3482		{
3483		for i in ${MAGE_FEATURES_GLOBAL[*]} ${MAGE_FEATURES[*]}
3484		do
3485		FVERBOSE=off msetfeature ${i}
3486		done
3487		}
3488
3489		msetfeature()
3490		{
3491		local feature
3492		local count
3493		local i
3494		local found
3495
3496		for feature in $@
3497		do
3498		found=0
3499		count="${#MAGE_FEATURES_CURRENT[*]}"
3500
3501		if ! known_mage_feature "${feature}"
3502		then
3503		[[ ${FVERBOSE} = off ]] || echo -e "${COLRED}Unknown feature '${feature}', ignoring it${COLDEFAULT}"
3504		return 3
3505		fi
3506
3507		for ((i=0; i<count; i++))
3508		do
3509		if [[ ${MAGE_FEATURES_CURRENT[${i}]} = ${feature} ]]
3510		then
3511		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' already enabled${COLDEFAULT}"
3512		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3513		found=1
3514		elif [[ ${MAGE_FEATURES_CURRENT[${i}]} = !${feature} ]]
3515		then
3516		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' currently disabled, enabling it!${COLDEFAULT}"
3517		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3518		found=1
3519		elif [[ ${MAGE_FEATURES_CURRENT[${i}]} = ${feature//!} ]]
3520		then
3521		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature//!}' currently enabled, disabling it!${COLDEFAULT}"
3522		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3523		found=1
3524		fi
3525		done
3526
3527		# if the feature was not found after proccessing the whole array
3528		# it was not declared. in this case enable it
3529		if [[ ${found} = 0 ]]
3530		then
3531		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' was not declared, enabling it!${COLDEFAULT}"
3532		MAGE_FEATURES_CURRENT=( ${MAGE_FEATURES_CURRENT[*]} "${feature}" )
3533		fi
3534
3535		export MAGE_FEATURES_CURRENT
3536		done
3537		}
3538
3539		mqueryfeature()
3540		{
3541		local feature="$1"
3542		local retval=1
3543		local i
3544
3545		if known_mage_feature "${feature}"
3546		then
3547		for i in ${MAGE_FEATURES_CURRENT[*]}
3548		do
3549		if [[ ${i} = ${feature} ]]
3550		then
3551		retval=0
3552		break # found break here
3553		fi
3554		done
3555		else
3556		[[ ${FVERBOSE} = off ]] || echo -e "${COLRED}Unknown feature '${feature}', ignoring it${COLDEFAULT}"
3557		retval=3
3558		fi
3559
3560		return ${retval}
3561		}
3562
3563		mprintfeatures()
3564		{
3565		echo -e "${COLRED}Global features:${COLDEFAULT} ${MAGE_FEATURES_GLOBAL[*]}"
3566		echo -e "${COLYELLOW}Local features:${COLDEFAULT} ${MAGE_FEATURES[*]}"
3567		echo -e "${COLGREEN}Current features:${COLDEFAULT} ${MAGE_FEATURES_CURRENT[*]}"
3568		}

---

Colored Diff Long Colored Diff Full Colored Diff Unidiff Context Diff Side by Side

Legend: Removed from v.258   changed lines   Added in v.2867