rohc.h

Go to the documentation of this file.

/*
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

#ifndef ROHC_H
#define ROHC_H

#include <endian.h>


/*
 * Below are some return codes:
 */

#define ROHC_OK                     1

#define ROHC_ERROR_NO_CONTEXT      -1

#define ROHC_ERROR_PACKET_FAILED   -2

#define ROHC_FEEDBACK_ONLY         -3

#define ROHC_ERROR_CRC             -4

#define ROHC_ERROR                 -5

#define ROHC_NEED_REPARSE          -6

#define ROHC_TRUE   1

#define ROHC_FALSE  0

typedef unsigned char boolean;


#define RTP_PORTS  1234, 36780, 33238, 5020, 5002



typedef enum
{
        U_MODE = 1,
        O_MODE = 2,
        R_MODE = 3,
} rohc_mode;


struct medium
{
        enum {
                LARGE_CID,
                SMALL_CID,
        } cid_type;

        int max_cid;
};


/*
 * ROHC profiles numbers allocated by the IANA (see 8 in the RFC 3095):
 */

#define ROHC_PROFILE_UNCOMPRESSED  0x0000

#define ROHC_PROFILE_RTP           0x0001

#define ROHC_PROFILE_UDP           0x0002

#define ROHC_PROFILE_IP            0x0004

#define ROHC_PROFILE_UDPLITE       0x0008


/*
 * The limits for the compressor states changes:
 */

#define CHANGE_TO_IR_COUNT  1700

#define CHANGE_TO_FO_COUNT  700

#define MAX_IR_COUNT  3

#define MAX_FO_COUNT  3


/*
 * The types of ROHC packets and their extensions:
 */

#define PACKET_UO_0      0

#define PACKET_UO_1      1

#define PACKET_UOR_2     2

#define PACKET_IR_DYN    3

#define PACKET_IR        4

#define PACKET_UNKNOWN   5

#define PACKET_CCE       6

#define PACKET_CCE_OFF   7

#define PACKET_UO_1_RTP  8

#define PACKET_UO_1_ID   9

#define PACKET_UO_1_TS  10

#define PACKET_UOR_2_RTP 11

#define PACKET_UOR_2_ID  12

#define PACKET_UOR_2_TS  13

#define PACKET_NORMAL    14

#define PACKET_NOEXT    (-1)

#define PACKET_EXT_0     0

#define PACKET_EXT_1     1

#define PACKET_EXT_2     2

#define PACKET_EXT_3     3


/*
 * Constants related to packet recovery after CRC failure:
 */

#define CRC_ACTION  1


/*
 * Bitwised operations:
 */

#define GET_BIT_0_2(x)  ((*(x)) & 0x07)
#define GET_BIT_0_4(x)  ((*(x)) & 0x1f)
#define GET_BIT_0_3(x)  ((*(x)) & 0x0f)
#define GET_BIT_0_5(x)  ((*(x)) & 0x3f)
#define GET_BIT_0_6(x)  ((*(x)) & 0x7f)
#define GET_BIT_0_7(x)  ((*(x)) & 0xff)

#define GET_BIT_1_7(x)  ( ((*(x)) & 0xfe) >> 1 )
#define GET_BIT_3_4(x)  ( ((*(x)) & 0x18) >> 3 )
#define GET_BIT_3_5(x)  ( ((*(x)) & 0x38) >> 3 )
#define GET_BIT_3_6(x)  ( ((*(x)) & 0x78) >> 3 )
#define GET_BIT_3_7(x)  ( ((*(x)) & 0xf8) >> 3 )
#define GET_BIT_4_7(x)  ( ((*(x)) & 0xf0) >> 4 )
#define GET_BIT_5_7(x)  ( ((*(x)) & 0xe0) >> 5 )
#define GET_BIT_6_7(x)  ( ((*(x)) & 0xc0) >> 6 )
#define GET_BIT_4_6(x)  ( ((*(x)) & 0x70) >> 4 )

#define GET_BIT_0(x)  ((*(x)) & 0x01)
#define GET_BIT_1(x)  ((*(x)) & 0x02)
#define GET_BIT_2(x)  ((*(x)) & 0x04)
#define GET_BIT_3(x)  ((*(x)) & 0x08)
#define GET_BIT_4(x)  ((*(x)) & 0x10)
#define GET_BIT_5(x)  ((*(x)) & 0x20)
#define GET_BIT_6(x)  ((*(x)) & 0x40)
#define GET_BIT_7(x)  ((*(x)) & 0x80)

#define GET_REAL(x)     ( (x) ? 1 : 0 )

#if __BYTE_ORDER == __LITTLE_ENDIAN
#       define GET_NEXT_16_BITS(x) \
                ((((*((x) + 1)) << 8) & 0xff00) | ((*(x)) & 0x00ff))
#elif __BYTE_ORDER == __BIG_ENDIAN
#       define GET_NEXT_16_BITS(x) \
                ((((*(x)) << 8) & 0xff00) | ((*((x) + 1)) & 0x00ff))
