The branch, v3-6-test has been updated
       via  4bb610a s3-rpc_client: Fixed an uninitialized variable.
       via  84a7c49 s3-rpc_client: Added dcerpc_winreg_int_openkey() which 
dectects the hive.
       via  2130f3f s3-rpc_client: Fixed winreg int documentation.
       via  183d168 s3-rpc_server: Fixed possible segfaults in svcctl server.
      from  0d7a2d2 s3:smbd: fix switch indentation level in 
get_ea_dos_attribute()

http://gitweb.samba.org/?p=samba.git;a=shortlog;h=v3-6-test


- Log -----------------------------------------------------------------
commit 4bb610a66158dfdf2ae09fe0574e2821574679df
Author: Andreas Schneider <[email protected]>
Date:   Wed Feb 9 09:46:43 2011 +0100

    s3-rpc_client: Fixed an uninitialized variable.
    
    Signed-off-by: Günther Deschner <[email protected]>
    
    Autobuild-User: Günther Deschner <[email protected]>
    Autobuild-Date: Thu Feb 10 18:32:08 CET 2011 on sn-devel-104
    (cherry picked from commit da9cd736d2e9e32de9b5259aa06f9cf4634377bc)

commit 84a7c49c297804e9407bc8c003a5bd3c09f5f67c
Author: Andreas Schneider <[email protected]>
Date:   Tue Feb 8 11:54:15 2011 +0100

    s3-rpc_client: Added dcerpc_winreg_int_openkey() which dectects the hive.
    
    Signed-off-by: Günther Deschner <[email protected]>
    (cherry picked from commit 8cffe147eb609fe6aef05124d2ba93ec21b88715)

commit 2130f3f299f7d66ee8f13524fe4652c5e0f484eb
Author: Andreas Schneider <[email protected]>
Date:   Tue Feb 8 11:53:40 2011 +0100

    s3-rpc_client: Fixed winreg int documentation.
    
    Signed-off-by: Günther Deschner <[email protected]>
    (cherry picked from commit 8ed5808390ccb449c7c6dfdc510101c1ad8feb4c)

commit 183d168d2f8e089407cbdfbcc051a8da089a2014
Author: Andreas Schneider <[email protected]>
Date:   Tue Feb 8 15:33:51 2011 +0100

    s3-rpc_server: Fixed possible segfaults in svcctl server.
    
    Signed-off-by: Günther Deschner <[email protected]>
    (cherry picked from commit f0a90551b279c2dc7ab9d4c0e4b16b3e724548e2)

-----------------------------------------------------------------------

Summary of changes:
 source3/rpc_client/cli_lsarpc.c     |    2 +-
 source3/rpc_client/cli_winreg_int.c |  215 ++++++++++++++++++++++++++++++++---
 source3/rpc_client/cli_winreg_int.h |   39 ++++++-
 source3/rpc_server/srv_svcctl_reg.c |    8 ++
 4 files changed, 244 insertions(+), 20 deletions(-)


Changeset truncated at 500 lines:

