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