Client-server chat using Qt / C ++ sockets

Foreword

The article focuses mainly on beginners. The purpose of writing it is a quick and detailed description of sockets, for an initial understanding of the network and sockets. At one time I was looking for a similar one, but I needed detailed examples. In the standard example, fortune server / client that comes with qt shows very poorly the capabilities of sockets.

So, the server is able:

• "Listen" arbitrary address, port
• Authorize a customer by name
• Send public, private, server messages
• Send user list

The client is able to make the appropriate requests to the server.

To understand this, Gouy applications will be:
')


In qt, there are classes QTcpSocket and QTcpServer for working with sockets. Using signals and slots, you can work with them in non-blocking (asynchronous mode). This means if the connection to the server takes a noticeable amount of time, the gui is not blocked, but continues to process events, and when a connection occurs (or an error), a certain slot will be called (in the current case connected to the connected () signal).

Customer

Let's start with a simple one — let's not inherit the classes, but use QTcpSocket:

//dialog.h class Dialog : public QDialog { private slots: //      void onSokConnected(); void onSokDisconnected(); // readyRead ,     (      )  void onSokReadyRead(); void onSokDisplayError(QAbstractSocket::SocketError socketError); private: QTcpSocket *_sok; // quint16 _blockSize;//    QString _name;//  }; 

In general, when working with sockets, you need to look at the data as a set of bytes, otherwise there may be problems with displaying information only partially (it was not a complete message, and the following is displayed with a piece of the previous one). To avoid these troubles, we will use data streams (QDataStream) and transfer blocks between sockets in which the first 2 bytes are the size of the current block, the 3rd byte is the client’s command to the server (or server response), and the rest is data depending on the command. It is worth saying that the tcp protocol guarantees the delivery of all packets, so you can safely wait for the full block size before processing it.

 //dialog.cpp Dialog::Dialog(QWidget *parent) :QDialog(parent),ui(new Ui::Dialog) { //  _sok = new QTcpSocket(this); //  connect(_sok, SIGNAL(readyRead()), this, SLOT(onSokReadyRead())); connect(_sok, SIGNAL(connected()), this, SLOT(onSokConnected())); connect(_sok, SIGNAL(disconnected()), this, SLOT(onSokDisconnected())); connect(_sok, SIGNAL(error(QAbstractSocket::SocketError)),this, SLOT(onSokDisplayError(QAbstractSocket::SocketError))); } //     , ,  connectToHost()   void, ,            onSokDisplayError void Dialog::on_pbConnect_clicked() { _sok->connectToHost(ui->leHost->text(), ui->sbPort->value()); } void Dialog::onSokConnected() { //       QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); // 2    .  MyClient    ,        -   //  -  out << (quint16)0 << (quint8)MyClient::comAutchReq << ui->leName->text(); _name = ui->leName->text(); //   out.device()->seek(0); //      out << (quint16)(block.size() - sizeof(quint16)); _sok->write(block); } void Dialog::onSokReadyRead() { //     QDataStream in(_sok); //     2     if (_blockSize == 0) { //   2     2  if (_sok->bytesAvailable() < (int)sizeof(quint16)) return; //  (2 ) in >> _blockSize; } //     if (_sok->bytesAvailable() < _blockSize) return; else //    _blockSize = 0; //3  -   quint8 command; in >> command; switch (command) { //   ,   ,        MyClient::comUsersOnline case MyClient::comUsersOnline: { QString users; in >> users; if (users == "") return; //    ,   (       QStringList) QStringList l = users.split(","); //  ui->lwUsers->addItems(l); } break; //    case MyClient::comPublicServerMessage: { //     QString message; in >> message; AddToLog("[PublicServerMessage]: "+message, Qt::red); } ... } } 

This is all with the client - the main points are described, the rest is pretty simple.

Server

The server will be more complicated - separate the gui (dialog), server (myserver) and client (myclient). Who is unfamiliar with sockets can not understand what client can be in the server? So, when connecting a socket to the server, on the server, as a rule, a “client” socket is created, which is added to the array (a thought arises to use an associative array, but for simplicity we take QList).

 //dialog.cpp Dialog::Dialog(QWidget *parent) :QDialog(parent), ui(new Ui::Dialog) { // .    - parent,  -     ,     myclient   _serv = new MyServer(this, this); //      connect(this, SIGNAL(messageFromGui(QString,QStringList)), _serv, SLOT(onMessageFromGui(QString,QStringList))); ... //     127.0.0.1:1234 if (_serv->doStartServer(QHostAddress::LocalHost, 1234)) {...} else {...} } 

We will inherit the class from QTcpServer, it is necessary to redefine the incomingConnection virtual function, in which the incoming connection is intercepted (input parameter is socket descriptor)

 //myserver.h class MyServer : public QTcpServer { public: bool doStartServer(QHostAddress addr, qint16 port); void doSendToAllUserJoin(QString name); //    void doSendToAllUserLeft(QString name); void doSendToAllMessage(QString message, QString fromUsername); //  void doSendToAllServerMessage(QString message);//  void doSendServerMessageToUsers(QString message, const QStringList &users); //   void doSendMessageToUsers(QString message, const QStringList &users, QString fromUsername); QStringList getUsersOnline() const; //   bool isNameValid(QString name) const; //  bool isNameUsed(QString name) const; //    protected: void incomingConnection(int handle); private: QList<MyClient *> _clients; //  QWidget *_widget; //         myclient }; //myserver.cpp void MyServer::incomingConnection(int handle) { //  ,    (   ),    - parent MyClient *client = new MyClient(handle, this, this); //    ,       if (_widget != 0) { connect(client, SIGNAL(addUserToGui(QString)), _widget, SLOT(onAddUserToGui(QString))); connect(client, SIGNAL(removeUserFromGui(QString)), _widget, SLOT(onRemoveUserFromGui(QString))); ... } _clients.append(client); } /*           ,    _clients, ,    */ void MyServer::doSendServerMessageToUsers(QString message, const QStringList &users) { //    QByteArray block; QDataStream out(&block, QIODevice::WriteOnly); out << (quint16)0 << MyClient::comPrivateServerMessage << message; out.device()->seek(0); out << (quint16)(block.size() - sizeof(quint16)); //   (  ,     users  ) for (int j = 0; j < _clients.length(); ++j) if (users.contains(_clients.at(j)->getName())) _clients.at(j)->_sok->write(block); } 

For a client class, perhaps, it is worth describing only the interface, everything is clear by analogy. MyClient does not need to inherit from QTcpSocket, you can do it differently:

 //myclient.h class MyClient : public QObject { //   MyServer    _sok friend class MyServer; public: static const QString constNameUnknown; static const quint8 comAutchReq = 1; static const quint8 comUsersOnline = 2; ... static const quint8 comErrNameUsed = 202; void setName(QString name) {_name = name;} QString getName() const {return _name;} bool getAutched() const {return _isAutched;} void doSendCommand(quint8 comm) const; void doSendUsersOnline() const; signals: //    void addUserToGui(QString name); void removeUserFromGui(QString name); void messageToGui(QString message, QString from, const QStringList &users); //    QList void removeUser(MyClient *client); //      private slots: void onConnect(); void onDisconnect(); void onReadyRead(); void onError(QAbstractSocket::SocketError socketError) const; private: QTcpSocket *_sok; // MyServer *_serv; //   quint16 _blockSize; //   QString _name; // bool _isAutched; //  }; 

Upd 2017 :
Alas, but the source is already lost forever
Upd 2018 :
As you know, everything that has ever been uploaded to the Internet remains there forever. Thanks to vladpower, the sources are again available.