← Back to branch summary

~ubuntu-branches/ubuntu/trusty/sflphone/trusty

« back to all changes in this revision

Viewing changes to daemon/libs/pjproject-2.0.1/pjsip/include/pjsip/sip_endpoint.h

  • Committer: Package Import Robot
  • Author(s): Mark Purcell
  • Date: 2014-01-28 18:23:36 UTC
  • mfrom: (4.3.4 sid)
  • Revision ID: package-import@ubuntu.com-20140128182336-jrsv0k9u6cawc068
Tags: 1.3.0-1
http://bugs.debian.org/735846
http://bugs.debian.org/727164
http://bugs.debian.org/718178
http://bugs.debian.org/736583
http://bugs.debian.org/722040
http://bugs.debian.org/736746
* New upstream release 
  - Fixes "New Upstream Release" (Closes: #735846)
  - Fixes "Ringtone does not stop" (Closes: #727164)
  - Fixes "[sflphone-kde] crash on startup" (Closes: #718178)
  - Fixes "sflphone GUI crashes when call is hung up" (Closes: #736583)
* Build-Depends: ensure GnuTLS 2.6
  - libucommon-dev (>= 6.0.7-1.1), libccrtp-dev (>= 2.0.6-3)
  - Fixes "FTBFS Build-Depends libgnutls{26,28}-dev" (Closes: #722040)
* Fix "boost 1.49 is going away" unversioned Build-Depends: (Closes: #736746)
* Add Build-Depends: libsndfile-dev, nepomuk-core-dev

Show diffs side-by-side

added added

removed removed

Lines of Context:
daemon/libs/pjproject-2.0.1/pjsip/include/pjsip/sip_endpoint.h
1
 
/* $Id: sip_endpoint.h 4154 2012-06-05 10:41:17Z bennylp $ */
2
 
/*
3
 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
4
 
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
5
 
 *
6
 
 * This program is free software; you can redistribute it and/or modify
7
 
 * it under the terms of the GNU General Public License as published by
8
 
 * the Free Software Foundation; either version 2 of the License, or
9
 
 * (at your option) any later version.
10
 
 *
11
 
 * This program is distributed in the hope that it will be useful,
12
 
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13
 
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14
 
 * GNU General Public License for more details.
15
 
 *
16
 
 * You should have received a copy of the GNU General Public License
17
 
 * along with this program; if not, write to the Free Software
18
 
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19
 
 */
20
 
#ifndef __PJSIP_SIP_ENDPOINT_H__
21
 
#define __PJSIP_SIP_ENDPOINT_H__
22
 
 
23
 
/**
24
 
 * @file sip_endpoint.h
25
 
 * @brief SIP Endpoint.
26
 
 */
27
 
 
28
 
#include <pjsip/sip_transport.h>
29
 
#include <pjsip/sip_resolve.h>
30
 
 
31
 
/**
32
 
 * @defgroup PJSIP_CORE_CORE At the Very Core
33
 
 * @ingroup PJSIP_CORE
34
 
 * @brief The very core of PJSIP.
35
 
 */
36
 
 
37
 
PJ_BEGIN_DECL
38
 
 
39
 
/**
40
 
 * @defgroup PJSIP_ENDPT Endpoint
41
 
 * @ingroup PJSIP_CORE_CORE
42
 
 * @brief The master, owner of all objects
43
 
 *
44
 
 * SIP Endpoint instance (pjsip_endpoint) can be viewed as the master/owner of
45
 
 * all SIP objects in an application. It performs the following roles:
46
 
 *  - it manages the allocation/deallocation of memory pools for all objects.
47
 
 *  - it manages listeners and transports, and how they are used by
48
 
 *    transactions.
49
 
 *  - it receives incoming messages from transport layer and automatically
50
 
 *    dispatches them to the correct transaction (or create a new one).
51
 
 *  - it has a single instance of timer management (timer heap).
52
 
 *  - it manages modules, which is the primary means of extending the library.
53
 
 *  - it provides single polling function for all objects and distributes
54
 
 *    events.
55
 
 *  - it automatically handles incoming requests which can not be handled by
56
 
 *    existing modules (such as when incoming request has unsupported method).
57
 
 *  - and so on..
58
 
 *
59
 
 * Application should only instantiate one SIP endpoint instance for every
60
 
 * process.
61
 
 *
62
 
 * @{
63
 
 */
64
 
 
65
 
 
66
 
/**
67
 
 * Type of callback to register to pjsip_endpt_atexit().
68
 
 */
69
 
typedef void (*pjsip_endpt_exit_callback)(pjsip_endpoint *endpt);
70
 
 
71
 
 
72
 
/**
73
 
 * Create an instance of SIP endpoint from the specified pool factory.
74
 
 * The pool factory reference then will be kept by the endpoint, so that
75
 
 * future memory allocations by SIP components will be taken from the same
76
 
 * pool factory.
77
 
 *
78
 
 * @param pf            Pool factory that will be used for the lifetime of
79
 
 *                      endpoint.
80
 
 * @param name          Optional name to be specified for the endpoint.
81
 
 *                      If this parameter is NULL, then the name will use
82
 
 *                      local host name.
83
 
 * @param endpt         Pointer to receive endpoint instance.
84
 
 *
85
 
 * @return              PJ_SUCCESS on success.
86
 
 */
87
 
PJ_DECL(pj_status_t) pjsip_endpt_create(pj_pool_factory *pf,
88
 
                                        const char *name,
89
 
                                        pjsip_endpoint **endpt);
90
 
 
91
 
/**
92
 
 * Destroy endpoint instance. Application must make sure that all pending
93
 
 * transactions have been terminated properly, because this function does not
94
 
 * check for the presence of pending transactions.
95
 
 *
96
 
 * @param endpt         The SIP endpoint to be destroyed.
97
 
 */
98
 
PJ_DECL(void) pjsip_endpt_destroy(pjsip_endpoint *endpt);
99
 
 
100
 
/**
101
 
 * Get endpoint name.
102
 
 *
103
 
 * @param endpt         The SIP endpoint instance.
104
 
 *
105
 
 * @return              Endpoint name, as was registered during endpoint
106
 
 *                      creation. The string is NULL terminated.
107
 
 */
108
 
PJ_DECL(const pj_str_t*) pjsip_endpt_name(const pjsip_endpoint *endpt);
109
 
 
110
 
/**
111
 
 * Poll for events. Application must call this function periodically to ensure
112
 
 * that all events from both transports and timer heap are handled in timely
113
 
 * manner.  This function, like all other endpoint functions, is thread safe,
114
 
 * and application may have more than one thread concurrently calling this function.
115
 
 *
116
 
 * @param endpt         The endpoint.
117
 
 * @param max_timeout   Maximum time to wait for events, or NULL to wait forever
118
 
 *                      until event is received.
119
 
 *
120
 
 * @return              PJ_SUCCESS on success.
121
 
 */
122
 
PJ_DECL(pj_status_t) pjsip_endpt_handle_events( pjsip_endpoint *endpt,
123
 
                                                const pj_time_val *max_timeout);
124
 
 
125
 
 
126
 
/**
127
 
 * Handle events with additional info about number of events that
128
 
 * have been handled.
129
 
 *
130
 
 * @param endpt         The endpoint.
131
 
 * @param max_timeout   Maximum time to wait for events, or NULL to wait forever
132
 
 *                      until event is received.
133
 
 * @param count         Optional argument to receive the number of events that
134
 
 *                      have been handled by the function.
135
 
 *
136
 
 * @return              PJ_SUCCESS on success.
137
 
 */
138
 
PJ_DECL(pj_status_t) pjsip_endpt_handle_events2(pjsip_endpoint *endpt,
139
 
                                                const pj_time_val *max_timeout,
140
 
                                                unsigned *count);
141
 
/**
142
 
 * Schedule timer to endpoint's timer heap. Application must poll the endpoint
143
 
 * periodically (by calling #pjsip_endpt_handle_events) to ensure that the
144
 
 * timer events are handled in timely manner. When the timeout for the timer
145
 
 * has elapsed, the callback specified in the entry argument will be called.
146
 
 * This function, like all other endpoint functions, is thread safe.
147
 
 *
148
 
 * @param endpt     The endpoint.
149
 
 * @param entry     The timer entry.
150
 
 * @param delay     The relative delay of the timer.
151
 
 * @return          PJ_OK (zero) if successfull.
152
 
 */
153
 
#if PJ_TIMER_DEBUG
154
 
#define pjsip_endpt_schedule_timer(ept,ent,d) \
155
 
                        pjsip_endpt_schedule_timer_dbg(ept, ent, d, \
156
 
                                                       __FILE__, __LINE__)
157
 
 
158
 
PJ_DECL(pj_status_t) pjsip_endpt_schedule_timer_dbg(pjsip_endpoint *endpt,
159
 
                                                    pj_timer_entry *entry,
160
 
                                                    const pj_time_val *delay,
161
 
                                                    const char *src_file,
162
 
                                                    int src_line);
163
 
#else
164
 
PJ_DECL(pj_status_t) pjsip_endpt_schedule_timer( pjsip_endpoint *endpt,
165
 
                                                 pj_timer_entry *entry,
166
 
                                                 const pj_time_val *delay );
167
 
#endif
168
 
 
169
 
/**
170
 
 * Cancel the previously registered timer.
171
 
 * This function, like all other endpoint functions, is thread safe.
172
 
 *
173
 
 * @param endpt     The endpoint.
174
 
 * @param entry     The timer entry previously registered.
175
 
 */
176
 
PJ_DECL(void) pjsip_endpt_cancel_timer( pjsip_endpoint *endpt,
177
 
                                        pj_timer_entry *entry );
178
 
 
179
 
/**
180
 
 * Get the timer heap instance of the SIP endpoint.
181
 
 *
182
 
 * @param endpt     The endpoint.
183
 
 *
184
 
 * @return          The timer heap instance.
185
 
 */
186
 
PJ_DECL(pj_timer_heap_t*) pjsip_endpt_get_timer_heap(pjsip_endpoint *endpt);
187
 
 
188
 
 
189
 
/**
190
 
 * Register new module to the endpoint.
191
 
 * The endpoint will then call the load and start function in the module to
192
 
 * properly initialize the module, and assign a unique module ID for the
193
 
 * module.
194
 
 *
195
 
 * @param endpt         The endpoint.
196
 
 * @param module        The module to be registered.
197
 
 *
198
 
 * @return              PJ_SUCCESS on success.
199
 
 */
200
 
PJ_DECL(pj_status_t) pjsip_endpt_register_module( pjsip_endpoint *endpt,
201
 
                                                  pjsip_module *module );
202
 
 
203
 
/**
204
 
 * Unregister a module from the endpoint.
205
 
 * The endpoint will then call the stop and unload function in the module to
206
 
 * properly shutdown the module.
207
 
 *
208
 
 * @param endpt         The endpoint.
209
 
 * @param module        The module to be registered.
210
 
 *
211
 
 * @return              PJ_SUCCESS on success.
212
 
 */
213
 
PJ_DECL(pj_status_t) pjsip_endpt_unregister_module( pjsip_endpoint *endpt,
214
 
                                                    pjsip_module *module );
215
 
 
216
 
 
217
 
/**
218
 
 * Create pool from the endpoint. All SIP components should allocate their
219
 
 * memory pool by calling this function, to make sure that the pools are
220
 
 * allocated from the same pool factory. This function, like all other endpoint
221
 
 * functions, is thread safe.
222
 
 *
223
 
 * @param endpt         The SIP endpoint.
224
 
 * @param pool_name     Name to be assigned to the pool.
225
 
 * @param initial       The initial size of the pool.
226
 
 * @param increment     The resize size.
227
 
 * @return              Memory pool, or NULL on failure.
228
 
 *
229
 
 * @see pj_pool_create
230
 
 */
231
 
PJ_DECL(pj_pool_t*) pjsip_endpt_create_pool( pjsip_endpoint *endpt,
232
 
                                             const char *pool_name,
233
 
                                             pj_size_t initial,
234
 
                                             pj_size_t increment );
235
 
 
236
 
/**
237
 
 * Return back pool to endpoint to be released back to the pool factory.
238
 
 * This function, like all other endpoint functions, is thread safe.
239
 
 *
240
 
 * @param endpt     The endpoint.
241
 
 * @param pool      The pool to be destroyed.
242
 
 */
243
 
PJ_DECL(void) pjsip_endpt_release_pool( pjsip_endpoint *endpt,
244
 
                                        pj_pool_t *pool );
245
 
 
246
 
/**
247
 
 * Find transaction in endpoint's transaction table by the transaction's key.
248
 
 * This function normally is only used by modules. The key for a transaction
249
 
 * can be created by calling #pjsip_tsx_create_key.
250
 
 *
251
 
 * @param endpt     The endpoint instance.
252
 
 * @param key       Transaction key, as created with #pjsip_tsx_create_key.
253
 
 *
254
 
 * @return          The transaction, or NULL if it's not found.
255
 
 */
256
 
PJ_DECL(pjsip_transaction*) pjsip_endpt_find_tsx( pjsip_endpoint *endpt,
257
 
                                                  const pj_str_t *key );
258
 
 
259
 
/**
260
 
 * Register the transaction to the endpoint's transaction table.
261
 
 * This function should only be used internally by the stack.
262
 
 *
263
 
 * @param endpt     The SIP endpoint.
264
 
 * @param tsx       The transaction.
265
 
 */
266
 
PJ_DECL(void) pjsip_endpt_register_tsx( pjsip_endpoint *endpt,
267
 
                                        pjsip_transaction *tsx);
268
 
 
269
 
/**
270
 
 * Forcefull destroy the transaction. This function should only be used
271
 
 * internally by the stack.
272
 
 *
273
 
 * @param endpt     The endpoint.
274
 
 * @param tsx       The transaction to destroy.
275
 
 */
276
 
PJ_DECL(void) pjsip_endpt_destroy_tsx( pjsip_endpoint *endpt,
277
 
                                      pjsip_transaction *tsx);
278
 
 
279
 
/**
280
 
 * Create a new transmit data buffer.
281
 
 * This function, like all other endpoint functions, is thread safe.
282
 
 *
283
 
 * @param endpt     The endpoint.
284
 
 * @param p_tdata    Pointer to receive transmit data buffer.
285
 
 *
286
 
 * @return          PJ_SUCCESS or the appropriate error code.
287
 
 */
288
 
PJ_DECL(pj_status_t) pjsip_endpt_create_tdata( pjsip_endpoint *endpt,
289
 
                                               pjsip_tx_data **p_tdata);
290
 
 
291
 
/**
292
 
 * Create the DNS resolver instance. Application creates the DNS
293
 
 * resolver instance, set the nameserver to be used by the DNS
294
 
 * resolver, then set the DNS resolver to be used by the endpoint
295
 
 * by calling #pjsip_endpt_set_resolver().
296
 
 *
297
 
 * @param endpt         The SIP endpoint instance.
298
 
 * @param p_resv        Pointer to receive the DNS resolver instance.
299
 
 *
300
 
 * @return              PJ_SUCCESS on success, or the appropriate error
301
 
 *                      code.
302
 
 */
303
 
PJ_DECL(pj_status_t) pjsip_endpt_create_resolver(pjsip_endpoint *endpt,
304
 
                                                 pj_dns_resolver **p_resv);
305
 
 
306
 
/**
307
 
 * Set DNS resolver to be used by the SIP resolver. Application can set
308
 
 * the resolver instance to NULL to disable DNS resolution (perhaps
309
 
 * temporarily). When DNS resolver is disabled, the endpoint will resolve
310
 
 * hostnames with the normal pj_gethostbyname() function.
311
 
 *
312
 
 * @param endpt         The SIP endpoint instance.
313
 
 * @param resv          The resolver instance to be used by the SIP
314
 
 *                      endpoint.
315
 
 *
316
 
 * @return              PJ_SUCCESS on success, or the appropriate error
317
 
 *                      code.
318
 
 */
319
 
PJ_DECL(pj_status_t) pjsip_endpt_set_resolver(pjsip_endpoint *endpt,
320
 
                                              pj_dns_resolver *resv);
321
 
 
322
 
/**
323
 
 * Get the DNS resolver being used by the SIP resolver.
324
 
 *
325
 
 * @param endpt         The SIP endpoint instance.
326
 
 *
327
 
 * @return              The DNS resolver instance currently being used
328
 
 *                      by the SIP endpoint.
329
 
 */
330
 
PJ_DECL(pj_dns_resolver*) pjsip_endpt_get_resolver(pjsip_endpoint *endpt);
331
 
 
332
 
/**
333
 
 * Asynchronously resolve a SIP target host or domain according to rule
334
 
 * specified in RFC 3263 (Locating SIP Servers). When the resolving operation
335
 
 * has completed, the callback will be called.
336
 
 *
337
 
 * @param endpt     The endpoint instance.
338
 
 * @param pool      The pool to allocate resolver job.
339
 
 * @param target    The target specification to be resolved.
340
 
 * @param token     A user defined token to be passed back to callback function.
341
 
 * @param cb        The callback function.
342
 
 */
343
 
PJ_DECL(void) pjsip_endpt_resolve( pjsip_endpoint *endpt,
344
 
                                   pj_pool_t *pool,
345
 
                                   pjsip_host_info *target,
346
 
                                   void *token,
347
 
                                   pjsip_resolver_callback *cb);
348
 
 
349
 
/**
350
 
 * Get transport manager instance.
351
 
 *
352
 
 * @param endpt     The endpoint.
353
 
 *
354
 
 * @return          Transport manager instance.
355
 
 */
356
 
PJ_DECL(pjsip_tpmgr*) pjsip_endpt_get_tpmgr(pjsip_endpoint *endpt);
357
 
 
358
 
/**
359
 
 * Get ioqueue instance.
360
 
 *
361
 
 * @param endpt     The endpoint.
362
 
 *
363
 
 * @return          The ioqueue.
364
 
 */
365
 
PJ_DECL(pj_ioqueue_t*) pjsip_endpt_get_ioqueue(pjsip_endpoint *endpt);
366
 
 
367
 
/**
368
 
 * Find a SIP transport suitable for sending SIP message to the specified
369
 
 * address. If transport selector ("sel") is set, then the function will
370
 
 * check if the transport selected is suitable to send requests to the
371
 
 * specified address.
372
 
 *
373
 
 * @see pjsip_tpmgr_acquire_transport
374
 
 *
375
 
 * @param endpt     The SIP endpoint instance.
376
 
 * @param type      The type of transport to be acquired.
377
 
 * @param remote    The remote address to send message to.
378
 
 * @param addr_len  Length of the remote address.
379
 
 * @param sel       Optional pointer to transport selector instance which is
380
 
 *                  used to find explicit transport, if required.
381
 
 * @param p_tp      Pointer to receive the transport instance, if one is found.
382
 
 *
383
 
 * @return          PJ_SUCCESS on success, or the appropriate error code.
384
 
 */
385
 
PJ_DECL(pj_status_t)
386
 
pjsip_endpt_acquire_transport( pjsip_endpoint *endpt,
387
 
                               pjsip_transport_type_e type,
388
 
                               const pj_sockaddr_t *remote,
389
 
                               int addr_len,
390
 
                               const pjsip_tpselector *sel,
391
 
                               pjsip_transport **p_tp);
392
 
 
393
 
 
394
 
/**
395
 
 * Find a SIP transport suitable for sending SIP message to the specified
396
 
 * address by also considering the outgoing SIP message data. If transport
397
 
 * selector ("sel") is set, then the function will check if the transport
398
 
 * selected is suitable to send requests to the specified address.
399
 
 *
400
 
 * @see pjsip_tpmgr_acquire_transport
401
 
 *
402
 
 * @param endpt     The SIP endpoint instance.
403
 
 * @param type      The type of transport to be acquired.
404
 
 * @param remote    The remote address to send message to.
405
 
 * @param addr_len  Length of the remote address.
406
 
 * @param sel       Optional pointer to transport selector instance which is
407
 
 *                  used to find explicit transport, if required.
408
 
 * @param tdata     Optional pointer to SIP message data to be sent.
409
 
 * @param p_tp      Pointer to receive the transport instance, if one is found.
410
 
 *
411
 
 * @return          PJ_SUCCESS on success, or the appropriate error code.
412
 
 */
413
 
PJ_DECL(pj_status_t)
414
 
pjsip_endpt_acquire_transport2(pjsip_endpoint *endpt,
415
 
                               pjsip_transport_type_e type,
416
 
                               const pj_sockaddr_t *remote,
417
 
                               int addr_len,
418
 
                               const pjsip_tpselector *sel,
419
 
                               pjsip_tx_data *tdata,
420
 
                               pjsip_transport **p_tp);
421
 
 
422
 
 
423
 
/*****************************************************************************
424
 
 *
425
 
 * Capabilities Management
426
 
 *
427
 
 * Modules may implement new capabilities to the stack. These capabilities
428
 
 * are indicated by the appropriate SIP header fields, such as Accept,
429
 
 * Accept-Encoding, Accept-Language, Allow, Supported, etc.
430
 
 *
431
 
 * When a module provides new capabilities to the stack, it registers these
432
 
 * capabilities to the endpoint by supplying new tags (strings) to the
433
 
 * appropriate header fields. Application (or other modules) can then query
434
 
 * these header fields to get the list of supported capabilities, and may
435
 
 * include these headers in the outgoing message.
436
 
 *****************************************************************************
437
 
 */
438
 
 
439
 
/**
440
 
 * Get the value of the specified capability header field.
441
 
 *
442
 
 * @param endpt     The endpoint.
443
 
 * @param htype     The header type to be retrieved, which value may be:
444
 
 *                  - PJSIP_H_ACCEPT
445
 
 *                  - PJSIP_H_ALLOW
446
 
 *                  - PJSIP_H_SUPPORTED
447
 
 * @param hname     If htype specifies PJSIP_H_OTHER, then the header name
448
 
 *                  must be supplied in this argument. Otherwise the value
449
 
 *                  must be set to NULL.
450
 
 *
451
 
 * @return          The appropriate header, or NULL if the header is not
452
 
 *                  available.
453
 
 */
454
 
PJ_DECL(const pjsip_hdr*) pjsip_endpt_get_capability( pjsip_endpoint *endpt,
455
 
                                                      int htype,
456
 
                                                      const pj_str_t *hname);
457
 
 
458
 
 
459
 
/**
460
 
 * Check if we have the specified capability.
461
 
 *
462
 
 * @param endpt     The endpoint.
463
 
 * @param htype     The header type to be retrieved, which value may be:
464
 
 *                  - PJSIP_H_ACCEPT
465
 
 *                  - PJSIP_H_ALLOW
466
 
 *                  - PJSIP_H_SUPPORTED
467
 
 * @param hname     If htype specifies PJSIP_H_OTHER, then the header name
468
 
 *                  must be supplied in this argument. Otherwise the value
469
 
 *                  must be set to NULL.
470
 
 * @param token     The capability token to check. For example, if \a htype
471
 
 *                  is PJSIP_H_ALLOW, then \a token specifies the method
472
 
 *                  names; if \a htype is PJSIP_H_SUPPORTED, then \a token
473
 
 *                  specifies the extension names such as "100rel".
474
 
 *
475
 
 * @return          PJ_TRUE if the specified capability is supported,
476
 
 *                  otherwise PJ_FALSE..
477
 
 */
478
 
PJ_DECL(pj_bool_t) pjsip_endpt_has_capability( pjsip_endpoint *endpt,
479
 
                                               int htype,
480
 
                                               const pj_str_t *hname,
481
 
                                               const pj_str_t *token);
482
 
 
483
 
 
484
 
/**
485
 
 * Add or register new capabilities as indicated by the tags to the
486
 
 * appropriate header fields in the endpoint.
487
 
 *
488
 
 * @param endpt     The endpoint.
489
 
 * @param mod       The module which registers the capability.
490
 
 * @param htype     The header type to be set, which value may be:
491
 
 *                  - PJSIP_H_ACCEPT
492
 
 *                  - PJSIP_H_ALLOW
493
 
 *                  - PJSIP_H_SUPPORTED
494
 
 * @param hname     If htype specifies PJSIP_H_OTHER, then the header name
495
 
 *                  must be supplied in this argument. Otherwise the value
496
 
 *                  must be set to NULL.
497
 
 * @param count     The number of tags in the array.
498
 
 * @param tags      Array of tags describing the capabilities or extensions
499
 
 *                  to be added to the appropriate header.
500
 
 *
501
 
 * @return          PJ_SUCCESS on success.
502
 
 */
503
 
PJ_DECL(pj_status_t) pjsip_endpt_add_capability( pjsip_endpoint *endpt,
504
 
                                                 pjsip_module *mod,
505
 
                                                 int htype,
506
 
                                                 const pj_str_t *hname,
507
 
                                                 unsigned count,
508
 
                                                 const pj_str_t tags[]);
509
 
 
510
 
/**
511
 
 * Get list of additional headers to be put in outgoing request message.
512
 
 * Currently only Max-Forwards are defined.
513
 
 *
514
 
 * @param e         The endpoint.
515
 
 *
516
 
 * @return          List of headers.
517
 
 */
518
 
PJ_DECL(const pjsip_hdr*) pjsip_endpt_get_request_headers(pjsip_endpoint *e);
519
 
 
520
 
 
521
 
/**
522
 
 * Dump endpoint status to the log. This will print the status to the log
523
 
 * with log level 3.
524
 
 *
525
 
 * @param endpt         The endpoint.
526
 
 * @param detail        If non zero, then it will dump a detailed output.
527
 
 *                      BEWARE that this option may crash the system because
528
 
 *                      it tries to access all memory pools.
529
 
 */
530
 
PJ_DECL(void) pjsip_endpt_dump( pjsip_endpoint *endpt, pj_bool_t detail );
531
 
 
532
 
 
533
 
/**
534
 
 * Register cleanup function to be called by SIP endpoint when
535
 
 * #pjsip_endpt_destroy() is called.  Note that application should not
536
 
 * use or access any endpoint resource (such as pool, ioqueue, timer heap)
537
 
 * from within the callback as such resource may have been released when
538
 
 * the callback function is invoked.
539
 
 *
540
 
 * @param endpt         The SIP endpoint.
541
 
 * @param func          The function to be registered.
542
 
 *
543
 
 * @return              PJ_SUCCESS on success.
544
 
 */
545
 
PJ_DECL(pj_status_t) pjsip_endpt_atexit(pjsip_endpoint *endpt,
546
 
                                        pjsip_endpt_exit_callback func);
547
 
 
548
 
 
549
 
/**
550
 
 * @}
551
 
 */
552
 
 
553
 
 
554
 
/**
555
 
 * Log an error.
556
 
 */
557
 
PJ_DECL(void) pjsip_endpt_log_error( pjsip_endpoint *endpt,
558
 
                                     const char *sender,
559
 
                                     pj_status_t error_code,
560
 
                                     const char *format,
561
 
                                     ... );
562
 
 
563
 
#define PJSIP_ENDPT_LOG_ERROR(expr)   \
564
 
            pjsip_endpt_log_error expr
565
 
 
566
 
#define PJSIP_ENDPT_TRACE(tracing,expr) \
567
 
            do {                        \
568
 
                if ((tracing))          \
569
 
                    PJ_LOG(4,expr);     \
570
 
            } while (0)
571
 
 
572
 
/*
573
 
 * Internal functions.
574
 
 */
575
 
/*
576
 
 * Receive transaction events from transactions and put in the event queue
577
 
 * to be processed later.
578
 
 */
579
 
void pjsip_endpt_send_tsx_event( pjsip_endpoint *endpt, pjsip_event *evt );
580
 
 
581
 
PJ_END_DECL
582
 
 
583
 
#endif  /* __PJSIP_SIP_ENDPOINT_H__ */