source3/groupdb/mapping.c

   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  *  Copyright (C) Volker Lendecke              2006.
   7  *  Copyright (C) Gerald Carter                2006.
   8  *
   9  *  This program is free software; you can redistribute it and/or modify
  10  *  it under the terms of the GNU General Public License as published by
  11  *  the Free Software Foundation; either version 3 of the License, or
  12  *  (at your option) any later version.
  13  *
  14  *  This program is distributed in the hope that it will be useful,
  15  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17  *  GNU General Public License for more details.
  18  *
  19  *  You should have received a copy of the GNU General Public License
  20  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  21  */
  22
  23 #include "includes.h"
  24 #include "groupdb/mapping.h"
  25
  26 static const struct mapping_backend *backend;
  27
  28 /*
  29   initialise a group mapping backend
  30  */
  31 static bool init_group_mapping(void)
  32 {
  33         if (backend != NULL) {
  34                 /* already initialised */
  35                 return True;
  36         }
  37
  38         backend = groupdb_tdb_init();
  39
  40         return backend != NULL;
  41 }
  42
  43 /****************************************************************************
  44 initialise first time the mapping list
  45 ****************************************************************************/
  46 NTSTATUS add_initial_entry(gid_t gid, const char *sid, enum lsa_SidType sid_name_use, const char *nt_name, const char *comment)
  47 {
  48         GROUP_MAP map;
  49
  50         if(!init_group_mapping()) {
  51                 DEBUG(0,("failed to initialize group mapping\n"));
  52                 return NT_STATUS_UNSUCCESSFUL;
  53         }
  54
  55         map.gid=gid;
  56         if (!string_to_sid(&map.sid, sid)) {
  57                 DEBUG(0, ("string_to_sid failed: %s", sid));
  58                 return NT_STATUS_UNSUCCESSFUL;
  59         }
  60
  61         map.sid_name_use=sid_name_use;
  62         fstrcpy(map.nt_name, nt_name);
  63         fstrcpy(map.comment, comment);
  64
  65         return pdb_add_group_mapping_entry(&map);
  66 }
  67
  68 static NTSTATUS alias_memberships(const struct dom_sid *members, size_t num_members,
  69                                   struct dom_sid **sids, size_t *num)
  70 {
  71         size_t i;
  72
  73         *num = 0;
  74         *sids = NULL;
  75
  76         for (i=0; i<num_members; i++) {
  77                 NTSTATUS status = backend->one_alias_membership(&members[i], sids, num);
  78                 if (!NT_STATUS_IS_OK(status))
  79                         return status;
  80         }
  81         return NT_STATUS_OK;
  82 }
  83
  84 struct aliasmem_closure {
  85         const struct dom_sid *alias;
  86         struct dom_sid **sids;
  87         size_t *num;
  88 };
  89
  90
  91
  92 /*
  93  *
  94  * High level functions
  95  * better to use them than the lower ones.
  96  *
  97  * we are checking if the group is in the mapping file
  98  * and if the group is an existing unix group
  99  *
 100  */
 101
 102 /* get a domain group from it's SID */
 103
 104 bool get_domain_group_from_sid(struct dom_sid sid, GROUP_MAP *map)
 105 {
 106         struct group *grp;
 107         bool ret;
 108
 109         if(!init_group_mapping()) {
 110                 DEBUG(0,("failed to initialize group mapping\n"));
 111                 return(False);
 112         }
 113
 114         DEBUG(10, ("get_domain_group_from_sid\n"));
 115
 116         /* if the group is NOT in the database, it CAN NOT be a domain group */
 117
 118         become_root();
 119         ret = pdb_getgrsid(map, sid);
 120         unbecome_root();
 121
 122         /* special case check for rid 513 */
 123
 124         if ( !ret ) {
 125                 uint32 rid;
 126
 127                 sid_peek_rid( &sid, &rid );
 128
 129                 if ( rid == DOMAIN_RID_USERS ) {
 130                         fstrcpy( map->nt_name, "None" );
 131                         fstrcpy( map->comment, "Ordinary Users" );
 132                         sid_copy( &map->sid, &sid );
 133                         map->sid_name_use = SID_NAME_DOM_GRP;
 134                         map->gid = (gid_t)-1;
 135                         return True;
 136                 }
 137                 return False;
 138         }
 139
 140         DEBUG(10, ("get_domain_group_from_sid: SID found in the TDB\n"));
 141
 142         /* if it's not a domain group, continue */
 143         if (map->sid_name_use!=SID_NAME_DOM_GRP) {
 144                 return False;
 145         }
 146
 147         DEBUG(10, ("get_domain_group_from_sid: SID is a domain group\n"));
 148
 149         if (map->gid==-1) {
 150                 return False;
 151         }
 152
 153         DEBUG(10, ("get_domain_group_from_sid: SID is mapped to gid:%lu\n",(unsigned long)map->gid));
 154
 155         grp = getgrgid(map->gid);
 156         if ( !grp ) {
 157                 DEBUG(10, ("get_domain_group_from_sid: gid DOESN'T exist in UNIX security\n"));
 158                 return False;
 159         }
 160
 161         DEBUG(10, ("get_domain_group_from_sid: gid exists in UNIX security\n"));
 162
 163         return True;
 164 }
 165
 166 /****************************************************************************
 167  Create a UNIX group on demand.
 168 ****************************************************************************/
 169
 170 int smb_create_group(const char *unix_group, gid_t *new_gid)
 171 {
 172         char *add_script = NULL;
 173         int     ret = -1;
 174         int     fd = 0;
 175
 176         *new_gid = 0;
 177
 178         /* defer to scripts */
 179
 180         if ( *lp_addgroup_script() ) {
 181                 TALLOC_CTX *ctx = talloc_tos();
 182
 183                 add_script = talloc_strdup(ctx,
 184                                         lp_addgroup_script());
 185                 if (!add_script) {
 186                         return -1;
 187                 }
 188                 add_script = talloc_string_sub(ctx,
 189                                 add_script, "%g", unix_group);
 190                 if (!add_script) {
 191                         return -1;
 192                 }
 193
 194                 ret = smbrun(add_script, &fd);
 195                 DEBUG(ret ? 0 : 3,("smb_create_group: Running the command `%s' gave %d\n",add_script,ret));
 196                 if (ret == 0) {
 197                         smb_nscd_flush_group_cache();
 198                 }
 199                 if (ret != 0)
 200                         return ret;
 201
 202                 if (fd != 0) {
 203                         fstring output;
 204
 205                         *new_gid = 0;
 206                         if (read(fd, output, sizeof(output)) > 0) {
 207                                 *new_gid = (gid_t)strtoul(output, NULL, 10);
 208                         }
 209
 210                         close(fd);
 211                 }
 212
 213         }
 214
 215         if (*new_gid == 0) {
 216                 struct group *grp = getgrnam(unix_group);
 217
 218                 if (grp != NULL)
 219                         *new_gid = grp->gr_gid;
 220         }
 221
 222         return ret;
 223 }
 224
 225 /****************************************************************************
 226  Delete a UNIX group on demand.
 227 ****************************************************************************/
 228
 229 int smb_delete_group(const char *unix_group)
 230 {
 231         char *del_script = NULL;
 232         int ret = -1;
 233
 234         /* defer to scripts */
 235
 236         if ( *lp_delgroup_script() ) {
 237                 TALLOC_CTX *ctx = talloc_tos();
 238
 239                 del_script = talloc_strdup(ctx,
 240                                 lp_delgroup_script());
 241                 if (!del_script) {
 242                         return -1;
 243                 }
 244                 del_script = talloc_string_sub(ctx,
 245                                 del_script, "%g", unix_group);
 246                 if (!del_script) {
 247                         return -1;
 248                 }
 249                 ret = smbrun(del_script,NULL);
 250                 DEBUG(ret ? 0 : 3,("smb_delete_group: Running the command `%s' gave %d\n",del_script,ret));
 251                 if (ret == 0) {
 252                         smb_nscd_flush_group_cache();
 253                 }
 254                 return ret;
 255         }
 256
 257         return -1;
 258 }
 259
 260 /****************************************************************************
 261  Set a user's primary UNIX group.
 262 ****************************************************************************/
 263
 264 int smb_set_primary_group(const char *unix_group, const char* unix_user)
 265 {
 266         char *add_script = NULL;
 267         int ret = -1;
 268
 269         /* defer to scripts */
 270
 271         if ( *lp_setprimarygroup_script() ) {
 272                 TALLOC_CTX *ctx = talloc_tos();
 273
 274                 add_script = talloc_strdup(ctx,
 275                                 lp_setprimarygroup_script());
 276                 if (!add_script) {
 277                         return -1;
 278                 }
 279                 add_script = talloc_all_string_sub(ctx,
 280                                 add_script, "%g", unix_group);
 281                 if (!add_script) {
 282                         return -1;
 283                 }
 284                 add_script = talloc_string_sub(ctx,
 285                                 add_script, "%u", unix_user);
 286                 if (!add_script) {
 287                         return -1;
 288                 }
 289                 ret = smbrun(add_script,NULL);
 290                 flush_pwnam_cache();
 291                 DEBUG(ret ? 0 : 3,("smb_set_primary_group: "
 292                          "Running the command `%s' gave %d\n",add_script,ret));
 293                 if (ret == 0) {
 294                         smb_nscd_flush_group_cache();
 295                 }
 296                 return ret;
 297         }
 298
 299         return -1;
 300 }
 301
 302 /****************************************************************************
 303  Add a user to a UNIX group.
 304 ****************************************************************************/
 305
 306 int smb_add_user_group(const char *unix_group, const char *unix_user)
 307 {
 308         char *add_script = NULL;
 309         int ret = -1;
 310
 311         /* defer to scripts */
 312
 313         if ( *lp_addusertogroup_script() ) {
 314                 TALLOC_CTX *ctx = talloc_tos();
 315
 316                 add_script = talloc_strdup(ctx,
 317                                 lp_addusertogroup_script());
 318                 if (!add_script) {
 319                         return -1;
 320                 }
 321                 add_script = talloc_string_sub(ctx,
 322                                 add_script, "%g", unix_group);
 323                 if (!add_script) {
 324                         return -1;
 325                 }
 326                 add_script = talloc_string_sub(ctx,
 327                                 add_script, "%u", unix_user);
 328                 if (!add_script) {
 329                         return -1;
 330                 }
 331                 ret = smbrun(add_script,NULL);
 332                 DEBUG(ret ? 0 : 3,("smb_add_user_group: Running the command `%s' gave %d\n",add_script,ret));
 333                 if (ret == 0) {
 334                         smb_nscd_flush_group_cache();
 335                 }
 336                 return ret;
 337         }
 338
 339         return -1;
 340 }
 341
 342 /****************************************************************************
 343  Delete a user from a UNIX group
 344 ****************************************************************************/
 345
 346 int smb_delete_user_group(const char *unix_group, const char *unix_user)
 347 {
 348         char *del_script = NULL;
 349         int ret = -1;
 350
 351         /* defer to scripts */
 352
 353         if ( *lp_deluserfromgroup_script() ) {
 354                 TALLOC_CTX *ctx = talloc_tos();
 355
 356                 del_script = talloc_strdup(ctx,
 357                                 lp_deluserfromgroup_script());
 358                 if (!del_script) {
 359                         return -1;
 360                 }
 361                 del_script = talloc_string_sub(ctx,
 362                                 del_script, "%g", unix_group);
 363                 if (!del_script) {
 364                         return -1;
 365                 }
 366                 del_script = talloc_string_sub(ctx,
 367                                 del_script, "%u", unix_user);
 368                 if (!del_script) {
 369                         return -1;
 370                 }
 371                 ret = smbrun(del_script,NULL);
 372                 DEBUG(ret ? 0 : 3,("smb_delete_user_group: Running the command `%s' gave %d\n",del_script,ret));
 373                 if (ret == 0) {
 374                         smb_nscd_flush_group_cache();
 375                 }
 376                 return ret;
 377         }
 378
 379         return -1;
 380 }
 381
 382
 383 NTSTATUS pdb_default_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
 384                                  struct dom_sid sid)
 385 {
 386         if (!init_group_mapping()) {
 387                 DEBUG(0,("failed to initialize group mapping\n"));
 388                 return NT_STATUS_UNSUCCESSFUL;
 389         }
 390         return backend->get_group_map_from_sid(sid, map) ?
 391                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 392 }
 393
 394 NTSTATUS pdb_default_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
 395                                  gid_t gid)
 396 {
 397         if (!init_group_mapping()) {
 398                 DEBUG(0,("failed to initialize group mapping\n"));
 399                 return NT_STATUS_UNSUCCESSFUL;
 400         }
 401         return backend->get_group_map_from_gid(gid, map) ?
 402                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 403 }
 404
 405 NTSTATUS pdb_default_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
 406                                  const char *name)
 407 {
 408         if (!init_group_mapping()) {
 409                 DEBUG(0,("failed to initialize group mapping\n"));
 410                 return NT_STATUS_UNSUCCESSFUL;
 411         }
 412         return backend->get_group_map_from_ntname(name, map) ?
 413                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 414 }
 415
 416 NTSTATUS pdb_default_add_group_mapping_entry(struct pdb_methods *methods,
 417                                                 GROUP_MAP *map)
 418 {
 419         if (!init_group_mapping()) {
 420                 DEBUG(0,("failed to initialize group mapping\n"));
 421                 return NT_STATUS_UNSUCCESSFUL;
 422         }
 423         return backend->add_mapping_entry(map, TDB_INSERT) ?
 424                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 425 }
 426
 427 NTSTATUS pdb_default_update_group_mapping_entry(struct pdb_methods *methods,
 428                                                    GROUP_MAP *map)
 429 {
 430         if (!init_group_mapping()) {
 431                 DEBUG(0,("failed to initialize group mapping\n"));
 432                 return NT_STATUS_UNSUCCESSFUL;
 433         }
 434         return backend->add_mapping_entry(map, TDB_REPLACE) ?
 435                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 436 }
 437
 438 NTSTATUS pdb_default_delete_group_mapping_entry(struct pdb_methods *methods,
 439                                                    struct dom_sid sid)
 440 {
 441         if (!init_group_mapping()) {
 442                 DEBUG(0,("failed to initialize group mapping\n"));
 443                 return NT_STATUS_UNSUCCESSFUL;
 444         }
 445         return backend->group_map_remove(&sid) ?
 446                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 447 }
 448
 449 NTSTATUS pdb_default_enum_group_mapping(struct pdb_methods *methods,
 450                                            const struct dom_sid *sid, enum lsa_SidType sid_name_use,
 451                                            GROUP_MAP **pp_rmap, size_t *p_num_entries,
 452                                            bool unix_only)
 453 {
 454         if (!init_group_mapping()) {
 455                 DEBUG(0,("failed to initialize group mapping\n"));
 456                 return NT_STATUS_UNSUCCESSFUL;
 457         }
 458         return backend->enum_group_mapping(sid, sid_name_use, pp_rmap, p_num_entries, unix_only) ?
 459                 NT_STATUS_OK : NT_STATUS_UNSUCCESSFUL;
 460 }
 461
 462 NTSTATUS pdb_default_create_alias(struct pdb_methods *methods,
 463                                   const char *name, uint32 *rid)
 464 {
 465         struct dom_sid sid;
 466         enum lsa_SidType type;
 467         uint32 new_rid;
 468         gid_t gid;
 469         bool exists;
 470         GROUP_MAP map;
 471         TALLOC_CTX *mem_ctx;
 472         NTSTATUS status;
 473
 474         DEBUG(10, ("Trying to create alias %s\n", name));
 475
 476         mem_ctx = talloc_new(NULL);
 477         if (mem_ctx == NULL) {
 478                 return NT_STATUS_NO_MEMORY;
 479         }
 480
 481         exists = lookup_name(mem_ctx, name, LOOKUP_NAME_LOCAL,
 482                              NULL, NULL, &sid, &type);
 483         TALLOC_FREE(mem_ctx);
 484
 485         if (exists) {
 486                 return NT_STATUS_ALIAS_EXISTS;
 487         }
 488
 489         if (!pdb_new_rid(&new_rid)) {
 490                 DEBUG(0, ("Could not allocate a RID.\n"));
 491                 return NT_STATUS_ACCESS_DENIED;
 492         }
 493
 494         sid_compose(&sid, get_global_sam_sid(), new_rid);
 495
 496         if (!winbind_allocate_gid(&gid)) {
 497                 DEBUG(3, ("Could not get a gid out of winbind - "
 498                           "wasted a rid :-(\n"));
 499                 return NT_STATUS_ACCESS_DENIED;
 500         }
 501
 502         DEBUG(10, ("Creating alias %s with gid %u and rid %u\n",
 503                    name, (unsigned int)gid, (unsigned int)new_rid));
 504
 505         map.gid = gid;
 506         sid_copy(&map.sid, &sid);
 507         map.sid_name_use = SID_NAME_ALIAS;
 508         fstrcpy(map.nt_name, name);
 509         fstrcpy(map.comment, "");
 510
 511         status = pdb_add_group_mapping_entry(&map);
 512
 513         if (!NT_STATUS_IS_OK(status)) {
 514                 DEBUG(0, ("Could not add group mapping entry for alias %s "
 515                           "(%s)\n", name, nt_errstr(status)));
 516                 return status;
 517         }
 518
 519         *rid = new_rid;
 520
 521         return NT_STATUS_OK;
 522 }
 523
 524 NTSTATUS pdb_default_delete_alias(struct pdb_methods *methods,
 525                                   const struct dom_sid *sid)
 526 {
 527         return pdb_delete_group_mapping_entry(*sid);
 528 }
 529
 530 NTSTATUS pdb_default_get_aliasinfo(struct pdb_methods *methods,
 531                                    const struct dom_sid *sid,
 532                                    struct acct_info *info)
 533 {
 534         GROUP_MAP map;
 535
 536         if (!pdb_getgrsid(&map, *sid))
 537                 return NT_STATUS_NO_SUCH_ALIAS;
 538
 539         if ((map.sid_name_use != SID_NAME_ALIAS) &&
 540             (map.sid_name_use != SID_NAME_WKN_GRP)) {
 541                 DEBUG(2, ("%s is a %s, expected an alias\n",
 542                           sid_string_dbg(sid),
 543                           sid_type_lookup(map.sid_name_use)));
 544                 return NT_STATUS_NO_SUCH_ALIAS;
 545         }
 546
 547         fstrcpy(info->acct_name, map.nt_name);
 548         fstrcpy(info->acct_desc, map.comment);
 549         sid_peek_rid(&map.sid, &info->rid);
 550         return NT_STATUS_OK;
 551 }
 552
 553 NTSTATUS pdb_default_set_aliasinfo(struct pdb_methods *methods,
 554                                    const struct dom_sid *sid,
 555                                    struct acct_info *info)
 556 {
 557         GROUP_MAP map;
 558
 559         if (!pdb_getgrsid(&map, *sid))
 560                 return NT_STATUS_NO_SUCH_ALIAS;
 561
 562         fstrcpy(map.nt_name, info->acct_name);
 563         fstrcpy(map.comment, info->acct_desc);
 564
 565         return pdb_update_group_mapping_entry(&map);
 566 }
 567
 568 NTSTATUS pdb_default_add_aliasmem(struct pdb_methods *methods,
 569                                   const struct dom_sid *alias, const struct dom_sid *member)
 570 {
 571         if (!init_group_mapping()) {
 572                 DEBUG(0,("failed to initialize group mapping\n"));
 573                 return NT_STATUS_UNSUCCESSFUL;
 574         }
 575         return backend->add_aliasmem(alias, member);
 576 }
 577
 578 NTSTATUS pdb_default_del_aliasmem(struct pdb_methods *methods,
 579                                   const struct dom_sid *alias, const struct dom_sid *member)
 580 {
 581         if (!init_group_mapping()) {
 582                 DEBUG(0,("failed to initialize group mapping\n"));
 583                 return NT_STATUS_UNSUCCESSFUL;
 584         }
 585         return backend->del_aliasmem(alias, member);
 586 }
 587
 588 NTSTATUS pdb_default_enum_aliasmem(struct pdb_methods *methods,
 589                                    const struct dom_sid *alias, TALLOC_CTX *mem_ctx,
 590                                    struct dom_sid **pp_members, size_t *p_num_members)
 591 {
 592         if (!init_group_mapping()) {
 593                 DEBUG(0,("failed to initialize group mapping\n"));
 594                 return NT_STATUS_UNSUCCESSFUL;
 595         }
 596         return backend->enum_aliasmem(alias, mem_ctx, pp_members,
 597                                       p_num_members);
 598 }
 599
 600 NTSTATUS pdb_default_alias_memberships(struct pdb_methods *methods,
 601                                        TALLOC_CTX *mem_ctx,
 602                                        const struct dom_sid *domain_sid,
 603                                        const struct dom_sid *members,
 604                                        size_t num_members,
 605                                        uint32 **pp_alias_rids,
 606                                        size_t *p_num_alias_rids)
 607 {
 608         struct dom_sid *alias_sids;
 609         size_t i, num_alias_sids;
 610         NTSTATUS result;
 611
 612         if (!init_group_mapping()) {
 613                 DEBUG(0,("failed to initialize group mapping\n"));
 614                 return NT_STATUS_UNSUCCESSFUL;
 615         }
 616
 617         alias_sids = NULL;
 618         num_alias_sids = 0;
 619
 620         result = alias_memberships(members, num_members,
 621                                    &alias_sids, &num_alias_sids);
 622
 623         if (!NT_STATUS_IS_OK(result))
 624                 return result;
 625
 626         *p_num_alias_rids = 0;
 627
 628         if (num_alias_sids == 0) {
 629                 TALLOC_FREE(alias_sids);
 630                 return NT_STATUS_OK;
 631         }
 632
 633         *pp_alias_rids = TALLOC_ARRAY(mem_ctx, uint32, num_alias_sids);
 634         if (*pp_alias_rids == NULL)
 635                 return NT_STATUS_NO_MEMORY;
 636
 637         for (i=0; i<num_alias_sids; i++) {
 638                 if (!sid_peek_check_rid(domain_sid, &alias_sids[i],
 639                                         &(*pp_alias_rids)[*p_num_alias_rids]))
 640                         continue;
 641                 *p_num_alias_rids += 1;
 642         }
 643
 644         TALLOC_FREE(alias_sids);
 645
 646         return NT_STATUS_OK;
 647 }
 648
 649 /**********************************************************************
 650  no ops for passdb backends that don't implement group mapping
 651  *********************************************************************/
 652
 653 NTSTATUS pdb_nop_getgrsid(struct pdb_methods *methods, GROUP_MAP *map,
 654                                  struct dom_sid sid)
 655 {
 656         return NT_STATUS_UNSUCCESSFUL;
 657 }
 658
 659 NTSTATUS pdb_nop_getgrgid(struct pdb_methods *methods, GROUP_MAP *map,
 660                                  gid_t gid)
 661 {
 662         return NT_STATUS_UNSUCCESSFUL;
 663 }
 664
 665 NTSTATUS pdb_nop_getgrnam(struct pdb_methods *methods, GROUP_MAP *map,
 666                                  const char *name)
 667 {
 668         return NT_STATUS_UNSUCCESSFUL;
 669 }
 670
 671 NTSTATUS pdb_nop_add_group_mapping_entry(struct pdb_methods *methods,
 672                                                 GROUP_MAP *map)
 673 {
 674         return NT_STATUS_UNSUCCESSFUL;
 675 }
 676
 677 NTSTATUS pdb_nop_update_group_mapping_entry(struct pdb_methods *methods,
 678                                                    GROUP_MAP *map)
 679 {
 680         return NT_STATUS_UNSUCCESSFUL;
 681 }
 682
 683 NTSTATUS pdb_nop_delete_group_mapping_entry(struct pdb_methods *methods,
 684                                                    struct dom_sid sid)
 685 {
 686         return NT_STATUS_UNSUCCESSFUL;
 687 }
 688
 689 NTSTATUS pdb_nop_enum_group_mapping(struct pdb_methods *methods,
 690                                            enum lsa_SidType sid_name_use,
 691                                            GROUP_MAP **rmap, size_t *num_entries,
 692                                            bool unix_only)
 693 {
 694         return NT_STATUS_UNSUCCESSFUL;
 695 }
 696
 697 /****************************************************************************
 698  These need to be redirected through pdb_interface.c
 699 ****************************************************************************/
 700 bool pdb_get_dom_grp_info(const struct dom_sid *sid, struct acct_info *info)
 701 {
 702         GROUP_MAP map;
 703         bool res;
 704
 705         become_root();
 706         res = get_domain_group_from_sid(*sid, &map);
 707         unbecome_root();
 708
 709         if (!res)
 710                 return False;
 711
 712         fstrcpy(info->acct_name, map.nt_name);
 713         fstrcpy(info->acct_desc, map.comment);
 714         sid_peek_rid(sid, &info->rid);
 715         return True;
 716 }
 717
 718 bool pdb_set_dom_grp_info(const struct dom_sid *sid, const struct acct_info *info)
 719 {
 720         GROUP_MAP map;
 721
 722         if (!get_domain_group_from_sid(*sid, &map))
 723                 return False;
 724
 725         fstrcpy(map.nt_name, info->acct_name);
 726         fstrcpy(map.comment, info->acct_desc);
 727
 728         return NT_STATUS_IS_OK(pdb_update_group_mapping_entry(&map));
 729 }
 730
 731 /********************************************************************
 732  Really just intended to be called by smbd
 733 ********************************************************************/
 734
 735 NTSTATUS pdb_create_builtin_alias(uint32 rid)
 736 {
 737         struct dom_sid sid;
 738         enum lsa_SidType type;
 739         gid_t gid;
 740         GROUP_MAP map;
 741         TALLOC_CTX *mem_ctx;
 742         NTSTATUS status;
 743         const char *name = NULL;
 744         fstring groupname;
 745
 746         DEBUG(10, ("Trying to create builtin alias %d\n", rid));
 747
 748         if ( !sid_compose( &sid, &global_sid_Builtin, rid ) ) {
 749                 return NT_STATUS_NO_SUCH_ALIAS;
 750         }
 751
 752         if ( (mem_ctx = talloc_new(NULL)) == NULL ) {
 753                 return NT_STATUS_NO_MEMORY;
 754         }
 755
 756         if ( !lookup_sid(mem_ctx, &sid, NULL, &name, &type) ) {
 757                 TALLOC_FREE( mem_ctx );
 758                 return NT_STATUS_NO_SUCH_ALIAS;
 759         }
 760
 761         /* validate RID so copy the name and move on */
 762
 763         fstrcpy( groupname, name );
 764         TALLOC_FREE( mem_ctx );
 765
 766         if (!winbind_allocate_gid(&gid)) {
 767                 DEBUG(3, ("pdb_create_builtin_alias: Could not get a gid out of winbind\n"));
 768                 return NT_STATUS_ACCESS_DENIED;
 769         }
 770
 771         DEBUG(10,("Creating alias %s with gid %u\n", groupname, (unsigned int)gid));
 772
 773         map.gid = gid;
 774         sid_copy(&map.sid, &sid);
 775         map.sid_name_use = SID_NAME_ALIAS;
 776         fstrcpy(map.nt_name, groupname);
 777         fstrcpy(map.comment, "");
 778
 779         status = pdb_add_group_mapping_entry(&map);
 780
 781         if (!NT_STATUS_IS_OK(status)) {
 782                 DEBUG(0, ("pdb_create_builtin_alias: Could not add group mapping entry for alias %d "
 783                           "(%s)\n", rid, nt_errstr(status)));
 784         }
 785
 786         return status;
 787 }
 788
 789