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

Revision 3922, 106.6 KB (checked in by ucacsva, 7 years ago)

1. Removed some tagged comments from previous commits (//SV-XXX).
2. Added newer config.[sub/guess]
3. Various fixes to sync common library with that of ANL:

  • Replaced some "dnl" comments with "#" and stripped off some dnl's from the end of lines
  • Require autoconf v2.5 with AC_PREREQ(2.5)
  • Replaced LIBOBJS="$LIBOBJS inet_ntop.o" by AC_LIBOBJ([inet_ntop])
  • Find which network interface is in use (WinXP).
  • Forgotten NDEF replaced by HAVE_MSGHDR_MSGCTRL.
  • Sets event.data to s->last.active (used by AccessGrid?'s logging code).
  • Introduced rtp_get_ssrc_count() (AccessGrid? logging code).


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