?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
r247: Fixup a couple of debug messages.
[Samba/gebeck_regimport.git] / source3 / groupdb / mapping.c
blob548651dfd538c6b1453c887f63525d543e8a56f5
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 /* Alias memberships are stored reverse, as memberships. The performance
32 * critical operation is to determine the aliases a SID is member of, not
33 * listing alias members. So we store a list of alias SIDs a SID is member of
34 * hanging of the member as key.
35 */
36 #define MEMBEROF_PREFIX "MEMBEROF/"
37
38 PRIVS privs[] = {
39 {SE_PRIV_NONE, "no_privs", "No privilege" }, /* this one MUST be first */
40 {SE_PRIV_ADD_MACHINES, "SeMachineAccountPrivilege", "Add workstations to the domain" },
41 {SE_PRIV_SEC_PRIV, "SeSecurityPrivilege", "Manage the audit logs" },
42 {SE_PRIV_TAKE_OWNER, "SeTakeOwnershipPrivilege", "Take ownership of file" },
43 {SE_PRIV_ADD_USERS, "SaAddUsers", "Add users to the domain - Samba" },
44 {SE_PRIV_PRINT_OPERATOR, "SaPrintOp", "Add or remove printers - Samba" },
45 {SE_PRIV_ALL, "SaAllPrivs", "all privileges" }
46 };
47
48
49 /****************************************************************************
50 dump the mapping group mapping to a text file
51 ****************************************************************************/
52 char *decode_sid_name_use(fstring group, enum SID_NAME_USE name_use)
53 {
54 static fstring group_type;
55
56 switch(name_use) {
57 case SID_NAME_USER:
58 fstrcpy(group_type,"User");
59 break;
60 case SID_NAME_DOM_GRP:
61 fstrcpy(group_type,"Domain group");
62 break;
63 case SID_NAME_DOMAIN:
64 fstrcpy(group_type,"Domain");
65 break;
66 case SID_NAME_ALIAS:
67 fstrcpy(group_type,"Local group");
68 break;
69 case SID_NAME_WKN_GRP:
70 fstrcpy(group_type,"Builtin group");
71 break;
72 case SID_NAME_DELETED:
73 fstrcpy(group_type,"Deleted");
74 break;
75 case SID_NAME_INVALID:
76 fstrcpy(group_type,"Invalid");
77 break;
78 case SID_NAME_UNKNOWN:
79 default:
80 fstrcpy(group_type,"Unknown type");
81 break;
82 }
83
84 fstrcpy(group, group_type);
85 return group_type;
86 }
87
88 /****************************************************************************
89 initialise first time the mapping list - called from init_group_mapping()
90 ****************************************************************************/
91 static BOOL default_group_mapping(void)
92 {
93 DOM_SID sid_admins;
94 DOM_SID sid_users;
95 DOM_SID sid_guests;
96 fstring str_admins;
97 fstring str_users;
98 fstring str_guests;
99
100 /* Add the Wellknown groups */
101
102 add_initial_entry(-1, "S-1-5-32-544", SID_NAME_WKN_GRP, "Administrators", "");
103 add_initial_entry(-1, "S-1-5-32-545", SID_NAME_WKN_GRP, "Users", "");
104 add_initial_entry(-1, "S-1-5-32-546", SID_NAME_WKN_GRP, "Guests", "");
105 add_initial_entry(-1, "S-1-5-32-547", SID_NAME_WKN_GRP, "Power Users", "");
106 add_initial_entry(-1, "S-1-5-32-548", SID_NAME_WKN_GRP, "Account Operators", "");
107 add_initial_entry(-1, "S-1-5-32-549", SID_NAME_WKN_GRP, "System Operators", "");
108 add_initial_entry(-1, "S-1-5-32-550", SID_NAME_WKN_GRP, "Print Operators", "");
109 add_initial_entry(-1, "S-1-5-32-551", SID_NAME_WKN_GRP, "Backup Operators", "");
110 add_initial_entry(-1, "S-1-5-32-552", SID_NAME_WKN_GRP, "Replicators", "");
111
112 /* Add the defaults domain groups */
113
114 sid_copy(&sid_admins, get_global_sam_sid());
115 sid_append_rid(&sid_admins, DOMAIN_GROUP_RID_ADMINS);
116 sid_to_string(str_admins, &sid_admins);
117 add_initial_entry(-1, str_admins, SID_NAME_DOM_GRP, "Domain Admins", "");
118
119 sid_copy(&sid_users, get_global_sam_sid());
120 sid_append_rid(&sid_users, DOMAIN_GROUP_RID_USERS);
121 sid_to_string(str_users, &sid_users);
122 add_initial_entry(-1, str_users, SID_NAME_DOM_GRP, "Domain Users", "");
123
124 sid_copy(&sid_guests, get_global_sam_sid());
125 sid_append_rid(&sid_guests, DOMAIN_GROUP_RID_GUESTS);
126 sid_to_string(str_guests, &sid_guests);
127 add_initial_entry(-1, str_guests, SID_NAME_DOM_GRP, "Domain Guests", "");
128
129 return True;
130 }
131
132 /****************************************************************************
133 Open the group mapping tdb.
134 ****************************************************************************/
135
136 static BOOL init_group_mapping(void)
137 {
138 static pid_t local_pid;
139 const char *vstring = "INFO/version";
140 int32 vers_id;
141
142 if (tdb && local_pid == sys_getpid())
143 return True;
144 tdb = tdb_open_log(lock_path("group_mapping.tdb"), 0, TDB_DEFAULT, O_RDWR|O_CREAT, 0600);
145 if (!tdb) {
146 DEBUG(0,("Failed to open group mapping database\n"));
147 return False;
148 }
149
150 local_pid = sys_getpid();
151
152 /* handle a Samba upgrade */
153 tdb_lock_bystring(tdb, vstring, 0);
154
155 /* Cope with byte-reversed older versions of the db. */
156 vers_id = tdb_fetch_int32(tdb, vstring);
157 if ((vers_id == DATABASE_VERSION_V1) || (IREV(vers_id) == DATABASE_VERSION_V1)) {
158 /* Written on a bigendian machine with old fetch_int code. Save as le. */
159 tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
160 vers_id = DATABASE_VERSION_V2;
161 }
162
163 if (vers_id != DATABASE_VERSION_V2) {
164 tdb_traverse(tdb, tdb_traverse_delete_fn, NULL);
165 tdb_store_int32(tdb, vstring, DATABASE_VERSION_V2);
166 }
167
168 tdb_unlock_bystring(tdb, vstring);
169
170 /* write a list of default groups */
171 if(!default_group_mapping())
172 return False;
173
174 return True;
175 }
176
177 /****************************************************************************
178 ****************************************************************************/
179 static BOOL add_mapping_entry(GROUP_MAP *map, int flag)
180 {
181 TDB_DATA kbuf, dbuf;
182 pstring key, buf;
183 fstring string_sid="";
184 int len;
185
186 if(!init_group_mapping()) {
187 DEBUG(0,("failed to initialize group mapping\n"));
188 return(False);
189 }
190
191 sid_to_string(string_sid, &map->sid);
192
193 len = tdb_pack(buf, sizeof(buf), "ddff",
194 map->gid, map->sid_name_use, map->nt_name, map->comment);
195
196 if (len > sizeof(buf))
197 return False;
198
199 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
200
201 kbuf.dsize = strlen(key)+1;
202 kbuf.dptr = key;
203 dbuf.dsize = len;
204 dbuf.dptr = buf;
205 if (tdb_store(tdb, kbuf, dbuf, flag) != 0) return False;
206
207 return True;
208 }
209
210 /****************************************************************************
211 initialise first time the mapping list
212 ****************************************************************************/
213 BOOL add_initial_entry(gid_t gid, const char *sid, enum SID_NAME_USE sid_name_use, const char *nt_name, const char *comment)
214 {
215 GROUP_MAP map;
216
217 if(!init_group_mapping()) {
218 DEBUG(0,("failed to initialize group mapping\n"));
219 return(False);
220 }
221
222 map.gid=gid;
223 if (!string_to_sid(&map.sid, sid)) {
224 DEBUG(0, ("string_to_sid failed: %s", sid));
225 return False;
226 }
227
228 map.sid_name_use=sid_name_use;
229 fstrcpy(map.nt_name, nt_name);
230 fstrcpy(map.comment, comment);
231
232 return pdb_add_group_mapping_entry(&map);
233 }
234
235 /****************************************************************************
236 Return the sid and the type of the unix group.
237 ****************************************************************************/
238
239 static BOOL get_group_map_from_sid(DOM_SID sid, GROUP_MAP *map)
240 {
241 TDB_DATA kbuf, dbuf;
242 pstring key;
243 fstring string_sid;
244 int ret = 0;
245
246 if(!init_group_mapping()) {
247 DEBUG(0,("failed to initialize group mapping\n"));
248 return(False);
249 }
250
251 /* the key is the SID, retrieving is direct */
252
253 sid_to_string(string_sid, &sid);
254 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
255
256 kbuf.dptr = key;
257 kbuf.dsize = strlen(key)+1;
258
259 dbuf = tdb_fetch(tdb, kbuf);
260 if (!dbuf.dptr)
261 return False;
262
263 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
264 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
265
266 SAFE_FREE(dbuf.dptr);
267
268 if ( ret == -1 ) {
269 DEBUG(3,("get_group_map_from_sid: tdb_unpack failure\n"));
270 return False;
271 }
272
273 sid_copy(&map->sid, &sid);
274
275 return True;
276 }
277
278 /****************************************************************************
279 Return the sid and the type of the unix group.
280 ****************************************************************************/
281
282 static BOOL get_group_map_from_gid(gid_t gid, GROUP_MAP *map)
283 {
284 TDB_DATA kbuf, dbuf, newkey;
285 fstring string_sid;
286 int ret;
287
288 if(!init_group_mapping()) {
289 DEBUG(0,("failed to initialize group mapping\n"));
290 return(False);
291 }
292
293 /* we need to enumerate the TDB to find the GID */
294
295 for (kbuf = tdb_firstkey(tdb);
296 kbuf.dptr;
297 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
298
299 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
300
301 dbuf = tdb_fetch(tdb, kbuf);
302 if (!dbuf.dptr)
303 continue;
304
305 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
306
307 string_to_sid(&map->sid, string_sid);
308
309 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
310 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
311
312 SAFE_FREE(dbuf.dptr);
313
314 if ( ret == -1 ) {
315 DEBUG(3,("get_group_map_from_gid: tdb_unpack failure\n"));
316 return False;
317 }
318
319 if (gid==map->gid) {
320 SAFE_FREE(kbuf.dptr);
321 return True;
322 }
323 }
324
325 return False;
326 }
327
328 /****************************************************************************
329 Return the sid and the type of the unix group.
330 ****************************************************************************/
331
332 static BOOL get_group_map_from_ntname(const char *name, GROUP_MAP *map)
333 {
334 TDB_DATA kbuf, dbuf, newkey;
335 fstring string_sid;
336 int ret;
337
338 if(!init_group_mapping()) {
339 DEBUG(0,("get_group_map_from_ntname:failed to initialize group mapping\n"));
340 return(False);
341 }
342
343 /* we need to enumerate the TDB to find the name */
344
345 for (kbuf = tdb_firstkey(tdb);
346 kbuf.dptr;
347 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
348
349 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0) continue;
350
351 dbuf = tdb_fetch(tdb, kbuf);
352 if (!dbuf.dptr)
353 continue;
354
355 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
356
357 string_to_sid(&map->sid, string_sid);
358
359 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
360 &map->gid, &map->sid_name_use, &map->nt_name, &map->comment);
361
362 SAFE_FREE(dbuf.dptr);
363
364 if ( ret == -1 ) {
365 DEBUG(3,("get_group_map_from_ntname: tdb_unpack failure\n"));
366 return False;
367 }
368
369 if (StrCaseCmp(name, map->nt_name)==0) {
370 SAFE_FREE(kbuf.dptr);
371 return True;
372 }
373 }
374
375 return False;
376 }
377
378 /****************************************************************************
379 Remove a group mapping entry.
380 ****************************************************************************/
381
382 static BOOL group_map_remove(DOM_SID sid)
383 {
384 TDB_DATA kbuf, dbuf;
385 pstring key;
386 fstring string_sid;
387
388 if(!init_group_mapping()) {
389 DEBUG(0,("failed to initialize group mapping\n"));
390 return(False);
391 }
392
393 /* the key is the SID, retrieving is direct */
394
395 sid_to_string(string_sid, &sid);
396 slprintf(key, sizeof(key), "%s%s", GROUP_PREFIX, string_sid);
397
398 kbuf.dptr = key;
399 kbuf.dsize = strlen(key)+1;
400
401 dbuf = tdb_fetch(tdb, kbuf);
402 if (!dbuf.dptr)
403 return False;
404
405 SAFE_FREE(dbuf.dptr);
406
407 if(tdb_delete(tdb, kbuf) != TDB_SUCCESS)
408 return False;
409
410 return True;
411 }
412
413 /****************************************************************************
414 Enumerate the group mapping.
415 ****************************************************************************/
416
417 static BOOL enum_group_mapping(enum SID_NAME_USE sid_name_use, GROUP_MAP **rmap,
418 int *num_entries, BOOL unix_only)
419 {
420 TDB_DATA kbuf, dbuf, newkey;
421 fstring string_sid;
422 fstring group_type;
423 GROUP_MAP map;
424 GROUP_MAP *mapt;
425 int ret;
426 int entries=0;
427
428 if(!init_group_mapping()) {
429 DEBUG(0,("failed to initialize group mapping\n"));
430 return(False);
431 }
432
433 *num_entries=0;
434 *rmap=NULL;
435
436 for (kbuf = tdb_firstkey(tdb);
437 kbuf.dptr;
438 newkey = tdb_nextkey(tdb, kbuf), safe_free(kbuf.dptr), kbuf=newkey) {
439
440 if (strncmp(kbuf.dptr, GROUP_PREFIX, strlen(GROUP_PREFIX)) != 0)
441 continue;
442
443 dbuf = tdb_fetch(tdb, kbuf);
444 if (!dbuf.dptr)
445 continue;
446
447 fstrcpy(string_sid, kbuf.dptr+strlen(GROUP_PREFIX));
448
449 ret = tdb_unpack(dbuf.dptr, dbuf.dsize, "ddff",
450 &map.gid, &map.sid_name_use, &map.nt_name, &map.comment);
451
452 SAFE_FREE(dbuf.dptr);
453
454 if ( ret == -1 ) {
455 DEBUG(3,("enum_group_mapping: tdb_unpack failure\n"));
456 continue;
457 }
458
459 /* list only the type or everything if UNKNOWN */
460 if (sid_name_use!=SID_NAME_UNKNOWN && sid_name_use!=map.sid_name_use) {
461 DEBUG(11,("enum_group_mapping: group %s is not of the requested type\n", map.nt_name));
462 continue;
463 }
464
465 if (unix_only==ENUM_ONLY_MAPPED && map.gid==-1) {
466 DEBUG(11,("enum_group_mapping: group %s is non mapped\n", map.nt_name));
467 continue;
468 }
469
470 string_to_sid(&map.sid, string_sid);
471
472 decode_sid_name_use(group_type, map.sid_name_use);
473 DEBUG(11,("enum_group_mapping: returning group %s of type %s\n", map.nt_name ,group_type));
474
475 mapt=(GROUP_MAP *)Realloc((*rmap), (entries+1)*sizeof(GROUP_MAP));
476 if (!mapt) {
477 DEBUG(0,("enum_group_mapping: Unable to enlarge group map!\n"));
478 SAFE_FREE(*rmap);
479 return False;
480 }
481 else
482 (*rmap) = mapt;
483
484 mapt[entries].gid = map.gid;
485 sid_copy( &mapt[entries].sid, &map.sid);
486 mapt[entries].sid_name_use = map.sid_name_use;
487 fstrcpy(mapt[entries].nt_name, map.nt_name);
488 fstrcpy(mapt[entries].comment, map.comment);
489
490 entries++;
491
492 }
493
494 *num_entries=entries;
495
496 return True;
497 }
498
499 /* This operation happens on session setup, so it should better be fast. We
500 * store a list of aliases a SID is member of hanging off MEMBEROF/SID. */
501
502 static NTSTATUS alias_memberships(const DOM_SID *sid, DOM_SID **sids, int *num)
503 {
504 fstring key, string_sid;
505 TDB_DATA kbuf, dbuf;
506 const char *p;
507
508 *num = 0;
509 *sids = NULL;
510
511 if (!init_group_mapping()) {
512 DEBUG(0,("failed to initialize group mapping\n"));
513 return NT_STATUS_ACCESS_DENIED;
514 }
515
516 sid_to_string(string_sid, sid);
517 slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX, string_sid);
518
519 kbuf.dsize = strlen(key)+1;
520 kbuf.dptr = key;
521
522 dbuf = tdb_fetch(tdb, kbuf);
523
524 if (dbuf.dptr == NULL) {
525 return NT_STATUS_OK;
526 }
527
528 p = dbuf.dptr;
529
530 while (next_token(&p, string_sid, " ", sizeof(string_sid))) {
531
532 DOM_SID alias;
533
534 if (!string_to_sid(&alias, string_sid))
535 continue;
536
537 add_sid_to_array(&alias, sids, num);
538
539 if (sids == NULL)
540 return NT_STATUS_NO_MEMORY;
541 }
542
543 SAFE_FREE(dbuf.dptr);
544 return NT_STATUS_OK;
545 }
546
547 static BOOL is_aliasmem(const DOM_SID *alias, const DOM_SID *member)
548 {
549 DOM_SID *sids;
550 int i, num;
551
552 /* This feels the wrong way round, but the on-disk data structure
553 * dictates it this way. */
554 if (!NT_STATUS_IS_OK(alias_memberships(member, &sids, &num)))
555 return False;
556
557 for (i=0; i<num; i++) {
558 if (sid_compare(alias, &sids[i]) == 0) {
559 SAFE_FREE(sids);
560 return True;
561 }
562 }
563 SAFE_FREE(sids);
564 return False;
565 }
566
567 static NTSTATUS add_aliasmem(const DOM_SID *alias, const DOM_SID *member)
568 {
569 GROUP_MAP map;
570 TDB_DATA kbuf, dbuf;
571 pstring key;
572 fstring string_sid;
573 char *new_memberstring;
574 int result;
575
576 if(!init_group_mapping()) {
577 DEBUG(0,("failed to initialize group mapping\n"));
578 return NT_STATUS_ACCESS_DENIED;
579 }
580
581 if (!get_group_map_from_sid(*alias, &map))
582 return NT_STATUS_NO_SUCH_ALIAS;
583
584 if ( (map.sid_name_use != SID_NAME_ALIAS) &&
585 (map.sid_name_use != SID_NAME_WKN_GRP) )
586 return NT_STATUS_NO_SUCH_ALIAS;
587
588 if (is_aliasmem(alias, member))
589 return NT_STATUS_MEMBER_IN_ALIAS;
590
591 sid_to_string(string_sid, member);
592 slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX, string_sid);
593
594 kbuf.dsize = strlen(key)+1;
595 kbuf.dptr = key;
596
597 dbuf = tdb_fetch(tdb, kbuf);
598
599 sid_to_string(string_sid, alias);
600
601 if (dbuf.dptr != NULL) {
602 asprintf(&new_memberstring, "%s %s", (char *)(dbuf.dptr),
603 string_sid);
604 } else {
605 new_memberstring = strdup(string_sid);
606 }
607
608 if (new_memberstring == NULL)
609 return NT_STATUS_NO_MEMORY;
610
611 SAFE_FREE(dbuf.dptr);
612 dbuf.dsize = strlen(new_memberstring)+1;
613 dbuf.dptr = new_memberstring;
614
615 result = tdb_store(tdb, kbuf, dbuf, 0);
616
617 SAFE_FREE(new_memberstring);
618
619 return (result == 0 ? NT_STATUS_OK : NT_STATUS_ACCESS_DENIED);
620 }
621
622 struct aliasmem_closure {
623 const DOM_SID *alias;
624 DOM_SID **sids;
625 int *num;
626 };
627
628 static int collect_aliasmem(TDB_CONTEXT *tdb_ctx, TDB_DATA key, TDB_DATA data,
629 void *state)
630 {
631 struct aliasmem_closure *closure = (struct aliasmem_closure *)state;
632 const char *p;
633 fstring alias_string;
634
635 if (strncmp(key.dptr, MEMBEROF_PREFIX,
636 strlen(MEMBEROF_PREFIX)) != 0)
637 return 0;
638
639 p = data.dptr;
640
641 while (next_token(&p, alias_string, " ", sizeof(alias_string))) {
642
643 DOM_SID alias, member;
644 const char *member_string;
645
646
647 if (!string_to_sid(&alias, alias_string))
648 continue;
649
650 if (sid_compare(closure->alias, &alias) != 0)
651 continue;
652
653 /* Ok, we found the alias we're looking for in the membership
654 * list currently scanned. The key represents the alias
655 * member. Add that. */
656
657 member_string = strchr(key.dptr, '/');
658
659 /* Above we tested for MEMBEROF_PREFIX which includes the
660 * slash. */
661
662 SMB_ASSERT(member_string != NULL);
663 member_string += 1;
664
665 if (!string_to_sid(&member, member_string))
666 continue;
667
668 add_sid_to_array(&member, closure->sids, closure->num);
669 }
670
671 return 0;
672 }
673
674 static NTSTATUS enum_aliasmem(const DOM_SID *alias, DOM_SID **sids, int *num)
675 {
676 GROUP_MAP map;
677 struct aliasmem_closure closure;
678
679 if(!init_group_mapping()) {
680 DEBUG(0,("failed to initialize group mapping\n"));
681 return NT_STATUS_ACCESS_DENIED;
682 }
683
684 if (!get_group_map_from_sid(*alias, &map))
685 return NT_STATUS_NO_SUCH_ALIAS;
686
687 if ( (map.sid_name_use != SID_NAME_ALIAS) &&
688 (map.sid_name_use != SID_NAME_WKN_GRP) )
689 return NT_STATUS_NO_SUCH_ALIAS;
690
691 *sids = NULL;
692 *num = 0;
693
694 closure.alias = alias;
695 closure.sids = sids;
696 closure.num = num;
697
698 tdb_traverse(tdb, collect_aliasmem, &closure);
699 return NT_STATUS_OK;
700 }
701
702 static NTSTATUS del_aliasmem(const DOM_SID *alias, const DOM_SID *member)
703 {
704 NTSTATUS result;
705 DOM_SID *sids;
706 int i, num;
707 BOOL found = False;
708 char *member_string;
709 TDB_DATA kbuf, dbuf;
710 pstring key;
711 fstring sid_string;
712
713 result = alias_memberships(member, &sids, &num);
714
715 if (!NT_STATUS_IS_OK(result))
716 return result;
717
718 for (i=0; i<num; i++) {
719 if (sid_compare(&sids[i], alias) == 0) {
720 found = True;
721 break;
722 }
723 }
724
725 if (!found) {
726 SAFE_FREE(sids);
727 return NT_STATUS_MEMBER_NOT_IN_ALIAS;
728 }
729
730 if (i < num)
731 sids[i] = sids[num-1];
732
733 num -= 1;
734
735 sid_to_string(sid_string, member);
736 slprintf(key, sizeof(key), "%s%s", MEMBEROF_PREFIX, sid_string);
737
738 kbuf.dsize = strlen(key)+1;
739 kbuf.dptr = key;
740
741 if (num == 0)
742 return tdb_delete(tdb, kbuf) == 0 ?
743 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
744
745 member_string = strdup("");
746
747 if (member_string == NULL) {
748 SAFE_FREE(sids);
749 return NT_STATUS_NO_MEMORY;
750 }
751
752 for (i=0; i<num; i++) {
753 char *s = member_string;
754
755 sid_to_string(sid_string, &sids[i]);
756 asprintf(&member_string, "%s %s", s, sid_string);
757
758 SAFE_FREE(s);
759 if (member_string == NULL) {
760 SAFE_FREE(sids);
761 return NT_STATUS_NO_MEMORY;
762 }
763 }
764
765 dbuf.dsize = strlen(member_string)+1;
766 dbuf.dptr = member_string;
767
768 result = tdb_store(tdb, kbuf, dbuf, 0) == 0 ?
769 NT_STATUS_OK : NT_STATUS_ACCESS_DENIED;
770
771 SAFE_FREE(sids);
772 SAFE_FREE(member_string);
773
774 return result;
775 }
776
777 /*
778 *
779 * High level functions
780 * better to use them than the lower ones.
781 *
782 * we are checking if the group is in the mapping file
783 * and if the group is an existing unix group
784 *
785 */
786
787 /* get a domain group from it's SID */
788
789 BOOL get_domain_group_from_sid(DOM_SID sid, GROUP_MAP *map)
790 {
791 struct group *grp;
792 BOOL ret;
793
794 if(!init_group_mapping()) {
795 DEBUG(0,("failed to initialize group mapping\n"));
796 return(False);
797 }
798
799 DEBUG(10, ("get_domain_group_from_sid\n"));
800
801 /* if the group is NOT in the database, it CAN NOT be a domain group */
802
803 become_root();
804 ret = pdb_getgrsid(map, sid);
805 unbecome_root();
806
807 if ( !ret )
808 return False;
809
810 DEBUG(10, ("get_domain_group_from_sid: SID found in the TDB\n"));
811
812 /* if it's not a domain group, continue */
813 if (map->sid_name_use!=SID_NAME_DOM_GRP) {
814 return False;
815 }
816
817 DEBUG(10, ("get_domain_group_from_sid: SID is a domain group\n"));
818
819 if (map->gid==-1) {
820 return False;
821 }
822
823 DEBUG(10, ("get_domain_group_from_sid: SID is mapped to gid:%lu\n",(unsigned long)map->gid));
824
825 grp = getgrgid(map->gid);
826 if ( !grp ) {
827 DEBUG(10, ("get_domain_group_from_sid: gid DOESN'T exist in UNIX security\n"));
828 return False;
829 }
830
831 DEBUG(10, ("get_domain_group_from_sid: gid exists in UNIX security\n"));
832
833 return True;
834 }
835
836
837 /* get a local (alias) group from it's SID */
838
839 BOOL get_local_group_from_sid(DOM_SID *sid, GROUP_MAP *map)
840 {
841 BOOL ret;
842
843 if(!init_group_mapping()) {
844 DEBUG(0,("failed to initialize group mapping\n"));
845 return(False);
846 }
847
848 /* The group is in the mapping table */
849 become_root();
850 ret = pdb_getgrsid(map, *sid);
851 unbecome_root();
852
853 if ( !ret )
854 return False;
855
856 if ( ( (map->sid_name_use != SID_NAME_ALIAS) &&
857 (map->sid_name_use != SID_NAME_WKN_GRP) )
858 || (map->gid == -1)
859 || (getgrgid(map->gid) == NULL) )
860 {
861 return False;
862 }
863
864 #if 1 /* JERRY */
865 /* local groups only exist in the group mapping DB so this
866 is not necessary */
867
868 else {
869 /* the group isn't in the mapping table.
870 * make one based on the unix information */
871 uint32 alias_rid;
872 struct group *grp;
873
874 sid_peek_rid(sid, &alias_rid);
875 map->gid=pdb_group_rid_to_gid(alias_rid);
876
877 grp = getgrgid(map->gid);
878 if ( !grp ) {
879 DEBUG(3,("get_local_group_from_sid: No unix group for [%ul]\n", map->gid));
880 return False;
881 }
882
883 map->sid_name_use=SID_NAME_ALIAS;
884
885 fstrcpy(map->nt_name, grp->gr_name);
886 fstrcpy(map->comment, "Local Unix Group");
887
888 sid_copy(&map->sid, sid);
889 }
890 #endif
891
892 return True;
893 }
894
895 /* get a builtin group from it's SID */
896
897 BOOL get_builtin_group_from_sid(DOM_SID *sid, GROUP_MAP *map)
898 {
899 struct group *grp;
900 BOOL ret;
901
902
903 if(!init_group_mapping()) {
904 DEBUG(0,("failed to initialize group mapping\n"));
905 return(False);
906 }
907
908 become_root();
909 ret = pdb_getgrsid(map, *sid);
910 unbecome_root();
911
912 if ( !ret )
913 return False;
914
915 if (map->sid_name_use!=SID_NAME_WKN_GRP) {
916 return False;
917 }
918
919 if (map->gid==-1) {
920 return False;
921 }
922
923 if ( (grp=getgrgid(map->gid)) == NULL) {
924 return False;
925 }
926
927 return True;
928 }
929
930
931
932 /****************************************************************************
933 Returns a GROUP_MAP struct based on the gid.
934 ****************************************************************************/
935 BOOL get_group_from_gid(gid_t gid, GROUP_MAP *map)
936 {
937 struct group *grp;
938 BOOL ret;
939
940 if(!init_group_mapping()) {
941 DEBUG(0,("failed to initialize group mapping\n"));
942 return(False);
943 }
944
945 if ( (grp=getgrgid(gid)) == NULL)
946 return False;
947
948 /*
949 * make a group map from scratch if doesn't exist.
950 */
951
952 become_root();
953 ret = pdb_getgrgid(map, gid);
954 unbecome_root();
955
956 if ( !ret ) {
957 map->gid=gid;
958 map->sid_name_use=SID_NAME_ALIAS;
959
960 /* interim solution until we have a last RID allocated */
961
962 sid_copy(&map->sid, get_global_sam_sid());
963 sid_append_rid(&map->sid, pdb_gid_to_group_rid(gid));
964
965 fstrcpy(map->nt_name, grp->gr_name);
966 fstrcpy(map->comment, "Local Unix Group");
967 }
968
969 return True;
970 }
971
972
973
974
975 /****************************************************************************
976 Get the member users of a group and
977 all the users who have that group as primary.
978
979 give back an array of SIDS
980 return the grand number of users
981
982
983 TODO: sort the list and remove duplicate. JFM.
984
985 ****************************************************************************/
986
987 BOOL get_sid_list_of_group(gid_t gid, DOM_SID **sids, int *num_sids)
988 {
989 struct group *grp;
990 int i=0;
991 char *gr;
992 DOM_SID *s;
993
994 struct sys_pwent *userlist;
995 struct sys_pwent *user;
996
997 if(!init_group_mapping()) {
998 DEBUG(0,("failed to initialize group mapping\n"));
999 return(False);
1000 }
1001
1002 *num_sids = 0;
1003 *sids=NULL;
1004
1005 if ( (grp=getgrgid(gid)) == NULL)
1006 return False;
1007
1008 gr = grp->gr_mem[0];
1009 DEBUG(10, ("getting members\n"));
1010
1011 while (gr && (*gr != (char)'\0')) {
1012 SAM_ACCOUNT *group_member_acct = NULL;
1013 BOOL found_user;
1014 s = Realloc((*sids), sizeof(**sids)*(*num_sids+1));
1015 if (!s) {
1016 DEBUG(0,("get_uid_list_of_group: unable to enlarge SID list!\n"));
1017 return False;
1018 }
1019 else (*sids) = s;
1020
1021 if (!NT_STATUS_IS_OK(pdb_init_sam(&group_member_acct))) {
1022 continue;
1023 }
1024
1025 become_root();
1026 found_user = pdb_getsampwnam(group_member_acct, gr);
1027 unbecome_root();
1028
1029 if (found_user) {
1030 sid_copy(&(*sids)[*num_sids], pdb_get_user_sid(group_member_acct));
1031 (*num_sids)++;
1032 }
1033
1034 pdb_free_sam(&group_member_acct);
1035
1036 gr = grp->gr_mem[++i];
1037 }
1038 DEBUG(10, ("got [%d] members\n", *num_sids));
1039
1040 winbind_off();
1041
1042 user = userlist = getpwent_list();
1043
1044 while (user != NULL) {
1045
1046 SAM_ACCOUNT *group_member_acct = NULL;
1047 BOOL found_user;
1048
1049 if (user->pw_gid != gid) {
1050 user = user->next;
1051 continue;
1052 }
1053
1054 s = Realloc((*sids), sizeof(**sids)*(*num_sids+1));
1055 if (!s) {
1056 DEBUG(0,("get_sid_list_of_group: unable to enlarge "
1057 "SID list!\n"));
1058 pwent_free(userlist);
1059 winbind_on();
1060 return False;
1061 }
1062 else (*sids) = s;
1063
1064 if (!NT_STATUS_IS_OK(pdb_init_sam(&group_member_acct))) {
1065 continue;
1066 }
1067
1068 become_root();
1069 found_user = pdb_getsampwnam(group_member_acct, user->pw_name);
1070 unbecome_root();
1071
1072 if (found_user) {
1073 sid_copy(&(*sids)[*num_sids],
1074 pdb_get_user_sid(group_member_acct));
1075 (*num_sids)++;
1076 } else {
1077 DEBUG(4,("get_sid_list_of_group: User %s [uid == %lu] "
1078 "has no samba account\n",
1079 user->pw_name, (unsigned long)user->pw_uid));
1080 if (algorithmic_uid_to_sid(&(*sids)[*num_sids],
1081 user->pw_uid))
1082 (*num_sids)++;
1083 }
1084 pdb_free_sam(&group_member_acct);
1085
1086 user = user->next;
1087 }
1088 pwent_free(userlist);
1089 DEBUG(10, ("got primary groups, members: [%d]\n", *num_sids));
1090
1091 winbind_on();
1092 return True;
1093 }
1094
1095 /****************************************************************************
1096 Create a UNIX group on demand.
1097 ****************************************************************************/
1098
1099 int smb_create_group(char *unix_group, gid_t *new_gid)
1100 {
1101 pstring add_script;
1102 int ret = -1;
1103 int fd = 0;
1104
1105 *new_gid = 0;
1106
1107 /* defer to scripts */
1108
1109 if ( *lp_addgroup_script() ) {
1110 pstrcpy(add_script, lp_addgroup_script());
1111 pstring_sub(add_script, "%g", unix_group);
1112 ret = smbrun(add_script, (new_gid!=NULL) ? &fd : NULL);
1113 DEBUG(3,("smb_create_group: Running the command `%s' gave %d\n",add_script,ret));
1114 if (ret != 0)
1115 return ret;
1116
1117 if (fd != 0) {
1118 fstring output;
1119
1120 *new_gid = 0;
1121 if (read(fd, output, sizeof(output)) > 0) {
1122 *new_gid = (gid_t)strtoul(output, NULL, 10);
1123 }
1124
1125 close(fd);
1126 }
1127
1128 } else if ( winbind_create_group( unix_group, NULL ) ) {
1129
1130 DEBUG(3,("smb_create_group: winbindd created the group (%s)\n",
1131 unix_group));
1132 ret = 0;
1133 }
1134
1135 if (*new_gid == 0) {
1136 struct group *grp = getgrnam(unix_group);
1137
1138 if (grp != NULL)
1139 *new_gid = grp->gr_gid;
1140 }
1141
1142 return ret;
1143 }
1144
1145 /****************************************************************************
1146 Delete a UNIX group on demand.
1147 ****************************************************************************/
1148
1149 int smb_delete_group(char *unix_group)
1150 {
1151 pstring del_script;
1152 int ret;
1153
1154 /* defer to scripts */
1155
1156 if ( *lp_delgroup_script() ) {
1157 pstrcpy(del_script, lp_delgroup_script());
1158 pstring_sub(del_script, "%g", unix_group);
1159 ret = smbrun(del_script,NULL);
1160 DEBUG(3,("smb_delete_group: Running the command `%s' gave %d\n",del_script,ret));
1161 return ret;
1162 }
1163
1164 if ( winbind_delete_group( unix_group ) ) {
1165 DEBUG(3,("smb_delete_group: winbindd deleted the group (%s)\n",
1166 unix_group));
1167 return 0;
1168 }
1169
1170 return -1;
1171 }
1172
1173 /****************************************************************************
1174 Set a user's primary UNIX group.
1175 ****************************************************************************/
1176 int smb_set_primary_group(const char *unix_group, const char* unix_user)
1177 {
1178 pstring add_script;
1179 int ret;
1180
1181 /* defer to scripts */
1182
1183 if ( *lp_setprimarygroup_script() ) {
1184 pstrcpy(add_script, lp_setprimarygroup_script());
1185 all_string_sub(add_script, "%g", unix_group, sizeof(add_script));
1186 all_string_sub(add_script, "%u", unix_user, sizeof(add_script));
1187 ret = smbrun(add_script,NULL);
1188 DEBUG(3,("smb_set_primary_group: "
1189 "Running the command `%s' gave %d\n",add_script,ret));
1190 return ret;
1191 }
1192
1193 /* Try winbindd */
1194
1195 if ( winbind_set_user_primary_group( unix_user, unix_group ) ) {
1196 DEBUG(3,("smb_delete_group: winbindd set the group (%s) as the primary group for user (%s)\n",
1197 unix_group, unix_user));
1198 return 0;
1199 }
1200
1201 return -1;
1202 }
1203
1204 /****************************************************************************
1205 Add a user to a UNIX group.
1206 ****************************************************************************/
1207
1208 int smb_add_user_group(char *unix_group, char *unix_user)
1209 {
1210 pstring add_script;
1211 int ret;
1212
1213 /* defer to scripts */
1214
1215 if ( *lp_addusertogroup_script() ) {
1216 pstrcpy(add_script, lp_addusertogroup_script());
1217 pstring_sub(add_script, "%g", unix_group);
1218 pstring_sub(add_script, "%u", unix_user);
1219 ret = smbrun(add_script,NULL);
1220 DEBUG(3,("smb_add_user_group: Running the command `%s' gave %d\n",add_script,ret));
1221 return ret;
1222 }
1223
1224 /* Try winbindd */
1225
1226 if ( winbind_add_user_to_group( unix_user, unix_group ) ) {
1227 DEBUG(3,("smb_delete_group: winbindd added user (%s) to the group (%s)\n",
1228 unix_user, unix_group));
1229 return -1;
1230 }
1231
1232 return -1;
1233 }
1234
1235 /****************************************************************************
1236 Delete a user from a UNIX group
1237 ****************************************************************************/
1238
1239 int smb_delete_user_group(const char *unix_group, const char *unix_user)
1240 {
1241 pstring del_script;
1242 int ret;
1243
1244 /* defer to scripts */
1245
1246 if ( *lp_deluserfromgroup_script() ) {
1247 pstrcpy(del_script, lp_deluserfromgroup_script());
1248 pstring_sub(del_script, "%g", unix_group);
1249 pstring_sub(del_script, "%u", unix_user);
1250 ret = smbrun(del_script,NULL);
1251 DEBUG(3,("smb_delete_user_group: Running the command `%s' gave %d\n",del_script,ret));
1252 return ret;
1253 }
1254
1255 /* Try winbindd */
1256
1257 if ( winbind_remove_user_from_group( unix_user, unix_group ) ) {
1258 DEBUG(3,("smb_delete_group: winbindd removed user (%s) from the group (%s)\n",
1259 unix_user, unix_group));
1260 return 0;
1261 }
1262
1263 return -1;
1264 }
1265
1266
1267 NTSTATUS pdb_default_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
1268 DOM_SID sid)
1269 {
1270 return get_group_map_from_sid(sid, map) ?
1271 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1272 }
1273
1274 NTSTATUS pdb_default_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
1275 gid_t gid)
1276 {
1277 return get_group_map_from_gid(gid, map) ?
1278 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1279 }
1280
1281 NTSTATUS pdb_default_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
1282 const char *name)
1283 {
1284 return get_group_map_from_ntname(name, map) ?
1285 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1286 }
1287
1288 NTSTATUS pdb_default_add_group_mapping_entry(struct pdb_methods *methods,
1289 GROUP_MAP *map)
1290 {
1291 return add_mapping_entry(map, TDB_INSERT) ?
1292 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1293 }
1294
1295 NTSTATUS pdb_default_update_group_mapping_entry(struct pdb_methods *methods,
1296 GROUP_MAP *map)
1297 {
1298 return add_mapping_entry(map, TDB_REPLACE) ?
1299 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1300 }
1301
1302 NTSTATUS pdb_default_delete_group_mapping_entry(struct pdb_methods *methods,
1303 DOM_SID sid)
1304 {
1305 return group_map_remove(sid) ?
1306 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1307 }
1308
1309 NTSTATUS pdb_default_enum_group_mapping(struct pdb_methods *methods,
1310 enum SID_NAME_USE sid_name_use,
1311 GROUP_MAP **rmap, int *num_entries,
1312 BOOL unix_only)
1313 {
1314 return enum_group_mapping(sid_name_use, rmap, num_entries, unix_only) ?
1315 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
1316 }
1317
1318 NTSTATUS pdb_default_find_alias(struct pdb_methods *methods,
1319 const char *name, DOM_SID *sid)
1320 {
1321 GROUP_MAP map;
1322
1323 if (!pdb_getgrnam(&map, name))
1324 return NT_STATUS_NO_SUCH_ALIAS;
1325
1326 if ((map.sid_name_use != SID_NAME_WKN_GRP) &&
1327 (map.sid_name_use != SID_NAME_ALIAS))
1328 return NT_STATUS_OBJECT_TYPE_MISMATCH;
1329
1330 sid_copy(sid, &map.sid);
1331 return NT_STATUS_OK;
1332 }
1333
1334 NTSTATUS pdb_default_create_alias(struct pdb_methods *methods,
1335 const char *name, uint32 *rid)
1336 {
1337 DOM_SID sid;
1338 enum SID_NAME_USE type;
1339 uint32 new_rid;
1340 gid_t gid;
1341
1342 GROUP_MAP map;
1343
1344 if (lookup_name(get_global_sam_name(), name, &sid, &type))
1345 return NT_STATUS_ALIAS_EXISTS;
1346
1347 if (!winbind_allocate_rid(&new_rid))
1348 return NT_STATUS_ACCESS_DENIED;
1349
1350 sid_copy(&sid, get_global_sam_sid());
1351 sid_append_rid(&sid, new_rid);
1352
1353 /* Here we allocate the gid */
1354 if (!winbind_sid_to_gid(&gid, &sid)) {
1355 DEBUG(0, ("Could not get gid for new RID\n"));
1356 return NT_STATUS_ACCESS_DENIED;
1357 }
1358
1359 map.gid = gid;
1360 sid_copy(&map.sid, &sid);
1361 map.sid_name_use = SID_NAME_ALIAS;
1362 fstrcpy(map.nt_name, name);
1363 fstrcpy(map.comment, "");
1364
1365 if (!pdb_add_group_mapping_entry(&map)) {
1366 DEBUG(0, ("Could not add group mapping entry for alias %s\n",
1367 name));
1368 return NT_STATUS_ACCESS_DENIED;
1369 }
1370
1371 *rid = new_rid;
1372
1373 return NT_STATUS_OK;
1374 }
1375
1376 NTSTATUS pdb_default_delete_alias(struct pdb_methods *methods,
1377 const DOM_SID *sid)
1378 {
1379 return pdb_delete_group_mapping_entry(*sid) ?
1380 NT_STATUS_OK : NT_STATUS_ACCESS_DENIED;
1381 }
1382
1383 NTSTATUS pdb_default_enum_aliases(struct pdb_methods *methods,
1384 const DOM_SID *sid,
1385 uint32 start_idx, uint32 max_entries,
1386 uint32 *num_aliases,
1387 struct acct_info **info)
1388 {
1389 extern DOM_SID global_sid_Builtin;
1390
1391 GROUP_MAP *map;
1392 int i, num_maps;
1393 enum SID_NAME_USE type = SID_NAME_UNKNOWN;
1394
1395 if (sid_compare(sid, get_global_sam_sid()) == 0)
1396 type = SID_NAME_ALIAS;
1397
1398 if (sid_compare(sid, &global_sid_Builtin) == 0)
1399 type = SID_NAME_WKN_GRP;
1400
1401 if (!pdb_enum_group_mapping(type, &map, &num_maps, False) ||
1402 (num_maps == 0)) {
1403 *num_aliases = 0;
1404 *info = NULL;
1405 goto done;
1406 }
1407
1408 if (start_idx > num_maps) {
1409 *num_aliases = 0;
1410 *info = NULL;
1411 goto done;
1412 }
1413
1414 *num_aliases = num_maps - start_idx;
1415
1416 if (*num_aliases > max_entries)
1417 *num_aliases = max_entries;
1418
1419 *info = malloc(sizeof(struct acct_info) * (*num_aliases));
1420
1421 for (i=0; i<*num_aliases; i++) {
1422 fstrcpy((*info)[i].acct_name, map[i+start_idx].nt_name);
1423 fstrcpy((*info)[i].acct_desc, map[i+start_idx].comment);
1424 sid_peek_rid(&map[i].sid, &(*info)[i+start_idx].rid);
1425 }
1426
1427 done:
1428 SAFE_FREE(map);
1429 return NT_STATUS_OK;
1430 }
1431
1432 NTSTATUS pdb_default_get_aliasinfo(struct pdb_methods *methods,
1433 const DOM_SID *sid,
1434 struct acct_info *info)
1435 {
1436 GROUP_MAP map;
1437
1438 if (!pdb_getgrsid(&map, *sid))
1439 return NT_STATUS_NO_SUCH_ALIAS;
1440
1441 fstrcpy(info->acct_name, map.nt_name);
1442 fstrcpy(info->acct_desc, map.comment);
1443 sid_peek_rid(&map.sid, &info->rid);
1444 return NT_STATUS_OK;
1445 }
1446
1447 NTSTATUS pdb_default_set_aliasinfo(struct pdb_methods *methods,
1448 const DOM_SID *sid,
1449 struct acct_info *info)
1450 {
1451 GROUP_MAP map;
1452
1453 if (!pdb_getgrsid(&map, *sid))
1454 return NT_STATUS_NO_SUCH_ALIAS;
1455
1456 fstrcpy(map.comment, info->acct_desc);
1457
1458 if (!pdb_update_group_mapping_entry(&map))
1459 return NT_STATUS_ACCESS_DENIED;
1460
1461 return NT_STATUS_OK;
1462 }
1463
1464 NTSTATUS pdb_default_add_aliasmem(struct pdb_methods *methods,
1465 const DOM_SID *alias, const DOM_SID *member)
1466 {
1467 return add_aliasmem(alias, member);
1468 }
1469
1470 NTSTATUS pdb_default_del_aliasmem(struct pdb_methods *methods,
1471 const DOM_SID *alias, const DOM_SID *member)
1472 {
1473 return del_aliasmem(alias, member);
1474 }
1475
1476 NTSTATUS pdb_default_enum_aliasmem(struct pdb_methods *methods,
1477 const DOM_SID *alias, DOM_SID **members,
1478 int *num_members)
1479 {
1480 return enum_aliasmem(alias, members, num_members);
1481 }
1482
1483 NTSTATUS pdb_default_alias_memberships(struct pdb_methods *methods,
1484 const DOM_SID *sid,
1485 DOM_SID **aliases, int *num)
1486 {
1487 return alias_memberships(sid, aliases, num);
1488 }
1489
1490 /**********************************************************************
1491 no ops for passdb backends that don't implement group mapping
1492 *********************************************************************/
1493
1494 NTSTATUS pdb_nop_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
1495 DOM_SID sid)
1496 {
1497 return NT_STATUS_UNSUCCESSFUL;
1498 }
1499
1500 NTSTATUS pdb_nop_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
1501 gid_t gid)
1502 {
1503 return NT_STATUS_UNSUCCESSFUL;
1504 }
1505
1506 NTSTATUS pdb_nop_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
1507 const char *name)
1508 {
1509 return NT_STATUS_UNSUCCESSFUL;
1510 }
1511
1512 NTSTATUS pdb_nop_add_group_mapping_entry(struct pdb_methods *methods,
1513 GROUP_MAP *map)
1514 {
1515 return NT_STATUS_UNSUCCESSFUL;
1516 }
1517
1518 NTSTATUS pdb_nop_update_group_mapping_entry(struct pdb_methods *methods,
1519 GROUP_MAP *map)
1520 {
1521 return NT_STATUS_UNSUCCESSFUL;
1522 }
1523
1524 NTSTATUS pdb_nop_delete_group_mapping_entry(struct pdb_methods *methods,
1525 DOM_SID sid)
1526 {
1527 return NT_STATUS_UNSUCCESSFUL;
1528 }
1529
1530 NTSTATUS pdb_nop_enum_group_mapping(struct pdb_methods *methods,
1531 enum SID_NAME_USE sid_name_use,
1532 GROUP_MAP **rmap, int *num_entries,
1533 BOOL unix_only)
1534 {
1535 return NT_STATUS_UNSUCCESSFUL;
1536 }
1537
reg import