Settings über eigenen Server laden möglich

[TDCroPower]

AW: Settings über eigenen Server laden möglich

so Plugin funktioniert soweit, da er das script startet jedoch gibt er mir beim Script diesen Fehler...

Ausführen eines externen Befehls:

/usr/script/ExecuteMyScript.sh: line 1: #!/bin/sh: not found
/usr/script/ExecuteMyScript.sh: cd: line 9: can't cd to /tmp/
connecting to unityhd.funpic.de (213.202.225.33:80)
wget server returned error: HTTP/1.1 503 Service Unavailable
connecting to unityhd.funpic.de (213.202.225.33:80)
wget server returned error: HTTP/1.1 503 Service Unavailable
chmod: /tmp/enigma2.tar: No such file or directory
chmod: /tmp/time.txt: No such file or directory
/usr/script/ExecuteMyScript.sh: cd: line 14: not found
cat: can't open '/tmp/time.txt': No such file or directory
/usr/script/ExecuteMyScript.sh: cd: line 18: not found
/usr/script/ExecuteMyScript.sh: cd: line 76: syntax error; unexpected "fi" (expecting "then")
Ausführung beendet!

mein bearbeitetes Script seht ihr ja im Post oben...

wo ist denn da der Fehler?

 

[Youtube18]

AW: Settings über eigenen Server laden möglich

Der Server unityhd.funpic.de ist nicht erreichbar oder der Pfad ist falsch.

Siehe:

/usr/script/ExecuteMyScript.sh: cd: line 9: can't cd to /tmp/
connecting to unityhd.funpic.de (213.202.225.33:80)
wget server returned error: HTTP/1.1 503 Service Unavailable
connecting to unityhd.funpic.de (213.202.225.33:80)
wget server returned error: HTTP/1.1 503 Service Unavailable

Wobei mir Service Unavailable eher nach einem Verbindungsproblem zu Server aussieht.

Gesendet von meinem GT-I9300 mit Tapatalk

 

[Alex]

AW: Settings über eigenen Server laden möglich

/usr/script/ExecuteMyScript.sh: line 1: #!/bin/sh: not found

Da er das schon nicht frisst, sieht es für mich so aus, als wäre das Script mit einem nicht linuxkonformen Editor bearbeitet worden.

 

[TDCroPower]

AW: Settings über eigenen Server laden möglich

@Youtube18

Server ist aktiv und Verlinkung stimmt ebenfalls kannst es ja bei klick auf den link testen...

Sie müssen registriert sein, um Links zu sehen.

@al-x83

habe es mit Notepad++ editiert, wie kann ich es denn kontrollieren das es linuxkonform gesichert ist?
Kann mir vielleicht jemand mein editiertes script von oben linuxkonform sichern und hier posten damit ich diesen Fehler ausklammern kann?

 

[jensebub]

AW: Settings über eigenen Server laden möglich

Hallo, nutze doch einfach das tool "dos2unix"
einfach zu installen:

apt-get install dos2unix

Und dann auch einfach anzuwenden:

dos2unix /pfad/zur/datei

Und schon ist die Datei wieder Linux-konform

Gruß
jensebub

 

[TDCroPower]

AW: Settings über eigenen Server laden möglich

habe leider keinen linux Rechner hier vor Ort und mein Raspberry ist zuhause um dos2unix zu installieren.

gibt es vielleicht noch eine Möglichkeit unter Windows oder Mac?


falls mir vielleicht doch jemand das testen vereinfachen will und das script umwandeln würde wäre schon mal der weg getan

hier mein script:

Sie müssen registriert sein, um Links zu sehen.

 

[Youtube18]

AW: Settings über eigenen Server laden möglich

Hier dein Script erstellt mit meinem Androiden:

Sie müssen registriert sein, um Links zu sehen.

Gesendet von meinem GT-I9300 mit Tapatalk

 

[TDCroPower]

AW: Settings über eigenen Server laden möglich

danke Fehler bleibt der gleiche wie davor gepostet...

Rechte habe ich natürlich auf 755 bzw. 777 gesetzt!


edit:

hier mal das script von Nobody28 was ohne Probleme durch läuft, vielleicht findet jemand von euch den Unterschied...

Sie müssen registriert sein, um Links zu sehen.

habe auch das script von 08005553333 getestet und auch da werden mir direkt die erste zeile als Fehler angezeigt und dazu jede Leerzeile im script!

 

[Youtube18]

AW: Settings über eigenen Server laden möglich

Ich habe Ihn gefunden

Alle Windows Editoren machen dieses komische Zeichen an den Anfang:



Hier mal die Datei OHNE dieses Zeichen:

Sie müssen registriert sein, um Links zu sehen.

Sollte dann laufen

 

[TDCroPower]

sieht schonmal besser aus jetzt kommt nur noch dieser Fehler...

/bin/sh: /usr/script/ExecuteMyScript.sh: not found

edit:

sehr komisch, habe mal mit TextMate für Mac ein Leerzeichen vor #!/bin/sh gesetzt und jetzt kommt nur noch...

/usr/script/ExecuteMyScript.sh: cd: line 9: can't cd to /tmp/
connecting to unityhd.funpic.de (213.202.225.33:80)
wget server returned error: HTTP/1.1 503 Service Unavailable
connecting to unityhd.funpic.de (213.202.225.33:80)
wget server returned error: HTTP/1.1 503 Service Unavailable
chmod: /tmp/enigma2.tar: No such file or directory
chmod: /tmp/time.txt: No such file or directory
/usr/script/ExecuteMyScript.sh: cd: line 14: not found
cat: can't open '/tmp/time.txt': No such file or directory
/usr/script/ExecuteMyScript.sh: cd: line 18: not found
/usr/script/ExecuteMyScript.sh: cd: line 76: syntax error; unexpected "fi" (expecting "then")
Ausführung beendet!

