[Projet terminé] correction anomalie de grub

ça a l'air de bien tourner !
j'ai eu quelques soucis sur mon PC lors des démontages , c'est pour ça que j'ai fait une boucle de démontage
sur ta machine , le démontage se fait correctement
et on voit bien la partition de boot

DevSd=/dev/sdb4          UPart=UUID=2ffbf271-02fa-4d6f-a8e6-dee7a63894e5 UBoot=UUID=13e83c99-8624-4136-a61d-10e67e670ba3

merci pour ce retour
ce qui me parait difficile pour aller plus loin encore c'est quand même la diversité des environnements
le fstab par exemple avec les partitions GPT que je ne connais pas du tout !!!!

@Bougron : j'étudierai ton post plus tard
====================================
voilà la version V35
qui prend en compte le boot séparé
et
qui ne traite que la partie comprise entre

 
### BEGIN /etc/grub.d/10_linux ###

et

 ### BEGIN /etc/grub.d/40_custom ###

lorsque l'on veut traiter un fichier "grub" d'essai ce fichier doit
commencer par une ligne de commentaire
mais cette ligne ne doit pas être ### BEGIN /etc/grub.d/10_linux ###

la ligne
### BEGIN /etc/grub.d/10_linux ###
doit être présente même

si la ligne
### BEGIN /etc/grub.d/40_custom ###
est présente elle doit être après la ligne ### BEGIN /etc/grub.d/10_linux ###

tout ce qui est avant est intégralement recopié
tout ce qui est après est intégralement recopié

j'ai préféré écrire un deuxième script que j'ai appelé recup_fstabV2 qui doit être mis dans le même répertoire que le script modif-grub

ce script est chargé de créer le fichier UBoot_UPart.txt qui contient les systèmes avec boot séparé
il est un peu long car il effectue un montage /démontage des partitions pour récupérer le fichier /etc/fstab

je ne peux pas tester en réel le bon fonctionnement !!!
il faudrait que je me crée des systèmes avec boot séparé , je ne sais pas trop faire

des fichiers temporaires sont créés , actuellement ils ne sont pas supprimés automatiquement

EDIT
Précision suite au post #153 de Babdu89
mettre les deux scripts dans le même répertoire et les rendre exécutables
modif_grub_V35 lance bien le script recup_fstab_V2
les fichiers résultants sont créés dans ce même répertoire

(on peut lancer le script recup_fstab à part pour des essais)

la version modif_grub_V35
###########################################################################
EDIT 16-03-2017 : ajout de # en ligne 40
le fichier à traiter ne doit pas commencer par ### BEGIN /etc/grub.d/10_linux ###
devient
# le fichier à traiter ne doit pas commencer par ### BEGIN /etc/grub.d/10_linux ###

dans le même paragraphe
remplacer

read ligne < $fich_source

par

read ligne < "$fich_source"

et

return1

par

exit 1

dans la fonction trier_fichier , mettre la ligne

ne_commence_pas_par_begin

après les lignes echo , deb= , fin=
FIN d'EDIT
############################################################################

#!/bin/bash

# V24 2017-03-06

#V25 
# chaine_linux="linux.*\/vmlinu" pour prise en compte de "linux	/@/boot/vmlinuz"

#V26 function sort_info_transforme donne des traces

# V28 2017-03-08
# présentation de concordances UUID-LABEL
# un ligne menuentry et submenu peut comporter des blank après   } 
# variable fin_submenu pour prise en compte des lignes menuentry se terminant par }  }

# V29 2017-03-09
# correction due à l'utilisation de ${#uuid[*]} dans la construction concordance label-uuid
# remplacement de tous les while ${#menu[*]} par for ${!menu[@]}

# V30 idem V29 sans les commentaires superflus
# si boot séparé on sort !!!!

# V33 ajout du sous programme recup_fstab_V2 ( étude système à boot séparé)

# V34 suite à V33 , suppression de certaines fonctions devenue inutiles
# réorganisation de certaines fonctions

# V35 le programme ne traite plus que les lignes comprises entre 
#    ### BEGIN /etc/grub.d/10_linux ###
# et
#    ### BEGIN /etc/grub.d/40_custom ###
#
# le fichier à traiter doit commencer par un #
# la ligne ### BEGIN /etc/grub.d/10_linux ### est obligatoire
# si la ligne ### BEGIN /etc/grub.d/40_custom ### est absente
# le programme traitera le fichier jusqu'à la fin



function ne_commence_pas_par_begin {
# le fichier à traiter ne doit pas commencer par ### BEGIN /etc/grub.d/10_linux ###
read ligne < "$fich_source"
if [[ $ligne =~ ^"$deb" ]]
	then
		echo "désolé"
		echo "le fichier source à traiter ( $fich_source )"
		echo "doit bien commencer par un commentaire"
		echo "et en plus"
		echo "ne doit pas commencer par"
		echo "$deb"
	
		exit 1
	fi
}




function trier_fichier {

echo $fich_source
deb="### BEGIN /etc/grub.d/10_linux ###"
fin="### BEGIN /etc/grub.d/40_custom ###"

ne_commence_pas_par_begin

# création de 3 fichiers tmp0-<date>.txt tmp1-<date>.txt tmp3-<date>.txt


fich_source_0=tmp0_$num.txt # lignes du fichier à traiter de 1 à 10_linux
fich_source_1=tmp1_$num.txt # lignes du fichier à traiter de 10_linux à 40_custom
fich_source_2=tmp2_$num.txt # lignes du fichier à traiter de 40_custom à la fin

[[ -e "$fich_source_0" ]] && rm "$fich_source_0" # inutile mais évite message d'erreur rm
[[ -e "$fich_source_1" ]] && rm "$fich_source_1" # inutile mais évite message d'erreur rm
[[ -e "$fich_source_2" ]] && rm "$fich_source_2" # inutile mais évite message d'erreur rm

fich="$fich_source_0"
presence_10_linux=1

while read ligne
do
	case "$ligne" in
		$deb ) fich="$fich_source_1" ;  presence_10_linux=0		;;
		$fin ) fich="$fich_source_2" 							;;
	esac
	echo $ligne >> $fich
done < $fich_source

if [[ $presence_10_linux -eq 1 ]]
then
	echo "la présence de la ligne $deb est obligatoire"
	echo "le traitement ne commence qu'à partir de cette ligne"	
	echo "ajouter cette ligne au fichier"
	exit 0
fi
	
}






function verifier_presence_dev { # dans le cas d'utilisation d'un blkid personnel
echo
# mettre les dev de "blkid-res.txt" dans un tableau
dev1=(`awk -F" " '{printf("%s ",$1)}' "blkid-res.txt"`)

# mettre les dev de $res_blkid dans un tableau
dev2=(`awk -F" " '{printf("%s ",$1)}' "$res_blkid"`)

manque=""
for d1 in ${dev1[@]} # /dev/sdxy: /dev/sdzt: de blkid
do
	res=`grep $d1 <<< ${dev2[@]}`
	[[ -z $res ]] && manque="$manque $d1" # si non trouvé , ajout
done
	if [[ -n $manque ]]
		then 
			echo "dans le fichier $res_blkid il manque"
			echo ; echo $manque ; echo
			echo "tous les dev présents sur la machine doivent être déclarés dans ce fichier"
			echo "veuillez éditer ce fichier"
			echo "format habituel dev/sdxx: LABEL=\"xxxx\"  UUID=\"xxxx\"" 
			exit 0
		fi
}




function modif_ligne1_grub { # récupère la première ligne et modifie en y mettant la date

res=`echo "$1" | grep "^ *	*#"`



if [[  -n $res ]] # la ligne est bien un commentaire (commence par #)
	then
		trans="#### $num : $fich_source modifié par $0 ####"
		echo $trans			> "$fich_sauv"
		((nb_lignes_cons++))
		((nb_lignes_hors_menu++))
sort_info_transforme "$1" "première ligne modifiée en" "$trans"

	else
		echo "la première ligne du fichier est "
		echo $1
		echo	
		echo "mais il faut que la première ligne du fichier"
		echo "$fich_source"
		echo "commence par un #"
		echo "ajouter cette ligne de commentaire au début de ce fichier"
		echo "arrêt du programme"
		exit 0
	fi #[[ -n $res  ]]

}


function OK {
rep=""
while [[ $rep != [oOyYnN] ]]
do
titre="programme $0        /!\/!\/!\/!\    Répondez par : (oOyYnN)"
texte="cette partie de programme supprime des lignes supposées inutiles de grub 
 ( paragraphes  contenant ......$rech_dev.....$rech_dev........... AVANT la chaine $rech_class )
 ( menuentry n'ayant pas des UUID égaux dans la ligne search et la ligne linux)
 (à partir de V34 les menuentry sur boot séparé devraient être conservés)	

 le programme demande le nom du fichier à traiter .. 
 en réel ce devrait être <partition>/boot/gub/grub.cfg ..
 et créera un fichier grub-OK-date qui pourra être utilisé pour remplacer le fichier grub
 il utilise aussi le label des partitions ou du fichier de référence 
 pour informer plus précisement la ligne menuentry de grub
 on peut utiliser un fichier de référence uuid label (au format blkid)
 
     remarque :pour des essais , on peut traiter n'importe quel fichier ayant un format grub
     si le fichier à traiter n'est pas au format grub , il ne fonctionnera pas correctement
     et en réel il serait préférable de lancer ce programme après avoir lancé un update-grub

trois fichiers peuvent être créés :
    grub-OK-<aaaa:mm:dd-hh:mm:ss>.txt         (le grub récupérable)
    grub-sup-<aaaa:mm:dd-hh:mm:ss>.txt        (les menuentry qui ont été supprimés)
    fich_transforme-<aaaa:mm:dd-hh:mm:ss>.txt (les lignes modifiées)

	vous pourrez analyser ces fichiers pour voir ce qui s'est passé
    avant de remplacer le grub 
    (en fin de traitement répondez alors non à la demande de remplacement
     et faites le remplacement manuellement)

lors du traitement .....
 les  x  qui défilent indiquent des lignes de menu qui seront supprimées
 les  c  qui défilent indiquent les lignes de menu qui seront conservées
 les  .  qui défilent indiquent les autres lignes  (qui seront conservées)
 un   S  indique un début de submenu
 un   M  indique un début de menuentry
 un   m  indique la suite de menuentry 
 
			tapez O puis valider pour continuer
			tapez A puis valider pour arrêter 

			O pour continuer / A pour arrêter le programme  
       "
       
rep=`zenity --entry --title "$titre" --text "$texte" --width "800"`
case $rep in
	[oOyY]	)	:												;;
	[aA]	)											exit 1	;;
	*		) 	echo "utilisez seulement oOyYaA S.V.P."			;;
esac	
done
}


function choix_fichier_blkid { # retourne 0 si fichier blkid choisi
fich_source=""
titre="$0               Sélectionnez le fichier contenant UUID et LABEL des partitions"
#fich_source=`zenity --file-selection --filename="../blkid/*" --title="$titre"`
fich_source=`zenity --file-selection --title="$titre"`

case $? in	#$? est le code de retour de zenity
 	0)	res_blkid="$fich_source"									;;
	1)	echo "Aucun fichier UUID-LABEL sélectionné."	; exit 1	;;
	-1)	echo "Une erreur inattendue est survenue." 		; exit 1	;;	
	*)	echo "erreur non reconnue" 						; exit 1	;;	
esac
}


function critere_suppression_2 { # se fait après une initialisation de menu[0 ...n]

##### attention les codes de retour ont changé
# 0 si ligne search et ligne linux et uuid égaux (menu conservé + label dans menu[0])
# 1 si pas de ligne search ou linux              (menu conservé intégralement)
# ligne search et linux trouvées
# 3 aucun UUID trouvé dans fichier UUID-LABEL
# 2 si uuid différents                           (menu supprimé à revoir?)

uuid_search="x"
uuid_linux="y"

ligne_search=""
ligne_linux=""

# recherche dans le tableau menu[1..n] de la ligne search

#TEST

for i in ${!menu[@]}				# pour tous les indices 0..n
do
	[[ $i = 0 ]] && continue		# sauf dans menu[0]
	res=`grep "$chaine_search" <<< "${menu[i]}"` # dans menu[1..n]
	if [[ -n $res ]]
		then
			ligne_search="${menu[i]}"
			break					# 1er menu[n] trouvé est le bon
		fi

	done


if [[ -z "$ligne_search" ]]
then
	return 1 # pas de chaine search => on conservera le menu intégralement
fi

# recherche dans le tableau menu[] de la ligne linux


for i in ${!menu[@]}				# pour tous les indices 0..n
do
	[[ $i = 0 ]] && continue		# sauf dans menu[0]
	tmp=`sed 's/[[:blank:]]//g'	<<< "${menu[i]}"` #suppression des blank de menu
	res=`grep "$chaine_linux"   <<< "${menu[i]}"` # dans menu[1..n]
	if [[ -n $res ]]
		then
			ligne_linux="${menu[i]}"
			break					# 1er menu[n] trouvé est le bon
		fi

	done


if [[ -z "$ligne_linux" ]]
then
	return 1 # pas de chaine linux => menu conservé sans modif
fi

#uuid ligne search présent dans fichier de réf uuid-label ?
# si trouvé positionne uuid_search
n=-1
while [[ $n -lt $maxuuid ]]
	do
	((n++))					# recherche de uuid[0..n]
	if [[ -n ${uuid[$n]} ]] # précaution supplémentaire uuid non vide
	then
		res=`grep ${uuid[$n]} <<< "$ligne_search"`	#  y-a-t-il l'UUID
		if [[ -n $res ]] 
			then
				uuid_search=${uuid[$n]}
				break 				# le premier uuid trouvé dans blkid sera le bon
		fi
	fi 
done 


# uuid ligne linux présent dans fichier de réf uuid-label ?
# si trouvé positionne uuid_linux
n=-1
while [[ $n -lt $maxuuid ]]
	do
	((n++))					# recherche de uuid[0..n]
	if [[ -n ${uuid[$n]} ]] # précaution supplémentaire uuid non vide 
	then
		res=`grep ${uuid[$n]} <<< "$ligne_linux"`	#  y-a-t-il l'UUID
		if [[ -n $res ]] 
			then
				uuid_linux=${uuid[$n]}
				break 				# le premier uuid trouvé dans blkid sera le bon
		fi
	fi 
done


# analyse des résultats

if [[ ${uuid_search}${uuid_linux} = "xy" ]]
then
	return 3 # aucun des uuid n'a été trouvé dans blkid ( peuvent être égaux ou non )
fi 

####################################################################################
# on peut avoir uuid_search  uuid_linux
#               x            1ea0....  : n'existe pas  , existe       : code retour 2
#               a04f...      y         :   existe      , n'existe pas : code retour 2
#               bcde...      fghi....  : uuids existants et différents: code retour 2
#               1234...      1234....  : uuids existants et égaux     : code retour 0
#####################################################################################



# si $uuid_search-$uuid_linux est dans UBoot on renvoie 4
# ce menu correspond à une partition avec boot séparée

for i in ${!UBoot[@]}		# pour tous les indices 0..n
do

	[[ $uuid_search-$uuid_linux = ${UBoot[$i]} ]] && return 4 

done


if [[ "$uuid_search" != "$uuid_linux" ]]
	then
		return 2 #  uuid différents on supprimera ce menu
	else
		return 0 # uuid egaux on conservera ce menu après modif de menu[0]
fi

} # fin function critere_suppression_2


