msg_parser.h

Go to the documentation of this file.

/*
 * $Id$
 *
 * Copyright (C) 2001-2003 FhG Fokus
 *
 * This file is part of ser, a free SIP server.
 *
 * ser 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
 *
 * For a license to use the ser software under conditions
 * other than those described here, or to purchase support for this
 * software, please contact iptel.org by e-mail at the following addresses:
 *    info@iptel.org
 *
 * ser 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
 *
 * History
 * -------
 *  2003-01-28  removed scratchpad (jiri)
 *  2003-02-28  scratchpad compatibility abandoned (jiri)
 *  2003-03-06  enum_request_method changed to begin with 1;
 *               0 reserved for invalid values; (jiri)
 *  2003-03-31  removed sip_msg->repl_add_rm (andrei)
 *  2003-04-01  2 macros added: GET_NEXT_HOP and GET_RURI (janakj)
 *  2003-04-04  structure for parsed inbound uri added (jiri)
 *  2003-04-11  updated the  sip_uri structure (lots of fields added) (andrei)
 *  2003-04-12  added msg_flags to sip_msg (andrei)
 *  2003-11-02  added diversion header field to sip_msg (jh)
 *  2004-11-08  added force_send_socket (andrei)
 *  2005-02-25  uri types added (sip, sips & tel)  (andrei)
 *  2006-04-20  uri comp member (only if USE_COMP is defined) (andrei)
 *  2006-11-10  check_transaction_quadruple inlined (andrei)
 *  2007-01-26  added date, identity, identity_info header fields
 *              to sip_msg (gergo)
 *  2007-03-14  added SIP_MSG_START(msg) macro
 */

#ifndef msg_parser_h
#define msg_parser_h


#include "../comp_defs.h"
#include "../str.h"
#include "../lump_struct.h"
#include "../flags.h"
#include "../ip_addr.h"
#include "../md5utils.h"
#include "../config.h"
#include "parse_def.h"
#include "parse_cseq.h"
#include "parse_via.h"
#include "parse_fline.h"
#include "parse_retry_after.h"
#include "hf.h"
#include "../error.h"



#define REQ_LINE(_msg) ((_msg)->first_line.u.request)
#define REQ_METHOD first_line.u.request.method_value
#define REPLY_STATUS first_line.u.reply.statuscode
#define REPLY_CLASS(_reply) ((_reply)->REPLY_STATUS/100)

#define SIP_MSG_START(m)        ((m)->first_line.u.request.method.s)

enum request_method {
        METHOD_UNDEF=0,           
        METHOD_INVITE=1,          
        METHOD_CANCEL=2,          
        METHOD_ACK=4,             
        METHOD_BYE=8,             
        METHOD_INFO=16,           
        METHOD_REGISTER=32,       
        METHOD_SUBSCRIBE=64,      
        METHOD_NOTIFY=128,        
        METHOD_MESSAGE=256,       
        METHOD_OPTIONS=512,       
        METHOD_PRACK=1024,        
        METHOD_UPDATE=2048,       
        METHOD_REFER=4096,        
        METHOD_PUBLISH=8192,      
        METHOD_OTHER=16384        
};

#define FL_FORCE_RPORT  (1 << 0)  
#define FL_FORCE_ACTIVE (1 << 1)  
#define FL_SDP_IP_AFS   (1 << 2)  
#define FL_SDP_PORT_AFS (1 << 3)  
#define FL_SHM_CLONE    (1 << 4)  
#define FL_TIMEOUT      (1 << 5)  
#define FL_REPLIED      (1 << 6)  
#define FL_HASH_INDEX   (1 << 7)  
#define FL_MTU_TCP_FB   (1 << 8)
#define FL_MTU_TLS_FB   (1 << 9)
#define FL_MTU_SCTP_FB  (1 << 10)
#define FL_ADD_LOCAL_RPORT  (1 << 11) 
#define FL_SDP_BODY     (1 << 12)  
#define FL_USE_UAC_FROM      (1<<13)  /* take FROM hdr from UAC instead of UAS*/
#define FL_USE_UAC_TO        (1<<14)  /* take TO hdr from UAC instead of UAS */

/* WARNING: Value (1 << 28) is temporarily reserved for use in kamailio call_control
 * module (flag  FL_USE_CALL_CONTROL )! */

/* WARNING: Value (1 << 29) is temporarily reserved for use in kamailio acc
 * module (flag FL_REQ_UPSTREAM)! */

/* WARNING: Value (1 << 30) is temporarily reserved for use in kamailio
 * media proxy module (flag FL_USE_MEDIA_PROXY)! */

