2 * Asterisk -- An open source telephony toolkit.
4 * Copyright (C) 1999 - 2006, Digium, Inc.
6 * Mark Spencer <markster@digium.com>
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.
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.
21 * \brief Implementation of Inter-Asterisk eXchange Version 2
23 * \author Mark Spencer <markster@digium.com>
26 * \arg \ref Config_iax
28 * \ingroup channel_drivers
38 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
42 #include <sys/types.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>
51 #include <sys/signal.h>
62 #include "asterisk/zapata.h"
64 #include "asterisk/lock.h"
65 #include "asterisk/frame.h"
66 #include "asterisk/channel.h"
67 #include "asterisk/logger.h"
68 #include "asterisk/module.h"
69 #include "asterisk/pbx.h"
70 #include "asterisk/sched.h"
71 #include "asterisk/io.h"
72 #include "asterisk/config.h"
73 #include "asterisk/options.h"
74 #include "asterisk/cli.h"
75 #include "asterisk/translate.h"
76 #include "asterisk/md5.h"
77 #include "asterisk/cdr.h"
78 #include "asterisk/crypto.h"
79 #include "asterisk/acl.h"
80 #include "asterisk/manager.h"
81 #include "asterisk/callerid.h"
82 #include "asterisk/app.h"
83 #include "asterisk/astdb.h"
84 #include "asterisk/musiconhold.h"
85 #include "asterisk/features.h"
86 #include "asterisk/utils.h"
87 #include "asterisk/causes.h"
88 #include "asterisk/localtime.h"
89 #include "asterisk/aes.h"
90 #include "asterisk/dnsmgr.h"
91 #include "asterisk/devicestate.h"
92 #include "asterisk/netsock.h"
93 #include "asterisk/stringfields.h"
94 #include "asterisk/linkedlists.h"
95 #include "asterisk/event.h"
98 #include "iax2-parser.h"
99 #include "iax2-provision.h"
100 #include "jitterbuf.h"
102 /* Define SCHED_MULTITHREADED to run the scheduler in a special
103 multithreaded mode. */
104 #define SCHED_MULTITHREADED
106 /* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
107 thread is actually doing. */
108 #define DEBUG_SCHED_MULTITHREAD
110 #ifndef IPTOS_MINCOST
111 #define IPTOS_MINCOST 0x02
115 static int nochecksums = 0;
119 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
120 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
122 #define DEFAULT_THREAD_COUNT 10
123 #define DEFAULT_MAX_THREAD_COUNT 100
124 #define DEFAULT_RETRY_TIME 1000
125 #define MEMORY_SIZE 100
126 #define DEFAULT_DROP 3
127 /* Flag to use with trunk calls, keeping these calls high up. It halves our effective use
128 but keeps the division between trunked and non-trunked better. */
129 #define TRUNK_CALL_START 0x4000
131 #define DEBUG_SUPPORT
133 #define MIN_REUSE_TIME 60 /* Don't reuse a call number within 60 seconds */
135 /* Sample over last 100 units to determine historic jitter */
138 static struct ast_codec_pref prefs;
140 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
143 /*! \brief Maximum transmission unit for the UDP packet in the trunk not to be
144 fragmented. This is based on 1516 - ethernet - ip - udp - iax minus one g711 frame = 1240 */
145 #define MAX_TRUNK_MTU 1240
147 static int global_max_trunk_mtu; /*!< Maximum MTU, 0 if not used */
148 static int trunk_timed, trunk_untimed, trunk_maxmtu, trunk_nmaxmtu ; /*!< Trunk MTU statistics */
151 static char context[80] = "default";
153 static char language[MAX_LANGUAGE] = "";
154 static char regcontext[AST_MAX_CONTEXT] = "";
156 static int maxauthreq = 3;
157 static int max_retries = 4;
158 static int ping_time = 21;
159 static int lagrq_time = 10;
160 static int maxtrunkcall = TRUNK_CALL_START;
161 static int maxnontrunkcall = 1;
162 static int maxjitterbuffer=1000;
163 static int resyncthreshold=1000;
164 static int maxjitterinterps=10;
165 static int jittertargetextra = 40; /* number of milliseconds the new jitter buffer adds on to its size */
167 #define MAX_TRUNKDATA 640 * 200 /*!< 40ms, uncompressed linear * 200 channels */
169 static int trunkfreq = 20;
170 static int trunkmaxsize = MAX_TRUNKDATA;
172 static int authdebug = 1;
173 static int autokill = 0;
174 static int iaxcompat = 0;
176 static int iaxdefaultdpcache=10 * 60; /* Cache dialplan entries for 10 minutes by default */
178 static int iaxdefaulttimeout = 5; /* Default to wait no more than 5 seconds for a reply to come back */
180 static unsigned int tos = 0;
182 static unsigned int cos = 0;
184 static int min_reg_expire;
185 static int max_reg_expire;
187 static int srvlookup = 0;
189 static int timingfd = -1; /* Timing file descriptor */
191 static struct ast_netsock_list *netsock;
192 static struct ast_netsock_list *outsock; /*!< used if sourceaddress specified and bindaddr == INADDR_ANY */
193 static int defaultsockfd = -1;
195 int (*iax2_regfunk)(const char *username, int onoff) = NULL;
198 #define IAX_CAPABILITY_FULLBANDWIDTH 0xFFFF
200 #define IAX_CAPABILITY_MEDBANDWIDTH (IAX_CAPABILITY_FULLBANDWIDTH & \
201 ~AST_FORMAT_SLINEAR & \
206 #define IAX_CAPABILITY_LOWBANDWIDTH (IAX_CAPABILITY_MEDBANDWIDTH & \
208 ~AST_FORMAT_G726_AAL2 & \
211 #define IAX_CAPABILITY_LOWFREE (IAX_CAPABILITY_LOWBANDWIDTH & \
215 #define DEFAULT_MAXMS 2000 /* Must be faster than 2 seconds by default */
216 #define DEFAULT_FREQ_OK 60 * 1000 /* How often to check for the host to be up */
217 #define DEFAULT_FREQ_NOTOK 10 * 1000 /* How often to check, if the host is down... */
219 static struct io_context *io;
220 static struct sched_context *sched;
222 static int iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
224 static int iaxdebug = 0;
226 static int iaxtrunkdebug = 0;
228 static int test_losspct = 0;
230 static int test_late = 0;
231 static int test_resync = 0;
232 static int test_jit = 0;
233 static int test_jitpct = 0;
234 #endif /* IAXTESTS */
236 static char accountcode[AST_MAX_ACCOUNT_CODE];
237 static char mohinterpret[MAX_MUSICCLASS];
238 static char mohsuggest[MAX_MUSICCLASS];
239 static int amaflags = 0;
241 static int delayreject = 0;
242 static int iax2_encryption = 0;
244 static struct ast_flags globalflags = { 0 };
246 static pthread_t netthreadid = AST_PTHREADT_NULL;
247 static pthread_t schedthreadid = AST_PTHREADT_NULL;
248 AST_MUTEX_DEFINE_STATIC(sched_lock);
249 static ast_cond_t sched_cond;
252 IAX_STATE_STARTED = (1 << 0),
253 IAX_STATE_AUTHENTICATED = (1 << 1),
254 IAX_STATE_TBD = (1 << 2),
255 IAX_STATE_UNCHANGED = (1 << 3),
258 struct iax2_context {
259 char context[AST_MAX_CONTEXT];
260 struct iax2_context *next;
264 IAX_HASCALLERID = (1 << 0), /*!< CallerID has been specified */
265 IAX_DELME = (1 << 1), /*!< Needs to be deleted */
266 IAX_TEMPONLY = (1 << 2), /*!< Temporary (realtime) */
267 IAX_TRUNK = (1 << 3), /*!< Treat as a trunk */
268 IAX_NOTRANSFER = (1 << 4), /*!< Don't native bridge */
269 IAX_USEJITTERBUF = (1 << 5), /*!< Use jitter buffer */
270 IAX_DYNAMIC = (1 << 6), /*!< dynamic peer */
271 IAX_SENDANI = (1 << 7), /*!< Send ANI along with CallerID */
272 /* (1 << 8) is currently unused due to the deprecation of an old option. Go ahead, take it! */
273 IAX_ALREADYGONE = (1 << 9), /*!< Already disconnected */
274 IAX_PROVISION = (1 << 10), /*!< This is a provisioning request */
275 IAX_QUELCH = (1 << 11), /*!< Whether or not we quelch audio */
276 IAX_ENCRYPTED = (1 << 12), /*!< Whether we should assume encrypted tx/rx */
277 IAX_KEYPOPULATED = (1 << 13), /*!< Whether we have a key populated */
278 IAX_CODEC_USER_FIRST = (1 << 14), /*!< are we willing to let the other guy choose the codec? */
279 IAX_CODEC_NOPREFS = (1 << 15), /*!< Force old behaviour by turning off prefs */
280 IAX_CODEC_NOCAP = (1 << 16), /*!< only consider requested format and ignore capabilities*/
281 IAX_RTCACHEFRIENDS = (1 << 17), /*!< let realtime stay till your reload */
282 IAX_RTUPDATE = (1 << 18), /*!< Send a realtime update */
283 IAX_RTAUTOCLEAR = (1 << 19), /*!< erase me on expire */
284 IAX_FORCEJITTERBUF = (1 << 20), /*!< Force jitterbuffer, even when bridged to a channel that can take jitter */
285 IAX_RTIGNOREREGEXPIRE = (1 << 21), /*!< When using realtime, ignore registration expiration */
286 IAX_TRUNKTIMESTAMPS = (1 << 22), /*!< Send trunk timestamps */
287 IAX_TRANSFERMEDIA = (1 << 23), /*!< When doing IAX2 transfers, transfer media only */
288 IAX_MAXAUTHREQ = (1 << 24), /*!< Maximum outstanding AUTHREQ restriction is in place */
289 IAX_DELAYPBXSTART = (1 << 25), /*!< Don't start a PBX on the channel until the peer sends us a
290 response, so that we've achieved a three-way handshake with
291 them before sending voice or anything else*/
294 static int global_rtautoclear = 120;
296 static int reload_config(void);
297 static int iax2_reload(int fd, int argc, char *argv[]);
301 AST_DECLARE_STRING_FIELDS(
302 AST_STRING_FIELD(name);
303 AST_STRING_FIELD(secret);
304 AST_STRING_FIELD(dbsecret);
305 AST_STRING_FIELD(accountcode);
306 AST_STRING_FIELD(mohinterpret);
307 AST_STRING_FIELD(mohsuggest);
308 AST_STRING_FIELD(inkeys); /*!< Key(s) this user can use to authenticate to us */
309 AST_STRING_FIELD(language);
310 AST_STRING_FIELD(cid_num);
311 AST_STRING_FIELD(cid_name);
320 int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
321 int curauthreq; /*!< Current number of outstanding AUTHREQs */
322 struct ast_codec_pref prefs;
324 struct iax2_context *contexts;
325 struct ast_variable *vars;
326 AST_LIST_ENTRY(iax2_user) entry;
330 AST_DECLARE_STRING_FIELDS(
331 AST_STRING_FIELD(name);
332 AST_STRING_FIELD(username);
333 AST_STRING_FIELD(secret);
334 AST_STRING_FIELD(dbsecret);
335 AST_STRING_FIELD(outkey); /*!< What key we use to talk to this peer */
337 AST_STRING_FIELD(regexten); /*!< Extension to register (if regcontext is used) */
338 AST_STRING_FIELD(context); /*!< For transfers only */
339 AST_STRING_FIELD(peercontext); /*!< Context to pass to peer */
340 AST_STRING_FIELD(mailbox); /*!< Mailbox */
341 AST_STRING_FIELD(mohinterpret);
342 AST_STRING_FIELD(mohsuggest);
343 AST_STRING_FIELD(inkeys); /*!< Key(s) this peer can use to authenticate to us */
344 /* Suggested caller id if registering */
345 AST_STRING_FIELD(cid_num); /*!< Default context (for transfer really) */
346 AST_STRING_FIELD(cid_name); /*!< Default context (for transfer really) */
347 AST_STRING_FIELD(zonetag); /*!< Time Zone */
349 struct ast_codec_pref prefs;
350 struct ast_dnsmgr_entry *dnsmgr; /*!< DNS refresh manager */
351 struct sockaddr_in addr;
353 int sockfd; /*!< Socket to use for transmission */
358 /* Dynamic Registration fields */
359 struct sockaddr_in defaddr; /*!< Default address if there is one */
360 int authmethods; /*!< Authentication methods (IAX_AUTH_*) */
361 int encmethods; /*!< Encryption methods (IAX_ENCRYPT_*) */
363 int expire; /*!< Schedule entry for expiry */
364 int expiry; /*!< How soon to expire */
365 int capability; /*!< Capability */
368 int callno; /*!< Call number of POKE request */
369 int pokeexpire; /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
370 int lastms; /*!< How long last response took (in ms), or -1 for no response */
371 int maxms; /*!< Max ms we will accept for the host to be up, 0 to not monitor */
373 int pokefreqok; /*!< How often to check if the host is up */
374 int pokefreqnotok; /*!< How often to check when the host has been determined to be down */
375 int historicms; /*!< How long recent average responses took */
376 int smoothing; /*!< Sample over how many units to determine historic ms */
378 struct ast_event_sub *mwi_event_sub;
381 AST_LIST_ENTRY(iax2_peer) entry;
384 #define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
386 struct iax2_trunk_peer {
389 struct sockaddr_in addr;
390 struct timeval txtrunktime; /*!< Transmit trunktime */
391 struct timeval rxtrunktime; /*!< Receive trunktime */
392 struct timeval lasttxtime; /*!< Last transmitted trunktime */
393 struct timeval trunkact; /*!< Last trunk activity */
394 unsigned int lastsent; /*!< Last sent time */
395 /* Trunk data and length */
396 unsigned char *trunkdata;
397 unsigned int trunkdatalen;
398 unsigned int trunkdataalloc;
402 AST_LIST_ENTRY(iax2_trunk_peer) list;
405 static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
407 struct iax_firmware {
408 AST_LIST_ENTRY(iax_firmware) list;
412 struct ast_iax2_firmware_header *fwh;
417 REG_STATE_UNREGISTERED = 0,
420 REG_STATE_REGISTERED,
426 enum iax_transfer_state {
431 TRANSFER_PASSTHROUGH,
435 TRANSFER_MPASSTHROUGH,
440 struct iax2_registry {
441 struct sockaddr_in addr; /*!< Who we connect to for registration purposes */
443 char secret[80]; /*!< Password or key name in []'s */
444 int expire; /*!< Sched ID of expiration */
445 int refresh; /*!< How often to refresh */
446 enum iax_reg_state regstate;
447 int messages; /*!< Message count, low 8 bits = new, high 8 bits = old */
448 int callno; /*!< Associated call number if applicable */
449 struct sockaddr_in us; /*!< Who the server thinks we are */
450 struct ast_dnsmgr_entry *dnsmgr; /*!< DNS refresh manager */
451 AST_LIST_ENTRY(iax2_registry) entry;
454 static AST_LIST_HEAD_STATIC(registrations, iax2_registry);
456 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
457 #define MIN_RETRY_TIME 100
458 #define MAX_RETRY_TIME 10000
460 #define MAX_JITTER_BUFFER 50
461 #define MIN_JITTER_BUFFER 10
463 #define DEFAULT_TRUNKDATA 640 * 10 /*!< 40ms, uncompressed linear * 10 channels */
465 #define MAX_TIMESTAMP_SKEW 160 /*!< maximum difference between actual and predicted ts for sending */
467 /* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
468 #define TS_GAP_FOR_JB_RESYNC 5000
470 static int iaxthreadcount = DEFAULT_THREAD_COUNT;
471 static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
472 static int iaxdynamicthreadcount = 0;
473 static int iaxactivethreadcount = 0;
487 struct chan_iax2_pvt {
488 /*! Socket to send/receive on for this call */
490 /*! Last received voice format */
492 /*! Last received video format */
494 /*! Last sent voice format */
496 /*! Last sent video format */
498 /*! What we are capable of sending */
500 /*! Last received timestamp */
502 /*! Last sent timestamp - never send the same timestamp twice in a single call */
503 unsigned int lastsent;
504 /*! Next outgoing timestamp if everything is good */
505 unsigned int nextpred;
506 /*! True if the last voice we transmitted was not silence/CNG */
507 unsigned int notsilenttx:1;
509 unsigned int pingtime;
510 /*! Max time for initial response */
513 struct sockaddr_in addr;
514 /*! Actual used codec preferences */
515 struct ast_codec_pref prefs;
516 /*! Requested codec preferences */
517 struct ast_codec_pref rprefs;
518 /*! Our call number */
519 unsigned short callno;
521 unsigned short peercallno;
522 /*! Peer selected format */
524 /*! Peer capability */
526 /*! timeval that we base our transmission on */
527 struct timeval offset;
528 /*! timeval that we base our delivery on */
529 struct timeval rxcore;
530 /*! The jitterbuffer */
532 /*! active jb read scheduler id */
536 /*! Error, as discovered by the manager */
538 /*! Owner if we have one */
539 struct ast_channel *owner;
540 /*! What's our state? */
541 struct ast_flags state;
542 /*! Expiry (optional) */
544 /*! Next outgoing sequence number */
545 unsigned char oseqno;
546 /*! Next sequence number they have not yet acknowledged */
547 unsigned char rseqno;
548 /*! Next incoming sequence number */
549 unsigned char iseqno;
550 /*! Last incoming sequence number we have acknowledged */
551 unsigned char aseqno;
553 AST_DECLARE_STRING_FIELDS(
555 AST_STRING_FIELD(peer);
556 /*! Default Context */
557 AST_STRING_FIELD(context);
558 /*! Caller ID if available */
559 AST_STRING_FIELD(cid_num);
560 AST_STRING_FIELD(cid_name);
561 /*! Hidden Caller ID (i.e. ANI) if appropriate */
562 AST_STRING_FIELD(ani);
564 AST_STRING_FIELD(dnid);
566 AST_STRING_FIELD(rdnis);
567 /*! Requested Extension */
568 AST_STRING_FIELD(exten);
569 /*! Expected Username */
570 AST_STRING_FIELD(username);
571 /*! Expected Secret */
572 AST_STRING_FIELD(secret);
574 AST_STRING_FIELD(challenge);
575 /*! Public keys permitted keys for incoming authentication */
576 AST_STRING_FIELD(inkeys);
577 /*! Private key for outgoing authentication */
578 AST_STRING_FIELD(outkey);
579 /*! Preferred language */
580 AST_STRING_FIELD(language);
581 /*! Hostname/peername for naming purposes */
582 AST_STRING_FIELD(host);
584 AST_STRING_FIELD(dproot);
585 AST_STRING_FIELD(accountcode);
586 AST_STRING_FIELD(mohinterpret);
587 AST_STRING_FIELD(mohsuggest);
588 /*! received OSP token */
589 AST_STRING_FIELD(osptoken);
592 /*! permitted authentication methods */
594 /*! permitted encryption methods */
596 /*! Encryption AES-128 Key */
597 ast_aes_encrypt_key ecx;
598 /*! Decryption AES-128 Key */
599 ast_aes_decrypt_key dcx;
600 /*! 32 bytes of semi-random data */
601 unsigned char semirand[32];
602 /*! Associated registry */
603 struct iax2_registry *reg;
604 /*! Associated peer for poking */
605 struct iax2_peer *peerpoke;
610 /*! Transferring status */
611 enum iax_transfer_state transferring;
612 /*! Transfer identifier */
614 /*! Who we are IAX transferring to */
615 struct sockaddr_in transfer;
616 /*! What's the new call number for the transfer */
617 unsigned short transfercallno;
618 /*! Transfer encrypt AES-128 Key */
619 ast_aes_encrypt_key tdcx;
621 /*! Status of knowledge of peer ADSI capability */
624 /*! Who we are bridged to */
625 unsigned short bridgecallno;
627 int pingid; /*!< Transmit PING request */
628 int lagid; /*!< Retransmit lag request */
629 int autoid; /*!< Auto hangup for Dialplan requestor */
630 int authid; /*!< Authentication rejection ID */
631 int authfail; /*!< Reason to report failure */
632 int initid; /*!< Initial peer auto-congest ID (based on qualified peers) */
637 AST_LIST_HEAD_NOLOCK(, iax2_dpcache) dpentries;
638 struct ast_variable *vars;
639 /*! last received remote rr */
640 struct iax_rr remote_rr;
641 /*! Current base time: (just for stats) */
643 /*! Dropped frame count: (just for stats) */
645 /*! received frame count: (just for stats) */
649 static AST_LIST_HEAD_STATIC(frame_queue, iax_frame);
651 static AST_LIST_HEAD_STATIC(users, iax2_user);
653 static AST_LIST_HEAD_STATIC(peers, iax2_peer);
655 static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);
658 /*! Extension exists */
659 CACHE_FLAG_EXISTS = (1 << 0),
660 /*! Extension is nonexistent */
661 CACHE_FLAG_NONEXISTENT = (1 << 1),
662 /*! Extension can exist */
663 CACHE_FLAG_CANEXIST = (1 << 2),
664 /*! Waiting to hear back response */
665 CACHE_FLAG_PENDING = (1 << 3),
667 CACHE_FLAG_TIMEOUT = (1 << 4),
668 /*! Request transmitted */
669 CACHE_FLAG_TRANSMITTED = (1 << 5),
671 CACHE_FLAG_UNKNOWN = (1 << 6),
673 CACHE_FLAG_MATCHMORE = (1 << 7),
676 struct iax2_dpcache {
677 char peercontext[AST_MAX_CONTEXT];
678 char exten[AST_MAX_EXTENSION];
680 struct timeval expiry;
682 unsigned short callno;
684 AST_LIST_ENTRY(iax2_dpcache) cache_list;
685 AST_LIST_ENTRY(iax2_dpcache) peer_list;
688 static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
690 static void reg_source_db(struct iax2_peer *p);
691 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
693 static void destroy_peer(struct iax2_peer *peer);
694 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
696 enum iax2_thread_iostate {
699 IAX_IOSTATE_PROCESSING,
700 IAX_IOSTATE_SCHEDREADY,
703 enum iax2_thread_type {
704 IAX_THREAD_TYPE_POOL,
705 IAX_THREAD_TYPE_DYNAMIC,
708 struct iax2_pkt_buf {
709 AST_LIST_ENTRY(iax2_pkt_buf) entry;
711 unsigned char buf[1];
715 AST_LIST_ENTRY(iax2_thread) list;
716 enum iax2_thread_type type;
717 enum iax2_thread_iostate iostate;
718 #ifdef SCHED_MULTITHREADED
719 void (*schedfunc)(void *);
722 #ifdef DEBUG_SCHED_MULTITHREAD
728 struct sockaddr_in iosin;
729 unsigned char readbuf[4096];
737 /*! if this thread is processing a full frame,
738 some information about that frame will be stored
739 here, so we can avoid dispatching any more full
740 frames for that callno to other threads */
742 unsigned short callno;
743 struct sockaddr_in sin;
747 /*! Queued up full frames for processing. If more full frames arrive for
748 * a call which this thread is already processing a full frame for, they
749 * are queued up here. */
750 AST_LIST_HEAD_NOLOCK(, iax2_pkt_buf) full_frames;
754 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
755 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
756 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
758 static void *iax2_process_thread(void *data);
760 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
762 ast_mutex_lock(lock);
763 ast_cond_signal(cond);
764 ast_mutex_unlock(lock);
767 static void iax_debug_output(const char *data)
770 ast_verbose("%s", data);
773 static void iax_error_output(const char *data)
775 ast_log(LOG_WARNING, "%s", data);
778 static void jb_error_output(const char *fmt, ...)
784 vsnprintf(buf, sizeof(buf), fmt, args);
787 ast_log(LOG_ERROR, buf);
790 static void jb_warning_output(const char *fmt, ...)
796 vsnprintf(buf, sizeof(buf), fmt, args);
799 ast_log(LOG_WARNING, buf);
802 static void jb_debug_output(const char *fmt, ...)
808 vsnprintf(buf, sizeof(buf), fmt, args);
815 * \brief an array of iax2 pvt structures
817 * The container for active chan_iax2_pvt structures is implemented as an
818 * array for extremely quick direct access to the correct pvt structure
819 * based on the local call number. The local call number is used as the
820 * index into the array where the associated pvt structure is stored.
822 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
824 * \brief chan_iax2_pvt structure locks
826 * These locks are used when accessing a pvt structure in the iaxs array.
827 * The index used here is the same as used in the iaxs array. It is the
828 * local call number for the associated pvt struct.
830 static ast_mutex_t iaxsl[IAX_MAX_CALLS];
832 * \brief The last time a call number was used
834 * It is important to know the last time that a call number was used locally so
835 * that it is not used again too soon. The reason for this is the same as the
836 * reason that the TCP protocol state machine requires a "TIME WAIT" state.
838 * For example, say that a call is up. Then, the remote side sends a HANGUP,
839 * which we respond to with an ACK. However, there is no way to know whether
840 * the ACK made it there successfully. If it were to get lost, the remote
841 * side may retransmit the HANGUP. If in the meantime, this call number has
842 * been reused locally, given the right set of circumstances, this retransmitted
843 * HANGUP could potentially improperly hang up the new session. So, to avoid
844 * this potential issue, we must wait a specified timeout period before reusing
845 * a local call number.
847 * The specified time that we must wait before reusing a local call number is
848 * defined as MIN_REUSE_TIME, with a default of 60 seconds.
850 static struct timeval lastused[IAX_MAX_CALLS];
852 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);
853 static int expire_registry(void *data);
854 static int iax2_answer(struct ast_channel *c);
855 static int iax2_call(struct ast_channel *c, char *dest, int timeout);
856 static int iax2_devicestate(void *data);
857 static int iax2_digit_begin(struct ast_channel *c, char digit);
858 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration);
859 static int iax2_do_register(struct iax2_registry *reg);
860 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
861 static int iax2_hangup(struct ast_channel *c);
862 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
863 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
864 static int iax2_provision(struct sockaddr_in *end, int sockfd, char *dest, const char *template, int force);
865 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
866 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
867 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
868 static int iax2_sendtext(struct ast_channel *c, const char *text);
869 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
870 static int iax2_transfer(struct ast_channel *c, const char *dest);
871 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
872 static int send_trunk(struct iax2_trunk_peer *tpeer, struct timeval *now);
873 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
874 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
875 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
876 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
877 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
878 static struct ast_channel *iax2_request(const char *type, int format, void *data, int *cause);
879 static struct ast_frame *iax2_read(struct ast_channel *c);
880 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
881 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
882 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime);
883 static void destroy_user(struct iax2_user *user);
884 static void prune_peers(void);
886 static int acf_channel_read(struct ast_channel *chan, const char *funcname, char *preparse, char *buf, size_t buflen);
887 static int acf_channel_write(struct ast_channel *chan, const char *function, char *data, const char *value);
889 static const struct ast_channel_tech iax2_tech = {
891 .description = tdesc,
892 .capabilities = IAX_CAPABILITY_FULLBANDWIDTH,
893 .properties = AST_CHAN_TP_WANTSJITTER,
894 .requester = iax2_request,
895 .devicestate = iax2_devicestate,
896 .send_digit_begin = iax2_digit_begin,
897 .send_digit_end = iax2_digit_end,
898 .send_text = iax2_sendtext,
899 .send_image = iax2_sendimage,
900 .send_html = iax2_sendhtml,
902 .hangup = iax2_hangup,
903 .answer = iax2_answer,
906 .write_video = iax2_write,
907 .indicate = iax2_indicate,
908 .setoption = iax2_setoption,
909 .bridge = iax2_bridge,
910 .transfer = iax2_transfer,
912 .func_channel_read = acf_channel_read,
913 .func_channel_write = acf_channel_write,
916 static void mwi_event_cb(const struct ast_event *event, void *userdata)
918 /* The MWI subscriptions exist just so the core knows we care about those
919 * mailboxes. However, we just grab the events out of the cache when it
920 * is time to send MWI, since it is only sent with a REGACK. */
923 /*! \brief Send manager event at call setup to link between Asterisk channel name
924 and IAX2 call identifiers */
925 static void iax2_ami_channelupdate(struct chan_iax2_pvt *pvt)
927 manager_event(EVENT_FLAG_SYSTEM, "ChannelUpdate",
928 "Channel: %s\r\nChanneltype: IAX2\r\nIAX2-callno-local: %d\r\nIAX2-callno-remote: %d\r\nIAX2-peer: %s\r\n",
929 pvt->owner ? pvt->owner->name : "",
930 pvt->callno, pvt->peercallno, pvt->peer ? pvt->peer : "");
934 static void insert_idle_thread(struct iax2_thread *thread)
936 if (thread->type == IAX_THREAD_TYPE_DYNAMIC) {
937 AST_LIST_LOCK(&dynamic_list);
938 AST_LIST_INSERT_TAIL(&dynamic_list, thread, list);
939 AST_LIST_UNLOCK(&dynamic_list);
941 AST_LIST_LOCK(&idle_list);
942 AST_LIST_INSERT_TAIL(&idle_list, thread, list);
943 AST_LIST_UNLOCK(&idle_list);
949 static struct iax2_thread *find_idle_thread(void)
951 struct iax2_thread *thread = NULL;
953 /* Pop the head of the idle list off */
954 AST_LIST_LOCK(&idle_list);
955 thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
956 AST_LIST_UNLOCK(&idle_list);
958 /* If we popped a thread off the idle list, just return it */
962 /* Pop the head of the dynamic list off */
963 AST_LIST_LOCK(&dynamic_list);
964 thread = AST_LIST_REMOVE_HEAD(&dynamic_list, list);
965 AST_LIST_UNLOCK(&dynamic_list);
967 /* If we popped a thread off the dynamic list, just return it */
971 /* If we can't create a new dynamic thread for any reason, return no thread at all */
972 if (iaxdynamicthreadcount >= iaxmaxthreadcount || !(thread = ast_calloc(1, sizeof(*thread))))
975 /* Set default values */
976 thread->threadnum = ast_atomic_fetchadd_int(&iaxdynamicthreadcount, 1);
977 thread->type = IAX_THREAD_TYPE_DYNAMIC;
979 /* Initialize lock and condition */
980 ast_mutex_init(&thread->lock);
981 ast_cond_init(&thread->cond, NULL);
983 /* Create thread and send it on it's way */
984 if (ast_pthread_create_detached_background(&thread->threadid, NULL, iax2_process_thread, thread)) {
985 ast_cond_destroy(&thread->cond);
986 ast_mutex_destroy(&thread->lock);
991 /* this thread is not processing a full frame (since it is idle),
992 so ensure that the field for the full frame call number is empty */
994 memset(&thread->ffinfo, 0, sizeof(thread->ffinfo));
999 #ifdef SCHED_MULTITHREADED
1000 static int __schedule_action(void (*func)(void *data), void *data, const char *funcname)
1002 struct iax2_thread *thread = NULL;
1003 static time_t lasterror;
1006 thread = find_idle_thread();
1008 if (thread != NULL) {
1009 thread->schedfunc = func;
1010 thread->scheddata = data;
1011 thread->iostate = IAX_IOSTATE_SCHEDREADY;
1012 #ifdef DEBUG_SCHED_MULTITHREAD
1013 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
1015 signal_condition(&thread->lock, &thread->cond);
1020 ast_log(LOG_NOTICE, "Out of idle IAX2 threads for scheduling!\n");
1025 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
1028 static int send_ping(void *data);
1030 static void __send_ping(void *data)
1032 int callno = (long)data;
1033 ast_mutex_lock(&iaxsl[callno]);
1034 if (iaxs[callno] && iaxs[callno]->pingid != -1) {
1035 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1036 iaxs[callno]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, data);
1038 ast_mutex_unlock(&iaxsl[callno]);
1041 static int send_ping(void *data)
1043 #ifdef SCHED_MULTITHREADED
1044 if (schedule_action(__send_ping, data))
1050 static int get_encrypt_methods(const char *s)
1053 if (!strcasecmp(s, "aes128"))
1054 e = IAX_ENCRYPT_AES128;
1055 else if (ast_true(s))
1056 e = IAX_ENCRYPT_AES128;
1062 static int send_lagrq(void *data);
1064 static void __send_lagrq(void *data)
1066 int callno = (long)data;
1067 /* Ping only if it's real not if it's bridged */
1068 ast_mutex_lock(&iaxsl[callno]);
1069 if (iaxs[callno] && iaxs[callno]->lagid != -1) {
1070 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1071 iaxs[callno]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, data);
1073 ast_mutex_unlock(&iaxsl[callno]);
1076 static int send_lagrq(void *data)
1078 #ifdef SCHED_MULTITHREADED
1079 if (schedule_action(__send_lagrq, data))
1085 static unsigned char compress_subclass(int subclass)
1089 /* If it's 128 or smaller, just return it */
1090 if (subclass < IAX_FLAG_SC_LOG)
1092 /* Otherwise find its power */
1093 for (x = 0; x < IAX_MAX_SHIFT; x++) {
1094 if (subclass & (1 << x)) {
1096 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
1102 return power | IAX_FLAG_SC_LOG;
1105 static int uncompress_subclass(unsigned char csub)
1107 /* If the SC_LOG flag is set, return 2^csub otherwise csub */
1108 if (csub & IAX_FLAG_SC_LOG) {
1109 /* special case for 'compressed' -1 */
1113 return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
1119 static struct iax2_peer *find_peer(const char *name, int realtime)
1121 struct iax2_peer *peer = NULL;
1123 /* Grab peer from linked list */
1124 AST_LIST_LOCK(&peers);
1125 AST_LIST_TRAVERSE(&peers, peer, entry) {
1126 if (!strcasecmp(peer->name, name)) {
1130 AST_LIST_UNLOCK(&peers);
1132 /* Now go for realtime if applicable */
1133 if(!peer && realtime)
1134 peer = realtime_peer(name, NULL);
1138 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int lockpeer)
1140 struct iax2_peer *peer = NULL;
1144 AST_LIST_LOCK(&peers);
1145 AST_LIST_TRAVERSE(&peers, peer, entry) {
1146 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1147 (peer->addr.sin_port == sin.sin_port)) {
1148 ast_copy_string(host, peer->name, len);
1154 AST_LIST_UNLOCK(&peers);
1156 peer = realtime_peer(NULL, &sin);
1158 ast_copy_string(host, peer->name, len);
1159 if (ast_test_flag(peer, IAX_TEMPONLY))
1168 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer, const char *host)
1170 struct chan_iax2_pvt *tmp;
1173 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1176 if (ast_string_field_init(tmp, 32)) {
1189 ast_string_field_set(tmp,exten, "s");
1190 ast_string_field_set(tmp,host, host);
1194 jbconf.max_jitterbuf = maxjitterbuffer;
1195 jbconf.resync_threshold = resyncthreshold;
1196 jbconf.max_contig_interp = maxjitterinterps;
1197 jbconf.target_extra = jittertargetextra;
1198 jb_setconf(tmp->jb,&jbconf);
1200 AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1205 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1207 struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen, fr->cacheable);
1209 size_t mallocd_datalen = new->mallocd_datalen;
1210 memcpy(new, fr, sizeof(*new));
1211 iax_frame_wrap(new, &fr->af);
1212 new->mallocd_datalen = mallocd_datalen;
1215 new->direction = DIRECTION_INGRESS;
1221 #define NEW_PREVENT 0
1225 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, const struct chan_iax2_pvt *cur)
1227 if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1228 (cur->addr.sin_port == sin->sin_port)) {
1229 /* This is the main host */
1230 if ((cur->peercallno == callno) ||
1231 ((dcallno == cur->callno) && !cur->peercallno)) {
1232 /* That's us. Be sure we keep track of the peer call number */
1236 if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1237 (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1238 /* We're transferring */
1239 if ((dcallno == cur->callno) || (cur->transferring == TRANSFER_MEDIAPASS && cur->transfercallno == callno))
1245 static void update_max_trunk(void)
1247 int max = TRUNK_CALL_START;
1249 /* XXX Prolly don't need locks here XXX */
1250 for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1256 ast_debug(1, "New max trunk callno is %d\n", max);
1259 static void update_max_nontrunk(void)
1263 /* XXX Prolly don't need locks here XXX */
1264 for (x=1;x<TRUNK_CALL_START - 1; x++) {
1268 maxnontrunkcall = max;
1270 ast_debug(1, "New max nontrunk callno is %d\n", max);
1273 static int make_trunk(unsigned short callno, int locked)
1278 if (iaxs[callno]->oseqno) {
1279 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1282 if (callno & TRUNK_CALL_START) {
1283 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1286 gettimeofday(&now, NULL);
1287 for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1288 ast_mutex_lock(&iaxsl[x]);
1289 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1290 iaxs[x] = iaxs[callno];
1291 iaxs[x]->callno = x;
1292 iaxs[callno] = NULL;
1293 /* Update the two timers that should have been started */
1294 if (iaxs[x]->pingid > -1)
1295 ast_sched_del(sched, iaxs[x]->pingid);
1296 if (iaxs[x]->lagid > -1)
1297 ast_sched_del(sched, iaxs[x]->lagid);
1298 iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1299 iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1301 ast_mutex_unlock(&iaxsl[callno]);
1304 ast_mutex_unlock(&iaxsl[x]);
1307 ast_mutex_unlock(&iaxsl[x]);
1309 if (x >= IAX_MAX_CALLS - 1) {
1310 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1313 ast_debug(1, "Made call %d into trunk call %d\n", callno, x);
1314 /* We move this call from a non-trunked to a trunked call */
1316 update_max_nontrunk();
1321 * \todo XXX Note that this function contains a very expensive operation that
1322 * happens for *every* incoming media frame. It iterates through every
1323 * possible call number, locking and unlocking each one, to try to match the
1324 * incoming frame to an active call. Call numbers can be up to 2^15, 32768.
1325 * So, for an call with a local call number of 20000, every incoming audio
1326 * frame would require 20000 mutex lock and unlock operations. Ouch.
1328 * It's a shame that IAX2 media frames carry the source call number instead of
1329 * the destination call number. If they did, this lookup wouldn't be needed.
1330 * However, it's too late to change that now. Instead, we need to come up with
1331 * a better way of indexing active calls so that these frequent lookups are not
1334 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int lockpeer, int sockfd)
1341 if (new <= NEW_ALLOW) {
1342 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1343 ast_mutex_lock(&iaxsl[x]);
1345 /* Look for an exact match */
1346 if (match(sin, callno, dcallno, iaxs[x])) {
1350 ast_mutex_unlock(&iaxsl[x]);
1352 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1353 ast_mutex_lock(&iaxsl[x]);
1355 /* Look for an exact match */
1356 if (match(sin, callno, dcallno, iaxs[x])) {
1360 ast_mutex_unlock(&iaxsl[x]);
1363 if ((res < 1) && (new >= NEW_ALLOW)) {
1364 /* It may seem odd that we look through the peer list for a name for
1365 * this *incoming* call. Well, it is weird. However, users don't
1366 * have an IP address/port number that we can match against. So,
1367 * this is just checking for a peer that has that IP/port and
1368 * assuming that we have a user of the same name. This isn't always
1369 * correct, but it will be changed if needed after authentication. */
1370 if (!iax2_getpeername(*sin, host, sizeof(host), lockpeer))
1371 snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1372 gettimeofday(&now, NULL);
1373 for (x=1;x<TRUNK_CALL_START;x++) {
1374 /* Find first unused call number that hasn't been used in a while */
1375 ast_mutex_lock(&iaxsl[x]);
1376 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1377 ast_mutex_unlock(&iaxsl[x]);
1379 /* We've still got lock held if we found a spot */
1380 if (x >= TRUNK_CALL_START) {
1381 ast_log(LOG_WARNING, "No more space\n");
1384 iaxs[x] = new_iax(sin, lockpeer, host);
1385 update_max_nontrunk();
1388 ast_debug(1, "Creating new call structure %d\n", x);
1389 iaxs[x]->sockfd = sockfd;
1390 iaxs[x]->addr.sin_port = sin->sin_port;
1391 iaxs[x]->addr.sin_family = sin->sin_family;
1392 iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1393 iaxs[x]->peercallno = callno;
1394 iaxs[x]->callno = x;
1395 iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1396 iaxs[x]->expiry = min_reg_expire;
1397 iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1398 iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1399 iaxs[x]->amaflags = amaflags;
1400 ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1402 ast_string_field_set(iaxs[x], accountcode, accountcode);
1403 ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1404 ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1406 ast_log(LOG_WARNING, "Out of resources\n");
1407 ast_mutex_unlock(&iaxsl[x]);
1410 ast_mutex_unlock(&iaxsl[x]);
1416 static void iax2_frame_free(struct iax_frame *fr)
1418 if (fr->retrans > -1)
1419 ast_sched_del(sched, fr->retrans);
1424 * \brief Queue a frame to a call's owning asterisk channel
1426 * \note This function assumes that iaxsl[callno] is locked when called.
1428 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1429 * was valid before calling it, it may no longer be valid after calling it.
1430 * This function may unlock and lock the mutex associated with this callno,
1431 * meaning that another thread may grab it and destroy the call.
1433 static int iax2_queue_frame(int callno, struct ast_frame *f)
1435 /* Assumes lock for callno is already held... */
1437 if (iaxs[callno] && iaxs[callno]->owner) {
1438 if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1439 /* Avoid deadlock by pausing and trying again */
1440 ast_mutex_unlock(&iaxsl[callno]);
1442 ast_mutex_lock(&iaxsl[callno]);
1444 ast_queue_frame(iaxs[callno]->owner, f);
1445 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1454 static void destroy_firmware(struct iax_firmware *cur)
1456 /* Close firmware */
1458 munmap(cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1464 static int try_firmware(char *s)
1467 struct iax_firmware *cur = NULL;
1468 int ifd, fd, res, len, chunk;
1469 struct ast_iax2_firmware_header *fwh, fwh2;
1470 struct MD5Context md5;
1471 unsigned char sum[16], buf[1024];
1474 if (!(s2 = alloca(strlen(s) + 100))) {
1475 ast_log(LOG_WARNING, "Alloca failed!\n");
1479 last = strrchr(s, '/');
1485 snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1487 if ((res = stat(s, &stbuf) < 0)) {
1488 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1492 /* Make sure it's not a directory */
1493 if (S_ISDIR(stbuf.st_mode))
1495 ifd = open(s, O_RDONLY);
1497 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1500 fd = open(s2, O_RDWR | O_CREAT | O_EXCL, AST_FILE_MODE);
1502 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1506 /* Unlink our newly created file */
1509 /* Now copy the firmware into it */
1510 len = stbuf.st_size;
1513 if (chunk > sizeof(buf))
1514 chunk = sizeof(buf);
1515 res = read(ifd, buf, chunk);
1517 ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1522 res = write(fd, buf, chunk);
1524 ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1532 /* Return to the beginning */
1533 lseek(fd, 0, SEEK_SET);
1534 if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1535 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1539 if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1540 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1544 if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1545 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1549 if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1550 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1554 fwh = mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
1555 if (fwh == (void *) -1) {
1556 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1561 MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1562 MD5Final(sum, &md5);
1563 if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1564 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1565 munmap(fwh, stbuf.st_size);
1570 AST_LIST_TRAVERSE(&firmwares, cur, list) {
1571 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1572 /* Found a candidate */
1573 if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1574 /* The version we have on loaded is older, load this one instead */
1576 /* This version is no newer than what we have. Don't worry about it.
1577 We'll consider it a proper load anyhow though */
1578 munmap(fwh, stbuf.st_size);
1584 if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1586 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1591 munmap(cur->fwh, cur->mmaplen);
1596 cur->mmaplen = stbuf.st_size;
1603 static int iax_check_version(char *dev)
1606 struct iax_firmware *cur = NULL;
1608 if (ast_strlen_zero(dev))
1611 AST_LIST_LOCK(&firmwares);
1612 AST_LIST_TRAVERSE(&firmwares, cur, list) {
1613 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1614 res = ntohs(cur->fwh->version);
1618 AST_LIST_UNLOCK(&firmwares);
1623 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1626 unsigned int bs = desc & 0xff;
1627 unsigned int start = (desc >> 8) & 0xffffff;
1629 struct iax_firmware *cur;
1631 if (ast_strlen_zero((char *)dev) || !bs)
1636 AST_LIST_LOCK(&firmwares);
1637 AST_LIST_TRAVERSE(&firmwares, cur, list) {
1638 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1640 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1641 if (start < ntohl(cur->fwh->datalen)) {
1642 bytes = ntohl(cur->fwh->datalen) - start;
1645 iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1648 iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1656 AST_LIST_UNLOCK(&firmwares);
1662 static void reload_firmware(void)
1664 struct iax_firmware *cur = NULL;
1667 char dir[256], fn[256];
1669 AST_LIST_LOCK(&firmwares);
1671 /* Mark all as dead */
1672 AST_LIST_TRAVERSE(&firmwares, cur, list)
1675 /* Now that we have marked them dead... load new ones */
1676 snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1679 while((de = readdir(fwd))) {
1680 if (de->d_name[0] != '.') {
1681 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1682 if (!try_firmware(fn)) {
1683 if (option_verbose > 1)
1684 ast_verbose(VERBOSE_PREFIX_2 "Loaded firmware '%s'\n", de->d_name);
1690 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1692 /* Clean up leftovers */
1693 AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1696 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1697 destroy_firmware(cur);
1699 AST_LIST_TRAVERSE_SAFE_END
1701 AST_LIST_UNLOCK(&firmwares);
1705 * \note This function assumes that iaxsl[callno] is locked when called.
1707 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
1708 * was valid before calling it, it may no longer be valid after calling it.
1709 * This function calls iax2_queue_frame(), which may unlock and lock the mutex
1710 * associated with this callno, meaning that another thread may grab it and destroy the call.
1712 static int __do_deliver(void *data)
1714 /* Just deliver the packet by using queueing. This is called by
1715 the IAX thread with the iaxsl lock held. */
1716 struct iax_frame *fr = data;
1718 fr->af.has_timing_info = 0;
1719 if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1720 iax2_queue_frame(fr->callno, &fr->af);
1721 /* Free our iax frame */
1722 iax2_frame_free(fr);
1723 /* And don't run again */
1727 static int handle_error(void)
1729 /* XXX Ideally we should figure out why an error occurred and then abort those
1730 rather than continuing to try. Unfortunately, the published interface does
1731 not seem to work XXX */
1733 struct sockaddr_in *sin;
1736 struct sock_extended_err e;
1741 m.msg_controllen = sizeof(e);
1743 res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1745 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1747 if (m.msg_controllen) {
1748 sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1750 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1752 ast_log(LOG_WARNING, "No address detected??\n");
1754 ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1761 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1764 res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1767 ast_debug(1, "Received error: %s\n", strerror(errno));
1774 static int send_packet(struct iax_frame *f)
1777 int callno = f->callno;
1779 /* Don't send if there was an error, but return error instead */
1780 if (!callno || !iaxs[callno] || iaxs[callno]->error)
1783 /* Called with iaxsl held */
1785 ast_debug(3, "Sending %d on %d/%d to %s:%d\n", f->ts, callno, iaxs[callno]->peercallno, ast_inet_ntoa(iaxs[callno]->addr.sin_addr), ntohs(iaxs[callno]->addr.sin_port));
1788 iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1789 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
1790 sizeof(iaxs[callno]->transfer));
1793 iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1794 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
1795 sizeof(iaxs[callno]->addr));
1799 ast_debug(1, "Received error: %s\n", strerror(errno));
1806 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1808 struct iax2_user *user = NULL;
1810 /* Decrement AUTHREQ count if needed */
1811 if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1812 AST_LIST_LOCK(&users);
1813 AST_LIST_TRAVERSE(&users, user, entry) {
1814 if (!strcmp(user->name, pvt->username)) {
1819 AST_LIST_UNLOCK(&users);
1820 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1822 /* No more pings or lagrq's */
1823 if (pvt->pingid > -1)
1824 ast_sched_del(sched, pvt->pingid);
1826 if (pvt->lagid > -1)
1827 ast_sched_del(sched, pvt->lagid);
1829 if (pvt->autoid > -1)
1830 ast_sched_del(sched, pvt->autoid);
1832 if (pvt->authid > -1)
1833 ast_sched_del(sched, pvt->authid);
1835 if (pvt->initid > -1)
1836 ast_sched_del(sched, pvt->initid);
1839 ast_sched_del(sched, pvt->jbid);
1843 static int iax2_predestroy(int callno)
1845 struct ast_channel *c = NULL;
1846 struct chan_iax2_pvt *pvt = iaxs[callno];
1851 if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
1852 iax2_destroy_helper(pvt);
1853 ast_set_flag(pvt, IAX_ALREADYGONE);
1856 if ((c = pvt->owner)) {
1857 c->_softhangup |= AST_SOFTHANGUP_DEV;
1859 ast_queue_hangup(c);
1861 ast_module_unref(ast_module_info->self);
1867 static void iax2_destroy(int callno)
1869 struct chan_iax2_pvt *pvt = NULL;
1870 struct iax_frame *cur = NULL;
1871 struct ast_channel *owner = NULL;
1875 gettimeofday(&lastused[callno], NULL);
1877 owner = pvt ? pvt->owner : NULL;
1880 if (ast_mutex_trylock(&owner->lock)) {
1881 ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1882 ast_mutex_unlock(&iaxsl[callno]);
1884 ast_mutex_lock(&iaxsl[callno]);
1889 iaxs[callno] = NULL;
1893 iax2_destroy_helper(pvt);
1896 ast_set_flag(pvt, IAX_ALREADYGONE);
1899 /* If there's an owner, prod it to give up */
1900 owner->_softhangup |= AST_SOFTHANGUP_DEV;
1901 ast_queue_hangup(owner);
1904 AST_LIST_LOCK(&frame_queue);
1905 AST_LIST_TRAVERSE(&frame_queue, cur, list) {
1906 /* Cancel any pending transmissions */
1907 if (cur->callno == pvt->callno)
1910 AST_LIST_UNLOCK(&frame_queue);
1913 pvt->reg->callno = 0;
1917 ast_variables_destroy(pvt->vars);
1921 while (jb_getall(pvt->jb, &frame) == JB_OK)
1922 iax2_frame_free(frame.data);
1923 jb_destroy(pvt->jb);
1924 /* gotta free up the stringfields */
1925 ast_string_field_free_pools(pvt);
1930 ast_mutex_unlock(&owner->lock);
1932 if (callno & 0x4000)
1936 static int update_packet(struct iax_frame *f)
1938 /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
1939 struct ast_iax2_full_hdr *fh = f->data;
1940 /* Mark this as a retransmission */
1941 fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
1943 f->iseqno = iaxs[f->callno]->iseqno;
1944 fh->iseqno = f->iseqno;
1948 static int attempt_transmit(void *data);
1949 static void __attempt_transmit(void *data)
1951 /* Attempt to transmit the frame to the remote peer...
1952 Called without iaxsl held. */
1953 struct iax_frame *f = data;
1955 int callno = f->callno;
1956 /* Make sure this call is still active */
1958 ast_mutex_lock(&iaxsl[callno]);
1959 if (callno && iaxs[callno]) {
1960 if ((f->retries < 0) /* Already ACK'd */ ||
1961 (f->retries >= max_retries) /* Too many attempts */) {
1962 /* Record an error if we've transmitted too many times */
1963 if (f->retries >= max_retries) {
1965 /* Transfer timeout */
1966 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1967 } else if (f->final) {
1969 iax2_destroy(callno);
1971 if (iaxs[callno]->owner)
1972 ast_log(LOG_WARNING, "Max retries exceeded to host %s on %s (type = %d, subclass = %d, ts=%d, seqno=%d)\n", ast_inet_ntoa(iaxs[f->callno]->addr.sin_addr),iaxs[f->callno]->owner->name , f->af.frametype, f->af.subclass, f->ts, f->oseqno);
1973 iaxs[callno]->error = ETIMEDOUT;
1974 if (iaxs[callno]->owner) {
1975 struct ast_frame fr = { 0, };
1977 fr.frametype = AST_FRAME_CONTROL;
1978 fr.subclass = AST_CONTROL_HANGUP;
1979 iax2_queue_frame(callno, &fr); // XXX
1980 /* Remember, owner could disappear */
1981 if (iaxs[callno] && iaxs[callno]->owner)
1982 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
1984 if (iaxs[callno]->reg) {
1985 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
1986 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
1987 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
1989 iax2_destroy(callno);
1996 /* Update it if it needs it */
1998 /* Attempt transmission */
2001 /* Try again later after 10 times as long */
2003 if (f->retrytime > MAX_RETRY_TIME)
2004 f->retrytime = MAX_RETRY_TIME;
2005 /* Transfer messages max out at one second */
2006 if (f->transfer && (f->retrytime > 1000))
2007 f->retrytime = 1000;
2008 f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
2011 /* Make sure it gets freed */
2016 ast_mutex_unlock(&iaxsl[callno]);
2017 /* Do not try again */
2019 /* Don't attempt delivery, just remove it from the queue */
2020 AST_LIST_LOCK(&frame_queue);
2021 AST_LIST_REMOVE(&frame_queue, f, list);
2022 AST_LIST_UNLOCK(&frame_queue);
2024 /* Free the IAX frame */
2029 static int attempt_transmit(void *data)
2031 #ifdef SCHED_MULTITHREADED
2032 if (schedule_action(__attempt_transmit, data))
2034 __attempt_transmit(data);
2038 static int iax2_prune_realtime(int fd, int argc, char *argv[])
2040 struct iax2_peer *peer;
2043 return RESULT_SHOWUSAGE;
2044 if (!strcmp(argv[3],"all")) {
2046 ast_cli(fd, "OK cache is flushed.\n");
2047 } else if ((peer = find_peer(argv[3], 0))) {
2048 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
2049 ast_set_flag(peer, IAX_RTAUTOCLEAR);
2050 expire_registry((void*)peer->name);
2051 ast_cli(fd, "OK peer %s was removed from the cache.\n", argv[3]);
2053 ast_cli(fd, "SORRY peer %s is not eligible for this operation.\n", argv[3]);
2056 ast_cli(fd, "SORRY peer %s was not found in the cache.\n", argv[3]);
2059 return RESULT_SUCCESS;
2062 static int iax2_test_losspct(int fd, int argc, char *argv[])
2065 return RESULT_SHOWUSAGE;
2067 test_losspct = atoi(argv[3]);
2069 return RESULT_SUCCESS;
2073 static int iax2_test_late(int fd, int argc, char *argv[])
2076 return RESULT_SHOWUSAGE;
2078 test_late = atoi(argv[3]);
2080 return RESULT_SUCCESS;
2083 static int iax2_test_resync(int fd, int argc, char *argv[])
2086 return RESULT_SHOWUSAGE;
2088 test_resync = atoi(argv[3]);
2090 return RESULT_SUCCESS;
2093 static int iax2_test_jitter(int fd, int argc, char *argv[])
2095 if (argc < 4 || argc > 5)
2096 return RESULT_SHOWUSAGE;
2098 test_jit = atoi(argv[3]);
2100 test_jitpct = atoi(argv[4]);
2102 return RESULT_SUCCESS;
2104 #endif /* IAXTESTS */
2106 /*! \brief peer_status: Report Peer status in character string */
2107 /* returns 1 if peer is online, -1 if unmonitored */
2108 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
2112 if (peer->lastms < 0) {
2113 ast_copy_string(status, "UNREACHABLE", statuslen);
2114 } else if (peer->lastms > peer->maxms) {
2115 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
2117 } else if (peer->lastms) {
2118 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
2121 ast_copy_string(status, "UNKNOWN", statuslen);
2124 ast_copy_string(status, "Unmonitored", statuslen);
2130 /*! \brief Show one peer in detail */
2131 static int iax2_show_peer(int fd, int argc, char *argv[])
2135 struct iax2_peer *peer;
2136 char codec_buf[512];
2137 int x = 0, codec = 0, load_realtime = 0;
2140 return RESULT_SHOWUSAGE;
2142 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? 1 : 0;
2144 peer = find_peer(argv[3], load_realtime);
2147 ast_cli(fd, " * Name : %s\n", peer->name);
2148 ast_cli(fd, " Secret : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
2149 ast_cli(fd, " Context : %s\n", peer->context);
2150 ast_cli(fd, " Mailbox : %s\n", peer->mailbox);
2151 ast_cli(fd, " Dynamic : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes":"No");
2152 ast_cli(fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
2153 ast_cli(fd, " Expire : %d\n", peer->expire);
2154 ast_cli(fd, " ACL : %s\n", (peer->ha?"Yes":"No"));
2155 ast_cli(fd, " Addr->IP : %s Port %d\n", peer->addr.sin_addr.s_addr ? ast_inet_ntoa(peer->addr.sin_addr) : "(Unspecified)", ntohs(peer->addr.sin_port));
2156 ast_cli(fd, " Defaddr->IP : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
2157 ast_cli(fd, " Username : %s\n", peer->username);
2158 ast_cli(fd, " Codecs : ");
2159 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
2160 ast_cli(fd, "%s\n", codec_buf);
2162 ast_cli(fd, " Codec Order : (");
2163 for(x = 0; x < 32 ; x++) {
2164 codec = ast_codec_pref_index(&peer->prefs,x);
2167 ast_cli(fd, "%s", ast_getformatname(codec));
2168 if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2173 ast_cli(fd, "none");
2176 ast_cli(fd, " Status : ");
2177 peer_status(peer, status, sizeof(status));
2178 ast_cli(fd, "%s\n",status);
2179 ast_cli(fd, " Qualify : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2181 if (ast_test_flag(peer, IAX_TEMPONLY))
2184 ast_cli(fd,"Peer %s not found.\n", argv[3]);
2188 return RESULT_SUCCESS;
2191 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2194 struct iax2_peer *p = NULL;
2196 int wordlen = strlen(word);
2198 /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2200 AST_LIST_LOCK(&peers);
2201 AST_LIST_TRAVERSE(&peers, p, entry) {
2202 if (!strncasecmp(p->name, word, wordlen) && ++which > state) {
2203 res = ast_strdup(p->name);
2207 AST_LIST_UNLOCK(&peers);
2213 static int iax2_show_stats(int fd, int argc, char *argv[])
2215 struct iax_frame *cur;
2216 int cnt = 0, dead=0, final=0;
2219 return RESULT_SHOWUSAGE;
2221 AST_LIST_LOCK(&frame_queue);
2222 AST_LIST_TRAVERSE(&frame_queue, cur, list) {
2223 if (cur->retries < 0)
2229 AST_LIST_UNLOCK(&frame_queue);
2231 ast_cli(fd, " IAX Statistics\n");
2232 ast_cli(fd, "---------------------\n");
2233 ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2234 ast_cli(fd, "%d timed and %d untimed transmits; MTU %d/%d/%d\n", trunk_timed, trunk_untimed,
2235 trunk_maxmtu, trunk_nmaxmtu, global_max_trunk_mtu);
2237 ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2239 trunk_timed = trunk_untimed = 0;
2240 if (trunk_maxmtu > trunk_nmaxmtu)
2241 trunk_nmaxmtu = trunk_maxmtu;
2243 return RESULT_SUCCESS;
2246 /*! \brief Set trunk MTU from CLI */
2247 static int iax2_set_mtu(int fd, int argc, char *argv[])
2252 return RESULT_SHOWUSAGE;
2253 if (strncasecmp(argv[3], "default", strlen(argv[3])) == 0)
2254 mtuv = MAX_TRUNK_MTU;
2256 mtuv = atoi(argv[3]);
2259 ast_cli(fd, "Trunk MTU control disabled (mtu was %d)\n", global_max_trunk_mtu);
2260 global_max_trunk_mtu = 0;
2261 return RESULT_SUCCESS;
2263 if (mtuv < 172 || mtuv > 4000) {
2264 ast_cli(fd, "Trunk MTU must be between 172 and 4000\n");
2265 return RESULT_SHOWUSAGE;
2267 ast_cli(fd, "Trunk MTU changed from %d to %d\n", global_max_trunk_mtu, mtuv);
2268 global_max_trunk_mtu = mtuv;
2269 return RESULT_SUCCESS;
2272 static int iax2_show_cache(int fd, int argc, char *argv[])
2274 struct iax2_dpcache *dp = NULL;
2275 char tmp[1024], *pc = NULL;
2279 gettimeofday(&tv, NULL);
2281 AST_LIST_LOCK(&dpcache);
2283 ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2285 AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2286 s = dp->expiry.tv_sec - tv.tv_sec;
2288 if (dp->flags & CACHE_FLAG_EXISTS)
2289 strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2290 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2291 strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2292 if (dp->flags & CACHE_FLAG_CANEXIST)
2293 strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2294 if (dp->flags & CACHE_FLAG_PENDING)
2295 strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2296 if (dp->flags & CACHE_FLAG_TIMEOUT)
2297 strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2298 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2299 strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2300 if (dp->flags & CACHE_FLAG_MATCHMORE)
2301 strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2302 if (dp->flags & CACHE_FLAG_UNKNOWN)
2303 strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2304 /* Trim trailing pipe */
2305 if (!ast_strlen_zero(tmp))
2306 tmp[strlen(tmp) - 1] = '\0';
2308 ast_copy_string(tmp, "(none)", sizeof(tmp));
2310 pc = strchr(dp->peercontext, '@');
2312 pc = dp->peercontext;
2315 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2316 if (dp->waiters[x] > -1)
2319 ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2321 ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2324 AST_LIST_LOCK(&dpcache);
2326 return RESULT_SUCCESS;
2329 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2331 static void unwrap_timestamp(struct iax_frame *fr)
2335 if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2336 x = fr->ts - iaxs[fr->callno]->last;
2338 /* Sudden big jump backwards in timestamp:
2339 What likely happened here is that miniframe timestamp has circled but we haven't
2340 gotten the update from the main packet. We'll just pretend that we did, and
2341 update the timestamp appropriately. */
2342 fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2344 ast_debug(1, "schedule_delivery: pushed forward timestamp\n");
2347 /* Sudden apparent big jump forwards in timestamp:
2348 What's likely happened is this is an old miniframe belonging to the previous
2349 top-16-bit timestamp that has turned up out of order.
2350 Adjust the timestamp appropriately. */
2351 fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2353 ast_debug(1, "schedule_delivery: pushed back timestamp\n");
2358 static int get_from_jb(void *p);
2360 static void update_jbsched(struct chan_iax2_pvt *pvt)
2364 when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2366 when = jb_next(pvt->jb) - when;
2368 if(pvt->jbid > -1) ast_sched_del(sched, pvt->jbid);
2371 /* XXX should really just empty until when > 0.. */
2375 pvt->jbid = ast_sched_add(sched, when, get_from_jb, CALLNO_TO_PTR(pvt->callno));
2377 /* Signal scheduler thread */
2378 signal_condition(&sched_lock, &sched_cond);
2381 static void __get_from_jb(void *p)
2383 int callno = PTR_TO_CALLNO(p);
2384 struct chan_iax2_pvt *pvt = NULL;
2385 struct iax_frame *fr;
2392 /* Make sure we have a valid private structure before going on */
2393 ast_mutex_lock(&iaxsl[callno]);
2397 ast_mutex_unlock(&iaxsl[callno]);
2403 gettimeofday(&tv,NULL);
2404 /* round up a millisecond since ast_sched_runq does; */
2405 /* prevents us from spinning while waiting for our now */
2406 /* to catch up with runq's now */
2409 now = ast_tvdiff_ms(tv, pvt->rxcore);
2411 if(now >= (next = jb_next(pvt->jb))) {
2412 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2417 /* __do_deliver() can cause the call to disappear */
2422 struct ast_frame af = { 0, };
2424 /* create an interpolation frame */
2425 af.frametype = AST_FRAME_VOICE;
2426 af.subclass = pvt->voiceformat;
2427 af.samples = frame.ms * 8;
2428 af.src = "IAX2 JB interpolation";
2429 af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2430 af.offset = AST_FRIENDLY_OFFSET;
2432 /* queue the frame: For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2433 * which we'd need to malloc, and then it would free it. That seems like a drag */
2434 if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE)) {
2435 iax2_queue_frame(callno, &af);
2436 /* iax2_queue_frame() could cause the call to disappear */
2442 iax2_frame_free(frame.data);
2449 /* shouldn't happen */
2454 update_jbsched(pvt);
2455 ast_mutex_unlock(&iaxsl[callno]);
2458 static int get_from_jb(void *data)
2460 #ifdef SCHED_MULTITHREADED
2461 if (schedule_action(__get_from_jb, data))
2463 __get_from_jb(data);
2468 * \note This function assumes fr->callno is locked
2470 * \note IMPORTANT NOTE!!! Any time this function is used, even if iaxs[callno]
2471 * was valid before calling it, it may no longer be valid after calling it.
2473 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2479 /* Attempt to recover wrapped timestamps */
2480 unwrap_timestamp(fr);
2482 /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2483 if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2484 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2487 ast_debug(1, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2489 fr->af.delivery = ast_tv(0,0);
2492 type = JB_TYPE_CONTROL;
2495 if(fr->af.frametype == AST_FRAME_VOICE) {
2496 type = JB_TYPE_VOICE;
2497 len = ast_codec_get_samples(&fr->af) / 8;
2498 } else if(fr->af.frametype == AST_FRAME_CNG) {
2499 type = JB_TYPE_SILENCE;
2502 if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2509 /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2510 * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2511 if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2512 iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2513 (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2516 /* deliver any frames in the jb */
2517 while (jb_getall(iaxs[fr->callno]->jb, &frame) == JB_OK) {
2518 __do_deliver(frame.data);
2519 /* __do_deliver() can make the call disappear */
2520 if (!iaxs[fr->callno])
2524 jb_reset(iaxs[fr->callno]->jb);
2526 if (iaxs[fr->callno]->jbid > -1)
2527 ast_sched_del(sched, iaxs[fr->callno]->jbid);
2529 iaxs[fr->callno]->jbid = -1;
2531 /* deliver this frame now */
2538 /* insert into jitterbuffer */
2539 /* TODO: Perhaps we could act immediately if it's not droppable and late */
2540 ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2541 calc_rxstamp(iaxs[fr->callno],fr->ts));
2542 if (ret == JB_DROP) {
2544 } else if (ret == JB_SCHED) {
2545 update_jbsched(iaxs[fr->callno]);
2550 /* Free our iax frame */
2551 iax2_frame_free(fr);
2557 static int iax2_transmit(struct iax_frame *fr)
2559 /* Lock the queue and place this packet at the end */
2560 /* By setting this to 0, the network thread will send it for us, and
2561 queue retransmission if necessary */
2563 AST_LIST_LOCK(&frame_queue);
2564 AST_LIST_INSERT_TAIL(&frame_queue, fr, list);
2565 AST_LIST_UNLOCK(&frame_queue);
2566 /* Wake up the network and scheduler thread */
2567 if (netthreadid != AST_PTHREADT_NULL)
2568 pthread_kill(netthreadid, SIGURG);
2569 signal_condition(&sched_lock, &sched_cond);
2575 static int iax2_digit_begin(struct ast_channel *c, char digit)
2577 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2580 static int iax2_digit_end(struct ast_channel *c, char digit, unsigned int duration)
2582 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2585 static int iax2_sendtext(struct ast_channel *c, const char *text)
2588 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2589 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2592 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2594 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2597 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2599 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2602 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2604 unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2605 ast_mutex_lock(&iaxsl[callno]);
2607 iaxs[callno]->owner = newchan;
2609 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2610 ast_mutex_unlock(&iaxsl[callno]);
2614 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2616 struct ast_variable *var;
2617 struct ast_variable *tmp;
2618 struct iax2_peer *peer=NULL;
2619 time_t regseconds = 0, nowtime;
2623 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2626 sprintf(porta, "%d", ntohs(sin->sin_port));
2627 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2629 /* We'll need the peer name in order to build the structure! */
2630 for (tmp = var; tmp; tmp = tmp->next) {
2631 if (!strcasecmp(tmp->name, "name"))
2632 peername = tmp->value;
2639 peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2642 ast_variables_destroy(var);
2646 for (tmp = var; tmp; tmp = tmp->next) {
2647 /* Make sure it's not a user only... */
2648 if (!strcasecmp(tmp->name, "type")) {
2649 if (strcasecmp(tmp->value, "friend") &&
2650 strcasecmp(tmp->value, "peer")) {
2651 /* Whoops, we weren't supposed to exist! */
2656 } else if (!strcasecmp(tmp->name, "regseconds")) {
2657 ast_get_time_t(tmp->value, ®seconds, 0, NULL);
2658 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2659 inet_aton(tmp->value, &(peer->addr.sin_addr));
2660 } else if (!strcasecmp(tmp->name, "port")) {
2661 peer->addr.sin_port = htons(atoi(tmp->value));
2662 } else if (!strcasecmp(tmp->name, "host")) {
2663 if (!strcasecmp(tmp->value, "dynamic"))
2668 ast_variables_destroy(var);
2673 if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2674 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
2675 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
2676 if (peer->expire > -1)
2677 ast_sched_del(sched, peer->expire);
2678 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, (void*)peer->name);
2680 AST_LIST_LOCK(&peers);
2681 AST_LIST_INSERT_HEAD(&peers, peer, entry);
2682 AST_LIST_UNLOCK(&peers);
2683 if (ast_test_flag(peer, IAX_DYNAMIC))
2684 reg_source_db(peer);
2686 ast_set_flag(peer, IAX_TEMPONLY);
2689 if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
2691 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
2692 memset(&peer->addr, 0, sizeof(peer->addr));
2693 realtime_update_peer(peer->name, &peer->addr, 0);
2694 ast_debug(1, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
2695 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2698 ast_debug(1, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
2699 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2706 static struct iax2_user *realtime_user(const char *username)
2708 struct ast_variable *var;
2709 struct ast_variable *tmp;
2710 struct iax2_user *user=NULL;
2712 var = ast_load_realtime("iaxusers", "name", username, NULL);
2718 /* Make sure it's not a peer only... */
2719 if (!strcasecmp(tmp->name, "type")) {
2720 if (strcasecmp(tmp->value, "friend") &&
2721 strcasecmp(tmp->value, "user")) {
2728 user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
2730 ast_variables_destroy(var);
2735 if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2736 ast_set_flag(user, IAX_RTCACHEFRIENDS);
2737 AST_LIST_LOCK(&users);
2738 AST_LIST_INSERT_HEAD(&users, user, entry);
2739 AST_LIST_UNLOCK(&users);
2741 ast_set_flag(user, IAX_TEMPONLY);
2747 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
2750 char regseconds[20];
2752 snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
2753 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2754 ast_update_realtime("iaxpeers", "name", peername,
2755 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port,
2756 "regseconds", regseconds, NULL);
2759 struct create_addr_info {
2772 char context[AST_MAX_CONTEXT];
2773 char peercontext[AST_MAX_CONTEXT];
2774 char mohinterpret[MAX_MUSICCLASS];
2775 char mohsuggest[MAX_MUSICCLASS];
2778 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
2780 struct iax2_peer *peer;
2782 ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
2783 cai->sockfd = defaultsockfd;
2785 sin->sin_family = AF_INET;
2787 if (!(peer = find_peer(peername, 1))) {
2789 if (ast_get_ip_or_srv(sin, peername, srvlookup ? "_iax._udp" : NULL)) {
2790 ast_log(LOG_WARNING, "No such host: %s\n", peername);
2793 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
2794 /* use global iax prefs for unknown peer/user */
2795 ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
2801 /* if the peer has no address (current or default), return failure */
2802 if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr)) {
2803 if (ast_test_flag(peer, IAX_TEMPONLY))
2808 /* if the peer is being monitored and is currently unreachable, return failure */
2809 if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0))) {
2810 if (ast_test_flag(peer, IAX_TEMPONLY))
2815 ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
2816 cai->maxtime = peer->maxms;
2817 cai->capability = peer->capability;
2818 cai->encmethods = peer->encmethods;
2819 cai->sockfd = peer->sockfd;
2820 cai->adsi = peer->adsi;
2821 ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
2822 ast_copy_string(cai->context, peer->context, sizeof(cai->context));
2823 ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
2824 ast_copy_string(cai->username, peer->username, sizeof(cai->username));
2825 ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
2826 ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
2827 ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
2828 ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
2829 if (ast_strlen_zero(peer->dbsecret)) {
2830 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
2835 family = ast_strdupa(peer->dbsecret);
2836 key = strchr(family, '/');
2839 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
2840 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
2841 if (ast_test_flag(peer, IAX_TEMPONLY))
2847 if (peer->addr.sin_addr.s_addr) {
2848 sin->sin_addr = peer->addr.sin_addr;
2849 sin->sin_port = peer->addr.sin_port;
2851 sin->sin_addr = peer->defaddr.sin_addr;
2852 sin->sin_port = peer->defaddr.sin_port;
2855 if (ast_test_flag(peer, IAX_TEMPONLY))
2861 static void __auto_congest(void *nothing)
2863 int callno = PTR_TO_CALLNO(nothing);
2864 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2865 ast_mutex_lock(&iaxsl[callno]);
2867 iaxs[callno]->initid = -1;
2868 iax2_queue_frame(callno, &f);
2869 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2871 ast_mutex_unlock(&iaxsl[callno]);
2874 static int auto_congest(void *data)
2876 #ifdef SCHED_MULTITHREADED
2877 if (schedule_action(__auto_congest, data))
2879 __auto_congest(data);
2883 static unsigned int iax2_datetime(const char *tz)
2889 if (!ast_strlen_zero(tz))
2890 ast_localtime(&t, &tm, tz);
2892 ast_localtime(&t, &tm, NULL);
2893 tmp = (tm.tm_sec >> 1) & 0x1f; /* 5 bits of seconds */
2894 tmp |= (tm.tm_min & 0x3f) << 5; /* 6 bits of minutes */
2895 tmp |= (tm.tm_hour & 0x1f) << 11; /* 5 bits of hours */
2896 tmp |= (tm.tm_mday & 0x1f) << 16; /* 5 bits of day of month */
2897 tmp |= ((tm.tm_mon + 1) & 0xf) << 21; /* 4 bits of month */
2898 tmp |= ((tm.tm_year - 100) & 0x7f) << 25; /* 7 bits of year */
2902 struct parsed_dial_string {
2914 * \brief Parses an IAX dial string into its component parts.
2915 * \param data the string to be parsed
2916 * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
2919 * This function parses the string and fills the structure
2920 * with pointers to its component parts. The input string
2923 * \note This function supports both plaintext passwords and RSA
2924 * key names; if the password string is formatted as '[keyname]',
2925 * then the keyname will be placed into the key field, and the
2926 * password field will be set to NULL.
2928 * \note The dial string format is:
2929 * [username[:password]@]peer[:port][/exten[@@context]][/options]
2931 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
2933 if (ast_strlen_zero(data))
2936 pds->peer = strsep(&data, "/");
2937 pds->exten = strsep(&data, "/");
2938 pds->options = data;
2942 pds->exten = strsep(&data, "@");
2943 pds->context = data;
2946 if (strchr(pds->peer, '@')) {
2948 pds->username = strsep(&data, "@");
2952 if (pds->username) {
2953 data = pds->username;
2954 pds->username = strsep(&data, ":");
2955 pds->password = data;
2959 pds->peer = strsep(&data, ":");
2962 /* check for a key name wrapped in [] in the secret position, if found,
2963 move it to the key field instead
2965 if (pds->password && (pds->password[0] == '[')) {
2966 pds->key = ast_strip_quoted(pds->password, "[", "]");
2967 pds->password = NULL;
2971 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
2973 struct sockaddr_in sin;
2974 char *l=NULL, *n=NULL, *tmpstr;
2975 struct iax_ie_data ied;
2976 char *defaultrdest = "s";
2977 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
2978 struct parsed_dial_string pds;
2979 struct create_addr_info cai;
2980 struct ast_var_t *var;
2981 const char* osp_token_ptr;
2982 unsigned int osp_token_length;
2983 unsigned char osp_block_index;
2984 unsigned int osp_block_length;
2985 unsigned char osp_buffer[256];
2987 if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
2988 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
2992 memset(&cai, 0, sizeof(cai));
2993 cai.encmethods = iax2_encryption;
2995 memset(&pds, 0, sizeof(pds));
2996 tmpstr = ast_strdupa(dest);
2997 parse_dial_string(tmpstr, &pds);
3000 pds.exten = defaultrdest;
3002 if (create_addr(pds.peer, &sin, &cai)) {
3003 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
3007 if (!pds.username && !ast_strlen_zero(cai.username))
3008 pds.username = cai.username;
3009 if (!pds.password && !ast_strlen_zero(cai.secret))
3010 pds.password = cai.secret;
3011 if (!pds.key && !ast_strlen_zero(cai.outkey))
3012 pds.key = cai.outkey;
3013 if (!pds.context && !ast_strlen_zero(cai.peercontext))
3014 pds.context = cai.peercontext;
3016 /* Keep track of the context for outgoing calls too */
3017 ast_copy_string(c->context, cai.context, sizeof(c->context));
3020 sin.sin_port = htons(atoi(pds.port));
3023 n = c->cid.cid_name;
3025 /* Now build request */
3026 memset(&ied, 0, sizeof(ied));
3028 /* On new call, first IE MUST be IAX version of caller */
3029 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
3030 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
3031 if (pds.options && strchr(pds.options, 'a')) {
3032 /* Request auto answer */
3033 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
3036 iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
3039 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
3040 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3043 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
3045 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
3048 iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->cid.cid_ton);
3049 iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->cid.cid_tns);
3052 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
3053 if (ast_test_flag(iaxs[callno], IAX_SENDANI) && c->cid.cid_ani)
3054 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->cid.cid_ani);
3056 if (!ast_strlen_zero(c->language))
3057 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
3058 if (!ast_strlen_zero(c->cid.cid_dnid))
3059 iax_ie_append_str(&ied, IAX_IE_DNID, c->cid.cid_dnid);
3060 if (!ast_strlen_zero(c->cid.cid_rdnis))
3061 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->cid.cid_rdnis);
3064 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
3067 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
3070 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
3072 ast_mutex_lock(&iaxsl[callno]);
3074 if (!ast_strlen_zero(c->context))
3075 ast_string_field_set(iaxs[callno], context, c->context);
3078 ast_string_field_set(iaxs[callno], username, pds.username);
3080 iaxs[callno]->encmethods = cai.encmethods;
3082 iaxs[callno]->adsi = cai.adsi;
3084 ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
3085 ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
3088 ast_string_field_set(iaxs[callno], outkey, pds.key);
3090 ast_string_field_set(iaxs[callno], secret, pds.password);
3092 iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
3093 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
3094 iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
3095 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
3097 if (iaxs[callno]->maxtime) {
3098 /* Initialize pingtime and auto-congest time */
3099 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
3100 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
3101 } else if (autokill) {
3102 iaxs[callno]->pingtime = autokill / 2;
3103 iaxs[callno]->initid = ast_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
3106 /* Check if there is an OSP token set by IAXCHANINFO function */
3107 osp_token_ptr = iaxs[callno]->osptoken;
3108 if (!ast_strlen_zero(osp_token_ptr)) {
3109 if ((osp_token_length = strlen(osp_token_ptr)) <= IAX_MAX_OSPTOKEN_SIZE) {
3110 osp_block_index = 0;
3111 while (osp_token_length > 0) {
3112 osp_block_length = IAX_MAX_OSPBLOCK_SIZE < osp_token_length ? IAX_MAX_OSPBLOCK_SIZE : osp_token_length;
3113 osp_buffer[0] = osp_block_index;
3114 memcpy(osp_buffer + 1, osp_token_ptr, osp_block_length);
3115 iax_ie_append_raw(&ied, IAX_IE_OSPTOKEN, osp_buffer, osp_block_length + 1);
3117 osp_token_ptr += osp_block_length;
3118 osp_token_length -= osp_block_length;
3121 ast_log(LOG_WARNING, "OSP token is too long\n");
3122 } else if (iaxdebug)
3123 ast_debug(1, "OSP token is undefined\n");
3125 /* send the command using the appropriate socket for this peer */
3126 iaxs[callno]->sockfd = cai.sockfd;
3128 /* Add remote vars */
3129 AST_LIST_TRAVERSE(&c->varshead, var, entries) {
3130 if (!strncmp(ast_var_name(var), "~IAX2~", strlen("~IAX2~"))) {
3133 /* Automatically divide the value up into sized chunks */
3134 for (i = 0; i < strlen(ast_var_value(var)); i += 255 - (strlen(ast_var_name(var)) - strlen("~IAX2~") + 1)) {
3135 snprintf(tmp, sizeof(tmp), "%s=%s", ast_var_name(var) + strlen("~IAX2~"), ast_var_value(var) + i);
3136 iax_ie_append_str(&ied, IAX_IE_VARIABLE, tmp);
3141 /* Transmit the string in a "NEW" request */
3142 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
3144 ast_mutex_unlock(&iaxsl[callno]);
3145 ast_setstate(c, AST_STATE_RINGING);
3150 static int iax2_hangup(struct ast_channel *c)
3152 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3154 struct iax_ie_data ied;
3155 memset(&ied, 0, sizeof(ied));
3156 ast_mutex_lock(&iaxsl[callno]);
3157 if (callno && iaxs[callno]) {
3158 ast_debug(1, "We're hanging up %s now...\n", c->name);
3159 alreadygone = ast_test_flag(iaxs[callno], IAX_ALREADYGONE);
3160 /* Send the hangup unless we have had a transmission error or are already gone */
3161 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)c->hangupcause);
3162 if (!iaxs[callno]->error && !alreadygone)
3163 send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
3164 /* Explicitly predestroy it */
3165 iax2_predestroy(callno);
3166 /* If we were already gone to begin with, destroy us now */
3168 ast_debug(1, "Really destroying %s now...\n", c->name);
3169 iax2_destroy(callno);
3172 ast_mutex_unlock(&iaxsl[callno]);
3173 if (option_verbose > 2)
3174 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
3178 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
3180 struct ast_option_header *h;
3184 case AST_OPTION_TXGAIN:
3185 case AST_OPTION_RXGAIN:
3186 /* these two cannot be sent, because they require a result */
3190 if (!(h = ast_malloc(datalen + sizeof(*h))))