This removes the automated DEFINITIONS recognition for MOC (which was not cross-platform apparently);
instead, we now explicitly set MOC_DEFINES for things where it matters, such as -DHAVE_DBUS and -DHAVE_SSL.
add_definitions(-DHAVE_EXECINFO)
endif(HAVE_EXECINFO)
-
# Select a Qt installation here, if you don't want to use system Qt
if(QT)
# FindQt4 will look for the qmake binary in $PATH, so we just prepend the Qt dir
message(STATUS "Found OpenSSL support in Qt")
add_definitions(-DHAVE_SSL)
set(HAVE_SSL true)
+ set(MOC_DEFINES ${MOC_DEFINES} -DHAVE_SSL)
else(NOT QT_DEFINITIONS MATCHES "QT_NO_OPENSSL")
message(STATUS "No OpenSSL support found in Qt, disabling")
endif(NOT QT_DEFINITIONS MATCHES "QT_NO_OPENSSL")
add_definitions(-DHAVE_DBUS)
set(LINK_DBUS DBUS)
set(HAVE_DBUS true)
+ set(MOC_DEFINES ${MOC_DEFINES} -DHAVE_DBUS)
else(QT_QTDBUS_FOUND)
message(STATUS "QtDBus not found, disabling D-Bus support")
endif(QT_QTDBUS_FOUND)
ENDMACRO(QT4_GET_MOC_INC_DIRS)
- # Added by Sput to provide definitions to moc calls
- MACRO (QT4_GET_MOC_DEFINES _moc_DEFINES)
- SET(${_moc_DEFINES})
- if(CMAKE_MAJOR_VERSION EQUAL 2 AND CMAKE_MINOR_VERSION LESS 6)
- GET_DIRECTORY_PROPERTY(_defines DEFINITIONS)
- SEPARATE_ARGUMENTS(_defines)
- FOREACH(_current ${_defines})
- SET(${_moc_DEFINES} ${${_moc_DEFINES}} ${_current})
- ENDFOREACH(_current ${_defines})
- else(CMAKE_MAJOR_VERSION EQUAL 2 AND CMAKE_MINOR_VERSION LESS 6)
- GET_DIRECTORY_PROPERTY(_defines COMPILE_DEFINITIONS)
- FOREACH(_current ${_defines})
- SET(${_moc_DEFINES} ${${_moc_DEFINES}} -D${_current})
- ENDFOREACH(_current ${_defines})
- endif(CMAKE_MAJOR_VERSION EQUAL 2 AND CMAKE_MINOR_VERSION LESS 6)
-
- ENDMACRO(QT4_GET_MOC_DEFINES)
-
MACRO (QT4_GENERATE_MOC infile outfile )
# get include dirs
# QT4_GET_MOC_INC_DIRS(moc_includes) # Not needed...
- QT4_GET_MOC_DEFINES(moc_defines)
+ # QT4_GET_MOC_DEFINES(moc_defines) # Now supplied via ${MOC_DEFINES}
GET_FILENAME_COMPONENT(abs_infile ${infile} ABSOLUTE)
ELSE (MSVC_IDE)
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
COMMAND ${QT_MOC_EXECUTABLE}
- ARGS ${moc_includes} ${moc_defines} -o ${outfile} ${abs_infile}
+ ARGS ${moc_includes} ${MOC_DEFINES} -o ${outfile} ${abs_infile}
DEPENDS ${abs_infile})
ENDIF (MSVC_IDE)
MACRO (QT4_WRAP_CPP outfiles )
# get include dirs
# QT4_GET_MOC_INC_DIRS(moc_includes) # Not needed
- QT4_GET_MOC_DEFINES(moc_defines)
+ # QT4_GET_MOC_DEFINES(moc_defines) # Now supplied via ${MOC_DEFINES}
QT4_EXTRACT_OPTIONS(moc_files moc_options ${ARGN})
FOREACH (it ${moc_files})
SET(outfile ${CMAKE_CURRENT_BINARY_DIR}/moc_${outfile}.cxx)
ADD_CUSTOM_COMMAND(OUTPUT ${outfile}
COMMAND ${QT_MOC_EXECUTABLE}
- ARGS ${moc_includes} ${moc_defines} ${moc_options} -o ${outfile} ${it}
+ ARGS ${moc_includes} ${MOC_DEFINES} ${moc_options} -o ${outfile} ${it}
DEPENDS ${it})
SET(${outfiles} ${${outfiles}} ${outfile})
ENDFOREACH(it)
//emit coreConnectionMsg(tr("Connecting..."));
Q_ASSERT(!socket);
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
QSslSocket *sock = new QSslSocket(Client::instance());
#else
if(conn["useSsl"].toBool()) {
}
emit connectionMsg(msg["CoreInfo"].toString());
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
if(coreConnectionInfo["useSsl"].toBool()) {
if(msg["SupportSsl"].toBool()) {
QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
socket->setProperty("UseCompression", true);
}
#endif
-
+
if(!msg["Configured"].toBool()) {
// start wizard
emit startCoreSetup(msg["StorageBackends"].toList());
}
}
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
void ClientSyncer::sslErrors(const QList<QSslError> &errors) {
qDebug() << "SSL Errors:";
foreach(QSslError err, errors)
#include <QString>
#include <QVariantMap>
-#ifndef QT_NO_OPENSSL
-#include <QSslSocket>
+#ifdef HAVE_SSL
+# include <QSslSocket>
#else
-#include <QTcpSocket>
+# include <QTcpSocket>
#endif
class IrcUser;
public:
ClientSyncer(QObject *parent = 0);
~ClientSyncer();
-
+
signals:
void recvPartialItem(quint32 avail, quint32 size);
void connectionError(const QString &errorMsg);
void networksProgress(quint32 part, quint32 total);
void socketStateChanged(QAbstractSocket::SocketState);
void socketDisconnected();
-
+
void startLogin();
void loginFailed(const QString &error);
void loginSuccess();
void startCoreSetup(const QVariantList &);
void coreSetupSuccess();
void coreSetupFailed(const QString &error);
-
+
void encrypted(bool);
-
+
public slots:
void connectToCore(const QVariantMap &);
void loginToCore(const QString &user, const QString &passwd);
void disconnectFromCore();
-
+
private slots:
void coreSocketError(QAbstractSocket::SocketError);
void coreHasData();
void coreSocketDisconnected();
void clientInitAck(const QVariantMap &msg);
-
+
// for sync progress
void networkInitDone();
void checkSyncState();
-
+
void syncToCore(const QVariantMap &sessionState);
void sessionStateReceived(const QVariantMap &state);
-
+
void doCoreSetup(const QVariant &setupData);
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
void sslErrors(const QList<QSslError> &errors);
#endif
-
+
private:
QPointer<QIODevice> socket;
quint32 blockSize;
QVariantMap coreConnectionInfo;
-
+
QSet<QObject *> netsToSync;
int numNetsToSync;
};
"Up %3d%4h%5m (since %6)").arg(Global::quasselVersion).arg(Global::quasselBuildDate)
.arg(updays).arg(uphours,2,10,QChar('0')).arg(upmins,2,10,QChar('0')).arg(startTime().toString(Qt::TextDate));
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
SslServer *sslServer = qobject_cast<SslServer *>(&server);
QSslSocket *sslSocket = qobject_cast<QSslSocket *>(socket);
bool supportSsl = (bool)sslServer && (bool)sslSocket && sslServer->certIsValid();
reply["MsgType"] = "ClientInitAck";
SignalProxy::writeDataToDevice(socket, reply);
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
// after we told the client that we are ssl capable we switch to ssl mode
if(supportSsl && msg["UseSsl"].toBool()) {
quDebug() << qPrintable(tr("Starting TLS for Client:")) << qPrintable(socket->peerAddress().toString());
return sess;
}
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
void Core::sslErrors(const QList<QSslError> &errors) {
Q_UNUSED(errors);
QSslSocket *socket = qobject_cast<QSslSocket *>(sender());
#include <QVariant>
#include <QTimer>
-#ifndef QT_NO_OPENSSL
-#include <QSslSocket>
-#include "sslserver.h"
+#ifdef HAVE_SSL
+# include <QSslSocket>
+# include "sslserver.h"
#else
-#include <QTcpSocket>
-#include <QTcpServer>
+# include <QTcpSocket>
+# include <QTcpServer>
#endif
#include "bufferinfo.h"
bool initStorage(QVariantMap dbSettings, bool setup = false);
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
void sslErrors(const QList<QSslError> &errors);
#endif
void socketError(QAbstractSocket::SocketError);
Storage *storage;
QTimer _storageSyncTimer;
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
SslServer server;
#else
QTcpServer server;
connect(network, SIGNAL(autoReconnectIntervalSet(quint32)), this, SLOT(autoReconnectSettingsChanged()));
connect(network, SIGNAL(autoReconnectRetriesSet(quint16)), this, SLOT(autoReconnectSettingsChanged()));
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
connect(&socket, SIGNAL(encrypted()), this, SLOT(socketEncrypted()));
connect(&socket, SIGNAL(sslErrors(const QList<QSslError> &)), this, SLOT(sslErrors(const QList<QSslError> &)));
#endif
//exit(1);
}
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
void NetworkConnection::sslErrors(const QList<QSslError> &sslErrors) {
Q_UNUSED(sslErrors)
socketInitialized();
}
-#endif // QT_NO_OPENSSL
+#endif // HAVE_SSL
void NetworkConnection::socketConnected() {
-#ifdef QT_NO_OPENSSL
+#ifndef HAVE_SSL
socketInitialized();
return;
#else
#include <QStringList>
#include <QTimer>
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
# include <QSslSocket>
# include <QSslError>
#else
void startAutoWhoCycle();
void nickChanged(const QString &newNick, const QString &oldNick); // this signal is inteded to rename query buffers in the storage backend
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
void socketEncrypted();
void sslErrors(const QList<QSslError> &errors);
#endif
void fillBucketAndProcessQueue();
private:
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
QSslSocket socket;
#else
QTcpSocket socket;
#include "sslserver.h"
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
# include <QSslSocket>
#endif
#include "logger.h"
#include "util.h"
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
SslServer::SslServer(QObject *parent)
: QTcpServer(parent)
}
}
-#endif // QT_NO_OPENSSL
+#endif // HAVE_SSL
#ifndef SSLSERVER_H
#define SSLSERVER_H
-#ifndef QT_NO_OPENSSL
-# include <QSslCertificate>
-# include <QSslKey>
+#ifdef HAVE_SSL
+
+#include <QSslCertificate>
+#include <QSslKey>
#include <QTcpServer>
#include <QLinkedList>
-#endif
-
-#ifndef QT_NO_OPENSSL
class SslServer : public QTcpServer {
Q_OBJECT
bool _certIsValid;
};
-#endif //QT_NO_OPENSSL
+#endif //HAVE_SSL
#endif //SSLSERVER_H
ui.port->setValue(acct["Port"].toUInt());
ui.useInternal->setChecked(acct["UseInternal"].toBool());
ui.accountName->setText(acct["AccountName"].toString());
-#ifndef QT_NO_OPENSSL
+#ifdef HAVE_SSL
ui.useSsl->setChecked(acct["useSsl"].toBool());
#else
ui.useSsl->setChecked(false);
ui.proxyPassword->setText(acct["proxyPassword"].toString());
} else {
setWindowTitle(tr("Add Core Account"));
-#ifdef QT_NO_OPENSSL
+#ifndef HAVE_SSL
ui.useSsl->setChecked(false);
ui.useSsl->setEnabled(false);
#endif