source4/torture/rap/rap.c

   1 /*
   2    Unix SMB/CIFS implementation.
   3    test suite for various RAP operations
   4    Copyright (C) Volker Lendecke 2004
   5    Copyright (C) Tim Potter 2005
   6    Copyright (C) Jelmer Vernooij 2007
   7
   8    This program is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 3 of the License, or
  11    (at your option) any later version.
  12
  13    This program is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20 */
  21
  22 #include "includes.h"
  23 #include "libcli/libcli.h"
  24 #include "torture/smbtorture.h"
  25 #include "torture/util.h"
  26 #include "../librpc/gen_ndr/ndr_rap.h"
  27 #include "librpc/ndr/libndr.h"
  28 #include "param/param.h"
  29 #include "torture/rap/proto.h"
  30
  31 #define RAP_GOTO(call) do { \
  32         NTSTATUS _status; \
  33         _status = call; \
  34         if (!NT_STATUS_IS_OK(_status)) { \
  35                 result = _status; \
  36                 goto done; \
  37         } \
  38 } while (0)
  39
  40 #define RAP_RETURN(call) do { \
  41         NTSTATUS _status; \
  42         _status = call; \
  43         if (!NT_STATUS_IS_OK(_status)) { \
  44                 return _status; \
  45         } \
  46 } while (0)
  47
  48
  49 #define NDR_GOTO(call) do { \
  50         enum ndr_err_code _ndr_err; \
  51         _ndr_err = call; \
  52         if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
  53                 result = ndr_map_error2ntstatus(_ndr_err); \
  54                 goto done; \
  55         } \
  56 } while (0)
  57
  58 #define NDR_RETURN(call) do { \
  59         enum ndr_err_code _ndr_err; \
  60         _ndr_err = call; \
  61         if (!NDR_ERR_CODE_IS_SUCCESS(_ndr_err)) { \
  62                 return ndr_map_error2ntstatus(_ndr_err); \
  63         } \
  64 } while (0)
  65
  66 struct rap_call {
  67         uint16_t callno;
  68         char *paramdesc;
  69         const char *datadesc;
  70         const char *auxdatadesc;
  71
  72         uint16_t status;
  73         uint16_t convert;
  74
  75         uint16_t rcv_paramlen, rcv_datalen;
  76
  77         struct ndr_push *ndr_push_param;
  78         struct ndr_push *ndr_push_data;
  79         struct ndr_pull *ndr_pull_param;
  80         struct ndr_pull *ndr_pull_data;
  81 };
  82
  83 #define RAPNDR_FLAGS (LIBNDR_FLAG_NOALIGN|LIBNDR_FLAG_STR_ASCII|LIBNDR_FLAG_STR_NULLTERM);
  84
  85 static struct rap_call *new_rap_cli_call(TALLOC_CTX *mem_ctx, uint16_t callno)
  86 {
  87         struct rap_call *call;
  88
  89         call = talloc(mem_ctx, struct rap_call);
  90
  91         if (call == NULL)
  92                 return NULL;
  93
  94         call->callno = callno;
  95         call->rcv_paramlen = 4;
  96
  97         call->paramdesc = NULL;
  98         call->datadesc = NULL;
  99         call->auxdatadesc = NULL;
 100
 101         call->ndr_push_param = ndr_push_init_ctx(mem_ctx);
 102         call->ndr_push_param->flags = RAPNDR_FLAGS;
 103
 104         call->ndr_push_data = ndr_push_init_ctx(mem_ctx);
 105         call->ndr_push_data->flags = RAPNDR_FLAGS;
 106
 107         return call;
 108 }
 109
 110 static void rap_cli_push_paramdesc(struct rap_call *call, char desc)
 111 {
 112         int len = 0;
 113
 114         if (call->paramdesc != NULL)
 115                 len = strlen(call->paramdesc);
 116
 117         call->paramdesc = talloc_realloc(call,
 118                                          call->paramdesc,
 119                                          char,
 120                                          len+2);
 121
 122         call->paramdesc[len] = desc;
 123         call->paramdesc[len+1] = '\0';
 124 }
 125
 126 static void rap_cli_push_word(struct rap_call *call, uint16_t val)
 127 {
 128         rap_cli_push_paramdesc(call, 'W');
 129         ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, val);
 130 }
 131
 132 static void rap_cli_push_dword(struct rap_call *call, uint32_t val)
 133 {
 134         rap_cli_push_paramdesc(call, 'D');
 135         ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, val);
 136 }
 137
 138 static void rap_cli_push_rcvbuf(struct rap_call *call, int len)
 139 {
 140         rap_cli_push_paramdesc(call, 'r');
 141         rap_cli_push_paramdesc(call, 'L');
 142         ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, len);
 143         call->rcv_datalen = len;
 144 }
 145
 146 static void rap_cli_push_sendbuf(struct rap_call *call, int len)
 147 {
 148         rap_cli_push_paramdesc(call, 's');
 149         rap_cli_push_paramdesc(call, 'T');
 150         ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, len);
 151 }
 152
 153 static void rap_cli_push_param(struct rap_call *call, uint16_t val)
 154 {
 155         rap_cli_push_paramdesc(call, 'P');
 156         ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, val);
 157 }
 158
 159 static void rap_cli_expect_multiple_entries(struct rap_call *call)
 160 {
 161         rap_cli_push_paramdesc(call, 'e');
 162         rap_cli_push_paramdesc(call, 'h');
 163         call->rcv_paramlen += 4; /* uint16_t entry count, uint16_t total */
 164 }
 165
 166 static void rap_cli_expect_word(struct rap_call *call)
 167 {
 168         rap_cli_push_paramdesc(call, 'h');
 169         call->rcv_paramlen += 2;
 170 }
 171
 172 static void rap_cli_push_string(struct rap_call *call, const char *str)
 173 {
 174         if (str == NULL) {
 175                 rap_cli_push_paramdesc(call, 'O');
 176                 return;
 177         }
 178         rap_cli_push_paramdesc(call, 'z');
 179         ndr_push_string(call->ndr_push_param, NDR_SCALARS, str);
 180 }
 181
 182 static void rap_cli_expect_format(struct rap_call *call, const char *format)
 183 {
 184         call->datadesc = format;
 185 }
 186
 187 static void rap_cli_expect_extra_format(struct rap_call *call, const char *format)
 188 {
 189         call->auxdatadesc = format;
 190 }
 191
 192 static NTSTATUS rap_pull_string(TALLOC_CTX *mem_ctx, struct ndr_pull *ndr,
 193                                 uint16_t convert, const char **dest)
 194 {
 195         uint16_t string_offset;
 196         uint16_t ignore;
 197         const char *p;
 198         size_t len;
 199
 200         NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &string_offset));
 201         NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &ignore));
 202
 203         string_offset -= convert;
 204
 205         if (string_offset+1 > ndr->data_size)
 206                 return NT_STATUS_INVALID_PARAMETER;
 207
 208         p = (const char *)(ndr->data + string_offset);
 209         len = strnlen(p, ndr->data_size-string_offset);
 210
 211         if ( string_offset + len + 1 >  ndr->data_size )
 212                 return NT_STATUS_INVALID_PARAMETER;
 213
 214         *dest = talloc_zero_array(mem_ctx, char, len+1);
 215         pull_string(discard_const_p(char, *dest), p, len+1, len, STR_ASCII);
 216
 217         return NT_STATUS_OK;
 218 }
 219
 220 static NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
 221                                 struct rap_call *call)
 222 {
 223         NTSTATUS result;
 224         DATA_BLOB param_blob;
 225         DATA_BLOB data_blob;
 226         struct ndr_push *params;
 227         struct ndr_push *data;
 228         struct smb_trans2 trans;
 229
 230         params = ndr_push_init_ctx(call);
 231
 232         if (params == NULL)
 233                 return NT_STATUS_NO_MEMORY;
 234
 235         params->flags = RAPNDR_FLAGS;
 236
 237         data = ndr_push_init_ctx(call);
 238
 239         if (data == NULL)
 240                 return NT_STATUS_NO_MEMORY;
 241
 242         data->flags = RAPNDR_FLAGS;
 243
 244         trans.in.max_param = call->rcv_paramlen;
 245         trans.in.max_data = call->rcv_datalen;
 246         trans.in.max_setup = 0;
 247         trans.in.flags = 0;
 248         trans.in.timeout = 0;
 249         trans.in.setup_count = 0;
 250         trans.in.setup = NULL;
 251         trans.in.trans_name = "\\PIPE\\LANMAN";
 252
 253         NDR_RETURN(ndr_push_uint16(params, NDR_SCALARS, call->callno));
 254         if (call->paramdesc)
 255                 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->paramdesc));
 256         if (call->datadesc)
 257                 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->datadesc));
 258
 259         param_blob = ndr_push_blob(call->ndr_push_param);
 260         NDR_RETURN(ndr_push_bytes(params, param_blob.data,
 261                                  param_blob.length));
 262
 263         data_blob = ndr_push_blob(call->ndr_push_data);
 264         NDR_RETURN(ndr_push_bytes(data, data_blob.data,
 265                                  data_blob.length));
 266
 267         if (call->auxdatadesc)
 268                 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->auxdatadesc));
 269
 270         trans.in.params = ndr_push_blob(params);
 271         trans.in.data = ndr_push_blob(data);
 272
 273         result = smb_raw_trans(tree, call, &trans);
 274
 275         if (!NT_STATUS_IS_OK(result))
 276                 return result;
 277
 278         call->ndr_pull_param = ndr_pull_init_blob(&trans.out.params, call);
 279         call->ndr_pull_param->flags = RAPNDR_FLAGS;
 280
 281         call->ndr_pull_data = ndr_pull_init_blob(&trans.out.data, call);
 282         call->ndr_pull_data->flags = RAPNDR_FLAGS;
 283
 284         return result;
 285 }
 286
 287
 288 static NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
 289                                         TALLOC_CTX *mem_ctx,
 290                                         struct rap_NetShareEnum *r)
 291 {
 292         struct rap_call *call;
 293         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 294         int i;
 295
 296         call = new_rap_cli_call(tree, RAP_WshareEnum);
 297
 298         if (call == NULL)
 299                 return NT_STATUS_NO_MEMORY;
 300
 301         rap_cli_push_word(call, r->in.level); /* Level */
 302         rap_cli_push_rcvbuf(call, r->in.bufsize);
 303         rap_cli_expect_multiple_entries(call);
 304
 305         switch(r->in.level) {
 306         case 0:
 307                 rap_cli_expect_format(call, "B13");
 308                 break;
 309         case 1:
 310                 rap_cli_expect_format(call, "B13BWz");
 311                 break;
 312         }
 313
 314         if (DEBUGLEVEL >= 10) {
 315                 NDR_PRINT_IN_DEBUG(rap_NetShareEnum, r);
 316         }
 317
 318         result = rap_cli_do_call(tree, call);
 319
 320         if (!NT_STATUS_IS_OK(result))
 321                 goto done;
 322
 323         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 324         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 325         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
 326         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
 327
 328         r->out.info = talloc_array(mem_ctx, union rap_share_info, r->out.count);
 329
 330         if (r->out.info == NULL) {
 331                 result = NT_STATUS_NO_MEMORY;
 332                 goto done;
 333         }
 334
 335         for (i=0; i<r->out.count; i++) {
 336                 switch(r->in.level) {
 337                 case 0:
 338                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 339                                                 r->out.info[i].info0.share_name, 13));
 340                         break;
 341                 case 1:
 342                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 343                                                 r->out.info[i].info1.share_name, 13));
 344                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 345                                                 &r->out.info[i].info1.reserved1, 1));
 346                         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_data,
 347                                                NDR_SCALARS, &r->out.info[i].info1.share_type));
 348                         RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
 349                                                r->out.convert,
 350                                                &r->out.info[i].info1.comment));
 351                         break;
 352                 }
 353         }
 354
 355         if (DEBUGLEVEL >= 10) {
 356                 NDR_PRINT_OUT_DEBUG(rap_NetShareEnum, r);
 357         }
 358         result = NT_STATUS_OK;
 359
 360  done:
 361         talloc_free(call);
 362         return result;
 363 }
 364
 365 static bool test_netshareenum(struct torture_context *tctx,
 366                               struct smbcli_state *cli)
 367 {
 368         struct rap_NetShareEnum r;
 369         int i;
 370
 371         r.in.level = 1;
 372         r.in.bufsize = 8192;
 373
 374         torture_assert_ntstatus_ok(tctx,
 375                 smbcli_rap_netshareenum(cli->tree, tctx, &r), "");
 376
 377         for (i=0; i<r.out.count; i++) {
 378                 printf("%s %d %s\n", r.out.info[i].info1.share_name,
 379                        r.out.info[i].info1.share_type,
 380                        r.out.info[i].info1.comment);
 381         }
 382
 383         return true;
 384 }
 385
 386 static NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
 387                                           TALLOC_CTX *mem_ctx,
 388                                           struct rap_NetServerEnum2 *r)
 389 {
 390         struct rap_call *call;
 391         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 392         int i;
 393
 394         call = new_rap_cli_call(mem_ctx, RAP_NetServerEnum2);
 395
 396         if (call == NULL)
 397                 return NT_STATUS_NO_MEMORY;
 398
 399         rap_cli_push_word(call, r->in.level);
 400         rap_cli_push_rcvbuf(call, r->in.bufsize);
 401         rap_cli_expect_multiple_entries(call);
 402         rap_cli_push_dword(call, r->in.servertype);
 403         rap_cli_push_string(call, r->in.domain);
 404
 405         switch(r->in.level) {
 406         case 0:
 407                 rap_cli_expect_format(call, "B16");
 408                 break;
 409         case 1:
 410                 rap_cli_expect_format(call, "B16BBDz");
 411                 break;
 412         }
 413
 414         if (DEBUGLEVEL >= 10) {
 415                 NDR_PRINT_IN_DEBUG(rap_NetServerEnum2, r);
 416         }
 417
 418         result = rap_cli_do_call(tree, call);
 419
 420         if (!NT_STATUS_IS_OK(result))
 421                 goto done;
 422
 423         result = NT_STATUS_INVALID_PARAMETER;
 424
 425         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 426         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 427         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
 428         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
 429
 430         r->out.info = talloc_array(mem_ctx, union rap_server_info, r->out.count);
 431
 432         if (r->out.info == NULL) {
 433                 result = NT_STATUS_NO_MEMORY;
 434                 goto done;
 435         }
 436
 437         for (i=0; i<r->out.count; i++) {
 438                 switch(r->in.level) {
 439                 case 0:
 440                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 441                                                 r->out.info[i].info0.name, 16));
 442                         break;
 443                 case 1:
 444                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 445                                                 r->out.info[i].info1.name, 16));
 446                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 447                                               &r->out.info[i].info1.version_major, 1));
 448                         NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 449                                               &r->out.info[i].info1.version_minor, 1));
 450                         NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
 451                                                NDR_SCALARS, &r->out.info[i].info1.servertype));
 452                         RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
 453                                                r->out.convert,
 454                                                &r->out.info[i].info1.comment));
 455                 }
 456         }
 457
 458         if (DEBUGLEVEL >= 10) {
 459                 NDR_PRINT_OUT_DEBUG(rap_NetServerEnum2, r);
 460         }
 461
 462         result = NT_STATUS_OK;
 463
 464  done:
 465         talloc_free(call);
 466         return result;
 467 }
 468
 469 static bool test_netserverenum(struct torture_context *tctx,
 470                                struct smbcli_state *cli)
 471 {
 472         struct rap_NetServerEnum2 r;
 473         int i;
 474
 475         r.in.level = 0;
 476         r.in.bufsize = 8192;
 477         r.in.servertype = 0xffffffff;
 478         r.in.servertype = 0x80000000;
 479         r.in.domain = NULL;
 480
 481         torture_assert_ntstatus_ok(tctx,
 482                    smbcli_rap_netserverenum2(cli->tree, tctx, &r), "");
 483
 484         for (i=0; i<r.out.count; i++) {
 485                 switch (r.in.level) {
 486                 case 0:
 487                         printf("%s\n", r.out.info[i].info0.name);
 488                         break;
 489                 case 1:
 490                         printf("%s %x %s\n", r.out.info[i].info1.name,
 491                                r.out.info[i].info1.servertype,
 492                                r.out.info[i].info1.comment);
 493                         break;
 494                 }
 495         }
 496
 497         return true;
 498 }
 499
 500 NTSTATUS smbcli_rap_netservergetinfo(struct smbcli_tree *tree,
 501                                      TALLOC_CTX *mem_ctx,
 502                                      struct rap_WserverGetInfo *r)
 503 {
 504         struct rap_call *call;
 505         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 506
 507         if (!(call = new_rap_cli_call(mem_ctx, RAP_WserverGetInfo))) {
 508                 return NT_STATUS_NO_MEMORY;
 509         }
 510
 511         rap_cli_push_word(call, r->in.level);
 512         rap_cli_push_rcvbuf(call, r->in.bufsize);
 513         rap_cli_expect_word(call);
 514
 515         switch(r->in.level) {
 516         case 0:
 517                 rap_cli_expect_format(call, "B16");
 518                 break;
 519         case 1:
 520                 rap_cli_expect_format(call, "B16BBDz");
 521                 break;
 522         default:
 523                 result = NT_STATUS_INVALID_PARAMETER;
 524                 goto done;
 525         }
 526
 527         if (DEBUGLEVEL >= 10) {
 528                 NDR_PRINT_IN_DEBUG(rap_WserverGetInfo, r);
 529         }
 530
 531         result = rap_cli_do_call(tree, call);
 532
 533         if (!NT_STATUS_IS_OK(result))
 534                 goto done;
 535
 536         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 537         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 538         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
 539
 540         switch(r->in.level) {
 541         case 0:
 542                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 543                                         r->out.info.info0.name, 16));
 544                 break;
 545         case 1:
 546                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 547                                         r->out.info.info1.name, 16));
 548                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 549                                       &r->out.info.info1.version_major, 1));
 550                 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
 551                                       &r->out.info.info1.version_minor, 1));
 552                 NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
 553                                        NDR_SCALARS, &r->out.info.info1.servertype));
 554                 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
 555                                        r->out.convert,
 556                                        &r->out.info.info1.comment));
 557         }
 558
 559         if (DEBUGLEVEL >= 10) {
 560                 NDR_PRINT_OUT_DEBUG(rap_WserverGetInfo, r);
 561         }
 562  done:
 563         talloc_free(call);
 564         return result;
 565 }
 566
 567 static enum ndr_err_code ndr_pull_rap_NetPrintQEnum_data(struct ndr_pull *ndr, struct rap_NetPrintQEnum *r)
 568 {
 569         uint32_t cntr_info_0;
 570         TALLOC_CTX *_mem_save_info_0;
 571
 572         NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
 573         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 574         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
 575         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
 576                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
 577                 NDR_CHECK(ndr_pull_rap_printq_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
 578         }
 579         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
 580                 NDR_CHECK(ndr_pull_rap_printq_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
 581         }
 582         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 583
 584         return NDR_ERR_SUCCESS;
 585 }
 586
 587 NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
 588                                   TALLOC_CTX *mem_ctx,
 589                                   struct rap_NetPrintQEnum *r)
 590 {
 591         struct rap_call *call;
 592         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 593
 594         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQEnum))) {
 595                 return NT_STATUS_NO_MEMORY;
 596         }
 597
 598         rap_cli_push_word(call, r->in.level);
 599         rap_cli_push_rcvbuf(call, r->in.bufsize);
 600         rap_cli_expect_multiple_entries(call);
 601
 602         switch(r->in.level) {
 603         case 0:
 604                 rap_cli_expect_format(call, "B13");
 605                 break;
 606         case 1:
 607                 rap_cli_expect_format(call, "B13BWWWzzzzzWW");
 608                 break;
 609         case 2:
 610                 rap_cli_expect_format(call, "B13BWWWzzzzzWN");
 611                 rap_cli_expect_extra_format(call, "WB21BB16B10zWWzDDz");
 612                 break;
 613         case 3:
 614                 rap_cli_expect_format(call, "zWWWWzzzzWWzzl");
 615                 break;
 616         case 4:
 617                 rap_cli_expect_format(call, "zWWWWzzzzWNzzl");
 618                 rap_cli_expect_extra_format(call, "WWzWWDDzz");
 619                 /* no mention of extra format in MS-RAP */
 620                 break;
 621         case 5:
 622                 rap_cli_expect_format(call, "z");
 623                 break;
 624         default:
 625                 result = NT_STATUS_INVALID_PARAMETER;
 626                 goto done;
 627         }
 628
 629         if (DEBUGLEVEL >= 10) {
 630                 NDR_PRINT_IN_DEBUG(rap_NetPrintQEnum, r);
 631         }
 632
 633         result = rap_cli_do_call(tree, call);
 634
 635         if (!NT_STATUS_IS_OK(result))
 636                 goto done;
 637
 638         result = NT_STATUS_INVALID_PARAMETER;
 639
 640         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 641         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 642         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
 643         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
 644
 645         call->ndr_pull_data->relative_rap_convert = r->out.convert;
 646
 647         NDR_GOTO(ndr_pull_rap_NetPrintQEnum_data(call->ndr_pull_data, r));
 648
 649         r->out.info = talloc_steal(mem_ctx, r->out.info);
 650
 651         if (DEBUGLEVEL >= 10) {
 652                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQEnum, r);
 653         }
 654
 655         result = NT_STATUS_OK;
 656
 657  done:
 658         talloc_free(call);
 659         return result;
 660 }
 661
 662 NTSTATUS smbcli_rap_netprintqgetinfo(struct smbcli_tree *tree,
 663                                      TALLOC_CTX *mem_ctx,
 664                                      struct rap_NetPrintQGetInfo *r)
 665 {
 666         struct rap_call *call;
 667         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 668
 669         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQGetInfo))) {
 670                 return NT_STATUS_NO_MEMORY;
 671         }
 672
 673         rap_cli_push_string(call, r->in.PrintQueueName);
 674         rap_cli_push_word(call, r->in.level);
 675         rap_cli_push_rcvbuf(call, r->in.bufsize);
 676         rap_cli_expect_word(call);
 677
 678         switch(r->in.level) {
 679         case 0:
 680                 rap_cli_expect_format(call, "B13");
 681                 break;
 682         case 1:
 683                 rap_cli_expect_format(call, "B13BWWWzzzzzWW");
 684                 break;
 685         case 2:
 686                 rap_cli_expect_format(call, "B13BWWWzzzzzWN");
 687                 rap_cli_expect_extra_format(call, "WB21BB16B10zWWzDDz");
 688                 break;
 689         case 3:
 690                 rap_cli_expect_format(call, "zWWWWzzzzWWzzl");
 691                 break;
 692         case 4:
 693                 rap_cli_expect_format(call, "zWWWWzzzzWNzzl");
 694                 rap_cli_expect_extra_format(call, "WWzWWDDzz");
 695                 /* no mention of extra format in MS-RAP */
 696                 break;
 697         case 5:
 698                 rap_cli_expect_format(call, "z");
 699                 break;
 700         default:
 701                 result = NT_STATUS_INVALID_PARAMETER;
 702                 goto done;
 703         }
 704
 705         if (DEBUGLEVEL >= 10) {
 706                 NDR_PRINT_IN_DEBUG(rap_NetPrintQGetInfo, r);
 707         }
 708
 709         result = rap_cli_do_call(tree, call);
 710
 711         if (!NT_STATUS_IS_OK(result))
 712                 goto done;
 713
 714         result = NT_STATUS_INVALID_PARAMETER;
 715
 716         ZERO_STRUCT(r->out);
 717
 718         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 719         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 720         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
 721
 722         call->ndr_pull_data->relative_rap_convert = r->out.convert;
 723
 724         NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
 725         NDR_GOTO(ndr_pull_rap_printq_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
 726
 727         if (DEBUGLEVEL >= 10) {
 728                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQGetInfo, r);
 729         }
 730
 731         result = NT_STATUS_OK;
 732  done:
 733         talloc_free(call);
 734         return result;
 735 }
 736
 737 NTSTATUS smbcli_rap_netprintjobpause(struct smbcli_tree *tree,
 738                                      TALLOC_CTX *mem_ctx,
 739                                      struct rap_NetPrintJobPause *r)
 740 {
 741         struct rap_call *call;
 742         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 743
 744         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobPause))) {
 745                 return NT_STATUS_NO_MEMORY;
 746         }
 747
 748         rap_cli_push_word(call, r->in.JobID);
 749
 750         rap_cli_expect_format(call, "W");
 751
 752         if (DEBUGLEVEL >= 10) {
 753                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobPause, r);
 754         }
 755
 756         result = rap_cli_do_call(tree, call);
 757
 758         if (!NT_STATUS_IS_OK(result))
 759                 goto done;
 760
 761         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 762         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 763
 764         if (DEBUGLEVEL >= 10) {
 765                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobPause, r);
 766         }
 767
 768  done:
 769         talloc_free(call);
 770         return result;
 771 }
 772
 773 NTSTATUS smbcli_rap_netprintjobcontinue(struct smbcli_tree *tree,
 774                                         TALLOC_CTX *mem_ctx,
 775                                         struct rap_NetPrintJobContinue *r)
 776 {
 777         struct rap_call *call;
 778         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 779
 780         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobContinue))) {
 781                 return NT_STATUS_NO_MEMORY;
 782         }
 783
 784         rap_cli_push_word(call, r->in.JobID);
 785
 786         rap_cli_expect_format(call, "W");
 787
 788         if (DEBUGLEVEL >= 10) {
 789                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobContinue, r);
 790         }
 791
 792         result = rap_cli_do_call(tree, call);
 793
 794         if (!NT_STATUS_IS_OK(result))
 795                 goto done;
 796
 797         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 798         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 799
 800         if (DEBUGLEVEL >= 10) {
 801                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobContinue, r);
 802         }
 803
 804  done:
 805         talloc_free(call);
 806         return result;
 807 }
 808
 809 NTSTATUS smbcli_rap_netprintjobdelete(struct smbcli_tree *tree,
 810                                       TALLOC_CTX *mem_ctx,
 811                                       struct rap_NetPrintJobDelete *r)
 812 {
 813         struct rap_call *call;
 814         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 815
 816         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobDel))) {
 817                 return NT_STATUS_NO_MEMORY;
 818         }
 819
 820         rap_cli_push_word(call, r->in.JobID);
 821
 822         rap_cli_expect_format(call, "W");
 823
 824         if (DEBUGLEVEL >= 10) {
 825                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobDelete, r);
 826         }
 827
 828         result = rap_cli_do_call(tree, call);
 829
 830         if (!NT_STATUS_IS_OK(result))
 831                 goto done;
 832
 833         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 834         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 835
 836         if (DEBUGLEVEL >= 10) {
 837                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobDelete, r);
 838         }
 839
 840  done:
 841         talloc_free(call);
 842         return result;
 843 }
 844
 845 NTSTATUS smbcli_rap_netprintqueuepause(struct smbcli_tree *tree,
 846                                        TALLOC_CTX *mem_ctx,
 847                                        struct rap_NetPrintQueuePause *r)
 848 {
 849         struct rap_call *call;
 850         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 851
 852         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPause))) {
 853                 return NT_STATUS_NO_MEMORY;
 854         }
 855
 856         rap_cli_push_string(call, r->in.PrintQueueName);
 857
 858         rap_cli_expect_format(call, "");
 859
 860         if (DEBUGLEVEL >= 10) {
 861                 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePause, r);
 862         }
 863
 864         result = rap_cli_do_call(tree, call);
 865
 866         if (!NT_STATUS_IS_OK(result))
 867                 goto done;
 868
 869         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 870         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 871
 872         if (DEBUGLEVEL >= 10) {
 873                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePause, r);
 874         }
 875
 876  done:
 877         talloc_free(call);
 878         return result;
 879 }
 880
 881 NTSTATUS smbcli_rap_netprintqueueresume(struct smbcli_tree *tree,
 882                                         TALLOC_CTX *mem_ctx,
 883                                         struct rap_NetPrintQueueResume *r)
 884 {
 885         struct rap_call *call;
 886         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 887
 888         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQContinue))) {
 889                 return NT_STATUS_NO_MEMORY;
 890         }
 891
 892         rap_cli_push_string(call, r->in.PrintQueueName);
 893
 894         rap_cli_expect_format(call, "");
 895
 896         if (DEBUGLEVEL >= 10) {
 897                 NDR_PRINT_IN_DEBUG(rap_NetPrintQueueResume, r);
 898         }
 899
 900         result = rap_cli_do_call(tree, call);
 901
 902         if (!NT_STATUS_IS_OK(result))
 903                 goto done;
 904
 905         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 906         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 907
 908         if (DEBUGLEVEL >= 10) {
 909                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueueResume, r);
 910         }
 911
 912  done:
 913         talloc_free(call);
 914         return result;
 915 }
 916
 917 NTSTATUS smbcli_rap_netprintqueuepurge(struct smbcli_tree *tree,
 918                                        TALLOC_CTX *mem_ctx,
 919                                        struct rap_NetPrintQueuePurge *r)
 920 {
 921         struct rap_call *call;
 922         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 923
 924         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPurge))) {
 925                 return NT_STATUS_NO_MEMORY;
 926         }
 927
 928         rap_cli_push_string(call, r->in.PrintQueueName);
 929
 930         rap_cli_expect_format(call, "");
 931
 932         if (DEBUGLEVEL >= 10) {
 933                 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePurge, r);
 934         }
 935
 936         result = rap_cli_do_call(tree, call);
 937
 938         if (!NT_STATUS_IS_OK(result))
 939                 goto done;
 940
 941         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 942         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 943
 944         if (DEBUGLEVEL >= 10) {
 945                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePurge, r);
 946         }
 947
 948  done:
 949         talloc_free(call);
 950         return result;
 951 }
 952
 953 static enum ndr_err_code ndr_pull_rap_NetPrintJobEnum_data(struct ndr_pull *ndr, struct rap_NetPrintJobEnum *r)
 954 {
 955         uint32_t cntr_info_0;
 956         TALLOC_CTX *_mem_save_info_0;
 957
 958         NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
 959         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 960         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
 961         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
 962                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
 963                 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
 964         }
 965         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
 966                 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
 967         }
 968         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 969
 970         return NDR_ERR_SUCCESS;
 971 }
 972
 973 NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
 974                                     TALLOC_CTX *mem_ctx,
 975                                     struct rap_NetPrintJobEnum *r)
 976 {
 977         struct rap_call *call;
 978         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 979
 980         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobEnum))) {
 981                 return NT_STATUS_NO_MEMORY;
 982         }
 983
 984         rap_cli_push_string(call, r->in.PrintQueueName);
 985         rap_cli_push_word(call, r->in.level);
 986         rap_cli_push_rcvbuf(call, r->in.bufsize);
 987         rap_cli_expect_multiple_entries(call);
 988
 989         switch(r->in.level) {
 990         case 0:
 991                 rap_cli_expect_format(call, "W");
 992                 break;
 993         case 1:
 994                 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
 995                 break;
 996         case 2:
 997                 rap_cli_expect_format(call, "WWzWWDDzz");
 998                 break;
 999         case 3:
1000                 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
1001                 break;
1002         case 4:
1003                 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
1004                 break;
1005         default:
1006                 result = NT_STATUS_INVALID_PARAMETER;
1007                 goto done;
1008         }
1009
1010         if (DEBUGLEVEL >= 10) {
1011                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobEnum, r);
1012         }
1013
1014         result = rap_cli_do_call(tree, call);
1015
1016         if (!NT_STATUS_IS_OK(result))
1017                 goto done;
1018
1019         result = NT_STATUS_INVALID_PARAMETER;
1020
1021         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1022         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1023         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1024         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1025
1026         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1027
1028         NDR_GOTO(ndr_pull_rap_NetPrintJobEnum_data(call->ndr_pull_data, r));
1029
1030         if (DEBUGLEVEL >= 10) {
1031                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobEnum, r);
1032         }
1033
1034         r->out.info = talloc_steal(mem_ctx, r->out.info);
1035
1036         result = NT_STATUS_OK;
1037
1038  done:
1039         talloc_free(call);
1040         return result;
1041 }
1042
1043 NTSTATUS smbcli_rap_netprintjobgetinfo(struct smbcli_tree *tree,
1044                                        TALLOC_CTX *mem_ctx,
1045                                        struct rap_NetPrintJobGetInfo *r)
1046 {
1047         struct rap_call *call;
1048         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1049
1050         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobGetInfo))) {
1051                 return NT_STATUS_NO_MEMORY;
1052         }
1053
1054         rap_cli_push_word(call, r->in.JobID);
1055         rap_cli_push_word(call, r->in.level);
1056         rap_cli_push_rcvbuf(call, r->in.bufsize);
1057         rap_cli_expect_word(call);
1058
1059         switch(r->in.level) {
1060         case 0:
1061                 rap_cli_expect_format(call, "W");
1062                 break;
1063         case 1:
1064                 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
1065                 break;
1066         case 2:
1067                 rap_cli_expect_format(call, "WWzWWDDzz");
1068                 break;
1069         case 3:
1070                 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
1071                 break;
1072         case 4:
1073                 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
1074                 break;
1075         default:
1076                 result = NT_STATUS_INVALID_PARAMETER;
1077                 goto done;
1078         }
1079
1080         if (DEBUGLEVEL >= 10) {
1081                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobGetInfo, r);
1082         }
1083
1084         result = rap_cli_do_call(tree, call);
1085
1086         if (!NT_STATUS_IS_OK(result))
1087                 goto done;
1088
1089         result = NT_STATUS_INVALID_PARAMETER;
1090
1091         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1092         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1093         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1094
1095         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1096
1097         NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1098         NDR_GOTO(ndr_pull_rap_printj_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1099
1100         if (DEBUGLEVEL >= 10) {
1101                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobGetInfo, r);
1102         }
1103
1104         result = NT_STATUS_OK;
1105
1106  done:
1107         talloc_free(call);
1108         return result;
1109 }
1110
1111 NTSTATUS smbcli_rap_netprintjobsetinfo(struct smbcli_tree *tree,
1112                                        TALLOC_CTX *mem_ctx,
1113                                        struct rap_NetPrintJobSetInfo *r)
1114 {
1115         struct rap_call *call;
1116         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1117
1118         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobSetInfo))) {
1119                 return NT_STATUS_NO_MEMORY;
1120         }
1121
1122         rap_cli_push_word(call, r->in.JobID);
1123         rap_cli_push_word(call, r->in.level);
1124         rap_cli_push_sendbuf(call, r->in.bufsize);
1125         rap_cli_push_param(call, r->in.ParamNum);
1126
1127         switch (r->in.ParamNum) {
1128         case RAP_PARAM_JOBNUM:
1129         case RAP_PARAM_JOBPOSITION:
1130         case RAP_PARAM_JOBSTATUS:
1131                 NDR_GOTO(ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, r->in.Param.value));
1132                 break;
1133         case RAP_PARAM_USERNAME:
1134         case RAP_PARAM_NOTIFYNAME:
1135         case RAP_PARAM_DATATYPE:
1136         case RAP_PARAM_PARAMETERS_STRING:
1137         case RAP_PARAM_JOBSTATUSSTR:
1138         case RAP_PARAM_JOBCOMMENT:
1139                 NDR_GOTO(ndr_push_string(call->ndr_push_param, NDR_SCALARS, r->in.Param.string));
1140                 break;
1141         case RAP_PARAM_TIMESUBMITTED:
1142         case RAP_PARAM_JOBSIZE:
1143                 NDR_GOTO(ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, r->in.Param.value4));
1144                 break;
1145         default:
1146                 result = NT_STATUS_INVALID_PARAMETER;
1147                 break;
1148         }
1149
1150         /* not really sure if this is correct */
1151         rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
1152
1153         if (DEBUGLEVEL >= 10) {
1154                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobSetInfo, r);
1155         }
1156
1157         result = rap_cli_do_call(tree, call);
1158
1159         if (!NT_STATUS_IS_OK(result))
1160                 goto done;
1161
1162         result = NT_STATUS_INVALID_PARAMETER;
1163
1164         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1165         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1166
1167         result = NT_STATUS_OK;
1168
1169         if (!NT_STATUS_IS_OK(result)) {
1170                 goto done;
1171         }
1172
1173         if (DEBUGLEVEL >= 10) {
1174                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobSetInfo, r);
1175         }
1176
1177  done:
1178         talloc_free(call);
1179         return result;
1180 }
1181
1182 static enum ndr_err_code ndr_pull_rap_NetPrintDestEnum_data(struct ndr_pull *ndr, struct rap_NetPrintDestEnum *r)
1183 {
1184         uint32_t cntr_info_0;
1185         TALLOC_CTX *_mem_save_info_0;
1186
1187         NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
1188         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1189         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
1190         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1191                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
1192                 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
1193         }
1194         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1195                 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
1196         }
1197         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1198
1199         return NDR_ERR_SUCCESS;
1200 }
1201
1202
1203 NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
1204                                      TALLOC_CTX *mem_ctx,
1205                                      struct rap_NetPrintDestEnum *r)
1206 {
1207         struct rap_call *call;
1208         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1209
1210         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestEnum))) {
1211                 return NT_STATUS_NO_MEMORY;
1212         }
1213
1214         rap_cli_push_word(call, r->in.level);
1215         rap_cli_push_rcvbuf(call, r->in.bufsize);
1216         rap_cli_expect_multiple_entries(call);
1217
1218         switch(r->in.level) {
1219         case 0:
1220                 rap_cli_expect_format(call, "B9");
1221                 break;
1222         case 1:
1223                 rap_cli_expect_format(call, "B9B21WWzW");
1224                 break;
1225         case 2:
1226                 rap_cli_expect_format(call, "z");
1227                 break;
1228         case 3:
1229                 rap_cli_expect_format(call, "zzzWWzzzWW");
1230                 break;
1231         default:
1232                 result = NT_STATUS_INVALID_PARAMETER;
1233                 goto done;
1234         }
1235
1236         if (DEBUGLEVEL >= 10) {
1237                 NDR_PRINT_IN_DEBUG(rap_NetPrintDestEnum, r);
1238         }
1239
1240         result = rap_cli_do_call(tree, call);
1241
1242         if (!NT_STATUS_IS_OK(result))
1243                 goto done;
1244
1245         result = NT_STATUS_INVALID_PARAMETER;
1246
1247         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1248         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1249         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1250         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1251
1252         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1253
1254         NDR_GOTO(ndr_pull_rap_NetPrintDestEnum_data(call->ndr_pull_data, r));
1255
1256         r->out.info = talloc_steal(mem_ctx, r->out.info);
1257
1258         if (DEBUGLEVEL >= 10) {
1259                 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestEnum, r);
1260         }
1261
1262         result = NT_STATUS_OK;
1263
1264  done:
1265         talloc_free(call);
1266         return result;
1267 }
1268
1269 NTSTATUS smbcli_rap_netprintdestgetinfo(struct smbcli_tree *tree,
1270                                         TALLOC_CTX *mem_ctx,
1271                                         struct rap_NetPrintDestGetInfo *r)
1272 {
1273         struct rap_call *call;
1274         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1275
1276         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestGetInfo))) {
1277                 return NT_STATUS_NO_MEMORY;
1278         }
1279
1280         rap_cli_push_string(call, r->in.PrintDestName);
1281         rap_cli_push_word(call, r->in.level);
1282         rap_cli_push_rcvbuf(call, r->in.bufsize);
1283         rap_cli_expect_word(call);
1284
1285         switch(r->in.level) {
1286         case 0:
1287                 rap_cli_expect_format(call, "B9");
1288                 break;
1289         case 1:
1290                 rap_cli_expect_format(call, "B9B21WWzW");
1291                 break;
1292         case 2:
1293                 rap_cli_expect_format(call, "z");
1294                 break;
1295         case 3:
1296                 rap_cli_expect_format(call, "zzzWWzzzWW");
1297                 break;
1298         default:
1299                 result = NT_STATUS_INVALID_PARAMETER;
1300                 goto done;
1301         }
1302
1303         if (DEBUGLEVEL >= 10) {
1304                 NDR_PRINT_IN_DEBUG(rap_NetPrintDestGetInfo, r);
1305         }
1306
1307         result = rap_cli_do_call(tree, call);
1308
1309         if (!NT_STATUS_IS_OK(result))
1310                 goto done;
1311
1312         result = NT_STATUS_INVALID_PARAMETER;
1313
1314         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1315         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1316         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1317
1318         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1319
1320         NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1321         NDR_GOTO(ndr_pull_rap_printdest_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1322
1323         if (DEBUGLEVEL >= 10) {
1324                 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestGetInfo, r);
1325         }
1326
1327         result = NT_STATUS_OK;
1328
1329  done:
1330         talloc_free(call);
1331         return result;
1332 }
1333
1334 NTSTATUS smbcli_rap_netuserpasswordset2(struct smbcli_tree *tree,
1335                                         struct smb_iconv_convenience *iconv_convenience,
1336                                         TALLOC_CTX *mem_ctx,
1337                                         struct rap_NetUserPasswordSet2 *r)
1338 {
1339         struct rap_call *call;
1340         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1341
1342         if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserPasswordSet2))) {
1343                 return NT_STATUS_NO_MEMORY;
1344         }
1345
1346         rap_cli_push_string(call, r->in.UserName);
1347         rap_cli_push_paramdesc(call, 'b');
1348         rap_cli_push_paramdesc(call, '1');
1349         rap_cli_push_paramdesc(call, '6');
1350         ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.OldPassword, 16);
1351         rap_cli_push_paramdesc(call, 'b');
1352         rap_cli_push_paramdesc(call, '1');
1353         rap_cli_push_paramdesc(call, '6');
1354         ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.NewPassword, 16);
1355         rap_cli_push_word(call, r->in.EncryptedPassword);
1356         rap_cli_push_word(call, r->in.RealPasswordLength);
1357
1358         rap_cli_expect_format(call, "");
1359
1360         if (DEBUGLEVEL >= 10) {
1361                 NDR_PRINT_IN_DEBUG(rap_NetUserPasswordSet2, r);
1362         }
1363
1364         result = rap_cli_do_call(tree, call);
1365
1366         if (!NT_STATUS_IS_OK(result))
1367                 goto done;
1368
1369         result = NT_STATUS_INVALID_PARAMETER;
1370
1371         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1372         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1373
1374         result = NT_STATUS_OK;
1375
1376         if (!NT_STATUS_IS_OK(result)) {
1377                 goto done;
1378         }
1379
1380         if (DEBUGLEVEL >= 10) {
1381                 NDR_PRINT_OUT_DEBUG(rap_NetUserPasswordSet2, r);
1382         }
1383
1384  done:
1385         talloc_free(call);
1386         return result;
1387 }
1388
1389 NTSTATUS smbcli_rap_netoemchangepassword(struct smbcli_tree *tree,
1390                                          struct smb_iconv_convenience *iconv_convenience,
1391                                          TALLOC_CTX *mem_ctx,
1392                                          struct rap_NetOEMChangePassword *r)
1393 {
1394         struct rap_call *call;
1395         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1396
1397         if (!(call = new_rap_cli_call(mem_ctx, RAP_SamOEMChgPasswordUser2_P))) {
1398                 return NT_STATUS_NO_MEMORY;
1399         }
1400
1401         rap_cli_push_string(call, r->in.UserName);
1402         rap_cli_push_sendbuf(call, 532);
1403         ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.crypt_password, 516);
1404         ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.password_hash, 16);
1405
1406         rap_cli_expect_format(call, "B516B16");
1407
1408         if (DEBUGLEVEL >= 10) {
1409                 NDR_PRINT_IN_DEBUG(rap_NetOEMChangePassword, r);
1410         }
1411
1412         result = rap_cli_do_call(tree, call);
1413
1414         if (!NT_STATUS_IS_OK(result))
1415                 goto done;
1416
1417         result = NT_STATUS_INVALID_PARAMETER;
1418
1419         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1420         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1421
1422         result = NT_STATUS_OK;
1423
1424         if (!NT_STATUS_IS_OK(result)) {
1425                 goto done;
1426         }
1427
1428         if (DEBUGLEVEL >= 10) {
1429                 NDR_PRINT_OUT_DEBUG(rap_NetOEMChangePassword, r);
1430         }
1431
1432  done:
1433         talloc_free(call);
1434         return result;
1435 }
1436
1437 NTSTATUS smbcli_rap_netusergetinfo(struct smbcli_tree *tree,
1438                                    TALLOC_CTX *mem_ctx,
1439                                    struct rap_NetUserGetInfo *r)
1440 {
1441         struct rap_call *call;
1442         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1443
1444         if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserGetInfo))) {
1445                 return NT_STATUS_NO_MEMORY;
1446         }
1447
1448         rap_cli_push_string(call, r->in.UserName);
1449         rap_cli_push_word(call, r->in.level);
1450         rap_cli_push_rcvbuf(call, r->in.bufsize);
1451         rap_cli_expect_word(call);
1452
1453         switch(r->in.level) {
1454         case 0:
1455                 rap_cli_expect_format(call, "B21");
1456                 break;
1457         case 1:
1458                 rap_cli_expect_format(call, "B21BB16DWzzWz");
1459                 break;
1460         case 2:
1461                 rap_cli_expect_format(call, "B21BB16DWzzWzDzzzzDDDDWb21WWzWW");
1462                 break;
1463         case 10:
1464                 rap_cli_expect_format(call, "B21Bzzz");
1465                 break;
1466         case 11:
1467                 rap_cli_expect_format(call, "B21BzzzWDDzzDDWWzWzDWb21W");
1468                 break;
1469         default:
1470                 result = NT_STATUS_INVALID_PARAMETER;
1471                 goto done;
1472         }
1473
1474         if (DEBUGLEVEL >= 10) {
1475                 NDR_PRINT_IN_DEBUG(rap_NetUserGetInfo, r);
1476         }
1477
1478         result = rap_cli_do_call(tree, call);
1479
1480         if (!NT_STATUS_IS_OK(result))
1481                 goto done;
1482
1483         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1484         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1485         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1486
1487         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1488
1489         NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1490         NDR_GOTO(ndr_pull_rap_netuser_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1491
1492         if (DEBUGLEVEL >= 10) {
1493                 NDR_PRINT_OUT_DEBUG(rap_NetUserGetInfo, r);
1494         }
1495
1496         result = NT_STATUS_OK;
1497
1498  done:
1499         talloc_free(call);
1500         return result;
1501 }
1502
1503
1504 static bool test_netservergetinfo(struct torture_context *tctx,
1505                                   struct smbcli_state *cli)
1506 {
1507         struct rap_WserverGetInfo r;
1508         bool res = true;
1509
1510         r.in.bufsize = 0xffff;
1511
1512         r.in.level = 0;
1513         torture_assert_ntstatus_ok(tctx,
1514                 smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
1515                 "rap_netservergetinfo level 0 failed");
1516         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
1517                 "rap_netservergetinfo level 0 failed");
1518
1519         r.in.level = 1;
1520         torture_assert_ntstatus_ok(tctx,
1521                 smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
1522                 "rap_netservergetinfo level 1 failed");
1523         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
1524                 "rap_netservergetinfo level 1 failed");
1525
1526         return res;
1527 }
1528
1529 bool torture_rap_scan(struct torture_context *torture, struct smbcli_state *cli)
1530 {
1531         int callno;
1532
1533         for (callno = 0; callno < 0xffff; callno++) {
1534                 struct rap_call *call = new_rap_cli_call(torture, callno);
1535                 NTSTATUS result;
1536
1537                 result = rap_cli_do_call(cli->tree, call);
1538
1539                 if (!NT_STATUS_EQUAL(result, NT_STATUS_INVALID_PARAMETER))
1540                         continue;
1541
1542                 printf("callno %d is RAP call\n", callno);
1543         }
1544
1545         return true;
1546 }
1547
1548 NTSTATUS torture_rap_init(void)
1549 {
1550         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "RAP");
1551         struct torture_suite *suite_basic = torture_suite_create(suite, "BASIC");
1552
1553         torture_suite_add_suite(suite, suite_basic);
1554         torture_suite_add_suite(suite, torture_rap_rpc(suite));
1555         torture_suite_add_suite(suite, torture_rap_printing(suite));
1556         torture_suite_add_suite(suite, torture_rap_sam(suite));
1557
1558         torture_suite_add_1smb_test(suite_basic, "netserverenum",
1559                                     test_netserverenum);
1560         torture_suite_add_1smb_test(suite_basic, "netshareenum",
1561                                     test_netshareenum);
1562         torture_suite_add_1smb_test(suite_basic, "netservergetinfo",
1563                                     test_netservergetinfo);
1564
1565         torture_suite_add_1smb_test(suite, "SCAN", torture_rap_scan);
1566
1567         suite->description = talloc_strdup(suite,
1568                                                 "Remote Administration Protocol tests");
1569
1570         torture_register_suite(suite);
1571
1572         return NT_STATUS_OK;
1573 }