Probleme Réseau C++

Bonjour, j'ai un problème avec mon application qui fonctionnais très bien jusqu’à maintenant.
Je n'ai pas changé le code.
Et j'ai pourtant une erreur dans mon code.
Les transferts réseaux s’exécutent correctement sauf lorsque je veux écrire dans le fichier.

Voici mon code :

Main Client :


#include <QtGui>
#include <FenClient.h>
#include <QApplication>

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

QApplication app(argc, argv);

FenClient fen;


fen.show();



return app.exec();
}



FenClient :


#include "FenClient.h"
#include "Pass.h"

#include <QTreeWidget>

FenClient::FenClient()
{

resize(1000, 800);

// Création et affichage de la fenetre permettant le choix du repertoire de téléchargement

// Création des widget qui affichent l'arbre avec les données de l'ordinateur
QVBoxLayout *layout = new QVBoxLayout;
modele = new QDirModel;
vue = new QTreeView;
vue->setModel(modele);

// Création du label qui demande de choisir un fichier
labelChoixRepertoire = new QLabel();
labelChoixRepertoire->setText("Choissisez le dossier dans le quel vous souhaitez enregistrer vos fichiers");

// CRéation bouton
QPushButton *button = new QPushButton();
button->setText("Choisir ce repertoire");

// Insertion dans les layouts
layout->addWidget(labelChoixRepertoire);
layout->addWidget(vue);
layout->addWidget(button);

setLayout(layout);

connect(button,SIGNAL(clicked()),this,SLOT(fichierChoisie()));

}

void FenClient::fichierChoisie(){

// Si le fichier choisi est un fichier ou un disque dur on demande de choisir un dossier

if(modele->fileInfo(vue->currentIndex()).isFile() || modele->fileInfo(vue->currentIndex()).isRoot() ){

labelChoixRepertoire->setText("Ceci n'est pas un dossier");

}

// Sinon on recupere le nom du fichier choisie et on l'affect à la variable permettant d'ecriren dans un dossier puis on
// créer la fenetre de connection au serveur


else {

// On ferme la fenetre
repertoireDesFichiers = modele->filePath(vue->currentIndex())+"/";

close();

// Création de la fenetre

QWidget *fen = new QWidget();
fen->setWindowIcon(QIcon(QApplication::applicationDirPath()+"/client.jpg"));
fen->resize(1000,800);

// Création des layout

layout = new QVBoxLayout;
QHBoxLayout *layoutConfigServeur = new QHBoxLayout();
QHBoxLayout *layoutPath = new QHBoxLayout();


fen->setLayout(layout);


// Création de l'arbre

tree = new QTreeWidget(this);
tree->setVisible(false);

boutonConnecter = new QPushButton();
boutonConnecter->setText("Se connecter");

//Initialisation des widgets

socket = new QTcpSocket(this);
labelText = new QLabel();




telechargement = new QLabel();


// On ajoute nos widgets au layouts
// Configuration serveur
layout->addLayout(layoutConfigServeur);
layout->addLayout(layoutPath);

QLabel *labelNomServeur = new QLabel();
labelNomServeur->setText("Adresse du serveur");
QLabel *labelPorServeur = new QLabel();
labelPorServeur->setText("N° de port du serveur");
adresseServeur = new QLineEdit();
adresseServeur->setText("127.0.0.1");
portServeur = new QSpinBox();
portServeur->setMaximum(100000);
portServeur->setValue(50885);

layoutConfigServeur->addWidget(labelNomServeur);
layoutConfigServeur->addWidget(adresseServeur);
layoutConfigServeur->addWidget(labelPorServeur);

layoutConfigServeur->addWidget(portServeur);
layoutConfigServeur->addWidget(boutonConnecter);


layout->addWidget(telechargement);
layout->addWidget(labelText);

setLayout(layout);
connect(boutonConnecter,SIGNAL(clicked()),this,SLOT(seConnecter()));
connect(socket, SIGNAL(readyRead()), this, SLOT(donneesRecues()));
connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(erreurSocket(QAbstractSocket::SocketError)));

tailleMessage = 0;


fen->show();

}
}