bleibt die Frage warum der Fehler...

/usr/script/ExecuteMyScript.sh: cd: line 9: can't cd to /tmp/

noch da ist!?
Und warum der Server wohl nicht erreichbar ist, jemand einen Server zu testen da wohin ich meine enigma2.tar und time.txt legen kann?

hat denn keiner eine Empfehlung oder Tipp für mich?

was mich wundert das im PluginUpdate.sh der Befehl "cd /tmp" funktioniert und in meinem bearbeiteten da schon ein Fehler ausgegeben wird!?

 

[Opelpower]

AW: Settings über eigenen Server laden möglich

@TDCroPower
Hast du es mittlerweile hinbekommen??

Komme auch nicht wirklich weiter......
Möchte auch einfach nur eine "Enigma2.tar" Datei herunterladen von meinem Server, aber es funktioniert leider nicht.

#!/bin/sh#BESCHREIBUNG=Herunterladen, Installation & Reload Enigma2 Bouquets
#Die URL auf eure eigene URL umändern wo das tar file liegt
BQ="http://MEINSERVER/Settings/enigma2.tar"
BG="enigma2.tar"
#Die URL auf eure eigene URL umändern wo das tar file liegt
ST="http://MEINSERVER/Settings/time.txt"
## Bouquet Download, Prüfung, Installation + Reload ##
cd /tmp/
wget $BQ
wget $ST
chmod 755 /tmp/enigma2.tar
chmod 755 /tmp/time.txt


#Speichern des Inhalts von timelu.txt und time in einer Variablen
export timelu=$(cat /etc/timelu.txt | head -n1 | tail -n1)
export timen=$(cat /tmp/time.txt | head -n1 | tail -n1)


if [ -s $BG ]; then
echo "Server Online"
else
echo "Server Offline, bitte spaeter nochmal versuchen!"
fi


#Vergleich: Ist timelu kleiner als timen ?#
if [ $timelu -lt $timen ];then


tar -xvf enigma2.tar


if [ -s /tmp/enigma2 ]; then
echo "Entpacken erfolgreich"


echo "Lade Senderliste"


cd /tmp/enigma2
mv /tmp/enigma2/satellites.xml /etc/tuxbox/


cd /etc/enigma2
rm -rf *.tv
rm -rf *.radio
rm -rf blacklist
rm -rf lamedb
mv /tmp/enigma2/* /etc/enigma2


rm -rf /tmp/enigma2
rm -rf /tmp/enigma2.tar


wget -qO - http://127.0.0.1/web/servicelistreload?mode=1
wget -qO - http://127.0.0.1/web/servicelistreload?mode=2


#Speichern der time.txt in timelu.txt
cd /etc
rm -rf /etc/timelu.txt
touch timelu.txt
echo "$timen" >> /etc/timelu.txt
rm -rf /tmp/time.txt


echo "Update erfolgreich abgeschlossen"

Es kommt immer direkt die Fehlermeldung: Permission Denied

Bin für jeden Tipp dankbar.

 

[lügnix]

AW: Settings über eigenen Server laden möglich

Habe mich damit auch bisschen befasst und möchte euch meine cron_get zeigen.

Habe ein Webserver über ein Anbieter. Mit dem ich per SFTP die Datei hochlade und von dort erhält der Receiver die Updates.

Bin gerade dabei es noch zu optimieren, dann braucht man keine cron_get mehr. Wenn ich fertig bin gebe ich bescheid.

cron_get:

Spoiler

#!/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

cron_pack (kommt auf dem Server, wird eine Datei geändert wird automatisch mit cronjob eine tar.bz2 erstellt:

Spoiler

#!/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

functions_cron_pack.conf:

Spoiler

#!/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 ++++++++++++++++++++++++++++++#

 

[Opelpower]

AW: Settings über eigenen Server laden möglich

Gibt es eine Möglichkeit die Senderliste (enigma2.tar) direkt herunterzuladen??
Ich meine halt ohne Port/Benutzer/Passwort usw. (h**p://MEINSERVER/Settings/enigma2.tar)

 

[amassidda]

AW: Settings über eigenen Server laden möglich

Gibt es eine Möglichkeit die Senderliste (enigma2.tar) direkt herunterzuladen??
Ich meine halt ohne Port/Benutzer/Passwort usw. (h**p://MEINSERVER/Settings/enigma2.tar)

Ja das ist möglich

Muss man eben den Standart Port 80 für Appache nicht ändern so wie die User Passwort abfrage weg lassen.

Dann klappt das ohne Probleme.

Gruß

amassidda


Gesendet von meinem iPad mit Tapatalk

 

[Opelpower]

AW: Settings über eigenen Server laden möglich

So läuft jetzt fast alles perfekt.
Ich musste die Dateien auf dem Receiver mit "Dos2unix" umwandeln.
Hab mir jetzt ein IPK Paket (hat ganz schön Nerven gekostet) erstellt, um die Sender auf der Box zu speichern und
eins, um die Senderliste direkt vom Server herunterzuladen und einzuspielen.

Nächstes Ziel ist es, dass die gespeicherte Senderliste direkt auf meinen FTP Server hochgeladen wird.........