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
37 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
41 #include <sys/types.h>
44 #include <sys/socket.h>
45 #include <netinet/in.h>
46 #include <arpa/inet.h>
47 #include <netinet/in_systm.h>
48 #include <netinet/ip.h>
50 #include <sys/signal.h>
62 #include <sys/ioctl.h>
63 #include <zaptel/zaptel.h>
66 #include "asterisk/lock.h"
67 #include "asterisk/frame.h"
68 #include "asterisk/channel.h"
69 #include "asterisk/logger.h"
70 #include "asterisk/module.h"
71 #include "asterisk/pbx.h"
72 #include "asterisk/sched.h"
73 #include "asterisk/io.h"
74 #include "asterisk/config.h"
75 #include "asterisk/options.h"
76 #include "asterisk/cli.h"
77 #include "asterisk/translate.h"
78 #include "asterisk/md5.h"
79 #include "asterisk/cdr.h"
80 #include "asterisk/crypto.h"
81 #include "asterisk/acl.h"
82 #include "asterisk/manager.h"
83 #include "asterisk/callerid.h"
84 #include "asterisk/app.h"
85 #include "asterisk/astdb.h"
86 #include "asterisk/musiconhold.h"
87 #include "asterisk/features.h"
88 #include "asterisk/utils.h"
89 #include "asterisk/causes.h"
90 #include "asterisk/localtime.h"
91 #include "asterisk/aes.h"
92 #include "asterisk/dnsmgr.h"
93 #include "asterisk/devicestate.h"
94 #include "asterisk/netsock.h"
95 #include "asterisk/stringfields.h"
96 #include "asterisk/linkedlists.h"
99 #include "iax2-parser.h"
100 #include "iax2-provision.h"
101 #include "jitterbuf.h"
103 /* Define SCHED_MULTITHREADED to run the scheduler in a special
104 multithreaded mode. */
105 #define SCHED_MULTITHREADED
107 /* Define DEBUG_SCHED_MULTITHREADED to keep track of where each
108 thread is actually doing. */
109 #define DEBUG_SCHED_MULTITHREAD
111 #ifndef IPTOS_MINCOST
112 #define IPTOS_MINCOST 0x02
116 static int nochecksums = 0;
120 #define PTR_TO_CALLNO(a) ((unsigned short)(unsigned long)(a))
121 #define CALLNO_TO_PTR(a) ((void *)(unsigned long)(a))
123 #define DEFAULT_THREAD_COUNT 10
124 #define DEFAULT_MAX_THREAD_COUNT 100
125 #define DEFAULT_RETRY_TIME 1000
126 #define MEMORY_SIZE 100
127 #define DEFAULT_DROP 3
128 /* Flag to use with trunk calls, keeping these calls high up. It halves our effective use
129 but keeps the division between trunked and non-trunked better. */
130 #define TRUNK_CALL_START 0x4000
132 #define DEBUG_SUPPORT
134 #define MIN_REUSE_TIME 60 /* Don't reuse a call number within 60 seconds */
136 /* Sample over last 100 units to determine historic jitter */
139 static struct ast_codec_pref prefs;
141 static const char tdesc[] = "Inter Asterisk eXchange Driver (Ver 2)";
143 static char context[80] = "default";
145 static char language[MAX_LANGUAGE] = "";
146 static char regcontext[AST_MAX_CONTEXT] = "";
148 static int maxauthreq = 3;
149 static int max_retries = 4;
150 static int ping_time = 20;
151 static int lagrq_time = 10;
152 static int maxtrunkcall = TRUNK_CALL_START;
153 static int maxnontrunkcall = 1;
154 static int maxjitterbuffer=1000;
155 static int resyncthreshold=1000;
156 static int maxjitterinterps=10;
157 static int trunkfreq = 20;
158 static int authdebug = 1;
159 static int autokill = 0;
160 static int iaxcompat = 0;
162 static int iaxdefaultdpcache=10 * 60; /* Cache dialplan entries for 10 minutes by default */
164 static int iaxdefaulttimeout = 5; /* Default to wait no more than 5 seconds for a reply to come back */
166 static unsigned int tos = 0;
168 static int min_reg_expire;
169 static int max_reg_expire;
171 static int timingfd = -1; /* Timing file descriptor */
173 static struct ast_netsock_list *netsock;
174 static int defaultsockfd = -1;
176 static int usecnt = 0;
178 int (*iax2_regfunk)(const char *username, int onoff) = NULL;
181 #define IAX_CAPABILITY_FULLBANDWIDTH 0xFFFF
183 #define IAX_CAPABILITY_MEDBANDWIDTH (IAX_CAPABILITY_FULLBANDWIDTH & \
184 ~AST_FORMAT_SLINEAR & \
188 #define IAX_CAPABILITY_LOWBANDWIDTH (IAX_CAPABILITY_MEDBANDWIDTH & \
190 ~AST_FORMAT_G726_AAL2 & \
193 #define IAX_CAPABILITY_LOWFREE (IAX_CAPABILITY_LOWBANDWIDTH & \
197 #define DEFAULT_MAXMS 2000 /* Must be faster than 2 seconds by default */
198 #define DEFAULT_FREQ_OK 60 * 1000 /* How often to check for the host to be up */
199 #define DEFAULT_FREQ_NOTOK 10 * 1000 /* How often to check, if the host is down... */
201 static struct io_context *io;
202 static struct sched_context *sched;
204 static int iax2_capability = IAX_CAPABILITY_FULLBANDWIDTH;
206 static int iaxdebug = 0;
208 static int iaxtrunkdebug = 0;
210 static int test_losspct = 0;
212 static int test_late = 0;
213 static int test_resync = 0;
214 static int test_jit = 0;
215 static int test_jitpct = 0;
216 #endif /* IAXTESTS */
218 static char accountcode[AST_MAX_ACCOUNT_CODE];
219 static char mohinterpret[MAX_MUSICCLASS];
220 static char mohsuggest[MAX_MUSICCLASS];
221 static int amaflags = 0;
223 static int delayreject = 0;
224 static int iax2_encryption = 0;
226 static struct ast_flags globalflags = { 0 };
228 static pthread_t netthreadid = AST_PTHREADT_NULL;
229 static pthread_t schedthreadid = AST_PTHREADT_NULL;
230 AST_MUTEX_DEFINE_STATIC(sched_lock);
231 static ast_cond_t sched_cond;
234 IAX_STATE_STARTED = (1 << 0),
235 IAX_STATE_AUTHENTICATED = (1 << 1),
236 IAX_STATE_TBD = (1 << 2),
237 IAX_STATE_UNCHANGED = (1 << 3),
240 struct iax2_context {
241 char context[AST_MAX_CONTEXT];
242 struct iax2_context *next;
246 IAX_HASCALLERID = (1 << 0), /*!< CallerID has been specified */
247 IAX_DELME = (1 << 1), /*!< Needs to be deleted */
248 IAX_TEMPONLY = (1 << 2), /*!< Temporary (realtime) */
249 IAX_TRUNK = (1 << 3), /*!< Treat as a trunk */
250 IAX_NOTRANSFER = (1 << 4), /*!< Don't native bridge */
251 IAX_USEJITTERBUF = (1 << 5), /*!< Use jitter buffer */
252 IAX_DYNAMIC = (1 << 6), /*!< dynamic peer */
253 IAX_SENDANI = (1 << 7), /*!< Send ANI along with CallerID */
254 /* (1 << 8) is currently unused due to the deprecation of an old option. Go ahead, take it! */
255 IAX_ALREADYGONE = (1 << 9), /*!< Already disconnected */
256 IAX_PROVISION = (1 << 10), /*!< This is a provisioning request */
257 IAX_QUELCH = (1 << 11), /*!< Whether or not we quelch audio */
258 IAX_ENCRYPTED = (1 << 12), /*!< Whether we should assume encrypted tx/rx */
259 IAX_KEYPOPULATED = (1 << 13), /*!< Whether we have a key populated */
260 IAX_CODEC_USER_FIRST = (1 << 14), /*!< are we willing to let the other guy choose the codec? */
261 IAX_CODEC_NOPREFS = (1 << 15), /*!< Force old behaviour by turning off prefs */
262 IAX_CODEC_NOCAP = (1 << 16), /*!< only consider requested format and ignore capabilities*/
263 IAX_RTCACHEFRIENDS = (1 << 17), /*!< let realtime stay till your reload */
264 IAX_RTUPDATE = (1 << 18), /*!< Send a realtime update */
265 IAX_RTAUTOCLEAR = (1 << 19), /*!< erase me on expire */
266 IAX_FORCEJITTERBUF = (1 << 20), /*!< Force jitterbuffer, even when bridged to a channel that can take jitter */
267 IAX_RTIGNOREREGEXPIRE = (1 << 21), /*!< When using realtime, ignore registration expiration */
268 IAX_TRUNKTIMESTAMPS = (1 << 22), /*!< Send trunk timestamps */
269 IAX_TRANSFERMEDIA = (1 << 23), /*!< When doing IAX2 transfers, transfer media only */
270 IAX_MAXAUTHREQ = (1 << 24), /*!< Maximum outstanding AUTHREQ restriction is in place */
273 static int global_rtautoclear = 120;
275 static int reload_config(void);
276 static int iax2_reload(int fd, int argc, char *argv[]);
280 AST_DECLARE_STRING_FIELDS(
281 AST_STRING_FIELD(name);
282 AST_STRING_FIELD(secret);
283 AST_STRING_FIELD(dbsecret);
284 AST_STRING_FIELD(accountcode);
285 AST_STRING_FIELD(mohinterpret);
286 AST_STRING_FIELD(mohsuggest);
287 AST_STRING_FIELD(inkeys); /*!< Key(s) this user can use to authenticate to us */
288 AST_STRING_FIELD(language);
289 AST_STRING_FIELD(cid_num);
290 AST_STRING_FIELD(cid_name);
299 int maxauthreq; /*!< Maximum allowed outstanding AUTHREQs */
300 int curauthreq; /*!< Current number of outstanding AUTHREQs */
301 struct ast_codec_pref prefs;
303 struct iax2_context *contexts;
304 struct ast_variable *vars;
305 AST_LIST_ENTRY(iax2_user) entry;
309 AST_DECLARE_STRING_FIELDS(
310 AST_STRING_FIELD(name);
311 AST_STRING_FIELD(username);
312 AST_STRING_FIELD(secret);
313 AST_STRING_FIELD(dbsecret);
314 AST_STRING_FIELD(outkey); /*!< What key we use to talk to this peer */
316 AST_STRING_FIELD(regexten); /*!< Extension to register (if regcontext is used) */
317 AST_STRING_FIELD(context); /*!< For transfers only */
318 AST_STRING_FIELD(peercontext); /*!< Context to pass to peer */
319 AST_STRING_FIELD(mailbox); /*!< Mailbox */
320 AST_STRING_FIELD(mohinterpret);
321 AST_STRING_FIELD(mohsuggest);
322 AST_STRING_FIELD(inkeys); /*!< Key(s) this peer can use to authenticate to us */
323 /* Suggested caller id if registering */
324 AST_STRING_FIELD(cid_num); /*!< Default context (for transfer really) */
325 AST_STRING_FIELD(cid_name); /*!< Default context (for transfer really) */
326 AST_STRING_FIELD(zonetag); /*!< Time Zone */
328 struct ast_codec_pref prefs;
329 struct ast_dnsmgr_entry *dnsmgr; /*!< DNS refresh manager */
330 struct sockaddr_in addr;
332 int sockfd; /*!< Socket to use for transmission */
337 /* Dynamic Registration fields */
338 struct sockaddr_in defaddr; /*!< Default address if there is one */
339 int authmethods; /*!< Authentication methods (IAX_AUTH_*) */
340 int encmethods; /*!< Encryption methods (IAX_ENCRYPT_*) */
342 int expire; /*!< Schedule entry for expiry */
343 int expiry; /*!< How soon to expire */
344 int capability; /*!< Capability */
347 int callno; /*!< Call number of POKE request */
348 int pokeexpire; /*!< Scheduled qualification-related task (ie iax2_poke_peer_s or iax2_poke_noanswer) */
349 int lastms; /*!< How long last response took (in ms), or -1 for no response */
350 int maxms; /*!< Max ms we will accept for the host to be up, 0 to not monitor */
352 int pokefreqok; /*!< How often to check if the host is up */
353 int pokefreqnotok; /*!< How often to check when the host has been determined to be down */
354 int historicms; /*!< How long recent average responses took */
355 int smoothing; /*!< Sample over how many units to determine historic ms */
358 AST_LIST_ENTRY(iax2_peer) entry;
361 #define IAX2_TRUNK_PREFACE (sizeof(struct iax_frame) + sizeof(struct ast_iax2_meta_hdr) + sizeof(struct ast_iax2_meta_trunk_hdr))
363 struct iax2_trunk_peer {
366 struct sockaddr_in addr;
367 struct timeval txtrunktime; /*!< Transmit trunktime */
368 struct timeval rxtrunktime; /*!< Receive trunktime */
369 struct timeval lasttxtime; /*!< Last transmitted trunktime */
370 struct timeval trunkact; /*!< Last trunk activity */
371 unsigned int lastsent; /*!< Last sent time */
372 /* Trunk data and length */
373 unsigned char *trunkdata;
374 unsigned int trunkdatalen;
375 unsigned int trunkdataalloc;
378 AST_LIST_ENTRY(iax2_trunk_peer) list;
381 static AST_LIST_HEAD_STATIC(tpeers, iax2_trunk_peer);
383 struct iax_firmware {
384 AST_LIST_ENTRY(iax_firmware) list;
388 struct ast_iax2_firmware_header *fwh;
393 REG_STATE_UNREGISTERED = 0,
396 REG_STATE_REGISTERED,
402 enum iax_transfer_state {
407 TRANSFER_PASSTHROUGH,
411 TRANSFER_MPASSTHROUGH,
416 struct iax2_registry {
417 struct sockaddr_in addr; /*!< Who we connect to for registration purposes */
419 char secret[80]; /*!< Password or key name in []'s */
421 int expire; /*!< Sched ID of expiration */
422 int refresh; /*!< How often to refresh */
423 enum iax_reg_state regstate;
424 int messages; /*!< Message count, low 8 bits = new, high 8 bits = old */
425 int callno; /*!< Associated call number if applicable */
426 struct sockaddr_in us; /*!< Who the server thinks we are */
427 struct iax2_registry *next;
428 struct ast_dnsmgr_entry *dnsmgr; /*!< DNS refresh manager */
431 static struct iax2_registry *registrations;
433 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
434 #define MIN_RETRY_TIME 100
435 #define MAX_RETRY_TIME 10000
437 #define MAX_JITTER_BUFFER 50
438 #define MIN_JITTER_BUFFER 10
440 #define DEFAULT_TRUNKDATA 640 * 10 /*!< 40ms, uncompressed linear * 10 channels */
441 #define MAX_TRUNKDATA 640 * 200 /*!< 40ms, uncompressed linear * 200 channels */
443 #define MAX_TIMESTAMP_SKEW 160 /*!< maximum difference between actual and predicted ts for sending */
445 /* If consecutive voice frame timestamps jump by more than this many milliseconds, then jitter buffer will resync */
446 #define TS_GAP_FOR_JB_RESYNC 5000
448 static int iaxthreadcount = DEFAULT_THREAD_COUNT;
449 static int iaxmaxthreadcount = DEFAULT_MAX_THREAD_COUNT;
450 static int iaxdynamicthreadcount = 0;
462 struct chan_iax2_pvt {
463 /*! Socket to send/receive on for this call */
465 /*! Last received voice format */
467 /*! Last received video format */
469 /*! Last sent voice format */
471 /*! Last sent video format */
473 /*! What we are capable of sending */
475 /*! Last received timestamp */
477 /*! Last sent timestamp - never send the same timestamp twice in a single call */
478 unsigned int lastsent;
479 /*! Next outgoing timestamp if everything is good */
480 unsigned int nextpred;
481 /*! True if the last voice we transmitted was not silence/CNG */
484 unsigned int pingtime;
485 /*! Max time for initial response */
488 struct sockaddr_in addr;
489 /*! Actual used codec preferences */
490 struct ast_codec_pref prefs;
491 /*! Requested codec preferences */
492 struct ast_codec_pref rprefs;
493 /*! Our call number */
494 unsigned short callno;
496 unsigned short peercallno;
497 /*! Peer selected format */
499 /*! Peer capability */
501 /*! timeval that we base our transmission on */
502 struct timeval offset;
503 /*! timeval that we base our delivery on */
504 struct timeval rxcore;
505 /*! The jitterbuffer */
507 /*! active jb read scheduler id */
511 /*! Error, as discovered by the manager */
513 /*! Owner if we have one */
514 struct ast_channel *owner;
515 /*! What's our state? */
516 struct ast_flags state;
517 /*! Expiry (optional) */
519 /*! Next outgoing sequence number */
520 unsigned char oseqno;
521 /*! Next sequence number they have not yet acknowledged */
522 unsigned char rseqno;
523 /*! Next incoming sequence number */
524 unsigned char iseqno;
525 /*! Last incoming sequence number we have acknowledged */
526 unsigned char aseqno;
528 AST_DECLARE_STRING_FIELDS(
530 AST_STRING_FIELD(peer);
531 /*! Default Context */
532 AST_STRING_FIELD(context);
533 /*! Caller ID if available */
534 AST_STRING_FIELD(cid_num);
535 AST_STRING_FIELD(cid_name);
536 /*! Hidden Caller ID (i.e. ANI) if appropriate */
537 AST_STRING_FIELD(ani);
539 AST_STRING_FIELD(dnid);
541 AST_STRING_FIELD(rdnis);
542 /*! Requested Extension */
543 AST_STRING_FIELD(exten);
544 /*! Expected Username */
545 AST_STRING_FIELD(username);
546 /*! Expected Secret */
547 AST_STRING_FIELD(secret);
549 AST_STRING_FIELD(challenge);
550 /*! Public keys permitted keys for incoming authentication */
551 AST_STRING_FIELD(inkeys);
552 /*! Private key for outgoing authentication */
553 AST_STRING_FIELD(outkey);
554 /*! Preferred language */
555 AST_STRING_FIELD(language);
556 /*! Hostname/peername for naming purposes */
557 AST_STRING_FIELD(host);
559 AST_STRING_FIELD(dproot);
560 AST_STRING_FIELD(accountcode);
561 AST_STRING_FIELD(mohinterpret);
562 AST_STRING_FIELD(mohsuggest);
565 /*! permitted authentication methods */
567 /*! permitted encryption methods */
569 /*! Encryption AES-128 Key */
571 /*! Decryption AES-128 Key */
573 /*! 32 bytes of semi-random data */
574 unsigned char semirand[32];
575 /*! Associated registry */
576 struct iax2_registry *reg;
577 /*! Associated peer for poking */
578 struct iax2_peer *peerpoke;
583 /*! Transferring status */
584 enum iax_transfer_state transferring;
585 /*! Transfer identifier */
587 /*! Who we are IAX transfering to */
588 struct sockaddr_in transfer;
589 /*! What's the new call number for the transfer */
590 unsigned short transfercallno;
591 /*! Transfer decrypt AES-128 Key */
592 aes_encrypt_ctx tdcx;
594 /*! Status of knowledge of peer ADSI capability */
597 /*! Who we are bridged to */
598 unsigned short bridgecallno;
600 int pingid; /*!< Transmit PING request */
601 int lagid; /*!< Retransmit lag request */
602 int autoid; /*!< Auto hangup for Dialplan requestor */
603 int authid; /*!< Authentication rejection ID */
604 int authfail; /*!< Reason to report failure */
605 int initid; /*!< Initial peer auto-congest ID (based on qualified peers) */
610 AST_LIST_HEAD_NOLOCK(, iax2_dpcache) dpentries;
611 struct ast_variable *vars;
612 /*! last received remote rr */
613 struct iax_rr remote_rr;
614 /*! Current base time: (just for stats) */
616 /*! Dropped frame count: (just for stats) */
618 /*! received frame count: (just for stats) */
622 static struct ast_iax2_queue {
623 AST_LIST_HEAD(, iax_frame) queue;
626 .queue = AST_LIST_HEAD_INIT_VALUE
629 static AST_LIST_HEAD_STATIC(users, iax2_user);
631 static AST_LIST_HEAD_STATIC(peers, iax2_peer);
633 static AST_LIST_HEAD_STATIC(firmwares, iax_firmware);
635 /*! Extension exists */
636 #define CACHE_FLAG_EXISTS (1 << 0)
637 /*! Extension is nonexistent */
638 #define CACHE_FLAG_NONEXISTENT (1 << 1)
639 /*! Extension can exist */
640 #define CACHE_FLAG_CANEXIST (1 << 2)
641 /*! Waiting to hear back response */
642 #define CACHE_FLAG_PENDING (1 << 3)
644 #define CACHE_FLAG_TIMEOUT (1 << 4)
645 /*! Request transmitted */
646 #define CACHE_FLAG_TRANSMITTED (1 << 5)
648 #define CACHE_FLAG_UNKNOWN (1 << 6)
650 #define CACHE_FLAG_MATCHMORE (1 << 7)
652 struct iax2_dpcache {
653 char peercontext[AST_MAX_CONTEXT];
654 char exten[AST_MAX_EXTENSION];
656 struct timeval expiry;
658 unsigned short callno;
660 AST_LIST_ENTRY(iax2_dpcache) cache_list;
661 AST_LIST_ENTRY(iax2_dpcache) peer_list;
664 static AST_LIST_HEAD_STATIC(dpcache, iax2_dpcache);
666 static void reg_source_db(struct iax2_peer *p);
667 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin);
669 static void destroy_peer(struct iax2_peer *peer);
670 static int ast_cli_netstats(struct mansession *s, int fd, int limit_fmt);
672 #define IAX_IOSTATE_IDLE 0
673 #define IAX_IOSTATE_READY 1
674 #define IAX_IOSTATE_PROCESSING 2
675 #define IAX_IOSTATE_SCHEDREADY 3
677 #define IAX_TYPE_POOL 1
678 #define IAX_TYPE_DYNAMIC 2
681 AST_LIST_ENTRY(iax2_thread) list;
684 #ifdef SCHED_MULTITHREADED
685 void (*schedfunc)(void *);
688 #ifdef DEBUG_SCHED_MULTITHREAD
694 struct sockaddr_in iosin;
695 unsigned char buf[4096];
704 static AST_LIST_HEAD_STATIC(idle_list, iax2_thread);
705 static AST_LIST_HEAD_STATIC(active_list, iax2_thread);
706 static AST_LIST_HEAD_STATIC(dynamic_list, iax2_thread);
708 static void *iax2_process_thread(void *data);
710 static void signal_condition(ast_mutex_t *lock, ast_cond_t *cond)
712 ast_mutex_lock(lock);
713 ast_cond_signal(cond);
714 ast_mutex_unlock(lock);
717 static void iax_debug_output(const char *data)
720 ast_verbose("%s", data);
723 static void iax_error_output(const char *data)
725 ast_log(LOG_WARNING, "%s", data);
728 static void jb_error_output(const char *fmt, ...)
734 vsnprintf(buf, 1024, fmt, args);
737 ast_log(LOG_ERROR, buf);
740 static void jb_warning_output(const char *fmt, ...)
746 vsnprintf(buf, 1024, fmt, args);
749 ast_log(LOG_WARNING, buf);
752 static void jb_debug_output(const char *fmt, ...)
758 vsnprintf(buf, 1024, fmt, args);
764 /* XXX We probably should use a mutex when working with this XXX */
765 static struct chan_iax2_pvt *iaxs[IAX_MAX_CALLS];
766 static ast_mutex_t iaxsl[IAX_MAX_CALLS];
767 static struct timeval lastused[IAX_MAX_CALLS];
769 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);
770 static int expire_registry(void *data);
771 static int iax2_answer(struct ast_channel *c);
772 static int iax2_call(struct ast_channel *c, char *dest, int timeout);
773 static int iax2_devicestate(void *data);
774 static int iax2_digit_begin(struct ast_channel *c, char digit);
775 static int iax2_digit_end(struct ast_channel *c, char digit);
776 static int iax2_do_register(struct iax2_registry *reg);
777 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan);
778 static int iax2_hangup(struct ast_channel *c);
779 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen);
780 static int iax2_poke_peer(struct iax2_peer *peer, int heldcall);
781 static int iax2_provision(struct sockaddr_in *end, int sockfd, char *dest, const char *template, int force);
782 static int iax2_send(struct chan_iax2_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final);
783 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen);
784 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img);
785 static int iax2_sendtext(struct ast_channel *c, const char *text);
786 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen);
787 static int iax2_transfer(struct ast_channel *c, const char *dest);
788 static int iax2_write(struct ast_channel *c, struct ast_frame *f);
789 static int send_command(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
790 static int send_command_final(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
791 static int send_command_immediate(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int, int);
792 static int send_command_locked(unsigned short callno, char, int, unsigned int, const unsigned char *, int, int);
793 static int send_command_transfer(struct chan_iax2_pvt *, char, int, unsigned int, const unsigned char *, int);
794 static struct ast_channel *iax2_request(const char *type, int format, void *data, int *cause);
795 static struct ast_frame *iax2_read(struct ast_channel *c);
796 static struct iax2_peer *build_peer(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
797 static struct iax2_user *build_user(const char *name, struct ast_variable *v, struct ast_variable *alt, int temponly);
798 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime);
799 static void destroy_user(struct iax2_user *user);
800 static void prune_peers(void);
802 static const struct ast_channel_tech iax2_tech = {
804 .description = tdesc,
805 .capabilities = IAX_CAPABILITY_FULLBANDWIDTH,
806 .properties = AST_CHAN_TP_WANTSJITTER,
807 .requester = iax2_request,
808 .devicestate = iax2_devicestate,
809 .send_digit_begin = iax2_digit_begin,
810 .send_digit_end = iax2_digit_end,
811 .send_text = iax2_sendtext,
812 .send_image = iax2_sendimage,
813 .send_html = iax2_sendhtml,
815 .hangup = iax2_hangup,
816 .answer = iax2_answer,
819 .write_video = iax2_write,
820 .indicate = iax2_indicate,
821 .setoption = iax2_setoption,
822 .bridge = iax2_bridge,
823 .transfer = iax2_transfer,
827 static struct iax2_thread *find_idle_thread(void)
829 struct iax2_thread *thread = NULL;
831 /* Pop the head of the list off */
832 AST_LIST_LOCK(&idle_list);
833 thread = AST_LIST_REMOVE_HEAD(&idle_list, list);
834 AST_LIST_UNLOCK(&idle_list);
836 /* If no idle thread is available from the regular list, try dynamic */
837 if (thread == NULL) {
838 AST_LIST_LOCK(&dynamic_list);
839 thread = AST_LIST_FIRST(&dynamic_list);
840 if (thread != NULL) {
841 AST_LIST_REMOVE(&dynamic_list, thread, list);
843 /* Make sure we absolutely have a thread... if not, try to make one if allowed */
844 if (thread == NULL && iaxmaxthreadcount > iaxdynamicthreadcount) {
845 /* We need to MAKE a thread! */
846 thread = ast_calloc(1, sizeof(*thread));
847 if (thread != NULL) {
848 thread->threadnum = iaxdynamicthreadcount;
849 thread->type = IAX_TYPE_DYNAMIC;
850 ast_mutex_init(&thread->lock);
851 ast_cond_init(&thread->cond, NULL);
852 if (ast_pthread_create(&thread->threadid, NULL, iax2_process_thread, thread)) {
856 /* All went well and the thread is up, so increment our count */
857 iaxdynamicthreadcount++;
861 AST_LIST_UNLOCK(&dynamic_list);
867 #ifdef SCHED_MULTITHREADED
868 static int __schedule_action(void (*func)(void *data), void *data, const char *funcname)
870 struct iax2_thread *thread = NULL;
871 static time_t lasterror;
874 thread = find_idle_thread();
876 if (thread != NULL) {
877 thread->schedfunc = func;
878 thread->scheddata = data;
879 thread->iostate = IAX_IOSTATE_SCHEDREADY;
880 #ifdef DEBUG_SCHED_MULTITHREAD
881 ast_copy_string(thread->curfunc, funcname, sizeof(thread->curfunc));
883 signal_condition(&thread->lock, &thread->cond);
888 ast_log(LOG_NOTICE, "Out of idle IAX2 threads for scheduling!\n");
893 #define schedule_action(func, data) __schedule_action(func, data, __PRETTY_FUNCTION__)
896 static void __send_ping(void *data)
898 int callno = (long)data;
899 send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
902 static int send_ping(void *data)
904 int callno = (long)data;
906 #ifdef SCHED_MULTITHREADED
907 if (schedule_action(__send_ping, data))
916 static int get_encrypt_methods(const char *s)
919 if (!strcasecmp(s, "aes128"))
920 e = IAX_ENCRYPT_AES128;
921 else if (ast_true(s))
922 e = IAX_ENCRYPT_AES128;
928 static void __send_lagrq(void *data)
930 int callno = (long)data;
931 /* Ping only if it's real not if it's bridged */
932 send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
935 static int send_lagrq(void *data)
937 int callno = (long)data;
939 #ifdef SCHED_MULTITHREADED
940 if (schedule_action(__send_lagrq, data))
949 static unsigned char compress_subclass(int subclass)
953 /* If it's 128 or smaller, just return it */
954 if (subclass < IAX_FLAG_SC_LOG)
956 /* Otherwise find its power */
957 for (x = 0; x < IAX_MAX_SHIFT; x++) {
958 if (subclass & (1 << x)) {
960 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
966 return power | IAX_FLAG_SC_LOG;
969 static int uncompress_subclass(unsigned char csub)
971 /* If the SC_LOG flag is set, return 2^csub otherwise csub */
972 if (csub & IAX_FLAG_SC_LOG) {
973 /* special case for 'compressed' -1 */
977 return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
983 static struct iax2_peer *find_peer(const char *name, int realtime)
985 struct iax2_peer *peer = NULL;
987 /* Grab peer from linked list */
988 AST_LIST_LOCK(&peers);
989 AST_LIST_TRAVERSE(&peers, peer, entry) {
990 if (!strcasecmp(peer->name, name)) {
994 AST_LIST_UNLOCK(&peers);
996 /* Now go for realtime if applicable */
997 if(!peer && realtime)
998 peer = realtime_peer(name, NULL);
1002 static int iax2_getpeername(struct sockaddr_in sin, char *host, int len, int lockpeer)
1004 struct iax2_peer *peer = NULL;
1008 AST_LIST_LOCK(&peers);
1009 AST_LIST_TRAVERSE(&peers, peer, entry) {
1010 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
1011 (peer->addr.sin_port == sin.sin_port)) {
1012 ast_copy_string(host, peer->name, len);
1018 AST_LIST_UNLOCK(&peers);
1020 peer = realtime_peer(NULL, &sin);
1022 ast_copy_string(host, peer->name, len);
1023 if (ast_test_flag(peer, IAX_TEMPONLY))
1032 static struct chan_iax2_pvt *new_iax(struct sockaddr_in *sin, int lockpeer, const char *host)
1034 struct chan_iax2_pvt *tmp;
1037 if (!(tmp = ast_calloc(1, sizeof(*tmp))))
1040 if (ast_string_field_init(tmp, 32)) {
1048 tmp->peercallno = 0;
1049 tmp->transfercallno = 0;
1050 tmp->bridgecallno = 0;
1057 ast_string_field_set(tmp,exten, "s");
1058 ast_string_field_set(tmp,host, host);
1062 jbconf.max_jitterbuf = maxjitterbuffer;
1063 jbconf.resync_threshold = resyncthreshold;
1064 jbconf.max_contig_interp = maxjitterinterps;
1065 jb_setconf(tmp->jb,&jbconf);
1067 AST_LIST_HEAD_INIT_NOLOCK(&tmp->dpentries);
1072 static struct iax_frame *iaxfrdup2(struct iax_frame *fr)
1074 struct iax_frame *new = iax_frame_new(DIRECTION_INGRESS, fr->af.datalen);
1076 size_t mallocd_datalen = new->mallocd_datalen;
1077 memcpy(new, fr, sizeof(*new));
1078 iax_frame_wrap(new, &fr->af);
1079 new->mallocd_datalen = mallocd_datalen;
1082 new->direction = DIRECTION_INGRESS;
1088 #define NEW_PREVENT 0
1092 static int match(struct sockaddr_in *sin, unsigned short callno, unsigned short dcallno, struct chan_iax2_pvt *cur)
1094 if ((cur->addr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1095 (cur->addr.sin_port == sin->sin_port)) {
1096 /* This is the main host */
1097 if ((cur->peercallno == callno) ||
1098 ((dcallno == cur->callno) && !cur->peercallno)) {
1099 /* That's us. Be sure we keep track of the peer call number */
1103 if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
1104 (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
1105 /* We're transferring */
1106 if (dcallno == cur->callno)
1112 static void update_max_trunk(void)
1114 int max = TRUNK_CALL_START;
1116 /* XXX Prolly don't need locks here XXX */
1117 for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1122 if (option_debug && iaxdebug)
1123 ast_log(LOG_DEBUG, "New max trunk callno is %d\n", max);
1126 static void update_max_nontrunk(void)
1130 /* XXX Prolly don't need locks here XXX */
1131 for (x=1;x<TRUNK_CALL_START - 1; x++) {
1135 maxnontrunkcall = max;
1136 if (option_debug && iaxdebug)
1137 ast_log(LOG_DEBUG, "New max nontrunk callno is %d\n", max);
1140 static int make_trunk(unsigned short callno, int locked)
1145 if (iaxs[callno]->oseqno) {
1146 ast_log(LOG_WARNING, "Can't make trunk once a call has started!\n");
1149 if (callno & TRUNK_CALL_START) {
1150 ast_log(LOG_WARNING, "Call %d is already a trunk\n", callno);
1153 gettimeofday(&now, NULL);
1154 for (x=TRUNK_CALL_START;x<IAX_MAX_CALLS - 1; x++) {
1155 ast_mutex_lock(&iaxsl[x]);
1156 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) {
1157 iaxs[x] = iaxs[callno];
1158 iaxs[x]->callno = x;
1159 iaxs[callno] = NULL;
1160 /* Update the two timers that should have been started */
1161 if (iaxs[x]->pingid > -1)
1162 ast_sched_del(sched, iaxs[x]->pingid);
1163 if (iaxs[x]->lagid > -1)
1164 ast_sched_del(sched, iaxs[x]->lagid);
1165 iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1166 iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1168 ast_mutex_unlock(&iaxsl[callno]);
1171 ast_mutex_unlock(&iaxsl[x]);
1174 ast_mutex_unlock(&iaxsl[x]);
1176 if (x >= IAX_MAX_CALLS - 1) {
1177 ast_log(LOG_WARNING, "Unable to trunk call: Insufficient space\n");
1180 ast_log(LOG_DEBUG, "Made call %d into trunk call %d\n", callno, x);
1181 /* We move this call from a non-trunked to a trunked call */
1183 update_max_nontrunk();
1187 static int find_callno(unsigned short callno, unsigned short dcallno, struct sockaddr_in *sin, int new, int lockpeer, int sockfd)
1193 if (new <= NEW_ALLOW) {
1194 /* Look for an existing connection first */
1195 for (x=1;(res < 1) && (x<maxnontrunkcall);x++) {
1196 ast_mutex_lock(&iaxsl[x]);
1198 /* Look for an exact match */
1199 if (match(sin, callno, dcallno, iaxs[x])) {
1203 ast_mutex_unlock(&iaxsl[x]);
1205 for (x=TRUNK_CALL_START;(res < 1) && (x<maxtrunkcall);x++) {
1206 ast_mutex_lock(&iaxsl[x]);
1208 /* Look for an exact match */
1209 if (match(sin, callno, dcallno, iaxs[x])) {
1213 ast_mutex_unlock(&iaxsl[x]);
1216 if ((res < 1) && (new >= NEW_ALLOW)) {
1217 if (!iax2_getpeername(*sin, host, sizeof(host), lockpeer))
1218 snprintf(host, sizeof(host), "%s:%d", ast_inet_ntoa(sin->sin_addr), ntohs(sin->sin_port));
1219 gettimeofday(&now, NULL);
1220 for (x=1;x<TRUNK_CALL_START;x++) {
1221 /* Find first unused call number that hasn't been used in a while */
1222 ast_mutex_lock(&iaxsl[x]);
1223 if (!iaxs[x] && ((now.tv_sec - lastused[x].tv_sec) > MIN_REUSE_TIME)) break;
1224 ast_mutex_unlock(&iaxsl[x]);
1226 /* We've still got lock held if we found a spot */
1227 if (x >= TRUNK_CALL_START) {
1228 ast_log(LOG_WARNING, "No more space\n");
1231 iaxs[x] = new_iax(sin, lockpeer, host);
1232 update_max_nontrunk();
1234 if (option_debug && iaxdebug)
1235 ast_log(LOG_DEBUG, "Creating new call structure %d\n", x);
1236 iaxs[x]->sockfd = sockfd;
1237 iaxs[x]->addr.sin_port = sin->sin_port;
1238 iaxs[x]->addr.sin_family = sin->sin_family;
1239 iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
1240 iaxs[x]->peercallno = callno;
1241 iaxs[x]->callno = x;
1242 iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
1243 iaxs[x]->expiry = min_reg_expire;
1244 iaxs[x]->pingid = ast_sched_add(sched, ping_time * 1000, send_ping, (void *)(long)x);
1245 iaxs[x]->lagid = ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)(long)x);
1246 iaxs[x]->amaflags = amaflags;
1247 ast_copy_flags(iaxs[x], (&globalflags), IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
1249 ast_string_field_set(iaxs[x], accountcode, accountcode);
1250 ast_string_field_set(iaxs[x], mohinterpret, mohinterpret);
1251 ast_string_field_set(iaxs[x], mohsuggest, mohsuggest);
1253 ast_log(LOG_WARNING, "Out of resources\n");
1254 ast_mutex_unlock(&iaxsl[x]);
1257 ast_mutex_unlock(&iaxsl[x]);
1263 static void iax2_frame_free(struct iax_frame *fr)
1265 if (fr->retrans > -1)
1266 ast_sched_del(sched, fr->retrans);
1270 static int iax2_queue_frame(int callno, struct ast_frame *f)
1272 /* Assumes lock for callno is already held... */
1274 if (iaxs[callno] && iaxs[callno]->owner) {
1275 if (ast_mutex_trylock(&iaxs[callno]->owner->lock)) {
1276 /* Avoid deadlock by pausing and trying again */
1277 ast_mutex_unlock(&iaxsl[callno]);
1279 ast_mutex_lock(&iaxsl[callno]);
1281 ast_queue_frame(iaxs[callno]->owner, f);
1282 ast_mutex_unlock(&iaxs[callno]->owner->lock);
1291 static void destroy_firmware(struct iax_firmware *cur)
1293 /* Close firmware */
1295 munmap(cur->fwh, ntohl(cur->fwh->datalen) + sizeof(*(cur->fwh)));
1301 static int try_firmware(char *s)
1304 struct iax_firmware *cur = NULL;
1305 int ifd, fd, res, len, chunk;
1306 struct ast_iax2_firmware_header *fwh, fwh2;
1307 struct MD5Context md5;
1308 unsigned char sum[16], buf[1024];
1311 if (!(s2 = alloca(strlen(s) + 100))) {
1312 ast_log(LOG_WARNING, "Alloca failed!\n");
1316 last = strrchr(s, '/');
1322 snprintf(s2, strlen(s) + 100, "/var/tmp/%s-%ld", last, (unsigned long)ast_random());
1324 if ((res = stat(s, &stbuf) < 0)) {
1325 ast_log(LOG_WARNING, "Failed to stat '%s': %s\n", s, strerror(errno));
1329 /* Make sure it's not a directory */
1330 if (S_ISDIR(stbuf.st_mode))
1332 ifd = open(s, O_RDONLY);
1334 ast_log(LOG_WARNING, "Cannot open '%s': %s\n", s, strerror(errno));
1337 fd = open(s2, O_RDWR | O_CREAT | O_EXCL);
1339 ast_log(LOG_WARNING, "Cannot open '%s' for writing: %s\n", s2, strerror(errno));
1343 /* Unlink our newly created file */
1346 /* Now copy the firmware into it */
1347 len = stbuf.st_size;
1350 if (chunk > sizeof(buf))
1351 chunk = sizeof(buf);
1352 res = read(ifd, buf, chunk);
1354 ast_log(LOG_WARNING, "Only read %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1359 res = write(fd, buf, chunk);
1361 ast_log(LOG_WARNING, "Only write %d of %d bytes of data :(: %s\n", res, chunk, strerror(errno));
1369 /* Return to the beginning */
1370 lseek(fd, 0, SEEK_SET);
1371 if ((res = read(fd, &fwh2, sizeof(fwh2))) != sizeof(fwh2)) {
1372 ast_log(LOG_WARNING, "Unable to read firmware header in '%s'\n", s);
1376 if (ntohl(fwh2.magic) != IAX_FIRMWARE_MAGIC) {
1377 ast_log(LOG_WARNING, "'%s' is not a valid firmware file\n", s);
1381 if (ntohl(fwh2.datalen) != (stbuf.st_size - sizeof(fwh2))) {
1382 ast_log(LOG_WARNING, "Invalid data length in firmware '%s'\n", s);
1386 if (fwh2.devname[sizeof(fwh2.devname) - 1] || ast_strlen_zero((char *)fwh2.devname)) {
1387 ast_log(LOG_WARNING, "No or invalid device type specified for '%s'\n", s);
1391 fwh = mmap(NULL, stbuf.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
1393 ast_log(LOG_WARNING, "mmap failed: %s\n", strerror(errno));
1398 MD5Update(&md5, fwh->data, ntohl(fwh->datalen));
1399 MD5Final(sum, &md5);
1400 if (memcmp(sum, fwh->chksum, sizeof(sum))) {
1401 ast_log(LOG_WARNING, "Firmware file '%s' fails checksum\n", s);
1402 munmap(fwh, stbuf.st_size);
1407 AST_LIST_TRAVERSE(&firmwares, cur, list) {
1408 if (!strcmp((char *)cur->fwh->devname, (char *)fwh->devname)) {
1409 /* Found a candidate */
1410 if (cur->dead || (ntohs(cur->fwh->version) < ntohs(fwh->version)))
1411 /* The version we have on loaded is older, load this one instead */
1413 /* This version is no newer than what we have. Don't worry about it.
1414 We'll consider it a proper load anyhow though */
1415 munmap(fwh, stbuf.st_size);
1421 if (!cur && ((cur = ast_calloc(1, sizeof(*cur))))) {
1423 AST_LIST_INSERT_TAIL(&firmwares, cur, list);
1428 munmap(cur->fwh, cur->mmaplen);
1433 cur->mmaplen = stbuf.st_size;
1440 static int iax_check_version(char *dev)
1443 struct iax_firmware *cur = NULL;
1445 if (ast_strlen_zero(dev))
1448 AST_LIST_LOCK(&firmwares);
1449 AST_LIST_TRAVERSE(&firmwares, cur, list) {
1450 if (!strcmp(dev, (char *)cur->fwh->devname)) {
1451 res = ntohs(cur->fwh->version);
1455 AST_LIST_UNLOCK(&firmwares);
1460 static int iax_firmware_append(struct iax_ie_data *ied, const unsigned char *dev, unsigned int desc)
1463 unsigned int bs = desc & 0xff;
1464 unsigned int start = (desc >> 8) & 0xffffff;
1466 struct iax_firmware *cur;
1468 if (ast_strlen_zero((char *)dev) || !bs)
1473 AST_LIST_LOCK(&firmwares);
1474 AST_LIST_TRAVERSE(&firmwares, cur, list) {
1475 if (strcmp((char *)dev, (char *)cur->fwh->devname))
1477 iax_ie_append_int(ied, IAX_IE_FWBLOCKDESC, desc);
1478 if (start < ntohl(cur->fwh->datalen)) {
1479 bytes = ntohl(cur->fwh->datalen) - start;
1482 iax_ie_append_raw(ied, IAX_IE_FWBLOCKDATA, cur->fwh->data + start, bytes);
1485 iax_ie_append(ied, IAX_IE_FWBLOCKDATA);
1493 AST_LIST_UNLOCK(&firmwares);
1499 static void reload_firmware(void)
1501 struct iax_firmware *cur = NULL;
1504 char dir[256], fn[256];
1506 AST_LIST_LOCK(&firmwares);
1508 /* Mark all as dead */
1509 AST_LIST_TRAVERSE(&firmwares, cur, list)
1512 /* Now that we have marked them dead... load new ones */
1513 snprintf(dir, sizeof(dir), "%s/firmware/iax", (char *)ast_config_AST_DATA_DIR);
1516 while((de = readdir(fwd))) {
1517 if (de->d_name[0] != '.') {
1518 snprintf(fn, sizeof(fn), "%s/%s", dir, de->d_name);
1519 if (!try_firmware(fn)) {
1520 if (option_verbose > 1)
1521 ast_verbose(VERBOSE_PREFIX_2 "Loaded firmware '%s'\n", de->d_name);
1527 ast_log(LOG_WARNING, "Error opening firmware directory '%s': %s\n", dir, strerror(errno));
1529 /* Clean up leftovers */
1530 AST_LIST_TRAVERSE_SAFE_BEGIN(&firmwares, cur, list) {
1533 AST_LIST_REMOVE_CURRENT(&firmwares, list);
1534 destroy_firmware(cur);
1536 AST_LIST_TRAVERSE_SAFE_END
1538 AST_LIST_UNLOCK(&firmwares);
1541 static int __do_deliver(void *data)
1543 /* Just deliver the packet by using queueing. This is called by
1544 the IAX thread with the iaxsl lock held. */
1545 struct iax_frame *fr = data;
1547 fr->af.has_timing_info = 0;
1548 if (iaxs[fr->callno] && !ast_test_flag(iaxs[fr->callno], IAX_ALREADYGONE))
1549 iax2_queue_frame(fr->callno, &fr->af);
1550 /* Free our iax frame */
1551 iax2_frame_free(fr);
1552 /* And don't run again */
1556 static int handle_error(void)
1558 /* XXX Ideally we should figure out why an error occured and then abort those
1559 rather than continuing to try. Unfortunately, the published interface does
1560 not seem to work XXX */
1562 struct sockaddr_in *sin;
1565 struct sock_extended_err e;
1570 m.msg_controllen = sizeof(e);
1572 res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
1574 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
1576 if (m.msg_controllen) {
1577 sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
1579 ast_log(LOG_WARNING, "Receive error from %s\n", ast_inet_ntoa(sin->sin_addr));
1581 ast_log(LOG_WARNING, "No address detected??\n");
1583 ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
1590 static int transmit_trunk(struct iax_frame *f, struct sockaddr_in *sin, int sockfd)
1593 res = sendto(sockfd, f->data, f->datalen, 0,(struct sockaddr *)sin,
1597 ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1604 static int send_packet(struct iax_frame *f)
1607 int callno = f->callno;
1609 /* Don't send if there was an error, but return error instead */
1610 if (!callno || !iaxs[callno] || iaxs[callno]->error)
1613 /* Called with iaxsl held */
1614 if (option_debug > 2 && iaxdebug)
1615 ast_log(LOG_DEBUG, "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));
1618 iax_showframe(f, NULL, 0, &iaxs[callno]->transfer, f->datalen - sizeof(struct ast_iax2_full_hdr));
1619 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->transfer,
1620 sizeof(iaxs[callno]->transfer));
1623 iax_showframe(f, NULL, 0, &iaxs[callno]->addr, f->datalen - sizeof(struct ast_iax2_full_hdr));
1624 res = sendto(iaxs[callno]->sockfd, f->data, f->datalen, 0,(struct sockaddr *)&iaxs[callno]->addr,
1625 sizeof(iaxs[callno]->addr));
1628 if (option_debug && iaxdebug)
1629 ast_log(LOG_DEBUG, "Received error: %s\n", strerror(errno));
1636 static void iax2_destroy_helper(struct chan_iax2_pvt *pvt)
1638 struct iax2_user *user = NULL;
1640 /* Decrement AUTHREQ count if needed */
1641 if (ast_test_flag(pvt, IAX_MAXAUTHREQ)) {
1642 AST_LIST_LOCK(&users);
1643 AST_LIST_TRAVERSE(&users, user, entry) {
1644 if (!strcmp(user->name, pvt->username)) {
1649 AST_LIST_UNLOCK(&users);
1650 ast_clear_flag(pvt, IAX_MAXAUTHREQ);
1652 /* No more pings or lagrq's */
1653 if (pvt->pingid > -1)
1654 ast_sched_del(sched, pvt->pingid);
1656 if (pvt->lagid > -1)
1657 ast_sched_del(sched, pvt->lagid);
1659 if (pvt->autoid > -1)
1660 ast_sched_del(sched, pvt->autoid);
1662 if (pvt->authid > -1)
1663 ast_sched_del(sched, pvt->authid);
1665 if (pvt->initid > -1)
1666 ast_sched_del(sched, pvt->initid);
1669 ast_sched_del(sched, pvt->jbid);
1673 static int iax2_predestroy(int callno)
1675 struct ast_channel *c = NULL;
1676 struct chan_iax2_pvt *pvt = NULL;
1678 ast_mutex_lock(&iaxsl[callno]);
1680 if (!(pvt = iaxs[callno])) {
1681 ast_mutex_unlock(&iaxsl[callno]);
1685 if (!ast_test_flag(pvt, IAX_ALREADYGONE)) {
1686 iax2_destroy_helper(pvt);
1687 ast_set_flag(pvt, IAX_ALREADYGONE);
1690 if ((c = pvt->owner)) {
1691 c->_softhangup |= AST_SOFTHANGUP_DEV;
1693 ast_queue_hangup(c);
1695 ast_atomic_fetchadd_int(&usecnt, -1);
1696 ast_update_use_count();
1699 ast_mutex_unlock(&iaxsl[callno]);
1704 static void iax2_destroy(int callno)
1706 struct chan_iax2_pvt *pvt = NULL;
1707 struct iax_frame *cur = NULL;
1708 struct ast_channel *owner = NULL;
1711 ast_mutex_lock(&iaxsl[callno]);
1713 gettimeofday(&lastused[callno], NULL);
1715 owner = pvt ? pvt->owner : NULL;
1718 if (ast_mutex_trylock(&owner->lock)) {
1719 ast_log(LOG_NOTICE, "Avoiding IAX destroy deadlock\n");
1720 ast_mutex_unlock(&iaxsl[callno]);
1726 iaxs[callno] = NULL;
1730 iax2_destroy_helper(pvt);
1733 ast_set_flag(pvt, IAX_ALREADYGONE);
1736 /* If there's an owner, prod it to give up */
1737 owner->_softhangup |= AST_SOFTHANGUP_DEV;
1738 ast_queue_hangup(owner);
1741 AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
1742 /* Cancel any pending transmissions */
1743 if (cur->callno == pvt->callno)
1747 pvt->reg->callno = 0;
1751 ast_variables_destroy(pvt->vars);
1755 while (jb_getall(pvt->jb, &frame) == JB_OK)
1756 iax2_frame_free(frame.data);
1757 jb_destroy(pvt->jb);
1758 /* gotta free up the stringfields */
1759 ast_string_field_free_all(pvt);
1764 ast_mutex_unlock(&owner->lock);
1766 ast_mutex_unlock(&iaxsl[callno]);
1767 if (callno & 0x4000)
1771 static int update_packet(struct iax_frame *f)
1773 /* Called with iaxsl lock held, and iaxs[callno] non-NULL */
1774 struct ast_iax2_full_hdr *fh = f->data;
1775 /* Mark this as a retransmission */
1776 fh->dcallno = ntohs(IAX_FLAG_RETRANS | f->dcallno);
1778 f->iseqno = iaxs[f->callno]->iseqno;
1779 fh->iseqno = f->iseqno;
1783 static int attempt_transmit(void *data);
1784 static void __attempt_transmit(void *data)
1786 /* Attempt to transmit the frame to the remote peer...
1787 Called without iaxsl held. */
1788 struct iax_frame *f = data;
1790 int callno = f->callno;
1791 /* Make sure this call is still active */
1793 ast_mutex_lock(&iaxsl[callno]);
1794 if (callno && iaxs[callno]) {
1795 if ((f->retries < 0) /* Already ACK'd */ ||
1796 (f->retries >= max_retries) /* Too many attempts */) {
1797 /* Record an error if we've transmitted too many times */
1798 if (f->retries >= max_retries) {
1800 /* Transfer timeout */
1801 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, NULL, 0, -1);
1802 } else if (f->final) {
1804 iax2_destroy(callno);
1806 if (iaxs[callno]->owner)
1807 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);
1808 iaxs[callno]->error = ETIMEDOUT;
1809 if (iaxs[callno]->owner) {
1810 struct ast_frame fr = { 0, };
1812 fr.frametype = AST_FRAME_CONTROL;
1813 fr.subclass = AST_CONTROL_HANGUP;
1814 iax2_queue_frame(callno, &fr);
1815 /* Remember, owner could disappear */
1816 if (iaxs[callno]->owner)
1817 iaxs[callno]->owner->hangupcause = AST_CAUSE_DESTINATION_OUT_OF_ORDER;
1819 if (iaxs[callno]->reg) {
1820 memset(&iaxs[callno]->reg->us, 0, sizeof(iaxs[callno]->reg->us));
1821 iaxs[callno]->reg->regstate = REG_STATE_TIMEOUT;
1822 iaxs[callno]->reg->refresh = IAX_DEFAULT_REG_EXPIRE;
1824 iax2_destroy(callno);
1831 /* Update it if it needs it */
1833 /* Attempt transmission */
1836 /* Try again later after 10 times as long */
1838 if (f->retrytime > MAX_RETRY_TIME)
1839 f->retrytime = MAX_RETRY_TIME;
1840 /* Transfer messages max out at one second */
1841 if (f->transfer && (f->retrytime > 1000))
1842 f->retrytime = 1000;
1843 f->retrans = ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1846 /* Make sure it gets freed */
1851 ast_mutex_unlock(&iaxsl[callno]);
1852 /* Do not try again */
1854 /* Don't attempt delivery, just remove it from the queue */
1855 AST_LIST_LOCK(&iaxq.queue);
1856 AST_LIST_REMOVE(&iaxq.queue, f, list);
1858 AST_LIST_UNLOCK(&iaxq.queue);
1860 /* Free the IAX frame */
1865 static int attempt_transmit(void *data)
1867 #ifdef SCHED_MULTITHREADED
1868 if (schedule_action(__attempt_transmit, data))
1870 __attempt_transmit(data);
1874 static int iax2_prune_realtime(int fd, int argc, char *argv[])
1876 struct iax2_peer *peer;
1879 return RESULT_SHOWUSAGE;
1880 if (!strcmp(argv[3],"all")) {
1882 ast_cli(fd, "OK cache is flushed.\n");
1883 } else if ((peer = find_peer(argv[3], 0))) {
1884 if(ast_test_flag(peer, IAX_RTCACHEFRIENDS)) {
1885 ast_set_flag(peer, IAX_RTAUTOCLEAR);
1886 expire_registry((void*)peer->name);
1887 ast_cli(fd, "OK peer %s was removed from the cache.\n", argv[3]);
1889 ast_cli(fd, "SORRY peer %s is not eligible for this operation.\n", argv[3]);
1892 ast_cli(fd, "SORRY peer %s was not found in the cache.\n", argv[3]);
1895 return RESULT_SUCCESS;
1898 static int iax2_test_losspct(int fd, int argc, char *argv[])
1901 return RESULT_SHOWUSAGE;
1903 test_losspct = atoi(argv[3]);
1905 return RESULT_SUCCESS;
1909 static int iax2_test_late(int fd, int argc, char *argv[])
1912 return RESULT_SHOWUSAGE;
1914 test_late = atoi(argv[3]);
1916 return RESULT_SUCCESS;
1919 static int iax2_test_resync(int fd, int argc, char *argv[])
1922 return RESULT_SHOWUSAGE;
1924 test_resync = atoi(argv[3]);
1926 return RESULT_SUCCESS;
1929 static int iax2_test_jitter(int fd, int argc, char *argv[])
1931 if (argc < 4 || argc > 5)
1932 return RESULT_SHOWUSAGE;
1934 test_jit = atoi(argv[3]);
1936 test_jitpct = atoi(argv[4]);
1938 return RESULT_SUCCESS;
1940 #endif /* IAXTESTS */
1942 /*! \brief peer_status: Report Peer status in character string */
1943 /* returns 1 if peer is online, -1 if unmonitored */
1944 static int peer_status(struct iax2_peer *peer, char *status, int statuslen)
1948 if (peer->lastms < 0) {
1949 ast_copy_string(status, "UNREACHABLE", statuslen);
1950 } else if (peer->lastms > peer->maxms) {
1951 snprintf(status, statuslen, "LAGGED (%d ms)", peer->lastms);
1953 } else if (peer->lastms) {
1954 snprintf(status, statuslen, "OK (%d ms)", peer->lastms);
1957 ast_copy_string(status, "UNKNOWN", statuslen);
1960 ast_copy_string(status, "Unmonitored", statuslen);
1966 /*! \brief Show one peer in detail */
1967 static int iax2_show_peer(int fd, int argc, char *argv[])
1971 struct iax2_peer *peer;
1972 char codec_buf[512];
1973 int x = 0, codec = 0, load_realtime = 0;
1976 return RESULT_SHOWUSAGE;
1978 load_realtime = (argc == 5 && !strcmp(argv[4], "load")) ? 1 : 0;
1980 peer = find_peer(argv[3], load_realtime);
1983 ast_cli(fd, " * Name : %s\n", peer->name);
1984 ast_cli(fd, " Secret : %s\n", ast_strlen_zero(peer->secret)?"<Not set>":"<Set>");
1985 ast_cli(fd, " Context : %s\n", peer->context);
1986 ast_cli(fd, " Mailbox : %s\n", peer->mailbox);
1987 ast_cli(fd, " Dynamic : %s\n", ast_test_flag(peer, IAX_DYNAMIC) ? "Yes":"No");
1988 ast_cli(fd, " Callerid : %s\n", ast_callerid_merge(cbuf, sizeof(cbuf), peer->cid_name, peer->cid_num, "<unspecified>"));
1989 ast_cli(fd, " Expire : %d\n", peer->expire);
1990 ast_cli(fd, " ACL : %s\n", (peer->ha?"Yes":"No"));
1991 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));
1992 ast_cli(fd, " Defaddr->IP : %s Port %d\n", ast_inet_ntoa(peer->defaddr.sin_addr), ntohs(peer->defaddr.sin_port));
1993 ast_cli(fd, " Username : %s\n", peer->username);
1994 ast_cli(fd, " Codecs : ");
1995 ast_getformatname_multiple(codec_buf, sizeof(codec_buf) -1, peer->capability);
1996 ast_cli(fd, "%s\n", codec_buf);
1998 ast_cli(fd, " Codec Order : (");
1999 for(x = 0; x < 32 ; x++) {
2000 codec = ast_codec_pref_index(&peer->prefs,x);
2003 ast_cli(fd, "%s", ast_getformatname(codec));
2004 if(x < 31 && ast_codec_pref_index(&peer->prefs,x+1))
2009 ast_cli(fd, "none");
2012 ast_cli(fd, " Status : ");
2013 peer_status(peer, status, sizeof(status));
2014 ast_cli(fd, "%s\n",status);
2015 ast_cli(fd, " Qualify : every %dms when OK, every %dms when UNREACHABLE (sample smoothing %s)\n", peer->pokefreqok, peer->pokefreqnotok, peer->smoothing ? "On" : "Off");
2017 if (ast_test_flag(peer, IAX_TEMPONLY))
2020 ast_cli(fd,"Peer %s not found.\n", argv[3]);
2024 return RESULT_SUCCESS;
2027 static char *complete_iax2_show_peer(const char *line, const char *word, int pos, int state)
2030 struct iax2_peer *p = NULL;
2032 int wordlen = strlen(word);
2034 /* 0 - iax2; 1 - show; 2 - peer; 3 - <peername> */
2036 AST_LIST_LOCK(&peers);
2037 AST_LIST_TRAVERSE(&peers, p, entry) {
2038 if (!strncasecmp(p->name, word, wordlen) && ++which > state) {
2039 res = ast_strdup(p->name);
2043 AST_LIST_UNLOCK(&peers);
2049 static int iax2_show_stats(int fd, int argc, char *argv[])
2051 struct iax_frame *cur;
2052 int cnt = 0, dead=0, final=0;
2054 return RESULT_SHOWUSAGE;
2055 AST_LIST_TRAVERSE(&iaxq.queue, cur, list) {
2056 if (cur->retries < 0)
2062 ast_cli(fd, " IAX Statistics\n");
2063 ast_cli(fd, "---------------------\n");
2064 ast_cli(fd, "Outstanding frames: %d (%d ingress, %d egress)\n", iax_get_frames(), iax_get_iframes(), iax_get_oframes());
2065 ast_cli(fd, "Packets in transmit queue: %d dead, %d final, %d total\n\n", dead, final, cnt);
2067 return RESULT_SUCCESS;
2070 static int iax2_show_cache(int fd, int argc, char *argv[])
2072 struct iax2_dpcache *dp = NULL;
2073 char tmp[1024], *pc = NULL;
2077 gettimeofday(&tv, NULL);
2079 AST_LIST_LOCK(&dpcache);
2081 ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8.8s %s\n", "Peer/Context", "Exten", "Exp.", "Wait.", "Flags");
2083 AST_LIST_TRAVERSE(&dpcache, dp, cache_list) {
2084 s = dp->expiry.tv_sec - tv.tv_sec;
2086 if (dp->flags & CACHE_FLAG_EXISTS)
2087 strncat(tmp, "EXISTS|", sizeof(tmp) - strlen(tmp) - 1);
2088 if (dp->flags & CACHE_FLAG_NONEXISTENT)
2089 strncat(tmp, "NONEXISTENT|", sizeof(tmp) - strlen(tmp) - 1);
2090 if (dp->flags & CACHE_FLAG_CANEXIST)
2091 strncat(tmp, "CANEXIST|", sizeof(tmp) - strlen(tmp) - 1);
2092 if (dp->flags & CACHE_FLAG_PENDING)
2093 strncat(tmp, "PENDING|", sizeof(tmp) - strlen(tmp) - 1);
2094 if (dp->flags & CACHE_FLAG_TIMEOUT)
2095 strncat(tmp, "TIMEOUT|", sizeof(tmp) - strlen(tmp) - 1);
2096 if (dp->flags & CACHE_FLAG_TRANSMITTED)
2097 strncat(tmp, "TRANSMITTED|", sizeof(tmp) - strlen(tmp) - 1);
2098 if (dp->flags & CACHE_FLAG_MATCHMORE)
2099 strncat(tmp, "MATCHMORE|", sizeof(tmp) - strlen(tmp) - 1);
2100 if (dp->flags & CACHE_FLAG_UNKNOWN)
2101 strncat(tmp, "UNKNOWN|", sizeof(tmp) - strlen(tmp) - 1);
2102 /* Trim trailing pipe */
2103 if (!ast_strlen_zero(tmp))
2104 tmp[strlen(tmp) - 1] = '\0';
2106 ast_copy_string(tmp, "(none)", sizeof(tmp));
2108 pc = strchr(dp->peercontext, '@');
2110 pc = dp->peercontext;
2113 for (x=0;x<sizeof(dp->waiters) / sizeof(dp->waiters[0]); x++)
2114 if (dp->waiters[x] > -1)
2117 ast_cli(fd, "%-20.20s %-12.12s %-9d %-8d %s\n", pc, dp->exten, s, y, tmp);
2119 ast_cli(fd, "%-20.20s %-12.12s %-9.9s %-8d %s\n", pc, dp->exten, "(expired)", y, tmp);
2122 AST_LIST_LOCK(&dpcache);
2124 return RESULT_SUCCESS;
2127 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset);
2129 static void unwrap_timestamp(struct iax_frame *fr)
2133 if ( (fr->ts & 0xFFFF0000) == (iaxs[fr->callno]->last & 0xFFFF0000) ) {
2134 x = fr->ts - iaxs[fr->callno]->last;
2136 /* Sudden big jump backwards in timestamp:
2137 What likely happened here is that miniframe timestamp has circled but we haven't
2138 gotten the update from the main packet. We'll just pretend that we did, and
2139 update the timestamp appropriately. */
2140 fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) + 0x10000) | (fr->ts & 0xFFFF);
2141 if (option_debug && iaxdebug)
2142 ast_log(LOG_DEBUG, "schedule_delivery: pushed forward timestamp\n");
2145 /* Sudden apparent big jump forwards in timestamp:
2146 What's likely happened is this is an old miniframe belonging to the previous
2147 top-16-bit timestamp that has turned up out of order.
2148 Adjust the timestamp appropriately. */
2149 fr->ts = ( (iaxs[fr->callno]->last & 0xFFFF0000) - 0x10000) | (fr->ts & 0xFFFF);
2150 if (option_debug && iaxdebug)
2151 ast_log(LOG_DEBUG, "schedule_delivery: pushed back timestamp\n");
2156 static int get_from_jb(void *p);
2158 static void update_jbsched(struct chan_iax2_pvt *pvt)
2162 when = ast_tvdiff_ms(ast_tvnow(), pvt->rxcore);
2164 when = jb_next(pvt->jb) - when;
2166 if(pvt->jbid > -1) ast_sched_del(sched, pvt->jbid);
2169 /* XXX should really just empty until when > 0.. */
2173 pvt->jbid = ast_sched_add(sched, when, get_from_jb, CALLNO_TO_PTR(pvt->callno));
2175 /* Signal scheduler thread */
2176 signal_condition(&sched_lock, &sched_cond);
2179 static void __get_from_jb(void *p)
2181 int callno = PTR_TO_CALLNO(p);
2182 struct chan_iax2_pvt *pvt = NULL;
2183 struct iax_frame *fr;
2190 /* Make sure we have a valid private structure before going on */
2191 ast_mutex_lock(&iaxsl[callno]);
2195 ast_mutex_unlock(&iaxsl[callno]);
2201 gettimeofday(&tv,NULL);
2202 /* round up a millisecond since ast_sched_runq does; */
2203 /* prevents us from spinning while waiting for our now */
2204 /* to catch up with runq's now */
2207 now = ast_tvdiff_ms(tv, pvt->rxcore);
2209 if(now >= (next = jb_next(pvt->jb))) {
2210 ret = jb_get(pvt->jb,&frame,now,ast_codec_interp_len(pvt->voiceformat));
2218 struct ast_frame af;
2220 /* create an interpolation frame */
2221 af.frametype = AST_FRAME_VOICE;
2222 af.subclass = pvt->voiceformat;
2224 af.samples = frame.ms * 8;
2226 af.src = "IAX2 JB interpolation";
2228 af.delivery = ast_tvadd(pvt->rxcore, ast_samp2tv(next, 1000));
2229 af.offset=AST_FRIENDLY_OFFSET;
2231 /* queue the frame: For consistency, we would call __do_deliver here, but __do_deliver wants an iax_frame,
2232 * which we'd need to malloc, and then it would free it. That seems like a drag */
2233 if (!ast_test_flag(iaxs[callno], IAX_ALREADYGONE))
2234 iax2_queue_frame(callno, &af);
2238 iax2_frame_free(frame.data);
2245 /* shouldn't happen */
2249 update_jbsched(pvt);
2250 ast_mutex_unlock(&iaxsl[callno]);
2253 static int get_from_jb(void *data)
2255 #ifdef SCHED_MULTITHREADED
2256 if (schedule_action(__get_from_jb, data))
2258 __get_from_jb(data);
2262 static int schedule_delivery(struct iax_frame *fr, int updatehistory, int fromtrunk, unsigned int *tsout)
2268 /* Attempt to recover wrapped timestamps */
2269 unwrap_timestamp(fr);
2272 /* delivery time is sender's sent timestamp converted back into absolute time according to our clock */
2273 if ( !fromtrunk && !ast_tvzero(iaxs[fr->callno]->rxcore))
2274 fr->af.delivery = ast_tvadd(iaxs[fr->callno]->rxcore, ast_samp2tv(fr->ts, 1000));
2277 ast_log(LOG_DEBUG, "schedule_delivery: set delivery to 0 as we don't have an rxcore yet, or frame is from trunk.\n");
2279 fr->af.delivery = ast_tv(0,0);
2282 type = JB_TYPE_CONTROL;
2285 if(fr->af.frametype == AST_FRAME_VOICE) {
2286 type = JB_TYPE_VOICE;
2287 len = ast_codec_get_samples(&fr->af) / 8;
2288 } else if(fr->af.frametype == AST_FRAME_CNG) {
2289 type = JB_TYPE_SILENCE;
2292 if ( (!ast_test_flag(iaxs[fr->callno], IAX_USEJITTERBUF)) ) {
2299 /* if the user hasn't requested we force the use of the jitterbuffer, and we're bridged to
2300 * a channel that can accept jitter, then flush and suspend the jb, and send this frame straight through */
2301 if( (!ast_test_flag(iaxs[fr->callno], IAX_FORCEJITTERBUF)) &&
2302 iaxs[fr->callno]->owner && ast_bridged_channel(iaxs[fr->callno]->owner) &&
2303 (ast_bridged_channel(iaxs[fr->callno]->owner)->tech->properties & AST_CHAN_TP_WANTSJITTER)) {
2306 /* deliver any frames in the jb */
2307 while(jb_getall(iaxs[fr->callno]->jb,&frame) == JB_OK)
2308 __do_deliver(frame.data);
2310 jb_reset(iaxs[fr->callno]->jb);
2312 if (iaxs[fr->callno]->jbid > -1)
2313 ast_sched_del(sched, iaxs[fr->callno]->jbid);
2315 iaxs[fr->callno]->jbid = -1;
2317 /* deliver this frame now */
2324 /* insert into jitterbuffer */
2325 /* TODO: Perhaps we could act immediately if it's not droppable and late */
2326 ret = jb_put(iaxs[fr->callno]->jb, fr, type, len, fr->ts,
2327 calc_rxstamp(iaxs[fr->callno],fr->ts));
2328 if (ret == JB_DROP) {
2330 } else if (ret == JB_SCHED) {
2331 update_jbsched(iaxs[fr->callno]);
2336 /* Free our iax frame */
2337 iax2_frame_free(fr);
2343 static int iax2_transmit(struct iax_frame *fr)
2345 /* Lock the queue and place this packet at the end */
2346 /* By setting this to 0, the network thread will send it for us, and
2347 queue retransmission if necessary */
2349 AST_LIST_LOCK(&iaxq.queue);
2350 AST_LIST_INSERT_TAIL(&iaxq.queue, fr, list);
2352 AST_LIST_UNLOCK(&iaxq.queue);
2353 /* Wake up the network and scheduler thread */
2354 pthread_kill(netthreadid, SIGURG);
2355 signal_condition(&sched_lock, &sched_cond);
2361 static int iax2_digit_begin(struct ast_channel *c, char digit)
2363 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_BEGIN, digit, 0, NULL, 0, -1);
2366 static int iax2_digit_end(struct ast_channel *c, char digit)
2368 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_DTMF_END, digit, 0, NULL, 0, -1);
2371 static int iax2_sendtext(struct ast_channel *c, const char *text)
2374 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_TEXT,
2375 0, 0, (unsigned char *)text, strlen(text) + 1, -1);
2378 static int iax2_sendimage(struct ast_channel *c, struct ast_frame *img)
2380 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_IMAGE, img->subclass, 0, img->data, img->datalen, -1);
2383 static int iax2_sendhtml(struct ast_channel *c, int subclass, const char *data, int datalen)
2385 return send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_HTML, subclass, 0, (unsigned char *)data, datalen, -1);
2388 static int iax2_fixup(struct ast_channel *oldchannel, struct ast_channel *newchan)
2390 unsigned short callno = PTR_TO_CALLNO(newchan->tech_pvt);
2391 ast_mutex_lock(&iaxsl[callno]);
2393 iaxs[callno]->owner = newchan;
2395 ast_log(LOG_WARNING, "Uh, this isn't a good sign...\n");
2396 ast_mutex_unlock(&iaxsl[callno]);
2400 static struct iax2_peer *realtime_peer(const char *peername, struct sockaddr_in *sin)
2402 struct ast_variable *var;
2403 struct ast_variable *tmp;
2404 struct iax2_peer *peer=NULL;
2405 time_t regseconds = 0, nowtime;
2409 var = ast_load_realtime("iaxpeers", "name", peername, NULL);
2412 sprintf(porta, "%d", ntohs(sin->sin_port));
2413 var = ast_load_realtime("iaxpeers", "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", porta, NULL);
2415 /* We'll need the peer name in order to build the structure! */
2416 for (tmp = var; tmp; tmp = tmp->next) {
2417 if (!strcasecmp(tmp->name, "name"))
2418 peername = tmp->value;
2425 peer = build_peer(peername, var, NULL, ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS) ? 0 : 1);
2430 for (tmp = var; tmp; tmp = tmp->next) {
2431 /* Make sure it's not a user only... */
2432 if (!strcasecmp(tmp->name, "type")) {
2433 if (strcasecmp(tmp->value, "friend") &&
2434 strcasecmp(tmp->value, "peer")) {
2435 /* Whoops, we weren't supposed to exist! */
2440 } else if (!strcasecmp(tmp->name, "regseconds")) {
2441 ast_get_time_t(tmp->value, ®seconds, 0, NULL);
2442 } else if (!strcasecmp(tmp->name, "ipaddr")) {
2443 inet_aton(tmp->value, &(peer->addr.sin_addr));
2444 } else if (!strcasecmp(tmp->name, "port")) {
2445 peer->addr.sin_port = htons(atoi(tmp->value));
2446 } else if (!strcasecmp(tmp->name, "host")) {
2447 if (!strcasecmp(tmp->value, "dynamic"))
2454 ast_variables_destroy(var);
2456 if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2457 ast_copy_flags(peer, &globalflags, IAX_RTAUTOCLEAR|IAX_RTCACHEFRIENDS);
2458 if (ast_test_flag(peer, IAX_RTAUTOCLEAR)) {
2459 if (peer->expire > -1)
2460 ast_sched_del(sched, peer->expire);
2461 peer->expire = ast_sched_add(sched, (global_rtautoclear) * 1000, expire_registry, (void*)peer->name);
2463 AST_LIST_LOCK(&peers);
2464 AST_LIST_INSERT_HEAD(&peers, peer, entry);
2465 AST_LIST_UNLOCK(&peers);
2466 if (ast_test_flag(peer, IAX_DYNAMIC))
2467 reg_source_db(peer);
2469 ast_set_flag(peer, IAX_TEMPONLY);
2472 if (!ast_test_flag(&globalflags, IAX_RTIGNOREREGEXPIRE) && dynamic) {
2474 if ((nowtime - regseconds) > IAX_DEFAULT_REG_EXPIRE) {
2475 memset(&peer->addr, 0, sizeof(peer->addr));
2476 realtime_update_peer(peer->name, &peer->addr, 0);
2478 ast_log(LOG_DEBUG, "realtime_peer: Bah, '%s' is expired (%d/%d/%d)!\n",
2479 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2483 ast_log(LOG_DEBUG, "realtime_peer: Registration for '%s' still active (%d/%d/%d)!\n",
2484 peername, (int)(nowtime - regseconds), (int)regseconds, (int)nowtime);
2491 static struct iax2_user *realtime_user(const char *username)
2493 struct ast_variable *var;
2494 struct ast_variable *tmp;
2495 struct iax2_user *user=NULL;
2497 var = ast_load_realtime("iaxusers", "name", username, NULL);
2503 /* Make sure it's not a peer only... */
2504 if (!strcasecmp(tmp->name, "type")) {
2505 if (strcasecmp(tmp->value, "friend") &&
2506 strcasecmp(tmp->value, "user")) {
2513 user = build_user(username, var, NULL, !ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS));
2517 ast_variables_destroy(var);
2519 if (ast_test_flag((&globalflags), IAX_RTCACHEFRIENDS)) {
2520 ast_set_flag(user, IAX_RTCACHEFRIENDS);
2521 AST_LIST_LOCK(&users);
2522 AST_LIST_INSERT_HEAD(&users, user, entry);
2523 AST_LIST_UNLOCK(&users);
2525 ast_set_flag(user, IAX_TEMPONLY);
2531 static void realtime_update_peer(const char *peername, struct sockaddr_in *sin, time_t regtime)
2534 char regseconds[20];
2536 snprintf(regseconds, sizeof(regseconds), "%d", (int)regtime);
2537 snprintf(port, sizeof(port), "%d", ntohs(sin->sin_port));
2538 ast_update_realtime("iaxpeers", "name", peername,
2539 "ipaddr", ast_inet_ntoa(sin->sin_addr), "port", port,
2540 "regseconds", regseconds, NULL);
2543 struct create_addr_info {
2556 char context[AST_MAX_CONTEXT];
2557 char peercontext[AST_MAX_CONTEXT];
2558 char mohinterpret[MAX_MUSICCLASS];
2559 char mohsuggest[MAX_MUSICCLASS];
2562 static int create_addr(const char *peername, struct sockaddr_in *sin, struct create_addr_info *cai)
2564 struct ast_hostent ahp;
2566 struct iax2_peer *peer;
2568 ast_clear_flag(cai, IAX_SENDANI | IAX_TRUNK);
2569 cai->sockfd = defaultsockfd;
2571 sin->sin_family = AF_INET;
2573 if (!(peer = find_peer(peername, 1))) {
2576 hp = ast_gethostbyname(peername, &ahp);
2578 memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
2579 sin->sin_port = htons(IAX_DEFAULT_PORTNO);
2580 /* use global iax prefs for unknown peer/user */
2581 ast_codec_pref_convert(&prefs, cai->prefs, sizeof(cai->prefs), 1);
2584 ast_log(LOG_WARNING, "No such host: %s\n", peername);
2591 /* if the peer has no address (current or default), return failure */
2592 if (!(peer->addr.sin_addr.s_addr || peer->defaddr.sin_addr.s_addr)) {
2593 if (ast_test_flag(peer, IAX_TEMPONLY))
2598 /* if the peer is being monitored and is currently unreachable, return failure */
2599 if (peer->maxms && ((peer->lastms > peer->maxms) || (peer->lastms < 0))) {
2600 if (ast_test_flag(peer, IAX_TEMPONLY))
2605 ast_copy_flags(cai, peer, IAX_SENDANI | IAX_TRUNK | IAX_NOTRANSFER | IAX_TRANSFERMEDIA | IAX_USEJITTERBUF | IAX_FORCEJITTERBUF);
2606 cai->maxtime = peer->maxms;
2607 cai->capability = peer->capability;
2608 cai->encmethods = peer->encmethods;
2609 cai->sockfd = peer->sockfd;
2610 cai->adsi = peer->adsi;
2611 ast_codec_pref_convert(&peer->prefs, cai->prefs, sizeof(cai->prefs), 1);
2612 ast_copy_string(cai->context, peer->context, sizeof(cai->context));
2613 ast_copy_string(cai->peercontext, peer->peercontext, sizeof(cai->peercontext));
2614 ast_copy_string(cai->username, peer->username, sizeof(cai->username));
2615 ast_copy_string(cai->timezone, peer->zonetag, sizeof(cai->timezone));
2616 ast_copy_string(cai->outkey, peer->outkey, sizeof(cai->outkey));
2617 ast_copy_string(cai->mohinterpret, peer->mohinterpret, sizeof(cai->mohinterpret));
2618 ast_copy_string(cai->mohsuggest, peer->mohsuggest, sizeof(cai->mohsuggest));
2619 if (ast_strlen_zero(peer->dbsecret)) {
2620 ast_copy_string(cai->secret, peer->secret, sizeof(cai->secret));
2625 family = ast_strdupa(peer->dbsecret);
2626 key = strchr(family, '/');
2629 if (!key || ast_db_get(family, key, cai->secret, sizeof(cai->secret))) {
2630 ast_log(LOG_WARNING, "Unable to retrieve database password for family/key '%s'!\n", peer->dbsecret);
2631 if (ast_test_flag(peer, IAX_TEMPONLY))
2637 if (peer->addr.sin_addr.s_addr) {
2638 sin->sin_addr = peer->addr.sin_addr;
2639 sin->sin_port = peer->addr.sin_port;
2641 sin->sin_addr = peer->defaddr.sin_addr;
2642 sin->sin_port = peer->defaddr.sin_port;
2645 if (ast_test_flag(peer, IAX_TEMPONLY))
2651 static void __auto_congest(void *nothing)
2653 int callno = PTR_TO_CALLNO(nothing);
2654 struct ast_frame f = { AST_FRAME_CONTROL, AST_CONTROL_CONGESTION };
2655 ast_mutex_lock(&iaxsl[callno]);
2657 iaxs[callno]->initid = -1;
2658 iax2_queue_frame(callno, &f);
2659 ast_log(LOG_NOTICE, "Auto-congesting call due to slow response\n");
2661 ast_mutex_unlock(&iaxsl[callno]);
2664 static int auto_congest(void *data)
2666 #ifdef SCHED_MULTITHREADED
2667 if (schedule_action(__auto_congest, data))
2669 __auto_congest(data);
2673 static unsigned int iax2_datetime(const char *tz)
2679 localtime_r(&t, &tm);
2680 if (!ast_strlen_zero(tz))
2681 ast_localtime(&t, &tm, tz);
2682 tmp = (tm.tm_sec >> 1) & 0x1f; /* 5 bits of seconds */
2683 tmp |= (tm.tm_min & 0x3f) << 5; /* 6 bits of minutes */
2684 tmp |= (tm.tm_hour & 0x1f) << 11; /* 5 bits of hours */
2685 tmp |= (tm.tm_mday & 0x1f) << 16; /* 5 bits of day of month */
2686 tmp |= ((tm.tm_mon + 1) & 0xf) << 21; /* 4 bits of month */
2687 tmp |= ((tm.tm_year - 100) & 0x7f) << 25; /* 7 bits of year */
2691 struct parsed_dial_string {
2703 * \brief Parses an IAX dial string into its component parts.
2704 * \param data the string to be parsed
2705 * \param pds pointer to a \c struct \c parsed_dial_string to be filled in
2708 * This function parses the string and fills the structure
2709 * with pointers to its component parts. The input string
2712 * \note This function supports both plaintext passwords and RSA
2713 * key names; if the password string is formatted as '[keyname]',
2714 * then the keyname will be placed into the key field, and the
2715 * password field will be set to NULL.
2717 * \note The dial string format is:
2718 * [username[:password]@]peer[:port][/exten[@@context]][/options]
2720 static void parse_dial_string(char *data, struct parsed_dial_string *pds)
2722 if (ast_strlen_zero(data))
2725 pds->peer = strsep(&data, "/");
2726 pds->exten = strsep(&data, "/");
2727 pds->options = data;
2731 pds->exten = strsep(&data, "@");
2732 pds->context = data;
2735 if (strchr(pds->peer, '@')) {
2737 pds->username = strsep(&data, "@");
2741 if (pds->username) {
2742 data = pds->username;
2743 pds->username = strsep(&data, ":");
2744 pds->password = data;
2748 pds->peer = strsep(&data, ":");
2751 /* check for a key name wrapped in [] in the secret position, if found,
2752 move it to the key field instead
2754 if (pds->password && (pds->password[0] == '[')) {
2755 pds->key = ast_strip_quoted(pds->password, "[", "]");
2756 pds->password = NULL;
2760 static int iax2_call(struct ast_channel *c, char *dest, int timeout)
2762 struct sockaddr_in sin;
2763 char *l=NULL, *n=NULL, *tmpstr;
2764 struct iax_ie_data ied;
2765 char *defaultrdest = "s";
2766 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
2767 struct parsed_dial_string pds;
2768 struct create_addr_info cai;
2770 if ((c->_state != AST_STATE_DOWN) && (c->_state != AST_STATE_RESERVED)) {
2771 ast_log(LOG_WARNING, "Channel is already in use (%s)?\n", c->name);
2775 memset(&cai, 0, sizeof(cai));
2776 cai.encmethods = iax2_encryption;
2778 memset(&pds, 0, sizeof(pds));
2779 tmpstr = ast_strdupa(dest);
2780 parse_dial_string(tmpstr, &pds);
2783 pds.exten = defaultrdest;
2785 if (create_addr(pds.peer, &sin, &cai)) {
2786 ast_log(LOG_WARNING, "No address associated with '%s'\n", pds.peer);
2790 if (!pds.username && !ast_strlen_zero(cai.username))
2791 pds.username = cai.username;
2792 if (!pds.password && !ast_strlen_zero(cai.secret))
2793 pds.password = cai.secret;
2794 if (!pds.key && !ast_strlen_zero(cai.outkey))
2795 pds.key = cai.outkey;
2796 if (!pds.context && !ast_strlen_zero(cai.peercontext))
2797 pds.context = cai.peercontext;
2799 /* Keep track of the context for outgoing calls too */
2800 ast_copy_string(c->context, cai.context, sizeof(c->context));
2803 sin.sin_port = htons(atoi(pds.port));
2806 n = c->cid.cid_name;
2808 /* Now build request */
2809 memset(&ied, 0, sizeof(ied));
2811 /* On new call, first IE MUST be IAX version of caller */
2812 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
2813 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, pds.exten);
2814 if (pds.options && strchr(pds.options, 'a')) {
2815 /* Request auto answer */
2816 iax_ie_append(&ied, IAX_IE_AUTOANSWER);
2819 iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, cai.prefs);
2822 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, l);
2823 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
2826 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, c->cid.cid_pres);
2828 iax_ie_append_byte(&ied, IAX_IE_CALLINGPRES, AST_PRES_NUMBER_NOT_AVAILABLE);
2831 iax_ie_append_byte(&ied, IAX_IE_CALLINGTON, c->cid.cid_ton);
2832 iax_ie_append_short(&ied, IAX_IE_CALLINGTNS, c->cid.cid_tns);
2835 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, n);
2836 if (ast_test_flag(iaxs[callno], IAX_SENDANI) && c->cid.cid_ani)
2837 iax_ie_append_str(&ied, IAX_IE_CALLING_ANI, c->cid.cid_ani);
2839 if (!ast_strlen_zero(c->language))
2840 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, c->language);
2841 if (!ast_strlen_zero(c->cid.cid_dnid))
2842 iax_ie_append_str(&ied, IAX_IE_DNID, c->cid.cid_dnid);
2843 if (!ast_strlen_zero(c->cid.cid_rdnis))
2844 iax_ie_append_str(&ied, IAX_IE_RDNIS, c->cid.cid_rdnis);
2847 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, pds.context);
2850 iax_ie_append_str(&ied, IAX_IE_USERNAME, pds.username);
2853 iax_ie_append_short(&ied, IAX_IE_ENCRYPTION, cai.encmethods);
2855 ast_mutex_lock(&iaxsl[callno]);
2857 if (!ast_strlen_zero(c->context))
2858 ast_string_field_set(iaxs[callno], context, c->context);
2861 ast_string_field_set(iaxs[callno], username, pds.username);
2863 iaxs[callno]->encmethods = cai.encmethods;
2865 iaxs[callno]->adsi = cai.adsi;
2867 ast_string_field_set(iaxs[callno], mohinterpret, cai.mohinterpret);
2868 ast_string_field_set(iaxs[callno], mohsuggest, cai.mohsuggest);
2871 ast_string_field_set(iaxs[callno], outkey, pds.key);
2873 ast_string_field_set(iaxs[callno], secret, pds.password);
2875 iax_ie_append_int(&ied, IAX_IE_FORMAT, c->nativeformats);
2876 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, iaxs[callno]->capability);
2877 iax_ie_append_short(&ied, IAX_IE_ADSICPE, c->adsicpe);
2878 iax_ie_append_int(&ied, IAX_IE_DATETIME, iax2_datetime(cai.timezone));
2880 if (iaxs[callno]->maxtime) {
2881 /* Initialize pingtime and auto-congest time */
2882 iaxs[callno]->pingtime = iaxs[callno]->maxtime / 2;
2883 iaxs[callno]->initid = ast_sched_add(sched, iaxs[callno]->maxtime * 2, auto_congest, CALLNO_TO_PTR(callno));
2884 } else if (autokill) {
2885 iaxs[callno]->pingtime = autokill / 2;
2886 iaxs[callno]->initid = ast_sched_add(sched, autokill * 2, auto_congest, CALLNO_TO_PTR(callno));
2889 /* Transmit the string in a "NEW" request */
2890 send_command(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
2892 ast_mutex_unlock(&iaxsl[callno]);
2893 ast_setstate(c, AST_STATE_RINGING);
2898 static int iax2_hangup(struct ast_channel *c)
2900 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
2902 struct iax_ie_data ied;
2903 memset(&ied, 0, sizeof(ied));
2904 ast_mutex_lock(&iaxsl[callno]);
2905 if (callno && iaxs[callno]) {
2906 ast_log(LOG_DEBUG, "We're hanging up %s now...\n", c->name);
2907 alreadygone = ast_test_flag(iaxs[callno], IAX_ALREADYGONE);
2908 /* Send the hangup unless we have had a transmission error or are already gone */
2909 iax_ie_append_byte(&ied, IAX_IE_CAUSECODE, (unsigned char)c->hangupcause);
2910 if (!iaxs[callno]->error && !alreadygone)
2911 send_command_final(iaxs[callno], AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
2912 /* Explicitly predestroy it */
2913 iax2_predestroy(callno);
2914 /* If we were already gone to begin with, destroy us now */
2916 ast_log(LOG_DEBUG, "Really destroying %s now...\n", c->name);
2917 iax2_destroy(callno);
2920 ast_mutex_unlock(&iaxsl[callno]);
2921 if (option_verbose > 2)
2922 ast_verbose(VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
2926 static int iax2_setoption(struct ast_channel *c, int option, void *data, int datalen)
2928 struct ast_option_header *h;
2932 case AST_OPTION_TXGAIN:
2933 case AST_OPTION_RXGAIN:
2934 /* these two cannot be sent, because they require a result */
2938 if (!(h = ast_malloc(datalen + sizeof(*h))))
2941 h->flag = AST_OPTION_FLAG_REQUEST;
2942 h->option = htons(option);
2943 memcpy(h->data, data, datalen);
2944 res = send_command_locked(PTR_TO_CALLNO(c->tech_pvt), AST_FRAME_CONTROL,
2945 AST_CONTROL_OPTION, 0, (unsigned char *) h,
2946 datalen + sizeof(*h), -1);
2952 static struct ast_frame *iax2_read(struct ast_channel *c)
2954 ast_log(LOG_NOTICE, "I should never be called!\n");
2955 return &ast_null_frame;
2958 static int iax2_start_transfer(unsigned short callno0, unsigned short callno1, int mediaonly)
2961 struct iax_ie_data ied0;
2962 struct iax_ie_data ied1;
2963 unsigned int transferid = (unsigned int)ast_random();
2964 memset(&ied0, 0, sizeof(ied0));
2965 iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &iaxs[callno1]->addr);
2966 iax_ie_append_short(&ied0, IAX_IE_CALLNO, iaxs[callno1]->peercallno);
2967 iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transferid);
2969 memset(&ied1, 0, sizeof(ied1));
2970 iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &iaxs[callno0]->addr);
2971 iax_ie_append_short(&ied1, IAX_IE_CALLNO, iaxs[callno0]->peercallno);
2972 iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transferid);
2974 res = send_command(iaxs[callno0], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
2977 res = send_command(iaxs[callno1], AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
2980 iaxs[callno0]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
2981 iaxs[callno1]->transferring = mediaonly ? TRANSFER_MBEGIN : TRANSFER_BEGIN;
2985 static void lock_both(unsigned short callno0, unsigned short callno1)
2987 ast_mutex_lock(&iaxsl[callno0]);
2988 while (ast_mutex_trylock(&iaxsl[callno1])) {
2989 ast_mutex_unlock(&iaxsl[callno0]);
2991 ast_mutex_lock(&iaxsl[callno0]);
2995 static void unlock_both(unsigned short callno0, unsigned short callno1)
2997 ast_mutex_unlock(&iaxsl[callno1]);
2998 ast_mutex_unlock(&iaxsl[callno0]);
3001 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)
3003 struct ast_channel *cs[3];
3004 struct ast_channel *who, *other;
3007 int transferstarted=0;
3008 struct ast_frame *f;
3009 unsigned short callno0 = PTR_TO_CALLNO(c0->tech_pvt);
3010 unsigned short callno1 = PTR_TO_CALLNO(c1->tech_pvt);
3011 struct timeval waittimer = {0, 0}, tv;
3013 lock_both(callno0, callno1);
3014 /* Put them in native bridge mode */
3015 if (!flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) {
3016 iaxs[callno0]->bridgecallno = callno1;
3017 iaxs[callno1]->bridgecallno = callno0;
3019 unlock_both(callno0, callno1);
3021 /* If not, try to bridge until we can execute a transfer, if we can */
3024 for (/* ever */;;) {
3025 /* Check in case we got masqueraded into */
3026 if ((c0->tech != &iax2_tech) || (c1->tech != &iax2_tech)) {
3027 if (option_verbose > 2)
3028 ast_verbose(VERBOSE_PREFIX_3 "Can't masquerade, we're different...\n");
3029 /* Remove from native mode */
3030 if (c0->tech == &iax2_tech) {
3031 ast_mutex_lock(&iaxsl[callno0]);
3032 iaxs[callno0]->bridgecallno = 0;
3033 ast_mutex_unlock(&iaxsl[callno0]);
3035 if (c1->tech == &iax2_tech) {
3036 ast_mutex_lock(&iaxsl[callno1]);
3037 iaxs[callno1]->bridgecallno = 0;
3038 ast_mutex_unlock(&iaxsl[callno1]);
3040 return AST_BRIDGE_FAILED_NOWARN;
3042 if (c0->nativeformats != c1->nativeformats) {
3043 if (option_verbose > 2) {
3046 ast_getformatname_multiple(buf0, sizeof(buf0) -1, c0->nativeformats);
3047 ast_getformatname_multiple(buf1, sizeof(buf1) -1, c1->nativeformats);
3048 ast_verbose(VERBOSE_PREFIX_3 "Operating with different codecs %d[%s] %d[%s] , can't native bridge...\n", c0->nativeformats, buf0, c1->nativeformats, buf1);
3050 /* Remove from native mode */
3051 lock_both(callno0, callno1);
3052 iaxs[callno0]->bridgecallno = 0;
3053 iaxs[callno1]->bridgecallno = 0;
3054 unlock_both(callno0, callno1);
3055 return AST_BRIDGE_FAILED_NOWARN;
3057 /* check if transfered and if we really want native bridging */
3058 if (!transferstarted && !ast_test_flag(iaxs[callno0], IAX_NOTRANSFER) && !ast_test_flag(iaxs[callno1], IAX_NOTRANSFER)) {
3059 /* Try the transfer */
3060 if (iax2_start_transfer(callno0, callno1, (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1)) ||
3061 ast_test_flag(iaxs[callno0], IAX_TRANSFERMEDIA) | ast_test_flag(iaxs[callno1], IAX_TRANSFERMEDIA)))
3062 ast_log(LOG_WARNING, "Unable to start the transfer\n");
3063 transferstarted = 1;
3065 if ((iaxs[callno0]->transferring == TRANSFER_RELEASED) && (iaxs[callno1]->transferring == TRANSFER_RELEASED)) {
3066 /* Call has been transferred. We're no longer involved */
3067 gettimeofday(&tv, NULL);
3068 if (ast_tvzero(waittimer)) {
3070 } else if (tv.tv_sec - waittimer.tv_sec > IAX_LINGER_TIMEOUT) {
3071 c0->_softhangup |= AST_SOFTHANGUP_DEV;
3072 c1->_softhangup |= AST_SOFTHANGUP_DEV;
3075 res = AST_BRIDGE_COMPLETE;
3080 who = ast_waitfor_n(cs, 2, &to);
3081 if (timeoutms > -1) {
3082 timeoutms -= (1000 - to);
3088 res = AST_BRIDGE_RETRY;
3091 if (ast_check_hangup(c0) || ast_check_hangup(c1)) {
3092 res = AST_BRIDGE_FAILED;
3101 res = AST_BRIDGE_COMPLETE;
3104 if ((f->frametype == AST_FRAME_CONTROL) && !(flags & AST_BRIDGE_IGNORE_SIGS)) {
3107 res = AST_BRIDGE_COMPLETE;
3110 other = (who == c0) ? c1 : c0; /* the 'other' channel */
3111 if ((f->frametype == AST_FRAME_VOICE) ||
3112 (f->frametype == AST_FRAME_TEXT) ||
3113 (f->frametype == AST_FRAME_VIDEO) ||
3114 (f->frametype == AST_FRAME_IMAGE) ||
3115 (f->frametype == AST_FRAME_DTMF)) {
3116 /* monitored dtmf take out of the bridge.
3117 * check if we monitor the specific source.
3119 int monitored_source = (who == c0) ? AST_BRIDGE_DTMF_CHANNEL_0 : AST_BRIDGE_DTMF_CHANNEL_1;
3120 if (f->frametype == AST_FRAME_DTMF && (flags & monitored_source)) {
3123 res = AST_BRIDGE_COMPLETE;
3124 /* Remove from native mode */
3127 /* everything else goes to the other side */
3128 ast_write(other, f);
3131 /* Swap who gets priority */
3136 lock_both(callno0, callno1);
3138 iaxs[callno0]->bridgecallno = 0;
3140 iaxs[callno1]->bridgecallno = 0;
3141 unlock_both(callno0, callno1);
3145 static int iax2_answer(struct ast_channel *c)
3147 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3149 ast_log(LOG_DEBUG, "Answering IAX2 call\n");
3150 return send_command_locked(callno, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
3153 static int iax2_indicate(struct ast_channel *c, int condition, const void *data, size_t datalen)
3155 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3157 if (option_debug && iaxdebug)
3158 ast_log(LOG_DEBUG, "Indicating condition %d\n", condition);
3160 if (!strcasecmp(iaxs[callno]->mohinterpret, "passthrough"))
3161 return send_command_locked(callno, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
3163 switch (condition) {
3164 case AST_CONTROL_HOLD:
3165 ast_moh_start(c, data, iaxs[callno]->mohinterpret);
3167 case AST_CONTROL_UNHOLD:
3171 return send_command_locked(callno, AST_FRAME_CONTROL, condition, 0, data, datalen, -1);
3175 static int iax2_transfer(struct ast_channel *c, const char *dest)
3177 unsigned short callno = PTR_TO_CALLNO(c->tech_pvt);
3178 struct iax_ie_data ied;
3179 char tmp[256], *context;
3180 ast_copy_string(tmp, dest, sizeof(tmp));
3181 context = strchr(tmp, '@');
3186 memset(&ied, 0, sizeof(ied));
3187 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, tmp);
3189 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
3191 ast_log(LOG_DEBUG, "Transferring '%s' to '%s'\n", c->name, dest);
3192 return send_command_locked(callno, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
3195 static int iax2_getpeertrunk(struct sockaddr_in sin)
3197 struct iax2_peer *peer = NULL;
3200 AST_LIST_LOCK(&peers);
3201 AST_LIST_TRAVERSE(&peers, peer, entry) {
3202 if ((peer->addr.sin_addr.s_addr == sin.sin_addr.s_addr) &&
3203 (peer->addr.sin_port == sin.sin_port)) {
3204 res = ast_test_flag(peer, IAX_TRUNK);
3208 AST_LIST_UNLOCK(&peers);
3213 /*! \brief Create new call, interface with the PBX core */
3214 static struct ast_channel *ast_iax2_new(int callno, int state, int capability)
3216 struct ast_channel *tmp;
3217 struct chan_iax2_pvt *i;
3218 struct ast_variable *v = NULL;
3220 if (!(i = iaxs[callno])) {
3221 ast_log(LOG_WARNING, "No IAX2 pvt found for callno '%d' !\n", callno);
3225 /* Don't hold call lock */
3226 ast_mutex_unlock(&iaxsl[callno]);
3227 tmp = ast_channel_alloc(1);
3228 ast_mutex_lock(&iaxsl[callno]);
3231 tmp->tech = &iax2_tech;
3232 ast_string_field_build(tmp, name, "IAX2/%s-%d", i->host, i->callno);
3233 /* We can support any format by default, until we get restricted */
3234 tmp->nativeformats = capability;
3235 tmp->readformat = ast_best_codec(capability);
3236 tmp->writeformat = ast_best_codec(capability);
3237 tmp->tech_pvt = CALLNO_TO_PTR(i->callno);
3239 /* Don't use ast_set_callerid() here because it will
3240 * generate a NewCallerID event before the NewChannel event */
3241 tmp->cid.cid_num = ast_strdup(i->cid_num);
3242 tmp->cid.cid_name = ast_strdup(i->cid_name);
3243 if (!ast_strlen_zero(i->ani))
3244 tmp->cid.cid_ani = ast_strdup(i->ani);
3246 tmp->cid.cid_ani = ast_strdup(i->cid_num);
3247 tmp->cid.cid_dnid = ast_strdup(i->dnid);
3248 tmp->cid.cid_rdnis = ast_strdup(i->rdnis);
3249 tmp->cid.cid_pres = i->calling_pres;
3250 tmp->cid.cid_ton = i->calling_ton;
3251 tmp->cid.cid_tns = i->calling_tns;
3252 if (!ast_strlen_zero(i->language))
3253 ast_string_field_set(tmp, language, i->language);
3254 if (!ast_strlen_zero(i->accountcode))
3255 ast_string_field_set(tmp, accountcode, i->accountcode);
3257 tmp->amaflags = i->amaflags;
3258 ast_copy_string(tmp->context, i->context, sizeof(tmp->context));
3259 ast_copy_string(tmp->exten, i->exten, sizeof(tmp->exten));
3261 tmp->adsicpe = i->peeradsicpe;
3263 tmp->adsicpe = AST_ADSI_UNAVAILABLE;
3265 i->capability = capability;
3266 ast_setstate(tmp, state);
3267 if (state != AST_STATE_DOWN) {
3268 if (ast_pbx_start(tmp)) {
3269 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
3276 for (v = i->vars ; v ; v = v->next)
3277 pbx_builtin_setvar_helper(tmp, v->name, v->value);
3279 ast_atomic_fetchadd_int(&usecnt, 1);
3280 ast_update_use_count();
3285 static unsigned int calc_txpeerstamp(struct iax2_trunk_peer *tpeer, int sampms, struct timeval *tv)
3287 unsigned long int mssincetx; /* unsigned to handle overflows */
3290 tpeer->trunkact = *tv;
3291 mssincetx = ast_tvdiff_ms(*tv, tpeer->lasttxtime);
3292 if (mssincetx > 5000 || ast_tvzero(tpeer->txtrunktime)) {
3293 /* If it's been at least 5 seconds since the last time we transmitted on this trunk, reset our timers */
3294 tpeer->txtrunktime = *tv;
3295 tpeer->lastsent = 999999;
3297 /* Update last transmit time now */
3298 tpeer->lasttxtime = *tv;
3300 /* Calculate ms offset */
3301 ms = ast_tvdiff_ms(*tv, tpeer->txtrunktime);
3302 /* Predict from last value */
3303 pred = tpeer->lastsent + sampms;
3304 if (abs(ms - pred) < MAX_TIMESTAMP_SKEW)
3307 /* We never send the same timestamp twice, so fudge a little if we must */
3308 if (ms == tpeer->lastsent)
3309 ms = tpeer->lastsent + 1;
3310 tpeer->lastsent = ms;
3314 static unsigned int fix_peerts(struct timeval *tv, int callno, unsigned int ts)
3316 long ms; /* NOT unsigned */
3317 if (ast_tvzero(iaxs[callno]->rxcore)) {
3318 /* Initialize rxcore time if appropriate */
3319 gettimeofday(&iaxs[callno]->rxcore, NULL);
3320 /* Round to nearest 20ms so traces look pretty */
3321 iaxs[callno]->rxcore.tv_usec -= iaxs[callno]->rxcore.tv_usec % 20000;
3323 /* Calculate difference between trunk and channel */
3324 ms = ast_tvdiff_ms(*tv, iaxs[callno]->rxcore);
3325 /* Return as the sum of trunk time and the difference between trunk and real time */
3329 static unsigned int calc_timestamp(struct chan_iax2_pvt *p, unsigned int ts, struct ast_frame *f)
3335 struct timeval *delivery = NULL;
3338 /* What sort of frame do we have?: voice is self-explanatory
3339 "genuine" means an IAX frame - things like LAGRQ/RP, PING/PONG, ACK
3340 non-genuine frames are CONTROL frames [ringing etc], DTMF
3341 The "genuine" distinction is needed because genuine frames must get a clock-based timestamp,
3342 the others need a timestamp slaved to the voice frames so that they go in sequence
3345 if (f->frametype == AST_FRAME_VOICE) {
3347 delivery = &f->delivery;
3348 } else if (f->frametype == AST_FRAME_IAX) {
3350 } else if (f->frametype == AST_FRAME_CNG) {
3354 if (ast_tvzero(p->offset)) {
3355 gettimeofday(&p->offset, NULL);
3356 /* Round to nearest 20ms for nice looking traces */
3357 p->offset.tv_usec -= p->offset.tv_usec % 20000;
3359 /* If the timestamp is specified, just send it as is */
3362 /* If we have a time that the frame arrived, always use it to make our timestamp */
3363 if (delivery && !ast_tvzero(*delivery)) {
3364 ms = ast_tvdiff_ms(*delivery, p->offset);
3365 if (option_debug > 2 && iaxdebug)
3366 ast_log(LOG_DEBUG, "calc_timestamp: call %d/%d: Timestamp slaved to delivery time\n", p->callno, iaxs[p->callno]->peercallno);
3368 ms = ast_tvdiff_ms(ast_tvnow(), p->offset);
3372 /* On a voice frame, use predicted values if appropriate */
3373 if (p->notsilenttx && abs(ms - p->nextpred) <= MAX_TIMESTAMP_SKEW) {
3374 /* Adjust our txcore, keeping voice and non-voice synchronized */
3376 When we send voice, we usually send "calculated" timestamps worked out
3377 on the basis of the number of samples sent. When we send other frames,
3378 we usually send timestamps worked out from the real clock.
3379 The problem is that they can tend to drift out of step because the
3380 source channel's clock and our clock may not be exactly at the same rate.
3381 We fix this by continuously "tweaking" p->offset. p->offset is "time zero"
3382 for this call. Moving it adjusts timestamps for non-voice frames.
3383 We make the adjustment in the style of a moving average. Each time we
3384 adjust p->offset by 10% of the difference between our clock-derived
3385 timestamp and the predicted timestamp. That's why you see "10000"
3386 below even though IAX2 timestamps are in milliseconds.
3387 The use of a moving average avoids offset moving too radically.
3388 Generally, "adjust" roams back and forth around 0, with offset hardly
3389 changing at all. But if a consistent different starts to develop it
3390 will be eliminated over the course of 10 frames (200-300msecs)
3392 adjust = (ms - p->nextpred);
3394 p->offset = ast_tvsub(p->offset, ast_samp2tv(abs(adjust), 10000));
3395 else if (adjust > 0)
3396 p->offset = ast_tvadd(p->offset, ast_samp2tv(adjust, 10000));
3399 p->nextpred = ms; /*f->samples / 8;*/
3400 if (p->nextpred <= p->lastsent)
3401 p->nextpred = p->lastsent + 3;
3405 /* in this case, just use the actual
3406 * time, since we're either way off
3407 * (shouldn't happen), or we're ending a
3408 * silent period -- and seed the next
3409 * predicted time. Also, round ms to the
3410 * next multiple of frame size (so our
3411 * silent periods are multiples of
3412 * frame size too) */
3414 if (iaxdebug && abs(ms - p->nextpred) > MAX_TIMESTAMP_SKEW )
3415 ast_log(LOG_DEBUG, "predicted timestamp skew (%u) > max (%u), using real ts instead.\n",
3416 abs(ms - p->nextpred), MAX_TIMESTAMP_SKEW);
3418 if (f->samples >= 8) /* check to make sure we dont core dump */
3420 int diff = ms % (f->samples / 8);
3422 ms += f->samples/8 - diff;
3429 /* On a dataframe, use last value + 3 (to accomodate jitter buffer shrinking) if appropriate unless
3430 it's a genuine frame */
3432 /* genuine (IAX LAGRQ etc) must keep their clock-based stamps */
3433 if (ms <= p->lastsent)
3434 ms = p->lastsent + 3;
3435 } else if (abs(ms - p->lastsent) <= MAX_TIMESTAMP_SKEW) {
3436 /* non-genuine frames (!?) (DTMF, CONTROL) should be pulled into the predicted stream stamps */
3437 ms = p->lastsent + 3;
3443 p->nextpred = p->nextpred + f->samples / 8;
3447 static unsigned int calc_rxstamp(struct chan_iax2_pvt *p, unsigned int offset)
3449 /* Returns where in "receive time" we are. That is, how many ms
3450 since we received (or would have received) the frame with timestamp 0 */
3454 #endif /* IAXTESTS */
3455 /* Setup rxcore if necessary */
3456 if (ast_tvzero(p->rxcore)) {
3457 p->rxcore = ast_tvnow();
3458 if (option_debug && iaxdebug)
3459 ast_log(LOG_DEBUG, "calc_rxstamp: call=%d: rxcore set to %d.%6.6d - %dms\n",
3460 p->callno, (int)(p->rxcore.tv_sec), (int)(p->rxcore.tv_usec), offset);
3461 p->rxcore = ast_tvsub(p->rxcore, ast_samp2tv(offset, 1000));
3463 if (option_debug && iaxdebug)
3464 ast_log(LOG_DEBUG, "calc_rxstamp: call=%d: works out as %d.%6.6d\n",
3465 p->callno, (int)(p->rxcore.tv_sec),(int)( p->rxcore.tv_usec));
3469 ms = ast_tvdiff_ms(ast_tvnow(), p->rxcore);
3472 if (!test_jitpct || ((100.0 * ast_random() / (RAND_MAX + 1.0)) < test_jitpct)) {
3473 jit = (int)((float)test_jit * ast_random() / (RAND_MAX + 1.0));
3474 if ((int)(2.0 * ast_random() / (RAND_MAX + 1.0)))
3483 #endif /* IAXTESTS */
3487 static struct iax2_trunk_peer *find_tpeer(struct sockaddr_in *sin, int fd)
3489 struct iax2_trunk_peer *tpeer = NULL;
3491 /* Finds and locks trunk peer */
3492 AST_LIST_LOCK(&tpeers);
3494 AST_LIST_TRAVERSE(&tpeers, tpeer, list) {
3495 if (!inaddrcmp(&tpeer->addr, sin)) {
3496 ast_mutex_lock(&tpeer->lock);
3502 if ((tpeer = ast_calloc(1, sizeof(*tpeer)))) {
3503 ast_mutex_init(&tpeer->lock);
3504 tpeer->lastsent = 9999;
3505 memcpy(&tpeer->addr, sin, sizeof(tpeer->addr));
3506 tpeer->trunkact = ast_tvnow();
3507 ast_mutex_lock(&tpeer->lock);
3510 setsockopt(tpeer->sockfd, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
3512 ast_log(LOG_DEBUG, "Created trunk peer for '%s:%d'\n", ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port));
3513 AST_LIST_INSERT_TAIL(&tpeers, tpeer, list);
3517 AST_LIST_UNLOCK(&tpeers);
3522 static int iax2_trunk_queue(struct chan_iax2_pvt *pvt, struct iax_frame *fr)
3524 struct ast_frame *f;
3525 struct iax2_trunk_peer *tpeer;
3527 struct ast_iax2_meta_trunk_entry *met;
3528 struct ast_iax2_meta_trunk_mini *mtm;
3531 tpeer = find_tpeer(&pvt->addr, pvt->sockfd);
3533 if (tpeer->trunkdatalen + f->datalen + 4 >= tpeer->trunkdataalloc) {
3534 /* Need to reallocate space */
3535 if (tpeer->trunkdataalloc < MAX_TRUNKDATA) {
3536 if (!(tmp = ast_realloc(tpeer->trunkdata, tpeer->trunkdataalloc + DEFAULT_TRUNKDATA + IAX2_TRUNK_PREFACE))) {
3537 ast_mutex_unlock(&tpeer->lock);
3541 tpeer->trunkdataalloc += DEFAULT_TRUNKDATA;
3542 tpeer->trunkdata = tmp;
3543 ast_log(LOG_DEBUG, "Expanded trunk '%s:%d' to %d bytes\n", ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port), tpeer->trunkdataalloc);
3545 ast_log(LOG_WARNING, "Maximum trunk data space exceeded to %s:%d\n", ast_inet_ntoa(tpeer->addr.sin_addr), ntohs(tpeer->addr.sin_port));
3546 ast_mutex_unlock(&tpeer->lock);
3551 /* Append to meta frame */
3552 ptr = tpeer->trunkdata + IAX2_TRUNK_PREFACE + tpeer->trunkdatalen;
3553 if (ast_test_flag(&globalflags, IAX_TRUNKTIMESTAMPS)) {
3554 mtm = (struct ast_iax2_meta_trunk_mini *)ptr;
3555 mtm->len = htons(f->datalen);
3556 mtm->mini.callno = htons(pvt->callno);
3557 mtm->mini.ts = htons(0xffff & fr->ts);
3558 ptr += sizeof(struct ast_iax2_meta_trunk_mini);
3559 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_mini);
3561 met = (struct ast_iax2_meta_trunk_entry *)ptr;
3562 /* Store call number and length in meta header */
3563 met->callno = htons(pvt->callno);
3564 met->len = htons(f->datalen);
3565 /* Advance pointers/decrease length past trunk entry header */
3566 ptr += sizeof(struct ast_iax2_meta_trunk_entry);
3567 tpeer->trunkdatalen += sizeof(struct ast_iax2_meta_trunk_entry);
3569 /* Copy actual trunk data */
3570 memcpy(ptr, f->data, f->datalen);
3571 tpeer->trunkdatalen += f->datalen;
3574 ast_mutex_unlock(&tpeer->lock);
3579 static void build_enc_keys(const unsigned char *digest, aes_encrypt_ctx *ecx, aes_decrypt_ctx *dcx)
3581 aes_encrypt_key128(digest, ecx);
3582 aes_decrypt_key128(digest, dcx);
3585 static void memcpy_decrypt(unsigned char *dst, const unsigned char *src, int len, aes_decrypt_ctx *dcx)
3588 /* Debug with "fake encryption" */
3591 ast_log(LOG_WARNING, "len should be multiple of 16, not %d!\n", len);
3593 dst[x] = src[x] ^ 0xff;
3595 unsigned char lastblock[16] = { 0 };
3598 aes_decrypt(src, dst, dcx);
3600 dst[x] ^= lastblock[x];
3601 memcpy(lastblock, src, sizeof(lastblock));
3609 static void memcpy_encrypt(unsigned char *dst, const unsigned char *src, int len, aes_encrypt_ctx *ecx)
3612 /* Debug with "fake encryption" */