#!/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
			;;
		d | delete)
			action="delete"
			name=$2
			shift
			;;
		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
			;;
		activate) # aktivieren
			action="activate"
			name=$2
			shift
			;;
		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
			clearcache=-c
			;;
		-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
			;;
		-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


getfilelist()
{
	group0=$1
	
	echo > $filelist
	cat $rootpath/etc/apm-sources.list | while read source; do
		source=`eval "echo \"$source\""`
		if [ -z "${source%%http*}" ]; then
			if [ ! -s $onlinecache -o -n "$clearcache" -o -n "`find ${onlinecache%/*} -mmin +60 -name ${onlinecache##*/}`" ]; then
				if [ -n "$verbose" ]; then
					echo "updating online cache"
				fi
				{ sleep 18; touch /tmp/onlineerror; killall wget; } 2>/dev/null &
				pid=$!
				wget $APM_WGET_ARGS "$source" -O "$onlinecache" -q 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.*" >> $filelist
		fi
	done
	
	cat $filelist | sed "s/.*MLD.*_\([^_]*\)_.*_.*\.sfs\|.*/\1/" | sort -u | grep ".\+" > "$filelist.groups"
	
	# 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##*_}
		if [ "${group1%-*}" = "${group0%-*}" ]; then
			echo $group0
		else
			echo $group1
		fi
	done | sort -u | while read group2; do
		# Addons der aktuellen Gruppe mit einer anderen Version aus dem online cache entfernen
		name=${group2%-*}
		grep -v "_${name}-" "$filelist" >> "$filelist.tmp"
		grep "_${group2}_" "$filelist" >> "$filelist.tmp"
		mv -f $filelist.tmp $filelist
	done
}

