Settings über eigenen Server laden möglich

#!/bin/sh
#
# Updatepruefung Senderliste und Scripte 
# 
# 
# Version 1.0


# Benutzername zum Zugriff auf Setting Ordner am Webserver
USERBQ="receiver"


# Passwort zum Zugriff auf Setting Ordner am Webserfer
PASSBQ="passwort"


# Die SERVERurl auf die Adresse eures Webservers umändern
SERVERurl="http://test-line.de"


# Script Ordner
Scriptdir="/usr/sbin"


# Ordner für Apps - damit diese unter Menü/Erweiterungen angezeigt werden
menuedir="/usr/lib/enigma2/python/Plugins/Extensions"


# Die Scripte sind in einem tar.bz2 Archiv hier Namen angeben
scriptetargz="scripte.tar.bz2"


# Die Apps sind in einem tar.bz2 Archiv hier Namen angeben
appstargz="apps.tar.bz2"


# Datei mit der Zeit die vom Server geladen wird
BQlist="list_bq.txt"
STscripte="time_scripte.txt"
STbq="time_bq.txt"
STapps="time_apps.txt"


# timelu***.txt, die auf dem Receiver gespeichert ist/wird
BQversion="version_bq.txt"
TLscripte="timelu_scripte.txt"
TLbq="timelu_bq.txt"
TLapps="timelu_apps.txt"


# PID File für das Image. Wird unter diesen Namen gespeichert
PIDFILE="/tmp/cron.pid"




#
## Ende der Konfiguration
#


# Funktionen
TEMPdir=/tmp
WGETo="-q"
FILES2="satellites.xml terrestrial.xml cables.xml timezone.xml"
psOPT="ps -e"
SCRIPTNAME=`basename $0`


# Damit wird ausgelesen ob es sich um ein openatv Image handelt.
RECEIVERversion=`cat /etc/issue | egrep "openatv" | grep -v grep | awk '{print $1;}'`




if [ $(id -u) -ne 0 ]; then
        exec sudo $0 $1 $2
        exit 0
fi


# Wird eine openatv Image ermittel, wird geprüft ob der Software stand passt. Das Script funktioniert erst am 0
openatverm() {
if [ "$RECEIVERversion" = openatv ]; then
	OStime=$(wget -O - -q http://127.0.0.1/web/deviceinfo | grep "<e2enigmaversion>" |  egrep "[0-9]" | sed -e "s/.*<e2enigmaversion>\(.*\)<\/e2enigmaversion>.*/\\1/" | sed -e s/-//g | sed -e s/$/0000/g)
	sDay="201312310000"


	if [ $OStime -le $sDay ]; then
		wget -O /dev/null "http://localhost:80/web/message?text=Script%20funktioniet%20ab%20Softwarestand%20-20131231-%20Bitte%20Updaten!&type=1"
		exit
	fi
fi
}


# Vorbereitung URL 
urlencodebq() {
case $SERVERurl in
	[hH][tT][tT][pP]*|[fF][tT][pP]*)
		URLprot="$(echo $SERVERurl | cut -d ":" -f 1)://"
		URL=$(echo $SERVERurl | cut -d ":" -f 2 | tr -d "//")
	;;
	*)
		URL=$SERVERurl
	;;
esac
if [ ! -z "$USERBQ" ]; then
	if [ -z "$PASSBQ" ]; then
		_error 1 "Die Script Einstellung USERNAME ist gesetzt aber PASSWORD ist leer!"
	fi
	URL="$USERBQ:$PASSBQ@$URL"
fi
[ ! -z "$SERVERport" ] && URL="$URL:$SERVERport"
[ ! -z "$URLprot" ] && URL=$URLprot$URL
}


