osip.h

Go to the documentation of this file.

/*
  The oSIP library implements the Session Initiation Protocol (SIP -rfc3261-)
  Copyright (C) 2001-2012 Aymeric MOIZARD amoizard@antisip.com
  
  This library is free software; you can redistribute it and/or
  modify it under the terms of the GNU Lesser General Public
  License as published by the Free Software Foundation; either
  version 2.1 of the License, or (at your option) any later version.
  
  This library 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
  Lesser General Public License for more details.
  
  You should have received a copy of the GNU Lesser General Public
  License along with this library; if not, write to the Free Software
  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/


#ifndef _OSIP_H_
#define _OSIP_H_

#include <osipparser2/osip_const.h>

/* Time-related functions and data types */
#include <osip2/osip_time.h>

#ifdef __sun
#include <sys/types.h>
#endif

#include <osipparser2/osip_parser.h>
#include <osip2/osip_fifo.h>

#ifdef __cplusplus
extern "C" {
#endif


  typedef enum _state_t {
    /* STATES for invite client transaction */
    ICT_PRE_CALLING,
    ICT_CALLING,
    ICT_PROCEEDING,
    ICT_COMPLETED,
    ICT_TERMINATED,

    /* STATES for invite server transaction */
    IST_PRE_PROCEEDING,
    IST_PROCEEDING,
    IST_COMPLETED,
    IST_CONFIRMED,
    IST_TERMINATED,

    /* STATES for NON-invite client transaction */
    NICT_PRE_TRYING,
    NICT_TRYING,
    NICT_PROCEEDING,
    NICT_COMPLETED,
    NICT_TERMINATED,

    /* STATES for NON-invite server transaction */
    NIST_PRE_TRYING,
    NIST_TRYING,
    NIST_PROCEEDING,
    NIST_COMPLETED,
    NIST_TERMINATED,

#ifndef DOXYGEN
    DIALOG_EARLY,
    DIALOG_CONFIRMED,
    DIALOG_CLOSE                /* ?? */
#endif
  } state_t;

  typedef enum type_t {
    /* TIMEOUT EVENTS for ICT */
    TIMEOUT_A,                   
    TIMEOUT_B,                   
    TIMEOUT_D,                   
    /* TIMEOUT EVENTS for NICT */
    TIMEOUT_E,                   
    TIMEOUT_F,                   
    TIMEOUT_K,                   
    /* TIMEOUT EVENTS for IST */
    TIMEOUT_G,                   
    TIMEOUT_H,                   
    TIMEOUT_I,                   
    /* TIMEOUT EVENTS for NIST */
    TIMEOUT_J,                   
    /* FOR INCOMING MESSAGE */
    RCV_REQINVITE,               
    RCV_REQACK,                  
    RCV_REQUEST,                 
    RCV_STATUS_1XX,              
    RCV_STATUS_2XX,              
    RCV_STATUS_3456XX,           
    /* FOR OUTGOING MESSAGE */
    SND_REQINVITE,               
    SND_REQACK,                  
    SND_REQUEST,                 
    SND_STATUS_1XX,              
    SND_STATUS_2XX,              
    SND_STATUS_3456XX,           
    KILL_TRANSACTION,            
    UNKNOWN_EVT                  
  } type_t;

  typedef enum osip_fsm_type_t {
    ICT,         
    IST,         
    NICT,        
    NIST         
  } osip_fsm_type_t;

#ifndef DEFAULT_T1

#define DEFAULT_T1 500          /* 500 ms */
#endif
#ifndef DEFAULT_T1_TCP_PROGRESS

#define DEFAULT_T1_TCP_PROGRESS 50         /* 50ms */
#endif
#ifndef DEFAULT_T2

#define DEFAULT_T2 4000         /* 4s */
#endif
#ifndef DEFAULT_T4

#define DEFAULT_T4 5000         /* 5s */
#endif


  typedef struct osip_ict osip_ict_t;

  struct osip_ict {
    int timer_a_length;                           
    struct timeval timer_a_start;                 
    int timer_b_length;                           
    struct timeval timer_b_start;                 
    int timer_d_length;                           
    struct timeval timer_d_start;                 
    char *destination;                            
    int port;                                     
  };

  typedef struct osip_nict osip_nict_t;

  struct osip_nict {
    int timer_e_length;                           
    struct timeval timer_e_start;                 
    int timer_f_length;                           
    struct timeval timer_f_start;                 
    int timer_k_length;                           
    struct timeval timer_k_start;                 
    char *destination;                            
    int port;                                     
  };

  typedef struct osip_ist osip_ist_t;

  struct osip_ist {
    int timer_g_length;                           
    struct timeval timer_g_start;                 
    int timer_h_length;                           
    struct timeval timer_h_start;                 
    int timer_i_length;                           
    struct timeval timer_i_start;                 
  };

  typedef struct osip_nist osip_nist_t;

  struct osip_nist {
    int timer_j_length;                            
    struct timeval timer_j_start;                  
  };

  typedef struct osip_srv_entry osip_srv_entry_t;

  struct osip_srv_entry {
    char srv[512];                   
    int priority;                    
    int weight;                      
    int rweight;                     
    int port;                        
    char ipaddress[512];             
    struct timeval srv_is_broken;    
  };

#define OSIP_SRV_STATE_UNKNOWN 0         
#define OSIP_SRV_STATE_RETRYLATER 2      
#define OSIP_SRV_STATE_COMPLETED 3       
#define OSIP_SRV_STATE_NOTSUPPORTED 4    
  typedef struct osip_srv_record osip_srv_record_t;

  struct osip_srv_record {
    char name[512];                  
    int srv_state;                   
    char protocol[64];               
    int order;                       
    int preference;                  
    int index;                       
    osip_srv_entry_t srventry[10];   
  };

#define OSIP_NAPTR_STATE_UNKNOWN 0         
#define OSIP_NAPTR_STATE_INPROGRESS 1      
#define OSIP_NAPTR_STATE_NAPTRDONE 2       
#define OSIP_NAPTR_STATE_SRVINPROGRESS 3   
#define OSIP_NAPTR_STATE_SRVDONE 4         
#define OSIP_NAPTR_STATE_RETRYLATER 5      
#define OSIP_NAPTR_STATE_NOTSUPPORTED 6    
  typedef struct osip_naptr osip_naptr_t;

  struct osip_naptr {
    char domain[512];                       
    int naptr_state;                        
    void *arg;                              
    int keep_in_cache;                      
    struct osip_srv_record sipudp_record;   
    struct osip_srv_record siptcp_record;   
    struct osip_srv_record siptls_record;   
    struct osip_srv_record sipdtls_record;  
    struct osip_srv_record sipsctp_record;  
  };

  typedef struct osip_transaction osip_transaction_t;

  struct osip_transaction {

    void *your_instance;                
    int transactionid;                  
    osip_fifo_t *transactionff;         
    osip_via_t *topvia;                 
    osip_from_t *from;                  
    osip_to_t *to;                      
    osip_call_id_t *callid;             
    osip_cseq_t *cseq;                  
    osip_message_t *orig_request;       
    osip_message_t *last_response;      
    osip_message_t *ack;                
    state_t state;                      
    time_t birth_time;                  
    time_t completed_time;              
    int in_socket;                      
    int out_socket;                     
    void *config;                       
    osip_fsm_type_t ctx_type;           
    osip_ict_t *ict_context;            
    osip_ist_t *ist_context;            
    osip_nict_t *nict_context;          
    osip_nist_t *nist_context;          
    osip_srv_record_t record;           
    osip_naptr_t *naptr_record;         
    void *reserved1;                    
    void *reserved2;                    
    void *reserved3;                    
    void *reserved4;                    
    void *reserved5;                    
    void *reserved6;                    
  };


  typedef enum osip_message_callback_type {
    OSIP_ICT_INVITE_SENT = 0,                           
    OSIP_ICT_INVITE_SENT_AGAIN,                         
    OSIP_ICT_ACK_SENT,                                  
    OSIP_ICT_ACK_SENT_AGAIN,                            
    OSIP_ICT_STATUS_1XX_RECEIVED,                       
    OSIP_ICT_STATUS_2XX_RECEIVED,                       
    OSIP_ICT_STATUS_2XX_RECEIVED_AGAIN,                 
    OSIP_ICT_STATUS_3XX_RECEIVED,                       
    OSIP_ICT_STATUS_4XX_RECEIVED,                       
    OSIP_ICT_STATUS_5XX_RECEIVED,                       
    OSIP_ICT_STATUS_6XX_RECEIVED,                       
    OSIP_ICT_STATUS_3456XX_RECEIVED_AGAIN,              
    OSIP_IST_INVITE_RECEIVED,                           
    OSIP_IST_INVITE_RECEIVED_AGAIN,                     
    OSIP_IST_ACK_RECEIVED,                              
    OSIP_IST_ACK_RECEIVED_AGAIN,                        
    OSIP_IST_STATUS_1XX_SENT,                           
    OSIP_IST_STATUS_2XX_SENT,                           
    OSIP_IST_STATUS_2XX_SENT_AGAIN,                     
    OSIP_IST_STATUS_3XX_SENT,                           
    OSIP_IST_STATUS_4XX_SENT,                           
    OSIP_IST_STATUS_5XX_SENT,                           
    OSIP_IST_STATUS_6XX_SENT,                           
    OSIP_IST_STATUS_3456XX_SENT_AGAIN,                  
    OSIP_NICT_REGISTER_SENT,                            
    OSIP_NICT_BYE_SENT,                                 
    OSIP_NICT_OPTIONS_SENT,                             
    OSIP_NICT_INFO_SENT,                                
    OSIP_NICT_CANCEL_SENT,                              
    OSIP_NICT_NOTIFY_SENT,                              
    OSIP_NICT_SUBSCRIBE_SENT,                           
    OSIP_NICT_UNKNOWN_REQUEST_SENT,                     
    OSIP_NICT_REQUEST_SENT_AGAIN,                       
    OSIP_NICT_STATUS_1XX_RECEIVED,                      
    OSIP_NICT_STATUS_2XX_RECEIVED,                      
    OSIP_NICT_STATUS_2XX_RECEIVED_AGAIN,                
    OSIP_NICT_STATUS_3XX_RECEIVED,                      
    OSIP_NICT_STATUS_4XX_RECEIVED,                      
    OSIP_NICT_STATUS_5XX_RECEIVED,                      
    OSIP_NICT_STATUS_6XX_RECEIVED,                      
    OSIP_NICT_STATUS_3456XX_RECEIVED_AGAIN,             
    OSIP_NIST_REGISTER_RECEIVED,                        
    OSIP_NIST_BYE_RECEIVED,                             
    OSIP_NIST_OPTIONS_RECEIVED,                         
    OSIP_NIST_INFO_RECEIVED,                            
    OSIP_NIST_CANCEL_RECEIVED,                          
    OSIP_NIST_NOTIFY_RECEIVED,                          
    OSIP_NIST_SUBSCRIBE_RECEIVED,                       
    OSIP_NIST_UNKNOWN_REQUEST_RECEIVED,                 
    OSIP_NIST_REQUEST_RECEIVED_AGAIN,                   
    OSIP_NIST_STATUS_1XX_SENT,                          
    OSIP_NIST_STATUS_2XX_SENT,                          
    OSIP_NIST_STATUS_2XX_SENT_AGAIN,                    
    OSIP_NIST_STATUS_3XX_SENT,                          
    OSIP_NIST_STATUS_4XX_SENT,                          
    OSIP_NIST_STATUS_5XX_SENT,                          
    OSIP_NIST_STATUS_6XX_SENT,                          
    OSIP_NIST_STATUS_3456XX_SENT_AGAIN,                 
    OSIP_ICT_STATUS_TIMEOUT,                            
    OSIP_NICT_STATUS_TIMEOUT,                           
    OSIP_MESSAGE_CALLBACK_COUNT                         
  } osip_message_callback_type_t;

  typedef enum osip_kill_callback_type {
    OSIP_ICT_KILL_TRANSACTION,                  
    OSIP_IST_KILL_TRANSACTION,                  
    OSIP_NICT_KILL_TRANSACTION,                 
    OSIP_NIST_KILL_TRANSACTION,                 
    OSIP_KILL_CALLBACK_COUNT                    
  } osip_kill_callback_type_t;

  typedef enum osip_transport_error_callback_type {
    OSIP_ICT_TRANSPORT_ERROR,                             
    OSIP_IST_TRANSPORT_ERROR,                             
    OSIP_NICT_TRANSPORT_ERROR,                            
    OSIP_NIST_TRANSPORT_ERROR,                            
    OSIP_TRANSPORT_ERROR_CALLBACK_COUNT                   
  } osip_transport_error_callback_type_t;

  typedef void (*osip_message_cb_t) (int type, osip_transaction_t *, osip_message_t *);
  typedef void (*osip_kill_transaction_cb_t) (int type, osip_transaction_t *);
  typedef void (*osip_transport_error_cb_t) (int type, osip_transaction_t *, int error);


  struct osip_dialog;

  typedef struct ixt ixt_t;

  struct ixt {
    /* any ACK received that match this context will set counter to -1 */
    struct osip_dialog *dialog;         
    osip_message_t *msg2xx;             
    osip_message_t *ack;                
    struct timeval start;               
    int interval;                       
    char *dest;                         
    int port;                           
    int sock;                           
    int counter;                        
  };


  typedef struct osip osip_t;

  struct osip {

    void *application_context;     
    void *ict_fastmutex;           
    void *ist_fastmutex;           
    void *nict_fastmutex;          
    void *nist_fastmutex;          
    void *ixt_fastmutex;           
    void *id_mutex;                
    int transactionid;             
    /* list of transactions for ict, ist, nict, nist */
    osip_list_t osip_ict_transactions;          
    osip_list_t osip_ist_transactions;          
    osip_list_t osip_nict_transactions;         
    osip_list_t osip_nist_transactions;         
    osip_list_t ixt_retransmissions;            
    osip_message_cb_t msg_callbacks[OSIP_MESSAGE_CALLBACK_COUNT];                
    osip_kill_transaction_cb_t kill_callbacks[OSIP_KILL_CALLBACK_COUNT];         
    osip_transport_error_cb_t tp_error_callbacks[OSIP_TRANSPORT_ERROR_CALLBACK_COUNT];     
    int (*cb_send_message) (osip_transaction_t *, osip_message_t *, char *, int, int);     
    void *osip_ict_hastable;                              
    void *osip_ist_hastable;                              
    void *osip_nict_hastable;                             
    void *osip_nist_hastable;                             
  };

  int osip_set_message_callback (osip_t * osip, int type, osip_message_cb_t cb);

  int osip_set_kill_transaction_callback (osip_t * osip, int type, osip_kill_transaction_cb_t cb);

  int osip_set_transport_error_callback (osip_t * osip, int type, osip_transport_error_cb_t cb);

  typedef struct osip_event osip_event_t;

  struct osip_event {
    type_t type;                     
    int transactionid;               
    osip_message_t *sip;             
  };



  int osip_transaction_init (osip_transaction_t ** transaction, osip_fsm_type_t ctx_type, osip_t * osip, osip_message_t * request);
  int osip_transaction_free (osip_transaction_t * transaction);
  int osip_transaction_free2 (osip_transaction_t * transaction);

  void osip_response_get_destination (osip_message_t * response, char **address, int *portnum);
  int osip_ict_set_destination (osip_ict_t * ict, char *destination, int port);

  int osip_nict_set_destination (osip_nict_t * nict, char *destination, int port);

  int osip_transaction_add_event (osip_transaction_t * transaction, osip_event_t * evt);
  int osip_transaction_execute (osip_transaction_t * transaction, osip_event_t * evt);
  int osip_transaction_set_your_instance (osip_transaction_t * transaction, void *ptr);

  int osip_transaction_set_reserved1 (osip_transaction_t * transaction, void *ptr);
  int osip_transaction_set_reserved2 (osip_transaction_t * transaction, void *ptr);

  int osip_transaction_set_reserved3 (osip_transaction_t * transaction, void *ptr);

  int osip_transaction_set_reserved4 (osip_transaction_t * transaction, void *ptr);

  int osip_transaction_set_reserved5 (osip_transaction_t * transaction, void *ptr);

  int osip_transaction_set_reserved6 (osip_transaction_t * transaction, void *ptr);

  void *osip_transaction_get_your_instance (osip_transaction_t * transaction);

  void *osip_transaction_get_reserved1 (osip_transaction_t * transaction);

  void *osip_transaction_get_reserved2 (osip_transaction_t * transaction);

  void *osip_transaction_get_reserved3 (osip_transaction_t * transaction);

  void *osip_transaction_get_reserved4 (osip_transaction_t * transaction);

  void *osip_transaction_get_reserved5 (osip_transaction_t * transaction);

  void *osip_transaction_get_reserved6 (osip_transaction_t * transaction);

  int osip_transaction_get_destination (osip_transaction_t * transaction, char **ip, int *port);


  int osip_transaction_set_srv_record (osip_transaction_t * transaction, osip_srv_record_t * record);

  int osip_transaction_set_naptr_record (osip_transaction_t * transaction, osip_naptr_t * record);

  int osip_transaction_set_in_socket (osip_transaction_t * transaction, int sock);
  int osip_transaction_set_out_socket (osip_transaction_t * transaction, int sock);



  int osip_init (osip_t ** osip);
  void osip_release (osip_t * osip);

  void osip_set_application_context (osip_t * osip, void *pointer);

  void *osip_get_application_context (osip_t * osip);


  int osip_remove_transaction (osip_t * osip, osip_transaction_t * ict);


  int osip_ict_execute (osip_t * osip);
  int osip_ist_execute (osip_t * osip);
  int osip_nict_execute (osip_t * osip);
  int osip_nist_execute (osip_t * osip);

  void osip_timers_gettimeout (osip_t * osip, struct timeval *lower_tv);

  void osip_timers_ict_execute (osip_t * osip);
  void osip_timers_ist_execute (osip_t * osip);
  void osip_timers_nict_execute (osip_t * osip);
  void osip_timers_nist_execute (osip_t * osip);

/* Take care of mutlithreading issuewhile using this method */
  osip_transaction_t *osip_transaction_find (osip_list_t * transactions, osip_event_t * evt);


#ifndef DOXYGEN

#ifdef OSIP_MONOTHREAD
  osip_transaction_t *osip_find_transaction (osip_t * osip, osip_event_t * evt);
#endif

  osip_transaction_t *__osip_find_transaction (osip_t * osip, osip_event_t * evt, int consume);
#endif

  int osip_find_transaction_and_add_event (osip_t * osip, osip_event_t * evt);

  osip_transaction_t *osip_create_transaction (osip_t * osip, osip_event_t * evt);

  osip_event_t *osip_parse (const char *buf, size_t length);


  void osip_retransmissions_execute (osip_t * osip);

  void osip_start_200ok_retransmissions (osip_t * osip, struct osip_dialog *dialog, osip_message_t * msg200ok, int sock);

  void osip_start_ack_retransmissions (osip_t * osip, struct osip_dialog *dialog, osip_message_t * ack, char *dest, int port, int sock);

  struct osip_dialog *osip_stop_200ok_retransmissions (osip_t * osip, osip_message_t * ack);

  void osip_stop_retransmissions_from_dialog (osip_t * osip, struct osip_dialog *dialog);


  osip_event_t *osip_new_outgoing_sipmessage (osip_message_t * sip);

  void osip_event_free (osip_event_t * event);

  void osip_set_cb_send_message (osip_t * cf, int (*cb) (osip_transaction_t *, osip_message_t *, char *, int, int));

/* FOR INCOMING TRANSACTION */
#define EVT_IS_RCV_INVITE(event)       (event->type==RCV_REQINVITE)

#define EVT_IS_RCV_ACK(event)          (event->type==RCV_REQACK)

#define EVT_IS_RCV_REQUEST(event)      (event->type==RCV_REQUEST)

#define EVT_IS_RCV_STATUS_1XX(event)   (event->type==RCV_STATUS_1XX)

#define EVT_IS_RCV_STATUS_2XX(event)   (event->type==RCV_STATUS_2XX)

#define EVT_IS_RCV_STATUS_3456XX(event)   (event->type==RCV_STATUS_3456XX)


/* FOR OUTGOING TRANSACTION */
#define EVT_IS_SND_INVITE(event)       (event->type==SND_REQINVITE)

#define EVT_IS_SND_ACK(event)          (event->type==SND_REQACK)

#define EVT_IS_SND_REQUEST(event)      (event->type==SND_REQUEST)

#define EVT_IS_SND_STATUS_1XX(event)   (event->type==SND_STATUS_1XX)

#define EVT_IS_SND_STATUS_2XX(event)   (event->type==SND_STATUS_2XX)

#define EVT_IS_SND_STATUS_3456XX(event)   (event->type==SND_STATUS_3456XX)

#define EVT_IS_INCOMINGMSG(event)      (event->type>=RCV_REQINVITE \
                                       &&event->type<=RCV_STATUS_3456XX)