function ajout_label_menuentry { # ajoute un label à menu[0] (search ou linux)
rech_uuid_label_menuentry "$1" 	# retour 0 si label trouvé , pas zéro sinon
code=$?
if [[ $code -eq 0 ]]
  then # on a un label
	  tmp=${menu[0]}	
	  menu[0]=`sed "s/menuentry '/menuentry '$label_trouve : /" <<< ${menu[0]}`
	  menu[0]=`sed "s/menuentry \"/menuentry \"$label_trouve : /" <<< ${menu[0]}`
	  menu[0]=`sed "s/${label_trouve} *:* *${label_trouve}/${label_trouve}/" <<<${menu[0]}`
	  if [[ $tmp != ${menu[0]} ]]
		then
			sort_info_transforme "$tmp" "	LIGNE transformée en" "${menu[0]}" 
		fi #[[ $tmp != ${menu[0]} ]]
	  fi # [[ $code -eq 0 ]]
}


function memorise_menuentry { # mémorise menuentry de submenu pour écriture ultérieure
	for  p in ${!menu[@]}	# pour tous les indices de menu[]
		do
			((i_s++))
			ligne_sousmenu[i_s]=${menu[$p]} 	# mémorise menu[0 ..n]
			((nb_lignes_menu_cons++))			# stat
		done 
}


function ecrire_lignes_memorisees { # écrit les lignes dans sauv

for p in ${!ligne_sousmenu[@]}	# pour tous les indices de ligne_sousmenu[]
	do
		echo "${ligne_sousmenu[$p]}" >> "$fich_sauv"	# écriture l_s[0..n]
		((nb_lignes_cons++))							# stat
	done
}


function traite_ligne_submenu { # reçoit $1 (ligne submenu '.......{

fin_submenu=1 # sera mise à 0 si un menuentry se termine par }  }
submenu="$1" #mise en mémoire de cette ligne

# j'utilise la mémorisation label_submenu du label d'un menuentry précédent  

if [[ -n $label_submenu ]]
then
# ajout du label et suppression double label
submenu=`sed "s/submenu '/submenu '${label_submenu} : /"   <<< $submenu`
submenu=`sed "s/submenu \"/submenu \"${label_submenu} : /" <<< $submenu`
submenu=`sed "s/${label_submenu} *:* *${label_submenu}/${label_submenu}/" <<<$submenu`
fi

i_s=0
unset ligne_sousmenu

ligne_sousmenu[0]="$submenu"	# mémorisation pour sortie finale
((nb_lignes_hors_menu++))		# ligne considérée comme hors menu

# lire les lignes qui suivent submenu jusquà trouver ligne ......} hors menuentry)

while read ligne
do
((nb_lignes_lues++))
		# si on trouve .... } hors menuentry on est au bout du submenu
		# il faut sauvegarder la ligne submenu , les lignes intermédiaires et menuentry
		# je ne traite pas du cas où on trouverait une ligne menuentry terminée par  } }
		# V28 et suivante ce cas est traité
		# une ligne menuentry terminée par } } provoque la fin du submenu  ($fin_submenu 0)

# on sort de la boucle si on trouve } en fin de ligne hors menuentry

tmp=`sed 's/[[:blank:]]//g' <<<"$ligne"` # supprime les blancs de la ligne

if [[ "$tmp" =~ }$ || "$fin_submenu" = 0 ]]   ### on est en fin de submenu ###
				# pas tout à fait exact
				# si on peut  avoir { ...... } hors menuentry
		then
			((i_s++))
			ligne_sousmenu[i_s]="$ligne"	# mémoriser cette ligne
			((nb_lignes_hors_menu++))		# stat
			echo -e ".\c"
			ecrire_lignes_memorisees		# écriture de ces lignes de submenu
			label_submenu=""
			return							# fin de traitement de submenu
		fi # [[ "$tmp" =~ }$ ]]

# V28 élargissement aux blancs de grep après {
res=`echo "$ligne" | grep "^[	 ]*menuentry.*{[ 	]*$"`
mem=`echo "$ligne" | grep "^[	 ]*menuentry ['\"]Memory test.*{[ 	]*$"`

if [[ -n $mem ]]
then			
	res=""		# si on trouve la chaine Memory pas intéressant on force res à vide
fi

if  [[ -z $res ]]
	then								# ni menuentry ..{ ni memory ...{
		((i_s++))						# 
		ligne_sousmenu[i_s]="$ligne"	# mise en mémoire pour écriture ultérieure
		((nb_lignes_hors_menu++))		# stat
		echo -e ".\c"	
	
	else
		lire_menuentry 					# menu[0..n]  et ((nb_lignes_lues++))
		trt_menu2 "${menu[0]}" 			# 1 si contient dev dev
		code_dev_dev=$?

		if [[ $code_dev_dev -eq 1 ]]	# 1 la ligne contient /dev /dev
			then
				sort_menu_1 " " "menu supprimé : trop de /dev/sd"		# suppression de ce menu
				((nb_menu_sup++))		# stat
			else 						# pas 1 : ne contient pas dev dev
				critere_suppression_2
				code_crit2=$?			# 0 1 2 3 

				case $code_crit2 in
				0)						# les uuid sont égaux modifier menu[0]
					ajout_label_menuentry "$chaine_search"
					memorise_menuentry	# mettre en mémoire ces lignes de menuentry
					((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
				;;
				1)						# pas de search ni de linux on garde sans modif
					memorise_menuentry	# mettre en mémoire ces lignes de menu
sort_info_transforme "${menu[0]}" "menu dans submenu conservé (sans search ou linux)"
					((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
				;;
				2)						# uuid différents on supprime ce menu
					sort_menu_1 " " "menu supprimé : uuid différents"
					((nb_menu_sup++))	# stat non prévu
				;;
				3)						# uuid non trouvé (search et linux existent)
					memorise_menuentry	# mettre en mémoire ces lignes de menu
sort_info_transforme "${menu[0]}" "menu dans submenu conservé : uuid (search-linux) non trouvé"
					((nb_menu_cons++))	# stat non prévu
					((nb_menu_sans_uuid++))
				;;
				4)						# uuid != mais boot séparé
					# revoir pour le label
					ajout_label_menuentry "$chaine_linux"
					memorise_menuentry	# mettre en mémoire ces lignes de menuentry
					((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
					((nb_menu_boot_cons++))
					
				;;					
				esac
			fi # [[ $code_dev_dev -eq 1 ]]
	fi # [[ -z $res ]]
done

# si on arrive ici il y a erreur de traitement quelque part
echo
echo " ligne bach $LINENO"
echo " erreur de format ? dans le fichier $fich_source !!!!!!!!!!"
echo " dernière ligne de menu lue :"
echo
echo ${menu[0]}
echo
echo " dernière ligne lue : $nb_lignes_lues"
echo " $ligne"
sleep 100
exit 0 
}


function rech_uuid_label_ligne { # recherche uuid et label  de $1 dans uuid[0..n]
# renvoie 0 uuid trouvé et label trouvé	uuid_trouve=xxx  label_trouve="yyy"
# renvoie 1 uuid trouvé et label vide	uuid_trouve=xxx  label_trouve=""
# renvoie 2 uuid non trouvé				uuid_trouve=""   label_trouve=""	
uuid_trouve=""
label_trouve=""
n=-1
while [[ $n -lt $maxuuid ]]
	do
	((n++))								# uuid suivant
	if [[ -n ${uuid[$n]} ]]				# précaution supplémentaire uuid non vide 
	then
		res=`grep ${uuid[$n]} <<< $1`	#  $1 est une ligne de menu
		if [[ -n $res ]] 
			then
				uuid_trouve=${uuid[$n]}
				if [[ -n ${label[$n]} ]]
				then
					label_trouve=${label[$n]}	# si label non vide positionne label_trouve
					return 0					# uuid trouvé / label non vide trouvé
				else
					return 1					# uuid trouvé / label ""
				fi
		fi
	fi 
done 
return 2										# uuid non trouvé 
}


function rech_uuid_label_menuentry { # recherche uuid et label dans la ligne $1 de menu[1 ..n]

for p in ${!menu[@]}	# pour tous les indices du tableau 0..n
do
	[[ $p = 0 ]] && continue	# mais pas dans menu[0]
	res=`echo ${menu[$p]} | grep "$1"`	
	if [[ -n $res ]]
		then
			rech_uuid_label_ligne ${menu[$p]}		# donne uuid_trouve / label_trouve
			return $?								# 0 uuid égaux 
													# 1 uuid trouvé , label vide
													# 2 pas d'uuid dans search 
		fi
	done
return 3	# pas de search trouvé , (donc pas d'uuid , et donc pas de label) !!!
}




function transforme_ligne_menuentry {	# modifie la première ligne d'un menuentry conservé
# recherche l'UUID dans la ligne search --no-floppy --fs-uuid --set=root
# si trouvé , on récupère le label
# si label vide on ne fait rien
# sinon on rajoute avec : en tête après menuentry ' ou menuentry " 
# 

label_trouve=""
uuid_trouve=""
tmp=${menu[0]}					# servira de test pour sortie si modifié
rech_uuid_label_menuentry "$1"	# positionne le label à la bonne valeur
code=$?							# retour de la fonction

case $code in
	0)		# UUID trouvé : $uuid_trouve LABEL trouvé : $label_trouve

			if [[ $label_submenu = "" ]]	# servira dans traitement d'un submenu éventuel
				then						# on memorise le premier label menuentry trouvé	
					label_submenu="$label_trouve"
				fi	
			menu[0]=`sed "s/menuentry '/menuentry '$label_trouve : /" <<< ${menu[0]}`
			menu[0]=`sed "s/menuentry \"/menuentry \"$label_trouve : /" <<< ${menu[0]}`
			#suppression double labels dans cette ligne
			menu[0]=`sed "s/${label_trouve} *:* *${label_trouve}/${label_trouve}/" <<<${menu[0]}`

			if [[ $tmp != ${menu[0]} ]]
			then #TEST
				sort_info_transforme "$tmp" "	LIGNE transformée en" "${menu[0]}"
			fi
	;;
	1)		# LABEL vide #TEST
				sort_info_transforme "$tmp" "pas de label pour $uuid_trouve"
	;;
	2)		#LABEL vide uuid non trouvé #TEST
				sort_info_transforme "$tmp" "uuid de ligne search non trouvé"
	;;
	3)		# pas de ligne search trouvée dans menuentry v
				sort_info_transforme "$tmp" "ligne search non trouvée"
	;;	
	*) # ???? #TEST
				sort_info_transforme "$tmp" "code inconnu : $code"
	;;
esac

return $code
}


function lire_menuentry { # met dans tableau menu[n] jusqu'à trouvé } seul sur la ligne
unset menu
i=0
menu[0]="$ligne"								# menu[0] est la première ligne
echo -e "M\c"									# trace début de menuentry
while read ligne								# ligne suivante
do
	((i++))
	((nb_lignes_lues++))
	menu[$i]="$ligne"							# mémorisée dans menu [1 .. n]
	echo -e "m\c"								# trace écran
	tmp=`sed 's/[[:blank:]]//g' <<<"$ligne"`	# suppression des blancs pour test

	if [[ "$tmp" =~ }}$ ]]
		then
			fin_submenu=0						# termine par  }   } fin de submenu !!!
		fi

	if [[ "$tmp" =~ }$ ]]   					# la ligne se termine par } ?
		then
			return								# oui fin de menuentry
		fi
			# et si pas de ... } on ira jusqu'en fin de fichier !!!!
			# c'est un critère de format de grub
done
}

function sort_menu_0 {	# écrit menu[0..n] dans le fichier de sauvegarde

for p in ${!menu[@]}						# pour tous les indices
	do
		echo "${menu[$p]}" >> "$fich_sauv"	# écriture menu[0..n]
		((nb_lignes_cons++))				# stat
		((nb_lignes_menu_cons++))			# stat
		echo -e "c\c"						# suivi écran
	done
}


function sort_menu_1 {	# écrit menu[0..n] dans le fichier suppression

#écriture des paramètres reçus dans fich_sup
	echo "#########################"	>> $fich_sup
	for arg in "$@"		# prends $1 $2 ... $n
	do
		echo $arg		>> $fich_sup
		#echo			>> $fich_sup
	done

# écriture du menu dans fichier sup
for p in ${!menu[@]}					# pour tous les indices
do
	echo "${menu[$p]}" >> "$fich_sup"	# écriture menu[0..n]
	((nb_lignes_sup++))					# stat
	echo -e "x\c"						# suivi écran
	done
}



function sort_info_transforme { # écrit les paramètres reçus fich_transforme

	echo "#########################"	>> $fich_transforme
	for arg in "$@"	# ( $1 $2 ... $n )
		do
			echo $arg		>> $fich_transforme
			#echo			>> $fich_transforme
		done
}


function trt_menu2 { # analyse le paramètre $1
	# renvoie 1 si $1 contient plus d'une fois /dev/sd  avant --class (suppresion)
	# renvoie 0 sinon

IFS=" "		# il faut l'espace comme délimiteur
tableau=($1)	# mise en tableau de la ligne
IFS="~"		# peut-être utile pour la suite ?

nbdevsd=0 					# nombre de fois que l'on trouve /dev/sd (avant --class)

for n in ${!tableau[@]} # de 0 1 2 .... x
do
	r_class=`echo ${tableau[$n]} | grep "$rech_class"`	# test présence --class
	if [[  -n $r_class ]] 								# --class ou pas ?
		then
			break				# --class est trouvé, sort de la boucle for
		else
			r_dev=`echo ${tableau[$n]} | grep "$rech_dev"`   #  test présence /dev/sd
			if [[ -n $r_dev ]]
				then
					((nbdevsd++))							# incrémente si on a /dev/sd 
					if [[ $nbdevsd -gt 1 ]]					# si plus d une fois /dev/sd
						then
							return 1 						# on sort en renvoyant 1
						fi #[[ $nbdevsd -gt 1 ]]
				fi #[[ -n $r_dev ]]
		fi #[[  -n $r_class ]]
done

if [[ $nbdevsd -gt 1 ]]	# test nombre
	then
		return 1 # 1 si plus d'une fois /dev/sd
	else
		return 0 # 0 sinon
fi
}



