#!/bin/sh
#
# Addon Packet Manager (apm) - (De)Installiert Addons
# Developer: Claus Muus
# License: GPL2

# for debugging only
#rootpath="."

. $rootpath/etc/rc.config

base=${0##*/}
pathAddons="$rootpath/etc/addons"
onlinecache="$rootpath/var/spool/apm.onlinecache"
filelist="$rootpath/var/spool/apm.filelist"


while [ $# != 0 ]; do
	case "$1" in
		i | install)
			action="install"
			name=$2
			shift
			;;
		e | erase)
			action="erase"
			name=$2
			shift
			;;
		u | update)
			action="update"
			name=$2
			shift
			;;
		ua | update-all)
			action="update-all"
			;;
		g | get)
			action="get"
			name=$2
			shift
			;;
		del | delete)
			action="delete"
			name=$2
			shift
			;;
		cc | clearcache)
			action="clearcache"
			;;
		l | list) # list installed
			action="list"
			;;
		lv | list-versions)
			action="list-versions"
			;;
		la | list-all)
			action="list-all"
			;;
		lu | list-updates)
			action="list-updates"
			;;
		list-available)
			action="list-available"
			;;
		list-inactive)
			action="list-inactive"
			;;
		list-active)
			action="list-active"
			;;
		dep-off)
			action="dep-off"
			name=$2
			shift
			;;
		dep-on)
			action="dep-on"
			name=$2
			shift
			;;
		t | test)
			action="test"
			name=$2
			shift
			;;
		s | search)
			action="search"
			search=$2
			shift
			;;
		a | activate) # aktivieren
			action="activate"
			name=$2
			shift
			;;
		d | deactivate) # deaktivieren
			action="deactivate"
			name=$2
			shift
			;;
		info) # Get and Returns the readme file
			action="info"
			name=$2
			shift
			;;
		basename)
			action="basename"
			name=$2
			shift
			;;
		addonpath)
			echo $pathAddons;
			exit;
			;;
		-f | --force) # force (ignore dependencies)
			force=-f
			;;
		-s | --start | --stop | --switch) # run start / stop script
			startstop=-s
			;;
		-c | --clear) # clear online cache
			$0 clearcache
			;;
		-d) # don't solve dependencies
			dontsolve=-d
			;;
		-b | --backup) # make backup befor update
			backup=-b
			;;
		-o | --offline) # solve dependencies only offline (from installed addons)
			offline=--offline
			;;
		--online) # only online
			online=--online
			;;
		-i | --ignore) #  ignore if already installed
			ignore=-i
			;;
		-a | --activate) # aktivieren
			activate=-a
			;;
		-l | --long) # be quiet
			long=-l
			;;
		-q | --quiet) # be quiet
			quiet=-q
			;;
		-v | --verbose) # be verbose
			verbose=-v
			;;
		-n | --newname) # return new addon name
			newname=-n
			;;
		-p | --parents) # parent dependenies
			parents="$2"
			shift
			;;
		-g | --group)
			group=$2
			shift
			;;
		--nogroup) # don't update groups
			nogroup=1
			;;
		-h | --help)
			action="help"
			;;
		*) # invalid opption
			echo "$base: invalid option: $1" >&2
			action="help"
			;;
	esac
	shift 2>/dev/null
	if [ $? != 0 ]; then
		echo "$base: option requires for argument '$1'";
	fi
done


