sipaccountbase.h 14.5 KB
Newer Older
1
/*
2
 *  Copyright (C) 2014-2019 Savoir-faire Linux Inc.
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
 *
 *  Author: Adrien Béraud <adrien.beraud@savoirfairelinux.com>
 *
 *  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, write to the Free Software
 *  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301 USA.
 */

21
#pragma once
22 23 24 25 26 27

#ifdef HAVE_CONFIG_H
#include "config.h"
#endif

#include "account.h"
28 29

#include "sip_utils.h"
30
#include "ip_utils.h"
31
#include "noncopyable.h"
Adrien Béraud's avatar
Adrien Béraud committed
32
#include "im/message_engine.h"
33 34 35

#include <pjsip/sip_types.h>

36
#include <array>
37
#include <deque>
38
#include <map>
39
#include <memory>
40 41
#include <mutex>
#include <vector>
42

43 44 45 46 47 48
#ifdef _WIN32
typedef uint16_t in_port_t;
#else
#include <netinet/in.h> // For in_port_t support
#endif

49 50 51 52
struct pjsip_dialog;
struct pjsip_inv_session;
struct pjmedia_sdp_session;

Adrien Béraud's avatar
Adrien Béraud committed
53
namespace jami {
54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87

namespace Conf {
    // SIP specific configuration keys
    const char *const INTERFACE_KEY = "interface";
    const char *const PORT_KEY = "port";
    const char *const PUBLISH_ADDR_KEY = "publishAddr";
    const char *const PUBLISH_PORT_KEY = "publishPort";
    const char *const SAME_AS_LOCAL_KEY = "sameasLocal";
    const char *const DTMF_TYPE_KEY = "dtmfType";
    const char *const SERVICE_ROUTE_KEY = "serviceRoute";
    const char *const PRESENCE_ENABLED_KEY = "presenceEnabled";
    const char *const PRESENCE_PUBLISH_SUPPORTED_KEY = "presencePublishSupported";
    const char *const PRESENCE_SUBSCRIBE_SUPPORTED_KEY = "presenceSubscribeSupported";
    const char *const PRESENCE_STATUS_KEY = "presenceStatus";
    const char *const PRESENCE_NOTE_KEY = "presenceNote";

    // TODO: write an object to store tls params which implement serializable
    const char *const TLS_KEY = "tls";
    const char *const TLS_PORT_KEY = "tlsPort";
    const char *const CERTIFICATE_KEY = "certificate";
    const char *const CALIST_KEY = "calist";
    const char *const CIPHERS_KEY = "ciphers";
    const char *const TLS_ENABLE_KEY = "enable";
    const char *const METHOD_KEY = "method";
    const char *const TIMEOUT_KEY = "timeout";
    const char *const TLS_PASSWORD_KEY = "password";
    const char *const PRIVATE_KEY_KEY = "privateKey";
    const char *const REQUIRE_CERTIF_KEY = "requireCertif";
    const char *const SERVER_KEY = "server";
    const char *const VERIFY_CLIENT_KEY = "verifyClient";
    const char *const VERIFY_SERVER_KEY = "verifyServer";

    const char *const STUN_ENABLED_KEY = "stunEnabled";
    const char *const STUN_SERVER_KEY = "stunServer";
88 89
    const char *const TURN_ENABLED_KEY = "turnEnabled";
    const char *const TURN_SERVER_KEY = "turnServer";
90 91 92
    const char *const TURN_SERVER_UNAME_KEY = "turnServerUserName";
    const char *const TURN_SERVER_PWD_KEY = "turnServerPassword";
    const char *const TURN_SERVER_REALM_KEY = "turnServerRealm";
93 94 95 96 97 98 99
    const char *const CRED_KEY = "credential";
    const char *const AUDIO_PORT_MIN_KEY = "audioPortMin";
    const char *const AUDIO_PORT_MAX_KEY = "audioPortMax";
    const char *const VIDEO_PORT_MIN_KEY = "videoPortMin";
    const char *const VIDEO_PORT_MAX_KEY = "videoPortMax";
}

100 101
typedef std::vector<pj_ssl_cipher> CipherArray;

102 103 104 105 106 107 108
class SIPVoIPLink;
class SIPCall;

/**
 * @file sipaccount.h
 * @brief A SIP Account specify SIP specific functions and object = SIPCall/SIPVoIPLink)
 */
109

110 111 112 113 114 115
enum class MatchRank {NONE, PARTIAL, FULL};

class SIPAccountBase : public Account {
public:
    constexpr static const char * const OVERRTP_STR = "overrtp";
    constexpr static const char * const SIPINFO_STR = "sipinfo";
116 117
    constexpr static unsigned MAX_PORT {65536};
    constexpr static unsigned HALF_MAX_PORT {MAX_PORT / 2};
118 119 120 121 122 123 124

