stubbed out an SslClient, no tests at all but it builds

src/amqp_client.cpp

@@ -32,12 +32,7 @@ ClientPrivate::~ClientPrivate()
 void ClientPrivate::init(const QUrl &connectionString)
 {
     Q_Q(Client);
-    socket = new QTcpSocket(q);
+    initSocket();
-    QObject::connect(socket, SIGNAL(connected()), q, SLOT(_q_socketConnected()));
-    QObject::connect(socket, SIGNAL(readyRead()), q, SLOT(_q_readyRead()));
-    QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
-                          q, SLOT(_q_socketError(QAbstractSocket::SocketError)));
-
     heartbeatTimer = new QTimer(q);
     QObject::connect(heartbeatTimer, SIGNAL(timeout()), q, SLOT(_q_heartbeat()));
 
@@ -50,6 +45,16 @@ void ClientPrivate::init(const QUrl &connectionString)
     }
 }
 
+void ClientPrivate::initSocket()
+{
+    Q_Q(Client);
+    socket = new QTcpSocket(q);
+    QObject::connect(socket, SIGNAL(connected()), q, SLOT(_q_socketConnected()));
+    QObject::connect(socket, SIGNAL(readyRead()), q, SLOT(_q_readyRead()));
+    QObject::connect(socket, SIGNAL(error(QAbstractSocket::SocketError)),
+                          q, SLOT(_q_socketError(QAbstractSocket::SocketError)));
+}
+
 void ClientPrivate::parseConnectionString(const QUrl &connectionString)
 {
     Q_Q(Client);
@@ -60,7 +65,7 @@ void ClientPrivate::parseConnectionString(const QUrl &connectionString)
     }
 
     q->setPassword(connectionString.password());
-    q->setUser(connectionString.userName());
+    q->setUsername(connectionString.userName());
     q->setPort(connectionString.port(AMQPPORT));
     q->setHost(connectionString.host());
     q->setVirtualHost(connectionString.path());
@@ -432,6 +437,12 @@ Client::Client(const QUrl &connectionString, QObject *parent)
     d->init(connectionString);
 }
 
+Client::Client(ClientPrivate *dd, QObject *parent)
+    : QObject(parent),
+      d_ptr(dd)
+{
+}
+
 Client::~Client()
 {
     Q_D(Client);
@@ -481,7 +492,7 @@ void Client::setVirtualHost(const QString &virtualHost)
     d->virtualHost = virtualHost;
 }
 
-QString Client::user() const
+QString Client::username() const
 {
     Q_D(const Client);
     const Authenticator *auth = d->authenticator.data();
@@ -493,13 +504,13 @@ QString Client::user() const
     return QString();
 }
 
-void Client::setUser(const QString &user)
+void Client::setUsername(const QString &username)
 {
     Q_D(const Client);
     Authenticator *auth = d->authenticator.data();
     if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
         AMQPlainAuthenticator *a = static_cast<AMQPlainAuthenticator*>(auth);
-        a->setLogin(user);
+        a->setLogin(username);
     }
 }
 
