e6df9933bff94605ba193c38af206e623585c4b5
[samba.git] / source3 / rpc_server / srv_lookup.c
1
2 /* 
3  *  Unix SMB/Netbios implementation.
4  *  Version 1.9.
5  *  RPC Pipe client / server routines
6  *  Copyright (C) Andrew Tridgell              1992-1998
7  *  Copyright (C) Luke Kenneth Casson Leighton 1996-1998,
8  *  Copyright (C) Paul Ashton                  1997-1998.
9  *  
10  *  This program is free software; you can redistribute it and/or modify
11  *  it under the terms of the GNU General Public License as published by
12  *  the Free Software Foundation; either version 2 of the License, or
13  *  (at your option) any later version.
14  *  
15  *  This program is distributed in the hope that it will be useful,
16  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
17  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
18  *  GNU General Public License for more details.
19  *  
20  *  You should have received a copy of the GNU General Public License
21  *  along with this program; if not, write to the Free Software
22  *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23  */
24
25 /*
26  *
27  *
28
29  this module provides nt user / nt rid lookup functions.
30  users, local groups, domain groups.
31
32  no unix / samba functions should be called in this module:
33  it should purely provide a gateway to the password database API,
34  the local group database API or the domain group database API,
35  but first checking built-in rids.
36
37  did i say rids?  oops, what about "S-1-1" the "Everyone" group
38  and other such well-known sids...
39
40  speed is not of the essence: no particular optimisation is in place.
41
42  *
43  *
44  */
45
46 #include "includes.h"
47 #include "nterr.h"
48
49 extern int DEBUGLEVEL;
50
51 extern fstring global_sam_name;
52 extern DOM_SID global_sam_sid;
53 extern DOM_SID global_sid_S_1_5_20;
54
55 /*
56  * A list of the rids of well known BUILTIN and Domain users
57  * and groups.
58  */
59
60 rid_name builtin_alias_rids[] =
61 {  
62     { BUILTIN_ALIAS_RID_ADMINS       , "Administrators" },
63     { BUILTIN_ALIAS_RID_USERS        , "Users" },
64     { BUILTIN_ALIAS_RID_GUESTS       , "Guests" },
65     { BUILTIN_ALIAS_RID_POWER_USERS  , "Power Users" },
66    
67     { BUILTIN_ALIAS_RID_ACCOUNT_OPS  , "Account Operators" },
68     { BUILTIN_ALIAS_RID_SYSTEM_OPS   , "System Operators" },
69     { BUILTIN_ALIAS_RID_PRINT_OPS    , "Print Operators" },
70     { BUILTIN_ALIAS_RID_BACKUP_OPS   , "Backup Operators" },
71     { BUILTIN_ALIAS_RID_REPLICATOR   , "Replicator" },
72     { 0                             , NULL }
73 };
74
75 /* array lookup of well-known Domain RID users. */
76 rid_name domain_user_rids[] =
77 {  
78     { DOMAIN_USER_RID_ADMIN         , "Administrator" },
79     { DOMAIN_USER_RID_GUEST         , "Guest" },
80     { 0                             , NULL }
81 };
82
83 /* array lookup of well-known Domain RID groups. */
84 rid_name domain_group_rids[] =
85 {  
86     { DOMAIN_GROUP_RID_ADMINS       , "Domain Admins" },
87     { DOMAIN_GROUP_RID_USERS        , "Domain Users" },
88     { DOMAIN_GROUP_RID_GUESTS       , "Domain Guests" },
89     { 0                             , NULL }
90 };
91
92
93 int make_dom_gids(DOMAIN_GRP *mem, int num_members, DOM_GID **ppgids)
94 {
95         int count;
96         int i;
97         DOM_GID *gids = NULL;
98
99         *ppgids = NULL;
100
101         DEBUG(4,("make_dom_gids: %d\n", num_members));
102
103         if (mem == NULL || num_members == 0)
104         {
105                 return 0;
106         }
107
108         for (i = 0, count = 0; i < num_members && count < LSA_MAX_GROUPS; i++) 
109         {
110                 uint32 status;
111
112                 uint32 rid;
113                 uint8  type;
114
115                 uint8  attr  = mem[count].attr;
116                 char   *name = mem[count].name;
117
118                 become_root(True);
119                 status = lookup_grp_rid(name, &rid, &type);
120                 unbecome_root(True);
121
122                 if (status == 0x0)
123                 {
124                         gids = (DOM_GID *)Realloc( gids, sizeof(DOM_GID) * (count+1) );
125
126                         if (gids == NULL)
127                         {
128                                 DEBUG(0,("make_dom_gids: Realloc fail !\n"));
129                                 return 0;
130                         }
131
132                         gids[count].g_rid = rid;
133                         gids[count].attr  = attr;
134
135                         DEBUG(5,("group name: %s rid: %d attr: %d\n",
136                                   name, rid, attr));
137                         count++;
138                 }
139                 else
140                 {
141                         DEBUG(1,("make_dom_gids: unknown group name %s\n", name));
142                 }
143         }
144
145         *ppgids = gids;
146         return count;
147 }
148
149 /*******************************************************************
150  gets a domain user's groups
151  ********************************************************************/
152 int get_domain_user_groups(DOMAIN_GRP_MEMBER **grp_members, uint32 group_rid)
153 {
154         DOMAIN_GRP *grp;
155         int num_mem;
156
157         if (grp_members == NULL) return 0;
158
159         grp = getgrouprid(group_rid, grp_members, &num_mem);
160
161         if (grp == NULL)
162         {
163                 return 0;
164         }
165
166         return num_mem;
167 }
168
169
170 /*******************************************************************
171  lookup_builtin_names
172  ********************************************************************/
173 uint32 lookup_builtin_names(uint32 rid, char *name, uint8 *type)
174 {
175         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
176
177         status = (status != 0x0) ? lookup_wk_user_name (rid, name, type) : status;
178         status = (status != 0x0) ? lookup_wk_group_name(rid, name, type) : status;
179         status = (status != 0x0) ? lookup_wk_alias_name(rid, name, type) : status;
180
181         return status;
182 }
183
184
185 /*******************************************************************
186  lookup_added_name - names that have been added to the SAM database by admins.
187  ********************************************************************/
188 uint32 lookup_added_name(uint32 rid, char *name, uint8 *type)
189 {
190         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
191
192         status = (status != 0x0) ? lookup_user_name (rid, name, type) : status;
193         status = (status != 0x0) ? lookup_group_name(rid, name, type) : status;
194         status = (status != 0x0) ? lookup_alias_name(rid, name, type) : status;
195
196         return status;
197 }
198
199
200 /*******************************************************************
201  lookup_name
202  ********************************************************************/
203 uint32 lookup_name(uint32 rid, char *name, uint8 *type)
204 {
205         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
206
207         status = (status != 0x0) ? lookup_builtin_names(rid, name, type) : status;
208         status = (status != 0x0) ? lookup_added_name   (rid, name, type) : status;
209
210         return status;
211 }
212
213
214 /*******************************************************************
215  lookup_wk_group_name
216  ********************************************************************/
217 uint32 lookup_wk_group_name(uint32 rid, char *group_name, uint8 *type)
218 {
219         int i = 0; 
220         (*type) = SID_NAME_WKN_GRP;
221
222         DEBUG(5,("lookup_wk_group_name: rid: %d", rid));
223
224         while (domain_group_rids[i].rid != rid && domain_group_rids[i].rid != 0)
225         {
226                 i++;
227         }
228
229         if (domain_group_rids[i].rid != 0)
230         {
231                 fstrcpy(group_name, domain_group_rids[i].name);
232                 DEBUG(5,(" = %s\n", group_name));
233                 return 0x0;
234         }
235
236         DEBUG(5,(" none mapped\n"));
237         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
238 }
239
240 /*******************************************************************
241  lookup_group_name
242  ********************************************************************/
243 uint32 lookup_group_name(uint32 rid, char *group_name, uint8 *type)
244 {
245         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
246         DOM_SID sid;
247
248         DEBUG(5,("lookup_group_name: rid: 0x%x", rid));
249
250         sid_copy      (&sid, &global_sam_sid);
251         sid_append_rid(&sid, rid);
252
253         (*type) = SID_NAME_DOM_GRP;
254
255         if (map_group_sid_to_name(&sid, group_name, NULL))
256         {
257                 status = 0x0;
258         }
259
260         if (status == 0x0)
261         {
262                 DEBUG(5,(" = %s\n", group_name));
263         }
264         else
265         {
266                 DEBUG(5,(" none mapped\n"));
267         }
268
269         return status;
270 }
271
272 /*******************************************************************
273  lookup_wk_alias_name
274  ********************************************************************/
275 uint32 lookup_wk_alias_name(uint32 rid, char *alias_name, uint8 *type)
276 {
277         int i = 0; 
278         (*type) = SID_NAME_ALIAS;
279
280         DEBUG(5,("lookup_wk_alias_name: rid: %d", rid));
281
282         while (builtin_alias_rids[i].rid != rid && builtin_alias_rids[i].rid != 0)
283         {
284                 i++;
285         }
286
287         if (builtin_alias_rids[i].rid != 0)
288         {
289                 fstrcpy(alias_name, builtin_alias_rids[i].name);
290                 DEBUG(5,(" = %s\n", alias_name));
291                 return 0x0;
292         }
293
294         DEBUG(5,(" none mapped\n"));
295         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
296 }
297
298 /*******************************************************************
299  lookup_alias_name
300  ********************************************************************/
301 uint32 lookup_alias_name(uint32 rid, char *alias_name, uint8 *type)
302 {
303         (*type) = SID_NAME_ALIAS;
304
305         DEBUG(2,("lookup_alias_name: rid: %d\n", rid));
306         DEBUG(2,(" NOT IMPLEMENTED\n"));
307
308         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
309 }
310
311 /*******************************************************************
312  lookup well-known user name
313  ********************************************************************/
314 uint32 lookup_wk_user_name(uint32 rid, char *user_name, uint8 *type)
315 {
316         int i = 0;
317         (*type) = SID_NAME_USER;
318
319         DEBUG(5,("lookup_wk_user_name: rid: %d", rid));
320
321         /* look up the well-known domain user rids first */
322         while (domain_user_rids[i].rid != rid && domain_user_rids[i].rid != 0)
323         {
324                 i++;
325         }
326
327         if (domain_user_rids[i].rid != 0)
328         {
329                 fstrcpy(user_name, domain_user_rids[i].name);
330                 DEBUG(5,(" = %s\n", user_name));
331                 return 0x0;
332         }
333
334         DEBUG(5,(" none mapped\n"));
335         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
336 }
337
338 /*******************************************************************
339  lookup user name
340  ********************************************************************/
341 uint32 lookup_user_name(uint32 rid, char *user_name, uint8 *type)
342 {
343         struct sam_disp_info *disp_info;
344         (*type) = SID_NAME_USER;
345
346         DEBUG(5,("lookup_user_name: rid: %d", rid));
347
348         /* find the user account */
349         become_root(True);
350         disp_info = getsamdisprid(rid);
351         unbecome_root(True);
352
353         if (disp_info != NULL)
354         {
355                 fstrcpy(user_name, disp_info->smb_name);
356                 DEBUG(5,(" = %s\n", user_name));
357                 return 0x0;
358         }
359
360         DEBUG(5,(" none mapped\n"));
361         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
362 }
363
364 /*******************************************************************
365  lookup_group_rid
366  ********************************************************************/
367 uint32 lookup_group_rid(char *group_name, uint32 *rid, uint8 *type)
368 {
369         DOM_SID sid;
370
371         (*rid) = 0;
372         (*type) = SID_NAME_DOM_GRP;
373
374         DEBUG(5,("lookup_group_rid: name: %s", group_name));
375
376         if (map_group_name_to_sid(group_name, &sid) &&
377             sid_split_rid(&sid, rid) &&
378             sid_equal(&sid, &global_sam_sid))
379         {
380                 DEBUG(5,(" = 0x%x\n", (*rid)));
381                 return 0x0;
382         }
383
384         DEBUG(5,(" none mapped\n"));
385         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
386 }
387
388 /*******************************************************************
389  lookup_wk_group_rid
390  ********************************************************************/
391 uint32 lookup_wk_group_rid(char *group_name, uint32 *rid, uint8 *type)
392 {
393         char *grp_name;
394         int i = -1; /* start do loop at -1 */
395         (*rid) = 0;
396         (*type) = SID_NAME_WKN_GRP;
397
398         do /* find, if it exists, a group rid for the group name */
399         {
400                 i++;
401                 (*rid) = domain_group_rids[i].rid;
402                 grp_name = domain_group_rids[i].name;
403
404         } while (grp_name != NULL && !strequal(grp_name, group_name));
405
406         return (grp_name != NULL) ? 0 : 0xC0000000 | NT_STATUS_NONE_MAPPED;
407 }
408
409 /*******************************************************************
410  lookup_alias_sid
411  ********************************************************************/
412 uint32 lookup_alias_sid(char *alias_name, DOM_SID *sid, uint8 *type)
413 {
414         (*type) = SID_NAME_ALIAS;
415
416         DEBUG(5,("lookup_alias_rid: name: %s", alias_name));
417
418         if (map_alias_name_to_sid(alias_name, sid))
419         {
420                 fstring sid_str;
421                 sid_to_string(sid_str, sid);
422                 DEBUG(5,(" = %s\n", sid_str));
423                 return 0x0;
424         }
425
426         DEBUG(5,(" none mapped\n"));
427         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
428 }
429
430 /*******************************************************************
431  lookup_alias_rid
432  ********************************************************************/
433 uint32 lookup_alias_rid(char *alias_name, uint32 *rid, uint8 *type)
434 {
435         DOM_SID sid;
436
437         (*rid) = 0;
438         (*type) = SID_NAME_ALIAS;
439
440         DEBUG(5,("lookup_alias_rid: name: %s", alias_name));
441
442         if (map_alias_name_to_sid(alias_name, &sid) &&
443             sid_split_rid(&sid, rid) &&
444             sid_equal(&sid, &global_sam_sid))
445         {
446                 DEBUG(5,(" = 0x%x\n", (*rid)));
447                 return 0x0;
448         }
449
450         DEBUG(5,(" none mapped\n"));
451         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
452 }
453
454 /*******************************************************************
455  lookup_wk_alias_sid
456  ********************************************************************/
457 uint32 lookup_wk_alias_sid(char *alias_name, DOM_SID *sid, uint8 *type)
458 {
459         char *als_name;
460         int i = 0;
461         uint32 rid;
462         (*type) = SID_NAME_ALIAS;
463
464         do /* find, if it exists, a alias rid for the alias name*/
465         {
466                 rid      = builtin_alias_rids[i].rid;
467                 als_name = builtin_alias_rids[i].name;
468
469                 i++;
470
471                 if (strequal(als_name, alias_name))
472                 {
473                         sid_copy(sid, &global_sid_S_1_5_20);
474                         sid_append_rid(sid, rid);
475
476                         return 0x0;
477                 }
478                         
479         } while (als_name != NULL);
480
481         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
482 }
483
484 /*******************************************************************
485  lookup_wk_alias_rid
486  ********************************************************************/
487 uint32 lookup_wk_alias_rid(char *alias_name, uint32 *rid, uint8 *type)
488 {
489         char *als_name;
490         int i = -1; /* start do loop at -1 */
491         (*rid) = 0;
492         (*type) = SID_NAME_ALIAS;
493
494         do /* find, if it exists, a alias rid for the alias name*/
495         {
496                 i++;
497                 (*rid) = builtin_alias_rids[i].rid;
498                 als_name = builtin_alias_rids[i].name;
499
500         } while (als_name != NULL && !strequal(als_name, alias_name));
501
502         return (als_name != NULL) ? 0 : 0xC0000000 | NT_STATUS_NONE_MAPPED;
503 }
504
505 /*******************************************************************
506  lookup_sid
507  ********************************************************************/
508 uint32 lookup_sid(char *name, DOM_SID *sid, uint8 *type)
509 {
510         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
511         fstring domain;
512         fstring user;
513         
514         split_domain_name(name, domain, user);
515
516         if (!strequal(domain, global_sam_name))
517         {
518                 DEBUG(0,("lookup_sid: remote domain %s not supported\n", domain));
519                 return status;
520         }
521
522         status = (status != 0x0) ? lookup_wk_alias_sid(user, sid, type) : status;
523         status = (status != 0x0) ? lookup_alias_sid   (user, sid, type) : status;
524 #if 0
525         status = (status != 0x0) ? lookup_domain_sid  (user, sid, type) : status;
526 #endif
527
528         return status;
529 }
530
531 /*******************************************************************
532  lookup_added_user_rid
533  ********************************************************************/
534 uint32 lookup_added_user_rids(char *user_name,
535                 uint32 *usr_rid, uint32 *grp_rid)
536 {
537         struct sam_passwd *sam_pass;
538         (*usr_rid) = 0;
539         (*grp_rid) = 0;
540
541         /* find the user account */
542         become_root(True);
543         sam_pass = getsam21pwnam(user_name);
544         unbecome_root(True);
545
546         if (sam_pass != NULL)
547         {
548                 (*usr_rid) = sam_pass->user_rid ;
549                 (*grp_rid) = sam_pass->group_rid;
550                 return 0x0;
551         }
552
553         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
554 }
555
556 /*******************************************************************
557  lookup_added_user_rid
558  ********************************************************************/
559 uint32 lookup_added_user_rid(char *user_name, uint32 *rid, uint8 *type)
560 {
561         struct sam_passwd *sam_pass;
562         (*rid) = 0;
563         (*type) = SID_NAME_USER;
564
565         /* find the user account */
566         become_root(True);
567         sam_pass = getsam21pwnam(user_name);
568         unbecome_root(True);
569
570         if (sam_pass != NULL)
571         {
572                 (*rid) = sam_pass->user_rid;
573                 return 0x0;
574         }
575
576         return 0xC0000000 | NT_STATUS_NONE_MAPPED;
577 }
578
579 /*******************************************************************
580  lookup_wk_user_rid
581  ********************************************************************/
582 uint32 lookup_wk_user_rid(char *user_name, uint32 *rid, uint8 *type)
583 {
584         char *usr_name;
585         int i = -1; /* start do loop at -1 */
586         (*rid) = 0;
587         (*type) = SID_NAME_USER;
588
589         do /* find, if it exists, a alias rid for the alias name*/
590         {
591                 i++;
592                 (*rid) = domain_user_rids[i].rid;
593                 usr_name = domain_user_rids[i].name;
594
595         } while (usr_name != NULL && !strequal(usr_name, user_name));
596
597         return (usr_name != NULL) ? 0 : 0xC0000000 | NT_STATUS_NONE_MAPPED;
598 }
599
600 /*******************************************************************
601  lookup_added_grp_rid
602  ********************************************************************/
603 uint32 lookup_added_grp_rid(char *name, uint32 *rid, uint8 *type)
604 {
605         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
606
607         status = (status != 0x0) ? lookup_group_rid(name, rid, type) : status;
608         status = (status != 0x0) ? lookup_alias_rid(name, rid, type) : status;
609
610         return status;
611 }
612
613 /*******************************************************************
614  lookup_builtin_grp_rid
615  ********************************************************************/
616 uint32 lookup_builtin_grp_rid(char *name, uint32 *rid, uint8 *type)
617 {
618         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
619
620         status = (status != 0x0) ? lookup_wk_group_rid(name, rid, type) : status;
621         status = (status != 0x0) ? lookup_wk_alias_rid(name, rid, type) : status;
622
623         return status;
624 }
625
626 /*******************************************************************
627  lookup_grp_rid
628  ********************************************************************/
629 uint32 lookup_grp_rid(char *name, uint32 *rid, uint8 *type)
630 {
631         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
632
633         status = (status != 0x0) ? lookup_builtin_grp_rid(name, rid, type) : status;
634         status = (status != 0x0) ? lookup_added_grp_rid  (name, rid, type) : status;
635
636         return status;
637 }
638
639 /*******************************************************************
640  lookup_user_rid
641  ********************************************************************/
642 uint32 lookup_user_rid(char *name, uint32 *rid, uint8 *type)
643 {
644         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
645
646         status = (status != 0x0) ? lookup_wk_user_rid   (name, rid, type) : status;
647         status = (status != 0x0) ? lookup_added_user_rid(name, rid, type) : status;
648
649         return status;
650 }
651
652 /*******************************************************************
653  lookup_rid
654  ********************************************************************/
655 uint32 lookup_rid(char *name, uint32 *rid, uint8 *type)
656 {
657         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
658
659         status = (status != 0x0) ? lookup_user_rid(name, rid, type) : status;
660         status = (status != 0x0) ? lookup_grp_rid (name, rid, type) : status;
661
662         return status;
663 }
664
665 /*******************************************************************
666  lookup_user_rids
667  ********************************************************************/
668 uint32 lookup_user_rids(char *name, uint32 *usr_rid, uint32 *grp_rid)
669 {
670         uint32 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
671         uint8 type;
672
673         /*
674          * try an ordinary user lookup
675          */
676
677         status = lookup_added_user_rids(name, usr_rid, grp_rid);
678         if (status == 0)
679         {
680                 return status;
681         }
682
683         /*
684          * hm.  must be a well-known user, in a well-known group.
685          */
686
687         status = lookup_wk_user_rid(name, usr_rid, &type);
688         if (status != 0 || type != SID_NAME_USER)
689         {
690                 return status; /* ok, maybe not! */
691         }
692         if (type != SID_NAME_USER)
693         {
694                 return 0xC0000000 | NT_STATUS_NONE_MAPPED; /* users only... */
695         }
696
697         /*
698          * ok, got the user rid: now try the group rid
699          */
700
701         status = lookup_builtin_grp_rid(name, grp_rid, &type);
702         if (type == SID_NAME_DOM_GRP ||
703             type == SID_NAME_ALIAS ||
704             type == SID_NAME_WKN_GRP)
705         {
706                 status = 0xC0000000 | NT_STATUS_NONE_MAPPED;
707         }
708
709         return status;
710 }