2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1998
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
6 * Copyright (C) Paul Ashton 1997-1998.
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 /* this module apparently provides an implementation of DCE/RPC over a
24 * named pipe (IPC$ connection using SMBtrans). details of DCE/RPC
25 * documentation are available (in on-line form) from the X-Open group.
27 * this module should provide a level of abstraction between SMB
28 * and DCE/RPC, while minimising the amount of mallocs, unnecessary
29 * data copies, and network traffic.
31 * in this version, which takes a "let's learn what's going on and
32 * get something running" approach, there is additional network
33 * traffic generated, but the code should be easier to understand...
35 * ... if you read the docs. or stare at packets for weeks on end.
42 #define DBGC_CLASS DBGC_RPC_SRV
45 * A list of the rids of well known BUILTIN and Domain users
49 rid_name builtin_alias_rids[] =
51 { BUILTIN_ALIAS_RID_ADMINS , "Administrators" },
52 { BUILTIN_ALIAS_RID_USERS , "Users" },
53 { BUILTIN_ALIAS_RID_GUESTS , "Guests" },
54 { BUILTIN_ALIAS_RID_POWER_USERS , "Power Users" },
56 { BUILTIN_ALIAS_RID_ACCOUNT_OPS , "Account Operators" },
57 { BUILTIN_ALIAS_RID_SYSTEM_OPS , "System Operators" },
58 { BUILTIN_ALIAS_RID_PRINT_OPS , "Print Operators" },
59 { BUILTIN_ALIAS_RID_BACKUP_OPS , "Backup Operators" },
60 { BUILTIN_ALIAS_RID_REPLICATOR , "Replicator" },
64 /* array lookup of well-known Domain RID users. */
65 rid_name domain_user_rids[] =
67 { DOMAIN_USER_RID_ADMIN , "Administrator" },
68 { DOMAIN_USER_RID_GUEST , "Guest" },
72 /* array lookup of well-known Domain RID groups. */
73 rid_name domain_group_rids[] =
75 { DOMAIN_GROUP_RID_ADMINS , "Domain Admins" },
76 { DOMAIN_GROUP_RID_USERS , "Domain Users" },
77 { DOMAIN_GROUP_RID_GUESTS , "Domain Guests" },
81 /*******************************************************************
82 gets a domain user's groups
83 ********************************************************************/
84 NTSTATUS get_alias_user_groups(TALLOC_CTX *ctx, DOM_SID *sid, int *numgroups, uint32 **prids, DOM_SID *q_sid)
86 SAM_ACCOUNT *sam_pass=NULL;
94 fstring str_domsid, str_qsid;
96 uint32 *rids=NULL, *new_rids=NULL;
97 gid_t winbind_gid_low, winbind_gid_high;
99 BOOL winbind_groups_exist;
102 * this code is far from perfect.
103 * first it enumerates the full /etc/group and that can be slow.
104 * second, it works only with users' SIDs
105 * whereas the day we support nested groups, it will have to
106 * support both users's SIDs and domain groups' SIDs
108 * having our own ldap backend would be so much faster !
109 * we're far from that, but hope one day ;-) JFM.
115 winbind_groups_exist = lp_idmap_gid(&winbind_gid_low, &winbind_gid_high);
118 DEBUG(10,("get_alias_user_groups: looking if SID %s is a member of groups in the SID domain %s\n",
119 sid_to_string(str_qsid, q_sid), sid_to_string(str_domsid, sid)));
121 pdb_init_sam(&sam_pass);
123 ret = pdb_getsampwsid(sam_pass, q_sid);
126 pdb_free_sam(&sam_pass);
127 return NT_STATUS_NO_SUCH_USER;
130 fstrcpy(user_name, pdb_get_username(sam_pass));
131 grid=pdb_get_group_rid(sam_pass);
132 if (!NT_STATUS_IS_OK(sid_to_gid(pdb_get_group_sid(sam_pass), &gid))) {
133 /* this should never happen */
134 DEBUG(2,("get_alias_user_groups: sid_to_gid failed!\n"));
135 pdb_free_sam(&sam_pass);
136 return NT_STATUS_UNSUCCESSFUL;
140 /* on some systems this must run as root */
141 num_groups = getgroups_user(user_name, &groups);
143 if (num_groups == -1) {
144 /* this should never happen */
145 DEBUG(2,("get_alias_user_groups: getgroups_user failed\n"));
146 pdb_free_sam(&sam_pass);
147 return NT_STATUS_UNSUCCESSFUL;
150 for (i=0;i<num_groups;i++) {
152 if (!get_group_from_gid(groups[i], &map)) {
153 DEBUG(10,("get_alias_user_groups: gid %d. not found\n", (int)groups[i]));
157 /* if it's not an alias, continue */
158 if (map.sid_name_use != SID_NAME_ALIAS) {
159 DEBUG(10,("get_alias_user_groups: not returing %s, not an ALIAS group.\n", map.nt_name));
163 sid_copy(&tmp_sid, &map.sid);
164 sid_split_rid(&tmp_sid, &rid);
166 /* if the sid is not in the correct domain, continue */
167 if (!sid_equal(&tmp_sid, sid)) {
168 DEBUG(10,("get_alias_user_groups: not returing %s, not in the domain SID.\n", map.nt_name));
172 /* Don't return winbind groups as they are not local! */
173 if (winbind_groups_exist && (groups[i] >= winbind_gid_low) && (groups[i] <= winbind_gid_high)) {
174 DEBUG(10,("get_alias_user_groups: not returing %s, not local.\n", map.nt_name));
178 /* Don't return user private groups... */
179 if (Get_Pwnam(map.nt_name) != 0) {
180 DEBUG(10,("get_alias_user_groups: not returing %s, clashes with user.\n", map.nt_name));
184 new_rids=(uint32 *)Realloc(rids, sizeof(uint32)*(cur_rid+1));
185 if (new_rids==NULL) {
186 DEBUG(10,("get_alias_user_groups: could not realloc memory\n"));
187 pdb_free_sam(&sam_pass);
189 return NT_STATUS_NO_MEMORY;
193 sid_peek_rid(&map.sid, &(rids[cur_rid]));
201 /* now check for the user's gid (the primary group rid) */
202 for (i=0; i<cur_rid && grid!=rids[i]; i++)
205 /* the user's gid is already there */
207 DEBUG(10,("get_alias_user_groups: user is already in the list. good.\n"));
211 DEBUG(10,("get_alias_user_groups: looking for gid %d of user %s\n", (int)gid, user_name));
213 if(!get_group_from_gid(gid, &map)) {
214 DEBUG(0,("get_alias_user_groups: gid of user %s doesn't exist. Check your "
215 "/etc/passwd and /etc/group files\n", user_name));
219 /* the primary group isn't an alias */
220 if (map.sid_name_use!=SID_NAME_ALIAS) {
221 DEBUG(10,("get_alias_user_groups: not returing %s, not an ALIAS group.\n", map.nt_name));
225 sid_copy(&tmp_sid, &map.sid);
226 sid_split_rid(&tmp_sid, &rid);
228 /* if the sid is not in the correct domain, continue */
229 if (!sid_equal(&tmp_sid, sid)) {
230 DEBUG(10,("get_alias_user_groups: not returing %s, not in the domain SID.\n", map.nt_name));
234 /* Don't return winbind groups as they are not local! */
235 if (winbind_groups_exist && (gid >= winbind_gid_low) && (gid <= winbind_gid_high)) {
236 DEBUG(10,("get_alias_user_groups: not returing %s, not local.\n", map.nt_name ));
240 /* Don't return user private groups... */
241 if (Get_Pwnam(map.nt_name) != 0) {
242 DEBUG(10,("get_alias_user_groups: not returing %s, clashes with user.\n", map.nt_name ));
246 new_rids=(uint32 *)Realloc(rids, sizeof(uint32)*(cur_rid+1));
247 if (new_rids==NULL) {
248 DEBUG(10,("get_alias_user_groups: could not realloc memory\n"));
249 pdb_free_sam(&sam_pass);
250 return NT_STATUS_NO_MEMORY;
254 sid_peek_rid(&map.sid, &(rids[cur_rid]));
260 pdb_free_sam(&sam_pass);
266 /*******************************************************************
267 gets a domain user's groups
268 ********************************************************************/
269 BOOL get_domain_user_groups(TALLOC_CTX *ctx, int *numgroups, DOM_GID **pgids, SAM_ACCOUNT *sam_pass)
272 int i, num, num_entries, cur_gid=0;
282 fstrcpy(user_name, pdb_get_username(sam_pass));
283 grid=pdb_get_group_rid(sam_pass);
285 DEBUG(10,("get_domain_user_groups: searching domain groups [%s] is a member of\n", user_name));
287 /* we must wrap this is become/unbecome root for ldap backends */
290 /* first get the list of the domain groups */
291 ret = pdb_enum_group_mapping(SID_NAME_DOM_GRP, &map, &num_entries, ENUM_ONLY_MAPPED);
295 /* end wrapper for group enumeration */
301 DEBUG(10,("get_domain_user_groups: there are %d mapped groups\n", num_entries));
305 * alloc memory. In the worse case, we alloc memory for nothing.
306 * but I prefer to alloc for nothing
307 * than reallocing everytime.
309 gids = (DOM_GID *)talloc(ctx, sizeof(DOM_GID) * num_entries);
311 /* for each group, check if the user is a member of. Only include groups
314 for(i=0; i<num_entries; i++) {
316 if ( !sid_check_is_in_our_domain(&map[i].sid) ) {
317 DEBUG(10,("get_domain_user_groups: skipping check of %s since it is not in our domain\n",
322 if ((grp=getgrgid(map[i].gid)) == NULL) {
324 DEBUG(5,("get_domain_user_groups: gid %d doesn't exist anymore !\n", (int)map[i].gid));
328 for(num=0; grp->gr_mem[num]!=NULL; num++) {
329 if(strcmp(grp->gr_mem[num], user_name)==0) {
330 /* we found the user, add the group to the list */
331 sid_peek_rid(&map[i].sid, &(gids[cur_gid].g_rid));
332 gids[cur_gid].attr=7;
333 DEBUG(10,("get_domain_user_groups: user found in group %s\n", map[i].nt_name));
340 /* we have checked the groups */
341 /* we must now check the gid of the user or the primary group rid, that's the same */
342 for (i=0; i<cur_gid && grid!=gids[i].g_rid; i++)
345 /* the user's gid is already there */
348 * the primary group of the user but be the first one in the list
351 gids[i].g_rid=gids[0].g_rid;
356 for(i=0; i<num_entries; i++) {
357 sid_peek_rid(&map[i].sid, &tmp_rid);
360 * the primary group of the user but be the first one in the list
363 gids[cur_gid].g_rid=gids[0].g_rid;
364 gids[0].g_rid=tmp_rid;
365 gids[cur_gid].attr=7;
366 DEBUG(10,("get_domain_user_groups: primary gid of user found in group %s\n", map[i].nt_name));
368 goto done; /* leave the loop early */
372 DEBUG(0,("get_domain_user_groups: primary gid of user [%s] is not a Domain group !\n", user_name));
373 DEBUGADD(0,("get_domain_user_groups: You should fix it, NT doesn't like that\n"));
384 /*******************************************************************
385 gets a domain user's groups from their already-calculated NT_USER_TOKEN
386 ********************************************************************/
387 NTSTATUS nt_token_to_group_list(TALLOC_CTX *mem_ctx, const DOM_SID *domain_sid,
388 const NT_USER_TOKEN *nt_token,
389 int *numgroups, DOM_GID **pgids)
394 gids = (DOM_GID *)talloc(mem_ctx, sizeof(*gids) * nt_token->num_sids);
397 return NT_STATUS_NO_MEMORY;
402 for (i=PRIMARY_GROUP_SID_INDEX; i < nt_token->num_sids; i++) {
403 if (sid_compare_domain(domain_sid, &nt_token->user_sids[i])==0) {
404 sid_peek_rid(&nt_token->user_sids[i], &(gids[*numgroups].g_rid));
405 gids[*numgroups].attr=7;
413 /*******************************************************************
414 Look up a local (domain) rid and return a name and type.
415 ********************************************************************/
416 NTSTATUS local_lookup_group_name(uint32 rid, char *group_name, uint32 *type)
419 (*type) = SID_NAME_DOM_GRP;
421 DEBUG(5,("lookup_group_name: rid: %d", rid));
423 while (domain_group_rids[i].rid != rid && domain_group_rids[i].rid != 0)
428 if (domain_group_rids[i].rid != 0)
430 fstrcpy(group_name, domain_group_rids[i].name);
431 DEBUG(5,(" = %s\n", group_name));
435 DEBUG(5,(" none mapped\n"));
436 return NT_STATUS_NONE_MAPPED;
439 /*******************************************************************
440 Look up a local alias rid and return a name and type.
441 ********************************************************************/
442 NTSTATUS local_lookup_alias_name(uint32 rid, char *alias_name, uint32 *type)
445 (*type) = SID_NAME_WKN_GRP;
447 DEBUG(5,("lookup_alias_name: rid: %d", rid));
449 while (builtin_alias_rids[i].rid != rid && builtin_alias_rids[i].rid != 0)
454 if (builtin_alias_rids[i].rid != 0)
456 fstrcpy(alias_name, builtin_alias_rids[i].name);
457 DEBUG(5,(" = %s\n", alias_name));
461 DEBUG(5,(" none mapped\n"));
462 return NT_STATUS_NONE_MAPPED;
466 #if 0 /*Nobody uses this function just now*/
467 /*******************************************************************
468 Look up a local user rid and return a name and type.
469 ********************************************************************/
470 NTSTATUS local_lookup_user_name(uint32 rid, char *user_name, uint32 *type)
472 SAM_ACCOUNT *sampwd=NULL;
476 (*type) = SID_NAME_USER;
478 DEBUG(5,("lookup_user_name: rid: %d", rid));
480 /* look up the well-known domain user rids first */
481 while (domain_user_rids[i].rid != rid && domain_user_rids[i].rid != 0)
486 if (domain_user_rids[i].rid != 0) {
487 fstrcpy(user_name, domain_user_rids[i].name);
488 DEBUG(5,(" = %s\n", user_name));
492 pdb_init_sam(&sampwd);
494 /* ok, it's a user. find the user account */
496 ret = pdb_getsampwrid(sampwd, rid);
500 fstrcpy(user_name, pdb_get_username(sampwd) );
501 DEBUG(5,(" = %s\n", user_name));
502 pdb_free_sam(&sampwd);
506 DEBUG(5,(" none mapped\n"));
507 pdb_free_sam(&sampwd);
508 return NT_STATUS_NONE_MAPPED;
513 /*******************************************************************
514 Look up a local (domain) group name and return a rid
515 ********************************************************************/
516 NTSTATUS local_lookup_group_rid(char *group_name, uint32 *rid)
518 const char *grp_name;
519 int i = -1; /* start do loop at -1 */
521 do /* find, if it exists, a group rid for the group name*/
524 (*rid) = domain_group_rids[i].rid;
525 grp_name = domain_group_rids[i].name;
527 } while (grp_name != NULL && !strequal(grp_name, group_name));
529 return (grp_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
532 /*******************************************************************
533 Look up a local (BUILTIN) alias name and return a rid
534 ********************************************************************/
535 NTSTATUS local_lookup_alias_rid(const char *alias_name, uint32 *rid)
537 const char *als_name;
538 int i = -1; /* start do loop at -1 */
540 do /* find, if it exists, a alias rid for the alias name*/
543 (*rid) = builtin_alias_rids[i].rid;
544 als_name = builtin_alias_rids[i].name;
546 } while (als_name != NULL && !strequal(als_name, alias_name));
548 return (als_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
551 /*******************************************************************
552 Look up a local user name and return a rid
553 ********************************************************************/
554 NTSTATUS local_lookup_user_rid(char *user_name, uint32 *rid)
556 SAM_ACCOUNT *sampass=NULL;
561 pdb_init_sam(&sampass);
563 /* find the user account */
565 ret = pdb_getsampwnam(sampass, user_name);
569 (*rid) = pdb_get_user_rid(sampass);
570 pdb_free_sam(&sampass);
574 pdb_free_sam(&sampass);
575 return NT_STATUS_NONE_MAPPED;