Remove IAX_OLD_FIND from chan_iax2.
[asterisk/asterisk.git] / channels / chan_iax2.c
1 /*
2  * Asterisk -- An open source telephony toolkit.
3  *
4  * Copyright (C) 1999 - 2006, Digium, Inc.
5  *
6  * Mark Spencer <markster@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 /*! \file
20  *
21  * \brief Implementation of Inter-Asterisk eXchange Version 2
22  *        as specified in RFC 5456
23  *
24  * \author Mark Spencer <markster@digium.com>
25  *
26  * \par See also
27  * \arg \ref Config_iax
28  *
29  * \ingroup channel_drivers
30  * 
31  * \todo Implement musicclass settings for IAX2 devices
32  */
33
34 /*** MODULEINFO
35         <use type="external">crypto</use>
36         <support_level>core</support_level>
37  ***/
38
39 #include "asterisk.h"
40
41 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
42
43 #include <sys/mman.h>
44 #include <dirent.h>
45 #include <sys/socket.h>
46 #include <netinet/in.h>
47 #include <arpa/inet.h>
48 #include <netinet/in_systm.h>
49 #include <netinet/ip.h>
50 #include <sys/time.h>
51 #include <sys/signal.h>
52 #include <signal.h>
53 #include <strings.h>
54 #include <netdb.h>
55 #include <fcntl.h>
56 #include <sys/stat.h>
57 #include <regex.h>
58
59 #include "asterisk/paths.h"     /* need ast_config_AST_DATA_DIR for firmware */
60
61 #include "asterisk/lock.h"
62 #include "asterisk/frame.h" 
63 #include "asterisk/channel.h"
64 #include "asterisk/module.h"
65 #include "asterisk/pbx.h"
66 #include "asterisk/sched.h"
67 #include "asterisk/io.h"
68 #include "asterisk/config.h"
69 #include "asterisk/cli.h"
70 #include "asterisk/translate.h"
71 #include "asterisk/md5.h"
72 #include "asterisk/cdr.h"
73 #include "asterisk/crypto.h"
74 #include "asterisk/acl.h"
75 #include "asterisk/manager.h"
76 #include "asterisk/callerid.h"
77 #include "asterisk/app.h"
78 #include "asterisk/astdb.h"
79 #include "asterisk/musiconhold.h"
80 #include "asterisk/features.h"
81 #include "asterisk/utils.h"
82 #include "asterisk/causes.h"
83 #include "asterisk/localtime.h"
84 #include "asterisk/dnsmgr.h"
85 #include "asterisk/devicestate.h"
86 #include "asterisk/netsock.h"
87 #include "asterisk/stringfields.h"
88 #include "asterisk/linkedlists.h"
89 #include "asterisk/event.h"
90 #include "asterisk/astobj2.h"
91 #include "asterisk/timing.h"
92 #include "asterisk/taskprocessor.h"
93 #include "asterisk/test.h"
94 #include "asterisk/data.h"
95 #include "asterisk/netsock2.h"
96
97 #include "iax2.h"
98 #include "iax2-parser.h"
99 #include "iax2-provision.h"
100 #include "jitterbuf.h"
101
102 /*** DOCUMENTATION
103         <application name="IAX2Provision" language="en_US">
104                 <synopsis>
105                         Provision a calling IAXy with a given template.
106                 </synopsis>
107                 <syntax>
108                         <parameter name="template">
109                                 <para>If not specified, defaults to <literal>default</literal>.</para>
110                         </parameter>
111                 </syntax>
112                 <description>
113                         <para>Provisions the calling IAXy (assuming the calling entity is in fact an IAXy) with the
114                         given <replaceable>template</replaceable>. Returns <literal>-1</literal> on error
115                         or <literal>0</literal> on success.</para>
116                 </description>
117         </application>
118         <function name="IAXPEER" language="en_US">
119                 <synopsis>
120                         Gets IAX peer information.
121                 </synopsis>
122                 <syntax>
123                         <parameter name="peername" required="true">
124                                 <enumlist>
125                                         <enum name="CURRENTCHANNEL">
126                                                 <para>If <replaceable>peername</replaceable> is specified to this value, return the IP address of the
127                                                 endpoint of the current channel</para>
128                                         </enum>
129                                 </enumlist>
130                         </parameter>
131                         <parameter name="item">
132                                 <para>If <replaceable>peername</replaceable> is specified, valid items are:</para>
133                                 <enumlist>
134                                         <enum name="ip">
135                                                 <para>(default) The IP address.</para>
136                                         </enum>
137                                         <enum name="status">
138                                                 <para>The peer's status (if <literal>qualify=yes</literal>)</para>
139                                         </enum>
140                                         <enum name="mailbox">
141                                                 <para>The configured mailbox.</para>
142                                         </enum>
143                                         <enum name="context">
144                                                 <para>The configured context.</para>
145                                         </enum>
146                                         <enum name="expire">
147                                                 <para>The epoch time of the next expire.</para>
148                                         </enum>
149                                         <enum name="dynamic">
150                                                 <para>Is it dynamic? (yes/no).</para>
151                                         </enum>
152                                         <enum name="callerid_name">
153                                                 <para>The configured Caller ID name.</para>
154                                         </enum>
155                                         <enum name="callerid_num">
156                                                 <para>The configured Caller ID number.</para>
157                                         </enum>
158                                         <enum name="codecs">
159                                                 <para>The configured codecs.</para>
160                                         </enum>
161                                         <enum name="codec[x]">
162                                                 <para>Preferred codec index number <replaceable>x</replaceable> (beginning
163                                                 with <literal>0</literal>)</para>
164                                         </enum>
165                                 </enumlist>
166                         </parameter>
167                 </syntax>
168                 <description></description>
169                 <see-also>
170                         <ref type="function">SIPPEER</ref>
171                 </see-also>
172         </function>
173         <function name="IAXVAR" language="en_US">
174                 <synopsis>
175                         Sets or retrieves a remote variable.
176                 </synopsis>
177                 <syntax>
178                         <parameter name="varname" required="true" />
179                 </syntax>
180                 <description></description>
181         </function>
182         <manager name="IAXpeers" language="en_US">
183                 <synopsis>
184                         List IAX peers.
185                 </synopsis>
186                 <syntax>
187                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
188                 </syntax>
189                 <description>
190                 </description>
191         </manager>
192         <manager name="IAXpeerlist" language="en_US">
193                 <synopsis>
194                         List IAX Peers.
195                 </synopsis>
196                 <syntax>
197                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
198                 </syntax>
199                 <description>
200                         <para>List all the IAX peers.</para>
201                 </description>
202         </manager>
203         <manager name="IAXnetstats" language="en_US">
204                 <synopsis>
205                         Show IAX Netstats.
206                 </synopsis>
207                 <syntax />
208                 <description>
209                         <para>Show IAX channels network statistics.</para>
210                 </description>
211         </manager>
212         <manager name="IAXregistry" language="en_US">
213                 <synopsis>
214                         Show IAX registrations.
215                 </synopsis>
216                 <syntax>
217                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
218                 </syntax>
219                 <description>
220                         <para>Show IAX registrations.</para>
221                 </description>
222         </manager>
223  ***/
224
225 /* Define SCHED_MULTITHREADED to run the scheduler in a special
226    multithreaded mode. */
227 #define SCHED_MULTITHREADED
228
229 /* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
230    thread is actually doing. */
231 #define DEBUG_SCHED_MULTITHREAD
232
233
234 #ifdef SO_NO_CHECK
235 static int nochecksums = 0;
236 #endif
237
238 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
239 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
240
241 #define DEFAULT_THREAD_COUNT 10
242 #define DEFAULT_MAX_THREAD_COUNT 100
243 #define DEFAULT_RETRY_TIME 1000
244 #define MEMORY_SIZE 100
245 #define DEFAULT_DROP 3
246
247 #define DEBUG_SUPPORT
248
249 #define MIN_REUSE_TIME          60      /* Don't reuse a call number within 60 seconds */
250
251 /* Sample over last 100 units to determine historic jitter */
252 #define GAMMA (0.01)
253
254 static struct ast_codec_pref prefs;
255
256 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
257
258
259 /*! \brief Maximum transmission unit for the UDP packet in the trunk not to be
260     fragmented. This is based on 1516 - ethernet - ip - udp - iax minus one g711 frame = 1240 */
261 #define MAX_TRUNK_MTU 1240
262
263 static int global_max_trunk_mtu;        /*!< Maximum MTU, 0 if not used */
264 static int trunk_timed, trunk_untimed, trunk_maxmtu, trunk_nmaxmtu ;    /*!< Trunk MTU statistics */
265
266 #define DEFAULT_CONTEXT "default"
267
268 static char default_parkinglot[AST_MAX_CONTEXT];
269
270 static char language[MAX_LANGUAGE] = "";
271 static char regcontext[AST_MAX_CONTEXT] = "";
272
273 static struct ast_event_sub *network_change_event_subscription; /*!< subscription id for network change events */
274 static int network_change_event_sched_id = -1;
275
276 static int maxauthreq = 3;
277 static int max_retries = 4;
278 static int ping_time = 21;
279 static int lagrq_time = 10;
280 static int maxjitterbuffer=1000;
281 static int resyncthreshold=1000;
282 static int maxjitterinterps=10;
283 static int jittertargetextra = 40; /* number of milliseconds the new jitter buffer adds on to its size */
284
285 #define MAX_TRUNKDATA           640 * 200       /*!< 40ms, uncompressed linear * 200 channels */
286
287 static int trunkfreq = 20;
288 static int trunkmaxsize = MAX_TRUNKDATA;
289
290 static int authdebug = 0;
291 static int autokill = 0;
292 static int iaxcompat = 0;
293 static int last_authmethod = 0;
294
295 static int iaxdefaultdpcache=10 * 60;   /* Cache dialplan entries for 10 minutes by default */
296
297 static int iaxdefaulttimeout = 5;               /* Default to wait no more than 5 seconds for a reply to come back */
298
299 static struct {
300         unsigned int tos;
301         unsigned int cos;
302 } qos = { 0, 0 };
303
304 static int min_reg_expire;
305 static int max_reg_expire;
306
307 static int srvlookup = 0;
308
309 static struct ast_timer *timer;                         /* Timer for trunking */
310
311 static struct ast_netsock_list *netsock;
312 static struct ast_netsock_list *outsock;                /*!< used if sourceaddress specified and bindaddr == INADDR_ANY */
313 static int defaultsockfd = -1;
314
315 static int (*iax2_regfunk)(const char *username, int onoff) = NULL;
316
317 /* Ethernet, etc */
318 #define IAX_CAPABILITY_FULLBANDWIDTH    0xFFFF
319 /* T1, maybe ISDN */
320 #define IAX_CAPABILITY_MEDBANDWIDTH (IAX_CAPABILITY_FULLBANDWIDTH & \
321                      ~ast_format_id_to_old_bitfield(AST_FORMAT_SLINEAR) &      \
322                      ~ast_format_id_to_old_bitfield(AST_FORMAT_SLINEAR16) &    \
323                      ~ast_format_id_to_old_bitfield(AST_FORMAT_SIREN7) &       \
324                      ~ast_format_id_to_old_bitfield(AST_FORMAT_SIREN14) &      \
325                      ~ast_format_id_to_old_bitfield(AST_FORMAT_G719) &         \
326                      ~ast_format_id_to_old_bitfield(AST_FORMAT_ULAW) &         \
327                      ~ast_format_id_to_old_bitfield(AST_FORMAT_ALAW) &         \
328                      ~ast_format_id_to_old_bitfield(AST_FORMAT_G722))
329 /* A modem */
330 #define IAX_CAPABILITY_LOWBANDWIDTH (IAX_CAPABILITY_MEDBANDWIDTH & \
331                      ~ast_format_id_to_old_bitfield(AST_FORMAT_G726) &         \
332                      ~ast_format_id_to_old_bitfield(AST_FORMAT_G726_AAL2) &    \
333                      ~ast_format_id_to_old_bitfield(AST_FORMAT_ADPCM))
334
335 #define IAX_CAPABILITY_LOWFREE      (IAX_CAPABILITY_LOWBANDWIDTH & \
336                      ~ast_format_id_to_old_bitfield(AST_FORMAT_G723_1))
337
338
339 #define DEFAULT_MAXMS           2000            /* Must be faster than 2 seconds by default */
340 #define DEFAULT_FREQ_OK         60 * 1000       /* How often to check for the host to be up */
341 #define DEFAULT_FREQ_NOTOK      10 * 1000       /* How often to check, if the host is down... */
342
343 /* if a pvt has encryption setup done and is running on the call */
344 #define IAX_CALLENCRYPTED(pvt) \
345         (ast_test_flag64(pvt, IAX_ENCRYPTED) && ast_test_flag64(pvt, IAX_KEYPOPULATED))
346
347 #define IAX_DEBUGDIGEST(msg, key) do { \
348                 int idx; \
349                 char digest[33] = ""; \
350                 \
351                 if (!iaxdebug) \
352                         break; \
353                 \
354                 for (idx = 0; idx < 16; idx++) \
355                         sprintf(digest + (idx << 1), "%2.2x", (unsigned char) key[idx]); \
356                 \
357                 ast_log(LOG_NOTICE, msg " IAX_COMMAND_RTKEY to rotate key to '%s'\n", digest); \
358         } while(0)
359
360 static struct io_context *io;
361 static struct ast_sched_context *sched;
362
363 #define DONT_RESCHEDULE -2
364
365 static iax2_format iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
366
367 static int iaxdebug = 0;
368
369 static int iaxtrunkdebug = 0;
370
371 static int test_losspct = 0;
372 #ifdef IAXTESTS
373 static int test_late = 0;
374 static int test_resync = 0;
375 static int test_jit = 0;
376 static int test_jitpct = 0;
377 #endif /* IAXTESTS */
378
379 static char accountcode[AST_MAX_ACCOUNT_CODE];
380 static char mohinterpret[MAX_MUSICCLASS];
381 static char mohsuggest[MAX_MUSICCLASS];
382 static int amaflags = 0;
383 static int adsi = 0;
384 static int delayreject = 0;
385 static int iax2_encryption = 0;
386
387 static struct ast_flags64 globalflags = { 0 };
388
389 static pthread_t netthreadid = AST_PTHREADT_NULL;
390
391 enum iax2_state {
392         IAX_STATE_STARTED =                     (1 << 0),
393         IAX_STATE_AUTHENTICATED =       (1 << 1),
394         IAX_STATE_TBD =                         (1 << 2),
395 };
396
397 struct iax2_context {
398         char context[AST_MAX_CONTEXT];
399         struct iax2_context *next;
400 };
401
402
403 #define IAX_HASCALLERID         (uint64_t)(1 << 0)    /*!< CallerID has been specified */
404 #define IAX_DELME               (uint64_t)(1 << 1)    /*!< Needs to be deleted */
405 #define IAX_TEMPONLY            (uint64_t)(1 << 2)    /*!< Temporary (realtime) */
406 #define IAX_TRUNK               (uint64_t)(1 << 3)    /*!< Treat as a trunk */
407 #define IAX_NOTRANSFER          (uint64_t)(1 << 4)    /*!< Don't native bridge */
408 #define IAX_USEJITTERBUF        (uint64_t)(1 << 5)    /*!< Use jitter buffer */
409 #define IAX_DYNAMIC             (uint64_t)(1 << 6)    /*!< dynamic peer */
410 #define IAX_SENDANI             (uint64_t)(1 << 7)    /*!< Send ANI along with CallerID */
411 #define IAX_RTSAVE_SYSNAME      (uint64_t)(1 << 8)    /*!< Save Systname on Realtime Updates */
412 #define IAX_ALREADYGONE         (uint64_t)(1 << 9)    /*!< Already disconnected */
413 #define IAX_PROVISION           (uint64_t)(1 << 10)   /*!< This is a provisioning request */
414 #define IAX_QUELCH              (uint64_t)(1 << 11)   /*!< Whether or not we quelch audio */
415 #define IAX_ENCRYPTED           (uint64_t)(1 << 12)   /*!< Whether we should assume encrypted tx/rx */
416 #define IAX_KEYPOPULATED        (uint64_t)(1 << 13)   /*!< Whether we have a key populated */
417 #define IAX_CODEC_USER_FIRST    (uint64_t)(1 << 14)   /*!< are we willing to let the other guy choose the codec? */
418 #define IAX_CODEC_NOPREFS       (uint64_t)(1 << 15)   /*!< Force old behaviour by turning off prefs */
419 #define IAX_CODEC_NOCAP         (uint64_t)(1 << 16)   /*!< only consider requested format and ignore capabilities*/
420 #define IAX_RTCACHEFRIENDS      (uint64_t)(1 << 17)   /*!< let realtime stay till your reload */
421 #define IAX_RTUPDATE            (uint64_t)(1 << 18)   /*!< Send a realtime update */
422 #define IAX_RTAUTOCLEAR         (uint64_t)(1 << 19)   /*!< erase me on expire */
423 #define IAX_FORCEJITTERBUF      (uint64_t)(1 << 20)   /*!< Force jitterbuffer, even when bridged to a channel that can take jitter */
424 #define IAX_RTIGNOREREGEXPIRE   (uint64_t)(1 << 21)   /*!< When using realtime, ignore registration expiration */
425 #define IAX_TRUNKTIMESTAMPS     (uint64_t)(1 << 22)   /*!< Send trunk timestamps */
426 #define IAX_TRANSFERMEDIA       (uint64_t)(1 << 23)   /*!< When doing IAX2 transfers, transfer media only */
427 #define IAX_MAXAUTHREQ          (uint64_t)(1 << 24)   /*!< Maximum outstanding AUTHREQ restriction is in place */
428 #define IAX_DELAYPBXSTART       (uint64_t)(1 << 25)   /*!< Don't start a PBX on the channel until the peer sends us a response, so that we've achieved a three-way handshake with them before sending voice or anything else */
429 #define IAX_ALLOWFWDOWNLOAD     (uint64_t)(1 << 26)   /*!< Allow the FWDOWNL command? */
430 #define IAX_IMMEDIATE           (uint64_t)(1 << 27)   /*!< Allow immediate off-hook to extension s */
431 #define IAX_SENDCONNECTEDLINE   (uint64_t)(1 << 28)   /*!< Allow sending of connected line updates */
432 #define IAX_RECVCONNECTEDLINE   (uint64_t)(1 << 29)   /*!< Allow receiving of connected line updates */
433 #define IAX_FORCE_ENCRYPT       (uint64_t)(1 << 30)   /*!< Forces call encryption, if encryption not possible hangup */
434 #define IAX_SHRINKCALLERID      (uint64_t)(1 << 31)   /*!< Turn on and off caller id shrinking */
435 static int global_rtautoclear = 120;
436
437 static int reload_config(void);
438
439 /*!
440  * \brief Call token validation settings.
441  */
442 enum calltoken_peer_enum {
443         /*! \brief Default calltoken required unless the ip is in the ignorelist */
444         CALLTOKEN_DEFAULT = 0,
445         /*! \brief Require call token validation. */
446         CALLTOKEN_YES = 1,
447         /*! \brief Require call token validation after a successful registration
448          *         using call token validation occurs. */
449         CALLTOKEN_AUTO = 2,
450         /*! \brief Do not require call token validation. */
451         CALLTOKEN_NO = 3,
452 };
453
454 struct iax2_user {
455         AST_DECLARE_STRING_FIELDS(
456                 AST_STRING_FIELD(name);
457                 AST_STRING_FIELD(secret);
458                 AST_STRING_FIELD(dbsecret);
459                 AST_STRING_FIELD(accountcode);
460                 AST_STRING_FIELD(mohinterpret);
461                 AST_STRING_FIELD(mohsuggest);
462                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this user can use to authenticate to us */
463                 AST_STRING_FIELD(language);
464                 AST_STRING_FIELD(cid_num);
465                 AST_STRING_FIELD(cid_name);
466                 AST_STRING_FIELD(parkinglot);           /*!< Default parkinglot for device */
467         );
468
469         int authmethods;
470         int encmethods;
471         int amaflags;
472         int adsi;
473         uint64_t flags;
474         iax2_format capability;
475         int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
476         int curauthreq; /*!< Current number of outstanding AUTHREQs */
477         struct ast_codec_pref prefs;
478         struct ast_ha *ha;
479         struct iax2_context *contexts;
480         struct ast_variable *vars;
481         enum calltoken_peer_enum calltoken_required;        /*!< Is calltoken validation required or not, can be YES, NO, or AUTO */
482 };
483
484 struct iax2_peer {
485         AST_DECLARE_STRING_FIELDS(
486                 AST_STRING_FIELD(name);
487                 AST_STRING_FIELD(username);
488                 AST_STRING_FIELD(description);          /*!< Description of the peer */
489                 AST_STRING_FIELD(secret);
490                 AST_STRING_FIELD(dbsecret);
491                 AST_STRING_FIELD(outkey);           /*!< What key we use to talk to this peer */
492
493                 AST_STRING_FIELD(regexten);     /*!< Extension to register (if regcontext is used) */
494                 AST_STRING_FIELD(context);      /*!< For transfers only */
495                 AST_STRING_FIELD(peercontext);  /*!< Context to pass to peer */
496                 AST_STRING_FIELD(mailbox);          /*!< Mailbox */
497                 AST_STRING_FIELD(mohinterpret);
498                 AST_STRING_FIELD(mohsuggest);
499                 AST_STRING_FIELD(inkeys);               /*!< Key(s) this peer can use to authenticate to us */
500                 /* Suggested caller id if registering */
501                 AST_STRING_FIELD(cid_num);              /*!< Default context (for transfer really) */
502                 AST_STRING_FIELD(cid_name);             /*!< Default context (for transfer really) */
503                 AST_STRING_FIELD(zonetag);              /*!< Time Zone */
504                 AST_STRING_FIELD(parkinglot);   /*!< Default parkinglot for device */
505         );
506         struct ast_codec_pref prefs;
507         struct ast_dnsmgr_entry *dnsmgr;                /*!< DNS refresh manager */
508         struct ast_sockaddr addr;
509         int formats;
510         int sockfd;                                     /*!< Socket to use for transmission */
511         struct in_addr mask;
512         int adsi;
513         uint64_t flags;
514
515         /* Dynamic Registration fields */
516         struct sockaddr_in defaddr;                     /*!< Default address if there is one */
517         int authmethods;                                /*!< Authentication methods (IAX_AUTH_*) */
518         int encmethods;                                 /*!< Encryption methods (IAX_ENCRYPT_*) */
519
520         int expire;                                     /*!< Schedule entry for expiry */
521         int expiry;                                     /*!< How soon to expire */
522         iax2_format capability;        /*!< Capability */
523
524         /* Qualification */
525         int callno;                                     /*!< Call number of POKE request */
526         int pokeexpire;                                 /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
527         int lastms;                                     /*!< How long last response took (in ms), or -1 for no response */
528         int maxms;                                      /*!< Max ms we will accept for the host to be up, 0 to not monitor */
529
530         int pokefreqok;                                 /*!< How often to check if the host is up */
531         int pokefreqnotok;                              /*!< How often to check when the host has been determined to be down */
532         int historicms;                                 /*!< How long recent average responses took */
533         int smoothing;                                  /*!< Sample over how many units to determine historic ms */
534         uint16_t maxcallno;                                     /*!< Max call number limit for this peer.  Set on registration */
535
536         struct ast_event_sub *mwi_event_sub;
537
538         struct ast_ha *ha;
539         enum calltoken_peer_enum calltoken_required;        /*!< Is calltoken validation required or not, can be YES, NO, or AUTO */
540 };
541
542 #define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
543
544 struct iax2_trunk_peer {
545         ast_mutex_t lock;
546         int sockfd;
547         struct sockaddr_in addr;
548         struct timeval txtrunktime;             /*!< Transmit trunktime */
549         struct timeval rxtrunktime;             /*!< Receive trunktime */
550         struct timeval lasttxtime;              /*!< Last transmitted trunktime */
551         struct timeval trunkact;                /*!< Last trunk activity */
552         unsigned int lastsent;                  /*!< Last sent time */
553         /* Trunk data and length */
554         unsigned char *trunkdata;
555         unsigned int trunkdatalen;
556         unsigned int trunkdataalloc;
557         int trunkmaxmtu;
558         int trunkerror;
559         int calls;
560         AST_LIST_ENTRY(iax2_trunk_peer) list;
561 };
562
563 static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
564
565 struct iax_firmware {
566         AST_LIST_ENTRY(iax_firmware) list;
567         int fd;
568         int mmaplen;
569         int dead;
570         struct ast_iax2_firmware_header *fwh;
571         unsigned char *buf;
572 };
573
574 enum iax_reg_state {
575         REG_STATE_UNREGISTERED = 0,
576         REG_STATE_REGSENT,
577         REG_STATE_AUTHSENT,
578         REG_STATE_REGISTERED,
579         REG_STATE_REJECTED,
580         REG_STATE_TIMEOUT,
581         REG_STATE_NOAUTH
582 };
583
584 enum iax_transfer_state {
585         TRANSFER_NONE = 0,
586         TRANSFER_BEGIN,
587         TRANSFER_READY,
588         TRANSFER_RELEASED,
589         TRANSFER_PASSTHROUGH,
590         TRANSFER_MBEGIN,
591         TRANSFER_MREADY,
592         TRANSFER_MRELEASED,
593         TRANSFER_MPASSTHROUGH,
594         TRANSFER_MEDIA,
595         TRANSFER_MEDIAPASS
596 };
597
598 struct iax2_registry {
599         struct ast_sockaddr addr;               /*!< Who we connect to for registration purposes */
600         char username[80];
601         char secret[80];                        /*!< Password or key name in []'s */
602         int expire;                             /*!< Sched ID of expiration */
603         int refresh;                            /*!< How often to refresh */
604         enum iax_reg_state regstate;
605         int messages;                           /*!< Message count, low 8 bits = new, high 8 bits = old */
606         int callno;                             /*!< Associated call number if applicable */
607         struct sockaddr_in us;                  /*!< Who the server thinks we are */
608         struct ast_dnsmgr_entry *dnsmgr;        /*!< DNS refresh manager */
609         AST_LIST_ENTRY(iax2_registry) entry;
610 };
611
612 static AST_LIST_HEAD_STATIC(registrations, iax2_registry);
613
614 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
615 #define MIN_RETRY_TIME          100
616 #define MAX_RETRY_TIME          10000
617
618 #define MAX_JITTER_BUFFER       50
619 #define MIN_JITTER_BUFFER       10
620
621 #define DEFAULT_TRUNKDATA       640 * 10        /*!< 40ms, uncompressed linear * 10 channels */
622
623 #define MAX_TIMESTAMP_SKEW      160             /*!< maximum difference between actual and predicted ts for sending */
624
625 /* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
626 #define TS_GAP_FOR_JB_RESYNC    5000
627
628 /* used for first_iax_message and last_iax_message.  If this bit is set it was TX, else RX */
629 #define MARK_IAX_SUBCLASS_TX    0x8000
630
631 static int iaxthreadcount = DEFAULT_THREAD_COUNT;
632 static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
633 static int iaxdynamicthreadcount = 0;
634 static int iaxdynamicthreadnum = 0;
635 static int iaxactivethreadcount = 0;
636
637 struct iax_rr {
638         int jitter;
639         int losspct;
640         int losscnt;
641         int packets;
642         int delay;
643         int dropped;
644         int ooo;
645 };
646
647 struct iax2_pvt_ref;
648
649 struct chan_iax2_pvt {
650         /*! Socket to send/receive on for this call */
651         int sockfd;
652         /*! Last received voice format */
653         iax2_format voiceformat;
654         /*! Last received video format */
655         iax2_format videoformat;
656         /*! Last sent voice format */
657         iax2_format svoiceformat;
658         /*! Last sent video format */
659         iax2_format svideoformat;
660         /*! What we are capable of sending */
661         iax2_format capability;
662         /*! Last received timestamp */
663         unsigned int last;
664         /*! Last sent timestamp - never send the same timestamp twice in a single call */
665         unsigned int lastsent;
666         /*! Timestamp of the last video frame sent */
667         unsigned int lastvsent;
668         /*! Next outgoing timestamp if everything is good */
669         unsigned int nextpred;
670         /*! iax frame subclass that began iax2_pvt entry. 0x8000 bit is set on TX */
671         int first_iax_message;
672         /*! Last iax frame subclass sent or received for a iax2_pvt. 0x8000 bit is set on TX */
673         int last_iax_message;
674         /*! True if the last voice we transmitted was not silence/CNG */
675         unsigned int notsilenttx:1;
676         /*! Ping time */
677         unsigned int pingtime;
678         /*! Max time for initial response */
679         int maxtime;
680         /*! Peer Address */
681         struct sockaddr_in addr;
682         /*! Actual used codec preferences */
683         struct ast_codec_pref prefs;
684         /*! Requested codec preferences */
685         struct ast_codec_pref rprefs;
686         /*! Our call number */
687         unsigned short callno;
688         /*! Our callno_entry entry */
689         struct callno_entry *callno_entry;
690         /*! Peer callno */
691         unsigned short peercallno;
692         /*! Negotiated format, this is only used to remember what format was
693             chosen for an unauthenticated call so that the channel can get
694             created later using the right format */
695         iax2_format chosenformat;
696         /*! Peer selected format */
697         iax2_format peerformat;
698         /*! Peer capability */
699         iax2_format peercapability;
700         /*! timeval that we base our transmission on */
701         struct timeval offset;
702         /*! timeval that we base our delivery on */
703         struct timeval rxcore;
704         /*! The jitterbuffer */
705         jitterbuf *jb;
706         /*! active jb read scheduler id */
707         int jbid;
708         /*! LAG */
709         int lag;
710         /*! Error, as discovered by the manager */
711         int error;
712         /*! Owner if we have one */
713         struct ast_channel *owner;
714         /*! What's our state? */
715         struct ast_flags state;
716         /*! Expiry (optional) */
717         int expiry;
718         /*! Next outgoing sequence number */
719         unsigned char oseqno;
720         /*! Next sequence number they have not yet acknowledged */
721         unsigned char rseqno;
722         /*! Next incoming sequence number */
723         unsigned char iseqno;
724         /*! Last incoming sequence number we have acknowledged */
725         unsigned char aseqno;
726
727         AST_DECLARE_STRING_FIELDS(
728                 /*! Peer name */
729                 AST_STRING_FIELD(peer);
730                 /*! Default Context */
731                 AST_STRING_FIELD(context);
732                 /*! Caller ID if available */
733                 AST_STRING_FIELD(cid_num);
734                 AST_STRING_FIELD(cid_name);
735                 /*! Hidden Caller ID (i.e. ANI) if appropriate */
736                 AST_STRING_FIELD(ani);
737                 /*! DNID */
738                 AST_STRING_FIELD(dnid);
739                 /*! RDNIS */
740                 AST_STRING_FIELD(rdnis);
741                 /*! Requested Extension */
742                 AST_STRING_FIELD(exten);
743                 /*! Expected Username */
744                 AST_STRING_FIELD(username);
745                 /*! Expected Secret */
746                 AST_STRING_FIELD(secret);
747                 /*! MD5 challenge */
748                 AST_STRING_FIELD(challenge);
749                 /*! Public keys permitted keys for incoming authentication */
750                 AST_STRING_FIELD(inkeys);
751                 /*! Private key for outgoing authentication */
752                 AST_STRING_FIELD(outkey);
753                 /*! Preferred language */
754                 AST_STRING_FIELD(language);
755                 /*! Hostname/peername for naming purposes */
756                 AST_STRING_FIELD(host);
757
758                 AST_STRING_FIELD(dproot);
759                 AST_STRING_FIELD(accountcode);
760                 AST_STRING_FIELD(mohinterpret);
761                 AST_STRING_FIELD(mohsuggest);
762                 /*! received OSP token */
763                 AST_STRING_FIELD(osptoken);
764                 /*! Default parkinglot */
765                 AST_STRING_FIELD(parkinglot);
766         );
767         /*! AUTHREJ all AUTHREP frames */
768         int authrej;
769         /*! permitted authentication methods */
770         int authmethods;
771         /*! permitted encryption methods */
772         int encmethods;
773         /*! Encryption AES-128 Key */
774         ast_aes_encrypt_key ecx;
775         /*! Decryption AES-128 Key corresponding to ecx */
776         ast_aes_decrypt_key mydcx;
777         /*! Decryption AES-128 Key used to decrypt peer frames */
778         ast_aes_decrypt_key dcx;
779         /*! scheduler id associated with iax_key_rotate 
780          * for encrypted calls*/
781         int keyrotateid;
782         /*! 32 bytes of semi-random data */
783         unsigned char semirand[32];
784         /*! Associated registry */
785         struct iax2_registry *reg;
786         /*! Associated peer for poking */
787         struct iax2_peer *peerpoke;
788         /*! IAX_ flags */
789         uint64_t flags;
790         int adsi;
791
792         /*! Transferring status */
793         enum iax_transfer_state transferring;
794         /*! Transfer identifier */
795         int transferid;
796         /*! Who we are IAX transferring to */
797         struct sockaddr_in transfer;
798         /*! What's the new call number for the transfer */
799         unsigned short transfercallno;
800         /*! Transfer encrypt AES-128 Key */
801         ast_aes_encrypt_key tdcx;
802
803         /*! Status of knowledge of peer ADSI capability */
804         int peeradsicpe;
805
806         /*! Who we are bridged to */
807         unsigned short bridgecallno;
808
809         int pingid;                     /*!< Transmit PING request */
810         int lagid;                      /*!< Retransmit lag request */
811         int autoid;                     /*!< Auto hangup for Dialplan requestor */
812         int authid;                     /*!< Authentication rejection ID */
813         int authfail;                   /*!< Reason to report failure */
814         int initid;                     /*!< Initial peer auto-congest ID (based on qualified peers) */
815         int calling_ton;
816         int calling_tns;
817         int calling_pres;
818         int amaflags;
819         AST_LIST_HEAD_NOLOCK(, iax2_dpcache) dpentries;
820         /*! variables inherited from the user definition */
821         struct ast_variable *vars;
822         /*! variables transmitted in a NEW packet */
823         struct ast_variable *iaxvars;
824         /*! last received remote rr */
825         struct iax_rr remote_rr;
826         /*! Current base time: (just for stats) */
827         int min;
828         /*! Dropped frame count: (just for stats) */
829         int frames_dropped;
830         /*! received frame count: (just for stats) */
831         int frames_received;
832         /*! num bytes used for calltoken ie, even an empty ie should contain 2 */
833         unsigned char calltoken_ie_len;
834         /*! hold all signaling frames from the pbx thread until we have a destination callno */
835         char hold_signaling;
836         /*! frame queue for signaling frames from pbx thread waiting for destination callno */
837         AST_LIST_HEAD_NOLOCK(signaling_queue, signaling_queue_entry) signaling_queue;
838 };
839
840 struct signaling_queue_entry {
841         struct ast_frame f;
842         AST_LIST_ENTRY(signaling_queue_entry) next;
843 };
844
845 /*! table of available call numbers */
846 static struct ao2_container *callno_pool;
847
848 /*! table of available trunk call numbers */
849 static struct ao2_container *callno_pool_trunk;
850
851 static const unsigned int CALLNO_POOL_BUCKETS = 2699;
852
853 /*!
854  * \brief a list of frames that may need to be retransmitted
855  *
856  * \note The contents of this list do not need to be explicitly destroyed
857  * on module unload.  This is because all active calls are destroyed, and
858  * all frames in this queue will get destroyed as a part of that process.
859  *
860  * \note Contents protected by the iaxsl[] locks
861  */
862 static AST_LIST_HEAD_NOLOCK(, iax_frame) frame_queue[IAX_MAX_CALLS + 1];
863
864 static struct ast_taskprocessor *transmit_processor;
865
866 static int randomcalltokendata;
867
868 static const time_t MAX_CALLTOKEN_DELAY = 10;
869
870 /*!
871  * This module will get much higher performance when doing a lot of
872  * user and peer lookups if the number of buckets is increased from 1.
873  * However, to maintain old behavior for Asterisk 1.4, these are set to
874  * 1 by default.  When using multiple buckets, search order through these
875  * containers is considered random, so you will not be able to depend on
876  * the order the entires are specified in iax.conf for matching order. */
877 #ifdef LOW_MEMORY
878 #define MAX_PEER_BUCKETS 17
879 #else
880 #define MAX_PEER_BUCKETS 563
881 #endif
882 static struct ao2_container *peers;
883
884 #define MAX_USER_BUCKETS MAX_PEER_BUCKETS
885 static struct ao2_container *users;
886
887 /*! Table containing peercnt objects for every ip address consuming a callno */
888 static struct ao2_container *peercnts;
889
890 /*! Table containing custom callno limit rules for a range of ip addresses. */
891 static struct ao2_container *callno_limits;
892
893 /*! Table containing ip addresses not requiring calltoken validation */
894 static struct ao2_container *calltoken_ignores;
895
896 static uint16_t DEFAULT_MAXCALLNO_LIMIT = 2048;
897
898 static uint16_t DEFAULT_MAXCALLNO_LIMIT_NONVAL = 8192;
899
900 static uint16_t global_maxcallno;
901
902 /*! Total num of call numbers allowed to be allocated without calltoken validation */
903 static uint16_t global_maxcallno_nonval;
904
905 static uint16_t total_nonval_callno_used = 0;
906
907 /*! peer connection private, keeps track of all the call numbers
908  *  consumed by a single ip address */
909 struct peercnt {
910         /*! ip address consuming call numbers */
911         unsigned long addr;
912         /*! Number of call numbers currently used by this ip address */
913         uint16_t cur;
914         /*! Max call numbers allowed for this ip address */
915         uint16_t limit;
916         /*! Specifies whether limit is set by a registration or not, if so normal
917          *  limit setting rules do not apply to this address. */
918         unsigned char reg;
919 };
920
921 /*! used by both callno_limits and calltoken_ignores containers */
922 struct addr_range {
923         /*! ip address range for custom callno limit rule */
924         struct ast_ha ha;
925         /*! callno limit for this ip address range, only used in callno_limits container */
926         uint16_t limit;
927         /*! delete me marker for reloads */
928         unsigned char delme;
929 };
930
931 struct callno_entry {
932         /*! callno used for this entry */
933         uint16_t callno;
934         /*! was this callno calltoken validated or not */
935         unsigned char validated;
936 };
937
938 static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);
939
940 enum {
941         /*! Extension exists */
942         CACHE_FLAG_EXISTS      = (1 << 0),
943         /*! Extension is nonexistent */
944         CACHE_FLAG_NONEXISTENT = (1 << 1),
945         /*! Extension can exist */
946         CACHE_FLAG_CANEXIST    = (1 << 2),
947         /*! Waiting to hear back response */
948         CACHE_FLAG_PENDING     = (1 << 3),
949         /*! Timed out */
950         CACHE_FLAG_TIMEOUT     = (1 << 4),
951         /*! Request transmitted */
952         CACHE_FLAG_TRANSMITTED = (1 << 5),
953         /*! Timeout */
954         CACHE_FLAG_UNKNOWN     = (1 << 6),
955         /*! Matchmore */
956         CACHE_FLAG_MATCHMORE   = (1 << 7),
957 };
958
959 struct iax2_dpcache {
960         char peercontext[AST_MAX_CONTEXT];
961         char exten[AST_MAX_EXTENSION];
962         struct timeval orig;
963         struct timeval expiry;
964         int flags;
965         unsigned short callno;
966         int waiters[256];
967         AST_LIST_ENTRY(iax2_dpcache) cache_list;
968         AST_LIST_ENTRY(iax2_dpcache) peer_list;
969 };
970
971 static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
972
973 static void reg_source_db(struct iax2_peer *p);
974 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
975 static struct iax2_user *realtime_user(const char *username, struct sockaddr_in *sin);
976
977 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
978 static char *complete_iax2_peers(const char *line, const char *word, int pos, int state, uint64_t flags);
979 static char *complete_iax2_unregister(const char *line, const char *word, int pos, int state);
980
981 enum iax2_thread_iostate {
982         IAX_IOSTATE_IDLE,
983         IAX_IOSTATE_READY,
984         IAX_IOSTATE_PROCESSING,
985         IAX_IOSTATE_SCHEDREADY,
986 };
987
988 enum iax2_thread_type {
989         IAX_THREAD_TYPE_POOL,
990         IAX_THREAD_TYPE_DYNAMIC,
991 };
992
993 struct iax2_pkt_buf {
994         AST_LIST_ENTRY(iax2_pkt_buf) entry;
995         size_t len;
996         unsigned char buf[1];
997 };
998
999 struct iax2_thread {
1000         AST_LIST_ENTRY(iax2_thread) list;
1001         enum iax2_thread_type type;
1002         enum iax2_thread_iostate iostate;
1003 #ifdef SCHED_MULTITHREADED
1004         void (*schedfunc)(const void *);
1005         const void *scheddata;
1006 #endif
1007 #ifdef DEBUG_SCHED_MULTITHREAD
1008         char curfunc[80];
1009 #endif  
1010         int actions;
1011         pthread_t threadid;
1012         int threadnum;
1013         struct sockaddr_in iosin;
1014         unsigned char readbuf[4096]; 
1015         unsigned char *buf;
1016         ssize_t buf_len;
1017         size_t buf_size;
1018         int iofd;
1019         time_t checktime;
1020         ast_mutex_t lock;
1021         ast_cond_t cond;
1022         ast_mutex_t init_lock;
1023         ast_cond_t init_cond;
1024         /*! if this thread is processing a full frame,
1025           some information about that frame will be stored
1026           here, so we can avoid dispatching any more full
1027           frames for that callno to other threads */
1028         struct {
1029                 unsigned short callno;
1030                 struct sockaddr_in sin;
1031                 unsigned char type;
1032                 unsigned char csub;
1033         } ffinfo;
1034         /*! Queued up full frames for processing.  If more full frames arrive for
1035          *  a call which this thread is already processing a full frame for, they
1036          *  are queued up here. */
1037         AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
1038         unsigned char stop;
1039 };
1040
1041 /* Thread lists */
1042 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
1043 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
1044 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
1045
1046 static void *iax2_process_thread(void *data);
1047 static void iax2_destroy(int callno);
1048
1049 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
1050 {
1051         ast_mutex_lock(lock);
1052         ast_cond_signal(cond);
1053         ast_mutex_unlock(lock);
1054 }
1055
1056 /*!
1057  * \brief an array of iax2 pvt structures
1058  *
1059  * The container for active chan_iax2_pvt structures is implemented as an
1060  * array for extremely quick direct access to the correct pvt structure
1061  * based on the local call number.  The local call number is used as the
1062  * index into the array where the associated pvt structure is stored.
1063  */
1064 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS + 1];
1065
1066 /*!
1067  * \brief Another container of iax2_pvt structures
1068  *
1069  * Active IAX2 pvt structs are also stored in this container, if they are a part
1070  * of an active call where we know the remote side's call number.  The reason
1071  * for this is that incoming media frames do not contain our call number.  So,
1072  * instead of having to iterate the entire iaxs array, we use this container to
1073  * look up calls where the remote side is using a given call number.
1074  */
1075 static struct ao2_container *iax_peercallno_pvts;
1076
1077 /*!
1078  * \brief chan_iax2_pvt structure locks
1079  *
1080  * These locks are used when accessing a pvt structure in the iaxs array.
1081  * The index used here is the same as used in the iaxs array.  It is the
1082  * local call number for the associated pvt struct.
1083  */
1084 static ast_mutex_t iaxsl[ARRAY_LEN(iaxs)];
1085
1086 /*!
1087  *  * \brief Another container of iax2_pvt structures
1088  *  
1089  *  Active IAX2 pvt stucts used during transfering a call are stored here.  
1090  */
1091 static struct ao2_container *iax_transfercallno_pvts;
1092
1093 /* Flag to use with trunk calls, keeping these calls high up.  It halves our effective use
1094    but keeps the division between trunked and non-trunked better. */
1095 #define TRUNK_CALL_START        IAX_MAX_CALLS / 2
1096
1097 /* Debug routines... */
1098 static struct sockaddr_in debugaddr;
1099
1100 static void iax_outputframe(struct iax_frame *f, struct ast_iax2_full_hdr *fhi, int rx, struct sockaddr_in *sin, int datalen)
1101 {
1102         if (iaxdebug ||
1103             (sin && debugaddr.sin_addr.s_addr && 
1104              (!ntohs(debugaddr.sin_port) ||
1105               debugaddr.sin_port == sin->sin_port) &&
1106              debugaddr.sin_addr.s_addr == sin->sin_addr.s_addr)) {
1107                 if (iaxdebug) {
1108                         iax_showframe(f, fhi, rx, sin, datalen);
1109                 } else {
1110                         iaxdebug = 1;
1111                         iax_showframe(f, fhi, rx, sin, datalen);
1112                         iaxdebug = 0;
1113                 }
1114         }
1115 }
1116
1117 static void iax_debug_output(const char *data)
1118 {
1119         if (iaxdebug)
1120                 ast_verbose("%s", data);
1121 }
1122
1123 static void iax_error_output(const char *data)
1124 {
1125         ast_log(LOG_WARNING, "%s", data);
1126 }
1127
1128 static void __attribute__((format(printf, 1, 2))) jb_error_output(const char *fmt, ...)
1129 {
1130         va_list args;
1131         char buf[1024];
1132
1133         va_start(args, fmt);
1134         vsnprintf(buf, sizeof(buf), fmt, args);
1135         va_end(args);
1136
1137         ast_log(LOG_ERROR, "%s", buf);
1138 }
1139
1140 static void __attribute__((format(printf, 1, 2))) jb_warning_output(const char *fmt, ...)
1141 {
1142         va_list args;
1143         char buf[1024];
1144
1145         va_start(args, fmt);
1146         vsnprintf(buf, sizeof(buf), fmt, args);
1147         va_end(args);
1148
1149         ast_log(LOG_WARNING, "%s", buf);
1150 }
1151
1152 static void __attribute__((format(printf, 1, 2))) jb_debug_output(const char *fmt, ...)
1153 {
1154         va_list args;
1155         char buf[1024];
1156
1157         va_start(args, fmt);
1158         vsnprintf(buf, sizeof(buf), fmt, args);
1159         va_end(args);
1160
1161         ast_verbose("%s", buf);
1162 }
1163
1164 static enum ast_bridge_result iax2_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);
1165 static int expire_registry(const void *data);
1166 static int iax2_answer(struct ast_channel *c);
1167 static int iax2_call(struct ast_channel *c, const char *dest, int timeout);
1168 static int iax2_devicestate(const char *data);
1169 static int iax2_digit_begin(struct ast_channel *c, char digit);
1170 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
1171 static int iax2_do_register(struct iax2_registry *reg);
1172 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
1173 static int iax2_hangup(struct ast_channel *c);
1174 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
1175 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
1176 static int iax2_provision(struct sockaddr_in *end, int sockfd, const char *dest, const char *template, int force);
1177 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
1178 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
1179 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
1180 static int iax2_sendtext(struct ast_channel *c, const char *text);
1181 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
1182 static int iax2_queryoption(struct ast_channel *c, int option, void *data, int *datalen);
1183 static int iax2_transfer(struct ast_channel *c, const char *dest);
1184 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
1185 static int iax2_sched_add(struct ast_sched_context *sched, int when, ast_sched_cb callback, const void *data);
1186
1187 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
1188 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1189 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1190 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
1191 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
1192 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
1193 static struct ast_channel *iax2_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause);
1194 static struct ast_frame *iax2_read(struct ast_channel *c);
1195 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1196 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
1197 static void realtime_update_peer(const char *peername, struct ast_sockaddr *sockaddr, time_t regtime);
1198 static void *iax2_dup_variable_datastore(void *);
1199 static void prune_peers(void);
1200 static void prune_users(void);
1201 static void iax2_free_variable_datastore(void *);
1202
1203 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
1204 static int decode_frame(ast_aes_decrypt_key *dcx, struct ast_iax2_full_hdr *fh, struct ast_frame *f, int *datalen);
1205 static int encrypt_frame(ast_aes_encrypt_key *ecx, struct ast_iax2_full_hdr *fh, unsigned char *poo, int *datalen);
1206 static void build_ecx_key(const unsigned char *digest, struct chan_iax2_pvt *pvt);
1207 static void build_rand_pad(unsigned char *buf, ssize_t len);
1208 static struct callno_entry *get_unused_callno(int trunk, int validated);
1209 static int replace_callno(const void *obj);
1210 static void sched_delay_remove(struct sockaddr_in *sin, struct callno_entry *callno_entry);
1211 static void network_change_event_cb(const struct ast_event *, void *);
1212
1213 static struct ast_channel_tech iax2_tech = {
1214         .type = "IAX2",
1215         .description = tdesc,
1216         .properties = AST_CHAN_TP_WANTSJITTER,
1217         .requester = iax2_request,
1218         .devicestate = iax2_devicestate,
1219         .send_digit_begin = iax2_digit_begin,
1220         .send_digit_end = iax2_digit_end,
1221         .send_text = iax2_sendtext,
1222         .send_image = iax2_sendimage,
1223         .send_html = iax2_sendhtml,
1224         .call = iax2_call,
1225         .hangup = iax2_hangup,
1226         .answer = iax2_answer,
1227         .read = iax2_read,
1228         .write = iax2_write,
1229         .write_video = iax2_write,
1230         .indicate = iax2_indicate,
1231         .setoption = iax2_setoption,
1232         .queryoption = iax2_queryoption,
1233         .bridge = iax2_bridge,
1234         .transfer = iax2_transfer,
1235         .fixup = iax2_fixup,
1236         .func_channel_read = acf_channel_read,
1237 };
1238
1239 /*!
1240  * \internal
1241  * \brief Obtain the owner channel lock if the owner exists.
1242  *
1243  * \param callno IAX2 call id.
1244  *
1245  * \note Assumes the iaxsl[callno] lock is already obtained.
1246  *
1247  * \note
1248  * IMPORTANT NOTE!!!  Any time this function is used, even if
1249  * iaxs[callno] was valid before calling it, it may no longer be
1250  * valid after calling it.  This function may unlock and lock
1251  * the mutex associated with this callno, meaning that another
1252  * thread may grab it and destroy the call.
1253  *
1254  * \return Nothing
1255  */
1256 static void iax2_lock_owner(int callno)
1257 {
1258         for (;;) {
1259                 if (!iaxs[callno] || !iaxs[callno]->owner) {
1260                         /* There is no owner lock to get. */
1261                         break;
1262                 }
1263                 if (!ast_channel_trylock(iaxs[callno]->owner)) {
1264                         /* We got the lock */
1265                         break;
1266                 }
1267                 /* Avoid deadlock by pausing and trying again */
1268                 DEADLOCK_AVOIDANCE(&iaxsl[callno]);
1269         }
1270 }
1271
1272 static void mwi_event_cb(const struct ast_event *event, void *userdata)
1273 {
1274         /* The MWI subscriptions exist just so the core knows we care about those
1275          * mailboxes.  However, we just grab the events out of the cache when it
1276          * is time to send MWI, since it is only sent with a REGACK. */
1277 }
1278
1279 static void network_change_event_subscribe(void)
1280 {
1281         if (!network_change_event_subscription) {
1282                 network_change_event_subscription = ast_event_subscribe(AST_EVENT_NETWORK_CHANGE,
1283                         network_change_event_cb, "IAX2 Network Change", NULL, AST_EVENT_IE_END);
1284         }
1285 }
1286
1287 static void network_change_event_unsubscribe(void)
1288 {
1289         if (network_change_event_subscription) {
1290                 network_change_event_subscription = ast_event_unsubscribe(network_change_event_subscription);
1291         }
1292 }
1293
1294 static int network_change_event_sched_cb(const void *data)
1295 {
1296         struct iax2_registry *reg;
1297         network_change_event_sched_id = -1;
1298         AST_LIST_LOCK(&registrations);
1299         AST_LIST_TRAVERSE(&registrations, reg, entry) {
1300                 iax2_do_register(reg);
1301         }
1302         AST_LIST_UNLOCK(&registrations);
1303
1304         return 0;
1305 }
1306
1307 static void network_change_event_cb(const struct ast_event *event, void *userdata)
1308 {
1309         ast_debug(1, "IAX, got a network change event, renewing all IAX registrations.\n");
1310         if (network_change_event_sched_id == -1) {
1311                 network_change_event_sched_id = iax2_sched_add(sched, 1000, network_change_event_sched_cb, NULL);
1312         }
1313
1314 }
1315
1316
1317 /*! \brief Send manager event at call setup to link between Asterisk channel name
1318         and IAX2 call identifiers */
1319 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt)
1320 {
1321         manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
1322                 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
1323                 pvt->owner ? ast_channel_name(pvt->owner) : "",
1324                 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
1325 }
1326
1327 static struct ast_datastore_info iax2_variable_datastore_info = {
1328         .type = "IAX2_VARIABLE",
1329         .duplicate = iax2_dup_variable_datastore,
1330         .destroy = iax2_free_variable_datastore,
1331 };
1332
1333 static void *iax2_dup_variable_datastore(void *old)
1334 {
1335         AST_LIST_HEAD(, ast_var_t) *oldlist = old, *newlist;
1336         struct ast_var_t *oldvar, *newvar;
1337
1338         newlist = ast_calloc(sizeof(*newlist), 1);
1339         if (!newlist) {
1340                 ast_log(LOG_ERROR, "Unable to duplicate iax2 variables\n");
1341                 return NULL;
1342         }
1343
1344         AST_LIST_HEAD_INIT(newlist);
1345         AST_LIST_LOCK(oldlist);
1346         AST_LIST_TRAVERSE(oldlist, oldvar, entries) {
1347                 newvar = ast_var_assign(ast_var_name(oldvar), ast_var_value(oldvar));
1348                 if (newvar)
1349                         AST_LIST_INSERT_TAIL(newlist, newvar, entries);
1350                 else
1351                         ast_log(LOG_ERROR, "Unable to duplicate iax2 variable '%s'\n", ast_var_name(oldvar));
1352         }
1353         AST_LIST_UNLOCK(oldlist);
1354         return newlist;
1355 }
1356
1357 static void iax2_free_variable_datastore(void *old)
1358 {
1359         AST_LIST_HEAD(, ast_var_t) *oldlist = old;
1360         struct ast_var_t *oldvar;
1361
1362         AST_LIST_LOCK(oldlist);
1363         while ((oldvar = AST_LIST_REMOVE_HEAD(oldlist, entries))) {
1364                 ast_free(oldvar);
1365         }
1366         AST_LIST_UNLOCK(oldlist);
1367         AST_LIST_HEAD_DESTROY(oldlist);
1368         ast_free(oldlist);
1369 }
1370
1371
1372 /* WARNING: insert_idle_thread should only ever be called within the
1373  * context of an iax2_process_thread() thread.
1374  */
1375 static void insert_idle_thread(struct iax2_thread *thread)
1376 {
1377         if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
1378                 AST_LIST_LOCK(&dynamic_list);
1379                 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
1380                 AST_LIST_UNLOCK(&dynamic_list);
1381         } else {
1382                 AST_LIST_LOCK(&idle_list);
1383                 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
1384                 AST_LIST_UNLOCK(&idle_list);
1385         }
1386
1387         return;
1388 }
1389
1390 static struct iax2_thread *find_idle_thread(void)
1391 {
1392         struct iax2_thread *thread = NULL;
1393
1394         /* Pop the head of the idle list off */
1395         AST_LIST_LOCK(&idle_list);
1396         thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
1397         AST_LIST_UNLOCK(&idle_list);
1398
1399         /* If we popped a thread off the idle list, just return it */
1400         if (thread) {
1401                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1402                 return thread;
1403         }
1404
1405         /* Pop the head of the dynamic list off */
1406         AST_LIST_LOCK(&dynamic_list);
1407         thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
1408         AST_LIST_UNLOCK(&dynamic_list);
1409
1410         /* If we popped a thread off the dynamic list, just return it */
1411         if (thread) {
1412                 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1413                 return thread;
1414         }
1415
1416         /* If we can't create a new dynamic thread for any reason, return no thread at all */
1417         if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
1418                 return NULL;
1419
1420         /* Set default values */
1421         ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
1422         thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadnum, 1);
1423         thread->type = IAX_THREAD_TYPE_DYNAMIC;
1424
1425         /* Initialize lock and condition */
1426         ast_mutex_init(&thread->lock);
1427         ast_cond_init(&thread->cond, NULL);
1428         ast_mutex_init(&thread->init_lock);
1429         ast_cond_init(&thread->init_cond, NULL);
1430         ast_mutex_lock(&thread->init_lock);
1431
1432         /* Create thread and send it on it's way */
1433         if (ast_pthread_create_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
1434                 ast_cond_destroy(&thread->cond);
1435                 ast_mutex_destroy(&thread->lock);
1436                 ast_mutex_unlock(&thread->init_lock);
1437                 ast_cond_destroy(&thread->init_cond);
1438                 ast_mutex_destroy(&thread->init_lock);
1439                 ast_free(thread);
1440                 return NULL;
1441         }
1442
1443         /* this thread is not processing a full frame (since it is idle),
1444            so ensure that the field for the full frame call number is empty */
1445         memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
1446
1447         /* Wait for the thread to be ready before returning it to the caller */
1448         ast_cond_wait(&thread->init_cond, &thread->init_lock);
1449
1450         /* Done with init_lock */
1451         ast_mutex_unlock(&thread->init_lock);
1452
1453         return thread;
1454 }
1455
1456 #ifdef SCHED_MULTITHREADED
1457 static int __schedule_action(void (*func)(const void *data), const void *data, const char *funcname)
1458 {
1459         struct iax2_thread *thread = NULL;
1460         static time_t lasterror;
1461         static time_t t;
1462
1463         thread = find_idle_thread();
1464
1465         if (thread != NULL) {
1466                 thread->schedfunc = func;
1467                 thread->scheddata = data;
1468                 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1469 #ifdef DEBUG_SCHED_MULTITHREAD
1470                 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1471 #endif
1472                 signal_condition(&thread->lock, &thread->cond);
1473                 return 0;
1474         }
1475         time(&t);
1476         if (t != lasterror)
1477                 ast_debug(1, "Out of idle IAX2 threads for scheduling!\n");
1478         lasterror = t;
1479
1480         return -1;
1481 }
1482 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1483 #endif
1484
1485 static int iax2_sched_replace(int id, struct ast_sched_context *con, int when,
1486                 ast_sched_cb callback, const void *data)
1487 {
1488         return ast_sched_replace(id, con, when, callback, data);
1489 }
1490
1491 static int iax2_sched_add(struct ast_sched_context *con, int when,
1492                 ast_sched_cb callback, const void *data)
1493 {
1494         return ast_sched_add(con, when, callback, data);
1495 }
1496
1497 static int send_ping(const void *data);
1498
1499 static void __send_ping(const void *data)
1500 {
1501         int callno = (long) data;
1502
1503         ast_mutex_lock(&iaxsl[callno]);
1504
1505         if (iaxs[callno]) {
1506                 if (iaxs[callno]->peercallno) {
1507                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1508                         if (iaxs[callno]->pingid != DONT_RESCHEDULE) {
1509                                 iaxs[callno]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, data);
1510                         }
1511                 }
1512         } else {
1513                 ast_debug(1, "I was supposed to send a PING with callno %d, but no such call exists.\n", callno);
1514         }
1515
1516         ast_mutex_unlock(&iaxsl[callno]);
1517 }
1518
1519 static int send_ping(const void *data)
1520 {
1521         int callno = (long) data;
1522         ast_mutex_lock(&iaxsl[callno]);
1523         if (iaxs[callno] && iaxs[callno]->pingid != DONT_RESCHEDULE) {
1524                 iaxs[callno]->pingid = -1;
1525         }
1526         ast_mutex_unlock(&iaxsl[callno]);
1527
1528 #ifdef SCHED_MULTITHREADED
1529         if (schedule_action(__send_ping, data))
1530 #endif
1531                 __send_ping(data);
1532
1533         return 0;
1534 }
1535
1536 static void encmethods_to_str(int e, struct ast_str *buf)
1537 {
1538         ast_str_set(&buf, 0, "(");
1539         if (e & IAX_ENCRYPT_AES128) {
1540                 ast_str_append(&buf, 0, "aes128");
1541         }
1542         if (e & IAX_ENCRYPT_KEYROTATE) {
1543                 ast_str_append(&buf, 0, ",keyrotate");
1544         }
1545         if (ast_str_strlen(buf) > 1) {
1546                 ast_str_append(&buf, 0, ")");
1547         } else {
1548                 ast_str_set(&buf, 0, "No");
1549         }
1550 }
1551
1552 static int get_encrypt_methods(const char *s)
1553 {
1554         int e;
1555         if (!strcasecmp(s, "aes128"))
1556                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1557         else if (ast_true(s))
1558                 e = IAX_ENCRYPT_AES128 | IAX_ENCRYPT_KEYROTATE;
1559         else
1560                 e = 0;
1561         return e;
1562 }
1563
1564 static int send_lagrq(const void *data);
1565
1566 static void __send_lagrq(const void *data)
1567 {
1568         int callno = (long) data;
1569
1570         ast_mutex_lock(&iaxsl[callno]);
1571
1572         if (iaxs[callno]) {
1573                 if (iaxs[callno]->peercallno) {
1574                         send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1575                         if (iaxs[callno]->lagid != DONT_RESCHEDULE) {
1576                                 iaxs[callno]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1577                         }
1578                 }
1579         } else {
1580                 ast_debug(1, "I was supposed to send a LAGRQ with callno %d, but no such call exists.\n", callno);
1581         }
1582
1583         ast_mutex_unlock(&iaxsl[callno]);
1584 }
1585
1586 static int send_lagrq(const void *data)
1587 {
1588         int callno = (long) data;
1589         ast_mutex_lock(&iaxsl[callno]);
1590         if (iaxs[callno] && iaxs[callno]->lagid != DONT_RESCHEDULE) {
1591                 iaxs[callno]->lagid = -1;
1592         }
1593         ast_mutex_unlock(&iaxsl[callno]);
1594
1595 #ifdef SCHED_MULTITHREADED
1596         if (schedule_action(__send_lagrq, data))
1597 #endif
1598                 __send_lagrq(data);
1599         return 0;
1600 }
1601
1602 static unsigned char compress_subclass(iax2_format subclass)
1603 {
1604         int x;
1605         int power=-1;
1606         /* If it's 64 or smaller, just return it */
1607         if (subclass < IAX_FLAG_SC_LOG)
1608                 return subclass;
1609         /* Otherwise find its power */
1610         for (x = 0; x < IAX_MAX_SHIFT; x++) {
1611                 if (subclass & (1LL << x)) {
1612                         if (power > -1) {
1613                                 ast_log(LOG_WARNING, "Can't compress subclass %lld\n", (long long) subclass);
1614                                 return 0;
1615                         } else
1616                                 power = x;
1617                 }
1618         }
1619         return power | IAX_FLAG_SC_LOG;
1620 }
1621
1622 static iax2_format uncompress_subclass(unsigned char csub)
1623 {
1624         /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1625         if (csub & IAX_FLAG_SC_LOG) {
1626                 /* special case for 'compressed' -1 */
1627                 if (csub == 0xff)
1628                         return -1;
1629                 else
1630                         return 1LL << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1631         }
1632         else
1633                 return csub;
1634 }
1635
1636 static iax2_format iax2_codec_choose(struct ast_codec_pref *pref, iax2_format formats, int find_best)
1637 {
1638         struct ast_format_cap *cap;
1639         struct ast_format tmpfmt;
1640         iax2_format format = 0;
1641         if ((cap = ast_format_cap_alloc_nolock())) {
1642                 ast_format_clear(&tmpfmt);
1643                 ast_format_cap_from_old_bitfield(cap, formats);
1644                 ast_codec_choose(pref, cap, find_best, &tmpfmt);
1645                 format = ast_format_to_old_bitfield(&tmpfmt);
1646                 cap = ast_format_cap_destroy(cap);
1647         }
1648
1649         return format;
1650 }
1651
1652 static iax2_format iax2_best_codec(iax2_format formats)
1653 {
1654         struct ast_format_cap *cap = ast_format_cap_alloc_nolock();
1655         struct ast_format tmpfmt;
1656         if (!cap) {
1657                 return 0;
1658         }
1659
1660         ast_format_clear(&tmpfmt);
1661         ast_format_cap_from_old_bitfield(cap, formats);
1662         ast_best_codec(cap, &tmpfmt);
1663         cap = ast_format_cap_destroy(cap);
1664         return ast_format_to_old_bitfield(&tmpfmt);
1665 }
1666
1667 const char *iax2_getformatname(iax2_format format)
1668 {
1669         struct ast_format tmpfmt;
1670         if (!(ast_format_from_old_bitfield(&tmpfmt, format))) {
1671                 return "Unknown";
1672         }
1673
1674         return ast_getformatname(&tmpfmt);
1675 }
1676
1677 static char *iax2_getformatname_multiple(char *codec_buf, size_t len, iax2_format format)
1678 {
1679         struct ast_format_cap *cap = ast_format_cap_alloc_nolock();
1680
1681         if (!cap) {
1682                 return "(Nothing)";
1683         }
1684         ast_format_cap_from_old_bitfield(cap, format);
1685         ast_getformatname_multiple(codec_buf, len, cap);
1686         cap = ast_format_cap_destroy(cap);
1687
1688         return codec_buf;
1689 }
1690
1691 static int iax2_parse_allow_disallow(struct ast_codec_pref *pref, iax2_format *formats, const char *list, int allowing)
1692 {
1693         int res;
1694         struct ast_format_cap *cap = ast_format_cap_alloc_nolock();
1695         if (!cap) {
1696                 return 1;
1697         }
1698
1699         ast_format_cap_from_old_bitfield(cap, *formats);
1700         res = ast_parse_allow_disallow(pref, cap, list, allowing);
1701         *formats = ast_format_cap_to_old_bitfield(cap);
1702         cap = ast_format_cap_destroy(cap);
1703
1704         return res;
1705 }
1706
1707 static int iax2_data_add_codecs(struct ast_data *root, const char *node_name, iax2_format formats)
1708 {
1709         int res;
1710         struct ast_format_cap *cap = ast_format_cap_alloc_nolock();
1711         if (!cap) {
1712                 return -1;
1713         }
1714         ast_format_cap_from_old_bitfield(cap, formats);
1715         res = ast_data_add_codecs(root, node_name, cap);
1716         cap = ast_format_cap_destroy(cap);
1717         return res;
1718 }
1719
1720 /*!
1721  * \note The only member of the peer passed here guaranteed to be set is the name field
1722  */
1723 static int peer_hash_cb(const void *obj, const int flags)
1724 {
1725         const struct iax2_peer *peer = obj;
1726         const char *name = obj;
1727
1728         return ast_str_hash(flags & OBJ_KEY ? name : peer->name);
1729 }
1730
1731 /*!
1732  * \note The only member of the peer passed here guaranteed to be set is the name field
1733  */
1734 static int peer_cmp_cb(void *obj, void *arg, int flags)
1735 {
1736         struct iax2_peer *peer = obj, *peer2 = arg;
1737         const char *name = arg;
1738
1739         return !strcmp(peer->name, flags & OBJ_KEY ? name : peer2->name) ?
1740                         CMP_MATCH | CMP_STOP : 0;
1741 }
1742
1743 /*!
1744  * \note The only member of the user passed here guaranteed to be set is the name field
1745  */
1746 static int user_hash_cb(const void *obj, const int flags)
1747 {
1748         const struct iax2_user *user = obj;
1749         const char *name = obj;
1750
1751         return ast_str_hash(flags & OBJ_KEY ? name : user->name);
1752 }
1753
1754 /*!
1755  * \note The only member of the user passed here guaranteed to be set is the name field
1756  */
1757 static int user_cmp_cb(void *obj, void *arg, int flags)
1758 {
1759         struct iax2_user *user = obj, *user2 = arg;
1760         const char *name = arg;
1761
1762         return !strcmp(user->name, flags & OBJ_KEY ? name : user2->name) ?
1763                         CMP_MATCH | CMP_STOP : 0;
1764 }
1765
1766 /*!
1767  * \note This funtion calls realtime_peer -> reg_source_db -> iax2_poke_peer -> find_callno,
1768  *       so do not call it with a pvt lock held.
1769  */
1770 static struct iax2_peer *find_peer(const char *name, int realtime) 
1771 {
1772         struct iax2_peer *peer = NULL;
1773
1774         peer = ao2_find(peers, name, OBJ_KEY);
1775
1776         /* Now go for realtime if applicable */
1777         if(!peer && realtime)
1778                 peer = realtime_peer(name, NULL);
1779
1780         return peer;
1781 }
1782
1783 static struct iax2_peer *peer_ref(struct iax2_peer *peer)
1784 {
1785         ao2_ref(peer, +1);
1786         return peer;
1787 }
1788
1789 static inline struct iax2_peer *peer_unref(struct iax2_peer *peer)
1790 {
1791         ao2_ref(peer, -1);
1792         return NULL;
1793 }
1794
1795 static struct iax2_user *find_user(const char *name)
1796 {
1797         return ao2_find(users, name, OBJ_KEY);
1798 }
1799 static inline struct iax2_user *user_ref(struct iax2_user *user)
1800 {
1801         ao2_ref(user, +1);
1802         return user;
1803 }
1804
1805 static inline struct iax2_user *user_unref(struct iax2_user *user)
1806 {
1807         ao2_ref(user, -1);
1808         return NULL;
1809 }
1810
1811 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len)
1812 {
1813         struct iax2_peer *peer = NULL;
1814         int res = 0;
1815         struct ao2_iterator i;
1816
1817         i = ao2_iterator_init(peers, 0);
1818         while ((peer = ao2_iterator_next(&i))) {
1819                 struct sockaddr_in peer_addr;
1820
1821                 ast_sockaddr_to_sin(&peer->addr, &peer_addr);
1822
1823                 if ((peer_addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1824                     (peer_addr.sin_port == sin.sin_port)) {
1825                         ast_copy_string(host, peer->name, len);
1826                         peer_unref(peer);
1827                         res = 1;
1828                         break;
1829                 }
1830                 peer_unref(peer);
1831         }
1832         ao2_iterator_destroy(&i);
1833
1834         if (!peer) {
1835                 peer = realtime_peer(NULL, &sin);
1836                 if (peer) {
1837                         ast_copy_string(host, peer->name, len);
1838                         peer_unref(peer);
1839                         res = 1;
1840                 }
1841         }
1842
1843         return res;
1844 }
1845
1846 /*!\note Assumes the lock on the pvt is already held, when
1847  * iax2_destroy_helper() is called. */
1848 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1849 {
1850         /* Decrement AUTHREQ count if needed */
1851         if (ast_test_flag64(pvt, IAX_MAXAUTHREQ)) {
1852                 struct iax2_user *user;
1853
1854                 user = ao2_find(users, pvt->username, OBJ_KEY);
1855                 if (user) {
1856                         ast_atomic_fetchadd_int(&user->curauthreq, -1);
1857                         user_unref(user);
1858                 }
1859
1860                 ast_clear_flag64(pvt, IAX_MAXAUTHREQ);
1861         }
1862         /* No more pings or lagrq's */
1863         AST_SCHED_DEL_SPINLOCK(sched, pvt->pingid, &iaxsl[pvt->callno]);
1864         pvt->pingid = DONT_RESCHEDULE;
1865         AST_SCHED_DEL_SPINLOCK(sched, pvt->lagid, &iaxsl[pvt->callno]);
1866         pvt->lagid = DONT_RESCHEDULE;
1867         AST_SCHED_DEL(sched, pvt->autoid);
1868         AST_SCHED_DEL(sched, pvt->authid);
1869         AST_SCHED_DEL(sched, pvt->initid);
1870         AST_SCHED_DEL(sched, pvt->jbid);
1871         AST_SCHED_DEL(sched, pvt->keyrotateid);
1872 }
1873
1874 static void iax2_frame_free(struct iax_frame *fr)
1875 {
1876         AST_SCHED_DEL(sched, fr->retrans);
1877         iax_frame_free(fr);
1878 }
1879
1880 static int scheduled_destroy(const void *vid)
1881 {
1882         unsigned short callno = PTR_TO_CALLNO(vid);
1883         ast_mutex_lock(&iaxsl[callno]);
1884         if (iaxs[callno]) {
1885                 ast_debug(1, "Really destroying %d now...\n", callno);
1886                 iax2_destroy(callno);
1887         }
1888         ast_mutex_unlock(&iaxsl[callno]);
1889         return 0;
1890 }
1891
1892 static void free_signaling_queue_entry(struct signaling_queue_entry *s)
1893 {
1894         if (s->f.datalen) {
1895                 ast_free(s->f.data.ptr);
1896         }
1897         ast_free(s);
1898 }
1899
1900 /*! \brief This function must be called once we are sure the other side has
1901  *  given us a call number.  All signaling is held here until that point. */
1902 static void send_signaling(struct chan_iax2_pvt *pvt)
1903 {
1904         struct signaling_queue_entry *s = NULL;
1905
1906         while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
1907                 iax2_send(pvt, &s->f, 0, -1, 0, 0, 0);
1908                 free_signaling_queue_entry(s);
1909         }
1910         pvt->hold_signaling = 0;
1911 }
1912
1913 /*! \brief All frames other than that of type AST_FRAME_IAX must be held until
1914  *  we have received a destination call number. */
1915 static int queue_signalling(struct chan_iax2_pvt *pvt, struct ast_frame *f)
1916 {
1917         struct signaling_queue_entry *new;
1918
1919         if (f->frametype == AST_FRAME_IAX || !pvt->hold_signaling) {
1920                 return 1; /* do not queue this frame */
1921         } else if (!(new = ast_calloc(1, sizeof(struct signaling_queue_entry)))) {
1922                 return -1;  /* out of memory */
1923         }
1924
1925         memcpy(&new->f, f, sizeof(new->f)); /* copy ast_frame into our queue entry */
1926
1927         if (new->f.datalen) { /* if there is data in this frame copy it over as well */
1928                 if (!(new->f.data.ptr = ast_calloc(1, new->f.datalen))) {
1929                         free_signaling_queue_entry(new);
1930                         return -1;
1931                 }
1932                 memcpy(new->f.data.ptr, f->data.ptr, sizeof(*new->f.data.ptr));
1933         }
1934         AST_LIST_INSERT_TAIL(&pvt->signaling_queue, new, next);
1935
1936         return 0;
1937 }
1938
1939 static void pvt_destructor(void *obj)
1940 {
1941         struct chan_iax2_pvt *pvt = obj;
1942         struct iax_frame *cur = NULL;
1943         struct signaling_queue_entry *s = NULL;
1944
1945         ast_mutex_lock(&iaxsl[pvt->callno]);
1946
1947         iax2_destroy_helper(pvt);
1948
1949         sched_delay_remove(&pvt->addr, pvt->callno_entry);
1950         pvt->callno_entry = NULL;
1951
1952         /* Already gone */
1953         ast_set_flag64(pvt, IAX_ALREADYGONE);
1954
1955         AST_LIST_TRAVERSE(&frame_queue[pvt->callno], cur, list) {
1956                 /* Cancel any pending transmissions */
1957                 cur->retries = -1;
1958         }
1959
1960         ast_mutex_unlock(&iaxsl[pvt->callno]);
1961
1962         while ((s = AST_LIST_REMOVE_HEAD(&pvt->signaling_queue, next))) {
1963                 free_signaling_queue_entry(s);
1964         }
1965
1966         if (pvt->reg) {
1967                 pvt->reg->callno = 0;
1968         }
1969
1970         if (!pvt->owner) {
1971                 jb_frame frame;
1972                 if (pvt->vars) {
1973                     ast_variables_destroy(pvt->vars);
1974                     pvt->vars = NULL;
1975                 }
1976
1977                 while (jb_getall(pvt->jb, &frame) == JB_OK) {
1978                         iax2_frame_free(frame.data);
1979                 }
1980
1981                 jb_destroy(pvt->jb);
1982                 ast_string_field_free_memory(pvt);
1983         }
1984 }
1985
1986 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, const char *host)
1987 {
1988         struct chan_iax2_pvt *tmp;
1989         jb_conf jbconf;
1990
1991         if (!(tmp = ao2_alloc(sizeof(*tmp), pvt_destructor))) {
1992                 return NULL;
1993         }
1994
1995         if (ast_string_field_init(tmp, 32)) {
1996                 ao2_ref(tmp, -1);
1997                 tmp = NULL;
1998                 return NULL;
1999         }
2000                 
2001         tmp->prefs = prefs;
2002         tmp->pingid = -1;
2003         tmp->lagid = -1;
2004         tmp->autoid = -1;
2005         tmp->authid = -1;
2006         tmp->initid = -1;
2007         tmp->keyrotateid = -1;
2008
2009         ast_string_field_set(tmp,exten, "s");
2010         ast_string_field_set(tmp,host, host);
2011
2012         tmp->jb = jb_new();
2013         tmp->jbid = -1;
2014         jbconf.max_jitterbuf = maxjitterbuffer;
2015         jbconf.resync_threshold = resyncthreshold;
2016         jbconf.max_contig_interp = maxjitterinterps;
2017         jbconf.target_extra = jittertargetextra;
2018         jb_setconf(tmp->jb,&jbconf);
2019
2020         AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
2021
2022         tmp->hold_signaling = 1;
2023         AST_LIST_HEAD_INIT_NOLOCK(&tmp->signaling_queue);
2024
2025         return tmp;
2026 }
2027
2028 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
2029 {
2030         struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
2031         if (new) {
2032                 size_t afdatalen = new->afdatalen;
2033                 memcpy(new, fr, sizeof(*new));
2034                 iax_frame_wrap(new, &fr->af);
2035                 new->afdatalen = afdatalen;
2036                 new->data = NULL;
2037                 new->datalen = 0;
2038                 new->direction = DIRECTION_INGRESS;
2039                 new->retrans = -1;
2040         }
2041         return new;
2042 }
2043 /* keep these defined in this order.  They are used in find_callno to
2044  * determine whether or not a new call number should be allowed. */
2045 enum {
2046         /* do not allow a new call number, only search ones in use for match */
2047         NEW_PREVENT = 0,
2048         /* search for match first, then allow a new one to be allocated */
2049         NEW_ALLOW = 1,
2050         /* do not search for match, force a new call number */
2051         NEW_FORCE = 2,
2052         /* do not search for match, force a new call number.  Signifies call number
2053          * has been calltoken validated */
2054         NEW_ALLOW_CALLTOKEN_VALIDATED = 3,
2055 };
2056
2057 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur, int check_dcallno)
2058 {
2059         if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2060                 (cur->addr.sin_port == sin->sin_port)) {
2061                 /* This is the main host */
2062                 if ( (cur->peercallno == 0 || cur->peercallno == callno) &&
2063                          (check_dcallno ? dcallno == cur->callno : 1) ) {
2064                         /* That's us.  Be sure we keep track of the peer call number */
2065                         return 1;
2066                 }
2067         }
2068         if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2069             (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
2070                 /* We're transferring */
2071                 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
2072                         return 1;
2073         }
2074         return 0;
2075 }
2076
2077 static int make_trunk(unsigned short callno, int locked)
2078 {
2079         int x;
2080         int res= 0;
2081         struct callno_entry *callno_entry;
2082         if (iaxs[callno]->oseqno) {
2083                 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
2084                 return -1;
2085         }
2086         if (callno & TRUNK_CALL_START) {
2087                 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
2088                 return -1;
2089         }
2090
2091         if (!(callno_entry = get_unused_callno(1, iaxs[callno]->callno_entry->validated))) {
2092                 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
2093                 return -1;
2094         }
2095
2096         x = callno_entry->callno;
2097         ast_mutex_lock(&iaxsl[x]);
2098
2099         /*!
2100          * \note We delete these before switching the slot, because if
2101          * they fire in the meantime, they will generate a warning.
2102          */
2103         AST_SCHED_DEL(sched, iaxs[callno]->pingid);
2104         AST_SCHED_DEL(sched, iaxs[callno]->lagid);
2105         iaxs[callno]->lagid = iaxs[callno]->pingid = -1;
2106         iaxs[x] = iaxs[callno];
2107         iaxs[x]->callno = x;
2108
2109         /* since we copied over the pvt from a different callno, make sure the old entry is replaced
2110          * before assigning the new one */
2111         if (iaxs[x]->callno_entry) {
2112                 iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, iaxs[x]->callno_entry);
2113         }
2114         iaxs[x]->callno_entry = callno_entry;
2115
2116         iaxs[callno] = NULL;
2117         /* Update the two timers that should have been started */
2118         iaxs[x]->pingid = iax2_sched_add(sched, 
2119                 ping_time * 1000, send_ping, (void *)(long)x);
2120         iaxs[x]->lagid = iax2_sched_add(sched, 
2121                 lagrq_time * 1000, send_lagrq, (void *)(long)x);
2122
2123         if (locked)
2124                 ast_mutex_unlock(&iaxsl[callno]);
2125         res = x;
2126         if (!locked)
2127                 ast_mutex_unlock(&iaxsl[x]);
2128
2129         /* We moved this call from a non-trunked to a trunked call */
2130         ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
2131
2132         return res;
2133 }
2134
2135 static void store_by_transfercallno(struct chan_iax2_pvt *pvt)
2136 {
2137         if (!pvt->transfercallno) {
2138                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2139                 return;
2140         }
2141
2142         ao2_link(iax_transfercallno_pvts, pvt);
2143 }
2144
2145 static void remove_by_transfercallno(struct chan_iax2_pvt *pvt)
2146 {
2147         if (!pvt->transfercallno) {
2148                 ast_log(LOG_ERROR, "This should not be called without a transfer call number.\n");
2149                 return;
2150         }
2151
2152         ao2_unlink(iax_transfercallno_pvts, pvt);
2153 }
2154 static void store_by_peercallno(struct chan_iax2_pvt *pvt)
2155 {
2156         if (!pvt->peercallno) {
2157                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2158                 return;
2159         }
2160
2161         ao2_link(iax_peercallno_pvts, pvt);
2162 }
2163
2164 static void remove_by_peercallno(struct chan_iax2_pvt *pvt)
2165 {
2166         if (!pvt->peercallno) {
2167                 ast_log(LOG_ERROR, "This should not be called without a peer call number.\n");
2168                 return;
2169         }
2170
2171         ao2_unlink(iax_peercallno_pvts, pvt);
2172 }
2173
2174 static int addr_range_delme_cb(void *obj, void *arg, int flags)
2175 {
2176         struct addr_range *lim = obj;
2177         lim->delme = 1;
2178         return 0;
2179 }
2180
2181 static int addr_range_hash_cb(const void *obj, const int flags)
2182 {
2183         const struct addr_range *lim = obj;
2184         struct sockaddr_in sin;
2185         ast_sockaddr_to_sin(&lim->ha.addr, &sin);
2186         return abs((int) sin.sin_addr.s_addr);
2187 }
2188
2189 static int addr_range_cmp_cb(void *obj, void *arg, int flags)
2190 {
2191         struct addr_range *lim1 = obj, *lim2 = arg;
2192         return (!(ast_sockaddr_cmp_addr(&lim1->ha.addr, &lim2->ha.addr)) &&
2193                         !(ast_sockaddr_cmp_addr(&lim1->ha.netmask, &lim2->ha.netmask))) ?
2194                         CMP_MATCH | CMP_STOP : 0;
2195 }
2196
2197 static int peercnt_hash_cb(const void *obj, const int flags)
2198 {
2199         const struct peercnt *peercnt = obj;
2200         return abs((int) peercnt->addr);
2201 }
2202
2203 static int peercnt_cmp_cb(void *obj, void *arg, int flags)
2204 {
2205         struct peercnt *peercnt1 = obj, *peercnt2 = arg;
2206         return (peercnt1->addr == peercnt2->addr) ? CMP_MATCH | CMP_STOP : 0;
2207 }
2208
2209 static int addr_range_match_address_cb(void *obj, void *arg, int flags)
2210 {
2211         struct addr_range *addr_range = obj;
2212         struct sockaddr_in *sin = arg;
2213         struct sockaddr_in ha_netmask_sin;
2214         struct sockaddr_in ha_addr_sin;
2215
2216         ast_sockaddr_to_sin(&addr_range->ha.netmask, &ha_netmask_sin);
2217         ast_sockaddr_to_sin(&addr_range->ha.addr, &ha_addr_sin);
2218
2219         if ((sin->sin_addr.s_addr & ha_netmask_sin.sin_addr.s_addr) == ha_addr_sin.sin_addr.s_addr) {
2220                 return CMP_MATCH | CMP_STOP;
2221         }
2222         return 0;
2223 }
2224
2225 /*! 
2226  * \internal
2227  *
2228  * \brief compares sin to calltoken_ignores table to determine if validation is required.
2229  */
2230 static int calltoken_required(struct sockaddr_in *sin, const char *name, int subclass)
2231 {
2232         struct addr_range *addr_range;
2233         struct iax2_peer *peer = NULL;
2234         struct iax2_user *user = NULL;
2235         /* if no username is given, check for guest accounts */
2236         const char *find = S_OR(name, "guest");
2237         int res = 1;  /* required by default */
2238         int optional = 0;
2239         enum calltoken_peer_enum calltoken_required = CALLTOKEN_DEFAULT;
2240         /* There are only two cases in which calltoken validation is not required.
2241          * Case 1. sin falls within the list of address ranges specified in the calltoken optional table and
2242          *         the peer definition has not set the requirecalltoken option.
2243          * Case 2. Username is a valid peer/user, and that peer has requirecalltoken set either auto or no.
2244          */
2245
2246         /* ----- Case 1 ----- */
2247         if ((addr_range = ao2_callback(calltoken_ignores, 0, addr_range_match_address_cb, sin))) {
2248                 ao2_ref(addr_range, -1);
2249                 optional = 1;
2250         }
2251
2252         /* ----- Case 2 ----- */
2253         if ((subclass == IAX_COMMAND_NEW) && (user = find_user(find))) {
2254                 calltoken_required = user->calltoken_required;
2255         } else if ((subclass == IAX_COMMAND_NEW) && (user = realtime_user(find, sin))) {
2256                 calltoken_required = user->calltoken_required;
2257         } else if ((subclass != IAX_COMMAND_NEW) && (peer = find_peer(find, 0))) {
2258                 calltoken_required = peer->calltoken_required;
2259         } else if ((subclass != IAX_COMMAND_NEW) && (peer = realtime_peer(find, sin))) {
2260                 calltoken_required = peer->calltoken_required;
2261         }
2262
2263         if (peer) {
2264                 peer_unref(peer);
2265         }
2266         if (user) {
2267                 user_unref(user);
2268         }
2269
2270         ast_debug(1, "Determining if address %s with username %s requires calltoken validation.  Optional = %d  calltoken_required = %d \n", ast_inet_ntoa(sin->sin_addr), name, optional, calltoken_required);
2271         if (((calltoken_required == CALLTOKEN_NO) || (calltoken_required == CALLTOKEN_AUTO)) ||
2272                 (optional && (calltoken_required == CALLTOKEN_DEFAULT))) {
2273                 res = 0;
2274         }
2275
2276         return res;
2277 }
2278
2279 /*! 
2280  * \internal
2281  *
2282  * \brief set peercnt callno limit.
2283  *
2284  * \details 
2285  * First looks in custom definitions. If not found, global limit
2286  * is used.  Entries marked as reg already have
2287  * a custom limit set by a registration and are not modified.
2288  */
2289 static void set_peercnt_limit(struct peercnt *peercnt)
2290 {
2291         uint16_t limit = global_maxcallno;
2292         struct addr_range *addr_range;
2293         struct sockaddr_in sin = {
2294                 .sin_addr.s_addr = peercnt->addr,
2295         };
2296
2297
2298         if (peercnt->reg && peercnt->limit) {
2299                 return; /* this peercnt has a custom limit set by a registration */
2300         }
2301
2302         if ((addr_range = ao2_callback(callno_limits, 0, addr_range_match_address_cb, &sin))) {
2303                 limit = addr_range->limit;
2304                 ast_debug(1, "custom addr_range %d found for %s\n", limit, ast_inet_ntoa(sin.sin_addr));
2305                 ao2_ref(addr_range, -1);
2306         }
2307
2308         peercnt->limit = limit;
2309 }
2310
2311 /*! 
2312  * \internal
2313  * \brief sets limits for all peercnts in table. done on reload to reflect changes in conf.
2314  */
2315 static int set_peercnt_limit_all_cb(void *obj, void *arg, int flags)
2316 {
2317         struct peercnt *peercnt = obj;
2318
2319         set_peercnt_limit(peercnt);
2320         ast_debug(1, "Reset limits for peercnts table\n");
2321
2322         return 0;
2323 }
2324
2325 /*! 
2326  * \internal
2327  * \brief returns match if delme is set. 
2328  */
2329 static int prune_addr_range_cb(void *obj, void *arg, int flags)
2330 {
2331         struct addr_range *addr_range = obj;
2332
2333         return addr_range->delme ? CMP_MATCH : 0;
2334 }
2335
2336 /*! 
2337  * \internal
2338  * \brief modifies peercnt entry in peercnts table. Used to set custom limit or mark a registered ip
2339  */
2340 static void peercnt_modify(unsigned char reg, uint16_t limit, struct ast_sockaddr *sockaddr)
2341 {
2342         /* this function turns off and on custom callno limits set by peer registration */
2343         struct peercnt *peercnt;
2344         struct peercnt tmp = {
2345                 .addr = 0,
2346         };
2347         struct sockaddr_in sin;
2348
2349         ast_sockaddr_to_sin(sockaddr, &sin);
2350
2351         tmp.addr = sin.sin_addr.s_addr;
2352
2353         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2354                 peercnt->reg = reg;
2355                 if (limit) {
2356                         peercnt->limit = limit;
2357                 } else {
2358                         set_peercnt_limit(peercnt);
2359                 }
2360                 ast_debug(1, "peercnt entry %s modified limit:%d registered:%d", ast_inet_ntoa(sin.sin_addr), peercnt->limit, peercnt->reg);
2361                 ao2_ref(peercnt, -1); /* decrement ref from find */
2362         }
2363 }
2364
2365 /*! 
2366  * \internal
2367  * \brief adds an ip to the peercnts table, increments connection count if it already exists
2368  *
2369  * \details First searches for the address in the peercnts table.  If found
2370  * the current count is incremented.  If not found a new peercnt is allocated
2371  * and linked into the peercnts table with a call number count of 1.
2372  */
2373 static int peercnt_add(struct sockaddr_in *sin)
2374 {
2375         struct peercnt *peercnt;
2376         unsigned long addr = sin->sin_addr.s_addr;
2377         int res = 0;
2378         struct peercnt tmp = {
2379                 .addr = addr,
2380         };
2381
2382         /* Reasoning for peercnts container lock:  Two identical ip addresses
2383          * could be added by different threads at the "same time". Without the container
2384          * lock, both threads could alloc space for the same object and attempt
2385          * to link to table.  With the lock, one would create the object and link
2386          * to table while the other would find the already created peercnt object
2387          * rather than creating a new one. */
2388         ao2_lock(peercnts);
2389         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2390                 ao2_lock(peercnt);
2391         } else if ((peercnt = ao2_alloc(sizeof(*peercnt), NULL))) {
2392                 ao2_lock(peercnt);
2393                 /* create and set defaults */
2394                 peercnt->addr = addr;
2395                 set_peercnt_limit(peercnt);
2396                 /* guarantees it does not go away after unlocking table
2397                  * ao2_find automatically adds this */
2398                 ao2_link(peercnts, peercnt);
2399         } else {
2400                 ao2_unlock(peercnts);
2401                 return -1;
2402         }
2403
2404         /* check to see if the address has hit its callno limit.  If not increment cur. */
2405         if (peercnt->limit > peercnt->cur) {
2406                 peercnt->cur++;
2407                 ast_debug(1, "ip callno count incremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin->sin_addr));
2408         } else { /* max num call numbers for this peer has been reached! */
2409                 ast_log(LOG_ERROR, "maxcallnumber limit of %d for %s has been reached!\n", peercnt->limit, ast_inet_ntoa(sin->sin_addr));
2410                 res = -1;
2411         }
2412
2413         /* clean up locks and ref count */
2414         ao2_unlock(peercnt);
2415         ao2_unlock(peercnts);
2416         ao2_ref(peercnt, -1); /* decrement ref from find/alloc, only the container ref remains. */
2417
2418         return res;
2419 }
2420
2421 /*! 
2422  * \internal
2423  * \brief decrements a peercnts table entry
2424  */
2425 static void peercnt_remove(struct peercnt *peercnt)
2426 {
2427         struct sockaddr_in sin = {
2428                 .sin_addr.s_addr = peercnt->addr,
2429         };
2430
2431         if (peercnt) {
2432                 /* Container locked here since peercnt may be unlinked from list.  If left unlocked,
2433                  * peercnt_add could try and grab this entry from the table and modify it at the
2434                  * "same time" this thread attemps to unlink it.*/
2435                 ao2_lock(peercnts);
2436                 peercnt->cur--;
2437                 ast_debug(1, "ip callno count decremented to %d for %s\n", peercnt->cur, ast_inet_ntoa(sin.sin_addr));
2438                 /* if this was the last connection from the peer remove it from table */
2439                 if (peercnt->cur == 0) {
2440                         ao2_unlink(peercnts, peercnt);/* decrements ref from table, last ref is left to scheduler */
2441                 }
2442                 ao2_unlock(peercnts);
2443         }
2444 }
2445
2446 /*! 
2447  * \internal
2448  * \brief called by scheduler to decrement object
2449  */
2450 static int peercnt_remove_cb(const void *obj)
2451 {
2452         struct peercnt *peercnt = (struct peercnt *) obj;
2453
2454         peercnt_remove(peercnt);
2455         ao2_ref(peercnt, -1); /* decrement ref from scheduler */
2456
2457         return 0;
2458 }
2459
2460 /*! 
2461  * \internal
2462  * \brief decrements peercnts connection count, finds by addr
2463  */
2464 static int peercnt_remove_by_addr(struct sockaddr_in *sin)
2465 {
2466         struct peercnt *peercnt;
2467         struct peercnt tmp = {
2468                 .addr = sin->sin_addr.s_addr,
2469         };
2470
2471         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2472                 peercnt_remove(peercnt);
2473                 ao2_ref(peercnt, -1); /* decrement ref from find */
2474         }
2475         return 0;
2476 }
2477
2478 /*! 
2479  * \internal
2480  * \brief Create callno_limit entry based on configuration
2481  */
2482 static void build_callno_limits(struct ast_variable *v)
2483 {
2484         struct addr_range *addr_range = NULL;
2485         struct addr_range tmp;
2486         struct ast_ha *ha;
2487         int limit;
2488         int error;
2489         int found;
2490
2491         for (; v; v = v->next) {
2492                 limit = -1;
2493                 error = 0;
2494                 found = 0;
2495                 ha = ast_append_ha("permit", v->name, NULL, &error);
2496
2497                 /* check for valid config information */
2498                 if (error) {
2499                         ast_log(LOG_ERROR, "Call number limit for %s could not be added, Invalid address range\n.", v->name);
2500                         continue;
2501                 } else if ((sscanf(v->value, "%d", &limit) != 1) || (limit < 0)) {
2502                         ast_log(LOG_ERROR, "Call number limit for %s could not be added. Invalid limit %s\n.", v->name, v->value);
2503                         ast_free_ha(ha);
2504                         continue;
2505                 }
2506
2507                 ast_copy_ha(ha, &tmp.ha);
2508                 /* find or create the addr_range */
2509                 if ((addr_range = ao2_find(callno_limits, &tmp, OBJ_POINTER))) {
2510                         ao2_lock(addr_range);
2511                         found = 1;
2512                 } else if (!(addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2513                         ast_free_ha(ha);
2514                         return; /* out of memory */
2515                 }
2516
2517                 /* copy over config data into addr_range object */
2518                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible for each limit */
2519                 ast_free_ha(ha); /* cleanup the tmp ha */
2520                 addr_range->limit = limit;
2521                 addr_range->delme = 0;
2522
2523                 /* cleanup */
2524                 if (found) {
2525                         ao2_unlock(addr_range);
2526                 } else {
2527                         ao2_link(callno_limits, addr_range);
2528                 }
2529                 ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2530         }
2531 }
2532
2533 /*! 
2534  * \internal
2535  * \brief Create calltoken_ignores entry based on configuration
2536  */
2537 static int add_calltoken_ignore(const char *addr)
2538 {
2539         struct addr_range tmp;
2540         struct addr_range *addr_range = NULL;
2541         struct ast_ha *ha = NULL;
2542         int error = 0;
2543
2544         if (ast_strlen_zero(addr)) {
2545                 ast_log(LOG_WARNING, "invalid calltokenoptional %s\n", addr);
2546                 return -1;
2547         }
2548
2549         ha = ast_append_ha("permit", addr, NULL, &error);
2550
2551         /* check for valid config information */
2552         if (error) {
2553                 ast_log(LOG_WARNING, "Error %d creating calltokenoptional entry %s\n", error, addr);
2554                 return -1;
2555         }
2556
2557         ast_copy_ha(ha, &tmp.ha);
2558         /* find or create the addr_range */
2559         if ((addr_range = ao2_find(calltoken_ignores, &tmp, OBJ_POINTER))) {
2560                 ao2_lock(addr_range);
2561                 addr_range->delme = 0;
2562                 ao2_unlock(addr_range);
2563         } else if ((addr_range = ao2_alloc(sizeof(*addr_range), NULL))) {
2564                 /* copy over config data into addr_range object */
2565                 ast_copy_ha(ha, &addr_range->ha); /* this is safe because only one ha is possible */
2566                 ao2_link(calltoken_ignores, addr_range);
2567         } else {
2568                 ast_free_ha(ha);
2569                 return -1;
2570         }
2571
2572         ast_free_ha(ha);
2573         ao2_ref(addr_range, -1); /* decrement ref from ao2_find and ao2_alloc, only container ref remains */
2574
2575         return 0;
2576 }
2577
2578 static char *handle_cli_iax2_show_callno_limits(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a)
2579 {
2580         struct ao2_iterator i;
2581         struct peercnt *peercnt;
2582         struct sockaddr_in sin;
2583         int found = 0;
2584
2585         switch (cmd) {
2586         case CLI_INIT:
2587                 e->command = "iax2 show callnumber usage";
2588                 e->usage =
2589                         "Usage: iax2 show callnumber usage [IP address]\n"
2590                         "       Shows current IP addresses which are consuming iax2 call numbers\n";
2591                 return NULL;
2592         case CLI_GENERATE:
2593                 return NULL;
2594         case CLI_HANDLER:
2595                 if (a->argc < 4 || a->argc > 5)
2596                         return CLI_SHOWUSAGE;
2597
2598                 ast_cli(a->fd, "%-15s %-12s %-12s\n", "Address", "Callno Usage", "Callno Limit");
2599                 i = ao2_iterator_init(peercnts, 0);
2600                 while ((peercnt = ao2_iterator_next(&i))) {
2601                         sin.sin_addr.s_addr = peercnt->addr;
2602                         if (a->argc == 5 && (!strcasecmp(a->argv[4], ast_inet_ntoa(sin.sin_addr)))) {
2603                                         ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
2604                                         ao2_ref(peercnt, -1);
2605                                         found = 1;
2606                                         break;
2607                         } else {
2608                                 ast_cli(a->fd, "%-15s %-12d %-12d\n", ast_inet_ntoa(sin.sin_addr), peercnt->cur, peercnt->limit);
2609                         }
2610                         ao2_ref(peercnt, -1);
2611                 }
2612                 ao2_iterator_destroy(&i);
2613
2614                 if (a->argc == 4) {
2615                         ast_cli(a->fd, "\nNon-CallToken Validation Callno Limit: %d\n"
2616                                          "Non-CallToken Validated Callno Used:   %d\n",
2617                                 global_maxcallno_nonval,
2618                                 total_nonval_callno_used);
2619
2620                         ast_cli(a->fd,   "Total Available Callno:                %d\n"
2621                                          "Regular Callno Available:              %d\n"
2622                                          "Trunk Callno Available:                %d\n",
2623                                 ao2_container_count(callno_pool) + ao2_container_count(callno_pool_trunk),
2624                                 ao2_container_count(callno_pool),
2625                                 ao2_container_count(callno_pool_trunk));
2626                 } else if (a->argc == 5 && !found) {
2627                         ast_cli(a->fd, "No callnumber table entries for %s found\n", a->argv[4] );
2628                 }
2629
2630
2631                 return CLI_SUCCESS;
2632         default:
2633                 return NULL;
2634         }
2635 }
2636
2637 static struct callno_entry *get_unused_callno(int trunk, int validated)
2638 {
2639         struct callno_entry *callno_entry = NULL;
2640         if ((!ao2_container_count(callno_pool) && !trunk) || (!ao2_container_count(callno_pool_trunk) && trunk)) {
2641                 ast_log(LOG_WARNING, "Out of CallNumbers\n");
2642                 /* Minor optimization for the extreme case. */
2643                 return NULL;
2644         }
2645
2646         /* the callno_pool container is locked here primarily to ensure thread
2647          * safety of the total_nonval_callno_used check and increment */
2648         ao2_lock(callno_pool);
2649
2650         /* only a certain number of nonvalidated call numbers should be allocated.
2651          * If there ever is an attack, this separates the calltoken validating
2652          * users from the non calltoken validating users. */
2653         if (!validated && (total_nonval_callno_used >= global_maxcallno_nonval)) {
2654                 ast_log(LOG_WARNING, "NON-CallToken callnumber limit is reached. Current:%d Max:%d\n", total_nonval_callno_used, global_maxcallno_nonval);
2655                 ao2_unlock(callno_pool);
2656                 return NULL;
2657         }
2658
2659         /* unlink the object from the container, taking over ownership
2660          * of the reference the container had to the object */
2661         callno_entry = ao2_find((trunk ? callno_pool_trunk : callno_pool), NULL, OBJ_POINTER | OBJ_UNLINK | OBJ_CONTINUE);
2662
2663         if (callno_entry) {
2664                 callno_entry->validated = validated;
2665                 if (!validated) {
2666                         total_nonval_callno_used++;
2667                 }
2668         }
2669
2670         ao2_unlock(callno_pool);
2671         return callno_entry;
2672 }
2673
2674 static int replace_callno(const void *obj)
2675 {
2676         struct callno_entry *callno_entry = (struct callno_entry *) obj;
2677
2678         /* the callno_pool container is locked here primarily to ensure thread
2679          * safety of the total_nonval_callno_used check and decrement */
2680         ao2_lock(callno_pool);
2681
2682         if (!callno_entry->validated && (total_nonval_callno_used != 0)) {
2683                 total_nonval_callno_used--;
2684         } else if (!callno_entry->validated && (total_nonval_callno_used == 0)) {
2685                 ast_log(LOG_ERROR, "Attempted to decrement total non calltoken validated callnumbers below zero... Callno is:%d \n", callno_entry->callno);
2686         }
2687
2688         if (callno_entry->callno < TRUNK_CALL_START) {
2689                 ao2_link(callno_pool, callno_entry);
2690         } else {
2691                 ao2_link(callno_pool_trunk, callno_entry);
2692         }
2693         ao2_ref(callno_entry, -1); /* only container ref remains */
2694
2695         ao2_unlock(callno_pool);
2696         return 0;
2697 }
2698
2699 static int callno_hash(const void *obj, const int flags)
2700 {
2701         return abs(ast_random());
2702 }
2703
2704 static int create_callno_pools(void)
2705 {
2706         uint16_t i;
2707
2708         if (!(callno_pool = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
2709                 return -1;
2710         }
2711
2712         if (!(callno_pool_trunk = ao2_container_alloc(CALLNO_POOL_BUCKETS, callno_hash, NULL))) {
2713                 return -1;
2714         }
2715
2716         /* start at 2, 0 and 1 are reserved */
2717         for (i = 2; i <= IAX_MAX_CALLS; i++) {
2718                 struct callno_entry *callno_entry;
2719
2720                 if (!(callno_entry = ao2_alloc(sizeof(*callno_entry), NULL))) {
2721                         return -1;
2722                 }
2723
2724                 callno_entry->callno = i;
2725
2726                 if (i < TRUNK_CALL_START) {
2727                         ao2_link(callno_pool, callno_entry);
2728                 } else {
2729                         ao2_link(callno_pool_trunk, callno_entry);
2730                 }
2731
2732                 ao2_ref(callno_entry, -1);
2733         }
2734
2735         return 0;
2736 }
2737
2738 /*!
2739  * \internal
2740  * \brief Schedules delayed removal of iax2_pvt call number data
2741  *
2742  * \note After MIN_REUSE_TIME has passed for a destroyed iax2_pvt, the callno is
2743  * avaliable again, and the address from the previous connection must be decremented
2744  * from the peercnts table.  This function schedules these operations to take place.
2745  */
2746 static void sched_delay_remove(struct sockaddr_in *sin, struct callno_entry *callno_entry)
2747 {
2748         int i;
2749         struct peercnt *peercnt;
2750         struct peercnt tmp = {
2751                 .addr = sin->sin_addr.s_addr,
2752         };
2753
2754         if ((peercnt = ao2_find(peercnts, &tmp, OBJ_POINTER))) {
2755                 /* refcount is incremented with ao2_find.  keep that ref for the scheduler */
2756                 ast_debug(1, "schedule decrement of callno used for %s in %d seconds\n", ast_inet_ntoa(sin->sin_addr), MIN_REUSE_TIME);
2757                 i = iax2_sched_add(sched, MIN_REUSE_TIME * 1000, peercnt_remove_cb, peercnt);
2758                 if (i == -1) {
2759                         ao2_ref(peercnt, -1);
2760                 }
2761         }
2762
2763         iax2_sched_add(sched, MIN_REUSE_TIME * 1000, replace_callno, callno_entry);
2764 }
2765
2766 /*! 
2767  * \internal
2768  * \brief returns whether or not a frame is capable of starting a new IAX2 dialog. 
2769  *
2770  * \note For this implementation, inbound pokes should _NOT_ be capable of allocating
2771  * a new callno.
2772  */
2773 static inline int attribute_pure iax2_allow_new(int frametype, int subclass, int inbound)
2774 {
2775         if (frametype != AST_FRAME_IAX) {
2776                 return 0;
2777         }
2778         switch (subclass) {
2779         case IAX_COMMAND_NEW:
2780         case IAX_COMMAND_REGREQ:
2781         case IAX_COMMAND_FWDOWNL:
2782         case IAX_COMMAND_REGREL:
2783                 return 1;
2784         case IAX_COMMAND_POKE:
2785                 if (!inbound) {
2786                         return 1;
2787                 }
2788                 break;
2789         }
2790         return 0;
2791 }
2792
2793 /*
2794  * \note Calling this function while holding another pvt lock can cause a deadlock.
2795  */
2796 static int __find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int return_locked, int check_dcallno)
2797 {
2798         int res = 0;
2799         int x;
2800         /* this call is calltoken validated as long as it is either NEW_FORCE
2801          * or NEW_ALLOW_CALLTOKEN_VALIDATED */
2802         int validated = (new > NEW_ALLOW) ? 1 : 0;
2803         char host[80];
2804
2805         if (new <= NEW_ALLOW) {
2806                 if (callno) {
2807                         struct chan_iax2_pvt *pvt;
2808                         struct chan_iax2_pvt tmp_pvt = {
2809                                 .callno = dcallno,
2810                                 .peercallno = callno,
2811                                 .transfercallno = callno,
2812                                 /* hack!! */
2813                                 .frames_received = check_dcallno,
2814                         };
2815
2816                         memcpy(&tmp_pvt.addr, sin, sizeof(tmp_pvt.addr));
2817                         /* this works for finding normal call numbers not involving transfering */ 
2818                         if ((pvt = ao2_find(iax_peercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
2819                                 if (return_locked) {
2820                                         ast_mutex_lock(&iaxsl[pvt->callno]);
2821                                 }
2822                                 res = pvt->callno;
2823                                 ao2_ref(pvt, -1);
2824                                 pvt = NULL;
2825                                 return res;
2826                         }
2827                         /* this searches for transfer call numbers that might not get caught otherwise */
2828                         memset(&tmp_pvt.addr, 0, sizeof(tmp_pvt.addr));
2829                         memcpy(&tmp_pvt.transfer, sin, sizeof(tmp_pvt.transfer));
2830                         if ((pvt = ao2_find(iax_transfercallno_pvts, &tmp_pvt, OBJ_POINTER))) {
2831                                 if (return_locked) {
2832                                         ast_mutex_lock(&iaxsl[pvt->callno]);
2833                                 }
2834                                 res = pvt->callno;
2835                                 ao2_ref(pvt, -1);
2836                                 pvt = NULL;
2837                                 return res;
2838                         }
2839                 }
2840                         /* This will occur on the first response to a message that we initiated,
2841                  * such as a PING. */
2842                 if (dcallno) {
2843                         ast_mutex_lock(&iaxsl[dcallno]);
2844                 }
2845                 if (callno && dcallno && iaxs[dcallno] && !iaxs[dcallno]->peercallno && match(sin, callno, dcallno, iaxs[dcallno], check_dcallno)) {
2846                         iaxs[dcallno]->peercallno = callno;
2847                         res = dcallno;
2848                         store_by_peercallno(iaxs[dcallno]);
2849                         if (!res || !return_locked) {
2850                                 ast_mutex_unlock(&iaxsl[dcallno]);
2851                         }
2852                         return res;
2853                 }
2854                 if (dcallno) {
2855                         ast_mutex_unlock(&iaxsl[dcallno]);
2856                 }
2857         }
2858         if (!res && (new >= NEW_ALLOW)) {
2859                 struct callno_entry *callno_entry;
2860                 /* It may seem odd that we look through the peer list for a name for
2861                  * this *incoming* call.  Well, it is weird.  However, users don't
2862                  * have an IP address/port number that we can match against.  So,
2863                  * this is just checking for a peer that has that IP/port and
2864                  * assuming that we have a user of the same name.  This isn't always
2865                  * correct, but it will be changed if needed after authentication. */
2866                 if (!iax2_getpeername(*sin, host, sizeof(host)))
2867                         snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
2868
2869                 if (peercnt_add(sin)) {
2870                         /* This address has hit its callnumber limit.  When the limit
2871                          * is reached, the connection is not added to the peercnts table.*/
2872                         return 0;
2873                 }
2874
2875                 if (!(callno_entry = get_unused_callno(0, validated))) {
2876                         /* since we ran out of space, remove the peercnt
2877                          * entry we added earlier */
2878                         peercnt_remove_by_addr(sin);
2879                         ast_log(LOG_WARNING, "No more space\n");
2880                         return 0;
2881                 }
2882                 x = callno_entry->callno;
2883                 ast_mutex_lock(&iaxsl[x]);
2884
2885                 iaxs[x] = new_iax(sin, host);
2886                 if (iaxs[x]) {
2887                         if (iaxdebug)
2888                                 ast_debug(1, "Creating new call structure %d\n", x);
2889                         iaxs[x]->callno_entry = callno_entry;
2890                         iaxs[x]->sockfd = sockfd;
2891                         iaxs[x]->addr.sin_port = sin->sin_port;
2892                         iaxs[x]->addr.sin_family = sin->sin_family;
2893                         iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
2894                         iaxs[x]->peercallno = callno;
2895                         iaxs[x]->callno = x;
2896                         iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
2897                         iaxs[x]->expiry = min_reg_expire;
2898                         iaxs[x]->pingid = iax2_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
2899                         iaxs[x]->lagid = iax2_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
2900                         iaxs[x]->amaflags = amaflags;
2901                         ast_copy_flags64(iaxs[x], &globalflags, IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF | IAX_SENDCONNECTEDLINE | IAX_RECVCONNECTEDLINE | IAX_FORCE_ENCRYPT);
2902                         ast_string_field_set(iaxs[x], accountcode, accountcode);
2903                         ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
2904                         ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
2905                         ast_string_field_set(iaxs[x], parkinglot, default_parkinglot);
2906
2907                         if (iaxs[x]->peercallno) {
2908                                 store_by_peercallno(iaxs[x]);
2909                         }
2910                 } else {
2911                         ast_log(LOG_WARNING, "Out of resources\n");
2912                         ast_mutex_unlock(&iaxsl[x]);
2913                         replace_callno(callno_entry);
2914                         return 0;
2915                 }
2916                 if (!return_locked)
2917                         ast_mutex_unlock(&iaxsl[x]);
2918                 res = x;
2919         }
2920         return res;
2921 }
2922
2923 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) { 
2924         return __find_callno(callno, dcallno, sin, new, sockfd, 0, full_frame);
2925 }
2926
2927 static int find_callno_locked(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int sockfd, int full_frame) {
2928
2929         return __find_callno(callno, dcallno, sin, new, sockfd, 1, full_frame);
2930 }
2931
2932 /*!
2933  * \brief Queue a frame to a call's owning asterisk channel
2934  *
2935  * \pre This function assumes that iaxsl[callno] is locked when called.
2936  *
2937  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2938  * was valid before calling it, it may no longer be valid after calling it.
2939  * This function may unlock and lock the mutex associated with this callno,
2940  * meaning that another thread may grab it and destroy the call.
2941  */
2942 static int iax2_queue_frame(int callno, struct ast_frame *f)
2943 {
2944         iax2_lock_owner(callno);
2945         if (iaxs[callno] && iaxs[callno]->owner) {
2946                 ast_queue_frame(iaxs[callno]->owner, f);
2947                 ast_channel_unlock(iaxs[callno]->owner);
2948         }
2949         return 0;
2950 }
2951
2952 /*!
2953  * \brief Queue a hangup frame on the ast_channel owner
2954  *
2955  * This function queues a hangup frame on the owner of the IAX2 pvt struct that
2956  * is active for the given call number.
2957  *
2958  * \pre Assumes lock for callno is already held.
2959  *
2960  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2961  * was valid before calling it, it may no longer be valid after calling it.
2962  * This function may unlock and lock the mutex associated with this callno,
2963  * meaning that another thread may grab it and destroy the call.
2964  */
2965 static int iax2_queue_hangup(int callno)
2966 {
2967         iax2_lock_owner(callno);
2968         if (iaxs[callno] && iaxs[callno]->owner) {
2969                 ast_queue_hangup(iaxs[callno]->owner);
2970                 ast_channel_unlock(iaxs[callno]->owner);
2971         }
2972         return 0;
2973 }
2974
2975 /*!
2976  * \brief Queue a control frame on the ast_channel owner
2977  *
2978  * This function queues a control frame on the owner of the IAX2 pvt struct that
2979  * is active for the given call number.
2980  *
2981  * \pre Assumes lock for callno is already held.
2982  *
2983  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2984  * was valid before calling it, it may no longer be valid after calling it.
2985  * This function may unlock and lock the mutex associated with this callno,
2986  * meaning that another thread may grab it and destroy the call.
2987  */
2988 static int iax2_queue_control_data(int callno, 
2989         enum ast_control_frame_type control, const void *data, size_t datalen)
2990 {
2991         iax2_lock_owner(callno);
2992         if (iaxs[callno] && iaxs[callno]->owner) {
2993                 ast_queue_control_data(iaxs[callno]->owner, control, data, datalen);
2994                 ast_channel_unlock(iaxs[callno]->owner);
2995         }
2996         return 0;
2997 }
2998 static void destroy_firmware(struct iax_firmware *cur)
2999 {
3000         /* Close firmware */
3001         if (cur->fwh) {
3002                 munmap((void*)cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
3003         }
3004         close(cur->fd);
3005         ast_free(cur);
3006 }
3007
3008 static int try_firmware(char *s)
3009 {
3010         struct stat stbuf;
3011         struct iax_firmware *cur = NULL;
3012         int ifd, fd, res, len, chunk;
3013         struct ast_iax2_firmware_header *fwh, fwh2;
3014         struct MD5Context md5;
3015         unsigned char sum[16], buf[1024];
3016         char *s2, *last;
3017
3018         if (!(s2 = alloca(strlen(s) + 100))) {
3019                 ast_log(LOG_WARNING, "Alloca failed!\n");
3020                 return -1;
3021         }
3022
3023         last = strrchr(s, '/');
3024         if (last)
3025                 last++;
3026         else
3027                 last = s;
3028
3029         snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
3030
3031         if (stat(s, &stbuf) < 0) {
3032                 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
3033                 return -1;
3034         }
3035
3036         /* Make sure it's not a directory */
3037         if (S_ISDIR(stbuf.st_mode))
3038                 return -1;
3039         ifd = open(s, O_RDONLY);
3040         if (ifd < 0) {
3041                 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
3042                 return -1;
3043         }
3044         fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
3045         if (fd < 0) {
3046                 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
3047                 close(ifd);
3048                 return -1;
3049         }
3050         /* Unlink our newly created file */
3051         unlink(s2);
3052         
3053         /* Now copy the firmware into it */
3054         len = stbuf.st_size;
3055         while(len) {
3056                 chunk = len;
3057                 if (chunk > sizeof(buf))
3058                         chunk = sizeof(buf);
3059                 res = read(ifd, buf, chunk);
3060                 if (res != chunk) {
3061                         ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
3062                         close(ifd);
3063                         close(fd);
3064                         return -1;
3065                 }
3066                 res = write(fd, buf, chunk);
3067                 if (res != chunk) {
3068                         ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
3069                         close(ifd);
3070                         close(fd);
3071                         return -1;
3072                 }
3073                 len -= chunk;
3074         }
3075         close(ifd);
3076         /* Return to the beginning */
3077         lseek(fd, 0, SEEK_SET);
3078         if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
3079                 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
3080                 close(fd);
3081                 return -1;
3082         }
3083         if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
3084                 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
3085                 close(fd);
3086                 return -1;
3087         }
3088         if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
3089                 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
3090                 close(fd);
3091                 return -1;
3092         }
3093         if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
3094                 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
3095                 close(fd);
3096                 return -1;
3097         }
3098         fwh = (struct ast_iax2_firmware_header*)mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0); 
3099         if (fwh == MAP_FAILED) {
3100                 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
3101                 close(fd);
3102                 return -1;
3103         }
3104         MD5Init(&md5);
3105         MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
3106         MD5Final(sum, &md5);
3107         if (memcmp(sum, fwh->chksum, sizeof(sum))) {
3108                 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
3109                 munmap((void*)fwh, stbuf.st_size);
3110                 close(fd);
3111                 return -1;
3112         }
3113
3114         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3115                 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
3116                         /* Found a candidate */
3117                         if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
3118                                 /* The version we have on loaded is older, load this one instead */
3119                                 break;
3120                         /* This version is no newer than what we have.  Don't worry about it.
3121                            We'll consider it a proper load anyhow though */
3122                         munmap((void*)fwh, stbuf.st_size);
3123                         close(fd);
3124                         return 0;
3125                 }
3126         }
3127         
3128         if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
3129                 cur->fd = -1;
3130                 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
3131         }
3132         
3133         if (cur) {
3134                 if (cur->fwh)
3135                         munmap((void*)cur->fwh, cur->mmaplen);
3136                 if (cur->fd > -1)
3137                         close(cur->fd);
3138                 cur->fwh = fwh;
3139                 cur->fd = fd;
3140                 cur->mmaplen = stbuf.st_size;
3141                 cur->dead = 0;
3142         }
3143         
3144         return 0;
3145 }
3146
3147 static int iax_check_version(char *dev)
3148 {
3149         int res = 0;
3150         struct iax_firmware *cur = NULL;
3151
3152         if (ast_strlen_zero(dev))
3153                 return 0;
3154
3155         AST_LIST_LOCK(&firmwares);
3156         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3157                 if (!strcmp(dev, (char *)cur->fwh->devname)) {
3158                         res = ntohs(cur->fwh->version);
3159                         break;
3160                 }
3161         }
3162         AST_LIST_UNLOCK(&firmwares);
3163
3164         return res;
3165 }
3166
3167 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
3168 {
3169         int res = -1;
3170         unsigned int bs = desc & 0xff;
3171         unsigned int start = (desc >> 8) & 0xffffff;
3172         unsigned int bytes;
3173         struct iax_firmware *cur;
3174
3175         if (ast_strlen_zero((char *)dev) || !bs)
3176                 return -1;
3177
3178         start *= bs;
3179         
3180         AST_LIST_LOCK(&firmwares);
3181         AST_LIST_TRAVERSE(&firmwares, cur, list) {
3182                 if (strcmp((char *)dev, (char *)cur->fwh->devname))
3183                         continue;
3184                 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
3185                 if (start < ntohl(cur->fwh->datalen)) {
3186                         bytes = ntohl(cur->fwh->datalen) - start;
3187                         if (bytes > bs)
3188                                 bytes = bs;
3189                         iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
3190                 } else {
3191                         bytes = 0;
3192                         iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
3193                 }
3194                 if (bytes == bs)
3195                         res = 0;
3196                 else
3197                         res = 1;
3198                 break;
3199         }
3200         AST_LIST_UNLOCK(&firmwares);
3201
3202         return res;
3203 }
3204
3205
3206 static void reload_firmware(int unload)
3207 {
3208         struct iax_firmware *cur = NULL;
3209         DIR *fwd;
3210         struct dirent *de;
3211         char dir[256], fn[256];
3212
3213         AST_LIST_LOCK(&firmwares);
3214
3215         /* Mark all as dead */
3216         AST_LIST_TRAVERSE(&firmwares, cur, list)
3217                 cur->dead = 1;
3218
3219         /* Now that we have marked them dead... load new ones */
3220         if (!unload) {
3221                 snprintf(dir, sizeof(dir), "%s/firmware/iax", ast_config_AST_DATA_DIR);
3222                 fwd = opendir(dir);
3223                 if (fwd) {
3224                         while((de = readdir(fwd))) {
3225                                 if (de->d_name[0] != '.') {
3226                                         snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
3227                                         if (!try_firmware(fn)) {
3228                                                 ast_verb(2, "Loaded firmware '%s'\n", de->d_name);
3229                                         }
3230                                 }
3231                         }
3232                         closedir(fwd);
3233                 } else 
3234                         ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
3235         }
3236
3237         /* Clean up leftovers */
3238         AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
3239                 if (!cur->dead)
3240                         continue;
3241                 AST_LIST_REMOVE_CURRENT(list);
3242                 destroy_firmware(cur);
3243         }
3244         AST_LIST_TRAVERSE_SAFE_END;
3245
3246         AST_LIST_UNLOCK(&firmwares);
3247 }
3248
3249 /*!
3250  * \note This function assumes that iaxsl[callno] is locked when called.
3251  *
3252  * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
3253  * was valid before calling it, it may no longer be valid after calling it.
3254  * This function calls iax2_queue_frame(), which may unlock and lock the mutex 
3255  * associated with this callno, meaning that another thread may grab it and destroy the call.
3256  */
3257 static int __do_deliver(void *data)
3258 {
3259         /* Just deliver the packet by using queueing.  This is called by
3260           the IAX thread with the iaxsl lock held. */
3261         struct iax_frame *fr = data;
3262         fr->retrans = -1;
3263         ast_clear_flag(&fr->af, AST_FRFLAG_HAS_TIMING_INFO);
3264         if (iaxs[fr->callno] && !ast_test_flag64(iaxs[fr->callno], IAX_ALREADYGONE))
3265                 iax2_queue_frame(fr->callno, &fr->af);
3266         /* Free our iax frame */
3267         iax2_frame_free(fr);
3268         /* And don't run again */
3269         return 0;