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

Parent Directory | Revision Log | Patch

	trunk/mage/usr/lib/mage/mage4.functions.sh revision 1271 by niro, Wed Apr 27 08:42:24 2011 UTC	branches/mage-next/src/mage4.functions.sh.in revision 2868 by niro, Thu Mar 19 15:29:17 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.38 2008-10-05 10:32:24 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 207  install_files()	Line 306  install_files()
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 219  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 246  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
#	Line 256  install_files()	Line 355  install_files()
355
356	# file is protected but ignored, delete the update/do nothing	# file is protected but ignored, delete the update/do nothing
357	4)	4)
358	if [[ ${VERBOSE} = on ]]	if mqueryfeature "verbose"
359	then	then
360	echo -en "${COLRED}"	echo -en "${COLRED}"
361	echo -n "! ignr "	echo -n "! ignr "
362	echo -en "${COLDEFAULT}"	echo -en "${COLDEFAULT}"
363	echo " === FILE: ${MROOT}${pathto}"	echo " === FILE: ${MROOT}${pathto}"
364	fi	fi
365	# simply do nothing here	# 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
#	Line 307  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
#	Line 357  install_blockdevices()	Line 464  install_blockdevices()
464	while read pathto posix major minor user group	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	mknod -m "${posix}" "${MROOT}${pathto}"	mknod -m "${posix}" "${MROOT}${pathto}"
470	# make it optional atm !!	# make it optional atm !!
#	Line 401  install_characterdevices()	Line 508  install_characterdevices()
508	while read pathto posix major minor user group	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}"	mknod -m ${posix} "${MROOT}${pathto}" b "${major}" "${minor}"
514
#	Line 445  install_fifos()	Line 552  install_fifos()
552	while read pathto posix user group	while read pathto posix user group
553	do	do
554	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
555	[[ ${VERBOSE} = on ]] && echo -e "\t>>> FIFO: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t>>> FIFO: ${MROOT}${pathto}"
556
557	mkfifo -m "${posix}" "${MROOT}${pathto}"	mkfifo -m "${posix}" "${MROOT}${pathto}"
558	chown "${user}:${group}" "${MROOT}${pathto}"	chown "${user}:${group}" "${MROOT}${pathto}"
#	Line 467  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 630  remove_database_entry()	Line 737  remove_database_entry()
737	[ ! -f ${magefile} ] && die "remove_database_entry() ${magefile} not exist."	[ ! -f ${magefile} ] && die "remove_database_entry() ${magefile} not exist."
738
739	# remove virtuals only if no other exist	# remove virtuals only if no other exist
740	if [[ $(count_installed_pkgs --pcat ${pcat} --pname ${pname}) -le 1 ]]	if [[ $(count_installed_pkgs --pcat=${pcat} --pname=${pname}) -le 1 ]]
741	then	then
742	# first unregister virtuals	# first unregister virtuals
743	provide="$(get_value_from_magefile PROVIDE ${magefile})"	provide="$(get_value_from_magefile PROVIDE ${magefile})"
#	Line 659  count_installed_pkgs()	Line 766  count_installed_pkgs()
766	local i	local i
767
768	# very basic getops	# very basic getops
769	for i in $*	for i in $@
770	do	do
771	case $1 in	case ${i} in
772	--pcat|-c) shift; pcat="$1" ;;	--pcat*) pcat="${i#*=}" ;;
773	--pname|-n) shift; pname="$1" ;;	--pname*) pname="${i#*=}" ;;
774	esac	esac
	shift
