ctdb/docs: Include ceph rados namespace support in man page

[samba.git] / source3 / registry / reg_dispatcher.c

diff --git a/source3/registry/reg_dispatcher.c b/source3/registry/reg_dispatcher.c
index f8c382536fadac9e708c790b0d5903f11de47745..ab3fb24dc2ff4efc4955cf88bed979e037a8fa7e 100644 (file)
--- a/source3/registry/reg_dispatcher.c
+++ b/source3/registry/reg_dispatcher.c
@@ -24,6 +24,10 @@
  */
 
 #include "includes.h"
+#include "system/passwd.h" /* uid_wrapper */
+#include "registry.h"
+#include "reg_dispatcher.h"
+#include "../libcli/security/security.h"
 
 #undef DBGC_CLASS
 #define DBGC_CLASS DBGC_REGISTRY
@@ -34,12 +38,12 @@ static const struct generic_mapping reg_generic_map =
 /********************************************************************
 ********************************************************************/
 
-static WERROR construct_registry_sd(TALLOC_CTX *ctx, SEC_DESC **psd)
+static WERROR construct_registry_sd(TALLOC_CTX *ctx, struct security_descriptor **psd)
 {
-       SEC_ACE ace[3];
+       struct security_ace ace[3];
        size_t i = 0;
-       SEC_DESC *sd;
-       SEC_ACL *theacl;
+       struct security_descriptor *sd;
+       struct security_acl *theacl;
        size_t sd_size;
 
        /* basic access for Everyone */
@@ -61,15 +65,15 @@ static WERROR construct_registry_sd(TALLOC_CTX *ctx, SEC_DESC **psd)
 
        theacl = make_sec_acl(ctx, NT4_ACL_REVISION, i, ace);
        if (theacl == NULL) {
-               return WERR_NOMEM;
+               return WERR_NOT_ENOUGH_MEMORY;
        }
 
-       sd = make_sec_desc(ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE,
+       sd = make_sec_desc(ctx, SD_REVISION, SEC_DESC_SELF_RELATIVE,
                           &global_sid_Builtin_Administrators,
                           &global_sid_System, NULL, theacl,
                           &sd_size);
        if (sd == NULL) {
-               return WERR_NOMEM;
+               return WERR_NOT_ENOUGH_MEMORY;
        }
 
        *psd = sd;
@@ -80,7 +84,8 @@ static WERROR construct_registry_sd(TALLOC_CTX *ctx, SEC_DESC **psd)
  High level wrapper function for storing registry subkeys
  ***********************************************************************/
 
-bool store_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkeys )
+bool store_reg_keys(struct registry_key_handle *key,
+                   struct regsubkey_ctr *subkeys)
 {
        if (key->ops && key->ops->store_subkeys)
                return key->ops->store_subkeys(key->name, subkeys);
@@ -92,7 +97,7 @@ bool store_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkeys )
  High level wrapper function for storing registry values
  ***********************************************************************/
 
-bool store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
+bool store_reg_values(struct registry_key_handle *key, struct regval_ctr *val)
 {
        if (key->ops && key->ops->store_values)
                return key->ops->store_values(key->name, val);
@@ -100,7 +105,7 @@ bool store_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
        return false;
 }
 
-WERROR create_reg_subkey(REGISTRY_KEY *key, const char *subkey)
+WERROR create_reg_subkey(struct registry_key_handle *key, const char *subkey)
 {
        if (key->ops && key->ops->create_subkey) {
                return key->ops->create_subkey(key->name, subkey);
@@ -109,10 +114,10 @@ WERROR create_reg_subkey(REGISTRY_KEY *key, const char *subkey)
        return WERR_NOT_SUPPORTED;
 }
 
-WERROR delete_reg_subkey(REGISTRY_KEY *key, const char *subkey)
+WERROR delete_reg_subkey(struct registry_key_handle *key, const char *subkey, bool lazy)
 {
        if (key->ops && key->ops->delete_subkey) {
-               return key->ops->delete_subkey(key->name, subkey);
+               return key->ops->delete_subkey(key->name, subkey, lazy);
        }
 
        return WERR_NOT_SUPPORTED;
@@ -123,7 +128,8 @@ WERROR delete_reg_subkey(REGISTRY_KEY *key, const char *subkey)
  Initialize the TALLOC_CTX if necessary
  ***********************************************************************/
 
-int fetch_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkey_ctr )
+int fetch_reg_keys(struct registry_key_handle *key,
+                  struct regsubkey_ctr *subkey_ctr)
 {
        int result = -1;
 
@@ -137,7 +143,7 @@ int fetch_reg_keys( REGISTRY_KEY *key, struct regsubkey_ctr *subkey_ctr )
  High level wrapper function for enumerating registry values
  ***********************************************************************/
 
-int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
+int fetch_reg_values(struct registry_key_handle *key, struct regval_ctr *val)
 {
        int result = -1;
 
@@ -155,13 +161,20 @@ int fetch_reg_values( REGISTRY_KEY *key, REGVAL_CTR *val )
  underlying registry backend
  ***********************************************************************/
 
-bool regkey_access_check( REGISTRY_KEY *key, uint32 requested, uint32 *granted,
-                         const struct nt_user_token *token )
+bool regkey_access_check(struct registry_key_handle *key, uint32_t requested,
+                        uint32_t *granted,
+                        const struct security_token *token )
 {
-       SEC_DESC *sec_desc;
+       struct security_descriptor *sec_desc;
        NTSTATUS status;
        WERROR err;
 
+       /* root free-pass, like we have on all other pipes like samr, lsa, etc. */
+       if (root_mode()) {
+               *granted = REG_KEY_ALL;
+               return true;
+       }
+
        /* use the default security check if the backend has not defined its
         * own */
 
@@ -187,7 +200,7 @@ bool regkey_access_check( REGISTRY_KEY *key, uint32 requested, uint32 *granted,
        return NT_STATUS_IS_OK(status);
 }
 
-WERROR regkey_get_secdesc(TALLOC_CTX *mem_ctx, REGISTRY_KEY *key,
+WERROR regkey_get_secdesc(TALLOC_CTX *mem_ctx, struct registry_key_handle *key,
                          struct security_descriptor **psecdesc)
 {
        struct security_descriptor *secdesc;
@@ -209,7 +222,7 @@ WERROR regkey_get_secdesc(TALLOC_CTX *mem_ctx, REGISTRY_KEY *key,
        return WERR_OK;
 }
 
-WERROR regkey_set_secdesc(REGISTRY_KEY *key,
+WERROR regkey_set_secdesc(struct registry_key_handle *key,
                          struct security_descriptor *psecdesc)
 {
        if (key->ops && key->ops->set_secdesc) {
@@ -223,27 +236,29 @@ WERROR regkey_set_secdesc(REGISTRY_KEY *key,
  * Check whether the in-memory version of the subkyes of a
  * registry key needs update from disk.
  */
-bool reg_subkeys_need_update(REGISTRY_KEY *key, struct regsubkey_ctr *subkeys)
+bool reg_subkeys_need_update(struct registry_key_handle *key,
+                            struct regsubkey_ctr *subkeys)
 {
        if (key->ops && key->ops->subkeys_need_update)
        {
                return key->ops->subkeys_need_update(subkeys);
        }
 
-       return false;
+       return true;
 }
 
 /**
  * Check whether the in-memory version of the values of a
  * registry key needs update from disk.
  */
-bool reg_values_need_update(REGISTRY_KEY *key, REGVAL_CTR *values)
+bool reg_values_need_update(struct registry_key_handle *key,
+                           struct regval_ctr *values)
 {
        if (key->ops && key->ops->values_need_update)
        {
                return key->ops->values_need_update(values);
        }
 
-       return false;
+       return true;
 }