/* Callback from hivex_node_delete_child which is called to delete a
* node AFTER its subnodes have been visited. The subnodes have been
* deleted but we still have to delete any lf/lh/li/ri records and the
* value list block and values, followed by deleting the node itself.
*/
static int
delete_node (hive_h *h, void *opaque, hive_node_h node, const char *name)
{
/* Get the intermediate blocks. The subkeys have already been
* deleted by this point, so tell get_children() not to check for
* validity of the nk-records.
*/
hive_node_h *unused;
size_t *blocks;
if (_hivex_get_children (h, node,
&unused, &blocks, GET_CHILDREN_NO_CHECK_NK) == -1)
return -1;
free (unused);
/* We don't care what's in these intermediate blocks, so we can just
* delete them unconditionally.
*/
size_t i;
for (i = 0; blocks[i] != 0; ++i)
mark_block_unused (h, blocks[i]);
free (blocks);
/* Delete the values in the node. */
if (delete_values (h, node) == -1)
return -1;
struct ntreg_nk_record *nk =
(struct ntreg_nk_record *) ((char *) h->addr + node);
/* If the NK references an SK, delete it. */
size_t sk_offs = le32toh (nk->sk);
if (sk_offs != 0xffffffff) {
sk_offs += 0x1000;
if (delete_sk (h, sk_offs) == -1)
return -1;
nk->sk = htole32 (0xffffffff);
}
/* If the NK references a classname, delete it. */
size_t cl_offs = le32toh (nk->classname);
if (cl_offs != 0xffffffff) {
cl_offs += 0x1000;
mark_block_unused (h, cl_offs);
nk->classname = htole32 (0xffffffff);
}
/* Delete the node itself. */
mark_block_unused (h, node);
return 0;
}
void delete_values(t_value *values)
{
if (values == NULL)
{
return;
}
delete_values(values->next);
free(values->name);
free(values->value);
free(values);
return;
}
void delete_scopes(t_scope *scopes)
{
if (scopes == NULL)
{
return;
}
delete_scopes(scopes->next);
free(scopes->id);
delete_values(scopes->variables);
free(scopes);
return;
}
void delete_state(t_state *state)
{
delete_scopes(state->variables);
delete_values(state->environ);
free(state);
}
int
hivex_node_set_values (hive_h *h, hive_node_h node,
size_t nr_values, const hive_set_value *values,
int flags)
{
CHECK_WRITABLE (-1);
if (!IS_VALID_BLOCK (h, node) || !block_id_eq (h, node, "nk")) {
SET_ERRNO (EINVAL, "invalid block or not an 'nk' block");
return -1;
}
/* Delete all existing values. */
if (delete_values (h, node) == -1)
return -1;
if (nr_values == 0)
return 0;
/* Allocate value list node. Value lists have no id field. */
static const char nul_id[2] = { 0, 0 };
size_t seg_len =
sizeof (struct ntreg_value_list) + (nr_values - 1) * sizeof (uint32_t);
size_t vallist_offs = allocate_block (h, seg_len, nul_id);
if (vallist_offs == 0)
return -1;
struct ntreg_nk_record *nk =
(struct ntreg_nk_record *) ((char *) h->addr + node);
nk->nr_values = htole32 (nr_values);
nk->vallist = htole32 (vallist_offs - 0x1000);
size_t i;
for (i = 0; i < nr_values; ++i) {
/* Allocate vk record to store this (key, value) pair. */
static const char vk_id[2] = { 'v', 'k' };
size_t recoded_name_len;
int use_utf16;
char* recoded_name = _hivex_encode_string (h, values[i].key, &recoded_name_len,
&use_utf16);
seg_len = sizeof (struct ntreg_vk_record) + recoded_name_len;
size_t vk_offs = allocate_block (h, seg_len, vk_id);
if (vk_offs == 0)
return -1;
/* Recalculate pointers that could have been invalidated by
* previous call to allocate_block.
*/
nk = (struct ntreg_nk_record *) ((char *) h->addr + node);
struct ntreg_value_list *vallist =
(struct ntreg_value_list *) ((char *) h->addr + vallist_offs);
vallist->offset[i] = htole32 (vk_offs - 0x1000);
struct ntreg_vk_record *vk =
(struct ntreg_vk_record *) ((char *) h->addr + vk_offs);
vk->name_len = htole16 (recoded_name_len);
memcpy (vk->name, recoded_name, recoded_name_len);
free (recoded_name);
vk->data_type = htole32 (values[i].t);
uint32_t len = values[i].len;
if (len <= 4) /* store it inline => set MSB flag */
len |= 0x80000000;
vk->data_len = htole32 (len);
if (recoded_name_len == 0)
vk->flags = 0;
else
vk->flags = htole16 (!use_utf16);
if (values[i].len <= 4) /* store it inline */
memcpy (&vk->data_offset, values[i].value, values[i].len);
else {
size_t offs = allocate_block (h, values[i].len + 4, nul_id);
if (offs == 0)
return -1;
/* Recalculate pointers that could have been invalidated by
* previous call to allocate_block.
*/
nk = (struct ntreg_nk_record *) ((char *) h->addr + node);
/* vallist could be invalid here */
vk = (struct ntreg_vk_record *) ((char *) h->addr + vk_offs);
memcpy ((char *) h->addr + offs + 4, values[i].value, values[i].len);
vk->data_offset = htole32 (offs - 0x1000);
}
size_t utf16_len = use_utf16 ? recoded_name_len : recoded_name_len * 2;
if (utf16_len > le32toh (nk->max_vk_name_len))
nk->max_vk_name_len = htole32 (utf16_len);
if (values[i].len > le32toh (nk->max_vk_data_len))
nk->max_vk_data_len = htole32 (values[i].len);
}
return 0;
}
static int
monitor_subsys_log_modify(
Operation *op,
SlapReply *rs,
Entry *e )
{
monitor_info_t *mi = ( monitor_info_t * )op->o_bd->be_private;
int rc = LDAP_OTHER;
int newlevel = ldap_syslog;
Attribute *save_attrs;
Modifications *modlist = op->orm_modlist;
Modifications *ml;
ldap_pvt_thread_mutex_lock( &monitor_log_mutex );
save_attrs = e->e_attrs;
e->e_attrs = attrs_dup( e->e_attrs );
for ( ml = modlist; ml != NULL; ml = ml->sml_next ) {
Modification *mod = &ml->sml_mod;
/*
* accept all operational attributes;
* this includes modifersName and modifyTimestamp
* if lastmod is "on"
*/
if ( is_at_operational( mod->sm_desc->ad_type ) ) {
( void ) attr_delete( &e->e_attrs, mod->sm_desc );
rc = rs->sr_err = attr_merge( e, mod->sm_desc,
mod->sm_values, mod->sm_nvalues );
if ( rc != LDAP_SUCCESS ) {
break;
}
continue;
/*
* only the "managedInfo" attribute can be modified
*/
} else if ( mod->sm_desc != mi->mi_ad_managedInfo ) {
rc = rs->sr_err = LDAP_UNWILLING_TO_PERFORM;
break;
}
switch ( mod->sm_op ) {
case LDAP_MOD_ADD:
rc = add_values( op, e, mod, &newlevel );
break;
case LDAP_MOD_DELETE:
rc = delete_values( op, e, mod, &newlevel );
break;
case LDAP_MOD_REPLACE:
rc = replace_values( op, e, mod, &newlevel );
break;
default:
rc = LDAP_OTHER;
break;
}
if ( rc != LDAP_SUCCESS ) {
rs->sr_err = rc;
break;
}
}
/* set the new debug level */
if ( rc == LDAP_SUCCESS ) {
const char *text;
static char textbuf[ BACKMONITOR_BUFSIZE ];
/* check for abandon */
if ( op->o_abandon ) {
rc = rs->sr_err = SLAPD_ABANDON;
goto cleanup;
}
/* check that the entry still obeys the schema */
rc = entry_schema_check( op, e, save_attrs, 0, 0, NULL,
&text, textbuf, sizeof( textbuf ) );
if ( rc != LDAP_SUCCESS ) {
rs->sr_err = rc;
goto cleanup;
}
/*
* Do we need to protect this with a mutex?
*/
ldap_syslog = newlevel;
#if 0 /* debug rather than log */
slap_debug = newlevel;
lutil_set_debug_level( "slapd", slap_debug );
ber_set_option(NULL, LBER_OPT_DEBUG_LEVEL, &slap_debug);
ldap_set_option(NULL, LDAP_OPT_DEBUG_LEVEL, &slap_debug);
ldif_debug = slap_debug;
#endif
}
cleanup:;
if ( rc == LDAP_SUCCESS ) {
attrs_free( save_attrs );
} else {
attrs_free( e->e_attrs );
e->e_attrs = save_attrs;
}
ldap_pvt_thread_mutex_unlock( &monitor_log_mutex );
if ( rc == LDAP_SUCCESS ) {
rc = SLAP_CB_CONTINUE;
}
return rc;
}
