auth.c

samba最新软件

	nt_status = NT_STATUS_NO_SUCH_USER; /* If all the modules say 'not for me', then this is reasonable */
	for (method = auth_ctx->methods; method; method = method->next) {
		NTSTATUS result;
		struct timed_event *te = NULL;

		/* check if the module wants to chek the password */
		result = method->ops->want_check(method, req, user_info);
		if (NT_STATUS_EQUAL(result, NT_STATUS_NOT_IMPLEMENTED)) {
			DEBUG(11,("auth_check_password_send: %s had nothing to say\n", method->ops->name));
			continue;
		}

		nt_status = result;
		req->method	= method;

		if (!NT_STATUS_IS_OK(nt_status)) break;

		te = event_add_timed(auth_ctx->event_ctx, req,
				     timeval_zero(),
				     auth_check_password_async_timed_handler, req);
		if (!te) {
			nt_status = NT_STATUS_NO_MEMORY;
			goto failed;
		}
		return;
	}

failed:
	req->status = nt_status;
	req->callback.fn(req, req->callback.private_data);
}

/**
 * Check a user's Plaintext, LM or NTLM password.
 * async receive function
 *
 * The return value takes precedence over the contents of the server_info 
 * struct.  When the return is other than NT_STATUS_OK the contents 
 * of that structure is undefined.
 *
 *
 * @param req The async auth_check_password state, passes to the callers callback function
 *
 * @param mem_ctx The parent memory context for the server_info structure
 *
 * @param server_info If successful, contains information about the authentication, 
 *                    including a SAM_ACCOUNT struct describing the user.
 *
 * @return An NTSTATUS with NT_STATUS_OK or an appropriate error.
 *
 **/

_PUBLIC_ NTSTATUS auth_check_password_recv(struct auth_check_password_request *req,
				  TALLOC_CTX *mem_ctx,
				  struct auth_serversupplied_info **server_info)
{
	NTSTATUS status;

	NT_STATUS_HAVE_NO_MEMORY(req);

	if (NT_STATUS_IS_OK(req->status)) {
		DEBUG(5,("auth_check_password_recv: %s authentication for user [%s\\%s] succeeded\n",
			 req->method->ops->name, req->server_info->domain_name, req->server_info->account_name));

		*server_info = talloc_steal(mem_ctx, req->server_info);
	} else {
		DEBUG(2,("auth_check_password_recv: %s authentication for user [%s\\%s] FAILED with error %s\n", 
			 (req->method ? req->method->ops->name : "NO_METHOD"),
			 req->user_info->mapped.domain_name,
			 req->user_info->mapped.account_name, 
			 nt_errstr(req->status)));
	}

	status = req->status;
	talloc_free(req);
	return status;
}

/***************************************************************************
 Make a auth_info struct for the auth subsystem
 - Allow the caller to specify the methods to use
***************************************************************************/
_PUBLIC_ NTSTATUS auth_context_create_methods(TALLOC_CTX *mem_ctx, const char **methods, 
				     struct event_context *ev,
				     struct messaging_context *msg,
				     struct loadparm_context *lp_ctx,
				     struct auth_context **auth_ctx)
{
	int i;
	struct auth_context *ctx;

	if (!methods) {
		DEBUG(0,("auth_context_create: No auth method list!?\n"));
		return NT_STATUS_INTERNAL_ERROR;
	}

	if (!ev) {
		DEBUG(0,("auth_context_create: called with out event context\n"));
		return NT_STATUS_INTERNAL_ERROR;
	}

	if (!msg) {
		DEBUG(0,("auth_context_create: called with out messaging context\n"));
		return NT_STATUS_INTERNAL_ERROR;
	}

	ctx = talloc(mem_ctx, struct auth_context);
	NT_STATUS_HAVE_NO_MEMORY(ctx);
	ctx->challenge.set_by		= NULL;
	ctx->challenge.may_be_modified	= false;
	ctx->challenge.data		= data_blob(NULL, 0);
	ctx->methods			= NULL;
	ctx->event_ctx			= ev;
	ctx->msg_ctx			= msg;
	ctx->lp_ctx			= lp_ctx;

	for (i=0; methods[i] ; i++) {
		struct auth_method_context *method;

		method = talloc(ctx, struct auth_method_context);
		NT_STATUS_HAVE_NO_MEMORY(method);

		method->ops = auth_backend_byname(methods[i]);
		if (!method->ops) {
			DEBUG(1,("auth_context_create: failed to find method=%s\n",
				methods[i]));
			return NT_STATUS_INTERNAL_ERROR;
		}
		method->auth_ctx	= ctx;
		method->depth		= i;
		DLIST_ADD_END(ctx->methods, method, struct auth_method_context *);
	}

