kyopages/scripts/getFlashPlayer

#!/bin/bash

version=4.9.0
date="04/03/2018"
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(){		# 01/03/2018

	if type -p tput &>/dev/null && tput setaf 1 &>/dev/null; then
		  BLACK=$( tput setaf 0 )
			RED=$( tput setaf 1 )		# alerte
		  GREEN=$( tput setaf 2 )		# ok
		 YELLOW=$( tput setaf 3 )		# question
		   BLUE=$( tput setaf 4 )		# info
		   CYAN=$( tput setaf 6 )
		MAGENTA=$( tput setaf 5 )
			STD=$( tput sgr0 )			# retour "normal"
		BOLD=$( tput bold )
		ITAL=$( tput sitm )
		SOUL=$( tput smul )
	else 
		YELLOW=$( echo -n "\033[0;33m" )		# ?
		 GREEN=$( echo -n "\033[0;32m" )		# ok
		  BLUE=$( echo -n "\033[0;34m" )		# info
		   RED=$( echo -n "\033[0;31m" )		# alerte
		 COLOR=$( echo -n "\033[0m" )		# standard
		   STD=$( echo -n "\033[0m" )		# standard
	fi
}

	# 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(){		# 22/02/2018
	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
}

	# recherche commandes/paquets, $1 liste: cmd1|cmd2[>paquet] (séparées par espaces) ex: "gawk|mawk>gawk wget"
	# si manque, return 1 & affiche commandes manquantes (si debian, ajout proposition paquet à installer)
