int
rewrite_session(
struct rewrite_info *info,
const char *rewriteContext,
const char *string,
const void *cookie,
char **result
)
{
struct rewrite_context *context;
struct rewrite_op op = { 0, 0, NULL, NULL, NULL };
int rc;
assert( info != NULL );
assert( rewriteContext != NULL );
assert( string != NULL );
assert( result != NULL );
/*
* cookie can be null; means: don't care about session stuff
*/
*result = NULL;
op.lo_cookie = cookie;
/*
* Engine not on means no failure, but explicit no rewriting
*/
if ( info->li_state != REWRITE_ON ) {
rc = REWRITE_REGEXEC_OK;
goto rc_return;
}
/*
* Undefined context means no rewriting also
* (conservative, are we sure it's what we want?)
*/
context = rewrite_context_find( info, rewriteContext );
if ( context == NULL ) {
switch ( info->li_rewrite_mode ) {
case REWRITE_MODE_ERR:
rc = REWRITE_REGEXEC_ERR;
goto rc_return;
case REWRITE_MODE_OK:
rc = REWRITE_REGEXEC_OK;
goto rc_return;
case REWRITE_MODE_COPY_INPUT:
*result = strdup( string );
rc = ( *result != NULL ) ? REWRITE_REGEXEC_OK : REWRITE_REGEXEC_ERR;
goto rc_return;
case REWRITE_MODE_USE_DEFAULT:
context = rewrite_context_find( info,
REWRITE_DEFAULT_CONTEXT );
break;
}
}
#if 0 /* FIXME: not used anywhere! (debug? then, why strdup?) */
op.lo_string = strdup( string );
if ( op.lo_string == NULL ) {
rc = REWRITE_REGEXEC_ERR;
goto rc_return;
}
#endif
/*
* Applies rewrite context
*/
rc = rewrite_context_apply( info, &op, context, string, result );
assert( op.lo_depth == 0 );
#if 0 /* FIXME: not used anywhere! (debug? then, why strdup?) */
free( op.lo_string );
#endif
switch ( rc ) {
/*
* Success
*/
case REWRITE_REGEXEC_OK:
case REWRITE_REGEXEC_STOP:
/*
* If rewrite succeeded return OK regardless of how
* the successful rewriting was obtained!
*/
rc = REWRITE_REGEXEC_OK;
break;
/*
* Internal or forced error, return = NULL; rc already OK.
*/
case REWRITE_REGEXEC_UNWILLING:
case REWRITE_REGEXEC_ERR:
if ( *result != NULL ) {
if ( *result != string ) {
free( *result );
}
*result = NULL;
}
default:
break;
}
rc_return:;
if ( op.lo_vars ) {
rewrite_var_delete( op.lo_vars );
}
return rc;
}
/*
* 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;
}