Contenu | Rechercher | Menus

Annonce

Si vous avez des soucis pour rester connecté, déconnectez-vous puis reconnectez-vous depuis ce lien en cochant la case
Me connecter automatiquement lors de mes prochaines visites.

À propos de l'équipe du forum.

#1 Le 07/02/2011, à 13:03

men-go

Sauvegarde/Restauration de partitions NTFS (Windows) avec ntfsclone

PREMIERE PARTIE

Dernières modifications:
11/01/2013
Mise à jour des scripts. Ajout du script rmount. Mise à jour du texte ci-dessous
27/02/2011
1) Suppression des arguments dans le script d'installation
2) Prise en compte des noms de fichiers avec caractère(s) blanc(s)


Ceci est un tutoriel décrivant une application de sauvegarde et restauration de partitions NTFS. Il s'adresse en premier à ceux qui commencent à avoir quelques notions de Linux, qui font cohabiter Windows et Ubuntu et qui ne veulent absolument pas être dans l'obligation de restaurer Windows comme il était installé en usine. Le but de cette petite application est de pouvoir faire "pas cher du tout" et régulièrement des sauvegardes de ce système. L'intérêt, si on est dans l'obligation de restaurer Windows, est:

        - Éviter de reparamétrer le système
        - Ne pas réinstaller la totalité des logiciels  (et encore, à condition qu'on se souvienne parfaitement de ceux qui étaient installés)
        - De récupérer une bonne partie des données personnelles (on ne perdrait que les modifications faites entre la sauvegarde et la restauration)
        - D' être un peu plus zen lorsque teste ou qu'on installe un logiciel à provenance incertaine
        - etc.

Cette application tient compte d'un environnement d'exécution qu'elle crée, mais ses commandes principales sont:

ntfsclone [--rescue] -so chemin_du_fichier_de_sauvegarde  /dev/sd??    # Sauvegarde de la partition NTFS /dev/sd??

ntfsclone -rO  /dev/sd??   chemin_du_fichier_de_sauvegarde  /dev/sd??    # Restauration de la partition NTFS /dev/sd??
ntfsfix /dev/sd??            # Provoque chkdsk au redémarrage de Windows

Avec --rescue=ignorer les erreurs d'entrée/sortie, -s=save-image (sauvegarde), -o=sauvegarde sur le fichier chemin_du_fichier_de_sauvegarde qui sera créé, -r=restore-image (restauration), -O=overwrite (en restauration écrase les éventuels fichiers restaurés existants, en sauvegarde écrase le fichier de sauvegarde s'il existe), /dev/sd?? unité d'une partition NTFS non montée. La taille de la partition restaurée doit être au moins égale à celle sauvegardée.

FONCTIONNEMENT (Testé avec XP, Vista, 7)
      L'application gère plusieurs sauvegardes dans le temps de telle sorte qu'on puisse restaurer éventuellement une instance plus âgée mais sûre. Pour ce faire, elle a besoin de place disque qui va être fonction du nombre d'instances qu'on veut garder. Le nombre d'instances sera paramétré dans un fichier index qui, lorsqu'on le sollicitera donnera un numéro qui fera partie du nom du fichier de sauvegarde.

      Le fichier index contient 5 nombres: l'index courant (il s'agit du numéro de la prochaine sauvegarde), l'index rendu(par le script),  l'index minimum, l'index maximum et l'incrément.  Chaque sauvegarde génèrera (si possible, sur un autre disque que le disque source par souci de performance et de sécurité, ex: disque externe USB) un ou deux fichiers (système et éventuellement données personnelles – Documents, Images ...- ) dont les noms comporteront un numéro correspondant à l'index courant. Puis l'index courant sera additionné de l'incrément. Si résultat est supérieur à l'index maximum, l'index minimum sera le nouvel index courant provoquant ainsi, à la prochaine sauvegarde, l'écrasement de l'archive la plus âgée.

      À la fin normale de la sauvegarde, l'index courant prend la même valeur que l'index rendu.  En cas d'arrêt intempestif durant la sauvegarde, l'index courant sera différent de l'index rendu. Lors de la prochaine tentative de sauvegarde, le script demandera de quelle façon on remettra "index courant"="index rendu" (normalement répondre "r").

      Cette application est basée sur l'utilitaire ntfsclone qui fait partie de la suite ntfsprogs. Elle est composée de scripts shell (2 pour la sauvegarde: ntfscln, ntfswins, 2 pour la restauration: ntfsrst, ntfswinr et 3 communs: mg-xmgr, vmount, rmount) et 2 lanceurs: Arch_WIN.desktop, Rest_WIN.desktop.

      Les scripts utilisent les noms (labels ou étiquettes) des partitions ou volumes. Il vaut donc mieux que chaque nom soit choisi de telle sorte qu'il soit unique pour l'ensemble des systèmes (utiliser GParted par exemple pour affecter ces étiquettes).

      Tous les scripts affichent un "Usage" lorsqu'on les exécute sans argument. Leurs messages ont chacun un identifiant préfixé par 4 caractères spécifiques au script et suffixé par: I(information), R(répondre), A | W(attention), E(erreur). Ils ont les fonction suivantes:

mg-xmgr  (gestion du fichier index. Messages préfixés par XMGR...)
- Suffixe le nom du fichier index par ".mgx"
- Crée le fichier index s'il n'existe pas
- Lit le fichier index, sauvegarde l'index courant et incrémente ce dernier
- Retourne l'index courant précédemment sauvegardé

vmount  (vérification du montage d'un volume. Messages préfixés par VMNT...)
- Vérifie que l'argument (répertoire) passé est valide (l'argument contient le label volume)
- Extrait le label volume de l'argument
- Quelque soit le label (label ou label_), vérifie que /media/label ou /media/label_ est monté
- Retourne le bon argument où "_" a été ajouté ou supprimé dans le label volume
- Retourne un argument vide si le volume n'est pas monté
- Retourne dans tous les cas le label, la partie répertoire et cette dernière préfixée par "/"

rmount  (remontage d'un ou plusieurs volumes. Messages préfixés par RMNT...)
Remontage de volumes qui étaient montés dans /media/labelvolume_  ou /media/userid/labelvolume[_] dans /media/labelvolume

ntfscln  (sauvegarde d'un volume ou partition. Messages préfixés par NCLS...)
- Vérification des paramètres passés en argument
- Vérification (par ntfslabel) que le disque à sauvegarder existe et qu'il est démonté
- Création du répertoire de sauvegarde s'il n'existe pas
- Si l'index est donné, vérifie qu'il est compris entre des valeurs minimum et maximum
- Si l'index n'est pas donné, affiche les sauvegardes existantes et demande quel est l'index à utiliser
- Émet un message de confirmation. En cas de réponse positive ("o|O"), éventuellement supprime le fichier de sauvegarde qu'on veut remplacer et effectue la sauvegarde
- Émet un message de fin

ntfswins (appel de ntfscln pour sauvegarder un ou deux volumes. Messages préfixés par NWRS...)
- Vérifie que le volume de sauvegarde est monté
- Vérification avec vmount que le volume source est démonté. Démontage du volume si monté.
- Création du répertoire de sauvegarde s'il n'existe pas
- Obtention de l'index par appel de mg-xmgr
- Appel ntfscln pour sauvegarder le premier volume
- Appel éventuel de ntfscln pour sauvegarder le second volume

ntfsrst (restaure 1 volume. Messages préfixés par NRST...)
- Vérifie que l'argument de dénomination de la cible a été passé (il détermine le chemin de recherche et le nom de l'archive)
- Si le device (/dev/sdbn) n'est pas passé, détermination (par ntfslabel) que le disque à sauvegarder existe et qu'il est démonté
- Vérification de l'existence du chemin d'archivage
- Demande le numéro de l'archive à restaurer
- Restauration avec ntfsclone

ntfswinr (appel de ntfsrst pour restaurer un ou deux volumes. Messages préfixés par NWSR...)
- Vérification avec vmount que le volume cible est démonté. Démontage du volume si monté
- Vérification de l'existence des répertoires contenant les archives
- Appel ntfsrst pour restaurer le(s) volume(s)

INSTALLATION
    Installation normale
1)    Créer un répertoire, par exemple: /home/userid/darwin
2)    Faire un copier/coller de la totalité de l'annexe ci-dessous (à partir de "#!/bin/bash") dans "Nouveau document" d'un éditeur et sauvegarder dans le répertoire nouvellement créé avec un nom par exemple: intfsr
3)    Donner l'attribut d'exécution à ce fichier avec nautilus: Propriétés/[Permission]/"Autoriser l'exécution du fichier..." ou Terminal: chmod u+x  ~/darwin/intfsr
4)    Mettre en ligne le disque qu'on utilisera pour sauvegarder
5)    Exécuter dans "Terminal" ce nouveau fichier:
darwin/intfsr
6)     Après extraction, le script va demander les éléments suivants:
       - Le répertoire de sauvegarde sans '/media/'
       - Le label volume de la partition système à sauvegarder
       - Le suffixe (&WIN, défaut=WIN) du nom des lanceurs (Arch&WIN.desktop, Rest&WIN.desktop),
       - Le commentaire dans les lanceurs (type de Windows,défaut=7)
       - [Le label volume de la partition des données personnelles]