f__requis(){		# 26/01/2018
	local ENV_DEBIAN ireq table package commands command commandsMissing packagesMissing 

	type -p "dpkg" &>/dev/null && ENV_DEBIAN="oui"							# debian
	type -t f__info &>/dev/null && c_echo="f__info" || c_echo="echo -e"		# f__info existe? sinon echo

	for ireq in $1; do						# pour tous les composants de la liste $1
		table=( ${ireq//>/ } )				# séparation sur >, split avec double bashisme, mais évite manip $IFS

		commands=( ${table[0]//|/ } )		# séparation sur |
		if [ ${table[1]} ]; then
			package=${table[1]}
		else
			package="$commands"				# pas de oackages dans les options, donc idem commands[0]
		fi

		for command in ${commands[@]}; do	# pour toutes les commandes
			if type -p "$command" &>/dev/null ; then
				unset commandsMissing packagesMissing
				break
			else	# inexistant
				commandsMissing+="$command "
				packagesMissing+="$package "
			fi
		done
	done

		# dédoublonnage & triage
	commandsMissing=$( echo $commandsMissing | tr ' ' '\n' | sort --unique | tr '\n' ' ' )
	packagesMissing=$( echo $packagesMissing | tr ' ' '\n' | sort --unique | tr '\n' ' ' )
		# suppression éventuel espace final
	commandsMissing=${commandsMissing% }
	packagesMissing=${packagesMissing% }
		# affichage final
	if [ "$commandsMissing" ] && [ "$ENV_DEBIAN" ]; then
		$c_echo "${RED}erreur critique, manquant: $STD$BOLD$commandsMissing" \
						"vous devriez exécuter:$GREEN apt install $packagesMissing"
	elif [ "$commandsMissing" ]; then
		$c_echo "${RED}erreur critique, manquant: $STD$BOLD$commandsMissing"
	fi

	[ "$commandsMissing" ] && return 1 || return 0
}

	# $@=cmd à lancer en root avec su ou sudo. si $@ contient [':x:'] x=nombre de tentatives, 3 par défaut
	# si sudo si possible sera utilisé. 
	# si su &2 redirigé sur &1
	# si bash inexistant, return 2
f__sudo(){		# 24/02/2018
	local nb sudo isudo toBash options nbDefault=3

		# détermination sudo possible
	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
		# extraction nb de tentatives éventuel
	if [[ "$@" =~ :.{1,2}: ]]; then
		nb="$@"
		nb=${nb#*:}
		nb=${nb%:*}
		options=${@//:$nb:/ }
		(( ${nb}+1 )) 2>/dev/null || nb="$nbDefault"	# test si numérique, sinon, 
	else
		nb="$nbDefault"
		options="$@"
	fi
		# lancement cmds
	if [[ "$sudo" =~ ^sudo ]]; then
			$sudo "$options"
	else
		for (( isudo=1 ; isudo<="$nb" ; isudo++ )); do 
			echo -n "[su] Root, "
			$sudo "$options" 2>&1	 # redirection demande pass (et erreur) sur &1 (utile quand &2 est redirigé en amont)
			[ "$?" == 0 ] && break
			[ "$isudo" == "$nb" ] && return 1
		done
	fi
}

	# 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(){		# 24/02/2018
	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 who | grep -qv 'root'; then 
			user=$( who | grep -v 'root' | head -n1 | cut -d ' ' -f1 );	# who | grep -v 'root' | 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
	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(){		# 22/02/2018
	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$STD"
		else
			echo -e "$BLUE  $1$STD\t$GREEN  $retourHttp$STD" 
		fi
	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(){		# 24/01/2018
		local affichage_text="              _   _____ _           _     ____  _                       
    __ _  ___| |_|  ___| | __ _ ___| |__ |  _ \| | __ _ _   _  ___ _ __ 
   / _' |/ _ \ __| |_  | |/ _' / __| '_ \| |_) | |/ _' | | | |/ _ \ '__|
  | (_| |  __/ |_|  _| | | (_| \__ \ | | |  __/| | (_| | |_| |  __/ |   
   \__, |\___|\__|_|   |_|\__,_|___/_| |_|_|   |_|\__,_|\__, |\___|_|   
   |___/                                                |___/"

	clear
	echo "$BLUE$affichage_text"
	tput cuu1						# une ligne plus haut
	tput cuf 10						# 10 caractères à droite
	echo -e "${YELLOW}pour Firefox, version $version - $date$STD\n"
}

f_help(){		# 04/03/2018
	local ligne help=(
		"-----------------------------------------------------------------------"
		"$BLUE$script install$STD :  installation de $appli"
		"    avec option $GREEN--sauve$STD l'archive téléchargée est sauvegardée dans le répertoire courant"
		""
		"$BLUE$script remove$STD  :  désinstallation de $appli"
		"$BLUE$script upgrade$STD :  mise à jour plugin si disponible"
		"$BLUE$script version$STD :  versions de $appli et du script, en ligne et installée"
		""
		"$BLUE$script manuel$GREEN archive.tar.gz$STD : installation d'une archive téléchargée manuellement"
		"-----------------------------------------------------------------------"
		"$BLUE./$script$STD (ou $BLUE./$script -i$STD) : installation du script dans le système (root)"
		"$BLUE$script -h$STD, --help    : affichage aide"
		"$BLUE$script -r$STD, --remove  : désinstallation du script $RED(root)$STD"
		"$BLUE$script -u$STD, --upgrade : mise à jour script & $appli"
		"$BLUE$script -v$STD, --version : version du script"
		""
		)

	tput cuu1						# une ligne plus haut
	for ligne in "${help[@]}"; do
		echo -e "  $ligne"
	done
	echo -e "$STD  plus d'infos: $GREEN https://kyodev.frama.io/kyopages/scripts/getFlashPlayer/$STD"
	echo "  -----------------------------------------------------------------------"
}

fflash_avertissement(){		# 24/01/2018

cat << 'EOF'
  FlashPlayer n'est pas libre, c'est un programme propriétaire dont on ne peut pas connaître 
  le code source, que l'on ne peut utiliser sans conditions, ni même distribuer librement.
  Il souffre de nombreuses vulnérabilités chroniques, depuis des années...
  Il sera 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(){		# 24/01/2018
	local verInstall

	x_get_version=1
		# détection version en ligne
	ver_flash=$( wget -q --tries=2 --timeout=15 --user-agent="$user_agent" -o /dev/null -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' )
		[[ "$ver_flash" && "$verInstall" == "$ver_flash" ]] || plugin_a_jour="ko"
	else
		verInstall="Non Installé"
	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(){		# 04/03/2018
	local verArchive recup_url file_temp dirTemp="/tmp/$script" 

	[ "$operation" == "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/flashplayer_$ver_flash""_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 /dev/null -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
	mkdir -p "$dir_install"
	cp -f "$dirTemp/libflashplayer.so"  "$dir_install/"
	chown -R "$fu_user:" "$dir_install"
		# svg éventuelle archive, effacement répertoire temporaire
	if [ "$dl_to_svg" == "ok" ]; then
		chown "$fu_user:" "$fileTemp"
		mv "$fileTemp" ./
	fi
	rm -Rf "$dirTemp/"

	if [ "$1" == "manuel" ]; then
		f__info "log" "archive FlashPlayer $verArchive installé"
	else
		f__info "log:raw" "FlashPlayer $ver_flash installé"
	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(){		# 24/01/2018
	local verInstall

	if [ ! -e "$dir_install/libflashplayer.so" ]; then
		f__info "FlashPlayer non installé pour $fu_user\n"
		return 1
	fi
	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(){		# 24/01/2018

	if [ ! -e "$dir_install/libflashplayer.so" ]; then
		f__info "FlashPlayer non installé pour $fu_user\n"
		return 1
	fi
	(( 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(){		# 26/01/2018
	local dirAnacron dirSpool fileAnacron

	type -t fscript_cronAnacron_special &>/dev/null && 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, [$1=quiet], assigne $ver_script_install, $ver_script_online, $script_a_jour=ok|KO
fscript_get_version(){		# 24/01/2018

	x_script_get_version=1
		# version online
	ver_script_online=$( wget -q --timeout=15 -o /dev/null -O - "$url_script" | grep -m1 '^version=' | cut -d'=' -f2 )
	[ "$?" -ne 0 ] && f__wget_test "$url_script"
		# 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é"
	[ "$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(){		# 24/02/2018

	if grep -Eq "$script_install|/usr/bin/$script" <<< "$0"; then
		f__info "${RED}l'installation dans le système doit se faire depuis le script non installé $GREEN(./$script -i )"
		return 1
	fi
	type -t fscript_install_special &>/dev/null && 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(){		# 24/02/2018

	if ! grep -Eq "$script_install|/usr/bin/$script" <<< "$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

	type -t fscript_remove_special &>/dev/null && fscript_remove_special	# test, si fonction spécifique, appel
		# suppression /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(){		# 01/03/2018
	local dirTemp="/tmp/$script-maj" upgradeEnPlace="$1"

	type -t fscript_update_special &>/dev/null && fscript_update_special	# test, si fonction spécifique, appel
	if [ -z "$upgradeEnPlace" ] && ! grep -Eq "$script_install|/usr/bin/$script" <<< "$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 /dev/null -O "$dirTemp/$script" "$url_script"
	if [ "$?" -ne 0 ]; then
		rm -rf "$dirTemp"
		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/"
}

prg_init(){		# 04/03/2018

	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"

		# 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 "awk>gawk file tar strings>binutils getconf>libc-bin"  || exit 1 
}

######## 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
appli="Flashplayer"
dir_install="/home/$fu_user/.mozilla/plugins"
url_online="https://get.adobe.com/fr/flashplayer/"		# test version & referer

options=$@
	# auto-installation script éventuel, si pas de marqueur $fileDev
if [[ $( dirname $0 ) != $( dirname $script_install ) && $( dirname $0 ) != "/usr/bin" && ! -e "$fileDev" ]]; then
	options="-i" 		# option installation script
fi

for j in $options; do								# première passe options
	case $j in
		-i | --install | -r | --remove )
			if [ "$EUID" -ne 0 ]; then
				f__info "vous devez être$RED ROOT$BLUE pour cette opération"
				f__sudo "exec $0 $@"
				exit
			fi
			;;&
		--sauve )
			dl_to_svg="ok"
			;;&
	esac
done
options=${options//--sauve/ }

[ "$options" ] || options="-h"		# vide? help

for j in $options; do
	case $j in
		install )									# installation plugin
			fflash_install
			;;
		manuel )									# installation manuelle d'un chargement
			fflash_install_manuel "$2"
			shift 1
			exit;;
		remove )									# remove plugin
			fflash_remove
			;;
		upgrade )									# upgrade plugin si installé
			operation="upgrade"
			fflash_upgrade
			;;

		version | versions )						# version plugin en ligne & installée
			fscript_get_version
			fflash_get_version
			;;

		-i | --install )							# installation du script dans le système
			fscript_install
			;;
		-r | --remove )								# désinstallation du script
			fscript_remove
			;;
		-u | --upgrade )							# upgrade script et plugin
			operation="upgrade"
			fscript_update
			$0 upgrade	# on relance le script en upgrade pour le plugin
			exit ;;
		-v | --version )							# version du script, en ligne et en place
			fscript_get_version
			;;
		-h | --help | * )		 					# affichage help
			f_help
			fflash_avertissement
			;;
	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