source4/dsdb/repl/drepl_out_helpers.c

   1 /*
   2    Unix SMB/CIFS mplementation.
   3    DSDB replication service helper function for outgoing traffic
   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 "auth/auth.h"
  26 #include "smbd/service.h"
  27 #include "lib/events/events.h"
  28 #include "lib/messaging/irpc.h"
  29 #include "dsdb/repl/drepl_service.h"
  30 #include "lib/ldb/include/ldb_errors.h"
  31 #include "lib/util/dlinklist.h"
  32 #include "librpc/gen_ndr/ndr_misc.h"
  33 #include "librpc/gen_ndr/ndr_drsuapi.h"
  34 #include "librpc/gen_ndr/ndr_drsblobs.h"
  35 #include "libcli/composite/composite.h"
  36 #include "auth/gensec/gensec.h"
  37
  38 struct dreplsrv_out_drsuapi_state {
  39         struct composite_context *creq;
  40
  41         struct dreplsrv_out_connection *conn;
  42
  43         struct dreplsrv_drsuapi_connection *drsuapi;
  44
  45         struct drsuapi_DsBindInfoCtr bind_info_ctr;
  46         struct drsuapi_DsBind bind_r;
  47 };
  48
  49 static void dreplsrv_out_drsuapi_connect_recv(struct composite_context *creq);
  50
  51 static struct composite_context *dreplsrv_out_drsuapi_send(struct dreplsrv_out_connection *conn)
  52 {
  53         struct composite_context *c;
  54         struct composite_context *creq;
  55         struct dreplsrv_out_drsuapi_state *st;
  56
  57         c = composite_create(conn, conn->service->task->event_ctx);
  58         if (c == NULL) return NULL;
  59
  60         st = talloc_zero(c, struct dreplsrv_out_drsuapi_state);
  61         if (composite_nomem(st, c)) return c;
  62
  63         c->private_data = st;
  64
  65         st->creq        = c;
  66         st->conn        = conn;
  67         st->drsuapi     = conn->drsuapi;
  68
  69         if (st->drsuapi && !st->drsuapi->pipe->conn->dead) {
  70                 composite_done(c);
  71                 return c;
  72         } else if (st->drsuapi && st->drsuapi->pipe->conn->dead) {
  73                 talloc_free(st->drsuapi);
  74                 conn->drsuapi = NULL;
  75         }
  76
  77         st->drsuapi     = talloc_zero(st, struct dreplsrv_drsuapi_connection);
  78         if (composite_nomem(st->drsuapi, c)) return c;
  79
  80         creq = dcerpc_pipe_connect_b_send(st, conn->binding, &dcerpc_table_drsuapi,
  81                                           conn->service->system_session_info->credentials,
  82                                           c->event_ctx);
  83         composite_continue(c, creq, dreplsrv_out_drsuapi_connect_recv, st);
  84
  85         return c;
  86 }
  87
  88 static void dreplsrv_out_drsuapi_bind_send(struct dreplsrv_out_drsuapi_state *st);
  89
  90 static void dreplsrv_out_drsuapi_connect_recv(struct composite_context *creq)
  91 {
  92         struct dreplsrv_out_drsuapi_state *st = talloc_get_type(creq->async.private_data,
  93                                                 struct dreplsrv_out_drsuapi_state);
  94         struct composite_context *c = st->creq;
  95
  96         c->status = dcerpc_pipe_connect_b_recv(creq, st->drsuapi, &st->drsuapi->pipe);
  97         if (!composite_is_ok(c)) return;
  98
  99         c->status = gensec_session_key(st->drsuapi->pipe->conn->security_state.generic_state,
 100                                        &st->drsuapi->gensec_skey);
 101         if (!composite_is_ok(c)) return;
 102
 103         dreplsrv_out_drsuapi_bind_send(st);
 104 }
 105
 106 static void dreplsrv_out_drsuapi_bind_recv(struct rpc_request *req);
 107
 108 static void dreplsrv_out_drsuapi_bind_send(struct dreplsrv_out_drsuapi_state *st)
 109 {
 110         struct composite_context *c = st->creq;
 111         struct rpc_request *req;
 112
 113         st->bind_info_ctr.length        = 28;
 114         st->bind_info_ctr.info.info28   = st->conn->service->bind_info28;
 115
 116         st->bind_r.in.bind_guid = &st->conn->service->ntds_guid;
 117         st->bind_r.in.bind_info = &st->bind_info_ctr;
 118         st->bind_r.out.bind_handle = &st->drsuapi->bind_handle;
 119
 120         req = dcerpc_drsuapi_DsBind_send(st->drsuapi->pipe, st, &st->bind_r);
 121         composite_continue_rpc(c, req, dreplsrv_out_drsuapi_bind_recv, st);
 122 }
 123
 124 static void dreplsrv_out_drsuapi_bind_recv(struct rpc_request *req)
 125 {
 126         struct dreplsrv_out_drsuapi_state *st = talloc_get_type(req->async.private_data,
 127                                                 struct dreplsrv_out_drsuapi_state);
 128         struct composite_context *c = st->creq;
 129
 130         c->status = dcerpc_ndr_request_recv(req);
 131         if (!composite_is_ok(c)) return;
 132
 133         if (!W_ERROR_IS_OK(st->bind_r.out.result)) {
 134                 composite_error(c, werror_to_ntstatus(st->bind_r.out.result));
 135                 return;
 136         }
 137
 138         ZERO_STRUCT(st->drsuapi->remote_info28);
 139         if (st->bind_r.out.bind_info) {
 140                 switch (st->bind_r.out.bind_info->length) {
 141                 case 24: {
 142                         struct drsuapi_DsBindInfo24 *info24;
 143                         info24 = &st->bind_r.out.bind_info->info.info24;
 144                         st->drsuapi->remote_info28.supported_extensions = info24->supported_extensions;
 145                         st->drsuapi->remote_info28.site_guid            = info24->site_guid;
 146                         st->drsuapi->remote_info28.u1                   = info24->u1;
 147                         st->drsuapi->remote_info28.repl_epoch           = 0;
 148                         break;
 149                 }
 150                 case 28:
 151                         st->drsuapi->remote_info28 = st->bind_r.out.bind_info->info.info28;
 152                         break;
 153                 }
 154         }
 155
 156         composite_done(c);
 157 }
 158
 159 static NTSTATUS dreplsrv_out_drsuapi_recv(struct composite_context *c)
 160 {
 161         NTSTATUS status;
 162         struct dreplsrv_out_drsuapi_state *st = talloc_get_type(c->private_data,
 163                                                 struct dreplsrv_out_drsuapi_state);
 164
 165         status = composite_wait(c);
 166
 167         if (NT_STATUS_IS_OK(status)) {
 168                 st->conn->drsuapi = talloc_steal(st->conn, st->drsuapi);
 169         }
 170
 171         talloc_free(c);
 172         return status;
 173 }
 174
 175 struct dreplsrv_op_pull_source_state {
 176         struct composite_context *creq;
 177
 178         struct dreplsrv_out_operation *op;
 179
 180         struct dreplsrv_drsuapi_connection *drsuapi;
 181
 182         bool have_all;
 183
 184         uint32_t ctr_level;
 185         struct drsuapi_DsGetNCChangesCtr1 *ctr1;
 186         struct drsuapi_DsGetNCChangesCtr6 *ctr6;
 187 };
 188
 189 static void dreplsrv_op_pull_source_connect_recv(struct composite_context *creq);
 190
 191 struct composite_context *dreplsrv_op_pull_source_send(struct dreplsrv_out_operation *op)
 192 {
 193         struct composite_context *c;
 194         struct composite_context *creq;
 195         struct dreplsrv_op_pull_source_state *st;
 196
 197         c = composite_create(op, op->service->task->event_ctx);
 198         if (c == NULL) return NULL;
 199
 200         st = talloc_zero(c, struct dreplsrv_op_pull_source_state);
 201         if (composite_nomem(st, c)) return c;
 202
 203         st->creq        = c;
 204         st->op          = op;
 205
 206         creq = dreplsrv_out_drsuapi_send(op->source_dsa->conn);
 207         composite_continue(c, creq, dreplsrv_op_pull_source_connect_recv, st);
 208
 209         return c;
 210 }
 211
 212 static void dreplsrv_op_pull_source_get_changes_send(struct dreplsrv_op_pull_source_state *st);
 213
 214 static void dreplsrv_op_pull_source_connect_recv(struct composite_context *creq)
 215 {
 216         struct dreplsrv_op_pull_source_state *st = talloc_get_type(creq->async.private_data,
 217                                                    struct dreplsrv_op_pull_source_state);
 218         struct composite_context *c = st->creq;
 219
 220         c->status = dreplsrv_out_drsuapi_recv(creq);
 221         if (!composite_is_ok(c)) return;
 222
 223         dreplsrv_op_pull_source_get_changes_send(st);
 224 }
 225
 226 static void dreplsrv_op_pull_source_get_changes_recv(struct rpc_request *req);
 227
 228 static void dreplsrv_op_pull_source_get_changes_send(struct dreplsrv_op_pull_source_state *st)
 229 {
 230         struct composite_context *c = st->creq;
 231         struct repsFromTo1 *rf1 = st->op->source_dsa->repsFrom1;
 232         struct dreplsrv_service *service = st->op->service;
 233         struct dreplsrv_partition *partition = st->op->source_dsa->partition;
 234         struct dreplsrv_drsuapi_connection *drsuapi = st->op->source_dsa->conn->drsuapi;
 235         struct rpc_request *req;
 236         struct drsuapi_DsGetNCChanges *r;
 237
 238         r = talloc(st, struct drsuapi_DsGetNCChanges);
 239         if (composite_nomem(r, c)) return;
 240
 241         r->in.level = talloc(r, int32_t);
 242         if (composite_nomem(r->in.level, c)) return;
 243         r->out.level = talloc(r, int32_t);
 244         if (composite_nomem(r->out.level, c)) return;
 245
 246         r->in.bind_handle       = &drsuapi->bind_handle;
 247         if (drsuapi->remote_info28.supported_extensions & DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8) {
 248                 *r->in.level                            = 8;
 249                 r->in.req.req8.destination_dsa_guid     = service->ntds_guid;
 250                 r->in.req.req8.source_dsa_invocation_id = rf1->source_dsa_invocation_id;
 251                 r->in.req.req8.naming_context           = &partition->nc;
 252                 r->in.req.req8.highwatermark            = rf1->highwatermark;
 253                 r->in.req.req8.uptodateness_vector      = NULL;/*&partition->uptodatevector_ex;*/
 254                 r->in.req.req8.replica_flags            = rf1->replica_flags;
 255                 r->in.req.req8.max_object_count         = 133;
 256                 r->in.req.req8.max_ndr_size             = 1336811;
 257                 r->in.req.req8.unknown4                 = 0;
 258                 r->in.req.req8.h1                       = 0;
 259                 r->in.req.req8.unique_ptr1              = 0;
 260                 r->in.req.req8.unique_ptr2              = 0;
 261                 r->in.req.req8.mapping_ctr.num_mappings = 0;
 262                 r->in.req.req8.mapping_ctr.mappings     = NULL;
 263         } else {
 264                 *r->in.level                            = 5;
 265                 r->in.req.req5.destination_dsa_guid     = service->ntds_guid;
 266                 r->in.req.req5.source_dsa_invocation_id = rf1->source_dsa_invocation_id;
 267                 r->in.req.req5.naming_context           = &partition->nc;
 268                 r->in.req.req5.highwatermark            = rf1->highwatermark;
 269                 r->in.req.req5.uptodateness_vector      = NULL;/*&partition->uptodatevector_ex;*/
 270                 r->in.req.req5.replica_flags            = rf1->replica_flags;
 271                 r->in.req.req5.max_object_count         = 133;
 272                 r->in.req.req5.max_ndr_size             = 1336770;
 273                 r->in.req.req5.unknown4                 = 0;
 274                 r->in.req.req5.h1                       = 0;
 275         }
 276
 277         req = dcerpc_drsuapi_DsGetNCChanges_send(drsuapi->pipe, r, r);
 278         composite_continue_rpc(c, req, dreplsrv_op_pull_source_get_changes_recv, st);
 279 }
 280
 281 static void dreplsrv_op_pull_source_apply_changes_send(struct dreplsrv_op_pull_source_state *st,
 282                                                        struct drsuapi_DsGetNCChanges *r,
 283                                                        uint32_t ctr_level,
 284                                                        struct drsuapi_DsGetNCChangesCtr1 *ctr1,
 285                                                        struct drsuapi_DsGetNCChangesCtr6 *ctr6);
 286
 287 static void dreplsrv_op_pull_source_get_changes_recv(struct rpc_request *req)
 288 {
 289         struct dreplsrv_op_pull_source_state *st = talloc_get_type(req->async.private_data,
 290                                                    struct dreplsrv_op_pull_source_state);
 291         struct composite_context *c = st->creq;
 292         struct drsuapi_DsGetNCChanges *r = talloc_get_type(req->ndr.struct_ptr,
 293                                            struct drsuapi_DsGetNCChanges);
 294         uint32_t ctr_level = 0;
 295         struct drsuapi_DsGetNCChangesCtr1 *ctr1 = NULL;
 296         struct drsuapi_DsGetNCChangesCtr6 *ctr6 = NULL;
 297
 298         c->status = dcerpc_ndr_request_recv(req);
 299         if (!composite_is_ok(c)) return;
 300
 301         if (!W_ERROR_IS_OK(r->out.result)) {
 302                 composite_error(c, werror_to_ntstatus(r->out.result));
 303                 return;
 304         }
 305
 306         if (*r->out.level == 1) {
 307                 ctr_level = 1;
 308                 ctr1 = &r->out.ctr.ctr1;
 309         } else if (*r->out.level == 2) {
 310                 ctr_level = 1;
 311                 ctr1 = r->out.ctr.ctr2.ctr.mszip1.ctr1;
 312         } else if (*r->out.level == 6) {
 313                 ctr_level = 6;
 314                 ctr6 = &r->out.ctr.ctr6;
 315         } else if (*r->out.level == 7 &&
 316                    r->out.ctr.ctr7.level == 6 &&
 317                    r->out.ctr.ctr7.type == DRSUAPI_COMPRESSION_TYPE_MSZIP) {
 318                 ctr_level = 6;
 319                 ctr6 = r->out.ctr.ctr7.ctr.mszip6.ctr6;
 320         } else {
 321                 composite_error(c, werror_to_ntstatus(WERR_BAD_NET_RESP));
 322                 return;
 323         }
 324
 325         dreplsrv_op_pull_source_apply_changes_send(st, r, ctr_level, ctr1, ctr6);
 326 }
 327
 328 static void dreplsrv_op_pull_source_apply_changes_send(struct dreplsrv_op_pull_source_state *st,
 329                                                        struct drsuapi_DsGetNCChanges *r,
 330                                                        uint32_t ctr_level,
 331                                                        struct drsuapi_DsGetNCChangesCtr1 *ctr1,
 332                                                        struct drsuapi_DsGetNCChangesCtr6 *ctr6)
 333 {
 334         struct composite_context *c = st->creq;
 335         struct repsFromTo1 rf1 = *st->op->source_dsa->repsFrom1;
 336         struct dreplsrv_service *service = st->op->service;
 337         struct dreplsrv_partition *partition = st->op->source_dsa->partition;
 338         struct dreplsrv_drsuapi_connection *drsuapi = st->op->source_dsa->conn->drsuapi;
 339         const struct drsuapi_DsReplicaOIDMapping_Ctr *mapping_ctr;
 340         uint32_t object_count;
 341         struct drsuapi_DsReplicaObjectListItemEx *first_object;
 342         uint32_t linked_attributes_count;
 343         struct drsuapi_DsReplicaLinkedAttribute *linked_attributes;
 344         const struct drsuapi_DsReplicaCursor2CtrEx *uptodateness_vector;
 345         bool more_data = false;
 346         WERROR status;
 347
 348         switch (ctr_level) {
 349         case 1:
 350                 mapping_ctr                     = &ctr1->mapping_ctr;
 351                 object_count                    = ctr1->object_count;
 352                 first_object                    = ctr1->first_object;
 353                 linked_attributes_count         = 0;
 354                 linked_attributes               = NULL;
 355                 rf1.highwatermark               = ctr1->new_highwatermark;
 356                 uptodateness_vector             = NULL; /* TODO: map it */
 357                 break;
 358         case 6:
 359                 mapping_ctr                     = &ctr6->mapping_ctr;
 360                 object_count                    = ctr6->object_count;
 361                 first_object                    = ctr6->first_object;
 362                 linked_attributes_count         = ctr6->linked_attributes_count;
 363                 linked_attributes               = ctr6->linked_attributes;
 364                 rf1.highwatermark               = ctr6->new_highwatermark;
 365                 uptodateness_vector             = ctr6->uptodateness_vector;
 366                 break;
 367         default:
 368                 composite_error(c, werror_to_ntstatus(WERR_BAD_NET_RESP));
 369                 return;
 370         }
 371
 372         status = dsdb_extended_replicated_objects_commit(service->samdb,
 373                                                          partition->nc.dn,
 374                                                          mapping_ctr,
 375                                                          object_count,
 376                                                          first_object,
 377                                                          linked_attributes_count,
 378                                                          linked_attributes,
 379                                                          &rf1,
 380                                                          uptodateness_vector,
 381                                                          &drsuapi->gensec_skey,
 382                                                          st, NULL);
 383         if (!W_ERROR_IS_OK(status)) {
 384                 DEBUG(0,("Failed to commit objects: %s\n", win_errstr(status)));
 385                 composite_error(c, werror_to_ntstatus(status));
 386                 return;
 387         }
 388
 389         /* if it applied fine, we need to update the highwatermark */
 390         *st->op->source_dsa->repsFrom1 = rf1;
 391
 392         /*
 393          * TODO: update our uptodatevector!
 394          */
 395
 396         /*
 397          * if the tmp_highest_usn is higher than highest_usn
 398          * there's more to pull from this source_dsa
 399          */
 400         if (rf1.highwatermark.tmp_highest_usn > rf1.highwatermark.highest_usn) {
 401                 more_data = true;
 402         }
 403
 404         if (more_data) {
 405                 dreplsrv_op_pull_source_get_changes_send(st);
 406                 return;
 407         }
 408
 409         composite_done(c);
 410 }
 411
 412 WERROR dreplsrv_op_pull_source_recv(struct composite_context *c)
 413 {
 414         NTSTATUS status;
 415
 416         status = composite_wait(c);
 417
 418         talloc_free(c);
 419         return ntstatus_to_werror(status);
 420 }