kyopages/scripts/getFlashPlayer

#!/bin/bash

version=3.17.0
date="16/10/2017"
projet="simpledeb"
contact="IRC freenode ##sdeb ou https://framagit.org/kyodev/kyopages/issues/"
script="getFlashPlayer"
urlScript="https://framagit.org/kyodev/kyopages/raw/master/scripts/getFlashPlayer"
urlNotice="https://kyodev.frama.io/kyopages/scripts/getFlashPlayer/"
user_agent="Mozilla/5.0 Firefox"

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

f__affichage(){		# 08/10/2017
	f__color
	clear
	printf "$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(){		# 15/10/2017
	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é à 10000octets, $1 message à loguer
f__log(){		# 08/09/2017
	if [ -w "$fileLogs" ];  then 
		if [ "$(stat -c %s  $fileLogs)" -ge "10000" ]; then
			echo "$(date +%Y%m%d\ %H%M%S) $1"  &>/dev/null > "$fileLogs"
		else 
			echo "$(date +%Y%m%d\ %H%M%S) $1"  &>/dev/null >> "$fileLogs"
		fi
	else
		f__info "$fileLogs doit être activé" "Réinstaller un script plus récent" \
			"voir $GREEN""$urlNotice#installation-rapide-du-script"
	fi
}

	# $1=cmd si $2: nb de tentatives pour s'identifier, sinon 1 tentative par défaut
f__sudo(){		# 11/10/2017
	local nb=1 sudo isudo
		# sudo --shell bash		équivalent su ?
	if sudo -v &>/dev/null && [ $EUID -ne 0 ] ; then
		sudo="sudo su --shell $(which bash) --preserve-environment -c "
	else
		sudo="su --shell $(which bash) --preserve-environment -c "
	fi
	[ "$2" ] && nb="$2"
	for (( isudo=1 ; isudo<="$nb" ; isudo++ )); do 
		$sudo " $1"
		[ "$?" == 0 ] && break
		[ "$isudo" == "$nb" ] && return 1
	done
}

	# test dépendances/paquets, $1 liste commande[>paquet] (ex: killall>psmisc)
	# si manque, SORTIE & info commandes manquantes, si debian, SORTIE & proposition paquet à installer 
	# si $2=debOnly et si paquets manquants: return 1 et $debOnlyPackages ( $1=liste paquets )
	# si $2=debOnly et si paquets présent: return 0 et $debOnlyPresents ( $1=liste paquets )
	# attention priorité $debOnlyPackages sur $debOnlyPresents
f__requis(){		# 15/10/2017
	local dependsMissing packagesMissing command package i
	unset debOnlyPackages debOnlyPresents
	for i in $1; do
		command="$(cut -d '>' -f 1 <<< $i)"
		package="$(cut -d '>' -f 2 <<< $i)"
		if [ "$2" == "debOnly" ]; then
			if [ "$(which dpkg)" ]; then	# package only et debian
				LC_ALL=C dpkg --get-selections | grep -qE "^$package[[:space:]]+install" \
					&& debOnlyPresents+="$package " || debOnlyPackages+="$package " 
			else f__error "dpkg n'est pas disponible sur ce système"; fi
		elif [ -z "$(which $command)" ]; then
			dependsMissing+="$command "
			packagesMissing+="$package "
		fi
	done
	[ "$debOnlyPackages" ] && debOnlyPackages="$(xargs <<< $debOnlyPackages)"		# trim début & fin
	[ "$debOnlyPresents" ] && debOnlyPresents="$(xargs <<< $debOnlyPresents)"		# trim début & fin
	[ "$debOnlyPackages" ] && return 1 
	[ "$debOnlyPresents" ] && return 0
	if [ "$dependsMissing" ]; then
		if [ -e /etc/debian_version ]; then f__error "paquet(s) manquant(s): " "  $dependsMissing" \
			"  vous devriez exécuter:$GREEN apt install $packagesMissing"
		else f__error "commandes(s) manquante(s): " "$dependsMissing"; fi	# -> exit
		return 1
	fi
}

	# user ayant initié la session graphique, assigne $user_
	# return 1 sur échec identification user, return 2 sur absence home/
	# gestion variable environnement user avec: USER_INSTALL=user script
f__user(){		# 06/10/2017
	local user_id 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 
		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
			user_="$root_login"
			return 0
		fi
	fi
	if [ "$SUDO_UID" ]; then 
		user_id="$SUDO_UID"; 
	elif grep -qEo '[0-9]+' <<< "$XDG_RUNTIME_DIR" ; then 
		user_id="$(grep -Eo '[0-9]+' <<< $XDG_RUNTIME_DIR | cut -d'/' -f4)"
	elif grep -qEo '[0-9]+' <<< "$XAUTHORITY" ; then 
		user_id="$(grep -Eo '[0-9]+' <<< $XAUTHORITY | cut -d'/' -f4)"
	fi
	[ "$user_id" ] && user_="$(grep $user_id /etc/passwd | cut -d ":" -f 1 )"
	if [ "$user_" ] && [ "$user_" != "$root_login" ]; then
		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) | awk '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 | awk 'FNR==1{print $2}
		fi
	fi
	if [ -z "$user_" ]; then return 1; fi
	if [ ! -d "/home/$user_" ]; then return 2; fi
	return 0
}

	# test wget, $1 url à tester, sortie du script si $1 seul (même si url testée ok)
	# si $2=print affiche url testée & entêtes http & location (si présente) et sortie normale fonction
	# si $2=loc affiche seulement location et sortie normale fonction
	# si $2=test return 0 si ok, return 1 si ko
