Changeset 745 for trunk/server/source4/lib/registry/ldb.c
- Timestamp:
- Nov 27, 2012, 4:43:17 PM (13 years ago)
- Location:
- trunk/server
- Files:
-
- 2 edited
-
. (modified) (1 prop)
-
source4/lib/registry/ldb.c (modified) (39 diffs)
Legend:
- Unmodified
- Added
- Removed
-
trunk/server
- Property svn:mergeinfo changed
/vendor/current merged: 581,587,591,594,597,600,615,618,740
- Property svn:mergeinfo changed
-
trunk/server/source4/lib/registry/ldb.c
r414 r745 3 3 Registry interface 4 4 Copyright (C) 2004-2007, Jelmer Vernooij, jelmer@samba.org 5 Copyright (C) 2008 Matthias Dieter Wallnöfer, mwallnoefer@yahoo.de5 Copyright (C) 2008-2010, Matthias Dieter Wallnöfer, mdw@samba.org 6 6 7 7 This program is free software; you can redistribute it and/or modify … … 21 21 #include "includes.h" 22 22 #include "registry.h" 23 #include "lib/ldb/include/ldb.h"24 #include "lib/ldb/include/ldb_errors.h"23 #include <ldb.h> 24 #include <ldb_errors.h> 25 25 #include "ldb_wrap.h" 26 26 #include "librpc/gen_ndr/winreg.h" … … 35 35 struct ldb_dn *dn; 36 36 struct ldb_message **subkeys, **values; 37 int subkey_count, value_count; 37 unsigned int subkey_count, value_count; 38 const char *classname; 38 39 }; 39 40 40 static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, 41 static void reg_ldb_unpack_value(TALLOC_CTX *mem_ctx, 41 42 struct ldb_message *msg, 42 43 const char **name, uint32_t *type, … … 46 47 uint32_t value_type; 47 48 48 if (name != NULL) 49 if (name != NULL) { 49 50 *name = talloc_strdup(mem_ctx, 50 51 ldb_msg_find_attr_as_string(msg, "value", 51 NULL)); 52 "")); 53 } 52 54 53 55 value_type = ldb_msg_find_attr_as_uint(msg, "type", 0); 54 *type = value_type; 56 *type = value_type; 55 57 56 58 val = ldb_msg_find_ldb_val(msg, "data"); … … 60 62 case REG_SZ: 61 63 case REG_EXPAND_SZ: 62 if (val != NULL) 64 if (val != NULL) { 65 /* The data should be provided as UTF16 string */ 63 66 convert_string_talloc(mem_ctx, CH_UTF8, CH_UTF16, 64 65 66 else {67 val->data, val->length, 68 (void **)&data->data, &data->length, false); 69 } else { 67 70 data->data = NULL; 68 71 data->length = 0; … … 70 73 break; 71 74 72 case REG_BINARY: 73 if (val != NULL) 74 *data = data_blob_talloc(mem_ctx, val->data, val->length); 75 else { 75 case REG_DWORD: 76 case REG_DWORD_BIG_ENDIAN: 77 if (val != NULL) { 78 /* The data is a plain DWORD */ 79 uint32_t tmp = strtoul((char *)val->data, NULL, 0); 80 data->data = talloc_size(mem_ctx, sizeof(uint32_t)); 81 if (data->data != NULL) { 82 SIVAL(data->data, 0, tmp); 83 } 84 data->length = sizeof(uint32_t); 85 } else { 76 86 data->data = NULL; 77 87 data->length = 0; … … 79 89 break; 80 90 81 case REG_DWORD: { 82 uint32_t tmp = strtoul((char *)val->data, NULL, 0); 83 *data = data_blob_talloc(mem_ctx, &tmp, 4); 91 case REG_QWORD: 92 if (val != NULL) { 93 /* The data is a plain QWORD */ 94 uint64_t tmp = strtoull((char *)val->data, NULL, 0); 95 data->data = talloc_size(mem_ctx, sizeof(uint64_t)); 96 if (data->data != NULL) { 97 SBVAL(data->data, 0, tmp); 98 } 99 data->length = sizeof(uint64_t); 100 } else { 101 data->data = NULL; 102 data->length = 0; 84 103 } 85 104 break; 86 105 106 case REG_BINARY: 87 107 default: 88 *data = data_blob_talloc(mem_ctx, val->data, val->length); 108 if (val != NULL) { 109 data->data = talloc_memdup(mem_ctx, val->data, 110 val->length); 111 data->length = val->length; 112 } else { 113 data->data = NULL; 114 data->length = 0; 115 } 89 116 break; 90 117 } … … 96 123 uint32_t type, DATA_BLOB data) 97 124 { 98 struct ldb_val val; 99 struct ldb_message *msg = talloc_zero(mem_ctx, struct ldb_message); 100 char *type_s; 101 102 ldb_msg_add_string(msg, "value", talloc_strdup(mem_ctx, name)); 125 struct ldb_message *msg; 126 char *name_dup, *type_str; 127 int ret; 128 129 msg = talloc_zero(mem_ctx, struct ldb_message); 130 if (msg == NULL) { 131 return NULL; 132 } 133 134 name_dup = talloc_strdup(msg, name); 135 if (name_dup == NULL) { 136 talloc_free(msg); 137 return NULL; 138 } 139 140 ret = ldb_msg_add_string(msg, "value", name_dup); 141 if (ret != LDB_SUCCESS) { 142 talloc_free(msg); 143 return NULL; 144 } 103 145 104 146 switch (type) { 105 147 case REG_SZ: 106 148 case REG_EXPAND_SZ: 107 if (data.data[0] != '\0') { 108 convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8, 109 (void *)data.data, 110 data.length, 111 (void **)&val.data, &val.length, false); 112 ldb_msg_add_value(msg, "data", &val, NULL); 149 if ((data.length > 0) && (data.data != NULL)) { 150 struct ldb_val *val; 151 bool ret2 = false; 152 153 val = talloc_zero(msg, struct ldb_val); 154 if (val == NULL) { 155 talloc_free(msg); 156 return NULL; 157 } 158 159 /* The data is provided as UTF16 string */ 160 ret2 = convert_string_talloc(mem_ctx, CH_UTF16, CH_UTF8, 161 (void *)data.data, data.length, 162 (void **)&val->data, &val->length, 163 false); 164 if (ret2) { 165 ret = ldb_msg_add_value(msg, "data", val, NULL); 166 } else { 167 /* workaround for non-standard data */ 168 ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL); 169 } 113 170 } else { 114 ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL);171 ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL); 115 172 } 116 173 break; 117 174 175 case REG_DWORD: 176 case REG_DWORD_BIG_ENDIAN: 177 if ((data.length > 0) && (data.data != NULL)) { 178 if (data.length == sizeof(uint32_t)) { 179 char *conv_str; 180 181 conv_str = talloc_asprintf(msg, "0x%8.8x", 182 IVAL(data.data, 0)); 183 if (conv_str == NULL) { 184 talloc_free(msg); 185 return NULL; 186 } 187 ret = ldb_msg_add_string(msg, "data", conv_str); 188 } else { 189 /* workaround for non-standard data */ 190 talloc_free(msg); 191 return NULL; 192 } 193 } else { 194 ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL); 195 } 196 break; 197 198 case REG_QWORD: 199 if ((data.length > 0) && (data.data != NULL)) { 200 if (data.length == sizeof(uint64_t)) { 201 char *conv_str; 202 203 conv_str = talloc_asprintf(msg, "0x%16.16llx", 204 (unsigned long long)BVAL(data.data, 0)); 205 if (conv_str == NULL) { 206 talloc_free(msg); 207 return NULL; 208 } 209 ret = ldb_msg_add_string(msg, "data", conv_str); 210 } else { 211 /* workaround for non-standard data */ 212 talloc_free(msg); 213 return NULL; 214 215 } 216 } else { 217 ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL); 218 } 219 break; 220 118 221 case REG_BINARY: 119 if (data.length > 0) 120 ldb_msg_add_value(msg, "data", &data, NULL); 121 else 122 ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL); 222 default: 223 if ((data.length > 0) && (data.data != NULL)) { 224 ret = ldb_msg_add_value(msg, "data", &data, NULL); 225 } else { 226 ret = ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL); 227 } 123 228 break; 124 125 case REG_DWORD: 126 ldb_msg_add_string(msg, "data", 127 talloc_asprintf(mem_ctx, "0x%x", 128 IVAL(data.data, 0))); 129 break; 130 default: 131 ldb_msg_add_value(msg, "data", &data, NULL); 132 } 133 134 135 type_s = talloc_asprintf(mem_ctx, "%u", type); 136 ldb_msg_add_string(msg, "type", type_s); 229 } 230 231 if (ret != LDB_SUCCESS) { 232 talloc_free(msg); 233 return NULL; 234 } 235 236 type_str = talloc_asprintf(mem_ctx, "%u", type); 237 if (type_str == NULL) { 238 talloc_free(msg); 239 return NULL; 240 } 241 242 ret = ldb_msg_add_string(msg, "type", type_str); 243 if (ret != LDB_SUCCESS) { 244 talloc_free(msg); 245 return NULL; 246 } 137 247 138 248 return msg; … … 167 277 const char *path, const char *add) 168 278 { 169 TALLOC_CTX *local_ctx;170 279 struct ldb_dn *ret; 171 char *mypath = talloc_strdup(mem_ctx, path);280 char *mypath; 172 281 char *begin; 173 282 struct ldb_key_data *kd = talloc_get_type(from, struct ldb_key_data); 174 283 struct ldb_context *ldb = kd->ldb; 175 284 176 local_ctx = talloc_new(mem_ctx); 177 178 if (add) { 179 ret = ldb_dn_new(mem_ctx, ldb, add); 180 } else { 181 ret = ldb_dn_new(mem_ctx, ldb, NULL); 182 } 285 mypath = talloc_strdup(mem_ctx, path); 286 if (mypath == NULL) { 287 return NULL; 288 } 289 290 ret = ldb_dn_new(mem_ctx, ldb, add); 183 291 if (!ldb_dn_validate(ret)) { 184 292 talloc_free(ret); 185 talloc_free(local_ctx);186 293 return NULL; 187 294 } 188 295 189 while (mypath) { 190 char *keyname; 191 192 begin = strrchr(mypath, '\\'); 193 194 if (begin) keyname = begin + 1; 195 else keyname = mypath; 196 197 if(strlen(keyname)) { 198 if (!ldb_dn_add_base_fmt(ret, "key=%s", 199 reg_ldb_escape(local_ctx, 200 keyname))) 201 { 202 talloc_free(local_ctx); 203 return NULL; 204 } 205 } 206 207 if(begin) { 296 if (!ldb_dn_add_base(ret, kd->dn)) { 297 talloc_free(ret); 298 return NULL; 299 } 300 301 while (mypath[0] != '\0') { 302 begin = strchr(mypath, '\\'); 303 if (begin != NULL) { 208 304 *begin = '\0'; 305 } 306 307 if (!ldb_dn_add_child_fmt(ret, "key=%s", 308 reg_ldb_escape(mem_ctx, mypath))) { 309 talloc_free(ret); 310 return NULL; 311 } 312 313 if (begin != NULL) { 314 mypath = begin + 1; 209 315 } else { 210 316 break; 211 317 } 212 318 } 213 214 ldb_dn_add_base(ret, kd->dn);215 216 talloc_free(local_ctx);217 319 218 320 return ret; … … 225 327 int ret; 226 328 227 ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "(key=*)");228 329 ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL, 330 NULL, "(key=*)"); 229 331 if (ret != LDB_SUCCESS) { 230 332 DEBUG(0, ("Error getting subkeys for '%s': %s\n", … … 248 350 ret = ldb_search(c, c, &res, kd->dn, LDB_SCOPE_ONELEVEL, 249 351 NULL, "(value=*)"); 250 251 352 if (ret != LDB_SUCCESS) { 252 353 DEBUG(0, ("Error getting values for '%s': %s\n", … … 269 370 NTTIME *last_mod_time) 270 371 { 271 struct ldb_message_element *el;272 372 struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data); 273 373 274 374 /* Initialization */ 275 375 if (name != NULL) 276 376 *name = NULL; 277 377 if (classname != NULL) 278 *classname = NULL; /* TODO: Store properly */378 *classname = NULL; 279 379 if (last_mod_time != NULL) 280 380 *last_mod_time = 0; /* TODO: we need to add this to the … … 289 389 return WERR_NO_MORE_ITEMS; 290 390 291 el = ldb_msg_find_element(kd->subkeys[idx], "key");292 SMB_ASSERT(el != NULL);293 SMB_ASSERT(el->num_values != 0);294 295 391 if (name != NULL) 296 *name = talloc_strdup(mem_ctx, (char *)el->values[0].data); 297 298 return WERR_OK; 299 } 300 301 static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx, struct hive_key *k, 302 const char **name, uint32_t *data_type, 303 DATA_BLOB *data) 392 *name = talloc_strdup(mem_ctx, 393 ldb_msg_find_attr_as_string(kd->subkeys[idx], "key", NULL)); 394 if (classname != NULL) 395 *classname = talloc_strdup(mem_ctx, 396 ldb_msg_find_attr_as_string(kd->subkeys[idx], "classname", NULL)); 397 398 return WERR_OK; 399 } 400 401 static WERROR ldb_get_default_value(TALLOC_CTX *mem_ctx, 402 const struct hive_key *k, 403 const char **name, uint32_t *data_type, 404 DATA_BLOB *data) 304 405 { 305 406 struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data); … … 309 410 int ret; 310 411 311 ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_BASE, attrs, " %s", "");412 ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_BASE, attrs, "(dn=*)"); 312 413 313 414 if (ret != LDB_SUCCESS) { … … 317 418 } 318 419 319 if (res->count == 0 || res->msgs[0]->num_elements == 0) 420 if (res->count == 0 || res->msgs[0]->num_elements == 0) { 421 talloc_free(res); 320 422 return WERR_BADFILE; 321 322 reg_ldb_unpack_value(mem_ctx, 323 res->msgs[0], name, data_type, data); 423 } 424 425 if ((data_type != NULL) && (data != NULL)) { 426 reg_ldb_unpack_value(mem_ctx, res->msgs[0], name, data_type, 427 data); 428 } 324 429 325 430 talloc_free(res); … … 329 434 330 435 static WERROR ldb_get_value_by_id(TALLOC_CTX *mem_ctx, struct hive_key *k, 331 int idx, const char **name,436 uint32_t idx, const char **name, 332 437 uint32_t *data_type, DATA_BLOB *data) 333 438 { 334 439 struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data); 335 440 336 /* if default value exists, give it back */441 /* if the default value exists, give it back */ 337 442 if (W_ERROR_IS_OK(ldb_get_default_value(mem_ctx, k, name, data_type, 338 443 data))) { … … 361 466 { 362 467 struct ldb_key_data *kd = talloc_get_type(k, struct ldb_key_data); 363 struct ldb_context *c = kd->ldb; 364 struct ldb_result *res; 365 int ret; 366 char *query; 367 368 if (strlen(name) == 0) { 369 /* default value */ 468 const char *res_name; 469 uint32_t idx; 470 471 /* the default value was requested, give it back */ 472 if (name[0] == '\0') { 370 473 return ldb_get_default_value(mem_ctx, k, NULL, data_type, data); 371 } else { 372 /* normal value */ 373 query = talloc_asprintf(mem_ctx, "(value=%s)", name); 374 ret = ldb_search(c, mem_ctx, &res, kd->dn, LDB_SCOPE_ONELEVEL, NULL, "%s", query); 375 talloc_free(query); 376 377 if (ret != LDB_SUCCESS) { 378 DEBUG(0, ("Error getting values for '%s': %s\n", 379 ldb_dn_get_linearized(kd->dn), ldb_errstring(c))); 380 return WERR_FOOBAR; 381 } 382 383 if (res->count == 0) 384 return WERR_BADFILE; 385 386 reg_ldb_unpack_value(mem_ctx, res->msgs[0], NULL, data_type, data); 387 388 talloc_free(res); 389 } 390 391 return WERR_OK; 474 } 475 476 /* Do the search if necessary */ 477 if (kd->values == NULL) { 478 W_ERROR_NOT_OK_RETURN(cache_values(kd)); 479 } 480 481 for (idx = 0; idx < kd->value_count; idx++) { 482 res_name = ldb_msg_find_attr_as_string(kd->values[idx], "value", 483 ""); 484 if (ldb_attr_cmp(name, res_name) == 0) { 485 reg_ldb_unpack_value(mem_ctx, kd->values[idx], NULL, 486 data_type, data); 487 return WERR_OK; 488 } 489 } 490 491 return WERR_BADFILE; 392 492 } 393 493 … … 396 496 { 397 497 struct ldb_result *res; 398 struct ldb_dn *ld ap_path;498 struct ldb_dn *ldb_path; 399 499 int ret; 400 500 struct ldb_key_data *newkd; … … 402 502 struct ldb_context *c = kd->ldb; 403 503 404 ldap_path = reg_path_to_ldb(mem_ctx, h, name, NULL); 405 406 ret = ldb_search(c, mem_ctx, &res, ldap_path, LDB_SCOPE_BASE, NULL, "(key=*)"); 504 ldb_path = reg_path_to_ldb(mem_ctx, h, name, NULL); 505 W_ERROR_HAVE_NO_MEMORY(ldb_path); 506 507 ret = ldb_search(c, mem_ctx, &res, ldb_path, LDB_SCOPE_BASE, NULL, "(key=*)"); 407 508 408 509 if (ret != LDB_SUCCESS) { 409 510 DEBUG(3, ("Error opening key '%s': %s\n", 410 ldb_dn_get_linearized(ld ap_path), ldb_errstring(c)));511 ldb_dn_get_linearized(ldb_path), ldb_errstring(c))); 411 512 return WERR_FOOBAR; 412 513 } else if (res->count == 0) { 413 514 DEBUG(3, ("Key '%s' not found\n", 414 ldb_dn_get_linearized(ld ap_path)));515 ldb_dn_get_linearized(ldb_path))); 415 516 talloc_free(res); 416 517 return WERR_BADFILE; … … 418 519 419 520 newkd = talloc_zero(mem_ctx, struct ldb_key_data); 521 W_ERROR_HAVE_NO_MEMORY(newkd); 420 522 newkd->key.ops = ®_backend_ldb; 421 523 newkd->ldb = talloc_reference(newkd, kd->ldb); 422 newkd->dn = ldb_dn_copy(mem_ctx, res->msgs[0]->dn); 524 newkd->dn = ldb_dn_copy(newkd, res->msgs[0]->dn); 525 newkd->classname = talloc_steal(newkd, 526 ldb_msg_find_attr_as_string(res->msgs[0], "classname", NULL)); 527 528 talloc_free(res); 423 529 424 530 *key = (struct hive_key *)newkd; … … 442 548 443 549 wrap = ldb_wrap_connect(parent_ctx, ev_ctx, lp_ctx, 444 location, session_info, credentials, 0 , NULL);550 location, session_info, credentials, 0); 445 551 446 552 if (wrap == NULL) { … … 477 583 { 478 584 struct ldb_key_data *parentkd = discard_const_p(struct ldb_key_data, parent); 585 struct ldb_dn *ldb_path; 479 586 struct ldb_message *msg; 480 587 struct ldb_key_data *newkd; 481 588 int ret; 482 589 590 ldb_path = reg_path_to_ldb(mem_ctx, parent, name, NULL); 591 W_ERROR_HAVE_NO_MEMORY(ldb_path); 592 483 593 msg = ldb_msg_new(mem_ctx); 484 485 msg->dn = reg_path_to_ldb(msg, parent, name, NULL); 486 487 ldb_msg_add_string(msg, "key", talloc_strdup(mem_ctx, name)); 488 if (classname != NULL) 489 ldb_msg_add_string(msg, "classname", 490 talloc_strdup(mem_ctx, classname)); 594 W_ERROR_HAVE_NO_MEMORY(msg); 595 596 msg->dn = ldb_path; 597 598 ldb_msg_add_string(msg, "key", name); 599 if (classname != NULL) { 600 ldb_msg_add_string(msg, "classname", classname); 601 } 491 602 492 603 ret = ldb_add(parentkd->ldb, msg); 604 605 talloc_free(msg); 606 493 607 if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) { 494 608 return WERR_ALREADY_EXISTS; … … 500 614 } 501 615 502 DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized( msg->dn)));616 DEBUG(2, ("key added: %s\n", ldb_dn_get_linearized(ldb_path))); 503 617 504 618 newkd = talloc_zero(mem_ctx, struct ldb_key_data); 619 W_ERROR_HAVE_NO_MEMORY(newkd); 505 620 newkd->ldb = talloc_reference(newkd, parentkd->ldb); 506 621 newkd->key.ops = ®_backend_ldb; 507 newkd->dn = talloc_steal(newkd, msg->dn); 622 newkd->dn = talloc_steal(newkd, ldb_path); 623 newkd->classname = talloc_steal(newkd, classname); 508 624 509 625 *newkey = (struct hive_key *)newkd; … … 516 632 } 517 633 518 static WERROR ldb_del_value (struct hive_key *key, const char *child) 634 static WERROR ldb_del_value(TALLOC_CTX *mem_ctx, struct hive_key *key, 635 const char *child) 519 636 { 520 637 int ret; 521 638 struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data); 522 TALLOC_CTX *mem_ctx;523 639 struct ldb_message *msg; 524 640 struct ldb_dn *childdn; 525 641 526 if ( strlen(child) == 0) {642 if (child[0] == '\0') { 527 643 /* default value */ 528 mem_ctx = talloc_init("ldb_del_value");529 530 644 msg = talloc_zero(mem_ctx, struct ldb_message); 645 W_ERROR_HAVE_NO_MEMORY(msg); 531 646 msg->dn = ldb_dn_copy(msg, kd->dn); 647 W_ERROR_HAVE_NO_MEMORY(msg->dn); 532 648 ldb_msg_add_empty(msg, "data", LDB_FLAG_MOD_DELETE, NULL); 533 649 ldb_msg_add_empty(msg, "type", LDB_FLAG_MOD_DELETE, NULL); 534 650 535 651 ret = ldb_modify(kd->ldb, msg); 652 653 talloc_free(msg); 654 536 655 if (ret != LDB_SUCCESS) { 537 656 DEBUG(1, ("ldb_del_value: %s\n", ldb_errstring(kd->ldb))); 538 talloc_free(mem_ctx);539 657 return WERR_FOOBAR; 540 658 } 541 542 talloc_free(mem_ctx);543 659 } else { 544 660 /* normal value */ … … 570 686 } 571 687 572 static WERROR ldb_del_key(const struct hive_key *key, const char *name) 573 { 574 int i, ret; 688 static WERROR ldb_del_key(TALLOC_CTX *mem_ctx, const struct hive_key *key, 689 const char *name) 690 { 691 unsigned int i; 692 int ret; 575 693 struct ldb_key_data *parentkd = talloc_get_type(key, struct ldb_key_data); 576 struct ldb_dn *ldap_path; 577 TALLOC_CTX *mem_ctx = talloc_init("ldb_del_key"); 694 struct ldb_dn *ldb_path; 578 695 struct ldb_context *c = parentkd->ldb; 579 696 struct ldb_result *res_keys; … … 585 702 werr = ldb_open_key(mem_ctx, key, name, &hk); 586 703 if (!W_ERROR_IS_OK(werr)) { 587 talloc_free(mem_ctx);588 704 return werr; 589 705 } 590 706 591 ldap_path = reg_path_to_ldb(mem_ctx, key, name, NULL); 592 if (!ldap_path) { 593 talloc_free(mem_ctx); 594 return WERR_FOOBAR; 595 } 707 ldb_path = reg_path_to_ldb(mem_ctx, key, name, NULL); 708 W_ERROR_HAVE_NO_MEMORY(ldb_path); 596 709 597 710 /* Search for subkeys */ 598 ret = ldb_search(c, mem_ctx, &res_keys, ld ap_path, LDB_SCOPE_ONELEVEL,711 ret = ldb_search(c, mem_ctx, &res_keys, ldb_path, LDB_SCOPE_ONELEVEL, 599 712 NULL, "(key=*)"); 600 713 601 714 if (ret != LDB_SUCCESS) { 602 715 DEBUG(0, ("Error getting subkeys for '%s': %s\n", 603 ldb_dn_get_linearized(ldap_path), ldb_errstring(c))); 604 talloc_free(mem_ctx); 716 ldb_dn_get_linearized(ldb_path), ldb_errstring(c))); 605 717 return WERR_FOOBAR; 606 718 } 607 719 608 720 /* Search for values */ 609 ret = ldb_search(c, mem_ctx, &res_vals, ld ap_path, LDB_SCOPE_ONELEVEL,721 ret = ldb_search(c, mem_ctx, &res_vals, ldb_path, LDB_SCOPE_ONELEVEL, 610 722 NULL, "(value=*)"); 611 723 612 724 if (ret != LDB_SUCCESS) { 613 725 DEBUG(0, ("Error getting values for '%s': %s\n", 614 ldb_dn_get_linearized(ldap_path), ldb_errstring(c))); 615 talloc_free(mem_ctx); 726 ldb_dn_get_linearized(ldb_path), ldb_errstring(c))); 616 727 return WERR_FOOBAR; 617 728 } … … 622 733 if (ret != LDB_SUCCESS) { 623 734 DEBUG(0, ("ldb_transaction_start: %s\n", ldb_errstring(c))); 624 talloc_free(mem_ctx);625 735 return WERR_FOOBAR; 626 736 } … … 631 741 for (i = 0; i < res_keys->count; i++) 632 742 { 633 werr = ldb_del_key(hk, ldb_msg_find_attr_as_string( 743 werr = ldb_del_key(mem_ctx, hk, 744 ldb_msg_find_attr_as_string( 634 745 res_keys->msgs[i], 635 746 "key", NULL)); 636 747 if (!W_ERROR_IS_OK(werr)) { 637 748 ret = ldb_transaction_cancel(c); 638 talloc_free(mem_ctx);639 749 return werr; 640 750 } … … 644 754 for (i = 0; i < res_vals->count; i++) 645 755 { 646 werr = ldb_del_value(hk, ldb_msg_find_attr_as_string( 756 werr = ldb_del_value(mem_ctx, hk, 757 ldb_msg_find_attr_as_string( 647 758 res_vals->msgs[i], 648 759 "value", NULL)); 649 760 if (!W_ERROR_IS_OK(werr)) { 650 761 ret = ldb_transaction_cancel(c); 651 talloc_free(mem_ctx);652 762 return werr; 653 763 } 654 764 } 655 765 } 766 talloc_free(res_keys); 767 talloc_free(res_vals); 656 768 657 769 /* Delete the key itself */ 658 ret = ldb_delete(c, ld ap_path);770 ret = ldb_delete(c, ldb_path); 659 771 660 772 if (ret != LDB_SUCCESS) … … 662 774 DEBUG(1, ("ldb_del_key: %s\n", ldb_errstring(c))); 663 775 ret = ldb_transaction_cancel(c); 664 talloc_free(mem_ctx);665 776 return WERR_FOOBAR; 666 777 } … … 673 784 DEBUG(0, ("ldb_transaction_commit: %s\n", ldb_errstring(c))); 674 785 ret = ldb_transaction_cancel(c); 675 talloc_free(mem_ctx); 676 return WERR_FOOBAR; 677 } 678 679 talloc_free(mem_ctx); 786 return WERR_FOOBAR; 787 } 680 788 681 789 /* reset cache */ … … 692 800 struct ldb_message *msg; 693 801 struct ldb_key_data *kd = talloc_get_type(parent, struct ldb_key_data); 802 unsigned int i; 694 803 int ret; 695 804 TALLOC_CTX *mem_ctx = talloc_init("ldb_set_value"); 696 805 697 806 msg = reg_ldb_pack_value(kd->ldb, mem_ctx, name, type, data); 807 W_ERROR_HAVE_NO_MEMORY(msg); 808 698 809 msg->dn = ldb_dn_copy(msg, kd->dn); 699 700 if (strlen(name) > 0) { 810 W_ERROR_HAVE_NO_MEMORY(msg->dn); 811 812 if (name[0] != '\0') { 701 813 /* For a default value, we add/overwrite the attributes to/of the hive. 702 For a normal value, we create new childs. */814 For a normal value, we create a new child. */ 703 815 if (!ldb_dn_add_child_fmt(msg->dn, "value=%s", 704 816 reg_ldb_escape(mem_ctx, name))) … … 709 821 } 710 822 711 ret = ldb_add(kd->ldb, msg); 712 if (ret == LDB_ERR_ENTRY_ALREADY_EXISTS) { 713 int i; 714 for (i = 0; i < msg->num_elements; i++) { 715 if (msg->elements[i].flags != LDB_FLAG_MOD_DELETE) 716 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE; 717 } 718 ret = ldb_modify(kd->ldb, msg); 719 } 823 /* Try first a "modify" and if this doesn't work do try an "add" */ 824 for (i = 0; i < msg->num_elements; i++) { 825 if (msg->elements[i].flags != LDB_FLAG_MOD_DELETE) { 826 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE; 827 } 828 } 829 ret = ldb_modify(kd->ldb, msg); 830 if (ret == LDB_ERR_NO_SUCH_OBJECT) { 831 i = 0; 832 while (i < msg->num_elements) { 833 if (LDB_FLAG_MOD_TYPE(msg->elements[i].flags) == LDB_FLAG_MOD_DELETE) { 834 ldb_msg_remove_element(msg, &msg->elements[i]); 835 } else { 836 ++i; 837 } 838 } 839 ret = ldb_add(kd->ldb, msg); 840 } 841 if (ret == LDB_ERR_NO_SUCH_ATTRIBUTE) { 842 /* ignore this -> the value didn't exist and also now doesn't */ 843 ret = LDB_SUCCESS; 844 } 845 846 talloc_free(msg); 720 847 721 848 if (ret != LDB_SUCCESS) { … … 744 871 { 745 872 struct ldb_key_data *kd = talloc_get_type(key, struct ldb_key_data); 873 uint32_t default_value_type = REG_NONE; 874 DATA_BLOB default_value = { NULL, 0 }; 875 WERROR werr; 746 876 747 877 /* Initialization */ … … 761 891 *max_valbufsize = 0; 762 892 893 /* We need this to get the default value (if it exists) for counting 894 * the values under the key and for finding out the longest value buffer 895 * size. If no default value exists the DATA_BLOB "default_value" will 896 * remain { NULL, 0 }. */ 897 werr = ldb_get_default_value(mem_ctx, key, NULL, &default_value_type, 898 &default_value); 899 if ((!W_ERROR_IS_OK(werr)) && (!W_ERROR_EQUAL(werr, WERR_BADFILE))) { 900 return werr; 901 } 902 763 903 if (kd->subkeys == NULL) { 764 904 W_ERROR_NOT_OK_RETURN(cache_subkeys(kd)); 765 905 } 766 767 906 if (kd->values == NULL) { 768 907 W_ERROR_NOT_OK_RETURN(cache_values(kd)); 769 908 } 770 909 910 if (classname != NULL) { 911 *classname = kd->classname; 912 } 913 771 914 if (num_subkeys != NULL) { 772 915 *num_subkeys = kd->subkey_count; … … 774 917 if (num_values != NULL) { 775 918 *num_values = kd->value_count; 919 /* also consider the default value if it exists */ 920 if (default_value.data != NULL) { 921 ++(*num_values); 922 } 776 923 } 777 924 778 925 779 926 if (max_subkeynamelen != NULL) { 780 int i;927 unsigned int i; 781 928 struct ldb_message_element *el; 782 783 *max_subkeynamelen = 0;784 929 785 930 for (i = 0; i < kd->subkey_count; i++) { … … 790 935 791 936 if (max_valnamelen != NULL || max_valbufsize != NULL) { 792 int i;937 unsigned int i; 793 938 struct ldb_message_element *el; 794 939 W_ERROR_NOT_OK_RETURN(cache_values(kd)); 795 940 796 if (max_valbufsize != NULL)797 *max_valbufsize = 0;798 799 if (max_valnamelen != NULL)800 *max_valnamelen = 0;941 /* also consider the default value if it exists */ 942 if ((max_valbufsize != NULL) && (default_value.data != NULL)) { 943 *max_valbufsize = MAX(*max_valbufsize, 944 default_value.length); 945 } 801 946 802 947 for (i = 0; i < kd->value_count; i++) { … … 809 954 uint32_t data_type; 810 955 DATA_BLOB data; 811 reg_ldb_unpack_value(mem_ctx, 812 kd->values[i], NULL, 956 reg_ldb_unpack_value(mem_ctx, 957 kd->values[i], NULL, 813 958 &data_type, &data); 814 959 *max_valbufsize = MAX(*max_valbufsize, data.length); … … 817 962 } 818 963 } 964 965 talloc_free(default_value.data); 819 966 820 967 return WERR_OK;
Note:
See TracChangeset
for help on using the changeset viewer.
