c++ - Es QLocalSocket realmente utilizado para namedpipes

qt qt5

Question

De acuerdo con la documentación de Qt si queremos usar named pipes en Windows, podemos usar QLocalSocket. Estoy escribiendo un programa de servidor y cliente con Qt. Si trato de usar la API de WIN32 para escribir algún mensaje en la línea de tubería, el cliente de Qt no lo muestra. Además, si el cliente escribe usando nuevamente la API WIN32, el servidor Qt no repite el mensaje enviado. ¿QLocalSocket realmente se recomienda para tuberías con nombre?

Este es el código del Servidor Win32

     wcout << "Creating an instance of a named pipe..." << endl;
    // Create a pipe to send data
    HANDLE pipe = CreateNamedPipeW(
        L"////.//pipe//ServicePipe", // name of the pipe
        PIPE_ACCESS_OUTBOUND, // 1-way pipe -- send only
        PIPE_TYPE_BYTE, // send data as a byte stream
        100, // only allow 1 instance of this pipe
        0, // no outbound buffer
        0, // no inbound buffer
        0, // use default wait time
        NULL // use default security attributes
        );

    if (pipe == NULL || pipe == INVALID_HANDLE_VALUE) {
        wcout << "Failed to create outbound pipe instance.";
        // look up error code here using GetLastError()
        system("pause");
        return 1;
    }

    wcout << "Waiting for a client to connect to the pipe..." << endl;

    // This call blocks until a client process connects to the pipe
    BOOL result = ConnectNamedPipe(pipe, NULL);
    if (!result) {
        wcout << "Failed to make connection on named pipe." << endl;
        // look up error code here using GetLastError()
        CloseHandle(pipe); // close the pipe
        system("pause");
        return 1;
    }

    wcout << "Sending data to pipe..." << endl;

    // This call blocks until a client process reads all the data
    wcout <<endl<<"Input your message: ";

    wstring data=L"";
    getline(wcin,data);
    DWORD numBytesWritten = 0;
    result = WriteFile(
        pipe, // handle to our outbound pipe
        data.c_str(), // data to send
        wcslen(data.c_str()) * sizeof(wchar_t), // length of data to send (bytes)
        &numBytesWritten, // will store actual amount of data sent
        NULL // not using overlapped IO
        );


    if (result) {
        wcout << "Number of bytes sent: " << numBytesWritten << endl;
    } else {
        wcout << "Failed to send data." << endl;
        // look up error code here using GetLastError()
    }

    // Close the pipe (automatically disconnects client too)
    CloseHandle(pipe);

    wcout << "Done." << endl;

Este es el lado del Cliente Win32:

    wcout << "Connecting to pipe..." << endl;
    // Open the named pipe
    // Most of these parameters aren''t very relevant for pipes.
    HANDLE pipe = CreateFileW(
        L"////.//pipe//ServicePipe",
        GENERIC_READ, // only need read access
        FILE_SHARE_READ | FILE_SHARE_WRITE,
        NULL,
        OPEN_EXISTING,
        FILE_ATTRIBUTE_NORMAL,
        NULL
        );

    if (pipe == INVALID_HANDLE_VALUE) {
        wcout << "Failed to connect to pipe." << endl;
        // look up error code here using GetLastError()
        system("pause");
        return 1;
    }

    wcout << "Reading data from pipe..." << endl;

    // The read operation will block until there is data to read
    wchar_t buffer[128];
    DWORD numBytesRead = 0;
    BOOL result = ReadFile(
        pipe,
        buffer, // the data from the pipe will be put here
        127 * sizeof(wchar_t), // number of bytes allocated
        &numBytesRead, // this will store number of bytes actually read
        NULL // not using overlapped IO
        );

    if (result) {
        buffer[numBytesRead / sizeof(wchar_t)] = ''?''; // null terminate the string
        wcout << "Number of bytes read: " << numBytesRead << endl;
        wcout << "Message: " << buffer << endl;
    } else {
        wcout << "Failed to read data from the pipe." << endl;
    }

    // Close our pipe handle
    CloseHandle(pipe);

    wcout << "Done." << endl;

Este es el lado del servidor Qt

   LocalSocketIpcServer::LocalSocketIpcServer(QString servername, QObject *parent)
:QObject(parent) {
m_server = new QLocalServer(this);
if (!m_server->listen(servername)) {
    showMessage("Not able to start the Server");
}

connect(m_server, SIGNAL(newConnection()), this, SLOT(socket_new_connection()));
}

