source3/winbindd/winbindd_irpc.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    async implementation of commands submitted over IRPC
   4    Copyright (C) Volker Lendecke 2009
   5    Copyright (C) Guenther Deschner 2009
   6    Copyright (C) Andrew Bartlett 2014
   7    Copyright (C) Andrew Tridgell 2009
   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 "winbindd.h"
  25 #include "librpc/gen_ndr/ndr_winbind_c.h"
  26 #include "source4/lib/messaging/irpc.h"
  27 #include "librpc/gen_ndr/ndr_winbind.h"
  28 #include "librpc/gen_ndr/ndr_lsa.h"
  29 #include "librpc/gen_ndr/ndr_lsa_c.h"
  30 #include "libcli/security/dom_sid.h"
  31 #include "passdb/lookup_sid.h" /* only for LOOKUP_NAME_NO_NSS flag */
  32 #include "librpc/gen_ndr/ndr_irpc.h"
  33 #include "librpc/gen_ndr/ndr_netlogon.h"
  34 #include "lib/global_contexts.h"
  35 #include "lib/param/param.h"
  36 #include "messages.h"
  37
  38 struct imessaging_context *winbind_imessaging_context(void)
  39 {
  40         static struct imessaging_context *msg = NULL;
  41         struct messaging_context *msg_ctx;
  42         struct server_id myself;
  43         struct loadparm_context *lp_ctx;
  44
  45         if (msg != NULL) {
  46                 return msg;
  47         }
  48
  49         msg_ctx = global_messaging_context();
  50         if (msg_ctx == NULL) {
  51                 smb_panic("global_messaging_context failed\n");
  52         }
  53         myself = messaging_server_id(msg_ctx);
  54
  55         lp_ctx = loadparm_init_s3(NULL, loadparm_s3_helpers());
  56         if (lp_ctx == NULL) {
  57                 smb_panic("Could not load smb.conf to init winbindd's imessaging context.\n");
  58         }
  59
  60         /*
  61          * Note we MUST use the NULL context here, not the autofree context,
  62          * to avoid side effects in forked children exiting.
  63          */
  64         msg = imessaging_init(NULL, lp_ctx, myself, global_event_context());
  65         talloc_unlink(NULL, lp_ctx);
  66
  67         if (msg == NULL) {
  68                 smb_panic("Could not init winbindd's messaging context.\n");
  69         }
  70         return msg;
  71 }
  72
  73 struct wb_irpc_forward_state {
  74         struct irpc_message *msg;
  75         const char *opname;
  76         struct dcesrv_call_state *dce_call;
  77 };
  78
  79 /*
  80   called when the forwarded rpc request is finished
  81  */
  82 static void wb_irpc_forward_callback(struct tevent_req *subreq)
  83 {
  84         struct wb_irpc_forward_state *st =
  85                 tevent_req_callback_data(subreq,
  86                 struct wb_irpc_forward_state);
  87         const char *opname = st->opname;
  88         NTSTATUS status;
  89
  90         status = dcerpc_binding_handle_call_recv(subreq);
  91         TALLOC_FREE(subreq);
  92         if (!NT_STATUS_IS_OK(status)) {
  93                 DEBUG(0,("RPC callback failed for %s - %s\n",
  94                          opname, nt_errstr(status)));
  95                 irpc_send_reply(st->msg, status);
  96                 return;
  97         }
  98
  99         irpc_send_reply(st->msg, status);
 100 }
 101
 102
 103
 104 /**
 105  * Forward a RPC call using IRPC to another task
 106  */
 107
 108 static NTSTATUS wb_irpc_forward_rpc_call(struct irpc_message *msg, TALLOC_CTX *mem_ctx,
 109                                          struct tevent_context *ev,
 110                                          void *r, uint32_t callid,
 111                                          const char *opname,
 112                                          struct winbindd_domain *domain,
 113                                          uint32_t timeout)
 114 {
 115         struct wb_irpc_forward_state *st;
 116         struct dcerpc_binding_handle *binding_handle;
 117         struct tevent_req *subreq;
 118
 119         st = talloc(mem_ctx, struct wb_irpc_forward_state);
 120         if (st == NULL) {
 121                 return NT_STATUS_NO_MEMORY;
 122         }
 123
 124         st->msg = msg;
 125         st->opname   = opname;
 126
 127         binding_handle =  dom_child_handle(domain);
 128         if (binding_handle == NULL) {
 129                 DEBUG(0,("%s: Failed to forward request to winbind handler for %s\n",
 130                          opname, domain->name));
 131                 return NT_STATUS_UNSUCCESSFUL;
 132         }
 133
 134         /* reset timeout for the handle */
 135         dcerpc_binding_handle_set_timeout(binding_handle, timeout);
 136
 137         /* forward the call */
 138         subreq = dcerpc_binding_handle_call_send(st, ev,
 139                                                  binding_handle,
 140                                                  NULL, &ndr_table_winbind,
 141                                                  callid,
 142                                                  msg, r);
 143         if (subreq == NULL) {
 144                 DEBUG(0,("%s: Failed to forward request to winbind handler for %s\n",
 145                          opname, domain->name));
 146                 return NT_STATUS_UNSUCCESSFUL;
 147         }
 148
 149         /* mark the request as replied async */
 150         msg->defer_reply = true;
 151
 152         /* setup the callback */
 153         tevent_req_set_callback(subreq, wb_irpc_forward_callback, st);
 154         return NT_STATUS_OK;
 155 }
 156
 157 static NTSTATUS wb_irpc_DsrUpdateReadOnlyServerDnsRecords(struct irpc_message *msg,
 158                                                    struct winbind_DsrUpdateReadOnlyServerDnsRecords *req)
 159 {
 160         struct winbindd_domain *domain = find_our_domain();
 161         if (domain == NULL) {
 162                 return NT_STATUS_NO_SUCH_DOMAIN;
 163         }
 164
 165         DEBUG(5, ("wb_irpc_DsrUpdateReadOnlyServerDnsRecords called\n"));
 166
 167         return wb_irpc_forward_rpc_call(msg, msg,
 168                                         global_event_context(),
 169                                         req, NDR_WINBIND_DSRUPDATEREADONLYSERVERDNSRECORDS,
 170                                         "winbind_DsrUpdateReadOnlyServerDnsRecords",
 171                                         domain, IRPC_CALL_TIMEOUT);
 172 }
 173
 174 static NTSTATUS wb_irpc_SamLogon(struct irpc_message *msg,
 175                                  struct winbind_SamLogon *req)
 176 {
 177         struct winbindd_domain *domain;
 178         struct netr_IdentityInfo *identity_info;
 179         const char *target_domain_name = NULL;
 180         const char *account_name = NULL;
 181
 182         /*
 183          * Make sure we start with authoritative=true,
 184          * it will only set to false if we don't know the
 185          * domain.
 186          */
 187         req->out.authoritative = true;
 188
 189         switch (req->in.logon_level) {
 190         case NetlogonInteractiveInformation:
 191         case NetlogonServiceInformation:
 192         case NetlogonInteractiveTransitiveInformation:
 193         case NetlogonServiceTransitiveInformation:
 194                 if (req->in.logon.password == NULL) {
 195                         return NT_STATUS_REQUEST_NOT_ACCEPTED;
 196                 }
 197                 identity_info = &req->in.logon.password->identity_info;
 198                 break;
 199
 200         case NetlogonNetworkInformation:
 201         case NetlogonNetworkTransitiveInformation:
 202                 if (req->in.logon.network == NULL) {
 203                         return NT_STATUS_REQUEST_NOT_ACCEPTED;
 204                 }
 205
 206                 identity_info = &req->in.logon.network->identity_info;
 207                 break;
 208
 209         case NetlogonGenericInformation:
 210                 if (req->in.logon.generic == NULL) {
 211                         return NT_STATUS_REQUEST_NOT_ACCEPTED;
 212                 }
 213
 214                 identity_info = &req->in.logon.generic->identity_info;
 215                 break;
 216
 217         default:
 218                 return NT_STATUS_REQUEST_NOT_ACCEPTED;
 219         }
 220
 221         target_domain_name = identity_info->domain_name.string;
 222         if (target_domain_name == NULL) {
 223                 target_domain_name = "";
 224         }
 225
 226         account_name = identity_info->account_name.string;
 227         if (account_name == NULL) {
 228                 account_name = "";
 229         }
 230
 231         if (IS_DC && target_domain_name[0] == '\0') {
 232                 const char *p = NULL;
 233
 234                 p = strchr_m(account_name, '@');
 235                 if (p != NULL) {
 236                         target_domain_name = p + 1;
 237                 }
 238         }
 239
 240         if (IS_DC && target_domain_name[0] == '\0') {
 241                 DBG_ERR("target_domain[%s] account[%s]\n",
 242                         target_domain_name, account_name);
 243                 return NT_STATUS_REQUEST_NOT_ACCEPTED;
 244         }
 245
 246         domain = find_auth_domain(0, target_domain_name);
 247         if (domain == NULL) {
 248                 DBG_INFO("target_domain[%s] for account[%s] not known\n",
 249                         target_domain_name, account_name);
 250                 req->out.result = NT_STATUS_NO_SUCH_USER;
 251                 req->out.authoritative = 0;
 252                 return NT_STATUS_OK;
 253         }
 254
 255         DEBUG(5, ("wb_irpc_SamLogon called\n"));
 256
 257         return wb_irpc_forward_rpc_call(msg, msg,
 258                                         global_event_context(),
 259                                         req, NDR_WINBIND_SAMLOGON,
 260                                         "winbind_SamLogon",
 261                                         domain, IRPC_CALL_TIMEOUT);
 262 }
 263
 264 static NTSTATUS wb_irpc_LogonControl(struct irpc_message *msg,
 265                                      struct winbind_LogonControl *req)
 266 {
 267         TALLOC_CTX *frame = talloc_stackframe();
 268         char *domain_name = NULL;
 269         struct winbindd_domain *domain = NULL;
 270
 271         DEBUG(5, ("wb_irpc_LogonControl called\n"));
 272
 273         switch (req->in.function_code) {
 274         case NETLOGON_CONTROL_REDISCOVER:
 275         case NETLOGON_CONTROL_TC_QUERY:
 276         case NETLOGON_CONTROL_CHANGE_PASSWORD:
 277         case NETLOGON_CONTROL_TC_VERIFY:
 278                 if (req->in.data->domain == NULL) {
 279                         TALLOC_FREE(frame);
 280                         return NT_STATUS_INVALID_PARAMETER;
 281                 }
 282
 283                 domain_name = talloc_strdup(frame, req->in.data->domain);
 284                 if (domain_name == NULL) {
 285                         req->out.result = WERR_NOT_ENOUGH_MEMORY;
 286                         TALLOC_FREE(frame);
 287                         return NT_STATUS_OK;
 288                 }
 289
 290                 break;
 291         default:
 292                 TALLOC_FREE(frame);
 293                 return NT_STATUS_NOT_IMPLEMENTED;
 294         }
 295
 296         if (req->in.function_code == NETLOGON_CONTROL_REDISCOVER) {
 297                 char *p = NULL;
 298
 299                 /*
 300                  * NETLOGON_CONTROL_REDISCOVER
 301                  * gets an optional \dcname appended to the domain name
 302                  */
 303                 p = strchr_m(domain_name, '\\');
 304                 if (p != NULL) {
 305                         *p = '\0';
 306                 }
 307         }
 308
 309         domain = find_domain_from_name_noinit(domain_name);
 310         if (domain == NULL) {
 311                 req->out.result = WERR_NO_SUCH_DOMAIN;
 312                 TALLOC_FREE(frame);
 313                 return NT_STATUS_OK;
 314         }
 315
 316         TALLOC_FREE(frame);
 317         return wb_irpc_forward_rpc_call(msg, msg,
 318                                         global_event_context(),
 319                                         req, NDR_WINBIND_LOGONCONTROL,
 320                                         "winbind_LogonControl",
 321                                         domain, 45 /* timeout */);
 322 }
 323
 324 static NTSTATUS wb_irpc_GetForestTrustInformation(struct irpc_message *msg,
 325                                      struct winbind_GetForestTrustInformation *req)
 326 {
 327         struct winbindd_domain *domain = NULL;
 328
 329         if (req->in.trusted_domain_name == NULL) {
 330                 req->out.result = WERR_NO_SUCH_DOMAIN;
 331                 return NT_STATUS_OK;
 332         }
 333
 334         domain = find_trust_from_name_noinit(req->in.trusted_domain_name);
 335         if (domain == NULL) {
 336                 req->out.result = WERR_NO_SUCH_DOMAIN;
 337                 return NT_STATUS_OK;
 338         }
 339
 340         /*
 341          * checking for domain->internal and domain->primary
 342          * makes sure we only do some work when running as DC.
 343          */
 344
 345         if (domain->internal) {
 346                 req->out.result = WERR_NO_SUCH_DOMAIN;
 347                 return NT_STATUS_OK;
 348         }
 349
 350         if (domain->primary) {
 351                 req->out.result = WERR_NO_SUCH_DOMAIN;
 352                 return NT_STATUS_OK;
 353         }
 354
 355         DEBUG(5, ("wb_irpc_GetForestTrustInformation called\n"));
 356
 357         return wb_irpc_forward_rpc_call(msg, msg,
 358                                         global_event_context(),
 359                                         req, NDR_WINBIND_GETFORESTTRUSTINFORMATION,
 360                                         "winbind_GetForestTrustInformation",
 361                                         domain, 45 /* timeout */);
 362 }
 363
 364 static NTSTATUS wb_irpc_SendToSam(struct irpc_message *msg,
 365                                   struct winbind_SendToSam *req)
 366 {
 367         /* TODO make sure that it is RWDC */
 368         struct winbindd_domain *domain = find_our_domain();
 369         if (domain == NULL) {
 370                 return NT_STATUS_NO_SUCH_DOMAIN;
 371         }
 372
 373         DEBUG(5, ("wb_irpc_SendToSam called\n"));
 374
 375         return wb_irpc_forward_rpc_call(msg, msg,
 376                                         global_event_context(),
 377                                         req, NDR_WINBIND_SENDTOSAM,
 378                                         "winbind_SendToSam",
 379                                         domain, IRPC_CALL_TIMEOUT);
 380 }
 381
 382 struct wb_irpc_lsa_LookupSids3_state {
 383         struct irpc_message *msg;
 384         struct lsa_LookupSids3 *req;
 385 };
 386
 387 static void wb_irpc_lsa_LookupSids3_done(struct tevent_req *subreq);
 388
 389 static NTSTATUS wb_irpc_lsa_LookupSids3_call(struct irpc_message *msg,
 390                                              struct lsa_LookupSids3 *req)
 391 {
 392         struct wb_irpc_lsa_LookupSids3_state *state = NULL;
 393         struct tevent_req *subreq = NULL;
 394         struct dom_sid *sids = NULL;
 395         uint32_t i;
 396
 397         state = talloc_zero(msg, struct wb_irpc_lsa_LookupSids3_state);
 398         if (state == NULL) {
 399                 return NT_STATUS_NO_MEMORY;
 400         }
 401
 402         state->msg = msg;
 403         state->req = req;
 404
 405         state->req->out.domains = talloc_zero(state->msg,
 406                                         struct lsa_RefDomainList *);
 407         if (state->req->out.domains == NULL) {
 408                 return NT_STATUS_NO_MEMORY;
 409         }
 410         state->req->out.names = talloc_zero(state->msg,
 411                                             struct lsa_TransNameArray2);
 412         if (state->req->out.names == NULL) {
 413                 return NT_STATUS_NO_MEMORY;
 414         }
 415         state->req->out.count = talloc_zero(state->msg, uint32_t);
 416         if (state->req->out.count == NULL) {
 417                 return NT_STATUS_NO_MEMORY;
 418         }
 419
 420         state->req->out.names->names = talloc_zero_array(state->msg,
 421                                                 struct lsa_TranslatedName2,
 422                                                 req->in.sids->num_sids);
 423         if (state->req->out.names->names == NULL) {
 424                 return NT_STATUS_NO_MEMORY;
 425         }
 426
 427         sids = talloc_zero_array(state, struct dom_sid,
 428                                  req->in.sids->num_sids);
 429         if (sids == NULL) {
 430                 return NT_STATUS_NO_MEMORY;
 431         }
 432
 433         for (i = 0; i < req->in.sids->num_sids; i++) {
 434                 if (req->in.sids->sids[i].sid == NULL) {
 435                         return NT_STATUS_REQUEST_NOT_ACCEPTED;
 436                 }
 437
 438                 sids[i] = *req->in.sids->sids[i].sid;
 439         }
 440
 441         subreq = wb_lookupsids_send(msg,
 442                                     global_event_context(),
 443                                     sids, req->in.sids->num_sids);
 444         if (subreq == NULL) {
 445                 return NT_STATUS_NO_MEMORY;
 446         }
 447         tevent_req_set_callback(subreq, wb_irpc_lsa_LookupSids3_done, state);
 448         msg->defer_reply = true;
 449
 450         return NT_STATUS_OK;
 451 }
 452
 453 static void wb_irpc_lsa_LookupSids3_done(struct tevent_req *subreq)
 454 {
 455         struct wb_irpc_lsa_LookupSids3_state *state =
 456                 tevent_req_callback_data(subreq,
 457                 struct wb_irpc_lsa_LookupSids3_state);
 458         struct lsa_RefDomainList *domains = NULL;
 459         struct lsa_TransNameArray *names = NULL;
 460         NTSTATUS status;
 461         uint32_t i;
 462
 463         status = wb_lookupsids_recv(subreq, state->msg,
 464                                     &domains, &names);
 465         TALLOC_FREE(subreq);
 466         if (!NT_STATUS_IS_OK(status)) {
 467                 DEBUG(0,("RPC callback failed for %s - %s\n",
 468                          __func__, nt_errstr(status)));
 469                 irpc_send_reply(state->msg, status);
 470                 return;
 471         }
 472
 473         if (names->count > state->req->in.sids->num_sids) {
 474                 status = NT_STATUS_INTERNAL_ERROR;
 475                 DEBUG(0,("RPC callback failed for %s - %s\n",
 476                          __func__, nt_errstr(status)));
 477                 irpc_send_reply(state->msg, status);
 478                 return;
 479         }
 480
 481         *state->req->out.domains = domains;
 482         for (i = 0; i < names->count; i++) {
 483                 struct lsa_TranslatedName2 *n2 =
 484                         &state->req->out.names->names[i];
 485
 486                 n2->sid_type = names->names[i].sid_type;
 487                 n2->name = names->names[i].name;
 488                 n2->sid_index = names->names[i].sid_index;
 489                 n2->unknown = 0;
 490
 491                 if (n2->sid_type != SID_NAME_UNKNOWN) {
 492                         (*state->req->out.count)++;
 493                 }
 494         }
 495         state->req->out.names->count = names->count;
 496
 497         if (*state->req->out.count == 0) {
 498                 state->req->out.result = NT_STATUS_NONE_MAPPED;
 499         } else if (*state->req->out.count != names->count) {
 500                 state->req->out.result = NT_STATUS_SOME_NOT_MAPPED;
 501         } else {
 502                 state->req->out.result = NT_STATUS_OK;
 503         }
 504
 505         irpc_send_reply(state->msg, NT_STATUS_OK);
 506         return;
 507 }
 508
 509 struct wb_irpc_lsa_LookupNames4_name {
 510         void *state;
 511         uint32_t idx;
 512         const char *namespace;
 513         const char *domain;
 514         char *name;
 515         struct dom_sid sid;
 516         enum lsa_SidType type;
 517         struct dom_sid *authority_sid;
 518 };
 519
 520 struct wb_irpc_lsa_LookupNames4_state {
 521         struct irpc_message *msg;
 522         struct lsa_LookupNames4 *req;
 523         struct wb_irpc_lsa_LookupNames4_name *names;
 524         uint32_t num_pending;
 525         uint32_t num_domain_sids;
 526         struct dom_sid *domain_sids;
 527 };
 528
 529 static void wb_irpc_lsa_LookupNames4_done(struct tevent_req *subreq);
 530
 531 static NTSTATUS wb_irpc_lsa_LookupNames4_call(struct irpc_message *msg,
 532                                               struct lsa_LookupNames4 *req)
 533 {
 534         struct wb_irpc_lsa_LookupNames4_state *state = NULL;
 535         struct tevent_req *subreq = NULL;
 536         uint32_t i;
 537
 538
 539         state = talloc_zero(msg, struct wb_irpc_lsa_LookupNames4_state);
 540         if (state == NULL) {
 541                 return NT_STATUS_NO_MEMORY;
 542         }
 543
 544         state->msg = msg;
 545         state->req = req;
 546
 547         state->req->out.domains = talloc_zero(state->msg,
 548                                         struct lsa_RefDomainList *);
 549         if (state->req->out.domains == NULL) {
 550                 return NT_STATUS_NO_MEMORY;
 551         }
 552         state->req->out.sids = talloc_zero(state->msg,
 553                                            struct lsa_TransSidArray3);
 554         if (state->req->out.sids == NULL) {
 555                 return NT_STATUS_NO_MEMORY;
 556         }
 557         state->req->out.count = talloc_zero(state->msg, uint32_t);
 558         if (state->req->out.count == NULL) {
 559                 return NT_STATUS_NO_MEMORY;
 560         }
 561
 562         state->req->out.sids->sids = talloc_zero_array(state->msg,
 563                                                 struct lsa_TranslatedSid3,
 564                                                 req->in.num_names);
 565         if (state->req->out.sids->sids == NULL) {
 566                 return NT_STATUS_NO_MEMORY;
 567         }
 568
 569         state->names = talloc_zero_array(state,
 570                                          struct wb_irpc_lsa_LookupNames4_name,
 571                                          req->in.num_names);
 572         if (state->names == NULL) {
 573                 return NT_STATUS_NO_MEMORY;
 574         }
 575
 576         for (i = 0; i < req->in.num_names; i++) {
 577                 struct wb_irpc_lsa_LookupNames4_name *nstate =
 578                         &state->names[i];
 579                 char *p = NULL;
 580
 581                 if (req->in.names[i].string == NULL) {
 582                         DBG_ERR("%s: name[%s] NT_STATUS_REQUEST_NOT_ACCEPTED.\n",
 583                                 __location__, req->in.names[i].string);
 584                         return NT_STATUS_REQUEST_NOT_ACCEPTED;
 585                 }
 586                 nstate->state = state;
 587                 nstate->idx = i;
 588                 nstate->name = talloc_strdup(state->names,
 589                                              req->in.names[i].string);
 590                 if (nstate->name == NULL) {
 591                         return NT_STATUS_NO_MEMORY;
 592                 }
 593                 nstate->type = SID_NAME_UNKNOWN;
 594
 595                 /* cope with the name being a fully qualified name */
 596                 p = strchr(nstate->name, '\\');
 597                 if (p != NULL) {
 598                         *p = 0;
 599                         nstate->domain = nstate->name;
 600                         nstate->namespace = nstate->domain;
 601                         nstate->name = p+1;
 602                 } else if ((p = strchr(nstate->name, '@')) != NULL) {
 603                         /* upn */
 604                         nstate->domain = "";
 605                         nstate->namespace = p + 1;
 606                 } else {
 607                         /*
 608                          * TODO: select the domain based on
 609                          * req->in.level and req->in.client_revision
 610                          *
 611                          * For now we don't allow this.
 612                          */
 613                         DBG_ERR("%s: name[%s] NT_STATUS_REQUEST_NOT_ACCEPTED.\n",
 614                                 __location__, nstate->name);
 615                         return NT_STATUS_REQUEST_NOT_ACCEPTED;
 616                 }
 617
 618                 subreq = wb_lookupname_send(msg,
 619                                             global_event_context(),
 620                                             nstate->namespace,
 621                                             nstate->domain,
 622                                             nstate->name,
 623                                             LOOKUP_NAME_NO_NSS);
 624                 if (subreq == NULL) {
 625                         return NT_STATUS_NO_MEMORY;
 626                 }
 627                 tevent_req_set_callback(subreq,
 628                                         wb_irpc_lsa_LookupNames4_done,
 629                                         nstate);
 630                 state->num_pending++;
 631         }
 632
 633         msg->defer_reply = true;
 634
 635         return NT_STATUS_OK;
 636 }
 637
 638 static void wb_irpc_lsa_LookupNames4_domains_done(struct tevent_req *subreq);
 639
 640 static void wb_irpc_lsa_LookupNames4_done(struct tevent_req *subreq)
 641 {
 642         struct wb_irpc_lsa_LookupNames4_name *nstate =
 643                 (struct wb_irpc_lsa_LookupNames4_name *)
 644                 tevent_req_callback_data_void(subreq);
 645         struct wb_irpc_lsa_LookupNames4_state *state =
 646                 talloc_get_type_abort(nstate->state,
 647                 struct wb_irpc_lsa_LookupNames4_state);
 648         struct dom_sid_buf buf;
 649         NTSTATUS status;
 650
 651         SMB_ASSERT(state->num_pending > 0);
 652         state->num_pending--;
 653         status = wb_lookupname_recv(subreq, &nstate->sid, &nstate->type);
 654         TALLOC_FREE(subreq);
 655         if (NT_STATUS_IS_OK(status) && nstate->type == SID_NAME_UNKNOWN) {
 656                 status = NT_STATUS_NONE_MAPPED;
 657         }
 658         if (!NT_STATUS_IS_OK(status)) {
 659                 DEBUG(0,("RPC callback failed for %s - %s\n",
 660                          __func__, nt_errstr(status)));
 661                 irpc_send_reply(state->msg, status);
 662                 return;
 663         }
 664
 665         status = dom_sid_split_rid(state, &nstate->sid,
 666                                    &nstate->authority_sid, NULL);
 667         if (!NT_STATUS_IS_OK(status)) {
 668                 DBG_ERR("dom_sid_split_rid(%s) failed - %s\n",
 669                         dom_sid_str_buf(&nstate->sid, &buf),
 670                         nt_errstr(status));
 671                 irpc_send_reply(state->msg, status);
 672                 return;
 673         }
 674
 675         status = add_sid_to_array_unique(state,
 676                                          nstate->authority_sid,
 677                                          &state->domain_sids,
 678                                          &state->num_domain_sids);
 679         if (!NT_STATUS_IS_OK(status)) {
 680                 DBG_ERR("add_sid_to_array_unique(%s) failed - %s\n",
 681                         dom_sid_str_buf(nstate->authority_sid, &buf),
 682                         nt_errstr(status));
 683                 irpc_send_reply(state->msg, status);
 684                 return;
 685         }
 686
 687         if (state->num_pending > 0) {
 688                 /*
 689                  * wait for more...
 690                  */
 691                 return;
 692         }
 693
 694         /*
 695          * Now resolve all domains back to a name
 696          * to get a good lsa_RefDomainList
 697          */
 698         subreq = wb_lookupsids_send(state,
 699                                     global_event_context(),
 700                                     state->domain_sids,
 701                                     state->num_domain_sids);
 702         if (subreq == NULL) {
 703                 status = NT_STATUS_NO_MEMORY;
 704                 DBG_ERR("wb_lookupsids_send - %s\n",
 705                         nt_errstr(status));
 706                 irpc_send_reply(state->msg, status);
 707                 return;
 708         }
 709         tevent_req_set_callback(subreq,
 710                                 wb_irpc_lsa_LookupNames4_domains_done,
 711                                 state);
 712
 713         return;
 714 }
 715
 716 static void wb_irpc_lsa_LookupNames4_domains_done(struct tevent_req *subreq)
 717 {
 718         struct wb_irpc_lsa_LookupNames4_state *state =
 719                 tevent_req_callback_data(subreq,
 720                 struct wb_irpc_lsa_LookupNames4_state);
 721         struct lsa_RefDomainList *domains = NULL;
 722         struct lsa_TransNameArray *names = NULL;
 723         NTSTATUS status;
 724         uint32_t i;
 725
 726         status = wb_lookupsids_recv(subreq, state->msg,
 727                                     &domains, &names);
 728         TALLOC_FREE(subreq);
 729         if (!NT_STATUS_IS_OK(status)) {
 730                 DEBUG(0,("RPC callback failed for %s - %s\n",
 731                          __func__, nt_errstr(status)));
 732                 irpc_send_reply(state->msg, status);
 733                 return;
 734         }
 735
 736         *state->req->out.domains = domains;
 737         for (i = 0; i < state->req->in.num_names; i++) {
 738                 struct wb_irpc_lsa_LookupNames4_name *nstate =
 739                         &state->names[i];
 740                 struct lsa_TranslatedSid3 *s3 =
 741                         &state->req->out.sids->sids[i];
 742                 uint32_t di;
 743
 744                 s3->sid_type = nstate->type;
 745                 if (s3->sid_type != SID_NAME_UNKNOWN) {
 746                         s3->sid = &nstate->sid;
 747                 } else {
 748                         s3->sid = NULL;
 749                 }
 750                 s3->sid_index = UINT32_MAX;
 751                 for (di = 0; di < domains->count; di++) {
 752                         bool match;
 753
 754                         if (domains->domains[di].sid == NULL) {
 755                                 continue;
 756                         }
 757
 758                         match = dom_sid_equal(nstate->authority_sid,
 759                                               domains->domains[di].sid);
 760                         if (match) {
 761                                 s3->sid_index = di;
 762                                 break;
 763                         }
 764                 }
 765                 if (s3->sid_type != SID_NAME_UNKNOWN) {
 766                         (*state->req->out.count)++;
 767                 }
 768         }
 769         state->req->out.sids->count = state->req->in.num_names;
 770
 771         if (*state->req->out.count == 0) {
 772                 state->req->out.result = NT_STATUS_NONE_MAPPED;
 773         } else if (*state->req->out.count != state->req->in.num_names) {
 774                 state->req->out.result = NT_STATUS_SOME_NOT_MAPPED;
 775         } else {
 776                 state->req->out.result = NT_STATUS_OK;
 777         }
 778
 779         irpc_send_reply(state->msg, NT_STATUS_OK);
 780         return;
 781 }
 782
 783 struct wb_irpc_GetDCName_state {
 784         struct irpc_message *msg;
 785         struct wbint_DsGetDcName *req;
 786 };
 787
 788 static void wb_irpc_GetDCName_done(struct tevent_req *subreq);
 789
 790 static NTSTATUS wb_irpc_GetDCName(struct irpc_message *msg,
 791                                   struct wbint_DsGetDcName *req)
 792 {
 793
 794         struct tevent_req *subreq = NULL;
 795         struct wb_irpc_GetDCName_state *state = NULL;
 796
 797         state = talloc_zero(msg, struct wb_irpc_GetDCName_state);
 798         if (state == NULL) {
 799                 return NT_STATUS_NO_MEMORY;
 800         }
 801
 802         state->msg = msg;
 803         state->req = req;
 804
 805         subreq = wb_dsgetdcname_send(msg,
 806                                      global_event_context(),
 807                                      req->in.domain_name,
 808                                      req->in.domain_guid,
 809                                      req->in.site_name,
 810                                      req->in.flags);
 811         if (subreq == NULL) {
 812                 return NT_STATUS_NO_MEMORY;
 813         }
 814
 815         tevent_req_set_callback(subreq,
 816                                 wb_irpc_GetDCName_done,
 817                                 state);
 818
 819         msg->defer_reply = true;
 820
 821         return NT_STATUS_OK;
 822 }
 823
 824 static void wb_irpc_GetDCName_done(struct tevent_req *subreq)
 825 {
 826         struct wb_irpc_GetDCName_state *state = tevent_req_callback_data(
 827                 subreq, struct wb_irpc_GetDCName_state);
 828         NTSTATUS status;
 829
 830         status = wb_dsgetdcname_recv(subreq, state->msg,
 831                                      state->req->out.dc_info);
 832         TALLOC_FREE(subreq);
 833         if (!NT_STATUS_IS_OK(status)) {
 834                 DBG_INFO("RPC callback failed for %s - %s\n", "DSGETDCNAME",
 835                          nt_errstr(status));
 836         }
 837
 838         state->req->out.result = status;
 839
 840         irpc_send_reply(state->msg, NT_STATUS_OK);
 841 }
 842
 843 NTSTATUS wb_irpc_register(void)
 844 {
 845         NTSTATUS status;
 846
 847         status = IRPC_REGISTER(winbind_imessaging_context(), winbind, WINBIND_DSRUPDATEREADONLYSERVERDNSRECORDS,
 848                                wb_irpc_DsrUpdateReadOnlyServerDnsRecords, NULL);
 849         if (!NT_STATUS_IS_OK(status)) {
 850                 return status;
 851         }
 852         status = IRPC_REGISTER(winbind_imessaging_context(), winbind, WINBIND_SAMLOGON,
 853                                wb_irpc_SamLogon, NULL);
 854         if (!NT_STATUS_IS_OK(status)) {
 855                 return status;
 856         }
 857         status = IRPC_REGISTER(winbind_imessaging_context(), winbind,
 858                                WINBIND_LOGONCONTROL,
 859                                wb_irpc_LogonControl, NULL);
 860         if (!NT_STATUS_IS_OK(status)) {
 861                 return status;
 862         }
 863         status = IRPC_REGISTER(winbind_imessaging_context(), winbind,
 864                                WINBIND_GETFORESTTRUSTINFORMATION,
 865                                wb_irpc_GetForestTrustInformation, NULL);
 866         if (!NT_STATUS_IS_OK(status)) {
 867                 return status;
 868         }
 869         status = IRPC_REGISTER(winbind_imessaging_context(), winbind, WINBIND_SENDTOSAM,
 870                                wb_irpc_SendToSam, NULL);
 871         if (!NT_STATUS_IS_OK(status)) {
 872                 return status;
 873         }
 874         status = IRPC_REGISTER(winbind_imessaging_context(),
 875                                lsarpc, LSA_LOOKUPSIDS3,
 876                                wb_irpc_lsa_LookupSids3_call, NULL);
 877         if (!NT_STATUS_IS_OK(status)) {
 878                 return status;
 879         }
 880         status = IRPC_REGISTER(winbind_imessaging_context(),
 881                                lsarpc, LSA_LOOKUPNAMES4,
 882                                wb_irpc_lsa_LookupNames4_call, NULL);
 883         if (!NT_STATUS_IS_OK(status)) {
 884                 return status;
 885         }
 886         status = IRPC_REGISTER(winbind_imessaging_context(),
 887                                winbind, WBINT_DSGETDCNAME,
 888                                wb_irpc_GetDCName, NULL);
 889         if (!NT_STATUS_IS_OK(status)) {
 890                 return status;
 891         }
 892
 893         return NT_STATUS_OK;
 894 }