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