Tutoriel : Qt : Quelques fonctionnalités non-GUI

ID	Contenu
0	Jean
1	Dupont
2	25

Clé	Contenu
prenom	Jean
nom	Dupont
age	25

Clé	ID	Contenu
prenom	hacher("prenom")	Jean
nom	hacher("nom")	Dupont
age	hacher("age")	25

Avec Qt

Prêts à passer à la pratique ?

Qt gère les tables de hachage avec la classe QHash.

Pour commencer, voyons le prototype du constructeur :

QHash ()

Bon, ok, on pouvait pas faire plus simple...
Seulement, sa définition se fait un peu comme une QList (un exemple de QList ?) :

QList<QWidget*> liste; // crée une QList contenant des QWidget

Pour créer un QHash, il faut donc lui indiquer le type des valeurs qui seront stockées. Mais pas seulement ! Il faut aussi lui indiquer de quel type sera la clé ! Eh oui, on peut créer des tables de hachage dont les clés sont... n'importe quel type de variables, objets compris ! Les clés peuvent donc par exemple être des pointeurs sur des QPushButtons, ça ne posera aucun problème (eh oui, c'est ça que je vous cachais depuis tout à l'heure :-° ) !
Dans la plupart des cas, la clé reste une chaîne de caractères.

Pour créer une table de hachage, on aura donc un code ressemblant à celui-ci :

QHash<typeCle, typeValeur> table1; // clés de type typeCle, valeurs de type typeValeur
QHash<QString, int> table2; // clés de type QString, valeurs de type int
QHash<QString, QWidget*> table3; // clés de type QString, valeurs de type pointeur sur QWidget
QHash<QPushButton*, int> table4; // clés de type pointeur sur QPushButton, valeurs de type int

Ce code créera 4 tables de hachage (explications dans les commentaires).

J'imagine qu'ensuite, vous avez l'intention d'ajouter des valeurs, en supprimer, les lire, etc., n'est-ce pas ? Eh bien, il y a plusieurs manières de faire. On va commencer par... la première.

Méthode 1 : comme avec un tableau

La première méthode est de faire comme s'il s'agissait d'un simple tableau.

Dans cette méthode, nous allons considérer qu'on a affaire à un tableau classique (mais extensible quand même, vous pouvez donc ajouter une valeur). Nous allons donc utiliser l'objet suivant :

QHash<QString, int> table;

Tiens, d'ailleurs, normalement, vous devriez être capables de me dire quel type de clés et quel type de valeurs attend cette table !

Solution :

Les clés seront de type QString
Les valeurs seront de type int

Pour ajouter un item dans un tableau de ce genre, on ferait donc :

table["reponse"]=42; // la clé est "reponse", la valeur est "42".

Le code pour modifier la valeur associée à la clé "réponse" est exactement le même. Lorsqu'on modifie pour la première fois la valeur associée à une clé, on crée cet item.

Et pour supprimer un item ?

Ah ben ça... Avec cette méthode on peut pas :-° . Avec la méthode suivante, on verra ça !

Méthode 2 : avec des méthodes

Oui, je sais, le titre est un peu bizarre. Par "avec des méthodes", je veux dire "avec des fonctions contenues dans une classe".

Nous allons réutiliser notre QHash de tout à l'heure :

QHash<QString, int> table;

Il y a des méthodes pour faire ce qu'on a vu en 1, et même plus !

Ajouter un item

Nous utiliserons pour cela la méthode insert :

iterator QHash::insert ( const Key & key, const T & value )

Cette méthode prend en premier paramètre la nouvelle clé (key) et en second paramètre la nouvelle valeur (value). Notez que si l'item est déjà existant, la méthode remplacera l'ancienne valeur par la nouvelle. On utilisera donc la même méthode pour modifier cette valeur.

C'est quoi ce "iterator" que ça retourne ? Et c'est quoi ce "T" ?

Pour le "iterator", nous verrons ça après ^^ !
Et pour ce qui est du "T", il s'agit du type que vous avez défini pour les valeurs de cette table de hachage, ici "int" (QHash<QString, int> table). Il s'agit d'un template.

Donc, si vous avez bien compris, pour ajouter à notre table de hachage "table" l'item de valeur "42" et de clé "reponse", le code sera...

table.insert("reponse", 42);

Tester l'existence d'une clé

Pour vérifier si une clé existe dans une table de hachage, on utilise la méthode contains, qui prend en paramètre la clé recherchée, et renvoie true si la clé existe, sinon false.

Exemple :

if(table.contains("reponse"))
    // la clé "reponse" existe
else
    // la clé "reponse" n'existe pas

Récupérer le nombre d'items contenus dans la table de hachage

On utilise la méthode count :

int nombre=table.count();
//nombre = nombre d'items dans "table"

Récupérer une valeur

La méthode est value :

const T QHash::value ( const Key & key ) const

Cette méthode prend pour paramètre la clé (key) de la valeur qu'on cherche, et retourne la valeur. Elle s'utilise très simplement :

table.insert("reponse", 42); // pour avoir quelque chose à lire
int reponse=table.value("reponse");
// reponse = 42

Dans le cas où la clé n'existe pas, cette méthode renvoie la valeur par défaut du type de la valeur.

Gné ? o_O

En fait, c'est pas compliqué du tout : ça renvoie la valeur par défaut, celle qui est donnée à une variable qui vient d'être créée. Seulement, cette valeur est différente selon le type de valeurs que prend la table de hachage. Par exemple, pour une QString, la valeur par défaut est une chaine vide, alors que pour un int, la valeur par défaut est 0.

On peut aussi donner la valeur de retour qu'on veut dans le cas où la clé n'existe pas avec la méthode surchargée :

const T QHash::value ( const Key & key, const T & defaultValue ) const

Exactement pareil, sauf que le 2ème paramètre devient la valeur de retour par défaut. Elle peut s'utiliser comme ça :

table.insert("reponse", 42); // pour avoir quelque chose à lire
int reponse=table.value("reponse", -1);
QLabel label;
label.setText(QString::number(reponse)); // affichera 42, ou -1 si un problème est survenu.

Récupérer une clé

Je ne vais pas m'étendre sur le sujet, tout ce qui a été dit sur la récupération des valeurs est valable pour celle des clés, si ce n'est que la méthode est key et que son premier paramètre est une valeur au lieu d'une clé (en même temps, logique :-° ).

Supprimer un item

La méthode utilisée est delete :

int QHash::remove ( const Key & key )

On l'utilise donc en lui passant en paramètre la clé de l'item à supprimer. Cette méthode renvoie le nombre d'items supprimés.

Mais... Elle renvoie donc 1 si l'item a été supprimé, ou 0 si il n'existe pas, donc ! Pourquoi ne pas avoir mis de booléen ?

Eh bien, parce que... Une clé peut contenir plusieurs valeurs ! Eh oui ! Aussi bizarre que ça puisse paraître, c'est possible !

Ajouter une valeur à une clé

Pour avoir plusieurs valeurs par clé, on utilise non pas insert, mais insertMulti :

iterator QHash::insertMulti ( const Key & key, const T & value )

Cette méthode marche exactement comme insert, mais au lieu de remplacer si la valeur est déjà existante, elle "ajoute" la valeur.

Récupérer DES valeurs

Dans ce cas, value() retourne quoi ?

value retourne la dernière valeur ajoutée. Pour obtenir une liste de toutes les valeurs pour une clé donnée, on utilise values (attention au 'S' à la fin) :

QList<T> QHash::values ( const Key & key ) const

Cette méthode marche comme value, mais elle retourne une QList contenant toutes les valeurs pour la clé key.

Méthode de lecture : les itérateurs

Vous vous souvenez de cet "iterator" en retour de insert ? Le moment est venu de vous expliquer ce que c'est. Un "iterator" (in english) se traduit par un itérateur.

Alors là, on est bien avancés ! Mes pensées se résument en un mot : gné ? o_O

Pour vous définir ça, je pense que Wikipedia sera très bien :

Citation

Un itérateur est un objet qui permet de parcourir tous les éléments contenus dans un autre objet, le plus souvent un conteneur (liste, arbre, etc).

Comme il est dit dans la définition, c'est un objet à part entière. La classe qui gère ça est QHashIterator.

Voyons d'abord son constructeur :

QHashIterator::QHashIterator ( const QHash<Key, T> & hash )

Il prend donc en paramètre le QHash qu'il devra parcourir, mais devra, comme QHash, être déclaré avec un template :

QHashIterator<QString, int> iterator(table);

Le gros avantage est la possibilité de faire des tests sur les positions précédentes et suivantes :

Clé et valeur actuelle

On peut avoir la clé et la valeur actuelle en utilisant key() et value() :

// prototype de key
const Key & QHashIterator::key () const

// prototype de value()
const T & QHashIterator::value () const

Tester l'existence des items suivants/précédents

On peut vérifier l'existence d'un item suivant ou précédent respectivement avec hasNext et hasPrevious :

bool QHashIterator::hasNext () const

