Communication fails between Python 3 socket and QTcpsocket (c++) - c++

Question

Using Qt's QTcpsocket library and python 3's socket class currently. I have already gotten Qt's c++ fortune client / server example to build and run properly. However, it's for a client and server that are both C++. The requirement is that the server is running Python.
# Server.py
import socket
# ...
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("localhost", 45000)
sock.listen(1) # queuing up 1 request for now.
(clientsocket, address) = sock.accept() # waits until client connects.
chunk = clientsocket.recv(1024).decode() # client is now connect
print(chunk) #prints out message from client
msg = "Hello from the server"
msg = str.encode(msg)
# send the message back to the client
clientsocket.sendall(msg)
and
// Client.h
#ifndef CLIENT_H
#define CLIENT_H
#include <QObject>
#include <QtNetwork/QtNetwork>
class Client : public QObject {
Q_OBJECT
public:
Client();
QTcpSocket *m_socket;
QHostAddress m_serverAddr = QHostAddress("127.0.0.1");
quint16 m_serverPort = 45000;
private:
QDataStream m_dataStream;
void testConnect();
};
#endif
and
// client.cpp
Client::Client() {
m_socket = new QTcpSocket(this);
m_dataStream.setDevice(m_socket);
m_dataStream.setVersion(QDataStream::Qt_4_0);
testConnect();
}
void Client::testConnect() {
m_socket->abort(); // if m_socket is not already connected, this does nothing
m_socket->connectToHost(m_serverAddr, m_serverPort);
if (m_socket->waitForConnected(30000)) {
qDebug() << "Connected to server...";
m_socket->write("Hello server from client"); // is received!
m_socket->waitForBytesWritten();
m_socket->waitForReadyRead();
qDebug() << "Reading: " << m_socket->bytesAvailable();
m_dataStream.startTransaction();
QString nextFortune;
m_dataStream >> nextFortune;
if (!m_dataStream.commitTransaction()) {
qDebug() << "Read errors have occurred."; // prints when connected to python server. not desired behavior
m_socket->close();
return;
}
// This prints when running the Qt fortune c++ server, but not the python server (above).
qDebug() << "No read errors occurred during read transactions.";
qDebug() << nextFortune;
}
}
What ends up happening is the server receives the message from the client without issue, but when the server attempts to send a reply with clientsocket.sendall(msg), m_dataStream.commitTransaction() returns false. My initial instinct was that the encoding was wrong on the python side. Does QDataStream require a special encoding?
Documentation for QDataStream::commitTransaction():
bool QDataStream::commitTransaction()
Completes a read transaction. Returns true if no read errors have occurred
during the transaction; otherwise returns false.
Also, after running, here is the output of the c++ client:
Connected to server...
Reading: 25
Read errors have occurred.

Answer 1

When you want to use QDataStream with operator >> you have to follow a serialization format. The call QDataStream.setVersion() select concrete format.
I've been able to found documentation only for version 12 (applies from QDataStream::Qt_4_6 to QDataStream::Qt_4_9) and version 13 (QDataStream::Qt_5_0).
Version 12 and 13 have the same format for serialization of the QString:
> If the string is null: 0xFFFFFFFF (quint32)
> Otherwise: The string length in bytes (quint32) followed by the data in UTF-16
When you call m_dataStream >> nextFortune it expects the incoming data will be in the format described above.
The code in Python for send encoded QString can look like this:
import struct
msg = "Hello from the server".encode("utf-16be")
clientsocket.sendall(struct.pack(">I", len(msg)) + msg)
str.encode("utf-16be") - encodes the string into UTF-16 with big-endian order
struct.pack(">I", len(msg)) - creates a 32-bit unsigned integer contains the length of the encoded string (I) in the big-endian orderd (>)
All data send to Qt's client are in big-endian order because it is implicit order which QDataStream uses.
I've tested the code with Qt 5.9 and serialization version QDataStream::Qt_4_0.