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

/*
 * 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_TYPES_H__
#define __ZRTP_TYPES_H__

#include "zrtp_config.h"
#include "bn.h"
#include "zrtp_base.h"
#include "zrtp_iface.h"
#include "zrtp_list.h"
#include "zrtp_legal.h"
#include "zrtp_string.h"
#include "zrtp_protocol.h"


typedef enum zrtp_state_t
{    
    ZRTP_STATE_NONE             = 0,
    ZRTP_STATE_ACTIVE,                  
    ZRTP_STATE_START,                   
    ZRTP_STATE_WAIT_HELLOACK,           
    ZRTP_STATE_WAIT_HELLO,              
    ZRTP_STATE_CLEAR,                   
    ZRTP_STATE_START_INITIATINGSECURE,  
    ZRTP_STATE_INITIATINGSECURE,        
    ZRTP_STATE_WAIT_CONFIRM1,           
    ZRTP_STATE_WAIT_CONFIRMACK,         
    ZRTP_STATE_PENDINGSECURE,           
    ZRTP_STATE_WAIT_CONFIRM2,           
    ZRTP_STATE_SECURE,                  
    ZRTP_STATE_SASRELAYING,             
    ZRTP_STATE_INITIATINGCLEAR,         
    ZRTP_STATE_PENDINGCLEAR,            
    ZRTP_STATE_INITIATINGERROR,         
    ZRTP_STATE_PENDINGERROR,            
    ZRTP_STATE_ERROR,                   
#if (defined(ZRTP_BUILD_FOR_CSD) && (ZRTP_BUILD_FOR_CSD == 1))
    ZRTP_STATE_DRIVEN_INITIATOR,
    ZRTP_STATE_DRIVEN_RESPONDER,
    ZRTP_STATE_DRIVEN_PENDING,
#endif
    ZRTP_STATE_NO_ZRTP,                 
    ZRTP_STATE_COUNT
} zrtp_state_t;

typedef enum zrtp_stream_mode_t
{
    ZRTP_STREAM_MODE_UNKN      = 0, 
    ZRTP_STREAM_MODE_CLEAR     = 1, 
    ZRTP_STREAM_MODE_DH        = 2, 
    ZRTP_STREAM_MODE_PRESHARED = 3, 
    ZRTP_STREAM_MODE_MULT      = 4, 
    ZRTP_STREAM_MODE_COUNT     = 5
} zrtp_stream_mode_t;

struct zrtp_profile_t
{
    uint8_t             allowclear;
    
    uint8_t             autosecure;   
    
    uint8_t             disclose_bit;
    
    uint8_t             discovery_optimization;
    
    uint32_t            cache_ttl;
    
    uint8_t             sas_schemes[ZRTP_MAX_COMP_COUNT+1];
    
    uint8_t             cipher_types[ZRTP_MAX_COMP_COUNT+1];
    
    uint8_t             pk_schemes[ZRTP_MAX_COMP_COUNT+1];
    
    uint8_t             auth_tag_lens[ZRTP_MAX_COMP_COUNT+1];
    
    uint8_t             hash_schemes[ZRTP_MAX_COMP_COUNT+1];
};

struct zrtp_shared_secret_t
{
    zrtp_string64_t         value;        

    uint32_t                lastused_at;

    uint32_t                ttl;
    
    uint8_t                 _cachedflag;    
};

typedef enum zrtp_mitm_mode_t
{
    ZRTP_MITM_MODE_UNKN = 0,
    
    ZRTP_MITM_MODE_CLIENT,
    
    ZRTP_MITM_MODE_RECONFIRM_SERVER,
    ZRTP_MITM_MODE_RECONFIRM_CLIENT,
    ZRTP_MITM_MODE_REG_SERVER,
    ZRTP_MITM_MODE_REG_CLIENT
} zrtp_mitm_mode_t;


/*======================================================================*/
/*    Internal ZRTP libzrtp datatypes                                   */
/*======================================================================*/

typedef enum
{
    ZRTP_UNPARSED       = -1,   
    ZRTP_NONE           = 0,    
    ZRTP_HELLO          = 1,    
    ZRTP_HELLOACK       = 2,    
    ZRTP_COMMIT         = 3,    
    ZRTP_DHPART1        = 4,    
    ZRTP_DHPART2        = 5,    
    ZRTP_CONFIRM1       = 6,    
    ZRTP_CONFIRM2       = 7,    
    ZRTP_CONFIRM2ACK    = 8,    
    ZRTP_GOCLEAR        = 9,    
    ZRTP_GOCLEARACK     = 10,   
    ZRTP_ERROR          = 11,   
    ZRTP_ERRORACK       = 12,   
    ZRTP_PROCESS        = 13,   
    ZRTP_SASRELAY       = 14,   
    ZRTP_RELAYACK       = 15,   
    ZRTP_ZFONEPING      = 16,   
    ZRTP_ZFONEPINGACK   = 17,   
    ZRTP_MSG_TYPE_COUNT = 18
} zrtp_msg_type_t;


