void set_mail_type (const void *stuff)
{
const char * value;
struct mail_checker *new_checker;
char old_mailval[16];
value = (const char *)stuff;
if (value == NULL)
new_checker = NULL;
else if (!my_stricmp(value, "MBOX"))
new_checker = &mail_types[0];
else if (!my_stricmp(value, "MAILDIR"))
new_checker = &mail_types[1];
else
{
say("/SET MAIL_TYPE must be MBOX or MAILDIR.");
return;
}
snprintf(old_mailval, sizeof(old_mailval), "%d", get_int_var(MAIL_VAR));
set_var_value(MAIL_VAR, zero);
checkmail = new_checker;
set_var_value(MAIL_VAR, old_mailval);
}
void CMemory::StoreValue(const char * pquery, CEvalInfoFunction **logCallingFunction, int *e)
{
int i = 0, index = 0;
char var[512] = {0}, value[512] = {0};
double result = 0.;
CGrammar gram;
strcpy_s(var, 512, &pquery[6]);
if (strstr(var, "_")!=NULL)
var[strstr(var, "_")-var]='\0';
strcpy_s(value, 512, &pquery[6+strlen(var)+1]);
// see if we already have this variable name
index=_var_count+1;
for (i=0; i<=_var_count; i++)
{
if (strlen(var)==strlen(_var_name[i]) && memcmp(var, _var_name[i], strlen(var))==0)
{
index=i;
}
}
// if we didn't find the var, put it in a new slot
if (index==_var_count+1)
set_var_count(_var_count+1);
//store the value
if (memcmp(value,"f$",2)==0)
{
*e = SUCCESS;
result = gram.DoCalcF$symbol(p_formula, value, logCallingFunction, logCallingFunction!=NULL, e);
if (*e==SUCCESS)
{
set_var_value(index, result);
set_var_name(index, var);
}
else
{
*e = ERR_INVALID_EXPR;
}
}
else
{
if (strstr(value, "_")!=NULL)
value[strstr(value, "_")-value]='.';
set_var_value(index, atof(value));
set_var_name(index, var);
}
}
void
toggle_var(WebKitWebView *page, GArray *argv, GString *result) {
(void) page; (void) result;
if(!argv_idx(argv, 0))
return;
const gchar *var_name = argv_idx(argv, 0);
uzbl_cmdprop *c = get_var_c(var_name);
if(!c) {
if (argv->len > 1) {
set_var_value(var_name, argv_idx(argv, 1));
} else {
set_var_value(var_name, "1");
}
return;
}
switch(c->type) {
case TYPE_STR:
{
const gchar *next;
if(argv->len >= 3) {
gchar *current = get_var_value_string_c(c);
guint i = 2;
const gchar *first = argv_idx(argv, 1);
const gchar *this = first;
next = argv_idx(argv, 2);
while(next && strcmp(current, this)) {
this = next;
next = argv_idx(argv, ++i);
}
if(!next)
next = first;
g_free(current);
} else
next = "";
set_var_value_string_c(c, next);
break;
}
int pv_xavp_to_var_helper(sr_xavp_t *avp) {
script_var_t *it;
int_str value;
int flags = 0;
it = add_var(&avp->name, VAR_TYPE_ZERO);
if(!it) return -1;
if(avp->val.type==SR_XTYPE_STR){
flags |= VAR_VAL_STR;
value.s.len = avp->val.v.s.len;
value.s.s = avp->val.v.s.s;
LM_DBG("var:[%.*s] STR:[%.*s]\n", avp->name.len, avp->name.s,
value.s.len, value.s.s);
}
else if(avp->val.type==SR_XTYPE_INT) {
flags |= VAR_VAL_INT;
value.n = avp->val.v.i;
LM_DBG("var:[%.*s] INT:[%d]\n", avp->name.len, avp->name.s,
value.n);
} else {
LM_ERR("avp type not STR nor INT\n");
return -1;
}
set_var_value(it, &value, flags);
return 0;
}
static int w_get_profile_size(struct sip_msg *msg, char *profile,
char *value, char *result)
{
pv_elem_t *pve;
str val_s;
pv_spec_t *sp_dest;
unsigned int size;
int_str res;
int avp_name;
unsigned short avp_type;
script_var_t * sc_var;
pve = (pv_elem_t *)value;
sp_dest = (pv_spec_t *)result;
if ( pve!=NULL && ((struct dlg_profile_table*)profile)->has_value) {
if ( pv_printf_s(msg, pve, &val_s)!=0 ||
val_s.len == 0 || val_s.s == NULL) {
LM_WARN("cannot get string for value\n");
return -1;
}
size = get_profile_size( (struct dlg_profile_table*)profile ,&val_s );
} else {
size = get_profile_size( (struct dlg_profile_table*)profile, NULL );
}
switch (sp_dest->type) {
case PVT_AVP:
if (pv_get_avp_name( msg, &(sp_dest->pvp), &avp_name,
&avp_type)!=0){
LM_CRIT("BUG in getting AVP name\n");
return -1;
}
res.n = size;
if (add_avp(avp_type, avp_name, res)<0){
LM_ERR("cannot add AVP\n");
return -1;
}
break;
case PVT_SCRIPTVAR:
if(sp_dest->pvp.pvn.u.dname == 0){
LM_ERR("cannot find svar name\n");
return -1;
}
res.n = size;
sc_var = (script_var_t *)sp_dest->pvp.pvn.u.dname;
if(!set_var_value(sc_var, &res, 0)){
LM_ERR("cannot set svar\n");
return -1;
}
break;
default:
LM_CRIT("BUG: invalid pvar type\n");
return -1;
}
return 1;
}
int param_set_xvar( modparam_t type, void* val, int mode)
{
str s;
char *p;
int_str isv;
int flags;
int ival;
script_var_t *sv;
if(shvar_initialized!=0)
goto error;
s.s = (char*)val;
if(s.s == NULL || s.s[0] == '\0')
goto error;
p = s.s;
while(*p && *p!='=') p++;
if(*p!='=')
goto error;
s.len = p - s.s;
if(s.len == 0)
goto error;
p++;
flags = 0;
if(*p!='s' && *p!='S' && *p!='i' && *p!='I')
goto error;
if(*p=='s' || *p=='S')
flags = VAR_VAL_STR;
p++;
if(*p!=':')
goto error;
p++;
isv.s.s = p;
isv.s.len = strlen(p);
if(flags != VAR_VAL_STR) {
if(str2sint(&isv.s, &ival)<0)
goto error;
isv.n = ival;
}
if(mode==0)
sv = add_var(&s);
else
sv = add_local_shvar(&s);
if(sv==NULL)
goto error;
if(set_var_value(sv, &isv, flags)==NULL)
goto error;
return 0;
error:
LM_ERR("unable to set %s parameter [%s]\n",
(mode == 0 ? "var" : "shv"), s.s);
return -1;
}
int w_fetch_dlg_value(struct sip_msg *msg, char *name, char *result)
{
struct dlg_cell *dlg;
str val;
pv_spec_t *sp_dest;
int_str res;
int avp_name;
unsigned short avp_type;
script_var_t * sc_var;
sp_dest = (pv_spec_t *)result;
if ( (dlg=get_current_dialog())==NULL )
return -1;
if (fetch_dlg_value( dlg, (str*)name, &val, 0) ) {
LM_DBG("failed to fetch dialog value <%.*s>\n",
((str*)name)->len, ((str*)name)->s);
return -1;
}
switch (sp_dest->type) {
case PVT_AVP:
if (pv_get_avp_name( msg, &(sp_dest->pvp), &avp_name,
&avp_type)!=0){
LM_CRIT("BUG in getting AVP name\n");
return -1;
}
res.s = val;
if (add_avp(avp_type|AVP_VAL_STR, avp_name, res)<0){
LM_ERR("cannot add AVP\n");
return -1;
}
break;
case PVT_SCRIPTVAR:
if(sp_dest->pvp.pvn.u.dname == 0){
LM_ERR("cannot find svar name\n");
return -1;
}
res.s = val;
sc_var = (script_var_t *)sp_dest->pvp.pvn.u.dname;
if(!set_var_value(sc_var, &res, VAR_VAL_STR)){
LM_ERR("cannot set svar\n");
return -1;
}
break;
default:
LM_CRIT("BUG: invalid pvar type\n");
return -1;
}
return 1;
}
void
set_var(WebKitWebView *page, GArray *argv, GString *result) {
(void) page; (void) result;
if(!argv_idx(argv, 0))
return;
gchar **split = g_strsplit(argv_idx(argv, 0), "=", 2);
if (split[0] != NULL) {
gchar *value = split[1] ? g_strchug(split[1]) : " ";
set_var_value(g_strstrip(split[0]), value);
}
g_strfreev(split);
}
void
test_keycmd (void) {
add_binding("insert", "set insert_mode = 1");
add_binding("command", "set insert_mode = 0");
/* the 'keycmd' command */
parse_command("keycmd", "insert", NULL);
g_assert_cmpint(1, ==, reuzbl.behave.insert_mode);
g_assert_cmpstr("", ==, reuzbl.state.keycmd);
/* setting the keycmd variable directly, equivalent to the 'keycmd' comand */
set_var_value("keycmd", "command");
g_assert_cmpint(0, ==, reuzbl.behave.insert_mode);
g_assert_cmpstr("", ==, reuzbl.state.keycmd);
}
static int l_siplua_scriptVarSet(lua_State *L)
{
const char *name;
str s;
int_str val;
int flags = 0;
script_var_t *it;
name = luaL_checkstring(L, 1);
if (*name == '$')
++name;
s.s = (char *)name;
s.len = strlen(name);
switch (lua_type(L, 2))
{
case LUA_TNIL: /* no way currently exists to drop a script variable */
/* well, set_var_value(it, NULL, 0) API exists but won't do anything useful */
val.n = 0;
break;
case LUA_TNUMBER:
val.n = luaL_checkinteger(L, 2);
break;
case LUA_TSTRING:
flags = VAR_VAL_STR;
val.s.s = (char *)luaL_checkstring(L, 2);
val.s.len = strlen(val.s.s);
break;
default:
return luaL_error(L, "scriptVarSet %s type value not supported",
lua_typename(L, lua_type(L, 2)));
}
it = get_var_by_name(&s);
if (!it)
it = add_var(&s);
if (!it)
return luaL_error(L, "add_var of script variable `%s' failed", name);
if (set_var_value(it, &val, flags))
lua_pushboolean(L, 1);
else
lua_pushboolean(L, 0);
return 1;
}
/**
* Set result pvs
*/
int set_result_pv(struct sip_msg* _msg, unsigned short _avp_type, int_str _avp_val, char* _res_avp)
{
pv_spec_t* _avp = (pv_spec_t*) _res_avp;
int avp_name;
unsigned short avp_type;
switch (_avp->type) {
case PVT_AVP:
if (pv_get_avp_name(_msg, &(_avp->pvp), &avp_name, &avp_type) != 0) {
LM_CRIT("BUG in getting AVP name");
return -1;
}
avp_type |= _avp_type;
if (add_avp(avp_type, avp_name, _avp_val) < 0) {
LM_ERR("cannot add AVP");
return -1;
}
break;
case PVT_SCRIPTVAR:
if(_avp->pvp.pvn.u.dname == 0){
LM_ERR("cannot find svar name");
return -1;
}
if (!set_var_value((script_var_t*) _avp->pvp.pvn.u.dname, &_avp_val, VAR_VAL_STR)) {
LM_ERR("cannot set svar");
return -1;
}
break;
default:
LM_CRIT("BUG: invalid pvar type");
return -1;
}
return OK;
}
int param_set_xvar( modparam_t type, void* val, int mode)
{
str s;
char *p;
int_str isv;
int flags;
int ival;
script_var_t *pkv;
sh_var_t *shv;
if(!shm_initialized())
{
LM_ERR("shm not initialized - cannot set value for PVs\n");
return -1;
}
s.s = (char*)val;
if(s.s == NULL || s.s[0] == '\0')
goto error;
p = s.s;
while(*p && *p!='=') p++;
if(*p!='=')
goto error;
s.len = p - s.s;
if(s.len == 0)
goto error;
p++;
flags = 0;
if(*p!='s' && *p!='S' && *p!='i' && *p!='I')
goto error;
if(*p=='s' || *p=='S')
flags = VAR_VAL_STR;
p++;
if(*p!=':')
goto error;
p++;
isv.s.s = p;
isv.s.len = strlen(p);
if(flags != VAR_VAL_STR) {
if(str2sint(&isv.s, &ival)<0)
goto error;
isv.n = ival;
}
if(mode==0) {
pkv = add_var(&s, VAR_TYPE_ZERO);
if(pkv==NULL)
goto error;
if(set_var_value(pkv, &isv, flags)==NULL)
goto error;
} else {
shv = add_shvar(&s);
if(shv==NULL)
goto error;
if(set_shvar_value(shv, &isv, flags)==NULL)
goto error;
}
return 0;
error:
LM_ERR("unable to set shv parame [%s]\n", s.s);
return -1;
}
cons_t eval(cons_t *c, var_t *local_vars){
cons_t p;
switch(c->type){
case TYPE_OPERATE:{
int (*func)(int x, int y) = c->v.func;
int n;
if(c->cdr == NULL){
printf("operate error\n");
return p;
}
n = eval(c->cdr, local_vars).v.i;
c = c->cdr->cdr;
while(c != NULL){
p = eval(c, local_vars);
n = func(n, p.v.i);
c = c->cdr;
}
p.type = TYPE_INT;
p.v.i = n;
return p;
}
case TYPE_COMPARE:{
int (*func)(int x, int y) = c->v.func;
if(c->cdr == NULL || c->cdr->cdr == NULL){
printf("compare error\n");
return p;
}
int n1 = eval(c->cdr, local_vars).v.i;
int n2 = eval(c->cdr->cdr, local_vars).v.i;
p.type = func(n1, n2);
return p;
}
case TYPE_IF:
p = eval(c->cdr, local_vars);
if(p.type != TYPE_NIL){
return eval(c->cdr->cdr, local_vars);
}else{
return eval(c->cdr->cdr->cdr, local_vars);
}
case TYPE_SETQ:
c = c->cdr;
if(c->type == TYPE_STR){
p = eval(c->cdr, local_vars);
if(p.type == TYPE_INT){
const char *name = c->v.str;
int value = p.v.i;
global_vars = set_var_value(global_vars, name, value);
return p;
}else{
printf("setq error 1");
}
}else{
printf("setq error 2");
}
break;
case TYPE_DEFUN:
c = c->cdr;
funcs = set_func(funcs, c->v.str, c->cdr->v.car, c->cdr->cdr->v.car);
p.type = TYPE_DEFUN;
return p;
case TYPE_STR:{
func_t *f = get_func(funcs, c->v.str);
if(f != NULL){
// function?
cons_t *args = f->args;
var_t *locals = NULL;
c = c->cdr;
while(args != NULL){
if(c == NULL){
printf("func argument error\n");
return p;
}
cons_t p = eval(c, local_vars);
locals = set_var_value(locals, args->v.str, p.v.i);
args = args->cdr;
c = c->cdr;
}
p = eval(f->car, locals);
free_vars(locals);
}else{
var_t *v;
// local variable?
v = get_var_value(local_vars, c->v.str);
if(v == NULL){
// global variable?
v = get_var_value(global_vars, c->v.str);
}
if(v == NULL){
printf("var get error\n");
return p;
}
p.type = TYPE_INT;
p.v.i = v->value;
}
break;
}
case TYPE_INT:
return *c;
case TYPE_CAR:
return eval(c->v.car, local_vars);
default:
printf("error type %d\n", c->type);
}
return p;
}
