kyopages/scripts/getFlashPlayer

#!/bin/bash

version=4.1.0
date="29/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
#####

	# détecte architecture système, assign $fu_archi: i386|x86_64
	# return 1 on unknown architecture
	# remarque, debian: dpkg --print-architecture affiche i386
f__architecture(){		# 14/12/2017		SPECIFIQUE

	x_architecture=1
	case "$(uname -m)" in
		amd64 | x86_64 )
			fu_archi="x86_64";;
		i?86 | x86 )
			fu_archi="i386";;
		* )
			case "$(getconf LONG_BIT)" in
				64 )
					fu_archi="x86_64";;
				32 )
					fu_archi="i386";;
				*)
					return 1
			esac ;;
	esac
}

	# test validité archive, $1 archive, assigne $archive_detect (gzip|xz|deb|zip), return 1 si inconnue
f__archive_test(){		# 19/12/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"
	[[ -z "$archive_detect" || "$archive_detect" == "empty" ]] && return 1  || return 0		# laisser return 0 final sinon erreur, toujours return 1?!!
}

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 $operation=upgrade
f__error(){		# 18/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
	[ "$operation" == "upgrade" ] && f__log "$script $version: $1"
	exit 1
}

	# affichage en bleu, si $1=raw pas de ligne vide à la fin, si $1=log alors uniquement $2 logué, combiné: $1="log:raw"
