?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Clean up a comment noticed by Jonathan Shao@Panasas.com and remove an
[Samba/gebeck_regimport.git] / source3 / groupdb / mapping.c
blob8f534d779ef3682d134f8de38ba985a33ae68aa7
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 return pdb_add_group_mapping_entry(&map);
226 }
227
228 /****************************************************************************
229 Return the sid and the type of the unix group.
230 ****************************************************************************/
231
232 static BOOL get_group_map_from_sid(DOM_SID sid, GROUP_MAP *map)
233 {
234 TDB_DATA kbuf, dbuf;
235 pstring key;
236 fstring string_sid;
237 int ret = 0;
238
239 if(!init_group_mapping()) {
240 DEBUG(0,("failed to initialize group mapping"));
241 return(False);
242 }
243
244 /* the key is the SID, retrieving is direct */
245
246 sid_to_string(string_sid, &sid);
247 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
248
249 kbuf.dptr = key;
250 kbuf.dsize = strlen(key)+1;
251
252 dbuf = tdb_fetch(tdb, kbuf);
253 if (!dbuf.dptr)
254 return False;
255
256 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
257 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
258
259 SAFE_FREE(dbuf.dptr);
260
261 if ( ret == -1 ) {
262 DEBUG(3,("get_group_map_from_sid: tdb_unpack failure\n"));
263 return False;
264 }
265
266 sid_copy(&map->sid, &sid);
267
268 return True;
269 }
270
271 /****************************************************************************
272 Return the sid and the type of the unix group.
273 ****************************************************************************/
274
275 static BOOL get_group_map_from_gid(gid_t gid, GROUP_MAP *map)
276 {
277 TDB_DATA kbuf, dbuf, newkey;
278 fstring string_sid;
279 int ret;
280
281 if(!init_group_mapping()) {
282 DEBUG(0,("failed to initialize group mapping"));
283 return(False);
284 }
285
286 /* we need to enumerate the TDB to find the GID */
287
288 for (kbuf = tdb_firstkey(tdb);
289 kbuf.dptr;
290 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
291
292 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
293
294 dbuf = tdb_fetch(tdb, kbuf);
295 if (!dbuf.dptr)
296 continue;
297
298 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
299
300 string_to_sid(&map->sid, string_sid);
301
302 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
303 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
304
305 SAFE_FREE(dbuf.dptr);
306
307 if ( ret == -1 ) {
308 DEBUG(3,("get_group_map_from_gid: tdb_unpack failure\n"));
309 return False;
310 }
311
312 if (gid==map->gid) {
313 SAFE_FREE(kbuf.dptr);
314 return True;
315 }
316 }
317
318 return False;
319 }
320
321 /****************************************************************************
322 Return the sid and the type of the unix group.
323 ****************************************************************************/
324
325 static BOOL get_group_map_from_ntname(const char *name, GROUP_MAP *map)
326 {
327 TDB_DATA kbuf, dbuf, newkey;
328 fstring string_sid;
329 int ret;
330
331 if(!init_group_mapping()) {
332 DEBUG(0,("get_group_map_from_ntname:failed to initialize group mapping"));
333 return(False);
334 }
335
336 /* we need to enumerate the TDB to find the name */
337
338 for (kbuf = tdb_firstkey(tdb);
339 kbuf.dptr;
340 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
341
342 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
343
344 dbuf = tdb_fetch(tdb, kbuf);
345 if (!dbuf.dptr)
346 continue;
347
348 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
349
350 string_to_sid(&map->sid, string_sid);
351
352 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
353 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
354
355 SAFE_FREE(dbuf.dptr);
356
357 if ( ret == -1 ) {
358 DEBUG(3,("get_group_map_from_ntname: tdb_unpack failure\n"));
359 return False;
360 }
361
362 if (StrCaseCmp(name, map->nt_name)==0) {
363 SAFE_FREE(kbuf.dptr);
364 return True;
365 }
366 }
367
368 return False;
369 }
370
371 /****************************************************************************
372 Remove a group mapping entry.
373 ****************************************************************************/
374
375 static BOOL group_map_remove(DOM_SID sid)
376 {
377 TDB_DATA kbuf, dbuf;
378 pstring key;
379 fstring string_sid;
380
381 if(!init_group_mapping()) {
382 DEBUG(0,("failed to initialize group mapping"));
383 return(False);
384 }
385
386 /* the key is the SID, retrieving is direct */
387
388 sid_to_string(string_sid, &sid);
389 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
390
391 kbuf.dptr = key;
392 kbuf.dsize = strlen(key)+1;
393
394 dbuf = tdb_fetch(tdb, kbuf);
395 if (!dbuf.dptr)
396 return False;
397
398 SAFE_FREE(dbuf.dptr);
399
400 if(tdb_delete(tdb, kbuf) != TDB_SUCCESS)
401 return False;
402
403 return True;
404 }
405
406 /****************************************************************************
407 Enumerate the group mapping.
408 ****************************************************************************/
409
410 static BOOL enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
411 int *num_entries, BOOL unix_only)
412 {
413 TDB_DATA kbuf, dbuf, newkey;
414 fstring string_sid;
415 fstring group_type;
416 GROUP_MAP map;
417 GROUP_MAP *mapt;
418 int ret;
419 int entries=0;
420
421 if(!init_group_mapping()) {
422 DEBUG(0,("failed to initialize group mapping"));
423 return(False);
424 }
425
426 *num_entries=0;
427 *rmap=NULL;
428
429 for (kbuf = tdb_firstkey(tdb);
430 kbuf.dptr;
431 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
432
433 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0)
434 continue;
435
436 dbuf = tdb_fetch(tdb, kbuf);
437 if (!dbuf.dptr)
438 continue;
439
440 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
441
442 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
443 &map.gid, &map.sid_name_use, &map.nt_name, &map.comment);
444
445 SAFE_FREE(dbuf.dptr);
446
447 if ( ret == -1 ) {
448 DEBUG(3,("enum_group_mapping: tdb_unpack failure\n"));
449 continue;
450 }
451
452 /* list only the type or everything if UNKNOWN */
453 if (sid_name_use!=SID_NAME_UNKNOWN && sid_name_use!=map.sid_name_use) {
454 DEBUG(11,("enum_group_mapping: group %s is not of the requested type\n", map.nt_name));
455 continue;
456 }
457
458 if (unix_only==ENUM_ONLY_MAPPED && map.gid==-1) {
459 DEBUG(11,("enum_group_mapping: group %s is non mapped\n", map.nt_name));
460 continue;
461 }
462
463 string_to_sid(&map.sid, string_sid);
464
465 decode_sid_name_use(group_type, map.sid_name_use);
466 DEBUG(11,("enum_group_mapping: returning group %s of type %s\n", map.nt_name ,group_type));
467
468 mapt=(GROUP_MAP *)Realloc((*rmap), (entries+1)*sizeof(GROUP_MAP));
469 if (!mapt) {
470 DEBUG(0,("enum_group_mapping: Unable to enlarge group map!\n"));
471 SAFE_FREE(*rmap);
472 return False;
473 }
474 else
475 (*rmap) = mapt;
476
477 mapt[entries].gid = map.gid;
478 sid_copy( &mapt[entries].sid, &map.sid);
479 mapt[entries].sid_name_use = map.sid_name_use;
480 fstrcpy(mapt[entries].nt_name, map.nt_name);
481 fstrcpy(mapt[entries].comment, map.comment);
482
483 entries++;
484
485 }
486
487 *num_entries=entries;
488
489 return True;
490 }
491
492 /*
493 *
494 * High level functions
495 * better to use them than the lower ones.
496 *
497 * we are checking if the group is in the mapping file
498 * and if the group is an existing unix group
499 *
500 */
501
502 /* get a domain group from it's SID */
503
504 BOOL get_domain_group_from_sid(DOM_SID sid, GROUP_MAP *map)
505 {
506 struct group *grp;
507
508 if(!init_group_mapping()) {
509 DEBUG(0,("failed to initialize group mapping"));
510 return(False);
511 }
512
513 DEBUG(10, ("get_domain_group_from_sid\n"));
514
515 /* if the group is NOT in the database, it CAN NOT be a domain group */
516 if(!pdb_getgrsid(map, sid))
517 return False;
518
519 DEBUG(10, ("get_domain_group_from_sid: SID found in the TDB\n"));
520
521 /* if it's not a domain group, continue */
522 if (map->sid_name_use!=SID_NAME_DOM_GRP) {
523 return False;
524 }
525
526 DEBUG(10, ("get_domain_group_from_sid: SID is a domain group\n"));
527
528 if (map->gid==-1) {
529 return False;
530 }
531
532 DEBUG(10, ("get_domain_group_from_sid: SID is mapped to gid:%lu\n",(unsigned long)map->gid));
533
534 grp = getgrgid(map->gid);
535 if ( !grp ) {
536 DEBUG(10, ("get_domain_group_from_sid: gid DOESN'T exist in UNIX security\n"));
537 return False;
538 }
539
540 DEBUG(10, ("get_domain_group_from_sid: gid exists in UNIX security\n"));
541
542 return True;
543 }
544
545
546 /* get a local (alias) group from it's SID */
547
548 BOOL get_local_group_from_sid(DOM_SID sid, GROUP_MAP *map)
549 {
550 struct group *grp;
551
552 if(!init_group_mapping()) {
553 DEBUG(0,("failed to initialize group mapping"));
554 return(False);
555 }
556
557 /* The group is in the mapping table */
558 if(pdb_getgrsid(map, sid)) {
559 if (map->sid_name_use!=SID_NAME_ALIAS) {
560 return False;
561 }
562
563 if (map->gid==-1) {
564 return False;
565 }
566
567 if ( (grp=getgrgid(map->gid)) == NULL) {
568 return False;
569 }
570 } else {
571 /* the group isn't in the mapping table.
572 * make one based on the unix information */
573 uint32 alias_rid;
574
575 sid_peek_rid(&sid, &alias_rid);
576 map->gid=pdb_group_rid_to_gid(alias_rid);
577
578 grp = getgrgid(map->gid);
579 if ( !grp ) {
580 DEBUG(3,("get_local_group_from_sid: No unix group for [%ul]\n", map->gid));
581 return False;
582 }
583
584 map->sid_name_use=SID_NAME_ALIAS;
585
586 fstrcpy(map->nt_name, grp->gr_name);
587 fstrcpy(map->comment, "Local Unix Group");
588
589 sid_copy(&map->sid, &sid);
590 }
591
592 return True;
593 }
594
595 /* get a builtin group from it's SID */
596
597 BOOL get_builtin_group_from_sid(DOM_SID sid, GROUP_MAP *map)
598 {
599 struct group *grp;
600
601 if(!init_group_mapping()) {
602 DEBUG(0,("failed to initialize group mapping"));
603 return(False);
604 }
605
606 if(!pdb_getgrsid(map, sid))
607 return False;
608
609 if (map->sid_name_use!=SID_NAME_WKN_GRP) {
610 return False;
611 }
612
613 if (map->gid==-1) {
614 return False;
615 }
616
617 if ( (grp=getgrgid(map->gid)) == NULL) {
618 return False;
619 }
620
621 return True;
622 }
623
624
625
626 /****************************************************************************
627 Returns a GROUP_MAP struct based on the gid.
628 ****************************************************************************/
629 BOOL get_group_from_gid(gid_t gid, GROUP_MAP *map)
630 {
631 struct group *grp;
632 BOOL ret;
633
634 if(!init_group_mapping()) {
635 DEBUG(0,("failed to initialize group mapping"));
636 return(False);
637 }
638
639 if ( (grp=getgrgid(gid)) == NULL)
640 return False;
641
642 /*
643 * make a group map from scratch if doesn't exist.
644 */
645
646 become_root();
647 ret = pdb_getgrgid(map, gid);
648 unbecome_root();
649
650 if ( !ret ) {
651 map->gid=gid;
652 map->sid_name_use=SID_NAME_ALIAS;
653
654 /* interim solution until we have a last RID allocated */
655
656 sid_copy(&map->sid, get_global_sam_sid());
657 sid_append_rid(&map->sid, pdb_gid_to_group_rid(gid));
658
659 fstrcpy(map->nt_name, grp->gr_name);
660 fstrcpy(map->comment, "Local Unix Group");
661 }
662
663 return True;
664 }
665
666
667
668
669 /****************************************************************************
670 Get the member users of a group and
671 all the users who have that group as primary.
672
673 give back an array of uid
674 return the grand number of users
675
676
677 TODO: sort the list and remove duplicate. JFM.
678
679 ****************************************************************************/
680
681 BOOL get_uid_list_of_group(gid_t gid, uid_t **uid, int *num_uids)
682 {
683 struct group *grp;
684 struct passwd *pwd;
685 int i=0;
686 char *gr;
687 uid_t *u;
688
689 if(!init_group_mapping()) {
690 DEBUG(0,("failed to initialize group mapping"));
691 return(False);
692 }
693
694 *num_uids = 0;
695 *uid=NULL;
696
697 if ( (grp=getgrgid(gid)) == NULL)
698 return False;
699
700 gr = grp->gr_mem[0];
701 DEBUG(10, ("getting members\n"));
702
703 while (gr && (*gr != (char)'\0')) {
704 u = Realloc((*uid), sizeof(uid_t)*(*num_uids+1));
705 if (!u) {
706 DEBUG(0,("get_uid_list_of_group: unable to enlarge uid list!\n"));
707 return False;
708 }
709 else (*uid) = u;
710
711 if( (pwd=getpwnam_alloc(gr)) !=NULL) {
712 (*uid)[*num_uids]=pwd->pw_uid;
713 (*num_uids)++;
714 passwd_free(&pwd);
715 }
716 gr = grp->gr_mem[++i];
717 }
718 DEBUG(10, ("got [%d] members\n", *num_uids));
719
720 setpwent();
721 while ((pwd=getpwent()) != NULL) {
722 if (pwd->pw_gid==gid) {
723 u = Realloc((*uid), sizeof(uid_t)*(*num_uids+1));
724 if (!u) {
725 DEBUG(0,("get_uid_list_of_group: unable to enlarge uid list!\n"));
726 return False;
727 }
728 else (*uid) = u;
729 (*uid)[*num_uids]=pwd->pw_uid;
730
731 (*num_uids)++;
732 }
733 }
734 endpwent();
735 DEBUG(10, ("got primary groups, members: [%d]\n", *num_uids));
736
737 return True;
738 }
739
740 /****************************************************************************
741 Create a UNIX group on demand.
742 ****************************************************************************/
743
744 int smb_create_group(char *unix_group, gid_t *new_gid)
745 {
746 pstring add_script;
747 int ret = -1;
748 int fd = 0;
749
750 *new_gid = 0;
751
752 /* defer to scripts */
753
754 if ( *lp_addgroup_script() ) {
755 pstrcpy(add_script, lp_addgroup_script());
756 pstring_sub(add_script, "%g", unix_group);
757 ret = smbrun(add_script, (new_gid!=NULL) ? &fd : NULL);
758 DEBUG(3,("smb_create_group: Running the command `%s' gave %d\n",add_script,ret));
759 if (ret != 0)
760 return ret;
761
762 if (fd != 0) {
763 fstring output;
764
765 *new_gid = 0;
766 if (read(fd, output, sizeof(output)) > 0) {
767 *new_gid = (gid_t)strtoul(output, NULL, 10);
768 }
769
770 close(fd);
771 }
772 }
773
774 /* Try winbindd */
775
776 if ( winbind_create_group( unix_group, NULL ) ) {
777 DEBUG(3,("smb_create_group: winbindd created the group (%s)\n",
778 unix_group));
779 ret = 0;
780 }
781
782 if (*new_gid == 0) {
783 struct group *grp = getgrnam(unix_group);
784
785 if (grp != NULL)
786 *new_gid = grp->gr_gid;
787 }
788
789 return ret;
790 }
791
792 /****************************************************************************
793 Delete a UNIX group on demand.
794 ****************************************************************************/
795
796 int smb_delete_group(char *unix_group)
797 {
798 pstring del_script;
799 int ret;
800
801 /* defer to scripts */
802
803 if ( *lp_delgroup_script() ) {
804 pstrcpy(del_script, lp_delgroup_script());
805 pstring_sub(del_script, "%g", unix_group);
806 ret = smbrun(del_script,NULL);
807 DEBUG(3,("smb_delete_group: Running the command `%s' gave %d\n",del_script,ret));
808 return ret;
809 }
810
811 if ( winbind_delete_group( unix_group ) ) {
812 DEBUG(3,("smb_delete_group: winbindd deleted the group (%s)\n",
813 unix_group));
814 return 0;
815 }
816
817 return -1;
818 }
819
820 /****************************************************************************
821 Set a user's primary UNIX group.
822 ****************************************************************************/
823 int smb_set_primary_group(const char *unix_group, const char* unix_user)
824 {
825 pstring add_script;
826 int ret;
827
828 /* defer to scripts */
829
830 if ( *lp_setprimarygroup_script() ) {
831 pstrcpy(add_script, lp_setprimarygroup_script());
832 all_string_sub(add_script, "%g", unix_group, sizeof(add_script));
833 all_string_sub(add_script, "%u", unix_user, sizeof(add_script));
834 ret = smbrun(add_script,NULL);
835 DEBUG(3,("smb_set_primary_group: "
836 "Running the command `%s' gave %d\n",add_script,ret));
837 return ret;
838 }
839
840 /* Try winbindd */
841
842 if ( winbind_set_user_primary_group( unix_user, unix_group ) ) {
843 DEBUG(3,("smb_delete_group: winbindd set the group (%s) as the primary group for user (%s)\n",
844 unix_group, unix_user));
845 return 0;
846 }
847
848 return -1;
849 }
850
851 /****************************************************************************
852 Add a user to a UNIX group.
853 ****************************************************************************/
854
855 int smb_add_user_group(char *unix_group, char *unix_user)
856 {
857 pstring add_script;
858 int ret;
859
860 /* defer to scripts */
861
862 if ( *lp_addusertogroup_script() ) {
863 pstrcpy(add_script, lp_addusertogroup_script());
864 pstring_sub(add_script, "%g", unix_group);
865 pstring_sub(add_script, "%u", unix_user);
866 ret = smbrun(add_script,NULL);
867 DEBUG(3,("smb_add_user_group: Running the command `%s' gave %d\n",add_script,ret));
868 return ret;
869 }
870
871 /* Try winbindd */
872
873 if ( winbind_add_user_to_group( unix_user, unix_group ) ) {
874 DEBUG(3,("smb_delete_group: winbindd added user (%s) to the group (%s)\n",
875 unix_user, unix_group));
876 return -1;
877 }
878
879 return -1;
880 }
881
882 /****************************************************************************
883 Delete a user from a UNIX group
884 ****************************************************************************/
885
886 int smb_delete_user_group(const char *unix_group, const char *unix_user)
887 {
888 pstring del_script;
889 int ret;
890
891 /* defer to scripts */
892
893 if ( *lp_deluserfromgroup_script() ) {
894 pstrcpy(del_script, lp_deluserfromgroup_script());
895 pstring_sub(del_script, "%g", unix_group);
896 pstring_sub(del_script, "%u", unix_user);
897 ret = smbrun(del_script,NULL);
898 DEBUG(3,("smb_delete_user_group: Running the command `%s' gave %d\n",del_script,ret));
899 return ret;
900 }
901
902 /* Try winbindd */
903
904 if ( winbind_remove_user_from_group( unix_user, unix_group ) ) {
905 DEBUG(3,("smb_delete_group: winbindd removed user (%s) from the group (%s)\n",
906 unix_user, unix_group));
907 return 0;
908 }
909
910 return -1;
911 }
912
913
914 NTSTATUS pdb_default_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
915 DOM_SID sid)
916 {
917 return get_group_map_from_sid(sid, map) ?
918 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
919 }
920
921 NTSTATUS pdb_default_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
922 gid_t gid)
923 {
924 return get_group_map_from_gid(gid, map) ?
925 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
926 }
927
928 NTSTATUS pdb_default_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
929 const char *name)
930 {
931 return get_group_map_from_ntname(name, map) ?
932 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
933 }
934
935 NTSTATUS pdb_default_add_group_mapping_entry(struct pdb_methods *methods,
936 GROUP_MAP *map)
937 {
938 return add_mapping_entry(map, TDB_INSERT) ?
939 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
940 }
941
942 NTSTATUS pdb_default_update_group_mapping_entry(struct pdb_methods *methods,
943 GROUP_MAP *map)
944 {
945 return add_mapping_entry(map, TDB_REPLACE) ?
946 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
947 }
948
949 NTSTATUS pdb_default_delete_group_mapping_entry(struct pdb_methods *methods,
950 DOM_SID sid)
951 {
952 return group_map_remove(sid) ?
953 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
954 }
955
956 NTSTATUS pdb_default_enum_group_mapping(struct pdb_methods *methods,
957 enum SID_NAME_USE sid_name_use,
958 GROUP_MAP **rmap, int *num_entries,
959 BOOL unix_only)
960 {
961 return enum_group_mapping(sid_name_use, rmap, num_entries, unix_only) ?
962 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
963 }
964
965 /**********************************************************************
966 no ops for passdb backends that don't implement group mapping
967 *********************************************************************/
968
969 NTSTATUS pdb_nop_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
970 DOM_SID sid)
971 {
972 return NT_STATUS_UNSUCCESSFUL;
973 }
974
975 NTSTATUS pdb_nop_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
976 gid_t gid)
977 {
978 return NT_STATUS_UNSUCCESSFUL;
979 }
980
981 NTSTATUS pdb_nop_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
982 const char *name)
983 {
984 return NT_STATUS_UNSUCCESSFUL;
985 }
986
987 NTSTATUS pdb_nop_add_group_mapping_entry(struct pdb_methods *methods,
988 GROUP_MAP *map)
989 {
990 return NT_STATUS_UNSUCCESSFUL;
991 }
992
993 NTSTATUS pdb_nop_update_group_mapping_entry(struct pdb_methods *methods,
994 GROUP_MAP *map)
995 {
996 return NT_STATUS_UNSUCCESSFUL;
997 }
998
999 NTSTATUS pdb_nop_delete_group_mapping_entry(struct pdb_methods *methods,
1000 DOM_SID sid)
1001 {
1002 return NT_STATUS_UNSUCCESSFUL;
1003 }
1004
1005 NTSTATUS pdb_nop_enum_group_mapping(struct pdb_methods *methods,
1006 enum SID_NAME_USE sid_name_use,
1007 GROUP_MAP **rmap, int *num_entries,
1008 BOOL unix_only)
1009 {
1010 return NT_STATUS_UNSUCCESSFUL;
1011 }
1012
reg import