plaintext, password_state);
if (NT_STATUS_IS_OK(result)) {
/* We have tried mapping */
- (*user_info)->mapped_state = True;
+ (*user_info)->mapped_state = true;
/* did we actually map the user to a different name? */
(*user_info)->was_mapped = was_mapped;
}
if (NT_STATUS_IS_OK(status)) {
(*user_info)->logon_parameters = logon_parameters;
}
- ret = NT_STATUS_IS_OK(status) ? True : False;
+ ret = NT_STATUS_IS_OK(status) ? true : false;
data_blob_free(&lm_blob);
data_blob_free(&nt_blob);
(*user_info)->logon_parameters = logon_parameters;
}
- ret = NT_STATUS_IS_OK(nt_status) ? True : False;
+ ret = NT_STATUS_IS_OK(nt_status) ? true : false;
data_blob_free(&local_lm_blob);
data_blob_free(&local_nt_blob);
return ret;
(const char *)plaintext_password.data,
plaintext_password.length);
if (!plaintext_password_string) {
- return False;
+ return false;
}
ret = make_user_info_map(
}
data_blob_free(&local_lm_blob);
- return NT_STATUS_IS_OK(ret) ? True : False;
+ return NT_STATUS_IS_OK(ret) ? true : false;
}
/****************************************************************************
}
/****************************************************************************
- Create a guest user_info blob, for anonymous authenticaion.
+ Create a guest user_info blob, for anonymous authentication.
****************************************************************************/
bool make_user_info_guest(const struct tsocket_address *remote_address,
NULL,
AUTH_PASSWORD_RESPONSE);
- return NT_STATUS_IS_OK(nt_status) ? True : False;
+ return NT_STATUS_IS_OK(nt_status) ? true : false;
}
static NTSTATUS log_nt_token(struct security_token *token)
NTSTATUS create_local_token(TALLOC_CTX *mem_ctx,
const struct auth_serversupplied_info *server_info,
DATA_BLOB *session_key,
+ const char *smb_username, /* for ->sanitized_username, for %U subs */
struct auth_session_info **session_info_out)
{
struct security_token *t;
struct dom_sid tmp_sid;
struct auth_session_info *session_info;
struct wbcUnixId *ids;
+ fstring tmp;
/* Ensure we can't possible take a code path leading to a
* null defref. */
return NT_STATUS_LOGON_FAILURE;
}
- session_info = make_auth_session_info(mem_ctx);
+ session_info = talloc_zero(mem_ctx, struct auth_session_info);
if (!session_info) {
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_MEMORY;
}
- session_info->unix_info->sanitized_username = talloc_strdup(session_info, server_info->sanitized_username);
- if (!session_info->unix_info->sanitized_username) {
- TALLOC_FREE(session_info);
- return NT_STATUS_NO_MEMORY;
- }
+ /* This is a potentially untrusted username for use in %U */
+ alpha_strcpy(tmp, smb_username, ". _-$", sizeof(tmp));
+ session_info->unix_info->sanitized_username =
+ talloc_strdup(session_info->unix_info, tmp);
- session_info->unix_info->guest = server_info->guest;
session_info->unix_info->system = server_info->system;
if (session_key) {
if (((lp_server_role() == ROLE_DOMAIN_MEMBER) && !winbind_ping()) ||
(server_info->nss_token)) {
+ char *found_username = NULL;
status = create_token_from_username(session_info,
server_info->unix_name,
server_info->guest,
&session_info->unix_token->uid,
&session_info->unix_token->gid,
- &session_info->unix_info->unix_name,
+ &found_username,
&session_info->security_token);
-
+ if (NT_STATUS_IS_OK(status)) {
+ session_info->unix_info->unix_name = found_username;
+ }
} else {
status = create_local_nt_token_from_info3(session_info,
server_info->guest,
}
result->unix_name = talloc_strdup(result, unix_username);
- result->sanitized_username = sanitize_username(result, unix_username);
- if ((result->unix_name == NULL)
- || (result->sanitized_username == NULL)) {
+ if (result->unix_name == NULL) {
TALLOC_FREE(result);
return NT_STATUS_NO_MEMORY;
}
return NT_STATUS_NO_SUCH_USER;
}
- /* Set acount name */
+ /* Set account name */
tmp = talloc_strdup(mem_ctx, pwd->pw_name);
if (tmp == NULL) {
return NT_STATUS_NO_MEMORY;
The resulting structure is a 'session_info' because
create_local_token() has already been called on it. This is quite
- nasty, as the auth subsystem isn't expect this, but the behaviour is
+ nasty, as the auth subsystem isn't expect this, but the behavior is
left as-is for now.
***************************************************************************/
struct netr_SamInfo3 info3;
TALLOC_CTX *tmp_ctx;
NTSTATUS status;
- fstring tmp;
tmp_ctx = talloc_stackframe();
if (tmp_ctx == NULL) {
goto done;
}
- (*server_info)->guest = True;
+ (*server_info)->guest = true;
/* This should not be done here (we should produce a server
* info, and later construct a session info from it), but for
- * now this does not change the previous behaviours */
- status = create_local_token(tmp_ctx, *server_info, NULL, session_info);
+ * now this does not change the previous behavior */
+ status = create_local_token(tmp_ctx, *server_info, NULL,
+ (*server_info)->info3->base.account_name.string,
+ session_info);
if (!NT_STATUS_IS_OK(status)) {
DEBUG(0, ("create_local_token failed: %s\n",
nt_errstr(status)));
all zeros! */
(*session_info)->session_key = data_blob(zeros, sizeof(zeros));
- alpha_strcpy(tmp, (*server_info)->info3->base.account_name.string,
- ". _-$", sizeof(tmp));
- (*session_info)->unix_info->sanitized_username = talloc_strdup(*session_info, tmp);
-
status = NT_STATUS_OK;
done:
TALLOC_FREE(tmp_ctx);
status = make_server_info_pw(&result, pwd->pw_name, pwd);
- TALLOC_FREE(pwd);
-
if (!NT_STATUS_IS_OK(status)) {
+ TALLOC_FREE(pwd);
return status;
}
result->guest = is_guest;
/* Now turn the server_info into a session_info with the full token etc */
- status = create_local_token(mem_ctx, result, NULL, session_info);
+ status = create_local_token(mem_ctx, result, NULL, pwd->pw_name, session_info);
+ TALLOC_FREE(pwd);
talloc_free(result);
return status;
}
/* This element must be provided to convert back to an auth_serversupplied_info */
SMB_ASSERT(src->unix_info);
- dst->guest = src->unix_info->guest;
- dst->system = src->unix_info->system;
+ dst->guest = true;
+ dst->system = false;
/* This element must be provided to convert back to an
- * auth_serversupplied_info. This needs to be from hte
+ * auth_serversupplied_info. This needs to be from the
* auth_session_info because the group values in particular
* may change during create_local_token() processing */
SMB_ASSERT(src->unix_token);
return NULL;
}
- dst->sanitized_username = talloc_strdup(dst, src->unix_info->sanitized_username);
- if (!dst->sanitized_username) {
- TALLOC_FREE(dst);
- return NULL;
- }
-
return dst;
}
bool init_guest_info(void)
{
if (guest_info != NULL)
- return True;
+ return true;
return NT_STATUS_IS_OK(make_new_session_info_guest(&guest_info, &guest_server_info));
}
groups = (gid_t *)memdup(src->ut.groups,
sizeof(gid_t) * src->ut.ngroups);
if ((src->ut.ngroups != 0) && (groups == NULL)) {
- return False;
+ return false;
}
nt_token = dup_nt_token(NULL, src->nt_user_token);
if (nt_token == NULL) {
SAFE_FREE(groups);
- return False;
+ return false;
}
dst->conn = src->conn;
dst->ut.ngroups = src->ut.ngroups;
dst->ut.groups = groups;
dst->nt_user_token = nt_token;
- return True;
+ return true;
}
/***************************************************************************
return NT_STATUS_NO_MEMORY;
}
- passwd = smb_getpwnam(mem_ctx, dom_user, &real_username, True );
+ passwd = smb_getpwnam(mem_ctx, dom_user, &real_username, true );
if (!passwd) {
DEBUG(3, ("Failed to find authenticated user %s via "
"getpwnam(), denying access.\n", dom_user));
*pwd = passwd;
- /* This is pointless -- there is no suport for differing
+ /* This is pointless -- there is no support for differing
unix and windows names. Make sure to always store the
one we actually looked up and succeeded. Have I mentioned
why I hate the 'winbind use default domain' parameter?
result->unix_name = talloc_strdup(result, found_username);
- result->sanitized_username = sanitize_username(result,
- result->unix_name);
- if (result->sanitized_username == NULL) {
- TALLOC_FREE(result);
- return NT_STATUS_NO_MEMORY;
- }
-
/* copy in the info3 */
result->info3 = i3 = copy_netr_SamInfo3(result, info3);
if (result->info3 == NULL) {
result->utok.gid = pwd->pw_gid;
/* We can't just trust that the primary group sid sent us is something
- * we can really use. Obtain the useable sid, and store the original
+ * we can really use. Obtain the usable sid, and store the original
* one as an additional group if it had to be replaced */
nt_status = get_primary_group_sid(mem_ctx, found_username,
&pwd, &group_sid);
/* no trusted domains for a standalone server */
if ( lp_server_role() == ROLE_STANDALONE )
- return False;
+ return false;
if (dom_name == NULL || dom_name[0] == '\0') {
return false;
ret = pdb_get_trusteddom_pw(dom_name, NULL, NULL, NULL);
unbecome_root();
if (ret)
- return True;
+ return true;
}
else {
wbcErr result;
result = wb_is_trusted_domain(dom_name);
if (result == WBC_ERR_SUCCESS) {
- return True;
+ return true;
}
if (result == WBC_ERR_DOMAIN_NOT_FOUND) {
/* winbind could not find the domain */
- return False;
+ return false;
}
/* The only other possible result is that winbind is not up
* domains (like a domain member would use */
if ( trustdom_cache_fetch(dom_name, &trustdom_sid) ) {
- return True;
+ return true;
}
- return False;
+ return false;
}
+
+
+/*
+ on a logon error possibly map the error to success if "map to guest"
+ is set approriately
+*/
+NTSTATUS do_map_to_guest_server_info(NTSTATUS status,
+ struct auth_serversupplied_info **server_info,
+ const char *user, const char *domain)
+{
+ user = user ? user : "";
+ domain = domain ? domain : "";
+
+ if (NT_STATUS_EQUAL(status, NT_STATUS_NO_SUCH_USER)) {
+ if ((lp_map_to_guest() == MAP_TO_GUEST_ON_BAD_USER) ||
+ (lp_map_to_guest() == MAP_TO_GUEST_ON_BAD_PASSWORD)) {
+ DEBUG(3,("No such user %s [%s] - using guest account\n",
+ user, domain));
+ status = make_server_info_guest(NULL, server_info);
+ }
+ } else if (NT_STATUS_EQUAL(status, NT_STATUS_WRONG_PASSWORD)) {
+ if (lp_map_to_guest() == MAP_TO_GUEST_ON_BAD_PASSWORD) {
+ DEBUG(3,("Registered username %s for guest access\n",
+ user));
+ status = make_server_info_guest(NULL, server_info);
+ }
+ }
+
+ return status;
+}
git.samba.org / kai / samba-autobuild / .git / blobdiff