Exemple  1
Installation pour un Windows  7 (label HELIOS) avec une partition de données (celle qui contient "Mes documents", label GAIA) sur un disque USB (label ARTEMIS-X4, file system ext4). On aura: nom de lanceur WIN7, type 7, répertoire de sauvegarde ARTEMIS-X4/SV_WIN7, système Windows HELIOS, partition de données  GAIA. On répondra:
ARTEMIS-X4/SV_WIN7 HELIOS , , GAIA

Si la partition "données personnelles" n'existe pas:
ARTEMIS-X4/SV_WIN7 HELIOS WINDOWS7 "Windows Seven"

Dans la première réponse, on a pris les valeurs par défaut pour le suffixe des nom de lanceurs et le type de Windows, alors que dans la seconde on les donne

Exemple 2
La partition RECOVERY de ce Windows 7 peut aussi être sauvegardée. Mais comme, à priori, cette sauvegarde se fera rarement, le répertoire de sauvegarde ne sera pas le même que celui de Windows:
ARTEMIS-X4/SV_RECOVERY7  RECOVERY  RCVY7  "Windows 7 RECOVERY"

Exemple 3
Sauvegarde d'un Windows XP (label PERSEE) avec une partition de données (label APHRODITE) sur un disque USB (label POSEIDON, file system NTFS). Suffixe du nom de lanceur WINXP, type XP, répertoire de sauvegarde POSEIDON/SV_WINXP, système Windows PERSEE, partition de données  APHRODITE:
POSEIDON/SV_WINXP  PERSEE  WINXP  XP  APHRODITE

      Le script d'installation est réexécutable, il tient compte des éléments déjà installés. L'installation modifie ou ajoute :  ~/bin (scripts), ~/Bureau (lanceurs), /usr/local/sbin (liens) et le répertoire sur le disque de sauvegarde.

      Les lanceurs peuvent être recopiés dans  "~/.local/share/applications" auquel cas ils apparaîtront dans le menu "Applications/Accessoires".

      Pour désinstaller il suffit de supprimer les objets dans les différents répertoires qui viennent d'être cités ci-dessus.

    Installation sur "live clé USB"
      L'installation sur une "live clé USB" se fait de la même façon qu'une installation normale, l'environnement de travail étant celui de l'utilisateur ubuntu.