#define EVT_IS_INCOMINGREQ(event)      (EVT_IS_RCV_INVITE(event) \
                                       ||EVT_IS_RCV_ACK(event) \
                                       ||EVT_IS_RCV_REQUEST(event))

#define EVT_IS_INCOMINGRESP(event)     (EVT_IS_RCV_STATUS_1XX(event) \
                                       ||EVT_IS_RCV_STATUS_2XX(event) \
                                       ||EVT_IS_RCV_STATUS_3456XX(event))

#define EVT_IS_OUTGOINGMSG(event)      (event->type>=SND_REQINVITE \
                                       &&event->type<=SND_STATUS_3456XX)

#define EVT_IS_OUTGOINGREQ(event)      (EVT_IS_SND_INVITE(event) \
                                       ||EVT_IS_SND_ACK(event) \
                                       ||EVT_IS_SND_REQUEST(event))

#define EVT_IS_OUTGOINGRESP(event)     (EVT_IS_SND_STATUS_1XX(event) \
                                       ||EVT_IS_SND_STATUS_2XX(event) \
                                       ||EVT_IS_SND_STATUS_3456XX(event))

#define EVT_IS_MSG(event)              (event->type>=RCV_REQINVITE \
                                       &&event->type<=SND_STATUS_3456XX)

#define EVT_IS_KILL_TRANSACTION(event) (event->type==KILL_TRANSACTION)

#ifdef __cplusplus
}
#endif

#endif