core: added internal flag for adding xavp fields to via params
[sip-router] / src / core / parser / msg_parser.h
1 /*
2  * Copyright (C) 2001-2003 FhG Fokus
3  *
4  * This file is part of Kamailio, a free SIP server.
5  *
6  * Kamailio is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License as published by
8  * the Free Software Foundation; either version 2 of the License, or
9  * (at your option) any later version
10  *
11  * Kamailio is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  * GNU General Public License for more details.
15  *
16  * You should have received a copy of the GNU General Public License
17  * along with this program; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
19  *
20  */
21
22 /*! \file
23  * \brief Parser :: ???
24  *
25  * \ingroup parser
26  */
27
28
29 #ifndef msg_parser_h
30 #define msg_parser_h
31
32
33 #include "../comp_defs.h"
34 #include "../str.h"
35 #include "../lump_struct.h"
36 #include "../flags.h"
37 #include "../ip_addr.h"
38 #include "../md5utils.h"
39 #include "../config.h"
40 #include "parse_def.h"
41 #include "parse_cseq.h"
42 #include "parse_via.h"
43 #include "parse_fline.h"
44 #include "parse_retry_after.h"
45 #include "hf.h"
46 #include "../error.h"
47
48
49 /*! \name convenience short-cut macros */
50 /*@{ */
51 #define REQ_LINE(_msg) ((_msg)->first_line.u.request)
52 #define REQ_METHOD first_line.u.request.method_value
53 #define REPLY_STATUS first_line.u.reply.statuscode
54 #define REPLY_CLASS(_reply) ((_reply)->REPLY_STATUS/100)
55 /*@} */
56
57 /*! \brief start of "actual" sip msg (start of first line) */
58 #define SIP_MSG_START(m)        ((m)->first_line.u.request.method.s)
59
60 /*! \brief number methods as power of two to allow bitmap matching */
61 typedef enum request_method {
62         METHOD_UNDEF=0,           /*!< 0 - --- */
63         METHOD_INVITE=1,          /*!< 1 - 2^0 */
64         METHOD_CANCEL=2,          /*!< 2 - 2^1 */
65         METHOD_ACK=4,             /*!< 4 - 2^2 */
66         METHOD_BYE=8,             /*!< 8 - 2^3 */
67         METHOD_INFO=16,           /*!< 16 - 2^4 */
68         METHOD_REGISTER=32,       /*!< 32 - 2^5 */
69         METHOD_SUBSCRIBE=64,      /*!< 64 - 2^6 */
70         METHOD_NOTIFY=128,        /*!< 128 - 2^7 */
71         METHOD_MESSAGE=256,       /*!< 256 - 2^8 */
72         METHOD_OPTIONS=512,       /*!< 512 - 2^9 */
73         METHOD_PRACK=1024,        /*!< 1024 - 2^10 */
74         METHOD_UPDATE=2048,       /*!< 2048 - 2^11 */
75         METHOD_REFER=4096,        /*!< 4096 - 2^12 */
76         METHOD_PUBLISH=8192,      /*!< 8192 - 2^13 */
77         METHOD_OTHER=16384        /*!< 16384 - 2^14 */
78 } request_method_t;
79
80 #define FL_FORCE_RPORT  (1 << 0)  /*!< force rport */
81 #define FL_FORCE_ACTIVE (1 << 1)  /*!< force active SDP */
82 #define FL_SDP_IP_AFS   (1 << 2)  /*!< SDP IP rewritten */
83 #define FL_SDP_PORT_AFS (1 << 3)  /*!< SDP port rewritten */
84 #define FL_SHM_CLONE    (1 << 4)  /*!< msg cloned in SHM as a single chunk */
85 #define FL_TIMEOUT      (1 << 5)  /*!< message belongs to an "expired" branch
86                                                                         (for failure route use) */
87 #define FL_REPLIED      (1 << 6)  /*!< message branch received at least one reply
88                                                                         (for failure route use) */
89 #define FL_HASH_INDEX   (1 << 7)  /*!< msg->hash_index contains a valid value (tm use)*/
90
91 #define FL_MTU_TCP_FB   (1 << 8)
92 #define FL_MTU_TLS_FB   (1 << 9)
93 #define FL_MTU_SCTP_FB  (1 << 10)
94 #define FL_ADD_LOCAL_RPORT  (1 << 11) /*!< add 'rport' to local via hdr */
95 #define FL_SDP_BODY     (1 << 12)  /*!< msg has SDP in body */
96 #define FL_USE_UAC_FROM      (1<<13)  /* take FROM hdr from UAC instead of UAS*/
97 #define FL_USE_UAC_TO        (1<<14)  /* take TO hdr from UAC instead of UAS */
98 #define FL_TM_RPL_MATCHED    (1<<15)  /* tm matched reply already */
99 #define FL_RPL_SUSPENDED     (1<<16)  /* for async reply processing */
100 #define FL_BODY_MULTIPART    (1<<17)  /* body modified is multipart */
101 #define FL_RR_ADDED          (1<<18)  /* Record-Route header was added */
102 #define FL_UAC_AUTH          (1<<19)  /* Proxy UAC-like authentication */
103 #define FL_ADD_SRVID         (1<<20) /*!< add 'srvid' to local via hdr */
104 #define FL_ADD_XAVP_VIA      (1<<21) /*!< add xavp fields to local via params */
105
106 /* WARNING: Value (1 << 28) is temporarily reserved for use in kamailio call_control
107  * module (flag  FL_USE_CALL_CONTROL )! */
108
109 /* WARNING: Value (1 << 29) is temporarily reserved for use in kamailio acc
110  * module (flag FL_REQ_UPSTREAM)! */
111
112 /* WARNING: Value (1 << 30) is temporarily reserved for use in kamailio
113  * media proxy module (flag FL_USE_MEDIA_PROXY)! */
114
115 /* WARNING: Value (1 << 31) is temporarily reserved for use in kamailio
116  * nat_traversal module (flag FL_DO_KEEPALIVE)! */
117
118 #define FL_MTU_FB_MASK  (FL_MTU_TCP_FB|FL_MTU_TLS_FB|FL_MTU_SCTP_FB)
119
120
121 #define IFISMETHOD(methodname,firstchar)                                  \
122 if (  (*tmp==(firstchar) || *tmp==((firstchar) | 32)) &&                  \
123                 strncasecmp( tmp+1, #methodname +1, methodname##_LEN-1)==0 &&     \
124                 *(tmp+methodname##_LEN)==' ') {                                   \
125                                 fl->type=SIP_REQUEST;                                     \
126                                 fl->u.request.method.len=methodname##_LEN;                \
127                                 fl->u.request.method_value=METHOD_##methodname;           \
128                                 tmp=buffer+methodname##_LEN;                              \
129 }
130
131 #define IS_HTTP(req)                                                \
132         ((req)->first_line.u.request.version.len >= HTTP_VERSION_LEN && \
133         !strncasecmp((req)->first_line.u.request.version.s,             \
134                 HTTP_VERSION, HTTP_VERSION_LEN))
135
136 #define IS_SIP(req)                                                \
137         ((req)->first_line.u.request.version.len >= SIP_VERSION_LEN && \
138         !strncasecmp((req)->first_line.u.request.version.s,             \
139                 SIP_VERSION, SIP_VERSION_LEN))
140
141 #define IS_HTTP_REPLY(rpl)                                                \
142         ((rpl)->first_line.u.reply.version.len >= HTTP_VERSION_LEN && \
143         !strncasecmp((rpl)->first_line.u.reply.version.s,             \
144                 HTTP_VERSION, HTTP_VERSION_LEN))
145
146 #define IS_SIP_REPLY(rpl)                                                \
147         ((rpl)->first_line.u.reply.version.len >= SIP_VERSION_LEN && \
148         !strncasecmp((rpl)->first_line.u.reply.version.s,             \
149                 SIP_VERSION, SIP_VERSION_LEN))
150
151 /*! \brief
152  * Return a URI to which the message should be really sent (not what should
153  * be in the Request URI. The following fields are tried in this order:
154  * 1) dst_uri
155  * 2) new_uri
156  * 3) first_line.u.request.uri
157  */
158 #define GET_NEXT_HOP(m) \
159 (((m)->dst_uri.s && (m)->dst_uri.len) ? (&(m)->dst_uri) : \
160 (((m)->new_uri.s && (m)->new_uri.len) ? (&(m)->new_uri) : (&(m)->first_line.u.request.uri)))
161
162
163 /*! \brief
164  * Return the Reqeust URI of a message.
165  * The following fields are tried in this order:
166  * 1) new_uri
167  * 2) first_line.u.request.uri
168  */
169 #define GET_RURI(m) \
170 (((m)->new_uri.s && (m)->new_uri.len) ? (&(m)->new_uri) : (&(m)->first_line.u.request.uri))
171
172
173 enum _uri_type{ERROR_URI_T=0, SIP_URI_T, SIPS_URI_T, TEL_URI_T, TELS_URI_T, URN_URI_T};
174 typedef enum _uri_type uri_type;
175 enum _uri_flags{
176         URI_USER_NORMALIZE=1,
177         URI_SIP_USER_PHONE=2
178 }; /* bit fields */
179 typedef enum _uri_flags uri_flags;
180
181 /*! \brief The SIP uri object */
182 struct sip_uri {
183         str user;     /*!< Username */
184         str passwd;   /*!< Password */
185         str host;     /*!< Host name */
186         str port;     /*!< Port number */
187         str params;   /*!< Parameters */
188         str sip_params; /*!< Parameters of the sip: URI.
189                                         * (If a tel: URI is embedded in a sip: URI, then
190                                         * params points to the parameters of the tel: URI,
191                                         * and sip_params to the parameters of the sip: URI.
192                                         */
193         str headers;
194         unsigned short port_no;
195         unsigned short proto; /*!< from transport */
196         uri_type type; /*!< uri scheme */
197         uri_flags flags;
198         /*!< parameters */
199         str transport;
200         str ttl;
201         str user_param;
202         str maddr;
203         str method;
204         str lr;
205         str r2; /*!< ser specific rr parameter */
206         str gr;
207         str transport_val; /*!< transport value */
208         str ttl_val;     /*!< TTL value */
209         str user_param_val; /*!< User= param value */
210         str maddr_val; /*!< Maddr= param value */
211         str method_val; /*!< Method value */
212         str lr_val; /*!< lr value placeholder for lr=on a.s.o*/
213         str r2_val;
214         str gr_val;
215 #ifdef USE_COMP
216         unsigned short comp;
217 #endif
218 };
219
220 typedef struct sip_uri sip_uri_t;
221
222 struct msg_body;
223
224 typedef void (*free_msg_body_f)(struct msg_body** ptr);
225
226 typedef enum msg_body_type {
227         MSG_BODY_UNKNOWN = 0,
228         MSG_BODY_SDP
229 } msg_body_type_t;
230
231 /*! \brief This structure represents a generic SIP message body, regardless of the
232  * body type.
233  *
234  * Body parsers are supposed to cast this structure to some other
235  * body-type specific structure, but the body type specific structure must
236  * retain msg_body_type variable and a pointer to the free function as the
237  * first two variables within the structure.
238  */
239 typedef struct msg_body {
240         msg_body_type_t type;
241         free_msg_body_f free;
242 } msg_body_t;
243
244
245 /* pre-declaration, to include sys/time.h in .c */
246 struct timeval;
247
248 /* structure for cached decoded flow for outbound */
249 typedef struct ocd_flow {
250                 int decoded;
251                 struct receive_info rcv;
252 } ocd_flow_t;
253
254 /* structure holding fields that don't have to be cloned in shm
255  * - its content is memset'ed to in shm clone
256  * - add to msg_ldata_reset() if a field uses dynamic memory */
257 typedef struct msg_ldata {
258         ocd_flow_t flow;
259 } msg_ldata_t;
260
261 /*! \brief The SIP message */
262 typedef struct sip_msg {
263         unsigned int id;               /*!< message id, unique/process*/
264         int pid;                       /*!< process id */
265         struct timeval tval;           /*!< time value associated to message */
266         snd_flags_t fwd_send_flags;    /*!< send flags for forwarding */
267         snd_flags_t rpl_send_flags;    /*!< send flags for replies */
268         struct msg_start first_line;   /*!< Message first line */
269         struct via_body* via1;         /*!< The first via */
270         struct via_body* via2;         /*!< The second via */
271         struct hdr_field* headers;     /*!< All the parsed headers*/
272         struct hdr_field* last_header; /*!< Pointer to the last parsed header*/
273         hdr_flags_t parsed_flag;    /*!< Already parsed header field types */
274
275         /* Via, To, CSeq, Call-Id, From, end of header*/
276         /* pointers to the first occurrences of these headers;
277          * everything is also saved in 'headers'
278          * (WARNING: do not deallocate them twice!)*/
279
280         struct hdr_field* h_via1;
281         struct hdr_field* h_via2;
282         struct hdr_field* callid;
283         struct hdr_field* to;
284         struct hdr_field* cseq;
285         struct hdr_field* from;
286         struct hdr_field* contact;
287         struct hdr_field* maxforwards;
288         struct hdr_field* route;
289         struct hdr_field* record_route;
290         struct hdr_field* content_type;
291         struct hdr_field* content_length;
292         struct hdr_field* authorization;
293         struct hdr_field* expires;
294         struct hdr_field* proxy_auth;
295         struct hdr_field* supported;
296         struct hdr_field* require;
297         struct hdr_field* proxy_require;
298         struct hdr_field* unsupported;
299         struct hdr_field* allow;
300         struct hdr_field* event;
301         struct hdr_field* accept;
302         struct hdr_field* accept_language;
303         struct hdr_field* organization;
304         struct hdr_field* priority;
305         struct hdr_field* subject;
306         struct hdr_field* user_agent;
307         struct hdr_field* server;
308         struct hdr_field* content_disposition;
309         struct hdr_field* diversion;
310         struct hdr_field* rpid;
311         struct hdr_field* refer_to;
312         struct hdr_field* session_expires;
313         struct hdr_field* min_se;
314         struct hdr_field* sipifmatch;
315         struct hdr_field* subscription_state;
316         struct hdr_field* date;
317         struct hdr_field* identity;
318         struct hdr_field* identity_info;
319         struct hdr_field* pai;
320         struct hdr_field* ppi;
321         struct hdr_field* path;
322         struct hdr_field* privacy;
323         struct hdr_field* min_expires;
324
325         struct msg_body* body;
326
327         char* eoh;        /*!< pointer to the end of header (if found) or null */
328         char* unparsed;   /*!< here we stopped parsing*/
329
330         struct receive_info rcv; /*!< source & dest ip, ports, proto a.s.o*/
331
332         char* buf;        /*!< scratch pad, holds a modified message,
333                                                 *  via, etc. point into it */
334         unsigned int len; /*!< message len (orig) */
335
336         /* modifications */
337
338         str new_uri; /*!< changed first line uri, when you change this
339                                         don't forget to set parsed_uri_ok to 0*/
340
341         str dst_uri; /*!< Destination URI, must be forwarded to this URI if len != 0 */
342
343         /* current uri */
344         int parsed_uri_ok; /*!< 1 if parsed_uri is valid, 0 if not, set if to 0
345                                                 if you modify the uri (e.g change new_uri)*/
346         struct sip_uri parsed_uri; /*!< speed-up > keep here the parsed uri*/
347         int parsed_orig_ruri_ok; /*!< 1 if parsed_orig_uri is valid, 0 if not, set if to 0
348                                                                 if you modify the uri (e.g change new_uri)*/
349         struct sip_uri parsed_orig_ruri; /*!< speed-up > keep here the parsed orig uri*/
350
351         struct lump* add_rm;       /*!< used for all the forwarded requests/replies */
352         struct lump* body_lumps;     /*!< Lumps that update Content-Length */
353         struct lump_rpl *reply_lump; /*!< only for localy generated replies !!!*/
354
355         /*! \brief str add_to_branch;
356                 whatever whoever want to append to Via branch comes here */
357         char add_to_branch_s[MAX_BRANCH_PARAM_LEN];
358         int add_to_branch_len;
359
360         unsigned int  hash_index; /*!< index to TM hash table; stored in core
361                                                                 to avoid unnecessary calculations */
362         unsigned int msg_flags; /*!< internal flags used by core */
363         flag_t flags; /*!< config flags */
364         flag_t xflags[KSR_XFLAGS_SIZE]; /*!< config extended flags */
365         str set_global_address;
366         str set_global_port;
367         struct socket_info* force_send_socket; /*!< force sending on this socket */
368         str path_vec;
369         str instance;
370         unsigned int reg_id;
371         str ruid;
372         str location_ua;
373
374         /* structure with fields that are needed for local processing
375          * - not cloned to shm, reset to 0 in the clone */
376         msg_ldata_t ldv;
377
378         /* IMPORTANT: when adding new fields in this structure (sip_msg_t),
379          * be sure it is freed in free_sip_msg() and it is cloned or reset
380          * to shm structure for transaction - see sip_msg_clone.c. In tm
381          * module, take care of these fields for faked environemt used for
382          * runing failure handlers - see modules/tm/t_reply.c */
383 } sip_msg_t;
384
385 /*! \brief pointer to a fakes message which was never received ;
386         (when this message is "relayed", it is generated out
387         of the original request)
388 */
389 #define FAKED_REPLY     ((struct sip_msg *) -1)
390
391 extern int via_cnt;
392 /** global  request flags.
393  *  msg->msg_flags should be OR'ed with it before
394  * a flag value is checked, e.g.:
395  * if ((msg->msg_flags|global_req_flags) & FL_XXX) ...
396  */
397 extern unsigned int global_req_flags;
398
399
400 int parse_msg(char* const buf, const unsigned int len, struct sip_msg* const msg);
401
402 int parse_headers(struct sip_msg* const msg, const hdr_flags_t flags, const int next);
403
404 char* get_hdr_field(char* const buf, char* const end, struct hdr_field* const hdr);
405
406 void free_sip_msg(struct sip_msg* const msg);
407
408 /*! \brief make sure all HFs needed for transaction identification have been
409         parsed; return 0 if those HFs can't be found
410 */
411 int check_transaction_quadruple(sip_msg_t* const msg);
412
413 /*! \brief returns a pointer to the begining of the msg's body
414  */
415 char* get_body(sip_msg_t* const msg);
416
417 /*! \brief If the new_uri is set, then reset it */
418 void reset_new_uri(struct sip_msg* const msg);
419
420 /*! \brief
421  * Make a private copy of the string and assign it to dst_uri
422  */
423 int set_dst_uri(struct sip_msg* const msg, const str* const uri);
424
425 /*! \brief If the dst_uri is set to an URI then reset it */
426 void reset_dst_uri(struct sip_msg* const msg);
427
428 hdr_field_t* get_hdr(const sip_msg_t* const msg, const enum _hdr_types_t ht);
429 hdr_field_t* next_sibling_hdr(const hdr_field_t* const hf);
430 /** not used yet */
431 hdr_field_t* get_hdr_by_name(const sip_msg_t* const msg, const char* const name,
432                 const int name_len);
433 hdr_field_t* next_sibling_hdr_by_name(const hdr_field_t* const hf);
434
435 int set_path_vector(struct sip_msg* msg, str* path);
436
437 void reset_path_vector(struct sip_msg* const msg);
438
439 int set_instance(struct sip_msg* msg, str* instance);
440
441 void reset_instance(struct sip_msg* const msg);
442
443 int set_ruid(struct sip_msg* msg, str* ruid);
444
445 void reset_ruid(struct sip_msg* const msg);
446
447 int set_ua(struct sip_msg* msg, str *location_ua);
448
449 void reset_ua(struct sip_msg* const msg);
450
451 /** force a specific send socket for forwarding a request.
452  * @param msg - sip msg.
453  * @param fsocket - forced socket, pointer to struct socket_info, can be 0 (in
454  *                  which case it's equivalent to reset_force_socket()).
455  */
456 #define set_force_socket(msg, fsocket) \
457         do { \
458                 (msg)->force_send_socket=(fsocket); \
459                 if ((msg)->force_send_socket) \
460                         (msg)->fwd_send_flags.f |= SND_F_FORCE_SOCKET; \
461                 else \
462                         (msg)->fwd_send_flags.f &= ~SND_F_FORCE_SOCKET; \
463         } while (0)
464
465 /** reset a previously forced send socket. */
466 #define reset_force_socket(msg) set_force_socket(msg, 0)
467
468 /**
469  * struct to identify a msg context
470  * - the pair of pid and message-id
471  */
472 typedef struct msg_ctx_id {
473         int pid;
474         int msgid;
475 } msg_ctx_id_t;
476
477 /**
478  * set msg context id
479  * - return: -1 on error; 0 - on set
480  */
481 int msg_ctx_id_set(const sip_msg_t* const msg, msg_ctx_id_t* const mid);
482
483 /**
484  * check msg context id
485  * - return: -1 on error; 0 - on no match; 1 - on match
486  */
487 int msg_ctx_id_match(const sip_msg_t* const msg, const msg_ctx_id_t* const mid);
488
489 /**
490  * set msg time value
491  */
492 int msg_set_time(sip_msg_t* const msg);
493
494 /**
495  * reset content of msg->ldv (msg_ldata_t structure)
496  */
497 void msg_ldata_reset(sip_msg_t*);
498
499 /**
500  * get source ip, port and protocol in SIP URI format
501  */
502 int get_src_uri(sip_msg_t *m, int tmode, str *uri);
503
504 /**
505  * get source proto:ip:port (socket address format)
506  */
507 int get_src_address_socket(sip_msg_t *m, str *ssock);
508
509 /**
510  * get received-on-socket ip, port and protocol in SIP URI format
511  */
512 int get_rcv_socket_uri(sip_msg_t *m, int tmode, str *uri, int atype);
513
514 #endif