_userInputHandler(new CoreUserInputHandler(this)),
_autoReconnectCount(0),
_quitRequested(false),
+ _disconnectExpected(false),
_previousConnectionAttemptFailed(false),
_lastUsedServerIndex(0),
CoreNetwork::~CoreNetwork()
{
- if (connectionState() != Disconnected && connectionState() != Network::Reconnecting)
- disconnectFromIrc(false); // clean up, but this does not count as requested disconnect!
+ // Request a proper disconnect, but don't count as user-requested disconnect
+ if (socketConnected()) {
+ // Only try if the socket's fully connected (not initializing or disconnecting).
+ // Force an immediate disconnect, jumping the command queue. Ensures the proper QUIT is
+ // shown even if other messages are queued.
+ disconnectFromIrc(false, QString(), false, true);
+ // Process the putCmd events that trigger the quit. Without this, shutting down the core
+ // results in abrubtly closing the socket rather than sending the QUIT as expected.
+ QCoreApplication::processEvents();
+ // Wait briefly for each network to disconnect. Sometimes it takes a little while to send.
+ if (!forceDisconnect()) {
+ qWarning() << "Timed out quitting network" << networkName() <<
+ "(user ID " << userId() << ")";
+ }
+ }
disconnect(&socket, 0, this, 0); // this keeps the socket from triggering events during clean up
delete _userInputHandler;
}
+bool CoreNetwork::forceDisconnect(int msecs)
+{
+ if (socket.state() == QAbstractSocket::UnconnectedState) {
+ // Socket already disconnected.
+ return true;
+ }
+ // Request a socket-level disconnect if not already happened
+ socket.disconnectFromHost();
+ // Return the result of waiting for disconnect; true if successful, otherwise false
+ return socket.waitForDisconnected(msecs);
+}
+
+
QString CoreNetwork::channelDecode(const QString &bufferName, const QByteArray &string) const
{
if (!bufferName.isEmpty()) {
}
-void CoreNetwork::disconnectFromIrc(bool requested, const QString &reason, bool withReconnect)
+void CoreNetwork::disconnectFromIrc(bool requested, const QString &reason, bool withReconnect,
+ bool forceImmediate)
{
+ // Disconnecting from the network, should expect a socket close or error
+ _disconnectExpected = true;
_quitRequested = requested; // see socketDisconnected();
if (!withReconnect) {
_autoReconnectTimer.stop();
socketDisconnected();
} else {
if (socket.state() == QAbstractSocket::ConnectedState) {
- userInputHandler()->issueQuit(_quitReason);
+ userInputHandler()->issueQuit(_quitReason, forceImmediate);
} else {
socket.close();
}
}
-void CoreNetwork::putRawLine(QByteArray s)
+void CoreNetwork::putRawLine(const QByteArray s, const bool prepend)
{
- if (_tokenBucket > 0)
+ if (_tokenBucket > 0) {
writeToSocket(s);
- else
- _msgQueue.append(s);
+ } else {
+ if (prepend) {
+ _msgQueue.prepend(s);
+ } else {
+ _msgQueue.append(s);
+ }
+ }
}
-void CoreNetwork::putCmd(const QString &cmd, const QList<QByteArray> ¶ms, const QByteArray &prefix)
+void CoreNetwork::putCmd(const QString &cmd, const QList<QByteArray> ¶ms, const QByteArray &prefix, const bool prepend)
{
QByteArray msg;
msg += params[i];
}
- putRawLine(msg);
+ putRawLine(msg, prepend);
}
-void CoreNetwork::putCmd(const QString &cmd, const QList<QList<QByteArray>> ¶ms, const QByteArray &prefix)
+void CoreNetwork::putCmd(const QString &cmd, const QList<QList<QByteArray>> ¶ms, const QByteArray &prefix, const bool prependAll)
{
QListIterator<QList<QByteArray>> i(params);
while (i.hasNext()) {
QList<QByteArray> msg = i.next();
- putCmd(cmd, msg, prefix);
+ putCmd(cmd, msg, prefix, prependAll);
}
}
void CoreNetwork::socketError(QAbstractSocket::SocketError error)
{
- if (_quitRequested && error == QAbstractSocket::RemoteHostClosedError)
+ // Ignore socket closed errors if expected
+ if (_disconnectExpected && error == QAbstractSocket::RemoteHostClosedError) {
return;
+ }
_previousConnectionAttemptFailed = true;
qWarning() << qPrintable(tr("Could not connect to %1 (%2)").arg(networkName(), socket.errorString()));
setConnected(false);
emit disconnected(networkId());
emit socketDisconnected(identityPtr(), localAddress(), localPort(), peerAddress(), peerPort());
+ // Reset disconnect expectations
+ _disconnectExpected = false;
if (_quitRequested) {
_quitRequested = false;
setConnectionState(Network::Disconnected);
{
setConnectionState(Network::Initialized);
setConnected(true);
+ _disconnectExpected = false;
_quitRequested = false;
if (useAutoReconnect()) {
void CoreNetwork::beginCapNegotiation()
{
// Don't begin negotiation if no capabilities are queued to request
- if (!capNegotiationInProgress())
+ if (!capNegotiationInProgress()) {
+ // If the server doesn't have any capabilities, but supports CAP LS, continue on with the
+ // normal connection.
+ displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("No capabilities available"));
+ endCapNegotiation();
return;
+ }
_capNegotiationActive = true;
displayMsg(Message::Server, BufferInfo::StatusBuffer, "",
_capNegotiationActive = false;
}
- // If nick registration is already complete, CAP END is not required
- if (!_capInitialNegotiationEnded) {
- putRawLine(serverEncode(QString("CAP END")));
- _capInitialNegotiationEnded = true;
- }
+ endCapNegotiation();
+ }
+}
+
+void CoreNetwork::endCapNegotiation()
+{
+ // If nick registration is already complete, CAP END is not required
+ if (!_capInitialNegotiationEnded) {
+ putRawLine(serverEncode(QString("CAP END")));
+ _capInitialNegotiationEnded = true;
}
}
#ifdef HAVE_SSL
void CoreNetwork::sslErrors(const QList<QSslError> &sslErrors)
{
- Q_UNUSED(sslErrors)
- socket.ignoreSslErrors();
- // TODO errorhandling
+ Server server = usedServer();
+ if (server.sslVerify) {
+ // Treat the SSL error as a hard error
+ QString sslErrorMessage = tr("Encrypted connection couldn't be verified, disconnecting "
+ "since verification is required");
+ if (!sslErrors.empty()) {
+ // Add the error reason if known
+ sslErrorMessage.append(tr(" (Reason: %1)").arg(sslErrors.first().errorString()));
+ }
+ displayMsg(Message::Error, BufferInfo::StatusBuffer, "", sslErrorMessage);
+
+ // Disconnect, triggering a reconnect in case it's a temporary issue with certificate
+ // validity, network trouble, etc.
+ disconnectFromIrc(false, QString("Encrypted connection not verified"), true /* withReconnect */);
+ } else {
+ // Treat the SSL error as a warning, continue to connect anyways
+ QString sslErrorMessage = tr("Encrypted connection couldn't be verified, continuing "
+ "since verification is not required");
+ if (!sslErrors.empty()) {
+ // Add the error reason if known
+ sslErrorMessage.append(tr(" (Reason: %1)").arg(sslErrors.first().errorString()));
+ }
+ displayMsg(Message::Info, BufferInfo::StatusBuffer, "", sslErrorMessage);
+
+ // Proceed with the connection
+ socket.ignoreSslErrors();
+ }
}
projects / quassel.git / blobdiff