searchaddonpath()
{
	# prüfen ob nur ein name angegeben wurde
	if [ -n "${addonpath##*gz}" ]; then
		# Nur Addon Name wurde angegeben
		addonpath="`find $pathAddons -maxdepth 1 -regex ".*_${name}\(\.[^-]+\)?-[^_-]*_[^_]*" -printf "%A@\t%p\n" | 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 -e :a -e 's/\(^\|[^0-9]\)\([0-9]\{1,2\}\)\([^0-9]\|$\)/\10\2\3/;ta'`.000
		ver2=`echo $version2 | 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
}


case "$action" in
	install)
		#Addon installieren
		
		# Prüfen ob addon installiert ist
		if [ -e $rootpath/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 "$startstop" ]; then
			eval "$APM_POST_CMD"
		fi

		if [ -n "$newname" ]; then
			echo "$addonpath"
		fi
		;;
	erase)
		# Addon entfernen
		
		# Prüfen ob addon installiert ist
		if [ ! -e $rootpath/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
		
		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

		if [ -n "$startstop" ]; then
			eval "$APM_POST_CMD"
		fi
		;;
	update-all)
		# Alle verfügbaren updates einspielen
		touch $rootpath/var/spool/apm.updatelist
		updates="`$0 list-updates $online $clearcache`"
		
		if [ -n "$updates" -a -n "$BACKUP_ON_APM_UPDATEALL" -a -x "/usr/bin/backup" ]; then
			if [ -z "$quiet" ]; then
				echo "create backup"
			fi
			backup delete "apm-update-all" 2>/dev/null
			backup create "apm-update-all"
		fi
		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
		
		# Prüfen ob addon installiert ist
		if [ -z "`find $pathAddons -maxdepth 1 -regex ".*_$name-[^_-]*_[^_]*"; find $rootpath/boot/ -maxdepth 1 -regex ".*_$name-[^_-]*_[^_]*"`" ]; then
			echo "$base: $name: not installed" >&2
			exit 2
		fi
		
		getfilelist $group

		if [ -z "$group" -a -n "`grep "^$name-" $filelist.groups 2>/dev/null`" ]; then
			# eine Gruppe updaten
			version=`$0 list-updates $online | grep "^$name .*\." | sed "s/.* \(.*\) .*/\1/"`
			if [ -n "$version" ]; then
				if [ -n "$verbose" ]; then
					echo "take version: $version"
				fi
				for addonpath in `find $pathAddons -maxdepth 1 -regex ".*MLD[^_]*_$name-.*\.sfs"; find $rootpath/boot/ -maxdepth 1 -regex ".*MLD[^_]*_$name-.*\.gz"`; do
					if [ -z "$quiet" ]; then
						addon=${addonpath%-*_*}
						addon=${addon##*_}
						echo "update addon: $addon"
					fi
					$0 update $addonpath $online $backup $verbose $quiet --group $name-$version
				done
				exit
			fi
		fi
		
		addonpath=$( 
			grep -e "_$name-[^_-]*_[^_]*$" $filelist | while read addonpath; do
				version=${addonpath%.*}
				version=${version##*_}
				echo $version $addonpath
			done | sort -n | tail -n1 | cut -d " " -f2
		)
		
		if [ -z "$addonpath" ]; then
			echo "$base: $name: can't find addon" >&2
			exit 2
		fi
		
		if [ -e $rootpath/var/spool/apm.updatelist ]; then
			echo $name >> $rootpath/var/spool/apm.updatelist
		fi
		
		if [ -z "$force" -a -n "`find $pathAddons -maxdepth 1 -name "${addonpath##*/}"; find $rootpath/boot/ -maxdepth 1 -name "${addonpath##*/}"`" ]; then
			if [ -z "$quiet" ]; then
				echo "addon is up to date"
			fi
			exit
		fi
		
		if [ -n "$verbose" ]; then
			echo "take addon: $addonpath"
		fi
		
		$0 get "$addonpath" $quiet
		
		addon=${addonpath##*/}
		
		# 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
		
		active="`grep ".*_$name-[^_-]*_[^_]*" $pathAddons/active`"
		if [ -n "$active" ]; then
			# neues Addon aktivieren wenn altes aktiv war
			sed "/_$name-[^-]*_/d" -i $pathAddons/active
			echo $addon >> $pathAddons/active
		fi
		
		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
			# 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" $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##*/}" >&2
			# MD5 File abholen und checken
#			wget $ADDONS_WGET_ARGS $quiet "${addonpath}.md5" -O "/tmp/${addonpath##*/}.md5" >&2
#			if [ -e "/tmp/${addonpath##*/}.md5" ]; then
#				
#			fi
		elif [ -z "${addonpath%%/media/dvd*}" ]; then
			mount /media/dvd
			cp "$addonpath" "$pathAddons/${addonpath##*/}" >&2
			umount /media/dvd
		else
			cp "$addonpath" "$pathAddons/${addonpath##*/}" >&2
		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

		ls $rootpath/var/spool/apm.mnt/
		;;
	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%-*}
			version=${addon##*_}
			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 gruppen (z.B. vdrapi, kernel)
		for group1 in `{ find $pathAddons -maxdepth 1 -regex ".*MLD.*\.sfs"; } | sed "s/.*MLD.*_\(.*\)_.*_.*\.sfs\|.*/\1/" | sort -u`; do
			name1=${group1%-*}
			version1=${group1##*-}
			grep -e "^${name1}-" $filelist.groups | while read group2; do
				version2=${group2##*-}
				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 [ -e "$rootpath/var/spool/apm/$basename" ]; then
			$rootpath/var/spool/apm/$basename depend 2>/dev/null
		else
			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
		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
		;;
	*)
		echo "Usage: $base install NAME [-f] [-d] [-o] [-i] [-s] [-a] [-v] [-q] [--online]"
		echo "       $base erase NAME [-f] [-s] [-v]"
		echo "       $base update NAME [-s] [-b] [-f] [-v] [-q] [--online]"
		echo "       $base update-all [-b] [-v] [-q] [--online]"
		echo "       $base get NAME [-v] [-q]"
		echo "       $base delete NAME [-v] [-q]"
		echo "       $base clearcache"
		echo "       $base list"
		echo "       $base list-all [-g GROUP] [--online]"
		echo "       $base list-updates [--online]"
		echo "       $base list-available"
		echo "       $base list-active"
		echo "       $base list-inactive"
		echo "       $base search NAME [--online]"
		echo "       $base dep-off NAME"
		echo "       $base dep-on NAME [-o]"
		echo "       $base test NAME [-o]"
		echo "       $base activate NAME [-i]"
		echo "       $base deactivate NAME [-i]"
		echo "       $base basename NAME"
		echo "       $base info NAME [-o] [-q]"
		echo "       $base activepath"
		echo "       $base inactivepath"
		echo "  i, install         install addon NAME or FILE or URL"
		echo "      -f             force install, ignore dependencies"
		echo "      -d             don't solve dependencies"
		echo "      -o, --offline  solve dependencies only offline"
		echo "      --online       only online"
		echo "      -i, --ignore   ignore if addon is already installed"
		echo "      -s, --start    run start script"
		echo "      -a, --activate activate addon after install"
		echo "      -v             be verbose"
		echo "      -q, --quiet    be quiet"
		echo "  e, erase           erase addon NAME"
		echo "      -d             don't solve dependencies"
		echo "      -s, --stop     run stop script"
		echo "      -v             be verbose"
		echo "  u, update          update addon NAME from online"
		echo "      --online       only online"
		echo "      -s, --switch   switch to new addon after update"
		echo "      -b, --backup   make backup of old addons"
		echo "      -f             force update, ignore installed version"
		echo "      -v             be verbose"
		echo "      -q, --quiet    be quiet"
		echo "  ua, update-all     take all available updates"
		echo "      --online       only online"
		echo "      -b, --backup   make backup of old addons"
		echo "      -v             be verbose"
		echo "      -q, --quiet    be quiet"
		echo "  g, get             get addon of NAME or URL from online"
		echo "      -v             be verbose"
		echo "      -q, --quiet    be quiet"
		echo "  d, delete          delete addon NAME"
		echo "      -q, --quiet    be quiet"
		echo "  clearcache         clear online cache"
		echo "  l, list            list installed addons"
		echo "  lv, list-versions  list version of local available addons"
		echo "  la, list-all       list all addons (online and offline)"
		echo "      --online       only online"
		echo "      -g, --group    only addons of addon group GROUP"
		echo "  lu, list-updates   list all addons and groups for that updates available"
		echo "      --online       only online"
		echo "  list-available     list all local addons witch are not installed"
		echo "  list-active        list on boot time activated addons"
		echo "  list-inactive      list on boot time not activated addons"
		echo "  s, search          search for addons with NAME as part of addon name"
		echo "      --online       only online"
		echo "  dep-off            list installed addons that need the addon NAME"
		echo "  dep-on             list addons that must be installed to install NAME"
		echo "      -o, --offline  solve dependencies only offline"
		echo "  t, test            test if depending of addon NAME or FILE are complied with"
		echo "      -o, --offline  solve dependencies only offline"
		echo "  activate           activate addon on next boot process"
		echo "      -i, --ignore   ignore if addon is already activated"
		echo "  deactivate         deactivate addon on next boot process"
		echo "      -i, --ignore   ignore if addon is already deactivated"
		echo "  info               Informations about the addon NAME"
		echo "      -o, --offline  solve dependencies only offline"
		echo "      -q, --quiet    be quiet, dont show the readme, only put it in the doc folder"
		echo "  basename           returns the basename of the given addon NAME or FILE or URL"
		echo "  addonpath          returns the path of active addons"
		exit 1
esac