addonpath=$name
addon=${name##*/}
name=${addon%-*_*}
name=${name##*_}
basename=${name%.*}


mkdir -p $rootpath/var/spool/apm
mkdir -p $rootpath/var/spool/apm.mnt


help()
{
	cat <<- EOF
	Usage: $base install NAME [-f] [-d] [-o] [-i] [-s] [-a] [-v] [-q] [--online]
	       $base erase NAME [-f] [-d] [-s] [-v]
	       $base update NAME [-s] [-b] [-f] [-v] [-q] [--online]
	       $base update-all [-b] [-v] [-q] [--online]
	       $base get NAME [-v] [-q]
	       $base delete NAME [-v] [-q]
	       $base clearcache
	       $base list
	       $base list-versions [-l]
	       $base list-all [-g GROUP] [--online]
	       $base list-updates [--online]
	       $base list-available
	       $base list-active
	       $base list-inactive
	       $base search NAME [--online]
	       $base dep-off NAME
	       $base dep-on NAME [-o]
	       $base test NAME [-o]
	       $base activate NAME [-i]
	       $base deactivate NAME [-i]
	       $base basename NAME
	       $base info NAME [-o] [-q]
	       $base activepath
	       $base inactivepath
	  i, install         install addon NAME or FILE or URL
	      -f             force install, ignore dependencies
	      -d             don't solve dependencies
	      -o, --offline  solve dependencies only offline
	      --online       only online
	      -i, --ignore   ignore if addon is already installed
	      -s, --start    run start script
	      -a, --activate activate addon after install
	      -v             be verbose
	      -q, --quiet    be quiet
	  e, erase           erase addon NAME
	      -d             don't solve dependencies
	      -s, --stop     run stop script
	      -f             force erase, kill all dependent processes
	      -v             be verbose
	  u, update          update addon NAME from online
	      --online       only online
	      -s, --switch   switch to new addon after update
	      -b, --backup   make backup of old addons
	      -f             force update, ignore installed version
	      -v             be verbose
	      -q, --quiet    be quiet
	  ua, update-all     take all available updates
	      --online       only online
	      -b, --backup   make backup of old addons
	      -v             be verbose
	      -q, --quiet    be quiet
	  g, get             get addon of NAME or URL from online
	      -v             be verbose
	      -q, --quiet    be quiet
	  del, delete          delete addon NAME
	      -q, --quiet    be quiet
	  cc, clearcache     clear online cache
	  l, list            list installed addons
	  lv, list-versions  list version of local available addons
	  la, list-all       list all addons (online and offline)
	      --online       only online
	      -g, --group    only addons of addon group GROUP
	  lu, list-updates   list all addons and groups for that updates available
	      --online       only online
	  list-available     list all local addons witch are not installed
	  list-active        list on boot time activated addons
	  list-inactive      list on boot time not activated addons
	  s, search          search for addons with NAME as part of addon name
	      --online       only online
	  dep-off            list installed addons that need the addon NAME
	  dep-on             list addons that must be installed to install NAME
	      -o, --offline  solve dependencies only offline
	  t, test            test if depending of addon NAME or FILE are complied with
	      -o, --offline  solve dependencies only offline
	  a, activate           activate addon on next boot process
	      -i, --ignore   ignore if addon is already activated
	  d, deactivate         deactivate addon on next boot process
	      -i, --ignore   ignore if addon is already deactivated
	  info               Informations about the addon NAME
	      -o, --offline  solve dependencies only offline
	      -q, --quiet    be quiet, dont show the readme, only put it in the doc folder
	  basename           returns the basename of the given addon NAME or FILE or URL
	  addonpath          returns the path of active addons
	EOF
}

getfilelist()
{
	group0=$1
	
	if [ ! -s $onlinecache -o -n "`find ${onlinecache%/*} -mmin +60 -name ${onlinecache##*/}`" -o /etc/apm-sources.list -nt $onlinecache ]; then
		updatecache=1
		rm -f $onlinecache
		if [ -n "$verbose" ]; then
			echo "updating online cache"
		fi
	fi

	echo > $filelist
	cat $rootpath/etc/apm-sources.list | while read source; do
		source=`eval "echo \"$source\""`
		if [ -z "${source%%http*}" ]; then
			if [ -n "$updatecache" ]; then
				{ sleep 18; touch /tmp/onlineerror; killall wget; } 2>/dev/null &
				pid=$!
				wget $APM_WGET_ARGS "$source" -q -O - >>$onlinecache 2>/dev/null
				kill $pid 2>/dev/null
				if [ -e /tmp/onlineerror -a -z "$quiet" ]; then
					echo "$base: No online connection or timeout to: $source" >&2
				fi
				rm -f /tmp/onlineerror
			fi
			cat $onlinecache >> $filelist 2>/dev/null
		elif [ -z "${source%%/media/dvd*}" -a -z "$online" ]; then
			mount /media/dvd 2>/dev/null
			find $source -maxdepth 1 -regex ".*MLD.*" 2>/dev/null >> $filelist
			umount /media/dvd 2>/dev/null
		elif [ -n "${source%%#*}" -a -z "$online" ]; then
			find $source -maxdepth 1 -regex ".*MLD.*" 2>/dev/null >> $filelist
		fi
	done
	
	cat $filelist | sed "s/.*MLD.*_\([^_]*\)_.*_.*\.sfs\|.*/\1/" | sort -u | grep ".\+" > "$filelist.groups"
	
	if [ -n "$group0" ]; then
		# nur addons der gewählten Gruppe
		grep "_${group0}_" "$filelist" >> "$filelist.tmp"
		mv -f $filelist.tmp $filelist
	else
		# bei installierten Gruppen, Addons mit anderer Gruppen Version aussortieren
		for addonpath in `find $pathAddons -maxdepth 1 -regex ".*MLD.*_.*_.*_.*\.sfs"`; do
			# alle local installierten Gruppen durchlaufen
			addon=${addonpath##*/}
			group1=${addon%_*_*}
			group1=${group1##*_}
			echo $group1
		done | sort -ur | while read group2; do
			# Addons der aktuellen Gruppe mit einer anderen Version aus dem online cache entfernen
			name=${group2%-*}
			if [ "$lastname" != "$name" ]; then
				grep -v "_${name}-.*_.*_" "$filelist" >> "$filelist.tmp"
				grep "_${group2}_.*_" "$filelist" >> "$filelist.tmp"
				mv -f $filelist.tmp $filelist
				lastname=$name
			fi
		done
	fi
	# only for renaiming of vdrapi to vdr
	if ! ls $pathAdons | grep -q vdrapi ; then
		sed "/_vdrapi-/d" -i $filelist
	fi
}

searchaddonpath()
{
	# prüfen ob nur ein name angegeben wurde
	if [ -n "${addonpath##*_*}" ]; then
		# Nur Addon Name wurde angegeben
		addonpath="`find $pathAddons -maxdepth 1 -regex ".*_${name}\(\.[^-]+\)?-[^_-]*_[^_]*" -printf "%A@\t%p\n" | grep -v ".part" | sort | cut -f2 | tail -n1`"
		if [ -z "$addonpath" -a "$1" != "--offline" -o "$1" = "--online" ]; then
			getfilelist
			addonpath=$( 
				grep -e "_${name}\(\.[^-]\+\)\?-[^_-]*_[^_]*$" $filelist | while read addonpath; do
					version=${addonpath%.*}
					version=${version##*_}
					echo $version $addonpath
				done | sort -n | tail -n1 | cut -d " " -f2
			)
		fi
		addon=${addonpath##*/}
		search=1
	elif [ "$addonpath" = "$addon" ]; then
		# Exakter Addon Dateiname wurde angegeben
		addonpath="`find $pathAddons -maxdepth 1 -name "$addon" -printf "%A@\t%p\n" | sort | cut -f2 | tail -n1`"
		if [ -z "$addonpath" -a "$1" != "--offline" -o "$1" = "--online" ]; then
			getfilelist
			addonpath="`grep "$addon" $filelist | tail -n1`"
		fi
		search=1
	fi
	if [ "$search" = 1 -a -n "$addonpath" -a -n "$verbose" ]; then
		echo "take Addon: $addonpath"
	fi
}

uniquesort()
{
	mkdir -p /tmp/apm.usort
	while read line; do
		name=${line%% *}
		version1=${line#* }
		version1=${version1%% *}
		version2=${line#* * }
		version2=${version2%% *}
		ver1=`echo $version1 | sed "s/\(.*\)_\(.*\)/\2_\1/" | sed -e :a -e 's/\(^\|[^0-9]\)\([0-9]\{1,2\}\)\([^0-9]\|$\)/\10\2\3/;ta'`.000
		ver2=`echo $version2 | sed "s/\(.*\)_\(.*\)/\2_\1/" | sed -e :a -e 's/\(^\|[^0-9]\)\([0-9]\{1,2\}\)\([^0-9]\|$\)/\10\2\3/;ta'`.000
		echo "$name $version1 $version2 $ver1 $ver2" >> /tmp/apm.usort/$name
	done
	for name in `ls /tmp/apm.usort`; do
		line=`cat /tmp/apm.usort/$name | sort -uk 4,5 | tail -n 1`
		ver1=${line% *}
		ver1=${ver1##* }
		ver2=${line##* }
		if expr "$ver1" ">" "$ver2" >/dev/null; then
			echo ${line% * *}
		fi
	done
	rm -r /tmp/apm.usort
}

service()
{
	if [ $(ps | grep " $0" | grep -v grep | wc -l) = 2 ]; then
		if [ -n "$verbose" ]; then
			echo "run $1 processing scripts:"
		fi
		for script in `cd /etc/apm.d/; ls 2>/dev/null | sort`; do
			quiet=$quiet verbose=$verbose /etc/apm.d/$script $1 $2 
		done
	fi
}


service pre $action

case "$action" in
	install)
		#Addon installieren
		
		# Prüfen ob addon installiert ist
		if mount | grep -q " /var/spool/apm.mnt/$basename "; then
			if [ -n "$ignore" ]; then
				exit
			fi
			echo "$base: $basename: already installed. Remove it first" >&2
			exit 2
		fi
		
		searchaddonpath $offline
		
		# Prüfen ob addon existiert
		if [ -z "$addonpath" ]; then
			echo "$base: $name: No such addon" >&2
			exit 2
		fi

		if [ -n "${addonpath%%$pathAddons*}" ]; then
			$0 get "$addonpath" $quiet
			# localen Pfad suchen
			addonpath=${addonpath##*/}
			searchaddonpath --offline
		fi
		
		# Prüfen ob addonfile existiert
		if [ ! -f "$addonpath" ]; then
			echo "$base: $addonpath: No such file" >&2
			exit 2
		fi
		
		if [ "$name" = "kernel" -o "$name" = "initramfs"  ]; then
			if [ -z "$quiet" ]; then
				echo "install: $name"
			fi
			
			old=`ls -l $rootpath/boot/$name | sed "s/.*-> //" | grep MLD`
			mv $pathAddons/$addon $rootpath/boot/
			ln -fs $addon $rootpath/boot/$name
			if [ -n "$old" -a "$addon" != "$old" ]; then
				rm -f "$rootpath/boot/$old"
			fi
		
		else
			# Addons
			
			# abhaengigkeiten aufloesen
			if [ -z "$dontsolve" -a -n "`$0 test $addonpath $offline`" ]; then
				$0 test $addonpath $offline | sed "s/ or / /g" | while read deps; do
					for dep in $deps; do
						if [ -n "$parents" -a -z "${parents##* $dep *}" ]; then
							echo "$base: interdependency detected in: $dep and $name" >&2
							force=-f
							dontsolve=-d
						fi
						$0 install "$dep" $online $ignore $activate $startstop $force $dontsolve $offline $quiet $verbose $newname --parents "$parents $name " && break
					done
				done
			fi
			
			if [ -n "$activate" ]; then
				$0 activate ${addonpath##*/}
				# localen Pfad suchen
				addonpath=${addonpath##*/}
				searchaddonpath --offline
			fi
		
			# Prüfen ob Abhängigkeiten erfüllt sind
			if [ -z "$force" -a  -n "`$0 test $addonpath $offline`" ]; then
				echo "$base: $basename: dependencies are not fulfilled. Install first:" >&2
				$0 test $addonpath $offline | tee $rootpath/var/spool/apm.depend | sed "s/^/    /g"
				exit 2
			fi
		
			if [ -z "$quiet" ]; then
				echo "install addon: $name"
			fi
		
			# installieren
			mkdir -p $rootpath/var/spool/apm.mnt/$basename
			mount $addonpath $rootpath/var/spool/apm.mnt/$basename -t squashfs -o loop
			mount -o remount,append:$rootpath/var/spool/apm.mnt/$basename /
			test -e $rootpath/var/spool/apm.mnt/$basename/lib/modules && depmod
			ldconfig.sh
			
			if [ -e $rootpath/var/spool/apm/$basename ]; then
				$rootpath/var/spool/apm/$basename install
			fi
									
			if [ -n "$startstop" -a -e $rootpath/etc/init.d/$basename ]; then
				start $basename
			fi
		fi

		if [ -n "$newname" ]; then
			echo "$addonpath"
		fi
		;;
	erase)
		# Addon entfernen
		
		# Prüfen ob addon installiert ist
		if ! mount | grep -q " /var/spool/apm.mnt/$basename "; then
			echo "$base: $basename: not installed" >&2
			exit 2
		fi

		# abhängige Addons löschen
		if [ -z "$dontsolve" -a -n "`$0 dep-off $basename`" ]; then
			$0 dep-off $basename | while read dep; do
				$0 erase "$dep" $startstop $verbose
			done
		fi

		if [ -n "$verbose" ]; then
			echo "erase addon: $basename"
		fi
		
		# addon stoppen
		if [ -n "$startstop" -a -e $rootpath/etc/init.d/$basename ]; then
			stop $basename
		fi

		# addon deinstallieren
		if [ -e $rootpath/var/spool/apm/$basename ]; then
			$rootpath/var/spool/apm/$basename uninstall
		fi
		
		# kill all dependent processes
		if [ -n "$force" ]; then
			pids="`lsof 2>/dev/null | grep /var/spool/apm.mnt/$basename | sed "s/\S\+\s\+\(\S\+\).*/\\1/" | uniq`"
			if [ -n "$pids" ]; then
				kill -9 $pids
			fi
		fi
		
		if ! mount -o remount,del:$rootpath/var/spool/apm.mnt/$basename /; then
			echo "$base: $basename: uninstall failed" >&2
			exit 3
		fi
		test -e $rootpath/var/spool/apm.mnt/$basename/lib/modules && depmod
		umount $rootpath/var/spool/apm.mnt/$basename
		rmdir $rootpath/var/spool/apm.mnt/$basename
		;;
	update-all)
		# Alle verfügbaren updates einspielen
		touch $rootpath/var/spool/apm.updatelist
		updates="`$0 list-updates $online`"
		
		echo "$updates" | while read update; do
			name=${update%% *}
			if [ -n "$name" -a -z "`grep $name $rootpath/var/spool/apm.updatelist`" ]; then
				if [ -z "$quiet" ]; then
					echo "update addon: $name"
				fi
				$0 update $online $name $backup $verbose $quiet
				touch $rootpath/var/spool/apm.update
			fi
		done
		rm $rootpath/var/spool/apm.updatelist
		if [ -e $rootpath/var/spool/apm.update ]; then
			rm $rootpath/var/spool/apm.update
		else
			echo "$base: no updates available"
		fi
		;;
	update)
		# Update eines Addons
		
		oldaddonpath=$(find $pathAddons -maxdepth 1 -regex ".*_$name-[^_-]*_[^_]*\.sfs"; find $rootpath/boot/ -maxdepth 1 -regex ".*_$name-[^_-]*_[^_]*\.gz")
		
		# Prüfen ob addon installiert ist
		if [ -z "$oldaddonpath" ]; then
			echo "$base: $name: not installed" >&2
			exit 2
		fi
		
		getfilelist $group
		
		newaddonpath=$( 
			grep -e "_$name-[^_-]*_[^_]*$" $filelist | while read addonpath; do
				version=${addonpath%.*}
				version=${version##*-}
				version=`echo $version | sed "s/\(.*\)_\(.*\)/\2_\1/" | sed -e :a -e 's/\(^\|[^0-9]\)\([0-9]\{1,2\}\)\([^0-9]\|$\)/\10\2\3/;ta'`.000
				echo $version $addonpath
			done | sort | tail -n1 | cut -d " " -f2
		)

		if [ -z "$newaddonpath" ]; then
			echo "$base: $name: can't find addon" >&2
			exit 2
		fi

		if [ -z "$group" -a -n "`grep "^$name-" $filelist.groups 2>/dev/null`" ]; then
			# eine Gruppe updaten
			oldgroup=${oldaddonpath%_*}
			oldgroup=${oldgroup##*_}
			newgroup=${newaddonpath%_*}
			newgroup=${newgroup##*_}
			if [ "$oldgroup" != "$newgroup" ]; then
				if [ -n "$verbose" ]; then
					echo "take group: $newgroup"
				fi
				for addonpath in `find $pathAddons -maxdepth 1 -regex ".*MLD[^_]*_$name\(api\)?-.*_.*_.*\.sfs"`; do
					if [ -z "$quiet" ]; then
						addon=${addonpath%-*_*}
						addon=${addon##*_}
						echo "update addon: $addon"
					fi
					$0 update $addonpath --force $online $backup $verbose $quiet --group $newgroup
				done
			fi
		fi
		
		if [ -z "$force" -a -n "`find $pathAddons -maxdepth 1 -name "${newaddonpath##*/}"; find $rootpath/boot/ -maxdepth 1 -name "${newaddonpath##*/}"`" ]; then
			if [ -z "$quiet" ]; then
				echo "addon is up to date"
			fi
			exit
		fi
		
		if [ -n "$verbose" ]; then
			echo "take addon: $newaddonpath"
		fi
		
		$0 get "$newaddonpath" $quiet

		addon=${newaddonpath##*/}
		
		# alte Addons löschen
		for addonpath in `find $pathAddons -maxdepth 1 -regex ".*_$name-[^_-]*_[^_]*"`; do
			if [ "${addonpath##*/}" != "$addon" ]; then
				if [ -n "$backup" ]; then
					mkdir -p $pathAddons/backup/
					mv "$addonpath" $pathAddons/backup/
				else
					rm "$addonpath"
				fi
			fi
		done
		
		if [ "$name" = "kernel" -o "$name" = "initramfs" ]; then
			old=`ls -l $rootpath/boot/$name | sed "s/.*-> //" | grep MLD`
			mv $pathAddons/$addon $rootpath/boot/
			ln -fs $addon $rootpath/boot/$name
			if [ -n "$old" -a "$addon" != "$old" ]; then
				if [ -n "$backup" ]; then
					mkdir -p $pathAddons/backup/
					mv "$rootpath/boot/$old" $pathAddons/backup/
				else
					rm "$rootpath/boot/$old"
				fi
			fi
		else
			# neues Addon aktivieren wenn altes aktiv war
			activate="`grep -q ".*_$name-[^_-]*_[^_]*" $pathAddons/active && echo '-a'`"
			if [ -n "$activate" ]; then
				sed "/_$name-[^-_]*_[^_]*$/d" -i $pathAddons/active
				echo $addon >> $pathAddons/active
			fi
		
			# abhaengigkeiten aufloesen
			if [ -z "$dontsolve" -a -n "`$0 test $addon $offline`" ]; then
				$0 test $addon $offline | sed "s/ or / /g" | while read deps; do
					for dep in $deps; do
						$0 install "$dep" $activate $startstop $offline $quiet $verbose && break
					done
				done
			fi
			
			#if [ -n "$startstop" -a "${group%%-*}" != "kernel" ]; then
			#	# Updates der Kernel Gruppe ignorieren, alle anderen neu installieren
			#	if [ -e "$rootpath/var/spool/apm.mnt/$basename" ]; then
			#		$0 erase $name -s -d
			#		$0 install $name -s
			#	fi
			#fi
		fi
		
		if [ -n "$newname" ]; then
			echo "$pathAddons/$addon"
		fi
		;;
	get)
		# Datei von online downloaden
		
		searchaddonpath --online
		echo $addonpath > $rootpath/var/spool/apm.wget
		
		if [ -z "$quiet" ]; then
			echo "get addon: $name"
		fi

		if [ -z "${addonpath%%http*}" ]; then
			wget $ADDONS_WGET_ARGS $quiet "$addonpath" -O "$pathAddons/${addonpath##*/}.part" >&2 && mv -f "$pathAddons/${addonpath##*/}.part" "$pathAddons/${addonpath##*/}"
		elif [ -z "${addonpath%%/media/dvd*}" ]; then
			mount /media/dvd
			cp "$addonpath" "$pathAddons/${addonpath##*/}.part" >&2 && mv -f "$pathAddons/${addonpath##*/}.part" "$pathAddons/${addonpath##*/}"
			umount /media/dvd
		else
			cp "$addonpath" "$pathAddons/${addonpath##*/}.part" >&2 && mv -f "$pathAddons/${addonpath##*/}.part" "$pathAddons/${addonpath##*/}"
		fi
		;;
	delete)
		# Datei löschen

		searchaddonpath --offline
		# Prüfen ob addon installiert ist
		if [ -z "$addonpath" ]; then
			echo "$base: $basename: not found" >&2
			exit 2
		fi
		
		if [ -z "$quiet" ]; then
			echo "delete addon: $addon"
		fi
		rm $addonpath
		sed "/$addon/d" -i $pathAddons/active
		;;
	clearcache)
		# online Cache löschen
	
		rm -f $onlinecache
		;;
	list)
		# alle installierten Addons auflisten

		mount | grep /apm.mnt/ | sed "s|.*/\(\S\+\).*|\\1|"
		;;
	list-versions)
		# versionen der local verfügbaren Addons
		
		for addon in `{ find $rootpath/boot/ -maxdepth 1 -regex ".*MLD.*\.gz"; find $pathAddons -maxdepth 1 -regex ".*MLD.*\.sfs"; } | sed "s/.*MLD.*_\(.*_.*\)\.\(gz\|sfs\)\|.*/\1/"`; do
			name=${addon%-*}
			if [ -z "long" ]; then
				version=${addon##*_}
			else
				version=${addon##*-}
			fi
			echo -e "$name\t$version"
		done
		;;
	list-available)
		# all local addons witch are not installed
		
		installed=`apm list`
		for addonpath in `{ find $pathAddons -maxdepth 1 -name "MLD*.sfs"; } | sort -u`; do
			name=${addonpath%-*_*}
			name=${name##*_}
			name=${name%.*}
			if [ -z "`echo "$installed" | grep "^$name$"`" ]; then
				if [ -n "$newname" ]; then
					echo -e "$name\t$addonpath"
				else
					echo "$name"
				fi
			fi
		done
		;;
	list-active)
		# Aktive Addons auflisten
		
		for addon in `cat $pathAddons/active | sort -u`; do
			name=${addon%-*_*}
			name=${name##*_}
			name=${name%.*}
			if [ -n "$newname" ]; then
				echo -e "$name\t$pathAddons/$addon"
			else
				echo "$name"
			fi
		done
		;;
	list-inactive)
		# Inaktive Addons auflisten
		
		for addonpath in `find $pathAddons -maxdepth 1 -name "MLD*.sfs" | sort -u`; do
			if [ -z "`grep ${addonpath##*/} $pathAddons/active`" ]; then
				name=${addonpath%-*_*}
				name=${name##*_}
				name=${name%.*}
				if [ -n "$newname" ]; then
					echo -e "$name\t$addonpath"
				else
					echo "$name"
				fi
			fi
		done
		;;
	list-all)
		# alle verfügbaren Addons auflisten
		
		getfilelist
		if [ -n "$group" ]; then
			group=".*_$group\-.*_.*_"
		fi
		for addonpath in `find $pathAddons -maxdepth 1 -regex ".*MLD$group.*\.sfs"; grep -e "MLD$group.*\.sfs$" $filelist`; do
			addon=${addonpath##*/}
			name=${addon%-*_*}
			name=${name##*_}
			version=${addon%.*}
			version=${version##*_}
			echo "$name $version"
		done | sort -urk 1,1 | sort
		;;
	list-updates)
		# list all available updates (name new-version old-version)
		
		getfilelist
		
		# Updates zu initramfs und Kernel
		for addon1 in `find $rootpath/boot/ -maxdepth 1 -regex ".*MLD.*\.gz" | sed "s/.*MLD.*_\(.*_.*\)\.gz\|.*/\1/"`; do
			name1=${addon1%-*}
			version1=${addon1##*-}
			grep -e "_${name1}-[^_-]*_[^_]*$" $filelist | while read addonpath2; do
				version2=${addonpath2%.*}
				version2=${version2##*-}
				echo "$name1 $version2 $version1"
			done
		done | uniquesort
		# Updates zu addons	
		for addon1 in `find $pathAddons -maxdepth 1 -regex ".*MLD.*\.sfs" | sed "s/.*MLD.*_\(.*_.*\)\.sfs\|.*/\1/"`; do
			name1=${addon1%-*}
			version1=${addon1##*-}
			grep -e "_${name1}-[^_-]*_[^_]*$" $filelist | while read addonpath2; do
				version2=${addonpath2%.*}
				version2=${version2##*-}
				echo "$name1 $version2 $version1"
			done
		done | uniquesort
		;;
	search)
		# Addon suchen
		
		find $pathAddons -maxdepth 1 -regex ".*$search[^_]*_[^_]*" -printf "%A@\t%p\n" | sort | cut -f2
		getfilelist
		grep -e "$search[^_]*_[^_]*$" $filelist
		;;
	dep-off)
		# alle Installierten Addons die das angegebene Adon benötigen auflisten

		for addon in $rootpath/var/spool/apm/*; do 
			test -f "$addon" && $addon depend | grep -q "^$basename$" && echo ${addon##*/}
		done
		;;
	dep-on)
		# abhängigkeiten prüfen
		
		searchaddonpath $offline

		if [ -f "$addonpath" ]; then
			mkdir -p $rootpath/var/spool/apm.mnt/$basename.$$
			mount $addonpath $rootpath/var/spool/apm.mnt/$basename.$$ -t squashfs -o loop
			if [ -e "$rootpath/var/spool/apm.mnt/$basename.$$/var/spool/apm/$basename" ]; then
				$rootpath/var/spool/apm.mnt/$basename.$$/var/spool/apm/$basename depend
			fi
			umount $rootpath/var/spool/apm.mnt/$basename.$$
			rmdir $rootpath/var/spool/apm.mnt/$basename.$$
		else
			echo "$base: $basename: addon not found" >&2
			exit 2
		fi
		;;
	test)
		# Prüft ob alle für das angegebene Addon benötigten addons installiert sind
		
		list=`$0 list`
		depend="`$0 dep-on "$addonpath" $offline`"
		state=$?
		
		if [ -n "$depend" ]; then
			for addons in $depend; do
				addon=`echo "$addons" | sed "s/\.[^|]*//g"`
				addon=`echo "$addon" | sed "s/|/\$\\\\\|^/g"`
				if [ -z "`echo "$list" | grep "^$addon$"`" ]; then
					echo -e "$addons" | sed "s/|/ or $rootpath/g"
					state=2
				fi
			done
			exit $state
		fi
		;;
	activate)
		# aktivieren
		addonpath="`find $pathAddons -maxdepth 1 -regex ".*_$name-[^_-]*_[^_]*" | sort | tail -n1`"
		
		if [ -z "$addonpath" ]; then
			if [ -n "$ignore" ]; then
				exit
			fi
			echo "$base: $name: can't find inactive addon" >&2
			exit 2
		fi
		
		addon=${addonpath##*/}
		if [ -z "`grep $addon $pathAddons/active`" ]; then
			echo $addon >> $pathAddons/active
		fi
		
		if [ -n "$newname" ]; then
			echo "$addon"
		fi
		;;
	deactivate)
		# deaktivieren
		addon="`grep ".*_$name-[^_-]*_[^_]*" $pathAddons/active | sort | tail -n1`"
		
		if [ -z "$addon" ]; then
			if [ -n "$ignore" ]; then
				exit
			fi
			echo "$base: $name: can't find active addon" >&2
			exit 2
		fi
		
		sed "/$addon/d" -i $pathAddons/active
		
		if [ -n "$newname" ]; then
			echo "$addon"
		fi
		;;
	basename)
		echo $basename;
		;;
	info)
		if [ -z "`find /usr/share/doc/$name -name readme 2>/dev/null`" ]; then
			searchaddonpath $offline
			
			if [ -z "${addonpath%%http*}" ]; then
				# von online
				mkdir -p /usr/share/doc/$name
				cat $rootpath/etc/apm-sources.list | grep -e "^http" | while read source; do
					source=`eval "echo \"$source\""`
					wget $APM_WGET_ARGS "$source&readme=$name" -O "/usr/share/doc/$name/readme" -q
					if [ -s "/usr/share/doc/$name/readme" ]; then
						break
					fi
				done
			else
				# bereits installiert
				tar -xzf "$addonpath" -C $rootpath/ usr/share/doc/$name/readme 2>/dev/null
			fi
		fi
		
		if [ -z "$quiet" -a -e /usr/share/doc/$name/readme ]; then
			cat /usr/share/doc/$name/readme
			echo
		fi
		;;
	help)
		help
		;;
	*)
		help >&2
		exit 1
		;;
esac

service post $action