BUG 1023: surround get_group_from_gid() with become_unbecome_root() block

[Samba/gebeck_regimport.git] / source / rpc_server / srv_util.c

/* 
 *  Unix SMB/CIFS implementation.
 *  RPC Pipe client / server routines
 *  Copyright (C) Andrew Tridgell              1992-1998
 *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
 *  Copyright (C) Paul Ashton                  1997-1998.
 *  
 *  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.
 */

/*  this module apparently provides an implementation of DCE/RPC over a
 *  named pipe (IPC$ connection using SMBtrans).  details of DCE/RPC
 *  documentation are available (in on-line form) from the X-Open group.
 *
 *  this module should provide a level of abstraction between SMB
 *  and DCE/RPC, while minimising the amount of mallocs, unnecessary
 *  data copies, and network traffic.
 *
 *  in this version, which takes a "let's learn what's going on and
 *  get something running" approach, there is additional network
 *  traffic generated, but the code should be easier to understand...
 *
 *  ... if you read the docs.  or stare at packets for weeks on end.
 *
 */

#include "includes.h"

#undef DBGC_CLASS
#define DBGC_CLASS DBGC_RPC_SRV

/*
 * A list of the rids of well known BUILTIN and Domain users
 * and groups.
 */

rid_name builtin_alias_rids[] =
{  
    { BUILTIN_ALIAS_RID_ADMINS       , "Administrators" },
    { BUILTIN_ALIAS_RID_USERS        , "Users" },
    { BUILTIN_ALIAS_RID_GUESTS       , "Guests" },
    { BUILTIN_ALIAS_RID_POWER_USERS  , "Power Users" },
   
    { BUILTIN_ALIAS_RID_ACCOUNT_OPS  , "Account Operators" },
    { BUILTIN_ALIAS_RID_SYSTEM_OPS   , "System Operators" },
    { BUILTIN_ALIAS_RID_PRINT_OPS    , "Print Operators" },
    { BUILTIN_ALIAS_RID_BACKUP_OPS   , "Backup Operators" },
    { BUILTIN_ALIAS_RID_REPLICATOR   , "Replicator" },
    { 0                             , NULL }
};

/* array lookup of well-known Domain RID users. */
rid_name domain_user_rids[] =
{  
    { DOMAIN_USER_RID_ADMIN         , "Administrator" },
    { DOMAIN_USER_RID_GUEST         , "Guest" },
    { 0                             , NULL }
};

/* array lookup of well-known Domain RID groups. */
rid_name domain_group_rids[] =
{  
    { DOMAIN_GROUP_RID_ADMINS       , "Domain Admins" },
    { DOMAIN_GROUP_RID_USERS        , "Domain Users" },
    { DOMAIN_GROUP_RID_GUESTS       , "Domain Guests" },
    { 0                             , NULL }
};

/*******************************************************************
 gets a domain user's groups
 ********************************************************************/
