1 /*
2 * libiax: An implementation of Inter-Asterisk eXchange
3 *
4 * Copyright (C) 2001, Linux Support Services, Inc.
5 *
6 * Mark Spencer <markster@linux-support.net>
7 * Frik Strecker <frik@gatherworks.com>
8 *
9 * This program is free software, distributed under the terms of
10 * the GNU Lesser (Library) General Public License
11 */
12
13 #ifdef HAVE_CONFIG_H
14 #include "config.h"
15 #endif
16
17 #if defined(WIN32) || defined(_WIN32_WCE)
18 #undef __STRICT_ANSI__ //for strdup with ms
19 #include "winpoop.h"
20 #if defined(_WIN32_WCE)
21 #define strdup _strdup
22 #else
23 #include <process.h>
24 #include <fcntl.h>
25 #include <io.h>
26 #include <errno.h>
27 #endif
28 #include <string.h>
29 #include <time.h>
30 #include <stdlib.h>
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include <limits.h>
34
35 #if !defined(_WIN32_WCE)
36 #include <sys/timeb.h>
37 #endif
38
39 #define snprintf _snprintf
40
41 #if defined(_MSC_VER)
42 #define close closesocket
43 #if !defined(_WIN32_WCE)
44 #define inline __inline
45 #endif
46 #endif
47
48 #else // !#if defined(WIN32) || defined(_WIN32_WCE)
49 #include <netdb.h>
50 #include <sys/socket.h>
51 #include <netinet/in.h>
52 #include <sys/time.h> // gettimeofday
53 #ifndef HAVE_GETTIMEOFDAY
54 #define HAVE_GETTIMEOFDAY 1
55 #endif
56 #include <stdlib.h>
57
58 #ifdef __GNUC__
59 #ifndef __USE_SVID
60 #define __USE_SVID
61 #endif
62 #endif
63
64 #include <string.h>
65 #include <stdarg.h>
66 #include <stdio.h>
67 #include <unistd.h>
68 #include <fcntl.h>
69 #include <errno.h>
70 #include <sys/select.h>
71 #include <netinet/in.h>
72 #include <arpa/inet.h>
73 #include <time.h>
74
75 // FlightGear: Modified to include FreeBSD
76 #if !defined(MACOSX) && !defined(__OpenBSD__) && !defined(__FreeBSD__)
77 #include <malloc.h>
78 #if !defined(SOLARIS)
79 #include <error.h>
80 #endif
81 #endif
82
83 #endif // #if defined(WIN32) || defined(_WIN32_WCE) yes or no
84
85 #ifndef _MSC_VER
86 #endif
87
88 #include "jitterbuf.h"
89 #include "iax-client.h"
90 #include "md5.h"
91
92 /* Define socket options for IAX2 sockets, based on platform
93 * availability of flags */
94 #if defined(WIN32) || defined(_WIN32_WCE)
95 #define IAX_SOCKOPTS 0
96 #else
97 #ifdef MACOSX
98 #define IAX_SOCKOPTS MSG_DONTWAIT
99 #else
100 #if defined(SOLARIS) || defined(__OpenBSD__)
101 #define IAX_SOCKOPTS MSG_DONTWAIT
102 #else /* Linux and others */
103 #define IAX_SOCKOPTS MSG_DONTWAIT | MSG_NOSIGNAL
104 #endif
105 #endif
106 #endif
107
108
109 #ifdef SNOM_HACK
110 /* The snom phone seems to improperly execute memset in some cases */
111 #include "../../snom_phonecore2/include/snom_memset.h"
112 #endif
113
114 /* Voice TS Prediction causes libiax2 to clean up the timestamps on
115 * outgoing frames. It works best with either continuous voice, or
116 * callers who call iax_send_cng to indicate DTX for silence */
117 #define USE_VOICE_TS_PREDICTION
118
119 #define MIN_RETRY_TIME 10
120 #define MAX_RETRY_TIME 4000
121 #define MEMORY_SIZE 1000
122
123 #define TRANSFER_NONE 0
124 #define TRANSFER_BEGIN 1
125 #define TRANSFER_READY 2
126 #define TRANSFER_REL 3
127
128 /* Video frames bypass jitterbuffer */
129 static int video_bypass_jitterbuffer = 0;
130
131 /* To use or not to use the jitterbuffer */
132 static int iax_use_jitterbuffer = 1;
133
134 /* UDP Socket (file descriptor) */
135 static int netfd = -1;
136
137 /* Max timeouts */
138 static const int maxretries = 10;
139
140 /* configurable jitterbuffer options */
141 static long jb_target_extra = -1;
142
143 /* external global networking replacements */
144 static iax_sendto_t iax_sendto = (iax_sendto_t) sendto;
145 static iax_recvfrom_t iax_recvfrom = (iax_recvfrom_t) recvfrom;
146
147 /* ping interval (seconds) */
148 static int ping_time = 10;
149 static void send_ping(void *session);
150
151 struct iax_session {
152 /* Private data */
153 void *pvt;
154 /* session-local Sendto function */
155 iax_sendto_t sendto;
156 /* Is voice quelched (e.g. hold) */
157 int quelch;
158 /* Codec Pref Order */
159 char codec_order[32];
160 /* Codec Pref Order Index*/
161 int codec_order_len;
162 /* Last received voice format */
163 int voiceformat;
164 /* Last transmitted voice format */
165 int svoiceformat;
166 /* Last received video format */
167 int videoformat;
168 /* Last transmitted video format */
169 int svideoformat;
170 /* Per session capability */
171 int capability;
172 /* Last received timestamp */
173 unsigned int last_ts;
174 /* Last transmitted timestamp */
175 unsigned int lastsent;
176 /* Timestamp of the last transmitted video frame */
177 unsigned int lastvsent;
178 #ifdef USE_VOICE_TS_PREDICTION
179 /* Next predicted voice ts */
180 unsigned int nextpred;
181 /* True if the last voice we transmitted was not silence/CNG */
182 int notsilenttx;
183 #endif
184 /* Our last measured ping time */
185 unsigned int pingtime;
186 /* Address of peer */
187 struct sockaddr_in peeraddr;
188 /* Our call number */
189 int callno;
190 /* Peer's call number */
191 int peercallno;
192 /* Our next outgoing sequence number */
193 unsigned char oseqno;
194 /* Next sequence number they have not yet acknowledged */
195 unsigned char rseqno;
196 /* Our last received incoming sequence number */
197 unsigned char iseqno;
198 /* Last acknowledged sequence number */
199 unsigned char aseqno;
200 /* Last sequence number we VNAKd */
201 unsigned char lastvnak;
202 /* Time value that we base our transmission on */
203 struct timeval offset;
204 /* Time value we base our delivery on */
205 struct timeval rxcore;
206 /* Current link state */
207 int state;
208 /* Unregister reason */
209 char unregreason[MAXSTRLEN];
210 /* Expected Username */
211 char username[MAXSTRLEN];
212 /* Expected Secret */
213 char secret[MAXSTRLEN];
214 /* Refresh if applicable */
215 int refresh;
216
217 /* ping scheduler id */
218 int pingid;
219
220 /* Transfer stuff */
221 struct sockaddr_in transfer;
222 int transferring;
223 int transfercallno;
224 int transferid;
225 int transferpeer; /* for attended transfer */
226 int transfer_moh; /* for music on hold while performing attended transfer */
227
228 jitterbuf *jb;
229
230 struct iax_netstat remote_netstats;
231
232 /* For linking if there are multiple connections */
233 struct iax_session *next;
234 };
235
236 char iax_errstr[256];
237
238
239 #define IAXERROR snprintf(iax_errstr, sizeof(iax_errstr),
240
241 #ifdef DEBUG_SUPPORT
242
243 #ifdef DEBUG_DEFAULT
244 static int debug = 1;
245 #else
246 static int debug = 0;
247 #endif
248
iax_enable_debug(void)249 void iax_enable_debug(void)
250 {
251 debug = 1;
252 }
253
iax_disable_debug(void)254 void iax_disable_debug(void)
255 {
256 debug = 0;
257 }
258
iax_enable_jitterbuffer(void)259 void iax_enable_jitterbuffer(void)
260 {
261 iax_use_jitterbuffer = 1;
262 }
263
iax_disable_jitterbuffer(void)264 void iax_disable_jitterbuffer(void)
265 {
266 iax_use_jitterbuffer = 0;
267 }
268
iax_set_private(struct iax_session * s,void * ptr)269 void iax_set_private(struct iax_session *s, void *ptr)
270 {
271 s->pvt = ptr;
272 }
273
iax_get_private(struct iax_session * s)274 void *iax_get_private(struct iax_session *s)
275 {
276 return s->pvt;
277 }
278
iax_set_sendto(struct iax_session * s,iax_sendto_t ptr)279 void iax_set_sendto(struct iax_session *s, iax_sendto_t ptr)
280 {
281 s->sendto = ptr;
282 }
283
284 /* This is a little strange, but to debug you call DEBU(G "Hello World!\n"); */
285 #if defined(WIN32) || defined(_WIN32_WCE)
286 #define G __FILE__, __LINE__,
287 #else
288 #define G __FILE__, __LINE__, __PRETTY_FUNCTION__,
289 #endif
290
291 #define DEBU __debug
292 #if defined(WIN32) || defined(_WIN32_WCE)
__debug(const char * file,int lineno,const char * fmt,...)293 static int __debug(const char *file, int lineno, const char *fmt, ...)
294 {
295 va_list args;
296 va_start(args, fmt);
297 if (debug) {
298 fprintf(stderr, "%s line %d: ", file, lineno);
299 vfprintf(stderr, fmt, args);
300 }
301 va_end(args);
302 return 0;
303 }
304 #else
__debug(const char * file,int lineno,const char * func,const char * fmt,...)305 static int __debug(const char *file, int lineno, const char *func, const char *fmt, ...)
306 {
307 va_list args;
308 va_start(args, fmt);
309 if (debug) {
310 fprintf(stderr, "%s line %d in %s: ", file, lineno, func);
311 vfprintf(stderr, fmt, args);
312 }
313 va_end(args);
314 return 0;
315 }
316 #endif
317 #else /* No debug support */
318
319 #if defined(WIN32) || defined(_WIN32_WCE)
320 #define DEBU
321 #else
322 #define DEBU(fmt...) \
323 do {} while(0)
324 #endif
325 #define G
326 #endif
327
iax_seed_random()328 void iax_seed_random()
329 {
330 #if defined(HAVE_SRANDOMDEV)
331 srandomdev();
332 #elif defined(HAVE_SRANDOM)
333 srandom((unsigned int)time(0));
334 #elif defined(HAVE_SRAND48)
335 srand48((long int)time(0));
336 #else
337 srand((unsigned int)time(0));
338 #endif
339 }
340
iax_random()341 int iax_random()
342 {
343 #if defined(HAVE_RANDOM)
344 return (int)random();
345 #elif defined(HAVE_LRAND48)
346 return (int)lrand48();
347 #else
348 return rand();
349 #endif
350 }
351
352 typedef void (*sched_func)(void *);
353
354 struct iax_sched {
355 /* These are scheduled things to be delivered */
356 struct timeval when;
357 /* If event is non-NULL then we're delivering an event */
358 struct iax_event *event;
359 /* If frame is non-NULL then we're transmitting a frame */
360 struct iax_frame *frame;
361 /* If func is non-NULL then we should call it */
362 sched_func func;
363 /* and pass it this argument */
364 void *arg;
365 /* Easy linking */
366 struct iax_sched *next;
367 };
368
369 static struct iax_sched *schedq = NULL;
370 static struct iax_session *sessions = NULL;
371 static int callnums = 1;
372
iax_session_get_capability(struct iax_session * s)373 unsigned int iax_session_get_capability(struct iax_session *s)
374 {
375 return s->capability;
376 }
377
inaddrcmp(struct sockaddr_in * sin1,struct sockaddr_in * sin2)378 static int inaddrcmp(struct sockaddr_in *sin1, struct sockaddr_in *sin2)
379 {
380 return (sin1->sin_addr.s_addr != sin2->sin_addr.s_addr) || (sin1->sin_port != sin2->sin_port);
381 }
382
iax_sched_add(struct iax_event * event,struct iax_frame * frame,sched_func func,void * arg,int ms)383 static int iax_sched_add(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, int ms)
384 {
385
386 /* Schedule event to be delivered to the client
387 in ms milliseconds from now, or a reliable frame to be retransmitted */
388 struct iax_sched *sched, *cur, *prev = NULL;
389
390 if (!event && !frame && !func) {
391 DEBU(G "No event, no frame, no func? what are we scheduling?\n");
392 return -1;
393 }
394
395 //fprintf(stderr, "scheduling event %d ms from now\n", ms);
396 sched = (struct iax_sched*)malloc(sizeof(struct iax_sched));
397 if (sched) {
398 memset(sched, 0, sizeof(struct iax_sched));
399 sched->when = iax_tvnow();
400 sched->when.tv_sec += (ms / 1000);
401 ms = ms % 1000;
402 sched->when.tv_usec += (ms * 1000);
403 if (sched->when.tv_usec > 1000000) {
404 sched->when.tv_usec -= 1000000;
405 sched->when.tv_sec++;
406 }
407 sched->event = event;
408 sched->frame = frame;
409 sched->func = func;
410 sched->arg = arg;
411 /* Put it in the list, in order */
412 cur = schedq;
413 while(cur && ((cur->when.tv_sec < sched->when.tv_sec) ||
414 ((cur->when.tv_usec <= sched->when.tv_usec) &&
415 (cur->when.tv_sec == sched->when.tv_sec)))) {
416 prev = cur;
417 cur = cur->next;
418 }
419 sched->next = cur;
420 if (prev) {
421 prev->next = sched;
422 } else {
423 schedq = sched;
424 }
425 return 0;
426 } else {
427 DEBU(G "Out of memory!\n");
428 return -1;
429 }
430 }
431
iax_sched_del(struct iax_event * event,struct iax_frame * frame,sched_func func,void * arg,int all)432 static int iax_sched_del(struct iax_event *event, struct iax_frame *frame, sched_func func, void *arg, int all)
433 {
434 struct iax_sched *cur, *tmp, *prev = NULL;
435
436 cur = schedq;
437 while (cur) {
438 if (cur->event == event && cur->frame == frame && cur->func == func && cur->arg == arg) {
439 if (prev)
440 prev->next = cur->next;
441 else
442 schedq = cur->next;
443 tmp = cur;
444 cur = cur->next;
445 free(tmp);
446 if (!all)
447 return -1;
448 } else {
449 prev = cur;
450 cur = cur->next;
451 }
452 }
453 return 0;
454 }
455
456
iax_time_to_next_event(void)457 int iax_time_to_next_event(void)
458 {
459 struct timeval tv;
460 struct iax_sched *cur = schedq;
461 int ms, min = 999999999;
462
463 /* If there are no pending events, we don't need to timeout */
464 if (!cur)
465 return -1;
466 tv = iax_tvnow();
467 while(cur) {
468 ms = (cur->when.tv_sec - tv.tv_sec) * 1000 +
469 (cur->when.tv_usec - tv.tv_usec) / 1000;
470 if (ms < min)
471 min = ms;
472 cur = cur->next;
473 }
474 if (min < 0)
475 min = 0;
476 return min;
477 }
478
iax_session_new(void)479 struct iax_session *iax_session_new(void)
480 {
481 struct iax_session *s;
482 s = calloc(1, sizeof(struct iax_session));
483 if (s) {
484 jb_conf jbconf;
485
486 /* Initialize important fields */
487 s->voiceformat = -1;
488 s->svoiceformat = -1;
489 s->videoformat = -1;
490 /* Default pingtime to 100 ms -- should cover most decent net connections */
491 s->pingtime = 100;
492 /* XXX Not quite right -- make sure it's not in use, but that won't matter
493 unless you've had at least 65k calls. XXX */
494 s->callno = callnums++;
495 if (callnums > 32767)
496 callnums = 1;
497 s->peercallno = 0;
498 s->lastvnak = -1;
499 s->transferpeer = 0; /* for attended transfer */
500 s->next = sessions;
501 s->sendto = iax_sendto;
502 s->pingid = -1;
503
504 #ifdef USE_VOICE_TS_PREDICTION
505 s->nextpred = 0;
506 #endif
507
508 s->jb = jb_new();
509 if ( !s->jb )
510 {
511 free(s);
512 return 0;
513 }
514 jbconf.max_jitterbuf = 0;
515 jbconf.resync_threshold = 1000;
516 jbconf.max_contig_interp = 0;
517 jbconf.target_extra = jb_target_extra;
518 jb_setconf(s->jb, &jbconf);
519
520 sessions = s;
521 }
522 return s;
523 }
524
iax_session_valid(struct iax_session * session)525 static int iax_session_valid(struct iax_session *session)
526 {
527 /* Return -1 on a valid iax session pointer, 0 on a failure */
528 struct iax_session *cur = sessions;
529 while(cur) {
530 if (session == cur)
531 return -1;
532 cur = cur->next;
533 }
534 return 0;
535 }
536
iax_get_netstats(struct iax_session * session,int * rtt,struct iax_netstat * local,struct iax_netstat * remote)537 int iax_get_netstats(struct iax_session *session, int *rtt, struct iax_netstat *local, struct iax_netstat *remote)
538 {
539 jb_info stats;
540
541 if(!iax_session_valid(session)) return -1;
542
543 *rtt = session->pingtime;
544
545 *remote = session->remote_netstats;
546
547 jb_getinfo(session->jb, &stats);
548
549 local->jitter = stats.jitter;
550 /* XXX: should be short-term loss pct.. */
551 if(stats.frames_in == 0) stats.frames_in = 1;
552 local->losspct = stats.losspct/1000;
553 local->losscnt = stats.frames_lost;
554 local->packets = stats.frames_in;
555 local->delay = stats.current - stats.min;
556 local->dropped = stats.frames_dropped;
557 local->ooo = stats.frames_ooo;
558
559 return 0;
560 }
561
562 #ifdef USE_VOICE_TS_PREDICTION
add_ms(struct timeval * tv,int ms)563 static void add_ms(struct timeval *tv, int ms)
564 {
565 tv->tv_usec += ms * 1000;
566 if (tv->tv_usec > 999999) {
567 tv->tv_sec += tv->tv_usec / 1000000;
568 tv->tv_usec %= 1000000;
569 }
570
571 if (tv->tv_usec < 0) {
572 tv->tv_sec += (tv->tv_usec / 1000000 - 1);
573 tv->tv_usec = (tv->tv_usec % 1000000) + 1000000;
574 }
575 }
576 #endif
577
calc_timestamp(struct iax_session * session,unsigned int ts,struct ast_frame * f)578 static int calc_timestamp(struct iax_session *session, unsigned int ts, struct ast_frame *f)
579 {
580 int ms;
581 struct timeval tv;
582 int voice = 0;
583 int video = 0;
584 int genuine = 0;
585
586 if ( f && f->frametype == AST_FRAME_VOICE )
587 {
588 voice = 1;
589 } else if ( f && f->frametype == AST_FRAME_VIDEO )
590 {
591 video = 1;
592 } else if (!f || f->frametype == AST_FRAME_IAX)
593 {
594 genuine = 1;
595 }
596
597 /* If this is the first packet we're sending, get our
598 offset now. */
599 if (!session->offset.tv_sec && !session->offset.tv_usec)
600 session->offset = iax_tvnow();
601
602 /* If the timestamp is specified, just use their specified
603 timestamp no matter what. Usually this is done for
604 special cases. */
605 if (ts)
606 {
607 if ( f && session )
608 session->lastsent = ts;
609 return ts;
610 }
611
612 /* Otherwise calculate the timestamp from the current time */
613 tv = iax_tvnow();
614
615 /* Calculate the number of milliseconds since we sent the first packet */
616 ms = (tv.tv_sec - session->offset.tv_sec) * 1000 +
617 (tv.tv_usec - session->offset.tv_usec) / 1000;
618
619 if (ms < 0)
620 ms = 0;
621
622 if(voice) {
623 #ifdef USE_VOICE_TS_PREDICTION
624 /* If we haven't most recently sent silence, and we're
625 * close in time, use predicted time */
626 if(session->notsilenttx && (ms - session->nextpred) <= 240) {
627 /* Adjust our txcore, keeping voice and non-voice
628 * synchronized */
629 add_ms(&session->offset, (int)(ms - session->nextpred)/10);
630
631 if(!session->nextpred)
632 session->nextpred = ms;
633 ms = session->nextpred;
634 } else {
635 /* in this case, just use the actual time, since
636 * we're either way off (shouldn't happen), or we're
637 * ending a silent period -- and seed the next predicted
638 * time. Also, round ms to the next multiple of
639 * frame size (so our silent periods are multiples
640 * of frame size too) */
641 int diff = ms % (f->samples / 8);
642 if(diff)
643 ms += f->samples/8 - diff;
644 session->nextpred = ms;
645 }
646 session->notsilenttx = 1;
647 #else
648 if(ms <= session->lastsent)
649 ms = session->lastsent + 3;
650 #endif
651 } else if ( video ) {
652 /*
653 * IAX2 draft 03 says that timestamps MUST be in order.
654 * It does not say anything about several frames having the same timestamp
655 * When transporting video, we can have a frame that spans multiple iax packets
656 * (so called slices), so it would make sense to use the same timestamp for all of
657 * them
658 * We do want to make sure that frames don't go backwards though
659 */
660 if ( (unsigned int)ms < session->lastsent )
661 ms = session->lastsent;
662 } else {
663 /* On a dataframe, use last value + 3 (to accomodate jitter buffer shrinking)
664 if appropriate unless it's a genuine frame */
665 if (genuine) {
666 if ((unsigned int)ms <= session->lastsent)
667 ms = session->lastsent + 3;
668 } else if ((ms - session->lastsent) <= 240) {
669 ms = session->lastsent + 3;
670 }
671
672 }
673
674 /* Record the last sent packet for future reference */
675 /* unless an AST_FRAME_IAX */
676 if (!genuine)
677 session->lastsent = ms;
678
679 #ifdef USE_VOICE_TS_PREDICTION
680 /* set next predicted ts based on 8khz samples */
681 if(voice)
682 session->nextpred += f->samples / 8;
683 #endif
684
685 return ms;
686 }
687
get_n_bits_at(unsigned char * data,int n,int bit)688 static unsigned char get_n_bits_at(unsigned char *data, int n, int bit)
689 {
690 int byte = bit / 8; /* byte containing first bit */
691 int rem = 8 - (bit % 8); /* remaining bits in first byte */
692 unsigned char ret = 0;
693
694 if (n <= 0 || n > 8)
695 return 0;
696
697 if (rem < n) {
698 ret = (data[byte] << (n - rem));
699 ret |= (data[byte + 1] >> (8 - n + rem));
700 } else {
701 ret = (data[byte] >> (rem - n));
702 }
703
704 return (ret & (0xff >> (8 - n)));
705 }
706
speex_get_wb_sz_at(unsigned char * data,int len,int bit)707 static int speex_get_wb_sz_at(unsigned char *data, int len, int bit)
708 {
709 static int SpeexWBSubModeSz[] = {
710 0, 36, 112, 192,
711 352, 0, 0, 0 };
712 int off = bit;
713 unsigned char c;
714
715 /* skip up to two wideband frames */
716 if (((len * 8 - off) >= 5) &&
717 get_n_bits_at(data, 1, off)) {
718 c = get_n_bits_at(data, 3, off + 1);
719 off += SpeexWBSubModeSz[c];
720
721 if (((len * 8 - off) >= 5) &&
722 get_n_bits_at(data, 1, off)) {
723 c = get_n_bits_at(data, 3, off + 1);
724 off += SpeexWBSubModeSz[c];
725
726 if (((len * 8 - off) >= 5) &&
727 get_n_bits_at(data, 1, off)) {
728 /* too many in a row */
729 DEBU(G "\tCORRUPT too many wideband streams in a row\n");
730 return -1;
731 }
732 }
733
734 }
735 return off - bit;
736 }
737
speex_get_samples(unsigned char * data,int len)738 static int speex_get_samples(unsigned char *data, int len)
739 {
740 static int SpeexSubModeSz[] = {
741 0, 43, 119, 160,
742 220, 300, 364, 492,
743 79, 0, 0, 0,
744 0, 0, 0, 0 };
745 static int SpeexInBandSz[] = {
746 1, 1, 4, 4,
747 4, 4, 4, 4,
748 8, 8, 16, 16,
749 32, 32, 64, 64 };
750 int bit = 0;
751 int cnt = 0;
752 int off = 0;
753 unsigned char c;
754
755 DEBU(G "speex_get_samples(%d)\n", len);
756 while ((len * 8 - bit) >= 5) {
757 /* skip wideband frames */
758 off = speex_get_wb_sz_at(data, len, bit);
759 if (off < 0) {
760 DEBU(G "\tERROR reading wideband frames\n");
761 break;
762 }
763 bit += off;
764
765 if ((len * 8 - bit) < 5) {
766 DEBU(G "\tERROR not enough bits left after wb\n");
767 break;
768 }
769
770 /* get control bits */
771 c = get_n_bits_at(data, 5, bit);
772 DEBU(G "\tCONTROL: %d at %d\n", c, bit);
773 bit += 5;
774
775 if (c == 15) {
776 DEBU(G "\tTERMINATOR\n");
777 break;
778 } else if (c == 14) {
779 /* in-band signal; next 4 bits contain signal id */
780 c = get_n_bits_at(data, 4, bit);
781 bit += 4;
782 DEBU(G "\tIN-BAND %d bits\n", SpeexInBandSz[c]);
783 bit += SpeexInBandSz[c];
784 } else if (c == 13) {
785 /* user in-band; next 5 bits contain msg len */
786 c = get_n_bits_at(data, 5, bit);
787 bit += 5;
788 DEBU(G "\tUSER-BAND %d bytes\n", c);
789 bit += c * 8;
790 } else if (c > 8) {
791 DEBU(G "\tUNKNOWN sub-mode %d\n", c);
792 break;
793 } else {
794 /* skip number bits for submode (less the 5 control bits) */
795 DEBU(G "\tSUBMODE %d %d bits\n", c, SpeexSubModeSz[c]);
796 bit += SpeexSubModeSz[c] - 5;
797
798 cnt += 160; /* new frame */
799 }
800 }
801 DEBU(G "\tSAMPLES: %d\n", cnt);
802 return cnt;
803 }
804
get_interp_len(int format)805 static inline int get_interp_len(int format)
806 {
807 return (format == AST_FORMAT_ILBC) ? 30 : 20;
808 }
809
get_sample_cnt(struct iax_event * e)810 static int get_sample_cnt(struct iax_event *e)
811 {
812 int cnt = 0;
813
814 /*
815 * In the case of zero length frames, do not return a cnt of 0
816 */
817 if ( e->datalen == 0 ) {
818 return get_interp_len( e->subclass ) * 8;
819 }
820
821 switch (e->subclass) {
822 case AST_FORMAT_SPEEX:
823 cnt = speex_get_samples(e->data, e->datalen);
824 break;
825 case AST_FORMAT_G723_1:
826 cnt = 240; /* FIXME Not always the case */
827 break;
828 case AST_FORMAT_ILBC:
829 cnt = 240 * (e->datalen / 50);
830 break;
831 case AST_FORMAT_GSM:
832 cnt = 160 * (e->datalen / 33);
833 break;
834 case AST_FORMAT_G729A:
835 cnt = 160 * (e->datalen / 20);
836 break;
837 case AST_FORMAT_SLINEAR:
838 cnt = e->datalen / 2;
839 break;
840 case AST_FORMAT_LPC10:
841 cnt = 22 * 8 + (((char *)(e->data))[7] & 0x1) * 8;
842 break;
843 case AST_FORMAT_ULAW:
844 case AST_FORMAT_ALAW:
845 cnt = e->datalen;
846 break;
847 case AST_FORMAT_ADPCM:
848 case AST_FORMAT_G726:
849 cnt = e->datalen * 2;
850 break;
851 default:
852 return 0;
853 }
854 return cnt;
855 }
856
iax_xmit_frame(struct iax_frame * f)857 static int iax_xmit_frame(struct iax_frame *f)
858 {
859 int res;
860 #ifdef DEBUG_SUPPORT
861 if (debug) {
862 struct ast_iax2_full_hdr *h = (struct ast_iax2_full_hdr *)f->data;
863
864 if (ntohs(h->scallno) & IAX_FLAG_FULL)
865 iax_showframe(f, NULL, 0, f->transfer ?
866 &(f->session->transfer) :
867 &(f->session->peeraddr),
868 f->datalen - sizeof(struct ast_iax2_full_hdr));
869 }
870 #endif
871 /* Send the frame raw */
872 res = f->session->sendto(netfd, (const char *) f->data, f->datalen,
873 IAX_SOCKOPTS, f->transfer ?
874 (struct sockaddr *)&(f->session->transfer) :
875 (struct sockaddr *)&(f->session->peeraddr),
876 sizeof(f->session->peeraddr));
877 return res;
878 }
879
iax_reliable_xmit(struct iax_frame * f)880 static int iax_reliable_xmit(struct iax_frame *f)
881 {
882 struct iax_frame *fc;
883 struct ast_iax2_full_hdr *fh;
884 fh = (struct ast_iax2_full_hdr *) f->data;
885 if (!fh->type) {
886 return -2;
887 }
888 fc = (struct iax_frame *)malloc(sizeof(struct iax_frame));
889 if (fc) {
890 /* Make a copy of the frame */
891 memcpy(fc, f, sizeof(struct iax_frame));
892 /* And a copy of the data if applicable */
893 if (!fc->data || !fc->datalen) {
894 IAXERROR "No frame data?");
895 DEBU(G "No frame data?\n");
896 return -1;
897 } else {
898 fc->data = (char *)malloc(fc->datalen);
899 if (!fc->data) {
900 DEBU(G "Out of memory\n");
901 IAXERROR "Out of memory\n");
902 return -1;
903 }
904 memcpy(fc->data, f->data, f->datalen);
905 iax_sched_add(NULL, fc, NULL, NULL, fc->retrytime);
906 return iax_xmit_frame(fc);
907 }
908 } else
909 return -1;
910 }
911
iax_set_networking(iax_sendto_t st,iax_recvfrom_t rf)912 void iax_set_networking(iax_sendto_t st, iax_recvfrom_t rf)
913 {
914 iax_sendto = st;
915 iax_recvfrom = rf;
916 }
917
iax_set_jb_target_extra(long value)918 void iax_set_jb_target_extra( long value )
919 {
920 /* store in jb_target_extra, a static global */
921 jb_target_extra = value ;
922 }
923
iax_init(int preferredportno)924 int iax_init(int preferredportno)
925 {
926 int portno = preferredportno;
927 #ifndef _MSC_VER // avoid compare of address of imported function
928 /* MSVC only - In certain circumstances the addresses placed in iax_sendto and iax_recvfrom
929 can be an offset to a jump table, making a compare of the current address to the address
930 of the actual imported function fail. */
931 if (iax_recvfrom == (iax_recvfrom_t)recvfrom)
932 #endif // !_MSC_VER
933 {
934 struct sockaddr_in sin;
935 socklen_t sinlen;
936 int flags;
937 int bufsize = 128 * 1024;
938
939 if (netfd > -1)
940 {
941 /* Okay, just don't do anything */
942 DEBU(G "Already initialized.");
943 return 0;
944 }
945 netfd = (int)socket(AF_INET, SOCK_DGRAM, IPPROTO_IP);
946 if (netfd < 0)
947 {
948 DEBU(G "Unable to allocate UDP socket\n");
949 IAXERROR "Unable to allocate UDP socket\n");
950 return -1;
951 }
952
953 if (preferredportno == 0)
954 preferredportno = IAX_DEFAULT_PORTNO;
955
956 if (preferredportno < 0)
957 preferredportno = 0;
958
959 sin.sin_family = AF_INET;
960 sin.sin_addr.s_addr = 0;
961 sin.sin_port = htons((short)preferredportno);
962 if (bind(netfd, (struct sockaddr *) &sin, sizeof(sin)) < 0)
963 {
964 #if defined(WIN32) || defined(_WIN32_WCE)
965 if (WSAGetLastError() == WSAEADDRINUSE)
966 #else
967 if (errno == EADDRINUSE)
968 #endif
969 {
970 /*the port is already in use, so bind to a free port chosen by the IP stack*/
971 DEBU(G "Unable to bind to preferred port - port is in use. Trying to bind to a free one");
972 sin.sin_port = htons((short)0);
973 if (bind(netfd, (struct sockaddr *) &sin, sizeof(sin)) < 0)
974 {
975 IAXERROR "Unable to bind UDP socket\n");
976 return -1;
977 }
978 } else
979 {
980 IAXERROR "Unable to bind UDP socket\n");
981 return -1;
982 }
983 }
984
985 sinlen = sizeof(sin);
986 if (getsockname(netfd, (struct sockaddr *) &sin, &sinlen) < 0)
987 {
988 close(netfd);
989 netfd = -1;
990 DEBU(G "Unable to figure out what I'm bound to.");
991 IAXERROR "Unable to determine bound port number.");
992 return -1;
993 }
994 #if defined(WIN32) || defined(_WIN32_WCE)
995 flags = 1;
996 if (ioctlsocket(netfd,FIONBIO,(unsigned long *) &flags))
997 {
998 closesocket(netfd);
999 netfd = -1;
1000 DEBU(G "Unable to set non-blocking mode.");
1001 IAXERROR "Unable to set non-blocking mode.");
1002 return -1;
1003 }
1004
1005 #else
1006 if ((flags = fcntl(netfd, F_GETFL)) < 0)
1007 {
1008 close(netfd);
1009 netfd = -1;
1010 DEBU(G "Unable to retrieve socket flags.");
1011 IAXERROR "Unable to retrieve socket flags.");
1012 return -1;
1013 }
1014 if (fcntl(netfd, F_SETFL, flags | O_NONBLOCK) < 0)
1015 {
1016 close(netfd);
1017 netfd = -1;
1018 DEBU(G "Unable to set non-blocking mode.");
1019 IAXERROR "Unable to set non-blocking mode.");
1020 return -1;
1021 }
1022 #endif
1023 /* Mihai: increase UDP socket buffers to avoid packet loss. */
1024 if (setsockopt(netfd, SOL_SOCKET, SO_RCVBUF, (char *)&bufsize,
1025 sizeof(bufsize)) < 0)
1026 {
1027 DEBU(G "Unable to set receive buffer size.");
1028 IAXERROR "Unable to set receive buffer size.");
1029 }
1030
1031 /* set send buffer size too */
1032 if (setsockopt(netfd, SOL_SOCKET, SO_SNDBUF, (char *)&bufsize,
1033 sizeof(bufsize)) < 0)
1034 {
1035 DEBU(G "Unable to set send buffer size.");
1036 IAXERROR "Unable to set send buffer size.");
1037 }
1038
1039 portno = ntohs(sin.sin_port);
1040 DEBU(G "Started on port %d\n", portno);
1041 }
1042
1043 iax_seed_random();
1044 callnums = 1 + (int)(32767.0 * (iax_random() / (RAND_MAX + 1.0)));
1045
1046 return portno;
1047 }
1048
1049 static void destroy_session(struct iax_session *session);
1050
convert_reply(char * out,unsigned char * in)1051 static void convert_reply(char *out, unsigned char *in)
1052 {
1053 int x;
1054 for (x=0;x<16;x++)
1055 sprintf(out + (x << 1), "%2.2x", (int)in[x]);
1056 }
1057
compress_subclass(int subclass)1058 static unsigned char compress_subclass(int subclass)
1059 {
1060 int x;
1061 int power=-1;
1062 /* If it's 128 or smaller, just return it */
1063 if (subclass < IAX_FLAG_SC_LOG)
1064 return subclass;
1065 /* Otherwise find its power */
1066 for (x = 0; x < IAX_MAX_SHIFT; x++) {
1067 if (subclass & (1 << x)) {
1068 if (power > -1) {
1069 DEBU(G "Can't compress subclass %d\n", subclass);
1070 return 0;
1071 } else
1072 power = x;
1073 }
1074 }
1075 return power | IAX_FLAG_SC_LOG;
1076 }
1077
iax_send(struct iax_session * pvt,struct ast_frame * f,unsigned int ts,int seqno,int now,int transfer,int final,int fullframe)1078 static int iax_send(struct iax_session *pvt, struct ast_frame *f, unsigned int ts, int seqno, int now, int transfer, int final, int fullframe)
1079 {
1080 /* Queue a packet for delivery on a given private structure. Use "ts" for
1081 timestamp, or calculate if ts is 0. Send immediately without retransmission
1082 or delayed, with retransmission */
1083 struct ast_iax2_full_hdr *fh;
1084 struct ast_iax2_mini_hdr *mh;
1085 struct ast_iax2_video_hdr *vh;
1086 //unsigned char buf[5120]; //fd: changed max packet size[5120];
1087 unsigned char buf[32 * 1024]; //Mihai: let's see if this is where it crashes
1088
1089 struct iax_frame *fr;
1090 int res;
1091 int sendmini=0;
1092 unsigned int lastsent;
1093 unsigned int fts;
1094
1095 if (!pvt)
1096 {
1097 IAXERROR "No private structure for packet?\n");
1098 return -1;
1099 }
1100
1101 /* this must come before the next call to calc_timestamp() since
1102 calc_timestamp() will change lastsent to the returned value */
1103 lastsent = pvt->lastsent;
1104
1105 /* Calculate actual timestamp */
1106 fts = calc_timestamp(pvt, ts, f);
1107
1108 if (((fts & 0xFFFF0000L) == (lastsent & 0xFFFF0000L))
1109 /* High two bits are the same on timestamp, or sending on a trunk */ &&
1110 (f->frametype == AST_FRAME_VOICE)
1111 /* is a voice frame */ &&
1112 (f->subclass == pvt->svoiceformat)
1113 /* is the same type */ )
1114 {
1115 /* Force immediate rather than delayed transmission */
1116 now = 1;
1117 /* Mark that mini-style frame is appropriate */
1118 sendmini = 1;
1119 }
1120
1121 /* Bitmask taken from chan_iax2.c... I must ask Mark Spencer for this? I think not... */
1122 if ( f->frametype == AST_FRAME_VIDEO )
1123 {
1124 /* Check if the timestamp has rolled over or if the video codec has changed */
1125 if ( ((fts & 0xFFFF8000L) == (pvt->lastvsent & 0xFFFF8000L)) &&
1126 (f->subclass == pvt->svideoformat)
1127 )
1128 {
1129 /* send a mini video frame immediately */
1130 now = 1;
1131 sendmini = 1;
1132 } else
1133 {
1134 /* we want to send a fullframe and be able to retransmit it */
1135 now = 0;
1136 sendmini = 0;
1137 }
1138 pvt->lastvsent = fts;
1139 }
1140
1141 /* if requested, force a full frame */
1142 if ( fullframe )
1143 {
1144 now = 0;
1145 sendmini = 0;
1146 }
1147
1148 /* Allocate an iax_frame */
1149 if (now)
1150 {
1151 fr = (struct iax_frame *) buf;
1152 } else
1153 {
1154 fr = iax_frame_new(DIRECTION_OUTGRESS, f->datalen);
1155 if ( fr == NULL )
1156 {
1157 IAXERROR "Out of memory\n");
1158 return -1;
1159 }
1160 }
1161
1162 /* Copy our prospective frame into our immediate or retransmitted wrapper */
1163 iax_frame_wrap(fr, f);
1164
1165 fr->ts = fts;
1166 if (!fr->ts)
1167 {
1168 IAXERROR "timestamp is 0?\n");
1169 if (!now)
1170 iax_frame_free(fr);
1171 return -1;
1172 }
1173
1174 fr->callno = pvt->callno;
1175 fr->transfer = transfer;
1176 fr->final = final;
1177 fr->session = pvt;
1178 if (!sendmini)
1179 {
1180 /* We need a full frame */
1181 if (seqno > -1)
1182 fr->oseqno = seqno;
1183 else
1184 fr->oseqno = pvt->oseqno++;
1185 fr->iseqno = pvt->iseqno;
1186 fh = (struct ast_iax2_full_hdr *)(((char *)fr->af.data) - sizeof(struct ast_iax2_full_hdr));
1187 fh->scallno = htons(fr->callno | IAX_FLAG_FULL);
1188 fh->ts = htonl(fr->ts);
1189 fh->oseqno = fr->oseqno;
1190 if (transfer)
1191 {
1192 fh->iseqno = 0;
1193 } else
1194 fh->iseqno = fr->iseqno;
1195 /* Keep track of the last thing we've acknowledged */
1196 pvt->aseqno = fr->iseqno;
1197 fh->type = fr->af.frametype & 0xFF;
1198 if (f->frametype == AST_FRAME_VIDEO)
1199 fh->csub = compress_subclass(fr->af.subclass & ~0x1) | ((fr->af.subclass & 0x1) << 6);
1200 else
1201 fh->csub = compress_subclass(fr->af.subclass);
1202 if (transfer)
1203 {
1204 fr->dcallno = pvt->transfercallno;
1205 } else
1206 fr->dcallno = pvt->peercallno;
1207 fh->dcallno = htons(fr->dcallno);
1208 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_full_hdr);
1209 fr->data = fh;
1210 fr->retries = maxretries;
1211 /* Retry after 2x the ping time has passed */
1212 fr->retrytime = pvt->pingtime * 2;
1213 if (fr->retrytime < MIN_RETRY_TIME)
1214 fr->retrytime = MIN_RETRY_TIME;
1215 if (fr->retrytime > MAX_RETRY_TIME)
1216 fr->retrytime = MAX_RETRY_TIME;
1217 /* Acks' don't get retried */
1218 if ((f->frametype == AST_FRAME_IAX) && (f->subclass == IAX_COMMAND_ACK))
1219 fr->retries = -1;
1220 if (f->frametype == AST_FRAME_VOICE)
1221 {
1222 pvt->svoiceformat = f->subclass;
1223 }
1224 else if (f->frametype == AST_FRAME_VIDEO)
1225 {
1226 pvt->svideoformat = f->subclass & ~0x1;
1227 }
1228 if (now)
1229 {
1230 res = iax_xmit_frame(fr);
1231 } else
1232 res = iax_reliable_xmit(fr);
1233 } else
1234 {
1235 if (fr->af.frametype == AST_FRAME_VIDEO)
1236 {
1237 /* Video frame have no sequence number */
1238 fr->oseqno = -1;
1239 fr->iseqno = -1;
1240 vh = (struct ast_iax2_video_hdr *)(((char* )fr->af.data) - sizeof(struct ast_iax2_video_hdr));
1241 vh->zeros = 0;
1242 vh->callno = htons(0x8000 | fr->callno);
1243 vh->ts = htons((fr->ts & 0x7FFF) | (fr->af.subclass & 0x1 ? 0x8000 : 0));
1244 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_video_hdr);
1245 fr->data = vh;
1246 fr->retries = -1;
1247 res = iax_xmit_frame(fr);
1248 } else
1249 {
1250 /* Mini-frames have no sequence number */
1251 fr->oseqno = -1;
1252 fr->iseqno = -1;
1253 /* Mini frame will do */
1254 mh = (struct ast_iax2_mini_hdr *)(((char *)fr->af.data) - sizeof(struct ast_iax2_mini_hdr));
1255 mh->callno = htons(fr->callno);
1256 mh->ts = htons(fr->ts & 0xFFFF);
1257 fr->datalen = fr->af.datalen + sizeof(struct ast_iax2_mini_hdr);
1258 fr->data = mh;
1259 fr->retries = -1;
1260 res = iax_xmit_frame(fr);
1261 }
1262 }
1263 if( !now && fr!=NULL )
1264 iax_frame_free( fr );
1265 return res;
1266 }
1267
1268 #if 0
1269 static int iax_predestroy(struct iax_session *pvt)
1270 {
1271 if (!pvt) {
1272 return -1;
1273 }
1274 if (!pvt->alreadygone) {
1275 /* No more pings or lagrq's */
1276 if (pvt->pingid > -1)
1277 ast_sched_del(sched, pvt->pingid);
1278 if (pvt->lagid > -1)
1279 ast_sched_del(sched, pvt->lagid);
1280 if (pvt->autoid > -1)
1281 ast_sched_del(sched, pvt->autoid);
1282 if (pvt->initid > -1)
1283 ast_sched_del(sched, pvt->initid);
1284 pvt->pingid = -1;
1285 pvt->lagid = -1;
1286 pvt->autoid = -1;
1287 pvt->initid = -1;
1288 pvt->alreadygone = 1;
1289 }
1290 return 0;
1291 }
1292 #endif
1293
__send_command(struct iax_session * i,char type,int command,unsigned int ts,unsigned char * data,int datalen,int seqno,int now,int transfer,int final,int fullframe,int samples)1294 static int __send_command(struct iax_session *i, char type, int command,
1295 unsigned int ts, unsigned char *data, int datalen, int seqno,
1296 int now, int transfer, int final, int fullframe, int samples)
1297 {
1298 struct ast_frame f;
1299 f.frametype = type;
1300 f.subclass = command;
1301 f.datalen = datalen;
1302 f.samples = samples;
1303 f.mallocd = 0;
1304 f.offset = 0;
1305 #ifdef __GNUC__
1306 f.src = (char *) __FUNCTION__;
1307 #else
1308 f.src = (char *) __FILE__;
1309 #endif
1310 f.data = data;
1311 return iax_send(i, &f, ts, seqno, now, transfer, final, fullframe);
1312 }
1313
send_command(struct iax_session * i,char type,int command,unsigned int ts,unsigned char * data,int datalen,int seqno)1314 static int send_command(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno)
1315 {
1316 return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0, 0, 0);
1317 }
1318
send_command_video(struct iax_session * i,char type,int command,unsigned int ts,unsigned char * data,int datalen,int seqno,int fullframe)1319 static int send_command_video(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno, int fullframe)
1320 {
1321 return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0, fullframe, 0);
1322 }
1323
send_command_final(struct iax_session * i,char type,int command,unsigned int ts,unsigned char * data,int datalen,int seqno)1324 static int send_command_final(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno)
1325 {
1326 #if 0
1327 /* It is assumed that the callno has already been locked */
1328 iax_predestroy(i);
1329 #endif
1330 int r;
1331 r = __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 1, 0, 0);
1332 if (r >= 0) destroy_session(i);
1333 return r;
1334 }
1335
send_command_immediate(struct iax_session * i,char type,int command,unsigned int ts,unsigned char * data,int datalen,int seqno)1336 static int send_command_immediate(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno)
1337 {
1338 return __send_command(i, type, command, ts, data, datalen, seqno, 1, 0, 0, 0, 0);
1339 }
1340
send_command_transfer(struct iax_session * i,char type,int command,unsigned int ts,unsigned char * data,int datalen)1341 static int send_command_transfer(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen)
1342 {
1343 return __send_command(i, type, command, ts, data, datalen, 0, 0, 1, 0, 0, 0);
1344 }
1345
send_command_samples(struct iax_session * i,char type,int command,unsigned int ts,unsigned char * data,int datalen,int seqno,int samples)1346 static int send_command_samples(struct iax_session *i, char type, int command, unsigned int ts, unsigned char *data, int datalen, int seqno, int samples)
1347 {
1348 return __send_command(i, type, command, ts, data, datalen, seqno, 0, 0, 0, 0, samples);
1349 }
1350
1351
iax_transfer(struct iax_session * session,const char * number)1352 int iax_transfer(struct iax_session *session, const char *number)
1353 {
1354 static int res; //Return Code
1355 struct iax_ie_data ied; //IE Data Structure (Stuff To Send)
1356
1357 // Clear The Memory Used For IE Buffer
1358 memset(&ied, 0, sizeof(ied));
1359
1360 // Copy The Transfer Destination Into The IE Structure
1361 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, number);
1362
1363 // Send The Transfer Command - Asterisk Will Handle The Rest!
1364 res = send_command(session, AST_FRAME_IAX, IAX_COMMAND_TRANSFER, 0, ied.buf, ied.pos, -1);
1365
1366 // Return Success
1367 return 0;
1368 }
1369
stop_transfer(struct iax_session * session)1370 static void stop_transfer(struct iax_session *session)
1371 {
1372 struct iax_sched *sch;
1373
1374 sch = schedq;
1375 while(sch) {
1376 if (sch->frame && (sch->frame->session == session))
1377 sch->frame->retries = -1;
1378 sch = sch->next;
1379 }
1380 } /* stop_transfer */
1381
complete_transfer(struct iax_session * session,int peercallno,int xfr2peer,int preserveSeq)1382 static void complete_transfer(struct iax_session *session, int peercallno, int xfr2peer, int preserveSeq)
1383 {
1384 jb_frame frame;
1385
1386 session->peercallno = peercallno;
1387 /* Change from transfer to session now */
1388 if (xfr2peer) {
1389 memcpy(&session->peeraddr, &session->transfer, sizeof(session->peeraddr));
1390 memset(&session->transfer, 0, sizeof(session->transfer));
1391 session->transferring = TRANSFER_NONE;
1392 session->transferpeer = 0;
1393 session->transfer_moh = 0;
1394 /* Force retransmission of a real voice packet, and reset all timing */
1395 session->svoiceformat = -1;
1396 session->voiceformat = 0;
1397 session->svideoformat = -1;
1398 session->videoformat = 0;
1399 }
1400
1401 memset(&session->rxcore, 0, sizeof(session->rxcore));
1402 memset(&session->offset, 0, sizeof(session->offset));
1403
1404 /* Reset jitterbuffer */
1405 while(jb_getall(session->jb,&frame) == JB_OK)
1406 iax_event_free((struct iax_event *)frame.data);
1407
1408 jb_reset(session->jb);
1409
1410 if (! preserveSeq)
1411 {
1412 /* Reset sequence numbers */
1413 session->aseqno = 0;
1414 session->oseqno = 0;
1415 session->iseqno = 0;
1416 }
1417
1418 session->lastsent = 0;
1419 session->last_ts = 0;
1420 session->pingtime = 30;
1421 /* We have to dump anything we were going to (re)transmit now that we've been
1422 transferred since they're all invalid and for the old host. */
1423 stop_transfer(session);
1424 } /* complete_transfer */
1425
iax_setup_transfer(struct iax_session * org_session,struct iax_session * new_session)1426 int iax_setup_transfer(struct iax_session *org_session, struct iax_session *new_session)
1427 {
1428 int res;
1429 struct iax_ie_data ied0;
1430 struct iax_ie_data ied1;
1431
1432 struct iax_session *s0 = org_session;
1433 struct iax_session *s1 = new_session;
1434
1435 int transfer_id = 1 + (int)(32767.0 * (iax_random() / (RAND_MAX + 1.0)));
1436
1437 memset(&ied0, 0, sizeof(ied0));
1438
1439 memset(&ied1, 0, sizeof(ied1));
1440
1441 /* reversed setup */
1442 iax_ie_append_addr(&ied0, IAX_IE_APPARENT_ADDR, &s1->peeraddr);
1443 iax_ie_append_short(&ied0, IAX_IE_CALLNO, s1->peercallno);
1444 iax_ie_append_int(&ied0, IAX_IE_TRANSFERID, transfer_id);
1445
1446 iax_ie_append_addr(&ied1, IAX_IE_APPARENT_ADDR, &s0->peeraddr);
1447 iax_ie_append_short(&ied1, IAX_IE_CALLNO, s0->peercallno);
1448 iax_ie_append_int(&ied1, IAX_IE_TRANSFERID, transfer_id);
1449
1450 s0->transfer = s1->peeraddr;
1451 s1->transfer = s0->peeraddr;
1452
1453 s0->transferid = transfer_id;
1454 s1->transferid = transfer_id;
1455
1456 s0->transfercallno = s0->peercallno;
1457 s1->transfercallno = s1->peercallno;
1458
1459 s0->transferring = TRANSFER_BEGIN;
1460 s1->transferring = TRANSFER_BEGIN;
1461
1462 s0->transferpeer = s1->callno;
1463 s1->transferpeer = s0->callno;
1464 #ifdef DEBUG_SUPPORT
1465 if (debug) {
1466 DEBU(G "iax_setup_transfer(%d, %d) transfer_id=%d\n", s0->callno, s1->callno, transfer_id);
1467 DEBU(G "\torg: callno=%d peercallno=%d peeraddr=%s peerport=%d\n", s0->callno, s0->peercallno, inet_ntoa(s0->peeraddr.sin_addr), ntohs(s0->peeraddr.sin_port));
1468 DEBU(G "\tnew: callno=%d peercallno=%d peeraddr=%s peerport=%d\n", s1->callno, s1->peercallno, inet_ntoa(s1->peeraddr.sin_addr), ntohs(s1->peeraddr.sin_port));
1469 }
1470 #endif
1471
1472 res = send_command(s0, AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied0.buf, ied0.pos, -1);
1473 if (res < 0) {
1474 return -1;
1475 }
1476
1477 res = send_command(s1, AST_FRAME_IAX, IAX_COMMAND_TXREQ, 0, ied1.buf, ied1.pos, -1);
1478 if (res < 0) {
1479 return -1;
1480 }
1481
1482 return 0;
1483 }
1484
iax_finish_transfer(struct iax_session * s,short new_peer)1485 static int iax_finish_transfer(struct iax_session *s, short new_peer)
1486 {
1487 int res;
1488 struct iax_ie_data ied;
1489
1490 memset(&ied, 0, sizeof(ied));
1491
1492 iax_ie_append_short(&ied, IAX_IE_CALLNO, new_peer);
1493
1494 res = send_command(s, AST_FRAME_IAX, IAX_COMMAND_TXREL, 0, ied.buf, ied.pos, -1);
1495
1496 complete_transfer(s, new_peer, 0, 1);
1497
1498 return res;
1499
1500 }
1501
iax_find_session2(short callno)1502 static struct iax_session *iax_find_session2(short callno)
1503 {
1504 struct iax_session *cur = sessions;
1505
1506 while(cur) {
1507 if (callno == cur->callno && callno != 0) {
1508 return cur;
1509 }
1510 cur = cur->next;
1511 }
1512
1513 return NULL;
1514 }
1515
iax_handle_txready(struct iax_session * s)1516 static int iax_handle_txready(struct iax_session *s)
1517 {
1518 struct iax_session *s0, *s1;
1519 short s0_org_peer, s1_org_peer;
1520
1521 if (s->transfer_moh) {
1522 s->transfer_moh = 0;
1523 iax_unquelch(s);
1524 }
1525
1526 complete_transfer(s, s->peercallno, 0, 1);
1527
1528 s->transferring = TRANSFER_REL;
1529
1530 s0 = s;
1531 s1 = iax_find_session2(s0->transferpeer);
1532
1533 if (s1 != NULL &&
1534 s1->callno == s0->transferpeer &&
1535 s0->transferring == TRANSFER_REL &&
1536 s1->transferring == TRANSFER_REL) {
1537
1538 s0_org_peer = s0->peercallno;
1539 s1_org_peer = s1->peercallno;
1540
1541 iax_finish_transfer(s0, s1_org_peer);
1542 iax_finish_transfer(s1, s0_org_peer);
1543 return 1;
1544 }
1545
1546 return 0;
1547 }
1548
iax_handle_txreject(struct iax_session * s)1549 static void iax_handle_txreject(struct iax_session *s)
1550 {
1551 struct iax_session *s0, *s1;
1552
1553 s0 = s;
1554 s1 = iax_find_session2(s0->transferpeer);
1555 if (s1 != NULL &&
1556 s0->transferpeer == s1->callno &&
1557 s1->transferring) {
1558 if (s1->transfer_moh) {
1559 s1->transfer_moh = 0;
1560 send_command_immediate(s1, AST_FRAME_IAX, IAX_COMMAND_UNQUELCH, 0, NULL, 0, s1->iseqno);
1561 }
1562 }
1563 if (s0->transfer_moh) {
1564 s0->transfer_moh = 0;
1565 send_command_immediate(s0, AST_FRAME_IAX, IAX_COMMAND_UNQUELCH, 0, NULL, 0, s0->iseqno);
1566 }
1567
1568 memset(&s->transfer, 0, sizeof(s->transfer));
1569 s->transferring = TRANSFER_NONE;
1570 s->transferpeer = 0;
1571 s->transfer_moh = 0;
1572 }
1573
destroy_session(struct iax_session * session)1574 static void destroy_session(struct iax_session *session)
1575 {
1576 struct iax_session *cur, *prev=NULL;
1577 struct iax_sched *curs, *prevs=NULL, *nexts=NULL;
1578 int loop_cnt=0;
1579 curs = schedq;
1580 while(curs) {
1581 nexts = curs->next;
1582 if (curs->frame && curs->frame->session == session) {
1583 /* Just mark these frames as if they've been sent */
1584 curs->frame->retries = -1;
1585 } else if (curs->event && curs->event->session == session) {
1586 if (prevs)
1587 prevs->next = nexts;
1588 else
1589 schedq = nexts;
1590 if (curs->event)
1591 iax_event_free(curs->event);
1592 free(curs);
1593 } else {
1594 prevs = curs;
1595 }
1596 curs = nexts;
1597 loop_cnt++;
1598 }
1599
1600 cur = sessions;
1601 while(cur) {
1602 if (cur == session) {
1603 jb_frame frame;
1604
1605 if (prev)
1606 prev->next = session->next;
1607 else
1608 sessions = session->next;
1609
1610 while(jb_getall(session->jb,&frame) == JB_OK)
1611 iax_event_free((struct iax_event *)frame.data);
1612
1613 jb_destroy(session->jb);
1614
1615 free(session);
1616 return;
1617 }
1618 prev = cur;
1619 cur = cur->next;
1620 }
1621 }
1622
1623 static int iax_send_lagrp(struct iax_session *session, unsigned int ts);
1624 static int iax_send_pong(struct iax_session *session, unsigned int ts);
1625
handle_event(struct iax_event * event)1626 static struct iax_event *handle_event(struct iax_event *event)
1627 {
1628 /* We have a candidate event to be delievered. Be sure
1629 the session still exists. */
1630 if (event)
1631 {
1632 if ( event->etype == IAX_EVENT_NULL ) return event;
1633 if (iax_session_valid(event->session))
1634 {
1635 /* Lag requests are never actually sent to the client, but
1636 other than that are handled as normal packets */
1637 switch(event->etype)
1638 {
1639 /* the user on the outside may need to look at the session so we will not free
1640 it here anymore we will test for hangup event in iax_event_free and do it
1641 there.
1642 */
1643 case IAX_EVENT_REJECT:
1644 case IAX_EVENT_HANGUP:
1645 /* Destroy this session -- it's no longer valid */
1646 destroy_session(event->session);
1647 return event;
1648 case IAX_EVENT_LAGRQ:
1649 event->etype = IAX_EVENT_LAGRP;
1650 iax_send_lagrp(event->session, event->ts);
1651 iax_event_free(event);
1652 break;
1653 case IAX_EVENT_PING:
1654 event->etype = IAX_EVENT_PONG;
1655 iax_send_pong(event->session, event->ts);
1656 iax_event_free(event);
1657 break;
1658 case IAX_EVENT_POKE:
1659 event->etype = IAX_EVENT_PONG;
1660 iax_send_pong(event->session, event->ts);
1661 destroy_session(event->session);
1662 iax_event_free(event);
1663 break;
1664 default:
1665 return event;
1666 }
1667 } else
1668 iax_event_free(event);
1669 }
1670 return NULL;
1671 }
1672
iax2_vnak(struct iax_session * session)1673 static int iax2_vnak(struct iax_session *session)
1674 {
1675 /* send vnak just once for a given sequence number */
1676 if ( (unsigned char)(session->lastvnak - session->iseqno) < 128 )
1677 {
1678 return 0;
1679 }
1680
1681 session->lastvnak = session->iseqno;
1682 return send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_VNAK, 0, NULL, 0, session->iseqno);
1683 }
1684
iax_send_dtmf(struct iax_session * session,char digit)1685 int iax_send_dtmf(struct iax_session *session, char digit)
1686 {
1687 return send_command(session, AST_FRAME_DTMF, digit, 0, NULL, 0, -1);
1688 }
1689
iax_send_voice(struct iax_session * session,int format,unsigned char * data,int datalen,int samples)1690 int iax_send_voice(struct iax_session *session, int format, unsigned char *data, int datalen, int samples)
1691 {
1692 /* Send a (possibly compressed) voice frame */
1693 if (!session->quelch)
1694 return send_command_samples(session, AST_FRAME_VOICE, format, 0, data, datalen, -1, samples);
1695 return 0;
1696 }
1697
iax_send_cng(struct iax_session * session,int level,unsigned char * data,int datalen)1698 int iax_send_cng(struct iax_session *session, int level, unsigned char *data,
1699 int datalen)
1700 {
1701 #ifdef USE_VOICE_TS_PREDICTION
1702 session->notsilenttx = 0;
1703 #endif
1704 return send_command(session, AST_FRAME_CNG, level, 0, data, datalen, -1);
1705 }
1706
iax_send_image(struct iax_session * session,int format,unsigned char * data,int datalen)1707 int iax_send_image(struct iax_session *session, int format, unsigned char *data,
1708 int datalen)
1709 {
1710 /* Send an image frame */
1711 return send_command(session, AST_FRAME_IMAGE, format, 0, data, datalen, -1);
1712 }
1713
iax_send_video(struct iax_session * session,int format,unsigned char * data,int datalen,int fullframe)1714 int iax_send_video(struct iax_session *session, int format, unsigned char *data,
1715 int datalen, int fullframe)
1716 {
1717 if (!session->quelch)
1718 {
1719 int res = send_command_video(session, AST_FRAME_VIDEO, format,
1720 0, data, datalen, -1, fullframe);
1721 return res;
1722 }
1723 return 0;
1724 }
1725
iax_send_video_trunk(struct iax_session * session,int format,char * data,int datalen,int fullframe,int ntrunk)1726 int iax_send_video_trunk(struct iax_session *session, int format,
1727 char *data, int datalen, int fullframe, int ntrunk)
1728 {
1729 static int my_lastts = 0;
1730
1731 if ( ntrunk == 0 )
1732 my_lastts = calc_timestamp(session, 0, NULL);
1733
1734 if ( !session->quelch )
1735 {
1736 return send_command_video(session, AST_FRAME_VIDEO, format,
1737 my_lastts, (unsigned char *)data, datalen, -1,
1738 fullframe);
1739 }
1740 return 0;
1741 }
1742
iax_video_bypass_jitter(struct iax_session * s,int mode)1743 int iax_video_bypass_jitter(struct iax_session *s, int mode)
1744 {
1745 video_bypass_jitterbuffer = mode;
1746 return 0;
1747 }
1748
iax_register(struct iax_session * session,const char * server,const char * peer,const char * secret,int refresh)1749 int iax_register(struct iax_session *session, const char *server, const char *peer, const char *secret, int refresh)
1750 {
1751 /* Send a registration request */
1752 char tmp[256];
1753 char *p;
1754 int res;
1755 int portno = IAX_DEFAULT_PORTNO;
1756 struct iax_ie_data ied;
1757 struct hostent *hp;
1758
1759 tmp[255] = '\0';
1760 strncpy(tmp, server, sizeof(tmp) - 1);
1761 p = strchr(tmp, ':');
1762 if (p) {
1763 *p = '\0';
1764 portno = atoi(p+1);
1765 }
1766
1767 memset(&ied, 0, sizeof(ied));
1768 if (secret)
1769 strncpy(session->secret, secret, sizeof(session->secret) - 1);
1770 else
1771 strcpy(session->secret, "");
1772
1773 memset(&session->unregreason, 0, sizeof(session->unregreason));
1774
1775 /* Connect first */
1776 hp = gethostbyname(tmp);
1777 if (!hp) {
1778 snprintf(iax_errstr, sizeof(iax_errstr), "Invalid hostname: %s", tmp);
1779 return -1;
1780 }
1781 memcpy(&session->peeraddr.sin_addr, hp->h_addr, sizeof(session->peeraddr.sin_addr));
1782 session->peeraddr.sin_port = htons(portno);
1783 session->peeraddr.sin_family = AF_INET;
1784 strncpy(session->username, peer, sizeof(session->username) - 1);
1785 session->refresh = refresh;
1786 iax_ie_append_str(&ied, IAX_IE_USERNAME, peer);
1787 iax_ie_append_short(&ied, IAX_IE_REFRESH, refresh);
1788 res = send_command(session, AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
1789 return res;
1790 }
1791
iax_unregister(struct iax_session * session,const char * server,const char * peer,const char * secret,const char * reason)1792 int iax_unregister(struct iax_session *session, const char *server, const char *peer, const char *secret, const char *reason)
1793 {
1794 /* Send an unregistration request */
1795 char tmp[256];
1796 char *p;
1797 int portno = IAX_DEFAULT_PORTNO;
1798 struct iax_ie_data ied;
1799 struct hostent *hp;
1800
1801 tmp[255] = '\0';
1802 strncpy(tmp, server, sizeof(tmp) - 1);
1803 p = strchr(tmp, ':');
1804 if (p) {
1805 *p = '\0';
1806 portno = atoi(p+1);
1807 }
1808
1809 memset(&ied, 0, sizeof(ied));
1810 if (secret)
1811 strncpy(session->secret, secret, sizeof(session->secret) - 1);
1812 else
1813 strcpy(session->secret, "");
1814
1815 if (reason && strlen(reason))
1816 strncpy(session->unregreason, reason, sizeof(session->unregreason) - 1);
1817 else
1818 strcpy(session->unregreason, "Unspecified");
1819
1820 /* Connect first */
1821 hp = gethostbyname(tmp);
1822 if (!hp) {
1823 snprintf(iax_errstr, sizeof(iax_errstr), "Invalid hostname: %s", tmp);
1824 return -1;
1825 }
1826 memcpy(&session->peeraddr.sin_addr, hp->h_addr, sizeof(session->peeraddr.sin_addr));
1827 session->peeraddr.sin_port = htons(portno);
1828 session->peeraddr.sin_family = AF_INET;
1829 strncpy(session->username, peer, sizeof(session->username) - 1);
1830 iax_ie_append_str(&ied, IAX_IE_USERNAME, peer);
1831 iax_ie_append_str(&ied, IAX_IE_CAUSE, session->unregreason);
1832 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_REGREL, 0, ied.buf, ied.pos, -1);
1833 }
1834
iax_reject(struct iax_session * session,char * reason)1835 int iax_reject(struct iax_session *session, char *reason)
1836 {
1837 struct iax_ie_data ied;
1838 memset(&ied, 0, sizeof(ied));
1839 iax_ie_append_str(&ied, IAX_IE_CAUSE, reason ? reason : "Unspecified");
1840 return send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1);
1841 }
1842
iax_hangup(struct iax_session * session,char * byemsg)1843 int iax_hangup(struct iax_session *session, char *byemsg)
1844 {
1845 struct iax_ie_data ied;
1846 iax_sched_del(NULL, NULL, send_ping, (void *) session, 1);
1847 memset(&ied, 0, sizeof(ied));
1848 iax_ie_append_str(&ied, IAX_IE_CAUSE, byemsg ? byemsg : "Normal clearing");
1849 return send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_HANGUP, 0, ied.buf, ied.pos, -1);
1850 }
1851
iax_sendurl(struct iax_session * session,char * url)1852 int iax_sendurl(struct iax_session *session, char *url)
1853 {
1854 return send_command(session, AST_FRAME_HTML, AST_HTML_URL, 0,
1855 (unsigned char *)url, (int)strlen(url), -1);
1856 }
1857
iax_ring_announce(struct iax_session * session)1858 int iax_ring_announce(struct iax_session *session)
1859 {
1860 return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_RINGING, 0, NULL, 0, -1);
1861 }
1862
iax_lag_request(struct iax_session * session)1863 int iax_lag_request(struct iax_session *session)
1864 {
1865 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_LAGRQ, 0, NULL, 0, -1);
1866 }
1867
iax_busy(struct iax_session * session)1868 int iax_busy(struct iax_session *session)
1869 {
1870 return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_BUSY, 0, NULL, 0, -1);
1871 }
1872
iax_congestion(struct iax_session * session)1873 int iax_congestion(struct iax_session *session)
1874 {
1875 return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_CONGESTION, 0, NULL, 0, -1);
1876 }
1877
1878
iax_accept(struct iax_session * session,int format)1879 int iax_accept(struct iax_session *session, int format)
1880 {
1881 struct iax_ie_data ied;
1882 memset(&ied, 0, sizeof(ied));
1883 iax_ie_append_int(&ied, IAX_IE_FORMAT, format);
1884 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_ACCEPT, 0, ied.buf, ied.pos, -1);
1885 }
1886
iax_answer(struct iax_session * session)1887 int iax_answer(struct iax_session *session)
1888 {
1889 return send_command(session, AST_FRAME_CONTROL, AST_CONTROL_ANSWER, 0, NULL, 0, -1);
1890 }
1891
iax_load_complete(struct iax_session * session)1892 int iax_load_complete(struct iax_session *session)
1893 {
1894 return send_command(session, AST_FRAME_HTML, AST_HTML_LDCOMPLETE, 0, NULL, 0, -1);
1895 }
1896
iax_send_url(struct iax_session * session,const char * url,int link)1897 int iax_send_url(struct iax_session *session, const char *url, int link)
1898 {
1899 return send_command(session, AST_FRAME_HTML,
1900 link ? AST_HTML_LINKURL : AST_HTML_URL, 0,
1901 (unsigned char *)url, (int)strlen(url), -1);
1902 }
1903
iax_send_text(struct iax_session * session,const char * text)1904 int iax_send_text(struct iax_session *session, const char *text)
1905 {
1906 return send_command(session, AST_FRAME_TEXT, 0, 0,
1907 (unsigned char *)text, (int)strlen(text) + 1, -1);
1908 }
1909
iax_send_unlink(struct iax_session * session)1910 int iax_send_unlink(struct iax_session *session)
1911 {
1912 return send_command(session, AST_FRAME_HTML, AST_HTML_UNLINK, 0, NULL, 0, -1);
1913 }
1914
iax_send_link_reject(struct iax_session * session)1915 int iax_send_link_reject(struct iax_session *session)
1916 {
1917 return send_command(session, AST_FRAME_HTML, AST_HTML_LINKREJECT, 0, NULL, 0, -1);
1918 }
1919
iax_send_pong(struct iax_session * session,unsigned int ts)1920 static int iax_send_pong(struct iax_session *session, unsigned int ts)
1921 {
1922 struct iax_ie_data ied;
1923 jb_info stats;
1924
1925 memset(&ied, 0, sizeof(ied));
1926
1927 jb_getinfo(session->jb, &stats);
1928
1929 iax_ie_append_int(&ied,IAX_IE_RR_JITTER, stats.jitter);
1930 /* XXX: should be short-term loss pct.. */
1931 if(stats.frames_in == 0) stats.frames_in = 1;
1932 iax_ie_append_int(&ied,IAX_IE_RR_LOSS,
1933 ((0xff & (stats.losspct/1000)) << 24 |
1934 (stats.frames_lost & 0x00ffffff)));
1935 iax_ie_append_int(&ied,IAX_IE_RR_PKTS, stats.frames_in);
1936 iax_ie_append_short(&ied,IAX_IE_RR_DELAY,
1937 (unsigned short)(stats.current - stats.min));
1938 iax_ie_append_int(&ied,IAX_IE_RR_DROPPED, stats.frames_dropped);
1939 iax_ie_append_int(&ied,IAX_IE_RR_OOO, stats.frames_ooo);
1940
1941 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_PONG, ts, ied.buf, ied.pos, -1);
1942 }
1943
1944 /* external API; deprecated since we send pings ourselves now (finally) */
iax_send_ping(struct iax_session * session)1945 int iax_send_ping(struct iax_session *session)
1946 {
1947 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1948 }
1949
1950 /* scheduled ping sender; sends ping, then reschedules */
send_ping(void * s)1951 static void send_ping(void *s)
1952 {
1953 struct iax_session *session = (struct iax_session *)s;
1954
1955 /* important, eh? */
1956 if(!iax_session_valid(session)) return;
1957
1958 send_command(session, AST_FRAME_IAX, IAX_COMMAND_PING, 0, NULL, 0, -1);
1959 session->pingid = iax_sched_add(NULL,NULL, send_ping, (void *)session, ping_time * 1000);
1960 return;
1961 }
1962
iax_send_lagrp(struct iax_session * session,unsigned int ts)1963 static int iax_send_lagrp(struct iax_session *session, unsigned int ts)
1964 {
1965 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_LAGRP, ts, NULL, 0, -1);
1966 }
1967
iax_send_txcnt(struct iax_session * session)1968 static int iax_send_txcnt(struct iax_session *session)
1969 {
1970 struct iax_ie_data ied;
1971 memset(&ied, 0, sizeof(ied));
1972 iax_ie_append_int(&ied, IAX_IE_TRANSFERID, session->transferid);
1973 return send_command_transfer(session, AST_FRAME_IAX, IAX_COMMAND_TXCNT, 0, ied.buf, ied.pos);
1974 }
1975
iax_send_txrej(struct iax_session * session)1976 static int iax_send_txrej(struct iax_session *session)
1977 {
1978 struct iax_ie_data ied;
1979 memset(&ied, 0, sizeof(ied));
1980 iax_ie_append_int(&ied, IAX_IE_TRANSFERID, session->transferid);
1981 return send_command_transfer(session, AST_FRAME_IAX, IAX_COMMAND_TXREJ, 0, ied.buf, ied.pos);
1982 }
1983
iax_send_txaccept(struct iax_session * session)1984 static int iax_send_txaccept(struct iax_session *session)
1985 {
1986 struct iax_ie_data ied;
1987 memset(&ied, 0, sizeof(ied));
1988 iax_ie_append_int(&ied, IAX_IE_TRANSFERID, session->transferid);
1989 return send_command_transfer(session, AST_FRAME_IAX, IAX_COMMAND_TXACC, 0, ied.buf, ied.pos);
1990 }
1991
iax_send_txready(struct iax_session * session)1992 static int iax_send_txready(struct iax_session *session)
1993 {
1994 struct iax_ie_data ied;
1995 memset(&ied, 0, sizeof(ied));
1996 /* see asterisk chan_iax2.c */
1997 iax_ie_append_short(&ied, IAX_IE_CALLNO, session->callno);
1998 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_TXREADY, 0, ied.buf, ied.pos, -1);
1999 }
2000
iax_auth_reply(struct iax_session * session,char * password,char * challenge,int methods)2001 int iax_auth_reply(struct iax_session *session, char *password, char *challenge, int methods)
2002 {
2003 char reply[16];
2004 struct MD5Context md5;
2005 char realreply[256];
2006 struct iax_ie_data ied;
2007 memset(&ied, 0, sizeof(ied));
2008 if ((methods & IAX_AUTH_MD5) && challenge) {
2009 MD5Init(&md5);
2010 MD5Update(&md5, (const unsigned char *) challenge,
2011 (unsigned int)strlen(challenge));
2012 MD5Update(&md5, (const unsigned char *) password,
2013 (unsigned int)strlen(password));
2014 MD5Final((unsigned char *) reply, &md5);
2015 memset(realreply, 0, sizeof(realreply));
2016 convert_reply(realreply, (unsigned char *) reply);
2017 iax_ie_append_str(&ied, IAX_IE_MD5_RESULT, realreply);
2018 } else {
2019 iax_ie_append_str(&ied, IAX_IE_PASSWORD, password);
2020 }
2021 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_AUTHREP, 0, ied.buf, ied.pos, -1);
2022 }
2023
iax_regauth_reply(struct iax_session * session,char * password,char * challenge,int methods)2024 static int iax_regauth_reply(struct iax_session *session, char *password, char *challenge, int methods)
2025 {
2026 char reply[16];
2027 struct MD5Context md5;
2028 char realreply[256];
2029 struct iax_ie_data ied;
2030 memset(&ied, 0, sizeof(ied));
2031 iax_ie_append_str(&ied, IAX_IE_USERNAME, session->username);
2032 if ((methods & IAX_AUTHMETHOD_MD5) && challenge) {
2033 MD5Init(&md5);
2034 MD5Update(&md5, (const unsigned char *) challenge,
2035 (unsigned int)strlen(challenge));
2036 MD5Update(&md5, (const unsigned char *) password,
2037 (unsigned int)strlen(password));
2038 MD5Final((unsigned char *) reply, &md5);
2039 memset(realreply, 0, sizeof(realreply));
2040 convert_reply(realreply, (unsigned char *) reply);
2041 iax_ie_append_str(&ied, IAX_IE_MD5_RESULT, realreply);
2042 } else {
2043 iax_ie_append_str(&ied, IAX_IE_PASSWORD, password);
2044 }
2045 if (strlen(session->unregreason)) { /* Non-zero unregreason length indicates REGREL */
2046 iax_ie_append_str(&ied, IAX_IE_CAUSE, session->unregreason);
2047 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_REGREL, 0, ied.buf, ied.pos, -1);
2048 } else {
2049 iax_ie_append_short(&ied, IAX_IE_REFRESH, session->refresh);
2050 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_REGREQ, 0, ied.buf, ied.pos, -1);
2051 }
2052 }
2053
2054
iax_dial(struct iax_session * session,char * number)2055 int iax_dial(struct iax_session *session, char *number)
2056 {
2057 struct iax_ie_data ied;
2058 memset(&ied, 0, sizeof(ied));
2059 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, number);
2060 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_DIAL, 0, ied.buf, ied.pos, -1);
2061 }
2062
iax_quelch(struct iax_session * session)2063 int iax_quelch(struct iax_session *session)
2064 {
2065 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_QUELCH, 0, NULL, 0, -1);
2066 }
2067
iax_unquelch(struct iax_session * session)2068 int iax_unquelch(struct iax_session *session)
2069 {
2070 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_UNQUELCH, 0, NULL, 0, -1);
2071 }
2072
iax_dialplan_request(struct iax_session * session,char * number)2073 int iax_dialplan_request(struct iax_session *session, char *number)
2074 {
2075 struct iax_ie_data ied;
2076 memset(&ied, 0, sizeof(ied));
2077 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, number);
2078 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_DPREQ, 0, ied.buf, ied.pos, -1);
2079 }
2080
which_bit(unsigned int i)2081 static inline int which_bit(unsigned int i)
2082 {
2083 char x;
2084 for(x = 0; x < 32; x++) {
2085 if ((1U << x) == i) {
2086 return x + 1;
2087 }
2088 }
2089 return 0;
2090 }
2091
iax_pref_codec_add(struct iax_session * session,unsigned int format)2092 char iax_pref_codec_add(struct iax_session *session, unsigned int format)
2093 {
2094 int diff = (int) 'A';
2095 session->codec_order[session->codec_order_len++] = (which_bit(format)) + diff;
2096 session->codec_order[session->codec_order_len] = '\0';
2097 return session->codec_order[session->codec_order_len-1];
2098 }
2099
2100
iax_pref_codec_del(struct iax_session * session,unsigned int format)2101 void iax_pref_codec_del(struct iax_session *session, unsigned int format)
2102 {
2103 int diff = (int) 'A';
2104 int x;
2105 char old[32];
2106 char remove = which_bit(format) + diff;
2107
2108 strncpy(old, session->codec_order, sizeof(old));
2109 session->codec_order_len = 0;
2110
2111 for (x = 0; x < (int) strlen(old); x++) {
2112 if (old[x] != remove) {
2113 session->codec_order[session->codec_order_len++] = old[x];
2114 }
2115 }
2116 session->codec_order[session->codec_order_len] = '\0';
2117 }
2118
iax_pref_codec_get(struct iax_session * session,unsigned int * array,int len)2119 int iax_pref_codec_get(struct iax_session *session, unsigned int *array, int len)
2120 {
2121 int diff = (int) 'A';
2122 int x;
2123
2124 for (x = 0; x < session->codec_order_len && x < len; x++) {
2125 array[x] = (1 << (session->codec_order[x] - diff - 1));
2126 }
2127
2128 return x;
2129 }
2130
iax_call(struct iax_session * session,const char * cidnum,const char * cidname,const char * ich,const char * lang,int wait,int formats,int capabilities)2131 int iax_call(struct iax_session *session, const char *cidnum, const char *cidname, const char *ich, const char *lang, int wait, int formats, int capabilities)
2132 {
2133 char tmp[256]="";
2134 char *part1, *part2;
2135 int res;
2136 int portno;
2137 char *username, *hostname, *secret, *context, *exten, *dnid;
2138 struct iax_ie_data ied;
2139 struct hostent *hp;
2140 /* We start by parsing up the temporary variable which is of the form of:
2141 [user@]peer[:portno][/exten[@context]] */
2142 if (!ich) {
2143 IAXERROR "Invalid IAX Call Handle\n");
2144 DEBU(G "Invalid IAX Call Handle\n");
2145 return -1;
2146 }
2147 memset(&ied, 0, sizeof(ied));
2148 strncpy(tmp, ich, sizeof(tmp) - 1);
2149 iax_ie_append_short(&ied, IAX_IE_VERSION, IAX_PROTO_VERSION);
2150 if (cidnum)
2151 iax_ie_append_str(&ied, IAX_IE_CALLING_NUMBER, cidnum);
2152 if (cidname)
2153 iax_ie_append_str(&ied, IAX_IE_CALLING_NAME, cidname);
2154
2155 if (session->codec_order_len) {
2156 iax_ie_append_str(&ied, IAX_IE_CODEC_PREFS, session->codec_order);
2157 }
2158
2159 session->capability = capabilities;
2160 session->pingid = iax_sched_add(NULL,NULL, send_ping, (void *)session, 2 * 1000);
2161
2162 /* XXX We should have a preferred format XXX */
2163 iax_ie_append_int(&ied, IAX_IE_FORMAT, formats);
2164 iax_ie_append_int(&ied, IAX_IE_CAPABILITY, capabilities);
2165 if (lang)
2166 iax_ie_append_str(&ied, IAX_IE_LANGUAGE, lang);
2167
2168 /* Part 1 is [user[:password]@]peer[:port] */
2169 part1 = strtok(tmp, "/");
2170
2171 /* Part 2 is exten[@context] if it is anything all */
2172 part2 = strtok(NULL, "/");
2173
2174 if (strchr(part1, '@')) {
2175 username = strtok(part1, "@");
2176 hostname = strtok(NULL, "@");
2177 } else {
2178 username = NULL;
2179 hostname = part1;
2180 }
2181
2182 if (username && strchr(username, ':')) {
2183 username = strtok(username, ":");
2184 secret = strtok(NULL, ":");
2185 } else
2186 secret = NULL;
2187
2188 if(username)
2189 strncpy(session->username, username, sizeof(session->username) - 1);
2190
2191 if(secret)
2192 strncpy(session->secret, secret, sizeof(session->secret) - 1);
2193
2194 if (strchr(hostname, ':')) {
2195 strtok(hostname, ":");
2196 portno = atoi(strtok(NULL, ":"));
2197 } else {
2198 portno = IAX_DEFAULT_PORTNO;
2199 }
2200 if (part2) {
2201 exten = strtok(part2, "@");
2202 dnid = exten;
2203 context = strtok(NULL, "@");
2204 } else {
2205 exten = NULL;
2206 dnid = NULL;
2207 context = NULL;
2208 }
2209 if (username)
2210 iax_ie_append_str(&ied, IAX_IE_USERNAME, username);
2211 if (exten && strlen(exten))
2212 iax_ie_append_str(&ied, IAX_IE_CALLED_NUMBER, exten);
2213 if (dnid && strlen(dnid))
2214 iax_ie_append_str(&ied, IAX_IE_DNID, dnid);
2215 if (context && strlen(context))
2216 iax_ie_append_str(&ied, IAX_IE_CALLED_CONTEXT, context);
2217
2218 /* Setup host connection */
2219 hp = gethostbyname(hostname);
2220 if (!hp) {
2221 snprintf(iax_errstr, sizeof(iax_errstr), "Invalid hostname: %s", hostname);
2222 return -1;
2223 }
2224 memcpy(&session->peeraddr.sin_addr, hp->h_addr, sizeof(session->peeraddr.sin_addr));
2225 session->peeraddr.sin_port = htons(portno);
2226 session->peeraddr.sin_family = AF_INET;
2227 res = send_command(session, AST_FRAME_IAX, IAX_COMMAND_NEW, 0, ied.buf, ied.pos, -1);
2228 if (res < 0)
2229 return res;
2230 if (wait) {
2231 DEBU(G "Waiting not yet implemented\n");
2232 return -1;
2233 }
2234 return res;
2235 }
2236
calc_rxstamp(struct iax_session * session)2237 static int calc_rxstamp(struct iax_session *session)
2238 {
2239 struct timeval tv;
2240 int ms;
2241
2242 if (!session->rxcore.tv_sec && !session->rxcore.tv_usec) {
2243 session->rxcore = iax_tvnow();
2244 }
2245 tv = iax_tvnow();
2246
2247 ms = (tv.tv_sec - session->rxcore.tv_sec) * 1000 +
2248 (tv.tv_usec - session->rxcore.tv_usec) / 1000;
2249 return ms;
2250 }
2251
2252 #ifdef notdef_cruft
match(struct sockaddr_in * sin,short callno,short dcallno,struct iax_session * cur)2253 static int match(struct sockaddr_in *sin, short callno, short dcallno, struct iax_session *cur)
2254 {
2255 if ((cur->peeraddr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2256 (cur->peeraddr.sin_port == sin->sin_port)) {
2257 /* This is the main host */
2258 if ((cur->peercallno == callno) ||
2259 ((dcallno == cur->callno) && !cur->peercallno)) {
2260 /* That's us. Be sure we keep track of the peer call number */
2261 cur->peercallno = callno;
2262 return 1;
2263 }
2264 }
2265 if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2266 (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
2267 /* We're transferring */
2268 if (dcallno == cur->callno)
2269 return 1;
2270 }
2271 return 0;
2272 }
2273 #endif
2274
2275 /* splitted match into 2 passes otherwise causing problem of matching
2276 up the wrong session using the dcallno and the peercallno because
2277 during a transfer (2 IAX channels on the same client/system) the
2278 same peercallno (from two different asterisks) exist in more than
2279 one session.
2280 */
forward_match(struct sockaddr_in * sin,short callno,short dcallno,struct iax_session * cur)2281 static int forward_match(struct sockaddr_in *sin, short callno, short dcallno, struct iax_session *cur)
2282 {
2283 if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2284 (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
2285 /* We're transferring */
2286 if (dcallno == cur->callno)
2287 {
2288 return 1;
2289 }
2290 }
2291
2292 if ((cur->peeraddr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2293 (cur->peeraddr.sin_port == sin->sin_port)) {
2294 if (dcallno == cur->callno && dcallno != 0) {
2295 /* That's us. Be sure we keep track of the peer call number */
2296 if (cur->peercallno == 0) {
2297 cur->peercallno = callno;
2298 }
2299 else if ( cur->peercallno != callno )
2300 {
2301 // print a warning when the callno's don't match
2302 fprintf( stderr, "WARNING: peercallno does not match callno"
2303 ", peercallno => %d, callno => %d, dcallno => %d",
2304 cur->peercallno, callno, dcallno ) ;
2305 return 0 ;
2306 }
2307 return 1;
2308 }
2309 }
2310
2311 return 0;
2312 }
2313
reverse_match(struct sockaddr_in * sin,short callno,struct iax_session * cur)2314 static int reverse_match(struct sockaddr_in *sin, short callno, struct iax_session *cur)
2315 {
2316 if ((cur->transfer.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2317 (cur->transfer.sin_port == sin->sin_port) && (cur->transferring)) {
2318 /* We're transferring */
2319 if (callno == cur->peercallno) {
2320 return 1;
2321 }
2322 }
2323 if ((cur->peeraddr.sin_addr.s_addr == sin->sin_addr.s_addr) &&
2324 (cur->peeraddr.sin_port == sin->sin_port)) {
2325 if (callno == cur->peercallno) {
2326 return 1;
2327 }
2328 }
2329
2330 return 0;
2331 }
2332
iax_find_session(struct sockaddr_in * sin,short callno,short dcallno,int makenew)2333 static struct iax_session *iax_find_session(struct sockaddr_in *sin,
2334 short callno,
2335 short dcallno,
2336 int makenew)
2337 {
2338 struct iax_session *cur = sessions;
2339 while(cur) {
2340 if (forward_match(sin, callno, dcallno, cur)) {
2341 return cur;
2342 }
2343 cur = cur->next;
2344 }
2345
2346 cur = sessions;
2347 while(cur) {
2348 if (reverse_match(sin, callno, cur)) {
2349 return cur;
2350 }
2351 cur = cur->next;
2352 }
2353
2354 if (makenew && !dcallno) {
2355 cur = iax_session_new();
2356 cur->peercallno = callno;
2357 cur->peeraddr.sin_addr.s_addr = sin->sin_addr.s_addr;
2358 cur->peeraddr.sin_port = sin->sin_port;
2359 cur->peeraddr.sin_family = AF_INET;
2360 cur->pingid = iax_sched_add(NULL,NULL, send_ping, (void *)cur, 2 * 1000);
2361 DEBU(G "Making new session, peer callno %d, our callno %d\n", callno, cur->callno);
2362 } else {
2363 DEBU(G "No session, peer = %d, us = %d\n", callno, dcallno);
2364 }
2365 return cur;
2366 }
2367
2368 #ifdef EXTREME_DEBUG
display_time(int ms)2369 static int display_time(int ms)
2370 {
2371 static int oldms = -1;
2372 if (oldms < 0) {
2373 DEBU(G "First measure\n");
2374 oldms = ms;
2375 return 0;
2376 }
2377 DEBU(G "Time from last frame is %d ms\n", ms - oldms);
2378 oldms = ms;
2379 return 0;
2380 }
2381 #endif
2382
2383 /* From chan_iax2/steve davies: need to get permission from steve or digium, I guess */
unwrap_timestamp(long ts,long last)2384 static long unwrap_timestamp(long ts, long last)
2385 {
2386 int x;
2387
2388 if ( (ts & 0xFFFF0000) == (last & 0xFFFF0000) ) {
2389 x = ts - last;
2390 if (x < -50000) {
2391 /* Sudden big jump backwards in timestamp:
2392 What likely happened here is that miniframe
2393 timestamp has circled but we haven't gotten the
2394 update from the main packet. We'll just pretend
2395 that we did, and update the timestamp
2396 appropriately. */
2397 ts = ( (last & 0xFFFF0000) + 0x10000) | (ts & 0xFFFF);
2398 DEBU(G "schedule_delivery: pushed forward timestamp\n");
2399 }
2400 if (x > 50000) {
2401 /* Sudden apparent big jump forwards in timestamp:
2402 What's likely happened is this is an old miniframe
2403 belonging to the previous top-16-bit timestamp that
2404 has turned up out of order. Adjust the timestamp
2405 appropriately. */
2406 ts = ( (last & 0xFFFF0000) - 0x10000) | (ts & 0xFFFF);
2407 DEBU(G "schedule_delivery: pushed back timestamp\n");
2408 }
2409 }
2410 else if ( (ts & 0xFFFF8000L) == (last & 0xFFFF8000L) ) {
2411 x = ts - last;
2412 if (x < -50000) {
2413 /* Sudden big jump backwards in timestamp:
2414 What likely happened here is that miniframe
2415 timestamp has circled but we haven't gotten the
2416 update from the main packet. We'll just pretend
2417 that we did, and update the timestamp
2418 appropriately. */
2419 ts = ( (last & 0xFFFF8000L) + 0x10000) | (ts & 0xFFFF);
2420 DEBU(G "schedule_delivery: pushed forward timestamp\n");
2421 }
2422 if (x > 50000) {
2423 /* Sudden apparent big jump forwards in timestamp:
2424 * What's likely happened is this is an old miniframe
2425 * belonging to the previous top-16-bit timestamp that
2426 * has turned up out of order. Adjust the timestamp
2427 * appropriately. */
2428 ts = ( (last & 0xFFFF8000L) - 0x10000) | (ts & 0xFFFF);
2429 DEBU(G "schedule_delivery: pushed back timestamp\n");
2430 }
2431 }
2432 return ts;
2433 }
2434
2435
schedule_delivery(struct iax_event * e,unsigned int ts,int updatehistory)2436 static struct iax_event *schedule_delivery(struct iax_event *e, unsigned int ts, int updatehistory)
2437 {
2438 /*
2439 * This is the core of the IAX jitterbuffer delivery mechanism:
2440 * Dynamically adjust the jitterbuffer and decide how long to wait
2441 * before delivering the packet.
2442 */
2443
2444 #ifdef EXTREME_DEBUG
2445 DEBU(G "[%p] We are at %d, packet is for %d\n", e->session, calc_rxstamp(e->session), ts);
2446 #endif
2447
2448 /* insert into jitterbuffer */
2449 /* TODO: Perhaps we could act immediately if it's not droppable and late */
2450 if ( !iax_use_jitterbuffer ||
2451 (e->etype == IAX_EVENT_VIDEO &&
2452 video_bypass_jitterbuffer) )
2453 {
2454 iax_sched_add(e, NULL, NULL, NULL, 0);
2455 return NULL;
2456 } else
2457 {
2458 int type = JB_TYPE_CONTROL;
2459 int len = 0;
2460
2461 if(e->etype == IAX_EVENT_VOICE)
2462 {
2463 type = JB_TYPE_VOICE;
2464 /* The frame time only has an effect for voice */
2465 len = get_sample_cnt(e) / 8;
2466 } else if(e->etype == IAX_EVENT_VIDEO)
2467 {
2468 type = JB_TYPE_VIDEO;
2469 } else if(e->etype == IAX_EVENT_CNG)
2470 {
2471 type = JB_TYPE_SILENCE;
2472 }
2473
2474 /* unwrap timestamp */
2475 ts = unwrap_timestamp(ts,e->session->last_ts);
2476
2477 /* move forward last_ts if it's greater. We do this _after_
2478 * unwrapping, because asterisk _still_ has cases where it
2479 * doesn't send full frames when it ought to */
2480 if(ts > e->session->last_ts)
2481 {
2482 e->session->last_ts = ts;
2483 }
2484
2485 if(jb_put(e->session->jb, e, type, len, ts,
2486 calc_rxstamp(e->session)) == JB_DROP)
2487 {
2488 iax_event_free(e);
2489 }
2490 }
2491
2492 return NULL;
2493 }
2494
uncompress_subclass(unsigned char csub)2495 static int uncompress_subclass(unsigned char csub)
2496 {
2497 /* If the SC_LOG flag is set, return 2^csub otherwise csub */
2498 if (csub & IAX_FLAG_SC_LOG)
2499 return 1 << (csub & ~IAX_FLAG_SC_LOG & IAX_MAX_SHIFT);
2500 else
2501 return csub;
2502 }
2503
iax_handle_vnak(struct iax_session * session,struct ast_iax2_full_hdr * fh)2504 static void iax_handle_vnak(struct iax_session *session, struct ast_iax2_full_hdr *fh)
2505 {
2506 struct iax_sched *sch, *list, *l, *tmp;
2507
2508 /*
2509 * According to the IAX2 02 draft, we MUST immediately retransmit all frames
2510 * with higher sequence number than the VNAK's iseqno
2511 * However, it seems that the right thing to do would be to retransmit
2512 * frames with sequence numbers higher OR EQUAL to VNAK's iseqno.
2513 */
2514 sch = schedq;
2515 list = NULL;
2516 while ( sch != NULL )
2517 {
2518 if ( sch->frame != NULL &&
2519 sch->frame->session == session
2520 )
2521 {
2522 /*
2523 * We want to check if our frame's oseqno is greater or equal than
2524 * the VNAK's iseqno, but we need to take into account sequence
2525 * number wrap-arounds
2526 * session->rseqno is our last acknowledged sequence number, so
2527 * we use that as a base
2528 */
2529 if ( (unsigned char)(fh->iseqno - session->rseqno) <= (unsigned char)(sch->frame->oseqno - session->rseqno) )
2530 {
2531 /*
2532 * We cannot retransmit immediately, since the frames are ordered by retransmit time
2533 * We need to collect them and orrange them in ascending order of their oseqno
2534 */
2535 tmp = (struct iax_sched *)calloc(1, sizeof(struct iax_sched));
2536 tmp->frame = sch->frame;
2537
2538 if ( list == NULL ||
2539 (list->frame->oseqno - session->rseqno) > (tmp->frame->oseqno - session->rseqno)
2540 )
2541 {
2542 tmp->next = list;
2543 list = tmp;
2544 } else
2545 {
2546 l = list;
2547 while ( l != NULL )
2548 {
2549 if ( l->next == NULL ||
2550 (l->next->frame->oseqno - session->rseqno) > (tmp->frame->oseqno - session->rseqno)
2551 )
2552 {
2553 tmp->next = l->next;
2554 l->next = tmp;
2555 break;
2556 }
2557 l = l->next;
2558 }
2559 }
2560 }
2561 }
2562 sch = sch->next;
2563 }
2564
2565 /* Transmit collected frames and free the space */
2566 while ( list != NULL )
2567 {
2568 tmp = list;
2569 iax_xmit_frame(tmp->frame);
2570 list = list->next;
2571 free(tmp);
2572 }
2573 }
2574
iax_header_to_event(struct iax_session * session,struct ast_iax2_full_hdr * fh,int datalen,struct sockaddr_in * sin)2575 static struct iax_event *iax_header_to_event(struct iax_session *session, struct ast_iax2_full_hdr *fh, int datalen, struct sockaddr_in *sin)
2576 {
2577 struct iax_event *e;
2578 struct iax_sched *sch;
2579 unsigned int ts;
2580 int subclass;
2581 int nowts;
2582 int updatehistory = 1;
2583 ts = ntohl(fh->ts);
2584
2585 if (fh->type==AST_FRAME_VIDEO)
2586 subclass = uncompress_subclass(fh->csub & ~0x40) | ((fh->csub >> 6) & 0x1);
2587 else
2588 subclass = uncompress_subclass(fh->csub);
2589
2590 /* don't run last_ts backwards; i.e. for retransmits and the like */
2591 if (ts > session->last_ts &&
2592 (fh->type == AST_FRAME_IAX &&
2593 subclass != IAX_COMMAND_ACK &&
2594 subclass != IAX_COMMAND_PONG &&
2595 subclass != IAX_COMMAND_LAGRP))
2596 {
2597 session->last_ts = ts;
2598 }
2599
2600 #ifdef DEBUG_SUPPORT
2601 if (debug)
2602 iax_showframe(NULL, fh, 1, sin, datalen);
2603 #endif
2604
2605 /* Get things going with it, timestamp wise, if we
2606 haven't already. */
2607
2608 /* Handle implicit ACKing unless this is an INVAL, and only if this is
2609 from the real peer, not the transfer peer */
2610 if ( !inaddrcmp(sin, &session->peeraddr) &&
2611 ( subclass != IAX_COMMAND_INVAL ||
2612 fh->type != AST_FRAME_IAX
2613 )
2614 )
2615 {
2616 unsigned char x;
2617 /* XXX This code is not very efficient. Surely there is a better way which still
2618 properly handles boundary conditions? XXX */
2619 /* First we have to qualify that the ACKed value is within our window */
2620 for (x=session->rseqno; x != session->oseqno; x++)
2621 if (fh->iseqno == x)
2622 break;
2623 if ((x != session->oseqno) || (session->oseqno == fh->iseqno))
2624 {
2625 /* The acknowledgement is within our window. Time to acknowledge everything
2626 that it says to */
2627 for (x=session->rseqno; x != fh->iseqno; x++)
2628 {
2629 /* Ack the packet with the given timestamp */
2630 DEBU(G "Cancelling transmission of packet %d\n", x);
2631 sch = schedq;
2632 while(sch)
2633 {
2634 if ( sch->frame &&
2635 sch->frame->session == session &&
2636 sch->frame->oseqno == x
2637 )
2638 sch->frame->retries = -1;
2639 sch = sch->next;
2640 }
2641 }
2642 /* Note how much we've received acknowledgement for */
2643 session->rseqno = fh->iseqno;
2644 } else
2645 DEBU(G "Received iseqno %d not within window %d->%d\n", fh->iseqno, session->rseqno, session->oseqno);
2646 }
2647
2648 /* Check where we are */
2649 if ((ntohs(fh->dcallno) & IAX_FLAG_RETRANS) ||
2650 ((fh->type != AST_FRAME_VOICE) && (fh->type != AST_FRAME_VIDEO)))
2651 updatehistory = 0;
2652 if ((session->iseqno != fh->oseqno) &&
2653 (session->iseqno ||
2654 ((subclass != IAX_COMMAND_TXREADY) &&
2655 (subclass != IAX_COMMAND_TXREL) &&
2656 (subclass != IAX_COMMAND_TXCNT) &&
2657 (subclass != IAX_COMMAND_TXACC)) ||
2658 (fh->type != AST_FRAME_IAX)))
2659 {
2660 if (
2661 ((subclass != IAX_COMMAND_ACK) &&
2662 (subclass != IAX_COMMAND_INVAL) &&
2663 (subclass != IAX_COMMAND_TXREADY) &&
2664 (subclass != IAX_COMMAND_TXREL) &&
2665 (subclass != IAX_COMMAND_TXCNT) &&
2666 (subclass != IAX_COMMAND_TXACC) &&
2667 (subclass != IAX_COMMAND_VNAK)) ||
2668 (fh->type != AST_FRAME_IAX))
2669 {
2670 /* If it's not an ACK packet, it's out of order. */
2671 DEBU(G "Packet arrived out of order (expecting %d, got %d) (frametype = %d, subclass = %d)\n",
2672 session->iseqno, fh->oseqno, fh->type, subclass);
2673
2674 /*
2675 * Check if session->iseqno > fh->oseqno, accounting for possible wrap around
2676 * This is correct if the two values are not equal (which, in this case, is guaranteed)
2677 */
2678 if ( (unsigned char)(session->iseqno - fh->oseqno) < 128 )
2679 {
2680 /* If we've already seen it, ack it XXX There's a border condition here XXX */
2681 if ((fh->type != AST_FRAME_IAX) ||
2682 ((subclass != IAX_COMMAND_ACK) && (subclass != IAX_COMMAND_INVAL)))
2683 {
2684 DEBU(G "Acking anyway\n");
2685 /* XXX Maybe we should handle its ack to us, but then again, it's probably outdated anyway, and if
2686 we have anything to send, we'll retransmit and get an ACK back anyway XXX */
2687 send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, ts, NULL, 0,fh->iseqno);
2688 }
2689 } else
2690 {
2691 /* Send a VNAK requesting retransmission */
2692 iax2_vnak(session);
2693 }
2694 return NULL;
2695 }
2696 } else
2697 {
2698 /* Increment unless it's an ACK or VNAK */
2699 if (((subclass != IAX_COMMAND_ACK) &&
2700 (subclass != IAX_COMMAND_INVAL) &&
2701 (subclass != IAX_COMMAND_TXCNT) &&
2702 (subclass != IAX_COMMAND_TXACC) &&
2703 (subclass != IAX_COMMAND_VNAK)) ||
2704 (fh->type != AST_FRAME_IAX))
2705 session->iseqno++;
2706 }
2707
2708 e = (struct iax_event *)malloc(sizeof(struct iax_event) + datalen + 1);
2709
2710 if (e) {
2711 memset(e, 0, sizeof(struct iax_event) + datalen);
2712 /* Set etype to some unknown value so do not inavertently
2713 sending IAX_EVENT_CONNECT event, which is 0 to application.
2714 */
2715 e->etype = -1;
2716 e->session = session;
2717 switch(fh->type) {
2718 case AST_FRAME_DTMF:
2719 e->etype = IAX_EVENT_DTMF;
2720 e->subclass = subclass;
2721 /*
2722 We want the DTMF event deliver immediately so all I/O can be
2723 terminate quickly in an IVR system.
2724 e = schedule_delivery(e, ts, updatehistory); */
2725 break;
2726 case AST_FRAME_VOICE:
2727 e->etype = IAX_EVENT_VOICE;
2728 e->subclass = subclass;
2729 e->ts = ts;
2730 session->voiceformat = subclass;
2731 if (datalen) {
2732 memcpy(e->data, fh->iedata, datalen);
2733 e->datalen = datalen;
2734 }
2735 e = schedule_delivery(e, ts, updatehistory);
2736 break;
2737 case AST_FRAME_CNG:
2738 e->etype = IAX_EVENT_CNG;
2739 e->subclass = subclass;
2740 if (datalen) {
2741 memcpy(e->data, fh->iedata, datalen);
2742 e->datalen = datalen;
2743 }
2744 e = schedule_delivery(e, ts, updatehistory);
2745 break;
2746 case AST_FRAME_IAX:
2747 /* Parse IE's */
2748 if (datalen) {
2749 memcpy(e->data, fh->iedata, datalen);
2750 e->datalen = datalen;
2751 }
2752 if (iax_parse_ies(&e->ies, e->data, e->datalen)) {
2753 IAXERROR "Unable to parse IE's");
2754 free(e);
2755 e = NULL;
2756 break;
2757 }
2758 switch(subclass) {
2759 case IAX_COMMAND_NEW:
2760 /* This is a new, incoming call */
2761 /* save the capability for validation */
2762 session->capability = e->ies.capability;
2763 if (e->ies.codec_prefs) {
2764 strncpy(session->codec_order,
2765 e->ies.codec_prefs,
2766 sizeof(session->codec_order));
2767 session->codec_order_len =
2768 (int)strlen(session->codec_order);
2769 }
2770 e->etype = IAX_EVENT_CONNECT;
2771 e = schedule_delivery(e, ts, updatehistory);
2772 break;
2773 case IAX_COMMAND_AUTHREQ:
2774 /* This is a request for a call */
2775 e->etype = IAX_EVENT_AUTHRQ;
2776 if (strlen(session->username) && !strcmp(e->ies.username, session->username) &&
2777 strlen(session->secret)) {
2778 /* Hey, we already know this one */
2779 iax_auth_reply(session, session->secret, e->ies.challenge, e->ies.authmethods);
2780 free(e);
2781 e = NULL;
2782 break;
2783 }
2784 e = schedule_delivery(e, ts, updatehistory);
2785 break;
2786 case IAX_COMMAND_HANGUP:
2787 e->etype = IAX_EVENT_HANGUP;
2788 e = schedule_delivery(e, ts, updatehistory);
2789 break;
2790 case IAX_COMMAND_INVAL:
2791 e->etype = IAX_EVENT_HANGUP;
2792 e = schedule_delivery(e, ts, updatehistory);
2793 break;
2794 case IAX_COMMAND_REJECT:
2795 e->etype = IAX_EVENT_REJECT;
2796 e = schedule_delivery(e, ts, updatehistory);
2797 break;
2798 case IAX_COMMAND_ACK:
2799 free(e);
2800 e = NULL;
2801 break;
2802 case IAX_COMMAND_VNAK:
2803 iax_handle_vnak(session, fh);
2804 free(e);
2805 e = NULL;
2806 break;
2807 case IAX_COMMAND_LAGRQ:
2808 /* Pass this along for later handling */
2809 e->etype = IAX_EVENT_LAGRQ;
2810 e->ts = ts;
2811 e = schedule_delivery(e, ts, updatehistory);
2812 break;
2813 case IAX_COMMAND_POKE:
2814 e->etype = IAX_EVENT_POKE;
2815 e->ts = ts;
2816 break;
2817 case IAX_COMMAND_PING:
2818 /* PINGS and PONGS don't get scheduled; */
2819 e->etype = IAX_EVENT_PING;
2820 e->ts = ts;
2821 break;
2822 case IAX_COMMAND_PONG:
2823 e->etype = IAX_EVENT_PONG;
2824 /* track weighted average of ping time */
2825 session->pingtime = ((2 * session->pingtime) + (calc_timestamp(session,0,NULL) - ts)) / 3;
2826 session->remote_netstats.jitter = e->ies.rr_jitter;
2827 session->remote_netstats.losspct = e->ies.rr_loss >> 24;;
2828 session->remote_netstats.losscnt = e->ies.rr_loss & 0xffffff;
2829 session->remote_netstats.packets = e->ies.rr_pkts;
2830 session->remote_netstats.delay = e->ies.rr_delay;
2831 session->remote_netstats.dropped = e->ies.rr_dropped;
2832 session->remote_netstats.ooo = e->ies.rr_ooo;
2833 break;
2834 case IAX_COMMAND_ACCEPT:
2835 if (e->ies.format & session->capability) {
2836 e->etype = IAX_EVENT_ACCEPT;
2837 }
2838 else {
2839 struct iax_ie_data ied;
2840 /* Although this should not happen, we
2841 * added this to make sure the
2842 * negotiation protocol is enforced.
2843 * For lack of event to notify the
2844 * application we use the defined
2845 * REJECT event.
2846 */
2847 memset(&ied, 0, sizeof(ied));
2848 iax_ie_append_str(&ied, IAX_IE_CAUSE, "Unable to negotiate codec");
2849 send_command_final(session, AST_FRAME_IAX, IAX_COMMAND_REJECT, 0, ied.buf, ied.pos, -1);
2850 e->etype = IAX_EVENT_REJECT;
2851 }
2852 e = schedule_delivery(e, ts, updatehistory);
2853 break;
2854 case IAX_COMMAND_REGACK:
2855 e->etype = IAX_EVENT_REGACK;
2856 e = schedule_delivery(e, ts, updatehistory);
2857 break;
2858 case IAX_COMMAND_REGAUTH:
2859 iax_regauth_reply(session, session->secret, e->ies.challenge, e->ies.authmethods);
2860 free(e);
2861 e = NULL;
2862 break;
2863 case IAX_COMMAND_REGREJ:
2864 e->etype = IAX_EVENT_REGREJ;
2865 e = schedule_delivery(e, ts, updatehistory);
2866 break;
2867 case IAX_COMMAND_LAGRP:
2868 e->etype = IAX_EVENT_LAGRP;
2869 nowts = calc_timestamp(session, 0, NULL);
2870 e->ts = nowts - ts;
2871 /* Can't call schedule_delivery since timestamp is non-normal */
2872 break;;
2873 case IAX_COMMAND_TXREQ:
2874 /* added check for defensive programming
2875 * - in case the asterisk server
2876 * or another client does not send the
2877 * apparent transfer address
2878 */
2879 if (e->ies.apparent_addr != NULL) {
2880 /* so a full voice frame is sent on the
2881 next voice output */
2882 session->svoiceformat = -1;
2883 session->transfer = *e->ies.apparent_addr;
2884 session->transfer.sin_family = AF_INET;
2885 session->transfercallno = e->ies.callno;
2886 session->transferring = TRANSFER_BEGIN;
2887 session->transferid = e->ies.transferid;
2888 iax_send_txcnt(session);
2889 }
2890 free(e);
2891 e = NULL;
2892 break;
2893 case IAX_COMMAND_DPREP:
2894 /* Received dialplan reply */
2895 e->etype = IAX_EVENT_DPREP;
2896 /* Return immediately, makes no sense to schedule */
2897 break;
2898 case IAX_COMMAND_TXCNT:
2899 if (session->transferring) {
2900 session->transfer = *sin;
2901 iax_send_txaccept(session);
2902 }
2903 free(e);
2904 e = NULL;
2905 break;
2906 case IAX_COMMAND_TXACC:
2907 if (session->transferring) {
2908 stop_transfer(session);
2909 session->transferring = TRANSFER_READY;
2910 iax_send_txready(session);
2911 }
2912 free(e);
2913 e = NULL;
2914 break;
2915 case IAX_COMMAND_TXREL:
2916 /* Release the transfer */
2917 send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, ts, NULL, 0, fh->iseqno);
2918 if (session->transferring) {
2919 complete_transfer(session, e->ies.callno, 1, 0);
2920 }
2921 else {
2922 complete_transfer(session, session->peercallno, 0, 1);
2923 }
2924 e->etype = IAX_EVENT_TRANSFER;
2925 /* notify that asterisk no longer sitting between peers */
2926 e = schedule_delivery(e, ts, updatehistory);
2927 break;
2928 case IAX_COMMAND_QUELCH:
2929 e->etype = IAX_EVENT_QUELCH;
2930 session->quelch = 1;
2931 break;
2932 case IAX_COMMAND_UNQUELCH:
2933 e->etype = IAX_EVENT_UNQUELCH;
2934 session->quelch = 0;
2935 break;
2936 case IAX_COMMAND_TXREJ:
2937 e->etype = IAX_EVENT_TXREJECT;
2938 iax_handle_txreject(session);
2939 break;
2940
2941 case IAX_COMMAND_TXREADY:
2942 send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, ts, NULL, 0, fh->iseqno);
2943 if (iax_handle_txready(session)) {
2944 e->etype = IAX_EVENT_TXREADY;
2945 }
2946 else {
2947 free(e);
2948 e = NULL;
2949 }
2950 break;
2951 default:
2952 DEBU(G "Don't know what to do with IAX command %d\n", subclass);
2953 free(e);
2954 e = NULL;
2955 }
2956 break;
2957 case AST_FRAME_CONTROL:
2958 switch(subclass) {
2959 case AST_CONTROL_ANSWER:
2960 e->etype = IAX_EVENT_ANSWER;
2961 e = schedule_delivery(e, ts, updatehistory);
2962 break;
2963 case AST_CONTROL_CONGESTION:
2964 case AST_CONTROL_BUSY:
2965 e->etype = IAX_EVENT_BUSY;
2966 e = schedule_delivery(e, ts, updatehistory);
2967 break;
2968 case AST_CONTROL_RINGING:
2969 e->etype = IAX_EVENT_RINGA;
2970 e = schedule_delivery(e, ts, updatehistory);
2971 break;
2972 default:
2973 DEBU(G "Don't know what to do with AST control %d\n", subclass);
2974 free(e);
2975 return NULL;
2976 }
2977 break;
2978 case AST_FRAME_IMAGE:
2979 e->etype = IAX_EVENT_IMAGE;
2980 e->subclass = subclass;
2981 if (datalen) {
2982 memcpy(e->data, fh->iedata, datalen);
2983 }
2984 e = schedule_delivery(e, ts, updatehistory);
2985 break;
2986 case AST_FRAME_VIDEO:
2987 e->etype = IAX_EVENT_VIDEO;
2988 e->subclass = subclass;
2989 e->ts = ts;
2990 session->videoformat = e->subclass;
2991 memcpy(e->data, fh->iedata, datalen);
2992 e->datalen = datalen;
2993 e = schedule_delivery(e, ts, updatehistory);
2994 break;
2995 case AST_FRAME_TEXT:
2996 e->etype = IAX_EVENT_TEXT;
2997 if (datalen) {
2998 memcpy(e->data, fh->iedata, datalen);
2999 e->datalen = datalen;
3000 }
3001 e = schedule_delivery(e, ts, updatehistory);
3002 break;
3003
3004 case AST_FRAME_HTML:
3005 switch(fh->csub) {
3006 case AST_HTML_LINKURL:
3007 e->etype = IAX_EVENT_LINKURL;
3008 /* Fall through */
3009 case AST_HTML_URL:
3010 if (e->etype == -1)
3011 e->etype = IAX_EVENT_URL;
3012 e->subclass = fh->csub;
3013 e->datalen = datalen;
3014 if (datalen) {
3015 memcpy(e->data, fh->iedata, datalen);
3016 }
3017 e = schedule_delivery(e, ts, updatehistory);
3018 break;
3019 case AST_HTML_LDCOMPLETE:
3020 e->etype = IAX_EVENT_LDCOMPLETE;
3021 e = schedule_delivery(e, ts, updatehistory);
3022 break;
3023 case AST_HTML_UNLINK:
3024 e->etype = IAX_EVENT_UNLINK;
3025 e = schedule_delivery(e, ts, updatehistory);
3026 break;
3027 case AST_HTML_LINKREJECT:
3028 e->etype = IAX_EVENT_LINKREJECT;
3029 e = schedule_delivery(e, ts, updatehistory);
3030 break;
3031 default:
3032 DEBU(G "Don't know how to handle HTML type %d frames\n", fh->csub);
3033 free(e);
3034 return NULL;
3035 }
3036 break;
3037 default:
3038 DEBU(G "Don't know what to do with frame type %d\n", fh->type);
3039 free(e);
3040 return NULL;
3041 }
3042 } else
3043 DEBU(G "Out of memory\n");
3044
3045 /* Already ack'd iax frames */
3046 if (session->aseqno != session->iseqno) {
3047 send_command_immediate(session, AST_FRAME_IAX, IAX_COMMAND_ACK, ts, NULL, 0, fh->iseqno);
3048 }
3049 return e;
3050 }
3051
3052 /* Some parts taken from iax_miniheader_to_event and from from chan_iax2.c. We must inform Mark Spencer? */
iax_videoheader_to_event(struct iax_session * session,struct ast_iax2_video_hdr * vh,int datalen)3053 static struct iax_event *iax_videoheader_to_event(struct iax_session *session,
3054 struct ast_iax2_video_hdr *vh, int datalen)
3055 {
3056 struct iax_event * e;
3057
3058 if ( session->videoformat <= 0 )
3059 {
3060 DEBU(G "No last video format received on session %d\n",
3061 session->callno);
3062 return 0;
3063 }
3064
3065 e = (struct iax_event *)malloc(sizeof(struct iax_event) + datalen);
3066
3067 if ( !e )
3068 {
3069 DEBU(G "Out of memory\n");
3070 return 0;
3071 }
3072
3073 e->etype = IAX_EVENT_VIDEO;
3074 e->session = session;
3075 e->subclass = session->videoformat | (ntohs(vh->ts) & 0x8000 ? 1 : 0);
3076 e->datalen = datalen;
3077 memcpy(e->data, vh->data, e->datalen);
3078 e->ts = (session->last_ts & 0xFFFF8000L) | (ntohs(vh->ts) & 0x7fff);
3079
3080 return schedule_delivery(e, e->ts, 1);
3081 }
3082
iax_miniheader_to_event(struct iax_session * session,struct ast_iax2_mini_hdr * mh,int datalen)3083 static struct iax_event *iax_miniheader_to_event(struct iax_session *session,
3084 struct ast_iax2_mini_hdr *mh, int datalen)
3085 {
3086 struct iax_event * e;
3087
3088 if ( session->voiceformat <= 0 )
3089 {
3090 DEBU(G "No last format received on session %d\n", session->callno);
3091 return 0;
3092 }
3093
3094 e = (struct iax_event *)malloc(sizeof(struct iax_event) + datalen);
3095
3096 if ( !e )
3097 {
3098 DEBU(G "Out of memory\n");
3099 return 0;
3100 }
3101
3102 e->etype = IAX_EVENT_VOICE;
3103 e->session = session;
3104 e->subclass = session->voiceformat;
3105 e->datalen = datalen;
3106 memcpy(e->data, mh->data, datalen);
3107 e->ts = (session->last_ts & 0xFFFF0000) | ntohs(mh->ts);
3108
3109 return schedule_delivery(e, e->ts, 1);
3110 }
3111
iax_destroy(struct iax_session * session)3112 void iax_destroy(struct iax_session *session)
3113 {
3114 destroy_session(session);
3115 }
3116
iax_net_read(void)3117 static struct iax_event *iax_net_read(void)
3118 {
3119 unsigned char buf[65536];
3120 int res;
3121 struct sockaddr_in sin;
3122 socklen_t sinlen;
3123 struct iax_event *event;
3124
3125 sinlen = sizeof(sin);
3126 res = iax_recvfrom(netfd, (char *)buf, sizeof(buf), 0, (struct sockaddr *) &sin, &sinlen);
3127 if (res < 0) {
3128 #if defined(_WIN32_WCE)
3129 if (WSAGetLastError() != WSAEWOULDBLOCK) {
3130 DEBU(G "Error on read: %d\n", WSAGetLastError());
3131 IAXERROR "Read error on network socket: ???");
3132 }
3133 #elif defined(WIN32) || defined(_WIN32_WCE)
3134 if (WSAGetLastError() != WSAEWOULDBLOCK) {
3135 DEBU(G "Error on read: %d\n", WSAGetLastError());
3136 IAXERROR "Read error on network socket: %s", strerror(errno));
3137 }
3138 #else
3139 if (errno != EAGAIN) {
3140 DEBU(G "Error on read: %s\n", strerror(errno));
3141 IAXERROR "Read error on network socket: %s", strerror(errno));
3142 }
3143 #endif
3144 return NULL;
3145 }
3146 event = iax_net_process(buf, res, &sin);
3147 if ( event == NULL )
3148 {
3149 // We have received a frame. The corresponding event is queued
3150 // We need to motify the entire stack of calling functions so they
3151 // don't go to sleep thinking there are no more frames to process
3152 // TODO: this is buttugly from a design point of view. Basically we
3153 // change libiax2 behavior to accomodate iaxclient.
3154 // There must be a way to do it better.
3155 event = (struct iax_event *)malloc(sizeof(struct iax_event));
3156 if ( event != NULL ) event->etype = IAX_EVENT_NULL;
3157 }
3158 return event;
3159 }
3160
iax_txcnt_session(struct ast_iax2_full_hdr * fh,int datalen,struct sockaddr_in * sin,short callno,short dcallno)3161 static struct iax_session *iax_txcnt_session(struct ast_iax2_full_hdr *fh, int datalen,
3162 struct sockaddr_in *sin, short callno, short dcallno)
3163 {
3164 int subclass = uncompress_subclass(fh->csub);
3165 unsigned char buf[ 65536 ]; /* allocated on stack with same size as iax_net_read() */
3166 struct iax_ies ies;
3167 struct iax_session *cur;
3168
3169 if ((fh->type != AST_FRAME_IAX) || (subclass != IAX_COMMAND_TXCNT) || (!datalen)) {
3170 return NULL; /* special handling for TXCNT only */
3171 }
3172 memcpy(buf, fh->iedata, datalen); /* prepare local buf for iax_parse_ies() */
3173
3174 if (iax_parse_ies(&ies, buf, datalen)) {
3175 return NULL; /* Unable to parse IE's */
3176 }
3177 if (!ies.transferid) {
3178 return NULL; /* TXCNT without proper IAX_IE_TRANSFERID */
3179 }
3180 for( cur=sessions; cur; cur=cur->next ) {
3181 if ((cur->transferring) && (cur->transferid == (int) ies.transferid) &&
3182 (cur->callno == dcallno) && (cur->transfercallno == callno)) {
3183 /* We're transferring ---
3184 * skip address/port checking which would fail while
3185 * remote peer behind symmetric NAT, verify
3186 * transferid instead
3187 */
3188 cur->transfer.sin_addr.s_addr = sin->sin_addr.s_addr; /* setup for further handling */
3189 cur->transfer.sin_port = sin->sin_port;
3190 break;
3191 }
3192 }
3193 return cur;
3194 }
3195
iax_net_process(unsigned char * buf,int len,struct sockaddr_in * sin)3196 struct iax_event *iax_net_process(unsigned char *buf, int len, struct sockaddr_in *sin)
3197 {
3198 struct ast_iax2_full_hdr *fh = (struct ast_iax2_full_hdr *)buf;
3199 struct ast_iax2_mini_hdr *mh = (struct ast_iax2_mini_hdr *)buf;
3200 struct ast_iax2_video_hdr *vh = (struct ast_iax2_video_hdr *)buf;
3201 struct iax_session *session;
3202
3203 if (ntohs(fh->scallno) & IAX_FLAG_FULL) {
3204 /* Full size header */
3205 if ((size_t)len < sizeof(struct ast_iax2_full_hdr)) {
3206 DEBU(G "Short header received from %s\n", inet_ntoa(sin->sin_addr));
3207 IAXERROR "Short header received from %s\n", inet_ntoa(sin->sin_addr));
3208 return NULL;
3209 }
3210 /* We have a full header, process appropriately */
3211 session = iax_find_session(sin,
3212 ntohs(fh->scallno) & ~IAX_FLAG_FULL,
3213 ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS, 1);
3214 if (!session)
3215 session = iax_txcnt_session(fh,
3216 len - sizeof(struct ast_iax2_full_hdr),
3217 sin, ntohs(fh->scallno) & ~IAX_FLAG_FULL,
3218 ntohs(fh->dcallno) & ~IAX_FLAG_RETRANS);
3219 if (session)
3220 return iax_header_to_event(session, fh, len - sizeof(struct ast_iax2_full_hdr), sin);
3221 DEBU(G "No session?\n");
3222 return NULL;
3223 } else {
3224 if ((size_t)len < sizeof(struct ast_iax2_mini_hdr)) {
3225 DEBU(G "Short header received from %s\n", inet_ntoa(sin->sin_addr));
3226 IAXERROR "Short header received from %s\n", inet_ntoa(sin->sin_addr));
3227 return NULL;
3228 }
3229 /* Miniature, voice frame */
3230 if ((vh->zeros == 0) && (ntohs(vh->callno) & 0x8000))
3231 {
3232 session = iax_find_session(sin, ntohs(vh->callno) & ~0x8000, 0, 0);
3233
3234 if (session)
3235 return iax_videoheader_to_event(session, vh,
3236 len - sizeof(struct ast_iax2_video_hdr));
3237 } else {
3238 /* audio frame */
3239 session = iax_find_session(sin, ntohs(fh->scallno), 0, 0);
3240 if (session)
3241 return iax_miniheader_to_event(session, mh,
3242 len - sizeof(struct ast_iax2_mini_hdr));
3243 }
3244 DEBU(G "No session?\n");
3245 return NULL;
3246 }
3247 }
3248
iax_get_sched(struct timeval tv)3249 static struct iax_sched *iax_get_sched(struct timeval tv)
3250 {
3251 struct iax_sched *cur, *prev=NULL;
3252 cur = schedq;
3253 /* Check the event schedule first. */
3254 while(cur) {
3255 if ((tv.tv_sec > cur->when.tv_sec) ||
3256 ((tv.tv_sec == cur->when.tv_sec) &&
3257 (tv.tv_usec >= cur->when.tv_usec))) {
3258 /* Take it out of the event queue */
3259 if (prev) {
3260 prev->next = cur->next;
3261 } else {
3262 schedq = cur->next;
3263 }
3264 return cur;
3265 }
3266 cur = cur->next;
3267 }
3268 return NULL;
3269 }
3270
iax_get_event(int blocking)3271 struct iax_event *iax_get_event(int blocking)
3272 {
3273 struct iax_event *event;
3274 struct iax_frame *frame;
3275 struct timeval tv;
3276 struct iax_sched *cur;
3277 struct iax_session *session;
3278
3279 tv = iax_tvnow();
3280
3281 while((cur = iax_get_sched(tv)))
3282 {
3283 event = cur->event;
3284 frame = cur->frame;
3285 if (event)
3286 {
3287 /* See if this is an event we need to handle */
3288 event = handle_event(event);
3289 if (event)
3290 {
3291 free(cur);
3292 return event;
3293 }
3294 } else if(frame)
3295 {
3296 /* It's a frame, transmit it and schedule a retry */
3297 if (frame->retries < 0)
3298 {
3299 /* It's been acked. No need to send it. Destroy the old
3300 frame. If final, destroy the session. */
3301 if (frame->final)
3302 destroy_session(frame->session);
3303 if (frame->data)
3304 free(frame->data);
3305 free(frame);
3306 } else if (frame->retries == 0)
3307 {
3308 if (frame->transfer)
3309 {
3310 /* Send a transfer reject since we weren't able to connect */
3311 iax_send_txrej(frame->session);
3312 if (frame->data)
3313 free(frame->data);
3314 free(frame);
3315 free(cur);
3316 break;
3317 } else
3318 {
3319 /* We haven't been able to get an ACK on this packet. If a
3320 final frame, destroy the session, otherwise, pass up timeout */
3321 if (frame->final)
3322 {
3323 destroy_session(frame->session);
3324 if (frame->data)
3325 free(frame->data);
3326 free(frame);
3327 } else
3328 {
3329 event = (struct iax_event *)malloc(sizeof(struct iax_event));
3330 if (event)
3331 {
3332 event->etype = IAX_EVENT_TIMEOUT;
3333 event->session = frame->session;
3334 if (frame->data)
3335 free(frame->data);
3336 free(frame);
3337 free(cur);
3338 return handle_event(event);
3339 }
3340 }
3341 }
3342 } else
3343 {
3344 struct ast_iax2_full_hdr *fh;
3345 /* Decrement remaining retries */
3346 frame->retries--;
3347 /* Multiply next retry time by 4, not above MAX_RETRY_TIME though */
3348 frame->retrytime *= 4;
3349 /* Keep under 1000 ms if this is a transfer packet */
3350 if (!frame->transfer)
3351 {
3352 if (frame->retrytime > MAX_RETRY_TIME)
3353 frame->retrytime = MAX_RETRY_TIME;
3354 } else if (frame->retrytime > 1000)
3355 frame->retrytime = 1000;
3356 fh = (struct ast_iax2_full_hdr *)(frame->data);
3357 fh->dcallno = htons(IAX_FLAG_RETRANS | frame->dcallno);
3358 iax_xmit_frame(frame);
3359 /* Schedule another retransmission */
3360 DEBU(G "Scheduling retransmission %d\n", frame->retries);
3361 iax_sched_add(NULL, frame, NULL, NULL, frame->retrytime);
3362 }
3363 } else if (cur->func)
3364 {
3365 cur->func(cur->arg);
3366 }
3367 free(cur);
3368 }
3369
3370 /* get jitterbuffer-scheduled events */
3371 for ( session = sessions; session; session = session->next )
3372 {
3373 int ret;
3374 long now;
3375 long next;
3376 jb_frame frame;
3377
3378 now = (tv.tv_sec - session->rxcore.tv_sec) * 1000 +
3379 (tv.tv_usec - session->rxcore.tv_usec) / 1000;
3380
3381 if ( now <= (next = jb_next(session->jb)) )
3382 continue;
3383
3384 /* interp len no longer hardcoded, now determined by get_interp_len */
3385 ret = jb_get(session->jb,&frame,now,get_interp_len(session->voiceformat));
3386
3387 switch(ret) {
3388 case JB_OK:
3389 event = (struct iax_event *)frame.data;
3390 event = handle_event(event);
3391 if (event) {
3392 return event;
3393 }
3394 break;
3395 case JB_INTERP:
3396 /* create an interpolation frame */
3397 //fprintf(stderr, "Making Interpolation frame\n");
3398 event = (struct iax_event *)malloc(sizeof(struct iax_event));
3399 if (event) {
3400 event->etype = IAX_EVENT_VOICE;
3401 event->subclass = session->voiceformat;
3402 /* XXX: ??? applications probably ignore this anyway */
3403 event->ts = now;
3404 event->session = session;
3405 event->datalen = 0;
3406 event = handle_event(event);
3407 if(event)
3408 return event;
3409 }
3410 break;
3411 case JB_DROP:
3412 iax_event_free((struct iax_event *)frame.data);
3413 break;
3414 case JB_NOFRAME:
3415 case JB_EMPTY:
3416 /* do nothing */
3417 break;
3418 default:
3419 /* shouldn't happen */
3420 break;
3421 }
3422 }
3423
3424 /* Now look for networking events */
3425 if (blocking) {
3426 /* Block until there is data if desired */
3427 fd_set fds;
3428 int nextEventTime;
3429
3430 FD_ZERO(&fds);
3431 FD_SET(netfd, &fds);
3432
3433 nextEventTime = iax_time_to_next_event();
3434
3435 if(nextEventTime < 0) select(netfd + 1, &fds, NULL, NULL, NULL);
3436 else
3437 {
3438 struct timeval nextEvent;
3439
3440 nextEvent.tv_sec = nextEventTime / 1000;
3441 nextEvent.tv_usec = (nextEventTime % 1000) * 1000;
3442
3443 select(netfd + 1, &fds, NULL, NULL, &nextEvent);
3444 }
3445
3446 }
3447 event = iax_net_read();
3448
3449 return handle_event(event);
3450 }
3451
iax_get_peer_addr(struct iax_session * session)3452 struct sockaddr_in iax_get_peer_addr(struct iax_session *session)
3453 {
3454 return session->peeraddr;
3455 }
3456
iax_session_destroy(struct iax_session ** session)3457 void iax_session_destroy(struct iax_session **session)
3458 {
3459 destroy_session(*session);
3460 *session = NULL;
3461 }
3462
iax_event_free(struct iax_event * event)3463 void iax_event_free(struct iax_event *event)
3464 {
3465 /* We gave the user a chance to play with the session now we need to
3466 * destroy it if you are not calling this function on every event you
3467 * read you are now going to leak sessions as well as events!
3468 */
3469 switch(event->etype) {
3470 case IAX_EVENT_REJECT:
3471 case IAX_EVENT_HANGUP:
3472 /* Destroy this session -- it's no longer valid */
3473 if (event->session) { /* maybe the user did it already */
3474 destroy_session(event->session);
3475 }
3476 break;
3477 }
3478 free(event);
3479 }
3480
iax_get_fd(void)3481 int iax_get_fd(void)
3482 {
3483 /* Return our network file descriptor. The client can select on this
3484 * (probably with other things, or can add it to a network add sort
3485 * of gtk_input_add for example */
3486 return netfd;
3487 }
3488
iax_quelch_moh(struct iax_session * session,int MOH)3489 int iax_quelch_moh(struct iax_session *session, int MOH)
3490 {
3491 struct iax_ie_data ied; //IE Data Structure (Stuff To Send)
3492 memset(&ied, 0, sizeof(ied));
3493
3494 // You can't quelch the quelched
3495 if (session->quelch == 1)
3496 return -1;
3497
3498 if (MOH) {
3499 iax_ie_append(&ied, IAX_IE_MUSICONHOLD);
3500 session->transfer_moh = 1;
3501 }
3502
3503 return send_command(session, AST_FRAME_IAX, IAX_COMMAND_QUELCH, 0, ied.buf, ied.pos, -1);
3504 }
3505
iax_tvnow(void)3506 struct timeval iax_tvnow(void)
3507 {
3508 struct timeval tv;
3509
3510 #ifdef HAVE_GETTIMEOFDAY
3511 gettimeofday(&tv, 0);
3512 #elif defined(_MSC_VER)
3513 struct _timeb curSysTime;
3514
3515 _ftime(&curSysTime);
3516 tv.tv_sec = (long)curSysTime.time;
3517 tv.tv_usec = curSysTime.millitm * 1000;
3518 #else
3519 #error no gettimeofday or equivalent available
3520 #endif
3521 return tv;
3522 }
3523