Client.h

Go to the documentation of this file.

/*
 * Copyright (C) 2004-2025 ZNC, see the NOTICE file for details.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#ifndef ZNC_CLIENT_H
#define ZNC_CLIENT_H
 
#include <znc/zncconfig.h>
#include <znc/Socket.h>
#include <znc/Utils.h>
#include <znc/Message.h>
#include <znc/main.h>
#include <memory>
#include <functional>
 
// Forward Declarations
class CZNC;
class CUser;
class CIRCNetwork;
class CIRCSock;
class CClient;
class CMessage;
class CChan;
// !Forward Declarations
 
class CAuthBase : private CCoreTranslationMixin {
  public:
    CAuthBase(const CString& sUsername, const CString& sPassword,
              CZNCSock* pSock)
        : m_sUsername(sUsername), m_sPassword(sPassword), m_pSock(pSock) {}
 
    virtual ~CAuthBase() {}
 
    CAuthBase(const CAuthBase&) = delete;
    CAuthBase& operator=(const CAuthBase&) = delete;
 
    virtual void SetLoginInfo(const CString& sUsername,
                              const CString& sPassword, CZNCSock* pSock) {
        m_sUsername = sUsername;
        m_sPassword = sPassword;
        m_pSock = pSock;
    }
 
    void AcceptLogin(CUser& User);
    void RefuseLogin(const CString& sReason);
 
    const CString& GetUsername() const { return m_sUsername; }
    const CString& GetPassword() const { return m_sPassword; }
    Csock* GetSocket() const { return m_pSock; }
    CString GetRemoteIP() const;
 
    // Invalidate this CAuthBase instance which means it will no longer use
    // m_pSock and AcceptLogin() or RefusedLogin() will have no effect.
    virtual void Invalidate();
 
  protected:
    virtual void AcceptedLogin(CUser& User) = 0;
    virtual void RefusedLogin(const CString& sReason) = 0;
 
  private:
    CString m_sUsername;
    CString m_sPassword;
    CZNCSock* m_pSock;
};
 
class CClientAuth : public CAuthBase {
  public:
    CClientAuth(CClient* pClient, const CString& sUsername,
                const CString& sPassword);
    virtual ~CClientAuth() {}
 
    CClientAuth(const CClientAuth&) = delete;
    CClientAuth& operator=(const CClientAuth&) = delete;
 
    void Invalidate() override {
        m_pClient = nullptr;
        CAuthBase::Invalidate();
    }
    void AcceptedLogin(CUser& User) override;
    void RefusedLogin(const CString& sReason) override;
 
  private:
  protected:
    CClient* m_pClient;
};
 
class CClient : public CIRCSocket {
  public:
    CClient();
    virtual ~CClient();
 
    CClient(const CClient&) = delete;
    CClient& operator=(const CClient&) = delete;
 
    void SendRequiredPasswordNotice();
    void AcceptLogin(CUser& User);
    void RefuseLogin(const CString& sReason);
 
    CString GetNick(bool bAllowIRCNick = true) const;
    CString GetNickMask() const;
    CString GetIdentifier() const { return m_sIdentifier; }
    unsigned short int CapVersion() const { return m_uCapVersion; }
    bool HasCap302() const { return CapVersion() >= 302; }
    bool HasCapNotify() const { return m_bCapNotify; }
    bool HasAwayNotify() const { return m_bAwayNotify; }
    bool HasAccountNotify() const { return m_bAccountNotify; }
    bool HasInviteNotify() const { return m_bInviteNotify; }
    bool HasExtendedJoin() const { return m_bExtendedJoin; }
    bool HasNamesx() const { return m_bNamesx; }
    bool HasUHNames() const { return m_bUHNames; }
    bool HasChgHost() const { return m_bChgHost; }
    bool IsAway() const { return m_bAway; }
    bool HasServerTime() const { return m_bServerTime; }
    bool HasBatch() const { return m_bBatch; }
    bool HasEchoMessage() const { return m_bEchoMessage; }
    bool HasSelfMessage() const { return m_bSelfMessage; }
 
    static bool IsValidIdentifier(const CString& sIdentifier);
 
    void UserCommand(CString& sLine);
    void UserPortCommand(CString& sLine);
    void StatusCTCP(const CString& sCommand);
    void BouncedOff();
    bool IsAttached() const { return m_pUser != nullptr; }
 
    bool IsPlaybackActive() const { return m_bPlaybackActive; }
    void SetPlaybackActive(bool bActive) { m_bPlaybackActive = bActive; }
 
    void PutIRC(const CString& sLine);
    // Strips prefix and potentially tags before sending to server.
    void PutIRCStripping(CMessage Message);
    bool PutClientRaw(const CString& sLine);
    void PutClient(const CString& sLine);
    bool PutClient(const CMessage& Message);
    unsigned int PutStatus(const CTable& table);
    void PutStatus(const CString& sLine);
    void PutStatusNotice(const CString& sLine);
    void PutModule(const CString& sModule, const CString& sLine);
    void PutModNotice(const CString& sModule, const CString& sLine);
 
    bool IsCapEnabled(const CString& sCap) const {
        return 1 == m_ssAcceptedCaps.count(sCap);
    }
 
    bool IsTagEnabled(const CString& sTag) const {
        return 1 == m_ssSupportedTags.count(sTag);
    }
    void SetTagSupport(const CString& sTag, bool bState);
 
    void NotifyServerDependentCap(const CString& sCap, bool bValue, const CString& sValue);
 
    void ReadLine(const CString& sData) override;
    bool SendMotd();
    void HelpUser(const CString& sFilter = "");
    void AuthUser();
    void Connected() override;
    void Timeout() override;
    void Disconnected() override;
    void ConnectionRefused() override;
    void ReachedMaxBuffer() override;
 
    void SetNick(const CString& s);
    void SetAway(bool bAway) { m_bAway = bAway; }
    CUser* GetUser() const { return m_pUser; }
    void SetNetwork(CIRCNetwork* pNetwork, bool bDisconnect = true,
                    bool bReconnect = true);
    CIRCNetwork* GetNetwork() const { return m_pNetwork; }
    const std::vector<CClient*>& GetClients() const;
    const CIRCSock* GetIRCSock() const;
    CIRCSock* GetIRCSock();
    CString GetFullName() const;
 
    void SendSASLChallenge(CString sMessage);
    void RefuseSASLLogin(const CString& sReason);
    void AcceptSASLLogin(CUser& User);
    void StartSASLPasswordCheck(const CString& sUser, const CString& sPassword,
                                const CString& sAuthorizationId);
    CString ParseUser(const CString& sAuthLine);
 
  private:
    void HandleCap(const CMessage& Message);
    void RespondCap(const CString& sResponse);
    void ParsePass(const CString& sAuthLine);
    void ParseIdentifier(const CString& sAuthLine);
 
    template <typename T>
    void AddBuffer(const T& Message);
    void EchoMessage(const CMessage& Message);
 
    std::set<CChan*> MatchChans(const CString& sPatterns) const;
    unsigned int AttachChans(const std::set<CChan*>& sChans);
    unsigned int DetachChans(const std::set<CChan*>& sChans);
 
    bool OnActionMessage(CActionMessage& Message);
    void OnAuthenticateMessage(const CAuthenticateMessage& Message);
    void AbortSASL(const CString& sFullIRCLine);
    bool IsDuringSASL() const { return !m_sSASLMechanism.empty(); }
 
    SCString EnumerateSASLMechanisms() const;
 
    bool OnCTCPMessage(CCTCPMessage& Message);
    bool OnJoinMessage(CJoinMessage& Message);
    bool OnModeMessage(CModeMessage& Message);
    bool OnNoticeMessage(CNoticeMessage& Message);
    bool OnPartMessage(CPartMessage& Message);
    bool OnPingMessage(CMessage& Message);
    bool OnPongMessage(CMessage& Message);
    bool OnQuitMessage(CQuitMessage& Message);
    bool OnTagMessage(CTargetMessage& Message);
    bool OnTextMessage(CTextMessage& Message);
    bool OnTopicMessage(CTopicMessage& Message);
    bool OnOtherMessage(CMessage& Message);
 
  protected:
    bool m_bGotPass;
    bool m_bGotNick;
    bool m_bGotUser;
    unsigned short int m_uCapVersion;
    bool m_bInCap;
    bool m_bCapNotify;
    bool m_bAwayNotify;
    bool m_bAccountNotify;
    bool m_bInviteNotify;
    bool m_bExtendedJoin;
    bool m_bNamesx;
    bool m_bUHNames;
    bool m_bChgHost;
    bool m_bAway;
    bool m_bServerTime;
    bool m_bBatch;
    bool m_bEchoMessage;
    bool m_bSelfMessage;
    bool m_bMessageTagCap;
    bool m_bSASLCap;
    bool m_bPlaybackActive;
    CUser* m_pUser;
    CIRCNetwork* m_pNetwork;
    CString m_sNick;
    CString m_sPass;
    // User who didn't necessarily login yet, or might not even exist.
    CString m_sUser;
    CString m_sNetwork;
    CString m_sIdentifier;
    CString m_sSASLBuffer;
    // Set while the exchange is in progress
    CString m_sSASLMechanism;
    // Username who successfully logged in using SASL. This is not a CUser*
    // because between the 903 and CAP END the user could have been deleted.
    CString m_sSASLUser;
    std::shared_ptr<CAuthBase> m_spAuth;
    SCString m_ssAcceptedCaps;
    SCString m_ssSupportedTags;
    SCString m_ssPreviouslyFailedSASLMechanisms;
    // The capabilities supported by the ZNC core - capability names mapped to
    // change handler. Note: this lists caps which don't require support on IRC
    // server.
    static const std::map<CString, std::function<void(CClient*, bool bVal)>>&
    CoreCaps();
 
    friend class ClientTest;
    friend class CCoreCaps;
};
 
#endif  // !ZNC_CLIENT_H