sipaccount.h

Go to the documentation of this file.

/*
 *  Copyright (C) 2004-2026 Savoir-faire Linux Inc.
 *
 *  This program is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program. If not, see <https://www.gnu.org/licenses/>.
 */
#pragma once
 
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
 
#include "sip/sipaccountbase.h"
#include "sip/siptransport.h"
#include "noncopyable.h"
#include "sipaccount_config.h"
 
#include <pjsip/sip_transport_tls.h>
#include <pjsip/sip_types.h>
#include <pjsip-ua/sip_regc.h>
 
#include <vector>
#include <map>
 
namespace jami {
 
typedef std::vector<pj_ssl_cipher> CipherArray;
 
class SIPPresence;
class SIPCall;
 
class SIPAccount : public SIPAccountBase
{
public:
    constexpr static auto ACCOUNT_TYPE = ACCOUNT_TYPE_SIP;
 
    std::shared_ptr<SIPAccount> shared() { return std::static_pointer_cast<SIPAccount>(shared_from_this()); }
    std::shared_ptr<SIPAccount const> shared() const
    {
        return std::static_pointer_cast<SIPAccount const>(shared_from_this());
    }
    std::weak_ptr<SIPAccount> weak() { return std::static_pointer_cast<SIPAccount>(shared_from_this()); }
    std::weak_ptr<SIPAccount const> weak() const
    {
        return std::static_pointer_cast<SIPAccount const>(shared_from_this());
    }
 
    SIPAccount(const std::string& accountID, bool presenceEnabled);
 
    ~SIPAccount() noexcept;
 
    const SipAccountConfig& config() const { return *static_cast<const SipAccountConfig*>(&Account::config()); }
 
    std::unique_ptr<AccountConfig> buildConfig() const override
    {
        return std::make_unique<SipAccountConfig>(getAccountID());
    }
    inline void editConfig(std::function<void(SipAccountConfig& conf)>&& edit)
    {
        Account::editConfig([&](AccountConfig& conf) { edit(*static_cast<SipAccountConfig*>(&conf)); });
    }
 
    std::string_view getAccountType() const override { return ACCOUNT_TYPE; }
 
    pjsip_host_port getHostPortFromSTUN(pj_pool_t* pool);
 
    void updateDialogViaSentBy(pjsip_dialog* dlg);
 
    void resetAutoRegistration();
 
    bool checkNATAddress(pjsip_regc_cbparam* param, pj_pool_t* pool);
 
    bool isIP2IP() const override;
 
    virtual std::map<std::string, std::string> getVolatileAccountDetails() const override;
 
    std::map<std::string, std::string> getTlsSettings() const;
 
    void loadConfig() override;
 
    void updateProfile(const std::string& displayName,
                       const std::string& avatar,
                       const std::string& fileType,
                       int32_t flag) override;
 
    void doRegister() override;
 
    void doUnregister(bool forceShutdownConnections = false) override;
 
    void sendRegister();
 
    void sendUnregister();
 
    const pjsip_cred_info* getCredInfo() const { return cred_.data(); }
 
    unsigned getCredentialCount() const { return config().credentials.size(); }
 
    bool hasCredentials() const { return not config().credentials.empty(); }
 
    std::vector<std::map<std::string, std::string>> getCredentials() const { return config().getCredentials(); }
 
    virtual void setRegistrationState(RegistrationState state,
                                      int code = 0,
                                      const std::string& detail_str = {}) override;
 
    unsigned getRegistrationExpire() const
    {
        unsigned re = config().registrationExpire;
        return re ? re : PJSIP_REGC_EXPIRATION_NOT_SPECIFIED;
    }
 
    bool isRegistered() const { return bRegister_; }
 
    pjsip_regc* getRegistrationInfo() { return regc_; }
 
    void setRegistrationInfo(pjsip_regc* regc)
    {
        if (regc_)
            destroyRegistrationInfo();
        regc_ = regc;
    }
 
    void destroyRegistrationInfo();
 
    uint16_t getLocalPort() const { return config().localPort; }
 
    void setLocalPort(uint16_t port)
    {
        editConfig([&](SipAccountConfig& config) { config.localPort = port; });
    }
 
    pjsip_tls_setting* getTlsSetting() { return &tlsSetting_; }
 
    pj_uint16_t getTlsListenerPort() const { return config().tlsListenerPort; }
 
    pj_str_t getStunServerName() const { return stunServerName_; }
 
    static const std::vector<std::string>& getSupportedTlsCiphers();
    static const std::vector<std::string>& getSupportedTlsProtocols();
 
    pj_uint16_t getStunPort() const override { return stunPort_; }
 
    bool isStunEnabled() const override { return config().stunEnabled; }
 
    std::string getStunServer() const { return config().stunServer; }
 
    std::string getFromUri() const override;
 
    std::string getToUri(const std::string& username) const override;
 
    std::string getServerUri() const;
 
    dhtnet::IpAddr getContactAddress() const;
    std::string getContactHeader() const;
 
    std::string getServiceRoute() const { return config().serviceRoute; }
 
    bool hasServiceRoute() const { return not config().serviceRoute.empty(); }
 
    virtual bool isTlsEnabled() const override { return config().tlsEnable; }
 
    void setReceivedParameter(const std::string& received)
    {
        receivedParameter_ = received;
        via_addr_.host = sip_utils::CONST_PJ_STR(receivedParameter_);
    }
 
    const std::string& getReceivedParameter() const { return receivedParameter_; }
 
    pjsip_host_port* getViaAddr() { return &via_addr_; }
 
    int getRPort() const
    {
        if (rPort_ == -1)
            return config().localPort;
        else
            return rPort_;
    }
 
