2 * Asterisk -- A telephony toolkit for Linux.
4 * Implementation of Inter-Asterisk eXchange
6 * Copyright (C) 1999, Mark Spencer
8 * Mark Spencer <markster@linux-support.net>
10 * This program is free software, distributed under the terms of
11 * the GNU General Public License
14 #include <asterisk/frame.h>
15 #include <asterisk/channel.h>
16 #include <asterisk/channel_pvt.h>
17 #include <asterisk/logger.h>
18 #include <asterisk/module.h>
19 #include <asterisk/pbx.h>
20 #include <asterisk/sched.h>
21 #include <asterisk/io.h>
22 #include <asterisk/config.h>
23 #include <asterisk/options.h>
24 #include <asterisk/cli.h>
25 #include <asterisk/translate.h>
26 #include <asterisk/md5.h>
27 #include <arpa/inet.h>
28 #include <sys/socket.h>
29 #include <netinet/in.h>
31 #include <sys/signal.h>
41 #define DEFAULT_RETRY_TIME 1000
42 #define MEMORY_SIZE 100
43 #define DEFAULT_DROP 3
45 /* If you want to use the simulator, then define IAX_SIMULATOR. */
50 static char *desc = "Inter Asterisk eXchange";
51 static char *tdesc = "Inter Asterisk eXchange Drver";
52 static char *type = "IAX";
53 static char *config = "iax.conf";
55 static char context[80] = "default";
57 static int max_retries = 4;
58 static int ping_time = 20;
59 static int lagrq_time = 10;
60 static int nextcallno = 0;
61 static int maxjitterbuffer=4000;
63 static int netsocket = -1;
66 static pthread_mutex_t usecnt_lock = PTHREAD_MUTEX_INITIALIZER;
67 static pthread_mutex_t iaxs_lock = PTHREAD_MUTEX_INITIALIZER;
70 #define IAX_CAPABILITY_FULLBANDWIDTH 0x7FFFFFFF
72 #define IAX_CAPABILITY_MEDBANDWIDTH (IAX_CAPABILITY_FULLBANDWIDTH & \
73 ~AST_FORMAT_SLINEAR & \
77 #define IAX_CAPABILITY_LOWBANDWIDTH (IAX_CAPABILITY_MEDBANDWIDTH & \
81 #define IAX_CAPABILITY_LOWFREE (IAX_CAPABILITY_LOWBANDWIDTH & \
84 static struct io_context *io;
85 static struct sched_context *sched;
87 static int iax_capability = IAX_CAPABILITY_FULLBANDWIDTH;
89 static int iax_dropcount = DEFAULT_DROP;
91 static int use_jitterbuffer = 1;
93 static pthread_t netthreadid;
95 #define IAX_STATE_STARTED (1 << 0)
96 #define IAX_STATE_AUTHENTICATED (1 << 1)
98 #define IAX_SENSE_DENY 0
99 #define IAX_SENSE_ALLOW 1
102 /* Host access rule */
103 struct in_addr netaddr;
104 struct in_addr netmask;
110 char context[AST_MAX_EXTENSION];
111 struct iax_context *next;
119 struct iax_context *contexts;
120 struct iax_user *next;
127 struct sockaddr_in addr;
130 struct iax_peer *next;
133 /* Don't retry more frequently than every 10 ms, or less frequently than every 5 seconds */
134 #define MIN_RETRY_TIME 10
135 #define MAX_RETRY_TIME 10000
136 #define MAX_JITTER_BUFFER 50
138 /* If we have more than this much excess real jitter buffer, srhink it. */
139 static int max_jitter_buffer = MAX_JITTER_BUFFER;
141 struct chan_iax_pvt {
142 /* Pipes for communication. pipe[1] belongs to the
143 network thread (write), and pipe[0] belongs to the individual
146 /* Last received voice format */
148 /* Last sent voice format */
150 /* Last received timestamp */
152 /* Last sent timestamp - never send the same timestamp twice in a single call */
153 unsigned int lastsent;
155 unsigned int pingtime;
157 struct sockaddr_in addr;
158 /* Our call number */
162 /* Peer supported formats */
164 /* timeval that we base our transmission on */
165 struct timeval offset;
166 /* timeval that we base our delivery on */
167 struct timeval rxcore;
168 /* Historical delivery time */
169 int history[MEMORY_SIZE];
170 /* Current base jitterbuffer */
172 /* Current jitter measure */
176 /* Error, as discovered by the manager */
178 /* Onwer if we have one */
179 struct ast_channel *owner;
180 /* What's our state? */
182 /* Next outgoing sequence number */
183 unsigned short oseqno;
184 /* Next incoming sequence number */
185 unsigned short iseqno;
188 /* Default Context */
190 /* Caller ID if available */
194 /* Requested Extension */
195 char exten[AST_MAX_EXTENSION];
196 /* Expected Username */
198 /* Expected Secret */
200 /* permitted authentication methods */
206 struct ast_iax_frame {
207 /* Actual, isolated frame */
209 /* /Our/ call number */
211 /* Start of raw frame (outgoing only) */
213 /* Length of frame (outgoing only) */
215 /* How many retries so far? */
217 /* Outgoing relative timestamp (ms) */
219 /* How long to wait before retrying */
221 /* Are we received out of order? */
223 /* Have we been sent at all yet? */
225 /* Packet sequence number */
228 struct ast_iax_frame *next;
229 struct ast_iax_frame *prev;
232 static struct ast_iax_queue {
233 struct ast_iax_frame *head;
234 struct ast_iax_frame *tail;
236 pthread_mutex_t lock;
239 static struct ast_user_list {
240 struct iax_user *users;
241 pthread_mutex_t lock;
244 static struct ast_peer_list {
245 struct iax_peer *peers;
246 pthread_mutex_t lock;
249 /* XXX We probably should use a mutex when working with this XXX */
250 static struct chan_iax_pvt *iaxs[AST_IAX_MAX_CALLS];
252 static int send_command(struct chan_iax_pvt *, char, int, unsigned int, char *, int, int);
254 static unsigned int calc_timestamp(struct chan_iax_pvt *p, unsigned int ts);
256 static int send_ping(void *data)
258 int callno = (long)data;
260 send_command(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_PING, 0, NULL, 0, -1);
266 static int send_lagrq(void *data)
268 int callno = (long)data;
270 send_command(iaxs[callno], AST_FRAME_IAX, AST_IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
276 static unsigned char compress_subclass(int subclass)
280 /* If it's 128 or smaller, just return it */
281 if (subclass < AST_FLAG_SC_LOG)
283 /* Otherwise find its power */
284 for (x = 0; x < AST_MAX_SHIFT; x++) {
285 if (subclass & (1 << x)) {
287 ast_log(LOG_WARNING, "Can't compress subclass %d\n", subclass);
293 return power | AST_FLAG_SC_LOG;
296 static int uncompress_subclass(unsigned char csub)
298 /* If the SC_LOG flag is set, return 2^csub otherwise csub */
299 if (csub & AST_FLAG_SC_LOG)
300 return 1 << (csub & ~AST_FLAG_SC_LOG & AST_MAX_SHIFT);
305 static struct chan_iax_pvt *new_iax(void)
307 struct chan_iax_pvt *tmp;
308 tmp = malloc(sizeof(struct chan_iax_pvt));
310 memset(tmp, 0, sizeof(struct chan_iax_pvt));
311 /* On my linux system, pipe's are more than 2x as fast as socketpairs */
312 if (pipe(tmp->pipe)) {
313 ast_log(LOG_WARNING, "Unable to create pipe: %s\n", strerror(errno));
318 tmp->peercallno = -1;
319 /* strncpy(tmp->context, context, sizeof(tmp->context)); */
320 strncpy(tmp->exten, "s", sizeof(tmp->exten));
325 static int get_timelen(struct ast_frame *f)
328 switch(f->subclass) {
329 case AST_FORMAT_G723_1:
335 case AST_FORMAT_SLINEAR:
336 timelen = f->datalen / 8;
338 case AST_FORMAT_LPC10:
340 timelen += ((char *)(f->data))[7] & 0x1;
343 ast_log(LOG_WARNING, "Don't know how to calculate timelen on %d packets\n", f->subclass);
349 static struct ast_iax_frame *iaxfrdup(struct ast_iax_frame *fr)
351 /* Malloc() a copy of a frame */
352 struct ast_iax_frame *new = malloc(sizeof(struct ast_iax_frame));
354 memcpy(new, fr, sizeof(struct ast_iax_frame));
359 static struct ast_iax_frame *iaxfrdup2(struct ast_iax_frame *fr, int ch)
361 /* Malloc() a copy of a frame */
362 struct ast_iax_frame *new = malloc(sizeof(struct ast_iax_frame));
364 memcpy(new, fr, sizeof(struct ast_iax_frame));
365 new->f = ast_frdup(fr->f);
366 /* Copy full header */
368 memcpy(new->f->data - sizeof(struct ast_iax_full_hdr),
369 fr->f->data - sizeof(struct ast_iax_full_hdr),
370 sizeof(struct ast_iax_full_hdr));
371 /* Grab new data pointer */
372 new->data = new->f->data - (fr->f->data - fr->data);
381 #define NEW_PREVENT 0
385 static int find_callno(short callno, short dcallno ,struct sockaddr_in *sin, int new)
390 if (new <= NEW_ALLOW) {
391 /* Look for an existing connection first */
392 for (x=0;x<AST_IAX_MAX_CALLS;x++) {
394 /* Look for an exact match */
395 if ((sin->sin_port == iaxs[x]->addr.sin_port) &&
396 (sin->sin_addr.s_addr == iaxs[x]->addr.sin_addr.s_addr) &&
397 ((callno == iaxs[x]->peercallno) || /* Our expected source call number is the same */
398 ((dcallno == x) && (iaxs[x]->peercallno = -1))
399 /* We have no expected source number, and the destination is right */
407 if ((res < 0) && (new >= NEW_ALLOW)) {
408 /* Create a new one */
410 for (x = nextcallno + 1; iaxs[x] && (x != start); x = (x + 1) % AST_IAX_MAX_CALLS)
412 ast_log(LOG_WARNING, "Unable to accept more calls\n");
418 ast_log(LOG_DEBUG, "Creating new call structure %d\n", x);
419 iaxs[x]->addr.sin_port = sin->sin_port;
420 iaxs[x]->addr.sin_family = sin->sin_family;
421 iaxs[x]->addr.sin_addr.s_addr = sin->sin_addr.s_addr;
422 iaxs[x]->peercallno = callno;
424 iaxs[x]->pingtime = DEFAULT_RETRY_TIME;
425 ast_sched_add(sched, ping_time * 1000, send_ping, (void *)x);
426 ast_sched_add(sched, lagrq_time * 1000, send_lagrq, (void *)x);
428 ast_log(LOG_DEBUG, "Out of memory\n");
435 static int iax_send(struct chan_iax_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno);
437 static int do_deliver(void *data)
439 /* Just deliver the packet by writing it to half of the pipe. */
440 struct ast_iax_frame *fr = data;
442 if (iaxs[fr->callno]) {
443 if (fr->f->frametype == AST_FRAME_IAX) {
444 /* We have to treat some of these packets specially because
445 they're LAG measurement packets */
446 if (fr->f->subclass == AST_IAX_COMMAND_LAGRQ) {
447 /* If we got a queued request, build a reply and send it */
448 fr->f->subclass = AST_IAX_COMMAND_LAGRP;
449 iax_send(iaxs[fr->callno], fr->f, fr->ts, -1);
450 } else if (fr->f->subclass == AST_IAX_COMMAND_LAGRP) {
451 /* This is a reply we've been given, actually measure the difference */
452 ts = calc_timestamp(iaxs[fr->callno], 0);
453 iaxs[fr->callno]->lag = ts - fr->ts;
456 ast_fr_fdwrite(iaxs[fr->callno]->pipe[1], fr->f);
459 /* Free the packet */
461 /* And our iax frame */
463 /* And don't run again */
467 static int handle_error()
469 /* XXX Ideally we should figure out why an error occured and then abort those
470 rather than continuing to try. Unfortunately, the published interface does
471 not seem to work XXX */
473 struct sockaddr_in *sin;
476 struct sock_extended_err e;
481 m.msg_controllen = sizeof(e);
483 res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
485 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
487 if (m.msg_controllen) {
488 sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
490 ast_log(LOG_WARNING, "Receive error from %s\n", inet_ntoa(sin->sin_addr));
492 ast_log(LOG_WARNING, "No address detected??\n");
494 ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
502 static int __send_packet(struct ast_iax_frame *f)
504 static int send_packet(struct ast_iax_frame *f)
509 ast_log(LOG_DEBUG, "Sending %d on %d/%d to %s:%d\n", f->ts, f->callno, iaxs[f->callno]->peercallno, inet_ntoa(iaxs[f->callno]->addr.sin_addr), ntohs(iaxs[f->callno]->addr.sin_port));
510 /* Don't send if there was an error, but return error instead */
512 ast_log(LOG_WARNING, "Call number = %d\n", f->callno);
515 if (iaxs[f->callno]->error)
517 res = sendto(netsocket, f->data, f->datalen, 0, &iaxs[f->callno]->addr,
518 sizeof(iaxs[f->callno]->addr));
520 ast_log(LOG_WARNING, "Received error: %s\n", strerror(errno));
529 /* Average amount of delay in the connection */
530 static int average_delay = 0;
531 /* Permitted deviation either side of the average delay */
532 static int delay_deviation = 0;
533 /* Percent chance that a packet arrives O.K. */
534 static int reliability = 100;
536 static int iax_sim_calc_delay()
539 ms = average_delay - delay_deviation;
540 ms += ((float)(delay_deviation * 2)) * rand() / (RAND_MAX + 1.0);
543 if ((float)rand()/(RAND_MAX + 1.0) < ((float)reliability)/100)
549 static int d_send_packet(void *v)
551 struct ast_iax_frame *f = (struct ast_iax_frame *)v;
559 static int send_packet(struct ast_iax_frame *f)
561 struct ast_iax_frame *fn;
563 ms = iax_sim_calc_delay();
565 return __send_packet(f);
567 /* Make a completely independent frame, in case the other
568 is destroyed -- still doesn't make things like hangups
569 arrive if the main channel is destroyed, but close enough */
570 fn = iaxfrdup2(f, 1);
571 ast_sched_add(sched, ms, d_send_packet, fn);
572 } /* else we drop the packet */
576 static int iax_sim_set(int fd, int argc, char *argv[])
579 return RESULT_SHOWUSAGE;
580 if (!strcasecmp(argv[2], "delay"))
581 average_delay = atoi(argv[3]);
582 else if (!strcasecmp(argv[2], "deviation"))
583 delay_deviation = atoi(argv[3]);
584 else if (!strcasecmp(argv[2], "reliability"))
585 reliability = atoi(argv[3]);
587 return RESULT_SHOWUSAGE;
588 if (reliability > 100)
592 if (delay_deviation > average_delay)
593 delay_deviation = average_delay;
594 return RESULT_SUCCESS;
597 static char delay_usage[] =
598 "Usage: sim set delay <value>\n"
599 " Configure the IAX network simulator to generate average\n"
600 " delays equal to the specified value (in milliseconds).\n";
602 static char deviation_usage[] =
603 "Usage: sim set deviation <value>\n"
604 " Configures the IAX network simulator's deviation value.\n"
605 " The delays generated by the simulator will always be within\n"
606 " this value of milliseconds (postive or negative) of the \n"
609 static char reliability_usage[] =
610 "Usage: sim set reliability <value>\n"
611 " Configure the probability that a packet will be delivered.\n"
612 " The value specified is a percentage from 0 to 100\n";
614 static int iax_sim_show(int fd, int argc, char *argv[])
617 return RESULT_SHOWUSAGE;
618 ast_cli(fd, "Average Delay: %d ms\n", average_delay);
619 ast_cli(fd, "Delay Deviation: %d ms\n", delay_deviation);
620 ast_cli(fd, "Reliability: %d %\n", reliability);
621 return RESULT_SUCCESS;
624 static char sim_show_usage[] =
626 " Displays average delay, deviation, and reliability\n"
627 " used by the network simulator.\n";
629 static struct ast_cli_entry delay_cli =
630 { { "sim", "set", "delay", NULL }, iax_sim_set, "Sets simulated average delay", delay_usage };
631 static struct ast_cli_entry deviation_cli =
632 { { "sim", "set", "deviation", NULL }, iax_sim_set, "Sets simulated delay deviation", deviation_usage };
633 static struct ast_cli_entry reliability_cli =
634 { { "sim", "set", "reliability", NULL }, iax_sim_set, "Sets simulated reliability", reliability_usage };
635 static struct ast_cli_entry sim_show_cli =
636 { { "sim", "show", NULL }, iax_sim_show, "Displays simulation parameters", sim_show_usage };
640 static int attempt_transmit(void *data)
642 /* Attempt to transmit the frame to the remote peer */
644 struct ast_iax_frame *f = data;
646 /* Make sure this call is still active */
647 if (iaxs[f->callno]) {
648 if ((f->retries == -1) /* Already ACK'd */ ||
649 (f->retries >= max_retries) /* Too many attempts */) {
650 /* Record an error if we've transmitted too many times */
651 if (f->retries >= max_retries) {
652 ast_log(LOG_WARNING, "Max retries exceeded to host %s (type = %d, subclass = %d, ts=%d, seqno=%d)\n", inet_ntoa(iaxs[f->callno]->addr.sin_addr), f->f->frametype, f->f->subclass, f->ts, f->seqno);
653 iaxs[f->callno]->error = ETIMEDOUT;
654 /* Send a bogus frame to wake up the waiting process */
655 write(iaxs[f->callno]->pipe[1], &zero, 1);
657 /* Don't attempt delivery, just remove it from the queue */
658 pthread_mutex_lock(&iaxq.lock);
660 f->prev->next = f->next;
664 f->next->prev = f->prev;
668 pthread_mutex_unlock(&iaxq.lock);
670 /* Attempt transmission */
673 /* Try again later after 10 times as long */
675 if (f->retrytime > MAX_RETRY_TIME)
676 f->retrytime = MAX_RETRY_TIME;
677 ast_sched_add(sched, f->retrytime, attempt_transmit, f);
681 /* Do not try again */
685 static int iax_set_jitter(int fd, int argc, char *argv[])
687 if ((argc != 4) && (argc != 5))
688 return RESULT_SHOWUSAGE;
690 max_jitter_buffer = atoi(argv[3]);
691 if (max_jitter_buffer < 0)
692 max_jitter_buffer = 0;
695 pthread_mutex_lock(&iaxs_lock);
696 if ((atoi(argv[3]) >= 0) && (atoi(argv[3]) < AST_IAX_MAX_CALLS)) {
697 if (iaxs[atoi(argv[3])]) {
698 iaxs[atoi(argv[3])]->jitterbuffer = atoi(argv[4]);
699 if (iaxs[atoi(argv[3])]->jitterbuffer < 0)
700 iaxs[atoi(argv[3])]->jitterbuffer = 0;
702 ast_cli(fd, "No such call '%d'\n", atoi(argv[3]));
704 ast_cli(fd, "%d is not a valid call number\n", atoi(argv[3]));
705 pthread_mutex_unlock(&iaxs_lock);
708 return RESULT_SUCCESS;
711 static char jitter_usage[] =
712 "Usage: iax set jitter [callid] <value>\n"
713 " If used with a callid, it sets the jitter buffer to the given static\n"
714 "value (until its next calculation). If used without a callid, the value is used\n"
715 "to establish the maximum excess jitter buffer that is permitted before the jitter\n"
716 "buffer size is reduced.";
718 static struct ast_cli_entry cli_set_jitter =
719 { { "iax", "set", "jitter", NULL }, iax_set_jitter, "Sets IAX jitter buffer", jitter_usage };
721 static unsigned int calc_rxstamp(struct chan_iax_pvt *p);
723 static int schedule_delivery(struct ast_iax_frame *fr)
725 /* XXX FIXME: I should delay delivery with a sliding jitter buffer XXX */
727 int drops[MEMORY_SIZE];
728 int min, max=0, maxone=0,y,z, match;
729 /* ms is a measure of the "lateness" of the packet relative to the first
730 packet we received, which always has a lateness of 1. */
731 ms = calc_rxstamp(iaxs[fr->callno]) - fr->ts;
733 /* Rotate our history queue of "lateness". Don't worry about those initial
734 zeros because the first entry will always be zero */
735 for (x=0;x<MEMORY_SIZE - 1;x++)
736 iaxs[fr->callno]->history[x] = iaxs[fr->callno]->history[x+1];
737 /* Add a history entry for this one */
738 iaxs[fr->callno]->history[x] = ms;
740 /* Initialize the minimum to reasonable values. It's too much
741 work to do the same for the maximum, repeatedly */
742 min=iaxs[fr->callno]->history[0];
743 for (z=0;z < iax_dropcount + 1;z++) {
744 /* Start very pessimistic ;-) */
746 for (x=0;x<MEMORY_SIZE;x++) {
747 if (max < iaxs[fr->callno]->history[x]) {
748 /* We have a candidate new maximum value. Make
749 sure it's not in our drop list */
751 for (y=0;!match && (y<z);y++)
752 match |= (drops[y] == x);
754 /* It's not in our list, use it as the new maximum */
755 max = iaxs[fr->callno]->history[x];
761 /* On our first pass, find the minimum too */
762 if (min > iaxs[fr->callno]->history[x])
763 min = iaxs[fr->callno]->history[x];
770 /* Just for reference, keep the "jitter" value, the difference between the
771 earliest and the latest. */
772 iaxs[fr->callno]->jitter = max - min;
774 /* If our jitter buffer is too big (by a significant margin), then we slowly
775 shrink it by about 1 ms each time to avoid letting the change be perceived */
776 if (max < iaxs[fr->callno]->jitterbuffer - max_jitter_buffer)
777 iaxs[fr->callno]->jitterbuffer -= 2;
780 /* Constrain our maximum jitter buffer appropriately */
781 if (max > min + maxjitterbuffer) {
783 ast_log(LOG_DEBUG, "Constraining buffer from %d to %d + %d\n", max, min , maxjitterbuffer);
784 max = min + maxjitterbuffer;
788 /* If our jitter buffer is smaller than our maximum delay, grow the jitter
789 buffer immediately to accomodate it (and a little more). */
790 if (max > iaxs[fr->callno]->jitterbuffer)
791 iaxs[fr->callno]->jitterbuffer = max
792 /* + ((float)iaxs[fr->callno]->jitter) * 0.1 */;
796 ast_log(LOG_DEBUG, "min = %d, max = %d, jb = %d, lateness = %d\n", min, max, iaxs[fr->callno]->jitterbuffer, ms);
798 /* Subtract the lateness from our jitter buffer to know how long to wait
799 before sending our packet. */
800 ms = iaxs[fr->callno]->jitterbuffer - ms;
802 if (!use_jitterbuffer)
807 ast_log(LOG_DEBUG, "Calculated ms is %d\n", ms);
808 /* Don't deliver it more than 4 ms late */
809 if ((ms > -4) || (fr->f->frametype != AST_FRAME_VOICE)) {
813 /* Free the packet */
815 /* And our iax frame */
820 ast_log(LOG_DEBUG, "Scheduling delivery in %d ms\n", ms);
821 ast_sched_add(sched, ms, do_deliver, fr);
826 static int iax_transmit(struct ast_iax_frame *fr)
828 /* Lock the queue and place this packet at the end */
831 /* By setting this to 0, the network thread will send it for us, and
832 queue retransmission if necessary */
834 pthread_mutex_lock(&iaxq.lock);
841 iaxq.tail->next = fr;
842 fr->prev = iaxq.tail;
846 pthread_mutex_unlock(&iaxq.lock);
847 /* Wake up the network thread */
848 pthread_kill(netthreadid, SIGURG);
854 static int iax_digit(struct ast_channel *c, char digit)
856 return send_command(c->pvt->pvt, AST_FRAME_DTMF, digit, 0, NULL, 0, -1);
859 static int iax_sendtext(struct ast_channel *c, char *text)
862 return send_command(c->pvt->pvt, AST_FRAME_TEXT,
863 0, 0, text, strlen(text) + 1, -1);
866 static int create_addr(struct sockaddr_in *sin, char *peer)
870 sin->sin_family = AF_INET;
871 pthread_mutex_lock(&peerl.lock);
874 if (!strcasecmp(p->name, peer)) {
875 sin->sin_addr = p->addr.sin_addr;
876 sin->sin_port = p->addr.sin_port;
881 pthread_mutex_unlock(&peerl.lock);
883 hp = gethostbyname(peer);
885 memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
886 sin->sin_port = htons(AST_DEFAULT_IAX_PORTNO);
893 static int iax_call(struct ast_channel *c, char *dest, int timeout)
895 struct sockaddr_in sin;
901 char requeststr[256] = "";
902 char myrdest [5] = "s";
904 if ((c->state != AST_STATE_DOWN) && (c->state != AST_STATE_RESERVED)) {
905 ast_log(LOG_WARNING, "Line is already in use (%s)?\n", c->name);
908 strncpy(host, dest, sizeof(host));
910 /* If no destination extension specified, use 's' */
911 rdest = strtok(NULL, "/");
915 rcontext = strtok(NULL, "@");
917 username = strtok(NULL, "@");
919 /* Really the second argument is the host, not the username */
925 if (strtok(hname, ":")) {
927 portno = strtok(hname, ":");
929 if (create_addr(&sin, hname)) {
930 ast_log(LOG_WARNING, "No address associated with '%s'\n", hname);
934 sin.sin_port = htons(atoi(portno));
936 /* Now we build our request string */
937 #define MYSNPRINTF snprintf(requeststr + strlen(requeststr), sizeof(requeststr) - strlen(requeststr),
938 MYSNPRINTF "exten=%s;", rdest);
940 MYSNPRINTF "callerid=%s;", c->callerid);
942 MYSNPRINTF "dnid=%s;", c->dnid);
944 MYSNPRINTF "context=%s;", rcontext);
946 MYSNPRINTF "username=%s;", username);
947 MYSNPRINTF "formats=%d;", c->format);
948 MYSNPRINTF "version=%d;", AST_IAX_PROTO_VERSION);
949 /* Trim the trailing ";" */
950 if (strlen(requeststr))
951 requeststr[strlen(requeststr) - 1] = '\0';
952 /* Transmit the string in a "NEW" request */
953 if (option_verbose > 2)
954 ast_verbose(VERBOSE_PREFIX_3 "Calling using options '%s'\n", requeststr);
955 send_command((struct chan_iax_pvt *)c->pvt->pvt, AST_FRAME_IAX,
956 AST_IAX_COMMAND_NEW, 0, requeststr, strlen(requeststr) + 1, -1);
957 c->state = AST_STATE_RINGING;
961 static void iax_destroy(int callno)
964 struct chan_iax_pvt *pvt = iaxs[callno];
967 /* If there's an owner, prod it to give up */
968 write(pvt->pipe[1], &zero, 1);
978 static int iax_hangup(struct ast_channel *c) {
979 struct chan_iax_pvt *pvt = c->pvt->pvt;
980 /* Send the hangup unless we have had a transmission error */
982 send_command(pvt, AST_FRAME_IAX, AST_IAX_COMMAND_HANGUP, 0, NULL, 0, -1);
983 /* Wait for the network thread to transmit our command -- of course, if
984 it doesn't, that's okay too -- the other end will find out
985 soon enough, but it's a nicity if it can know now. */
988 pthread_mutex_lock(&iaxs_lock);
991 pthread_mutex_lock(&usecnt_lock);
994 ast_log(LOG_WARNING, "Usecnt < 0???\n");
995 pthread_mutex_unlock(&usecnt_lock);
996 ast_update_use_count();
997 if (option_verbose > 2)
998 ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
999 iax_destroy(pvt->callno);
1000 pthread_mutex_unlock(&iaxs_lock);
1004 static struct ast_frame *iax_read(struct ast_channel *c)
1006 struct chan_iax_pvt *pvt = c->pvt->pvt;
1007 struct ast_frame *f;
1009 ast_log(LOG_DEBUG, "Connection closed, error: %s\n", strerror(pvt->error));
1012 f = ast_fr_fdread(pvt->pipe[0]);
1014 if ((f->frametype == AST_FRAME_CONTROL) &&
1015 (f->subclass == AST_CONTROL_ANSWER))
1016 c->state = AST_STATE_UP;
1021 static int iax_answer(struct ast_channel *c)
1023 struct chan_iax_pvt *pvt = c->pvt->pvt;
1025 ast_log(LOG_DEBUG, "Answering\n");
1026 return send_command(pvt, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
1029 static int iax_write(struct ast_channel *c, struct ast_frame *f);
1031 static struct ast_channel *ast_iax_new(struct chan_iax_pvt *i, int state)
1033 struct ast_channel *tmp;
1034 tmp = ast_channel_alloc();
1036 snprintf(tmp->name, sizeof(tmp->name), "IAX[%s:%d]/%d", inet_ntoa(i->addr.sin_addr), ntohs(i->addr.sin_port), i->callno);
1038 tmp->fd = i->pipe[0];
1039 /* We can support any format by default, until we get restricted */
1040 tmp->format = iax_capability;
1042 tmp->pvt->send_digit = iax_digit;
1043 tmp->pvt->send_text = iax_sendtext;
1044 tmp->pvt->call = iax_call;
1045 tmp->pvt->hangup = iax_hangup;
1046 tmp->pvt->answer = iax_answer;
1047 tmp->pvt->read = iax_read;
1048 tmp->pvt->write = iax_write;
1049 if (strlen(i->callerid))
1050 tmp->callerid = strdup(i->callerid);
1051 if (strlen(i->dnid))
1052 tmp->dnid = strdup(i->dnid);
1053 strncpy(tmp->context, i->context, sizeof(tmp->context));
1054 strncpy(tmp->exten, i->exten, sizeof(tmp->exten));
1057 pthread_mutex_lock(&usecnt_lock);
1059 pthread_mutex_unlock(&usecnt_lock);
1060 ast_update_use_count();
1061 if (state != AST_STATE_DOWN) {
1062 if (ast_pbx_start(tmp)) {
1063 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
1072 static unsigned int calc_timestamp(struct chan_iax_pvt *p, unsigned int ts)
1076 if (!p->offset.tv_sec && !p->offset.tv_usec)
1077 gettimeofday(&p->offset, NULL);
1078 /* If the timestamp is specified, just send it as is */
1081 gettimeofday(&tv, NULL);
1082 ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
1083 /* We never send the same timestamp twice, so fudge a little if we must */
1084 if (ms <= p->lastsent)
1085 ms = p->lastsent + 1;
1090 static unsigned int calc_rxstamp(struct chan_iax_pvt *p)
1092 /* Returns where in "receive time" we are */
1095 if (!p->rxcore.tv_sec && !p->rxcore.tv_usec)
1096 gettimeofday(&p->rxcore, NULL);
1097 gettimeofday(&tv, NULL);
1098 ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
1101 static int iax_send(struct chan_iax_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno)
1103 /* Queue a packet for delivery on a given private structure. Use "ts" for
1104 timestamp, or calculate if ts is 0 */
1105 struct ast_iax_full_hdr *fh;
1106 struct ast_iax_mini_hdr *mh;
1107 struct ast_iax_frame *fr;
1109 unsigned int lastsent;
1110 /* Allocate an ast_iax_frame */
1111 fr = malloc(sizeof(struct ast_iax_frame));
1113 ast_log(LOG_WARNING, "Out of memory\n");
1117 ast_log(LOG_WARNING, "No private structure for packet (%d)?\n", fr->callno);
1121 /* Isolate our frame for transmission */
1122 fr->f = ast_frdup(f);
1124 ast_log(LOG_WARNING, "Out of memory\n");
1128 if (fr->f->offset < sizeof(struct ast_iax_full_hdr)) {
1129 ast_log(LOG_WARNING, "Packet from '%s' not friendly\n", fr->f->src);
1133 lastsent = pvt->lastsent;
1134 fr->ts = calc_timestamp(pvt, ts);
1136 ast_log(LOG_WARNING, "timestamp is 0?\n");
1139 fr->callno = pvt->callno;
1140 if (((fr->ts & 0xFFFF0000L) != (lastsent & 0xFFFF0000L))
1141 /* High two bits of timestamp differ */ ||
1142 (fr->f->frametype != AST_FRAME_VOICE)
1143 /* or not a voice frame */ ||
1144 (fr->f->subclass != pvt->svoiceformat)
1145 /* or new voice format */ ) {
1146 /* We need a full frame */
1150 fr->seqno = pvt->oseqno++;
1151 fh = (struct ast_iax_full_hdr *)(fr->f->data - sizeof(struct ast_iax_full_hdr));
1152 fh->callno = htons(fr->callno | AST_FLAG_FULL);
1153 fh->ts = htonl(fr->ts);
1154 fh->seqno = htons(fr->seqno);
1155 fh->type = fr->f->frametype & 0xFF;
1156 fh->csub = compress_subclass(fr->f->subclass);
1158 fh->subclasshigh = (fr->f->subclass & 0xFF0000) >> 16;
1159 fh->subclasslow = htons(fr->f->subclass & 0xFFFF);
1161 fh->dcallno = htons(pvt->peercallno);
1162 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_full_hdr);
1165 /* Retry after 2x the ping time has passed */
1166 fr->retrytime = pvt->pingtime * 2;
1167 if (fr->retrytime < MIN_RETRY_TIME)
1168 fr->retrytime = MIN_RETRY_TIME;
1169 if (fr->retrytime > MAX_RETRY_TIME)
1170 fr->retrytime = MAX_RETRY_TIME;
1171 /* Acks' don't get retried */
1172 if ((f->frametype == AST_FRAME_IAX) && (f->subclass == AST_IAX_COMMAND_ACK))
1174 if (f->frametype == AST_FRAME_VOICE) {
1175 pvt->svoiceformat = f->subclass;
1177 res = iax_transmit(fr);
1179 /* Mini-frames have no sequence number */
1181 /* Mini frame will do */
1182 mh = (struct ast_iax_mini_hdr *)(fr->f->data - sizeof(struct ast_iax_mini_hdr));
1183 mh->callno = htons(fr->callno);
1184 mh->ts = htons(fr->ts & 0xFFFF);
1185 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_mini_hdr);
1188 res = iax_transmit(fr);
1195 static int iax_show_users(int fd, int argc, char *argv[])
1197 #define FORMAT "%-15.15s %-15.15s %-15.15s %-15.15s %-5.5s\n"
1198 struct iax_user *user;
1200 return RESULT_SHOWUSAGE;
1201 pthread_mutex_lock(&userl.lock);
1202 ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C");
1203 for(user=userl.users;user;user=user->next) {
1204 ast_cli(fd, FORMAT, user->name, user->secret, user->methods,
1205 user->contexts ? user->contexts->context : context,
1206 user->ha ? "Yes" : "No");
1208 pthread_mutex_unlock(&userl.lock);
1209 return RESULT_SUCCESS;
1213 static int iax_show_peers(int fd, int argc, char *argv[])
1215 #define FORMAT2 "%-15.15s %-15.15s %-15.15s %-15.15s %s\n"
1216 #define FORMAT "%-15.15s %-15.15s %-15.15s %-15.15s %d\n"
1217 struct iax_peer *peer;
1219 return RESULT_SHOWUSAGE;
1220 pthread_mutex_lock(&peerl.lock);
1221 ast_cli(fd, FORMAT2, "Name", "Username", "Host", "Mask", "Port");
1222 for (peer = peerl.peers;peer;peer = peer->next) {
1224 strncpy(nm, inet_ntoa(peer->mask), sizeof(nm));
1225 ast_cli(fd, FORMAT, peer->name,
1226 peer->username ? peer->username : "(Any)",
1227 peer->addr.sin_addr.s_addr ? inet_ntoa(peer->addr.sin_addr) : "(Any)",
1229 ntohs(peer->addr.sin_port));
1231 pthread_mutex_unlock(&peerl.lock);
1232 return RESULT_SUCCESS;
1237 static int iax_show_channels(int fd, int argc, char *argv[])
1239 #define FORMAT2 "%-15.15s %-10.10s %-11.11s %-11.11s %-7.7s %-6.6s %s\n"
1240 #define FORMAT "%-15.15s %-10.10s %5.5d/%5.5d %5.5d/%5.5d %-5.5dms %-4.4dms %d\n"
1243 return RESULT_SHOWUSAGE;
1244 pthread_mutex_lock(&iaxs_lock);
1245 ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format");
1246 for (x=0;x<AST_IAX_MAX_CALLS;x++)
1248 ast_cli(fd, FORMAT, inet_ntoa(iaxs[x]->addr.sin_addr),
1249 strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)",
1250 iaxs[x]->callno, iaxs[x]->peercallno,
1251 iaxs[x]->oseqno, iaxs[x]->iseqno,
1254 iaxs[x]->voiceformat);
1255 pthread_mutex_unlock(&iaxs_lock);
1256 return RESULT_SUCCESS;
1261 static char show_users_usage[] =
1262 "Usage: iax show users\n"
1263 " Lists all users known to the IAX (Inter-Asterisk eXchange) subsystem.\n";
1265 static char show_channels_usage[] =
1266 "Usage: iax show channels\n"
1267 " Lists all currently active IAX channels.\n";
1269 static char show_peers_usage[] =
1270 "Usage: iax show peers\n"
1271 " Lists all known IAX peers.\n";
1273 static struct ast_cli_entry cli_show_users =
1274 { { "iax", "show", "users", NULL }, iax_show_users, "Show defined IAX users", show_users_usage };
1275 static struct ast_cli_entry cli_show_channels =
1276 { { "iax", "show", "channels", NULL }, iax_show_channels, "Show active IAX channels", show_channels_usage };
1277 static struct ast_cli_entry cli_show_peers =
1278 { { "iax", "show", "peers", NULL }, iax_show_peers, "Show defined IAX peers", show_peers_usage };
1280 static int iax_write(struct ast_channel *c, struct ast_frame *f)
1282 struct chan_iax_pvt *i = c->pvt->pvt;
1283 /* If there's an outstanding error, return failure now */
1285 ast_log(LOG_DEBUG, "Write error: %s\n", strerror(errno));
1288 /* Don't waste bandwidth sending null frames */
1289 if (f->frametype == AST_FRAME_NULL)
1291 /* Simple, just queue for transmission */
1292 return iax_send(i, f, 0, -1);
1295 static int send_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
1299 f.subclass = command;
1300 f.datalen = datalen;
1304 f.src = __FUNCTION__;
1306 return iax_send(i, &f, ts, seqno);
1309 static int apply_context(struct iax_context *con, char *context)
1312 if (!strcmp(con->context, context))
1319 static int apply_ha(struct iax_ha *ha, struct sockaddr_in *sin)
1321 /* Start optimistic */
1322 int res = IAX_SENSE_ALLOW;
1324 /* For each rule, if this address and the netmask = the net address
1325 apply the current rule */
1326 if ((sin->sin_addr.s_addr & ha->netmask.s_addr) == (ha->netaddr.s_addr))
1333 static int iax_getformats(int callno, char *orequest)
1337 strncpy(request, orequest, sizeof(request));
1338 var = strtok(request, ";");
1340 value = strchr(var, '=');
1344 if (!strcmp(var, "formats")) {
1345 iaxs[callno]->peerformats = atoi(value);
1347 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
1349 var = strtok(NULL, ";");
1354 static int check_access(int callno, struct sockaddr_in *sin, char *orequest, int requestl)
1356 /* Start pessimistic */
1360 struct iax_user *user;
1362 strncpy(request, orequest, sizeof(request));
1365 var = strtok(request, ";");
1367 value = strchr(var, '=');
1371 if (!strcmp(var, "exten"))
1372 strncpy(iaxs[callno]->exten, value, sizeof(iaxs[callno]->exten));
1373 else if (!strcmp(var, "callerid"))
1374 strncpy(iaxs[callno]->callerid, value, sizeof(iaxs[callno]->callerid));
1375 else if (!strcmp(var, "dnid"))
1376 strncpy(iaxs[callno]->dnid, value, sizeof(iaxs[callno]->dnid));
1377 else if (!strcmp(var, "context"))
1378 strncpy(iaxs[callno]->context, value, sizeof(iaxs[callno]->context));
1379 else if (!strcmp(var, "username"))
1380 strncpy(iaxs[callno]->username, value, sizeof(iaxs[callno]->username));
1381 else if (!strcmp(var, "formats"))
1382 iaxs[callno]->peerformats = atoi(value);
1383 else if (!strcmp(var, "version"))
1384 version = atoi(value);
1386 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
1388 var = strtok(NULL, ";");
1390 if (version > AST_IAX_PROTO_VERSION) {
1391 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
1392 inet_ntoa(sin->sin_addr), version);
1395 pthread_mutex_lock(&userl.lock);
1396 /* Search the userlist for a compatible entry, and fill in the rest */
1399 if ((!strlen(iaxs[callno]->username) || /* No username specified */
1400 !strcmp(iaxs[callno]->username, user->name)) /* Or this username specified */
1401 && (apply_ha(user->ha, sin) == IAX_SENSE_ALLOW) /* Access is permitted from this IP */
1402 && (!strlen(iaxs[callno]->context) || /* No context specified */
1403 apply_context(user->contexts, iaxs[callno]->context))) { /* Context is permitted */
1404 /* We found our match (use the first) */
1406 /* Store the requested username if not specified */
1407 if (!strlen(iaxs[callno]->username))
1408 strncpy(iaxs[callno]->username, user->name, sizeof(iaxs[callno]->username));
1409 /* And use the default context */
1410 if (!strlen(iaxs[callno]->context)) {
1412 strncpy(iaxs[callno]->context, user->contexts->context, sizeof(iaxs[callno]->context));
1414 strncpy(iaxs[callno]->context, context, sizeof(iaxs[callno]->context));
1416 /* Copy the secret */
1417 strncpy(iaxs[callno]->secret, user->secret, sizeof(iaxs[callno]->secret));
1418 /* And the permitted authentication methods */
1419 strncpy(iaxs[callno]->methods, user->methods, sizeof(iaxs[callno]->methods));
1425 pthread_mutex_unlock(&userl.lock);
1429 static int raw_hangup(struct sockaddr_in *sin, short src, short dst)
1431 struct ast_iax_full_hdr fh;
1432 fh.callno = htons(src | AST_FLAG_FULL);
1433 fh.dcallno = htons(dst);
1436 fh.type = AST_FRAME_IAX;
1437 fh.csub = compress_subclass(AST_IAX_COMMAND_INVAL);
1439 ast_log(LOG_DEBUG, "Raw Hangup\n");
1440 return sendto(netsocket, &fh, sizeof(fh), 0, sin, sizeof(*sin));
1443 static int authenticate_request(struct chan_iax_pvt *p)
1445 char requeststr[256] = "";
1446 MYSNPRINTF "methods=%s;", p->methods);
1447 if (strstr(p->methods, "md5")) {
1448 /* Build the challenge */
1450 snprintf(p->challenge, sizeof(p->challenge), "%d", rand());
1451 MYSNPRINTF "challenge=%s;", p->challenge);
1453 MYSNPRINTF "username=%s;", p->username);
1454 if (strlen(requeststr))
1455 requeststr[strlen(requeststr) - 1] = '\0';
1456 return send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREQ, 0, requeststr, strlen(requeststr) + 1, -1);
1459 static int authenticate_verify(struct chan_iax_pvt *p, char *orequest)
1461 char requeststr[256] = "";
1462 char *var, *value, request[256];
1463 char md5secret[256] = "";
1464 char secret[256] = "";
1468 if (!(p->state & IAX_STATE_AUTHENTICATED))
1470 strncpy(request, orequest, sizeof(request));
1471 var = strtok(request, ";");
1473 value = strchr(var, '=');
1477 if (!strcmp(var, "secret"))
1478 strncpy(secret, value, sizeof(secret));
1479 else if (!strcmp(var, "md5secret"))
1480 strncpy(md5secret, value, sizeof(md5secret));
1482 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
1484 var = strtok(NULL, ";");
1486 if (strstr(p->methods, "md5")) {
1487 struct MD5Context md5;
1488 unsigned char digest[16];
1490 MD5Update(&md5, p->challenge, strlen(p->challenge));
1491 MD5Update(&md5, p->secret, strlen(p->secret));
1492 MD5Final(digest, &md5);
1493 /* If they support md5, authenticate with it. */
1495 MYSNPRINTF "%2.2x", digest[x]);
1496 if (!strcasecmp(requeststr, md5secret))
1498 } else if (strstr(p->methods, "plaintext")) {
1499 if (!strcmp(secret, p->secret))
1505 static int authenticate_reply(struct chan_iax_pvt *p, struct sockaddr_in *sin, char *orequest)
1507 struct iax_peer *peer;
1508 /* Start pessimistic */
1511 char methods[80] = "";
1512 char requeststr[256] = "";
1515 strncpy(request, orequest, sizeof(request));
1516 var = strtok(request, ";");
1518 value = strchr(var, '=');
1522 if (!strcmp(var, "username"))
1523 strncpy(p->username, value, sizeof(p->username));
1524 else if (!strcmp(var, "challenge"))
1525 strncpy(p->challenge, value, sizeof(p->challenge));
1526 else if (!strcmp(var, "methods"))
1527 strncpy(methods, value, sizeof(methods));
1529 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
1531 var = strtok(NULL, ";");
1533 pthread_mutex_lock(&peerl.lock);
1536 if ((!strlen(p->peer) || !strcmp(p->peer, peer->name))
1537 /* No peer specified at our end, or this is the peer */
1538 && (!strlen(peer->username) || (!strcmp(peer->username, p->username)))
1539 /* No username specified in peer rule, or this is the right username */
1540 && (!peer->addr.sin_addr.s_addr || ((sin->sin_addr.s_addr & peer->mask.s_addr) == (peer->addr.sin_addr.s_addr & peer->mask.s_addr)))
1541 /* No specified host, or this is our host */
1543 /* We have a match, authenticate it. */
1545 if (strstr(methods, "md5")) {
1546 struct MD5Context md5;
1547 unsigned char digest[16];
1549 MD5Update(&md5, p->challenge, strlen(p->challenge));
1550 MD5Update(&md5, peer->secret, strlen(peer->secret));
1551 MD5Final(digest, &md5);
1552 /* If they support md5, authenticate with it. */
1553 MYSNPRINTF "md5secret=");
1555 MYSNPRINTF "%2.2x", digest[x]);
1557 } else if (strstr(methods, "plaintext")) {
1558 MYSNPRINTF "secret=%s;", peer->secret);
1561 if (strlen(requeststr))
1562 requeststr[strlen(requeststr)-1] = '\0';
1564 res = send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREP, 0, requeststr, strlen(requeststr) + 1, -1);
1569 pthread_mutex_unlock(&peerl.lock);
1573 static int socket_read(int *id, int fd, short events, void *cbdata)
1575 struct sockaddr_in sin;
1577 int new = NEW_PREVENT;
1580 int len = sizeof(sin);
1582 struct ast_iax_full_hdr *fh = (struct ast_iax_full_hdr *)buf;
1583 struct ast_iax_mini_hdr *mh = (struct ast_iax_mini_hdr *)buf;
1584 struct ast_iax_frame fr, *cur;
1586 struct ast_channel *c;
1587 res = recvfrom(netsocket, buf, sizeof(buf), 0, &sin, &len);
1589 ast_log(LOG_WARNING, "Error: %s\n", strerror(errno));
1593 if (res < sizeof(struct ast_iax_mini_hdr)) {
1594 ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, sizeof(struct ast_iax_mini_hdr));
1597 if (ntohs(mh->callno) & AST_FLAG_FULL) {
1598 /* Get the destination call number */
1599 dcallno = ntohs(fh->dcallno);
1600 /* Retrieve the type and subclass */
1601 f.frametype = fh->type;
1602 f.subclass = uncompress_subclass(fh->csub);
1604 f.subclass = fh->subclasshigh << 16;
1605 f.subclass += ntohs(fh->subclasslow);
1607 if ((f.frametype == AST_FRAME_IAX) && (f.subclass == AST_IAX_COMMAND_NEW))
1610 pthread_mutex_lock(&iaxs_lock);
1611 fr.callno = find_callno(ntohs(mh->callno) & ~AST_FLAG_FULL, dcallno, &sin, new);
1612 if ((fr.callno < 0) || !iaxs[fr.callno]) {
1613 /* A call arrived for a non-existant destination. Unless it's an "inval"
1614 frame, reply with an inval */
1615 if (ntohs(mh->callno) & AST_FLAG_FULL) {
1616 /* We can only raw hangup control frames */
1617 if ((f.subclass != AST_IAX_COMMAND_INVAL) || (f.frametype != AST_FRAME_IAX))
1618 raw_hangup(&sin, ntohs(fh->dcallno), ntohs(mh->callno));
1620 pthread_mutex_unlock(&iaxs_lock);
1623 iaxs[fr.callno]->peercallno = ntohs(mh->callno) & ~AST_FLAG_FULL;
1624 if (ntohs(mh->callno) & AST_FLAG_FULL) {
1626 ast_log(LOG_DEBUG, "Received packet %d, (%d, %d)\n", ntohs(fh->seqno), f.frametype, f.subclass);
1627 /* Check if it's out of order (and not an ACK or INVAL) */
1628 fr.seqno = ntohs(fh->seqno);
1629 if (iaxs[fr.callno]->iseqno != fr.seqno) {
1631 ((f.subclass != AST_IAX_COMMAND_ACK) && (f.subclass != AST_IAX_COMMAND_INVAL)) ||
1632 (f.frametype != AST_FRAME_IAX)) {
1633 /* If it's not an ACK packet, it's out of order. */
1635 ast_log(LOG_DEBUG, "Packet arrived out of order (expecting %d, got %d) (frametype = %d, subclass = %d)\n",
1636 iaxs[fr.callno]->iseqno, fr.seqno, f.frametype, f.subclass);
1637 if (iaxs[fr.callno]->iseqno > fr.seqno) {
1638 /* If we've already seen it, ack it XXX There's a border condition here XXX */
1639 if ((f.frametype != AST_FRAME_IAX) ||
1640 ((f.subclass != AST_IAX_COMMAND_ACK) && (f.subclass != AST_IAX_COMMAND_INVAL))) {
1642 ast_log(LOG_DEBUG, "Acking anyway\n");
1643 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACK, fr.ts, NULL, 0,fr.seqno);
1646 pthread_mutex_unlock(&iaxs_lock);
1650 /* Increment unless it's an ACK */
1651 if ((f.subclass != AST_IAX_COMMAND_ACK) ||
1652 (f.frametype != AST_FRAME_IAX))
1653 iaxs[fr.callno]->iseqno++;
1656 if (res < sizeof(struct ast_iax_full_hdr)) {
1657 ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, sizeof(struct ast_iax_full_hdr));
1658 pthread_mutex_unlock(&iaxs_lock);
1661 f.datalen = res - sizeof(struct ast_iax_full_hdr);
1663 f.data = buf + sizeof(struct ast_iax_full_hdr);
1666 fr.ts = ntohl(fh->ts);
1667 /* Unless this is an ACK or INVAL frame, ack it */
1668 if ((f.frametype != AST_FRAME_IAX) ||
1669 ((f.subclass != AST_IAX_COMMAND_ACK) && (f.subclass != AST_IAX_COMMAND_INVAL)))
1670 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACK, fr.ts, NULL, 0,fr.seqno);
1671 if (f.frametype == AST_FRAME_VOICE)
1672 iaxs[fr.callno]->voiceformat = f.subclass;
1673 if (f.frametype == AST_FRAME_IAX) {
1674 /* Handle the IAX pseudo frame itself */
1676 ast_log(LOG_DEBUG, "IAX subclass %d received\n", f.subclass);
1677 switch(f.subclass) {
1678 case AST_IAX_COMMAND_ACK:
1679 /* Ack the packet with the given timestamp */
1680 pthread_mutex_lock(&iaxq.lock);
1681 for (cur = iaxq.head; cur ; cur = cur->next) {
1682 /* If it's our call, and our timestamp, mark -1 retries */
1683 if ((fr.callno == cur->callno) && (fr.seqno == cur->seqno))
1686 pthread_mutex_unlock(&iaxq.lock);
1688 case AST_IAX_COMMAND_NEW:
1689 ((char *)f.data)[f.datalen] = '\0';
1690 if (check_access(fr.callno, &sin, f.data, f.datalen)) {
1691 /* They're not allowed on */
1692 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_REJECT, 0, "No authority found", strlen("No authority found"), -1);
1693 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, request '%s'\n", inet_ntoa(sin.sin_addr), f.data);
1694 /* XXX Not guaranteed to work, but probably does XXX */
1695 pthread_mutex_lock(&iaxq.lock);
1696 send_packet(iaxq.tail);
1697 pthread_mutex_unlock(&iaxq.lock);
1698 iax_destroy(fr.callno);
1701 if (!strlen(iaxs[fr.callno]->secret)) {
1702 /* No authentication required, let them in */
1703 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACCEPT, 0, NULL, 0, -1);
1704 iaxs[fr.callno]->state |= IAX_STATE_STARTED;
1705 if(!(c = ast_iax_new(iaxs[fr.callno], AST_STATE_RING)))
1706 iax_destroy(fr.callno);
1708 c->format = iaxs[fr.callno]->peerformats;
1711 authenticate_request(iaxs[fr.callno]);
1712 iaxs[fr.callno]->state |= IAX_STATE_AUTHENTICATED;
1714 case AST_IAX_COMMAND_HANGUP:
1716 iaxs[fr.callno]->error = ENOTCONN;
1718 iax_destroy(fr.callno);
1720 case AST_IAX_COMMAND_REJECT:
1722 ((char *)f.data)[f.datalen] = '\0';
1723 ast_log(LOG_WARNING, "Call rejected by %s: %s\n", inet_ntoa(iaxs[fr.callno]->addr.sin_addr), f.data);
1724 iaxs[fr.callno]->error = EPERM;
1725 iax_destroy(fr.callno);
1727 case AST_IAX_COMMAND_ACCEPT:
1729 ((char *)f.data)[f.datalen]='\0';
1730 iax_getformats(fr.callno, (char *)f.data);
1732 iaxs[fr.callno]->peerformats = iax_capability;
1734 if (option_verbose > 2)
1735 ast_verbose(VERBOSE_PREFIX_3 "Call accepted by %s\n", inet_ntoa(iaxs[fr.callno]->addr.sin_addr));
1736 iaxs[fr.callno]->state |= IAX_STATE_STARTED;
1737 if (iaxs[fr.callno]->owner) {
1738 /* Switch us to use a compatible format */
1739 iaxs[fr.callno]->owner->format &= iaxs[fr.callno]->peerformats;
1741 if (!iaxs[fr.callno]->owner->format)
1742 iaxs[fr.callno]->owner->format = iaxs[fr.callno]->peerformats & iax_capability;
1743 if (!iaxs[fr.callno]->owner->format) {
1744 ast_log(LOG_WARNING, "Unable to negotiate a common format with the peer.");
1745 iaxs[fr.callno]->error = EBADE;
1746 iax_destroy(fr.callno);
1748 if (option_verbose > 2)
1749 ast_verbose(VERBOSE_PREFIX_3 "Format for call is %d\n", iaxs[fr.callno]->owner->format);
1754 case AST_IAX_COMMAND_PING:
1755 /* Send back a pong packet with the original timestamp */
1756 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_PONG, fr.ts, NULL, 0, -1);
1758 case AST_IAX_COMMAND_PONG:
1759 iaxs[fr.callno]->pingtime = calc_timestamp(iaxs[fr.callno], 0) - fr.ts;
1761 case AST_IAX_COMMAND_LAGRQ:
1762 case AST_IAX_COMMAND_LAGRP:
1763 /* A little strange -- We have to actually go through the motions of
1764 delivering the packet. In the very last step, it will be properly
1765 handled by do_deliver */
1766 snprintf(src, sizeof(src), "LAGRQ-IAX/%s/%d", inet_ntoa(sin.sin_addr),fr.callno);
1772 schedule_delivery(iaxfrdup2(&fr, 0));
1774 case AST_IAX_COMMAND_AUTHREQ:
1775 ((char *)f.data)[f.datalen] = '\0';
1776 if (authenticate_reply(iaxs[fr.callno], &iaxs[fr.callno]->addr, (char *)f.data)) {
1777 ast_log(LOG_WARNING,
1778 "I don't know how to authenticate %s to %s\n",
1779 f.data, inet_ntoa(iaxs[fr.callno]->addr.sin_addr));
1780 iax_destroy(fr.callno);
1783 case AST_IAX_COMMAND_AUTHREP:
1784 ((char *)f.data)[f.datalen] = '\0';
1785 if (authenticate_verify(iaxs[fr.callno], (char *)f.data)) {
1786 ast_log(LOG_NOTICE, "Host %s failed to authenticate as %s\n", inet_ntoa(iaxs[fr.callno]->addr.sin_addr), iaxs[fr.callno]->username);
1787 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_REJECT, 0, "No authority found", strlen("No authority found"), -1);
1788 /* XXX Not guaranteed to work, but probably does XXX */
1789 pthread_mutex_lock(&iaxq.lock);
1790 send_packet(iaxq.tail);
1791 pthread_mutex_unlock(&iaxq.lock);
1792 iax_destroy(fr.callno);
1795 /* Authentication is fine, go ahead */
1796 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACCEPT, 0, NULL, 0, -1);
1797 iaxs[fr.callno]->state |= IAX_STATE_STARTED;
1798 if(!(c = ast_iax_new(iaxs[fr.callno], AST_STATE_RING)))
1799 iax_destroy(fr.callno);
1801 c->format = iaxs[fr.callno]->peerformats;
1803 case AST_IAX_COMMAND_INVAL:
1804 iaxs[fr.callno]->error = ENOTCONN;
1805 iax_destroy(fr.callno);
1807 ast_log(LOG_DEBUG, "Destroying call %d\n", fr.callno);
1810 ast_log(LOG_DEBUG, "Unknown IAX command %d on %d/%d\n", f.subclass, fr.callno, iaxs[fr.callno]->peercallno);
1812 /* Don't actually pass these frames along */
1813 pthread_mutex_unlock(&iaxs_lock);
1818 f.frametype = AST_FRAME_VOICE;
1819 if (iaxs[fr.callno]->voiceformat > 0)
1820 f.subclass = iaxs[fr.callno]->voiceformat;
1822 ast_log(LOG_WARNING, "Received mini frame before first full voice frame\n ");
1823 pthread_mutex_unlock(&iaxs_lock);
1826 f.datalen = res - sizeof(struct ast_iax_mini_hdr);
1827 if (f.datalen < 0) {
1828 ast_log(LOG_WARNING, "Datalen < 0?\n");
1829 pthread_mutex_unlock(&iaxs_lock);
1833 f.data = buf + sizeof(struct ast_iax_mini_hdr);
1836 fr.ts = (iaxs[fr.callno]->last & 0xFFFF0000L) | ntohs(mh->ts);
1838 /* Don't pass any packets until we're started */
1839 if (!(iaxs[fr.callno]->state & IAX_STATE_STARTED)) {
1840 pthread_mutex_unlock(&iaxs_lock);
1844 snprintf(src, sizeof(src), "IAX/%s/%d", inet_ntoa(sin.sin_addr),fr.callno);
1849 if (f.datalen && (f.frametype == AST_FRAME_VOICE))
1850 f.timelen = get_timelen(&f);
1854 /* If this is our most recent packet, use it as our basis for timestamping */
1855 if (iaxs[fr.callno]->last < fr.ts) {
1856 iaxs[fr.callno]->last = fr.ts;
1859 ast_log(LOG_DEBUG, "Received out of order packet... (type=%d, subclass %d, ts = %d, last = %d)\n", f.frametype, f.subclass, fr.ts, iaxs[fr.callno]->last);
1862 schedule_delivery(iaxfrdup2(&fr, 0));
1863 /* Always run again */
1864 pthread_mutex_unlock(&iaxs_lock);
1868 static void free_ha(struct iax_ha *ha)
1878 static void free_context(struct iax_context *con)
1880 struct iax_context *conl;
1888 static struct ast_channel *iax_request(char *type, int format, void *data)
1891 struct sockaddr_in sin;
1894 struct ast_channel *c;
1895 strncpy(s, (char *)data, sizeof(s));
1898 st = strtok(NULL, "@");
1901 /* Populate our address from the given */
1902 if (create_addr(&sin, st)) {
1903 ast_log(LOG_WARNING, "Unable to assign address\n");
1906 pthread_mutex_lock(&iaxs_lock);
1907 callno = find_callno(-1, -1, &sin, NEW_FORCE);
1909 ast_log(LOG_WARNING, "Unable to create call\n");
1912 c = ast_iax_new(iaxs[callno], AST_STATE_DOWN);
1914 /* Choose a format we can live with */
1915 if (c->format & format)
1916 c->format &= format;
1918 c->format = ast_translator_best_choice(format, c->format);
1920 pthread_mutex_unlock(&iaxs_lock);
1924 static void *network_thread(void *ignore)
1926 /* Our job is simple: Send queued messages, retrying if necessary. Read frames
1927 from the network, and queue them for delivery to the channels */
1929 struct ast_iax_frame *f, *freeme;
1930 /* Establish I/O callback for socket read */
1931 ast_io_add(io, netsocket, socket_read, AST_IO_IN, NULL);
1932 pthread_mutex_lock(&iaxs_lock);
1934 /* Go through the queue, sending messages which have not yet been
1935 sent, and scheduling retransmissions if appropriate */
1936 pthread_mutex_lock(&iaxq.lock);
1942 /* Send a copy immediately */
1943 if (iaxs[f->callno]) {
1946 if (f->retries < 0) {
1947 /* This is not supposed to be retransmitted */
1949 f->prev->next = f->next;
1951 iaxq.head = f->next;
1953 f->next->prev = f->prev;
1955 iaxq.tail = f->prev;
1957 /* Free the frame */
1959 /* Free the iax frame */
1962 /* We need reliable delivery. Schedule a retransmission */
1964 ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1971 pthread_mutex_unlock(&iaxq.lock);
1972 pthread_mutex_unlock(&iaxs_lock);
1973 res = ast_sched_wait(sched);
1974 res = ast_io_wait(io, res);
1975 pthread_mutex_lock(&iaxs_lock);
1977 ast_sched_runq(sched);
1982 static int start_network_thread()
1984 return pthread_create(&netthreadid, NULL, network_thread, NULL);
1987 static struct iax_context *build_context(char *context)
1989 struct iax_context *con = malloc(sizeof(struct iax_context));
1991 strncpy(con->context, context, sizeof(con->context));
1997 static struct iax_ha *build_ha(char *sense, char *stuff)
1999 struct iax_ha *ha = malloc(sizeof(struct iax_ha));
2003 nm = strtok(NULL, "/");
2005 nm = "255.255.255.255";
2006 if (!inet_aton(stuff, &ha->netaddr)) {
2007 ast_log(LOG_WARNING, "%s not a valid IP\n", stuff);
2011 if (!inet_aton(nm, &ha->netmask)) {
2012 ast_log(LOG_WARNING, "%s not a valid netmask\n", nm);
2016 ha->netaddr.s_addr &= ha->netmask.s_addr;
2017 if (!strcasecmp(sense, "a")) {
2018 ha->sense = IAX_SENSE_ALLOW;
2020 ha->sense = IAX_SENSE_DENY;
2027 static struct iax_peer *build_peer(char *name, struct ast_variable *v)
2029 struct iax_peer *peer;
2032 peer = malloc(sizeof(struct iax_peer));
2034 memset(peer, 0, sizeof(struct iax_peer));
2035 strncpy(peer->name, name, sizeof(peer->name));
2036 peer->addr.sin_port = htons(AST_DEFAULT_IAX_PORTNO);
2038 if (!strcasecmp(v->name, "secret"))
2039 strncpy(peer->secret, v->value, sizeof(peer->secret));
2040 else if (!strcasecmp(v->name, "host")) {
2041 hp = gethostbyname(v->value);
2043 memcpy(&peer->addr.sin_addr, hp->h_addr, sizeof(peer->addr.sin_addr));
2045 ast_log(LOG_WARNING, "Unable to lookup '%s'\n", v->value);
2050 inet_aton("255.255.255.255", &peer->mask);
2052 else if (!strcasecmp(v->name, "mask")) {
2054 inet_aton(v->value, &peer->mask);
2055 } else if (!strcasecmp(v->name, "port"))
2056 peer->addr.sin_port = htons(atoi(v->value));
2057 else if (!strcasecmp(v->name, "username"))
2058 strncpy(peer->username, v->value, sizeof(peer->username));
2065 static struct iax_user *build_user(char *name, struct ast_variable *v)
2067 struct iax_user *user;
2068 struct iax_context *con, *conl = NULL;
2069 struct iax_ha *ha, *hal = NULL;
2070 user = (struct iax_user *)malloc(sizeof(struct iax_user));
2072 memset(user, 0, sizeof(struct iax_user));
2073 strncpy(user->name, name, sizeof(user->name));
2075 if (!strcasecmp(v->name, "context")) {
2076 con = build_context(v->value);
2081 user->contexts = con;
2084 } else if (!strcasecmp(v->name, "allow") ||
2085 !strcasecmp(v->name, "deny")) {
2086 ha = build_ha(v->name, v->value);
2094 } else if (!strcasecmp(v->name, "auth")) {
2095 strncpy(user->methods, v->value, sizeof(user->methods));
2096 } else if (!strcasecmp(v->name, "secret")) {
2097 strncpy(user->secret, v->value, sizeof(user->secret));
2108 struct ast_config *cfg;
2109 struct ast_variable *v;
2110 struct iax_user *user;
2111 struct iax_peer *peer;
2116 struct sockaddr_in sin;
2118 sin.sin_family = AF_INET;
2119 sin.sin_port = ntohs(AST_DEFAULT_IAX_PORTNO);
2120 sin.sin_addr.s_addr = INADDR_ANY;
2122 io = io_context_create();
2123 sched = sched_context_create();
2125 if (!io || !sched) {
2126 ast_log(LOG_ERROR, "Out of memory\n");
2130 pthread_mutex_init(&iaxq.lock, NULL);
2131 pthread_mutex_init(&userl.lock, NULL);
2133 ast_cli_register(&cli_show_users);
2134 ast_cli_register(&cli_show_channels);
2135 ast_cli_register(&cli_show_peers);
2136 ast_cli_register(&cli_set_jitter);
2137 #ifdef IAX_SIMULATOR
2138 ast_cli_register(&delay_cli);
2139 ast_cli_register(&deviation_cli);
2140 ast_cli_register(&reliability_cli);
2141 ast_cli_register(&sim_show_cli);
2143 cfg = ast_load(config);
2146 ast_log(LOG_ERROR, "Unable to load config %s\n", config);
2149 v = ast_variable_browse(cfg, "general");
2151 if (!strcasecmp(v->name, "port"))
2152 sin.sin_port = ntohs(atoi(v->value));
2153 else if (!strcasecmp(v->name, "pingtime"))
2154 ping_time = atoi(v->value);
2155 else if (!strcasecmp(v->name, "maxjitterbuffer"))
2156 maxjitterbuffer = atoi(v->value);
2157 else if (!strcasecmp(v->name, "maxexcessbuffer"))
2158 max_jitter_buffer = atoi(v->value);
2159 else if (!strcasecmp(v->name, "lagrqtime"))
2160 lagrq_time = atoi(v->value);
2161 else if (!strcasecmp(v->name, "dropcount"))
2162 iax_dropcount = atoi(v->value);
2163 else if (!strcasecmp(v->name, "bindaddr"))
2164 inet_aton(v->value, &sin.sin_addr);
2165 else if (!strcasecmp(v->name, "jitterbuffer"))
2166 use_jitterbuffer = ast_true(v->value);
2167 else if (!strcasecmp(v->name, "bandwidth")) {
2168 if (!strcasecmp(v->value, "low")) {
2169 iax_capability = IAX_CAPABILITY_LOWBANDWIDTH;
2170 } else if (!strcasecmp(v->value, "medium")) {
2171 iax_capability = IAX_CAPABILITY_MEDBANDWIDTH;
2172 } else if (!strcasecmp(v->value, "high")) {
2173 iax_capability = IAX_CAPABILITY_FULLBANDWIDTH;
2175 ast_log(LOG_WARNING, "bandwidth must be either low, medium, or high\n");
2176 } else if (!strcasecmp(v->name, "allow")) {
2177 format = ast_getformatbyname(v->value);
2179 ast_log(LOG_WARNING, "Cannot allow unknown format '%s'\n", v->value);
2181 iax_capability |= format;
2182 } else if (!strcasecmp(v->name, "disallow")) {
2183 format = ast_getformatbyname(v->value);
2185 ast_log(LOG_WARNING, "Cannot disallow unknown format '%s'\n", v->value);
2187 iax_capability &= ~format;
2191 cat = ast_category_browse(cfg, NULL);
2193 if (strcasecmp(cat, "general")) {
2194 utype = ast_variable_retrieve(cfg, cat, "type");
2196 if (!strcasecmp(utype, "user")) {
2197 user = build_user(cat, ast_variable_browse(cfg, cat));
2199 pthread_mutex_lock(&userl.lock);
2200 user->next = userl.users;
2202 pthread_mutex_unlock(&userl.lock);
2204 } else if (!strcasecmp(utype, "peer")) {
2205 peer = build_peer(cat, ast_variable_browse(cfg, cat));
2207 pthread_mutex_lock(&peerl.lock);
2208 peer->next = peerl.peers;
2210 pthread_mutex_unlock(&peerl.lock);
2213 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config);
2216 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
2218 cat = ast_category_browse(cfg, cat);
2221 if (ast_channel_register(type, tdesc, iax_capability, iax_request)) {
2222 ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
2227 /* Make a UDP socket */
2228 netsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
2230 if (netsocket < 0) {
2231 ast_log(LOG_ERROR, "Unable to create network socket: %s\n", strerror(errno));
2234 if (bind(netsocket, &sin, sizeof(sin))) {
2235 ast_log(LOG_ERROR, "Unable to bind to %s port %d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
2240 res = start_network_thread();
2241 if (option_verbose > 1)
2242 ast_verbose(VERBOSE_PREFIX_2 "IAX Ready and Listening on %s port %d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
2244 ast_log(LOG_ERROR, "Unable to start network thread\n");
2257 struct iax_user *user, *userlast;
2258 struct iax_peer *peer, *peerlast;
2260 /* Cancel the network thread, close the net socket */
2261 pthread_cancel(netthreadid);
2262 pthread_join(netthreadid, NULL);
2264 for (x=0;x<AST_IAX_MAX_CALLS;x++)
2267 ast_cli_unregister(&cli_show_users);
2268 ast_cli_unregister(&cli_show_channels);
2269 ast_cli_unregister(&cli_show_peers);
2270 ast_cli_unregister(&cli_set_jitter);
2271 #ifdef IAX_SIMULATOR
2272 ast_cli_unregister(&delay_cli);
2273 ast_cli_unregister(&deviation_cli);
2274 ast_cli_unregister(&reliability_cli);
2275 ast_cli_unregister(&sim_show_cli);
2277 for (user=userl.users;user;) {
2279 free_context(user->contexts);
2284 for (peer=peerl.peers;peer;) {
2295 pthread_mutex_lock(&usecnt_lock);
2297 pthread_mutex_unlock(&usecnt_lock);