Bonjour a tous,

J'ai créer une application en suivant le cours de C++ qui devrait permettre d’échanger grâce au réseau.

J'ai aussi un serveur. Enfin mon code est exactement le même que sur cette page: https://openclassrooms.com/fr/courses/1894236-programmez-avec-le-langage-c/1902751-communiquez-en-reseau-avec-son-programme  .

Pourtant aucun client autre que mon ordinateur n'arrive a se connecter.

Savez vous d'ou peu venir le problème?

Merci d'avance!

Salut,

Sans code, on ne pourra pas t'aider.

Voici mon code:

Pour le client:

fenetreclient.h:

#ifndef FENETRECLIEN_H
#define FENETRECLIEN_H

#include <QMainWindow>
#include <QtNetwork>
#include<QApplication>
#include<QTcpSocket>
#include<QTcpServer>
#include "ui_fenetreclien.h"
#include<QWidget>

namespace Ui
{
class FenetreClien;
}

class FenetreClien : public QMainWindow
{
    Q_OBJECT

public:
    explicit FenetreClien(QWidget *parent = nullptr);
    ~FenetreClien();
private slots:
    void boutonConnection_cilque();
    void boutonEnvoyer_clique();
    void message_entre();
    void arriveeMsg();
    void connection();
    void deconnection();
    void erreurSocket();
private:
    Ui::FenetreClien *ui;
    QTcpSocket *socket;
    quint16 tailleMessage=0;
};

#endif // FENETRECLIEN_H

fenetreclient.cpp:

#include "fenetreclien.h"
#include "ui_fenetreclien.h"

FenetreClien::FenetreClien(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::FenetreClien)
{
    ui->setupUi(this);
    socket = new QTcpSocket(this);
    connect(socket, SIGNAL(readyRead()), this, SLOT(arriveeMsg()));
    connect(socket, SIGNAL(connected()), this, SLOT(connection()));
    connect(socket, SIGNAL(disconnected()), this, SLOT(deconnection()));
    connect(socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(erreurSocket(QAbstractSocket::SocketError)));
}

FenetreClien::~FenetreClien()
{
    delete ui;
    deconnection();
}
void FenetreClien::boutonConnection_cilque()
{
    ui->textEdit->append(tr("<em>Tentative de connection en cours...</em>"));
    ui->boutonConnection->setEnabled(false);
    socket->abort();
    socket->connectToHost(ui->adresseIPServeur->text(),ui->portEntreeServeur->value());
}
void FenetreClien::boutonEnvoyer_clique()
{
    QByteArray paquet;
    QDataStream messageSortant(&paquet,QIODevice::WriteOnly);
    QString messageAEnvoyer=tr("<strong>")+ui->nomUtilisateur->text()+tr(": </strong>")+ui->message->text();
    messageSortant<<quint16(0);
    messageSortant<<messageAEnvoyer;
    messageSortant.device()->seek(0);
    messageSortant<<quint16(paquet.size()-sizeof (quint16));
    socket->write(paquet);
    ui->message->clear();
    ui->message->setFocus();
}
void FenetreClien::message_entre()
{
    boutonEnvoyer_clique();
}
void FenetreClien::arriveeMsg()
{

        QDataStream messageEntrant(socket);

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

            messageEntrant >> tailleMessage;
        }

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

        QString messageRecu;
        messageEntrant >> messageRecu;

        ui->textEdit->append(messageRecu);

        tailleMessage = 0;
}
void FenetreClien::connection()
{
    ui->textEdit->append(tr("<em>Vous etes connectés!</em>"));
    ui->boutonConnection->setEnabled(true);
    ui->textEdit->setEnabled(true);
    ui->boutonEnvoiMessage->setEnabled(true);
}
void FenetreClien::deconnection()
{
    ui->textEdit->append(tr("<em>Vous etes deconnecté</em>"));
}
void FenetreClien::erreurSocket()
{
    ui->textEdit->append(tr("<em>Erreur:")+socket->errorString()+tr(".</em>"));
}

main.cpp:

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

int main(int argc, char *argv[])
{
    QApplication a(argc, argv);
    FenetreClien fenClient;
    fenClient.show();

    return a.exec();
}

fenetreclien.ui:

Pour le serveur:

fenetreserveur.h:

#ifndef FENETRESERVEUR_H
#define FENETRESERVEUR_H
#include<QFile>
#include <QObject>
#include <QWidget>
#include<QLabel>
#include<QPushButton>
#include<QTcpServer>
#include<QTcpSocket>
#include<QApplication>
#include<QVBoxLayout>
#include<QTextStream>
#include<fstream>
#include<string>
#include<ctime>