LocalSocketIpcServer::~LocalSocketIpcServer() {

}


void LocalSocketIpcServer::socket_new_connection() {

QLocalSocket *clientConnection = m_server->nextPendingConnection();

while (clientConnection->bytesAvailable() < (int)sizeof(quint32))
    clientConnection->waitForReadyRead();



//connect(clientConnection,SIGNAL(readyRead()),clientConnection,SLOT(rea));
connect(clientConnection, SIGNAL(disconnected()),clientConnection, SLOT(deleteLater()));

QDataStream in(clientConnection);
in.setVersion(QDataStream::Qt_5_1);
if (clientConnection->bytesAvailable() < (int)sizeof(quint16)) {
    return;
}

QString message;
in >> message;

QByteArray block;
QDataStream out(&block, QIODevice::WriteOnly);
QString msg=+"Message recieved with content "+message+"/n";
out.setVersion(QDataStream::Qt_5_1);
out <<msg;
out.device()->seek(0);
clientConnection->write(block);
clientConnection->flush();
clientConnection->disconnectFromServer();

emit messageReceived(message);
}


void LocalSocketIpcServer::showMessage(QString msg)
{
QMessageBox m;
m.setText(msg);
m.exec();
}
LocalSocketIpcServer::FrmMain(QWidget *parent) :QMainWindow(parent),ui(new Ui::FrmMain)
{
ui->setupUi(this);

m_server = new LocalSocketIpcServer("////.//pipe/ServicePipe", this);
connect(m_server, SIGNAL(messageReceived(QString)), this, SLOT(messageReceived(QString)));
}

LocalSocketIpcServer::~FrmMain()
{
delete ui;
}

void LocalSocketIpcServer::messageReceived(QString message)
{
   ui->textBrowser->append(message+"/n");
}

Este es el lado del cliente de Qt

LocalSocketIpcClient::LocalSocketIpcClient(QString remoteServername, QObject *parent) :
    QObject(parent) {

m_socket = new QLocalSocket(this);
m_serverName = remoteServername;

connect(m_socket, SIGNAL(connected()), this, SLOT(socket_connected()));
connect(m_socket, SIGNAL(disconnected()), this, SLOT(socket_disconnected()));

connect(m_socket, SIGNAL(readyRead()), this, SLOT(socket_readReady()));
connect(m_socket, SIGNAL(error(QLocalSocket::LocalSocketError)),
        this, SLOT(socket_error(QLocalSocket::LocalSocketError)));
}

LocalSocketIpcClient::~LocalSocketIpcClient() {
m_socket->abort();
delete m_socket;
m_socket = NULL;
}

QString LocalSocketIpcClient::Read()
{

QDataStream in(this->m_socket);
in.setVersion(QDataStream::Qt_5_1);

if (m_socket->bytesAvailable() < (int)sizeof(quint16)) {
    return "No data available";
}

QString message;
in >> message;
return message;
}

void LocalSocketIpcClient::send_MessageToServer(QString message) {
m_socket->abort();
m_message = message;
m_socket->connectToServer(m_serverName,QIODevice::ReadWrite);
}


void LocalSocketIpcClient::socket_connected(){
QByteArray block;
QDataStream out(&block, QIODevice::ReadWrite);
out.setVersion(QDataStream::Qt_5_1);
out << m_message;
out.device()->seek(0);
m_socket->write(block);
m_socket->flush();
}

 void LocalSocketIpcClient::socket_disconnected() {
 //showMessage("Client socket_disconnected");
}


void LocalSocketIpcClient::socket_readReady() {
//showMessage("Client socket read Ready");

QDataStream in(this->m_socket);
in.setVersion(QDataStream::Qt_5_1);

if (m_socket->bytesAvailable() < (int)sizeof(quint16)) {
    return;
}

QString message;
in >> message;
emit RecievedDataFromServer(message);

}

