Changeset 310

Show
Ignore:
Timestamp:
11/24/99 13:02:17 (14 years ago)
Author:
ucaccsp
Message:

- Fix uninitialized use of session->last_update in RTP code
- Fix assertion failures in RTP library when sending RTCP packets
- Recognize, but ignore, profile specific extensions to RTCP SR/RR packets
- Update RTCP reporting interval calculation
- Implement reverse reconsideration of RTCP reporting interval
- Fix tv_diff in rtp.c to handle negative results
- Remove rtp_get_encryption_key(), the user of the library is assumed to

remember the passphrase used and doesn't need access to the internal
form of the key.

- Global change of integer types, and removal of compatibility defines:

u_int8 -> u_int8_t
u_int16 -> u_int16_t
u_int32 -> u_int32_t

and the same for the signed varients.

- Start to implement RTP encryption, not yet finished.

Location:
common/trunk
Files:
17 modified

Legend:

Unmodified
Added
Removed
  • common/trunk/MODS

    r301 r310  
    166166                - Address must be unique 
    167167                - Delete failed reliable messages if err_handler is present 
    168         GNU autoconf modifications from Bill Fenner 
     168        - Fix uninitialized use of session->last_update in RTP code 
     169        - Fix assertion failures in RTP library when sending RTCP packets 
     170        - Recognize, but ignore, profile specific extensions to RTCP SR/RR packets 
     171        - Update RTCP reporting interval calculation 
     172        - Implement reverse reconsideration of RTCP reporting interval 
     173        - Fix tv_diff in rtp.c to handle negative results 
     174        - Remove rtp_get_encryption_key(), the user of the library is assumed to  
     175          remember the passphrase used and doesn't need access to the internal 
     176          form of the key. 
     177        - GNU autoconf modifications from Bill Fenner 
     178        - Global change of integer types, and removal of compatibility defines: 
     179                u_int8  -> u_int8_t 
     180                u_int16 -> u_int16_t 
     181                u_int32 -> u_int32_t 
     182          and the same for the signed varients. 
     183 
    169184 
    170185Still to do... 
     
    173188          return the IPv4 hostname only on some machines. 
    174189        - Doesn't do DNS AAAA lookups when given a name rather than an IP address. 
    175         - "instance:pid" in mbus addresses? 
    176         - We use hmac_md5 and the mbus spec requires hmac_md5_96? Bug in 
    177           the spec, since they both reference RFC2104? 
    178         - Fixed offsets in the mbus config file parser? 
    179190        - Mbus code should check timestamp in received headers, and discard 
    180191          messages if it decreases, as a hinderance to replay attacks. 
     
    184195        - rtp_recv should split into rtp_select and rtp_recv. Jitter issues 
    185196          otherwise, as pointed out by Orion. 
    186         - version number in mbus config file 
    187         - allow a callback for background processing during mbus_rendezvous_...() 
     197        - Add a version number to the mbus config file 
     198        - Allow a callback for background processing during mbus_rendezvous_*() 
    188199        - move completely away from OS-based #ifdef's 
     200        - Implement encryption in the RTP code 
     201 
  • common/trunk/configure

    r308 r310  
    11591159# Check for standard size types.  The defaults are only valid on some 
    11601160# systems so we hope that <inttypes.h> exists when they're wrong. 
    1161 echo $ac_n "checking for uint8_t""... $ac_c" 1>&6 
    1162 echo "configure:1163: checking for uint8_t" >&5 
    1163 if eval "test \"`echo '$''{'ac_cv_type_uint8_t'+set}'`\" = set"; then 
     1161echo $ac_n "checking for u_int8_t""... $ac_c" 1>&6 
     1162echo "configure:1163: checking for u_int8_t" >&5 
     1163if eval "test \"`echo '$''{'ac_cv_type_u_int8_t'+set}'`\" = set"; then 
    11641164  echo $ac_n "(cached) $ac_c" 1>&6 
    11651165else 
     
    11741174EOF 
    11751175if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 
    1176   egrep "(^|[^a-zA-Z_0-9])uint8_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then 
    1177   rm -rf conftest* 
    1178   ac_cv_type_uint8_t=yes 
    1179 else 
    1180   rm -rf conftest* 
    1181   ac_cv_type_uint8_t=no 
    1182 fi 
    1183 rm -f conftest* 
    1184  
    1185 fi 
    1186 echo "$ac_t""$ac_cv_type_uint8_t" 1>&6 
    1187 if test $ac_cv_type_uint8_t = no; then 
     1176  egrep "(^|[^a-zA-Z_0-9])u_int8_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then 
     1177  rm -rf conftest* 
     1178  ac_cv_type_u_int8_t=yes 
     1179else 
     1180  rm -rf conftest* 
     1181  ac_cv_type_u_int8_t=no 
     1182fi 
     1183rm -f conftest* 
     1184 
     1185fi 
     1186echo "$ac_t""$ac_cv_type_u_int8_t" 1>&6 
     1187if test $ac_cv_type_u_int8_t = no; then 
    11881188  cat >> confdefs.h <<\EOF 
    1189 #define uint8_t unsigned char 
    1190 EOF 
    1191  
    1192 fi 
    1193  
    1194 echo $ac_n "checking for uint16_t""... $ac_c" 1>&6 
    1195 echo "configure:1196: checking for uint16_t" >&5 
    1196 if eval "test \"`echo '$''{'ac_cv_type_uint16_t'+set}'`\" = set"; then 
     1189#define u_int8_t unsigned char 
     1190EOF 
     1191 
     1192fi 
     1193 
     1194echo $ac_n "checking for u_int16_t""... $ac_c" 1>&6 
     1195echo "configure:1196: checking for u_int16_t" >&5 
     1196if eval "test \"`echo '$''{'ac_cv_type_u_int16_t'+set}'`\" = set"; then 
    11971197  echo $ac_n "(cached) $ac_c" 1>&6 
    11981198else 
     
    12071207EOF 
    12081208if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 
    1209   egrep "(^|[^a-zA-Z_0-9])uint16_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then 
    1210   rm -rf conftest* 
    1211   ac_cv_type_uint16_t=yes 
    1212 else 
    1213   rm -rf conftest* 
    1214   ac_cv_type_uint16_t=no 
    1215 fi 
    1216 rm -f conftest* 
    1217  
    1218 fi 
    1219 echo "$ac_t""$ac_cv_type_uint16_t" 1>&6 
    1220 if test $ac_cv_type_uint16_t = no; then 
     1209  egrep "(^|[^a-zA-Z_0-9])u_int16_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then 
     1210  rm -rf conftest* 
     1211  ac_cv_type_u_int16_t=yes 
     1212else 
     1213  rm -rf conftest* 
     1214  ac_cv_type_u_int16_t=no 
     1215fi 
     1216rm -f conftest* 
     1217 
     1218fi 
     1219echo "$ac_t""$ac_cv_type_u_int16_t" 1>&6 
     1220if test $ac_cv_type_u_int16_t = no; then 
    12211221  cat >> confdefs.h <<\EOF 
    1222 #define uint16_t unsigned short 
    1223 EOF 
    1224  
    1225 fi 
    1226  
    1227 echo $ac_n "checking for uint32_t""... $ac_c" 1>&6 
    1228 echo "configure:1229: checking for uint32_t" >&5 
    1229 if eval "test \"`echo '$''{'ac_cv_type_uint32_t'+set}'`\" = set"; then 
     1222#define u_int16_t unsigned short 
     1223EOF 
     1224 
     1225fi 
     1226 
     1227echo $ac_n "checking for u_int32_t""... $ac_c" 1>&6 
     1228echo "configure:1229: checking for u_int32_t" >&5 
     1229if eval "test \"`echo '$''{'ac_cv_type_u_int32_t'+set}'`\" = set"; then 
    12301230  echo $ac_n "(cached) $ac_c" 1>&6 
    12311231else 
     
    12401240EOF 
    12411241if (eval "$ac_cpp conftest.$ac_ext") 2>&5 | 
    1242   egrep "(^|[^a-zA-Z_0-9])uint32_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then 
    1243   rm -rf conftest* 
    1244   ac_cv_type_uint32_t=yes 
    1245 else 
    1246   rm -rf conftest* 
    1247   ac_cv_type_uint32_t=no 
    1248 fi 
    1249 rm -f conftest* 
    1250  
    1251 fi 
    1252 echo "$ac_t""$ac_cv_type_uint32_t" 1>&6 
    1253 if test $ac_cv_type_uint32_t = no; then 
     1242  egrep "(^|[^a-zA-Z_0-9])u_int32_t[^a-zA-Z_0-9]" >/dev/null 2>&1; then 
     1243  rm -rf conftest* 
     1244  ac_cv_type_u_int32_t=yes 
     1245else 
     1246  rm -rf conftest* 
     1247  ac_cv_type_u_int32_t=no 
     1248fi 
     1249rm -f conftest* 
     1250 
     1251fi 
     1252echo "$ac_t""$ac_cv_type_u_int32_t" 1>&6 
     1253if test $ac_cv_type_u_int32_t = no; then 
    12541254  cat >> confdefs.h <<\EOF 
    1255 #define uint32_t unsigned long 
     1255#define u_int32_t unsigned long 
    12561256EOF 
    12571257 
  • common/trunk/configure.in

    r308 r310  
    4242# Check for standard size types.  The defaults are only valid on some 
    4343# systems so we hope that <inttypes.h> exists when they're wrong. 
    44 AC_CHECK_TYPE(uint8_t, unsigned char) 
    45 AC_CHECK_TYPE(uint16_t, unsigned short) 
    46 AC_CHECK_TYPE(uint32_t, unsigned long) 
     44AC_CHECK_TYPE(u_int8_t, unsigned char) 
     45AC_CHECK_TYPE(u_int16_t, unsigned short) 
     46AC_CHECK_TYPE(u_int32_t, unsigned long) 
    4747AC_CHECK_TYPE(int8_t, signed char) 
    4848AC_CHECK_TYPE(int16_t, short) 
  • common/trunk/src/btree.c

    r297 r310  
    1919 
    2020typedef struct s_btree_node { 
    21         u_int32       key; 
     21        u_int32_t       key; 
    2222        void         *data; 
    2323        struct s_btree_node *parent; 
     
    7777 
    7878static btree_node_t* 
    79 btree_search(btree_node_t *x, u_int32 key) 
     79btree_search(btree_node_t *x, u_int32_t key) 
    8080{ 
    8181        while (x != NULL && key != x->key) { 
     
    182182 
    183183int 
    184 btree_find(btree_t *tree, u_int32 key, void **d) 
     184btree_find(btree_t *tree, u_int32_t key, void **d) 
    185185{ 
    186186        btree_node_t *x; 
     
    194194 
    195195int  
    196 btree_add(btree_t *tree, u_int32 key, void *data) 
     196btree_add(btree_t *tree, u_int32_t key, void *data) 
    197197{ 
    198198        btree_node_t *x; 
     
    214214 
    215215int 
    216 btree_remove(btree_t *tree, u_int32 key, void **data) 
     216btree_remove(btree_t *tree, u_int32_t key, void **data) 
    217217{ 
    218218        btree_node_t *x; 
     
    240240 
    241241int  
    242 btree_get_min_key(btree_t *tree, u_int32 *key) 
     242btree_get_min_key(btree_t *tree, u_int32_t *key) 
    243243{ 
    244244        btree_node_t *x; 
     
    258258 
    259259int  
    260 btree_get_max_key(btree_t *tree, u_int32 *key) 
     260btree_get_max_key(btree_t *tree, u_int32_t *key) 
    261261{ 
    262262        btree_node_t *x; 
     
    276276 
    277277int 
    278 btree_get_next_key(btree_t *tree, u_int32 cur_key, u_int32 *next_key) 
     278btree_get_next_key(btree_t *tree, u_int32_t cur_key, u_int32_t *next_key) 
    279279{ 
    280280        btree_node_t *x; 
     
    353353{ 
    354354        btree_t *b; 
    355         u_int32 i, *x; 
    356         u_int32 v[] = {15, 5, 16, 3, 12, 20, 10, 13, 18, 23, 6, 7};  
    357         u_int32 nv = sizeof(v) / sizeof(v[0]); 
     355        u_int32_t i, *x; 
     356        u_int32_t v[] = {15, 5, 16, 3, 12, 20, 10, 13, 18, 23, 6, 7};  
     357        u_int32_t nv = sizeof(v) / sizeof(v[0]); 
    358358 
    359359        btree_create(&b); 
    360360 
    361361        for(i = 0; i < nv; i++) { 
    362                 x = (u_int32*)xmalloc(sizeof(u_int32)); 
    363                 *x = (u_int32)random(); 
     362                x = (u_int32_t*)xmalloc(sizeof(u_int32_t)); 
     363                *x = (u_int32_t)random(); 
    364364                if (btree_add(b, v[i], (void*)x) != TRUE) { 
    365365                        printf("Fail Add %lu %lu\n", v[i], *x); 
  • common/trunk/src/btree.h

    r297 r310  
    3535/* if key is already on tree.  */ 
    3636 
    37 int btree_add    (btree_t *tree, u_int32 key, void *data); 
     37int btree_add    (btree_t *tree, u_int32_t key, void *data); 
    3838 
    3939/* btree_remove attempts to remove data from tree.  Returns TRUE on success  */ 
     
    4141/* on tree.                                                                  */ 
    4242 
    43 int btree_remove (btree_t *tree, u_int32 key, void **d); 
     43int btree_remove (btree_t *tree, u_int32_t key, void **d); 
    4444 
    4545/* btree_find locates data for key and make *d point to it.  Returns TRUE if */ 
    4646/* data for key is found, FALSE otherwise.                                   */ 
    4747 
    48 int btree_find   (btree_t *tree, u_int32 key, void **d); 
     48int btree_find   (btree_t *tree, u_int32_t key, void **d); 
    4949 
    5050/* btree_get_min_key attempts to return minimum key of tree.  Function       */ 
     
    5252/* and fills key with key if possible, FALSE otherwise                       */ 
    5353 
    54 int btree_get_min_key (btree_t *tree, u_int32 *key); 
    55 int btree_get_max_key (btree_t *tree, u_int32 *key); 
     54int btree_get_min_key (btree_t *tree, u_int32_t *key); 
     55int btree_get_max_key (btree_t *tree, u_int32_t *key); 
    5656 
    5757/* btree_get_next_key attempts to get the key above cur_key.  Returns        */ 
    5858/* TRUE and fills key with key if possible, FALSE otherwise.                 */ 
    5959 
    60 int btree_get_next_key (btree_t *tree, u_int32 cur_key, u_int32 *next_key); 
     60int btree_get_next_key (btree_t *tree, u_int32_t cur_key, u_int32_t *next_key); 
    6161 
    6262#endif /* __BTREE_H__ */ 
  • common/trunk/src/config_unix.h

    r301 r310  
    8383typedef unsigned char   byte; 
    8484 
    85 /* Typedefs from standard types to ours */ 
    86 typedef uint8_t         u_int8; 
    87 typedef uint16_t        u_int16; 
    88 typedef uint32_t        u_int32; 
    89 typedef int8_t          int8; 
    90 typedef int16_t         int16; 
    91 typedef int32_t         int32; 
    92 typedef int64_t         int64; 
    93  
    9485typedef u_char  ttl_t; 
    9586typedef int     fd_t; 
     
    160151#endif 
    161152 
    162 #ifdef HPUX 
    163 int gethostname(char *hostname, size_t size); 
    164 #endif 
    165  
    166 #ifdef Linux 
    167 void *memcpy(void *dest, const void *src, size_t n); 
    168 int   memcmp(const void *s1, const void *s2, size_t n); 
    169 #endif /* Linux */ 
    170  
    171153#endif /* _CONFIG_UNIX_H_ */ 
    172154#endif /* WIN32 */ 
  • common/trunk/src/crypt_random.c

    r301 r310  
    4747#include "crypt_random.h" 
    4848 
    49 static u_int32 randseed = 1; 
     49static u_int32_t randseed = 1; 
    5050 
    5151void 
    52 lbl_srandom(u_int32 seed) 
     52lbl_srandom(u_int32_t seed) 
    5353{ 
    5454        randseed = seed; 
    5555} 
    5656 
    57 u_int32 
     57u_int32_t 
    5858lbl_random(void) 
    5959{ 
  • common/trunk/src/crypt_random.h

    r104 r310  
    4343 */ 
    4444 
    45 void    lbl_srandom(u_int32 seed); 
    46 u_int32 lbl_random(void); 
     45void      lbl_srandom(u_int32_t seed); 
     46u_int32_t lbl_random(void); 
    4747 
  • common/trunk/src/mbus.c

    r305 r310  
    394394        int              i; 
    395395        char            *net_addr; 
    396         u_int16          net_port; 
     396        u_int16_t        net_port; 
    397397        int              net_scope; 
    398398 
  • common/trunk/src/mbus_config.c

    r299 r310  
    6565        /* Step 1: generate a random string for the key... */ 
    6666        for (i = 0; i < MBUS_ENCRKEY_LEN; i++) { 
    67                 random_string[i] = ((int32)lbl_random() | 0x000ff000) >> 24; 
     67                random_string[i] = ((int32_t)lbl_random() | 0x000ff000) >> 24; 
    6868        } 
    6969 
     
    105105        /* Step 1: generate a random string for the key... */ 
    106106        for (i = 0; i < MBUS_HASHKEY_LEN; i++) { 
    107                 random_string[i] = ((int32)lbl_random() | 0x000ff000) >> 24; 
     107                random_string[i] = ((int32_t)lbl_random() | 0x000ff000) >> 24; 
    108108        } 
    109109        /* Step 2: base64 encode that string... */ 
     
    469469} 
    470470 
    471 void mbus_get_net_addr(struct mbus_config *m, char *net_addr, u_int16 *net_port, int *net_scope){ 
     471void mbus_get_net_addr(struct mbus_config *m, char *net_addr, u_int16_t *net_port, int *net_scope) 
     472{ 
    472473#ifdef WIN32 
    473     /* TODO: get values out of registry */ 
    474     strcpy(net_addr, MBUS_DEFAULT_NET_ADDR); 
    475     *net_port = MBUS_DEFAULT_NET_PORT; 
    476     *net_scope = MBUS_DEFAULT_SCOPE; 
     474        /* TODO: get values out of registry */ 
     475        strcpy(net_addr, MBUS_DEFAULT_NET_ADDR); 
     476        *net_port = MBUS_DEFAULT_NET_PORT; 
     477        *net_scope = MBUS_DEFAULT_SCOPE; 
    477478#else 
    478479        struct stat      s; 
     
    485486        int              scope; 
    486487        char            *addr; 
    487         u_int16          port; 
     488        u_int16_t        port; 
    488489 
    489490        assert(m->cfg_locked); 
  • common/trunk/src/mbus_config.h

    r269 r310  
    7272void mbus_get_encrkey(struct mbus_config *m, struct mbus_key *key); 
    7373void mbus_get_hashkey(struct mbus_config *m, struct mbus_key *key); 
    74 void mbus_get_net_addr(struct mbus_config *m, char *net_addr, u_int16 *net_port, int *net_scope); 
     74void mbus_get_net_addr(struct mbus_config *m, char *net_addr, u_int16_t *net_port, int *net_scope); 
    7575 
    7676#if defined(__cplusplus) 
  • common/trunk/src/md5.c

    r94 r310  
    7373 */ 
    7474#define FF(a, b, c, d, x, s, ac) { \ 
    75  (a) += F ((b), (c), (d)) + (x) + (u_int32)(ac); \ 
     75 (a) += F ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ 
    7676 (a) = ROTATE_LEFT ((a), (s)); \ 
    7777 (a) += (b); \ 
    7878  } 
    7979#define GG(a, b, c, d, x, s, ac) { \ 
    80  (a) += G ((b), (c), (d)) + (x) + (u_int32)(ac); \ 
     80 (a) += G ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ 
    8181 (a) = ROTATE_LEFT ((a), (s)); \ 
    8282 (a) += (b); \ 
    8383  } 
    8484#define HH(a, b, c, d, x, s, ac) { \ 
    85  (a) += H ((b), (c), (d)) + (x) + (u_int32)(ac); \ 
     85 (a) += H ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ 
    8686 (a) = ROTATE_LEFT ((a), (s)); \ 
    8787 (a) += (b); \ 
    8888  } 
    8989#define II(a, b, c, d, x, s, ac) { \ 
    90  (a) += I ((b), (c), (d)) + (x) + (u_int32)(ac); \ 
     90 (a) += I ((b), (c), (d)) + (x) + (u_int32_t)(ac); \ 
    9191 (a) = ROTATE_LEFT ((a), (s)); \ 
    9292 (a) += (b); \ 
     
    9494 
    9595/* 
    96  * Encodes input (u_int32) into output (unsigned char). Assumes len is a 
     96 * Encodes input (u_int32_t) into output (unsigned char). Assumes len is a 
    9797 * multiple of 4. 
    9898 */ 
    9999static void  
    100 Encode(unsigned char *output, u_int32 * input, unsigned int len) 
     100Encode(unsigned char *output, u_int32_t * input, unsigned int len) 
    101101{ 
    102102        unsigned int    i, j; 
     
    113113 
    114114/* 
    115  * Decodes input (unsigned char) into output (u_int32). Assumes len is a 
     115 * Decodes input (unsigned char) into output (u_int32_t). Assumes len is a 
    116116 * multiple of 4. 
    117117 */ 
    118118static void  
    119 Decode(u_int32 * output, unsigned char *input, unsigned int len) 
     119Decode(u_int32_t * output, unsigned char *input, unsigned int len) 
    120120{ 
    121121        unsigned int    i, j; 
    122122 
    123123        for (i = 0, j = 0; j < len; i++, j += 4) 
    124                 output[i] = ((u_int32) input[j]) | (((u_int32) input[j + 1]) << 8) | 
    125                         (((u_int32) input[j + 2]) << 16) | (((u_int32) input[j + 3]) << 24); 
     124                output[i] = ((u_int32_t) input[j]) | (((u_int32_t) input[j + 1]) << 8) | 
     125                        (((u_int32_t) input[j + 2]) << 16) | (((u_int32_t) input[j + 3]) << 24); 
    126126} 
    127127 
     
    130130 */ 
    131131static void  
    132 MD5Transform(u_int32 state[4], unsigned char block[64]) 
    133 { 
    134         u_int32           a = state[0], b = state[1], c = state[2], d = state[3], 
     132MD5Transform(u_int32_t state[4], unsigned char block[64]) 
     133{ 
     134        u_int32_t           a = state[0], b = state[1], c = state[2], d = state[3], 
    135135                        x[16]; 
    136136 
     
    247247 
    248248        /* Update number of bits */ 
    249         if ((context->count[0] += ((u_int32) inputLen << 3)) < ((u_int32) inputLen << 3)) { 
     249        if ((context->count[0] += ((u_int32_t) inputLen << 3)) < ((u_int32_t) inputLen << 3)) { 
    250250                context->count[1]++; 
    251251        } 
    252         context->count[1] += ((u_int32) inputLen >> 29); 
     252        context->count[1] += ((u_int32_t) inputLen >> 29); 
    253253 
    254254        partLen = 64 - index; 
  • common/trunk/src/md5.h

    r3 r310  
    3030/* MD5 context. */ 
    3131typedef struct { 
    32   u_int32 state[4];             /* state (ABCD) */ 
    33   u_int32 count[2];             /* number of bits, modulo 2^64 (lsb first) */ 
     32  u_int32_t state[4];             /* state (ABCD) */ 
     33  u_int32_t count[2];           /* number of bits, modulo 2^64 (lsb first) */ 
    3434  unsigned char buffer[64];     /* input buffer */ 
    3535} MD5_CTX; 
  • common/trunk/src/net_udp.c

    r283 r310  
    6767        int              mode;  /* IPv4 or IPv6 */ 
    6868        char            *addr; 
    69         u_int16          rx_port; 
    70         u_int16          tx_port; 
     69        u_int16_t                rx_port; 
     70        u_int16_t                tx_port; 
    7171        ttl_t            ttl; 
    7272        fd_t             fd; 
     
    187187/*****************************************************************************/ 
    188188 
    189 static socket_udp *udp_init4(char *addr, u_int16 rx_port, u_int16 tx_port, int ttl) 
     189static socket_udp *udp_init4(char *addr, u_int16_t rx_port, u_int16_t tx_port, int ttl) 
    190190{ 
    191191        int                 reuse = 1; 
     
    307307/*****************************************************************************/ 
    308308 
    309 static socket_udp *udp_init6(char *addr, u_int16 rx_port, u_int16 tx_port, int ttl) 
     309static socket_udp *udp_init6(char *addr, u_int16_t rx_port, u_int16_t tx_port, int ttl) 
    310310{ 
    311311#ifdef HAVE_IPv6 
     
    553553/*****************************************************************************/ 
    554554 
    555 socket_udp *udp_init(char *addr, u_int16 rx_port, u_int16 tx_port, int ttl) 
     555socket_udp *udp_init(char *addr, u_int16_t rx_port, u_int16_t tx_port, int ttl) 
    556556{ 
    557557        socket_udp *res; 
  • common/trunk/src/net_udp.h

    r205 r310  
    4343#endif 
    4444 
    45 socket_udp *udp_init(char *addr, u_int16 rx_port, u_int16 tx_port, int ttl); 
     45socket_udp *udp_init(char *addr, u_int16_t rx_port, u_int16_t tx_port, int ttl); 
    4646void        udp_exit(socket_udp *s); 
    4747int         udp_send(socket_udp *s, char *buffer, int buflen); 
  • common/trunk/src/rtp.c

    r304 r310  
    5555#include "drand48.h" 
    5656#include "gettimeofday.h" 
     57#include "qfDES.h" 
    5758#include "rtp.h" 
    5859 
     
    8889        unsigned short  pt:8;           /* payload type           */ 
    8990#endif 
    90         u_int16         length;         /* packet length          */ 
     91        u_int16_t         length;               /* packet length          */ 
    9192} rtcp_common; 
    9293 
     
    99100                } sr; 
    100101                struct { 
    101                         u_int32         ssrc;           /* source this RTCP packet is coming from */ 
     102                        u_int32_t         ssrc;         /* source this RTCP packet is coming from */ 
    102103                        rtcp_rr         rr[1];          /* variable-length list */ 
    103104                } rr; 
    104105                struct rtcp_sdes_t { 
    105                         u_int32         ssrc; 
     106                        u_int32_t               ssrc; 
    106107                        rtcp_sdes_item  item[1];        /* list of SDES */ 
    107108                } sdes; 
    108109                struct { 
    109                         u_int32         ssrc[1];        /* list of sources */ 
     110                        u_int32_t         ssrc[1];      /* list of sources */ 
    110111                                                        /* can't express the trailing text... */ 
    111112                } bye; 
    112113                struct { 
    113                         u_int32         ssrc;            
    114                         u_int8          name[4]; 
    115                         u_int8          data[1]; 
     114                        u_int32_t         ssrc;            
     115                        u_int8_t          name[4]; 
     116                        u_int8_t          data[1]; 
    116117                } app; 
    117118        } r; 
     
    121122        struct _rtcp_rr_wrapper *next; 
    122123        struct _rtcp_rr_wrapper *prev; 
    123         u_int32                  reporter_ssrc; 
     124        u_int32_t                  reporter_ssrc; 
    124125        rtcp_rr                 *rr; 
    125126        struct timeval          *ts;    /* Arrival time of this RR */ 
     
    134135        struct _source  *next; 
    135136        struct _source  *prev; 
    136         u_int32          ssrc; 
     137        u_int32_t                ssrc; 
    137138        char            *cname; 
    138139        char            *name; 
     
    147148        int              sender; 
    148149        int              got_bye;       /* TRUE if we've received an RTCP bye from this source */ 
    149         u_int32          base_seq; 
    150         u_int16          max_seq; 
    151         u_int32          bad_seq; 
    152         u_int32          cycles; 
     150        u_int32_t                base_seq; 
     151        u_int16_t                max_seq; 
     152        u_int32_t                bad_seq; 
     153        u_int32_t                cycles; 
    153154        int              received; 
    154155        int              received_prior; 
    155156        int              expected_prior; 
    156157        int              probation; 
    157         u_int32          jitter; 
    158         u_int32          transit; 
     158        u_int32_t                jitter; 
     159        u_int32_t                transit; 
    159160} source; 
    160161 
     
    187188        socket_udp      *rtcp_socket; 
    188189        char            *addr; 
    189         u_int16          rx_port; 
    190         u_int16          tx_port; 
     190        u_int16_t                rx_port; 
     191        u_int16_t                tx_port; 
    191192        int              ttl; 
    192         u_int32          my_ssrc; 
     193        u_int32_t                my_ssrc; 
    193194        source          *db[RTP_DB_SIZE]; 
    194195        rtcp_rr_wrapper  rr[RTP_DB_SIZE][RTP_DB_SIZE];  /* Indexed by [hash(reporter)][hash(reportee)] */ 
     
    198199        int              invalid_rtcp_count; 
    199200        int              ssrc_count; 
     201        int              ssrc_count_prev;               /* ssrc_count at the time we last recalculated our RTCP interval */ 
    200202        int              sender_count; 
    201203        int              initial_rtcp; 
     
    210212        int              sdes_count_sec; 
    211213        int              sdes_count_ter; 
    212         u_int16          rtp_seq; 
    213         u_int32          rtp_pcount; 
    214         u_int32          rtp_bcount; 
     214        u_int16_t                rtp_seq; 
     215        u_int32_t                rtp_pcount; 
     216        u_int32_t                rtp_bcount; 
    215217        char            *encryption_key; 
    216218        void (*callback)(struct rtp *session, rtp_event *event); 
     
    220222{ 
    221223    /* Return curr_time - prev_time */ 
    222     double sec; 
    223     double usec; 
    224  
    225     sec = curr_time.tv_sec - prev_time.tv_sec ; 
    226     usec = curr_time.tv_usec - prev_time.tv_usec ; 
    227  
    228     assert(sec >= 0); 
    229     if (usec < 0 ) { 
    230         assert(sec > 0); 
    231         sec--; 
    232         usec += 1000000; 
    233     } 
    234  
    235     return (sec+(usec/1000000)); 
     224    double      ct, pt; 
     225 
     226    ct = (double) curr_time.tv_sec + (((double) curr_time.tv_usec) / 1000000.0); 
     227    pt = (double) prev_time.tv_sec + (((double) prev_time.tv_usec) / 1000000.0); 
     228    return (ct - pt); 
    236229} 
    237230 
     
    263256} 
    264257 
    265 static int ssrc_hash(u_int32 ssrc) 
     258static int ssrc_hash(u_int32_t ssrc) 
    266259{ 
    267260        /* Hash from an ssrc to a position in the source database.   */ 
     
    278271} 
    279272 
    280 static void insert_rr(struct rtp *session, u_int32 reporter_ssrc, rtcp_rr *rr, struct timeval *ts) 
     273static void insert_rr(struct rtp *session, u_int32_t reporter_ssrc, rtcp_rr *rr, struct timeval *ts) 
    281274{ 
    282275        /* Insert the reception report into the receiver report      */ 
     
    321314} 
    322315 
    323 static void remove_rr(struct rtp *session, u_int32 ssrc) 
     316static void remove_rr(struct rtp *session, u_int32_t ssrc) 
    324317{ 
    325318        /* Remove any RRs from "s" which refer to "ssrc" as either   */ 
     
    400393} 
    401394 
    402 static const rtcp_rr* get_rr(struct rtp *session, u_int32 reporter_ssrc, u_int32 reportee_ssrc) 
     395static const rtcp_rr* get_rr(struct rtp *session, u_int32_t reporter_ssrc, u_int32_t reportee_ssrc) 
    403396{ 
    404397        rtcp_rr_wrapper *cur, *start; 
     
    468461} 
    469462 
    470 static source *get_source(struct rtp *session, u_int32 ssrc) 
     463static source *get_source(struct rtp *session, u_int32_t ssrc) 
    471464{ 
    472465        source *s; 
     
    481474} 
    482475 
    483 static source *create_source(struct rtp *session, u_int32 ssrc) 
     476static source *create_source(struct rtp *session, u_int32_t ssrc) 
    484477{ 
    485478        /* Create a new source entry, and add it to the database.    */ 
     
    548541} 
    549542 
    550 static void delete_source(struct rtp *session, u_int32 ssrc) 
     543static void delete_source(struct rtp *session, u_int32_t ssrc) 
    551544{ 
    552545        /* Remove a source from the RTP database... */ 
     
    557550 
    558551        assert(s != NULL);      /* Deleting a source which doesn't exist is an error... */ 
     552 
     553        gettimeofday(&event_ts, NULL); 
    559554 
    560555        check_database(session); 
     
    582577        if (s->sr    != NULL) xfree(s->sr); 
    583578 
    584         remove_rr(session, ssrc); 
    585         /* Done... reduce our source count, and signal to the application that this source is dead */ 
     579        remove_rr(session, ssrc);  
     580 
     581        /* Reduce our SSRC count, and perform reverse reconsideration on the RTCP */ 
     582        /* reporting interval (draft-ietf-avt-rtp-new-05.txt, section 6.3.4). To  */ 
     583        /* make the transmission rate of RTCP packets more adaptive to changes in */ 
     584        /* group membership, the following "reverse reconsideration" algorithm    */ 
     585        /* SHOULD be executed when a BYE packet is received that reduces members  */ 
     586        /* to a value less than pmembers:                                         */ 
     587        /* o  The value for tn is updated according to the following formula:     */ 
     588        /*       tn = tc + (members/pmembers)(tn - tc)                            */ 
     589        /* o  The value for tp is updated according the following formula:        */ 
     590        /*       tp = tc - (members/pmembers)(tc - tp).                           */ 
     591        /* o  The next RTCP packet is rescheduled for transmission at time tn,    */ 
     592        /*    which is now earlier.                                               */ 
     593        /* o  The value of pmembers is set equal to members.                      */ 
    586594        session->ssrc_count--; 
    587         gettimeofday(&event_ts, NULL); 
     595        if (session->ssrc_count < session->ssrc_count_prev) { 
     596                tv_add(&(session->next_rtcp_send_time), (session->ssrc_count / session->ssrc_count_prev)  
     597                                                     * tv_diff(session->next_rtcp_send_time, event_ts)); 
     598                tv_add(&(session->last_rtcp_send_time), - ((session->ssrc_count / session->ssrc_count_prev)  
     599                                                     * tv_diff(event_ts, session->next_rtcp_send_time))); 
     600                session->ssrc_count_prev = session->ssrc_count; 
     601        } 
     602 
     603        /* Signal to the application that this source is dead... */ 
    588604        event.ssrc = ssrc; 
    589605        event.type = SOURCE_DELETED; 
     
    595611} 
    596612 
    597 static void init_seq(source *s, u_int16 seq) 
     613static void init_seq(source *s, u_int16_t seq) 
    598614{ 
    599615        /* Taken from draft-ietf-avt-rtp-new-01.txt */ 
     
    607623} 
    608624 
    609 static int update_seq(source *s, u_int16 seq) 
     625static int update_seq(source *s, u_int16_t seq) 
    610626{ 
    611627        /* Taken from draft-ietf-avt-rtp-new-01.txt */ 
    612         u_int16 udelta = seq - s->max_seq; 
     628        u_int16_t udelta = seq - s->max_seq; 
    613629 
    614630        /* 
     
    660676} 
    661677 
    662 static double rtcp_interval(struct rtp *session, int reconsider) 
     678static double rtcp_interval(struct rtp *session) 
    663679{ 
    664680        /* Minimum average time between RTCP packets from this site (in   */ 
     
    676692        /* receiver fraction must be 1 - the sender fraction.             */ 
    677693        double const RTCP_SENDER_BW_FRACTION = 0.25; 
    678         double const RTCP_RCVR_BW_FRACTION = (1-RTCP_SENDER_BW_FRACTION); 
     694        double const RTCP_RCVR_BW_FRACTION   = (1-RTCP_SENDER_BW_FRACTION); 
     695        /* To compensate for "unconditional reconsideration" converging   */ 
     696        /* to a value below the intended average.                         */ 
     697        double const COMPENSATION            = 2.71828 - 1.5; 
     698 
    679699        double t;                                             /* interval */ 
    680700        double rtcp_min_time = RTCP_MIN_TIME; 
    681701        int n;                          /* no. of members for computation */ 
    682702        double rtcp_bw = session->rtcp_bw; 
    683  
    684         if (reconsider) { 
    685                 rtcp_bw *= 1.21828; 
    686         } 
    687703 
    688704        /* Very first call at application start-up uses half the min      */ 
     
    725741        /* other sites, we then pick our actual next report interval as a */ 
    726742        /* random number uniformly distributed between 0.5*t and 1.5*t.   */ 
    727         return t * (drand48() + 0.5); 
     743        return (t * (drand48() + 0.5)) / COMPENSATION; 
    728744} 
    729745 
     
    767783 
    768784 
    769 struct rtp *rtp_init(char *addr, u_int16 rx_port, u_int16 tx_port, int ttl, double rtcp_bw,  
     785struct rtp *rtp_init(char *addr, u_int16_t rx_port, u_int16_t tx_port, int ttl, double rtcp_bw,  
    770786                     void (*callback)(struct rtp *session, rtp_event *e), 
    771787                     void *userdata) 
     
    789805        session->ttl            = ttl; 
    790806        session->rtp_socket     = udp_init(addr, rx_port, tx_port, ttl); 
    791         session->rtcp_socket    = udp_init(addr, (u_int16) (rx_port+1), (u_int16) (tx_port+1), ttl); 
     807        session->rtcp_socket    = udp_init(addr, (u_int16_t) (rx_port+1), (u_int16_t) (tx_port+1), ttl); 
    792808 
    793809        init_opt(session); 
     
    798814        } 
    799815 
    800         session->my_ssrc            = (u_int32) lrand48(); 
     816        session->my_ssrc            = (u_int32_t) lrand48(); 
    801817        session->callback           = callback; 
    802818        session->invalid_rtp_count  = 0; 
    803819        session->invalid_rtcp_count = 0; 
    804820        session->ssrc_count         = 0; 
     821        session->ssrc_count_prev    = 0; 
    805822        session->sender_count       = 0; 
    806823        session->initial_rtcp       = TRUE; 
     
    811828        session->sdes_count_sec     = 0; 
    812829        session->sdes_count_ter     = 0; 
    813         session->rtp_seq            = (u_int16) lrand48(); 
     830        session->rtp_seq            = (u_int16_t) lrand48(); 
    814831        session->rtp_pcount         = 0; 
    815832        session->rtp_bcount         = 0; 
     833        gettimeofday(&(session->last_update), NULL); 
    816834        gettimeofday(&(session->last_rtcp_send_time), NULL); 
    817835        gettimeofday(&(session->next_rtcp_send_time), NULL); 
     
    819837 
    820838        /* Calculate when we're supposed to send our first RTCP packet... */ 
    821         tv_add(&(session->next_rtcp_send_time), rtcp_interval(session, FALSE)); 
     839        tv_add(&(session->next_rtcp_send_time), rtcp_interval(session)); 
    822840 
    823841        /* Initialise the source database... */ 
     
    843861} 
    844862 
    845 int rtp_set_my_ssrc(struct rtp *session, u_int32 ssrc) 
     863int rtp_set_my_ssrc(struct rtp *session, u_int32_t ssrc) 
    846864{ 
    847865        source *s; 
    848         u_int32 h; 
     866        u_int32_t h; 
    849867        /* Sets my_ssrc when called immediately after rtp_init. */ 
    850868        /* Returns TRUE on success, FALSE otherwise.  Needed to */ 
     
    907925} 
    908926 
    909 u_int32 rtp_my_ssrc(struct rtp *session) 
     927u_int32_t rtp_my_ssrc(struct rtp *session) 
    910928{ 
    911929        assert(session != NULL); 
     
    962980} 
    963981 
    964 static void process_rtp(struct rtp *session, u_int32 curr_time, rtp_packet *packet, source *s) 
     982static void process_rtp(struct rtp *session, u_int32_t curr_time, rtp_packet *packet, source *s) 
    965983{ 
    966984        int              i, d, transit; 
     
    9951013} 
    9961014 
    997 static void rtp_recv_data(struct rtp *session, u_int32 curr_time) 
     1015static void rtp_recv_data(struct rtp *session, u_int32_t curr_time) 
    9981016{ 
    9991017        /* This routine preprocesses an incoming RTP packet, deciding whether to process it. */ 
    10001018        rtp_packet      *packet = (rtp_packet *) xmalloc(RTP_MAX_PACKET_LEN); 
    1001         u_int8          *buffer = ((u_int8 *) packet) + RTP_PACKET_HEADER_SIZE; 
     1019        u_int8_t                *buffer = ((u_int8_t *) packet) + RTP_PACKET_HEADER_SIZE; 
    10021020        int              buflen; 
    10031021        source          *s; 
     
    10111029                /* Setup internal pointers, etc... */ 
    10121030                if (packet->cc) { 
    1013                         packet->csrc = (u_int32 *)(buffer + 12); 
     1031                        packet->csrc = (u_int32_t *)(buffer + 12); 
    10141032                } else { 
    10151033                        packet->csrc = NULL; 
     
    10641082} 
    10651083 
    1066 static int validate_rtcp(u_int8 *packet, int len) 
     1084static int validate_rtcp(u_int8_t *packet, int len) 
    10671085{ 
    10681086        /* Validity check for a compound RTCP packet. This function returns */ 
     
    11201138                if (r->common.p == 1) last = 1; 
    11211139                l += (ntohs(r->common.length) + 1) * 4; 
    1122                 r  = (rtcp_t *) (((u_int32 *) r) + ntohs(r->common.length) + 1); 
     1140                r  = (rtcp_t *) (((u_int32_t *) r) + ntohs(r->common.length) + 1); 
    11231141        } while (r < end); 
    11241142 
     
    11331151} 
    11341152 
    1135 static void process_report_blocks(struct rtp *session, rtcp_t *packet, u_int32 ssrc, rtcp_rr *rrp, struct timeval *event_ts) 
     1153static void process_report_blocks(struct rtp *session, rtcp_t *packet, u_int32_t ssrc, rtcp_rr *rrp, struct timeval *event_ts) 
    11361154{ 
    11371155        int i; 
     
    11751193static void process_rtcp_sr(struct rtp *session, rtcp_t *packet, struct timeval *event_ts) 
    11761194{ 
    1177         u_int32          ssrc; 
     1195        u_int32_t                ssrc; 
    11781196        rtp_event        event; 
    11791197        rtcp_sr         *sr; 
     
    12111229 
    12121230        process_report_blocks(session, packet, ssrc, packet->r.sr.rr, event_ts); 
     1231 
     1232        if (((packet->common.count * 6) + 1) < (ntohs(packet->common.length) - 5)) { 
     1233                debug_msg("Profile specific SR extension ignored\n"); 
     1234        } 
    12131235} 
    12141236 
    12151237static void process_rtcp_rr(struct rtp *session, rtcp_t *packet, struct timeval *event_ts) 
    12161238{ 
    1217         u_int32          ssrc; 
     1239        u_int32_t                ssrc; 
    12181240        source          *s; 
    12191241 
     
    12261248 
    12271249        process_report_blocks(session, packet, ssrc, packet->r.rr.rr, event_ts); 
     1250 
     1251        if (((packet->common.count * 6) + 1) < ntohs(packet->common.length)) { 
     1252                debug_msg("Profile specific RR extension ignored\n"); 
     1253        } 
    12281254} 
    12291255 
     
    12341260        rtcp_sdes_item          *rsp;  
    12351261        rtcp_sdes_item          *rspn; 
    1236         rtcp_sdes_item          *end  = (rtcp_sdes_item *) ((u_int32 *)packet + packet->common.length + 1); 
     1262        rtcp_sdes_item          *end  = (rtcp_sdes_item *) ((u_int32_t *)packet + packet->common.length + 1); 
    12371263        source                  *s; 
    12381264        rtp_event                event; 
     
    12651291                        } 
    12661292                } 
    1267                 sd = (struct rtcp_sdes_t *) ((u_int32 *)sd + (((char *)rsp - (char *)sd) >> 2)+1); 
     1293                sd = (struct rtcp_sdes_t *) ((u_int32_t *)sd + (((char *)rsp - (char *)sd) >> 2)+1); 
    12681294        } 
    12691295        if (count >= 0) { 
     
    12751301{ 
    12761302        int              i; 
    1277         u_int32          ssrc; 
     1303        u_int32_t                ssrc; 
    12781304        rtp_event        event; 
    12791305        source          *s; 
     
    13001326static void process_rtcp_app(struct rtp *session, rtcp_t *packet, struct timeval *event_ts) 
    13011327{ 
    1302         u_int32          ssrc; 
     1328        u_int32_t          ssrc; 
    13031329        rtp_event        event; 
    13041330        rtcp_app        *app; 
     
    13101336        create_source(session, ssrc); 
    13111337        s = get_source(session, ssrc); 
    1312         if( s == NULL ) { 
     1338        if (s == NULL) { 
    13131339                /* This should only occur in the event of database malfunction. */ 
    13141340                debug_msg("Source 0x%08x invalid, skipping...\n", ssrc); 
     
    13391365} 
    13401366 
    1341 static void rtp_process_ctrl(struct rtp *session, u_int8 *buffer, int buflen) 
     1367static void rtp_process_ctrl(struct rtp *session, u_int8_t *buffer, int buflen) 
    13421368{ 
    13431369        /* This routine processes incoming RTCP packets */ 
     
    13951421} 
    13961422 
    1397 int rtp_recv(struct rtp *session, struct timeval *timeout, u_int32 curr_time) 
     1423int rtp_recv(struct rtp *session, struct timeval *timeout, u_int32_t curr_time) 
    13981424{ 
    13991425        udp_fd_zero(); 
     
    14051431                } 
    14061432                if (udp_fd_isset(session->rtcp_socket)) { 
    1407                         u_int8           buffer[RTP_MAX_PACKET_LEN]; 
     1433                        u_int8_t                 buffer[RTP_MAX_PACKET_LEN]; 
    14081434                        int              buflen; 
    14091435                        buflen = udp_recv(session->rtcp_socket, buffer, RTP_MAX_PACKET_LEN); 
     
    14151441} 
    14161442 
    1417 int rtp_add_csrc(struct rtp *session, u_int32 csrc) 
     1443int rtp_add_csrc(struct rtp *session, u_int32_t csrc) 
    14181444{ 
    14191445        UNUSED(session); 
     
    14221448} 
    14231449 
    1424 int rtp_set_sdes(struct rtp *session, u_int32 ssrc, u_int8 type, char *value, int length) 
     1450int rtp_set_sdes(struct rtp *session, u_int32_t ssrc, u_int8_t type, char *value, int length) 
    14251451{ 
    14261452        source  *s = get_source(session, ssrc); 
     
    14731499} 
    14741500 
    1475 const char *rtp_get_sdes(struct rtp *session, u_int32 ssrc, u_int8 type) 
     1501const char *rtp_get_sdes(struct rtp *session, u_int32_t ssrc, u_int8_t type) 
    14761502{ 
    14771503        source  *s = get_source(session, ssrc); 
     
    15021528} 
    15031529 
    1504 const rtcp_sr *rtp_get_sr(struct rtp *session, u_int32 ssrc) 
     1530const rtcp_sr *rtp_get_sr(struct rtp *session, u_int32_t ssrc) 
    15051531{ 
    15061532        /* Return the last SR received from this ssrc. The */ 
     
    15141540} 
    15151541 
    1516 const rtcp_rr *rtp_get_rr(struct rtp *session, u_int32 reporter, u_int32 reportee) 
     1542const rtcp_rr *rtp_get_rr(struct rtp *session, u_int32_t reporter, u_int32_t reportee) 
    15171543{ 
    15181544        return get_rr(session, reporter, reportee); 
    15191545} 
    15201546 
    1521 int rtp_send_data(struct rtp *session, u_int32 ts, char pt, int m, int cc, u_int32 csrc[],  
     1547int rtp_send_data(struct rtp *session, u_int32_t ts, char pt, int m, int cc, u_int32_t csrc[],  
    15221548                  char *data, int data_len, char *extn, int extn_len) 
    15231549{ 
    1524         int              buffer_len, i, rc; 
    1525         u_int8          *buffer; 
     1550        int              buffer_len, i, rc, pad, pad_len; 
     1551        u_int8_t        *buffer; 
    15261552        rtp_packet      *packet; 
     1553        u_int8_t         initVec[8] = {0,0,0,0,0,0,0,0}; 
    15271554 
    15281555        buffer_len = data_len + extn_len + 12 + (4 * cc); 
    1529         buffer     = (u_int8 *) xmalloc(buffer_len + RTP_PACKET_HEADER_SIZE); 
     1556 
     1557        /* Do we need to pad this packet to a multiple of 64 bits? */ 
     1558        /* This is only needed if encryption is enabled, since DES */ 
     1559        /* only works on multiples of 64 bits. We just calculate   */ 
     1560        /* the amount of padding to add here, so we can reserve    */ 
     1561        /* space - the actual padding is added later.              */ 
     1562        if ((session->encryption_key != NULL) && ((buffer_len % 8) != 0)) { 
     1563                pad     = 1; 
     1564                pad_len = 8 - (buffer_len % 8); 
     1565        } else { 
     1566                pad     = 0; 
     1567                pad_len = 0; 
     1568        } 
     1569 
     1570        /* Allocate memory for the packet... */ 
     1571        buffer_len = buffer_len + pad_len; 
     1572        buffer     = (u_int8_t *) xmalloc(buffer_len + RTP_PACKET_HEADER_SIZE); 
    15301573        packet     = (rtp_packet *) buffer; 
    15311574 
    15321575        /* These are internal pointers into the buffer... */ 
    1533         packet->csrc = (u_int32 *) (buffer + RTP_PACKET_HEADER_SIZE + 12); 
    1534         packet->extn = (u_int8  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc)); 
    1535         packet->data = (u_int8  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc) + extn_len); 
     1576        packet->csrc = (u_int32_t *) (buffer + RTP_PACKET_HEADER_SIZE + 12); 
     1577        packet->extn = (u_int8_t  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc)); 
     1578        packet->data = (u_int8_t  *) (buffer + RTP_PACKET_HEADER_SIZE + 12 + (4 * cc) + extn_len); 
    15361579        /* ...and the actual packet header... */ 
    15371580        packet->v    = 2; 
    1538         packet->p    = 0; 
     1581        packet->p    = pad; 
    15391582        packet->x    = (extn != NULL); 
    15401583        packet->cc   = cc; 
     
    15501593        /* ...a header extension? */ 
    15511594        memcpy(packet->extn, extn, extn_len); 
    1552         /* ...finally the data itself... */ 
     1595        /* ...and the media data... */ 
    15531596        memcpy(packet->data, data, data_len); 
     1597        /* ...and any padding... */ 
     1598        if (pad) { 
     1599                for (i = 0; i < pad_len; i++) { 
     1600                        packet->data[buffer_len - i] = 0; 
     1601                } 
     1602                packet->data[buffer_len] = (char) pad_len; 
     1603        } 
     1604         
     1605        /* Finally, encrypt if desired... */ 
     1606        if (session->encryption_key != NULL) { 
     1607                qfDES_CBC_e(session->encryption_key, buffer, buffer_len, initVec);  
     1608        } 
    15541609 
    15551610        rc = udp_send(session->rtp_socket, buffer + RTP_PACKET_HEADER_SIZE, buffer_len); 
     
    15871642                                int     lost_interval     = expected_interval - received_interval; 
    15881643                                int     fraction; 
    1589                                 u_int32 lsr; 
    1590                                 u_int32 dlsr; 
     1644                                u_int32_t       lsr; 
     1645                                u_int32_t dlsr; 
    15911646 
    15921647                                s->expected_prior = expected; 
     
    16261681} 
    16271682 
    1628 static u_int8 *format_rtcp_sr(u_int8 *buffer, int buflen, struct rtp *session, u_int32 ts) 
     1683static u_int8_t *format_rtcp_sr(u_int8_t *buffer, int buflen, struct rtp *session, u_int32_t ts) 
    16291684{ 
    16301685        /* Write an RTCP SR into buffer, returning a pointer to */ 
     
    16331688        int              remaining_length; 
    16341689        struct timeval   curr_time; 
    1635         u_int32          ntp_sec, ntp_frac; 
     1690        u_int32_t                ntp_sec, ntp_frac; 
    16361691 
    16371692        assert(buflen >= 28);   /* ...else there isn't space for the header and sender report */ 
     
    16581713        remaining_length = buflen - 28; 
    16591714        packet->common.count = format_report_blocks(packet->r.sr.rr, remaining_length, session); 
    1660         packet->common.length = htons((u_int16) (6 + (packet->common.count * 6))); 
     1715        packet->common.length = htons((u_int16_t) (6 + (packet->common.count * 6))); 
    16611716        return buffer + 28 + (24 * packet->common.count); 
    16621717} 
    16631718 
    1664 static u_int8 *format_rtcp_rr(u_int8 *buffer, int buflen, struct rtp *session) 
     1719static u_int8_t *format_rtcp_rr(u_int8_t *buffer, int buflen, struct rtp *session) 
    16651720{ 
    16661721        /* Write an RTCP RR into buffer, returning a pointer to */ 
     
    16821737        remaining_length = buflen - 8; 
    16831738        packet->common.count = format_report_blocks(packet->r.rr.rr, remaining_length, session); 
    1684         packet->common.length = htons((u_int16) (1 + (packet->common.count * 6))); 
     1739        packet->common.length = htons((u_int16_t) (1 + (packet->common.count * 6))); 
    16851740        return buffer + 8 + (24 * packet->common.count); 
    16861741} 
    16871742 
    1688 static int add_sdes_item(u_int8 *buf, int type, const char *val) 
     1743static int add_sdes_item(u_int8_t *buf, int type, const char *val) 
    16891744{ 
    16901745        /* Fill out an SDES item. It is assumed that the item is a NULL    */ 
     
    17041759} 
    17051760 
    1706 static u_int8 *format_rtcp_sdes(u_int8 *buffer, int buflen, u_int32 ssrc, struct rtp *session) 
     1761static u_int8_t *format_rtcp_sdes(u_int8_t *buffer, int buflen, u_int32_t ssrc, struct rtp *session) 
    17071762{ 
    17081763        /* From draft-ietf-avt-profile-new-00:                             */ 
     
    17161771        /* 4, 7, 10, 13, 16, 19, while, say, EMAIL is used in RTCP packet  */ 
    17171772        /* 22".                                                            */ 
    1718         u_int8          *packet = buffer; 
     1773        u_int8_t                *packet = buffer; 
    17191774        rtcp_common     *common = (rtcp_common *) buffer; 
    17201775        const char      *item; 
     
    17311786        packet += sizeof(common); 
    17321787 
    1733         *((u_int32 *) packet) = htonl(ssrc); 
     1788        *((u_int32_t *) packet) = htonl(ssrc); 
    17341789        packet += 4; 
    17351790 
     
    17911846        } 
    17921847 
    1793         common->length = htons((u_int16) (((int) (packet - buffer) / 4) - 1)); 
     1848        common->length = htons((u_int16_t) (((int) (packet - buffer) / 4) - 1)); 
    17941849 
    17951850        return packet; 
    17961851} 
    17971852 
    1798 static u_int8 *format_rtcp_app(u_int8 *buffer, int buflen, u_int32 ssrc, rtcp_app *app) 
     1853static u_int8_t *format_rtcp_app(u_int8_t *buffer, int buflen, u_int32_t ssrc, rtcp_app *app) 
    17991854{ 
    18001855        /* Write an RTCP APP into the outgoing packet buffer. */ 
     
    18201875} 
    18211876 
    1822 static void send_rtcp(struct rtp *session, u_int32 ts, 
    1823                      rtcp_app *(*appcallback)(struct rtp *session, u_int32 ts, int max_size)) 
     1877static void send_rtcp(struct rtp *session, u_int32_t ts, 
     1878                     rtcp_app *(*appcallback)(struct rtp *session, u_int32_t ts, int max_size)) 
    18241879{ 
    18251880        /* Construct and send an RTCP packet. The order in which packets are packed into a */ 
    18261881        /* compound packet is defined by section 6.1 of draft-ietf-avt-rtp-new-03.txt and  */ 
    18271882        /* we follow the recommended order.                                                */ 
    1828         u_int8     buffer[RTP_MAX_PACKET_LEN]; 
    1829         u_int8    *ptr = buffer; 
    1830         u_int8    *old_ptr; 
     1883        u_int8_t           buffer[RTP_MAX_PACKET_LEN]; 
     1884        u_int8_t          *ptr = buffer; 
     1885        u_int8_t    *old_ptr; 
     1886        u_int8_t    *lpt;               /* the last packet in the compound */ 
    18311887        rtcp_app  *app; 
     1888        u_int8_t           initVec[8] = {0,0,0,0,0,0,0,0}; 
     1889 
     1890        /* If encryption is enabled, add a 32 bit random prefix to the packet */ 
     1891        if (session->encryption_key != NULL) { 
     1892                *((u_int32_t *) ptr) = lbl_random(); 
     1893                ptr += 4; 
     1894        } 
    18321895 
    18331896        /* The first RTCP packet in the compound packet MUST always be a report packet...  */ 
     
    18371900                ptr = format_rtcp_rr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session); 
    18381901        } 
     1902        /* Add the appropriate SDES items to the packet... This should really be after the */ 
     1903        /* insertion of the additional report blocks, but if we do that there are problems */ 
     1904        /* with us being unable to fit the SDES packet in when we run out of buffer space  */ 
     1905        /* adding RRs. The correct fix would be to calculate the length of the SDES items  */ 
     1906        /* in advance and subtract this from the buffer length but this is non-trivial and */ 
     1907        /* probably not worth it.                                                          */ 
     1908        lpt = ptr; 
     1909        ptr = format_rtcp_sdes(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), rtp_my_ssrc(session), session); 
     1910 
    18391911        /* Following that, additional RR packets SHOULD follow if there are more than 31   */ 
    1840         /* senders (such that the reports do not fit into the initial packet. We give up   */ 
     1912        /* senders, such that the reports do not fit into the initial packet. We give up   */ 
    18411913        /* if there is insufficient space in the buffer: this is bad, since we always drop */ 
    18421914        /* the reports from the same sources (those at the end of the hash table).         */ 
    1843         while ((session->sender_count > 0)  && ((RTP_MAX_PACKET_LEN - (ptr - buffer)) > 0)) { 
     1915        while ((session->sender_count > 0)  && ((RTP_MAX_PACKET_LEN - (ptr - buffer)) >= 8)) { 
     1916                lpt = ptr; 
    18441917                ptr = format_rtcp_rr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session); 
    18451918        } 
    1846  
    1847         /* Add the appropriate SDES items to the packet... */ 
    1848         ptr = format_rtcp_sdes(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), rtp_my_ssrc(session), session); 
    18491919 
    18501920        /* Finish with as many APP packets as the application will provide. */ 
     
    18521922        if (appcallback) { 
    18531923                while ((app = (*appcallback)(session, ts, RTP_MAX_PACKET_LEN - (ptr - buffer)))) { 
     1924                        lpt = ptr; 
    18541925                        ptr = format_rtcp_app(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), rtp_my_ssrc(session), app); 
    18551926                        assert(ptr > old_ptr); 
     
    18591930        } 
    18601931 
     1932        if (session->encryption_key != NULL) { 
     1933                if (((ptr - buffer) % 8) != 0) { 
     1934                        /* We need to add padding to the last packet in the compound. */ 
     1935                        ((rtcp_t *) lpt)->common.p = TRUE; 
     1936                         
     1937                } 
     1938                qfDES_CBC_e(session->encryption_key, buffer, ptr - buffer, initVec);  
     1939        } 
    18611940        udp_send(session->rtcp_socket, buffer, ptr - buffer); 
    18621941 
     
    18671946} 
    18681947 
    1869 void rtp_send_ctrl(struct rtp *session, u_int32 ts, 
    1870                    rtcp_app *(*appcallback)(struct rtp *session, u_int32 ts, int max_size)) 
     1948void rtp_send_ctrl(struct rtp *session, u_int32_t ts, 
     1949                   rtcp_app *(*appcallback)(struct rtp *session, u_int32_t ts, int max_size)) 
    18711950{ 
    18721951        /* Send an RTCP packet, if one is due... */ 
     
    18821961                double           new_interval; 
    18831962 
    1884                 new_interval  = rtcp_interval(session, TRUE); 
     1963                new_interval  = rtcp_interval(session); 
    18851964                new_send_time = session->last_rtcp_send_time; 
    18861965                tv_add(&new_send_time, new_interval); 
     
    19041983                        tv_add(&(session->next_rtcp_send_time), new_interval); 
    19051984                } 
     1985                session->ssrc_count_prev = session->ssrc_count; 
    19061986        }  
    19071987} 
     
    19582038        /* 50 members in the group), or b) returns without sending a BYE (if there are 50  */ 
    19592039        /* or more members). See draft-ietf-avt-rtp-new-01.txt (section 6.3.7).            */ 
    1960         u_int8   buffer[RTP_MAX_PACKET_LEN]; 
    1961         u_int8  *ptr = buffer; 
     2040        u_int8_t         buffer[RTP_MAX_PACKET_LEN]; 
     2041        u_int8_t        *ptr = buffer; 
    19622042        rtcp_common     *common; 
    19632043 
     2044        if (session->encryption_key != NULL) { 
     2045                printf("Encryption not yet supported in rtp_send_bye\n"); 
     2046        } 
    19642047        if (session->ssrc_count < 50) { 
    19652048                ptr = format_rtcp_rr(ptr, RTP_MAX_PACKET_LEN - (ptr - buffer), session);     
     
    19732056                ptr += sizeof(common); 
    19742057                 
    1975                 *((u_int32 *) ptr) = htonl(session->my_ssrc);   
     2058                *((u_int32_t *) ptr) = htonl(session->my_ssrc);   
    19762059                ptr += sizeof(session->my_ssrc);  
    19772060                 
     
    20102093} 
    20112094 
    2012 int rtp_set_encryption_key(struct rtp* session, const char *key) 
    2013 { 
    2014         UNUSED(session); 
    2015         UNUSED(key); 
     2095int rtp_set_encryption_key(struct rtp* session, const char *passphrase) 
     2096{ 
     2097        /* Convert the user supplied key into a form suitable for use with RTP */ 
     2098        /* and install it as the active key. Passing in NULL as the passphrase */ 
     2099        /* disables encryption. The passphrase is converted into a DES key as  */ 
     2100        /* specified in RFC1890, that is:                                      */ 
     2101        /*   - convert to canonical form                                       */ 
     2102        /*   - derive an MD5 hash of the canonical form                        */ 
     2103        /*   - take the first 56 bits of the MD5 hash                          */ 
     2104        /*   - add parity bits to form a 64 bit key                            */ 
     2105        /* Note that versions of rat prior to 4.1.2 do not convert the pass-   */ 
     2106        /* phrase to canonical form before taking the MD5 hash, and so will    */ 
     2107        /* not be compatible for keys which are non-invarient under this step. */ 
     2108        char    *canonical_passphrase; 
    20162109 
    20172110        if (session->encryption_key != NULL) { 
    20182111                xfree(session->encryption_key); 
    20192112        } 
    2020         session->encryption_key = xstrdup(key); 
    2021         debug_msg("rtp_set_encyption_key not yet supported.\n"); 
    2022         return FALSE; 
    2023 } 
    2024  
    2025 const char *rtp_get_encryption_key(struct rtp* session) 
    2026 { 
    2027         return session->encryption_key; 
     2113        session->encryption_key = (char *) malloc(8); 
     2114 
     2115        /* Step 1: convert to canonical form, comprising the following steps:  */ 
     2116        /*   a) convert the input string to the ISO 10646 character set, using */ 
     2117        /*      the UTF-8 encoding as specified in Annex P to ISO/IEC          */ 
     2118        /*      10646-1:1993 (ASCII characters require no mapping, but ISO     */ 
     2119        /*      8859-1 characters do);                                         */ 
     2120        /*   b) remove leading and trailing white space characters;            */ 
     2121        /*   c) replace one or more contiguous white space characters by a     */ 
     2122        /*      single space (ASCII or UTF-8 0x20);                            */ 
     2123        /*   d) convert all letters to lower case and replace sequences of     */ 
     2124        /*      characters and non-spacing accents with a single character,    */ 
     2125        /*      where possible.                                                */ 
     2126        canonical_passphrase = (char *) xmalloc(strlen(passphrase)); 
     2127 
     2128        /* Step 2: derive an MD5 hash */ 
     2129        /* Step 3: take first 56 bits of the MD5 hash */ 
     2130        /* Step 4: add parity bits */ 
     2131        return TRUE; 
    20282132} 
    20292133 
     
    20332137} 
    20342138 
    2035 u_int16 rtp_get_rx_port(struct rtp *session) 
     2139u_int16_t rtp_get_rx_port(struct rtp *session) 
    20362140{ 
    20372141        return session->rx_port; 
    20382142} 
    20392143 
    2040 u_int16 rtp_get_tx_port(struct rtp *session) 
     2144u_int16_t rtp_get_tx_port(struct rtp *session) 
    20412145{ 
    20422146        return session->tx_port; 
  • common/trunk/src/rtp.h

    r309 r310  
    4141 
    4242#define RTP_VERSION 2 
    43 #define RTP_PACKET_HEADER_SIZE  ((sizeof(char *) * 2) + sizeof(u_int32 *) + (2 * sizeof(int))) 
     43#define RTP_PACKET_HEADER_SIZE  ((sizeof(char *) * 2) + sizeof(u_int32_t *) + (2 * sizeof(int))) 
    4444#define RTP_MAX_PACKET_LEN 1500 
    4545 
     
    5757        /* WARNING: Don't change the size of the first portion of the */ 
    5858        /* struct without changing RTP_PACKET_HEADER_SIZE to match.   */ 
    59         u_int32         *csrc; 
     59        u_int32_t               *csrc; 
    6060        char            *data; 
    6161        int              data_len; 
     
    7878        unsigned short   m:1;           /* marker bit                 */ 
    7979#endif 
    80         u_int16          seq;           /* sequence number            */ 
    81         u_int32          ts;            /* timestamp                  */ 
    82         u_int32          ssrc;          /* synchronization source     */ 
     80        u_int16_t          seq;         /* sequence number            */ 
     81        u_int32_t          ts;          /* timestamp                  */ 
     82        u_int32_t          ssrc;                /* synchronization source     */ 
    8383        /* The csrc list, header extension and data follow, but can't */ 
    8484        /* be represented in the struct.                              */ 
     
    8686 
    8787typedef struct { 
    88         u_int32         ssrc; 
    89         u_int32         ntp_sec; 
    90         u_int32         ntp_frac; 
    91         u_int32         rtp_ts; 
    92         u_int32         sender_pcount; 
    93         u_int32         sender_bcount; 
     88        u_int32_t         ssrc; 
     89        u_int32_t         ntp_sec; 
     90        u_int32_t         ntp_frac; 
     91        u_int32_t         rtp_ts; 
     92        u_int32_t         sender_pcount; 
     93        u_int32_t         sender_bcount; 
    9494} rtcp_sr; 
    9595 
    9696typedef struct { 
    97         u_int32         ssrc;           /* The ssrc to which this RR pertains */ 
     97        u_int32_t               ssrc;           /* The ssrc to which this RR pertains */ 
    9898#ifdef WORDS_BIGENDIAN 
    99         u_int32         fract_lost:8; 
    100         u_int32         total_lost:24; 
     99        u_int32_t               fract_lost:8; 
     100        u_int32_t               total_lost:24; 
    101101#else 
    102         u_int32         total_lost:24; 
    103         u_int32         fract_lost:8; 
     102        u_int32_t               total_lost:24; 
     103        u_int32_t               fract_lost:8; 
    104104#endif   
    105         u_int32         last_seq; 
    106         u_int32         jitter; 
    107         u_int32         lsr; 
    108         u_int32         dlsr; 
     105        u_int32_t               last_seq; 
     106        u_int32_t               jitter; 
     107        u_int32_t               lsr; 
     108        u_int32_t               dlsr; 
    109109} rtcp_rr; 
    110110 
    111111typedef struct { 
    112         u_int8          type;           /* type of SDES item              */ 
    113         u_int8          length;         /* length of SDES item (in bytes) */ 
     112        u_int8_t          type;         /* type of SDES item              */ 
     113        u_int8_t          length;               /* length of SDES item (in bytes) */ 
    114114        char            data[1];        /* text, not zero-terminated      */ 
    115115} rtcp_sdes_item; 
     
    126126#endif 
    127127        unsigned short  pt:8;           /* packet type            */ 
    128         u_int16         length;         /* packet length          */ 
    129         u_int32         ssrc; 
     128        u_int16_t         length;               /* packet length          */ 
     129        u_int32_t         ssrc; 
    130130        char            name[4];        /* four ASCII characters  */ 
    131131        char            data[1];        /* variable length field  */ 
     
    133133 
    134134typedef struct { 
    135         u_int32          ssrc; 
     135        u_int32_t                ssrc; 
    136136        int              type; 
    137137        void            *data; 
     
    170170struct rtp; 
    171171 
    172 struct rtp      *rtp_init(char *addr, u_int16 rx_port, u_int16 tx_port, int ttl, double rtcp_bw,  
     172struct rtp      *rtp_init(char *addr, u_int16_t rx_port, u_int16_t tx_port, int ttl, double rtcp_bw,  
    173173                          void (*callback)(struct rtp *session, rtp_event *e), 
    174174                          void *user_data); 
     
    176176int              rtp_getopt(struct rtp *session, int optname, int *optval); 
    177177void            *rtp_get_userdata(struct rtp *session); 
    178 int              rtp_recv(struct rtp *session, struct timeval *timeout, u_int32 curr_time); 
    179 int              rtp_send_data(struct rtp *session, u_int32 ts, char pt, int m, int cc, u_int32 csrc[],  
     178int              rtp_recv(struct rtp *session, struct timeval *timeout, u_int32_t curr_time); 
     179int              rtp_send_data(struct rtp *session, u_int32_t ts, char pt, int m, int cc, u_int32_t csrc[],  
    180180                               char *data, int data_len, char *extn, int extn_len); 
    181 void             rtp_send_ctrl(struct rtp *session, u_int32 ts,  
    182                                rtcp_app *(*appcallback)(struct rtp *session, u_int32 ts, int max_size)); 
     181void             rtp_send_ctrl(struct rtp *session, u_int32_t ts,  
     182                               rtcp_app *(*appcallback)(struct rtp *session, u_int32_t ts, int max_size)); 
    183183void             rtp_update(struct rtp *session); 
    184184 
    185 u_int32          rtp_my_ssrc(struct rtp *session); 
    186 int              rtp_add_csrc(struct rtp *session, u_int32 csrc); 
    187 int              rtp_valid_ssrc(struct rtp *session, u_int32 ssrc); 
    188 int              rtp_set_sdes(struct rtp *session, u_int32 ssrc, u_int8 type, char *value, int length); 
    189 const char      *rtp_get_sdes(struct rtp *session, u_int32 ssrc, u_int8 type); 
    190 const rtcp_sr   *rtp_get_sr(struct rtp *session, u_int32 ssrc); 
    191 const rtcp_rr   *rtp_get_rr(struct rtp *session, u_int32 reporter, u_int32 reportee); 
     185u_int32_t        rtp_my_ssrc(struct rtp *session); 
     186int              rtp_add_csrc(struct rtp *session, u_int32_t csrc); 
     187int              rtp_valid_ssrc(struct rtp *session, u_int32_t ssrc); 
     188int              rtp_set_sdes(struct rtp *session, u_int32_t ssrc, u_int8_t type, char *value, int length); 
     189const char      *rtp_get_sdes(struct rtp *session, u_int32_t ssrc, u_int8_t type); 
     190const rtcp_sr   *rtp_get_sr(struct rtp *session, u_int32_t ssrc); 
     191const rtcp_rr   *rtp_get_rr(struct rtp *session, u_int32_t reporter, u_int32_t reportee); 
    192192void             rtp_send_bye(struct rtp *session); 
    193193void             rtp_done(struct rtp *session); 
    194 int              rtp_set_encryption_key(struct rtp *session, const char *key); 
    195 const char      *rtp_get_encryption_key(struct rtp *session); 
     194int              rtp_set_encryption_key(struct rtp *session, const char *passphrase); 
    196195 
    197196char            *rtp_get_addr(struct rtp *session); 
    198 u_int16          rtp_get_rx_port(struct rtp *session); 
    199 u_int16          rtp_get_tx_port(struct rtp *session); 
     197u_int16_t        rtp_get_rx_port(struct rtp *session); 
     198u_int16_t        rtp_get_tx_port(struct rtp *session); 
    200199int              rtp_get_ttl(struct rtp *session); 
    201200 
    202 int              rtp_set_my_ssrc(struct rtp *session, u_int32 ssrc); 
     201int              rtp_set_my_ssrc(struct rtp *session, u_int32_t ssrc); 
    203202 
    204203#endif /* __RTP_H__ */