Core Update of doxygen, removal of history, changing "ser" to "kamailio"
[sip-router] / rvalue.h
1 /* 
2  * Copyright (C) 2008 iptelorg GmbH
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16  
17 /**
18  * @file 
19  * @brief SIP-router core :: rvalue expressions
20  * @ingroup core
21  * Module: \ref core
22  * @author andrei
23  */
24  
25 #ifndef _rvalue_h_
26 #define _rvalue_h_
27
28 #include "str.h"
29 #include "ut.h"
30 #include "usr_avp.h"
31 #include "select.h"
32 #include "pvar.h"
33 #include "route.h"
34 #include "parser/msg_parser.h"
35 #include "action.h"
36
37 enum rval_type{
38         RV_NONE, RV_INT, RV_STR, /* basic types */
39         RV_BEXPR, RV_ACTION_ST,  /* special values */
40         RV_SEL, RV_AVP, RV_PVAR
41 };
42
43 enum rval_expr_op{
44         RVE_NONE_OP,  /**< uninit / empty */
45         RVE_RVAL_OP,  /**< special op, means that the expr. is in fact a rval */
46         RVE_UMINUS_OP, /**< one member expression, returns -(val) */
47         RVE_BOOL_OP,  /**< one member evaluate as bool. : (val!=0)*/
48         RVE_LNOT_OP,  /**< one member evaluate as bool. : (!val)*/
49         RVE_BNOT_OP,  /**< one member evaluate as binary : (~ val)*/
50         RVE_MUL_OP,   /**< 2 members, returns left * right */
51         RVE_DIV_OP,   /**< 2 members, returns left / right */
52         RVE_MOD_OP,   /**< 2 members, returns left % right */
53         RVE_MINUS_OP, /**< 2 members, returns left - right */
54         RVE_BAND_OP,  /**< 2 members, returns left | right */
55         RVE_BOR_OP,   /**< 2 members, returns left & right */
56         RVE_BXOR_OP,   /**< 2 members, returns left XOR right */
57         RVE_BLSHIFT_OP, /**< 2 members, returns left << right */
58         RVE_BRSHIFT_OP, /**< 2 members, returns left >> right */
59         RVE_LAND_OP,  /**< 2 members, returns left && right */
60         RVE_LOR_OP,   /**< 2 members, returns left || right */
61         RVE_GT_OP,    /**<  2 members, returns left > right */
62         RVE_GTE_OP,   /**<  2 members, returns left >= right */
63         RVE_LT_OP,    /**<  2 members, returns left  < right */
64         RVE_LTE_OP,   /**<  2 members, returns left <= right */
65         RVE_IEQ_OP,   /**<  2 members, int == version, returns left == right */
66         RVE_IDIFF_OP, /**< 2 members, int != version, returns left != right */
67         RVE_IPLUS_OP, /**< 2 members, integer +, returns int(a)+int(b) */
68         /* common int & str */
69         RVE_PLUS_OP,  /**< generic plus (int or str) returns left + right */
70         RVE_EQ_OP,    /**<  2 members, returns left == right  (int)*/
71         RVE_DIFF_OP,  /**<  2 members, returns left != right  (int)*/
72         /* str only */
73         RVE_CONCAT_OP, /**< 2 members, string concat, returns left . right (str)*/
74         RVE_STRLEN_OP, /**< one member, string length:, returns strlen(val) (int)*/
75         RVE_STREMPTY_OP, /**< one member, returns val=="" (bool) */
76         RVE_STREQ_OP,  /**< 2 members, string == , returns left == right (bool)*/
77         RVE_STRDIFF_OP,/**< 2 members, string != , returns left != right (bool)*/
78         RVE_MATCH_OP,  /**< 2 members, string ~),  returns left matches re(right) */
79         /* avp, pvars a.s.o */
80         RVE_DEFINED_OP, /**< one member, returns is_defined(val) (bool) */
81         RVE_NOTDEFINED_OP, /**< one member, returns is_not_defined(val) (bool) */
82         RVE_INT_OP,   /**< one member, returns (int)val  (int) */
83         RVE_STR_OP    /**< one member, returns (str)val  (str) */
84 };
85
86
87 struct str_re{
88         str s;
89         regex_t* regex;
90 };
91
92 union rval_val{
93         void* p;
94         long  l;
95         str s;
96         avp_spec_t avps;
97         select_t sel;
98         pv_spec_t pvs;
99         struct action* action;
100         struct expr* bexpr;
101         struct str_re re;
102 };
103
104
105 struct rvalue{
106         enum rval_type type;
107         int refcnt; /**< refcnt, on 0 the structure is destroyed */
108         union rval_val v;
109         int bsize; /**< extra data size */
110         short flags;
111         char buf[1]; /**< extra data, like string contents can be stored here */
112 };
113
114
115 /* rvalue flags */
116 #define RV_CNT_ALLOCED_F  1  /**< free contents  (pkg mem allocated) */
117 #define RV_RV_ALLOCED_F   2  /**< free rv itself (pkg_free(rv)) */
118 #define RV_ALL_ALLOCED_F  (RV_CNT_ALLOCED|RV_RV_ALLOCED)
119 #define RV_RE_F  4 /**< string is a RE with a valid v->re member */
120 #define RV_RE_ALLOCED_F 8 /**< v->re.regex must be freed */
121
122 struct rval_expr{
123         enum rval_expr_op op;
124         union{
125                 struct rval_expr* rve;
126                 struct rvalue rval;
127         }left;
128         union{
129                 struct rval_expr* rve;
130                 struct rvalue rval;
131         }right;
132         struct cfg_pos fpos;
133 };
134
135
136 enum rval_cache_type{
137         RV_CACHE_EMPTY,
138         RV_CACHE_PVAR,
139         RV_CACHE_AVP,
140         RV_CACHE_SELECT,
141         RV_CACHE_INT2STR
142 };
143
144 /** value cache for a rvalue struct.
145   * Used to optimize functions that would need to 
146   * get the value repeatedly (e.g. rval_get_btype() and then rval_get_int())
147   */
148 struct rval_cache{
149         enum rval_cache_type cache_type;
150         enum rval_type val_type;
151         union{
152                 int_str avp_val; /**< avp value */
153                 pv_value_t pval; /**< pvar value */
154         }c;
155         char i2s[INT2STR_MAX_LEN]; /**< space for converting an int to string*/
156 };
157
158
159
160 /** allocates a new rval (should be freed by rval_destroy()). */
161 struct rvalue* rval_new_empty(int extra_size);
162 struct rvalue* rval_new_str(str* s, int extra_size);
163
164 /**
165  * @brief create a new pk_malloc'ed rvalue from a rval_val union
166  * @param t rvalue type
167  * @param v rvalue value
168  * @param extra_size extra space to allocate
169  * (so that future string operation can reuse the space)
170  * @return new rv or 0 on error
171  */
172 struct rvalue* rval_new(enum rval_type t, union rval_val* v, int extra_size);
173
174 /** inits a rvalue structure- */
175 void rval_init(struct rvalue* rv, enum rval_type t, union rval_val* v,
176                                         int flags);
177 /** frees a rval_new(), rval_convert() or rval_expr_eval() returned rval. */
178 void rval_destroy(struct rvalue* rv);
179
180 /** frees a rval contents */
181 void rval_clean(struct rvalue* rv);
182
183 /** init a rval_cache struct */
184 #define rval_cache_init(rvc) \
185         do{ (rvc)->cache_type=RV_CACHE_EMPTY; (rvc)->val_type=RV_NONE; }while(0)
186
187 /** destroy a rval_cache struct contents */
188 void rval_cache_clean(struct rval_cache* rvc);
189
190
191 /**
192  * @brief Convert a rvalue to another rvalue, of a specific type
193  *
194  * Convert a rvalue to another rvalue, of a specific type.
195  * The result is read-only in most cases (can be a reference
196  * to another rvalue, can be checked by using rv_chg_in_place()) and
197  * _must_ be rval_destroy()'ed.
198  *
199  * @param h run action context
200  * @param msg SIP mesasge
201  * @param type - type to convert to
202  * @param v - rvalue to convert
203  * @param c - rval_cache (cached v value if known/filled by another
204  *            function), can be 0 (unknown/not needed)
205  * @return pointer to a rvalue (reference to an existing one or a new
206  * one, @see rv_chg_in_place() and the above comment), or 0 on error.
207  */
208 struct rvalue* rval_convert(struct run_act_ctx* h, struct sip_msg* msg, 
209                                                         enum rval_type type, struct rvalue* v,
210                                                         struct rval_cache* c);
211
212 /** get the integer value of an rvalue. */
213 int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, int* i, 
214                                 struct rvalue* rv, struct rval_cache* cache);
215 /** get the string value of an rv. */
216 int rval_get_str(struct run_act_ctx* h, struct sip_msg* msg,
217                                                                 str* s, struct rvalue* rv,
218                                                                 struct rval_cache* cache);
219 /** get the string value of an rv in a tmp variable */
220 int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg,
221                                                                 str* tmpv, struct rvalue* rv,
222                                                                 struct rval_cache* cache,
223                                                                 struct rval_cache* tmp_cache);
224
225 /** evals an integer expr  to an int. */
226 int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg,
227                                                 int* res, struct rval_expr* rve);
228
229 /**
230  * @brief Evals a rval expression
231  * @warning result must be rval_destroy()'ed if non-null (it might be
232  * a reference to another rval). The result can be modified only
233  * if rv_chg_in_place() returns true.
234  * @param h run action context
235  * @param msg SIP message
236  * @param rve rvalue expression
237  * @return rvalue on success, 0 on error
238  */
239 struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg,
240                                                                 struct rval_expr* rve);
241
242 /**
243  * @brief Evals a rval expression into an int or another rv(str)
244  * @warning rv result (rv_res) must be rval_destroy()'ed if non-null
245  * (it might be a reference to another rval). The result can be
246  * modified only if rv_chg_in_place() returns true.
247  * @param h run action context
248  * @param msg SIP message
249  * @param res_rv pointer to rvalue result, if non-null it means the 
250  * expression evaluated to a non-int (str), which will be stored here.
251  * @param res_i pointer to int result, if res_rv==0 and the function
252  * returns success => the result is an int which will be stored here.
253  * @param rve expression that will be evaluated.
254  * @param cache write-only value cache, it might be filled if non-null and
255  * empty (rval_cache_init()). If non-null, it _must_ be rval_cache_clean()'ed
256  * when done. 
257  * @return 0 on success, -1 on error, sets *res_rv or *res_i.
258  */
259 int rval_expr_eval_rvint( struct run_act_ctx* h, struct sip_msg* msg,
260                                                  struct rvalue** rv_res, int* i_res,
261                                                  struct rval_expr* rve, struct rval_cache* cache);
262
263
264 /** guess the type of an expression.  */
265 enum rval_type rve_guess_type(struct rval_expr* rve);
266 /** returns true if expression is constant. */
267 int rve_is_constant(struct rval_expr* rve);
268 /** returns true if the expression can have side-effect */
269 int rve_has_side_effects(struct rval_expr* rve);
270
271 /**
272  * @brief Returns 1 if expression is valid (type-wise)
273  * @param type filled with the type of the expression (RV_INT, RV_STR or
274  *                RV_NONE if it's dynamic)
275  * @param rve  checked expression
276  * @param bad_rve set on failure to the subexpression for which the 
277  * type check failed
278  * @param bad_t set on failure to the type of the bad subexpression
279  * @param exp_t set on failure to the expected type for the bad
280  * subexpression
281  * @return 0 or 1 and sets *type to the resulting type
282  * (RV_INT, RV_STR or RV_NONE if it can be found only at runtime)
283  */
284 int rve_check_type(enum rval_type* type, struct rval_expr* rve,
285                                         struct rval_expr** bad_rve, enum rval_type* bad_type,
286                                         enum rval_type* exp_type);
287 /** returns a string name for type (debugging).*/
288 char* rval_type_name(enum rval_type type);
289
290 /** create a RVE_RVAL_OP rval_expr, containing a single rval of the given type
291   */
292 struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val,
293                                                                         struct cfg_pos* pos);
294
295 /**
296  * @brief Create a unary op. rval_expr
297  * ret= op rve1
298  * @param op   - rval expr. unary operator
299  * @param rve1 - rval expr. on which the operator will act.
300  * @param pos configuration position
301  * @return new pkg_malloc'ed rval_expr or 0 on error.
302  */
303 struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1,
304                                                                         struct cfg_pos* pos);
305
306 /**
307  * @brief Create a rval_expr. from 2 other rval exprs, using op
308  * ret = rve1 op rve2
309  * @param op   - rval expr. operator
310  * @param rve1 - rval expr. on which the operator will act.
311  * @param rve2 - rval expr. on which the operator will act.
312  * @param pos configuration position
313  * @return new pkg_malloc'ed rval_expr or 0 on error.
314  */
315 struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1,
316                                                                                                           struct rval_expr* rve2,
317                                                                                                           struct cfg_pos* pos);
318 /** destroys a pkg_malloc'ed rve. */
319 void rve_destroy(struct rval_expr* rve);
320
321 /** fix a rval_expr. */
322 int fix_rval_expr(void* p);
323 #endif /* _rvalue_h */