Changeset 745 for trunk/server/source3/registry/reg_objects.c

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• source3/registry/reg_objects.c (modified) (20 diffs)

trunk/server/source3/registry/reg_objects.c

@@ -3 +3 @@
  *  Virtual Windows Registry Layer
  *  Copyright (C) Gerald Carter                     2002-2005
+ *  Copyright (C) Michael Adam                      2007-2010
  *
  *  This program is free software; you can redistribute it and/or modify
@@ -21 +22 @@
 
 #include "includes.h"
+#include "registry.h"
+#include "reg_objects.h"
+#include "util_tdb.h"
+#include "dbwrap.h"
+#include "../libcli/registry/util_reg.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
+
+/* low level structure to contain registry values */
+
+struct regval_blob {
+        fstring         valuename;
+        uint32_t        type;
+        /* this should be encapsulated in an RPC_DATA_BLOB */
+        uint32_t        size;   /* in bytes */
+        uint8_t         *data_p;
+};
+
+/* container for registry values */
+
+struct regval_ctr {
+        uint32_t num_values;
+        struct regval_blob **values;
+        int seqnum;
+};
 
 struct regsubkey_ctr {
@@ -109 +133 @@
 static WERROR regsubkey_ctr_hash_keyname(struct regsubkey_ctr *ctr,
                                          const char *keyname,
-                                         uint32 idx)
+                                         uint32_t idx)
 {
         WERROR werr;
@@ -115 +139 @@
         werr = ntstatus_to_werror(dbwrap_store_bystring_upper(ctr->subkeys_hash,
                                                 keyname,
-                                                make_tdb_data((uint8 *)&idx,
+                                                make_tdb_data((uint8_t *)&idx,
                                                               sizeof(idx)),
                                                 TDB_REPLACE));
@@ -143 +167 @@
 static WERROR regsubkey_ctr_index_for_keyname(struct regsubkey_ctr *ctr,
                                               const char *keyname,
-                                              uint32 *idx)
+                                              uint32_t *idx)
 {
         TDB_DATA data;
@@ -162 +186 @@
 
         if (idx != NULL) {
-                *idx = *(uint32 *)data.dptr;
+                *idx = *(uint32_t *)data.dptr;
         }
 
@@ -218 +242 @@
 {
         WERROR werr;
-        uint32 idx, j;
+        uint32_t idx, j;
 
         if (keyname == NULL) {
@@ -293 +317 @@
  */
 
+/**
+ * allocate a regval_ctr structure.
+ */
+WERROR regval_ctr_init(TALLOC_CTX *mem_ctx, struct regval_ctr **ctr)
+{
+        if (ctr == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        *ctr = talloc_zero(mem_ctx, struct regval_ctr);
+        if (*ctr == NULL) {
+                return WERR_NOMEM;
+        }
+
+        return WERR_OK;
+}
+
 /***********************************************************************
  How many keys does the container hold ?
@@ -328 +369 @@
         if ( val->data_p && val->size )
         {
-                if ( !(copy->data_p = (uint8 *)memdup( val->data_p,
+                if ( !(copy->data_p = (uint8_t *)memdup( val->data_p,
                                                        val->size )) ) {
                         DEBUG(0,("dup_registry_value: memdup() failed for [%d] "
@@ -359 +400 @@
  *********************************************************************/
 
-uint8* regval_data_p(struct regval_blob *val)
+uint8_t* regval_data_p(struct regval_blob *val)
 {
         return val->data_p;
@@ -367 +408 @@
  *********************************************************************/
 
-uint32 regval_size(struct regval_blob *val)
+uint32_t regval_size(struct regval_blob *val)
 {
         return val->size;
@@ -383 +424 @@
  *********************************************************************/
 
-uint32 regval_type(struct regval_blob *val)
+uint32_t regval_type(struct regval_blob *val)
 {
         return val->type;
@@ -394 +435 @@
 
 struct regval_blob *regval_ctr_specific_value(struct regval_ctr *ctr,
-                                              uint32 idx)
+                                              uint32_t idx)
 {
         if ( !(idx < ctr->num_values) )
@@ -423 +464 @@
 
 struct regval_blob *regval_compose(TALLOC_CTX *ctx, const char *name,
-                                   uint16 type,
-                                   const char *data_p, size_t size)
+                                   uint32_t type,
+                                   const uint8_t *data_p, size_t size)
 {
         struct regval_blob *regval = TALLOC_P(ctx, struct regval_blob);
@@ -435 +476 @@
         regval->type = type;
         if (size) {
-                regval->data_p = (uint8 *)TALLOC_MEMDUP(regval, data_p, size);
+                regval->data_p = (uint8_t *)TALLOC_MEMDUP(regval, data_p, size);
                 if (!regval->data_p) {
                         TALLOC_FREE(regval);
@@ -452 +493 @@
  **********************************************************************/
 
-int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint16 type,
-                        const char *data_p, size_t size)
+int regval_ctr_addvalue(struct regval_ctr *ctr, const char *name, uint32_t type,
+                        const uint8_t *data_p, size_t size)
 {
         if ( !name )
@@ -503 +544 @@
 
         return regval_ctr_addvalue(ctr, name, REG_SZ,
-                                   (const char *)blob.data,
+                                   (const uint8_t *)blob.data,
                                    blob.length);
 }
@@ -520 +561 @@
 
         return regval_ctr_addvalue(ctr, name, REG_MULTI_SZ,
-                                   (const char *)blob.data,
+                                   (const uint8_t *)blob.data,
                                    blob.length);
 }
@@ -532 +573 @@
         if ( val ) {
                 regval_ctr_addvalue(ctr, val->valuename, val->type,
-                                    (char *)val->data_p, val->size);
+                                    (uint8_t *)val->data_p, val->size);
         }
 
@@ -586 +627 @@
 }
 
-/***********************************************************************
- return the data_p as a uint32
- **********************************************************************/
-
-uint32 regval_dword(struct regval_blob *val)
-{
-        uint32 data;
+int regval_ctr_get_seqnum(struct regval_ctr *ctr)
+{
+        if (ctr == NULL) {
+                return -1;
+        }
+
+        return ctr->seqnum;
+}
+
+WERROR regval_ctr_set_seqnum(struct regval_ctr *ctr, int seqnum)
+{
+        if (ctr == NULL) {
+                return WERR_INVALID_PARAM;
+        }
+
+        ctr->seqnum = seqnum;
+
+        return WERR_OK;
+}
+
+/***********************************************************************
+ return the data_p as a uint32_t
+ **********************************************************************/
+
+uint32_t regval_dword(struct regval_blob *val)
+{
+        uint32_t data;
 
         data = IVAL( regval_data_p(val), 0 );