* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. *
***************************************************************************/
-#ifndef CORENETWORK_H
-#define CORENETWORK_H
+#pragma once
#include "network.h"
#include "coreircchannel.h"
class CoreNetwork : public Network
{
- SYNCABLE_OBJECT
- Q_OBJECT
+ Q_OBJECT
public:
CoreNetwork(const NetworkId &networkid, CoreSession *session);
- ~CoreNetwork();
- inline virtual const QMetaObject *syncMetaObject() const { return &Network::staticMetaObject; }
+ ~CoreNetwork() override;
inline CoreIdentity *identityPtr() const { return coreSession()->identity(identity()); }
inline CoreSession *coreSession() const { return _coreSession; }
*/
inline bool isPongReplyPending() const { return _pongReplyPending; }
- QList<QList<QByteArray>> splitMessage(const QString &cmd, const QString &message, std::function<QList<QByteArray>(QString &)> cmdGenerator);
+ QList<QList<QByteArray>> splitMessage(const QString &cmd, const QString &message, const std::function<QList<QByteArray>(QString &)> &cmdGenerator);
// IRCv3 capability negotiation
*
* @returns True if in progress, otherwise false
*/
- inline bool capNegotiationInProgress() const { return (!_capsQueuedIndividual.empty() ||
- !_capsQueuedBundled.empty()); }
+ inline bool capNegotiationInProgress() const { return (!_capsQueuedIndividual.empty() || !_capsQueuedBundled.empty()); }
/**
* Queues a capability to be requested.
};
public slots:
- virtual void setMyNick(const QString &mynick);
+ void setMyNick(const QString &mynick) override;
- virtual void requestConnect() const;
- virtual void requestDisconnect() const;
- virtual void requestSetNetworkInfo(const NetworkInfo &info);
+ void requestConnect() const override;
+ void requestDisconnect() const override;
+ void requestSetNetworkInfo(const NetworkInfo &info) override;
- virtual void setUseAutoReconnect(bool);
- virtual void setAutoReconnectInterval(quint32);
- virtual void setAutoReconnectRetries(quint16);
+ void setUseAutoReconnect(bool) override;
+ void setAutoReconnectInterval(quint32) override;
+ void setAutoReconnectRetries(quint16) override;
void setPingInterval(int interval);
*/
void setPongTimestampValid(bool validTimestamp);
+ /**
+ * Indicates that the CoreSession is shutting down.
+ *
+ * Disconnects the network if connected, and sets a flag that prevents reconnections.
+ */
+ void shutdown();
+
void connectToIrc(bool reconnecting = false);
/**
* Disconnect from the IRC server.
* @param requested If true, user requested this disconnect; don't try to reconnect
* @param reason Reason for quitting, defaulting to the user-configured quit reason
* @param withReconnect Reconnect to the network after disconnecting (e.g. ping timeout)
- * @param forceImmediate Immediately disconnect from network, skipping queue of other commands
*/
- void disconnectFromIrc(bool requested = true, const QString &reason = QString(),
- bool withReconnect = false, bool forceImmediate = false);
+ void disconnectFromIrc(bool requested = true, const QString &reason = QString(), bool withReconnect = false);
/**
* Forcibly close the IRC server socket, waiting for it to close.
*
* Call CoreNetwork::disconnectFromIrc() first, allow the event loop to run, then if you need to
- * be sure the network's disconencted (e.g. clean-up), call this.
+ * be sure the network's disconnected (e.g. clean-up), call this.
*
* @param msecs Maximum time to wait for socket to close, in milliseconds.
* @return True if socket closes successfully; false if error occurs or timeout reached
*/
bool forceDisconnect(int msecs = 1000);
- void userInput(BufferInfo bufferInfo, QString msg);
+ void userInput(const BufferInfo &bufferInfo, QString msg);
/**
* Sends the raw (encoded) line, adding to the queue if needed, optionally with higher priority.
* PING/PONG replies, the other side will close the connection.
* @endparmblock
*/
- void putRawLine(const QByteArray input, const bool prepend = false);
+ void putRawLine(const QByteArray &input, bool prepend = false);
/**
* Sends the command with encoded parameters, with optional prefix or high priority.
* maintain PING/PONG replies, the other side will close the connection.
* @endparmblock
*/
- void putCmd(const QString &cmd, const QList<QByteArray> ¶ms, const QByteArray &prefix = QByteArray(), const bool prepend = false);
+ void putCmd(const QString &cmd, const QList<QByteArray> ¶ms, const QByteArray &prefix = {}, bool prepend = false);
/**
* Sends the command for each set of encoded parameters, with optional prefix or high priority.
* cannot maintain PING/PONG replies, the other side will close the connection.
* @endparmblock
*/
- void putCmd(const QString &cmd, const QList<QList<QByteArray>> ¶ms, const QByteArray &prefix = QByteArray(), const bool prependAll = false);
+ void putCmd(const QString &cmd, const QList<QList<QByteArray>> ¶ms, const QByteArray &prefix = {}, bool prependAll = false);
void setChannelJoined(const QString &channel);
void setChannelParted(const QString &channel);
*/
inline void resetPongReplyPending() { _pongReplyPending = false; }
- inline void displayMsg(Message::Type msgType, BufferInfo::Type bufferType, const QString &target, const QString &text, const QString &sender = "", Message::Flags flags = Message::None)
+ void onDisplayMsg(Message::Type msgType, BufferInfo::Type bufferType, const QString &target, const QString &text, const QString &sender, Message::Flags flags)
{
emit displayMsg(networkId(), msgType, bufferType, target, text, sender, flags);
}
signals:
void recvRawServerMsg(QString);
void displayStatusMsg(QString);
- void displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &target, const QString &text, const QString &sender = "", Message::Flags flags = Message::None);
+ void displayMsg(NetworkId, Message::Type, BufferInfo::Type, const QString &target, const QString &text, const QString &sender, Message::Flags flags);
void disconnected(NetworkId networkId);
void connectionError(const QString &errorMsg);
void socketDisconnected(const CoreIdentity *identity, const QHostAddress &localAddress, quint16 localPort, const QHostAddress &peerAddress, quint16 peerPort, qint64 socketId);
protected:
- inline virtual IrcChannel *ircChannelFactory(const QString &channelname) { return new CoreIrcChannel(channelname, this); }
- inline virtual IrcUser *ircUserFactory(const QString &hostmask) { return new CoreIrcUser(hostmask, this); }
+ inline IrcChannel *ircChannelFactory(const QString &channelname) override { return new CoreIrcChannel(channelname, this); }
+ inline IrcUser *ircUserFactory(const QString &hostmask) override { return new CoreIrcUser(hostmask, this); }
protected slots:
// TODO: remove cached cipher keys, when appropriate
//virtual void removeChansAndUsers();
private slots:
- void socketHasData();
- void socketError(QAbstractSocket::SocketError);
- void socketInitialized();
- inline void socketCloseTimeout() { socket.abort(); }
- void socketDisconnected();
- void socketStateChanged(QAbstractSocket::SocketState);
+ void onSocketHasData();
+ void onSocketError(QAbstractSocket::SocketError);
+ void onSocketInitialized();
+ void onSocketCloseTimeout();
+ void onSocketDisconnected();
+ void onSocketStateChanged(QAbstractSocket::SocketState);
+
void networkInitialized();
void sendPerform();
void startAutoWhoCycle();
#ifdef HAVE_SSL
- void sslErrors(const QList<QSslError> &errors);
+ void onSslErrors(const QList<QSslError> &errors);
#endif
/**
void writeToSocket(const QByteArray &data);
+private:
+ void showMessage(Message::Type msgType,
+ BufferInfo::Type bufferType,
+ const QString &target,
+ const QString &text,
+ const QString &sender = "",
+ Message::Flags flags = Message::None)
+ {
+ emit displayMsg(networkId(), msgType, bufferType, target, text, sender, flags);
+ }
+
private:
CoreSession *_coreSession;
// This avoids logging a spurious RemoteHostClosedError whenever disconnect is called without
// specifying a permanent (saved to core session) disconnect.
+ bool _shuttingDown{false}; ///< If true, we're shutting down and ignore requests to (dis)connect networks
+
bool _previousConnectionAttemptFailed;
int _lastUsedServerIndex;
// List of blowfish keys for channels
QHash<QString, QByteArray> _cipherKeys;
};
-
-
-#endif //CORENETWORK_H