diff --git a/source3/rpc_client/cli_lsarpc.c b/source3/rpc_client/cli_lsarpc.c
index 36239f5..0dbe813 100644
--- a/source3/rpc_client/cli_lsarpc.c
+++ b/source3/rpc_client/cli_lsarpc.c
@@ -337,7 +337,7 @@ static NTSTATUS dcerpc_lsa_lookup_sids_generic(struct 
dcerpc_binding_handle *h,
                                               bool use_lookupsids3,
                                               NTSTATUS *presult)
 {
-       NTSTATUS status;
+       NTSTATUS status = NT_STATUS_OK;
        NTSTATUS result = NT_STATUS_OK;
        int sids_left = 0;
        int sids_processed = 0;
diff --git a/source3/rpc_client/cli_winreg_int.c 
b/source3/rpc_client/cli_winreg_int.c
index bd9cb01..6b3b82e 100644
--- a/source3/rpc_client/cli_winreg_int.c
+++ b/source3/rpc_client/cli_winreg_int.c
@@ -20,20 +20,81 @@
  */
 
 #include "includes.h"
-#include "../librpc/gen_ndr/ndr_winreg_c.h"
+#include "include/registry.h"
+#include "utils/net_registry_util.h"
+#include "librpc/gen_ndr/ndr_winreg_c.h"
 #include "rpc_client/cli_winreg_int.h"
 #include "rpc_server/rpc_ncacn_np.h"
 
-NTSTATUS dcerpc_winreg_int_hklm_openkey(TALLOC_CTX *mem_ctx,
-                                       const struct auth_serversupplied_info 
*server_info,
-                                       struct messaging_context *msg_ctx,
-                                       struct dcerpc_binding_handle **h,
-                                       const char *key,
-                                       bool create_key,
-                                       uint32_t access_mask,
-                                       struct policy_handle *hive_handle,
-                                       struct policy_handle *key_handle,
-                                       WERROR *pwerr)
+/**
+ * Split path into hive name and subkeyname
+ * normalizations performed:
+ *  - if the path contains no '\\' characters,
+ *    assume that the legacy format of using '/'
+ *    as a separator is used and  convert '/' to '\\'
+ *  - strip trailing '\\' chars
+ */
+static WERROR _split_hive_key(TALLOC_CTX *mem_ctx,
+                             const char *path,
+                             char **hivename,
+                             char **subkeyname)
+{
+       char *p;
+       const char *tmp_subkeyname;
+
+       if ((path == NULL) || (hivename == NULL) || (subkeyname == NULL)) {
+               return WERR_INVALID_PARAM;
+       }
+
+       if (strlen(path) == 0) {
+               return WERR_INVALID_PARAM;
+       }
+
+       if (strchr(path, '\\') == NULL) {
+               *hivename = talloc_string_sub(mem_ctx, path, "/", "\\");
+       } else {
+               *hivename = talloc_strdup(mem_ctx, path);
+       }
+
+       if (*hivename == NULL) {
+               return WERR_NOMEM;
+       }
+
+       /* strip trailing '\\' chars */
+       p = strrchr(*hivename, '\\');
+       while ((p != NULL) && (p[1] == '\0')) {
+               *p = '\0';
+               p = strrchr(*hivename, '\\');
+       }
+
+       p = strchr(*hivename, '\\');
+
+       if ((p == NULL) || (*p == '\0')) {
+               /* just the hive - no subkey given */
+               tmp_subkeyname = "";
+       } else {
+               *p = '\0';
+               tmp_subkeyname = p+1;
+       }
+       *subkeyname = talloc_strdup(mem_ctx, tmp_subkeyname);
+       if (*subkeyname == NULL) {
+               return WERR_NOMEM;
+       }
+
+       return WERR_OK;
+}
+
+static NTSTATUS _winreg_int_openkey(TALLOC_CTX *mem_ctx,
+                                   const struct auth_serversupplied_info 
*server_info,
+                                   struct messaging_context *msg_ctx,
+                                   struct dcerpc_binding_handle **h,
+                                   uint32_t reg_type,
+                                   const char *key,
+                                   bool create_key,
+                                   uint32_t access_mask,
+                                   struct policy_handle *hive_handle,
+                                   struct policy_handle *key_handle,
+                                   WERROR *pwerr)
 {
        static struct client_address client_id;
        struct dcerpc_binding_handle *binding_handle;
@@ -56,12 +117,51 @@ NTSTATUS dcerpc_winreg_int_hklm_openkey(TALLOC_CTX 
*mem_ctx,
                return status;
        }
 
-       status = dcerpc_winreg_OpenHKLM(binding_handle,
-                                       mem_ctx,
-                                       NULL,
-                                       access_mask,
-                                       hive_handle,
-                                       &result);
+       switch (reg_type) {
+       case HKEY_LOCAL_MACHINE:
+               status = dcerpc_winreg_OpenHKLM(binding_handle,
+                                               mem_ctx,
+                                               NULL,
+                                               access_mask,
+                                               hive_handle,
+                                               &result);
+               break;
+       case HKEY_CLASSES_ROOT:
+               status = dcerpc_winreg_OpenHKCR(binding_handle,
+                                               mem_ctx,
+                                               NULL,
+                                               access_mask,
+                                               hive_handle,
+                                               &result);
+               break;
+       case HKEY_USERS:
+               status = dcerpc_winreg_OpenHKU(binding_handle,
+                                              mem_ctx,
+                                              NULL,
+                                              access_mask,
+                                              hive_handle,
+                                              &result);
+               break;
+       case HKEY_CURRENT_USER:
+               status = dcerpc_winreg_OpenHKCU(binding_handle,
+                                               mem_ctx,
+                                               NULL,
+                                               access_mask,
+                                               hive_handle,
+                                               &result);
+               break;
+       case HKEY_PERFORMANCE_DATA:
+               status = dcerpc_winreg_OpenHKPD(binding_handle,
+                                               mem_ctx,
+                                               NULL,
+                                               access_mask,
+                                               hive_handle,
+                                               &result);
+               break;
+       default:
+               result = WERR_INVALID_PARAMETER;
+               status = NT_STATUS_OK;
+       }
        if (!NT_STATUS_IS_OK(status)) {
                talloc_free(binding_handle);
                return status;
@@ -131,4 +231,85 @@ NTSTATUS dcerpc_winreg_int_hklm_openkey(TALLOC_CTX 
*mem_ctx,
        return status;
 }
 
+NTSTATUS dcerpc_winreg_int_openkey(TALLOC_CTX *mem_ctx,
+                                  const struct auth_serversupplied_info 
*server_info,
+                                  struct messaging_context *msg_ctx,
+                                  struct dcerpc_binding_handle **h,
+                                  const char *key,
+                                  bool create_key,
+                                  uint32_t access_mask,
+                                  struct policy_handle *hive_handle,
+                                  struct policy_handle *key_handle,
+                                  WERROR *pwerr)
+{
+       char *hivename = NULL;
+       char *subkey = NULL;
+       uint32_t reg_type;
+       WERROR result;
+
+       result = _split_hive_key(mem_ctx, key, &hivename, &subkey);
+       if (!W_ERROR_IS_OK(result)) {
+               *pwerr = result;
+               return NT_STATUS_OK;
+       }
+
+       if (strequal(hivename, "HKLM") ||
+           strequal(hivename, "HKEY_LOCAL_MACHINE")) {
+               reg_type = HKEY_LOCAL_MACHINE;
+       } else if (strequal(hivename, "HKCR") ||
+                  strequal(hivename, "HKEY_CLASSES_ROOT")) {
+               reg_type = HKEY_CLASSES_ROOT;
+       } else if (strequal(hivename, "HKU") ||
+                  strequal(hivename, "HKEY_USERS")) {
+               reg_type = HKEY_USERS;
+       } else if (strequal(hivename, "HKCU") ||
+                  strequal(hivename, "HKEY_CURRENT_USER")) {
+               reg_type = HKEY_CURRENT_USER;
+       } else if (strequal(hivename, "HKPD") ||
+                  strequal(hivename, "HKEY_PERFORMANCE_DATA")) {
+               reg_type = HKEY_PERFORMANCE_DATA;
+       } else {
+               DEBUG(10,("dcerpc_winreg_int_openkey: unrecognised hive key 
%s\n",
+                         key));
+               *pwerr = WERR_INVALID_PARAMETER;
+               return NT_STATUS_OK;
+       }
+
+       return _winreg_int_openkey(mem_ctx,
+                                  server_info,
+                                  msg_ctx,
+                                  h,
+                                  reg_type,
+                                  key,
+                                  create_key,
+                                  access_mask,
+                                  hive_handle,
+                                  key_handle,
+                                  pwerr);
+}
+
+NTSTATUS dcerpc_winreg_int_hklm_openkey(TALLOC_CTX *mem_ctx,
+                                       const struct auth_serversupplied_info 
*server_info,
+                                       struct messaging_context *msg_ctx,
+                                       struct dcerpc_binding_handle **h,
+                                       const char *key,
+                                       bool create_key,
+                                       uint32_t access_mask,
+                                       struct policy_handle *hive_handle,
+                                       struct policy_handle *key_handle,
+                                       WERROR *pwerr)
+{
+       return _winreg_int_openkey(mem_ctx,
+                                  server_info,
+                                  msg_ctx,
+                                  h,
+                                  HKEY_LOCAL_MACHINE,
+                                  key,
+                                  create_key,
+                                  access_mask,
+                                  hive_handle,
+                                  key_handle,
+                                  pwerr);
+}
+
 /* vim: set ts=8 sw=8 noet cindent syntax=c.doxygen: */
diff --git a/source3/rpc_client/cli_winreg_int.h 
b/source3/rpc_client/cli_winreg_int.h
index 83d9652..f991559 100644
--- a/source3/rpc_client/cli_winreg_int.h
+++ b/source3/rpc_client/cli_winreg_int.h
@@ -22,7 +22,7 @@
 #ifndef CLI_WINREG_INT_H
 #define CLI_WINREG_INT_H
 
-/*
+/**
  * @brief Connect to the interal winreg server and open the given key.
  *
  * The function will create the needed subkeys if they don't exist.
@@ -31,7 +31,42 @@
  *
  * @param[in]  server_info   The supplied server info.
  *
- * @param[in]  path          The path to the key to open.
+ * @param[in]  key           The key to open. This needs to start with the name
+ *                           of the hive like HKLM.
+ *
+ * @param[in]  create_key    Set to true if the key should be created if it
+ *                           doesn't exist.
+ *
+ * @param[in]  access_mask   The access mask to open the key.
+ *
+ * @param[out] binding_handle A pointer for the winreg dcerpc binding handle.
+ *
+ * @param[out] hive_handle   A policy handle for the opened hive.
+ *
+ * @param[out] key_handle    A policy handle for the opened key.
+ *
+ * @return                   WERR_OK on success, the corresponding DOS error
+ *                           code if something gone wrong.
+ */
+NTSTATUS dcerpc_winreg_int_openkey(TALLOC_CTX *mem_ctx,
+                                  const struct auth_serversupplied_info 
*server_info,
+                                  struct messaging_context *msg_ctx,
+                                  struct dcerpc_binding_handle **h,
+                                  const char *key,
+                                  bool create_key,
+                                  uint32_t access_mask,
+                                  struct policy_handle *hive_handle,
+                                  struct policy_handle *key_handle,
+                                  WERROR *pwerr);
+
+/**
+ * @brief Connect to the interal winreg server and open the given key.
+ *
+ * The function will create the needed subkeys if they don't exist.
+ *
+ * @param[in]  mem_ctx       The memory context to use.
+ *
+ * @param[in]  server_info   The supplied server info.
  *
  * @param[in]  key           The key to open.
  *
diff --git a/source3/rpc_server/srv_svcctl_reg.c 
b/source3/rpc_server/srv_svcctl_reg.c
index 7de47d8..ca6a68a 100644
--- a/source3/rpc_server/srv_svcctl_reg.c
+++ b/source3/rpc_server/srv_svcctl_reg.c
@@ -483,6 +483,7 @@ static bool svcctl_add_service(TALLOC_CTX *mem_ctx,
        if (is_valid_policy_hnd(&key_hnd)) {
                dcerpc_winreg_CloseKey(h, mem_ctx, &key_hnd, &result);
        }
+       ZERO_STRUCT(key_hnd);
 
        ZERO_STRUCT(wkey);
        wkey.name = talloc_asprintf(mem_ctx, "%s\\%s\\Security", key, name);
@@ -564,7 +565,13 @@ bool svcctl_init_winreg(struct messaging_context *msg_ctx)
 
        DEBUG(3, ("Initialise the svcctl registry keys if needed.\n"));
 
+       ZERO_STRUCT(hive_hnd);
+       ZERO_STRUCT(key_hnd);
+
        key = talloc_strdup(tmp_ctx, TOP_LEVEL_SERVICES_KEY);
+       if (key == NULL) {
+               goto done;
+       }
 
        status = dcerpc_winreg_int_hklm_openkey(tmp_ctx,
                                                get_server_info_system(),
@@ -653,6 +660,7 @@ bool svcctl_init_winreg(struct messaging_context *msg_ctx)
                if (is_valid_policy_hnd(&key_hnd)) {
                        dcerpc_winreg_CloseKey(h, tmp_ctx, &key_hnd, &result);
                }
+               ZERO_STRUCT(key_hnd);
 
                if (!ok) {
                        goto done;


-- 
Samba Shared Repository

Reply via email to