/* periodically generate a csn and dump it to the error log */
static void
_csngen_gen_tester_main (void *data)
{
CSNGen *gen = (CSNGen*)data;
CSN *csn = NULL;
char buff [CSN_STRSIZE];
int rc;
PR_ASSERT (gen);
while (!s_must_exit)
{
rc = csngen_new_csn (gen, &csn, PR_FALSE);
if (rc != CSN_SUCCESS)
{
slapi_log_err(SLAPI_LOG_ERR, "_csngen_gen_tester_main",
"failed to generate csn; csn error - %d\n", rc);
}
else
{
slapi_log_err(SLAPI_LOG_INFO, "_csngen_gen_tester_main", "generate csn %s\n",
csn_as_string(csn, PR_FALSE, buff));
}
csn_free(&csn);
/* sleep for 30 seconds */
DS_Sleep (PR_SecondsToInterval(10));
}
PR_AtomicDecrement (&s_thread_count);
}
/* simulate clock skew with remote servers that causes
generator to advance its remote offset */
static void
_csngen_remote_tester_main (void *data)
{
CSNGen *gen = (CSNGen*)data;
CSN *csn;
time_t csn_time;
int rc;
PR_ASSERT (gen);
while (!s_must_exit)
{
rc = csngen_new_csn (gen, &csn, PR_FALSE);
if (rc != CSN_SUCCESS)
{
slapi_log_err(SLAPI_LOG_ERR, "_csngen_remote_tester_main",
"Failed to generate csn; csn error - %d\n", rc);
}
else
{
csn_time = csn_get_time(csn);
csn_set_time (csn, csn_time + slapi_rand () % 100);
rc = csngen_adjust_time (gen, csn);
if (rc != CSN_SUCCESS)
{
slapi_log_err(SLAPI_LOG_ERR, "_csngen_remote_tester_main",
"Failed to adjust generator's time; csn error - %d\n", rc);
}
csngen_dump_state (gen);
}
csn_free(&csn);
/* sleep for 30 seconds */
DS_Sleep (PR_SecondsToInterval(60));
}
PR_AtomicDecrement (&s_thread_count);
}
static int
my_ber_scanf_attr (BerElement *ber, Slapi_Attr **attr, PRBool *deleted)
{
char *attrtype = NULL;
CSN *attr_deletion_csn = NULL;
PRBool val_deleted;
char *lasti;
ber_len_t len;
ber_tag_t tag;
char *str = NULL;
int rc;
Slapi_Value *value = NULL;
if (attr == NULL)
{
goto loser;
}
PR_ASSERT (ber && attr && deleted);
/* allocate the attribute */
*attr = slapi_attr_new ();
if (*attr == NULL)
{
goto loser;
}
if (ber_scanf(ber, "{a", &attrtype) == LBER_ERROR) /* Begin sequence for this attr */
{
goto loser;
}
slapi_attr_init(*attr, attrtype);
slapi_ch_free ((void **)&attrtype);
/* The attribute deletion CSN is next and is optional? */
if (ber_peek_tag(ber, &len) == LBER_OCTETSTRING)
{
if (ber_scanf(ber, "a", &str) == LBER_ERROR)
{
goto loser;
}
attr_deletion_csn = csn_new_by_string(str);
slapi_ch_free((void **)&str);
}
if (attr_deletion_csn)
{
rc = attr_set_deletion_csn(*attr, attr_deletion_csn);
csn_free (&attr_deletion_csn);
if (rc != 0)
{
goto loser;
}
}
/* The "attribute deleted" flag is next, and is optional */
if (ber_peek_tag(ber, &len) == LBER_BOOLEAN)
{
if (ber_scanf(ber, "b", deleted) == LBER_DEFAULT)
{
goto loser;
}
}
else /* default is present */
{
*deleted = PR_FALSE;
}
/* loop over the list of attribute values */
for (tag = ber_first_element(ber, &len, &lasti);
tag != LBER_ERROR && tag != LBER_END_OF_SEQORSET;
tag = ber_next_element(ber, &len, lasti))
{
value = NULL;
if (my_ber_scanf_value(ber, &value, &val_deleted) == -1)
{
goto loser;
}
if (val_deleted)
{
/* Add the value to the attribute */
if (attr_add_deleted_value(*attr, value) == -1) /* attr has ownership of value */
{
goto loser;
}
}
else
{
/* Add the value to the attribute */
if (slapi_attr_add_value(*attr, value) == -1) /* attr has ownership of value */
{
goto loser;
}
}
if (value)
slapi_value_free(&value);
}
if (ber_scanf(ber, "}") == LBER_ERROR) /* End sequence for this attribute */
{
goto loser;
}
return 0;
loser:
if (attr && *attr)
slapi_attr_free (attr);
if (value)
slapi_value_free (&value);
slapi_ch_free_string(&attrtype);
slapi_ch_free_string(&str);
return -1;
}
/*
* Get an annotated value from the BerElement. Returns 0 on
* success, -1 on failure.
*/
static int
my_ber_scanf_value(BerElement *ber, Slapi_Value **value, PRBool *deleted)
{
struct berval *attrval = NULL;
ber_len_t len = -1;
ber_tag_t tag;
CSN *csn = NULL;
char csnstring[CSN_STRSIZE + 1];
CSNType csntype;
char *lasti;
PR_ASSERT(ber && value && deleted);
if (NULL == ber && NULL == value)
{
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "my_ber_scanf_value BAD 1\n");
goto loser;
}
*value = NULL;
/* Each value is a sequence */
if (ber_scanf(ber, "{O", &attrval) == LBER_ERROR)
{
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "my_ber_scanf_value BAD 2\n");
goto loser;
}
/* Allocate and fill in the attribute value */
if ((*value = slapi_value_new_berval(attrval)) == NULL)
{
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "my_ber_scanf_value BAD 3\n");
goto loser;
}
/* check if this is a deleted value */
if (ber_peek_tag(ber, &len) == LBER_BOOLEAN)
{
if (ber_scanf(ber, "b", deleted) == LBER_ERROR)
{
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "my_ber_scanf_value BAD 4\n");
goto loser;
}
}
else /* default is present value */
{
*deleted = PR_FALSE;
}
/* Read the sequence of CSNs */
for (tag = ber_first_element(ber, &len, &lasti);
tag != LBER_ERROR && tag != LBER_END_OF_SEQORSET;
tag = ber_next_element(ber, &len, lasti))
{
ber_int_t csntype_tmp;
/* Each CSN is in a sequence that includes a csntype and CSN */
len = CSN_STRSIZE;
if (ber_scanf(ber, "{es}", &csntype_tmp, csnstring, &len) == LBER_ERROR)
{
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "my_ber_scanf_value BAD 7 - bval is %s\n", attrval->bv_val);
goto loser;
}
switch (csntype_tmp)
{
case CSN_TYPE_VALUE_UPDATED_ON_WIRE:
csntype = CSN_TYPE_VALUE_UPDATED;
break;
case CSN_TYPE_VALUE_DELETED_ON_WIRE:
csntype = CSN_TYPE_VALUE_DELETED;
break;
case CSN_TYPE_VALUE_DISTINGUISHED_ON_WIRE:
csntype = CSN_TYPE_VALUE_DISTINGUISHED;
break;
default:
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "Error: preposterous CSN type "
"%d received during total update.\n", csntype_tmp);
goto loser;
}
csn = csn_new_by_string(csnstring);
if (csn == NULL)
{
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "my_ber_scanf_value BAD 8\n");
goto loser;
}
value_add_csn(*value, csntype, csn);
csn_free (&csn);
}
if (ber_scanf(ber, "}") == LBER_ERROR) /* End of annotated attribute value seq */
{
slapi_log_error(SLAPI_LOG_FATAL, repl_plugin_name, "my_ber_scanf_value BAD 10\n");
goto loser;
}
if (attrval)
ber_bvfree(attrval);
return 0;
loser:
/* Free any stuff we allocated */
if (csn)
csn_free (&csn);
if (attrval)
ber_bvfree(attrval);
if (value)
{
slapi_value_free (value);
}
return -1;
}