Ignore:
Timestamp:
Nov 27, 2012, 4:43:17 PM (13 years ago)
Author:
Silvan Scherrer
Message:

Samba Server: updated trunk to 3.6.0

Location:
trunk/server
Files:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source3/rpcclient/cmd_samr.c

    r414 r745  
    2626#include "rpcclient.h"
    2727#include "../libcli/auth/libcli_auth.h"
    28 #include "../librpc/gen_ndr/cli_samr.h"
    29 
    30 extern DOM_SID domain_sid;
     28#include "../librpc/gen_ndr/ndr_samr.h"
     29#include "../librpc/gen_ndr/ndr_samr_c.h"
     30#include "rpc_client/cli_samr.h"
     31#include "rpc_client/init_samr.h"
     32#include "rpc_client/init_lsa.h"
     33#include "../libcli/security/security.h"
     34
     35extern struct dom_sid domain_sid;
    3136
    3237/****************************************************************************
    … …  
    277282                                  struct policy_handle *domain_pol)
    278283{
     284        struct dcerpc_binding_handle *b = cli->binding_handle;
     285        NTSTATUS status = NT_STATUS_INVALID_PARAMETER, result;
    279286
    280287        if (StrCaseCmp(sam, "domain") == 0) {
    281                 return rpccli_samr_OpenDomain(cli, mem_ctx,
     288                status = dcerpc_samr_OpenDomain(b, mem_ctx,
    282289                                              connect_pol,
    283290                                              access_mask,
    284291                                              _domain_sid,
    285                                               domain_pol);
     292                                              domain_pol,
     293                                              &result);
    286294        } else if (StrCaseCmp(sam, "builtin") == 0) {
    287                 return rpccli_samr_OpenDomain(cli, mem_ctx,
     295                status = dcerpc_samr_OpenDomain(b, mem_ctx,
    288296                                              connect_pol,
    289297                                              access_mask,
    290298                                              CONST_DISCARD(struct dom_sid2 *, &global_sid_Builtin),
    291                                               domain_pol);
    292         }
    293 
    294         return NT_STATUS_INVALID_PARAMETER;
     299                                              domain_pol,
     300                                              &result);
     301        }
     302
     303        if (!NT_STATUS_IS_OK(status)) {
     304                return status;
     305        }
     306
     307        return result;
    295308}
    296309
    … …  
    303316{
    304317        struct policy_handle connect_pol, domain_pol, user_pol;
    305         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     318        NTSTATUS status, result;
    306319        uint32 info_level = 21;
    307320        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    308321        union samr_UserInfo *info = NULL;
    309322        uint32 user_rid = 0;
     323        struct dcerpc_binding_handle *b = cli->binding_handle;
    310324
    311325        if ((argc < 2) || (argc > 4)) {
    … …  
    323337
    324338
    325         result = rpccli_try_samr_connects(cli, mem_ctx,
     339        status = rpccli_try_samr_connects(cli, mem_ctx,
    326340                                          MAXIMUM_ALLOWED_ACCESS,
    327341                                          &connect_pol);
    328 
    329         if (!NT_STATUS_IS_OK(result))
    330                 goto done;
    331 
    332         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     342        if (!NT_STATUS_IS_OK(status)) {
     343                goto done;
     344        }
     345
     346        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    333347                                        &connect_pol,
    334348                                        MAXIMUM_ALLOWED_ACCESS,
    335349                                        &domain_sid,
    336                                         &domain_pol);
    337         if (!NT_STATUS_IS_OK(result))
    338                 goto done;
    339 
    340         result = rpccli_samr_OpenUser(cli, mem_ctx,
     350                                        &domain_pol,
     351                                        &result);
     352        if (!NT_STATUS_IS_OK(status)) {
     353                goto done;
     354        }
     355        if (!NT_STATUS_IS_OK(result)) {
     356                status = result;
     357                goto done;
     358        }
     359
     360        status = dcerpc_samr_OpenUser(b, mem_ctx,
    341361                                      &domain_pol,
    342362                                      access_mask,
    343363                                      user_rid,
    344                                       &user_pol);
    345 
     364                                      &user_pol,
     365                                      &result);
     366        if (!NT_STATUS_IS_OK(status)) {
     367                goto done;
     368        }
    346369        if (NT_STATUS_EQUAL(result, NT_STATUS_NO_SUCH_USER) &&
    347370            (user_rid == 0)) {
    … …  
    353376                init_lsa_String(&lsa_acct_name, argv[1]);
    354377
    355                 result = rpccli_samr_LookupNames(cli, mem_ctx,
     378                status = dcerpc_samr_LookupNames(b, mem_ctx,
    356379                                                 &domain_pol,
    357380                                                 1,
    358381                                                 &lsa_acct_name,
    359382                                                 &rids,
    360                                                  &types);
    361 
     383                                                 &types,
     384                                                 &result);
     385                if (!NT_STATUS_IS_OK(status)) {
     386                        goto done;
     387                }
    362388                if (NT_STATUS_IS_OK(result)) {
    363                         result = rpccli_samr_OpenUser(cli, mem_ctx,
     389                        status = dcerpc_samr_OpenUser(b, mem_ctx,
    364390                                                      &domain_pol,
    365391                                                      access_mask,
    366392                                                      rids.ids[0],
    367                                                       &user_pol);
    368                 }
    369         }
    370 
    371 
    372         if (!NT_STATUS_IS_OK(result))
    373                 goto done;
    374 
    375         result = rpccli_samr_QueryUserInfo(cli, mem_ctx,
     393                                                      &user_pol,
     394                                                      &result);
     395                        if (!NT_STATUS_IS_OK(status)) {
     396                                goto done;
     397                        }
     398                }
     399        }
     400
     401
     402        if (!NT_STATUS_IS_OK(result)) {
     403                status = result;
     404                goto done;
     405        }
     406
     407        status = dcerpc_samr_QueryUserInfo(b, mem_ctx,
    376408                                           &user_pol,
    377409                                           info_level,
    378                                            &info);
    379 
    380         if (!NT_STATUS_IS_OK(result))
    381                 goto done;
     410                                           &info,
     411                                           &result);
     412        if (!NT_STATUS_IS_OK(status)) {
     413                goto done;
     414        }
     415        if (!NT_STATUS_IS_OK(result)) {
     416                status = result;
     417                goto done;
     418        }
    382419
    383420        switch (info_level) {
    … …  
    402439        }
    403440
    404         rpccli_samr_Close(cli, mem_ctx, &user_pol);
    405         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    406         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     441        dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
     442        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     443        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    407444
    408445done:
    409         return result;
     446        return status;
    410447}
    411448
    … …  
    491528{
    492529        struct policy_handle connect_pol, domain_pol, group_pol;
    493         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     530        NTSTATUS status, result;
    494531        enum samr_GroupInfoEnum info_level = GROUPINFOALL;
    495532        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    496533        union samr_GroupInfo *group_info = NULL;
    497534        uint32 group_rid;
     535        struct dcerpc_binding_handle *b = cli->binding_handle;
    498536
    499537        if ((argc < 2) || (argc > 4)) {
    … …  
    510548                sscanf(argv[3], "%x", &access_mask);
    511549
    512         result = rpccli_try_samr_connects(cli, mem_ctx,
     550        status = rpccli_try_samr_connects(cli, mem_ctx,
    513551                                          MAXIMUM_ALLOWED_ACCESS,
    514552                                          &connect_pol);
    515 
    516         if (!NT_STATUS_IS_OK(result))
    517                 goto done;
    518 
    519         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     553        if (!NT_STATUS_IS_OK(status)) {
     554                goto done;
     555        }
     556
     557        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    520558                                        &connect_pol,
    521559                                        MAXIMUM_ALLOWED_ACCESS,
    522560                                        &domain_sid,
    523                                         &domain_pol);
    524 
    525         if (!NT_STATUS_IS_OK(result))
    526                 goto done;
    527 
    528         result = rpccli_samr_OpenGroup(cli, mem_ctx,
     561                                        &domain_pol,
     562                                        &result);
     563        if (!NT_STATUS_IS_OK(status)) {
     564                goto done;
     565        }
     566        if (!NT_STATUS_IS_OK(result)) {
     567                status = result;
     568                goto done;
     569        }
     570
     571        status = dcerpc_samr_OpenGroup(b, mem_ctx,
    529572                                       &domain_pol,
    530573                                       access_mask,
    531574                                       group_rid,
    532                                        &group_pol);
    533 
    534         if (!NT_STATUS_IS_OK(result))
    535                 goto done;
    536 
    537         result = rpccli_samr_QueryGroupInfo(cli, mem_ctx,
     575                                       &group_pol,
     576                                       &result);
     577        if (!NT_STATUS_IS_OK(status)) {
     578                goto done;
     579        }
     580        if (!NT_STATUS_IS_OK(result)) {
     581                status = result;
     582                goto done;
     583        }
     584
     585        status = dcerpc_samr_QueryGroupInfo(b, mem_ctx,
    538586                                            &group_pol,
    539587                                            info_level,
    540                                             &group_info);
    541         if (!NT_STATUS_IS_OK(result)) {
     588                                            &group_info,
     589                                            &result);
     590        if (!NT_STATUS_IS_OK(status)) {
     591                goto done;
     592        }
     593        if (!NT_STATUS_IS_OK(result)) {
     594                status = result;
    542595                goto done;
    543596        }
    … …  
    545598        display_group_info(group_info, info_level);
    546599
    547         rpccli_samr_Close(cli, mem_ctx, &group_pol);
    548         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    549         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     600        dcerpc_samr_Close(b, mem_ctx, &group_pol, &result);
     601        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     602        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    550603done:
    551         return result;
     604        return status;
    552605}
    553606
    … …  
    561614                                domain_pol,
    562615                                user_pol;
    563         NTSTATUS                result = NT_STATUS_UNSUCCESSFUL;
     616        NTSTATUS status, result;
    564617        uint32                  user_rid;
    565618        uint32                  access_mask = MAXIMUM_ALLOWED_ACCESS;
    566619        int                     i;
    567620        struct samr_RidWithAttributeArray *rid_array = NULL;
     621        struct dcerpc_binding_handle *b = cli->binding_handle;
    568622
    569623        if ((argc < 2) || (argc > 3)) {
    … …  
    577631                sscanf(argv[2], "%x", &access_mask);
    578632
    579         result = rpccli_try_samr_connects(cli, mem_ctx,
     633        status = rpccli_try_samr_connects(cli, mem_ctx,
    580634                                          MAXIMUM_ALLOWED_ACCESS,
    581635                                          &connect_pol);
    582 
    583         if (!NT_STATUS_IS_OK(result))
    584                 goto done;
    585 
    586         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     636        if (!NT_STATUS_IS_OK(status)) {
     637                goto done;
     638        }
     639
     640        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    587641                                        &connect_pol,
    588642                                        MAXIMUM_ALLOWED_ACCESS,
    589                                         &domain_sid, &domain_pol);
    590 
    591         if (!NT_STATUS_IS_OK(result))
    592                 goto done;
    593 
    594         result = rpccli_samr_OpenUser(cli, mem_ctx,
     643                                        &domain_sid,
     644                                        &domain_pol,
     645                                        &result);
     646        if (!NT_STATUS_IS_OK(status)) {
     647                goto done;
     648        }
     649        if (!NT_STATUS_IS_OK(result)) {
     650                status = result;
     651                goto done;
     652        }
     653
     654        status = dcerpc_samr_OpenUser(b, mem_ctx,
    595655                                      &domain_pol,
    596656                                      access_mask,
    597657                                      user_rid,
    598                                       &user_pol);
    599 
    600         if (!NT_STATUS_IS_OK(result))
    601                 goto done;
    602 
    603         result = rpccli_samr_GetGroupsForUser(cli, mem_ctx,
     658                                      &user_pol,
     659                                      &result);
     660
     661        if (!NT_STATUS_IS_OK(status)) {
     662                goto done;
     663        }
     664        if (!NT_STATUS_IS_OK(result)) {
     665                status = result;
     666                goto done;
     667        }
     668
     669        status = dcerpc_samr_GetGroupsForUser(b, mem_ctx,
    604670                                              &user_pol,
    605                                               &rid_array);
    606 
    607         if (!NT_STATUS_IS_OK(result))
    608                 goto done;
     671                                              &rid_array,
     672                                              &result);
     673        if (!NT_STATUS_IS_OK(status)) {
     674                goto done;
     675        }
     676        if (!NT_STATUS_IS_OK(result)) {
     677                status = result;
     678                goto done;
     679        }
    609680
    610681        for (i = 0; i < rid_array->count; i++) {
    … …  
    614685        }
    615686
    616         rpccli_samr_Close(cli, mem_ctx, &user_pol);
    617         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    618         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     687        dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
     688        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     689        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    619690 done:
    620         return result;
     691        return status;
    621692}
    622693
    … …  
    628699{
    629700        struct policy_handle            connect_pol, domain_pol;
    630         NTSTATUS                result = NT_STATUS_UNSUCCESSFUL;
    631         DOM_SID                *sids;
    632         size_t                     num_sids;
     701        NTSTATUS status, result;
     702        struct dom_sid                *sids;
     703        uint32_t                     num_sids;
    633704        uint32                  access_mask = MAXIMUM_ALLOWED_ACCESS;
    634705        int                     i;
    635706        struct lsa_SidArray sid_array;
    636707        struct samr_Ids alias_rids;
     708        struct dcerpc_binding_handle *b = cli->binding_handle;
    637709
    638710        if (argc < 3) {
    … …  
    645717
    646718        for (i=2; i<argc; i++) {
    647                 DOM_SID tmp_sid;
     719                struct dom_sid tmp_sid;
    648720                if (!string_to_sid(&tmp_sid, argv[i])) {
    649721                        printf("%s is not a legal SID\n", argv[i]);
    … …  
    665737
    666738        for (i=0; i<num_sids; i++) {
    667                 sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sids[i]);
     739                sid_array.sids[i].sid = dom_sid_dup(mem_ctx, &sids[i]);
    668740                if (!sid_array.sids[i].sid) {
    669741                        return NT_STATUS_NO_MEMORY;
    … …  
    673745        sid_array.num_sids = num_sids;
    674746
    675         result = rpccli_try_samr_connects(cli, mem_ctx,
     747        status = rpccli_try_samr_connects(cli, mem_ctx,
    676748                                          MAXIMUM_ALLOWED_ACCESS,
    677749                                          &connect_pol);
    678 
    679         if (!NT_STATUS_IS_OK(result))
    680                 goto done;
    681 
    682         result = get_domain_handle(cli, mem_ctx, argv[1],
     750        if (!NT_STATUS_IS_OK(status)) {
     751                goto done;
     752        }
     753
     754        status = get_domain_handle(cli, mem_ctx, argv[1],
    683755                                   &connect_pol,
    684756                                   access_mask,
    685757                                   &domain_sid,
    686758                                   &domain_pol);
    687 
    688         if (!NT_STATUS_IS_OK(result))
    689                 goto done;
    690 
    691         result = rpccli_samr_GetAliasMembership(cli, mem_ctx,
     759        if (!NT_STATUS_IS_OK(status)) {
     760                goto done;
     761        }
     762
     763        status = dcerpc_samr_GetAliasMembership(b, mem_ctx,
    692764                                                &domain_pol,
    693765                                                &sid_array,
    694                                                 &alias_rids);
    695         if (!NT_STATUS_IS_OK(result))
    696                 goto done;
     766                                                &alias_rids,
     767                                                &result);
     768        if (!NT_STATUS_IS_OK(status)) {
     769                goto done;
     770        }
     771        if (!NT_STATUS_IS_OK(result)) {
     772                status = result;
     773                goto done;
     774        }
    697775
    698776        for (i = 0; i < alias_rids.count; i++) {
    … …  
    700778        }
    701779
    702         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    703         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     780        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     781        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    704782 done:
    705         return result;
     783        return status;
    706784}
    707785
    … …  
    713791{
    714792        struct policy_handle connect_pol, domain_pol, group_pol;
    715         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     793        NTSTATUS status, result;
    716794        uint32 group_rid;
    717795        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    718796        int i;
    719797        unsigned int old_timeout;
    720         struct samr_RidTypeArray *rids = NULL;
     798        struct samr_RidAttrArray *rids = NULL;
     799        struct dcerpc_binding_handle *b = cli->binding_handle;
    721800
    722801        if ((argc < 2) || (argc > 3)) {
    … …  
    730809                sscanf(argv[2], "%x", &access_mask);
    731810
    732         result = rpccli_try_samr_connects(cli, mem_ctx,
     811        status = rpccli_try_samr_connects(cli, mem_ctx,
    733812                                          MAXIMUM_ALLOWED_ACCESS,
    734813                                          &connect_pol);
    735 
    736         if (!NT_STATUS_IS_OK(result))
    737                 goto done;
    738 
    739         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     814        if (!NT_STATUS_IS_OK(status)) {
     815                goto done;
     816        }
     817
     818        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    740819                                        &connect_pol,
    741820                                        MAXIMUM_ALLOWED_ACCESS,
    742821                                        &domain_sid,
    743                                         &domain_pol);
    744 
    745         if (!NT_STATUS_IS_OK(result))
    746                 goto done;
    747 
    748         result = rpccli_samr_OpenGroup(cli, mem_ctx,
     822                                        &domain_pol,
     823                                        &result);
     824        if (!NT_STATUS_IS_OK(status)) {
     825                goto done;
     826        }
     827        if (!NT_STATUS_IS_OK(result)) {
     828                status = result;
     829                goto done;
     830        }
     831
     832        status = dcerpc_samr_OpenGroup(b, mem_ctx,
    749833                                       &domain_pol,
    750834                                       access_mask,
    751835                                       group_rid,
    752                                        &group_pol);
    753 
    754         if (!NT_STATUS_IS_OK(result))
    755                 goto done;
     836                                       &group_pol,
     837                                       &result);
     838        if (!NT_STATUS_IS_OK(status)) {
     839                goto done;
     840        }
     841        if (!NT_STATUS_IS_OK(result)) {
     842                status = result;
     843                goto done;
     844        }
    756845
    757846        /* Make sure to wait for our DC's reply */
    … …  
    759848        rpccli_set_timeout(cli, MAX(30000, old_timeout)); /* At least 30 sec */
    760849
    761         result = rpccli_samr_QueryGroupMember(cli, mem_ctx,
     850        status = dcerpc_samr_QueryGroupMember(b, mem_ctx,
    762851                                              &group_pol,
    763                                               &rids);
     852                                              &rids,
     853                                              &result);
    764854
    765855        rpccli_set_timeout(cli, old_timeout);
    766856
    767         if (!NT_STATUS_IS_OK(result))
    768                 goto done;
     857        if (!NT_STATUS_IS_OK(status)) {
     858                goto done;
     859        }
     860        if (!NT_STATUS_IS_OK(result)) {
     861                status = result;
     862                goto done;
     863        }
    769864
    770865        for (i = 0; i < rids->count; i++) {
    771866                printf("\trid:[0x%x] attr:[0x%x]\n", rids->rids[i],
    772                        rids->types[i]);
    773         }
    774 
    775         rpccli_samr_Close(cli, mem_ctx, &group_pol);
    776         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    777         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     867                       rids->attributes[i]);
     868        }
     869
     870        dcerpc_samr_Close(b, mem_ctx, &group_pol, &result);
     871        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     872        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    778873 done:
    779         return result;
     874        return status;
    780875}
    781876
    … …  
    787882{
    788883        struct policy_handle connect_pol, domain_pol;
    789         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     884        NTSTATUS status, result;
    790885        uint32 start_idx, num_dom_users, i;
    791886        struct samr_SamArray *dom_users = NULL;
    … …  
    793888        uint32 acb_mask = ACB_NORMAL;
    794889        uint32_t size = 0xffff;
     890        struct dcerpc_binding_handle *b = cli->binding_handle;
    795891
    796892        if ((argc < 1) || (argc > 4)) {
    … …  
    813909        /* Get sam policy handle */
    814910
    815         result = rpccli_try_samr_connects(cli, mem_ctx,
     911        status = rpccli_try_samr_connects(cli, mem_ctx,
    816912                                          MAXIMUM_ALLOWED_ACCESS,
    817913                                          &connect_pol);
    818 
    819         if (!NT_STATUS_IS_OK(result))
    820                 goto done;
     914        if (!NT_STATUS_IS_OK(status)) {
     915                goto done;
     916        }
    821917
    822918        /* Get domain policy handle */
    823919
    824         result = get_domain_handle(cli, mem_ctx, "domain",
     920        status = get_domain_handle(cli, mem_ctx, "domain",
    825921                                   &connect_pol,
    826922                                   access_mask,
    827923                                   &domain_sid,
    828924                                   &domain_pol);
    829         if (!NT_STATUS_IS_OK(result))
    830                 goto done;
     925        if (!NT_STATUS_IS_OK(status)) {
     926                goto done;
     927        }
    831928
    832929        /* Enumerate domain users */
    … …  
    835932
    836933        do {
    837                 result = rpccli_samr_EnumDomainUsers(cli, mem_ctx,
     934                status = dcerpc_samr_EnumDomainUsers(b, mem_ctx,
    838935                                                     &domain_pol,
    839936                                                     &start_idx,
    … …  
    841938                                                     &dom_users,
    842939                                                     size,
    843                                                      &num_dom_users);
    844 
     940                                                     &num_dom_users,
     941                                                     &result);
     942                if (!NT_STATUS_IS_OK(status)) {
     943                        goto done;
     944                }
    845945                if (NT_STATUS_IS_OK(result) ||
    846946                    NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
    … …  
    856956 done:
    857957        if (is_valid_policy_hnd(&domain_pol))
    858                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
     958                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
    859959
    860960        if (is_valid_policy_hnd(&connect_pol))
    861                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    862 
    863         return result;
     961                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     962
     963        return status;
    864964}
    865965
    … …  
    871971{
    872972        struct policy_handle connect_pol, domain_pol;
    873         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     973        NTSTATUS status, result;
    874974        uint32 start_idx, num_dom_groups, i;
    875975        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    876976        struct samr_SamArray *dom_groups = NULL;
    877977        uint32_t size = 0xffff;
     978        struct dcerpc_binding_handle *b = cli->binding_handle;
    878979
    879980        if ((argc < 1) || (argc > 3)) {
    … …  
    892993        /* Get sam policy handle */
    893994
    894         result = rpccli_try_samr_connects(cli, mem_ctx,
     995        status = rpccli_try_samr_connects(cli, mem_ctx,
    895996                                          MAXIMUM_ALLOWED_ACCESS,
    896997                                          &connect_pol);
    897 
    898         if (!NT_STATUS_IS_OK(result))
    899                 goto done;
     998        if (!NT_STATUS_IS_OK(status)) {
     999                goto done;
     1000        }
    9001001
    9011002        /* Get domain policy handle */
    9021003
    903         result = get_domain_handle(cli, mem_ctx, "domain",
     1004        status = get_domain_handle(cli, mem_ctx, "domain",
    9041005                                   &connect_pol,
    9051006                                   access_mask,
    9061007                                   &domain_sid,
    9071008                                   &domain_pol);
    908         if (!NT_STATUS_IS_OK(result))
    909                 goto done;
     1009        if (!NT_STATUS_IS_OK(status)) {
     1010                goto done;
     1011        }
    9101012
    9111013        /* Enumerate domain groups */
    … …  
    9141016
    9151017        do {
    916                 result = rpccli_samr_EnumDomainGroups(cli, mem_ctx,
     1018                status = dcerpc_samr_EnumDomainGroups(b, mem_ctx,
    9171019                                                      &domain_pol,
    9181020                                                      &start_idx,
    9191021                                                      &dom_groups,
    9201022                                                      size,
    921                                                       &num_dom_groups);
     1023                                                      &num_dom_groups,
     1024                                                      &result);
     1025                if (!NT_STATUS_IS_OK(status)) {
     1026                        goto done;
     1027                }
    9221028                if (NT_STATUS_IS_OK(result) ||
    9231029                    NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
    … …  
    9331039 done:
    9341040        if (is_valid_policy_hnd(&domain_pol))
    935                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
     1041                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
    9361042
    9371043        if (is_valid_policy_hnd(&connect_pol))
    938                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    939 
    940         return result;
     1044                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     1045
     1046        return status;
    9411047}
    9421048
    … …  
    9481054{
    9491055        struct policy_handle connect_pol, domain_pol;
    950         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1056        NTSTATUS status, result;
    9511057        uint32 start_idx, num_als_groups, i;
    9521058        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    9531059        struct samr_SamArray *als_groups = NULL;
    9541060        uint32_t size = 0xffff;
     1061        struct dcerpc_binding_handle *b = cli->binding_handle;
    9551062
    9561063        if ((argc < 2) || (argc > 4)) {
    … …  
    9691076        /* Get sam policy handle */
    9701077
    971         result = rpccli_try_samr_connects(cli, mem_ctx,
     1078        status = rpccli_try_samr_connects(cli, mem_ctx,
    9721079                                          MAXIMUM_ALLOWED_ACCESS,
    9731080                                          &connect_pol);
    974 
    975         if (!NT_STATUS_IS_OK(result))
    976                 goto done;
     1081        if (!NT_STATUS_IS_OK(status)) {
     1082                goto done;
     1083        }
    9771084
    9781085        /* Get domain policy handle */
    9791086
    980         result = get_domain_handle(cli, mem_ctx, argv[1],
     1087        status = get_domain_handle(cli, mem_ctx, argv[1],
    9811088                                   &connect_pol,
    9821089                                   access_mask,
    9831090                                   &domain_sid,
    9841091                                   &domain_pol);
    985 
    986         if (!NT_STATUS_IS_OK(result))
    987                 goto done;
     1092        if (!NT_STATUS_IS_OK(status)) {
     1093                goto done;
     1094        }
    9881095
    9891096        /* Enumerate alias groups */
    … …  
    9921099
    9931100        do {
    994                 result = rpccli_samr_EnumDomainAliases(cli, mem_ctx,
     1101                status = dcerpc_samr_EnumDomainAliases(b, mem_ctx,
    9951102                                                       &domain_pol,
    9961103                                                       &start_idx,
    9971104                                                       &als_groups,
    9981105                                                       size,
    999                                                        &num_als_groups);
    1000 
     1106                                                       &num_als_groups,
     1107                                                       &result);
     1108                if (!NT_STATUS_IS_OK(status)) {
     1109                        goto done;
     1110                }
    10011111                if (NT_STATUS_IS_OK(result) ||
    10021112                    NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
    … …  
    10111121 done:
    10121122        if (is_valid_policy_hnd(&domain_pol))
    1013                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
     1123                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
    10141124
    10151125        if (is_valid_policy_hnd(&connect_pol))
    1016                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1017 
    1018         return result;
     1126                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     1127
     1128        return status;
    10191129}
    10201130
    … …  
    10261136{
    10271137        struct policy_handle connect_pol;
    1028         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1138        NTSTATUS status, result;
    10291139        uint32 start_idx, size, num_entries, i;
    10301140        uint32 access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
    10311141        struct samr_SamArray *sam = NULL;
     1142        struct dcerpc_binding_handle *b = cli->binding_handle;
    10321143
    10331144        if ((argc < 1) || (argc > 2)) {
    … …  
    10421153        /* Get sam policy handle */
    10431154
    1044         result = rpccli_try_samr_connects(cli, mem_ctx,
     1155        status = rpccli_try_samr_connects(cli, mem_ctx,
    10451156                                          access_mask,
    10461157                                          &connect_pol);
    1047 
    1048         if (!NT_STATUS_IS_OK(result)) {
     1158        if (!NT_STATUS_IS_OK(status)) {
    10491159                goto done;
    10501160        }
    … …  
    10561166
    10571167        do {
    1058                 result = rpccli_samr_EnumDomains(cli, mem_ctx,
     1168                status = dcerpc_samr_EnumDomains(b, mem_ctx,
    10591169                                                 &connect_pol,
    10601170                                                 &start_idx,
    10611171                                                 &sam,
    10621172                                                 size,
    1063                                                  &num_entries);
    1064 
     1173                                                 &num_entries,
     1174                                                 &result);
     1175                if (!NT_STATUS_IS_OK(status)) {
     1176                        goto done;
     1177                }
    10651178                if (NT_STATUS_IS_OK(result) ||
    10661179                    NT_STATUS_V(result) == NT_STATUS_V(STATUS_MORE_ENTRIES)) {
    … …  
    10751188 done:
    10761189        if (is_valid_policy_hnd(&connect_pol)) {
    1077                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1078         }
    1079 
    1080         return result;
     1190                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     1191        }
     1192
     1193        return status;
    10811194}
    10821195
    … …  
    10891202{
    10901203        struct policy_handle connect_pol, domain_pol, alias_pol;
    1091         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1204        NTSTATUS status, result;
    10921205        uint32 alias_rid, i;
    10931206        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    10941207        struct lsa_SidArray sid_array;
     1208        struct dcerpc_binding_handle *b = cli->binding_handle;
    10951209
    10961210        if ((argc < 3) || (argc > 4)) {
    … …  
    11061220        /* Open SAMR handle */
    11071221
    1108         result = rpccli_try_samr_connects(cli, mem_ctx,
     1222        status = rpccli_try_samr_connects(cli, mem_ctx,
    11091223                                          MAXIMUM_ALLOWED_ACCESS,
    11101224                                          &connect_pol);
    1111 
    1112         if (!NT_STATUS_IS_OK(result))
    1113                 goto done;
     1225        if (!NT_STATUS_IS_OK(status)) {
     1226                goto done;
     1227        }
    11141228
    11151229        /* Open handle on domain */
    11161230
    1117         result = get_domain_handle(cli, mem_ctx, argv[1],
     1231        status = get_domain_handle(cli, mem_ctx, argv[1],
    11181232                                   &connect_pol,
    11191233                                   MAXIMUM_ALLOWED_ACCESS,
    11201234                                   &domain_sid,
    11211235                                   &domain_pol);
    1122 
    1123         if (!NT_STATUS_IS_OK(result))
    1124                 goto done;
     1236        if (!NT_STATUS_IS_OK(status)) {
     1237                goto done;
     1238        }
    11251239
    11261240        /* Open handle on alias */
    11271241
    1128         result = rpccli_samr_OpenAlias(cli, mem_ctx,
     1242        status = dcerpc_samr_OpenAlias(b, mem_ctx,
    11291243                                       &domain_pol,
    11301244                                       access_mask,
    11311245                                       alias_rid,
    1132                                        &alias_pol);
    1133         if (!NT_STATUS_IS_OK(result))
    1134                 goto done;
    1135 
    1136         result = rpccli_samr_GetMembersInAlias(cli, mem_ctx,
     1246                                       &alias_pol,
     1247                                       &result);
     1248        if (!NT_STATUS_IS_OK(status)) {
     1249                goto done;
     1250        }
     1251        if (!NT_STATUS_IS_OK(result)) {
     1252                status = result;
     1253                goto done;
     1254        }
     1255
     1256        status = dcerpc_samr_GetMembersInAlias(b, mem_ctx,
    11371257                                               &alias_pol,
    1138                                                &sid_array);
    1139 
    1140         if (!NT_STATUS_IS_OK(result))
    1141                 goto done;
     1258                                               &sid_array,
     1259                                               &result);
     1260        if (!NT_STATUS_IS_OK(status)) {
     1261                goto done;
     1262        }
     1263        if (!NT_STATUS_IS_OK(result)) {
     1264                status = result;
     1265                goto done;
     1266        }
    11421267
    11431268        for (i = 0; i < sid_array.num_sids; i++) {
    … …  
    11481273        }
    11491274
    1150         rpccli_samr_Close(cli, mem_ctx, &alias_pol);
    1151         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1152         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     1275        dcerpc_samr_Close(b, mem_ctx, &alias_pol, &result);
     1276        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     1277        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    11531278 done:
    1154         return result;
     1279        return status;
    11551280}
    11561281
    … …  
    11621287{
    11631288        struct policy_handle connect_pol, domain_pol, alias_pol;
    1164         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1289        NTSTATUS status, result;
    11651290        uint32_t alias_rid;
    11661291        uint32_t access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
    11671292        union samr_AliasInfo *info = NULL;
    11681293        enum samr_AliasInfoEnum level = ALIASINFOALL;
     1294        struct dcerpc_binding_handle *b = cli->binding_handle;
    11691295
    11701296        if ((argc < 3) || (argc > 4)) {
    … …  
    11861312        /* Open SAMR handle */
    11871313
    1188         result = rpccli_try_samr_connects(cli, mem_ctx,
     1314        status = rpccli_try_samr_connects(cli, mem_ctx,
    11891315                                          SEC_FLAG_MAXIMUM_ALLOWED,
    11901316                                          &connect_pol);
    1191 
    1192         if (!NT_STATUS_IS_OK(result)) {
     1317        if (!NT_STATUS_IS_OK(status)) {
    11931318                goto done;
    11941319        }
    … …  
    11961321        /* Open handle on domain */
    11971322
    1198         result = get_domain_handle(cli, mem_ctx, argv[1],
     1323        status = get_domain_handle(cli, mem_ctx, argv[1],
    11991324                                   &connect_pol,
    12001325                                   SEC_FLAG_MAXIMUM_ALLOWED,
    12011326                                   &domain_sid,
    12021327                                   &domain_pol);
    1203 
    1204         if (!NT_STATUS_IS_OK(result)) {
     1328        if (!NT_STATUS_IS_OK(status)) {
    12051329                goto done;
    12061330        }
    … …  
    12081332        /* Open handle on alias */
    12091333
    1210         result = rpccli_samr_OpenAlias(cli, mem_ctx,
     1334        status = dcerpc_samr_OpenAlias(b, mem_ctx,
    12111335                                       &domain_pol,
    12121336                                       access_mask,
    12131337                                       alias_rid,
    1214                                        &alias_pol);
    1215         if (!NT_STATUS_IS_OK(result)) {
    1216                 goto done;
    1217         }
    1218 
    1219         result = rpccli_samr_QueryAliasInfo(cli, mem_ctx,
     1338                                       &alias_pol,
     1339                                       &result);
     1340        if (!NT_STATUS_IS_OK(status)) {
     1341                goto done;
     1342        }
     1343        if (!NT_STATUS_IS_OK(result)) {
     1344                status = result;
     1345                goto done;
     1346        }
     1347
     1348        status = dcerpc_samr_QueryAliasInfo(b, mem_ctx,
    12201349                                            &alias_pol,
    12211350                                            level,
    1222                                             &info);
    1223 
    1224         if (!NT_STATUS_IS_OK(result)) {
     1351                                            &info,
     1352                                            &result);
     1353        if (!NT_STATUS_IS_OK(status)) {
     1354                goto done;
     1355        }
     1356        if (!NT_STATUS_IS_OK(result)) {
     1357                status = result;
    12251358                goto done;
    12261359        }
    … …  
    12421375        }
    12431376
    1244         rpccli_samr_Close(cli, mem_ctx, &alias_pol);
    1245         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1246         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     1377        dcerpc_samr_Close(b, mem_ctx, &alias_pol, &result);
     1378        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     1379        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    12471380 done:
    1248         return result;
     1381        return status;
    12491382}
    12501383
    … …  
    12571390{
    12581391        struct policy_handle connect_pol, domain_pol, alias_pol;
    1259         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1392        NTSTATUS status, result;
    12601393        uint32 alias_rid;
    12611394        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
     1395        struct dcerpc_binding_handle *b = cli->binding_handle;
    12621396
    12631397        if (argc != 3) {
    … …  
    12701404        /* Open SAMR handle */
    12711405
    1272         result = rpccli_try_samr_connects(cli, mem_ctx,
     1406        status = rpccli_try_samr_connects(cli, mem_ctx,
    12731407                                          MAXIMUM_ALLOWED_ACCESS,
    12741408                                          &connect_pol);
    1275 
    1276         if (!NT_STATUS_IS_OK(result))
    1277                 goto done;
     1409        if (!NT_STATUS_IS_OK(status)) {
     1410                goto done;
     1411        }
    12781412
    12791413        /* Open handle on domain */
    12801414
    1281         result = get_domain_handle(cli, mem_ctx, argv[1],
     1415        status = get_domain_handle(cli, mem_ctx, argv[1],
    12821416                                   &connect_pol,
    12831417                                   MAXIMUM_ALLOWED_ACCESS,
    12841418                                   &domain_sid,
    12851419                                   &domain_pol);
    1286 
    1287         if (!NT_STATUS_IS_OK(result))
    1288                 goto done;
     1420        if (!NT_STATUS_IS_OK(status)) {
     1421                goto done;
     1422        }
    12891423
    12901424        /* Open handle on alias */
    12911425
    1292         result = rpccli_samr_OpenAlias(cli, mem_ctx,
     1426        status = dcerpc_samr_OpenAlias(b, mem_ctx,
    12931427                                       &domain_pol,
    12941428                                       access_mask,
    12951429                                       alias_rid,
    1296                                        &alias_pol);
     1430                                       &alias_pol,
     1431                                       &result);
     1432        if (!NT_STATUS_IS_OK(status)) {
     1433                goto done;
     1434        }
    12971435        if (!NT_STATUS_IS_OK(result) && (alias_rid == 0)) {
    12981436                /* Probably this was a user name, try lookupnames */
    … …  
    13021440                init_lsa_String(&lsa_acct_name, argv[2]);
    13031441
    1304                 result = rpccli_samr_LookupNames(cli, mem_ctx,
     1442                status = dcerpc_samr_LookupNames(b, mem_ctx,
    13051443                                                 &domain_pol,
    13061444                                                 1,
    13071445                                                 &lsa_acct_name,
    13081446                                                 &rids,
    1309                                                  &types);
    1310 
     1447                                                 &types,
     1448                                                 &result);
     1449                if (!NT_STATUS_IS_OK(status)) {
     1450                        goto done;
     1451                }
    13111452                if (NT_STATUS_IS_OK(result)) {
    1312                         result = rpccli_samr_OpenAlias(cli, mem_ctx,
     1453                        status = dcerpc_samr_OpenAlias(b, mem_ctx,
    13131454                                                       &domain_pol,
    13141455                                                       access_mask,
    13151456                                                       rids.ids[0],
    1316                                                        &alias_pol);
    1317                 }
    1318         }
    1319 
    1320         result = rpccli_samr_DeleteDomAlias(cli, mem_ctx,
    1321                                             &alias_pol);
    1322 
    1323         if (!NT_STATUS_IS_OK(result))
    1324                 goto done;
    1325 
    1326         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1327         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     1457                                                       &alias_pol,
     1458                                                       &result);
     1459                        if (!NT_STATUS_IS_OK(status)) {
     1460                                goto done;
     1461                        }
     1462                }
     1463        }
     1464
     1465        status = dcerpc_samr_DeleteDomAlias(b, mem_ctx,
     1466                                            &alias_pol,
     1467                                            &result);
     1468        if (!NT_STATUS_IS_OK(status)) {
     1469                goto done;
     1470        }
     1471        if (!NT_STATUS_IS_OK(result)) {
     1472                status = result;
     1473                goto done;
     1474        }
     1475
     1476        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     1477        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    13281478 done:
    1329         return result;
     1479        return status;
    13301480}
    13311481
    … …  
    13381488{
    13391489        struct policy_handle connect_pol, domain_pol;
    1340         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1490        NTSTATUS status, result;
    13411491        uint32 start_idx=0, max_entries=250, max_size = 0xffff, num_entries = 0, i;
    13421492        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    … …  
    13461496        bool got_params = False; /* Use get_query_dispinfo_params() or not? */
    13471497        uint32_t total_size, returned_size;
     1498        struct dcerpc_binding_handle *b = cli->binding_handle;
    13481499
    13491500        if (argc > 6) {
    … …  
    13731524        /* Get sam policy handle */
    13741525
    1375         result = rpccli_try_samr_connects(cli, mem_ctx,
     1526        status = rpccli_try_samr_connects(cli, mem_ctx,
    13761527                                          MAXIMUM_ALLOWED_ACCESS,
    13771528                                          &connect_pol);
    1378 
    1379         if (!NT_STATUS_IS_OK(result))
    1380                 goto done;
     1529        if (!NT_STATUS_IS_OK(status)) {
     1530                goto done;
     1531        }
    13811532
    13821533        /* Get domain policy handle */
    13831534
    1384         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     1535        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    13851536                                        &connect_pol,
    13861537                                        access_mask,
    13871538                                        &domain_sid,
    1388                                         &domain_pol);
    1389 
    1390         if (!NT_STATUS_IS_OK(result))
    1391                 goto done;
     1539                                        &domain_pol,
     1540                                        &result);
     1541        if (!NT_STATUS_IS_OK(status)) {
     1542                goto done;
     1543        }
     1544        if (!NT_STATUS_IS_OK(result)) {
     1545                status = result;
     1546                goto done;
     1547        }
    13921548
    13931549        /* Query display info */
    … …  
    13961552
    13971553                if (!got_params)
    1398                         get_query_dispinfo_params(
     1554                        dcerpc_get_query_dispinfo_params(
    13991555                                loop_count, &max_entries, &max_size);
    14001556
    14011557                switch (opcode) {
    14021558                case NDR_SAMR_QUERYDISPLAYINFO:
    1403                         result = rpccli_samr_QueryDisplayInfo(cli, mem_ctx,
     1559                        status = dcerpc_samr_QueryDisplayInfo(b, mem_ctx,
    14041560                                                              &domain_pol,
    14051561                                                              info_level,
    … …  
    14091565                                                              &total_size,
    14101566                                                              &returned_size,
    1411                                                               &info);
     1567                                                              &info,
     1568                                                              &result);
    14121569                        break;
    14131570                case NDR_SAMR_QUERYDISPLAYINFO2:
    1414                         result = rpccli_samr_QueryDisplayInfo2(cli, mem_ctx,
     1571                        status = dcerpc_samr_QueryDisplayInfo2(b, mem_ctx,
    14151572                                                               &domain_pol,
    14161573                                                               info_level,
    … …  
    14201577                                                               &total_size,
    14211578                                                               &returned_size,
    1422                                                                &info);
     1579                                                               &info,
     1580                                                               &result);
    14231581
    14241582                        break;
    14251583                case NDR_SAMR_QUERYDISPLAYINFO3:
    1426                         result = rpccli_samr_QueryDisplayInfo3(cli, mem_ctx,
     1584                        status = dcerpc_samr_QueryDisplayInfo3(b, mem_ctx,
    14271585                                                               &domain_pol,
    14281586                                                               info_level,
    … …  
    14321590                                                               &total_size,
    14331591                                                               &returned_size,
    1434                                                                &info);
     1592                                                               &info,
     1593                                                               &result);
    14351594
    14361595                        break;
    … …  
    14391598                }
    14401599
     1600                if (!NT_STATUS_IS_OK(status)) {
     1601                        break;
     1602                }
     1603                status = result;
    14411604                if (!NT_STATUS_IS_OK(result) &&
    14421605                    !NT_STATUS_EQUAL(result, NT_STATUS_NO_MORE_ENTRIES) &&
    … …  
    14931656        } while ( NT_STATUS_EQUAL(result, STATUS_MORE_ENTRIES));
    14941657
    1495         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1496         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     1658        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     1659        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    14971660 done:
    1498         return result;
     1661        return status;
    14991662}
    15001663
    … …  
    15301693{
    15311694        struct policy_handle connect_pol, domain_pol;
    1532         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1695        NTSTATUS status, result;
    15331696        uint32 switch_level = 2;
    15341697        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    15351698        union samr_DomainInfo *info = NULL;
     1699        struct dcerpc_binding_handle *b = cli->binding_handle;
    15361700
    15371701        if (argc > 3) {
    … …  
    15481712        /* Get sam policy handle */
    15491713
    1550         result = rpccli_try_samr_connects(cli, mem_ctx,
     1714        status = rpccli_try_samr_connects(cli, mem_ctx,
    15511715                                          MAXIMUM_ALLOWED_ACCESS,
    15521716                                          &connect_pol);
    1553 
    1554         if (!NT_STATUS_IS_OK(result))
    1555                 goto done;
     1717        if (!NT_STATUS_IS_OK(status)) {
     1718                goto done;
     1719        }
    15561720
    15571721        /* Get domain policy handle */
    15581722
    1559         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     1723        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    15601724                                        &connect_pol,
    15611725                                        access_mask,
    15621726                                        &domain_sid,
    1563                                         &domain_pol);
    1564 
    1565         if (!NT_STATUS_IS_OK(result))
    1566                 goto done;
     1727                                        &domain_pol,
     1728                                        &result);
     1729        if (!NT_STATUS_IS_OK(status)) {
     1730                goto done;
     1731        }
     1732        if (!NT_STATUS_IS_OK(result)) {
     1733                status = result;
     1734                goto done;
     1735        }
    15671736
    15681737        /* Query domain info */
    15691738
    1570         result = rpccli_samr_QueryDomainInfo(cli, mem_ctx,
     1739        status = dcerpc_samr_QueryDomainInfo(b, mem_ctx,
    15711740                                             &domain_pol,
    15721741                                             switch_level,
    1573                                              &info);
    1574 
    1575         if (!NT_STATUS_IS_OK(result))
    1576                 goto done;
     1742                                             &info,
     1743                                             &result);
     1744        if (!NT_STATUS_IS_OK(status)) {
     1745                goto done;
     1746        }
     1747        if (!NT_STATUS_IS_OK(result)) {
     1748                status = result;
     1749                goto done;
     1750        }
    15771751
    15781752        /* Display domain info */
    … …  
    16211795 done:
    16221796
    1623         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1624         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1625         return result;
     1797        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     1798        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     1799        return status;
    16261800}
    16271801
    … …  
    16331807{
    16341808        struct policy_handle connect_pol, domain_pol, user_pol;
    1635         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1809        NTSTATUS status, result;
    16361810        struct lsa_String acct_name;
    16371811        uint32 acb_info;
    … …  
    16391813        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    16401814        uint32_t access_granted = 0;
     1815        struct dcerpc_binding_handle *b = cli->binding_handle;
    16411816
    16421817        if ((argc < 2) || (argc > 3)) {
    … …  
    16521827        /* Get sam policy handle */
    16531828
    1654         result = rpccli_try_samr_connects(cli, mem_ctx,
     1829        status = rpccli_try_samr_connects(cli, mem_ctx,
    16551830                                          MAXIMUM_ALLOWED_ACCESS,
    16561831                                          &connect_pol);
    1657 
    1658         if (!NT_STATUS_IS_OK(result))
    1659                 goto done;
     1832        if (!NT_STATUS_IS_OK(status)) {
     1833                goto done;
     1834        }
    16601835
    16611836        /* Get domain policy handle */
    16621837
    1663         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     1838        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    16641839                                        &connect_pol,
    16651840                                        access_mask,
    16661841                                        &domain_sid,
    1667                                         &domain_pol);
    1668 
    1669         if (!NT_STATUS_IS_OK(result))
    1670                 goto done;
     1842                                        &domain_pol,
     1843                                        &result);
     1844        if (!NT_STATUS_IS_OK(status)) {
     1845                goto done;
     1846        }
     1847        if (!NT_STATUS_IS_OK(result)) {
     1848                status = result;
     1849                goto done;
     1850        }
    16711851
    16721852        /* Create domain user */
    … …  
    16791859                     SAMR_USER_ACCESS_SET_ATTRIBUTES;
    16801860
    1681         result = rpccli_samr_CreateUser2(cli, mem_ctx,
     1861        status = dcerpc_samr_CreateUser2(b, mem_ctx,
    16821862                                         &domain_pol,
    16831863                                         &acct_name,
    … …  
    16861866                                         &user_pol,
    16871867                                         &access_granted,
    1688                                          &user_rid);
    1689 
    1690         if (!NT_STATUS_IS_OK(result))
    1691                 goto done;
    1692 
    1693         result = rpccli_samr_Close(cli, mem_ctx, &user_pol);
    1694         if (!NT_STATUS_IS_OK(result)) goto done;
    1695 
    1696         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1697         if (!NT_STATUS_IS_OK(result)) goto done;
    1698 
    1699         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1700         if (!NT_STATUS_IS_OK(result)) goto done;
     1868                                         &user_rid,
     1869                                         &result);
     1870        if (!NT_STATUS_IS_OK(status)) {
     1871                goto done;
     1872        }
     1873        if (!NT_STATUS_IS_OK(result)) {
     1874                status = result;
     1875                goto done;
     1876        }
     1877
     1878        status = dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
     1879        if (!NT_STATUS_IS_OK(status)) goto done;
     1880
     1881        status = dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     1882        if (!NT_STATUS_IS_OK(status)) goto done;
     1883
     1884        status = dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     1885        if (!NT_STATUS_IS_OK(status)) goto done;
    17011886
    17021887 done:
    1703         return result;
     1888        return status;
    17041889}
    17051890
    … …  
    17111896{
    17121897        struct policy_handle connect_pol, domain_pol, group_pol;
    1713         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1898        NTSTATUS status, result;
    17141899        struct lsa_String grp_name;
    17151900        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    17161901        uint32_t rid = 0;
     1902        struct dcerpc_binding_handle *b = cli->binding_handle;
    17171903
    17181904        if ((argc < 2) || (argc > 3)) {
    … …  
    17281914        /* Get sam policy handle */
    17291915
    1730         result = rpccli_try_samr_connects(cli, mem_ctx,
     1916        status = rpccli_try_samr_connects(cli, mem_ctx,
    17311917                                          MAXIMUM_ALLOWED_ACCESS,
    17321918                                          &connect_pol);
    1733 
    1734         if (!NT_STATUS_IS_OK(result))
    1735                 goto done;
     1919        if (!NT_STATUS_IS_OK(status)) {
     1920                goto done;
     1921        }
    17361922
    17371923        /* Get domain policy handle */
    17381924
    1739         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     1925        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    17401926                                        &connect_pol,
    17411927                                        access_mask,
    17421928                                        &domain_sid,
    1743                                         &domain_pol);
    1744 
    1745         if (!NT_STATUS_IS_OK(result))
    1746                 goto done;
     1929                                        &domain_pol,
     1930                                        &result);
     1931        if (!NT_STATUS_IS_OK(status)) {
     1932                goto done;
     1933        }
     1934        if (!NT_STATUS_IS_OK(result)) {
     1935                status = result;
     1936                goto done;
     1937        }
    17471938
    17481939        /* Create domain user */
    1749         result = rpccli_samr_CreateDomainGroup(cli, mem_ctx,
     1940        status = dcerpc_samr_CreateDomainGroup(b, mem_ctx,
    17501941                                               &domain_pol,
    17511942                                               &grp_name,
    17521943                                               MAXIMUM_ALLOWED_ACCESS,
    17531944                                               &group_pol,
    1754                                                &rid);
    1755 
    1756         if (!NT_STATUS_IS_OK(result))
    1757                 goto done;
    1758 
    1759         result = rpccli_samr_Close(cli, mem_ctx, &group_pol);
    1760         if (!NT_STATUS_IS_OK(result)) goto done;
    1761 
    1762         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1763         if (!NT_STATUS_IS_OK(result)) goto done;
    1764 
    1765         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1766         if (!NT_STATUS_IS_OK(result)) goto done;
     1945                                               &rid,
     1946                                               &result);
     1947        if (!NT_STATUS_IS_OK(status)) {
     1948                goto done;
     1949        }
     1950        if (!NT_STATUS_IS_OK(result)) {
     1951                status = result;
     1952                goto done;
     1953        }
     1954
     1955        status = dcerpc_samr_Close(b, mem_ctx, &group_pol, &result);
     1956        if (!NT_STATUS_IS_OK(status)) goto done;
     1957
     1958        status = dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     1959        if (!NT_STATUS_IS_OK(status)) goto done;
     1960
     1961        status = dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     1962        if (!NT_STATUS_IS_OK(status)) goto done;
    17671963
    17681964 done:
    1769         return result;
     1965        return status;
    17701966}
    17711967
    … …  
    17771973{
    17781974        struct policy_handle connect_pol, domain_pol, alias_pol;
    1779         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     1975        NTSTATUS status, result;
    17801976        struct lsa_String alias_name;
    17811977        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    17821978        uint32_t rid = 0;
     1979        struct dcerpc_binding_handle *b = cli->binding_handle;
    17831980
    17841981        if ((argc < 2) || (argc > 3)) {
    … …  
    17941991        /* Get sam policy handle */
    17951992
    1796         result = rpccli_try_samr_connects(cli, mem_ctx,
     1993        status = rpccli_try_samr_connects(cli, mem_ctx,
    17971994                                          MAXIMUM_ALLOWED_ACCESS,
    17981995                                          &connect_pol);
    1799 
    1800         if (!NT_STATUS_IS_OK(result))
    1801                 goto done;
     1996        if (!NT_STATUS_IS_OK(status)) {
     1997                goto done;
     1998        }
    18021999
    18032000        /* Get domain policy handle */
    18042001
    1805         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2002        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    18062003                                        &connect_pol,
    18072004                                        access_mask,
    18082005                                        &domain_sid,
    1809                                         &domain_pol);
    1810 
    1811         if (!NT_STATUS_IS_OK(result))
    1812                 goto done;
     2006                                        &domain_pol,
     2007                                        &result);
     2008        if (!NT_STATUS_IS_OK(status)) {
     2009                goto done;
     2010        }
     2011        if (!NT_STATUS_IS_OK(result)) {
     2012                status = result;
     2013                goto done;
     2014        }
    18132015
    18142016        /* Create domain user */
    18152017
    1816         result = rpccli_samr_CreateDomAlias(cli, mem_ctx,
     2018        status = dcerpc_samr_CreateDomAlias(b, mem_ctx,
    18172019                                            &domain_pol,
    18182020                                            &alias_name,
    18192021                                            MAXIMUM_ALLOWED_ACCESS,
    18202022                                            &alias_pol,
    1821                                             &rid);
    1822 
    1823         if (!NT_STATUS_IS_OK(result))
    1824                 goto done;
    1825 
    1826         result = rpccli_samr_Close(cli, mem_ctx, &alias_pol);
    1827         if (!NT_STATUS_IS_OK(result)) goto done;
    1828 
    1829         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1830         if (!NT_STATUS_IS_OK(result)) goto done;
    1831 
    1832         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1833         if (!NT_STATUS_IS_OK(result)) goto done;
     2023                                            &rid,
     2024                                            &result);
     2025        if (!NT_STATUS_IS_OK(status)) {
     2026                goto done;
     2027        }
     2028        if (!NT_STATUS_IS_OK(result)) {
     2029                status = result;
     2030                goto done;
     2031        }
     2032
     2033
     2034        status = dcerpc_samr_Close(b, mem_ctx, &alias_pol, &result);
     2035        if (!NT_STATUS_IS_OK(status)) goto done;
     2036
     2037        status = dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2038        if (!NT_STATUS_IS_OK(status)) goto done;
     2039
     2040        status = dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     2041        if (!NT_STATUS_IS_OK(status)) goto done;
    18342042
    18352043 done:
    1836         return result;
     2044        return status;
    18372045}
    18382046
    … …  
    18432051                                      int argc, const char **argv)
    18442052{
    1845         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2053        NTSTATUS status, result;
    18462054        struct policy_handle connect_pol, domain_pol;
    18472055        uint32 num_names;
    18482056        struct samr_Ids rids, name_types;
    18492057        int i;
    1850         struct lsa_String *names = NULL;;
     2058        struct lsa_String *names = NULL;
     2059        struct dcerpc_binding_handle *b = cli->binding_handle;
    18512060
    18522061        if (argc < 3) {
    … …  
    18592068        /* Get sam policy and domain handles */
    18602069
    1861         result = rpccli_try_samr_connects(cli, mem_ctx,
     2070        status = rpccli_try_samr_connects(cli, mem_ctx,
    18622071                                          MAXIMUM_ALLOWED_ACCESS,
    18632072                                          &connect_pol);
    1864 
    1865         if (!NT_STATUS_IS_OK(result))
    1866                 goto done;
    1867 
    1868         result = get_domain_handle(cli, mem_ctx, argv[1],
     2073        if (!NT_STATUS_IS_OK(status)) {
     2074                goto done;
     2075        }
     2076
     2077        status = get_domain_handle(cli, mem_ctx, argv[1],
    18692078                                   &connect_pol,
    18702079                                   MAXIMUM_ALLOWED_ACCESS,
    18712080                                   &domain_sid,
    18722081                                   &domain_pol);
    1873 
    1874         if (!NT_STATUS_IS_OK(result))
    1875                 goto done;
     2082        if (!NT_STATUS_IS_OK(status)) {
     2083                goto done;
     2084        }
    18762085
    18772086        /* Look up names */
    … …  
    18802089
    18812090        if ((names = TALLOC_ARRAY(mem_ctx, struct lsa_String, num_names)) == NULL) {
    1882                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1883                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1884                 result = NT_STATUS_NO_MEMORY;
     2091                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2092                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     2093                status = NT_STATUS_NO_MEMORY;
    18852094                goto done;
    18862095        }
    … …  
    18902099        }
    18912100
    1892         result = rpccli_samr_LookupNames(cli, mem_ctx,
     2101        status = dcerpc_samr_LookupNames(b, mem_ctx,
    18932102                                         &domain_pol,
    18942103                                         num_names,
    18952104                                         names,
    18962105                                         &rids,
    1897                                          &name_types);
    1898 
    1899         if (!NT_STATUS_IS_OK(result))
    1900                 goto done;
     2106                                         &name_types,
     2107                                         &result);
     2108        if (!NT_STATUS_IS_OK(status)) {
     2109                goto done;
     2110        }
     2111        if (!NT_STATUS_IS_OK(result)) {
     2112                status = result;
     2113                goto done;
     2114        }
    19012115
    19022116        /* Display results */
    … …  
    19062120                       name_types.ids[i]);
    19072121
    1908         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1909         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     2122        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2123        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    19102124 done:
    1911         return result;
     2125        return status;
    19122126}
    19132127
    … …  
    19182132                                     int argc, const char **argv)
    19192133{
    1920         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2134        NTSTATUS status, result;
    19212135        struct policy_handle connect_pol, domain_pol;
    19222136        uint32_t num_rids, *rids;
    19232137        struct lsa_Strings names;
    19242138        struct samr_Ids types;
     2139        struct dcerpc_binding_handle *b = cli->binding_handle;
    19252140
    19262141        int i;
    … …  
    19332148        /* Get sam policy and domain handles */
    19342149
    1935         result = rpccli_try_samr_connects(cli, mem_ctx,
     2150        status = rpccli_try_samr_connects(cli, mem_ctx,
    19362151                                          MAXIMUM_ALLOWED_ACCESS,
    19372152                                          &connect_pol);
    1938 
    1939         if (!NT_STATUS_IS_OK(result))
    1940                 goto done;
    1941 
    1942         result = get_domain_handle(cli, mem_ctx, argv[1],
     2153        if (!NT_STATUS_IS_OK(status)) {
     2154                goto done;
     2155        }
     2156
     2157        status = get_domain_handle(cli, mem_ctx, argv[1],
    19432158                                   &connect_pol,
    19442159                                   MAXIMUM_ALLOWED_ACCESS,
    19452160                                   &domain_sid,
    19462161                                   &domain_pol);
    1947 
    1948         if (!NT_STATUS_IS_OK(result))
    1949                 goto done;
     2162        if (!NT_STATUS_IS_OK(status)) {
     2163                goto done;
     2164        }
    19502165
    19512166        /* Look up rids */
    … …  
    19542169
    19552170        if ((rids = TALLOC_ARRAY(mem_ctx, uint32, num_rids)) == NULL) {
    1956                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1957                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    1958                 result = NT_STATUS_NO_MEMORY;
     2171                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2172                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     2173                status = NT_STATUS_NO_MEMORY;
    19592174                goto done;
    19602175        }
    … …  
    19632178                sscanf(argv[i + 2], "%i", &rids[i]);
    19642179
    1965         result = rpccli_samr_LookupRids(cli, mem_ctx,
     2180        status = dcerpc_samr_LookupRids(b, mem_ctx,
    19662181                                        &domain_pol,
    19672182                                        num_rids,
    19682183                                        rids,
    19692184                                        &names,
    1970                                         &types);
    1971 
     2185                                        &types,
     2186                                        &result);
     2187        if (!NT_STATUS_IS_OK(status)) {
     2188                goto done;
     2189        }
     2190        status = result;
    19722191        if (!NT_STATUS_IS_OK(result) &&
    19732192            !NT_STATUS_EQUAL(result, STATUS_SOME_UNMAPPED))
    … …  
    19812200        }
    19822201
    1983         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    1984         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     2202        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2203        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    19852204 done:
    1986         return result;
     2205        return status;
    19872206}
    19882207
    … …  
    19932212                                         int argc, const char **argv)
    19942213{
    1995         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2214        NTSTATUS status, result;
    19962215        struct policy_handle connect_pol, domain_pol, group_pol;
    19972216        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
     2217        struct dcerpc_binding_handle *b = cli->binding_handle;
    19982218
    19992219        if ((argc < 2) || (argc > 3)) {
    … …  
    20072227        /* Get sam policy and domain handles */
    20082228
    2009         result = rpccli_try_samr_connects(cli, mem_ctx,
     2229        status = rpccli_try_samr_connects(cli, mem_ctx,
    20102230                                          MAXIMUM_ALLOWED_ACCESS,
    20112231                                          &connect_pol);
    2012 
    2013         if (!NT_STATUS_IS_OK(result))
    2014                 goto done;
    2015 
    2016         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2232        if (!NT_STATUS_IS_OK(status)) {
     2233                goto done;
     2234        }
     2235
     2236        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    20172237                                        &connect_pol,
    20182238                                        MAXIMUM_ALLOWED_ACCESS,
    20192239                                        &domain_sid,
    2020                                         &domain_pol);
    2021 
    2022         if (!NT_STATUS_IS_OK(result))
    2023                 goto done;
     2240                                        &domain_pol,
     2241                                        &result);
     2242        if (!NT_STATUS_IS_OK(status)) {
     2243                goto done;
     2244        }
     2245        if (!NT_STATUS_IS_OK(result)) {
     2246                status = result;
     2247                goto done;
     2248        }
    20242249
    20252250        /* Get handle on group */
    … …  
    20312256                init_lsa_String(&lsa_acct_name, argv[1]);
    20322257
    2033                 result = rpccli_samr_LookupNames(cli, mem_ctx,
     2258                status = dcerpc_samr_LookupNames(b, mem_ctx,
    20342259                                                 &domain_pol,
    20352260                                                 1,
    20362261                                                 &lsa_acct_name,
    20372262                                                 &group_rids,
    2038                                                  &name_types);
    2039                 if (!NT_STATUS_IS_OK(result))
     2263                                                 &name_types,
     2264                                                 &result);
     2265                if (!NT_STATUS_IS_OK(status)) {
    20402266                        goto done;
    2041 
    2042                 result = rpccli_samr_OpenGroup(cli, mem_ctx,
     2267                }
     2268                if (!NT_STATUS_IS_OK(result)) {
     2269                        status = result;
     2270                        goto done;
     2271                }
     2272
     2273                status = dcerpc_samr_OpenGroup(b, mem_ctx,
    20432274                                               &domain_pol,
    20442275                                               access_mask,
    20452276                                               group_rids.ids[0],
    2046                                                &group_pol);
    2047 
    2048                 if (!NT_STATUS_IS_OK(result))
     2277                                               &group_pol,
     2278                                               &result);
     2279                if (!NT_STATUS_IS_OK(status)) {
    20492280                        goto done;
     2281                }
     2282                if (!NT_STATUS_IS_OK(result)) {
     2283                        status = result;
     2284                        goto done;
     2285                }
    20502286        }
    20512287
    20522288        /* Delete group */
    20532289
    2054         result = rpccli_samr_DeleteDomainGroup(cli, mem_ctx,
    2055                                                &group_pol);
    2056 
    2057         if (!NT_STATUS_IS_OK(result))
    2058                 goto done;
     2290        status = dcerpc_samr_DeleteDomainGroup(b, mem_ctx,
     2291                                               &group_pol,
     2292                                               &result);
     2293        if (!NT_STATUS_IS_OK(status)) {
     2294                goto done;
     2295        }
     2296        if (!NT_STATUS_IS_OK(result)) {
     2297                status = result;
     2298                goto done;
     2299        }
    20592300
    20602301        /* Display results */
    20612302
    2062         rpccli_samr_Close(cli, mem_ctx, &group_pol);
    2063         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    2064         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     2303        dcerpc_samr_Close(b, mem_ctx, &group_pol, &result);
     2304        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2305        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    20652306
    20662307 done:
    2067         return result;
     2308        return status;
    20682309}
    20692310
    … …  
    20742315                                         int argc, const char **argv)
    20752316{
    2076         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2317        NTSTATUS status, result;
    20772318        struct policy_handle connect_pol, domain_pol, user_pol;
    20782319        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
     2320        struct dcerpc_binding_handle *b = cli->binding_handle;
    20792321
    20802322        if ((argc < 2) || (argc > 3)) {
    … …  
    20882330        /* Get sam policy and domain handles */
    20892331
    2090         result = rpccli_try_samr_connects(cli, mem_ctx,
     2332        status = rpccli_try_samr_connects(cli, mem_ctx,
    20912333                                          MAXIMUM_ALLOWED_ACCESS,
    20922334                                          &connect_pol);
    2093 
    2094         if (!NT_STATUS_IS_OK(result))
    2095                 goto done;
    2096 
    2097         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2335        if (!NT_STATUS_IS_OK(status)) {
     2336                goto done;
     2337        }
     2338
     2339        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    20982340                                        &connect_pol,
    20992341                                        MAXIMUM_ALLOWED_ACCESS,
    21002342                                        &domain_sid,
    2101                                         &domain_pol);
    2102 
    2103         if (!NT_STATUS_IS_OK(result))
    2104                 goto done;
     2343                                        &domain_pol,
     2344                                        &result);
     2345        if (!NT_STATUS_IS_OK(status)) {
     2346                goto done;
     2347        }
     2348        if (!NT_STATUS_IS_OK(result)) {
     2349                status = result;
     2350                goto done;
     2351        }
    21052352
    21062353        /* Get handle on user */
    … …  
    21122359                init_lsa_String(&lsa_acct_name, argv[1]);
    21132360
    2114                 result = rpccli_samr_LookupNames(cli, mem_ctx,
     2361                status = dcerpc_samr_LookupNames(b, mem_ctx,
    21152362                                                 &domain_pol,
    21162363                                                 1,
    21172364                                                 &lsa_acct_name,
    21182365                                                 &user_rids,
    2119                                                  &name_types);
    2120 
    2121                 if (!NT_STATUS_IS_OK(result))
     2366                                                 &name_types,
     2367                                                 &result);
     2368                if (!NT_STATUS_IS_OK(status)) {
    21222369                        goto done;
    2123 
    2124                 result = rpccli_samr_OpenUser(cli, mem_ctx,
     2370                }
     2371                if (!NT_STATUS_IS_OK(result)) {
     2372                        status = result;
     2373                        goto done;
     2374                }
     2375
     2376                status = dcerpc_samr_OpenUser(b, mem_ctx,
    21252377                                              &domain_pol,
    21262378                                              access_mask,
    21272379                                              user_rids.ids[0],
    2128                                               &user_pol);
    2129 
    2130                 if (!NT_STATUS_IS_OK(result))
     2380                                              &user_pol,
     2381                                              &result);
     2382                if (!NT_STATUS_IS_OK(status)) {
    21312383                        goto done;
     2384                }
     2385                if (!NT_STATUS_IS_OK(result)) {
     2386                        status = result;
     2387                        goto done;
     2388                }
    21322389        }
    21332390
    21342391        /* Delete user */
    21352392
    2136         result = rpccli_samr_DeleteUser(cli, mem_ctx,
    2137                                         &user_pol);
    2138 
    2139         if (!NT_STATUS_IS_OK(result))
    2140                 goto done;
     2393        status = dcerpc_samr_DeleteUser(b, mem_ctx,
     2394                                        &user_pol,
     2395                                        &result);
     2396        if (!NT_STATUS_IS_OK(status)) {
     2397                goto done;
     2398        }
     2399        if (!NT_STATUS_IS_OK(result)) {
     2400                status = result;
     2401                goto done;
     2402        }
    21412403
    21422404        /* Display results */
    21432405
    2144         rpccli_samr_Close(cli, mem_ctx, &user_pol);
    2145         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    2146         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     2406        dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
     2407        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2408        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    21472409
    21482410 done:
    2149         return result;
     2411        return status;
    21502412}
    21512413
    … …  
    21582420{
    21592421        struct policy_handle connect_pol, domain_pol, user_pol, *pol;
    2160         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
    2161         uint32 sec_info = DACL_SECURITY_INFORMATION;
     2422        NTSTATUS status, result;
     2423        uint32 sec_info = SECINFO_DACL;
    21622424        uint32 user_rid = 0;
    21632425        TALLOC_CTX *ctx = NULL;
    2164         SEC_DESC_BUF *sec_desc_buf=NULL;
     2426        struct sec_desc_buf *sec_desc_buf=NULL;
    21652427        bool domain = False;
     2428        struct dcerpc_binding_handle *b = cli->binding_handle;
    21662429
    21672430        ctx=talloc_init("cmd_samr_query_sec_obj");
    … …  
    21852448        }
    21862449
    2187         result = rpccli_try_samr_connects(cli, mem_ctx,
     2450        status = rpccli_try_samr_connects(cli, mem_ctx,
    21882451                                          MAXIMUM_ALLOWED_ACCESS,
    21892452                                          &connect_pol);
    2190 
    2191         if (!NT_STATUS_IS_OK(result))
    2192                 goto done;
    2193 
    2194         if (domain || user_rid)
    2195                 result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2453        if (!NT_STATUS_IS_OK(status)) {
     2454                goto done;
     2455        }
     2456
     2457        if (domain || user_rid) {
     2458                status = dcerpc_samr_OpenDomain(b, mem_ctx,
    21962459                                                &connect_pol,
    21972460                                                MAXIMUM_ALLOWED_ACCESS,
    21982461                                                &domain_sid,
    2199                                                 &domain_pol);
    2200 
    2201         if (!NT_STATUS_IS_OK(result))
    2202                 goto done;
    2203 
    2204         if (user_rid)
    2205                 result = rpccli_samr_OpenUser(cli, mem_ctx,
     2462                                                &domain_pol,
     2463                                                &result);
     2464                if (!NT_STATUS_IS_OK(status)) {
     2465                        goto done;
     2466                }
     2467                if (!NT_STATUS_IS_OK(result)) {
     2468                        status = result;
     2469                        goto done;
     2470                }
     2471        }
     2472
     2473        if (user_rid) {
     2474                status = dcerpc_samr_OpenUser(b, mem_ctx,
    22062475                                              &domain_pol,
    22072476                                              MAXIMUM_ALLOWED_ACCESS,
    22082477                                              user_rid,
    2209                                               &user_pol);
    2210 
    2211         if (!NT_STATUS_IS_OK(result))
    2212                 goto done;
     2478                                              &user_pol,
     2479                                              &result);
     2480                if (!NT_STATUS_IS_OK(status)) {
     2481                        goto done;
     2482                }
     2483                if (!NT_STATUS_IS_OK(result)) {
     2484                        status = result;
     2485                        goto done;
     2486                }
     2487        }
    22132488
    22142489        /* Pick which query pol to use */
    … …  
    22242499        /* Query SAM security object */
    22252500
    2226         result = rpccli_samr_QuerySecurity(cli, mem_ctx,
     2501        status = dcerpc_samr_QuerySecurity(b, mem_ctx,
    22272502                                           pol,
    22282503                                           sec_info,
    2229                                            &sec_desc_buf);
    2230 
    2231         if (!NT_STATUS_IS_OK(result))
    2232                 goto done;
     2504                                           &sec_desc_buf,
     2505                                           &result);
     2506        if (!NT_STATUS_IS_OK(status)) {
     2507                goto done;
     2508        }
     2509        if (!NT_STATUS_IS_OK(result)) {
     2510                status = result;
     2511                goto done;
     2512        }
    22332513
    22342514        display_sec_desc(sec_desc_buf->sd);
    22352515
    2236         rpccli_samr_Close(cli, mem_ctx, &user_pol);
    2237         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    2238         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     2516        dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
     2517        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2518        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    22392519done:
    22402520        talloc_destroy(ctx);
    2241         return result;
     2521        return status;
    22422522}
    22432523
    … …  
    22462526                                           int argc, const char **argv)
    22472527{
    2248         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2528        NTSTATUS status, result;
    22492529        struct policy_handle connect_pol, domain_pol, user_pol;
    22502530        struct samr_PwInfo info;
    22512531        uint32_t rid;
     2532        struct dcerpc_binding_handle *b = cli->binding_handle;
    22522533
    22532534        if (argc != 2) {
    … …  
    22582539        sscanf(argv[1], "%i", &rid);
    22592540
    2260         result = rpccli_try_samr_connects(cli, mem_ctx,
     2541        status = rpccli_try_samr_connects(cli, mem_ctx,
    22612542                                          MAXIMUM_ALLOWED_ACCESS,
    22622543                                          &connect_pol);
    2263 
    2264         if (!NT_STATUS_IS_OK(result)) {
    2265                 goto done;
    2266         }
    2267 
    2268         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2544        if (!NT_STATUS_IS_OK(status)) {
     2545                goto done;
     2546        }
     2547
     2548        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    22692549                                        &connect_pol,
    22702550                                        MAXIMUM_ALLOWED_ACCESS,
    22712551                                        &domain_sid,
    2272                                         &domain_pol);
    2273 
    2274         if (!NT_STATUS_IS_OK(result)) {
    2275                 goto done;
    2276         }
    2277 
    2278         result = rpccli_samr_OpenUser(cli, mem_ctx,
     2552                                        &domain_pol,
     2553                                        &result);
     2554        if (!NT_STATUS_IS_OK(status)) {
     2555                goto done;
     2556        }
     2557        if (!NT_STATUS_IS_OK(result)) {
     2558                status = result;
     2559                goto done;
     2560        }
     2561
     2562        status = dcerpc_samr_OpenUser(b, mem_ctx,
    22792563                                      &domain_pol,
    22802564                                      MAXIMUM_ALLOWED_ACCESS,
    22812565                                      rid,
    2282                                       &user_pol);
    2283 
    2284         if (!NT_STATUS_IS_OK(result)) {
    2285                 goto done;
    2286         }
    2287 
    2288         result = rpccli_samr_GetUserPwInfo(cli, mem_ctx, &user_pol, &info);
     2566                                      &user_pol,
     2567                                      &result);
     2568        if (!NT_STATUS_IS_OK(status)) {
     2569                goto done;
     2570        }
     2571        if (!NT_STATUS_IS_OK(result)) {
     2572                status = result;
     2573                goto done;
     2574        }
     2575
     2576        status = dcerpc_samr_GetUserPwInfo(b, mem_ctx,
     2577                                           &user_pol,
     2578                                           &info,
     2579                                           &result);
     2580        if (!NT_STATUS_IS_OK(status)) {
     2581                goto done;
     2582        }
     2583        status = result;
    22892584        if (NT_STATUS_IS_OK(result)) {
    22902585                printf("min_password_length: %d\n", info.min_password_length);
    … …  
    22952590
    22962591 done:
    2297         rpccli_samr_Close(cli, mem_ctx, &user_pol);
    2298         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    2299         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    2300 
    2301         return result;
     2592        dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
     2593        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2594        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     2595
     2596        return status;
    23022597}
    23032598
    … …  
    23062601                                        int argc, const char **argv)
    23072602{
    2308         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2603        NTSTATUS status, result;
    23092604        struct lsa_String domain_name;
    23102605        struct samr_PwInfo info;
     2606        struct dcerpc_binding_handle *b = cli->binding_handle;
    23112607
    23122608        if (argc < 1 || argc > 3) {
    … …  
    23172613        init_lsa_String(&domain_name, argv[1]);
    23182614
    2319         result = rpccli_samr_GetDomPwInfo(cli, mem_ctx, &domain_name, &info);
    2320 
     2615        status = dcerpc_samr_GetDomPwInfo(b, mem_ctx,
     2616                                          &domain_name,
     2617                                          &info,
     2618                                          &result);
     2619        if (!NT_STATUS_IS_OK(status)) {
     2620                return status;
     2621        }
    23212622        if (NT_STATUS_IS_OK(result)) {
    23222623                printf("min_password_length: %d\n", info.min_password_length);
    … …  
    23342635{
    23352636        struct policy_handle connect_pol, domain_pol;
    2336         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2637        NTSTATUS status, result;
    23372638        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    23382639        fstring sid_string;
    23392640        struct lsa_String domain_name;
    2340         DOM_SID *sid = NULL;
     2641        struct dom_sid *sid = NULL;
     2642        struct dcerpc_binding_handle *b = cli->binding_handle;
    23412643
    23422644        if (argc != 2) {
    … …  
    23472649        init_lsa_String(&domain_name, argv[1]);
    23482650
    2349         result = rpccli_try_samr_connects(cli, mem_ctx,
     2651        status = rpccli_try_samr_connects(cli, mem_ctx,
    23502652                                          access_mask,
    23512653                                          &connect_pol);
    2352 
    2353         if (!NT_STATUS_IS_OK(result))
    2354                 goto done;
    2355 
    2356         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2654        if (!NT_STATUS_IS_OK(status)) {
     2655                goto done;
     2656        }
     2657
     2658        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    23572659                                        &connect_pol,
    23582660                                        access_mask,
    23592661                                        &domain_sid,
    2360                                         &domain_pol);
    2361 
    2362         if (!NT_STATUS_IS_OK(result))
    2363                 goto done;
    2364 
    2365         result = rpccli_samr_LookupDomain(cli, mem_ctx,
     2662                                        &domain_pol,
     2663                                        &result);
     2664        if (!NT_STATUS_IS_OK(status)) {
     2665                goto done;
     2666        }
     2667        if (!NT_STATUS_IS_OK(result)) {
     2668                status = result;
     2669                goto done;
     2670        }
     2671
     2672        status = dcerpc_samr_LookupDomain(b, mem_ctx,
    23662673                                          &connect_pol,
    23672674                                          &domain_name,
    2368                                           &sid);
     2675                                          &sid,
     2676                                          &result);
     2677        if (!NT_STATUS_IS_OK(status)) {
     2678                goto done;
     2679        }
     2680        if (!NT_STATUS_IS_OK(result)) {
     2681                status = result;
     2682                goto done;
     2683        }
    23692684
    23702685        if (NT_STATUS_IS_OK(result)) {
    … …  
    23742689        }
    23752690
    2376         rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    2377         rpccli_samr_Close(cli, mem_ctx, &connect_pol);
     2691        dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2692        dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
    23782693done:
    2379         return result;
     2694        return status;
    23802695}
    23812696
    … …  
    23872702{
    23882703        struct policy_handle connect_pol, domain_pol, user_pol;
    2389         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2704        NTSTATUS status, result;
    23902705        const char *user, *oldpass, *newpass;
    23912706        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    23922707        struct samr_Ids rids, types;
    23932708        struct lsa_String lsa_acct_name;
     2709        struct dcerpc_binding_handle *b = cli->binding_handle;
    23942710
    23952711        if (argc < 3) {
    … …  
    24042720        /* Get sam policy handle */
    24052721
    2406         result = rpccli_try_samr_connects(cli, mem_ctx,
     2722        status = rpccli_try_samr_connects(cli, mem_ctx,
    24072723                                          MAXIMUM_ALLOWED_ACCESS,
    24082724                                          &connect_pol);
    2409 
    2410         if (!NT_STATUS_IS_OK(result)) {
     2725        if (!NT_STATUS_IS_OK(status)) {
    24112726                goto done;
    24122727        }
    … …  
    24142729        /* Get domain policy handle */
    24152730
    2416         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2731        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    24172732                                        &connect_pol,
    24182733                                        access_mask,
    24192734                                        &domain_sid,
    2420                                         &domain_pol);
    2421 
    2422         if (!NT_STATUS_IS_OK(result)) {
     2735                                        &domain_pol,
     2736                                        &result);
     2737        if (!NT_STATUS_IS_OK(status)) {
     2738                goto done;
     2739        }
     2740        if (!NT_STATUS_IS_OK(result)) {
     2741                status = result;
    24232742                goto done;
    24242743        }
    … …  
    24262745        init_lsa_String(&lsa_acct_name, user);
    24272746
    2428         result = rpccli_samr_LookupNames(cli, mem_ctx,
     2747        status = dcerpc_samr_LookupNames(b, mem_ctx,
    24292748                                         &domain_pol,
    24302749                                         1,
    24312750                                         &lsa_acct_name,
    24322751                                         &rids,
    2433                                          &types);
    2434 
    2435         if (!NT_STATUS_IS_OK(result)) {
    2436                 goto done;
    2437         }
    2438 
    2439         result = rpccli_samr_OpenUser(cli, mem_ctx,
     2752                                         &types,
     2753                                         &result);
     2754        if (!NT_STATUS_IS_OK(status)) {
     2755                goto done;
     2756        }
     2757        if (!NT_STATUS_IS_OK(result)) {
     2758                status = result;
     2759                goto done;
     2760        }
     2761
     2762        status = dcerpc_samr_OpenUser(b, mem_ctx,
    24402763                                      &domain_pol,
    24412764                                      access_mask,
    24422765                                      rids.ids[0],
    2443                                       &user_pol);
    2444 
    2445         if (!NT_STATUS_IS_OK(result)) {
     2766                                      &user_pol,
     2767                                      &result);
     2768        if (!NT_STATUS_IS_OK(status)) {
     2769                goto done;
     2770        }
     2771        if (!NT_STATUS_IS_OK(result)) {
     2772                status = result;
    24462773                goto done;
    24472774        }
    24482775
    24492776        /* Change user password */
    2450         result = rpccli_samr_chgpasswd_user(cli, mem_ctx,
     2777        status = rpccli_samr_chgpasswd_user(cli, mem_ctx,
    24512778                                            &user_pol,
    24522779                                            newpass,
    24532780                                            oldpass);
    2454 
    2455         if (!NT_STATUS_IS_OK(result)) {
     2781        if (!NT_STATUS_IS_OK(status)) {
    24562782                goto done;
    24572783        }
    … …  
    24592785 done:
    24602786        if (is_valid_policy_hnd(&user_pol)) {
    2461                 rpccli_samr_Close(cli, mem_ctx, &user_pol);
     2787                dcerpc_samr_Close(b, mem_ctx, &user_pol, &result);
    24622788        }
    24632789        if (is_valid_policy_hnd(&domain_pol)) {
    2464                 rpccli_samr_Close(cli, mem_ctx, &domain_pol);
     2790                dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
    24652791        }
    24662792        if (is_valid_policy_hnd(&connect_pol)) {
    2467                 rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    2468         }
    2469 
    2470         return result;
     2793                dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     2794        }
     2795
     2796        return status;
    24712797}
    24722798
    … …  
    24792805{
    24802806        struct policy_handle connect_pol, domain_pol;
    2481         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2807        NTSTATUS status, result;
    24822808        const char *user, *oldpass, *newpass;
    24832809        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
     2810        struct dcerpc_binding_handle *b = cli->binding_handle;
    24842811
    24852812        if (argc < 3) {
    … …  
    24942821        /* Get sam policy handle */
    24952822
    2496         result = rpccli_try_samr_connects(cli, mem_ctx,
     2823        status = rpccli_try_samr_connects(cli, mem_ctx,
    24972824                                          MAXIMUM_ALLOWED_ACCESS,
    24982825                                          &connect_pol);
    2499 
    2500         if (!NT_STATUS_IS_OK(result))
    2501                 goto done;
     2826        if (!NT_STATUS_IS_OK(status)) {
     2827                goto done;
     2828        }
    25022829
    25032830        /* Get domain policy handle */
    25042831
    2505         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2832        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    25062833                                        &connect_pol,
    25072834                                        access_mask,
    25082835                                        &domain_sid,
    2509                                         &domain_pol);
    2510 
    2511         if (!NT_STATUS_IS_OK(result))
    2512                 goto done;
     2836                                        &domain_pol,
     2837                                        &result);
     2838        if (!NT_STATUS_IS_OK(status)) {
     2839                goto done;
     2840        }
     2841        if (!NT_STATUS_IS_OK(result)) {
     2842                status = result;
     2843                goto done;
     2844        }
    25132845
    25142846        /* Change user password */
    2515         result = rpccli_samr_chgpasswd_user2(cli, mem_ctx, user, newpass, oldpass);
    2516 
    2517         if (!NT_STATUS_IS_OK(result))
    2518                 goto done;
    2519 
    2520         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    2521         if (!NT_STATUS_IS_OK(result)) goto done;
    2522 
    2523         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    2524         if (!NT_STATUS_IS_OK(result)) goto done;
     2847        status = rpccli_samr_chgpasswd_user2(cli, mem_ctx, user, newpass, oldpass);
     2848
     2849        if (!NT_STATUS_IS_OK(status)) {
     2850                goto done;
     2851        }
     2852
     2853        status = dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2854        if (!NT_STATUS_IS_OK(status)) goto done;
     2855
     2856        status = dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     2857        if (!NT_STATUS_IS_OK(status)) goto done;
    25252858
    25262859 done:
    2527         return result;
     2860        return status;
    25282861}
    25292862
    … …  
    25362869{
    25372870        struct policy_handle connect_pol, domain_pol;
    2538         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
     2871        NTSTATUS status, result;
    25392872        const char *user, *oldpass, *newpass;
    25402873        uint32 access_mask = MAXIMUM_ALLOWED_ACCESS;
    25412874        struct samr_DomInfo1 *info = NULL;
    2542         struct samr_ChangeReject *reject = NULL;
     2875        struct userPwdChangeFailureInformation *reject = NULL;
     2876        struct dcerpc_binding_handle *b = cli->binding_handle;
    25432877
    25442878        if (argc < 3) {
    … …  
    25532887        /* Get sam policy handle */
    25542888
    2555         result = rpccli_try_samr_connects(cli, mem_ctx,
     2889        status = rpccli_try_samr_connects(cli, mem_ctx,
    25562890                                          MAXIMUM_ALLOWED_ACCESS,
    25572891                                          &connect_pol);
    2558 
    2559         if (!NT_STATUS_IS_OK(result))
    2560                 goto done;
     2892        if (!NT_STATUS_IS_OK(status)) {
     2893                goto done;
     2894        }
    25612895
    25622896        /* Get domain policy handle */
    25632897
    2564         result = rpccli_samr_OpenDomain(cli, mem_ctx,
     2898        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    25652899                                        &connect_pol,
    25662900                                        access_mask,
    25672901                                        &domain_sid,
    2568                                         &domain_pol);
    2569 
    2570         if (!NT_STATUS_IS_OK(result))
    2571                 goto done;
     2902                                        &domain_pol,
     2903                                        &result);
     2904        if (!NT_STATUS_IS_OK(status)) {
     2905                goto done;
     2906        }
     2907        if (!NT_STATUS_IS_OK(result)) {
     2908                status = result;
     2909                goto done;
     2910        }
    25722911
    25732912        /* Change user password */
    2574         result = rpccli_samr_chgpasswd_user3(cli, mem_ctx,
     2913        status = rpccli_samr_chgpasswd_user3(cli, mem_ctx,
    25752914                                             user,
    25762915                                             newpass,
    … …  
    25782917                                             &info,
    25792918                                             &reject);
     2919        if (!NT_STATUS_IS_OK(status)) {
     2920                goto done;
     2921        }
    25802922
    25812923        if (NT_STATUS_EQUAL(result, NT_STATUS_PASSWORD_RESTRICTION)) {
    … …  
    25832925                display_sam_dom_info_1(info);
    25842926
    2585                 switch (reject->reason) {
    2586                         case SAMR_REJECT_TOO_SHORT:
    2587                                 d_printf("SAMR_REJECT_TOO_SHORT\n");
     2927                switch (reject->extendedFailureReason) {
     2928                        case SAM_PWD_CHANGE_PASSWORD_TOO_SHORT:
     2929                                d_printf("SAM_PWD_CHANGE_PASSWORD_TOO_SHORT\n");
    25882930                                break;
    2589                         case SAMR_REJECT_IN_HISTORY:
    2590                                 d_printf("SAMR_REJECT_IN_HISTORY\n");
     2931                        case SAM_PWD_CHANGE_PWD_IN_HISTORY:
     2932                                d_printf("SAM_PWD_CHANGE_PWD_IN_HISTORY\n");
    25912933                                break;
    2592                         case SAMR_REJECT_COMPLEXITY:
    2593                                 d_printf("SAMR_REJECT_COMPLEXITY\n");
    2594                                 break;
    2595                         case SAMR_REJECT_OTHER:
    2596                                 d_printf("SAMR_REJECT_OTHER\n");
     2934                        case SAM_PWD_CHANGE_NOT_COMPLEX:
     2935                                d_printf("SAM_PWD_CHANGE_NOT_COMPLEX\n");
    25972936                                break;
    25982937                        default:
    25992938                                d_printf("unknown reject reason: %d\n",
    2600                                         reject->reason);
     2939                                        reject->extendedFailureReason);
    26012940                                break;
    26022941                }
    26032942        }
    26042943
    2605         if (!NT_STATUS_IS_OK(result))
    2606                 goto done;
    2607 
    2608         result = rpccli_samr_Close(cli, mem_ctx, &domain_pol);
    2609         if (!NT_STATUS_IS_OK(result)) goto done;
    2610 
    2611         result = rpccli_samr_Close(cli, mem_ctx, &connect_pol);
    2612         if (!NT_STATUS_IS_OK(result)) goto done;
     2944        if (!NT_STATUS_IS_OK(result)) {
     2945                status = result;
     2946                goto done;
     2947        }
     2948
     2949        status = dcerpc_samr_Close(b, mem_ctx, &domain_pol, &result);
     2950        if (!NT_STATUS_IS_OK(status)) goto done;
     2951
     2952        status = dcerpc_samr_Close(b, mem_ctx, &connect_pol, &result);
     2953        if (!NT_STATUS_IS_OK(status)) goto done;
    26132954
    26142955 done:
    2615         return result;
     2956        return status;
    26162957}
    26172958
    … …  
    26222963{
    26232964        struct policy_handle connect_pol, domain_pol, user_pol;
    2624         NTSTATUS status = NT_STATUS_UNSUCCESSFUL;
     2965        NTSTATUS status, result;
    26252966        const char *user, *param;
    26262967        uint32_t access_mask = MAXIMUM_ALLOWED_ACCESS;
    … …  
    26342975        DATA_BLOB session_key;
    26352976        uint8_t password_expired = 0;
     2977        struct dcerpc_binding_handle *b = cli->binding_handle;
    26362978
    26372979        if (argc < 4) {
    … …  
    27633105                                          MAXIMUM_ALLOWED_ACCESS,
    27643106                                          &connect_pol);
    2765 
    2766         if (!NT_STATUS_IS_OK(status))
    2767                 goto done;
     3107        if (!NT_STATUS_IS_OK(status)) {
     3108                goto done;
     3109        }
    27683110
    27693111        /* Get domain policy handle */
    27703112
    2771         status = rpccli_samr_OpenDomain(cli, mem_ctx,
     3113        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    27723114                                        &connect_pol,
    27733115                                        access_mask,
    27743116                                        &domain_sid,
    2775                                         &domain_pol);
     3117                                        &domain_pol,
     3118                                        &result);
    27763119
    27773120        if (!NT_STATUS_IS_OK(status))
    27783121                goto done;
     3122        if (!NT_STATUS_IS_OK(result)) {
     3123                status = result;
     3124                goto done;
     3125        }
    27793126
    27803127        user_rid = strtol(user, NULL, 0);
    27813128        if (user_rid) {
    2782                 status = rpccli_samr_OpenUser(cli, mem_ctx,
     3129                status = dcerpc_samr_OpenUser(b, mem_ctx,
    27833130                                              &domain_pol,
    27843131                                              access_mask,
    27853132                                              user_rid,
    2786                                               &user_pol);
     3133                                              &user_pol,
     3134                                              &result);
     3135                if (!NT_STATUS_IS_OK(status)) {
     3136                        goto done;
     3137                }
     3138
     3139                status = result;
    27873140        }
    27883141
    … …  
    27963149                init_lsa_String(&lsa_acct_name, user);
    27973150
    2798                 status = rpccli_samr_LookupNames(cli, mem_ctx,
     3151                status = dcerpc_samr_LookupNames(b, mem_ctx,
    27993152                                                 &domain_pol,
    28003153                                                 1,
    28013154                                                 &lsa_acct_name,
    28023155                                                 &rids,
    2803                                                  &types);
     3156                                                 &types,
     3157                                                 &result);
    28043158                if (!NT_STATUS_IS_OK(status)) {
    28053159                        return status;
    28063160                }
    2807 
    2808                 status = rpccli_samr_OpenUser(cli, mem_ctx,
     3161                if (!NT_STATUS_IS_OK(result)) {
     3162                        return result;
     3163                }
     3164
     3165
     3166                status = dcerpc_samr_OpenUser(b, mem_ctx,
    28093167                                              &domain_pol,
    28103168                                              access_mask,
    28113169                                              rids.ids[0],
    2812                                               &user_pol);
     3170                                              &user_pol,
     3171                                              &result);
    28133172                if (!NT_STATUS_IS_OK(status)) {
    28143173                        return status;
    28153174                }
     3175                if (!NT_STATUS_IS_OK(result)) {
     3176                        return result;
     3177                }
    28163178        }
    28173179
    28183180        switch (opcode) {
    28193181        case NDR_SAMR_SETUSERINFO:
    2820                 status = rpccli_samr_SetUserInfo(cli, mem_ctx,
     3182                status = dcerpc_samr_SetUserInfo(b, mem_ctx,
    28213183                                                 &user_pol,
    28223184                                                 level,
    2823                                                  &info);
     3185                                                 &info,
     3186                                                 &result);
    28243187                break;
    28253188        case NDR_SAMR_SETUSERINFO2:
    2826                 status = rpccli_samr_SetUserInfo2(cli, mem_ctx,
     3189                status = dcerpc_samr_SetUserInfo2(b, mem_ctx,
    28273190                                                  &user_pol,
    28283191                                                  level,
    2829                                                   &info);
     3192                                                  &info,
     3193                                                  &result);
    28303194                break;
    28313195        default:
    28323196                return NT_STATUS_INVALID_PARAMETER;
    28333197        }
    2834 
     3198        if (!NT_STATUS_IS_OK(status)) {
     3199                DEBUG(0,("status: %s\n", nt_errstr(status)));
     3200                goto done;
     3201        }
     3202        if (!NT_STATUS_IS_OK(result)) {
     3203                status = result;
     3204                DEBUG(0,("result: %s\n", nt_errstr(status)));
     3205                goto done;
     3206        }
    28353207 done:
    28363208        return status;
    … …  
    28573229                                          int argc, const char **argv)
    28583230{
    2859         NTSTATUS status;
     3231        NTSTATUS status, result;
    28603232        struct policy_handle connect_handle;
    28613233        struct policy_handle domain_handle;
    … …  
    28633235        struct lsa_String name;
    28643236        uint32_t idx = 0;
     3237        struct dcerpc_binding_handle *b = cli->binding_handle;
    28653238
    28663239        if (argc < 2 || argc > 3) {
    … …  
    28783251                                          SEC_FLAG_MAXIMUM_ALLOWED,
    28793252                                          &connect_handle);
    2880 
    2881         if (!NT_STATUS_IS_OK(status)) {
    2882                 goto done;
    2883         }
    2884 
    2885         status = rpccli_samr_OpenDomain(cli, mem_ctx,
     3253        if (!NT_STATUS_IS_OK(status)) {
     3254                goto done;
     3255        }
     3256
     3257        status = dcerpc_samr_OpenDomain(b, mem_ctx,
    28863258                                        &connect_handle,
    28873259                                        SEC_FLAG_MAXIMUM_ALLOWED,
    28883260                                        &domain_sid,
    2889                                         &domain_handle);
    2890 
    2891         if (!NT_STATUS_IS_OK(status))
    2892                 goto done;
    2893 
    2894 
    2895         status = rpccli_samr_GetDisplayEnumerationIndex(cli, mem_ctx,
     3261                                        &domain_handle,
     3262                                        &result);
     3263        if (!NT_STATUS_IS_OK(status)) {
     3264                goto done;
     3265        }
     3266        if (!NT_STATUS_IS_OK(result)) {
     3267                status = result;
     3268                goto done;
     3269        }
     3270
     3271        status = dcerpc_samr_GetDisplayEnumerationIndex(b, mem_ctx,
    28963272                                                        &domain_handle,
    28973273                                                        level,
    28983274                                                        &name,
    2899                                                         &idx);
     3275                                                        &idx,
     3276                                                        &result);
     3277        if (!NT_STATUS_IS_OK(status)) {
     3278                goto done;
     3279        }
     3280
     3281        status = result;
    29003282
    29013283        if (NT_STATUS_IS_OK(status) ||
    … …  
    29063288
    29073289        if (is_valid_policy_hnd(&domain_handle)) {
    2908                 rpccli_samr_Close(cli, mem_ctx, &domain_handle);
     3290                dcerpc_samr_Close(b, mem_ctx, &domain_handle, &result);
    29093291        }
    29103292        if (is_valid_policy_hnd(&connect_handle)) {
    2911                 rpccli_samr_Close(cli, mem_ctx, &connect_handle);
     3293                dcerpc_samr_Close(b, mem_ctx, &connect_handle, &result);
    29123294        }
    29133295
Note: See TracChangeset for help on using the changeset viewer.