# début du programme ##################################################################################
######### variables ################################### 
rech_class="\-\-class"		# jusqu'à trouver la chaine --class dans menuentry
rech_dev="\/dev\/sd"		# la présence de la chaine  /dev/sd dans menuentry
res_blkid="blkid-res.txt"	# le fichier contenant le résultat de sudo blkid
chaine_search="search \-\-no\-floppy \-\-fs\-uuid \-\-set=root"
	 						# protection des tirets pour les recherche par \  d'où les \-
chaine_linux="linux.*\/vmlinu" 			# + général "linux......./vmlinu"
label_submenu=""						# label valide du menuentry précédent
fich_fstab_conc="UBoot_UPart.txt" # créé par recup-fstab contient les uuid ayant boot séparé
#########################################################
num=`date +%Y:%m:%d`-`date +%H:%M:%S`
fich_sauv=grub-OK-$num.txt
fich_sup=grub-sup-$num.txt
fich_transforme=fich_transforme-$num.txt
fich_fstab=fich_fstab-$num.txt
##### pour les stat #####################################
nb_menu_cons=0
nb_menu_boot_cons=0
nb_menu_sup=0
nb_menu_sans_uuid=0
nb_lignes_sup=0
nb_lignes_cons=0
nb_lignes_lues=0
nb_lignes_hors_menu=0
nb_lignes_menus_cons=0
#########################################################

prg="./recup_fstab_V2"	# création de $fich_fstab_conc (UBoot_UPart.txt)

echo "lancement du programme $prg"

#si le programme n'existe pas on sort
! [[ -e "$prg" ]] && echo "il manque le fichier $prg de récupération de infos de fstab" && exit 0
# créé le fichier UBoot_UPart.txt contenant uuid1-uuid2 des systèmes boot séparés
code=0		# permet des essais sans lancer prg , en diésant seulement la ligne qui suit
./$prg		# pour des essais mettre #./$prg
code=$? 

if [[ $code -ne 0 ]]
	then
		echo "  il y a eu un problème de traitement du programme  $prg"
		echo "  si l'arrêt n'est pas volontaire"
		echo "  vérifier que le répertoire /mnt/jpb ne comporte pas des résidus de fichiers"
		echo "  éventuellement faire le ménage dans ce répertoire"
		exit 0
	fi

echo "suite du programme $0"

if ! [[ -e $fich_fstab_conc  ]]	# normalement il a été créé par recup_fstab
	then
		echo "le fichier  $fich_fstab_conc est introuvable"
		echo "il faut d'abord exécuter recup_fstab"
		exit 0
	else
		echo ; echo 
		echo "  vérification des uuid correspondants à des systèmes sur boot séparés"
		echo "  remarque : il existe deux lignes par couple"
		echo "  une ligne uuid1-uuid2 et une ligne uuid2-uuid1"
		echo ; echo
		echo "#############################################"
		cat $fich_fstab_conc
		echo "#############################################"
		echo ; echo
		echo "  vérifier visuellement le contenu des lignes comprises entre les ###"
		echo tapez sur entrée pour continuer
		read g
	fi

# lecture et mise en mémoire des infos donnée par le fichier $fich_fstab_conc ("UBoot_UPart.txt")
max_boot=-1
while read l_boot
do
	[[ -z $l_boot ]] && echo "ligne vide je passe" && continue		# si ligne vide ou commentée
	[[ $l_boot =~ ^[[:blank:]]*# ]] && echo "ligne commentée $l_boot je passe" && continue
	((max_boot++))
	echo $l_boot
	UBoot[$max_boot]=$l_boot # format uuid1-uuid2 à la suite
done <$fich_fstab_conc

OK # présentation du programme

rep=""
while [[ $rep != [oOyYaAcC] ]]
do
titre="     Utilisation des UUID et LABEL des partitions des disques"
texte="
			Choix du fichier de références  LABEL et UUID

	répondez par
			(aA)     pour arrêter ce programme
	
			(oOyY)   si vous voulez ré-utiliser le fichier $res_blkid existant
                         ce fichier a été créé précédemment
						(les labels utilisés pour mettre à jour le grub
						 seront alors ceux déclarés sur la partition)

			(cC)     permet de choisir un fichier de référence UUID LABEL
						(les labels utilisés pour mettre à jour le grub
						 seront alors ceux déclarés dans ce fichier de référence)

				     !!!!!	à partir de V31 ce fichier devra aussi comporter le champ /dev
						    chaque partition doit être déclarée
							le champ UUID est OBLIGATOIRE pour un traitement correct
							le champ type est conseillé

							ce choix peut servir si vous ne voulez pas labelliser les
							partitions mais mettre quand même un label dans grub
							ou bien effctuer des essais
							(ce choix un peu tordu est un peu difficile à comprendre ?)

							le champ /dev/sdxx en premier
							le champ LABEL="xxxxxx"
							le champ UUID="xxxxxx"
							le champ TYPE="xxxxx"							
							une ligne sera donc de la forme

/dev/sdxx LABEL=\"un label correct\" UUID=\"un uuid correct\" TYPE=\"le  type correspondant\"

				!!!!	en cas de doute utilisez le choix oOyY 

	puis Valider

					si vous répondez non , ce sera le fichier $res_blkid qui sera
					utilisé pour mettre à jour le titre des menus et sous menus
					dans le fichier traité (surtout utile pour des essais)

					O pour réutilisation du fichier blkid 
					C pour choisir un fichier de référence UUID LABEL
					A Arrêter
"
rep=`zenity --entry --title "$titre" --text "$texte" --width "800"`

case $rep in
	[oOyY]	) echo "réutilisation du fichier $res_blkid créé précédemment" ;;
	[aA]	) echo "arrêt du programme" 		; exit 0				;;
	[cC] 	) echo "choix du fichier des uuid" 	; choix_fichier_blkid 	;;
	*		) echo "utilisez seulement oO yY aA cC S.V.P."				;;
esac
done

# si le fichier de concordance n'existe pas sortie 

! [[ -e "$res_blkid" ]] && echo " $0 fichier UUID-LABEL $res_blkid inexistant" && read g && exit 0

# récupératon dev label UUID dans des tableaux
unset dev
unset uuid
unset label
unset bdev	# V31 pour boot séparé
unset btype #le type de la partition
unset bmont # point de montage à cause du boot séparé

############## récupération dev label uuid btype dans le fichier choisi ###################
maxuuid=-1
while read ligne
do
#TEST simplification par continue
	[[ -z $ligne ]] && echo "ligne vide je passe" && continue		# correction ligne vide
	((maxuuid++))
	tableau=($ligne) # découper la ligne en champ
	tmp=`sed 's/://g' <<< ${tableau[0]}` # supprime les : donne /dev/sdxx
	[[ -z `grep "^\/dev" <<< $tmp` ]] && echo \
		&& echo "il manque /dev dans la ligne $ligne du fichier de référence UUID-LABEL" \
		&& exit 0
  
	dev[maxuuid]=$tmp			#récupération du dev de la ligne
	label[maxuuid]=""
	uuid[maxuuid]=""
	btype[maxuuid]=""
	
	echo ${tableau[@]}
	
	for champ in ${tableau[@]}
		do
			deb=` echo $champ | cut -c1-5`
			case $deb in
				LABEL)		# en enlevant les guillemets donne U16.04-b7
					label[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
					;;
				UUID\=)		# en enlevant les guillemets donne c63335c7-b....2be94
					uuid[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
					;;
				TYPE\=)		# en enlevant les guillemets donne swap ntfs ext4 ....
					btype[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
			esac
	done

done < $res_blkid

##############################################################################
if [[ "$res_blkid" != "blkid-res.txt" ]]
then
	verifier_presence_dev # vérifie que tous les dev du fichier choisi sont bien déclarés
fi
###############################################################################
# sortie des uuid label pour info
		rm tmp_u_l.txt
echo
		p=0
		while [[ $p -le $maxuuid ]]
		do
			aff_dev="${dev[$p]}"		&& [[ -z "$aff_dev"		]]	&& aff_dev="_"
			aff_label="${label[$p]}"	&& [[ -z "$aff_label"	]]	&& aff_label="___"
			aff_uuid="${uuid[$p]}"		&& [[ -z "$aff_uuid"	]]	&& aff_uuid="___"
			aff_btype="${btype[$p]}"	&& [[ -z "$aff_btype"	]]	&& aff_btype="___"

# car si l'un des $ est "" , il y a erreur d'affichage

			printf "%02s %-10s UUID %-36s LABEL: %-20s  TYPE : %-10s\n" \
					$p $aff_dev $aff_uuid $aff_label $aff_btype  | tee -a tmp_u_l.txt
			((p++))											
		done

titre="Affichage des concordances LABEL <=> UUID      Visualiser puis  Valider pour continuer"
zenity --text-info --title "$titre" --filename "tmp_u_l.txt" --height "640" --width "1280" --font "Courier New Bold 10"
code=$?
if [[ $code -ne 0 ]]
	then
		echo $code
		exit 0 #sortie si on ne valide pas
	else
		echo $code

	fi

################ début de traitement du fichier GRUB ###############################

# Quel fichier grub traiter ?
titre="$0               Sélectionnez le fichier GRUB à traiter"
fich_source=`zenity --file-selection --filename="../fichier-grub/*" --title="$titre"`
case $? in	# $? est le code de retour de zenity
	0)	:														;;
	1)	echo "Aucun fichier sélectionné."			; exit 1	;;
	-1)	echo "Une erreur inattendue est survenue."	; exit 1	;;	
	*)	echo "erreur non reconnue"					; exit 1	;;	
esac


#### lecture et traitement du fichier GRUB #######

trier_fichier # création des 3 fichiers de 1 à 10 linux 10 linux à 40 custom 40 custom à la fin 

################# traitement jusqu'à 10_linux #####################
prem=0
while read ligne
do 
((nb_lignes_lues++))
if  [[ $prem -eq 0 ]]
	then
				modif_ligne1_grub "$ligne" ; ((prem++))
	else
				echo $ligne >> "$fich_sauv"
				((nb_lignes_cons++))
				((nb_lignes_hors_menu++))

fi
done < "$fich_source_0"

################# traitement de 10_linux à 40_custom
IFS="~"
while read ligne
do
((nb_lignes_lues++))

if  [[ $prem -eq 0 ]] # pourrait être supprimé depuis V34
	then
				modif_ligne1_grub "$ligne" ; ((prem++))
	else
				# entre les crochets on a tab et espace élargisement après {
	res=`echo "$ligne" | grep "^[	 ]*menuentry.*{[ 	]*$"`
	mem=`echo "$ligne" | grep "^[	 ]*menuentry ['\"]Memory test.*{[ 	]*$"`

	# res est vide s'il n'y a pas menuentry {
	# mem est non vide si on a Memory test -ne pas traiter menuentry 'Memory test

	if [[ -n $mem ]]
	then			# si Memory test on force res à vide
		res=""
	fi

	if  [[ -z $res ]]
		then 											# pas menuentry 
			subm=`echo "$ligne" | grep "^[	 ]*submenu.*{[ 	]*$"`
			if [[ -z $subm ]]
				then 									# pas menuentry pas submenu
					echo "$ligne" >> $fich_sauv			# écriture de cette ligne dans sauv
					((nb_lignes_cons++))				# stat
					((nb_lignes_hors_menu++))			# stat
					echo -e ".\c"						# trace écran
				else 									# contient submenu
					echo -e "S\c"						# trace
					traite_ligne_submenu "$ligne"		# traitement de submenu
			fi
		
		else								# on a menuentry
			lire_menuentry					# mettre en mémoire dans menu[0..n]
			trt_menu2 "${menu[0]}" 			# rem : 1 si /dev/sd /dev/sd
			code_dev_dev=$?
			if [[ $code_dev_dev -eq 1 ]]	# si 1 on supprime
				then						# le bloc menuentry contient /dev /dev
					sort_menu_1	" " "menu supprimé : trop de /dev/sd"	# fich_sup
					((nb_menu_sup++))

				else  						# menuentry ne contient pas /dev/sd /dev/sd
					critere_suppression_2	# analyse des uuid et recherche de label
					code_crit2=$?
					case $code_crit2 in
					0)						# les uuid sont égaux
						transforme_ligne_menuentry "$chaine_search"	# mettre un label dans menu[0]
						sort_menu_0					# écrire le menu dans fich_sauv
						((nb_menu_cons++))			# stat
					;;
					1)						# menu sans modif (ni search ni linux)
						sort_menu_0					# écrire le menu dans fich_sauv
sort_info_transforme "${menu[0]}" "menu conservé (sans search ou linux)"
						((nb_menu_cons++))			# stat
					;;
					2)						# uuid différents on supprime ce menu
						sort_menu_1	" " "menu supprimé : uuid différents"	# écrire dans fich_sup
						((nb_menu_sup++))				# stat
					;;
					3)						# uuid non trouvé (search et linux existent)
						sort_menu_0					# écrire le menu dans fich_sauv
