✎ hubic [Wiki ubuntu-fr]

Vous affichez une ancienne révision du document ! Si vous l'enregistrez, vous créerez une nouvelle version avec ce contenu.

{{tag>Precise Quantal BROUILLON}}
----
 
====== hubiC ======
 
hubiC ([[https://www.hubic.com/]]) est le service de stockage Cloud de OVH.

OVH met à la disposition des utilisateurs différents logiciels clients pour hubiC, dont un pour Linux.

<note important>OVH a passé sont infrastructure de WebDav à "Swift". L'établissement d'une connexion telle que décrite sur cette page n'est donc plus possible. (cf. [[http://forum.ovh.com/showpost.php?p=510840&postcount=6|Client(s) WebDAV: la fin?]])</note>
<note important>OVH a annoncé le 18 octobre 2013 la mise à disposition d'un nouveau client Linux en ligne de commande.
Annonce sur le forum officiel Hubic : [[https://forums.hubic.com/showthread.php?230-hubic-Linux-sortie-de-la-version-b%EAta|hubic Linux: sortie de la version bêta ]])</note>

===== Connexion avec le client hubiC fourni par OVH ====
==== Pré-requis ====
 
  * Disposer des [[:sudo|droits d'administration]].
  * Disposer d'une connexion à Internet configurée et activée.
    
==== Installation ====
 
Installation manuelle :

Télécharger, décompresser dans /opt l'archive disponible sur https://hubic.labs.ovh.com/hubic/hubiC-browser-LATEST.tar.gz :

<code>
cd /tmp

wget https://hubic.labs.ovh.com/hubic/hubiC-browser-LATEST.tar.gz

sudo tar xvfz hubiC-browser-LATEST.tar.gz -C /opt
</code>

Editer le fichier hubiC-browser :

<code>
gksudo gedit /opt/hubiC-browser/hubiC-browser
</code>

Et remplacer sont contenu par les instructions suivantes :

<code>
#!/bin/sh
readlinkOutput=`readlink $0`
if [ "${readlinkOutput}x" = "x" ]; then
dirname=`dirname ${readlinkOutput}`
else
dirname=`dirname $readlinkOutput`
fi
appname=`basename $0`
tmp="${dirname#?}"
if [ "${dirname%$tmp}" != "/" ]; then
dirname=$PWD/$dirname
fi
LD_LIBRARY_PATH=$dirname/.lib
export LD_LIBRARY_PATH
$dirname/.hubiC-browser-bin
</code>

Créer un lien symbolique sur le script dans /usr/bin :

<code>
sudo ln -s /opt/hubiC-browser/hubiC-browser /usr/bin/hubiC-browser
</code>

Créer et éditer le fichier lanceur :

<code>
gksudo gedit /usr/share/applications/hubiC-browser.desktop
</code>

Le contenu doit être le suivant :

<code>
[Desktop Entry]
Version=1.0
Type=Application
Terminal=false
Categories=GNOME;GTK;
Exec=hubiC-browser
Name=hubiC
Comment=Le navigateur de Fichier hubiC
Icon=/usr/share/icons/hubiclogo.svg
</code>

Dernière étape, télécharger l'icône du lanceur :

<code>
cd /usr/share/icons

sudo wget http://www.le-libriste.fr/hubiclogo.svg
</code>

Installation automatique :
 
==== Utilisation ====
 
Lancez l'application via le [[:unity#tableau_de_bord_dash|dash]] (Ubuntu 11.04 et ultérieures) ou via le [[:terminal]] (toutes versions d'Ubuntu) avec la [[:commande_shell|commande]] suivante :
<code>hubiC-browser</code>
 
==== Désinstallation ====

Désinstallation manuelle :
 
Pour supprimer cette application, il suffit de procéder

* à la suppression de la directory /opt/hubiC-browser ;

* à la suppression du lien symbolique /usr/bin/hubiC-browser ;

* à la suppression du lanceur /usr/share/applications/hubiC-browser.desktop.

===== Connexion en webdav =====

La connexion webdav est un peu plus complexe à mettre en œuvre mais fonctionne parfaitement avec Quantal à la date du 1er mai 2013.

<note warning>Cette manipulation fonctionne parfaitement ... tant que l'on ne se déconnecte pas trop longtemps (mise à jour quotidienne ?). II est donc nécessaire de récupérer manuellement des identifiants. Le tutoriel vous propose de passer par un lanceur qu'il faudra malheureusement activer à deux reprises.</note>

==== Création d'un compte hubiC ====

Commencer par créer un compte hubiC sur le [[http://www.ovh.fr/hubiC/|site]] du fournisseur. Bien noter ses identifiants (un identifiant et un mot de passe) qui seront dénommés "identifiants hubiC" dans la suite du tuto.

==== Récupération des identifiants webdav ====
Les identifiants de connexion web ne suffisent pas pour se connecter. Il est nécessaire de récupérer des identifiants spécifiques. Plusieurs scripts sont disponibles sur internet, qui fonctionnent plus ou moins bien selon les configurations. Le script suivant, en python, a bien fonctionné sur une configuration Quetzal .
<note>La source de ce script, récupéré sur internet, a été perdue par le rédacteur de cette partie du tutoriel. Si le créateur du script reconnaît son œuvre, qu'il reçoive immédiatement toutes les excuses qui lui sont dues et soit convaincu qu'aucune mauvaise manière ne cherche à lui être faite. Si un lecteur reconnaît le script, merci à lui de bien vouloir modifier la page pour citer l'auteur.</note>

<note warning>Cette partie de la manipulation proposée est celle qui est la moins sécurisée puisqu'elle nécessite que soient saisis en clair (en lignes 79 et 80 du script python) les identifiants de connexion à Hubic. Pour un ordinateur personnel aux profils à usage unique (pas aux profils partagés) sur ordinateur personnel dont la partition /home/utilisateur est cryptée, protégé par mot de passe, le risque est limité d'autant qu'il est proposé un peu plus loin dans le tutoriel de crypter les données sauvegardées sur Hubic par encfs. 
Il faut mesurer le risque au regard de ses propres pratiques et savoir que toute personne malveillante ou imprudente qui entrerait en possession de ces identifiants pourrait donc accéder à l'espace Hubic, éventuellement copier ou effacer les données stockées ... mais pas les lire si elles sont cryptées par encfs ainsi qu'il est proposé de le faire (à la condition que le mot de passe de cryptage soit différent du mot de passe Hubic, évidement).</note>

Le texte du script //webdav_hubic_credentials.py// à copier/coller dans un fichier texte (par exemple avec [[gedit|gedit]] : copier-coller le texte intégral sans ajout puis sauvegarder par control-S) :

<file python webdav_hubic_credentials.py>
#!/usr/bin/python
# -*- coding: utf-8 -*-
# Renvoie les identifiants de connexion au webdav Hubic à partir des identifiants web (saisis en dur !!!)

import httplib, urllib

class config:
    ovh_host = "ws.ovh.com"

def get_webdav_info(login, password):
    
    ws_info={}
    null = None

# Log into CloudNAS with nasLogin and retrieve a session ID
    print 'Logging into CloudNAS to retrieve a session ID...'
    params = 'session=&params={"email":"%s","password":"%s"}' % (urllib.quote(login), urllib.quote(password))
    headers = {"Content-type": 'application/x-www-form-urlencoded',
               "User-Agent": 'hubiC/0.4.8 beta (Windows NT 6.1; fr_FR)'}
    conn = httplib.HTTPSConnection(config.ovh_host)
    conn.request("POST", "/cloudnas/r3/ws.dispatcher/nasLogin", params, headers)
    resp = conn.getresponse()
    s = resp.status
    r = resp.reason
    data = resp.read()
    try:
        d = eval(data)
        sid = d['answer']['id']
    except KeyError:
        return ws_info
    finally:
        conn.close()
    print '# SID:', sid
    
    # POST on getNas using session ID to get URL
    print 'Retrieving user-specific URL for WebDAV...'
    params = 'session=%s' % sid
    conn = httplib.HTTPSConnection(config.ovh_host)
    conn.request("POST", "/cloudnas/r3/ws.dispatcher/getNas", params, headers)
    resp = conn.getresponse()
    s = resp.status
    r = resp.reason
    data = resp.read()
    try:
        d = eval(data)
        ws_info['url'] = d['answer'][0]['url']
    except KeyError :
        return ws_info
    finally:
        conn.close()
    print '# URL:', ws_info['url']

# POST on getCredentials using session ID to get credentials
    print 'Retrieving user-specific credentials for WebDAV...'
    params = 'session=%s' % sid
    conn = httplib.HTTPSConnection(config.ovh_host)
    conn.request("POST", "/cloudnas/r3/ws.dispatcher/getCredentials", params, headers)
    resp = conn.getresponse()
    s = resp.status
    r = resp.reason
    data = resp.read()
    try:
        d = eval(data)
        ws_info['login'] = d['answer']['username']
        ws_info['passwd'] = d['answer']['secret']
    except KeyError:
        return ws_info
    finally:
        conn.close()
    print '# Ok'

return ws_info

if __name__ == '__main__':
    import sys
    import getpass
    import os.path

login = 'identifiant_Hubic'
    password = 'mot_de_passe_Hubic'

ws_info = get_webdav_info(login, password)
    print '''

URL: %(url)s
      login: %(login)s
   password: %(passwd)s

''' % ws_info
</file>

Il est ensuite nécessaire de modifier les lignes 79 et 80 pour y insérer les identifiants Hubic (substituer les identifiants personnalisés en respectant les apostrophes) :

<code>
 login = 'identifiant_Hubic'
 password = 'mot_de_passe_Hubic'
</code>
Rendre le fichier [[http://doc.ubuntu-fr.org/permissions#en_ligne_de_commande1|exécutable]] et le lancer :

<code>
usr@machine:~$ chmod +x hubic-webdav-credentials.txt
usr@machine:~$ ./hubic-webdav-credentials.txt
</code>

Le programme python va se connecter au serveur OVH d'hubiC et renvoyer les éléments suivants :

<code>
Logging into CloudNAS to retrieve a session ID...
# SID: classic/xx0000-ovh.xxxxxx000000xxx0x00xxxx000xxxxx0x
Retrieving user-specific URL for WebDAV...
# URL: https://xx0000000x000000xxxxxx0000x0xx0x0.wd.hubic.ovh.net
 
Retrieving user-specific credentials for WebDAV...
# Ok

URL: https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net
 login: xXXXXxxxX000xXXxxXXXXXX000000xxxxXXXXXXX000xxxxxXXXXXXXXXXXXXXxxxxxxx000000xxxxxXXXxxxXX0xX
 password: x000000xxxxxxxxxxxx000xxxxxxx000x 
</code>

Il convient de relever les éléments suivants, appelés //identifiants webdav// dans la suite du tuto. Attention, la suite de lettre et de chiffres est assez indigeste et doit être reproduite avec précision :

* l'adresse https (URL) au format : https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net
  * l'identifiant (login) au format : xXXXXxxxX000xXXxxXXXXXX000000xxxxXXXXXXX000xxxxxXXXXXXXXXXXXXXxxxxxxx000000xxxxxXXXxxxXX0xX
  * le mot de passe (password) au format : x000000xxxxxxxxxxxx000xxxxxxx000x

==== Installation de davfs2 ====

S'il n'est pas présent sur le système, installer [[:tutoriel:comment_installer_un_paquet|davfs2]]

<code>
usr@machine:~$ sudo apt-get install davfs2
</code>

==== Installation du partage ====

<note-tip>Pour tester le système en "root":
	* créer un point de montage : 
<code>
usr@machine:~$ mkdir /media/Montage_Hubic
</code>
	* monter le partage de fichier :
<code>
usr@machine:~$ mount.davfs https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net /media/Montage_Hubic
</code>
	
Et là tout devrait fonctionner en lançant nautilus en superutilisateur (gksudo nautilus) -> apparition d'un nouveau répertoire etc.
</note>

=== Installation du partage en "userspace" ===

Cette installation sera ainsi accessible sans droits superutilisateurs ce qui est plus pratique et, semble-t-il, plus sûr :

== Modification des options de davfs2 ==
<code>
usr@machine:~$ sudo dpkg-reconfigure davfs2
</code>

et répondre "oui" à la question "Autoriser les utilisateurs non privilégiés à monter les ressources WebDAV ?" (en déplaçant la surbrillance rouge avec la flèche du clavier puis en cliquant sur entrée).

== Création d'un point de montage ==

Il s'agit de créer un répertoire qui sera relié au partage, c'est à dire le répertoire dans lequel apparaîtrons les données sauvegardées dans le cloud, dans [[nautilus|Nautilus]] ou en ligne de commande par exemple. Le choix de ce répertoire et de son positionnement dans l'arborescence est libre, sous réserve qu'il se trouve dan sle répertoire personnel de l'utilisateur (/home/utilisateur/). Dans le cas d'espèce ce sera /home/utilisateur/Documents/Hubic/Montage_Hubic

1. Création du répertoire 
<code>
usr@machine:~$ mkdir $HOME/Documents/Hubic/Montage_Hubic
</code>

2. Création d'une copie de sauvegarde du fichier /etc/fstab 
<code>
usr@machine:~$ sudo cp /etc/fstab /etc/fstab.anc
</code>
En cas de problème de montage des disques, il sera ainsi possible de restaurer la configuration d'origine.

3. Ajout de lignes dans /etc/fstab
  
Ajout des lignes suivantes dans fstab (idéalement en fin de fichier pour éviter des suppressions malencontreuses), par exemple avec gedit en mode superutilisateur :

<box 90% round |fstab>
<code>
# Montage WebDav Hubic
https://xxxxxxxxx000000xxxxxxxxx000x00xx0x0.wd.hubic.ovh.net /home/utilisateur/Hubic/Montage_Hubic davfs rw,user,noauto 0 0
</code>
</box>

== Ajout de l'utilisateur courant au groupe davfs2 ==

<code>
usr@machine:~$ sudo adduser $USER davfs2
</code>
== Création du répertoire caché .davfs2 si nécessaire ==

Si le répertoire caché .davfs2 n'existe pas dans le répertoire personnel, le créer :
<code>
usr@machine:~$ mkdir $HOME/.davfs2
</code>
Ensuite, copier dans ce nouveau répertoire les fichiers //secrets// et //dav2fs.conf"// depuis le répertoire /etc/dav2fs et rendre l'utilisateur courant propriétaire de //secrets//. Si le répertoire .davfs2 est préexistant, vérifier que ces fichiers sont présents, sinon les copier également :
<code>
usr@machine:~$ cp /etc/davfs2/davfs2.conf ~/.davfs2
usr@machine:~$ sudo cp /etc/davfs2/secrets ~/.davfs2
usr@machine:~$ sudo chown $USER ~/.davfs2/secrets
</code>

== Modification du fichier $HOME/.davfs2/secrets ==

Modifier le fichier //$HOME/.davfs2/secrets// en y ajoutant les lignes suivantes :
<box 90% round |$HOME/.davfs2/secrets>
<box 90% round> # Accès Hubic</box>
<box 90% round>#--------------</box>
<box 90% round>#</box>
<box 90% round># mise à jour du : [...]</box>
<box 90% round>/home/utilisateur/Hubic/Montage_Hubic	identifiant_webdav	mot_de_passe_webdav</box>
</box>
Soit quelque chose qui ressemble à cela :
<box 90% round |$HOME/.davfs2/secrets>
<box 90% round># Accès Hubic</box>
<box 90% round>#--------------</box>
<box 90% round>#</box>
<box 90% round># mise à jour du : dimanche 16 juin 2013, 12:50:09 (UTC+0200)</box>
<box 90% round>/home/utilisateur/Hubic/Montage_Hubic xXXXXxxxX000xXXxxXXXXXX000000xxxxXXXXXXX000xxxxxXXXXXXXXXXXXXXxxxxxxx000000xxxxxXXXxxxXX0xX x000000xxxxxxxxxxxx000xxxxxxx000x</box>
</box>
<note important>La présence des lignes de commentaire commençant par "#" n'est évidement pas nécessaire. Toutefois, dans la suite du tutoriel il est supposé qu'il existe une ligne commençant par "# mise à" qui sera mise à jour à chaque modification (traçabilité) et dont l'existence sera testée et cherchée.</note>
== Modification du fichier $HOME/.davfs2/davfs2.conf ==
Dans le tuto sur davfs2, il est conseillé de modifier également le fichier davfs2.conf en ajoutant (ou décommentant) la ligne suivante :
<box 90% round |$HOME/.davfs2/davfs2.conf>
use_locks 0
</box>

À la lecture du contenu de davfs2.conf, il est apparu une ligne commentée ainsi libellée
<box 90% round |$HOME/.davfs2/davfs2.conf>
#secrets ~/.davfs2/secrets # user config file only
</box>

Elle a donc été décommentée, ça semble logique :
<box 90% round |$HOME/.davfs2/davfs2.conf>
secrets ~/.davfs2/secrets # user config file only
</box>

Ça y est, ça fonctionne. Il est désormais possible de monter et démonter à volonté l'espace de stockage dans Nautilus ou bien naviguer en ligne de commande ou par tout autre moyen.
<note tip>En cas de connexion directe à hubiC par internet, ne pas oublier de démonter la partition virtuelle (dans Nautilus, clic droit sur l'emplacement).</note>
==== Mise à jour des identifiants webdav ====

À ce stade du tutoriel, une liaison directe webdav avec l'espace de stockage distant Hubic a été créée. Elle est accessible dans Nautilus, un nouveau périphérique apparaît dans la fenêtre de gauche de Nautilus. Dans l'exemple donné ce périphérique s'appelle //Montage_Hubic// et s'il n'est pas monté automatiquement à l'ouverture de Nautilus, il peut l'être par simple clic sur son nom.
Malheureusement au bout de quelques temps (demain par exemple), ce bel édifice se lézardera : les identifiants webdav sont modifiés régulièrement par Hubic (une fois par jour ?) et le montage ne peut plus se faire.
Comment résoudre cette difficulté ? Deux solutions sont proposées :
  - Manuelle : lancement de //webdav_hubic_credentials.py//, récupération manuelle des identifiants webdav et modification manuelle du fichier //secrets// selon la méthode expliquée ci-dessus. Lors de la nouvelle tentative de connexion dans Nautilus, tout fonctionne bien à nouveau.
  - Par simple clic : création d'un script bash appelé par un lanceur qui effectuera l'opération de mise à jour et de remplacement des identifiants webdav.

=== Création du script de mise à jour des identifiants webdav ===

Deux scripts seront nécessaires pour réaliser cette opération. Il est proposé de les stocker dans un nouveau répertoire à créer dans //$HOME/.davfs2/montage_auto///. De nombreux ubunteros préfèrent utiliser un répertoire //Scripts// dédié, à chacun sa méthode.

Le nouveau répertoire est ainsi créé :
<code>
usr@machine:~$ mkdir $HOME/.davfs2/montage_auto
</code>

== Opération préalable ==
Le script de mise à jour et les scripts de montage du répertoire crypté ont été conçus pour une machine disposant dans un répertoire dédié de scripts divers de conception personnelle dont l'un est destiné à éviter d'utiliser des noms de fichiers déjà existant. Les scripts utilisés pour la connexion en webdav font appel à ce script, il est donc proposé d'ajouter ce script dans le répertoire de webdav sauf à devoir revoir la conception des scripts proposés sur cette page. Ce script, dénommé //fichier_unique.sh// se contente d'indiquer si un nom de fichier est utilisé dans le répertoire courant. Il est à copier tel quel dans //$HOME/.davfs2/montage_auto/// sous le nom //fichier_unique.sh//. Ne pas oublier de le rendre exécutable.

<file bash fichier_unique.sh>
#!/bin/bash
#
# Création : 7 avril 2013
#	Version : 2.0 - 18 mai 2013
#
# 
# Test du nom du fichier de sortie, on incrémente le compteur si le nom est déjà utilisé
# Renvoie un nouveau nom incrémenté d'une valeur de compteur si le fichier existe déjà,
# nom inchangé sinon
# Options :
#		-e : extension du nom de fichier à tester (aucune en cas d'omission)
#		-d : chemin du répertoire de test (répertoire courant en cas d'omission)
#		-c : initialisation de la valeur du compteur, 0 si omis
#		-l : nombre minimal de chiffres utilisés pour le nom du compteur, 2 par défaut
#		-m : motif séparant le compteur du nom de fichier, "_" par défaut
#		-n : nom de fichier à tester
#		-r : le nom de fichier à tester est un chemin, ajouter / à la liste des caractères autorisés
#		-x : absence de recherche automatique de l'extension si omise
#		-z : aucun motif de séparation du nom de fichier et du compteur (annule l'option -m et permet d'éviter l'usage du motif par défaut)
#
#	Syntaxe :
#			fichier_unique.sh NOM_TESTE [option] [Option]...
#			fichier_unique.sh [option] [Option]... NOM_TESTE
#			fichier_unique.sh [option] [Option]...
#

if [[ "$1" == "-h" ]] ||  [[ "$1" == "-H" ]] # 000

#---------------------------------- Aide ------------------------------------------------
		then
			echo "# Création : 7 avril 2013"
			echo "# Version : 2.0 - 18 mai 2013"
			echo "# Nom : nom_de_fichier_unique.sh"
			echo "# Test du nom du fichier de sortie, on incrémente le compteur si le nom est déjà utilisé"
			echo "# Renvoie un nouveau nom incrémenté d'une valeur de compteur si le fichier existe déjà,"
			echo "# nom inchangé sinon"
			echo "# Options :"
			echo "#		-c : initialisation de la valeur du compteur, 0 si omis"
			echo "#		-d : chemin du répertoire de test (répertoire courant en cas d'omission)"
			echo "#		-e : extension du nom de fichier à tester (aucune en cas d'omission)"
			echo "#		-h, -H : affichage de l'aide (si passé en premier paramètre)"
			echo "#		-l : nombre minimal de chiffres utilisés pour le nom du compteur, 2 par défaut"
			echo "#		-m : motif séparant le compteur du nom de fichier, "_" par défaut"
			echo "#		-n : nom de fichier à tester"
			echo "#		-r : le nom de fichier à tester est un chemin, ajouter / à la liste des caractères autorisés"
			echo "#   -x : absence de test sur l'extension si omise"
			echo "#		-z : aucun motif de séparation du nom de fichier et du compteur (annule l'option -m et permet d'éviter l'usage du motif par défaut)"

#---------------------------------- Corps du programme -----------------------------------
		else																			# 000
	
			if [[ -n "$1" ]] 		#		001
				#--------- En cas d'absence de paramètre, on ne fera pas tourner la procédure.
				then

# -------- initialisation des valeurs par défaut
 					chemin=""
					compteur=-1
					le_motif="_"
					longueur_compteur=2
					extension=""
					repertoire=false

if [[ "$#" > "1" ]]	# S'il n'y a qu'un seul paramètre, c'est forcément un nom de fichier
															# donc pas nécessaire de rechercher les options

#--------- Il y a plusieurs paramètres, initialisation des paramètres
						then		# 0011

nb_var=$#
							i=1
							motif="^[-][a-zA-Z]$" # regex : un tiret suivi d'une lettre -> une option
				
							#-------- Recherche du nom de fichier
										
							if [[ !("$1" =~ $motif) ]] 
																					
								then			#		00111		si le premier paramètre n'est pas une option, 
													#						c'est un nom de fichier	
									nom=$1
									let "i=$i + 1"  # On incrémente au deuxième paramètre qui doit être une option
								else 			#		00111		Vérification de la présence d'un nom de fichier
													#						en fin de saisie (On considère qu'un nom saisi en début
													#						de saisie a priorité sur une saisie en fin
									derniere_valeur=$(eval echo "\$$nb_var")
									let "j=$nb_var - 1"
									avant_derniere_valeur=$(eval echo "\$$j")
									motif="^[-][cdelmn]$"  	# Motif de regex pour tester la présence d'une option
																					# qui nécessite un paramètre
									motif2="^[-][xz]$"	# Motif de regex pour tester la présence d'une option qui 
																			# ne nécessite pas de paramètre

if [[ !("$avant_derniere_valeur" =~ $motif) ]] || [[ !("$derniere_valeur" =~ $motif2) ]]
									# Si le dernier paramètre n'est ni -x, ni -z et que l'avant-dernier n'est 
									# pas une option nécessitant un paramètre (-c -d -e -l -m -n), alors le
									# dernier paramètre est un nom de fichier
										then		#		001111
											nom=$derniere_valeur
									fi				#		001111
								fi # 					00111

#-------- Récupération des options
							while [[ "$i" < "$nb_var" ]] # On va incrémenter de 2 en 2 les couples 
																						# option / valeur option
								do
									val="echo \"$*\" | cut -d\" \" -f$i" 
																# Attention à ne pas oublier les guillemets pour $*, sinon
																# même risque qu'avec les variables $1, $3, etc.
																# je n'utilise pas les variables $1, $3 etc car eval echo "$i"
																# quand $i vaut "-e" ou "-n" ne parvient pas à afficher la 
																# valeur de $i considérée comme un paramètre de echo
									option=$(eval $val)

case $option in
													# ------------------------------------------------------------
										-c )	#	Compteur
												let "i=$i + 1"  # incrémentation d'une unité pour atteindre le 
																			#	paramètre de l'option
												val="echo \"$*\" | cut -d\" \" -f$i" 
												valeur_option=$(eval "$val")	
												motif="^[0-9]*$" # regex : un nombre entier positif
									
												if [[ "$valeur_option" =~ $motif ]]  # 004  # Paramètre numérique
													then
														let "compteur=$valeur_option - 1" 	# on enlève 1 pour retrouver la 
												fi															# valeur initiale à la 
																												# première incrémentation
												;;

# ------------------------------------------------------------
										-d )	# Chemin
												let "i=$i + 1"  # incrémentation d'une unité pour atteindre le 
																				#	paramètre de l'option
												val="echo \"$*\" | cut -d\" \" -f$i" 
												valeur_option=$(eval "$val")
												motif="/$" # regex : chaine terminée par "/"

if [[ "$valeur_option" =~ $motif ]]  #   Le chemin se termine par "/"
													then				#		0021
														chemin="$valeur_option"
													else 	# Si non, on ajoute "/"  0021
														chemin="$valeur_option/"
												fi						#  	0021

motif="^~*[a-zA-Z0-9/._\-]+$" 	# test de la conformité du format du
																												# chemin, espaces non acceptés
												if [[ !("$chemin" =~ $motif) ]]
													then
														chemin=""		# Si le chemin n'est pas conforme, on l'élimine
													fi
											;;

# ------------------------------------------------------------
										"-e" )	#	extension
												let "i=$i + 1"  # incrémentation d'une unité pour atteindre le 
																				#	paramètre de l'option
												val="echo \"$*\" | cut -d\" \" -f$i" 
												valeur_option=$(eval "$val")
												motif="^[.]" # regex : un point

if [[ "$valeur_option" =~ $motif ]]  #   L'extension commence par "."
													then				#		0022
														extension="$valeur_option"	
													else				#		0022
														extension=".$valeur_option"
												fi
											;;

# ------------------------------------------------------------
										"-l" )  # Nb minimal de chiffres pour le compteur
												let "i=$i + 1"  # incrémentation d'une unité pour atteindre le 
																				#	paramètre de l'option
												val="echo \"$*\" | cut -d\" \" -f$i" 
												valeur_option=$(eval "$val")
												longueur_compteur=$valeur_option
											;;

# ------------------------------------------------------------
										"-m" )   # Motif utilisé pour séparer le nom du fichier du compteur
												let "i=$i + 1"  # incrémentation d'une unité pour atteindre le 
																				#	paramètre de l'option
												val="echo \"$*\" | cut -d\" \" -f$i" 
												valeur_option=$(eval "$val")
												motif="^[a-zA-Z0-9._\-]+$"	# C'est le motif de la regex !
													#		On teste la conformité du nom de fichier aux normes Posix, soit
													#		26×2 lettres de l'alphabet, aux 10 chiffres et aux 3 caractères
													# 	 ".", "-" et "_". Si ce n'est pas le cas, motif par défaut maintenu
												if [[ ("$valeur_option" =~ $motif) ]]
													then
														le_motif=$valeur_option
												fi

;;

# ------------------------------------------------------------
										-n )	#	nom
												let "i=$i + 1"  # incrémentation d'une unité pour atteindre le 
																				#	paramètre de l'option
												val="echo \"$*\" | cut -d\" \" -f$i" 
												valeur_option=$(eval "$val")
												nom=$valeur_option
												;;

# ------------------------------------------------------------
											"-r" ) 	# Le fichier à tester est un répertoire, inclure / dans les caractères autorisés pour le nom
															repertoire=true															
														;;
													
													# ------------------------------------------------------------
										-x )		# Blocage de la vérification automatique de l'extension
														# aucune action mais permet d'éviter de chercher un paramètre
														# qui n'a pas à être saisi avec cette option
												;;

# ------------------------------------------------------------
										"-z" )	# Absence de motif de séparation nom fichier / compteur
														# aucune action mais permet d'éviter de chercher un paramètre
														# qui n'a pas à être saisi avec cette option
											;;

# ------------------------------------------------------------
										* ) 		# sinon, on saute le parmètre & on passe au suivant
												let "i=$i + 1"  # incrémentation d'une unité pour atteindre le 
																				#	paramètre de l'option

esac
									# ---------------------------------------------------------------------

let "i=$i + 1"
								done

# ---------- Si l'option -z est passée, aucun motif de séparation n'est retenu,   
								#							même s'il a été saisi (faut être cohérent)
								if [[ $(echo $* | grep "\-z") != "" ]] 
									then
										le_motif=""
								fi

# --------- S'il n'y a qu'un seul paramètre, il s'agit d'un nom de fichier ------
						else 	# 0011  
							nom=$1

fi			# 0011

# ------- Vérification de l'extension (quel que soit le nb d'options passées ou pas 
					if [[ $(echo $* | grep "\-x") == "" ]] && [[ $(echo $* | grep "\-e") == "" ]]
								# En l'absence d'extension -e saisie en option et de blocage par l'option -x
								#	je recherche la présence d'une extension en fin de nom de fichier
							then		#		0012
								motif="(\.[a-zA-Z0-9]{3}[a-zA-Z0-9]?)$" # se termine par un point suivi de 
																												# 3 ou 4 caractères
								if [[ ("$nom" =~ $motif) ]]
									then			# 00121		Le nom du fichier se termine par une extension
										longueur=$(echo ${#nom})
										let  "longueur=$longueur - 4"

if [[ ${nom:$longueur:1} == "." ]] 
											then		# 	001211
												extension=${nom:$longueur:4}  # j'affecte l'extension à sa variable
												nom=${nom:0:$longueur}

else		# 	001211
												let  "longueur=$longueur - 1"
												extension=${nom:$longueur:5}  # j'affecte l'extension à sa variable
												nom=${nom:0:$longueur}
										fi				# 	001211

fi				# 00121

fi			#		0012

# ------ Conformité du nom de fichier ------------------------------------------------- 
				if $repertoire 
					then
						motif="^[a-zA-Z0-9._\/\-]+$"	# c'est un répertoire
					else
						motif="^[a-zA-Z0-9._\-]+$"
				fi

nom_complet=$nom$extension

if [[ ("$nom_complet" =~ $motif) ]]
				#		On teste tout de même la conformité du nom de fichier aux normes Posix, soit
				#		26×2 lettres de l'alphabet, aux 10 chiffres et aux 3 caractères . - et _ 
				# 	et si ce n'est pas le cas, aucun retour
					then 	# 		0013
								nom_final=$chemin$nom$extension

# ---------- Test du nom de fichier ----------------------------------------
								while [ -e "$nom_final" ]		#	005
									do		# On incrémente le compteur tant qu'un nom de fichier non utilisé 
												# n'est pas trouvé
										let "compteur=$compteur + 1"
										le_compteur=$(nombre_a_n_chiffres.sh $compteur -l $longueur_compteur)
											# Nom complet non utilisé du fichier 
										nom_final="$chemin$nom$le_motif$le_compteur$extension" 
									done										#	005
								
								# ----------- Restitution du nom de fichier - C'est fini --------------------
								echo "$nom_final"

fi		#		0013

fi				# 001

fi					#	000

exit 0;
</file>
== Le script de connexion au webdav ==

Déplacer //webdav_hubic_credentials.py// dans le nouveau répertoire //$HOME/.davfs2/montage_auto///.
<code>
usr@machine:~$ mv $HOME/repertoire/webdav_hubic_credentials.py $HOME/.davfs2/montage_auto/
</code>

Enregistrer ensuite le script bash suivant dans un fichier nommé //webdav_modifs_fichier_secrets.sh// et sauvegardé dans le répertoire //$HOME/.davfs2/montage_auto/// (par exemple copie des lignes ci-dessous dans gedit puis enregistrement par ctrl+S dans //$HOME/.davfs2/montage_auto///) :
<note important>Bien veiller à adapter le chemin de la ligne 10 //repertoire_de_montage="$HOME/Documents/Hubic/Montage_Hubic"// à la configuration retenue et remplacer ///Documents/Hubic/Montage_Hubic// par le point de montage de l'espace de stockage distant Hubic.</note>
<file bash webdav_modifs_fichier_secrets.sh>
#!/bin/bash
#
# Mise à jour des identifiants webdav de connexion automatique à Hubic
#
# Paramètres
#
	repertoire_du_fichier_du_webdav="$HOME/.davfs2/"
	fichier_des_cles=$($HOME/.davfs2/montage_auto/./fichier_unique.sh -d $repertoire_du_fichier_du_webdav -n fichier_des_cles.txt)
	fichier_du_webdav="secrets"
	repertoire_de_montage="$HOME/Documents/Hubic/Montage_Hubic"
	fichier_temporaire=$($HOME/.davfs2/montage_auto/./fichier_unique.sh -d $repertoire_du_fichier_du_webdav -n nouveau_secret.txt)
	fichier_du_webdav="secrets"

# Récupération des paramètres Hubic (changement régulier - Tous les jours ?)

$HOME/.davfs2/montage_auto/webdav_hubic-credentials_2.py > $fichier_des_cles 
	tartempion=$(cat $fichier_des_cles) # Insertion du texte du fichier dans la variable tartempion
	i=1
	val="echo \"$tartempion\" | cut -d\" \" -f1" 
	mot=$(eval $val)

# Lecture mot à mot - Recherche du mot "login"
	while [[ "$mot" != "" ]] && [[ "$mot" != "login:" ]]  
		do		#	0000
			let "i=$i + 1"
			val="echo \"$tartempion\" | cut -d\" \" -f$i" 
			mot=$(eval $val)
		done	#	0000

# Récupération du login (qui est situé juste après le mot "login")
	if [[ $mot == "login:" ]]
		then	#	0001
			let "i=$i + 1"
			val="echo \"$tartempion\" | cut -d\" \" -f$i" 
			login=$(eval $val)	
	fi			#	0001

# Je continue la lecture mot à mot - Recherche du mot "password"
	let "i=$i + 1"
	val="echo \"$tartempion\" | cut -d\" \" -f$i" 
	mot=$(eval $val)

while [[ "$mot" != "" ]] && [[ "$mot" != "password:" ]]
		do		#	0002
			let "i=$i + 1"
			val="echo \"$tartempion\" | cut -d\" \" -f$i" 
			mot=$(eval $val)
		done	#	0002

# Récupération du password (qui est situé juste après le mot "password")
	if [[ "$mot" == "password:" ]]
		then	#	0003
			let "i=$i + 1"
			val="echo \"$tartempion\" | cut -d\" \" -f$i" 
			password=$(eval $val)
	fi			#	0003

# Modification du fichier du webdav 
	cd $repertoire_du_fichier_du_webdav

# Lecture ligne à ligne à la recherche de la ligne relative au montage du webdav
	trouve=false

while read -r ligne_webdav # le -r permet d'éviter que les \ soient interprétés à la lecture
		do											#	0004
			
			if [[ $(echo $ligne_webdav | cut -d" " -f1) != "$repertoire_de_montage" ]]
				then	# 00040	Si la ligne courante n'est pas reconnue (ne concerne pas le webdav)

if [[ $(echo $ligne_webdav | cut -d" " -f1) = "#" ]] && [[ $(echo $ligne_webdav | cut -d" " -f2) = "mise" ]] && [[ $(echo $ligne_webdav | cut -d" " -f3) = "à" ]]
							then	#  000400	Insertion de la date de mise à jour
								echo "# mise à jour du : "$(date) >> $fichier_temporaire
							else 	# 000400	Sinon copie à l'identique
								echo "$ligne_webdav" >> $fichier_temporaire
						fi			#	000400

else	# 00040	Si la ligne courante est celle du webdav, insertion des nouveaux paramètres

echo "$repertoire_de_montage $login $password" >> $fichier_temporaire
					trouve=true
				fi		#	00040

done < $fichier_du_webdav	#	0004

# Si le fichier de paramétrage du webdav ne contient aucune ligne relative au montage du webdav, création de la ligne
	if [[ "$trouve" != true ]] 
		then 	#	0005
			echo "" >> $fichier_temporaire
			echo "# Accès Hubic" >> $fichier_temporaire
			echo "#--------------" >> $fichier_temporaire
			echo "#" >> $fichier_temporaire
			echo "# mise à jour du : "$(date) >> $fichier_temporaire
			echo "$repertoire_de_montage $login $password" >> $fichier_temporaire
	fi			#	0005

# Remplacement du fichier de paramétrage du webdav par le nouveau fichier
		mv "$fichier_du_webdav" "$fichier_du_webdav.anc"
		mv "$fichier_temporaire" "$fichier_du_webdav"
		chmod 600 "$fichier_du_webdav"
		rm "$fichier_des_cles"

exit 0;
</file>
Rendre exécutable le fichier nouvellement créé :
<code>
usr@machine:~$ chmod +x $HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh
</code>
Désormais tout appel à //webdav_modifs_fichier_secrets.sh// entraînera la mise à jour automatique du fichier //$HOME/.davfs2/.secrets// et permettra la connexion à l'espace de stockage distant Hubic dans Nautilus.
<code>
usr@machine:~$ $HOME/.davfs2/montage_auto/./webdav_modifs_fichier_secrets.sh
</code>

== Ajouter un message ==

Pour rendre l'opération un peu plus conviviale, surtout si le script est appelé par un lanceur ainsi qu'on le verra ci-dessous, il peut être intéressant de confirmer l'exécution du script par un petit message. Il est proposé d'utiliser [[zenity|Zenity]] pour afficher une fenêtre d'information.
pour ce faire il faut et il suffit d'insérer les lignes suivantes en fin de script bash (juste avant la ligne exit 0; qui termine le script :
<file>
zenity --info --title='Montage du dossier distant' --text="Montage du dossier distant demandé" --timeout=3
</file>
Désormais, à l’exécution du script une fenêtre surgissante indiquera que l'opération est lancée. Elle s'effacera d'elle même au bout de 3 secondes (timeout=3). 
En cas de problème avec //Zenity//, installer le paquet [[:tutoriel:comment_installer_un_paquet|zenity]] si celui-ci n'est pas encore présent sur le système (normalement c'est le cas).
<code>
usr@machine:~$ sudo apt-get install zenity
</code>
<note tip>L'affichage de la fenêtre d'information n'indique pas que le script s'est bien exécuté, elle se contente d'indiquer qu'il a été appelé.</note>

=== Création du lanceur  ===
L'étape suivante permet de créer un lanceur qui pourra être lancé d'un clic de souris dans la barre des lanceurs (Unity launcher) et assurera la mise à jour du fichier //secrets//.

== Création du fichier du lanceur ==
La création d'un lanceur se fait par copie du fichier suivant dans //$HOME/.local/share/applications// :
<file bash connect_webdav.desktop>
[Desktop Entry]
Name=Connexion webdav Hubic
GenericName=Connexion webdav Hubic
X-GNOME-FullName=Connexion webdav Hubic
Comment=Se connecter à un espace webdav Hubic
Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh
Icon=$HOME/repertoire_icones/Icone_cloud.png
Terminal=false
Type=Application
Categories=GNOME;GTK;Core;
StartupNotify=true

X-Ayatana-Desktop-Shortcuts=Se connecter à Hubic;

[Se connecter à Hubic]
Name=Se connecter à Hubic
Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh
</file>

Ce fichier doit être sauvegardé dans //$HOME/.local/share/applications// sous le nom //connect_webdav.desktop//. Le choix du nom du fichier est libre, sous la réserve qu'il se termine par //.desktop// (de façon à identifier le fichier comme lanceur). Le choix du nom doit être effectué avec soin car il sera utilisé par le moteur de recherche de Unity dans le //Dash//. Pour la suite du tutoriel on considère que le nom //connect_webdav.desktop// est utilisé.

Les éléments de personnalisation suivants peuvent être utilisés (pour davantage de précisions voir [[raccourci-lanceur|lanceur]]) :
 - Nom qui apparaît en infobulle lors du survol de l'icône par la souris : ligne 2 (à dupliquer en lignes 3 et 4)
<box 80%>
Name=Connexion webdav Hubic
</box 80%>
 - Script lancé par un clic sur l'icône : ligne 6
<box 80%>
Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh
</box>
 - Liste des options qui apparaissent après clic droit sur l'icône dans la barre des lanceurs : ligne 13
<box 80%>
X-Ayatana-Desktop-Shortcuts=Se connecter à Hubic;
</box>
Dans le cas où plusieurs options sont proposées, il est nécessaire de placer le nom de chacune des options à la suite de la formule //X-Ayatana-Desktop-Shortcuts=//, les options étant séparées par des points-virgules ";" et la liste terminée de même. L'option est reprise ensuite selon la **même** orthographe entre crochets pour fixer ses paramètres.

<box 90% round blue | Exemple : >
<box 80% >X-Ayatana-Desktop-Shortcuts=Se connecter à Hubic;Faire autre chose;</box> 
<box 80%>[Se connecter à Hubic]</box> 
<box 80%>Name=Se connecter à Hubic</box> 
<box 80%>Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh</box> 
<box 80%></box> 
<box 80%>[Faire autre chose]</box> 
<box 80%>Name=Je décide de faire autre chose</box> 
<box 80%>Exec=$HOME/.davfs2/montage_auto/autre_chose.sh</box> 
</box | Personnalisation du lanceur>

Le fichier du lanceur est donc sauvegardé dans //$HOME/.local/share/applications// sous le nom //connect_webdav.desktop//.

== Ajouter une icône ==
Ce lanceur ayant vocation à apparaître dans la barre de lanceur, il est plus esthétique de lui affecter une icône personnalisée. Totale liberté est laissée à l'ubuntero, il est conseillé une icône au format [[https://fr.wikipedia.org/wiki/Portable_Network_Graphics|png]], carrée, 128 x 128 px. 
<note tip>Une icône adaptée par coloration d'un original téléchargé [[http://www.screenfeed.fr/blog/icone-cloud-en-css-0465/|ici]] est proposée 
{{icone:icone_cloud.png?50|Icône Nuage}}</note>
Cette icône (ou une autre) doit être enregistrée sur le disque de l'utilisateur. Dans le tutoriel elle a été enregistrée dans le répertoire //$HOME/repertoire_icones/// sous le nom //Icone_cloud.png// (ligne 7 du fichier de lanceur).

Il est ensuite possible d'ajouter ce lanceur personnalisé à la barre des lanceurs :
saisie du mot "webdav" (ou autre selon le nom retenu pour le lanceur) puis, une fois l'icône apparue dans le //Dash//, de la faire glisser dans la barre des lanceurs.
 
==== Cryptage du partage ====

Les données stockées chez hubiC sont "en clair" pour l'hébergeur, elles ne sont pas non plus cryptées lorsqu'elle transitent entre l'utilisateur et le serveur. Il est possible, en utilisant la méthode indiquée à la page [[http://doc.ubuntu-fr.org/davfs2#astucenuage_et_vie_privee|davfs2]], d'utiliser [[encfs|EncFS]] pour chiffrer la partition.

=== Création du répertoire crypté ===

Si on considère que le partage Hubic a été créé dans le répertoire ///home/utilisateur/Hubic/Montage_Hubic//, un répertoire crypté pourrait être créé à l'intérieur du répertoire Hubic qui serait donc situé à l'emplacement ///home/utilisateur/Hubic/Montage_Hubic/Répertoire_crypté//. Le répertoire "en clair" pourrait être situé à l'emplacement suivant : ///home/utilisateur/Hubic/Hubic_en_clair// (c'est à dire sur le disque de l'utilisateur et non pas sur le réseau).
L'utilisateur devra donc monter son répertoire distant (automatique avec la technique proposée ci-dessus) puis monter son répertoire crypté dans ///home/utilisateur/Hubic/Hubic_en_clair//. En sauvegardant les données dans ///home/utilisateur/Hubic/Hubic_en_clair//, celles-ci seront automatiquement cryptées et transférées dans le répertoire distant.
<note important>Inconvénient :
Les données ne seront pas accessibles à partir d'un appareil (par ex. un smartphone) qui ne serait pas équipé de EncFS.</note>
<note important>Ne pas oublier
de créer une copie cryptée de la clé de cryptage EncFS avec [[ccrypt|ccrypt]]. Cf [[davfs2#renforcer_la_securite_du_chiffrement|ici]]</note>

Les instructions à passer en ligne de commande pour crypter ses données sont les suivantes :
<code>
usr@machine:~$ mkdir $HOME/Hubic/Hubic_en_clair/
usr@machine:~$ mkdir $HOME/Hubic/Montage_Hubic/Répertoire_crypte/
usr@machine:~$ encfs $HOME/Hubic/Montage_Hubic/Répertoire_crypte/ $HOME/Hubic/Hubic_en_clair/
</code>

Les deux premières lignes ne sont à saisir qu'une seule fois, lors de la création du répertoire crypté. Ensuite il suffit de monter ou de démonter le répertoire crypté lorsque vous en avez besoin :

=== Accès et verrouillage au dossier crypté ===
Pour le montage du répertoire (déjà utilisé) :
<code>
usr@machine:~$ encfs /home/utilsateur/Hubic/Montage_Hubic/Répertoire_crypté/ /home/utilsateur/Hubic/Hubic_en_clair/
</code>

Et pour le démontage :
<code>
usr@machine:~$ fusermount -u /home/utilsateur/Hubic/Hubic_en_clair/
</code>

=== Renforcement de la confidentialité : déplacement de la clé ===
Dans le schéma "classique" de encfs, le fichier permettant le déverrouillage du dossier crypté est palcé au même niveau que celui-ci, ce qui signifie, dans le cas d'un dossier distant, que ce fichier se trouve sur le serveur distant. C'est un peu ennuyeux si ce cryptage a été réalisé pour accroître la confidentialité des données vis à vis du fournisseur de stockage. Il convient donc de déplacer le fichier de déverrouillage dans un endroit sûr, d'en effectuer une copie elle-même sécurisée placée dans un autre endroit sûr (avec [[ccrypt|ccrypt]]) et d'indiquer à encfs à quel endroit se trouve ce fichier. Tout cela est clairement expliqué [[davfs2#renforcer_la_securite_du_chiffrement|ici]].
Pour la suite du tutoriel on suppose que cette clé de déverrouillage est désormais sauvegardée sur votre disque dur, dans le répertoire //$HOME/Documents/Hubic///, sous le nom //.encfs6.xml//. La commande de montage du dossier crypté devient donc :
<code>
usr@machine:~$ ENCFS6_CONFIG=$HOME/Documents/Hubic/.encfs6.xml encfs $HOME/Hubic/Montage_Hubic/Répertoire_crypté/ $HOME/Hubic/Hubic_en_clair/
</code>
La commande de démontage est sans changement.

=== Création d'un script pour monter et démonter le répertoire crypté ===
De façon à faciliter ces manipulations de montage et de démontage, il est proposé de confier ces missions à un script. Est utilisée dans ce cadre l'option //--extpass// de EncFS qui permet de récupérer le mot de passe de cryptage/décryptage en sortie d'un programme externe. Ce sont donc deux scripts qui vont être créés :
  - Un script de récupération du mot de passe ;
  - Un script de verrouillage / déverrouillage du répertoire crypté.

== Le script de récupération du mot de passe ==
Le script de récupération du mot de passe utilise [[zenity|Zenity]] qu'il faudra peut être installer. Ce script sera sauvegardé dans le répertoire //$HOME/.davfs2/montage_auto/// sous le nom //webdav_recup_mdp_cryptage.sh//.
Le script :
<file bash webdav_recup_mdp_cryptage.sh>
#!/bin/bash
#
# Récupération du mdp pour connection à l'espace sécurisé (cryptage encfs) installé sur Hubic
#
	# Se connecter à l'espace crypté

if mot_de_passe=`zenity --password --title='Connection serveur distant' --text="Saisissez votre mot de passe pour déverouiller votre espace sécurisé dans le \"nuage\" : "`
		then

if [ "$mot_de_passe" = "" ]
					then
						`zenity --error --title="Pas de saisie" --text="Aucun mot de passe saisi, connexion au webdav impossible" --timeout=6`
						exit
				fi

else
			`zenity --error --title="Annulation" --text="Annulation, connexion au webdav impossible" --timeout=6`
			exit

fi

echo $mot_de_passe

exit 0;

</file>

Ce script doit donc être téléchargé par l'utilisateur et sauvegardé dans le répertoire //$HOME/.davfs2/montage_auto/// sous le nom //webdav_recup_mdp_cryptage.sh//.

== Création du script de décryptage et de cryptage ==
La récupération du mot de passe étant organisée, il est maintenant possible de mettre en place le script qui permettra de monter et démonter les dossiers cryptés.

Le script proposé sera sauvegardé dans le répertoire //$HOME/.davfs2/montage_auto/// sous le nom //webdav_ouverture_dossier_crypte.sh//.

<file bash webdav_ouverture_dossier_crypte.sh>
#!/bin/bash
#
# Connexion et deconnexion à l'espace sécurisé (cryptage encfs) installé sur Hubic
#
# Paramètres (Attention il est impératif de saisir le "/" de fin de chemin)

chemin_complet_cle_encfs="$HOME/Documents/Hubic/.encfs6.xml"
	repertoire_de_stockage_des_donnees_cryptees="$HOME/Documents/Hubic/Montage_Hubic/Répertoire_crypte/"
	repertoire_de_stockage_des_donnees_decryptees="$HOME/Documents/Hubic/Hubic_en_clair/"
	repertoire_hubic_webdav="$HOME/Documents/Hubic/Montage_Hubic/"

# Vérifier si l'espace crypté n'est pas déjà monté

encfs_deja_monte=$(mount | grep ${repertoire_de_stockage_des_donnees_decryptees%?})

# Si déjà monté, on démonte

if [[ "$encfs_deja_monte" != "" ]]
		then
			fusermount -u "$repertoire_de_stockage_des_donnees_decryptees"
			zenity --info --title='Dossier déjà monté' --text='Les données cryptées sont déjà montées, démontage en cours' --timeout=3
			exit

else	# N'est pas déjà monté, donc il faut se connecter

# Se connecter à l'espace crypté

webdav_monte=$(mount | grep ${repertoire_hubic_webdav%?})

# Vérification du montage du dossier Hubic, s'il ne l'est pas il est illusoire de vouloir accéder à son contenu
	
			if [[ "$webdav_monte" == "" ]]
				then
					zenity --error --title='Webdav non monté' --text="Le webdav n'est pas monté, impossible par conséquent de monter le dossier crypté" --timeout=6
					exit

#	Si le dossier distant Hubic est monté, montage du dossier crypté avec indication de localisation de la clé
				else
					ENCFS6_CONFIG=$chemin_complet_cle_encfs encfs --extpass=$HOME/.davfs2/montage_auto/webdav_recup_mdp_cryptage.sh $repertoire_de_stockage_des_donnees_cryptees $repertoire_de_stockage_des_donnees_decryptees
					zenity --info --title='Montage du dossier crypté' --text="Montage du dossier crypté demandé" --timeout=3
			fi

fi

exit 0;
</file>

<note important>Attention à la syntaxe des lignes 7 à 10 qui doivent parfaitement correspondre à l'installation de chaque ubuntero.</note>

Ce script doit donc être téléchargé par l'utilisateur, modifié si nécessaire (lignes 7 à 10) et sauvegardé dans le répertoire //$HOME/.davfs2/montage_auto/// sous le nom //webdav_ouverture_dossier_crypte.sh//.

Le script permet de monter le répertoire crypté après avoir demandé le mot de passe ou, si le répertoire crypté est déjà présent, de le démonter.

== Utilisation ==
  * L'utilisation du script suppose que le webdav soit actif et monté. Si le webdav n'est pas monté, zenity affichera un avertissement qui s'effacera au bout de 6 secondes et rien ne se passera.
  * L'usage du script suppose aussi que le répertoire crypté ait d'ores et déjà été créé (voir ci-dessus pour création en mode console) et que le répertoire de montage du fichier décrypté (Montage_en_clair) existe également.
  * Pour monter le webdav, se rendre dans Nautilus après avoir lancé //webdav_modifs_fichier_secret// et monter le répertoire distant par un clic sur le périphérique. Lorsque le périphérique est monté, il est possible de lancer le script //webdav_ouverture_dossier_crypte.sh//.
  * Lors de son lancement, le script vérifie si le dossier crypté est monté ou ne l'est pas (lignes 14 à 18).
  *  Si le dossier crypté n'est pas encore monté, une première vérification est réalisée. Cette première vérification a pour objet de déterminer si le webdav Hubic est monté car s'il ne l'est pas, il n'est pas possible d'accéder aux fichiers qu'il contient. Ce contrôle est réalisé par les lignes 27 à 35.
  * Si l'espace distant est monté, alors le script de récupération du mot de passe  //webdav_recup_mdp_cryptage.sh// est appelé par EncFS (ligne 39) via l'option //--extpass//. Ce dernier ouvre une fenêtre de saisie pour le mot de passe puis, une fois celui-ci renseigné par l'utilisateur, envoie le mot de passe à EncFS qui monte le répertoire. Zenity (ligne 40) informe alors l'utilisateur que cette partie du script a été appelée (mais pas qu'elle s'st déroulée avec succès) par une fenêtre surgissante qui disparaît au bout de 3 secondes (timeout=3).
  * Si, au contraire, le dossier crypté est déjà monté, celui-ci est alors démonté (lignes 18 à 21) et l'utilisateur est informé de la tentative (mais pas de son résultat, une fois encore).

== Création du lanceur ==
Afin de rendre toutes ces manipulations le plus simple possible, il est proposé de créer un lanceur dans la barre des lanceurs, ou plus précisément d'étendre les fonctions du lanceur créé un peu plus haut pour permettre la connexion à Hubic.
Deux options sont ajoutées au lanceur, //Monter le répertoire crypté// et //Démonter le répertoire crypté//. Compte tenu du mode de fonctionnement du script //webdav_ouverture_dossier_crypte.sh// une seule option est nécessaire puisque l'appel au script monte et démonte alternativement le dossier crypté, toutefois en terme d'ergonomie la distinction peut avoir son utilité. C'est ce qui est retenu.
Le lanceur est donc ainsi modifié :
<file bash connect_webdav.desktop>
[Desktop Entry]
Name=Connexion webdav Hubic
GenericName=Connexion webdav Hubic
X-GNOME-FullName=Connexion webdav Hubic
Comment=Se connecter à un espace webdav Hubic
Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh
Icon=$HOME/repertoire_icones/Icone_cloud.png
Terminal=false
Type=Application
Categories=GNOME;GTK;Core;
StartupNotify=true
 
X-Ayatana-Desktop-Shortcuts=Se connecter à Hubic;Monter le répertoire crypté;Démonter le répertoire crypté;
 
[Se connecter à Hubic]
Name=Se connecter à Hubic
Exec=$HOME/.davfs2/montage_auto/webdav_modifs_fichier_secrets.sh

[Monter le répertoire crypté]
Name=Monter le répertoire crypté situé dans le dossier distant Hubic
Exec=$HOME/.davfs2/montage_auto/webdav_ouverture_dossier_crypte.sh

[Démonter le répertoire crypté]
Name=Démonter le répertoire crypté situé dans le dossier distant Hubic
Exec=$HOME/.davfs2/montage_auto/webdav_ouverture_dossier_crypte.sh
</file>

Ce lanceur doit donc être sauvegardé dans $HOME/.local/share/applications sous le nom connect_webdav.desktop, il prendra la place du précédent.
Sans surprise les lignes "Exec" des deux dernières options sont identiques mais c'est plus clair pour l'utilisateur.

Le lanceur doit être utilisé ainsi :
  - On commence par mettre à jour le dossier //secrets// : clic sur l'icône **Connexion webdav Hubic** dans la barre des lanceurs avec le bouton gauche de la souris ou bien clic bouton droit puis sélection de l'option **Se connecter à Hubic**;
  - Montage du dossier distant Hubic dans //Nautilus// (clic sur le nom dans la liste des périphériques);
  - Montage du répertoire crypté par clic bouton droit sur l'icône**Connexion webdav Hubic** dans la barre des lanceurs puis sur l'option **Monter le répertoire crypté**

Le répertoire distant crypté devient ainsi directement accessible dans //Nautilus//, sous la forme d'un périphérique autonome.
  * La fermeture du répertoire crypté est obtenue par un nouveau clic bouton droit sur l'icône **Connexion webdav Hubic** dans la barre des lanceurs puis sur l'option **Démonter le répertoire crypté**. Le dossier distant //Hubic// reste accessible mais pas le répertoire crypté.
===== Suppression du partage ====
Pour supprimer le compte hubiC, se référer aux conditions du fournisseur.
Pour supprimer la connexion à la plate-forme distante, il suffit de supprimer les lignes insérées dans** /etc/fstab** ou, mieux, de restaurer l'ancienen version (attention à la gestion des droits).
Pour parfaire les choses, vous pouvez aussi supprimer la ligne ajoutée au fichier  **$HOME/.davfs2/secrets**.

===== Voir aussi =====
 
  * **(fr)** [[http://www.ovh.fr/hubiC/]]
  * [[http://forum.ubuntu-fr.org/viewtopic.php?id=910111|Discussion « Installer Hubic sous ubuntu »]] sur le forum Ubuntu-fr
  * [[http://forum.ubuntu-fr.org/viewtopic.php?pid=8211801|Discussion « [Script] Client Hubic pour linux ;) »]] sur le forum Ubuntu-fr
  * [[http://forum.ubuntu-fr.org/viewtopic.php?id=920121|Discussion « installation de Hubic sur xubuntu 12.04 »]] sur le forum Ubuntu-fr
  *  [[http://doc.ubuntu-fr.org/davfs2#astucenuage_et_vie_privee|davfs2]]
  * http://doc.ubuntu-fr.org/encfs
  * **(fr)** [[http://www.protocol-hacking.org/post/2012/01/29/Hubic%2C-maintenant-vraiment-ubiquitous]]
 
----
//Contributeurs principaux : [[utilisateurs/libaud|Libaud]] Zococo.//
 
//Basé sur [[http://www.le-libriste.fr/2012/03/installer-sur-ubuntu-hubic-proposant-25-go-gratuit-sur-le-cloud/|« Installer sur Ubuntu hubiC proposant 25 Go gratuit sur le cloud »]] par Stéphane Robert.//

Merci de recopier le code ci-contre pour prouver que vous êtes humain : S Q Z K Q Merci de laisser ce champ vide :

Résumé

Note : En modifiant cette page, vous acceptez que le contenu soit placé sous les termes de la licence suivante : CC Paternité-Partage des Conditions Initiales à l'Identique 3.0 Unported