void FenClient::seConnecter(){


socket->abort(); // On désactive les connexions précédentes s'il y en a
socket->connectToHost(adresseServeur->text(), portServeur->value()); // On se connecte au serveur demande

pass = new Pass();
pass->setFenClient(this);
pass->show();

}


void FenClient::itemSelectionne(){


// Si aucun fichier est en cour de téléchargement

if(telechargement->text() != "Téléchargement en cours..."){

// On recupere l'item clicker et on envoye au serveur le nom du fichier que l'on veux télécharger
for(int i = 0; i < tree->selectedItems().size(); i++ ){

// Si on a selectionné un fichier

if(tree->selectedItems().at(i)->isSelected() == true){

telechargement->setText("Téléchargement en cours...");

// On stock le nom récupérer dans une variable
QString nomDufichierATelecharger = tree->selectedItems().at(i)->text(i);

nomDufichierATelecharger.append("&");

// objet envoyé sur le réseau contenant les informations
QByteArray paquet;

QDataStream out(&paquet, QIODevice::WriteOnly);
// On récupere le nom de l'item qui a été selectionné
// On écrit 0 au début du paquet pour réserver la place pour écrire la taille

out << (quint64) 0;
// On ajoute le nom notre item a notre paquet
out << nomDufichierATelecharger;
out.device()->seek(0); // On se replace au début du paquet
out << (quint64) (paquet.size() - sizeof(quint64)); // On écrase le 0 qu'on avait réservé par la longueur du message

socket->write(paquet); // On envoie le paquet
qDebug() << "nomfichier"+nomDufichierATelecharger;
itemATelecharger = nomDufichierATelecharger;

}
}
}
else{
telechargement->setText("Veuilliez attendre la fin du téléchargement avant d'en commencer un autre ");
}
}



void FenClient::deconnexionClient(){

QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
return;


socket->deleteLater();
}

void FenClient::donneesRecues()
{
qDebug() << "Les données sont bien reçu";

/* Même principe que lorsque le serveur reçoit un paquet :
On essaie de récupérer la taille du message
Une fois qu'on l'a, on attend d'avoir reçu le message entier (en se basant sur la taille annoncée tailleMessage)
*/


// On verrifie si un mot de pass est demandé

qDebug()<< "J'ai reçu les données";
boutonConnecter->setEnabled(false);

QDataStream in(socket);

if (tailleMessage == 0)
{
if (socket->bytesAvailable() < (int)sizeof(quint64))
return;

in >> tailleMessage;
}

qDebug << "socket"+socket->bytesAvailable();
qDebug << "taille"+tailleMessage;



// Si on arrive jusqu'à cette ligne, on peut récupérer le message entier



if(pass->isVisible()){


QString messageRecu;
in >> messageRecu;
qDebug() << "mON PASS"+messageRecu;
passServeur = messageRecu;


if(messageRecu == "PassCorrect"){

// On ferme la fenetre et on envoyer le nom du repertoire rechercher
pass->close();
receptionList = "ok";


qDebug() << "Envoyer Message";

QByteArray paquet;
QDataStream out(&paquet, QIODevice::WriteOnly);

// On prépare le paquet à envoyer
QString messageAEnvoyer = "CHEMIN";

out << (quint64) 0;
out << messageAEnvoyer;
out.device()->seek(0);
out << (quint64) (paquet.size() - sizeof(quint64));

socket->write(paquet); // On envoie le paquet

}
else{
}
qDebug() << "list"+receptionList;
}


else if (receptionList == "ok"){

receptionList = "fini";
QDataStream in(socket);

if (tailleMessage == 0)
{
if (socket->bytesAvailable() < (int)sizeof(quint64))
return;

in >> tailleMessage;
}

qDebug()<<socket->bytesAvailable();
qDebug()<<tailleMessage;

if (socket->bytesAvailable() < tailleMessage)
return;

qDebug() << "Il passe dans la methode";
// Si le message reçu est faux

QList<QString> messageRecu;
in >> messageRecu;

QString pass;
in >> pass;
qDebug() << "Mot de pass"+pass;
qDebug() << messageRecu;

tree->setVisible(true);

telechargement->setText("Double clikez sur un fichier pour le télécharger");



QString listDesMessages;
QTreeWidgetItem *item ;
QTreeWidgetItem *item2 ;

QString dossier = messageRecu.at(messageRecu.size()-1);
item = new QTreeWidgetItem(tree,0);
tree->selectedItems();
item->setText(0,dossier);
item->setIcon(0,QIcon(QApplication::applicationDirPath()+"/dossierIcon.jpg"));
qDebug() << QApplication::applicationDirPath();
connect(tree,SIGNAL(itemDoubleClicked(QTreeWidgetItem*,int)),this,SLOT(itemSelectionne()));


for(int i=0; i<messageRecu.size();i++){
qDebug() <<"Ma list"+messageRecu.at(i);
}

// On recupere la liste de messages qu'on affiche dans l'arborescencev
for(int i=0; i<messageRecu.size()-1;i++){

item2 = new QTreeWidgetItem(item,0);

item2->setText(0,messageRecu.at(i));

item2->setIcon(0,QIcon(QApplication::applicationDirPath()+"/fichierIcon.jpg"));

tree->addTopLevelItem(item);

}

layout->addWidget(tree);

qDebug() <<"liste2"+ listDesMessages;

labelText->setText(listDesMessages);
// On affiche le message sur la zone de Chat
// labelText->setText(messageRecu);

// On remet la taille du message à 0 pour pouvoir recevoir de futurs messages
}


else if(receptionList == "fini"){

QDataStream in(socket);

if (tailleMessage == 0)
{
if (socket->bytesAvailable() < (int)sizeof(quint64))
return;

in >> tailleMessage;
}

if (socket->bytesAvailable() < tailleMessage)
return;

// Si on arrive jusqu'à cette ligne, on peut récupérer le message entier

QByteArray message;
in >> message;

qDebug() << message.size();

itemATelecharger.remove(itemATelecharger.size()-1,1);
qDebug () << repertoireDesFichiers+itemATelecharger;

QFile fichier2(repertoireDesFichiers+itemATelecharger);

if(fichier2.open(QIODevice::WriteOnly | QIODevice::Truncate))
{
int i;
for(i = 0 ; i < message.size() ; i++)

fichier2.putChar(message.at(i));

qDebug()<<"Il passe";
fichier2.close();
telechargement->setText("Téléchargement Terminé");

tailleMessage = 0;

}

}
tailleMessage = 0;


}

