X-Git-Url: https://git.quassel-irc.org/?p=quassel.git;a=blobdiff_plain;f=src%2Fcore%2Fnetworkconnection.cpp;h=3d9fcc73c18dff8defef76c5130b7999c3195384;hp=651a1bea9dc0875d88d88822a4bdcb2a95f621c1;hb=546e609b7e2fa683e8b7b90d6079dd3a80ed4c6b;hpb=da3aa4136fe01e142238f0f42fe1273481037b9d diff --git a/src/core/networkconnection.cpp b/src/core/networkconnection.cpp index 651a1bea..3d9fcc73 100644 --- a/src/core/networkconnection.cpp +++ b/src/core/networkconnection.cpp @@ -36,24 +36,66 @@ #include "userinputhandler.h" #include "ctcphandler.h" -NetworkConnection::NetworkConnection(Network *network, CoreSession *session) : QObject(network), +NetworkConnection::NetworkConnection(Network *network, CoreSession *session) + : QObject(network), _connectionState(Network::Disconnected), _network(network), _coreSession(session), _ircServerHandler(new IrcServerHandler(this)), _userInputHandler(new UserInputHandler(this)), _ctcpHandler(new CtcpHandler(this)), - _autoReconnectCount(0) + _autoReconnectCount(0), + _quitRequested(false), + + _previousConnectionAttemptFailed(false), + _lastUsedServerlistIndex(0), + + // TODO make autowho configurable (possibly per-network) + _autoWhoEnabled(true), + _autoWhoInterval(90), + _autoWhoNickLimit(0), // unlimited + _autoWhoDelay(3), + + // TokenBucket to avaid sending too much at once + _messagesPerSecond(1), + _burstSize(5), + _tokenBucket(5), // init with a full bucket + + // TODO: + // should be 510 (2 bytes are added when writing to the socket) + // maxMsgSize is 510 minus the hostmask which will be added by the server + _maxMsgSize(450) { _autoReconnectTimer.setSingleShot(true); + _socketCloseTimer.setSingleShot(true); + connect(&_socketCloseTimer, SIGNAL(timeout()), this, SLOT(socketCloseTimeout())); + + _autoWhoTimer.setInterval(_autoWhoDelay * 1000); + _autoWhoCycleTimer.setInterval(_autoWhoInterval * 1000); + + _tokenBucketTimer.start(_messagesPerSecond * 1000); + + QHash channels = coreSession()->persistentChannels(networkId()); + foreach(QString chan, channels.keys()) { + _channelKeys[chan.toLower()] = channels[chan]; + } + connect(&_autoReconnectTimer, SIGNAL(timeout()), this, SLOT(doAutoReconnect())); + connect(&_autoWhoTimer, SIGNAL(timeout()), this, SLOT(sendAutoWho())); + connect(&_autoWhoCycleTimer, SIGNAL(timeout()), this, SLOT(startAutoWhoCycle())); + connect(&_tokenBucketTimer, SIGNAL(timeout()), this, SLOT(fillBucketAndProcessQueue())); connect(network, SIGNAL(currentServerSet(const QString &)), this, SLOT(networkInitialized(const QString &))); connect(network, SIGNAL(useAutoReconnectSet(bool)), this, SLOT(autoReconnectSettingsChanged())); connect(network, SIGNAL(autoReconnectIntervalSet(quint32)), this, SLOT(autoReconnectSettingsChanged())); connect(network, SIGNAL(autoReconnectRetriesSet(quint16)), this, SLOT(autoReconnectSettingsChanged())); +#ifndef QT_NO_OPENSSL + connect(&socket, SIGNAL(encrypted()), this, SLOT(socketEncrypted())); + connect(&socket, SIGNAL(sslErrors(const QList &)), this, SLOT(sslErrors(const QList &))); +#endif connect(&socket, SIGNAL(connected()), this, SLOT(socketConnected())); + connect(&socket, SIGNAL(disconnected()), this, SLOT(socketDisconnected())); connect(&socket, SIGNAL(error(QAbstractSocket::SocketError)), this, SLOT(socketError(QAbstractSocket::SocketError))); connect(&socket, SIGNAL(stateChanged(QAbstractSocket::SocketState)), this, SLOT(socketStateChanged(QAbstractSocket::SocketState))); @@ -61,63 +103,25 @@ NetworkConnection::NetworkConnection(Network *network, CoreSession *session) : Q connect(_ircServerHandler, SIGNAL(nickChanged(const QString &, const QString &)), this, SLOT(nickChanged(const QString &, const QString &))); + + network->proxy()->attachSignal(this, SIGNAL(sslErrors(const QVariant &))); } NetworkConnection::~NetworkConnection() { if(connectionState() != Network::Disconnected && connectionState() != Network::Reconnecting) - disconnectFromIrc(); + disconnectFromIrc(false); // clean up, but this does not count as requested disconnect! + disconnect(&socket, 0, this, 0); // this keeps the socket from triggering events during clean up delete _ircServerHandler; delete _userInputHandler; delete _ctcpHandler; } -bool NetworkConnection::isConnected() const { - // return socket.state() == QAbstractSocket::ConnectedState; - return connectionState() == Network::Initialized; -} - -Network::ConnectionState NetworkConnection::connectionState() const { - return _connectionState; -} - void NetworkConnection::setConnectionState(Network::ConnectionState state) { _connectionState = state; network()->setConnectionState(state); emit connectionStateChanged(state); } -NetworkId NetworkConnection::networkId() const { - return network()->networkId(); -} - -QString NetworkConnection::networkName() const { - return network()->networkName(); -} - -Identity *NetworkConnection::identity() const { - return coreSession()->identity(network()->identity()); -} - -Network *NetworkConnection::network() const { - return _network; -} - -CoreSession *NetworkConnection::coreSession() const { - return _coreSession; -} - -IrcServerHandler *NetworkConnection::ircServerHandler() const { - return _ircServerHandler; -} - -UserInputHandler *NetworkConnection::userInputHandler() const { - return _userInputHandler; -} - -CtcpHandler *NetworkConnection::ctcpHandler() const { - return _ctcpHandler; -} - QString NetworkConnection::serverDecode(const QByteArray &string) const { return network()->decodeServerString(string); } @@ -183,9 +187,20 @@ void NetworkConnection::connectToIrc(bool reconnecting) { qWarning() << "Invalid identity configures, ignoring connect request!"; return; } - // TODO implement cycling / random servers - QString host = serverList[0].toMap()["Host"].toString(); - quint16 port = serverList[0].toMap()["Port"].toUInt(); + // use a random server? + if(network()->useRandomServer()) { + _lastUsedServerlistIndex = qrand() % serverList.size(); + } else if(_previousConnectionAttemptFailed) { + // cycle to next server if previous connection attempt failed + displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Connection failed. Cycling to next Server")); + if(++_lastUsedServerlistIndex == serverList.size()) { + _lastUsedServerlistIndex = 0; + } + } + _previousConnectionAttemptFailed = false; + + QString host = serverList[_lastUsedServerlistIndex].toMap()["Host"].toString(); + quint16 port = serverList[_lastUsedServerlistIndex].toMap()["Port"].toUInt(); displayStatusMsg(tr("Connecting to %1:%2...").arg(host).arg(port)); displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Connecting to %1:%2...").arg(host).arg(port)); socket.connectToHost(host, port); @@ -205,6 +220,11 @@ void NetworkConnection::networkInitialized(const QString ¤tServer) { network()->setConnected(true); emit connected(networkId()); + if(_autoWhoEnabled) { + _autoWhoCycleTimer.start(); + _autoWhoTimer.start(); + startAutoWhoCycle(); // FIXME wait for autojoin to be completed + } } void NetworkConnection::sendPerform() { @@ -220,25 +240,33 @@ void NetworkConnection::sendPerform() { // rejoin channels we've been in QStringList channels, keys; - foreach(QString chan, network()->persistentChannels().keys()) { - QString key = network()->persistentChannels()[chan]; + foreach(QString chan, persistentChannels()) { + QString key = channelKey(chan); if(!key.isEmpty()) { channels.prepend(chan); keys.prepend(key); } else { channels.append(chan); } } - userInputHandler()->handleJoin(statusBuf, QString("%1 %2").arg(channels.join(",")).arg(keys.join(","))); + QString joinString = QString("%1 %2").arg(channels.join(",")).arg(keys.join(",")).trimmed(); + if(!joinString.isEmpty()) userInputHandler()->handleJoin(statusBuf, joinString); } -void NetworkConnection::disconnectFromIrc() { +void NetworkConnection::disconnectFromIrc(bool requested) { _autoReconnectTimer.stop(); _autoReconnectCount = 0; displayMsg(Message::Server, BufferInfo::StatusBuffer, "", tr("Disconnecting.")); if(socket.state() < QAbstractSocket::ConnectedState) { setConnectionState(Network::Disconnected); socketDisconnected(); - } else socket.disconnectFromHost(); + } else { + _socketCloseTimer.start(10000); // the irc server has 10 seconds to close the socket + } + + // this flag triggers quitRequested() once the socket is closed + // it is needed to determine whether or not the connection needs to be + // in the automatic session restore. + _quitRequested = requested; } void NetworkConnection::socketHasData() { @@ -249,6 +277,7 @@ void NetworkConnection::socketHasData() { } void NetworkConnection::socketError(QAbstractSocket::SocketError) { + _previousConnectionAttemptFailed = true; qDebug() << qPrintable(tr("Could not connect to %1 (%2)").arg(network()->networkName(), socket.errorString())); emit connectionError(socket.errorString()); emit displayMsg(Message::Error, BufferInfo::StatusBuffer, "", tr("Connection failure: %1").arg(socket.errorString())); @@ -257,9 +286,53 @@ void NetworkConnection::socketError(QAbstractSocket::SocketError) { setConnectionState(Network::Disconnected); socketDisconnected(); } + // mark last connection attempt as failed + + //qDebug() << "exiting..."; + //exit(1); +} + +#ifndef QT_NO_OPENSSL + +void NetworkConnection::sslErrors(const QList &sslErrors) { + Q_UNUSED(sslErrors) + socket.ignoreSslErrors(); + /* TODO errorhandling + QVariantMap errmsg; + QVariantList errnums; + foreach(QSslError err, errors) errnums << err.error(); + errmsg["SslErrors"] = errnums; + errmsg["SslCert"] = socket.peerCertificate().toPem(); + errmsg["PeerAddress"] = socket.peerAddress().toString(); + errmsg["PeerPort"] = socket.peerPort(); + errmsg["PeerName"] = socket.peerName(); + emit sslErrors(errmsg); + disconnectFromIrc(); + */ +} + +void NetworkConnection::socketEncrypted() { + //qDebug() << "encrypted!"; + socketInitialized(); } +#endif // QT_NO_OPENSSL + void NetworkConnection::socketConnected() { +#ifdef QT_NO_OPENSSL + socketInitialized(); + return; +#else + if(!network()->serverList()[_lastUsedServerlistIndex].toMap()["UseSSL"].toBool()) { + socketInitialized(); + return; + } + //qDebug() << "starting handshake"; + socket.startClientEncryption(); +#endif +} + +void NetworkConnection::socketInitialized() { //emit connected(networkId()); initialize first! Identity *identity = coreSession()->identity(network()->identity()); if(!identity) { @@ -267,6 +340,10 @@ void NetworkConnection::socketConnected() { disconnectFromIrc(); return; } + QString passwd = network()->serverList()[_lastUsedServerlistIndex].toMap()["Password"].toString(); + if(!passwd.isEmpty()) { + putRawLine(serverEncode(QString("PASS %1").arg(passwd))); + } putRawLine(serverEncode(QString("NICK :%1").arg(identity->nicks()[0]))); // FIXME: try more nicks if error occurs putRawLine(serverEncode(QString("USER %1 8 * :%2").arg(identity->ident(), identity->realName()))); } @@ -293,14 +370,26 @@ void NetworkConnection::socketStateChanged(QAbstractSocket::SocketState socketSt setConnectionState(state); } +void NetworkConnection::socketCloseTimeout() { + socket.disconnectFromHost(); +} + void NetworkConnection::socketDisconnected() { + _autoWhoCycleTimer.stop(); + _autoWhoTimer.stop(); + _autoWhoQueue.clear(); + _autoWhoInProgress.clear(); + + _socketCloseTimer.stop(); + network()->setConnected(false); emit disconnected(networkId()); - if(_autoReconnectCount == 0) emit quitRequested(networkId()); - else { + if(_autoReconnectCount != 0) { setConnectionState(Network::Reconnecting); if(_autoReconnectCount == network()->autoReconnectRetries()) doAutoReconnect(); // first try is immediate else _autoReconnectTimer.start(); + } else if(_quitRequested) { + emit quitRequested(networkId()); } } @@ -319,8 +408,29 @@ void NetworkConnection::userInput(BufferInfo buf, QString msg) { } void NetworkConnection::putRawLine(QByteArray s) { + if(_tokenBucket > 0) { + // qDebug() << "putRawLine: " << s; + writeToSocket(s); + } else { + _msgQueue.append(s); + } +} + +void NetworkConnection::writeToSocket(QByteArray s) { s += "\r\n"; + // qDebug() << "writeToSocket: " << s.size(); socket.write(s); + _tokenBucket--; +} + +void NetworkConnection::fillBucketAndProcessQueue() { + if(_tokenBucket < _burstSize) { + _tokenBucket++; + } + + while(_msgQueue.size() > 0 && _tokenBucket > 0) { + writeToSocket(_msgQueue.takeFirst()); + } } void NetworkConnection::putCmd(const QString &cmd, const QVariantList ¶ms, const QByteArray &prefix) { @@ -335,20 +445,83 @@ void NetworkConnection::putCmd(const QString &cmd, const QVariantList ¶ms, c if(!params.isEmpty()) msg += " :" + params.last().toByteArray(); + if(cmd == "PRIVMSG" && params.count() > 1) { + QByteArray msghead = "PRIVMSG " + params[0].toByteArray() + " :"; + + while (msg.size() > _maxMsgSize) { + QByteArray splitter(" .,-"); + int splitPosition = 0; + for(int i = 0; i < splitter.size(); i++) { + splitPosition = qMax(splitPosition, msg.lastIndexOf(splitter[i], _maxMsgSize)); + } + if(splitPosition < 300) { + splitPosition = _maxMsgSize; + } + putRawLine(msg.left(splitPosition)); + msg = msghead + msg.mid(splitPosition); + } + } + putRawLine(msg); } +void NetworkConnection::sendAutoWho() { + while(!_autoWhoQueue.isEmpty()) { + QString chan = _autoWhoQueue.takeFirst(); + IrcChannel *ircchan = network()->ircChannel(chan); + if(!ircchan) continue; + if(_autoWhoNickLimit > 0 && ircchan->ircUsers().count() > _autoWhoNickLimit) continue; + _autoWhoInProgress[chan]++; + putRawLine("WHO " + serverEncode(chan)); + if(_autoWhoQueue.isEmpty() && _autoWhoEnabled && !_autoWhoCycleTimer.isActive()) { + // Timer was stopped, means a new cycle is due immediately + _autoWhoCycleTimer.start(); + startAutoWhoCycle(); + } + break; + } +} + +void NetworkConnection::startAutoWhoCycle() { + if(!_autoWhoQueue.isEmpty()) { + _autoWhoCycleTimer.stop(); + return; + } + _autoWhoQueue = network()->channels(); +} + +bool NetworkConnection::setAutoWhoDone(const QString &channel) { + if(_autoWhoInProgress.value(channel.toLower(), 0) <= 0) return false; + _autoWhoInProgress[channel.toLower()]--; + return true; +} + +void NetworkConnection::setChannelJoined(const QString &channel) { + emit channelJoined(networkId(), channel, _channelKeys[channel.toLower()]); + _autoWhoQueue.prepend(channel.toLower()); // prepend so this new chan is the first to be checked +} + +void NetworkConnection::setChannelParted(const QString &channel) { + removeChannelKey(channel); + _autoWhoQueue.removeAll(channel.toLower()); + _autoWhoInProgress.remove(channel.toLower()); + emit channelParted(networkId(), channel); +} + void NetworkConnection::addChannelKey(const QString &channel, const QString &key) { - if(key.isEmpty()) removeChannelKey(channel); - else _channelKeys[channel] = key; + if(key.isEmpty()) { + removeChannelKey(channel); + } else { + _channelKeys[channel.toLower()] = key; + } } void NetworkConnection::removeChannelKey(const QString &channel) { - _channelKeys.remove(channel); + _channelKeys.remove(channel.toLower()); } void NetworkConnection::nickChanged(const QString &newNick, const QString &oldNick) { - emit nickChanged(_network->networkId(), newNick, oldNick); + emit nickChanged(networkId(), newNick, oldNick); } /* Exception classes for message handling */