/* ADDITION
* Input: Three ints (A, B, C) representing registers
*
* This function adds the values found at register
* B and C and places the resulting uint32_t into
* register A.
*
* Output: N/A
*/
void addition(int A, int B, int C)
{
uint32_t b = register_at(B);
uint32_t c = register_at(C);
uint32_t word = (b + c);
assign_to_register(word, A);
}
/* MULTIPLICATION
* Input: Three ints (A, B, C) representing registers
*
* This function multiplies the values found at register
* B and C and places the resulting uint32_t into
* register A.
*
* Output: N/A
*/
void multiplication(int A, int B, int C)
{
uint32_t b = register_at(B);
uint32_t c = register_at(C);
uint32_t word = (b * c);
assign_to_register(word, A);
}
/* BITWISE_NAND
* Input: Three ints (A, B, C) representing registers
*
* This function bitwisenands the values found at register
* B and C and places the resulting uint32_t into
* register A.
*
* Output: N/A
*/
void bitwise_nand(int A, int B, int C)
{
uint32_t b = register_at(B);
uint32_t c = register_at(C);
uint32_t word = ~(b & c);
assign_to_register(word, A);
}
/* SEGMENTED_LOAD
* Input: Three ints (A, B, C) representing registers
*
* This function returns the segment found in the segment
* memory sequence at the id found in register B. The
* uint32_t word found at offset found in register C is
* then placed in register A.
*
* Output: N/A
*/
void segmented_load(int A, int B, int C)
{
// fprintf(stderr, "in seg load\n");
uint32_t b = register_at(B);
uint32_t c = register_at(C);
Seg_array seg_array = SEG_MEMORY[b];
assign_to_register(seg_array->segment[(int)c], A);
}
/* CONDITIONAL_MOVE
* Input: Three ints (A, B, C) representing registers
*
* This function checks to see if the word at
* register C != 0. If it does the operation does
* does nothing, if it doesn't equal zero the value
* found at register B is placed in register A
*
* Output: N/A
*/
void conditional_move(int A, int B, int C)
{
uint32_t b = register_at(B);
uint32_t c = register_at(C);
if (c != 0){
assign_to_register(b, A);
}
}
/* SEGMENTED_STORE
* Input: Three ints (A, B, C) representing registers
*
* This function returns the segment found in the segment
* memory sequence at the id found in register A. The
* uint32_t word found at register C is then placed
* in the segment at the offset found in register B
*
* Output: N/A
*/
void segmented_store(int A, int B, int C)
{
// fprintf(stderr, "in seg store\n");
uint32_t a = register_at(A);
uint32_t b = register_at(B);
uint32_t c = register_at(C);
Seg_array seg_array = SEG_MEMORY[a];
if (seg_array->segment[b] == 0) {
seg_array->num_elements++;
}
seg_array->segment[b] = c;
}
/*
* call from within bdb_initialize()
*/
static int
bdb_monitor_initialize( void )
{
int i, code;
ConfigArgs c;
char *argv[ 3 ];
static int bdb_monitor_initialized = 0;
if ( backend_info( "monitor" ) == NULL ) {
return -1;
}
if ( bdb_monitor_initialized++ ) {
return 0;
}
/* register schema here */
argv[ 0 ] = "back-bdb/back-hdb monitor";
c.argv = argv;
c.argc = 3;
c.fname = argv[0];
for ( i = 0; s_oid[ i ].name; i++ ) {
c.lineno = i;
argv[ 1 ] = s_oid[ i ].name;
argv[ 2 ] = s_oid[ i ].oid;
if ( parse_oidm( &c, 0, NULL ) != 0 ) {
Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
": unable to add "
"objectIdentifier \"%s=%s\"\n",
s_oid[ i ].name, s_oid[ i ].oid, 0 );
return 1;
}
}
for ( i = 0; s_at[ i ].desc != NULL; i++ ) {
code = register_at( s_at[ i ].desc, s_at[ i ].ad, 1 );
if ( code != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
": register_at failed\n",
0, 0, 0 );
}
(*s_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE;
}
for ( i = 0; s_oc[ i ].desc != NULL; i++ ) {
code = register_oc( s_oc[ i ].desc, s_oc[ i ].oc, 1 );
if ( code != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
": register_oc failed\n",
0, 0, 0 );
}
(*s_oc[ i ].oc)->soc_flags |= SLAP_OC_HIDE;
}
return 0;
}
int lastbind_initialize()
{
int i, code;
/* register operational schema for this overlay (authTimestamp attribute) */
for (i=0; lastBind_OpSchema[i].def; i++) {
code = register_at( lastBind_OpSchema[i].def, lastBind_OpSchema[i].ad, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"lastbind_initialize: register_at failed\n" );
return code;
}
}
ad_authTimestamp->ad_type->sat_flags |= SLAP_AT_MANAGEABLE;
lastbind.on_bi.bi_type = "lastbind";
lastbind.on_bi.bi_db_init = lastbind_db_init;
lastbind.on_bi.bi_db_close = lastbind_db_close;
lastbind.on_bi.bi_op_bind = lastbind_bind;
/* register configuration directives */
lastbind.on_bi.bi_cf_ocs = lastbindocs;
code = config_register_schema( lastbindcfg, lastbindocs );
if ( code ) return code;
return overlay_register( &lastbind );
}
int
vernum_initialize(void)
{
int code, i;
for ( i = 0; as[ i ].desc != NULL; i++ ) {
code = register_at( as[ i ].desc, as[ i ].adp, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"vernum_initialize: register_at #%d failed\n",
i, 0, 0 );
return code;
}
/* Allow Manager to set these as needed */
if ( is_at_no_user_mod( (*as[ i ].adp)->ad_type ) ) {
(*as[ i ].adp)->ad_type->sat_flags |=
SLAP_AT_MANAGEABLE;
}
}
vernum.on_bi.bi_type = "vernum";
vernum.on_bi.bi_op_add = vernum_op_add;
vernum.on_bi.bi_op_modify = vernum_op_modify;
vernum.on_bi.bi_db_init = vernum_db_init;
vernum.on_bi.bi_db_open = vernum_db_open;
vernum.on_bi.bi_db_destroy = vernum_db_destroy;
return overlay_register( &vernum );
}
void map_segment(int A, int B, int C)
{
// fprintf(stderr, "in map seg\n");
(void) A;
uint32_t c = register_at(C);
Seg_array seg_array = initialize_seg_array((int)c);
uint32_t id = 0;
// fprintf(stderr, "before resize\n");
if (SEG_NUM + 1 >= SEG_LENGTH){
// fprintf(stderr, "in resize\n");
resize_seg_mem(SEG_LENGTH * 2);
}
// fprintf(stderr, "after resize\n");
if (Seq_length(UNMAP_SEG) == 0){
id = SEG_NUM + 1;
SEG_NUM++;
}
else {
id = (uint32_t)(uintptr_t)Seq_remlo(UNMAP_SEG);
}
assign_to_register(id, B);
// fprintf(stderr, "id: %u, seg_num: %d, mem_length: %d\n", id, SEG_NUM, UArray_length(SEG_MEMORY));
SEG_MEMORY[id] = seg_array;
//fprintf(stderr, "after seg\n");
}
int
pguid_initialize(void)
{
int code, i;
for ( i = 0; as[ i ].desc != NULL; i++ ) {
code = register_at( as[ i ].desc, as[ i ].adp, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"pguid_initialize: register_at #%d failed\n",
i, 0, 0 );
return code;
}
/* Allow Manager to set these as needed */
if ( is_at_no_user_mod( (*as[ i ].adp)->ad_type ) ) {
(*as[ i ].adp)->ad_type->sat_flags |=
SLAP_AT_MANAGEABLE;
}
}
pguid.on_bi.bi_type = "pguid";
pguid.on_bi.bi_op_add = pguid_op_add;
pguid.on_bi.bi_op_modrdn = pguid_op_rename;
pguid.on_bi.bi_db_init = pguid_db_init;
pguid.on_bi.bi_db_open = pguid_db_open;
return overlay_register( &pguid );
}
static
#endif /* SLAPD_OVER_ALLOWED == SLAPD_MOD_DYNAMIC */
int
aa_initialize( void )
{
int i;
aa.on_bi.bi_type = "allowed";
aa.on_bi.bi_operational = aa_operational;
/* aa schema integration */
for ( i = 0; aa_attrs[i].at; i++ ) {
int code;
code = register_at( aa_attrs[i].at, aa_attrs[i].ad, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"aa_initialize: register_at failed\n", 0, 0, 0 );
return -1;
}
}
return overlay_register( &aa );
}
int
usn_init( void )
{
int i, code;
memset( &usn, 0, sizeof( slap_overinst ) );
usn.on_bi.bi_type = "usn";
usn.on_bi.bi_db_init = usn_db_init;
usn.on_bi.bi_db_destroy = usn_db_destroy;
usn.on_bi.bi_db_open = usn_db_open;
usn.on_bi.bi_db_close = usn_db_close;
usn.on_bi.bi_op_modify = usn_func;
usn.on_bi.bi_op_modrdn = usn_func;
usn.on_bi.bi_op_add = usn_func;
usn.on_bi.bi_op_delete = usn_func;
usn.on_bi.bi_operational = usn_operational;
for ( i = 0; as[i].desc; i++ ) {
code = register_at( as[i].desc, as[i].adp, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"usn_init: register_at #%d failed\n", i, 0, 0 );
return code;
}
}
return overlay_register( &usn );
}
/*
* call from within ldap_back_initialize()
*/
static int
ldap_back_monitor_initialize( void )
{
int i, code;
ConfigArgs c;
char *argv[ 3 ];
static int ldap_back_monitor_initialized = 0;
/* register schema here; if compiled as dynamic object,
* must be loaded __after__ back_monitor.la */
if ( ldap_back_monitor_initialized++ ) {
return 0;
}
if ( backend_info( "monitor" ) == NULL ) {
return -1;
}
argv[ 0 ] = "back-ldap monitor";
c.argv = argv;
c.argc = 3;
c.fname = argv[0];
for ( i = 0; s_oid[ i ].name; i++ ) {
argv[ 1 ] = s_oid[ i ].name;
argv[ 2 ] = s_oid[ i ].oid;
if ( parse_oidm( &c, 0, NULL ) != 0 ) {
Debug( LDAP_DEBUG_ANY,
"ldap_back_monitor_initialize: unable to add "
"objectIdentifier \"%s=%s\"\n",
s_oid[ i ].name, s_oid[ i ].oid, 0 );
return 1;
}
}
for ( i = 0; s_at[ i ].desc != NULL; i++ ) {
code = register_at( s_at[ i ].desc, s_at[ i ].ad, 1 );
if ( code != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"ldap_back_monitor_initialize: register_at failed\n",
0, 0, 0 );
}
}
for ( i = 0; s_oc[ i ].desc != NULL; i++ ) {
code = register_oc( s_oc[ i ].desc, s_oc[ i ].oc, 1 );
if ( code != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"ldap_back_monitor_initialize: register_oc failed\n",
0, 0, 0 );
}
}
return 0;
}
/* OUTPUT
* Input: Three ints (A, B, C) representing registers
*
* This function returns the uint32_t found at from
* register C and pulls the char with lsb 0 out of the
* word and prints it to stdout.
*
* Output: N/A
*/
void output(int A, int B, int C)
{
(void) A;
(void) B;
uint32_t word = register_at(C);
char s = 0;
s = Bitpack_getu(word, 8, 0);
putchar(s);
}
/* UNMAP_SEGMENT
* Input: Three ints (A, B, C) representing registers
*
* This function returns the segment found in the segment
* memory sequence at the id found in register C. A NULL
* character is placed at that space in the segment_memory
* and that id is placed in the unmapped id sequence.
*
* Output: N/A
*/
void unmap_segment(int A, int B, int C)
{
// fprintf(stderr, "in unmap seg\n");
(void) A;
(void) B;
uint32_t c = register_at(C);
Seg_array seg_array = SEG_MEMORY[c];
SEG_MEMORY[c] = 0;
FREE(seg_array->segment);
FREE(seg_array);
Seq_addhi(UNMAP_SEG, (void *)(uintptr_t)c);
}
/* LOAD_PROGRAM
* Input: Three ints (A, B, C) representing registers
* Seq_T segment = (Seq_T)Seq_get(SEGMEMORY, 0);
* This function searches for the segment at the id
* found in register B. If the id is zero, the counter
* to the value found in register C. If the id is not
* the instruction code segment is freed and the
* segment at id is duplicated and placed in the 0th
* position in the segment_memory sequence.
*
* Output: N/A
*/
void load_program(int A, int B, int C)
{
// fprintf(stderr, "in load prog\n");
(void) A;
uint32_t b = register_at(B);
uint32_t c = register_at(C);
if (b == 0){
uint32_t c = register_at(C);
if (c == 0)
assign_counter(-1);
else
assign_counter(c - 1);
return;
}
Seg_array seg_array = SEG_MEMORY[b];
Seg_array new_seg_array = array_copy(seg_array);
Seg_array inst_seg_array = SEG_MEMORY[0];
FREE(inst_seg_array);
SEG_MEMORY[0] = new_seg_array;
if (c == 0)
assign_counter(-1);
assign_counter(c - 1);
}
int autoca_initialize() {
int i, code;
autoca.on_bi.bi_type = "autoca";
autoca.on_bi.bi_db_init = autoca_db_init;
autoca.on_bi.bi_db_destroy = autoca_db_destroy;
autoca.on_bi.bi_db_open = autoca_db_open;
autoca.on_bi.bi_op_search = autoca_op_search;
autoca.on_bi.bi_cf_ocs = autoca_ocs;
code = config_register_schema( autoca_cfg, autoca_ocs );
if ( code ) return code;
for ( i=0; aca_attrs[i]; i++ ) {
code = register_at( aca_attrs[i], NULL, 0 );
if ( code ) return code;
}
return overlay_register( &autoca );
}
int
rdnval_initialize(void)
{
int code, i;
for ( i = 0; as[ i ].desc != NULL; i++ ) {
code = register_at( as[ i ].desc, as[ i ].adp, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"rdnval_initialize: register_at #%d failed\n",
i, 0, 0 );
return code;
}
/* Allow Manager to set these as needed */
if ( is_at_no_user_mod( (*as[ i ].adp)->ad_type ) ) {
(*as[ i ].adp)->ad_type->sat_flags |=
SLAP_AT_MANAGEABLE;
}
}
syn_IA5String = syn_find( "1.3.6.1.4.1.1466.115.121.1.26" );
if ( syn_IA5String == NULL ) {
Debug( LDAP_DEBUG_ANY,
"rdnval_initialize: unable to find syntax '1.3.6.1.4.1.1466.115.121.1.26' (IA5String)\n",
0, 0, 0 );
return LDAP_OTHER;
}
rdnval.on_bi.bi_type = "rdnval";
rdnval.on_bi.bi_op_add = rdnval_op_add;
rdnval.on_bi.bi_op_modrdn = rdnval_op_rename;
rdnval.on_bi.bi_db_init = rdnval_db_init;
rdnval.on_bi.bi_db_open = rdnval_db_open;
return overlay_register( &rdnval );
}
static
#endif /* SLAPD_OVER_RETCODE == SLAPD_MOD_DYNAMIC */
int
retcode_initialize( void )
{
int i, code;
static struct {
char *desc;
AttributeDescription **ad;
} retcode_at[] = {
{ "( 1.3.6.1.4.1.4203.666.11.4.1.1 "
"NAME ( 'errCode' ) "
"DESC 'LDAP error code' "
"EQUALITY integerMatch "
"ORDERING integerOrderingMatch "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
"SINGLE-VALUE )",
&ad_errCode },
{ "( 1.3.6.1.4.1.4203.666.11.4.1.2 "
"NAME ( 'errOp' ) "
"DESC 'Operations the errObject applies to' "
"EQUALITY caseIgnoreMatch "
"SUBSTR caseIgnoreSubstringsMatch "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 )",
&ad_errOp},
{ "( 1.3.6.1.4.1.4203.666.11.4.1.3 "
"NAME ( 'errText' ) "
"DESC 'LDAP error textual description' "
"EQUALITY caseIgnoreMatch "
"SUBSTR caseIgnoreSubstringsMatch "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.15 "
"SINGLE-VALUE )",
&ad_errText },
{ "( 1.3.6.1.4.1.4203.666.11.4.1.4 "
"NAME ( 'errSleepTime' ) "
"DESC 'Time to wait before returning the error' "
"EQUALITY integerMatch "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.27 "
"SINGLE-VALUE )",
&ad_errSleepTime },
{ "( 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 },
{ "( 1.3.6.1.4.1.4203.666.11.4.1.6 "
"NAME ( 'errUnsolicitedOID' ) "
"DESC 'OID to be returned within unsolicited response' "
"EQUALITY objectIdentifierMatch "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.38 "
"SINGLE-VALUE )",
&ad_errUnsolicitedOID },
{ "( 1.3.6.1.4.1.4203.666.11.4.1.7 "
"NAME ( 'errUnsolicitedData' ) "
"DESC 'Data to be returned within unsolicited response' "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.40 "
"SINGLE-VALUE )",
&ad_errUnsolicitedData },
{ "( 1.3.6.1.4.1.4203.666.11.4.1.8 "
"NAME ( 'errDisconnect' ) "
"DESC 'Disconnect without notice' "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.7 "
"SINGLE-VALUE )",
&ad_errDisconnect },
{ NULL }
};
static struct {
char *desc;
ObjectClass **oc;
} retcode_oc[] = {
{ "( 1.3.6.1.4.1.4203.666.11.4.3.0 "
"NAME ( 'errAbsObject' ) "
"SUP top ABSTRACT "
"MUST ( errCode ) "
"MAY ( "
"cn "
"$ description "
"$ errOp "
"$ errText "
"$ errSleepTime "
"$ errMatchedDN "
"$ errUnsolicitedOID "
"$ errUnsolicitedData "
"$ errDisconnect "
") )",
&oc_errAbsObject },
{ "( 1.3.6.1.4.1.4203.666.11.4.3.1 "
"NAME ( 'errObject' ) "
"SUP errAbsObject STRUCTURAL "
")",
&oc_errObject },
{ "( 1.3.6.1.4.1.4203.666.11.4.3.2 "
"NAME ( 'errAuxObject' ) "
"SUP errAbsObject AUXILIARY "
")",
&oc_errAuxObject },
{ NULL }
};
for ( i = 0; retcode_at[ i ].desc != NULL; i++ ) {
code = register_at( retcode_at[ i ].desc, retcode_at[ i ].ad, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"retcode: register_at failed\n" );
return code;
}
(*retcode_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE;
}
for ( i = 0; retcode_oc[ i ].desc != NULL; i++ ) {
code = register_oc( retcode_oc[ i ].desc, retcode_oc[ i ].oc, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"retcode: register_oc failed\n" );
return code;
}
(*retcode_oc[ i ].oc)->soc_flags |= SLAP_OC_HIDE;
}
retcode.on_bi.bi_type = "retcode";
retcode.on_bi.bi_db_init = retcode_db_init;
retcode.on_bi.bi_db_open = retcode_db_open;
retcode.on_bi.bi_db_destroy = retcode_db_destroy;
retcode.on_bi.bi_op_add = retcode_op_func;
retcode.on_bi.bi_op_bind = retcode_op_func;
retcode.on_bi.bi_op_compare = retcode_op_func;
retcode.on_bi.bi_op_delete = retcode_op_func;
retcode.on_bi.bi_op_modify = retcode_op_func;
retcode.on_bi.bi_op_modrdn = retcode_op_func;
retcode.on_bi.bi_op_search = retcode_op_func;
retcode.on_bi.bi_extended = retcode_op_func;
retcode.on_response = retcode_response;
retcode.on_bi.bi_cf_ocs = rcocs;
code = config_register_schema( rccfg, rcocs );
if ( code ) {
return code;
}
return overlay_register( &retcode );
}
Assembler::Register top_of_stack_register() { return register_at(top_of_stack()); }
/*
* call from within bdb_initialize()
*/
static int
bdb_monitor_initialize( void )
{
int i, code;
ConfigArgs c;
char *argv[ 3 ];
static int bdb_monitor_initialized = 0;
/* set to 0 when successfully initialized; otherwise, remember failure */
static int bdb_monitor_initialized_failure = 1;
if ( bdb_monitor_initialized++ ) {
return bdb_monitor_initialized_failure;
}
if ( backend_info( "monitor" ) == NULL ) {
return -1;
}
/* register schema here */
argv[ 0 ] = "back-bdb/back-hdb monitor";
c.argv = argv;
c.argc = 3;
c.fname = argv[0];
for ( i = 0; s_oid[ i ].name; i++ ) {
c.lineno = i;
argv[ 1 ] = s_oid[ i ].name;
argv[ 2 ] = s_oid[ i ].oid;
if ( parse_oidm( &c, 0, NULL ) != 0 ) {
Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
": unable to add "
"objectIdentifier \"%s=%s\"\n",
s_oid[ i ].name, s_oid[ i ].oid, 0 );
return 2;
}
}
for ( i = 0; s_at[ i ].desc != NULL; i++ ) {
code = register_at( s_at[ i ].desc, s_at[ i ].ad, 1 );
if ( code != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
": register_at failed for attributeType (%s)\n",
s_at[ i ].desc, 0, 0 );
return 3;
} else {
(*s_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE;
}
}
for ( i = 0; s_oc[ i ].desc != NULL; i++ ) {
code = register_oc( s_oc[ i ].desc, s_oc[ i ].oc, 1 );
if ( code != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY, LDAP_XSTRING(bdb_monitor_initialize)
": register_oc failed for objectClass (%s)\n",
s_oc[ i ].desc, 0, 0 );
return 4;
} else {
(*s_oc[ i ].oc)->soc_flags |= SLAP_OC_HIDE;
}
}
return ( bdb_monitor_initialized_failure = LDAP_SUCCESS );
}
void pop(Assembler::Register reg) {
GUARANTEE(register_at(top_of_stack()) == reg, "Can only pop register at top of stack");
pop();
}
Assembler::Register register_for(int index) {
GUARANTEE(0 < index && index <= top_of_stack(), "Index out of bounds");
return register_at(top_of_stack() - index);
}
static int
aci_init( void )
{
/* OpenLDAP eXperimental Syntax */
static slap_syntax_defs_rec aci_syntax_def = {
"( 1.3.6.1.4.1.4203.666.2.1 DESC 'OpenLDAP Experimental ACI' )",
SLAP_SYNTAX_HIDE,
NULL,
OpenLDAPaciValidate,
OpenLDAPaciPretty
};
static slap_mrule_defs_rec aci_mr_def = {
"( 1.3.6.1.4.1.4203.666.4.2 NAME 'OpenLDAPaciMatch' "
"SYNTAX 1.3.6.1.4.1.4203.666.2.1 )",
SLAP_MR_HIDE | SLAP_MR_EQUALITY, NULL,
NULL, OpenLDAPaciNormalize, OpenLDAPaciMatch,
NULL, NULL,
NULL
};
static struct {
char *name;
char *desc;
slap_mask_t flags;
AttributeDescription **ad;
} aci_at = {
"OpenLDAPaci", "( 1.3.6.1.4.1.4203.666.1.5 "
"NAME 'OpenLDAPaci' "
"DESC 'OpenLDAP access control information (experimental)' "
"EQUALITY OpenLDAPaciMatch "
"SYNTAX 1.3.6.1.4.1.4203.666.2.1 "
"USAGE directoryOperation )",
SLAP_AT_HIDE,
&slap_ad_aci
};
int rc;
/* ACI syntax */
rc = register_syntax( &aci_syntax_def );
if ( rc != 0 ) {
return rc;
}
/* ACI equality rule */
rc = register_matching_rule( &aci_mr_def );
if ( rc != 0 ) {
return rc;
}
/* ACI attribute */
rc = register_at( aci_at.desc, aci_at.ad, 0 );
if ( rc != LDAP_SUCCESS ) {
Debug( LDAP_DEBUG_ANY,
"aci_init: at_register failed\n" );
return rc;
}
/* install flags */
(*aci_at.ad)->ad_type->sat_flags |= aci_at.flags;
return rc;
}
static
#endif /* SLAPD_OVER_DDS == SLAPD_MOD_DYNAMIC */
int
dds_initialize()
{
int rc = 0;
int i, code;
/* Make sure we don't exceed the bits reserved for userland */
config_check_userland( DDS_LAST );
if ( !do_not_load_schema ) {
static struct {
char *desc;
slap_mask_t flags;
AttributeDescription **ad;
} s_at[] = {
{ "( 1.3.6.1.4.1.4203.666.1.57 "
"NAME ( 'entryExpireTimestamp' ) "
"DESC 'RFC2589 OpenLDAP extension: expire time of a dynamic object, "
"computed as now + entryTtl' "
"EQUALITY generalizedTimeMatch "
"ORDERING generalizedTimeOrderingMatch "
"SYNTAX 1.3.6.1.4.1.1466.115.121.1.24 "
"SINGLE-VALUE "
"NO-USER-MODIFICATION "
"USAGE dSAOperation )",
SLAP_AT_HIDE,
&ad_entryExpireTimestamp },
{ NULL }
};
for ( i = 0; s_at[ i ].desc != NULL; i++ ) {
code = register_at( s_at[ i ].desc, s_at[ i ].ad, 0 );
if ( code ) {
Debug( LDAP_DEBUG_ANY,
"dds_initialize: register_at failed\n" );
return code;
}
(*s_at[ i ].ad)->ad_type->sat_flags |= SLAP_AT_HIDE;
}
}
if ( !do_not_load_exop ) {
rc = load_extop2( (struct berval *)&slap_EXOP_REFRESH,
SLAP_EXOP_WRITES|SLAP_EXOP_HIDE, slap_exop_refresh,
!do_not_replace_exop );
if ( rc != LDAP_SUCCESS ) {
Log1( LDAP_DEBUG_ANY, LDAP_LEVEL_ERR,
"DDS unable to register refresh exop: %d.\n",
rc );
return rc;
}
}
dds.on_bi.bi_type = "dds";
dds.on_bi.bi_db_init = dds_db_init;
dds.on_bi.bi_db_open = dds_db_open;
dds.on_bi.bi_db_close = dds_db_close;
dds.on_bi.bi_db_destroy = dds_db_destroy;
dds.on_bi.bi_op_add = dds_op_add;
dds.on_bi.bi_op_delete = dds_op_delete;
dds.on_bi.bi_op_modify = dds_op_modify;
dds.on_bi.bi_op_modrdn = dds_op_rename;
dds.on_bi.bi_extended = dds_op_extended;
dds.on_bi.bi_cf_ocs = dds_ocs;
rc = config_register_schema( dds_cfg, dds_ocs );
if ( rc ) {
return rc;
}
return overlay_register( &dds );
}