NTSTATUS get_alias_user_groups(TALLOC_CTX *ctx, DOM_SID *sid, int *numgroups, uint32 **prids, DOM_SID *q_sid)
{
        SAM_ACCOUNT *sam_pass=NULL;
        int i, cur_rid=0;
        gid_t gid;
        gid_t *groups = NULL;
        int num_groups;
        GROUP_MAP map;
        DOM_SID tmp_sid;
        fstring user_name;
        fstring str_domsid, str_qsid;
        uint32 rid,grid;
        uint32 *rids=NULL, *new_rids=NULL;
        gid_t winbind_gid_low, winbind_gid_high;
        BOOL ret;
        BOOL winbind_groups_exist;

        /*
         * this code is far from perfect.
         * first it enumerates the full /etc/group and that can be slow.
         * second, it works only with users' SIDs
         * whereas the day we support nested groups, it will have to
         * support both users's SIDs and domain groups' SIDs
         *
         * having our own ldap backend would be so much faster !
         * we're far from that, but hope one day ;-) JFM.
         */

        *prids=NULL;
        *numgroups=0;

        winbind_groups_exist = lp_idmap_gid(&winbind_gid_low, &winbind_gid_high);


        DEBUG(10,("get_alias_user_groups: looking if SID %s is a member of groups in the SID domain %s\n", 
                  sid_to_string(str_qsid, q_sid), sid_to_string(str_domsid, sid)));

        pdb_init_sam(&sam_pass);
        become_root();
        ret = pdb_getsampwsid(sam_pass, q_sid);
        unbecome_root();
        if (ret == False) {
                pdb_free_sam(&sam_pass);
                return NT_STATUS_NO_SUCH_USER;
        }

        fstrcpy(user_name, pdb_get_username(sam_pass));
        grid=pdb_get_group_rid(sam_pass);
        if (!NT_STATUS_IS_OK(sid_to_gid(pdb_get_group_sid(sam_pass), &gid))) {
                /* this should never happen */
                DEBUG(2,("get_alias_user_groups: sid_to_gid failed!\n"));
                pdb_free_sam(&sam_pass);
                return NT_STATUS_UNSUCCESSFUL;
        }

        become_root();
        /* on some systems this must run as root */
        num_groups = getgroups_user(user_name, &groups);        
        unbecome_root();
        if (num_groups == -1) {
                /* this should never happen */
                DEBUG(2,("get_alias_user_groups: getgroups_user failed\n"));
                pdb_free_sam(&sam_pass);
                return NT_STATUS_UNSUCCESSFUL;
        }

        for (i=0;i<num_groups;i++) {

                become_root();
                ret = get_group_from_gid(groups[i], &map);
                unbecome_root();
                
                if ( !ret ) {
                        DEBUG(10,("get_alias_user_groups: gid %d. not found\n", (int)groups[i]));
                        continue;
                }
                
                /* if it's not an alias, continue */
                if (map.sid_name_use != SID_NAME_ALIAS) {
                        DEBUG(10,("get_alias_user_groups: not returing %s, not an ALIAS group.\n", map.nt_name));
                        continue;
                }

                sid_copy(&tmp_sid, &map.sid);
                sid_split_rid(&tmp_sid, &rid);
                
                /* if the sid is not in the correct domain, continue */
                if (!sid_equal(&tmp_sid, sid)) {
                        DEBUG(10,("get_alias_user_groups: not returing %s, not in the domain SID.\n", map.nt_name));
                        continue;
                }

                /* Don't return winbind groups as they are not local! */
                if (winbind_groups_exist && (groups[i] >= winbind_gid_low) && (groups[i] <= winbind_gid_high)) {
                        DEBUG(10,("get_alias_user_groups: not returing %s, not local.\n", map.nt_name));
                        continue;
                }

                /* Don't return user private groups... */
                if (Get_Pwnam(map.nt_name) != 0) {
                        DEBUG(10,("get_alias_user_groups: not returing %s, clashes with user.\n", map.nt_name));
                        continue;                       
                }
                
                new_rids=(uint32 *)Realloc(rids, sizeof(uint32)*(cur_rid+1));
                if (new_rids==NULL) {
                        DEBUG(10,("get_alias_user_groups: could not realloc memory\n"));
                        pdb_free_sam(&sam_pass);
                        free(groups);
                        return NT_STATUS_NO_MEMORY;
                }
                rids=new_rids;
                
                sid_peek_rid(&map.sid, &(rids[cur_rid]));
                cur_rid++;
                break;
        }

        if(num_groups) 
                free(groups);

        /* now check for the user's gid (the primary group rid) */
        for (i=0; i<cur_rid && grid!=rids[i]; i++)
                ;

        /* the user's gid is already there */
        if (i!=cur_rid) {
                DEBUG(10,("get_alias_user_groups: user is already in the list. good.\n"));
                goto done;
        }

        DEBUG(10,("get_alias_user_groups: looking for gid %d of user %s\n", (int)gid, user_name));

        if(!get_group_from_gid(gid, &map)) {
                DEBUG(0,("get_alias_user_groups: gid of user %s doesn't exist. Check your "
                "/etc/passwd and /etc/group files\n", user_name));
                goto done;
        }       

        /* the primary group isn't an alias */
        if (map.sid_name_use!=SID_NAME_ALIAS) {
                DEBUG(10,("get_alias_user_groups: not returing %s, not an ALIAS group.\n", map.nt_name));
                goto done;
        }

        sid_copy(&tmp_sid, &map.sid);
        sid_split_rid(&tmp_sid, &rid);

        /* if the sid is not in the correct domain, continue */
        if (!sid_equal(&tmp_sid, sid)) {
                DEBUG(10,("get_alias_user_groups: not returing %s, not in the domain SID.\n", map.nt_name));
                goto done;
        }

        /* Don't return winbind groups as they are not local! */
        if (winbind_groups_exist && (gid >= winbind_gid_low) && (gid <= winbind_gid_high)) {
                DEBUG(10,("get_alias_user_groups: not returing %s, not local.\n", map.nt_name ));
                goto done;
        }

        /* Don't return user private groups... */
        if (Get_Pwnam(map.nt_name) != 0) {
                DEBUG(10,("get_alias_user_groups: not returing %s, clashes with user.\n", map.nt_name ));
                goto done;                      
        }

        new_rids=(uint32 *)Realloc(rids, sizeof(uint32)*(cur_rid+1));
        if (new_rids==NULL) {
                DEBUG(10,("get_alias_user_groups: could not realloc memory\n"));
                pdb_free_sam(&sam_pass);
                return NT_STATUS_NO_MEMORY;
        }
        rids=new_rids;

        sid_peek_rid(&map.sid, &(rids[cur_rid]));
        cur_rid++;

done:
        *prids=rids;
        *numgroups=cur_rid;
        pdb_free_sam(&sam_pass);

        return NT_STATUS_OK;
}