#else
#       error "Adjust your <bits/endian.h> defines"
#endif


/*
 * The flags for the IP changed fields:
 */

#define MOD_TOS       0x0001

#define MOD_TOT_LEN   0x0002

#define MOD_ID        0x0004

#define MOD_FRAG_OFF  0x0008

#define MOD_TTL       0x0010

#define MOD_PROTOCOL  0x0020

#define MOD_CHECK     0x0040

#define MOD_SADDR     0x0080

#define MOD_DADDR     0x0100


/*
 *  The flags for the RTP changed fields:
 */

#define MOD_RTP_PADDING  0x0200

#define MOD_RTP_EXT      0x0400

#define MOD_RTP_M        0x0800

#define MOD_RTP_PT       0x1000

#define MOD_RTP_SN       0x2000

#define MOD_RTP_TS       0x4000

#define MOD_RTP_SSRC     0x8000


/*
 * Time-related constants:
 */

#define WEIGHT_OLD  1
#define WEIGHT_NEW  1


/*
 * System includes:
 */

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <sys/time.h>
#include <netinet/in.h>

/*
 * Debug macros:
 */

#define zfree(pointer) \
        do { \
                free(pointer); \
                pointer = NULL; \
        } while(0)


#ifdef __i386__

static inline unsigned short ip_fast_csum(unsigned char *iph, unsigned int ihl)
{
        unsigned int sum;

        __asm__ __volatile__(" \n\
       movl (%1), %0      \n\
       subl $4, %2              \n\
       jbe 2f           \n\
       addl 4(%1), %0   \n\
       adcl 8(%1), %0   \n\
       adcl 12(%1), %0  \n\
1:     adcl 16(%1), %0  \n\
       lea 4(%1), %1    \n\
       decl %2          \n\
       jne 1b           \n\
       adcl $0, %0              \n\
       movl %0, %2              \n\
       shrl $16, %0     \n\
       addw %w2, %w0    \n\
       adcl $0, %0              \n\
       notl %0          \n\
2:     \n\
       "
        /* Since the input registers which are loaded with iph and ipl
           are modified, we must also specify them as outputs, or gcc
           will assume they contain their original values. */
        : "=r" (sum), "=r" (iph), "=r" (ihl)
        : "1" (iph), "2" (ihl));

        return(sum);
}

#else

static inline unsigned short from32to16(unsigned long x)
{
    /* add up 16-bit and 16-bit for 16+c bit */
    x = (x & 0xffff) + (x >> 16);
    /* add up carry.. */
    x = (x & 0xffff) + (x >> 16);
    return x;
}

static unsigned int do_csum(const unsigned char *buff, int len)                                        
{   
    int odd, count;
    unsigned long result = 0;                                                                          
    
    if (len <= 0)                                                                                      
        goto out;
    odd = 1 & (unsigned long) buff;                                                                    
    if (odd) {
#ifdef __LITTLE_ENDIAN
        result = *buff;                                                                                
#else   
        result += (*buff << 8);                                                                        
#endif  
        len--;
        buff++;                                                                                        
    }
    count = len >> 1;       /* nr of 16-bit words.. */                                                 
    if (count) {
        if (2 & (unsigned long) buff) {
            result += *(unsigned short *) buff;                                                        
            count--;
            len -= 2;
            buff += 2;                                                                                 
        }
        count >>= 1;        /* nr of 32-bit words.. */                                                 
        if (count) { 
            unsigned long carry = 0;                                                                   
            do {
                unsigned long w = *(unsigned int *) buff;                                              
                count--;
                buff += 4;
                result += carry;                                                                       
                result += w; 
                carry = (w > result);                                                                  
            } while (count);                                                                           
            result += carry; 
            result = (result & 0xffff) + (result >> 16);                                               
        }
        if (len & 2) {
            result += *(unsigned short *) buff;                                                        
            buff += 2;                                                                                 
        }                                                                                              
    }
    if (len & 1)
#ifdef __LITTLE_ENDIAN
        result += *buff;                                                                               
#else   
        result += (*buff << 8);                                                                        
#endif
    result = from32to16(result);                                                                       
    if (odd)
        result = ((result >> 8) & 0xff) | ((result & 0xff) << 8);
out:
    return result;
}

static inline uint16_t ip_fast_csum(const void *iph, unsigned int ihl)
{
    return (uint16_t)~do_csum(iph, ihl*4);
}

#endif


static inline unsigned int get_microseconds(void)
{
        struct timeval tv;
        gettimeofday(&tv, NULL);
        return tv.tv_sec * 1000000 + tv.tv_usec;
}


static inline unsigned int get_milliseconds(void)
{
        struct timeval tv;
        gettimeofday(&tv, NULL);
        return tv.tv_sec * 1000 + tv.tv_usec / 1000;
}

char *rohc_version(void);


/*
 * ROHC library includes:
 */

#include "crc.h"
#include "decode.h"
#include "ip_id.h"
#include "lsb.h"
#include "sdvl.h"
#include "wlsb.h"
#include "rtp.h"
#include "ip.h"


#endif