La méthode retourne donc un booléen (true si l'item existe, sinon false), et ne prend aucun paramètre.

Avancer/reculer la position actuelle

Pour déplacer la position actuelle de l'itérateur, on utilise next et previous :

Item QHashIterator::next ()

Donc, la méthode ne prend aucun paramètre, et retourne... un Item, qui contient la valeur et la clé de l'item sur lequel on se trouve maintenant. Ces variables s'obtiennent respectivement avec value() et key().

Item précédent/suivant

Les méthodes next() et previous() retournent un Item contenant la valeur et la clé de la nouvelle valeur, après déplacement. Avec les méthodes peekNext() et peekPrevious(), on obtient la même valeur de retour, mais sans se déplacer !

Item QHashIterator::peekNext () const

Aller au début/à la fin

Pour aller au début (avant le premier item) ou à la fin (après le dernier item), on utilise les méthodes toFront() (début) ou toBack() (fin) :

void QHashIterator::toBack ()

Rechercher vers l'avant/vers l'arrière

On peut également faire une recherche partant d'avant ou après l'item actuel avec les méthodes findNext() et findPrevious() qui prennent en paramètre la valeur à rechercher :

bool QHashIterator::findNext ( const T & value )

La méthode retourne un booléen indiquant si la valeur value a été trouvée ou non.
L'utilisation est à peine différente selon le sens de la recherche :

findNext() : vers l'avant
La recherche commence à l'item suivant l'item actuel. Si l'item est trouvé, la position courante après la fonction est juste après l'item trouvé. Sinon, la position après la fonction est après le dernier item (comme après un toBack()).
findPrevious() : vers l'arrière
La recherche commence à l'item avant l'item actuel. Si l'item est trouvé, la position courante après la fonction est juste avant l'item trouvé. Sinon, la position après la fonction est avant le premier item (comme après un toFront()).

Récupérer toutes les valeurs : foreach()

Alors là, rien de plus simple : il s'agit d'une boucle spéciale qui est exécutée pour toutes les valeurs de la table, mais qui ne permet pas de voir la clé associée.
On l'utilise ainsi :

foreach(int valeur, table)
{
    quelqueChose(valeur); // "valeur" contient la valeur actuelle
}

Eh bien voilà, normalement (enfin je l'espère), vous maîtrisez les tables de hachage !
Je ne vois pas grand chose de plus à dire à ce sujet...

Par contre, je peux vous dire que le prochain chapitre est... un TP ! Prêts ? Alors cliquez sur "suivant" !

TP : le zLogin

Présentation du sujet

Dans ce TP, nous allons créer le zLogin ! C'est un programme-serveur auquel peuvent se connecter d'autres programmes via un réseau (loopback, local, internet).

Vue d'ensemble

Son rôle est simple : un programme lui envoie un paquet en TCP, contenant un login et un mot de passe haché en MD5 (nous ne coderons pas ce programme). Le zLogin (que nous allons créer) se chargera de comparer ce mot de passe à une liste de mots de passe contenus dans un fichier, et dira au programme si le login et le mdp sont bons.

Et... Le hachage, les tables de hachage, et les ressources, elles sont où dans tout ça ?

Premièrement, pour le hachage, vous DEVREZ re-hacher le mdp envoyé, avec salage et toutes les sécurités qu'on a vues. Vous ne pensiez pas que nous allions stocker un mot de passe haché seulement en MD5, non ? Par contre, pensez bien à tenir compte du fait qu'il est déjà haché en MD5 lors de sa réception !

Ensuite, pour les tables de hachage. Vous devrez, à l'ouverture du programme, prendre tous les couples login/mdp et les stocker dans une table de hachage (clé = pseudo, valeur = mdp haché).

Et pour les ressources, on va faire simple : l'icône sera dans un fichier de ressources, si vous arrivez à faire ça, vous arriverez à tout faire.

Schéma des paquets

Vous êtes libres d'utiliser les architectures de paquets que vous voulez, mais si vous ne savez pas quoi prendre, je vous donne les structures que j'utilise :

Paquets entrants : pseudos/hashs mdp

J'utilise donc un paquet composé de 4 parties :

Une variable quint16 contenant la taille du pseudo,
Une variable QString contenant de pseudo,
Une variable quint16 contenant la taille du hash du mdp,
Une variable QByteArray contenant le hash du mdp.

paquets sortants : connexion acceptée/refusée

Cette fois, le paquet se compose d'un simple quint8. Celui-ci peut prendre différentes valeurs :

0 : Erreur indéterminée
1 : Connexion acceptée
2 : Mauvais login
3 : Mauvais mdp
4 : Erreur interne au zLogin
5 : Service indisponible

Fonctionnalités gérées par le zLogin

Voici une liste des fonctionnalités que doit avoir le zLogin. Bien sûr, rien ne vous empêche d'en rajouter :D !

Charger dans une table de hachage tous les logins/mdps au démarrage depuis un fichier (voir ce tuto d'Amnell et Shareman, impossible de se passer des fichiers dans un TP comme ça)
Communiquer en réseau, et fonctionner comme programme serveur
Pouvoir recevoir des données sur un port de votre choix (j'utiliserai le 31742)
Traiter les données reçues en les comparant avec la table de hachage générée à l'ouverture du programme
Hacher les mdps en utilisant des sels (eux mêmes hachés séparément), en utilisant les algorithmes de votre choix
Renvoyer des données pour confirmer (ou non) la connexion
Aucune fenêtre. Une icône du system tray (descendez un peu, jusqu'à croiser "system tray") sera la seule manifestation du zLogin (un petit tour dans la doc vous sera utile)
Un menu sera accessible avec l'icône system tray, il contiendra :
- Ajouter/supprimer des comptes : ouvre une boite de dialogue (voir la doc de QDialog, vous devrez créer une classe héritant de QDialog) permettant de voir les comptes créés, de les supprimer, et d'en ajouter. Quand on ajoute un compte, la liste des comptes doit être rechargée. Mais dans le cas où quelqu'un enverrait une requête à ce moment, le programme ne doit pas fournir de fausse information ! La "pause du service" doit être la plus courte possible.
- Une option désactivée par défaut, qui, si activée, lors de chaque tentative de login, affiche une bulle d'information affichant le login de la personne, et le résultat sous forme de chaîne de caractères (et non de chiffre).
- Une option "suspendre le programme" : si activée, aucune demande ne sera traitée, et le code 5 (service indisponible) sera renvoyé.
- Quitter : Je ne pense pas avoir besoin de vous décrire à quoi cette action sert :D . Pensez à faire un dialogue demandant confirmation, au lieu de quitter directement !
L'icône du system tray sera chargée depuis un fichier de ressources

Dernières recommandations

Pour commencer, 2-3 choses qui peuvent vous être utiles :

Pack d'icônes : Je vous ai préparé un petit pack d'icônes, libre à vous de les utiliser ou non. Téléchargez-le !
zLogin testeur : J'ai également fait un programme client qui vous servira à tester votre zLogin, en se connectant à une adresse et un port (que vous choisissez) avec un pseudo et un mot de passe (que vous choisissez également). Téléchargez-le !

Une partie du code : En codant le programme, j'ai remarqué qu'une grosse partie de celui-ci était composé uniquement de GUI, notamment au niveau de l'interface de gestion des comptes. Pour ceux qui le veulent seulement, et qui préfèrent se concentrer sur les nouveautés et ne pas réviser la GUI, je vous propose le code source de la gestion des comptes :

J'ai utilisé pour ça deux classes : une qui gère le dialogue de gestion des comptes en lui-même, que j'ai appelé GereComptes, et une autre qui gère le dialogue d'édition/création de comptes (celui où on rentre le login/mdp du futur utilisateur), que j'ai appelée DialSetUser.
Je vais commencer par GereComptes :

gerecomptes.h (en général, mes noms de fichiers sont entièrement en minuscules par flemme de changer celui par défaut du QtCreator :-° )

#ifndef GERECOMPTES_H
#define GERECOMPTES_H

// eh oui, il y en a pas mal
#include <QWidget>
#include <QTableView>
#include <QStandardItemModel>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QPushButton>
#include <QIcon>
#include <QHash>
#include <QHashIterator>
#include <QCloseEvent>
#include <QList>
#include <QHeaderView>
#include <QMessageBox>
#include <QFile>
#include <QTextStream>
#include <QRegExp>

#include "dialsetuser.h"

class GereComptes : public QWidget
{
Q_OBJECT

public:
    GereComptes(QHash<QString, QString> authIn);

signals:
    void fini(); // émis à la fermeture du dialogue

private slots:
    void slotAddUser();
    void slotSetUser();
    void slotDelUser();
    void slotOk();

private:
    // methodes
    void majModele(); // appelé pour ajouter dans "modele" tout ce qui est contenu dans "authTable" (appelé dans le constructeur uniquement)
    void closeEvent(QCloseEvent *event); // Pour intercepter l'évènement de fermeture

    //attributs
    QHBoxLayout *l_principal;
    QTableView *tableau; // j'utilise une architecture MV (voir tuto de M@t')
    QStandardItemModel *modele;
    QVBoxLayout *l_boutons;
    QPushButton *b_addUser;
    QPushButton *b_setUser;
    QPushButton *b_delUser;
    QPushButton *b_ok;

    QHash<QString, QString> authTable;

    bool closing;
};

#endif // GERECOMPTES_H

Rien de bien compliqué, ça reste un .h :D .

gerecomptes.cpp

#include "gerecomptes.h"

GereComptes::GereComptes(QHash<QString, QString> authIn)
{
    setWindowTitle("zLogin - gestion des comptes");
    setWindowIcon(QIcon(":/icones/prog"));
    authTable=authIn;
    closing=false;

    // GUI
    l_principal=new QHBoxLayout;
    modele=new QStandardItemModel(0, 2);
    modele->setHeaderData(0, Qt::Horizontal, "Pseudo", Qt::DisplayRole);
    modele->setHeaderData(1, Qt::Horizontal, "Hash du MDP", Qt::DisplayRole);
    tableau=new QTableView;
    tableau->setModel(modele);
    tableau->setMinimumWidth(425);
    majModele();
    l_principal->addWidget(tableau);

    l_boutons=new QVBoxLayout;
    b_addUser=new QPushButton(QIcon(":/icones/addUser"), "Créer un compte");
    l_boutons->addWidget(b_addUser);
    b_setUser=new QPushButton(QIcon(":/icones/setUser"), "Modifier le compte");
    l_boutons->addWidget(b_setUser);
    b_delUser=new QPushButton(QIcon(":/icones/delUser"), "Supprimer le compte");
    l_boutons->addWidget(b_delUser);
    b_ok=new QPushButton(QIcon(":/icones/accept"), "Ok");
    l_boutons->addWidget(b_ok);
    l_principal->addLayout(l_boutons);

    setLayout(l_principal);

    // connect
    connect(b_addUser, SIGNAL(clicked()), this, SLOT(slotAddUser()));
    connect(b_setUser, SIGNAL(clicked()), this, SLOT(slotSetUser()));
    connect(b_delUser, SIGNAL(clicked()), this, SLOT(slotDelUser()));
    connect(b_ok, SIGNAL(clicked()), this, SLOT(slotOk()));
}

void GereComptes::majModele()
{
    // assez simple : on ajoute dans le modèle tous les logins/hashs.
    QHashIterator<QString, QString> iterateur(authTable);

    while(iterateur.hasNext())
    {
        iterateur.next();
        QList<QStandardItem *> items;
        items << new QStandardItem(iterateur.key()) << new QStandardItem(iterateur.value());
        modele->appendRow(items);
    }

    tableau->resizeColumnsToContents();
}

void GereComptes::slotAddUser()
{
    // On ajoutera le nouvel utilisateur directement dans le fichier, qui devra être rechargé une fois le dialogue fermé

    QFile f_auth;
    QTextStream authStream;

    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    User::Infos infos=DialSetUser::get(); // méthode statique

    if(infos.annule)
        return;

    QHashIterator<QString, QString> iterateur(authTable);

    while(iterateur.hasNext()) // vérif que le pseudo n'est pas utilisé
    {
        iterateur.next();
        if(iterateur.key() == infos.pseudo)
        {
            QMessageBox::warning(this, "Erreur", "Le pseudo choisi est déjà utilisé.");
            return;
        }
    }

    authStream.readAll(); // aller à la fin du fichier
    authStream << infos.pseudo+';'+infos.hashmdp+'\n';

    QList<QStandardItem *> items; // ajout du nouvel utilisateur au modèle
    items << new QStandardItem(infos.pseudo) << new QStandardItem(infos.hashmdp);
    modele->appendRow(items);
    tableau->resizeColumnsToContents();

    f_auth.close();
}

void GereComptes::slotSetUser()
{
    QFile f_auth;
    QTextStream authStream;
    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    QModelIndex setIndex=tableau->selectionModel()->currentIndex();
    if(!setIndex.isValid()) // index invalide, pas de selection
    {
        QMessageBox::warning(this, "Aucune sélection", "Aucun item n'est sélectionné.");
        return;
    }

    int setRow=setIndex.row(); // récupère l'ID de la ligne sélectionnée
    QString basePseudo=modele->item(setRow, 0)->data(Qt::DisplayRole).toString(); // recup le pseudo actuel
    QString baseHash=modele->item(setRow, 1)->data(Qt::DisplayRole).toString(); // récup le hash actuel
    User::Infos infos=DialSetUser::get(basePseudo, baseHash);

    if(infos.annule) // si l'user a annulé
        return;

    if(infos.pseudo != basePseudo || infos.hashmdp != baseHash) // si il y a eu une modif
    {

        if(infos.pseudo!=basePseudo) //vérif que le pseudo est libre
        {
            QHashIterator<QString, QString> iterateur(authTable);

            while(iterateur.hasNext())
            {
                iterateur.next();
                if(iterateur.key() == infos.pseudo)
                {
                    QMessageBox::warning(this, "Erreur", "Le pseudo choisi est déjà utilisé.");
                    return;
                }
            }
        }

        // recherche de la ligne du fichier
        QString setInfo=setIndex.data(Qt::DisplayRole).toString();
        bool isPseudo;
        if(setIndex.column() == 0)
            isPseudo=true;
        else if(setIndex.column() == 1)
            isPseudo=false;

        authStream.device()->seek(0);
        QString contenu;
        for(int i=0;!authStream.atEnd();i++)
        {
            QString ligne=authStream.readLine();
            QString info;
            if(isPseudo)
                info=ligne.section(';', 0, 0);
            else
                info=ligne.section(';', 1, 1);

            if(info != setInfo)
            {
                contenu+=ligne+'\n'; // on prend en mémoire toutes les lignes sauf celle à modif
            }
        }

        contenu += infos.pseudo+';'+infos.hashmdp+'\n'; // puis on ajoute à ça la ligne AVEC modifs

        f_auth.resize(0); // supprime le contenu du fichier
        authStream << contenu; // puis le réécrit

        modele->setItem(setRow, 0, new QStandardItem(infos.pseudo)); // édite la ligne du modèle
        modele->setItem(setRow, 1, new QStandardItem(infos.hashmdp));

        tableau->resizeColumnsToContents();
    }

    f_auth.close();
}

void GereComptes::slotDelUser()
{
    // idem slotSetUser() en grande partie
    // ===================================
    QFile f_auth;
    QTextStream authStream;
    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    QModelIndex delIndex=tableau->selectionModel()->currentIndex();
    if(!delIndex.isValid()) // index invalide, pas de selection
    {
        QMessageBox::warning(this, "Aucune sélection", "Aucun item n'est sélectionné.");
        return;
    }

    if(QMessageBox::warning(this, "Êtes-vous sûr ?", "Êtes-vous sûr de vouloir supprimer ce compte définitivement ?",
                            QMessageBox::No | QMessageBox::Yes, QMessageBox::No) == QMessageBox::No)
    {
        return;
    }

    QString delInfo=delIndex.data(Qt::DisplayRole).toString();
    bool isPseudo;
    if(delIndex.column() == 0)
        isPseudo=true;
    else if(delIndex.column() == 1)
        isPseudo=false;

    authStream.device()->seek(0);
    QString contenu;
    for(int i=0;!authStream.atEnd();i++)
    {
        QString ligne=authStream.readLine();
        QString info;
        if(isPseudo)
            info=ligne.section(';', 0, 0);
        else
            info=ligne.section(';', 1, 1);

        if(info != delInfo)
        {
            contenu+=ligne+'\n';
        }
    }

    f_auth.resize(0);
    authStream << contenu;

    modele->removeRow(delIndex.row());
    tableau->resizeColumnsToContents();

    f_auth.close();
}

void GereComptes::slotOk()
{
    closing=true;
    emit fini();
    close();
}

void GereComptes::closeEvent(QCloseEvent *event)
{
    if(!closing) // si on est pas passé par slotOk()
        slotOk();
    else
        event->accept();
}

Pour les explications, elles sont dans la correction et dans quelques commentaires (évitez de lire la correction maintenant, vous risquez de lire la correction du reste) !

Passons à DialSetUser :

dialsetuser.h

#ifndef DIALSETUSER_H
#define DIALSETUSER_H

#include <QDialog>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QFormLayout>
#include <QLineEdit>
#include <QPushButton>
#include <QString>
#include <QMessageBox>

#include "fonctions.h"

class User // oui, je suis flemmard. C'est plus court comme ça.
{
public:
    struct Infos // structure contenant toutes les infos renvoyées par le dialogue.
    {
        QString pseudo;
        QString hashmdp;
        bool annule;
    };
};

class DialSetUser : public QDialog
{
Q_OBJECT

public:
    DialSetUser(User::Infos *out_infos, QString in_pseudo=QString(), QString in_hash=QString()); // in_pseudo et in_hash sont des paramètres facultatifs. Si ils ont été donnés, ce sont les valeurs par défaut.
    static User::Infos get(QString pseudo=QString(), QString hash=QString()); // méthode statique permettant d'appeler le dialogue sans créer un objet.

private slots:
    void slotOk();
    void slotAnnule();

private:
    QVBoxLayout *l_principal;
    QFormLayout *l_form;
    QLineEdit *linePseudo;
    QLineEdit *linePass;
    QLineEdit *linePass2;
    QHBoxLayout *l_boutons;
    QPushButton *b_ok;
    QPushButton *b_annule;

    User::Infos *infos; // pointeur vers la structure passée en paramètre du constructeur
    QString defhash;
};

#endif // DIALSETUSER_H

dialsetuser.cpp

#include "dialsetuser.h"

DialSetUser::DialSetUser(User::Infos *out_infos, QString in_pseudo, QString in_hash)
{
    QString passLabelEnd=""; // permet d'afficher un message ou non en fonction des paramètres passés
    if(in_pseudo.isEmpty() && in_hash.isEmpty())
        setWindowTitle("Ajouter un utilisateur");
    else
    {
        passLabelEnd=" (laisser vide\npour aucun changement)";
        setWindowTitle("Modifier un utilisateur");
    }

    defhash=in_hash; // hash par défaut

    setWindowIcon(QIcon(":/icones/prog"));

    infos=out_infos;

    infos->annule=true; // si fermé, considéré comme annuler

    // ===== GUI ======
    l_principal=new QVBoxLayout;
    l_form=new QFormLayout;
    linePseudo=new QLineEdit;
    linePseudo->setText(in_pseudo);
    l_form->addRow("Pseudo",linePseudo);
    linePass=new QLineEdit;
    linePass->setEchoMode(QLineEdit::Password);
    l_form->addRow("Mot de passe"+passLabelEnd, linePass);
    linePass2=new QLineEdit;
    linePass2->setEchoMode(QLineEdit::Password);
    l_form->addRow("Confirmez le mot de passe", linePass2);
    l_principal->addLayout(l_form);

    l_boutons=new QHBoxLayout;
    b_annule=new QPushButton(QIcon(":/icones/cancel"), "Annuler");
    l_boutons->addWidget(b_annule);
    b_ok=new QPushButton(QIcon(":/icones/accept"), "Ok");
    b_ok->setDefault(true);
    l_boutons->addWidget(b_ok);
    l_principal->addLayout(l_boutons);

    setLayout(l_principal);

    // ===== connexions =====
    connect(b_annule, SIGNAL(clicked()), this, SLOT(slotAnnule()));
    connect(b_ok, SIGNAL(clicked()), this, SLOT(slotOk()));
}

void DialSetUser::slotAnnule()
{
    infos->annule=true;
    close();
}

void DialSetUser::slotOk()
{
    if(linePseudo->text().isEmpty())
    {
        QMessageBox::warning(this, "Erreur", "Tous les champs doivent être remplis !");
        return;
    }

    if(linePass->text() != linePass2->text())
    {
        QMessageBox::warning(this, "Erreur", "Les mots de passe ne correspondent pas.");
        return;
    }

    if(linePseudo->text().contains(';'))
    {
        QMessageBox::warning(this, "Erreur", "Le pseudo contient des caractères interdits.");
        return;
    }

    QString hashpass=linePass->text();
    if(hashpass.isEmpty())
    {
        if(defhash.isEmpty())
        {
            QMessageBox::warning(this, "Erreur", "Tous les champs doivent être remplis !");
            return;
        }
        else
        {
            hashpass=defhash;
        }
    }
    else
        hashpass=Fonctions::hash(hashpass);

    infos->annule=false;
    infos->pseudo=linePseudo->text();
    infos->hashmdp=hashpass;
    close();
}

User::Infos DialSetUser::get(QString pseudo, QString hash)
{
    User::Infos retour; // on crée une structure à retourner,
    DialSetUser dial(&retour, pseudo, hash); // on crée un dialogue
    dial.exec();
    return retour; // puis on retourne la structure
}

Et voilà, vous avez tout le code !

Ensuite, il faut pouvoir le faire marcher avec le code que vous allez faire ! Pour ça, il ne vous faut que trois choses :

Slot d'appel : Vous devrez créer un slot qui créera un objet GereComptes, l'ouvrira (show();), puis le connectera à un autre slot avec son signal fini(). Seulement, pour que ça marche, la fenêtre doit être un attribut de votre classe principale ! À vous de gérer ça.
Slot de fin : Vous devrez donc connecter le signal fini() de la fenêtre à ce slot, qui rechargera le fichier pour garder à jour la liste des logins/hashs.
Fonction de hachage : J'ai choisi de la mettre dans une classe à part, Fonctions, contenue dans les fichiers fonctions.h et fonctions.cpp. La fonction est statique, et son prototype est :
```
QString Fonctions::hash(QString input, bool alreadyMd5 = false);
```
Elle retourne une QString contenant le hash final, et prend en paramètre une QString contenant la chaîne à hacher, ainsi qu'un booléen facultatif (par défaut false) indiquant si input est déjà haché en MD5 ou pas. Ainsi, le retour doit être égal si on envoie en paramètre "sdz", false et si on envoie "sdz" haché en MD5, true.

Et maintenant, à vous de jouer ! Bonne programmation !

Correction

Alors ? Fini ?

Dans ce cas, attaquons la correction !

On va commencer soft, avec le main.cpp :

#include <QtGui/QApplication>
#include <QTextCodec>
#include <QTranslator>
#include <QLocale>
#include <QLibraryInfo>

#include "trayicon.h"

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);

    QString locale = QLocale::system().name().section('_', 0, 0);
    QTranslator translator;
    translator.load(QString("qt_") + locale, QLibraryInfo::location(QLibraryInfo::TranslationsPath));
    a.installTranslator(&translator);

    a.setQuitOnLastWindowClosed(false); // la fermeture de toutes les fenêtres ne fermera pas le programme (utile pour un prog sans fenêtres)

    TrayIcon t;
    t.show();
    return a.exec();
}

Rien de bien particulier, si ce n'est que j'utilise comme classe principale TrayIcon, une classe héritant de QSystemTrayIcon.

Bon, on va attaquer plus dur : TrayIcon !

TrayIcon

trayicon.h (mes noms de fichier sont en minuscules)

#ifndef TRAYICON_H
#define TRAYICON_H

// Eh oui, quand on utilise pas QtGui, ça donne ça !
#include <QSystemTrayIcon>
#include <QIcon>
#include <QMenu>
#include <QAction>
#include <QMessageBox>
#include <QHash>
#include <QByteArray>
#include <QFile>
#include <QTextStream>
#include <QCryptographicHash>
#include <QTcpServer>
#include <QTcpSocket>

#include "gerecomptes.h"
#include "fonctions.h"

class TrayIcon : public QSystemTrayIcon
{
Q_OBJECT

public:
    TrayIcon();
    void genereListePass(); // analyse le fichier contenant les logins/hashs pour les mettre dans "passTable"

private slots:
    void slotGereComptes();
    void slotGereComptesDone(); // appelé quand la fenêtre de gestion des comptes est fermée
    void slotDisplayAll();
    void slotSuspendre();
    void slotQuitter();

    // slots réseau
    void slotNewConnexion();
    void slotDonneesRecues();
    void slotDeconnexion();

private:
    // =========== METHODES ===========
    void envoyer(QTcpSocket *sock, quint8 reponse);

    // =========== ATTRIBUTS ==========
    // GUI
    QMenu *menu;
    QAction *actGereComptes;
    QAction *actDisplayAll;
    QAction *actSuspendre;
    QAction *actQuitter;

    GereComptes *fenComptes;

    // network
    QTcpServer *serv;
    quint16 size1; // stocke la taille de la 1ere partie des paquets reçus
    QString data1; // 1ere part. paquets reçus
    quint16 size2; // idem size1 pour la 2nde
    QString data2; // idem data1 pour la 2nde
    QList<QTcpSocket *> listeClients;

    // pass
    QHash<QString, QString> passTable; // stocke les correspondances logins/hashs

    // options
    bool displayAll; // si true, chaque connexion sera affichée dans une infobulle
    bool suspendu; // si true, toute connexion renverra 5 (service indisponible)
};

#endif // TRAYICON_H

Bon, lui je vous le donne d'un coup, c'est pas bien dur à comprendre. Vous voyez qu'on inclut gerecomptes.h et fonctions.h. gerecomptes.h contient la classe GereComptes créant l'interface graphique pour ajouter/modifier/supprimer des comptes, et fonctions.h contient la classe Fonctions, qui contient la méthode statique servant au hachage.

On va attaquer les méthodes une par une maintenant :

TrayIcon() (constructeur)

TrayIcon::TrayIcon()
{
    // inits
    setIcon(QIcon(":/icones/prog")); // définit l'icône
    displayAll=false; // par défaut, infobulles désactivées
    suspendu=false; // par défaut, service activé
    genereListePass();

    size1=0;
    data1="";
    size2=0;
    data2="";

    serv=new QTcpServer(this); // on démarre le serveur
    if(!serv->listen(QHostAddress::Any, 31742))
    {
        QMessageBox::critical(0, "zLogin : erreur fatale", "Le programme zLogin ne peut établir de connexion. Il va donc fermer.\nErreur : "+serv->errorString());
        exit(EXIT_FAILURE);
    }
    else
    {
        connect(serv, SIGNAL(newConnection()), this, SLOT(slotNewConnexion()));
    }

    // Création du menu
    menu=new QMenu("Application");
    actGereComptes=menu->addAction("Gérer les comptes", this, SLOT(slotGereComptes()));
    menu->addSeparator();
    actDisplayAll=menu->addAction("Activer les infobulles", this, SLOT(slotDisplayAll()));
    actDisplayAll->setToolTip("Affiche une infobulle à chaque tentative de connexion");
    actDisplayAll->setCheckable(true);
    actDisplayAll->setChecked(false);
    actSuspendre=menu->addAction("Suspendre le service", this, SLOT(slotSuspendre()));
    actSuspendre->setToolTip("Refuse toute tentative de connexion, tout en gardant le programme ouvert");
    actSuspendre->setCheckable(true);
    actSuspendre->setChecked(false);
    menu->addSeparator();
    actQuitter=menu->addAction("Quitter", this, SLOT(slotQuitter()));
    setContextMenu(menu);
}

Encore une fois, rien de bien compliqué : on initialise le serveur (voir le tuto de M@t' si vous ne comprenez pas cette partie du code), puis on crée le menu de l'icône dans le system tray, en créant un menu comme pour une fenêtre, puis en l'attribuant à l'icône avec setContextMenu(menu);.

On va ensuite voir tout ce qui ne concerne pas le réseau, puis on s'attaquera à la gestion du réseau.

Non-réseau

genereListePass() (qui remplit la table de hachage en fonction du fichier "auth.zla")

void TrayIcon::genereListePass()
{
    QFile f_pass("auth.zla"); // zla = ZLogin Auth, fichier texte.
    if(!f_pass.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur critique", "Le programme \"zLogin\" a rencontré une erreur critique lors de la mise à jour de la liste des logins/mdps du zLogin. Le programme va donc fermer.\nErreur : "+f_pass.errorString());
        exit(EXIT_FAILURE);
    }

    QTextStream stream(&f_pass);

    QHash<QString, QString> tempPassTable; // on crée une table temporaire pour réduire le temps d'indisponiblité du service

    while(!stream.atEnd())
    {
        QString line=stream.readLine();
        QString pseudo=line.section(';', 0, 0);
        QString pass=line.section(';', 1, 1);
        tempPassTable.insert(pseudo, pass);
    }

    f_pass.close();

    suspendu=true; // On évite les erreurs si une requête est effectuée à ce moment en désactivant le service
    passTable.empty();
    passTable=tempPassTable;
    suspendu=false; // Puis on le réactive
}

On ouvre donc le fichier auth.zla, qui contient les logins/hashs stockés ainsi :

login;hash
autrelogin;autrehash

On boucle jusqu'à la fin du fichier en remplissant une table de hachage temporaire, puis on ferme le fichier. Utiliser une table de hachage temporaire permet de réduire le temps où le service sera indisponible.
Ensuite, on rend le service indisponible (en passant suspendu à true), on vide la table de hachage (la vraie cette fois), puis on copie les données de la table de hachage temporaire dans la table de hachage, et enfin on réactive le service. Couper le service permet d'éviter des bugs dans le cas où une requête serait effectuée pile au moment où la table de hachage est vide.

Ensuite, les slots appelés quand on clique sur un élément du menu :
slotGereComptes() (appelé par "Gérer les comptes")

void TrayIcon::slotGereComptes()
{
    fenComptes=new GereComptes(passTable);
    fenComptes->show();
    connect(fenComptes, SIGNAL(fini()), this, SLOT(slotGereComptesDone()));
}

Très court, on crée la fenêtre en lui passant la table de hachage qui contient les logins/hashs, on l'affiche, puis on connecte le signal personnalisé fini() au slot slotGereComptesDone.

slotGereComptesDone() (appelé quand la fenêtre de gestion des comptes est fermée)

void TrayIcon::slotGereComptesDone()
{
    genereListePass();
}

Encore plus court, ce slot se contente de mettre à jour, à partir du fichier que la fenêtre de gestion des comptes a peut-être modifié, la table de hachage qui contient les logins/hashs. J'ai utilisé un slot en lui-même au lieu de connecter directement fini() à genereListePass(), car si on a besoin ensuite de rajouter une action lors de la fermeture du dialogue, c'est plus simple :D .

slotDisplayAll() (appelé par "Activer les infobulles")

void TrayIcon::slotDisplayAll()
{
    displayAll=actDisplayAll->isChecked();

    if(displayAll)
        showMessage("Infobulles activées", "Les infobulles ont été activées. Toute tentative de login sera signalée.", QSystemTrayIcon::Information, 5000);
    else
        showMessage("Infobulles désactivées", "Les infobulles ont été désactivées. Les tentatives de login ne seront plus signalées.", QSystemTrayIcon::Information, 5000);
}

On modifie la valeur de displayAll en fonction de l'état d'actDisplayAll (l'élément du menu "Activer les infobulles"), puis on affiche que les infobulles ont été activées/désactivées.

slotSuspendre() (appelé par "Suspendre le service")

void TrayIcon::slotSuspendre()
{
    if(actSuspendre->isChecked()) // Si on demande de suspendre
    {
        if(QMessageBox::warning(0, "Êtes-vous sûr ?", "Voulez-vous vraiment suspendre le service ? Toute tentative de connexion sera refusée, mais le programme sera toujours ouvert.",
                                QMessageBox::No | QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
        {
            suspendu=true;
            showMessage("Service suspendu", "Le service a bien été suspendu. Toute tentative de login sera rejetée, et renverra le code 5 (service indisponible)", QSystemTrayIcon::Information, 5000);
        }
    }
    else
    {
        suspendu=false;
        showMessage("Service activé", "Le service a bien été activé. Les tentatives de login seront maintenant traitées.", QSystemTrayIcon::Information, 5000);
    }
}

Idem à slotDisplayAll, sauf qu'on modifie suspendu, et qu'on demande une confirmation pour le faire passer à true.

slotQuitter() (appelé par "Quitter")

void TrayIcon::slotQuitter()
{
    int ret = QMessageBox::warning(0, "Êtes-vous sûr ?", "Êtes-vous sûr de vouloir quitter le zLogin ?",
                                   QMessageBox::No | QMessageBox::Yes, QMessageBox::No);

    if(ret==QMessageBox::Yes)
        exit(EXIT_SUCCESS);
}

On demande une confirmation, puis on quitte, tout simplement.
On en a fini avec ce qui ne concerne pas le réseau !

Réseau

slotNewConnexion() (appelé lors d'une connexion au serveur)

void TrayIcon::slotNewConnexion()
{
    QTcpSocket *sock=serv->nextPendingConnection();
    listeClients << sock;
    connect(sock, SIGNAL(readyRead()), this, SLOT(slotDonneesRecues()));
    connect(sock, SIGNAL(disconnected()), this, SLOT(slotDeconnexion()));
}

Si vous avez le tuto de M@t' sur le réseau avec Qt en tête, c'est très simple : on récupère le client, on le stocke dans une liste, puis on connecte readyRead() et disconnected à des slots personnalisés.

Continuons avec...
envoyer() (appelé pour envoyer la réponse)

void TrayIcon::envoyer(QTcpSocket *sock, quint8 reponse)
{
    QByteArray paquet;
    QDataStream stream(&paquet, QIODevice::WriteOnly);

    stream << reponse;

    sock->write(paquet);
}

On crée un QByteArray stockant ce qu'on va envoyer, on y ajoute le paramètre reponse, puis on l'envoie.

slotDeconnexion() (appelé quand un client se déconnecte)

void TrayIcon::slotDeconnexion()
{
    QTcpSocket *sock=qobject_cast<QTcpSocket *>(sender());
    if(sock==0)
        return;

    sock->deleteLater();
    listeClients.removeOne(sock);
}

On identifie le client en question, puis on le supprime de la liste, et on le supprime tout court avec deleteLater().

Attention, maintenant, on s'attaque au gros ! La plus grosse partie de la gestion réseau est bien évidemment celle qui gère la réception des paquets, puis ce qui sera retourné !
slotDonneesRecues() (gère la réception des paquets, puis le renvoi de la réponse)
Je vais faire exception à la règle, et vous donner le code petit bout par petit bout.
Déjà, on a deux cas possibles : le service est suspendu, ou ne l'est pas. Mais dans les deux cas, on doit savoir de qui vient la requête. Ce qui nous donne la base de code suivante :

void TrayIcon::slotDonneesRecues()
{
    // ==== Recup du socket
    QTcpSocket *sock = qobject_cast<QTcpSocket *>(sender());
    if(sock==0)
        return;

    QDataStream stream(sock);

    if(!suspendu) // si le service est actif
    {
        
    }
    else // service suspendu
    {
        
    }
}

Commençons par le plus simple : le service est suspendu. Avant tout, il faut attendre qu'on aie reçu tous les sous-paquets. Pour cela, pas d'autre choix que de récupérer les deux tailles de parties ainsi :

// ==== Recup du socket
    QTcpSocket *sock = qobject_cast<QTcpSocket *>(sender());
    if(sock==0)
        return;

    QDataStream stream(sock);

    if(!suspendu) // si le service est actif
    {
        
    }
    else // service suspendu
    {
        // on attend la fin de la transmission

        if(size1 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size1;
        }
        if(data1 == "")
        {
            if(sock->bytesAvailable() < size1)
                return;
            data1="ok";
        }
        if(size2 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size2;
        }
        if(sock->bytesAvailable() < size2)
            return;

        // fin de la transmission
        envoyer(sock, 5);

        size1=0;
        data1="";
        size2=0;
        data2="";
    }
}

On envoie ensuite dans tous les cas le code 5, soit "Service indisponible", puis on réinitialise les variables "size1", "data1", "size2" et "data2".

La partie "service actif" n'est pas bien différente, on y ajoute simplement le traitement des données reçues :

void TrayIcon::slotDonneesRecues()
{
    // ==== Recup du socket
    QTcpSocket *sock = qobject_cast<QTcpSocket *>(sender());
    if(sock==0)
        return;

    QDataStream stream(sock);

    if(!suspendu) // si le service est actif
    {
        // ==== Recup des donnees
        if(size1 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size1;
        }

        if(data1 == "")
        {
            if(sock->bytesAvailable() < size1)
                return;
            stream >> data1;
        }

        if(size2 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size2;
        }

        if(sock->bytesAvailable() < size2)
            return;

        stream >> data2;

        // ==== Traitement des donnees

        QString startInfo="Une tentative de connexion depuis l'IP "+sock->peerAddress().toString()+" a été établie (pseudo : "+data1+").\nRésultat : ";

        if(!passTable.contains(data1)) // existence du pseudo
        {
            if(displayAll) // infobulles activées
                showMessage("Tentative de connexion (échec)", startInfo+"mauvais login.", QSystemTrayIcon::NoIcon, 5000);
            envoyer(sock, 2);

            size1=0;
            data1="";
            size2=0;
            data2="";
            return;
        }
        QString hashPass=passTable.value(data1);
        if(hashPass=="") // vérif que le hash ne soit pas vide
        {
            if(displayAll) // infobulles activées
                showMessage("Tentative de connexion (échec)", startInfo+"erreur interne au zLogin (aucun mdp associé au login).", QSystemTrayIcon::NoIcon, 5000);
            envoyer(sock, 4);

            size1=0;
            data1="";
            size2=0;
            data2="";
            return;
        }
        else if(hashPass != Fonctions::hash(data2, true)) // vérif mdp = mdp envoyé
        {
            if(displayAll) // infobulles activées
                showMessage("Tentative de connexion (échec)", startInfo+"mauvais MDP.", QSystemTrayIcon::NoIcon, 5000);
            envoyer(sock, 3);

            size1=0;
            data1="";
            size2=0;
            data2="";
            return;
        }

        // Si on arrive là, login/mdp OK !
        if(displayAll) // infobulles activées
            showMessage("Tentative de connexion (succès)", startInfo+"succès.", QSystemTrayIcon::NoIcon, 5000);
        envoyer(sock, 1);

        size1=0;
        data1="";
        size2=0;
        data2="";
    }
    else // service suspendu
    {
        // on attend la fin de la transmission

        if(size1 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size1;
        }
        if(data1 == "")
        {
            if(sock->bytesAvailable() < size1)
                return;
            data1="ok";
        }
        if(size2 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size2;
        }
        if(sock->bytesAvailable() < size2)
            return;

        // fin de la transmission
        envoyer(sock, 5);

        size1=0;
        data1="";
        size2=0;
        data2="";
    }
}

On vérifie que le login existe, sinon, on renvoie 2 et on retourne. Puis on vérifie qu'un mot de passe est bien associé à ce login, sinon on renvoie 4 (erreur interne). Ensuite, on vérifie que le hash correspond bien à celui associé au login, sinon, on renvoie 3. À la fin, si tout est OK, on renvoie 1 (succès).

Et voilà, on en a fini avec TrayIcon !

Le code entier le trayicon.cpp :

#include "trayicon.h"

TrayIcon::TrayIcon()
{
    // inits
    setIcon(QIcon(":/icones/prog"));
    displayAll=false; // par défaut, infobulles désactivées
    suspendu=false; // par défaut, service activé
    genereListePass();

    size1=0;
    data1="";
    size2=0;
    data2="";

    serv=new QTcpServer(this); // on démarre le serveur
    if(!serv->listen(QHostAddress::Any, 31742))
    {
        QMessageBox::critical(0, "zLogin : erreur fatale", "Le programme zLogin ne peut établir de connexion. Il va donc fermer.\nErreur : "+serv->errorString());
        exit(EXIT_FAILURE);
    }
    else
    {
        connect(serv, SIGNAL(newConnection()), this, SLOT(slotNewConnexion()));
    }

    // Création du menu
    menu=new QMenu("Application");
    actGereComptes=menu->addAction("Gérer les comptes", this, SLOT(slotGereComptes()));
    menu->addSeparator();
    actDisplayAll=menu->addAction("Activer les infobulles", this, SLOT(slotDisplayAll()));
    actDisplayAll->setToolTip("Affiche une infobulle à chaque tentative de connexion");
    actDisplayAll->setCheckable(true);
    actDisplayAll->setChecked(false);
    actSuspendre=menu->addAction("Suspendre le service", this, SLOT(slotSuspendre()));
    actSuspendre->setToolTip("Refuse toute tentative de connexion, tout en gardant le programme ouvert");
    actSuspendre->setCheckable(true);
    actSuspendre->setChecked(false);
    menu->addSeparator();
    actQuitter=menu->addAction("Quitter", this, SLOT(slotQuitter()));
    setContextMenu(menu);
}

// =============================
// ====== NETWORK ==============
// =============================

void TrayIcon::slotNewConnexion()
{
    QTcpSocket *sock=serv->nextPendingConnection();
    listeClients << sock;
    connect(sock, SIGNAL(readyRead()), this, SLOT(slotDonneesRecues()));
    connect(sock, SIGNAL(disconnected()), this, SLOT(slotDeconnexion()));
}

void TrayIcon::slotDonneesRecues()
{
    // ==== Recup du socket
    QTcpSocket *sock = qobject_cast<QTcpSocket *>(sender());
    if(sock==0)
        return;

    QDataStream stream(sock);

    if(!suspendu) // si le service est actif
    {
        // ==== Recup des donnees
        if(size1 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size1;
        }

        if(data1 == "")
        {
            if(sock->bytesAvailable() < size1)
                return;
            stream >> data1;
        }

        if(size2 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size2;
        }

        if(sock->bytesAvailable() < size2)
            return;

        stream >> data2;

        // ==== Traitement des donnees

        QString startInfo="Une tentative de connexion depuis l'IP "+sock->peerAddress().toString()+" a été établie (pseudo : "+data1+").\nRésultat : ";

        if(!passTable.contains(data1)) // existence du pseudo
        {
            if(displayAll) // infobulles activées
                showMessage("Tentative de connexion (échec)", startInfo+"mauvais login.", QSystemTrayIcon::NoIcon, 5000);
            envoyer(sock, 2);

            size1=0;
            data1="";
            size2=0;
            data2="";
            return;
        }
        QString hashPass=passTable.value(data1);
        if(hashPass=="") // vérif que le hash ne soit pas vide
        {
            if(displayAll) // infobulles activées
                showMessage("Tentative de connexion (échec)", startInfo+"erreur interne au zLogin (aucun mdp associé au login).", QSystemTrayIcon::NoIcon, 5000);
            envoyer(sock, 4);

            size1=0;
            data1="";
            size2=0;
            data2="";
            return;
        }
        else if(hashPass != Fonctions::hash(data2, true)) // vérif mdp = mdp envoyé
        {
            if(displayAll) // infobulles activées
                showMessage("Tentative de connexion (échec)", startInfo+"mauvais MDP.", QSystemTrayIcon::NoIcon, 5000);
            envoyer(sock, 3);

            size1=0;
            data1="";
            size2=0;
            data2="";
            return;
        }

        // Si on arrive là, login/mdp OK !
        if(displayAll) // infobulles activées
            showMessage("Tentative de connexion (succès)", startInfo+"succès.", QSystemTrayIcon::NoIcon, 5000);
        envoyer(sock, 1);

        size1=0;
        data1="";
        size2=0;
        data2="";
    }
    else // service suspendu
    {
        // on attend la fin de la transmission

        if(size1 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size1;
        }
        if(data1 == "")
        {
            if(sock->bytesAvailable() < size1)
                return;
            data1="ok";
        }
        if(size2 == 0)
        {
            if(sock->bytesAvailable() < (int)sizeof(quint16))
                return;
            stream >> size2;
        }
        if(sock->bytesAvailable() < size2)
            return;

        // fin de la transmission
        envoyer(sock, 5);

        size1=0;
        data1="";
        size2=0;
        data2="";
    }
}

void TrayIcon::envoyer(QTcpSocket *sock, quint8 reponse)
{
    QByteArray paquet;
    QDataStream stream(&paquet, QIODevice::WriteOnly);

    stream << reponse;

    sock->write(paquet);
}

void TrayIcon::slotDeconnexion()
{
    QTcpSocket *sock=qobject_cast<QTcpSocket *>(sender());
    if(sock==0)
        return;

    sock->deleteLater();
    listeClients.removeOne(sock);
}

// =============================
// ====== GUI & gestion pass ===
// =============================

void TrayIcon::genereListePass()
{
    QFile f_pass("auth.zla"); // zla = ZLogin Auth, fichier texte.
    if(!f_pass.open(QIODevice::ReadOnly | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur critique", "Le programme \"zLogin\" a rencontré une erreur critique lors de la mise à jour de la liste des logins/mdps du zLogin. Le programme va donc fermer.\nErreur : "+f_pass.errorString());
        exit(EXIT_FAILURE);
    }

    QTextStream stream(&f_pass);

    QHash<QString, QString> tempPassTable; // on crée une table temporaire pour réduire le temps d'indisponiblité du service

    while(!stream.atEnd())
    {
        QString line=stream.readLine();
        QString pseudo=line.section(';', 0, 0);
        QString pass=line.section(';', 1, 1);
        tempPassTable.insert(pseudo, pass);
    }

    f_pass.close();

    suspendu=true; // On évite les erreurs si une requête est effectuée à ce moment en désactivant le service
    passTable.empty();
    passTable=tempPassTable;
    suspendu=false; // Puis on le réactive
}

void TrayIcon::slotGereComptes()
{
    fenComptes=new GereComptes(passTable);
    fenComptes->show();
    connect(fenComptes, SIGNAL(fini()), this, SLOT(slotGereComptesDone()));
}

void TrayIcon::slotGereComptesDone()
{
    genereListePass();
}

void TrayIcon::slotDisplayAll()
{
    displayAll=actDisplayAll->isChecked();

    if(displayAll)
        showMessage("Infobulles activées", "Les infobulles ont été activées. Toute tentative de login sera signalée.", QSystemTrayIcon::Information, 5000);
    else
        showMessage("Infobulles désactivées", "Les infobulles ont été désactivées. Les tentatives de login ne seront plus signalées.", QSystemTrayIcon::Information, 5000);
}

void TrayIcon::slotSuspendre()
{
    if(actSuspendre->isChecked()) // Si on demande de suspendre
    {
        if(QMessageBox::warning(0, "Êtes-vous sûr ?", "Voulez-vous vraiment suspendre le service ? Toute tentative de connexion sera refusée, mais le programme sera toujours ouvert.",
                                QMessageBox::No | QMessageBox::Yes, QMessageBox::No) == QMessageBox::Yes)
        {
            suspendu=true;
            showMessage("Service suspendu", "Le service a bien été suspendu. Toute tentative de login sera rejetée, et renverra le code 5 (service indisponible)", QSystemTrayIcon::Information, 5000);
        }
    }
    else
    {
        suspendu=false;
        showMessage("Service activé", "Le service a bien été activé. Les tentatives de login seront maintenant traitées.", QSystemTrayIcon::Information, 5000);
    }
}

void TrayIcon::slotQuitter()
{
    int ret = QMessageBox::warning(0, "Êtes-vous sûr ?", "Êtes-vous sûr de vouloir quitter le zLogin ?",
                                   QMessageBox::No | QMessageBox::Yes, QMessageBox::No);

    if(ret==QMessageBox::Yes)
        exit(EXIT_SUCCESS);
}

GereComptes

Cette classe est l'interface graphique servant à gérer les comptes.
On va attaquer avec gerecomptes.h :

gerecomptes.h

#ifndef GERECOMPTES_H
#define GERECOMPTES_H

// eh oui, il y en a pas mal
#include <QWidget>
#include <QTableView>
#include <QStandardItemModel>
#include <QHBoxLayout>
#include <QVBoxLayout>
#include <QPushButton>
#include <QIcon>
#include <QHash>
#include <QHashIterator>
#include <QCloseEvent>
#include <QList>
#include <QHeaderView>
#include <QMessageBox>
#include <QFile>
#include <QTextStream>
#include <QRegExp>

#include "dialsetuser.h"

class GereComptes : public QWidget
{
Q_OBJECT

public:
    GereComptes(QHash<QString, QString> authIn);

signals:
    void fini(); // émis à la fermeture du dialogue

private slots:
    void slotAddUser();
    void slotSetUser();
    void slotDelUser();
    void slotOk();

private:
    // methodes
    void majModele(); // appelé pour ajouter dans "modele" tout ce qui est contenu dans "authTable" (appelé dans le constructeur uniquement)
    void closeEvent(QCloseEvent *event); // Pour intercepter l'évènement de fermeture

    //attributs
    QHBoxLayout *l_principal;
    QTableView *tableau; // j'utilise une architecture MV (voir tuto de M@t')
    QStandardItemModel *modele;
    QVBoxLayout *l_boutons;
    QPushButton *b_addUser;
    QPushButton *b_setUser;
    QPushButton *b_delUser;
    QPushButton *b_ok;

    QHash<QString, QString> authTable;

    bool closing;
};

#endif // GERECOMPTES_H

Rien à expliquer ici je pense, si ce n'est que j'utilise une architecture MV (une MVC simplifiée, tuto de M@t' ici), comme en témoignent QTableView *tableau; et QStandardItemModel *modele;.

Attaquons-nous maintenant à l'implémentation de ces fonctions :

GereComptes() (constructeur)

GereComptes::GereComptes(QHash<QString, QString> authIn)
{
    setWindowTitle("zLogin - gestion des comptes");
    setWindowIcon(QIcon(":/icones/prog"));
    authTable=authIn;
    closing=false;

    // GUI
    l_principal=new QHBoxLayout;
    modele=new QStandardItemModel(0, 2);
    modele->setHeaderData(0, Qt::Horizontal, "Pseudo", Qt::DisplayRole);
    modele->setHeaderData(1, Qt::Horizontal, "Hash du MDP", Qt::DisplayRole);
    tableau=new QTableView;
    tableau->setModel(modele);
    tableau->setMinimumWidth(425);
    majModele();
    l_principal->addWidget(tableau);

    l_boutons=new QVBoxLayout;
    b_addUser=new QPushButton(QIcon(":/icones/addUser"), "Créer un compte");
    l_boutons->addWidget(b_addUser);
    b_setUser=new QPushButton(QIcon(":/icones/setUser"), "Modifier le compte");
    l_boutons->addWidget(b_setUser);
    b_delUser=new QPushButton(QIcon(":/icones/delUser"), "Supprimer le compte");
    l_boutons->addWidget(b_delUser);
    b_ok=new QPushButton(QIcon(":/icones/accept"), "Ok");
    l_boutons->addWidget(b_ok);
    l_principal->addLayout(l_boutons);

    setLayout(l_principal);

    // connect
    connect(b_addUser, SIGNAL(clicked()), this, SLOT(slotAddUser()));
    connect(b_setUser, SIGNAL(clicked()), this, SLOT(slotSetUser()));
    connect(b_delUser, SIGNAL(clicked()), this, SLOT(slotDelUser()));
    connect(b_ok, SIGNAL(clicked()), this, SLOT(slotOk()));
}

On crée la GUI, on crée modele et on l'associe à tableau, puis on appelle majModele(), qui crée, à partir de la table de hachage reçue en paramètre du constructeur, le modèle.

majModele() (appelé depuis le constructeur)

void GereComptes::majModele()
{
    // assez simple : on ajoute dans le modèle tous les logins/hashs.
    QHashIterator<QString, QString> iterateur(authTable);

    while(iterateur.hasNext())
    {
        iterateur.next();
        QList<QStandardItem *> items;
        items << new QStandardItem(iterateur.key()) << new QStandardItem(iterateur.value());
        modele->appendRow(items);
    }

    tableau->resizeColumnsToContents();
}

On crée un itérateur utilisant la table de hachage reçue en paramètre du constructeur, puis on le parcourt en ajoutant à chaque fois au modèle la clé et la valeur, soit le login et le hash. À la fin, tableau->resizeColumnsToContents(); sert à ajuster les colonnes du tableau aux valeurs contenues.

slotAddUser() (appelé par un clic sur "Créer un compte")

void GereComptes::slotAddUser()
{
    // On ajoutera le nouvel utilisateur directement dans le fichier, qui devra être rechargé une fois le dialogue fermé

    QFile f_auth;
    QTextStream authStream;

    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    User::Infos infos=DialSetUser::get(); // méthode statique

    if(infos.annule)
        return;

    QHashIterator<QString, QString> iterateur(authTable);

    while(iterateur.hasNext()) // vérif que le pseudo n'est pas utilisé
    {
        iterateur.next();
        if(iterateur.key() == infos.pseudo)
        {
            QMessageBox::warning(this, "Erreur", "Le pseudo choisi est déjà utilisé.");
            return;
        }
    }

    authStream.readAll(); // aller à la fin du fichier
    authStream << infos.pseudo+';'+infos.hashmdp+'\n';

    QList<QStandardItem *> items; // ajout du nouvel utilisateur au modèle
    items << new QStandardItem(infos.pseudo) << new QStandardItem(infos.hashmdp);
    modele->appendRow(items);
    tableau->resizeColumnsToContents();

    f_auth.close();
}

On ouvre d'abord le fichier auth.zla, puis on ouvre un dialogue demandant à l'utilisateur le login et le mot de passe du nouvel utilisateur. Le dialogue se charge de hacher le MdP. On vérifie que l'utilisateur n'a pas annulé, puis on parcourt la table pour vérifier que le pseudo n'est pas déjà présent. On se place à la fin du fichier en le lisant entièrement, puis on y ajoute la ligne formée ainsi : login;hash ( étant un retour à la ligne). Ensuite, on ajoute le nouvel utilisateur au modèle, puis on ferme le fichier.

slotDelUser() (appelé par un clic sur "Supprimer le compte")

void GereComptes::slotDelUser()
{
    QFile f_auth;
    QTextStream authStream;
    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    QModelIndex delIndex=tableau->selectionModel()->currentIndex();
    if(!delIndex.isValid()) // index invalide, pas de selection
    {
        QMessageBox::warning(this, "Aucune sélection", "Aucun item n'est sélectionné.");
        return;
    }

    if(QMessageBox::warning(this, "Êtes-vous sûr ?", "Êtes-vous sûr de vouloir supprimer ce compte définitivement ?",
                            QMessageBox::No | QMessageBox::Yes, QMessageBox::No) == QMessageBox::No)
    {
        return;
    }

    QString delInfo=delIndex.data(Qt::DisplayRole).toString();
    bool isPseudo;
    if(delIndex.column() == 0)
        isPseudo=true;
    else if(delIndex.column() == 1)
        isPseudo=false;

    authStream.device()->seek(0);
    QString contenu;
    for(int i=0;!authStream.atEnd();i++)
    {
        QString ligne=authStream.readLine();
        QString info;
        if(isPseudo)
            info=ligne.section(';', 0, 0);
        else
            info=ligne.section(';', 1, 1);

        if(info != delInfo)
        {
            contenu+=ligne+'\n';
        }
    }

    f_auth.resize(0);
    authStream << contenu;

    modele->removeRow(delIndex.row());
    tableau->resizeColumnsToContents();

    f_auth.close();
}

Pareil, on ouvre le fichier auth.zla, puis on récupère la sélection pour savoir quelle ligne supprimer. Si l'index est invalide, il n'y a donc pas de sélection, on affiche une erreur et on retourne. On demande confirmation, et on prend en mémoire toutes les lignes sauf celle à supprimer. Avec f_auth.resize(0), on supprime tout le contenu du fichier, puis on réinscrit dedans tout ce qu'on a gardé en mémoire. On supprime la ligne du modèle, puis on ferme le fichier.

slotSetUser() (appelé par un clic sur "Modifier le compte")

void GereComptes::slotSetUser()
{
    QFile f_auth;
    QTextStream authStream;
    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    QModelIndex setIndex=tableau->selectionModel()->currentIndex();
    if(!setIndex.isValid()) // index invalide, pas de selection
    {
        QMessageBox::warning(this, "Aucune sélection", "Aucun item n'est sélectionné.");
        return;
    }

    int setRow=setIndex.row(); // récupère l'ID de la ligne sélectionnée
    QString basePseudo=modele->item(setRow, 0)->data(Qt::DisplayRole).toString(); // recup le pseudo actuel
    QString baseHash=modele->item(setRow, 1)->data(Qt::DisplayRole).toString(); // récup le hash actuel
    User::Infos infos=DialSetUser::get(basePseudo, baseHash);

    if(infos.annule) // si l'user a annulé
        return;

    if(infos.pseudo != basePseudo || infos.hashmdp != baseHash) // si il y a eu une modif
    {

        if(infos.pseudo!=basePseudo) //vérif que le pseudo est libre
        {
            QHashIterator<QString, QString> iterateur(authTable);

            while(iterateur.hasNext())
            {
                iterateur.next();
                if(iterateur.key() == infos.pseudo)
                {
                    QMessageBox::warning(this, "Erreur", "Le pseudo choisi est déjà utilisé.");
                    return;
                }
            }
        }

        // recherche de la ligne du fichier
        QString setInfo=setIndex.data(Qt::DisplayRole).toString();
        bool isPseudo;
        if(setIndex.column() == 0)
            isPseudo=true;
        else if(setIndex.column() == 1)
            isPseudo=false;

        authStream.device()->seek(0);
        QString contenu;
        for(int i=0;!authStream.atEnd();i++)
        {
            QString ligne=authStream.readLine();
            QString info;
            if(isPseudo)
                info=ligne.section(';', 0, 0);
            else
                info=ligne.section(';', 1, 1);

            if(info != setInfo)
            {
                contenu+=ligne+'\n'; // on prend en mémoire toutes les lignes sauf celle à modif
            }
        }

        contenu += infos.pseudo+';'+infos.hashmdp+'\n'; // puis on ajoute à ça la ligne AVEC modifs

        f_auth.resize(0); // supprime le contenu du fichier
        authStream << contenu; // puis le réécrit

        modele->setItem(setRow, 0, new QStandardItem(infos.pseudo)); // édite la ligne du modèle
        modele->setItem(setRow, 1, new QStandardItem(infos.hashmdp));

        tableau->resizeColumnsToContents();
    }

    f_auth.close();
}

Ce slot est un simple mélange de slotAddUser() et de slotDelUser, je n'expliquerai donc rien ici, en croisant les deux explications vous devriez assez bien comprendre !

slotOk() (appelé par un clic sur "Ok")

void GereComptes::slotOk()
{
    closing=true;
    emit fini();
    close();
}

On définit closing à true, on émet fini(), puis on ferme la fenêtre.

closeEvent() (appelé par close(), ou un clic sur la croix)

void GereComptes::closeEvent(QCloseEvent *event)
{
    if(!closing) // si on est pas passé par slotOk()
        slotOk();
    else
        event->accept();
}

Pour que fini() soit émit si on clique sur la croix, on vérifie si closing vaut true (seulement vrai après un appel de slotOk(), si oui, on accepte la fermeture, sinon, on appelle slotOk().

On en a également fini avec GereComptes !
Le code complet :

#include "gerecomptes.h"

GereComptes::GereComptes(QHash<QString, QString> authIn)
{
    setWindowTitle("zLogin - gestion des comptes");
    setWindowIcon(QIcon(":/icones/prog"));
    authTable=authIn;
    closing=false;

    // GUI
    l_principal=new QHBoxLayout;
    modele=new QStandardItemModel(0, 2);
    modele->setHeaderData(0, Qt::Horizontal, "Pseudo", Qt::DisplayRole);
    modele->setHeaderData(1, Qt::Horizontal, "Hash du MDP", Qt::DisplayRole);
    tableau=new QTableView;
    tableau->setModel(modele);
    tableau->setMinimumWidth(425);
    majModele();
    l_principal->addWidget(tableau);

    l_boutons=new QVBoxLayout;
    b_addUser=new QPushButton(QIcon(":/icones/addUser"), "Créer un compte");
    l_boutons->addWidget(b_addUser);
    b_setUser=new QPushButton(QIcon(":/icones/setUser"), "Modifier le compte");
    l_boutons->addWidget(b_setUser);
    b_delUser=new QPushButton(QIcon(":/icones/delUser"), "Supprimer le compte");
    l_boutons->addWidget(b_delUser);
    b_ok=new QPushButton(QIcon(":/icones/accept"), "Ok");
    l_boutons->addWidget(b_ok);
    l_principal->addLayout(l_boutons);

    setLayout(l_principal);

    // connect
    connect(b_addUser, SIGNAL(clicked()), this, SLOT(slotAddUser()));
    connect(b_setUser, SIGNAL(clicked()), this, SLOT(slotSetUser()));
    connect(b_delUser, SIGNAL(clicked()), this, SLOT(slotDelUser()));
    connect(b_ok, SIGNAL(clicked()), this, SLOT(slotOk()));
}

void GereComptes::majModele()
{
    // assez simple : on ajoute dans le modèle tous les logins/hashs.
    QHashIterator<QString, QString> iterateur(authTable);

    while(iterateur.hasNext())
    {
        iterateur.next();
        QList<QStandardItem *> items;
        items << new QStandardItem(iterateur.key()) << new QStandardItem(iterateur.value());
        modele->appendRow(items);
    }

    tableau->resizeColumnsToContents();
}

void GereComptes::slotAddUser()
{
    // On ajoutera le nouvel utilisateur directement dans le fichier, qui devra être rechargé une fois le dialogue fermé

    QFile f_auth;
    QTextStream authStream;

    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    User::Infos infos=DialSetUser::get(); // méthode statique

    if(infos.annule)
        return;

    QHashIterator<QString, QString> iterateur(authTable);

    while(iterateur.hasNext()) // vérif que le pseudo n'est pas utilisé
    {
        iterateur.next();
        if(iterateur.key() == infos.pseudo)
        {
            QMessageBox::warning(this, "Erreur", "Le pseudo choisi est déjà utilisé.");
            return;
        }
    }

    authStream.readAll(); // aller à la fin du fichier
    authStream << infos.pseudo+';'+infos.hashmdp+'\n';

    QList<QStandardItem *> items; // ajout du nouvel utilisateur au modèle
    items << new QStandardItem(infos.pseudo) << new QStandardItem(infos.hashmdp);
    modele->appendRow(items);
    tableau->resizeColumnsToContents();

    f_auth.close();
}

void GereComptes::slotSetUser()
{
    QFile f_auth;
    QTextStream authStream;
    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    QModelIndex setIndex=tableau->selectionModel()->currentIndex();
    if(!setIndex.isValid()) // index invalide, pas de selection
    {
        QMessageBox::warning(this, "Aucune sélection", "Aucun item n'est sélectionné.");
        return;
    }

    int setRow=setIndex.row(); // récupère l'ID de la ligne sélectionnée
    QString basePseudo=modele->item(setRow, 0)->data(Qt::DisplayRole).toString(); // recup le pseudo actuel
    QString baseHash=modele->item(setRow, 1)->data(Qt::DisplayRole).toString(); // récup le hash actuel
    User::Infos infos=DialSetUser::get(basePseudo, baseHash);

    if(infos.annule) // si l'user a annulé
        return;

    if(infos.pseudo != basePseudo || infos.hashmdp != baseHash) // si il y a eu une modif
    {

        if(infos.pseudo!=basePseudo) //vérif que le pseudo est libre
        {
            QHashIterator<QString, QString> iterateur(authTable);

            while(iterateur.hasNext())
            {
                iterateur.next();
                if(iterateur.key() == infos.pseudo)
                {
                    QMessageBox::warning(this, "Erreur", "Le pseudo choisi est déjà utilisé.");
                    return;
                }
            }
        }

        // recherche de la ligne du fichier
        QString setInfo=setIndex.data(Qt::DisplayRole).toString();
        bool isPseudo;
        if(setIndex.column() == 0)
            isPseudo=true;
        else if(setIndex.column() == 1)
            isPseudo=false;

        authStream.device()->seek(0);
        QString contenu;
        for(int i=0;!authStream.atEnd();i++)
        {
            QString ligne=authStream.readLine();
            QString info;
            if(isPseudo)
                info=ligne.section(';', 0, 0);
            else
                info=ligne.section(';', 1, 1);

            if(info != setInfo)
            {
                contenu+=ligne+'\n'; // on prend en mémoire toutes les lignes sauf celle à modif
            }
        }

        contenu += infos.pseudo+';'+infos.hashmdp+'\n'; // puis on ajoute à ça la ligne AVEC modifs

        f_auth.resize(0); // supprime le contenu du fichier
        authStream << contenu; // puis le réécrit

        modele->setItem(setRow, 0, new QStandardItem(infos.pseudo)); // édite la ligne du modèle
        modele->setItem(setRow, 1, new QStandardItem(infos.hashmdp));

        tableau->resizeColumnsToContents();
    }

    f_auth.close();
}

void GereComptes::slotDelUser()
{
    QFile f_auth;
    QTextStream authStream;
    f_auth.setFileName("auth.zla");
    if(!f_auth.open(QIODevice::ReadWrite | QIODevice::Text))
    {
        QMessageBox::critical(0, "zLogin : erreur", "Le programme \"zLogin\" a rencontré une erreur lors de l'ouverture de la liste des logins/mdps du zLogin.\nErreur : "+f_auth.errorString());
        close();
    }
    authStream.setDevice(&f_auth);


    QModelIndex delIndex=tableau->selectionModel()->currentIndex();
    if(!delIndex.isValid()) // index invalide, pas de selection
    {
        QMessageBox::warning(this, "Aucune sélection", "Aucun item n'est sélectionné.");
        return;
    }

    if(QMessageBox::warning(this, "Êtes-vous sûr ?", "Êtes-vous sûr de vouloir supprimer ce compte définitivement ?",
                            QMessageBox::No | QMessageBox::Yes, QMessageBox::No) == QMessageBox::No)
    {
        return;
    }

    QString delInfo=delIndex.data(Qt::DisplayRole).toString();
    bool isPseudo;
    if(delIndex.column() == 0)
        isPseudo=true;
    else if(delIndex.column() == 1)
        isPseudo=false;

    authStream.device()->seek(0);
    QString contenu;
    for(int i=0;!authStream.atEnd();i++)
    {
        QString ligne=authStream.readLine();
        QString info;
        if(isPseudo)
            info=ligne.section(';', 0, 0);
        else
            info=ligne.section(';', 1, 1);

        if(info != delInfo)
        {
            contenu+=ligne+'\n';
        }
    }

    f_auth.resize(0);
    authStream << contenu;

    modele->removeRow(delIndex.row());
    tableau->resizeColumnsToContents();

    f_auth.close();
}

void GereComptes::slotOk()
{
    closing=true;
    emit fini();
    close();
}

void GereComptes::closeEvent(QCloseEvent *event)
{
    if(!closing) // si on est pas passé par slotOk()
        slotOk();
    else
        event->accept();
}

DialSetUser

Assez simple celui-là, ça va aller vite !

Commençons par dialsetuser.h

#ifndef DIALSETUSER_H
#define DIALSETUSER_H

#include <QDialog>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QFormLayout>
#include <QLineEdit>
#include <QPushButton>
#include <QString>
#include <QMessageBox>

#include "fonctions.h"

class User // oui, je suis flemmard. C'est plus court comme ça.
{
public:
    struct Infos // structure contenant toutes les infos renvoyées par le dialogue.
    {
        QString pseudo;
        QString hashmdp;
        bool annule;
    };
};

class DialSetUser : public QDialog
{
Q_OBJECT

public:
    DialSetUser(User::Infos *out_infos, QString in_pseudo=QString(), QString in_hash=QString()); // in_pseudo et in_hash sont des paramètres facultatifs. Si ils ont été donnés, ce sont les valeurs par défaut.
    static User::Infos get(QString pseudo=QString(), QString hash=QString()); // méthode statique permettant d'appeler le dialogue sans créer un objet.

private slots:
    void slotOk();
    void slotAnnule();

private:
    QVBoxLayout *l_principal;
    QFormLayout *l_form;
    QLineEdit *linePseudo;
    QLineEdit *linePass;
    QLineEdit *linePass2;
    QHBoxLayout *l_boutons;
    QPushButton *b_ok;
    QPushButton *b_annule;

    User::Infos *infos; // pointeur vers la structure passée en paramètre du constructeur
    QString defhash;
};

#endif // DIALSETUSER_H

Seul truc un peu bizarre : je crée ici deux classes, dont une quasi-vide. En fait, la classe User ne contient qu'une déclaration structure, qui servira à retourner les informations entrées dans le dialogue. Par flemme de réécrire DialSetUser::Infos partout (oui, je confirme ce qu'on dit sur les programmeurs et la flemme :D ), j'ai créé une classe appelée User, comme ça, j'aurai juste besoin de marquer User::Infos. Sinon, DialSetUser est une classe héritant de QDialog.

On inclut fonctions.h, car on aura besoin de hacher le mot de passe. La QString defhash contient ici le hash passé en paramètre du constructeur, permettant de donner une valeur par défaut si on appelle le dialogue pour éditer un utilisateur.

DialSetUser() (constructeur)

DialSetUser::DialSetUser(User::Infos *out_infos, QString in_pseudo, QString in_hash)
{
    QString passLabelEnd=""; // permet d'afficher un message ou non en fonction des paramètres passés
    if(in_pseudo.isEmpty() && in_hash.isEmpty())
        setWindowTitle("Ajouter un utilisateur");
    else
    {
        passLabelEnd=" (laisser vide\npour aucun changement)";
        setWindowTitle("Modifier un utilisateur");
    }

    defhash=in_hash; // hash par défaut

    setWindowIcon(QIcon(":/icones/prog"));

    infos=out_infos;

    infos->annule=true; // si fermé, considéré comme annuler

    // ===== GUI ======
    l_principal=new QVBoxLayout;
    l_form=new QFormLayout;
    linePseudo=new QLineEdit;
    linePseudo->setText(in_pseudo);
    l_form->addRow("Pseudo",linePseudo);
    linePass=new QLineEdit;
    linePass->setEchoMode(QLineEdit::Password);
    l_form->addRow("Mot de passe"+passLabelEnd, linePass);
    linePass2=new QLineEdit;
    linePass2->setEchoMode(QLineEdit::Password);
    l_form->addRow("Confirmez le mot de passe", linePass2);
    l_principal->addLayout(l_form);

    l_boutons=new QHBoxLayout;
    b_annule=new QPushButton(QIcon(":/icones/cancel"), "Annuler");
    l_boutons->addWidget(b_annule);
    b_ok=new QPushButton(QIcon(":/icones/accept"), "Ok");
    b_ok->setDefault(true);
    l_boutons->addWidget(b_ok);
    l_principal->addLayout(l_boutons);

    setLayout(l_principal);

    // ===== connexions =====
    connect(b_annule, SIGNAL(clicked()), this, SLOT(slotAnnule()));
    connect(b_ok, SIGNAL(clicked()), this, SLOT(slotOk()));
}

On crée une QString qui sera affichée à la fin du texte associé au champ de MdP, ce qui permet de dire, dans le cas où on a passé un hash en paramètre, que le mot de passe est facultatif.
Ensuite, rien de spécial, on fait pointer infos sur out_infos, soit le paramètre qu'on a reçu, ce qui permet de retourner les infos saisies, puis on définit la GUI (en définissant comme valeur par défaut de linePseudo in_pseudo).

slotAnnule() (appelé par un clic sur "Annuler")

void DialSetUser::slotAnnule()
{
    infos->annule=true;
    close();
}

On définit annuler (booléen contenu dans infos, la structure de retour) à true, puis on ferme le dialogue.

slotOk() (appelé par un clic sur "Ok")

void DialSetUser::slotOk()
{
    if(linePseudo->text().isEmpty())
    {
        QMessageBox::warning(this, "Erreur", "Tous les champs doivent être remplis !");
        return;
    }

    if(linePass->text() != linePass2->text())
    {
        QMessageBox::warning(this, "Erreur", "Les mots de passe ne correspondent pas.");
        return;
    }

    if(linePseudo->text().contains(';'))
    {
        QMessageBox::warning(this, "Erreur", "Le pseudo contient des caractères interdits.");
        return;
    }

    QString hashpass=linePass->text();
    if(hashpass.isEmpty())
    {
        if(defhash.isEmpty())
        {
            QMessageBox::warning(this, "Erreur", "Tous les champs doivent être remplis !");
            return;
        }
        else
        {
            hashpass=defhash;
        }
    }
    else
        hashpass=Fonctions::hash(hashpass);

    infos->annule=false;
    infos->pseudo=linePseudo->text();
    infos->hashmdp=hashpass;
    close();
}

On vérifie que la ligne du pseudo n'est pas vide, que les deux mdp sont identiques, que le pseudo ne contient pas de ';' (ça ferait pas bon ménage dans auth.zla, mais pour le mot de passe c'est pas grave, vu qu'il sera haché), et que le mot de passe, si aucun par défaut n'est défini, ne soit pas vide.
Puis on hache le mdp, on définit les valeurs de infos avec ce qu'il faut y mettre, puis on ferme le dialogue.

get() (appelé depuis l'extérieur)

User::Infos DialSetUser::get(QString pseudo, QString hash)
{
    User::Infos retour; // on crée une structure à retourner,
    DialSetUser dial(&retour, pseudo, hash); // on crée un dialogue
    dial.exec();
    return retour; // puis on retourne la structure
}

C'est quoi cette méthode bizarre qui sert à rien ?

C'est une méthode que je crée tout le temps dans mes dialogues, qui m'évite de devoir créer un objet, l'exécuter, etc.
En fait, cette méthode statique se charge de créer un objet, de l'exécuter, et de retourner tout simplement les valeurs de retour. Comme ça, quand j'ai besoin d'ouvrir ce dialogue, il me suffit de faire

User::Infos infos=DialSetUser::get();

Sinon, on devrait faire :

User::Infos infos;
DialSetUser dialogue(&infos);
dialogue.exec();

Avouez que c'est un peu plus long !

Eh bien voilà, on en a fini avec notre DialSetUser !
Code complet :

#include "dialsetuser.h"

DialSetUser::DialSetUser(User::Infos *out_infos, QString in_pseudo, QString in_hash)
{
    QString passLabelEnd=""; // permet d'afficher un message ou non en fonction des paramètres passés
    if(in_pseudo.isEmpty() && in_hash.isEmpty())
        setWindowTitle("Ajouter un utilisateur");
    else
    {
        passLabelEnd=" (laisser vide\npour aucun changement)";
        setWindowTitle("Modifier un utilisateur");
    }

    defhash=in_hash; // hash par défaut

    setWindowIcon(QIcon(":/icones/prog"));

    infos=out_infos;

    infos->annule=true; // si fermé, considéré comme annuler

    // ===== GUI ======
    l_principal=new QVBoxLayout;
    l_form=new QFormLayout;
    linePseudo=new QLineEdit;
    linePseudo->setText(in_pseudo);
    l_form->addRow("Pseudo",linePseudo);
    linePass=new QLineEdit;
    linePass->setEchoMode(QLineEdit::Password);
    l_form->addRow("Mot de passe"+passLabelEnd, linePass);
    linePass2=new QLineEdit;
    linePass2->setEchoMode(QLineEdit::Password);
    l_form->addRow("Confirmez le mot de passe", linePass2);
    l_principal->addLayout(l_form);

    l_boutons=new QHBoxLayout;
    b_annule=new QPushButton(QIcon(":/icones/cancel"), "Annuler");
    l_boutons->addWidget(b_annule);
    b_ok=new QPushButton(QIcon(":/icones/accept"), "Ok");
    b_ok->setDefault(true);
    l_boutons->addWidget(b_ok);
    l_principal->addLayout(l_boutons);

    setLayout(l_principal);

    // ===== connexions =====
    connect(b_annule, SIGNAL(clicked()), this, SLOT(slotAnnule()));
    connect(b_ok, SIGNAL(clicked()), this, SLOT(slotOk()));
}

void DialSetUser::slotAnnule()
{
    infos->annule=true;
    close();
}

void DialSetUser::slotOk()
{
    if(linePseudo->text().isEmpty())
    {
        QMessageBox::warning(this, "Erreur", "Tous les champs doivent être remplis !");
        return;
    }

    if(linePass->text() != linePass2->text())
    {
        QMessageBox::warning(this, "Erreur", "Les mots de passe ne correspondent pas.");
        return;
    }

    if(linePseudo->text().contains(';'))
    {
        QMessageBox::warning(this, "Erreur", "Le pseudo contient des caractères interdits.");
        return;
    }

    QString hashpass=linePass->text();
    if(hashpass.isEmpty())
    {
        if(defhash.isEmpty())
        {
            QMessageBox::warning(this, "Erreur", "Tous les champs doivent être remplis !");
            return;
        }
        else
        {
            hashpass=defhash;
        }
    }
    else
        hashpass=Fonctions::hash(hashpass);

    infos->annule=false;
    infos->pseudo=linePseudo->text();
    infos->hashmdp=hashpass;
    close();
}

User::Infos DialSetUser::get(QString pseudo, QString hash)
{
    User::Infos retour; // on crée une structure à retourner,
    DialSetUser dial(&retour, pseudo, hash); // on crée un dialogue
    dial.exec();
    return retour; // puis on retourne la structure
}

Fonctions

Cette fois, on attaque la dernière classe, très courte en plus !

Allez, c'est parti pour le fonctions.h :

#ifndef FONCTIONS_H
#define FONCTIONS_H

#include <QString>
#include <QCryptographicHash>
#include <QByteArray>

#define SEL_BEFORE "*D9)'Jj89K"
#define SEL_AFTER "^,iU078Jng"

class Fonctions
{
public:
    Fonctions();
    static QString hash(QString input, bool alreadyMd5=false);
};

#endif // FONCTIONS_H

Pas bien complexe, hein ?
En fait, cette classe n'est pas faite pour être instanciée, mais pour contenir des méthodes statiques.

Pourquoi ne pas faire simplement des fonctions, sans classe ?

J'y ai pensé. Mais ainsi, on regroupe toutes les fonctions dans un "ensemble" (même si il n'y en a qu'une, si le programme évolue, il peut y en avoir plus).
Je fais également deux defines, pour les sels.

fichier.cpp est tellement court que je vais vous le donner d'un seul coup :

#include "fonctions.h"

Fonctions::Fonctions()
{
}

QString Fonctions::hash(QString input, bool alreadyMd5)
{
    if(!alreadyMd5)
    {
        QByteArray ba_input=QCryptographicHash::hash(input.toUtf8(), QCryptographicHash::Md5);
        input=ba_input.toHex();
    }
    QByteArray ba_hash=QCryptographicHash::hash(QCryptographicHash::hash(QString(SEL_BEFORE).toUtf8(), QCryptographicHash::Md4) +
                                                input.toUtf8() +
                                                QCryptographicHash::hash(QString(SEL_AFTER).toUtf8(), QCryptographicHash::Md4),
                                                QCryptographicHash::Sha1); // hachage d'input, avec sels.
    return ba_hash.toHex();
}

Le constructeur est vide, puisque la classe ne sera pas instanciée.
La méthode statique hash() contient tout ce qu'on a vu dans le chapitre sur le hachage. Elle effectue les actions suivantes :

Si l'input n'est pas déjà haché en MD5, on le hache.
On hache avec des sels : SEL_BEFORE est haché en MD4, puis ajouté au MdP (déjà haché en MD5), et le tout est ajouté à SEL_AFTER, lui aussi haché en MD4. Puis, le tout est haché en SHA-1.
On convertit ça en chaîne de caractères avec toHex()
On retourne la chaîne obtenue

Eh bien, je vous annonce que le zLogin est terminé !!!
En réalisant ce TP, je l'ai pas trouvé très complexe, mais long. Si vous l'avez réussi, félicitations ! Maintenant, vous n'avez plus qu'à créer des programmes qui l'utilisent :-° .

J'espère que ce TP vous a plu, que vous l'avez réussi et qu'il ne vous a pas paru trop long ou dur (le premier qui pense à Mozinor a gagné :-° ).

Si vous l'avez réussi, c'est que vous maîtrisez maintenant le hachage, les tables de hachage et les ressources Qt !

Et voilà, c'est fini !

Mais ce tuto n'est pas fermé ! Ainsi, si je pense à une autre fonctionnalité de Qt n'utilisant pas la GUI, j'ajouterai sûrement un chapitre à ce tuto. Je ne peux pas dire à l'avance si le cours sera continué ou non, et sur combien de chapitres !

Sinon, j'espère que vous avez compris sans problème ce cours, et que vous l'avez trouvé bien !

Bonne programmation à tous !
@+, Tobast.

Tutoriel : Qt : Quelques fonctionnalités non-GUI

Table des matières

Qt : Quelques fonctionnalités non-GUI

Utiliser les ressources Qt

Présentation

Présentation

Créer le fichier de ressources

Créer le fichier de ressources

Structure d'un fichier de ressources Qt

Créer le fichier de ressources

"À la main"

Avec Qt Creator

Bonus : l'Éditeur de ressources Qt !

Utiliser le fichier ressource

Utiliser le fichier ressource

Hacher avec Qt

Théorie

Théorie

Hacher avec Qt

Hacher avec Qt

Plus de sécurité ?

Les tables de hachage

Théorie

Théorie

Avec Qt

Avec Qt

Méthode 1 : comme avec un tableau

Méthode 2 : avec des méthodes

Ajouter un item

Tester l'existence d'une clé

Récupérer le nombre d'items contenus dans la table de hachage

Récupérer une valeur

Récupérer une clé

Supprimer un item

Ajouter une valeur à une clé

Récupérer DES valeurs

Méthode de lecture : les itérateurs

Clé et valeur actuelle

Tester l'existence des items suivants/précédents

Avancer/reculer la position actuelle

Item précédent/suivant

Aller au début/à la fin

Rechercher vers l'avant/vers l'arrière

Récupérer toutes les valeurs : foreach()

TP : le zLogin

Présentation du sujet

Présentation du sujet

Vue d'ensemble

Schéma des paquets

Paquets entrants : pseudos/hashs mdp

paquets sortants : connexion acceptée/refusée

Fonctionnalités gérées par le zLogin

Dernières recommandations

Correction

Correction

TrayIcon

Non-réseau

Réseau

GereComptes

DialSetUser

Fonctions