source/groupdb/groupdb.c

   1 /*
   2    Unix SMB/Netbios implementation.
   3    Version 1.9.
   4    Password and authentication handling
   5    Copyright (C) Jeremy Allison 1996-1998
   6    Copyright (C) Luke Kenneth Casson Leighton 1996-1998
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program; if not, write to the Free Software
  20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21 */
  22
  23 #include "includes.h"
  24
  25 /*
  26  * NOTE. All these functions are abstracted into a structure
  27  * that points to the correct function for the selected database. JRA.
  28  */
  29
  30 static struct groupdb_ops *gpdb_ops;
  31
  32 /***************************************************************
  33  Initialise the group db operations.
  34 ***************************************************************/
  35
  36 BOOL initialise_group_db(void)
  37 {
  38   if (gpdb_ops)
  39   {
  40     return True;
  41   }
  42
  43 #ifdef WITH_NISPLUS
  44   gpdb_ops =  nisplus_initialise_group_db();
  45 #elif defined(WITH_LDAP)
  46   gpdb_ops = ldap_initialise_group_db();
  47 #else
  48   gpdb_ops = file_initialise_group_db();
  49 #endif
  50
  51   return (gpdb_ops != NULL);
  52 }
  53
  54 /*
  55  * Functions that return/manipulate a DOMAIN_GRP.
  56  */
  57
  58 /************************************************************************
  59  Utility function to search group database by gid: the DOMAIN_GRP
  60  structure does not have a gid member, so we have to convert here
  61  from gid to group rid.
  62 *************************************************************************/
  63 DOMAIN_GRP *iterate_getgroupgid(gid_t gid, DOMAIN_GRP_MEMBER **mem, int *num_mem)
  64 {
  65         return iterate_getgrouprid(pwdb_gid_to_group_rid(gid), mem, num_mem);
  66 }
  67
  68 /************************************************************************
  69  Utility function to search group database by rid.  use this if your database
  70  does not have search facilities.
  71 *************************************************************************/
  72 DOMAIN_GRP *iterate_getgrouprid(uint32 rid, DOMAIN_GRP_MEMBER **mem, int *num_mem)
  73 {
  74         DOMAIN_GRP *grp = NULL;
  75         void *fp = NULL;
  76
  77         DEBUG(10, ("search by rid: 0x%x\n", rid));
  78
  79         /* Open the group database file - not for update. */
  80         fp = startgroupent(False);
  81
  82         if (fp == NULL)
  83         {
  84                 DEBUG(0, ("unable to open group database.\n"));
  85                 return NULL;
  86         }
  87
  88         while ((grp = getgroupent(fp, mem, num_mem)) != NULL && grp->rid != rid)
  89         {
  90         }
  91
  92         if (grp != NULL)
  93         {
  94                 DEBUG(10, ("found group %s by rid: 0x%x\n", grp->name, rid));
  95         }
  96
  97         endgroupent(fp);
  98         return grp;
  99 }
 100
 101 /************************************************************************
 102  Utility function to search group database by name.  use this if your database
 103  does not have search facilities.
 104 *************************************************************************/
 105 DOMAIN_GRP *iterate_getgroupnam(char *name, DOMAIN_GRP_MEMBER **mem, int *num_mem)
 106 {
 107         DOMAIN_GRP *grp = NULL;
 108         void *fp = NULL;
 109
 110         DEBUG(10, ("search by name: %s\n", name));
 111
 112         /* Open the group database file - not for update. */
 113         fp = startgroupent(False);
 114
 115         if (fp == NULL)
 116         {
 117                 DEBUG(0, ("unable to open group database.\n"));
 118                 return NULL;
 119         }
 120
 121         while ((grp = getgroupent(fp, mem, num_mem)) != NULL && !strequal(grp->name, name))
 122         {
 123         }
 124
 125         if (grp != NULL)
 126         {
 127                 DEBUG(10, ("found by name: %s\n", name));
 128         }
 129
 130         endgroupent(fp);
 131         return grp;
 132 }
 133
 134 /*************************************************************************
 135  Routine to return the next entry in the smbdomaingroup list.
 136  *************************************************************************/
 137 BOOL add_domain_group(DOMAIN_GRP **grps, int *num_grps, DOMAIN_GRP *grp)
 138 {
 139         DOMAIN_GRP *tgrps;
 140
 141         if (grps == NULL || num_grps == NULL || grp == NULL)
 142                 return False;
 143
 144         tgrps = (DOMAIN_GRP *)Realloc((*grps), ((*num_grps)+1) * sizeof(DOMAIN_GRP));
 145         if (tgrps == NULL) {
 146                 if (*grps)
 147                         free(*grps);
 148                 return False;
 149         } else
 150                 (*grps) = tgrps;
 151
 152         DEBUG(10,("adding group %s(%s)\n", grp->name, grp->comment));
 153
 154         fstrcpy((*grps)[(*num_grps)].name   , grp->name);
 155         fstrcpy((*grps)[(*num_grps)].comment, grp->comment);
 156         (*grps)[(*num_grps)].attr = grp->attr;
 157         (*grps)[(*num_grps)].rid  = grp->rid ;
 158
 159         (*num_grps)++;
 160
 161         return True;
 162 }
 163
 164 /*************************************************************************
 165  checks to see if a user is a member of a domain group
 166  *************************************************************************/
 167 static BOOL user_is_member(char *user_name, DOMAIN_GRP_MEMBER *mem, int num_mem)
 168 {
 169         int i;
 170         for (i = 0; i < num_mem; i++)
 171         {
 172                 DEBUG(10,("searching against user %s...\n", mem[i].name));
 173                 if (strequal(mem[i].name, user_name))
 174                 {
 175                         DEBUG(10,("searching for user %s: found\n", user_name));
 176                         return True;
 177                 }
 178         }
 179         DEBUG(10,("searching for user %s: not found\n", user_name));
 180         return False;
 181 }
 182
 183 /*************************************************************************
 184  gets an array of groups that a user is in.  use this if your database
 185  does not have search facilities
 186  *************************************************************************/
 187 BOOL iterate_getusergroupsnam(char *user_name, DOMAIN_GRP **grps, int *num_grps)
 188 {
 189         DOMAIN_GRP *grp;
 190         DOMAIN_GRP_MEMBER *mem = NULL;
 191         int num_mem = 0;
 192         void *fp = NULL;
 193
 194         DEBUG(10, ("search for usergroups by name: %s\n", user_name));
 195
 196         if (user_name == NULL || grp == NULL || num_grps == NULL)
 197         {
 198                 return False;
 199         }
 200
 201         (*grps) = NULL;
 202         (*num_grps) = 0;
 203
 204         /* Open the group database file - not for update. */
 205         fp = startgroupent(False);
 206
 207         if (fp == NULL)
 208         {
 209                 DEBUG(0, ("unable to open group database.\n"));
 210                 return False;
 211         }
 212
 213         /* iterate through all groups.  search members for required user */
 214         while ((grp = getgroupent(fp, &mem, &num_mem)) != NULL)
 215         {
 216                 DEBUG(5,("group name %s members: %d\n", grp->name, num_mem));
 217                 if (num_mem != 0 && mem != NULL)
 218                 {
 219                         BOOL ret = True;
 220                         if (user_is_member(user_name, mem, num_mem))
 221                         {
 222                                 ret = add_domain_group(grps, num_grps, grp);
 223                         }
 224
 225                         free(mem);
 226                         mem = NULL;
 227                         num_mem = 0;
 228
 229                         if (!ret)
 230                         {
 231                                 (*num_grps) = 0;
 232                                 break;
 233                         }
 234                 }
 235         }
 236
 237         if ((*num_grps) != 0)
 238         {
 239                 DEBUG(10, ("found %d user groups:\n", (*num_grps)));
 240         }
 241
 242         endgroupent(fp);
 243         return True;
 244 }
 245
 246 /*************************************************************************
 247  gets an array of groups that a user is in.  use this if your database
 248  does not have search facilities
 249  *************************************************************************/
 250 BOOL enumdomgroups(DOMAIN_GRP **grps, int *num_grps)
 251 {
 252         DOMAIN_GRP *grp;
 253         void *fp = NULL;
 254
 255         DEBUG(10, ("enum user groups\n"));
 256
 257         if (grp == NULL || num_grps == NULL)
 258         {
 259                 return False;
 260         }
 261
 262         (*grps) = NULL;
 263         (*num_grps) = 0;
 264
 265         /* Open the group database file - not for update. */
 266         fp = startgroupent(False);
 267
 268         if (fp == NULL)
 269         {
 270                 DEBUG(0, ("unable to open group database.\n"));
 271                 return False;
 272         }
 273
 274         /* iterate through all groups. */
 275         while ((grp = getgroupent(fp, NULL, NULL)) != NULL)
 276         {
 277                 if (!add_domain_group(grps, num_grps, grp))
 278                 {
 279                         DEBUG(0,("unable to add group while enumerating\n"));
 280                         return False;
 281                 }
 282         }
 283
 284         if ((*num_grps) != 0)
 285         {
 286                 DEBUG(10, ("found %d user groups:\n", (*num_grps)));
 287         }
 288
 289         endgroupent(fp);
 290         return True;
 291 }
 292
 293 /***************************************************************
 294  Start to enumerate the group database list. Returns a void pointer
 295  to ensure no modification outside this module.
 296 ****************************************************************/
 297
 298 void *startgroupent(BOOL update)
 299 {
 300   return gpdb_ops->startgroupent(update);
 301 }
 302
 303 /***************************************************************
 304  End enumeration of the group database list.
 305 ****************************************************************/
 306
 307 void endgroupent(void *vp)
 308 {
 309   gpdb_ops->endgroupent(vp);
 310 }
 311
 312 /*************************************************************************
 313  Routine to return the next entry in the group database list.
 314  *************************************************************************/
 315
 316 DOMAIN_GRP *getgroupent(void *vp, DOMAIN_GRP_MEMBER **mem, int *num_mem)
 317 {
 318         return gpdb_ops->getgroupent(vp, mem, num_mem);
 319 }
 320
 321 /************************************************************************
 322  Routine to add an entry to the group database file.
 323 *************************************************************************/
 324
 325 BOOL add_group_entry(DOMAIN_GRP *newgrp)
 326 {
 327         return gpdb_ops->add_group_entry(newgrp);
 328 }
 329
 330 /************************************************************************
 331  Routine to search the group database file for an entry matching the groupname.
 332  and then replace the entry.
 333 ************************************************************************/
 334
 335 BOOL mod_group_entry(DOMAIN_GRP* grp)
 336 {
 337         return gpdb_ops->mod_group_entry(grp);
 338 }
 339
 340 /************************************************************************
 341  Routine to search group database by name.
 342 *************************************************************************/
 343
 344 DOMAIN_GRP *getgroupnam(char *name, DOMAIN_GRP_MEMBER **mem, int *num_mem)
 345 {
 346         return gpdb_ops->getgroupnam(name, mem, num_mem);
 347 }
 348
 349 /************************************************************************
 350  Routine to search group database by group rid.
 351 *************************************************************************/
 352
 353 DOMAIN_GRP *getgrouprid(uint32 group_rid, DOMAIN_GRP_MEMBER **mem, int *num_mem)
 354 {
 355         return gpdb_ops->getgrouprid(group_rid, mem, num_mem);
 356 }
 357
 358 /************************************************************************
 359  Routine to search group database by gid.
 360 *************************************************************************/
 361
 362 DOMAIN_GRP *getgroupgid(gid_t gid, DOMAIN_GRP_MEMBER **mem, int *num_mem)
 363 {
 364         return gpdb_ops->getgroupgid(gid, mem, num_mem);
 365 }
 366
 367 /*************************************************************************
 368  gets an array of groups that a user is in.
 369  *************************************************************************/
 370 BOOL getusergroupsnam(char *user_name, DOMAIN_GRP **grp, int *num_grps)
 371 {
 372         return gpdb_ops->getusergroupsnam(user_name, grp, num_grps);
 373 }
 374
 375 /*************************************************************
 376  initialises a DOMAIN_GRP.
 377  **************************************************************/
 378
 379 void gpdb_init_grp(DOMAIN_GRP *grp)
 380 {
 381         if (grp == NULL) return;
 382         ZERO_STRUCTP(grp);
 383 }
 384