source4/dsdb/repl/replicated_objects.c

   1 /*
   2    Unix SMB/CIFS mplementation.
   3    Helper functions for applying replicated objects
   4
   5    Copyright (C) Stefan Metzmacher 2007
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program; if not, write to the Free Software
  19    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  20
  21 */
  22
  23 #include "includes.h"
  24 #include "dsdb/samdb/samdb.h"
  25 #include "lib/ldb/include/ldb_errors.h"
  26 #include "lib/util/dlinklist.h"
  27 #include "librpc/gen_ndr/ndr_misc.h"
  28 #include "librpc/gen_ndr/ndr_drsuapi.h"
  29 #include "librpc/gen_ndr/ndr_drsblobs.h"
  30
  31 static WERROR dsdb_convert_object(struct ldb_context *ldb,
  32                                   const struct dsdb_schema *schema,
  33                                   struct dsdb_extended_replicated_objects *ctr,
  34                                   const struct drsuapi_DsReplicaObjectListItemEx *in,
  35                                   TALLOC_CTX *mem_ctx,
  36                                   struct dsdb_extended_replicated_object *out)
  37 {
  38         NTSTATUS nt_status;
  39         WERROR status;
  40         uint32_t i;
  41         struct ldb_message *msg;
  42         struct replPropertyMetaDataBlob md;
  43         struct ldb_val md_value;
  44         struct drsuapi_DsReplicaObjMetaDataCtr mdc;
  45         struct ldb_val guid_value;
  46         NTTIME whenChanged = 0;
  47         time_t whenChanged_t;
  48         const char *whenChanged_s;
  49         const char *rdn_name;
  50         const struct ldb_val *rdn_value;
  51         const struct dsdb_attribute *rdn_attr;
  52         uint32_t rdn_attid;
  53         struct drsuapi_DsReplicaAttribute *name_a;
  54         struct drsuapi_DsReplicaMetaData *name_d;
  55         struct replPropertyMetaData1 *rdn_m;
  56         struct drsuapi_DsReplicaObjMetaData *rdn_mc;
  57         int ret;
  58
  59         if (!in->object.identifier) {
  60                 return WERR_FOOBAR;
  61         }
  62
  63         if (!in->object.identifier->dn || !in->object.identifier->dn[0]) {
  64                 return WERR_FOOBAR;
  65         }
  66
  67         msg = ldb_msg_new(mem_ctx);
  68         W_ERROR_HAVE_NO_MEMORY(msg);
  69
  70         msg->dn                 = ldb_dn_new(msg, ldb, in->object.identifier->dn);
  71         W_ERROR_HAVE_NO_MEMORY(msg->dn);
  72
  73         rdn_name        = ldb_dn_get_rdn_name(msg->dn);
  74         rdn_attr        = dsdb_attribute_by_lDAPDisplayName(schema, rdn_name);
  75         if (!rdn_attr) {
  76                 return WERR_FOOBAR;
  77         }
  78         rdn_attid       = rdn_attr->attributeID_id;
  79         rdn_value       = ldb_dn_get_rdn_val(msg->dn);
  80
  81         msg->num_elements       = in->object.attribute_ctr.num_attributes;
  82         msg->elements           = talloc_array(msg, struct ldb_message_element,
  83                                                msg->num_elements);
  84         W_ERROR_HAVE_NO_MEMORY(msg->elements);
  85
  86         for (i=0; i < msg->num_elements; i++) {
  87                 status = dsdb_attribute_drsuapi_to_ldb(schema,
  88                                                        &in->object.attribute_ctr.attributes[i],
  89                                                        msg->elements, &msg->elements[i]);
  90                 W_ERROR_NOT_OK_RETURN(status);
  91         }
  92
  93         if (in->object.attribute_ctr.num_attributes != 0 && !in->meta_data_ctr) {
  94                 return WERR_FOOBAR;
  95         }
  96
  97         if (in->object.attribute_ctr.num_attributes != in->meta_data_ctr->count) {
  98                 return WERR_FOOBAR;
  99         }
 100
 101         md.version              = 1;
 102         md.reserved             = 0;
 103         md.ctr.ctr1.count       = in->meta_data_ctr->count;
 104         md.ctr.ctr1.reserved    = 0;
 105         md.ctr.ctr1.array       = talloc_array(mem_ctx,
 106                                                struct replPropertyMetaData1,
 107                                                md.ctr.ctr1.count + 1);
 108         W_ERROR_HAVE_NO_MEMORY(md.ctr.ctr1.array);
 109
 110         mdc.count       = in->meta_data_ctr->count;
 111         mdc.reserved    = 0;
 112         mdc.array       = talloc_array(mem_ctx,
 113                                        struct drsuapi_DsReplicaObjMetaData,
 114                                        mdc.count + 1);
 115         W_ERROR_HAVE_NO_MEMORY(mdc.array);
 116
 117         for (i=0; i < in->meta_data_ctr->count; i++) {
 118                 struct drsuapi_DsReplicaAttribute *a;
 119                 struct drsuapi_DsReplicaMetaData *d;
 120                 struct replPropertyMetaData1 *m;
 121                 struct drsuapi_DsReplicaObjMetaData *mc;
 122
 123                 a = &in->object.attribute_ctr.attributes[i];
 124                 d = &in->meta_data_ctr->meta_data[i];
 125                 m = &md.ctr.ctr1.array[i];
 126                 mc = &mdc.array[i];
 127
 128                 m->attid                        = a->attid;
 129                 m->version                      = d->version;
 130                 m->orginating_time              = d->orginating_time;
 131                 m->orginating_invocation_id     = d->orginating_invocation_id;
 132                 m->orginating_usn               = d->orginating_usn;
 133                 m->local_usn                    = 0;
 134
 135                 mc->attribute_name              = dsdb_lDAPDisplayName_by_id(schema, a->attid);
 136                 mc->version                     = d->version;
 137                 mc->originating_last_changed    = d->orginating_time;
 138                 mc->originating_dsa_invocation_id= d->orginating_invocation_id;
 139                 mc->originating_usn             = d->orginating_usn;
 140                 mc->local_usn                   = 0;
 141
 142                 if (d->orginating_time > whenChanged) {
 143                         whenChanged = d->orginating_time;
 144                 }
 145
 146                 if (a->attid == DRSUAPI_ATTRIBUTE_name) {
 147                         name_a = a;
 148                         name_d = d;
 149                         rdn_m = &md.ctr.ctr1.array[md.ctr.ctr1.count];
 150                         rdn_mc = &mdc.array[mdc.count];
 151                 }
 152         }
 153
 154         if (!name_d) {
 155                 return WERR_FOOBAR;
 156         }
 157
 158         ret = ldb_msg_add_value(msg, rdn_attr->lDAPDisplayName, rdn_value, NULL);
 159         if (ret != LDB_SUCCESS) {
 160                 return WERR_FOOBAR;
 161         }
 162
 163         nt_status = ndr_push_struct_blob(&guid_value, msg, &in->object.identifier->guid,
 164                                          (ndr_push_flags_fn_t)ndr_push_GUID);
 165         if (!NT_STATUS_IS_OK(nt_status)) {
 166                 return ntstatus_to_werror(nt_status);
 167         }
 168         ret = ldb_msg_add_value(msg, "objectGUID", &guid_value, NULL);
 169         if (ret != LDB_SUCCESS) {
 170                 return WERR_FOOBAR;
 171         }
 172
 173         whenChanged_t = nt_time_to_unix(whenChanged);
 174         whenChanged_s = ldb_timestring(msg, whenChanged_t);
 175         W_ERROR_HAVE_NO_MEMORY(whenChanged_s);
 176         ret = ldb_msg_add_string(msg, "whenChanged", whenChanged_s);
 177         if (ret != LDB_SUCCESS) {
 178                 return WERR_FOOBAR;
 179         }
 180
 181         rdn_m->attid                            = rdn_attid;
 182         rdn_m->version                          = name_d->version;
 183         rdn_m->orginating_time                  = name_d->orginating_time;
 184         rdn_m->orginating_invocation_id         = name_d->orginating_invocation_id;
 185         rdn_m->orginating_usn                   = name_d->orginating_usn;
 186         rdn_m->local_usn                        = 0;
 187         md.ctr.ctr1.count++;
 188
 189         rdn_mc->attribute_name                  = rdn_attr->lDAPDisplayName;
 190         rdn_mc->version                         = name_d->version;
 191         rdn_mc->originating_last_changed        = name_d->orginating_time;
 192         rdn_mc->originating_dsa_invocation_id   = name_d->orginating_invocation_id;
 193         rdn_mc->originating_usn                 = name_d->orginating_usn;
 194         rdn_mc->local_usn                       = 0;
 195         mdc.count++;
 196
 197         nt_status = ndr_push_struct_blob(&md_value, msg, &md,
 198                                          (ndr_push_flags_fn_t)ndr_push_replPropertyMetaDataBlob);
 199         if (!NT_STATUS_IS_OK(nt_status)) {
 200                 return ntstatus_to_werror(nt_status);
 201         }
 202         ret = ldb_msg_add_value(msg, "replPropertyMetaData", &md_value, NULL);
 203         if (ret != LDB_SUCCESS) {
 204                 return WERR_FOOBAR;
 205         }
 206
 207         if (lp_parm_bool(-1, "become dc", "dump objects", False)) {
 208                 struct ldb_ldif ldif;
 209                 fprintf(stdout, "#\n");
 210                 ldif.changetype = LDB_CHANGETYPE_NONE;
 211                 ldif.msg = msg;
 212                 ldb_ldif_write_file(ldb, stdout, &ldif);
 213                 NDR_PRINT_DEBUG(drsuapi_DsReplicaObjMetaDataCtr, &mdc);
 214         }
 215
 216         out->msg = msg;
 217         return WERR_OK;
 218 }
 219
 220 WERROR dsdb_extended_replicated_objects_commit(struct ldb_context *ldb,
 221                                                const char *partition_dn,
 222                                                const struct dsdb_schema *schema,
 223                                                uint32_t ctr_level,
 224                                                const struct drsuapi_DsGetNCChangesCtr1 *ctr1,
 225                                                const struct drsuapi_DsGetNCChangesCtr6 *ctr6,
 226                                                TALLOC_CTX *mem_ctx,
 227                                                struct dsdb_extended_replicated_objects **_out)
 228 {
 229         WERROR status;
 230         struct dsdb_extended_replicated_objects *out;
 231         struct ldb_result *ext_res;
 232         const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
 233         uint32_t object_count;
 234         struct drsuapi_DsReplicaObjectListItemEx *first_object;
 235         struct drsuapi_DsReplicaObjectListItemEx *cur;
 236         uint32_t i;
 237         int ret;
 238
 239         switch (ctr_level) {
 240         case 1:
 241                 mapping_ctr             = &ctr1->mapping_ctr;
 242                 object_count            = ctr1->object_count;
 243                 first_object            = ctr1->first_object;
 244                 break;
 245         case 6:
 246                 mapping_ctr             = &ctr6->mapping_ctr;
 247                 object_count            = ctr6->object_count;
 248                 first_object            = ctr6->first_object;
 249                 break;
 250         default:
 251                 return WERR_INVALID_PARAM;
 252         }
 253
 254         status = dsdb_verify_oid_mappings(schema, mapping_ctr);
 255         W_ERROR_NOT_OK_RETURN(status);
 256
 257         out = talloc_zero(mem_ctx, struct dsdb_extended_replicated_objects);
 258         W_ERROR_HAVE_NO_MEMORY(out);
 259
 260         out->partition_dn = ldb_dn_new(out, ldb, partition_dn);
 261         W_ERROR_HAVE_NO_MEMORY(out->partition_dn);
 262
 263         out->num_objects        = object_count;
 264         out->objects            = talloc_array(out,
 265                                                struct dsdb_extended_replicated_object,
 266                                                out->num_objects);
 267         W_ERROR_HAVE_NO_MEMORY(out->objects);
 268
 269         for (i=0, cur = first_object; cur; cur = cur->next_object, i++) {
 270                 if (i == out->num_objects) {
 271                         return WERR_FOOBAR;
 272                 }
 273
 274                 status = dsdb_convert_object(ldb, schema, out, cur, out->objects, &out->objects[i]);
 275                 W_ERROR_NOT_OK_RETURN(status);
 276         }
 277         if (i != out->num_objects) {
 278                 return WERR_FOOBAR;
 279         }
 280
 281         /* TODO: handle linked attributes */
 282
 283         ret = ldb_extended(ldb, DSDB_EXTENDED_REPLICATED_OBJECTS_OID, out, &ext_res);
 284         if (ret != LDB_SUCCESS) {
 285                 DEBUG(0,("Failed to apply records: %d\n",
 286                         ret));
 287                 talloc_free(out);
 288                 return WERR_FOOBAR;
 289         }
 290         talloc_free(ext_res);
 291
 292         if (_out) {
 293                 *_out = out;
 294         } else {
 295                 talloc_free(out);
 296         }
 297
 298         return WERR_OK;
 299 }