rtp.c

   1 /*
   2  * Asterisk -- A telephony toolkit for Linux.
   3  *
   4  * Real-time Protocol Support
   5  *      Supports RTP and RTCP with Symmetric RTP support for NAT
   6  *      traversal
   7  *
   8  * Copyright (C) 1999 - 2005, Digium, Inc.
   9  *
  10  * Mark Spencer <markster@digium.com>
  11  *
  12  * This program is free software, distributed under the terms of
  13  * the GNU General Public License
  14  */
  15
  16 #include <stdio.h>
  17 #include <stdlib.h>
  18 #include <string.h>
  19 #include <sys/time.h>
  20 #include <signal.h>
  21 #include <errno.h>
  22 #include <unistd.h>
  23 #include <netinet/in.h>
  24 #include <sys/time.h>
  25 #include <sys/socket.h>
  26 #include <arpa/inet.h>
  27 #include <fcntl.h>
  28
  29 #include <asterisk/rtp.h>
  30 #include <asterisk/frame.h>
  31 #include <asterisk/logger.h>
  32 #include <asterisk/options.h>
  33 #include <asterisk/channel.h>
  34 #include <asterisk/acl.h>
  35 #include <asterisk/channel.h>
  36 #include <asterisk/config.h>
  37 #include <asterisk/lock.h>
  38 #include <asterisk/utils.h>
  39 #include <asterisk/cli.h>
  40 #include <asterisk/unaligned.h>
  41
  42 #define MAX_TIMESTAMP_SKEW      640
  43
  44 #define RTP_MTU         1200
  45
  46 #define TYPE_HIGH        0x0
  47 #define TYPE_LOW         0x1
  48 #define TYPE_SILENCE     0x2
  49 #define TYPE_DONTSEND    0x3
  50 #define TYPE_MASK        0x3
  51
  52 static int dtmftimeout = 3000;  /* 3000 samples */
  53
  54 static int rtpstart = 0;
  55 static int rtpend = 0;
  56 static int rtpdebug = 0;                /* Are we debugging? */
  57 static struct sockaddr_in rtpdebugaddr; /* Debug packets to/from this host */
  58 #ifdef SO_NO_CHECK
  59 static int nochecksums = 0;
  60 #endif
  61
  62 /* The value of each payload format mapping: */
  63 struct rtpPayloadType {
  64         int isAstFormat;        /* whether the following code is an AST_FORMAT */
  65         int code;
  66 };
  67
  68 #define MAX_RTP_PT 256
  69
  70 #define FLAG_3389_WARNING (1 << 0)
  71
  72 struct ast_rtp {
  73         int s;
  74         char resp;
  75         struct ast_frame f;
  76         unsigned char rawdata[8192 + AST_FRIENDLY_OFFSET];
  77         unsigned int ssrc;
  78         unsigned int lastts;
  79         unsigned int lastdigitts;
  80         unsigned int lastrxts;
  81         unsigned int lastividtimestamp;
  82         unsigned int lastovidtimestamp;
  83         unsigned int lasteventseqn;
  84         int lasttxformat;
  85         int lastrxformat;
  86         int dtmfcount;
  87         unsigned int dtmfduration;
  88         int nat;
  89         int flags;
  90         struct sockaddr_in us;
  91         struct sockaddr_in them;
  92         struct timeval rxcore;
  93         struct timeval txcore;
  94         struct timeval dtmfmute;
  95         struct ast_smoother *smoother;
  96         int *ioid;
  97         unsigned short seqno;
  98         unsigned short rxseqno;
  99         struct sched_context *sched;
 100         struct io_context *io;
 101         void *data;
 102         ast_rtp_callback callback;
 103         struct rtpPayloadType current_RTP_PT[MAX_RTP_PT];
 104         int rtp_lookup_code_cache_isAstFormat;  /* a cache for the result of rtp_lookup_code(): */
 105         int rtp_lookup_code_cache_code;
 106         int rtp_lookup_code_cache_result;
 107         int rtp_offered_from_local;
 108         struct ast_rtcp *rtcp;
 109 };
 110
 111 struct ast_rtcp {
 112         int s;          /* Socket */
 113         struct sockaddr_in us;
 114         struct sockaddr_in them;
 115 };
 116
 117 static struct ast_rtp_protocol *protos = NULL;
 118
 119 int ast_rtp_fd(struct ast_rtp *rtp)
 120 {
 121         return rtp->s;
 122 }
 123
 124 int ast_rtcp_fd(struct ast_rtp *rtp)
 125 {
 126         if (rtp->rtcp)
 127                 return rtp->rtcp->s;
 128         return -1;
 129 }
 130
 131 static int g723_len(unsigned char buf)
 132 {
 133         switch(buf & TYPE_MASK) {
 134         case TYPE_DONTSEND:
 135                 return 0;
 136                 break;
 137         case TYPE_SILENCE:
 138                 return 4;
 139                 break;
 140         case TYPE_HIGH:
 141                 return 24;
 142                 break;
 143         case TYPE_LOW:
 144                 return 20;
 145                 break;
 146         default:
 147                 ast_log(LOG_WARNING, "Badly encoded frame (%d)\n", buf & TYPE_MASK);
 148         }
 149         return -1;
 150 }
 151
 152 static int g723_samples(unsigned char *buf, int maxlen)
 153 {
 154         int pos = 0;
 155         int samples = 0;
 156         int res;
 157         while(pos < maxlen) {
 158                 res = g723_len(buf[pos]);
 159                 if (res <= 0)
 160                         break;
 161                 samples += 240;
 162                 pos += res;
 163         }
 164         return samples;
 165 }
 166
 167 void ast_rtp_set_data(struct ast_rtp *rtp, void *data)
 168 {
 169         rtp->data = data;
 170 }
 171
 172 void ast_rtp_set_callback(struct ast_rtp *rtp, ast_rtp_callback callback)
 173 {
 174         rtp->callback = callback;
 175 }
 176
 177 void ast_rtp_setnat(struct ast_rtp *rtp, int nat)
 178 {
 179         rtp->nat = nat;
 180 }
 181
 182 static struct ast_frame *send_dtmf(struct ast_rtp *rtp)
 183 {
 184         struct timeval tv;
 185         static struct ast_frame null_frame = { AST_FRAME_NULL, };
 186         char iabuf[INET_ADDRSTRLEN];
 187         gettimeofday(&tv, NULL);
 188         if ((tv.tv_sec < rtp->dtmfmute.tv_sec) ||
 189             ((tv.tv_sec == rtp->dtmfmute.tv_sec) && (tv.tv_usec < rtp->dtmfmute.tv_usec))) {
 190                 if (option_debug)
 191                         ast_log(LOG_DEBUG, "Ignore potential DTMF echo from '%s'\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
 192                 rtp->resp = 0;
 193                 rtp->dtmfduration = 0;
 194                 return &null_frame;
 195         }
 196         if (option_debug)
 197                 ast_log(LOG_DEBUG, "Sending dtmf: %d (%c), at %s\n", rtp->resp, rtp->resp, ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr));
 198         if (rtp->resp == 'X') {
 199                 rtp->f.frametype = AST_FRAME_CONTROL;
 200                 rtp->f.subclass = AST_CONTROL_FLASH;
 201         } else {
 202                 rtp->f.frametype = AST_FRAME_DTMF;
 203                 rtp->f.subclass = rtp->resp;
 204         }
 205         rtp->f.datalen = 0;
 206         rtp->f.samples = 0;
 207         rtp->f.mallocd = 0;
 208         rtp->f.src = "RTP";
 209         rtp->resp = 0;
 210         rtp->dtmfduration = 0;
 211         return &rtp->f;
 212
 213 }
 214
 215 static inline int rtp_debug_test_addr(struct sockaddr_in *addr)
 216 {
 217         if (rtpdebug == 0)
 218                 return 0;
 219         if (rtpdebugaddr.sin_addr.s_addr) {
 220                 if (((ntohs(rtpdebugaddr.sin_port) != 0)
 221                         && (rtpdebugaddr.sin_port != addr->sin_port))
 222                         || (rtpdebugaddr.sin_addr.s_addr != addr->sin_addr.s_addr))
 223                 return 0;
 224         }
 225         return 1;
 226 }
 227
 228 static struct ast_frame *process_cisco_dtmf(struct ast_rtp *rtp, unsigned char *data, int len)
 229 {
 230         unsigned int event;
 231         char resp = 0;
 232         struct ast_frame *f = NULL;
 233         event = ntohl(*((unsigned int *)(data)));
 234         event &= 0x001F;
 235 #if 0
 236         printf("Cisco Digit: %08x (len = %d)\n", event, len);
 237 #endif
 238         if (event < 10) {
 239                 resp = '0' + event;
 240         } else if (event < 11) {
 241                 resp = '*';
 242         } else if (event < 12) {
 243                 resp = '#';
 244         } else if (event < 16) {
 245                 resp = 'A' + (event - 12);
 246         } else if (event < 17) {
 247                 resp = 'X';
 248         }
 249         if (rtp->resp && (rtp->resp != resp)) {
 250                 f = send_dtmf(rtp);
 251         }
 252         rtp->resp = resp;
 253         rtp->dtmfcount = dtmftimeout;
 254         return f;
 255 }
 256
 257 static struct ast_frame *process_rfc2833(struct ast_rtp *rtp, unsigned char *data, int len)
 258 {
 259         unsigned int event;
 260         unsigned int event_end;
 261         unsigned int duration;
 262         char resp = 0;
 263         struct ast_frame *f = NULL;
 264         event = ntohl(*((unsigned int *)(data)));
 265         event >>= 24;
 266         event_end = ntohl(*((unsigned int *)(data)));
 267         event_end <<= 8;
 268         event_end >>= 24;
 269         duration = ntohl(*((unsigned int *)(data)));
 270         duration &= 0xFFFF;
 271 #if 0
 272         printf("Event: %08x (len = %d)\n", event, len);
 273 #endif
 274         if (event < 10) {
 275                 resp = '0' + event;
 276         } else if (event < 11) {
 277                 resp = '*';
 278         } else if (event < 12) {
 279                 resp = '#';
 280         } else if (event < 16) {
 281                 resp = 'A' + (event - 12);
 282         } else if (event < 17) {
 283                 resp = 'X';
 284         }
 285         if (rtp->resp && (rtp->resp != resp)) {
 286                 f = send_dtmf(rtp);
 287         }
 288         else if(event_end & 0x80)
 289         {
 290                 if (rtp->resp) {
 291                         f = send_dtmf(rtp);
 292                         rtp->resp = 0;
 293                 }
 294                 resp = 0;
 295                 duration = 0;
 296         }
 297         else if(rtp->dtmfduration && (duration < rtp->dtmfduration))
 298         {
 299                 f = send_dtmf(rtp);
 300         }
 301         if (!(event_end & 0x80))
 302                 rtp->resp = resp;
 303         rtp->dtmfcount = dtmftimeout;
 304         rtp->dtmfduration = duration;
 305         return f;
 306 }
 307
 308 static struct ast_frame *process_rfc3389(struct ast_rtp *rtp, unsigned char *data, int len)
 309 {
 310         struct ast_frame *f = NULL;
 311         /* Convert comfort noise into audio with various codecs.  Unfortunately this doesn't
 312            totally help us out becuase we don't have an engine to keep it going and we are not
 313            guaranteed to have it every 20ms or anything */
 314 #if 1
 315         printf("RFC3389: %d bytes, level %d...\n", len, rtp->lastrxformat);
 316 #endif
 317         if (!(rtp->flags & FLAG_3389_WARNING)) {
 318                 ast_log(LOG_NOTICE, "RFC3389 support incomplete.  Turn off on client if possible\n");
 319                 rtp->flags |= FLAG_3389_WARNING;
 320         }
 321         /* Must have at least one byte */
 322         if (!len)
 323                 return NULL;
 324         if (len < 24) {
 325                 rtp->f.data = rtp->rawdata + AST_FRIENDLY_OFFSET;
 326                 rtp->f.datalen = len - 1;
 327                 rtp->f.offset = AST_FRIENDLY_OFFSET;
 328                 memcpy(rtp->f.data, data + 1, len - 1);
 329         } else {
 330                 rtp->f.data = NULL;
 331                 rtp->f.offset = 0;
 332                 rtp->f.datalen = 0;
 333         }
 334         rtp->f.frametype = AST_FRAME_CNG;
 335         rtp->f.subclass = data[0] & 0x7f;
 336         rtp->f.datalen = len - 1;
 337         rtp->f.samples = 0;
 338         rtp->f.delivery.tv_usec = rtp->f.delivery.tv_sec = 0;
 339         f = &rtp->f;
 340         return f;
 341 }
 342
 343 static int rtpread(int *id, int fd, short events, void *cbdata)
 344 {
 345         struct ast_rtp *rtp = cbdata;
 346         struct ast_frame *f;
 347         f = ast_rtp_read(rtp);
 348         if (f) {
 349                 if (rtp->callback)
 350                         rtp->callback(rtp, f, rtp->data);
 351         }
 352         return 1;
 353 }
 354
 355 struct ast_frame *ast_rtcp_read(struct ast_rtp *rtp)
 356 {
 357         static struct ast_frame null_frame = { AST_FRAME_NULL, };
 358         int len;
 359         int hdrlen = 8;
 360         int res;
 361         struct sockaddr_in sin;
 362         unsigned int rtcpdata[1024];
 363         char iabuf[INET_ADDRSTRLEN];
 364
 365         if (!rtp->rtcp)
 366                 return &null_frame;
 367
 368         len = sizeof(sin);
 369
 370         res = recvfrom(rtp->rtcp->s, rtcpdata, sizeof(rtcpdata),
 371                                         0, (struct sockaddr *)&sin, &len);
 372
 373         if (res < 0) {
 374                 if (errno == EAGAIN)
 375                         ast_log(LOG_NOTICE, "RTP: Received packet with bad UDP checksum\n");
 376                 else
 377                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
 378                 if (errno == EBADF)
 379                         CRASH;
 380                 return &null_frame;
 381         }
 382
 383         if (res < hdrlen) {
 384                 ast_log(LOG_WARNING, "RTP Read too short\n");
 385                 return &null_frame;
 386         }
 387
 388         if (rtp->nat) {
 389                 /* Send to whoever sent to us */
 390                 if ((rtp->rtcp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
 391                     (rtp->rtcp->them.sin_port != sin.sin_port)) {
 392                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
 393                         rtp->rxseqno = 0;
 394                         if (option_debug)
 395                                 ast_log(LOG_DEBUG, "RTP NAT: Using address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->rtcp->them.sin_addr), ntohs(rtp->rtcp->them.sin_port));
 396                 }
 397         }
 398         if (option_debug)
 399                 ast_log(LOG_DEBUG, "Got RTCP report of %d bytes\n", res);
 400         return &null_frame;
 401 }
 402
 403 static void calc_rxstamp(struct timeval *tv, struct ast_rtp *rtp, unsigned int timestamp, int mark)
 404 {
 405         if ((!rtp->rxcore.tv_sec && !rtp->rxcore.tv_usec) || mark) {
 406                 gettimeofday(&rtp->rxcore, NULL);
 407                 rtp->rxcore.tv_sec -= timestamp / 8000;
 408                 rtp->rxcore.tv_usec -= (timestamp % 8000) * 125;
 409                 /* Round to 20ms for nice, pretty timestamps */
 410                 rtp->rxcore.tv_usec -= rtp->rxcore.tv_usec % 20000;
 411                 if (rtp->rxcore.tv_usec < 0) {
 412                         /* Adjust appropriately if necessary */
 413                         rtp->rxcore.tv_usec += 1000000;
 414                         rtp->rxcore.tv_sec -= 1;
 415                 }
 416         }
 417         tv->tv_sec = rtp->rxcore.tv_sec + timestamp / 8000;
 418         tv->tv_usec = rtp->rxcore.tv_usec + (timestamp % 8000) * 125;
 419         if (tv->tv_usec >= 1000000) {
 420                 tv->tv_usec -= 1000000;
 421                 tv->tv_sec += 1;
 422         }
 423 }
 424
 425 struct ast_frame *ast_rtp_read(struct ast_rtp *rtp)
 426 {
 427         int res;
 428         struct sockaddr_in sin;
 429         int len;
 430         unsigned int seqno;
 431         int version;
 432         int payloadtype;
 433         int hdrlen = 12;
 434         int mark;
 435         int ext;
 436         int x;
 437         char iabuf[INET_ADDRSTRLEN];
 438         unsigned int timestamp;
 439         unsigned int *rtpheader;
 440         static struct ast_frame *f, null_frame = { AST_FRAME_NULL, };
 441         struct rtpPayloadType rtpPT;
 442
 443         len = sizeof(sin);
 444
 445         /* Cache where the header will go */
 446         res = recvfrom(rtp->s, rtp->rawdata + AST_FRIENDLY_OFFSET, sizeof(rtp->rawdata) - AST_FRIENDLY_OFFSET,
 447                                         0, (struct sockaddr *)&sin, &len);
 448
 449
 450         rtpheader = (unsigned int *)(rtp->rawdata + AST_FRIENDLY_OFFSET);
 451         if (res < 0) {
 452                 if (errno == EAGAIN)
 453                         ast_log(LOG_NOTICE, "RTP: Received packet with bad UDP checksum\n");
 454                 else
 455                         ast_log(LOG_WARNING, "RTP Read error: %s\n", strerror(errno));
 456                 if (errno == EBADF)
 457                         CRASH;
 458                 return &null_frame;
 459         }
 460         if (res < hdrlen) {
 461                 ast_log(LOG_WARNING, "RTP Read too short\n");
 462                 return &null_frame;
 463         }
 464
 465         /* Ignore if the other side hasn't been given an address
 466            yet.  */
 467         if (!rtp->them.sin_addr.s_addr || !rtp->them.sin_port)
 468                 return &null_frame;
 469
 470         if (rtp->nat) {
 471                 /* Send to whoever sent to us */
 472                 if ((rtp->them.sin_addr.s_addr != sin.sin_addr.s_addr) ||
 473                     (rtp->them.sin_port != sin.sin_port)) {
 474                         memcpy(&rtp->them, &sin, sizeof(rtp->them));
 475                         rtp->rxseqno = 0;
 476                         ast_log(LOG_DEBUG, "RTP NAT: Using address %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port));
 477                 }
 478         }
 479
 480         /* Get fields */
 481         seqno = ntohl(rtpheader[0]);
 482
 483         /* Check RTP version */
 484         version = (seqno & 0xC0000000) >> 30;
 485         if (version != 2)
 486                 return &null_frame;
 487
 488         payloadtype = (seqno & 0x7f0000) >> 16;
 489         mark = seqno & (1 << 23);
 490         ext = seqno & (1 << 28);
 491         seqno &= 0xffff;
 492         timestamp = ntohl(rtpheader[1]);
 493         if (ext) {
 494                 /* RTP Extension present */
 495                 hdrlen += 4;
 496                 hdrlen += (ntohl(rtpheader[3]) & 0xffff) << 2;
 497         }
 498
 499         if (res < hdrlen) {
 500                 ast_log(LOG_WARNING, "RTP Read too short (%d, expecting %d)\n", res, hdrlen);
 501                 return &null_frame;
 502         }
 503
 504         if(rtp_debug_test_addr(&sin))
 505                 ast_verbose("Got RTP packet from %s:%d (type %d, seq %d, ts %d, len %d)\n"
 506                         , ast_inet_ntoa(iabuf, sizeof(iabuf), sin.sin_addr), ntohs(sin.sin_port), payloadtype, seqno, timestamp,res - hdrlen);
 507
 508         rtpPT = ast_rtp_lookup_pt(rtp, payloadtype);
 509         if (!rtpPT.isAstFormat) {
 510                 /* This is special in-band data that's not one of our codecs */
 511                 if (rtpPT.code == AST_RTP_DTMF) {
 512                         /* It's special -- rfc2833 process it */
 513                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
 514                                 f = process_rfc2833(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
 515                                 rtp->lasteventseqn = seqno;
 516                         } else
 517                                 f = NULL;
 518                         if (f)
 519                                 return f;
 520                         else
 521                                 return &null_frame;
 522                 } else if (rtpPT.code == AST_RTP_CISCO_DTMF) {
 523                         /* It's really special -- process it the Cisco way */
 524                         if (rtp->lasteventseqn <= seqno || rtp->resp == 0 || (rtp->lasteventseqn >= 65530 && seqno <= 6)) {
 525                                 f = process_cisco_dtmf(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
 526                                 rtp->lasteventseqn = seqno;
 527                         } else
 528                                 f = NULL;
 529                         if (f)
 530                                 return f;
 531                         else
 532                                 return &null_frame;
 533                 } else if (rtpPT.code == AST_RTP_CN) {
 534                         /* Comfort Noise */
 535                         f = process_rfc3389(rtp, rtp->rawdata + AST_FRIENDLY_OFFSET + hdrlen, res - hdrlen);
 536                         if (f)
 537                                 return f;
 538                         else
 539                                 return &null_frame;
 540                 } else {
 541                         ast_log(LOG_NOTICE, "Unknown RTP codec %d received\n", payloadtype);
 542                         return &null_frame;
 543                 }
 544         }
 545         rtp->f.subclass = rtpPT.code;
 546         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO)
 547                 rtp->f.frametype = AST_FRAME_VOICE;
 548         else
 549                 rtp->f.frametype = AST_FRAME_VIDEO;
 550         rtp->lastrxformat = rtp->f.subclass;
 551
 552         if (!rtp->lastrxts)
 553                 rtp->lastrxts = timestamp;
 554
 555         if (rtp->rxseqno) {
 556                 for (x=rtp->rxseqno + 1; x < seqno; x++) {
 557                         /* Queue empty frames */
 558                         rtp->f.mallocd = 0;
 559                         rtp->f.datalen = 0;
 560                         rtp->f.data = NULL;
 561                         rtp->f.offset = 0;
 562                         rtp->f.samples = 0;
 563                         rtp->f.src = "RTPMissedFrame";
 564                 }
 565         }
 566         rtp->rxseqno = seqno;
 567
 568         if (rtp->dtmfcount) {
 569 #if 0
 570                 printf("dtmfcount was %d\n", rtp->dtmfcount);
 571 #endif
 572                 rtp->dtmfcount -= (timestamp - rtp->lastrxts);
 573                 if (rtp->dtmfcount < 0)
 574                         rtp->dtmfcount = 0;
 575 #if 0
 576                 if (dtmftimeout != rtp->dtmfcount)
 577                         printf("dtmfcount is %d\n", rtp->dtmfcount);
 578 #endif
 579         }
 580         rtp->lastrxts = timestamp;
 581
 582         /* Send any pending DTMF */
 583         if (rtp->resp && !rtp->dtmfcount) {
 584                 if (option_debug)
 585                         ast_log(LOG_DEBUG, "Sending pending DTMF\n");
 586                 return send_dtmf(rtp);
 587         }
 588         rtp->f.mallocd = 0;
 589         rtp->f.datalen = res - hdrlen;
 590         rtp->f.data = rtp->rawdata + hdrlen + AST_FRIENDLY_OFFSET;
 591         rtp->f.offset = hdrlen + AST_FRIENDLY_OFFSET;
 592         if (rtp->f.subclass < AST_FORMAT_MAX_AUDIO) {
 593                 switch(rtp->f.subclass) {
 594                 case AST_FORMAT_ULAW:
 595                 case AST_FORMAT_ALAW:
 596                         rtp->f.samples = rtp->f.datalen;
 597                         break;
 598                 case AST_FORMAT_SLINEAR:
 599                         rtp->f.samples = rtp->f.datalen / 2;
 600                         ast_frame_byteswap_be(&rtp->f);
 601                         break;
 602                 case AST_FORMAT_GSM:
 603                         rtp->f.samples = 160 * (rtp->f.datalen / 33);
 604                         break;
 605                 case AST_FORMAT_ILBC:
 606                         rtp->f.samples = 240 * (rtp->f.datalen / 50);
 607                         break;
 608                 case AST_FORMAT_ADPCM:
 609                 case AST_FORMAT_G726:
 610                         rtp->f.samples = rtp->f.datalen * 2;
 611                         break;
 612                 case AST_FORMAT_G729A:
 613                         rtp->f.samples = rtp->f.datalen * 8;
 614                         break;
 615                 case AST_FORMAT_G723_1:
 616                         rtp->f.samples = g723_samples(rtp->f.data, rtp->f.datalen);
 617                         break;
 618                 case AST_FORMAT_SPEEX:
 619                         /* assumes that the RTP packet contained one Speex frame */
 620                         rtp->f.samples = 160;
 621                         break;
 622                 case AST_FORMAT_LPC10:
 623                         rtp->f.samples = 22 * 8;
 624                         rtp->f.samples += (((char *)(rtp->f.data))[7] & 0x1) * 8;
 625                         break;
 626                 default:
 627                         ast_log(LOG_NOTICE, "Unable to calculate samples for format %s\n", ast_getformatname(rtp->f.subclass));
 628                         break;
 629                 }
 630                 calc_rxstamp(&rtp->f.delivery, rtp, timestamp, mark);
 631         } else {
 632                 /* Video -- samples is # of samples vs. 90000 */
 633                 if (!rtp->lastividtimestamp)
 634                         rtp->lastividtimestamp = timestamp;
 635                 rtp->f.samples = timestamp - rtp->lastividtimestamp;
 636                 rtp->lastividtimestamp = timestamp;
 637                 rtp->f.delivery.tv_sec = 0;
 638                 rtp->f.delivery.tv_usec = 0;
 639                 if (mark)
 640                         rtp->f.subclass |= 0x1;
 641
 642         }
 643         rtp->f.src = "RTP";
 644         return &rtp->f;
 645 }
 646
 647 /* The following array defines the MIME Media type (and subtype) for each
 648    of our codecs, or RTP-specific data type. */
 649 static struct {
 650   struct rtpPayloadType payloadType;
 651   char* type;
 652   char* subtype;
 653 } mimeTypes[] = {
 654   {{1, AST_FORMAT_G723_1}, "audio", "G723"},
 655   {{1, AST_FORMAT_GSM}, "audio", "GSM"},
 656   {{1, AST_FORMAT_ULAW}, "audio", "PCMU"},
 657   {{1, AST_FORMAT_ALAW}, "audio", "PCMA"},
 658   {{1, AST_FORMAT_G726}, "audio", "G726-32"},
 659   {{1, AST_FORMAT_ADPCM}, "audio", "DVI4"},
 660   {{1, AST_FORMAT_SLINEAR}, "audio", "L16"},
 661   {{1, AST_FORMAT_LPC10}, "audio", "LPC"},
 662   {{1, AST_FORMAT_G729A}, "audio", "G729"},
 663   {{1, AST_FORMAT_SPEEX}, "audio", "speex"},
 664   {{1, AST_FORMAT_ILBC}, "audio", "iLBC"},
 665   {{0, AST_RTP_DTMF}, "audio", "telephone-event"},
 666   {{0, AST_RTP_CISCO_DTMF}, "audio", "cisco-telephone-event"},
 667   {{0, AST_RTP_CN}, "audio", "CN"},
 668   {{1, AST_FORMAT_JPEG}, "video", "JPEG"},
 669   {{1, AST_FORMAT_PNG}, "video", "PNG"},
 670   {{1, AST_FORMAT_H261}, "video", "H261"},
 671   {{1, AST_FORMAT_H263}, "video", "H263"},
 672   {{1, AST_FORMAT_H263_PLUS}, "video", "h263-1998"},
 673 };
 674
 675 /* Static (i.e., well-known) RTP payload types for our "AST_FORMAT..."s:
 676    also, our own choices for dynamic payload types.  This is our master
 677    table for transmission */
 678 static struct rtpPayloadType static_RTP_PT[MAX_RTP_PT] = {
 679   [0] = {1, AST_FORMAT_ULAW},
 680 #ifdef USE_DEPRECATED_G726
 681   [2] = {1, AST_FORMAT_G726}, /* Technically this is G.721, but if Cisco can do it, so can we... */
 682 #endif
 683   [3] = {1, AST_FORMAT_GSM},
 684   [4] = {1, AST_FORMAT_G723_1},
 685   [5] = {1, AST_FORMAT_ADPCM}, /* 8 kHz */
 686   [6] = {1, AST_FORMAT_ADPCM}, /* 16 kHz */
 687   [7] = {1, AST_FORMAT_LPC10},
 688   [8] = {1, AST_FORMAT_ALAW},
 689   [10] = {1, AST_FORMAT_SLINEAR}, /* 2 channels */
 690   [11] = {1, AST_FORMAT_SLINEAR}, /* 1 channel */
 691   [13] = {0, AST_RTP_CN},
 692   [16] = {1, AST_FORMAT_ADPCM}, /* 11.025 kHz */
 693   [17] = {1, AST_FORMAT_ADPCM}, /* 22.050 kHz */
 694   [18] = {1, AST_FORMAT_G729A},
 695   [19] = {0, AST_RTP_CN},               /* Also used for CN */
 696   [26] = {1, AST_FORMAT_JPEG},
 697   [31] = {1, AST_FORMAT_H261},
 698   [34] = {1, AST_FORMAT_H263},
 699   [103] = {1, AST_FORMAT_H263_PLUS},
 700   [97] = {1, AST_FORMAT_ILBC},
 701   [101] = {0, AST_RTP_DTMF},
 702   [110] = {1, AST_FORMAT_SPEEX},
 703   [111] = {1, AST_FORMAT_G726},
 704   [121] = {0, AST_RTP_CISCO_DTMF}, /* Must be type 121 */
 705 };
 706
 707 void ast_rtp_pt_clear(struct ast_rtp* rtp)
 708 {
 709         int i;
 710
 711         for (i = 0; i < MAX_RTP_PT; ++i) {
 712                 rtp->current_RTP_PT[i].isAstFormat = 0;
 713                 rtp->current_RTP_PT[i].code = 0;
 714         }
 715
 716         rtp->rtp_lookup_code_cache_isAstFormat = 0;
 717         rtp->rtp_lookup_code_cache_code = 0;
 718         rtp->rtp_lookup_code_cache_result = 0;
 719 }
 720
 721 void ast_rtp_pt_default(struct ast_rtp* rtp)
 722 {
 723         int i;
 724
 725         /* Initialize to default payload types */
 726         for (i = 0; i < MAX_RTP_PT; ++i) {
 727                 rtp->current_RTP_PT[i].isAstFormat = static_RTP_PT[i].isAstFormat;
 728                 rtp->current_RTP_PT[i].code = static_RTP_PT[i].code;
 729         }
 730
 731         rtp->rtp_lookup_code_cache_isAstFormat = 0;
 732         rtp->rtp_lookup_code_cache_code = 0;
 733         rtp->rtp_lookup_code_cache_result = 0;
 734 }
 735
 736 /* Make a note of a RTP payload type that was seen in a SDP "m=" line. */
 737 /* By default, use the well-known value for this type (although it may */
 738 /* still be set to a different value by a subsequent "a=rtpmap:" line): */
 739 void ast_rtp_set_m_type(struct ast_rtp* rtp, int pt) {
 740         if (pt < 0 || pt > MAX_RTP_PT)
 741                 return; /* bogus payload type */
 742
 743         if (static_RTP_PT[pt].code != 0) {
 744                 rtp->current_RTP_PT[pt] = static_RTP_PT[pt];
 745         }
 746 }
 747
 748 /* Make a note of a RTP payload type (with MIME type) that was seen in */
 749 /* a SDP "a=rtpmap:" line. */
 750 void ast_rtp_set_rtpmap_type(struct ast_rtp* rtp, int pt,
 751                          char* mimeType, char* mimeSubtype) {
 752         int i;
 753
 754         if (pt < 0 || pt > MAX_RTP_PT)
 755                         return; /* bogus payload type */
 756
 757         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
 758                 if (strcasecmp(mimeSubtype, mimeTypes[i].subtype) == 0 &&
 759                      strcasecmp(mimeType, mimeTypes[i].type) == 0) {
 760                         rtp->current_RTP_PT[pt] = mimeTypes[i].payloadType;
 761                 return;
 762                 }
 763         }
 764 }
 765
 766 /* Return the union of all of the codecs that were set by rtp_set...() calls */
 767 /* They're returned as two distinct sets: AST_FORMATs, and AST_RTPs */
 768 void ast_rtp_get_current_formats(struct ast_rtp* rtp,
 769                              int* astFormats, int* nonAstFormats) {
 770         int pt;
 771
 772         *astFormats = *nonAstFormats = 0;
 773         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
 774                 if (rtp->current_RTP_PT[pt].isAstFormat) {
 775                         *astFormats |= rtp->current_RTP_PT[pt].code;
 776                 } else {
 777                         *nonAstFormats |= rtp->current_RTP_PT[pt].code;
 778                 }
 779         }
 780 }
 781
 782 void ast_rtp_offered_from_local(struct ast_rtp* rtp, int local) {
 783         if (rtp)
 784                 rtp->rtp_offered_from_local = local;
 785         else
 786                 ast_log(LOG_WARNING, "rtp structure is null\n");
 787 }
 788
 789 struct rtpPayloadType ast_rtp_lookup_pt(struct ast_rtp* rtp, int pt)
 790 {
 791         struct rtpPayloadType result;
 792
 793         result.isAstFormat = result.code = 0;
 794         if (pt < 0 || pt > MAX_RTP_PT)
 795                 return result; /* bogus payload type */
 796
 797         /* Start with the negotiated codecs */
 798         if (!rtp->rtp_offered_from_local)
 799                 result = rtp->current_RTP_PT[pt];
 800
 801         /* If it doesn't exist, check our static RTP type list, just in case */
 802         if (!result.code)
 803                 result = static_RTP_PT[pt];
 804         return result;
 805 }
 806
 807 /* Looks up an RTP code out of our *static* outbound list */
 808 int ast_rtp_lookup_code(struct ast_rtp* rtp, const int isAstFormat, const int code) {
 809
 810         int pt;
 811
 812         if (isAstFormat == rtp->rtp_lookup_code_cache_isAstFormat &&
 813                 code == rtp->rtp_lookup_code_cache_code) {
 814
 815                 /* Use our cached mapping, to avoid the overhead of the loop below */
 816                 return rtp->rtp_lookup_code_cache_result;
 817         }
 818
 819         /* Check the dynamic list first */
 820         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
 821                 if (rtp->current_RTP_PT[pt].code == code && rtp->current_RTP_PT[pt].isAstFormat == isAstFormat) {
 822                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
 823                         rtp->rtp_lookup_code_cache_code = code;
 824                         rtp->rtp_lookup_code_cache_result = pt;
 825                         return pt;
 826                 }
 827         }
 828
 829         /* Then the static list */
 830         for (pt = 0; pt < MAX_RTP_PT; ++pt) {
 831                 if (static_RTP_PT[pt].code == code && static_RTP_PT[pt].isAstFormat == isAstFormat) {
 832                         rtp->rtp_lookup_code_cache_isAstFormat = isAstFormat;
 833                         rtp->rtp_lookup_code_cache_code = code;
 834                         rtp->rtp_lookup_code_cache_result = pt;
 835                         return pt;
 836                 }
 837         }
 838         return -1;
 839 }
 840
 841 char* ast_rtp_lookup_mime_subtype(const int isAstFormat, const int code) {
 842
 843         int i;
 844
 845         for (i = 0; i < sizeof mimeTypes/sizeof mimeTypes[0]; ++i) {
 846         if (mimeTypes[i].payloadType.code == code && mimeTypes[i].payloadType.isAstFormat == isAstFormat) {
 847                 return mimeTypes[i].subtype;
 848                 }
 849         }
 850         return "";
 851 }
 852
 853 char *ast_rtp_lookup_mime_multiple(char *buf, int size, const int capability, const int isAstFormat)
 854 {
 855         int format;
 856
 857         if (!buf || !size)
 858                 return NULL;
 859
 860         snprintf(buf, size, "0x%x (", capability);
 861
 862         for (format = 1; format < AST_RTP_MAX; format <<= 1) {
 863                 if (capability & format) {
 864                         const char *name = ast_rtp_lookup_mime_subtype(isAstFormat, format);
 865                         snprintf(buf + strlen(buf), size - strlen(buf), "%s|", name);
 866                 }
 867         }
 868         if (!ast_strlen_zero(buf))
 869                 buf[strlen(buf)] = ')';
 870
 871         return buf;
 872 }
 873
 874 static int rtp_socket(void)
 875 {
 876         int s;
 877         long flags;
 878         s = socket(AF_INET, SOCK_DGRAM, 0);
 879         if (s > -1) {
 880                 flags = fcntl(s, F_GETFL);
 881                 fcntl(s, F_SETFL, flags | O_NONBLOCK);
 882 #ifdef SO_NO_CHECK
 883                 if (nochecksums)
 884                         setsockopt(s, SOL_SOCKET, SO_NO_CHECK, &nochecksums, sizeof(nochecksums));
 885 #endif
 886         }
 887         return s;
 888 }
 889
 890 static struct ast_rtcp *ast_rtcp_new(void)
 891 {
 892         struct ast_rtcp *rtcp;
 893         rtcp = malloc(sizeof(struct ast_rtcp));
 894         if (!rtcp)
 895                 return NULL;
 896         memset(rtcp, 0, sizeof(struct ast_rtcp));
 897         rtcp->s = rtp_socket();
 898         rtcp->us.sin_family = AF_INET;
 899         if (rtcp->s < 0) {
 900                 free(rtcp);
 901                 ast_log(LOG_WARNING, "Unable to allocate socket: %s\n", strerror(errno));
 902                 return NULL;
 903         }
 904         return rtcp;
 905 }
 906
 907 struct ast_rtp *ast_rtp_new_with_bindaddr(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode, struct in_addr addr)
 908 {
 909         struct ast_rtp *rtp;
 910         int x;
 911         int first;
 912         int startplace;
 913         rtp = malloc(sizeof(struct ast_rtp));
 914         if (!rtp)
 915                 return NULL;
 916         memset(rtp, 0, sizeof(struct ast_rtp));
 917         rtp->them.sin_family = AF_INET;
 918         rtp->us.sin_family = AF_INET;
 919         rtp->s = rtp_socket();
 920         rtp->ssrc = rand();
 921         rtp->seqno = rand() & 0xffff;
 922         if (rtp->s < 0) {
 923                 free(rtp);
 924                 ast_log(LOG_ERROR, "Unable to allocate socket: %s\n", strerror(errno));
 925                 return NULL;
 926         }
 927         if (sched && rtcpenable) {
 928                 rtp->sched = sched;
 929                 rtp->rtcp = ast_rtcp_new();
 930         }
 931         /* Find us a place */
 932         x = (rand() % (rtpend-rtpstart)) + rtpstart;
 933         x = x & ~1;
 934         startplace = x;
 935         for (;;) {
 936                 /* Must be an even port number by RTP spec */
 937                 rtp->us.sin_port = htons(x);
 938                 rtp->us.sin_addr = addr;
 939                 if (rtp->rtcp)
 940                         rtp->rtcp->us.sin_port = htons(x + 1);
 941                 if (!(first = bind(rtp->s, (struct sockaddr *)&rtp->us, sizeof(rtp->us))) &&
 942                         (!rtp->rtcp || !bind(rtp->rtcp->s, (struct sockaddr *)&rtp->rtcp->us, sizeof(rtp->rtcp->us))))
 943                         break;
 944                 if (!first) {
 945                         /* Primary bind succeeded! Gotta recreate it */
 946                         close(rtp->s);
 947                         rtp->s = rtp_socket();
 948                 }
 949                 if (errno != EADDRINUSE) {
 950                         ast_log(LOG_ERROR, "Unexpected bind error: %s\n", strerror(errno));
 951                         close(rtp->s);
 952                         if (rtp->rtcp) {
 953                                 close(rtp->rtcp->s);
 954                                 free(rtp->rtcp);
 955                         }
 956                         free(rtp);
 957                         return NULL;
 958                 }
 959                 x += 2;
 960                 if (x > rtpend)
 961                         x = (rtpstart + 1) & ~1;
 962                 if (x == startplace) {
 963                         ast_log(LOG_ERROR, "No RTP ports remaining\n");
 964                         close(rtp->s);
 965                         if (rtp->rtcp) {
 966                                 close(rtp->rtcp->s);
 967                                 free(rtp->rtcp);
 968                         }
 969                         free(rtp);
 970                         return NULL;
 971                 }
 972         }
 973         if (io && sched && callbackmode) {
 974                 /* Operate this one in a callback mode */
 975                 rtp->sched = sched;
 976                 rtp->io = io;
 977                 rtp->ioid = ast_io_add(rtp->io, rtp->s, rtpread, AST_IO_IN, rtp);
 978         }
 979         ast_rtp_pt_default(rtp);
 980         return rtp;
 981 }
 982
 983 struct ast_rtp *ast_rtp_new(struct sched_context *sched, struct io_context *io, int rtcpenable, int callbackmode)
 984 {
 985         struct in_addr ia;
 986
 987         memset(&ia, 0, sizeof(ia));
 988         return ast_rtp_new_with_bindaddr(sched, io, rtcpenable, callbackmode, ia);
 989 }
 990
 991 int ast_rtp_settos(struct ast_rtp *rtp, int tos)
 992 {
 993         int res;
 994
 995         if ((res = setsockopt(rtp->s, IPPROTO_IP, IP_TOS, &tos, sizeof(tos))))
 996                 ast_log(LOG_WARNING, "Unable to set TOS to %d\n", tos);
 997         return res;
 998 }
 999
