Merge branch 'master' of ssh://git.samba.org/data/git/samba into regsrv
[tprouty/samba.git] / source4 / lib / registry / ldb.c
index d15fdb3457f5fcff0912d5175f18504812d14666..9c1f59c4df6f75e28b6a39de651c33c4ca5fcbc2 100644 (file)
@@ -52,41 +52,42 @@ static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx,
                                      NULL));
 
        value_type = ldb_msg_find_attr_as_uint(msg, "type", 0);
                                      NULL));
 
        value_type = ldb_msg_find_attr_as_uint(msg, "type", 0);
-       if (type != NULL)
-               *type = value_type; 
+       *type = value_type; 
 
 
-       if (data != NULL) {
-               val = ldb_msg_find_ldb_val(msg, "data");
+       val = ldb_msg_find_ldb_val(msg, "data");
 
 
-               switch (value_type)
-               {
-               case REG_SZ:
-               case REG_EXPAND_SZ:
-                       data->length = convert_string_talloc(mem_ctx,
-                               iconv_convenience, CH_UNIX, CH_UTF16,
+       switch (value_type)
+       {
+       case REG_SZ:
+       case REG_EXPAND_SZ:
+               if (val != NULL)
+                       data->length = convert_string_talloc(mem_ctx, iconv_convenience, CH_UTF8, CH_UTF16,
                                                     val->data, val->length,
                                                     (void **)&data->data);
                                                     val->data, val->length,
                                                     (void **)&data->data);
-                       break;
-
-               case REG_BINARY:
-                       if (val != NULL)
-                               *data = strhex_to_data_blob((char *)val->data);
-                       else {
-                               data->data = NULL;
-                               data->length = 0;
-                       }
-                       break;
+               else {
+                       data->data = NULL;
+                       data->length = 0;
+               }
+               break;
 
 
-               case REG_DWORD: {
-                       uint32_t tmp = strtoul((char *)val->data, NULL, 0);
-                       *data = data_blob_talloc(mem_ctx, &tmp, 4);
-                       }
-                       break;
+       case REG_BINARY:
+               if (val != NULL)
+                       *data = *val;
+               else {
+                       data->data = NULL;
+                       data->length = 0;
+               }
+               break;
 
 
-               default:
-                       *data = data_blob_talloc(mem_ctx, val->data, val->length);
-                       break;
+       case REG_DWORD: {
+               uint32_t tmp = strtoul((char *)val->data, NULL, 0);
+               *data = data_blob_talloc(mem_ctx, &tmp, 4);
                }
                }
+               break;
+
+       default:
+               *data = *val;
+               break;
        }
 }
 
        }
 }
 
@@ -104,16 +105,22 @@ static struct ldb_message *reg_ldb_pack_value(struct ldb_context *ctx,
        switch (type) {
        case REG_SZ:
        case REG_EXPAND_SZ:
        switch (type) {
        case REG_SZ:
        case REG_EXPAND_SZ:
-               val.length = convert_string_talloc(mem_ctx, lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UNIX,
+               if (data.data[0] != '\0') {
+                       val.length = convert_string_talloc(mem_ctx, lp_iconv_convenience(global_loadparm), CH_UTF16, CH_UTF8,
                                                   (void *)data.data,
                                                   data.length,
                                                   (void **)&val.data);
                                                   (void *)data.data,
                                                   data.length,
                                                   (void **)&val.data);
-               ldb_msg_add_value(msg, "data", &val, NULL);
+                       ldb_msg_add_value(msg, "data", &val, NULL);
+               } else {
+                       ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
+               }
                break;
 
        case REG_BINARY:
                break;
 
        case REG_BINARY:
-               ldb_msg_add_string(msg, "data",
-                                  data_blob_hex_string(mem_ctx, &data));
+               if (data.length > 0)
+                       ldb_msg_add_value(msg, "data", &data, NULL);
+               else
+                       ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);
                break;
 
        case REG_DWORD:
                break;
 
        case REG_DWORD:
@@ -218,7 +225,7 @@ static WERROR cache_subkeys(struct ldb_key_data *kd)
        struct ldb_result *res;
        int ret;
 
        struct ldb_result *res;
        int ret;
 
-       ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, "(key=*)", NULL, &res);
+       ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "(key=*)");
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting subkeys for '%s': %s\n",
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting subkeys for '%s': %s\n",
@@ -239,8 +246,8 @@ static WERROR cache_values(struct ldb_key_data *kd)
        struct ldb_result *res;
        int ret;
 
        struct ldb_result *res;
        int ret;
 
-       ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL,
-                        "(value=*)", NULL, &res);
+       ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL,
+                        NULL, "(value=*)");
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting values for '%s': %s\n",
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting values for '%s': %s\n",
@@ -293,7 +300,7 @@ static WERROR ldb_get_subkey_by_id(TALLOC_CTX *mem_ctx,
 }
 
 static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
 }
 
 static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