UTILISATION

      La sauvegarde et la restauration se font à partir de systèmes de fichiers démontés. Les fichiers de sauvegarde ne sont pas compressés, la performance a été choisie au détriment de la place disque (si l'utilisateur en éprouve le besoin "man ntfsclone" donne la procédure de compression).

    La sauvegarde

      La sauvegarde se fait en principe quelques jours après une mise à jour de Windows pour s'assurer de "l'innocuité" de la mise à jour et débute (normalement) par quelques manipulations dans Windows (W7):
- Prendre  un point de restauration: \Propriétés[Protection du système]{Créer…}
- Faire "le ménage" dans Windows (\Tous les programmes\Accessoires\Outils système\Nettoyage de disque(choix C:)[de disque]{Nettoyer les fichiers système} => [Autres options]: Restauration du système et de clichés instantanés {Nettoyer…}. )
- Supprimer le fichier 'hiberfil.sys' ( 'cmd.exe' en mode administrateur: powercfg   -h    off)
- Défragmentation des disques (le mieux est de la faire en mode sans échec avec un logiciel genre Jkdefrag)

      Ces manipulations permettent de sauvegarder un système propre et d'exécuter automatiquement l'utilitaire de vérification du disque système chkdsk en cas de restauration de ce dernier.

      Revenir sur Ubuntu et supprimer le fichier pagefile.sys (ce fichier est recréé dès qu'on reviendra dans Windows). Exécuter la sauvegarde par le lanceur approprié et suivre les consignes des messages.

    La restauration

      La restauration se fait en principe dans les partitions d'origine dont les tailles sont supérieures ou égales à celles sauvegardées. En cas de besoin (vérifications, tests anti-virus...) on pourra restaurer dans d'autres partitions et/ou autres disques (ce type de restauration ne sera pas "bootable"). Si Windows comprend deux partitions l'application demandera le numéro de fichier de restauration de chaque partition, l'utilisateur a ainsi la possibilité de faire une restauration asynchrone système/données. La restauration va écraser tout ce qui subsisteraient dans les partitions cibles.

      Si la restauration concerne la partition "bootable" d'un système faisant cohabiter Windows et Ubuntu et que cette dernière a été manipulée par gparted (ex: reformatage), il faudra vraisemblablement faire un update-grub (ou mettre à jour menu.lst si grub legacy) pour pouvoir la "booter". Par contre si l'utilisateur a pris soin de créer des menus grub en changeant les UUID par les LABEL, cette étape est inutile.

ANNEXE: OBJETS A INSTALLER

#!/bin/bash
#men-go: intfsr
#
if [[ "$1" && "$1" = "-h" ]]; then echo -e "
NINS01A Usage:
#
# intfsrW [-h]
#
# -h|rsm    '-h' Affiche l'aide
#         'rsm' saute l'extraction et reprend pour une autre installation
#
# Extraction des scripts et lanceurs. Résultats dans le répertoire d'installation
# Installation de l'application
##################################################################################
#"
exit 2; fi
#
#_________________________________________________________________________________
# Fonction pour sortie [a]normale
csortie ()
{
if [ ! $SL ]
  then
    read -n 1 -p "NINS10R Appuyer sur une touche ..."  INDX; echo ""
fi
if [ $1 ]; then exit $1; else exit 1; fi
}
#_________________________________________________________________________________
# 

IFILE=$0; exec 3<"$IFILE"; if [[ $? -ne 0 ]]; then echo "NINS03E Fichier '$IFILE' non trouvé"; csortie; fi
ODIR=${IFILE%/*}"/"
exec 4>/dev/null        # Permet de ne pas extraire ce script
if [[ "$1" && "$1" = "rsm" ]]; then RSM=resume; fi

# Extraction des objets
SIFS=$IFS; IFS=ø
if [[ ! -a "$ODIR"vmount && ! $RSM ]]; then
  while read -r -u 3 record
  do
    pseprcd=`expr index "$record" °`                 # pseprcd -> premier "°" dans record
    l_rcd=${#record}
    if [[ $pseprcd -ne 0 ]]; then
      rarg1=${record%°*}                    # extract s-chaîne avant  "°"
      rarg2=${record#*°}                    # extract s-chaîne après  "°"
      if [[ "$rarg1" = "<========" || "$rarg1" = ">========" ]]; then
        if [[ "$rarg2" = "" ]]; then echo "NINS03E Nom d'objet inexistant dans le séparateur"; csortie; fi
        if [[ "$rarg2" = "##" ]]; then echo " "
        else
          OFILE=$ODIR$rarg2; exec 4>&-; exec 4> $OFILE            #; echo "???? $OFILE ******"
          if [[ $? != 0 ]]; then echo "NINS06E Erreur ouverture fichier: $OFILE"; csortie; fi
          chmod u+x $OFILE; typobj="Script"; if [[ "$rarg1" = ">========" ]]; then typobj="Lanceur"; fi
          echo "NINS04I $typobj extrait: '$OFILE'"
        fi
      else echo "$record" >&4
      fi
    else echo "$record" >&4
    fi
  done
  exec 3<&-; exec 4>&-
fi


# Installation       
IFS=";"
echo "
NINS05R Donner le répertoire de sauvegarde sans '/media/',
le label volume de la partition système à sauvegarder,
le suffixe (&WIN, défaut=WIN7) du nom des lanceurs (Arch&WIN.desktop, Rest&WIN.desktop),
le commentaire dans les lanceurs (type de Windows,défaut=7),
[le label volume de la partition des données personnelles]"
echo sous la forme: SVDIR"$IFS"SYSLAB"$IFS"LANCSUF"$IFS"LANCOM"$IFS"[DATALAB]

read SVDIR SYSLAB LANCSUF LANCOM DATALAB
if [[ $LANCSUF = "" || $LANCSUF = "," ]]; then LANCSUF="WIN7"; fi
if [[ $LANCOM = "" || $LANCOM = "," ]]; then LANCOM="7"; fi
IFS=$SIFS

VMNT="$SVDIR"
. "$ODIR""vmount" "$VMNT"
if [[ ! "$VMNT" ]]; then VMNT=$SVDIR; fi

"$ODIR""arWIN" $LANCSUF  $LANCOM "$VMNT" "$SYSLAB" "$DATALAB"       # "D BIN"
SIFS=$(date --rfc-3339=ns)
echo "
NINS07I Fin de traitement :=:=:=:=:=:=:=:=:=:=:=: $SIFS"
echo ""

csortie 0

>========°Arch_WIN.desktop
[Desktop Entry]
Version=1.0
Terminal=false
Name=Arch&LANCSUF
Comment=Archivage Windows &LANCOM
TryExec=gnome-terminal
Exec=gnome-terminal  --geometry 118x28  -x sudo ntfswins "&SVDIR" "&SYSLAB" "&DATALAB"
Icon=/usr/share/icons/Humanity/actions/48/archive-insert.svg
Type=Application
X-GNOME-DocPath=gnome-terminal/index.html
X-GNOME-Bugzilla-Bugzilla=GNOME
X-GNOME-Bugzilla-Product=gnome-terminal
X-GNOME-Bugzilla-Component=BugBuddyBugs
X-GNOME-Bugzilla-Version=3.0.1
Categories=GNOME;GTK;Utility;Archiving;
StartupNotify=true
OnlyShowIn=GNOME;Unity;
X-Ubuntu-Gettext-Domain=gnome-terminal
>========°Rest_WIN.desktop
[Desktop Entry]
Version=1.0
Terminal=false
Name=Rest&LANCSUF
Comment=Restauration Windows &LANCOM
TryExec=gnome-terminal
Exec=gnome-terminal  --geometry 148x34  -x sudo ntfswinr "&SVDIR" "&SYSLAB" "&DATALAB"
Icon=/usr/share/icons/Humanity/actions/48/extract-archive.svg
Type=Application
X-GNOME-DocPath=gnome-terminal/index.html
X-GNOME-Bugzilla-Bugzilla=GNOME
X-GNOME-Bugzilla-Product=gnome-terminal
X-GNOME-Bugzilla-Component=BugBuddyBugs
X-GNOME-Bugzilla-Version=3.0.1
Categories=GNOME;GTK;Utility;Archiving;
StartupNotify=true
OnlyShowIn=GNOME;Unity;
X-Ubuntu-Gettext-Domain=gnome-terminal
<========°arWIN
#!/bin/bash
#men-go: arWIN

if [ $# -eq 0 ]; then echo -e "
AINT11A Usage:
#
# arWIN    WIN LANCOM SVDIR SYSLAB [DATALAB] [BIN]
           $LANCSUF  $LANCOM "$SVDIR" "$SYSLAB" "$DATALAB"
#
# WIN | -l | ,    Nom lanceur ('Arch\$WIN.desktop')        
#               '-l': recréation des liens symboliques uniquement
#               ',': pas de copie des lanceurs
# LANCOM      Commentaire du lanceur (type de Windows: XP, Vista, 7)
# SVDIR    Directory de sauvegarde/restauration
# SYSLAB    Label disque système Windows à sauvegarder
# DATALAB    Label disque data à sauvegarder
# BIN         Défaut bin
#
# Installations de l'application Sauvegarde/Restauration Windows, copie des scripts et des lanceurs.
#######################################################################################################
#"
exit 2; fi

DIRSRC=$0; DIRSRC=${DIRSRC%/*}        # Répertoire source des scripts, lanceurs
if [ "$1" = "-l" ]; then sudo "$DIRSRC/sarWIN" -l; exit 0; fi

LANCSUF=$1           # Nom lanceur ("Arch$LANCSUF.desktop")
LANCOM=$2            # LANCOMe de Windows à mettre dans le commentaire du lanceur
SVDIR=$(echo $3 | sed "s/\//(/g")        # Directory de sauvegarde/restauration
SV_DWIN=$3        # Directory de sauvegarde/restauration
SYSLAB=$4        # Label disque système Windows sauvegardé
if [[ "$5" && "$5" != "," ]]; then DATALAB=$5; else DATALAB=" "; fi    # Label disque data sauvegardé
BIN="bin"; if [[ "$6" ]]; then BIN=$6; fi    # répertoire scripts OUT

OBUR="Bureau"
if [ ! -d ~/$OBUR ]; then OBUR="Desktop"; fi

# Tests si la source et la cible existent
if [ ! -d "$DIRSRC" ]; then echo "AINT01E Répertoire source '$DIRSRC' non trouvé"; exit 1; fi
if [ ! -d ~/$OBUR ]; then echo "AINT02E Répertoire ~/$OBUR non trouvé"; exit 1; fi

# Si "~/$BIN" n'est pas un lien symbolique
if [ ! -L ~/"$BIN" ]; then
   if [ ! -d ~/"$BIN" ]; then mkdir ~/"$BIN"; echo "AINT03I Création du répertoire '~/$BIN'"; fi
   cp -pu "$DIRSRC/"ntfs* ~/"$BIN"/; cp -pu "$DIRSRC/mg-xmgr" ~/"$BIN"/; cp -pu "$DIRSRC/vmount" ~/"$BIN"/
   if [ $? = 0 ]; then echo "AINT04I Copie des scripts ntfs*, mg-xmgr, vmount OK"
     chmod u+x ~/"$BIN"/ntfscln; chmod u+x ~/"$BIN"/ntfsrst; chmod u+x ~/"$BIN"/ntfswinr; chmod u+x ~/"$BIN"/ntfswins
     chmod u+x ~/"$BIN"/mg-xmgr; chmod u+x ~/"$BIN"/vmount
   fi
else echo "AINT10E '~/"$BIN"' est un lien symbolique. Abandon..."; exit 1
fi

if [[ "$LANCSUF" != "," ]]; then
   cat "$DIRSRC/Arch_WIN.desktop" | sed -e "s/&LANCSUF/$LANCSUF/g; s/&SVDIR/$SVDIR/g; s/&SYSLAB/$SYSLAB/g; s/&DATALAB/$DATALAB/g; s/&LANCOM/$LANCOM/g" | sed "s/(/\//g"  > ~/$OBUR/Arch$LANCSUF.desktop; rc1=$?
   cat "$DIRSRC/Rest_WIN.desktop" | sed -e "s/&LANCSUF/$LANCSUF/g; s/&SVDIR/$SVDIR/g; s/&SYSLAB/$SYSLAB/g; s/&DATALAB/$DATALAB/g; s/&LANCOM/$LANCOM/g" | sed "s/(/\//g"  > ~/$OBUR/Rest$LANCSUF.desktop; rc2=$?
   if [ $(($rc1+$rc2)) = 0 ]; then
   chmod a+x ~/$OBUR/Rest$WIN.desktop; chmod a+x ~/$OBUR/Arch$WIN.desktop
   echo "AINT05I Création des lanceurs OK"
   fi
fi

sudo "$DIRSRC/sarWIN" "$SV_DWIN" "$BIN"

exit 0

<========°sarWIN
#!/bin/bash
#men-go: sarWIN
#

if [ $# -eq 0 ]; then echo -e "
AINT11A Usage:
#
# sudo sarWIN SV_DWIN | -l  BIN
#
# SV_DWIN    Répertoire de sauvegarde/restauration. Si '-l' recréation des liens uniquement
# BIN         Défaut bin
#
# Installations de l'application Sauvegarde/Restauration Windows, création des liens symboliques des scripts,
# ainsi que le répertoire de sauvegarde.
############################################################################################################
#"
exit 2; fi

lnusrloc () {
if [ ! -L /usr/local/sbin/$1 ]
  then ln -sT /home/$SUDO_USER/"$BIN"/$1   /usr/local/sbin/$1
    if [ $? != 0 ]; then echo "AINT06E Erreur création du lien symbolique '/usr/local/sbin/$1'"; return 1;fi
  echo "AINT06I Création du lien symbolique '/usr/local/sbin/$1'"
  else echo "AINT06A Le lien symbolique '/usr/local/sbin/$1' existe"
fi
return 0
}

BIN="bin"; if [[ $2 ]]; then BIN=$2; fi    # répertoire scripts
# Création des liens symboliques dans "/usr/local/sbin"
lnusrloc ntfscln
lnusrloc ntfswins
lnusrloc ntfsrst
lnusrloc ntfswinr
lnusrloc mg-xmgr
lnusrloc vmount
if [ "$1" = "-l" ]; then exit 0; fi 

# Création du répertoire de sauvegarde
VMNT=$1; . vmount "$VMNT"
if [ ! "$VMNT" ]; then exit 1; fi
if [ -d "/media/$VMNT" ]; then echo "AINT09I Le répertoire '/media/$VMNT' existe déjà"; exit 0; fi
mkdir -p "/media/$VMNT"
if [ $? = 0 ]; then echo "AINT07I Création du répertoire de sauvegarde '/media/$VMNT' OK"; fi

exit 0

<========°ntfscln
#!/bin/bash
#men-go: ntfscln
#_________________________________________________________________________________
# Fonction pour sortie [a]normale
csortie ()
{
if [ $SL != "-s" ]
  then
    read -n 1 -p "NCLS10R Appuyer sur une touche ... "  INDX; echo ""
fi
if [ $1 ]; then exit $1; else exit 1; fi
}
#_________________________________________________________________________________

if [ $# -eq 0 ]; then echo -e "
NCLS01A Usage:
#
# ntfscln [-s][r] IN_DISK SV_DISK [INDX]
#
# -r &| s   -r => ’--rescue’ -s => mode ’esclave’
# IN_DISK   Label du volume à sauvegarder
# SV_DISK   Label/répertoire récepteur
# INDX      Index du fichier récepteur 0<= INDX <=9
#
# Sauvegarde d'un disque NTFS avec l'utilitaire ntfsclone.
# Le répertoire de réception sera: /media/SV_DISK/SV_IN_DISK
# Le nom du fichier archive sera:  NTFSclone_IN_DISK_?.img
##################################################################################
#"
csortie 2; fi

declare -i XMIN=0; declare -i XMAX=999
if [[ $VWIXMIN ]]; then XMIN=$VWIXMIN; fi		#Récup index mini XMIN si var envt $VWIXMIN existe
if [[ $VWIXMAX ]]; then XMAX=$VWIXMAX; fi		#Récup index mini XMAX si var envt $VWIXMAX existe
if [[ $XMAX -le $XMIN ]]; then echo "TARS11E Plage index ’$XMIN - $XMAX’ invalide"; csortie; fi

OPTR=$1; if [[ "$1" = "-r" || "$1" = "-sr" || "$1" = "-rs" || "$1" = "-s" ]]; then shift ; fi
if [[ "$OPTR" = "-s" || "$OPTR" = "-sr" || "$OPTR" = "-rs" ]]; then SL="-s"; fi
if [[ "$OPTR" = "-r" || "$OPTR" = "-sr" || "$OPTR" = "-rs" ]]; then OPTR="--rescue"; else OPTR=" "; fi

if [ $# -eq 0 ]; then echo "NCLS01E Pas d'argument"; csortie; fi

IN_DISK=$1
SV_DISK=$2

if [ ! "$2" ]
  then
  echo "NCLS02E Le volume récepteur est obligatoire en 2ème argument"; csortie 
fi 

Rfile="/tmp/fileR"$(date --rfc-3339=ns); IN_DSK=$(echo $IN_DISK | sed 's/ /°/g')
ls -Gg --time-style=long-iso /dev/disk/by-label | sed 's/\\x20/°/g' | grep "$IN_DSK " | sed 's/\.\.\// /g' > "$Rfile"
read rd1 rd2 rd3 rdd rdt rdlab rdf rddev < "$Rfile"; rm "$Rfile"
ntfslabel /dev/$rddev > /dev/null
if [ $? -ne 0 ]; then echo "NCLS03E Le disque ’$rdlab’ n'existe pas ou doit être démonté"; csortie ;fi

if [ ! -d "/media/$SV_DISK/SV_$IN_DISK" ]
   then
   mkdir "/media/$SV_DISK/SV_$IN_DISK"
   if [ $? -eq 0 ]; then echo "NCLS09I Répertoire ’/media/$SV_DISK/SV_$IN_DISK’ créé"
      else echo "NCLS09E Erreur création répertoire ’/media/$SV_DISK/SV_$IN_DISK’"; csortie
   fi 
fi
cd "/media/$SV_DISK/SV_$IN_DISK"

rootfile=NTFSclone_"$IN_DISK"_

if [ $3 ]
  then
    INDX=$3
    if [ $INDX -lt $XMIN -o  $INDX -gt $XMAX ]
    then echo "NCLS08A Argument ’index nom d'archive’ invalide ($XMIN>= INDX <=$XMAX)"; csortie
    fi
  else INDX=-1
fi

#until [[ ( $INDX -ge $XMIN ) && ( $INDX -le $XMAX ) ]]
until  [ $INDX -ge $XMIN  -a  $INDX -le $XMAX ]
  do
  echo "PERMISSIONS    UID      GID    Taille    DERNIERES MAJ    NOMS"
  ls -lt "$rootfile"*.img
  echo " ";echo " "
  echo "NCLS04I Donner le numéro du fichier archive à créer ou remplacer"
  read -n 3 -p "NCLS05R Le numéro de fichier archive doit être compris entre $XMIN et $XMAX: "  INDX; echo ""
  done

svwdisk=$rootfile$INDX.img
read -n 1 -p "NCLS06R Archive à créer|remplacer: ’/media/$SV_DISK/SV_$IN_DISK/$svwdisk’. Répondre ’O|o’ "  rcfin; echo ""
if [[ $rcfin != "O" && $rcfin != "o" ]]; then echo "Abandon"; csortie 0; fi
if [ -a "$svwdisk" ]
  then
  rm "$svwdisk"
fi
 
date --rfc-3339=ns

time ntfsclone $OPTR -so "/media/$SV_DISK/SV_$IN_DISK/$svwdisk"  /dev/$rddev
svrc=$?

date --rfc-3339=ns
cd ~

if [ $svrc = 0 ]
  then
  rcfin="normale"; msgsuf=I
  else
  rcfin="ANORMALE"; msgsuf=A; svrc=2
fi

echo "NCLS07$msgsuf Fin de sauvegarde $rcfin ’/media/$IN_DISK’ sur ’/media/$SV_DISK/SV_$IN_DISK/$svwdisk’"
if [ $SL != "-s" ]; then csortie 0; fi

exit $svrc

<========°ntfswins
#!/bin/bash
#men-go: ntfswins
#_________________________________________________________________________________
# Fonction pour sortie [a]normale
csortie ()
{
if [ ! $SL ]
  then
    read -n 1 -p "NWSR10R Appuyer sur une touche ... "  XCOUR; echo ""
fi
if [ $1 ]; then exit $1; else exit 1; fi
}

# suppression de pagefile.sys et de hiberfil.sys
delwsys()
{
if [[ -d "/media/$LABEL/Windows" || -d "/media/$LABEL/WINDOWS" && -d "/media/$LABEL/Program Files" && -d "/media/$LABEL/Documents and Settings" ]]
then
#     rc1=$(ls "/media/$LABEL/pagefile.sys"); if [ "$rc1" != "" ]; then rm "/media/$LABEL/pagefile.sys"; fi
  if [ -a "/media/$LABEL/pagefile.sys" ]; then rm "/media/$LABEL/pagefile.sys"
  echo "NWSR07I Fichier ”pagefile.sys” supprimé"; fi
  if [ -a "/media/$LABEL/hiberfil.sys" ]; then rm "/media/$LABEL/hiberfil.sys"
  echo "NWSR07I Fichier ”hiberfil.sys” supprimé"; fi
fi
}

# montage préalable
mntpre()
{
AA=$(ls -l /dev/disk/by-label | grep "$1" | sed "s/\.\.\/\.\./\/dev/g"); AA=($AA); DEV=${AA[10]}  
# udisks --mount $DEV --mount-fstype ntfs --mount-options rw,nosuid,nodev
mount -o rw,nosuid,nodev -t ntfs $DEV /media/"$1"; sleep 2 
}
#_________________________________________________________________________________

if [ $# -eq 0 ]; then echo -e "
NWSR05A Usage:
#
# ntfswins  SV_DISK IN_DISK1 [IN_DISK2 | ’,’] [-R]
#
# SV_DISK   Label/répertoire du volume récepteur
# IN_DISK1  Label du volume 1 à sauvegarder
# IN_DISK2  Label du volume 2 à sauvegarder
# -R        Si donné => option ’--rescue’ dans ntfsclone
#
# Sauvegarde d'un Windows comprenant une ou deux partitions NTFS par ’ntfsclone’
# (faire le ménage dans Windows avant).
# Appel du script ntfscln avec un index récupéré par le script mg-xmgr
# Création du répertoire de sauvegarde s'il n'existe pas
##################################################################################
#"
csortie 2; fi

SV_DISK=$1; VMNT=$1;. vmount "$VMNT"; if [[ $? -ne 0 ]]; then csortie; else SV_DISK=$VMNT; fi
rc="NWSR01I Volume démonté: "

IN_DISK1="$2"; mntpre "$IN_DISK1"; VMNT="$IN_DISK1";. vmount "$VMNT" x
if [[ $? -eq 0 ]]; then
  delwsys
  umount "/media/$LABEL"; echo $rc ’$LABEL’
fi
if [[ "$3" && "$3" != "," ]]; then IN_DISK2=$3; mntpre "$IN_DISK2"; VMNT="$IN_DISK2";. vmount "$VMNT" x
  if [[ $? -eq 0 ]]; then
  rc1=99; delwsys
  umount "/media/$LABEL"; echo $rc ’$LABEL’; fi
fi
OPT="-s"; if [[ "$4" = "-R" ]]; then OPT="-sr"; fi


# Traitement du répertoire de sauvegarde
if [ ! -d "/media/$SV_DISK" ]
   then
   mkdir "/media/$SV_DISK"
   if [ $? -ne 0 ]; then echo "NWSR02E Erreur création ’/media/$SV_DISK’"; csortie;
     else echo "NWSR02I Création ’/media/$SV_DISK’"
   fi
fi

#Lecture du fichier index
Ifile="/media/$SV_DISK/ntfscln"
# if [ ! "$3" ]; then Ifile="/media/$SV_DISK/SV_$IN_DISK1/ntfscln"; fi
. mg-xmgr "$Ifile"


#Sauvegarde partition 1
ntfscln "$OPT" "$IN_DISK1" "$SV_DISK" $XCOUR
rc=$?

#Si donné, sauvegarde partition 2
if [[ $rc1 = 99 ]]; then
  ntfscln "$OPT" "$IN_DISK2" "$SV_DISK" $XCOUR; rc1=$?
  else rc1=0
fi

(( rc=$rc+$rc1 ))
if [ $rc = 0 ]; then . mg-xmgr -w "$Ifile"; fi
csortie $rc

<========°ntfsrst
#!/bin/bash
#men-go: ntfsrst
#_________________________________________________________________________________
# Fonction pour sortie [a]normale
csortie ()
{
if [ ! $SL ]
  then
    read -n 1 -p "NRST10R Appuyer sur une touche ... "  INDX; echo ""
fi
if [ $1 ]; then exit $1; else exit 1; fi
}
#_________________________________________________________________________________

if [ $# -eq 0 ]; then echo -e "
NRST01A Usage:
#
# ntfsrst [-s] SV_DISK OU_DISK [RDDEV]
#
# -s        Mode esclave
# SV_DISK   Label/Répertoire du volume d'archive
# OU_DISK   Label(nom) du volume à restaurer
# RDDEV     ’device’ si pas de label partition à restaurer
#
# Restauration d'un disque NTFS avec l'utilitaire ntfsclone.
# Le répertoire d'archive est: /media/SV_DISK/SV_OU_DISK
# Le nom du fichier archivé est:  NTFSclone_OU_DISK_?.img
##################################################################################
#"
csortie 2; fi

if [ "$1" = "-s" ]; then SL=$1; shift; fi

if [ $# -eq 0 ]; then echo "NRST01E Pas d'argument"; csortie; fi 

SV_DISK=$1
OU_DISK=$2
RDDEV=$3

if [[ ! "$2" ]]
  then
  echo "NRST02E Le nom de volume récepteur est obligatoire"; csortie 1
fi 

if [ -z $RDDEV ]
  then
  Rfile="/tmp/fileR"$(date --rfc-3339=ns); OU_DSK=$(echo $OU_DISK | sed 's/ /°/g')
  ls -Gg --time-style=long-iso /dev/disk/by-label | sed 's/\\x20/°/g' | grep "$OU_DSK " |  sed 's/\.\.\// /g' > "$Rfile"
  read rd1 rd2 rd3 rdd rdt rdlab rdf RDDEV < "$Rfile"; rm "$Rfile"  #; echo $RDDEV ; exit #
  ntfslabel /dev/$RDDEV > /dev/null
  if [ $? -ne 0 ]; then echo "NRST03E Le disque $rdlab n'existe pas ou doit être démonté"; csortie 1;fi
fi
# echo /media/$SV_DISK/SV_$OU_DISK
if [ ! -d "/media/$SV_DISK/SV_$OU_DISK" ]
   then
   echo "NRST09E Répertoire d'archivage non trouvé: ’/media/$SV_DISK/SV_$OU_DISK’"; csortie
fi
cd "/media/$SV_DISK/SV_$OU_DISK/"

rootfile=NTFSclone_"$OU_DISK"_; INDX=-1

  echo "PERMISSIONS  UID   GID    Taille    DERNIERES MAJ    NOMS"
  ls -lt --time-style=long-iso "$rootfile"?.img
  echo " ";echo " "
  echo "NRST04I Donner le numéro du fichier archive à restaurer sur /media/$OU_DISK($RDDEV)"
  read -p "NRST05R Le numéro de fichier archive doit se trouver dans la liste ou ’,’ (abandon): "  INDX; echo ""
  if [ $INDX = "," ]; then echo "NRST08I Pas de restauration de ’/media/$OU_DISK’ à faire"; csortie 0; fi

svwdisk=$rootfile$INDX.img
read -n 1 -p "NRST06R Archive à restaurer: ’/media/$SV_DISK/SV_$OU_DISK/$svwdisk’. Répondre ’O|o’ "  rcfin; echo ""
if [[ $rcfin != "O" && $rcfin != "o" ]]; then echo "Abandon"; csortie; fi
if [[ ! -a "$svwdisk" ]]
  then
  echo "NRST07E Fichier $svwdisk inexistant"
  csortie
fi
 
date --rfc-3339=ns

time ntfsclone -rO  /dev/$RDDEV   "/media/$SV_DISK/SV_$OU_DISK/$svwdisk"
svrc=$?
ntfsfix /dev/$RDDEV			# Provoque chkdsk au redémarrage de Windows

date --rfc-3339=ns
cd ~

if [ $svrc = 0 ]
  then
  rcfin="normale"; msgsuf=I
  else
  rcfin="ANORMALE"; msgsuf=A; svrc=2
fi

echo "NRST07$msgsuf Fin de restauration $rcfin /media/$OU_DISK($RDDEV) à partir de ’/media/$SV_DISK/SV_$OU_DISK/$svwdisk’"
if [ ! $SL ]; then csortie 0; fi

exit $svrc

<========°ntfswinr
#!/bin/bash
#men-go: ntfswinr
#_________________________________________________________________________________
# Fonction pour sortie [a]normale
csortie ()
{
if [ ! $SL ]
  then
    read -n 1 -p "NWSR10R Appuyer sur une touche ..."  INDX; echo ""
fi
if [ $1 ]; then exit $1; else exit 1; fi
}
#_________________________________________________________________________________

if [ $# -eq 0 ]; then echo -e "
NWSR05A Usage:
#
# ntfswinr  SV_DISK OU_DISK1 [OU_DISK2]
#
# SV_DISK   Label/répertoire du volume archive
# OU_DISK1  Label/device du volume 1 récepteur
# OU_DISK2  Label/device du volume 2 récepteur 
#
# Restauration d'un Windows comprenant une ou deux partitions NTFS par ’ntfsclone’
###################################################################################
#"
csortie 2; fi

SV_DISK=$1; VMNT=$1;. vmount "$VMNT"; if [[ $? -ne 0 ]]; then csortie; else SV_DISK=$VMNT; fi
rc="NWSR01I Volume démonté: "
OU_DISK1=$2; VMNT=$2;. vmount "$VMNT" x
if [[ $? -eq 0 ]]; then umount "/media/$LABEL"; echo $rc ’$LABEL’; fi
if [ "$3" ]; then OU_DISK2=$3; VMNT=$3;. vmount "$VMNT" x
  if [[ $? -eq 0 ]]; then umount "/media/$LABEL"; echo $rc ’$LABEL’; fi
fi

if [ ! -d "/media/$SV_DISK/SV_$OU_DISK1" ]
  then
  echo "NWSR04E Répertoire ’/media/$SV_DISK/SV_$OU_DISK1’ non trouvé"; csortie
fi 

if [ ! -z "$OU_DISK2" ]
  then
  if [ ! -d "/media/$SV_DISK/SV_$OU_DISK2" ]
    then
    echo "NWSR04E Répertoire ’/media/$SV_DISK/SV_$OU_DISK2’ non trouvé"; csortie
  fi
fi 

#Restauration partition 1
ntfsrst -s "$SV_DISK" "$OU_DISK1"
rc=$?; rc1=0

#Si donné et si restauration partition 1 OK, restauration partition 2
if [ $rc -eq 0 ]; then
  if [ "$3" ]; then OU_DISK2=$3
    ntfsrst -s "$SV_DISK" "$OU_DISK2"; rc1=$?
  fi
fi

(( rc=$rc+$rc1 ))
csortie $rc

<========°mg-xmgr
#!/bin/bash
#men-go: mg-xmgr
if [ $# -eq 0 ]; then echo -e "XMGR01W Usage:
#
# mg-xmgr   [-f|-F|-w] XFILEN
#
# -f|-F|-w  Si ’index en cours’ != ’dernier index rendu’, avec -f ’dernier index rendu’=
#           ’index en cours’, ’-F’ ’index en cours’ = ’dernier index rendu’ si appel du
#           script pour lecture du fichier index. ’-w’ met à jour le fichier index avec
#           ’index en cours’ = ’dernier index rendu’ si appel du script dans le même
#           processus
# XFILEN    Nom du fichier index
#
# Gère le fichier index ’XFILEN’ (création + retour de l'index courant + réécriture
# du prochain index). << Script exécuté dans le shell en cours >>.           
# Rend l'index courant dans la variable XCOUR
#####################################################################################
#"
exit 2; fi

#_________________________________________________________________________________
# Fonction de réécriture de l'enregistrement d'index
w_index ()
{
echo "$1 $2	$3	$4	$5  $6
↑_↑	↑	↑	↑ incrément
|	|	+-index maxi
|	+-index mini
+-index courant et index rendu" > "$XFILEN"
}
#_________________________________________________________________________________


declare -i XMIN=1; declare -i XMAX=12; declare -i XINC=1
declare -i xmin; declare -i xmax; declare -i xinc; declare -i XCOUR; declare -i xcour

if [[ "$1" = "-f" || "$1" = "-F" || "$1" = "-w" ]]; then chx="$1"; shift; fi
XFILEN="$1"".mgx"

if [ ! "$chx" ]; then
# Création du fichier index si n'existe pas
  while [[ ! -a "$XFILEN" ]]
  do
    read -p "XMGR02R donner les index ’mini maxi incrément’ (Défauts: $XMIN $XMAX $XINC) => " xmin xmax xinc; echo ""
    if [[ $xmin = 0 && $xmax = 0 && $xinc = 0 ]]; then xmin=$XMIN; xmax=$XMAX; xinc=$XINC; fi
    if [[ $xmax = 0 ]]; then xmax=$XMAX; fi
    if [[ $xinc = 0 && $xmax != 0 ]]; then xinc=$XINC; fi
    if [[ $xmin -ge $xmax ]]; then echo "XMGR02E Plage index invalide: index mini ’$xmin’ >= index xmaxi ’$xmax’"; break; fi #<=exit
    if [[ $xinc = 0 || $((xmax-xmin)) -lt $xinc ]]; then echo "XMGR03E Incrément invalide: ’0’ ou ’$xinc > $xmax-$xmin’"; break; fi #<=exit
    w_index 0  0  $xmin $xmax $xinc
    if [ $? -eq 0 ]; then echo "XMGR04I Fichier index ’$XFILEN’ créé avec: 0 0 $xmin $xmax $xinc (index courant, index rendu, index mini, index maxi, incrément)"
      else echo "XMGR04E Erreur création fichier index ’$XFILEN’"; break  #<=exit
    fi
  done

  #Lecture du fichier index
  if [[ -a "$XFILEN" ]]; then
    read xcour XCOUR xmin xmax xinc PID < "$XFILEN"
    if [[ $xcour -ne $XCOUR ]]; then
      while [[ "$aswr" != "R" && "$aswr" != "M" ]]; do  
      echo -e "Déphasage fichier index $XFILEN. Index en cours=$xcour, dernier index rendu=$XCOUR.
Répondre ’r|R’ pour réinitialiser à ’index en cours=index rendu=$xcour’ ou ’m|M’ pour mettre
à jour avec ’index en cours=index rendu=$XCOUR’"
      read -n 2 aswr; aswr=`echo $aswr | tr a-z A-Z`
      done
      if [ $aswr = "R" ]; then XCOUR=$xcour; else xcour=$XCOUR; fi
    fi    
  XCOUR=$((XCOUR+xinc))
  if [[ $XCOUR -gt $xmax ]]; then XCOUR=$xmin; fi
  w_index $xcour $XCOUR $xmin $xmax $xinc $$
  fi
fi

#Lecture "forcée" du fichier index
if [[ "$chx" = "-f" || "$chx" = "-F" ]]; then
  if [[ -a "$XFILEN" ]]; then
    read xcour XCOUR xmin xmax xinc PID < "$XFILEN"
    if [[ "$chx" = "-f" ]]; then XCOUR=$xcour; else xcour=$XCOUR; fi
  fi    
  XCOUR=$((XCOUR+xinc))
  if [[ $XCOUR -gt $xmax ]]; then XCOUR=$xmin; fi
  w_index $xcour $XCOUR $xmin $xmax $xinc $$
fi

#MAJ après utilisation de l'index rendu
if [[ "$chx" = "-w" ]]; then
  if [[ -a "$XFILEN" ]]; then
    read xcour XCOUR xmin xmax xinc PID < "$XFILEN"
    if [ $PID != $$ ]; then
    echo "XMGR05E Processus en cours différent de celui du fichier index. Faut-il mettre à jour (o|O)?"
    read -n 2 aswr; aswr=`echo $aswr | tr a-z A-Z`
      if [ $aswr != "O" ]; then exit 1; fi
    fi 
    w_index $XCOUR $XCOUR $xmin $xmax $xinc
  fi
fi

<========°vmount
#!/bin/bash
#men-go: vmount  
#
if [ $# -eq 0 ]; then echo -e "
VMNT01A Usage:
#
# vmount  VMNT "*"
#
# VMNT      Répertoire où est inclus le label volume
# "*"       Si arg 2 donné, pas de message d'erreur VMNT02E
#
# Vérification du montage du volume dont le label est inclus dans l'argument,
# label étant suffixé ou non par ’_’. << Exécuté dans le shell courant >>.
# Retourne VMNT rectifié si le volume [re]monté existe et rc = 0
# Retourne rc=1 si volume non monté et variable VMNT non déclarée
# Retourne rc=2 si argument 1 vide
# Retourne dans tous les cas LABEL, MDIR et EOPATH 
##################################################################################
#"
exit 2; fi

vermnt () {
  VMNTt=$(mount -l | grep "/$1 ")				# verif si MEDIA=LABEL_ est monté
  if [[ "$VMNTt" != "" ]]; then VMNTt=($VMNTt)			# Résultat de mount=tableau
    if [ ${VMNTt[0]:0:5} = "/dev/" ]; then rmount $LABEL	# si les 5 premiers chr=/dev => unité (sinon: loop)
      if [[ $? -eq 0 ]]; then VMNT=$LABEL$EOPATH; return 0
      else unset VMNT; return 1
      fi
    else VMNT=$LABEL$EOPATH; return 2				# fsloop
    fi
  fi
return 255
}
#
# $VMNT=*********?/******/******
#       <--------VMNTl--------->
#       <-MEDIAc->
#       **MEDIA**?EOPATH********
#                  MDIR*********
#
# 12.10: Vérif si $USER/LABEL... 
VMNTt=${VMNT#$USER/}; if [ "$VMNTt" != "$VMNT" ]; then VMNT="$VMNTt"; fi

VMNTl=${#VMNT}    # VMNT length
if [[ $VMNTl -eq 0 ]]; then echo "VMNT03E Argument ’VMNT’ vide"; return 2; fi
MEDIA=${VMNT%%/*}						# extract s-chaîne avant 1er "/"
if [[ "$MEDIA" = "" ]]; then VMNT=${VMNT#/}; MEDIA=${VMNT%%/*}; fi  # Suppr 1er "/" de VMNT
MEDIAc=${#MEDIA}       						# MEDIAc=longueur avant 1er "/"
MDIR=${VMNT#*/}; if [[ "$MDIR" = "$VMNT" ]]; then MDIR=""; fi 	# extract s-chaîne après 1er "/"
EOPATH="/"$MDIR; if [[ "$MDIR" = "" ]]; then EOPATH=""; fi 	# extract s-chaîne avec 1er "/"
#
# test '/media/**MEDIA**" est donné ou non avec "_" en suffixe
if [[ ${MEDIA:$((--MEDIAc)):1} = "_" ]]				# Si l'argument contient '_'
then

  LABEL=${MEDIA%_}						# Suppression de '_'
  vermnt "$MEDIA" 
  MTRC=$?; if [ $MTRC -ne 255 ]; then return $MTRC; fi

  vermnt "$LABEL" 
  MTRC=$?; if [ $MTRC -ne 255 ]; then return $MTRC; fi

else								# L'argument ne contient pas '_'

  LABEL=$MEDIA; MEDIAc=$MEDIA"_"
  vermnt "$MEDIAc" 
  MTRC=$?; if [ $MTRC -ne 255 ]; then return $MTRC; fi

  LABEL=$MEDIA
  vermnt "$LABEL" 
  MTRC=$?; if [ $MTRC -ne 255 ]; then return $MTRC; fi 

fi

if [[ ! $2 ]]; then echo "VMNT02E Disque ’/media/$MEDIA’ non trouvé (démonté ?)"; LABEL=$MEDIA; fi
unset VMNT; return 1
#

<========°rmount
#!/bin/bash
#men-go: rmount  
#
if [ $# -eq 0 ]; then echo -e "
RMNT01A Usage:
#
# rmount  \"label1 ... labeln\" 
#
# Démontage d'un répertoire [suffixé par ’_’] et remontage du volume dans un 
# répertoire non suffixé et de premier niveau dans ”/media”. 
#
# label1 ... labeln	Nom du(es) volume(s) (sans ’_’) à remonter
##################################################################################
#"
exit 2; fi
if [ $UID -ne 0 ]; then echo "SUID01W Ce script doit être exécuté par ”root”"; exit 1; fi
#
declare -ai RC
TLAB=( $1 ); if [ ${#TLAB[@]} = 0 ]; then exit 1; fi

for ix in $(seq 0 $((${#TLAB[@]} - 1 ))); do
  LABEL=${TLAB[$ix]}; LABEL_=$LABEL"_"
  AA=$(mount -l | grep -e "\[$LABEL\]")
  if [ $? -eq 0 ]; then 
    AA=($AA); TYFS=${AA[4]}; if [ "$TYFS" = "fuseblk" ]; then TYFS="ntfs"; fi
    RMTDEV=${AA[0]}; MPT=${AA[2]}; OPT=${AA[5]};
    if [ $MPT != "/media/$LABEL" ]; then 
      udisks --unmount /dev/disk/by-label/$LABEL
      if [[ $? -ne 0 ]]
        then echo "RMNT05E Erreur de démontage du disque: $LABEL"; RC[$ix]=1
      else
        MPTf=${MPT:$((${#AA[2]}-1)):1}
        if [[ $MPTf != "_" ]]; then
          echo "RMNT02W Répertoire non monté: /media/$LABEL_ "; RC[$ix]=1 
        fi
      
        OPT=${OPT%)}; OPT=${OPT#(}; # echo $OPT
        #
        mount -o $OPT -t $TYFS $RMTDEV "/media/$LABEL" 
        if [[ $? -eq 0 ]]
          then echo "RMNT03I Remontage de $RMTDEV dans le répertoire: /media/$LABEL "; RC[$ix]=0; sleep 2
          else echo "RMNT04E Erreur de remontage de $RMTDEV dans le répertoire: /media/$LABEL "; RC[$ix]=1
        fi 
      fi
    else echo "RMNT06W Répertoire déjà monté: /media/$LABEL "; RC[$ix]=0
    fi
  else echo "RMNT02E Disque non monté: $LABEL "; RC[$ix]=1  
  fi
done

RCM=$(($ix+1)); ix=$RCM
for (( ixr=0; $((ix--)); $((ixr++)) )); do RCT=$((RCT+${RC[$ixr]})); done
RCR=0; if [[ $RCT -lt $RCM && $RCT -ne 0 ]]; then RCR=2; fi #Erreur sur au moins 1 volume
if [ $RCT -eq $RCM ]; then RCR=1; fi #Erreur sur tous volumes
exit $RCR
#

                                        QUELQUES TRUCS

    Temporisation: timedly
Ce petit script fait une temporisation (défaut 30s) puis passe le deuxième argument à une autre instance de BASH. Personnellement je l'utilise dans "Système/Préférences/Applications au démarrage" pour lancer Firefox et Thunderbird après initialisation de la liaison wifi. Exemple d'utilisation:

timedly , "gnome-terminal  --geometry 118x28 -x sudo UPD_home /home \"ARTEMIS X4/UPD CRIO-UB_h\""

avec:
","        temporisation de 30s (défaut)
"gnome-terminal  --geometry 118x28 -x sudo UPD_home /home \"ARTEMIS X4/UPD CRIO-UB_h\""     argument passé à bash. Noter l'insertion du paramètre entre \" \", obligatoire puisqu'il s'agit d'un nom de répertoire contenant un caractère blanc.

#!/bin/bash
#men-go timedly
if [ $# -eq 0 ]; then echo -e "
Usage:
# timedly   NBSEC \"CMDE ARG1...ARGn\" 
#
# NBSEC		Nombre de secondes d'attente. Défaut 30s si \",\" 
# \"CMDE ARG1...ARGn\"
# 		CMDE=Commande à appeler. ARG1...ARGn Arguments de la commande CMDE. \"CMDE ARG1...ARGn\"
# 		est exécuté par une 2ème instance de BASH. Les arguments ARGn doivent être mis entre
#		\\\"\\\" en cas de besoin.
#
# Exécution de la commande CMDE après un temps d'attente NBSEC avec les arguments \"ARG1\"...\"ARGn\"
# Ex:
# timedly , \"gnome-terminal  --geometry 118x28 -x sudo UPD_home /home \\\"ARTEMIS X4/UPD CRIO-UB_h\\\"\"
###################################################################################################
#"
exit 2; fi

# Tests whether *entire string* is numerical.
isdigit ()
{
case $1 in
  *[!0-9]*|"") return 1;;
            *) return 0;;
esac
}

# Test de l'argument "nombre de secondes d'attente"
declare -i nb_secs=30

if [[ $1 != "," && $1 != "" ]]; then
  if isdigit $1; then 
    nb_secs=$1
  else exit 1
  fi
sleep $nb_secs
fi 
 
# Récup commande et argument(s)
if [[ "$2" ]]; then
  CMDE=$2					# CMDE=Commande à exécuter
  bash -c "$CMDE"				# Exécution de la ligne de commande
fi

exit 0


    Modification récursive de  "mode" uniquement pour répertoires: chmodRD
Il peut arriver de devoir faire de telles modifications surtout si on veut mettre de façon récursive l'attribut "execute" sur uniquement les répertoires. Exemple d'utilisation:

chmodRD "-c g+rwx" ~/.local

#!/bin/bash 
#men-go: chmodRD
#
if [ $# -eq 0 ]; then echo -e "
# Usage:
#
# chmodRD  MODE DIRECTORY
# 
# MODE       Argument passé dans la commande chmod (ex: u+rw. Voir ’man chmod’)
# DIRECTORY  Répertoire.
#
# Exécution de la commande ’chmod -R’ qui n'affecte que les [sous-]répertoires
# Ex:    chmodRD \"-c g+rw\" ~/Documents
#        chmodRD \"-c g+rw\".[a-zA-Z0-9]*	# Affecte .* mais sans /. et /..
###################################################################################"
  echo " "; exit 2
fi

MODE=$1
DIR=$2

# Test de l'argument "DIRECTORY"
if [[ ! "$2" ]]; then read -n 1 -p "Confirmer si action à faire sur le répertoire courant (o|O) >: " DIR; echo " "
  if [[ $DIR = "o" || $DIR = "O" ]]; then DIR=" "; else echo "Abandon..."; exit 2; fi
fi

ls -1aR --file-type "$DIR" | awk '/\//' | awk '/:/' | sed 's/:/ /g' | sed 's/\.\// /g' | awk -v cmdr="chmod $MODE  " '{dir=$S0; dir=substr(dir,1,length(dir)-1); dir="\""dir"\""; cmde=cmdr dir; system(cmde)}'

exit 0
#

    Utilisation des "file systems loop"
Il s'agit de simples fichiers qu'on formatera en tant que systèmes de fichiers. Avantages:
  - Peut avoir n'importe quelle taille même petite
  - Sauvegarde en ne recopiant qu'un seul fichier
  - Ne modifie pas l'architecture du système si on prend soin de placer le fichier dans une autre partition

Inconvénient, obligation de monter le système de fichiers pour avoir accès à ces mêmes fichiers. Exemple de mise en place, création d'un file system pour y placer tout ce qui se trouve dans /usr/local:

sudo dd if=/dev/zero of=/media/répertoire/USR-local bs=1M count=1    # fichier de 1 Mo créé dans autre partition
sudo mkfs.ext2 -F USR-local -L U64_usrlocal        # création du système de fichiers, label= U64_usrlocal
sudo mount  -o loop -t ext2  USR-local /mnt        # montage sur un répertoire inutilisé
sudo cp /usr/local/*  /mnt                        # Recopie de /usr/local/* dans le nouveau file system
sudo umount  /mnt
sudo mount  -o loop -t ext2  /media/répertoire/USR-local  /usr/local    # remontage à demeure
#Mise à jour /etc/fstab, ajout:
/media/répertoire/USR-local  /usr/local          ext2    rw,loop            0       0

A compter de ce moment toutes les modifications portées à /usr/local/* seront faites dans le nouveau file system. Si on démonte le file system, on retrouve les anciennes données de la partition système. Si on réinstalle Ubuntu, il suffit de mettre à jour le file system avec les nouvelles données de la nouvelle installation et remettre les paramètres sus-cités dans /etc/fstab.

    Et d'un RAMfs
Le RAM file system et l'utilisation du surplus de RAM pour l'utiliser comme un disque avec comme avantages, la rapidité et comme inconvénient de tout perdre en cas de mise hors tension une taille plus ou moins limitée. Pour développer ou tester on peut s'accommoder de ces inconvénients.
Mise en place:

sudo mknod -m 660 /dev/ram b 1 1
sudo chown root:disk /dev/ram
# Création de /media/RAMfs
sudo mount -t ramfs /dev/ram0 /media/RAMfs
# Modif /etc/fstab, ajout RAMfs:
/dev/ram0        /media/RAMfs    rw        0    0

Dernière modification par men-go (Le 11/01/2013, à 17:39)

Hors ligne

#2 Le 12/02/2011, à 12:48

men-go

Re : Sauvegarde/Restauration de partitions NTFS (Windows) avec ntfsclone

Tout d'abord un grand merci à slasher-fun qui a notablement amélioré la présentation de mon sujet.

Corrections, modifications:
ntfswins
Changer la ligne 32: SV_DISK=$1; VMNT=$1;. vmount;SV_DISK=$VMNT; if [[ $? != 0 ]]; then csortie; fi
et mettre à la place:  SV_DISK=$1; VMNT=$1;. vmount $VMNT; if [[ $? != 0 ]]; then csortie; else SV_DISK=$VMNT; fi

ntfswinr
Changer la ligne 29: SV_DISK=$1; VMNT=$1;. vmount;SV_DISK=$VMNT; if [[ $? != 0 ]]; then csortie; fi
et mettre à la place:  SV_DISK=$1; VMNT=$1;. vmount $VMNT; if [[ $? != 0 ]]; then csortie; else SV_DISK=$VMNT; fi

ntfsrst
Modifer la séquence à partir de la ligne 80:
time ntfsclone -rO  /dev/$RDDEV   /media/$SV_DISK/SV_$OU_DISK/$svwdisk

svrc=$?

par:
time ntfsclone -rO  /dev/$RDDEV   /media/$SV_DISK/SV_$OU_DISK/$svwdisk
svrc=$?
ntfsfix /dev/$RDDEV            # Provoque chkdsk au redémarrage de Windows

      Dans le paragraphe "La sauvegarde" du chapitre "UTILISATION" du sujet, ne plus tenir compte de la phrase:

- Juste avant de quitter Windows, faire: "Explorateur Windows(choix C:)\Propriétés[Outils]: Vérification des erreurs{Vérifier maintenant…}"

Le but de cette "directive" est de provoquer lors d'une restauration du volume système C:, l'exécution de chkdsk au redémarrage de Windows. Ceci est est assuré par l'ajout de la commande ntfsfix dans ntfsrst comme indiqué ci-dessus.

Hors ligne