@@ -507,7 +518,7 @@ QString Client::password() const
 {
     Q_D(const Client);
     const Authenticator *auth = d->authenticator.data();
-    if (auth && auth->type() == "AMQPLAIN") {
+    if (auth && auth->type() == QLatin1String("AMQPLAIN")) {
         const AMQPlainAuthenticator *a = static_cast<const AMQPlainAuthenticator*>(auth);
         return a->password();
     }
@@ -627,4 +638,66 @@ void Client::disconnectFromHost()
     d->_q_disconnect();
 }
 
+//////////////////////////////////////////////////////////////////////////
+
+#ifndef QT_NO_SSL
+#include <QSslSocket>
+
+SslClientPrivate::SslClientPrivate(SslClient *q)
+    : ClientPrivate(q)
+{
+}
+
+void SslClientPrivate::initSocket()
+{
+    Q_Q(Client);
+    QSslSocket *sslSocket = new QSslSocket(q);
+    QObject::connect(sslSocket, SIGNAL(connected()), q, SLOT(_q_socketConnected()));
+    QObject::connect(sslSocket, SIGNAL(readyRead()), q, SLOT(_q_readyRead()));
+    QObject::connect(sslSocket, SIGNAL(error(QAbstractSocket::SocketError)),
+                          q, SLOT(_q_socketError(QAbstractSocket::SocketError)));
+    QObject::connect(sslSocket, SIGNAL(sslErrors(QList<QSslError>)),
+                             q, SLOT(_q_sslErrors(QList<QSslError>)));
+    socket = sslSocket;
+}
+
+void SslClientPrivate::_q_connect()
+{
+    if (socket->state() != QAbstractSocket::UnconnectedState) {
+        qDebug() << Q_FUNC_INFO << "socket already connected, disconnecting..";
+        _q_disconnect();
+    }
+
+    QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
+    if (!sslConfiguration.isNull())
+        sslSocket->setSslConfiguration(sslConfiguration);
+    sslSocket->connectToHostEncrypted(host, port);
+}
+
+void SslClientPrivate::_q_sslErrors(const QList<QSslError> &errors)
+{
+    // TODO: these need to be passed on to the user potentially, this is
+    //       very unsafe
+    QSslSocket *sslSocket = qobject_cast<QSslSocket*>(socket);
+    sslSocket->ignoreSslErrors(errors);
+}
+
+SslClient::SslClient(QObject *parent)
+    : Client(new SslClientPrivate(this), parent)
+{
+}
+
+SslClient::SslClient(const QUrl &connectionString, QObject *parent)
+    : Client(new SslClientPrivate(this), parent)
+{
+    Q_D(SslClient);
+    d->init(connectionString);
+}
+
+SslClient::~SslClient()
+{
+}
+
+#endif
+
 #include "moc_amqp_client.cpp"

src/amqp_client.h

@@ -5,6 +5,11 @@
 #include <QUrl>
 #include <QHostAddress>
 
+#ifndef QT_NO_SSL
+#include <QSslConfiguration>
+#include <QSslError>
+#endif
+
 #include "amqp_global.h"
 
 namespace QAMQP
@@ -20,7 +25,7 @@ class QAMQP_EXPORT Client : public QObject
     Q_PROPERTY(quint32 port READ port WRITE setPort)
     Q_PROPERTY(QString host READ host WRITE setHost)
     Q_PROPERTY(QString virtualHost READ virtualHost WRITE setVirtualHost)
-    Q_PROPERTY(QString user READ user WRITE setUser)
+    Q_PROPERTY(QString user READ username WRITE setUsername)
     Q_PROPERTY(QString password READ password WRITE setPassword)
     Q_PROPERTY(bool autoReconnect READ autoReconnect WRITE setAutoReconnect)
 
@@ -29,15 +34,7 @@ public:
     Client(const QUrl &connectionString, QObject *parent = 0);
     ~Client();
 
-    void addCustomProperty(const QString &name, const QString &value);
+    // properties
-    QString customProperty(const QString &name) const;
-
-    Exchange *createExchange(int channelNumber = -1);
-    Exchange *createExchange(const QString &name, int channelNumber = -1);
-
-    Queue *createQueue(int channelNumber = -1);
-    Queue *createQueue(const QString &name, int channelNumber = -1);
-
     quint16 port() const;
     void setPort(quint16 port);
 
@@ -47,8 +44,8 @@ public:
     QString virtualHost() const;
     void setVirtualHost(const QString &virtualHost);
 
-    QString user() const;
+    QString username() const;
-    void setUser(const QString &user);
+    void setUsername(const QString &username);
 
     QString password() const;
     void setPassword(const QString &password);
@@ -61,6 +58,17 @@ public:
 
     bool isConnected() const;
 
+    void addCustomProperty(const QString &name, const QString &value);
+    QString customProperty(const QString &name) const;
+
+    // channels
+    Exchange *createExchange(int channelNumber = -1);
+    Exchange *createExchange(const QString &name, int channelNumber = -1);
+
+    Queue *createQueue(int channelNumber = -1);
+    Queue *createQueue(const QString &name, int channelNumber = -1);
+
+    // methods
     void connectToHost(const QString &connectionString = QString());
     void connectToHost(const QHostAddress &address, quint16 port = AMQPPORT);
     void disconnectFromHost();
@@ -69,11 +77,14 @@ Q_SIGNALS:
     void connected();
     void disconnected();
 
-private:
+protected:
+    Client(ClientPrivate *dd, QObject *parent = 0);
+
     Q_DISABLE_COPY(Client)
     Q_DECLARE_PRIVATE(Client)
     QScopedPointer<ClientPrivate> d_ptr;
 
+private:
     Q_PRIVATE_SLOT(d_func(), void _q_socketConnected())
     Q_PRIVATE_SLOT(d_func(), void _q_readyRead())
     Q_PRIVATE_SLOT(d_func(), void _q_socketError(QAbstractSocket::SocketError error))
@@ -85,6 +96,28 @@ private:
 
 };
 
+#ifndef QT_NO_SSL
+class SslClientPrivate;
+class SslClient : public Client
+{
+    Q_OBJECT
+public:
+    SslClient(QObject *parent = 0);
+    SslClient(const QUrl &connectionString, QObject *parent = 0);
+    ~SslClient();
+
+    QSslConfiguration sslConfiguration() const;
+    void setSslConfiguration(const QSslConfiguration &config);
+
+private:
+    Q_DISABLE_COPY(SslClient)
+    Q_DECLARE_PRIVATE(SslClient)
+
+    Q_PRIVATE_SLOT(d_func(), void _q_sslErrors(const QList<QSslError> &errors))
+
+};
+#endif
+
 } // namespace QAMQP
 
 #endif // amqp_client_h__

src/amqp_client_p.h

@@ -35,7 +35,8 @@ public:
     ClientPrivate(Client *q);
     virtual ~ClientPrivate();
 
-    void init(const QUrl &connectionString = QUrl());
+    virtual void init(const QUrl &connectionString = QUrl());
+    virtual void initSocket();
     void parseConnectionString(const QUrl &connectionString);
     void sendFrame(const Frame::Base &frame);
 
@@ -44,7 +45,7 @@ public:
     void _q_readyRead();
     void _q_socketError(QAbstractSocket::SocketError error);
     void _q_heartbeat();
-    void _q_connect();
+    virtual void _q_connect();
     void _q_disconnect();
 
     virtual bool _q_method(const Frame::Method &frame);
@@ -95,6 +96,23 @@ public:
 
 };
 
+#ifndef QT_NO_SSL
+class SslClientPrivate : public ClientPrivate
+{
+public:
+    SslClientPrivate(SslClient *q);
+
+    virtual void initSocket();
+    virtual void _q_connect();
+
+    // private slots
+    void _q_sslErrors(const QList<QSslError> &errors);
+
+    QSslConfiguration sslConfiguration;
+
+};
+#endif
+
 } // namespace QAMQP
 
 #endif // amqp_client_p_h__