X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=servers%2Fslapd%2Fctxcsn.c;h=95d7ba6ed1e36dae33b7b8696fa0dfac15ea5f63;hb=f4d00f763f872f2b80aa470914872c8baeb61f0f;hp=8ebb54574694ce629fc1044236b8e1b497ec0392;hpb=c25a892e622e9ee26534e2a209b0bbc8a0803817;p=openldap diff --git a/servers/slapd/ctxcsn.c b/servers/slapd/ctxcsn.c index 8ebb545746..95d7ba6ed1 100644 --- a/servers/slapd/ctxcsn.c +++ b/servers/slapd/ctxcsn.c @@ -1,23 +1,18 @@ +/* ctxcsn.c -- Context CSN Management Routines */ /* $OpenLDAP$ */ -/* - * Context CSN Management Routines - */ -/* Copyright (c) 2003 by International Business Machines, Inc. +/* This work is part of OpenLDAP Software . + * + * Copyright 2003-2009 The OpenLDAP Foundation. + * Portions Copyright 2003 IBM Corporation. + * All rights reserved. * - * International Business Machines, Inc. (hereinafter called IBM) grants - * permission under its copyrights to use, copy, modify, and distribute this - * Software with or without fee, provided that the above copyright notice and - * all paragraphs of this notice appear in all copies, and that the name of IBM - * not be used in connection with the marketing of any product incorporating - * the Software or modifications thereof, without specific, written prior - * permission. + * Redistribution and use in source and binary forms, with or without + * modification, are permitted only as authorized by the OpenLDAP + * Public License. * - * THE SOFTWARE IS PROVIDED "AS IS", AND IBM DISCLAIMS ALL WARRANTIES, - * INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A - * PARTICULAR PURPOSE. IN NO EVENT SHALL IBM BE LIABLE FOR ANY SPECIAL, - * DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER ARISING - * OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE, EVEN - * IF IBM IS APPRISED OF THE POSSIBILITY OF SUCH DAMAGES. + * A copy of this license is available in the file LICENSE in the + * top-level directory of the distribution or, alternatively, at + * . */ #include "portable.h" @@ -26,270 +21,201 @@ #include #include -#include -#include "ldap_pvt.h" #include "lutil.h" #include "slap.h" #include "lutil_ldap.h" -struct berval * -slap_get_commit_csn( Operation *op ) -{ - struct berval *max_committed_csn = NULL; - struct slap_csn_entry *csne = NULL, *committed_csne = NULL; - int i = 0; +const struct berval slap_ldapsync_bv = BER_BVC("ldapsync"); +const struct berval slap_ldapsync_cn_bv = BER_BVC("cn=ldapsync"); +int slap_serverID; - ldap_pvt_thread_mutex_lock( &op->o_bd->be_pcl_mutex ); +/* maxcsn->bv_val must point to a char buf[LDAP_LUTIL_CSNSTR_BUFSIZE] */ +void +slap_get_commit_csn( + Operation *op, + struct berval *maxcsn, + int *foundit +) +{ + struct slap_csn_entry *csne, *committed_csne = NULL; + BackendDB *be = op->o_bd->bd_self; + int sid = -1; - LDAP_TAILQ_FOREACH( csne, &op->o_bd->be_pending_csn_list, csn_link ) { - if ( csne->opid == op->o_opid && csne->connid == op->o_connid ) - break; + if ( maxcsn ) { + assert( maxcsn->bv_val != NULL ); + assert( maxcsn->bv_len >= LDAP_LUTIL_CSNSTR_BUFSIZE ); + } + if ( foundit ) { + *foundit = 0; } - if ( csne ) { - csne->state = SLAP_CSN_COMMIT; + ldap_pvt_thread_mutex_lock( &be->be_pcl_mutex ); + + if ( !BER_BVISEMPTY( &op->o_csn )) { + sid = slap_parse_csn_sid( &op->o_csn ); } - LDAP_TAILQ_FOREACH( csne, &op->o_bd->be_pending_csn_list, csn_link ) { - if ( csne->state == SLAP_CSN_COMMIT ) - committed_csne = csne; - if ( csne->state == SLAP_CSN_PENDING ) + LDAP_TAILQ_FOREACH( csne, be->be_pending_csn_list, ce_csn_link ) { + if ( csne->ce_opid == op->o_opid && csne->ce_connid == op->o_connid ) { + csne->ce_state = SLAP_CSN_COMMIT; + if ( foundit ) *foundit = 1; break; + } } - ldap_pvt_thread_mutex_unlock( &op->o_bd->be_pcl_mutex ); - - if ( committed_csne ) { - max_committed_csn = ber_dupbv( NULL, committed_csne->csn ); + LDAP_TAILQ_FOREACH( csne, be->be_pending_csn_list, ce_csn_link ) { + if ( sid != -1 && sid == csne->ce_sid ) { + if ( csne->ce_state == SLAP_CSN_COMMIT ) committed_csne = csne; + if ( csne->ce_state == SLAP_CSN_PENDING ) break; + } } - return max_committed_csn; + if ( maxcsn ) { + if ( committed_csne ) { + if ( committed_csne->ce_csn.bv_len < maxcsn->bv_len ) + maxcsn->bv_len = committed_csne->ce_csn.bv_len; + AC_MEMCPY( maxcsn->bv_val, committed_csne->ce_csn.bv_val, + maxcsn->bv_len+1 ); + } else { + maxcsn->bv_len = 0; + maxcsn->bv_val[0] = 0; + } + } + ldap_pvt_thread_mutex_unlock( &be->be_pcl_mutex ); } void slap_rewind_commit_csn( Operation *op ) { - struct slap_csn_entry *csne = NULL; + struct slap_csn_entry *csne; + BackendDB *be = op->o_bd->bd_self; - ldap_pvt_thread_mutex_lock( &op->o_bd->be_pcl_mutex ); + ldap_pvt_thread_mutex_lock( &be->be_pcl_mutex ); - LDAP_TAILQ_FOREACH( csne, &op->o_bd->be_pending_csn_list, csn_link ) { - if ( csne->opid == op->o_opid && csne->connid == op->o_connid ) + LDAP_TAILQ_FOREACH( csne, be->be_pending_csn_list, ce_csn_link ) { + if ( csne->ce_opid == op->o_opid && csne->ce_connid == op->o_connid ) { + csne->ce_state = SLAP_CSN_PENDING; break; + } } - if ( csne ) { - csne->state = SLAP_CSN_PENDING; - } - - ldap_pvt_thread_mutex_unlock( &op->o_bd->be_pcl_mutex ); + ldap_pvt_thread_mutex_unlock( &be->be_pcl_mutex ); } void slap_graduate_commit_csn( Operation *op ) { - struct slap_csn_entry *csne = NULL; - - ldap_pvt_thread_mutex_lock( &op->o_bd->be_pcl_mutex ); - - LDAP_TAILQ_FOREACH( csne, &op->o_bd->be_pending_csn_list, csn_link ) { - if ( csne->opid == op->o_opid && csne->connid == op->o_connid ) + struct slap_csn_entry *csne; + BackendDB *be; + + if ( op == NULL ) return; + if ( op->o_bd == NULL ) return; + be = op->o_bd->bd_self; + + ldap_pvt_thread_mutex_lock( &be->be_pcl_mutex ); + + LDAP_TAILQ_FOREACH( csne, be->be_pending_csn_list, ce_csn_link ) { + if ( csne->ce_opid == op->o_opid && csne->ce_connid == op->o_connid ) { + LDAP_TAILQ_REMOVE( be->be_pending_csn_list, + csne, ce_csn_link ); + Debug( LDAP_DEBUG_SYNC, "slap_graduate_commit_csn: removing %p %s\n", + csne->ce_csn.bv_val, csne->ce_csn.bv_val, 0 ); + if ( op->o_csn.bv_val == csne->ce_csn.bv_val ) { + BER_BVZERO( &op->o_csn ); + } + ch_free( csne->ce_csn.bv_val ); + ch_free( csne ); break; + } } - if ( csne ) { - LDAP_TAILQ_REMOVE( &op->o_bd->be_pending_csn_list, csne, csn_link ); - ch_free( csne->csn->bv_val ); - ch_free( csne->csn ); - ch_free( csne ); - } - - ldap_pvt_thread_mutex_unlock( &op->o_bd->be_pcl_mutex ); + ldap_pvt_thread_mutex_unlock( &be->be_pcl_mutex ); return; } +static struct berval ocbva[] = { + BER_BVC("top"), + BER_BVC("subentry"), + BER_BVC("syncProviderSubentry"), + BER_BVNULL +}; + Entry * slap_create_context_csn_entry( Backend *be, - struct berval *context_csn -) + struct berval *context_csn ) { - Modifications *ml; - Modifications *mlnext; - Modifications *mod; - Modifications *modlist; - Modifications **modtail = &modlist; - - struct berval* ocbva = NULL; - struct berval* socbva = NULL; - struct berval* cnbva = NULL; - struct berval* ssbva = NULL; - struct berval* scbva = NULL; - - char substr[64]; - char rdnstr[67]; - const char *text; - char txtbuf[SLAP_TEXT_BUFLEN]; - size_t textlen = sizeof txtbuf; - Entry* e; - int rc; - - struct berval sub_bv = { 0, NULL }; - struct berval psubrdn = { 0, NULL }; - - slap_callback cb; - SlapReply rs = {REP_RESULT}; - - struct berval rdn = { 0, NULL }; - int match = 0; - char *def_filter_str = NULL; - - ocbva = ( struct berval * ) ch_calloc( 4, sizeof( struct berval )); - socbva = ( struct berval * ) ch_calloc( 2, sizeof( struct berval )); - cnbva = ( struct berval * ) ch_calloc( 2, sizeof( struct berval )); - ssbva = ( struct berval * ) ch_calloc( 2, sizeof( struct berval )); - scbva = ( struct berval * ) ch_calloc( 2, sizeof( struct berval )); - - ber_str2bv( "top", strlen("top"), 1, &ocbva[0] ); - ber_str2bv( "subentry", strlen("subentry"), 1, &ocbva[1] ); - ber_str2bv( "syncProviderSubentry", - strlen("syncProviderSubentry"), 1, &ocbva[2] ); - - mod = (Modifications *) ch_calloc( 1, sizeof( Modifications )); - mod->sml_op = LDAP_MOD_REPLACE; - ber_str2bv( "objectClass", strlen("objectClass"), 1, &mod->sml_type ); - mod->sml_bvalues = ocbva; - *modtail = mod; - modtail = &mod->sml_next; - - ber_str2bv( "syncProviderSubentry", - strlen("syncProviderSubentry"), 1, &socbva[0] ); - - mod = (Modifications *) ch_calloc( 1, sizeof( Modifications )); - mod->sml_op = LDAP_MOD_REPLACE; - ber_str2bv( "structuralObjectClass", strlen("structuralObjectClass"), 1, &mod->sml_type ); - mod->sml_bvalues = socbva; - *modtail = mod; - modtail = &mod->sml_next; - - sprintf( substr, "ldapsync" ); - sprintf( rdnstr, "cn=%s", substr ); - ber_str2bv( substr, strlen( substr ), 1, &cnbva[0] ); - ber_str2bv( rdnstr, strlen( rdnstr ), 1, &psubrdn ); - mod = (Modifications *) ch_calloc( 1, sizeof( Modifications )); - mod->sml_op = LDAP_MOD_REPLACE; - ber_str2bv( "cn", strlen("cn"), 1, &mod->sml_type ); - mod->sml_bvalues = cnbva; - *modtail = mod; - modtail = &mod->sml_next; - if ( context_csn ) { - ber_dupbv( &scbva[0], context_csn ); - mod = (Modifications *) ch_calloc( 1, sizeof( Modifications )); - mod->sml_op = LDAP_MOD_REPLACE; - ber_str2bv( "contextCSN", strlen("contextCSN"), 1, &mod->sml_type ); - mod->sml_bvalues = scbva; - *modtail = mod; - modtail = &mod->sml_next; - } + struct berval bv; - ber_str2bv( "{}", strlen("{}"), 1, &ssbva[0] ); - mod = (Modifications *) ch_calloc( 1, sizeof( Modifications )); - mod->sml_op = LDAP_MOD_REPLACE; - ber_str2bv( "subtreeSpecification", - strlen("subtreeSpecification"), 1, &mod->sml_type ); - mod->sml_bvalues = ssbva; - *modtail = mod; - modtail = &mod->sml_next; - - rc = slap_mods_check( modlist, 1, &text, txtbuf, textlen, NULL ); - - if ( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG( OPERATION, ERR, - "create_context_csn_entry: mods check (%s)\n", text, 0, 0 ); -#else - Debug( LDAP_DEBUG_ANY, "create_context_csn_entry: mods check (%s)\n", - text, 0, 0 ); -#endif - } - - e = ( Entry * ) ch_calloc( 1, sizeof( Entry )); - - build_new_dn( &sub_bv, &be->be_nsuffix[0], &psubrdn ); - dnPrettyNormal( NULL, &sub_bv, &e->e_name, &e->e_nname, NULL ); - ch_free( sub_bv.bv_val ); - ch_free( psubrdn.bv_val ); + e = entry_alloc(); - e->e_attrs = NULL; + attr_merge( e, slap_schema.si_ad_objectClass, + ocbva, NULL ); + attr_merge_one( e, slap_schema.si_ad_structuralObjectClass, + &ocbva[1], NULL ); + attr_merge_one( e, slap_schema.si_ad_cn, + (struct berval *)&slap_ldapsync_bv, NULL ); - rc = slap_mods2entry( modlist, &e, 1, 1, &text, txtbuf, textlen ); - - if( rc != LDAP_SUCCESS ) { -#ifdef NEW_LOGGING - LDAP_LOG( OPERATION, ERR, - "create_context_csn_entry: mods2entry (%s)\n", text, 0, 0 ); -#else - Debug( LDAP_DEBUG_ANY, "create_context_csn_entry: mods2entry (%s)\n", - text, 0, 0 ); -#endif + if ( context_csn ) { + attr_merge_one( e, slap_schema.si_ad_contextCSN, + context_csn, NULL ); } - for ( ml = modlist; ml != NULL; ml = mlnext ) { - mlnext = ml->sml_next; - free( ml ); - } + BER_BVSTR( &bv, "{}" ); + attr_merge_one( e, slap_schema.si_ad_subtreeSpecification, &bv, NULL ); + + build_new_dn( &e->e_name, &be->be_nsuffix[0], + (struct berval *)&slap_ldapsync_cn_bv, NULL ); + ber_dupbv( &e->e_nname, &e->e_name ); return e; } -static int -slap_contextcsn_callback( - Operation* op, - SlapReply* rs -) +void +slap_queue_csn( + Operation *op, + struct berval *csn ) { - if ( rs->sr_type != REP_SEARCH ) { - *((int*)op->o_callback->sc_private) = 0; - } else { - *((int*)op->o_callback->sc_private) = 1; - } - return LDAP_SUCCESS; + struct slap_csn_entry *pending; + BackendDB *be = op->o_bd->bd_self; + + pending = (struct slap_csn_entry *) ch_calloc( 1, + sizeof( struct slap_csn_entry )); + + Debug( LDAP_DEBUG_SYNC, "slap_queue_csn: queing %p %s\n", csn->bv_val, csn->bv_val, 0 ); + + ldap_pvt_thread_mutex_lock( &be->be_pcl_mutex ); + + ber_dupbv( &pending->ce_csn, csn ); + ber_bvreplace_x( &op->o_csn, &pending->ce_csn, op->o_tmpmemctx ); + pending->ce_sid = slap_parse_csn_sid( csn ); + pending->ce_connid = op->o_connid; + pending->ce_opid = op->o_opid; + pending->ce_state = SLAP_CSN_PENDING; + LDAP_TAILQ_INSERT_TAIL( be->be_pending_csn_list, + pending, ce_csn_link ); + ldap_pvt_thread_mutex_unlock( &be->be_pcl_mutex ); } int slap_get_csn( Operation *op, - char *csnbuf, - int len, struct berval *csn, - int manage_ctxcsn -) + int manage_ctxcsn ) { - struct slap_csn_entry *pending; - - if ( manage_ctxcsn ) { - pending = (struct slap_csn_entry *) ch_calloc( 1, sizeof( struct slap_csn_entry )); - } + if ( csn == NULL ) return LDAP_OTHER; - if ( csn == NULL ) - return LDAP_OTHER; + /* gmtime doesn't always need a mutex, but lutil_csnstr does */ + ldap_pvt_thread_mutex_lock( &gmtime_mutex ); + csn->bv_len = lutil_csnstr( csn->bv_val, csn->bv_len, slap_serverID, 0 ); + if ( manage_ctxcsn ) + slap_queue_csn( op, csn ); - csn->bv_len = lutil_csnstr( csnbuf, len, 0, 0 ); - csn->bv_val = csnbuf; - - if ( manage_ctxcsn ) { - ldap_pvt_thread_mutex_lock( &op->o_bd->be_pcl_mutex ); - pending->csn = ber_dupbv( NULL, csn ); - pending->connid = op->o_connid; - pending->opid = op->o_opid; - pending->state = SLAP_CSN_PENDING; - LDAP_TAILQ_INSERT_TAIL( &op->o_bd->be_pending_csn_list, pending, csn_link ); - ldap_pvt_thread_mutex_unlock( &op->o_bd->be_pcl_mutex ); - } + ldap_pvt_thread_mutex_unlock( &gmtime_mutex ); return LDAP_SUCCESS; }