f__wget_test(){		# 15/10/2017
	local file_test_wget retourWget retourHttp location
	file_test_wget="/tmp/testWget-$$-$RANDOM"
	wget -Sq --tries=1 --timeout=10 --user-agent="$user_agent" --spider --save-headers "$1" &>"$file_test_wget"
	retourWget="$?"
	[ "$2" == "test" ] && rm  "$file_test_wget"
	[ "$2" == "test" ] && [ "$retourWget" == "0" ] && return 0 || return 1
	[ "$retourWget" == 1 ] && retourWget="code erreur générique"
	[ "$retourWget" == 2 ] && retourWget="parse erreur (ligne de commande?)"
	[ "$retourWget" == 3 ] && retourWget="erreur Entrée/sortie fichier"
	[ "$retourWget" == 4 ] && retourWget="défaut réseau"
	[ "$retourWget" == 5 ] && retourWget="défaut vérification SSL"
	[ "$retourWget" == 6 ] && retourWget="défaut authentification"
	[ "$retourWget" == 7 ] && retourWget="erreur de protocole"
	[ "$retourWget" == 8 ] && retourWget="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" == "print" ]; then
		if [ "$retourWget" ]; then 
			echo "erreur wget: $RED$retourWget" 
			echo -e "$BLUE  $1$STD\t$RED  $retourHttp"
		else
			echo -e "$BLUE  $1$STD\t$GREEN  $retourHttp" 
		fi
	fi
	if [ "$2" == "print" ] || [ "$2" == "loc" ]; then
		[ "$location" ] && echo "$YELLOW  $location" || echo "$YELLOW  no location"
		echo "$STD"
		return 0
	fi
	if [ "$retourWget" ]; then
		rm  "$file_test_wget"
		f__error "erreur wget, $retourWget" "$1" "$YELLOW$retourHttp"
	fi
	if [ "$(grep -c '200' <<< $retourHttp)" -ne 0 ]; then 
		echo -e "$GREEN\ntout est ok, réessayer\n$STD"
	fi
	rm  "$file_test_wget"
	exit 0
}

	# affichage help
f_help(){		# 08/10/2017
	printf "$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
	printf "$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. 
  Il désinstallera le paquet flashplugin-nonfree si présent (debian). 
  SEUL le plugin sera installé comme plugin Firefox.
  -----------------------------------------------------------------------
EOF
echo -e "  plus d'infos: $GREEN https://kyodev.frama.io/kyopages/scripts/getFlashPlayer/\n"
}

	# pas beau ce soft :(
fflash_avertissement(){		# 06/2017
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
  sans que l'éditeur fasse beaucoup d'efforts pour corriger cela...
  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(){		# 06/2017
	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="na"
	if [ "$?" != "0" ]; then f__wget_test "$urlOnline"; fi		# sortie script si erreur wget
	if [ $verFlash == "na" ]; then f__error "version FlashPlayer non accessible";
	else [ "$1" == "quiet" ] || f__info "version FlashPlayer en ligne: $verFlash"; fi
	if [ ! -e "$dirInstall/libflashplayer.so" ]; then
		f__info "FlashPlayer non installé"
		return 0
	fi
		# détection version du plugin installé
	local 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 à jour"
	else
		plugin_aJour="ko"
		[ "$1" == "quiet" ] || f__info "version FlashPlayer installée: $verInstall, mise à jour possible"
	fi
}

	# install plugin dans config user mozilla, $1 manuel (install manuelle), $2 script à installer si install manuelle
fflash_install(){		# 06/09/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"
		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
		if [ "$?" != "0" ]; then f__wget_test "$recup_url"; fi
		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 "$user_:" "$dirInstall"
	f__info "log" "FlashPlayer $verFlash installé pour $user_" "\tPour tester$YELLOW: http://get.adobe.com/flashplayer/about/"
}

	# installation du plugin chargé manuellement, $1
fflash_install_manuel(){		# 16/08/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"
	[ -e "$fileDev" ] || rm "$1" &>/dev/null	## on efface pas si fileDev (dev)
}

	# 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(){		# 06/2017
	[ -e /home/kyodev/.mozilla/plugins/libflashplayer.so ] || f__error "FlashPlayer inexistant pour $user_\n"
	local 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 $user_"
}

	# test et mise à jour plugin si plugin outdated
fflash_upgrade(){		# 30/08/2017
	fflash_get_version
	if [ "$plugin_aJour" == "ko" ]; then
		fflash_install
	else f__info "log" "pas de mise à jour disponible pour Flash"; fi
}

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

	# spécifique script
