unable to send data via QTcpSocket

[SGaist]

Hi,

As already suggested, you should use the errorOccured signal.

[Lightshadown]

@SGaist ok i just read all the documentation for my version of Qt 5.11, and im using TCP_socket->errorString() the reason why, is beacuse im not having the error signal been trigger, but if i use the errorstring function i get and Unknown error, the port is open, the port is writable and yet im unable to trigger any signal or write anything, in fact my program crash everytime, i even had to do a static_cast on the error handling so it can compile, i add my actual code below

Server::Server(){
    Gen gen;
    TCP_socket = new QTcpSocket();
    QMessageBox MBox;
    QPushButton *boton_OK = MBox.addButton("Ok", QMessageBox::AcceptRole);
    MBox.setDefaultButton(boton_OK);
    
    //data.setDevice(TCP_socket);
    //data.setVersion(QDataStream::Qt_DefaultCompiledVersion);
    
    
    QObject::connect(TCP_socket, &QTcpSocket::connected, [&](){     // escrituta cuando se conecta
        MBox.setWindowTitle("Servidor");
        MBox.setText("Conectado");
             gen.Log("tcp conectado");
        bool yes;
        
        QByteArray block("Hola motherfucker, from laptop");
        //QString dataSend;
//        QDataStream data(&block, QIODevice::ReadWrite);
//        //data << (quint16)0;
//        dataSend.append("Enviando desde laptop");
//        data << dataSend;
        //data.device()->seek(0);
        //data <<(quint16)(block.size()) - sizeof(quint16);
              gen.Log("antes de escribir");
        //TCP_socket->write(block.size());
        TCP_socket->write(block);
              gen.Log("despues de escribir");
        yes = TCP_socket->waitForBytesWritten();
              gen.Log("despues de esperar");
        if (yes == true){ MBox.exec();} else {MBox.setText("Hay pedo"); MBox.exec();}
        TCP_socket->disconnectFromHost();
             gen.Log("coneecion terminada");
    } ); 
                                                          
    QObject::connect(TCP_socket, &QTcpSocket::readyRead, [&](){    // lectura de datos
        gen.Log("dentro de readyRead");
        QString dataread;
        QByteArray data;
        
        MBox.setWindowTitle("Data Read");
        data = TCP_socket->readAll();
        dataread.append(data);
        MBox.setText("leido: " + dataread);
        gen.Log(dataread);
        MBox.exec();
    });
    
    // manejo de erores
    //QObject::connect(TCP_socket, QOverload<QAbstractSocket::SocketError>::of(&QAbstractSocket::error), [&](QAbstractSocket::SocketError error) {
    QObject::connect(TCP_socket, static_cast<void (QTcpSocket::*)(QAbstractSocket::SocketError)> (&QAbstractSocket::error), [&](QAbstractSocket::SocketError error){   
        gen.Log("Error");
        MBox.setWindowTitle("Error ");
        //error = TCP_socket->error();
        switch(error){
            case QAbstractSocket::RemoteHostClosedError:
                MBox.setText("El servidor Cerro la coneccion, Error 500");
                MBox.exec();
                break;
            case QAbstractSocket::HostNotFoundError:
                MBox.setText("No se encontro el Servidor, Error 404");
                MBox.exec();
                break;
            case QAbstractSocket::ConnectionRefusedError:
                MBox.setText("La coneccion fue rechazada por el Servidor, Error 403");
                MBox.exec();
                break;
            default:
                MBox.setText("Hubo un error inesperado: " + TCP_socket->errorString());
                MBox.exec();
        }
    });
    
    QObject::connect(TCP_socket, &QTcpSocket::disconnected, [&](){
        gen.Log("Desconectado del servidor");
        TCP_socket->deleteLater();
    });
}

Server::~Server(){
    
}