    /**
     * Constructor
     * @param accountID The account identifier
     */
    SIPAccountBase(const std::string& accountID);

125
    virtual ~SIPAccountBase();
126

127 128 129
    /**
     * Create incoming SIPCall.
     * @param[in] id The ID of the call
130
     * @param details use to set some specific details
131 132 133 134 135
     * @return std::shared_ptr<T> A shared pointer on the created call.
     *      The type of this instance is given in template argument.
     *      This type can be any base class of SIPCall class (included).
     */
    virtual std::shared_ptr<SIPCall>
136
    newIncomingCall(const std::string& from, const std::map<std::string, std::string>& details = {}) = 0;
137 138 139 140 141

    virtual bool isStunEnabled() const {
        return false;
    }

142
    virtual pj_str_t getStunServerName() const { return pj_str_t {nullptr, 0}; };
143 144 145 146 147 148 149

    virtual pj_uint16_t getStunPort() const { return 0; };

    virtual std::string getDtmfType() const {
        return dtmfType_;
    }

Adrien Béraud's avatar
Adrien Béraud committed
150 151
    /**
     * Determine if TLS is enabled for this account. TLS provides a secured channel for
Hugo Lefeuvre's avatar
Hugo Lefeuvre committed
152
     * SIP signalization. It is independent of the media encryption (as provided by SRTP).
Adrien Béraud's avatar
Adrien Béraud committed
153 154 155
     */
    virtual bool isTlsEnabled() const {
        return false;
156 157
    }

158 159 160 161 162 163 164 165 166 167 168 169 170
    /**
     * Create UAC attached dialog and invite session
     * @return true if success. false if failure and dlg and inv pointers
     *         should not be considered as valid.
     */
    bool CreateClientDialogAndInvite(const pj_str_t* from,
                                     const pj_str_t* contact,
                                     const pj_str_t* to,
                                     const pj_str_t* target,
                                     const pjmedia_sdp_session* local_sdp,
                                     pjsip_dialog** dlg,
                                     pjsip_inv_session** inv);

171
    /**
172
     * Get the local interface name on which this account is bound.
173
     */
174 175
    const std::string& getLocalInterface() const {
        return interface_;
176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191
    }

    /**
     * Get the public IP address set by the user for this account.
     * If this setting is not provided, the local bound adddress
     * will be used.
     * @return std::string The public IPv4 or IPv6 address formatted in standard notation.
     */
    std::string getPublishedAddress() const {
        return publishedIpAddress_;
    }

    IpAddr getPublishedIpAddress() const {
        return publishedIp_;
    }

192
    void setPublishedAddress(const IpAddr& ip_addr);
193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211

    /**
     * Get the published port, which is the port to be advertised as the port
     * for the chosen SIP transport.
     * @return pj_uint16 The port used for that account
     */
    pj_uint16_t getPublishedPort() const {
        return (pj_uint16_t) publishedPort_;
    }

    /**
     * Set the published port, which is the port to be advertised as the port
     * for the chosen SIP transport.
     * @pram port The port used by this account.
     */
    void setPublishedPort(pj_uint16_t port) {
        publishedPort_ = port;
    }

212 213 214 215 216 217 218 219 220
    /**
     * Get a flag which determine the usage in sip headers of either the local
     * IP address and port (_localAddress and localPort_) or to an address set
     * manually (_publishedAddress and publishedPort_).
     */
    bool getPublishedSameasLocal() const {
        return publishedSameasLocal_;
    }

Guillaume Roguez's avatar
Guillaume Roguez committed
221
    virtual sip_utils::KeyExchangeProtocol getSrtpKeyExchange() const = 0;
222

Adrien Béraud's avatar
Adrien Béraud committed
223
    virtual bool getSrtpFallback() const = 0;
224 225 226 227 228

