git.sur5r.net Git - openldap/blob - libraries/librewrite/info.c

   1 /******************************************************************************
   2  *
   3  * Copyright (C) 2000 Pierangelo Masarati, <ando@sys-net.it>
   4  * All rights reserved.
   5  *
   6  * Permission is granted to anyone to use this software for any purpose
   7  * on any computer system, and to alter it and redistribute it, subject
   8  * to the following restrictions:
   9  *
  10  * 1. The author is not responsible for the consequences of use of this
  11  * software, no matter how awful, even if they arise from flaws in it.
  12  *
  13  * 2. The origin of this software must not be misrepresented, either by
  14  * explicit claim or by omission.  Since few users ever read sources,
  15  * credits should appear in the documentation.
  16  *
  17  * 3. Altered versions must be plainly marked as such, and must not be
  18  * misrepresented as being the original software.  Since few users
  19  * ever read sources, credits should appear in the documentation.
  20  *
  21  * 4. This notice may not be removed or altered.
  22  *
  23  ******************************************************************************/
  24
  25 #include <portable.h>
  26
  27 #include "rewrite-int.h"
  28
  29 /*
  30  * Global data
  31  */
  32
  33 /*
  34  * This becomes the running context for subsequent calls to
  35  * rewrite_parse; it can be altered only by a
  36  * rewriteContext config line or by a change in info.
  37  */
  38 struct rewrite_context *__curr_context = NULL;
  39
  40 /*
  41  * Inits the info
  42  */
  43 struct rewrite_info *
  44 rewrite_info_init(
  45                 int mode
  46 )
  47 {
  48         struct rewrite_info *info;
  49         struct rewrite_context *context;
  50
  51         switch ( mode ) {
  52         case REWRITE_MODE_ERR:
  53         case REWRITE_MODE_OK:
  54         case REWRITE_MODE_COPY_INPUT:
  55         case REWRITE_MODE_USE_DEFAULT:
  56                 break;
  57         default:
  58                 mode = REWRITE_MODE_USE_DEFAULT;
  59                 break;
  60                 /* return NULL */
  61         }
  62
  63         /*
  64          * Resets the running context for parsing ...
  65          */
  66         __curr_context = NULL;
  67
  68         info = calloc( sizeof( struct rewrite_info ), 1 );
  69         if ( info == NULL ) {
  70                 return NULL;
  71         }
  72
  73         info->li_state = REWRITE_DEFAULT;
  74         info->li_max_passes = REWRITE_MAX_PASSES;
  75         info->li_rewrite_mode = mode;
  76
  77         /*
  78          * Add the default (empty) rule
  79          */
  80         context = rewrite_context_create( info, REWRITE_DEFAULT_CONTEXT );
  81         if ( context == NULL ) {
  82                 free( info );
  83                 return NULL;
  84         }
  85
  86 #ifdef USE_REWRITE_LDAP_PVT_THREADS
  87         if ( ldap_pvt_thread_rdwr_init( &info->li_cookies_mutex ) ) {
  88                 free( info );
  89                 return NULL;
  90         }
  91         if ( ldap_pvt_thread_rdwr_init( &info->li_params_mutex ) ) {
  92                 free( info );
  93                 return NULL;
  94         }
  95 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
  96
  97         return info;
  98 }
  99
 100 /*
 101  * Cleans up the info structure
 102  */
 103 int
 104 rewrite_info_delete(
 105                 struct rewrite_info *info
 106 )
 107 {
 108         assert( info != NULL );
 109
 110         rewrite_session_destroy( info );
 111
 112         rewrite_param_destroy( info );
 113
 114 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 115         ldap_pvt_thread_rdwr_destroy( &info->li_cookies_mutex );
 116         ldap_pvt_thread_rdwr_destroy( &info->li_params_mutex );
 117 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 118
 119         return REWRITE_SUCCESS;
 120 }
 121
 122 /*
 123  * Rewrites a string according to context.
 124  * If the engine is off, OK is returned, but the return string will be NULL.
 125  * In case of 'unwilling to perform', UNWILLING is returned, and the
 126  * return string will also be null. The same in case of error.
 127  * Otherwise, OK is returned, and result will hold a newly allocated string
 128  * with the rewriting.
 129  *
 130  * What to do in case of non-existing rewrite context is still an issue.
 131  * Four possibilities:
 132  *      - error,
 133  *      - ok with NULL result,
 134  *      - ok with copy of string as result,
 135  *      - use the default rewrite context.
 136  */
 137 int
 138 rewrite(
 139                 struct rewrite_info *info,
 140                 const char *rewriteContext,
 141                 const char *string,
 142                 char **result
 143 )
 144 {
 145         return rewrite_session( info, rewriteContext,
 146                         string, NULL, result );
 147 }
 148
 149 int
 150 rewrite_session(
 151                 struct rewrite_info *info,
 152                 const char *rewriteContext,
 153                 const char *string,
 154                 const void *cookie,
 155                 char **result
 156 )
 157 {
 158         struct rewrite_context *context;
 159         struct rewrite_op op = { 0, 0, NULL, NULL, NULL, NULL };
 160         int rc;
 161
 162         assert( info != NULL );
 163         assert( rewriteContext != NULL );
 164         assert( string != NULL );
 165         assert( result != NULL );
 166
 167         /*
 168          * cookie can be null; means: don't care about session stuff
 169          */
 170
 171         *result = NULL;
 172         op.lo_cookie = cookie;
 173
 174         /*
 175          * Engine not on means no failure, but explicit no rewriting
 176          */
 177         if ( info->li_state != REWRITE_ON ) {
 178                 rc = REWRITE_REGEXEC_OK;
 179                 goto rc_return;
 180         }
 181
 182         /*
 183          * Undefined context means no rewriting also
 184          * (conservative, are we sure it's what we want?)
 185          */
 186         context = rewrite_context_find( info, rewriteContext );
 187         if ( context == NULL ) {
 188                 switch ( info->li_rewrite_mode ) {
 189                 case REWRITE_MODE_ERR:
 190                         rc = REWRITE_REGEXEC_ERR;
 191                         goto rc_return;
 192                 case REWRITE_MODE_OK:
 193                         rc = REWRITE_REGEXEC_OK;
 194                         goto rc_return;
 195                 case REWRITE_MODE_COPY_INPUT:
 196                         *result = strdup( string );
 197                         rc = REWRITE_REGEXEC_OK;
 198                         goto rc_return;
 199                 case REWRITE_MODE_USE_DEFAULT:
 200                         context = rewrite_context_find( info,
 201                                         REWRITE_DEFAULT_CONTEXT );
 202                         break;
 203                 }
 204         }
 205
 206         op.lo_string = strdup( string );
 207         if ( op.lo_string == NULL ) {
 208                 rc = REWRITE_REGEXEC_ERR;
 209                 goto rc_return;
 210         }
 211
 212         /*
 213          * Applies rewrite context
 214          */
 215         rc = rewrite_context_apply(info, &op, context, string, result );
 216         assert( op.lo_depth == 0 );
 217
 218         /* ?!? */
 219         free( op.lo_string );
 220
 221         switch ( rc ) {
 222         /*
 223          * Success
 224          */
 225         case REWRITE_REGEXEC_OK:
 226         case REWRITE_REGEXEC_STOP:
 227                 /*
 228                  * If rewrite succeeded return OK regardless of how
 229                  * the successful rewriting was obtained!
 230                  */
 231                 rc = REWRITE_REGEXEC_OK;
 232                 break;
 233
 234
 235         /*
 236          * Internal or forced error, return = NULL; rc already OK.
 237          */
 238         case REWRITE_REGEXEC_UNWILLING:
 239         case REWRITE_REGEXEC_ERR:
 240         default:
 241                 if ( *result != NULL ) {
 242                         free( *result );
 243                         *result = NULL;
 244                 }
 245         }
 246
 247 rc_return:;
 248         if ( op.lo_vars ) {
 249                 rewrite_var_delete( op.lo_vars );
 250         }
 251
 252         return rc;
 253 }
 254