1000 void ast_rtp_set_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1001 {
1002         rtp->them.sin_port = them->sin_port;
1003         rtp->them.sin_addr = them->sin_addr;
1004         if (rtp->rtcp) {
1005                 rtp->rtcp->them.sin_port = htons(ntohs(them->sin_port) + 1);
1006                 rtp->rtcp->them.sin_addr = them->sin_addr;
1007         }
1008         rtp->rxseqno = 0;
1009 }
1010
1011 void ast_rtp_get_peer(struct ast_rtp *rtp, struct sockaddr_in *them)
1012 {
1013         them->sin_family = AF_INET;
1014         them->sin_port = rtp->them.sin_port;
1015         them->sin_addr = rtp->them.sin_addr;
1016 }
1017
1018 void ast_rtp_get_us(struct ast_rtp *rtp, struct sockaddr_in *us)
1019 {
1020         memcpy(us, &rtp->us, sizeof(rtp->us));
1021 }
1022
1023 void ast_rtp_stop(struct ast_rtp *rtp)
1024 {
1025         memset(&rtp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1026         memset(&rtp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1027         if (rtp->rtcp) {
1028                 memset(&rtp->rtcp->them.sin_addr, 0, sizeof(rtp->them.sin_addr));
1029                 memset(&rtp->rtcp->them.sin_port, 0, sizeof(rtp->them.sin_port));
1030         }
1031 }
1032
1033 void ast_rtp_reset(struct ast_rtp *rtp)
1034 {
1035         memset(&rtp->rxcore, 0, sizeof(rtp->rxcore));
1036         memset(&rtp->txcore, 0, sizeof(rtp->txcore));
1037         memset(&rtp->dtmfmute, 0, sizeof(rtp->dtmfmute));
1038         rtp->lastts = 0;
1039         rtp->lastdigitts = 0;
1040         rtp->lastrxts = 0;
1041         rtp->lastividtimestamp = 0;
1042         rtp->lastovidtimestamp = 0;
1043         rtp->lasteventseqn = 0;
1044         rtp->lasttxformat = 0;
1045         rtp->lastrxformat = 0;
1046         rtp->dtmfcount = 0;
1047         rtp->dtmfduration = 0;
1048         rtp->seqno = 0;
1049         rtp->rxseqno = 0;
1050 }
1051
1052 void ast_rtp_destroy(struct ast_rtp *rtp)
1053 {
1054         if (rtp->smoother)
1055                 ast_smoother_free(rtp->smoother);
1056         if (rtp->ioid)
1057                 ast_io_remove(rtp->io, rtp->ioid);
1058         if (rtp->s > -1)
1059                 close(rtp->s);
1060         if (rtp->rtcp) {
1061                 close(rtp->rtcp->s);
1062                 free(rtp->rtcp);
1063         }
1064         free(rtp);
1065 }
1066
1067 static unsigned int calc_txstamp(struct ast_rtp *rtp, struct timeval *delivery)
1068 {
1069         struct timeval now;
1070         unsigned int ms;
1071         if (!rtp->txcore.tv_sec && !rtp->txcore.tv_usec) {
1072                 gettimeofday(&rtp->txcore, NULL);
1073                 /* Round to 20ms for nice, pretty timestamps */
1074                 rtp->txcore.tv_usec -= rtp->txcore.tv_usec % 20000;
1075         }
1076         if (delivery && (delivery->tv_sec || delivery->tv_usec)) {
1077                 /* Use previous txcore */
1078                 ms = (delivery->tv_sec - rtp->txcore.tv_sec) * 1000;
1079                 ms += (1000000 + delivery->tv_usec - rtp->txcore.tv_usec) / 1000 - 1000;
1080                 rtp->txcore.tv_sec = delivery->tv_sec;
1081                 rtp->txcore.tv_usec = delivery->tv_usec;
1082         } else {
1083                 gettimeofday(&now, NULL);
1084                 ms = (now.tv_sec - rtp->txcore.tv_sec) * 1000;
1085                 ms += (1000000 + now.tv_usec - rtp->txcore.tv_usec) / 1000 - 1000;
1086                 /* Use what we just got for next time */
1087                 rtp->txcore.tv_sec = now.tv_sec;
1088                 rtp->txcore.tv_usec = now.tv_usec;
1089         }
1090         return ms;
1091 }
1092
1093 int ast_rtp_senddigit(struct ast_rtp *rtp, char digit)
1094 {
1095         unsigned int *rtpheader;
1096         int hdrlen = 12;
1097         int res;
1098         int x;
1099         int payload;
1100         char data[256];
1101         char iabuf[INET_ADDRSTRLEN];
1102
1103         if ((digit <= '9') && (digit >= '0'))
1104                 digit -= '0';
1105         else if (digit == '*')
1106                 digit = 10;
1107         else if (digit == '#')
1108                 digit = 11;
1109         else if ((digit >= 'A') && (digit <= 'D'))
1110                 digit = digit - 'A' + 12;
1111         else if ((digit >= 'a') && (digit <= 'd'))
1112                 digit = digit - 'a' + 12;
1113         else {
1114                 ast_log(LOG_WARNING, "Don't know how to represent '%c'\n", digit);
1115                 return -1;
1116         }
1117         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_DTMF);
1118
1119         /* If we have no peer, return immediately */
1120         if (!rtp->them.sin_addr.s_addr)
1121                 return 0;
1122
1123         gettimeofday(&rtp->dtmfmute, NULL);
1124         rtp->dtmfmute.tv_usec += (500 * 1000);
1125         if (rtp->dtmfmute.tv_usec > 1000000) {
1126                 rtp->dtmfmute.tv_usec -= 1000000;
1127                 rtp->dtmfmute.tv_sec += 1;
1128         }
1129
1130         /* Get a pointer to the header */
1131         rtpheader = (unsigned int *)data;
1132         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1133         rtpheader[1] = htonl(rtp->lastdigitts);
1134         rtpheader[2] = htonl(rtp->ssrc);
1135         rtpheader[3] = htonl((digit << 24) | (0xa << 16) | (0));
1136         for (x=0;x<6;x++) {
1137                 if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1138                         res = sendto(rtp->s, (void *)rtpheader, hdrlen + 4, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1139                         if (res < 0)
1140                                 ast_log(LOG_ERROR, "RTP Transmission error to %s:%d: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1141                         if(rtp_debug_test_addr(&rtp->them))
1142                                 ast_verbose("Sent RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1143                                                 , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastdigitts, res - hdrlen);
1144
1145                 }
1146                 /* Clear marker bit and increment seqno */
1147                 rtpheader[0] = htonl((2 << 30)  | (payload << 16) | (rtp->seqno++));
1148                 /* For the last three packets, set the duration and the end bit */
1149                 if (x == 2) {
1150                         /* Make duration 800 (100ms) */
1151                         rtpheader[3] |= htonl((800));
1152                         /* Set the End bit for the last 3 */
1153                         rtpheader[3] |= htonl((1 << 23));
1154                 }
1155         }
1156         /* Increment the digit timestamp by 100ms, to ensure that digits
1157            sent sequentially with no intervening non-digit packets do not
1158            get sent with the same timestamp.
1159         */
1160         rtp->lastdigitts += 800;
1161         return 0;
1162 }
1163
1164 int ast_rtp_sendcng(struct ast_rtp *rtp, int level)
1165 {
1166         unsigned int *rtpheader;
1167         int hdrlen = 12;
1168         int res;
1169         int payload;
1170         char data[256];
1171         char iabuf[INET_ADDRSTRLEN];
1172         level = 127 - (level & 0x7f);
1173         payload = ast_rtp_lookup_code(rtp, 0, AST_RTP_CN);
1174
1175         /* If we have no peer, return immediately */
1176         if (!rtp->them.sin_addr.s_addr)
1177                 return 0;
1178
1179         gettimeofday(&rtp->dtmfmute, NULL);
1180         rtp->dtmfmute.tv_usec += (500 * 1000);
1181         if (rtp->dtmfmute.tv_usec > 1000000) {
1182                 rtp->dtmfmute.tv_usec -= 1000000;
1183                 rtp->dtmfmute.tv_sec += 1;
1184         }
1185
1186         /* Get a pointer to the header */
1187         rtpheader = (unsigned int *)data;
1188         rtpheader[0] = htonl((2 << 30) | (1 << 23) | (payload << 16) | (rtp->seqno++));
1189         rtpheader[1] = htonl(rtp->lastts);
1190         rtpheader[2] = htonl(rtp->ssrc);
1191         data[12] = level;
1192         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1193                 res = sendto(rtp->s, (void *)rtpheader, hdrlen + 1, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1194                 if (res <0)
1195                         ast_log(LOG_ERROR, "RTP Comfort Noise Transmission error to %s:%d: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1196                 if(rtp_debug_test_addr(&rtp->them))
1197                         ast_verbose("Sent Comfort Noise RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1198                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), payload, rtp->seqno, rtp->lastts,res - hdrlen);
1199
1200         }
1201         return 0;
1202 }
1203
1204 static int ast_rtp_raw_write(struct ast_rtp *rtp, struct ast_frame *f, int codec)
1205 {
1206         unsigned char *rtpheader;
1207         char iabuf[INET_ADDRSTRLEN];
1208         int hdrlen = 12;
1209         int res;
1210         int ms;
1211         int pred;
1212         int mark = 0;
1213
1214         ms = calc_txstamp(rtp, &f->delivery);
1215         /* Default prediction */
1216         if (f->subclass < AST_FORMAT_MAX_AUDIO) {
1217                 pred = rtp->lastts + ms * 8;
1218
1219                 switch(f->subclass) {
1220                 case AST_FORMAT_ULAW:
1221                 case AST_FORMAT_ALAW:
1222                         /* If we're within +/- 20ms from when where we
1223                            predict we should be, use that */
1224                         pred = rtp->lastts + f->datalen;
1225                         break;
1226                 case AST_FORMAT_ADPCM:
1227                 case AST_FORMAT_G726:
1228                         /* If we're within +/- 20ms from when where we
1229                            predict we should be, use that */
1230                         pred = rtp->lastts + f->datalen * 2;
1231                         break;
1232                 case AST_FORMAT_G729A:
1233                         pred = rtp->lastts + f->datalen * 8;
1234                         break;
1235                 case AST_FORMAT_GSM:
1236                         pred = rtp->lastts + (f->datalen * 160 / 33);
1237                         break;
1238                 case AST_FORMAT_ILBC:
1239                         pred = rtp->lastts + (f->datalen * 240 / 50);
1240                         break;
1241                 case AST_FORMAT_G723_1:
1242                         pred = rtp->lastts + g723_samples(f->data, f->datalen);
1243                         break;
1244                 case AST_FORMAT_SPEEX:
1245                     pred = rtp->lastts + 160;
1246                         /* assumes that the RTP packet contains one Speex frame */
1247                         break;
1248                 case AST_FORMAT_LPC10:
1249                         /* assumes that the RTP packet contains one LPC10 frame */
1250                         pred = rtp->lastts + 22 * 8;
1251                         pred += (((char *)(f->data))[7] & 0x1) * 8;
1252                         break;
1253                 default:
1254                         ast_log(LOG_WARNING, "Not sure about timestamp format for codec format %s\n", ast_getformatname(f->subclass));
1255                 }
1256                 /* Re-calculate last TS */
1257                 rtp->lastts = rtp->lastts + ms * 8;
1258                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1259                         /* If this isn't an absolute delivery time, Check if it is close to our prediction,
1260                            and if so, go with our prediction */
1261                         if (abs(rtp->lastts - pred) < MAX_TIMESTAMP_SKEW)
1262                                 rtp->lastts = pred;
1263                         else {
1264                                 if (option_debug > 2)
1265                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d\n", abs(rtp->lastts - pred), ms);
1266                                 mark = 1;
1267                         }
1268                 }
1269         } else {
1270                 mark = f->subclass & 0x1;
1271                 pred = rtp->lastovidtimestamp + f->samples;
1272                 /* Re-calculate last TS */
1273                 rtp->lastts = rtp->lastts + ms * 90;
1274                 /* If it's close to our prediction, go for it */
1275                 if (!f->delivery.tv_sec && !f->delivery.tv_usec) {
1276                         if (abs(rtp->lastts - pred) < 7200) {
1277                                 rtp->lastts = pred;
1278                                 rtp->lastovidtimestamp += f->samples;
1279                         } else {
1280                                 if (option_debug > 2)
1281                                         ast_log(LOG_DEBUG, "Difference is %d, ms is %d (%d), pred/ts/samples %d/%d/%d\n", abs(rtp->lastts - pred), ms, ms * 90, rtp->lastts, pred, f->samples);
1282                                 rtp->lastovidtimestamp = rtp->lastts;
1283                         }
1284                 }
1285         }
1286         /* If the timestamp for non-digit packets has moved beyond the timestamp
1287            for digits, update the digit timestamp.
1288         */
1289         if (rtp->lastts > rtp->lastdigitts)
1290                 rtp->lastdigitts = rtp->lastts;
1291
1292         /* Get a pointer to the header */
1293         rtpheader = (unsigned char *)(f->data - hdrlen);
1294
1295         put_unaligned_uint32(rtpheader, htonl((2 << 30) | (codec << 16) | (rtp->seqno) | (mark << 23)));
1296         put_unaligned_uint32(rtpheader + 4, htonl(rtp->lastts));
1297         put_unaligned_uint32(rtpheader + 8, htonl(rtp->ssrc));
1298
1299         if (rtp->them.sin_port && rtp->them.sin_addr.s_addr) {
1300                 res = sendto(rtp->s, (void *)rtpheader, f->datalen + hdrlen, 0, (struct sockaddr *)&rtp->them, sizeof(rtp->them));
1301                 if (res <0)
1302                         ast_log(LOG_NOTICE, "RTP Transmission error to %s:%d: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), strerror(errno));
1303                 if(rtp_debug_test_addr(&rtp->them))
1304                         ast_verbose("Sent RTP packet to %s:%d (type %d, seq %d, ts %d, len %d)\n"
1305                                         , ast_inet_ntoa(iabuf, sizeof(iabuf), rtp->them.sin_addr), ntohs(rtp->them.sin_port), codec, rtp->seqno, rtp->lastts,res - hdrlen);
1306         }
1307
1308         rtp->seqno++;
1309
1310         return 0;
1311 }
1312
1313 int ast_rtp_write(struct ast_rtp *rtp, struct ast_frame *_f)
1314 {
1315         struct ast_frame *f;
1316         int codec;
1317         int hdrlen = 12;
1318         int subclass;
1319
1320
1321         /* If we have no peer, return immediately */
1322         if (!rtp->them.sin_addr.s_addr)
1323                 return 0;
1324
1325         /* If there is no data length, return immediately */
1326         if (!_f->datalen)
1327                 return 0;
1328
1329         /* Make sure we have enough space for RTP header */
1330         if ((_f->frametype != AST_FRAME_VOICE) && (_f->frametype != AST_FRAME_VIDEO)) {
1331                 ast_log(LOG_WARNING, "RTP can only send voice\n");
1332                 return -1;
1333         }
1334
1335         subclass = _f->subclass;
1336         if (_f->frametype == AST_FRAME_VIDEO)
1337                 subclass &= ~0x1;
1338
1339         codec = ast_rtp_lookup_code(rtp, 1, subclass);
1340         if (codec < 0) {
1341                 ast_log(LOG_WARNING, "Don't know how to send format %s packets with RTP\n", ast_getformatname(_f->subclass));
1342                 return -1;
1343         }
1344
1345         if (rtp->lasttxformat != subclass) {
1346                 /* New format, reset the smoother */
1347                 if (option_debug)
1348                         ast_log(LOG_DEBUG, "Ooh, format changed from %s to %s\n", ast_getformatname(rtp->lasttxformat), ast_getformatname(subclass));
1349                 rtp->lasttxformat = subclass;
1350                 if (rtp->smoother)
1351                         ast_smoother_free(rtp->smoother);
1352                 rtp->smoother = NULL;
1353         }
1354
1355
1356         switch(subclass) {
1357         case AST_FORMAT_SLINEAR:
1358                 if (!rtp->smoother) {
1359                         rtp->smoother = ast_smoother_new(320);
1360                 }
1361                 if (!rtp->smoother) {
1362                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1363                         return -1;
1364                 }
1365                 ast_smoother_feed_be(rtp->smoother, _f);
1366
1367                 while((f = ast_smoother_read(rtp->smoother)))
1368                         ast_rtp_raw_write(rtp, f, codec);
1369                 break;
1370         case AST_FORMAT_ULAW:
1371         case AST_FORMAT_ALAW:
1372                 if (!rtp->smoother) {
1373                         rtp->smoother = ast_smoother_new(160);
1374                 }
1375                 if (!rtp->smoother) {
1376                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1377                         return -1;
1378                 }
1379                 ast_smoother_feed(rtp->smoother, _f);
1380
1381                 while((f = ast_smoother_read(rtp->smoother)))
1382                         ast_rtp_raw_write(rtp, f, codec);
1383                 break;
1384         case AST_FORMAT_ADPCM:
1385         case AST_FORMAT_G726:
1386                 if (!rtp->smoother) {
1387                         rtp->smoother = ast_smoother_new(80);
1388                 }
1389                 if (!rtp->smoother) {
1390                         ast_log(LOG_WARNING, "Unable to create smoother :(\n");
1391                         return -1;
1392                 }
1393                 ast_smoother_feed(rtp->smoother, _f);
1394
1395                 while((f = ast_smoother_read(rtp->smoother)))
1396                         ast_rtp_raw_write(rtp, f, codec);
1397                 break;
1398         case AST_FORMAT_G729A:
1399                 if (!rtp->smoother) {
1400                         rtp->smoother = ast_smoother_new(20);
1401                         if (rtp->smoother)
1402                                 ast_smoother_set_flags(rtp->smoother, AST_SMOOTHER_FLAG_G729);
1403                 }
1404                 if (!rtp->smoother) {
1405                         ast_log(LOG_WARNING, "Unable to create g729 smoother :(\n");
1406                         return -1;
1407                 }
1408                 ast_smoother_feed(rtp->smoother, _f);
1409
1410                 while((f = ast_smoother_read(rtp->smoother)))
1411                         ast_rtp_raw_write(rtp, f, codec);
1412                 break;
1413         case AST_FORMAT_GSM:
1414                 if (!rtp->smoother) {
1415                         rtp->smoother = ast_smoother_new(33);
1416                 }
1417                 if (!rtp->smoother) {
1418                         ast_log(LOG_WARNING, "Unable to create GSM smoother :(\n");
1419                         return -1;
1420                 }
1421                 ast_smoother_feed(rtp->smoother, _f);
1422                 while((f = ast_smoother_read(rtp->smoother)))
1423                         ast_rtp_raw_write(rtp, f, codec);
1424                 break;
1425         case AST_FORMAT_ILBC:
1426                 if (!rtp->smoother) {
1427                         rtp->smoother = ast_smoother_new(50);
1428                 }
1429                 if (!rtp->smoother) {
1430                         ast_log(LOG_WARNING, "Unable to create ILBC smoother :(\n");
1431                         return -1;
1432                 }
1433                 ast_smoother_feed(rtp->smoother, _f);
1434                 while((f = ast_smoother_read(rtp->smoother)))
1435                         ast_rtp_raw_write(rtp, f, codec);
1436                 break;
1437         default:
1438                 ast_log(LOG_WARNING, "Not sure about sending format %s packets\n", ast_getformatname(subclass));
1439                 /* fall through to... */
1440         case AST_FORMAT_H261:
1441         case AST_FORMAT_H263:
1442         case AST_FORMAT_H263_PLUS:
1443         case AST_FORMAT_G723_1:
1444         case AST_FORMAT_LPC10:
1445         case AST_FORMAT_SPEEX:
1446                 /* Don't buffer outgoing frames; send them one-per-packet: */
1447                 if (_f->offset < hdrlen) {
1448                         f = ast_frdup(_f);
1449                 } else {
1450                         f = _f;
1451                 }
1452                 ast_rtp_raw_write(rtp, f, codec);
1453         }
1454
1455         return 0;
1456 }
1457
1458 void ast_rtp_proto_unregister(struct ast_rtp_protocol *proto)
1459 {
1460         struct ast_rtp_protocol *cur, *prev;
1461
1462         cur = protos;
1463         prev = NULL;
1464         while(cur) {
1465                 if (cur == proto) {
1466                         if (prev)
1467                                 prev->next = proto->next;
1468                         else
1469                                 protos = proto->next;
1470                         return;
1471                 }
1472                 prev = cur;
1473                 cur = cur->next;
1474         }
1475 }
1476
1477 int ast_rtp_proto_register(struct ast_rtp_protocol *proto)
1478 {
1479         struct ast_rtp_protocol *cur;
1480         cur = protos;
1481         while(cur) {
1482                 if (cur->type == proto->type) {
1483                         ast_log(LOG_WARNING, "Tried to register same protocol '%s' twice\n", cur->type);
1484                         return -1;
1485                 }
1486                 cur = cur->next;
1487         }
1488         proto->next = protos;
1489         protos = proto;
1490         return 0;
1491 }
1492
1493 static struct ast_rtp_protocol *get_proto(struct ast_channel *chan)
1494 {
1495         struct ast_rtp_protocol *cur;
1496         cur = protos;
1497         while(cur) {
1498                 if (cur->type == chan->type) {
1499                         return cur;
1500                 }
1501                 cur = cur->next;
1502         }
1503         return NULL;
1504 }
1505
1506 int ast_rtp_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc)
1507 {
1508         struct ast_frame *f;
1509         struct ast_channel *who, *cs[3];
1510         struct ast_rtp *p0, *p1;
1511         struct ast_rtp *vp0, *vp1;
1512         struct ast_rtp_protocol *pr0, *pr1;
1513         struct sockaddr_in ac0, ac1;
1514         struct sockaddr_in vac0, vac1;
1515         struct sockaddr_in t0, t1;
1516         struct sockaddr_in vt0, vt1;
1517         char iabuf[INET_ADDRSTRLEN];
1518
1519         void *pvt0, *pvt1;
1520         int to;
1521         int codec0,codec1, oldcodec0, oldcodec1;
1522
1523         memset(&vt0, 0, sizeof(vt0));
1524         memset(&vt1, 0, sizeof(vt1));
1525         memset(&vac0, 0, sizeof(vac0));
1526         memset(&vac1, 0, sizeof(vac1));
1527
1528         /* if need DTMF, cant native bridge */
1529         if (flags & (AST_BRIDGE_DTMF_CHANNEL_0 | AST_BRIDGE_DTMF_CHANNEL_1))
1530                 return -2;
1531         ast_mutex_lock(&c0->lock);
1532         while(ast_mutex_trylock(&c1->lock)) {
1533                 ast_mutex_unlock(&c0->lock);
1534                 usleep(1);
1535                 ast_mutex_lock(&c0->lock);
1536         }
1537         pr0 = get_proto(c0);
1538         pr1 = get_proto(c1);
1539         if (!pr0) {
1540                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c0->name);
1541                 ast_mutex_unlock(&c0->lock);
1542                 ast_mutex_unlock(&c1->lock);
1543                 return -1;
1544         }
1545         if (!pr1) {
1546                 ast_log(LOG_WARNING, "Can't find native functions for channel '%s'\n", c1->name);
1547                 ast_mutex_unlock(&c0->lock);
1548                 ast_mutex_unlock(&c1->lock);
1549                 return -1;
1550         }
1551         pvt0 = c0->tech_pvt;
1552         pvt1 = c1->tech_pvt;
1553         p0 = pr0->get_rtp_info(c0);
1554         if (pr0->get_vrtp_info)
1555                 vp0 = pr0->get_vrtp_info(c0);
1556         else
1557                 vp0 = NULL;
1558         p1 = pr1->get_rtp_info(c1);
1559         if (pr1->get_vrtp_info)
1560                 vp1 = pr1->get_vrtp_info(c1);
1561         else
1562                 vp1 = NULL;
1563         if (!p0 || !p1) {
1564                 /* Somebody doesn't want to play... */
1565                 ast_mutex_unlock(&c0->lock);
1566                 ast_mutex_unlock(&c1->lock);
1567                 return -2;
1568         }
1569         if (pr0->get_codec)
1570                 codec0 = pr0->get_codec(c0);
1571         else
1572                 codec0 = 0;
1573         if (pr1->get_codec)
1574                 codec1 = pr1->get_codec(c1);
1575         else
1576                 codec1 = 0;
1577         if (pr0->get_codec && pr1->get_codec) {
1578                 /* Hey, we can't do reinvite if both parties speak diffrent codecs */
1579                 if (!(codec0 & codec1)) {
1580                         ast_log(LOG_WARNING, "codec0 = %d is not codec1 = %d, cannot native bridge.\n",codec0,codec1);
1581                         ast_mutex_unlock(&c0->lock);
1582                         ast_mutex_unlock(&c1->lock);
1583                         return -2;
1584                 }
1585         }
1586         if (pr0->set_rtp_peer(c0, p1, vp1, codec1))
1587                 ast_log(LOG_WARNING, "Channel '%s' failed to talk to '%s'\n", c0->name, c1->name);
1588         else {
1589                 /* Store RTP peer */
1590                 ast_rtp_get_peer(p1, &ac1);
1591                 if (vp1)
1592                         ast_rtp_get_peer(vp1, &vac1);
1593         }
1594         if (pr1->set_rtp_peer(c1, p0, vp0, codec0))
1595                 ast_log(LOG_WARNING, "Channel '%s' failed to talk back to '%s'\n", c1->name, c0->name);
1596         else {
1597                 /* Store RTP peer */
1598                 ast_rtp_get_peer(p0, &ac0);
1599                 if (vp0)
1600                         ast_rtp_get_peer(vp0, &vac0);
1601         }
1602         ast_mutex_unlock(&c0->lock);
1603         ast_mutex_unlock(&c1->lock);
1604         cs[0] = c0;
1605         cs[1] = c1;
1606         cs[2] = NULL;
1607         oldcodec0 = codec0;
1608         oldcodec1 = codec1;
1609         for (;;) {
1610                 if ((c0->tech_pvt != pvt0)  ||
1611                         (c1->tech_pvt != pvt1) ||
1612                         (c0->masq || c0->masqr || c1->masq || c1->masqr)) {
1613                                 ast_log(LOG_DEBUG, "Oooh, something is weird, backing out\n");
1614                                 if (c0->tech_pvt == pvt0) {
1615                                         if (pr0->set_rtp_peer(c0, NULL, NULL, 0))
1616                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1617                                 }
1618                                 if (c1->tech_pvt == pvt1) {
1619                                         if (pr1->set_rtp_peer(c1, NULL, NULL, 0))
1620                                                 ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1621                                 }
1622                                 /* Tell it to try again later */
1623                                 return -3;
1624                 }
1625                 to = -1;
1626                 ast_rtp_get_peer(p1, &t1);
1627                 ast_rtp_get_peer(p0, &t0);
1628                 if (pr0->get_codec)
1629                         codec0 = pr0->get_codec(c0);
1630                 if (pr1->get_codec)
1631                         codec1 = pr1->get_codec(c1);
1632                 if (vp1)
1633                         ast_rtp_get_peer(vp1, &vt1);
1634                 if (vp0)
1635                         ast_rtp_get_peer(vp0, &vt0);
1636                 if (inaddrcmp(&t1, &ac1) || (vp1 && inaddrcmp(&vt1, &vac1)) || (codec1 != oldcodec1)) {
1637                         if (option_debug) {
1638                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
1639                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t1.sin_addr), ntohs(t1.sin_port), codec1);
1640                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end vaddress to %s:%d (format %d)\n",
1641                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vt1.sin_addr), ntohs(vt1.sin_port), codec1);
1642                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
1643                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac1.sin_addr), ntohs(ac1.sin_port), oldcodec1);
1644                                 ast_log(LOG_DEBUG, "Oooh, '%s' wasv %s:%d/(format %d)\n",
1645                                         c1->name, ast_inet_ntoa(iabuf, sizeof(iabuf), vac1.sin_addr), ntohs(vac1.sin_port), oldcodec1);
1646                         }
1647                         if (pr0->set_rtp_peer(c0, t1.sin_addr.s_addr ? p1 : NULL, vt1.sin_addr.s_addr ? vp1 : NULL, codec1))
1648                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c0->name, c1->name);
1649                         memcpy(&ac1, &t1, sizeof(ac1));
1650                         memcpy(&vac1, &vt1, sizeof(vac1));
1651                         oldcodec1 = codec1;
1652                 }
1653                 if (inaddrcmp(&t0, &ac0) || (vp0 && inaddrcmp(&vt0, &vac0))) {
1654                         if (option_debug) {
1655                                 ast_log(LOG_DEBUG, "Oooh, '%s' changed end address to %s:%d (format %d)\n",
1656                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), t0.sin_addr), ntohs(t0.sin_port), codec0);
1657                                 ast_log(LOG_DEBUG, "Oooh, '%s' was %s:%d/(format %d)\n",
1658                                         c0->name, ast_inet_ntoa(iabuf, sizeof(iabuf), ac0.sin_addr), ntohs(ac0.sin_port), oldcodec0);
1659                         }
1660                         if (pr1->set_rtp_peer(c1, t0.sin_addr.s_addr ? p0 : NULL, vt0.sin_addr.s_addr ? vp0 : NULL, codec0))
1661                                 ast_log(LOG_WARNING, "Channel '%s' failed to update to '%s'\n", c1->name, c0->name);
1662                         memcpy(&ac0, &t0, sizeof(ac0));
1663                         memcpy(&vac0, &vt0, sizeof(vac0));
1664                         oldcodec0 = codec0;
1665                 }
1666                 who = ast_waitfor_n(cs, 2, &to);
1667                 if (!who) {
1668                         if (option_debug)
1669                                 ast_log(LOG_DEBUG, "Ooh, empty read...\n");
1670                         /* check for hagnup / whentohangup */
1671                         if (ast_check_hangup(c0) || ast_check_hangup(c1))
1672                                 break;
1673                         continue;
1674                 }
1675                 f = ast_read(who);
1676                 if (!f || ((f->frametype == AST_FRAME_DTMF) &&
1677                                    (((who == c0) && (flags & AST_BRIDGE_DTMF_CHANNEL_0)) ||
1678                                ((who == c1) && (flags & AST_BRIDGE_DTMF_CHANNEL_1))))) {
1679                         *fo = f;
1680                         *rc = who;
1681                         if (option_debug)
1682                                 ast_log(LOG_DEBUG, "Oooh, got a %s\n", f ? "digit" : "hangup");
1683                         if ((c0->tech_pvt == pvt0) && (!c0->_softhangup)) {
1684                                 if (pr0->set_rtp_peer(c0, NULL, NULL, 0))
1685                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert\n", c0->name);
1686                         }
1687                         if ((c1->tech_pvt == pvt1) && (!c1->_softhangup)) {
1688                                 if (pr1->set_rtp_peer(c1, NULL, NULL, 0))
1689                                         ast_log(LOG_WARNING, "Channel '%s' failed to revert back\n", c1->name);
1690                         }
1691                         /* That's all we needed */
1692                         return 0;
1693                 } else {
1694                         if ((f->frametype == AST_FRAME_DTMF) ||
1695                                 (f->frametype == AST_FRAME_VOICE) ||
1696                                 (f->frametype == AST_FRAME_VIDEO)) {
1697                                 /* Forward voice or DTMF frames if they happen upon us */
1698                                 if (who == c0) {
1699                                         ast_write(c1, f);
1700                                 } else if (who == c1) {
1701                                         ast_write(c0, f);
1702                                 }
1703                         }
1704                         ast_frfree(f);
1705                 }
1706                 /* Swap priority not that it's a big deal at this point */
1707                 cs[2] = cs[0];
1708                 cs[0] = cs[1];
1709                 cs[1] = cs[2];
1710
1711         }
1712         return -1;
1713 }
1714
1715 static int rtp_do_debug_ip(int fd, int argc, char *argv[])
1716 {
1717         struct hostent *hp;
1718         struct ast_hostent ahp;
1719         char iabuf[INET_ADDRSTRLEN];
1720         int port = 0;
1721         char *p, *arg;
1722
1723         if (argc != 4)
1724                 return RESULT_SHOWUSAGE;
1725         arg = argv[3];
1726         p = strstr(arg, ":");
1727         if (p) {
1728                 *p = '\0';
1729                 p++;
1730                 port = atoi(p);
1731         }
1732         hp = ast_gethostbyname(arg, &ahp);
1733         if (hp == NULL)
1734                 return RESULT_SHOWUSAGE;
1735         rtpdebugaddr.sin_family = AF_INET;
1736         memcpy(&rtpdebugaddr.sin_addr, hp->h_addr, sizeof(rtpdebugaddr.sin_addr));
1737         rtpdebugaddr.sin_port = htons(port);
1738         if (port == 0)
1739                 ast_cli(fd, "RTP Debugging Enabled for IP: %s\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr));
1740         else
1741                 ast_cli(fd, "RTP Debugging Enabled for IP: %s:%d\n", ast_inet_ntoa(iabuf, sizeof(iabuf), rtpdebugaddr.sin_addr), port);
1742         rtpdebug = 1;
1743         return RESULT_SUCCESS;
1744 }
1745
1746 static int rtp_do_debug(int fd, int argc, char *argv[])
1747 {
1748         if(argc != 2){
1749                 if(argc != 4)
1750                         return RESULT_SHOWUSAGE;
1751                 return rtp_do_debug_ip(fd, argc, argv);
1752         }
1753         rtpdebug = 1;
1754         memset(&rtpdebugaddr,0,sizeof(rtpdebugaddr));
1755         ast_cli(fd, "RTP Debugging Enabled\n");
1756         return RESULT_SUCCESS;
1757 }
1758
1759 static int rtp_no_debug(int fd, int argc, char *argv[])
1760 {
1761         if(argc !=3)
1762                 return RESULT_SHOWUSAGE;
1763         rtpdebug = 0;
1764         ast_cli(fd,"RTP Debugging Disabled\n");
1765         return RESULT_SUCCESS;
1766 }
1767
1768 static char debug_usage[] =
1769   "Usage: rtp debug [ip host[:port]]\n"
1770   "       Enable dumping of all RTP packets to and from host.\n";
1771
1772 static char no_debug_usage[] =
1773   "Usage: rtp no debug\n"
1774   "       Disable all RTP debugging\n";
1775
1776 static struct ast_cli_entry  cli_debug_ip =
1777 {{ "rtp", "debug", "ip", NULL } , rtp_do_debug, "Enable RTP debugging on IP", debug_usage };
1778
1779 static struct ast_cli_entry  cli_debug =
1780 {{ "rtp", "debug", NULL } , rtp_do_debug, "Enable RTP debugging", debug_usage };
1781
1782 static struct ast_cli_entry  cli_no_debug =
1783 {{ "rtp", "no", "debug", NULL } , rtp_no_debug, "Disable RTP debugging", no_debug_usage };
1784
1785 void ast_rtp_reload(void)
1786 {
1787         struct ast_config *cfg;
1788         char *s;
1789
1790         rtpstart = 5000;
1791         rtpend = 31000;
1792         cfg = ast_config_load("rtp.conf");
1793         if (cfg) {
1794                 if ((s = ast_variable_retrieve(cfg, "general", "rtpstart"))) {
1795                         rtpstart = atoi(s);
1796                         if (rtpstart < 1024)
1797                                 rtpstart = 1024;
1798                         if (rtpstart > 65535)
1799                                 rtpstart = 65535;
1800                 }
1801                 if ((s = ast_variable_retrieve(cfg, "general", "rtpend"))) {
1802                         rtpend = atoi(s);
1803                         if (rtpend < 1024)
1804                                 rtpend = 1024;
1805                         if (rtpend > 65535)
1806                                 rtpend = 65535;
1807                 }
1808                 if ((s = ast_variable_retrieve(cfg, "general", "rtpchecksums"))) {
1809 #ifdef SO_NO_CHECK
1810                         if (ast_false(s))
1811                                 nochecksums = 1;
1812                         else
1813                                 nochecksums = 0;
1814 #else
1815                         if (ast_false(s))
1816                                 ast_log(LOG_WARNING, "Disabling RTP checksums is not supported on this operating system!\n");
1817 #endif
1818                 }
1819                 ast_config_destroy(cfg);
1820         }
1821         if (rtpstart >= rtpend) {
1822                 ast_log(LOG_WARNING, "Unreasonable values for RTP start in rtp.conf/end\n");
1823                 rtpstart = 5000;
1824                 rtpend = 31000;
1825         }
1826         if (option_verbose > 1)
1827                 ast_verbose(VERBOSE_PREFIX_2 "RTP Allocating from port range %d -> %d\n", rtpstart, rtpend);
1828
1829 }
1830
1831 void ast_rtp_init(void)
1832 {
1833         ast_cli_register(&cli_debug);
1834         ast_cli_register(&cli_debug_ip);
1835         ast_cli_register(&cli_no_debug);
1836         ast_rtp_reload();
1837 }