Greg Dickie spotted some wierd memory corruption problem with group
[samba.git] / source3 / groupdb / aliasunix.c
index cda53570f5c55dd6bccb4838d1046af520fa2990..c53692f32825df470c2854434312ac253cc8f594 100644 (file)
@@ -27,6 +27,13 @@ extern int DEBUGLEVEL;
 extern DOM_SID global_sam_sid;
 extern fstring global_sam_name;
 
+struct unix_entries
+{
+       struct group *grps;
+       int num_grps;
+       int grp_idx;
+};
+
 /***************************************************************
  Start to enumerate the alspasswd list. Returns a void pointer
  to ensure no modification outside this module.
@@ -34,8 +41,23 @@ extern fstring global_sam_name;
 
 static void *startalsunixpwent(BOOL update)
 {
-       setgrent();
-       return (void*)(-1);
+       struct unix_entries *grps;
+       grps = (struct unix_entries*)malloc(sizeof(struct unix_entries));
+
+       if (grps == NULL)
+       {
+               return NULL;
+       }
+
+       if (!get_unix_grps(&grps->num_grps, &grps->grps))
+       {
+               free(grps);
+               return NULL;
+       }
+
+       grps->grp_idx = 0;
+
+       return (void*)grps;
 }
 
 /***************************************************************
@@ -44,7 +66,13 @@ static void *startalsunixpwent(BOOL update)
 
 static void endalsunixpwent(void *vp)
 {
-       endgrent();
+       struct unix_entries *grps = (struct unix_entries *)vp;
+
+       if (grps != NULL)
+       {
+               free_unix_grps(grps->num_grps, grps->grps);
+               free(vp);
+       }
 }
 
 /*************************************************************************
@@ -65,42 +93,14 @@ static BOOL setalsunixpwpos(void *vp, SMB_BIG_UINT tok)
        return False;
 }
 
-/*************************************************************************
- maps a unix alias to a rid, domain sid and an nt alias name.  
-*************************************************************************/
-static void map_unix_als_to_nt_als(struct group *unix_als, char *nt_name, DOM_SID *sid, uint32 *rid)
-{
-       if (map_alias_gid(unix_als->gr_gid, sid, nt_name, NULL))
-       {
-               /*
-                * find the NT name represented by this UNIX gid.
-                * then, only accept NT aliass that are in our domain
-                */
-
-               sid_split_rid(sid, rid);
-       }
-       else
-       {
-               /*
-                * assume that the UNIX alias is an NT alias with
-                * the same name.  convert gid to a alias rid.
-                */
-               
-               fstrcpy(nt_name, unix_als->gr_name);
-               sid_copy(sid, &global_sam_sid);
-               (*rid) = pwdb_gid_to_alias_rid(unix_als->gr_gid);
-       }
-}
-
 /*************************************************************************
  Routine to return the next entry in the smbdomainalias list.
  *************************************************************************/
