source/groupdb/groupfile.c

   1 /*
   2  * Unix SMB/CIFS implementation.
   3  * SMB parameters and setup
   4  * Copyright (C) Andrew Tridgell 1992-1998 Modified by Jeremy Allison 1995.
   5  *
   6  * This program is free software; you can redistribute it and/or modify it under
   7  * the terms of the GNU General Public License as published by the Free
   8  * Software Foundation; either version 2 of the License, or (at your option)
   9  * any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  14  * more details.
  15  *
  16  * You should have received a copy of the GNU General Public License along with
  17  * this program; if not, write to the Free Software Foundation, Inc., 675
  18  * Mass Ave, Cambridge, MA 02139, USA.
  19  */
  20
  21 #include "includes.h"
  22
  23 #ifdef USE_SMBPASS_DB
  24
  25 static int gp_file_lock_depth = 0;
  26
  27 static char s_readbuf[1024];
  28
  29 /***************************************************************
  30  Start to enumerate the grppasswd list. Returns a void pointer
  31  to ensure no modification outside this module.
  32 ****************************************************************/
  33
  34 static void *startgrpfilepwent(BOOL update)
  35 {
  36         return startfilepwent(lp_smb_group_file(),
  37                               s_readbuf, sizeof(s_readbuf),
  38                               &gp_file_lock_depth, update);
  39 }
  40
  41 /***************************************************************
  42  End enumeration of the grppasswd list.
  43 ****************************************************************/
  44
  45 static void endgrpfilepwent(void *vp)
  46 {
  47         endfilepwent(vp, &gp_file_lock_depth);
  48 }
  49
  50 /*************************************************************************
  51  Return the current position in the grppasswd list as an SMB_BIG_UINT.
  52  This must be treated as an opaque token.
  53 *************************************************************************/
  54 static SMB_BIG_UINT getgrpfilepwpos(void *vp)
  55 {
  56         return getfilepwpos(vp);
  57 }
  58
  59 /*************************************************************************
  60  Set the current position in the grppasswd list from an SMB_BIG_UINT.
  61  This must be treated as an opaque token.
  62 *************************************************************************/
  63 static BOOL setgrpfilepwpos(void *vp, SMB_BIG_UINT tok)
  64 {
  65         return setfilepwpos(vp, tok);
  66 }
  67
  68 static BOOL make_group_line(char *p, int max_len,
  69                                 DOMAIN_GRP *grp,
  70                                 DOMAIN_GRP_MEMBER **mem, int *num_mem)
  71 {
  72         int i;
  73         int len;
  74         len = slprintf(p, max_len-1, "%s:%s:%d:", grp->name, grp->comment, grp->rid);
  75
  76         if (len == -1)
  77         {
  78                 DEBUG(0,("make_group_line: cannot create entry\n"));
  79                 return False;
  80         }
  81
  82         p += len;
  83         max_len -= len;
  84
  85         if (mem == NULL || num_mem == NULL)
  86         {
  87                 return True;
  88         }
  89
  90         for (i = 0; i < (*num_mem); i++)
  91         {
  92                 len = strlen((*mem)[i].name);
  93                 p = safe_strcpy(p, (*mem)[i].name, max_len);
  94
  95                 if (p == NULL)
  96                 {
  97                         DEBUG(0, ("make_group_line: out of space for groups!\n"));
  98                         return False;
  99                 }
 100
 101                 max_len -= len;
 102
 103                 if (i != (*num_mem)-1)
 104                 {
 105                         *p = ',';
 106                         p++;
 107                         max_len--;
 108                 }
 109         }
 110
 111         return True;
 112 }
 113
 114 /*************************************************************************
 115  Routine to return the next entry in the smbdomaingroup list.
 116  *************************************************************************/
 117 static char *get_group_members(char *p, int *num_mem, DOMAIN_GRP_MEMBER **members)
 118 {
 119         fstring name;
 120
 121         if (num_mem == NULL || members == NULL)
 122         {
 123                 return NULL;
 124         }
 125
 126         (*num_mem) = 0;
 127         (*members) = NULL;
 128
 129         while (next_token(&p, name, ",", sizeof(fstring)))
 130         {
 131                 DOMAIN_GRP_MEMBER *mbrs;
 132
 133                 mbrs = Realloc((*members), ((*num_mem)+1) * sizeof(DOMAIN_GRP_MEMBER));
 134                 if (mbrs == NULL) {
 135                         SAFE_FREE(*members);
 136                         return NULL;
 137                 }
 138                 else (*members) = mbrs;
 139                 fstrcpy((*members)[(*num_mem)].name, name);
 140                 (*members)[(*num_mem)].attr = 0x07;
 141                 (*num_mem)++;
 142         }
 143         return p;
 144 }
 145
 146 /*************************************************************************
 147  Routine to return the next entry in the smbdomaingroup list.
 148  *************************************************************************/
 149 static DOMAIN_GRP *getgrpfilepwent(void *vp, DOMAIN_GRP_MEMBER **mem, int *num_mem)
 150 {
 151         /* Static buffers we will return. */
 152         static DOMAIN_GRP gp_buf;
 153
 154         int gidval;
 155
 156         pstring linebuf;
 157         char  *p;
 158         size_t            linebuf_len;
 159
 160         gpdb_init_grp(&gp_buf);
 161
 162         /*
 163          * Scan the file, a line at a time and check if the name matches.
 164          */
 165         while ((linebuf_len = getfileline(vp, linebuf, sizeof(linebuf))) > 0)
 166         {
 167                 /* get group name */
 168
 169                 p = strncpyn(gp_buf.name, linebuf, sizeof(gp_buf.name), ':');
 170                 if (p == NULL)
 171                 {
 172                         DEBUG(0, ("getgrpfilepwent: malformed group entry (no :)\n"));
 173                         continue;
 174                 }
 175
 176                 /* Go past ':' */
 177                 p++;
 178
 179                 /* get group comment */
 180
 181                 p = strncpyn(gp_buf.comment, p, sizeof(gp_buf.comment), ':');
 182                 if (p == NULL)
 183                 {
 184                         DEBUG(0, ("getgrpfilepwent: malformed group entry (no :)\n"));
 185                         continue;
 186                 }
 187
 188                 /* Go past ':' */
 189                 p++;
 190
 191                 /* Get group gid. */
 192
 193                 p = Atoic(p, &gidval, ":");
 194
 195                 if (p == NULL)
 196                 {
 197                         DEBUG(0, ("getgrpfilepwent: malformed group entry (no : after uid)\n"));
 198                         continue;
 199                 }
 200
 201                 /* Go past ':' */
 202                 p++;
 203
 204                 /* now get the user's groups.  there are a maximum of 32 */
 205
 206                 if (mem != NULL && num_mem != NULL)
 207                 {
 208                         (*mem) = NULL;
 209                         (*num_mem) = 0;
 210
 211                         p = get_group_members(p, num_mem, mem);
 212                         if (p == NULL)
 213                         {
 214                                 DEBUG(0, ("getgrpfilepwent: malformed group entry (no : after members)\n"));
 215                         }
 216                 }
 217
 218                 /* ok, set up the static data structure and return it */
 219
 220                 gp_buf.rid     = pwdb_gid_to_group_rid((gid_t)gidval);
 221                 gp_buf.attr    = 0x07;
 222
 223                 make_group_line(linebuf, sizeof(linebuf), &gp_buf, mem, num_mem);
 224                 DEBUG(10,("line: '%s'\n", linebuf));
 225
 226                 return &gp_buf;
 227         }
 228
 229         DEBUG(5,("getgrpfilepwent: end of file reached.\n"));
 230         return NULL;
 231 }
 232
 233 /************************************************************************
 234  Routine to add an entry to the grppasswd file.
 235 *************************************************************************/
 236
 237 static BOOL add_grpfilegrp_entry(DOMAIN_GRP *newgrp)
 238 {
 239         DEBUG(0, ("add_grpfilegrp_entry: NOT IMPLEMENTED\n"));
 240         return False;
 241 }
 242
 243 /************************************************************************
 244  Routine to search the grppasswd file for an entry matching the groupname.
 245  and then modify its group entry. We can't use the startgrppwent()/
 246  getgrppwent()/endgrppwent() interfaces here as we depend on looking
 247  in the actual file to decide how much room we have to write data.
 248  override = False, normal
 249  override = True, override XXXXXXXX'd out group or NO PASS
 250 ************************************************************************/
 251
 252 static BOOL mod_grpfilegrp_entry(DOMAIN_GRP* grp)
 253 {
 254         DEBUG(0, ("mod_grpfilegrp_entry: NOT IMPLEMENTED\n"));
 255         return False;
 256 }
 257
 258
 259 static struct groupdb_ops file_ops =
 260 {
 261         startgrpfilepwent,
 262         endgrpfilepwent,
 263         getgrpfilepwpos,
 264         setgrpfilepwpos,
 265
 266         iterate_getgroupnam,          /* In groupdb.c */
 267         iterate_getgroupgid,          /* In groupdb.c */
 268         iterate_getgrouprid,          /* In groupdb.c */
 269         getgrpfilepwent,
 270
 271         add_grpfilegrp_entry,
 272         mod_grpfilegrp_entry,
 273
 274         iterate_getusergroupsnam      /* in groupdb.c */
 275 };
 276
 277 struct groupdb_ops *file_initialise_group_db(void)
 278 {
 279         return &file_ops;
 280 }
 281
 282 #else
 283  /* Do *NOT* make this function static. It breaks the compile on gcc. JRA */
 284  void grppass_dummy_function(void) { } /* stop some compilers complaining */
 285 #endif /* USE_SMBPASS_DB */