Ignore:
Timestamp:
Jul 1, 2011, 4:02:23 PM (14 years ago)
Author:
Herwig Bauernfeind
Message:

Samba 3.5: Update vendor to version 3.5.8

Location:
vendor/current/source3/lib
Files:
16 edited

Legend:

Unmodified
Added
Removed

  • vendor/current/source3/lib/events.c

    r591 r594  
    140140        }
    141141
    142         if (selrtn == 0) {
     142        if (selrtn <= 0) {
    143143                /*
    144144                 * No fd ready
    … …  
    154154
    155155                if (flags & fde->flags) {
     156                        DLIST_DEMOTE(ev->fd_events, fde, struct tevent_fd *);
    156157                        fde->handler(ev, fde, flags, fde->private_data);
    157158                        return true;

  • vendor/current/source3/lib/netapi/file.c

    r414 r594  
    4343        }
    4444
    45         status = rpccli_srvsvc_NetFileClose(pipe_cli, ctx,
     45        status = rpccli_srvsvc_NetFileClose(pipe_cli, talloc_tos(),
    4646                                            r->in.server_name,
    4747                                            r->in.fileid,
    … …  
    137137        }
    138138
    139         status = rpccli_srvsvc_NetFileGetInfo(pipe_cli, ctx,
     139        status = rpccli_srvsvc_NetFileGetInfo(pipe_cli, talloc_tos(),
    140140                                              r->in.server_name,
    141141                                              r->in.fileid,
    … …  
    217217        }
    218218
    219         status = rpccli_srvsvc_NetFileEnum(pipe_cli, ctx,
     219        status = rpccli_srvsvc_NetFileEnum(pipe_cli, talloc_tos(),
    220220                                           r->in.server_name,
    221221                                           r->in.base_path,

  • vendor/current/source3/lib/netapi/getdc.c

    r414 r594  
    5353        }
    5454
    55         status = rpccli_netr_GetDcName(pipe_cli, ctx,
     55        status = rpccli_netr_GetDcName(pipe_cli, talloc_tos(),
    5656                                       r->in.server_name,
    5757                                       r->in.domain_name,
    … …  
    9393        }
    9494
    95         status = rpccli_netr_GetAnyDCName(pipe_cli, ctx,
     95        status = rpccli_netr_GetAnyDCName(pipe_cli, talloc_tos(),
    9696                                          r->in.server_name,
    9797                                          r->in.domain_name,

  • vendor/current/source3/lib/netapi/group.c

    r414 r594  
    106106        }
    107107
    108         status = rpccli_samr_CreateDomainGroup(pipe_cli, ctx,
     108        status = rpccli_samr_CreateDomainGroup(pipe_cli, talloc_tos(),
    109109                                               &domain_handle,
    110110                                               &lsa_group_name,
    … …  
    125125                                                info1->grpi1_comment);
    126126
    127                                 status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     127                                status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    128128                                                                  &group_handle,
    129129                                                                  GROUPINFODESCRIPTION,
    … …  
    136136                                                info2->grpi2_comment);
    137137
    138                                 status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     138                                status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    139139                                                                  &group_handle,
    140140                                                                  GROUPINFODESCRIPTION,
    … …  
    148148                        if (info2->grpi2_attributes != 0) {
    149149                                info.attributes.attributes = info2->grpi2_attributes;
    150                                 status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     150                                status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    151151                                                                  &group_handle,
    152152                                                                  GROUPINFOATTRIBUTES,
    … …  
    160160                                                info3->grpi3_comment);
    161161
    162                                 status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     162                                status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    163163                                                                  &group_handle,
    164164                                                                  GROUPINFODESCRIPTION,
    … …  
    172172                        if (info3->grpi3_attributes != 0) {
    173173                                info.attributes.attributes = info3->grpi3_attributes;
    174                                 status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     174                                status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    175175                                                                  &group_handle,
    176176                                                                  GROUPINFOATTRIBUTES,
    … …  
    191191
    192192 failed:
    193         rpccli_samr_DeleteDomainGroup(pipe_cli, ctx,
     193        rpccli_samr_DeleteDomainGroup(pipe_cli, talloc_tos(),
    194194                                      &group_handle);
    195195
    196196 done:
    197197        if (is_valid_policy_hnd(&group_handle)) {
    198                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     198                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    199199        }
    200200
    … …  
    263263        init_lsa_String(&lsa_group_name, r->in.group_name);
    264264
    265         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     265        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    266266                                         &domain_handle,
    267267                                         1,
    … …  
    279279        }
    280280
    281         status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     281        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    282282                                       &domain_handle,
    283283                                       SEC_STD_DELETE |
    … …  
    293293        }
    294294
    295         status = rpccli_samr_QueryGroupInfo(pipe_cli, ctx,
     295        status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
    296296                                            &group_handle,
    297297                                            GROUPINFOATTRIBUTES,
    … …  
    309309        }
    310310#endif
    311         status = rpccli_samr_QueryGroupMember(pipe_cli, ctx,
     311        status = rpccli_samr_QueryGroupMember(pipe_cli, talloc_tos(),
    312312                                              &group_handle,
    313313                                              &rid_array);
    … …  
    321321        struct samr_Ids member_types;
    322322
    323         status = rpccli_samr_LookupRids(pipe_cli, ctx,
     323        status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
    324324                                        &domain_handle,
    325325                                        rid_array->count,
    … …  
    335335        for (i=0; i < rid_array->count; i++) {
    336336
    337                 status = rpccli_samr_DeleteGroupMember(pipe_cli, ctx,
     337                status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
    338338                                                       &group_handle,
    339339                                                       rid_array->rids[i]);
    … …  
    344344        }
    345345
    346         status = rpccli_samr_DeleteDomainGroup(pipe_cli, ctx,
     346        status = rpccli_samr_DeleteDomainGroup(pipe_cli, talloc_tos(),
    347347                                               &group_handle);
    348348        if (!NT_STATUS_IS_OK(status)) {
    … …  
    357357 done:
    358358        if (is_valid_policy_hnd(&group_handle)) {
    359                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     359                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    360360        }
    361361
    … …  
    428428        init_lsa_String(&lsa_group_name, r->in.group_name);
    429429
    430         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     430        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    431431                                         &domain_handle,
    432432                                         1,
    … …  
    444444        }
    445445
    446         status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     446        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    447447                                       &domain_handle,
    448448                                       SAMR_GROUP_ACCESS_SET_INFO |
    … …  
    459459                        g0 = (struct GROUP_INFO_0 *)r->in.buffer;
    460460                        init_lsa_String(&info.name, g0->grpi0_name);
    461                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     461                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    462462                                                          &group_handle,
    463463                                                          GROUPINFONAME,
    … …  
    467467                        g1 = (struct GROUP_INFO_1 *)r->in.buffer;
    468468                        init_lsa_String(&info.description, g1->grpi1_comment);
    469                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     469                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    470470                                                          &group_handle,
    471471                                                          GROUPINFODESCRIPTION,
    … …  
    475475                        g2 = (struct GROUP_INFO_2 *)r->in.buffer;
    476476                        init_lsa_String(&info.description, g2->grpi2_comment);
    477                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     477                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    478478                                                          &group_handle,
    479479                                                          GROUPINFODESCRIPTION,
    … …  
    484484                        }
    485485                        info.attributes.attributes = g2->grpi2_attributes;
    486                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     486                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    487487                                                          &group_handle,
    488488                                                          GROUPINFOATTRIBUTES,
    … …  
    492492                        g3 = (struct GROUP_INFO_3 *)r->in.buffer;
    493493                        init_lsa_String(&info.description, g3->grpi3_comment);
    494                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     494                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    495495                                                          &group_handle,
    496496                                                          GROUPINFODESCRIPTION,
    … …  
    501501                        }
    502502                        info.attributes.attributes = g3->grpi3_attributes;
    503                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     503                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    504504                                                          &group_handle,
    505505                                                          GROUPINFOATTRIBUTES,
    … …  
    509509                        g1002 = (struct GROUP_INFO_1002 *)r->in.buffer;
    510510                        init_lsa_String(&info.description, g1002->grpi1002_comment);
    511                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     511                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    512512                                                          &group_handle,
    513513                                                          GROUPINFODESCRIPTION,
    … …  
    517517                        g1005 = (struct GROUP_INFO_1005 *)r->in.buffer;
    518518                        info.attributes.attributes = g1005->grpi1005_attributes;
    519                         status = rpccli_samr_SetGroupInfo(pipe_cli, ctx,
     519                        status = rpccli_samr_SetGroupInfo(pipe_cli, talloc_tos(),
    520520                                                          &group_handle,
    521521                                                          GROUPINFOATTRIBUTES,
    … …  
    536536 done:
    537537        if (is_valid_policy_hnd(&group_handle)) {
    538                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     538                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    539539        }
    540540
    … …  
    663663        init_lsa_String(&lsa_group_name, r->in.group_name);
    664664
    665         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     665        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    666666                                         &domain_handle,
    667667                                         1,
    … …  
    679679        }
    680680
    681         status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     681        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    682682                                       &domain_handle,
    683683                                       SAMR_GROUP_ACCESS_LOOKUP_INFO,
    … …  
    689689        }
    690690
    691         status = rpccli_samr_QueryGroupInfo(pipe_cli, ctx,
     691        status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
    692692                                            &group_handle,
    693693                                            GROUPINFOALL2,
    694694                                            &info);
    695695        if (NT_STATUS_EQUAL(status, NT_STATUS_INVALID_INFO_CLASS)) {
    696                 status = rpccli_samr_QueryGroupInfo(pipe_cli, ctx,
     696                status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
    697697                                                    &group_handle,
    698698                                                    GROUPINFOALL,
    … …  
    715715 done:
    716716        if (is_valid_policy_hnd(&group_handle)) {
    717                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     717                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    718718        }
    719719
    … …  
    779779        init_lsa_String(&lsa_group_name, r->in.group_name);
    780780
    781         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     781        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    782782                                         &domain_handle,
    783783                                         1,
    … …  
    795795        }
    796796
    797         status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     797        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    798798                                       &domain_handle,
    799799                                       SAMR_GROUP_ACCESS_ADD_MEMBER,
    … …  
    807807        init_lsa_String(&lsa_user_name, r->in.user_name);
    808808
    809         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     809        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    810810                                         &domain_handle,
    811811                                         1,
    … …  
    823823        }
    824824
    825         status = rpccli_samr_AddGroupMember(pipe_cli, ctx,
     825        status = rpccli_samr_AddGroupMember(pipe_cli, talloc_tos(),
    826826                                            &group_handle,
    827827                                            rids.ids[0],
    … …  
    836836 done:
    837837        if (is_valid_policy_hnd(&group_handle)) {
    838                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     838                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    839839        }
    840840
    … …  
    900900        init_lsa_String(&lsa_group_name, r->in.group_name);
    901901
    902         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     902        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    903903                                         &domain_handle,
    904904                                         1,
    … …  
    916916        }
    917917
    918         status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     918        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    919919                                       &domain_handle,
    920920                                       SAMR_GROUP_ACCESS_REMOVE_MEMBER,
    … …  
    928928        init_lsa_String(&lsa_user_name, r->in.user_name);
    929929
    930         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     930        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    931931                                         &domain_handle,
    932932                                         1,
    … …  
    944944        }
    945945
    946         status = rpccli_samr_DeleteGroupMember(pipe_cli, ctx,
     946        status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
    947947                                               &group_handle,
    948948                                               rids.ids[0]);
    … …  
    956956 done:
    957957        if (is_valid_policy_hnd(&group_handle)) {
    958                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     958                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    959959        }
    960960
    … …  
    11781178        }
    11791179
    1180         status = rpccli_samr_QueryDomainInfo(pipe_cli, ctx,
     1180        status = rpccli_samr_QueryDomainInfo(pipe_cli, talloc_tos(),
    11811181                                             &domain_handle,
    11821182                                             2,
    … …  
    13091309        init_lsa_String(&lsa_account_name, r->in.group_name);
    13101310
    1311         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     1311        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    13121312                                         &domain_handle,
    13131313                                         1,
    … …  
    13201320        }
    13211321
    1322         status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     1322        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    13231323                                       &domain_handle,
    13241324                                       SAMR_GROUP_ACCESS_GET_MEMBERS,
    … …  
    13301330        }
    13311331
    1332         status = rpccli_samr_QueryGroupMember(pipe_cli, ctx,
     1332        status = rpccli_samr_QueryGroupMember(pipe_cli, talloc_tos(),
    13331333                                              &group_handle,
    13341334                                              &rid_array);
    … …  
    13381338        }
    13391339
    1340         status = rpccli_samr_LookupRids(pipe_cli, ctx,
     1340        status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
    13411341                                        &domain_handle,
    13421342                                        rid_array->count,
    … …  
    13741374 done:
    13751375        if (is_valid_policy_hnd(&group_handle)) {
    1376                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     1376                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    13771377        }
    13781378
    … …  
    14611461        init_lsa_String(&lsa_account_name, r->in.group_name);
    14621462
    1463         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     1463        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    14641464                                         &domain_handle,
    14651465                                         1,
    … …  
    14721472        }
    14731473
    1474         status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     1474        status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    14751475                                       &domain_handle,
    14761476                                       SAMR_GROUP_ACCESS_GET_MEMBERS |
    … …  
    14851485        }
    14861486
    1487         status = rpccli_samr_QueryGroupInfo(pipe_cli, ctx,
     1487        status = rpccli_samr_QueryGroupInfo(pipe_cli, talloc_tos(),
    14881488                                            &group_handle,
    14891489                                            GROUPINFOATTRIBUTES,
    … …  
    15231523        }
    15241524
    1525         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     1525        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    15261526                                         &domain_handle,
    15271527                                         r->in.num_entries,
    … …  
    15371537        num_member_rids = user_rids.count;
    15381538
    1539         status = rpccli_samr_QueryGroupMember(pipe_cli, ctx,
     1539        status = rpccli_samr_QueryGroupMember(pipe_cli, talloc_tos(),
    15401540                                              &group_handle,
    15411541                                              &rid_array);
    … …  
    15881588
    15891589        for (i=0; i < num_add_rids; i++) {
    1590                 status = rpccli_samr_AddGroupMember(pipe_cli, ctx,
     1590                status = rpccli_samr_AddGroupMember(pipe_cli, talloc_tos(),
    15911591                                                    &group_handle,
    15921592                                                    add_rids[i],
    … …  
    16011601
    16021602        for (i=0; i < num_del_rids; i++) {
    1603                 status = rpccli_samr_DeleteGroupMember(pipe_cli, ctx,
     1603                status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
    16041604                                                       &group_handle,
    16051605                                                       del_rids[i]);
    … …  
    16141614 done:
    16151615        if (is_valid_policy_hnd(&group_handle)) {
    1616                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     1616                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    16171617        }
    16181618

  • vendor/current/source3/lib/netapi/joindomain.c

    r414 r594  
    123123        old_timeout = rpccli_set_timeout(pipe_cli, 600000);
    124124
    125         status = rpccli_wkssvc_NetrJoinDomain2(pipe_cli, ctx,
     125        status = rpccli_wkssvc_NetrJoinDomain2(pipe_cli, talloc_tos(),
    126126                                               r->in.server,
    127127                                               r->in.domain,
    … …  
    249249        old_timeout = rpccli_set_timeout(pipe_cli, 60000);
    250250
    251         status = rpccli_wkssvc_NetrUnjoinDomain2(pipe_cli, ctx,
     251        status = rpccli_wkssvc_NetrUnjoinDomain2(pipe_cli, talloc_tos(),
    252252                                                 r->in.server_name,
    253253                                                 r->in.account,
    … …  
    286286        }
    287287
    288         status = rpccli_wkssvc_NetrGetJoinInformation(pipe_cli, ctx,
     288        status = rpccli_wkssvc_NetrGetJoinInformation(pipe_cli, talloc_tos(),
    289289                                                      r->in.server_name,
    290290                                                      &buffer,
    … …  
    423423        }
    424424
    425         status = rpccli_wkssvc_NetrGetJoinableOus2(pipe_cli, ctx,
     425        status = rpccli_wkssvc_NetrGetJoinableOus2(pipe_cli, talloc_tos(),
    426426                                                   r->in.server_name,
    427427                                                   r->in.domain,
    … …  
    465465        }
    466466
    467         status = rpccli_wkssvc_NetrRenameMachineInDomain2(pipe_cli, ctx,
     467        status = rpccli_wkssvc_NetrRenameMachineInDomain2(pipe_cli, talloc_tos(),
    468468                                                          r->in.server_name,
    469469                                                          r->in.new_machine_name,

  • vendor/current/source3/lib/netapi/libnetapi.c

    r414 r594  
    4040        NET_API_STATUS status;
    4141        WERROR werr;
    42 
    43         status = libnetapi_getctx(&ctx);
    44         if (status != 0) {
     42        TALLOC_CTX *frame = talloc_stackframe();
     43
     44        status = libnetapi_getctx(&ctx);
     45        if (status != 0) {
     46                TALLOC_FREE(frame);
    4547                return status;
    4648        }
    … …  
    7274        }
    7375
     76        TALLOC_FREE(frame);
    7477        return r.out.result;
    7578}
    … …  
    8891        NET_API_STATUS status;
    8992        WERROR werr;
    90 
    91         status = libnetapi_getctx(&ctx);
    92         if (status != 0) {
     93        TALLOC_CTX *frame = talloc_stackframe();
     94
     95        status = libnetapi_getctx(&ctx);
     96        if (status != 0) {
     97                TALLOC_FREE(frame);
    9398                return status;
    9499        }
    … …  
    118123        }
    119124
     125        TALLOC_FREE(frame);
    120126        return r.out.result;
    121127}
    … …  
    133139        NET_API_STATUS status;
    134140        WERROR werr;
    135 
    136         status = libnetapi_getctx(&ctx);
    137         if (status != 0) {
     141        TALLOC_CTX *frame = talloc_stackframe();
     142
     143        status = libnetapi_getctx(&ctx);
     144        if (status != 0) {
     145                TALLOC_FREE(frame);
    138146                return status;
    139147        }
    … …  
    162170        }
    163171
     172        TALLOC_FREE(frame);
    164173        return r.out.result;
    165174}
    … …  
    180189        NET_API_STATUS status;
    181190        WERROR werr;
    182 
    183         status = libnetapi_getctx(&ctx);
    184         if (status != 0) {
     191        TALLOC_CTX *frame = talloc_stackframe();
     192
     193        status = libnetapi_getctx(&ctx);
     194        if (status != 0) {
     195                TALLOC_FREE(frame);
    185196                return status;
    186197        }
    … …  
    212223        }
    213224
     225        TALLOC_FREE(frame);
    214226        return r.out.result;
    215227}
    … …  
    229241        NET_API_STATUS status;
    230242        WERROR werr;
    231 
    232         status = libnetapi_getctx(&ctx);
    233         if (status != 0) {
     243        TALLOC_CTX *frame = talloc_stackframe();
     244
     245        status = libnetapi_getctx(&ctx);
     246        if (status != 0) {
     247                TALLOC_FREE(frame);
    234248                return status;
    235249        }
    … …  
    260274        }
    261275
     276        TALLOC_FREE(frame);
    262277        return r.out.result;
    263278}
    … …  
    275290        NET_API_STATUS status;
    276291        WERROR werr;
    277 
    278         status = libnetapi_getctx(&ctx);
    279         if (status != 0) {
     292        TALLOC_CTX *frame = talloc_stackframe();
     293
     294        status = libnetapi_getctx(&ctx);
     295        if (status != 0) {
     296                TALLOC_FREE(frame);
    280297                return status;
    281298        }
    … …  
    304321        }
    305322
     323        TALLOC_FREE(frame);
    306324        return r.out.result;
    307325}
    … …  
    320338        NET_API_STATUS status;
    321339        WERROR werr;
    322 
    323         status = libnetapi_getctx(&ctx);
    324         if (status != 0) {
     340        TALLOC_CTX *frame = talloc_stackframe();
     341
     342        status = libnetapi_getctx(&ctx);
     343        if (status != 0) {
     344                TALLOC_FREE(frame);
    325345                return status;
    326346        }
    … …  
    350370        }
    351371
     372        TALLOC_FREE(frame);
    352373        return r.out.result;
    353374}
    … …  
    365386        NET_API_STATUS status;
    366387        WERROR werr;
    367 
    368         status = libnetapi_getctx(&ctx);
    369         if (status != 0) {
     388        TALLOC_CTX *frame = talloc_stackframe();
     389
     390        status = libnetapi_getctx(&ctx);
     391        if (status != 0) {
     392                TALLOC_FREE(frame);
    370393                return status;
    371394        }
    … …  
    394417        }
    395418
     419        TALLOC_FREE(frame);
    396420        return r.out.result;
    397421}
    … …  
    409433        NET_API_STATUS status;
    410434        WERROR werr;
    411 
    412         status = libnetapi_getctx(&ctx);
    413         if (status != 0) {
     435        TALLOC_CTX *frame = talloc_stackframe();
     436
     437        status = libnetapi_getctx(&ctx);
     438        if (status != 0) {
     439                TALLOC_FREE(frame);
    414440                return status;
    415441        }
    … …  
    438464        }
    439465
     466        TALLOC_FREE(frame);
    440467        return r.out.result;
    441468}
    … …  
    456483        NET_API_STATUS status;
    457484        WERROR werr;
    458 
    459         status = libnetapi_getctx(&ctx);
    460         if (status != 0) {
     485        TALLOC_CTX *frame = talloc_stackframe();
     486
     487        status = libnetapi_getctx(&ctx);
     488        if (status != 0) {
     489                TALLOC_FREE(frame);
    461490                return status;
    462491        }
    … …  
    488517        }
    489518
     519        TALLOC_FREE(frame);
    490520        return r.out.result;
    491521}
    … …  
    504534        NET_API_STATUS status;
    505535        WERROR werr;
    506 
    507         status = libnetapi_getctx(&ctx);
    508         if (status != 0) {
     536        TALLOC_CTX *frame = talloc_stackframe();
     537
     538        status = libnetapi_getctx(&ctx);
     539        if (status != 0) {
     540                TALLOC_FREE(frame);
    509541                return status;
    510542        }
    … …  
    534566        }
    535567
     568        TALLOC_FREE(frame);
    536569        return r.out.result;
    537570}
    … …  
    548581        NET_API_STATUS status;
    549582        WERROR werr;
    550 
    551         status = libnetapi_getctx(&ctx);
    552         if (status != 0) {
     583        TALLOC_CTX *frame = talloc_stackframe();
     584
     585        status = libnetapi_getctx(&ctx);
     586        if (status != 0) {
     587                TALLOC_FREE(frame);
    553588                return status;
    554589        }
    … …  
    576611        }
    577612
     613        TALLOC_FREE(frame);
    578614        return r.out.result;
    579615}
    … …  
    596632        NET_API_STATUS status;
    597633        WERROR werr;
    598 
    599         status = libnetapi_getctx(&ctx);
    600         if (status != 0) {
     634        TALLOC_CTX *frame = talloc_stackframe();
     635
     636        status = libnetapi_getctx(&ctx);
     637        if (status != 0) {
     638                TALLOC_FREE(frame);
    601639                return status;
    602640        }
    … …  
    631669        }
    632670
     671        TALLOC_FREE(frame);
    633672        return r.out.result;
    634673}
    … …  
    647686        NET_API_STATUS status;
    648687        WERROR werr;
    649 
    650         status = libnetapi_getctx(&ctx);
    651         if (status != 0) {
     688        TALLOC_CTX *frame = talloc_stackframe();
     689
     690        status = libnetapi_getctx(&ctx);
     691        if (status != 0) {
     692                TALLOC_FREE(frame);
    652693                return status;
    653694        }
    … …  
    677718        }
    678719
     720        TALLOC_FREE(frame);
    679721        return r.out.result;
    680722}
    … …  
    693735        NET_API_STATUS status;
    694736        WERROR werr;
    695 
    696         status = libnetapi_getctx(&ctx);
    697         if (status != 0) {
     737        TALLOC_CTX *frame = talloc_stackframe();
     738
     739        status = libnetapi_getctx(&ctx);
     740        if (status != 0) {
     741                TALLOC_FREE(frame);
    698742                return status;
    699743        }
    … …  
    723767        }
    724768
     769        TALLOC_FREE(frame);
    725770        return r.out.result;
    726771}
    … …  
    740785        NET_API_STATUS status;
    741786        WERROR werr;
    742 
    743         status = libnetapi_getctx(&ctx);
    744         if (status != 0) {
     787        TALLOC_CTX *frame = talloc_stackframe();
     788
     789        status = libnetapi_getctx(&ctx);
     790        if (status != 0) {
     791                TALLOC_FREE(frame);
    745792                return status;
    746793        }
    … …  
    771818        }
    772819
     820        TALLOC_FREE(frame);
    773821        return r.out.result;
    774822}
    … …  
    790838        NET_API_STATUS status;
    791839        WERROR werr;
    792 
    793         status = libnetapi_getctx(&ctx);
    794         if (status != 0) {
     840        TALLOC_CTX *frame = talloc_stackframe();
     841
     842        status = libnetapi_getctx(&ctx);
     843        if (status != 0) {
     844                TALLOC_FREE(frame);
    795845                return status;
    796846        }
    … …  
    823873        }
    824874
     875        TALLOC_FREE(frame);
    825876        return r.out.result;
    826877}
    … …  
    840891        NET_API_STATUS status;
    841892        WERROR werr;
    842 
    843         status = libnetapi_getctx(&ctx);
    844         if (status != 0) {
     893        TALLOC_CTX *frame = talloc_stackframe();
     894
     895        status = libnetapi_getctx(&ctx);
     896        if (status != 0) {
     897                TALLOC_FREE(frame);
    845898                return status;
    846899        }
    … …  
    871924        }
    872925
     926        TALLOC_FREE(frame);
    873927        return r.out.result;
    874928}
    … …  
    891945        NET_API_STATUS status;
    892946        WERROR werr;
    893 
    894         status = libnetapi_getctx(&ctx);
    895         if (status != 0) {
     947        TALLOC_CTX *frame = talloc_stackframe();
     948
     949        status = libnetapi_getctx(&ctx);
     950        if (status != 0) {
     951                TALLOC_FREE(frame);
    896952                return status;
    897953        }
    … …  
    925981        }
    926982
     983        TALLOC_FREE(frame);
    927984        return r.out.result;
    928985}
    … …  
    940997        NET_API_STATUS status;
    941998        WERROR werr;
    942 
    943         status = libnetapi_getctx(&ctx);
    944         if (status != 0) {
     999        TALLOC_CTX *frame = talloc_stackframe();
     1000
     1001        status = libnetapi_getctx(&ctx);
     1002        if (status != 0) {
     1003                TALLOC_FREE(frame);
    9451004                return status;
    9461005        }
    … …  
    9691028        }
    9701029
     1030        TALLOC_FREE(frame);
    9711031        return r.out.result;
    9721032}
    … …  
    9851045        NET_API_STATUS status;
    9861046        WERROR werr;
    987 
    988         status = libnetapi_getctx(&ctx);
    989         if (status != 0) {
     1047        TALLOC_CTX *frame = talloc_stackframe();
     1048
     1049        status = libnetapi_getctx(&ctx);
     1050        if (status != 0) {
     1051                TALLOC_FREE(frame);
    9901052                return status;
    9911053        }
    … …  
    10151077        }
    10161078
     1079        TALLOC_FREE(frame);
    10171080        return r.out.result;
    10181081}
    … …  
    10341097        NET_API_STATUS status;
    10351098        WERROR werr;
    1036 
    1037         status = libnetapi_getctx(&ctx);
    1038         if (status != 0) {
     1099        TALLOC_CTX *frame = talloc_stackframe();
     1100
     1101        status = libnetapi_getctx(&ctx);
     1102        if (status != 0) {
     1103                TALLOC_FREE(frame);
    10391104                return status;
    10401105        }
    … …  
    10671132        }
    10681133
     1134        TALLOC_FREE(frame);
    10691135        return r.out.result;
    10701136}
    … …  
    10831149        NET_API_STATUS status;
    10841150        WERROR werr;
    1085 
    1086         status = libnetapi_getctx(&ctx);
    1087         if (status != 0) {
     1151        TALLOC_CTX *frame = talloc_stackframe();
     1152
     1153        status = libnetapi_getctx(&ctx);
     1154        if (status != 0) {
     1155                TALLOC_FREE(frame);
    10881156                return status;
    10891157        }
    … …  
    11131181        }
    11141182
     1183        TALLOC_FREE(frame);
    11151184        return r.out.result;
    11161185}
    … …  
    11271196        NET_API_STATUS status;
    11281197        WERROR werr;
    1129 
    1130         status = libnetapi_getctx(&ctx);
    1131         if (status != 0) {
     1198        TALLOC_CTX *frame = talloc_stackframe();
     1199
     1200        status = libnetapi_getctx(&ctx);
     1201        if (status != 0) {
     1202                TALLOC_FREE(frame);
    11321203                return status;
    11331204        }
    … …  
    11551226        }
    11561227
     1228        TALLOC_FREE(frame);
    11571229        return r.out.result;
    11581230}
    … …  
    11741246        NET_API_STATUS status;
    11751247        WERROR werr;
    1176 
    1177         status = libnetapi_getctx(&ctx);
    1178         if (status != 0) {
     1248        TALLOC_CTX *frame = talloc_stackframe();
     1249
     1250        status = libnetapi_getctx(&ctx);
     1251        if (status != 0) {
     1252                TALLOC_FREE(frame);
    11791253                return status;
    11801254        }
    … …  
    12081282        }
    12091283
     1284        TALLOC_FREE(frame);
    12101285        return r.out.result;
    12111286}
    … …  
    12251300        NET_API_STATUS status;
    12261301        WERROR werr;
    1227 
    1228         status = libnetapi_getctx(&ctx);
    1229         if (status != 0) {
     1302        TALLOC_CTX *frame = talloc_stackframe();
     1303
     1304        status = libnetapi_getctx(&ctx);
     1305        if (status != 0) {
     1306                TALLOC_FREE(frame);
    12301307                return status;
    12311308        }
    … …  
    12561333        }
    12571334
     1335        TALLOC_FREE(frame);
    12581336        return r.out.result;
    12591337}
    … …  
    12721350        NET_API_STATUS status;
    12731351        WERROR werr;
    1274 
    1275         status = libnetapi_getctx(&ctx);
    1276         if (status != 0) {
     1352        TALLOC_CTX *frame = talloc_stackframe();
     1353
     1354        status = libnetapi_getctx(&ctx);
     1355        if (status != 0) {
     1356                TALLOC_FREE(frame);
    12771357                return status;
    12781358        }
    … …  
    13021382        }
    13031383
     1384        TALLOC_FREE(frame);
    13041385        return r.out.result;
    13051386}
    … …  
    13171398        NET_API_STATUS status;
    13181399        WERROR werr;
    1319 
    1320         status = libnetapi_getctx(&ctx);
    1321         if (status != 0) {
     1400        TALLOC_CTX *frame = talloc_stackframe();
     1401
     1402        status = libnetapi_getctx(&ctx);
     1403        if (status != 0) {
     1404                TALLOC_FREE(frame);
    13221405                return status;
    13231406        }
    … …  
    13461429        }
    13471430
     1431        TALLOC_FREE(frame);
    13481432        return r.out.result;
    13491433}
    … …  
    13611445        NET_API_STATUS status;
    13621446        WERROR werr;
    1363 
    1364         status = libnetapi_getctx(&ctx);
    1365         if (status != 0) {
     1447        TALLOC_CTX *frame = talloc_stackframe();
     1448
     1449        status = libnetapi_getctx(&ctx);
     1450        if (status != 0) {
     1451                TALLOC_FREE(frame);
    13661452                return status;
    13671453        }
    … …  
    13901476        }
    13911477
     1478        TALLOC_FREE(frame);
    13921479        return r.out.result;
    13931480}
    … …  
    14101497        NET_API_STATUS status;
    14111498        WERROR werr;
    1412 
    1413         status = libnetapi_getctx(&ctx);
    1414         if (status != 0) {
     1499        TALLOC_CTX *frame = talloc_stackframe();
     1500
     1501        status = libnetapi_getctx(&ctx);
     1502        if (status != 0) {
     1503                TALLOC_FREE(frame);
    14151504                return status;
    14161505        }
    … …  
    14451534        }
    14461535
     1536        TALLOC_FREE(frame);
    14471537        return r.out.result;
    14481538}
    … …  
    14621552        NET_API_STATUS status;
    14631553        WERROR werr;
    1464 
    1465         status = libnetapi_getctx(&ctx);
    1466         if (status != 0) {
     1554        TALLOC_CTX *frame = talloc_stackframe();
     1555
     1556        status = libnetapi_getctx(&ctx);
     1557        if (status != 0) {
     1558                TALLOC_FREE(frame);
    14671559                return status;
    14681560        }
    … …  
    14931585        }
    14941586
     1587        TALLOC_FREE(frame);
    14951588        return r.out.result;
    14961589}
    … …  
    15091602        NET_API_STATUS status;
    15101603        WERROR werr;
    1511 
    1512         status = libnetapi_getctx(&ctx);
    1513         if (status != 0) {
     1604        TALLOC_CTX *frame = talloc_stackframe();
     1605
     1606        status = libnetapi_getctx(&ctx);
     1607        if (status != 0) {
     1608                TALLOC_FREE(frame);
    15141609                return status;
    15151610        }
    … …  
    15391634        }
    15401635
     1636        TALLOC_FREE(frame);
    15411637        return r.out.result;
    15421638}
    … …  
    15531649        NET_API_STATUS status;
    15541650        WERROR werr;
    1555 
    1556         status = libnetapi_getctx(&ctx);
    1557         if (status != 0) {
     1651        TALLOC_CTX *frame = talloc_stackframe();
     1652
     1653        status = libnetapi_getctx(&ctx);
     1654        if (status != 0) {
     1655                TALLOC_FREE(frame);
    15581656                return status;
    15591657        }
    … …  
    15811679        }
    15821680
     1681        TALLOC_FREE(frame);
    15831682        return r.out.result;
    15841683}
    … …  
    15971696        NET_API_STATUS status;
    15981697        WERROR werr;
    1599 
    1600         status = libnetapi_getctx(&ctx);
    1601         if (status != 0) {
     1698        TALLOC_CTX *frame = talloc_stackframe();
     1699
     1700        status = libnetapi_getctx(&ctx);
     1701        if (status != 0) {
     1702                TALLOC_FREE(frame);
    16021703                return status;
    16031704        }
    … …  
    16271728        }
    16281729
     1730        TALLOC_FREE(frame);
    16291731        return r.out.result;
    16301732}
    … …  
    16441746        NET_API_STATUS status;
    16451747        WERROR werr;
    1646 
    1647         status = libnetapi_getctx(&ctx);
    1648         if (status != 0) {
     1748        TALLOC_CTX *frame = talloc_stackframe();
     1749
     1750        status = libnetapi_getctx(&ctx);
     1751        if (status != 0) {
     1752                TALLOC_FREE(frame);
    16491753                return status;
    16501754        }
    … …  
    16751779        }
    16761780
     1781        TALLOC_FREE(frame);
    16771782        return r.out.result;
    16781783}
    … …  
    16941799        NET_API_STATUS status;
    16951800        WERROR werr;
    1696 
    1697         status = libnetapi_getctx(&ctx);
    1698         if (status != 0) {
     1801        TALLOC_CTX *frame = talloc_stackframe();
     1802
     1803        status = libnetapi_getctx(&ctx);
     1804        if (status != 0) {
     1805                TALLOC_FREE(frame);
    16991806                return status;
    17001807        }
    … …  
    17281835        }
    17291836
     1837        TALLOC_FREE(frame);
    17301838        return r.out.result;
    17311839}
    … …  
    17451853        NET_API_STATUS status;
    17461854        WERROR werr;
    1747 
    1748         status = libnetapi_getctx(&ctx);
    1749         if (status != 0) {
     1855        TALLOC_CTX *frame = talloc_stackframe();
     1856
     1857        status = libnetapi_getctx(&ctx);
     1858        if (status != 0) {
     1859                TALLOC_FREE(frame);
    17501860                return status;
    17511861        }
    … …  
    17761886        }
    17771887
     1888        TALLOC_FREE(frame);
    17781889        return r.out.result;
    17791890}
    … …  
    17931904        NET_API_STATUS status;
    17941905        WERROR werr;
    1795 
    1796         status = libnetapi_getctx(&ctx);
    1797         if (status != 0) {
     1906        TALLOC_CTX *frame = talloc_stackframe();
     1907
     1908        status = libnetapi_getctx(&ctx);
     1909        if (status != 0) {
     1910                TALLOC_FREE(frame);
    17981911                return status;
    17991912        }
    … …  
    18241937        }
    18251938
     1939        TALLOC_FREE(frame);
    18261940        return r.out.result;
    18271941}
    … …  
    18441958        NET_API_STATUS status;
    18451959        WERROR werr;
    1846 
    1847         status = libnetapi_getctx(&ctx);
    1848         if (status != 0) {
     1960        TALLOC_CTX *frame = talloc_stackframe();
     1961
     1962        status = libnetapi_getctx(&ctx);
     1963        if (status != 0) {
     1964                TALLOC_FREE(frame);
    18491965                return status;
    18501966        }
    … …  
    18791995        }
    18801996
     1997        TALLOC_FREE(frame);
    18811998        return r.out.result;
    18821999}
    … …  
    18962013        NET_API_STATUS status;
    18972014        WERROR werr;
    1898 
    1899         status = libnetapi_getctx(&ctx);
    1900         if (status != 0) {
     2015        TALLOC_CTX *frame = talloc_stackframe();
     2016
     2017        status = libnetapi_getctx(&ctx);
     2018        if (status != 0) {
     2019                TALLOC_FREE(frame);
    19012020                return status;
    19022021        }
    … …  
    19272046        }
    19282047
     2048        TALLOC_FREE(frame);
    19292049        return r.out.result;
    19302050}
    … …  
    19412061        NET_API_STATUS status;
    19422062        WERROR werr;
    1943 
    1944         status = libnetapi_getctx(&ctx);
    1945         if (status != 0) {
     2063        TALLOC_CTX *frame = talloc_stackframe();
     2064
     2065        status = libnetapi_getctx(&ctx);
     2066        if (status != 0) {
     2067                TALLOC_FREE(frame);
    19462068                return status;
    19472069        }
    … …  
    19692091        }
    19702092
     2093        TALLOC_FREE(frame);
    19712094        return r.out.result;
    19722095}
    … …  
    19852108        NET_API_STATUS status;
    19862109        WERROR werr;
    1987 
    1988         status = libnetapi_getctx(&ctx);
    1989         if (status != 0) {
     2110        TALLOC_CTX *frame = talloc_stackframe();
     2111
     2112        status = libnetapi_getctx(&ctx);
     2113        if (status != 0) {
     2114                TALLOC_FREE(frame);
    19902115                return status;
    19912116        }
    … …  
    20152140        }
    20162141
     2142        TALLOC_FREE(frame);
    20172143        return r.out.result;
    20182144}
    … …  
    20302156        NET_API_STATUS status;
    20312157        WERROR werr;
    2032 
    2033         status = libnetapi_getctx(&ctx);
    2034         if (status != 0) {
     2158        TALLOC_CTX *frame = talloc_stackframe();
     2159
     2160        status = libnetapi_getctx(&ctx);
     2161        if (status != 0) {
     2162                TALLOC_FREE(frame);
    20352163                return status;
    20362164        }
    … …  
    20592187        }
    20602188
     2189        TALLOC_FREE(frame);
    20612190        return r.out.result;
    20622191}
    … …  
    20782207        NET_API_STATUS status;
    20792208        WERROR werr;
    2080 
    2081         status = libnetapi_getctx(&ctx);
    2082         if (status != 0) {
     2209        TALLOC_CTX *frame = talloc_stackframe();
     2210
     2211        status = libnetapi_getctx(&ctx);
     2212        if (status != 0) {
     2213                TALLOC_FREE(frame);
    20832214                return status;
    20842215        }
    … …  
    21122243        }
    21132244
     2245        TALLOC_FREE(frame);
    21142246        return r.out.result;
    21152247}
    … …  
    21282260        NET_API_STATUS status;
    21292261        WERROR werr;
    2130 
    2131         status = libnetapi_getctx(&ctx);
    2132         if (status != 0) {
     2262        TALLOC_CTX *frame = talloc_stackframe();
     2263
     2264        status = libnetapi_getctx(&ctx);
     2265        if (status != 0) {
     2266                TALLOC_FREE(frame);
    21332267                return status;
    21342268        }
    … …  
    21582292        }
    21592293
     2294        TALLOC_FREE(frame);
    21602295        return r.out.result;
    21612296}
    … …  
    21752310        NET_API_STATUS status;
    21762311        WERROR werr;
    2177 
    2178         status = libnetapi_getctx(&ctx);
    2179         if (status != 0) {
     2312        TALLOC_CTX *frame = talloc_stackframe();
     2313
     2314        status = libnetapi_getctx(&ctx);
     2315        if (status != 0) {
     2316                TALLOC_FREE(frame);
    21802317                return status;
    21812318        }
    … …  
    22062343        }
    22072344
     2345        TALLOC_FREE(frame);
    22082346        return r.out.result;
    22092347}
    … …  
    22202358        NET_API_STATUS status;
    22212359        WERROR werr;
    2222 
    2223         status = libnetapi_getctx(&ctx);
    2224         if (status != 0) {
     2360        TALLOC_CTX *frame = talloc_stackframe();
     2361
     2362        status = libnetapi_getctx(&ctx);
     2363        if (status != 0) {
     2364                TALLOC_FREE(frame);
    22252365                return status;
    22262366        }
    … …  
    22482388        }
    22492389
     2390        TALLOC_FREE(frame);
    22502391        return r.out.result;
    22512392}
    … …  
    22642405        NET_API_STATUS status;
    22652406        WERROR werr;
    2266 
    2267         status = libnetapi_getctx(&ctx);
    2268         if (status != 0) {
     2407        TALLOC_CTX *frame = talloc_stackframe();
     2408
     2409        status = libnetapi_getctx(&ctx);
     2410        if (status != 0) {
     2411                TALLOC_FREE(frame);
    22692412                return status;
    22702413        }
    … …  
    22942437        }
    22952438
     2439        TALLOC_FREE(frame);
    22962440        return r.out.result;
    22972441}
    … …  
    23152459        NET_API_STATUS status;
    23162460        WERROR werr;
    2317 
    2318         status = libnetapi_getctx(&ctx);
    2319         if (status != 0) {
     2461        TALLOC_CTX *frame = talloc_stackframe();
     2462
     2463        status = libnetapi_getctx(&ctx);
     2464        if (status != 0) {
     2465                TALLOC_FREE(frame);
    23202466                return status;
    23212467        }
    … …  
    23512497        }
    23522498
     2499        TALLOC_FREE(frame);
    23532500        return r.out.result;
    23542501}
    … …  
    23682515        NET_API_STATUS status;
    23692516        WERROR werr;
    2370 
    2371         status = libnetapi_getctx(&ctx);
    2372         if (status != 0) {
     2517        TALLOC_CTX *frame = talloc_stackframe();
     2518
     2519        status = libnetapi_getctx(&ctx);
     2520        if (status != 0) {
     2521                TALLOC_FREE(frame);
    23732522                return status;
    23742523        }
    … …  
    23992548        }
    24002549
     2550        TALLOC_FREE(frame);
    24012551        return r.out.result;
    24022552}
    … …  
    24122562        NET_API_STATUS status;
    24132563        WERROR werr;
    2414 
    2415         status = libnetapi_getctx(&ctx);
    2416         if (status != 0) {
     2564        TALLOC_CTX *frame = talloc_stackframe();
     2565
     2566        status = libnetapi_getctx(&ctx);
     2567        if (status != 0) {
     2568                TALLOC_FREE(frame);
    24172569                return status;
    24182570        }
    … …  
    24392591        }
    24402592
     2593        TALLOC_FREE(frame);
    24412594        return r.out.result;
    24422595}
    … …  
    24552608        NET_API_STATUS status;
    24562609        WERROR werr;
    2457 
    2458         status = libnetapi_getctx(&ctx);
    2459         if (status != 0) {
     2610        TALLOC_CTX *frame = talloc_stackframe();
     2611
     2612        status = libnetapi_getctx(&ctx);
     2613        if (status != 0) {
     2614                TALLOC_FREE(frame);
    24602615                return status;
    24612616        }
    … …  
    24852640        }
    24862641
     2642        TALLOC_FREE(frame);
    24872643        return r.out.result;
    24882644}
    … …  
    25022658        NET_API_STATUS status;
    25032659        WERROR werr;
    2504 
    2505         status = libnetapi_getctx(&ctx);
    2506         if (status != 0) {
     2660        TALLOC_CTX *frame = talloc_stackframe();
     2661
     2662        status = libnetapi_getctx(&ctx);
     2663        if (status != 0) {
     2664                TALLOC_FREE(frame);
    25072665                return status;
    25082666        }
    … …  
    25332691        }
    25342692
    2535         return r.out.result;
    2536 }
    2537 
     2693        TALLOC_FREE(frame);
     2694        return r.out.result;
     2695}
     2696

  • vendor/current/source3/lib/netapi/localgroup.c

    r414 r594  
    197197        init_lsa_String(&lsa_account_name, alias_name);
    198198
    199         status = rpccli_samr_CreateDomAlias(pipe_cli, ctx,
     199        status = rpccli_samr_CreateDomAlias(pipe_cli, talloc_tos(),
    200200                                            &domain_handle,
    201201                                            &lsa_account_name,
    … …  
    215215                init_lsa_String(&alias_info.description, info1->lgrpi1_comment);
    216216
    217                 status = rpccli_samr_SetAliasInfo(pipe_cli, ctx,
     217                status = rpccli_samr_SetAliasInfo(pipe_cli, talloc_tos(),
    218218                                                  &alias_handle,
    219219                                                  ALIASINFODESCRIPTION,
    … …  
    229229 done:
    230230        if (is_valid_policy_hnd(&alias_handle)) {
    231                 rpccli_samr_Close(pipe_cli, ctx, &alias_handle);
     231                rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
    232232        }
    233233
    … …  
    332332
    333333 delete_alias:
    334         status = rpccli_samr_DeleteDomAlias(pipe_cli, ctx,
     334        status = rpccli_samr_DeleteDomAlias(pipe_cli, talloc_tos(),
    335335                                            &alias_handle);
    336336        if (!NT_STATUS_IS_OK(status)) {
    … …  
    345345 done:
    346346        if (is_valid_policy_hnd(&alias_handle)) {
    347                 rpccli_samr_Close(pipe_cli, ctx, &alias_handle);
     347                rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
    348348        }
    349349
    … …  
    503503
    504504 query_alias:
    505         status = rpccli_samr_QueryAliasInfo(pipe_cli, ctx,
     505        status = rpccli_samr_QueryAliasInfo(pipe_cli, talloc_tos(),
    506506                                            &alias_handle,
    507507                                            ALIASINFOALL,
    … …  
    520520 done:
    521521        if (is_valid_policy_hnd(&alias_handle)) {
    522                 rpccli_samr_Close(pipe_cli, ctx, &alias_handle);
     522                rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
    523523        }
    524524
    … …  
    681681        }
    682682
    683         status = rpccli_samr_SetAliasInfo(pipe_cli, ctx,
     683        status = rpccli_samr_SetAliasInfo(pipe_cli, talloc_tos(),
    684684                                          &alias_handle,
    685685                                          alias_level,
    … …  
    694694 done:
    695695        if (is_valid_policy_hnd(&alias_handle)) {
    696                 rpccli_samr_Close(pipe_cli, ctx, &alias_handle);
     696                rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
    697697        }
    698698
    … …  
    789789        }
    790790
    791         status = rpccli_samr_QueryDomainInfo(pipe_cli, ctx,
     791        status = rpccli_samr_QueryDomainInfo(pipe_cli, talloc_tos(),
    792792                                             &builtin_handle,
    793793                                             2,
    … …  
    802802        }
    803803
    804         status = rpccli_samr_QueryDomainInfo(pipe_cli, ctx,
     804        status = rpccli_samr_QueryDomainInfo(pipe_cli, talloc_tos(),
    805805                                             &domain_handle,
    806806                                             2,
    … …  
    815815        }
    816816
    817         status = rpccli_samr_EnumDomainAliases(pipe_cli, ctx,
     817        status = rpccli_samr_EnumDomainAliases(pipe_cli, talloc_tos(),
    818818                                               &builtin_handle,
    819819                                               r->in.resume_handle,
    … …  
    851851        }
    852852
    853         status = rpccli_samr_EnumDomainAliases(pipe_cli, ctx,
     853        status = rpccli_samr_EnumDomainAliases(pipe_cli, talloc_tos(),
    854854                                               &domain_handle,
    855855                                               r->in.resume_handle,
    … …  
    11571157                struct lsa_SidArray current_sids;
    11581158
    1159                 status = rpccli_samr_GetMembersInAlias(pipe_cli, ctx,
     1159                status = rpccli_samr_GetMembersInAlias(pipe_cli, talloc_tos(),
    11601160                                                       &alias_handle,
    11611161                                                       &current_sids);
    … …  
    12131213
    12141214        for (i=0; i < num_add_sids; i++) {
    1215                 status = rpccli_samr_AddAliasMember(pipe_cli, ctx,
     1215                status = rpccli_samr_AddAliasMember(pipe_cli, talloc_tos(),
    12161216                                                    &alias_handle,
    12171217                                                    &add_sids[i]);
    … …  
    12251225
    12261226        for (i=0; i < num_del_sids; i++) {
    1227                 status = rpccli_samr_DeleteAliasMember(pipe_cli, ctx,
     1227                status = rpccli_samr_DeleteAliasMember(pipe_cli, talloc_tos(),
    12281228                                                       &alias_handle,
    12291229                                                       &del_sids[i]);
    … …  
    12381238 done:
    12391239        if (is_valid_policy_hnd(&alias_handle)) {
    1240                 rpccli_samr_Close(pipe_cli, ctx, &alias_handle);
     1240                rpccli_samr_Close(pipe_cli, talloc_tos(), &alias_handle);
    12411241        }
    12421242

  • vendor/current/source3/lib/netapi/netlogon.c

    r414 r594  
    137137        }
    138138
    139         status = rpccli_netr_LogonControl(pipe_cli, ctx,
     139        status = rpccli_netr_LogonControl(pipe_cli, talloc_tos(),
    140140                                          r->in.server_name,
    141141                                          r->in.function_code,
    … …  
    194194        case NETLOGON_CONTROL_TC_VERIFY:
    195195        case NETLOGON_CONTROL_SET_DBFLAG:
    196                 status = rpccli_netr_LogonControl2Ex(pipe_cli, ctx,
     196                status = rpccli_netr_LogonControl2Ex(pipe_cli, talloc_tos(),
    197197                                                     r->in.server_name,
    198198                                                     r->in.function_code,
    … …  
    203203                break;
    204204        default:
    205                 status = rpccli_netr_LogonControl2(pipe_cli, ctx,
     205                status = rpccli_netr_LogonControl2(pipe_cli, talloc_tos(),
    206206                                                   r->in.server_name,
    207207                                                   r->in.function_code,

  • vendor/current/source3/lib/netapi/serverinfo.c

    r414 r594  
    509509        }
    510510
    511         status = rpccli_srvsvc_NetSrvGetInfo(pipe_cli, ctx,
     511        status = rpccli_srvsvc_NetSrvGetInfo(pipe_cli, talloc_tos(),
    512512                                             r->in.server_name,
    513513                                             r->in.level,
    … …  
    615615        }
    616616
    617         status = rpccli_srvsvc_NetSrvSetInfo(pipe_cli, ctx,
     617        status = rpccli_srvsvc_NetSrvSetInfo(pipe_cli, talloc_tos(),
    618618                                             r->in.server_name,
    619619                                             r->in.level,
    … …  
    648648        }
    649649
    650         status = rpccli_srvsvc_NetRemoteTOD(pipe_cli, ctx,
     650        status = rpccli_srvsvc_NetRemoteTOD(pipe_cli, talloc_tos(),
    651651                                            r->in.server_name,
    652652                                            &info,

  • vendor/current/source3/lib/netapi/share.c

    r414 r594  
    216216        }
    217217
    218         status = rpccli_srvsvc_NetShareAdd(pipe_cli, ctx,
     218        status = rpccli_srvsvc_NetShareAdd(pipe_cli, talloc_tos(),
    219219                                           r->in.server_name,
    220220                                           r->in.level,
    … …  
    260260        }
    261261
    262         status = rpccli_srvsvc_NetShareDel(pipe_cli, ctx,
     262        status = rpccli_srvsvc_NetShareDel(pipe_cli, talloc_tos(),
    263263                                           r->in.server_name,
    264264                                           r->in.net_name,
    … …  
    339339        }
    340340
    341         status = rpccli_srvsvc_NetShareEnumAll(pipe_cli, ctx,
     341        status = rpccli_srvsvc_NetShareEnumAll(pipe_cli, talloc_tos(),
    342342                                               r->in.server_name,
    343343                                               &info_ctr,
    … …  
    424424        }
    425425
    426         status = rpccli_srvsvc_NetShareGetInfo(pipe_cli, ctx,
     426        status = rpccli_srvsvc_NetShareGetInfo(pipe_cli, talloc_tos(),
    427427                                               r->in.server_name,
    428428                                               r->in.net_name,
    … …  
    503503        }
    504504
    505         status = rpccli_srvsvc_NetShareSetInfo(pipe_cli, ctx,
     505        status = rpccli_srvsvc_NetShareSetInfo(pipe_cli, talloc_tos(),
    506506                                               r->in.server_name,
    507507                                               r->in.net_name,

  • vendor/current/source3/lib/netapi/shutdown.c

    r414 r594  
    4646        init_lsa_StringLarge(&message, r->in.message);
    4747
    48         status = rpccli_initshutdown_Init(pipe_cli, ctx,
     48        status = rpccli_initshutdown_Init(pipe_cli, talloc_tos(),
    4949                                          NULL,
    5050                                          &message,
    … …  
    8888        }
    8989
    90         status = rpccli_initshutdown_Abort(pipe_cli, ctx,
     90        status = rpccli_initshutdown_Abort(pipe_cli, talloc_tos(),
    9191                                           NULL,
    9292                                           &werr);

  • vendor/current/source3/lib/netapi/user.c

    r414 r594  
    5252        if (infoX->usriX_flags) {
    5353                fields_present |= SAMR_FIELD_ACCT_FLAGS;
    54         }
    55         if (infoX->usriX_name) {
    56                 fields_present |= SAMR_FIELD_FULL_NAME;
    5754        }
    5855        if (infoX->usriX_home_dir) {
    … …  
    314311                                          &user_info.info25.password);
    315312
    316                 status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
     313                status = rpccli_samr_SetUserInfo2(pipe_cli, talloc_tos(),
    317314                                                  user_handle,
    318315                                                  25,
    … …  
    327324                                                &user_info.info23.password);
    328325
    329                         status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
     326                        status = rpccli_samr_SetUserInfo2(pipe_cli, talloc_tos(),
    330327                                                          user_handle,
    331328                                                          23,
    … …  
    336333                user_info.info21 = info21;
    337334
    338                 status = rpccli_samr_SetUserInfo(pipe_cli, ctx,
     335                status = rpccli_samr_SetUserInfo(pipe_cli, talloc_tos(),
    339336                                                 user_handle,
    340337                                                 21,
    … …  
    410407        init_lsa_String(&lsa_account_name, uX.usriX_name);
    411408
    412         status = rpccli_samr_CreateUser2(pipe_cli, ctx,
     409        status = rpccli_samr_CreateUser2(pipe_cli, talloc_tos(),
    413410                                         &domain_handle,
    414411                                         &lsa_account_name,
    … …  
    427424        }
    428425
    429         status = rpccli_samr_QueryUserInfo(pipe_cli, ctx,
     426        status = rpccli_samr_QueryUserInfo(pipe_cli, talloc_tos(),
    430427                                           &user_handle,
    431428                                           16,
    … …  
    441438        }
    442439
    443         status = rpccli_samr_GetUserPwInfo(pipe_cli, ctx,
     440        status = rpccli_samr_GetUserPwInfo(pipe_cli, talloc_tos(),
    444441                                           &user_handle,
    445442                                           &pw_info);
    … …  
    464461
    465462 failed:
    466         rpccli_samr_DeleteUser(pipe_cli, ctx,
     463        rpccli_samr_DeleteUser(pipe_cli, talloc_tos(),
    467464                               &user_handle);
    468465
    469466 done:
    470467        if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
    471                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
     468                rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
    472469        }
    473470
    … …  
    528525        }
    529526
    530         status = rpccli_samr_OpenDomain(pipe_cli, ctx,
     527        status = rpccli_samr_OpenDomain(pipe_cli, talloc_tos(),
    531528                                        &connect_handle,
    532529                                        SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
    … …  
    540537        init_lsa_String(&lsa_account_name, r->in.user_name);
    541538
    542         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     539        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    543540                                         &domain_handle,
    544541                                         1,
    … …  
    551548        }
    552549
    553         status = rpccli_samr_OpenUser(pipe_cli, ctx,
     550        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
    554551                                      &domain_handle,
    555552                                      SEC_STD_DELETE,
    … …  
    563560        sid_compose(&user_sid, domain_sid, user_rids.ids[0]);
    564561
    565         status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, ctx,
     562        status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, talloc_tos(),
    566563                                                           &builtin_handle,
    567564                                                           &user_sid);
    … …  
    571568        }
    572569
    573         status = rpccli_samr_DeleteUser(pipe_cli, ctx,
     570        status = rpccli_samr_DeleteUser(pipe_cli, talloc_tos(),
    574571                                        &user_handle);
    575572        if (!NT_STATUS_IS_OK(status)) {
    … …  
    582579 done:
    583580        if (is_valid_policy_hnd(&user_handle)) {
    584                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
     581                rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
    585582        }
    586583
    … …  
    16721669        init_lsa_String(&lsa_account_name, r->in.user_name);
    16731670
    1674         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     1671        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    16751672                                         &domain_handle,
    16761673                                         1,
    … …  
    16991696 done:
    17001697        if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
    1701                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
     1698                rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
    17021699        }
    17031700
    … …  
    18271824        init_lsa_String(&lsa_account_name, r->in.user_name);
    18281825
    1829         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     1826        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    18301827                                         &domain_handle,
    18311828                                         1,
    … …  
    18381835        }
    18391836
    1840         status = rpccli_samr_OpenUser(pipe_cli, ctx,
     1837        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
    18411838                                      &domain_handle,
    18421839                                      user_mask,
    … …  
    18671864 done:
    18681865        if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
    1869                 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
     1866                rpccli_samr_Close(pipe_cli, talloc_tos(), &user_handle);
    18701867        }
    18711868
    … …  
    28462843        init_lsa_String(&lsa_account_name, r->in.user_name);
    28472844
    2848         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     2845        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    28492846                                         &domain_handle,
    28502847                                         1,
    … …  
    28572854        }
    28582855
    2859         status = rpccli_samr_OpenUser(pipe_cli, ctx,
     2856        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
    28602857                                      &domain_handle,
    28612858                                      SAMR_USER_ACCESS_GET_GROUPS,
    … …  
    28672864        }
    28682865
    2869         status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
     2866        status = rpccli_samr_GetGroupsForUser(pipe_cli, talloc_tos(),
    28702867                                              &user_handle,
    28712868                                              &rid_array);
    … …  
    28852882        }
    28862883
    2887         status = rpccli_samr_LookupRids(pipe_cli, ctx,
     2884        status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
    28882885                                        &domain_handle,
    28892886                                        rid_array->count,
    … …  
    29972994        init_lsa_String(&lsa_account_name, r->in.user_name);
    29982995
    2999         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     2996        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    30002997                                         &domain_handle,
    30012998                                         1,
    … …  
    30083005        }
    30093006
    3010         status = rpccli_samr_OpenUser(pipe_cli, ctx,
     3007        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
    30113008                                      &domain_handle,
    30123009                                      SAMR_USER_ACCESS_GET_GROUPS,
    … …  
    30473044        }
    30483045
    3049         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     3046        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    30503047                                         &domain_handle,
    30513048                                         r->in.num_entries,
    … …  
    30613058        num_member_rids = group_rids.count;
    30623059
    3063         status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
     3060        status = rpccli_samr_GetGroupsForUser(pipe_cli, talloc_tos(),
    30643061                                              &user_handle,
    30653062                                              &rid_array);
    … …  
    31123109
    31133110        for (i=0; i < num_add_rids; i++) {
    3114                 status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     3111                status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    31153112                                               &domain_handle,
    31163113                                               SAMR_GROUP_ACCESS_ADD_MEMBER,
    … …  
    31223119                }
    31233120
    3124                 status = rpccli_samr_AddGroupMember(pipe_cli, ctx,
     3121                status = rpccli_samr_AddGroupMember(pipe_cli, talloc_tos(),
    31253122                                                    &group_handle,
    31263123                                                    user_rids.ids[0],
    … …  
    31323129
    31333130                if (is_valid_policy_hnd(&group_handle)) {
    3134                         rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     3131                        rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    31353132                }
    31363133        }
    … …  
    31393136
    31403137        for (i=0; i < num_del_rids; i++) {
    3141                 status = rpccli_samr_OpenGroup(pipe_cli, ctx,
     3138                status = rpccli_samr_OpenGroup(pipe_cli, talloc_tos(),
    31423139                                               &domain_handle,
    31433140                                               SAMR_GROUP_ACCESS_REMOVE_MEMBER,
    … …  
    31493146                }
    31503147
    3151                 status = rpccli_samr_DeleteGroupMember(pipe_cli, ctx,
     3148                status = rpccli_samr_DeleteGroupMember(pipe_cli, talloc_tos(),
    31523149                                                       &group_handle,
    31533150                                                       user_rids.ids[0]);
    … …  
    31583155
    31593156                if (is_valid_policy_hnd(&group_handle)) {
    3160                         rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     3157                        rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    31613158                }
    31623159        }
    … …  
    31663163 done:
    31673164        if (is_valid_policy_hnd(&group_handle)) {
    3168                 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
     3165                rpccli_samr_Close(pipe_cli, talloc_tos(), &group_handle);
    31693166        }
    31703167
    … …  
    32913288        init_lsa_String(&lsa_account_name, r->in.user_name);
    32923289
    3293         status = rpccli_samr_LookupNames(pipe_cli, ctx,
     3290        status = rpccli_samr_LookupNames(pipe_cli, talloc_tos(),
    32943291                                         &domain_handle,
    32953292                                         1,
    … …  
    33023299        }
    33033300
    3304         status = rpccli_samr_OpenUser(pipe_cli, ctx,
     3301        status = rpccli_samr_OpenUser(pipe_cli, talloc_tos(),
    33053302                                      &domain_handle,
    33063303                                      SAMR_USER_ACCESS_GET_GROUPS,
    … …  
    33123309        }
    33133310
    3314         status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
     3311        status = rpccli_samr_GetGroupsForUser(pipe_cli, talloc_tos(),
    33153312                                              &user_handle,
    33163313                                              &rid_array);
    … …  
    33533350        }
    33543351
    3355         status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
     3352        status = rpccli_samr_GetAliasMembership(pipe_cli, talloc_tos(),
    33563353                                                &domain_handle,
    33573354                                                &sid_array,
    … …  
    33703367        }
    33713368
    3372         status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
     3369        status = rpccli_samr_GetAliasMembership(pipe_cli, talloc_tos(),
    33733370                                                &builtin_handle,
    33743371                                                &sid_array,
    … …  
    33873384        }
    33883385
    3389         status = rpccli_samr_LookupRids(pipe_cli, ctx,
     3386        status = rpccli_samr_LookupRids(pipe_cli, talloc_tos(),
    33903387                                        &builtin_handle,
    33913388                                        num_rids,

  • vendor/current/source3/lib/privileges_basic.c

    r414 r594  
    4747const SE_PRIV se_restore         = SE_RESTORE;
    4848const SE_PRIV se_take_ownership  = SE_TAKE_OWNERSHIP;
     49const SE_PRIV se_security       = SE_SECURITY;
    4950
    5051/********************************************************************
    … …  
    99100#endif
    100101        {SE_MACHINE_ACCOUNT,    "SeMachineAccountPrivilege",    "Add machines to domain",                  { 0x0, 0x0006 }},
     102        {SE_SECURITY,           "SeSecurityPrivilege",          "Manage auditing and security log",        { 0x0, 0x0008 }},
    101103        {SE_TAKE_OWNERSHIP,     "SeTakeOwnershipPrivilege",     "Take ownership of files or other objects",{ 0x0, 0x0009 }},
    102104        {SE_BACKUP,             "SeBackupPrivilege",            "Back up files and directories",           { 0x0, 0x0011 }},
    … …  
    108110        {SE_DISK_OPERATOR,      "SeDiskOperatorPrivilege",      "Manage disk shares",                      { 0x0, 0x1003 }},
    109111
     112
    110113        {SE_END, "", "", { 0x0, 0x0 }}
    111114};
    … …  
    190193{
    191194        return ( memcmp(mask1, mask2, sizeof(SE_PRIV)) == 0 );
     195}
     196
     197/***************************************************************************
     198 check if 2 LUID's are equal.
     199****************************************************************************/
     200
     201static bool luid_equal( const LUID *luid1, const LUID *luid2 )
     202{
     203        return ( luid1->low == luid2->low && luid1->high == luid2->high);
    192204}
    193205
    … …  
    407419        int i;
    408420
    409         if (set->high != 0)
    410                 return NULL;
    411 
    412421        for ( i=0; !se_priv_equal(&privs[i].se_priv, &se_priv_end); i++ ) {
    413                 if ( set->low == privs[i].luid.low ) {
     422                if (luid_equal(set, &privs[i].luid)) {
    414423                        return privs[i].name;
    415424                }
    … …  
    478487        int i;
    479488        uint32 num_privs = count_all_privileges();
     489        LUID local_luid;
     490
     491        local_luid.low = luid->low;
     492        local_luid.high = luid->high;
    480493
    481494        for ( i=0; i<num_privs; i++ ) {
    482                 if ( luid->low == privs[i].luid.low ) {
     495                if (luid_equal(&local_luid, &privs[i].luid)) {
    483496                        se_priv_copy( mask, &privs[i].se_priv );
    484497                        return True;
    … …  
    501514                SE_PRIV r;
    502515
    503                 /* sanity check for invalid privilege.  we really
    504                    only care about the low 32 bits */
    505 
    506                 if ( privset->set[i].luid.high != 0 )
    507                         return False;
    508 
    509516                if ( luid_to_se_priv( &privset->set[i].luid, &r ) )
    510517                        se_priv_add( mask, &r );

  • vendor/current/source3/lib/util.c

    r414 r594  
    14081408        uid_t u;
    14091409
    1410         pass = getpwnam_alloc(talloc_autofree_context(), name);
     1410        pass = Get_Pwnam_alloc(talloc_autofree_context(), name);
    14111411        if (pass) {
    14121412                u = pass->pw_uid;
    … …  
    30713071        return s;
    30723072}
     3073
     3074bool tevent_req_poll_ntstatus(struct tevent_req *req,
     3075                              struct tevent_context *ev,
     3076                              NTSTATUS *status)
     3077{
     3078        bool ret = tevent_req_poll(req, ev);
     3079        if (!ret) {
     3080                *status = map_nt_error_from_unix(errno);
     3081        }
     3082        return ret;
     3083}

  • vendor/current/source3/lib/util_seaccess.c

    r414 r594  
    180180        }
    181181
    182 #if 0
    183         /* We need to support SeSecurityPrivilege for this. */
    184 
    185182        if (access_desired & SEC_FLAG_SYSTEM_SECURITY) {
    186                 if (user_has_privileges(token, &sec_security)) {
     183                if (user_has_privileges(token, &se_security)) {
    187184                        bits_remaining &= ~SEC_FLAG_SYSTEM_SECURITY;
    188185                } else {
    … …  
    190187                }
    191188        }
    192 #endif
    193189
    194190        /* a NULL dacl allows access */

  • vendor/current/source3/lib/util_str.c

    r414 r594  
    14551455
    14561456/**
     1457 * Calculate the number of units (8 or 16-bit, depending on the
     1458 * destination charset), that would be needed to convert the input
     1459 * string which is expected to be in in CH_UNIX encoding to the
     1460 * destination charset (which should be a unicode charset).
     1461 */
     1462size_t strlen_m_ext(const char *s, const charset_t dst_charset)
     1463{
     1464        size_t count = 0;
     1465
     1466        if (!s) {
     1467                return 0;
     1468        }
     1469
     1470        while (*s && !(((uint8_t)*s) & 0x80)) {
     1471                s++;
     1472                count++;
     1473        }
     1474
     1475        if (!*s) {
     1476                return count;
     1477        }
     1478
     1479        while (*s) {
     1480                size_t c_size;
     1481                codepoint_t c = next_codepoint(s, &c_size);
     1482                s += c_size;
     1483
     1484                switch(dst_charset) {
     1485                case CH_UTF16LE:
     1486                case CH_UTF16BE:
     1487                case CH_UTF16MUNGED:
     1488                        if (c < 0x10000) {
     1489                                /* Unicode char fits into 16 bits. */
     1490                                count += 1;
     1491                        } else {
     1492                                /* Double-width unicode char - 32 bits. */
     1493                                count += 2;
     1494                        }
     1495                        break;
     1496                case CH_UTF8:
     1497                        /*
     1498                         * this only checks ranges, and does not
     1499                         * check for invalid codepoints
     1500                         */
     1501                        if (c < 0x80) {
     1502                                count += 1;
     1503                        } else if (c < 0x800) {
     1504                                count += 2;
     1505                        } else if (c < 0x1000) {
     1506                                count += 3;
     1507                        } else {
     1508                                count += 4;
     1509                        }
     1510                        break;
     1511                default:
     1512                        /*
     1513                         * non-unicode encoding:
     1514                         * assume that each codepoint fits into
     1515                         * one unit in the destination encoding.
     1516                         */
     1517                        count += 1;
     1518                }
     1519        }
     1520
     1521        return count;
     1522}
     1523
     1524size_t strlen_m_ext_term(const char *s, const charset_t dst_charset)
     1525{
     1526        if (!s) {
     1527                return 0;
     1528        }
     1529        return strlen_m_ext(s, dst_charset) + 1;
     1530}
     1531
     1532/**
    14571533 Count the number of UCS2 characters in a string. Normally this will
    14581534 be the same as the number of bytes in a string for single byte strings,
    … …  
    14621538size_t strlen_m(const char *s)
    14631539{
    1464         size_t count = 0;
    1465 
    1466         if (!s) {
    1467                 return 0;
    1468         }
    1469 
    1470         while (*s && !(((uint8_t)*s) & 0x80)) {
    1471                 s++;
    1472                 count++;
    1473         }
    1474 
    1475         if (!*s) {
    1476                 return count;
    1477         }
    1478 
    1479         while (*s) {
    1480                 size_t c_size;
    1481                 codepoint_t c = next_codepoint(s, &c_size);
    1482                 if (c < 0x10000) {
    1483                         /* Unicode char fits into 16 bits. */
    1484                         count += 1;
    1485                 } else {
    1486                         /* Double-width unicode char - 32 bits. */
    1487                         count += 2;
    1488                 }
    1489                 s += c_size;
    1490         }
    1491 
    1492         return count;
     1540        return strlen_m_ext(s, CH_UTF16LE);
    14931541}
    14941542
Note: See TracChangeset for help on using the changeset viewer.