sort_info_transforme "${menu[0]}" "menu conservé : UUID search-linux non trouvé"
						((nb_menu_cons++))			# ce menu étant conservé
						((nb_menu_sans_uuid++))
					;;
					4)						# uuid != mais boot séparé
						transforme_ligne_menuentry "$chaine_linux" # met label dans menu[0]
						sort_menu_0					# écrire le menu dans fich_sauv
						((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
						((nb_menu_boot_cons++))
					;;
					esac

				fi # [[ $code_dev_dev -eq 1 ]]
		fi #[[ -z $res ]]
	fi #[[ $prem -eq 0 ]]
#done < "$fich_source"
done < "$fich_source_1"

echo $nb_lignes_lues

################# traitement 40_custom à fin #####################
if [[ -e "$fich_source_2" ]] # en cas d'essai sans ligne 40_custom
	then
		while read ligne
		do 
			((nb_lignes_lues++))
			((nb_lignes_cons++))
			((nb_lignes_hors_menu++))
			echo $ligne >> "$fich_sauv"
		done < "$fich_source_2"
	fi
#################################################################

echo $nb_lignes_lues

# fin présentation des résultats sur l'écran

echo
echo
printf "%-40s %s %s\n" "fichier traité" " : " "$fich_source"
printf "%-40s %s %s\n" "le résultat se trouve dans"  " : " "$fich_sauv"
echo
printf "%-39s %s %5d\n" "nombre de lignes lues" " : " "$nb_lignes_lues"
printf "%-40s %s %5d\n" "lignes conservées" " : " "$nb_lignes_cons"
printf "%-40s %s %5d\n" "lignes supprimées" " : " "$nb_lignes_sup"
if [[ $nb_lignes_sup -gt 0 ]]
	then
printf "%-40s %s %s\n" "fichier des lignes supprimées" " : " "$fich_sup"
	echo
	fi
printf "%-40s %s %5d\n" "nombre de menus conservés" " : " "$nb_menu_cons"
printf "%-40s %s %5d\n" "nombre de menus supprimés" " : " "$nb_menu_sup"
printf "%-40s %s %5d\n" "nombre de menus avec boot conservés" " : " "$nb_menu_boot_cons"
if [[ $nb_menu_sans_uuid -gt 0 ]]
	then
printf "%-40s %s %5d\n" "nombre de menus sans uuid trouvé" " : " "$nb_menu_sans_uuid"
	fi
echo
printf "%-40s %s %5d\n" "lignes conservées (hors menu)" " : " "$nb_lignes_hors_menu"
printf "%-40s %s %5d\n" "lignes conservées (menu)" " : " "$nb_lignes_menu_cons"


echo "après avoir vérifié manuellement le fichier"
echo "$fich_sauv"
echo "vous pourrez remplacer grub.cfg par celui-ci à vos risques et périls"
echo


rep=""
while [[ $rep != [oOyYnN] ]]
do

################ mise à jour du fichier traité  ou non ###########################
titre="       remplacement de GRUB"
texte="Voulez-vous remplacer le grub original par le nouveau fichier généré (oOyYnN)
	
       mais par précaution si vous répondez oui le fichier
 $fich_source (fichier original choisi)
          sera sauvegardé dans
 $fich_source-$num

	   Attention
 $fich_source 
	sera remplacé par le contenu du fichier
 $fich_sauv  (le résultat OK obtenu)
       donc si avez choisi de traiter /boot/grub
       /boot/grub sera remplacé par le fichier résultant ... prenez vos précautions

		personnellement si je traite le fichier réel je réponds N

        pour vérifier le contenu du fichier créé 

        puis j'effectue manuellement la copie

                   répondez par (oOyYnN)"

rep=`zenity --entry --title "$titre" --text "$texte" --width "800"`
case $rep in
	[oOyY] )	# sauvegarde de "grub" , je conserve $num	
			echo "OK je sauvegarde le fichier original $fich_source dans $fich_source-$num"
			sudo cp "$fich_source" "$fich_source-$num"

			#et fich_sauv remplace grub
			echo "et je remplace $fich_source par $fich_sauv"
			sudo mv "$fich_sauv" "$fich_source"
	;;
	[nN]	)	
             echo ; echo "grub non remplacé"
             echo "  mais le fichier $fich_sauv est à disposition"
	;;
	*	) 	echo "utilisez seulement oOyYnN S.V.P."
	;;
esac
done

echo "taper entrée pour terminer"
read g #pour attendre
exit 0

fin normale du programme ././recup_fstab_V2

déjà ce programme s'est bien déroulé ......

modif_grub_V35.sh: ligne 36: le : commande introuvable

le numéro de ligne est bizarre normalement ce devrait être 40

en plus c'est une ligne de commentaire que j'ai du ajouter après mon test

il faut ajouter un # devant cette ligne !!!!!!!!!!!
j'édite la ligne dans le post
remplacement de

le fichier à traiter ne doit pas commencer par ### BEGIN /etc/grub.d/10_linux ###

par

# le fichier à traiter ne doit pas commencer par ### BEGIN /etc/grub.d/10_linux ###

pour le message

modif_grub_V35.sh: ligne 37: $fich_source : redirection ambiguë

il faut effectuer le remplacement suivant dans la ligne qui suit (ligne 41)

read ligne < $fich_source

par

read ligne < "$fich_source"

cela n'a pas généré d'erreur mais
en ligne 50
il faut remplacer return 1 par exit 1

pour le message

la présence de la ligne ### BEGIN /etc/grub.d/10_linux ### est obligatoire

IL FAUT que tu ajoutes cette ligne dans ton fichier et AVANT les lignes que tu veux traiter
si cette ligne n'est pas présente le programme ne modifiera rien !!!!
le programme est prévu comme ça !!!

donc
soit tu fais les modifs dans le fichier modif-grub que tu as récupéré soit tu recharges le fichier au post 150
(j'ai fais quelques autres modifs mineures)

un petit truc qui t'évitera de d'avoir à relancer recup-ftsab
(le fichier UBoot_UPart.txt doit exister dans le répertoire de lancement)
vers les lignes 780
au lieu de

./$prg
code=$?

mets

code=0
# ./$prg
code=$?

dans le fichier du post 150 il suffit de diésé la ligne ./$prg
ne pas oublié après les essais de remettre la ligne ./$prg sans dièse

je suis pris tout le week-end je n'aurais pas le temps de regarder

oui c'est bien exit 1 avec une espace !! , ( j'ai édité directement dans le forum )

je chercherais pourquoi on a toujours
modif_grub_V35.sh: ligne 58: $fich_source : redirection ambiguë


Tu veux traiter tout ce qu'il y a depuis la Ligne ### BEGIN /etc/grub.d/10_linux ###
jusqu'à la ligne ; ### BEGIN /etc/grub.d/40_custom ### ??.

oui , il me semble que cela avait été demandé dans l'un des post

le fichier à traiter doit être de la forme
#
ligne 2
.......
ligne n
### BEGIN /etc/grub.d/10_linux ### (ligne obligatoire)
ligne p
.....
ligne p+x
### BEGIN /etc/grub.d/40_custom ### (cette ligne n'est pas obligatoire)
ligne q
..
ligne q+t
fin de fichier

si 40 custom est présent , le programme traitera de 10 à 40
si 40 custom n'est pas présente le programme traitera de 10 à la fin (valable pour les essais , puisqu'en réel cette ligne est présente

nouvelle version modif_grub_V37
et recup_fstab_V3

le fichier généré fonctionne sur ma machine

#!/bin/bash

# V24 2017-03-06

#V25 
# chaine_linux="linux.*\/vmlinu" pour prise en compte de "linux	/@/boot/vmlinuz"

#V26 function sort_info_transforme donne des traces

# V28 2017-03-08
# présentation de concordances UUID-LABEL
# un ligne menuentry et submenu peut comporter des blank après   } 
# variable fin_submenu pour prise en compte des lignes menuentry se terminant par }  }

# V29 2017-03-09
# correction due à l'utilisation de ${#uuid[*]} dans la construction concordance label-uuid
# remplacement de tous les while ${#menu[*]} par for ${!menu[@]}

# V30 idem V29 sans les commentaires superflus
# si boot séparé on sort !!!!

# V33 ajout du sous programme recup_fstab_V2 ( étude système à boot séparé)

# V34 suite à V33 , suppression de certaines fonctions devenue inutiles
# réorganisation de certaines fonctions

# V35 le programme ne traite plus que les lignes comprises entre 
#    ### BEGIN /etc/grub.d/10_linux ###
# et
#    ### BEGIN /etc/grub.d/40_custom ###
# le fichier à traiter doit commencer par un #
# la ligne ### BEGIN /etc/grub.d/10_linux ### est obligatoire
# mais ne doit pas commencer le fichier
# si la ligne ### BEGIN /etc/grub.d/40_custom ### est absente
# le programme traitera le fichier jusqu'à la fin

#V37 ajout de l'option --sansfstab 
#   ( permet de ne pas lancer la récupération des fichiers fstab
# la création du fichier de concordance UUID-Part-UUIDBoot ne sera pas faite
# le fichier 

function ne_commence_pas_par_begin {
# le fichier à traiter ne doit pas commencer par ### BEGIN /etc/grub.d/10_linux ###
read ligne < "$fich_source"
if [[ "$ligne" =~ ^"$deb" ]]
	then
		echo ; echo
		echo "désolé"
		echo "si le fichier grub à traiter ( $fich_source )"
		echo "n'a pas le droit de commencer par la ligne"
		echo "$deb"
		echo "rappel :" 
		echo "    1- cette ligne"
		echo "       $deb"
		echo "       DOIT apparaître plus loin dans le fichier"
		echo "            même pour un fichier grub d'essai"
		echo
		echo "    2- le fichier à traiter DOIT commencer par une ligne de commentaire"
		echo "         (car cette première ligne sera modifiée)"
		echo
		echo "    3- en réel le fichier grub commence par #"
		exit 1 # au lieu de return 1
	fi
}

function trier_fichier {
echo ; echo
echo "fichier grub choisi : $fich_source"
deb="### BEGIN /etc/grub.d/10_linux ###"
fin="### BEGIN /etc/grub.d/40_custom ###"

ne_commence_pas_par_begin

# création de 3 fichiers tmp0-<date>.txt tmp1-<date>.txt tmp3-<date>.txt




fich_source_0=tmp0_$num.txt	# lignes du fichier à traiter de 1 à 10_linux
fich_source_1=tmp1_$num.txt # lignes du fichier à traiter de 10_linux à 40_custom
fich_source_2=tmp2_$num.txt # lignes du fichier à traiter de 40_custom à la fin

[[ -e "$fich_source_0" ]] && rm "$fich_source_0" # inutile mais évite message d'erreur rm
[[ -e "$fich_source_1" ]] && rm "$fich_source_1" # inutile mais évite message d'erreur rm
[[ -e "$fich_source_2" ]] && rm "$fich_source_2" # inutile mais évite message d'erreur rm


fich="$fich_source_0"
presence_10_linux=1
IFS="~"
while read ligne
do
	case "$ligne" in
		$deb ) fich="$fich_source_1" ;  presence_10_linux=0		;;
		$fin ) fich="$fich_source_2" 							;;
	esac
	echo "$ligne" >> $fich
done < "$fich_source"


# après lecture du fichier on a du renconter le ligne 10_linux sinon
if [[ $presence_10_linux -eq 1 ]]
then
	echo "la présence de la ligne $deb est obligatoire"
	echo "le traitement ne commence qu'à partir de cette ligne"	
	echo "ajouter cette ligne au fichier"
	exit 0
fi
	
}






function verifier_presence_dev { # dans le cas d'utilisation d'un blkid personnel
echo
# mettre les dev de "blkid-res.txt" dans un tableau
dev1=(`awk -F" " '{printf("%s ",$1)}' "blkid-res.txt"`)

# mettre les dev de $res_blkid dans un tableau
dev2=(`awk -F" " '{printf("%s ",$1)}' "$res_blkid"`)

manque=""
for d1 in ${dev1[@]} # /dev/sdxy: /dev/sdzt: de blkid
do
	res=`grep $d1 <<< ${dev2[@]}`
	[[ -z $res ]] && manque="$manque $d1" # si non trouvé , ajout
done
	if [[ -n $manque ]]
		then 
			echo "dans le fichier $res_blkid il manque"
			echo ; echo $manque ; echo
			echo "tous les dev présents sur la machine doivent être déclarés dans ce fichier"
			echo "veuillez éditer ce fichier"
			echo "format habituel dev/sdxx: LABEL=\"xxxx\"  UUID=\"xxxx\"" 
			exit 0
		fi
}




function modif_ligne1_grub { # récupère la première ligne et modifie en y mettant la date

res=`echo "$1" | grep "^ *	*#"`



if [[  -n $res ]] # la ligne est bien un commentaire (commence par #)
	then
		trans="#### $num : $fich_source modifié par $0 ####"
		echo $trans			> "$fich_sauv"
		((nb_lignes_cons++))
		((nb_lignes_hors_menu++))
sort_info_transforme "$1" "première ligne modifiée en" "$trans"

	else
		echo "la première ligne du fichier est "
		echo $1
		echo	
		echo "mais il faut que la première ligne du fichier"
		echo "$fich_source"
		echo "commence par un #"
		echo "ajouter cette ligne de commentaire au début de ce fichier"
		echo "arrêt du programme"
		exit 0
	fi #[[ -n $res  ]]

}


function OK {
rep=""
while [[ $rep != [oOyYnN] ]]
do
titre="programme $0        /!\/!\/!\/!\    Répondez par : (oOyYnN)"
texte="cette partie de programme supprime des lignes supposées inutiles de grub 
 ( paragraphes  contenant ......$rech_dev.....$rech_dev........... AVANT la chaine $rech_class )
 ( menuentry n'ayant pas des UUID égaux dans la ligne search et la ligne linux)
 (à partir de V34 les menuentry sur boot séparé devraient être conservés)	

 le programme demande le nom du fichier à traiter .. 
 en réel ce devrait être <partition>/boot/gub/grub.cfg ..
 et créera un fichier grub-OK-date qui pourra être utilisé pour remplacer le fichier grub
 il utilise aussi le label des partitions ou du fichier de référence 
 pour informer plus précisement la ligne menuentry de grub
 on peut utiliser un fichier de référence uuid label (au format blkid)
 
     remarque :pour des essais , on peut traiter n'importe quel fichier ayant un format grub
     si le fichier à traiter n'est pas au format grub , il ne fonctionnera pas correctement
     et en réel il serait préférable de lancer ce programme après avoir lancé un update-grub

trois fichiers peuvent être créés :
    grub-OK-<aaaa:mm:dd-hh:mm:ss>.txt         (le grub récupérable)
    grub-sup-<aaaa:mm:dd-hh:mm:ss>.txt        (les menuentry qui ont été supprimés)
    fich_transforme-<aaaa:mm:dd-hh:mm:ss>.txt (les lignes modifiées)

	vous pourrez analyser ces fichiers pour voir ce qui s'est passé
    avant de remplacer le grub 
    (en fin de traitement répondez alors non à la demande de remplacement
     et faites le remplacement manuellement)

lors du traitement .....
 les  x  qui défilent indiquent des lignes de menu qui seront supprimées
 les  c  qui défilent indiquent les lignes de menu qui seront conservées
 les  .  qui défilent indiquent les autres lignes  (qui seront conservées)
 un   S  indique un début de submenu
 un   M  indique un début de menuentry
 un   m  indique la suite de menuentry 
 
			tapez O puis valider pour continuer
			tapez A puis valider pour arrêter 

			O pour continuer / A pour arrêter le programme  
       "
       
rep=`zenity --entry --title "$titre" --text "$texte" --width "800"`
case $rep in
	[oOyY]	)	:												;;
	[aA]	)											exit 1	;;
	*		) 	echo "utilisez seulement oOyYaA S.V.P."			;;
