X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fclient%2Fcoreconnection.cpp;h=f5239140281f9364735a5b22b9bb24626e665cec;hp=3d769cc31ef4f9990264ce0840b25234f33dba40;hb=cf721fb75a7525b03c0086f98314b828f5322001;hpb=67a80c804797ba432378ad6b81fc82b1aa0d9a1d

diff --git a/src/client/coreconnection.cpp b/src/client/coreconnection.cpp
index 3d769cc3..f5239140 100644
--- a/src/client/coreconnection.cpp
+++ b/src/client/coreconnection.cpp
@@ -39,16 +39,32 @@ CoreConnection::CoreConnection(CoreAccountModel *model, QObject *parent)
   _model(model),
   _blockSize(0),
   _state(Disconnected),
+  _wantReconnect(false),
   _progressMinimum(0),
   _progressMaximum(-1),
   _progressValue(-1)
 {
   qRegisterMetaType<ConnectionState>("CoreConnection::ConnectionState");
-
 }
 
 void CoreConnection::init() {
+  Client::signalProxy()->setHeartBeatInterval(30);
   connect(Client::signalProxy(), SIGNAL(disconnected()), SLOT(coreSocketDisconnected()));
+  connect(Client::signalProxy(), SIGNAL(lagUpdated(int)), SIGNAL(lagUpdated(int)));
+
+  _reconnectTimer.setSingleShot(true);
+  connect(&_reconnectTimer, SIGNAL(timeout()), SLOT(reconnectTimeout()));
+
+#ifdef HAVE_KDE
+  connect(Solid::Networking::notifier(), SIGNAL(statusChanged(Solid::Networking::Status)),
+          SLOT(solidNetworkStatusChanged(Solid::Networking::Status)));
+#endif
+
+  CoreConnectionSettings s;
+  s.initAndNotify("PingTimeoutInterval", this, SLOT(pingTimeoutIntervalChanged(QVariant)), 60);
+  s.initAndNotify("ReconnectInterval", this, SLOT(reconnectIntervalChanged(QVariant)), 60);
+  s.notify("NetworkDetectionMode", this, SLOT(networkDetectionModeChanged(QVariant)));
+  networkDetectionModeChanged(s.networkDetectionMode());
 }
 
 void CoreConnection::setProgressText(const QString &text) {
@@ -87,25 +103,75 @@ void CoreConnection::updateProgress(int value, int max) {
   setProgressValue(value);
 }
 
-void CoreConnection::resetConnection() {
-  if(_socket) {
-    disconnect(_socket, 0, this, 0);
-    _socket->deleteLater();
-    _socket = 0;
+void CoreConnection::reconnectTimeout() {
+  if(!_socket) {
+    CoreConnectionSettings s;
+    if(_wantReconnect && s.autoReconnect()) {
+
+#ifdef HAVE_KDE
+      // If using Solid, we don't want to reconnect if we're offline
+      if(s.networkDetectionMode() == CoreConnectionSettings::UseSolid) {
+        if(Solid::Networking::status() != Solid::Networking::Connected
+           && Solid::Networking::status() != Solid::Networking::Unknown) {
+          return;
+        }
+      }
+#endif /* HAVE_KDE */
+
+      reconnectToCore();
+    }
   }
-  _blockSize = 0;
+}
 
-  _coreMsgBuffer.clear();
+void CoreConnection::networkDetectionModeChanged(const QVariant &vmode) {
+  CoreConnectionSettings s;
+  CoreConnectionSettings::NetworkDetectionMode mode = (CoreConnectionSettings::NetworkDetectionMode)vmode.toInt();
+  if(mode == CoreConnectionSettings::UsePingTimeout)
+    Client::signalProxy()->setMaxHeartBeatCount(s.pingTimeoutInterval() / 30);
+  else {
+    Client::signalProxy()->setMaxHeartBeatCount(-1);
+  }
+}
 
-  _netsToSync.clear();
-  _numNetsToSync = 0;
+void CoreConnection::pingTimeoutIntervalChanged(const QVariant &interval) {
+  CoreConnectionSettings s;
+  if(s.networkDetectionMode() == CoreConnectionSettings::UsePingTimeout)
+    Client::signalProxy()->setMaxHeartBeatCount(interval.toInt() / 30); // interval is 30 seconds
+}
 
-  setProgressMaximum(-1); // disable
-  setState(Disconnected);
-  emit connectionMsg(tr("Disconnected from core."));
-  emit encrypted(false);
+void CoreConnection::reconnectIntervalChanged(const QVariant &interval) {
+  _reconnectTimer.setInterval(interval.toInt() * 1000);
+}
+
+#ifdef HAVE_KDE
+
+void CoreConnection::solidNetworkStatusChanged(Solid::Networking::Status status) {
+  CoreConnectionSettings s;
+  if(s.networkDetectionMode() != CoreConnectionSettings::UseSolid)
+    return;
+
+  switch(status) {
+  case Solid::Networking::Unknown:
+  case Solid::Networking::Connected:
+    qDebug() << "Solid: Network status changed to connected or unknown";
+    if(state() == Disconnected) {
+      if(_wantReconnect && s.autoReconnect()) {
+        reconnectToCore();
+      }
+    }
+    break;
+  case Solid::Networking::Unconnected:
+    qDebug() << "Solid: Disconnected";
+    if(!isLocalConnection())
+      disconnectFromCore(tr("Network is down"), true);
+    break;
+  default:
+    break;
+  }
 }
 
+#endif
+
 bool CoreConnection::isEncrypted() const {
 #ifndef HAVE_SSL
   return false;
@@ -115,6 +181,17 @@ bool CoreConnection::isEncrypted() const {
 #endif
 }
 
+bool CoreConnection::isLocalConnection() const {
+  if(!isConnected())
+    return false;
+  if(currentAccount().isInternal())
+    return true;
+  if(_socket->peerAddress().isInSubnet(QHostAddress::LocalHost, 0x00ffffff))
+    return true;
+
+  return false;
+}
+
 void CoreConnection::socketStateChanged(QAbstractSocket::SocketState socketState) {
   QString text;
 
@@ -153,6 +230,7 @@ void CoreConnection::setState(QAbstractSocket::SocketState socketState) {
     break;
   case QAbstractSocket::HostLookupState:
   case QAbstractSocket::ConnectingState:
+  case QAbstractSocket::ConnectedState:  // we'll set it to Connected in connectionReady()
     state = Connecting;
     break;
   default:
@@ -173,13 +251,12 @@ void CoreConnection::setState(ConnectionState state) {
 
 void CoreConnection::coreSocketError(QAbstractSocket::SocketError) {
   qDebug() << "coreSocketError" << _socket << _socket->errorString();
-  emit connectionError(_socket->errorString());
-  resetConnection();
+  disconnectFromCore(_socket->errorString(), true);
 }
 
 void CoreConnection::coreSocketDisconnected() {
-  emit disconnected();
-  resetConnection();
+  qDebug() << Q_FUNC_INFO;
+  resetConnection(true);
   // FIXME handle disconnects gracefully
 }
 
@@ -190,19 +267,19 @@ void CoreConnection::coreHasData() {
     if(!msg.contains("MsgType")) {
       // This core is way too old and does not even speak our init protocol...
       emit connectionErrorPopup(tr("The Quassel Core you try to connect to is too old! Please consider upgrading."));
-      disconnectFromCore();
+      disconnectFromCore(QString(), false);
       return;
     }
     if(msg["MsgType"] == "ClientInitAck") {
       clientInitAck(msg);
     } else if(msg["MsgType"] == "ClientInitReject") {
       emit connectionErrorPopup(msg["Error"].toString());
-      disconnectFromCore();
+      disconnectFromCore(QString(), false);
       return;
     } else if(msg["MsgType"] == "CoreSetupAck") {
-      //emit coreSetupSuccess();
+      emit coreSetupSuccess();
     } else if(msg["MsgType"] == "CoreSetupReject") {
-      //emit coreSetupFailed(msg["Error"].toString());
+      emit coreSetupFailed(msg["Error"].toString());
     } else if(msg["MsgType"] == "ClientLoginReject") {
       loginFailed(msg["Error"].toString());
     } else if(msg["MsgType"] == "ClientLoginAck") {
@@ -217,7 +294,7 @@ void CoreConnection::coreHasData() {
       sessionStateReceived(msg["SessionState"].toMap());
       break; // this is definitively the last message we process here!
     } else {
-      disconnectFromCore(tr("Invalid data received from core"));
+      disconnectFromCore(tr("Invalid data received from core"), false);
       return;
     }
   }
@@ -226,14 +303,50 @@ void CoreConnection::coreHasData() {
   }
 }
 
-void CoreConnection::disconnectFromCore(const QString &errorString) {
+void CoreConnection::disconnectFromCore() {
+  disconnectFromCore(QString(), false);  // requested disconnect, so don't try to reconnect
+}
+
+void CoreConnection::disconnectFromCore(const QString &errorString, bool wantReconnect) {
+  if(!wantReconnect)
+    _reconnectTimer.stop();
+
   if(errorString.isEmpty())
     emit connectionError(tr("Disconnected"));
   else
     emit connectionError(errorString);
 
   Client::signalProxy()->removeAllPeers();
-  resetConnection();
+  resetConnection(wantReconnect);
+}
+
+void CoreConnection::resetConnection(bool wantReconnect) {
+  _wantReconnect = wantReconnect;
+
+  if(_socket) {
+    disconnect(_socket, 0, this, 0);
+    _socket->deleteLater();
+    _socket = 0;
+  }
+  _blockSize = 0;
+
+  _coreMsgBuffer.clear();
+
+  _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();
+  }
 }
 
 void CoreConnection::reconnectToCore() {
@@ -279,7 +392,7 @@ bool CoreConnection::connectToCore(AccountId accId) {
 }
 
 void CoreConnection::connectToCurrentAccount() {
-  resetConnection();
+  resetConnection(false);
 
   if(currentAccount().isInternal()) {
     if(Quassel::runMode() != Quassel::Monolithic) {
@@ -357,10 +470,12 @@ void CoreConnection::clientInitAck(const QVariantMap &msg) {
   if(ver < Quassel::buildInfo().clientNeedsProtocol) {
     emit connectionErrorPopup(tr("<b>The Quassel Core you are trying to connect to is too old!</b><br>"
         "Need at least core/client protocol v%1 to connect.").arg(Quassel::buildInfo().clientNeedsProtocol));
-    disconnectFromCore();
+    disconnectFromCore(QString(), false);
     return;
   }
 
+  Client::setCoreFeatures((Quassel::Features)msg["CoreFeatures"].toUInt());
+
 #ifndef QT_NO_COMPRESS
   if(msg["SupportsCompression"].toBool()) {
     _socket->setProperty("UseCompression", true);
@@ -386,7 +501,7 @@ void CoreConnection::clientInitAck(const QVariantMap &msg) {
         bool accepted = false;
         emit handleNoSslInCore(&accepted);
         if(!accepted) {
-          disconnectFromCore(tr("Unencrypted connection canceled"));
+          disconnectFromCore(tr("Unencrypted connection canceled"), false);
           return;
         }
         s.setAccountValue("ShowNoCoreSslWarning", false);
@@ -431,7 +546,7 @@ void CoreConnection::sslErrors() {
     emit handleSslErrors(socket, &accepted, &permanently);
 
     if(!accepted) {
-      disconnectFromCore(tr("Unencrypted connection canceled"));
+      disconnectFromCore(tr("Unencrypted connection canceled"), false);
       return;
     }
 
@@ -459,13 +574,20 @@ void CoreConnection::connectionReady() {
   _coreMsgBuffer.clear();
 }
 
+void CoreConnection::loginToCore(const QString &user, const QString &password, bool remember) {
+  _account.setUser(user);
+  _account.setPassword(password);
+  _account.setStorePassword(remember);
+  loginToCore();
+}
+
 void CoreConnection::loginToCore(const QString &prevError) {
   emit connectionMsg(tr("Logging in..."));
   if(currentAccount().user().isEmpty() || currentAccount().password().isEmpty() || !prevError.isEmpty()) {
     bool valid = false;
     emit userAuthenticationRequired(&_account, &valid, prevError);  // *must* be a synchronous call
     if(!valid || currentAccount().user().isEmpty() || currentAccount().password().isEmpty()) {
-      disconnectFromCore(tr("Login canceled"));
+      disconnectFromCore(tr("Login canceled"), false);
       return;
     }
   }
@@ -488,6 +610,8 @@ void CoreConnection::loginSuccess() {
   _model->createOrUpdateAccount(currentAccount());
   _model->save();
 
+  _reconnectTimer.stop();
+
   setProgressText(tr("Receiving session state"));
   setState(Synchronizing);
   emit connectionMsg(tr("Synchronizing to %1...").arg(currentAccount().accountName()));
@@ -548,8 +672,9 @@ void CoreConnection::syncToCore(const QVariantMap &sessionState) {
   checkSyncState();
 }
 
+// this is also called for destroyed networks!
 void CoreConnection::networkInitDone() {
-  Network *net = qobject_cast<Network *>(sender());
+  QObject *net = sender();
   Q_ASSERT(net);
   disconnect(net, 0, this, 0);
   _netsToSync.remove(net);
@@ -558,10 +683,17 @@ void CoreConnection::networkInitDone() {
 }
 
 void CoreConnection::checkSyncState() {
-  if(_netsToSync.isEmpty()) {
+  if(_netsToSync.isEmpty() && state() >= Synchronizing) {
     setState(Synchronized);
     setProgressText(tr("Synchronized to %1").arg(currentAccount().accountName()));
     setProgressMaximum(-1);
     emit synchronized();
   }
 }
+
+void CoreConnection::doCoreSetup(const QVariant &setupData) {
+  QVariantMap setup;
+  setup["MsgType"] = "CoreSetupData";
+  setup["SetupData"] = setupData;
+  SignalProxy::writeDataToDevice(_socket, setup);
+}