/*******************************************************************
 gets a domain user's groups
 ********************************************************************/
BOOL get_domain_user_groups(TALLOC_CTX *ctx, int *numgroups, DOM_GID **pgids, SAM_ACCOUNT *sam_pass)
{
        GROUP_MAP *map=NULL;
        int i, num, num_entries, cur_gid=0;
        struct group *grp;
        DOM_GID *gids;
        fstring user_name;
        uint32 grid;
        uint32 tmp_rid;
        BOOL ret;

        *numgroups= 0;

        fstrcpy(user_name, pdb_get_username(sam_pass));
        grid=pdb_get_group_rid(sam_pass);

        DEBUG(10,("get_domain_user_groups: searching domain groups [%s] is a member of\n", user_name));

        /* we must wrap this is become/unbecome root for ldap backends */
        
        become_root();
        /* first get the list of the domain groups */
        ret = pdb_enum_group_mapping(SID_NAME_DOM_GRP, &map, &num_entries, ENUM_ONLY_MAPPED);
        
        unbecome_root();

        /* end wrapper for group enumeration */

        
        if ( !ret )
                return False;
                
        DEBUG(10,("get_domain_user_groups: there are %d mapped groups\n", num_entries));


        /* 
         * alloc memory. In the worse case, we alloc memory for nothing.
         * but I prefer to alloc for nothing
         * than reallocing everytime.
         */
        gids = (DOM_GID *)talloc(ctx, sizeof(DOM_GID) *  num_entries);  

        /* for each group, check if the user is a member of.  Only include groups 
           from this domain */
        
        for(i=0; i<num_entries; i++) {
        
                if ( !sid_check_is_in_our_domain(&map[i].sid) ) {
                        DEBUG(10,("get_domain_user_groups: skipping check of %s since it is not in our domain\n",
                                map[i].nt_name));
                        continue;
                }
                        
                if ((grp=getgrgid(map[i].gid)) == NULL) {
                        /* very weird !!! */
                        DEBUG(5,("get_domain_user_groups: gid %d doesn't exist anymore !\n", (int)map[i].gid));
                        continue;
                }

                for(num=0; grp->gr_mem[num]!=NULL; num++) {
                        if(strcmp(grp->gr_mem[num], user_name)==0) {
                                /* we found the user, add the group to the list */
                                sid_peek_rid(&map[i].sid, &(gids[cur_gid].g_rid));
                                gids[cur_gid].attr=7;
                                DEBUG(10,("get_domain_user_groups: user found in group %s\n", map[i].nt_name));
                                cur_gid++;
                                break;
                        }
                }
        }

        /* we have checked the groups */
        /* we must now check the gid of the user or the primary group rid, that's the same */
        for (i=0; i<cur_gid && grid!=gids[i].g_rid; i++)
                ;
        
        /* the user's gid is already there */
        if (i!=cur_gid) {
                /* 
                 * the primary group of the user but be the first one in the list
                 * don't ask ! JFM.
                 */
                gids[i].g_rid=gids[0].g_rid;
                gids[0].g_rid=grid;
                goto done;
        }

        for(i=0; i<num_entries; i++) {
                sid_peek_rid(&map[i].sid, &tmp_rid);
                if (tmp_rid==grid) {
                        /* 
                         * the primary group of the user but be the first one in the list
                         * don't ask ! JFM.
                         */
                        gids[cur_gid].g_rid=gids[0].g_rid;
                        gids[0].g_rid=tmp_rid;
                        gids[cur_gid].attr=7;
                        DEBUG(10,("get_domain_user_groups: primary gid of user found in group %s\n", map[i].nt_name));
                        cur_gid++;
                        goto done; /* leave the loop early */
                }
        }

        DEBUG(0,("get_domain_user_groups: primary gid of user [%s] is not a Domain group !\n", user_name));
        DEBUGADD(0,("get_domain_user_groups: You should fix it, NT doesn't like that\n"));


 done:
        *pgids=gids;
        *numgroups=cur_gid;
        SAFE_FREE(map);

        return True;
}

