New SIP Channel driver: Always Auth Reject
[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         /*! Frequency to send OPTIONS requests to contact. 0 is disabled. */
143         unsigned int qualify_frequency;
144         /*! If true authenticate the qualify if needed */
145         int authenticate_qualify;
146 };
147
148 #define CONTACT_STATUS "contact_status"
149
150 /*!
151  * \brief Status type for a contact.
152  */
153 enum ast_sip_contact_status_type {
154         UNAVAILABLE,
155         AVAILABLE
156 };
157
158 /*!
159  * \brief A contact's status.
160  *
161  * \detail Maintains a contact's current status and round trip time
162  *         if available.
163  */
164 struct ast_sip_contact_status {
165         SORCERY_OBJECT(details);
166         /*! Current status for a contact (default - unavailable) */
167         enum ast_sip_contact_status_type status;
168         /*! The round trip start time set before sending a qualify request */
169         struct timeval rtt_start;
170         /*! The round trip time in microseconds */
171         int64_t rtt;
172 };
173
174 /*!
175  * \brief A transport to be used for messages to a contact
176  */
177 struct ast_sip_contact_transport {
178         AST_DECLARE_STRING_FIELDS(
179                 /*! Full URI of the contact */
180                 AST_STRING_FIELD(uri);
181         );
182         pjsip_transport *transport;
183 };
184
185 /*!
186  * \brief A SIP address of record
187  */
188 struct ast_sip_aor {
189         /*! Sorcery object details, the id is the AOR name */
190         SORCERY_OBJECT(details);
191         AST_DECLARE_STRING_FIELDS(
192                 /*! Voicemail boxes for this AOR */
193                 AST_STRING_FIELD(mailboxes);
194         );
195         /*! Minimum expiration time */
196         unsigned int minimum_expiration;
197         /*! Maximum expiration time */
198         unsigned int maximum_expiration;
199         /*! Default contact expiration if one is not provided in the contact */
200         unsigned int default_expiration;
201         /*! Frequency to send OPTIONS requests to AOR contacts. 0 is disabled. */
202         unsigned int qualify_frequency;
203         /*! If true authenticate the qualify if needed */
204         int authenticate_qualify;
205         /*! Maximum number of external contacts, 0 to disable */
206         unsigned int max_contacts;
207         /*! Whether to remove any existing contacts not related to an incoming REGISTER when it comes in */
208         unsigned int remove_existing;
209         /*! Any permanent configured contacts */
210         struct ao2_container *permanent_contacts;
211 };
212
213 /*!
214  * \brief DTMF modes for SIP endpoints
215  */
216 enum ast_sip_dtmf_mode {
217         /*! No DTMF to be used */
218         AST_SIP_DTMF_NONE,
219         /* XXX Should this be 2833 instead? */
220         /*! Use RFC 4733 events for DTMF */
221         AST_SIP_DTMF_RFC_4733,
222         /*! Use DTMF in the audio stream */
223         AST_SIP_DTMF_INBAND,
224         /*! Use SIP INFO DTMF (blech) */
225         AST_SIP_DTMF_INFO,
226 };
227
228 /*!
229  * \brief Methods of storing SIP digest authentication credentials.
230  *
231  * Note that both methods result in MD5 digest authentication being
232  * used. The two methods simply alter how Asterisk determines the
233  * credentials for a SIP authentication
234  */
235 enum ast_sip_auth_type {
236         /*! Credentials stored as a username and password combination */
237         AST_SIP_AUTH_TYPE_USER_PASS,
238         /*! Credentials stored as an MD5 sum */
239         AST_SIP_AUTH_TYPE_MD5,
240         /*! Credentials not stored this is a fake auth */
241         AST_SIP_AUTH_TYPE_ARTIFICIAL
242 };
243
244 #define SIP_SORCERY_AUTH_TYPE "auth"
245
246 struct ast_sip_auth {
247         /* Sorcery ID of the auth is its name */
248         SORCERY_OBJECT(details);
249         AST_DECLARE_STRING_FIELDS(
250                 /* Identification for these credentials */
251                 AST_STRING_FIELD(realm);
252                 /* Authentication username */
253                 AST_STRING_FIELD(auth_user);
254                 /* Authentication password */
255                 AST_STRING_FIELD(auth_pass);
256                 /* Authentication credentials in MD5 format (hash of user:realm:pass) */
257                 AST_STRING_FIELD(md5_creds);
258         );
259         /* The time period (in seconds) that a nonce may be reused */
260         unsigned int nonce_lifetime;
261         /* Used to determine what to use when authenticating */
262         enum ast_sip_auth_type type;
263 };
264
265 /*!
266  * \brief Different methods by which incoming requests can be matched to endpoints
267  */
268 enum ast_sip_endpoint_identifier_type {
269         /*! Identify based on user name in From header */
270         AST_SIP_ENDPOINT_IDENTIFY_BY_USERNAME = (1 << 0),
271         /*! Identify based on source location of the SIP message */
272         AST_SIP_ENDPOINT_IDENTIFY_BY_LOCATION = (1 << 1),
273 };
274
275 enum ast_sip_session_refresh_method {
276         /*! Use reinvite to negotiate direct media */
277         AST_SIP_SESSION_REFRESH_METHOD_INVITE,
278         /*! Use UPDATE to negotiate direct media */
279         AST_SIP_SESSION_REFRESH_METHOD_UPDATE,
280 };
281
282 enum ast_sip_direct_media_glare_mitigation {
283         /*! Take no special action to mitigate reinvite glare */
284         AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_NONE,
285         /*! Do not send an initial direct media session refresh on outgoing call legs
286          * Subsequent session refreshes will be sent no matter the session direction
287          */
288         AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_OUTGOING,
289         /*! Do not send an initial direct media session refresh on incoming call legs
290          * Subsequent session refreshes will be sent no matter the session direction
291          */
292         AST_SIP_DIRECT_MEDIA_GLARE_MITIGATION_INCOMING,
293 };
294
295 enum ast_sip_session_media_encryption {
296         /*! Invalid media encryption configuration */
297         AST_SIP_MEDIA_TRANSPORT_INVALID = 0,
298         /*! Do not allow any encryption of session media */
299         AST_SIP_MEDIA_ENCRYPT_NONE,
300         /*! Offer SDES-encrypted session media */
301         AST_SIP_MEDIA_ENCRYPT_SDES,
302         /*! Offer encrypted session media with datagram TLS key exchange */
303         AST_SIP_MEDIA_ENCRYPT_DTLS,
304 };
305
306 /*!
307  * \brief An entity with which Asterisk communicates
308  */
309 struct ast_sip_endpoint {
310         SORCERY_OBJECT(details);
311         AST_DECLARE_STRING_FIELDS(
312                 /*! Context to send incoming calls to */
313                 AST_STRING_FIELD(context);
314                 /*! Name of an explicit transport to use */
315                 AST_STRING_FIELD(transport);
316                 /*! Outbound proxy to use */
317                 AST_STRING_FIELD(outbound_proxy);
318                 /*! Explicit AORs to dial if none are specified */
319                 AST_STRING_FIELD(aors);
320                 /*! Musiconhold class to suggest that the other side use when placing on hold */
321                 AST_STRING_FIELD(mohsuggest);
322                 /*! Optional external media address to use in SDP */
323                 AST_STRING_FIELD(external_media_address);
324                 /*! Configured voicemail boxes for this endpoint. Used for MWI */
325                 AST_STRING_FIELD(mailboxes);
326         );
327         /*! Identification information for this endpoint */
328         struct ast_party_id id;
329         /*! Domain to which this endpoint belongs */
330         struct ast_sip_domain *domain;
331         /*! Address of record for incoming registrations */
332         struct ast_sip_aor *aor;
333         /*! Codec preferences */
334         struct ast_codec_pref prefs;
335         /*! Configured codecs */
336         struct ast_format_cap *codecs;
337         /*! Names of inbound authentication credentials */
338         const char **sip_inbound_auths;
339         /*! Number of configured auths */
340         size_t num_inbound_auths;
341         /*! Names of outbound authentication credentials */
342         const char **sip_outbound_auths;
343         /*! Number of configured outbound auths */
344         size_t num_outbound_auths;
345         /*! DTMF mode to use with this endpoint */
346         enum ast_sip_dtmf_mode dtmf;
347         /*! Whether IPv6 RTP is enabled or not */
348         unsigned int rtp_ipv6;
349         /*! Whether symmetric RTP is enabled or not */
350         unsigned int rtp_symmetric;
351         /*! Whether ICE support is enabled or not */
352         unsigned int ice_support;
353         /*! Whether to use the "ptime" attribute received from the endpoint or not */
354         unsigned int use_ptime;
355         /*! Whether to force using the source IP address/port for sending responses */
356         unsigned int force_rport;
357         /*! Whether to rewrite the Contact header with the source IP address/port or not */
358         unsigned int rewrite_contact;
359         /*! Enabled SIP extensions */
360         unsigned int extensions;
361         /*! Minimum session expiration period, in seconds */
362         unsigned int min_se;
363         /*! Session expiration period, in seconds */
364         unsigned int sess_expires;
365         /*! List of outbound registrations */
366         AST_LIST_HEAD_NOLOCK(, ast_sip_registration) registrations;
367         /*! Method(s) by which the endpoint should be identified. */
368         enum ast_sip_endpoint_identifier_type ident_method;
369         /*! Boolean indicating if direct_media is permissible */
370         unsigned int direct_media;
371         /*! When using direct media, which method should be used */
372         enum ast_sip_session_refresh_method direct_media_method;
373         /*! When performing connected line update, which method should be used */
374         enum ast_sip_session_refresh_method connected_line_method;
375         /*! Take steps to mitigate glare for direct media */
376         enum ast_sip_direct_media_glare_mitigation direct_media_glare_mitigation;
377         /*! Do not attempt direct media session refreshes if a media NAT is detected */
378         unsigned int disable_direct_media_on_nat;
379         /*! Do we trust the endpoint with our outbound identity? */
380         unsigned int trust_id_outbound;
381         /*! Do we trust identity information that originates externally (e.g. P-Asserted-Identity header)? */
382         unsigned int trust_id_inbound;
383         /*! Do we send P-Asserted-Identity headers to this endpoint? */
384         unsigned int send_pai;
385         /*! Do we send Remote-Party-ID headers to this endpoint? */
386         unsigned int send_rpid;
387         /*! Do we add Diversion headers to applicable outgoing requests/responses? */
388         unsigned int send_diversion;
389         /*! Should unsolicited MWI be aggregated into a single NOTIFY? */
390         unsigned int aggregate_mwi;
391         /*! Do we use media encryption? what type? */
392         enum ast_sip_session_media_encryption media_encryption;
393         /*! Do we use AVPF exclusively for this endpoint? */
394         unsigned int use_avpf;
395         /*! Is one-touch recording permitted? */
396         unsigned int one_touch_recording;
397         /*! Boolean indicating if ringing should be sent as inband progress */
398         unsigned int inband_progress;
399         /*! Call group */
400         ast_group_t callgroup;
401         /*! Pickup group */
402         ast_group_t pickupgroup;
403         /*! Named call group */
404         struct ast_namedgroups *named_callgroups;
405         /*! Named pickup group */
406         struct ast_namedgroups *named_pickupgroups;
407         /*! Pointer to the persistent Asterisk endpoint */
408         struct ast_endpoint *persistent;
409         /*! The number of channels at which busy device state is returned */
410         unsigned int devicestate_busy_at;
411 };
412
413 /*!
414  * \brief Possible returns from ast_sip_check_authentication
415  */
416 enum ast_sip_check_auth_result {
417     /*! Authentication needs to be challenged */
418     AST_SIP_AUTHENTICATION_CHALLENGE,
419     /*! Authentication succeeded */
420     AST_SIP_AUTHENTICATION_SUCCESS,
421     /*! Authentication failed */
422     AST_SIP_AUTHENTICATION_FAILED,
423     /*! Authentication encountered some internal error */
424     AST_SIP_AUTHENTICATION_ERROR,
425 };
426
427 /*!
428  * \brief An interchangeable way of handling digest authentication for SIP.
429  *
430  * An authenticator is responsible for filling in the callbacks provided below. Each is called from a publicly available
431  * function in res_sip. The authenticator can use configuration or other local policy to determine whether authentication
432  * should take place and what credentials should be used when challenging and authenticating a request.
433  */
434 struct ast_sip_authenticator {
435     /*!
436      * \brief Check if a request requires authentication
437      * See ast_sip_requires_authentication for more details
438      */
439     int (*requires_authentication)(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata);
440         /*!
441          * \brief Check that an incoming request passes authentication.
442          *
443          * The tdata parameter is useful for adding information such as digest challenges.
444          *
445          * \param endpoint The endpoint sending the incoming request
446          * \param rdata The incoming request
447          * \param tdata Tentative outgoing request.
448          */
449         enum ast_sip_check_auth_result (*check_authentication)(struct ast_sip_endpoint *endpoint,
450                         pjsip_rx_data *rdata, pjsip_tx_data *tdata);
451 };
452
453 /*!
454  * \brief an interchangeable way of responding to authentication challenges
455  *
456  * An outbound authenticator takes incoming challenges and formulates a new SIP request with
457  * credentials.
458  */
459 struct ast_sip_outbound_authenticator {
460         /*!
461          * \brief Create a new request with authentication credentials
462          *
463          * \param auths An array of IDs of auth sorcery objects
464          * \param num_auths The number of IDs in the array
465          * \param challenge The SIP response with authentication challenge(s)
466          * \param tsx The transaction in which the challenge was received
467          * \param new_request The new SIP request with challenge response(s)
468          * \retval 0 Successfully created new request
469          * \retval -1 Failed to create a new request
470          */
471         int (*create_request_with_auth)(const char **auths, size_t num_auths, struct pjsip_rx_data *challenge,
472                         struct pjsip_transaction *tsx, struct pjsip_tx_data **new_request);
473 };
474
475 /*!
476  * \brief An entity responsible for identifying the source of a SIP message
477  */
478 struct ast_sip_endpoint_identifier {
479     /*!
480      * \brief Callback used to identify the source of a message.
481      * See ast_sip_identify_endpoint for more details
482      */
483     struct ast_sip_endpoint *(*identify_endpoint)(pjsip_rx_data *rdata);
484 };
485
486 #define SIP_SORCERY_SECURITY_TYPE "security"
487
488 /*!
489  * \brief SIP security details and configuration.
490  */
491 struct ast_sip_security {
492         SORCERY_OBJECT(details);
493         struct ast_acl_list *acl;
494         struct ast_acl_list *contact_acl;
495 };
496
497 /*!
498  * \brief Register a SIP service in Asterisk.
499  *
500  * This is more-or-less a wrapper around pjsip_endpt_register_module().
501  * Registering a service makes it so that PJSIP will call into the
502  * service at appropriate times. For more information about PJSIP module
503  * callbacks, see the PJSIP documentation. Asterisk modules that call
504  * this function will likely do so at module load time.
505  *
506  * \param module The module that is to be registered with PJSIP
507  * \retval 0 Success
508  * \retval -1 Failure
509  */
510 int ast_sip_register_service(pjsip_module *module);
511
512 /*!
513  * This is the opposite of ast_sip_register_service().  Unregistering a
514  * service means that PJSIP will no longer call into the module any more.
515  * This will likely occur when an Asterisk module is unloaded.
516  *
517  * \param module The PJSIP module to unregister
518  */
519 void ast_sip_unregister_service(pjsip_module *module);
520
521 /*!
522  * \brief Register a SIP authenticator
523  *
524  * An authenticator has three main purposes:
525  * 1) Determining if authentication should be performed on an incoming request
526  * 2) Gathering credentials necessary for issuing an authentication challenge
527  * 3) Authenticating a request that has credentials
528  *
529  * Asterisk provides a default authenticator, but it may be replaced by a
530  * custom one if desired.
531  *
532  * \param auth The authenticator to register
533  * \retval 0 Success
534  * \retval -1 Failure
535  */
536 int ast_sip_register_authenticator(struct ast_sip_authenticator *auth);
537
538 /*!
539  * \brief Unregister a SIP authenticator
540  *
541  * When there is no authenticator registered, requests cannot be challenged
542  * or authenticated.
543  *
544  * \param auth The authenticator to unregister
545  */
546 void ast_sip_unregister_authenticator(struct ast_sip_authenticator *auth);
547
548  /*!
549  * \brief Register an outbound SIP authenticator
550  *
551  * An outbound authenticator is responsible for creating responses to
552  * authentication challenges by remote endpoints.
553  *
554  * \param auth The authenticator to register
555  * \retval 0 Success
556  * \retval -1 Failure
557  */
558 int ast_sip_register_outbound_authenticator(struct ast_sip_outbound_authenticator *outbound_auth);
559
560 /*!
561  * \brief Unregister an outbound SIP authenticator
562  *
563  * When there is no outbound authenticator registered, authentication challenges
564  * will be handled as any other final response would be.
565  *
566  * \param auth The authenticator to unregister
567  */
568 void ast_sip_unregister_outbound_authenticator(struct ast_sip_outbound_authenticator *auth);
569
570 /*!
571  * \brief Register a SIP endpoint identifier
572  *
573  * An endpoint identifier's purpose is to determine which endpoint a given SIP
574  * message has come from.
575  *
576  * Multiple endpoint identifiers may be registered so that if an endpoint
577  * cannot be identified by one identifier, it may be identified by another.
578  *
579  * Asterisk provides two endpoint identifiers. One identifies endpoints based
580  * on the user part of the From header URI. The other identifies endpoints based
581  * on the source IP address.
582  *
583  * If the order in which endpoint identifiers is run is important to you, then
584  * be sure to load individual endpoint identifier modules in the order you wish
585  * for them to be run in modules.conf
586  *
587  * \param identifier The SIP endpoint identifier to register
588  * \retval 0 Success
589  * \retval -1 Failure
590  */
591 int ast_sip_register_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier);
592
593 /*!
594  * \brief Unregister a SIP endpoint identifier
595  *
596  * This stops an endpoint identifier from being used.
597  *
598  * \param identifier The SIP endoint identifier to unregister
599  */
600 void ast_sip_unregister_endpoint_identifier(struct ast_sip_endpoint_identifier *identifier);
601
602 /*!
603  * \brief Allocate a new SIP endpoint
604  *
605  * This will return an endpoint with its refcount increased by one. This reference
606  * can be released using ao2_ref().
607  *
608  * \param name The name of the endpoint.
609  * \retval NULL Endpoint allocation failed
610  * \retval non-NULL The newly allocated endpoint
611  */
612 void *ast_sip_endpoint_alloc(const char *name);
613
614 /*!
615  * \brief Get a pointer to the PJSIP endpoint.
616  *
617  * This is useful when modules have specific information they need
618  * to register with the PJSIP core.
619  * \retval NULL endpoint has not been created yet.
620  * \retval non-NULL PJSIP endpoint.
621  */
622 pjsip_endpoint *ast_sip_get_pjsip_endpoint(void);
623
624 /*!
625  * \brief Get a pointer to the SIP sorcery structure.
626  *
627  * \retval NULL sorcery has not been initialized
628  * \retval non-NULL sorcery structure
629  */
630 struct ast_sorcery *ast_sip_get_sorcery(void);
631
632 /*!
633  * \brief Initialize transport support on a sorcery instance
634  *
635  * \param sorcery The sorcery instance
636  *
637  * \retval -1 failure
638  * \retval 0 success
639  */
640 int ast_sip_initialize_sorcery_transport(struct ast_sorcery *sorcery);
641
642 /*!
643  * \brief Initialize qualify support on a sorcery instance
644  *
645  * \param sorcery The sorcery instance
646  *
647  * \retval -1 failure
648  * \retval 0 success
649  */
650 int ast_sip_initialize_sorcery_qualify(struct ast_sorcery *sorcery);
651
652 /*!
653  * \brief Initialize location support on a sorcery instance
654  *
655  * \param sorcery The sorcery instance
656  *
657  * \retval -1 failure
658  * \retval 0 success
659  */
660 int ast_sip_initialize_sorcery_location(struct ast_sorcery *sorcery);
661
662 /*!
663  * \brief Retrieve a named AOR
664  *
665  * \param aor_name Name of the AOR
666  *
667  * \retval NULL if not found
668  * \retval non-NULL if found
669  */
670 struct ast_sip_aor *ast_sip_location_retrieve_aor(const char *aor_name);
671
672 /*!
673  * \brief Retrieve the first bound contact for an AOR
674  *
675  * \param aor Pointer to the AOR
676  * \retval NULL if no contacts available
677  * \retval non-NULL if contacts available
678  */
679 struct ast_sip_contact *ast_sip_location_retrieve_first_aor_contact(const struct ast_sip_aor *aor);
680
681 /*!
682  * \brief Retrieve all contacts currently available for an AOR
683  *
684  * \param aor Pointer to the AOR
685  *
686  * \retval NULL if no contacts available
687  * \retval non-NULL if contacts available
688  */
689 struct ao2_container *ast_sip_location_retrieve_aor_contacts(const struct ast_sip_aor *aor);
690
691 /*!
692  * \brief Retrieve the first bound contact from a list of AORs
693  *
694  * \param aor_list A comma-separated list of AOR names
695  * \retval NULL if no contacts available
696  * \retval non-NULL if contacts available
697  */
698 struct ast_sip_contact *ast_sip_location_retrieve_contact_from_aor_list(const char *aor_list);
699
700 /*!
701  * \brief Retrieve a named contact
702  *
703  * \param contact_name Name of the contact
704  *
705  * \retval NULL if not found
706  * \retval non-NULL if found
707  */
708 struct ast_sip_contact *ast_sip_location_retrieve_contact(const char *contact_name);
709
710 /*!
711  * \brief Add a transport for a contact to use
712  */
713
714 void ast_sip_location_add_contact_transport(struct ast_sip_contact_transport *ct);
715
716 /*!
717  * \brief Delete a transport for a contact that went away
718  */
719 void ast_sip_location_delete_contact_transport(struct ast_sip_contact_transport *ct);
720
721 /*!
722  * \brief Retrieve a contact_transport, by URI
723  *
724  * \param contact_uri URI of the contact
725  *
726  * \retval NULL if not found
727  * \retval non-NULL if found
728  */
729 struct ast_sip_contact_transport *ast_sip_location_retrieve_contact_transport_by_uri(const char *contact_uri);
730
731 /*!
732  * \brief Retrieve a contact_transport, by transport
733  *
734  * \param transport transport the contact uses
735  *
736  * \retval NULL if not found
737  * \retval non-NULL if found
738  */
739 struct ast_sip_contact_transport *ast_sip_location_retrieve_contact_transport_by_transport(pjsip_transport *transport);
740
741 /*!
742  * \brief Add a new contact to an AOR
743  *
744  * \param aor Pointer to the AOR
745  * \param uri Full contact URI
746  * \param expiration_time Optional expiration time of the contact
747  *
748  * \retval -1 failure
749  * \retval 0 success
750  */
751 int ast_sip_location_add_contact(struct ast_sip_aor *aor, const char *uri, struct timeval expiration_time);
752
753 /*!
754  * \brief Update a contact
755  *
756  * \param contact New contact object with details
757  *
758  * \retval -1 failure
759  * \retval 0 success
760  */
761 int ast_sip_location_update_contact(struct ast_sip_contact *contact);
762
763 /*!
764 * \brief Delete a contact
765 *
766 * \param contact Contact object to delete
767 *
768 * \retval -1 failure
769 * \retval 0 success
770 */
771 int ast_sip_location_delete_contact(struct ast_sip_contact *contact);
772
773 /*!
774  * \brief Initialize domain aliases support on a sorcery instance
775  *
776  * \param sorcery The sorcery instance
777  *
778  * \retval -1 failure
779  * \retval 0 success
780  */
781 int ast_sip_initialize_sorcery_domain_alias(struct ast_sorcery *sorcery);
782
783 /*!
784  * \brief Initialize authentication support on a sorcery instance
785  *
786  * \param sorcery The sorcery instance
787  *
788  * \retval -1 failure
789  * \retval 0 success
790  */
791 int ast_sip_initialize_sorcery_auth(struct ast_sorcery *sorcery);
792
793 /*!
794  * \brief Initialize security support on a sorcery instance
795  *
796  * \param sorcery The sorcery instance
797  *
798  * \retval -1 failure
799  * \retval 0 success
800  */
801 int ast_sip_initialize_sorcery_security(struct ast_sorcery *sorcery);
802
803 /*!
804  * \brief Callback called when an outbound request with authentication credentials is to be sent in dialog
805  *
806  * This callback will have the created request on it. The callback's purpose is to do any extra
807  * housekeeping that needs to be done as well as to send the request out.
808  *
809  * This callback is only necessary if working with a PJSIP API that sits between the application
810  * and the dialog layer.
811  *
812  * \param dlg The dialog to which the request belongs
813  * \param tdata The created request to be sent out
814  * \param user_data Data supplied with the callback
815  *
816  * \retval 0 Success
817  * \retval -1 Failure
818  */
819 typedef int (*ast_sip_dialog_outbound_auth_cb)(pjsip_dialog *dlg, pjsip_tx_data *tdata, void *user_data);
820
821 /*!
822  * \brief Set up outbound authentication on a SIP dialog
823  *
824  * This sets up the infrastructure so that all requests associated with a created dialog
825  * can be re-sent with authentication credentials if the original request is challenged.
826  *
827  * \param dlg The dialog on which requests will be authenticated
828  * \param endpoint The endpoint whom this dialog pertains to
829  * \param cb Callback to call to send requests with authentication
830  * \param user_data Data to be provided to the callback when it is called
831  *
832  * \retval 0 Success
833  * \retval -1 Failure
834  */
835 int ast_sip_dialog_setup_outbound_authentication(pjsip_dialog *dlg, const struct ast_sip_endpoint *endpoint,
836                 ast_sip_dialog_outbound_auth_cb cb, void *user_data);
837
838 /*!
839  * \brief Initialize the distributor module
840  *
841  * The distributor module is responsible for taking an incoming
842  * SIP message and placing it into the threadpool. Once in the threadpool,
843  * the distributor will perform endpoint lookups and authentication, and
844  * then distribute the message up the stack to any further modules.
845  *
846  * \retval -1 Failure
847  * \retval 0 Success
848  */
849 int ast_sip_initialize_distributor(void);
850
851 /*!
852  * \brief Destruct the distributor module.
853  *
854  * Unregisters pjsip modules and cleans up any allocated resources.
855  */
856 void ast_sip_destroy_distributor(void);
857
858 /*!
859  * \brief Retrieves a reference to the artificial auth.
860  *
861  * \retval The artificial auth
862  */
863 struct ast_sip_auth *ast_sip_get_artificial_auth(void);
864
865 /*!
866  * \brief Retrieves a reference to the artificial endpoint.
867  *
868  * \retval The artificial endpoint
869  */
870 struct ast_sip_endpoint *ast_sip_get_artificial_endpoint(void);
871
872 /*!
873  * \page Threading model for SIP
874  *
875  * There are three major types of threads that SIP will have to deal with:
876  * \li Asterisk threads
877  * \li PJSIP threads
878  * \li SIP threadpool threads (a.k.a. "servants")
879  *
880  * \par Asterisk Threads
881  *
882  * Asterisk threads are those that originate from outside of SIP but within
883  * Asterisk. The most common of these threads are PBX (channel) threads and
884  * the autoservice thread. Most interaction with these threads will be through
885  * channel technology callbacks. Within these threads, it is fine to handle
886  * Asterisk data from outside of SIP, but any handling of SIP data should be
887  * left to servants, \b especially if you wish to call into PJSIP for anything.
888  * Asterisk threads are not registered with PJLIB, so attempting to call into
889  * PJSIP will cause an assertion to be triggered, thus causing the program to
890  * crash.
891  *
892  * \par PJSIP Threads
893  *
894  * PJSIP threads are those that originate from handling of PJSIP events, such
895  * as an incoming SIP request or response, or a transaction timeout. The role
896  * of these threads is to process information as quickly as possible so that
897  * the next item on the SIP socket(s) can be serviced. On incoming messages,
898  * Asterisk automatically will push the request to a servant thread. When your
899  * module callback is called, processing will already be in a servant. However,
900  * for other PSJIP events, such as transaction state changes due to timer
901  * expirations, your module will be called into from a PJSIP thread. If you
902  * are called into from a PJSIP thread, then you should push whatever processing
903  * is needed to a servant as soon as possible. You can discern if you are currently
904  * in a SIP servant thread using the \ref ast_sip_thread_is_servant function.
905  *
906  * \par Servants
907  *
908  * Servants are where the bulk of SIP work should be performed. These threads
909  * exist in order to do the work that Asterisk threads and PJSIP threads hand
910  * off to them. Servant threads register themselves with PJLIB, meaning that
911  * they are capable of calling PJSIP and PJLIB functions if they wish.
912  *
913  * \par Serializer
914  *
915  * Tasks are handed off to servant threads using the API call \ref ast_sip_push_task.
916  * The first parameter of this call is a serializer. If this pointer
917  * is NULL, then the work will be handed off to whatever servant can currently handle
918  * the task. If this pointer is non-NULL, then the task will not be executed until
919  * previous tasks pushed with the same serializer have completed. For more information
920  * on serializers and the benefits they provide, see \ref ast_threadpool_serializer
921  *
922  * \note
923  *
924  * Do not make assumptions about individual threads based on a corresponding serializer.
925  * In other words, just because several tasks use the same serializer when being pushed
926  * to servants, it does not mean that the same thread is necessarily going to execute those
927  * tasks, even though they are all guaranteed to be executed in sequence.
928  */
929
930 /*!
931  * \brief Create a new serializer for SIP tasks
932  *
933  * See \ref ast_threadpool_serializer for more information on serializers.
934  * SIP creates serializers so that tasks operating on similar data will run
935  * in sequence.
936  *
937  * \retval NULL Failure
938  * \retval non-NULL Newly-created serializer
939  */
940 struct ast_taskprocessor *ast_sip_create_serializer(void);
941
942 /*!
943  * \brief Set a serializer on a SIP dialog so requests and responses are automatically serialized
944  *
945  * Passing a NULL serializer is a way to remove a serializer from a dialog.
946  *
947  * \param dlg The SIP dialog itself
948  * \param serializer The serializer to use
949  */
950 void ast_sip_dialog_set_serializer(pjsip_dialog *dlg, struct ast_taskprocessor *serializer);
951
952 /*!
953  * \brief Set an endpoint on a SIP dialog so in-dialog requests do not undergo endpoint lookup.
954  *
955  * \param dlg The SIP dialog itself
956  * \param endpoint The endpoint that this dialog is communicating with
957  */
958 void ast_sip_dialog_set_endpoint(pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint);
959
960 /*!
961  * \brief Get the endpoint associated with this dialog
962  *
963  * This function increases the refcount of the endpoint by one. Release
964  * the reference once you are finished with the endpoint.
965  *
966  * \param dlg The SIP dialog from which to retrieve the endpoint
967  * \retval NULL No endpoint associated with this dialog
968  * \retval non-NULL The endpoint.
969  */
970 struct ast_sip_endpoint *ast_sip_dialog_get_endpoint(pjsip_dialog *dlg);
971
972 /*!
973  * \brief Pushes a task to SIP servants
974  *
975  * This uses the serializer provided to determine how to push the task.
976  * If the serializer is NULL, then the task will be pushed to the
977  * servants directly. If the serializer is non-NULL, then the task will be
978  * queued behind other tasks associated with the same serializer.
979  *
980  * \param serializer The serializer to which the task belongs. Can be NULL
981  * \param sip_task The task to execute
982  * \param task_data The parameter to pass to the task when it executes
983  * \retval 0 Success
984  * \retval -1 Failure
985  */
986 int ast_sip_push_task(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data);
987
988 /*!
989  * \brief Push a task to SIP servants and wait for it to complete
990  *
991  * Like \ref ast_sip_push_task except that it blocks until the task completes.
992  *
993  * \warning \b Never use this function in a SIP servant thread. This can potentially
994  * cause a deadlock. If you are in a SIP servant thread, just call your function
995  * in-line.
996  *
997  * \param serializer The SIP serializer to which the task belongs. May be NULL.
998  * \param sip_task The task to execute
999  * \param task_data The parameter to pass to the task when it executes
1000  * \retval 0 Success
1001  * \retval -1 Failure
1002  */
1003 int ast_sip_push_task_synchronous(struct ast_taskprocessor *serializer, int (*sip_task)(void *), void *task_data);
1004
1005 /*!
1006  * \brief Determine if the current thread is a SIP servant thread
1007  *
1008  * \retval 0 This is not a SIP servant thread
1009  * \retval 1 This is a SIP servant thread
1010  */
1011 int ast_sip_thread_is_servant(void);
1012
1013 /*!
1014  * \brief SIP body description
1015  *
1016  * This contains a type and subtype that will be added as
1017  * the "Content-Type" for the message as well as the body
1018  * text.
1019  */
1020 struct ast_sip_body {
1021         /*! Type of the body, such as "application" */
1022         const char *type;
1023         /*! Subtype of the body, such as "sdp" */
1024         const char *subtype;
1025         /*! The text to go in the body */
1026         const char *body_text;
1027 };
1028
1029 /*!
1030  * \brief General purpose method for creating a dialog with an endpoint
1031  *
1032  * \param endpoint A pointer to the endpoint
1033  * \param aor_name Optional name of the AOR to target, may even be an explicit SIP URI
1034  * \param request_user Optional user to place into the target URI
1035  *
1036  * \retval non-NULL success
1037  * \retval NULL failure
1038  */
1039  pjsip_dialog *ast_sip_create_dialog(const struct ast_sip_endpoint *endpoint, const char *aor_name, const char *request_user);
1040
1041 /*!
1042  * \brief General purpose method for creating a SIP request
1043  *
1044  * Its typical use would be to create one-off requests such as an out of dialog
1045  * SIP MESSAGE.
1046  *
1047  * The request can either be in- or out-of-dialog. If in-dialog, the
1048  * dlg parameter MUST be present. If out-of-dialog the endpoint parameter
1049  * MUST be present. If both are present, then we will assume that the message
1050  * is to be sent in-dialog.
1051  *
1052  * The uri parameter can be specified if the request should be sent to an explicit
1053  * URI rather than one configured on the endpoint.
1054  *
1055  * \param method The method of the SIP request to send
1056  * \param dlg Optional. If specified, the dialog on which to request the message.
1057  * \param endpoint Optional. If specified, the request will be created out-of-dialog
1058  * to the endpoint.
1059  * \param uri Optional. If specified, the request will be sent to this URI rather
1060  * than one configured for the endpoint.
1061  * \param[out] tdata The newly-created request
1062  * \retval 0 Success
1063  * \retval -1 Failure
1064  */
1065 int ast_sip_create_request(const char *method, struct pjsip_dialog *dlg,
1066                 struct ast_sip_endpoint *endpoint, const char *uri, pjsip_tx_data **tdata);
1067
1068 /*!
1069  * \brief General purpose method for sending a SIP request
1070  *
1071  * This is a companion function for \ref ast_sip_create_request. The request
1072  * created there can be passed to this function, though any request may be
1073  * passed in.
1074  *
1075  * This will automatically set up handling outbound authentication challenges if
1076  * they arrive.
1077  *
1078  * \param tdata The request to send
1079  * \param dlg Optional. If specified, the dialog on which the request should be sent
1080  * \param endpoint Optional. If specified, the request is sent out-of-dialog to the endpoint.
1081  * \retval 0 Success
1082  * \retval -1 Failure
1083  */
1084 int ast_sip_send_request(pjsip_tx_data *tdata, struct pjsip_dialog *dlg, struct ast_sip_endpoint *endpoint);
1085
1086 /*!
1087  * \brief Determine if an incoming request requires authentication
1088  *
1089  * This calls into the registered authenticator's requires_authentication callback
1090  * in order to determine if the request requires authentication.
1091  *
1092  * If there is no registered authenticator, then authentication will be assumed
1093  * not to be required.
1094  *
1095  * \param endpoint The endpoint from which the request originates
1096  * \param rdata The incoming SIP request
1097  * \retval non-zero The request requires authentication
1098  * \retval 0 The request does not require authentication
1099  */
1100 int ast_sip_requires_authentication(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata);
1101
1102 /*!
1103  * \brief Method to determine authentication status of an incoming request
1104  *
1105  * This will call into a registered authenticator. The registered authenticator will
1106  * do what is necessary to determine whether the incoming request passes authentication.
1107  * A tentative response is passed into this function so that if, say, a digest authentication
1108  * challenge should be sent in the ensuing response, it can be added to the response.
1109  *
1110  * \param endpoint The endpoint from the request was sent
1111  * \param rdata The request to potentially authenticate
1112  * \param tdata Tentative response to the request
1113  * \return The result of checking authentication.
1114  */
1115 enum ast_sip_check_auth_result ast_sip_check_authentication(struct ast_sip_endpoint *endpoint,
1116                 pjsip_rx_data *rdata, pjsip_tx_data *tdata);
1117
1118 /*!
1119  * \brief Create a response to an authentication challenge
1120  *
1121  * This will call into an outbound authenticator's create_request_with_auth callback
1122  * to create a new request with authentication credentials. See the create_request_with_auth
1123  * callback in the \ref ast_sip_outbound_authenticator structure for details about
1124  * the parameters and return values.
1125  */
1126 int ast_sip_create_request_with_auth(const char **auths, size_t num_auths, pjsip_rx_data *challenge,
1127                 pjsip_transaction *tsx, pjsip_tx_data **new_request);
1128
1129 /*!
1130  * \brief Determine the endpoint that has sent a SIP message
1131  *
1132  * This will call into each of the registered endpoint identifiers'
1133  * identify_endpoint() callbacks until one returns a non-NULL endpoint.
1134  * This will return an ao2 object. Its reference count will need to be
1135  * decremented when completed using the endpoint.
1136  *
1137  * \param rdata The inbound SIP message to use when identifying the endpoint.
1138  * \retval NULL No matching endpoint
1139  * \retval non-NULL The matching endpoint
1140  */
1141 struct ast_sip_endpoint *ast_sip_identify_endpoint(pjsip_rx_data *rdata);
1142
1143 /*!
1144  * \brief Add a header to an outbound SIP message
1145  *
1146  * \param tdata The message to add the header to
1147  * \param name The header name
1148  * \param value The header value
1149  * \retval 0 Success
1150  * \retval -1 Failure
1151  */
1152 int ast_sip_add_header(pjsip_tx_data *tdata, const char *name, const char *value);
1153
1154 /*!
1155  * \brief Add a body to an outbound SIP message
1156  *
1157  * If this is called multiple times, the latest body will replace the current
1158  * body.
1159  *
1160  * \param tdata The message to add the body to
1161  * \param body The message body to add
1162  * \retval 0 Success
1163  * \retval -1 Failure
1164  */
1165 int ast_sip_add_body(pjsip_tx_data *tdata, const struct ast_sip_body *body);
1166
1167 /*!
1168  * \brief Add a multipart body to an outbound SIP message
1169  *
1170  * This will treat each part of the input array as part of a multipart body and
1171  * add each part to the SIP message.
1172  *
1173  * \param tdata The message to add the body to
1174  * \param bodies The parts of the body to add
1175  * \retval 0 Success
1176  * \retval -1 Failure
1177  */
1178 int ast_sip_add_body_multipart(pjsip_tx_data *tdata, const struct ast_sip_body *bodies[], int num_bodies);
1179
1180 /*!
1181  * \brief Append body data to a SIP message
1182  *
1183  * This acts mostly the same as ast_sip_add_body, except that rather than replacing
1184  * a body if it currently exists, it appends data to an existing body.
1185  *
1186  * \param tdata The message to append the body to
1187  * \param body The string to append to the end of the current body
1188  * \retval 0 Success
1189  * \retval -1 Failure
1190  */
1191 int ast_sip_append_body(pjsip_tx_data *tdata, const char *body_text);
1192
1193 /*!
1194  * \brief Copy a pj_str_t into a standard character buffer.
1195  *
1196  * pj_str_t is not NULL-terminated. Any place that expects a NULL-
1197  * terminated string needs to have the pj_str_t copied into a separate
1198  * buffer.
1199  *
1200  * This method copies the pj_str_t contents into the destination buffer
1201  * and NULL-terminates the buffer.
1202  *
1203  * \param dest The destination buffer
1204  * \param src The pj_str_t to copy
1205  * \param size The size of the destination buffer.
1206  */
1207 void ast_copy_pj_str(char *dest, const pj_str_t *src, size_t size);
1208
1209 /*!
1210  * \brief Get the looked-up endpoint on an out-of dialog request or response
1211  *
1212  * The function may ONLY be called on out-of-dialog requests or responses. For
1213  * in-dialog requests and responses, it is required that the user of the dialog
1214  * has the looked-up endpoint stored locally.
1215  *
1216  * This function should never return NULL if the message is out-of-dialog. It will
1217  * always return NULL if the message is in-dialog.
1218  *
1219  * This function will increase the reference count of the returned endpoint by one.
1220  * Release your reference using the ao2_ref function when finished.
1221  *
1222  * \param rdata Out-of-dialog request or response
1223  * \return The looked up endpoint
1224  */
1225 struct ast_sip_endpoint *ast_pjsip_rdata_get_endpoint(pjsip_rx_data *rdata);
1226
1227 /*!
1228  * \brief Retrieve any endpoints available to sorcery.
1229  *
1230  * \retval Endpoints available to sorcery, NULL if no endpoints found.
1231  */
1232 struct ao2_container *ast_sip_get_endpoints(void);
1233
1234 /*!
1235  * \brief Retrieve relevant SIP auth structures from sorcery
1236  *
1237  * \param auth_names The sorcery IDs of auths to retrieve
1238  * \param num_auths The number of auths to retrieve
1239  * \param[out] out The retrieved auths are stored here
1240  */
1241 int ast_sip_retrieve_auths(const char *auth_names[], size_t num_auths, struct ast_sip_auth **out);
1242
1243 /*!
1244  * \brief Clean up retrieved auth structures from memory
1245  *
1246  * Call this function once you have completed operating on auths
1247  * retrieved from \ref ast_sip_retrieve_auths
1248  *
1249  * \param auths An array of auth structures to clean up
1250  * \param num_auths The number of auths in the array
1251  */
1252 void ast_sip_cleanup_auths(struct ast_sip_auth *auths[], size_t num_auths);
1253
1254 /*!
1255  * \brief Checks if the given content type matches type/subtype.
1256  *
1257  * Compares the pjsip_media_type with the passed type and subtype and
1258  * returns the result of that comparison.  The media type parameters are
1259  * ignored.
1260  *
1261  * \param content_type The pjsip_media_type structure to compare
1262  * \param type The media type to compare
1263  * \param subtype The media subtype to compare
1264  * \retval 0 No match
1265  * \retval -1 Match
1266  */
1267 int ast_sip_is_content_type(pjsip_media_type *content_type, char *type, char *subtype);
1268
1269 /*!
1270  * \brief Send a security event notification for when an invalid endpoint is requested
1271  *
1272  * \param name Name of the endpoint requested
1273  * \param rdata Received message
1274  */
1275 void ast_sip_report_invalid_endpoint(const char *name, pjsip_rx_data *rdata);
1276
1277 /*!
1278  * \brief Send a security event notification for when an ACL check fails
1279  *
1280  * \param endpoint Pointer to the endpoint in use
1281  * \param rdata Received message
1282  * \param name Name of the ACL
1283  */
1284 void ast_sip_report_failed_acl(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, const char *name);
1285
1286 /*!
1287  * \brief Send a security event notification for when a challenge response has failed
1288  *
1289  * \param endpoint Pointer to the endpoint in use
1290  * \param rdata Received message
1291  */
1292 void ast_sip_report_auth_failed_challenge_response(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata);
1293
1294 /*!
1295  * \brief Send a security event notification for when authentication succeeds
1296  *
1297  * \param endpoint Pointer to the endpoint in use
1298  * \param rdata Received message
1299  */
1300 void ast_sip_report_auth_success(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata);
1301
1302 /*!
1303  * \brief Send a security event notification for when an authentication challenge is sent
1304  *
1305  * \param endpoint Pointer to the endpoint in use
1306  * \param rdata Received message
1307  * \param tdata Sent message
1308  */
1309 void ast_sip_report_auth_challenge_sent(struct ast_sip_endpoint *endpoint, pjsip_rx_data *rdata, pjsip_tx_data *tdata);
1310
1311 #endif /* _RES_SIP_H */