reactos/dll/win32/samlib/samlib.c

   1 /*
   2  *  ReactOS kernel
   3  *  Copyright (C) 2004 ReactOS Team
   4  *
   5  *  This program is free software; you can redistribute it and/or modify
   6  *  it under the terms of the GNU General Public License as published by
   7  *  the Free Software Foundation; either version 2 of the License, or
   8  *  (at your option) any later version.
   9  *
  10  *  This program is distributed in the hope that it will be useful,
  11  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  *  GNU General Public License for more details.
  14  *
  15  *  You should have received a copy of the GNU General Public License along
  16  *  with this program; if not, write to the Free Software Foundation, Inc.,
  17  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18  */
  19 /* $Id$
  20  *
  21  * COPYRIGHT:         See COPYING in the top level directory
  22  * PROJECT:           ReactOS system libraries
  23  * PURPOSE:           SAM interface library
  24  * FILE:              lib/samlib/samlib.c
  25  * PROGRAMER:         Eric Kohl
  26  */
  27
  28 /* INCLUDES *****************************************************************/
  29
  30 #include "precomp.h"
  31
  32 WINE_DEFAULT_DEBUG_CHANNEL(samlib);
  33
  34 /* GLOBALS *******************************************************************/
  35
  36
  37 /* FUNCTIONS *****************************************************************/
  38
  39 void __RPC_FAR * __RPC_USER midl_user_allocate(SIZE_T len)
  40 {
  41     return HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, len);
  42 }
  43
  44
  45 void __RPC_USER midl_user_free(void __RPC_FAR * ptr)
  46 {
  47     HeapFree(GetProcessHeap(), 0, ptr);
  48 }
  49
  50
  51 handle_t __RPC_USER
  52 PSAMPR_SERVER_NAME_bind(PSAMPR_SERVER_NAME pszSystemName)
  53 {
  54     handle_t hBinding = NULL;
  55     LPWSTR pszStringBinding;
  56     RPC_STATUS status;
  57
  58     TRACE("PSAMPR_SERVER_NAME_bind() called\n");
  59
  60     status = RpcStringBindingComposeW(NULL,
  61                                       L"ncacn_np",
  62                                       pszSystemName,
  63                                       L"\\pipe\\samr",
  64                                       NULL,
  65                                       &pszStringBinding);
  66     if (status)
  67     {
  68         TRACE("RpcStringBindingCompose returned 0x%x\n", status);
  69         return NULL;
  70     }
  71
  72     /* Set the binding handle that will be used to bind to the server. */
  73     status = RpcBindingFromStringBindingW(pszStringBinding,
  74                                           &hBinding);
  75     if (status)
  76     {
  77         TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
  78     }
  79
  80     status = RpcStringFreeW(&pszStringBinding);
  81     if (status)
  82     {
  83 //        TRACE("RpcStringFree returned 0x%x\n", status);
  84     }
  85
  86     return hBinding;
  87 }
  88
  89
  90 void __RPC_USER
  91 PSAMPR_SERVER_NAME_unbind(PSAMPR_SERVER_NAME pszSystemName,
  92                           handle_t hBinding)
  93 {
  94     RPC_STATUS status;
  95
  96     TRACE("PSAMPR_SERVER_NAME_unbind() called\n");
  97
  98     status = RpcBindingFree(&hBinding);
  99     if (status)
 100     {
 101         TRACE("RpcBindingFree returned 0x%x\n", status);
 102     }
 103 }
 104
 105
 106 NTSTATUS
 107 NTAPI
 108 SamAddMemberToAlias(IN SAM_HANDLE AliasHandle,
 109                     IN PSID MemberId)
 110 {
 111     NTSTATUS Status;
 112
 113     TRACE("SamAddMemberToAlias(%p %p)\n",
 114           AliasHandle, MemberId);
 115
 116     RpcTryExcept
 117     {
 118         Status = SamrAddMemberToAlias((SAMPR_HANDLE)AliasHandle,
 119                                       (PRPC_SID)MemberId);
 120     }
 121     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 122     {
 123         Status = I_RpcMapWin32Status(RpcExceptionCode());
 124     }
 125     RpcEndExcept;
 126
 127     return Status;
 128 }
 129
 130
 131 NTSTATUS
 132 NTAPI
 133 SamCloseHandle(IN SAM_HANDLE SamHandle)
 134 {
 135     NTSTATUS Status;
 136
 137     TRACE("SamCloseHandle(%p)\n", SamHandle);
 138
 139     RpcTryExcept
 140     {
 141         Status = SamrCloseHandle((SAMPR_HANDLE *)&SamHandle);
 142     }
 143     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 144     {
 145         Status = I_RpcMapWin32Status(RpcExceptionCode());
 146     }
 147     RpcEndExcept;
 148
 149     return Status;
 150 }
 151
 152
 153 NTSTATUS
 154 NTAPI
 155 SamConnect(IN OUT PUNICODE_STRING ServerName,
 156            OUT PSAM_HANDLE ServerHandle,
 157            IN ACCESS_MASK DesiredAccess,
 158            IN POBJECT_ATTRIBUTES ObjectAttributes)
 159 {
 160     NTSTATUS Status;
 161
 162     TRACE("SamConnect(%p,%p,0x%08x,%p)\n",
 163           ServerName, ServerHandle, DesiredAccess, ObjectAttributes);
 164
 165     RpcTryExcept
 166     {
 167         Status = SamrConnect((PSAMPR_SERVER_NAME)ServerName,
 168                              (SAMPR_HANDLE *)ServerHandle,
 169                              DesiredAccess);
 170     }
 171     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 172     {
 173         Status = I_RpcMapWin32Status(RpcExceptionCode());
 174     }
 175     RpcEndExcept;
 176
 177     return Status;
 178 }
 179
 180
 181 NTSTATUS
 182 NTAPI
 183 SamCreateAliasInDomain(IN SAM_HANDLE DomainHandle,
 184                        IN PUNICODE_STRING AccountName,
 185                        IN ACCESS_MASK DesiredAccess,
 186                        OUT PSAM_HANDLE AliasHandle,
 187                        OUT PULONG RelativeId)
 188 {
 189     NTSTATUS Status;
 190
 191     TRACE("SamCreateAliasInDomain(%p,%p,0x%08x,%p,%p)\n",
 192           DomainHandle, AccountName, DesiredAccess, AliasHandle, RelativeId);
 193
 194     RpcTryExcept
 195     {
 196         Status = SamrCreateAliasInDomain((SAMPR_HANDLE)DomainHandle,
 197                                          (PRPC_UNICODE_STRING)AccountName,
 198                                          DesiredAccess,
 199                                          (SAMPR_HANDLE *)AliasHandle,
 200                                          RelativeId);
 201     }
 202     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 203     {
 204         Status = I_RpcMapWin32Status(RpcExceptionCode());
 205     }
 206     RpcEndExcept;
 207
 208     return Status;
 209 }
 210
 211
 212 NTSTATUS
 213 NTAPI
 214 SamCreateGroupInDomain(IN SAM_HANDLE DomainHandle,
 215                        IN PUNICODE_STRING AccountName,
 216                        IN ACCESS_MASK DesiredAccess,
 217                        OUT PSAM_HANDLE GroupHandle,
 218                        OUT PULONG RelativeId)
 219 {
 220     NTSTATUS Status;
 221
 222     TRACE("SamCreateGroupInDomain(%p,%p,0x%08x,%p,%p)\n",
 223           DomainHandle, AccountName, DesiredAccess, GroupHandle, RelativeId);
 224
 225     RpcTryExcept
 226     {
 227         Status = SamrCreateGroupInDomain((SAMPR_HANDLE)DomainHandle,
 228                                          (PRPC_UNICODE_STRING)AccountName,
 229                                          DesiredAccess,
 230                                          (SAMPR_HANDLE *)GroupHandle,
 231                                          RelativeId);
 232     }
 233     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 234     {
 235         Status = I_RpcMapWin32Status(RpcExceptionCode());
 236     }
 237     RpcEndExcept;
 238
 239     return Status;
 240 }
 241
 242
 243 NTSTATUS
 244 NTAPI
 245 SamCreateUserInDomain(IN SAM_HANDLE DomainHandle,
 246                       IN PUNICODE_STRING AccountName,
 247                       IN ACCESS_MASK DesiredAccess,
 248                       OUT PSAM_HANDLE UserHandle,
 249                       OUT PULONG RelativeId)
 250 {
 251     NTSTATUS Status;
 252
 253     TRACE("SamCreateUserInDomain(%p,%p,0x%08x,%p,%p)\n",
 254           DomainHandle, AccountName, DesiredAccess, UserHandle, RelativeId);
 255
 256     RpcTryExcept
 257     {
 258         Status = SamrCreateUserInDomain((SAMPR_HANDLE)DomainHandle,
 259                                         (PRPC_UNICODE_STRING)AccountName,
 260                                         DesiredAccess,
 261                                         (SAMPR_HANDLE *)UserHandle,
 262                                         RelativeId);
 263     }
 264     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 265     {
 266         Status = I_RpcMapWin32Status(RpcExceptionCode());
 267     }
 268     RpcEndExcept;
 269
 270     return Status;
 271 }
 272
 273
 274 NTSTATUS
 275 NTAPI
 276 SamEnumerateAliasesInDomain(IN SAM_HANDLE DomainHandle,
 277                             IN OUT PSAM_ENUMERATE_HANDLE EnumerationContext,
 278                             OUT PVOID *Buffer,
 279                             IN ULONG PreferedMaximumLength,
 280                             OUT PULONG CountReturned)
 281 {
 282     PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
 283     NTSTATUS Status;
 284
 285     TRACE("SamEnumerateAliasesInDomain(%p,%p,%p,%lu,%p)\n",
 286           DomainHandle, EnumerationContext, Buffer, PreferedMaximumLength,
 287           CountReturned);
 288
 289     if ((EnumerationContext == NULL) ||
 290         (Buffer == NULL) ||
 291         (CountReturned == NULL))
 292         return STATUS_INVALID_PARAMETER;
 293
 294     *Buffer = NULL;
 295
 296     RpcTryExcept
 297     {
 298         Status = SamrEnumerateAliasesInDomain((SAMPR_HANDLE)DomainHandle,
 299                                               EnumerationContext,
 300                                               (PSAMPR_ENUMERATION_BUFFER *)&EnumBuffer,
 301                                               PreferedMaximumLength,
 302                                               CountReturned);
 303
 304         if (EnumBuffer != NULL)
 305         {
 306             if (EnumBuffer->Buffer != NULL)
 307             {
 308                 *Buffer = EnumBuffer->Buffer;
 309             }
 310
 311             midl_user_free(EnumBuffer);
 312         }
 313     }
 314     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 315     {
 316         Status = I_RpcMapWin32Status(RpcExceptionCode());
 317     }
 318     RpcEndExcept;
 319
 320     return Status;
 321 }
 322
 323
 324 NTSTATUS
 325 NTAPI
 326 SamEnumerateDomainsInSamServer(IN SAM_HANDLE ServerHandle,
 327                                IN OUT PSAM_ENUMERATE_HANDLE EnumerationContext,
 328                                OUT PVOID *Buffer,
 329                                IN ULONG PreferedMaximumLength,
 330                                OUT PULONG CountReturned)
 331 {
 332     PSAMPR_ENUMERATION_BUFFER EnumBuffer = NULL;
 333     NTSTATUS Status;
 334
 335     TRACE("SamEnumerateDomainsInSamServer(%p,%p,%p,%lu,%p)\n",
 336           ServerHandle, EnumerationContext, Buffer, PreferedMaximumLength,
 337           CountReturned);
 338
 339     if ((EnumerationContext == NULL) ||
 340         (Buffer == NULL) ||
 341         (CountReturned == NULL))
 342         return STATUS_INVALID_PARAMETER;
 343
 344     *Buffer = NULL;
 345
 346     RpcTryExcept
 347     {
 348         Status = SamrEnumerateDomainsInSamServer((SAMPR_HANDLE)ServerHandle,
 349                                                  EnumerationContext,
 350                                                  (PSAMPR_ENUMERATION_BUFFER *)&EnumBuffer,
 351                                                  PreferedMaximumLength,
 352                                                  CountReturned);
 353
 354         if (EnumBuffer != NULL)
 355         {
 356             if (EnumBuffer->Buffer != NULL)
 357             {
 358                 *Buffer = EnumBuffer->Buffer;
 359             }
 360
 361             midl_user_free(EnumBuffer);
 362         }
 363     }
 364     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 365     {
 366         Status = I_RpcMapWin32Status(RpcExceptionCode());
 367     }
 368     RpcEndExcept;
 369
 370     return Status;
 371 }
 372
 373
 374 NTSTATUS
 375 NTAPI
 376 SamFreeMemory(IN PVOID Buffer)
 377 {
 378     if (Buffer != NULL)
 379         midl_user_free(Buffer);
 380
 381     return STATUS_SUCCESS;
 382 }
 383
 384
 385 NTSTATUS
 386 NTAPI
 387 SamGetAliasMembership(IN SAM_HANDLE DomainHandle,
 388                       IN ULONG PassedCount,
 389                       IN PSID *Sids,
 390                       OUT PULONG MembershipCount,
 391                       OUT PULONG *Aliases)
 392 {
 393     SAMPR_PSID_ARRAY SidArray;
 394     SAMPR_ULONG_ARRAY Membership;
 395     NTSTATUS Status;
 396
 397     TRACE("SamAliasMembership(%p %ul %p %p %p)\n",
 398           DomainHandle, PassedCount, Sids, MembershipCount, Aliases);
 399
 400     if (Sids == NULL ||
 401         MembershipCount == NULL ||
 402         Aliases == NULL)
 403         return STATUS_INVALID_PARAMETER;
 404
 405     Membership.Element = NULL;
 406
 407     RpcTryExcept
 408     {
 409         SidArray.Count = PassedCount;
 410         SidArray.Sids = (PSAMPR_SID_INFORMATION)Sids;
 411
 412         Status = SamrGetAliasMembership((SAMPR_HANDLE)DomainHandle,
 413                                         &SidArray,
 414                                         &Membership);
 415         if (NT_SUCCESS(Status))
 416         {
 417             *MembershipCount = Membership.Count;
 418             *Aliases = Membership.Element;
 419         }
 420         else
 421         {
 422             if (Membership.Element != NULL)
 423                 midl_user_free(Membership.Element);
 424         }
 425     }
 426     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 427     {
 428         Status = I_RpcMapWin32Status(RpcExceptionCode());
 429     }
 430     RpcEndExcept;
 431
 432     return Status;
 433 }
 434
 435
 436 NTSTATUS
 437 NTAPI
 438 SamGetMembersInAlias(IN SAM_HANDLE AliasHandle,
 439                      OUT PSID **MemberIds,
 440                      OUT PULONG MemberCount)
 441 {
 442     SAMPR_PSID_ARRAY_OUT SidArray;
 443     NTSTATUS Status;
 444
 445     TRACE("SamGetMembersInAlias(%p %p %p)\n",
 446           AliasHandle, MemberIds, MemberCount);
 447
 448     if ((MemberIds == NULL) ||
 449         (MemberCount == NULL))
 450         return STATUS_INVALID_PARAMETER;
 451
 452     *MemberIds = NULL;
 453     *MemberCount = 0;
 454
 455     SidArray.Sids = NULL;
 456
 457     RpcTryExcept
 458     {
 459         Status = SamrGetMembersInAlias((SAMPR_HANDLE)AliasHandle,
 460                                        &SidArray);
 461         if (NT_SUCCESS(Status))
 462         {
 463             *MemberCount = SidArray.Count;
 464             *MemberIds = (PSID *)SidArray.Sids;
 465         }
 466
 467     }
 468     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 469     {
 470         Status = I_RpcMapWin32Status(RpcExceptionCode());
 471     }
 472     RpcEndExcept;
 473
 474     return Status;
 475 }
 476
 477
 478 NTSTATUS
 479 NTAPI
 480 SamLookupDomainInSamServer(IN SAM_HANDLE ServerHandle,
 481                            IN PUNICODE_STRING Name,
 482                            OUT PSID *DomainId)
 483 {
 484     NTSTATUS Status;
 485
 486     TRACE("SamLookupDomainInSamServer(%p,%p,%p)\n",
 487           ServerHandle, Name, DomainId);
 488
 489     RpcTryExcept
 490     {
 491         Status = SamrLookupDomainInSamServer((SAMPR_HANDLE)ServerHandle,
 492                                              (PRPC_UNICODE_STRING)Name,
 493                                              (PRPC_SID *)DomainId);
 494     }
 495     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 496     {
 497         Status = I_RpcMapWin32Status(RpcExceptionCode());
 498     }
 499     RpcEndExcept;
 500
 501     return Status;
 502 }
 503
 504
 505 NTSTATUS
 506 NTAPI
 507 SamLookupNamesInDomain(IN SAM_HANDLE DomainHandle,
 508                        IN ULONG Count,
 509                        IN PUNICODE_STRING Names,
 510                        OUT PULONG *RelativeIds,
 511                        OUT PSID_NAME_USE *Use)
 512 {
 513     UNIMPLEMENTED;
 514     return STATUS_NOT_IMPLEMENTED;
 515 }
 516
 517
 518 NTSTATUS
 519 NTAPI
 520 SamOpenAlias(IN SAM_HANDLE DomainHandle,
 521              IN ACCESS_MASK DesiredAccess,
 522              IN ULONG AliasId,
 523              OUT PSAM_HANDLE AliasHandle)
 524 {
 525     NTSTATUS Status;
 526
 527     TRACE("SamOpenAlias(%p 0x%08x %lx %p)\n",
 528           DomainHandle, DesiredAccess, AliasId, AliasHandle);
 529
 530     RpcTryExcept
 531     {
 532         Status = SamrOpenAlias((SAMPR_HANDLE)DomainHandle,
 533                                DesiredAccess,
 534                                AliasId,
 535                                (SAMPR_HANDLE *)AliasHandle);
 536     }
 537     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 538     {
 539         Status = I_RpcMapWin32Status(RpcExceptionCode());
 540     }
 541     RpcEndExcept;
 542
 543     return Status;
 544 }
 545
 546
 547 NTSTATUS
 548 NTAPI
 549 SamOpenDomain(IN SAM_HANDLE ServerHandle,
 550               IN ACCESS_MASK DesiredAccess,
 551               IN PSID DomainId,
 552               OUT PSAM_HANDLE DomainHandle)
 553 {
 554     NTSTATUS Status;
 555
 556     TRACE("SamOpenDomain(%p,0x%08x,%p,%p)\n",
 557           ServerHandle, DesiredAccess, DomainId, DomainHandle);
 558
 559     RpcTryExcept
 560     {
 561         Status = SamrOpenDomain((SAMPR_HANDLE)ServerHandle,
 562                                 DesiredAccess,
 563                                 (PRPC_SID)DomainId,
 564                                 (SAMPR_HANDLE *)DomainHandle);
 565     }
 566     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 567     {
 568         Status = I_RpcMapWin32Status(RpcExceptionCode());
 569     }
 570     RpcEndExcept;
 571
 572     return Status;
 573 }
 574
 575
 576 NTSTATUS
 577 NTAPI
 578 SamOpenGroup(IN SAM_HANDLE DomainHandle,
 579              IN ACCESS_MASK DesiredAccess,
 580              IN ULONG GroupId,
 581              OUT PSAM_HANDLE GroupHandle)
 582 {
 583     NTSTATUS Status;
 584
 585     TRACE("SamOpenGroup(%p,0x%08x,%p,%p)\n",
 586           DomainHandle, DesiredAccess, GroupId, GroupHandle);
 587
 588     RpcTryExcept
 589     {
 590         Status = SamrOpenGroup((SAMPR_HANDLE)DomainHandle,
 591                                DesiredAccess,
 592                                GroupId,
 593                                (SAMPR_HANDLE *)GroupHandle);
 594     }
 595     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 596     {
 597         Status = I_RpcMapWin32Status(RpcExceptionCode());
 598     }
 599     RpcEndExcept;
 600
 601     return Status;
 602 }
 603
 604
 605 NTSTATUS
 606 NTAPI
 607 SamOpenUser(IN SAM_HANDLE DomainHandle,
 608             IN ACCESS_MASK DesiredAccess,
 609             IN ULONG UserId,
 610             OUT PSAM_HANDLE UserHandle)
 611 {
 612     NTSTATUS Status;
 613
 614     TRACE("SamOpenUser(%p,0x%08x,%lx,%p)\n",
 615           DomainHandle, DesiredAccess, UserId, UserHandle);
 616
 617     RpcTryExcept
 618     {
 619         Status = SamrOpenUser((SAMPR_HANDLE)DomainHandle,
 620                               DesiredAccess,
 621                               UserId,
 622                               (SAMPR_HANDLE *)UserHandle);
 623     }
 624     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 625     {
 626         Status = I_RpcMapWin32Status(RpcExceptionCode());
 627     }
 628     RpcEndExcept;
 629
 630     return Status;
 631 }
 632
 633
 634 NTSTATUS
 635 NTAPI
 636 SamQueryInformationAlias(IN SAM_HANDLE AliasHandle,
 637                          IN ALIAS_INFORMATION_CLASS AliasInformationClass,
 638                          OUT PVOID *Buffer)
 639 {
 640     NTSTATUS Status;
 641
 642     TRACE("SamQueryInformationAlias(%p %lu %p)\n",
 643           AliasHandle, AliasInformationClass, Buffer);
 644
 645     RpcTryExcept
 646     {
 647         Status = SamrQueryInformationAlias((SAMPR_HANDLE)AliasHandle,
 648                                            AliasInformationClass,
 649                                            (PSAMPR_ALIAS_INFO_BUFFER *)Buffer);
 650     }
 651     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 652     {
 653         Status = I_RpcMapWin32Status(RpcExceptionCode());
 654     }
 655     RpcEndExcept;
 656
 657     return Status;
 658 }
 659
 660
 661 NTSTATUS
 662 NTAPI
 663 SamQueryInformationDomain(IN SAM_HANDLE DomainHandle,
 664                           IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
 665                           OUT PVOID *Buffer)
 666 {
 667     NTSTATUS Status;
 668
 669     TRACE("SamQueryInformationDomain(%p %lu %p)\n",
 670           DomainHandle, DomainInformationClass, Buffer);
 671
 672     RpcTryExcept
 673     {
 674         Status = SamrQueryInformationDomain((SAMPR_HANDLE)DomainHandle,
 675                                             DomainInformationClass,
 676                                             (PSAMPR_DOMAIN_INFO_BUFFER *)Buffer);
 677     }
 678     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 679     {
 680         Status = I_RpcMapWin32Status(RpcExceptionCode());
 681     }
 682     RpcEndExcept;
 683
 684     return Status;
 685 }
 686
 687
 688 NTSTATUS
 689 NTAPI
 690 SamQueryInformationGroup(IN SAM_HANDLE GroupHandle,
 691                          IN GROUP_INFORMATION_CLASS GroupInformationClass,
 692                          OUT PVOID *Buffer)
 693 {
 694     NTSTATUS Status;
 695
 696     TRACE("SamQueryInformationGroup(%p %lu %p)\n",
 697           GroupHandle, GroupInformationClass, Buffer);
 698
 699     RpcTryExcept
 700     {
 701         Status = SamrQueryInformationGroup((SAMPR_HANDLE)GroupHandle,
 702                                            GroupInformationClass,
 703                                            (PSAMPR_GROUP_INFO_BUFFER *)Buffer);
 704     }
 705     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 706     {
 707         Status = I_RpcMapWin32Status(RpcExceptionCode());
 708     }
 709     RpcEndExcept;
 710
 711     return Status;
 712 }
 713
 714
 715 NTSTATUS
 716 NTAPI
 717 SamQueryInformationUser(IN SAM_HANDLE UserHandle,
 718                         IN USER_INFORMATION_CLASS UserInformationClass,
 719                         OUT PVOID *Buffer)
 720 {
 721     NTSTATUS Status;
 722
 723     TRACE("SamQueryInformationUser(%p %lu %p)\n",
 724           UserHandle, UserInformationClass, Buffer);
 725
 726     RpcTryExcept
 727     {
 728         Status = SamrQueryInformationUser((SAMPR_HANDLE)UserHandle,
 729                                           UserInformationClass,
 730                                           (PSAMPR_USER_INFO_BUFFER *)Buffer);
 731     }
 732     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 733     {
 734         Status = I_RpcMapWin32Status(RpcExceptionCode());
 735     }
 736     RpcEndExcept;
 737
 738     return Status;
 739 }
 740
 741
 742 NTSTATUS
 743 NTAPI
 744 SamSetInformationAlias(IN SAM_HANDLE AliasHandle,
 745                        IN ALIAS_INFORMATION_CLASS AliasInformationClass,
 746                        IN PVOID Buffer)
 747 {
 748     NTSTATUS Status;
 749
 750     TRACE("SamSetInformationAlias(%p %lu %p)\n",
 751           AliasHandle, AliasInformationClass, Buffer);
 752
 753     RpcTryExcept
 754     {
 755         Status = SamrSetInformationAlias((SAMPR_HANDLE)AliasHandle,
 756                                          AliasInformationClass,
 757                                          Buffer);
 758     }
 759     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 760     {
 761         Status = I_RpcMapWin32Status(RpcExceptionCode());
 762     }
 763     RpcEndExcept;
 764
 765     return Status;
 766 }
 767
 768
 769 NTSTATUS
 770 NTAPI
 771 SamSetInformationDomain(IN SAM_HANDLE DomainHandle,
 772                         IN DOMAIN_INFORMATION_CLASS DomainInformationClass,
 773                         IN PVOID DomainInformation)
 774 {
 775     NTSTATUS Status;
 776
 777     TRACE("SamSetInformationDomain(%p %lu %p)\n",
 778           DomainHandle, DomainInformationClass, DomainInformation);
 779
 780     RpcTryExcept
 781     {
 782         Status = SamrSetInformationDomain((SAMPR_HANDLE)DomainHandle,
 783                                           DomainInformationClass,
 784                                           DomainInformation);
 785     }
 786     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 787     {
 788         Status = I_RpcMapWin32Status(RpcExceptionCode());
 789     }
 790     RpcEndExcept;
 791
 792     return Status;
 793 }
 794
 795
 796 NTSTATUS
 797 NTAPI
 798 SamSetInformationGroup(IN SAM_HANDLE GroupHandle,
 799                        IN GROUP_INFORMATION_CLASS GroupInformationClass,
 800                        IN PVOID Buffer)
 801 {
 802     NTSTATUS Status;
 803
 804     TRACE("SamSetInformationGroup(%p %lu %p)\n",
 805           GroupHandle, GroupInformationClass, Buffer);
 806
 807     RpcTryExcept
 808     {
 809         Status = SamrSetInformationGroup((SAMPR_HANDLE)GroupHandle,
 810                                          GroupInformationClass,
 811                                          Buffer);
 812     }
 813     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 814     {
 815         Status = I_RpcMapWin32Status(RpcExceptionCode());
 816     }
 817     RpcEndExcept;
 818
 819     return Status;
 820 }
 821
 822
 823 NTSTATUS
 824 NTAPI
 825 SamSetInformationUser(IN SAM_HANDLE UserHandle,
 826                       IN USER_INFORMATION_CLASS UserInformationClass,
 827                       IN PVOID Buffer)
 828 {
 829     NTSTATUS Status;
 830
 831     TRACE("SamSetInformationUser(%p %lu %p)\n",
 832           UserHandle, UserInformationClass, Buffer);
 833
 834     RpcTryExcept
 835     {
 836         Status = SamrSetInformationUser((SAMPR_HANDLE)UserHandle,
 837                                         UserInformationClass,
 838                                         Buffer);
 839     }
 840     RpcExcept(EXCEPTION_EXECUTE_HANDLER)
 841     {
 842         Status = I_RpcMapWin32Status(RpcExceptionCode());
 843     }
 844     RpcEndExcept;
 845
 846     return Status;
 847 }
 848
 849
 850 NTSTATUS
 851 NTAPI
 852 SamShutdownSamServer(IN SAM_HANDLE ServerHandle)
 853 {
 854     UNIMPLEMENTED;
 855     return STATUS_NOT_IMPLEMENTED;
 856 }
 857
 858 /* EOF */