void LocalSocketIpcClient::socket_error(QLocalSocket::LocalSocketError e) {
/*
QString errorMessage="Client socket_error:";

switch (e) {
case QLocalSocket::ConnectionRefusedError:
    errorMessage+="The connection was refused by the peer (or timed out).";
    break;

case QLocalSocket::PeerClosedError:
    errorMessage+="The remote socket closed the connection. Note that the client socket (i.e., this socket) will be closed after the remote close notification has been sent.";
    break;

case QLocalSocket::ServerNotFoundError:
    errorMessage+="The local socket name was not found.";
    break;

case QLocalSocket::SocketAccessError:
    errorMessage+="The socket operation failed because the application lacked the required privileges.";
    break;

case QLocalSocket::SocketResourceError:
    errorMessage+="The local system ran out of resources (e.g., too many sockets).";
    break;

case QLocalSocket::SocketTimeoutError:
    errorMessage+="The socket operation timed out.";
    break;

case QLocalSocket::DatagramTooLargeError:
    errorMessage+="The datagram was larger than the operating system''s limit (which can be as low as 8192 bytes).";
    break;

case QLocalSocket::ConnectionError:
    errorMessage+="An error occurred with the connection.";
    break;

case QLocalSocket::UnsupportedSocketOperationError:
    errorMessage+="The requested socket operation is not supported by the local operating      system.";
    break;

case QLocalSocket::UnknownSocketError:
    errorMessage+="An unidentified error occurred.";
    break;

default:
    break;
}
showMessage(errorMessage);
*/
}

void LocalSocketIpcClient::showMessage(QString msg)
{
QMessageBox m;
m.setText(msg);
m.exec();
}
LocalSocketIpcClient::SingleMessageSend(QWidget *parent) :
QDialog(parent),
ui(new Ui::SingleMessageSend)
{
ui->setupUi(this);

client  = new LocalSocketIpcClient("////.//pipe/ServicePipe", this);
connect(this->client,SIGNAL(RecievedDataFromServer(QString)),this,SLOT(UpdateGUI(QString)));
}

LocalSocketIpcClient::~SingleMessageSend()
{
delete ui;
}

void SingleMessageSend::on_pushButton_clicked()
{
QString msg=this->ui->lineEdit->text().trimmed();
client->send_MessageToServer(msg);

}

void SingleMessageSend::UpdateGUI(QString message)
{
 ui->textEdit->insertPlainText(message+"/n");
}

void SingleMessageSend::on_pushButton_2_clicked()
{
ui->textEdit->insertPlainText(client->Read()+QString("/n"));
}

Answer 1

Sin pasar por todo tu código, puedo responder esto afirmativamente. Aquí hay un código de una aplicación en funcionamiento que escribe desde una aplicación Qt a una tubería con nombre en otra aplicación Qt (restaura otra aplicación que está minimizada):

QLocalSocket ls;
ls.connectToServer("Restore Server", QIODevice::WriteOnly);
if (!ls.waitForConnected(5000))
{
        qDebug(ls.errorString().toUtf8());
        return false;
}
ls.write("raise");
if (!ls.waitForBytesWritten(5000))
{
        qDebug(ls.errorString().toUtf8());
        return false;
}
ls.disconnectFromServer();

La aplicación que se va a restaurar configura las cosas así:

localServer = new QLocalServer(this);

connect(localServer, SIGNAL(newConnection()), this,
    SLOT(messageFromOtherInstance()));
localServer->listen("Restore Server");

Cuando llega el momento de leer el mensaje, lo hago así:

QLocalSocket *localSocket = localServer->nextPendingConnection();
if (!localSocket->waitForReadyRead(5000))
{
        qDebug(localSocket->errorString().toLatin1());
        return;
}
QByteArray byteArray = localSocket->readAll();
QString message = QString::fromUtf8(byteArray.constData());

if (message == "raise")
    bringToTop(this);

Puede ser que Qt named pipes y M $ named pipes sean de alguna manera incompatibles. Sugiero que escriba una aplicación de M $ framework para escribir en el cliente de M $ framework y una aplicación M $ framework para leer, para asegurarse de que ambos funcionen correctamente. Luego, sustituya una aplicación Qt para leer desde el servidor Qt. Si eso no funciona, es una especie de incompatibilidad de framework (aunque espero que ambos interactúen con el sistema operativo correctamente). Una cosa de la que debe estar seguro en situaciones como esta es asegurarse de que los procesos no se bloqueen. Por eso, por ejemplo, me aseguro de que la lectura esté lista antes de leerla. También es posible que deba enjuagar la tubería después de escribir en el lado M $, aunque no lo hice con Qt.

(Tenga en cuenta que, desde entonces, descubrí que si está abierto un cuadro de diálogo Imprimir, Vista previa de impresión, Configurar página o Examinar archivo, detiene el ciclo del mensaje Qt y la aplicación no responderá a mensajes como este. El cuadro de diálogo Elegir fuente, OTOH , no bloquea la aplicación principal. Ir a la figura).