esac	
done
}


function choix_fichier_blkid { # retourne 0 si fichier blkid choisi
fich_source=""
titre="$0               Sélectionnez le fichier contenant UUID et LABEL des partitions"
#fich_source=`zenity --file-selection --filename="../blkid/*" --title="$titre"`
fich_source=`zenity --file-selection --title="$titre"`

case $? in	#$? est le code de retour de zenity
 	0)	res_blkid="$fich_source"									;;
	1)	echo "Aucun fichier UUID-LABEL sélectionné."	; exit 1	;;
	-1)	echo "Une erreur inattendue est survenue." 		; exit 1	;;	
	*)	echo "erreur non reconnue" 						; exit 1	;;	
esac
}


function critere_suppression_2 { # se fait après une initialisation de menu[0 ...n]

##### attention les codes de retour ont changé
# 0 si ligne search et ligne linux et uuid égaux (menu conservé + label dans menu[0])
# 1 si pas de ligne search ou linux              (menu conservé intégralement)
# ligne search et linux trouvées
# 3 aucun UUID trouvé dans fichier UUID-LABEL
# 2 si uuid différents                           (menu supprimé à revoir?)

uuid_search="x"
uuid_linux="y"

ligne_search=""
ligne_linux=""

# recherche dans le tableau menu[1..n] de la ligne search

#TEST

for i in ${!menu[@]}				# pour tous les indices 0..n
do
	[[ $i = 0 ]] && continue		# sauf dans menu[0]
	res=`grep "$chaine_search" <<< "${menu[i]}"` # dans menu[1..n]
	if [[ -n $res ]]
		then
			ligne_search="${menu[i]}"
			break					# 1er menu[n] trouvé est le bon
		fi

	done


if [[ -z "$ligne_search" ]]
then
	return 1 # pas de chaine search => on conservera le menu intégralement
fi

# recherche dans le tableau menu[] de la ligne linux


for i in ${!menu[@]}				# pour tous les indices 0..n
do
	[[ $i = 0 ]] && continue		# sauf dans menu[0]
	tmp=`sed 's/[[:blank:]]//g'	<<< "${menu[i]}"` #suppression des blank de menu
	res=`grep "$chaine_linux"   <<< "${menu[i]}"` # dans menu[1..n]
	if [[ -n $res ]]
		then
			ligne_linux="${menu[i]}"
			break					# 1er menu[n] trouvé est le bon
		fi

	done


if [[ -z "$ligne_linux" ]]
then
	return 1 # pas de chaine linux => menu conservé sans modif
fi

#uuid ligne search présent dans fichier de réf uuid-label ?
# si trouvé positionne uuid_search
n=-1
while [[ $n -lt $maxuuid ]]
	do
	((n++))					# recherche de uuid[0..n]
	if [[ -n ${uuid[$n]} ]] # précaution supplémentaire uuid non vide
	then
		res=`grep ${uuid[$n]} <<< "$ligne_search"`	#  y-a-t-il l'UUID
		if [[ -n $res ]] 
			then
				uuid_search=${uuid[$n]}
				break 				# le premier uuid trouvé dans blkid sera le bon
		fi
	fi 
done 


# uuid ligne linux présent dans fichier de réf uuid-label ?
# si trouvé positionne uuid_linux
n=-1
while [[ $n -lt $maxuuid ]]
	do
	((n++))					# recherche de uuid[0..n]
	if [[ -n ${uuid[$n]} ]] # précaution supplémentaire uuid non vide 
	then
		res=`grep ${uuid[$n]} <<< "$ligne_linux"`	#  y-a-t-il l'UUID
		if [[ -n $res ]] 
			then
				uuid_linux=${uuid[$n]}
				break 				# le premier uuid trouvé dans blkid sera le bon
		fi
	fi 
done


# analyse des résultats

if [[ ${uuid_search}${uuid_linux} = "xy" ]]
then
	return 3 # aucun des uuid n'a été trouvé dans blkid ( peuvent être égaux ou non )
fi 

####################################################################################
# on peut avoir uuid_search  uuid_linux
#               x            1ea0....  : n'existe pas  , existe       : code retour 2
#               a04f...      y         :   existe      , n'existe pas : code retour 2
#               bcde...      fghi....  : uuids existants et différents: code retour 2
#               1234...      1234....  : uuids existants et égaux     : code retour 0
#####################################################################################



# si $uuid_search-$uuid_linux est dans UBoot on renvoie 4
# ce menu correspond à une partition avec boot séparée

for i in ${!UBoot[@]}		# pour tous les indices 0..n
do

	[[ $uuid_search-$uuid_linux = ${UBoot[$i]} ]] && return 4 

done


if [[ "$uuid_search" != "$uuid_linux" ]]
	then
		return 2 #  uuid différents on supprimera ce menu
	else
		return 0 # uuid egaux on conservera ce menu après modif de menu[0]
fi

} # fin function critere_suppression_2


function ajout_label_menuentry { # ajoute un label à menu[0] (search ou linux)
rech_uuid_label_menuentry "$1" 	# retour 0 si label trouvé , pas zéro sinon
code=$?
if [[ $code -eq 0 ]]
  then # on a un label
	  tmp=${menu[0]}	
	  menu[0]=`sed "s/menuentry '/menuentry '$label_trouve : /" <<< ${menu[0]}`
	  menu[0]=`sed "s/menuentry \"/menuentry \"$label_trouve : /" <<< ${menu[0]}`
	  menu[0]=`sed "s/${label_trouve} *:* *${label_trouve}/${label_trouve}/" <<<${menu[0]}`
	  if [[ $tmp != ${menu[0]} ]]
		then
			sort_info_transforme "$tmp" "	LIGNE transformée en" "${menu[0]}" 
		fi #[[ $tmp != ${menu[0]} ]]
	  fi # [[ $code -eq 0 ]]
}


function memorise_menuentry { # mémorise menuentry de submenu pour écriture ultérieure
	for  p in ${!menu[@]}	# pour tous les indices de menu[]
		do
			((i_s++))
			ligne_sousmenu[i_s]=${menu[$p]} 	# mémorise menu[0 ..n]
			((nb_lignes_menu_cons++))			# stat
		done 
}


function ecrire_lignes_memorisees { # écrit les lignes dans sauv

for p in ${!ligne_sousmenu[@]}	# pour tous les indices de ligne_sousmenu[]
	do
		echo "${ligne_sousmenu[$p]}" >> "$fich_sauv"	# écriture l_s[0..n]
		((nb_lignes_cons++))							# stat
	done
}


function traite_ligne_submenu { # reçoit $1 (ligne submenu '.......{

fin_submenu=1 # sera mise à 0 si un menuentry se termine par }  }
submenu="$1" #mise en mémoire de cette ligne

# j'utilise la mémorisation label_submenu du label d'un menuentry précédent  

if [[ -n $label_submenu ]]
then
# ajout du label et suppression double label
submenu=`sed "s/submenu '/submenu '${label_submenu} : /"   <<< $submenu`
submenu=`sed "s/submenu \"/submenu \"${label_submenu} : /" <<< $submenu`
submenu=`sed "s/${label_submenu} *:* *${label_submenu}/${label_submenu}/" <<<$submenu`
fi

i_s=0
unset ligne_sousmenu

ligne_sousmenu[0]="$submenu"	# mémorisation pour sortie finale
((nb_lignes_hors_menu++))		# ligne considérée comme hors menu

# lire les lignes qui suivent submenu jusquà trouver ligne ......} hors menuentry)

while read ligne
do
((nb_lignes_lues++))
		# si on trouve .... } hors menuentry on est au bout du submenu
		# il faut sauvegarder la ligne submenu , les lignes intermédiaires et menuentry
		# je ne traite pas du cas où on trouverait une ligne menuentry terminée par  } }
		# V28 et suivante ce cas est traité
		# une ligne menuentry terminée par } } provoque la fin du submenu  ($fin_submenu 0)

# on sort de la boucle si on trouve } en fin de ligne hors menuentry

tmp=`sed 's/[[:blank:]]//g' <<<"$ligne"` # supprime les blancs de la ligne

if [[ "$tmp" =~ }$ || "$fin_submenu" = 0 ]]   ### on est en fin de submenu ###
				# pas tout à fait exact
				# si on peut  avoir { ...... } hors menuentry
		then
			((i_s++))
			ligne_sousmenu[i_s]="$ligne"	# mémoriser cette ligne
			((nb_lignes_hors_menu++))		# stat
			echo -e ".\c"
			ecrire_lignes_memorisees		# écriture de ces lignes de submenu
			label_submenu=""
			return							# fin de traitement de submenu
		fi # [[ "$tmp" =~ }$ ]]

# V28 élargissement aux blancs de grep après {
res=`echo "$ligne" | grep "^[	 ]*menuentry.*{[ 	]*$"`
mem=`echo "$ligne" | grep "^[	 ]*menuentry ['\"]Memory test.*{[ 	]*$"`

if [[ -n $mem ]]
then			
	res=""		# si on trouve la chaine Memory pas intéressant on force res à vide
fi

if  [[ -z $res ]]
	then								# ni menuentry ..{ ni memory ...{
		((i_s++))						# 
		ligne_sousmenu[i_s]="$ligne"	# mise en mémoire pour écriture ultérieure
		((nb_lignes_hors_menu++))		# stat
		echo -e ".\c"	
	
	else
		lire_menuentry 					# menu[0..n]  et ((nb_lignes_lues++))
		trt_menu2 "${menu[0]}" 			# 1 si contient dev dev
		code_dev_dev=$?

		if [[ $code_dev_dev -eq 1 ]]	# 1 la ligne contient /dev /dev
			then
				sort_menu_1 " " "menu supprimé : trop de /dev/sd"		# suppression de ce menu
				((nb_menu_sup++))		# stat
			else 						# pas 1 : ne contient pas dev dev
				critere_suppression_2
				code_crit2=$?			# 0 1 2 3 

				case $code_crit2 in
				0)						# les uuid sont égaux modifier menu[0]
					ajout_label_menuentry "$chaine_search"
					memorise_menuentry	# mettre en mémoire ces lignes de menuentry
					((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
				;;
				1)						# pas de search ni de linux on garde sans modif
					memorise_menuentry	# mettre en mémoire ces lignes de menu
sort_info_transforme "${menu[0]}" "menu dans submenu conservé (sans search ou linux)"
					((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
				;;
				2)						# uuid différents on supprime ce menu
					sort_menu_1 " " "menu supprimé : uuid différents"
					((nb_menu_sup++))	# stat non prévu
				;;
				3)						# uuid non trouvé (search et linux existent)
					memorise_menuentry	# mettre en mémoire ces lignes de menu
sort_info_transforme "${menu[0]}" "menu dans submenu conservé : uuid (search-linux) non trouvé"
					((nb_menu_cons++))	# stat non prévu
					((nb_menu_sans_uuid++))
				;;
				4)						# uuid != mais boot séparé
					# revoir pour le label
					ajout_label_menuentry "$chaine_linux"
					memorise_menuentry	# mettre en mémoire ces lignes de menuentry
					((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
					((nb_menu_boot_cons++))
					
				;;					
				esac
			fi # [[ $code_dev_dev -eq 1 ]]
	fi # [[ -z $res ]]
done

# si on arrive ici il y a erreur de traitement quelque part
echo
echo " ligne bach $LINENO"
echo " erreur de format ? dans le fichier $fich_source !!!!!!!!!!"
echo " dernière ligne de menu lue :"
echo
echo ${menu[0]}
echo
echo " dernière ligne lue : $nb_lignes_lues"
echo " $ligne"
sleep 100
exit 0 
}


function rech_uuid_label_ligne { # recherche uuid et label  de $1 dans uuid[0..n]
# renvoie 0 uuid trouvé et label trouvé	uuid_trouve=xxx  label_trouve="yyy"
# renvoie 1 uuid trouvé et label vide	uuid_trouve=xxx  label_trouve=""
# renvoie 2 uuid non trouvé				uuid_trouve=""   label_trouve=""	
uuid_trouve=""
label_trouve=""
n=-1
while [[ $n -lt $maxuuid ]]
	do
	((n++))								# uuid suivant
	if [[ -n ${uuid[$n]} ]]				# précaution supplémentaire uuid non vide 
	then
		res=`grep ${uuid[$n]} <<< $1`	#  $1 est une ligne de menu
		if [[ -n $res ]] 
			then
				uuid_trouve=${uuid[$n]}
				if [[ -n ${label[$n]} ]]
				then
					label_trouve=${label[$n]}	# si label non vide positionne label_trouve
					return 0					# uuid trouvé / label non vide trouvé
				else
					return 1					# uuid trouvé / label ""
				fi
		fi
	fi 
done 
return 2										# uuid non trouvé 
}


function rech_uuid_label_menuentry { # recherche uuid et label dans la ligne $1 de menu[1 ..n]

for p in ${!menu[@]}	# pour tous les indices du tableau 0..n
do
	[[ $p = 0 ]] && continue	# mais pas dans menu[0]
	res=`echo ${menu[$p]} | grep "$1"`	
	if [[ -n $res ]]
		then
			rech_uuid_label_ligne ${menu[$p]}		# donne uuid_trouve / label_trouve
			return $?								# 0 uuid égaux 
													# 1 uuid trouvé , label vide
													# 2 pas d'uuid dans search 
		fi
	done
return 3	# pas de search trouvé , (donc pas d'uuid , et donc pas de label) !!!
}




function transforme_ligne_menuentry {	# modifie la première ligne d'un menuentry conservé
# recherche l'UUID dans la ligne search --no-floppy --fs-uuid --set=root
# si trouvé , on récupère le label
# si label vide on ne fait rien
# sinon on rajoute avec : en tête après menuentry ' ou menuentry " 
# 

label_trouve=""
uuid_trouve=""
tmp=${menu[0]}					# servira de test pour sortie si modifié
rech_uuid_label_menuentry "$1"	# positionne le label à la bonne valeur
code=$?							# retour de la fonction

case $code in
	0)		# UUID trouvé : $uuid_trouve LABEL trouvé : $label_trouve

			if [[ $label_submenu = "" ]]	# servira dans traitement d'un submenu éventuel
				then						# on memorise le premier label menuentry trouvé	
					label_submenu="$label_trouve"
				fi	
			menu[0]=`sed "s/menuentry '/menuentry '$label_trouve : /" <<< ${menu[0]}`
			menu[0]=`sed "s/menuentry \"/menuentry \"$label_trouve : /" <<< ${menu[0]}`
			#suppression double labels dans cette ligne
			menu[0]=`sed "s/${label_trouve} *:* *${label_trouve}/${label_trouve}/" <<<${menu[0]}`

			if [[ $tmp != ${menu[0]} ]]
			then #TEST
				sort_info_transforme "$tmp" "	LIGNE transformée en" "${menu[0]}"
			fi
	;;
	1)		# LABEL vide #TEST
				sort_info_transforme "$tmp" "pas de label pour $uuid_trouve"
	;;
	2)		#LABEL vide uuid non trouvé #TEST
				sort_info_transforme "$tmp" "uuid de ligne search non trouvé"
	;;
	3)		# pas de ligne search trouvée dans menuentry v
				sort_info_transforme "$tmp" "ligne search non trouvée"
	;;	
	*) # ???? #TEST
				sort_info_transforme "$tmp" "code inconnu : $code"
	;;