775	done	done
776
777	# sanity checks; abort if not given	# sanity checks; abort if not given
#	Line 704  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 779  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 791  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 863  remove_files()	Line 958  remove_files()
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 889  remove_files()	Line 984  remove_files()
984	case ${retval} in	case ${retval} in
985	# file is not protected - delete it	# file is not protected - delete it
986	0|3)	0|3)
987	[[ ${VERBOSE} = on ]] && echo -e "\t<<< FILE: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< FILE: ${MROOT}${pathto}"
988	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
989	;;	;;
990
991	# file is protected, do not delete	# file is protected, do not delete
992	2)	2)
993	if [[ ${VERBOSE} = on ]]	if mqueryfeature "verbose"
994	then	then
995	echo -en "${COLRED}"	echo -en "${COLRED}"
996	echo -n "! prot "	echo -n "! prot "
#	Line 906  remove_files()	Line 1001  remove_files()
1001
1002	# file is protected but ignored, delete the update/do nothing	# file is protected but ignored, delete the update/do nothing
1003	4)	4)
1004	if [[ ${VERBOSE} = on ]]	if mqueryfeature "verbose"
1005	then	then
1006	echo -en "${COLRED}"	echo -en "${COLRED}"
1007	echo -n "! ignr "	echo -n "! ignr "
#	Line 918  remove_files()	Line 1013  remove_files()
1013	esac	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 980  remove_blockdevices()	Line 1075  remove_blockdevices()
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 1040  remove_characterdevices()	Line 1135  remove_characterdevices()
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 1102  remove_fifos()	Line 1197  remove_fifos()
1197	do	do
1198	[ -z "${pathto}" ] && continue	[ -z "${pathto}" ] && continue
1199
1200	[[ ${VERBOSE} = on ]] && echo -e "\t<<< FIFO: ${MROOT}${pathto}"	mqueryfeature "verbose" && echo -e "\t<<< FIFO: ${MROOT}${pathto}"
1201	rm "${MROOT}${pathto}"	rm "${MROOT}${pathto}"
1202	done < ${MROOT}${INSTALLDB}/${pfull}/.fifo	done < ${MROOT}${INSTALLDB}/${pfull}/.fifo
1203
#	Line 1163  remove_directories()	Line 1258  remove_directories()
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 1171  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
#	Line 1184  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	done
#	Line 1244  build_douninstall()	Line 1339  build_douninstall()
1339	done	done
1340	}	}
1341
1342		# convertmirrors [uri]
1343		convertmirrors()
1344		{
1345		local uri="$1"
1346		local scheme
1347		local mirror
1348		local mirrors
1349		local addon
1350		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://*|file://*) 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		case ${mirror} in
1430		file://*)
1431		cp -v "${mirror//file:\/\/}" "${outputdir}/${outputfile}"
1432		retval="$?"
1433		;;
1434		*)
1435		wget ${wget_opts} --output-document="${outputdir}/${outputfile}" "${mirror}"
1436		retval="$?"
1437		;;
1438		esac
1439
1440		if [[ ${retval} = 0 ]]
1441		then
1442		break
1443		else
1444		continue
1445		fi
1446		done
1447
1448		# return wget retval
1449		return "${retval}"
1450		}
1451
1452	# fetch_packages /path/to/mage/file1 /path/to/mage/file2	# fetch_packages /path/to/mage/file1 /path/to/mage/file2
1453	fetch_packages()	fetch_packages()
1454	{	{
1455		local i
1456	local list="$@"	local list="$@"
1457	local pkg	local pkgname
1458		local pkgfile
1459		local pcat
1460		local pname
1461	local mirr	local mirr
1462	local magefile	local magefile
1463	local md5file	local md5file
1464	local opt	local opt
1465	local count_current	local count_current
1466	local count_total	local count_total
1467		local wget_opts
1468		local fetching
1469
1470	[ -z "${MIRRORS}" ] && die "You have no mirrors defined. Please edit your ${MAGERC}."	[ -z "${MIRRORS}" ] && die "You have no mirrors defined. Please edit your ${MAGERC}."
1471
1472		# filter wget command if busybox was found
1473		wget_opts="$(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1474
1475	# get count of total packages	# get count of total packages
1476	declare -i count_current=0	declare -i count_current=0
1477	declare -i count_total=0	declare -i count_total=0
#	Line 1266  fetch_packages()	Line 1480  fetch_packages()
1480
1481	for magefile in ${list}	for magefile in ${list}
1482	do	do
1483	pkg="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
1484		pkgfile="${pkgname}.${PKGSUFFIX}"
1485	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
1486
1487		pcat=$(magename2pcat ${magefile})
1488		pname=$(magename2pname ${magefile})
1489		md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
1490
1491	(( count_current++ ))	(( count_current++ ))
1492	xtitle "[ (${count_current}/${count_total}) Fetching ${pkg} ]"	xtitle "[ (${count_current}/${count_total}) Fetching ${pkgfile} ]"
1493
1494	# abort on virtual pkg	# abort on virtual pkg
1495	if [[ ${pkgtype} = virtual ]]	if [[ ${pkgtype} = virtual ]]
1496	then	then
1497	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
1498	echo " !fetch virtual (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "	echo " !fetch virtual (${count_current}/${count_total}): ${pkgname} ... "
1499	continue	continue
1500	fi	fi
1501
#	Line 1284  fetch_packages()	Line 1503  fetch_packages()
1503	if [[ ${pkgtype} = sources ]]	if [[ ${pkgtype} = sources ]]
1504	then	then
1505	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
1506	echo " !fetch sources (${count_current}/${count_total}): ${pkg/.${PKGSUFFIX}/} ... "	echo " !fetch sources (${count_current}/${count_total}): ${pkgname} ... "
1507	continue	continue
1508	fi	fi
1509
1510	# abort if already exist	# check if FETCHING is required
1511	if [ -f ${PKGDIR}/${pkg} ]	if [ ! -f "${md5file}" ]
1512	then	then
1513	echo -ne " ${COLBLUE}***${COLDEFAULT}"	fetching=true
1514	echo " fetch complete (${count_current}/${count_total}): ${pkg} ... "	else
1515	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 \
	${WGET_FETCH_OPTIONS} \
	--directory-prefix=${PKGDIR} \
	${opt} ${mirr}/${PACKAGES_SERVER_PATH}/${pkg}
	if [[ $? = 0 ]]
1516	then	then
1517	break	# md5's ok, no fetching required
1518		fetching=false
1519	else	else
1520	continue	fetching=true
1521	fi	fi
1522	done	fi
1523
1524	if [ ! -f ${PKGDIR}/${pkg} ]	if [[ ${fetching} = false ]]
1525	then	then
1526	die "Could not download ${pkg}"	echo -ne " ${COLBLUE}***${COLDEFAULT}"
1527		echo " fetch complete (${count_current}/${count_total}): ${pkgfile} ... "
1528		continue
1529		else
1530		echo -ne " ${COLBLUE}***${COLDEFAULT}"
1531		echo -e " fetching (${count_current}/${count_total}): ${pkgfile} ... "
1532		mdownload --uri "package://${pkgfile}" --dir "${PKGDIR}" || die "Could not download ${pkgfile}"
1533		fi
1534
1535		# sanity check, not really needed but to be sure
1536		if [ ! -f ${PKGDIR}/${pkgfile} ]
1537		then
1538		die "Package '${pkgfile}' after download not found in '${PKGDIR}'"
1539	fi	fi
1540	done	done
1541
#	Line 1344  syncmage()	Line 1563  syncmage()
1563	done	done
1564
1565	# clean up backup files (foo~)	# clean up backup files (foo~)
1566	find ${MAGEDIR} -name *~ -exec rm '{}' ';'	find ${MAGEDIR} -name \*~ -exec rm '{}' ';'
1567
1568	# check if a newer mage version is available	# check if a newer mage version is available
1569	is_newer_mage_version_available	is_newer_mage_version_available
#	Line 1357  syncmage_tarball()	Line 1576  syncmage_tarball()
1576	local temp="$(mktemp -d)"	local temp="$(mktemp -d)"
1577	local mirr mymirr	local mirr mymirr
1578	local opt	local opt
1579		local tar_opts
1580		local wget_opts
1581
1582	# try to get the md5 marked as latest on the server	# try to get the md5 marked as latest on the server
1583	latest_md5="mage-latest.md5"	latest_md5="mage-latest.md5"
#	Line 1364  syncmage_tarball()	Line 1585  syncmage_tarball()
1585	# try to get the tarball marked as latest on the server	# try to get the tarball marked as latest on the server
1586	latest_tarball="mage-latest.tar.bz2"	latest_tarball="mage-latest.tar.bz2"
1587
1588		# filter wget command if busybox was found
1589		wget_opts="$(busybox_filter_wget_options ${WGET_FETCH_OPTIONS})"
1590
1591	for mirr in ${MIRRORS}	for mirr in ${MIRRORS}
1592	do	do
1593	# path without distribution	# path without distribution
1594	mymirr="${mirr%/*}"	# (only for stable|testing|unstable and not DISTROTAG)
1595		case ${mirr##*/} in
1596		stable|testing|unstable) mymirr="${mirr%/*}";;
1597		*) mymirr="${mirr}";;
1598		esac
1599
1600	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1601	echo "fetching latest md5 from ${mymirr} ..."	echo "fetching latest md5 from ${mymirr} ..."
1602	[[ ${VERBOSE} = off ]] && opt="--quiet"	mqueryfeature "!verbose" && opt="--quiet"
1603	wget \	wget \
1604	${WGET_FETCH_OPTIONS} \	${wget_opts} \
1605	--directory-prefix=${temp} \	--directory-prefix=${temp} \
1606	${opt} ${mymirr}/rsync/tarballs/${latest_md5}	${opt} ${mymirr}/rsync/tarballs/${latest_md5}
1607
1608	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1609	echo "fetching latest tarball from ${mymirr} ..."	echo "fetching latest tarball from ${mymirr} ..."
1610	wget \	wget \
1611	${WGET_FETCH_OPTIONS} \	${wget_opts} \
1612	--directory-prefix=${temp} \	--directory-prefix=${temp} \
1613	${opt} ${mymirr}/rsync/tarballs/${latest_tarball}	${opt} ${mymirr}/rsync/tarballs/${latest_tarball}
1614	if [[ $? = 0 ]]	if [[ $? = 0 ]]
#	Line 1400  syncmage_tarball()	Line 1628  syncmage_tarball()
1628	else	else
1629	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1630	echo -n "checking md5sum... "	echo -n "checking md5sum... "
1631	( cd ${temp}; md5sum --check ${latest_md5} ) || die "md5 for ${latest_tarball} failed"	mchecksum --rundir "${temp}" --file "${latest_md5}" --method md5 || die "md5 for ${latest_tarball} failed"
1632	fi	fi
1633
1634	if [[ -d ${MAGEDIR} ]]	if [[ -d ${MAGEDIR} ]]
1635	then	then
1636	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1637	echo "cleaning old mage-tree ${MAGEDIR}..."	echo "cleaning old mage-tree ${MAGEDIR}..."
1638	rm -rf ${MAGEDIR}	# honor mountpoints and empty dirs
1639		if mountpoint -q ${MAGEDIR}
1640		then
1641		if ! mcheckemptydir ${MAGEDIR}
1642		then
1643		find ${MAGEDIR} -mindepth 1 -maxdepth 1 | xargs --no-run-if-empty rm -r
1644		fi
1645		else
1646		rm -rf ${MAGEDIR}
1647		fi
1648		fi
1649
1650		if need_busybox_support tar
1651		then
1652		tar_opts="xjf"
1653		else
1654		tar_opts="xjmf"
1655	fi	fi
1656
1657	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
1658	echo "updating mage-tree from tarball ..."	echo "updating mage-tree from tarball ..."
1659	# unpack in dirname of MAGEDIR, as the tarball has already the mage	# unpack in dirname of MAGEDIR, as the tarball has already the mage
1660	tar xjmf ${temp}/${latest_tarball} -C ${MAGEDIR%/*} || die "Unpacking tarball"	tar ${tar_opts} ${temp}/${latest_tarball} -C ${MAGEDIR%/*} || die "Unpacking tarball"
1661
1662	if [[ -d ${temp} ]]	if [[ -d ${temp} ]]
1663	then	then
#	Line 1439  cleanpkg()	Line 1683  cleanpkg()
1683	fi	fi
1684	}	}
1685
1686	xtitle()	# unused?
1687	{	#
1688	if [[ ${TERM} = xterm ]]	# # cuts full pathnames or versionized names down to basename
1689	then	# choppkgname()
1690	echo -ne "\033]0;Mage: $1\007"	# {
1691	fi	# #we want this only if full name was used
1692	return 0	# if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]
1693	}	# then
1694		# #cuts ARCH and PBUILD
1695		# #ARCH comes from ${MAGERC}
1696	xtitleclean()	# MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}$(print_distrotag)-r*.::g")
1697	{	#
1698	if [[ ${TERM} = xterm ]]	# #cuts version number
1699	then	# MAGENAME=$(basename ${MAGENAME%-*} .mage)
1700	echo -ne "\033]0;\007"	# fi
1701	fi	# }
	return 0
	}
1702
1703
	# cuts full pathnames or versioniezed names down to basename
	choppkgname()
	{
	#we want this only if full name was used
	if [ -n "$(echo ${MAGENAME}|fgrep .mage)" ]
	then
	#cuts ARCH and PBUILD
	#ARCH comes from ${MAGERC}
	MAGENAME=$(echo ${MAGENAME} |sed -e "s:-${ARCH}-r*.::g")
	#cuts version number
	MAGENAME=$(basename ${MAGENAME%-*} .mage)
	fi
	}
1704	# get_categorie $PNAME, returns CATEGORIE	# get_categorie $PNAME, returns CATEGORIE
1705	# $1=pname	# $1=pname
1706	# ret 0=ok, 1=not_found	# ret 0=ok, 1=not_found
#	Line 1495  pname2pcat()	Line 1722  pname2pcat()
1722	echo "${categorie}"	echo "${categorie}"
1723	}	}
1724
	# check_stable_package /path/to/foo.mage
	# returns 0=stable 1=unstable
	check_stable_package()
	{
	# first check if this magefile is not blacklisted
	blacklisted "$1" || return 1
	local STATE
	STATE="$(get_value_from_magefile STATE "$1")"
	# state testing
	if [[ ${USE_TESTING} = true ]] || [[ ${MAGE_DISTRIBUTION} = testing ]]
	then
	case ${STATE} in
	testing|stable) return 0 ;;
	*) return 1 ;;
	esac
	fi
	# state unstable
	if [[ ${USE_UNSTABLE} = true ]] || [[ ${MAGE_DISTRIBUTION} = unstable ]]
	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
	}
1725	# get_highest_magefile ${PCAT} ${PNAME}	# get_highest_magefile ${PCAT} ${PNAME}
1726	# fake at moment returns only stable pkgs (must set to be one)	# returns $HIGHEST_MAGEFILE
	# return $HIGHEST_MAGEFILE
1727	get_highest_magefile()	get_highest_magefile()
1728	{	{
1729	local HIGHEST_MAGEFILE	local pcat="$1"
1730	local PCAT="$1"	local pname="$2"
	local PNAME="$2"
	local magefile
	# do not list the content of a directory, only the name (-d)
	for magefile in $(ls --format=single-column -v -d ${MAGEDIR}/${PCAT}/${PNAME}/*)
	do
	[[ -z ${magefile} ]] && continue
	# 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
1731
1732	# do not so anything	${MLIBDIR}/highest_magefile ${MAGEDIR}/${pcat}/${pname}
	# # 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}"
1733	return 0	return 0
1734	}	}
1735
1736	###################################################	###################################################
1737	# function is_config_protected                    #	# function is_config_protected                    #
1738	#       is_config_protected /path/to/file         #	#       is_config_protected /path/to/file         #
#	Line 1680  count_protected_files()	Line 1831  count_protected_files()
1831	local filename="${file##*/}"	local filename="${file##*/}"
1832	local count	local count
1833	local output	local output
1834		local oldprotected
1835	local i	local i
1836		local x
1837
1838		# hack; do not honor a global set IFS like '§'
1839		local IFS
1840
1841	declare -i count=0	count=0
1842
1843	# check if there are already protected files	# check if there are already protected files
1844	for oldpretected in $(find ${dirname} -iname "._cfg????_${filename}" |	for oldprotected in $(find ${dirname} -iname "._cfg????_${filename}" |
1845	sed -e "s:\(^.*/\)\(._cfg*_\)\(/.*$\):\1\2\3\%\2\%\3:" |	sed -e "s:\(^.*/\)\(._cfg*_\)\(/.*$\):\1\2\3\%\2\%\3:" |
1846	sort -t'%' -k3 -k2 | cut -f1 -d'%')	sort -t'%' -k3 -k2 | cut -f1 -d'%')
1847	do	do
1848	count=$(echo ${oldpretected} | cut -d_ -f2 | sed -e "s:cfg::")	count="$(echo ${oldprotected} | sed 's:.*\/._cfg\(.*\)_.*:\1:')"
1849		done
1850
1851		# convert 0001 -> 1; 0120 -> 120 etc
1852		# use bash internal base functions to this task
1853		x="$((10#${count}))"
1854		for (( i=0; i<x; i++ ))
1855		do
1856		if [[ ${count:${i}:1} != 0 ]]
1857		then
1858		count="${count:${i}}"
1859		break
1860		fi
1861	done	done
1862	(( count ++ ))
1863		count="$(( ${count}+1 ))"
1864
1865	# fill output up with zeros	# fill output up with zeros
1866	for (( i=${#count}; i < 4; i++ )); do output="${output}0"; done	for (( i=${#count}; i < 4; i++ )); do output="${output}0"; done
#	Line 1981  minclude()	Line 2150  minclude()
2150	then	then
2151	for i in $*	for i in $*
2152	do	do
2153	[[ ${MAGEDEBUG} = on ]] && \	mqueryfeature "debug" && \
2154	echo "--- Including ${MAGEDIR}/include/${i}.minc"	echo "--- Including ${MAGEDIR}/include/${i}.minc"
2155	source ${MAGEDIR}/include/${i}.minc	source ${MAGEDIR}/include/${i}.minc
2156	done	done
2157	[[ ${MAGEDEBUG} = on ]] && echo	mqueryfeature "debug" && echo
2158	fi	fi
2159	}	}
2160
#	Line 1997  sminclude()	Line 2166  sminclude()
2166	then	then
2167	for i in $*	for i in $*
2168	do	do
2169	echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"	[[ ${SILENT} = 1 ]] || echo "--- Including ${SMAGESCRIPTSDIR}/include/${i}.sminc"
2170	source ${SMAGESCRIPTSDIR}/include/${i}.sminc	source ${SMAGESCRIPTSDIR}/include/${i}.sminc
2171	done	done
2172	echo	[[ ${SILENT} = 1 ]] || echo
2173	fi	fi
2174	}	}
2175
#	Line 2027  is_newer_mage_version_available()	Line 2196  is_newer_mage_version_available()
2196	fi	fi
2197	}	}
2198
2199	# returns pname from pkgname	# returns pname from pkgname
2200	# pkgname2pname $PKGNAME	# pkgname2pname $PKGNAME
2201	pkgname2pname()	pkgname2pname()
#	Line 2304  get_value_from_magefile()	Line 2472  get_value_from_magefile()
2472	local SDEPEND	local SDEPEND
2473	local PROVIDE	local PROVIDE
2474	local PKGTYPE	local PKGTYPE
	local MAGE_TARGETS
