Line data Source code
1 : /*
2 : * Copyright (C) 2004-2026 Savoir-faire Linux Inc.
3 : *
4 : * This program is free software: you can redistribute it and/or modify
5 : * it under the terms of the GNU General Public License as published by
6 : * the Free Software Foundation, either version 3 of the License, or
7 : * (at your option) any later version.
8 : *
9 : * This program is distributed in the hope that it will be useful,
10 : * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 : * GNU General Public License for more details.
13 : *
14 : * You should have received a copy of the GNU General Public License
15 : * along with this program. If not, see <https://www.gnu.org/licenses/>.
16 : */
17 : #pragma once
18 :
19 : #ifdef HAVE_CONFIG_H
20 : #include "config.h"
21 : #endif
22 :
23 : #include "account.h"
24 :
25 : #include "connectivity/sip_utils.h"
26 : #include "noncopyable.h"
27 : #include "im/message_engine.h"
28 : #include "sipaccountbase_config.h"
29 :
30 : #include <dhtnet/turn_cache.h>
31 : #include <dhtnet/ip_utils.h>
32 : #include <dhtnet/ice_options.h>
33 :
34 : #include <array>
35 : #include <deque>
36 : #include <map>
37 : #include <memory>
38 : #include <mutex>
39 : #include <vector>
40 :
41 : extern "C" {
42 : #include <pjsip/sip_types.h>
43 : #ifdef _WIN32
44 : typedef uint16_t in_port_t;
45 : #else
46 : #include <netinet/in.h> // For in_port_t support
47 : #endif
48 :
49 : struct pjsip_dialog;
50 : struct pjsip_inv_session;
51 : struct pjmedia_sdp_session;
52 : }
53 :
54 : static constexpr const char MIME_TYPE_TEXT_PLAIN[] {"text/plain"};
55 :
56 : namespace jami {
57 :
58 : class SipTransport;
59 : class Task;
60 :
61 : typedef std::vector<pj_ssl_cipher> CipherArray;
62 :
63 : class SIPVoIPLink;
64 : class SIPCall;
65 :
66 : /**
67 : * @file sipaccount.h
68 : * @brief A SIP Account specify SIP specific functions and object = SIPCall/SIPVoIPLink)
69 : */
70 :
71 : enum class MatchRank { NONE, PARTIAL, FULL };
72 :
73 : class SIPAccountBase : public Account
74 : {
75 : public:
76 : constexpr static unsigned MAX_PORT {65536};
77 : constexpr static unsigned HALF_MAX_PORT {MAX_PORT / 2};
78 :
79 : /**
80 : * Constructor
81 : * @param accountID The account identifier
82 : */
83 : SIPAccountBase(const std::string& accountID);
84 :
85 : virtual ~SIPAccountBase() noexcept;
86 :
87 2150 : const SipAccountBaseConfig& config() const { return *static_cast<const SipAccountBaseConfig*>(&Account::config()); }
88 :
89 : void loadConfig() override;
90 :
91 : /**
92 : * Create incoming SIPCall.
93 : * @param[in] from The origin of the call
94 : * @param mediaList A list of media
95 : * @param sipTr: SIP Transport
96 : * @return A shared pointer on the created call.
97 : */
98 : virtual std::shared_ptr<SIPCall> newIncomingCall(const std::string& from,
99 : const std::vector<libjami::MediaMap>& mediaList,
100 : const std::shared_ptr<SipTransport>& sipTr = {})
101 : = 0;
102 :
103 91 : virtual bool isStunEnabled() const { return false; }
104 :
105 0 : virtual pj_uint16_t getStunPort() const { return 0; };
106 :
107 0 : virtual std::string getDtmfType() const { return config().dtmfType; }
108 :
109 : /**
110 : * Determine if TLS is enabled for this account. TLS provides a secured channel for
111 : * SIP signalization. It is independent of the media encryption (as provided by SRTP).
112 : */
113 0 : virtual bool isTlsEnabled() const { return false; }
114 :
115 : /**
116 : * Create UAC attached dialog and invite session
117 : * @return true if success. false if failure and dlg and inv pointers
118 : * should not be considered as valid.
119 : */
120 : bool CreateClientDialogAndInvite(const pj_str_t* from,
121 : const pj_str_t* contact,
122 : const pj_str_t* to,
123 : const pj_str_t* target,
124 : const pjmedia_sdp_session* local_sdp,
125 : pjsip_dialog** dlg,
126 : pjsip_inv_session** inv);
127 :
128 : /**
129 : * Get the local interface name on which this account is bound.
130 : */
131 308 : const std::string& getLocalInterface() const { return config().interface; }
132 :
133 : /**
134 : * Get the public IP address set by the user for this account.
135 : * If this setting is not provided, the local bound adddress
136 : * will be used.
137 : * @return std::string The public IPv4 or IPv6 address formatted in standard notation.
138 : */
139 0 : std::string getPublishedAddress() const { return config().publishedIp; }
140 :
141 : virtual dhtnet::IpAddr getPublishedIpAddress(uint16_t family = PF_UNSPEC) const;
142 :
143 : void setPublishedAddress(const dhtnet::IpAddr& ip_addr);
144 :
145 : /**
146 : * Get a flag which determine the usage in sip headers of either the local
147 : * IP address and port (_localAddress and localPort_) or to an address set
148 : * manually (_publishedAddress and publishedPort_).
149 : */
150 217 : bool getPublishedSameasLocal() const { return config().publishedSameasLocal; }
151 :
152 : virtual bool isSrtpEnabled() const = 0;
153 :
154 : virtual std::string getToUri(const std::string& username) const = 0;
155 :
156 : /**
157 : * Socket port generators for media
158 : * Note: given ports are application wide, a port is unable to be given again
159 : * by any account instances until it's released by the static method
160 : * releasePort().
161 : */
162 : uint16_t generateAudioPort() const;
163 : #ifdef ENABLE_VIDEO
164 : uint16_t generateVideoPort() const;
165 : #endif
166 : static void releasePort(uint16_t port) noexcept;
167 :
168 : virtual dhtnet::IceTransportOptions getIceOptions() const;
169 :
170 : virtual void sendMessage(const std::string& to,
171 : const std::string& deviceId,
172 : const std::map<std::string, std::string>& payloads,
173 : uint64_t id,
174 : bool retryOnTimeout = true,
175 : bool onlyConnected = false)
176 : = 0;
177 :
178 13873 : virtual uint64_t sendTextMessage(const std::string& to,
179 : const std::string& deviceId,
180 : const std::map<std::string, std::string>& payloads,
181 : uint64_t refreshToken = 0,
182 : bool onlyConnected = false) override
183 : {
184 13873 : if (onlyConnected) {
185 0 : auto token = std::uniform_int_distribution<uint64_t> {1, JAMI_ID_MAX_VAL}(rand);
186 0 : sendMessage(to, deviceId, payloads, token, false, true);
187 0 : return token;
188 : }
189 13873 : return messageEngine_.sendMessage(to, deviceId, payloads, refreshToken);
190 : }
191 :
192 0 : im::MessageStatus getMessageStatus(uint64_t id) const override { return messageEngine_.getStatus(id); }
193 :
194 : virtual void onTextMessage(const std::string& id,
195 : const std::string& from,
196 : const std::shared_ptr<dht::crypto::Certificate>& peerCert,
197 : const std::map<std::string, std::string>& payloads);
198 :
199 : /* Returns true if the username and/or hostname match this account */
200 : virtual MatchRank matches(std::string_view username, std::string_view hostname) const = 0;
201 :
202 0 : void connectivityChanged() override {};
203 :
204 : virtual std::string getUserUri() const = 0;
205 :
206 : std::vector<libjami::Message> getLastMessages(const uint64_t& base_timestamp) override;
207 :
208 : // Build the list of medias to be included in the SDP (offer/answer)
209 : std::vector<MediaAttribute> createDefaultMediaList(bool addVideo, bool onHold = false);
210 :
211 : public: // overloaded methods
212 : virtual void flush() override;
213 :
214 : protected:
215 : /**
216 : * Retrieve volatile details such as recent registration errors
217 : * @return std::map< std::string, std::string > The account volatile details
218 : */
219 : virtual std::map<std::string, std::string> getVolatileAccountDetails() const override;
220 :
221 : virtual void setRegistrationState(RegistrationState state,
222 : int code = 0,
223 : const std::string& detail_str = {}) override;
224 :
225 : im::MessageEngine messageEngine_;
226 :
227 : /**
228 : * Voice over IP Link contains a listener thread and calls
229 : */
230 : SIPVoIPLink& link_;
231 :
232 : /**
233 : * Published IPv4/IPv6 addresses, used only if defined by the user in account
234 : * configuration
235 : *
236 : */
237 : dhtnet::IpAddr publishedIp_[2] {};
238 :
239 : pj_status_t transportStatus_ {PJSIP_SC_TRYING};
240 : std::string transportError_ {};
241 :
242 : static std::array<bool, HALF_MAX_PORT>& getPortsReservation() noexcept;
243 : static uint16_t acquirePort(uint16_t port);
244 : uint16_t getRandomEvenPort(const std::pair<uint16_t, uint16_t>& range) const;
245 : uint16_t acquireRandomEvenPort(const std::pair<uint16_t, uint16_t>& range) const;
246 :
247 : /**
248 : * The deamon can be launched without any client (or with a non ready client)
249 : * Like call and file transfer, a client should be able to retrieve current messages.
250 : * To avoid to explode the size in memory, this container should be limited.
251 : * We don't want to see monsters in memory.
252 : */
253 : std::mutex mutexLastMessages_;
254 : static constexpr size_t MAX_WAITING_MESSAGES_SIZE = 1000;
255 : std::deque<libjami::Message> lastMessages_;
256 :
257 : std::shared_ptr<dhtnet::TurnCache> turnCache_;
258 :
259 : private:
260 : NON_COPYABLE(SIPAccountBase);
261 : };
262 :
263 : } // namespace jami
|
