samba-mirror/source3/nsswitch/winbindd_user.c

/* 
   Unix SMB/Netbios implementation.
   Version 2.2

   Winbind daemon - user related functions

   Copyright (C) Tim Potter 2000
   Copyright (C) Jeremy Allison 2001.
   
   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
   (at your option) any later version.
   
   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   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.
*/

#include "winbindd.h"

/* Fill a pwent structure with information we have obtained */

static BOOL winbindd_fill_pwent(char *domain_name, char *name, 
				uint32 user_rid, uint32 group_rid, 
				char *full_name, struct winbindd_pw *pw)
{
	extern userdom_struct current_user_info;
	fstring name_domain, name_user;
	pstring homedir;
	
	if (!pw || !name)
		return False;
	
	/* Resolve the uid number */
	
	if (!winbindd_idmap_get_uid_from_rid(domain_name, user_rid, 
					     &pw->pw_uid)) {
		DEBUG(1, ("error getting user id for rid %d\n", user_rid));
		return False;
	}
	
	/* Resolve the gid number */   
	
	if (!winbindd_idmap_get_gid_from_rid(domain_name, group_rid, 
					     &pw->pw_gid)) {
		DEBUG(1, ("error getting group id for rid %d\n", group_rid));
		return False;
	}

	/* Username */
	
	safe_strcpy(pw->pw_name, name, sizeof(pw->pw_name) - 1);
	
	/* Full name (gecos) */
	
	safe_strcpy(pw->pw_gecos, full_name, sizeof(pw->pw_gecos) - 1);

	/* Home directory and shell - use template config parameters.  The
	   defaults are /tmp for the home directory and /bin/false for
	   shell. */
	
	parse_domain_user(name, name_domain, name_user);
	
	/* The substitution of %U and %D in the 'template homedir' is done
	   by lp_string() calling standard_sub_basic(). */

	fstrcpy(current_user_info.smb_name, name_user);
	fstrcpy(current_user_info.domain, name_domain);

	pstrcpy(homedir, lp_template_homedir());
	
	safe_strcpy(pw->pw_dir, homedir, sizeof(pw->pw_dir) - 1);
	
	safe_strcpy(pw->pw_shell, lp_template_shell(), 
		    sizeof(pw->pw_shell) - 1);
	
	/* Password - set to "x" as we can't generate anything useful here.
	   Authentication can be done using the pam_ntdom module. */

	safe_strcpy(pw->pw_passwd, "x", sizeof(pw->pw_passwd) - 1);
	
	return True;
}

/************************************************************************
 Empty static struct for negative caching.
*************************************************************************/

static struct winbindd_pw negative_pw_cache_entry;

/* Return a password structure from a username.  Specify whether cached data 
   can be returned. */

enum winbindd_result winbindd_getpwnam_from_user(struct winbindd_cli_state *state) 
{
	uint32 user_rid, group_rid;
	SAM_USERINFO_CTR *user_info;
	DOM_SID user_sid;
	fstring name_domain, name_user, name, gecos_name;
	enum SID_NAME_USE name_type;
	struct winbindd_domain *domain;
	TALLOC_CTX *mem_ctx;
	
	DEBUG(3, ("[%5d]: getpwnam %s\n", state->pid,
		  state->request.data.username));
	
	/* Parse domain and username */

	parse_domain_user(state->request.data.username, name_domain, 
			  name_user);

	/* Reject names that don't have a domain - i.e name_domain contains 
	   the entire name. */
 
	if (strequal(name_domain, ""))
		return WINBINDD_ERROR;
	
	if ((domain = find_domain_from_name(name_domain)) == NULL) {
		DEBUG(5, ("No such domain: %s\n", name_domain));
		return WINBINDD_ERROR;
	}

	/* Check for cached user entry */

	if (winbindd_fetch_user_cache_entry(domain, name_user, &state->response.data.pw)) {
		/* Check if this is a negative cache entry. */
		if (memcmp(&negative_pw_cache_entry, &state->response.data.pw,
						sizeof(state->response.data.pw)) == 0)
			return WINBINDD_ERROR;
		return WINBINDD_OK;
	}

	slprintf(name, sizeof(name) - 1, "%s\\%s", name_domain, name_user);
	
	/* Get rid and name type from name */