void Server::TCP_Request(){   // this one is been called from another class and triggers everything
    Gen L;
    QString Ip("192.168.1.70");
    L.Log("antes de coneccion");
    TCP_socket->connectToHost( Ip, 8000 );   // do a broadcast and search for servers ip
    //TCP_socket->waitForConnected(5000);
    
    
    if (TCP_socket->isOpen()){ L.Log("esta abierto el puerto"); }
    else { L.Log("no esta abierto el puerto"); }
    
    if(TCP_socket->isWritable()){ L.Log("Se puede escribir"); }
    else { L.Log("No se puede usar el puerto"); }
    
    L.Log("Error en el socket: " + TCP_socket->errorString());
    
//    switch (TCP_socket->state()){
//        case QAbstractSocket::UnconnectedState:
//            L.Log("sin coneccion");
//        case QAbstractSocket::ConnectingState:
//            L.Log("Conecctando...");
//        case QAbstractSocket::ConnectedState:
//            L.Log("Coneccion exitosa");
//    }
}

[jsulm]

@Lightshadown said in unable to send data via QTcpSocket:

TCP_socket->write(block);

Up to here you did NOT connect error() signal!
Please connect this signal BEFORE you try to send any data.

[J.Hilk]

@Lightshadown said in unable to send data via QTcpSocket:

yes = TCP_socket->waitForBytesWritten();

also do not use blocking calls when you're already using signals. QTcpSocket has the bytesWritten signal for this.

Also,also, please remove the QMessageBox from the lambda body.

Currently you're mixing synchronous and asynchronous apis and sprinkle some additional event loops in. Those 3 should never meet.

[Lightshadown]

@jsulm the error handler is already connected but forgot to uncomment on the one i posted my bad, this is the one i used error = TCP_socket->error(); , still i can access the lambda but the switch statement fails for some reason, i did updated the switch and added all the errors that comes from the enum and it still fails, i have a problem with the error handler and already tried to use my Log function that accept QString, but it crash onces i use the error variable

@J-Hilk ok sorry on that one didnt pay attention, i already erased all the QMessageBox, so its working properly until i reach TCP_socket->write i suspect its my server, its writen in python, it works but only for the first string i did check using another client writen in python

edit: i simply added TPC_socket->flush() and it kinda works, it behaves like the data is already send and even disconect from the server at the end but the data its not recieved on my server

Server.py

import asyncio
import websockets
import socket
import sqlite3 


def get_ip():    # returns primary private IP only
    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
    try:
        # doesn't even have to be reachable
        s.connect(('10.255.255.255', 1))
        IP = s.getsockname()[0]
    except Exception:
        IP = '127.0.0.1'
    finally:
        s.close()
    return IP


async def handle_connectio(websocket, path):  # recive and handle connection from client, would handle json or file data
    try:
        async for name in websocket:
            #name = await websocket.recv()
            print(f"<<< {name}")
    except websocket.exceptions.ConnectionClosed as e:
        print (f"Coneecion terminada")


print ("Iniciando el Server webSocket")
print ("Current Ip: " + get_ip())
servidor = websockets.serve(handle_connectio, get_ip(), 8000)

asyncio.get_event_loop().run_until_complete(servidor)
asyncio.get_event_loop().run_forever()
        
#async def main():  # main function
#    print ("Iniciando Server websocket")
#    print("Current Ip: " + get_ip())
#    async with websockets.serve(handle_connectio, get_ip(), 8000):
#        await asyncio.Future()


#if __name__ == '__main__':
#    asyncio.run(main())

[SGaist]

@Lightshadown said in unable to send data via QTcpSocket:

TCP_socket = new QTcpSocket();

You are shadowing your class member variable of the same name and likely have a warning about that when you compile.

@Lightshadown said in unable to send data via QTcpSocket:

void Server::TCP_Request(){ // this one is been called from another class and triggers everything
Gen L;
QString Ip("192.168.1.70");
L.Log("antes de coneccion");
TCP_socket->connectToHost( Ip, 8000 ); // do a broadcast and search for servers ip
//TCP_socket->waitForConnected(5000);

Using an uninitialized variable and thus crash.

[edit: must have been too tired, I thought I saw the variable declared within the constructor... SGaist]

[Lightshadown]

@SGaist that socket was declared as private on the class declaration

class Server {
   public:
        Server();
        virtual ~Server();
        void TCP_Request();
    public slots:
    private: 
         QTcpSocket *TCP_socket = nullptr;
   };

[KroMignon]

@Lightshadown said in unable to send data via QTcpSocket:

class Server {
public:
Server();
virtual ~Server();
void TCP_Request();
public slots:
private:
QTcpSocket *TCP_socket = nullptr;
};

If you want to declare slots (or signals) in your class, you have to:

• subclass QObject (or a QObject based class)
• add Q_OBJECT declaration

so you class should be:

class Server : public QObject {
   Q_OBJECT
   public:
        explicit Server(QObject * parent=nullptr);
        virtual ~Server();
        void TCP_Request();
    public slots:
    private: 
         QTcpSocket *TCP_socket = nullptr;
   };

[Lightshadown]

ok i ditched the lambda and used a normal function, for some reason it wont work inside the connect signal, but now the socket its lock, and got the error
QAbstractSocket::UnfinishedSocketOperationError i have to restart both machines to free the socket, any idea how to free the socket or check the socket if its aviable?

void Server::TCP_Request(){
    Gen L;
    QString Ip("192.168.1.70");
    L.Log("antes de coneccion");
    TCP_socket->abort();
    TCP_socket->connectToHost( Ip, 8000, QIODevice::ReadWrite );   // do a broadcast and search for servers ip
    L.Log("tcp conectado");
        
    bool yes = false;
    QByteArray block("Hola, from laptop");
    //QDataStream salida(&block, QIODevice::WriteOnly);

    //salida << "Enviando desde laptop ";
    //block.append("Enviando desde Laptop");

    if (TCP_socket->isValid()) {
        L.Log("antes de escribir");
        TCP_socket->write(block);
        yes = TCP_socket->flush();
    //TCP_socket->waitForBytesWritten(100);
    }
    if (yes == true){ L.Log("datos enviados");} else {L.Log("no se envio los datos");}
    TCP_socket->disconnectFromHost();
    //TCP_socket->abort();
    L.Log("coneecion terminada");
    }

[jsulm]

@Lightshadown said in unable to send data via QTcpSocket:

TCP_socket->disconnectFromHost();

You are disconnecting without knowing whether all data was sent (flush() does not guarantee this!).
You should listen to https://doc.qt.io/qt-5/qiodevice.html#bytesWritten signal and disconnect when all data was sent.

[Lightshadown]

@jsulm ok i did try using waitForBytesWritten() and it kinda works, now i can send the data to the server, and i just had to wait for the socket to connect, waitForConnected(1000) like it follows

void Server::TCP_Request(){
    Gen L;
    QString Ip("192.168.1.70");    
    bool yes = false;
    QByteArray block("Hola, from laptop");    
            
    TCP_socket->abort();
            
    if (TCP_socket->state() == QAbstractSocket::UnconnectedState){

        L.Log("antes de coneccion");
        TCP_socket->connectToHost( Ip, 8000, QIODevice::ReadWrite );   // do a broadcast and search for servers ip
        
        //QDataStream salida(&block, QIODevice::WriteOnly);
        //salida << "Enviando desde laptop ";
        //block.append("Enviando desde Laptop");
        if (TCP_socket->waitForConnected(1000)){
            if (TCP_socket->isValid()) { // && TCP_socket->state() == QAbstractSocket::ConnectedState) {
                L.Log("antes de escribir");
                TCP_socket->write(block);
                yes = TCP_socket->flush();
                TCP_socket->waitForBytesWritten(1000);
            }
        }
        if (yes == true){ L.Log("datos enviados");} else {L.Log("no se envio los datos");}
        TCP_socket->disconnectFromHost();
        TCP_socket->close();
        //TCP_socket->abort();
        L.Log("coneecion terminada");

    }
        
}

also i would check the signal bytes emited and try to figure it out when all the data is sent, next i would check sending files, thanks

[jsulm]

@Lightshadown Actually I suggested to use https://doc.qt.io/qt-5/qiodevice.html#bytesWritten signal instead of doing blocking calls to wait. But it is up to you.