/* ldapsync.c -- LDAP Content Sync Routines */ /* $OpenLDAP$ */ /* This work is part of OpenLDAP Software . * * Copyright 2003-2004 The OpenLDAP Foundation. * Portions Copyright 2003 IBM Corporation. * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted only as authorized by the OpenLDAP * Public License. * * 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" #include #include #include #include "ldap_pvt.h" #include "lutil.h" #include "slap.h" #include "../../libraries/liblber/lber-int.h" /* get ber_strndup() */ #include "lutil_ldap.h" #if 0 struct sync_cookie *slap_sync_cookie = NULL; #else struct slap_sync_cookie_s slap_sync_cookie = LDAP_STAILQ_HEAD_INITIALIZER( slap_sync_cookie ); #endif int slap_build_sync_state_ctrl( Operation *op, SlapReply *rs, Entry *e, int entry_sync_state, LDAPControl **ctrls, int num_ctrls, int send_cookie, struct berval *cookie) { Attribute* a; int ret; int res; const char *text = NULL; BerElementBuffer berbuf; BerElement *ber = (BerElement *)&berbuf; struct berval entryuuid_bv = BER_BVNULL; ber_init2( ber, 0, LBER_USE_DER ); ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx ); ctrls[num_ctrls] = sl_malloc ( sizeof ( LDAPControl ), op->o_tmpmemctx ); for ( a = e->e_attrs; a != NULL; a = a->a_next ) { AttributeDescription *desc = a->a_desc; if ( desc == slap_schema.si_ad_entryUUID ) { ber_dupbv( &entryuuid_bv, &a->a_nvals[0] ); } } if ( send_cookie && cookie ) { ber_printf( ber, "{eOON}", entry_sync_state, &entryuuid_bv, cookie ); } else { ber_printf( ber, "{eON}", entry_sync_state, &entryuuid_bv ); } ch_free( entryuuid_bv.bv_val ); entryuuid_bv.bv_val = NULL; ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_STATE; ctrls[num_ctrls]->ldctl_iscritical = op->o_sync; ret = ber_flatten2( ber, &ctrls[num_ctrls]->ldctl_value, 1 ); ber_free_buf( ber ); if ( ret < 0 ) { #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, RESULTS, "slap_build_sync_ctrl: ber_flatten2 failed\n", 0, 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "slap_build_sync_ctrl: ber_flatten2 failed\n", 0, 0, 0 ); #endif send_ldap_error( op, rs, LDAP_OTHER, "internal error" ); return ret; } return LDAP_SUCCESS; } int slap_build_sync_done_ctrl( Operation *op, SlapReply *rs, LDAPControl **ctrls, int num_ctrls, int send_cookie, struct berval *cookie, int refreshDeletes ) { int ret; BerElementBuffer berbuf; BerElement *ber = (BerElement *)&berbuf; ber_init2( ber, NULL, LBER_USE_DER ); ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx ); ctrls[num_ctrls] = ch_malloc ( sizeof ( LDAPControl ) ); ber_printf( ber, "{" ); if ( send_cookie && cookie ) { ber_printf( ber, "O", cookie ); } if ( refreshDeletes == LDAP_SYNC_REFRESH_DELETES ) { ber_printf( ber, "b", refreshDeletes ); } ber_printf( ber, "N}" ); ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_DONE; ctrls[num_ctrls]->ldctl_iscritical = op->o_sync; ret = ber_flatten2( ber, &ctrls[num_ctrls]->ldctl_value, 1 ); ber_free_buf( ber ); if ( ret < 0 ) { #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, RESULTS, "slap_build_sync_done_ctrl: ber_flatten2 failed\n", 0, 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "slap_build_sync_done_ctrl: ber_flatten2 failed\n", 0, 0, 0 ); #endif send_ldap_error( op, rs, LDAP_OTHER, "internal error" ); return ret; } return LDAP_SUCCESS; } int slap_build_sync_state_ctrl_from_slog( Operation *op, SlapReply *rs, struct slog_entry *slog_e, int entry_sync_state, LDAPControl **ctrls, int num_ctrls, int send_cookie, struct berval *cookie) { Attribute* a; int ret; int res; const char *text = NULL; BerElementBuffer berbuf; BerElement *ber = (BerElement *)&berbuf; struct berval entryuuid_bv = BER_BVNULL; ber_init2( ber, NULL, LBER_USE_DER ); ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx ); ctrls[num_ctrls] = ch_malloc ( sizeof ( LDAPControl ) ); ber_dupbv( &entryuuid_bv, &slog_e->sl_uuid ); if ( send_cookie && cookie ) { ber_printf( ber, "{eOON}", entry_sync_state, &entryuuid_bv, cookie ); } else { ber_printf( ber, "{eON}", entry_sync_state, &entryuuid_bv ); } ch_free( entryuuid_bv.bv_val ); entryuuid_bv.bv_val = NULL; ctrls[num_ctrls]->ldctl_oid = LDAP_CONTROL_SYNC_STATE; ctrls[num_ctrls]->ldctl_iscritical = op->o_sync; ret = ber_flatten2( ber, &ctrls[num_ctrls]->ldctl_value, 1 ); ber_free_buf( ber ); if ( ret < 0 ) { #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, RESULTS, "slap_build_sync_ctrl: ber_flatten2 failed\n", 0, 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "slap_build_sync_ctrl: ber_flatten2 failed\n", 0, 0, 0 ); #endif send_ldap_error( op, rs, LDAP_OTHER, "internal error" ); return ret; } return LDAP_SUCCESS; } int slap_send_syncinfo( Operation *op, SlapReply *rs, int type, struct berval *cookie, int refreshDone, BerVarray syncUUIDs, int refreshDeletes ) { BerElementBuffer berbuf; BerElement *ber = (BerElement *)&berbuf; struct berval rspdata; int ret; ber_init2( ber, NULL, LBER_USE_DER ); ber_set_option( ber, LBER_OPT_BER_MEMCTX, &op->o_tmpmemctx ); if ( type ) { switch ( type ) { case LDAP_TAG_SYNC_NEW_COOKIE: ber_printf( ber, "tO", type, cookie ); break; case LDAP_TAG_SYNC_REFRESH_DELETE: case LDAP_TAG_SYNC_REFRESH_PRESENT: ber_printf( ber, "t{", type ); if ( cookie ) { ber_printf( ber, "O", cookie ); } if ( refreshDone == 0 ) { ber_printf( ber, "b", refreshDone ); } ber_printf( ber, "N}" ); break; case LDAP_TAG_SYNC_ID_SET: ber_printf( ber, "t{", type ); if ( cookie ) { ber_printf( ber, "O", cookie ); } if ( refreshDeletes == 1 ) { ber_printf( ber, "b", refreshDeletes ); } ber_printf( ber, "[W]", syncUUIDs ); ber_printf( ber, "N}" ); break; default: #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, RESULTS, "slap_send_syncinfo: invalid syncinfo type (%d)\n", type, 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "slap_send_syncinfo: invalid syncinfo type (%d)\n", type, 0, 0 ); #endif return LDAP_OTHER; } } ret = ber_flatten2( ber, &rspdata, 0 ); if ( ret < 0 ) { #ifdef NEW_LOGGING LDAP_LOG ( OPERATION, RESULTS, "slap_send_syncinfo: ber_flatten2 failed\n", 0, 0, 0 ); #else Debug( LDAP_DEBUG_TRACE, "slap_send_syncinfo: ber_flatten2 failed\n", 0, 0, 0 ); #endif send_ldap_error( op, rs, LDAP_OTHER, "internal error" ); return ret; } rs->sr_rspdata = &rspdata; send_ldap_intermediate( op, rs ); rs->sr_rspdata = NULL; ber_free_buf( ber ); return LDAP_SUCCESS; } void slap_compose_sync_cookie( Operation *op, struct berval *cookie, struct berval *csn, int sid, int rid ) { char cookiestr[ LDAP_LUTIL_CSNSTR_BUFSIZE + 20 ]; if ( csn->bv_val == NULL ) { if ( sid == -1 ) { if ( rid == -1 ) { cookiestr[0] = '\0'; } else { snprintf( cookiestr, LDAP_LUTIL_CSNSTR_BUFSIZE + 20, "rid=%03d", rid ); } } else { if ( rid == -1 ) { snprintf( cookiestr, LDAP_LUTIL_CSNSTR_BUFSIZE + 20, "sid=%03d", sid ); } else { snprintf( cookiestr, LDAP_LUTIL_CSNSTR_BUFSIZE + 20, "sid=%03d,rid=%03d", sid, rid ); } } } else { if ( sid == -1 ) { if ( rid == -1 ) { snprintf( cookiestr, LDAP_LUTIL_CSNSTR_BUFSIZE + 20, "csn=%s", csn->bv_val ); } else { snprintf( cookiestr, LDAP_LUTIL_CSNSTR_BUFSIZE + 20, "csn=%s,rid=%03d", csn->bv_val, rid ); } } else { if ( rid == -1 ) { snprintf( cookiestr, LDAP_LUTIL_CSNSTR_BUFSIZE + 20, "csn=%s,sid=%03d", csn->bv_val, sid ); } else { snprintf( cookiestr, LDAP_LUTIL_CSNSTR_BUFSIZE + 20, "csn=%s,sid=%03d,rid=%03d", csn->bv_val, sid, rid ); } } } ber_str2bv( cookiestr, strlen(cookiestr), 1, cookie ); } void slap_sync_cookie_free( struct sync_cookie *cookie, int free_cookie ) { if ( cookie == NULL ) return; if ( cookie->ctxcsn ) { ber_bvarray_free( cookie->ctxcsn ); cookie->ctxcsn = NULL; } if ( cookie->octet_str ) { ber_bvarray_free( cookie->octet_str ); cookie->octet_str = NULL; } if ( free_cookie ) { ch_free( cookie ); } return; } int slap_parse_sync_cookie( struct sync_cookie *cookie ) { char *csn_ptr; char *csn_str; int csn_str_len; char *sid_ptr; char *sid_str; char *rid_ptr; char *rid_str; char *cval; struct berval *ctxcsn; if ( cookie == NULL ) return -1; if (( csn_ptr = strstr( cookie->octet_str[0].bv_val, "csn=" )) != NULL ) { csn_str = SLAP_STRNDUP( csn_ptr, LDAP_LUTIL_CSNSTR_BUFSIZE ); if ( (cval = strchr( csn_str, ',' )) != NULL ) { *cval = '\0'; csn_str_len = cval - csn_str - (sizeof("csn=") - 1); } else { csn_str_len = cookie->octet_str[0].bv_len - (csn_ptr - cookie->octet_str[0].bv_val) - (sizeof("csn=") - 1); } ctxcsn = ber_str2bv( csn_str + (sizeof("csn=")-1), csn_str_len, 1, NULL ); ch_free( csn_str ); ber_bvarray_add( &cookie->ctxcsn, ctxcsn ); ch_free( ctxcsn ); } else { cookie->ctxcsn = NULL; } if (( sid_ptr = strstr( cookie->octet_str->bv_val, "sid=" )) != NULL ) { sid_str = SLAP_STRNDUP( sid_ptr, SLAP_SYNC_SID_SIZE + sizeof("sid=") - 1 ); if ( (cval = strchr( sid_str, ',' )) != NULL ) { *cval = '\0'; } cookie->sid = atoi( sid_str + sizeof("sid=") - 1 ); ch_free( sid_str ); } else { cookie->sid = -1; } if (( rid_ptr = strstr( cookie->octet_str->bv_val, "rid=" )) != NULL ) { rid_str = SLAP_STRNDUP( rid_ptr, SLAP_SYNC_RID_SIZE + sizeof("rid=") - 1 ); if ( (cval = strchr( rid_str, ',' )) != NULL ) { *cval = '\0'; } cookie->rid = atoi( rid_str + sizeof("rid=") - 1 ); ch_free( rid_str ); } else { cookie->rid = -1; } return 0; } int slap_init_sync_cookie_ctxcsn( struct sync_cookie *cookie ) { char csnbuf[ LDAP_LUTIL_CSNSTR_BUFSIZE + 4 ]; struct berval octet_str = BER_BVNULL; struct berval ctxcsn = BER_BVNULL; struct berval ctxcsn_dup = BER_BVNULL; struct berval slap_syncCookie; if ( cookie == NULL ) return -1; octet_str.bv_len = snprintf( csnbuf, LDAP_LUTIL_CSNSTR_BUFSIZE + 4, "csn=%4d%02d%02d%02d%02d%02dZ#%06x#%02x#%06x", 1900, 1, 1, 0, 0, 0, 0, 0, 0 ); octet_str.bv_val = csnbuf; build_new_dn( &slap_syncCookie, &cookie->octet_str[0], &octet_str, NULL ); ber_bvarray_free( cookie->octet_str ); cookie->octet_str = NULL; ber_bvarray_add( &cookie->octet_str, &slap_syncCookie ); ber_dupbv( &ctxcsn, &octet_str ); ctxcsn.bv_val += 4; ctxcsn.bv_len -= 4; ber_dupbv( &ctxcsn_dup, &ctxcsn ); ch_free( ctxcsn.bv_val ); ber_bvarray_add( &cookie->ctxcsn, &ctxcsn_dup ); return 0; } struct sync_cookie * slap_dup_sync_cookie( struct sync_cookie *dst, struct sync_cookie *src ) { int i; struct sync_cookie *new; struct berval tmp_bv; if ( src == NULL ) return NULL; if ( dst ) { ber_bvarray_free( dst->ctxcsn ); ber_bvarray_free( dst->octet_str ); new = dst; } else { new = ( struct sync_cookie * ) ch_calloc( 1, sizeof( struct sync_cookie )); } new->sid = src->sid; new->rid = src->rid; if ( src->ctxcsn ) { for ( i=0; src->ctxcsn[i].bv_val; i++ ) { ber_dupbv( &tmp_bv, &src->ctxcsn[i] ); ber_bvarray_add( &new->ctxcsn, &tmp_bv ); } } if ( src->octet_str ) { for ( i=0; src->octet_str[i].bv_val; i++ ) { ber_dupbv( &tmp_bv, &src->octet_str[i] ); ber_bvarray_add( &new->octet_str, &tmp_bv ); } } return new; } int slap_build_syncUUID_set( Operation *op, BerVarray *set, Entry *e ) { int ret; Attribute* a; struct berval entryuuid_bv = BER_BVNULL; for ( a = e->e_attrs; a != NULL; a = a->a_next ) { AttributeDescription *desc = a->a_desc; if ( desc == slap_schema.si_ad_entryUUID ) { ber_dupbv_x( &entryuuid_bv, &a->a_nvals[0], op->o_tmpmemctx ); } } ret = ber_bvarray_add_x( set, &entryuuid_bv, op->o_tmpmemctx ); return ret; }