	if (!winbindd_lookup_sid_by_name(name, &user_sid, &name_type)) {
		DEBUG(1, ("user '%s' does not exist\n", name_user));
		winbindd_store_user_cache_entry(domain, name_user, &negative_pw_cache_entry);
		return WINBINDD_ERROR;
	}

	if (name_type != SID_NAME_USER) {
		DEBUG(1, ("name '%s' is not a user name: %d\n", name_user, 
			  name_type));
		winbindd_store_user_cache_entry(domain, name_user, &negative_pw_cache_entry);
		return WINBINDD_ERROR;
	}
	
	/* Get some user info.  Split the user rid from the sid obtained
	   from the winbind_lookup_by_name() call and use it in a
	   winbind_lookup_userinfo() */
    
	if (!(mem_ctx = talloc_init())) {
		DEBUG(1, ("out of memory\n"));
		return WINBINDD_ERROR;
	}

	sid_split_rid(&user_sid, &user_rid);
	
	if (!winbindd_lookup_userinfo(domain, mem_ctx, user_rid, &user_info)) {
		DEBUG(1, ("pwnam_from_user(): error getting user info for "
			  "user '%s'\n", name_user));
		winbindd_store_user_cache_entry(domain, name_user, &negative_pw_cache_entry);
		return WINBINDD_ERROR;
	}
    
	group_rid = user_info->info.id21->group_rid;

	unistr2_to_ascii(gecos_name, &user_info->info.id21->uni_full_name,
			 sizeof(gecos_name) - 1);

	talloc_destroy(mem_ctx);
	user_info = NULL;

	/* Now take all this information and fill in a passwd structure */
	
	if (!winbindd_fill_pwent(name_domain, state->request.data.username, 
				 user_rid, group_rid, gecos_name,
				 &state->response.data.pw)) {
		winbindd_store_user_cache_entry(domain, name_user, &negative_pw_cache_entry);
		return WINBINDD_ERROR;
	}
	
	winbindd_store_user_cache_entry(domain, name_user, &state->response.data.pw);
	
	return WINBINDD_OK;
}       

/* Return a password structure given a uid number */

enum winbindd_result winbindd_getpwnam_from_uid(struct winbindd_cli_state *state)
{
	DOM_SID user_sid;
	struct winbindd_domain *domain;
	uint32 user_rid, group_rid;
	fstring user_name, gecos_name;
	enum SID_NAME_USE name_type;
	SAM_USERINFO_CTR *user_info;
	gid_t gid;
	TALLOC_CTX *mem_ctx;
	
	/* Bug out if the uid isn't in the winbind range */

	if ((state->request.data.uid < server_state.uid_low ) ||
	    (state->request.data.uid > server_state.uid_high))
		return WINBINDD_ERROR;

	DEBUG(3, ("[%5d]: getpwuid %d\n", state->pid, 
		  state->request.data.uid));
	
	/* Get rid from uid */

	if (!winbindd_idmap_get_rid_from_uid(state->request.data.uid, 
					     &user_rid, &domain)) {
		DEBUG(1, ("Could not convert uid %d to rid\n", 
			  state->request.data.uid));
		return WINBINDD_ERROR;
	}
	
	/* Check for cached uid entry */

	if (winbindd_fetch_uid_cache_entry(domain, 
					   state->request.data.uid,
					   &state->response.data.pw)) {
		/* Check if this is a negative cache entry. */
		if (memcmp(&negative_pw_cache_entry, &state->response.data.pw,
						sizeof(state->response.data.pw)) == 0)
			return WINBINDD_ERROR;
		return WINBINDD_OK;
	}

	/* Get name and name type from rid */

	sid_copy(&user_sid, &domain->sid);
	sid_append_rid(&user_sid, user_rid);
	
	if (!winbindd_lookup_name_by_sid(&user_sid, user_name, &name_type)) {
		fstring temp;
		
		sid_to_string(temp, &user_sid);
		DEBUG(1, ("Could not lookup sid %s\n", temp));

		winbindd_store_uid_cache_entry(domain, state->request.data.uid, &negative_pw_cache_entry);
		return WINBINDD_ERROR;
	}
	
	if (strcmp("\\", lp_winbind_separator()))
		string_sub(user_name, "\\", lp_winbind_separator(), 
			   sizeof(fstring));