# Vorbereitung fuer http Ausgabe auf Receiver
urlencode() {
	if [ "$1" = alle ]; then
		string="$list"
	fi
	
	if [ "$1" = eins ]; then
		string="$LIST"
	fi
	
	if [ "$1" = alte ]; then
		string="$BQv"
	fi
	
	if [ "$1" = bq ]; then
		string="Senderlisten-Update/Installation"
	fi
	
	if [ "$1" = apps ]; then
		string="APPS-Update/Installation"
	fi
	
	if [ "$1" = cron ]; then
		string="Cron-Update/Installation"
	fi
	
	if [ "$1" = scripte ]; then
		string="Scripte-Update/Installation"
	fi


	if [ "$1" = uptime ]; then
		string="$uptime"
	fi
	
	if [ ! -x "/usr/bin/hexdump" ]; then
		echo "hexdump not found, nutze sed Befehl"
		encodedurl=$(echo "$string" | sed 's/ /%20/g;s/!/%21/g;s/"/%22/g;s/#/%23/g;s/\$/%24/g;s/\&/%26/g;s/'\''/%27/g;s/(/%28/g;s/)/%29/g;s/:/%3A/g')
	else
		encodedurl=`
		echo $string | hexdump -v -e '1/1 "%02x\t"' -e '1/1 "%_c\n"' |
		LANG=C awk '
		$1 == "20"                    { printf("%s",   "+"); next } # space becomes plus
		$1 ~  /0[adAD]/               {                      next } # strip newlines
		$2 ~  /^[a-zA-Z0-9.*()\/-]$/  { printf("%s",   $2);  next } # pass through what we can
									{ printf("%%%s", $1)        } # take hex value of everything else
	'`
	fi
    echo "${encodedurl}"
	REPLAY="${encodedurl}"
}
	
# Umgang mit error Meldung
_error() {
    if [ $1 -gt 0 ]; then
        [ -z "$2" ] && message="Es ist ein Fehler aufgetreten" || message=$2
		echo "$message"
        exit 0
    fi
}


# Ausgabe - Hilfe wie Script funktioniert
help_txt() {	
	echo "Um Update zu pruefen: $0 {scripte|senderliste|apps} start"
	echo "Um Update zu erzwingen: $0 {scripte|senderliste|apps} erzwingen"
	exit 0
}




# Aufräumen .txt file
_cleanupscripte() {
	if [ -f "$TEMPdir/$STscripte" ]; then
		rm -r $TEMPdir/$STscripte
	fi


	if [ -f "$TEMPdir/$scriptetargz" ]; then
		rm -r $TEMPdir/$scriptetargz
	fi
	
	if [ -d "$TEMPdir/scripte" ]; then
		rm -r $TEMPdir/scripte
	fi
}
_cleanupapps() {
	if [ -f "$TEMPdir/$STapps" ]; then
		rm -r $TEMPdir/$STapps
	fi


	if [ -f "$TEMPdir/$appstargz" ]; then
		rm -r $TEMPdir/$appstargz
	fi
	
	if [ -d "$TEMPdir/apps" ]; then
		rm -r $TEMPdir/apps
	fi
}
_cleanupbq() {
	if [ -f "$TEMPdir/$STbq" ]; then
		rm -f $TEMPdir/$STbq
	fi


	if [ -f "$TEMPdir/$ENIGMA" ]; then
		rm -f $TEMPdir/$ENIGMA
	fi
}
_cleanupbqlist() {
	if [ -f "$TEMPdir/$BQlist" ]; then
		rm -f $TEMPdir/$BQlist
	fi
}


# Aufräumen Cron PIDFILE	
_cleanCRON() {
	rm -r $TEMPdir/$CRON
}


# Abfrage GUI Neustart ja/nein
GUIneustart() {
	if [ "$erzw" = 1 ]; then
		wget -O /dev/null "http://localhost:80/web/message?text=Script%20Erzwungenes-Update%20fertig!%20Starte%20Receiver%20neu!&type=1&timeout=5" && sleep 5
		wget -O /dev/null -q http://127.0.0.1/web/powerstate?newstate=3
	else
		answer=""
		wget -O /dev/null "http://localhost:80/web/message?text=$( urlencode $1 "$args" )%20fertig!%20Soll%20Receiver%20neu%20gestartet%20werden?%20$( urlencode $1 "$args" )%20erst%20nach%20neu%20start%20verfügbar!&type=0"
		wget -O /dev/null "http://localhost:80/web/remotecontrol?command=108"
		while [ -z "$answer" ]; do
			answer=$(wget -O - 'http://localhost:80/web/messageanswer?getanswer=now' | egrep -o 'YES|NO') 
			sleep 1
		done
		if [ "$answer" = YES ];then
			wget -O /dev/null -q http://127.0.0.1/web/powerstate?newstate=3
		fi
	fi
}




# Abfrage ob Senderlisten Update starten soll
bqfrage() {
	if [ ! -f "$TEMPdir/$STbq" ]; then
		downtimetxtbq
		timen=$(cat $TEMPdir/$STbq | head -n1 | tail -n1)
		uptime=$(date -d @$timen +"%d.%m.%Y um %H:%M")
	else
		timen=$(cat $TEMPdir/$STbq | head -n1 | tail -n1)
		uptime=$(date -d @$timen +"%d.%m.%Y um %H:%M")	
	fi
	
	answer=""
	BQv=$(cat /etc/$BQversion)
	wget -O /dev/null "http://localhost:80/web/message?text=Soll%20die%20$( urlencode alte "$args" )%20Senderliste%20vom%20$( urlencode uptime "$args" )%20akutalisiert%20werden?&type=0"
	while [ -z "$answer" ]; do 
		answer=$(wget -O - 'http://localhost:80/web/messageanswer?getanswer=now' | egrep -o 'YES|NO') 
		sleep 1 
	done
	
	if [ "$answer" = NO ]; then
		install=0
		bqerinnerung
	fi
}


# Abfrage ob zum Aktuellen Update nochmal erinnert werden soll. Wenn die vorherige abfrage mit Nein beantwortet wurde.	
bqerinnerung() {	
	answer=""	
	wget -O /dev/null "http://localhost:80/web/message?text=Willst%20du%20zur%20Senderliste%20$( urlencode alte "$args" )%20vom%20$( urlencode uptime "$args" )%20nochmal%20erinnert%20werden?\n\nKann%20manuell%20über%20Donload-Senderliste%20gestartet%20werden!&type=0"
	while [ -z "$answer" ]; do 
		answer=$(wget -O - 'http://localhost:80/web/messageanswer?getanswer=now' | egrep -o 'YES|NO') 
		sleep 1 
	done
	if [ "$answer" = NO ];then
		_cleanupbq
		downtimetxtbq
		savetimetxtbq
	else
		if [ -f "/etc/$TLbq" ]; then
			echo "Lösche $TLbq"
			rm -r /etc/$TLbq
		fi
	fi
}
	
# Senderliste ermitteln. Mit der bqlist vom Server, die Auswahl wird in eine BQ_version abgelegt, damit beim Update nicht jedesmal danach gefragt wird.
SATerm() {
	_cleanupbqlist
	downbqlist


	for LIST in $list; do
		if [ "$weiter" = 1 ]; then
			continue
			break
		fi
			
		answer=""


		wget -O /dev/null "http://localhost:80/web/message?text=Folgende%20Senderlisten%20gefunden:\n$( urlencode alle "$args" )\n\nMöchtest%20du%20die%20$( urlencode eins "$args" )%20Senderliste%20auswählen?\n\nDu%20wirst%20im%20nächsten%20Schritt%20gefragt%20ob%20du%20wirklich%20Updaten%20möchtest!\n\nAuswahl%20ist%20pflicht!&type=0"
	
		while [ -z "$answer" ]; do
			answer=$(wget -O - 'http://localhost:80/web/messageanswer?getanswer=now' | egrep -o 'YES|NO') 
			sleep 1
		done
	
		if [ "$answer" = YES ]; then
			SERVERdir=$LIST
			savebqlist
			bqfrage
			weiter=1
			bq=1
		else
			bq=0
		fi
	done
	
	if [ "$bq" = 0 ]; then
		answer=""
		wget -O /dev/null "http://localhost:80/web/message?text=Bitte%20eine%20der%20Senderliste%20auswählen!\n\nFolgende%20Senderliste%20gefunden:\n$( urlencode alle "$args" )\n\nSoll%20abfrage%20nochmal%20starten?\nBei%20Nein%20wird%20Script%20beendet%20und%20später%20nochmal%20gefragt!&type=0"
		
		while [ -z "$answer" ]; do
			answer=$(wget -O - 'http://localhost:80/web/messageanswer?getanswer=now' | egrep -o 'YES|NO') 
			sleep 1
		done
		
		if [ "$answer" = YES ]; then
			SATerm
		else
			exit 0
		fi
	fi
}


# Download von BQlist
downbqlist() {
	
    #Downloaden von list_bq.txt vom Server
    wget $WGETo $URL/www/settings/$BQlist
    _error $? "Es ist ein Fehler aufgetreten (download $BQlist)"
	
    #prüfen ob download erfolgreich
    if [ ! -f "$TEMPdir/$BQlist" ]; then
        _error 1 "Es ist ein Fehler aufgetreten (download $BQlist)"
	else
		echo "$BQlist erfolgreich runtergeladen"
	fi
	
	#Speichern des Inhalts von bqlist.txt in einer Variablen
    list=$(cat $TEMPdir/$BQlist)
    _error $? "Es ist ein Fehler aufgetreten (auslesen von $TEMPdir/$BQlist)"
}


# Speichern der BQliste
savebqlist() {
	if [ -f "/etc/$BQversion" ]; then
		rm -r /etc/$BQversion
	fi


	echo "$SERVERdir" > /etc/$BQversion
	_error $? "Es ist ein Fehler aufgetreten (schreiben von /etc/$BQversion)"
}


## Download und Save der time_***.txt
#
# Alle Scripte 
# Downloaden von time_scripte.txt - Scripte files
downtimetxtscripte() {
	
	cd $TEMPdir
	
    #Downloaden von time_scripte.txt vom Server
    wget $WGETo $URL/www/scripte/$STscripte
    _error $? "Es ist ein Fehler aufgetreten (download $STscripte)"
    
    #prüfen ob download erfolgreich
    if [ ! -f "$TEMPdir/$STscripte" ]; then
        _error 1 "Es ist ein Fehler aufgetreten (download $STscripte)"
	else
		echo "$STscripte erfolgreich runtergeladen"
    fi
}


# Speichern der time_scripte.txt in timelu_scripte.txt - Scripte files
savetimetxtscripte() {
    cp -r $TEMPdir/$STscripte /etc/$TLscripte
}


#
##


## Download der jeweiligen Dateie(n)
#
# Download und install von allen scripten 
downinstscripte() {
	
	wget -O /dev/null "http://localhost:80/web/message?text=Starte%20Scripte-Files%20Update%20vom%20$( urlencode uptime "$args" )!&type=1&timeout=5" && sleep 5
	cd $TEMPdir
	
	#Download vom Server
	wget $WGETo $URL/www/scripte/$scriptetargz
		_error $? "Es ist ein Fehler aufgetreten (download $scriptetargz)"


	#prüfen ob download erfolgreich
	if [ ! -f "$TEMPdir/$scriptetargz" ]; then
		_error 1 "Es ist ein Fehler aufgetreten ($scriptetargz wurde nicht heruntergeladen)"
	fi


    #Entpacken
    tar -xjf $scriptetargz
    _error $? "Es ist ein Fehler aufgetreten (entpacken $scriptetargz)"


	if [ "$RECEIVERversion" = openatv ]; then
		/etc/init.d/busybox-cron stop
		cp -rf $TEMPdir/scripte/cronm/* /etc/cron/crontabs
		_error $? "Es ist ein Fehler aufgetreten (verschieben $TEMPdir/scripte/cronm/* nach /etc/cron)"
		chmod 755 /etc/cron
		chmod 600 /etc/cron/crontabs/root
		/etc/init.d/busybox-cron start
	else
		/etc/init.d/cron stop
		cp -rf $TEMPdir/scripte/cronm/* /cron/tabs
		_error $? "Es ist ein Fehler aufgetreten (verschieben $TEMPdir/scripte/cronm/* nach /cron)"
		chmod 755 /cron
		chmod 600 /cron/tabs/root
		/etc/init.d/cron start
	fi
	
	#menueFILES=$(cd $TEMPdir/scripte/menue && ls)
	#cp -r $TEMPdir/scripte/menue/* $menuedir
    #_error $? "Es ist ein Fehler aufgetreten (verschieben $TEMPdir/scripte/menue/* nach $menuedir)"
	
	#for MENUEfiles in $menueFILES; do
	#	chmod 644 $menuedir/$MENUEfiles
	#done
	
	# Dieser Punkt sorgt dafür das die alte cron_get in cron_get.old gewandelt wird
	if [ "$0" = $Scriptdir/cron_get ]; then
		cp -r $Scriptdir/cron_get $TEMPdir/cron_get.old
		chmod 755 $TEMPdir/cron_get.old
		
		# Dieser Punkt sorgt dafür das im Falle eines cron_get Update die angelegte cron_get.old gestartet wird. Somit gibt es keine Probleme beim überschreiben der cron_get
		if [ "$Update" = 1 ]; then
			$TEMPdir/cron_get.old scripte update1
		else
			$TEMPdir/cron_get.old scripte update
		fi
		
		rm -r $PIDFILE
		exit
	fi
}


# Update der cron_get
instcronget() {
	scriptFILES=$(cd $TEMPdir/scripte/cron_get && ls)
	cp -r $TEMPdir/scripte/cron_get/* $Scriptdir
    _error $? "Es ist ein Fehler aufgetreten (verschieben $TEMPdir/scripte/cron_get/* nach $Scriptdir)"
	
	for SCRIPTfiles in $scriptFILES; do
		chmod 755 $Scriptdir/$SCRIPTfiles
	done
	
	savetimetxtscripte
	
	reboot=1
}


downtimetxtapps() {
	
	cd $TEMPdir
	
    #Downloaden von time_apps.txt vom Server
    wget $WGETo $URL/www/apps/$STapps
    _error $? "Es ist ein Fehler aufgetreten (download $STapps)"
    
    #prüfen ob download erfolgreich
    if [ ! -f "$TEMPdir/$STapps" ]; then
        _error 1 "Es ist ein Fehler aufgetreten (download $STapps)"
	else
		echo "$STapps erfolgreich runtergeladen"
    fi
}


# Speichern der time_apps.txt in timelu_apps.txt - apps files 
savetimetxtapps() {
    cp -r $TEMPdir/$STapps /etc/$TLapps
}
downinstapps() {
	wget -O /dev/null "http://localhost:80/web/message?text=Starte%20APPS-Files%20Update%20vom%20$( urlencode uptime "$args" )!&type=1&timeout=5" && sleep 5
	cd $TEMPdir
	
	#Download vom Server
	wget $WGETo $URL/www/apps/$appstargz
		_error $? "Es ist ein Fehler aufgetreten (download $appstargz)"


	#prüfen ob download erfolgreich
	if [ ! -f "$TEMPdir/$appstargz" ]; then
		_error 1 "Es ist ein Fehler aufgetreten ($scriptetargz wurde nicht heruntergeladen)"
	fi


    #Entpacken
    tar -xjf $appstargz
    _error $? "Es ist ein Fehler aufgetreten (entpacken $appstargz)"
	
	appsFILES=$(cd $TEMPdir/apps && ls)
	
	for APPSfiles in $appsFILES; do
		opkg install $TEMPdir/apps/$APPSfiles
	done
}


# Download von time_bq.txt - BQ Settings
downtimetxtbq() {
	if [ -f "/etc/$BQversion" ]; then
		# Speichern des Inhalts von vorhanden bq_version.txt in einer Variablen
		SERVERdir=$(cat /etc/$BQversion | head -n1 | tail -n1)
		_error $? "Es ist ein Fehler aufgetreten (auslesen von /etc/$BQversion)"
	fi
	
    #Downloaden von time_bq.txt vom Server
    wget $WGETo $URL/www/settings/$SERVERdir/$STbq
    _error $? "Es ist ein Fehler aufgetreten (download $STbq)"
	
    #prüfen ob download erfolgreich
    if [ ! -f "$TEMPdir/$STbq" ]; then
        _error 1 "Es ist ein Fehler aufgetreten (download $STbq)"
	else
		echo "$STbq erfolgreich runtergeladen"
	fi
}


# Speichern der time_bq.txt in timelu_bq.txt - BQ Settings
savetimetxtbq() {
    cp -r $TEMPdir/$STbq /etc/$TLbq
}
downinstbq() {
	wget -O /dev/null "http://localhost:80/web/message?text=Starte%20Senderlisten%20Update%20vom%20$( urlencode uptime "$args" )!&type=1&timeout=5" && sleep 5
	# Name der gepackten Bouquets Datei
	BQ="${ENIGMA}.tar.bz2"
	
		if [ -f "$TEMPdir/$BQ" ]; then
			rm -rf $TEMPdir/$BQ
		fi


		#Download der Senderliste vom Server
		wget $WGETo $URL/www/settings/$SERVERdir/$BQ
		_error $? "Es ist ein Fehler aufgetreten (download $BQ)"


		#prüfen ob download erfolgreich
		if [ ! -f "$TEMPdir/$BQ" ]; then
			_error 1 "Es ist ein Fehler aufgetreten ($BQ wurde nicht heruntergeladen)"
		fi


		#Entpacken
		tar -xjf $BQ
		_error $? "Es ist ein Fehler aufgetreten (entpacken $BQ)"


		if [ "$ENIGMA" = "enigma2" ]; then
			PakValidated=0
			for file in $FILES2; do
				if [ -f "$TEMPdir/$ENIGMA/$file" ]; then
					mv -f $TEMPdir/$ENIGMA/$file /etc/tuxbox/
					PakValidated=1
				fi
			done
			#prüfen ob der inhalt des enigma2 archives korrekt ist
			[ $PakValidated = 0 ] && _error 1 "Das Archive $BQ entspricht nicht den Anforderungen!"


			cd /etc/$ENIGMA
			rm -f *.tv
			rm -f *.radio
			rm -f blacklist
			rm -f lamedb
			mv -f $TEMPdir/$ENIGMA/* /etc/$ENIGMA/
			_error $? "Es ist ein Fehler aufgetreten (verschieben $TEMPdir/$ENIGMA/* nach /etc/$ENIGMA/)"


			echo "Lade Senderliste neu"
			RELOAD1=$(wget -qO - http://127.0.0.1/web/servicelistreload?mode=1)
			RELOAD2=$(wget -qO - http://127.0.0.1/web/servicelistreload?mode=2)
			echo $RELOAD1 | grep statetext | cut -d ">" -f 2 | cut -d "<" -f 1
			echo $RELOAD2 | grep statetext | cut -d ">" -f 2 | cut -d "<" -f 1
			echo " "	
			echo "Bouquets erfolgreich abgeschlossen"	
			sleep 5
		else
			cd /var/tuxbox/config/enigma/
			rm -f *.tv
			rm -f *.radio
			rm -f *.epl
			rm -f bouquets
			rm -f services
			rm -f services.locked
			mv -f /tmp/$ENIGMA/* /var/tuxbox/config/enigma/
			_error $? "Es ist ein Fehler aufgetreten (verschieben $TEMPdir/$ENIGMA/* nach /var/tuxbox/config/enigma/)"
		
			echo "Lade Senderliste neu"
			RELOAD1=$(wget -qO - http://127.0.0.1/web/servicelistreload?mode=1)
			RELOAD2=$(wget -qO - http://127.0.0.1/web/servicelistreload?mode=2)
			echo $RELOAD1 | grep statetext | cut -d ">" -f 2 | cut -d "<" -f 1
			echo $RELOAD2 | grep statetext | cut -d ">" -f 2 | cut -d "<" -f 1
			echo " "
			echo "Bouquets erfolgreich abgeschlossen" 
			sleep 5
		fi
}
#
##


case $1 in								
		scripte)
						SCRIPT="scripte"
						urlencodebq
						;;
						
		senderliste)
						SCRIPT="bq"
						urlencodebq
						;;
						
		apps)
						SCRIPT="apps"
						urlencodebq
						;;
		*)
						help_txt
						;;
esac




case $2 in
		erzwingen) 
					Update=1
					;;
					
		start)
					;;
					
		update)
					get=1
					;;
					
		update1)
					get=1
					erzw=1
					;;
					
		*)
					help_txt
					;;
esac


echo "$URL"




# Starte Ermittelung: Ob openatv Image installiert ist 
openatverm


# Prüfen ob Server Offline ist
SERVER=$(echo $SERVERurl | cut -d ":" -f 2 | tr -d "//")
ping -c 1 $SERVER >/dev/null 2>&1
if [ $? -ne 0 ] ; then
	echo "Server Offline, bitte spaeter nochmal versuchen!"
	wget -O /dev/null "http://localhost:80/web/message?text=Update%20Server%20ist%20Offline!&type=1&timeout=10" && sleep 10
else
	echo "Server Online"
fi




##
# Prueft ob Update-Prüfung schon läuft, wenn ja wird Script beendet
echo "Prüfe ob Update-Prüfung schon läuft"
ENDEXECUTION=0


if [ -f "$PIDFILE" ]; then
	RUNNINGPID=`cat "$PIDFILE"`


	PROGRAMPID=`$psOPT | grep "$SCRIPTNAME" | grep -v grep | awk '{print $1;}'`
	
	for PIDEL in $PROGRAMPID
	do
		if [ "$PIDEL" == "$RUNNINGPID" ]; then
			ENDEXECUTION=1
			break
		fi
	done
fi


if [ "$ENDEXECUTION" == 1 ]; then
	answer=""
	if [ "$Update" = 1 ]; then
		wget -O /dev/null "http://localhost:80/web/message?text=Update-Prüfung%20läuft%20schon%20im%20Hintergrund!\nReceiver%20neu%20starten%20und%20Script%20nochmal%20starten!\nSoll%20Receiver%20neu%20gestartet%20werden?&type=0" 
		wget -O /dev/null "http://localhost:80/web/remotecontrol?command=108"
		while [ -z "$answer" ]; do
			answer=$(wget -O - 'http://localhost:80/web/messageanswer?getanswer=now' | egrep -o 'YES|NO') 
			sleep 1
		done
			if [ "$answer" = YES ];then
				wget -O /dev/null -q http://127.0.0.1/web/powerstate?newstate=2
			else
				exit 0
			fi
	else	
		echo "Update-Prüfung läuft schon"
		exit 0
	fi
else
	echo "Starte Update-Prüfung"
	echo $$ > $PIDFILE
fi
#
##
# Pruefen ob Cronmanager installiert ist
if [ "$RECEIVERversion" = openatv ]; then
	if [ ! -f /etc/init.d/busybox-cron ]; then
		opkg install enigma2-plugin-extensions-cronmanager
		wget -O /dev/null "http://localhost:80/web/message?text=Cronmanager%20wurde%20installiert,%20Receiver%20startet%20neu\Updateprüfung%20startet%20erst%20im%20nächsten%20intervall!&type=1&timeout=10"
		GUIneustart cron
	fi
else
	if [ ! -f /etc/init.d/cron ]; then
		opkg install enigma2-plugin-extensions-cronmanager
		wget -O /dev/null "http://localhost:80/web/message?text=Cronmanager%20wurde%20installiert,%20Receiver%20startet%20neu\Updateprüfung%20startet%20erst%20im%20nächsten%20intervall!&type=1&timeout=10"
		GUIneustart cron
	fi
fi


#Versuche ENIGMA version zu ermitteln
if [ -z "$ENIGMA" ]; then
	[ -d "/etc/enigma2/" ] && ENIGMA="enigma2"
	[ -d "/var/tuxbox/config/enigma/" ] && ENIGMA="enigma1"
	if [ -z "$ENIGMA" ]; then
		_error 1 "Kann die ENIGMA Version nicht ermitteln!"
	fi
fi		
			
# pruefe gültige ENIGMA einstellung
if [ "$ENIGMA" != "enigma1" ] && [ "$ENIGMA" != "enigma2" ]; then
	_error 1 "Die Script Einstellung ENIGMA ist fehlerhaft!\n Gueltige Einstellung: ENIGMA=\"e1\" oder ENIGMA=\"e2\""
fi


if [ "$get" = 1 ]; then
	instcronget
else
	for script in $SCRIPT; do
	
		install=1
		cd $TEMPdir
		#prüfen ob das script schon mal genutzt wurde und /etc/timelu_***.txt überhaupt vorhanden ist
		if [ -f "/etc/timelu_$script.txt" ]; then


			#vor dem download sicherstellen das die Dateien/Ordner nicht vorhanden sind. .txt und .tar.gz und /tmp/"DIR***"
			_cleanup$script
			
			downtimetxt$script
			
			if [ "$Update" = 1 ]; then
				echo "Update wird erzwungen"
				if [ "$script" = bq ]; then
					weiter=0
					SATerm
				fi
					
				if [ "$install" = 1 ]; then
					savetimetxt$script
					downinst$script
					reboot=1
				fi
			else
				# Speichern des Inhalts von vorhanden timelu_***.txt in einer Variablen
				timelu=$(cat /etc/timelu_$script.txt | head -n1 | tail -n1)
				_error $? "Es ist ein Fehler aufgetreten (auslesen von /etc/timelu_$script.txt)"
			
				# Speichern des Inhalts von time_***.txt in einer Variablen
				timen=$(cat $TEMPdir/time_$script.txt | head -n1 | tail -n1)
				_error $? "Es ist ein Fehler aufgetreten (auslesen von $TEMPdir/$ST$script)"
			
				if [ $timelu -lt $timen ]; then
					uptime=$(date -d @$timen +"%d.%m.%Y um %H:%M")
					echo "Update vom $uptime vorhanden.. Starte Installation/Update"
					if [ "$script" = bq ]; then
						bqfrage
					fi
			
					if [ "$install" = 1 ]; then
						downinst$script
						savetimetxt$script
						reboot=1
					fi
				else
					if [ "$script" = bq ]; then
						echo "Es ist kein Update vorhanden! -"$SERVERdir""
					else
						echo "Es ist kein Update vorhanden! -"$script"-"
					fi
					reboot=0
				fi
			fi
		else
			if [ ! -f "/etc/$BQversion" ]; then
				if [ "$script" = bq ]; then
					SATerm
				fi
			fi
		
			if [ "$script" = bq ]; then
				bqfrage
			fi
			
			if [ "$install" = 1 ]; then
				_cleanup$script
				downtimetxt$script
				timen=$(cat $TEMPdir/time_$script.txt | head -n1 | tail -n1)
				uptime=$(date -d @$timen +"%d.%m.%Y um %H:%M")
				downinst$script
				savetimetxt$script
				reboot=1
			fi
		fi
		_cleanup$script
	done
fi


echo "Installation/Update $script fertig"


# Löscht PIDFILE wenn Script fertig ist
rm -r $PIDFILE


echo "Bitte OK Taste drücken"


if [ "$1" = senderliste ] && [ "$reboot" = 1 ]; then
	GUIneustart bq
fi


if [ "$1" = apps ] && [ "$reboot" = 1 ]; then
	GUIneustart apps
fi


if [ "$1" = scripte ] && [ "$reboot" = 1 ]; then
	GUIneustart scripte
fi


exit 0

#!/bin/sh
#
# Pruefung ob Dateien geaendert worden sind und packt diese in tar.gz auf dem Server. Version 1.0
#
# Hier sollte nichts veraendert werden!


# Auslesen der Funktionen / Variablen
. /etc/functions_cron_pack.conf


##############################################################################################################################
if [ -d "$DIR/fertig/apps" ]; then
	if [ `ls $DIR/fertig/apps/apps | wc -w` = 0 ]; then
		APPS=0
	else
		APPS=1
		apps="$DIR/fertig/apps/apps"
	fi
else
	APPS=0
fi




appsFILES=$(cd $apps && ls)
appstargz="apps.tar.bz2"
apps_time="time_apps.txt"
PACKapps=0


putappsftp() {
export SSHPASS=passwort
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
mkdir apps
bye
!
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
cd apps
put $DIR/fertig/apps/$appstargz
put $DIR/fertig/apps/$apps_time
chmod 775 *.*
bye
!
}
	
packinstAPPS() {
cd $DIR/fertig/apps
tar -cjf $appstargz apps
_error $? "Fehler beim packen von $appstargz"


if [ -f "$appstargz" ]; then
	echo $TIMESTAMP > $apps_time
	_erfolgreich "$apps_time und $appstargz erfolgreich erstellt ($TIMESTAMP)"
	putappsftp
fi
}


echo "Pruefe Apps-Files-Update"
for APPSfiles in $appsFILES; do
	if [ -f "$DIR/fertig/apps/$apps_time" ]; then
		if [ $(stat -c %Y $apps/$APPSfiles) -gt $(stat -c %Y $DIR/fertig/apps/$apps_time) ]; then
			PACKapps=1
		fi
	else
		PACKapps=1
	fi
done


if [ "$PACKapps" = 1 ]; then
	packinstAPPS
else
	echo "Keine Aktualisierung noetig"
fi


if [ ! -f "$apps/$appstargz" ] && [ -f "$apps/$apps_time" ]; then
	rm -r $apps/$apps_time
fi


if [ -f "$apps/$appstargz" ] && [ ! -f "$apps/$apps_time" ]; then
	rm -r $apps/$apps_time
fi
##############################################################################################################################
if [ -d "$DIR/fertig/scripte" ]; then
	if [ `ls $DIR/fertig/scripte/scripte | wc -w` = 0 ]; then
		SCRIPTE=0
	else
		SCRIPTE=1
		scripte="$DIR/fertig/scripte/scripte"
	fi
else
	SCRIPTE=0
fi




scripteDIR=$(cd $scripte && ls)
scriptetargz="scripte.tar.bz2"
scripte_time="time_scripte.txt"
COPYscripte=0


putscripteftp() {
export SSHPASS=passwort
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
mkdir scripte
bye
!
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
cd scripte
put $DIR/fertig/scripte/$scriptetargz
put $DIR/fertig/scripte/$scripte_time
chmod 775 *.*
bye
!
}
	
packinstSCRIPTE() {
cd $DIR/fertig/scripte/
tar -cjf $scriptetargz scripte
_error $? "Fehler beim packen von $scriptetargz"


if [ -f "$DIR/fertig/scripte/$scriptetargz" ]; then
	echo $TIMESTAMP > $scripte_time
	_erfolgreich "$scripte_time und $scriptetargz erfolgreich erstellt ($TIMESTAMP)"
	putscripteftp
fi
}


echo "Pruefe Script-Files-Update"
for SCRIPTEdir in $scripteDIR; do
	scripteFILES=$(cd $scripte/$SCRIPTEdir && ls)
	
	for SCRIPTEfiles in $scripteFILES; do
		if [ -f "$DIR/fertig/scripte/$scripte_time" ]; then
			if [ $(stat -c %Y $scripte/$SCRIPTEdir/$SCRIPTEfiles) -gt $(stat -c %Y $DIR/fertig/scripte/$scripte_time) ]; then
				PACKscripte=1
			fi
		else
			PACKscripte=1
		fi
done
	done


if [ "$PACKscripte" = 1 ]; then
	packinstSCRIPTE
else
	echo "Keine Aktualisierung noetig"
fi


if [ ! -f "$scripte/$scriptetargz" ] && [ -f "$scripte/$scripte_time" ]; then
	rm -r $scripte/$scripte_time
fi


if [ -f "$scripte/$scriptetargz" ] && [ ! -f "$scripte/$scripte_time" ]; then
	rm -r $scripte/$scripte_time
fi
##############################################################################################################################
bqORG="$DIR/original/settings"
SAT=$(cd $bqORG && ls)
COPYbq=0
bq="DIR/fertig/settings"


if [ -f "$DIR/fertig/settings/list_bq.txt" ]; then
	rm -r $DIR/fertig/settings/list_bq.txt
fi


		
for sat in $SAT; do


putbqlistftp() {
export SSHPASS=passwort
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
cd settings
put $bq/list_bq.txt
bye
!
}


putbqftp() {
export SSHPASS=passwort
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
mkdir settings
bye
!
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
cd settings
mkdir $sat
bye
!
sshpass -e sftp -oBatchMode=no -b - ftp-user@test-line.de << !
cd settings
cd $sat
put $bq/$sat/$bqtargz
put $bq/$sat/$bq_time
chmod 775 *.*
bye
!
}


packinstBQ() {
if [ -f "$bq/$sat/$bqtargz" ]; then
	rm -r $bq/$sat/$bqtargz
fi


if [ ! -d "$bq/$sat" ]; then
	mkdir $bq/$sat
fi


cd $bqORG/$sat
tar -cjf $bq/$sat/$bqtargz $ENIGMA
_error $? "Fehler beim packen von $sat!"


if [ -f "$bq/$sat/$bqtargz" ]; then
	echo $TIMESTAMP > $bq/$sat/$bq_time
	_erfolgreich "$bq_time und $bqtargz erfolgreich erstellt ($TIMESTAMP)"
			
	putbqftp


	if [ -d "$bqORG/$sat/$ENIGMA" ]; then
		rm -r $bqORG/$sat/$ENIGMA
	fi
fi
}


copyBQ() {
if [ -d "$bqORG/$sat/$ENIGMA" ]; then
	rm -r $bqORG/$sat/$ENIGMA
fi


mkdir $bqORG/$sat/$ENIGMA
cp -R $bqORG/$sat/files/* $bqORG/$sat/$ENIGMA
_error $? "Es ist ein Fehler aufgetreten beim kopieren von $bqtargz, $bq_time"
}
	version=${sat##*_}


	if [ "$version" = e1 ]; then
		ENIGMA="enigma1"
	elif [ "$version" = e2 ]; then
		ENIGMA="enigma2"
	fi


	if [ ! "$version" = e2 ] && [ ! "$version" = e1 ]; then
		_error $? "Fehler beim erkennen der Enigma Version bitte so angeben 'SAT'_e2 oder 'SAT'_e1"
	fi


	bqtargz="$ENIGMA.tar.bz2"
	bq_time="time_bq.txt"
	bqFILES=$(cd $bqORG/$sat/files && ls)
	bq="$DIR/fertig/settings"
	COPYbq=0
	#if [ -f "$bq/list_bq.txt" ]; then
	#	bqlist=$(cat $bq/list_bq.txt)
	#	sed 's/'$bqlist'/'$bqlist$sat'/g' $bq/list_bq.txt 
	#else
	#	echo "Erstelle list_bq.txt"
		echo $SAT > $bq/list_bq.txt
	#fi
	
	echo "Pruefe BQ-$sat-Update"
	for BQfiles in $bqFILES; do
		if [ -f "$bq/$sat/$bq_time" ]; then
			if [ $(stat -c %Y $bqORG/$sat/files/$BQfiles) -gt $(stat -c %Y $bq/$sat/$bq_time) ]; then
				COPYbq=1
			fi
		else
			COPYbq=1
		fi
	done


	if [ "$COPYbq" = 1 ]; then
		copyBQ
		packinstBQ
	else
		echo "Keine Aktualisierung ($sat) noetig"
	fi


	if [ ! -f "$bq/$sat/$bqtargz" ] && [ -f "$bq/$sat/$bq_time" ]; then
		rm -r $bq/$sat/$bq_time
	fi
	
	if [ -f "$bq/$sat/$bqtargz" ] && [ ! -f "$bq/$sat/$bq_time" ]; then
		rm -r $bq/$sat/$bq_time
	fi
done


if [ "$COPYbq" = 1 ]; then
	putbqlistftp
fi
##############################################################################################################################






exit 0

#!/bin/bash# cron_pack - Functions - 64bit
#
# BITTE GLEICH BEARBEITEN, DASS INSTALLER SCRIPT BENUTZT GLEICH VARIABLEN VON HIER!!!
#
# Version 1.0
# set -x #debug


#++++++++++++++++++++++++++++++ Variables ++++++++++++++++++++++++++++++#


# Hier koennt ihr eure Einstellungen machen, alle Scripte greifen auf die functions_cron_pack.sh


# Hier Server Verzeichnis angeben, wo die Files und Settings abgelegt werden
DIR="/media/daten/www"


# Soll Benutzernamen automatisch ausgelesen werden? Aus 'DIR'! 1 = Ja; 0 = Nein
readBENUTZER="1"


# Falls readBENUTZER 0 bitte hier Benutzernamen angeben, sonst leer lassen!
BENUTZER=""
# Soll bei erfolgreichen packen ein Nachricht versendet werden?
# 0 = nur Ausgabe im Terminal; 1 = nur eMail Versand; 2 = Terminal und eMail
sendEMAIL="0"


# Soll IPC eMail Daten verwendet werden fuer eMail Versand? 0 = Nein; 1 = Ja!
IPCeMail="1"


# Wenn Nein bitte hier eMail Daten angeben, sonst leer lassen!
SMTPFROM=""
SMTPTO=""
SMTPSERVER=""
SMTPUSER=""
SMTPPASS=""
SMTPTLS=""
######################### Ende Konfiguration ############################
#++++++++++++++++++++++++++++++ Variables ++++++++++++++++++++++++++++++#


#++++++++++++++++++++++++++++++ Functions ++++++++++++++++++++++++++++++#


TIMESTAMP=$(date +%s)


# Falls aktiviert auslesen der Benutzernamen
if [ "$readBENUTZER" = 1 ]; then
BENUTZER="$(cd $SERVERdir && ls)"
fi


# Auslesen der eMail Daten aus ipc.cfg
if [ "$IPCeMail" = 1 ]; then
. /var/emu/conf/ipc.cfg
fi


# Auslesen ob TLS verwendet werden soll
if [ "$SMTPTLS" = 1 ]; then
OPT="-o tls=yes"
fi


#error handling
_error() {
    if [ $1 -gt 0 ]; then
        [ -z "$2" ] && message="Es ist ein Fehler aufgetreten" || message=$2
            echo "\033[1;31;4m $message \033[0m"
			echo "\033[1;31;4m Abbruch \033[0m"
			sendEmail -f $SMTPFROM -t $SMTPTO -u "$message" $OPT -s $SMTPSERVER -xu $SMTPUSER -xp $SMTPPASS -m $message $(date)
    fi
}


_erfolgreich() {
message=$1


if [ "$sendEMAIL" = 0 ]; then
echo "\033[1;34;4m $message \033[0m"
fi


if [ "$sendEMAIL" = 1 ]; then
sendEmail -f $SMTPFROM -t $SMTPTO -u "$message" $OPT -s $SMTPSERVER -xu $SMTPUSER -xp $SMTPPASS -m $message $(date)
fi


if [ "$sendEMAIL" = 2 ]; then
echo "\033[1;34;4m $message \033[0m"
sendEmail -f $SMTPFROM -t $SMTPTO -u "$message" $OPT -s $SMTPSERVER -xu $SMTPUSER -xp $SMTPPASS -m $message $(date)
fi
}


############################# Ende Functions ############################
#++++++++++++++++++++++++++++++ Functions ++++++++++++++++++++++++++++++#