source4/dsdb/schema/schema_info_attr.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    SCHEMA::schemaInfo implementation
   5
   6    Copyright (C) Kamen Mazdrashki <kamenim@samba.org> 2010
   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 "dsdb/common/util.h"
  24 #include "dsdb/samdb/samdb.h"
  25 #include "dsdb/samdb/ldb_modules/util.h"
  26 #include "lib/ldb/include/ldb_module.h"
  27 #include "librpc/gen_ndr/ndr_drsuapi.h"
  28 #include "librpc/gen_ndr/ndr_drsblobs.h"
  29 #include "param/param.h"
  30
  31
  32 /**
  33  * Creates and initializes new dsdb_schema_info value.
  34  * Initial schemaInfo values is with:
  35  *   revision = 0
  36  *   invocationId = GUID_ZERO
  37  */
  38 WERROR dsdb_schema_info_new(TALLOC_CTX *mem_ctx, struct dsdb_schema_info **_schema_info)
  39 {
  40         struct dsdb_schema_info *schema_info;
  41
  42         schema_info = talloc_zero(mem_ctx, struct dsdb_schema_info);
  43         W_ERROR_HAVE_NO_MEMORY(schema_info);
  44
  45         *_schema_info = schema_info;
  46
  47         return WERR_OK;
  48 }
  49
  50 /**
  51  * Creates and initializes new dsdb_schema_info blob value.
  52  * Initial schemaInfo values is with:
  53  *   revision = 0
  54  *   invocationId = GUID_ZERO
  55  */
  56 WERROR dsdb_schema_info_blob_new(TALLOC_CTX *mem_ctx, DATA_BLOB *_schema_info_blob)
  57 {
  58         DATA_BLOB blob;
  59
  60         blob = data_blob_talloc_zero(mem_ctx, 21);
  61         W_ERROR_HAVE_NO_MEMORY(blob.data);
  62
  63         /* Set the schemaInfo marker to 0xFF */
  64         blob.data[0] = 0xFF;
  65
  66         *_schema_info_blob = blob;
  67
  68         return WERR_OK;
  69 }
  70
  71
  72 /**
  73  * Parse schemaInfo structure from a data_blob
  74  * (DATA_BLOB or ldb_val).
  75  * Suitable for parsing blobs that comes from
  76  * DRS interface of from LDB database
  77  */
  78 WERROR dsdb_schema_info_from_blob(const DATA_BLOB *blob,
  79                                   TALLOC_CTX *mem_ctx, struct dsdb_schema_info **_schema_info)
  80 {
  81         TALLOC_CTX *temp_ctx;
  82         enum ndr_err_code ndr_err;
  83         struct dsdb_schema_info *schema_info;
  84         struct schemaInfoBlob schema_info_blob;
  85
  86         if (!blob || !blob->data) {
  87                 return WERR_INVALID_PARAMETER;
  88         }
  89
  90         if (blob->length != 21) {
  91                 return WERR_INVALID_PARAMETER;
  92         }
  93
  94         /* schemaInfo blob should start with 0xFF */
  95         if (blob->data[0] != 0xFF) {
  96                 return WERR_INVALID_PARAMETER;
  97         }
  98
  99         temp_ctx = talloc_new(mem_ctx);
 100         W_ERROR_HAVE_NO_MEMORY(temp_ctx);
 101
 102         ndr_err = ndr_pull_struct_blob_all(blob, temp_ctx,
 103                                            &schema_info_blob,
 104                                            (ndr_pull_flags_fn_t)ndr_pull_schemaInfoBlob);
 105         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 106                 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
 107                 talloc_free(temp_ctx);
 108                 return ntstatus_to_werror(nt_status);
 109         }
 110
 111         schema_info = talloc(mem_ctx, struct dsdb_schema_info);
 112         if (!schema_info) {
 113                 talloc_free(temp_ctx);
 114                 return WERR_NOMEM;
 115         }
 116
 117         /* note that we accept revision numbers of zero now - w2k8r2
 118            sends a revision of zero on initial vampire */
 119         schema_info->revision      = schema_info_blob.revision;
 120         schema_info->invocation_id = schema_info_blob.invocation_id;
 121         *_schema_info = schema_info;
 122
 123         talloc_free(temp_ctx);
 124         return WERR_OK;
 125 }
 126
 127 /**
 128  * Creates a blob from schemaInfo structure
 129  * Suitable for packing schemaInfo into a blob
 130  * which is to be used in DRS interface of LDB database
 131  */
 132 WERROR dsdb_blob_from_schema_info(const struct dsdb_schema_info *schema_info,
 133                                   TALLOC_CTX *mem_ctx, DATA_BLOB *blob)
 134 {
 135         enum ndr_err_code ndr_err;
 136         struct schemaInfoBlob schema_info_blob;
 137
 138         schema_info_blob.marker         = 0xFF;
 139         schema_info_blob.revision       = schema_info->revision;
 140         schema_info_blob.invocation_id  = schema_info->invocation_id;
 141
 142         ndr_err = ndr_push_struct_blob(blob, mem_ctx,
 143                                        &schema_info_blob,
 144                                        (ndr_push_flags_fn_t)ndr_push_schemaInfoBlob);
 145         if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
 146                 NTSTATUS nt_status = ndr_map_error2ntstatus(ndr_err);
 147                 return ntstatus_to_werror(nt_status);
 148         }
 149
 150         return WERR_OK;
 151 }
 152
 153
 154 /**
 155  * Reads schema_info structure from schemaInfo
 156  * attribute on SCHEMA partition
 157  *
 158  * @param dsdb_flags    DSDB_FLAG_... flag of 0
 159  */
 160 WERROR dsdb_module_schema_info_blob_read(struct ldb_module *ldb_module,
 161                                          uint32_t dsdb_flags,
 162                                          TALLOC_CTX *mem_ctx, DATA_BLOB *schema_info_blob)
 163 {
 164         int ldb_err;
 165         const struct ldb_val *blob_val;
 166         struct ldb_dn *schema_dn;
 167         struct ldb_result *schema_res = NULL;
 168         static const char *schema_attrs[] = {
 169                 "schemaInfo",
 170                 NULL
 171         };
 172
 173         schema_dn = ldb_get_schema_basedn(ldb_module_get_ctx(ldb_module));
 174         if (!schema_dn) {
 175                 DEBUG(0,("dsdb_module_schema_info_blob_read: no schema dn present!\n"));
 176                 return WERR_INTERNAL_DB_CORRUPTION;
 177         }
 178
 179         ldb_err = dsdb_module_search(ldb_module, mem_ctx, &schema_res, schema_dn,
 180                                      LDB_SCOPE_BASE, schema_attrs, dsdb_flags, NULL);
 181         if (ldb_err == LDB_ERR_NO_SUCH_OBJECT) {
 182                 DEBUG(0,("dsdb_module_schema_info_blob_read: Schema DN not found!\n"));
 183                 talloc_free(schema_res);
 184                 return WERR_INTERNAL_DB_CORRUPTION;
 185         } else if (ldb_err != LDB_SUCCESS) {
 186                 DEBUG(0,("dsdb_module_schema_info_blob_read: failed to find schemaInfo attribute\n"));
 187                 talloc_free(schema_res);
 188                 return WERR_INTERNAL_DB_CORRUPTION;
 189         }
 190
 191         blob_val = ldb_msg_find_ldb_val(schema_res->msgs[0], "schemaInfo");
 192         if (!blob_val) {
 193                 DEBUG(0,("dsdb_module_schema_info_blob_read: no schemaInfo attribute found\n"));
 194                 talloc_free(schema_res);
 195                 return WERR_DS_NO_ATTRIBUTE_OR_VALUE;
 196         }
 197
 198         /* transfer .data ownership to mem_ctx */
 199         schema_info_blob->length = blob_val->length;
 200         schema_info_blob->data = talloc_steal(mem_ctx, blob_val->data);
 201
 202         talloc_free(schema_res);
 203
 204         return WERR_OK;
 205 }
 206
 207 /**
 208  * Prepares ldb_msg to be used for updating schemaInfo value in DB
 209  */
 210 static WERROR _dsdb_schema_info_write_prepare(struct ldb_context *ldb,
 211                                               DATA_BLOB *schema_info_blob,
 212                                               TALLOC_CTX *mem_ctx,
 213                                               struct ldb_message **_msg)
 214 {
 215         int ldb_err;
 216         struct ldb_message *msg;
 217         struct ldb_dn *schema_dn;
 218         struct ldb_message_element *return_el;
 219
 220         schema_dn = ldb_get_schema_basedn(ldb);
 221         if (!schema_dn) {
 222                 DEBUG(0,("_dsdb_schema_info_write_prepare: no schema dn present\n"));
 223                 return WERR_INTERNAL_DB_CORRUPTION;
 224         }
 225
 226         /* prepare ldb_msg to update schemaInfo */
 227         msg = ldb_msg_new(mem_ctx);
 228         W_ERROR_HAVE_NO_MEMORY(msg);
 229
 230         msg->dn = schema_dn;
 231         ldb_err = ldb_msg_add_value(msg, "schemaInfo", schema_info_blob, &return_el);
 232         if (ldb_err != 0) {
 233                 DEBUG(0,("_dsdb_schema_info_write_prepare: ldb_msg_add_value failed - %s\n",
 234                          ldb_strerror(ldb_err)));
 235                 talloc_free(msg);
 236                 return WERR_INTERNAL_ERROR;
 237         }
 238
 239         /* mark schemaInfo element for replacement */
 240         return_el->flags = LDB_FLAG_MOD_REPLACE;
 241
 242         *_msg = msg;
 243
 244         return WERR_OK;
 245 }
 246
 247 /**
 248  * Writes schema_info structure into schemaInfo
 249  * attribute on SCHEMA partition
 250  *
 251  * @param dsdb_flags    DSDB_FLAG_... flag of 0
 252  */
 253 WERROR dsdb_module_schema_info_blob_write(struct ldb_module *ldb_module,
 254                                           uint32_t dsdb_flags,
 255                                           DATA_BLOB *schema_info_blob)
 256 {
 257         int ldb_err;
 258         WERROR werr;
 259         struct ldb_message *msg;
 260         TALLOC_CTX *temp_ctx;
 261
 262         temp_ctx = talloc_new(ldb_module);
 263         W_ERROR_HAVE_NO_MEMORY(temp_ctx);
 264
 265         /* write serialized schemaInfo into LDB */
 266         werr = _dsdb_schema_info_write_prepare(ldb_module_get_ctx(ldb_module),
 267                                                schema_info_blob,
 268                                                temp_ctx, &msg);
 269         if (!W_ERROR_IS_OK(werr)) {
 270                 talloc_free(temp_ctx);
 271                 return werr;
 272         }
 273
 274
 275         ldb_err = dsdb_module_modify(ldb_module, msg, dsdb_flags);
 276
 277         talloc_free(temp_ctx);
 278
 279         if (ldb_err != 0) {
 280                 DEBUG(0,("dsdb_module_schema_info_blob_write: dsdb_replace failed: %s (%s)\n",
 281                          ldb_strerror(ldb_err),
 282                          ldb_errstring(ldb_module_get_ctx(ldb_module))));
 283                 return WERR_INTERNAL_DB_ERROR;
 284         }
 285
 286         return WERR_OK;
 287 }
 288
 289
 290 /**
 291  * Reads schema_info structure from schemaInfo
 292  * attribute on SCHEMA partition
 293  */
 294 static WERROR dsdb_module_schema_info_read(struct ldb_module *ldb_module,
 295                                            uint32_t dsdb_flags,
 296                                            TALLOC_CTX *mem_ctx,
 297                                            struct dsdb_schema_info **_schema_info)
 298 {
 299         WERROR werr;
 300         DATA_BLOB ndr_blob;
 301         TALLOC_CTX *temp_ctx;
 302
 303         temp_ctx = talloc_new(mem_ctx);
 304         W_ERROR_HAVE_NO_MEMORY(temp_ctx);
 305
 306         /* read serialized schemaInfo from LDB  */
 307         werr = dsdb_module_schema_info_blob_read(ldb_module, dsdb_flags, temp_ctx, &ndr_blob);
 308         if (!W_ERROR_IS_OK(werr)) {
 309                 talloc_free(temp_ctx);
 310                 return werr;
 311         }
 312
 313         /* convert NDR blob to dsdb_schema_info object */
 314         werr = dsdb_schema_info_from_blob(&ndr_blob,
 315                                           mem_ctx,
 316                                           _schema_info);
 317         talloc_free(temp_ctx);
 318
 319         return werr;
 320 }
 321
 322 /**
 323  * Writes schema_info structure into schemaInfo
 324  * attribute on SCHEMA partition
 325  *
 326  * @param dsdb_flags    DSDB_FLAG_... flag of 0
 327  */
 328 static WERROR dsdb_module_schema_info_write(struct ldb_module *ldb_module,
 329                                             uint32_t dsdb_flags,
 330                                             const struct dsdb_schema_info *schema_info)
 331 {
 332         WERROR werr;
 333         DATA_BLOB ndr_blob;
 334         TALLOC_CTX *temp_ctx;
 335
 336         temp_ctx = talloc_new(ldb_module);
 337         W_ERROR_HAVE_NO_MEMORY(temp_ctx);
 338
 339         /* convert schema_info to a blob */
 340         werr = dsdb_blob_from_schema_info(schema_info, temp_ctx, &ndr_blob);
 341         if (!W_ERROR_IS_OK(werr)) {
 342                 talloc_free(temp_ctx);
 343                 return werr;
 344         }
 345
 346         /* write serialized schemaInfo into LDB */
 347         werr = dsdb_module_schema_info_blob_write(ldb_module, dsdb_flags, &ndr_blob);
 348
 349         talloc_free(temp_ctx);
 350
 351         return werr;
 352 }
 353
 354
 355 /**
 356  * Increments schemaInfo revision and save it to DB
 357  * setting our invocationID in the process
 358  * NOTE: this function should be called in a transaction
 359  * much in the same way prefixMap update function is called
 360  *
 361  * @param ldb_module    current module
 362  * @param schema        schema cache
 363  * @param dsdb_flags    DSDB_FLAG_... flag of 0
 364  */
 365 WERROR dsdb_module_schema_info_update(struct ldb_module *ldb_module,
 366                                       struct dsdb_schema *schema,
 367                                       int dsdb_flags)
 368 {
 369         WERROR werr;
 370         const struct GUID *invocation_id;
 371         DATA_BLOB ndr_blob;
 372         struct dsdb_schema_info *schema_info;
 373         const char *schema_info_str;
 374
 375         TALLOC_CTX *temp_ctx = talloc_new(schema);
 376         W_ERROR_HAVE_NO_MEMORY(temp_ctx);
 377
 378         invocation_id = samdb_ntds_invocation_id(ldb_module_get_ctx(ldb_module));
 379         if (!invocation_id) {
 380                 return WERR_INTERNAL_DB_CORRUPTION;
 381         }
 382
 383         /* read serialized schemaInfo from LDB  */
 384         werr = dsdb_module_schema_info_read(ldb_module, dsdb_flags, temp_ctx, &schema_info);
 385         if (W_ERROR_EQUAL(werr, WERR_DS_NO_ATTRIBUTE_OR_VALUE)) {
 386                 /* make default value in case
 387                  * we have no schemaInfo value yet */
 388                 werr = dsdb_schema_info_new(temp_ctx, &schema_info);
 389         }
 390         if (!W_ERROR_IS_OK(werr)) {
 391                 DEBUG(0,("dsdb_module_schema_info_update: failed to reload schemaInfo - %s\n",
 392                          win_errstr(werr)));
 393                 talloc_free(temp_ctx);
 394                 return werr;
 395         }
 396
 397         /* update schemaInfo */
 398         schema_info->revision++;
 399         schema_info->invocation_id = *invocation_id;
 400
 401         werr = dsdb_module_schema_info_write(ldb_module, dsdb_flags, schema_info);
 402         if (!W_ERROR_IS_OK(werr)) {
 403                 DEBUG(0,("dsdb_module_schema_info_update: failed to save schemaInfo - %s\n",
 404                          win_errstr(werr)));
 405                 talloc_free(temp_ctx);
 406                 return werr;
 407         }
 408
 409         /* finally, update schema_info in the cache */
 410         werr = dsdb_blob_from_schema_info(schema_info, temp_ctx, &ndr_blob);
 411         W_ERROR_NOT_OK_RETURN(werr);
 412
 413         schema_info_str = hex_encode_talloc(schema, ndr_blob.data, ndr_blob.length);
 414         W_ERROR_HAVE_NO_MEMORY(schema_info_str);
 415
 416         talloc_unlink(schema, discard_const(schema->schema_info));
 417         schema->schema_info = schema_info_str;
 418
 419         talloc_free(temp_ctx);
 420         return WERR_OK;
 421 }