	/* Get some user info */
	
	if (!(mem_ctx = talloc_init())) {
		DEBUG(1, ("out of memory\n"));
		return WINBINDD_ERROR;
	}

	if (!winbindd_lookup_userinfo(domain, mem_ctx, user_rid, &user_info)) {
		DEBUG(1, ("pwnam_from_uid(): error getting user info for "
			  "user '%s'\n", user_name));
		winbindd_store_uid_cache_entry(domain, state->request.data.uid, &negative_pw_cache_entry);
		return WINBINDD_ERROR;
	}
	
	group_rid = user_info->info.id21->group_rid;
	unistr2_to_ascii(gecos_name, &user_info->info.id21->uni_full_name,
			 sizeof(gecos_name) - 1);

	talloc_destroy(mem_ctx);
	user_info = NULL;

	/* Resolve gid number */

	if (!winbindd_idmap_get_gid_from_rid(domain->name, group_rid, &gid)) {
		DEBUG(1, ("error getting group id for user %s\n", user_name));
		return WINBINDD_ERROR;
	}

	/* Fill in password structure */

	if (!winbindd_fill_pwent(domain->name, user_name, user_rid, group_rid,
				 gecos_name, &state->response.data.pw)) {
		winbindd_store_uid_cache_entry(domain, state->request.data.uid, &negative_pw_cache_entry);
		return WINBINDD_ERROR;
	}
	
	winbindd_store_uid_cache_entry(domain, state->request.data.uid, &state->response.data.pw);
	
	return WINBINDD_OK;
}

/*
 * set/get/endpwent functions
 */

/* Rewind file pointer for ntdom passwd database */

enum winbindd_result winbindd_setpwent(struct winbindd_cli_state *state)
{
	struct winbindd_domain *tmp;
        
	DEBUG(3, ("[%5d]: setpwent\n", state->pid));
        
	/* Check user has enabled this */
        
	if (!lp_winbind_enum_users())
		return WINBINDD_ERROR;

	/* Free old static data if it exists */
        
	if (state->getpwent_state != NULL) {
		free_getent_state(state->getpwent_state);
		state->getpwent_state = NULL;
	}
        
	/* Create sam pipes for each domain we know about */
        
	if (domain_list == NULL)
		get_domain_info();

	for(tmp = domain_list; tmp != NULL; tmp = tmp->next) {
		struct getent_state *domain_state;
                
		/*
		 * Skip domains other than WINBINDD_DOMAIN environment
		 * variable.
		 */
                
		if ((strcmp(state->request.domain, "") != 0) &&
				!check_domain_env(state->request.domain, tmp->name))
			continue;

		/* Create a state record for this domain */
                
		if ((domain_state = (struct getent_state *)malloc(sizeof(struct getent_state))) == NULL)
			return WINBINDD_ERROR;
                
		ZERO_STRUCTP(domain_state);

		domain_state->domain = tmp;

		/* Add to list of open domains */
                
		DLIST_ADD(state->getpwent_state, domain_state);
	}
        
	return WINBINDD_OK;
}

/* Close file pointer to ntdom passwd database */

enum winbindd_result winbindd_endpwent(struct winbindd_cli_state *state)
{
	DEBUG(3, ("[%5d]: endpwent\n", state->pid));

	free_getent_state(state->getpwent_state);    
	state->getpwent_state = NULL;
        
	return WINBINDD_OK;
}

/* Get partial list of domain users for a domain.  We fill in the sam_entries,
   and num_sam_entries fields with domain user information.  The dispinfo_ndx
   field is incremented to the index of the next user to fetch.  Return True if
   some users were returned, False otherwise. */

#define MAX_FETCH_SAM_ENTRIES 100

