Diff for /servers/slapd/overlays/retcode.c between versions 1.4 and 1.4.2.9

version 1.4, 2005/07/17 10:17:54 version 1.4.2.9, 2007/01/02 21:44:08
Line 1 Line 1
 /* retcode.c - customizable response for client testing purposes */  /* retcode.c - customizable response for client testing purposes */
 /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/retcode.c,v 1.3 2005/07/11 17:09:30 hallvard Exp $ */  /* $OpenLDAP: pkg/ldap/servers/slapd/overlays/retcode.c,v 1.4.2.8 2006/06/02 13:15:49 ando Exp $ */
 /* This work is part of OpenLDAP Software <http://www.openldap.org/>.  /* This work is part of OpenLDAP Software <http://www.openldap.org/>.
  *   *
  * Copyright 2005 The OpenLDAP Foundation.   * Copyright 2005-2007 The OpenLDAP Foundation.
  * Portions Copyright 2005 Pierangelo Masarati <ando@sys-net.it>   * Portions Copyright 2005 Pierangelo Masarati <ando@sys-net.it>
  * All rights reserved.   * All rights reserved.
  *   *
Line 39  static AttributeDescription *ad_errCode; Line 39  static AttributeDescription *ad_errCode;
 static AttributeDescription     *ad_errText;  static AttributeDescription     *ad_errText;
 static AttributeDescription     *ad_errOp;  static AttributeDescription     *ad_errOp;
 static AttributeDescription     *ad_errSleepTime;  static AttributeDescription     *ad_errSleepTime;
   static AttributeDescription     *ad_errMatchedDN;
   static ObjectClass              *oc_errAbsObject;
 static ObjectClass              *oc_errObject;  static ObjectClass              *oc_errObject;
   static ObjectClass              *oc_errAuxObject;
   
 typedef enum retcode_op_e {  typedef enum retcode_op_e {
         SN_DG_OP_NONE           = 0x0000,          SN_DG_OP_NONE           = 0x0000,
Line 61  typedef struct retcode_item_t { Line 64  typedef struct retcode_item_t {
         struct berval           rdi_dn;          struct berval           rdi_dn;
         struct berval           rdi_ndn;          struct berval           rdi_ndn;
         struct berval           rdi_text;          struct berval           rdi_text;
           struct berval           rdi_matched;
         int                     rdi_err;          int                     rdi_err;
         BerVarray               rdi_ref;          BerVarray               rdi_ref;
         int                     rdi_sleeptime;          int                     rdi_sleeptime;
Line 73  typedef struct retcode_t { Line 77  typedef struct retcode_t {
         struct berval           rd_pdn;          struct berval           rd_pdn;
         struct berval           rd_npdn;          struct berval           rd_npdn;
   
           int                     rd_sleep;
   
         retcode_item_t          *rd_item;          retcode_item_t          *rd_item;
   
         unsigned                rd_flags;          unsigned                rd_flags;
Line 82  typedef struct retcode_t { Line 88  typedef struct retcode_t {
 } retcode_t;  } retcode_t;
   
 static int  static int
 retcode_entry_response( Operation *op, SlapReply *rs, Entry *e );  retcode_entry_response( Operation *op, SlapReply *rs, BackendInfo *bi, Entry *e );
   
 static int  static int
 retcode_cleanup_cb( Operation *op, SlapReply *rs )  retcode_cleanup_cb( Operation *op, SlapReply *rs )
Line 110  retcode_send_onelevel( Operation *op, Sl Line 116  retcode_send_onelevel( Operation *op, Sl
         retcode_item_t  *rdi;          retcode_item_t  *rdi;
                   
         for ( rdi = rd->rd_item; rdi != NULL; rdi = rdi->rdi_next ) {          for ( rdi = rd->rd_item; rdi != NULL; rdi = rdi->rdi_next ) {
                 int     rc;  
   
                 if ( op->o_abandon ) {                  if ( op->o_abandon ) {
                         return rs->sr_err = SLAPD_ABANDON;                          return rs->sr_err = SLAPD_ABANDON;
                 }                  }
Line 131  retcode_send_onelevel( Operation *op, Sl Line 135  retcode_send_onelevel( Operation *op, Sl
                         rs->sr_err = LDAP_SUCCESS;                          rs->sr_err = LDAP_SUCCESS;
                         rs->sr_entry = &rdi->rdi_e;                          rs->sr_entry = &rdi->rdi_e;
   
                         rc = send_search_entry( op, rs );                          rs->sr_err = send_search_entry( op, rs );
                           rs->sr_entry = NULL;
   
                         switch ( rc ) {                          switch ( rs->sr_err ) {
                         case 0:         /* entry sent ok */                          case LDAP_UNAVAILABLE:  /* connection closed */
                                 break;  
                         case 1:         /* entry not sent */  
                                 break;  
                         case -1:        /* connection closed */  
                                 rs->sr_entry = NULL;  
                                 rs->sr_err = LDAP_OTHER;                                  rs->sr_err = LDAP_OTHER;
                                   /* fallthru */
                           case LDAP_SIZELIMIT_EXCEEDED:
                                 goto done;                                  goto done;
                         }                          }
                 }                  }