    /**
     * Get the contact header for
     * @return pj_str_t The contact header based on account information
     */
229
    virtual pj_str_t getContactHeader(pjsip_transport* = nullptr) = 0;
230 231 232

    virtual std::string getToUri(const std::string& username) const = 0;

233 234 235 236 237 238 239
    /**
     * Socket port generators for media
     * Note: given ports are application wide, a port cannot be given again
     * by any account instances until it's released by the static method
     * releasePort().
     */
    uint16_t generateAudioPort() const;
Adrien Béraud's avatar
Adrien Béraud committed
240
#ifdef ENABLE_VIDEO
241 242 243 244
    uint16_t generateVideoPort() const;
#endif
    static void releasePort(uint16_t port) noexcept;

245 246 247 248 249 250 251 252 253 254 255 256 257
    /**
     * @return pj_str_t , filled from the configuration
     * file, that can be used directly by PJSIP to initialize
     * an alternate UDP transport.
     */
    std::string getStunServer() const {
        return stunServer_;
    }

    void setStunServer(const std::string &srv) {
        stunServer_ = srv;
    }

258 259
    const IceTransportOptions getIceOptions() const noexcept override;

Adrien Béraud's avatar
Adrien Béraud committed
260 261 262 263 264 265 266 267 268 269 270
    virtual void sendTextMessage(const std::string& to, const std::map<std::string, std::string>& payloads, uint64_t id) = 0;

    virtual uint64_t sendTextMessage(const std::string& to,
                                     const std::map<std::string, std::string>& payloads) override {
        return messageEngine_.sendMessage(to, payloads);
    }

    virtual im::MessageStatus getMessageStatus(uint64_t id) const override {
        return messageEngine_.getStatus(id);
    }

271 272 273 274
    virtual bool cancelMessage(uint64_t id) override {
        return messageEngine_.cancel(id);
    }

275
    void onTextMessage(const std::string& from, const std::map<std::string, std::string>& payloads);
276

277 278 279
    /* Returns true if the username and/or hostname match this account */
    virtual MatchRank matches(const std::string &username, const std::string &hostname) const = 0;

280 281
    void connectivityChanged() override {};

Philippe Gorley's avatar
Philippe Gorley committed
282 283
    virtual std::string getUserUri() const = 0;

Philippe Gorley's avatar
Philippe Gorley committed
284
    std::vector<DRing::Message> getLastMessages(const uint64_t& base_timestamp) override {
285 286 287 288 289 290 291 292 293 294 295 296
        std::lock_guard<std::mutex> lck(mutexLastMessages_);
        auto it = lastMessages_.begin();
        size_t num = lastMessages_.size();
        while (it != lastMessages_.end() and it->received <= base_timestamp) {
            num--;
            ++it;
        }
        if (num == 0)
            return {};
        return {it, lastMessages_.end()};
    }

297 298 299
public: // overloaded methods
    virtual void flush() override;

300
protected:
301 302
    virtual void serialize(YAML::Emitter &out) const override;
    virtual void serializeTls(YAML::Emitter &out) const;
303
    virtual void unserialize(const YAML::Node &node) override;
304

305
    virtual void setAccountDetails(const std::map<std::string, std::string> &details) override;
306

307
    virtual std::map<std::string, std::string> getAccountDetails() const override;
308

309 310 311 312
    /**
     * Retrieve volatile details such as recent registration errors
     * @return std::map< std::string, std::string > The account volatile details
     */
313
    virtual std::map<std::string, std::string> getVolatileAccountDetails() const override;
314

Adrien Béraud's avatar
Adrien Béraud committed
315 316 317 318
    virtual void setRegistrationState(RegistrationState state, unsigned code=0, const std::string& detail_str={}) override;

    im::MessageEngine messageEngine_;

319
    /**
320
     * Voice over IP Link contains a listener thread and calls
321
     */
322 323
    std::shared_ptr<SIPVoIPLink> link_;

324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
    /**
     * interface name on which this account is bound
     */
    std::string interface_ {"default"};