f__info(){		# 26/12/2017
	local depart=1 i

	[[ "$1" =~ "raw"  ||  "$1" =~ "log" ]] && depart=2
	[[ "$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 "$script_logs" ];  then 
		if [ "$(stat -c %s  $script_logs)" -ge "10000" ]; then
			echo "$(date +%Y%m%d\ %H%M%S) $1"  &>/dev/null > "$script_logs"
		else 
			echo "$(date +%Y%m%d\ %H%M%S) $1"  &>/dev/null >> "$script_logs"
		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(){		# 23/12/2017
	local nb=2 sudo isudo toBash

	type -p bash &>/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, $2=''|print|loc|test
	# par défaut, 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(){		# 24/12/2017
	local file_test_wget="/tmp/testWget-$script" retourWget retourHttp location

	wget -Sq --timeout=5 --tries=2 --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 -f "$file_test_wget"
			# spécial maintenance frama.link, pas de redirection sur page status framalink
		grep -q '303' <<< $retourHttp && return 1			# 303 See Other
		[ "$retourWget" == "0" ] && return 0 || return 1
	fi
	if [ "$2" == "print" ]; then
		if [ "$retourWget" != "0" ]; then
			echo "erreur wget: erreur $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 -f "$file_test_wget"
		return 0
	fi
	if [ "$retourWget" != "0" ]; then
		rm -f "$file_test_wget"
		f__error "wget, erreur $retourWget" "$1" "$YELLOW$retourHttp" "$location"
		echo -e "$RED   erreur wget, $retourWget \n  $1 \n  $YELLOW$retourHttp \n  $location$STD" # pour les diags
		return 1
	fi
	if grep -q '200' <<< $retourHttp; then 
		echo -e "$GREEN\ntout est ok, réessayer$STD\n"
	fi
	rm -f "$file_test_wget"
	exit 0
}

f_affichage(){		# 27/12/2017

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

	# affichage help
f_help(){		# 27/12/2017
	echo -n "$BLUE"
cat << 'EOF'
  -----------------------------------------------------------------------
  getFlashPlayer install :  téléchargement & installation de FlashPlashplayer
  getFlashPlayer remove  :  désinstallation de FlashPlayer
  getFlashPlayer version :  versions de FlashPlayer et du script, en ligne et installées
  getFlashPlayer upgrade :  mise à jour plugin si disponible
  ----
  getFlashPlayer manuel archive.tar.gz   : installation manuelle d'une archive
  ----
  ./getFlashPlayer                       : installation du script dans le système (root)
  getFlashPlayer -h, --help              : affichage aide
  getFlashPlayer -r, --remove, sysremove : désinstallation du script du système (root)
  getFlashPlayer -u, --upgrade           : mise à jour script & plugin
  getFlashPlayer -v, --version           : versions du script
  -----------------------------------------------------------------------
EOF
	echo -e "$STD  plus d'infos: $GREEN https://kyodev.frama.io/kyopages/scripts/getFlashPlayer/\n$STD"
}

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, $ver_flash, $plugin_a_jour=ko
fflash_get_version(){		# 27/12/2017
	local verInstall

	x_get_version=1
		# détection version en ligne
	ver_flash=$( wget -q --tries=2 --timeout=15 --user-agent="$user_agent" -O - "$url_online" | \
		sed -nr 's/^.*AUTO_ID.*Version[[:blank:]]+([0-9].*[0-9]).*$/\1/p' )
		# détection version installée
	if [ -e "$dir_install/libflashplayer.so" ]; then
		verInstall=$( strings $dir_install/libflashplayer.so | grep -Eo '[0-9]+_[0-9]+_[0-9]+_[0-9]+' | sed 's/_/./g' )
	else
		verInstall="Non Installé"
	fi

	if [[ "$verInstall" && "$ver_flash" ]]; then 
		[ "$verInstall" == "$ver_flash" ] || plugin_a_jour="ko"
	fi
	[ "$ver_flash" ] || ver_flash="$RED""n/a"
	[ "$1" == "quiet" ] && return 0

	f__info "raw" "FlashPlayer en place: $GREEN$verInstall"
	f__info "FlashPlayer en ligne: $YELLOW$ver_flash"
}

	# install plugin dans config user mozilla, [$1='manuel', $2 archive]
fflash_install(){		# 27/12/2017
	local verArchive recup_url file_temp dirTemp="/tmp/$script" 

	[ "$opType" == "upgrade" ] || fflash_avertissement
	mkdir -p "$dirTemp"
	if [ "$1" == "manuel" ]; then
		f__info "installation manuelle de $2 version $verArchive"
		fileTemp="$2"
	else
		(( x_get_version == 1 )) || fflash_get_version "quiet"
		f__info "installation FlashPlayer, version $ver_flash"
		fileTemp="$dirTemp/flash_player_npapi-linux$( getconf LONG_BIT ).tar.gz"
			# détection/chargement/test archive plugin flashplayer
		f__info "  - téléchargement..."
		recup_url="https://fpdownload.adobe.com/get/flashplayer/pdc/"
		recup_url+="$ver_flash/flash_player_npapi_linux.$fu_archi.tar.gz"
		wget -q -c --show-progress --tries=2 --timeout=15 --user-agent="$user_agent" --referer="$url_online" -o "$wget_log" -O "$fileTemp" "$recup_url"
		[ "$?" -eq 0 ] || f__wget_test "$recup_url"
	fi
	f__archive_test "$fileTemp" || f__error "    Le fichier $fileTemp n'est pas une archive tar.gz valide"
		# décompression archive téléchargée dans dossier de travail
	f__info "\n    - décompression..."
	tar -xaf "$fileTemp" -C "$dirTemp/"
	verArchive=$( grep -m1 -i 'version' "$dirTemp/readme.txt" )
	verArchive=${verArchive,,}
	verArchive=${verArchive#version }
		# copie de la bibliothèque flash dans plugins/ user mozilla, effacement répertoire temporaire
	mkdir -p "$dir_install"
	cp -f "$dirTemp/libflashplayer.so"  "$dir_install/"
	rm -Rf "$dirTemp/"
		# droits user si jamais installation par root
	chown -R "$fu_user:" "$dir_install"

	if [ "$1" == "manuel" ]; then
		f__info "log" "archive FlashPlayer $verArchive installé pour $fu_user"
	else
		f__info "log:raw" "FlashPlayer $ver_flash installé pour $fu_user"
	fi
	f__info "  Pour tester$YELLOW: http://get.adobe.com/flashplayer/about/"
}

	# installation du plugin chargé manuellement, $1=archive
fflash_install_manuel(){		# 27/12//2017

	[ -e "$1" ] || f__error "fichier plugin $1 introuvable"
	fflash_install "manuel" "$1"
	[ -e "$fileDev" ] || rm -f "$1" ## on n'efface pas si fileDev (dev)
}

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

	[ -e "/home/$fu_user/.mozilla/plugins/libflashplayer.so" ] || f__error "FlashPlayer inexistant pour $fu_user\n"
	rm "$dir_install/libflashplayer.so"
	rm -f "$dir_install/libflashplayer.maj"					# ancien fichier éventuel
	rm -f "$dir_install/libflashplayer.version"				# ancien fichier éventuel

	f__info "log" "FlashPlayer désinstallé pour $fu_user"
}

	# test et mise à jour plugin si plugin outdated
fflash_upgrade(){		# 27/12/2017

	(( x_get_version == 1 )) || fflash_get_version "quiet"
	if [[ "$ver_flash" =~ "n/a" ]]; then
		f__info "log" "version en ligne du plugin flash non accessible"
	elif [ "$plugin_a_jour" == "ko" ]; then
		fflash_install
	else
		f__info "log" "pas de mise à jour disponible"
	fi
}

	# tache upgrade dans anacron hebdomadaire, via cron horaire, $1=upgrade|install|remove
fscript_cronAnacron(){		# 29/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 $script_install --upgrade 1>/dev/null" > "$fileAnacron"	# juste erreurs en syslog
				## anacron journalier pour dev logname 
			if [ -e "$fileDev" ]; then
				echo "1 00 $script""Dev nice $script_install --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 -q "$script" "/etc/crontab" || echo f__error "inscription crontab"
		;;
		remove )
			rm -f "$dirSpool/$script"*  &>/dev/null
			rm -f "$fileAnacron" &>/dev/null
			rmdir "$dirSpool" "$dirAnacron" &>/dev/null
		;;
	esac
}

	# version script en ligne, [$1=quiet], assigne $ver_script_install, $ver_script_online, $script_a_jour=ok|KO
fscript_get_version(){		# 27/12/2017
	local wget_log="/tmp/wget_$RANDOM.log"

	x_script_get_version=1
		# version online
	ver_script_online=$( wget -q --timeout=15 -o "$wget_log" -O - "$url_script" | grep -m1 '^version=' | cut -d'=' -f2 )
	if [ "$?" -ne 0 ]; then
		rm "$wget_log"
		f__wget_test "$url_script"
	fi
		# version installée
	if [ -e "$script_install" ]; then
		ver_script_install=$( grep -m1 '^version=' $script_install | cut -d'=' -f2 )
	fi

	if [[ "$ver_script_online" && "$script_install" ]]; then 
		[ "$ver_script_install" != "$ver_script_online" ] && script_a_jour="KO" || script_a_jour="ok"
	fi
	[ "$ver_script_online" ] || ver_script_online="$RED""n/a"
	[ "$ver_script_install" ] || ver_script_install="Non installé"
	rm "$wget_log"
	[ "$1" == "quiet" ] && return 0

	f__info "raw" "script en place: $GREEN$ver_script_install"
	f__info "script en ligne: $YELLOW$ver_script_online"
}

	# installation du script dans le système
fscript_install(){		# 27/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 "$0" "$script_install"
	ln -s "$script_install" "/usr/bin/$script" &>/dev/null
	chmod 775 "$script_install"	# rwx rwx r-x, proprio fu_user
		# cron/anacron install
	fscript_cronAnacron "install"
		# création fichier log
	touch "$script_logs"
	chmod 664 "$script_logs"	# rw- rw- r--, proprio fu_user
	chown "$fu_user:" "$script_logs" "$script_install"
	[ -e "$fileDev" ] || rm -f "$0"			## 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(){		# 27/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 "$script_install" ];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 lien /usr/bin
	rm -f "$script_install"
	unlink "/usr/bin/$script" &>/dev/null
		# cron/anacron remove
	fscript_cronAnacron "remove"

	f__info "log" "$script $version supprimé du système."
}

	# mise à jour script, [$1 != "" si upgrade en place, $1 dans message info]
fscript_update(){		# 27/12/2017
	local dirTemp="/tmp/$script-maj" wget_log="/tmp/wget_$RANDOM.log" upgradeEnPlace="$1"

	[ "$(type -t fscript_update_special)" ] && fscript_update_special		# test, si fonction spécifique, appel
	if [ -z "$upgradeEnPlace" ] && ! 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
	(( x_script_get_version == 1 )) || fscript_get_version
	if [ "$script_a_jour" == "ok" ]; then 
		f__info "log" "pas de mise à jour disponible pour $script $version"
		return 0
	else
		f__info "mise à jour en cours"
	fi
	mkdir -p "$dirTemp"
	wget -q --tries=2 --timeout=15 -o "$wget_log" -O "$dirTemp/$script" "$url_script"
	if [ "$?" -ne 0 ]; then
		rm -rf "$dirTemp/"
		rm -f "$wget_log"
		f__wget_test "$url_script"
	fi
	if grep -q '#!/bin/bash' "$dirTemp/$script" && grep -q '^### END CONTROL' "$dirTemp/$script"; then 
		cp -d "$dirTemp/$script" "$script_install"
		chmod 775 "$script_install"	# rwx rwx r-x, proprio fu_user
		chown "$fu_user:" "$script_install"
		[ -z "$upgradeEnPlace" ] && fscript_cronAnacron "upgrade"
		f__info "log" "$script mis à jour en version $ver_script_online $updateSpecial"
	else
		f_info "log" "$script: échec update" "mauvais téléchargement, réessayer plus tard"
	fi
	rm -rf "$dirTemp/"
	rm -f "$wget_log"
}

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"

		# architectures possibles
	f__architecture || f__error "Seules les architecture 32 et/ou 64 bits sont supportée (i686 & amd64)"

		# 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

		# définition couleurs
	f__color

		# requis pour fonctionnement programme
	f__requis "file tar strings>binutils getconf>libc-bin"  || exit 1 

		#  fichier log pour wget, évite bug wget? sur testing
	touch "/tmp/wget.log" && wget_log="/tmp/wget.log" || wget_log="/tmp/wget-$RANDOM.log" # accessible?: wget.log sinon avec un random
	chmod 666 "$wget_log" 2>/dev/null		# rw pour tous, écrasable et effaçable par tous
}

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

	# tests au démarrage
prg_init

	# logo et définition couleurs
f_affichage

	# paramètres script
user_agent="Mozilla/5.0 Firefox"
fileDev="/opt/bin/fileDev"
script_install="/opt/bin/$script"
script_logs="/var/log/sdeb_$script.log"
url_script="https://framagit.org/kyodev/kyopages/raw/master/scripts/getFlashPlayer"
url_notice="https://kyodev.frama.io/kyopages/scripts/getFlashPlayer/"

	# paramètres flash
dir_install="/home/$fu_user/.mozilla/plugins"
url_online="https://get.adobe.com/fr/flashplayer/"		# test version & referer

options=$@
if [ "$(dirname $0)" == "." ] && [ ! -e "$fileDev" ]; then
	options="-i" 		# script install
fi
[ "$options" ] || options="-h"		# vide? help

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 ) 
			fscript_get_version
			fflash_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