	if (!ctx->methods) {
		return NT_STATUS_INTERNAL_ERROR;
	}

	*auth_ctx = ctx;

	return NT_STATUS_OK;
}
/***************************************************************************
 Make a auth_info struct for the auth subsystem
 - Uses default auth_methods, depending on server role and smb.conf settings
***************************************************************************/
_PUBLIC_ NTSTATUS auth_context_create(TALLOC_CTX *mem_ctx, 
			     struct event_context *ev,
			     struct messaging_context *msg,
			     struct loadparm_context *lp_ctx,
			     struct auth_context **auth_ctx)
{
	const char **auth_methods = NULL;
	switch (lp_server_role(lp_ctx)) {
	case ROLE_STANDALONE:
		auth_methods = lp_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "standalone", NULL);
		break;
	case ROLE_DOMAIN_MEMBER:
		auth_methods = lp_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "member server", NULL);
		break;
	case ROLE_DOMAIN_CONTROLLER:
		auth_methods = lp_parm_string_list(mem_ctx, lp_ctx, NULL, "auth methods", "domain controller", NULL);
		break;
	}
	return auth_context_create_methods(mem_ctx, auth_methods, ev, msg, lp_ctx, auth_ctx);
}


/* the list of currently registered AUTH backends */
static struct auth_backend {
	const struct auth_operations *ops;
} *backends = NULL;
static int num_backends;

/*
  register a AUTH backend. 

  The 'name' can be later used by other backends to find the operations
  structure for this backend.
*/
_PUBLIC_ NTSTATUS auth_register(const struct auth_operations *ops)
{
	struct auth_operations *new_ops;
	
	if (auth_backend_byname(ops->name) != NULL) {
		/* its already registered! */
		DEBUG(0,("AUTH backend '%s' already registered\n", 
			 ops->name));
		return NT_STATUS_OBJECT_NAME_COLLISION;
	}

	backends = talloc_realloc(talloc_autofree_context(), backends, 
				  struct auth_backend, num_backends+1);
	NT_STATUS_HAVE_NO_MEMORY(backends);

	new_ops = talloc_memdup(backends, ops, sizeof(*ops));
	NT_STATUS_HAVE_NO_MEMORY(new_ops);
	new_ops->name = talloc_strdup(new_ops, ops->name);
	NT_STATUS_HAVE_NO_MEMORY(new_ops->name);

	backends[num_backends].ops = new_ops;

	num_backends++;

	DEBUG(3,("AUTH backend '%s' registered\n", 
		 ops->name));

	return NT_STATUS_OK;
}

/*
  return the operations structure for a named backend of the specified type
*/
const struct auth_operations *auth_backend_byname(const char *name)
{
	int i;

	for (i=0;i<num_backends;i++) {
		if (strcmp(backends[i].ops->name, name) == 0) {
			return backends[i].ops;
		}
	}

	return NULL;
}

/*
  return the AUTH interface version, and the size of some critical types
  This can be used by backends to either detect compilation errors, or provide
  multiple implementations for different smbd compilation options in one module
*/
const struct auth_critical_sizes *auth_interface_version(void)
{
	static const struct auth_critical_sizes critical_sizes = {
		AUTH_INTERFACE_VERSION,
		sizeof(struct auth_operations),
		sizeof(struct auth_method_context),
		sizeof(struct auth_context),
		sizeof(struct auth_usersupplied_info),
		sizeof(struct auth_serversupplied_info)
	};

	return &critical_sizes;
}

_PUBLIC_ NTSTATUS auth_init(void)
{
	static bool initialized = false;
	extern NTSTATUS auth_developer_init(void);
	extern NTSTATUS auth_winbind_init(void);
	extern NTSTATUS auth_anonymous_init(void);
	extern NTSTATUS auth_unix_init(void);
	extern NTSTATUS auth_sam_init(void);
	extern NTSTATUS auth_server_init(void);

	init_module_fn static_init[] = { STATIC_auth_MODULES };
	
	if (initialized) return NT_STATUS_OK;
	initialized = true;
	
	run_init_functions(static_init);
	
	return NT_STATUS_OK;	
}

NTSTATUS server_service_auth_init(void)
{
	return auth_init();
}