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

   1 /* $OpenLDAP$ */
   2 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   3  *
   4  * Copyright 2000-2004 The OpenLDAP Foundation.
   5  * All rights reserved.
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted only as authorized by the OpenLDAP
   9  * Public License.
  10  *
  11  * A copy of this license is available in the file LICENSE in the
  12  * top-level directory of the distribution or, alternatively, at
  13  * <http://www.OpenLDAP.org/license.html>.
  14  */
  15 /* ACKNOWLEDGEMENT:
  16  * This work was initially developed by Pierangelo Masarati for
  17  * inclusion in OpenLDAP Software.
  18  */
  19
  20 #include <portable.h>
  21
  22 #include "rewrite-int.h"
  23
  24 /*
  25  * Compares two cookies
  26  */
  27 static int
  28 rewrite_cookie_cmp(
  29                 const void *c1,
  30                 const void *c2
  31 )
  32 {
  33         const struct rewrite_session *s1, *s2;
  34
  35         s1 = ( const struct rewrite_session * )c1;
  36         s2 = ( const struct rewrite_session * )c2;
  37
  38         assert( s1 != NULL );
  39         assert( s2 != NULL );
  40         assert( s1->ls_cookie != NULL );
  41         assert( s2->ls_cookie != NULL );
  42
  43         return ( ( s1->ls_cookie < s2->ls_cookie ) ? -1 :
  44                         ( ( s1->ls_cookie > s2->ls_cookie ) ? 1 : 0 ) );
  45 }
  46
  47 /*
  48  * Duplicate cookies?
  49  */
  50 static int
  51 rewrite_cookie_dup(
  52                 void *c1,
  53                 void *c2
  54 )
  55 {
  56         struct rewrite_session *s1, *s2;
  57
  58         s1 = ( struct rewrite_session * )c1;
  59         s2 = ( struct rewrite_session * )c2;
  60
  61         assert( s1 != NULL );
  62         assert( s2 != NULL );
  63         assert( s1->ls_cookie != NULL );
  64         assert( s2->ls_cookie != NULL );
  65
  66         assert( s1->ls_cookie != s2->ls_cookie );
  67
  68         return ( ( s1->ls_cookie == s2->ls_cookie ) ? -1 : 0 );
  69 }
  70
  71 /*
  72  * Inits a session
  73  */
  74 struct rewrite_session *
  75 rewrite_session_init(
  76                 struct rewrite_info *info,
  77                 const void *cookie
  78 )
  79 {
  80         struct rewrite_session  *session, tmp;
  81         int                     rc;
  82
  83         assert( info != NULL );
  84         assert( cookie != NULL );
  85
  86 #ifdef USE_REWRITE_LDAP_PVT_THREADS
  87         ldap_pvt_thread_rdwr_wlock( &info->li_cookies_mutex );
  88 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
  89
  90         tmp.ls_cookie = ( void * )cookie;
  91         session = ( struct rewrite_session * )avl_find( info->li_cookies,
  92                         ( caddr_t )&tmp, rewrite_cookie_cmp );
  93         if ( session ) {
  94                 session->ls_count++;
  95 #ifdef USE_REWRITE_LDAP_PVT_THREADS
  96                 ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
  97 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
  98                 return session;
  99         }
 100
 101         session = calloc( sizeof( struct rewrite_session ), 1 );
 102         if ( session == NULL ) {
 103                 return NULL;
 104         }
 105         session->ls_cookie = ( void * )cookie;
 106         session->ls_count = 1;
 107
 108 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 109         if ( ldap_pvt_thread_mutex_init( &session->ls_mutex ) ) {
 110                 free( session );
 111                 return NULL;
 112         }
 113         if ( ldap_pvt_thread_rdwr_init( &session->ls_vars_mutex ) ) {
 114                 ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
 115                 free( session );
 116                 return NULL;
 117         }
 118 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 119
 120         rc = avl_insert( &info->li_cookies, ( caddr_t )session,
 121                         rewrite_cookie_cmp, rewrite_cookie_dup );
 122         info->li_num_cookies++;
 123
 124 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 125         ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
 126 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 127
 128         if ( rc != 0 ) {
 129 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 130                 ldap_pvt_thread_rdwr_destroy( &session->ls_vars_mutex );
 131                 ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
 132 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 133
 134                 free( session );
 135                 return NULL;
 136         }
 137
 138         return session;
 139 }
 140
 141 /*
 142  * Fetches a session
 143  */
 144 struct rewrite_session *
 145 rewrite_session_find(
 146                 struct rewrite_info *info,
 147                 const void *cookie
 148 )
 149 {
 150         struct rewrite_session *session, tmp;
 151
 152         assert( info != NULL );
 153         assert( cookie != NULL );
 154
 155         tmp.ls_cookie = ( void * )cookie;
 156 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 157         ldap_pvt_thread_rdwr_rlock( &info->li_cookies_mutex );
 158 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 159         session = ( struct rewrite_session * )avl_find( info->li_cookies,
 160                         ( caddr_t )&tmp, rewrite_cookie_cmp );
 161 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 162         if ( session ) {
 163                 ldap_pvt_thread_mutex_lock( &session->ls_mutex );
 164         }
 165         ldap_pvt_thread_rdwr_runlock( &info->li_cookies_mutex );
 166 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 167
 168         return session;
 169 }
 170
 171 /*
 172  * Returns a session
 173  */
 174 void
 175 rewrite_session_return(
 176                 struct rewrite_info *info,
 177                 struct rewrite_session *session
 178 )
 179 {
 180         assert( session );
 181         ldap_pvt_thread_mutex_unlock( &session->ls_mutex );
 182 }
 183
 184 /*
 185  * Defines and inits a var with session scope
 186  */
 187 int
 188 rewrite_session_var_set_f(
 189                 struct rewrite_info *info,
 190                 const void *cookie,
 191                 const char *name,
 192                 const char *value,
 193                 int flags
 194 )
 195 {
 196         struct rewrite_session *session;
 197         struct rewrite_var *var;
 198
 199         assert( info != NULL );
 200         assert( cookie != NULL );
 201         assert( name != NULL );
 202         assert( value != NULL );
 203
 204         session = rewrite_session_find( info, cookie );
 205         if ( session == NULL ) {
 206                 session = rewrite_session_init( info, cookie );
 207         }
 208
 209 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 210         ldap_pvt_thread_rdwr_wlock( &session->ls_vars_mutex );
 211 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 212
 213         var = rewrite_var_find( session->ls_vars, name );
 214         if ( var != NULL ) {
 215                 assert( var->lv_value.bv_val != NULL );
 216
 217                 (void)rewrite_var_replace( var, value, flags );
 218
 219         } else {
 220                 var = rewrite_var_insert_f( &session->ls_vars, name, value, flags );
 221                 if ( var == NULL ) {
 222 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 223                         ldap_pvt_thread_rdwr_wunlock( &session->ls_vars_mutex );
 224 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 225                         rewrite_session_return( info, session );
 226                         return REWRITE_ERR;
 227                 }
 228         }
 229
 230 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 231         ldap_pvt_thread_rdwr_wunlock( &session->ls_vars_mutex );
 232 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 233
 234         rewrite_session_return( info, session );
 235
 236         return REWRITE_SUCCESS;
 237 }
 238
 239 /*
 240  * Gets a var with session scope
 241  */
 242 int
 243 rewrite_session_var_get(
 244                 struct rewrite_info *info,
 245                 const void *cookie,
 246                 const char *name,
 247                 struct berval *value
 248 )
 249 {
 250         struct rewrite_session *session;
 251         struct rewrite_var *var;
 252
 253         assert( info != NULL );
 254         assert( cookie != NULL );
 255         assert( name != NULL );
 256         assert( value != NULL );
 257
 258         value->bv_val = NULL;
 259         value->bv_len = 0;
 260
 261         if ( cookie == NULL ) {
 262                 return REWRITE_ERR;
 263         }
 264
 265         session = rewrite_session_find( info, cookie );
 266         if ( session == NULL ) {
 267                 return REWRITE_ERR;
 268         }
 269
 270 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 271         ldap_pvt_thread_rdwr_rlock( &session->ls_vars_mutex );
 272 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 273
 274         var = rewrite_var_find( session->ls_vars, name );
 275         if ( var == NULL ) {
 276
 277 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 278                 ldap_pvt_thread_rdwr_runlock( &session->ls_vars_mutex );
 279 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 280
 281                 rewrite_session_return( info, session );
 282
 283                 return REWRITE_ERR;
 284         } else {
 285                 value->bv_val = strdup( var->lv_value.bv_val );
 286                 value->bv_len = var->lv_value.bv_len;
 287         }
 288
 289 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 290         ldap_pvt_thread_rdwr_runlock( &session->ls_vars_mutex );
 291 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 292
 293         rewrite_session_return( info, session );
 294
 295         return REWRITE_SUCCESS;
 296 }
 297
 298 /*
 299  * Deletes a session
 300  */
 301 int
 302 rewrite_session_delete(
 303                 struct rewrite_info *info,
 304                 const void *cookie
 305 )
 306 {
 307         struct rewrite_session *session, tmp;
 308
 309         assert( info != NULL );
 310         assert( cookie != NULL );
 311
 312         tmp.ls_cookie = ( void * )cookie;
 313
 314         session = rewrite_session_find( info, cookie );
 315
 316         if ( session == NULL ) {
 317                 return REWRITE_SUCCESS;
 318         }
 319
 320         if ( --session->ls_count > 0 ) {
 321                 rewrite_session_return( info, session );
 322                 return REWRITE_SUCCESS;
 323         }
 324
 325 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 326         ldap_pvt_thread_rdwr_wlock( &session->ls_vars_mutex );
 327 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 328
 329         rewrite_var_delete( session->ls_vars );
 330
 331 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 332         ldap_pvt_thread_rdwr_wunlock( &session->ls_vars_mutex );
 333         ldap_pvt_thread_rdwr_destroy( &session->ls_vars_mutex );
 334         ldap_pvt_thread_mutex_unlock( &session->ls_mutex );
 335         ldap_pvt_thread_mutex_destroy( &session->ls_mutex );
 336 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 337
 338 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 339         ldap_pvt_thread_rdwr_wlock( &info->li_cookies_mutex );
 340 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 341
 342         assert( info->li_num_cookies > 0 );
 343         info->li_num_cookies--;
 344
 345         /*
 346          * There is nothing to delete in the return value
 347          */
 348         avl_delete( &info->li_cookies, ( caddr_t )&tmp, rewrite_cookie_cmp );
 349         free( session );
 350
 351 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 352         ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
 353 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 354
 355         return REWRITE_SUCCESS;
 356 }
 357
 358 /*
 359  * Destroys the cookie tree
 360  */
 361 int
 362 rewrite_session_destroy(
 363                 struct rewrite_info *info
 364 )
 365 {
 366         int count;
 367
 368         assert( info != NULL );
 369
 370 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 371         ldap_pvt_thread_rdwr_wlock( &info->li_cookies_mutex );
 372 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 373
 374         /*
 375          * Should call per-session destruction routine ...
 376          */
 377
 378         count = avl_free( info->li_cookies, NULL );
 379         info->li_cookies = NULL;
 380
 381 #if 0
 382         fprintf( stderr, "count = %d; num_cookies = %d\n",
 383                         count, info->li_num_cookies );
 384 #endif
 385
 386         assert( count == info->li_num_cookies );
 387         info->li_num_cookies = 0;
 388
 389 #ifdef USE_REWRITE_LDAP_PVT_THREADS
 390         ldap_pvt_thread_rdwr_wunlock( &info->li_cookies_mutex );
 391 #endif /* USE_REWRITE_LDAP_PVT_THREADS */
 392
 393         return REWRITE_SUCCESS;
 394 }
 395