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);
458 /* Free the packet */
460 /* And our iax frame */
462 /* And don't run again */
466 static int handle_error()
468 /* XXX Ideally we should figure out why an error occured and then abort those
469 rather than continuing to try. Unfortunately, the published interface does
470 not seem to work XXX */
472 struct sockaddr_in *sin;
475 struct sock_extended_err e;
480 m.msg_controllen = sizeof(e);
482 res = recvmsg(netsocket, &m, MSG_ERRQUEUE);
484 ast_log(LOG_WARNING, "Error detected, but unable to read error: %s\n", strerror(errno));
486 if (m.msg_controllen) {
487 sin = (struct sockaddr_in *)SO_EE_OFFENDER(&e);
489 ast_log(LOG_WARNING, "Receive error from %s\n", inet_ntoa(sin->sin_addr));
491 ast_log(LOG_WARNING, "No address detected??\n");
493 ast_log(LOG_WARNING, "Local error: %s\n", strerror(e.ee_errno));
501 static int __send_packet(struct ast_iax_frame *f)
503 static int send_packet(struct ast_iax_frame *f)
508 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));
509 /* Don't send if there was an error, but return error instead */
511 ast_log(LOG_WARNING, "Call number = %d\n", f->callno);
514 if (iaxs[f->callno]->error)
516 res = sendto(netsocket, f->data, f->datalen, 0, &iaxs[f->callno]->addr,
517 sizeof(iaxs[f->callno]->addr));
519 ast_log(LOG_WARNING, "Received error: %s\n", strerror(errno));
528 /* Average amount of delay in the connection */
529 static int average_delay = 0;
530 /* Permitted deviation either side of the average delay */
531 static int delay_deviation = 0;
532 /* Percent chance that a packet arrives O.K. */
533 static int reliability = 100;
535 static int iax_sim_calc_delay()
538 ms = average_delay - delay_deviation;
539 ms += ((float)(delay_deviation * 2)) * rand() / (RAND_MAX + 1.0);
542 if ((float)rand()/(RAND_MAX + 1.0) < ((float)reliability)/100)
548 static int d_send_packet(void *v)
550 struct ast_iax_frame *f = (struct ast_iax_frame *)v;
558 static int send_packet(struct ast_iax_frame *f)
560 struct ast_iax_frame *fn;
562 ms = iax_sim_calc_delay();
564 return __send_packet(f);
566 /* Make a completely independent frame, in case the other
567 is destroyed -- still doesn't make things like hangups
568 arrive if the main channel is destroyed, but close enough */
569 fn = iaxfrdup2(f, 1);
570 ast_sched_add(sched, ms, d_send_packet, fn);
571 } /* else we drop the packet */
575 static int iax_sim_set(int fd, int argc, char *argv[])
578 return RESULT_SHOWUSAGE;
579 if (!strcasecmp(argv[2], "delay"))
580 average_delay = atoi(argv[3]);
581 else if (!strcasecmp(argv[2], "deviation"))
582 delay_deviation = atoi(argv[3]);
583 else if (!strcasecmp(argv[2], "reliability"))
584 reliability = atoi(argv[3]);
586 return RESULT_SHOWUSAGE;
587 if (reliability > 100)
591 if (delay_deviation > average_delay)
592 delay_deviation = average_delay;
593 return RESULT_SUCCESS;
596 static char delay_usage[] =
597 "Usage: sim set delay <value>\n"
598 " Configure the IAX network simulator to generate average\n"
599 " delays equal to the specified value (in milliseconds).\n";
601 static char deviation_usage[] =
602 "Usage: sim set deviation <value>\n"
603 " Configures the IAX network simulator's deviation value.\n"
604 " The delays generated by the simulator will always be within\n"
605 " this value of milliseconds (postive or negative) of the \n"
608 static char reliability_usage[] =
609 "Usage: sim set reliability <value>\n"
610 " Configure the probability that a packet will be delivered.\n"
611 " The value specified is a percentage from 0 to 100\n";
613 static int iax_sim_show(int fd, int argc, char *argv[])
616 return RESULT_SHOWUSAGE;
617 ast_cli(fd, "Average Delay: %d ms\n", average_delay);
618 ast_cli(fd, "Delay Deviation: %d ms\n", delay_deviation);
619 ast_cli(fd, "Reliability: %d %\n", reliability);
620 return RESULT_SUCCESS;
623 static char sim_show_usage[] =
625 " Displays average delay, deviation, and reliability\n"
626 " used by the network simulator.\n";
628 static struct ast_cli_entry delay_cli =
629 { { "sim", "set", "delay", NULL }, iax_sim_set, "Sets simulated average delay", delay_usage };
630 static struct ast_cli_entry deviation_cli =
631 { { "sim", "set", "deviation", NULL }, iax_sim_set, "Sets simulated delay deviation", deviation_usage };
632 static struct ast_cli_entry reliability_cli =
633 { { "sim", "set", "reliability", NULL }, iax_sim_set, "Sets simulated reliability", reliability_usage };
634 static struct ast_cli_entry sim_show_cli =
635 { { "sim", "show", NULL }, iax_sim_show, "Displays simulation parameters", sim_show_usage };
639 static int attempt_transmit(void *data)
641 /* Attempt to transmit the frame to the remote peer */
643 struct ast_iax_frame *f = data;
645 /* Make sure this call is still active */
646 if (iaxs[f->callno]) {
647 if ((f->retries == -1) /* Already ACK'd */ ||
648 (f->retries >= max_retries) /* Too many attempts */) {
649 /* Record an error if we've transmitted too many times */
650 if (f->retries >= max_retries) {
651 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);
652 iaxs[f->callno]->error = ETIMEDOUT;
653 /* Send a bogus frame to wake up the waiting process */
654 write(iaxs[f->callno]->pipe[1], &zero, 1);
656 /* Don't attempt delivery, just remove it from the queue */
657 pthread_mutex_lock(&iaxq.lock);
659 f->prev->next = f->next;
663 f->next->prev = f->prev;
667 pthread_mutex_unlock(&iaxq.lock);
669 /* Attempt transmission */
672 /* Try again later after 10 times as long */
674 if (f->retrytime > MAX_RETRY_TIME)
675 f->retrytime = MAX_RETRY_TIME;
676 ast_sched_add(sched, f->retrytime, attempt_transmit, f);
680 /* Do not try again */
684 static int iax_set_jitter(int fd, int argc, char *argv[])
686 if ((argc != 4) && (argc != 5))
687 return RESULT_SHOWUSAGE;
689 max_jitter_buffer = atoi(argv[3]);
690 if (max_jitter_buffer < 0)
691 max_jitter_buffer = 0;
694 pthread_mutex_lock(&iaxs_lock);
695 if ((atoi(argv[3]) >= 0) && (atoi(argv[3]) < AST_IAX_MAX_CALLS)) {
696 if (iaxs[atoi(argv[3])]) {
697 iaxs[atoi(argv[3])]->jitterbuffer = atoi(argv[4]);
698 if (iaxs[atoi(argv[3])]->jitterbuffer < 0)
699 iaxs[atoi(argv[3])]->jitterbuffer = 0;
701 ast_cli(fd, "No such call '%d'\n", atoi(argv[3]));
703 ast_cli(fd, "%d is not a valid call number\n", atoi(argv[3]));
704 pthread_mutex_unlock(&iaxs_lock);
707 return RESULT_SUCCESS;
710 static char jitter_usage[] =
711 "Usage: iax set jitter [callid] <value>\n"
712 " If used with a callid, it sets the jitter buffer to the given static\n"
713 "value (until its next calculation). If used without a callid, the value is used\n"
714 "to establish the maximum excess jitter buffer that is permitted before the jitter\n"
715 "buffer size is reduced.";
717 static struct ast_cli_entry cli_set_jitter =
718 { { "iax", "set", "jitter", NULL }, iax_set_jitter, "Sets IAX jitter buffer", jitter_usage };
720 static unsigned int calc_rxstamp(struct chan_iax_pvt *p);
722 static int schedule_delivery(struct ast_iax_frame *fr)
724 /* XXX FIXME: I should delay delivery with a sliding jitter buffer XXX */
726 int drops[MEMORY_SIZE];
727 int min, max=0, maxone=0,y,z, match;
728 /* ms is a measure of the "lateness" of the packet relative to the first
729 packet we received, which always has a lateness of 1. */
730 ms = calc_rxstamp(iaxs[fr->callno]) - fr->ts;
732 /* Rotate our history queue of "lateness". Don't worry about those initial
733 zeros because the first entry will always be zero */
734 for (x=0;x<MEMORY_SIZE - 1;x++)
735 iaxs[fr->callno]->history[x] = iaxs[fr->callno]->history[x+1];
736 /* Add a history entry for this one */
737 iaxs[fr->callno]->history[x] = ms;
739 /* Initialize the minimum to reasonable values. It's too much
740 work to do the same for the maximum, repeatedly */
741 min=iaxs[fr->callno]->history[0];
742 for (z=0;z < iax_dropcount + 1;z++) {
743 /* Start very pessimistic ;-) */
745 for (x=0;x<MEMORY_SIZE;x++) {
746 if (max < iaxs[fr->callno]->history[x]) {
747 /* We have a candidate new maximum value. Make
748 sure it's not in our drop list */
750 for (y=0;!match && (y<z);y++)
751 match |= (drops[y] == x);
753 /* It's not in our list, use it as the new maximum */
754 max = iaxs[fr->callno]->history[x];
760 /* On our first pass, find the minimum too */
761 if (min > iaxs[fr->callno]->history[x])
762 min = iaxs[fr->callno]->history[x];
769 /* Just for reference, keep the "jitter" value, the difference between the
770 earliest and the latest. */
771 iaxs[fr->callno]->jitter = max - min;
773 /* If our jitter buffer is too big (by a significant margin), then we slowly
774 shrink it by about 1 ms each time to avoid letting the change be perceived */
775 if (max < iaxs[fr->callno]->jitterbuffer - max_jitter_buffer)
776 iaxs[fr->callno]->jitterbuffer -= 2;
779 /* Constrain our maximum jitter buffer appropriately */
780 if (max > min + maxjitterbuffer) {
782 ast_log(LOG_DEBUG, "Constraining buffer from %d to %d + %d\n", max, min , maxjitterbuffer);
783 max = min + maxjitterbuffer;
787 /* If our jitter buffer is smaller than our maximum delay, grow the jitter
788 buffer immediately to accomodate it (and a little more). */
789 if (max > iaxs[fr->callno]->jitterbuffer)
790 iaxs[fr->callno]->jitterbuffer = max
791 /* + ((float)iaxs[fr->callno]->jitter) * 0.1 */;
795 ast_log(LOG_DEBUG, "min = %d, max = %d, jb = %d, lateness = %d\n", min, max, iaxs[fr->callno]->jitterbuffer, ms);
797 /* Subtract the lateness from our jitter buffer to know how long to wait
798 before sending our packet. */
799 ms = iaxs[fr->callno]->jitterbuffer - ms;
801 if (!use_jitterbuffer)
806 ast_log(LOG_DEBUG, "Calculated ms is %d\n", ms);
807 /* Don't deliver it more than 4 ms late */
808 if ((ms > -4) || (fr->f->frametype != AST_FRAME_VOICE)) {
812 /* Free the packet */
814 /* And our iax frame */
819 ast_log(LOG_DEBUG, "Scheduling delivery in %d ms\n", ms);
820 ast_sched_add(sched, ms, do_deliver, fr);
825 static int iax_transmit(struct ast_iax_frame *fr)
827 /* Lock the queue and place this packet at the end */
830 /* By setting this to 0, the network thread will send it for us, and
831 queue retransmission if necessary */
833 pthread_mutex_lock(&iaxq.lock);
840 iaxq.tail->next = fr;
841 fr->prev = iaxq.tail;
845 pthread_mutex_unlock(&iaxq.lock);
846 /* Wake up the network thread */
847 pthread_kill(netthreadid, SIGURG);
853 static int iax_digit(struct ast_channel *c, char digit)
855 return send_command(c->pvt->pvt, AST_FRAME_DTMF, digit, 0, NULL, 0, -1);
858 static int iax_sendtext(struct ast_channel *c, char *text)
861 return send_command(c->pvt->pvt, AST_FRAME_TEXT,
862 0, 0, text, strlen(text) + 1, -1);
865 static int create_addr(struct sockaddr_in *sin, char *peer)
869 sin->sin_family = AF_INET;
870 pthread_mutex_lock(&peerl.lock);
873 if (!strcasecmp(p->name, peer)) {
874 sin->sin_addr = p->addr.sin_addr;
875 sin->sin_port = p->addr.sin_port;
880 pthread_mutex_unlock(&peerl.lock);
882 hp = gethostbyname(peer);
884 memcpy(&sin->sin_addr, hp->h_addr, sizeof(sin->sin_addr));
885 sin->sin_port = htons(AST_DEFAULT_IAX_PORTNO);
892 static int iax_call(struct ast_channel *c, char *dest, int timeout)
894 struct sockaddr_in sin;
900 char requeststr[256] = "";
901 char myrdest [5] = "s";
902 if ((c->state != AST_STATE_DOWN) && (c->state != AST_STATE_RESERVED)) {
903 ast_log(LOG_WARNING, "Line is already in use (%s)?\n", c->name);
906 strncpy(host, dest, sizeof(host));
908 /* If no destination extension specified, use 's' */
909 rdest = strtok(NULL, ":");
913 rcontext = strtok(NULL, "@");
915 username = strtok(NULL, "@");
917 /* Really the second argument is the host, not the username */
923 if (create_addr(&sin, hname)) {
924 ast_log(LOG_WARNING, "No address associated with '%s'\n", hname);
927 /* Now we build our request string */
928 #define MYSNPRINTF snprintf(requeststr + strlen(requeststr), sizeof(requeststr) - strlen(requeststr),
929 MYSNPRINTF "exten=%s;", rdest);
931 MYSNPRINTF "callerid=%s;", c->callerid);
933 MYSNPRINTF "dnid=%s;", c->dnid);
935 MYSNPRINTF "context=%s;", rcontext);
937 MYSNPRINTF "username=%s;", username);
938 MYSNPRINTF "formats=%d;", c->format);
939 MYSNPRINTF "version=%d;", AST_IAX_PROTO_VERSION);
940 /* Trim the trailing ";" */
941 if (strlen(requeststr))
942 requeststr[strlen(requeststr) - 1] = '\0';
943 /* Transmit the string in a "NEW" request */
944 if (option_verbose > 2)
945 ast_verbose(VERBOSE_PREFIX_3 "Calling using options '%s'\n", requeststr);
946 send_command((struct chan_iax_pvt *)c->pvt->pvt, AST_FRAME_IAX,
947 AST_IAX_COMMAND_NEW, 0, requeststr, strlen(requeststr) + 1, -1);
948 c->state = AST_STATE_RINGING;
952 static void iax_destroy(int callno)
955 struct chan_iax_pvt *pvt = iaxs[callno];
958 /* If there's an owner, prod it to give up */
959 write(pvt->pipe[1], &zero, 1);
969 static int iax_hangup(struct ast_channel *c) {
970 struct chan_iax_pvt *pvt = c->pvt->pvt;
971 /* Send the hangup unless we have had a transmission error */
973 send_command(pvt, AST_FRAME_IAX, AST_IAX_COMMAND_HANGUP, 0, NULL, 0, -1);
974 /* Wait for the network thread to transmit our command -- of course, if
975 it doesn't, that's okay too -- the other end will find out
976 soon enough, but it's a nicity if it can know now. */
979 pthread_mutex_lock(&iaxs_lock);
982 pthread_mutex_lock(&usecnt_lock);
985 ast_log(LOG_WARNING, "Usecnt < 0???\n");
986 pthread_mutex_unlock(&usecnt_lock);
987 ast_update_use_count();
988 if (option_verbose > 2)
989 ast_verbose( VERBOSE_PREFIX_3 "Hungup '%s'\n", c->name);
990 iax_destroy(pvt->callno);
991 pthread_mutex_unlock(&iaxs_lock);
995 static struct ast_frame *iax_read(struct ast_channel *c)
997 struct chan_iax_pvt *pvt = c->pvt->pvt;
1000 ast_log(LOG_DEBUG, "Connection closed, error: %s\n", strerror(pvt->error));
1003 f = ast_fr_fdread(pvt->pipe[0]);
1005 if ((f->frametype == AST_FRAME_CONTROL) &&
1006 (f->subclass == AST_CONTROL_ANSWER))
1007 c->state = AST_STATE_UP;
1012 static int iax_answer(struct ast_channel *c)
1014 struct chan_iax_pvt *pvt = c->pvt->pvt;
1016 ast_log(LOG_DEBUG, "Answering\n");
1017 return send_command(pvt, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
1020 static int iax_write(struct ast_channel *c, struct ast_frame *f);
1022 static struct ast_channel *ast_iax_new(struct chan_iax_pvt *i, int state)
1024 struct ast_channel *tmp;
1025 tmp = ast_channel_alloc();
1027 snprintf(tmp->name, sizeof(tmp->name), "IAX[%s:%d]/%d", inet_ntoa(i->addr.sin_addr), ntohs(i->addr.sin_port), i->callno);
1029 tmp->fd = i->pipe[0];
1030 /* We can support any format by default, until we get restricted */
1031 tmp->format = iax_capability;
1033 tmp->pvt->send_digit = iax_digit;
1034 tmp->pvt->send_text = iax_sendtext;
1035 tmp->pvt->call = iax_call;
1036 tmp->pvt->hangup = iax_hangup;
1037 tmp->pvt->answer = iax_answer;
1038 tmp->pvt->read = iax_read;
1039 tmp->pvt->write = iax_write;
1040 if (strlen(i->callerid))
1041 tmp->callerid = strdup(i->callerid);
1042 if (strlen(i->dnid))
1043 tmp->dnid = strdup(i->dnid);
1044 strncpy(tmp->context, i->context, sizeof(tmp->context));
1045 strncpy(tmp->exten, i->exten, sizeof(tmp->exten));
1048 pthread_mutex_lock(&usecnt_lock);
1050 pthread_mutex_unlock(&usecnt_lock);
1051 ast_update_use_count();
1052 if (state != AST_STATE_DOWN) {
1053 if (ast_pbx_start(tmp)) {
1054 ast_log(LOG_WARNING, "Unable to start PBX on %s\n", tmp->name);
1063 static unsigned int calc_timestamp(struct chan_iax_pvt *p, unsigned int ts)
1067 if (!p->offset.tv_sec && !p->offset.tv_usec)
1068 gettimeofday(&p->offset, NULL);
1069 /* If the timestamp is specified, just send it as is */
1072 gettimeofday(&tv, NULL);
1073 ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
1074 /* We never send the same timestamp twice, so fudge a little if we must */
1075 if (ms <= p->lastsent)
1076 ms = p->lastsent + 1;
1081 static unsigned int calc_rxstamp(struct chan_iax_pvt *p)
1083 /* Returns where in "receive time" we are */
1086 if (!p->rxcore.tv_sec && !p->rxcore.tv_usec)
1087 gettimeofday(&p->rxcore, NULL);
1088 gettimeofday(&tv, NULL);
1089 ms = (tv.tv_sec - p->offset.tv_sec) * 1000 + (tv.tv_usec - p->offset.tv_usec) / 1000;
1092 static int iax_send(struct chan_iax_pvt *pvt, struct ast_frame *f, unsigned int ts, int seqno)
1094 /* Queue a packet for delivery on a given private structure. Use "ts" for
1095 timestamp, or calculate if ts is 0 */
1096 struct ast_iax_full_hdr *fh;
1097 struct ast_iax_mini_hdr *mh;
1098 struct ast_iax_frame *fr;
1100 unsigned int lastsent;
1101 /* Allocate an ast_iax_frame */
1102 fr = malloc(sizeof(struct ast_iax_frame));
1104 ast_log(LOG_WARNING, "Out of memory\n");
1108 ast_log(LOG_WARNING, "No private structure for packet (%d)?\n", fr->callno);
1112 /* Isolate our frame for transmission */
1113 fr->f = ast_frdup(f);
1115 ast_log(LOG_WARNING, "Out of memory\n");
1119 if (fr->f->offset < sizeof(struct ast_iax_full_hdr)) {
1120 ast_log(LOG_WARNING, "Packet from '%s' not friendly\n", fr->f->src);
1124 lastsent = pvt->lastsent;
1125 fr->ts = calc_timestamp(pvt, ts);
1127 ast_log(LOG_WARNING, "timestamp is 0?\n");
1130 fr->callno = pvt->callno;
1131 if (((fr->ts & 0xFFFF0000L) != (lastsent & 0xFFFF0000L))
1132 /* High two bits of timestamp differ */ ||
1133 (fr->f->frametype != AST_FRAME_VOICE)
1134 /* or not a voice frame */ ||
1135 (fr->f->subclass != pvt->svoiceformat)
1136 /* or new voice format */ ) {
1137 /* We need a full frame */
1141 fr->seqno = pvt->oseqno++;
1142 fh = (struct ast_iax_full_hdr *)(fr->f->data - sizeof(struct ast_iax_full_hdr));
1143 fh->callno = htons(fr->callno | AST_FLAG_FULL);
1144 fh->ts = htonl(fr->ts);
1145 fh->seqno = htons(fr->seqno);
1146 fh->type = fr->f->frametype & 0xFF;
1147 fh->csub = compress_subclass(fr->f->subclass);
1149 fh->subclasshigh = (fr->f->subclass & 0xFF0000) >> 16;
1150 fh->subclasslow = htons(fr->f->subclass & 0xFFFF);
1152 fh->dcallno = htons(pvt->peercallno);
1153 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_full_hdr);
1156 /* Retry after 2x the ping time has passed */
1157 fr->retrytime = pvt->pingtime * 2;
1158 if (fr->retrytime < MIN_RETRY_TIME)
1159 fr->retrytime = MIN_RETRY_TIME;
1160 if (fr->retrytime > MAX_RETRY_TIME)
1161 fr->retrytime = MAX_RETRY_TIME;
1162 /* Acks' don't get retried */
1163 if ((f->frametype == AST_FRAME_IAX) && (f->subclass == AST_IAX_COMMAND_ACK))
1165 if (f->frametype == AST_FRAME_VOICE) {
1166 pvt->svoiceformat = f->subclass;
1168 res = iax_transmit(fr);
1170 /* Mini-frames have no sequence number */
1172 /* Mini frame will do */
1173 mh = (struct ast_iax_mini_hdr *)(fr->f->data - sizeof(struct ast_iax_mini_hdr));
1174 mh->callno = htons(fr->callno);
1175 mh->ts = htons(fr->ts & 0xFFFF);
1176 fr->datalen = fr->f->datalen + sizeof(struct ast_iax_mini_hdr);
1179 res = iax_transmit(fr);
1186 static int iax_show_users(int fd, int argc, char *argv[])
1188 #define FORMAT "%-15.15s %-15.15s %-15.15s %-15.15s %-5.5s\n"
1189 struct iax_user *user;
1191 return RESULT_SHOWUSAGE;
1192 pthread_mutex_lock(&userl.lock);
1193 ast_cli(fd, FORMAT, "Username", "Secret", "Authen", "Def.Context", "A/C");
1194 for(user=userl.users;user;user=user->next) {
1195 ast_cli(fd, FORMAT, user->name, user->secret, user->methods,
1196 user->contexts ? user->contexts->context : context,
1197 user->ha ? "Yes" : "No");
1199 pthread_mutex_unlock(&userl.lock);
1200 return RESULT_SUCCESS;
1204 static int iax_show_peers(int fd, int argc, char *argv[])
1206 #define FORMAT2 "%-15.15s %-15.15s %-15.15s %-15.15s %s\n"
1207 #define FORMAT "%-15.15s %-15.15s %-15.15s %-15.15s %d\n"
1208 struct iax_peer *peer;
1210 return RESULT_SHOWUSAGE;
1211 pthread_mutex_lock(&peerl.lock);
1212 ast_cli(fd, FORMAT2, "Name", "Username", "Host", "Mask", "Port");
1213 for (peer = peerl.peers;peer;peer = peer->next) {
1215 strncpy(nm, inet_ntoa(peer->mask), sizeof(nm));
1216 ast_cli(fd, FORMAT, peer->name,
1217 peer->username ? peer->username : "(Any)",
1218 peer->addr.sin_addr.s_addr ? inet_ntoa(peer->addr.sin_addr) : "(Any)",
1220 ntohs(peer->addr.sin_port));
1222 pthread_mutex_unlock(&peerl.lock);
1223 return RESULT_SUCCESS;
1228 static int iax_show_channels(int fd, int argc, char *argv[])
1230 #define FORMAT2 "%-15.15s %-10.10s %-11.11s %-11.11s %-7.7s %-6.6s %s\n"
1231 #define FORMAT "%-15.15s %-10.10s %5.5d/%5.5d %5.5d/%5.5d %-5.5dms %-4.4dms %d\n"
1234 return RESULT_SHOWUSAGE;
1235 pthread_mutex_lock(&iaxs_lock);
1236 ast_cli(fd, FORMAT2, "Peer", "Username", "ID (Lo/Rem)", "Seq (Tx/Rx)", "Lag", "Jitter", "Format");
1237 for (x=0;x<AST_IAX_MAX_CALLS;x++)
1239 ast_cli(fd, FORMAT, inet_ntoa(iaxs[x]->addr.sin_addr),
1240 strlen(iaxs[x]->username) ? iaxs[x]->username : "(None)",
1241 iaxs[x]->callno, iaxs[x]->peercallno,
1242 iaxs[x]->oseqno, iaxs[x]->iseqno,
1245 iaxs[x]->voiceformat);
1246 pthread_mutex_unlock(&iaxs_lock);
1247 return RESULT_SUCCESS;
1252 static char show_users_usage[] =
1253 "Usage: iax show users\n"
1254 " Lists all users known to the IAX (Inter-Asterisk eXchange) subsystem.\n";
1256 static char show_channels_usage[] =
1257 "Usage: iax show channels\n"
1258 " Lists all currently active IAX channels.\n";
1260 static char show_peers_usage[] =
1261 "Usage: iax show peers\n"
1262 " Lists all known IAX peers.\n";
1264 static struct ast_cli_entry cli_show_users =
1265 { { "iax", "show", "users", NULL }, iax_show_users, "Show defined IAX users", show_users_usage };
1266 static struct ast_cli_entry cli_show_channels =
1267 { { "iax", "show", "channels", NULL }, iax_show_channels, "Show active IAX channels", show_channels_usage };
1268 static struct ast_cli_entry cli_show_peers =
1269 { { "iax", "show", "peers", NULL }, iax_show_peers, "Show defined IAX peers", show_peers_usage };
1271 static int iax_write(struct ast_channel *c, struct ast_frame *f)
1273 struct chan_iax_pvt *i = c->pvt->pvt;
1274 /* If there's an outstanding error, return failure now */
1276 ast_log(LOG_DEBUG, "Write error: %s\n", strerror(errno));
1279 /* Don't waste bandwidth sending null frames */
1280 if (f->frametype == AST_FRAME_NULL)
1282 /* Simple, just queue for transmission */
1283 return iax_send(i, f, 0, -1);
1286 static int send_command(struct chan_iax_pvt *i, char type, int command, unsigned int ts, char *data, int datalen, int seqno)
1290 f.subclass = command;
1291 f.datalen = datalen;
1295 f.src = __FUNCTION__;
1297 return iax_send(i, &f, ts, seqno);
1300 static int apply_context(struct iax_context *con, char *context)
1303 if (!strcmp(con->context, context))
1310 static int apply_ha(struct iax_ha *ha, struct sockaddr_in *sin)
1312 /* Start optimistic */
1313 int res = IAX_SENSE_ALLOW;
1315 /* For each rule, if this address and the netmask = the net address
1316 apply the current rule */
1317 if ((sin->sin_addr.s_addr & ha->netmask.s_addr) == (ha->netaddr.s_addr))
1324 static int check_access(int callno, struct sockaddr_in *sin, char *orequest, int requestl)
1326 /* Start pessimistic */
1330 struct iax_user *user;
1332 strncpy(request, orequest, sizeof(request));
1335 var = strtok(request, ";");
1337 value = strchr(var, '=');
1341 if (!strcmp(var, "exten"))
1342 strncpy(iaxs[callno]->exten, value, sizeof(iaxs[callno]->exten));
1343 else if (!strcmp(var, "callerid"))
1344 strncpy(iaxs[callno]->callerid, value, sizeof(iaxs[callno]->callerid));
1345 else if (!strcmp(var, "dnid"))
1346 strncpy(iaxs[callno]->dnid, value, sizeof(iaxs[callno]->dnid));
1347 else if (!strcmp(var, "context"))
1348 strncpy(iaxs[callno]->context, value, sizeof(iaxs[callno]->context));
1349 else if (!strcmp(var, "username"))
1350 strncpy(iaxs[callno]->username, value, sizeof(iaxs[callno]->username));
1351 else if (!strcmp(var, "formats"))
1352 iaxs[callno]->peerformats = atoi(value);
1353 else if (!strcmp(var, "version"))
1354 version = atoi(value);
1356 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
1358 var = strtok(NULL, ";");
1360 if (version > AST_IAX_PROTO_VERSION) {
1361 ast_log(LOG_WARNING, "Peer '%s' has too new a protocol version (%d) for me\n",
1362 inet_ntoa(sin->sin_addr), version);
1365 pthread_mutex_lock(&userl.lock);
1366 /* Search the userlist for a compatible entry, and fill in the rest */
1369 if ((!strlen(iaxs[callno]->username) || /* No username specified */
1370 !strcmp(iaxs[callno]->username, user->name)) /* Or this username specified */
1371 && (apply_ha(user->ha, sin) == IAX_SENSE_ALLOW) /* Access is permitted from this IP */
1372 && (!strlen(iaxs[callno]->context) || /* No context specified */
1373 apply_context(user->contexts, iaxs[callno]->context))) { /* Context is permitted */
1374 /* We found our match (use the first) */
1376 /* Store the requested username if not specified */
1377 if (!strlen(iaxs[callno]->username))
1378 strncpy(iaxs[callno]->username, user->name, sizeof(iaxs[callno]->username));
1379 /* And use the default context */
1380 if (!strlen(iaxs[callno]->context)) {
1382 strncpy(iaxs[callno]->context, user->contexts->context, sizeof(iaxs[callno]->context));
1384 strncpy(iaxs[callno]->context, context, sizeof(iaxs[callno]->context));
1386 /* Copy the secret */
1387 strncpy(iaxs[callno]->secret, user->secret, sizeof(iaxs[callno]->secret));
1388 /* And the permitted authentication methods */
1389 strncpy(iaxs[callno]->methods, user->methods, sizeof(iaxs[callno]->methods));
1395 pthread_mutex_unlock(&userl.lock);
1399 static int raw_hangup(struct sockaddr_in *sin, short src, short dst)
1401 struct ast_iax_full_hdr fh;
1402 fh.callno = htons(src | AST_FLAG_FULL);
1403 fh.dcallno = htons(dst);
1406 fh.type = AST_FRAME_IAX;
1407 fh.csub = compress_subclass(AST_IAX_COMMAND_INVAL);
1409 ast_log(LOG_DEBUG, "Raw Hangup\n");
1410 return sendto(netsocket, &fh, sizeof(fh), 0, sin, sizeof(*sin));
1413 static int authenticate_request(struct chan_iax_pvt *p)
1415 char requeststr[256] = "";
1416 MYSNPRINTF "methods=%s;", p->methods);
1417 if (strstr(p->methods, "md5")) {
1418 /* Build the challenge */
1420 snprintf(p->challenge, sizeof(p->challenge), "%d", rand());
1421 MYSNPRINTF "challenge=%s;", p->challenge);
1423 MYSNPRINTF "username=%s;", p->username);
1424 if (strlen(requeststr))
1425 requeststr[strlen(requeststr) - 1] = '\0';
1426 return send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREQ, 0, requeststr, strlen(requeststr) + 1, -1);
1429 static int authenticate_verify(struct chan_iax_pvt *p, char *orequest)
1431 char requeststr[256] = "";
1432 char *var, *value, request[256];
1433 char md5secret[256] = "";
1434 char secret[256] = "";
1438 if (!(p->state & IAX_STATE_AUTHENTICATED))
1440 strncpy(request, orequest, sizeof(request));
1441 var = strtok(request, ";");
1443 value = strchr(var, '=');
1447 if (!strcmp(var, "secret"))
1448 strncpy(secret, value, sizeof(secret));
1449 else if (!strcmp(var, "md5secret"))
1450 strncpy(md5secret, value, sizeof(md5secret));
1452 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
1454 var = strtok(NULL, ";");
1456 if (strstr(p->methods, "md5")) {
1457 struct MD5Context md5;
1458 unsigned char digest[16];
1460 MD5Update(&md5, p->challenge, strlen(p->challenge));
1461 MD5Update(&md5, p->secret, strlen(p->secret));
1462 MD5Final(digest, &md5);
1463 /* If they support md5, authenticate with it. */
1465 MYSNPRINTF "%2.2x", digest[x]);
1466 if (!strcasecmp(requeststr, md5secret))
1468 } else if (strstr(p->methods, "plaintext")) {
1469 if (!strcmp(secret, p->secret))
1475 static int authenticate_reply(struct chan_iax_pvt *p, struct sockaddr_in *sin, char *orequest)
1477 struct iax_peer *peer;
1478 /* Start pessimistic */
1481 char methods[80] = "";
1482 char requeststr[256] = "";
1485 strncpy(request, orequest, sizeof(request));
1486 var = strtok(request, ";");
1488 value = strchr(var, '=');
1492 if (!strcmp(var, "username"))
1493 strncpy(p->username, value, sizeof(p->username));
1494 else if (!strcmp(var, "challenge"))
1495 strncpy(p->challenge, value, sizeof(p->challenge));
1496 else if (!strcmp(var, "methods"))
1497 strncpy(methods, value, sizeof(methods));
1499 ast_log(LOG_WARNING, "Unknown variable '%s' with value '%s'\n", var, value);
1501 var = strtok(NULL, ";");
1503 pthread_mutex_lock(&peerl.lock);
1506 if ((!strlen(p->peer) || !strcmp(p->peer, peer->name))
1507 /* No peer specified at our end, or this is the peer */
1508 && (!strlen(peer->username) || (!strcmp(peer->username, p->username)))
1509 /* No username specified in peer rule, or this is the right username */
1510 && (!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)))
1511 /* No specified host, or this is our host */
1513 /* We have a match, authenticate it. */
1515 if (strstr(methods, "md5")) {
1516 struct MD5Context md5;
1517 unsigned char digest[16];
1519 MD5Update(&md5, p->challenge, strlen(p->challenge));
1520 MD5Update(&md5, peer->secret, strlen(peer->secret));
1521 MD5Final(digest, &md5);
1522 /* If they support md5, authenticate with it. */
1523 MYSNPRINTF "md5secret=");
1525 MYSNPRINTF "%2.2x", digest[x]);
1527 } else if (strstr(methods, "plaintext")) {
1528 MYSNPRINTF "secret=%s;", peer->secret);
1531 if (strlen(requeststr))
1532 requeststr[strlen(requeststr)-1] = '\0';
1534 res = send_command(p, AST_FRAME_IAX, AST_IAX_COMMAND_AUTHREP, 0, requeststr, strlen(requeststr) + 1, -1);
1539 pthread_mutex_unlock(&peerl.lock);
1543 static int socket_read(int *id, int fd, short events, void *cbdata)
1545 struct sockaddr_in sin;
1547 int new = NEW_PREVENT;
1550 int len = sizeof(sin);
1552 struct ast_iax_full_hdr *fh = (struct ast_iax_full_hdr *)buf;
1553 struct ast_iax_mini_hdr *mh = (struct ast_iax_mini_hdr *)buf;
1554 struct ast_iax_frame fr, *cur;
1556 struct ast_channel *c;
1557 res = recvfrom(netsocket, buf, sizeof(buf), 0, &sin, &len);
1559 ast_log(LOG_WARNING, "Error: %s\n", strerror(errno));
1563 if (res < sizeof(struct ast_iax_mini_hdr)) {
1564 ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, sizeof(struct ast_iax_mini_hdr));
1567 if (ntohs(mh->callno) & AST_FLAG_FULL) {
1568 /* Get the destination call number */
1569 dcallno = ntohs(fh->dcallno);
1570 /* Retrieve the type and subclass */
1571 f.frametype = fh->type;
1572 f.subclass = uncompress_subclass(fh->csub);
1574 f.subclass = fh->subclasshigh << 16;
1575 f.subclass += ntohs(fh->subclasslow);
1577 if ((f.frametype == AST_FRAME_IAX) && (f.subclass == AST_IAX_COMMAND_NEW))
1580 pthread_mutex_lock(&iaxs_lock);
1581 fr.callno = find_callno(ntohs(mh->callno) & ~AST_FLAG_FULL, dcallno, &sin, new);
1582 if ((fr.callno < 0) || !iaxs[fr.callno]) {
1583 /* A call arrived for a non-existant destination. Unless it's an "inval"
1584 frame, reply with an inval */
1585 if (ntohs(mh->callno) & AST_FLAG_FULL) {
1586 /* We can only raw hangup control frames */
1587 if ((f.subclass != AST_IAX_COMMAND_INVAL) || (f.frametype != AST_FRAME_IAX))
1588 raw_hangup(&sin, ntohs(fh->dcallno), ntohs(mh->callno));
1590 pthread_mutex_unlock(&iaxs_lock);
1593 iaxs[fr.callno]->peercallno = ntohs(mh->callno) & ~AST_FLAG_FULL;
1594 if (ntohs(mh->callno) & AST_FLAG_FULL) {
1596 ast_log(LOG_DEBUG, "Received packet %d, (%d, %d)\n", ntohs(fh->seqno), f.frametype, f.subclass);
1597 /* Check if it's out of order (and not an ACK or INVAL) */
1598 fr.seqno = ntohs(fh->seqno);
1599 if (iaxs[fr.callno]->iseqno != fr.seqno) {
1601 ((f.subclass != AST_IAX_COMMAND_ACK) && (f.subclass != AST_IAX_COMMAND_INVAL)) ||
1602 (f.frametype != AST_FRAME_IAX)) {
1603 /* If it's not an ACK packet, it's out of order. */
1605 ast_log(LOG_DEBUG, "Packet arrived out of order (expecting %d, got %d) (frametype = %d, subclass = %d)\n",
1606 iaxs[fr.callno]->iseqno, fr.seqno, f.frametype, f.subclass);
1607 if (iaxs[fr.callno]->iseqno > fr.seqno) {
1608 /* If we've already seen it, ack it XXX There's a border condition here XXX */
1609 if ((f.frametype != AST_FRAME_IAX) ||
1610 ((f.subclass != AST_IAX_COMMAND_ACK) && (f.subclass != AST_IAX_COMMAND_INVAL))) {
1612 ast_log(LOG_DEBUG, "Acking anyway\n");
1613 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACK, fr.ts, NULL, 0,fr.seqno);
1616 pthread_mutex_unlock(&iaxs_lock);
1620 /* Increment unless it's an ACK */
1621 if ((f.subclass != AST_IAX_COMMAND_ACK) ||
1622 (f.frametype != AST_FRAME_IAX))
1623 iaxs[fr.callno]->iseqno++;
1626 if (res < sizeof(struct ast_iax_full_hdr)) {
1627 ast_log(LOG_WARNING, "midget packet received (%d of %d min)\n", res, sizeof(struct ast_iax_full_hdr));
1628 pthread_mutex_unlock(&iaxs_lock);
1631 f.datalen = res - sizeof(struct ast_iax_full_hdr);
1633 f.data = buf + sizeof(struct ast_iax_full_hdr);
1636 fr.ts = ntohl(fh->ts);
1637 /* Unless this is an ACK or INVAL frame, ack it */
1638 if ((f.frametype != AST_FRAME_IAX) ||
1639 ((f.subclass != AST_IAX_COMMAND_ACK) && (f.subclass != AST_IAX_COMMAND_INVAL)))
1640 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACK, fr.ts, NULL, 0,fr.seqno);
1641 if (f.frametype == AST_FRAME_VOICE)
1642 iaxs[fr.callno]->voiceformat = f.subclass;
1643 if (f.frametype == AST_FRAME_IAX) {
1644 /* Handle the IAX pseudo frame itself */
1646 ast_log(LOG_DEBUG, "IAX subclass %d received\n", f.subclass);
1647 switch(f.subclass) {
1648 case AST_IAX_COMMAND_ACK:
1649 /* Ack the packet with the given timestamp */
1650 pthread_mutex_lock(&iaxq.lock);
1651 for (cur = iaxq.head; cur ; cur = cur->next) {
1652 /* If it's our call, and our timestamp, mark -1 retries */
1653 if ((fr.callno == cur->callno) && (fr.seqno == cur->seqno))
1656 pthread_mutex_unlock(&iaxq.lock);
1658 case AST_IAX_COMMAND_NEW:
1659 ((char *)f.data)[f.datalen] = '\0';
1660 if (check_access(fr.callno, &sin, f.data, f.datalen)) {
1661 /* They're not allowed on */
1662 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_REJECT, 0, "No authority found", strlen("No authority found"), -1);
1663 ast_log(LOG_NOTICE, "Rejected connect attempt from %s, request '%s'\n", inet_ntoa(sin.sin_addr), f.data);
1664 /* XXX Not guaranteed to work, but probably does XXX */
1665 pthread_mutex_lock(&iaxq.lock);
1666 send_packet(iaxq.tail);
1667 pthread_mutex_unlock(&iaxq.lock);
1668 iax_destroy(fr.callno);
1671 if (!strlen(iaxs[fr.callno]->secret)) {
1672 /* No authentication required, let them in */
1673 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACCEPT, 0, NULL, 0, -1);
1674 iaxs[fr.callno]->state |= IAX_STATE_STARTED;
1675 if(!(c = ast_iax_new(iaxs[fr.callno], AST_STATE_RING)))
1676 iax_destroy(fr.callno);
1678 c->format = iaxs[fr.callno]->peerformats;
1681 authenticate_request(iaxs[fr.callno]);
1682 iaxs[fr.callno]->state |= IAX_STATE_AUTHENTICATED;
1684 case AST_IAX_COMMAND_HANGUP:
1686 iaxs[fr.callno]->error = ENOTCONN;
1688 iax_destroy(fr.callno);
1690 case AST_IAX_COMMAND_REJECT:
1691 ((char *)f.data)[f.datalen] = '\0';
1692 ast_log(LOG_WARNING, "Call rejected by %s: %s\n", inet_ntoa(iaxs[fr.callno]->addr.sin_addr), f.data);
1693 iaxs[fr.callno]->error = EPERM;
1694 iax_destroy(fr.callno);
1696 case AST_IAX_COMMAND_ACCEPT:
1697 if (option_verbose > 2)
1698 ast_verbose(VERBOSE_PREFIX_3 "Call accepted by %s\n", inet_ntoa(iaxs[fr.callno]->addr.sin_addr));
1699 iaxs[fr.callno]->state |= IAX_STATE_STARTED;
1701 case AST_IAX_COMMAND_PING:
1702 /* Send back a pong packet with the original timestamp */
1703 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_PONG, fr.ts, NULL, 0, -1);
1705 case AST_IAX_COMMAND_PONG:
1706 iaxs[fr.callno]->pingtime = calc_timestamp(iaxs[fr.callno], 0) - fr.ts;
1708 case AST_IAX_COMMAND_LAGRQ:
1709 case AST_IAX_COMMAND_LAGRP:
1710 /* A little strange -- We have to actually go through the motions of
1711 delivering the packet. In the very last step, it will be properly
1712 handled by do_deliver */
1713 snprintf(src, sizeof(src), "LAGRQ-IAX/%s/%d", inet_ntoa(sin.sin_addr),fr.callno);
1719 schedule_delivery(iaxfrdup2(&fr, 0));
1721 case AST_IAX_COMMAND_AUTHREQ:
1722 ((char *)f.data)[f.datalen] = '\0';
1723 if (authenticate_reply(iaxs[fr.callno], &iaxs[fr.callno]->addr, (char *)f.data)) {
1724 ast_log(LOG_WARNING,
1725 "I don't know how to authenticate %s to %s\n",
1726 f.data, inet_ntoa(iaxs[fr.callno]->addr.sin_addr));
1727 iax_destroy(fr.callno);
1730 case AST_IAX_COMMAND_AUTHREP:
1731 ((char *)f.data)[f.datalen] = '\0';
1732 if (authenticate_verify(iaxs[fr.callno], (char *)f.data)) {
1733 ast_log(LOG_NOTICE, "Host %s failed to authenticate as %s\n", inet_ntoa(iaxs[fr.callno]->addr.sin_addr), iaxs[fr.callno]->username);
1734 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_REJECT, 0, "No authority found", strlen("No authority found"), -1);
1735 /* XXX Not guaranteed to work, but probably does XXX */
1736 pthread_mutex_lock(&iaxq.lock);
1737 send_packet(iaxq.tail);
1738 pthread_mutex_unlock(&iaxq.lock);
1739 iax_destroy(fr.callno);
1742 /* Authentication is fine, go ahead */
1743 send_command(iaxs[fr.callno], AST_FRAME_IAX, AST_IAX_COMMAND_ACCEPT, 0, NULL, 0, -1);
1744 iaxs[fr.callno]->state |= IAX_STATE_STARTED;
1745 if(!(c = ast_iax_new(iaxs[fr.callno], AST_STATE_RING)))
1746 iax_destroy(fr.callno);
1748 c->format = iaxs[fr.callno]->peerformats;
1750 case AST_IAX_COMMAND_INVAL:
1751 iaxs[fr.callno]->error = ENOTCONN;
1752 iax_destroy(fr.callno);
1754 ast_log(LOG_DEBUG, "Destroying call %d\n", fr.callno);
1757 ast_log(LOG_DEBUG, "Unknown IAX command %d on %d/%d\n", f.subclass, fr.callno, iaxs[fr.callno]->peercallno);
1759 /* Don't actually pass these frames along */
1760 pthread_mutex_unlock(&iaxs_lock);
1765 f.frametype = AST_FRAME_VOICE;
1766 if (iaxs[fr.callno]->voiceformat > 0)
1767 f.subclass = iaxs[fr.callno]->voiceformat;
1769 ast_log(LOG_WARNING, "Received mini frame before first full voice frame\n ");
1770 pthread_mutex_unlock(&iaxs_lock);
1773 f.datalen = res - sizeof(struct ast_iax_mini_hdr);
1774 if (f.datalen < 0) {
1775 ast_log(LOG_WARNING, "Datalen < 0?\n");
1776 pthread_mutex_unlock(&iaxs_lock);
1780 f.data = buf + sizeof(struct ast_iax_mini_hdr);
1783 fr.ts = (iaxs[fr.callno]->last & 0xFFFF0000L) | ntohs(mh->ts);
1785 /* Don't pass any packets until we're started */
1786 if (!(iaxs[fr.callno]->state & IAX_STATE_STARTED)) {
1787 pthread_mutex_unlock(&iaxs_lock);
1791 snprintf(src, sizeof(src), "IAX/%s/%d", inet_ntoa(sin.sin_addr),fr.callno);
1796 if (f.datalen && (f.frametype == AST_FRAME_VOICE))
1797 f.timelen = get_timelen(&f);
1801 /* If this is our most recent packet, use it as our basis for timestamping */
1802 if (iaxs[fr.callno]->last < fr.ts) {
1803 iaxs[fr.callno]->last = fr.ts;
1806 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);
1809 schedule_delivery(iaxfrdup2(&fr, 0));
1810 /* Always run again */
1811 pthread_mutex_unlock(&iaxs_lock);
1815 static void free_ha(struct iax_ha *ha)
1825 static void free_context(struct iax_context *con)
1827 struct iax_context *conl;
1835 static struct ast_channel *iax_request(char *type, int format, void *data)
1838 struct sockaddr_in sin;
1841 struct ast_channel *c;
1842 strncpy(s, (char *)data, sizeof(s));
1845 st = strtok(NULL, "@");
1848 /* Populate our address from the given */
1849 if (create_addr(&sin, st)) {
1850 ast_log(LOG_WARNING, "Unable to assign address\n");
1853 pthread_mutex_lock(&iaxs_lock);
1854 callno = find_callno(-1, -1, &sin, NEW_FORCE);
1856 ast_log(LOG_WARNING, "Unable to create call\n");
1859 c = ast_iax_new(iaxs[callno], AST_STATE_DOWN);
1861 /* Choose a format we can live with */
1862 if (c->format & format)
1863 c->format &= format;
1865 c->format = ast_translator_best_choice(format, c->format);
1867 pthread_mutex_unlock(&iaxs_lock);
1871 static void *network_thread(void *ignore)
1873 /* Our job is simple: Send queued messages, retrying if necessary. Read frames
1874 from the network, and queue them for delivery to the channels */
1876 struct ast_iax_frame *f, *freeme;
1877 /* Establish I/O callback for socket read */
1878 ast_io_add(io, netsocket, socket_read, AST_IO_IN, NULL);
1879 pthread_mutex_lock(&iaxs_lock);
1881 /* Go through the queue, sending messages which have not yet been
1882 sent, and scheduling retransmissions if appropriate */
1883 pthread_mutex_lock(&iaxq.lock);
1889 /* Send a copy immediately */
1890 if (iaxs[f->callno]) {
1893 if (f->retries < 0) {
1894 /* This is not supposed to be retransmitted */
1896 f->prev->next = f->next;
1898 iaxq.head = f->next;
1900 f->next->prev = f->prev;
1902 iaxq.tail = f->prev;
1904 /* Free the frame */
1906 /* Free the iax frame */
1909 /* We need reliable delivery. Schedule a retransmission */
1911 ast_sched_add(sched, f->retrytime, attempt_transmit, f);
1918 pthread_mutex_unlock(&iaxq.lock);
1919 pthread_mutex_unlock(&iaxs_lock);
1920 res = ast_sched_wait(sched);
1921 res = ast_io_wait(io, res);
1922 pthread_mutex_lock(&iaxs_lock);
1924 ast_sched_runq(sched);
1929 static int start_network_thread()
1931 return pthread_create(&netthreadid, NULL, network_thread, NULL);
1934 static struct iax_context *build_context(char *context)
1936 struct iax_context *con = malloc(sizeof(struct iax_context));
1938 strncpy(con->context, context, sizeof(con->context));
1944 static struct iax_ha *build_ha(char *sense, char *stuff)
1946 struct iax_ha *ha = malloc(sizeof(struct iax_ha));
1950 nm = strtok(NULL, "/");
1952 nm = "255.255.255.255";
1953 if (!inet_aton(stuff, &ha->netaddr)) {
1954 ast_log(LOG_WARNING, "%s not a valid IP\n", stuff);
1958 if (!inet_aton(nm, &ha->netmask)) {
1959 ast_log(LOG_WARNING, "%s not a valid netmask\n", nm);
1963 ha->netaddr.s_addr &= ha->netmask.s_addr;
1964 if (!strcasecmp(sense, "a")) {
1965 ha->sense = IAX_SENSE_ALLOW;
1967 ha->sense = IAX_SENSE_DENY;
1974 static struct iax_peer *build_peer(char *name, struct ast_variable *v)
1976 struct iax_peer *peer;
1979 peer = malloc(sizeof(struct iax_peer));
1981 memset(peer, 0, sizeof(struct iax_peer));
1982 strncpy(peer->name, name, sizeof(peer->name));
1983 peer->addr.sin_port = htons(AST_DEFAULT_IAX_PORTNO);
1985 if (!strcasecmp(v->name, "secret"))
1986 strncpy(peer->secret, v->value, sizeof(peer->secret));
1987 else if (!strcasecmp(v->name, "host")) {
1988 hp = gethostbyname(v->value);
1990 memcpy(&peer->addr.sin_addr, hp->h_addr, sizeof(peer->addr.sin_addr));
1992 ast_log(LOG_WARNING, "Unable to lookup '%s'\n", v->value);
1997 inet_aton("255.255.255.255", &peer->mask);
1999 else if (!strcasecmp(v->name, "mask")) {
2001 inet_aton(v->value, &peer->mask);
2002 } else if (!strcasecmp(v->name, "port"))
2003 peer->addr.sin_port = htons(atoi(v->value));
2004 else if (!strcasecmp(v->name, "username"))
2005 strncpy(peer->username, v->value, sizeof(peer->username));
2012 static struct iax_user *build_user(char *name, struct ast_variable *v)
2014 struct iax_user *user;
2015 struct iax_context *con, *conl = NULL;
2016 struct iax_ha *ha, *hal = NULL;
2017 user = (struct iax_user *)malloc(sizeof(struct iax_user));
2019 memset(user, 0, sizeof(struct iax_user));
2020 strncpy(user->name, name, sizeof(user->name));
2022 if (!strcasecmp(v->name, "context")) {
2023 con = build_context(v->value);
2028 user->contexts = con;
2031 } else if (!strcasecmp(v->name, "allow") ||
2032 !strcasecmp(v->name, "deny")) {
2033 ha = build_ha(v->name, v->value);
2041 } else if (!strcasecmp(v->name, "auth")) {
2042 strncpy(user->methods, v->value, sizeof(user->methods));
2043 } else if (!strcasecmp(v->name, "secret")) {
2044 strncpy(user->secret, v->value, sizeof(user->secret));
2055 struct ast_config *cfg;
2056 struct ast_variable *v;
2057 struct iax_user *user;
2058 struct iax_peer *peer;
2063 struct sockaddr_in sin;
2065 sin.sin_family = AF_INET;
2066 sin.sin_port = ntohs(AST_DEFAULT_IAX_PORTNO);
2067 sin.sin_addr.s_addr = INADDR_ANY;
2069 io = io_context_create();
2070 sched = sched_context_create();
2072 if (!io || !sched) {
2073 ast_log(LOG_ERROR, "Out of memory\n");
2077 pthread_mutex_init(&iaxq.lock, NULL);
2078 pthread_mutex_init(&userl.lock, NULL);
2080 ast_cli_register(&cli_show_users);
2081 ast_cli_register(&cli_show_channels);
2082 ast_cli_register(&cli_show_peers);
2083 ast_cli_register(&cli_set_jitter);
2084 #ifdef IAX_SIMULATOR
2085 ast_cli_register(&delay_cli);
2086 ast_cli_register(&deviation_cli);
2087 ast_cli_register(&reliability_cli);
2088 ast_cli_register(&sim_show_cli);
2090 cfg = ast_load(config);
2093 ast_log(LOG_ERROR, "Unable to load config %s\n", config);
2096 v = ast_variable_browse(cfg, "general");
2098 if (!strcasecmp(v->name, "port"))
2099 sin.sin_port = ntohs(atoi(v->value));
2100 else if (!strcasecmp(v->name, "pingtime"))
2101 ping_time = atoi(v->value);
2102 else if (!strcasecmp(v->name, "maxjitterbuffer"))
2103 maxjitterbuffer = atoi(v->value);
2104 else if (!strcasecmp(v->name, "maxexcessbuffer"))
2105 max_jitter_buffer = atoi(v->value);
2106 else if (!strcasecmp(v->name, "lagrqtime"))
2107 lagrq_time = atoi(v->value);
2108 else if (!strcasecmp(v->name, "dropcount"))
2109 iax_dropcount = atoi(v->value);
2110 else if (!strcasecmp(v->name, "bindaddr"))
2111 inet_aton(v->value, &sin.sin_addr);
2112 else if (!strcasecmp(v->name, "jitterbuffer"))
2113 use_jitterbuffer = ast_true(v->value);
2114 else if (!strcasecmp(v->name, "bandwidth")) {
2115 if (!strcasecmp(v->value, "low")) {
2116 iax_capability = IAX_CAPABILITY_LOWBANDWIDTH;
2117 } else if (!strcasecmp(v->value, "medium")) {
2118 iax_capability = IAX_CAPABILITY_MEDBANDWIDTH;
2119 } else if (!strcasecmp(v->value, "high")) {
2120 iax_capability = IAX_CAPABILITY_FULLBANDWIDTH;
2122 ast_log(LOG_WARNING, "bandwidth must be either low, medium, or high\n");
2123 } else if (!strcasecmp(v->name, "allow")) {
2124 format = ast_getformatbyname(v->value);
2126 ast_log(LOG_WARNING, "Cannot allow unknown format '%s'\n", v->value);
2128 iax_capability |= format;
2129 } else if (!strcasecmp(v->name, "disallow")) {
2130 format = ast_getformatbyname(v->value);
2132 ast_log(LOG_WARNING, "Cannot disallow unknown format '%s'\n", v->value);
2134 iax_capability &= ~format;
2138 cat = ast_category_browse(cfg, NULL);
2140 if (strcasecmp(cat, "general")) {
2141 utype = ast_variable_retrieve(cfg, cat, "type");
2143 if (!strcasecmp(utype, "user")) {
2144 user = build_user(cat, ast_variable_browse(cfg, cat));
2146 pthread_mutex_lock(&userl.lock);
2147 user->next = userl.users;
2149 pthread_mutex_unlock(&userl.lock);
2151 } else if (!strcasecmp(utype, "peer")) {
2152 peer = build_peer(cat, ast_variable_browse(cfg, cat));
2154 pthread_mutex_lock(&peerl.lock);
2155 peer->next = peerl.peers;
2157 pthread_mutex_unlock(&peerl.lock);
2160 ast_log(LOG_WARNING, "Unknown type '%s' for '%s' in %s\n", utype, cat, config);
2163 ast_log(LOG_WARNING, "Section '%s' lacks type\n", cat);
2165 cat = ast_category_browse(cfg, cat);
2168 if (ast_channel_register(type, tdesc, iax_capability, iax_request)) {
2169 ast_log(LOG_ERROR, "Unable to register channel class %s\n", type);
2174 /* Make a UDP socket */
2175 netsocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
2177 if (netsocket < 0) {
2178 ast_log(LOG_ERROR, "Unable to create network socket: %s\n", strerror(errno));
2181 if (bind(netsocket, &sin, sizeof(sin))) {
2182 ast_log(LOG_ERROR, "Unable to bind to %s port %d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
2187 res = start_network_thread();
2188 if (option_verbose > 1)
2189 ast_verbose(VERBOSE_PREFIX_2 "IAX Ready and Listening on %s port %d\n", inet_ntoa(sin.sin_addr), ntohs(sin.sin_port));
2191 ast_log(LOG_ERROR, "Unable to start network thread\n");
2204 struct iax_user *user, *userlast;
2205 struct iax_peer *peer, *peerlast;
2207 /* Cancel the network thread, close the net socket */
2208 pthread_cancel(netthreadid);
2209 pthread_join(netthreadid, NULL);
2211 for (x=0;x<AST_IAX_MAX_CALLS;x++)
2214 ast_cli_unregister(&cli_show_users);
2215 ast_cli_unregister(&cli_show_channels);
2216 ast_cli_unregister(&cli_show_peers);
2217 ast_cli_unregister(&cli_set_jitter);
2218 #ifdef IAX_SIMULATOR
2219 ast_cli_unregister(&delay_cli);
2220 ast_cli_unregister(&deviation_cli);
2221 ast_cli_unregister(&reliability_cli);
2222 ast_cli_unregister(&sim_show_cli);
2224 for (user=userl.users;user;) {
2226 free_context(user->contexts);
2231 for (peer=peerl.peers;peer;) {
2242 pthread_mutex_lock(&usecnt_lock);
2244 pthread_mutex_unlock(&usecnt_lock);