kyopages/scripts/getFlashPlayer

#!/bin/bash

version=3.19.0
date="6/12/2017"
projet="simpledeb"
contact="IRC freenode ##sdeb ou https://framagit.org/kyodev/kyopages/issues/"
script="getFlashPlayer"

##### license LPRAB/WTFPL
#  auteur: simpledeb
#    contributeurs: kyodev, coyotus, naguam
#####

f_affichage(){		# 5/12/2017
	f__color
	clear
	echo -n "$BLUE"
cat << 'EOF'
                _   _____ _           _     ____  _                       
      __ _  ___| |_|  ___| | __ _ ___| |__ |  _ \| | __ _ _   _  ___ _ __ 
     / _' |/ _ \ __| |_  | |/ _' / __| '_ \| |_) | |/ _' | | | |/ _ \ '__|
    | (_| |  __/ |_|  _| | | (_| \__ \ | | |  __/| | (_| | |_| |  __/ |   
     \__, |\___|\__|_|   |_|\__,_|___/_| |_|_|   |_|\__,_|\__, |\___|_|   
     |___/                                                |___/           
EOF
echo -e "$YELLOW         pour Firefox, version $version - $date$STD\n"
}

	# test validité archive, $1 archive, assigne $archive_detect (gzip|xz|deb|zip), return 1 si inconnue
f__archive_test(){		# 30/08/2017
	local filetest="$(file -b $1)"

	grep -q 'gzip compressed data' <<< "$filetest"  && archive_detect="gzip"
	grep -q 'bzip2 compressed data' <<< "$filetest" && archive_detect="bzip2"
	grep -q 'Debian binary package' <<< "$filetest" && archive_detect="deb"
	grep -q 'Zip archive data' <<< "$filetest"      && archive_detect="zip"
	grep -q 'XZ compressed data' <<< "$filetest"    && archive_detect="xz"
	if [ ! "$archive_detect" ] || [ "$archive_detect" == "empty" ]; then return 1; fi
}

f__color(){		# 08/10/2017
	YELLOW=$(tput setaf 3)		# question
	 GREEN=$(tput setaf 2)		# ok
	  BLUE=$(tput setaf 4)		# info
	   RED=$(tput setaf 1)		# alerte
	   STD=$(tput sgr0)			# retour normal
		MAGENTA=$(tput setaf 5)
		CYAN=$(tput setaf 6)
	BOLD=$(tput bold)
	ITAL=$(tput sitm)
	SOUL=$(tput smul)
}

	# affichage $1 en rouge, $1++ optionnels en bleu, sortie script sur erreur, log $1 si $opType=upgrade
f__error(){		# 4/12/2017
	local depart=1 i

	echo -e "\n$RED  $script $version, erreur critique: $1 $STD"
	for (( i=2 ; i<=$# ; i++ )); do
		echo -e "  $BLUE${!i}$STD"
	done
	echo
	if [ "$opType" == "upgrade" ]; then f__log "$script $version: $1"; fi
	exit 1
}

	# affichage des paramètres en bleu, si $1=raw pas de ligne vide à la fin, si $1=log alors uniquement $2 logué
f__info(){		# 15/10/2017
	local depart=1 i

	if [ "$1" == "raw" ] || [ "$1" == "log" ]; then depart=2; fi
	[ "$1" == "log" ] && f__log "$(sed -E 's/\\t//;s/\\n// ' <<< $2 | xargs )"
	for (( i=$depart ; i<=$# ; i++ )); do
		echo -e "  $BLUE${!i}$STD"
	done
	[ "$1" == raw ] || echo 
}

	# log spécifique, fichier log limité à 10000 octets, $1 message à loguer
f__log(){		# 4/12/2017
	if [ -w "$scriptLogs" ];  then 
		if [ "$(stat -c %s  $scriptLogs)" -ge "10000" ]; then
			echo "$(date +%Y%m%d\ %H%M%S) $1"  &>/dev/null > "$scriptLogs"
		else 
			echo "$(date +%Y%m%d\ %H%M%S) $1"  &>/dev/null >> "$scriptLogs"
		fi
	fi
}

	# test dépendances/paquets, $1 liste commande[>paquet] (ex: killall>psmisc)
	# si manque, return 1 & info commandes manquantes, si debian proposition paquet à installer 
	# si $2=debOnly et si paquets manquants: return 1 et $debOnlyAbsent ( $1=liste paquets )
	# si $2=debOnly et si paquets présent: return 0 et $debOnlyPresent ( $1=liste paquets )
	# attention priorité $debOnlyAbsent sur $debOnlyPresent
f__requis(){		# 4/12/2017
	local dependsMissing packagesMissing command package ireq compteur pluriel

	unset debOnlyAbsent debOnlyPresent
	for ireq in $1; do
		command="$(cut -d '>' -f 1 <<< $ireq)"
		package="$(cut -d '>' -f 2 <<< $ireq)"
		if [ "$2" == "debOnly" ]; then
			if type -p "dpkg" &>/dev/null ; then	# package only et debian
				LC_ALL=C dpkg --get-selections | grep -qE "^$package[[:space:]]+install" \
					&& debOnlyPresent+="$package " || debOnlyAbsent+="$package " 
			fi
		elif ! type -p "$command" &>/dev/null ; then
			dependsMissing+="$command "
			packagesMissing+="$package "
		fi
	done
	[ "$debOnlyAbsent" ] && debOnlyAbsent="$(xargs <<< $debOnlyAbsent)"		# trim début & fin
	[ "$debOnlyPresent" ] && debOnlyPresent="$(xargs <<< $debOnlyPresent)"		# trim début & fin
	[ "$debOnlyAbsent" ] && return 1 
	[ "$debOnlyPresent" ] && return 0
	if [ "$dependsMissing" ]; then
		compteur="$(wc -w <<< $dependsMissing)"
		[ "$compteur" -gt "1" ] && pluriel="s" || unset pluriel
		if [ -e /etc/debian_version ]; then 
			f__info "$RED""erreur critique: $compteur paquet"$pluriel" manquant"$pluriel": $STD$BOLD$dependsMissing" \
				"\n  vous devriez exécuter:$GREEN apt install $packagesMissing"
		else 
			f__info "$RED""erreur critique: $compteur commande"$pluriel" manquante"$pluriel": $STD$BOLD$dependsMissing"
		fi
		return 1
	fi
}

	# $1=cmd si $2: nb de tentatives pour s'identifier, sinon 2 tentatives par défaut, suppose bash existant
f__sudo(){		# 4/12/2017
	local nb=2 sudo isudo toBash

	[ $( type -p bash 2>/dev/null ) ] && toBash="$( type -p bash )" || return 2
		# sudo --shell bash		équivalent su ?
	if sudo -v &>/dev/null && [ $EUID -ne 0 ] ; then
		sudo="sudo su --shell $toBash --preserve-environment -c "
	else
		sudo="su --shell $toBash --preserve-environment -c "
	fi
	[ "$2" ] && nb="$2"
	for (( isudo=1 ; isudo<="$nb" ; isudo++ )); do 
		$sudo " $1"
		[ "$?" == 0 ] && break
		[ "$isudo" == "$nb" ] && return 1
	done
}

	# user ayant initié la session graphique, assigne $fu_user
	# return 1 sur échec identification user, return 2 sur absence home/
	# gestion variable environnement user avec: USER_INSTALL=<user> script
f__user(){		# 3/12/2017
	local user userid test root_login

	root_login="$(grep ':0:' /etc/passwd | cut -d':' -f1)" || root_login="root"
	if [ "$USER_INSTALL" ]; then 	# user via variable environnement, moyen d'injecter root si pb 
		fu_user="$USER_INSTALL"; 
		return 0
	elif [[ "$TERM" =~ linux ]]; then	#debian 9 recovery ou nomodeset TERM=linux
		if [ "$USER" ]; then
			user="$USER"
		elif [ "$EUID" -eq 0 ]; then
			fu_user="$root_login"
			return 0
		fi
	fi
	if [ "$SUDO_UID" ]; then 
		userid="$SUDO_UID"; 
	elif grep -qEo '[0-9]+' <<< "$XDG_RUNTIME_DIR" ; then 
		userid="$(grep -Eo '[0-9]+' <<< $XDG_RUNTIME_DIR | cut -d'/' -f4)"
	elif grep -qEo '[0-9]+' <<< "$XAUTHORITY" ; then 
		userid="$(grep -Eo '[0-9]+' <<< $XAUTHORITY | cut -d'/' -f4)"
	fi
	[ "$userid" ] && user="$(grep $userid /etc/passwd | cut -d ":" -f 1 )"
	if [ "$user" ] && [ "$user" != "$root_login" ]; then
		fu_user="$user"
		return 0
	else
		if [ "$SUDO_USER" ] && [ "$SUDO_USER" != "$root_login" ]; then 
			user="$SUDO_USER"; 
		elif grep -qv 'root' <<< "$(who)"; then 
			user="$(grep -v 'root' <<< $(who) | head -n1 | cut -d ' ' -f1)";	# grep -v 'root' <<< $(who) | gawk 'FNR==1{print $1}'
		elif grep -q 'hourly.*get[A-Z].*\.anacrontab.*\.config/anacron/spool' /etc/crontab; then 
			user="$(grep 'hourly.*get[A-Z].*\.anacrontab.*\.config/anacron/spool' /etc/crontab | head -n1 | cut -d' ' -f2)"; # grep 'hourly.*get[A-Z].*\.anacrontab.*\.config/anacron/spool' /etc/crontab | gawk 'FNR==1{print $2}
		fi
	fi
	fu_user="$user"
	[ "$fu_user" ] || return 1
	[ -d "/home/$fu_user" ] || return 2
	return 0
}

	# test wget, $1=url à tester, sortie du script (même si url testée ok) avec affichage erreur ou ok
	# si $2=print affiche url testée & entêtes http & location, return 0
	# si $2=loc affiche seulement location, return 0
	# si $2=test return 0 si ok, return 1 si KO
f__wget_test(){		# 5/12/2017
	local file_test_wget retourWget retourHttp location

	file_test_wget="/tmp/testWget-$$-$RANDOM"
	wget -Sq --timeout=10 --user-agent="$user_agent" --spider --save-headers "$1" &>"$file_test_wget"
	retourWget="$?"
	[ "$retourWget" == 1 ] && retourWget="1: code erreur générique"
	[ "$retourWget" == 2 ] && retourWget="2: parse erreur (ligne de commande?)"
	[ "$retourWget" == 3 ] && retourWget="3: erreur Entrée/sortie fichier"
	[ "$retourWget" == 4 ] && retourWget="4: défaut réseau"
	[ "$retourWget" == 5 ] && retourWget="5: défaut vérification SSL"
	[ "$retourWget" == 6 ] && retourWget="6: défaut authentification"
	[ "$retourWget" == 7 ] && retourWget="7: erreur de protocole"
	[ "$retourWget" == 8 ] && retourWget="8: réponse serveur en erreur"
	retourHttp="$( grep -i 'HTTP/' "$file_test_wget" | tr -d '\n' | xargs )"
	location="$( grep -i 'location' $file_test_wget | xargs )"
	if [ "$2" == "test" ]; then
		rm  "$file_test_wget" 2>/dev/null
			# spécial maintenance frama.link, pas de redirection sur page status framalink
		[ "$( grep -c '303' <<< $retourHttp )" -ne 0 ] && return 1	# 303 See Other
		[ "$retourWget" == "0" ] && return 0 || return 1
	fi
	if [ "$2" == "print" ]; then
		if [ "$retourWget" != "0" ]; then
			echo "erreur wget: $RED$retourWget" 
			echo -e "$BLUE  $1$STD\t$RED  $retourHttp"
		else
			echo -e "$BLUE  $1$STD\t$GREEN  $retourHttp" 
		fi
		echo "$STD"
	fi
	if [ "$2" == "print" ] || [ "$2" == "loc" ]; then
		[ "$location" ] && echo -n "$YELLOW  $location" || echo -n "$YELLOW  no location"
		echo "$STD"
		rm  "$file_test_wget" 2>/dev/null
		return 0
	fi
	if [ "$retourWget" != "0" ]; then
		rm  "$file_test_wget" 2>/dev/null
#		f__error "wget, $retourWget" "$1" "$YELLOW$retourHttp" "$location"
		echo -e "$RED   erreur wget, $retourWget \n  $1 \n  $YELLOW$retourHttp \n  $location$STD"
	fi
	if [ "$(grep -c '200' <<< $retourHttp)" -ne 0 ]; then 
		echo -e "$GREEN\ntout est ok, réessayer$STD\n"
	fi
	rm  "$file_test_wget" 2>/dev/null
	exit 0
}

	# affichage help
f_help(){		# 5/12/2017
	echo -n "$BLUE"
cat << 'EOF'
  -----------------------------------------------------------------------
  getFlashPlayer install :  téléchargement & installation de FlashPlashplayer
  getFlashPlayer remove  :  désinstallation de FlashPlayer
  getFlashPlayer version :  version en ligne de FlashPlayer et du script
  getFlashPlayer upgrade :  mise à jour plugin si disponible
  ----
  getFlashPlayer manuel fichier.tar.gz : installation manuelle d'une archive
  ----
  ./getFlashPlayer                       : installation du script dans le système
  getFlashPlayer -h, --help              : affichage aide
  getFlashPlayer -r, --remove, sysremove : désinstallation du script du système
  getFlashPlayer -u, --upgrade           : mise à jour script & plugin, cron hebdomadaire
  getFlashPlayer -v, --version           : versions du script
EOF
	echo -n "$STD"
 cat << 'EOF'
  -----------------------------------------------------------------------
  Ce script doit être exécuté avec les droits root uniquement pour 
  l'installation et la suppression du script dans le système. 
  SEUL le plugin sera installé comme plugin Firefox, par tout utilisateur,
  sans droits root requis.
  -----------------------------------------------------------------------
EOF
	echo -e "  plus d'infos: $GREEN https://kyodev.frama.io/kyopages/scripts/getFlashPlayer/\n$STD"
}

	# pas beau ce soft :(
fflash_avertissement(){		# 5/12/2017
	echo -n "$BLUE"
cat << 'EOF'
  FlashPlayer n'est pas libre, c'est un programme propriétaire dont on
  ne peut pas connaître le code source, ni l'utiliser sans conditions,
  ni le distribuer librement.
  Il souffre de nombreuses vulnérabilités chroniques, depuis des années...
  Il sera bloqué plus ou moins bloqué à terme pas les navigateurs majeurs,
  c'est à dire Firefox et Chrom(ium). Préparez vous à cela...
EOF
	echo -e "  voir:$GREEN https://developer.mozilla.org/fr/docs/Plugins/Roadmap$STD\n"
}

	# version Flash en ligne & installée, si $1="quiet" pas d'affichage, $verFlash=x.y, $plugin_aJour=ko
fflash_get_version(){		# 5/12/2017
	local verInstall

		# détection version en ligne
	verFlash="$(wget -q --tries=2 --timeout=15 --user-agent="$user_agent" -O - "$urlOnline" | \
		sed -nr 's/^.*AUTO_ID.*Version[[:blank:]]+([0-9].*[0-9]).*$/\1/p')"
	[ "$verFlash" ] || verFlash="n/a"
	[ "$1" == "quiet" ] || f__info "version FlashPlayer en ligne: $YELLOW$verFlash"
	if [ ! -e "$dirInstall/libflashplayer.so" ]; then
		f__info "FlashPlayer non installé"
		return 0
	fi
		# détection version du plugin installé
	verInstall="$(strings $dirInstall/libflashplayer.so | grep -Eo '[0-9]+_[0-9]+_[0-9]+_[0-9]+' | sed 's/_/./g')"
	if [ "$verInstall" == "$verFlash" ]; then 
		[ "$1" == "quiet" ] || f__info "FlashPlayer $GREENà jour"
	elif [[ "$verFlash" == "n/a" ]]; then
		f__info "version FlashPlayer en place: $GREEN$verInstall"
	else
		plugin_aJour="ko"
		[ "$1" == "quiet" ] || f__info "version FlashPlayer en place: $GREEN$verInstall$STD, mise à jour possible"
	fi
}

	# install plugin dans config user mozilla, $1 manuel (install manuelle), $2 script à installer si install manuelle
fflash_install(){		# 5/12/2017
	local dirTemp fileTemp

	[ "$opType" == "upgrade" ] || fflash_avertissement
	if [ "$1" == "manuel" ]; then
		f__info "installation manuelle de $2"
		dirTemp="$(dirname $2)/$script-$RANDOM"
		fileTemp="$(basename $2)"
		mkdir -p "$dirTemp"
	else
		[ -z $verFlash ] && fflash_get_version "quiet"	# pas de test si version=n/a, dès fois que le DL fonctionne
		f__info "installation FlashPlayer, version $verFlash"
		dirTemp="/tmp/$script-$RANDOM"
		fileTemp="$dirTemp/flash_player_npapi_linux.$(getconf LONG_BIT).tar.gz"
		mkdir -p "$dirTemp"
			# détection/chargement/test archive plugin flashplayer
		f__info "  - téléchargement..."
		fflash_recup_url_v1
		wget -q --show-progress --tries=2 --timeout=15 --user-agent="$user_agent" --referer="$urlOnline" -O "$fileTemp" "$recup_url" 2>&1
		[ "$?" -eq 0 ] || f__wget_test "$recup_url"
		f__archive_test "$fileTemp" || f__error "    Le fichier $fileTemp n'est pas une archive tar.gz valide"
	fi
		# décompression archive téléchargée dans dossier de travail
	f__info "  - décompression..."
	tar -xaf "$fileTemp" -C "$dirTemp/"
	if [ "$1" == "manuel" ]; then
		verFlash="$(strings $dirTemp/libflashplayer.so | grep -Eo '[0-9]+_[0-9]+_[0-9]+_[0-9]+' | sed 's/_/./g')"
	fi
		# copie de la bibliothèque flash dans plugins/ user mozilla, effacement répertoire temporaire
	mkdir -p "$dirInstall"
	cp -f "$dirTemp/libflashplayer.so"  "$dirInstall/"
	rm -Rf "$dirTemp/"
		# droits user si jamais installation par root
	chown -R "$fu_user:" "$dirInstall"
	f__info "log" "FlashPlayer $verFlash installé pour $fu_user" "\tPour tester$YELLOW: http://get.adobe.com/flashplayer/about/"
}

	# installation du plugin chargé manuellement, $1
fflash_install_manuel(){		# 5/12//2017
	[ -e "$1" ] || f__error "fichier plugin $1 introuvable"
	f__archive_test "$1" || f__error "Le fichier $1 n'est pas une archive valide"
	fflash_install "manuel" "$1"
}

	# calcul url téléchargement plugin, assigne $recup_url, 
fflash_recup_url_v1(){		# 30/08/2017
	local recup1 recup2

	recup1="https://fpdownload.adobe.com/get/flashplayer/pdc/"
	if [ "$(uname -m)" == "i686" ] || [ "$(uname -m)" == "i386" ]; then
		recup2='i386'
	elif [ "$(uname -m)" == "x86_64" ] || [ "$(uname -m)" == "amd64" ]; then 
		recup2='x86_64'
	else 
		f__error "architecture non reconnue"
	fi
	recup_url="$recup1$verFlash/flash_player_npapi_linux.$recup2.tar.gz"
}

	# suppression du plugin
fflash_remove(){		# 5/12/2017
	local verInstall

	[ -e "/home/$fu_user/.mozilla/plugins/libflashplayer.so" ] || f__error "FlashPlayer inexistant pour $fu_user\n"
	verInstall=$( strings $dirInstall/libflashplayer.so | grep -Eo '[0-9]+_[0-9]+_[0-9]+_[0-9]+' | sed 's/_/./g' )
	rm "$dirInstall/libflashplayer.so"
	rm "$dirInstall/libflashplayer.maj" &>/dev/null			# ancien fichier éventuel
	rm "$dirInstall/libflashplayer.version" &>/dev/null		# ancien fichier éventuel
	f__info "log" "FlashPlayer $verInstall désinstallé pour $fu_user"
}

	# test et mise à jour plugin si plugin outdated
fflash_upgrade(){		# 5/12/2017
	fflash_get_version
	if [ "$verFlash" == "n/a" ]; then
		f__info "log" "version du plugin flash non accessible flash"
	elif [ "$plugin_aJour" == "ko" ]; then
		fflash_install
	else
		f__info "log" "pas de mise à jour disponible pour Flash"
	fi
}

	# spécifique script
fscript_cronAnacron_special(){		# 5/12/2017
	rm "/home/$fu_user/.mozilla/plugins/libflashplayer.anacrontab" &>/dev/null	# ancienne localisation 
	rm "/home/$fu_user/.config/anacron/spool/getFP"* &>/dev/null				# ancien job
		# ancienne localisation anacrontab, suppression 
	[ "$EUID" -eq 0 ] && sed -i "/libflashplayer.anacrontab/d" /etc/crontab
}

	# spécifique script
fscript_install_special(){		# 5/12/2017
		# changement ancien logs
	[ -e "/var/log/sdeb_getFlash.log" ] && mv "/var/log/sdeb_getFlash.log" "$scriptLogs"
}

	# inscription dans tache upgrade en anacron hebdomadaire, via cron horaire, $1=upgrade|install|remove
fscript_cronAnacron(){		# 4/12/2017
	local dirAnacron dirSpool fileAnacron

	[ "$(type -t fscript_cronAnacron_special)" ] && fscript_cronAnacron_special		# test, si fonction spécifique, appel
	dirAnacron="/home/$fu_user/.config/anacron"
	dirSpool="$dirAnacron/spool"
	fileAnacron="$dirAnacron/$script.anacrontab"
	[ "$EUID" -eq 0 ] && sed -i "/$script.anacrontab/d" /etc/crontab
	case "$1" in 
		install | upgrade )
			mkdir -p  "$dirAnacron"
				# table anacron
			echo "7 10 $script nice $scriptInstall --upgrade 1>/dev/null" > "$fileAnacron"	# juste erreurs en syslog
				## anacron journalier pour dev logname 
			if [ -e "$fileDev" ]; then
				echo "1 00 $script""Dev nice $scriptInstall --upgrade 1>/dev/null" >> "$fileAnacron"
			fi
				# création spool anacron utilisateur
			mkdir -p "$dirSpool"
			chown -R "$fu_user:" "$dirAnacron" "$dirSpool"
			if [ "$EUID" -eq 0 ]; then
					# crontab pour activation horaire anacron
				echo "@hourly $fu_user /usr/sbin/anacron -t $fileAnacron -S $dirSpool" >> /etc/crontab
			fi
			[ "$(grep "$script" /etc/crontab)" ] || echo f__error "inscription crontab" \
				"certains systèmes semblent poser poser problème, merci de rapporter ce bug à $projet, $contact"
		;;
		remove )
			rm "$dirSpool/$script"* &>/dev/null
			rm "$fileAnacron" &>/dev/null
			rmdir "$dirSpool" "$dirAnacron" &>/dev/null
		;;
	esac
}

	# version script en ligne, [$1=update], assigne $versionScript, $script_aJour=ok|ko
fscript_get_version(){		# 5/12/2017
	local var_temp

	f__info "raw" "version script en cours: $GREEN$version"
	versionScript=$(wget -q --timeout=15 -O - "$urlScript" | grep -m1 '^version=' | cut -d'=' -f2)
	if [ "$versionScript" ]; then 
		if [ "$version" != "$versionScript" ]; then 
			[ "$1" == "update" ] && var_temp=", mise à jour en cours" || var_temp=", mise à jour possible"
			script_aJour="ko"
		else
			script_aJour="ok"
		fi
		f__info "version script en ligne: $YELLOW$versionScript$BLUE$var_temp"
	else 
		f__info "version script en ligne$RED non accessible"
	fi
}

	# installation du script dans le système
fscript_install(){		# 4/12/2017
	if grep -q 'bin' <<< "$(dirname $0)" ; then
		f__info "$RED""l'installation dans le système doit se faire depuis un script local $GREEN(./$script -i )"
		return 1
	fi
	if [ "$EUID" -ne 0 ]; then
		f__info "vous devez être$RED ROOT$BLUE pour installer ce script dans le système"
		f__sudo "exec $0 -i"
		return $?
	fi
	[ "$(type -t fscript_install_special)" ] && fscript_install_special		# test, si fonction spécifique, appel
	f__requis "wget anacron cron" || exit 1 
		# install /opt
	mkdir -p /opt/bin/
	cp -d "$(basename $0)" "$scriptInstall"
	ln -s "$scriptInstall" "/usr/bin/$script" &>/dev/null
	chmod 775 "$scriptInstall"	# rwx rwx r-x, proprio fu_user
		# cron/anacron install
	fscript_cronAnacron "install"
		# création fichier log
	touch "$scriptLogs"
	chmod 664 "$scriptLogs"	# rw- rw- r--, proprio fu_user
	chown "$fu_user:" "$scriptLogs" "$scriptInstall"
	[ -e "$fileDev" ] || rm "$(basename $0)" &>/dev/null	## on efface pas si fileDev (dev)
	f__info "log" "$script $version installé dans le système." "maintenant, appel du script par: $GREEN$script$BLUE (sans ./)"
}

	# suppression du script dans le système
fscript_remove(){		# 4/12/2017
	if ! grep -q 'bin' <<< "$(dirname $0)" ; then
		f__info "$RED""cette fonction doit être appelée depuis le script installé dans le système $GREEN($script -r)"
		return 1
	fi
	if [ ! -x "$scriptInstall" ];then
		f__info "$RED$script n'est pas installé"
		return 1
	fi
	if [ "$EUID" -ne 0 ]; then
		f__info "vous devez être$RED ROOT$BLUE pour supprimer ce script dans le système"
		f__sudo "exec $0 -r"
		return $?
	fi
	[ "$(type -t fscript_remove_special)" ] && fscript_remove_special		# test, si fonction spécifique, appel
		# suppression de /opt
	rm "$scriptInstall" &>/dev/null
	unlink "/usr/bin/$script" &>/dev/null
		# cron/anacron remove
	fscript_cronAnacron "remove"
	f__info "log" "$script $version supprimé du système."
}

	# mise à jour script si dispo, v2, +update spécifique
fscript_update(){		# 6/12/2017
	local dirTemp="/tmp/$script-$RANDOM"

	[ $(type -t fscript_update_special) ] && fscript_update_special		# test, si fonction spécifique, appel
	if [ -z "$updateSpecial" ] && ! grep -q 'bin' <<< "$(dirname $0)" ; then
		f__info "$RED""cette fonction doit être appelée depuis le script installé dans le système $GREEN($script -u)"
		return 1
	fi
	fscript_get_version "update"
	if [ "$script_aJour" == "ok" ]; then 
		f__info "log" "pas de mise à jour disponible pour $script $version"
		return 0
	fi
	mkdir -p "$dirTemp"
	wget -q --tries=2 --timeout=15 -O "$dirTemp/$script" "$urlScript"
	if [ "$?" != "0" ]; then f__wget_test "$urlScript"; fi
	if grep -q '#!/bin/bash' "$dirTemp/$script" && grep -q '^### END CONTROL' "$dirTemp/$script"; then 
		cp -d "$dirTemp/$script" "$scriptInstall"
		chmod 775 "$scriptInstall"	# rwx rwx r-x, proprio fu_user
		chown "$fu_user:" "$scriptInstall"
		[ -z "$updateSpecial" ] && fscript_cronAnacron "upgrade"
		f__info "log" "$script mis à jour en version $versionScript $updateSpecial"
	else
		rm -rf "$dirTemp/"
		f__error "échec update" "mauvais téléchargement, réessayer plus tard"
	fi
	rm -rf "$dirTemp/"
}

prg_init(){		# 4/12/2017

	PATH='/usr/sbin:/usr/bin:/sbin:/bin' 
	TERM=xterm  
	IFS_INI="$IFS"
	IFS=$' \t\n'
	export PATH TERM IFS

		# test bash v4
	[ "$BASH_VERSINFO" == 4 ] || f__error "bash v4 requis" "version installée: $BASH_VERSION"

		# test SSH
	[[ "$SSH_CLIENT" || "$SSH_CLIENT" || "$SSH_CLIENT" ]] && ENV_SSH="ssh"
		# test $DISPLAY
	[ -z "$DISPLAY" ]  && ENV_DISPLAY="no DISPLAY"

		# détermination user derrière root
	f__user
	retourFUser="$?"
	[ "$retourFUser" -eq 1 ] && f__error "user indéterminé" \
		"pour contourner, lancer le script avec:\n$GREEN  USER_INSTALL=<user> $0 \n"
	if [ "$retourFUser" -eq 2 ]; then
		[ "$EUID" -eq 0 ] && fu_user="root" || f__error "user détecté, mais pas de home: /home/$fu_user"
		f__info "user root"
	fi

		# requis pour fonctionnement programme
	f__requis "file tar"  || exit 1 
}

######## début script / initialisation

	# tests au démarrage
prg_init

	# logo et définition couleurs
f_affichage

urlScript="https://framagit.org/kyodev/kyopages/raw/master/scripts/getFlashPlayer"
urlNotice="https://kyodev.frama.io/kyopages/scripts/getFlashPlayer/"
user_agent="Mozilla/5.0 Firefox"

scriptInstall="/opt/bin/$script"
scriptLogs="/var/log/sdeb_$script.log"
fileDev="/opt/bin/fileDev"

dirInstall="/home/$fu_user/.mozilla/plugins"
urlOnline="https://get.adobe.com/fr/flashplayer/"		# test version & referer

[ -e "$scriptInstall" ] && [ "$(stat -c %G $scriptInstall)" == "root" ] && problemDetected+="-1"	# droits inappropriés sur le script, version de dev
options=$@
if [ "$(dirname $0)" == "." ] && [ ! -e "$fileDev" ]; then
	options="-i" 		# script install
else
	if [ ! -w "$scriptLogs" ] && [ -e "$dirInstall/libflashplayer.so" ]; then	# ancien système de logs via syslog
		problemDetected+="-2"
	fi
fi
[ "$problemDetected" ] && f__info "$RED""l'installation du script est obsolète ($problemDetected)" \
	"veuillez réinstaller le script manuellement" "$GREEN""voir $urlNotice#messages-avertissement"

for j in $options; do
	case $j in
		install )
			fflash_install
			exit ;;										# installation plugin
		manuel )
			fflash_install_manuel "$2"
			exit ;;										# installation manuelle d'un chargement
		remove )
			fflash_remove
			exit ;;										# désinstallation plugin
		upgrade )
			opType="upgrade"
			fflash_upgrade
			exit ;;										# upgrade plugin si installé
		version | versions ) 
			fflash_get_version
			fscript_get_version
			exit ;;										# version plugin en ligne & installée
		-i ) 
			fscript_install
			exit ;;										# installation du script dans le système
		-r | --remove | sysremove )
			fscript_remove
			exit ;;										# désinstallation du script
		-u | --upgrade )
			opType="upgrade"
			fscript_update
			$0 upgrade	# on relance le script en upgrade pour le plugin
			exit ;;										# upgrade script et plugin
		-v | --version )
			fscript_get_version
			exit ;;										# version du script, en ligne et exécuté
		-h | --help | * )
			f_help
			fflash_avertissement
			exit ;;		 								# affichage help
	esac
done

exit 0

### END CONTROL (contrôle chargement)

wget -O getFlashPlayer https://framagit.org/kyodev/kyopages/raw/master/scripts/getFlashPlayer
chmod +x getFlashPlayer && ./getFlashPlayer