Diff of /branches/mage-next/src/mage4.functions.sh.in

Parent Directory | Revision Log | Patch

	trunk/mage/usr/lib/mage/mage4.functions.sh revision 226 by niro, Fri Sep 9 16:35:46 2005 UTC	branches/mage-next/src/mage4.functions.sh.in revision 2811 by niro, Wed Sep 3 12:01:21 2014 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.1 2005-09-09 16:35:38 niro Exp $	# $Id$
4
5	mage_setup()	mage_setup()
6	{	{
#	Line 15  mage_setup()	Line 15  mage_setup()
15	return 0	return 0
16	}	}
17
18		mchecksum()
19		{
20		local i
21		local rundir
22		local file
23		local method
24		local cmd
25		local retval
26		local sum
27		local dest
28
29		# very basic getops
30		for i in $*
31		do
32		case $1 in
33		--rundir|-r) shift; rundir="$1" ;;
34		--file|-f) shift; file="$1" ;;
35		--method|-m) shift; method="$1" ;;
36		esac
37		shift
38		done
39
40		# sanity checks
41		[[ -z ${rundir} ]] && die "mchecksum(): rundir missing"
42		[[ -z ${file} ]] && die "mchecksum(): file missing"
43		[[ -z ${method} ]] && die "mchecksum(): method missing"
44
45		case ${method} in
46		md5) cmd="md5sum" ;;
47		sha256) cmd="sha256sum" ;;
48		*) die "mchecksum(): unknown method '${method}'" ;;
49		esac
50
51		if [[ -d ${rundir} ]]
52		then
53		pushd ${rundir} &> /dev/null
54
55		# all file must be non-zero
56		retval=0
57		while read sum dest
58		do
59		if [ ! -s ${dest} ]
60		then
61		echo "${dest}: file is empty ;("
62		retval=127
63		fi
64		done < ${file}
65		if [[ ${retval} != 127 ]]
66		then
67		# be verbose here
68		${cmd} -c ${file} #&> /dev/null
69		retval="$?"
70		fi
71
72		popd &> /dev/null
73		else
74		retval=1
75		fi
76
77		return "${retval}"
78		}
79
80		mcheckemptydir()
81		{
82		local dir="$1"
83		local retval=1
84
85		if [[ ! -d ${dir} ]]
86		then
87		echo "mcheckemptydir(): '${dir}' is not a directory!"
88		retval=3
89		else
90		shopt -s nullglob dotglob
91		files=( ${dir}/* )
92		(( ${#files[*]} )) || retval=0
93		shopt -u nullglob dotglob
94		fi
95
96		return ${retval}
97		}
98
99		unpack_package()
100		{
101		local magefile="$1"
102		local pkgname
103		local pkgfile
104		local pkgtype
105		local tar_opts
106
107		pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
108		pkgfile="${pkgname}.${PKGSUFFIX}"
109		pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
110
111		xtitle "[ Unpacking ${pkg} ]"
112
113		# abort on virtual pkg
114		if [[ ${pkgtype} = virtual ]]
115		then
116		echo -ne " ${COLBLUE}---${COLDEFAULT}"
117		echo " !unpack virtual ${pkgname} ... "
118		continue
119		fi
120
121		# abort on sources pkg
122		if [[ ${pkgtype} = sources ]]
123		then
124		echo -ne " ${COLBLUE}---${COLDEFAULT}"
125		echo " !unpack sources ${pkgname} ... "
126		continue
127		fi
128
129		# busybox?
130		if need_busybox_support tar
131		then
132		tar_opts="xjf"
133		else
134		tar_opts="xjmf"
135		fi
136
137		echo -e " ${COLBLUE}***${COLDEFAULT} unpacking ${pkgfile} ... "
138		tar ${tar_opts} ${PKGDIR}/${pkgfile} -C ${BUILDDIR} || die "Unpacking package ${pkgfile}"
139		}
140
141	unpack_packages()	unpack_packages()
142	{	{
143	local list="$@"	local list="$@"
144	local magefile	local magefile
	local pkg
	local pkgtype
145	local count_current	local count_current
146	local count_total	local count_total
147		local tar_opts
148
149	# get count of total packages	# get count of total packages
150	declare -i count_current=0	declare -i count_current=0
#	Line 32  unpack_packages()	Line 154  unpack_packages()
154
155	for magefile in ${list}	for magefile in ${list}
156	do	do
157	pkg="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	unpack_package "${magefile}"
	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
158	(( 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}"
159	done	done
160
161	# add a crlf for a better view	# add a crlf for a better view
162	if [ ${count_total} -gt 1 ]; then echo; fi	if [ ${count_total} -gt 1 ]; then echo; fi
163	}	}
164
165	# fix_mtime path/to/$mtime/reffile $pathto/file	# fix_mtime path/to/$mtime/reffile $pathto/file
166	# creates a given reference file and fixes given file	# creates a given reference file and fixes given file
167	# returns new mtime	# returns new mtime
#	Line 75  fix_mtime()	Line 174  fix_mtime()
174	mtime=$(stat -c %Y "${reference}")	mtime=$(stat -c %Y "${reference}")
175	touch \	touch \
176	--no-create \	--no-create \
177		--no-dereference \
178	--time=mtime \	--time=mtime \
179	--reference "${reference}" \	--reference="${reference}" \
180	"${pathto}"	"${pathto}"
181
182	echo "${mtime}"	echo "${mtime}"
#	Line 130  install_directories()	Line 230  install_directories()
230	while read pathto posix user group	while read pathto posix user group
231	do	do
232	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
233	[[ ${VERBOSE} = on ]] && echo -e "\t>>> DIR:  ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> DIR:  ${MROOT}${pathto}"
234
235	# monitors /etc/env.d -> env-rebuild	# monitors /etc/env.d -> env-rebuild
236	[[ ${pathto} = /etc/env.d ]] && export MAGE_ENV_REBUILD=true	[[ ${pathto} = /etc/env.d ]] && export MAGE_ENV_REBUILD=true
#	Line 198  install_files()	Line 297  install_files()
297	is_config_protected "${pathto}"	is_config_protected "${pathto}"
298	retval="$?"	retval="$?"
299
300	# 0 - not protected        #	# 0 - not protected         #
301	# 1 - error                #	# 1 - error                 #
302	# 2 - protected            #	# 2 - protected             #
303	# 3 - protected but masked #	# 3 - protected but masked  #
304		# 4 - protected but ignored #
305
306	case ${retval} in	case ${retval} in
307	# file is not protected - (over)write it	# file is not protected - (over)write it
308	0|3)	0|3)
309	[[ ${VERBOSE} = on ]] && echo -e "\t>>> FILE: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> FILE: ${MROOT}${pathto}"
310	install -m "${posix}" -o "${user}" -g "${group}" \	install -m "${posix}" -o "${user}" -g "${group}" \
311	${BUILDDIR}/${pkgname}/binfiles/"${pathto}" \	${BUILDDIR}/${pkgname}/binfiles/"${pathto}" \
312	"${MROOT}${pathto}"	"${MROOT}${pathto}"
#	Line 218  install_files()	Line 318  install_files()
318	"${user}" \	"${user}" \
319	"${group}" \	"${group}" \
320	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
321	"${MROOT}${pathto}")" \	"${MROOT}${pathto}")" \
322	"${md5sum}"	"${md5sum}"
323	;;	;;
324
325	# file is protected, write backup file	# file is protected, write backup file
326	2)	2)
327	if [[ ${VERBOSE} = on ]]	if mqueryfeature "verbose"
328	then	then
329	echo -en "${COLRED}"	echo -en "${COLRED}"
330	echo -n "! prot "	echo -n "! prot "
#	Line 245  install_files()	Line 345  install_files()
345	"${user}" \	"${user}" \
346	"${group}" \	"${group}" \
347	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
348	"${dest_protected}")" \	"${dest_protected}")" \
349	"${md5sum}"	"${md5sum}"
350
351	# update global MAGE_PROTECT_COUNTER	# update global MAGE_PROTECT_COUNTER
352	(( MAGE_PROTECT_COUNTER++ ))	(( MAGE_PROTECT_COUNTER++ ))
353	export MAGE_PROTECT_COUNTER	export MAGE_PROTECT_COUNTER
354	;;	;;
355
356		# file is protected but ignored, delete the update/do nothing
357		4)
358		if mqueryfeature "verbose"
359		then
360		echo -en "${COLRED}"
361		echo -n "! ignr "
362		echo -en "${COLDEFAULT}"
363		echo " === FILE: ${MROOT}${pathto}"
364		fi
365		# simply do nothing here - only fix mtime
366		fix_descriptor ${pkgname}/.files \
367		"${pathto}" \
368		"${posix}" \
369		"${user}" \
370		"${group}" \
371		"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
372		"${MROOT}${pathto}")" \
373		"${md5sum}"
374		;;
375	esac	esac
376	done < ${BUILDDIR}/${pkgname}/.files	done < ${BUILDDIR}/${pkgname}/.files
377
#	Line 294  install_symlinks()	Line 414  install_symlinks()
414	while read pathto posix link mtime	while read pathto posix link mtime
415	do	do
416	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
417	[[ ${VERBOSE} = on ]] && echo -e "\t>>> LINK: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> LINK: ${MROOT}${pathto}"
418
419	ln -snf "${link}" "${MROOT}${pathto}"	ln -snf "${link}" "${MROOT}${pathto}"
420
421	# fix mtime and db	# fix mtime and db
422	fix_descriptor ${pkgname}/.symlinks \	fix_descriptor ${pkgname}/.symlinks \
423	"${pathto}" \	"${pathto}" \
424	"${posix}" \	"${posix}" \
425	"${link}" \	"${link}" \
426	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \	"$(fix_mtime "${BUILDDIR}/${pkgname}"/.mtime \
427	"${MROOT}${pathto}")"	"${MROOT}${pathto}")"
428
429	done < ${BUILDDIR}/${pkgname}/.symlinks	done < ${BUILDDIR}/${pkgname}/.symlinks
430
431	# now copy the fixed file over the old one	# # now copy the fixed file over the old one
432	[ -f ${BUILDDIR}/${pkgname}/.symlinks_fixed ] && \	# [ -f ${BUILDDIR}/${pkgname}/.symlinks_fixed ] && \
433	cp -f ${BUILDDIR}/${pkgname}/.symlinks{_fixed,}	# cp -f ${BUILDDIR}/${pkgname}/.symlinks{_fixed,}
434
435	# very important: unsetting the '§' fieldseperator	# very important: unsetting the '§' fieldseperator
436	IFS=$'\n'	IFS=$'\n'
#	Line 326  install_blockdevices()	Line 446  install_blockdevices()
446	local pkgname="$1"	local pkgname="$1"
447	local pathto	local pathto
448	local posix	local posix
449		local user
450		local group
451	local IFS	local IFS
452
453	# sanity checks; abort if not given	# sanity checks; abort if not given
#	Line 339  install_blockdevices()	Line 461  install_blockdevices()
461	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
462	IFS=§	IFS=§
463
464	while read pathto posix	while read pathto posix major minor user group
465	do	do
466	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
467	[[ ${VERBOSE} = on ]] && echo -e "\t>>> PIPE: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> PIPE: ${MROOT}${pathto}"
468
469	mkfifo -m "${posix}" "${MROOT}$pathto"	mknod -m "${posix}" "${MROOT}${pathto}"
470		# make it optional atm !!
471		if [[ ! -z ${user} ]] && [[ ! -z ${group} ]]
472		then
473		chown "${user}:${group}" "${MROOT}${pathto}" b "${major}" "${minor}"
474		fi
475	done < ${BUILDDIR}/${pkgname}/.pipes	done < ${BUILDDIR}/${pkgname}/.pipes
476
477	# very important: unsetting the '§' fieldseperator	# very important: unsetting the '§' fieldseperator
#	Line 361  install_characterdevices()	Line 488  install_characterdevices()
488	local pkgname="$1"	local pkgname="$1"
489	local pathto	local pathto
490	local posix	local posix
491		local major
492		local minor
493		local user
494		local group
495	local IFS	local IFS
496
497	# sanity checks; abort if not given	# sanity checks; abort if not given
#	Line 374  install_characterdevices()	Line 505  install_characterdevices()
505	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
506	IFS=§	IFS=§
507
508	while read pathto posix	while read pathto posix major minor user group
509	do	do
510	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
511	[[ ${VERBOSE} = on ]] && echo -e "\t>>> CHAR: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> CHAR: ${MROOT}${pathto}"
512
513		mknod -m ${posix} "${MROOT}${pathto}" b "${major}" "${minor}"
514
515	mknode -m ${posix} -c "${MROOT}${pathto}"	# make it optional atm !!
516		if [[ ! -z ${user} ]] && [[ ! -z ${group} ]]
517		then
518		chown "${user}:${group}" "${MROOT}${pathto}"
519		fi
520	done < ${BUILDDIR}/${pkgname}/.char	done < ${BUILDDIR}/${pkgname}/.char
521
522	# very important: unsetting the '§' fieldseperator	# very important: unsetting the '§' fieldseperator
523	IFS=$'\n'	IFS=$'\n'
524	}	}
525
526		###################################################
527		# function install_fifos                          #
528		# install_fifos $PKGNAME                    #
529		###################################################
530		install_fifos()
531		{
532		local pkgname="$1"
533		local pathto
534		local posix
535		local user
536		local group
537		local IFS
538
539		# sanity checks; abort if not given
540		[ -z "${pkgname}" ] && die "install_fifos() \$pkgname not given."
541
542		# check needed global vars
543		[ -z "${BUILDDIR}" ] && die "install_fifos() \$BUILDDIR not set."
544
545		# make it optional atm !!
546		#[ ! -f ${BUILDDIR}/${pkgname}/.fifo ] && die "install_fifos() .fifo not found"
547		[ ! -f ${BUILDDIR}/${pkgname}/.fifo ] && return
548
549		# sets fieldseperator to "§" instead of " "
550		IFS=§
551
552		while read pathto posix user group
553		do
554		[ -z "${pathto}" ] && continue
555		mqueryfeature "verbose" && echo -e "\t>>> FIFO: ${MROOT}${pathto}"
556
557		mkfifo -m "${posix}" "${MROOT}${pathto}"
558		chown "${user}:${group}" "${MROOT}${pathto}"
559		done < ${BUILDDIR}/${pkgname}/.fifo
560
561		# very important: unsetting the '§' fieldseperator
562		IFS=$'\n'
563		}
564
565
566	###################################################	###################################################
567	# function build_doinstall                        #	# function build_doinstall                        #
568	# build_doinstall $PKGNAME                  #	# build_doinstall $PKGNAME                  #
569	# NOTE: this is an wrapper do install packages    #	# NOTE: this is an wrapper to install packages    #
570	###################################################	###################################################
571	build_doinstall()	build_doinstall()
572	{	{
#	Line 398  build_doinstall()	Line 574  build_doinstall()
574
575	# sanity checks; abort if not given	# sanity checks; abort if not given
576	[ -z "${pkgname}" ] && die "build_doinstall() \$pkgname not given."	[ -z "${pkgname}" ] && die "build_doinstall() \$pkgname not given."
577
578	# this is only a wrapper	# this is only a wrapper
579
580	# NOTE:	# NOTE:
#	Line 413  build_doinstall()	Line 589  build_doinstall()
589	install_symlinks ${pkgname} || die "install symlinks ${pkgname}"	install_symlinks ${pkgname} || die "install symlinks ${pkgname}"
590	install_blockdevices ${pkgname} || die "install blockdevices ${pkgname}"	install_blockdevices ${pkgname} || die "install blockdevices ${pkgname}"
591	install_characterdevices ${pkgname} || die "install chardevices ${pkgname}"	install_characterdevices ${pkgname} || die "install chardevices ${pkgname}"
592		install_fifos ${pkgname} || die "install fifos ${pkgname}"
593	}	}
594
595
#	Line 432  install_database_entry()	Line 609  install_database_entry()
609	local magefile	local magefile
610	local dbrecorddir	local dbrecorddir
611	local provide	local provide
612		local i
613
614	# very basic getops	# very basic getops
615	for i in $*	for i in $*
#	Line 473  install_database_entry()	Line 651  install_database_entry()
651
652	# create fake file descriptors	# create fake file descriptors
653	# used by virtual and source packages	# used by virtual and source packages
654	local i	for i in .dirs .symlinks .files .pipes .char .fifo
	for i in .dirs .symlinks .files .pipes .char
655	do	do
656	touch ${dbrecorddir}/${i}	touch ${dbrecorddir}/${i}
657	done	done
#	Line 492  install_database_entry()	Line 669  install_database_entry()
669
670	# normal packages needs these files	# normal packages needs these files
671	local i	local i
672	for i in .char .dirs .files .pipes .symlinks	for i in .char .dirs .files .pipes .symlinks .fifo
673	do	do
674	install -m 0644 ${BUILDDIR}/${pkgname}/${i} \	# make .fifo optional atm
675	${dbrecorddir}/${i}	if [[ -f ${BUILDDIR}/${pkgname}/${i} ]]
676		then
677		install -m 0644 ${BUILDDIR}/${pkgname}/${i} ${dbrecorddir}/${i}
678		fi
679	done	done
680	;;	;;
681	esac	esac
#	Line 504  install_database_entry()	Line 684  install_database_entry()
684	provide="$(get_value_from_magefile PROVIDE ${magefile})"	provide="$(get_value_from_magefile PROVIDE ${magefile})"
685	if [ -n "${provide}" ]	if [ -n "${provide}" ]
686	then	then
687	virtuals_add "${provide}" "${pcat}/${pname}"	for i in ${provide}
688		do
689		virtuals_add "${i}" "${pcat}/${pname}"
690		done
691	fi	fi
692	}	}
693
#	Line 523  remove_database_entry()	Line 706  remove_database_entry()
706	local magefile	local magefile
707	local dbrecorddir	local dbrecorddir
708	local provide	local provide
709		local i
710
711	# very basic getops	# very basic getops
712	for i in $*	for i in $*
#	Line 552  remove_database_entry()	Line 736  remove_database_entry()
736	# abort if mage file not exists	# abort if mage file not exists
737	[ ! -f ${magefile} ] && die "remove_database_entry() ${magefile} not exist."	[ ! -f ${magefile} ] && die "remove_database_entry() ${magefile} not exist."
738
739	# first unregister virtuals	# remove virtuals only if no other exist
740	provide="$(get_value_from_magefile PROVIDE ${magefile})"	if [[ $(count_installed_pkgs --pcat=${pcat} --pname=${pname}) -le 1 ]]
	if [ -n "${provide}" ]
741	then	then
742	virtuals_del "${provide}" "${pcat}/${pname}"	# first unregister virtuals
743		provide="$(get_value_from_magefile PROVIDE ${magefile})"
744		if [ -n "${provide}" ]
745		then
746		for i in ${provide}
747		do
748		virtuals_del "${i}" "${pcat}/${pname}"
749		done
750		fi
751	fi	fi
752
753	# removes database entry	# removes database entry
#	Line 566  remove_database_entry()	Line 757  remove_database_entry()
757	fi	fi
758	}	}
759
760		# get the number of installed packages
761		count_installed_pkgs()
762		{
763		local pcat
764		local pname
765		local pkg
766		local i
767
768		# very basic getops
769		for i in $@
770		do
771		case ${i} in
772		--pcat*) pcat="${i#*=}" ;;
773		--pname*) pname="${i#*=}" ;;
774		esac
775		done
776
777		# sanity checks; abort if not given
778		[ -z "${pcat}" ] && die "pkg_count() \$pcat not given."
779		[ -z "${pname}" ] && die "pkg_count() \$pname not given."
780
781		declare -i i=0
782		for pkg in $(get_uninstall_candidates --pcat ${pcat} --pname ${pname})
783		do
784		(( i++ ))
785		#echo "$i ${pkg}"
786		done
787
788		# return the value
789		echo "${i}"
790		}
791
792
793	###################################################	###################################################
794	# function compare_mtime                          #	# function compare_mtime                          #
#	Line 587  compare_mtime()	Line 810  compare_mtime()
810
811	mtime="$(stat -c %Y ${MROOT}${INSTALLDB}/${pfull}/.mtime)"	mtime="$(stat -c %Y ${MROOT}${INSTALLDB}/${pfull}/.mtime)"
812
813	# if $pathto is a symlink than compare linked binary	# no extra handlink for symlinks anymore as fix_mtime
814	if [ -L "${MROOT}${pathto}" ]	# uses --no-dereference, compare directly
815	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
816
817	[[ ${mtime} = ${x} ]] && return 0	[[ ${mtime} = ${x} ]] && return 0
818
#	Line 662  remove_symlinks()	Line 874  remove_symlinks()
874	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
875	if [ ! -L "${MROOT}${pathto}" ]	if [ ! -L "${MROOT}${pathto}" ]
876	then	then
877	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
878	echo -e "${COLRED}! exist${COLDEFAULT} === LINK: ${MROOT}${pathto}"	echo -e "${COLRED}! exist${COLDEFAULT} === LINK: ${MROOT}${pathto}"
879	continue	continue
880	fi	fi
#	Line 674  remove_symlinks()	Line 886  remove_symlinks()
886	# 1=keep me   #	# 1=keep me   #
887	case ${retval} in	case ${retval} in
888	0)	0)
889	[[ ${VERBOSE} = on ]] && echo -e "\t<<< LINK: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< LINK: ${MROOT}${pathto}"
890	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
891	;;	;;
892
893	1)	1)
894	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
895	echo -e "${COLRED}! mtime${COLDEFAULT} === LINK: ${MROOT}${pathto}"	echo -e "${COLRED}! mtime${COLDEFAULT} === LINK: ${MROOT}${pathto}"
896	;;	;;
897	esac	esac
#	Line 726  remove_files()	Line 938  remove_files()
938	done	done
939
940	# sanity checks; abort if not given	# sanity checks; abort if not given
941	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_files() \$pcat not given."
942	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_files() \$pname not given."
943	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_files() \$pver not given."
944	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_files() \$pbuild not given."
945	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
946
947	# check needed global vars	# check needed global vars
#	Line 744  remove_files()	Line 956  remove_files()
956	do	do
957	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
958
959	if [ -e "${MROOT}${pathto}" ]	if [ ! -e "${MROOT}${pathto}" ]
960	then	then
961	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
962	echo -e "${COLRED}! exist${COLDEFAULT} === FILE: ${MROOT}${pathto}"	echo -e "${COLRED}! exist${COLDEFAULT} === FILE: ${MROOT}${pathto}"
963	continue	continue
964	fi	fi
#	Line 758  remove_files()	Line 970  remove_files()
970	# 1=keep me   #	# 1=keep me   #
971	case ${retval} in	case ${retval} in
972	0)	0)
973	[[ ${VERBOSE} = on ]] && echo -e "\t<<< FILE: ${MROOT}${pathto}"	# check if the file is config_protected
974	rm "${MROOT}${pathto}"	# ${MROOT} will automatically added if set !!
975	;;	is_config_protected "${pathto}"
976		retval="$?"
977
978		# 0 - not protected         #
979		# 1 - error                 #
980		# 2 - protected             #
981		# 3 - protected but masked  #
982		# 4 - protected but ignored #
983
984		case ${retval} in
985		# file is not protected - delete it
986		0|3)
987		mqueryfeature "verbose" && echo -e "\t<<< FILE: ${MROOT}${pathto}"
988		rm "${MROOT}${pathto}"
989		;;
990
991		# file is protected, do not delete
992		2)
993		if mqueryfeature "verbose"
994		then
995		echo -en "${COLRED}"
996		echo -n "! prot "
997		echo -en "${COLDEFAULT}"
998		echo " === FILE: ${MROOT}${pathto}"
999		fi
1000		;;
1001
1002		# file is protected but ignored, delete the update/do nothing
1003		4)
1004		if mqueryfeature "verbose"
1005		then
1006		echo -en "${COLRED}"
1007		echo -n "! ignr "
1008		echo -en "${COLDEFAULT}"
1009		echo " === FILE: ${MROOT}${pathto}"
1010		fi
1011		# simply do nothing here
1012		;;
1013		esac
1014		;;
1015	1)	1)
1016	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1017	echo -e "${COLRED}! mtime${COLDEFAULT} === FILE: ${MROOT}${pathto}"	echo -e "${COLRED}! mtime${COLDEFAULT} === FILE: ${MROOT}${pathto}"
1018	;;	;;
1019	esac	esac
#	Line 782  remove_blockdevices()	Line 1032  remove_blockdevices()
1032	{	{
1033	local pathto	local pathto
1034	local posix	local posix
1035		local user
1036		local group
1037	local IFS	local IFS
1038	local pcat	local pcat
1039	local pname	local pname
#	Line 805  remove_blockdevices()	Line 1057  remove_blockdevices()
1057	done	done
1058
1059	# sanity checks; abort if not given	# sanity checks; abort if not given
1060	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_blockdevices() \$pcat not given."
1061	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_blockdevices() \$pname not given."
1062	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_blockdevices() \$pver not given."
1063	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_blockdevices() \$pbuild not given."
1064	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
1065
1066	# check needed global vars	# check needed global vars
#	Line 819  remove_blockdevices()	Line 1071  remove_blockdevices()
1071	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
1072	IFS=§	IFS=§
1073
1074	while read pathto posix	while read pathto posix user group
1075	do	do
1076	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
1077
1078	[[ ${VERBOSE} = on ]] && echo -e "\t<<< PIPE: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< PIPE: ${MROOT}${pathto}"
1079	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
1080	done < ${MROOT}${INSTALLDB}/${pfull}/.pipes	done < ${MROOT}${INSTALLDB}/${pfull}/.pipes
1081
#	Line 840  remove_characterdevices()	Line 1092  remove_characterdevices()
1092	{	{
1093	local pathto	local pathto
1094	local posix	local posix
1095		local user
1096		local group
1097	local IFS	local IFS
1098	local pcat	local pcat
1099	local pname	local pname
#	Line 863  remove_characterdevices()	Line 1117  remove_characterdevices()
1117	done	done
1118
1119	# sanity checks; abort if not given	# sanity checks; abort if not given
1120	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_characterdevices() \$pcat not given."
1121	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_characterdevices() \$pname not given."
1122	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_characterdevices() \$pver not given."
1123	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_characterdevices() \$pbuild not given."
1124	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
1125
1126	# check needed global vars	# check needed global vars
#	Line 877  remove_characterdevices()	Line 1131  remove_characterdevices()
1131	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
1132	IFS=§	IFS=§
1133
1134	while read pathto posix	while read pathto posix user group
1135	do	do
1136	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
1137
1138	[[ ${VERBOSE} = on ]] && echo -e "\t<<< CHAR: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< CHAR: ${MROOT}${pathto}"
1139	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
1140	done < ${MROOT}${INSTALLDB}/${pfull}/.char	done < ${MROOT}${INSTALLDB}/${pfull}/.char
1141
#	Line 891  remove_characterdevices()	Line 1145  remove_characterdevices()
1145
1146
1147	###################################################	###################################################
1148		# function remove_fifos                           #
1149		# remove_fifos $PKGNAME                     #
1150		###################################################
1151		remove_fifos()
1152		{
1153		local pathto
1154		local posix
1155		local user
1156		local group
1157		local IFS
1158		local pcat
1159		local pname
1160		local pver
1161		local pbuild
1162		local i
1163		local pfull
1164
1165		IFS=$'\n'
1166
1167		# very basic getops
1168		for i in $*
1169		do
1170		case $1 in
1171		--pcat|-c) shift; pcat="$1" ;;
1172		--pname|-n) shift; pname="$1" ;;
1173		--pver|-v) shift; pver="$1" ;;
1174		--pbuild|-b) shift; pbuild="$1" ;;
1175		esac
1176		shift
1177		done
1178
1179		# sanity checks; abort if not given
1180		[ -z "${pcat}" ] && die "remove_fifos() \$pcat not given."
1181		[ -z "${pname}" ] && die "remove_fifos() \$pname not given."
1182		[ -z "${pver}" ] && die "remove_fifos() \$pver not given."
1183		[ -z "${pbuild}" ] && die "remove_fifos() \$pbuild not given."
1184		pfull="${pcat}/${pname}-${pver}-${pbuild}"
1185
1186		# check needed global vars
1187		[ -z "${BUILDDIR}" ] && die "remove_fifos() \$BUILDDIR not set."
1188
1189		# make it optional atm !!
1190		#[ ! -f ${MROOT}${INSTALLDB}/${pfull}/.fifo ] && die "remove_fifos() .fifo not found"
1191		[ ! -f ${MROOT}${INSTALLDB}/${pfull}/.fifo ] && return
1192
1193		# sets fieldseperator to "§" instead of " "
1194		IFS=§
1195
1196		while read pathto posix user group
1197		do
1198		[ -z "${pathto}" ] && continue
1199
1200		mqueryfeature "verbose" && echo -e "\t<<< FIFO: ${MROOT}${pathto}"
1201		rm "${MROOT}${pathto}"
1202		done < ${MROOT}${INSTALLDB}/${pfull}/.fifo
1203
1204		# very important: unsetting the '§' fieldseperator
1205		IFS=$'\n'
1206		}
1207
1208
1209		###################################################
1210	# function remove_direcories                      #	# function remove_direcories                      #
1211	# remove_direcories $PKGNAME                #	# remove_direcories $PKGNAME                #
1212	###################################################	###################################################
#	Line 921  remove_directories()	Line 1237  remove_directories()
1237	done	done
1238
1239	# sanity checks; abort if not given	# sanity checks; abort if not given
1240	[ -z "${pcat}" ] && die "remove_symlinks() \$pcat not given."	[ -z "${pcat}" ] && die "remove_directories() \$pcat not given."
1241	[ -z "${pname}" ] && die "remove_symlinks() \$pname not given."	[ -z "${pname}" ] && die "remove_directories() \$pname not given."
1242	[ -z "${pver}" ] && die "remove_symlinks() \$pver not given."	[ -z "${pver}" ] && die "remove_directories() \$pver not given."
1243	[ -z "${pbuild}" ] && die "remove_symlinks() \$pbuild not given."	[ -z "${pbuild}" ] && die "remove_directories() \$pbuild not given."
1244	pfull="${pcat}/${pname}-${pver}-${pbuild}"	pfull="${pcat}/${pname}-${pver}-${pbuild}"
1245
1246	# check needed global vars	# check needed global vars
#	Line 932  remove_directories()	Line 1248  remove_directories()
1248
1249	[ ! -f ${MROOT}${INSTALLDB}/${pfull}/.char ] && die "remove_directories() .dirs not found"	[ ! -f ${MROOT}${INSTALLDB}/${pfull}/.char ] && die "remove_directories() .dirs not found"
1250
	# uninstall of dirs ## added small hack to fix dirs
	# must be reverse -> smage2 doesn't sort them
	# -> using tac
1251	# sets fieldseperator to "§" instead of " "	# sets fieldseperator to "§" instead of " "
1252	IFS=§	IFS=§
1253
1254	while read pathto posix	# reversed order is mandatory !
1255		tac ${MROOT}${INSTALLDB}/${pfull}/.dirs | while read pathto posix
1256	do	do
1257	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
1258
1259	if [ ! -d "${MROOT}${pathto}" ]	if [ ! -d "${MROOT}${pathto}" ]
1260	then	then
1261	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1262	echo -e "${COLRED}! exist${COLDEFAULT} === DIR:  ${MROOT}${pathto}"	echo -e "${COLRED}! exist${COLDEFAULT} === DIR:  ${MROOT}${pathto}"
1263	continue	continue
1264	fi	fi
#	Line 953  remove_directories()	Line 1266  remove_directories()
1266	# exclude .keep directories	# exclude .keep directories
1267	if [ -f "${MROOT}${pathto}/.keep" ]	if [ -f "${MROOT}${pathto}/.keep" ]
1268	then	then
1269	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1270	echo -e "${COLRED}  .keep${COLDEFAULT} === DIR:  ${MROOT}${pathto}"	echo -e "${COLRED}! .keep${COLDEFAULT} === DIR:  ${MROOT}${pathto}"
1271	continue	continue
1272	fi	fi
1273
#	Line 966  remove_directories()	Line 1279  remove_directories()
1279
1280	if rmdir "${MROOT}${pathto}" &> /dev/null	if rmdir "${MROOT}${pathto}" &> /dev/null
1281	then	then
1282	[[ ${VERBOSE} = on ]] && echo -e "\t<<< DIR:  ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< DIR:  ${MROOT}${pathto}"
1283	else	else
1284	[[ ${VERBOSE} = on ]] && \	mqueryfeature "verbose" && \
1285	echo -e "${COLRED}! empty${COLDEFAULT} === DIR:  ${MROOT}${pathto}"	echo -e "${COLRED}! empty${COLDEFAULT} === DIR:  ${MROOT}${pathto}"
1286	fi	fi
1287	done < ${MROOT}${INSTALLDB}/${pfull}/.dirs	done
1288
1289	# very important: unsetting the '§' fieldseperator	# very important: unsetting the '§' fieldseperator
1290	IFS=$'\n'	IFS=$'\n'
#	Line 981  remove_directories()	Line 1294  remove_directories()
1294	###################################################	###################################################
1295	# function build_douninstall                      #	# function build_douninstall                      #
1296	# build_douninstall $PKGNAME                #	# build_douninstall $PKGNAME                #
1297	# NOTE: this is an wrapper do remove packages     #	# NOTE: this is an wrapper to remove packages     #
1298	###################################################	###################################################
1299	build_douninstall()	build_douninstall()
1300	{	{
#	Line 1015  build_douninstall()	Line 1328  build_douninstall()
1328	# !! we use § as field seperator !!	# !! we use § as field seperator !!
1329	# doing so prevent us to get errors by filenames with spaces	# doing so prevent us to get errors by filenames with spaces
1330
1331	for i in symlinks files blockdevices characterdevices directories	for i in symlinks files blockdevices characterdevices directories fifos
1332	do	do
1333	remove_${i} \	remove_${i} \
1334	--pcat "${pcat}" \	--pcat "${pcat}" \
#	Line 1026  build_douninstall()	Line 1339  build_douninstall()
1339	done	done
1340	}	}
1341
1342	# fetch_packages /path/to/mage/file1 /path/to/mage/file2	# convertmirrors [uri]
1343	fetch_packages()	convertmirrors()
1344	{	{
1345	local list="$@"	local uri="$1"
1346	local pkg	local scheme
1347	local mirr	local mirror
1348	local magefile	local mirrors
1349	local md5file	local addon
1350	local opt	local real_uri
1351		local output
1352
1353		# needs
1354		[[ -z ${MIRRORS} ]] && die "convertmirrors(): no mirrors defined!"
1355		[[ -z ${SOURCEFORGE_MIRRORS} ]] && die "convertmirrors(): no sourceforge mirrors defined!"
1356		[[ -z ${GNU_MIRRORS} ]] && die "convertmirrors(): no gnu mirrors defined!"
1357		[[ -z ${GNOME_MIRRORS} ]] && die "convertmirrors(): no gnome mirrors defined!"
1358		[[ -z ${KDE_MIRRORS} ]] && die "convertmirrors(): no kde mirrors defined!"
1359
1360		# check known uri schemes
1361		case ${uri} in
1362		http://*|https://*|ftp://*|ftps://*) mirrors="" ;;
1363		mirror://*) mirrors="${MIRRORS}"; scheme="mirror://"; addon="/sources" ;;
1364		package://*) mirrors="${MIRRORS}"; scheme="package://"; addon="/${PACKAGES_SERVER_PATH}" ;;
1365		gnu://*) mirrors="${GNU_MIRRORS}"; scheme="gnu://" ;;
1366		sourceforge://*) mirrors="${SOURCEFORGE_MIRRORS}"; scheme="sourceforge://" ;;
1367		gnome://*) mirrors="${GNOME_MIRRORS}"; scheme="gnome://" ;;
1368		kde://*) mirrors="${KDE_MIRRORS}"; scheme="kde://" ;;
1369		*) die "convertmirror(): unsupported uri scheme in '${uri}'!" ;;
1370		esac
1371
1372		if [[ ! -z ${mirrors} ]]
1373		then
1374		for mirror in ${mirrors}
1375		do
1376		# add a whitespace to the output
1377		[[ -z ${output} ]] || output+=" "
1378		output+="${mirror}${addon}/${uri/${scheme}/}"
1379		done
1380		else
1381		output="${uri}"
1382		fi
1383
1384		echo "${output}"
1385		}
1386
1387		mdownload()
1388		{
1389		local i
1390		local uri
1391		local real_uris
1392		local mirror
1393		local outputfile
1394		local outputdir
1395		local retval
1396		local wget_opts
1397
1398		# very basic getops
1399		for i in $*
1400		do
1401		case $1 in
1402		--uri|-u) shift; uri="$1" ;;
1403		--dir|-d) shift; outputdir="$1" ;;
1404		esac
1405		shift
1406		done
1407
1408		# sanity checks; abort if not given
1409		[[ -z ${uri} ]] && die "mdownload(): no uri given!"
1410		[[ -z ${outputdir} ]] && die "mdownload(): no dir given!"
1411
1412		# convert mirrored uris to the real ones
1413		real_uris="$(convertmirrors ${uri})"
1414
1415		# verbose or not
1416		mqueryfeature "!verbose" && wget_opts+=" --quiet"
1417
1418		# filter wget options if busybox was found
1419		wget_opts+=" $(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1420
1421		# create outputdir
1422		[[ ! -d ${outputdir} ]] && install -d "${outputdir}"
1423
1424		for mirror in ${real_uris}
1425		do
1426		# get the name of the output file
1427		outputfile="${mirror##*/}"
1428
1429		wget ${wget_opts} --output-document="${outputdir}/${outputfile}" "${mirror}"
1430		retval="$?"
1431		if [[ ${retval} = 0 ]]
1432		then
1433		break
1434		else
1435		continue
1436		fi
1437		done
1438
1439		# return wget retval
1440		return "${retval}"
1441		}
1442
1443		# fetch_packages /path/to/mage/file1 /path/to/mage/file2
1444		fetch_packages()
1445		{
1446		local i
1447		local list="$@"
1448		local pkgname
1449		local pkgfile
1450		local pcat
1451		local pname
1452		local mirr
1453		local magefile
1454		local md5file
1455		local opt
1456	local count_current	local count_current
1457	local count_total	local count_total
1458		local wget_opts
1459		local fetching
1460
1461	[ -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}."
1462
1463		# filter wget command if busybox was found
1464		wget_opts="$(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1465
1466	# get count of total packages	# get count of total packages
1467	declare -i count_current=0	declare -i count_current=0
#	Line 1048  fetch_packages()	Line 1471  fetch_packages()
1471
1472	for magefile in ${list}	for magefile in ${list}
1473	do	do
1474	pkg="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
1475		pkgfile="${pkgname}.${PKGSUFFIX}"
1476	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
1477
1478		pcat=$(magename2pcat ${magefile})
1479		pname=$(magename2pname ${magefile})
1480		md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
1481
1482	(( count_current++ ))	(( count_current++ ))
1483	xtitle "[ (${count_current}/${count_total}) Fetching ${pkg} ]"	xtitle "[ (${count_current}/${count_total}) Fetching ${pkgfile} ]"
1484
1485	# abort on virtual pkg	# abort on virtual pkg
1486	if [[ ${pkgtype} = virtual ]]	if [[ ${pkgtype} = virtual ]]
1487	then	then
1488	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
1489	echo " !fetch virtual (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "	echo " !fetch virtual (${count_current}/${count_total}): ${pkgname} ... "
1490	continue	continue
1491	fi	fi
1492
#	Line 1066  fetch_packages()	Line 1494  fetch_packages()
1494	if [[ ${pkgtype} = sources ]]	if [[ ${pkgtype} = sources ]]
1495	then	then
1496	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
1497	echo " !fetch sources (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "	echo " !fetch sources (${count_current}/${count_total}): ${pkgname} ... "
1498	continue	continue
1499	fi	fi
1500
1501	# abort if already exist	# check if FETCHING is required
1502	if [ -f ${PKGDIR}/${pkg} ]	if [ ! -f "${md5file}" ]
1503	then	then
1504	echo -ne " ${COLBLUE}***${COLDEFAULT}"	fetching=true
1505	echo " fetch complete (${count_current}/${count_total}): ${pkg} ... "	else
1506	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 ]]
1507	then	then
1508	break	# md5's ok, no fetching required
1509		fetching=false
1510	else	else
1511	continue	fetching=true
1512	fi	fi
1513	done	fi
1514
1515	if [ ! -f ${PKGDIR}/${pkg} ]	if [[ ${fetching} = false ]]
1516	then	then
1517	die "Could not download ${pkg}"	echo -ne " ${COLBLUE}***${COLDEFAULT}"
1518		echo " fetch complete (${count_current}/${count_total}): ${pkgfile} ... "
1519		continue
1520		else
1521		echo -ne " ${COLBLUE}***${COLDEFAULT}"
1522		echo -e " fetching (${count_current}/${count_total}): ${pkgfile} ... "
1523		mdownload --uri "package://${pkgfile}" --dir "${PKGDIR}" || die "Could not download ${pkgfile}"
1524		fi
1525
1526		# sanity check, not really needed but to be sure
1527		if [ ! -f ${PKGDIR}/${pkgfile} ]
1528		then
1529		die "Package '${pkgfile}' after download not found in '${PKGDIR}'"
1530	fi	fi
1531	done	done
1532
#	Line 1113  syncmage()	Line 1538  syncmage()
1538	{	{
1539	if [ -z "${RSYNC}" ]	if [ -z "${RSYNC}" ]
1540	then	then
1541	die "You have no rsync-mirrors defined. Please edit your /etc/mage.rc."	die "You have no rsync-mirrors defined. Please edit your ${MAGERC}."
1542	fi	fi
1543
1544	local i	local i
1545	for i in ${RSYNC}	for i in ${RSYNC}
1546	do	do
1547	rsync \	rsync ${RSYNC_FETCH_OPTIONS} ${i} ${MAGEDIR}
	--recursive \
	--links \
	--perms \
	--times \
	--devices \
	--timeout=600 \
	--verbose \
	--compress \
	--progress \
	--stats \
	--delete \
	--delete-after \
	${i} ${MAGEDIR}
1548	if [[ $? = 0 ]]	if [[ $? = 0 ]]
1549	then	then
1550	break	break
#	Line 1142  syncmage()	Line 1554  syncmage()
1554	done	done
1555
1556	# clean up backup files (foo~)	# clean up backup files (foo~)
1557	find ${MAGEDIR} -name *~ -exec rm '{}' ';'	find ${MAGEDIR} -name \*~ -exec rm '{}' ';'
1558
1559	# check if an newer mage version is available	# check if a newer mage version is available
1560	is_newer_mage_version_available	is_newer_mage_version_available
1561	}	}
1562
1563	cleanpkg()	syncmage_tarball()
1564	{	{
1565	if [ -d "${PKGDIR}" ]	local latest_tarball
1566	then	local latest_md5
1567	echo -n "Removing downloaded packages... "	local temp="$(mktemp -d)"
1568	rm -rf ${PKGDIR}/*	local mirr mymirr
1569	echo "done."	local opt
1570	fi	local tar_opts
1571	}	local wget_opts
1572
1573	xtitle()	# try to get the md5 marked as latest on the server
1574	{	latest_md5="mage-latest.md5"
	if [[ ${TERM} = xterm ]]
	then
	echo -ne "\033]0;Mage: $1\007"
	fi
	return 0
	}
1575
1576		# try to get the tarball marked as latest on the server
1577		latest_tarball="mage-latest.tar.bz2"
1578
1579	xtitleclean()	# filter wget command if busybox was found
1580	{	wget_opts="$(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1581	if [[ ${TERM} = xterm ]]
1582		for mirr in ${MIRRORS}
1583		do
1584		# path without distribution
1585		# (only for stable|testing|unstable and not DISTROTAG)
1586		case ${mirr##*/} in
1587		stable|testing|unstable) mymirr="${mirr%/*}";;
1588		*) mymirr="${mirr}";;
1589		esac
1590
1591		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1592		echo "fetching latest md5 from ${mymirr} ..."
1593		mqueryfeature "!verbose" && opt="--quiet"
1594		wget \
1595		${wget_opts} \
1596		--directory-prefix=${temp} \
1597		${opt} ${mymirr}/rsync/tarballs/${latest_md5}
1598
1599		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1600		echo "fetching latest tarball from ${mymirr} ..."
1601		wget \
1602		${wget_opts} \
1603		--directory-prefix=${temp} \
1604		${opt} ${mymirr}/rsync/tarballs/${latest_tarball}
1605		if [[ $? = 0 ]]
1606		then
1607		break
1608		else
1609		continue
1610		fi
1611		done
1612
1613		if [[ -f ${temp}/${latest_tarball} ]]
1614	then	then
1615	echo -ne "\033]0;\007"	# check md5
1616		if [[ ! -f ${temp}/${latest_md5} ]]
1617		then
1618		die "md5 is missing ... aborting"
1619		else
1620		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1621		echo -n "checking md5sum... "
1622		mchecksum --rundir "${temp}" --file "${latest_md5}" --method md5 || die "md5 for ${latest_tarball} failed"
1623		fi
1624
1625		if [[ -d ${MAGEDIR} ]]
1626		then
1627		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1628		echo "cleaning old mage-tree ${MAGEDIR}..."
1629		# honor mountpoints and empty dirs
1630		if mountpoint -q ${MAGEDIR}
1631		then
1632		if ! mcheckemptydir ${MAGEDIR}
1633		then
1634		find ${MAGEDIR} -mindepth 1 -maxdepth 1 | xargs --no-run-if-empty rm -r
1635		fi
1636		else
1637		rm -rf ${MAGEDIR}
1638		fi
1639		fi
1640
1641		if need_busybox_support tar
1642		then
1643		tar_opts="xjf"
1644		else
1645		tar_opts="xjmf"
1646		fi
1647
1648		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1649		echo "updating mage-tree from tarball ..."
1650		# unpack in dirname of MAGEDIR, as the tarball has already the mage
1651		tar ${tar_opts} ${temp}/${latest_tarball} -C ${MAGEDIR%/*} || die "Unpacking tarball"
1652
1653		if [[ -d ${temp} ]]
1654		then
1655		echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1656		echo "cleaning temp-files ..."
1657		rm -rf ${temp}
1658		fi
1659
1660		# check if a newer mage version is available
1661		is_newer_mage_version_available
1662		else
1663		die "Could not fetch the latest tarball ... aborting"
1664	fi	fi
	return 0
1665	}	}
1666
1667		cleanpkg()
	# cuts full pathnames or versioniezed names down to basename
	choppkgname()
1668	{	{
1669	#we want this only if full name was used	if [ -d "${PKGDIR}" ]
	if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]
1670	then	then
1671	#cuts ARCH and PBUILD	echo -n "Removing downloaded packages... "
1672	#ARCH comes from /etc/mage.rc	rm -rf ${PKGDIR}/*
1673	MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}-r*.::g")	echo "done."
	#cuts version number
	MAGENAME=$(basename ${MAGENAME%-*} .mage)
1674	fi	fi
1675	}	}
1676
1677		# unused?
1678		#
1679		# # cuts full pathnames or versionized names down to basename
1680		# choppkgname()
1681		# {
1682		# #we want this only if full name was used
1683		# if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]
1684		# then
1685		# #cuts ARCH and PBUILD
1686		# #ARCH comes from ${MAGERC}
1687		# MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}$(print_distrotag)-r*.::g")
1688		#
1689		# #cuts version number
1690		# MAGENAME=$(basename ${MAGENAME%-*} .mage)
1691		# fi
1692		# }
1693
1694
1695	# get_categorie $PNAME, returns CATEGORIE	# get_categorie $PNAME, returns CATEGORIE
1696	# $1=pname	# $1=pname
1697	# ret 0=ok, 1=not_found	# ret 0=ok, 1=not_found
#	Line 1214  pname2pcat()	Line 1713  pname2pcat()
1713	echo "${categorie}"	echo "${categorie}"
1714	}	}
1715
	# check_stable_package /path/to/foo.mage
	# returns 0=stable 1=unstable
	check_stable_package()
	{
	local STATE
	STATE="$(get_value_from_magefile STATE "$1")"
	# state testing
	if [[ ${USE_TESTING} = true ]]
	then
	case ${STATE} in
	testing|stable) return 0 ;;
	*) return 1 ;;
	esac
	fi
	# state unstable
	if [[ ${USE_UNSTABLE} = true ]]
	then
	case ${STATE} in
	unstable|testing|stable) return 0 ;;
	*) return 1 ;;
	esac
	fi
	# no use_state given = stable
	case ${STATE} in
	stable) return 0 ;;
	*) return 1 ;;
	esac
	}
1716	# get_highest_magefile ${PCAT} ${PNAME}	# get_highest_magefile ${PCAT} ${PNAME}
1717	# fake at moment returns only stable pkgs (must set to be one)	# returns $HIGHEST_MAGEFILE
	# return $HIGHEST_MAGEFILE
1718	get_highest_magefile()	get_highest_magefile()
1719	{	{
1720	local HIGHEST_MAGEFILE	local pcat="$1"
1721	local PCAT="$1"	local pname="$2"
	local PNAME="$2"
	local magefile
1722
1723	for magefile in $(ls --format=single-column -v ${MAGEDIR}/${PCAT}/${PNAME}/*)	${MLIBDIR}/highest_magefile ${MAGEDIR}/${pcat}/${pname}
	do
	# we exclude subdirs (for stuff like a md5sum dir)
	[ -d ${magefile} ] && continue
	if check_stable_package ${magefile}
	then
	HIGHEST_MAGEFILE=${magefile}
	#for debug only
	[[ ${MAGEDEBUG} = on ]] && echo "HIGHEST_MAGEFILE=${HIGHEST_MAGEFILE}"
	fi
	done
	# 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
	echo "${HIGHEST_MAGEFILE}"
1724	return 0	return 0
1725	}	}
1726
1727	###################################################	###################################################
1728	# function is_config_protected                    #	# function is_config_protected                    #
1729	#       is_config_protected /path/to/file         #	#       is_config_protected /path/to/file         #
#	Line 1304  get_highest_magefile()	Line 1733  get_highest_magefile()
1733	#        1 - error                                #	#        1 - error                                #
1734	#        2 - protected                            #	#        2 - protected                            #
1735	#        3 - protected but masked                 #	#        3 - protected but masked                 #
1736		#        4 - protected but ignored                #
1737	#                                                 #	#                                                 #
1738	###################################################	###################################################
1739	is_config_protected()	is_config_protected()
#	Line 1312  is_config_protected()	Line 1742  is_config_protected()
1742	local TEST	local TEST
1743	local PROTECTED	local PROTECTED
1744	local IFS	local IFS
1745		local i
1746		local x
1747
1748	EXPFILE="${MROOT}$1"	EXPFILE="${MROOT}$1"
1749
1750	# file does not exist; it can be written	# file does not exist; it can be written
1751	[ ! -e ${EXPFILE} ] && return 0	[[ ! -e ${EXPFILE} ]] && return 0
1752
1753	# to be safe; it may be '§'	# to be safe; it may be '§'
1754	IFS=' '	IFS=' '
1755
1756	# check ob in config protect	# check if config protected
1757	for i in ${CONFIG_PROTECT}	for i in ${CONFIG_PROTECT}
1758	do	do
1759	# ersetzen von $i nur wenn am anfang der variable	# only replace $i in the beginning of the variable
1760	TEST="${EXPFILE/#${MROOT}${i}/Protected}"	TEST="${EXPFILE/#${MROOT}${i}/Protected}"
1761	if [ "${TEST}" != "${EXPFILE}" ]	if [[ ${TEST} != ${EXPFILE} ]]
1762	then	then
1763	# setzen das es protected ist	# file is config proteced
1764	PROTECTED=TRUE	PROTECTED=TRUE
1765
1766	# check ob nicht doch maskiert	# check if not masked
1767	for x in ${CONFIG_PROTECT_MASK}	for x in ${CONFIG_PROTECT_MASK}
1768	do	do
1769	TEST="${EXPFILE/#${MROOT}${x}/Protect_Masked}"	TEST="${EXPFILE/#${MROOT}${x}/Protect_Masked}"
1770	if [ "${TEST}" != "${EXPFILE}" ]	if [[ ${TEST} != ${EXPFILE} ]]
1771	then	then
1772	PROTECTED=MASKED	PROTECTED=MASKED
1773	fi	fi
1774	done	done
1775
1776		# check if not ignored
1777		for x in ${CONFIG_PROTECT_IGNORE}
1778		do
1779		TEST="${EXPFILE/#${MROOT}${x}/Protect_Ignored}"
1780		if [[ ${TEST} != ${EXPFILE} ]]
1781		then
1782		PROTECTED=IGNORED
1783		fi
1784		done
1785	fi	fi
1786	done	done
1787
#	Line 1354  is_config_protected()	Line 1796  is_config_protected()
1796	#echo "I'm protected, but masked - delete me"	#echo "I'm protected, but masked - delete me"
1797	return 3	return 3
1798	;;	;;
1799		IGNORED)
1800		#echo "I'm protected, but ignored - keep me, del update"
1801		return 4
1802		;;
1803	*)	*)
1804	#echo "delete me"	#echo "delete me"
1805	return 0	return 0
#	Line 1371  is_config_protected()	Line 1817  is_config_protected()
1817	###################################################	###################################################
1818	count_protected_files()	count_protected_files()
1819	{	{
1820	${MLIBDIR}/writeprotected "$1"	local file="$1"
1821		local dirname="${file%/*}"
1822		local filename="${file##*/}"
1823		local count
1824		local output
1825		local oldprotected
1826		local i
1827		local x
1828
1829		# hack; do not honor a global set IFS like '§'
1830		local IFS
1831
1832		count=0
1833
1834		# check if there are already protected files
1835		for oldprotected in $(find ${dirname} -iname "._cfg????_${filename}" |
1836		sed -e "s:\(^.*/\)\(._cfg*_\)\(/.*$\):\1\2\3\%\2\%\3:" |
1837		sort -t'%' -k3 -k2 | cut -f1 -d'%')
1838		do
1839		count="$(echo ${oldprotected} | sed 's:.*\/._cfg\(.*\)_.*:\1:')"
1840		done
1841
1842		# convert 0001 -> 1; 0120 -> 120 etc
1843		# use bash internal base functions to this task
1844		x="$((10#${count}))"
1845		for (( i=0; i<x; i++ ))
1846		do
1847		if [[ ${count:${i}:1} != 0 ]]
1848		then
1849		count="${count:${i}}"
1850		break
1851		fi
1852		done
1853
1854		count="$(( ${count}+1 ))"
1855
1856		# fill output up with zeros
1857		for (( i=${#count}; i < 4; i++ )); do output="${output}0"; done
1858		output="${output}${count}"
1859
1860		echo "${output}"
1861	}	}
1862
1863	# call with	# call with
#	Line 1388  get_uninstall_candidates()	Line 1874  get_uninstall_candidates()
1874	local list	local list
1875	local pcatdir	local pcatdir
1876	local protected	local protected
1877		local i
1878
1879	# very basic getops	# very basic getops
1880	for i in $*	for i in $*
#	Line 1400  get_uninstall_candidates()	Line 1887  get_uninstall_candidates()
1887	shift	shift
1888	done	done
1889
1890	# sanity checks; abort if not given	# it's not good to complain here about empty pnames; better to continue later anyway
1891	[ -z "${search_pname}" ] && die "get_uninstall_candidates() \$search_pname not given."	# # sanity checks; abort if not given
1892		# [ -z "${search_pname}" ] && die "get_uninstall_candidates() \$search_pname not given."
1893
1894
1895	# check needed global vars	# check needed global vars
1896	[ -z "${INSTALLDB}" ] && die "get_uninstall_candidates() \$INSTALLDB not set."	[ -z "${INSTALLDB}" ] && die "get_uninstall_candidates() \$INSTALLDB not set."
1897
1898	# set pcatdir to '*' if empty	# set pcatdir to '*' if empty
1899	[ -z "${pcatdir}" ] && pcatdir=*	[ -z "${pcatdir}" ] && pcatdir='*'
1900
1901	for pkg in ${MROOT}${INSTALLDB}/${pcatdir}/*	for pkg in ${MROOT}${INSTALLDB}/${pcatdir}/*
1902	do	do
#	Line 1493  virtuals_add()	Line 1981  virtuals_add()
1981	local oldline	local oldline
1982	local line i	local line i
1983	local installed_file	local installed_file
1984		local OLDIFS
1985
1986	if virtuals_read ${virtualname}	if virtuals_read ${virtualname}
1987	then	then
1988	# make shure ${PKG_NAME} is *not* in ${VIRTUAL_NAME} already	# make sure ${PKG_NAME} is *not* in ${VIRTUAL_NAME} already
1989	for i in $(virtuals_read ${virtualname} showpkgs)	for i in $(virtuals_read ${virtualname} showpkgs)
1990	do	do
1991	if [[ ${i} = ${pkgname} ]]	if [[ ${i} = ${pkgname} ]]
#	Line 1515  virtuals_add()	Line 2004  virtuals_add()
2004	# make a backup	# make a backup
2005	mv ${MROOT}${VIRTUALDB_FILE} ${MROOT}${VIRTUALDB_FILE}.old	mv ${MROOT}${VIRTUALDB_FILE} ${MROOT}${VIRTUALDB_FILE}.old
2006
2007		OLDIFS="${IFS}"
2008	IFS=$'\n'	IFS=$'\n'
2009	for line in $(< ${MROOT}${VIRTUALDB_FILE}.old)	for line in $(< ${MROOT}${VIRTUALDB_FILE}.old)
2010	do	do
#	Line 1526  virtuals_add()	Line 2016  virtuals_add()
2016	echo "${line}" >> ${MROOT}${VIRTUALDB_FILE}	echo "${line}" >> ${MROOT}${VIRTUALDB_FILE}
2017	fi	fi
2018	done	done
2019		# unset IFS
2020	#unset IFS	IFS="${OLDIFS}"
2021	else	else
2022	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} >>> ${COLDEFAULT}"
2023	echo "register ${pkgname} as ${virtualname} ..."	echo "register ${pkgname} as ${virtualname} ..."
2024	echo "${virtualname} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}	echo "${virtualname} ${pkgname}" >> ${MROOT}${VIRTUALDB_FILE}
2025	fi	fi
#	Line 1539  virtuals_add()	Line 2029  virtuals_add()
2029
2030	#deletes pakages from virtual database	#deletes pakages from virtual database
2031	#$1 virtualname; $2 pkgname	#$1 virtualname; $2 pkgname
2032	virtuals_del() {	virtuals_del()
2033		{
2034
2035	local VIRTUAL_NAME PKG_NAME OLD_LINE METHOD line i x PKG_INSTALLED	local virtualname="$1"
2036		local pkgname="$2"
2037	VIRTUAL_NAME=$1	local oldline
2038	PKG_NAME=$2	local method
2039		local line i x
2040	#first check if exists	local pkg_installed
2041	if virtuals_read ${VIRTUAL_NAME}	local OLDIFS
2042
2043		# first check if exists
2044		if virtuals_read ${virtualname}
2045	then	then
2046	#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}
2047	declare -i x=0	declare -i x=0
2048	for i in $(virtuals_read ${VIRTUAL_NAME} showpkgs)	for i in $(virtuals_read ${virtualname} showpkgs)
2049	do	do
2050	if [ "${i}" == "${PKG_NAME}" ]	if [[ ${i} = ${pkgname} ]]
2051	then	then
2052	PKG_INSTALLED=true	pkg_installed=true
2053	fi	fi
2054	((x++))	((x++))
2055	done	done
2056
2057	#abort if not installed	# abort if not installed
2058	if [ "${PKG_INSTALLED}" != "true" ]	if [[ ${pkg_installed} != true ]]
2059	then	then
2060	echo "!!!! ${PKG_NAME} does not exists in ${VIRTUAL_NAME}."	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2061		echo "${pkgname} does not exists in ${virtualname}."
2062	return 0	return 0
2063	fi	fi
2064
2065	if [ ${x} -ge 2 ]	if [ ${x} -ge 2 ]
2066	then	then
2067	METHOD=update	method=update
2068	else	else
2069	METHOD=delall	method=delall
2070	fi	fi
2071
2072	#get the complete line	# get the complete line
2073	OLD_LINE="$(virtuals_read ${VIRTUAL_NAME} showline)"	oldline="$(virtuals_read ${virtualname} showline)"
2074
2075	#make a backup	# make a backup of the db
2076	mv ${VIRTUALDB_FILE} ${VIRTUALDB_FILE}.old	mv ${VIRTUALDB_FILE} ${VIRTUALDB_FILE}.old
2077
2078	#parse virtualdb	# parse virtualdb
2079		OLDIFS="${IFS}"
2080	IFS=$'\n'	IFS=$'\n'
2081	for line in $(< ${VIRTUALDB_FILE}.old)	for line in $(< ${VIRTUALDB_FILE}.old)
2082	do	do
2083	if [ "${line}" == "${OLD_LINE}" ]	if [[ ${line} = ${oldline} ]]
2084	then	then
2085	#delall or update?	#delall or update?
2086	case ${METHOD} in	case ${method} in
2087	update)	update)
2088	echo "<<<< Unlinking ${PKG_NAME} from ${VIRTUAL_NAME} in virtual database ..."	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2089	#del PKG_NAME from line	echo "Unlinking ${pkgname} from ${virtualname} in virtual database ..."
2090	echo "${line/ ${PKG_NAME}/}" >> ${VIRTUALDB_FILE}	# del PKG_NAME from line
2091		echo "${line/ ${pkgname}/}" >> ${VIRTUALDB_FILE}
2092	;;	;;
2093	delall)	delall)
2094	echo "<<<< Deleting ${VIRTUAL_NAME} in virtual database ..."	echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
2095	#continue; do not write anything	echo "Deleting ${virtualname} in virtual database ..."
2096		# continue; do not write anything
2097	continue	continue
2098	;;	;;
2099	esac	esac
#	Line 1603  virtuals_del() {	Line 2101  virtuals_del() {
2101	echo "${line}" >> ${VIRTUALDB_FILE}	echo "${line}" >> ${VIRTUALDB_FILE}
2102	fi	fi
2103	done	done
2104	unset IFS	# unset IFS
2105		IFS="${OLDIFS}"
2106	else	else
2107	echo "!!!! ${VIRTUAL_NAME} does not exists in virtual database."	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2108		echo "${virtualname} does not exists in virtual database."
2109	fi	fi
2110	}	}
2111
#	Line 1637  minclude()	Line 2137  minclude()
2137	{	{
2138	local i	local i
2139
2140	if [ -n "$@" ]	if [[ -n $* ]]
2141	then	then
2142	for i in $@	for i in $*
2143	do	do
2144	[[ ${MAGEDEBUG} = on ]] && \	mqueryfeature "debug" && \
2145	echo "--- Including ${MAGEDIR}/include/${i}.minc"	echo "--- Including ${MAGEDIR}/include/${i}.minc"
2146	source ${MAGEDIR}/include/${i}.minc	source ${MAGEDIR}/include/${i}.minc
2147	done	done
2148	[[ ${MAGEDEBUG} = on ]] && echo	mqueryfeature "debug" && echo
2149	fi	fi
2150	}	}
2151
#	Line 1653  sminclude()	Line 2153  sminclude()
2153	{	{
2154	local i	local i
2155
2156	if [ -n "$@" ]	if [[ -n $* ]]
2157	then	then
2158	for i in $@	for i in $*
2159	do	do
2160	echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"	[[ ${SILENT} = 1 ]] || echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
2161	source ${SMAGESCRIPTSDIR}/include/${i}.sminc	source ${SMAGESCRIPTSDIR}/include/${i}.sminc
2162	done	done
2163	echo	[[ ${SILENT} = 1 ]] || echo
2164	fi	fi
2165	}	}
2166
#	Line 1670  is_newer_mage_version_available()	Line 2170  is_newer_mage_version_available()
2170	local newest_mage	local newest_mage
2171	local installed_mage	local installed_mage
2172
2173	newest_mage="$( CATEGORIE=app-mage MAGENAME=mage get_highest_magefile;echo $(basename ${MAGEFILE} .mage) )"	newest_mage="$(basename $(get_highest_magefile app-mage mage) .mage)"
2174	installed_mage="$(magequery -n mage | cut -d' ' -f5)"	installed_mage="$(magequery -n mage | cut -d' ' -f5)"
2175
2176	if [[ ${newest_mage} > ${installed_mage} ]]	if [[ ${newest_mage} > ${installed_mage} ]]
#	Line 1679  is_newer_mage_version_available()	Line 2179  is_newer_mage_version_available()
2179	echo -en ${COLRED}"An update for your packetmanager is available. "${COLDEFAULT}	echo -en ${COLRED}"An update for your packetmanager is available. "${COLDEFAULT}
2180	echo -e ${COLBLUE}"[ ${newest_mage} ]"${COLDEFAULT}	echo -e ${COLBLUE}"[ ${newest_mage} ]"${COLDEFAULT}
2181	echo "It is recommened to install this newer version"	echo "It is recommened to install this newer version"
2182	echo "or your current system installation may brake."	echo "or your current system installation may break."
2183	echo	echo
2184	echo -en "Please update mage by running "	echo -en "Please update mage by running "
2185	echo -e ${COLGREEN}"'mage install mage'"${COLDEFAULT}	echo -e ${COLGREEN}"'mage install mage'"${COLDEFAULT}
#	Line 1687  is_newer_mage_version_available()	Line 2187  is_newer_mage_version_available()
2187	fi	fi
2188	}	}
2189
2190	# returns pname from pkgname	# returns pname from pkgname
2191	# pkgname2pname $PKGNAME	# pkgname2pname $PKGNAME
2192	pkgname2pname()	pkgname2pname()
#	Line 1951  get_value_from_magefile()	Line 2450  get_value_from_magefile()
2450	local magefile="$2"	local magefile="$2"
2451	local value	local value
2452
2453		[[ -z ${var} ]] && return 1
2454		[[ -z ${magefile} ]] && return 1
2455
2456	# local all possible vars of a mage file	# local all possible vars of a mage file
2457	# to prevent bad issues	# to prevent bad issues
2458	local PKGNAME	local PKGNAME
#	Line 1961  get_value_from_magefile()	Line 2463  get_value_from_magefile()
2463	local SDEPEND	local SDEPEND
2464	local PROVIDE	local PROVIDE
2465	local PKGTYPE	local PKGTYPE
2466		local SPLIT_PACKAGE_BASE
2467	local preinstall	local preinstall
2468	local postinstall	local postinstall
2469		local preremove
2470		local postremove
2471
2472	# sanity checks	# sanity checks
2473	[ -f ${magefile} ] && source ${magefile} || \	[ -f ${magefile} ] && source ${magefile} || \
#	Line 1972  get_value_from_magefile()	Line 2477  get_value_from_magefile()
2477	source ${magefile}	source ${magefile}
2478	eval value=\$$(echo ${var})	eval value=\$$(echo ${var})
2479	echo "${value}"	echo "${value}"
2480
2481		# unset these functions
2482		unset -f preinstall
2483		unset -f postinstall
2484		unset -f preremove
2485		unset -f postremove
2486	}	}
2487
2488	mage_install()	mage_install()
#	Line 1988  mage_install()	Line 2499  mage_install()
2499	local PKGTYPE	local PKGTYPE
2500	local preinstall	local preinstall
2501	local postinstall	local postinstall
2502		local preremove
2503		local postremove
2504
2505	local pcat	local pcat
2506	local pname	local pname
#	Line 1997  mage_install()	Line 2510  mage_install()
2510	local count_current	local count_current
2511	local magefile	local magefile
2512	local src_install	local src_install
2513		local i
2514
2515	# very basic getops	# very basic getops
2516	for i in $*	for i in $*
#	Line 2070  mage_install()	Line 2584  mage_install()
2584	echo B:${pbuild}	echo B:${pbuild}
2585	fi	fi
2586
2587	smage2file=${SMAGESCRIPTSDIR}/${pname}/${pname}-${pver}-${pbuild}.smage2	if [[ -n ${SPLIT_PACKAGE_BASE} ]]
2588		then
2589		# basic svn compat
2590		if [[ -d ${SMAGESCRIPTSDIR}/.svn ]]
2591		then
2592		for i in ${SMAGESCRIPTSDIR}/*/${SPLIT_PACKAGE_BASE}/${SPLIT_PACKAGE_BASE}-${pver}-${pbuild}.smage2
2593		do
2594		smage2file="${i}"
2595		done
2596		else
2597		smage2file=${SMAGESCRIPTSDIR}/${SPLIT_PACKAGE_BASE}/${SPLIT_PACKAGE_BASE}-${pver}-${pbuild}.smage2
2598		fi
2599
2600		else
2601		# basic svn compat
2602		if [[ -d ${SMAGESCRIPTSDIR}/.svn ]]
2603		then
2604		for i in ${SMAGESCRIPTSDIR}/*/${pname}/${pname}-${pver}-${pbuild}.smage2
2605		do
2606		smage2file="${i}"
2607		done
2608		else
2609		smage2file=${SMAGESCRIPTSDIR}/${pname}/${pname}-${pver}-${pbuild}.smage2
2610		fi
2611		fi
2612
2613	if [ -f "${smage2file}" ]	if [ -f "${smage2file}" ]
2614	then	then
2615		echo -e " ${COLBLUE}***${COLDEFAULT} building package from source ... "
2616	smage2 ${smage2file} || die "compile failed"	smage2 ${smage2file} || die "compile failed"
2617	else	else
2618	echo	echo
#	Line 2086  mage_install()	Line 2626  mage_install()
2626	if [[ ${PKGTYPE} != virtual ]] && \	if [[ ${PKGTYPE} != virtual ]] && \
2627	[[ ${PKGTYPE} != sources ]]	[[ ${PKGTYPE} != sources ]]
2628	then	then
2629	# show a verbose message on src-install	unpack_package "${magefile}"
2630	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
2631	build_doinstall ${PKGNAME}	build_doinstall ${PKGNAME}
2632	fi	fi
2633
#	Line 2137  mage_install()	Line 2671  mage_install()
2671	then	then
2672	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2673	echo -n "rebuilding environment ... "	echo -n "rebuilding environment ... "
2674	${MLIBDIR}/env-rebuild.sh > /dev/null && \	${MLIBDIR}/env-rebuild > /dev/null && \
2675	echo "done." || echo "failure."	echo "done." || echo "failure."
2676	unset MAGE_ENV_REBUILD	unset MAGE_ENV_REBUILD
2677	fi	fi
#	Line 2149  mage_install()	Line 2683  mage_install()
2683	# echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"	# echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
2684	# echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "	# echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
2685	echo "successfully installed."	echo "successfully installed."
2686
2687		# unset these functions
2688		unset -f preinstall
2689		unset -f postinstall
2690		unset -f preremove
2691		unset -f postremove
2692	}	}
2693
2694	md5sum_packages()	md5sum_packages()
#	Line 2175  md5sum_packages()	Line 2715  md5sum_packages()
2715	pname=$(magename2pname ${magefile})	pname=$(magename2pname ${magefile})
2716	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
2717	md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"	md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
2718	pkgfile="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	pkgfile="${pkgname}.${PKGSUFFIX}"
2719	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
2720
2721	(( count_current++ ))	(( count_current++ ))
#	Line 2185  md5sum_packages()	Line 2725  md5sum_packages()
2725	if [[ ${pkgtype} = virtual ]]	if [[ ${pkgtype} = virtual ]]
2726	then	then
2727	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
2728	echo " !md5sum virtual (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "	echo " !md5sum virtual (${count_current}/${count_total}): ${pkgname} ... "
2729	continue	continue
2730	fi	fi
2731
#	Line 2193  md5sum_packages()	Line 2733  md5sum_packages()
2733	if [[ ${pkgtype} = sources ]]	if [[ ${pkgtype} = sources ]]
2734	then	then
2735	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
2736	echo " !md5sum sources (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "	echo " !md5sum sources (${count_current}/${count_total}): ${pkgname} ... "
2737	continue	continue
2738	fi	fi
2739
#	Line 2201  md5sum_packages()	Line 2741  md5sum_packages()
2741	then	then
2742	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2743	echo -ne "checking md5sum (${count_current}/${count_total}): "	echo -ne "checking md5sum (${count_current}/${count_total}): "
2744	( cd ${PKGDIR}; md5sum --check ${md5file}) || die "md5 for ${pkgfile} failed"	mchecksum --rundir "${PKGDIR}" --file "${md5file}" --method md5 || die "md5 for ${pkgfile} failed"
2745	else	else
2746	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2747	echo -e "!! no md5sum file found for ${pkgfile} :("	echo -e "!! no md5sum file found for ${pkgfile} :("
#	Line 2241  uninstall_packages()	Line 2781  uninstall_packages()
2781	pbuild=$(magename2pbuild ${pkg})	pbuild=$(magename2pbuild ${pkg})
2782	can_pcat="${pcat}"	can_pcat="${pcat}"
2783	can_pname="${pname}"	can_pname="${pname}"
2784
2785	if [ -z "${can_ver_list}" ]	if [ -z "${can_ver_list}" ]
2786	then	then
2787	can_ver_list=" ${pver}-${pbuild}"	can_ver_list=" ${pver}-${pbuild}"
#	Line 2253  uninstall_packages()	Line 2793  uninstall_packages()
2793	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2794	echo "following candidate(s) will be removed:"	echo "following candidate(s) will be removed:"
2795	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2796	echo -ne "\033[1m${can_pcat}/${can_pname}:${COLDEFAULT}"	echo -ne "${COLBOLD}${can_pcat}/${can_pname}:${COLDEFAULT}"
2797	echo -e "${COLRED} ${can_ver_list} ${COLDEFAULT}"	echo -e "${COLRED} ${can_ver_list} ${COLDEFAULT}"
2798	echo	echo
2799	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	if [ ${MAGE_UNINSTALL_TIMEOUT} -gt 0 ]
2800	echo "( Press [CTRL+C] to abort )"	then
2801	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2802	echo -n "Waiting ${MAGE_UNINSTALL_TIMEOUT} seconds ..."	echo "( Press [CTRL+C] to abort )"
2803	for ((i=MAGE_UNINSTALL_TIMEOUT; i >= 0; i--))	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2804	do	echo -n "Waiting ${MAGE_UNINSTALL_TIMEOUT} seconds ..."
2805	echo -ne "${COLRED} ${i}${COLDEFAULT}"	for ((i=MAGE_UNINSTALL_TIMEOUT; i >= 0; i--))
2806	sleep 1	do
2807	done	echo -ne "${COLRED} ${i}${COLDEFAULT}"
2808	echo	sleep 1
2809	echo	done
2810		echo
2811		echo
2812		fi
2813
2814	for pkg in ${list}	for pkg in ${list}
2815	do	do
#	Line 2304  mage_uninstall()	Line 2847  mage_uninstall()
2847	local PKGTYPE	local PKGTYPE
2848	local preinstall	local preinstall
2849	local postinstall	local postinstall
2850		local preremove
2851		local postremove
2852
2853	local pcat	local pcat
2854	local pname	local pname
#	Line 2339  mage_uninstall()	Line 2884  mage_uninstall()
2884	echo -ne "${COLBLUE} <<< ${COLDEFAULT}"	echo -ne "${COLBLUE} <<< ${COLDEFAULT}"
2885	echo -n "removing: "	echo -n "removing: "
2886	echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"	echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
2887	echo -e "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT}"	echo -e "${COLRED}${pname}-${pver}-${pbuild}${COLDEFAULT}"
2888
2889	magefile="${MAGEDIR}/${pcat}/${pname}/${pname}-${pver}-${pbuild}.mage"	magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
2890	source ${magefile}	source ${magefile}
2891
2892	## preremove scripts	## preremove scripts
#	Line 2391  mage_uninstall()	Line 2936  mage_uninstall()
2936	then	then
2937	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2938	echo -n "rebuilding environment ... "	echo -n "rebuilding environment ... "
2939	${MLIBDIR}/env-rebuild.sh > /dev/null && \	${MLIBDIR}/env-rebuild > /dev/null && \
2940	echo "done." || echo "failure."	echo "done." || echo "failure."
2941	unset MAGE_ENV_REBUILD	unset MAGE_ENV_REBUILD
2942	fi	fi
#	Line 2401  mage_uninstall()	Line 2946  mage_uninstall()
2946	# echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"	# echo -ne "${COLBLUE}${pcat}/${COLDEFAULT}"
2947	# echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "	# echo -ne "${COLGREEN}${pname}-${pver}-${pbuild}${COLDEFAULT} "
2948	echo "successfully removed."	echo "successfully removed."
2949
2950		# unset these functions
2951		unset -f preinstall
2952		unset -f postinstall
2953		unset -f preremove
2954		unset -f postremove
2955	}	}
2956
2957	show_etc_update_mesg() {	# rerun_pkgfunctions [method] pkg1 pkg2 pkg3
2958		rerun_pkgfunctions()
2959		{
2960		local method
2961		local list
2962		local pcat
2963		local pname
2964		local pver
2965		local pbuild
2966		local magefile
2967		local i
2968
2969		# very basic getops
2970		case $1 in
2971		--method) shift; method="$1" ;;
2972		esac
2973		shift
2974		local list="$@"
2975
2976		# sanity check
2977		case ${method} in
2978		preinstall|postinstall) ;;
2979		preremove|postremove) ;;
2980		*) die "rerun_pkgfunctions(): Unknown method '${method}'." ;;
2981		esac
2982
2983		if [[ -n ${MROOT} ]]
2984		then
2985		echo -ne ${COLRED}
2986		echo "!! running in MROOT=${MROOT}"
2987		echo -ne ${COLDEFAULT}
2988		echo
2989		fi
2990
2991		for pkg in ${list}
2992		do
2993		pcat=$(dep2pcat ${pkg})
2994		pname=$(magename2pname ${pkg})
2995		pver=$(magename2pver ${pkg})
2996		pbuild=$(magename2pbuild ${pkg})
2997		magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
2998
2999		if [ -e ${magefile} ]
3000		then
3001		source ${magefile}
3002		if [ -n "$(typeset -f ${method})" ]
3003		then
3004		echo -e " ${COLBLUE}***${COLDEFAULT} running ${method} for ${pkg} ... "
3005		${method}
3006		else
3007		echo "No ${method}() for pkg '${pkg}' defined. Doing nothing."
3008		fi
3009		unset -f preinstall postinstall preremove postremove
3010		else
3011		die "Magefile '${magefile}' does not exist."
3012		fi
3013		done
3014		}
3015
3016		show_etc_update_mesg()
3017		{
3018	[ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0	[ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0
3019
3020	echo	echo
#	Line 2415  show_etc_update_mesg() {	Line 3026  show_etc_update_mesg() {
3026	echo "Please run 'etc-update' to update your configuration files."	echo "Please run 'etc-update' to update your configuration files."
3027	echo	echo
3028	}	}
3029
3030		pkgsearch()
3031		{
3032		local string="$1"
3033		local result
3034		local pkg
3035		local pcat
3036		local pname
3037		local magefile
3038		local pver
3039		local pbuild
3040		local state
3041		local descriptiom
3042		local homepage
3043		local license
3044		local i
3045		local all_installed
3046		local ipver
3047		local ipbuild
3048		local latest_available
3049		local depsfull
3050		local sdepsfull
3051		local deps
3052		local sdeps
3053		local dep
3054		local sign
3055
3056		# only names no versions
3057		result="$(find ${MAGEDIR} -mindepth 2 -maxdepth 2 -type d -name '*'${string}'*'| sed '/profiles/d' | sed '/includes/d')"
3058		#result="$(find ${MAGEDIR} -type f -name '*'${string}'*'.mage | sort)"
3059
3060		# nothing found
3061		[[ -z ${result} ]] && die "No package found containing '${string}' in the name."
3062
3063		for pkg in ${result}
3064		do
3065		# dirty, but does the job
3066		pcat="$(magename2pcat ${pkg}/foo)"
3067		pname="$(magename2pname ${pkg}-foo-foo)"
3068
3069		# get highest version available
3070		magefile=$(get_highest_magefile ${pcat} ${pname})
3071
3072		if [[ ! -z ${magefile} ]]
3073		then
3074		# now get all needed infos to print a nice output
3075		pver="$(magename2pver ${magefile})"
3076		pbuild="$(magename2pbuild ${magefile})"
3077		state="$(get_value_from_magefile STATE ${magefile})"
3078		description="$(get_value_from_magefile DESCRIPTION ${magefile})"
3079		homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"
3080		license="$(get_value_from_magefile LICENSE ${magefile})"
3081
3082		# all installed
3083		for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})
3084		do
3085		ipver="$(magename2pver ${i})"
3086		ipbuild="$(magename2pbuild ${i})"
3087
3088		if [[ -z ${all_installed} ]]
3089		then
3090		all_installed="${ipver}-${ipbuild}"
3091		else
3092		all_installed="${all_installed} ${ipver}-${ipbuild}"
3093		fi
3094		done
3095		[[ -z ${all_installed} ]] && all_installed="none"
3096
3097		case ${state} in
3098		stable) state=${COLGREEN}"[s] ";;
3099		testing) state=${COLYELLOW}"[t] ";;
3100		unstable) state=${COLRED}"[u] ";;
3101		old) state=${COLGRAY}"[o] ";;
3102		esac
3103
3104		latest_available="${pver}-${pbuild}"
3105		else
3106		# package is masked
3107		state="${COLRED}[m] "
3108		latest_available="${COLRED}masked for this distribution.${COLDEFAULT}"
3109		fi
3110
3111		depsfull="$(get_value_from_magefile DEPEND ${magefile})"
3112		sdepsfull="$(get_value_from_magefile SDEPEND ${magefile})"
3113
3114		while read sign dep
3115		do
3116		case ${dep} in
3117		"") continue;;
3118		esac
3119
3120		if [[ -z ${deps} ]]
3121		then
3122		deps="$(basename ${dep%-*})"
3123		else
3124		deps="${deps} $(basename ${dep%-*})"
3125		fi
3126		done << EOF
3127		${depsfull}
3128		EOF
3129
3130		while read sign dep
3131		do
3132		case ${dep} in
3133		"") continue;;
3134		esac
3135
3136		if [[ -z ${sdeps} ]]
3137		then
3138		sdeps="$(basename ${dep%-*})"
3139		else
3140		sdeps="${sdeps} $(basename ${dep%-*})"
3141		fi
3142		done << EOF
3143		${sdepsfull}
3144		EOF
3145
3146		echo -e "${state}${pcat}/${pname}"${COLDEFAULT}
3147		echo -e "      Latest available:   ${latest_available}"
3148		echo "      Installed versions: ${all_installed}"
3149		echo "      Description: ${description}"
3150		echo "      Homepage: ${homepage}"
3151		if [[ ! -z ${license} ]]
3152		then
3153		echo "      License:  ${license}"
3154		fi
3155		echo "      Depends:  ${deps}"
3156		echo "      SDepends: ${sdeps}"
3157		echo
3158
3159		unset pcat
3160		unset pname
3161		unset magefile
3162		unset pver
3163		unset pbuild
3164		unset state
3165		unset descriptiom
3166		unset homepage
3167		unset all_installed
3168		unset ipver
3169		unset ipbuild
3170		unset depsfull
3171		unset sdepsfull
3172		unset deps
3173		unset sdeps
3174		unset dep
3175		unset sign
3176		done
3177		}
3178
3179		export_inherits()
3180		{
3181		local include="$1"
3182		shift
3183
3184		while [ "$1" ]
3185		do
3186		local functions="$1"
3187
3188		# sanity checks
3189		[ -z "${include}" ] && die "export_inherits(): \$include not given."
3190		[ -z "${functions}" ] && die "export_inherits(): \$functions not given."
3191
3192		eval "${functions}() { ${include}_${functions} ; }"
3193
3194		# debug
3195		mqueryfeature "debug" && typeset -f "${functions}"
3196
3197		shift
3198		done
3199		}
3200
3201		mlibdir()
3202		{
3203		local libdir=lib
3204		[[ ${ARCH} = x86_64 ]] && libdir=lib64
3205
3206		echo "${libdir}"
3207		}
3208
3209		## blacklisted ${magefile}
3210		blacklisted()
3211		{
3212		[[ -z ${MAGE_DISTRIBUTION} ]] && local MAGE_DISTRIBUTION=stable
3213
3214		# compat
3215		[[ ${USE_UNSTABLE} = true ]] && local MAGE_DISTRIBUTION=unstable
3216		[[ ${USE_TESTING} = true ]] && local MAGE_DISTRIBUTION=testing
3217
3218		# support both types for the moment
3219		if [[ -f /etc/mage-profile/package.blacklist-${ARCH}-${MAGE_DISTRIBUTION} ]]
3220		then
3221		local EXCLUDED="/etc/mage-profile/package.blacklist-${ARCH}-${MAGE_DISTRIBUTION}"
3222		else
3223		local EXCLUDED="/etc/mage-profile/package.blacklist-${ARCH}"
3224		fi
3225
3226		# return 0 if the list not exist; nothin is masked
3227		[[ ! -f ${EXCLUDED} ]] && return 0
3228
3229		local MAGEFILE="$1"
3230
3231		local PCAT="$(magename2pcat ${MAGEFILE})"
3232		local PNAME="$(magename2pname ${MAGEFILE})"
3233		local PVER="$(magename2pver ${MAGEFILE})"
3234		local PBUILD="$(magename2pbuild ${MAGEFILE})"
3235
3236		local EXPCAT EXPNAME EXPVER EXPBUILD
3237		while read EXPCAT EXPNAME EXPVER EXPBUILD
3238		do
3239		# ignore spaces and comments
3240		case "${EXPCAT}" in
3241		\#*|"") continue ;;
3242		esac
3243
3244		# exclude full pver
3245		if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
3246		[[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
3247		[[ -n ${PVER} ]] && [[ -n ${PBUILD} ]] &&
3248		[[ -n ${EXPVER} ]] && [[ -n ${EXPBUILD} ]]
3249		then
3250		[[ ${EXPCAT}/${EXPNAME}-${EXPVER}-${EXPBUILD} = ${PCAT}/${PNAME}-${PVER}-${PBUILD} ]] && return 1
3251		fi
3252
3253		# exclude pcat/pname only
3254		if [[ -n ${PCAT} ]] && [[ -n ${PNAME} ]] &&
3255		[[ -n ${EXPCAT} ]] && [[ -n ${EXPNAME} ]] &&
3256		[[ -z ${EXPVER} ]] && [[ -z ${EXPBUILD} ]]
3257		then
3258		[[ ${EXPCAT}/${EXPNAME} = ${PCAT}/${PNAME} ]] && return 1
3259		fi
3260		done << EOF
3261		$( cat ${EXCLUDED}; echo)
3262		EOF
3263
3264		return 0
3265		}
3266
3267		# need_busybox_support ${cmd}
3268		# return 0 (no error = needs busybox support) or return 1 (error = no busybox support required)
3269		need_busybox_support()
3270		{
3271		local cmd
3272		local busybox
3273		cmd="$1"
3274
3275		for busybox in {,/usr}/bin/busybox
3276		do
3277		if [[ -x ${busybox} ]]
3278		then
3279		if [[ $(readlink $(type -P ${cmd})) = ${busybox} ]]
3280		then
3281		# needs busybox support
3282		return 0
3283		fi
3284		fi
3285		done
3286
3287		# no busybox
3288		return 1
3289		}
3290
3291		# busybox_filter_wget_options ${wget_opts}
3292		busybox_filter_wget_options()
3293		{
3294		local opts="$@"
3295		local i
3296		local fixed_opts
3297
3298		if need_busybox_support wget
3299		then
3300		for i in ${opts}
3301		do
3302		# show only the allowed ones
3303		case ${i} in
3304		-c|--continue) fixed_opts+=" -c" ;;
3305		-s|--spider) fixed_opts+=" -s" ;;
3306		-q|--quiet) fixed_opts+=" -q" ;;
3307		-O|--output-document) shift; fixed_opts+=" -O $1" ;;
3308		--header) shift; fixed_opts+=" --header $1" ;;
3309		-Y|--proxy) shift; fixed_opts+=" -Y $1" ;;
3310		-P) shift; fixed_opts+=" -P $1" ;;
3311		--no-check-certificate) fixed_opts+=" --no-check-certificate ${i}" ;;
3312		-U|--user-agent) shift; fixed_opts+=" -U ${i}" ;;
3313		# simply drop all other opts
3314		*) continue ;;
3315		esac
3316		done
3317
3318		echo "${fixed_opts}"
3319		else
3320		echo "${opts}"
3321		fi
3322		}
3323
3324		have_root_privileges()
3325		{
3326		local retval
3327
3328		if [[ $(id -u) = 0 ]]
3329		then
3330		retval=0
3331		else
3332		retval=1
3333		fi
3334
3335		return ${retval}
3336		}
3337
3338		known_mage_feature()
3339		{
3340		local feature="$1"
3341		local retval
3342
3343		case "${feature}" in
3344		autosvc|!autosvc) retval=0 ;;
3345		buildlog|!buildlog) retval=0 ;;
3346		ccache|!ccache) retval=0 ;;
3347		check|!check) retval=0 ;;
3348		compressdoc|!compressdoc) retval=0 ;;
3349		debug|!debug) retval=0 ;;
3350		distcc|!distcc) retval=0 ;;
3351		icecc|!icecc) retval=0 ;;
3352		kernelsrcunpack|!kernelsrcunpack) retval=0 ;;
3353		libtool|!libtool) retval=0 ;;
3354		linuxsymlink|!linuxsymlink) retval=0 ;;
3355		multilib|!multilib) reval=0 ;;
3356		pkgbuild|!pkgbuild) retval=0 ;;
3357		pkgdistrotag|!pkgdistrotag) retval=0 ;;
3358		pkgmetadata|!pkgmetadata) retval=0 ;;
3359		purge|!purge) retval=0 ;;
3360		qalint|!qalint) retval=0 ;;
3361		regentree|!regentree) retval=0 ;;
3362		resume|!resume) retval=0 ;;
3363		srcpkgbuild|!srcpkgbuild) retval=0 ;;
3364		srcpkgtarball|!srcpkgtarball) retval=0 ;;
3365		static|!static) retval=0 ;;
3366		stepbystep|!stepbystep) retval=0 ;;
3367		strip|!strip) retval=0 ;;
3368		verbose|!verbose) retval=0 ;;
3369		*) retval=1 ;;
3370		esac
3371
3372		return "${retval}"
3373		}
3374
3375		load_mage_features()
3376		{
3377		for i in ${MAGE_FEATURES_GLOBAL[*]} ${MAGE_FEATURES[*]}
3378		do
3379		FVERBOSE=off msetfeature ${i}
3380		done
3381		}
3382
3383		msetfeature()
3384		{
3385		local feature
3386		local count
3387		local i
3388		local found
3389
3390		for feature in $@
3391		do
3392		found=0
3393		count="${#MAGE_FEATURES_CURRENT[*]}"
3394
3395		if ! known_mage_feature "${feature}"
3396		then
3397		[[ ${FVERBOSE} = off ]] || echo -e "${COLRED}Unknown feature '${feature}', ignoring it${COLDEFAULT}"
3398		return 3
3399		fi
3400
3401		for ((i=0; i<count; i++))
3402		do
3403		if [[ ${MAGE_FEATURES_CURRENT[${i}]} = ${feature} ]]
3404		then
3405		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' already enabled${COLDEFAULT}"
3406		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3407		found=1
3408		elif [[ ${MAGE_FEATURES_CURRENT[${i}]} = !${feature} ]]
3409		then
3410		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' currently disabled, enabling it!${COLDEFAULT}"
3411		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3412		found=1
3413		elif [[ ${MAGE_FEATURES_CURRENT[${i}]} = ${feature//!} ]]
3414		then
3415		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature//!}' currently enabled, disabling it!${COLDEFAULT}"
3416		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3417		found=1
3418		fi
3419		done
3420
3421		# if the feature was not found after proccessing the whole array
3422		# it was not declared. in this case enable it
3423		if [[ ${found} = 0 ]]
3424		then
3425		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' was not declared, enabling it!${COLDEFAULT}"
3426		MAGE_FEATURES_CURRENT=( ${MAGE_FEATURES_CURRENT[*]} "${feature}" )
3427		fi
3428
3429		export MAGE_FEATURES_CURRENT
3430		done
3431		}
3432
3433		mqueryfeature()
3434		{
3435		local feature="$1"
3436		local retval=1
3437		local i
3438
3439		if known_mage_feature "${feature}"
3440		then
3441		for i in ${MAGE_FEATURES_CURRENT[*]}
3442		do
3443		if [[ ${i} = ${feature} ]]
3444		then
3445		retval=0
3446		break # found break here
3447		fi
3448		done
3449		else
3450		[[ ${FVERBOSE} = off ]] || echo -e "${COLRED}Unknown feature '${feature}', ignoring it${COLDEFAULT}"
3451		retval=3
3452		fi
3453
3454		return ${retval}
3455		}
3456
3457		mprintfeatures()
3458		{
3459		echo -e "${COLRED}Global features:${COLDEFAULT} ${MAGE_FEATURES_GLOBAL[*]}"
3460		echo -e "${COLYELLOW}Local features:${COLDEFAULT} ${MAGE_FEATURES[*]}"
3461		echo -e "${COLGREEN}Current features:${COLDEFAULT} ${MAGE_FEATURES_CURRENT[*]}"
3462		}

---

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

Legend: Removed from v.226   changed lines   Added in v.2811