r25175: Change to talloc_asprintf_append_buffer().
[jelmer/samba4-debian.git] / source / winbind / wb_samba3_cmd.c
index 64d75016bb05baaec5c2be9a6d255923071fe38c..56a168ebb0ed65386a4a7bedca61ace7c2bca8ed 100644 (file)
@@ -4,10 +4,11 @@
 
    Copyright (C) Stefan Metzmacher     2005
    Copyright (C) Volker Lendecke       2005
+   Copyright (C) Andrew Bartlett <abartlet@samba.org> 2005
 
    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
-   the Free Software Foundation; either version 2 of the License, or
+   the Free Software Foundation; either version 3 of the License, or
    (at your option) any later version.
    
    This program is distributed in the hope that it will be useful,
    GNU General Public License for more details.
    
    You should have received a copy of the GNU General Public License
-   along with this program; if not, write to the Free Software
-   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+   along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
 #include "includes.h"
-#include "smbd/service_stream.h"
-#include "nsswitch/winbind_nss_config.h"
-#include "nsswitch/winbindd_nss.h"
 #include "winbind/wb_server.h"
-#include "winbind/wb_samba3_protocol.h"
 #include "winbind/wb_async_helpers.h"
-#include "librpc/gen_ndr/nbt.h"
-#include "libcli/raw/libcliraw.h"
+#include "winbind/wb_helper.h"
 #include "libcli/composite/composite.h"
-#include "libcli/smb_composite/smb_composite.h"
-#include "include/version.h"
-#include "lib/events/events.h"
-#include "librpc/gen_ndr/ndr_netlogon.h"
+#include "version.h"
+#include "librpc/gen_ndr/netlogon.h"
+#include "libcli/security/security.h"
+#include "auth/pam_errors.h"
+#include "param/param.h"
+
+/* 
+   Send off the reply to an async Samba3 query, handling filling in the PAM, NTSTATUS and string errors.
+*/
+
+static void wbsrv_samba3_async_auth_epilogue(NTSTATUS status,
+                                            struct wbsrv_samba3_call *s3call)
+{
+       struct winbindd_response *resp = &s3call->response;
+       if (!NT_STATUS_IS_OK(status)) {
+               resp->result = WINBINDD_ERROR;
+               WBSRV_SAMBA3_SET_STRING(resp->data.auth.nt_status_string,
+                                       nt_errstr(status));
+               WBSRV_SAMBA3_SET_STRING(resp->data.auth.error_string,
+                                       get_friendly_nt_error_msg(status));
+       } else {
+               resp->result = WINBINDD_OK;
+       }
+
+       resp->data.auth.pam_error = nt_status_to_pam(status);
+       resp->data.auth.nt_status = NT_STATUS_V(status);
+
+       wbsrv_samba3_send_reply(s3call);
+}
+
+/* 
+   Send of a generic reply to a Samba3 query
+*/
+
+static void wbsrv_samba3_async_epilogue(NTSTATUS status,
+                                       struct wbsrv_samba3_call *s3call)
+{
+       struct winbindd_response *resp = &s3call->response;
+       if (NT_STATUS_IS_OK(status)) {
+               resp->result = WINBINDD_OK;
+       } else {
+               resp->result = WINBINDD_ERROR;
+       }
+
+       wbsrv_samba3_send_reply(s3call);
+}
+
+/* 
+   Boilerplate commands, simple queries without network traffic 
+*/
 
 NTSTATUS wbsrv_samba3_interface_version(struct wbsrv_samba3_call *s3call)
 {
@@ -46,30 +87,33 @@ NTSTATUS wbsrv_samba3_info(struct wbsrv_samba3_call *s3call)
 {
        s3call->response.result                 = WINBINDD_OK;
        s3call->response.data.info.winbind_separator = *lp_winbind_separator();
-       WBSRV_SAMBA3_SET_STRING(s3call->response.data.info.samba_version, SAMBA_VERSION_STRING);
+       WBSRV_SAMBA3_SET_STRING(s3call->response.data.info.samba_version,
+                               SAMBA_VERSION_STRING);
        return NT_STATUS_OK;
 }
 
 NTSTATUS wbsrv_samba3_domain_name(struct wbsrv_samba3_call *s3call)
 {
        s3call->response.result                 = WINBINDD_OK;
-       WBSRV_SAMBA3_SET_STRING(s3call->response.data.domain_name, lp_workgroup());
+       WBSRV_SAMBA3_SET_STRING(s3call->response.data.domain_name,
+                               lp_workgroup());
        return NT_STATUS_OK;
 }
 
 NTSTATUS wbsrv_samba3_netbios_name(struct wbsrv_samba3_call *s3call)
 {
        s3call->response.result                 = WINBINDD_OK;
-       WBSRV_SAMBA3_SET_STRING(s3call->response.data.netbios_name, lp_netbios_name());
+       WBSRV_SAMBA3_SET_STRING(s3call->response.data.netbios_name,
+                               lp_netbios_name());
        return NT_STATUS_OK;
 }
 
 NTSTATUS wbsrv_samba3_priv_pipe_dir(struct wbsrv_samba3_call *s3call)
 {
        s3call->response.result                 = WINBINDD_OK;
-       s3call->response.extra_data             = smbd_tmp_path(s3call,
-                                                 WINBINDD_SAMBA3_PRIVILEGED_SOCKET);
-       NT_STATUS_HAVE_NO_MEMORY(s3call->response.extra_data);
+       s3call->response.extra_data.data =
+               smbd_tmp_path(s3call, WINBINDD_SAMBA3_PRIVILEGED_SOCKET);
+       NT_STATUS_HAVE_NO_MEMORY(s3call->response.extra_data.data);
        return NT_STATUS_OK;
 }
 
@@ -79,6 +123,12 @@ NTSTATUS wbsrv_samba3_ping(struct wbsrv_samba3_call *s3call)
        return NT_STATUS_OK;
 }
 
