/home/chaser/Zfone/Work/build/zfone-full-0.90.438/zfone3/lib/libzrtp/include/zrtp.h

Go to the documentation of this file.

/*
 * libZRTP SDK library, implements the ZRTP secure VoIP protocol.
 * Copyright (c) 2006-2009 Philip R. Zimmermann.  All rights reserved.
 * Contact: http://philzimmermann.com
 * For licensing and other legal details, see the file zrtp_legal.c.
 * 
 * Viktor Krykun <v.krikun at zfoneproject.com> 
 */

#ifndef __ZRTP_H__
#define __ZRTP_H__

#include "zrtp_config.h"
#include "zrtp_base.h"
#include "zrtp_error.h"
#include "zrtp_types.h"
#include "zrtp_protocol.h"
#include "zrtp_engine.h"
#include "zrtp_crypto.h"
#include "zrtp_iface.h"
#include "zrtp_iface_system.h"
#include "zrtp_iface_scheduler.h"
#include "zrtp_list.h"
#include "zrtp_legal.h"
#include "zrtp_log.h"
#include "zrtp_srtp.h"
#include "zrtp_srtp_builtin.h"
#include "zrtp_string.h"
#include "zrtp_pbx.h"
#include "zrtp_legal.h"
#include "zrtp_version.h"
#include "zrtp_iface_cache.h"
#if (defined(ZRTP_ENABLE_EC) && (ZRTP_ENABLE_EC == 1))
#include "zrtp_ec.h"
#endif



/*======================================================================*/
/*    Public ZRTP libzrtp datatypes                                     */
/*======================================================================*/


typedef enum zrtp_license_mode_t
{
    ZRTP_LICENSE_MODE_PASSIVE = 0,
    ZRTP_LICENSE_MODE_ACTIVE,
    ZRTP_LICENSE_MODE_UNLIMITED
} zrtp_license_mode_t;


typedef unsigned char zrtp_zid_t[12];

typedef char zrtp_client_id_t[16];
    
typedef struct zrtp_config_t
{   
    zrtp_client_id_t        client_id;
    
    zrtp_license_mode_t     lic_mode;
    
    uint8_t                 is_mitm;
    
    zrtp_callback_t         cb;

    zrtp_string128_t        def_cache_path;
} zrtp_config_t;

struct zrtp_stream_info_t
{
    zrtp_id_t               id;
        
    zrtp_session_t*         session;
    
    zrtp_stream_mode_t      mode;
    
    zrtp_mitm_mode_t        mitm_mode;
    
    zrtp_state_t            state;
    
    zrtp_protocol_error_t   last_error;
    
    uint8_t                 peer_passive;
    
    uint8_t                 res_allowclear;
        
    uint8_t                 peer_disclose; 
    
    uint8_t                 peer_mitm;
};

struct zrtp_session_info_t
{
    zrtp_id_t           id;
        
    zrtp_string16_t     zid;
    
    zrtp_string16_t     peer_zid;
    
    zrtp_string16_t     peer_clientid;
    
    zrtp_string16_t     peer_version;
    
    uint8_t             sas_is_ready;
    
    zrtp_string16_t     sas1;
    
    zrtp_string16_t     sas2;
    
    zrtp_string32_t     sasbin;
    
    uint32_t            cached_flags;
    
    uint32_t            matches_flags;
    
    uint32_t            wrongs_flags;
   
    uint32_t            sas_is_verified;

    uint8_t             sas_is_base256;
        
    uint32_t            secrets_ttl;
        
    zrtp_string32_t     hash_name;
    
    zrtp_string32_t     cipher_name;
    
    zrtp_string32_t     auth_name;
    
    zrtp_string32_t     sas_name;
    
    zrtp_string32_t     pk_name;
};

/* \} */


/*======================================================================*/
/*    libzrtp Public API: Streams management                            */
/*======================================================================*/


#if defined(__cplusplus)
extern "C"
{
#endif  

void zrtp_config_defaults(zrtp_config_t* config);
    
zrtp_status_t zrtp_init(zrtp_config_t* config, zrtp_global_t** zrtp);

zrtp_status_t zrtp_down(zrtp_global_t* zrtp);

/* \} */

zrtp_status_t zrtp_session_init( zrtp_global_t* zrtp,
                                 zrtp_profile_t* profile,
                                 zrtp_zid_t zid,
                                 uint8_t is_initiator,
                                 zrtp_session_t **session);
void zrtp_session_down(zrtp_session_t *session);
    

zrtp_status_t zrtp_session_get(zrtp_session_t *session, zrtp_session_info_t *info);

void zrtp_session_set_userdata(zrtp_session_t *session, void* udata);
    
void* zrtp_session_get_userdata(zrtp_session_t *session);

zrtp_status_t zrtp_stream_attach(zrtp_session_t *session, zrtp_stream_t** stream);

zrtp_status_t zrtp_stream_start(zrtp_stream_t* stream, uint32_t ssrc);

zrtp_status_t zrtp_stream_stop(zrtp_stream_t* stream);

zrtp_status_t zrtp_stream_clear(zrtp_stream_t *stream);

zrtp_status_t zrtp_stream_secure(zrtp_stream_t *stream);

zrtp_status_t zrtp_stream_get(zrtp_stream_t *stream, zrtp_stream_info_t *info);

void zrtp_stream_set_userdata(zrtp_stream_t *stream, void* udata);
    
void* zrtp_stream_get_userdata(const zrtp_stream_t *stream);

/* \} */

/*======================================================================*/
/*    libzrtp Public API: Encryption                                    */
/*======================================================================*/

zrtp_status_t  zrtp_process_rtp( zrtp_stream_t *stream,
                                 char* packet,
                                 unsigned int* length);

zrtp_status_t  zrtp_process_srtp( zrtp_stream_t *stream,
                                  char* packet,
                                  unsigned int* length);

zrtp_status_t  zrtp_process_rtcp( zrtp_stream_t *stream,
                                  char* packet,
                                  unsigned int* length);

zrtp_status_t  zrtp_process_srtcp( zrtp_stream_t *stream,
                                   char* packet,
                                   unsigned int* length);

/* \} */

zrtp_status_t zrtp_signaling_hash_set( zrtp_stream_t* stream,
                                      const char *hash_buff,
                                      uint32_t hash_buff_length);

zrtp_status_t zrtp_signaling_hash_get( zrtp_stream_t* stream,
                                       char* hash_buff,
                                       uint32_t hash_buff_length);

zrtp_status_t zrtp_verified_set( zrtp_global_t *zrtp,
                                 zrtp_string16_t *zid1,
                                 zrtp_string16_t *zid2,
                                 uint8_t verified); 

zrtp_status_t zrtp_profile_check(const zrtp_profile_t* profile, zrtp_global_t* zrtp);

void zrtp_profile_defaults(zrtp_profile_t* profile, zrtp_global_t* zrtp);

int zrtp_profile_find(const zrtp_profile_t* profile, zrtp_crypto_comp_t type, uint8_t id);
    
/* \} */

int zrtp_entropy_add(zrtp_global_t* zrtp, const unsigned char *buffer, uint32_t length);

int zrtp_randstr(zrtp_global_t* zrtp, unsigned char *buffer, uint32_t length);

/* \} */

#if defined(__cplusplus)
}
#endif

#endif /* __ZRTP_H__ */

---