fscript_install_special(){		# 25/08/2017
	[ -e "/var/log/sdeb_getFlash.log" ] && mv "/var/log/sdeb_getFlash.log" "$fileLogs"		# changement ancien logs
	if f__requis "flashplugin-nonfree" "debOnly" && [ "$debOnlyPresents" ]; then
		apt-get purge flashplugin-nonfree
	fi
}

	# inscription dans tache upgrade en anacron hebdomadaire, via cron horaire, $1=upgrade|install|remove
fscript_cronAnacron(){		# 06/09/2017
	local dirAnacron dirSpool fileAnacron
	[ "$(type -t fscript_cronAnacron_special)" ] && fscript_cronAnacron_special		# test, si fonction spécifique, appel
	dirAnacron="/home/$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 /opt/bin/$script --upgrade 1>/dev/null" > "$fileAnacron"	# juste erreurs en syslog
				## anacron journalier pour dev logname 
			if [ -e "$fileDev" ]; then
				echo "1 00 $script""Dev nice /opt/bin/$script --upgrade 1>/dev/null" >> "$fileAnacron"
			fi
				# création spool anacron utilisateur
			mkdir -p "$dirSpool"
			chown -R "$user_:" "$dirAnacron" "$dirSpool"
			if [ "$EUID" -eq 0 ]; then
					# crontab pour activation horaire anacron
				echo "@hourly $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, assigne $versionScript, $script_aJour=ok|ko
fscript_get_version(){		# 08/10/2017
	f__info "raw" "$GREEN""version script en cours: $version"
	versionScript="$(wget -q --tries=2 --timeout=15 -O - "$urlScript" | grep '^version=' | cut -d '=' -f 2)"
	if [ "$versionScript" ]; then 
		if [ "$version" != "$versionScript" ]; then 
			f__info "version script en ligne: $versionScript, mise à jour possible"
			script_aJour="ko"
		else
			f__info "version script en ligne: $versionScript"
			script_aJour="ok"
		fi
	else f__info "version script en ligne $RED""non accessible"; fi
}

	# installation du script dans le système
fscript_install(){		# 08/10/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"
		# install /opt
	mkdir -p /opt/bin/
	cp -d "$(basename $0)" "/opt/bin/$script"
	ln -s "/opt/bin/$script" "/usr/bin/$script" &>/dev/null
	chmod 775 "/opt/bin/$script"	# rwx rwx r-x, proprio user_
		# cron/anacron install
	fscript_cronAnacron "install"
		# création fichier log
	touch "$fileLogs"
	chmod 664 "$fileLogs"	# rw- rw- r--, proprio user_
	chown "$user_:" "$fileLogs" "/opt/bin/$script"
	[ -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(){		# 08/10/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 "/opt/bin/$script" ];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 "/opt/bin/$script" &>/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
fscript_update(){		# 08/10/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 -u)"
		return
	fi
	[ "$(type -t fscript_update_special)" ] && fscript_update_special		# test, si fonction spécifique, appel
	fscript_get_version
	if [ "$script_aJour" == "ok" ]; then 
		f__info "log" "pas de mise à jour disponible pour $script $version"
		return 0
	fi
	local dirTemp="/tmp/$script-$RANDOM"
	mkdir -p "$dirTemp"
	wget -q --tries=2 --timeout=15 -O "$dirTemp/$script" "$urlScript"
	if [ "$?" != "0" ]; then f__wget_test "$urlScript"; fi
	chmod 775 "/opt/bin/$script"	# rwx rwx r-x, proprio user_
	chown "$user_:" "$dirTemp/$script"
	cp -d "$dirTemp/$script" "/opt/bin/$script"
	rm -rf "$dirTemp/"
	fscript_cronAnacron "upgrade"
	f__info "log" "$script mis à jour en version $versionScript"
}

	#initialisation
PATH='/usr/sbin:/usr/bin:/sbin:/bin'; TERM=xterm; IFS=$' \t\n'
export PATH TERM IFS

f__affichage

f__user
retourFUser="$?"
[ "$retourFUser" -eq 1 ] && f__error "user indéterminé" 
[ "$retourFUser" -eq 2 ] && f__error "user détecté, mais pas de home: /home/$user_"

[ "$(grep -o 'version 4' <<< $(bash --version) | sed 's/version //')" -ge "4" ] || f__error "bash version 4"
f__requis "file tar"		# requis pour fonctionnement programme

fileLogs="/var/log/sdeb_$script.log"
fileDev="/opt/bin/fileDev"
dirInstall="/home/$user_/.mozilla/plugins"
urlOnline="https://get.adobe.com/fr/flashplayer/"		# test version & referer

[ -e "/opt/bin/$script" ] && [ "$(stat -c %G /opt/bin/$script)" == "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 "$fileLogs" ] && [ -e "$dirInstall/libflashplayer.so" ] ; then problemDetected+="-2"; fi	# ancien système de logs via syslog
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
unset j
exit 0

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