core: fix another bunch of 'no real prototype' warnings, add doxygen docs
[sip-router] / rvalue.h
1 /* 
2  * $Id$
3  * 
4  * Copyright (C) 2008 iptelorg GmbH
5  *
6  * Permission to use, copy, modify, and distribute this software for any
7  * purpose with or without fee is hereby granted, provided that the above
8  * copyright notice and this permission notice appear in all copies.
9  *
10  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17  */
18 /**
19  * @file 
20  * @brief rvalue expressions
21  */
22 /* 
23  * History:
24  * --------
25  *  2008-11-30  initial version (andrei)
26  *  2009-04-28  added string and interger versions for the EQ and DIFF
27  *              operators (andrei)
28  *  2009-05-05  casts operator for int & string (andrei)
29  *  2010-03-16  space for an int2str result inside rval_cache (andrei)
30  */
31
32 #ifndef _rvalue_h_
33 #define _rvalue_h_
34
35 #include "str.h"
36 #include "ut.h"
37 #include "usr_avp.h"
38 #include "select.h"
39 #include "pvar.h"
40 #include "route.h"
41 #include "parser/msg_parser.h"
42 #include "action.h"
43
44 enum rval_type{
45         RV_NONE, RV_INT, RV_STR, /* basic types */
46         RV_BEXPR, RV_ACTION_ST,  /* special values */
47         RV_SEL, RV_AVP, RV_PVAR
48 };
49
50 enum rval_expr_op{
51         RVE_NONE_OP,  /* uninit / empty */
52         RVE_RVAL_OP,  /* special op, means that the expr. is in fact a rval */
53         RVE_UMINUS_OP, /* one member expression, returns -(val) */
54         RVE_BOOL_OP,  /* one member evaluate as bool. : (val!=0)*/
55         RVE_LNOT_OP,  /* one member evaluate as bool. : (!val)*/
56         RVE_BNOT_OP,  /* one member evaluate as binary : (~ val)*/
57         RVE_MUL_OP,   /* 2 members, returns left * right */
58         RVE_DIV_OP,   /* 2 members, returns left / right */
59         RVE_MOD_OP,   /* 2 members, returns left % right */
60         RVE_MINUS_OP, /* 2 members, returns left - right */
61         RVE_BAND_OP,  /* 2 members, returns left | right */
62         RVE_BOR_OP,   /* 2 members, returns left & right */
63         RVE_BXOR_OP,   /* 2 members, returns left XOR right */
64         RVE_BLSHIFT_OP,   /* 2 members, returns left << right */
65         RVE_BRSHIFT_OP,   /* 2 members, returns left >> right */
66         RVE_LAND_OP,  /* 2 members, returns left && right */
67         RVE_LOR_OP,   /* 2 members, returns left || right */
68         RVE_GT_OP,    /*  2 members, returns left > right */
69         RVE_GTE_OP,   /*  2 members, returns left >= right */
70         RVE_LT_OP,    /*  2 members, returns left  < right */
71         RVE_LTE_OP,   /*  2 members, returns left <= right */
72         RVE_IEQ_OP, /*  2 members, int == version, returns left == right */
73         RVE_IDIFF_OP,/* 2 members, int != version, returns left != right */
74         RVE_IPLUS_OP, /* 2 members, integer +, returns int(a)+int(b) */
75         /* common int & str */
76         RVE_PLUS_OP,  /* generic plus (int or str) returns left + right */
77         RVE_EQ_OP,    /*  2 members, returns left == right  (int)*/
78         RVE_DIFF_OP,  /*  2 members, returns left != right  (int)*/
79         /* str only */
80         RVE_CONCAT_OP,/* 2 members, string concat, returns left . right (str)*/
81         RVE_STRLEN_OP, /* one member, string length:, returns strlen(val) (int)*/
82         RVE_STREMPTY_OP, /* one member, returns val=="" (bool) */
83         RVE_STREQ_OP,  /* 2 members, string == , returns left == right (bool)*/
84         RVE_STRDIFF_OP,/* 2 members, string != , returns left != right (bool)*/
85         RVE_MATCH_OP,  /* 2 members, string ~),  returns left matches re(right) */
86         /* avp, pvars a.s.o */
87         RVE_DEFINED_OP, /* one member, returns is_defined(val) (bool) */
88         RVE_INT_OP,   /* one member, returns (int)val  (int) */
89         RVE_STR_OP    /* one member, returns (str)val  (str) */
90 };
91
92
93 struct str_re{
94         str s;
95         regex_t* regex;
96 };
97
98 union rval_val{
99         void* p;
100         long  l;
101         str s;
102         avp_spec_t avps;
103         select_t sel;
104         pv_spec_t pvs;
105         struct action* action;
106         struct expr* bexpr;
107         struct str_re re;
108 };
109
110
111 struct rvalue{
112         enum rval_type type;
113         int refcnt; /**< refcnt, on 0 the structure is destroyed */
114         union rval_val v;
115         int bsize; /**< extra data size */
116         short flags;
117         char buf[1]; /**< extra data, like string contents can be stored here */
118 };
119
120
121 /* rvalue flags */
122 #define RV_CNT_ALLOCED_F  1  /* free contents  (pkg mem allocated) */
123 #define RV_RV_ALLOCED_F   2  /* free rv itself (pkg_free(rv)) */
124 #define RV_ALL_ALLOCED_F  (RV_CNT_ALLOCED|RV_RV_ALLOCED)
125 #define RV_RE_F  4 /* string is a RE with a valid v->re member */
126 #define RV_RE_ALLOCED_F 8 /* v->re.regex must be freed */
127
128
129 struct rval_expr{
130         enum rval_expr_op op;
131         union{
132                 struct rval_expr* rve;
133                 struct rvalue rval;
134         }left;
135         union{
136                 struct rval_expr* rve;
137                 struct rvalue rval;
138         }right;
139         struct cfg_pos fpos;
140 };
141
142
143 enum rval_cache_type{
144         RV_CACHE_EMPTY,
145         RV_CACHE_PVAR,
146         RV_CACHE_AVP,
147         RV_CACHE_SELECT,
148         RV_CACHE_INT2STR
149 };
150
151 /** value cache for a rvalue struct.
152   * Used to optimize functions that would need to 
153   * get the value repeatedly (e.g. rval_get_btype() and then rval_get_int())
154   */
155 struct rval_cache{
156         enum rval_cache_type cache_type;
157         enum rval_type val_type;
158         union{
159                 int_str avp_val; /**< avp value */
160                 pv_value_t pval; /**< pvar value */
161         }c;
162         char i2s[INT2STR_MAX_LEN]; /**< space for converting an int to string*/
163 };
164
165
166
167 /** allocates a new rval (should be freed by rval_destroy()). */
168 struct rvalue* rval_new_empty(int extra_size);
169 struct rvalue* rval_new_str(str* s, int extra_size);
170 struct rvalue* rval_new(enum rval_type t, union rval_val* v, int extra_size);
171
172 /** inits a rvalue structure- */
173 void rval_init(struct rvalue* rv, enum rval_type t, union rval_val* v,
174                                         int flags);
175 /** frees a rval_new(), rval_convert() or rval_expr_eval() returned rval. */
176 void rval_destroy(struct rvalue* rv);
177
178 /** frees a rval contents */
179 void rval_clean(struct rvalue* rv);
180
181 /** init a rval_cache struct */
182 #define rval_cache_init(rvc) \
183         do{ (rvc)->cache_type=RV_CACHE_EMPTY; (rvc)->val_type=RV_NONE; }while(0)
184
185 /** destroy a rval_cache struct contents */
186 void rval_cache_clean(struct rval_cache* rvc);
187
188
189 /** convert a rvalue to another type.  */
190 struct rvalue* rval_convert(struct run_act_ctx* h, struct sip_msg* msg, 
191                                                         enum rval_type type, struct rvalue* v,
192                                                         struct rval_cache* c);
193
194 /** get the integer value of an rvalue. */
195 int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, int* i, 
196                                 struct rvalue* rv, struct rval_cache* cache);
197 /** get the string value of an rv. */
198 int rval_get_str(struct run_act_ctx* h, struct sip_msg* msg,
199                                                                 str* s, struct rvalue* rv,
200                                                                 struct rval_cache* cache);
201 /** get the string value of an rv in a tmp variable */
202 int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg,
203                                                                 str* tmpv, struct rvalue* rv,
204                                                                 struct rval_cache* cache,
205                                                                 struct rval_cache* tmp_cache);
206
207 /** evals an integer expr  to an int. */
208 int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg,
209                                                 int* res, struct rval_expr* rve);
210 /** evals a rval expr.. */
211 struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg,
212                                                                 struct rval_expr* rve);
213 /** evals an integer expr  to an int or rvalue. */
214 int rval_expr_eval_rvint( struct run_act_ctx* h, struct sip_msg* msg,
215                                                  struct rvalue** rv_res, int* i_res,
216                                                  struct rval_expr* rve, struct rval_cache* cache);
217
218
219 /** guess the type of an expression.  */
220 enum rval_type rve_guess_type(struct rval_expr* rve);
221 /** returns true if expression is constant. */
222 int rve_is_constant(struct rval_expr* rve);
223 /** returns true if the expression can have side-effect */
224 int rve_has_side_effects(struct rval_expr* rve);
225 /** returns 1 if expression is valid (type-wise).*/
226 int rve_check_type(enum rval_type* type, struct rval_expr* rve,
227                                         struct rval_expr** bad_rve, enum rval_type* bad_type,
228                                         enum rval_type* exp_type);
229 /** returns a string name for type (debugging).*/
230 char* rval_type_name(enum rval_type type);
231
232 /** create a RVE_RVAL_OP rval_expr, containing a single rval of the given type
233   */
234 struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val,
235                                                                         struct cfg_pos* pos);
236 /** create a unary op. rval_expr.. */
237 struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1,
238                                                                         struct cfg_pos* pos);
239 /** create a rval_expr. from 2 other rval exprs, using op. */
240 struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1,
241                                                                                                           struct rval_expr* rve2,
242                                                                                                           struct cfg_pos* pos);
243 /** destroys a pkg_malloc'ed rve. */
244 void rve_destroy(struct rval_expr* rve);
245
246 /** fix a rval_expr. */
247 int fix_rval_expr(void* p);
248 #endif /* _rvalue_h */