void FenClient::erreurSocket(QAbstractSocket::SocketError erreur)
{
switch(erreur) // On affiche un message différent selon l'erreur qu'on nous indique
{
case QAbstractSocket::HostNotFoundError:
telechargement->setText(tr("<em>ERREUR : le serveur n'a pas pu être trouvé. Vérifiez l'IP et le port.</em>"));
break;
case QAbstractSocket::ConnectionRefusedError:
telechargement->setText(tr("<em>ERREUR : le serveur a refusé la connexion. Vérifiez si le programme \"serveur\" a bien été lancé. Vérifiez aussi l'IP et le port.</em>"));
break;
case QAbstractSocket::RemoteHostClosedError:
telechargement->setText(tr("<em>ERREUR : le serveur a coupé la connexion.</em>"));
break;
default:
telechargement->setText(tr("<em>ERREUR : ") + socket->errorString() + tr("</em>"));
}

boutonConnecter->setEnabled(true);
}

void FenClient::setPassword(QString aPassword){


verrificationPassword(aPassword);
}


void FenClient::verrificationPassword(QString aPassword){


QByteArray paquet;
QDataStream out(&paquet, QIODevice::WriteOnly);

// On prépare le paquet à envoyer

out << (quint64) 0;
out << aPassword;
out.device()->seek(0);
out << (quint64) (paquet.size() - sizeof(quint64));

socket->write(paquet); // On envoie le paquet
qDebug() <<"passeword"+aPassword;

}

QString FenClient::getMotDePassServeur(){

return passServeur;
}




Pass :


#include "Pass.h"

Pass::Pass(){

// On paramettre la fenetre
resize(500,200);
setWindowTitle("Demande d'autorisation");
layout = new QVBoxLayout();
setLayout(layout);

// On créer le label le le QLineEdit pour recuperer le mot de passe et le boouton de validation


QLabel *labelPassword = new QLabel();
labelPassword->setText("Veuiller entrer le mot de passe");
password = new QLineEdit();
password->setEchoMode(QLineEdit::Password);
QPushButton *valider = new QPushButton();
valider->setText("Valider");

layout->addWidget(labelPassword);

layout->addWidget(password);
layout->addWidget(valider);

label = new QLabel();
layout->addWidget(label);

connect(valider,SIGNAL(clicked()),this,SLOT(getPassword()));
}

