+void CoreConnection::resetConnection(bool wantReconnect)
+{
+ if (_resetting)
+ return;
+ _resetting = true;
+
+ _wantReconnect = wantReconnect;
+
+ if (_authHandler) {
+ disconnect(_authHandler, 0, this, 0);
+ _authHandler->close();
+ _authHandler->deleteLater();
+ _authHandler = 0;
+ }
+
+ if (_peer) {
+ disconnect(_peer, 0, this, 0);
+ // peer belongs to the sigproxy and thus gets deleted by it
+ _peer->close();
+ _peer = 0;
+ }
+
+ _netsToSync.clear();
+ _numNetsToSync = 0;
+
+ setProgressMaximum(-1); // disable
+ setState(Disconnected);
+ emit lagUpdated(-1);
+
+ emit connectionMsg(tr("Disconnected from core."));
+ emit encrypted(false);
+
+ // initiate if a reconnect if appropriate
+ CoreConnectionSettings s;
+ if (wantReconnect && s.autoReconnect()) {
+ _reconnectTimer.start();
+ }
+
+ _resetting = false;
+}
+
+
+void CoreConnection::reconnectToCore()
+{
+ if (currentAccount().isValid()) {
+ _wasReconnect = true;
+ connectToCore(currentAccount().accountId());
+ }
+}
+
+
+bool CoreConnection::connectToCore(AccountId accId)
+{
+ if (isConnected())
+ return false;
+
+ CoreAccountSettings s;
+
+ // FIXME: Don't force connection to internal core in mono client
+ if (Quassel::runMode() == Quassel::Monolithic) {
+ _account = accountModel()->account(accountModel()->internalAccount());
+ Q_ASSERT(_account.isValid());
+ }
+ else {
+ if (!accId.isValid()) {
+ // check our settings and figure out what to do
+ if (!s.autoConnectOnStartup())
+ return false;
+ if (s.autoConnectToFixedAccount())
+ accId = s.autoConnectAccount();
+ else
+ accId = s.lastAccount();
+ if (!accId.isValid())
+ return false;
+ }
+ _account = accountModel()->account(accId);
+ if (!_account.accountId().isValid()) {
+ return false;
+ }
+ if (Quassel::runMode() != Quassel::Monolithic) {
+ if (_account.isInternal())
+ return false;
+ }
+ }
+
+ s.setLastAccount(accId);
+ connectToCurrentAccount();
+ return true;
+}
+
+
+void CoreConnection::connectToCurrentAccount()
+{
+ if (_authHandler) {
+ qWarning() << Q_FUNC_INFO << "Already connected!";
+ return;
+ }
+
+ resetConnection(false);
+
+ if (currentAccount().isInternal()) {
+ if (Quassel::runMode() != Quassel::Monolithic) {
+ qWarning() << "Cannot connect to internal core in client-only mode!";
+ return;
+ }
+ emit startInternalCore();
+
+ InternalPeer *peer = new InternalPeer();
+ _peer = peer;
+ Client::instance()->signalProxy()->addPeer(peer); // sigproxy will take ownership
+ emit connectToInternalCore(peer);
+
+ return;
+ }
+
+ _authHandler = new ClientAuthHandler(currentAccount(), this);
+
+ connect(_authHandler, SIGNAL(disconnected()), SLOT(coreSocketDisconnected()));
+ connect(_authHandler, SIGNAL(connectionReady()), SLOT(onConnectionReady()));
+ connect(_authHandler, SIGNAL(socketStateChanged(QAbstractSocket::SocketState)), SLOT(socketStateChanged(QAbstractSocket::SocketState)));
+ connect(_authHandler, SIGNAL(socketError(QAbstractSocket::SocketError,QString)), SLOT(coreSocketError(QAbstractSocket::SocketError,QString)));
+ connect(_authHandler, SIGNAL(transferProgress(int,int)), SLOT(updateProgress(int,int)));
+ connect(_authHandler, SIGNAL(requestDisconnect(QString,bool)), SLOT(disconnectFromCore(QString,bool)));
+
+ connect(_authHandler, SIGNAL(errorMessage(QString)), SIGNAL(connectionError(QString)));
+ connect(_authHandler, SIGNAL(errorPopup(QString)), SIGNAL(connectionErrorPopup(QString)), Qt::QueuedConnection);
+ connect(_authHandler, SIGNAL(statusMessage(QString)), SIGNAL(connectionMsg(QString)));
+ connect(_authHandler, SIGNAL(encrypted(bool)), SIGNAL(encrypted(bool)));
+ connect(_authHandler, SIGNAL(startCoreSetup(QVariantList)), SIGNAL(startCoreSetup(QVariantList)));
+ connect(_authHandler, SIGNAL(coreSetupFailed(QString)), SIGNAL(coreSetupFailed(QString)));
+ connect(_authHandler, SIGNAL(coreSetupSuccessful()), SIGNAL(coreSetupSuccess()));
+ connect(_authHandler, SIGNAL(userAuthenticationRequired(CoreAccount*,bool*,QString)), SIGNAL(userAuthenticationRequired(CoreAccount*,bool*,QString)));
+ connect(_authHandler, SIGNAL(handleNoSslInClient(bool*)), SIGNAL(handleNoSslInClient(bool*)));
+ connect(_authHandler, SIGNAL(handleNoSslInCore(bool*)), SIGNAL(handleNoSslInCore(bool*)));