/*******************************************************************
 gets a domain user's groups from their already-calculated NT_USER_TOKEN
 ********************************************************************/
NTSTATUS nt_token_to_group_list(TALLOC_CTX *mem_ctx, const DOM_SID *domain_sid, 
                                const NT_USER_TOKEN *nt_token,
                                int *numgroups, DOM_GID **pgids) 
{
        DOM_GID *gids;
        int i;

        gids = (DOM_GID *)talloc(mem_ctx, sizeof(*gids) * nt_token->num_sids);

        if (!gids) {
                return NT_STATUS_NO_MEMORY;
        }

        *numgroups=0;

        for (i=PRIMARY_GROUP_SID_INDEX; i < nt_token->num_sids; i++) {
                if (sid_compare_domain(domain_sid, &nt_token->user_sids[i])==0) {
                        sid_peek_rid(&nt_token->user_sids[i], &(gids[*numgroups].g_rid));
                        gids[*numgroups].attr=7;
                        (*numgroups)++;
                }
        }
        *pgids = gids; 
        return NT_STATUS_OK;
}

/*******************************************************************
 Look up a local (domain) rid and return a name and type.
 ********************************************************************/
NTSTATUS local_lookup_group_name(uint32 rid, char *group_name, uint32 *type)
{
        int i = 0; 
        (*type) = SID_NAME_DOM_GRP;

        DEBUG(5,("lookup_group_name: rid: %d", rid));

        while (domain_group_rids[i].rid != rid && domain_group_rids[i].rid != 0)
        {
                i++;
        }

        if (domain_group_rids[i].rid != 0)
        {
                fstrcpy(group_name, domain_group_rids[i].name);
                DEBUG(5,(" = %s\n", group_name));
                return NT_STATUS_OK;
        }

        DEBUG(5,(" none mapped\n"));
        return NT_STATUS_NONE_MAPPED;
}

/*******************************************************************
 Look up a local alias rid and return a name and type.
 ********************************************************************/
