开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多媒体 > 流媒体/Mpeg4/MP4 > 查看源码
rtp.c
资源名称：NETVIDEO.rar　[点击查看]
上传用户：sun1608
上传日期：2007-02-02
资源大小：6116k
文件大小：113k
源码类别：

流媒体/Mpeg4/MP4

开发平台：

Visual C++

rtp.c：源码内容
  1. /*
  2.  * FILE:     rtp.c
  3.  * AUTHOR:   Colin Perkins   <csp@isi.edu>
  4.  * MODIFIED: Orion Hodson    <o.hodson@cs.ucl.ac.uk>
  5.  *           Markus Germeier <mager@tzi.de>
  6.  *           Bill Fenner     <fenner@research.att.com>
  7.  *           Timur Friedman  <timur@research.att.com>
  8.  *
  9.  * The routines in this file implement the Real-time Transport Protocol,
  10.  * RTP, as specified in RFC1889 with current updates under discussion in
  11.  * the IETF audio/video transport working group. Portions of the code are
  12.  * derived from the algorithms published in that specification.
  13.  *
  14.  * $Revision: 1.24 $ 
  15.  * $Date: 2002/07/05 22:03:53 $
  16.  * 
  17.  * Copyright (c) 1998-2001 University College London
  18.  * All rights reserved.
  19.  *
  20.  * Redistribution and use in source and binary forms, with or without
  21.  * modification, is permitted provided that the following conditions 
  22.  * are met:
  23.  * 1. Redistributions of source code must retain the above copyright
  24.  *    notice, this list of conditions and the following disclaimer.
  25.  * 2. Redistributions in binary form must reproduce the above copyright
  26.  *    notice, this list of conditions and the following disclaimer in the
  27.  *    documentation and/or other materials provided with the distribution.
  28.  * 3. All advertising materials mentioning features or use of this software
  29.  *    must display the following acknowledgement:
  30.  *      This product includes software developed by the Computer Science
  31.  *      Department at University College London.
  32.  * 4. Neither the name of the University nor of the Department may be used
  33.  *    to endorse or promote products derived from this software without
  34.  *    specific prior written permission.
  35.  * THIS SOFTWARE IS PROVIDED BY THE AUTHORS AND CONTRIBUTORS ``AS IS'' AND
  36.  * ANY EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  38.  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHORS OR CONTRIBUTORS BE LIABLE
  39.  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  40.  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  41.  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  42.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  43.  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  44.  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  45.  * SUCH DAMAGE.
  46.  *
  47.  */
  49. #include "config_unix.h"
  50. #include "config_win32.h"
  51. #include "memory.h"
  52. #include "debug.h"
  53. #include "net_udp.h"
  54. #include "crypt_random.h"
  55. #include "rijndael-api-fst.h"
  56. #include "drand48.h"
  57. #include "gettimeofday.h"
  58. #include "qfDES.h"
  59. #include "md5.h"
  60. #include "ntp.h"
  62. #include "rtp.h"
  63. typedef struct {
  64.         uint32_t key;   /* Original allocation number   */
  65.         uint32_t size;  /* Size of allocation requested */
  66.         uint32_t pad;   /* Alignment padding to 8 bytes */
  67.         uint32_t magic; /* Magic number                 */
  68. } chk_header;
  69.   extern int chk_header_okay(const chk_header *ch);
  71. /*
  72.  * Encryption stuff.
  73.  */
  74. #define MAX_ENCRYPTION_PAD 16
  76. static int rijndael_initialize(struct rtp *session, u_char *hash, int hash_len);
  78. static int rijndael_decrypt(void *ifptr, uint8_t *data,
  79.     unsigned int *size);
  80. static int rijndael_encrypt(void *ifptr, uint8_t *data,
  81.     unsigned int *size);
  83. static int des_initialize(struct rtp *session, u_char *hash, int hash_len);
  84. static int des_decrypt(void *ifptr, uint8_t *data,
  85.        unsigned int *size);
  86. static int des_encrypt(void *ifptr, uint8_t *data,
  87.        unsigned int *size);
  89. #define MAX_DROPOUT    3000
  90. #define MAX_MISORDER   100
  91. #define MIN_SEQUENTIAL 2
  93. /*
  94.  * Definitions for the RTP/RTCP packets on the wire...
  95.  */
  97. #define RTP_SEQ_MOD        0x10000
  98. #define RTP_MAX_SDES_LEN   256
  100. #define RTP_LOWER_LAYER_OVERHEAD 28 /* IPv4 + UDP */
  102. #define RTCP_SR   200
  103. #define RTCP_RR   201
  104. #define RTCP_SDES 202
  105. #define RTCP_BYE  203
  106. #define RTCP_APP  204
  108. typedef struct {
  109. #ifdef WORDS_BIGENDIAN
  110. unsigned short  version:2; /* packet type            */
  111. unsigned short  p:1; /* padding flag           */
  112. unsigned short  count:5; /* varies by payload type */
  113. unsigned short  pt:8; /* payload type           */
  114. #else
  115. unsigned short  count:5; /* varies by payload type */
  116. unsigned short  p:1; /* padding flag           */
  117. unsigned short  version:2; /* packet type            */
  118. unsigned short  pt:8; /* payload type           */
  119. #endif
  120. uint16_t        length; /* packet length          */
  121. } rtcp_common;
  123. typedef struct {
  124. rtcp_common   common;
  125. union {
  126. struct {
  127. rtcp_sr sr;
  128. rtcp_rr        rr[1]; /* variable-length list */
  129. } sr;
  130. struct {
  131. uint32_t        ssrc; /* source this RTCP packet is coming from */
  132. rtcp_rr        rr[1]; /* variable-length list */
  133. } rr;
  134. struct rtcp_sdes_t {
  135. uint32_t ssrc;
  136. rtcp_sdes_item  item[1]; /* list of SDES */
  137. } sdes;
  138. struct {
  139. uint32_t        ssrc[1]; /* list of sources */
  140. /* can't express the trailing text... */
  141. } bye;
  142. struct {
  143. uint32_t        ssrc;           
  144. uint8_t         name[4];
  145. uint8_t         data[1];
  146. } app;
  147. } r;
  148. } rtcp_t;
  150. typedef struct _rtcp_rr_wrapper {
  151. struct _rtcp_rr_wrapper *next;
  152. struct _rtcp_rr_wrapper *prev;
  153.         uint32_t                 reporter_ssrc;
  154. rtcp_rr *rr;
  155. struct timeval *ts; /* Arrival time of this RR */
  156. } rtcp_rr_wrapper;
  158. /*
  159.  * The RTP database contains source-specific information needed 
  160.  * to make it all work. 
  161.  */
  163. typedef struct _source {
  164. struct _source *next;
  165. struct _source *prev;
  166. uint32_t  ssrc;
  167. char *cname;
  168. char *name;
  169. char *email;
  170. char *phone;
  171. char *loc;
  172. char *tool;
  173. char *note;
  174. char *priv;
  175. rtcp_sr *sr;
  176. struct timeval  last_sr;
  177. struct timeval  last_active;
  178. int  should_advertise_sdes; /* TRUE if this source is a CSRC which we need to advertise SDES for */
  179. int  sender;
  180. int  got_bye; /* TRUE if we've received an RTCP bye from this source */
  181. uint32_t  base_seq;
  182. uint16_t  max_seq;
  183. uint32_t  bad_seq;
  184. uint32_t  cycles;
  185. int  received;
  186. int  received_prior;
  187. int  expected_prior;
  188. int  probation;
  189. uint32_t  jitter;
  190. uint32_t  transit;
  191. uint32_t  magic; /* For debugging... */
  192. } source;
  194. /* The size of the hash table used to hold the source database. */
  195. /* Should be large enough that we're unlikely to get collisions */
  196. /* when sources are added, but not too large that we waste too  */
  197. /* much memory. Sedgewick ("Algorithms", 2nd Ed, Addison-Wesley */
  198. /* 1988) suggests that this should be around 1/10th the number  */
  199. /* of entries that we expect to have in the database and should */
  200. /* be a prime number. Everything continues to work if this is   */
  201. /* too low, it just goes slower... for now we assume around 100 */
  202. /* participants is a sensible limit so we set this to 11.       */   
  203. #define RTP_DB_SIZE 11
  205. /*
  206.  *  Options for an RTP session are stored in the "options" struct.
  207.  */
  209. typedef struct {
  210. int  promiscuous_mode;
  211. int wait_for_rtcp;
  212. int filter_my_packets;
  213. } options;
  215. /*
  216.  * Encryption function types
  217.  */
  219. // moved to rtp.h by nori
  220. /*
  221.  * typedef int (*rtp_encrypt_func)(struct rtp *, unsigned char *data,
  222.  * unsigned int size);
  223.  *
  224.  * typedef int (*rtp_decrypt_func)(struct rtp *, unsigned char *data,
  225.  * unsigned int size);
  226.  */
  227. typedef int (*rtcp_send_f)(struct rtp *s, uint8_t *buffer, int buflen);
  229. /*
  230.  * The "struct rtp" defines an RTP session.
  231.  */
  233. struct rtp {
  234. socket_udp *rtp_socket;
  235. socket_udp *rtcp_socket;
  236. char *addr;
  237. uint16_t  rx_port;
  238. uint16_t  tx_port;
  239. int  ttl;
  240. uint32_t  my_ssrc;
  241. int  last_advertised_csrc;
  242. source *db[RTP_DB_SIZE];
  243.         rtcp_rr_wrapper  rr[RTP_DB_SIZE][RTP_DB_SIZE];  /* Indexed by [hash(reporter)][hash(reportee)] */
  244. options *opt;
  245. uint8_t *userdata;
  246. int  invalid_rtp_count;
  247. int  invalid_rtcp_count;
  248. int  bye_count;
  249. int  csrc_count;
  250. int  ssrc_count;
  251. int  ssrc_count_prev; /* ssrc_count at the time we last recalculated our RTCP interval */
  252. int  sender_count;
  253. int  initial_rtcp;
  254. int  sending_bye; /* TRUE if we're in the process of sending a BYE packet */
  255. double  avg_rtcp_size;
  256. int  we_sent;
  257. double  rtcp_bw; /* RTCP bandwidth fraction, in octets per second. */
  258. struct timeval  last_update;
  259. struct timeval  last_rtp_send_time;
  260. struct timeval  last_rtcp_send_time;
  261. struct timeval  next_rtcp_send_time;
  262. double  rtcp_interval;
  263. int  sdes_count_pri;
  264. int  sdes_count_sec;
  265. int  sdes_count_ter;
  266. uint16_t  rtp_seq;
  267. uint32_t  rtp_pcount;
  268. uint32_t  rtp_bcount;
  269.     char *encryption_algorithm;
  270.   int encryption_enabled;
  271.   rtp_encrypt_func encrypt_func;
  272.   rtp_decrypt_func decrypt_func;
  273.   int encryption_pad_length;
  274.   int encryption_lenadd;
  275.   void *encrypt_userdata; // added by nori
  276.   union {
  277.   struct {
  278.   keyInstance keyInstEncrypt;
  279.   keyInstance keyInstDecrypt;
  280.   cipherInstance cipherInst;
  281.   } rijndael;
  282.   struct {
  283.   char            *encryption_key;
  284.   } des;
  285.   } crypto_state;
  286. rtp_callback  callback;
  287.   rtcp_send_f rtcp_send;
  288.   rtcp_send_packet_t rtcp_send_packet;
  289. uint32_t  magic; /* For debugging...  */
  290. };
  292. static int filter_event(struct rtp *session, uint32_t ssrc)
  293. {
  294. int filter;
  296. rtp_get_option(session, RTP_OPT_FILTER_MY_PACKETS, &filter);
  297. return filter && (ssrc == rtp_my_ssrc(session));
  298. }
  300. static double tv_diff(struct timeval curr_time, struct timeval prev_time)
  301. {
  302.     /* Return curr_time - prev_time */
  303.     double ct, pt;
  305.     ct = (double) curr_time.tv_sec + (((double) curr_time.tv_usec) / 1000000.0);
  306.     pt = (double) prev_time.tv_sec + (((double) prev_time.tv_usec) / 1000000.0);
  307.     return (ct - pt);
  308. }
  310. static void tv_add(struct timeval *ts, double offset)
  311. {
  312. /* Add offset seconds to ts */
  313. double offset_sec, offset_usec;
  315. offset_usec = modf(offset, &offset_sec) * 1000000;
  316. ts->tv_sec  += (long) offset_sec;
  317. ts->tv_usec += (long) offset_usec;
  318. if (ts->tv_usec > 1000000) {
  319. ts->tv_sec++;
  320. ts->tv_usec -= 1000000;
  321. }
  322. }
  324. static int tv_gt(struct timeval a, struct timeval b)
  325. {
  326. /* Returns (a>b) */
  327. if (a.tv_sec > b.tv_sec) {
  328. return TRUE;
  329. }
  330. if (a.tv_sec < b.tv_sec) {
  331. return FALSE;
  332. }
  333. ASSERT(a.tv_sec == b.tv_sec);
  334. return a.tv_usec > b.tv_usec;
  335. }
  337. static uint32_t next_csrc(struct rtp *session)
  338. {
  339. /* This returns each source marked "should_advertise_sdes" in turn. */
  340. int  chain, cc;
  341. source *s;
  343. cc = 0;
  344. for (chain = 0; chain < RTP_DB_SIZE; chain++) {
  345. /* Check that the linked lists making up the chains in */
  346. /* the hash table are correctly linked together...     */
  347. for (s = session->db[chain]; s != NULL; s = s->next) {
  348. if (s->should_advertise_sdes) {
  349. if (cc == session->last_advertised_csrc) {
  350.                                         session->last_advertised_csrc++;
  351.                                         if (session->last_advertised_csrc == session->csrc_count) {
  352.                                                 session->last_advertised_csrc = 0;
  353.                                         }
  354. return s->ssrc;
  355. } else {
  356. cc++;
  357. }
  358. }
  359. }
  360. }
  361. /* We should never get here... */
  362. abort();
  363. }
  365. static int ssrc_hash(uint32_t ssrc)
  366. {
  367. /* Hash from an ssrc to a position in the source database.   */
  368. /* Assumes that ssrc values are uniformly distributed, which */
  369. /* should be true but probably isn't (Rosenberg has reported */
  370. /* that many implementations generate ssrc values which are  */
  371. /* not uniformly distributed over the space, and the H.323   */
  372. /* spec requires that they are non-uniformly distributed).   */
  373. /* This routine is written as a function rather than inline  */
  374. /* code to allow it to be made smart in future: probably we  */
  375. /* should run MD5 on the ssrc and derive a hash value from   */
  376. /* that, to ensure it's more uniformly distributed?          */
  377. return ssrc % RTP_DB_SIZE;
  378. }
  380. static void insert_rr(struct rtp *session, uint32_t reporter_ssrc, rtcp_rr *rr, struct timeval *ts)
  381. {
  382.         /* Insert the reception report into the receiver report      */
  383.         /* database. This database is a two dimensional table of     */
  384.         /* rr_wrappers indexed by hashes of reporter_ssrc and        */
  385.         /* reportee_src.  The rr_wrappers in the database are        */
  386.         /* sentinels to reduce conditions in list operations.        */
  387. /* The ts is used to determine when to timeout this rr.      */
  389.         rtcp_rr_wrapper *cur, *start;
  391.         start = &session->rr[ssrc_hash(reporter_ssrc)][ssrc_hash(rr->ssrc)];
  392.         cur   = start->next;
  394.         while (cur != start) {
  395.                 if (cur->reporter_ssrc == reporter_ssrc && cur->rr->ssrc == rr->ssrc) {
  396.                         /* Replace existing entry in the database  */
  397.                         xfree(cur->rr);
  398. xfree(cur->ts);
  399.                         cur->rr = rr;
  400. cur->ts = (struct timeval *) xmalloc(sizeof(struct timeval));
  401. memcpy(cur->ts, ts, sizeof(struct timeval));
  402.                         return;
  403.                 }
  404.                 cur = cur->next;
  405.         }
  406.         
  407.         /* No entry in the database so create one now. */
  408.         cur = (rtcp_rr_wrapper*)xmalloc(sizeof(rtcp_rr_wrapper));
  409.         cur->reporter_ssrc = reporter_ssrc;
  410.         cur->rr = rr;
  411. cur->ts = (struct timeval *) xmalloc(sizeof(struct timeval));
  412. memcpy(cur->ts, ts, sizeof(struct timeval));
  413.         /* Fix links */
  414.         cur->next       = start->next;
  415.         cur->next->prev = cur;
  416.         cur->prev       = start;
  417.         cur->prev->next = cur;
  419.         rtp_message(LOG_INFO, "Created new rr entry for 0x%08x from source 0x%08x", rr->ssrc, reporter_ssrc);
  420.         return;
  421. }
  423. static void remove_rr(struct rtp *session, uint32_t ssrc)
  424. {
  425. /* Remove any RRs from "s" which refer to "ssrc" as either   */
  426.         /* reporter or reportee.                                     */
  427.         rtcp_rr_wrapper *start, *cur, *tmp;
  428.         int i;
  430.         /* Remove rows, i.e. ssrc == reporter_ssrc                   */
  431.         for(i = 0; i < RTP_DB_SIZE; i++) {
  432.                 start = &session->rr[ssrc_hash(ssrc)][i];
  433.                 cur   = start->next;
  434.                 while (cur != start) {
  435.                         if (cur->reporter_ssrc == ssrc) {
  436.                                 tmp = cur;
  437.                                 cur = cur->prev;
  438.                                 tmp->prev->next = tmp->next;
  439.                                 tmp->next->prev = tmp->prev;
  440. xfree(tmp->ts);
  441.                                 xfree(tmp->rr);
  442.                                 xfree(tmp);
  443.                         }
  444.                         cur = cur->next;
  445.                 }
  446.         }
  448.         /* Remove columns, i.e.  ssrc == reporter_ssrc */
  449.         for(i = 0; i < RTP_DB_SIZE; i++) {
  450.                 start = &session->rr[i][ssrc_hash(ssrc)];
  451.                 cur   = start->next;
  452.                 while (cur != start) {
  453.                         if (cur->rr->ssrc == ssrc) {
  454.                                 tmp = cur;
  455.                                 cur = cur->prev;
  456.                                 tmp->prev->next = tmp->next;
  457.                                 tmp->next->prev = tmp->prev;
  458. xfree(tmp->ts);
  459.                                 xfree(tmp->rr);
  460.                                 xfree(tmp);
  461.                         }
  462.                         cur = cur->next;
  463.                 }
  464.         }
  465. }
  467. static void timeout_rr(struct rtp *session, struct timeval *curr_ts)
  468. {
  469. /* Timeout any reception reports which have been in the database for more than 3 */
  470. /* times the RTCP reporting interval without refresh.                            */
  471.         rtcp_rr_wrapper *start, *cur, *tmp;
  472. rtp_event  event;
  473.         int   i, j;
  475.         for(i = 0; i < RTP_DB_SIZE; i++) {
  476.          for(j = 0; j < RTP_DB_SIZE; j++) {
  477. start = &session->rr[i][j];
  478. cur   = start->next;
  479. while (cur != start) {
  480. if (tv_diff(*curr_ts, *(cur->ts)) > (session->rtcp_interval * 3)) {
  481. /* Signal the application... */
  482. if (!filter_event(session, cur->reporter_ssrc)) {
  483. event.ssrc = cur->reporter_ssrc;
  484. event.type = RR_TIMEOUT;
  485. event.data = cur->rr;
  486. event.ts   = curr_ts;
  487. session->callback(session, &event);
  488. }
  489. /* Delete this reception report... */
  490. tmp = cur;
  491. cur = cur->prev;
  492. tmp->prev->next = tmp->next;
  493. tmp->next->prev = tmp->prev;
  494. xfree(tmp->ts);
  495. xfree(tmp->rr);
  496. xfree(tmp);
  497. }
  498. cur = cur->next;
  499. }
  500. }
  501. }
  502. }
  504. static const rtcp_rr* get_rr(struct rtp *session, uint32_t reporter_ssrc, uint32_t reportee_ssrc)
  505. {
  506.         rtcp_rr_wrapper *cur, *start;
  508.         start = &session->rr[ssrc_hash(reporter_ssrc)][ssrc_hash(reportee_ssrc)];
  509.         cur   = start->next;
  510.         while (cur != start) {
  511.                 if (cur->reporter_ssrc == reporter_ssrc &&
  512.                     cur->rr->ssrc      == reportee_ssrc) {
  513.                         return cur->rr;
  514.                 }
  515.                 cur = cur->next;
  516.         }
  517.         return NULL;
  518. }
  520. static void check_source(source *s)
  521. {
  522. ASSERT(s != NULL);
  523. ASSERT(s->magic == 0xc001feed);
  524. }
  526. static void check_database(struct rtp *session)
  527. {
  528. /* This routine performs a sanity check on the database. */
  529. /* This should not call any of the other routines which  */
  530. /* manipulate the database, to avoid common failures.    */
  531. #ifdef DEBUG
  532. source    *s;
  533. int    source_count;
  534. int  chain;
  535. #endif
  536. ASSERT(session != NULL);
  537. ASSERT(session->magic == 0xfeedface);
  538. #ifdef DEBUG
  539. /* Check that we have a database entry for our ssrc... */
  540. /* We only do this check if ssrc_count > 0 since it is */
  541. /* performed during initialisation whilst creating the */
  542. /* source entry for my_ssrc.                           */
  543. if (session->ssrc_count > 0) {
  544. for (s = session->db[ssrc_hash(session->my_ssrc)]; s != NULL; s = s->next) {
  545. if (s->ssrc == session->my_ssrc) {
  546. break;
  547. }
  548. }
  549. ASSERT(s != NULL);
  550. }
  552. source_count = 0;
  553. for (chain = 0; chain < RTP_DB_SIZE; chain++) {
  554. /* Check that the linked lists making up the chains in */
  555. /* the hash table are correctly linked together...     */
  556. for (s = session->db[chain]; s != NULL; s = s->next) {
  557. check_source(s);
  558. source_count++;
  559. if (s->prev == NULL) {
  560. ASSERT(s == session->db[chain]);
  561. } else {
  562. ASSERT(s->prev->next == s);
  563. }
  564. if (s->next != NULL) {
  565. ASSERT(s->next->prev == s);
  566. }
  567. /* Check that the SR is for this source... */
  568. if (s->sr != NULL) {
  569.   if (s->sr->ssrc != s->ssrc) {
  570.     rtp_message(LOG_CRIT, "database error ssrc sr->ssrc is %d should be %d",
  571. s->sr->ssrc, s->ssrc);
  572. ASSERT(s->sr->ssrc == s->ssrc);
  573.   }
  574. }
  575. }
  576. }
  577. /* Check that the number of entries in the hash table  */
  578. /* matches session->ssrc_count                         */
  579. ASSERT(source_count == session->ssrc_count);
  580. if (source_count != session->ssrc_count) {
  581.   rtp_message(LOG_DEBUG, "source count %d does not equal session count %d", source_count, session->ssrc_count);
  582. }
  583. #endif
  584. }
  586. static source *get_source(struct rtp *session, uint32_t ssrc)
  587. {
  588. source *s;
  590. check_database(session);
  591. for (s = session->db[ssrc_hash(ssrc)]; s != NULL; s = s->next) {
  592. if (s->ssrc == ssrc) {
  593. check_source(s);
  594. return s;
  595. }
  596. }
  597. return NULL;
  598. }
  600. static source *create_source(struct rtp *session, uint32_t ssrc, int probation)
  601. {
  602. /* Create a new source entry, and add it to the database.    */
  603. /* The database is a hash table, using the separate chaining */
  604. /* algorithm.                                                */
  605. rtp_event  event;
  606. struct timeval  event_ts;
  607. source *s = get_source(session, ssrc);
  608. int  h;
  610. if (s != NULL) {
  611. /* Source is already in the database... Mark it as */
  612. /* active and exit (this is the common case...)    */
  613. gettimeofday(&(s->last_active), NULL);
  614. return s;
  615. }
  616. check_database(session);
  617. /* This is a new source, we have to create it... */
  618. h = ssrc_hash(ssrc);
  619. s = (source *) xmalloc(sizeof(source));
  620. memset(s, 0, sizeof(source));
  621. s->magic          = 0xc001feed;
  622. s->next           = session->db[h];
  623. s->ssrc           = ssrc;
  624. if (probation) {
  625. /* This is a probationary source, which only counts as */
  626. /* valid once several consecutive packets are received */
  627. s->probation = -1;
  628. } else {
  629. s->probation = 0;
  630. }
  632. gettimeofday(&(s->last_active), NULL);
  633. /* Now, add it to the database... */
  634. if (session->db[h] != NULL) {
  635. session->db[h]->prev = s;
  636. }
  637. session->db[ssrc_hash(ssrc)] = s;
  638. session->ssrc_count++;
  639. check_database(session);
  641. rtp_message(LOG_INFO, "Created database entry for ssrc 0x%08x (%d valid sources)", ssrc, session->ssrc_count);
  642.         if (ssrc != session->my_ssrc) {
  643.                 /* Do not send during rtp_init since application cannot map the address */
  644.                 /* of the rtp session to anything since rtp_init has not returned yet.  */
  645. if (!filter_event(session, ssrc)) {
  646. gettimeofday(&event_ts, NULL);
  647. event.ssrc = ssrc;
  648. event.type = SOURCE_CREATED;
  649. event.data = NULL;
  650. event.ts   = &event_ts;
  651. session->callback(session, &event);
  652. }
  653.         }
  655. return s;
  656. }
  658. static void delete_source(struct rtp *session, uint32_t ssrc)
  659. {
  660. /* Remove a source from the RTP database... */
  661. source *s = get_source(session, ssrc);
  662. int  h = ssrc_hash(ssrc);
  663. rtp_event  event;
  664. struct timeval  event_ts;
  666. ASSERT(s != NULL); /* Deleting a source which doesn't exist is an error... */
  668. gettimeofday(&event_ts, NULL);
  670. check_source(s);
  671. check_database(session);
  672. if (session->db[h] == s) {
  673. /* It's the first entry in this chain... */
  674. session->db[h] = s->next;
  675. if (s->next != NULL) {
  676. s->next->prev = NULL;
  677. }
  678. } else {
  679. ASSERT(s->prev != NULL); /* Else it would be the first in the chain... */
  680. s->prev->next = s->next;
  681. if (s->next != NULL) {
  682. s->next->prev = s->prev;
  683. }
  684. }
  685. /* Free the memory allocated to a source... */
  686. if (s->cname != NULL) xfree(s->cname);
  687. if (s->name  != NULL) xfree(s->name);
  688. if (s->email != NULL) xfree(s->email);
  689. if (s->phone != NULL) xfree(s->phone);
  690. if (s->loc   != NULL) xfree(s->loc);
  691. if (s->tool  != NULL) xfree(s->tool);
  692. if (s->note  != NULL) xfree(s->note);
  693. if (s->priv  != NULL) xfree(s->priv);
  694. if (s->sr    != NULL) xfree(s->sr);
  696.         remove_rr(session, ssrc); 
  698. /* Reduce our SSRC count, and perform reverse reconsideration on the RTCP */
  699. /* reporting interval (draft-ietf-avt-rtp-new-05.txt, section 6.3.4). To  */
  700. /* make the transmission rate of RTCP packets more adaptive to changes in */
  701. /* group membership, the following "reverse reconsideration" algorithm    */
  702. /* SHOULD be executed when a BYE packet is received that reduces members  */
  703. /* to a value less than pmembers:                                         */
  704. /* o  The value for tn is updated according to the following formula:     */
  705. /*       tn = tc + (members/pmembers)(tn - tc)                            */
  706. /* o  The value for tp is updated according the following formula:        */
  707. /*       tp = tc - (members/pmembers)(tc - tp).                           */
  708. /* o  The next RTCP packet is rescheduled for transmission at time tn,    */
  709. /*    which is now earlier.                                               */
  710. /* o  The value of pmembers is set equal to members.                      */
  711. session->ssrc_count--;
  712. if (session->ssrc_count < session->ssrc_count_prev) {
  713. gettimeofday(&(session->next_rtcp_send_time), NULL);
  714. gettimeofday(&(session->last_rtcp_send_time), NULL);
  715. tv_add(&(session->next_rtcp_send_time), (session->ssrc_count / session->ssrc_count_prev) 
  716.      * tv_diff(session->next_rtcp_send_time, event_ts));
  717. tv_add(&(session->last_rtcp_send_time), - ((session->ssrc_count / session->ssrc_count_prev) 
  718.      * tv_diff(event_ts, session->last_rtcp_send_time)));
  719. session->ssrc_count_prev = session->ssrc_count;
  720. }
  722. /* Reduce our csrc count... */
  723. if (s->should_advertise_sdes == TRUE) {
  724. session->csrc_count--;
  725. }
  726. if (session->last_advertised_csrc == session->csrc_count) {
  727. session->last_advertised_csrc = 0;
  728. }
  730. /* Signal to the application that this source is dead... */
  731. if (!filter_event(session, ssrc)) {
  732. event.ssrc = ssrc;
  733. event.type = SOURCE_DELETED;
  734. event.data = NULL;
  735. event.ts   = &event_ts;
  736. session->callback(session, &event);
  737. }
  738.         xfree(s);
  739. check_database(session);
  740. }
  742. static void init_seq(source *s, uint16_t seq)
  743. {
  744. /* Taken from draft-ietf-avt-rtp-new-01.txt */
  745. check_source(s);
  746. s->base_seq = seq;
  747. s->max_seq = seq;
  748. s->bad_seq = RTP_SEQ_MOD + 1;
  749. s->cycles = 0;
  750. s->received = 0;
  751. s->received_prior = 0;
  752. s->expected_prior = 0;
  753. }
  755. static int update_seq(source *s, uint16_t seq)
  756. {
  757. /* Taken from draft-ietf-avt-rtp-new-01.txt */
  758. uint16_t udelta = seq - s->max_seq;
  760. /*
  761.  * Source is not valid until MIN_SEQUENTIAL packets with
  762.  * sequential sequence numbers have been received.
  763.  */
  764. check_source(s);
  765. if (s->probation) {
  766.   /* packet is in sequence */
  767.   if (seq == s->max_seq + 1) {
  768. s->probation--;
  769. s->max_seq = seq;
  770. if (s->probation == 0) {
  771.  init_seq(s, seq);
  772.  s->received++;
  773.  return 1;
  774. }
  775.   } else {
  776. s->probation = MIN_SEQUENTIAL - 1;
  777. s->max_seq = seq;
  778.   }
  779.   return 0;
  780. } else if (udelta < MAX_DROPOUT) {
  781.   /* in order, with permissible gap */
  782.   if (seq < s->max_seq) {
  783. /*
  784.  * Sequence number wrapped - count another 64K cycle.
  785.  */
  786. s->cycles += RTP_SEQ_MOD;
  787.   }
  788.   s->max_seq = seq;
  789. } else if (udelta <= RTP_SEQ_MOD - MAX_MISORDER) {
  790.   /* the sequence number made a very large jump */
  791.   if (seq == s->bad_seq) {
  792. /*
  793.  * Two sequential packets -- assume that the other side
  794.  * restarted without telling us so just re-sync
  795.  * (i.e., pretend this was the first packet).
  796.  */
  797. init_seq(s, seq);
  798.   } else {
  799. s->bad_seq = (seq + 1) & (RTP_SEQ_MOD-1);
  800. return 0;
  801.   }
  802. } else {
  803.   /* duplicate or reordered packet */
  804. }
  805. s->received++;
  806. return 1;
  807. }
  809. static double rtcp_interval(struct rtp *session)
  810. {
  811. /* Minimum average time between RTCP packets from this site (in   */
  812. /* seconds).  This time prevents the reports from `clumping' when */
  813. /* sessions are small and the law of large numbers isn't helping  */
  814. /* to smooth out the traffic.  It also keeps the report interval  */
  815. /* from becoming ridiculously small during transient outages like */
  816. /* a network partition.                                           */
  817. double const RTCP_MIN_TIME = 5.0;
  818. /* Fraction of the RTCP bandwidth to be shared among active       */
  819. /* senders.  (This fraction was chosen so that in a typical       */
  820. /* session with one or two active senders, the computed report    */
  821. /* time would be roughly equal to the minimum report time so that */
  822. /* we don't unnecessarily slow down receiver reports.) The        */
  823. /* receiver fraction must be 1 - the sender fraction.             */
  824. double const RTCP_SENDER_BW_FRACTION = 0.25;
  825. double const RTCP_RCVR_BW_FRACTION   = (1-RTCP_SENDER_BW_FRACTION);
  826. /* To compensate for "unconditional reconsideration" converging   */
  827. /* to a value below the intended average.                         */
  828. double const COMPENSATION            = 2.71828 - 1.5;
  830. double t;               /* interval */
  831. double rtcp_min_time = RTCP_MIN_TIME;
  832. int n;         /* no. of members for computation */
  833. double rtcp_bw = session->rtcp_bw;
  835. /* Very first call at application start-up uses half the min      */
  836. /* delay for quicker notification while still allowing some time  */
  837. /* before reporting for randomization and to learn about other    */
  838. /* sources so the report interval will converge to the correct    */
  839. /* interval more quickly.                                         */
  840. if (session->initial_rtcp) {
  841. rtcp_min_time /= 2;
  842. }
  844. /* If there were active senders, give them at least a minimum     */
  845. /* share of the RTCP bandwidth.  Otherwise all participants share */
  846. /* the RTCP bandwidth equally.                                    */
  847. if (session->sending_bye) {
  848. n = session->bye_count;
  849. } else {
  850. n = session->ssrc_count;
  851. }
  852. if (session->sender_count > 0 && session->sender_count < n * RTCP_SENDER_BW_FRACTION) {
  853. if (session->we_sent) {
  854. rtcp_bw *= RTCP_SENDER_BW_FRACTION;
  855. n = session->sender_count;
  856. } else {
  857. rtcp_bw *= RTCP_RCVR_BW_FRACTION;
  858. n -= session->sender_count;
  859. }
  860. }
  862. /* The effective number of sites times the average packet size is */
  863. /* the total number of octets sent when each site sends a report. */
  864. /* Dividing this by the effective bandwidth gives the time        */
  865. /* interval over which those packets must be sent in order to     */
  866. /* meet the bandwidth target, with a minimum enforced.  In that   */
  867. /* time interval we send one report so this time is also our      */
  868. /* average time between reports.                                  */
  869. t = session->avg_rtcp_size * n / rtcp_bw;
  870. if (t < rtcp_min_time) {
  871. t = rtcp_min_time;
  872. }
  873. session->rtcp_interval = t;
  875. /* To avoid traffic bursts from unintended synchronization with   */
  876. /* other sites, we then pick our actual next report interval as a */
  877. /* random number uniformly distributed between 0.5*t and 1.5*t.   */
  878. return (t * (drand48() + 0.5)) / COMPENSATION;
  879. }
  881. #define MAXCNAMELEN 255
  883. static char *get_cname(socket_udp *s)
  884. {
  885.         /* Set the CNAME. This is "user@hostname" or just "hostname" if the username cannot be found. */
  886.         char              *hname;
  887.         char                    *uname;
  888.         char                    *cname;
  889. #ifndef WIN32
  890.         struct passwd           *pwent;
  891. #else
  892.         char *name;
  893.         int   namelen;
  894. #endif
  896.         cname = (char *) xmalloc(MAXCNAMELEN + 1);
  897.         cname[0] = '';
  899.         /* First, fill in the username... */
  900. #ifdef WIN32
  901.         name = NULL;
  902.         namelen = 0;
  903.         GetUserName(NULL, &namelen);
  904.         if (namelen > 0) {
  905.                 name = (char*)xmalloc(namelen+1);
  906.                 GetUserName(name, &namelen);
  907.         } else {
  908.                 uname = getenv("USER");
  909.                 if (uname != NULL) {
  910.                         name = xstrdup(uname);
  911.                 }
  912.         }
  913.         if (name != NULL) {
  914.                 strncpy(cname, name, MAXCNAMELEN - 1);
  915.                 strcat(cname, "@");
  916.                 xfree(name);
  917.         }
  918. #else
  919.         pwent = getpwuid(getuid());
  920.         uname = pwent->pw_name;
  921.         if (uname != NULL) {
  922.                 strncpy(cname, uname, MAXCNAMELEN - 1);
  923.                 strcat(cname, "@");
  924.         }
  926. #endif
  927.         
  928.         /* Now the hostname. Must be dotted-quad IP address. */
  929.         hname = udp_host_addr(s);
  930. if (hname == NULL) {
  931. /* If we can't get our IP address we use the loopback address... */
  932. /* This is horrible, but it stops the code from failing.         */
  933.   strncpy(cname + strlen(cname),
  934.   "127.0.0.1",
  935.   MAXCNAMELEN - strlen(cname));
  936. } else {
  937.   strncpy(cname + strlen(cname), hname, MAXCNAMELEN - strlen(cname));
  938.   xfree(hname);
  939. }
  940.         return cname;
  941. }
  943. static void init_opt(struct rtp *session)
  944. {
  945. /* Default option settings. */
  946. rtp_set_option(session, RTP_OPT_PROMISC,           FALSE);
  947. rtp_set_option(session, RTP_OPT_WEAK_VALIDATION,   TRUE);
  948. rtp_set_option(session, RTP_OPT_FILTER_MY_PACKETS, FALSE);
  949. }
  951. static void init_rng(const char *s)
  952. {
  953.         static uint32_t seed;
  954. if (s == NULL) s = "ARANDOMSTRINGSOWEDONTCOREDUMP";
  955.         if (seed == 0) {
  956.                 pid_t p = getpid();
  957. int32_t i, n;
  958.                 while (*s) {
  959.                         seed += (uint32_t)*s++;
  960.                         seed = seed * 31 + 1;
  961.                 }
  962.                 seed = 1 + seed * 31 + (uint32_t)p;
  963.                 srand48(seed);
  964. /* At time of writing we use srand48 -> srand on Win32
  965.                    which is only 16 bit. lrand48 -> rand which is only
  966.                    15 bits, step a long way through table seq */
  967. #ifdef WIN32
  968. n = (seed >> 16) & 0xffff;
  969. for(i = 0; i < n; i++) {
  970. seed = lrand48();
  971. }
  972. #endif /* WIN32 */
  973. UNUSED(i);
  974. UNUSED(n);
  975. }
  976. }
  978. /* See rtp_init_if(); calling rtp_init() is just like calling
  979.  * rtp_init_if() with a NULL interface argument.
  980.  */
  982. /**
  983.  * rtp_init:
  984.  * @addr: IP destination of this session (unicast or multicast),
  985.  * as an ASCII string.  May be a host name, which will be looked up,
  986.  * or may be an IPv4 dotted quad or IPv6 literal adddress.
  987.  * @rx_port: The port to which to bind the UDP socket
  988.  * @tx_port: The port to which to send UDP packets
  989.  * @ttl: The TTL with which to send multicasts
  990.  * @rtcp_bw: The total bandwidth (in units of bytes per second) that is
  991.  * allocated to RTCP.
  992.  * @callback: See section on #rtp_callback.
  993.  * @userdata: Opaque data associated with the session.  See
  994.  * rtp_get_userdata().
  995.  *
  996.  *
  997.  * Returns: An opaque session identifier to be used in future calls to
  998.  * the RTP library functions, or NULL on failure.
  999.  */
  1000. struct rtp *rtp_init(const char *addr, 
  1001.      uint16_t rx_port, uint16_t tx_port, 
  1002.      int ttl, double rtcp_bw, 
  1003.                      rtp_callback callback,
  1004.                      uint8_t *userdata)
  1005. {
  1006. return rtp_init_if(addr, NULL, rx_port, tx_port, ttl, rtcp_bw, callback, userdata, 0);
  1007. }
  1009. static int rtcp_local_send (struct rtp *session, uint8_t *buffer, int buflen)
  1010. {
  1011.   return (session->rtcp_send_packet)(session->userdata, buffer, buflen);
  1012. }
  1014. static int rtcp_udp_send (struct rtp *session, uint8_t *buffer, int buflen)
  1015. {
  1016.   return (udp_send(session->rtcp_socket, buffer, buflen));
  1017. }
  1019. struct rtp *rtp_init_extern_net (const char *addr, 
  1020.  uint16_t rx_port, uint16_t tx_port, 
  1021.  int ttl, double rtcp_bw, 
  1022.  rtp_callback callback,
  1023.  rtcp_send_packet_t rtcp_send_packet,
  1024.  uint8_t *userdata)
  1025. {
  1026.   rtp_t rtp_ptr = rtp_init_if(addr, NULL, rx_port, tx_port, ttl, rtcp_bw, callback, userdata, 1);
  1027.   if (rtp_ptr == NULL) return NULL;
  1028.   rtp_ptr->rtcp_send = rtcp_local_send;
  1029.   rtp_ptr->rtcp_send_packet = rtcp_send_packet;
  1030.   return (rtp_ptr);
  1031. }
  1032. /**
  1033.  * rtp_init_if:
  1034.  * @addr: IP destination of this session (unicast or multicast),
  1035.  * as an ASCII string.  May be a host name, which will be looked up,
  1036.  * or may be an IPv4 dotted quad or IPv6 literal adddress.
  1037.  * @iface: If the destination of the session is multicast,
  1038.  * the optional interface to bind to.  May be NULL, in which case
  1039.  * the default multicast interface as determined by the system
  1040.  * will be used.
  1041.  * @rx_port: The port to which to bind the UDP socket
  1042.  * @tx_port: The port to which to send UDP packets
  1043.  * @ttl: The TTL with which to send multicasts
  1044.  * @rtcp_bw: The total bandwidth (in units of ___) that is
  1045.  * allocated to RTCP.
  1046.  * @callback: See section on #rtp_callback.
  1047.  * @userdata: Opaque data associated with the session.  See
  1048.  * rtp_get_userdata().
  1049.  *
  1050.  * Creates and initializes an RTP session.
  1051.  *
  1052.  * Returns: An opaque session identifier to be used in future calls to
  1053.  * the RTP library functions, or NULL on failure.
  1054.  */
  1055. struct rtp *rtp_init_if(const char *addr, char *iface, 
  1056. uint16_t rx_port, uint16_t tx_port, 
  1057. int ttl, double rtcp_bw, 
  1058.                         rtp_callback callback,
  1059.                         uint8_t *userdata,
  1060. int dont_init_sockets)
  1061. {
  1062. struct rtp  *session;
  1063. int           i, j;
  1064. char *cname;
  1065. char *hname;
  1067.         if (ttl < 0) {
  1068.                 rtp_message(LOG_CRIT, "ttl must be greater than zero");
  1069.                 return NULL;
  1070.         }
  1071.         if (rx_port % 2) {
  1072.                 rtp_message(LOG_CRIT, "rx_port must be even");
  1073.                 return NULL;
  1074.         }
  1075.         if (tx_port % 2) {
  1076.                 rtp_message(LOG_CRIT, "tx_port must be even");
  1077.                 return NULL;
  1078.         }
  1080. session  = (struct rtp *) xmalloc(sizeof(struct rtp));
  1081. session->magic = 0xfeedface;
  1082. session->opt = (options *) xmalloc(sizeof(options));
  1083. session->userdata = userdata;
  1084. session->addr = xstrdup(addr);
  1085. session->rx_port = rx_port;
  1086. session->tx_port = tx_port;
  1087. session->ttl = min(ttl, 127);
  1089. init_opt(session);
  1091. if (dont_init_sockets == 0) {
  1092.   session->rtp_socket = udp_init_if(addr, iface, rx_port, tx_port, ttl);
  1093.   session->rtcp_socket = udp_init_if(addr, iface, (uint16_t) (rx_port+1), (uint16_t) (tx_port+1), ttl);
  1094.   if (session->rtp_socket == NULL || session->rtcp_socket == NULL) {
  1095.     xfree(session);
  1096.     return NULL;
  1097.   }
  1098. } else {
  1099.   session->rtp_socket = NULL;
  1100.   session->rtcp_socket = NULL;
  1101. }
  1103. hname = udp_host_addr(session->rtp_socket);
  1104.         init_rng(hname);
  1105. if (hname != NULL) {
  1106.   xfree(hname);
  1107. }
  1109. session->my_ssrc            = (uint32_t) lrand48();
  1110. session->rtcp_send          = rtcp_udp_send;
  1111. session->callback           = callback;
  1112. session->invalid_rtp_count  = 0;
  1113. session->invalid_rtcp_count = 0;
  1114. session->bye_count          = 0;
  1115. session->csrc_count         = 0;
  1116. session->ssrc_count         = 0;
  1117. session->ssrc_count_prev    = 0;
  1118. session->sender_count       = 0;
  1119. session->initial_rtcp       = TRUE;
  1120. session->sending_bye        = FALSE;
  1121. session->avg_rtcp_size      = -1; /* Sentinal value: reception of first packet starts initial value... */
  1122. session->we_sent            = FALSE;
  1123. session->rtcp_bw            = rtcp_bw;
  1124. session->sdes_count_pri     = 0;
  1125. session->sdes_count_sec     = 0;
  1126. session->sdes_count_ter     = 0;
  1127. session->rtp_seq            = (uint16_t) lrand48();
  1128. session->rtp_pcount         = 0;
  1129. session->rtp_bcount         = 0;
  1130. gettimeofday(&(session->last_update), NULL);
  1131. gettimeofday(&(session->last_rtcp_send_time), NULL);
  1132. gettimeofday(&(session->next_rtcp_send_time), NULL);
  1133.         session->encryption_enabled = 0;
  1134. session->encryption_algorithm = NULL;
  1136. /* Calculate when we're supposed to send our first RTCP packet... */
  1137. tv_add(&(session->next_rtcp_send_time), rtcp_interval(session));
  1139. /* Initialise the source database... */
  1140. for (i = 0; i < RTP_DB_SIZE; i++) {
  1141. session->db[i] = NULL;
  1142. }
  1143. session->last_advertised_csrc = 0;
  1145.         /* Initialize sentinels in rr table */
  1146.         for (i = 0; i < RTP_DB_SIZE; i++) {
  1147.                 for (j = 0; j < RTP_DB_SIZE; j++) {
  1148.                         session->rr[i][j].next = &session->rr[i][j];
  1149.                         session->rr[i][j].prev = &session->rr[i][j];
  1150.                 }
  1151.         }
  1153. /* Create a database entry for ourselves... */
  1154. create_source(session, session->my_ssrc, FALSE);
  1155. cname = get_cname(session->rtp_socket);
  1156. rtp_set_sdes(session, session->my_ssrc, RTCP_SDES_CNAME, cname, strlen(cname));
  1157. xfree(cname); /* cname is copied by rtp_set_sdes()... */
  1159. return session;
  1160. }
  1163. /**
  1164.  * rtp_set_my_ssrc:
  1165.  * @session: the RTP session 
  1166.  * @ssrc: the SSRC to be used by the RTP session
  1167.  * 
  1168.  * This function coerces the local SSRC identifer to be ssrc.  For
  1169.  * this function to succeed it must be called immediately after
  1170.  * rtp_init or rtp_init_if.  The intended purpose of this
  1171.  * function is to co-ordinate SSRC's between layered sessions, it
  1172.  * should not be used otherwise.
  1173.  *
  1174.  * Returns: TRUE on success, FALSE otherwise.  
  1175.  */
  1176. int rtp_set_my_ssrc(struct rtp *session, uint32_t ssrc)
  1177. {
  1178.         source *s;
  1179.         uint32_t h;
  1181.         if (session->ssrc_count != 1 && session->sender_count != 0) {
  1182.                 return FALSE;
  1183.         }
  1184.         /* Remove existing source */
  1185.         h = ssrc_hash(session->my_ssrc);
  1186.         s = session->db[h];
  1187.         session->db[h] = NULL;
  1188.         /* Fill in new ssrc       */
  1189.         session->my_ssrc = ssrc;
  1190.         s->ssrc          = ssrc;
  1191.         h                = ssrc_hash(ssrc);
  1192.         /* Put source back        */
  1193.         session->db[h]   = s;
  1194.         return TRUE;
  1195. }
  1197. /**
  1198.  * rtp_set_option:
  1199.  * @session: The RTP session.
  1200.  * @optname: The option name, see #rtp_option.
  1201.  * @optval: The value to set.
  1202.  *
  1203.  * Sets the value of a session option.  See #rtp_option for
  1204.  * documentation on the options and their legal values.
  1205.  *
  1206.  * Returns: TRUE on success, else FALSE.
  1207.  */
  1208. int rtp_set_option(struct rtp *session, rtp_option optname, int optval)
  1209. {
  1210. ASSERT((optval == TRUE) || (optval == FALSE));
  1212. switch (optname) {
  1213. case RTP_OPT_WEAK_VALIDATION:
  1214. session->opt->wait_for_rtcp = optval;
  1215. break;
  1216.         case RTP_OPT_PROMISC:
  1217. session->opt->promiscuous_mode = optval;
  1218. break;
  1219.         case RTP_OPT_FILTER_MY_PACKETS:
  1220. session->opt->filter_my_packets = optval;
  1221. break;
  1222.          default:
  1223. rtp_message(LOG_ALERT, "Ignoring unknown option (%d) in call to rtp_set_option().", optname);
  1224.                         return FALSE;
  1225. }
  1226.         return TRUE;
  1227. }
  1229. /**
  1230.  * rtp_get_option:
  1231.  * @session: The RTP session.
  1232.  * @optname: The option name, see #rtp_option.
  1233.  * @optval: The return value.
  1234.  *
  1235.  * Retrieves the value of a session option.  See #rtp_option for
  1236.  * documentation on the options and their legal values.
  1237.  *
  1238.  * Returns: TRUE and the value of the option in optval on success, else FALSE.
  1239.  */
  1240. int rtp_get_option(struct rtp *session, rtp_option optname, int *optval)
  1241. {
  1242. switch (optname) {
  1243. case RTP_OPT_WEAK_VALIDATION:
  1244. *optval = session->opt->wait_for_rtcp;
  1245.                         break;
  1246.          case RTP_OPT_PROMISC:
  1247. *optval = session->opt->promiscuous_mode;
  1248.                         break;
  1249.         case RTP_OPT_FILTER_MY_PACKETS:
  1250. *optval = session->opt->filter_my_packets;
  1251. break;
  1252.          default:
  1253.                         *optval = 0;
  1254. rtp_message(LOG_ALERT, "Ignoring unknown option (%d) in call to rtp_get_option().", optname);
  1255.                         return FALSE;
  1256. }
  1257.         return TRUE;
  1258. }
  1260. /**
  1261.  * rtp_get_userdata:
  1262.  * @session: The RTP session.
  1263.  *
  1264.  * This function returns the userdata pointer that was passed to the
  1265.  * rtp_init() or rtp_init_if() function when creating this session.
  1266.  *
  1267.  * Returns: pointer to userdata.
  1268.  */
  1269. uint8_t *rtp_get_userdata(struct rtp *session)
  1270. {
  1271. check_database(session);
  1272. return session->userdata;
  1273. }
  1275. /**
  1276.  * rtp_my_ssrc:
  1277.  * @session: The RTP Session.
  1278.  *
  1279.  * Returns: The SSRC we are currently using in this session. Note that our
  1280.  * SSRC can change at any time (due to collisions) so applications must not
  1281.  * store the value returned, but rather should call this function each time 
  1282.  * they need it.
  1283.  */
  1284. uint32_t rtp_my_ssrc(struct rtp *session)
  1285. {
  1286. check_database(session);
  1287. return session->my_ssrc;
  1288. }
  1290. static int validate_rtp(rtp_packet *packet, int len)
  1291. {
  1292. /* This function checks the header info to make sure that the packet */
  1293. /* is valid. We return TRUE if the packet is valid, FALSE otherwise. */
  1294. /* See Appendix A.1 of the RTP specification.                        */
  1296. /* We only accept RTPv2 packets... */
  1297. if (packet->rtp_pak_v != 2) {
  1298. rtp_message(LOG_WARNING, "rtp_header_validation: v != 2");
  1299. return FALSE;
  1300. }
  1301. /* Check for valid payload types..... 72-76 are RTCP payload type numbers, with */
  1302. /* the high bit missing so we report that someone is running on the wrong port. */
  1303. if (packet->rtp_pak_pt >= 72 && packet->rtp_pak_pt <= 76) {
  1304. rtp_message(LOG_WARNING, "rtp_header_validation: payload-type invalid %d - seq%d", packet->rtp_pak_pt, packet->rtp_pak_seq);
  1305. if (packet->rtp_pak_m) {
  1306. rtp_message(LOG_WARNING, " (RTCP packet on RTP port?)");
  1307. }
  1308. return FALSE;
  1309. }
  1310. /* Check that the length of the packet is sensible... */
  1311. if (len < (12 + (4 * packet->rtp_pak_cc))) {
  1312. rtp_message(LOG_WARNING, "rtp_header_validation: packet length is smaller than the header");
  1313. return FALSE;
  1314. }
  1315. /* Check that the amount of padding specified is sensible. */
  1316. /* Note: have to include the size of any extension header! */
  1317. if (packet->rtp_pak_p) {
  1318. int payload_len = len - 12 - (packet->rtp_pak_cc * 4);
  1319.                 if (packet->rtp_pak_x) {
  1320.                         /* extension header and data */
  1321.                         payload_len -= 4 * (1 + packet->rtp_extn_len);
  1322.                 }
  1323.                 if (packet->rtp_data[packet->rtp_data_len - 1] > payload_len) {
  1324.                         rtp_message(LOG_WARNING, "rtp_header_validation: padding greater than payload length");
  1325.                         return FALSE;
  1326.                 }
  1327.                 if (packet->rtp_data[packet->rtp_data_len - 1] < 1) {
  1328. rtp_message(LOG_WARNING, "rtp_header_validation: padding zero");
  1329. return FALSE;
  1330. }
  1331.         }
  1332. return TRUE;
  1333. }
  1335. static void process_rtp(struct rtp *session, uint32_t curr_rtp_ts, rtp_packet *packet, source *s)
  1336. {
  1337. int  i, d, transit;
  1338. rtp_event  event;
  1339. struct timeval  event_ts;
  1341. if (packet->rtp_pak_cc > 0) {
  1342. for (i = 0; i < packet->rtp_pak_cc; i++) {
  1343. create_source(session, packet->rtp_csrc[i], FALSE);
  1344. }
  1345. }
  1346. /* Update the source database... */
  1347. if (s->sender == FALSE) {
  1348. s->sender = TRUE;
  1349. session->sender_count++;
  1350. }
  1351. transit    = curr_rtp_ts - packet->rtp_pak_ts;
  1352. d          = transit - s->transit;
  1353. s->transit = transit;
  1354. if (d < 0) {
  1355. d = -d;
  1356. }
  1357. s->jitter += d - ((s->jitter + 8) / 16);
  1359. /* Callback to the application to process the packet... */
  1360. if (!filter_event(session, packet->rtp_pak_ssrc)) {
  1361. gettimeofday(&event_ts, NULL);
  1362. event.ssrc = packet->rtp_pak_ssrc;
  1363. event.type = RX_RTP;
  1364. event.data = (void *) packet; /* The callback function MUST free this! */
  1365. event.ts   = &event_ts;
  1366. session->callback(session, &event);
  1367. }
  1368. }
  1370. int rtp_process_recv_data (struct rtp *session,
  1371.    uint32_t curr_rtp_ts,
  1372.    rtp_packet *packet,
  1373.    int buflen)
  1374. {
  1375.   uint8_t *buffer = ((uint8_t *) packet) + RTP_PACKET_HEADER_SIZE;
  1376.   source *s;
  1377.   int ret;
  1379.   packet->pd.rtp_pd_buflen = buflen;
  1381.   if (buflen > 0) {
  1382.     if (session->encryption_enabled)
  1383.       {
  1384. ret = (session->decrypt_func)(session->encrypt_userdata, buffer, &buflen);
  1385. if (ret != TRUE) return -1;
  1386. packet->pd.rtp_pd_buflen = buflen;
  1387.       }
  1388.     
  1389.     /* Convert header fields to host byte order... */
  1390.     packet->rtp_next = packet->rtp_prev = NULL;
  1391.     packet->rtp_pak_seq  = ntohs(packet->rtp_pak_seq);
  1392.     packet->rtp_pak_ts   = ntohl(packet->rtp_pak_ts);
  1393.     packet->rtp_pak_ssrc = ntohl(packet->rtp_pak_ssrc);
  1394.     /* Setup internal pointers, etc... */
  1395.     if (packet->rtp_pak_cc) {
  1396.       int i;
  1397.       packet->rtp_csrc = (uint32_t *)(buffer + 12);
  1398.       for (i = 0; i < packet->rtp_pak_cc; i++) {
  1399. packet->rtp_csrc[i] = ntohl(packet->rtp_csrc[i]);
  1400.       }
  1401.     } else {
  1402.       packet->rtp_csrc = NULL;
  1403.     }
  1404.     if (packet->rtp_pak_x) {
  1405.       packet->rtp_extn      = buffer + 12 + (packet->rtp_pak_cc * 4);
  1406.       packet->rtp_extn_len  = (packet->rtp_extn[2] << 8) | packet->rtp_extn[3];
  1407.       packet->rtp_extn_type = (packet->rtp_extn[0] << 8) | packet->rtp_extn[1];
  1408.     } else {
  1409.       packet->rtp_extn      = NULL;
  1410.       packet->rtp_extn_len  = 0;
  1411.       packet->rtp_extn_type = 0;
  1412.     }
  1413.     packet->rtp_data     = buffer + 12 + (packet->rtp_pak_cc * 4);
  1414.     packet->rtp_data_len = buflen -  (packet->rtp_pak_cc * 4) - 12;
  1415.     if (packet->rtp_extn != NULL) {
  1416.       packet->rtp_data += ((packet->rtp_extn_len + 1) * 4);
  1417.       packet->rtp_data_len -= ((packet->rtp_extn_len + 1) * 4);
  1418.     }
  1419.     if (validate_rtp(packet, buflen)) {
  1420.       int weak = 0, promisc = 0;
  1421.       rtp_get_option(session, RTP_OPT_WEAK_VALIDATION, &weak);
  1422.       if (weak) {
  1423. s = get_source(session, packet->rtp_pak_ssrc);
  1424.       } else {
  1425. s = create_source(session, packet->rtp_pak_ssrc, TRUE);
  1426.       }
  1427.       rtp_get_option(session, RTP_OPT_PROMISC, &promisc);
  1428.       if (promisc) {
  1429. if (s == NULL) {
  1430.   create_source(session, packet->rtp_pak_ssrc, FALSE);
  1431.   s = get_source(session, packet->rtp_pak_ssrc);
  1432. }
  1433. if (s->probation == -1) {
  1434.   s->probation = MIN_SEQUENTIAL;
  1435.   s->max_seq = packet->rtp_pak_seq - 1;
  1436. }
  1437. update_seq(s, packet->rtp_pak_seq);
  1438.   
  1439. process_rtp(session, curr_rtp_ts, packet, s);
  1440. return 0; /* We don't free "packet", that's done by the callback function... */
  1441.       } 
  1442.       if (s != NULL) {
  1443. if (s->probation == -1) {
  1444.   s->probation = MIN_SEQUENTIAL;
  1445.   s->max_seq   = packet->rtp_pak_seq - 1;
  1446. }
  1447. if (update_seq(s, packet->rtp_pak_seq)) {
  1448.   process_rtp(session, curr_rtp_ts, packet, s);
  1449.   return 0; /* we don't free "packet", that's done by the callback function... */
  1450. } else {
  1451.   /* This source is still on probation... */
  1452.   rtp_message(LOG_INFO, "RTP packet from probationary source ignored...");
  1453. }
  1454.       } else {
  1455. rtp_message(LOG_WARNING, "RTP packet from unknown source %d ignored", packet->rtp_pak_ssrc);
  1456.       }
  1457.     } else {
  1458.       session->invalid_rtp_count++;
  1459.       rtp_message(LOG_INFO, "Invalid RTP packet discarded");
  1460.     }
  1461.   }
  1462.   return -1; /* We need to free the packet */
  1463. }
  1465. void rtp_recv_data(struct rtp *session, uint32_t curr_rtp_ts)
  1466. {
  1467. /* This routine preprocesses an incoming RTP packet, deciding whether to process it. */
  1468. rtp_packet *packet = (rtp_packet *) xmalloc(RTP_MAX_PACKET_LEN + RTP_PACKET_HEADER_SIZE);
  1469. uint8_t *buffer = ((uint8_t *) packet) + RTP_PACKET_HEADER_SIZE;
  1470. int  buflen;
  1472. buflen = udp_recv(session->rtp_socket, buffer, RTP_MAX_PACKET_LEN);
  1473. if (rtp_process_recv_data(session, curr_rtp_ts, packet, buflen) < 0)
  1474.   xfree(packet);
  1475. }
  1477. static int validate_rtcp(uint8_t *packet, int len)
  1478. {
  1479. /* Validity check for a compound RTCP packet. This function returns */
  1480. /* TRUE if the packet is okay, FALSE if the validity check fails.   */
  1481.         /*                                                                  */
  1482. /* The following checks can be applied to RTCP packets [RFC1889]:   */
  1483.         /* o RTP version field must equal 2.                                */
  1484.         /* o The payload type field of the first RTCP packet in a compound  */
  1485.         /*   packet must be equal to SR or RR.                              */
  1486.         /* o The padding bit (P) should be zero for the first packet of a   */
  1487.         /*   compound RTCP packet because only the last should possibly     */
  1488.         /*   need padding.                                                  */
  1489.         /* o The length fields of the individual RTCP packets must total to */
  1490.         /*   the overall length of the compound RTCP packet as received.    */
  1492. rtcp_t *pkt  = (rtcp_t *) packet;
  1493. rtcp_t *end  = (rtcp_t *) (((char *) pkt) + len);
  1494. rtcp_t *r    = pkt;
  1495. int  l    = 0;
  1496. int  pc   = 1;
  1497. int  p    = 0;
  1499. /* All RTCP packets must be compound packets (RFC1889, section 6.1) */
  1500. if (((ntohs(pkt->common.length) + 1) * 4) == len) {
  1501. rtp_message(LOG_WARNING, "Bogus RTCP packet: not a compound packet");
  1502. return FALSE;
  1503. }
  1505. /* Check the RTCP version, payload type and padding of the first in  */
  1506. /* the compund RTCP packet...                                        */
  1507. if (pkt->common.version != 2) {
  1508. rtp_message(LOG_WARNING, "Bogus RTCP packet: version number != 2 in the first sub-packet");
  1509. return FALSE;
  1510. }
  1511. if (pkt->common.p != 0) {
  1512. rtp_message(LOG_WARNING, "Bogus RTCP packet: padding bit is set on first packet in compound");
  1513. return FALSE;
  1514. }
  1515. if ((pkt->common.pt != RTCP_SR) && (pkt->common.pt != RTCP_RR)) {
  1516. rtp_message(LOG_WARNING, "Bogus RTCP packet: compund packet does not start with SR or RR");
  1517. return FALSE;
  1518. }
  1520. /* Check all following parts of the compund RTCP packet. The RTP version */
  1521. /* number must be 2, and the padding bit must be zero on all apart from  */
  1522. /* the last packet.                                                      */
  1523. do {
  1524. if (p == 1) {
  1525. rtp_message(LOG_WARNING, "Bogus RTCP packet: padding bit set before last in compound (sub-packet %d)", pc);
  1526. return FALSE;
  1527. }
  1528. if (r->common.p) {
  1529. p = 1;
  1530. }
  1531. if (r->common.version != 2) {
  1532. rtp_message(LOG_WARNING, "Bogus RTCP packet: version number != 2 in sub-packet %d", pc);
  1533. return FALSE;
  1534. }
  1535. l += (ntohs(r->common.length) + 1) * 4;
  1536. r  = (rtcp_t *) (((uint32_t *) r) + ntohs(r->common.length) + 1);
  1537. pc++; /* count of sub-packets, for debugging... */
  1538. } while (r < end);
  1540. /* Check that the length of the packets matches the length of the UDP */
  1541. /* packet in which they were received...                              */
  1542. if (l != len) {
  1543. rtp_message(LOG_WARNING, "Bogus RTCP packet: RTCP packet length does not match UDP packet length (%d != %d)", l, len);
  1544. return FALSE;
  1545. }
  1546. if (r != end) {
  1547. rtp_message(LOG_WARNING, "Bogus RTCP packet: RTCP packet length does not match UDP packet length (%p != %p)", r, end);
  1548. return FALSE;
  1549. }
  1551. return TRUE;
  1552. }
  1554. static void process_report_blocks(struct rtp *session, rtcp_t *packet, uint32_t ssrc, rtcp_rr *rrp, struct timeval *event_ts)
  1555. {
  1556. int i;
  1557. rtp_event  event;
  1558. rtcp_rr *rr;
  1560. /* ...process RRs... */
  1561. if (packet->common.count == 0) {
  1562. if (!filter_event(session, ssrc)) {
  1563. event.ssrc = ssrc;
  1564. event.type = RX_RR_EMPTY;
  1565. event.data = NULL;
  1566. event.ts   = event_ts;
  1567. session->callback(session, &event);
  1568. }
  1569. } else {
  1570. for (i = 0; i < packet->common.count; i++, rrp++) {
  1571. rr = (rtcp_rr *) xmalloc(sizeof(rtcp_rr));
  1572. rr->ssrc          = ntohl(rrp->ssrc);
  1573. rr->fract_lost    = rrp->fract_lost; /* Endian conversion handled in the */
  1574. rr->total_lost    = rrp->total_lost; /* definition of the rtcp_rr type.  */
  1575. rr->last_seq      = ntohl(rrp->last_seq);
  1576. rr->jitter        = ntohl(rrp->jitter);
  1577. rr->lsr           = ntohl(rrp->lsr);
  1578. rr->dlsr          = ntohl(rrp->dlsr);
  1580. /* Create a database entry for this SSRC, if one doesn't already exist... */
  1581. create_source(session, rr->ssrc, FALSE);
  1583. /* Store the RR for later use... */
  1584. insert_rr(session, ssrc, rr, event_ts);
  1586. /* Call the event handler... */
  1587. if (!filter_event(session, ssrc)) {
  1588. event.ssrc = ssrc;
  1589. event.type = RX_RR;
  1590. event.data = (void *) rr;
  1591. event.ts   = event_ts;
  1592. session->callback(session, &event);
  1593. }
  1594. }
  1595. }
  1596. }
  1598. static void process_rtcp_sr(struct rtp *session, rtcp_t *packet, struct timeval *event_ts)
  1599. {
  1600. uint32_t  ssrc;
  1601. rtp_event  event;
  1602. rtcp_sr *sr;
  1603. source *s;
  1605. ssrc = ntohl(packet->r.sr.sr.ssrc);
  1606. s = create_source(session, ssrc, FALSE);
  1607. if (s == NULL) {
  1608. rtp_message(LOG_WARNING, "Source 0x%08x invalid, skipping...", ssrc);
  1609. return;
  1610. }
  1612. /* Mark as an active sender, if we get a sender report... */
  1613. if (s->sender == FALSE) {
  1614. s->sender = TRUE;
  1615. session->sender_count++;
  1616. }
  1618. /* Process the SR... */
  1619. sr = (rtcp_sr *) xmalloc(sizeof(rtcp_sr));
  1620. sr->ssrc          = ssrc;
  1621. sr->ntp_sec       = ntohl(packet->r.sr.sr.ntp_sec);
  1622. sr->ntp_frac      = ntohl(packet->r.sr.sr.ntp_frac);
  1623. sr->rtp_ts        = ntohl(packet->r.sr.sr.rtp_ts);
  1624. sr->sender_pcount = ntohl(packet->r.sr.sr.sender_pcount);
  1625. sr->sender_bcount = ntohl(packet->r.sr.sr.sender_bcount);
  1627. /* Store the SR for later retrieval... */
  1628. if (s->sr != NULL) {
  1629. xfree(s->sr);
  1630. }
  1631. s->sr = sr;
  1632. s->last_sr = *event_ts;
  1634. /* Call the event handler... */
  1635. if (!filter_event(session, ssrc)) {
  1636. event.ssrc = ssrc;
  1637. event.type = RX_SR;
  1638. event.data = (void *) sr;
  1639. event.ts   = event_ts;
  1640. session->callback(session, &event);
  1641. }
  1643. process_report_blocks(session, packet, ssrc, packet->r.sr.rr, event_ts);
  1645. if (((packet->common.count * 6) + 1) < (ntohs(packet->common.length) - 5)) {
  1646. rtp_message(LOG_NOTICE, "Profile specific SR extension ignored");
  1647. }
  1648. }
  1650. static void process_rtcp_rr(struct rtp *session, rtcp_t *packet, struct timeval *event_ts)
  1651. {
  1652. uint32_t  ssrc;
  1653. source *s;
  1655. ssrc = ntohl(packet->r.rr.ssrc);
  1656. s = create_source(session, ssrc, FALSE);
  1657. if (s == NULL) {
  1658. rtp_message(LOG_WARNING, "Source 0x%08x invalid, skipping...", ssrc);
  1659. return;
  1660. }
  1662. process_report_blocks(session, packet, ssrc, packet->r.rr.rr, event_ts);
  1664. if (((packet->common.count * 6) + 1) < ntohs(packet->common.length)) {
  1665. rtp_message(LOG_INFO, "Profile specific RR extension ignored");
  1666. }
  1667. }
  1669. static void process_rtcp_sdes(struct rtp *session, rtcp_t *packet, struct timeval *event_ts)
  1670. {
  1671. int  count = packet->common.count;
  1672. struct rtcp_sdes_t  *sd   = &packet->r.sdes;
  1673. rtcp_sdes_item  *rsp; 
  1674. rtcp_sdes_item *rspn;
  1675. rtcp_sdes_item  *end  = (rtcp_sdes_item *) ((uint32_t *)packet + packet->common.length + 1);
  1676. source  *s;
  1677. rtp_event  event;
  1679. while (--count >= 0) {
  1680. rsp = &sd->item[0];
  1681. if (rsp >= end) {
  1682. break;
  1683. }
  1684. sd->ssrc = ntohl(sd->ssrc);
  1685. s = create_source(session, sd->ssrc, FALSE);
  1686. if (s == NULL) {
  1687. rtp_message(LOG_NOTICE, "Cannot get valid source entry for 0x%08x, skipping...", sd->ssrc);
  1688. } else {
  1689. for (; rsp->type; rsp = rspn ) {
  1690. rspn = (rtcp_sdes_item *)((char*)rsp+rsp->length+2);
  1691. if (rspn >= end) {
  1692. rsp = rspn;
  1693. break;
  1694. }
  1695. if (rtp_set_sdes(session, sd->ssrc, rsp->type, rsp->data, rsp->length)) {
  1696. if (!filter_event(session, sd->ssrc)) {
  1697. event.ssrc = sd->ssrc;
  1698. event.type = RX_SDES;
  1699. event.data = (void *) rsp;
  1700. event.ts   = event_ts;
  1701. session->callback(session, &event);
  1702. }
  1703. } else {
  1704. rtp_message(LOG_WARNING, "Invalid sdes item for source 0x%08x, skipping...", sd->ssrc);
  1705. }
  1706. }
  1707. }
  1708. sd = (struct rtcp_sdes_t *) ((uint32_t *)sd + (((char *)rsp - (char *)sd) >> 2)+1);
  1709. }
  1710. if (count >= 0) {
  1711. rtp_message(LOG_INFO, "Invalid RTCP SDES packet, some items ignored.");
  1712. }
  1713. }
  1715. static void process_rtcp_bye(struct rtp *session, rtcp_t *packet, struct timeval *event_ts)
  1716. {
  1717. int  i;
  1718. uint32_t  ssrc;
  1719. rtp_event  event;
  1720. source *s;
  1722. for (i = 0; i < packet->common.count; i++) {
  1723. ssrc = ntohl(packet->r.bye.ssrc[i]);
  1724. /* This is kind-of strange, since we create a source we are about to delete. */
  1725. /* This is done to ensure that the source mentioned in the event which is    */
  1726. /* passed to the user of the RTP library is valid, and simplify client code. */
  1727. create_source(session, ssrc, FALSE);
  1728. /* Call the event handler... */
  1729. if (!filter_event(session, ssrc)) {
  1730. event.ssrc = ssrc;
  1731. event.type = RX_BYE;
  1732. event.data = NULL;
  1733. event.ts   = event_ts;
  1734. session->callback(session, &event);
  1735. }
  1736. /* Mark the source as ready for deletion. Sources are not deleted immediately */
  1737. /* since some packets may be delayed and arrive after the BYE...              */
  1738. s = get_source(session, ssrc);
  1739. s->got_bye = TRUE;
  1740. check_source(s);
  1741. session->bye_count++;
  1742. }
  1743. }
  1745. static void process_rtcp_app(struct rtp *session, rtcp_t *packet, struct timeval *event_ts)
  1746. {
  1747. uint32_t         ssrc;
  1748. rtp_event        event;
  1749. rtcp_app        *app;
  1750. source          *s;
  1751. int              data_len;
  1753. /* Update the database for this source. */
  1754. ssrc = ntohl(packet->r.app.ssrc);
  1755. create_source(session, ssrc, FALSE);
  1756. s = get_source(session, ssrc);
  1757. if (s == NULL) {
  1758.         /* This should only occur in the event of database malfunction. */
  1759.         rtp_message(LOG_NOTICE, "Source 0x%08x invalid, skipping...", ssrc);
  1760.         return;
  1761. }
  1762. check_source(s);
  1764. /* Copy the entire packet, converting the header (only) into host byte order. */
  1765. app = (rtcp_app *) xmalloc(RTP_MAX_PACKET_LEN);
  1766. app->version        = packet->common.version;
  1767. app->p              = packet->common.p;
  1768. app->subtype        = packet->common.count;
  1769. app->pt             = packet->common.pt;
  1770. app->length         = ntohs(packet->common.length);
  1771. app->ssrc           = ssrc;
  1772. app->name[0]        = packet->r.app.name[0];
  1773. app->name[1]        = packet->r.app.name[1];
  1774. app->name[2]        = packet->r.app.name[2];
  1775. app->name[3]        = packet->r.app.name[3];
  1776. data_len            = (app->length - 2) * 4;
  1777. memcpy(app->data, packet->r.app.data, data_len);
  1779. /* Callback to the application to process the app packet... */
  1780. if (!filter_event(session, ssrc)) {
  1781. event.ssrc = ssrc;
  1782. event.type = RX_APP;
  1783. event.data = (void *) app;       /* The callback function MUST free this! */
  1784. event.ts   = event_ts;
  1785. session->callback(session, &event);
  1786. }
  1787. }
  1789. void rtp_process_ctrl(struct rtp *session, uint8_t *buffer, int buflen)
  1790. {
  1791. /* This routine processes incoming RTCP packets */
  1792. rtp_event  event;
  1793. struct timeval  event_ts;
  1794. rtcp_t *packet;
  1795. int  first;
  1796. uint32_t  packet_ssrc = rtp_my_ssrc(session);
  1798. gettimeofday(&event_ts, NULL);
  1799. if (buflen > 0) {
  1800. if (session->encryption_enabled)
  1801. {
  1802. /* Decrypt the packet... */
  1803. (session->decrypt_func)(session->encrypt_userdata, buffer, &buflen);
  1804. buffer += 4; /* Skip the random prefix... */
  1805. buflen -= 4;
  1806. }
  1807. if (validate_rtcp(buffer, buflen)) {
  1808. first  = TRUE;
  1809. packet = (rtcp_t *) buffer;
  1810. while (packet < (rtcp_t *) (buffer + buflen)) {
  1811. switch (packet->common.pt) {
  1812. case RTCP_SR:
  1813. if (first && !filter_event(session, ntohl(packet->r.sr.sr.ssrc))) {
  1814. event.ssrc  = ntohl(packet->r.sr.sr.ssrc);
  1815. event.type  = RX_RTCP_START;
  1816. event.data  = &buflen;
  1817. event.ts    = &event_ts;
  1818. packet_ssrc = event.ssrc;
  1819. session->callback(session, &event);
  1820. }
  1821. process_rtcp_sr(session, packet, &event_ts);
  1822. break;
  1823. case RTCP_RR:
  1824. if (first && !filter_event(session, ntohl(packet->r.rr.ssrc))) {
  1825. event.ssrc  = ntohl(packet->r.rr.ssrc);
  1826. event.type  = RX_RTCP_START;
  1827. event.data  = &buflen;
  1828. event.ts    = &event_ts;
  1829. packet_ssrc = event.ssrc;
  1830. session->callback(session, &event);
  1831. }
  1832. process_rtcp_rr(session, packet, &event_ts);
  1833. break;
  1834. case RTCP_SDES:
  1835. if (first && !filter_event(session, ntohl(packet->r.sdes.ssrc))) {
  1836. event.ssrc  = ntohl(packet->r.sdes.ssrc);
  1837. event.type  = RX_RTCP_START;
  1838. event.data  = &buflen;
  1839. event.ts    = &event_ts;
  1840. packet_ssrc = event.ssrc;
  1841. session->callback(session, &event);
  1842. }
  1843. process_rtcp_sdes(session, packet, &event_ts);
  1844. break;
  1845. case RTCP_BYE:
  1846. if (first && !filter_event(session, ntohl(packet->r.bye.ssrc[0]))) {
  1847. event.ssrc  = ntohl(packet->r.bye.ssrc[0]);
  1848. event.type  = RX_RTCP_START;
  1849. event.data  = &buflen;
  1850. event.ts    = &event_ts;
  1851. packet_ssrc = event.ssrc;
  1852. session->callback(session, &event);
  1853. }
  1854. process_rtcp_bye(session, packet, &event_ts);
  1855. break;
  1856.         case RTCP_APP:
  1857. if (first && !filter_event(session, ntohl(packet->r.app.ssrc))) {
  1858. event.ssrc  = ntohl(packet->r.app.ssrc);
  1859. event.type  = RX_RTCP_START;
  1860. event.data  = &buflen;
  1861. event.ts    = &event_ts;
  1862. packet_ssrc = event.ssrc;
  1863. session->callback(session, &event);
  1864. }
  1865.         process_rtcp_app(session, packet, &event_ts);
  1866. break;
  1867. default: 
  1868. rtp_message(LOG_WARNING, "RTCP packet with unknown type (%d) ignored.", packet->common.pt);
  1869. break;
  1870. }
  1871. packet = (rtcp_t *) ((uint8_t *) packet + (4 * (ntohs(packet->common.length) + 1)));
  1872. first  = FALSE;
  1873. }
  1874. if (session->avg_rtcp_size < 0) {
  1875. /* This is the first RTCP packet we've received, set our initial estimate */
  1876. /* of the average  packet size to be the size of this packet.             */
  1877. session->avg_rtcp_size = buflen + RTP_LOWER_LAYER_OVERHEAD;
  1878. } else {
  1879. /* Update our estimate of the average RTCP packet size. The constants are */
  1880. /* 1/16 and 15/16 (section 6.3.3 of draft-ietf-avt-rtp-new-02.txt).       */
  1881. session->avg_rtcp_size = (0.0625 * (buflen + RTP_LOWER_LAYER_OVERHEAD)) + (0.9375 * session->avg_rtcp_size);
  1882. }
  1883. /* Signal that we've finished processing this packet */
  1884. if (!filter_event(session, packet_ssrc)) {
  1885. event.ssrc = packet_ssrc;
  1886. event.type = RX_RTCP_FINISH;
  1887. event.data = NULL;
  1888. event.ts   = &event_ts;
  1889. session->callback(session, &event);
  1890. }
  1891. } else {
  1892. rtp_message(LOG_INFO, "Invalid RTCP packet discarded");
  1893. session->invalid_rtcp_count++;
  1894. }
  1895. }
  1896. }
  1898. /**
  1899.  * rtp_recv:
  1900.  * @session: the session pointer (returned by rtp_init())
  1901.  * @timeout: the amount of time that rtcp_recv() is allowed to block
  1902.  * @curr_rtp_ts: the current time expressed in units of the media
  1903.  * timestamp.
  1904.  *
  1905.  * Receive RTP packets and dispatch them.
  1906.  *
  1907.  * Returns: TRUE if data received, FALSE if the timeout occurred.
  1908.  */
  1909. int rtp_recv(struct rtp *session, struct timeval *timeout, uint32_t curr_rtp_ts)
  1910. {
  1911. check_database(session);
  1912. udp_fd_zero();
  1913. udp_fd_set(session->rtp_socket);
  1914. udp_fd_set(session->rtcp_socket);
  1915. if (udp_select(timeout) > 0) {
  1916. if (udp_fd_isset(session->rtp_socket)) {
  1917. rtp_recv_data(session, curr_rtp_ts);
  1918. }
  1919. if (udp_fd_isset(session->rtcp_socket)) {
  1920.                         uint8_t  buffer[RTP_MAX_PACKET_LEN];
  1921.                         int  buflen;
  1922.                         buflen = udp_recv(session->rtcp_socket, buffer, RTP_MAX_PACKET_LEN);
  1923. rtp_process_ctrl(session, buffer, buflen);
  1924. }
  1925. check_database(session);
  1926.                 return TRUE;
  1927. }
  1928. check_database(session);
  1929.         return FALSE;
  1930. }
  1934. /**
  1935.  * rtp_add_csrc:
  1936.  * @session: the session pointer (returned by rtp_init()) 
  1937.  * @csrc: Constributing SSRC identifier
  1938.  * 
  1939.  * Adds @csrc to list of contributing sources used in SDES items.
  1940.  * Used by mixers and transcoders.
  1941.  * 
  1942.  * Return value: TRUE.
  1943.  **/
  1944. int rtp_add_csrc(struct rtp *session, uint32_t csrc)
  1945. {
  1946. /* Mark csrc as something for which we should advertise RTCP SDES items, */
  1947. /* in addition to our own SDES.                                          */
  1948. source *s;
  1950. check_database(session);
  1951. s = get_source(session, csrc);
  1952. if (s == NULL) {
  1953. s = create_source(session, csrc, FALSE);
  1954. rtp_message(LOG_INFO, "Created source 0x%08x as CSRC", csrc);
  1955. }
  1956. check_source(s);
  1957. s->should_advertise_sdes = TRUE;
  1958. session->csrc_count++;
  1959. rtp_message(LOG_INFO, "Added CSRC 0x%08x as CSRC %d", csrc, session->csrc_count);
  1960. return TRUE;
  1961. }
  1963. /**
  1964.  * rtp_del_csrc:
  1965.  * @session: the session pointer (returned by rtp_init()) 
  1966.  * @csrc: Constributing SSRC identifier
  1967.  * 
  1968.  * Removes @csrc from list of contributing sources used in SDES items.
  1969.  * Used by mixers and transcoders.
  1970.  * 
  1971.  * Return value: TRUE on success, FALSE if @csrc is not a valid source.
  1972.  **/
  1973. int rtp_del_csrc(struct rtp *session, uint32_t csrc)
  1974. {
  1975. source *s;
  1977. check_database(session);
  1978. s = get_source(session, csrc);
  1979. if (s == NULL) {
  1980. rtp_message(LOG_ERR, "Invalid source 0x%08x when deleting", csrc);
  1981. return FALSE;
  1982. }
  1983. check_source(s);
  1984. s->should_advertise_sdes = FALSE;
  1985. session->csrc_count--;
  1986. if (session->last_advertised_csrc >= session->csrc_count) {
  1987.                 session->last_advertised_csrc = 0;
  1988.         }
  1989. return TRUE;
  1990. }
  1992. /**
  1993.  * rtp_set_sdes:
  1994.  * @session: the session pointer (returned by rtp_init()) 
  1995.  * @ssrc: the SSRC identifier of a participant
  1996.  * @type: the SDES type represented by @value
  1997.  * @value: the SDES description
  1998.  * @length: the length of the description
  1999.  * 
  2000.  * Sets session description information associated with participant
  2001.  * @ssrc.  Under normal circumstances applications always use the
  2002.  * @ssrc of the local participant, this SDES information is
  2003.  * transmitted in receiver reports.  Setting SDES information for
  2004.  * other participants affects the local SDES entries, but are not
  2005.  * transmitted onto the network.
  2006.  * 
  2007.  * Return value: Returns TRUE if participant exists, FALSE otherwise.
  2008.  **/
  2009. int rtp_set_sdes(struct rtp *session, uint32_t ssrc, rtcp_sdes_type type, const char *value, int length)
  2010. {
  2011. source *s;
  2012. char *v;
  2014. check_database(session);
  2016. s = get_source(session, ssrc);
  2017. if (s == NULL) {
  2018. rtp_message(LOG_ERR, "Invalid source 0x%08x when setting", ssrc);
  2019. return FALSE;
  2020. }
  2021. check_source(s);
  2023. v = (char *) xmalloc(length + 1);
  2024. memset(v, '', length + 1);
  2025. memcpy(v, value, length);
  2027. switch (type) {
  2028. case RTCP_SDES_CNAME: 
  2029. if (s->cname) xfree(s->cname);
  2030. s->cname = v; 
  2031. break;
  2032. case RTCP_SDES_NAME:
  2033. if (s->name) xfree(s->name);
  2034. s->name = v; 
  2035. break;
  2036. case RTCP_SDES_EMAIL:
  2037. if (s->email) xfree(s->email);
  2038. s->email = v; 
  2039. break;
  2040. case RTCP_SDES_PHONE:
  2041. if (s->phone) xfree(s->phone);
  2042. s->phone = v; 
  2043. break;
  2044. case RTCP_SDES_LOC:
  2045. if (s->loc) xfree(s->loc);
  2046. s->loc = v; 
  2047. break;
  2048. case RTCP_SDES_TOOL:
  2049. if (s->tool) xfree(s->tool);
  2050. s->tool = v; 
  2051. break;
  2052. case RTCP_SDES_NOTE:
  2053. if (s->note) xfree(s->note);
  2054. s->note = v; 
  2055. break;
  2056. case RTCP_SDES_PRIV:
  2057. if (s->priv) xfree(s->priv);
  2058. s->priv = v; 
  2059. break;
  2060. default :
  2061. rtp_message(LOG_NOTICE, "Unknown SDES item (type=%d, value=%s)", type, v);
  2062.                         xfree(v);
  2063. check_database(session);
  2064. return FALSE;
  2065. }
  2066. check_database(session);
  2067. return TRUE;
  2068. }
  2070. /**
  2071.  * rtp_get_sdes:
  2072.  * @session: the session pointer (returned by rtp_init()) 
  2073.  * @ssrc: the SSRC identifier of a participant
  2074.  * @type: the SDES information to retrieve
  2075.  * 
  2076.  * Recovers session description (SDES) information on participant
  2077.  * identified with @ssrc.  The SDES information associated with a
  2078.  * source is updated when receiver reports are received.  There are
  2079.  * several different types of SDES information, e.g. username,
  2080.  * location, phone, email.  These are enumerated by #rtcp_sdes_type.
  2081.  * 
  2082.  * Return value: pointer to string containing SDES description if
  2083.  * received, NULL otherwise.  
  2084.  */
  2085. const char *rtp_get_sdes(struct rtp *session, uint32_t ssrc, rtcp_sdes_type type)
  2086. {
  2087. source *s;
  2089. check_database(session);
  2091. s = get_source(session, ssrc);
  2092. if (s == NULL) {
  2093. rtp_message(LOG_ERR, "Invalid source 0x%08x getting sdes", ssrc);
  2094. return NULL;
  2095. }
  2096. check_source(s);
  2098. switch (type) {
  2099.         case RTCP_SDES_CNAME: 
  2100.                 return s->cname;
  2101.         case RTCP_SDES_NAME:
  2102.                 return s->name;
  2103.         case RTCP_SDES_EMAIL:
  2104.                 return s->email;
  2105.         case RTCP_SDES_PHONE:
  2106.                 return s->phone;
  2107.         case RTCP_SDES_LOC:
  2108.                 return s->loc;
  2109.         case RTCP_SDES_TOOL:
  2110.                 return s->tool;
  2111.         case RTCP_SDES_NOTE:
  2112.                 return s->note;
  2113. case RTCP_SDES_PRIV:
  2114. return s->priv;
  2115.         default:
  2116.                 /* This includes RTCP_SDES_PRIV and RTCP_SDES_END */
  2117.                 rtp_message(LOG_WARNING, "Unknown SDES item (type=%d)", type);
  2118. }
  2119. return NULL;
  2120. }
  2122. /**
  2123.  * rtp_get_sr:
  2124.  * @session: the session pointer (returned by rtp_init()) 
  2125.  * @ssrc: identifier of source
  2126.  * 
  2127.  * Retrieve the latest sender report made by sender with @ssrc identifier.
  2128.  * 
  2129.  * Return value: A pointer to an rtcp_sr structure on success, NULL
  2130.  * otherwise.  The pointer must not be freed.
  2131.  **/
  2132. const rtcp_sr *rtp_get_sr(struct rtp *session, uint32_t ssrc)
  2133. {
  2134. /* Return the last SR received from this ssrc. The */
  2135. /* caller MUST NOT free the memory returned to it. */
  2136. source *s;
  2138. check_database(session);
  2140. s = get_source(session, ssrc);
  2141. if (s == NULL) {
  2142. return NULL;
  2143. } 
  2144. check_source(s);
  2145. return s->sr;
  2146. }
  2148. /**
  2149.  * rtp_get_rr:
  2150.  * @session: the session pointer (returned by rtp_init())
  2151.  * @reporter: participant originating receiver report
  2152.  * @reportee: participant included in receiver report
  2153.  * 
  2154.  * Retrieve the latest receiver report on @reportee made by @reporter.
  2155.  * Provides an indication of other receivers reception service.
  2156.  * 
  2157.  * Return value: A pointer to a rtcp_rr structure on success, NULL
  2158.  * otherwise.  The pointer must not be freed.
  2159.  **/
  2160. const rtcp_rr *rtp_get_rr(struct rtp *session, uint32_t reporter, uint32_t reportee)
  2161. {
  2162. check_database(session);
  2163.         return get_rr(session, reporter, reportee);
  2164. }
  2166. /**
  2167.  * rtp_send_data:
  2168.  * @session: the session pointer (returned by rtp_init())
  2169.  * @rtp_ts: The timestamp reflects the sampling instant of the first octet of the RTP data to be sent.  The timestamp is expressed in media units.
  2170.  * @pt: The payload type identifying the format of the data.
  2171.  * @m: Marker bit, interpretation defined by media profile of payload.
  2172.  * @cc: Number of contributing sources (excluding local participant)
  2173.  * @csrc: Array of SSRC identifiers for contributing sources.
  2174.  * @data: The RTP data to be sent.
  2175.  * @data_len: The size @data in bytes.
  2176.  * @extn: Extension data (if present).
  2177.  * @extn_len: size of @extn in bytes.
  2178.  * @extn_type: extension type indicator.
  2179.  * 
  2180.  * Send an RTP packet.  Most media applications will only set the
  2181.  * @session, @rtp_ts, @pt, @m, @data, @data_len arguments.
  2182.  *
  2183.  * Mixers and translators typically set additional contributing sources 
  2184.  * arguments (@cc, @csrc).
  2185.  *
  2186.  * Extensions fields (@extn, @extn_len, @extn_type) are for including
  2187.  * application specific information.  When the widest amount of
  2188.  * inter-operability is required these fields should be avoided as
  2189.  * some applications discard packets with extensions they do not
  2190.  * recognize.
  2191.  * 
  2192.  * Return value: Number of bytes transmitted.
  2193.  **/
  2194. int rtp_send_data(struct rtp *session, uint32_t rtp_ts, int8_t pt, int m, 
  2195.   int cc, uint32_t* csrc, 
  2196.                   uint8_t *data, int data_len, 
  2197.   uint8_t *extn, uint16_t extn_len, uint16_t extn_type)
  2198. {
  2199. int  buffer_len, i, rc, pad, pad_len;
  2200. int malloc_len;
  2201. uint8_t *buffer;
  2202. rtp_packet *packet;
  2204. check_database(session);
  2206. ASSERT(data_len > 0);
  2208. buffer_len = data_len + 12 + (4 * cc);
  2209. if (extn != NULL) {
  2210. buffer_len += (extn_len + 1) * 4;
  2211. }
  2213. /* Do we need to pad this packet to a multiple of 64 bits? */
  2214. /* This is only needed if encryption is enabled, since DES */
  2215. /* only works on multiples of 64 bits. We just calculate   */
  2216. /* the amount of padding to add here, so we can reserve    */
  2217. /* space - the actual padding is added later.              */
  2218. pad     = FALSE;
  2219. pad_len = 0;
  2220. if (session->encryption_enabled) {
  2221.   if ((session->encryption_pad_length != 0) &&
  2222.       ((buffer_len % session->encryption_pad_length) != 0)) {
  2223.     pad         = TRUE;
  2224.     pad_len     = session->encryption_pad_length - (buffer_len % session->encryption_pad_length);
  2225.     buffer_len += pad_len; 
  2226.     ASSERT((buffer_len % session->encryption_pad_length) == 0);
  2227.   } 
  2228.   malloc_len = buffer_len;
  2229.   malloc_len = buffer_len + session->encryption_lenadd;
  2230. } else
  2231.   malloc_len = buffer_len;
  2233. /* Allocate memory for the packet... */
  2234. buffer     = (uint8_t *) xmalloc(malloc_len + RTP_PACKET_HEADER_SIZE);
  2235. packet     = (rtp_packet *) buffer;
  2237. /* These are internal pointers into the buffer... */
  2238. packet->rtp_csrc = (uint32_t *) (buffer + RTP_PACKET_HEADER_SIZE + 12);
  2239. packet->rtp_extn = (uint8_t  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc));
  2240. packet->rtp_data = (uint8_t  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc));
  2241. if (extn != NULL) {
  2242. packet->rtp_data += (extn_len + 1) * 4;
  2243. }
  2244. /* ...and the actual packet header... */
  2245. packet->rtp_pak_v    = 2;
  2246. packet->rtp_pak_p    = pad;
  2247. packet->rtp_pak_x    = (extn != NULL);
  2248. packet->rtp_pak_cc   = cc;
  2249. packet->rtp_pak_m    = m;
  2250. packet->rtp_pak_pt   = pt;
  2251. packet->rtp_pak_seq  = htons(session->rtp_seq++);
  2252. packet->rtp_pak_ts   = htonl(rtp_ts);
  2253. packet->rtp_pak_ssrc = htonl(rtp_my_ssrc(session));
  2254. /* ...now the CSRC list... */
  2255. for (i = 0; i < cc; i++) {
  2256. packet->rtp_csrc[i] = htonl(csrc[i]);
  2257. }
  2258. /* ...a header extension? */
  2259. if (extn != NULL) {
  2260. /* We don't use the packet->extn_type field here, that's for receive only... */
  2261. uint16_t *base = (uint16_t *) packet->rtp_extn;
  2262. base[0] = htons(extn_type);
  2263. base[1] = htons(extn_len);
  2264. memcpy(packet->rtp_extn + 4, extn, extn_len * 4);
  2265. }
  2266. /* ...and the media data... */
  2267. memcpy(packet->rtp_data, data, data_len);
  2268. /* ...and any padding... */
  2269. if (pad) {
  2270. for (i = 0; i < pad_len; i++) {
  2271. buffer[buffer_len + RTP_PACKET_HEADER_SIZE - pad_len + i] = 0;
  2272. }
  2273. buffer[buffer_len + RTP_PACKET_HEADER_SIZE - 1] = (uint8_t) pad_len;
  2274. }
  2275. #if 0
  2276. {
  2277.   chk_header *ch;
  2278.   ch = ((chk_header *)buffer) - 1;
  2279.   if (chk_header_okay(ch) == FALSE) {
  2280.     printf("header is not okayn");
  2281.   } else {
  2282.     printf("Header is okayn");
  2283.   }
  2284. }
  2285. #endif
  2286. /* Finally, encrypt if desired... */
  2287. if (session->encryption_enabled)
  2288. {
  2289.   if (session->encryption_pad_length != 0) {
  2290. ASSERT((buffer_len % session->encryption_pad_length) == 0);
  2291.   }
  2292. (session->encrypt_func)(session->encrypt_userdata, buffer + RTP_PACKET_HEADER_SIZE,
  2293. &buffer_len); 
  2294. }
  2296. rc = udp_send(session->rtp_socket, buffer + RTP_PACKET_HEADER_SIZE, buffer_len);
  2297. xfree(buffer);
  2299. /* Update the RTCP statistics... */
  2300. session->we_sent     = TRUE;
  2301. session->rtp_pcount += 1;
  2302. session->rtp_bcount += buffer_len;
  2303. gettimeofday(&session->last_rtp_send_time, NULL);
  2305. check_database(session);
  2306. return rc;
  2307. }
  2309. #ifndef _WIN32
  2310. int rtp_send_data_iov(struct rtp *session, uint32_t rtp_ts, int8_t pt, int m, int cc, uint32_t csrc[], struct iovec *iov, int iov_count, uint8_t *extn, uint16_t extn_len, uint16_t extn_type)
  2311. {
  2312. int  buffer_len, i, rc;
  2313. uint8_t *buffer;
  2314. rtp_packet *packet;
  2315. int my_iov_count = iov_count + 1;
  2316. struct iovec *my_iov;
  2318. /* operation not supported on encrypted sessions */
  2319. if ((session->encryption_enabled)) {
  2320. return -1;
  2321. }
  2323. check_database(session);
  2325. buffer_len = 12 + (4 * cc);
  2326. if (extn != NULL) {
  2327. buffer_len += (extn_len + 1) * 4;
  2328. }
  2330. /* Allocate memory for the packet... */
  2331. buffer     = (uint8_t *) xmalloc(buffer_len + RTP_PACKET_HEADER_SIZE);
  2332. packet     = (rtp_packet *) buffer;
  2334. /* These are internal pointers into the buffer... */
  2335. packet->rtp_csrc = (uint32_t *) (buffer + RTP_PACKET_HEADER_SIZE + 12);
  2336. packet->rtp_extn = (uint8_t  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc));
  2337. packet->rtp_data = (uint8_t  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc));
  2338. if (extn != NULL) {
  2339. packet->rtp_data += (extn_len + 1) * 4;
  2340. }
  2341. /* ...and the actual packet header... */
  2342. packet->rtp_pak_v    = 2;
  2343. packet->rtp_pak_p    = 0;
  2344. packet->rtp_pak_x    = (extn != NULL);
  2345. packet->rtp_pak_cc   = cc;
  2346. packet->rtp_pak_m    = m;
  2347. packet->rtp_pak_pt   = pt;
  2348. packet->rtp_pak_seq  = htons(session->rtp_seq++);
  2349. packet->rtp_pak_ts   = htonl(rtp_ts);
  2350. packet->rtp_pak_ssrc = htonl(rtp_my_ssrc(session));
  2351. /* ...now the CSRC list... */
  2352. for (i = 0; i < cc; i++) {
  2353. packet->rtp_csrc[i] = htonl(csrc[i]);
  2354. }
  2355. /* ...a header extension? */
  2356. if (extn != NULL) {
  2357. /* We don't use the packet->extn_type field here, that's for receive only... */
  2358. uint16_t *base = (uint16_t *) packet->rtp_extn;
  2359. base[0] = htons(extn_type);
  2360. base[1] = htons(extn_len);
  2361. memcpy(packet->rtp_extn + 4, extn, extn_len * 4);
  2362. }
  2364. /* Add the RTP packet header to the beginning of the iov list */
  2365. my_iov = (struct iovec*)xmalloc(my_iov_count * sizeof(struct iovec));
  2367. my_iov[0].iov_base = buffer + RTP_PACKET_HEADER_SIZE;
  2368. my_iov[0].iov_len = buffer_len;
  2370. for (i = 1; i < my_iov_count; i++) {
  2371. my_iov[i].iov_base = iov[i-1].iov_base;
  2372. my_iov[i].iov_len = iov[i-1].iov_len;
  2373. buffer_len += my_iov[i].iov_len;
  2374. }
  2376. /* Send the data */
  2377. rc = udp_send_iov(session->rtp_socket, my_iov, my_iov_count);
  2379. xfree(buffer);
  2380. xfree(my_iov);
  2382. /* Update the RTCP statistics... */
  2383. session->we_sent     = TRUE;
  2384. session->rtp_pcount += 1;
  2385. session->rtp_bcount += buffer_len;
  2387. check_database(session);
  2388. return rc;
  2389. }
  2390. #endif
  2392. static int format_report_blocks(rtcp_rr *rrp, int remaining_length, struct rtp *session)
  2393. {
  2394. int nblocks = 0;
  2395. int h;
  2396. source *s;
  2397. struct timeval now;
  2399. gettimeofday(&now, NULL);
  2401. for (h = 0; h < RTP_DB_SIZE; h++) {
  2402. for (s = session->db[h]; s != NULL; s = s->next) {
  2403. check_source(s);
  2404. if ((nblocks == 31) || (remaining_length < 24)) {
  2405. break; /* Insufficient space for more report blocks... */
  2406. }
  2407. if (s->sender) {
  2408. /* Much of this is taken from A.3 of draft-ietf-avt-rtp-new-01.txt */
  2409. int extended_max      = s->cycles + s->max_seq;
  2410.         int expected          = extended_max - s->base_seq + 1;
  2411.         int lost              = expected - s->received;
  2412. int expected_interval = expected - s->expected_prior;
  2413.         int received_interval = s->received - s->received_prior;
  2414.         int  lost_interval     = expected_interval - received_interval;
  2415. int fraction;
  2416. uint32_t lsr;
  2417. uint32_t dlsr;
  2419.         s->expected_prior = expected;
  2420.         s->received_prior = s->received;
  2421.         if (expected_interval == 0 || lost_interval <= 0) {
  2422. fraction = 0;
  2423.         } else {
  2424. fraction = (lost_interval << 8) / expected_interval;
  2425. }
  2427. if (s->sr == NULL) {
  2428. lsr = 0;
  2429. dlsr = 0;
  2430. } else {
  2431. lsr = ntp64_to_ntp32(s->sr->ntp_sec, s->sr->ntp_frac);
  2432. dlsr = (uint32_t)(tv_diff(now, s->last_sr) * 65536);
  2433. }
  2434. rrp->ssrc       = htonl(s->ssrc);
  2435. rrp->fract_lost = fraction;
  2436. rrp->total_lost = lost & 0x00ffffff;
  2437. rrp->last_seq   = htonl(extended_max);
  2438. rrp->jitter     = htonl(s->jitter / 16);
  2439. rrp->lsr        = htonl(lsr);
  2440. rrp->dlsr       = htonl(dlsr);
  2441. rrp++;
  2442. remaining_length -= 24;
  2443. nblocks++;
  2444. s->sender = FALSE;
  2445. session->sender_count--;
  2446. if (session->sender_count == 0) {
  2447. break; /* No point continuing, since we've reported on all senders... */
  2448. }
  2449. }
  2450. }
  2451. }
  2452. return nblocks;
  2453. }
  2455. static uint8_t *format_rtcp_sr(uint8_t *buffer, int buflen, struct rtp *session, uint32_t rtp_ts, uint64_t ntp_ts)
  2456. {
  2457. /* Write an RTCP SR into buffer, returning a pointer to */
  2458. /* the next byte after the header we have just written. */
  2459. rtcp_t *packet = (rtcp_t *) buffer;
  2460. int  remaining_length;
  2462. ASSERT(buflen >= 28); /* ...else there isn't space for the header and sender report */
  2464. packet->common.version = 2;
  2465. packet->common.p       = 0;
  2466. packet->common.count   = 0;
  2467. packet->common.pt      = RTCP_SR;
  2468. packet->common.length  = htons(1);
  2471. packet->r.sr.sr.ssrc          = htonl(rtp_my_ssrc(session));
  2472. packet->r.sr.sr.ntp_sec       = htonl((uint32_t)(ntp_ts >> 32));
  2473. packet->r.sr.sr.ntp_frac      = htonl((uint32_t)(ntp_ts & 0xFFFFFFFF));
  2474. packet->r.sr.sr.rtp_ts        = htonl(rtp_ts);
  2475. packet->r.sr.sr.sender_pcount = htonl(session->rtp_pcount);
  2476. packet->r.sr.sr.sender_bcount = htonl(session->rtp_bcount);
  2478. /* Add report blocks, until we either run out of senders */
  2479. /* to report upon or we run out of space in the buffer.  */
  2480. remaining_length = buflen - 28;
  2481. packet->common.count = format_report_blocks(packet->r.sr.rr, remaining_length, session);
  2482. packet->common.length = htons((uint16_t) (6 + (packet->common.count * 6)));
  2483. return buffer + 28 + (24 * packet->common.count);
  2484. }
  2486. static uint8_t *format_rtcp_rr(uint8_t *buffer, int buflen, struct rtp *session)
  2487. {
  2488. /* Write an RTCP RR into buffer, returning a pointer to */
  2489. /* the next byte after the header we have just written. */
  2490. rtcp_t *packet = (rtcp_t *) buffer;
  2491. int  remaining_length;
  2493. ASSERT(buflen >= 8); /* ...else there isn't space for the header */
  2495. packet->common.version = 2;
  2496. packet->common.p       = 0;
  2497. packet->common.count   = 0;
  2498. packet->common.pt      = RTCP_RR;
  2499. packet->common.length  = htons(1);
  2500. packet->r.rr.ssrc      = htonl(session->my_ssrc);
  2502. /* Add report blocks, until we either run out of senders */
  2503. /* to report upon or we run out of space in the buffer.  */
  2504. remaining_length = buflen - 8;
  2505. packet->common.count = format_report_blocks(packet->r.rr.rr, remaining_length, session);
  2506. packet->common.length = htons((uint16_t) (1 + (packet->common.count * 6)));
  2507. return buffer + 8 + (24 * packet->common.count);
  2508. }
  2510. static int add_sdes_item(uint8_t *buf, int buflen, int type, const char *val)
  2511. {
  2512. /* Fill out an SDES item. It is assumed that the item is a NULL    */
  2513. /* terminated string.                                              */
  2514.         rtcp_sdes_item *shdr = (rtcp_sdes_item *) buf;
  2515.         int             namelen;
  2517.         if (val == NULL) {
  2518.                 rtp_message(LOG_ERR, "Cannot format SDES item. type=%d val=%p", type, val);
  2519.                 return 0;
  2520.         }
  2521.         shdr->type = type;
  2522.         namelen = strlen(val);
  2523.         shdr->length = namelen;
  2524.         strncpy(shdr->data, val, buflen - 2); /* The "-2" accounts for the other shdr fields */
  2525.         return namelen + 2;
  2526. }
  2528. static uint8_t *format_rtcp_sdes(uint8_t *buffer, int buflen, uint32_t ssrc, struct rtp *session)
  2529. {
  2530.         /* From draft-ietf-avt-profile-new-00:                             */
  2531.         /* "Applications may use any of the SDES items described in the    */
  2532.         /* RTP specification. While CNAME information is sent every        */
  2533.         /* reporting interval, other items should be sent only every third */
  2534.         /* reporting interval, with NAME sent seven out of eight times     */
  2535.         /* within that slot and the remaining SDES items cyclically taking */
  2536.         /* up the eighth slot, as defined in Section 6.2.2 of the RTP      */
  2537.         /* specification. In other words, NAME is sent in RTCP packets 1,  */
  2538.         /* 4, 7, 10, 13, 16, 19, while, say, EMAIL is used in RTCP packet  */
  2539.         /* 22".                                                            */
  2540. uint8_t *packet = buffer;
  2541. rtcp_common *common = (rtcp_common *) buffer;
  2542. const char *item;
  2543. size_t  remaining_len;
  2544.         int              pad;
  2546. ASSERT(buflen > (int) sizeof(rtcp_common));
  2548. common->version = 2;
  2549. common->p       = 0;
  2550. common->count   = 1;
  2551. common->pt      = RTCP_SDES;
  2552. common->length  = 0;
  2553. packet += sizeof(common);
  2555. *((uint32_t *) packet) = htonl(ssrc);
  2556. packet += 4;
  2558. remaining_len = buflen - (packet - buffer);
  2559. item = rtp_get_sdes(session, ssrc, RTCP_SDES_CNAME);
  2560. if ((item != NULL) && ((strlen(item) + (size_t) 2) <= remaining_len)) {
  2561. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_CNAME, item);
  2562. }
  2564. remaining_len = buflen - (packet - buffer);
  2565. item = rtp_get_sdes(session, ssrc, RTCP_SDES_NOTE);
  2566. if ((item != NULL) && ((strlen(item) + (size_t) 2) <= remaining_len)) {
  2567. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_NOTE, item);
  2568. }
  2570. remaining_len = buflen - (packet - buffer);
  2571. if ((session->sdes_count_pri % 3) == 0) {
  2572. session->sdes_count_sec++;
  2573. if ((session->sdes_count_sec % 8) == 0) {
  2574. /* Note that the following is supposed to fall-through the cases */
  2575. /* until one is found to send... The lack of break statements in */
  2576. /* the switch is not a bug.                                      */
  2577. switch (session->sdes_count_ter % 5) {
  2578. case 0: item = rtp_get_sdes(session, ssrc, RTCP_SDES_TOOL);
  2579. if ((item != NULL) && ((strlen(item) + (size_t) 2) <= remaining_len)) {
  2580. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_TOOL, item);
  2581. break;
  2582. }
  2583. case 1: item = rtp_get_sdes(session, ssrc, RTCP_SDES_EMAIL);
  2584. if ((item != NULL) && ((strlen(item) + (size_t) 2) <= remaining_len)) {
  2585. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_EMAIL, item);
  2586. break;
  2587. }
  2588. case 2: item = rtp_get_sdes(session, ssrc, RTCP_SDES_PHONE);
  2589. if ((item != NULL) && ((strlen(item) + (size_t) 2) <= remaining_len)) {
  2590. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_PHONE, item);
  2591. break;
  2592. }
  2593. case 3: item = rtp_get_sdes(session, ssrc, RTCP_SDES_LOC);
  2594. if ((item != NULL) && ((strlen(item) + (size_t) 2) <= remaining_len)) {
  2595. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_LOC, item);
  2596. break;
  2597. }
  2598. case 4: item = rtp_get_sdes(session, ssrc, RTCP_SDES_PRIV);
  2599. if ((item != NULL) && ((strlen(item) + (size_t) 2) <= remaining_len)) {
  2600. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_PRIV, item);
  2601. break;
  2602. }
  2603. }
  2604. session->sdes_count_ter++;
  2605. } else {
  2606. item = rtp_get_sdes(session, ssrc, RTCP_SDES_NAME);
  2607. if (item != NULL) {
  2608. packet += add_sdes_item(packet, remaining_len, RTCP_SDES_NAME, item);
  2609. }
  2610. }
  2611. }
  2612. session->sdes_count_pri++;
  2614. /* Pad to a multiple of 4 bytes... */
  2615.         pad = 4 - ((packet - buffer) & 0x3);
  2616.         while (pad--) {
  2617.                *packet++ = RTCP_SDES_END;
  2618.         }
  2620. common->length = htons((uint16_t) (((int) (packet - buffer) / 4) - 1));
  2622. return packet;
  2623. }
  2625. static uint8_t *format_rtcp_app(uint8_t *buffer, int buflen, uint32_t ssrc, rtcp_app *app)
  2626. {
  2627. /* Write an RTCP APP into the outgoing packet buffer. */
  2628. rtcp_app    *packet       = (rtcp_app *) buffer;
  2629. int          pkt_octets   = (app->length + 1) * 4;
  2630. int          data_octets  =  pkt_octets - 12;
  2632. ASSERT(data_octets >= 0);          /* ...else not a legal APP packet.               */
  2633. ASSERT(buflen      >  pkt_octets); /* ...else there isn't space for the APP packet. */
  2635. /* Copy one APP packet from "app" to "packet". */
  2636. packet->version        =   RTP_VERSION;
  2637. packet->p              =   app->p;
  2638. packet->subtype        =   app->subtype;
  2639. packet->pt             =   RTCP_APP;
  2640. packet->length         =   htons(app->length);
  2641. packet->ssrc           =   htonl(ssrc);
  2642. memcpy(packet->name, app->name, 4);
  2643. memcpy(packet->data, app->data, data_octets);
  2645. /* Return a pointer to the byte that immediately follows the last byte written. */
  2646. return buffer + pkt_octets;
  2647. }
  2649. static void send_rtcp(struct rtp *session,
  2650.       uint32_t rtp_ts,
  2651.       uint64_t ntp_ts,
  2652.      rtcp_app_callback appcallback)
  2653. {
  2654. /* Construct and send an RTCP packet. The order in which packets are packed into a */
  2655. /* compound packet is defined by section 6.1 of draft-ietf-avt-rtp-new-03.txt and  */
  2656. /* we follow the recommended order.                                                */
  2657. uint8_t    buffer[RTP_MAX_PACKET_LEN + MAX_ENCRYPTION_PAD + 1024]; /* The +8 is to allow for padding when encrypting */
  2658. uint8_t   *ptr = buffer;
  2659. uint8_t   *old_ptr;
  2660. uint8_t   *lpt; /* the last packet in the compound */
  2661. rtcp_app  *app;
  2662. unsigned int length, new_length;
  2664. check_database(session);
  2665. /* If encryption is enabled, add a 32 bit random prefix to the packet */
  2666. if (session->encryption_enabled)
  2667. {
  2668. *((uint32_t *) ptr) = lbl_random();
  2669. ptr += 4;
  2670. }
  2672. /* The first RTCP packet in the compound packet MUST always be a report packet...  */
  2673. if (session->we_sent) {
  2674. ptr = format_rtcp_sr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session, rtp_ts, ntp_ts);
  2675. } else {
  2676. ptr = format_rtcp_rr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session);
  2677. }
  2678. /* Add the appropriate SDES items to the packet... This should really be after the */
  2679. /* insertion of the additional report blocks, but if we do that there are problems */
  2680. /* with us being unable to fit the SDES packet in when we run out of buffer space  */
  2681. /* adding RRs. The correct fix would be to calculate the length of the SDES items  */
  2682. /* in advance and subtract this from the buffer length but this is non-trivial and */
  2683. /* probably not worth it.                                                          */
  2684. lpt = ptr;
  2685. ptr = format_rtcp_sdes(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), rtp_my_ssrc(session), session);
  2687. /* If we have any CSRCs, we include SDES items for each of them in turn...         */
  2688. if (session->csrc_count > 0) {
  2689. ptr = format_rtcp_sdes(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), next_csrc(session), session);
  2690. }
  2692. /* Following that, additional RR packets SHOULD follow if there are more than 31   */
  2693. /* senders, such that the reports do not fit into the initial packet. We give up   */
  2694. /* if there is insufficient space in the buffer: this is bad, since we always drop */
  2695. /* the reports from the same sources (those at the end of the hash table).         */
  2696. while ((session->sender_count > 0)  && ((RTP_MAX_PACKET_LEN - (ptr - buffer)) >= 8)) {
  2697. lpt = ptr;
  2698. ptr = format_rtcp_rr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session);
  2699. }
  2701. /* Finish with as many APP packets as the application will provide. */
  2702. old_ptr = ptr;
  2703. if (appcallback) {
  2704. while ((app = (*appcallback)(session, rtp_ts, RTP_MAX_PACKET_LEN - (ptr - buffer)))) {
  2705. lpt = ptr;
  2706. ptr = format_rtcp_app(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), rtp_my_ssrc(session), app);
  2707. ASSERT(ptr > old_ptr);
  2708. old_ptr = ptr;
  2709. ASSERT(RTP_MAX_PACKET_LEN - (ptr - buffer) >= 0);
  2710. }
  2711. }
  2713. /* And encrypt if desired... */
  2714. if (session->encryption_enabled)
  2715.   {
  2716.     if (session->encryption_pad_length != 0) {
  2717. if (((ptr - buffer) % session->encryption_pad_length) != 0) {
  2718. /* Add padding to the last packet in the compound, if necessary. */
  2719. /* We don't have to worry about overflowing the buffer, since we */
  2720. /* intentionally allocated it 8 bytes longer to allow for this.  */
  2721. int padlen = session->encryption_pad_length - ((ptr - buffer) % session->encryption_pad_length);
  2722. int i;
  2724. for (i = 0; i < padlen-1; i++) {
  2725. *(ptr++) = '';
  2726. }
  2727. *(ptr++) = (uint8_t) padlen;
  2728. ASSERT(((ptr - buffer) % session->encryption_pad_length) == 0); 
  2730. ((rtcp_t *) lpt)->common.p = TRUE;
  2731. ((rtcp_t *) lpt)->common.length = htons((int16_t)(((ptr - lpt) / 4) - 1));
  2732. }
  2733.     }
  2734.     //     (session->encrypt_func)(session, buffer, ptr - buffer); 
  2735.     //NORI - FIGURE OUT HOW TO FIX THIS - Change the value of ptr
  2736.     length = ptr - buffer;//nori
  2737.     new_length = length;
  2738.     (session->encrypt_func)(session->encrypt_userdata, buffer, &new_length); //nori
  2739.     if (new_length != length) ptr += new_length - length;
  2740. }
  2741. if (session->rtcp_bw != 0.0) {
  2742.   (session->rtcp_send)(session, buffer, ptr - buffer);
  2743.   //(session->rtcp_send)(session, buffer, length);   
  2744. }
  2746.         /* Loop the data back to ourselves so local participant can */
  2747.         /* query own stats when using unicast or multicast with no  */
  2748.         /* loopback.                                                */
  2749. //        rtp_process_ctrl(session, buffer, ptr - buffer);
  2750.         rtp_process_ctrl(session, buffer, ptr - buffer);
  2751. check_database(session);
  2752. }
  2754. /**
  2755.  * rtp_send_ctrl:
  2756.  * @session: the session pointer (returned by rtp_init())
  2757.  * @rtp_ts: the current time expressed in units of the media timestamp.
  2758.  * @appcallback: a callback to create an APP RTCP packet, if needed.
  2759.  *
  2760.  * Checks RTCP timer and sends RTCP data when nececessary.  The
  2761.  * interval between RTCP packets is randomized over an interval that
  2762.  * depends on the session bandwidth, the number of participants, and
  2763.  * whether the local participant is a sender.  This function should be
  2764.  * called at least once per second, and can be safely called more
  2765.  * frequently.  
  2766.  */
  2767. void rtp_send_ctrl(struct rtp *session,
  2768.    uint32_t rtp_ts,
  2769.    rtcp_app *(*appcallback)(struct rtp *session, uint32_t rtp_ts, int max_size))
  2770. {
  2771.       uint32_t         ntp_sec, ntp_frac;
  2772.       ntp64_time(&ntp_sec, &ntp_frac);
  2773.       rtp_send_ctrl_2(session, rtp_ts, (((uint64_t)ntp_sec) << 32) | ntp_frac, appcallback);
  2774. }
  2775. void rtp_send_ctrl_2(struct rtp *session,
  2776.      uint32_t rtp_ts,
  2777.      uint64_t ntp_ts,
  2778.      rtcp_app *(*appcallback)(struct rtp *session, uint32_t rtp_ts, int max_size))
  2779. {
  2780. /* Send an RTCP packet, if one is due... */
  2781. struct timeval  curr_time;
  2783. check_database(session);
  2784. gettimeofday(&curr_time, NULL);
  2785. if (tv_gt(curr_time, session->next_rtcp_send_time)) {
  2786. /* The RTCP transmission timer has expired. The following */
  2787. /* implements draft-ietf-avt-rtp-new-02.txt section 6.3.6 */
  2788. int  h;
  2789. source *s;
  2790. struct timeval  new_send_time;
  2791. double  new_interval;
  2793. new_interval  = rtcp_interval(session) / (session->csrc_count + 1);
  2794. new_send_time = session->last_rtcp_send_time;
  2795. tv_add(&new_send_time, new_interval);
  2796. if (tv_gt(curr_time, new_send_time)) {
  2797. send_rtcp(session, rtp_ts, ntp_ts, appcallback);
  2798. session->initial_rtcp        = FALSE;
  2799. session->last_rtcp_send_time = curr_time;
  2800. session->next_rtcp_send_time = curr_time; 
  2801. tv_add(&(session->next_rtcp_send_time), rtcp_interval(session) / (session->csrc_count + 1));
  2802. /* We're starting a new RTCP reporting interval, zero out */
  2803. /* the per-interval statistics.                           */
  2804. session->sender_count = 0;
  2805. for (h = 0; h < RTP_DB_SIZE; h++) {
  2806. for (s = session->db[h]; s != NULL; s = s->next) {
  2807. check_source(s);
  2808. s->sender = FALSE;
  2809. }
  2810. }
  2811. } else {
  2812. session->next_rtcp_send_time = new_send_time;
  2813. }
  2814. session->ssrc_count_prev = session->ssrc_count;
  2815. } 
  2816. check_database(session);
  2817. }
  2819. /**
  2820.  * rtp_update:
  2821.  * @session: the session pointer (returned by rtp_init())
  2822.  *
  2823.  * Trawls through the internal data structures and performs
  2824.  * housekeeping.  This function should be called at least once per
  2825.  * second.  It uses an internal timer to limit the number of passes
  2826.  * through the data structures to once per second, it can be safely
  2827.  * called more frequently.
  2828.  */
  2829. void rtp_update(struct rtp *session)
  2830. {
  2831. /* Perform housekeeping on the source database... */
  2832. int    h;
  2833. source   *s, *n;
  2834. struct timeval  curr_time;
  2835. double  delay;
  2837. gettimeofday(&curr_time, NULL);
  2838. if (tv_diff(curr_time, session->last_update) < 1.0) {
  2839. /* We only perform housekeeping once per second... */
  2840. return;
  2841. }
  2842. session->last_update = curr_time;
  2844. /* Update we_sent (section 6.3.8 of RTP spec) */
  2845. delay = tv_diff(curr_time, session->last_rtp_send_time);
  2846. if (delay >= 2 * rtcp_interval(session)) {
  2847. session->we_sent = FALSE;
  2848. }
  2850. check_database(session);
  2852. for (h = 0; h < RTP_DB_SIZE; h++) {
  2853. for (s = session->db[h]; s != NULL; s = n) {
  2854. check_source(s);
  2855. n = s->next;
  2856. /* Expire sources which haven't been heard from for a long time.   */
  2857. /* Section 6.2.1 of the RTP specification details the timers used. */
  2859. /* How long since we last heard from this source?  */
  2860. delay = tv_diff(curr_time, s->last_active);
  2862. /* Check if we've received a BYE packet from this source.    */
  2863. /* If we have, and it was received more than 2 seconds ago   */
  2864. /* then the source is deleted. The arbitrary 2 second delay  */
  2865. /* is to ensure that all delayed packets are received before */
  2866. /* the source is timed out.                                  */
  2867. if (s->got_bye && (delay > 2.0)) {
  2868. rtp_message(LOG_INFO, "Deleting source 0x%08x due to reception of BYE %f seconds ago...", s->ssrc, delay);
  2869. delete_source(session, s->ssrc);
  2870. }
  2872. /* Sources are marked as inactive if they haven't been heard */
  2873. /* from for more than 2 intervals (RTP section 6.3.5)        */
  2874. if ((s->ssrc != rtp_my_ssrc(session)) && (delay > (session->rtcp_interval * 2))) {
  2875. if (s->sender) {
  2876. s->sender = FALSE;
  2877. session->sender_count--;
  2878. }
  2879. }
  2881. /* If a source hasn't been heard from for more than 5 RTCP   */
  2882. /* reporting intervals, we delete it from our database...    */
  2883. if ((s->ssrc != rtp_my_ssrc(session)) && (delay > (session->rtcp_interval * 5))) {
  2884. rtp_message(LOG_INFO, "Deleting source 0x%08x due to timeout...", s->ssrc);
  2885. delete_source(session, s->ssrc);
  2886. }
  2887. }
  2888. }
  2890. /* Timeout those reception reports which haven't been refreshed for a long time */
  2891. timeout_rr(session, &curr_time);
  2892. check_database(session);
  2893. }
  2895. static void rtp_send_bye_now(struct rtp *session)
  2896. {
  2897. /* Send a BYE packet immediately. This is an internal function,  */
  2898. /* hidden behind the rtp_send_bye() wrapper which implements BYE */
  2899. /* reconsideration for the application.                          */
  2900. uint8_t    buffer[RTP_MAX_PACKET_LEN + MAX_ENCRYPTION_PAD + 1024]; /* + 8 to allow for padding when encrypting */
  2901. uint8_t *ptr = buffer;
  2902. rtcp_common *common;
  2903. unsigned int length, new_length; //nori
  2904. check_database(session);
  2905. /* If encryption is enabled, add a 32 bit random prefix to the packet */
  2906. if (session->encryption_enabled) {
  2907. *((uint32_t *) ptr) = lbl_random();
  2908. ptr += 4;
  2909. }
  2911. ptr    = format_rtcp_rr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session);    
  2912. common = (rtcp_common *) ptr;
  2914. common->version = 2;
  2915. common->p       = 0;
  2916. common->count   = 1;
  2917. common->pt      = RTCP_BYE;
  2918. common->length  = htons(1);
  2919. ptr += sizeof(common);
  2921. *((uint32_t *) ptr) = htonl(session->my_ssrc);  
  2922. ptr += 4;
  2924. if (session->encryption_enabled) {
  2925.        if (session->encryption_pad_length != 0) {
  2926.       if (((ptr - buffer) % session->encryption_pad_length) != 0) {
  2927. /* Add padding to the last packet in the compound, if necessary. */
  2928. /* We don't have to worry about overflowing the buffer, since we */
  2929. /* intentionally allocated it 8 bytes longer to allow for this.  */
  2930. int padlen = session->encryption_pad_length - ((ptr - buffer) % session->encryption_pad_length);
  2931. int i;
  2933. for (i = 0; i < padlen-1; i++) {
  2934. *(ptr++) = '';
  2935. }
  2936. *(ptr++) = (uint8_t) padlen;
  2938. common->p      = TRUE;
  2939. common->length = htons((int16_t)(((ptr - (uint8_t *) common) / 4) - 1));
  2940. }
  2941. ASSERT(((ptr - buffer) % session->encryption_pad_length) == 0);
  2942.     }
  2943.     //     (session->encrypt_func)(session, buffer, ptr - buffer);
  2944.     // NORI - FIX THIS, TOO
  2945.     new_length = length = ptr - buffer;//nori
  2946.     (session->encrypt_func)(session->encrypt_userdata, buffer, &new_length);//nori
  2947.     ptr += new_length - length;
  2948. }
  2949. (session->rtcp_send)(session, buffer, ptr - buffer);
  2950. //(session->rtcp_send)(session, buffer, length);
  2951. /* Loop the data back to ourselves so local participant can */
  2952. /* query own stats when using unicast or multicast with no  */
  2953. /* loopback.                                                */
  2954. rtp_process_ctrl(session, buffer, ptr - buffer);
  2955. //rtp_process_ctrl(session, buffer, length);
  2956. check_database(session);
  2957. }
  2959. /**
  2960.  * rtp_send_bye:
  2961.  * @session: The RTP session
  2962.  *
  2963.  * Sends a BYE message on the RTP session, indicating that this
  2964.  * participant is leaving the session. The process of sending a
  2965.  * BYE may take some time, and this function will block until 
  2966.  * it is complete. During this time, RTCP events are reported 
  2967.  * to the application via the callback function (data packets 
  2968.  * are silently discarded).
  2969.  */
  2970. void rtp_send_bye(struct rtp *session)
  2971. {
  2972. struct timeval curr_time, timeout, new_send_time;
  2973. uint8_t buffer[RTP_MAX_PACKET_LEN];
  2974. int buflen;
  2975. double new_interval;
  2977. check_database(session);
  2979. /* "...a participant which never sent an RTP or RTCP packet MUST NOT send  */
  2980. /* a BYE packet when they leave the group." (section 6.3.7 of RTP spec)    */
  2981. if ((session->we_sent == FALSE) && (session->initial_rtcp == TRUE)) {
  2982. rtp_message(LOG_NOTICE, "Silent BYE");
  2983. return;
  2984. }
  2986. /* If the session is small, send an immediate BYE. Otherwise, we delay and */
  2987. /* perform BYE reconsideration as needed.                                  */
  2988. if ((session->ssrc_count < 50) || session->rtp_socket == NULL) {
  2989. rtp_send_bye_now(session);
  2990. } else {
  2991. gettimeofday(&curr_time, NULL);
  2992. session->sending_bye         = TRUE;
  2993. session->last_rtcp_send_time = curr_time;
  2994. session->next_rtcp_send_time = curr_time; 
  2995. session->bye_count           = 1;
  2996. session->initial_rtcp        = TRUE;
  2997. session->we_sent             = FALSE;
  2998. session->sender_count        = 0;
  2999. session->avg_rtcp_size       = 70.0 + RTP_LOWER_LAYER_OVERHEAD; /* FIXME */
  3000. tv_add(&session->next_rtcp_send_time, rtcp_interval(session) / (session->csrc_count + 1));
  3002. rtp_message(LOG_DEBUG, "Preparing to send BYE...");
  3003. while (1) {
  3004. /* Schedule us to block in udp_select() until the time we are due to send our */
  3005. /* BYE packet. If we receive an RTCP packet from another participant before   */
  3006. /* then, we are woken up to handle it...                                      */
  3007. timeout.tv_sec  = 0;
  3008. timeout.tv_usec = 0;
  3009. tv_add(&timeout, tv_diff(session->next_rtcp_send_time, curr_time));
  3010. udp_fd_zero();
  3011. udp_fd_set(session->rtcp_socket);
  3012. if ((udp_select(&timeout) > 0) && udp_fd_isset(session->rtcp_socket)) {
  3013. /* We woke up because an RTCP packet was received; process it... */
  3014. buflen = udp_recv(session->rtcp_socket, buffer, RTP_MAX_PACKET_LEN);
  3015. rtp_process_ctrl(session, buffer, buflen);
  3016. }
  3017. /* Is it time to send our BYE? */
  3018. gettimeofday(&curr_time, NULL);
  3019. new_interval  = rtcp_interval(session) / (session->csrc_count + 1);
  3020. new_send_time = session->last_rtcp_send_time;
  3021. tv_add(&new_send_time, new_interval);
  3022. if (tv_gt(curr_time, new_send_time)) {
  3023. rtp_message(LOG_DEBUG, "Sent BYE...");
  3024. rtp_send_bye_now(session);
  3025. break;
  3026. }
  3027. /* No, we reconsider... */
  3028. session->next_rtcp_send_time = new_send_time;
  3029. rtp_message(LOG_INFO, "Reconsidered sending BYE... delay = %f", tv_diff(session->next_rtcp_send_time, curr_time));
  3030. /* ...and perform housekeeping in the usual manner */
  3031. rtp_update(session);
  3032. }
  3033. }
  3034. }
  3036. /**
  3037.  * rtp_done:
  3038.  * @session: the RTP session to finish
  3039.  *
  3040.  * Free the state associated with the given RTP session. This function does 
  3041.  * not send any packets (e.g. an RTCP BYE) - an application which wishes to
  3042.  * exit in a clean manner should call rtp_send_bye() first.
  3043.  */
  3044. void rtp_done(struct rtp *session)
  3045. {
  3046. int i;
  3047.         source *s, *n;
  3049. check_database(session);
  3050.         /* In delete_source, check database gets called and this assumes */
  3051.         /* first added and last removed is us.                           */
  3052. for (i = 0; i < RTP_DB_SIZE; i++) {
  3053.                 s = session->db[i];
  3054.                 while (s != NULL) {
  3055.                         n = s->next;
  3056.                         if (s->ssrc != session->my_ssrc) {
  3057.                                 delete_source(session,session->db[i]->ssrc);
  3058.                         }
  3059.                         s = n;
  3060.                 }
  3061. }
  3063. delete_source(session, session->my_ssrc);
  3065. /*
  3066.  * Introduce a memory leak until we add algorithm-specific
  3067.  * cleanup functions.
  3068.         if (session->encryption_key != NULL) {
  3069.                 xfree(session->encryption_key);
  3070.         }
  3071. */
  3073. if (session->rtp_socket != NULL) {
  3074.   udp_exit(session->rtp_socket);
  3075.   session->rtp_socket = NULL;
  3076. }
  3077. if (session->rtcp_socket != NULL) {
  3078.   udp_exit(session->rtcp_socket);
  3079.   session->rtcp_socket = NULL;
  3080. }
  3081. xfree(session->addr);
  3082. xfree(session->opt);
  3083. xfree(session);
  3084. }
  3086. /**
  3087.  * rtp_set_encryption_key:
  3088.  * @session: The RTP session.
  3089.  * @passphrase: The user-provided "pass phrase" to map to an encryption key.
  3090.  *
  3091.  * Converts the user supplied key into a form suitable for use with RTP
  3092.  * and install it as the active key. Passing in NULL as the passphrase
  3093.  * disables encryption. The passphrase is converted into a DES key as
  3094.  * specified in RFC1890, that is:
  3095.  * 
  3096.  *   - convert to canonical form
  3097.  * 
  3098.  *   - derive an MD5 hash of the canonical form
  3099.  * 
  3100.  *   - take the first 56 bits of the MD5 hash
  3101.  * 
  3102.  *   - add parity bits to form a 64 bit key
  3103.  * 
  3104.  * Note that versions of rat prior to 4.1.2 do not convert the passphrase
  3105.  * to canonical form before taking the MD5 hash, and so will
  3106.  * not be compatible for keys which are non-invarient under this step.
  3107.  *
  3108.  * Determine from the user's encryption key which encryption
  3109.  * mechanism we're using. Per the RTP RFC, if the key is of the form
  3110.  *
  3111.  * string/key
  3112.  *
  3113.  * then "string" is the name of the encryption algorithm,  and
  3114.  * "key" is the key to be used. If no / is present, then the
  3115.  * algorithm is assumed to be (the appropriate variant of) DES.
  3116.  *
  3117.  * Returns: TRUE on success, FALSE on failure.
  3118.  */
  3119. int rtp_set_encryption_key(struct rtp* session, const char *passphrase)
  3120. {
  3121. char *canonical_passphrase;
  3122. u_char  hash[16];
  3123. MD5_CTX  context;
  3124. char *slash;
  3126. check_database(session);
  3127.         if (session->encryption_algorithm != NULL) {
  3128. xfree(session->encryption_algorithm);
  3129.   session->encryption_algorithm = NULL;
  3130.         }
  3132. if (passphrase == NULL) {
  3133. /* A NULL passphrase means disable encryption... */
  3134.     session->encryption_enabled = 0;
  3135. check_database(session);
  3136. return TRUE;
  3137. }
  3139. rtp_message(LOG_DEBUG, "Enabling RTP/RTCP encryption");
  3140. session->encryption_enabled = 1;
  3142.   /*
  3143.    * Determine which algorithm we're using.
  3144.    */
  3145.  
  3146.   slash = strchr(passphrase, '/');
  3147.   if (slash == 0)
  3148.   {
  3149.     session->encryption_algorithm = xstrdup("DES");
  3150.   }
  3151.   else
  3152.   {
  3153.     int l = slash - passphrase;
  3154.     session->encryption_algorithm = xmalloc(l + 1);
  3155.     strncpy(session->encryption_algorithm, passphrase, l);
  3156.     session->encryption_algorithm[l] = '';
  3157.     passphrase = slash + 1;
  3158.   }
  3159.  
  3160.   rtp_message(LOG_INFO, "Initializing encryption, algorithm is '%s'",
  3161.     session->encryption_algorithm);
  3162.  
  3163. /* Step 1: convert to canonical form, comprising the following steps:  */
  3164. /*   a) convert the input string to the ISO 10646 character set, using */
  3165. /*      the UTF-8 encoding as specified in Annex P to ISO/IEC          */
  3166. /*      10646-1:1993 (ASCII characters require no mapping, but ISO     */
  3167. /*      8859-1 characters do);                                         */
  3168. /*   b) remove leading and trailing white space characters;            */
  3169. /*   c) replace one or more contiguous white space characters by a     */
  3170. /*      single space (ASCII or UTF-8 0x20);                            */
  3171. /*   d) convert all letters to lower case and replace sequences of     */
  3172. /*      characters and non-spacing accents with a single character,    */
  3173. /*      where possible.                                                */
  3174. canonical_passphrase = (char *) xstrdup(passphrase); /* FIXME */
  3176. /* Step 2: derive an MD5 hash */
  3177. MD5Init(&context);
  3178. MD5Update(&context, (u_char *) canonical_passphrase, strlen(canonical_passphrase));
  3179. MD5Final((u_char *) hash, &context);
  3181. /* Initialize the encryption algorithm we've received */
  3183. if (strcmp(session->encryption_algorithm, "DES") == 0)
  3184. {
  3185. return des_initialize(session, hash, sizeof(hash));
  3186. }
  3187. else if (strcmp(session->encryption_algorithm, "Rijndael") == 0)
  3188. {
  3189. return rijndael_initialize(session, hash, sizeof(hash));
  3190. }
  3191. else
  3192. {
  3193. rtp_message(LOG_ERR, "Encryption algorithm "%s" not found",
  3194.   session->encryption_algorithm);
  3195. return FALSE;
  3196. }
  3197. }
  3199. static int des_initialize(struct rtp *session, u_char *hash, int hashlen)
  3200. {
  3201. char *key;
  3202. int  i, j, k;
  3204. UNUSED(hashlen);
  3206. rtp_set_encryption(session,des_encrypt, des_decrypt, session->encrypt_userdata, 0);
  3207. session->encryption_pad_length = 8;
  3208. //nori
  3209. // session->encrypt_func = des_encrypt;
  3210. //session->decrypt_func = des_decrypt;
  3212.         if (session->crypto_state.des.encryption_key != NULL) {
  3213.                 xfree(session->crypto_state.des.encryption_key);
  3214.         }
  3216.         key = session->crypto_state.des.encryption_key = (char *) xmalloc(8);
  3218. /* Step 3: take first 56 bits of the MD5 hash */
  3219. key[0] = hash[0];
  3220. key[1] = hash[0] << 7 | hash[1] >> 1;
  3221. key[2] = hash[1] << 6 | hash[2] >> 2;
  3222. key[3] = hash[2] << 5 | hash[3] >> 3;
  3223. key[4] = hash[3] << 4 | hash[4] >> 4;
  3224. key[5] = hash[4] << 3 | hash[5] >> 5;
  3225. key[6] = hash[5] << 2 | hash[6] >> 6;
  3226. key[7] = hash[6] << 1;
  3228. /* Step 4: add parity bits */
  3229. for (i = 0; i < 8; ++i) {
  3230. k = key[i] & 0xfe;
  3231. j = k;
  3232. j ^= j >> 4;
  3233. j ^= j >> 2;
  3234. j ^= j >> 1;
  3235. j = (j & 1) ^ 1;
  3236. key[i] = k | j;
  3237. }
  3239. check_database(session);
  3240. return TRUE;
  3241. }
  3243. //static
  3244. int des_encrypt(void *ifptr, uint8_t *data,
  3245. unsigned int *size)
  3246. {
  3247.   struct rtp *session = (struct rtp *)ifptr;
  3249.   uint8_t   initVec[8] = {0,0,0,0,0,0,0,0};
  3250.     qfDES_CBC_e(session->crypto_state.des.encryption_key,
  3251. data, *size, initVec);
  3252.     return TRUE;
  3253. }
  3255. //static 
  3256. int des_decrypt(void *ifptr, uint8_t *data,
  3257. unsigned int *size)
  3258. {
  3259.   struct rtp *session = (struct rtp *)ifptr;
  3260.   uint8_t   initVec[8] = {0,0,0,0,0,0,0,0};
  3261.     qfDES_CBC_d(session->crypto_state.des.encryption_key,
  3262. data, *size, initVec);
  3263.     return TRUE;
  3264. }
  3266. static int rijndael_initialize(struct rtp *session, u_char *hash, int hash_len)
  3267. {
  3268. int rc;
  3270. rtp_set_encryption(session,rijndael_encrypt, rijndael_decrypt, session->encrypt_userdata, 0);
  3271. session->encryption_pad_length = 16;
  3272. //nori
  3273. // session->encrypt_func = rijndael_encrypt;
  3274. //session->decrypt_func = rijndael_decrypt;
  3276. rc = makeKey(&session->crypto_state.rijndael.keyInstEncrypt,
  3277.      DIR_ENCRYPT, hash_len * 8, (char *) hash);
  3278. if (rc < 0)
  3279. {
  3280. debug_msg("makeKey failed: %dn", rc);
  3281. return FALSE;
  3282. }
  3284. rc = makeKey(&session->crypto_state.rijndael.keyInstDecrypt,
  3285.      DIR_DECRYPT, hash_len * 8, (char *) hash);
  3286. if (rc < 0)
  3287. {
  3288. debug_msg("makeKey failed: %dn", rc);
  3289. return FALSE;
  3290. }
  3292. rc = cipherInit(&session->crypto_state.rijndael.cipherInst,
  3293. MODE_ECB, NULL);
  3294. if (rc < 0)
  3295. {
  3296. debug_msg("cipherInst failed: %dn", rc);
  3297. return FALSE;
  3298. }
  3299.     return TRUE;
  3300. }
  3302. static int rijndael_encrypt(void *ifptr, uint8_t *data,
  3303.     unsigned int *size)
  3304. {
  3305.   struct rtp *session = (struct rtp *)ifptr;
  3306. int rc;
  3309. /*
  3310.  * Try doing this in place. If it doesn't work that way,
  3311.  * we'll have to allocate a buffer and copy back.
  3312.  */
  3313. rc = blockEncrypt(&session->crypto_state.rijndael.cipherInst,
  3314.   &session->crypto_state.rijndael.keyInstEncrypt,
  3315.   data, (*size) * 8, data);
  3316. return rc;
  3317. }
  3319. static int rijndael_decrypt(void *ifptr, uint8_t *data,
  3320.     unsigned int *size)
  3321. {
  3322.   struct rtp *session = (struct rtp *)ifptr;
  3323. int rc;
  3325. /*
  3326.  * Try doing this in place. If it doesn't work that way,
  3327.  * we'll have to allocate a buffer and copy back.
  3328.  */
  3329. rc = blockDecrypt(&session->crypto_state.rijndael.cipherInst,
  3330.   &session->crypto_state.rijndael.keyInstDecrypt,
  3331.   data, (*size) * 8, data);
  3332. return rc;
  3333. }
  3335. /**
  3336.  * rtp_get_addr:
  3337.  * @session: The RTP Session.
  3338.  *
  3339.  * Returns: The session's destination address, as set when creating the
  3340.  * session with rtp_init() or rtp_init_if().
  3341.  */
  3342. char *rtp_get_addr(struct rtp *session)
  3343. {
  3344. check_database(session);
  3345. return session->addr;
  3346. }
  3348. /**
  3349.  * rtp_get_rx_port:
  3350.  * @session: The RTP Session.
  3351.  *
  3352.  * Returns: The UDP port to which this session is bound, as set when
  3353.  * creating the session with rtp_init() or rtp_init_if().
  3354.  */
  3355. uint16_t rtp_get_rx_port(struct rtp *session)
  3356. {
  3357. check_database(session);
  3358. return session->rx_port;
  3359. }
  3361. /**
  3362.  * rtp_get_tx_port:
  3363.  * @session: The RTP Session.
  3364.  *
  3365.  * Returns: The UDP port to which RTP packets are transmitted, as set
  3366.  * when creating the session with rtp_init() or rtp_init_if().
  3367.  */
  3368. uint16_t rtp_get_tx_port(struct rtp *session)
  3369. {
  3370. check_database(session);
  3371. return session->tx_port;
  3372. }
  3374. /**
  3375.  * rtp_get_ttl:
  3376.  * @session: The RTP Session.
  3377.  *
  3378.  * Returns: The session's TTL, as set when creating the session with
  3379.  * rtp_init() or rtp_init_if().
  3380.  */
  3381. int rtp_get_ttl(struct rtp *session)
  3382. {
  3383. check_database(session);
  3384. return session->ttl;
  3385. }
  3387. // test (by nori)
  3388. int rtp_set_encryption(struct rtp *session, rtp_encrypt_func efunc, rtp_decrypt_func dfunc, void *userdata, unsigned int alloc_extra)
  3389. {
  3391. rtp_message(LOG_DEBUG, "Enabling SRTP encryption");
  3392. session->encryption_enabled = 1;
  3393. session->encrypt_func = efunc;
  3394. session->decrypt_func = dfunc;
  3395.         session->encrypt_userdata = userdata;
  3396. session->encryption_pad_length = 0;
  3397. session->encryption_lenadd = alloc_extra;
  3398. return 0;
  3399. }
  3400. int rtp_get_encryption_enabled(struct rtp *session)
  3401. {
  3402.   return session->encryption_enabled;
  3403. }
  3405. socket_udp *get_rtp_data_socket (struct rtp *session)
  3406. {
  3407.   return session->rtp_socket;
  3408. }
  3410. socket_udp *get_rtp_rtcp_socket (struct rtp *session)
  3411. {
  3412.   return session->rtcp_socket;
  3413. }