+#if 0
+/* 
+   Validate that we have a working pipe to the domain controller.
+   Return any NT error found in the process
+*/
+
 static void checkmachacc_recv_creds(struct composite_context *ctx);
 
 NTSTATUS wbsrv_samba3_check_machacc(struct wbsrv_samba3_call *s3call)
@@ -104,41 +154,221 @@ static void checkmachacc_recv_creds(struct composite_context *ctx)
        NTSTATUS status;
 
        status = wb_cmd_checkmachacc_recv(ctx);
-       if (NT_STATUS_IS_OK(status)) {
-               s3call->response.result = WINBINDD_OK;
-       } else {
-               struct winbindd_response *resp = &s3call->response;
-               resp->result = WINBINDD_ERROR;
-               WBSRV_SAMBA3_SET_STRING(resp->data.auth.nt_status_string,
-                                       nt_errstr(status));
-               WBSRV_SAMBA3_SET_STRING(resp->data.auth.error_string,
-                                       nt_errstr(status));
-               resp->data.auth.pam_error = nt_status_to_pam(status);
+
+       wbsrv_samba3_async_auth_epilogue(status, s3call);
+}
+#endif
+
+/*
+  Find the name of a suitable domain controller, by query on the
+  netlogon pipe to the DC.  
+*/
+
+static void getdcname_recv_dc(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_getdcname(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_getdcname called\n"));
+
+       ctx = wb_cmd_getdcname_send(s3call, service,
+                                   s3call->request.domain_name);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = getdcname_recv_dc;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void getdcname_recv_dc(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       const char *dcname;
+       NTSTATUS status;
+
+       status = wb_cmd_getdcname_recv(ctx, s3call, &dcname);
+       if (!NT_STATUS_IS_OK(status)) goto done;
+
+       s3call->response.result = WINBINDD_OK;
+       WBSRV_SAMBA3_SET_STRING(s3call->response.data.dc_name, dcname);
+
+ done:
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+/* 
+   Lookup a user's domain groups
+*/
+
+static void userdomgroups_recv_groups(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_userdomgroups(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct dom_sid *sid;
+
+       DEBUG(5, ("wbsrv_samba3_userdomgroups called\n"));
+
+       sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
+       if (sid == NULL) {
+               DEBUG(5, ("Could not parse sid %s\n",
+                         s3call->request.data.sid));
+               return NT_STATUS_NO_MEMORY;
        }
-       status = wbsrv_send_reply(s3call->call);
-       if (!NT_STATUS_IS_OK(status)) {
-               wbsrv_terminate_connection(s3call->call->wbconn,
-                                          "wbsrv_queue_reply() failed");
-               return;
+
+       ctx = wb_cmd_userdomgroups_send(
+               s3call, s3call->wbconn->listen_socket->service, sid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = userdomgroups_recv_groups;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void userdomgroups_recv_groups(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       int i, num_sids;
+       struct dom_sid **sids;
+       char *sids_string;
+       NTSTATUS status;
+
+       status = wb_cmd_userdomgroups_recv(ctx, s3call, &num_sids, &sids);
+       if (!NT_STATUS_IS_OK(status)) goto done;
+
+       sids_string = talloc_strdup(s3call, "");
+       if (sids_string == NULL) {
+               status = NT_STATUS_NO_MEMORY;
+               goto done;
+       }
+
+       for (i=0; i<num_sids; i++) {
+               sids_string = talloc_asprintf_append_buffer(
+                       sids_string, "%s\n", dom_sid_string(s3call, sids[i]));
+       }
+
+       if (sids_string == NULL) {
+               status = NT_STATUS_NO_MEMORY;
+               goto done;
+       }
+
+       s3call->response.result = WINBINDD_OK;
+       s3call->response.extra_data.data = sids_string;
+       s3call->response.length += strlen(sids_string)+1;
+       s3call->response.data.num_entries = num_sids;
+
+ done:
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+/* 
+   Lookup the list of SIDs for a user 
+*/
+static void usersids_recv_sids(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_usersids(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct dom_sid *sid;
+
+       DEBUG(5, ("wbsrv_samba3_usersids called\n"));
+
+       sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
+       if (sid == NULL) {
+               DEBUG(5, ("Could not parse sid %s\n",
+                         s3call->request.data.sid));
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       ctx = wb_cmd_usersids_send(
+               s3call, s3call->wbconn->listen_socket->service, sid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = usersids_recv_sids;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void usersids_recv_sids(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       int i, num_sids;
+       struct dom_sid **sids;
+       char *sids_string;
+       NTSTATUS status;
+
+       status = wb_cmd_usersids_recv(ctx, s3call, &num_sids, &sids);
+       if (!NT_STATUS_IS_OK(status)) goto done;
+
+       sids_string = talloc_strdup(s3call, "");
+       if (sids_string == NULL) {
+               status = NT_STATUS_NO_MEMORY;
+               goto done;
+       }
+
+       for (i=0; i<num_sids; i++) {
+               sids_string = talloc_asprintf_append_buffer(
+                       sids_string, "%s\n", dom_sid_string(s3call, sids[i]));
+               if (sids_string == NULL) {
+                       status = NT_STATUS_NO_MEMORY;
+                       goto done;
+               }
+       }
+
+       s3call->response.result = WINBINDD_OK;
+       s3call->response.extra_data.data = sids_string;
+       s3call->response.length += strlen(sids_string);
+       s3call->response.data.num_entries = num_sids;
+
+       /* Hmmmm. Nasty protocol -- who invented the zeros between the
+        * SIDs? Hmmm. Could have been me -- vl */
+
+       while (*sids_string != '\0') {
+               if ((*sids_string) == '\n') {
+                       *sids_string = '\0';
+               }
+               sids_string += 1;
        }
+
+ done:
+       wbsrv_samba3_async_epilogue(status, s3call);
 }
 
+/* 
+   Lookup a DOMAIN\\user style name, and return a SID
+*/
+
 static void lookupname_recv_sid(struct composite_context *ctx);
 
 NTSTATUS wbsrv_samba3_lookupname(struct wbsrv_samba3_call *s3call)
 {
        struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
 
        DEBUG(5, ("wbsrv_samba3_lookupname called\n"));
 
-       ctx = wb_cmd_lookupname_send(s3call->call,
+       ctx = wb_cmd_lookupname_send(s3call, service,
+                                    s3call->request.data.name.dom_name,
                                     s3call->request.data.name.name);
        NT_STATUS_HAVE_NO_MEMORY(ctx);
 
        /* setup the callbacks */
        ctx->async.fn = lookupname_recv_sid;
        ctx->async.private_data = s3call;
-       s3call->call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
        return NT_STATUS_OK;
 }
 
@@ -159,139 +389,685 @@ static void lookupname_recv_sid(struct composite_context *ctx)
                                dom_sid_string(s3call, sid->sid));
 
  done:
-       if (!NT_STATUS_IS_OK(status)) {
-               struct winbindd_response *resp = &s3call->response;
-               resp->result = WINBINDD_ERROR;
-               WBSRV_SAMBA3_SET_STRING(resp->data.auth.nt_status_string,
-                                       nt_errstr(status));
-               WBSRV_SAMBA3_SET_STRING(resp->data.auth.error_string,
-                                       nt_errstr(status));
-               resp->data.auth.pam_error = nt_status_to_pam(status);
-       }
-
-       status = wbsrv_send_reply(s3call->call);
-       if (!NT_STATUS_IS_OK(status)) {
-               wbsrv_terminate_connection(s3call->call->wbconn,
-                                          "wbsrv_queue_reply() failed");
-               return;
-       }
+       wbsrv_samba3_async_epilogue(status, s3call);
 }
 
-NTSTATUS wbsrv_samba3_pam_auth(struct wbsrv_samba3_call *s3call)
+/* 
+   Lookup a SID, and return a DOMAIN\\user style name
+*/
+
+static void lookupsid_recv_name(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_lookupsid(struct wbsrv_samba3_call *s3call)
 {
+       struct composite_context *ctx;
        struct wbsrv_service *service =
-               s3call->call->wbconn->listen_socket->service;
-       
-       s3call->response.result                 = WINBINDD_ERROR;
+               s3call->wbconn->listen_socket->service;
+       struct dom_sid *sid;
+
+       DEBUG(5, ("wbsrv_samba3_lookupsid called\n"));
+
+       sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
+       if (sid == NULL) {
+               DEBUG(5, ("Could not parse sid %s\n",
+                         s3call->request.data.sid));
+               return NT_STATUS_NO_MEMORY;
+       }
+
+       ctx = wb_cmd_lookupsid_send(s3call, service, sid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       /* setup the callbacks */
+       ctx->async.fn = lookupsid_recv_name;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
        return NT_STATUS_OK;
 }
 
+static void lookupsid_recv_name(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       struct wb_sid_object *sid;
+       NTSTATUS status;
+
+       status = wb_cmd_lookupsid_recv(ctx, s3call, &sid);
+       if (!NT_STATUS_IS_OK(status)) goto done;
+
+       s3call->response.result = WINBINDD_OK;
+       s3call->response.data.name.type = sid->type;
+       WBSRV_SAMBA3_SET_STRING(s3call->response.data.name.dom_name,
+                               sid->domain);
+       WBSRV_SAMBA3_SET_STRING(s3call->response.data.name.name, sid->name);
+
+ done:
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+/*
+  Challenge-response authentication.  This interface is used by
+  ntlm_auth and the smbd auth subsystem to pass NTLM authentication
+  requests along a common pipe to the domain controller.  
+
+  The return value (in the async reply) may include the 'info3'
+  (effectivly most things you would want to know about the user), or
+  the NT and LM session keys seperated.
+*/
+
+static void pam_auth_crap_recv(struct composite_context *ctx);
+
 NTSTATUS wbsrv_samba3_pam_auth_crap(struct wbsrv_samba3_call *s3call)
 {
+       struct composite_context *ctx;
        struct wbsrv_service *service =
-               s3call->call->wbconn->listen_socket->service;
-       struct creds_CredentialState *creds_state;
-       struct netr_Authenticator auth, auth2;
-       struct netr_NetworkInfo ninfo;
-       struct netr_LogonSamLogon r;
+               s3call->wbconn->listen_socket->service;
+       DATA_BLOB chal, nt_resp, lm_resp;
+
+       DEBUG(5, ("wbsrv_samba3_pam_auth_crap called\n"));
+
+       chal.data       = s3call->request.data.auth_crap.chal;
+       chal.length     = sizeof(s3call->request.data.auth_crap.chal);
+       nt_resp.data    = (uint8_t *)s3call->request.data.auth_crap.nt_resp;
+       nt_resp.length  = s3call->request.data.auth_crap.nt_resp_len;
+       lm_resp.data    = (uint8_t *)s3call->request.data.auth_crap.lm_resp;
+       lm_resp.length  = s3call->request.data.auth_crap.lm_resp_len;
+
+       ctx = wb_cmd_pam_auth_crap_send(
+               s3call, service,
+               s3call->request.data.auth_crap.logon_parameters,
+               s3call->request.data.auth_crap.domain,
+               s3call->request.data.auth_crap.user,
+               s3call->request.data.auth_crap.workstation,
+               chal, nt_resp, lm_resp);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = pam_auth_crap_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void pam_auth_crap_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
        NTSTATUS status;
-       TALLOC_CTX *mem_ctx = talloc_new(s3call);
-       if (!mem_ctx) {
-               return NT_STATUS_NO_MEMORY;
+       DATA_BLOB info3;
+       struct netr_UserSessionKey user_session_key;
+       struct netr_LMSessionKey lm_key;
+       char *unix_username;
+       
+       status = wb_cmd_pam_auth_crap_recv(ctx, s3call, &info3,
+                                          &user_session_key, &lm_key, &unix_username);
+       if (!NT_STATUS_IS_OK(status)) goto done;
+
+       if (s3call->request.flags & WBFLAG_PAM_USER_SESSION_KEY) {
+               memcpy(s3call->response.data.auth.user_session_key, 
+                      &user_session_key.key,
+                      sizeof(s3call->response.data.auth.user_session_key));
        }
 
-       ZERO_STRUCT(auth2);
-       creds_state = cli_credentials_get_netlogon_creds(service->domains->schannel_creds);
-       
-       creds_client_authenticator(creds_state, &auth);
-
-       ninfo.identity_info.account_name.string = s3call->request.data.auth_crap.user;
-       ninfo.identity_info.domain_name.string = s3call->request.data.auth_crap.domain;
-       ninfo.identity_info.parameter_control = 0;
-       ninfo.identity_info.logon_id_low = 0;
-       ninfo.identity_info.logon_id_high = 0;
-       ninfo.identity_info.workstation.string = s3call->request.data.auth_crap.workstation;
-       memcpy(ninfo.challenge, s3call->request.data.auth_crap.chal,
-              sizeof(ninfo.challenge));
-       ninfo.nt.length = s3call->request.data.auth_crap.nt_resp_len;
-       ninfo.nt.data = s3call->request.data.auth_crap.nt_resp;
-       ninfo.lm.length = s3call->request.data.auth_crap.lm_resp_len;
-       ninfo.lm.data = s3call->request.data.auth_crap.lm_resp;
-
-       r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(service->domains->netlogon_pipe));
-       r.in.workstation = cli_credentials_get_workstation(service->domains->schannel_creds);
-       r.in.credential = &auth;
-       r.in.return_authenticator = &auth2;
-       r.in.logon_level = 2;
-       r.in.validation_level = 3;
-       r.in.logon.network = &ninfo;
-
-       r.out.return_authenticator = NULL;
-       status = dcerpc_netr_LogonSamLogon(service->domains->netlogon_pipe, mem_ctx, &r);
-       if (!r.out.return_authenticator || 
-           !creds_client_check(creds_state, &r.out.return_authenticator->cred)) {
-               DEBUG(0, ("Credentials check failed!\n"));
-               status = NT_STATUS_ACCESS_DENIED;
+       if (s3call->request.flags & WBFLAG_PAM_INFO3_NDR) {
+               s3call->response.extra_data.data = info3.data;
+               s3call->response.length += info3.length;
        }
-       if (NT_STATUS_IS_OK(status)) {
-               struct netr_SamBaseInfo *base;
-               switch (r.in.validation_level) {
-               case 2:
-                       base = &r.out.validation.sam2->base;
-                       break;
-               case 3:
-                       base = &r.out.validation.sam3->base;
-                       break;
-               case 6:
-                       base = &r.out.validation.sam6->base;
-                       break;
-               }
 
-               creds_decrypt_samlogon(creds_state, 
-                                      r.in.validation_level, 
-                                      &r.out.validation);
-
-               if ((s3call->request.flags & WBFLAG_PAM_INFO3_NDR) 
-                   && (r.in.validation_level == 3)) {
-                       DATA_BLOB tmp_blob, tmp_blob2;
-                       status = ndr_push_struct_blob(&tmp_blob, mem_ctx, r.out.validation.sam3,
-                                                     (ndr_push_flags_fn_t)ndr_push_netr_SamInfo3);
-                       if (NT_STATUS_IS_OK(status)) {
-                               tmp_blob2 = data_blob_talloc(mem_ctx, NULL, tmp_blob.length + 4);
-                               if (!tmp_blob2.data) {
-                                       status = NT_STATUS_NO_MEMORY;
-                               }
-                       }
-                       /* Ugly Samba3 winbind pipe compatability */
-                       if (NT_STATUS_IS_OK(status)) {
-                               SIVAL(tmp_blob2.data, 0, 1);
-                               memcpy(tmp_blob2.data + 4, tmp_blob.data, tmp_blob.length); 
-                       }
-                       s3call->response.extra_data = talloc_steal(s3call, tmp_blob2.data);
-                       s3call->response.length += tmp_blob2.length;
-               }
-               if (s3call->request.flags & WBFLAG_PAM_USER_SESSION_KEY) {
-                       memcpy(s3call->response.data.auth.user_session_key, 
-                              base->key.key, sizeof(s3call->response.data.auth.user_session_key) /* 16 */);
-               }
-               if (s3call->request.flags & WBFLAG_PAM_LMKEY) {
-                       memcpy(s3call->response.data.auth.first_8_lm_hash, 
-                              base->LMSessKey.key, sizeof(s3call->response.data.auth.first_8_lm_hash) /* 8 */);
-               }
+       if (s3call->request.flags & WBFLAG_PAM_LMKEY) {
+               memcpy(s3call->response.data.auth.first_8_lm_hash, 
+                      lm_key.key,
+                      sizeof(s3call->response.data.auth.first_8_lm_hash));
        }
-               
-       if (!NT_STATUS_IS_OK(status)) {
-               struct winbindd_response *resp = &s3call->response;
-               resp->result = WINBINDD_ERROR;
-       } else {
-               struct winbindd_response *resp = &s3call->response;
-               resp->result = WINBINDD_OK;
+       
+       if (s3call->request.flags & WBFLAG_PAM_UNIX_NAME) {
+               s3call->response.extra_data.data = unix_username;
+               s3call->response.length += strlen(unix_username)+1;
+       }
+
+ done:
+       wbsrv_samba3_async_auth_epilogue(status, s3call);
+}
+
+/* Plaintext authentication 
+   
+   This interface is used by ntlm_auth in it's 'basic' authentication
+   mode, as well as by pam_winbind to authenticate users where we are
+   given a plaintext password.
+*/
+
+static void pam_auth_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_pam_auth(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+       char *user, *domain;
+
+       if (!wb_samba3_split_username(s3call,
+                                s3call->request.data.auth.user,
+                                &domain, &user)) {
+               return NT_STATUS_NO_SUCH_USER;
        }
-               
-       WBSRV_SAMBA3_SET_STRING(s3call->response.data.auth.nt_status_string,
-                               nt_errstr(status));
-       WBSRV_SAMBA3_SET_STRING(s3call->response.data.auth.error_string,
-                               nt_errstr(status));
-       s3call->response.data.auth.pam_error = nt_status_to_pam(status);
+
+       ctx = wb_cmd_pam_auth_send(s3call, service, domain, user,
+                                  s3call->request.data.auth.pass);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = pam_auth_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
        return NT_STATUS_OK;
 }
+
+static void pam_auth_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+
+       status = wb_cmd_pam_auth_recv(ctx);
+
+       if (!NT_STATUS_IS_OK(status)) goto done;
+
+ done:
+       wbsrv_samba3_async_auth_epilogue(status, s3call);
+}
+
+/* 
+   List trusted domains
+*/
+
+static void list_trustdom_recv_doms(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_list_trustdom(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_list_trustdom called\n"));
+
+       ctx = wb_cmd_list_trustdoms_send(s3call, service);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = list_trustdom_recv_doms;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void list_trustdom_recv_doms(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       int i, num_domains;
+       struct wb_dom_info **domains;
+       NTSTATUS status;
+       char *result;
+
+       status = wb_cmd_list_trustdoms_recv(ctx, s3call, &num_domains,
+                                           &domains);
+       if (!NT_STATUS_IS_OK(status)) goto done;
+
+       result = talloc_strdup(s3call, "");
+       if (result == NULL) {
+               status = NT_STATUS_NO_MEMORY;
+               goto done;
+       }
+
+       for (i=0; i<num_domains; i++) {
+               result = talloc_asprintf_append_buffer(
+                       result, "%s\\%s\\%s",
+                       domains[i]->name, domains[i]->name,
+                       dom_sid_string(s3call, domains[i]->sid));
+       }
+
+       if (result == NULL) {
+               status = NT_STATUS_NO_MEMORY;
+               goto done;
+       }
+
+       s3call->response.result = WINBINDD_OK;
+       if (num_domains > 0) {
+               s3call->response.extra_data.data = result;
+               s3call->response.length += strlen(result)+1;
+       }
+
+ done:
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+
+/* List users */
+
+static void list_users_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_list_users(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_list_users called\n"));
+
+       ctx = wb_cmd_list_users_send(s3call, service,
+                       s3call->request.domain_name);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = list_users_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void list_users_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       uint32_t extra_data_len;
+       char *extra_data;
+       NTSTATUS status;
+
+       DEBUG(5, ("list_users_recv called\n"));
+
+       status = wb_cmd_list_users_recv(ctx, s3call, &extra_data_len,
+                       &extra_data);
+
+       if (NT_STATUS_IS_OK(status)) {
+               s3call->response.extra_data.data = extra_data;
+               s3call->response.length += extra_data_len;
+       }
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+/* NSS calls */
+
+static void getpwnam_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_getpwnam(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_getpwnam called\n"));
+
+       ctx = wb_cmd_getpwnam_send(s3call, service,
+                       s3call->request.data.username);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = getpwnam_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void getpwnam_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+       struct winbindd_pw *pw;
+
+       DEBUG(5, ("getpwnam_recv called\n"));
+
+       status = wb_cmd_getpwnam_recv(ctx, s3call, &pw);
+       if(NT_STATUS_IS_OK(status))
+               s3call->response.data.pw = *pw;
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+static void getpwuid_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_getpwuid(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service = s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_getpwuid called\n"));
+
+       ctx = wb_cmd_getpwuid_send(s3call, service,
+                       s3call->request.data.uid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = getpwuid_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void getpwuid_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+       struct winbindd_pw *pw;
+
+       DEBUG(5, ("getpwuid_recv called\n"));
+
+       status = wb_cmd_getpwuid_recv(ctx, s3call, &pw);
+       if (NT_STATUS_IS_OK(status))
+               s3call->response.data.pw = *pw;
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+static void setpwent_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_setpwent(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service = s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_setpwent called\n"));
+
+       ctx = wb_cmd_setpwent_send(s3call, service);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = setpwent_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void setpwent_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+       struct wbsrv_pwent *pwent;
+
+       DEBUG(5, ("setpwent_recv called\n"));
+
+       status = wb_cmd_setpwent_recv(ctx, s3call->wbconn, &pwent);
+       if (NT_STATUS_IS_OK(status)) {
+               s3call->wbconn->protocol_private_data = pwent;
+       }
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+static void getpwent_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_getpwent(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service = s3call->wbconn->listen_socket->service;
+       struct wbsrv_pwent *pwent;
+
+       DEBUG(5, ("wbsrv_samba3_getpwent called\n"));
+
+       NT_STATUS_HAVE_NO_MEMORY(s3call->wbconn->protocol_private_data);
+
+       pwent = talloc_get_type(s3call->wbconn->protocol_private_data,
+                       struct wbsrv_pwent);
+       NT_STATUS_HAVE_NO_MEMORY(pwent);
+
+       ctx = wb_cmd_getpwent_send(s3call, service, pwent,
+                       s3call->request.data.num_entries);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = getpwent_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+}
+
+static void getpwent_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+       struct winbindd_pw *pw;
+       uint32_t num_users;
+
+       DEBUG(5, ("getpwent_recv called\n"));
+
+       status = wb_cmd_getpwent_recv(ctx, s3call, &pw, &num_users);
+       if (NT_STATUS_IS_OK(status)) {
+               uint32_t extra_len = sizeof(struct winbindd_pw) * num_users;
+
+               s3call->response.data.num_entries = num_users;
+               s3call->response.extra_data.data = pw;
+               s3call->response.length += extra_len;
+       }
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+NTSTATUS wbsrv_samba3_endpwent(struct wbsrv_samba3_call *s3call)
+{
+       struct wbsrv_pwent *pwent =
+               talloc_get_type(s3call->wbconn->protocol_private_data,
+                               struct wbsrv_pwent);
+       DEBUG(5, ("wbsrv_samba3_endpwent called\n"));
+
+       talloc_free(pwent);
+
+       s3call->wbconn->protocol_private_data = NULL;
+       s3call->response.result = WINBINDD_OK;
+       return NT_STATUS_OK;
+}
+
+NTSTATUS wbsrv_samba3_getgrnam(struct wbsrv_samba3_call *s3call)
+{
+       DEBUG(5, ("wbsrv_samba3_getgrnam called\n"));
+       s3call->response.result = WINBINDD_ERROR;
+       return NT_STATUS_OK;
+}
+
+NTSTATUS wbsrv_samba3_getgrgid(struct wbsrv_samba3_call *s3call)
+{
+       DEBUG(5, ("wbsrv_samba3_getgrgid called\n"));
+       s3call->response.result = WINBINDD_ERROR;
+       return NT_STATUS_OK;
+}
+
+NTSTATUS wbsrv_samba3_getgroups(struct wbsrv_samba3_call *s3call)
+{
+       DEBUG(5, ("wbsrv_samba3_getgroups called\n"));
+       s3call->response.result = WINBINDD_ERROR;
+       return NT_STATUS_OK;
+}
+
+NTSTATUS wbsrv_samba3_setgrent(struct wbsrv_samba3_call *s3call)
+{
+       DEBUG(5, ("wbsrv_samba3_setgrent called\n"));
+       s3call->response.result = WINBINDD_OK;
+       return NT_STATUS_OK;
+}
+
+NTSTATUS wbsrv_samba3_getgrent(struct wbsrv_samba3_call *s3call)
+{
+       DEBUG(5, ("wbsrv_samba3_getgrent called\n"));
+       s3call->response.result = WINBINDD_ERROR;
+       return NT_STATUS_OK;
+}
+
+NTSTATUS wbsrv_samba3_endgrent(struct wbsrv_samba3_call *s3call)
+{
+       DEBUG(5, ("wbsrv_samba3_endgrent called\n"));
+       s3call->response.result = WINBINDD_OK;
+       return NT_STATUS_OK;
+}
+
+static void sid2uid_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_sid2uid(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+       struct dom_sid *sid;
+
+       DEBUG(5, ("wbsrv_samba3_sid2uid called\n"));
+
+       sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
+       NT_STATUS_HAVE_NO_MEMORY(sid);
+
+       ctx = wb_sid2uid_send(s3call, service, sid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = sid2uid_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+
+}
+
+static void sid2uid_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+
+       DEBUG(5, ("sid2uid_recv called\n"));
+
+       status = wb_sid2uid_recv(ctx, &s3call->response.data.uid);
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+static void sid2gid_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_sid2gid(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+       struct dom_sid *sid;
+
+       DEBUG(5, ("wbsrv_samba3_sid2gid called\n"));
+
+       sid = dom_sid_parse_talloc(s3call, s3call->request.data.sid);
+       NT_STATUS_HAVE_NO_MEMORY(sid);
+
+       ctx = wb_sid2gid_send(s3call, service, sid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = sid2gid_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+
+}
+
+static void sid2gid_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+
+       DEBUG(5, ("sid2gid_recv called\n"));
+
+       status = wb_sid2gid_recv(ctx, &s3call->response.data.gid);
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+static void uid2sid_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_uid2sid(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_uid2sid called\n"));
+
+       ctx = wb_uid2sid_send(s3call, service, s3call->request.data.uid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = uid2sid_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+
+}
+
+static void uid2sid_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+       struct dom_sid *sid;
+       char *sid_str;
+
+       DEBUG(5, ("uid2sid_recv called\n"));
+
+       status = wb_uid2sid_recv(ctx, s3call, &sid);
+       if(NT_STATUS_IS_OK(status)) {
+               sid_str = dom_sid_string(s3call, sid);
+
+               /* If the conversion failed, bail out with a failure. */
+               if (sid_str == NULL)
+                       wbsrv_samba3_async_epilogue(NT_STATUS_NO_MEMORY,s3call);
+
+               /* But we assume this worked, so we'll set the string. Work
+                * done. */
+               WBSRV_SAMBA3_SET_STRING(s3call->response.data.sid.sid, sid_str);
+               s3call->response.data.sid.type = SID_NAME_USER;
+       }
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+
+static void gid2sid_recv(struct composite_context *ctx);
+
+NTSTATUS wbsrv_samba3_gid2sid(struct wbsrv_samba3_call *s3call)
+{
+       struct composite_context *ctx;
+       struct wbsrv_service *service =
+               s3call->wbconn->listen_socket->service;
+
+       DEBUG(5, ("wbsrv_samba3_gid2sid called\n"));
+
+       ctx = wb_gid2sid_send(s3call, service, s3call->request.data.gid);
+       NT_STATUS_HAVE_NO_MEMORY(ctx);
+
+       ctx->async.fn = gid2sid_recv;
+       ctx->async.private_data = s3call;
+       s3call->flags |= WBSRV_CALL_FLAGS_REPLY_ASYNC;
+       return NT_STATUS_OK;
+
+}
+
+static void gid2sid_recv(struct composite_context *ctx)
+{
+       struct wbsrv_samba3_call *s3call =
+               talloc_get_type(ctx->async.private_data,
+                               struct wbsrv_samba3_call);
+       NTSTATUS status;
+       struct dom_sid *sid;
+       char *sid_str;
+
+       DEBUG(5, ("gid2sid_recv called\n"));
+
+       status = wb_gid2sid_recv(ctx, s3call, &sid);
+       if(NT_STATUS_IS_OK(status)) {
+               sid_str = dom_sid_string(s3call, sid);
+
+               if (sid_str == NULL)
+                       wbsrv_samba3_async_epilogue(NT_STATUS_NO_MEMORY,s3call);
+
+               WBSRV_SAMBA3_SET_STRING(s3call->response.data.sid.sid, sid_str);
+               s3call->response.data.sid.type = SID_NAME_DOMAIN;
+       }
+
+       wbsrv_samba3_async_epilogue(status, s3call);
+}
+