esac

return $code
}


function lire_menuentry { # met dans tableau menu[n] jusqu'à trouvé } seul sur la ligne
unset menu
i=0
menu[0]="$ligne"								# menu[0] est la première ligne
echo -e "M\c"									# trace début de menuentry
while read ligne								# ligne suivante
do
	((i++))
	((nb_lignes_lues++))
	menu[$i]="$ligne"							# mémorisée dans menu [1 .. n]
	echo -e "m\c"								# trace écran
	tmp=`sed 's/[[:blank:]]//g' <<<"$ligne"`	# suppression des blancs pour test

	if [[ "$tmp" =~ }}$ ]]
		then
			fin_submenu=0						# termine par  }   } fin de submenu !!!
		fi

	if [[ "$tmp" =~ }$ ]]   					# la ligne se termine par } ?
		then
			return								# oui fin de menuentry
		fi
			# et si pas de ... } on ira jusqu'en fin de fichier !!!!
			# c'est un critère de format de grub
done
}

function sort_menu_0 {	# écrit menu[0..n] dans le fichier de sauvegarde

for p in ${!menu[@]}						# pour tous les indices
	do
		echo "${menu[$p]}" >> "$fich_sauv"	# écriture menu[0..n]
		((nb_lignes_cons++))				# stat
		((nb_lignes_menu_cons++))			# stat
		echo -e "c\c"						# suivi écran
	done
}


function sort_menu_1 {	# écrit menu[0..n] dans le fichier suppression

#écriture des paramètres reçus dans fich_sup
	echo "#########################"	>> $fich_sup
	for arg in "$@"		# prends $1 $2 ... $n
	do
		echo $arg		>> $fich_sup
		#echo			>> $fich_sup
	done

# écriture du menu dans fichier sup
for p in ${!menu[@]}					# pour tous les indices
do
	echo "${menu[$p]}" >> "$fich_sup"	# écriture menu[0..n]
	((nb_lignes_sup++))					# stat
	echo -e "x\c"						# suivi écran
	done
}



function sort_info_transforme { # écrit les paramètres reçus fich_transforme

	echo "#########################"	>> $fich_transforme
	for arg in "$@"	# ( $1 $2 ... $n )
		do
			echo $arg		>> $fich_transforme
			#echo			>> $fich_transforme
		done
}


function trt_menu2 { # analyse le paramètre $1
	# renvoie 1 si $1 contient plus d'une fois /dev/sd  avant --class (suppresion)
	# renvoie 0 sinon

IFS=" "		# il faut l'espace comme délimiteur
tableau=($1)	# mise en tableau de la ligne
IFS="~"		# peut-être utile pour la suite ?

nbdevsd=0 					# nombre de fois que l'on trouve /dev/sd (avant --class)

for n in ${!tableau[@]} # de 0 1 2 .... x
do
	r_class=`echo ${tableau[$n]} | grep "$rech_class"`	# test présence --class
	if [[  -n $r_class ]] 								# --class ou pas ?
		then
			break				# --class est trouvé, sort de la boucle for
		else
			r_dev=`echo ${tableau[$n]} | grep "$rech_dev"`   #  test présence /dev/sd
			if [[ -n $r_dev ]]
				then
					((nbdevsd++))							# incrémente si on a /dev/sd 
					if [[ $nbdevsd -gt 1 ]]					# si plus d une fois /dev/sd
						then
							return 1 						# on sort en renvoyant 1
						fi #[[ $nbdevsd -gt 1 ]]
				fi #[[ -n $r_dev ]]
		fi #[[  -n $r_class ]]
done

if [[ $nbdevsd -gt 1 ]]	# test nombre
	then
		return 1 # 1 si plus d'une fois /dev/sd
	else
		return 0 # 0 sinon
fi
}



# début du programme ##################################################################################
######### variables ################################### 
rech_class="\-\-class"		# jusqu'à trouver la chaine --class dans menuentry
rech_dev="\/dev\/sd"		# la présence de la chaine  /dev/sd dans menuentry
res_blkid="blkid-res.txt"	# le fichier contenant le résultat de sudo blkid
chaine_search="search \-\-no\-floppy \-\-fs\-uuid \-\-set=root"
	 						# protection des tirets pour les recherche par \  d'où les \-
chaine_linux="linux.*\/vmlinu" 			# + général "linux......./vmlinu"
label_submenu=""						# label valide du menuentry précédent
fich_fstab_conc="UBoot_UPart.txt" # créé par recup-fstab contient les uuid ayant boot séparé
#########################################################
num=`date +%Y:%m:%d`-`date +%H:%M:%S`
fich_sauv=grub-OK-$num.txt
fich_sup=grub-sup-$num.txt
fich_transforme=fich_transforme-$num.txt
fich_fstab=fich_fstab-$num.txt
##### pour les stat #####################################
nb_menu_cons=0
nb_menu_boot_cons=0
nb_menu_sup=0
nb_menu_sans_uuid=0
nb_lignes_sup=0
nb_lignes_cons=0
nb_lignes_lues=0
nb_lignes_hors_menu=0
nb_lignes_menus_cons=0
#########################################################

prg="./recup_fstab_V3"	# création de $fich_fstab_conc (UBoot_UPart.txt)

echo "lancement du programme $prg"

#si le programme n'existe pas on sort
! [[ -e "$prg" ]] && echo "il manque le fichier $prg de récupération de infos de fstab" && exit 0
 
# créé le fichier UBoot_UPart.txt contenant uuid1-uuid2 des systèmes boot séparés

code=0		# permet des essais sans lancer prg , en diésant seulement la ligne qui suit

./$prg		# pour des essais mettre #./$prg

code=$?  

if [[ $code -ne 0 ]]
	then
		echo "  il y a eu un problème de traitement du programme  $prg"
		echo "  si l'arrêt n'est pas volontaire"
		echo "  vérifier que le répertoire /mnt/jpb ne comporte pas des résidus de fichiers"
		echo "  éventuellement faire le ménage dans ce répertoire"
		exit 0
	fi

echo
echo "suite du programme $0"
echo ; echo

if ! [[ -e $fich_fstab_conc  ]]	# normalement il a été créé par recup_fstab
	then
		echo "le fichier  $fich_fstab_conc est introuvable"
		echo "il faut d'abord exécuter $prg" 
		echo "ou mettre à disposition manuellement le fichier $fich_fstab_conc"
		echo ; echo
		exit 0
	else  
		echo "  vérification des uuid correspondants à des systèmes sur boot séparés"
		echo "  la première ligne est une ligne de commentaire puis"
		echo "  il existe deux lignes par couple"
		echo "  une ligne uuid1-uuid2"
		echo "  une ligne uuid2-uuid1"
		echo ; echo
		echo "###### contenu du fichier $fich_fstab_conc ############################"
		cat $fich_fstab_conc
		echo "#######################################################################"
		echo ; echo
		echo "  vérifier visuellement le contenu des lignes comprises entre les ###"
		echo "  tapez sur entrée pour continuer"
		read g
	fi

# lecture et mise en mémoire des infos donnée par le fichier $fich_fstab_conc ("UBoot_UPart.txt")
#################################################################################################
max_boot=-1
while read l_boot
do
	[[ -z $l_boot ]] && echo "ligne vide je passe" && continue		# si ligne vide ou commentée
	[[ $l_boot =~ ^[[:blank:]]*# ]] && echo "ligne commentée $l_boot je passe" && continue
	((max_boot++))
	echo $l_boot
	UBoot[$max_boot]=$l_boot # format uuid1-uuid2 à la suite
done < $fich_fstab_conc
#################################################################################################

OK # présentation du programme

code=1
while [[ $code = 1 ]]
do
rep=""
while [[ $rep != [oOyYaAcC] ]]
do
titre="     Utilisation des UUID et LABEL des partitions des disques"
texte="     Choix du fichier de références  LABEL et UUID
	répondez par
			(aA)     pour arrêter ce programme
	
			(oOyY)   si vous voulez ré-utiliser le fichier $res_blkid existant
                         ce fichier a été créé précédemment
						(les labels utilisés pour mettre à jour le grub
						 seront alors ceux déclarés sur la partition)

			(cC)     permet de choisir un fichier de référence UUID LABEL
						(les labels utilisés pour mettre à jour le grub
						 seront alors ceux déclarés dans ce fichier de référence)

				     !!!!!	à partir de V31 ce fichier devra aussi comporter le champ /dev
						    chaque partition doit être déclarée
							le champ UUID est OBLIGATOIRE pour un traitement correct
							le champ type est conseillé
							ce choix peut servir si vous ne voulez pas labelliser les
							partitions mais mettre quand même un label dans grub
							ou bien effctuer des essais
							(ce choix un peu tordu est un peu difficile à comprendre ?)
							le champ /dev/sdxx en premier
							le champ LABEL="xxxxxx"
							le champ UUID="xxxxxx"
							le champ TYPE="xxxxx"							
							une ligne sera donc de la forme
/dev/sdxx LABEL=\"un label correct\" UUID=\"un uuid correct\" TYPE=\"le  type correspondant\"

				            !!!!	en cas de doute utilisez le choix oOyY 	puis Valider

					si vous répondez non , c'est le fichier $res_blkid qui sera
					utilisé pour mettre à jour le titre des menus et sous menus
					dans le fichier traité (surtout utile pour des essais)

					O pour réutilisation du fichier blkid 
					C pour choisir un fichier de référence UUID LABEL
					A Arrêter
"
rep=`zenity --entry --title "$titre" --text "$texte" --width "800"`

case $rep in
	[oOyY]	) echo "réutilisation du fichier $res_blkid créé précédemment" ;;
	[aA]	) echo "arrêt du programme" 		; exit 0				;;
	[cC] 	) echo "choix du fichier des uuid" 	; choix_fichier_blkid 	;;
	*		) echo "utilisez seulement oO yY aA cC S.V.P."				;;
esac
done


# si le fichier de concordance n'existe pas sortie 

if ! [[ -e "$res_blkid" ]]
	then
		echo ; echo
		echo " $0 n'a pas trouvé le fichier"
		echo " $res_blkid"
		echo " que vous avez choisi comme référence UUID-LABEL"
		echo " Modifier votre choix de fichier"
		echo "    ou bien mettez à disposition ce fichier pour continuer" 
		echo ; echo ; sleep 5
		# exit 0
	else
		code=0
	fi

done	# sors de la boucle uniquement si code=0



# récupératon dev label UUID dans des tableaux
unset dev
unset uuid
unset label
unset bdev	# V31 pour boot séparé
unset btype #le type de la partition
unset bmont # point de montage à cause du boot séparé

############## récupération dev label uuid btype dans le fichier choisi ###################
maxuuid=-1
while read ligne
do
#TEST simplification par continue
	[[ -z $ligne ]] && echo "ligne vide je passe" && continue		# correction ligne vide
	((maxuuid++))
	tableau=($ligne) # découper la ligne en champ
	tmp=`sed 's/://g' <<< ${tableau[0]}` # supprime les : donne /dev/sdxx
	[[ -z `grep "^\/dev" <<< $tmp` ]] && echo \
		&& echo "il manque /dev dans la ligne $ligne du fichier de référence UUID-LABEL" \
		&& exit 0
  
	dev[maxuuid]=$tmp			#récupération du dev de la ligne
	label[maxuuid]=""
	uuid[maxuuid]=""
	btype[maxuuid]=""
	
	echo ${tableau[@]}
	
	for champ in ${tableau[@]}
		do
			deb=` echo $champ | cut -c1-5`
			case $deb in
				LABEL)		# en enlevant les guillemets donne U16.04-b7
					label[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
					;;
				UUID\=)		# en enlevant les guillemets donne c63335c7-b....2be94
					uuid[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
					;;
				TYPE\=)		# en enlevant les guillemets donne swap ntfs ext4 ....
					btype[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
			esac
	done

done < $res_blkid

##############################################################################
if [[ "$res_blkid" != "blkid-res.txt" ]]
then
	verifier_presence_dev # vérifie que tous les dev du fichier choisi sont bien déclarés
fi
###############################################################################
# sortie des uuid label pour info
		rm tmp_u_l.txt
echo
		p=0
		while [[ $p -le $maxuuid ]]
		do
			aff_dev="${dev[$p]}"		&& [[ -z "$aff_dev"		]]	&& aff_dev="_"
			aff_label="${label[$p]}"	&& [[ -z "$aff_label"	]]	&& aff_label="___"
			aff_uuid="${uuid[$p]}"		&& [[ -z "$aff_uuid"	]]	&& aff_uuid="___"
			aff_btype="${btype[$p]}"	&& [[ -z "$aff_btype"	]]	&& aff_btype="___"

# car si l'un des $ est "" , il y a erreur d'affichage

			printf "%02s %-10s UUID %-36s LABEL: %-20s  TYPE : %-10s\n" \
					$p $aff_dev $aff_uuid $aff_label $aff_btype  | tee -a tmp_u_l.txt
			((p++))											
		done

titre="Affichage des concordances LABEL <=> UUID      Visualiser puis  Valider pour continuer"
zenity --text-info --title "$titre" --filename "tmp_u_l.txt" --height "640" --width "1280" --font "Courier New Bold 10"
code=$?
if [[ $code -ne 0 ]]
	then
		echo $code
		exit 0 #sortie si on ne valide pas
	else
		echo $code

	fi

################ début de traitement du fichier GRUB ###############################

# Quel fichier grub traiter ?
titre="$0               Sélectionnez le fichier GRUB à traiter"
fich_source=`zenity --file-selection --filename="../fichier-grub/*" --title="$titre"`
case $? in	# $? est le code de retour de zenity
	0)	:														;;
	1)	echo "Aucun fichier sélectionné."			; exit 1	;;
	-1)	echo "Une erreur inattendue est survenue."	; exit 1	;;	
	*)	echo "erreur non reconnue"					; exit 1	;;	
