root/common/trunk/src/rtp.c @ 3932

Revision 3932, 105.9 KB (checked in by ucacsva, 7 years ago)

commit_msg_15Nov2006.txt

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