static BOOL get_sam_user_entries(struct getent_state *ent)
{
	NTSTATUS status;
	uint32 num_entries;
	WINBIND_DISPINFO *info;
	struct getpwent_user *name_list = NULL;
	BOOL result = False;
	TALLOC_CTX *mem_ctx;
	struct winbindd_methods *methods;

	if (ent->got_all_sam_entries)
		return False;

	if (!(mem_ctx = talloc_init()))
		return False;

	methods = ent->domain->methods;

#if 0
	/* Look in cache for entries, else get them direct */
		    
	if (winbindd_fetch_user_cache(ent->domain,
				      (struct getpwent_user **)
				      &ent->sam_entries, 
				      &ent->num_sam_entries)) {
		return True;
	}
#endif

	/* Free any existing user info */

	SAFE_FREE(ent->sam_entries);
	ent->num_sam_entries = 0;
	
	/* Call query_dispinfo to get a list of usernames and user rids */

	do {
		int i;
					
		num_entries = 0;

		status = methods->query_dispinfo(ent->domain, mem_ctx,
						 &ent->dispinfo_ndx, 
						 &num_entries, &info);
		
		if (num_entries) {
			struct getpwent_user *tnl;

			tnl = (struct getpwent_user *)Realloc(name_list, 
					    sizeof(struct getpwent_user) *
					    (ent->num_sam_entries + 
					     num_entries));

			if (!tnl) {
				DEBUG(0,("get_sam_user_entries: Realloc failed.\n"));
				SAFE_FREE(name_list);
                                goto done;
			} else
				name_list = tnl;
		}

		for (i = 0; i < num_entries; i++) {
			/* Store account name and gecos */
			if (!info[i].acct_name) {
				fstrcpy(name_list[ent->num_sam_entries + i].name, "");
			} else {
				fstrcpy(name_list[ent->num_sam_entries + i].name, 
					info[i].acct_name); 
			}
			if (!info[i].full_name) {
				fstrcpy(name_list[ent->num_sam_entries + i].gecos, "");
			} else {
				fstrcpy(name_list[ent->num_sam_entries + i].gecos, 
					info[i].full_name); 
			}

			/* User and group ids */
			name_list[ent->num_sam_entries+i].user_rid = info[i].user_rid;
			name_list[ent->num_sam_entries+i].group_rid = info[i].group_rid;
		}
		
		ent->num_sam_entries += num_entries;

		if (NT_STATUS_V(status) != NT_STATUS_V(STATUS_MORE_ENTRIES))
			break;

	} while (ent->num_sam_entries < MAX_FETCH_SAM_ENTRIES);
	
#if 0
	/* Fill cache with received entries */
	
	winbindd_store_user_cache(ent->domain, ent->sam_entries, 
				  ent->num_sam_entries);
#endif

	/* Fill in remaining fields */
	
	ent->sam_entries = name_list;
	ent->sam_entry_index = 0;
	ent->got_all_sam_entries = (NT_STATUS_V(status) != NT_STATUS_V(STATUS_MORE_ENTRIES));

	result = ent->num_sam_entries > 0;

 done:

	talloc_destroy(mem_ctx);

	return result;
}

/* Fetch next passwd entry from ntdom database */

#define MAX_GETPWENT_USERS 500

enum winbindd_result winbindd_getpwent(struct winbindd_cli_state *state)
{
	struct getent_state *ent;
	struct winbindd_pw *user_list;
	int num_users, user_list_ndx = 0, i;
	char *sep;

	DEBUG(3, ("[%5d]: getpwent\n", state->pid));

	/* Check user has enabled this */

	if (!lp_winbind_enum_users())
		return WINBINDD_ERROR;

	/* Allocate space for returning a chunk of users */

	num_users = MIN(MAX_GETPWENT_USERS, state->request.data.num_entries);
	
	if ((state->response.extra_data = 
	     malloc(num_users * sizeof(struct winbindd_pw))) == NULL)
		return WINBINDD_ERROR;

	memset(state->response.extra_data, 0, num_users * 
	       sizeof(struct winbindd_pw));

	user_list = (struct winbindd_pw *)state->response.extra_data;
	sep = lp_winbind_separator();
	
	if (!(ent = state->getpwent_state))
		return WINBINDD_ERROR;

	/* Start sending back users */

