wb_samba3_cmd.c

samba最新软件

}

/* 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;
	struct cli_credentials *credentials;
	char *user, *domain;

	if (!wb_samba3_split_username(s3call, s3call->wbconn->lp_ctx,
				 s3call->request.data.auth.user,
				 &domain, &user)) {
		return NT_STATUS_NO_SUCH_USER;
	}

	credentials = cli_credentials_init(s3call);
	if (!credentials) {
		return NT_STATUS_NO_MEMORY;
	}
	cli_credentials_set_conf(credentials, service->task->lp_ctx);
	cli_credentials_set_domain(credentials, domain, CRED_SPECIFIED);
	cli_credentials_set_username(credentials, user, CRED_SPECIFIED);

	cli_credentials_set_password(credentials, s3call->request.data.auth.pass, CRED_SPECIFIED);

	ctx = wb_cmd_pam_auth_send(s3call, service, credentials);
	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;
		if (extra_data) {
			s3call->response.length += 1;
		}
	}

	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);
}