?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Add initshutdown pipe commands to rpcclient. Second part of fix to bug
[Samba/gebeck_regimport.git] / source / groupdb / mapping.c
blob7a07b5c344816bc3879204de654bed5bd772f2f9
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
633 if(!init_group_mapping()) {
634 DEBUG(0,("failed to initialize group mapping"));
635 return(False);
636 }
637
638 if ( (grp=getgrgid(gid)) == NULL)
639 return False;
640
641 /*
642 * make a group map from scratch if doesn't exist.
643 */
644 if (!pdb_getgrgid(map, gid)) {
645 map->gid=gid;
646 map->sid_name_use=SID_NAME_ALIAS;
647
648 /* interim solution until we have a last RID allocated */
649
650 sid_copy(&map->sid, get_global_sam_sid());
651 sid_append_rid(&map->sid, pdb_gid_to_group_rid(gid));
652
653 fstrcpy(map->nt_name, grp->gr_name);
654 fstrcpy(map->comment, "Local Unix Group");
655 }
656
657 return True;
658 }
659
660
661
662
663 /****************************************************************************
664 Get the member users of a group and
665 all the users who have that group as primary.
666
667 give back an array of uid
668 return the grand number of users
669
670
671 TODO: sort the list and remove duplicate. JFM.
672
673 ****************************************************************************/
674
675 BOOL get_uid_list_of_group(gid_t gid, uid_t **uid, int *num_uids)
676 {
677 struct group *grp;
678 struct passwd *pwd;
679 int i=0;
680 char *gr;
681 uid_t *u;
682
683 if(!init_group_mapping()) {
684 DEBUG(0,("failed to initialize group mapping"));
685 return(False);
686 }
687
688 *num_uids = 0;
689 *uid=NULL;
690
691 if ( (grp=getgrgid(gid)) == NULL)
692 return False;
693
694 gr = grp->gr_mem[0];
695 DEBUG(10, ("getting members\n"));
696
697 while (gr && (*gr != (char)'\0')) {
698 u = Realloc((*uid), sizeof(uid_t)*(*num_uids+1));
699 if (!u) {
700 DEBUG(0,("get_uid_list_of_group: unable to enlarge uid list!\n"));
701 return False;
702 }
703 else (*uid) = u;
704
705 if( (pwd=getpwnam_alloc(gr)) !=NULL) {
706 (*uid)[*num_uids]=pwd->pw_uid;
707 (*num_uids)++;
708 passwd_free(&pwd);
709 }
710 gr = grp->gr_mem[++i];
711 }
712 DEBUG(10, ("got [%d] members\n", *num_uids));
713
714 setpwent();
715 while ((pwd=getpwent()) != NULL) {
716 if (pwd->pw_gid==gid) {
717 u = Realloc((*uid), sizeof(uid_t)*(*num_uids+1));
718 if (!u) {
719 DEBUG(0,("get_uid_list_of_group: unable to enlarge uid list!\n"));
720 return False;
721 }
722 else (*uid) = u;
723 (*uid)[*num_uids]=pwd->pw_uid;
724
725 (*num_uids)++;
726 }
727 }
728 endpwent();
729 DEBUG(10, ("got primary groups, members: [%d]\n", *num_uids));
730
731 return True;
732 }
733
734 /****************************************************************************
735 Create a UNIX group on demand.
736 ****************************************************************************/
737
738 int smb_create_group(char *unix_group, gid_t *new_gid)
739 {
740 pstring add_script;
741 int ret = -1;
742 int fd = 0;
743
744 *new_gid = 0;
745
746 /* defer to scripts */
747
748 if ( *lp_addgroup_script() ) {
749 pstrcpy(add_script, lp_addgroup_script());
750 pstring_sub(add_script, "%g", unix_group);
751 ret = smbrun(add_script, (new_gid!=NULL) ? &fd : NULL);
752 DEBUG(3,("smb_create_group: Running the command `%s' gave %d\n",add_script,ret));
753 if (ret != 0)
754 return ret;
755
756 if (fd != 0) {
757 fstring output;
758
759 *new_gid = 0;
760 if (read(fd, output, sizeof(output)) > 0) {
761 *new_gid = (gid_t)strtoul(output, NULL, 10);
762 }
763
764 close(fd);
765 }
766 }
767
768 /* Try winbindd */
769
770 if ( winbind_create_group( unix_group, NULL ) ) {
771 DEBUG(3,("smb_create_group: winbindd created the group (%s)\n",
772 unix_group));
773 ret = 0;
774 }
775
776 if (*new_gid == 0) {
777 struct group *grp = getgrnam(unix_group);
778
779 if (grp != NULL)
780 *new_gid = grp->gr_gid;
781 }
782
783 return ret;
784 }
785
786 /****************************************************************************
787 Delete a UNIX group on demand.
788 ****************************************************************************/
789
790 int smb_delete_group(char *unix_group)
791 {
792 pstring del_script;
793 int ret;
794
795 /* defer to scripts */
796
797 if ( *lp_delgroup_script() ) {
798 pstrcpy(del_script, lp_delgroup_script());
799 pstring_sub(del_script, "%g", unix_group);
800 ret = smbrun(del_script,NULL);
801 DEBUG(3,("smb_delete_group: Running the command `%s' gave %d\n",del_script,ret));
802 return ret;
803 }
804
805 if ( winbind_delete_group( unix_group ) ) {
806 DEBUG(3,("smb_delete_group: winbindd deleted the group (%s)\n",
807 unix_group));
808 return 0;
809 }
810
811 return -1;
812 }
813
814 /****************************************************************************
815 Set a user's primary UNIX group.
816 ****************************************************************************/
817 int smb_set_primary_group(const char *unix_group, const char* unix_user)
818 {
819 pstring add_script;
820 int ret;
821
822 /* defer to scripts */
823
824 if ( *lp_setprimarygroup_script() ) {
825 pstrcpy(add_script, lp_setprimarygroup_script());
826 all_string_sub(add_script, "%g", unix_group, sizeof(add_script));
827 all_string_sub(add_script, "%u", unix_user, sizeof(add_script));
828 ret = smbrun(add_script,NULL);
829 DEBUG(3,("smb_set_primary_group: "
830 "Running the command `%s' gave %d\n",add_script,ret));
831 return ret;
832 }
833
834 /* Try winbindd */
835
836 if ( winbind_set_user_primary_group( unix_user, unix_group ) ) {
837 DEBUG(3,("smb_delete_group: winbindd set the group (%s) as the primary group for user (%s)\n",
838 unix_group, unix_user));
839 return 0;
840 }
841
842 return -1;
843 }
844
845 /****************************************************************************
846 Add a user to a UNIX group.
847 ****************************************************************************/
848
849 int smb_add_user_group(char *unix_group, char *unix_user)
850 {
851 pstring add_script;
852 int ret;
853
854 /* defer to scripts */
855
856 if ( *lp_addusertogroup_script() ) {
857 pstrcpy(add_script, lp_addusertogroup_script());
858 pstring_sub(add_script, "%g", unix_group);
859 pstring_sub(add_script, "%u", unix_user);
860 ret = smbrun(add_script,NULL);
861 DEBUG(3,("smb_add_user_group: Running the command `%s' gave %d\n",add_script,ret));
862 return ret;
863 }
864
865 /* Try winbindd */
866
867 if ( winbind_add_user_to_group( unix_user, unix_group ) ) {
868 DEBUG(3,("smb_delete_group: winbindd added user (%s) to the group (%s)\n",
869 unix_user, unix_group));
870 return -1;
871 }
872
873 return -1;
874 }
875
876 /****************************************************************************
877 Delete a user from a UNIX group
878 ****************************************************************************/
879
880 int smb_delete_user_group(const char *unix_group, const char *unix_user)
881 {
882 pstring del_script;
883 int ret;
884
885 /* defer to scripts */
886
887 if ( *lp_deluserfromgroup_script() ) {
888 pstrcpy(del_script, lp_deluserfromgroup_script());
889 pstring_sub(del_script, "%g", unix_group);
890 pstring_sub(del_script, "%u", unix_user);
891 ret = smbrun(del_script,NULL);
892 DEBUG(3,("smb_delete_user_group: Running the command `%s' gave %d\n",del_script,ret));
893 return ret;
894 }
895
896 /* Try winbindd */
897
898 if ( winbind_remove_user_from_group( unix_user, unix_group ) ) {
899 DEBUG(3,("smb_delete_group: winbindd removed user (%s) from the group (%s)\n",
900 unix_user, unix_group));
901 return 0;
902 }
903
904 return -1;
905 }
906
907
908 NTSTATUS pdb_default_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
909 DOM_SID sid)
910 {
911 return get_group_map_from_sid(sid, map) ?
912 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
913 }
914
915 NTSTATUS pdb_default_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
916 gid_t gid)
917 {
918 return get_group_map_from_gid(gid, map) ?
919 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
920 }
921
922 NTSTATUS pdb_default_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
923 const char *name)
924 {
925 return get_group_map_from_ntname(name, map) ?
926 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
927 }
928
929 NTSTATUS pdb_default_add_group_mapping_entry(struct pdb_methods *methods,
930 GROUP_MAP *map)
931 {
932 return add_mapping_entry(map, TDB_INSERT) ?
933 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
934 }
935
936 NTSTATUS pdb_default_update_group_mapping_entry(struct pdb_methods *methods,
937 GROUP_MAP *map)
938 {
939 return add_mapping_entry(map, TDB_REPLACE) ?
940 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
941 }
942
943 NTSTATUS pdb_default_delete_group_mapping_entry(struct pdb_methods *methods,
944 DOM_SID sid)
945 {
946 return group_map_remove(sid) ?
947 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
948 }
949
950 NTSTATUS pdb_default_enum_group_mapping(struct pdb_methods *methods,
951 enum SID_NAME_USE sid_name_use,
952 GROUP_MAP **rmap, int *num_entries,
953 BOOL unix_only)
954 {
955 return enum_group_mapping(sid_name_use, rmap, num_entries, unix_only) ?
956 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
957 }
958
959 /**********************************************************************
960 no ops for passdb backends that don't implement group mapping
961 *********************************************************************/
962
963 NTSTATUS pdb_nop_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
964 DOM_SID sid)
965 {
966 return NT_STATUS_UNSUCCESSFUL;
967 }
968
969 NTSTATUS pdb_nop_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
970 gid_t gid)
971 {
972 return NT_STATUS_UNSUCCESSFUL;
973 }
974
975 NTSTATUS pdb_nop_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
976 const char *name)
977 {
978 return NT_STATUS_UNSUCCESSFUL;
979 }
980
981 NTSTATUS pdb_nop_add_group_mapping_entry(struct pdb_methods *methods,
982 GROUP_MAP *map)
983 {
984 return NT_STATUS_UNSUCCESSFUL;
985 }
986
987 NTSTATUS pdb_nop_update_group_mapping_entry(struct pdb_methods *methods,
988 GROUP_MAP *map)
989 {
990 return NT_STATUS_UNSUCCESSFUL;
991 }
992
993 NTSTATUS pdb_nop_delete_group_mapping_entry(struct pdb_methods *methods,
994 DOM_SID sid)
995 {
996 return NT_STATUS_UNSUCCESSFUL;
997 }
998
999 NTSTATUS pdb_nop_enum_group_mapping(struct pdb_methods *methods,
1000 enum SID_NAME_USE sid_name_use,
1001 GROUP_MAP **rmap, int *num_entries,
1002 BOOL unix_only)
1003 {
1004 return NT_STATUS_UNSUCCESSFUL;
1005 }
1006
reg import