	for (i = 0; i < num_users; i++) {
		struct getpwent_user *name_list = NULL;
		fstring domain_user_name;
		uint32 result;

		/* Do we need to fetch another chunk of users? */

		if (ent->num_sam_entries == ent->sam_entry_index) {

			while(ent && !get_sam_user_entries(ent)) {
				struct getent_state *next_ent;

				/* Free state information for this domain */

				SAFE_FREE(ent->sam_entries);

				next_ent = ent->next;
				DLIST_REMOVE(state->getpwent_state, ent);

				SAFE_FREE(ent);
				ent = next_ent;
			}
 
			/* No more domains */

			if (!ent) 
				break;
		}

		name_list = ent->sam_entries;

		/* Skip machine accounts */

		if (name_list[ent->sam_entry_index].
		    name[strlen(name_list[ent->sam_entry_index].name) - 1] 
		    == '$') {
			ent->sam_entry_index++;
			continue;
		}

		/* Lookup user info */
		
		slprintf(domain_user_name, sizeof(domain_user_name) - 1,
			 "%s%s%s", ent->domain->name, sep,
			 name_list[ent->sam_entry_index].name);
		
		result = winbindd_fill_pwent(
			ent->domain->name, 
			domain_user_name,
			name_list[ent->sam_entry_index].user_rid,
			name_list[ent->sam_entry_index].group_rid,
			name_list[ent->sam_entry_index].gecos,
			&user_list[user_list_ndx]);
		
		ent->sam_entry_index++;
		
		/* Add user to return list */
		
		if (result) {
				
			user_list_ndx++;
			state->response.data.num_entries++;
			state->response.length += 
				sizeof(struct winbindd_pw);

		} else
			DEBUG(1, ("could not lookup domain user %s\n",
				  domain_user_name));
	}

	/* Out of domains */

	return (user_list_ndx > 0) ? WINBINDD_OK : WINBINDD_ERROR;
}

/* List domain users without mapping to unix ids */

enum winbindd_result winbindd_list_users(struct winbindd_cli_state *state)
{
	struct winbindd_domain *domain;
	WINBIND_DISPINFO *info;
	uint32 num_entries = 0, total_entries = 0;
	char *ted, *extra_data = NULL;
	int extra_data_len = 0;
	TALLOC_CTX *mem_ctx;
	enum winbindd_result rv = WINBINDD_ERROR;

	DEBUG(3, ("[%5d]: list users\n", state->pid));

	if (!(mem_ctx = talloc_init()))
		return WINBINDD_ERROR;

	/* Enumerate over trusted domains */

	if (domain_list == NULL)
		get_domain_info();

	for (domain = domain_list; domain; domain = domain->next) {
		NTSTATUS status;
		uint32 start_ndx = 0;
		struct winbindd_methods *methods;

		/* Skip domains other than WINBINDD_DOMAIN environment
		   variable */ 

		if ((strcmp(state->request.domain, "") != 0) &&
		    !check_domain_env(state->request.domain, domain->name))
			continue;

		methods = domain->methods;

		/* Query display info */

		do {
			int i;

			status = methods->query_dispinfo(domain, mem_ctx, &start_ndx, 
							 &num_entries, &info);

			if (num_entries == 0)
				continue;

			/* Allocate some memory for extra data */
			total_entries += num_entries;
			
			ted = Realloc(extra_data, sizeof(fstring) * 
					     total_entries);
			
			if (!ted) {
				DEBUG(0,("winbindd_list_users: failed to enlarge buffer!\n"));
				SAFE_FREE(extra_data);
				goto done;
			} else 
				extra_data = ted;
			
			/* Pack user list into extra data fields */
			
			for (i = 0; i < num_entries; i++) {
				fstring acct_name, name;

				if (!info[i].acct_name) {
					fstrcpy(acct_name, "");
				} else {
					fstrcpy(acct_name, info[i].acct_name);
				}
                                                 
				slprintf(name, sizeof(name) - 1, "%s%s%s",
					 domain->name, lp_winbind_separator(),
					 acct_name);

				/* Append to extra data */
				memcpy(&extra_data[extra_data_len], name, 
				       strlen(name));
				extra_data_len += strlen(name);
				extra_data[extra_data_len++] = ',';
			}   
		} while (NT_STATUS_V(status) == NT_STATUS_V(STATUS_MORE_ENTRIES));
        }

	/* Assign extra_data fields in response structure */

	if (extra_data) {
		extra_data[extra_data_len - 1] = '\0';
		state->response.extra_data = extra_data;
		state->response.length += extra_data_len;
	}

	/* No domains responded but that's still OK so don't return an
	   error. */

	rv = WINBINDD_OK;

 done:

	talloc_destroy(mem_ctx);

	return rv;
}