Line 157  done:; Line 159  done:;
 static int  static int
 retcode_op_add( Operation *op, SlapReply *rs )  retcode_op_add( Operation *op, SlapReply *rs )
 {  {
         return retcode_entry_response( op, rs, op->ora_e );          return retcode_entry_response( op, rs, NULL, op->ora_e );
 }  }
   
 typedef struct retcode_cb_t {  typedef struct retcode_cb_t {
           BackendInfo     *rdc_info;
         unsigned        rdc_flags;          unsigned        rdc_flags;
         ber_tag_t       rdc_tag;          ber_tag_t       rdc_tag;
           AttributeName   *rdc_attrs;
 } retcode_cb_t;  } retcode_cb_t;
   
 static int  static int
Line 175  retcode_cb_response( Operation *op, Slap Line 179  retcode_cb_response( Operation *op, Slap
                 int             rc;                  int             rc;
   
                 op->o_tag = rdc->rdc_tag;                  op->o_tag = rdc->rdc_tag;
                 rc = retcode_entry_response( op, rs, rs->sr_entry );                  if ( op->o_tag == LDAP_REQ_SEARCH ) {
                           rs->sr_attrs = rdc->rdc_attrs;
                   }
                   rc = retcode_entry_response( op, rs, rdc->rdc_info, rs->sr_entry );
                 op->o_tag = o_tag;                  op->o_tag = o_tag;
   
                 return rc;                  return rc;
         }          }
   
         if ( rs->sr_err == LDAP_SUCCESS ) {          if ( rs->sr_err == LDAP_SUCCESS ) {
                 rdc->rdc_flags = SLAP_CB_CONTINUE;                  if ( !op->o_abandon ) {
                           rdc->rdc_flags = SLAP_CB_CONTINUE;
                   }
                 return 0;                  return 0;
         }          }
   
