kyopages/scripts/getFlashPlayer

#!/bin/bash

version=3.6.0
date="27/08/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(){		# v06/2017	définition couleurs
	YELLOW="$(printf "\033[0;33m")"		# ?
	 GREEN="$(printf "\033[0;32m")"		# ok
	  BLUE="$(printf "\033[0;34m")"		# info
	   RED="$(printf "\033[0;31m")"		# alerte
	 COLOR="$(printf "\033[0m")"		# standard

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

	# test validité archive, $1 fichier (gzip), return 1 si invalide
f__archive_test(){		# v07/2017
	file -b "$1" | grep -q 'gzip compressed data' || return 1
}

	# affichage $1 en rouge, $1++ optionnels en bleu, sortie script sur erreur, log $1 si $opType=upgrade
f__error() {		# v25/08/2017
	echo -e "\n$RED  $script $version, erreur critique: $1 $COLOR"
	for (( i=2 ; i<=$# ; i++ )); do echo -e "  $BLUE${!i}"; done 
	echo "$COLOR"
	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 uniquement $2 logué
f__info() {		# v25/08/2017
	local depart=1
	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}"; done
	[ "$1" == raw ] && printf "$COLOR" || echo "$COLOR"
}

	# log spécifique, fichier log limité à 10000octets, $1 message à loguer
f__log(){		# v08/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é"
	fi
}

	# 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(){		# v17/08/2017-3
	local dependsMissing packagesMissing
	unset debOnlyPackages debOnlyPresents
	for i in $1; do
		local command="$(cut -d '>' -f 1 <<< $i)"
		local 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
	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(){		# v21/08/2017-4
	if [ "$USER_INSTALL" ]; then 	# user_ via variable environnement, moyen d'injecter root 
		user_="$USER_INSTALL"; 
		return 0
	fi
	local user_id test
	local root_login="$(grep ':0:' /etc/passwd | cut -d':' -f1)" || local root_login="root"
	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)";
		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)"; 
		fi
	fi
	if [ -z "$user_" ]; then return 1; fi
	if [ ! -d "/home/$user_" ]; then return 2; fi
	return 0
}

	# test wget, $1 url à tester affiche url testée & entêtes http, sortie script sur erreur
f__wget_test(){		#v25/08/2017
	local file_test_wget="/tmp/testWget-$RANDOM"
	wget -Sq --tries=1 --timeout=10 --user-agent="$user_agent" --spider --save-headers "$1" &>"$file_test_wget" || local retourWget="$?"
	[ "$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)"
	f__error "erreur wget: $retourWget" "url: $1" "$retourHttp" \
		"Erreur wget" "si persistance, contacter $projet $contact en indiquant les messages précédents" 
	rm  "$file_test_wget"
}

	# pas beau ce soft :(
fflash_avertissement(){
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$COLOR\n"
}

	# version Flash en ligne & installée, si $1="quiet" pas d'affichage, $verFlash=x.y, $plugin_aJour=ko
fflash_get_version(){
	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
}

	# affichage help
fflash_help(){
	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 d'une archive manuellement
  ----
  ./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 "$COLOR"
 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/$COLOR\n"
}

	# install plugin dans config user mozilla, $1 manuel (install manuelle), $2 script à installer si install manuelle
fflash_install(){		#v27/08/2017
	[ "$opType" == "upgrade" ] || fflash_avertissement
	if [ "$1" == "manuel" ]; then
		f__info "installation manuelle de $2"
		local dirTemp="$(dirname $2)/$script-$RANDOM/"
		local fileTemp="$(basename $2)"
		mkdir -p "$dirTemp"
	else
		[ -z $verFlash ] && fflash_get_version "quiet"
		f__info "installation FlashPlayer, version $verFlash"
		local dirTemp="/tmp/$script-$RANDOM/"
		local 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 -c --show-progress --tries=1 --timeout=15 --user-agent="$user_agent" --referer="$urlOnline" -O "$fileTemp" "$recup_url"
		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(){		# v16/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(){
	local recup1="https://fpdownload.adobe.com/get/flashplayer/pdc/"
	if [ "$(uname -m)" == "i686" ] || [ "$(uname -m)" == "i386" ]; then local recup2='i386';
	elif [ "$(uname -m)" == "x86_64" ] || [ "$(uname -m)" == "amd64" ]; then local 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(){
	[ -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(){		#v24/08/2017
	fflash_get_version
	if [ "$plugin_aJour" == "ko" ]; then
		fflash_install
	else f__info "log" "pas de plugin Flash à mettre à jour"; fi
}

	# inscription dans tache upgrade en anacron hebdomadaire, via cron horaire
fscript_cronAnacron(){		# v27/08/2017
	[ "$(type -t fscript_cronAnacron_special)" ] && fscript_cronAnacron_special		# test, si fonction spécifique, appel
	local dirAnacron="/home/$user_/.config/anacron"
	local dirSpool="$dirAnacron/spool"
	local 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
}

	# spécifique script
fscript_cronAnacron_special(){		# v19/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
}

	# version script en ligne, assigne $versionScript, $script_aJour=ok|ko
fscript_get_version(){		# v27/08/2017
	f__requis "wget"
	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 non accessible"; fi
}

	# installation du script dans le système
fscript_install(){		# v27/08/2017
	[ "$(type -t fscript_install_special)" ] && fscript_install_special		# test, si fonction spécifique, appel
	if dirname "$0" | grep -q 'bin' ; then
		f__info "$RED""$script $version est déjà installé"
		return 1
	fi
	[ $EUID -eq 0 ] || f__error "vous devez être ROOT pour installer ce script dans le système"
	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 755 "/opt/bin/$script"
		# cron/anacron install
	fscript_cronAnacron "install"
		# création fichier log
	touch "$fileLogs"
	chmod 644 "$fileLogs"
	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 ./)"
}

	# spécifique script
fscript_install_special(){		# v25/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
}

	# suppression du script dans le système
fscript_remove(){		# v27/08/2017
	[ $EUID -eq 0 ] || f__error "vous devez être ROOT pour supprimer ce script dans le système"
		# 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(){		# v26/08/2017
	fscript_get_version
	if [ "$script_aJour" == "ok" ]; then 
		f__info "log" "pas de mise à jour disponible pour $script"
		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 755 "$dirTemp$script"
	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' ; IFS=' '; TERM=xterm
export PATH TERM
f__affichage
f__user || f__error "échec détection user"
f__requis "file tar"		# requis pour fonctionnement programme

fileLogs="/var/log/sdeb_$script.log"
fileDev="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)" == "." ]; 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""#installation-rapide-du-script"

for i in $options; do
	case $i 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 ) 
			if ! dirname "$0" | grep -q 'bin' ; then
				fscript_install
			else fflash_help; fi
			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 | * )
			fflash_help
			fflash_avertissement
			exit ;;		 								# affichage help
	esac
done

exit 0

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