socket.cpp

/*
 * SPDX-FileCopyrightText: (C) 2016-2018 Daniel Nicoletti <dantti12@gmail.com>
 * SPDX-License-Identifier: BSD-3-Clause
 */
#include "socket.h"
 
#include "server.h"
 
#include <QLoggingCategory>
 
Q_LOGGING_CATEGORY(C_SERVER_SOCK, "cutelyst.server.socket", QtWarningMsg)
 
using namespace Cutelyst;
 
Socket::Socket(bool secure, Cutelyst::Engine *_engine)
    : engine(_engine)
    , isSecure(secure)
{
}
 
Socket::~Socket()
{
    delete protoData;
}
 
TcpSocket::TcpSocket(Cutelyst::Engine *engine, QObject *parent)
    : QTcpSocket(parent)
    , Socket(false, engine)
{
    connect(this,
            &QTcpSocket::disconnected,
            this,
            &TcpSocket::socketDisconnected,
            Qt::DirectConnection);
}
 
void TcpSocket::connectionClose()
{
    QTcpSocket::flush();
    disconnectFromHost();
}
 
bool TcpSocket::requestFinished()
{
    bool disconnected = state() != ConnectedState;
    if (!--processing && disconnected) {
        Q_EMIT finished();
    }
    return !disconnected;
}
 
bool TcpSocket::flush()
{
    return QTcpSocket::flush();
}
 
void TcpSocket::socketDisconnected()
{
    if (!processing) {
        Q_EMIT finished();
    } else {
        protoData->socketDisconnected();
    }
}
 
LocalSocket::LocalSocket(Cutelyst::Engine *engine, QObject *parent)
    : QLocalSocket(parent)
    , Socket(false, engine)
{
    connect(this,
            &QLocalSocket::disconnected,
            this,
            &LocalSocket::socketDisconnected,
            Qt::DirectConnection);
}
 
void LocalSocket::connectionClose()
{
    QLocalSocket::flush();
    disconnectFromServer();
}
 
bool LocalSocket::requestFinished()
{
    bool disconnected = state() != ConnectedState;
    if (!--processing && disconnected) {
        Q_EMIT finished();
    }
    return !disconnected;
}
 
bool LocalSocket::flush()
{
    return QLocalSocket::flush();
}
 
void LocalSocket::socketDisconnected()
{
    if (!processing) {
        Q_EMIT finished();
    } else {
        protoData->socketDisconnected();
    }
}
 
#ifndef QT_NO_SSL
 
SslSocket::SslSocket(Cutelyst::Engine *engine, QObject *parent)
    : QSslSocket(parent)
    , Socket(true, engine)
{
    connect(this,
            &QSslSocket::disconnected,
            this,
            &SslSocket::socketDisconnected,
            Qt::DirectConnection);
}
 
void SslSocket::connectionClose()
{
    QSslSocket::flush();
    disconnectFromHost();
}
 
bool SslSocket::requestFinished()
{
    bool disconnected = state() != ConnectedState;
    if (!--processing && disconnected) {
        Q_EMIT finished();
    }
    return !disconnected;
}
 
bool SslSocket::flush()
{
    return QSslSocket::flush();
}
 
void SslSocket::socketDisconnected()
{
    if (!processing) {
        Q_EMIT finished();
    } else {
        protoData->socketDisconnected();
    }
}
 
#endif // QT_NO_SSL
 
#include "moc_socket.cpp"