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         if (r->out.status == 0) {
 723                 call->ndr_pull_data->relative_rap_convert = r->out.convert;
 724
 725                 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
 726                 NDR_GOTO(ndr_pull_rap_printq_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
 727         }
 728
 729         if (DEBUGLEVEL >= 10) {
 730                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQGetInfo, r);
 731         }
 732
 733         result = NT_STATUS_OK;
 734  done:
 735         talloc_free(call);
 736         return result;
 737 }
 738
 739 NTSTATUS smbcli_rap_netprintjobpause(struct smbcli_tree *tree,
 740                                      TALLOC_CTX *mem_ctx,
 741                                      struct rap_NetPrintJobPause *r)
 742 {
 743         struct rap_call *call;
 744         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 745
 746         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobPause))) {
 747                 return NT_STATUS_NO_MEMORY;
 748         }
 749
 750         rap_cli_push_word(call, r->in.JobID);
 751
 752         rap_cli_expect_format(call, "W");
 753
 754         if (DEBUGLEVEL >= 10) {
 755                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobPause, r);
 756         }
 757
 758         result = rap_cli_do_call(tree, call);
 759
 760         if (!NT_STATUS_IS_OK(result))
 761                 goto done;
 762
 763         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 764         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 765
 766         if (DEBUGLEVEL >= 10) {
 767                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobPause, r);
 768         }
 769
 770  done:
 771         talloc_free(call);
 772         return result;
 773 }
 774
 775 NTSTATUS smbcli_rap_netprintjobcontinue(struct smbcli_tree *tree,
 776                                         TALLOC_CTX *mem_ctx,
 777                                         struct rap_NetPrintJobContinue *r)
 778 {
 779         struct rap_call *call;
 780         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 781
 782         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobContinue))) {
 783                 return NT_STATUS_NO_MEMORY;
 784         }
 785
 786         rap_cli_push_word(call, r->in.JobID);
 787
 788         rap_cli_expect_format(call, "W");
 789
 790         if (DEBUGLEVEL >= 10) {
 791                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobContinue, r);
 792         }
 793
 794         result = rap_cli_do_call(tree, call);
 795
 796         if (!NT_STATUS_IS_OK(result))
 797                 goto done;
 798
 799         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 800         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 801
 802         if (DEBUGLEVEL >= 10) {
 803                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobContinue, r);
 804         }
 805
 806  done:
 807         talloc_free(call);
 808         return result;
 809 }
 810
 811 NTSTATUS smbcli_rap_netprintjobdelete(struct smbcli_tree *tree,
 812                                       TALLOC_CTX *mem_ctx,
 813                                       struct rap_NetPrintJobDelete *r)
 814 {
 815         struct rap_call *call;
 816         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 817
 818         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobDel))) {
 819                 return NT_STATUS_NO_MEMORY;
 820         }
 821
 822         rap_cli_push_word(call, r->in.JobID);
 823
 824         rap_cli_expect_format(call, "W");
 825
 826         if (DEBUGLEVEL >= 10) {
 827                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobDelete, r);
 828         }
 829
 830         result = rap_cli_do_call(tree, call);
 831
 832         if (!NT_STATUS_IS_OK(result))
 833                 goto done;
 834
 835         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 836         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 837
 838         if (DEBUGLEVEL >= 10) {
 839                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobDelete, r);
 840         }
 841
 842  done:
 843         talloc_free(call);
 844         return result;
 845 }
 846
 847 NTSTATUS smbcli_rap_netprintqueuepause(struct smbcli_tree *tree,
 848                                        TALLOC_CTX *mem_ctx,
 849                                        struct rap_NetPrintQueuePause *r)
 850 {
 851         struct rap_call *call;
 852         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 853
 854         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPause))) {
 855                 return NT_STATUS_NO_MEMORY;
 856         }
 857
 858         rap_cli_push_string(call, r->in.PrintQueueName);
 859
 860         rap_cli_expect_format(call, "");
 861
 862         if (DEBUGLEVEL >= 10) {
 863                 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePause, r);
 864         }
 865
 866         result = rap_cli_do_call(tree, call);
 867
 868         if (!NT_STATUS_IS_OK(result))
 869                 goto done;
 870
 871         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 872         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 873
 874         if (DEBUGLEVEL >= 10) {
 875                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePause, r);
 876         }
 877
 878  done:
 879         talloc_free(call);
 880         return result;
 881 }
 882
 883 NTSTATUS smbcli_rap_netprintqueueresume(struct smbcli_tree *tree,
 884                                         TALLOC_CTX *mem_ctx,
 885                                         struct rap_NetPrintQueueResume *r)
 886 {
 887         struct rap_call *call;
 888         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 889
 890         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQContinue))) {
 891                 return NT_STATUS_NO_MEMORY;
 892         }
 893
 894         rap_cli_push_string(call, r->in.PrintQueueName);
 895
 896         rap_cli_expect_format(call, "");
 897
 898         if (DEBUGLEVEL >= 10) {
 899                 NDR_PRINT_IN_DEBUG(rap_NetPrintQueueResume, r);
 900         }
 901
 902         result = rap_cli_do_call(tree, call);
 903
 904         if (!NT_STATUS_IS_OK(result))
 905                 goto done;
 906
 907         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 908         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 909
 910         if (DEBUGLEVEL >= 10) {
 911                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueueResume, r);
 912         }
 913
 914  done:
 915         talloc_free(call);
 916         return result;
 917 }
 918
 919 NTSTATUS smbcli_rap_netprintqueuepurge(struct smbcli_tree *tree,
 920                                        TALLOC_CTX *mem_ctx,
 921                                        struct rap_NetPrintQueuePurge *r)
 922 {
 923         struct rap_call *call;
 924         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 925
 926         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPurge))) {
 927                 return NT_STATUS_NO_MEMORY;
 928         }
 929
 930         rap_cli_push_string(call, r->in.PrintQueueName);
 931
 932         rap_cli_expect_format(call, "");
 933
 934         if (DEBUGLEVEL >= 10) {
 935                 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePurge, r);
 936         }
 937
 938         result = rap_cli_do_call(tree, call);
 939
 940         if (!NT_STATUS_IS_OK(result))
 941                 goto done;
 942
 943         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
 944         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
 945
 946         if (DEBUGLEVEL >= 10) {
 947                 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePurge, r);
 948         }
 949
 950  done:
 951         talloc_free(call);
 952         return result;
 953 }
 954
 955 static enum ndr_err_code ndr_pull_rap_NetPrintJobEnum_data(struct ndr_pull *ndr, struct rap_NetPrintJobEnum *r)
 956 {
 957         uint32_t cntr_info_0;
 958         TALLOC_CTX *_mem_save_info_0;
 959
 960         NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
 961         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
 962         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
 963         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
 964                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
 965                 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
 966         }
 967         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
 968                 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
 969         }
 970         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
 971
 972         return NDR_ERR_SUCCESS;
 973 }
 974
 975 NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
 976                                     TALLOC_CTX *mem_ctx,
 977                                     struct rap_NetPrintJobEnum *r)
 978 {
 979         struct rap_call *call;
 980         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
 981
 982         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobEnum))) {
 983                 return NT_STATUS_NO_MEMORY;
 984         }
 985
 986         rap_cli_push_string(call, r->in.PrintQueueName);
 987         rap_cli_push_word(call, r->in.level);
 988         rap_cli_push_rcvbuf(call, r->in.bufsize);
 989         rap_cli_expect_multiple_entries(call);
 990
 991         switch(r->in.level) {
 992         case 0:
 993                 rap_cli_expect_format(call, "W");
 994                 break;
 995         case 1:
 996                 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
 997                 break;
 998         case 2:
 999                 rap_cli_expect_format(call, "WWzWWDDzz");
1000                 break;
1001         case 3:
1002                 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
1003                 break;
1004         case 4:
1005                 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
1006                 break;
1007         default:
1008                 result = NT_STATUS_INVALID_PARAMETER;
1009                 goto done;
1010         }
1011
1012         if (DEBUGLEVEL >= 10) {
1013                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobEnum, r);
1014         }
1015
1016         result = rap_cli_do_call(tree, call);
1017
1018         if (!NT_STATUS_IS_OK(result))
1019                 goto done;
1020
1021         result = NT_STATUS_INVALID_PARAMETER;
1022
1023         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1024         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1025         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1026         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1027
1028         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1029
1030         NDR_GOTO(ndr_pull_rap_NetPrintJobEnum_data(call->ndr_pull_data, r));
1031
1032         if (DEBUGLEVEL >= 10) {
1033                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobEnum, r);
1034         }
1035
1036         r->out.info = talloc_steal(mem_ctx, r->out.info);
1037
1038         result = NT_STATUS_OK;
1039
1040  done:
1041         talloc_free(call);
1042         return result;
1043 }
1044
1045 NTSTATUS smbcli_rap_netprintjobgetinfo(struct smbcli_tree *tree,
1046                                        TALLOC_CTX *mem_ctx,
1047                                        struct rap_NetPrintJobGetInfo *r)
1048 {
1049         struct rap_call *call;
1050         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1051
1052         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobGetInfo))) {
1053                 return NT_STATUS_NO_MEMORY;
1054         }
1055
1056         rap_cli_push_word(call, r->in.JobID);
1057         rap_cli_push_word(call, r->in.level);
1058         rap_cli_push_rcvbuf(call, r->in.bufsize);
1059         rap_cli_expect_word(call);
1060
1061         switch(r->in.level) {
1062         case 0:
1063                 rap_cli_expect_format(call, "W");
1064                 break;
1065         case 1:
1066                 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
1067                 break;
1068         case 2:
1069                 rap_cli_expect_format(call, "WWzWWDDzz");
1070                 break;
1071         case 3:
1072                 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
1073                 break;
1074         case 4:
1075                 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
1076                 break;
1077         default:
1078                 result = NT_STATUS_INVALID_PARAMETER;
1079                 goto done;
1080         }
1081
1082         if (DEBUGLEVEL >= 10) {
1083                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobGetInfo, r);
1084         }
1085
1086         result = rap_cli_do_call(tree, call);
1087
1088         if (!NT_STATUS_IS_OK(result))
1089                 goto done;
1090
1091         result = NT_STATUS_INVALID_PARAMETER;
1092
1093         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1094         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1095         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1096
1097         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1098
1099         NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1100         NDR_GOTO(ndr_pull_rap_printj_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1101
1102         if (DEBUGLEVEL >= 10) {
1103                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobGetInfo, r);
1104         }
1105
1106         result = NT_STATUS_OK;
1107
1108  done:
1109         talloc_free(call);
1110         return result;
1111 }
1112
1113 NTSTATUS smbcli_rap_netprintjobsetinfo(struct smbcli_tree *tree,
1114                                        TALLOC_CTX *mem_ctx,
1115                                        struct rap_NetPrintJobSetInfo *r)
1116 {
1117         struct rap_call *call;
1118         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1119
1120         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobSetInfo))) {
1121                 return NT_STATUS_NO_MEMORY;
1122         }
1123
1124         rap_cli_push_word(call, r->in.JobID);
1125         rap_cli_push_word(call, r->in.level);
1126         rap_cli_push_sendbuf(call, r->in.bufsize);
1127         rap_cli_push_param(call, r->in.ParamNum);
1128
1129         switch (r->in.ParamNum) {
1130         case RAP_PARAM_JOBNUM:
1131         case RAP_PARAM_JOBPOSITION:
1132         case RAP_PARAM_JOBSTATUS:
1133                 NDR_GOTO(ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, r->in.Param.value));
1134                 break;
1135         case RAP_PARAM_USERNAME:
1136         case RAP_PARAM_NOTIFYNAME:
1137         case RAP_PARAM_DATATYPE:
1138         case RAP_PARAM_PARAMETERS_STRING:
1139         case RAP_PARAM_JOBSTATUSSTR:
1140         case RAP_PARAM_JOBCOMMENT:
1141                 NDR_GOTO(ndr_push_string(call->ndr_push_param, NDR_SCALARS, r->in.Param.string));
1142                 break;
1143         case RAP_PARAM_TIMESUBMITTED:
1144         case RAP_PARAM_JOBSIZE:
1145                 NDR_GOTO(ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, r->in.Param.value4));
1146                 break;
1147         default:
1148                 result = NT_STATUS_INVALID_PARAMETER;
1149                 break;
1150         }
1151
1152         /* not really sure if this is correct */
1153         rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
1154
1155         if (DEBUGLEVEL >= 10) {
1156                 NDR_PRINT_IN_DEBUG(rap_NetPrintJobSetInfo, r);
1157         }
1158
1159         result = rap_cli_do_call(tree, call);
1160
1161         if (!NT_STATUS_IS_OK(result))
1162                 goto done;
1163
1164         result = NT_STATUS_INVALID_PARAMETER;
1165
1166         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1167         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1168
1169         result = NT_STATUS_OK;
1170
1171         if (!NT_STATUS_IS_OK(result)) {
1172                 goto done;
1173         }
1174
1175         if (DEBUGLEVEL >= 10) {
1176                 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobSetInfo, r);
1177         }
1178
1179  done:
1180         talloc_free(call);
1181         return result;
1182 }
1183
1184 static enum ndr_err_code ndr_pull_rap_NetPrintDestEnum_data(struct ndr_pull *ndr, struct rap_NetPrintDestEnum *r)
1185 {
1186         uint32_t cntr_info_0;
1187         TALLOC_CTX *_mem_save_info_0;
1188
1189         NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
1190         _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1191         NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
1192         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1193                 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
1194                 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
1195         }
1196         for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1197                 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
1198         }
1199         NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1200
1201         return NDR_ERR_SUCCESS;
1202 }
1203
1204
1205 NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
1206                                      TALLOC_CTX *mem_ctx,
1207                                      struct rap_NetPrintDestEnum *r)
1208 {
1209         struct rap_call *call;
1210         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1211
1212         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestEnum))) {
1213                 return NT_STATUS_NO_MEMORY;
1214         }
1215
1216         rap_cli_push_word(call, r->in.level);
1217         rap_cli_push_rcvbuf(call, r->in.bufsize);
1218         rap_cli_expect_multiple_entries(call);
1219
1220         switch(r->in.level) {
1221         case 0:
1222                 rap_cli_expect_format(call, "B9");
1223                 break;
1224         case 1:
1225                 rap_cli_expect_format(call, "B9B21WWzW");
1226                 break;
1227         case 2:
1228                 rap_cli_expect_format(call, "z");
1229                 break;
1230         case 3:
1231                 rap_cli_expect_format(call, "zzzWWzzzWW");
1232                 break;
1233         default:
1234                 result = NT_STATUS_INVALID_PARAMETER;
1235                 goto done;
1236         }
1237
1238         if (DEBUGLEVEL >= 10) {
1239                 NDR_PRINT_IN_DEBUG(rap_NetPrintDestEnum, r);
1240         }
1241
1242         result = rap_cli_do_call(tree, call);
1243
1244         if (!NT_STATUS_IS_OK(result))
1245                 goto done;
1246
1247         result = NT_STATUS_INVALID_PARAMETER;
1248
1249         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1250         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1251         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1252         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1253
1254         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1255
1256         NDR_GOTO(ndr_pull_rap_NetPrintDestEnum_data(call->ndr_pull_data, r));
1257
1258         r->out.info = talloc_steal(mem_ctx, r->out.info);
1259
1260         if (DEBUGLEVEL >= 10) {
1261                 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestEnum, r);
1262         }
1263
1264         result = NT_STATUS_OK;
1265
1266  done:
1267         talloc_free(call);
1268         return result;
1269 }
1270
1271 NTSTATUS smbcli_rap_netprintdestgetinfo(struct smbcli_tree *tree,
1272                                         TALLOC_CTX *mem_ctx,
1273                                         struct rap_NetPrintDestGetInfo *r)
1274 {
1275         struct rap_call *call;
1276         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1277
1278         if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestGetInfo))) {
1279                 return NT_STATUS_NO_MEMORY;
1280         }
1281
1282         rap_cli_push_string(call, r->in.PrintDestName);
1283         rap_cli_push_word(call, r->in.level);
1284         rap_cli_push_rcvbuf(call, r->in.bufsize);
1285         rap_cli_expect_word(call);
1286
1287         switch(r->in.level) {
1288         case 0:
1289                 rap_cli_expect_format(call, "B9");
1290                 break;
1291         case 1:
1292                 rap_cli_expect_format(call, "B9B21WWzW");
1293                 break;
1294         case 2:
1295                 rap_cli_expect_format(call, "z");
1296                 break;
1297         case 3:
1298                 rap_cli_expect_format(call, "zzzWWzzzWW");
1299                 break;
1300         default:
1301                 result = NT_STATUS_INVALID_PARAMETER;
1302                 goto done;
1303         }
1304
1305         if (DEBUGLEVEL >= 10) {
1306                 NDR_PRINT_IN_DEBUG(rap_NetPrintDestGetInfo, r);
1307         }
1308
1309         result = rap_cli_do_call(tree, call);
1310
1311         if (!NT_STATUS_IS_OK(result))
1312                 goto done;
1313
1314         result = NT_STATUS_INVALID_PARAMETER;
1315
1316         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1317         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1318         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1319
1320         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1321
1322         NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1323         NDR_GOTO(ndr_pull_rap_printdest_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1324
1325         if (DEBUGLEVEL >= 10) {
1326                 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestGetInfo, r);
1327         }
1328
1329         result = NT_STATUS_OK;
1330
1331  done:
1332         talloc_free(call);
1333         return result;
1334 }
1335
1336 NTSTATUS smbcli_rap_netuserpasswordset2(struct smbcli_tree *tree,
1337                                         struct smb_iconv_convenience *iconv_convenience,
1338                                         TALLOC_CTX *mem_ctx,
1339                                         struct rap_NetUserPasswordSet2 *r)
1340 {
1341         struct rap_call *call;
1342         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1343
1344         if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserPasswordSet2))) {
1345                 return NT_STATUS_NO_MEMORY;
1346         }
1347
1348         rap_cli_push_string(call, r->in.UserName);
1349         rap_cli_push_paramdesc(call, 'b');
1350         rap_cli_push_paramdesc(call, '1');
1351         rap_cli_push_paramdesc(call, '6');
1352         ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.OldPassword, 16);
1353         rap_cli_push_paramdesc(call, 'b');
1354         rap_cli_push_paramdesc(call, '1');
1355         rap_cli_push_paramdesc(call, '6');
1356         ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.NewPassword, 16);
1357         rap_cli_push_word(call, r->in.EncryptedPassword);
1358         rap_cli_push_word(call, r->in.RealPasswordLength);
1359
1360         rap_cli_expect_format(call, "");
1361
1362         if (DEBUGLEVEL >= 10) {
1363                 NDR_PRINT_IN_DEBUG(rap_NetUserPasswordSet2, r);
1364         }
1365
1366         result = rap_cli_do_call(tree, call);
1367
1368         if (!NT_STATUS_IS_OK(result))
1369                 goto done;
1370
1371         result = NT_STATUS_INVALID_PARAMETER;
1372
1373         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1374         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1375
1376         result = NT_STATUS_OK;
1377
1378         if (!NT_STATUS_IS_OK(result)) {
1379                 goto done;
1380         }
1381
1382         if (DEBUGLEVEL >= 10) {
1383                 NDR_PRINT_OUT_DEBUG(rap_NetUserPasswordSet2, r);
1384         }
1385
1386  done:
1387         talloc_free(call);
1388         return result;
1389 }
1390
1391 NTSTATUS smbcli_rap_netoemchangepassword(struct smbcli_tree *tree,
1392                                          struct smb_iconv_convenience *iconv_convenience,
1393                                          TALLOC_CTX *mem_ctx,
1394                                          struct rap_NetOEMChangePassword *r)
1395 {
1396         struct rap_call *call;
1397         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1398
1399         if (!(call = new_rap_cli_call(mem_ctx, RAP_SamOEMChgPasswordUser2_P))) {
1400                 return NT_STATUS_NO_MEMORY;
1401         }
1402
1403         rap_cli_push_string(call, r->in.UserName);
1404         rap_cli_push_sendbuf(call, 532);
1405         ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.crypt_password, 516);
1406         ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.password_hash, 16);
1407
1408         rap_cli_expect_format(call, "B516B16");
1409
1410         if (DEBUGLEVEL >= 10) {
1411                 NDR_PRINT_IN_DEBUG(rap_NetOEMChangePassword, r);
1412         }
1413
1414         result = rap_cli_do_call(tree, call);
1415
1416         if (!NT_STATUS_IS_OK(result))
1417                 goto done;
1418
1419         result = NT_STATUS_INVALID_PARAMETER;
1420
1421         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1422         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1423
1424         result = NT_STATUS_OK;
1425
1426         if (!NT_STATUS_IS_OK(result)) {
1427                 goto done;
1428         }
1429
1430         if (DEBUGLEVEL >= 10) {
1431                 NDR_PRINT_OUT_DEBUG(rap_NetOEMChangePassword, r);
1432         }
1433
1434  done:
1435         talloc_free(call);
1436         return result;
1437 }
1438
1439 NTSTATUS smbcli_rap_netusergetinfo(struct smbcli_tree *tree,
1440                                    TALLOC_CTX *mem_ctx,
1441                                    struct rap_NetUserGetInfo *r)
1442 {
1443         struct rap_call *call;
1444         NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1445
1446         if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserGetInfo))) {
1447                 return NT_STATUS_NO_MEMORY;
1448         }
1449
1450         rap_cli_push_string(call, r->in.UserName);
1451         rap_cli_push_word(call, r->in.level);
1452         rap_cli_push_rcvbuf(call, r->in.bufsize);
1453         rap_cli_expect_word(call);
1454
1455         switch(r->in.level) {
1456         case 0:
1457                 rap_cli_expect_format(call, "B21");
1458                 break;
1459         case 1:
1460                 rap_cli_expect_format(call, "B21BB16DWzzWz");
1461                 break;
1462         case 2:
1463                 rap_cli_expect_format(call, "B21BB16DWzzWzDzzzzDDDDWb21WWzWW");
1464                 break;
1465         case 10:
1466                 rap_cli_expect_format(call, "B21Bzzz");
1467                 break;
1468         case 11:
1469                 rap_cli_expect_format(call, "B21BzzzWDDzzDDWWzWzDWb21W");
1470                 break;
1471         default:
1472                 result = NT_STATUS_INVALID_PARAMETER;
1473                 goto done;
1474         }
1475
1476         if (DEBUGLEVEL >= 10) {
1477                 NDR_PRINT_IN_DEBUG(rap_NetUserGetInfo, r);
1478         }
1479
1480         result = rap_cli_do_call(tree, call);
1481
1482         if (!NT_STATUS_IS_OK(result))
1483                 goto done;
1484
1485         NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1486         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1487         NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1488
1489         call->ndr_pull_data->relative_rap_convert = r->out.convert;
1490
1491         NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1492         NDR_GOTO(ndr_pull_rap_netuser_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1493
1494         if (DEBUGLEVEL >= 10) {
1495                 NDR_PRINT_OUT_DEBUG(rap_NetUserGetInfo, r);
1496         }
1497
1498         result = NT_STATUS_OK;
1499
1500  done:
1501         talloc_free(call);
1502         return result;
1503 }
1504
1505
1506 static bool test_netservergetinfo(struct torture_context *tctx,
1507                                   struct smbcli_state *cli)
1508 {
1509         struct rap_WserverGetInfo r;
1510         bool res = true;
1511
1512         r.in.bufsize = 0xffff;
1513
1514         r.in.level = 0;
1515         torture_assert_ntstatus_ok(tctx,
1516                 smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
1517                 "rap_netservergetinfo level 0 failed");
1518         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
1519                 "rap_netservergetinfo level 0 failed");
1520
1521         r.in.level = 1;
1522         torture_assert_ntstatus_ok(tctx,
1523                 smbcli_rap_netservergetinfo(cli->tree, tctx, &r),
1524                 "rap_netservergetinfo level 1 failed");
1525         torture_assert_werr_ok(tctx, W_ERROR(r.out.status),
1526                 "rap_netservergetinfo level 1 failed");
1527
1528         return res;
1529 }
1530
1531 bool torture_rap_scan(struct torture_context *torture, struct smbcli_state *cli)
1532 {
1533         int callno;
1534
1535         for (callno = 0; callno < 0xffff; callno++) {
1536                 struct rap_call *call = new_rap_cli_call(torture, callno);
1537                 NTSTATUS result;
1538
1539                 result = rap_cli_do_call(cli->tree, call);
1540
1541                 if (!NT_STATUS_EQUAL(result, NT_STATUS_INVALID_PARAMETER))
1542                         continue;
1543
1544                 printf("callno %d is RAP call\n", callno);
1545         }
1546
1547         return true;
1548 }
1549
1550 NTSTATUS torture_rap_init(void)
1551 {
1552         struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "RAP");
1553         struct torture_suite *suite_basic = torture_suite_create(suite, "BASIC");
1554
1555         torture_suite_add_suite(suite, suite_basic);
1556         torture_suite_add_suite(suite, torture_rap_rpc(suite));
1557         torture_suite_add_suite(suite, torture_rap_printing(suite));
1558         torture_suite_add_suite(suite, torture_rap_sam(suite));
1559
1560         torture_suite_add_1smb_test(suite_basic, "netserverenum",
1561                                     test_netserverenum);
1562         torture_suite_add_1smb_test(suite_basic, "netshareenum",
1563                                     test_netshareenum);
1564         torture_suite_add_1smb_test(suite_basic, "netservergetinfo",
1565                                     test_netservergetinfo);
1566
1567         torture_suite_add_1smb_test(suite, "SCAN", torture_rap_scan);
1568
1569         suite->description = talloc_strdup(suite,
1570                                                 "Remote Administration Protocol tests");
1571
1572         torture_register_suite(suite);
1573
1574         return NT_STATUS_OK;
1575 }