NTSTATUS local_lookup_alias_name(uint32 rid, char *alias_name, uint32 *type)
{
        int i = 0; 
        (*type) = SID_NAME_WKN_GRP;

        DEBUG(5,("lookup_alias_name: rid: %d", rid));

        while (builtin_alias_rids[i].rid != rid && builtin_alias_rids[i].rid != 0)
        {
                i++;
        }

        if (builtin_alias_rids[i].rid != 0)
        {
                fstrcpy(alias_name, builtin_alias_rids[i].name);
                DEBUG(5,(" = %s\n", alias_name));
                return NT_STATUS_OK;
        }

        DEBUG(5,(" none mapped\n"));
        return NT_STATUS_NONE_MAPPED;
}


#if 0 /*Nobody uses this function just now*/
/*******************************************************************
 Look up a local user rid and return a name and type.
 ********************************************************************/
NTSTATUS local_lookup_user_name(uint32 rid, char *user_name, uint32 *type)
{
        SAM_ACCOUNT *sampwd=NULL;
        int i = 0;
        BOOL ret;
        
        (*type) = SID_NAME_USER;

        DEBUG(5,("lookup_user_name: rid: %d", rid));

        /* look up the well-known domain user rids first */
        while (domain_user_rids[i].rid != rid && domain_user_rids[i].rid != 0)
        {
                i++;
        }

        if (domain_user_rids[i].rid != 0) {
                fstrcpy(user_name, domain_user_rids[i].name);
                DEBUG(5,(" = %s\n", user_name));
                return NT_STATUS_OK;
        }

        pdb_init_sam(&sampwd);

        /* ok, it's a user.  find the user account */
        become_root();
        ret = pdb_getsampwrid(sampwd, rid);
        unbecome_root();

        if (ret == True) {
                fstrcpy(user_name, pdb_get_username(sampwd) );
                DEBUG(5,(" = %s\n", user_name));
                pdb_free_sam(&sampwd);
                return NT_STATUS_OK;
        }

        DEBUG(5,(" none mapped\n"));
        pdb_free_sam(&sampwd);
        return NT_STATUS_NONE_MAPPED;
}

#endif

/*******************************************************************
 Look up a local (domain) group name and return a rid
 ********************************************************************/
NTSTATUS local_lookup_group_rid(char *group_name, uint32 *rid)
{
        const char *grp_name;
        int i = -1; /* start do loop at -1 */

        do /* find, if it exists, a group rid for the group name*/
        {
                i++;
                (*rid) = domain_group_rids[i].rid;
                grp_name = domain_group_rids[i].name;

        } while (grp_name != NULL && !strequal(grp_name, group_name));

        return (grp_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
}

/*******************************************************************
 Look up a local (BUILTIN) alias name and return a rid
 ********************************************************************/
NTSTATUS local_lookup_alias_rid(const char *alias_name, uint32 *rid)
{
        const char *als_name;
        int i = -1; /* start do loop at -1 */

        do /* find, if it exists, a alias rid for the alias name*/
        {
                i++;
                (*rid) = builtin_alias_rids[i].rid;
                als_name = builtin_alias_rids[i].name;

        } while (als_name != NULL && !strequal(als_name, alias_name));

        return (als_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
}

/*******************************************************************
 Look up a local user name and return a rid
 ********************************************************************/
NTSTATUS local_lookup_user_rid(char *user_name, uint32 *rid)
{
        SAM_ACCOUNT *sampass=NULL;
        BOOL ret;

        (*rid) = 0;

        pdb_init_sam(&sampass);

        /* find the user account */
        become_root();
        ret = pdb_getsampwnam(sampass, user_name);
        unbecome_root();

        if (ret == True) {
                (*rid) = pdb_get_user_rid(sampass);
                pdb_free_sam(&sampass);
                return NT_STATUS_OK;
        }

        pdb_free_sam(&sampass);
        return NT_STATUS_NONE_MAPPED;
}