return WERR_OK;
}
+#if 0 /* unused */
+
static BOOL vl_verify(VL_TYPE vl, int count, int size)
{
if(!vl) return False;
return True;
}
+#endif
+
static WERROR lf_verify(REG_HANDLE *h, LF_HDR *lf_hdr, int size)
{
int lf_id;
return WERR_OK;
}
+#if 0 /* unused */
+
/*
* Allocate a new hbin block, set up the header for the block etc
*/
}
-#if 0
-
/*
* Store a KEY in the file ...
*
error:
return 0;
}
-#endif
/*
* Store the registry header ...
return NULL;
}
+#endif
+
static WERROR nt_close_registry (REG_HANDLE *h)
{
REGF *regf = h->backend_data;
static WERROR rpc_open_key(REG_HANDLE *h, const char *name, REG_KEY **key)
{
- WERROR error;
struct rpc_key_data *mykeydata;
*key = reg_key_new_abs(name, h, NULL);
return rpc_key_put_rpc_data(*key, &mykeydata);
{
struct winreg_EnumValue r;
struct winreg_Uint8buf vb;
- struct winreg_Uint16buf bn;
struct rpc_data *mydata = parent->handle->backend_data;
struct winreg_EnumValueName vn;
NTSTATUS status;
struct rpc_data *mydata = parent->handle->backend_data;
struct rpc_key_data *mykeydata = parent->backend_data;
WERROR error;
- int i;
NTSTATUS status;
- TALLOC_CTX *mem_ctx;
/* If parent is the root key, list the hives */
if(parent->backend_data == mydata) {
{
NTSTATUS status;
struct winreg_QueryInfoKey r;
- struct rpc_data *mydata = k->handle->backend_data;
- struct rpc_key_data *mykeydata;
- WERROR error = rpc_key_put_rpc_data(k, &mykeydata);
-
+ struct rpc_data *mydata = k->handle->backend_data;
+ struct rpc_key_data *mykeydata;
r.in.handle = &mykeydata->pol;
init_winreg_String(&r.in.class, NULL);
if(!W_ERROR_IS_OK(error)) return error;
if(mykeydata->num_values == -1) {
- WERROR error = rpc_query_key(key);
+ error = rpc_query_key(key);
if(!W_ERROR_IS_OK(error)) return error;
}
if(!W_ERROR_IS_OK(error)) return error;
if(mykeydata->num_subkeys == -1) {
- WERROR error = rpc_query_key(key);
+ error = rpc_query_key(key);
if(!W_ERROR_IS_OK(error)) return error;
}
return ret;
}
+#if 0 /* unused */
+
static DWORD calc_hash(const char *str) {
DWORD ret = 0;
int i;
for(i = start_off; end_off - i > sizeof(RGKN_KEY); i+= sizeof(RGKN_KEY)) {
RGKN_KEY *key = (RGKN_KEY *)LOCN_RGKN(creg, i);
if(key->type == 0) {
- DEBUG(4,("Regular, id: %d, %d, parent: %x, firstchild: %x, next: %x hash: %lX\n", key->id.id, key->id.rgdb, key->parent_offset, key->first_child_offset, key->next_offset, key->hash));
+ DEBUG(4,("Regular, id: %d, %d, parent: %x, firstchild: %x, next: %x hash: %lX\n", key->id.id, key->id.rgdb, key->parent_offset, key->first_child_offset, key->next_offset, (long)key->hash));
} else if(key->type == 0x80000000) {
DEBUG(3,("free\n"));
i += key->hash;
}
}
+#endif
+
static void parse_rgdb_block(CREG *creg, RGDB_HDR *rgdb_hdr)
{
DWORD used_size = rgdb_hdr->size - rgdb_hdr->unused_size;
{
CREG *creg;
DWORD creg_id, rgkn_id;
- DWORD i, nfree = 0;
- DWORD offset, end_offset;
+ DWORD i;
+ DWORD offset;
creg = talloc_p(h->mem_ctx, CREG);
memset(creg, 0, sizeof(CREG));
RGDB_HDR *rgdb_hdr = (RGDB_HDR *)LOCN_RGDB_BLOCK(creg, offset);
if(strncmp((char *)&(rgdb_hdr->RGDB_ID), "RGDB", 4)) {
- DEBUG(0, ("unrecognized rgdb entry: %4s, %s\n",
- &rgdb_hdr->RGDB_ID, location));
+ DEBUG(0, ("unrecognized rgdb entry: %4d, %s\n",
+ rgdb_hdr->RGDB_ID, location));
return WERR_FOOBAR;
} else {
DEBUG(3, ("Valid rgdb entry, first free id: %d, max id: %d\n", rgdb_hdr->first_free_id, rgdb_hdr->max_id));
static WERROR w95_fetch_values(REG_KEY *k, int *count, REG_VAL ***values)
{
RGKN_KEY *rgkn_key = k->backend_data;
- RGDB_VALUE *val;
DWORD i;
DWORD offset = 0;
RGDB_KEY *rgdb_key = LOCN_RGDB_KEY((CREG *)k->handle->backend_data, rgkn_key->id.rgdb, rgkn_key->id.id);
void writediff(REG_KEY *oldkey, REG_KEY *newkey, FILE *out)
{
- int i, numkeys1, numvals1, numvals2, numkeys2;
+ int i;
REG_KEY *t1,*t2;
REG_VAL *v1, *v2;
WERROR error1, error2;
if(W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
fprintf(out, "-%s\n", reg_key_get_path(t1)+1);
} else if(!W_ERROR_IS_OK(error2)) {
- DEBUG(0, ("Error occured while getting subkey by name: %d\n", error2));
+ DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
}
}
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
- DEBUG(0, ("Error occured while getting subkey by index: %d\n", error1));
+ DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
return;
}
if(W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
fprintf(out, "\n[%s]\n", reg_key_get_path(t1)+1);
} else if(!W_ERROR_IS_OK(error2)) {
- DEBUG(0, ("Error occured while getting subkey by name: %d\n", error2));
+ DEBUG(0, ("Error occured while getting subkey by name: %d\n", W_ERROR_V(error2)));
}
writediff(t2, t1, out);
}
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
- DEBUG(0, ("Error occured while getting subkey by index: %d\n", error1));
+ DEBUG(0, ("Error occured while getting subkey by index: %d\n", W_ERROR_V(error1)));
return;
}
}
if(!W_ERROR_IS_OK(error2) && !W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
- DEBUG(0, ("Error occured while getting value by name: %d\n", error2));
+ DEBUG(0, ("Error occured while getting value by name: %d\n", W_ERROR_V(error2)));
}
}
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
- DEBUG(0, ("Error occured while getting value by index: %d\n", error1));
+ DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
return;
}
} else if(W_ERROR_EQUAL(error2, WERR_DEST_NOT_FOUND)) {
fprintf(out, "\"%s\"=-\n", reg_val_name(v1));
} else {
- DEBUG(0, ("Error occured while getting value by name: %d\n", error2));
+ DEBUG(0, ("Error occured while getting value by name: %d\n", W_ERROR_V(error2)));
}
}
if(!W_ERROR_EQUAL(error1, WERR_NO_MORE_ITEMS)) {
- DEBUG(0, ("Error occured while getting value by index: %d\n", error1));
+ DEBUG(0, ("Error occured while getting value by index: %d\n", W_ERROR_V(error1)));
return;
}
}
int main (int argc, char **argv)
{
- uint32 setparms, checkparms;
int opt;
poptContext pc;
- REG_KEY *root;
const char *backend1 = NULL, *backend2 = NULL;
const char *location2;
const char *credentials1= NULL, *credentials2 = NULL;
REG_HANDLE *h2;
REG_KEY *root1 = NULL, *root2;
int from_null = 0;
- int fullpath = 0, no_values = 0;
WERROR error;
struct poptOption long_options[] = {
POPT_AUTOHELP
int main (int argc, char **argv)
{
- uint32 setparms, checkparms;
int opt;
poptContext pc;
REG_KEY *root;
const char *patch;
const char *backend = "dir";
REG_HANDLE *h;
- int fullpath = 0, no_values = 0;
WERROR error;
struct poptOption long_options[] = {
POPT_AUTOHELP
static REG_KEY *cmd_ls(REG_KEY *cur, int argc, char **argv)
{
- int i, num;
+ int i;
WERROR error;
REG_VAL *value;
REG_KEY *sub;
int main (int argc, char **argv)
{
- uint32 setparms, checkparms;
int opt;
char *backend = "dir";
char *credentials = NULL;
int main (int argc, char **argv)
{
- uint32 setparms, checkparms;
int opt;
char *backend = "dir", *credentials = NULL;
poptContext pc;
#define func_winreg_OpenHive(k,n) static NTSTATUS winreg_Open ## k (struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct winreg_Open ## k *r) \
{ \
- struct _privatedata *data = dce_call->conn->private; \
- REG_KEY *root/* = reg_get_root(data->registry)*/; \
- REG_KEY *k/* = reg_open_key(root, n)*/; \
+ /*struct _privatedata *data = dce_call->conn->private*/; \
+ /*REG_KEY *root = reg_get_root(data->registry)*/; \
+ REG_KEY *k /*= reg_open_key(root, n)*/; \
\
if(!k) { \
r->out.result = WERR_BADFILE; \
{
struct dcesrv_handle *h = dcesrv_handle_fetch(dce_call->conn, r->in.handle, HTYPE_REGKEY);
REG_KEY *parent, *key;
- WERROR error;
if(!h) {
return NT_STATUS_INVALID_HANDLE;
}
r->out.result = reg_open_key(k, r->in.keyname.name, &subkey);
if(W_ERROR_IS_OK(r->out.result)) {
- struct dcesrv_handle *newh = dcesrv_handle_new(dce_call->conn, HTYPE_REGKEY);
h->data = subkey;
r->out.handle = &h->wire_handle;
}
struct winreg_CreateKey r;
struct policy_handle newhandle;
NTSTATUS status;
- struct sec_desc_buf sec_desc;
uint32 sec_info = 0;
printf("\ntesting CreateKey\n");