root/source4/torture/ldb/ldb.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. torture_ldb_attrs
  2. torture_ldb_dn_attrs
  3. torture_ldb_dn_extended
  4. torture_ldb_dn
  5. torture_ldb_dn_invalid_extended
  6. torture_ldb_init

   1 /* 
   2    Unix SMB/CIFS implementation.
   3 
   4    Test LDB attribute functions
   5 
   6    Copyright (C) Andrew Bartlet <abartlet@samba.org> 2008
   7    
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12    
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17    
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21 
  22 #include "includes.h"
  23 #include "lib/events/events.h"
  24 #include "lib/ldb/include/ldb.h"
  25 #include "lib/ldb/include/ldb_errors.h"
  26 #include "lib/ldb-samba/ldif_handlers.h"
  27 #include "ldb_wrap.h"
  28 #include "dsdb/samdb/samdb.h"
  29 #include "param/param.h"
  30 #include "torture/smbtorture.h"
  31 #include "torture/ldb/proto.h"
  32 
  33 static const char *sid = "S-1-5-21-4177067393-1453636373-93818737";
  34 static const char *hex_sid = "01040000000000051500000081FDF8F815BBA456718F9705";
  35 static const char *guid = "975ac5fa-35d9-431d-b86a-845bcd34fff9";
  36 static const char *guid2 = "{975ac5fa-35d9-431d-b86a-845bcd34fff9}";
  37 static const char *hex_guid = "FAC55A97D9351D43B86A845BCD34FFF9";
  38 
  39 static bool torture_ldb_attrs(struct torture_context *torture)
     /* [<][>][^][v][top][bottom][index][help] */
  40 {
  41         TALLOC_CTX *mem_ctx = talloc_new(torture);
  42         struct ldb_context *ldb;
  43         const struct ldb_schema_attribute *attr;
  44         struct ldb_val string_sid_blob, binary_sid_blob;
  45         struct ldb_val string_guid_blob, string_guid_blob2, binary_guid_blob;
  46 
  47         DATA_BLOB sid_blob = strhex_to_data_blob(mem_ctx, hex_sid);
  48         DATA_BLOB guid_blob = strhex_to_data_blob(mem_ctx, hex_guid);
  49 
  50         torture_assert(torture, 
  51                        ldb = ldb_init(mem_ctx, torture->ev),
  52                        "Failed to init ldb");
  53 
  54         torture_assert_int_equal(torture, 
  55                                  ldb_register_samba_handlers(ldb), 0, 
  56                                  "Failed to register Samba handlers");
  57 
  58         ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
  59 
  60         /* Test SID behaviour */
  61         torture_assert(torture, attr = ldb_schema_attribute_by_name(ldb, "objectSid"), 
  62                        "Failed to get objectSid schema attribute");
  63         
  64         string_sid_blob = data_blob_string_const(sid);
  65 
  66         torture_assert_int_equal(torture, 
  67                                  attr->syntax->ldif_read_fn(ldb, mem_ctx, 
  68                                                             &string_sid_blob, &binary_sid_blob), 0,
  69                                  "Failed to parse string SID");
  70         
  71         torture_assert_data_blob_equal(torture, binary_sid_blob, sid_blob, 
  72                                        "Read SID into blob form failed");
  73         
  74         torture_assert_int_equal(torture, 
  75                                  attr->syntax->ldif_read_fn(ldb, mem_ctx, 
  76                                                             &sid_blob, &binary_sid_blob), -1,
  77                                  "Should have failed to parse binary SID");
  78         
  79         torture_assert_int_equal(torture, 
  80                                  attr->syntax->ldif_write_fn(ldb, mem_ctx, &binary_sid_blob, &string_sid_blob), 0,
  81                                  "Failed to parse binary SID");
  82         
  83         torture_assert_data_blob_equal(torture, 
  84                                        string_sid_blob, data_blob_string_const(sid),
  85                                        "Write SID into string form failed");
  86         
  87         torture_assert_int_equal(torture, 
  88                                  attr->syntax->comparison_fn(ldb, mem_ctx, &binary_sid_blob, &string_sid_blob), 0,
  89                                  "Failed to compare binary and string SID");
  90         
  91         torture_assert_int_equal(torture, 
  92                                  attr->syntax->comparison_fn(ldb, mem_ctx, &string_sid_blob, &binary_sid_blob), 0,
  93                                  "Failed to compare string and binary binary SID");
  94         
  95         torture_assert_int_equal(torture, 
  96                                  attr->syntax->comparison_fn(ldb, mem_ctx, &string_sid_blob, &string_sid_blob), 0,
  97                                  "Failed to compare string and string SID");
  98         
  99         torture_assert_int_equal(torture, 
 100                                  attr->syntax->comparison_fn(ldb, mem_ctx, &binary_sid_blob, &binary_sid_blob), 0,
 101                                  "Failed to compare binary and binary SID");
 102         
 103         torture_assert(torture, attr->syntax->comparison_fn(ldb, mem_ctx, &guid_blob, &binary_sid_blob) != 0,
 104                        "Failed to distinguish binary GUID and binary SID");
 105 
 106 
 107         /* Test GUID behaviour */
 108         torture_assert(torture, attr = ldb_schema_attribute_by_name(ldb, "objectGUID"), 
 109                        "Failed to get objectGUID schema attribute");
 110         
 111         string_guid_blob = data_blob_string_const(guid);
 112 
 113         torture_assert_int_equal(torture, 
 114                                  attr->syntax->ldif_read_fn(ldb, mem_ctx, 
 115                                                             &string_guid_blob, &binary_guid_blob), 0,
 116                                  "Failed to parse string GUID");
 117         
 118         torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob, 
 119                                        "Read GUID into blob form failed");
 120         
 121         string_guid_blob2 = data_blob_string_const(guid2);
 122         
 123         torture_assert_int_equal(torture, 
 124                                  attr->syntax->ldif_read_fn(ldb, mem_ctx, 
 125                                                             &string_guid_blob2, &binary_guid_blob), 0,
 126                                  "Failed to parse string GUID");
 127         
 128         torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob, 
 129                                        "Read GUID into blob form failed");
 130         
 131         torture_assert_int_equal(torture, 
 132                                  attr->syntax->ldif_read_fn(ldb, mem_ctx, 
 133                                                             &guid_blob, &binary_guid_blob), 0,
 134                                  "Failed to parse binary GUID");
 135         
 136         torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob, 
 137                                        "Read GUID into blob form failed");
 138         
 139         torture_assert_int_equal(torture, 
 140                                  attr->syntax->ldif_write_fn(ldb, mem_ctx, &binary_guid_blob, &string_guid_blob), 0,
 141                                  "Failed to print binary GUID as string");
 142 
 143         torture_assert_data_blob_equal(torture, string_sid_blob, data_blob_string_const(sid),
 144                                        "Write SID into string form failed");
 145         
 146         torture_assert_int_equal(torture, 
 147                                  attr->syntax->comparison_fn(ldb, mem_ctx, &binary_guid_blob, &string_guid_blob), 0,
 148                                  "Failed to compare binary and string GUID");
 149         
 150         torture_assert_int_equal(torture, 
 151                                  attr->syntax->comparison_fn(ldb, mem_ctx, &string_guid_blob, &binary_guid_blob), 0,
 152                                  "Failed to compare string and binary binary GUID");
 153         
 154         torture_assert_int_equal(torture, 
 155                                  attr->syntax->comparison_fn(ldb, mem_ctx, &string_guid_blob, &string_guid_blob), 0,
 156                                  "Failed to compare string and string GUID");
 157         
 158         torture_assert_int_equal(torture, 
 159                                  attr->syntax->comparison_fn(ldb, mem_ctx, &binary_guid_blob, &binary_guid_blob), 0,
 160                                  "Failed to compare binary and binary GUID");
 161         
 162         
 163         
 164         talloc_free(mem_ctx);
 165         return true;
 166 }
 167 
 168 static bool torture_ldb_dn_attrs(struct torture_context *torture)
     /* [<][>][^][v][top][bottom][index][help] */
 169 {
 170         TALLOC_CTX *mem_ctx = talloc_new(torture);
 171         struct ldb_context *ldb;
 172         const struct ldb_dn_extended_syntax *attr;
 173         struct ldb_val string_sid_blob, binary_sid_blob;
 174         struct ldb_val string_guid_blob, binary_guid_blob;
 175         struct ldb_val hex_sid_blob, hex_guid_blob;
 176 
 177         DATA_BLOB sid_blob = strhex_to_data_blob(mem_ctx, hex_sid);
 178         DATA_BLOB guid_blob = strhex_to_data_blob(mem_ctx, hex_guid);
 179 
 180         torture_assert(torture, 
 181                        ldb = ldb_init(mem_ctx, torture->ev),
 182                        "Failed to init ldb");
 183 
 184         torture_assert_int_equal(torture, 
 185                                  ldb_register_samba_handlers(ldb), 0, 
 186                                  "Failed to register Samba handlers");
 187 
 188         ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
 189 
 190         /* Test SID behaviour */
 191         torture_assert(torture, attr = ldb_dn_extended_syntax_by_name(ldb, "SID"), 
 192                        "Failed to get SID DN syntax");
 193         
 194         string_sid_blob = data_blob_string_const(sid);
 195 
 196         torture_assert_int_equal(torture, 
 197                                  attr->read_fn(ldb, mem_ctx, 
 198                                                &string_sid_blob, &binary_sid_blob), 0,
 199                                  "Failed to parse string SID");
 200         
 201         torture_assert_data_blob_equal(torture, binary_sid_blob, sid_blob, 
 202                                        "Read SID into blob form failed");
 203 
 204         hex_sid_blob = data_blob_string_const(hex_sid);
 205         
 206         torture_assert_int_equal(torture, 
 207                                  attr->read_fn(ldb, mem_ctx, 
 208                                                &hex_sid_blob, &binary_sid_blob), 0,
 209                                  "Failed to parse HEX SID");
 210         
 211         torture_assert_data_blob_equal(torture, binary_sid_blob, sid_blob, 
 212                                        "Read SID into blob form failed");
 213         
 214         torture_assert_int_equal(torture, 
 215                                  attr->read_fn(ldb, mem_ctx, 
 216                                                &sid_blob, &binary_sid_blob), -1,
 217                                  "Should have failed to parse binary SID");
 218         
 219         torture_assert_int_equal(torture, 
 220                                  attr->write_hex_fn(ldb, mem_ctx, &sid_blob, &hex_sid_blob), 0,
 221                                  "Failed to parse binary SID");
 222         
 223         torture_assert_data_blob_equal(torture, 
 224                                        hex_sid_blob, data_blob_string_const(hex_sid),
 225                                        "Write SID into HEX string form failed");
 226         
 227         torture_assert_int_equal(torture, 
 228                                  attr->write_clear_fn(ldb, mem_ctx, &sid_blob, &string_sid_blob), 0,
 229                                  "Failed to parse binary SID");
 230         
 231         torture_assert_data_blob_equal(torture, 
 232                                        string_sid_blob, data_blob_string_const(sid),
 233                                        "Write SID into clear string form failed");
 234         
 235 
 236         /* Test GUID behaviour */
 237         torture_assert(torture, attr = ldb_dn_extended_syntax_by_name(ldb, "GUID"), 
 238                        "Failed to get GUID DN syntax");
 239         
 240         string_guid_blob = data_blob_string_const(guid);
 241 
 242         torture_assert_int_equal(torture, 
 243                                  attr->read_fn(ldb, mem_ctx, 
 244                                                &string_guid_blob, &binary_guid_blob), 0,
 245                                  "Failed to parse string GUID");
 246         
 247         torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob, 
 248                                        "Read GUID into blob form failed");
 249         
 250         hex_guid_blob = data_blob_string_const(hex_guid);
 251         
 252         torture_assert_int_equal(torture, 
 253                                  attr->read_fn(ldb, mem_ctx, 
 254                                                &hex_guid_blob, &binary_guid_blob), 0,
 255                                  "Failed to parse HEX GUID");
 256         
 257         torture_assert_data_blob_equal(torture, binary_guid_blob, guid_blob, 
 258                                        "Read GUID into blob form failed");
 259         
 260         torture_assert_int_equal(torture, 
 261                                  attr->read_fn(ldb, mem_ctx, 
 262                                                &guid_blob, &binary_guid_blob), -1,
 263                                  "Should have failed to parse binary GUID");
 264         
 265         torture_assert_int_equal(torture, 
 266                                  attr->write_hex_fn(ldb, mem_ctx, &guid_blob, &hex_guid_blob), 0,
 267                                  "Failed to parse binary GUID");
 268         
 269         torture_assert_data_blob_equal(torture, 
 270                                        hex_guid_blob, data_blob_string_const(hex_guid),
 271                                        "Write GUID into HEX string form failed");
 272         
 273         torture_assert_int_equal(torture, 
 274                                  attr->write_clear_fn(ldb, mem_ctx, &guid_blob, &string_guid_blob), 0,
 275                                  "Failed to parse binary GUID");
 276         
 277         torture_assert_data_blob_equal(torture, 
 278                                        string_guid_blob, data_blob_string_const(guid),
 279                                        "Write GUID into clear string form failed");
 280         
 281 
 282 
 283         talloc_free(mem_ctx);
 284         return true;
 285 }
 286 
 287 static bool torture_ldb_dn_extended(struct torture_context *torture)
     /* [<][>][^][v][top][bottom][index][help] */
 288 {
 289         TALLOC_CTX *mem_ctx = talloc_new(torture);
 290         struct ldb_context *ldb;
 291         struct ldb_dn *dn, *dn2;
 292 
 293         DATA_BLOB sid_blob = strhex_to_data_blob(mem_ctx, hex_sid);
 294         DATA_BLOB guid_blob = strhex_to_data_blob(mem_ctx, hex_guid);
 295 
 296         const char *dn_str = "cn=admin,cn=users,dc=samba,dc=org";
 297 
 298         torture_assert(torture, 
 299                        ldb = ldb_init(mem_ctx, torture->ev),
 300                        "Failed to init ldb");
 301 
 302         torture_assert_int_equal(torture, 
 303                                  ldb_register_samba_handlers(ldb), 0, 
 304                                  "Failed to register Samba handlers");
 305 
 306         ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
 307 
 308         /* Check behaviour of a normal DN */
 309         torture_assert(torture, 
 310                        dn = ldb_dn_new(mem_ctx, ldb, dn_str), 
 311                        "Failed to create a 'normal' DN");
 312 
 313         torture_assert(torture, 
 314                        ldb_dn_validate(dn),
 315                        "Failed to validate 'normal' DN");
 316 
 317         torture_assert(torture, ldb_dn_has_extended(dn) == false, 
 318                        "Should not find plain DN to be 'extended'");
 319 
 320         torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL, 
 321                        "Should not find an SID on plain DN");
 322 
 323         torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL, 
 324                        "Should not find an GUID on plain DN");
 325         
 326         torture_assert(torture, ldb_dn_get_extended_component(dn, "WKGUID") == NULL, 
 327                        "Should not find an WKGUID on plain DN");
 328         
 329         /* Now make an extended DN */
 330         torture_assert(torture, 
 331                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>;<SID=%s>;%s",
 332                                            guid, sid, dn_str), 
 333                        "Failed to create an 'extended' DN");
 334 
 335         torture_assert(torture, 
 336                        dn2 = ldb_dn_copy(mem_ctx, dn), 
 337                        "Failed to copy the 'extended' DN");
 338         talloc_free(dn);
 339         dn = dn2;
 340 
 341         torture_assert(torture, 
 342                        ldb_dn_validate(dn),
 343                        "Failed to validate 'extended' DN");
 344 
 345         torture_assert(torture, ldb_dn_has_extended(dn) == true, 
 346                        "Should find extended DN to be 'extended'");
 347 
 348         torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") != NULL, 
 349                        "Should find an SID on extended DN");
 350 
 351         torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") != NULL, 
 352                        "Should find an GUID on extended DN");
 353         
 354         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob, 
 355                                        "Extended DN SID incorect");
 356 
 357         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob, 
 358                                        "Extended DN GUID incorect");
 359 
 360         torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), dn_str, 
 361                                  "linearized DN incorrect");
 362 
 363         torture_assert_str_equal(torture, ldb_dn_get_casefold(dn), strupper_talloc(mem_ctx, dn_str), 
 364                                  "casefolded DN incorrect");
 365 
 366         torture_assert_str_equal(torture, ldb_dn_get_component_name(dn, 0), "cn", 
 367                                  "componet zero incorrect");
 368 
 369         torture_assert_data_blob_equal(torture, *ldb_dn_get_component_val(dn, 0), data_blob_string_const("admin"), 
 370                                  "componet zero incorrect");
 371 
 372         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
 373                                  talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s", 
 374                                                  guid, sid, dn_str),
 375                                  "Clear extended linearized DN incorrect");
 376 
 377         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
 378                                  talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s", 
 379                                                  hex_guid, hex_sid, dn_str),
 380                                  "HEX extended linearized DN incorrect");
 381 
 382         torture_assert(torture, ldb_dn_remove_child_components(dn, 1) == true,
 383                                  "Failed to remove DN child");
 384                        
 385         torture_assert(torture, ldb_dn_has_extended(dn) == false, 
 386                        "Extended DN flag should be cleared after child element removal");
 387         
 388         torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL, 
 389                        "Should not find an SID on DN");
 390 
 391         torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL, 
 392                        "Should not find an GUID on DN");
 393 
 394 
 395         /* TODO:  test setting these in the other order, and ensure it still comes out 'GUID first' */
 396         torture_assert_int_equal(torture, ldb_dn_set_extended_component(dn, "GUID", &guid_blob), 0, 
 397                        "Failed to set a GUID on DN");
 398         
 399         torture_assert_int_equal(torture, ldb_dn_set_extended_component(dn, "SID", &sid_blob), 0, 
 400                        "Failed to set a SID on DN");
 401 
 402         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob, 
 403                                        "Extended DN SID incorect");
 404 
 405         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob, 
 406                                        "Extended DN GUID incorect");
 407 
 408         torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "cn=users,dc=samba,dc=org", 
 409                                  "linearized DN incorrect");
 410 
 411         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
 412                                  talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s", 
 413                                                  guid, sid, "cn=users,dc=samba,dc=org"),
 414                                  "Clear extended linearized DN incorrect");
 415 
 416         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
 417                                  talloc_asprintf(mem_ctx, "<GUID=%s>;<SID=%s>;%s", 
 418                                                  hex_guid, hex_sid, "cn=users,dc=samba,dc=org"),
 419                                  "HEX extended linearized DN incorrect");
 420 
 421         /* Now check a 'just GUID' DN (clear format) */
 422         torture_assert(torture, 
 423                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>",
 424                                            guid), 
 425                        "Failed to create an 'extended' DN");
 426 
 427         torture_assert(torture, 
 428                        ldb_dn_validate(dn),
 429                        "Failed to validate 'extended' DN");
 430 
 431         torture_assert(torture, ldb_dn_has_extended(dn) == true, 
 432                        "Should find extended DN to be 'extended'");
 433 
 434         torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL, 
 435                        "Should not find an SID on this DN");
 436 
 437         torture_assert_int_equal(torture, ldb_dn_get_comp_num(dn), 0, 
 438                        "Should not find an 'normal' componet on this DN");
 439 
 440         torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") != NULL, 
 441                        "Should find an GUID on this DN");
 442         
 443         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob, 
 444                                        "Extended DN GUID incorect");
 445 
 446         torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "", 
 447                                  "linearized DN incorrect");
 448 
 449         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
 450                                  talloc_asprintf(mem_ctx, "<GUID=%s>", 
 451                                                  guid),
 452                                  "Clear extended linearized DN incorrect");
 453 
 454         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
 455                                  talloc_asprintf(mem_ctx, "<GUID=%s>", 
 456                                                  hex_guid),
 457                                  "HEX extended linearized DN incorrect");
 458 
 459         /* Now check a 'just GUID' DN (HEX format) */
 460         torture_assert(torture, 
 461                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>",
 462                                            hex_guid), 
 463                        "Failed to create an 'extended' DN");
 464 
 465         torture_assert(torture, 
 466                        ldb_dn_validate(dn),
 467                        "Failed to validate 'extended' DN");
 468 
 469         torture_assert(torture, ldb_dn_has_extended(dn) == true, 
 470                        "Should find extended DN to be 'extended'");
 471 
 472         torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") == NULL, 
 473                        "Should not find an SID on this DN");
 474 
 475         torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") != NULL, 
 476                        "Should find an GUID on this DN");
 477         
 478         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "GUID"), guid_blob, 
 479                                        "Extended DN GUID incorect");
 480 
 481         torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "", 
 482                                  "linearized DN incorrect");
 483 
 484         /* Now check a 'just SID' DN (clear format) */
 485         torture_assert(torture, 
 486                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>",
 487                                            sid), 
 488                        "Failed to create an 'extended' DN");
 489 
 490         torture_assert(torture, 
 491                        ldb_dn_validate(dn),
 492                        "Failed to validate 'extended' DN");
 493 
 494         torture_assert(torture, ldb_dn_has_extended(dn) == true, 
 495                        "Should find extended DN to be 'extended'");
 496 
 497         torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL, 
 498                        "Should not find an SID on this DN");
 499 
 500         torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") != NULL, 
 501                        "Should find an SID on this DN");
 502         
 503         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob, 
 504                                        "Extended DN SID incorect");
 505 
 506         torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "", 
 507                                  "linearized DN incorrect");
 508 
 509         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 1),
 510                                  talloc_asprintf(mem_ctx, "<SID=%s>", 
 511                                                  sid),
 512                                  "Clear extended linearized DN incorrect");
 513 
 514         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0),
 515                                  talloc_asprintf(mem_ctx, "<SID=%s>", 
 516                                                  hex_sid),
 517                                  "HEX extended linearized DN incorrect");
 518 
 519         /* Now check a 'just SID' DN (HEX format) */
 520         torture_assert(torture, 
 521                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>",
 522                                            hex_sid), 
 523                        "Failed to create an 'extended' DN");
 524 
 525         torture_assert(torture, 
 526                        ldb_dn_validate(dn),
 527                        "Failed to validate 'extended' DN");
 528 
 529         torture_assert(torture, ldb_dn_has_extended(dn) == true, 
 530                        "Should find extended DN to be 'extended'");
 531 
 532         torture_assert(torture, ldb_dn_get_extended_component(dn, "GUID") == NULL, 
 533                        "Should not find an SID on this DN");
 534 
 535         torture_assert(torture, ldb_dn_get_extended_component(dn, "SID") != NULL, 
 536                        "Should find an SID on this DN");
 537         
 538         torture_assert_data_blob_equal(torture, *ldb_dn_get_extended_component(dn, "SID"), sid_blob, 
 539                                        "Extended DN SID incorect");
 540 
 541         torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "", 
 542                                  "linearized DN incorrect");
 543 
 544         talloc_free(mem_ctx);
 545         return true;
 546 }
 547 
 548 
 549 static bool torture_ldb_dn(struct torture_context *torture)
     /* [<][>][^][v][top][bottom][index][help] */
 550 {
 551         TALLOC_CTX *mem_ctx = talloc_new(torture);
 552         struct ldb_context *ldb;
 553         struct ldb_dn *dn;
 554         struct ldb_dn *child_dn;
 555         struct ldb_dn *typo_dn;
 556 
 557         torture_assert(torture, 
 558                        ldb = ldb_init(mem_ctx, torture->ev),
 559                        "Failed to init ldb");
 560 
 561         torture_assert_int_equal(torture, 
 562                                  ldb_register_samba_handlers(ldb), 0, 
 563                                  "Failed to register Samba handlers");
 564 
 565         ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
 566 
 567         /* Check behaviour of a normal DN */
 568         torture_assert(torture, 
 569                        dn = ldb_dn_new(mem_ctx, ldb, NULL), 
 570                        "Failed to create a NULL DN");
 571 
 572         torture_assert(torture, 
 573                        ldb_dn_validate(dn),
 574                        "Failed to validate NULL DN");
 575 
 576         torture_assert(torture, 
 577                        ldb_dn_add_base_fmt(dn, "dc=org"), 
 578                        "Failed to add base DN");
 579 
 580         torture_assert(torture, 
 581                        ldb_dn_add_child_fmt(dn, "dc=samba"), 
 582                        "Failed to add base DN");
 583 
 584         torture_assert_str_equal(torture, ldb_dn_get_linearized(dn), "dc=samba,dc=org", 
 585                                  "linearized DN incorrect");
 586 
 587         torture_assert_str_equal(torture, ldb_dn_get_extended_linearized(mem_ctx, dn, 0), "dc=samba,dc=org", 
 588                                  "extended linearized DN incorrect");
 589 
 590         /* Check child DN comparisons */
 591         torture_assert(torture, 
 592                        child_dn = ldb_dn_new(mem_ctx, ldb, "CN=users,DC=SAMBA,DC=org"), 
 593                        "Failed to create child DN");
 594 
 595         torture_assert(torture, 
 596                        ldb_dn_compare(dn, child_dn) != 0,
 597                        "Comparison on dc=samba,dc=org and CN=users,DC=SAMBA,DC=org should != 0");
 598 
 599         torture_assert(torture, 
 600                        ldb_dn_compare_base(child_dn, dn) != 0,
 601                        "Base Comparison of CN=users,DC=SAMBA,DC=org and dc=samba,dc=org should != 0");
 602 
 603         torture_assert(torture, 
 604                        ldb_dn_compare_base(dn, child_dn) == 0,
 605                        "Base Comparison on dc=samba,dc=org and CN=users,DC=SAMBA,DC=org should == 0");
 606 
 607         /* Check comparisons with a truncated DN */
 608         torture_assert(torture, 
 609                        typo_dn = ldb_dn_new(mem_ctx, ldb, "c=samba,dc=org"), 
 610                        "Failed to create 'typo' DN");
 611 
 612         torture_assert(torture, 
 613                        ldb_dn_compare(dn, typo_dn) != 0,
 614                        "Comparison on dc=samba,dc=org and c=samba,dc=org should != 0");
 615 
 616         torture_assert(torture, 
 617                        ldb_dn_compare_base(typo_dn, dn) != 0,
 618                        "Base Comparison of c=samba,dc=org and dc=samba,dc=org should != 0");
 619 
 620         torture_assert(torture, 
 621                        ldb_dn_compare_base(dn, typo_dn) != 0,
 622                        "Base Comparison on dc=samba,dc=org and c=samba,dc=org should != 0");
 623 
 624         talloc_free(mem_ctx);
 625         return true;
 626 }
 627 
 628 static bool torture_ldb_dn_invalid_extended(struct torture_context *torture)
     /* [<][>][^][v][top][bottom][index][help] */
 629 {
 630         TALLOC_CTX *mem_ctx = talloc_new(torture);
 631         struct ldb_context *ldb;
 632         struct ldb_dn *dn;
 633 
 634         const char *dn_str = "cn=admin,cn=users,dc=samba,dc=org";
 635 
 636         torture_assert(torture, 
 637                        ldb = ldb_init(mem_ctx, torture->ev),
 638                        "Failed to init ldb");
 639 
 640         torture_assert_int_equal(torture, 
 641                                  ldb_register_samba_handlers(ldb), 0, 
 642                                  "Failed to register Samba handlers");
 643 
 644         ldb_set_utf8_fns(ldb, NULL, wrap_casefold);
 645 
 646         /* Check behaviour of a normal DN */
 647         torture_assert(torture, 
 648                        dn = ldb_dn_new(mem_ctx, ldb, "samba,dc=org"), 
 649                        "Failed to create a 'normal' invalid DN");
 650 
 651         torture_assert(torture, 
 652                        ldb_dn_validate(dn) == false,
 653                        "should have failed to validate 'normal' invalid DN");
 654 
 655         /* Now make an extended DN */
 656         torture_assert(torture, 
 657                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<PID=%s>;%s",
 658                                            sid, dn_str), 
 659                        "Failed to create an invalid 'extended' DN");
 660 
 661         torture_assert(torture, 
 662                        ldb_dn_validate(dn) == false,
 663                        "should have failed to validate 'extended' DN");
 664 
 665         torture_assert(torture, 
 666                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>%s",
 667                                            sid, dn_str), 
 668                        "Failed to create an invalid 'extended' DN");
 669 
 670         torture_assert(torture, 
 671                        ldb_dn_validate(dn) == false,
 672                        "should have failed to validate 'extended' DN");
 673 
 674         torture_assert(torture, 
 675                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>;",
 676                                            sid), 
 677                        "Failed to create an invalid 'extended' DN");
 678 
 679         torture_assert(torture, 
 680                        ldb_dn_validate(dn) == false,
 681                        "should have failed to validate 'extended' DN");
 682 
 683         torture_assert(torture, 
 684                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=%s>;",
 685                                            hex_sid), 
 686                        "Failed to create an invalid 'extended' DN");
 687 
 688         torture_assert(torture, 
 689                        ldb_dn_validate(dn) == false,
 690                        "should have failed to validate 'extended' DN");
 691 
 692         torture_assert(torture, 
 693                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>;",
 694                                            hex_guid), 
 695                        "Failed to create an invalid 'extended' DN");
 696 
 697         torture_assert(torture, 
 698                        ldb_dn_validate(dn) == false,
 699                        "should have failed to validate 'extended' DN");
 700 
 701         torture_assert(torture, 
 702                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<SID=%s>;",
 703                                            guid), 
 704                        "Failed to create an invalid 'extended' DN");
 705 
 706         torture_assert(torture, 
 707                        ldb_dn_validate(dn) == false,
 708                        "should have failed to validate 'extended' DN");
 709 
 710         torture_assert(torture, 
 711                        dn = ldb_dn_new_fmt(mem_ctx, ldb, "<GUID=>"), 
 712                        "Failed to create an invalid 'extended' DN");
 713 
 714         torture_assert(torture, 
 715                        ldb_dn_validate(dn) == false,
 716                        "should have failed to validate 'extended' DN");
 717 
 718         return true;
 719 }
 720 
 721 NTSTATUS torture_ldb_init(void)
     /* [<][>][^][v][top][bottom][index][help] */
 722 {
 723         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "LDB");
 724         torture_suite_add_simple_test(suite, "ATTRS", torture_ldb_attrs);
 725         torture_suite_add_simple_test(suite, "DN-ATTRS", torture_ldb_dn_attrs);
 726         torture_suite_add_simple_test(suite, "DN-EXTENDED", torture_ldb_dn_extended);
 727         torture_suite_add_simple_test(suite, "DN-INVALID-EXTENDED", torture_ldb_dn_invalid_extended);
 728         torture_suite_add_simple_test(suite, "DN", torture_ldb_dn);
 729 
 730         suite->description = talloc_strdup(suite, "LDB (samba-specific behaviour) tests");
 731 
 732         torture_register_suite(suite);
 733 
 734         return NT_STATUS_OK;
 735 }

/* [<][>][^][v][top][bottom][index][help] */