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; }