Line 195  retcode_op_internal( Operation *op, Slap Line 204  retcode_op_internal( Operation *op, Slap
         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;          slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
   
         Operation       op2 = *op;          Operation       op2 = *op;
         SlapReply       rs2 = { 0 };  
         BackendDB       db = *op->o_bd;          BackendDB       db = *op->o_bd;
         slap_callback   sc = { 0 };          slap_callback   sc = { 0 };
         retcode_cb_t    rdc;          retcode_cb_t    rdc;
Line 211  retcode_op_internal( Operation *op, Slap Line 219  retcode_op_internal( Operation *op, Slap
         op2.ors_attrsonly = 0;          op2.ors_attrsonly = 0;
         op2.ors_attrs = slap_anlist_all_attributes;          op2.ors_attrs = slap_anlist_all_attributes;
   
         ber_str2bv_x( "(objectClass=errObject)", STRLENOF( "(objectClass=errObject)" ),          ber_str2bv_x( "(objectClass=errAbsObject)",
                   STRLENOF( "(objectClass=errAbsObject)" ),
                 1, &op2.ors_filterstr, op2.o_tmpmemctx );                  1, &op2.ors_filterstr, op2.o_tmpmemctx );
         op2.ors_filter = str2filter_x( &op2, op2.ors_filterstr.bv_val );          op2.ors_filter = str2filter_x( &op2, op2.ors_filterstr.bv_val );
   
         db.bd_info = on->on_info->oi_orig;          db.bd_info = on->on_info->oi_orig;
         op2.o_bd = &db;          op2.o_bd = &db;
   
           rdc.rdc_info = on->on_info->oi_orig;
         rdc.rdc_flags = RETCODE_FINDIR;          rdc.rdc_flags = RETCODE_FINDIR;
           if ( op->o_tag == LDAP_REQ_SEARCH ) {
                   rdc.rdc_attrs = op->ors_attrs;
           }
         rdc.rdc_tag = op->o_tag;          rdc.rdc_tag = op->o_tag;
         sc.sc_response = retcode_cb_response;          sc.sc_response = retcode_cb_response;
         sc.sc_private = &rdc;          sc.sc_private = &rdc;
         op2.o_callback = &sc;          op2.o_callback = &sc;
   
         rc = op2.o_bd->be_search( &op2, &rs2 );          rc = op2.o_bd->be_search( &op2, rs );
           op->o_abandon = op2.o_abandon;
   
         filter_free_x( &op2, op2.ors_filter );          filter_free_x( &op2, op2.ors_filter );
         ber_memfree_x( op2.ors_filterstr.bv_val, op2.o_tmpmemctx );          ber_memfree_x( op2.ors_filterstr.bv_val, op2.o_tmpmemctx );
Line 247  retcode_op_func( Operation *op, SlapRepl Line 261  retcode_op_func( Operation *op, SlapRepl
   
         slap_callback           *cb = NULL;          slap_callback           *cb = NULL;
   
           /* sleep as required */
           if ( rd->rd_sleep < 0 ) {
                   sleep( rand() % ( - rd->rd_sleep ) );
   
           } else if ( rd->rd_sleep > 0 ) {
                   sleep( rd->rd_sleep );
           }
   
         if ( !dnIsSuffix( &op->o_req_ndn, &rd->rd_npdn ) ) {          if ( !dnIsSuffix( &op->o_req_ndn, &rd->rd_npdn ) ) {
                 if ( RETCODE_INDIR( rd ) ) {                  if ( RETCODE_INDIR( rd ) ) {
                         switch ( op->o_tag ) {                          switch ( op->o_tag ) {
Line 254  retcode_op_func( Operation *op, SlapRepl Line 276  retcode_op_func( Operation *op, SlapRepl
                                 return retcode_op_add( op, rs );                                  return retcode_op_add( op, rs );
   
                         case LDAP_REQ_BIND:                          case LDAP_REQ_BIND:
                                   /* skip if rootdn */
                                 if ( be_isroot_pw( op ) ) {                                  if ( be_isroot_pw( op ) ) {
                                         return SLAP_CB_CONTINUE;                                          return SLAP_CB_CONTINUE;
                                 }                                  }
                                 /* fallthru */                                  return retcode_op_internal( op, rs );
   
                           case LDAP_REQ_SEARCH:
                                   if ( op->ors_scope == LDAP_SCOPE_BASE ) {
                                           rs->sr_err = retcode_op_internal( op, rs );
                                           switch ( rs->sr_err ) {
                                           case SLAP_CB_CONTINUE:
                                                   if ( rs->sr_nentries == 0 ) {
                                                           break;
                                                   }
                                                   rs->sr_err = LDAP_SUCCESS;
                                                   /* fallthru */
   
                                           default:
                                                   send_ldap_result( op, rs );
                                                   break;
                                           }
                                           return rs->sr_err;
                                   }
                                   break;
   
                         case LDAP_REQ_MODIFY:                          case LDAP_REQ_MODIFY:
                         case LDAP_REQ_DELETE:                          case LDAP_REQ_DELETE:
                         case LDAP_REQ_MODRDN:                          case LDAP_REQ_MODRDN:
                         case LDAP_REQ_COMPARE:                          case LDAP_REQ_COMPARE:
                         case LDAP_REQ_SEARCH:  
                                 return retcode_op_internal( op, rs );                                  return retcode_op_internal( op, rs );
                         }                          }
                 }                  }
Line 352  retcode_op_func( Operation *op, SlapRepl Line 393  retcode_op_func( Operation *op, SlapRepl
         } else {          } else {
                 rs->sr_err = rdi->rdi_err;                  rs->sr_err = rdi->rdi_err;
                 rs->sr_text = rdi->rdi_text.bv_val;                  rs->sr_text = rdi->rdi_text.bv_val;
                   rs->sr_matched = rdi->rdi_matched.bv_val;
   
                 /* FIXME: we only honor the rdi_ref field in case rdi_err                  /* FIXME: we only honor the rdi_ref field in case rdi_err
                  * is LDAP_REFERRAL otherwise send_ldap_result() bails out */                   * is LDAP_REFERRAL otherwise send_ldap_result() bails out */
Line 394  retcode_op_func( Operation *op, SlapRepl Line 436  retcode_op_func( Operation *op, SlapRepl
                 send_ldap_result( op, rs );                  send_ldap_result( op, rs );
                 if ( rs->sr_ref != NULL ) {                  if ( rs->sr_ref != NULL ) {
                         ber_bvarray_free( rs->sr_ref );                          ber_bvarray_free( rs->sr_ref );
                           rs->sr_ref = NULL;
                 }                  }
                 rs->sr_matched = NULL;                  rs->sr_matched = NULL;
                 rs->sr_text = NULL;                  rs->sr_text = NULL;
Line 436  retcode_op2str( ber_tag_t op, struct ber Line 479  retcode_op2str( ber_tag_t op, struct ber
 }  }
   
 static int  static int
 retcode_entry_response( Operation *op, SlapReply *rs, Entry *e )  retcode_entry_response( Operation *op, SlapReply *rs, BackendInfo *bi, Entry *e )
 {  {
         slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;  
   
         Attribute       *a;          Attribute       *a;
         int             err;          int             err;
         char            *next;          char            *next;
Line 448  retcode_entry_response( Operation *op, S Line 489  retcode_entry_response( Operation *op, S
                 return SLAP_CB_CONTINUE;                  return SLAP_CB_CONTINUE;
         }          }
   
         if ( !is_entry_objectclass( e, oc_errObject, 0 ) ) {          if ( !is_entry_objectclass_or_sub( e, oc_errAbsObject ) ) {
                 return SLAP_CB_CONTINUE;                  return SLAP_CB_CONTINUE;
         }          }
   
Line 490  retcode_entry_response( Operation *op, S Line 531  retcode_entry_response( Operation *op, S
   
         /* sleep time */          /* sleep time */
         a = attr_find( e->e_attrs, ad_errSleepTime );          a = attr_find( e->e_attrs, ad_errSleepTime );
         if ( a != NULL ) {          if ( a != NULL && a->a_nvals[ 0 ].bv_val[ 0 ] != '-' ) {
                 int     sleepTime;                  int     sleepTime;
   
                 sleepTime = strtoul( a->a_nvals[ 0 ].bv_val, &next, 0 );                  sleepTime = strtoul( a->a_nvals[ 0 ].bv_val, &next, 0 );
Line 500  retcode_entry_response( Operation *op, S Line 541  retcode_entry_response( Operation *op, S
         }          }
   
         if ( rs->sr_err != LDAP_SUCCESS ) {          if ( rs->sr_err != LDAP_SUCCESS ) {
                 BackendDB       db = *op->o_bd;                  BackendDB       db = *op->o_bd,
                                   *o_bd = op->o_bd;
                 void            *o_callback = op->o_callback;                  void            *o_callback = op->o_callback;
   
                 /* message text */                  /* message text */
Line 509  retcode_entry_response( Operation *op, S Line 551  retcode_entry_response( Operation *op, S
                         rs->sr_text = a->a_vals[ 0 ].bv_val;                          rs->sr_text = a->a_vals[ 0 ].bv_val;
                 }                  }
   
                 db.bd_info = on->on_info->oi_orig;                  /* matched DN */
                   a = attr_find( e->e_attrs, ad_errMatchedDN );
                   if ( a != NULL ) {
                           rs->sr_matched = a->a_vals[ 0 ].bv_val;
                   }
   
                   if ( bi == NULL ) {
                           slap_overinst   *on = (slap_overinst *)op->o_bd->bd_info;
   
                           bi = on->on_info->oi_orig;
                   }
   
                   db.bd_info = bi;
                 op->o_bd = &db;                  op->o_bd = &db;
                 op->o_callback = NULL;                  op->o_callback = NULL;
   
Line 533  retcode_entry_response( Operation *op, S Line 587  retcode_entry_response( Operation *op, S
                 }                  }
   
                 rs->sr_text = NULL;                  rs->sr_text = NULL;
                   rs->sr_matched = NULL;
                   op->o_bd = o_bd;
                 op->o_callback = o_callback;                  op->o_callback = o_callback;
         }          }
                   
Line 554  retcode_response( Operation *op, SlapRep Line 610  retcode_response( Operation *op, SlapRep
                 return SLAP_CB_CONTINUE;                  return SLAP_CB_CONTINUE;
         }          }
   
         return retcode_entry_response( op, rs, rs->sr_entry );          return retcode_entry_response( op, rs, NULL, rs->sr_entry );
 }  }
   
 static int  static int
Line 700  retcode_db_config( Line 756  retcode_db_config(
                                                 } else if ( strcasecmp( ops[ j ], "compare" ) == 0 ) {                                                  } else if ( strcasecmp( ops[ j ], "compare" ) == 0 ) {
                                                         rdi.rdi_mask |= SN_DG_OP_COMPARE;                                                          rdi.rdi_mask |= SN_DG_OP_COMPARE;
   
                                                 } else if ( strcasecmp( ops[ j ], "add" ) == 0 ) {                                                  } else if ( strcasecmp( ops[ j ], "delete" ) == 0 ) {
                                                         rdi.rdi_mask |= SN_DG_OP_DELETE;                                                          rdi.rdi_mask |= SN_DG_OP_DELETE;
   
                                                 } else if ( strcasecmp( ops[ j ], "modify" ) == 0 ) {                                                  } else if ( strcasecmp( ops[ j ], "modify" ) == 0 ) {
                                                         rdi.rdi_mask |= SN_DG_OP_MODIFY;                                                          rdi.rdi_mask |= SN_DG_OP_MODIFY;
   
                                                 } else if ( strcasecmp( ops[ j ], "rename" ) == 0 ) {                                                  } else if ( strcasecmp( ops[ j ], "rename" ) == 0
                                                           || strcasecmp( ops[ j ], "modrdn" ) == 0 )
                                                   {
                                                         rdi.rdi_mask |= SN_DG_OP_RENAME;                                                          rdi.rdi_mask |= SN_DG_OP_RENAME;
   
                                                 } else if ( strcasecmp( ops[ j ], "search" ) == 0 ) {                                                  } else if ( strcasecmp( ops[ j ], "search" ) == 0 ) {
Line 746  retcode_db_config( Line 804  retcode_db_config(
                                         }                                          }
                                         ber_str2bv( &argv[ i ][ STRLENOF( "text=" ) ], 0, 1, &rdi.rdi_text );                                          ber_str2bv( &argv[ i ][ STRLENOF( "text=" ) ], 0, 1, &rdi.rdi_text );
   
                                   } else if ( strncasecmp( argv[ i ], "matched=", STRLENOF( "matched=" ) ) == 0 )
                                   {
                                           struct berval   dn;
   
                                           if ( !BER_BVISNULL( &rdi.rdi_matched ) ) {
                                                   fprintf( stderr, "%s: line %d: retcode: "
                                                           "\"matched\" already provided.\n",
                                                           fname, lineno );
                                                   return 1;
                                           }
                                           ber_str2bv( &argv[ i ][ STRLENOF( "matched=" ) ], 0, 0, &dn );
                                           if ( dnPretty( NULL, &dn, &rdi.rdi_matched, NULL ) != LDAP_SUCCESS ) {
                                                   fprintf( stderr, "%s: line %d: retcode: "
                                                           "unable to prettify matched DN \"%s\".\n",
                                                           fname, lineno, &argv[ i ][ STRLENOF( "matched=" ) ] );
                                                   return 1;
                                           }
   
                                 } else if ( strncasecmp( argv[ i ], "ref=", STRLENOF( "ref=" ) ) == 0 )                                  } else if ( strncasecmp( argv[ i ], "ref=", STRLENOF( "ref=" ) ) == 0 )
                                 {                                  {
                                         char            **refs;                                          char            **refs;
Line 816  retcode_db_config( Line 892  retcode_db_config(
         } else if ( strcasecmp( argv0, "indir" ) == 0 ) {          } else if ( strcasecmp( argv0, "indir" ) == 0 ) {
                 rd->rd_flags |= RETCODE_FINDIR;                  rd->rd_flags |= RETCODE_FINDIR;
   
           } else if ( strcasecmp( argv0, "sleep" ) == 0 ) {
                   switch ( argc ) {
                   case 1:
                           fprintf( stderr, "%s: line %d: retcode: "
                                   "\"retcode-sleep <time>\": missing <time>\n",
                                   fname, lineno );
                           return 1;
   
                   case 2:
                           break;
   
                   default:
                           fprintf( stderr, "%s: line %d: retcode: "
                                   "\"retcode-sleep <time>\": extra cruft after <time>\n",
                                   fname, lineno );
                           return 1;
                   }
   
                   if ( lutil_atoi( &rd->rd_sleep, argv[ 1 ] ) != 0 ) {
                           fprintf( stderr, "%s: line %d: retcode: "
                                   "\"retcode-sleep <time>\": unable to parse <time>\n",
                                   fname, lineno );
                           return 1;
                   }
   
         } else {          } else {
                 return SLAP_CONF_UNKNOWN;                  return SLAP_CONF_UNKNOWN;
         }          }
Line 887  retcode_db_open( BackendDB *be ) Line 988  retcode_db_open( BackendDB *be )
                         attr_merge_normalize_one( &rdi->rdi_e, ad_errText, &val[ 0 ], NULL );                          attr_merge_normalize_one( &rdi->rdi_e, ad_errText, &val[ 0 ], NULL );
                 }                  }
   
                   /* matched */
                   if ( !BER_BVISNULL( &rdi->rdi_matched ) ) {
                           val[ 0 ] = rdi->rdi_matched;
   
                           attr_merge_normalize_one( &rdi->rdi_e, ad_errMatchedDN, &val[ 0 ], NULL );
                   }
   
                 /* sleep time */                  /* sleep time */
                 if ( rdi->rdi_sleeptime > 0 ) {                  if ( rdi->rdi_sleeptime > 0 ) {
                         snprintf( buf, sizeof( buf ), "%d", rdi->rdi_sleeptime );                          snprintf( buf, sizeof( buf ), "%d", rdi->rdi_sleeptime );
Line 957  retcode_db_destroy( BackendDB *be ) Line 1065  retcode_db_destroy( BackendDB *be )
                                 ber_memfree( rdi->rdi_text.bv_val );                                  ber_memfree( rdi->rdi_text.bv_val );
                         }                          }
   
                           if ( !BER_BVISNULL( &rdi->rdi_matched ) ) {
                                   ber_memfree( rdi->rdi_matched.bv_val );
                           }
   
                           if ( rdi->rdi_ref ) {
                                   ber_bvarray_free( rdi->rdi_ref );
                           }
   
                         BER_BVZERO( &rdi->rdi_e.e_name );                          BER_BVZERO( &rdi->rdi_e.e_name );
                         BER_BVZERO( &rdi->rdi_e.e_nname );                          BER_BVZERO( &rdi->rdi_e.e_nname );
   
Line 967  retcode_db_destroy( BackendDB *be ) Line 1083  retcode_db_destroy( BackendDB *be )
                         ch_free( rdi );                          ch_free( rdi );
                 }                  }
   
                   if ( !BER_BVISNULL( &rd->rd_pdn ) ) {
                           ber_memfree( rd->rd_pdn.bv_val );
                   }
   
                   if ( !BER_BVISNULL( &rd->rd_npdn ) ) {
                           ber_memfree( rd->rd_npdn.bv_val );
                   }
   
                 ber_memfree( rd );                  ber_memfree( rd );
         }          }
   
Line 977  retcode_db_destroy( BackendDB *be ) Line 1101  retcode_db_destroy( BackendDB *be )
 static  static
 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */  #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */
 int  int
 retcode_init( void )  retcode_initialize( void )
 {  {
         int             i, code;          int             i, code;
         const char      *err;          const char      *err;
Line 1017  retcode_init( void ) Line 1141  retcode_init( void )
                         "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "                          "SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
                         "SINGLE-VALUE )",                          "SINGLE-VALUE )",
                         &ad_errSleepTime },                          &ad_errSleepTime },
                   { "errMatchedDN", "( 1.3.6.1.4.1.4203.666.11.4.1.5 "
                           "NAME ( 'errMatchedDN' ) "
                           "DESC 'Value to be returned as matched DN' "
                           "EQUALITY distinguishedNameMatch "
                           "SYNTAX 1.3.6.1.4.1.1466.115.121.1.12 "
                           "SINGLE-VALUE )",
                           &ad_errMatchedDN },
                 { NULL }                  { NULL }
         };          };
   
Line 1025  retcode_init( void ) Line 1156  retcode_init( void )
                 char            *desc;                  char            *desc;
                 ObjectClass     **oc;                  ObjectClass     **oc;
         } retcode_oc[] = {          } retcode_oc[] = {
                 { "errObject", "( 1.3.6.1.4.1.4203.666.11.4.3.1 "                  { "errAbsObject", "( 1.3.6.1.4.1.4203.666.11.4.3.0 "
                         "NAME ( 'errObject' ) "                          "NAME ( 'errAbsObject' ) "
                         "SUP top STRUCTURAL "                          "SUP top ABSTRACT "
                         "MUST ( errCode ) "                          "MUST ( errCode ) "
                         "MAY ( "                          "MAY ( "
                                 "cn "                                  "cn "
Line 1035  retcode_init( void ) Line 1166  retcode_init( void )
                                 "$ errOp "                                  "$ errOp "
                                 "$ errText "                                  "$ errText "
                                 "$ errSleepTime "                                  "$ errSleepTime "
                                   "$ errMatchedDN "
                         ") )",                          ") )",
                           &oc_errAbsObject },
                   { "errObject", "( 1.3.6.1.4.1.4203.666.11.4.3.1 "
                           "NAME ( 'errObject' ) "
                           "SUP errAbsObject STRUCTURAL "
                           ")",
                         &oc_errObject },                          &oc_errObject },
                   { "errAuxObject", "( 1.3.6.1.4.1.4203.666.11.4.3.2 "
                           "NAME ( 'errAuxObject' ) "
                           "SUP errAbsObject AUXILIARY "
                           ")",
                           &oc_errAuxObject },
                 { NULL }                  { NULL }
         };          };
   
Line 1136  retcode_init( void ) Line 1278  retcode_init( void )
 int  int
 init_module( int argc, char *argv[] )  init_module( int argc, char *argv[] )
 {  {
         return retcode_init();          return retcode_initialize();
 }  }
 #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */  #endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */
   

Removed from v.1.4  
changed lines
  Added in v.1.4.2.9


______________
© Copyright 1998-2020, OpenLDAP Foundation, info@OpenLDAP.org