typedef enum zrtp_statemachine_type_t
{
    ZRTP_STATEMACHINE_NONE      = 0,    
    ZRTP_STATEMACHINE_INITIATOR = 1,    
    ZRTP_STATEMACHINE_RESPONDER = 2     
} zrtp_statemachine_type_t;

#define    ZRTP_BIT_RS1     0x02
#define    ZRTP_BIT_RS2     0x04
#define    ZRTP_BIT_AUX     0x10
#define    ZRTP_BIT_PBX     0x20

struct zrtp_global_t
{
    uint32_t                lic_mode;
    
    zrtp_string16_t         client_id;
    
    uint8_t                 is_mitm;
    
    MD_CTX                  rand_ctx;
    
    uint8_t                 rand_initialized;

    zrtp_string128_t        def_cache_path;
    
    zrtp_mutex_t*           rng_protector;
    
    struct BigNum           one;
    struct BigNum           G;
    struct BigNum           P_2048;
    struct BigNum           P_2048_1;
    struct BigNum           P_3072;
    struct BigNum           P_3072_1;
    uint8_t                 P_2048_data[256];
    uint8_t                 P_3072_data[384];
    
    mlist_t                 hash_head;
    
    mlist_t                 cipher_head;
    
    mlist_t                 atl_head;
    
    mlist_t                 pktype_head;
    
    mlist_t                 sas_head;
            
    void*                   srtp_global;
    
    mlist_t                 sessions_head;
    
    uint32_t                sessions_count;
    
    uint32_t                streams_count;
    
    zrtp_mutex_t*           sessions_protector;
        
    zrtp_callback_t         cb;
};


typedef struct zrtp_rtp_info_t
{   
    uint32_t                *length;
    
    char                    *packet;
    
    void                    *message;
    
    zrtp_msg_type_t         type;
    
    uint32_t                seq;
    
    uint32_t                ssrc;
} zrtp_rtp_info_t;


typedef struct zrtp_secrets_t
{    
    zrtp_shared_secret_t    *rs1;
    
    zrtp_shared_secret_t    *rs2;
    
    zrtp_shared_secret_t    *auxs;
    
    zrtp_shared_secret_t    *pbxs;
    
    uint32_t                cached;
    uint32_t                cached_curr;
    
    uint32_t                matches;
    uint32_t                matches_curr;
    
    uint32_t                wrongs;
    uint32_t                wrongs_curr;
    
    uint8_t                 is_ready;   
} zrtp_secrets_t;


typedef struct zrtp_proto_secret_t
{
    zrtp_string8_t          id;
    
    zrtp_string8_t          peer_id;
    
    zrtp_shared_secret_t    *secret;
} zrtp_proto_secret_t;


typedef struct zrtp_stream_mescache_t
{
    zrtp_packet_Hello_t     peer_hello;
    zrtp_packet_Hello_t     hello;
    zrtp_packet_GoClear_t   goclear;    
    zrtp_packet_Commit_t    peer_commit;
    zrtp_packet_Commit_t    commit;
    zrtp_packet_DHPart_t    peer_dhpart;
    zrtp_packet_DHPart_t    dhpart;
    zrtp_packet_Confirm_t   confirm;
    zrtp_string32_t         h0;
    zrtp_packet_Confirm_t   peer_confirm;
    zrtp_packet_Error_t     error;
    zrtp_packet_SASRelay_t  sasrelay;
    
    zrtp_retry_task_t       hello_task;
    zrtp_retry_task_t       goclear_task;
    zrtp_retry_task_t       dh_task;
    zrtp_retry_task_t       commit_task;
    zrtp_retry_task_t       dhpart_task;
    zrtp_retry_task_t       confirm_task;
    zrtp_retry_task_t       error_task;
    zrtp_retry_task_t       errorack_task;
    zrtp_retry_task_t       sasrelay_task;
    
    zrtp_string16_t         signaling_hash; 
} zrtp_stream_mescache_t;


typedef struct zrtp_dh_crypto_context_t
{
    struct BigNum           sv;
    
    struct BigNum           pv;
    
    struct BigNum           peer_pv;
    
    zrtp_string64_t         dhss;
    
    unsigned int            initialized_with;
} zrtp_dh_crypto_context_t;


typedef struct zrtp_dsa_crypto_context_t
{
    struct BigNum           sv;     
    struct BigNum           pv;     
    struct BigNum           peer_pv;
} zrtp_dsa_crypto_context_t;


typedef struct zrtp_proto_crypto_t
{   
    zrtp_string128_t        kdf_context;
    
    zrtp_string64_t         s0;
    
    zrtp_string64_t         hv;
    
    zrtp_string64_t         peer_hv;
    
    zrtp_string64_t         mes_hash;
    
    zrtp_proto_secret_t     rs1;
    
    zrtp_proto_secret_t     rs2;
    
    zrtp_proto_secret_t     auxs;
    
    zrtp_proto_secret_t     pbxs;
} zrtp_proto_crypto_t;