-BOOL get_unixalias_members(struct group *als,
+BOOL get_unixalias_members(struct group *grp,
                                int *num_mem, LOCAL_GRP_MEMBER **members)
 {
        int i;
        char *unix_name;
-       fstring nt_name;
 
        if (num_mem == NULL || members == NULL)
        {
@@ -110,60 +110,74 @@ BOOL get_unixalias_members(struct group *als,
        (*num_mem) = 0;
        (*members) = NULL;
 
-       for (i = 0; (unix_name = als->gr_mem[i]) != NULL; i++)
+       for (i = 0; (unix_name = grp->gr_mem[i]) != NULL; i++)
        {
-               DOM_SID sid;
-               BOOL found = False;
-               struct group unix_als;
+               fstring name;
+               DOM_NAME_MAP gmep;
+               LOCAL_GRP_MEMBER *mem;
 
-               if (isdigit(unix_name[0]))
-               {
-                       unix_als.gr_gid = get_number(unix_name);
-                       unix_als.gr_name = unix_name;
-               }
-               else
+               fstrcpy(name, unix_name);
+
+               if (!lookupsmbpwnam (name, &gmep) &&
+                   !lookupsmbgrpnam(name, &gmep))
                {
-                       unix_als.gr_name = unix_name;
-                       found = map_unix_alias_name(unix_name, &sid, nt_name, NULL);
+                       continue;
                }
 
-               found = found ? sid_equal(&sid, &global_sam_sid) : False;
-
-               if (!found)
+               if (!sid_front_equal(&global_sam_sid, &gmep.sid))
                {
-                       DEBUG(0,("alias database: could not resolve name %s in domain %s\n",
-                                 unix_name, global_sam_name));
+                       DEBUG(0,("alias database: could not resolve name %s (wrong Domain SID)\n",
+                                 name));
                        continue;
                }
 
-               (*members) = Realloc((*members), ((*num_mem)+1) * sizeof(LOCAL_GRP_MEMBER));
+               (*num_mem)++;
+               (*members) = Realloc((*members), (*num_mem) * sizeof(LOCAL_GRP_MEMBER));
                if ((*members) == NULL)
                {
+                       DEBUG(0,("get_unixalias_members: could not realloc LOCAL_GRP_MEMBERs\n"));
                        return False;
                }
 
-               fstrcpy((*members)[(*num_mem)].name, nt_name);
-               (*num_mem)++;
+               mem = &(*members)[(*num_mem)-1];
+               slprintf(mem->name, sizeof(mem->name)-1, "%s\\%s",
+                        gmep.nt_domain, gmep.nt_name);
+               sid_copy(&mem->sid, &gmep.sid);
+               mem->sid_use = gmep.type;
+
+               DEBUG(10,("get_unixalias_members: adding alias %s\n",
+                          mem->name));
        }
        return True;
 }
 
 /*************************************************************************
  Routine to return the next entry in the domain alias list.
+
+ when we are a PDC or BDC, then unix groups that are explicitly NOT mapped
+ to aliases are treated as DOMAIN groups (see groupunix.c).
+
+ when we are a member of a domain (not a PDC or BDC) then unix groups
+ that are explicitly NOT mapped to aliases (map_alias_gid) are treated
+ as LOCAL groups.
+
+ the reasoning behind this is to make it as simple as possible (not an easy
+ task) for people to set up a domain-aware samba server, in each role that
+ the server can take.
+
  *************************************************************************/
 static LOCAL_GRP *getalsunixpwent(void *vp, LOCAL_GRP_MEMBER **mem, int *num_mem)
 {
        /* Static buffers we will return. */
        static LOCAL_GRP gp_buf;
-       struct group *unix_grp;
+       struct group unix_grp;
+       struct unix_entries *grps = (struct unix_entries *)vp;
 
-       if (lp_server_role() == ROLE_DOMAIN_NONE || 
-           lp_server_role() == ROLE_DOMAIN_MEMBER)
+       if (lp_server_role() == ROLE_DOMAIN_NONE)
        {
                /*
-                * only PDC and BDC have domain aliass in the SAM.
-                * (however as member of domain you can have LOCAL aliass,
-                * but that's dealt with in the aliasdb...)
+                * no domain role, no domain aliases (or domain groups,
+                * but that's dealt with by groupdb...).
                 */
 
                return NULL;
@@ -171,60 +185,68 @@ static LOCAL_GRP *getalsunixpwent(void *vp, LOCAL_GRP_MEMBER **mem, int *num_mem
 
        aldb_init_als(&gp_buf);
 
-       fstrcpy(gp_buf.comment, "");
+       /* get array of unix names + gids.  this function does NOT
+          get a copy of the unix group members
+        */
 
-       /* cycle through unix aliass */
-       while ((unix_grp = getgrent()) != NULL)
+       /* cycle through unix groups */
+       for (; grps->grp_idx < grps->num_grps; grps->grp_idx++)
        {
-               DOM_SID sid;
-               if (map_alias_gid(unix_grp->gr_gid, &sid, gp_buf.name, NULL))
+               DOM_NAME_MAP gmep;
+               fstring sid_str;
+
+               memcpy(&unix_grp, &grps->grps[grps->grp_idx], sizeof(unix_grp));
+
+               DEBUG(10,("getgrpunixpwent: enum unix group entry %s\n",
+                          unix_grp.gr_name));
+                       
+               if (!lookupsmbgrpgid(unix_grp.gr_gid, &gmep))
                {
-                       /*
-                        * find the NT name represented by this UNIX gid.
-                        * then, only accept NT aliass that are in our domain
-                        */
-
-                       sid_split_rid(&sid, &gp_buf.rid);
-                       if (sid_equal(&sid, &global_sam_sid))
-                       {
-                               break; /* hooray. */
-                       }
+                       continue;
                }
-               else
+
+               sid_to_string(sid_str, &gmep.sid);
+               DEBUG(10,("group %s found, sid %s type %d\n",
+                       gmep.nt_name, sid_str, gmep.type));
+
+               if (gmep.type != SID_NAME_ALIAS)
                {
-                       /*
-                        * assume that the UNIX alias is an NT alias with
-                        * the same name.  convert gid to a alias rid.
-                        */
-                       
-                       fstrcpy(gp_buf.name, unix_grp->gr_name);
-                       gp_buf.rid = pwdb_gid_to_alias_rid(unix_grp->gr_gid);
+                       continue;
                }
+
+               sid_split_rid(&gmep.sid, &gp_buf.rid);
+               if (!sid_equal(&global_sam_sid, &gmep.sid))
+               {
+                       continue;
+               }
+
+               fstrcpy(gp_buf.name, gmep.nt_name);
+               break;
        }
 
-       if (unix_grp == NULL)
+       if (grps->grp_idx >= grps->num_grps)
        {
                return NULL;
        }
 
-       /* get the user's domain aliass.  there are a maximum of 32 */
+       /* get the user's domain aliases.  there are a maximum of 32 */
 
        if (mem != NULL && num_mem != NULL)
        {
                (*mem) = NULL;
                (*num_mem) = 0;
 
-               get_unixalias_members(unix_grp, num_mem, mem);
+               memcpy(&unix_grp, getgrgid(unix_grp.gr_gid), sizeof(unix_grp));
+               get_unixalias_members(&unix_grp, num_mem, mem);
        }
 
-#if 0
        {
                pstring linebuf;
                make_alias_line(linebuf, sizeof(linebuf), &gp_buf, mem, num_mem);
                DEBUG(10,("line: '%s'\n", linebuf));
        }
-#endif
 
+       grps->grp_idx++; /* advance so next enum gets next entry */
        return &gp_buf;
 }
 
@@ -232,24 +254,49 @@ static LOCAL_GRP *getalsunixpwent(void *vp, LOCAL_GRP_MEMBER **mem, int *num_mem
  Routine to add an entry to the alspasswd file.
 *************************************************************************/
 
-static BOOL add_alsunixals_entry(LOCAL_GRP *newals)
+static BOOL add_alsunixgrp_entry(LOCAL_GRP *newals)
 {
-       DEBUG(0, ("add_alsunixals_entry: NOT IMPLEMENTED\n"));
+       DEBUG(0, ("add_alsunixgrp_entry: NOT IMPLEMENTED\n"));
        return False;
 }
 
 /************************************************************************
  Routine to search the alspasswd file for an entry matching the aliasname.
- and then modify its alias entry. We can't use the startalspwent()/
- getalspwent()/endalspwent() interfaces here as we depend on looking
- in the actual file to decide how much room we have to write data.
- override = False, normal
- override = True, override XXXXXXXX'd out alias or NO PASS
+ and then modify its alias entry. 
 ************************************************************************/
 
-static BOOL mod_alsunixals_entry(LOCAL_GRP* als)
+static BOOL mod_alsunixgrp_entry(LOCAL_GRP* als)
 {
-       DEBUG(0, ("mod_alsunixals_entry: NOT IMPLEMENTED\n"));
+       DEBUG(0, ("mod_alsunixgrp_entry: NOT IMPLEMENTED\n"));
+       return False;
+}
+
+/************************************************************************
+ Routine to search the grppasswd file for an entry matching the rid.
+ and then delete it.
+************************************************************************/
+
+static BOOL del_alsunixgrp_entry(uint32 rid)
+{
+       DEBUG(0, ("del_alsunixgrp_entry: NOT IMPLEMENTED\n"));
+       return False;
+}
+
+/************************************************************************
+ Routine to add a member to an entry to the grppasswd file.
+*************************************************************************/
+static BOOL add_alsunixgrp_member(uint32 rid, DOM_SID *member_sid)
+{
+       DEBUG(0, ("add_alsunixgrp_member: NOT IMPLEMENTED\n"));
+       return False;
+}
+
+/************************************************************************
+ Routine to delete a member from an entry to the grppasswd file.
+*************************************************************************/
+static BOOL del_alsunixgrp_member(uint32 rid, DOM_SID *member_sid)
+{
+       DEBUG(0, ("del_alsunixgrp_member: NOT IMPLEMENTED\n"));
        return False;
 }
 
@@ -261,15 +308,19 @@ static struct aliasdb_ops unix_ops =
        getalsunixpwpos,
        setalsunixpwpos,
 
-       iterate_getaliasnam,          /* In aliasdb.c */
+       iterate_getaliasntnam,          /* In aliasdb.c */
        iterate_getaliasgid,          /* In aliasdb.c */
        iterate_getaliasrid,          /* In aliasdb.c */
        getalsunixpwent,
 
-       add_alsunixals_entry,
-       mod_alsunixals_entry,
+       add_alsunixgrp_entry,
+       mod_alsunixgrp_entry,
+       del_alsunixgrp_entry,
+
+       add_alsunixgrp_member,
+       del_alsunixgrp_member,
 
-       iterate_getuseraliasnam      /* in aliasdb.c */
+       iterate_getuseraliasntnam      /* in aliasdb.c */
 };
 
 struct aliasdb_ops *unix_initialise_alias_db(void)