class fenetreServeur: public QWidget
{
    Q_OBJECT
public:
    fenetreServeur();
    void envoyerMessage(const QString & message);
private slots:
    void nouvelleConnection();
    void recevoirDonnes();
    void deconnection();

private:
    QLabel *etatServeur;
    QPushButton *fermetureServeur;
    QTcpServer *serveur;
    QList<QTcpSocket *> clients;
    quint16 tailleMessage;

};

#endif // FENETRESERVEUR_H

fenetreserveur.cpp:

#include "fenetreserveur.h"
using namespace std;
fenetreServeur::fenetreServeur()
{
    etatServeur=new QLabel;
    fermetureServeur=new QPushButton("Fermer le serveur");
    QObject::connect(fermetureServeur,SIGNAL(clicked()),qApp,SLOT(quit()));
    QVBoxLayout *lay=new QVBoxLayout;
    lay->addWidget(etatServeur);
    lay->addWidget(fermetureServeur);
    setLayout(lay);
    setWindowTitle(tr("Serveur"));
    serveur= new QTcpServer(this);
    if(!serveur->listen(QHostAddress::Any,21))
    {
        etatServeur->setText(tr("Le serveur n'a pas pu se lancer!\n")+serveur->errorString());
    }
    else
    {
        etatServeur->setText(tr("Le serveur s'est lancé sur le port ") + QString::number(serveur->serverPort()) + tr("\nDes clients peuvent maintenant se connecter."));
        connect(serveur,SIGNAL(newConnection()),this,SLOT(nouvelleConnection()));
    }
    tailleMessage=0;
}
void fenetreServeur::nouvelleConnection()
{
    envoyerMessage(tr("<em>Un nouvel utilisateur s'est conecté!</em>"));
    QTcpSocket *nouveauClient=serveur->nextPendingConnection();
    clients<<nouveauClient;
    connect(nouveauClient,SIGNAL(readyRead()),this,SLOT(recevoirDonnes()));
    connect(nouveauClient,SIGNAL(disconnected()),this,SLOT(deconnection()));
}
void fenetreServeur::envoyerMessage(const QString &message)
{
    ofstream fluxHistorique;
    fluxHistorique.open("Serveur_Historique.txt",ios::app);
    string messageStr=message.toStdString();
    time_t tmm = time(nullptr);
       char* dt = ctime(&tmm);
    fluxHistorique<<dt<<messageStr<<endl;
    QByteArray paquet;
    QDataStream fluxSortant(&paquet,QIODevice::WriteOnly);
    fluxSortant<<(quint16)0;
    fluxSortant<<message;
    fluxSortant.device()->seek(0);
    fluxSortant<<(quint16)(unsigned(paquet.size())-sizeof (quint16));
    for(int numClient=0;numClient<clients.size();numClient++)
    {
        clients[numClient]->write(paquet);
    }
}
void fenetreServeur::deconnection()
{
    envoyerMessage(tr("<em>Une personne s'est deconnectée!</em>"));
    QTcpSocket *socket=qobject_cast<QTcpSocket*>(sender());
    if(socket==nullptr)
        return;
    clients.removeOne(socket);
    socket->deleteLater();
}
void fenetreServeur::recevoirDonnes()
{
    QTcpSocket *socket=qobject_cast<QTcpSocket*>(sender());
    if(socket==nullptr)
        return;
    QDataStream fluxEntrant(socket);
    if(tailleMessage==0)
    {
        if(socket->bytesAvailable()<(int)sizeof(quint16))
            return;
        fluxEntrant>>tailleMessage;
    }
    if(socket->bytesAvailable()<tailleMessage)
        return;
    QString message;
    fluxEntrant>>message;
    envoyerMessage(message);
    tailleMessage=0;
}

et enfin le main.cpp:

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

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

    fenetreServeur fenetre;
    fenetre.show();

    return app.exec();
}

Somme toutes c'est presque la même chose que le code de Mathieu Nebra, mon seul ajout, c'est un fichier qui fait usage d'historique.
Merci d'avance pour le temps que vous avez pris pour tout lire!

-
Edité par PieWar 9 juin 2019 à 14:03:33

Bonjour,

Mauvais forum

Le sujet est déplacé de la section Vos réseaux vers la section Langage C++

Toujours les mêmes raisons que dans ce sujet :

https://openclassrooms.com/forum/sujet/diffuser-un-programme-utilisant-le-resau#93225689

Oui je sais mais j'avais mis ce sujet dans la rubrique "resaux" un modérateur l'a déplace ici...