/* Relink all lights that are so marked. */
void relink_light_sources(boolean ghostly, struct level *lev)
{
char which;
unsigned nid;
light_source *ls;
for (ls = lev->lev_lights; ls; ls = ls->next) {
if (ls->flags & LSF_NEEDS_FIXUP) {
if (ls->type == LS_OBJECT || ls->type == LS_MONSTER) {
if (ghostly) {
if (!lookup_id_mapping((long)ls->id, &nid))
impossible("relink_light_sources: no id mapping");
} else
nid = (long) ls->id;
if (ls->type == LS_OBJECT) {
which = 'o';
ls->id = find_oid(nid);
} else {
which = 'm';
ls->id = find_mid(lev, nid, FM_EVERYWHERE);
}
if (!ls->id)
impossible("relink_light_sources: cant find %c_id %d",
which, nid);
} else
impossible("relink_light_sources: bad type (%d)", ls->type);
ls->flags &= ~LSF_NEEDS_FIXUP;
}
}
}
struct oid_store *find_oid_name(struct oid_store *xoid, char *name, int num)
{
int i;
struct oid_store *ret;
ret = xoid;
for (i=0; i<num; i++) {
ret = find_oid(ret, name[i]);
if(ret == NULL) {
break;
}
}
return ret;
}
/* Convert a structured DN from an X.509 certificate into an LDAPV3 DN.
* x509_name must be raw DER. If func is non-NULL, the
* constructed DN will use numeric OIDs to identify attributeTypes,
* and the func() will be invoked to rewrite the DN with the given
* flags.
*
* Otherwise the DN will use shortNames from a hardcoded table.
*/
int
ldap_X509dn2bv( void *x509_name, struct berval *bv, LDAPDN_rewrite_func *func,
unsigned flags )
{
LDAPDN newDN;
LDAPRDN newRDN;
LDAPAVA *newAVA, *baseAVA;
BerElementBuffer berbuf;
BerElement *ber = (BerElement *)&berbuf;
char oids[8192], *oidptr = oids, *oidbuf = NULL;
void *ptrs[2048];
char *dn_end, *rdn_end;
int i, navas, nrdns, rc = LDAP_SUCCESS;
size_t dnsize, oidrem = sizeof(oids), oidsize = 0;
int csize;
ber_tag_t tag;
ber_len_t len;
oid_name *oidname;
struct berval Oid, Val, oid2, *in = x509_name;
assert( bv != NULL );
bv->bv_len = 0;
bv->bv_val = NULL;
navas = 0;
nrdns = 0;
/* A DN is a SEQUENCE of RDNs. An RDN is a SET of AVAs.
* An AVA is a SEQUENCE of attr and value.
* Count the number of AVAs and RDNs
*/
ber_init2( ber, in, LBER_USE_DER );
tag = ber_peek_tag( ber, &len );
if ( tag != LBER_SEQUENCE )
return LDAP_DECODING_ERROR;
for ( tag = ber_first_element( ber, &len, &dn_end );
tag == LBER_SET;
tag = ber_next_element( ber, &len, dn_end )) {
nrdns++;
for ( tag = ber_first_element( ber, &len, &rdn_end );
tag == LBER_SEQUENCE;
tag = ber_next_element( ber, &len, rdn_end )) {
tag = ber_skip_tag( ber, &len );
ber_skip_data( ber, len );
navas++;
}
}
/* Allocate the DN/RDN/AVA stuff as a single block */
dnsize = sizeof(LDAPRDN) * (nrdns+1);
dnsize += sizeof(LDAPAVA *) * (navas+nrdns);
dnsize += sizeof(LDAPAVA) * navas;
if (dnsize > sizeof(ptrs)) {
newDN = (LDAPDN)LDAP_MALLOC( dnsize );
if ( newDN == NULL )
return LDAP_NO_MEMORY;
} else {
newDN = (LDAPDN)(char *)ptrs;
}
newDN[nrdns] = NULL;
newRDN = (LDAPRDN)(newDN + nrdns+1);
newAVA = (LDAPAVA *)(newRDN + navas + nrdns);
baseAVA = newAVA;
/* Rewind and start extracting */
ber_rewind( ber );
tag = ber_first_element( ber, &len, &dn_end );
for ( i = nrdns - 1; i >= 0; i-- ) {
newDN[i] = newRDN;
for ( tag = ber_first_element( ber, &len, &rdn_end );
tag == LBER_SEQUENCE;
tag = ber_next_element( ber, &len, rdn_end )) {
*newRDN++ = newAVA;
tag = ber_skip_tag( ber, &len );
tag = ber_get_stringbv( ber, &Oid, LBER_BV_NOTERM );
if ( tag != LBER_TAG_OID ) {
rc = LDAP_DECODING_ERROR;
goto nomem;
}
oid2.bv_val = oidptr;
oid2.bv_len = oidrem;
if ( ber_decode_oid( &Oid, &oid2 ) < 0 ) {
rc = LDAP_DECODING_ERROR;
goto nomem;
}
oidname = find_oid( &oid2 );
if ( !oidname ) {
newAVA->la_attr = oid2;
oidptr += oid2.bv_len + 1;
oidrem -= oid2.bv_len + 1;
/* Running out of OID buffer space? */
if (oidrem < 128) {
if ( oidsize == 0 ) {
oidsize = sizeof(oids) * 2;
oidrem = oidsize;
oidbuf = LDAP_MALLOC( oidsize );
if ( oidbuf == NULL ) goto nomem;
oidptr = oidbuf;
} else {
char *old = oidbuf;
oidbuf = LDAP_REALLOC( oidbuf, oidsize*2 );
if ( oidbuf == NULL ) goto nomem;
/* Buffer moved! Fix AVA pointers */
if ( old != oidbuf ) {
LDAPAVA *a;
long dif = oidbuf - old;
for (a=baseAVA; a<=newAVA; a++){
if (a->la_attr.bv_val >= old &&
a->la_attr.bv_val <= (old + oidsize))
a->la_attr.bv_val += dif;
}
}
oidptr = oidbuf + oidsize - oidrem;
oidrem += oidsize;
oidsize *= 2;
}
}
} else {
if ( func ) {
newAVA->la_attr = oidname->oid;
} else {
newAVA->la_attr = oidname->name;
}
}
newAVA->la_private = NULL;
newAVA->la_flags = LDAP_AVA_STRING;
tag = ber_get_stringbv( ber, &Val, LBER_BV_NOTERM );
switch(tag) {
case LBER_TAG_UNIVERSAL:
/* This uses 32-bit ISO 10646-1 */
csize = 4; goto to_utf8;
case LBER_TAG_BMP:
/* This uses 16-bit ISO 10646-1 */
csize = 2; goto to_utf8;
case LBER_TAG_TELETEX:
/* This uses 8-bit, assume ISO 8859-1 */
csize = 1;
to_utf8: rc = ldap_ucs_to_utf8s( &Val, csize, &newAVA->la_value );
newAVA->la_flags |= LDAP_AVA_NONPRINTABLE;
allocd:
newAVA->la_flags |= LDAP_AVA_FREE_VALUE;
if (rc != LDAP_SUCCESS) goto nomem;
break;
case LBER_TAG_UTF8:
newAVA->la_flags |= LDAP_AVA_NONPRINTABLE;
/* This is already in UTF-8 encoding */
case LBER_TAG_IA5:
case LBER_TAG_PRINTABLE:
/* These are always 7-bit strings */
newAVA->la_value = Val;
break;
case LBER_BITSTRING:
/* X.690 bitString value converted to RFC4517 Bit String */
rc = der_to_ldap_BitString( &Val, &newAVA->la_value );
goto allocd;
default:
/* Not a string type at all */
newAVA->la_flags = 0;
newAVA->la_value = Val;
break;
}
newAVA++;
}
*newRDN++ = NULL;
tag = ber_next_element( ber, &len, dn_end );
}
if ( func ) {
rc = func( newDN, flags, NULL );
if ( rc != LDAP_SUCCESS )
goto nomem;
}
rc = ldap_dn2bv_x( newDN, bv, LDAP_DN_FORMAT_LDAPV3, NULL );
nomem:
for (;baseAVA < newAVA; baseAVA++) {
if (baseAVA->la_flags & LDAP_AVA_FREE_ATTR)
LDAP_FREE( baseAVA->la_attr.bv_val );
if (baseAVA->la_flags & LDAP_AVA_FREE_VALUE)
LDAP_FREE( baseAVA->la_value.bv_val );
}
if ( oidsize != 0 )
LDAP_FREE( oidbuf );
if ( newDN != (LDAPDN)(char *) ptrs )
LDAP_FREE( newDN );
return rc;
}
/*
* compactdb_start - Compact classes
* return: error code
* verbose_flag(in):
* delete_old_repr_flag(in): delete old class representations from catalog
* input_filename(in): classes file name
* input_class_names(in): classes list
* input_class_length(in): classes list length
* max_processed_space(in): maximum space to process for one iteration
*/
static int
compactdb_start (bool verbose_flag, bool delete_old_repr_flag,
char *input_filename,
char **input_class_names, int input_class_length,
int max_processed_space, int instance_lock_timeout,
int class_lock_timeout, DB_TRAN_ISOLATION tran_isolation)
{
int status = NO_ERROR;
OID **class_oids = NULL, *next_oid = NULL;
int i, num_classes = 0;
LIST_MOPS *class_table = NULL;
OID last_processed_class_oid, last_processed_oid;
int *total_objects = NULL, *iteration_total_objects = NULL;
int *failed_objects = NULL, *iteration_failed_objects = NULL;
int *modified_objects = NULL, *iteration_modified_objects = NULL;
char *incomplete_processing = NULL;
int *big_objects = NULL, *iteration_big_objects = NULL;
int *initial_last_repr = NULL;
MOP *class_mops = NULL;
int last_completed_class_index, temp_index;
int num_class_mops = 0;
SM_CLASS *class_ptr = NULL;
int num_classes_fully_compacted = 0;
char *class_name = NULL;
MOP *processed_class_mops = NULL;
if (input_filename && input_class_names && input_class_length > 0)
{
return ER_FAILED;
}
status = compact_db_start ();
if (status != NO_ERROR)
{
if (status == ER_COMPACTDB_ALREADY_STARTED)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_ALREADY_STARTED));
}
return ER_FAILED;
}
tran_reset_wait_times ((float) class_lock_timeout);
if (input_class_names && input_class_length > 0)
{
status = get_class_mops (input_class_names, input_class_length,
&class_mops, &num_class_mops);
if (status != NO_ERROR)
{
goto error;
}
}
else if (input_filename)
{
status = get_class_mops_from_file (input_filename, &class_mops,
&num_class_mops);
if (status != NO_ERROR)
{
goto error;
}
}
else
{
class_table =
locator_get_all_mops (sm_Root_class_mop, DB_FETCH_QUERY_READ);
if (!class_table)
{
status = ER_FAILED;
goto error;
}
class_mops = class_table->mops;
num_class_mops = class_table->num;
}
class_oids = (OID **) malloc (DB_SIZEOF (OID *) * (num_class_mops));
if (class_oids == NULL)
{
status = ER_FAILED;
goto error;
}
for (i = 0; i < num_class_mops; i++)
{
class_oids[i] = NULL;
}
processed_class_mops = (DB_OBJECT **) malloc (DB_SIZEOF (DB_OBJECT *) *
(num_class_mops));
if (processed_class_mops == NULL)
{
status = ER_FAILED;
goto error;
}
for (i = 0; i < num_class_mops; i++)
{
processed_class_mops[i] = NULL;
}
num_classes = 0;
for (i = 0; i < num_class_mops; i++)
{
ws_find (class_mops[i], (MOBJ *) & class_ptr);
if (class_ptr == NULL)
{
continue;
}
if (class_ptr->class_type != SM_CLASS_CT)
{
continue;
}
class_oids[num_classes] = ws_oid (class_mops[i]);
if (class_oids[num_classes] != NULL)
{
processed_class_mops[num_classes] = class_mops[i];
num_classes++;
}
}
if (num_classes == 0)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_NOTHING_TO_PROCESS));
goto error;
}
total_objects = (int *) malloc (num_classes * sizeof (int));
if (total_objects == NULL)
{
status = ER_FAILED;
goto error;
}
iteration_total_objects = (int *) malloc (num_classes * sizeof (int));
if (iteration_total_objects == NULL)
{
status = ER_FAILED;
goto error;
}
failed_objects = (int *) malloc (num_classes * sizeof (int));
if (failed_objects == NULL)
{
status = ER_FAILED;
goto error;
}
iteration_failed_objects = (int *) malloc (num_classes * sizeof (int));
if (iteration_failed_objects == NULL)
{
status = ER_FAILED;
goto error;
}
modified_objects = (int *) malloc (num_classes * sizeof (int));
if (modified_objects == NULL)
{
status = ER_FAILED;
goto error;
}
iteration_modified_objects = (int *) malloc (num_classes * sizeof (int));
if (iteration_modified_objects == NULL)
{
status = ER_FAILED;
goto error;
}
big_objects = (int *) malloc (num_classes * sizeof (int));
if (big_objects == NULL)
{
status = ER_FAILED;
goto error;
}
iteration_big_objects = (int *) malloc (num_classes * sizeof (int));
if (iteration_big_objects == NULL)
{
status = ER_FAILED;
goto error;
}
initial_last_repr = (int *) malloc (num_classes * sizeof (int));
if (initial_last_repr == NULL)
{
status = ER_FAILED;
goto error;
}
incomplete_processing = (char *) malloc (num_classes * sizeof (char));
if (incomplete_processing == NULL)
{
status = ER_FAILED;
goto error;
}
for (i = 0; i < num_classes; i++)
{
total_objects[i] = 0;
failed_objects[i] = 0;
modified_objects[i] = 0;
big_objects[i] = 0;
incomplete_processing[i] = 0;
initial_last_repr[i] = NULL_REPRID;
}
for (i = 0; i < num_class_mops; i++)
{
status = locator_flush_all_instances (class_mops[i], true);
if (status != NO_ERROR)
{
goto error;
}
}
status = db_commit_transaction ();
if (status != NO_ERROR)
{
goto error;
}
COPY_OID (&last_processed_class_oid, class_oids[0]);
OID_SET_NULL (&last_processed_oid);
temp_index = -1;
last_completed_class_index = -1;
if (verbose_flag)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_PASS1));
}
while (true)
{
status = db_set_isolation (tran_isolation);
if (status != NO_ERROR)
{
if (verbose_flag)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_ISOLATION_LEVEL_FAILURE));
}
status = ER_FAILED;
goto error;
}
status = boot_compact_classes (class_oids, num_classes,
max_processed_space,
instance_lock_timeout * 1000,
class_lock_timeout * 1000,
delete_old_repr_flag,
&last_processed_class_oid,
&last_processed_oid,
iteration_total_objects,
iteration_failed_objects,
iteration_modified_objects,
iteration_big_objects,
initial_last_repr);
if (OID_ISNULL (&last_processed_class_oid))
{
temp_index = num_classes;
}
else
{
temp_index = find_oid (&last_processed_class_oid,
class_oids, num_classes);
}
switch (status)
{
case NO_ERROR:
if (delete_old_repr_flag &&
temp_index - 1 > last_completed_class_index)
{
for (i = last_completed_class_index + 1; i < temp_index; i++)
{
if (initial_last_repr[i] == COMPACTDB_REPR_DELETED)
{
sm_destroy_representations (processed_class_mops[i]);
}
}
}
status = db_commit_transaction ();
if (status != NO_ERROR)
{
goto error;
}
break;
case ER_LK_UNILATERALLY_ABORTED:
status = tran_abort_only_client (false);
if (status != NO_ERROR)
{
goto error;
}
break;
case ER_FAILED:
status = db_abort_transaction ();
if (status != NO_ERROR)
{
goto error;
}
break;
default:
db_abort_transaction ();
status = ER_FAILED;
goto error;
}
for (i = 0; i < num_classes; i++)
{
if (iteration_total_objects[i] >= 0)
{
total_objects[i] += iteration_total_objects[i];
failed_objects[i] += iteration_failed_objects[i];
modified_objects[i] += iteration_modified_objects[i];
big_objects[i] += iteration_big_objects[i];
}
else
{
incomplete_processing[i] = iteration_total_objects[i];
}
}
if (temp_index - 1 > last_completed_class_index)
{
for (i = last_completed_class_index + 1; i < temp_index; i++)
{
status = db_set_isolation (tran_isolation);
if (status != NO_ERROR)
{
if (verbose_flag)
{
printf (msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_ISOLATION_LEVEL_FAILURE));
}
status = ER_FAILED;
goto error;
}
tran_reset_wait_times ((float) class_lock_timeout);
show_statistics
(class_oids[i],
incomplete_processing[i] != COMPACTDB_LOCKED_CLASS,
incomplete_processing[i] != COMPACTDB_INVALID_CLASS,
incomplete_processing[i] != COMPACTDB_UNPROCESSED_CLASS,
total_objects[i], failed_objects[i],
modified_objects[i], big_objects[i],
delete_old_repr_flag,
initial_last_repr[i] == COMPACTDB_REPR_DELETED);
db_commit_transaction ();
}
last_completed_class_index = temp_index - 1;
}
if (OID_ISNULL (&last_processed_class_oid))
{
break;
}
}
if (verbose_flag)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_PASS2));
}
status = do_reclaim_addresses (class_oids, num_classes,
&num_classes_fully_compacted, verbose_flag,
(float) class_lock_timeout);
if (status != NO_ERROR)
{
goto error;
}
if (verbose_flag)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_PASS3));
}
for (i = 0; i < num_classes; i++)
{
status = db_set_isolation (tran_isolation);
if (status != NO_ERROR)
{
if (verbose_flag)
{
printf (msgcat_message
(MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_ISOLATION_LEVEL_FAILURE));
}
status = ER_FAILED;
goto error;
}
tran_reset_wait_times ((float) class_lock_timeout);
status = boot_heap_compact (class_oids[i]);
switch (status)
{
case NO_ERROR:
status = db_commit_transaction ();
if (status != NO_ERROR)
{
goto error;
}
break;
case ER_LK_UNILATERALLY_ABORTED:
status = tran_abort_only_client (false);
if (status != NO_ERROR)
{
goto error;
}
break;
default:
status = db_abort_transaction ();
if (status != NO_ERROR)
{
goto error;
}
break;
}
class_name = get_name_from_class_oid (class_oids[i]);
if (class_name == NULL)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_UNKNOWN_CLASS_NAME));
}
else
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_CLASS), class_name);
}
if (status != NO_ERROR)
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_HEAP_COMPACT_FAILED));
}
else
{
printf (msgcat_message (MSGCAT_CATALOG_UTILS,
MSGCAT_UTIL_SET_COMPACTDB,
COMPACTDB_MSG_HEAP_COMPACT_SUCCEEDED));
}
if (class_name)
{
free (class_name);
class_name = NULL;
}
db_commit_transaction ();
}
error:
if (class_oids)
{
free_and_init (class_oids);
}
if (processed_class_mops)
{
free_and_init (processed_class_mops);
}
if (total_objects)
{
free_and_init (total_objects);
}
if (iteration_total_objects)
{
free_and_init (iteration_total_objects);
}
if (failed_objects)
{
free_and_init (failed_objects);
}
if (iteration_failed_objects)
{
free_and_init (iteration_failed_objects);
}
if (modified_objects)
{
free_and_init (modified_objects);
}
if (iteration_modified_objects)
{
free_and_init (iteration_modified_objects);
}
if (big_objects)
{
free_and_init (big_objects);
}
if (iteration_big_objects)
{
free_and_init (iteration_big_objects);
}
if (initial_last_repr)
{
free_and_init (initial_last_repr);
}
if (incomplete_processing)
{
free_and_init (incomplete_processing);
}
if (class_table)
{
locator_free_list_mops (class_table);
}
else
{
if (class_mops)
{
for (i = 0; i < num_class_mops; i++)
{
class_mops[i] = NULL;
}
free_and_init (class_mops);
}
}
compact_db_stop ();
return status;
}