source/winbind/wb_samba3_cmd.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    Main winbindd samba3 server routines
   4
   5    Copyright (C) Stefan Metzmacher      2005
   6    Copyright (C) Volker Lendecke        2005
   7    Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
   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 2 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, write to the Free Software
  21    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  22 */
  23
  24 #include "includes.h"
  25 #include "nsswitch/winbind_nss_config.h"
  26 #include "nsswitch/winbindd_nss.h"
  27 #include "winbind/wb_server.h"
  28 #include "winbind/wb_async_helpers.h"
  29 #include "libcli/composite/composite.h"
  30 #include "version.h"
  31 #include "librpc/gen_ndr/netlogon.h"
  32 #include "libcli/security/security.h"
  33 #include "auth/pam_errors.h"
  34
  35 /*
  36    Send off the reply to an async Samba3 query, handling filling in the PAM, NTSTATUS and string errors.
  37 */
  38
  39 static void wbsrv_samba3_async_auth_epilogue(NTSTATUS status,
  40                                              struct wbsrv_samba3_call *s3call)
  41 {
  42         struct winbindd_response *resp = &s3call->response;
  43         if (!NT_STATUS_IS_OK(status)) {
  44                 resp->result = WINBINDD_ERROR;
  45                 WBSRV_SAMBA3_SET_STRING(resp->data.auth.nt_status_string,
  46                                         nt_errstr(status));
  47                 WBSRV_SAMBA3_SET_STRING(resp->data.auth.error_string,
  48                                         get_friendly_nt_error_msg(status));
  49         } else {
  50                 resp->result = WINBINDD_OK;
  51         }
  52
  53         resp->data.auth.pam_error = nt_status_to_pam(status);
  54         resp->data.auth.nt_status = NT_STATUS_V(status);
  55
  56         wbsrv_samba3_send_reply(s3call);
  57 }
  58
  59 /*
  60    Send of a generic reply to a Samba3 query
  61 */
  62
  63 static void wbsrv_samba3_async_epilogue(NTSTATUS status,
  64                                         struct wbsrv_samba3_call *s3call)
  65 {
  66         struct winbindd_response *resp = &s3call->response;
  67         if (NT_STATUS_IS_OK(status)) {
  68                 resp->result = WINBINDD_OK;
  69         } else {
  70                 resp->result = WINBINDD_ERROR;
  71         }
  72
  73         wbsrv_samba3_send_reply(s3call);
  74 }
  75
  76 /*
  77    Boilerplate commands, simple queries without network traffic
  78 */
  79
  80 NTSTATUS wbsrv_samba3_interface_version(struct wbsrv_samba3_call *s3call)
  81 {
  82         s3call->response.result                 = WINBINDD_OK;
  83         s3call->response.data.interface_version = WINBIND_INTERFACE_VERSION;
  84         return NT_STATUS_OK;
  85 }
  86
  87 NTSTATUS wbsrv_samba3_info(struct wbsrv_samba3_call *s3call)
  88 {
  89         s3call->response.result                 = WINBINDD_OK;
  90         s3call->response.data.info.winbind_separator = *lp_winbind_separator();
  91         WBSRV_SAMBA3_SET_STRING(s3call->response.data.info.samba_version,
  92                                 SAMBA_VERSION_STRING);
  93         return NT_STATUS_OK;
  94 }
  95
  96 NTSTATUS wbsrv_samba3_domain_name(struct wbsrv_samba3_call *s3call)
  97 {
  98         s3call->response.result                 = WINBINDD_OK;
  99         WBSRV_SAMBA3_SET_STRING(s3call->response.data.domain_name,
 100                                 lp_workgroup());
 101         return NT_STATUS_OK;
 102 }
 103
 104 NTSTATUS wbsrv_samba3_netbios_name(struct wbsrv_samba3_call *s3call)
 105 {
 106         s3call->response.result                 = WINBINDD_OK;
 107         WBSRV_SAMBA3_SET_STRING(s3call->response.data.netbios_name,
 108                                 lp_netbios_name());
 109         return NT_STATUS_OK;
 110 }
 111
 112 NTSTATUS wbsrv_samba3_priv_pipe_dir(struct wbsrv_samba3_call *s3call)
 113 {
 114         s3call->response.result                 = WINBINDD_OK;
 115         s3call->response.extra_data.data =
 116                 smbd_tmp_path(s3call, WINBINDD_SAMBA3_PRIVILEGED_SOCKET);
 117         NT_STATUS_HAVE_NO_MEMORY(s3call->response.extra_data.data);
 118         return NT_STATUS_OK;
 119 }
 120
 121 NTSTATUS wbsrv_samba3_ping(struct wbsrv_samba3_call *s3call)
 122 {
 123         s3call->response.result                 = WINBINDD_OK;
 124         return NT_STATUS_OK;
 125 }
 126
 127 #if 0
 128 /*
 129    Validate that we have a working pipe to the domain controller.
 130    Return any NT error found in the process
 131 */
 132
 133 static void checkmachacc_recv_creds(struct composite_context *ctx);
 134
 135 NTSTATUS wbsrv_samba3_check_machacc(struct wbsrv_samba3_call *s3call)
 136 {
 137         struct composite_context *ctx;
 138
 139         DEBUG(5, ("wbsrv_samba3_check_machacc called\n"));
 140
 141         ctx = wb_cmd_checkmachacc_send(s3call->call);
 142         NT_STATUS_HAVE_NO_MEMORY(ctx);
 143
 144         ctx->async.fn = checkmachacc_recv_creds;
 145         ctx->async.private_data = s3call;
 146         s3call->call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 147         return NT_STATUS_OK;
 148 }
 149
 150 static void checkmachacc_recv_creds(struct composite_context *ctx)
 151 {
 152         struct wbsrv_samba3_call *s3call =
 153                 talloc_get_type(ctx->async.private_data,
 154                                 struct wbsrv_samba3_call);
 155         NTSTATUS status;
 156
 157         status = wb_cmd_checkmachacc_recv(ctx);
 158
 159         wbsrv_samba3_async_auth_epilogue(status, s3call);
 160 }
 161 #endif
 162
 163 /*
 164   Find the name of a suitable domain controller, by query on the
 165   netlogon pipe to the DC.
 166 */
 167
 168 static void getdcname_recv_dc(struct composite_context *ctx);
 169
 170 NTSTATUS wbsrv_samba3_getdcname(struct wbsrv_samba3_call *s3call)
 171 {
 172         struct composite_context *ctx;
 173         struct wbsrv_service *service =
 174                 s3call->wbconn->listen_socket->service;
 175
 176         DEBUG(5, ("wbsrv_samba3_getdcname called\n"));
 177
 178         ctx = wb_cmd_getdcname_send(s3call, service,
 179                                     s3call->request.domain_name);
 180         NT_STATUS_HAVE_NO_MEMORY(ctx);
 181
 182         ctx->async.fn = getdcname_recv_dc;
 183         ctx->async.private_data = s3call;
 184         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 185         return NT_STATUS_OK;
 186 }
 187
 188 static void getdcname_recv_dc(struct composite_context *ctx)
 189 {
 190         struct wbsrv_samba3_call *s3call =
 191                 talloc_get_type(ctx->async.private_data,
 192                                 struct wbsrv_samba3_call);
 193         const char *dcname;
 194         NTSTATUS status;
 195
 196         status = wb_cmd_getdcname_recv(ctx, s3call, &dcname);
 197         if (!NT_STATUS_IS_OK(status)) goto done;
 198
 199         s3call->response.result = WINBINDD_OK;
 200         WBSRV_SAMBA3_SET_STRING(s3call->response.data.dc_name, dcname);
 201
 202  done:
 203         wbsrv_samba3_async_epilogue(status, s3call);
 204 }
 205
 206 /*
 207    Lookup a user's domain groups
 208 */
 209
 210 static void userdomgroups_recv_groups(struct composite_context *ctx);
 211
 212 NTSTATUS wbsrv_samba3_userdomgroups(struct wbsrv_samba3_call *s3call)
 213 {
 214         struct composite_context *ctx;
 215         struct dom_sid *sid;
 216
 217         DEBUG(5, ("wbsrv_samba3_userdomgroups called\n"));
 218
 219         sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
 220         if (sid == NULL) {
 221                 DEBUG(5, ("Could not parse sid %s\n",
 222                           s3call->request.data.sid));
 223                 return NT_STATUS_NO_MEMORY;
 224         }
 225
 226         ctx = wb_cmd_userdomgroups_send(
 227                 s3call, s3call->wbconn->listen_socket->service, sid);
 228         NT_STATUS_HAVE_NO_MEMORY(ctx);
 229
 230         ctx->async.fn = userdomgroups_recv_groups;
 231         ctx->async.private_data = s3call;
 232         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 233         return NT_STATUS_OK;
 234 }
 235
 236 static void userdomgroups_recv_groups(struct composite_context *ctx)
 237 {
 238         struct wbsrv_samba3_call *s3call =
 239                 talloc_get_type(ctx->async.private_data,
 240                                 struct wbsrv_samba3_call);
 241         int i, num_sids;
 242         struct dom_sid **sids;
 243         char *sids_string;
 244         NTSTATUS status;
 245
 246         status = wb_cmd_userdomgroups_recv(ctx, s3call, &num_sids, &sids);
 247         if (!NT_STATUS_IS_OK(status)) goto done;
 248
 249         sids_string = talloc_strdup(s3call, "");
 250         if (sids_string == NULL) {
 251                 status = NT_STATUS_NO_MEMORY;
 252                 goto done;
 253         }
 254
 255         for (i=0; i<num_sids; i++) {
 256                 sids_string = talloc_asprintf_append(
 257                         sids_string, "%s\n", dom_sid_string(s3call, sids[i]));
 258         }
 259
 260         if (sids_string == NULL) {
 261                 status = NT_STATUS_NO_MEMORY;
 262                 goto done;
 263         }
 264
 265         s3call->response.result = WINBINDD_OK;
 266         s3call->response.extra_data.data = sids_string;
 267         s3call->response.length += strlen(sids_string)+1;
 268         s3call->response.data.num_entries = num_sids;
 269
 270  done:
 271         wbsrv_samba3_async_epilogue(status, s3call);
 272 }
 273
 274 /*
 275    Lookup the list of SIDs for a user
 276 */
 277 static void usersids_recv_sids(struct composite_context *ctx);
 278
 279 NTSTATUS wbsrv_samba3_usersids(struct wbsrv_samba3_call *s3call)
 280 {
 281         struct composite_context *ctx;
 282         struct dom_sid *sid;
 283
 284         DEBUG(5, ("wbsrv_samba3_usersids called\n"));
 285
 286         sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
 287         if (sid == NULL) {
 288                 DEBUG(5, ("Could not parse sid %s\n",
 289                           s3call->request.data.sid));
 290                 return NT_STATUS_NO_MEMORY;
 291         }
 292
 293         ctx = wb_cmd_usersids_send(
 294                 s3call, s3call->wbconn->listen_socket->service, sid);
 295         NT_STATUS_HAVE_NO_MEMORY(ctx);
 296
 297         ctx->async.fn = usersids_recv_sids;
 298         ctx->async.private_data = s3call;
 299         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 300         return NT_STATUS_OK;
 301 }
 302
 303 static void usersids_recv_sids(struct composite_context *ctx)
 304 {
 305         struct wbsrv_samba3_call *s3call =
 306                 talloc_get_type(ctx->async.private_data,
 307                                 struct wbsrv_samba3_call);
 308         int i, num_sids;
 309         struct dom_sid **sids;
 310         char *sids_string;
 311         NTSTATUS status;
 312
 313         status = wb_cmd_usersids_recv(ctx, s3call, &num_sids, &sids);
 314         if (!NT_STATUS_IS_OK(status)) goto done;
 315
 316         sids_string = talloc_strdup(s3call, "");
 317         if (sids_string == NULL) {
 318                 status = NT_STATUS_NO_MEMORY;
 319                 goto done;
 320         }
 321
 322         for (i=0; i<num_sids; i++) {
 323                 sids_string = talloc_asprintf_append(
 324                         sids_string, "%s\n", dom_sid_string(s3call, sids[i]));
 325                 if (sids_string == NULL) {
 326                         status = NT_STATUS_NO_MEMORY;
 327                         goto done;
 328                 }
 329         }
 330
 331         s3call->response.result = WINBINDD_OK;
 332         s3call->response.extra_data.data = sids_string;
 333         s3call->response.length += strlen(sids_string);
 334         s3call->response.data.num_entries = num_sids;
 335
 336         /* Hmmmm. Nasty protocol -- who invented the zeros between the
 337          * SIDs? Hmmm. Could have been me -- vl */
 338
 339         while (*sids_string != '\0') {
 340                 if ((*sids_string) == '\n') {
 341                         *sids_string = '\0';
 342                 }
 343                 sids_string += 1;
 344         }
 345
 346  done:
 347         wbsrv_samba3_async_epilogue(status, s3call);
 348 }
 349
 350 /*
 351    Lookup a DOMAIN\\user style name, and return a SID
 352 */
 353
 354 static void lookupname_recv_sid(struct composite_context *ctx);
 355
 356 NTSTATUS wbsrv_samba3_lookupname(struct wbsrv_samba3_call *s3call)
 357 {
 358         struct composite_context *ctx;
 359         struct wbsrv_service *service =
 360                 s3call->wbconn->listen_socket->service;
 361
 362         DEBUG(5, ("wbsrv_samba3_lookupname called\n"));
 363
 364         ctx = wb_cmd_lookupname_send(s3call, service,
 365                                      s3call->request.data.name.dom_name,
 366                                      s3call->request.data.name.name);
 367         NT_STATUS_HAVE_NO_MEMORY(ctx);
 368
 369         /* setup the callbacks */
 370         ctx->async.fn = lookupname_recv_sid;
 371         ctx->async.private_data = s3call;
 372         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 373         return NT_STATUS_OK;
 374 }
 375
 376 static void lookupname_recv_sid(struct composite_context *ctx)
 377 {
 378         struct wbsrv_samba3_call *s3call =
 379                 talloc_get_type(ctx->async.private_data,
 380                                 struct wbsrv_samba3_call);
 381         struct wb_sid_object *sid;
 382         NTSTATUS status;
 383
 384         status = wb_cmd_lookupname_recv(ctx, s3call, &sid);
 385         if (!NT_STATUS_IS_OK(status)) goto done;
 386
 387         s3call->response.result = WINBINDD_OK;
 388         s3call->response.data.sid.type = sid->type;
 389         WBSRV_SAMBA3_SET_STRING(s3call->response.data.sid.sid,
 390                                 dom_sid_string(s3call, sid->sid));
 391
 392  done:
 393         wbsrv_samba3_async_epilogue(status, s3call);
 394 }
 395
 396 /*
 397    Lookup a SID, and return a DOMAIN\\user style name
 398 */
 399
 400 static void lookupsid_recv_name(struct composite_context *ctx);
 401
 402 NTSTATUS wbsrv_samba3_lookupsid(struct wbsrv_samba3_call *s3call)
 403 {
 404         struct composite_context *ctx;
 405         struct wbsrv_service *service =
 406                 s3call->wbconn->listen_socket->service;
 407         struct dom_sid *sid;
 408
 409         DEBUG(5, ("wbsrv_samba3_lookupsid called\n"));
 410
 411         sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
 412         if (sid == NULL) {
 413                 DEBUG(5, ("Could not parse sid %s\n",
 414                           s3call->request.data.sid));
 415                 return NT_STATUS_NO_MEMORY;
 416         }
 417
 418         ctx = wb_cmd_lookupsid_send(s3call, service, sid);
 419         NT_STATUS_HAVE_NO_MEMORY(ctx);
 420
 421         /* setup the callbacks */
 422         ctx->async.fn = lookupsid_recv_name;
 423         ctx->async.private_data = s3call;
 424         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 425         return NT_STATUS_OK;
 426 }
 427
 428 static void lookupsid_recv_name(struct composite_context *ctx)
 429 {
 430         struct wbsrv_samba3_call *s3call =
 431                 talloc_get_type(ctx->async.private_data,
 432                                 struct wbsrv_samba3_call);
 433         struct wb_sid_object *sid;
 434         NTSTATUS status;
 435
 436         status = wb_cmd_lookupsid_recv(ctx, s3call, &sid);
 437         if (!NT_STATUS_IS_OK(status)) goto done;
 438
 439         s3call->response.result = WINBINDD_OK;
 440         s3call->response.data.name.type = sid->type;
 441         WBSRV_SAMBA3_SET_STRING(s3call->response.data.name.dom_name,
 442                                 sid->domain);
 443         WBSRV_SAMBA3_SET_STRING(s3call->response.data.name.name, sid->name);
 444
 445  done:
 446         wbsrv_samba3_async_epilogue(status, s3call);
 447 }
 448
 449 /*
 450   Challenge-response authentication.  This interface is used by
 451   ntlm_auth and the smbd auth subsystem to pass NTLM authentication
 452   requests along a common pipe to the domain controller.
 453
 454   The return value (in the async reply) may include the 'info3'
 455   (effectivly most things you would want to know about the user), or
 456   the NT and LM session keys seperated.
 457 */
 458
 459 static void pam_auth_crap_recv(struct composite_context *ctx);
 460
 461 NTSTATUS wbsrv_samba3_pam_auth_crap(struct wbsrv_samba3_call *s3call)
 462 {
 463         struct composite_context *ctx;
 464         struct wbsrv_service *service =
 465                 s3call->wbconn->listen_socket->service;
 466         DATA_BLOB chal, nt_resp, lm_resp;
 467
 468         DEBUG(5, ("wbsrv_samba3_pam_auth_crap called\n"));
 469
 470         chal.data       = s3call->request.data.auth_crap.chal;
 471         chal.length     = sizeof(s3call->request.data.auth_crap.chal);
 472         nt_resp.data    = (uint8_t *)s3call->request.data.auth_crap.nt_resp;
 473         nt_resp.length  = s3call->request.data.auth_crap.nt_resp_len;
 474         lm_resp.data    = (uint8_t *)s3call->request.data.auth_crap.lm_resp;
 475         lm_resp.length  = s3call->request.data.auth_crap.lm_resp_len;
 476
 477         ctx = wb_cmd_pam_auth_crap_send(
 478                 s3call, service,
 479                 s3call->request.data.auth_crap.logon_parameters,
 480                 s3call->request.data.auth_crap.domain,
 481                 s3call->request.data.auth_crap.user,
 482                 s3call->request.data.auth_crap.workstation,
 483                 chal, nt_resp, lm_resp);
 484         NT_STATUS_HAVE_NO_MEMORY(ctx);
 485
 486         ctx->async.fn = pam_auth_crap_recv;
 487         ctx->async.private_data = s3call;
 488         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 489         return NT_STATUS_OK;
 490 }
 491
 492 static void pam_auth_crap_recv(struct composite_context *ctx)
 493 {
 494         struct wbsrv_samba3_call *s3call =
 495                 talloc_get_type(ctx->async.private_data,
 496                                 struct wbsrv_samba3_call);
 497         NTSTATUS status;
 498         DATA_BLOB info3;
 499         struct netr_UserSessionKey user_session_key;
 500         struct netr_LMSessionKey lm_key;
 501         char *unix_username;
 502
 503         status = wb_cmd_pam_auth_crap_recv(ctx, s3call, &info3,
 504                                            &user_session_key, &lm_key, &unix_username);
 505         if (!NT_STATUS_IS_OK(status)) goto done;
 506
 507         if (s3call->request.flags & WBFLAG_PAM_USER_SESSION_KEY) {
 508                 memcpy(s3call->response.data.auth.user_session_key,
 509                        &user_session_key.key,
 510                        sizeof(s3call->response.data.auth.user_session_key));
 511         }
 512
 513         if (s3call->request.flags & WBFLAG_PAM_INFO3_NDR) {
 514                 s3call->response.extra_data.data = info3.data;
 515                 s3call->response.length += info3.length;
 516         }
 517
 518         if (s3call->request.flags & WBFLAG_PAM_LMKEY) {
 519                 memcpy(s3call->response.data.auth.first_8_lm_hash,
 520                        lm_key.key,
 521                        sizeof(s3call->response.data.auth.first_8_lm_hash));
 522         }
 523
 524         if (s3call->request.flags & WBFLAG_PAM_UNIX_NAME) {
 525                 s3call->response.extra_data.data = unix_username;
 526                 s3call->response.length += strlen(unix_username)+1;
 527         }
 528
 529  done:
 530         wbsrv_samba3_async_auth_epilogue(status, s3call);
 531 }
 532
 533 /* Helper function: Split a domain\\user string into it's parts,
 534  * because the client supplies it as one string */
 535
 536 static BOOL samba3_parse_domuser(TALLOC_CTX *mem_ctx, const char *domuser,
 537                                  char **domain, char **user)
 538 {
 539         char *p = strchr(domuser, *lp_winbind_separator());
 540
 541         if (p == NULL) {
 542                 *domain = talloc_strdup(mem_ctx, lp_workgroup());
 543         } else {
 544                 *domain = talloc_strndup(mem_ctx, domuser,
 545                                          PTR_DIFF(p, domuser));
 546                 domuser = p+1;
 547         }
 548
 549         *user = talloc_strdup(mem_ctx, domuser);
 550
 551         return ((*domain != NULL) && (*user != NULL));
 552 }
 553
 554 /* Plaintext authentication
 555
 556    This interface is used by ntlm_auth in it's 'basic' authentication
 557    mode, as well as by pam_winbind to authenticate users where we are
 558    given a plaintext password.
 559 */
 560
 561 static void pam_auth_recv(struct composite_context *ctx);
 562
 563 NTSTATUS wbsrv_samba3_pam_auth(struct wbsrv_samba3_call *s3call)
 564 {
 565         struct composite_context *ctx;
 566         struct wbsrv_service *service =
 567                 s3call->wbconn->listen_socket->service;
 568         char *user, *domain;
 569
 570         if (!samba3_parse_domuser(s3call,
 571                                  s3call->request.data.auth.user,
 572                                  &domain, &user)) {
 573                 return NT_STATUS_NO_SUCH_USER;
 574         }
 575
 576         ctx = wb_cmd_pam_auth_send(s3call, service, domain, user,
 577                                    s3call->request.data.auth.pass);
 578         NT_STATUS_HAVE_NO_MEMORY(ctx);
 579
 580         ctx->async.fn = pam_auth_recv;
 581         ctx->async.private_data = s3call;
 582         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 583         return NT_STATUS_OK;
 584 }
 585
 586 static void pam_auth_recv(struct composite_context *ctx)
 587 {
 588         struct wbsrv_samba3_call *s3call =
 589                 talloc_get_type(ctx->async.private_data,
 590                                 struct wbsrv_samba3_call);
 591         NTSTATUS status;
 592
 593         status = wb_cmd_pam_auth_recv(ctx);
 594
 595         if (!NT_STATUS_IS_OK(status)) goto done;
 596
 597  done:
 598         wbsrv_samba3_async_auth_epilogue(status, s3call);
 599 }
 600
 601 /*
 602    List trusted domains
 603 */
 604
 605 static void list_trustdom_recv_doms(struct composite_context *ctx);
 606
 607 NTSTATUS wbsrv_samba3_list_trustdom(struct wbsrv_samba3_call *s3call)
 608 {
 609         struct composite_context *ctx;
 610         struct wbsrv_service *service =
 611                 s3call->wbconn->listen_socket->service;
 612
 613         DEBUG(5, ("wbsrv_samba3_list_trustdom called\n"));
 614
 615         ctx = wb_cmd_list_trustdoms_send(s3call, service);
 616         NT_STATUS_HAVE_NO_MEMORY(ctx);
 617
 618         ctx->async.fn = list_trustdom_recv_doms;
 619         ctx->async.private_data = s3call;
 620         s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
 621         return NT_STATUS_OK;
 622 }
 623
 624 static void list_trustdom_recv_doms(struct composite_context *ctx)
 625 {
 626         struct wbsrv_samba3_call *s3call =
 627                 talloc_get_type(ctx->async.private_data,
 628                                 struct wbsrv_samba3_call);
 629         int i, num_domains;
 630         struct wb_dom_info **domains;
 631         NTSTATUS status;
 632         char *result;
 633
 634         status = wb_cmd_list_trustdoms_recv(ctx, s3call, &num_domains,
 635                                             &domains);
 636         if (!NT_STATUS_IS_OK(status)) goto done;
 637
 638         result = talloc_strdup(s3call, "");
 639         if (result == NULL) {
 640                 status = NT_STATUS_NO_MEMORY;
 641                 goto done;
 642         }
 643
 644         for (i=0; i<num_domains; i++) {
 645                 result = talloc_asprintf_append(
 646                         result, "%s\\%s\\%s",
 647                         domains[i]->name, domains[i]->name,
 648                         dom_sid_string(s3call, domains[i]->sid));
 649         }
 650
 651         if (result == NULL) {
 652                 status = NT_STATUS_NO_MEMORY;
 653                 goto done;
 654         }
 655
 656         s3call->response.result = WINBINDD_OK;
 657         if (num_domains > 0) {
 658                 s3call->response.extra_data.data = result;
 659                 s3call->response.length += strlen(result)+1;
 660         }
 661
 662  done:
 663         wbsrv_samba3_async_epilogue(status, s3call);
 664 }
 665
 666 /* NSS calls */
 667
 668 NTSTATUS wbsrv_samba3_getpwnam(struct wbsrv_samba3_call *s3call)
 669 {
 670         DEBUG(5, ("wbsrv_samba3_getpwnam called\n"));
 671         s3call->response.result = WINBINDD_ERROR;
 672         return NT_STATUS_OK;
 673 }
 674
 675 NTSTATUS wbsrv_samba3_getpwuid(struct wbsrv_samba3_call *s3call)
 676 {
 677         DEBUG(5, ("wbsrv_samba3_getpwuid called\n"));
 678         s3call->response.result = WINBINDD_ERROR;
 679         return NT_STATUS_OK;
 680 }
 681
 682 NTSTATUS wbsrv_samba3_setpwent(struct wbsrv_samba3_call *s3call)
 683 {
 684         DEBUG(5, ("wbsrv_samba3_setpwent called\n"));
 685         s3call->response.result = WINBINDD_OK;
 686         return NT_STATUS_OK;
 687 }
 688
 689 NTSTATUS wbsrv_samba3_getpwent(struct wbsrv_samba3_call *s3call)
 690 {
 691         DEBUG(5, ("wbsrv_samba3_getpwent called\n"));
 692         s3call->response.result = WINBINDD_ERROR;
 693         return NT_STATUS_OK;
 694 }
 695
 696 NTSTATUS wbsrv_samba3_endpwent(struct wbsrv_samba3_call *s3call)
 697 {
 698         DEBUG(5, ("wbsrv_samba3_endpwent called\n"));
 699         s3call->response.result = WINBINDD_OK;
 700         return NT_STATUS_OK;
 701 }
 702
 703 NTSTATUS wbsrv_samba3_getgrnam(struct wbsrv_samba3_call *s3call)
 704 {
 705         DEBUG(5, ("wbsrv_samba3_getgrnam called\n"));
 706         s3call->response.result = WINBINDD_ERROR;
 707         return NT_STATUS_OK;
 708 }
 709
 710 NTSTATUS wbsrv_samba3_getgrgid(struct wbsrv_samba3_call *s3call)
 711 {
 712         DEBUG(5, ("wbsrv_samba3_getgrgid called\n"));
 713         s3call->response.result = WINBINDD_ERROR;
 714         return NT_STATUS_OK;
 715 }
 716
 717 NTSTATUS wbsrv_samba3_getgroups(struct wbsrv_samba3_call *s3call)
 718 {
 719         DEBUG(5, ("wbsrv_samba3_getgroups called\n"));
 720         s3call->response.result = WINBINDD_ERROR;
 721         return NT_STATUS_OK;
 722 }
 723
 724 NTSTATUS wbsrv_samba3_setgrent(struct wbsrv_samba3_call *s3call)
 725 {
 726         DEBUG(5, ("wbsrv_samba3_setgrent called\n"));
 727         s3call->response.result = WINBINDD_OK;
 728         return NT_STATUS_OK;
 729 }
 730
 731 NTSTATUS wbsrv_samba3_getgrent(struct wbsrv_samba3_call *s3call)
 732 {
 733         DEBUG(5, ("wbsrv_samba3_getgrent called\n"));
 734         s3call->response.result = WINBINDD_ERROR;
 735         return NT_STATUS_OK;
 736 }
 737
 738 NTSTATUS wbsrv_samba3_endgrent(struct wbsrv_samba3_call *s3call)
 739 {
 740         DEBUG(5, ("wbsrv_samba3_endgrent called\n"));
 741         s3call->response.result = WINBINDD_OK;
 742         return NT_STATUS_OK;
 743 }