/* WARNING: Value (1 << 31) is temporarily reserved for use in kamailio
 * nat_traversal module (flag FL_DO_KEEPALIVE)! */

#define FL_MTU_FB_MASK  (FL_MTU_TCP_FB|FL_MTU_TLS_FB|FL_MTU_SCTP_FB)


#define IFISMETHOD(methodname,firstchar)                                  \
if (  (*tmp==(firstchar) || *tmp==((firstchar) | 32)) &&                  \
        strncasecmp( tmp+1, #methodname +1, methodname##_LEN-1)==0 &&     \
        *(tmp+methodname##_LEN)==' ') {                                   \
                fl->type=SIP_REQUEST;                                     \
                fl->u.request.method.len=methodname##_LEN;                \
                fl->u.request.method_value=METHOD_##methodname;           \
                tmp=buffer+methodname##_LEN;                              \
}

#define IS_HTTP(req)                                                \
    ((req)->first_line.u.request.version.len >= HTTP_VERSION_LEN && \
    !strncasecmp((req)->first_line.u.request.version.s,             \
                HTTP_VERSION, HTTP_VERSION_LEN))

#define IS_SIP(req)                                                \
    ((req)->first_line.u.request.version.len >= SIP_VERSION_LEN && \
    !strncasecmp((req)->first_line.u.request.version.s,             \
                SIP_VERSION, SIP_VERSION_LEN))

#define GET_NEXT_HOP(m) \
(((m)->dst_uri.s && (m)->dst_uri.len) ? (&(m)->dst_uri) : \
(((m)->new_uri.s && (m)->new_uri.len) ? (&(m)->new_uri) : (&(m)->first_line.u.request.uri)))


#define GET_RURI(m) \
(((m)->new_uri.s && (m)->new_uri.len) ? (&(m)->new_uri) : (&(m)->first_line.u.request.uri))


enum _uri_type{ERROR_URI_T=0, SIP_URI_T, SIPS_URI_T, TEL_URI_T, TELS_URI_T, URN_URI_T};
typedef enum _uri_type uri_type;
enum _uri_flags{
        URI_USER_NORMALIZE=1,
        URI_SIP_USER_PHONE=2
}; /* bit fields */
typedef enum _uri_flags uri_flags;

struct sip_uri {
        str user;     
        str passwd;   
        str host;     
        str port;     
        str params;   
        str sip_params; 
        str headers;
        unsigned short port_no;
        unsigned short proto; 
        uri_type type; 
        uri_flags flags;
        str transport;
        str ttl;
        str user_param;
        str maddr;
        str method;
        str lr;
        str r2; 
        str gr;
        str transport_val; 
        str ttl_val;     
        str user_param_val; 
        str maddr_val; 
        str method_val; 
        str lr_val; 
        str r2_val;
        str gr_val;
#ifdef USE_COMP
        unsigned short comp;
#endif
};

typedef struct sip_uri sip_uri_t;

struct msg_body;

typedef void (*free_msg_body_f)(struct msg_body** ptr);

typedef enum msg_body_type {
        MSG_BODY_UNKNOWN = 0,
        MSG_BODY_SDP
} msg_body_type_t;

typedef struct msg_body {
        msg_body_type_t type;
        free_msg_body_f free;
} msg_body_t;


/* pre-declaration, to include sys/time.h in .c */
struct timeval;

typedef struct sip_msg {
        unsigned int id;               
        int pid;                       
        struct timeval tval;           
        snd_flags_t fwd_send_flags;    
        snd_flags_t rpl_send_flags;    
        struct msg_start first_line;   
        struct via_body* via1;         
        struct via_body* via2;         
        struct hdr_field* headers;     
        struct hdr_field* last_header; 
        hdr_flags_t parsed_flag;    
             /* Via, To, CSeq, Call-Id, From, end of header*/
             /* pointers to the first occurrences of these headers;
                  * everything is also saved in 'headers'
                  * (WARNING: do not deallocate them twice!)*/

        struct hdr_field* h_via1;
        struct hdr_field* h_via2;
        struct hdr_field* callid;
        struct hdr_field* to;
        struct hdr_field* cseq;
        struct hdr_field* from;
        struct hdr_field* contact;
        struct hdr_field* maxforwards;
        struct hdr_field* route;
        struct hdr_field* record_route;
        struct hdr_field* content_type;
        struct hdr_field* content_length;
        struct hdr_field* authorization;
        struct hdr_field* expires;
        struct hdr_field* proxy_auth;
        struct hdr_field* supported;
        struct hdr_field* require;
        struct hdr_field* proxy_require;
        struct hdr_field* unsupported;
        struct hdr_field* allow;
        struct hdr_field* event;
        struct hdr_field* accept;
        struct hdr_field* accept_language;
        struct hdr_field* organization;
        struct hdr_field* priority;
        struct hdr_field* subject;
        struct hdr_field* user_agent;
        struct hdr_field* server;
        struct hdr_field* content_disposition;
        struct hdr_field* diversion;
        struct hdr_field* rpid;
        struct hdr_field* refer_to;
        struct hdr_field* session_expires;
        struct hdr_field* min_se;
        struct hdr_field* sipifmatch;
        struct hdr_field* subscription_state;
        struct hdr_field* date;
        struct hdr_field* identity;
        struct hdr_field* identity_info;
        struct hdr_field* pai;
        struct hdr_field* ppi;
        struct hdr_field* path;
        struct hdr_field* privacy;

        struct msg_body* body;

        char* eoh;        
        char* unparsed;   
        struct receive_info rcv; 
        char* buf;        
        unsigned int len; 
             /* modifications */

        str new_uri; 
        str dst_uri; 
        /* current uri */
        int parsed_uri_ok; 
        struct sip_uri parsed_uri; 
        int parsed_orig_ruri_ok; 
        struct sip_uri parsed_orig_ruri; 
        struct lump* add_rm;       
        struct lump* body_lumps;     
        struct lump_rpl *reply_lump; 
        char add_to_branch_s[MAX_BRANCH_PARAM_LEN];
        int add_to_branch_len;

        unsigned int  hash_index; 
        unsigned int msg_flags; 
             /* allows to set various flags on the message; may be used for
              * simple inter-module communication or remembering processing state
              * reached
              */
        flag_t flags;
        str set_global_address;
        str set_global_port;
        struct socket_info* force_send_socket; /* force sending on this socket,
                                                                                          if ser */
        str path_vec;
} sip_msg_t;

#define FAKED_REPLY     ((struct sip_msg *) -1)

extern int via_cnt;
extern unsigned int global_req_flags;


int parse_msg(char* buf, unsigned int len, struct sip_msg* msg);

int parse_headers(struct sip_msg* msg, hdr_flags_t flags, int next);

char* get_hdr_field(char* buf, char* end, struct hdr_field* hdr);

void free_sip_msg(struct sip_msg* msg);

inline static int check_transaction_quadruple( struct sip_msg* msg )
{
        if ( parse_headers(msg, HDR_FROM_F|HDR_TO_F|HDR_CALLID_F|HDR_CSEQ_F,0)!=-1
                && msg->from && msg->to && msg->callid && msg->cseq ) {
                return 1;
        } else {
                ser_error=E_BAD_TUPEL;
                return 0;
        }
}



inline static char* get_body(struct sip_msg *msg)
{
        int offset;
        unsigned int len;

        if ( parse_headers(msg, HDR_EOH_F, 0)==-1 )
                return 0;

        if (msg->unparsed){
                len=(unsigned int)(msg->unparsed-msg->buf);
        }else return 0;
        if ((len+2<=msg->len) && (strncmp(CRLF,msg->unparsed,CRLF_LEN)==0) )
                offset = CRLF_LEN;
        else if ( (len+1<=msg->len) &&
                                (*(msg->unparsed)=='\n' || *(msg->unparsed)=='\r' ) )
                offset = 1;
        else
                return 0;

        return msg->unparsed + offset;
}


int set_dst_uri(struct sip_msg* msg, str* uri);

void reset_dst_uri(struct sip_msg* msg);

hdr_field_t* get_hdr(sip_msg_t *msg, enum _hdr_types_t ht);
hdr_field_t* next_sibling_hdr(hdr_field_t *hf);
hdr_field_t* get_hdr_by_name(sip_msg_t *msg, char *name, int name_len);
hdr_field_t* next_sibling_hdr_by_name(hdr_field_t *hf);

int set_path_vector(struct sip_msg* msg, str* path);

void reset_path_vector(struct sip_msg* msg);


#define set_force_socket(msg, fsocket) \
        do { \
                (msg)->force_send_socket=(fsocket); \
                if ((msg)->force_send_socket) \
                        (msg)->fwd_send_flags.f |= SND_F_FORCE_SOCKET; \
                else \
                        (msg)->fwd_send_flags.f &= ~SND_F_FORCE_SOCKET; \
        } while (0)

#define reset_force_socket(msg) set_force_socket(msg, 0)

typedef struct msg_ctx_id {
        int pid;
        int msgid;
} msg_ctx_id_t;

int msg_ctx_id_set(sip_msg_t *msg, msg_ctx_id_t *mid);

int msg_ctx_id_match(sip_msg_t *msg, msg_ctx_id_t *mid);

int msg_set_time(sip_msg_t *msg);

#endif