void Pass::setFenClient(FenClient *aFen){

fen = aFen;
}

void Pass::getPassword(){

fen->setPassword(password->text());

if(fen->getMotDePassServeur() != password->text() || fen->getMotDePassServeur() == "" ){
label->setText("Mot de passe incorrect");
}
}

void Pass::keyPressEvent(QKeyEvent* event) {
getPassword();
}


FenClient.h :

#ifndef FENCLIENT_H
#define FENCLIENT_H

#include <QtGui>
#include <QtNetwork>

class Pass;

class FenClient : public QWidget
{

Q_OBJECT

public:
FenClient();
QLabel *labelText;
QTcpServer *serveur;
quint64 tailleMessage;
QTcpSocket *socket;
QList<QTcpSocket *> clients;
QPushButton *boutonConnecter;
QPushButton *boutonRemonter;
QString itemATelecharger;

QLineEdit *adresseServeur;
QSpinBox *portServeur;

QLineEdit *message;
QList<QString *> infosServeur;
QVBoxLayout *layout;
QTreeWidget *tree;
QLabel *telechargement;
Pass *pass;
QString repertoireDesFichiers;

QString receptionList;
QString passServeur;
QString getMotDePassServeur();

QTreeView *vue;
QDirModel *modele;

QLabel *labelChoixRepertoire;

void setPassword(QString aPassword);

private slots:

void erreurSocket(QAbstractSocket::SocketError erreur);
void seConnecter();
void deconnexionClient();
void donneesRecues();
void itemSelectionne();
void verrificationPassword(QString aPassword);
void fichierChoisie();

private:
};

#endif // FENCLIENT_H




Pass.h :

#ifndef PASS_H
#define PASS_H
#include <QtGui>
#include "FenClient.h"
#include <QKeyEvent>


class Pass : public QWidget
{

Q_OBJECT

public:

Pass();
QLabel *label;
FenClient *fen;
QLineEdit *password;
QVBoxLayout *layout;
void setFenClient(FenClient *aFen);
void getMotDePassServeur();
void keyPressEvent(QKeyEvent* event);
//void keyReleaseEvent(QKeyEvent* event);

private slots:
void getPassword();
private:


};

#endif // PASS_H





Le serveur


Serveur Main :


#include <QApplication>
#include "FenServeur.h"

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

FenServeur fenetre;




fenetre.show();
return app.exec();
}



FenServeur :


#include "FenServeur.h"

FenServeur::FenServeur()
{

etatServeur = new QLabel();
QHBoxLayout *layout = new QHBoxLayout();
etatServeur->setText("Test");
layout->addWidget(etatServeur);
setLayout(layout);
pass = true;
serveur = new QTcpServer(this);

if (!serveur->listen(QHostAddress::Any, 50885)) // Démarrage du serveur sur toutes les IP disponibles et sur le port 50585
{
// Si le serveur n'a pas été démarré correctement
etatServeur->setText(tr("Le serveur n'a pas pu être démarré. Raison :<br />") + serveur->errorString());
}
else
{
// Si le serveur a été démarré correctement
etatServeur->setText(tr("Le serveur a été démarré sur le port <strong>") + QString::number(serveur->serverPort()) + tr("</strong>.<br />Des clients peuvent maintenant se connecter."));
connect(serveur, SIGNAL(newConnection()), this, SLOT(nouvelleConnexion()));

}

pass = true;
tailleMessage = 0;

}



void FenServeur::fichierChoisie(){

qDebug() << modele->filePath(vue->currentIndex());


}

void FenServeur::nouvelleConnexion()
{
etatServeur->setText("Coonexion d'un nouveau client");
QTcpSocket *nouveauClient = serveur->nextPendingConnection();
clients << nouveauClient;// On ajoute le nouveau client


connect(nouveauClient,SIGNAL(readyRead()),this,SLOT(cheminRepertoire()));
// connect(nouveauClient, SIGNAL(readyRead()), this, SLOT(donneesRecues()));

}