2475	local SPLIT_PACKAGE_BASE	local SPLIT_PACKAGE_BASE
2476	local preinstall	local preinstall
2477	local postinstall	local postinstall
#	Line 2426  mage_install()	Line 2593  mage_install()
2593	echo B:${pbuild}	echo B:${pbuild}
2594	fi	fi
2595
2596	if [[ -n ${MAGE_TARGETS} ]]	if [[ -n ${SPLIT_PACKAGE_BASE} ]]
	then
	# basic svn compat
	if [[ -d ${SMAGESCRIPTSDIR}/trunk ]]
	then
	for i in ${SMAGESCRIPTSDIR}/trunk/*/${pname/${MAGE_TARGETS}/}/${pname/${MAGE_TARGETS}/}-${pver}-${pbuild}.smage2
	do
	smage2file="${i}"
	done
	else
	smage2file=${SMAGESCRIPTSDIR}/${pname/${MAGE_TARGETS}/}/${pname/${MAGE_TARGETS}/}-${pver}-${pbuild}.smage2
	fi
	elif [[ -n ${SPLIT_PACKAGE_BASE} ]]
2597	then	then
2598	# basic svn compat	# basic svn compat
2599	if [[ -d ${SMAGESCRIPTSDIR}/trunk ]]	if [[ -d ${SMAGESCRIPTSDIR}/.svn ]]
2600	then	then
2601	for i in ${SMAGESCRIPTSDIR}/trunk/*/${SPLIT_PACKAGE_BASE}/${SPLIT_PACKAGE_BASE}-${pver}-${pbuild}.smage2	for i in ${SMAGESCRIPTSDIR}/*/${SPLIT_PACKAGE_BASE}/${SPLIT_PACKAGE_BASE}-${pver}-${pbuild}.smage2
2602	do	do
2603	smage2file="${i}"	smage2file="${i}"
2604	done	done
#	Line 2454  mage_install()	Line 2608  mage_install()
2608
2609	else	else
2610	# basic svn compat	# basic svn compat
2611	if [[ -d ${SMAGESCRIPTSDIR}/trunk ]]	if [[ -d ${SMAGESCRIPTSDIR}/.svn ]]
2612	then	then
2613	for i in ${SMAGESCRIPTSDIR}/trunk/*/${pname}/${pname}-${pver}-${pbuild}.smage2	for i in ${SMAGESCRIPTSDIR}/*/${pname}/${pname}-${pver}-${pbuild}.smage2
2614	do	do
2615	smage2file="${i}"	smage2file="${i}"
2616	done	done
#	Line 2481  mage_install()	Line 2635  mage_install()
2635	if [[ ${PKGTYPE} != virtual ]] && \	if [[ ${PKGTYPE} != virtual ]] && \
2636	[[ ${PKGTYPE} != sources ]]	[[ ${PKGTYPE} != sources ]]
2637	then	then
2638		unpack_package "${magefile}"
2639	echo -e " ${COLBLUE}***${COLDEFAULT} merging files into system ... "	echo -e " ${COLBLUE}***${COLDEFAULT} merging files into system ... "
2640	build_doinstall ${PKGNAME}	build_doinstall ${PKGNAME}
2641	fi	fi
#	Line 2525  mage_install()	Line 2680  mage_install()
2680	then	then
2681	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2682	echo -n "rebuilding environment ... "	echo -n "rebuilding environment ... "
2683	${MLIBDIR}/env-rebuild.sh > /dev/null && \	${MLIBDIR}/env-rebuild > /dev/null && \
2684	echo "done." || echo "failure."	echo "done." || echo "failure."
2685	unset MAGE_ENV_REBUILD	unset MAGE_ENV_REBUILD
2686	fi	fi
#	Line 2569  md5sum_packages()	Line 2724  md5sum_packages()
2724	pname=$(magename2pname ${magefile})	pname=$(magename2pname ${magefile})
2725	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"	pkgname="$(get_value_from_magefile PKGNAME ${magefile})"
2726	md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"	md5file="${MAGEDIR}/${pcat}/${pname}/md5/${pkgname}.md5"
2727	pkgfile="$(get_value_from_magefile PKGNAME ${magefile}).${PKGSUFFIX}"	pkgfile="${pkgname}.${PKGSUFFIX}"
2728	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"	pkgtype="$(get_value_from_magefile PKGTYPE ${magefile})"
2729
2730	(( count_current++ ))	(( count_current++ ))
#	Line 2579  md5sum_packages()	Line 2734  md5sum_packages()
2734	if [[ ${pkgtype} = virtual ]]	if [[ ${pkgtype} = virtual ]]
2735	then	then
2736	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
2737	echo " !md5sum virtual (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "	echo " !md5sum virtual (${count_current}/${count_total}): ${pkgname} ... "
2738	continue	continue
2739	fi	fi
2740
#	Line 2587  md5sum_packages()	Line 2742  md5sum_packages()
2742	if [[ ${pkgtype} = sources ]]	if [[ ${pkgtype} = sources ]]
2743	then	then
2744	echo -ne " ${COLBLUE}---${COLDEFAULT}"	echo -ne " ${COLBLUE}---${COLDEFAULT}"
2745	echo " !md5sum sources (${count_current}/${count_total}): ${pkgfile/.${PKGSUFFIX}/} ... "	echo " !md5sum sources (${count_current}/${count_total}): ${pkgname} ... "
2746	continue	continue
2747	fi	fi
2748
#	Line 2595  md5sum_packages()	Line 2750  md5sum_packages()
2750	then	then
2751	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2752	echo -ne "checking md5sum (${count_current}/${count_total}): "	echo -ne "checking md5sum (${count_current}/${count_total}): "
2753	( cd ${PKGDIR}; md5sum --check ${md5file}) || die "md5 for ${pkgfile} failed"	mchecksum --rundir "${PKGDIR}" --file "${md5file}" --method md5 || die "md5 for ${pkgfile} failed"
2754	else	else
2755	echo -ne "${COLBLUE} --- ${COLDEFAULT}"	echo -ne "${COLBLUE} --- ${COLDEFAULT}"
2756	echo -e "!! no md5sum file found for ${pkgfile} :("	echo -e "!! no md5sum file found for ${pkgfile} :("
#	Line 2635  uninstall_packages()	Line 2790  uninstall_packages()
2790	pbuild=$(magename2pbuild ${pkg})	pbuild=$(magename2pbuild ${pkg})
2791	can_pcat="${pcat}"	can_pcat="${pcat}"
2792	can_pname="${pname}"	can_pname="${pname}"
2793
2794	if [ -z "${can_ver_list}" ]	if [ -z "${can_ver_list}" ]
2795	then	then
2796	can_ver_list=" ${pver}-${pbuild}"	can_ver_list=" ${pver}-${pbuild}"
#	Line 2790  mage_uninstall()	Line 2945  mage_uninstall()
2945	then	then
2946	echo -ne "${COLBLUE} *** ${COLDEFAULT}"	echo -ne "${COLBLUE} *** ${COLDEFAULT}"
2947	echo -n "rebuilding environment ... "	echo -n "rebuilding environment ... "
2948	${MLIBDIR}/env-rebuild.sh > /dev/null && \	${MLIBDIR}/env-rebuild > /dev/null && \
2949	echo "done." || echo "failure."	echo "done." || echo "failure."
2950	unset MAGE_ENV_REBUILD	unset MAGE_ENV_REBUILD
2951	fi	fi
#	Line 2808  mage_uninstall()	Line 2963  mage_uninstall()
2963	unset -f postremove	unset -f postremove
2964	}	}
2965
2966		# rerun_pkgfunctions [method] pkg1 pkg2 pkg3
2967		rerun_pkgfunctions()
2968		{
2969		local method
2970		local list
2971		local pcat
2972		local pname
2973		local pver
2974		local pbuild
2975		local magefile
2976		local i
2977
2978		# very basic getops
2979		case $1 in
2980		--method) shift; method="$1" ;;
2981		esac
2982		shift
2983		local list="$@"
2984
2985		# sanity check
2986		case ${method} in
2987		preinstall|postinstall) ;;
2988		preremove|postremove) ;;
2989		*) die "rerun_pkgfunctions(): Unknown method '${method}'." ;;
2990		esac
2991
2992		if [[ -n ${MROOT} ]]
2993		then
2994		echo -ne ${COLRED}
2995		echo "!! running in MROOT=${MROOT}"
2996		echo -ne ${COLDEFAULT}
2997		echo
2998		fi
2999
3000		for pkg in ${list}
3001		do
3002		pcat=$(dep2pcat ${pkg})
3003		pname=$(magename2pname ${pkg})
3004		pver=$(magename2pver ${pkg})
3005		pbuild=$(magename2pbuild ${pkg})
3006		magefile="${MROOT}${INSTALLDB}/${pcat}/${pname}-${pver}-${pbuild}/${pname}-${pver}-${pbuild}.mage"
3007
3008		if [ -e ${magefile} ]
3009		then
3010		source ${magefile}
3011		if [ -n "$(typeset -f ${method})" ]
3012		then
3013		echo -e " ${COLBLUE}***${COLDEFAULT} running ${method} for ${pkg} ... "
3014		${method}
3015		else
3016		echo "No ${method}() for pkg '${pkg}' defined. Doing nothing."
3017		fi
3018		unset -f preinstall postinstall preremove postremove
3019		else
3020		die "Magefile '${magefile}' does not exist."
3021		fi
3022		done
3023		}
3024
3025	show_etc_update_mesg()	show_etc_update_mesg()
3026	{	{
3027	[ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0	[ ${MAGE_PROTECT_COUNTER} -eq 0 ] && return 0
#	Line 2835  pkgsearch()	Line 3049  pkgsearch()
3049	local state	local state
3050	local descriptiom	local descriptiom
3051	local homepage	local homepage
3052		local license
3053	local i	local i
3054	local all_installed	local all_installed
3055	local ipver	local ipver
#	Line 2871  pkgsearch()	Line 3086  pkgsearch()
3086	state="$(get_value_from_magefile STATE ${magefile})"	state="$(get_value_from_magefile STATE ${magefile})"
3087	description="$(get_value_from_magefile DESCRIPTION ${magefile})"	description="$(get_value_from_magefile DESCRIPTION ${magefile})"
3088	homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"	homepage="$(get_value_from_magefile HOMEPAGE ${magefile})"
3089		license="$(get_value_from_magefile LICENSE ${magefile})"
3090
3091	# all installed	# all installed
3092	for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})	for i in $(get_uninstall_candidates --pname ${pname} --pcat ${pcat})
3093	do	do
3094	ipver="$(magename2pver ${i})"	ipver="$(magename2pver ${i})"
3095	ipbuild="$(magename2pbuild ${i})"	ipbuild="$(magename2pbuild ${i})"
3096
3097	if [[ -z ${all_installed} ]]	if [[ -z ${all_installed} ]]
3098	then	then
3099	all_installed="${ipver}-${ipbuild}"	all_installed="${ipver}-${ipbuild}"
#	Line 2886  pkgsearch()	Line 3102  pkgsearch()
3102	fi	fi
3103	done	done
3104	[[ -z ${all_installed} ]] && all_installed="none"	[[ -z ${all_installed} ]] && all_installed="none"
3105
3106	case ${state} in	case ${state} in
3107	stable) state=${COLGREEN}"[s] ";;	stable) state=${COLGREEN}"[s] ";;
3108	testing) state=${COLYELLOW}"[t] ";;	testing) state=${COLYELLOW}"[t] ";;
#	Line 2910  pkgsearch()	Line 3126  pkgsearch()
3126	"") continue;;	"") continue;;
3127	esac	esac
3128
3129	deps="${deps} $(basename ${dep%-*})"	if [[ -z ${deps} ]]
3130		then
3131		deps="$(basename ${dep%-*})"
3132		else
3133		deps="${deps} $(basename ${dep%-*})"
3134		fi
3135	done << EOF	done << EOF
3136	${depsfull}	${depsfull}
3137	EOF	EOF
#	Line 2921  EOF	Line 3142  EOF
3142	"") continue;;	"") continue;;
3143	esac	esac
3144
3145	sdeps="${sdeps} $(basename ${dep%-*})"	if [[ -z ${sdeps} ]]
3146		then
3147		sdeps="$(basename ${dep%-*})"
3148		else
3149		sdeps="${sdeps} $(basename ${dep%-*})"
3150		fi
3151	done << EOF	done << EOF
3152	${sdepsfull}	${sdepsfull}
3153	EOF	EOF
#	Line 2931  EOF	Line 3157  EOF
3157	echo "      Installed versions: ${all_installed}"	echo "      Installed versions: ${all_installed}"
3158	echo "      Description: ${description}"	echo "      Description: ${description}"
3159	echo "      Homepage: ${homepage}"	echo "      Homepage: ${homepage}"
3160	echo "      Depends: ${deps}"	if [[ ! -z ${license} ]]
3161		then
3162		echo "      License:  ${license}"
3163		fi
3164		echo "      Depends:  ${deps}"
3165	echo "      SDepends: ${sdeps}"	echo "      SDepends: ${sdeps}"
3166	echo	echo
3167
#	Line 2971  export_inherits()	Line 3201  export_inherits()
3201	eval "${functions}() { ${include}_${functions} ; }"	eval "${functions}() { ${include}_${functions} ; }"
3202
3203	# debug	# debug
3204	[[ ${MAGEDEBUG} = on ]] && typeset -f "${functions}"	mqueryfeature "debug" && typeset -f "${functions}"
3205
3206	shift	shift
3207	done	done
#	Line 3043  EOF	Line 3273  EOF
3273	return 0	return 0
3274	}	}
3275
3276		# need_busybox_support ${cmd}
3277		# return 0 (no error = needs busybox support) or return 1 (error = no busybox support required)
3278		need_busybox_support()
3279		{
3280		local cmd
3281		local busybox
3282		cmd="$1"
3283
3284		for busybox in {,/usr}/bin/busybox
3285		do
3286		if [[ -x ${busybox} ]]
3287		then
3288		if [[ $(readlink $(type -P ${cmd})) = ${busybox} ]]
3289		then
3290		# needs busybox support
3291		return 0
3292		fi
3293		fi
3294		done
3295
3296		# no busybox
3297		return 1
3298		}
3299
3300		# busybox_filter_wget_options ${wget_opts}
3301		busybox_filter_wget_options()
3302		{
3303		local opts="$@"
3304		local i
3305		local fixed_opts
3306
3307		if need_busybox_support wget
3308		then
3309		for i in ${opts}
3310		do
3311		# show only the allowed ones
3312		case ${i} in
3313		-c|--continue) fixed_opts+=" -c" ;;
3314		-s|--spider) fixed_opts+=" -s" ;;
3315		-q|--quiet) fixed_opts+=" -q" ;;
3316		-O|--output-document) shift; fixed_opts+=" -O $1" ;;
3317		--header) shift; fixed_opts+=" --header $1" ;;
3318		-Y|--proxy) shift; fixed_opts+=" -Y $1" ;;
3319		-P) shift; fixed_opts+=" -P $1" ;;
3320		--no-check-certificate) fixed_opts+=" --no-check-certificate ${i}" ;;
3321		-U|--user-agent) shift; fixed_opts+=" -U ${i}" ;;
3322		# simply drop all other opts
3323		*) continue ;;
3324		esac
3325		done
3326
3327		echo "${fixed_opts}"
3328		else
3329		echo "${opts}"
3330		fi
3331		}
3332
3333		have_root_privileges()
3334		{
3335		local retval
3336
3337		if [[ $(id -u) = 0 ]]
3338		then
3339		retval=0
3340		else
3341		retval=1
3342		fi
3343
3344		return ${retval}
3345		}
3346
3347		known_mage_feature()
3348		{
3349		local feature="$1"
3350		local retval
3351
3352		case "${feature}" in
3353		autosvc|!autosvc) retval=0 ;;
3354		buildlog|!buildlog) retval=0 ;;
3355		ccache|!ccache) retval=0 ;;
3356		check|!check) retval=0 ;;
3357		compressdoc|!compressdoc) retval=0 ;;
3358		debug|!debug) retval=0 ;;
3359		distcc|!distcc) retval=0 ;;
3360		icecc|!icecc) retval=0 ;;
3361		kernelsrcunpack|!kernelsrcunpack) retval=0 ;;
3362		libtool|!libtool) retval=0 ;;
3363		linuxsymlink|!linuxsymlink) retval=0 ;;
3364		multilib|!multilib) reval=0 ;;
3365		pkgbuild|!pkgbuild) retval=0 ;;
3366		pkgdistrotag|!pkgdistrotag) retval=0 ;;
3367		pkgmetadata|!pkgmetadata) retval=0 ;;
3368		purge|!purge) retval=0 ;;
3369		qalint|!qalint) retval=0 ;;
3370		regentree|!regentree) retval=0 ;;
3371		resume|!resume) retval=0 ;;
3372		srcpkgbuild|!srcpkgbuild) retval=0 ;;
3373		srcpkgtarball|!srcpkgtarball) retval=0 ;;
3374		static|!static) retval=0 ;;
3375		stepbystep|!stepbystep) retval=0 ;;
3376		strip|!strip) retval=0 ;;
3377		verbose|!verbose) retval=0 ;;
3378		*) retval=1 ;;
3379		esac
3380
3381		return "${retval}"
3382		}
3383
3384		load_mage_features()
3385		{
3386		for i in ${MAGE_FEATURES_GLOBAL[*]} ${MAGE_FEATURES[*]}
3387		do
3388		FVERBOSE=off msetfeature ${i}
3389		done
3390		}
3391
3392		msetfeature()
3393		{
3394		local feature
3395		local count
3396		local i
3397		local found
3398
3399		for feature in $@
3400		do
3401		found=0
3402		count="${#MAGE_FEATURES_CURRENT[*]}"
3403
3404		if ! known_mage_feature "${feature}"
3405		then
3406		[[ ${FVERBOSE} = off ]] || echo -e "${COLRED}Unknown feature '${feature}', ignoring it${COLDEFAULT}"
3407		return 3
3408		fi
3409
3410		for ((i=0; i<count; i++))
3411		do
3412		if [[ ${MAGE_FEATURES_CURRENT[${i}]} = ${feature} ]]
3413		then
3414		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' already enabled${COLDEFAULT}"
3415		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3416		found=1
3417		elif [[ ${MAGE_FEATURES_CURRENT[${i}]} = !${feature} ]]
3418		then
3419		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' currently disabled, enabling it!${COLDEFAULT}"
3420		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3421		found=1
3422		elif [[ ${MAGE_FEATURES_CURRENT[${i}]} = ${feature//!} ]]
3423		then
3424		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature//!}' currently enabled, disabling it!${COLDEFAULT}"
3425		MAGE_FEATURES_CURRENT[${i}]="${feature}"
3426		found=1
3427		fi
3428		done
3429
3430		# if the feature was not found after proccessing the whole array
3431		# it was not declared. in this case enable it
3432		if [[ ${found} = 0 ]]
3433		then
3434		[[ ${FVERBOSE} = off ]] || echo -e "${COLBLUE}---${COLGREEN} Feature '${feature}' was not declared, enabling it!${COLDEFAULT}"
3435		MAGE_FEATURES_CURRENT=( ${MAGE_FEATURES_CURRENT[*]} "${feature}" )
3436		fi
3437
3438		export MAGE_FEATURES_CURRENT
3439		done
3440		}
3441
3442		mqueryfeature()
3443		{
3444		local feature="$1"
3445		local retval=1
3446		local i
3447
3448		if known_mage_feature "${feature}"
3449		then
3450		for i in ${MAGE_FEATURES_CURRENT[*]}
3451		do
3452		if [[ ${i} = ${feature} ]]
3453		then
3454		retval=0
3455		break # found break here
3456		fi
3457		done
3458		else
3459		[[ ${FVERBOSE} = off ]] || echo -e "${COLRED}Unknown feature '${feature}', ignoring it${COLDEFAULT}"
3460		retval=3
3461		fi
3462
3463		return ${retval}
3464		}
3465
3466		mprintfeatures()
3467		{
3468		echo -e "${COLRED}Global features:${COLDEFAULT} ${MAGE_FEATURES_GLOBAL[*]}"
3469		echo -e "${COLYELLOW}Local features:${COLDEFAULT} ${MAGE_FEATURES[*]}"
3470		echo -e "${COLGREEN}Current features:${COLDEFAULT} ${MAGE_FEATURES_CURRENT[*]}"
3471		}

---

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

Legend: Removed from v.1271   changed lines   Added in v.2868