    /**
     * Flag which determine if localIpAddress_ or publishedIpAddress_ is used in
     * sip headers
     */
    bool publishedSameasLocal_ {true};

    /**
     * Published IP address, used only if defined by the user in account
     * configuration
     */
    IpAddr publishedIp_ {};

341
    std::string publishedIpAddress_ {};
342 343 344 345

    /**
     * Published port, used only if defined by the user
     */
346
    pj_uint16_t publishedPort_ {sip_utils::DEFAULT_SIP_PORT};
347

348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369
    /**
     * Determine if STUN public address resolution is required to register this account. In this case a
     * STUN server hostname must be specified.
     */
    bool stunEnabled_ {false};

    /**
     * The STUN server hostname (optional), used to provide the public IP address in case the softphone
     * stay behind a NAT.
     */
    std::string stunServer_ {};

    /**
     * Determine if TURN public address resolution is required to register this account. In this case a
     * TURN server hostname must be specified.
     */
    bool turnEnabled_ {false};

    /**
     * The TURN server hostname (optional), used to provide the public IP address in case the softphone
     * stay behind a NAT.
     */
370 371 372 373
    std::string turnServer_;
    std::string turnServerUserName_;
    std::string turnServerPwd_;
    std::string turnServerRealm_;
374

375 376 377 378
    std::string tlsCaListFile_;
    std::string tlsCertificateFile_;
    std::string tlsPrivateKeyFile_;
    std::string tlsPassword_;
379 380 381 382 383 384

    /**
     * DTMF type used for this account SIPINFO or RTP
     */
    std::string dtmfType_ {OVERRTP_STR};

385 386 387
    pj_status_t transportStatus_ {PJSIP_SC_TRYING};
    std::string transportError_ {};

388 389 390 391 392 393 394 395 396 397
    /*
     * Port range for audio RTP ports
     */
    std::pair<uint16_t, uint16_t> audioPortRange_ {16384, 32766};

    /**
     * Port range for video RTP ports
     */
    std::pair<uint16_t, uint16_t> videoPortRange_ {49152, (MAX_PORT) - 2};

398 399
    struct UsedPort {
        UsedPort() {};
400
        UsedPort(UsedPort&& o) noexcept : port_(o.port_) {
401 402 403 404 405 406 407 408 409 410
            o.port_ = 0;
        }
        UsedPort(in_port_t p) : port_(p) {
            if (port_)
                acquirePort(port_);
        };
        ~UsedPort() {
            if (port_)
                releasePort(port_);
        };
411
        UsedPort& operator=(UsedPort&& o) noexcept {
412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
            if (port_)
                releasePort(port_);
            port_ = o.port_;
            o.port_ = 0;
            return *this;
        }
        UsedPort& operator=(in_port_t p) {
            if (port_)
                releasePort(port_);
            port_ = p;
            if (port_)
                acquirePort(port_);
            return *this;
        }
        explicit operator in_port_t() const { return port_; }
    private:
        in_port_t port_ {0};
        NON_COPYABLE(UsedPort);
    };

432
    static std::array<bool, HALF_MAX_PORT>& getPortsReservation() noexcept;
433 434
    static uint16_t acquirePort(uint16_t port);
    uint16_t getRandomEvenPort(const std::pair<uint16_t, uint16_t>& range) const;
435
    uint16_t acquireRandomEvenPort(const std::pair<uint16_t, uint16_t>& range) const;
436

437 438 439 440 441 442 443 444 445 446
    /**
     * The deamon can be launched without any client (or with a non ready client)
     * Like call and file transfer, a client should be able to retrieve current messages.
     * To avoid to explode the size in memory, this container should be limited.
     * We don't want to see monsters in memory.
     */
    std::mutex mutexLastMessages_;
    static constexpr size_t MAX_WAITING_MESSAGES_SIZE = 1000;
    std::deque<DRing::Message> lastMessages_;

447 448 449 450 451
private:
    NON_COPYABLE(SIPAccountBase);

};

Adrien Béraud's avatar
Adrien Béraud committed
452
} // namespace jami