source/libnet/libnet_unbecome_dc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3
   4    Copyright (C) Stefan Metzmacher <metze@samba.org> 2006
   5
   6    This program is free software; you can redistribute it and/or modify
   7    it under the terms of the GNU General Public License as published by
   8    the Free Software Foundation; either version 3 of the License, or
   9    (at your option) any later version.
  10
  11    This program is distributed in the hope that it will be useful,
  12    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14    GNU General Public License for more details.
  15
  16    You should have received a copy of the GNU General Public License
  17    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18 */
  19
  20 #include "includes.h"
  21 #include "libnet/libnet.h"
  22 #include "libcli/composite/composite.h"
  23 #include "libcli/cldap/cldap.h"
  24 #include "lib/ldb/include/ldb.h"
  25 #include "lib/ldb/include/ldb_errors.h"
  26 #include "lib/db_wrap.h"
  27 #include "dsdb/samdb/samdb.h"
  28 #include "dsdb/common/flags.h"
  29 #include "librpc/gen_ndr/ndr_drsuapi_c.h"
  30
  31 /*****************************************************************************
  32  * Windows 2003 (w2k3) does the following steps when changing the server role
  33  * from domain controller back to domain member
  34  *
  35  * We mostly do the same.
  36  *****************************************************************************/
  37
  38 /*
  39  * lookup DC:
  40  * - using nbt name<1C> request and a samlogon mailslot request
  41  * or
  42  * - using a DNS SRV _ldap._tcp.dc._msdcs. request and a CLDAP netlogon request
  43  *
  44  * see: unbecomeDC_send_cldap() and unbecomeDC_recv_cldap()
  45  */
  46
  47 /*
  48  * Open 1st LDAP connection to the DC using admin credentials
  49  *
  50  * see: unbecomeDC_ldap_connect()
  51  */
  52
  53 /*
  54  * LDAP search 1st LDAP connection:
  55  *
  56  * see: unbecomeDC_ldap_rootdse()
  57  *
  58  * Request:
  59  *      basedn: ""
  60  *      scope:  base
  61  *      filter: (objectClass=*)
  62  *      attrs:  defaultNamingContext
  63  *              configurationNamingContext
  64  * Result:
  65  *      ""
  66  *              defaultNamingContext:   <domain_partition>
  67  *              configurationNamingContext:CN=Configuration,<domain_partition>
  68  */
  69
  70 /*
  71  * LDAP search 1st LDAP connection:
  72  *
  73  * see: unbecomeDC_ldap_computer_object()
  74  *
  75  * Request:
  76  *      basedn: <domain_partition>
  77  *      scope:  sub
  78  *      filter: (&(|(objectClass=user)(objectClass=computer))(sAMAccountName=<new_dc_account_name>))
  79  *      attrs:  distinguishedName
  80  *              userAccountControl
  81  * Result:
  82  *      CN=<new_dc_netbios_name>,CN=Domain Controllers,<domain_partition>
  83  *              distinguishedName:      CN=<new_dc_netbios_name>,CN=Domain Controllers,<domain_partition>
  84  *              userAccoountControl:    532480 <0x82000>
  85  */
  86
  87 /*
  88  * LDAP search 1st LDAP connection:
  89  *
  90  * see: unbecomeDC_ldap_modify_computer()
  91  *
  92  * Request:
  93  *      basedn: CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
  94  *      scope:  base
  95  *      filter: (objectClass=*)
  96  *      attrs:  userAccountControl
  97  * Result:
  98  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
  99  *              userAccoountControl:    532480 <0x82000>
 100  */
 101
 102 /*
 103  * LDAP modify 1st LDAP connection:
 104  *
 105  * see: unbecomeDC_ldap_modify_computer()
 106  *
 107  * Request (replace):
 108  *      CN=<new_dc_netbios_name>,CN=Computers,<domain_partition>
 109  *      userAccoountControl:    4096 <0x1000>
 110  * Result:
 111  *      <success>
 112  */
 113
 114 /*
 115  * LDAP search 1st LDAP connection:
 116  *
 117  * see: unbecomeDC_ldap_move_computer()
 118  *
 119  * Request:
 120  *      basedn: <WKGUID=aa312825768811d1aded00c04fd8d5cd,<domain_partition>>
 121  *      scope:  base
 122  *      filter: (objectClass=*)
 123  *      attrs:  1.1
 124  * Result:
 125  *      CN=Computers,<domain_partition>
 126  */
 127
 128 /*
 129  * LDAP search 1st LDAP connection:
 130  *
 131  * not implemented because it doesn't give any new information
 132  *
 133  * Request:
 134  *      basedn: CN=Computers,<domain_partition>
 135  *      scope:  base
 136  *      filter: (objectClass=*)
 137  *      attrs:  distinguishedName
 138  * Result:
 139  *      CN=Computers,<domain_partition>
 140  *              distinguishedName:      CN=Computers,<domain_partition>
 141  */
 142
 143 /*
 144  * LDAP modifyRDN 1st LDAP connection:
 145  *
 146  * see: unbecomeDC_ldap_move_computer()
 147  *
 148  * Request:
 149  *      entry:          CN=<new_dc_netbios_name>,CN=Domain Controllers,<domain_partition>
 150  *      newrdn:         CN=<new_dc_netbios_name>
 151  *      deleteoldrdn:   TRUE
 152  *      newparent:      CN=Computers,<domain_partition>
 153  * Result:
 154  *      <success>
 155  */
 156
 157 /*
 158  * LDAP unbind on the 1st LDAP connection
 159  *
 160  * not implemented, because it's not needed...
 161  */
 162
 163 /*
 164  * Open 1st DRSUAPI connection to the DC using admin credentials
 165  * DsBind with DRSUAPI_DS_BIND_GUID ("e24d201a-4fd6-11d1-a3da-0000f875ae0d")
 166  *
 167  * see: unbecomeDC_drsuapi_connect_send(), unbecomeDC_drsuapi_connect_recv(),
 168  *      unbecomeDC_drsuapi_bind_send() and unbecomeDC_drsuapi_bind_recv()
 169  */
 170
 171 /*
 172  * DsRemoveDsServer to remove the
 173  * CN=<machine_name>,CN=Servers,CN=<site_name>,CN=Configuration,<domain_partition>
 174  * and CN=NTDS Settings,CN=<machine_name>,CN=Servers,CN=<site_name>,CN=Configuration,<domain_partition>
 175  * on the 1st DRSUAPI connection
 176  *
 177  * see: unbecomeDC_drsuapi_remove_ds_server_send() and unbecomeDC_drsuapi_remove_ds_server_recv()
 178  */
 179
 180 /*
 181  * DsUnbind on the 1st DRSUAPI connection
 182  *
 183  * not implemented, because it's not needed...
 184  */
 185
 186
 187 struct libnet_UnbecomeDC_state {
 188         struct composite_context *creq;
 189
 190         struct libnet_context *libnet;
 191
 192         struct {
 193                 struct cldap_socket *sock;
 194                 struct cldap_netlogon io;
 195                 struct nbt_cldap_netlogon_5 netlogon5;
 196         } cldap;
 197
 198         struct {
 199                 struct ldb_context *ldb;
 200         } ldap;
 201
 202         struct {
 203                 struct dcerpc_binding *binding;
 204                 struct dcerpc_pipe *pipe;
 205                 struct drsuapi_DsBind bind_r;
 206                 struct GUID bind_guid;
 207                 struct drsuapi_DsBindInfoCtr bind_info_ctr;
 208                 struct drsuapi_DsBindInfo28 local_info28;
 209                 struct drsuapi_DsBindInfo28 remote_info28;
 210                 struct policy_handle bind_handle;
 211                 struct drsuapi_DsRemoveDSServer rm_ds_srv_r;
 212         } drsuapi;
 213
 214         struct {
 215                 /* input */
 216                 const char *dns_name;
 217                 const char *netbios_name;
 218
 219                 /* constructed */
 220                 struct GUID guid;
 221                 const char *dn_str;
 222         } domain;
 223
 224         struct {
 225                 /* constructed */
 226                 const char *config_dn_str;
 227         } forest;
 228
 229         struct {
 230                 /* input */
 231                 const char *address;
 232
 233                 /* constructed */
 234                 const char *dns_name;
 235                 const char *netbios_name;
 236                 const char *site_name;
 237         } source_dsa;
 238
 239         struct {
 240                 /* input */
 241                 const char *netbios_name;
 242
 243                 /* constructed */
 244                 const char *dns_name;
 245                 const char *site_name;
 246                 const char *computer_dn_str;
 247                 const char *server_dn_str;
 248                 uint32_t user_account_control;
 249         } dest_dsa;
 250 };
 251
 252 static void unbecomeDC_recv_cldap(struct cldap_request *req);
 253
 254 static void unbecomeDC_send_cldap(struct libnet_UnbecomeDC_state *s)
 255 {
 256         struct composite_context *c = s->creq;
 257         struct cldap_request *req;
 258
 259         s->cldap.io.in.dest_address     = s->source_dsa.address;
 260         s->cldap.io.in.realm            = s->domain.dns_name;
 261         s->cldap.io.in.host             = s->dest_dsa.netbios_name;
 262         s->cldap.io.in.user             = NULL;
 263         s->cldap.io.in.domain_guid      = NULL;
 264         s->cldap.io.in.domain_sid       = NULL;
 265         s->cldap.io.in.acct_control     = -1;
 266         s->cldap.io.in.version          = 6;
 267
 268         s->cldap.sock = cldap_socket_init(s, s->libnet->event_ctx);
 269         if (composite_nomem(s->cldap.sock, c)) return;
 270
 271         req = cldap_netlogon_send(s->cldap.sock, &s->cldap.io);
 272         if (composite_nomem(req, c)) return;
 273         req->async.fn           = unbecomeDC_recv_cldap;
 274         req->async.private      = s;
 275 }
 276
 277 static void unbecomeDC_connect_ldap(struct libnet_UnbecomeDC_state *s);
 278
 279 static void unbecomeDC_recv_cldap(struct cldap_request *req)
 280 {
 281         struct libnet_UnbecomeDC_state *s = talloc_get_type(req->async.private,
 282                                             struct libnet_UnbecomeDC_state);
 283         struct composite_context *c = s->creq;
 284
 285         c->status = cldap_netlogon_recv(req, s, &s->cldap.io);
 286         if (!composite_is_ok(c)) return;
 287
 288         s->cldap.netlogon5 = s->cldap.io.out.netlogon.logon5;
 289
 290         s->domain.dns_name              = s->cldap.netlogon5.dns_domain;
 291         s->domain.netbios_name          = s->cldap.netlogon5.domain;
 292         s->domain.guid                  = s->cldap.netlogon5.domain_uuid;
 293
 294         s->source_dsa.dns_name          = s->cldap.netlogon5.pdc_dns_name;
 295         s->source_dsa.netbios_name      = s->cldap.netlogon5.pdc_name;
 296         s->source_dsa.site_name         = s->cldap.netlogon5.server_site;
 297
 298         s->dest_dsa.site_name           = s->cldap.netlogon5.client_site;
 299
 300         unbecomeDC_connect_ldap(s);
 301 }
 302
 303 static NTSTATUS unbecomeDC_ldap_connect(struct libnet_UnbecomeDC_state *s)
 304 {
 305         char *url;
 306
 307         url = talloc_asprintf(s, "ldap://%s/", s->source_dsa.dns_name);
 308         NT_STATUS_HAVE_NO_MEMORY(url);
 309
 310         s->ldap.ldb = ldb_wrap_connect(s, url,
 311                                        NULL,
 312                                        s->libnet->cred,
 313                                        0, NULL);
 314         talloc_free(url);
 315         if (s->ldap.ldb == NULL) {
 316                 return NT_STATUS_UNEXPECTED_NETWORK_ERROR;
 317         }
 318
 319         return NT_STATUS_OK;
 320 }
 321
 322 static NTSTATUS unbecomeDC_ldap_rootdse(struct libnet_UnbecomeDC_state *s)
 323 {
 324         int ret;
 325         struct ldb_result *r;
 326         struct ldb_dn *basedn;
 327         static const char *attrs[] = {
 328                 "defaultNamingContext",
 329                 "configurationNamingContext",
 330                 NULL
 331         };
 332
 333         basedn = ldb_dn_new(s, s->ldap.ldb, NULL);
 334         NT_STATUS_HAVE_NO_MEMORY(basedn);
 335
 336         ret = ldb_search(s->ldap.ldb, basedn, LDB_SCOPE_BASE,
 337                          "(objectClass=*)", attrs, &r);
 338         talloc_free(basedn);
 339         if (ret != LDB_SUCCESS) {
 340                 return NT_STATUS_LDAP(ret);
 341         } else if (r->count != 1) {
 342                 talloc_free(r);
 343                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 344         }
 345         talloc_steal(s, r);
 346
 347         s->domain.dn_str        = ldb_msg_find_attr_as_string(r->msgs[0], "defaultNamingContext", NULL);
 348         if (!s->domain.dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 349         talloc_steal(s, s->domain.dn_str);
 350
 351         s->forest.config_dn_str = ldb_msg_find_attr_as_string(r->msgs[0], "configurationNamingContext", NULL);
 352         if (!s->forest.config_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 353         talloc_steal(s, s->forest.config_dn_str);
 354
 355         s->dest_dsa.server_dn_str = talloc_asprintf(s, "CN=%s,CN=Servers,CN=%s,CN=Sites,%s",
 356                                                     s->dest_dsa.netbios_name,
 357                                                     s->dest_dsa.site_name,
 358                                                     s->forest.config_dn_str);
 359         NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.server_dn_str);
 360
 361         talloc_free(r);
 362         return NT_STATUS_OK;
 363 }
 364
 365 static NTSTATUS unbecomeDC_ldap_computer_object(struct libnet_UnbecomeDC_state *s)
 366 {
 367         int ret;
 368         struct ldb_result *r;
 369         struct ldb_dn *basedn;
 370         char *filter;
 371         static const char *attrs[] = {
 372                 "distinguishedName",
 373                 "userAccountControl",
 374                 NULL
 375         };
 376
 377         basedn = ldb_dn_new(s, s->ldap.ldb, s->domain.dn_str);
 378         NT_STATUS_HAVE_NO_MEMORY(basedn);
 379
 380         filter = talloc_asprintf(basedn, "(&(|(objectClass=user)(objectClass=computer))(sAMAccountName=%s$))",
 381                                  s->dest_dsa.netbios_name);
 382         NT_STATUS_HAVE_NO_MEMORY(filter);
 383
 384         ret = ldb_search(s->ldap.ldb, basedn, LDB_SCOPE_SUBTREE,
 385                          filter, attrs, &r);
 386         talloc_free(basedn);
 387         if (ret != LDB_SUCCESS) {
 388                 return NT_STATUS_LDAP(ret);
 389         } else if (r->count != 1) {
 390                 talloc_free(r);
 391                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 392         }
 393
 394         s->dest_dsa.computer_dn_str     = samdb_result_string(r->msgs[0], "distinguishedName", NULL);
 395         if (!s->dest_dsa.computer_dn_str) return NT_STATUS_INVALID_NETWORK_RESPONSE;
 396         talloc_steal(s, s->dest_dsa.computer_dn_str);
 397
 398         s->dest_dsa.user_account_control = samdb_result_uint(r->msgs[0], "userAccountControl", 0);
 399
 400         talloc_free(r);
 401         return NT_STATUS_OK;
 402 }
 403
 404 static NTSTATUS unbecomeDC_ldap_modify_computer(struct libnet_UnbecomeDC_state *s)
 405 {
 406         int ret;
 407         struct ldb_message *msg;
 408         uint32_t user_account_control = UF_WORKSTATION_TRUST_ACCOUNT;
 409         uint32_t i;
 410
 411         /* as the value is already as we want it to be, we're done */
 412         if (s->dest_dsa.user_account_control == user_account_control) {
 413                 return NT_STATUS_OK;
 414         }
 415
 416         /* make a 'modify' msg, and only for serverReference */
 417         msg = ldb_msg_new(s);
 418         NT_STATUS_HAVE_NO_MEMORY(msg);
 419         msg->dn = ldb_dn_new(msg, s->ldap.ldb, s->dest_dsa.computer_dn_str);
 420         NT_STATUS_HAVE_NO_MEMORY(msg->dn);
 421
 422         ret = ldb_msg_add_fmt(msg, "userAccountControl", "%u", user_account_control);
 423         if (ret != 0) {
 424                 talloc_free(msg);
 425                 return NT_STATUS_NO_MEMORY;
 426         }
 427
 428         /* mark all the message elements (should be just one)
 429            as LDB_FLAG_MOD_REPLACE */
 430         for (i=0;i<msg->num_elements;i++) {
 431                 msg->elements[i].flags = LDB_FLAG_MOD_REPLACE;
 432         }
 433
 434         ret = ldb_modify(s->ldap.ldb, msg);
 435         talloc_free(msg);
 436         if (ret != LDB_SUCCESS) {
 437                 return NT_STATUS_LDAP(ret);
 438         }
 439
 440         s->dest_dsa.user_account_control = user_account_control;
 441
 442         return NT_STATUS_OK;
 443 }
 444
 445 static NTSTATUS unbecomeDC_ldap_move_computer(struct libnet_UnbecomeDC_state *s)
 446 {
 447         int ret;
 448         struct ldb_result *r;
 449         struct ldb_dn *basedn;
 450         struct ldb_dn *old_dn;
 451         struct ldb_dn *new_dn;
 452         static const char *_1_1_attrs[] = {
 453                 "1.1",
 454                 NULL
 455         };
 456
 457         basedn = ldb_dn_new_fmt(s, s->ldap.ldb, "<WKGUID=aa312825768811d1aded00c04fd8d5cd,%s>",
 458                                 s->domain.dn_str);
 459         NT_STATUS_HAVE_NO_MEMORY(basedn);
 460
 461         ret = ldb_search(s->ldap.ldb, basedn, LDB_SCOPE_BASE,
 462                          "(objectClass=*)", _1_1_attrs, &r);
 463         talloc_free(basedn);
 464         if (ret != LDB_SUCCESS) {
 465                 return NT_STATUS_LDAP(ret);
 466         } else if (r->count != 1) {
 467                 talloc_free(r);
 468                 return NT_STATUS_INVALID_NETWORK_RESPONSE;
 469         }
 470
 471         old_dn = ldb_dn_new(r, s->ldap.ldb, s->dest_dsa.computer_dn_str);
 472         NT_STATUS_HAVE_NO_MEMORY(old_dn);
 473
 474         new_dn = r->msgs[0]->dn;
 475
 476         if (!ldb_dn_add_child_fmt(new_dn, "CN=%s", s->dest_dsa.netbios_name)) {
 477                 talloc_free(r);
 478                 return NT_STATUS_NO_MEMORY;
 479         }
 480
 481         if (ldb_dn_compare(old_dn, new_dn) == 0) {
 482                 /* we don't need to rename if the old and new dn match */
 483                 talloc_free(r);
 484                 return NT_STATUS_OK;
 485         }
 486
 487         ret = ldb_rename(s->ldap.ldb, old_dn, new_dn);
 488         if (ret != LDB_SUCCESS) {
 489                 talloc_free(r);
 490                 return NT_STATUS_LDAP(ret);
 491         }
 492
 493         s->dest_dsa.computer_dn_str = ldb_dn_alloc_linearized(s, new_dn);
 494         NT_STATUS_HAVE_NO_MEMORY(s->dest_dsa.computer_dn_str);
 495
 496         talloc_free(r);
 497
 498         return NT_STATUS_OK;
 499 }
 500
 501 static void unbecomeDC_drsuapi_connect_send(struct libnet_UnbecomeDC_state *s);
 502
 503 static void unbecomeDC_connect_ldap(struct libnet_UnbecomeDC_state *s)
 504 {
 505         struct composite_context *c = s->creq;
 506
 507         c->status = unbecomeDC_ldap_connect(s);
 508         if (!composite_is_ok(c)) return;
 509
 510         c->status = unbecomeDC_ldap_rootdse(s);
 511         if (!composite_is_ok(c)) return;
 512
 513         c->status = unbecomeDC_ldap_computer_object(s);
 514         if (!composite_is_ok(c)) return;
 515
 516         c->status = unbecomeDC_ldap_modify_computer(s);
 517         if (!composite_is_ok(c)) return;
 518
 519         c->status = unbecomeDC_ldap_move_computer(s);
 520         if (!composite_is_ok(c)) return;
 521
 522         unbecomeDC_drsuapi_connect_send(s);
 523 }
 524
 525 static void unbecomeDC_drsuapi_connect_recv(struct composite_context *creq);
 526
 527 static void unbecomeDC_drsuapi_connect_send(struct libnet_UnbecomeDC_state *s)
 528 {
 529         struct composite_context *c = s->creq;
 530         struct composite_context *creq;
 531         char *binding_str;
 532
 533         binding_str = talloc_asprintf(s, "ncacn_ip_tcp:%s[seal]", s->source_dsa.dns_name);
 534         if (composite_nomem(binding_str, c)) return;
 535
 536         c->status = dcerpc_parse_binding(s, binding_str, &s->drsuapi.binding);
 537         talloc_free(binding_str);
 538         if (!composite_is_ok(c)) return;
 539
 540         creq = dcerpc_pipe_connect_b_send(s, s->drsuapi.binding, &dcerpc_table_drsuapi,
 541                                           s->libnet->cred, s->libnet->event_ctx);
 542         composite_continue(c, creq, unbecomeDC_drsuapi_connect_recv, s);
 543 }
 544
 545 static void unbecomeDC_drsuapi_bind_send(struct libnet_UnbecomeDC_state *s);
 546
 547 static void unbecomeDC_drsuapi_connect_recv(struct composite_context *req)
 548 {
 549         struct libnet_UnbecomeDC_state *s = talloc_get_type(req->async.private_data,
 550                                             struct libnet_UnbecomeDC_state);
 551         struct composite_context *c = s->creq;
 552
 553         c->status = dcerpc_pipe_connect_b_recv(req, s, &s->drsuapi.pipe);
 554         if (!composite_is_ok(c)) return;
 555
 556         unbecomeDC_drsuapi_bind_send(s);
 557 }
 558
 559 static void unbecomeDC_drsuapi_bind_recv(struct rpc_request *req);
 560
 561 static void unbecomeDC_drsuapi_bind_send(struct libnet_UnbecomeDC_state *s)
 562 {
 563         struct composite_context *c = s->creq;
 564         struct rpc_request *req;
 565         struct drsuapi_DsBindInfo28 *bind_info28;
 566
 567         GUID_from_string(DRSUAPI_DS_BIND_GUID, &s->drsuapi.bind_guid);
 568
 569         bind_info28                             = &s->drsuapi.local_info28;
 570         bind_info28->supported_extensions       = 0;
 571         bind_info28->site_guid                  = GUID_zero();
 572         bind_info28->u1                         = 508;
 573         bind_info28->repl_epoch                 = 0;
 574
 575         s->drsuapi.bind_info_ctr.length         = 28;
 576         s->drsuapi.bind_info_ctr.info.info28    = *bind_info28;
 577
 578         s->drsuapi.bind_r.in.bind_guid = &s->drsuapi.bind_guid;
 579         s->drsuapi.bind_r.in.bind_info = &s->drsuapi.bind_info_ctr;
 580         s->drsuapi.bind_r.out.bind_handle = &s->drsuapi.bind_handle;
 581
 582         req = dcerpc_drsuapi_DsBind_send(s->drsuapi.pipe, s, &s->drsuapi.bind_r);
 583         composite_continue_rpc(c, req, unbecomeDC_drsuapi_bind_recv, s);
 584 }
 585
 586 static void unbecomeDC_drsuapi_remove_ds_server_send(struct libnet_UnbecomeDC_state *s);
 587
 588 static void unbecomeDC_drsuapi_bind_recv(struct rpc_request *req)
 589 {
 590         struct libnet_UnbecomeDC_state *s = talloc_get_type(req->async.private_data,
 591                                             struct libnet_UnbecomeDC_state);
 592         struct composite_context *c = s->creq;
 593
 594         c->status = dcerpc_ndr_request_recv(req);
 595         if (!composite_is_ok(c)) return;
 596
 597         if (!W_ERROR_IS_OK(s->drsuapi.bind_r.out.result)) {
 598                 composite_error(c, werror_to_ntstatus(s->drsuapi.bind_r.out.result));
 599                 return;
 600         }
 601
 602         ZERO_STRUCT(s->drsuapi.remote_info28);
 603         if (s->drsuapi.bind_r.out.bind_info) {
 604                 switch (s->drsuapi.bind_r.out.bind_info->length) {
 605                 case 24: {
 606                         struct drsuapi_DsBindInfo24 *info24;
 607                         info24 = &s->drsuapi.bind_r.out.bind_info->info.info24;
 608                         s->drsuapi.remote_info28.supported_extensions   = info24->supported_extensions;
 609                         s->drsuapi.remote_info28.site_guid              = info24->site_guid;
 610                         s->drsuapi.remote_info28.u1                     = info24->u1;
 611                         s->drsuapi.remote_info28.repl_epoch             = 0;
 612                         break;
 613                 }
 614                 case 28:
 615                         s->drsuapi.remote_info28 = s->drsuapi.bind_r.out.bind_info->info.info28;
 616                         break;
 617                 }
 618         }
 619
 620         unbecomeDC_drsuapi_remove_ds_server_send(s);
 621 }
 622
 623 static void unbecomeDC_drsuapi_remove_ds_server_recv(struct rpc_request *req);
 624
 625 static void unbecomeDC_drsuapi_remove_ds_server_send(struct libnet_UnbecomeDC_state *s)
 626 {
 627         struct composite_context *c = s->creq;
 628         struct rpc_request *req;
 629         struct drsuapi_DsRemoveDSServer *r = &s->drsuapi.rm_ds_srv_r;
 630
 631         r->in.bind_handle       = &s->drsuapi.bind_handle;
 632         r->in.level             = 1;
 633         r->in.req.req1.server_dn= s->dest_dsa.server_dn_str;
 634         r->in.req.req1.domain_dn= s->domain.dn_str;
 635         r->in.req.req1.unknown  = 0x00000001;
 636
 637         req = dcerpc_drsuapi_DsRemoveDSServer_send(s->drsuapi.pipe, s, r);
 638         composite_continue_rpc(c, req, unbecomeDC_drsuapi_remove_ds_server_recv, s);
 639 }
 640
 641 static void unbecomeDC_drsuapi_remove_ds_server_recv(struct rpc_request *req)
 642 {
 643         struct libnet_UnbecomeDC_state *s = talloc_get_type(req->async.private_data,
 644                                             struct libnet_UnbecomeDC_state);
 645         struct composite_context *c = s->creq;
 646         struct drsuapi_DsRemoveDSServer *r = &s->drsuapi.rm_ds_srv_r;
 647
 648         c->status = dcerpc_ndr_request_recv(req);
 649         if (!composite_is_ok(c)) return;
 650
 651         if (!W_ERROR_IS_OK(r->out.result)) {
 652                 composite_error(c, werror_to_ntstatus(r->out.result));
 653                 return;
 654         }
 655
 656         if (r->out.level != 1) {
 657                 composite_error(c, NT_STATUS_INVALID_NETWORK_RESPONSE);
 658                 return;
 659         }
 660
 661         if (!W_ERROR_IS_OK(r->out.res.res1.status)) {
 662                 composite_error(c, werror_to_ntstatus(r->out.res.res1.status));
 663                 return;
 664         }
 665
 666         composite_done(c);
 667 }
 668
 669 struct composite_context *libnet_UnbecomeDC_send(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_UnbecomeDC *r)
 670 {
 671         struct composite_context *c;
 672         struct libnet_UnbecomeDC_state *s;
 673         char *tmp_name;
 674
 675         c = composite_create(mem_ctx, ctx->event_ctx);
 676         if (c == NULL) return NULL;
 677
 678         s = talloc_zero(c, struct libnet_UnbecomeDC_state);
 679         if (composite_nomem(s, c)) return c;
 680         c->private_data = s;
 681         s->creq         = c;
 682         s->libnet       = ctx;
 683
 684         /* Domain input */
 685         s->domain.dns_name      = talloc_strdup(s, r->in.domain_dns_name);
 686         if (composite_nomem(s->domain.dns_name, c)) return c;
 687         s->domain.netbios_name  = talloc_strdup(s, r->in.domain_netbios_name);
 688         if (composite_nomem(s->domain.netbios_name, c)) return c;
 689
 690         /* Source DSA input */
 691         s->source_dsa.address   = talloc_strdup(s, r->in.source_dsa_address);
 692         if (composite_nomem(s->source_dsa.address, c)) return c;
 693
 694         /* Destination DSA input */
 695         s->dest_dsa.netbios_name= talloc_strdup(s, r->in.dest_dsa_netbios_name);
 696         if (composite_nomem(s->dest_dsa.netbios_name, c)) return c;
 697
 698         /* Destination DSA dns_name construction */
 699         tmp_name                = strlower_talloc(s, s->dest_dsa.netbios_name);
 700         if (composite_nomem(tmp_name, c)) return c;
 701         s->dest_dsa.dns_name    = talloc_asprintf_append(tmp_name, ".%s",
 702                                                          s->domain.dns_name);
 703         if (composite_nomem(s->dest_dsa.dns_name, c)) return c;
 704
 705         unbecomeDC_send_cldap(s);
 706         return c;
 707 }
 708
 709 NTSTATUS libnet_UnbecomeDC_recv(struct composite_context *c, TALLOC_CTX *mem_ctx, struct libnet_UnbecomeDC *r)
 710 {
 711         NTSTATUS status;
 712
 713         status = composite_wait(c);
 714
 715         ZERO_STRUCT(r->out);
 716
 717         talloc_free(c);
 718         return status;
 719 }
 720
 721 NTSTATUS libnet_UnbecomeDC(struct libnet_context *ctx, TALLOC_CTX *mem_ctx, struct libnet_UnbecomeDC *r)
 722 {
 723         NTSTATUS status;
 724         struct composite_context *c;
 725         c = libnet_UnbecomeDC_send(ctx, mem_ctx, r);
 726         status = libnet_UnbecomeDC_recv(c, mem_ctx, r);
 727         return status;
 728 }