-                                 const char** name, uint32_t *data_type,
+                                 const char **name, uint32_t *data_type,
                                   DATA_BLOB *data)
 {
        struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
                                   DATA_BLOB *data)
 {
        struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data);
@@ -366,7 +373,7 @@ static WERROR ldb_get_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
        } else {
                /* normal value */
                query = talloc_asprintf(mem_ctx, "(value=%s)", name);
        } else {
                /* normal value */
                query = talloc_asprintf(mem_ctx, "(value=%s)", name);
-               ret = ldb_search(c, kd->dn, LDB_SCOPE_ONELEVEL, query, NULL, &res);
+               ret = ldb_search(c, kd->dn, &res, LDB_SCOPE_ONELEVEL, query, NULL, "%s", query);
                talloc_free(query);
 
                if (ret != LDB_SUCCESS) {
                talloc_free(query);
 
                if (ret != LDB_SUCCESS) {
@@ -384,6 +391,7 @@ static WERROR ldb_get_value(TALLOC_CTX *mem_ctx, struct hive_key *k,
                talloc_free(res);
        }
 
                talloc_free(res);
        }
 
+       talloc_free(res);
        return WERR_OK;
 }
 
        return WERR_OK;
 }
 
@@ -399,7 +407,7 @@ static WERROR ldb_open_key(TALLOC_CTX *mem_ctx, const struct hive_key *h,
 
        ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
 
 
        ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL);
 
-       ret = ldb_search(c, ldap_path, LDB_SCOPE_BASE, "(key=*)", NULL, &res);
+       ret = ldb_search(c, mem_ctx, &res, ldap_path, LDB_SCOPE_BASE, NULL, "(key=*)");
 
        if (ret != LDB_SUCCESS) {
                DEBUG(3, ("Error opening key '%s': %s\n",
 
        if (ret != LDB_SUCCESS) {
                DEBUG(3, ("Error opening key '%s': %s\n",
@@ -591,8 +599,8 @@ static WERROR ldb_del_key(const struct hive_key *key, const char *name)
        }
 
        /* Search for subkeys */
        }
 
        /* Search for subkeys */
-       ret = ldb_search(c, ldap_path, LDB_SCOPE_ONELEVEL,
-                        "(key=*)", NULL, &res_keys);
+       ret = ldb_search(c, mem_ctx, &res_keys, ldap_path, LDB_SCOPE_ONELEVEL,
+                        NULL, "(key=*)");
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting subkeys for '%s': %s\n",
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting subkeys for '%s': %s\n",
@@ -602,8 +610,8 @@ static WERROR ldb_del_key(const struct hive_key *key, const char *name)
        }
 
        /* Search for values */
        }
 
        /* Search for values */
-       ret = ldb_search(c, ldap_path, LDB_SCOPE_ONELEVEL,
-                        "(value=*)", NULL, &res_vals);
+       ret = ldb_search(c, mem_ctx, &res_vals, ldap_path, LDB_SCOPE_ONELEVEL,
+                        NULL, "(value=*)");
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting values for '%s': %s\n",
 
        if (ret != LDB_SUCCESS) {
                DEBUG(0, ("Error getting values for '%s': %s\n",
@@ -708,7 +716,8 @@ static WERROR ldb_set_value(struct hive_key *parent,
        if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
                int i;
                for (i = 0; i < msg->num_elements; i++) {
        if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) {
                int i;
                for (i = 0; i < msg->num_elements; i++) {
-                       msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
+                       if (msg->elements[i].flags != LDB_FLAG_MOD_DELETE)
+                               msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
                }
                ret = ldb_modify(kd->ldb, msg);
        }
                }
                ret = ldb_modify(kd->ldb, msg);
        }
@@ -801,11 +810,12 @@ static WERROR ldb_get_key_info(TALLOC_CTX *mem_ctx,
                        }
 
                        if (max_valbufsize != NULL) {
                        }
 
                        if (max_valbufsize != NULL) {
+                               uint32_t data_type;
                                DATA_BLOB data;
                                reg_ldb_unpack_value(mem_ctx, 
                                                     lp_iconv_convenience(global_loadparm),
                                                     kd->values[i], NULL, 
                                DATA_BLOB data;
                                reg_ldb_unpack_value(mem_ctx, 
                                                     lp_iconv_convenience(global_loadparm),
                                                     kd->values[i], NULL, 
-                                                    NULL, &data);
+                                                    &data_type, &data);
                                *max_valbufsize = MAX(*max_valbufsize, data.length);
                                talloc_free(data.data);
                        }
                                *max_valbufsize = MAX(*max_valbufsize, data.length);
                                talloc_free(data.data);
                        }