git.sur5r.net Git - openldap/blob - contrib/slapd-modules/samba4/pguid.c

   1 /* pguid.c - Parent GUID value overlay */
   2 /* $OpenLDAP$ */
   3 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
   4  *
   5  * Copyright 1998-2016 The OpenLDAP Foundation.
   6  * Portions Copyright 2008 Pierangelo Masarati.
   7  * All rights reserved.
   8  *
   9  * Redistribution and use in source and binary forms, with or without
  10  * modification, are permitted only as authorized by the OpenLDAP
  11  * Public License.
  12  *
  13  * A copy of this license is available in the file LICENSE in the
  14  * top-level directory of the distribution or, alternatively, at
  15  * <http://www.OpenLDAP.org/license.html>.
  16  */
  17 /* ACKNOWLEDGEMENTS:
  18  * This work was initially developed by Pierangelo Masarati
  19  * for inclusion in OpenLDAP Software.
  20  */
  21
  22 #include "portable.h"
  23
  24 #ifdef SLAPD_OVER_PGUID
  25
  26 #include <stdio.h>
  27
  28 #include "ac/string.h"
  29 #include "ac/socket.h"
  30
  31 #include "slap.h"
  32 #include "config.h"
  33
  34 #include "lutil.h"
  35
  36 /*
  37  * Maintain an attribute (parentUUID) that contains the value
  38  * of the entryUUID of the parent entry (used by Samba4)
  39  */
  40
  41 static AttributeDescription     *ad_parentUUID;
  42
  43 static slap_overinst            pguid;
  44
  45 static int
  46 pguid_op_add( Operation *op, SlapReply *rs )
  47 {
  48         slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
  49
  50         struct berval pdn, pndn;
  51         Entry *e = NULL;
  52         Attribute *a;
  53         int rc;
  54
  55         /* don't care about suffix entry */
  56         if ( dn_match( &op->o_req_ndn, &op->o_bd->be_nsuffix[0] ) ) {
  57                 return SLAP_CB_CONTINUE;
  58         }
  59
  60         dnParent( &op->o_req_dn, &pdn );
  61         dnParent( &op->o_req_ndn, &pndn );
  62
  63         rc = overlay_entry_get_ov( op, &pndn, NULL, slap_schema.si_ad_entryUUID, 0, &e, on );
  64         if ( rc != LDAP_SUCCESS || e == NULL ) {
  65                 Debug( LDAP_DEBUG_ANY, "%s: pguid_op_add: unable to get parent entry DN=\"%s\" (%d)\n",
  66                         op->o_log_prefix, pdn.bv_val, rc );
  67                 return SLAP_CB_CONTINUE;
  68         }
  69
  70         a = attr_find( e->e_attrs, slap_schema.si_ad_entryUUID );
  71         if ( a == NULL ) {
  72                 Debug( LDAP_DEBUG_ANY, "%s: pguid_op_add: unable to find entryUUID of parent entry DN=\"%s\" (%d)\n",
  73                         op->o_log_prefix, pdn.bv_val, rc );
  74
  75         } else {
  76                 assert( a->a_numvals == 1 );
  77
  78                 if ( op->ora_e != NULL ) {
  79                         attr_merge_one( op->ora_e, ad_parentUUID, &a->a_vals[0], a->a_nvals == a->a_vals ? NULL : &a->a_nvals[0] );
  80
  81                 } else {
  82                         Modifications *ml;
  83                         Modifications *mod;
  84
  85                         assert( op->ora_modlist != NULL );
  86
  87                         for ( ml = op->ora_modlist; ml != NULL; ml = ml->sml_next ) {
  88                                 if ( ml->sml_mod.sm_desc == slap_schema.si_ad_entryUUID ) {
  89                                         break;
  90                                 }
  91                         }
  92
  93                         if ( ml == NULL ) {
  94                                 ml = op->ora_modlist;
  95                         }
  96
  97                         mod = (Modifications *) ch_malloc( sizeof( Modifications ) );
  98                         mod->sml_flags = SLAP_MOD_INTERNAL;
  99                         mod->sml_op = LDAP_MOD_ADD;
 100                         mod->sml_desc = ad_parentUUID;
 101                         mod->sml_type = ad_parentUUID->ad_cname;
 102                         mod->sml_values = ch_malloc( sizeof( struct berval ) * 2 );
 103                         mod->sml_nvalues = NULL;
 104                         mod->sml_numvals = 1;
 105
 106                         ber_dupbv( &mod->sml_values[0], &a->a_vals[0] );
 107                         BER_BVZERO( &mod->sml_values[1] );
 108
 109                         mod->sml_next = ml->sml_next;
 110                         ml->sml_next = mod;
 111                 }
 112         }
 113
 114         if ( e != NULL ) {
 115                 (void)overlay_entry_release_ov( op, e, 0, on );
 116         }
 117
 118         return SLAP_CB_CONTINUE;
 119 }
 120
 121 static int
 122 pguid_op_rename( Operation *op, SlapReply *rs )
 123 {
 124         slap_overinst *on = (slap_overinst *)op->o_bd->bd_info;
 125
 126         Entry *e = NULL;
 127         Attribute *a;
 128         int rc;
 129
 130         if ( op->orr_nnewSup == NULL ) {
 131                 return SLAP_CB_CONTINUE;
 132         }
 133
 134         rc = overlay_entry_get_ov( op, op->orr_nnewSup, NULL, slap_schema.si_ad_entryUUID, 0, &e, on );
 135         if ( rc != LDAP_SUCCESS || e == NULL ) {
 136                 Debug( LDAP_DEBUG_ANY, "%s: pguid_op_rename: unable to get newSuperior entry DN=\"%s\" (%d)\n",
 137                         op->o_log_prefix, op->orr_newSup->bv_val, rc );
 138                 return SLAP_CB_CONTINUE;
 139         }
 140
 141         a = attr_find( e->e_attrs, slap_schema.si_ad_entryUUID );
 142         if ( a == NULL ) {
 143                 Debug( LDAP_DEBUG_ANY, "%s: pguid_op_rename: unable to find entryUUID of newSuperior entry DN=\"%s\" (%d)\n",
 144                         op->o_log_prefix, op->orr_newSup->bv_val, rc );
 145
 146         } else {
 147                 Modifications *mod;
 148
 149                 assert( a->a_numvals == 1 );
 150
 151                 mod = (Modifications *) ch_malloc( sizeof( Modifications ) );
 152                 mod->sml_flags = SLAP_MOD_INTERNAL;
 153                 mod->sml_op = LDAP_MOD_REPLACE;
 154                 mod->sml_desc = ad_parentUUID;
 155                 mod->sml_type = ad_parentUUID->ad_cname;
 156                 mod->sml_values = ch_malloc( sizeof( struct berval ) * 2 );
 157                 mod->sml_nvalues = NULL;
 158                 mod->sml_numvals = 1;
 159
 160                 ber_dupbv( &mod->sml_values[0], &a->a_vals[0] );
 161                 BER_BVZERO( &mod->sml_values[1] );
 162
 163                 mod->sml_next = op->orr_modlist;
 164                 op->orr_modlist = mod;
 165         }
 166
 167         if ( e != NULL ) {
 168                 (void)overlay_entry_release_ov( op, e, 0, on );
 169         }
 170
 171         return SLAP_CB_CONTINUE;
 172 }
 173
 174 static int
 175 pguid_db_init(
 176         BackendDB       *be,
 177         ConfigReply     *cr)
 178 {
 179         if ( SLAP_ISGLOBALOVERLAY( be ) ) {
 180                 Log0( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
 181                         "pguid_db_init: pguid cannot be used as global overlay.\n" );
 182                 return 1;
 183         }
 184
 185         if ( be->be_nsuffix == NULL ) {
 186                 Log0( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
 187                         "pguid_db_init: database must have suffix\n" );
 188                 return 1;
 189         }
 190
 191         if ( BER_BVISNULL( &be->be_rootndn ) || BER_BVISEMPTY( &be->be_rootndn ) ) {
 192                 Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
 193                         "pguid_db_init: missing rootdn for database DN=\"%s\", YMMV\n",
 194                         be->be_suffix[ 0 ].bv_val );
 195         }
 196
 197         return 0;
 198 }
 199
 200 typedef struct pguid_mod_t {
 201         struct berval ndn;
 202         struct berval pguid;
 203         struct pguid_mod_t *next;
 204 } pguid_mod_t;
 205
 206 typedef struct {
 207         slap_overinst *on;
 208         pguid_mod_t *mods;
 209 } pguid_repair_cb_t;
 210
 211 static int
 212 pguid_repair_cb( Operation *op, SlapReply *rs )
 213 {
 214         int rc;
 215         pguid_repair_cb_t *pcb = op->o_callback->sc_private;
 216         Entry *e = NULL;
 217         Attribute *a;
 218         struct berval pdn, pndn;
 219
 220         switch ( rs->sr_type ) {
 221         case REP_SEARCH:
 222                 break;
 223
 224         case REP_SEARCHREF:
 225         case REP_RESULT:
 226                 return rs->sr_err;
 227
 228         default:
 229                 assert( 0 );
 230         }
 231
 232         assert( rs->sr_entry != NULL );
 233
 234         dnParent( &rs->sr_entry->e_name, &pdn );
 235         dnParent( &rs->sr_entry->e_nname, &pndn );
 236
 237         rc = overlay_entry_get_ov( op, &pndn, NULL, slap_schema.si_ad_entryUUID, 0, &e, pcb->on );
 238         if ( rc != LDAP_SUCCESS || e == NULL ) {
 239                 Debug( LDAP_DEBUG_ANY, "%s: pguid_repair_cb: unable to get parent entry DN=\"%s\" (%d)\n",
 240                         op->o_log_prefix, pdn.bv_val, rc );
 241                 return 0;
 242         }
 243
 244         a = attr_find( e->e_attrs, slap_schema.si_ad_entryUUID );
 245         if ( a == NULL ) {
 246                 Debug( LDAP_DEBUG_ANY, "%s: pguid_repair_cb: unable to find entryUUID of parent entry DN=\"%s\" (%d)\n",
 247                         op->o_log_prefix, pdn.bv_val, rc );
 248
 249         } else {
 250                 ber_len_t len;
 251                 pguid_mod_t *mod;
 252
 253                 assert( a->a_numvals == 1 );
 254
 255                 len = sizeof( pguid_mod_t ) + rs->sr_entry->e_nname.bv_len + 1 + a->a_vals[0].bv_len + 1;
 256                 mod = op->o_tmpalloc( len, op->o_tmpmemctx );
 257                 mod->ndn.bv_len = rs->sr_entry->e_nname.bv_len;
 258                 mod->ndn.bv_val = (char *)&mod[1];
 259                 mod->pguid.bv_len = a->a_vals[0].bv_len;
 260                 mod->pguid.bv_val = (char *)&mod->ndn.bv_val[mod->ndn.bv_len + 1];
 261                 lutil_strncopy( mod->ndn.bv_val, rs->sr_entry->e_nname.bv_val, rs->sr_entry->e_nname.bv_len );
 262                 lutil_strncopy( mod->pguid.bv_val, a->a_vals[0].bv_val, a->a_vals[0].bv_len );
 263
 264                 mod->next = pcb->mods;
 265                 pcb->mods = mod;
 266
 267                 Debug( LDAP_DEBUG_TRACE, "%s: pguid_repair_cb: scheduling entry DN=\"%s\" for repair\n",
 268                         op->o_log_prefix, rs->sr_entry->e_name.bv_val, 0 );
 269         }
 270
 271         if ( e != NULL ) {
 272                 (void)overlay_entry_release_ov( op, e, 0, pcb->on );
 273         }
 274
 275         return 0;
 276 }
 277
 278 static int
 279 pguid_repair( BackendDB *be )
 280 {
 281         slap_overinst *on = (slap_overinst *)be->bd_info;
 282         void *ctx = ldap_pvt_thread_pool_context();
 283         Connection conn = { 0 };
 284         OperationBuffer opbuf;
 285         Operation *op;
 286         slap_callback sc = { 0 };
 287         pguid_repair_cb_t pcb = { 0 };
 288         SlapReply rs = { REP_RESULT };
 289         pguid_mod_t *pmod;
 290         int nrepaired = 0;
 291
 292         connection_fake_init2( &conn, &opbuf, ctx, 0 );
 293         op = &opbuf.ob_op;
 294
 295         op->o_tag = LDAP_REQ_SEARCH;
 296         memset( &op->oq_search, 0, sizeof( op->oq_search ) );
 297
 298         op->o_bd = select_backend( &be->be_nsuffix[ 0 ], 0 );
 299
 300         op->o_req_dn = op->o_bd->be_suffix[ 0 ];
 301         op->o_req_ndn = op->o_bd->be_nsuffix[ 0 ];
 302
 303         op->o_dn = op->o_bd->be_rootdn;
 304         op->o_ndn = op->o_bd->be_rootndn;
 305
 306         op->ors_scope = LDAP_SCOPE_SUBORDINATE;
 307         op->ors_tlimit = SLAP_NO_LIMIT;
 308         op->ors_slimit = SLAP_NO_LIMIT;
 309         op->ors_attrs = slap_anlist_no_attrs;
 310
 311         op->ors_filterstr.bv_len = STRLENOF( "(!(=*))" ) + ad_parentUUID->ad_cname.bv_len;
 312         op->ors_filterstr.bv_val = op->o_tmpalloc( op->ors_filterstr.bv_len + 1, op->o_tmpmemctx );
 313         snprintf( op->ors_filterstr.bv_val, op->ors_filterstr.bv_len + 1,
 314                 "(!(%s=*))", ad_parentUUID->ad_cname.bv_val );
 315
 316         op->ors_filter = str2filter_x( op, op->ors_filterstr.bv_val );
 317         if ( op->ors_filter == NULL ) {
 318                 rs.sr_err = LDAP_OTHER;
 319                 goto done_search;
 320         }
 321
 322         op->o_callback = &sc;
 323         sc.sc_response = pguid_repair_cb;
 324         sc.sc_private = &pcb;
 325         pcb.on = on;
 326
 327         (void)op->o_bd->bd_info->bi_op_search( op, &rs );
 328
 329         op->o_tag = LDAP_REQ_MODIFY;
 330         sc.sc_response = slap_null_cb;
 331         sc.sc_private = NULL;
 332         memset( &op->oq_modify, 0, sizeof( req_modify_s ) );
 333
 334         for ( pmod = pcb.mods; pmod != NULL; ) {
 335                 pguid_mod_t *pnext;
 336
 337                 Modifications *mod;
 338                 SlapReply rs2 = { REP_RESULT };
 339
 340                 mod = (Modifications *) ch_malloc( sizeof( Modifications ) );
 341                 mod->sml_flags = SLAP_MOD_INTERNAL;
 342                 mod->sml_op = LDAP_MOD_REPLACE;
 343                 mod->sml_desc = ad_parentUUID;
 344                 mod->sml_type = ad_parentUUID->ad_cname;
 345                 mod->sml_values = ch_malloc( sizeof( struct berval ) * 2 );
 346                 mod->sml_nvalues = NULL;
 347                 mod->sml_numvals = 1;
 348                 mod->sml_next = NULL;
 349
 350                 ber_dupbv( &mod->sml_values[0], &pmod->pguid );
 351                 BER_BVZERO( &mod->sml_values[1] );
 352
 353                 op->o_req_dn = pmod->ndn;
 354                 op->o_req_ndn = pmod->ndn;
 355
 356                 op->orm_modlist = mod;
 357                 op->o_bd->be_modify( op, &rs2 );
 358                 slap_mods_free( op->orm_modlist, 1 );
 359                 if ( rs2.sr_err == LDAP_SUCCESS ) {
 360                         Debug( LDAP_DEBUG_TRACE, "%s: pguid_repair: entry DN=\"%s\" repaired\n",
 361                                 op->o_log_prefix, pmod->ndn.bv_val, 0 );
 362                         nrepaired++;
 363
 364                 } else {
 365                         Debug( LDAP_DEBUG_ANY, "%s: pguid_repair: entry DN=\"%s\" repair failed (%d)\n",
 366                                 op->o_log_prefix, pmod->ndn.bv_val, rs2.sr_err );
 367                 }
 368
 369                 pnext = pmod->next;
 370                 op->o_tmpfree( pmod, op->o_tmpmemctx );
 371                 pmod = pnext;
 372         }
 373
 374 done_search:;
 375         op->o_tmpfree( op->ors_filterstr.bv_val, op->o_tmpmemctx );
 376         filter_free_x( op, op->ors_filter, 1 );
 377
 378         Log1( LDAP_DEBUG_STATS, LDAP_LEVEL_INFO,
 379                 "pguid: repaired=%d\n", nrepaired );
 380
 381         return rs.sr_err;
 382 }
 383
 384 /* search all entries without parentUUID; "repair" them */
 385 static int
 386 pguid_db_open(
 387         BackendDB       *be,
 388         ConfigReply     *cr )
 389 {
 390         if ( SLAP_SINGLE_SHADOW( be ) ) {
 391                 Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
 392                         "pguid incompatible with shadow database \"%s\".\n",
 393                         be->be_suffix[ 0 ].bv_val );
 394                 return 1;
 395         }
 396
 397         pguid_repair( be );
 398
 399         return 0;
 400 }
 401
 402 static struct {
 403         char    *desc;
 404         AttributeDescription **adp;
 405 } as[] = {
 406         { "( 1.3.6.1.4.1.4203.666.1.59 "
 407                 "NAME 'parentUUID' "
 408                 "DESC 'the value of the entryUUID of the parent' "
 409                 "EQUALITY UUIDMatch "
 410                 "ORDERING UUIDOrderingMatch "
 411                 "SYNTAX 1.3.6.1.1.16.1 "
 412                 "USAGE dSAOperation "
 413                 "SINGLE-VALUE "
 414                 "NO-USER-MODIFICATION "
 415                 ")",
 416                 &ad_parentUUID },
 417         { NULL }
 418 };
 419
 420 int
 421 pguid_initialize(void)
 422 {
 423         int code, i;
 424
 425         for ( i = 0; as[ i ].desc != NULL; i++ ) {
 426                 code = register_at( as[ i ].desc, as[ i ].adp, 0 );
 427                 if ( code ) {
 428                         Debug( LDAP_DEBUG_ANY,
 429                                 "pguid_initialize: register_at #%d failed\n",
 430                                 i, 0, 0 );
 431                         return code;
 432                 }
 433
 434                 /* Allow Manager to set these as needed */
 435                 if ( is_at_no_user_mod( (*as[ i ].adp)->ad_type ) ) {
 436                         (*as[ i ].adp)->ad_type->sat_flags |=
 437                                 SLAP_AT_MANAGEABLE;
 438                 }
 439         }
 440
 441         pguid.on_bi.bi_type = "pguid";
 442
 443         pguid.on_bi.bi_op_add = pguid_op_add;
 444         pguid.on_bi.bi_op_modrdn = pguid_op_rename;
 445
 446         pguid.on_bi.bi_db_init = pguid_db_init;
 447         pguid.on_bi.bi_db_open = pguid_db_open;
 448
 449         return overlay_register( &pguid );
 450 }
 451
 452 #if SLAPD_OVER_PGUID == SLAPD_MOD_DYNAMIC
 453 int
 454 init_module( int argc, char *argv[] )
 455 {
 456         return pguid_initialize();
 457 }
 458 #endif /* SLAPD_OVER_PGUID == SLAPD_MOD_DYNAMIC */
 459
 460 #endif /* SLAPD_OVER_PGUID */