source4/rpc_server/drsuapi/dcesrv_drsuapi.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    endpoint server for the drsuapi pipe
   5
   6    Copyright (C) Stefan Metzmacher 2004
   7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2006
   8
   9    This program is free software; you can redistribute it and/or modify
  10    it under the terms of the GNU General Public License as published by
  11    the Free Software Foundation; either version 3 of the License, or
  12    (at your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful,
  15    but WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17    GNU General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21 */
  22
  23 #include "includes.h"
  24 #include "librpc/gen_ndr/ndr_drsuapi.h"
  25 #include "rpc_server/dcerpc_server.h"
  26 #include "rpc_server/common/common.h"
  27 #include "dsdb/samdb/samdb.h"
  28 #include "rpc_server/drsuapi/dcesrv_drsuapi.h"
  29 #include "libcli/security/security.h"
  30
  31 /*
  32   drsuapi_DsBind
  33 */
  34 static WERROR dcesrv_drsuapi_DsBind(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
  35                        struct drsuapi_DsBind *r)
  36 {
  37         struct drsuapi_bind_state *b_state;
  38         struct dcesrv_handle *handle;
  39         struct drsuapi_DsBindInfoCtr *bind_info;
  40         struct GUID site_guid;
  41         struct ldb_result *site_res;
  42         struct ldb_dn *server_site_dn;
  43         static const char *site_attrs[] = { "objectGUID", NULL };
  44         struct ldb_result *ntds_res;
  45         struct ldb_dn *ntds_dn;
  46         static const char *ntds_attrs[] = { "ms-DS-ReplicationEpoch", NULL };
  47         uint32_t pid;
  48         uint32_t repl_epoch;
  49         int ret;
  50
  51         r->out.bind_info = NULL;
  52         ZERO_STRUCTP(r->out.bind_handle);
  53
  54         b_state = talloc_zero(mem_ctx, struct drsuapi_bind_state);
  55         W_ERROR_HAVE_NO_MEMORY(b_state);
  56
  57         /*
  58          * connect to the samdb
  59          */
  60         b_state->sam_ctx = samdb_connect(b_state, dce_call->event_ctx, dce_call->conn->dce_ctx->lp_ctx, dce_call->conn->auth_state.session_info);
  61         if (!b_state->sam_ctx) {
  62                 return WERR_FOOBAR;
  63         }
  64
  65         /*
  66          * find out the guid of our own site
  67          */
  68         server_site_dn = samdb_server_site_dn(b_state->sam_ctx, mem_ctx);
  69         W_ERROR_HAVE_NO_MEMORY(server_site_dn);
  70
  71         ret = ldb_search(b_state->sam_ctx, mem_ctx, &site_res,
  72                                  server_site_dn, LDB_SCOPE_BASE, site_attrs,
  73                                  "(objectClass=*)");
  74         if (ret != LDB_SUCCESS) {
  75                 return WERR_DS_DRA_INTERNAL_ERROR;
  76         }
  77         if (site_res->count != 1) {
  78                 return WERR_DS_DRA_INTERNAL_ERROR;
  79         }
  80         site_guid = samdb_result_guid(site_res->msgs[0], "objectGUID");
  81
  82         /*
  83          * lookup the local servers Replication Epoch
  84          */
  85         ntds_dn = samdb_ntds_settings_dn(b_state->sam_ctx);
  86         W_ERROR_HAVE_NO_MEMORY(ntds_dn);
  87
  88         ret = ldb_search(b_state->sam_ctx, mem_ctx, &ntds_res,
  89                                  ntds_dn, LDB_SCOPE_BASE, ntds_attrs,
  90                                  "(objectClass=*)");
  91         if (ret != LDB_SUCCESS) {
  92                 return WERR_DS_DRA_INTERNAL_ERROR;
  93         }
  94         if (ntds_res->count != 1) {
  95                 return WERR_DS_DRA_INTERNAL_ERROR;
  96         }
  97         repl_epoch = samdb_result_uint(ntds_res->msgs[0], "ms-DS-ReplicationEpoch", 0);
  98
  99         /*
 100          * The "process identifier" of the client.
 101          * According to the WSPP docs, sectin 5.35, this is
 102          * for informational and debugging purposes only.
 103          * The assignment is implementation specific.
 104          */
 105         pid = 0;
 106
 107         /*
 108          * store the clients bind_guid
 109          */
 110         if (r->in.bind_guid) {
 111                 b_state->remote_bind_guid = *r->in.bind_guid;
 112         }
 113
 114         /*
 115          * store the clients bind_info
 116          */
 117         if (r->in.bind_info) {
 118                 switch (r->in.bind_info->length) {
 119                 case 24: {
 120                         struct drsuapi_DsBindInfo24 *info24;
 121                         info24 = &r->in.bind_info->info.info24;
 122                         b_state->remote_info28.supported_extensions     = info24->supported_extensions;
 123                         b_state->remote_info28.site_guid                = info24->site_guid;
 124                         b_state->remote_info28.pid                      = info24->pid;
 125                         b_state->remote_info28.repl_epoch               = 0;
 126                         break;
 127                 }
 128                 case 28:
 129                         b_state->remote_info28 = r->in.bind_info->info.info28;
 130                         break;
 131                 }
 132         }
 133
 134         /*
 135          * fill in our local bind info 28
 136          */
 137         b_state->local_info28.supported_extensions      = 0;
 138         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_BASE;
 139         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_ASYNC_REPLICATION;
 140         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_REMOVEAPI;
 141         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_MOVEREQ_V2;
 142 #if 0 /* we don't support MSZIP compression (only decompression) */
 143         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GETCHG_COMPRESS;
 144 #endif
 145         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V1;
 146         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_RESTORE_USN_OPTIMIZATION;
 147         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_KCC_EXECUTE;
 148         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRY_V2;
 149         if (0 /*domain.behavior_version == 2*/) {
 150                 /* TODO: find out how this is really triggered! */
 151                 b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_LINKED_VALUE_REPLICATION;
 152         }
 153         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V2;
 154         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_INSTANCE_TYPE_NOT_REQ_ON_MOD;
 155         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_CRYPTO_BIND;
 156         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GET_REPL_INFO;
 157         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_STRONG_ENCRYPTION;
 158         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_DCINFO_V01;
 159         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_TRANSITIVE_MEMBERSHIP;
 160         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_ADD_SID_HISTORY;
 161         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_POST_BETA3;
 162         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_00100000;
 163         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GET_MEMBERSHIPS2;
 164         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V6;
 165         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_NONDOMAIN_NCS;
 166         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREQ_V8;
 167         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V5;
 168         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V6;
 169         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_ADDENTRYREPLY_V3;
 170         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_GETCHGREPLY_V7;
 171         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_VERIFY_OBJECT;
 172 #if 0 /* we don't support XPRESS compression yet */
 173         b_state->local_info28.supported_extensions      |= DRSUAPI_SUPPORTED_EXTENSION_XPRESS_COMPRESS;
 174 #endif
 175         b_state->local_info28.site_guid                 = site_guid;
 176         b_state->local_info28.pid                       = pid;
 177         b_state->local_info28.repl_epoch                = repl_epoch;
 178
 179         /*
 180          * allocate the return bind_info
 181          */
 182         bind_info = talloc(mem_ctx, struct drsuapi_DsBindInfoCtr);
 183         W_ERROR_HAVE_NO_MEMORY(bind_info);
 184
 185         bind_info->length       = 28;
 186         bind_info->info.info28  = b_state->local_info28;
 187
 188         /*
 189          * allocate a bind handle
 190          */
 191         handle = dcesrv_handle_new(dce_call->context, DRSUAPI_BIND_HANDLE);
 192         W_ERROR_HAVE_NO_MEMORY(handle);
 193         handle->data = talloc_steal(handle, b_state);
 194
 195         /*
 196          * prepare reply
 197          */
 198         r->out.bind_info = bind_info;
 199         *r->out.bind_handle = handle->wire_handle;
 200
 201         return WERR_OK;
 202 }
 203
 204
 205 /*
 206   drsuapi_DsUnbind
 207 */
 208 static WERROR dcesrv_drsuapi_DsUnbind(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 209                                struct drsuapi_DsUnbind *r)
 210 {
 211         struct dcesrv_handle *h;
 212
 213         *r->out.bind_handle = *r->in.bind_handle;
 214
 215         DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
 216
 217         talloc_free(h);
 218
 219         ZERO_STRUCTP(r->out.bind_handle);
 220
 221         return WERR_OK;
 222 }
 223
 224
 225 /*
 226   drsuapi_DsReplicaSync
 227 */
 228 static WERROR dcesrv_drsuapi_DsReplicaSync(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 229                                            struct drsuapi_DsReplicaSync *r)
 230 {
 231         if (security_session_user_level(dce_call->conn->auth_state.session_info) <
 232             SECURITY_DOMAIN_CONTROLLER) {
 233                 DEBUG(0,("DsReplicaSync refused for security token\n"));
 234                 return WERR_DS_DRA_ACCESS_DENIED;
 235         }
 236
 237         dcesrv_irpc_forward_rpc_call(dce_call, mem_ctx, r, NDR_DRSUAPI_DSREPLICASYNC,
 238                                      &ndr_table_drsuapi,
 239                                      "dreplsrv", "DsReplicaSync");
 240         return WERR_OK;
 241 }
 242
 243
 244 /*
 245   drsuapi_DsReplicaAdd
 246 */
 247 static WERROR dcesrv_drsuapi_DsReplicaAdd(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 248                                           struct drsuapi_DsReplicaAdd *r)
 249 {
 250         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 251 }
 252
 253
 254 /*
 255   drsuapi_DsReplicaDel
 256 */
 257 static WERROR dcesrv_drsuapi_DsReplicaDel(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 258                                           struct drsuapi_DsReplicaDel *r)
 259 {
 260         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 261 }
 262
 263
 264 /*
 265   drsuapi_DsReplicaModify
 266 */
 267 static WERROR dcesrv_drsuapi_DsReplicaMod(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 268                                           struct drsuapi_DsReplicaMod *r)
 269 {
 270         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 271 }
 272
 273
 274 /*
 275   DRSUAPI_VERIFY_NAMES
 276 */
 277 static WERROR dcesrv_DRSUAPI_VERIFY_NAMES(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 278                        struct DRSUAPI_VERIFY_NAMES *r)
 279 {
 280         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 281 }
 282
 283
 284 /*
 285   drsuapi_DsGetMemberships
 286 */
 287 static WERROR dcesrv_drsuapi_DsGetMemberships(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 288                        struct drsuapi_DsGetMemberships *r)
 289 {
 290         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 291 }
 292
 293
 294 /*
 295   DRSUAPI_INTER_DOMAIN_MOVE
 296 */
 297 static WERROR dcesrv_DRSUAPI_INTER_DOMAIN_MOVE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 298                        struct DRSUAPI_INTER_DOMAIN_MOVE *r)
 299 {
 300         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 301 }
 302
 303
 304 /*
 305   drsuapi_DsGetNT4ChangeLog
 306 */
 307 static WERROR dcesrv_drsuapi_DsGetNT4ChangeLog(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 308                        struct drsuapi_DsGetNT4ChangeLog *r)
 309 {
 310         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 311 }
 312
 313
 314 /*
 315   drsuapi_DsCrackNames
 316 */
 317 static WERROR dcesrv_drsuapi_DsCrackNames(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 318                             struct drsuapi_DsCrackNames *r)
 319 {
 320         WERROR status;
 321         struct drsuapi_bind_state *b_state;
 322         struct dcesrv_handle *h;
 323
 324         *r->out.level_out = r->in.level;
 325
 326         DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
 327         b_state = h->data;
 328
 329         r->out.ctr = talloc_zero(mem_ctx, union drsuapi_DsNameCtr);
 330         W_ERROR_HAVE_NO_MEMORY(r->out.ctr);
 331
 332         switch (r->in.level) {
 333                 case 1: {
 334                         struct drsuapi_DsNameCtr1 *ctr1;
 335                         struct drsuapi_DsNameInfo1 *names;
 336                         int count;
 337                         int i;
 338
 339                         ctr1 = talloc(mem_ctx, struct drsuapi_DsNameCtr1);
 340                         W_ERROR_HAVE_NO_MEMORY(ctr1);
 341
 342                         count = r->in.req->req1.count;
 343                         names = talloc_array(mem_ctx, struct drsuapi_DsNameInfo1, count);
 344                         W_ERROR_HAVE_NO_MEMORY(names);
 345
 346                         for (i=0; i < count; i++) {
 347                                 status = DsCrackNameOneName(b_state->sam_ctx, mem_ctx,
 348                                                             r->in.req->req1.format_flags,
 349                                                             r->in.req->req1.format_offered,
 350                                                             r->in.req->req1.format_desired,
 351                                                             r->in.req->req1.names[i].str,
 352                                                             &names[i]);
 353                                 if (!W_ERROR_IS_OK(status)) {
 354                                         return status;
 355                                 }
 356                         }
 357
 358                         ctr1->count = count;
 359                         ctr1->array = names;
 360                         r->out.ctr->ctr1 = ctr1;
 361
 362                         return WERR_OK;
 363                 }
 364         }
 365
 366         return WERR_UNKNOWN_LEVEL;
 367 }
 368
 369 /*
 370   drsuapi_DsWriteAccountSpn
 371 */
 372 static WERROR dcesrv_drsuapi_DsWriteAccountSpn(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 373                        struct drsuapi_DsWriteAccountSpn *r)
 374 {
 375         struct drsuapi_bind_state *b_state;
 376         struct dcesrv_handle *h;
 377
 378         *r->out.level_out = r->in.level;
 379
 380         DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
 381         b_state = h->data;
 382
 383         r->out.res = talloc(mem_ctx, union drsuapi_DsWriteAccountSpnResult);
 384         W_ERROR_HAVE_NO_MEMORY(r->out.res);
 385
 386         switch (r->in.level) {
 387                 case 1: {
 388                         struct drsuapi_DsWriteAccountSpnRequest1 *req;
 389                         struct ldb_message *msg;
 390                         int count, i, ret;
 391                         req = &r->in.req->req1;
 392                         count = req->count;
 393
 394                         msg = ldb_msg_new(mem_ctx);
 395                         if (msg == NULL) {
 396                                 return WERR_NOMEM;
 397                         }
 398
 399                         msg->dn = ldb_dn_new(msg, b_state->sam_ctx, req->object_dn);
 400                         if ( ! ldb_dn_validate(msg->dn)) {
 401                                 r->out.res->res1.status = WERR_OK;
 402                                 return WERR_OK;
 403                         }
 404
 405                         /* construct mods */
 406                         for (i = 0; i < count; i++) {
 407                                 samdb_msg_add_string(b_state->sam_ctx,
 408                                                      msg, msg, "servicePrincipalName",
 409                                                      req->spn_names[i].str);
 410                         }
 411                         for (i=0;i<msg->num_elements;i++) {
 412                                 switch (req->operation) {
 413                                 case DRSUAPI_DS_SPN_OPERATION_ADD:
 414                                         msg->elements[i].flags = LDB_FLAG_MOD_ADD;
 415                                         break;
 416                                 case DRSUAPI_DS_SPN_OPERATION_REPLACE:
 417                                         msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
 418                                         break;
 419                                 case DRSUAPI_DS_SPN_OPERATION_DELETE:
 420                                         msg->elements[i].flags = LDB_FLAG_MOD_DELETE;
 421                                         break;
 422                                 }
 423                         }
 424
 425                         /* Apply to database */
 426
 427                         ret = ldb_modify(b_state->sam_ctx, msg);
 428                         if (ret != 0) {
 429                                 DEBUG(0,("Failed to modify SPNs on %s: %s\n",
 430                                          ldb_dn_get_linearized(msg->dn),
 431                                          ldb_errstring(b_state->sam_ctx)));
 432                                 r->out.res->res1.status = WERR_ACCESS_DENIED;
 433                         } else {
 434                                 r->out.res->res1.status = WERR_OK;
 435                         }
 436
 437                         return WERR_OK;
 438                 }
 439         }
 440
 441         return WERR_UNKNOWN_LEVEL;
 442 }
 443
 444
 445 /*
 446   drsuapi_DsRemoveDSServer
 447 */
 448 static WERROR dcesrv_drsuapi_DsRemoveDSServer(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 449                                        struct drsuapi_DsRemoveDSServer *r)
 450 {
 451         struct drsuapi_bind_state *b_state;
 452         struct dcesrv_handle *h;
 453         struct ldb_dn *ntds_dn;
 454         int ret;
 455         bool ok;
 456
 457         ZERO_STRUCT(r->out.res);
 458         *r->out.level_out = 1;
 459
 460         if (security_session_user_level(dce_call->conn->auth_state.session_info) <
 461             SECURITY_DOMAIN_CONTROLLER) {
 462                 DEBUG(0,("DsRemoveDSServer refused for security token\n"));
 463                 return WERR_DS_DRA_ACCESS_DENIED;
 464         }
 465
 466         DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
 467         b_state = h->data;
 468
 469         switch (r->in.level) {
 470         case 1:
 471                 ntds_dn = ldb_dn_new(mem_ctx, b_state->sam_ctx, r->in.req->req1.server_dn);
 472                 W_ERROR_HAVE_NO_MEMORY(ntds_dn);
 473
 474                 ok = ldb_dn_validate(ntds_dn);
 475                 if (!ok) {
 476                         return WERR_FOOBAR;
 477                 }
 478
 479                 /* TODO: it's likely that we need more checks here */
 480
 481                 ok = ldb_dn_add_child_fmt(ntds_dn, "CN=NTDS Settings");
 482                 if (!ok) {
 483                         return WERR_FOOBAR;
 484                 }
 485
 486                 if (r->in.req->req1.commit) {
 487                         ret = ldb_delete(b_state->sam_ctx, ntds_dn);
 488                         if (ret != LDB_SUCCESS) {
 489                                 return WERR_FOOBAR;
 490                         }
 491                 }
 492
 493                 return WERR_OK;
 494         default:
 495                 break;
 496         }
 497
 498         return WERR_FOOBAR;
 499 }
 500
 501
 502 /*
 503   DRSUAPI_REMOVE_DS_DOMAIN
 504 */
 505 static WERROR dcesrv_DRSUAPI_REMOVE_DS_DOMAIN(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 506                        struct DRSUAPI_REMOVE_DS_DOMAIN *r)
 507 {
 508         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 509 }
 510
 511 /* Obtain the site name from a server DN */
 512 static const char *result_site_name(struct ldb_dn *site_dn)
 513 {
 514         /* Format is cn=<NETBIOS name>,cn=Servers,cn=<site>,cn=sites.... */
 515         const struct ldb_val *val = ldb_dn_get_component_val(site_dn, 2);
 516         const char *name = ldb_dn_get_component_name(site_dn, 2);
 517
 518         if (!name || (ldb_attr_cmp(name, "cn") != 0)) {
 519                 /* Ensure this matches the format.  This gives us a
 520                  * bit more confidence that a 'cn' value will be a
 521                  * ascii string */
 522                 return NULL;
 523         }
 524         if (val) {
 525                 return (char *)val->data;
 526         }
 527         return NULL;
 528 }
 529
 530 /*
 531   drsuapi_DsGetDomainControllerInfo
 532 */
 533 static WERROR dcesrv_drsuapi_DsGetDomainControllerInfo_1(struct drsuapi_bind_state *b_state,
 534                                                 TALLOC_CTX *mem_ctx,
 535                                                 struct drsuapi_DsGetDomainControllerInfo *r)
 536 {
 537         struct ldb_dn *sites_dn;
 538         struct ldb_result *res;
 539
 540         const char *attrs_account_1[] = { "cn", "dnsHostName", NULL };
 541         const char *attrs_account_2[] = { "cn", "dnsHostName", "objectGUID", NULL };
 542
 543         const char *attrs_none[] = { NULL };
 544
 545         const char *attrs_site[] = { "objectGUID", NULL };
 546
 547         const char *attrs_ntds[] = { "options", "objectGUID", NULL };
 548
 549         const char *attrs_1[] = { "serverReference", "cn", "dnsHostName", NULL };
 550         const char *attrs_2[] = { "serverReference", "cn", "dnsHostName", "objectGUID", NULL };
 551         const char **attrs;
 552
 553         struct drsuapi_DsGetDCInfoCtr1 *ctr1;
 554         struct drsuapi_DsGetDCInfoCtr2 *ctr2;
 555
 556         int ret, i;
 557
 558         *r->out.level_out = r->in.req->req1.level;
 559         r->out.ctr = talloc(mem_ctx, union drsuapi_DsGetDCInfoCtr);
 560         W_ERROR_HAVE_NO_MEMORY(r->out.ctr);
 561
 562         sites_dn = samdb_sites_dn(b_state->sam_ctx, mem_ctx);
 563         if (!sites_dn) {
 564                 return WERR_DS_OBJ_NOT_FOUND;
 565         }
 566
 567         switch (*r->out.level_out) {
 568         case -1:
 569                 /* this level is not like the others */
 570                 return WERR_UNKNOWN_LEVEL;
 571         case 1:
 572                 attrs = attrs_1;
 573                 break;
 574         case 2:
 575                 attrs = attrs_2;
 576                 break;
 577         default:
 578                 return WERR_UNKNOWN_LEVEL;
 579         }
 580
 581         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res, sites_dn, LDB_SCOPE_SUBTREE, attrs,
 582                                  "objectClass=server");
 583
 584         if (ret) {
 585                 DEBUG(1, ("searching for servers in sites DN %s failed: %s\n",
 586                           ldb_dn_get_linearized(sites_dn), ldb_errstring(b_state->sam_ctx)));
 587                 return WERR_GENERAL_FAILURE;
 588         }
 589
 590         switch (*r->out.level_out) {
 591         case 1:
 592                 ctr1 = &r->out.ctr->ctr1;
 593                 ctr1->count = res->count;
 594                 ctr1->array = talloc_zero_array(mem_ctx,
 595                                                 struct drsuapi_DsGetDCInfo1,
 596                                                 res->count);
 597                 for (i=0; i < res->count; i++) {
 598                         struct ldb_dn *domain_dn;
 599                         struct ldb_result *res_domain;
 600                         struct ldb_result *res_account;
 601                         struct ldb_dn *ntds_dn = ldb_dn_copy(mem_ctx, res->msgs[i]->dn);
 602
 603                         struct ldb_dn *ref_dn
 604                                 = ldb_msg_find_attr_as_dn(b_state->sam_ctx,
 605                                                           mem_ctx, res->msgs[i],
 606                                                           "serverReference");
 607
 608                         if (!ntds_dn || !ldb_dn_add_child_fmt(ntds_dn, "CN=NTDS Settings")) {
 609                                 return WERR_NOMEM;
 610                         }
 611
 612                         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_account, ref_dn,
 613                                                  LDB_SCOPE_BASE, attrs_account_1, "objectClass=computer");
 614                         if (ret == LDB_SUCCESS && res_account->count == 1) {
 615                                 const char *errstr;
 616                                 ctr1->array[i].dns_name
 617                                         = ldb_msg_find_attr_as_string(res_account->msgs[0], "dNSHostName", NULL);
 618                                 ctr1->array[i].netbios_name
 619                                         = ldb_msg_find_attr_as_string(res_account->msgs[0], "cn", NULL);
 620                                 ctr1->array[i].computer_dn
 621                                         = ldb_dn_get_linearized(res_account->msgs[0]->dn);
 622
 623                                 /* Determine if this is the PDC */
 624                                 ret = samdb_search_for_parent_domain(b_state->sam_ctx,
 625                                                                      mem_ctx, res_account->msgs[0]->dn,
 626                                                                      &domain_dn, &errstr);
 627
 628                                 if (ret == LDB_SUCCESS) {
 629                                         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_domain, domain_dn,
 630                                                                  LDB_SCOPE_BASE, attrs_none, "fSMORoleOwner=%s",
 631                                                                  ldb_dn_get_linearized(ntds_dn));
 632                                         if (ret) {
 633                                                 return WERR_GENERAL_FAILURE;
 634                                         }
 635                                         if (res_domain->count == 1) {
 636                                                 ctr1->array[i].is_pdc = true;
 637                                         }
 638                                 }
 639                         }
 640                         if ((ret != LDB_SUCCESS) && (ret != LDB_ERR_NO_SUCH_OBJECT)) {
 641                                 DEBUG(5, ("warning: searching for computer DN %s failed: %s\n",
 642                                           ldb_dn_get_linearized(ref_dn), ldb_errstring(b_state->sam_ctx)));
 643                         }
 644
 645                         /* Look at server DN and extract site component */
 646                         ctr1->array[i].site_name = result_site_name(res->msgs[i]->dn);
 647                         ctr1->array[i].server_dn = ldb_dn_get_linearized(res->msgs[i]->dn);
 648
 649
 650                         ctr1->array[i].is_enabled = true;
 651
 652                 }
 653                 break;
 654         case 2:
 655                 ctr2 = &r->out.ctr->ctr2;
 656                 ctr2->count = res->count;
 657                 ctr2->array = talloc_zero_array(mem_ctx,
 658                                                  struct drsuapi_DsGetDCInfo2,
 659                                                  res->count);
 660                 for (i=0; i < res->count; i++) {
 661                         struct ldb_dn *domain_dn;
 662                         struct ldb_result *res_domain;
 663                         struct ldb_result *res_account;
 664                         struct ldb_dn *ntds_dn = ldb_dn_copy(mem_ctx, res->msgs[i]->dn);
 665                         struct ldb_result *res_ntds;
 666                         struct ldb_dn *site_dn = ldb_dn_copy(mem_ctx, res->msgs[i]->dn);
 667                         struct ldb_result *res_site;
 668                         struct ldb_dn *ref_dn
 669                                 = ldb_msg_find_attr_as_dn(b_state->sam_ctx,
 670                                                           mem_ctx, res->msgs[i],
 671                                                           "serverReference");
 672
 673                         if (!ntds_dn || !ldb_dn_add_child_fmt(ntds_dn, "CN=NTDS Settings")) {
 674                                 return WERR_NOMEM;
 675                         }
 676
 677                         /* Format is cn=<NETBIOS name>,cn=Servers,cn=<site>,cn=sites.... */
 678                         if (!site_dn || !ldb_dn_remove_child_components(site_dn, 2)) {
 679                                 return WERR_NOMEM;
 680                         }
 681
 682                         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_ntds, ntds_dn,
 683                                                  LDB_SCOPE_BASE, attrs_ntds, "objectClass=nTDSDSA");
 684                         if (ret == LDB_SUCCESS && res_ntds->count == 1) {
 685                                 ctr2->array[i].is_gc
 686                                         = (ldb_msg_find_attr_as_int(res_ntds->msgs[0], "options", 0) == 1);
 687                                 ctr2->array[i].ntds_guid
 688                                         = samdb_result_guid(res_ntds->msgs[0], "objectGUID");
 689                                 ctr2->array[i].ntds_dn = ldb_dn_get_linearized(res_ntds->msgs[0]->dn);
 690                         }
 691                         if ((ret != LDB_SUCCESS) && (ret != LDB_ERR_NO_SUCH_OBJECT)) {
 692                                 DEBUG(5, ("warning: searching for NTDS DN %s failed: %s\n",
 693                                           ldb_dn_get_linearized(ntds_dn), ldb_errstring(b_state->sam_ctx)));
 694                         }
 695
 696                         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_site, site_dn,
 697                                                  LDB_SCOPE_BASE, attrs_site, "objectClass=site");
 698                         if (ret == LDB_SUCCESS && res_site->count == 1) {
 699                                 ctr2->array[i].site_guid
 700                                         = samdb_result_guid(res_site->msgs[0], "objectGUID");
 701                                 ctr2->array[i].site_dn = ldb_dn_get_linearized(res_site->msgs[0]->dn);
 702                         }
 703                         if ((ret != LDB_SUCCESS) && (ret != LDB_ERR_NO_SUCH_OBJECT)) {
 704                                 DEBUG(5, ("warning: searching for site DN %s failed: %s\n",
 705                                           ldb_dn_get_linearized(site_dn), ldb_errstring(b_state->sam_ctx)));
 706                         }
 707
 708                         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_account, ref_dn,
 709                                                  LDB_SCOPE_BASE, attrs_account_2, "objectClass=computer");
 710                         if (ret == LDB_SUCCESS && res_account->count == 1) {
 711                                 const char *errstr;
 712                                 ctr2->array[i].dns_name
 713                                         = ldb_msg_find_attr_as_string(res_account->msgs[0], "dNSHostName", NULL);
 714                                 ctr2->array[i].netbios_name
 715                                         = ldb_msg_find_attr_as_string(res_account->msgs[0], "cn", NULL);
 716                                 ctr2->array[i].computer_dn = ldb_dn_get_linearized(res_account->msgs[0]->dn);
 717                                 ctr2->array[i].computer_guid
 718                                         = samdb_result_guid(res_account->msgs[0], "objectGUID");
 719
 720                                 /* Determine if this is the PDC */
 721                                 ret = samdb_search_for_parent_domain(b_state->sam_ctx,
 722                                                                      mem_ctx, res_account->msgs[0]->dn,
 723                                                                      &domain_dn, &errstr);
 724
 725                                 if (ret == LDB_SUCCESS) {
 726                                         ret = ldb_search(b_state->sam_ctx, mem_ctx, &res_domain, domain_dn,
 727                                                                  LDB_SCOPE_BASE, attrs_none, "fSMORoleOwner=%s",
 728                                                                  ldb_dn_get_linearized(ntds_dn));
 729                                         if (ret == LDB_SUCCESS && res_domain->count == 1) {
 730                                                 ctr2->array[i].is_pdc = true;
 731                                         }
 732                                         if ((ret != LDB_SUCCESS) && (ret != LDB_ERR_NO_SUCH_OBJECT)) {
 733                                                 DEBUG(5, ("warning: searching for domain DN %s failed: %s\n",
 734                                                           ldb_dn_get_linearized(domain_dn), ldb_errstring(b_state->sam_ctx)));
 735                                         }
 736                                 }
 737                         }
 738                         if ((ret != LDB_SUCCESS) && (ret != LDB_ERR_NO_SUCH_OBJECT)) {
 739                                 DEBUG(5, ("warning: searching for computer account DN %s failed: %s\n",
 740                                           ldb_dn_get_linearized(ref_dn), ldb_errstring(b_state->sam_ctx)));
 741                         }
 742
 743                         /* Look at server DN and extract site component */
 744                         ctr2->array[i].site_name = result_site_name(res->msgs[i]->dn);
 745                         ctr2->array[i].server_dn = ldb_dn_get_linearized(res->msgs[i]->dn);
 746                         ctr2->array[i].server_guid
 747                                 = samdb_result_guid(res->msgs[i], "objectGUID");
 748
 749                         ctr2->array[i].is_enabled = true;
 750
 751                 }
 752                 break;
 753         }
 754         return WERR_OK;
 755 }
 756
 757 /*
 758   drsuapi_DsGetDomainControllerInfo
 759 */
 760 static WERROR dcesrv_drsuapi_DsGetDomainControllerInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 761                                                 struct drsuapi_DsGetDomainControllerInfo *r)
 762 {
 763         struct dcesrv_handle *h;
 764         struct drsuapi_bind_state *b_state;
 765         DCESRV_PULL_HANDLE_WERR(h, r->in.bind_handle, DRSUAPI_BIND_HANDLE);
 766         b_state = h->data;
 767
 768         switch (r->in.level) {
 769         case 1:
 770                 return dcesrv_drsuapi_DsGetDomainControllerInfo_1(b_state, mem_ctx, r);
 771         }
 772
 773         return WERR_UNKNOWN_LEVEL;
 774 }
 775
 776
 777
 778 /*
 779   drsuapi_DsExecuteKCC
 780 */
 781 static WERROR dcesrv_drsuapi_DsExecuteKCC(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 782                                   struct drsuapi_DsExecuteKCC *r)
 783 {
 784         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 785 }
 786
 787
 788 /*
 789   drsuapi_DsReplicaGetInfo
 790 */
 791 static WERROR dcesrv_drsuapi_DsReplicaGetInfo(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 792                        struct drsuapi_DsReplicaGetInfo *r)
 793 {
 794         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 795 }
 796
 797
 798 /*
 799   DRSUAPI_ADD_SID_HISTORY
 800 */
 801 static WERROR dcesrv_DRSUAPI_ADD_SID_HISTORY(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 802                        struct DRSUAPI_ADD_SID_HISTORY *r)
 803 {
 804         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 805 }
 806
 807 /*
 808   drsuapi_DsGetMemberships2
 809 */
 810 static WERROR dcesrv_drsuapi_DsGetMemberships2(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 811                        struct drsuapi_DsGetMemberships2 *r)
 812 {
 813         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 814 }
 815
 816 /*
 817   DRSUAPI_REPLICA_VERIFY_OBJECTS
 818 */
 819 static WERROR dcesrv_DRSUAPI_REPLICA_VERIFY_OBJECTS(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 820                        struct DRSUAPI_REPLICA_VERIFY_OBJECTS *r)
 821 {
 822         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 823 }
 824
 825
 826 /*
 827   DRSUAPI_GET_OBJECT_EXISTENCE
 828 */
 829 static WERROR dcesrv_DRSUAPI_GET_OBJECT_EXISTENCE(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 830                        struct DRSUAPI_GET_OBJECT_EXISTENCE *r)
 831 {
 832         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 833 }
 834
 835
 836 /*
 837   drsuapi_QuerySitesByCost
 838 */
 839 static WERROR dcesrv_drsuapi_QuerySitesByCost(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx,
 840                        struct drsuapi_QuerySitesByCost *r)
 841 {
 842         DCESRV_FAULT(DCERPC_FAULT_OP_RNG_ERROR);
 843 }
 844
 845
 846 /* include the generated boilerplate */
 847 #include "librpc/gen_ndr/ndr_drsuapi_s.c"