struct zrtp_protocol_t
{
    zrtp_statemachine_type_t type;
    
    zrtp_proto_crypto_t*    cc;
    
    zrtp_srtp_ctx_t*        _srtp;
    
    zrtp_stream_t       *context;               
};

typedef struct zrtp_stream_crypto_t
{
    zrtp_string64_t         hmackey;
    
    zrtp_string64_t         peer_hmackey;
    
    zrtp_string64_t         zrtp_key;
    
    zrtp_string64_t         peer_zrtp_key;  
} zrtp_stream_crypto_t;


typedef struct zrtp_media_context_t
{
    uint32_t                high_in_zrtp_seq;
    
    uint32_t                high_out_zrtp_seq;
    
    uint32_t                high_in_media_seq;
    
    uint32_t                high_out_media_seq;
    
    uint32_t                ssrc;
} zrtp_media_context_t;

struct zrtp_stream_t
{
    zrtp_id_t               id;
    
    zrtp_stream_mode_t      mode;
    
    zrtp_mitm_mode_t        mitm_mode;
    
    zrtp_state_t            prev_state;
    
    zrtp_state_t            state;
    
    zrtp_stream_crypto_t    cc;
    
    zrtp_dh_crypto_context_t dh_cc;
    
    zrtp_protocol_t         *protocol;
    
    zrtp_string128_t        signaling_hash;
    
    zrtp_media_context_t    media_ctx;
    
    zrtp_stream_mescache_t  messages;
    
    uint8_t                 allowclear;
    
    uint8_t                 peer_passive;
    
    uint32_t                cache_ttl;
    
    uint8_t                 peer_disclose_bit;    
    
    zrtp_protocol_error_t   last_error;
        
    uint8_t                 peer_mitm_flag;
    
    zrtp_stream_t           *concurrent;
    
    zrtp_global_t           *zrtp;
    
    zrtp_session_t          *session;
    
    zrtp_pk_scheme_t        *pubkeyscheme;
    
    void                    *usr_data;
    
    zrtp_mutex_t*           stream_protector;
};


struct zrtp_session_t
{
    zrtp_id_t               id;
    
    zrtp_string16_t         zid;
    
    zrtp_string16_t         peer_zid;
    
    zrtp_profile_t          profile;
    
    uint8_t                 is_initiator;
    
    zrtp_secrets_t          secrets;
    
    zrtp_string64_t         zrtpsess;       
    
    zrtp_string16_t         sas1;
    
    zrtp_string16_t         sas2;
    
    zrtp_string32_t         sasbin;
    
    zrtp_global_t           *zrtp;
    
    void                    *usr_data;
    
    zrtp_hash_t             *hash;
    
    zrtp_cipher_t           *blockcipher;
    
    zrtp_auth_tag_length_t  *authtaglength;    
    
    zrtp_sas_scheme_t       *sasscheme;
    
    zrtp_stream_t           streams[ZRTP_MAX_STREAMS_PER_SESSION];
    
    zrtp_mutex_t*           streams_protector;
    
    zrtp_mutex_t*           init_protector;
    
    uint8_t                 mitm_alert_detected;
    
    mlist_t                 _mlist;
};

/*===========================================================================*/
/* Data types and definitions for SRTP                                       */
/*===========================================================================*/

#if ZRTP_BYTE_ORDER == ZBO_LITTLE_ENDIAN

typedef struct
{
  uint16_t      cc:4;       
  uint16_t      x:1;        
  uint16_t      p:1;        
  uint16_t      version:2;  
  uint16_t      pt:7;       
  uint16_t      m:1;        
  uint16_t      seq;        
  uint32_t      ts;         
  uint32_t      ssrc;       
} zrtp_rtp_hdr_t;

typedef struct
{
  unsigned char rc:5;       
  unsigned char p:1;        
  unsigned char version:2;  
  unsigned char pt:8;       
  uint16_t      len;        
  uint32_t      ssrc;       
} zrtp_rtcp_hdr_t;

typedef struct
{
  unsigned int  index:31;   
  unsigned int  e:1;        
} zrtp_rtcp_trailer_t;

#else

typedef struct
{
  uint16_t      version:2;  
  uint16_t      p:1;        
  uint16_t      x:1;        
  uint16_t      cc:4;       
  uint16_t      m:1;        
  uint16_t      pt:7;       
  uint16_t      seq;        
  uint32_t      ts;         
  uint32_t      ssrc;       
} zrtp_rtp_hdr_t;

typedef struct
{
  unsigned char version:2;  
  unsigned char p:1;        
  unsigned char rc:5;       
  unsigned char pt:8;       
  uint16_t      len;        
  uint32_t      ssrc;       
} zrtp_rtcp_hdr_t;

typedef struct
{
  unsigned int e:1;         
  unsigned int index:31;    
} zrtp_rtcp_trailer_t;

#endif

typedef struct
{
  uint16_t      profile_specific; 
  uint16_t      length;           
} zrtp_rtp_hdr_xtnd_t;


#endif  /* __ZRTP_TYPES_H__ */

---