osip.h

Go to the documentation of this file.

/*
  The oSIP library implements the Session Initiation Protocol (SIP -rfc3261-)
  Copyright (C) 2001-2020 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 500 /* 500ms */
#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[1024];               
  int srv_state;                 
  char flag[256];                
  char protocol[1024];           
  char regexp[1024];             
  char replacement[1024];        
  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];                      
  char AUS[64];                          
  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; 
  struct osip_srv_record sipenum_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; 
  struct timeval created_time;   
  struct timeval destroyed_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