    void setRPort(int rPort)
    {
        rPort_ = rPort;
        via_addr_.port = rPort;
    }
 
    bool isRegistrationRefreshEnabled() const { return config().registrationRefreshEnabled; }
 
    void setTransport(const std::shared_ptr<SipTransport>& = nullptr);
 
    virtual inline std::shared_ptr<SipTransport> getTransport() { return transport_; }
 
    inline pjsip_transport_type_e getTransportType() const { return transportType_; }
 
    pjsip_tpselector getTransportSelector();
 
    /* Returns true if the username and/or hostname match this account */
    MatchRank matches(std::string_view username, std::string_view hostname) const override;
 
    SIPPresence* getPresence() const;
 
    void enablePresence(const bool& enable);
    void supportPresence(int function, bool enable);
 
    std::shared_ptr<Call> newOutgoingCall(std::string_view toUrl,
                                          const std::vector<libjami::MediaMap>& mediaList) override;
 
    std::shared_ptr<SIPCall> newIncomingCall(const std::string& from,
                                             const std::vector<libjami::MediaMap>& mediaList,
                                             const std::shared_ptr<SipTransport>& sipTr = {}) override;
 
    void onRegister(pjsip_regc_cbparam* param);
 
    virtual void sendMessage(const std::string& to,
                             const std::string& deviceId,
                             const std::map<std::string, std::string>& payloads,
                             uint64_t id,
                             bool retryOnTimeout = true,
                             bool onlyConnected = false) override;
 
    void connectivityChanged() override;
 
    std::string getUserUri() const override;
 
    dhtnet::IpAddr createBindingAddress();
 
    void setActiveCodecs(const std::vector<unsigned>& list) override;
    bool isSrtpEnabled() const override { return config().srtpKeyExchange != KeyExchangeProtocol::NONE; }
 
    bool setPushNotificationToken(const std::string& pushDeviceToken = "") override;
    bool setPushNotificationConfig(const std::map<std::string, std::string>& data) override;
 
    void pushNotificationReceived(const std::string& from, const std::map<std::string, std::string>& data);
 
private:
    void doRegister1_();
    void doRegister2_();
 
    // Initialize the address to be used in contact header. Might
    // be updated (as the contact header)after the registration.
    bool initContactAddress();
    void updateContactHeader();
 
    void setCredentials(const std::vector<SipAccountConfig::Credentials>& creds);
 
    void setUpTransmissionData(pjsip_tx_data* tdata, long transportKeyType);
 
    NON_COPYABLE(SIPAccount);
 
    std::shared_ptr<Call> newRegisteredAccountCall(const std::string& id, const std::string& toUrl);
 
    bool SIPStartCall(std::shared_ptr<SIPCall>& call);
 
    void usePublishedAddressPortInVIA();
    void useUPnPAddressPortInVIA();
    bool fullMatch(std::string_view username, std::string_view hostname) const;
    bool userMatch(std::string_view username) const;
    bool hostnameMatch(std::string_view hostname) const;
    bool proxyMatch(std::string_view hostname) const;
 
    virtual void onTransportStateChanged(pjsip_transport_state state, const pjsip_transport_state_info* info);
 
    struct
    {
        pj_bool_t active {false}; 
        pj_timer_entry timer {};  
        unsigned attempt_cnt {0}; 
    } auto_rereg_ {};             
    std::uniform_int_distribution<int> delay10ZeroDist_ {-10000, 10000};
    std::uniform_int_distribution<unsigned int> delay10PosDist_ {0, 10000};
 
    void scheduleReregistration();
    void autoReregTimerCb();
 
    std::shared_ptr<SipTransport> transport_ {};
 
    std::shared_ptr<TlsListener> tlsListener_ {};
 
    pjsip_transport_type_e transportType_ {PJSIP_TRANSPORT_UNSPECIFIED};
 
    static pj_uint32_t tlsProtocolFromString(const std::string& method);
 
    void initTlsConfiguration();
 
    void trimCiphers();
 
    void initStunConfiguration();
 
    static std::string getLoginName();
 
    bool mapPortUPnP();
 
    static std::string printContactHeader(const std::string& username,
                                          const std::string& displayName,
                                          const std::string& address,
                                          pj_uint16_t port,
                                          bool secure,
                                          const std::string& deviceKey = {});
 
    dhtnet::IpAddr hostIp_;
 
    pjsip_regc* regc_ {nullptr};
 
    bool bRegister_;
 
    std::vector<pjsip_cred_info> cred_;
 
    pjsip_tls_setting tlsSetting_;
 
    CipherArray ciphers_;
 
    pj_str_t stunServerName_ {nullptr, 0};
 
    pj_uint16_t stunPort_ {PJ_STUN_PORT};
 
    static void onComplete(void* token, pjsip_event* event);
 
    std::pair<int, std::string> registrationStateDetailed_;
 
    std::string receivedParameter_;
 
    int rPort_ {-1};
 
    pjsip_host_port via_addr_;
 
    // This is used at runtime . Mainly by SIPAccount::usePublishedAddressPortInVIA()
    std::string publishedIpStr_ {};
 
    std::string upnpIpAddr_;
 
    mutable std::mutex contactMutex_;
    // Contact header
    std::string contactHeader_;
    // Contact address (the address part of a SIP URI)
    dhtnet::IpAddr contactAddress_ {};
    pjsip_transport* via_tp_ {nullptr};
 
    SIPPresence* presence_;
 
    pj_uint16_t publishedPortUsed_ {sip_utils::DEFAULT_SIP_PORT};
};
 
} // namespace jami