/*
* Sets/inserts a var
*/
struct rewrite_var *
rewrite_var_set_f(
Avlnode **tree,
const char *name,
const char *value,
int flags
)
{
struct rewrite_var *var;
assert( tree != NULL );
assert( name != NULL );
assert( value != NULL );
var = rewrite_var_find( *tree, name );
if ( var == NULL ) {
if ( flags & REWRITE_VAR_INSERT ) {
return rewrite_var_insert_f( tree, name, value, flags );
} else {
return NULL;
}
} else {
assert( var->lv_value.bv_val != NULL );
(void)rewrite_var_replace( var, value, flags );
}
return var;
}
/*
* Defines and inits a var with session scope
*/
int
rewrite_session_var_set_f(
struct rewrite_info *info,
const void *cookie,
const char *name,
const char *value,
int flags
)
{
struct rewrite_session *session;
struct rewrite_var *var;
assert( info != NULL );
assert( cookie != NULL );
assert( name != NULL );
assert( value != NULL );
session = rewrite_session_find( info, cookie );
if ( session == NULL ) {
session = rewrite_session_init( info, cookie );
if ( session == NULL ) {
return REWRITE_ERR;
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_mutex_lock( &session->ls_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wlock( &session->ls_vars_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
var = rewrite_var_find( session->ls_vars, name );
if ( var != NULL ) {
assert( var->lv_value.bv_val != NULL );
(void)rewrite_var_replace( var, value, flags );
} else {
var = rewrite_var_insert_f( &session->ls_vars, name, value, flags );
if ( var == NULL ) {
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &session->ls_vars_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
rewrite_session_return( info, session );
return REWRITE_ERR;
}
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &session->ls_vars_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
rewrite_session_return( info, session );
return REWRITE_SUCCESS;
}
/*
* Gets a var with session scope
*/
int
rewrite_session_var_get(
struct rewrite_info *info,
const void *cookie,
const char *name,
struct berval *value
)
{
struct rewrite_session *session;
struct rewrite_var *var;
int rc = REWRITE_SUCCESS;
assert( info != NULL );
assert( cookie != NULL );
assert( name != NULL );
assert( value != NULL );
value->bv_val = NULL;
value->bv_len = 0;
if ( cookie == NULL ) {
return REWRITE_ERR;
}
session = rewrite_session_find( info, cookie );
if ( session == NULL ) {
return REWRITE_ERR;
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_rlock( &session->ls_vars_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
var = rewrite_var_find( session->ls_vars, name );
if ( var != NULL ) {
value->bv_val = strdup( var->lv_value.bv_val );
value->bv_len = var->lv_value.bv_len;
}
if ( var == NULL || value->bv_val == NULL ) {
rc = REWRITE_ERR;
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_runlock( &session->ls_vars_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
rewrite_session_return( info, session );
return rc;
}
/*
* Gets a var with global scope
*/
int
rewrite_param_get(
struct rewrite_info *info,
const char *name,
struct berval *value
)
{
struct rewrite_var *var;
assert( info != NULL );
assert( name != NULL );
assert( value != NULL );
value->bv_val = NULL;
value->bv_len = 0;
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_rlock( &info->li_params_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
var = rewrite_var_find( info->li_params, name );
if ( var == NULL ) {
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_runlock( &info->li_params_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
return REWRITE_ERR;
} else {
value->bv_val = strdup( var->lv_value.bv_val );
value->bv_len = var->lv_value.bv_len;
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_runlock( &info->li_params_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
return REWRITE_SUCCESS;
}
/*
* Defines and inits a variable with global scope
*/
int
rewrite_param_set(
struct rewrite_info *info,
const char *name,
const char *value
)
{
struct rewrite_var *var;
assert( info != NULL );
assert( name != NULL );
assert( value != NULL );
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wlock( &info->li_params_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
var = rewrite_var_find( info->li_params, name );
if ( var != NULL ) {
assert( var->lv_value.bv_val != NULL );
free( var->lv_value.bv_val );
var->lv_value.bv_val = strdup( value );
var->lv_value.bv_len = strlen( value );
} else {
var = rewrite_var_insert( &info->li_params, name, value );
if ( var == NULL ) {
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &info->li_params_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
return REWRITE_ERR;
}
}
#ifdef USE_REWRITE_LDAP_PVT_THREADS
ldap_pvt_thread_rdwr_wunlock( &info->li_params_mutex );
#endif /* USE_REWRITE_LDAP_PVT_THREADS */
return REWRITE_SUCCESS;
}
/*
* Inserts a newly created var
*/
struct rewrite_var *
rewrite_var_insert_f(
Avlnode **tree,
const char *name,
const char *value,
int flags
)
{
struct rewrite_var *var;
int rc = 0;
assert( tree != NULL );
assert( name != NULL );
assert( value != NULL );
var = rewrite_var_find( *tree, name );
if ( var != NULL ) {
if ( flags & REWRITE_VAR_UPDATE ) {
(void)rewrite_var_replace( var, value, flags );
goto cleanup;
}
rc = -1;
goto cleanup;
}
var = calloc( sizeof( struct rewrite_var ), 1 );
if ( var == NULL ) {
return NULL;
}
memset( var, 0, sizeof( struct rewrite_var ) );
if ( flags & REWRITE_VAR_COPY_NAME ) {
var->lv_name = strdup( name );
if ( var->lv_name == NULL ) {
rc = -1;
goto cleanup;
}
var->lv_flags |= REWRITE_VAR_COPY_NAME;
} else {
var->lv_name = (char *)name;
}
if ( flags & REWRITE_VAR_COPY_VALUE ) {
var->lv_value.bv_val = strdup( value );
if ( var->lv_value.bv_val == NULL ) {
rc = -1;
goto cleanup;
}
var->lv_flags |= REWRITE_VAR_COPY_VALUE;
} else {
var->lv_value.bv_val = (char *)value;
}
var->lv_value.bv_len = strlen( value );
rc = avl_insert( tree, ( caddr_t )var,
rewrite_var_cmp, rewrite_var_dup );
cleanup:;
if ( rc != 0 && var ) {
avl_delete( tree, ( caddr_t )var, rewrite_var_cmp );
rewrite_var_free( var );
var = NULL;
}
return var;
}
/*
* Applies the new map type
*/
int
rewrite_map_apply(
struct rewrite_info *info,
struct rewrite_op *op,
struct rewrite_map *map,
struct berval *key,
struct berval *val
)
{
int rc = REWRITE_SUCCESS;
assert( info != NULL );
assert( op != NULL );
assert( map != NULL );
assert( key != NULL );
assert( val != NULL );
val->bv_val = NULL;
val->bv_len = 0;
switch ( map->lm_type ) {
case REWRITE_MAP_SUBCONTEXT:
rc = rewrite_context_apply( info, op,
( struct rewrite_context * )map->lm_data,
key->bv_val, &val->bv_val );
if ( val->bv_val != NULL ) {
if ( val->bv_val == key->bv_val ) {
val->bv_len = key->bv_len;
key->bv_val = NULL;
} else {
val->bv_len = strlen( val->bv_val );
}
}
break;
case REWRITE_MAP_SET_OP_VAR:
case REWRITE_MAP_SETW_OP_VAR:
rc = rewrite_var_set( &op->lo_vars, map->lm_name,
key->bv_val, 1 )
? REWRITE_SUCCESS : REWRITE_ERR;
if ( rc == REWRITE_SUCCESS ) {
if ( map->lm_type == REWRITE_MAP_SET_OP_VAR ) {
val->bv_val = strdup( "" );
} else {
val->bv_val = strdup( key->bv_val );
val->bv_len = key->bv_len;
}
if ( val->bv_val == NULL ) {
rc = REWRITE_ERR;
}
}
break;
case REWRITE_MAP_GET_OP_VAR: {
struct rewrite_var *var;
var = rewrite_var_find( op->lo_vars, map->lm_name );
if ( var == NULL ) {
rc = REWRITE_ERR;
} else {
val->bv_val = strdup( var->lv_value.bv_val );
val->bv_len = var->lv_value.bv_len;
if ( val->bv_val == NULL ) {
rc = REWRITE_ERR;
}
}
break;
}
case REWRITE_MAP_SET_SESN_VAR:
case REWRITE_MAP_SETW_SESN_VAR:
if ( op->lo_cookie == NULL ) {
rc = REWRITE_ERR;
break;
}
rc = rewrite_session_var_set( info, op->lo_cookie,
map->lm_name, key->bv_val );
if ( rc == REWRITE_SUCCESS ) {
if ( map->lm_type == REWRITE_MAP_SET_SESN_VAR ) {
val->bv_val = strdup( "" );
} else {
val->bv_val = strdup( key->bv_val );
val->bv_len = key->bv_len;
}
if ( val->bv_val == NULL ) {
rc = REWRITE_ERR;
}
}
break;
case REWRITE_MAP_GET_SESN_VAR:
rc = rewrite_session_var_get( info, op->lo_cookie,
map->lm_name, val );
break;
case REWRITE_MAP_GET_PARAM:
rc = rewrite_param_get( info, map->lm_name, val );
break;
case REWRITE_MAP_BUILTIN: {
struct rewrite_builtin_map *bmap = map->lm_data;
if ( bmap->lb_mapper && bmap->lb_mapper->rm_apply )
rc = bmap->lb_mapper->rm_apply( bmap->lb_private, key->bv_val,
val );
else
rc = REWRITE_ERR;
break;
break;
}
default:
rc = REWRITE_ERR;
break;
}
return rc;
}
