rvalue.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2008 iptelorg GmbH
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
/* 
 * History:
 * --------
 *  2008-11-30  initial version (andrei)
 *  2009-04-28  added string and interger versions for the EQ and DIFF
 *              operators (andrei)
 *  2009-05-05  casts operator for int & string (andrei)
 *  2010-03-16  space for an int2str result inside rval_cache (andrei)
 */

#ifndef _rvalue_h_
#define _rvalue_h_

#include "str.h"
#include "ut.h"
#include "usr_avp.h"
#include "select.h"
#include "pvar.h"
#include "route.h"
#include "parser/msg_parser.h"
#include "action.h"

enum rval_type{
        RV_NONE, RV_INT, RV_STR, /* basic types */
        RV_BEXPR, RV_ACTION_ST,  /* special values */
        RV_SEL, RV_AVP, RV_PVAR
};

enum rval_expr_op{
        RVE_NONE_OP,  
        RVE_RVAL_OP,  
        RVE_UMINUS_OP, 
        RVE_BOOL_OP,  
        RVE_LNOT_OP,  
        RVE_BNOT_OP,  
        RVE_MUL_OP,   
        RVE_DIV_OP,   
        RVE_MOD_OP,   
        RVE_MINUS_OP, 
        RVE_BAND_OP,  
        RVE_BOR_OP,   
        RVE_BXOR_OP,   
        RVE_BLSHIFT_OP, 
        RVE_BRSHIFT_OP, 
        RVE_LAND_OP,  
        RVE_LOR_OP,   
        RVE_GT_OP,    
        RVE_GTE_OP,   
        RVE_LT_OP,    
        RVE_LTE_OP,   
        RVE_IEQ_OP,   
        RVE_IDIFF_OP, 
        RVE_IPLUS_OP, 
        /* common int & str */
        RVE_PLUS_OP,  
        RVE_EQ_OP,    
        RVE_DIFF_OP,  
        /* str only */
        RVE_CONCAT_OP, 
        RVE_STRLEN_OP, 
        RVE_STREMPTY_OP, 
        RVE_STREQ_OP,  
        RVE_STRDIFF_OP,
        RVE_MATCH_OP,  
        /* avp, pvars a.s.o */
        RVE_DEFINED_OP, 
        RVE_INT_OP,   
        RVE_STR_OP    
};


struct str_re{
        str s;
        regex_t* regex;
};

union rval_val{
        void* p;
        long  l;
        str s;
        avp_spec_t avps;
        select_t sel;
        pv_spec_t pvs;
        struct action* action;
        struct expr* bexpr;
        struct str_re re;
};


struct rvalue{
        enum rval_type type;
        int refcnt; 
        union rval_val v;
        int bsize; 
        short flags;
        char buf[1]; 
};


/* rvalue flags */
#define RV_CNT_ALLOCED_F  1  
#define RV_RV_ALLOCED_F   2  
#define RV_ALL_ALLOCED_F  (RV_CNT_ALLOCED|RV_RV_ALLOCED)
#define RV_RE_F  4 
#define RV_RE_ALLOCED_F 8 
struct rval_expr{
        enum rval_expr_op op;
        union{
                struct rval_expr* rve;
                struct rvalue rval;
        }left;
        union{
                struct rval_expr* rve;
                struct rvalue rval;
        }right;
        struct cfg_pos fpos;
};


enum rval_cache_type{
        RV_CACHE_EMPTY,
        RV_CACHE_PVAR,
        RV_CACHE_AVP,
        RV_CACHE_SELECT,
        RV_CACHE_INT2STR
};

struct rval_cache{
        enum rval_cache_type cache_type;
        enum rval_type val_type;
        union{
                int_str avp_val; 
                pv_value_t pval; 
        }c;
        char i2s[INT2STR_MAX_LEN]; 
};



struct rvalue* rval_new_empty(int extra_size);
struct rvalue* rval_new_str(str* s, int extra_size);

struct rvalue* rval_new(enum rval_type t, union rval_val* v, int extra_size);

void rval_init(struct rvalue* rv, enum rval_type t, union rval_val* v,
                                        int flags);
void rval_destroy(struct rvalue* rv);

void rval_clean(struct rvalue* rv);

#define rval_cache_init(rvc) \
        do{ (rvc)->cache_type=RV_CACHE_EMPTY; (rvc)->val_type=RV_NONE; }while(0)

void rval_cache_clean(struct rval_cache* rvc);


struct rvalue* rval_convert(struct run_act_ctx* h, struct sip_msg* msg, 
                                                        enum rval_type type, struct rvalue* v,
                                                        struct rval_cache* c);

int rval_get_int(struct run_act_ctx* h, struct sip_msg* msg, int* i, 
                                struct rvalue* rv, struct rval_cache* cache);
int rval_get_str(struct run_act_ctx* h, struct sip_msg* msg,
                                                                str* s, struct rvalue* rv,
                                                                struct rval_cache* cache);
int rval_get_tmp_str(struct run_act_ctx* h, struct sip_msg* msg,
                                                                str* tmpv, struct rvalue* rv,
                                                                struct rval_cache* cache,
                                                                struct rval_cache* tmp_cache);

int rval_expr_eval_int( struct run_act_ctx* h, struct sip_msg* msg,
                                                int* res, struct rval_expr* rve);

struct rvalue* rval_expr_eval(struct run_act_ctx* h, struct sip_msg* msg,
                                                                struct rval_expr* rve);

int rval_expr_eval_rvint( struct run_act_ctx* h, struct sip_msg* msg,
                                                 struct rvalue** rv_res, int* i_res,
                                                 struct rval_expr* rve, struct rval_cache* cache);


enum rval_type rve_guess_type(struct rval_expr* rve);
int rve_is_constant(struct rval_expr* rve);
int rve_has_side_effects(struct rval_expr* rve);

int rve_check_type(enum rval_type* type, struct rval_expr* rve,
                                        struct rval_expr** bad_rve, enum rval_type* bad_type,
                                        enum rval_type* exp_type);
char* rval_type_name(enum rval_type type);

struct rval_expr* mk_rval_expr_v(enum rval_type rv_type, void* val,
                                                                        struct cfg_pos* pos);

struct rval_expr* mk_rval_expr1(enum rval_expr_op op, struct rval_expr* rve1,
                                                                        struct cfg_pos* pos);

struct rval_expr* mk_rval_expr2(enum rval_expr_op op, struct rval_expr* rve1,
                                                                                                          struct rval_expr* rve2,
                                                                                                          struct cfg_pos* pos);
void rve_destroy(struct rval_expr* rve);

int fix_rval_expr(void* p);
#endif /* _rvalue_h */