Migrate PeerStatus events to stasis, add stasis endpoints, and add chan_pjsip device...
[asterisk/asterisk.git] / include / asterisk / res_sip.h
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 2013, Digium, Inc.
5  *
6  * Mark Michelson <mmichelson@digium.com>
7  *
8  * See http://www.asterisk.org for more information about
9  * the Asterisk project. Please do not directly contact
10  * any of the maintainers of this project for assistance;
11  * the project provides a web site, mailing lists and IRC
12  * channels for your use.
13  *
14  * This program is free software, distributed under the terms of
15  * the GNU General Public License Version 2. See the LICENSE file
16  * at the top of the source tree.
17  */
18
19 #ifndef _RES_SIP_H
20 #define _RES_SIP_H
21
22 #include "asterisk/stringfields.h"
23 /* Needed for struct ast_sockaddr */
24 #include "asterisk/netsock2.h"
25 /* Needed for linked list macros */
26 #include "asterisk/linkedlists.h"
27 /* Needed for ast_party_id */
28 #include "asterisk/channel.h"
29 /* Needed for ast_sorcery */
30 #include "asterisk/sorcery.h"
31 /* Needed for ast_dnsmgr */
32 #include "asterisk/dnsmgr.h"
33 /* Needed for ast_endpoint */
34 #include "asterisk/endpoints.h"
35 /* Needed for pj_sockaddr */
36 #include <pjlib.h>
37
38 /* Forward declarations of PJSIP stuff */
39 struct pjsip_rx_data;
40 struct pjsip_module;
41 struct pjsip_tx_data;
42 struct pjsip_dialog;
43 struct pjsip_transport;
44 struct pjsip_tpfactory;
45 struct pjsip_tls_setting;
46 struct pjsip_tpselector;
47
48 /*!
49  * \brief Structure for SIP transport information
50  */
51 struct ast_sip_transport_state {
52         /*! \brief Transport itself */
53         struct pjsip_transport *transport;
54
55         /*! \brief Transport factory */
56         struct pjsip_tpfactory *factory;
57 };
58
59 #define SIP_SORCERY_DOMAIN_ALIAS_TYPE "domain_alias"
60
61 /*!
62  * Details about a SIP domain alias
63  */
64 struct ast_sip_domain_alias {
65         /*! Sorcery object details */
66         SORCERY_OBJECT(details);
67         AST_DECLARE_STRING_FIELDS(
68                 /*! Domain to be aliased to */
69                 AST_STRING_FIELD(domain);
70         );
71 };
72
73 /*! \brief Maximum number of ciphers supported for a TLS transport */
74 #define SIP_TLS_MAX_CIPHERS 64
75
76 /*
77  * \brief Transport to bind to
78  */
79 struct ast_sip_transport {
80         /*! Sorcery object details */
81         SORCERY_OBJECT(details);
82         AST_DECLARE_STRING_FIELDS(
83                 /*! Certificate of authority list file */
84                 AST_STRING_FIELD(ca_list_file);
85                 /*! Public certificate file */
86                 AST_STRING_FIELD(cert_file);
87                 /*! Optional private key of the certificate file */
88                 AST_STRING_FIELD(privkey_file);
89                 /*! Password to open the private key */
90                 AST_STRING_FIELD(password);
91                 /*! External signaling address */
92                 AST_STRING_FIELD(external_signaling_address);
93                 /*! External media address */
94                 AST_STRING_FIELD(external_media_address);
95                 /*! Optional domain to use for messages if provided could not be found */
96                 AST_STRING_FIELD(domain);
97                 );
98         /*! Type of transport */
99         enum ast_transport type;
100         /*! Address and port to bind to */
101         pj_sockaddr host;
102         /*! Number of simultaneous asynchronous operations */
103         unsigned int async_operations;
104         /*! Optional external port for signaling */
105         unsigned int external_signaling_port;
106         /*! TLS settings */
107         pjsip_tls_setting tls;
108         /*! Configured TLS ciphers */
109         pj_ssl_cipher ciphers[SIP_TLS_MAX_CIPHERS];
110         /*! Optional local network information, used for NAT purposes */
111         struct ast_ha *localnet;
112         /*! DNS manager for refreshing the external address */
113         struct ast_dnsmgr_entry *external_address_refresher;
114         /*! Optional external address information */
115         struct ast_sockaddr external_address;
116         /*! Transport state information */
117         struct ast_sip_transport_state *state;
118 };
119
120 /*!
121  * \brief Structure for SIP nat hook information
122  */
123 struct ast_sip_nat_hook {
124         /*! Sorcery object details */
125         SORCERY_OBJECT(details);
126         /*! Callback for when a message is going outside of our local network */
127         void (*outgoing_external_message)(struct pjsip_tx_data *tdata, struct ast_sip_transport *transport);
128 };
129
130 /*!
131  * \brief Contact associated with an address of record
132  */
133 struct ast_sip_contact {
134         /*! Sorcery object details, the id is the aor name plus a random string */
135         SORCERY_OBJECT(details);
136         AST_DECLARE_STRING_FIELDS(
137                 /*! Full URI of the contact */
138                 AST_STRING_FIELD(uri);
139         );
140         /*! Absolute time that this contact is no longer valid after */
141         struct timeval expiration_time;
142 };
143
144 /*!
145  * \brief A SIP address of record
146  */
147 struct ast_sip_aor {
148         /*! Sorcery object details, the id is the AOR name */
149         SORCERY_OBJECT(details);
150         AST_DECLARE_STRING_FIELDS(
151                 /*! Voicemail boxes for this AOR */
152                 AST_STRING_FIELD(mailboxes);
153         );
154         /*! Minimum expiration time */
155         unsigned int minimum_expiration;
156         /*! Maximum expiration time */
157         unsigned int maximum_expiration;
158         /*! Default contact expiration if one is not provided in the contact */
159         unsigned int default_expiration;
160         /*! Maximum number of external contacts, 0 to disable */
161         unsigned int max_contacts;
162         /*! Whether to remove any existing contacts not related to an incoming REGISTER when it comes in */
163         unsigned int remove_existing;
164         /*! Any permanent configured contacts */
165         struct ao2_container *permanent_contacts;
166 };
167
168 /*!
169  * \brief DTMF modes for SIP endpoints
170  */
171 enum ast_sip_dtmf_mode {
172         /*! No DTMF to be used */
173         AST_SIP_DTMF_NONE,
174         /* XXX Should this be 2833 instead? */
175         /*! Use RFC 4733 events for DTMF */
176         AST_SIP_DTMF_RFC_4733,
177         /*! Use DTMF in the audio stream */
178         AST_SIP_DTMF_INBAND,
179         /*! Use SIP INFO DTMF (blech) */
180         AST_SIP_DTMF_INFO,
181 };
182
183 /*!
184  * \brief Methods of storing SIP digest authentication credentials.
185  *
186  * Note that both methods result in MD5 digest authentication being
187  * used. The two methods simply alter how Asterisk determines the
188  * credentials for a SIP authentication
189  */
190 enum ast_sip_auth_type {
191         /*! Credentials stored as a username and password combination */
192         AST_SIP_AUTH_TYPE_USER_PASS,
193         /*! Credentials stored as an MD5 sum */
194         AST_SIP_AUTH_TYPE_MD5,
195 };
196
197 #define SIP_SORCERY_AUTH_TYPE "auth"
198
199 struct ast_sip_auth {
200         /* Sorcery ID of the auth is its name */
201         SORCERY_OBJECT(details);
202         AST_DECLARE_STRING_FIELDS(
203                 /* Identification for these credentials */
204                 AST_STRING_FIELD(realm);
205                 /* Authentication username */
206                 AST_STRING_FIELD(auth_user);
207                 /* Authentication password */
208                 AST_STRING_FIELD(auth_pass);
209                 /* Authentication credentials in MD5 format (hash of user:realm:pass) */
210                 AST_STRING_FIELD(md5_creds);
211         );
212         /* The time period (in seconds) that a nonce may be reused */
213         unsigned int nonce_lifetime;
214         /* Used to determine what to use when authenticating */
215         enum ast_sip_auth_type type;
216 };
217
218 /*!
219  * \brief Different methods by which incoming requests can be matched to endpoints
220  */
221 enum ast_sip_endpoint_identifier_type {
222         /*! Identify based on user name in From header */
223         AST_SIP_ENDPOINT_IDENTIFY_BY_USERNAME = (1 << 0),
224         /*! Identify based on source location of the SIP message */
225         AST_SIP_ENDPOINT_IDENTIFY_BY_LOCATION = (1 << 1),
226 };
227
228 enum ast_sip_session_refresh_method {
229         /*! Use reinvite to negotiate direct media */
230         AST_SIP_SESSION_REFRESH_METHOD_INVITE,
231         /*! Use UPDATE to negotiate direct media */
232         AST_SIP_SESSION_REFRESH_METHOD_UPDATE,
233 };
234
235 enum ast_sip_direct_media_glare_mitigation {
236         /*! Take no special action to mitigate reinvite glare */
237         AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_NONE,
238         /*! Do not send an initial direct media session refresh on outgoing call legs
239          * Subsequent session refreshes will be sent no matter the session direction
240          */
241         AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_OUTGOING,
242         /*! Do not send an initial direct media session refresh on incoming call legs
243          * Subsequent session refreshes will be sent no matter the session direction
244          */
245         AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_INCOMING,
246 };
247
248 /*!
249  * \brief An entity with which Asterisk communicates
250  */
251 struct ast_sip_endpoint {
252         SORCERY_OBJECT(details);
253         AST_DECLARE_STRING_FIELDS(
254                 /*! Context to send incoming calls to */
255                 AST_STRING_FIELD(context);
256                 /*! Name of an explicit transport to use */
257                 AST_STRING_FIELD(transport);
258                 /*! Outbound proxy to use */
259                 AST_STRING_FIELD(outbound_proxy);
260                 /*! Explicit AORs to dial if none are specified */
261                 AST_STRING_FIELD(aors);
262                 /*! Musiconhold class to suggest that the other side use when placing on hold */
263                 AST_STRING_FIELD(mohsuggest);
264                 /*! Optional external media address to use in SDP */
265                 AST_STRING_FIELD(external_media_address);
266                 /*! Configured voicemail boxes for this endpoint. Used for MWI */
267                 AST_STRING_FIELD(mailboxes);
268         );
269         /*! Identification information for this endpoint */
270         struct ast_party_id id;
271         /*! Domain to which this endpoint belongs */
272         struct ast_sip_domain *domain;
273         /*! Address of record for incoming registrations */
274         struct ast_sip_aor *aor;
275         /*! Codec preferences */
276         struct ast_codec_pref prefs;
277         /*! Configured codecs */
278         struct ast_format_cap *codecs;
279         /*! Names of inbound authentication credentials */
280         const char **sip_inbound_auths;
281         /*! Number of configured auths */
282         size_t num_inbound_auths;
283         /*! Names of outbound authentication credentials */
284         const char **sip_outbound_auths;
285         /*! Number of configured outbound auths */
286         size_t num_outbound_auths;
287         /*! DTMF mode to use with this endpoint */
288         enum ast_sip_dtmf_mode dtmf;
289         /*! Whether IPv6 RTP is enabled or not */
290         unsigned int rtp_ipv6;
291         /*! Whether symmetric RTP is enabled or not */
292         unsigned int rtp_symmetric;
293         /*! Whether ICE support is enabled or not */
294         unsigned int ice_support;
295         /*! Whether to use the "ptime" attribute received from the endpoint or not */
296         unsigned int use_ptime;
297         /*! Whether to force using the source IP address/port for sending responses */
298         unsigned int force_rport;
299         /*! Whether to rewrite the Contact header with the source IP address/port or not */
300         unsigned int rewrite_contact;
301         /*! Enabled SIP extensions */
302         unsigned int extensions;
303         /*! Minimum session expiration period, in seconds */
304         unsigned int min_se;
305         /*! Session expiration period, in seconds */
306         unsigned int sess_expires;
307         /*! List of outbound registrations */
308         AST_LIST_HEAD_NOLOCK(, ast_sip_registration) registrations;
309         /*! Frequency to send OPTIONS requests to endpoint. 0 is disabled. */
310         unsigned int qualify_frequency;
311         /*! Method(s) by which the endpoint should be identified. */
312         enum ast_sip_endpoint_identifier_type ident_method;
313         /*! Boolean indicating if direct_media is permissible */
314         unsigned int direct_media;
315         /*! When using direct media, which method should be used */
316         enum ast_sip_session_refresh_method direct_media_method;
317         /*! Take steps to mitigate glare for direct media */
318         enum ast_sip_direct_media_glare_mitigation direct_media_glare_mitigation;
319         /*! Do not attempt direct media session refreshes if a media NAT is detected */
320         unsigned int disable_direct_media_on_nat;
321         /*! Do we trust the endpoint with our outbound identity? */
322         unsigned int trust_id_outbound;
323         /*! Do we trust identity information that originates externally (e.g. P-Asserted-Identity header)? */
324         unsigned int trust_id_inbound;
325         /*! Do we send P-Asserted-Identity headers to this endpoint? */
326         unsigned int send_pai;
327         /*! Do we send Remote-Party-ID headers to this endpoint? */
328         unsigned int send_rpid;
329         /*! Should unsolicited MWI be aggregated into a single NOTIFY? */
330         unsigned int aggregate_mwi;
331         /*! Pointer to the persistent Asterisk endpoint */
332         struct ast_endpoint *persistent;
333         /*! The number of channels at which busy device state is returned */
334         unsigned int devicestate_busy_at;
335 };
336
337 /*!
338  * \brief Possible returns from ast_sip_check_authentication
339  */
340 enum ast_sip_check_auth_result {
341     /*! Authentication needs to be challenged */
342     AST_SIP_AUTHENTICATION_CHALLENGE,
343     /*! Authentication succeeded */
344     AST_SIP_AUTHENTICATION_SUCCESS,
345     /*! Authentication failed */
346     AST_SIP_AUTHENTICATION_FAILED,
347     /*! Authentication encountered some internal error */
348     AST_SIP_AUTHENTICATION_ERROR,
349 };
350
351 /*!
352  * \brief An interchangeable way of handling digest authentication for SIP.
353  *
354  * An authenticator is responsible for filling in the callbacks provided below. Each is called from a publicly available
355  * function in res_sip. The authenticator can use configuration or other local policy to determine whether authentication
356  * should take place and what credentials should be used when challenging and authenticating a request.
357  */
358 struct ast_sip_authenticator {
359     /*!
360      * \brief Check if a request requires authentication
361      * See ast_sip_requires_authentication for more details
362      */
363     int (*requires_authentication)(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata);
364         /*!
365          * \brief Check that an incoming request passes authentication.
366          *
367          * The tdata parameter is useful for adding information such as digest challenges.
368          *
369          * \param endpoint The endpoint sending the incoming request
370          * \param rdata The incoming request
371          * \param tdata Tentative outgoing request.
372          */
373         enum ast_sip_check_auth_result (*check_authentication)(struct ast_sip_endpoint *endpoint,
374                         pjsip_rx_data *rdata, pjsip_tx_data *tdata);
375 };
376
377 /*!
378  * \brief an interchangeable way of responding to authentication challenges
379  *
380  * An outbound authenticator takes incoming challenges and formulates a new SIP request with
381  * credentials.
382  */
383 struct ast_sip_outbound_authenticator {
384         /*!
385          * \brief Create a new request with authentication credentials
386          *
387          * \param auths An array of IDs of auth sorcery objects
388          * \param num_auths The number of IDs in the array
389          * \param challenge The SIP response with authentication challenge(s)
390          * \param tsx The transaction in which the challenge was received
391          * \param new_request The new SIP request with challenge response(s)
392          * \retval 0 Successfully created new request
393          * \retval -1 Failed to create a new request
394          */
395         int (*create_request_with_auth)(const char **auths, size_t num_auths, struct pjsip_rx_data *challenge,
396                         struct pjsip_transaction *tsx, struct pjsip_tx_data **new_request);
397 };
398
399 /*!
400  * \brief An entity responsible for identifying the source of a SIP message
401  */
402 struct ast_sip_endpoint_identifier {
403     /*!
404      * \brief Callback used to identify the source of a message.
405      * See ast_sip_identify_endpoint for more details
406      */
407     struct ast_sip_endpoint *(*identify_endpoint)(pjsip_rx_data *rdata);
408 };
409
410 /*!
411  * \brief Register a SIP service in Asterisk.
412  *
413  * This is more-or-less a wrapper around pjsip_endpt_register_module().
414  * Registering a service makes it so that PJSIP will call into the
415  * service at appropriate times. For more information about PJSIP module
416  * callbacks, see the PJSIP documentation. Asterisk modules that call
417  * this function will likely do so at module load time.
418  *
419  * \param module The module that is to be registered with PJSIP
420  * \retval 0 Success
421  * \retval -1 Failure
422  */
423 int ast_sip_register_service(pjsip_module *module);
424
425 /*!
426  * This is the opposite of ast_sip_register_service().  Unregistering a
427  * service means that PJSIP will no longer call into the module any more.
428  * This will likely occur when an Asterisk module is unloaded.
429  *
430  * \param module The PJSIP module to unregister
431  */
432 void ast_sip_unregister_service(pjsip_module *module);
433
434 /*!
435  * \brief Register a SIP authenticator
436  *
437  * An authenticator has three main purposes:
438  * 1) Determining if authentication should be performed on an incoming request
439  * 2) Gathering credentials necessary for issuing an authentication challenge
440  * 3) Authenticating a request that has credentials
441  *
442  * Asterisk provides a default authenticator, but it may be replaced by a
443  * custom one if desired.
444  *
445  * \param auth The authenticator to register
446  * \retval 0 Success
447  * \retval -1 Failure
448  */
449 int ast_sip_register_authenticator(struct ast_sip_authenticator *auth);
450
451 /*!
452  * \brief Unregister a SIP authenticator
453  *
454  * When there is no authenticator registered, requests cannot be challenged
455  * or authenticated.
456  *
457  * \param auth The authenticator to unregister
458  */
459 void ast_sip_unregister_authenticator(struct ast_sip_authenticator *auth);
460
461  /*!
462  * \brief Register an outbound SIP authenticator
463  *
464  * An outbound authenticator is responsible for creating responses to
465  * authentication challenges by remote endpoints.
466  *
467  * \param auth The authenticator to register
468  * \retval 0 Success
469  * \retval -1 Failure
470  */
471 int ast_sip_register_outbound_authenticator(struct ast_sip_outbound_authenticator *outbound_auth);
472
473 /*!
474  * \brief Unregister an outbound SIP authenticator
475  *
476  * When there is no outbound authenticator registered, authentication challenges
477  * will be handled as any other final response would be.
478  *
479  * \param auth The authenticator to unregister
480  */
481 void ast_sip_unregister_outbound_authenticator(struct ast_sip_outbound_authenticator *auth);
482
483 /*!
484  * \brief Register a SIP endpoint identifier
485  *
486  * An endpoint identifier's purpose is to determine which endpoint a given SIP
487  * message has come from.
488  *
489  * Multiple endpoint identifiers may be registered so that if an endpoint
490  * cannot be identified by one identifier, it may be identified by another.
491  *
492  * Asterisk provides two endpoint identifiers. One identifies endpoints based
493  * on the user part of the From header URI. The other identifies endpoints based
494  * on the source IP address.
495  *
496  * If the order in which endpoint identifiers is run is important to you, then
497  * be sure to load individual endpoint identifier modules in the order you wish
498  * for them to be run in modules.conf
499  *
500  * \param identifier The SIP endpoint identifier to register
501  * \retval 0 Success
502  * \retval -1 Failure
503  */
504 int ast_sip_register_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier);
505
506 /*!
507  * \brief Unregister a SIP endpoint identifier
508  *
509  * This stops an endpoint identifier from being used.
510  *
511  * \param identifier The SIP endoint identifier to unregister
512  */
513 void ast_sip_unregister_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier);
514
515 /*!
516  * \brief Allocate a new SIP endpoint
517  *
518  * This will return an endpoint with its refcount increased by one. This reference
519  * can be released using ao2_ref().
520  *
521  * \param name The name of the endpoint.
522  * \retval NULL Endpoint allocation failed
523  * \retval non-NULL The newly allocated endpoint
524  */
525 void *ast_sip_endpoint_alloc(const char *name);
526
527 /*!
528  * \brief Get a pointer to the PJSIP endpoint.
529  *
530  * This is useful when modules have specific information they need
531  * to register with the PJSIP core.
532  * \retval NULL endpoint has not been created yet.
533  * \retval non-NULL PJSIP endpoint.
534  */
535 pjsip_endpoint *ast_sip_get_pjsip_endpoint(void);
536
537 /*!
538  * \brief Get a pointer to the SIP sorcery structure.
539  *
540  * \retval NULL sorcery has not been initialized
541  * \retval non-NULL sorcery structure
542  */
543 struct ast_sorcery *ast_sip_get_sorcery(void);
544
545 /*!
546  * \brief Initialize transport support on a sorcery instance
547  *
548  * \param sorcery The sorcery instance
549  *
550  * \retval -1 failure
551  * \retval 0 success
552  */
553 int ast_sip_initialize_sorcery_transport(struct ast_sorcery *sorcery);
554
555 /*!
556  * \brief Initialize location support on a sorcery instance
557  *
558  * \param sorcery The sorcery instance
559  *
560  * \retval -1 failure
561  * \retval 0 success
562  */
563 int ast_sip_initialize_sorcery_location(struct ast_sorcery *sorcery);
564
565 /*!
566  * \brief Retrieve a named AOR
567  *
568  * \param aor_name Name of the AOR
569  *
570  * \retval NULL if not found
571  * \retval non-NULL if found
572  */
573 struct ast_sip_aor *ast_sip_location_retrieve_aor(const char *aor_name);
574
575 /*!
576  * \brief Retrieve the first bound contact for an AOR
577  *
578  * \param aor Pointer to the AOR
579  * \retval NULL if no contacts available
580  * \retval non-NULL if contacts available
581  */
582 struct ast_sip_contact *ast_sip_location_retrieve_first_aor_contact(const struct ast_sip_aor *aor);
583
584 /*!
585  * \brief Retrieve all contacts currently available for an AOR
586  *
587  * \param aor Pointer to the AOR
588  *
589  * \retval NULL if no contacts available
590  * \retval non-NULL if contacts available
591  */
592 struct ao2_container *ast_sip_location_retrieve_aor_contacts(const struct ast_sip_aor *aor);
593
594 /*!
595  * \brief Retrieve the first bound contact from a list of AORs
596  *
597  * \param aor_list A comma-separated list of AOR names
598  * \retval NULL if no contacts available
599  * \retval non-NULL if contacts available
600  */
601 struct ast_sip_contact *ast_sip_location_retrieve_contact_from_aor_list(const char *aor_list);
602
603 /*!
604  * \brief Retrieve a named contact
605  *
606  * \param contact_name Name of the contact
607  *
608  * \retval NULL if not found
609  * \retval non-NULL if found
610  */
611 struct ast_sip_contact *ast_sip_location_retrieve_contact(const char *contact_name);
612
613 /*!
614  * \brief Add a new contact to an AOR
615  *
616  * \param aor Pointer to the AOR
617  * \param uri Full contact URI
618  * \param expiration_time Optional expiration time of the contact
619  *
620  * \retval -1 failure
621  * \retval 0 success
622  */
623 int ast_sip_location_add_contact(struct ast_sip_aor *aor, const char *uri, struct timeval expiration_time);
624
625 /*!
626  * \brief Update a contact
627  *
628  * \param contact New contact object with details
629  *
630  * \retval -1 failure
631  * \retval 0 success
632  */
633 int ast_sip_location_update_contact(struct ast_sip_contact *contact);
634
635 /*!
636 * \brief Delete a contact
637 *
638 * \param contact Contact object to delete
639 *
640 * \retval -1 failure
641 * \retval 0 success
642 */
643 int ast_sip_location_delete_contact(struct ast_sip_contact *contact);
644
645 /*!
646  * \brief Initialize domain aliases support on a sorcery instance
647  *
648  * \param sorcery The sorcery instance
649  *
650  * \retval -1 failure
651  * \retval 0 success
652  */
653 int ast_sip_initialize_sorcery_domain_alias(struct ast_sorcery *sorcery);
654
655 /*!
656  * \brief Initialize authentication support on a sorcery instance
657  *
658  * \param sorcery The sorcery instance
659  *
660  * \retval -1 failure
661  * \retval 0 success
662  */
663 int ast_sip_initialize_sorcery_auth(struct ast_sorcery *sorcery);
664
665 /*!
666  * \brief Callback called when an outbound request with authentication credentials is to be sent in dialog
667  *
668  * This callback will have the created request on it. The callback's purpose is to do any extra
669  * housekeeping that needs to be done as well as to send the request out.
670  *
671  * This callback is only necessary if working with a PJSIP API that sits between the application
672  * and the dialog layer.
673  *
674  * \param dlg The dialog to which the request belongs
675  * \param tdata The created request to be sent out
676  * \param user_data Data supplied with the callback
677  *
678  * \retval 0 Success
679  * \retval -1 Failure
680  */
681 typedef int (*ast_sip_dialog_outbound_auth_cb)(pjsip_dialog *dlg, pjsip_tx_data *tdata, void *user_data);
682
683 /*!
684  * \brief Set up outbound authentication on a SIP dialog
685  *
686  * This sets up the infrastructure so that all requests associated with a created dialog
687  * can be re-sent with authentication credentials if the original request is challenged.
688  *
689  * \param dlg The dialog on which requests will be authenticated
690  * \param endpoint The endpoint whom this dialog pertains to
691  * \param cb Callback to call to send requests with authentication
692  * \param user_data Data to be provided to the callback when it is called
693  *
694  * \retval 0 Success
695  * \retval -1 Failure
696  */
697 int ast_sip_dialog_setup_outbound_authentication(pjsip_dialog *dlg, const struct ast_sip_endpoint *endpoint,
698                 ast_sip_dialog_outbound_auth_cb cb, void *user_data);
699
700 /*!
701  * \brief Initialize the distributor module
702  *
703  * The distributor module is responsible for taking an incoming
704  * SIP message and placing it into the threadpool. Once in the threadpool,
705  * the distributor will perform endpoint lookups and authentication, and
706  * then distribute the message up the stack to any further modules.
707  *
708  * \retval -1 Failure
709  * \retval 0 Success
710  */
711 int ast_sip_initialize_distributor(void);
712
713 /*!
714  * \page Threading model for SIP
715  *
716  * There are three major types of threads that SIP will have to deal with:
717  * \li Asterisk threads
718  * \li PJSIP threads
719  * \li SIP threadpool threads (a.k.a. "servants")
720  *
721  * \par Asterisk Threads
722  *
723  * Asterisk threads are those that originate from outside of SIP but within
724  * Asterisk. The most common of these threads are PBX (channel) threads and
725  * the autoservice thread. Most interaction with these threads will be through
726  * channel technology callbacks. Within these threads, it is fine to handle
727  * Asterisk data from outside of SIP, but any handling of SIP data should be
728  * left to servants, \b especially if you wish to call into PJSIP for anything.
729  * Asterisk threads are not registered with PJLIB, so attempting to call into
730  * PJSIP will cause an assertion to be triggered, thus causing the program to
731  * crash.
732  *
733  * \par PJSIP Threads
734  *
735  * PJSIP threads are those that originate from handling of PJSIP events, such
736  * as an incoming SIP request or response, or a transaction timeout. The role
737  * of these threads is to process information as quickly as possible so that
738  * the next item on the SIP socket(s) can be serviced. On incoming messages,
739  * Asterisk automatically will push the request to a servant thread. When your
740  * module callback is called, processing will already be in a servant. However,
741  * for other PSJIP events, such as transaction state changes due to timer
742  * expirations, your module will be called into from a PJSIP thread. If you
743  * are called into from a PJSIP thread, then you should push whatever processing
744  * is needed to a servant as soon as possible. You can discern if you are currently
745  * in a SIP servant thread using the \ref ast_sip_thread_is_servant function.
746  *
747  * \par Servants
748  *
749  * Servants are where the bulk of SIP work should be performed. These threads
750  * exist in order to do the work that Asterisk threads and PJSIP threads hand
751  * off to them. Servant threads register themselves with PJLIB, meaning that
752  * they are capable of calling PJSIP and PJLIB functions if they wish.
753  *
754  * \par Serializer
755  *
756  * Tasks are handed off to servant threads using the API call \ref ast_sip_push_task.
757  * The first parameter of this call is a serializer. If this pointer
758  * is NULL, then the work will be handed off to whatever servant can currently handle
759  * the task. If this pointer is non-NULL, then the task will not be executed until
760  * previous tasks pushed with the same serializer have completed. For more information
761  * on serializers and the benefits they provide, see \ref ast_threadpool_serializer
762  *
763  * \note
764  *
765  * Do not make assumptions about individual threads based on a corresponding serializer.
766  * In other words, just because several tasks use the same serializer when being pushed
767  * to servants, it does not mean that the same thread is necessarily going to execute those
768  * tasks, even though they are all guaranteed to be executed in sequence.
769  */
770
771 /*!
772  * \brief Create a new serializer for SIP tasks
773  *
774  * See \ref ast_threadpool_serializer for more information on serializers.
775  * SIP creates serializers so that tasks operating on similar data will run
776  * in sequence.
777  *
778  * \retval NULL Failure
779  * \retval non-NULL Newly-created serializer
780  */
781 struct ast_taskprocessor *ast_sip_create_serializer(void);
782
783 /*!
784  * \brief Set a serializer on a SIP dialog so requests and responses are automatically serialized
785  *
786  * Passing a NULL serializer is a way to remove a serializer from a dialog.
787  *
788  * \param dlg The SIP dialog itself
789  * \param serializer The serializer to use
790  */
791 void ast_sip_dialog_set_serializer(pjsip_dialog *dlg, struct ast_taskprocessor *serializer);
792
793 /*!
794  * \brief Set an endpoint on a SIP dialog so in-dialog requests do not undergo endpoint lookup.
795  *
796  * \param dlg The SIP dialog itself
797  * \param endpoint The endpoint that this dialog is communicating with
798  */
799 void ast_sip_dialog_set_endpoint(pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint);
800
801 /*!
802  * \brief Get the endpoint associated with this dialog
803  *
804  * This function increases the refcount of the endpoint by one. Release
805  * the reference once you are finished with the endpoint.
806  *
807  * \param dlg The SIP dialog from which to retrieve the endpoint
808  * \retval NULL No endpoint associated with this dialog
809  * \retval non-NULL The endpoint.
810  */
811 struct ast_sip_endpoint *ast_sip_dialog_get_endpoint(pjsip_dialog *dlg);
812
813 /*!
814  * \brief Pushes a task to SIP servants
815  *
816  * This uses the serializer provided to determine how to push the task.
817  * If the serializer is NULL, then the task will be pushed to the
818  * servants directly. If the serializer is non-NULL, then the task will be
819  * queued behind other tasks associated with the same serializer.
820  *
821  * \param serializer The serializer to which the task belongs. Can be NULL
822  * \param sip_task The task to execute
823  * \param task_data The parameter to pass to the task when it executes
824  * \retval 0 Success
825  * \retval -1 Failure
826  */
827 int ast_sip_push_task(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data);
828
829 /*!
830  * \brief Push a task to SIP servants and wait for it to complete
831  *
832  * Like \ref ast_sip_push_task except that it blocks until the task completes.
833  *
834  * \warning \b Never use this function in a SIP servant thread. This can potentially
835  * cause a deadlock. If you are in a SIP servant thread, just call your function
836  * in-line.
837  *
838  * \param serializer The SIP serializer to which the task belongs. May be NULL.
839  * \param sip_task The task to execute
840  * \param task_data The parameter to pass to the task when it executes
841  * \retval 0 Success
842  * \retval -1 Failure
843  */
844 int ast_sip_push_task_synchronous(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data);
845
846 /*!
847  * \brief Determine if the current thread is a SIP servant thread
848  *
849  * \retval 0 This is not a SIP servant thread
850  * \retval 1 This is a SIP servant thread
851  */
852 int ast_sip_thread_is_servant(void);
853
854 /*!
855  * \brief SIP body description
856  *
857  * This contains a type and subtype that will be added as
858  * the "Content-Type" for the message as well as the body
859  * text.
860  */
861 struct ast_sip_body {
862         /*! Type of the body, such as "application" */
863         const char *type;
864         /*! Subtype of the body, such as "sdp" */
865         const char *subtype;
866         /*! The text to go in the body */
867         const char *body_text;
868 };
869
870 /*!
871  * \brief General purpose method for creating a dialog with an endpoint
872  *
873  * \param endpoint A pointer to the endpoint
874  * \param aor_name Optional name of the AOR to target, may even be an explicit SIP URI
875  * \param request_user Optional user to place into the target URI
876  *
877  * \retval non-NULL success
878  * \retval NULL failure
879  */
880  pjsip_dialog *ast_sip_create_dialog(const struct ast_sip_endpoint *endpoint, const char *aor_name, const char *request_user);
881
882 /*!
883  * \brief General purpose method for creating a SIP request
884  *
885  * Its typical use would be to create one-off requests such as an out of dialog
886  * SIP MESSAGE.
887  *
888  * The request can either be in- or out-of-dialog. If in-dialog, the
889  * dlg parameter MUST be present. If out-of-dialog the endpoint parameter
890  * MUST be present. If both are present, then we will assume that the message
891  * is to be sent in-dialog.
892  *
893  * The uri parameter can be specified if the request should be sent to an explicit
894  * URI rather than one configured on the endpoint.
895  *
896  * \param method The method of the SIP request to send
897  * \param dlg Optional. If specified, the dialog on which to request the message.
898  * \param endpoint Optional. If specified, the request will be created out-of-dialog
899  * to the endpoint.
900  * \param uri Optional. If specified, the request will be sent to this URI rather
901  * than one configured for the endpoint.
902  * \param[out] tdata The newly-created request
903  * \retval 0 Success
904  * \retval -1 Failure
905  */
906 int ast_sip_create_request(const char *method, struct pjsip_dialog *dlg,
907                 struct ast_sip_endpoint *endpoint, const char *uri, pjsip_tx_data **tdata);
908
909 /*!
910  * \brief General purpose method for sending a SIP request
911  *
912  * This is a companion function for \ref ast_sip_create_request. The request
913  * created there can be passed to this function, though any request may be
914  * passed in.
915  *
916  * This will automatically set up handling outbound authentication challenges if
917  * they arrive.
918  *
919  * \param tdata The request to send
920  * \param dlg Optional. If specified, the dialog on which the request should be sent
921  * \param endpoint Optional. If specified, the request is sent out-of-dialog to the endpoint.
922  * \retval 0 Success
923  * \retval -1 Failure
924  */
925 int ast_sip_send_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint);
926
927 /*!
928  * \brief Determine if an incoming request requires authentication
929  *
930  * This calls into the registered authenticator's requires_authentication callback
931  * in order to determine if the request requires authentication.
932  *
933  * If there is no registered authenticator, then authentication will be assumed
934  * not to be required.
935  *
936  * \param endpoint The endpoint from which the request originates
937  * \param rdata The incoming SIP request
938  * \retval non-zero The request requires authentication
939  * \retval 0 The request does not require authentication
940  */
941 int ast_sip_requires_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata);
942
943 /*!
944  * \brief Method to determine authentication status of an incoming request
945  *
946  * This will call into a registered authenticator. The registered authenticator will
947  * do what is necessary to determine whether the incoming request passes authentication.
948  * A tentative response is passed into this function so that if, say, a digest authentication
949  * challenge should be sent in the ensuing response, it can be added to the response.
950  *
951  * \param endpoint The endpoint from the request was sent
952  * \param rdata The request to potentially authenticate
953  * \param tdata Tentative response to the request
954  * \return The result of checking authentication.
955  */
956 enum ast_sip_check_auth_result ast_sip_check_authentication(struct ast_sip_endpoint *endpoint,
957                 pjsip_rx_data *rdata, pjsip_tx_data *tdata);
958
959 /*!
960  * \brief Create a response to an authentication challenge
961  *
962  * This will call into an outbound authenticator's create_request_with_auth callback
963  * to create a new request with authentication credentials. See the create_request_with_auth
964  * callback in the \ref ast_sip_outbound_authenticator structure for details about
965  * the parameters and return values.
966  */
967 int ast_sip_create_request_with_auth(const char **auths, size_t num_auths, pjsip_rx_data *challenge,
968                 pjsip_transaction *tsx, pjsip_tx_data **new_request);
969
970 /*!
971  * \brief Determine the endpoint that has sent a SIP message
972  *
973  * This will call into each of the registered endpoint identifiers'
974  * identify_endpoint() callbacks until one returns a non-NULL endpoint.
975  * This will return an ao2 object. Its reference count will need to be
976  * decremented when completed using the endpoint.
977  *
978  * \param rdata The inbound SIP message to use when identifying the endpoint.
979  * \retval NULL No matching endpoint
980  * \retval non-NULL The matching endpoint
981  */
982 struct ast_sip_endpoint *ast_sip_identify_endpoint(pjsip_rx_data *rdata);
983
984 /*!
985  * \brief Add a header to an outbound SIP message
986  *
987  * \param tdata The message to add the header to
988  * \param name The header name
989  * \param value The header value
990  * \retval 0 Success
991  * \retval -1 Failure
992  */
993 int ast_sip_add_header(pjsip_tx_data *tdata, const char *name, const char *value);
994
995 /*!
996  * \brief Add a body to an outbound SIP message
997  *
998  * If this is called multiple times, the latest body will replace the current
999  * body.
1000  *
1001  * \param tdata The message to add the body to
1002  * \param body The message body to add
1003  * \retval 0 Success
1004  * \retval -1 Failure
1005  */
1006 int ast_sip_add_body(pjsip_tx_data *tdata, const struct ast_sip_body *body);
1007
1008 /*!
1009  * \brief Add a multipart body to an outbound SIP message
1010  *
1011  * This will treat each part of the input array as part of a multipart body and
1012  * add each part to the SIP message.
1013  *
1014  * \param tdata The message to add the body to
1015  * \param bodies The parts of the body to add
1016  * \retval 0 Success
1017  * \retval -1 Failure
1018  */
1019 int ast_sip_add_body_multipart(pjsip_tx_data *tdata, const struct ast_sip_body *bodies[], int num_bodies);
1020
1021 /*!
1022  * \brief Append body data to a SIP message
1023  *
1024  * This acts mostly the same as ast_sip_add_body, except that rather than replacing
1025  * a body if it currently exists, it appends data to an existing body.
1026  *
1027  * \param tdata The message to append the body to
1028  * \param body The string to append to the end of the current body
1029  * \retval 0 Success
1030  * \retval -1 Failure
1031  */
1032 int ast_sip_append_body(pjsip_tx_data *tdata, const char *body_text);
1033
1034 /*!
1035  * \brief Copy a pj_str_t into a standard character buffer.
1036  *
1037  * pj_str_t is not NULL-terminated. Any place that expects a NULL-
1038  * terminated string needs to have the pj_str_t copied into a separate
1039  * buffer.
1040  *
1041  * This method copies the pj_str_t contents into the destination buffer
1042  * and NULL-terminates the buffer.
1043  *
1044  * \param dest The destination buffer
1045  * \param src The pj_str_t to copy
1046  * \param size The size of the destination buffer.
1047  */
1048 void ast_copy_pj_str(char *dest, pj_str_t *src, size_t size);
1049
1050 /*!
1051  * \brief Get the looked-up endpoint on an out-of dialog request or response
1052  *
1053  * The function may ONLY be called on out-of-dialog requests or responses. For
1054  * in-dialog requests and responses, it is required that the user of the dialog
1055  * has the looked-up endpoint stored locally.
1056  *
1057  * This function should never return NULL if the message is out-of-dialog. It will
1058  * always return NULL if the message is in-dialog.
1059  *
1060  * This function will increase the reference count of the returned endpoint by one.
1061  * Release your reference using the ao2_ref function when finished.
1062  *
1063  * \param rdata Out-of-dialog request or response
1064  * \return The looked up endpoint
1065  */
1066 struct ast_sip_endpoint *ast_pjsip_rdata_get_endpoint(pjsip_rx_data *rdata);
1067
1068 /*!
1069  * \brief Retrieve relevant SIP auth structures from sorcery
1070  *
1071  * \param auth_names The sorcery IDs of auths to retrieve
1072  * \param num_auths The number of auths to retrieve
1073  * \param[out] out The retrieved auths are stored here
1074  */
1075 int ast_sip_retrieve_auths(const char *auth_names[], size_t num_auths, struct ast_sip_auth **out);
1076
1077 /*!
1078  * \brief Clean up retrieved auth structures from memory
1079  *
1080  * Call this function once you have completed operating on auths
1081  * retrieved from \ref ast_sip_retrieve_auths
1082  *
1083  * \param auths An array of auth structures to clean up
1084  * \param num_auths The number of auths in the array
1085  */
1086 void ast_sip_cleanup_auths(struct ast_sip_auth *auths[], size_t num_auths);
1087
1088 #endif /* _RES_SIP_H */