?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix memleak in groupdb. Spotted by Metze
[Samba.git] / source / groupdb / mapping.c
blob5d2d28f152604d755ab7a65af0000df796205e6b
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-2000,
5 * Copyright (C) Jean François Micouleau 1998-2001.
6 *
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation; either version 2 of the License, or
10 * (at your option) any later version.
11 *
12 * This program is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with this program; if not, write to the Free Software
19 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 */
21
22 #include "includes.h"
23
24 static TDB_CONTEXT *tdb; /* used for driver files */
25
26 #define DATABASE_VERSION_V1 1 /* native byte format. */
27 #define DATABASE_VERSION_V2 2 /* le format. */
28
29 #define GROUP_PREFIX "UNIXGROUP/"
30
31 PRIVS privs[] = {
32 {SE_PRIV_NONE, "no_privs", "No privilege" }, /* this one MUST be first */
33 {SE_PRIV_ADD_MACHINES, "SeMachineAccountPrivilege", "Add workstations to the domain" },
34 {SE_PRIV_SEC_PRIV, "SeSecurityPrivilege", "Manage the audit logs" },
35 {SE_PRIV_TAKE_OWNER, "SeTakeOwnershipPrivilege", "Take ownership of file" },
36 {SE_PRIV_ADD_USERS, "SaAddUsers", "Add users to the domain - Samba" },
37 {SE_PRIV_PRINT_OPERATOR, "SaPrintOp", "Add or remove printers - Samba" },
38 {SE_PRIV_ALL, "SaAllPrivs", "all privileges" }
39 };
40
41
42 /****************************************************************************
43 dump the mapping group mapping to a text file
44 ****************************************************************************/
45 char *decode_sid_name_use(fstring group, enum SID_NAME_USE name_use)
46 {
47 static fstring group_type;
48
49 switch(name_use) {
50 case SID_NAME_USER:
51 fstrcpy(group_type,"User");
52 break;
53 case SID_NAME_DOM_GRP:
54 fstrcpy(group_type,"Domain group");
55 break;
56 case SID_NAME_DOMAIN:
57 fstrcpy(group_type,"Domain");
58 break;
59 case SID_NAME_ALIAS:
60 fstrcpy(group_type,"Local group");
61 break;
62 case SID_NAME_WKN_GRP:
63 fstrcpy(group_type,"Builtin group");
64 break;
65 case SID_NAME_DELETED:
66 fstrcpy(group_type,"Deleted");
67 break;
68 case SID_NAME_INVALID:
69 fstrcpy(group_type,"Invalid");
70 break;
71 case SID_NAME_UNKNOWN:
72 default:
73 fstrcpy(group_type,"Unknown type");
74 break;
75 }
76
77 fstrcpy(group, group_type);
78 return group_type;
79 }
80
81 /****************************************************************************
82 initialise first time the mapping list - called from init_group_mapping()
83 ****************************************************************************/
84 static BOOL default_group_mapping(void)
85 {
86 DOM_SID sid_admins;
87 DOM_SID sid_users;
88 DOM_SID sid_guests;
89 fstring str_admins;
90 fstring str_users;
91 fstring str_guests;
92
93 /* Add the Wellknown groups */
94
95 add_initial_entry(-1, "S-1-5-32-544", SID_NAME_WKN_GRP, "Administrators", "");
96 add_initial_entry(-1, "S-1-5-32-545", SID_NAME_WKN_GRP, "Users", "");
97 add_initial_entry(-1, "S-1-5-32-546", SID_NAME_WKN_GRP, "Guests", "");
98 add_initial_entry(-1, "S-1-5-32-547", SID_NAME_WKN_GRP, "Power Users", "");
99 add_initial_entry(-1, "S-1-5-32-548", SID_NAME_WKN_GRP, "Account Operators", "");
100 add_initial_entry(-1, "S-1-5-32-549", SID_NAME_WKN_GRP, "System Operators", "");
101 add_initial_entry(-1, "S-1-5-32-550", SID_NAME_WKN_GRP, "Print Operators", "");
102 add_initial_entry(-1, "S-1-5-32-551", SID_NAME_WKN_GRP, "Backup Operators", "");
103 add_initial_entry(-1, "S-1-5-32-552", SID_NAME_WKN_GRP, "Replicators", "");
104
105 /* Add the defaults domain groups */
106
107 sid_copy(&sid_admins, get_global_sam_sid());
108 sid_append_rid(&sid_admins, DOMAIN_GROUP_RID_ADMINS);
109 sid_to_string(str_admins, &sid_admins);
110 add_initial_entry(-1, str_admins, SID_NAME_DOM_GRP, "Domain Admins", "");
111
112 sid_copy(&sid_users, get_global_sam_sid());
113 sid_append_rid(&sid_users, DOMAIN_GROUP_RID_USERS);
114 sid_to_string(str_users, &sid_users);
115 add_initial_entry(-1, str_users, SID_NAME_DOM_GRP, "Domain Users", "");
116
117 sid_copy(&sid_guests, get_global_sam_sid());
118 sid_append_rid(&sid_guests, DOMAIN_GROUP_RID_GUESTS);
119 sid_to_string(str_guests, &sid_guests);
120 add_initial_entry(-1, str_guests, SID_NAME_DOM_GRP, "Domain Guests", "");
121
122 return True;
123 }
124
125 /****************************************************************************
126 Open the group mapping tdb.
127 ****************************************************************************/
128
129 static BOOL init_group_mapping(void)
130 {
131 static pid_t local_pid;
132 const char *vstring = "INFO/version";
133 int32 vers_id;
134
135 if (tdb && local_pid == sys_getpid())
136 return True;
137 tdb = tdb_open_log(lock_path("group_mapping.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
138 if (!tdb) {
139 DEBUG(0,("Failed to open group mapping database\n"));
140 return False;
141 }
142
143 local_pid = sys_getpid();
144
145 /* handle a Samba upgrade */
146 tdb_lock_bystring(tdb, vstring, 0);
147
148 /* Cope with byte-reversed older versions of the db. */
149 vers_id = tdb_fetch_int32(tdb, vstring);
150 if ((vers_id == DATABASE_VERSION_V1) || (IREV(vers_id) == DATABASE_VERSION_V1)) {
151 /* Written on a bigendian machine with old fetch_int code. Save as le. */
152 tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
153 vers_id = DATABASE_VERSION_V2;
154 }
155
156 if (vers_id != DATABASE_VERSION_V2) {
157 tdb_traverse(tdb, tdb_traverse_delete_fn, NULL);
158 tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
159 }
160
161 tdb_unlock_bystring(tdb, vstring);
162
163 /* write a list of default groups */
164 if(!default_group_mapping())
165 return False;
166
167 return True;
168 }
169
170 /****************************************************************************
171 ****************************************************************************/
172 static BOOL add_mapping_entry(GROUP_MAP *map, int flag)
173 {
174 TDB_DATA kbuf, dbuf;
175 pstring key, buf;
176 fstring string_sid="";
177 int len;
178
179 if(!init_group_mapping()) {
180 DEBUG(0,("failed to initialize group mapping"));
181 return(False);
182 }
183
184 sid_to_string(string_sid, &map->sid);
185
186 len = tdb_pack(buf, sizeof(buf), "ddff",
187 map->gid, map->sid_name_use, map->nt_name, map->comment);
188
189 if (len > sizeof(buf))
190 return False;
191
192 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
193
194 kbuf.dsize = strlen(key)+1;
195 kbuf.dptr = key;
196 dbuf.dsize = len;
197 dbuf.dptr = buf;
198 if (tdb_store(tdb, kbuf, dbuf, flag) != 0) return False;
199
200 return True;
201 }
202
203 /****************************************************************************
204 initialise first time the mapping list
205 ****************************************************************************/
206 BOOL add_initial_entry(gid_t gid, const char *sid, enum SID_NAME_USE sid_name_use, const char *nt_name, const char *comment)
207 {
208 GROUP_MAP map;
209
210 if(!init_group_mapping()) {
211 DEBUG(0,("failed to initialize group mapping"));
212 return(False);
213 }
214
215 map.gid=gid;
216 if (!string_to_sid(&map.sid, sid)) {
217 DEBUG(0, ("string_to_sid failed: %s", sid));
218 return False;
219 }
220
221 map.sid_name_use=sid_name_use;
222 fstrcpy(map.nt_name, nt_name);
223 fstrcpy(map.comment, comment);
224
225 pdb_add_group_mapping_entry(&map);
226
227 return True;
228 }
229
230 /****************************************************************************
231 Return the sid and the type of the unix group.
232 ****************************************************************************/
233
234 static BOOL get_group_map_from_sid(DOM_SID sid, GROUP_MAP *map)
235 {
236 TDB_DATA kbuf, dbuf;
237 pstring key;
238 fstring string_sid;
239 int ret;
240
241 if(!init_group_mapping()) {
242 DEBUG(0,("failed to initialize group mapping"));
243 return(False);
244 }
245
246 /* the key is the SID, retrieving is direct */
247
248 sid_to_string(string_sid, &sid);
249 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
250
251 kbuf.dptr = key;
252 kbuf.dsize = strlen(key)+1;
253
254 dbuf = tdb_fetch(tdb, kbuf);
255 if (!dbuf.dptr)
256 return False;
257
258 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
259 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
260
261 SAFE_FREE(dbuf.dptr);
262
263 sid_copy(&map->sid, &sid);
264
265 return True;
266 }
267
268 /****************************************************************************
269 Return the sid and the type of the unix group.
270 ****************************************************************************/
271
272 static BOOL get_group_map_from_gid(gid_t gid, GROUP_MAP *map)
273 {
274 TDB_DATA kbuf, dbuf, newkey;
275 fstring string_sid;
276 int ret;
277
278 if(!init_group_mapping()) {
279 DEBUG(0,("failed to initialize group mapping"));
280 return(False);
281 }
282
283 /* we need to enumerate the TDB to find the GID */
284
285 for (kbuf = tdb_firstkey(tdb);
286 kbuf.dptr;
287 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
288
289 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
290
291 dbuf = tdb_fetch(tdb, kbuf);
292 if (!dbuf.dptr)
293 continue;
294
295 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
296
297 string_to_sid(&map->sid, string_sid);
298
299 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
300 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
301
302 SAFE_FREE(dbuf.dptr);
303
304 if (gid==map->gid) {
305 SAFE_FREE(kbuf.dptr);
306 return True;
307 }
308 }
309
310 return False;
311 }
312
313 /****************************************************************************
314 Return the sid and the type of the unix group.
315 ****************************************************************************/
316
317 static BOOL get_group_map_from_ntname(const char *name, GROUP_MAP *map)
318 {
319 TDB_DATA kbuf, dbuf, newkey;
320 fstring string_sid;
321 int ret;
322
323 if(!init_group_mapping()) {
324 DEBUG(0,("get_group_map_from_ntname:failed to initialize group mapping"));
325 return(False);
326 }
327
328 /* we need to enumerate the TDB to find the name */
329
330 for (kbuf = tdb_firstkey(tdb);
331 kbuf.dptr;
332 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
333
334 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
335
336 dbuf = tdb_fetch(tdb, kbuf);
337 if (!dbuf.dptr)
338 continue;
339
340 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
341
342 string_to_sid(&map->sid, string_sid);
343
344 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
345 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
346
347 SAFE_FREE(dbuf.dptr);
348
349 if (StrCaseCmp(name, map->nt_name)==0) {
350 SAFE_FREE(kbuf.dptr);
351 return True;
352 }
353 }
354
355 return False;
356 }
357
358 /****************************************************************************
359 Remove a group mapping entry.
360 ****************************************************************************/
361
362 static BOOL group_map_remove(DOM_SID sid)
363 {
364 TDB_DATA kbuf, dbuf;
365 pstring key;
366 fstring string_sid;
367
368 if(!init_group_mapping()) {
369 DEBUG(0,("failed to initialize group mapping"));
370 return(False);
371 }
372
373 /* the key is the SID, retrieving is direct */
374
375 sid_to_string(string_sid, &sid);
376 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
377
378 kbuf.dptr = key;
379 kbuf.dsize = strlen(key)+1;
380
381 dbuf = tdb_fetch(tdb, kbuf);
382 if (!dbuf.dptr)
383 return False;
384
385 SAFE_FREE(dbuf.dptr);
386
387 if(tdb_delete(tdb, kbuf) != TDB_SUCCESS)
388 return False;
389
390 return True;
391 }
392
393 /****************************************************************************
394 Enumerate the group mapping.
395 ****************************************************************************/
396
397 static BOOL enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
398 int *num_entries, BOOL unix_only)
399 {
400 TDB_DATA kbuf, dbuf, newkey;
401 fstring string_sid;
402 fstring group_type;
403 GROUP_MAP map;
404 GROUP_MAP *mapt;
405 int ret;
406 int entries=0;
407
408 if(!init_group_mapping()) {
409 DEBUG(0,("failed to initialize group mapping"));
410 return(False);
411 }
412
413 *num_entries=0;
414 *rmap=NULL;
415
416 for (kbuf = tdb_firstkey(tdb);
417 kbuf.dptr;
418 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
419
420 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0)
421 continue;
422
423 dbuf = tdb_fetch(tdb, kbuf);
424 if (!dbuf.dptr)
425 continue;
426
427 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
428
429 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
430 &map.gid, &map.sid_name_use, &map.nt_name, &map.comment);
431
432 SAFE_FREE(dbuf.dptr);
433
434 /* list only the type or everything if UNKNOWN */
435 if (sid_name_use!=SID_NAME_UNKNOWN && sid_name_use!=map.sid_name_use) {
436 DEBUG(11,("enum_group_mapping: group %s is not of the requested type\n", map.nt_name));
437 continue;
438 }
439
440 if (unix_only==ENUM_ONLY_MAPPED && map.gid==-1) {
441 DEBUG(11,("enum_group_mapping: group %s is non mapped\n", map.nt_name));
442 continue;
443 }
444
445 string_to_sid(&map.sid, string_sid);
446
447 decode_sid_name_use(group_type, map.sid_name_use);
448 DEBUG(11,("enum_group_mapping: returning group %s of type %s\n", map.nt_name ,group_type));
449
450 mapt=(GROUP_MAP *)Realloc((*rmap), (entries+1)*sizeof(GROUP_MAP));
451 if (!mapt) {
452 DEBUG(0,("enum_group_mapping: Unable to enlarge group map!\n"));
453 SAFE_FREE(*rmap);
454 return False;
455 }
456 else
457 (*rmap) = mapt;
458
459 mapt[entries].gid = map.gid;
460 sid_copy( &mapt[entries].sid, &map.sid);
461 mapt[entries].sid_name_use = map.sid_name_use;
462 fstrcpy(mapt[entries].nt_name, map.nt_name);
463 fstrcpy(mapt[entries].comment, map.comment);
464
465 entries++;
466
467 }
468
469 *num_entries=entries;
470
471 return True;
472 }
473
474 /*
475 *
476 * High level functions
477 * better to use them than the lower ones.
478 *
479 * we are checking if the group is in the mapping file
480 * and if the group is an existing unix group
481 *
482 */
483
484 /* get a domain group from it's SID */
485
486 BOOL get_domain_group_from_sid(DOM_SID sid, GROUP_MAP *map)
487 {
488 struct group *grp;
489
490 if(!init_group_mapping()) {
491 DEBUG(0,("failed to initialize group mapping"));
492 return(False);
493 }
494
495 DEBUG(10, ("get_domain_group_from_sid\n"));
496
497 /* if the group is NOT in the database, it CAN NOT be a domain group */
498 if(!pdb_getgrsid(map, sid))
499 return False;
500
501 DEBUG(10, ("get_domain_group_from_sid: SID found in the TDB\n"));
502
503 /* if it's not a domain group, continue */
504 if (map->sid_name_use!=SID_NAME_DOM_GRP) {
505 return False;
506 }
507
508 DEBUG(10, ("get_domain_group_from_sid: SID is a domain group\n"));
509
510 if (map->gid==-1) {
511 return False;
512 }
513
514 DEBUG(10, ("get_domain_group_from_sid: SID is mapped to gid:%d\n",map->gid));
515
516 if ( (grp=getgrgid(map->gid)) == NULL) {
517 DEBUG(10, ("get_domain_group_from_sid: gid DOESN'T exist in UNIX security\n"));
518 return False;
519 }
520
521 DEBUG(10, ("get_domain_group_from_sid: gid exists in UNIX security\n"));
522
523 return True;
524 }
525
526
527 /* get a local (alias) group from it's SID */
528
529 BOOL get_local_group_from_sid(DOM_SID sid, GROUP_MAP *map)
530 {
531 struct group *grp;
532
533 if(!init_group_mapping()) {
534 DEBUG(0,("failed to initialize group mapping"));
535 return(False);
536 }
537
538 /* The group is in the mapping table */
539 if(pdb_getgrsid(map, sid)) {
540 if (map->sid_name_use!=SID_NAME_ALIAS) {
541 return False;
542 }
543
544 if (map->gid==-1) {
545 return False;
546 }
547
548 if ( (grp=getgrgid(map->gid)) == NULL) {
549 return False;
550 }
551 } else {
552 /* the group isn't in the mapping table.
553 * make one based on the unix information */
554 uint32 alias_rid;
555
556 sid_peek_rid(&sid, &alias_rid);
557 map->gid=pdb_group_rid_to_gid(alias_rid);
558
559 if ((grp=getgrgid(map->gid)) == NULL)
560 return False;
561
562 map->sid_name_use=SID_NAME_ALIAS;
563
564 fstrcpy(map->nt_name, grp->gr_name);
565 fstrcpy(map->comment, "Local Unix Group");
566
567 sid_copy(&map->sid, &sid);
568 }
569
570 return True;
571 }
572
573 /* get a builtin group from it's SID */
574
575 BOOL get_builtin_group_from_sid(DOM_SID sid, GROUP_MAP *map)
576 {
577 struct group *grp;
578
579 if(!init_group_mapping()) {
580 DEBUG(0,("failed to initialize group mapping"));
581 return(False);
582 }
583
584 if(!pdb_getgrsid(map, sid))
585 return False;
586
587 if (map->sid_name_use!=SID_NAME_WKN_GRP) {
588 return False;
589 }
590
591 if (map->gid==-1) {
592 return False;
593 }
594
595 if ( (grp=getgrgid(map->gid)) == NULL) {
596 return False;
597 }
598
599 return True;
600 }
601
602
603
604 /****************************************************************************
605 Returns a GROUP_MAP struct based on the gid.
606 ****************************************************************************/
607 BOOL get_group_from_gid(gid_t gid, GROUP_MAP *map)
608 {
609 struct group *grp;
610
611 if(!init_group_mapping()) {
612 DEBUG(0,("failed to initialize group mapping"));
613 return(False);
614 }
615
616 if ( (grp=getgrgid(gid)) == NULL)
617 return False;
618
619 /*
620 * make a group map from scratch if doesn't exist.
621 */
622 if (!pdb_getgrgid(map, gid)) {
623 map->gid=gid;
624 map->sid_name_use=SID_NAME_ALIAS;
625
626 /* interim solution until we have a last RID allocated */
627
628 sid_copy(&map->sid, get_global_sam_sid());
629 sid_append_rid(&map->sid, pdb_gid_to_group_rid(gid));
630
631 fstrcpy(map->nt_name, grp->gr_name);
632 fstrcpy(map->comment, "Local Unix Group");
633 }
634
635 return True;
636 }
637
638
639
640
641 /****************************************************************************
642 Get the member users of a group and
643 all the users who have that group as primary.
644
645 give back an array of uid
646 return the grand number of users
647
648
649 TODO: sort the list and remove duplicate. JFM.
650
651 ****************************************************************************/
652
653 BOOL get_uid_list_of_group(gid_t gid, uid_t **uid, int *num_uids)
654 {
655 struct group *grp;
656 struct passwd *pwd;
657 int i=0;
658 char *gr;
659 uid_t *u;
660
661 if(!init_group_mapping()) {
662 DEBUG(0,("failed to initialize group mapping"));
663 return(False);
664 }
665
666 *num_uids = 0;
667 *uid=NULL;
668
669 if ( (grp=getgrgid(gid)) == NULL)
670 return False;
671
672 gr = grp->gr_mem[0];
673 DEBUG(10, ("getting members\n"));
674
675 while (gr && (*gr != (char)'\0')) {
676 u = Realloc((*uid), sizeof(uid_t)*(*num_uids+1));
677 if (!u) {
678 DEBUG(0,("get_uid_list_of_group: unable to enlarge uid list!\n"));
679 return False;
680 }
681 else (*uid) = u;
682
683 if( (pwd=getpwnam_alloc(gr)) !=NULL) {
684 (*uid)[*num_uids]=pwd->pw_uid;
685 (*num_uids)++;
686 passwd_free(&pwd);
687 }
688 gr = grp->gr_mem[++i];
689 }
690 DEBUG(10, ("got [%d] members\n", *num_uids));
691
692 setpwent();
693 while ((pwd=getpwent()) != NULL) {
694 if (pwd->pw_gid==gid) {
695 u = Realloc((*uid), sizeof(uid_t)*(*num_uids+1));
696 if (!u) {
697 DEBUG(0,("get_uid_list_of_group: unable to enlarge uid list!\n"));
698 return False;
699 }
700 else (*uid) = u;
701 (*uid)[*num_uids]=pwd->pw_uid;
702
703 (*num_uids)++;
704 }
705 }
706 endpwent();
707 DEBUG(10, ("got primary groups, members: [%d]\n", *num_uids));
708
709 return True;
710 }
711
712 /****************************************************************************
713 Create a UNIX group on demand.
714 ****************************************************************************/
715
716 int smb_create_group(char *unix_group, gid_t *new_gid)
717 {
718 pstring add_script;
719 int ret;
720 int fd = 0;
721
722 pstrcpy(add_script, lp_addgroup_script());
723 if (! *add_script) return -1;
724 pstring_sub(add_script, "%g", unix_group);
725 ret = smbrun(add_script, (new_gid!=NULL) ? &fd : NULL);
726 DEBUG(3,("smb_create_group: Running the command `%s' gave %d\n",add_script,ret));
727 if (ret != 0)
728 return ret;
729
730 if (fd != 0) {
731 fstring output;
732
733 *new_gid = 0;
734 if (read(fd, output, sizeof(output)) > 0) {
735 *new_gid = (gid_t)strtoul(output, NULL, 10);
736 }
737 close(fd);
738
739 if (*new_gid == 0) {
740 /* The output was garbage. We assume nobody
741 will create group 0 via smbd. Now we try to
742 get the group via getgrnam. */
743
744 struct group *grp = getgrnam(unix_group);
745 if (grp != NULL)
746 *new_gid = grp->gr_gid;
747 else
748 return 1;
749 }
750 }
751
752 return ret;
753 }
754
755 /****************************************************************************
756 Delete a UNIX group on demand.
757 ****************************************************************************/
758
759 int smb_delete_group(char *unix_group)
760 {
761 pstring del_script;
762 int ret;
763
764 pstrcpy(del_script, lp_delgroup_script());
765 if (! *del_script) return -1;
766 pstring_sub(del_script, "%g", unix_group);
767 ret = smbrun(del_script,NULL);
768 DEBUG(3,("smb_delete_group: Running the command `%s' gave %d\n",del_script,ret));
769 return ret;
770 }
771
772 /****************************************************************************
773 Set a user's primary UNIX group.
774 ****************************************************************************/
775 int smb_set_primary_group(const char *unix_group, const char* unix_user)
776 {
777 pstring add_script;
778 int ret;
779
780 pstrcpy(add_script, lp_setprimarygroup_script());
781 if (! *add_script) return -1;
782 all_string_sub(add_script, "%g", unix_group, sizeof(add_script));
783 all_string_sub(add_script, "%u", unix_user, sizeof(add_script));
784 ret = smbrun(add_script,NULL);
785 DEBUG(3,("smb_set_primary_group: "
786 "Running the command `%s' gave %d\n",add_script,ret));
787 return ret;
788 }
789
790 /****************************************************************************
791 Add a user to a UNIX group.
792 ****************************************************************************/
793
794 int smb_add_user_group(char *unix_group, char *unix_user)
795 {
796 pstring add_script;
797 int ret;
798
799 pstrcpy(add_script, lp_addusertogroup_script());
800 if (! *add_script) return -1;
801 pstring_sub(add_script, "%g", unix_group);
802 pstring_sub(add_script, "%u", unix_user);
803 ret = smbrun(add_script,NULL);
804 DEBUG(3,("smb_add_user_group: Running the command `%s' gave %d\n",add_script,ret));
805 return ret;
806 }
807
808 /****************************************************************************
809 Delete a user from a UNIX group
810 ****************************************************************************/
811
812 int smb_delete_user_group(const char *unix_group, const char *unix_user)
813 {
814 pstring del_script;
815 int ret;
816
817 pstrcpy(del_script, lp_deluserfromgroup_script());
818 if (! *del_script) return -1;
819 pstring_sub(del_script, "%g", unix_group);
820 pstring_sub(del_script, "%u", unix_user);
821 ret = smbrun(del_script,NULL);
822 DEBUG(3,("smb_delete_user_group: Running the command `%s' gave %d\n",del_script,ret));
823 return ret;
824 }
825
826
827 NTSTATUS pdb_default_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
828 DOM_SID sid)
829 {
830 return get_group_map_from_sid(sid, map) ?
831 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
832 }
833
834 NTSTATUS pdb_default_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
835 gid_t gid)
836 {
837 return get_group_map_from_gid(gid, map) ?
838 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
839 }
840
841 NTSTATUS pdb_default_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
842 const char *name)
843 {
844 return get_group_map_from_ntname(name, map) ?
845 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
846 }
847
848 NTSTATUS pdb_default_add_group_mapping_entry(struct pdb_methods *methods,
849 GROUP_MAP *map)
850 {
851 return add_mapping_entry(map, TDB_INSERT) ?
852 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
853 }
854
855 NTSTATUS pdb_default_update_group_mapping_entry(struct pdb_methods *methods,
856 GROUP_MAP *map)
857 {
858 return add_mapping_entry(map, TDB_REPLACE) ?
859 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
860 }
861
862 NTSTATUS pdb_default_delete_group_mapping_entry(struct pdb_methods *methods,
863 DOM_SID sid)
864 {
865 return group_map_remove(sid) ?
866 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
867 }
868
869 NTSTATUS pdb_default_enum_group_mapping(struct pdb_methods *methods,
870 enum SID_NAME_USE sid_name_use,
871 GROUP_MAP **rmap, int *num_entries,
872 BOOL unix_only)
873 {
874 return enum_group_mapping(sid_name_use, rmap, num_entries, unix_only) ?
875 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
876 }
877
878 /**********************************************************************
879 no ops for passdb backends that don't implement group mapping
880 *********************************************************************/
881
882 NTSTATUS pdb_nop_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
883 DOM_SID sid)
884 {
885 return NT_STATUS_UNSUCCESSFUL;
886 }
887
888 NTSTATUS pdb_nop_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
889 gid_t gid)
890 {
891 return NT_STATUS_UNSUCCESSFUL;
892 }
893
894 NTSTATUS pdb_nop_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
895 const char *name)
896 {
897 return NT_STATUS_UNSUCCESSFUL;
898 }
899
900 NTSTATUS pdb_nop_add_group_mapping_entry(struct pdb_methods *methods,
901 GROUP_MAP *map)
902 {
903 return NT_STATUS_UNSUCCESSFUL;
904 }
905
906 NTSTATUS pdb_nop_update_group_mapping_entry(struct pdb_methods *methods,
907 GROUP_MAP *map)
908 {
909 return NT_STATUS_UNSUCCESSFUL;
910 }
911
912 NTSTATUS pdb_nop_delete_group_mapping_entry(struct pdb_methods *methods,
913 DOM_SID sid)
914 {
915 return NT_STATUS_UNSUCCESSFUL;
916 }
917
918 NTSTATUS pdb_nop_enum_group_mapping(struct pdb_methods *methods,
919 enum SID_NAME_USE sid_name_use,
920 GROUP_MAP **rmap, int *num_entries,
921 BOOL unix_only)
922 {
923 return NT_STATUS_UNSUCCESSFUL;
924 }
925
Samba GIT mirror