esac


#### lecture et traitement du fichier GRUB #######

trier_fichier # création des 3 fichiers de 1 à 10 linux 10 linux à 40 custom 40 custom à la fin 

################# traitement jusqu'à 10_linux #####################
prem=0
while read ligne
do 
((nb_lignes_lues++))
if  [[ $prem -eq 0 ]]
	then
				modif_ligne1_grub "$ligne" ; ((prem++))
	else
				echo $ligne >> "$fich_sauv"
				((nb_lignes_cons++))
				((nb_lignes_hors_menu++))

fi
done < "$fich_source_0"

################# traitement de 10_linux à 40_custom
IFS="~"
while read ligne
do
((nb_lignes_lues++))

if  [[ $prem -eq 0 ]] # pourrait être supprimé depuis V34
	then
				modif_ligne1_grub "$ligne" ; ((prem++))
	else
				# entre les crochets on a tab et espace élargisement après {
	res=`echo "$ligne" | grep "^[	 ]*menuentry.*{[ 	]*$"`
	mem=`echo "$ligne" | grep "^[	 ]*menuentry ['\"]Memory test.*{[ 	]*$"`

	# res est vide s'il n'y a pas menuentry {
	# mem est non vide si on a Memory test -ne pas traiter menuentry 'Memory test

	if [[ -n $mem ]]
	then			# si Memory test on force res à vide
		res=""
	fi

	if  [[ -z $res ]]
		then 											# pas menuentry 
			subm=`echo "$ligne" | grep "^[	 ]*submenu.*{[ 	]*$"`
			if [[ -z $subm ]]
				then 									# pas menuentry pas submenu
					echo "$ligne" >> $fich_sauv			# écriture de cette ligne dans sauv
					((nb_lignes_cons++))				# stat
					((nb_lignes_hors_menu++))			# stat
					echo -e ".\c"						# trace écran
				else 									# contient submenu
					echo -e "S\c"						# trace
					traite_ligne_submenu "$ligne"		# traitement de submenu
			fi
		
		else								# on a menuentry
			lire_menuentry					# mettre en mémoire dans menu[0..n]
			trt_menu2 "${menu[0]}" 			# rem : 1 si /dev/sd /dev/sd
			code_dev_dev=$?
			if [[ $code_dev_dev -eq 1 ]]	# si 1 on supprime
				then						# le bloc menuentry contient /dev /dev
					sort_menu_1	" " "menu supprimé : trop de /dev/sd"	# fich_sup
					((nb_menu_sup++))

				else  						# menuentry ne contient pas /dev/sd /dev/sd
					critere_suppression_2	# analyse des uuid et recherche de label
					code_crit2=$?
					case $code_crit2 in
					0)						# les uuid sont égaux
						transforme_ligne_menuentry "$chaine_search"	# mettre un label dans menu[0]
						sort_menu_0					# écrire le menu dans fich_sauv
						((nb_menu_cons++))			# stat
					;;
					1)						# menu sans modif (ni search ni linux)
						sort_menu_0					# écrire le menu dans fich_sauv
sort_info_transforme "${menu[0]}" "menu conservé (sans search ou linux)"
						((nb_menu_cons++))			# stat
					;;
					2)						# uuid différents on supprime ce menu
						sort_menu_1	" " "menu supprimé : uuid différents"	# écrire dans fich_sup
						((nb_menu_sup++))				# stat
					;;
					3)						# uuid non trouvé (search et linux existent)
						sort_menu_0					# écrire le menu dans fich_sauv
sort_info_transforme "${menu[0]}" "menu conservé : UUID search-linux non trouvé"
						((nb_menu_cons++))			# ce menu étant conservé
						((nb_menu_sans_uuid++))
					;;
					4)						# uuid != mais boot séparé
						transforme_ligne_menuentry "$chaine_linux" # met label dans menu[0]
						sort_menu_0					# écrire le menu dans fich_sauv
						((nb_menu_cons++))	# stat non prévu dans memorise_menuentry
						((nb_menu_boot_cons++))
					;;
					esac

				fi # [[ $code_dev_dev -eq 1 ]]
		fi #[[ -z $res ]]
	fi #[[ $prem -eq 0 ]]
done < "$fich_source_1"

echo $nb_lignes_lues

################# traitement 40_custom à fin #####################
if [[ -e "$fich_source_2" ]] # en cas d'essai sans ligne 40_custom
	then
		while read ligne
		do 
			((nb_lignes_lues++))
			((nb_lignes_cons++))
			((nb_lignes_hors_menu++))
			echo $ligne >> "$fich_sauv"
		done < "$fich_source_2"
	fi
#################################################################

echo $nb_lignes_lues

# fin présentation des résultats sur l'écran

echo
echo
printf "%-40s %s %s\n" "fichier traité" " : " "$fich_source"
printf "%-40s %s %s\n" "le résultat se trouve dans"  " : " "$fich_sauv"
echo
printf "%-39s %s %5d\n" "nombre de lignes lues" " : " "$nb_lignes_lues"
printf "%-40s %s %5d\n" "lignes conservées" " : " "$nb_lignes_cons"
printf "%-40s %s %5d\n" "lignes supprimées" " : " "$nb_lignes_sup"
if [[ $nb_lignes_sup -gt 0 ]]
	then
printf "%-40s %s %s\n" "fichier des lignes supprimées" " : " "$fich_sup"
	echo
	fi
printf "%-40s %s %5d\n" "nombre de menus conservés" " : " "$nb_menu_cons"
printf "%-40s %s %5d\n" "nombre de menus supprimés" " : " "$nb_menu_sup"
printf "%-40s %s %5d\n" "nombre de menus avec boot conservés" " : " "$nb_menu_boot_cons"
if [[ $nb_menu_sans_uuid -gt 0 ]]
	then
printf "%-40s %s %5d\n" "nombre de menus sans uuid trouvé" " : " "$nb_menu_sans_uuid"
	fi
echo
printf "%-40s %s %5d\n" "lignes conservées (hors menu)" " : " "$nb_lignes_hors_menu"
printf "%-40s %s %5d\n" "lignes conservées (menu)" " : " "$nb_lignes_menu_cons"


echo "après avoir vérifié manuellement le fichier"
echo "$fich_sauv"
echo "en réel vous pourrez remplacer grub.cfg à vos risques et périls"
echo


rep=""
while [[ $rep != [oOyYnN] ]]
do

################ mise à jour du fichier traité  ou non ###########################
titre="    ################       remplacement de GRUB    ###########"
texte="
       Voulez-vous remplacer le fichier choisi par le nouveau fichier généré (oOyYnN)
	
       mais par précaution si vous répondez oui le fichier
 $fich_source (fichier original choisi)
          sera sauvegardé dans
 $fich_source-$num

	   Attention
 $fich_source 
	sera remplacé par le contenu du fichier
 $fich_sauv  (le résultat OK obtenu)
       donc si avez choisi de traiter /boot/grub
       /boot/grub sera remplacé par le fichier résultant ... prenez vos précautions

		personnellement si je traite le fichier réel je réponds N

        pour vérifier le contenu du fichier créé 

        puis j'effectue manuellement la copie

                   répondez par (oOyYnN)"

rep=`zenity --entry --title "$titre" --text "$texte" --width "800"`
case $rep in
	[oOyY] )	# sauvegarde de "grub" , je conserve $num	
			echo "
            OK mais avant je sauvegarde le fichier original
            $fich_source
            dans 
            $fich_source-$num
            mais il me faut le mot de passe"
 			sudo cp "$fich_source" "$fich_source-$num"
			code=$?
			if [[ $code != 0 ]]
				then
					echo "il y a eu un problème lors de la sauvegarde du fichier
                         (code erreur : $code) je sors"
					exit 0
				fi

			#et fich_sauv remplace grub
			echo "
            OK je remplace
            $fich_source
            par
            $fich_sauv"
			sudo mv "$fich_sauv" "$fich_source"
			code=$?
			if [[ $code != 0 ]]
				then
					echo "il y a eu un problème lors du remplacement du fichier
                         (code erreur : $code) je sors"
					exit 0
				fi			

	;;
	[nN]	)	
             echo ; echo "fichier oiginal non remplacé"
             echo "  mais le fichier résultant $fich_sauv est à disposition"
	;;
	*	) 	echo "utilisez seulement oOyYnN S.V.P."
	;;
esac
done

echo "taper entrée pour terminer"
read g #pour attendre
exit 0

le fichier recup_fstab_V3

#!/bin/bash

# V1 récupère le contenu des fichiers fstab qui peuvent exister sur la machine
# comment ?
# récupération des dev présents par blkid
# création du fichier blkid-res.txt
# pour les partitions déjà montées (via mount)
# lecture et traitement de <partition>/etc/fstab

# et pour chacune des autres partitions
# montage
# lecture et traitement de <point de montage>/etc/fstab
# démontage

# le traitement consiste à écrire dans le fichier DevSd_UBoot_UPart.txt
# pour chaque partition qui sera reconnue comme ayant un boot séparé
# DevSd="/dev/sdxx" UPart="uuid de la partition avec boot" UBoot="uuid du boot" 

# le traitement consiste à écrire dans le fichier DevSd_Uboot_Upart-date.txt
# pour chaque partition qui sera reconnue comme ayant un boot séparé
# DevSD="/dev/sdxx" UBoot="uuid du boot" UPart="uuid de la partition avec boot"

# V2 création fichier UBoot_UPart contenant les uuid d'un système avec boot séparé
# format uuid1-uuid2 et uuid2-uuid1 servira lors du traitement modif-grub

# V3 remise en forme

function OK {
# à cause de problème d'affichage


reponse=""
while [[ $reponse != [oOyYnN] ]]
do
titre="programme $0        /!\/!\/!\/!\    Répondez par : (oOyYnN)"
texte="
    (remarque  : il manque des soulignés dans le nom des fichiers !!!)
    le but principal de ce sous programme est de créer le fichier
    $fich_fstab_conc
    qui contiendra les uuid des sysèmes avec boot séparé

    il met a disposition le fichier $res_blkid
    qui contient le résultat de la commande sudo blkid
	
    il crée aussi (pour info d analyse) le fichier
	        DevSd_UBoot_UPart-$num.txt
    qui contiendra entre autre le fichier /etc/fsab des partitions présentes
	
    le fichier
            "$fich_fstab_court" 
    qui contient pour chaque partition 
	DevSd=\"/dev/sdxx\" UPart=\"uuid de la partition avec boot\" UBoot=\"uuid du boot\"
    
    et le fichier 
	"$fich_fstab_long"

 comment ? partie délicate
	récupération des dev existants par sudo blkid

	pour les partitions déjà montées (via mount)
	        lecture et traitement de <partition>/etc/fstab

	et pour chacune des autres partitions
	montage
	        lecture et traitement de <point de montage>$fich_recup
	démontage

 			SOUS-PROGRAMME DE MODIF GRUB
			tapez O puis valider pour continuer
			tapez A puis valider pour arrêter 

			O pour continuer / A pour arrêter le programme  
       "
       
reponse=`zenity --entry --title "$titre" --text "$texte" --width "800"`
case $reponse in
	[oOyY]	)	:												;;
	[aA]	)											exit 1	;;
	*		) 	echo "$reponse utilisez seulement oOyYnN S.V.P."			;;
esac	
done
}


function rech_uuid_dev { # si $1 est dans dev[] renvoi l'uuid correspondant
for i in ${!dev[@]}
do
	[[ "$1" = ${dev[$i]} ]] && uuid=${uuid[$i]} && break
done
}

function rech_uuid_label { # si $1 est dans label[] renvoi l'uuid correspondant
for i in ${!dev[@]}
do
	[[ "$1" = ${label[$i]} ]] && uuid=${uuid[$i]} && break
done
}


function ecrit_uuid1_uuid2 {  # recoit $1 $2 sous la fore UUID= ou LABEL= ou /dev/sdxx
# écrit uuid1-uuid2 et uuid2-uuid1 dans $fich_fstab_conc
# en remplacant le label ou le /dev/sdxx par l'uuid correspondant
# et en enlevant UUID= et LABEL=
uuid1=""
uuid2=""

echo "fonction ecrit_uuid1_uuid2 $1 $2"

#pour le premier paramètre
debut=`echo "$1" | cut -c1-5`
uuid=""
case "$debut" in
		\/dev\/ )
			rech_uuid_dev "$1" # /dev/sdxx on recherche l'uuid correspondant
			uuid1="$uuid"
		;;
		UUID\= )
			uuid1=`echo "$1" | cut -c6-` 			# si UUID= on prend ce qui se trouve après = 
		;;
		LABEL )
			rech_uuid_label `echo "$1" | cut -c7-`	# si LABEL on prend ce qui se trouve après = 
			uuid1="$uuid"							# et on recherche l'uuid correspondant
		;;
esac

#même chose pour le deuxième paramètre
debut=`echo "$2" | cut -c1-5`
uuid=""
case "$debut" in
		\/dev\/ )
			rech_uuid_dev "$2" # /dev/sdxx on recherche l'uuid correspondant
			uuid2="$uuid"
		;;
		UUID\= )
			uuid2=`echo "$2" | cut -c6-`			# UUID= on prend ce qui se trouve après = 
		;;
		LABEL )
			rech_uuid_label `echo "$2" | cut -c7-`	# LABEL on prend ce qui se trouve après =
			uuid2="$uuid"							# et on recherche l'uuid corespondant
		;;
esac

if [[ -n $uuid1 ]] && [[ -n $uuid2 ]]
then
# on écrit les deux combinaisons possibles , plus simple à traiter ensuite
echo $uuid1-$uuid2		>> $fich_fstab_conc
echo $uuid2-$uuid1		>> $fich_fstab_conc
fi

echo "fin de fonction ecrit_uuid1 uuid2 =1=>$uuid1<=== =2=>$uuid2<==="
}