void FenServeur::cheminRepertoire(){


// 1 : on reçoit un paquet (ou un sous-paquet) d'un des clients
qDebug() << "donnéesreçu";
// On détermine quel client envoie le message (recherche du QTcpSocket du client)
QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
return;


// Si tout va bien, on continue : on récupère le message
QDataStream in(socket);
if (tailleMessage == 0) // Si on ne connaît pas encore la taille du message, on essaie de la récupérer
{
if (socket->bytesAvailable() < (int)sizeof(quint16)) // On n'a pas reçu la taille du message en entier
return;

in >> tailleMessage; // Si on a reçu la taille du message en entier, on la récupère

}

// Si on connaît la taille du message, on vérifie si on a reçu le message en entier
if (socket->bytesAvailable() < tailleMessage) // Si on n'a pas encore tout reçu, on arrête la méthode
return;


// Si ces lignes s'exécutent, c'est qu'on a reçu tout le message : on peut le récupérer !
QString messageRecu;
in >> messageRecu;

qDebug() << messageRecu;
message = messageRecu ;
qDebug()<< "MessageRecurepertoire"+messageRecu;
qDebug() << message;

// 2 : on renvoie le message à tous les clients
etatServeur->setText(messageRecu);

// 3 : remise de la taille du message à 0 pour permettre la réception des futurs messages
tailleMessage = 0;


// On verrifie si le serveur est proteger par un mot de pass


if(pass == true){

qDebug()<< "passEnvoyé test"+messageRecu;

if(messageRecu == "691KJO"){

qDebug() << "Message691kjo"+messageRecu;
// On envoyer les données au client pour lui dire que le mot de pass est bon
qDebug()<< "testpassok";
QByteArray paquet;
QDataStream out(&paquet, QIODevice::WriteOnly);

// On prépare le paquet à envoyer
QString messageAEnvoyer = "PassCorrect";

out << (quint64) 0;
out << messageAEnvoyer;
out.device()->seek(0);
out << (quint64) (paquet.size() - sizeof(quint64));

for (int i = 0; i < clients.size(); i++)
{
qDebug() << "Envoye des donnés au client ";
clients[i]->write(paquet);
}

}
}


if(messageRecu.at(messageRecu.size()-1) == '&'){
messageRecu.remove(messageRecu.size()-1,1);

QFile fichier1("C:/ServeurPTI/"+messageRecu);
qDebug()<< "C:/ServeurPTI/"+messageRecu;
QByteArray array;

if(fichier1.open(QIODevice::ReadOnly))
{
// pour créer le fichier test

qDebug()<<"Passe dans la création du fichier";
char caractere = 0;

// par un QByteArray

while(fichier1.getChar(&caractere))
{
array += caractere;
}

qDebug() << array.size();


fichier1.close();
}

QByteArray paquet;
QDataStream out(&paquet, QIODevice::WriteOnly);
// On récupere le nom de l'item qui a été selectionné
// On écrit 0 au début du paquet pour réserver la place pour écrire la taille

out << (quint64) 0;
// On ajoute le nom notre item a notre paquet
out << array;
out.device()->seek(0); // On se replace au début du paquet
out << (quint64) (paquet.size() - sizeof(quint64)); // On écrase le 0 qu'on avait réservé par la longueur du message

for (int i = 0; i < clients.size(); i++)
{
qDebug() << "Envoye des donnés au client ";
clients[i]->write(paquet);
}


}

else{

qDebug()<< "TestElse";
dossierParent = "C:/ServeurPTI/" ;
for(int i = 0; i < fichiersList.size();i++){
fichiersList.removeAt(i);
}

qDebug() << "DossierParent"+dossierParent;

rechercheDonnees(dossierParent);
fichiersList.append(dossierParent);

// On recupere les données du serveur

QByteArray paquet;
QDataStream out(&paquet, QIODevice::WriteOnly);

// On prépare le paquet à envoyer
QString messageAEnvoyer = message;
message ="Mon message";
etatServeur->setText(message);
qDebug() << "Mon message"+message;

out << (quint64) 0;
out << fichiersList;
out.device()->seek(0);
out << (quint64) (paquet.size() - sizeof(quint64));


for(int i=0; i<fichiersList.size();i++){
}
for (int i = 0; i < clients.size(); i++)
{
clients[i]->write(paquet);
}
}


}
// On recupere les données du fichier


