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
3 copied

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/source4/torture/rap/rap.c

    r414 r745  
    55   Copyright (C) Tim Potter 2005
    66   Copyright (C) Jelmer Vernooij 2007
     7   Copyright (C) Guenther Deschner 2010
    78   
    89   This program is free software; you can redistribute it and/or modify
    … …  
    2425#include "torture/smbtorture.h"
    2526#include "torture/util.h"
     27#include "param/param.h"
    2628#include "libcli/rap/rap.h"
    27 #include "libcli/raw/libcliraw.h"
    28 #include "libcli/libcli.h"
    29 #include "librpc/ndr/libndr.h"
    30 #include "param/param.h"
    31 
    32 #define RAP_GOTO(call) do { \
    33         NTSTATUS _status; \
    34         _status = call; \
    35         if (!NT_STATUS_IS_OK(_status)) { \
    36                 result = _status; \
    37                 goto done; \
    38         } \
    39 } while (0)
    40 
    41 #define NDR_GOTO(call) do { \
    42         enum ndr_err_code _ndr_err; \
    43         _ndr_err = call; \
    44         if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
    45                 result = ndr_map_error2ntstatus(_ndr_err); \
    46                 goto done; \
    47         } \
    48 } while (0)
    49 
    50 #define NDR_RETURN(call) do { \
    51         enum ndr_err_code _ndr_err; \
    52         _ndr_err = call; \
    53         if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
    54                 return ndr_map_error2ntstatus(_ndr_err); \
    55         } \
    56 } while (0)
    57 
    58 struct rap_call {
    59         uint16_t callno;
    60         char *paramdesc;
    61         const char *datadesc;
    62 
    63         uint16_t status;
    64         uint16_t convert;
    65        
    66         uint16_t rcv_paramlen, rcv_datalen;
    67 
    68         struct ndr_push *ndr_push_param;
    69         struct ndr_push *ndr_push_data;
    70         struct ndr_pull *ndr_pull_param;
    71         struct ndr_pull *ndr_pull_data;
    72 };
    73 
    74 #define RAPNDR_FLAGS (LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
    75 
    76 static struct rap_call *new_rap_cli_call(TALLOC_CTX *mem_ctx, struct smb_iconv_convenience *iconv_convenience, uint16_t callno)
    77 {
    78         struct rap_call *call;
    79 
    80         call = talloc(mem_ctx, struct rap_call);
    81 
    82         if (call == NULL)
    83                 return NULL;
    84 
    85         call->callno = callno;
    86         call->rcv_paramlen = 4;
    87 
    88         call->paramdesc = NULL;
    89         call->datadesc = NULL;
    90 
    91         call->ndr_push_param = ndr_push_init_ctx(mem_ctx, iconv_convenience);
    92         call->ndr_push_param->flags = RAPNDR_FLAGS;
    93 
    94         call->ndr_push_data = ndr_push_init_ctx(mem_ctx, iconv_convenience);
    95         call->ndr_push_data->flags = RAPNDR_FLAGS;
    96 
    97         return call;
    98 }
    99 
    100 static void rap_cli_push_paramdesc(struct rap_call *call, char desc)
    101 {
    102         int len = 0;
    103 
    104         if (call->paramdesc != NULL)
    105                 len = strlen(call->paramdesc);
    106 
    107         call->paramdesc = talloc_realloc(call,
    108                                          call->paramdesc,
    109                                          char,
    110                                          len+2);
    111 
    112         call->paramdesc[len] = desc;
    113         call->paramdesc[len+1] = '\0';
    114 }
    115 
    116 static void rap_cli_push_word(struct rap_call *call, uint16_t val)
    117 {
    118         rap_cli_push_paramdesc(call, 'W');
    119         ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, val);
    120 }
    121 
    122 static void rap_cli_push_dword(struct rap_call *call, uint32_t val)
    123 {
    124         rap_cli_push_paramdesc(call, 'D');
    125         ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, val);
    126 }
    127 
    128 static void rap_cli_push_rcvbuf(struct rap_call *call, int len)
    129 {
    130         rap_cli_push_paramdesc(call, 'r');
    131         rap_cli_push_paramdesc(call, 'L');
    132         ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, len);
    133         call->rcv_datalen = len;
    134 }
    135 
    136 static void rap_cli_expect_multiple_entries(struct rap_call *call)
    137 {
    138         rap_cli_push_paramdesc(call, 'e');
    139         rap_cli_push_paramdesc(call, 'h');
    140         call->rcv_paramlen += 4; /* uint16_t entry count, uint16_t total */
    141 }
    142 
    143 static void rap_cli_expect_word(struct rap_call *call)
    144 {
    145         rap_cli_push_paramdesc(call, 'h');
    146         call->rcv_paramlen += 2;
    147 }
    148 
    149 static void rap_cli_push_string(struct rap_call *call, const char *str)
    150 {
    151         if (str == NULL) {
    152                 rap_cli_push_paramdesc(call, 'O');
    153                 return;
    154         }
    155         rap_cli_push_paramdesc(call, 'z');
    156         ndr_push_string(call->ndr_push_param, NDR_SCALARS, str);
    157 }
    158 
    159 static void rap_cli_expect_format(struct rap_call *call, const char *format)
    160 {
    161         call->datadesc = format;
    162 }
    163 
    164 static NTSTATUS rap_pull_string(TALLOC_CTX *mem_ctx, struct ndr_pull *ndr,
    165                                 uint16_t convert, char **dest)
    166 {
    167         uint16_t string_offset;
    168         uint16_t ignore;
    169         const char *p;
    170         size_t len;
    171 
    172         NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &string_offset));
    173         NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &ignore));
    174 
    175         string_offset -= convert;
    176 
    177         if (string_offset+1 > ndr->data_size)
    178                 return NT_STATUS_INVALID_PARAMETER;
    179 
    180         p = (const char *)(ndr->data + string_offset);
    181         len = strnlen(p, ndr->data_size-string_offset);
    182 
    183         if ( string_offset + len + 1 >  ndr->data_size )
    184                 return NT_STATUS_INVALID_PARAMETER;
    185 
    186         *dest = talloc_zero_array(mem_ctx, char, len+1);
    187         pull_string(*dest, p, len+1, len, STR_ASCII);
    188 
    189         return NT_STATUS_OK;
    190 }
    191 
    192 static NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
    193                                 struct smb_iconv_convenience *iconv_convenience,
    194                                 struct rap_call *call)
    195 {
    196         NTSTATUS result;
    197         DATA_BLOB param_blob;
    198         struct ndr_push *params;
    199         struct smb_trans2 trans;
    200 
    201         params = ndr_push_init_ctx(call, iconv_convenience);
    202 
    203         if (params == NULL)
    204                 return NT_STATUS_NO_MEMORY;
    205 
    206         params->flags = RAPNDR_FLAGS;
    207 
    208         trans.in.max_param = call->rcv_paramlen;
    209         trans.in.max_data = call->rcv_datalen;
    210         trans.in.max_setup = 0;
    211         trans.in.flags = 0;
    212         trans.in.timeout = 0;
    213         trans.in.setup_count = 0;
    214         trans.in.setup = NULL;
    215         trans.in.trans_name = "\\PIPE\\LANMAN";
    216 
    217         NDR_RETURN(ndr_push_uint16(params, NDR_SCALARS, call->callno));
    218         if (call->paramdesc)
    219                 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->paramdesc));
    220         if (call->datadesc)
    221                 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->datadesc));
    222 
    223         param_blob = ndr_push_blob(call->ndr_push_param);
    224         NDR_RETURN(ndr_push_bytes(params, param_blob.data,
    225                                  param_blob.length));
    226 
    227         trans.in.params = ndr_push_blob(params);
    228         trans.in.data = data_blob(NULL, 0);
    229 
    230         result = smb_raw_trans(tree, call, &trans);
    231 
    232         if (!NT_STATUS_IS_OK(result))
    233                 return result;
    234 
    235         call->ndr_pull_param = ndr_pull_init_blob(&trans.out.params, call,
    236                                                   iconv_convenience);
    237         call->ndr_pull_param->flags = RAPNDR_FLAGS;
    238 
    239         call->ndr_pull_data = ndr_pull_init_blob(&trans.out.data, call,
    240                                                  iconv_convenience);
    241         call->ndr_pull_data->flags = RAPNDR_FLAGS;
    242 
    243         return result;
    244 }
    245 
    246 
    247 static NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
    248                                         struct smb_iconv_convenience *iconv_convenience,
    249                                         TALLOC_CTX *mem_ctx,
    250                                         struct rap_NetShareEnum *r)
    251 {
    252         struct rap_call *call;
    253         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
    254         int i;
    255 
    256         call = new_rap_cli_call(tree, iconv_convenience, RAP_WshareEnum);
    257 
    258         if (call == NULL)
    259                 return NT_STATUS_NO_MEMORY;
    260 
    261         rap_cli_push_word(call, r->in.level); /* Level */
    262         rap_cli_push_rcvbuf(call, r->in.bufsize);
    263         rap_cli_expect_multiple_entries(call);
    264 
    265         switch(r->in.level) {
    266         case 0:
    267                 rap_cli_expect_format(call, "B13");
    268                 break;
    269         case 1:
    270                 rap_cli_expect_format(call, "B13BWz");
    271                 break;
    272         }
    273 
    274         result = rap_cli_do_call(tree, iconv_convenience, call);
    275 
    276         if (!NT_STATUS_IS_OK(result))
    277                 goto done;
    278 
    279         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
    280         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
    281         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
    282         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
    283 
    284         r->out.info = talloc_array(mem_ctx, union rap_shareenum_info, r->out.count);
    285 
    286         if (r->out.info == NULL) {
    287                 result = NT_STATUS_NO_MEMORY;
    288                 goto done;
    289         }
    290 
    291         for (i=0; i<r->out.count; i++) {
    292                 switch(r->in.level) {
    293                 case 0:
    294                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    295                                               (uint8_t *)r->out.info[i].info0.name, 13));
    296                         break;
    297                 case 1:
    298                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    299                                               (uint8_t *)r->out.info[i].info1.name, 13));
    300                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    301                                               (uint8_t *)&r->out.info[i].info1.pad, 1));
    302                         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_data,
    303                                                NDR_SCALARS, &r->out.info[i].info1.type));
    304                         RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
    305                                                r->out.convert,
    306                                                &r->out.info[i].info1.comment));
    307                         break;
    308                 }
    309         }
    310 
    311         result = NT_STATUS_OK;
    312 
    313  done:
    314         talloc_free(call);
    315         return result;
    316 }
     29#include "torture/rap/proto.h"
    31730
    31831static bool test_netshareenum(struct torture_context *tctx,
    … …  
    32639
    32740        torture_assert_ntstatus_ok(tctx,
    328                 smbcli_rap_netshareenum(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r), "");
     41                smbcli_rap_netshareenum(cli->tree, tctx, &r), "");
    32942
    33043        for (i=0; i<r.out.count; i++) {
    331                 printf("%s %d %s\n", r.out.info[i].info1.name,
    332                        r.out.info[i].info1.type,
     44                printf("%s %d %s\n", r.out.info[i].info1.share_name,
     45                       r.out.info[i].info1.share_type,
    33346                       r.out.info[i].info1.comment);
    33447        }
    33548
    33649        return true;
    337 }
    338 
    339 static NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
    340                                           struct smb_iconv_convenience *iconv_convenience,
    341                                           TALLOC_CTX *mem_ctx,
    342                                           struct rap_NetServerEnum2 *r)
    343 {
    344         struct rap_call *call;
    345         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
    346         int i;
    347 
    348         call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_NetServerEnum2);
    349 
    350         if (call == NULL)
    351                 return NT_STATUS_NO_MEMORY;
    352 
    353         rap_cli_push_word(call, r->in.level);
    354         rap_cli_push_rcvbuf(call, r->in.bufsize);
    355         rap_cli_expect_multiple_entries(call);
    356         rap_cli_push_dword(call, r->in.servertype);
    357         rap_cli_push_string(call, r->in.domain);
    358 
    359         switch(r->in.level) {
    360         case 0:
    361                 rap_cli_expect_format(call, "B16");
    362                 break;
    363         case 1:
    364                 rap_cli_expect_format(call, "B16BBDz");
    365                 break;
    366         }
    367 
    368         result = rap_cli_do_call(tree, iconv_convenience, call);
    369 
    370         if (!NT_STATUS_IS_OK(result))
    371                 goto done;
    372 
    373         result = NT_STATUS_INVALID_PARAMETER;
    374 
    375         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
    376         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
    377         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
    378         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
    379 
    380         r->out.info = talloc_array(mem_ctx, union rap_server_info, r->out.count);
    381 
    382         if (r->out.info == NULL) {
    383                 result = NT_STATUS_NO_MEMORY;
    384                 goto done;
    385         }
    386 
    387         for (i=0; i<r->out.count; i++) {
    388                 switch(r->in.level) {
    389                 case 0:
    390                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    391                                               (uint8_t *)r->out.info[i].info0.name, 16));
    392                         break;
    393                 case 1:
    394                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    395                                               (uint8_t *)r->out.info[i].info1.name, 16));
    396                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    397                                               &r->out.info[i].info1.version_major, 1));
    398                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    399                                               &r->out.info[i].info1.version_minor, 1));
    400                         NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
    401                                                NDR_SCALARS, &r->out.info[i].info1.servertype));
    402                         RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
    403                                                r->out.convert,
    404                                                &r->out.info[i].info1.comment));
    405                 }
    406         }
    407 
    408         result = NT_STATUS_OK;
    409 
    410  done:
    411         talloc_free(call);
    412         return result;
    41350}
    41451
    … …  
    42663
    42764        torture_assert_ntstatus_ok(tctx,
    428                    smbcli_rap_netserverenum2(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r), "");
     65                   smbcli_rap_netserverenum2(cli->tree, tctx, &r), "");
    42966
    43067        for (i=0; i<r.out.count; i++) {
    … …  
    44481}
    44582
    446 NTSTATUS smbcli_rap_netservergetinfo(struct smbcli_tree *tree,
    447                                               struct smb_iconv_convenience *iconv_convenience,
    448                                      TALLOC_CTX *mem_ctx,
    449                                      struct rap_WserverGetInfo *r)
    450 {
    451         struct rap_call *call;
    452         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
    453 
    454         if (!(call = new_rap_cli_call(mem_ctx, iconv_convenience, RAP_WserverGetInfo))) {
    455                 return NT_STATUS_NO_MEMORY;
    456         }
    457 
    458         rap_cli_push_word(call, r->in.level);
    459         rap_cli_push_rcvbuf(call, r->in.bufsize);
    460         rap_cli_expect_word(call);
    461 
    462         switch(r->in.level) {
    463         case 0:
    464                 rap_cli_expect_format(call, "B16");
    465                 break;
    466         case 1:
    467                 rap_cli_expect_format(call, "B16BBDz");
    468                 break;
    469         default:
    470                 result = NT_STATUS_INVALID_PARAMETER;
    471                 goto done;
    472         }
    473 
    474         result = rap_cli_do_call(tree, iconv_convenience, call);
    475 
    476         if (!NT_STATUS_IS_OK(result))
    477                 goto done;
    478 
    479         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
    480         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
    481         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
    482 
    483         switch(r->in.level) {
    484         case 0:
    485                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    486                                       (uint8_t *)r->out.info.info0.name, 16));
    487                 break;
    488         case 1:
    489                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    490                                       (uint8_t *)r->out.info.info1.name, 16));
    491                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    492                                       &r->out.info.info1.version_major, 1));
    493                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
    494                                       &r->out.info.info1.version_minor, 1));
    495                 NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
    496                                        NDR_SCALARS, &r->out.info.info1.servertype));
    497                 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
    498                                        r->out.convert,
    499                                        &r->out.info.info1.comment));
    500         }
    501  done:
    502         talloc_free(call);
    503         return result;
    504 }
    505 
    50683static bool test_netservergetinfo(struct torture_context *tctx,
    50784                                  struct smbcli_state *cli)
    … …  
    51390
    51491        r.in.level = 0;
    515         torture_assert_ntstatus_ok(tctx, smbcli_rap_netservergetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r), "");
     92        torture_assert_ntstatus_ok(tctx,
     93                smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
     94                "rap_netservergetinfo level 0 failed");
     95        torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
     96                "rap_netservergetinfo level 0 failed");
     97
    51698        r.in.level = 1;
    517         torture_assert_ntstatus_ok(tctx, smbcli_rap_netservergetinfo(cli->tree, lp_iconv_convenience(tctx->lp_ctx), tctx, &r), "");
     99        torture_assert_ntstatus_ok(tctx,
     100                smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
     101                "rap_netservergetinfo level 1 failed");
     102        torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
     103                "rap_netservergetinfo level 1 failed");
    518104
    519105        return res;
    520106}
    521107
     108static bool test_netsessionenum(struct torture_context *tctx,
     109                                struct smbcli_state *cli)
     110{
     111        struct rap_NetSessionEnum r;
     112        int i,n;
     113        uint16_t levels[] = { 2 };
     114
     115        for (i=0; i < ARRAY_SIZE(levels); i++) {
     116
     117                r.in.level = levels[i];
     118                r.in.bufsize = 8192;
     119
     120                torture_comment(tctx,
     121                        "Testing rap_NetSessionEnum level %d\n", r.in.level);
     122
     123                torture_assert_ntstatus_ok(tctx,
     124                        smbcli_rap_netsessionenum(cli->tree, tctx, &r),
     125                        "smbcli_rap_netsessionenum failed");
     126                torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
     127                        "smbcli_rap_netsessionenum failed");
     128
     129                for (n=0; n < r.out.count; n++) {
     130                        switch (r.in.level) {
     131                        case 2:
     132                                torture_comment(tctx, "ComputerName: %s\n",
     133                                        r.out.info[n].info2.ComputerName);
     134
     135                                torture_comment(tctx, "UserName: %s\n",
     136                                        r.out.info[n].info2.UserName);
     137
     138                                torture_assert(tctx, r.out.info[n].info2.ComputerName,
     139                                        "ComputerName empty");
     140                                torture_assert(tctx, r.out.info[n].info2.UserName,
     141                                        "UserName empty");
     142                                break;
     143                        default:
     144                                break;
     145                        }
     146                }
     147        }
     148
     149        return true;
     150}
     151
     152static bool test_netsessiongetinfo_bysession(struct torture_context *tctx,
     153                                             struct smbcli_state *cli,
     154                                             const char *session)
     155{
     156        struct rap_NetSessionGetInfo r;
     157        int i;
     158        uint16_t levels[] = { 2 };
     159
     160        if (session && session[0] == '\\' && session[1] == '\\') {
     161                r.in.SessionName = session;
     162        } else {
     163                r.in.SessionName = talloc_asprintf(tctx, "\\\\%s", session);
     164        }
     165        r.in.bufsize = 0xffff;
     166
     167        for (i=0; i < ARRAY_SIZE(levels); i++) {
     168
     169                r.in.level = levels[i];
     170
     171                torture_assert_ntstatus_ok(tctx,
     172                        smbcli_rap_netsessiongetinfo(cli->tree, tctx, &r),
     173                        "rap_netsessiongetinfo failed");
     174                torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
     175                        "rap_netsessiongetinfo failed");
     176        }
     177
     178        return true;
     179}
     180
     181static bool test_netsessiongetinfo(struct torture_context *tctx,
     182                                   struct smbcli_state *cli)
     183{
     184        struct rap_NetSessionEnum r;
     185        int i,n;
     186        uint16_t levels[] = { 2 };
     187
     188        for (i=0; i < ARRAY_SIZE(levels); i++) {
     189
     190                r.in.level = levels[i];
     191                r.in.bufsize = 8192;
     192
     193                torture_assert_ntstatus_ok(tctx,
     194                        smbcli_rap_netsessionenum(cli->tree, tctx, &r),
     195                        "smbcli_rap_netsessionenum failed");
     196                torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
     197                        "smbcli_rap_netsessionenum failed");
     198
     199                for (n=0; n < r.out.count; n++) {
     200                        torture_assert(tctx,
     201                                test_netsessiongetinfo_bysession(tctx, cli, r.out.info[n].info2.ComputerName),
     202                                "failed to query sessioninfo");
     203                }
     204        }
     205
     206        return true;
     207}
     208
     209static bool test_netremotetod(struct torture_context *tctx,
     210                              struct smbcli_state *cli)
     211{
     212        struct rap_NetRemoteTOD r;
     213
     214        r.in.bufsize = 8192;
     215
     216        torture_assert_ntstatus_ok(tctx,
     217                smbcli_rap_netremotetod(cli->tree, tctx, &r),
     218                "smbcli_rap_netremotetod failed");
     219        torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
     220                "smbcli_rap_netremotetod failed");
     221
     222        return true;
     223}
     224
    522225bool torture_rap_scan(struct torture_context *torture, struct smbcli_state *cli)
    523226{
    … …  
    525228
    526229        for (callno = 0; callno < 0xffff; callno++) {
    527                 struct rap_call *call = new_rap_cli_call(torture, lp_iconv_convenience(torture->lp_ctx), callno);
     230                struct rap_call *call = new_rap_cli_call(torture, callno);
    528231                NTSTATUS result;
    529232
    530                 result = rap_cli_do_call(cli->tree, lp_iconv_convenience(torture->lp_ctx), call);
     233                result = rap_cli_do_call(cli->tree, call);
    531234
    532235                if (!NT_STATUS_EQUAL(result, NT_STATUS_INVALID_PARAMETER))
    … …  
    541244NTSTATUS torture_rap_init(void)
    542245{
    543         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "RAP");
    544         struct torture_suite *suite_basic = torture_suite_create(suite, "BASIC");
     246        struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "rap");
     247        struct torture_suite *suite_basic = torture_suite_create(suite, "basic");
    545248
    546249        torture_suite_add_suite(suite, suite_basic);
     250        torture_suite_add_suite(suite, torture_rap_rpc(suite));
     251        torture_suite_add_suite(suite, torture_rap_printing(suite));
     252        torture_suite_add_suite(suite, torture_rap_sam(suite));
    547253
    548254        torture_suite_add_1smb_test(suite_basic, "netserverenum",
    … …  
    552258        torture_suite_add_1smb_test(suite_basic, "netservergetinfo",
    553259                                    test_netservergetinfo);
    554 
    555         torture_suite_add_1smb_test(suite, "SCAN", torture_rap_scan);
     260        torture_suite_add_1smb_test(suite_basic, "netsessionenum",
     261                                    test_netsessionenum);
     262        torture_suite_add_1smb_test(suite_basic, "netsessiongetinfo",
     263                                    test_netsessiongetinfo);
     264        torture_suite_add_1smb_test(suite_basic, "netremotetod",
     265                                    test_netremotetod);
     266
     267        torture_suite_add_1smb_test(suite, "scan", torture_rap_scan);
    556268
    557269        suite->description = talloc_strdup(suite,
Note: See TracChangeset for help on using the changeset viewer.