source/rpc_server/srv_util.c

   1 /*
   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.
   7  *
   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.
  12  *
  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.
  17  *
  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.
  21  */
  22
  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.
  26  *
  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.
  30  *
  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...
  34  *
  35  *  ... if you read the docs.  or stare at packets for weeks on end.
  36  *
  37  */
  38
  39 #include "includes.h"
  40
  41 #undef DBGC_CLASS
  42 #define DBGC_CLASS DBGC_RPC_SRV
  43
  44 /*
  45  * A list of the rids of well known BUILTIN and Domain users
  46  * and groups.
  47  */
  48
  49 rid_name builtin_alias_rids[] =
  50 {
  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" },
  55
  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" },
  61     { 0                             , NULL }
  62 };
  63
  64 /* array lookup of well-known Domain RID users. */
  65 rid_name domain_user_rids[] =
  66 {
  67     { DOMAIN_USER_RID_ADMIN         , "Administrator" },
  68     { DOMAIN_USER_RID_GUEST         , "Guest" },
  69     { 0                             , NULL }
  70 };
  71
  72 /* array lookup of well-known Domain RID groups. */
  73 rid_name domain_group_rids[] =
  74 {
  75     { DOMAIN_GROUP_RID_ADMINS       , "Domain Admins" },
  76     { DOMAIN_GROUP_RID_USERS        , "Domain Users" },
  77     { DOMAIN_GROUP_RID_GUESTS       , "Domain Guests" },
  78     { 0                             , NULL }
  79 };
  80
  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)
  85 {
  86         SAM_ACCOUNT *sam_pass=NULL;
  87         int i, cur_rid=0;
  88         gid_t gid;
  89         gid_t *groups = NULL;
  90         int num_groups;
  91         GROUP_MAP map;
  92         DOM_SID tmp_sid;
  93         fstring user_name;
  94         fstring str_domsid, str_qsid;
  95         uint32 rid,grid;
  96         uint32 *rids=NULL, *new_rids=NULL;
  97         gid_t winbind_gid_low, winbind_gid_high;
  98         BOOL ret;
  99         BOOL winbind_groups_exist;
 100
 101         /*
 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
 107          *
 108          * having our own ldap backend would be so much faster !
 109          * we're far from that, but hope one day ;-) JFM.
 110          */
 111
 112         *prids=NULL;
 113         *numgroups=0;
 114
 115         winbind_groups_exist = lp_idmap_gid(&winbind_gid_low, &winbind_gid_high);
 116
 117
 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)));
 120
 121         pdb_init_sam(&sam_pass);
 122         become_root();
 123         ret = pdb_getsampwsid(sam_pass, q_sid);
 124         unbecome_root();
 125         if (ret == False) {
 126                 pdb_free_sam(&sam_pass);
 127                 return NT_STATUS_NO_SUCH_USER;
 128         }
 129
 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;
 137         }
 138
 139         become_root();
 140         /* on some systems this must run as root */
 141         num_groups = getgroups_user(user_name, &groups);
 142         unbecome_root();
 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;
 148         }
 149
 150         become_root();
 151
 152         for (i=0;i<num_groups;i++) {
 153
 154                 if (!get_group_from_gid(groups[i], &map)) {
 155                         DEBUG(10,("get_alias_user_groups: gid %d. not found\n", (int)groups[i]));
 156                         continue;
 157                 }
 158
 159                 /* if it's not an alias, continue */
 160                 if (map.sid_name_use != SID_NAME_ALIAS) {
 161                         DEBUG(10,("get_alias_user_groups: not returing %s, not an ALIAS group.\n", map.nt_name));
 162                         continue;
 163                 }
 164
 165                 sid_copy(&tmp_sid, &map.sid);
 166                 sid_split_rid(&tmp_sid, &rid);
 167
 168                 /* if the sid is not in the correct domain, continue */
 169                 if (!sid_equal(&tmp_sid, sid)) {
 170                         DEBUG(10,("get_alias_user_groups: not returing %s, not in the domain SID.\n", map.nt_name));
 171                         continue;
 172                 }
 173
 174                 /* Don't return winbind groups as they are not local! */
 175                 if (winbind_groups_exist && (groups[i] >= winbind_gid_low) && (groups[i] <= winbind_gid_high)) {
 176                         DEBUG(10,("get_alias_user_groups: not returing %s, not local.\n", map.nt_name));
 177                         continue;
 178                 }
 179
 180                 /* Don't return user private groups... */
 181                 if (Get_Pwnam(map.nt_name) != 0) {
 182                         DEBUG(10,("get_alias_user_groups: not returing %s, clashes with user.\n", map.nt_name));
 183                         continue;
 184                 }
 185
 186                 new_rids=(uint32 *)Realloc(rids, sizeof(uint32)*(cur_rid+1));
 187                 if (new_rids==NULL) {
 188                         DEBUG(10,("get_alias_user_groups: could not realloc memory\n"));
 189                         pdb_free_sam(&sam_pass);
 190                         free(groups);
 191                         return NT_STATUS_NO_MEMORY;
 192                 }
 193                 rids=new_rids;
 194
 195                 sid_peek_rid(&map.sid, &(rids[cur_rid]));
 196                 cur_rid++;
 197                 break;
 198         }
 199
 200         unbecome_root();
 201
 202         if(num_groups) free(groups);
 203
 204         /* now check for the user's gid (the primary group rid) */
 205         for (i=0; i<cur_rid && grid!=rids[i]; i++)
 206                 ;
 207
 208         /* the user's gid is already there */
 209         if (i!=cur_rid) {
 210                 DEBUG(10,("get_alias_user_groups: user is already in the list. good.\n"));
 211                 goto done;
 212         }
 213
 214         DEBUG(10,("get_alias_user_groups: looking for gid %d of user %s\n", (int)gid, user_name));
 215
 216         become_root();
 217
 218         if(!get_group_from_gid(gid, &map)) {
 219                 DEBUG(0,("get_alias_user_groups: gid of user %s doesn't exist. Check your /etc/passwd and /etc/group files\n", user_name));
 220                 goto done;
 221         }
 222
 223         unbecome_root();
 224
 225         /* the primary group isn't an alias */
 226         if (map.sid_name_use!=SID_NAME_ALIAS) {
 227                 DEBUG(10,("get_alias_user_groups: not returing %s, not an ALIAS group.\n", map.nt_name));
 228                 goto done;
 229         }
 230
 231         sid_copy(&tmp_sid, &map.sid);
 232         sid_split_rid(&tmp_sid, &rid);
 233
 234         /* if the sid is not in the correct domain, continue */
 235         if (!sid_equal(&tmp_sid, sid)) {
 236                 DEBUG(10,("get_alias_user_groups: not returing %s, not in the domain SID.\n", map.nt_name));
 237                 goto done;
 238         }
 239
 240         /* Don't return winbind groups as they are not local! */
 241         if (winbind_groups_exist && (gid >= winbind_gid_low) && (gid <= winbind_gid_high)) {
 242                 DEBUG(10,("get_alias_user_groups: not returing %s, not local.\n", map.nt_name ));
 243                 goto done;
 244         }
 245
 246         /* Don't return user private groups... */
 247         if (Get_Pwnam(map.nt_name) != 0) {
 248                 DEBUG(10,("get_alias_user_groups: not returing %s, clashes with user.\n", map.nt_name ));
 249                 goto done;
 250         }
 251
 252         new_rids=(uint32 *)Realloc(rids, sizeof(uint32)*(cur_rid+1));
 253         if (new_rids==NULL) {
 254                 DEBUG(10,("get_alias_user_groups: could not realloc memory\n"));
 255                 pdb_free_sam(&sam_pass);
 256                 return NT_STATUS_NO_MEMORY;
 257         }
 258         rids=new_rids;
 259
 260         sid_peek_rid(&map.sid, &(rids[cur_rid]));
 261         cur_rid++;
 262
 263 done:
 264         *prids=rids;
 265         *numgroups=cur_rid;
 266         pdb_free_sam(&sam_pass);
 267
 268         return NT_STATUS_OK;
 269 }
 270
 271
 272 /*******************************************************************
 273  gets a domain user's groups
 274  ********************************************************************/
 275 BOOL get_domain_user_groups(TALLOC_CTX *ctx, int *numgroups, DOM_GID **pgids, SAM_ACCOUNT *sam_pass)
 276 {
 277         GROUP_MAP *map=NULL;
 278         int i, num, num_entries, cur_gid=0;
 279         struct group *grp;
 280         DOM_GID *gids;
 281         fstring user_name;
 282         uint32 grid;
 283         uint32 tmp_rid;
 284
 285         *numgroups= 0;
 286
 287         fstrcpy(user_name, pdb_get_username(sam_pass));
 288         grid=pdb_get_group_rid(sam_pass);
 289
 290         DEBUG(10,("get_domain_user_groups: searching domain groups [%s] is a member of\n", user_name));
 291
 292         /* we must wrap this is become/unbecome root for ldap backends */
 293         become_root();
 294
 295         /* first get the list of the domain groups */
 296         if (!pdb_enum_group_mapping(SID_NAME_DOM_GRP, &map, &num_entries, ENUM_ONLY_MAPPED))
 297                 return False;
 298         DEBUG(10,("get_domain_user_groups: there are %d mapped groups\n", num_entries));
 299
 300         unbecome_root();
 301         /* end wrapper for group enumeration */
 302
 303         /*
 304          * alloc memory. In the worse case, we alloc memory for nothing.
 305          * but I prefer to alloc for nothing
 306          * than reallocing everytime.
 307          */
 308         gids = (DOM_GID *)talloc(ctx, sizeof(DOM_GID) *  num_entries);
 309
 310         /* for each group, check if the user is a member of.  Only include groups
 311            from this domain */
 312
 313         for(i=0; i<num_entries; i++) {
 314
 315                 if ( !sid_check_is_in_our_domain(&map[i].sid) ) {
 316                         DEBUG(10,("get_domain_user_groups: skipping check of %s since it is not in our domain\n",
 317                                 map[i].nt_name));
 318                         continue;
 319                 }
 320
 321                 if ((grp=getgrgid(map[i].gid)) == NULL) {
 322                         /* very weird !!! */
 323                         DEBUG(5,("get_domain_user_groups: gid %d doesn't exist anymore !\n", (int)map[i].gid));
 324                         continue;
 325                 }
 326
 327                 for(num=0; grp->gr_mem[num]!=NULL; num++) {
 328                         if(strcmp(grp->gr_mem[num], user_name)==0) {
 329                                 /* we found the user, add the group to the list */
 330                                 sid_peek_rid(&map[i].sid, &(gids[cur_gid].g_rid));
 331                                 gids[cur_gid].attr=7;
 332                                 DEBUG(10,("get_domain_user_groups: user found in group %s\n", map[i].nt_name));
 333                                 cur_gid++;
 334                                 break;
 335                         }
 336                 }
 337         }
 338
 339         /* we have checked the groups */
 340         /* we must now check the gid of the user or the primary group rid, that's the same */
 341         for (i=0; i<cur_gid && grid!=gids[i].g_rid; i++)
 342                 ;
 343
 344         /* the user's gid is already there */
 345         if (i!=cur_gid) {
 346                 /*
 347                  * the primary group of the user but be the first one in the list
 348                  * don't ask ! JFM.
 349                  */
 350                 gids[i].g_rid=gids[0].g_rid;
 351                 gids[0].g_rid=grid;
 352                 goto done;
 353         }
 354
 355         for(i=0; i<num_entries; i++) {
 356                 sid_peek_rid(&map[i].sid, &tmp_rid);
 357                 if (tmp_rid==grid) {
 358                         /*
 359                          * the primary group of the user but be the first one in the list
 360                          * don't ask ! JFM.
 361                          */
 362                         gids[cur_gid].g_rid=gids[0].g_rid;
 363                         gids[0].g_rid=tmp_rid;
 364                         gids[cur_gid].attr=7;
 365                         DEBUG(10,("get_domain_user_groups: primary gid of user found in group %s\n", map[i].nt_name));
 366                         cur_gid++;
 367                         goto done; /* leave the loop early */
 368                 }
 369         }
 370
 371         DEBUG(0,("get_domain_user_groups: primary gid of user [%s] is not a Domain group !\n", user_name));
 372         DEBUGADD(0,("get_domain_user_groups: You should fix it, NT doesn't like that\n"));
 373
 374
 375  done:
 376         *pgids=gids;
 377         *numgroups=cur_gid;
 378         safe_free(map);
 379
 380         return True;
 381 }
 382
 383 /*******************************************************************
 384  gets a domain user's groups from their already-calculated NT_USER_TOKEN
 385  ********************************************************************/
 386 NTSTATUS nt_token_to_group_list(TALLOC_CTX *mem_ctx, const DOM_SID *domain_sid,
 387                                 const NT_USER_TOKEN *nt_token,
 388                                 int *numgroups, DOM_GID **pgids)
 389 {
 390         DOM_GID *gids;
 391         int i;
 392
 393         gids = (DOM_GID *)talloc(mem_ctx, sizeof(*gids) * nt_token->num_sids);
 394
 395         if (!gids) {
 396                 return NT_STATUS_NO_MEMORY;
 397         }
 398
 399         *numgroups=0;
 400
 401         for (i=PRIMARY_GROUP_SID_INDEX; i < nt_token->num_sids; i++) {
 402                 if (sid_compare_domain(domain_sid, &nt_token->user_sids[i])==0) {
 403                         sid_peek_rid(&nt_token->user_sids[i], &(gids[*numgroups].g_rid));
 404                         gids[*numgroups].attr=7;
 405                         (*numgroups)++;
 406                 }
 407         }
 408         *pgids = gids;
 409         return NT_STATUS_OK;
 410 }
 411
 412 /*******************************************************************
 413  Look up a local (domain) rid and return a name and type.
 414  ********************************************************************/
 415 NTSTATUS local_lookup_group_name(uint32 rid, char *group_name, uint32 *type)
 416 {
 417         int i = 0;
 418         (*type) = SID_NAME_DOM_GRP;
 419
 420         DEBUG(5,("lookup_group_name: rid: %d", rid));
 421
 422         while (domain_group_rids[i].rid != rid && domain_group_rids[i].rid != 0)
 423         {
 424                 i++;
 425         }
 426
 427         if (domain_group_rids[i].rid != 0)
 428         {
 429                 fstrcpy(group_name, domain_group_rids[i].name);
 430                 DEBUG(5,(" = %s\n", group_name));
 431                 return NT_STATUS_OK;
 432         }
 433
 434         DEBUG(5,(" none mapped\n"));
 435         return NT_STATUS_NONE_MAPPED;
 436 }
 437
 438 /*******************************************************************
 439  Look up a local alias rid and return a name and type.
 440  ********************************************************************/
 441 NTSTATUS local_lookup_alias_name(uint32 rid, char *alias_name, uint32 *type)
 442 {
 443         int i = 0;
 444         (*type) = SID_NAME_WKN_GRP;
 445
 446         DEBUG(5,("lookup_alias_name: rid: %d", rid));
 447
 448         while (builtin_alias_rids[i].rid != rid && builtin_alias_rids[i].rid != 0)
 449         {
 450                 i++;
 451         }
 452
 453         if (builtin_alias_rids[i].rid != 0)
 454         {
 455                 fstrcpy(alias_name, builtin_alias_rids[i].name);
 456                 DEBUG(5,(" = %s\n", alias_name));
 457                 return NT_STATUS_OK;
 458         }
 459
 460         DEBUG(5,(" none mapped\n"));
 461         return NT_STATUS_NONE_MAPPED;
 462 }
 463
 464
 465 #if 0 /*Nobody uses this function just now*/
 466 /*******************************************************************
 467  Look up a local user rid and return a name and type.
 468  ********************************************************************/
 469 NTSTATUS local_lookup_user_name(uint32 rid, char *user_name, uint32 *type)
 470 {
 471         SAM_ACCOUNT *sampwd=NULL;
 472         int i = 0;
 473         BOOL ret;
 474
 475         (*type) = SID_NAME_USER;
 476
 477         DEBUG(5,("lookup_user_name: rid: %d", rid));
 478
 479         /* look up the well-known domain user rids first */
 480         while (domain_user_rids[i].rid != rid && domain_user_rids[i].rid != 0)
 481         {
 482                 i++;
 483         }
 484
 485         if (domain_user_rids[i].rid != 0) {
 486                 fstrcpy(user_name, domain_user_rids[i].name);
 487                 DEBUG(5,(" = %s\n", user_name));
 488                 return NT_STATUS_OK;
 489         }
 490
 491         pdb_init_sam(&sampwd);
 492
 493         /* ok, it's a user.  find the user account */
 494         become_root();
 495         ret = pdb_getsampwrid(sampwd, rid);
 496         unbecome_root();
 497
 498         if (ret == True) {
 499                 fstrcpy(user_name, pdb_get_username(sampwd) );
 500                 DEBUG(5,(" = %s\n", user_name));
 501                 pdb_free_sam(&sampwd);
 502                 return NT_STATUS_OK;
 503         }
 504
 505         DEBUG(5,(" none mapped\n"));
 506         pdb_free_sam(&sampwd);
 507         return NT_STATUS_NONE_MAPPED;
 508 }
 509
 510 #endif
 511
 512 /*******************************************************************
 513  Look up a local (domain) group name and return a rid
 514  ********************************************************************/
 515 NTSTATUS local_lookup_group_rid(char *group_name, uint32 *rid)
 516 {
 517         const char *grp_name;
 518         int i = -1; /* start do loop at -1 */
 519
 520         do /* find, if it exists, a group rid for the group name*/
 521         {
 522                 i++;
 523                 (*rid) = domain_group_rids[i].rid;
 524                 grp_name = domain_group_rids[i].name;
 525
 526         } while (grp_name != NULL && !strequal(grp_name, group_name));
 527
 528         return (grp_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
 529 }
 530
 531 /*******************************************************************
 532  Look up a local (BUILTIN) alias name and return a rid
 533  ********************************************************************/
 534 NTSTATUS local_lookup_alias_rid(const char *alias_name, uint32 *rid)
 535 {
 536         const char *als_name;
 537         int i = -1; /* start do loop at -1 */
 538
 539         do /* find, if it exists, a alias rid for the alias name*/
 540         {
 541                 i++;
 542                 (*rid) = builtin_alias_rids[i].rid;
 543                 als_name = builtin_alias_rids[i].name;
 544
 545         } while (als_name != NULL && !strequal(als_name, alias_name));
 546
 547         return (als_name != NULL) ? NT_STATUS_OK : NT_STATUS_NONE_MAPPED;
 548 }
 549
 550 /*******************************************************************
 551  Look up a local user name and return a rid
 552  ********************************************************************/
 553 NTSTATUS local_lookup_user_rid(char *user_name, uint32 *rid)
 554 {
 555         SAM_ACCOUNT *sampass=NULL;
 556         BOOL ret;
 557
 558         (*rid) = 0;
 559
 560         pdb_init_sam(&sampass);
 561
 562         /* find the user account */
 563         become_root();
 564         ret = pdb_getsampwnam(sampass, user_name);
 565         unbecome_root();
 566
 567         if (ret == True) {
 568                 (*rid) = pdb_get_user_rid(sampass);
 569                 pdb_free_sam(&sampass);
 570                 return NT_STATUS_OK;
 571         }
 572
 573         pdb_free_sam(&sampass);
 574         return NT_STATUS_NONE_MAPPED;
 575 }