function ecrit_ligne_court {	# ecrit $1 $2 $3 formatés dans un fichier
								# et si $3 (UBoot) non vide
								# uuid1-uuid2 dans UBoot_UPart

printf "DevSd=%-18s UPart=%-36s UBoot=%-36s\n" "$1" "$2" "$3" >> $fich_fstab_court

if [[ -n "$3" ]]			# si uboot non vide
	then
		ecrit_uuid1_uuid2 "$2" "$3" # envoie uuid de partition et uuid de boot
	fi
}


function trans_ligne_fstab { # récupère les champs d'une ligne
# champ1 champ2 champn mais on ne s'intérese qu'aux champs 1 et 2

# champ1 : UUID=uuid ou LABEL=label ou le dev [non traités : PARTUUID= PARTLABEL=]
# champ2 : le point de montage

champ1=`echo "$1"|awk -F" " '{printf ("%s",$1)}'`	# bloc spécial ou système de fichiers distant à monter	
champ2=`echo "$1"|awk -F" " '{printf ("%s",$2)}'`	# c'est le point de montage

case "$champ2" in
		\/ )
			dev_part=$champ1	# si champ2 est /     on positionne dev_part sur champ1
		;;
		\/boot )
			dev_boot=$champ1	# si champ2 est /boot on positionne dev_boot sur champ1
		;;
esac
}

# début du programme 
#########################################################################################
# variables
                 num=`date +%Y:%m:%d`-`date +%H:%M:%S`
           res_blkid="blkid-res.txt"				# résultat de sudo blkid
     fich_fstab_long="DevSd_UBoot_UPart-$num.txt"	# résultant commenté
    fich_fstab_court="DevSd_UBoot_UPart.txt"		# résultant court	DevSd=...U1...U2
     fich_fstab_conc="UBoot_UPart.txt"				# résultant concaténé UUID1-UUID2
 fich_fstab_conc_num="UBoot_UPart-$num.txt"			# sauvegarde,à supprimer manuellement
             rep_mnt=/mnt/jpb-$num					# répertoire pour montages/démontages
          fich_recup=/etc/fstab						# fichier à récupérer dans part.
#########################################################################################

[[ -e $fich_fstab_court ]] && rm $fich_fstab_court

echo "# $num : couples uuid-boot - uuid-systeme des menuentry en boot séparé" > $fich_fstab_conc 

OK 								# présentation du programme  / sortie ou non

reponse=""
while [[ $reponse != [oOyYnNaAcC] ]]
do
titre="récupération des UUID et LABEL des partitions des disques"
texte="
			Récupération des infos dans les fichiers $fich_recup des partitions
			ce programme travaille avec sudo pour
			récupérer les dev (blkid)
			effectuer des montages/démontages
			il vous demandera donc votre mot de passe d'administration

	répondez par	
			(oOyY) pour lancer la commande sudo blkid ( remise à jour du fichier) 
			(aA)   pour arrêter ce programme

					O pour récupérer les devices via SUDO
					A Arrêter
"
reponse=`zenity --entry --title "$titre" --text "$texte" --width "800"`
case $reponse in
	[oOyY]	) sudo blkid > $res_blkid								;;
	[aA]	) echo "arrêt du programme" 				; exit 1	;;
	*		) echo "$reponse utilisez seulement oOyYaA S.V.P."				;;
esac
done


# récupération des dev label et UUID 
unset uuid
unset label
unset bdev		# V31 pour boot séparé
unset bmont 	# pour le point de montage à cause du boot séparé
unset btype 	# le type de la partition


maxuuid=-1
while read ligne 		# lecture et traitement du fichier généré par sudo blkid
do
# c'est le même script que dans modif-grub
# certaine lignes sont inutiles mais je les ai laissées
	[[ -z $ligne ]] && echo "ligne vide je passe" && continue		# correction ligne vide
	((maxuuid++))
	tableau=($ligne) # découper la ligne en champ

	# le dev est le premier champ
	tmp=`sed 's/://g' <<< ${tableau[0]}` # donne /dev/sdxx
	[[ -z `grep "^\/dev" <<< $tmp` ]] && echo \
		&& echo "il manque /dev dans la ligne $ligne du fichier de référence UUID-LABEL" \
		&& exit 1

	# init variables d'indice maxuuid
	   dev[maxuuid]=$tmp		# le dev de la ligne blkid
	  label[maxuuid]=""			# le label de la ligne blkid
	   uuid[maxuuid]=""			# l'uuid de la ligne blkid
	  btype[maxuuid]=""			# le type de la ligne blkid
	mnt_dev[maxuuid]="1"		# modifié par mount : 0 si le dev est monté
	  p_dev[maxuuid]=""			# modifié par mount : point de montage

	# echo ${tableau[@]}			# liste des indices

	# positionnemnt des variables d'indice maxuuid en fonction de la ligne blkid	
	for champ in ${tableau[@]}
		do
			deb=` echo $champ | cut -c1-5`
			case $deb in
				LABEL)		# en enlevant les guillemets donne U16.04-b7
					label[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
					;;
				UUID\=)		# en enlevant les guillemets donne c63335c7-b....2be94
					uuid[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
					;;
				TYPE\=)		# en enlevant les guillemets donne swap ntfs ext4 ....
					btype[maxuuid]=`sed 's/"//g' <<< ${champ##*=}`
			esac
		done

done <$res_blkid


#récupération des partitions déjà montées

mount | grep '^\/dev' > tmp.txt
#     1         2   3        4    5    6
#    /dev/sda11 on /media/SH type ext4 (rw,relatime,data=ordered)

	# remarque :
	# awk -F" " '{printf ("%s ",$1)}' tmp.txt 
	# donne
	# tous les dev séparés par une espace grace à "%s "

	# awk -F" " '{printf ("%s ",$3)}' tmp.txt 
	# donne
	# tous les points de montage séparés par une espace grace à "%s "

mdev=(`awk -F" " '{printf ("%s ",$1)}' tmp.txt`)	# les dev montés dans un tableau
mont=(`awk -F" " '{printf ("%s ",$3)}' tmp.txt`)	# les points de montage dans un tableau


# positionnement montée ou non de chaque dev
for i in ${!dev[@]}						# pour tous les indices des dev
do
	for j in ${!mdev[@]}				# pour tous les indices des partitions montées
		do
			if [[ "${dev[$i]}" = "${mdev[$j]}" ]]
				then
					mnt_dev[i]="0"			# 0 indique que le dev est montée
					p_dev[i]=${mont[$j]}    # le point de montage du dev
					break
				fi
		done
done


# sortie des uuid label pour info
		[[ -e "tmp_u_l.txt" ]] && rm "tmp_u_l.txt"
echo
		p=0
		while [[ $p -le $maxuuid ]]
		do
			    aff_dev="${dev[$p]}"	 	# jamais vide
			aff_mnt_dev="${mnt_dev[$p]}" 	# vaut 0 (monté)  ou 1 (non monté)
			  aff_p_dev="${p_dev[$p]}"		# (affichage en fonction du précédent)
			# pour les corrections d'affichage 
			 aff_uuid="${uuid[$p]}"		&& [[ -z "$aff_uuid"	 ]]	&& aff_uuid="_"
			aff_label="${label[$p]}"	&& [[ -z "$aff_label"	 ]]	&& aff_label="_"
			aff_btype="${btype[$p]}"	&& [[ -z "$aff_btype"	 ]]	&& aff_btype="_"

			case $aff_mnt_dev in
			0)
				printf "%02s %-10s %-36s LABEL %-20s sur %-20s TYPE : %-10s\n" $p $aff_dev $aff_uuid $aff_label $aff_p_dev $aff_btype  | tee -a tmp_u_l.txt ;;
			1)
				printf "%02s %-10s %-36s LABEL %-20s                          TYPE : %-10s\n" $p $aff_dev $aff_uuid $aff_label  $aff_btype			| tee -a tmp_u_l.txt ;;
			esac	

			((p++))											
		done

reponse=""
titre="concordances     dev<=>LABEL<=>UUID<=>point de montage (de blkid)     Visualiser   puis Valider pour continuer"
zenity --text-info --title "$titre" --filename "tmp_u_l.txt" --height "640" --width "1280" --font "Courier New Bold 10"
code=$?
if [[ $code -eq 0 ]]
then
	echo "OK je continue"
else
	echo ; echo "Annulation demandée" ; echo ; exit 1
fi


##################################################
# pour cette partie il est absolument nécessaire d'avoir une liste des dev corrects
# d'où le sudo blkid effectué plus haut !
##################################################

echo "récupération des fstab de toutes les partitions"			 > $fich_fstab_long
echo 															>> $fich_fstab_long

############################################################
echo "pour les partitions déjà montées :" 						>> $fich_fstab_long
echo ${!dev[@]}

for i in ${!dev[@]} # pour tous les indices du tableau dev

	do
		echo $i ${dev[$i]} ${mnt_dev[$i]}
		[[ ${mnt_dev[$i]} = "1" ]]	&& continue		# non monté suivant !
		[[ ${btype[$i]} = "ntfs" ]]	&& continue 	# ntfs      suivant !
		[[ ${btype[$i]} = "swap" ]]	&& continue 	# swap      suivant !
		# on pourrait en ajouter d'autres

		echo  													>> $fich_fstab_long
		echo ${dev[$i]} "montée sur" ${p_dev[$i]} 				>> $fich_fstab_long

		#pour chaque dev monté on récupére les infos de fstab
		fich=${p_dev[$i]}$fich_recup 
		fich=`sed 's/\/\//\//g' <<< $fich` # supprime les doubles // (à cause de  //etc/fstab)

		echo $fich	#soit /etc/fstab soit /xxx/xxx/etc/fstab
		
		if [[ -e $fich ]]
			then
				echo  											>> $fich_fstab_long
				echo "$fich de ${dev[$i]}"  					>> $fich_fstab_long
				# on ne garde que les lignes non commentées et non vide

				dev_part=""
				dev_boot=""
				while read l_fstab
					do
						tmp=` grep '^[[:blank:]]*\#' <<< $l_fstab`
						#si tmp n est pas vide , elle commence par #
						if [[ -z $tmp ]] && [[ -n $l_fstab ]]
							then 
								echo $l_fstab >> $fich_fstab_long
								trans_ligne_fstab "$l_fstab"
							fi
					done < $fich
		ecrit_ligne_court "${dev[$i]}" "$dev_part" "$dev_boot"
			else
				echo 									>> $fich_fstab_long
				echo "pour ${dev[$i]} (${label[$i]}) /etc/fstab est inexistant"	>> $fich_fstab_long
			fi
	done

echo >> $fich_fstab_long

##############################################################
echo "pour les partitions non montées :" >> $fich_fstab_long


if [[ -e "/mnt" ]]
then
	echo "réperoire /mnt présent"
else
	echo "le répertoire /mnt n'existe pas !!!"
	exit 1
fi


rep_mnt_tmp="/mnt/jpb-$num"
echo "création du répertoire $rep_mnt_tmp pour monter les partitions"

sudo mkdir $rep_mnt_tmp

for i in ${!dev[@]} # pour tous les indices du tableau dev
do
	echo $i ${dev[$i]}

	[[ ${mnt_dev[$i]} = "0" ]]	&& continue		# montée    suivant !
	[[ ${btype[$i]} = "ntfs" ]]	&& continue 	# ntfs      suivant !
	[[ ${btype[$i]} = "swap" ]]	&& continue 	# swap      suivant !

	echo
	echo "traitement de $i ${dev[$i]} (${btype[$i]})"
	echo "montage de       ${dev[$i]} sur $rep_mnt_tmp"
	sudo mount ${dev[$i]} $rep_mnt_tmp
	code=$?
	
	echo "code de retour montage de ${dev[$i]} sur $rep_mnt_tmp : $code"
	if [[ $code = 0 ]]	# si le montage est réussi
		#################### montage réussi ####################
		then
			fich=$rep_mnt_tmp/etc/fstab
			if [[ -e $fich ]]
				then
					echo 							>> $fich_fstab_long
					echo ${dev[$i]} montée sur $rep_mnt_tmp	>> $fich_fstab_long
					dev_part=""
					dev_boot=""					
					while read l_fstab
							do
								tmp=` grep '^[[:blank:]]*\#' <<< $l_fstab`
								# si ne commence pas par # , tmp est vide 
								# et si la ligne n'est pas vide on l'écrit
							if [[ -z $tmp ]] && [[ -n $l_fstab ]]
								then 
									echo $l_fstab 					>> $fich_fstab_long
									trans_ligne_fstab "$l_fstab"
								fi
							done < $fich
		ecrit_ligne_court "${dev[$i]}" "$dev_part" "$dev_boot"
				else
		echo															>> $fich_fstab_long
		echo "pour ${dev[$i]} (${label[$i]}) /etc/fstab est inexistant" >> $fich_fstab_long
				fi
			# puis on le démonte avec boucle sinon le démontage ne se fait pas toujours
			boucle=0
			code=1
			while [[ $code -ne 0 ]]
			do
				sudo umount "$rep_mnt_tmp"
				code=$?
				echo "boucle $boucle  : ${dev[$i]} code de retour de umount $code"
				if [[ $code = 0 ]]
					then
						echo 
						echo "boucle $boucle : ${dev[$i]} démontage effectué (code retour $code)"
						ls -ails $rep_mnt_tmp
					else
						echo
						echo "boucle $boucle : ${dev[$i]} non démonté (code retour $code)"
						sleep 1 # attente en cas de non démontage
						((boucle++))
						if [[ $boucle -ge 10 ]]
							then
								echo "problème de démontage de ${dev[$i]}"
								exit 1
							fi	
					fi
			done # boucle while
		############################ échec de montage ###################
		else
			echo																	>> $fich_fstab_long
			echo "impossible de monter ${dev[$i]}  code echec de montage :$code"	>> $fich_fstab_long
		fi
done # boucle for i dev

echo ; echo
echo "fin de récupération des données de /etc/fstab des partitions présentes sur la machine"
echo ; echo

# sauvegarde de UBoot_UPart pour une utilisation personnelle
cp "$fich_fstab_conc" "$fich_fstab_conc_num"

echo "suppression du répertoire $rep_mnt_tmp en cours"
sudo rmdir $rep_mnt_tmp
code=$?

if [[ $code -ne 0 ]]
	then 
	#rmdir: échec de suppression de '/mnt/jpb-2017:03:11-12:02:43': Périphérique ou ressource occupé
		echo
		ls -ails /mnt/jpb*
		echo "vérifier le contenu du répertoire /mnt/jpb"
		echo "faire le ménage dans ce répertoire"
		exit 1
	fi

echo "supression réussie"
echo "fin normale du programme $0"
exit 0

EDIT ligne 320 (sans conséquence)