void FenServeur::donneesRecues()
{


// 1 : on reçoit un paquet (ou un sous-paquet) d'un des clients
qDebug() << "donnéesreçu";
// On détermine quel client envoie le message (recherche du QTcpSocket du client)
QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
return;

// Si tout va bien, on continue : on récupère le message
QDataStream in(socket);

if (tailleMessage == 0) // Si on ne connaît pas encore la taille du message, on essaie de la récupérer
{
if (socket->bytesAvailable() < (int)sizeof(quint16)) // On n'a pas reçu la taille du message en entier
return;

in >> tailleMessage; // Si on a reçu la taille du message en entier, on la récupère
}

// Si on connaît la taille du message, on vérifie si on a reçu le message en entier
if (socket->bytesAvailable() < tailleMessage) // Si on n'a pas encore tout reçu, on arrête la méthode
return;


// Si ces lignes s'exécutent, c'est qu'on a reçu tout le message : on peut le récupérer !

QString messageRecu;
in >> messageRecu;

qDebug() << messageRecu;
message = messageRecu ;
qDebug()<< "MessageRecu"+messageRecu;
qDebug() << message;

// 2 : on renvoie le message à tous les clients
etatServeur->setText(messageRecu);

// 3 : remise de la taille du message à 0 pour permettre la réception des futurs messages
tailleMessage = 0;

// On recupere les données du fichier


// on ouvre le premier fichier

QFile fichier1("C:/Test/Test.txt");
if(fichier1.open(QIODevice::ReadOnly) )
{

char caractere = 0;

QByteArray array;

while(fichier1.getChar(&caractere))
{
array += caractere;
qDebug() << caractere;
}



fichier1.close();

QByteArray paquet;
QDataStream out(&paquet, QIODevice::WriteOnly);

out << (quint64) 0;
out << array;
out.device()->seek(0);
out << (quint64) (paquet.size() - sizeof(quint64));

for (int i = 0; i < clients.size(); i++)
{
qDebug() << "Envoye des donnés au client ";
clients[i]->write(paquet);
}
}
}

void FenServeur::deconnexionClient()
{
/*
envoyerATous(tr("<em>Un client vient de se déconnecter</em>"));

// On détermine quel client se déconnecte
QTcpSocket *socket = qobject_cast<QTcpSocket *>(sender());
if (socket == 0) // Si par hasard on n'a pas trouvé le client à l'origine du signal, on arrête la méthode
return;

clients.removeOne(socket);

socket->deleteLater();
*/
}


void FenServeur::rechercheDonnees(QString sousRepertoire){




QFileInfo qmake (QString ("C") );

QDir dir(sousRepertoire);



foreach(qmake, dir.entryInfoList()) {

if(qmake.isDir()==true){

if(qmake.fileName() != ".."){

if(qmake.fileName() != "."){

QString path = qmake.filePath();
rechercheDonnees(path);
}
}
}
else{
fichiersList.append(qmake.fileName()); qDebug () << "Fichier :"+qmake.fileName();
}
}



}

void FenServeur::envoyerATous(const QString &message)
{

}



FenServeur.h :


#ifndef HEADER_FENSERVEUR
#define HEADER_FENSERVEUR

#include <QtGui>
#include <QtNetwork>


class FenServeur : public QWidget
{
Q_OBJECT

public:
FenServeur();

void rechercheDonnees(QString sousRepertoire);

void envoyerATous(const QString &message);

private slots:
void cheminRepertoire();
void nouvelleConnexion();
void donneesRecues();
void deconnexionClient();
void fichierChoisie();

private:
QLabel *etatServeur;
QPushButton *boutonQuitter;
bool pass;
QString message;
QTcpServer *serveur;
QList<QTcpSocket *> clients;
QList<QString> fichiersList;
quint64 tailleMessage;
QString dossierParent;
QTreeView *vue;
QDirModel *modele;

};

#endif




Mais le téléchargement ne s’effectue plus, il reste sur téléchargement en cour...

Mettre ton code dans les balises codes va aider à la lecture.