2 Unix SMB/CIFS implementation.
4 Copyright (C) Volker Lendecke 2004
5 Copyright (C) Tim Potter 2005
6 Copyright (C) Jelmer Vernooij 2007
7 Copyright (C) Guenther Deschner 2010-2011
9 This program is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3 of the License, or
12 (at your option) any later version.
14 This program is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
19 You should have received a copy of the GNU General Public License
20 along with this program. If not, see <http://www.gnu.org/licenses/>.
24 #include "libcli/libcli.h"
25 #include "../librpc/gen_ndr/ndr_rap.h"
26 #include "libcli/rap/rap.h"
27 #include "librpc/ndr/libndr.h"
29 struct rap_call *new_rap_cli_call(TALLOC_CTX *mem_ctx, uint16_t callno)
31 struct rap_call *call;
33 call = talloc_zero(mem_ctx, struct rap_call);
38 call->callno = callno;
39 call->rcv_paramlen = 4;
41 call->ndr_push_param = ndr_push_init_ctx(mem_ctx);
42 call->ndr_push_param->flags = RAPNDR_FLAGS;
44 call->ndr_push_data = ndr_push_init_ctx(mem_ctx);
45 call->ndr_push_data->flags = RAPNDR_FLAGS;
50 static void rap_cli_push_paramdesc(struct rap_call *call, char desc)
54 if (call->paramdesc != NULL)
55 len = strlen(call->paramdesc);
57 call->paramdesc = talloc_realloc(call,
62 call->paramdesc[len] = desc;
63 call->paramdesc[len+1] = '\0';
66 static void rap_cli_push_word(struct rap_call *call, uint16_t val)
68 rap_cli_push_paramdesc(call, 'W');
69 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, val);
72 static void rap_cli_push_dword(struct rap_call *call, uint32_t val)
74 rap_cli_push_paramdesc(call, 'D');
75 ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, val);
78 static void rap_cli_push_rcvbuf(struct rap_call *call, int len)
80 rap_cli_push_paramdesc(call, 'r');
81 rap_cli_push_paramdesc(call, 'L');
82 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, len);
83 call->rcv_datalen = len;
86 static void rap_cli_push_sendbuf(struct rap_call *call, int len)
88 rap_cli_push_paramdesc(call, 's');
89 rap_cli_push_paramdesc(call, 'T');
90 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, len);
93 static void rap_cli_push_param(struct rap_call *call, uint16_t val)
95 rap_cli_push_paramdesc(call, 'P');
96 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, val);
99 static void rap_cli_expect_multiple_entries(struct rap_call *call)
101 rap_cli_push_paramdesc(call, 'e');
102 rap_cli_push_paramdesc(call, 'h');
103 call->rcv_paramlen += 4; /* uint16_t entry count, uint16_t total */
106 static void rap_cli_expect_word(struct rap_call *call)
108 rap_cli_push_paramdesc(call, 'h');
109 call->rcv_paramlen += 2;
112 static void rap_cli_push_string(struct rap_call *call, const char *str)
115 rap_cli_push_paramdesc(call, 'O');
118 rap_cli_push_paramdesc(call, 'z');
119 ndr_push_string(call->ndr_push_param, NDR_SCALARS, str);
122 static void rap_cli_expect_format(struct rap_call *call, const char *format)
124 call->datadesc = format;
127 static void rap_cli_expect_extra_format(struct rap_call *call, const char *format)
129 call->auxdatadesc = format;
132 static NTSTATUS rap_pull_string(TALLOC_CTX *mem_ctx, struct ndr_pull *ndr,
133 uint16_t convert, const char **dest)
135 uint16_t string_offset;
140 NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &string_offset));
141 NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &ignore));
143 string_offset -= convert;
145 if (string_offset+1 > ndr->data_size)
146 return NT_STATUS_INVALID_PARAMETER;
148 p = (const char *)(ndr->data + string_offset);
149 len = strnlen(p, ndr->data_size-string_offset);
151 if ( string_offset + len + 1 > ndr->data_size )
152 return NT_STATUS_INVALID_PARAMETER;
154 *dest = talloc_zero_array(mem_ctx, char, len+1);
155 pull_string(discard_const_p(char, *dest), p, len+1, len, STR_ASCII);
160 NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
161 struct rap_call *call)
164 DATA_BLOB param_blob;
166 struct ndr_push *params;
167 struct ndr_push *data;
168 struct smb_trans2 trans;
170 params = ndr_push_init_ctx(call);
173 return NT_STATUS_NO_MEMORY;
175 params->flags = RAPNDR_FLAGS;
177 data = ndr_push_init_ctx(call);
180 return NT_STATUS_NO_MEMORY;
182 data->flags = RAPNDR_FLAGS;
184 trans.in.max_param = call->rcv_paramlen;
185 trans.in.max_data = call->rcv_datalen;
186 trans.in.max_setup = 0;
188 trans.in.timeout = 0;
189 trans.in.setup_count = 0;
190 trans.in.setup = NULL;
191 trans.in.trans_name = "\\PIPE\\LANMAN";
193 NDR_RETURN(ndr_push_uint16(params, NDR_SCALARS, call->callno));
195 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->paramdesc));
197 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->datadesc));
199 param_blob = ndr_push_blob(call->ndr_push_param);
200 NDR_RETURN(ndr_push_bytes(params, param_blob.data,
203 data_blob = ndr_push_blob(call->ndr_push_data);
204 NDR_RETURN(ndr_push_bytes(data, data_blob.data,
207 if (call->auxdatadesc)
208 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->auxdatadesc));
210 trans.in.params = ndr_push_blob(params);
211 trans.in.data = ndr_push_blob(data);
213 result = smb_raw_trans(tree, call, &trans);
215 if (!NT_STATUS_IS_OK(result))
218 call->ndr_pull_param = ndr_pull_init_blob(&trans.out.params, call);
219 call->ndr_pull_param->flags = RAPNDR_FLAGS;
221 call->ndr_pull_data = ndr_pull_init_blob(&trans.out.data, call);
222 call->ndr_pull_data->flags = RAPNDR_FLAGS;
228 NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
230 struct rap_NetShareEnum *r)
232 struct rap_call *call;
233 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
236 call = new_rap_cli_call(tree, RAP_WshareEnum);
239 return NT_STATUS_NO_MEMORY;
241 rap_cli_push_word(call, r->in.level); /* Level */
242 rap_cli_push_rcvbuf(call, r->in.bufsize);
243 rap_cli_expect_multiple_entries(call);
245 switch(r->in.level) {
247 rap_cli_expect_format(call, "B13");
250 rap_cli_expect_format(call, "B13BWz");
254 if (DEBUGLEVEL >= 10) {
255 NDR_PRINT_IN_DEBUG(rap_NetShareEnum, r);
258 result = rap_cli_do_call(tree, call);
260 if (!NT_STATUS_IS_OK(result))
263 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
264 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
265 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
266 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
268 r->out.info = talloc_array(mem_ctx, union rap_share_info, r->out.count);
270 if (r->out.info == NULL) {
271 result = NT_STATUS_NO_MEMORY;
275 for (i=0; i<r->out.count; i++) {
276 switch(r->in.level) {
278 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
279 r->out.info[i].info0.share_name, 13));
282 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
283 r->out.info[i].info1.share_name, 13));
284 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
285 &r->out.info[i].info1.reserved1, 1));
286 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_data,
287 NDR_SCALARS, &r->out.info[i].info1.share_type));
288 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
290 &r->out.info[i].info1.comment));
295 if (DEBUGLEVEL >= 10) {
296 NDR_PRINT_OUT_DEBUG(rap_NetShareEnum, r);
298 result = NT_STATUS_OK;
305 NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
307 struct rap_NetServerEnum2 *r)
309 struct rap_call *call;
310 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
313 call = new_rap_cli_call(mem_ctx, RAP_NetServerEnum2);
316 return NT_STATUS_NO_MEMORY;
318 rap_cli_push_word(call, r->in.level);
319 rap_cli_push_rcvbuf(call, r->in.bufsize);
320 rap_cli_expect_multiple_entries(call);
321 rap_cli_push_dword(call, r->in.servertype);
322 rap_cli_push_string(call, r->in.domain);
324 switch(r->in.level) {
326 rap_cli_expect_format(call, "B16");
329 rap_cli_expect_format(call, "B16BBDz");
333 if (DEBUGLEVEL >= 10) {
334 NDR_PRINT_IN_DEBUG(rap_NetServerEnum2, r);
337 result = rap_cli_do_call(tree, call);
339 if (!NT_STATUS_IS_OK(result))
342 result = NT_STATUS_INVALID_PARAMETER;
344 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
345 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
346 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
347 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
349 r->out.info = talloc_array(mem_ctx, union rap_server_info, r->out.count);
351 if (r->out.info == NULL) {
352 result = NT_STATUS_NO_MEMORY;
356 for (i=0; i<r->out.count; i++) {
357 switch(r->in.level) {
359 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
360 r->out.info[i].info0.name, 16));
363 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
364 r->out.info[i].info1.name, 16));
365 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
366 &r->out.info[i].info1.version_major, 1));
367 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
368 &r->out.info[i].info1.version_minor, 1));
369 NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
370 NDR_SCALARS, &r->out.info[i].info1.servertype));
371 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
373 &r->out.info[i].info1.comment));
377 if (DEBUGLEVEL >= 10) {
378 NDR_PRINT_OUT_DEBUG(rap_NetServerEnum2, r);
381 result = NT_STATUS_OK;
388 NTSTATUS smbcli_rap_netservergetinfo(struct smbcli_tree *tree,
390 struct rap_WserverGetInfo *r)
392 struct rap_call *call;
393 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
395 if (!(call = new_rap_cli_call(mem_ctx, RAP_WserverGetInfo))) {
396 return NT_STATUS_NO_MEMORY;
399 rap_cli_push_word(call, r->in.level);
400 rap_cli_push_rcvbuf(call, r->in.bufsize);
401 rap_cli_expect_word(call);
403 switch(r->in.level) {
405 rap_cli_expect_format(call, "B16");
408 rap_cli_expect_format(call, "B16BBDz");
411 result = NT_STATUS_INVALID_PARAMETER;
415 if (DEBUGLEVEL >= 10) {
416 NDR_PRINT_IN_DEBUG(rap_WserverGetInfo, r);
419 result = rap_cli_do_call(tree, call);
421 if (!NT_STATUS_IS_OK(result))
424 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
425 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
426 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
428 switch(r->in.level) {
430 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
431 r->out.info.info0.name, 16));
434 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
435 r->out.info.info1.name, 16));
436 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
437 &r->out.info.info1.version_major, 1));
438 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
439 &r->out.info.info1.version_minor, 1));
440 NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
441 NDR_SCALARS, &r->out.info.info1.servertype));
442 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
444 &r->out.info.info1.comment));
447 if (DEBUGLEVEL >= 10) {
448 NDR_PRINT_OUT_DEBUG(rap_WserverGetInfo, r);
455 static enum ndr_err_code ndr_pull_rap_NetPrintQEnum_data(struct ndr_pull *ndr, struct rap_NetPrintQEnum *r)
457 uint32_t cntr_info_0;
458 TALLOC_CTX *_mem_save_info_0;
460 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
461 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
462 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
463 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
464 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
465 NDR_CHECK(ndr_pull_rap_printq_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
467 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
468 NDR_CHECK(ndr_pull_rap_printq_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
470 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
472 return NDR_ERR_SUCCESS;
475 NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
477 struct rap_NetPrintQEnum *r)
479 struct rap_call *call;
480 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
482 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQEnum))) {
483 return NT_STATUS_NO_MEMORY;
486 rap_cli_push_word(call, r->in.level);
487 rap_cli_push_rcvbuf(call, r->in.bufsize);
488 rap_cli_expect_multiple_entries(call);
490 switch(r->in.level) {
492 rap_cli_expect_format(call, "B13");
495 rap_cli_expect_format(call, "B13BWWWzzzzzWW");
498 rap_cli_expect_format(call, "B13BWWWzzzzzWN");
499 rap_cli_expect_extra_format(call, "WB21BB16B10zWWzDDz");
502 rap_cli_expect_format(call, "zWWWWzzzzWWzzl");
505 rap_cli_expect_format(call, "zWWWWzzzzWNzzl");
506 rap_cli_expect_extra_format(call, "WWzWWDDzz");
507 /* no mention of extra format in MS-RAP */
510 rap_cli_expect_format(call, "z");
513 result = NT_STATUS_INVALID_PARAMETER;
517 if (DEBUGLEVEL >= 10) {
518 NDR_PRINT_IN_DEBUG(rap_NetPrintQEnum, r);
521 result = rap_cli_do_call(tree, call);
523 if (!NT_STATUS_IS_OK(result))
526 result = NT_STATUS_INVALID_PARAMETER;
528 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
529 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
530 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
531 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
533 call->ndr_pull_data->relative_rap_convert = r->out.convert;
535 NDR_GOTO(ndr_pull_rap_NetPrintQEnum_data(call->ndr_pull_data, r));
537 r->out.info = talloc_steal(mem_ctx, r->out.info);
539 if (DEBUGLEVEL >= 10) {
540 NDR_PRINT_OUT_DEBUG(rap_NetPrintQEnum, r);
543 result = NT_STATUS_OK;
550 NTSTATUS smbcli_rap_netprintqgetinfo(struct smbcli_tree *tree,
552 struct rap_NetPrintQGetInfo *r)
554 struct rap_call *call;
555 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
557 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQGetInfo))) {
558 return NT_STATUS_NO_MEMORY;
561 rap_cli_push_string(call, r->in.PrintQueueName);
562 rap_cli_push_word(call, r->in.level);
563 rap_cli_push_rcvbuf(call, r->in.bufsize);
564 rap_cli_expect_word(call);
566 switch(r->in.level) {
568 rap_cli_expect_format(call, "B13");
571 rap_cli_expect_format(call, "B13BWWWzzzzzWW");
574 rap_cli_expect_format(call, "B13BWWWzzzzzWN");
575 rap_cli_expect_extra_format(call, "WB21BB16B10zWWzDDz");
578 rap_cli_expect_format(call, "zWWWWzzzzWWzzl");
581 rap_cli_expect_format(call, "zWWWWzzzzWNzzl");
582 rap_cli_expect_extra_format(call, "WWzWWDDzz");
583 /* no mention of extra format in MS-RAP */
586 rap_cli_expect_format(call, "z");
589 result = NT_STATUS_INVALID_PARAMETER;
593 if (DEBUGLEVEL >= 10) {
594 NDR_PRINT_IN_DEBUG(rap_NetPrintQGetInfo, r);
597 result = rap_cli_do_call(tree, call);
599 if (!NT_STATUS_IS_OK(result))
602 result = NT_STATUS_INVALID_PARAMETER;
606 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
607 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
608 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
610 if (r->out.status == 0) {
611 call->ndr_pull_data->relative_rap_convert = r->out.convert;
613 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
614 NDR_GOTO(ndr_pull_rap_printq_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
617 if (DEBUGLEVEL >= 10) {
618 NDR_PRINT_OUT_DEBUG(rap_NetPrintQGetInfo, r);
621 result = NT_STATUS_OK;
627 NTSTATUS smbcli_rap_netprintjobpause(struct smbcli_tree *tree,
629 struct rap_NetPrintJobPause *r)
631 struct rap_call *call;
632 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
634 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobPause))) {
635 return NT_STATUS_NO_MEMORY;
638 rap_cli_push_word(call, r->in.JobID);
640 rap_cli_expect_format(call, "W");
642 if (DEBUGLEVEL >= 10) {
643 NDR_PRINT_IN_DEBUG(rap_NetPrintJobPause, r);
646 result = rap_cli_do_call(tree, call);
648 if (!NT_STATUS_IS_OK(result))
651 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
652 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
654 if (DEBUGLEVEL >= 10) {
655 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobPause, r);
663 NTSTATUS smbcli_rap_netprintjobcontinue(struct smbcli_tree *tree,
665 struct rap_NetPrintJobContinue *r)
667 struct rap_call *call;
668 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
670 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobContinue))) {
671 return NT_STATUS_NO_MEMORY;
674 rap_cli_push_word(call, r->in.JobID);
676 rap_cli_expect_format(call, "W");
678 if (DEBUGLEVEL >= 10) {
679 NDR_PRINT_IN_DEBUG(rap_NetPrintJobContinue, r);
682 result = rap_cli_do_call(tree, call);
684 if (!NT_STATUS_IS_OK(result))
687 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
688 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
690 if (DEBUGLEVEL >= 10) {
691 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobContinue, r);
699 NTSTATUS smbcli_rap_netprintjobdelete(struct smbcli_tree *tree,
701 struct rap_NetPrintJobDelete *r)
703 struct rap_call *call;
704 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
706 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobDel))) {
707 return NT_STATUS_NO_MEMORY;
710 rap_cli_push_word(call, r->in.JobID);
712 rap_cli_expect_format(call, "W");
714 if (DEBUGLEVEL >= 10) {
715 NDR_PRINT_IN_DEBUG(rap_NetPrintJobDelete, r);
718 result = rap_cli_do_call(tree, call);
720 if (!NT_STATUS_IS_OK(result))
723 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
724 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
726 if (DEBUGLEVEL >= 10) {
727 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobDelete, r);
735 NTSTATUS smbcli_rap_netprintqueuepause(struct smbcli_tree *tree,
737 struct rap_NetPrintQueuePause *r)
739 struct rap_call *call;
740 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
742 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPause))) {
743 return NT_STATUS_NO_MEMORY;
746 rap_cli_push_string(call, r->in.PrintQueueName);
748 rap_cli_expect_format(call, "");
750 if (DEBUGLEVEL >= 10) {
751 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePause, r);
754 result = rap_cli_do_call(tree, call);
756 if (!NT_STATUS_IS_OK(result))
759 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
760 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
762 if (DEBUGLEVEL >= 10) {
763 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePause, r);
771 NTSTATUS smbcli_rap_netprintqueueresume(struct smbcli_tree *tree,
773 struct rap_NetPrintQueueResume *r)
775 struct rap_call *call;
776 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
778 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQContinue))) {
779 return NT_STATUS_NO_MEMORY;
782 rap_cli_push_string(call, r->in.PrintQueueName);
784 rap_cli_expect_format(call, "");
786 if (DEBUGLEVEL >= 10) {
787 NDR_PRINT_IN_DEBUG(rap_NetPrintQueueResume, r);
790 result = rap_cli_do_call(tree, call);
792 if (!NT_STATUS_IS_OK(result))
795 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
796 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
798 if (DEBUGLEVEL >= 10) {
799 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueueResume, r);
807 NTSTATUS smbcli_rap_netprintqueuepurge(struct smbcli_tree *tree,
809 struct rap_NetPrintQueuePurge *r)
811 struct rap_call *call;
812 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
814 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPurge))) {
815 return NT_STATUS_NO_MEMORY;
818 rap_cli_push_string(call, r->in.PrintQueueName);
820 rap_cli_expect_format(call, "");
822 if (DEBUGLEVEL >= 10) {
823 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePurge, r);
826 result = rap_cli_do_call(tree, call);
828 if (!NT_STATUS_IS_OK(result))
831 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
832 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
834 if (DEBUGLEVEL >= 10) {
835 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePurge, r);
843 static enum ndr_err_code ndr_pull_rap_NetPrintJobEnum_data(struct ndr_pull *ndr, struct rap_NetPrintJobEnum *r)
845 uint32_t cntr_info_0;
846 TALLOC_CTX *_mem_save_info_0;
848 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
849 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
850 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
851 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
852 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
853 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
855 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
856 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
858 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
860 return NDR_ERR_SUCCESS;
863 NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
865 struct rap_NetPrintJobEnum *r)
867 struct rap_call *call;
868 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
870 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobEnum))) {
871 return NT_STATUS_NO_MEMORY;
874 rap_cli_push_string(call, r->in.PrintQueueName);
875 rap_cli_push_word(call, r->in.level);
876 rap_cli_push_rcvbuf(call, r->in.bufsize);
877 rap_cli_expect_multiple_entries(call);
879 switch(r->in.level) {
881 rap_cli_expect_format(call, "W");
884 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
887 rap_cli_expect_format(call, "WWzWWDDzz");
890 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
893 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
896 result = NT_STATUS_INVALID_PARAMETER;
900 if (DEBUGLEVEL >= 10) {
901 NDR_PRINT_IN_DEBUG(rap_NetPrintJobEnum, r);
904 result = rap_cli_do_call(tree, call);
906 if (!NT_STATUS_IS_OK(result))
909 result = NT_STATUS_INVALID_PARAMETER;
911 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
912 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
913 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
914 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
916 call->ndr_pull_data->relative_rap_convert = r->out.convert;
918 NDR_GOTO(ndr_pull_rap_NetPrintJobEnum_data(call->ndr_pull_data, r));
920 if (DEBUGLEVEL >= 10) {
921 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobEnum, r);
924 r->out.info = talloc_steal(mem_ctx, r->out.info);
926 result = NT_STATUS_OK;
933 NTSTATUS smbcli_rap_netprintjobgetinfo(struct smbcli_tree *tree,
935 struct rap_NetPrintJobGetInfo *r)
937 struct rap_call *call;
938 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
940 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobGetInfo))) {
941 return NT_STATUS_NO_MEMORY;
944 rap_cli_push_word(call, r->in.JobID);
945 rap_cli_push_word(call, r->in.level);
946 rap_cli_push_rcvbuf(call, r->in.bufsize);
947 rap_cli_expect_word(call);
949 switch(r->in.level) {
951 rap_cli_expect_format(call, "W");
954 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
957 rap_cli_expect_format(call, "WWzWWDDzz");
960 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
963 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
966 result = NT_STATUS_INVALID_PARAMETER;
970 if (DEBUGLEVEL >= 10) {
971 NDR_PRINT_IN_DEBUG(rap_NetPrintJobGetInfo, r);
974 result = rap_cli_do_call(tree, call);
976 if (!NT_STATUS_IS_OK(result))
979 result = NT_STATUS_INVALID_PARAMETER;
981 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
982 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
983 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
985 call->ndr_pull_data->relative_rap_convert = r->out.convert;
987 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
988 NDR_GOTO(ndr_pull_rap_printj_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
990 if (DEBUGLEVEL >= 10) {
991 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobGetInfo, r);
994 result = NT_STATUS_OK;
1001 NTSTATUS smbcli_rap_netprintjobsetinfo(struct smbcli_tree *tree,
1002 TALLOC_CTX *mem_ctx,
1003 struct rap_NetPrintJobSetInfo *r)
1005 struct rap_call *call;
1006 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1008 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobSetInfo))) {
1009 return NT_STATUS_NO_MEMORY;
1012 rap_cli_push_word(call, r->in.JobID);
1013 rap_cli_push_word(call, r->in.level);
1014 rap_cli_push_sendbuf(call, r->in.bufsize);
1015 rap_cli_push_param(call, r->in.ParamNum);
1017 switch (r->in.ParamNum) {
1018 case RAP_PARAM_JOBNUM:
1019 case RAP_PARAM_JOBPOSITION:
1020 case RAP_PARAM_JOBSTATUS:
1021 NDR_GOTO(ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, r->in.Param.value));
1023 case RAP_PARAM_USERNAME:
1024 case RAP_PARAM_NOTIFYNAME:
1025 case RAP_PARAM_DATATYPE:
1026 case RAP_PARAM_PARAMETERS_STRING:
1027 case RAP_PARAM_JOBSTATUSSTR:
1028 case RAP_PARAM_JOBCOMMENT:
1029 NDR_GOTO(ndr_push_string(call->ndr_push_param, NDR_SCALARS, r->in.Param.string));
1031 case RAP_PARAM_TIMESUBMITTED:
1032 case RAP_PARAM_JOBSIZE:
1033 NDR_GOTO(ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, r->in.Param.value4));
1036 result = NT_STATUS_INVALID_PARAMETER;
1040 /* not really sure if this is correct */
1041 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
1043 if (DEBUGLEVEL >= 10) {
1044 NDR_PRINT_IN_DEBUG(rap_NetPrintJobSetInfo, r);
1047 result = rap_cli_do_call(tree, call);
1049 if (!NT_STATUS_IS_OK(result))
1052 result = NT_STATUS_INVALID_PARAMETER;
1054 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1055 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1057 result = NT_STATUS_OK;
1059 if (!NT_STATUS_IS_OK(result)) {
1063 if (DEBUGLEVEL >= 10) {
1064 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobSetInfo, r);
1072 static enum ndr_err_code ndr_pull_rap_NetPrintDestEnum_data(struct ndr_pull *ndr, struct rap_NetPrintDestEnum *r)
1074 uint32_t cntr_info_0;
1075 TALLOC_CTX *_mem_save_info_0;
1077 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
1078 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1079 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
1080 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1081 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
1082 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
1084 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1085 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
1087 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1089 return NDR_ERR_SUCCESS;
1093 NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
1094 TALLOC_CTX *mem_ctx,
1095 struct rap_NetPrintDestEnum *r)
1097 struct rap_call *call;
1098 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1100 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestEnum))) {
1101 return NT_STATUS_NO_MEMORY;
1104 rap_cli_push_word(call, r->in.level);
1105 rap_cli_push_rcvbuf(call, r->in.bufsize);
1106 rap_cli_expect_multiple_entries(call);
1108 switch(r->in.level) {
1110 rap_cli_expect_format(call, "B9");
1113 rap_cli_expect_format(call, "B9B21WWzW");
1116 rap_cli_expect_format(call, "z");
1119 rap_cli_expect_format(call, "zzzWWzzzWW");
1122 result = NT_STATUS_INVALID_PARAMETER;
1126 if (DEBUGLEVEL >= 10) {
1127 NDR_PRINT_IN_DEBUG(rap_NetPrintDestEnum, r);
1130 result = rap_cli_do_call(tree, call);
1132 if (!NT_STATUS_IS_OK(result))
1135 result = NT_STATUS_INVALID_PARAMETER;
1137 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1138 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1139 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1140 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1142 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1144 NDR_GOTO(ndr_pull_rap_NetPrintDestEnum_data(call->ndr_pull_data, r));
1146 r->out.info = talloc_steal(mem_ctx, r->out.info);
1148 if (DEBUGLEVEL >= 10) {
1149 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestEnum, r);
1152 result = NT_STATUS_OK;
1159 NTSTATUS smbcli_rap_netprintdestgetinfo(struct smbcli_tree *tree,
1160 TALLOC_CTX *mem_ctx,
1161 struct rap_NetPrintDestGetInfo *r)
1163 struct rap_call *call;
1164 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1166 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestGetInfo))) {
1167 return NT_STATUS_NO_MEMORY;
1170 rap_cli_push_string(call, r->in.PrintDestName);
1171 rap_cli_push_word(call, r->in.level);
1172 rap_cli_push_rcvbuf(call, r->in.bufsize);
1173 rap_cli_expect_word(call);
1175 switch(r->in.level) {
1177 rap_cli_expect_format(call, "B9");
1180 rap_cli_expect_format(call, "B9B21WWzW");
1183 rap_cli_expect_format(call, "z");
1186 rap_cli_expect_format(call, "zzzWWzzzWW");
1189 result = NT_STATUS_INVALID_PARAMETER;
1193 if (DEBUGLEVEL >= 10) {
1194 NDR_PRINT_IN_DEBUG(rap_NetPrintDestGetInfo, r);
1197 result = rap_cli_do_call(tree, call);
1199 if (!NT_STATUS_IS_OK(result))
1202 result = NT_STATUS_INVALID_PARAMETER;
1204 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1205 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1206 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1208 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1210 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1211 NDR_GOTO(ndr_pull_rap_printdest_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1213 if (DEBUGLEVEL >= 10) {
1214 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestGetInfo, r);
1217 result = NT_STATUS_OK;
1224 NTSTATUS smbcli_rap_netuserpasswordset2(struct smbcli_tree *tree,
1225 TALLOC_CTX *mem_ctx,
1226 struct rap_NetUserPasswordSet2 *r)
1228 struct rap_call *call;
1229 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1231 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserPasswordSet2))) {
1232 return NT_STATUS_NO_MEMORY;
1235 rap_cli_push_string(call, r->in.UserName);
1236 rap_cli_push_paramdesc(call, 'b');
1237 rap_cli_push_paramdesc(call, '1');
1238 rap_cli_push_paramdesc(call, '6');
1239 ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.OldPassword, 16);
1240 rap_cli_push_paramdesc(call, 'b');
1241 rap_cli_push_paramdesc(call, '1');
1242 rap_cli_push_paramdesc(call, '6');
1243 ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.NewPassword, 16);
1244 rap_cli_push_word(call, r->in.EncryptedPassword);
1245 rap_cli_push_word(call, r->in.RealPasswordLength);
1247 rap_cli_expect_format(call, "");
1249 if (DEBUGLEVEL >= 10) {
1250 NDR_PRINT_IN_DEBUG(rap_NetUserPasswordSet2, r);
1253 result = rap_cli_do_call(tree, call);
1255 if (!NT_STATUS_IS_OK(result))
1258 result = NT_STATUS_INVALID_PARAMETER;
1260 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1261 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1263 result = NT_STATUS_OK;
1265 if (!NT_STATUS_IS_OK(result)) {
1269 if (DEBUGLEVEL >= 10) {
1270 NDR_PRINT_OUT_DEBUG(rap_NetUserPasswordSet2, r);
1278 NTSTATUS smbcli_rap_netoemchangepassword(struct smbcli_tree *tree,
1279 TALLOC_CTX *mem_ctx,
1280 struct rap_NetOEMChangePassword *r)
1282 struct rap_call *call;
1283 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1285 if (!(call = new_rap_cli_call(mem_ctx, RAP_SamOEMChgPasswordUser2_P))) {
1286 return NT_STATUS_NO_MEMORY;
1289 rap_cli_push_string(call, r->in.UserName);
1290 rap_cli_push_sendbuf(call, 532);
1291 ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.crypt_password, 516);
1292 ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.password_hash, 16);
1294 rap_cli_expect_format(call, "B516B16");
1296 if (DEBUGLEVEL >= 10) {
1297 NDR_PRINT_IN_DEBUG(rap_NetOEMChangePassword, r);
1300 result = rap_cli_do_call(tree, call);
1302 if (!NT_STATUS_IS_OK(result))
1305 result = NT_STATUS_INVALID_PARAMETER;
1307 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1308 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1310 result = NT_STATUS_OK;
1312 if (!NT_STATUS_IS_OK(result)) {
1316 if (DEBUGLEVEL >= 10) {
1317 NDR_PRINT_OUT_DEBUG(rap_NetOEMChangePassword, r);
1325 NTSTATUS smbcli_rap_netusergetinfo(struct smbcli_tree *tree,
1326 TALLOC_CTX *mem_ctx,
1327 struct rap_NetUserGetInfo *r)
1329 struct rap_call *call;
1330 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1332 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserGetInfo))) {
1333 return NT_STATUS_NO_MEMORY;
1336 rap_cli_push_string(call, r->in.UserName);
1337 rap_cli_push_word(call, r->in.level);
1338 rap_cli_push_rcvbuf(call, r->in.bufsize);
1339 rap_cli_expect_word(call);
1341 switch(r->in.level) {
1343 rap_cli_expect_format(call, "B21");
1346 rap_cli_expect_format(call, "B21BB16DWzzWz");
1349 rap_cli_expect_format(call, "B21BB16DWzzWzDzzzzDDDDWb21WWzWW");
1352 rap_cli_expect_format(call, "B21Bzzz");
1355 rap_cli_expect_format(call, "B21BzzzWDDzzDDWWzWzDWb21W");
1358 result = NT_STATUS_INVALID_PARAMETER;
1362 if (DEBUGLEVEL >= 10) {
1363 NDR_PRINT_IN_DEBUG(rap_NetUserGetInfo, r);
1366 result = rap_cli_do_call(tree, call);
1368 if (!NT_STATUS_IS_OK(result))
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 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1375 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1377 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1378 NDR_GOTO(ndr_pull_rap_netuser_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1380 if (DEBUGLEVEL >= 10) {
1381 NDR_PRINT_OUT_DEBUG(rap_NetUserGetInfo, r);
1384 result = NT_STATUS_OK;
1392 static enum ndr_err_code ndr_pull_rap_NetSessionEnum_data(struct ndr_pull *ndr, struct rap_NetSessionEnum *r)
1394 uint32_t cntr_info_0;
1395 TALLOC_CTX *_mem_save_info_0;
1397 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
1398 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1399 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
1400 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1401 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
1402 NDR_CHECK(ndr_pull_rap_session_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
1404 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1405 NDR_CHECK(ndr_pull_rap_session_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
1407 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1409 return NDR_ERR_SUCCESS;
1413 NTSTATUS smbcli_rap_netsessionenum(struct smbcli_tree *tree,
1414 TALLOC_CTX *mem_ctx,
1415 struct rap_NetSessionEnum *r)
1417 struct rap_call *call;
1418 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1420 call = new_rap_cli_call(tree, RAP_WsessionEnum);
1423 return NT_STATUS_NO_MEMORY;
1425 rap_cli_push_word(call, r->in.level);
1426 rap_cli_push_rcvbuf(call, r->in.bufsize);
1427 rap_cli_expect_multiple_entries(call);
1429 switch(r->in.level) {
1431 rap_cli_expect_format(call, "zzWWWDDDz");
1434 result = NT_STATUS_INVALID_PARAMETER;
1438 if (DEBUGLEVEL >= 10) {
1439 NDR_PRINT_IN_DEBUG(rap_NetSessionEnum, r);
1442 result = rap_cli_do_call(tree, call);
1444 if (!NT_STATUS_IS_OK(result))
1447 result = NT_STATUS_INVALID_PARAMETER;
1449 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1450 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1451 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1452 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1454 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1456 NDR_GOTO(ndr_pull_rap_NetSessionEnum_data(call->ndr_pull_data, r));
1458 r->out.info = talloc_steal(mem_ctx, r->out.info);
1460 if (DEBUGLEVEL >= 10) {
1461 NDR_PRINT_OUT_DEBUG(rap_NetSessionEnum, r);
1464 result = NT_STATUS_OK;
1471 NTSTATUS smbcli_rap_netsessiongetinfo(struct smbcli_tree *tree,
1472 TALLOC_CTX *mem_ctx,
1473 struct rap_NetSessionGetInfo *r)
1475 struct rap_call *call;
1476 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1478 if (!(call = new_rap_cli_call(mem_ctx, RAP_WsessionGetInfo))) {
1479 return NT_STATUS_NO_MEMORY;
1482 rap_cli_push_string(call, r->in.SessionName);
1483 rap_cli_push_word(call, r->in.level);
1484 rap_cli_push_rcvbuf(call, r->in.bufsize);
1485 rap_cli_expect_word(call);
1487 switch(r->in.level) {
1489 rap_cli_expect_format(call, "zzWWWDDDz");
1492 result = NT_STATUS_INVALID_PARAMETER;
1496 if (DEBUGLEVEL >= 10) {
1497 NDR_PRINT_IN_DEBUG(rap_NetSessionGetInfo, r);
1500 result = rap_cli_do_call(tree, call);
1502 if (!NT_STATUS_IS_OK(result))
1505 result = NT_STATUS_INVALID_PARAMETER;
1507 ZERO_STRUCT(r->out);
1509 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1510 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1511 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1513 if (r->out.status == 0 && r->out.available) {
1514 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1516 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1517 NDR_GOTO(ndr_pull_rap_session_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1520 if (DEBUGLEVEL >= 10) {
1521 NDR_PRINT_OUT_DEBUG(rap_NetSessionGetInfo, r);
1524 result = NT_STATUS_OK;
1531 NTSTATUS smbcli_rap_netuseradd(struct smbcli_tree *tree,
1532 TALLOC_CTX *mem_ctx,
1533 struct rap_NetUserAdd *r)
1535 struct rap_call *call;
1536 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1538 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserAdd2))) {
1539 return NT_STATUS_NO_MEMORY;
1542 rap_cli_push_word(call, r->in.level);
1543 rap_cli_push_sendbuf(call, r->in.bufsize);
1544 rap_cli_push_word(call, r->in.pwdlength);
1545 rap_cli_push_word(call, r->in.unknown);
1547 switch (r->in.level) {
1549 rap_cli_expect_format(call, "B21BB16DWzzWz");
1552 result = NT_STATUS_INVALID_PARAMETER;
1556 if (DEBUGLEVEL >= 10) {
1557 NDR_PRINT_IN_DEBUG(rap_NetUserAdd, r);
1560 NDR_GOTO(ndr_push_set_switch_value(call->ndr_push_data, &r->in.info, r->in.level));
1561 NDR_GOTO(ndr_push_rap_netuser_info(call->ndr_push_data, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
1563 result = rap_cli_do_call(tree, call);
1565 if (!NT_STATUS_IS_OK(result))
1568 result = NT_STATUS_INVALID_PARAMETER;
1570 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1571 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1573 result = NT_STATUS_OK;
1575 if (!NT_STATUS_IS_OK(result)) {
1579 if (DEBUGLEVEL >= 10) {
1580 NDR_PRINT_OUT_DEBUG(rap_NetUserAdd, r);
1588 NTSTATUS smbcli_rap_netuserdelete(struct smbcli_tree *tree,
1589 TALLOC_CTX *mem_ctx,
1590 struct rap_NetUserDelete *r)
1592 struct rap_call *call;
1593 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1595 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserDel))) {
1596 return NT_STATUS_NO_MEMORY;
1599 rap_cli_push_string(call, r->in.UserName);
1601 rap_cli_expect_format(call, "");
1602 rap_cli_expect_extra_format(call, "");
1604 if (DEBUGLEVEL >= 10) {
1605 NDR_PRINT_IN_DEBUG(rap_NetUserDelete, r);
1608 result = rap_cli_do_call(tree, call);
1610 if (!NT_STATUS_IS_OK(result))
1613 result = NT_STATUS_INVALID_PARAMETER;
1615 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1616 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1618 result = NT_STATUS_OK;
1620 if (!NT_STATUS_IS_OK(result)) {
1624 if (DEBUGLEVEL >= 10) {
1625 NDR_PRINT_OUT_DEBUG(rap_NetUserDelete, r);
1633 NTSTATUS smbcli_rap_netremotetod(struct smbcli_tree *tree,
1634 TALLOC_CTX *mem_ctx,
1635 struct rap_NetRemoteTOD *r)
1637 struct rap_call *call;
1638 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1640 if (!(call = new_rap_cli_call(mem_ctx, RAP_NetRemoteTOD))) {
1641 return NT_STATUS_NO_MEMORY;
1644 rap_cli_push_rcvbuf(call, r->in.bufsize);
1646 rap_cli_expect_format(call, "DDBBBBWWBBWB");
1647 rap_cli_expect_extra_format(call, "");
1649 if (DEBUGLEVEL >= 10) {
1650 NDR_PRINT_IN_DEBUG(rap_NetRemoteTOD, r);
1653 result = rap_cli_do_call(tree, call);
1655 if (!NT_STATUS_IS_OK(result))
1658 result = NT_STATUS_INVALID_PARAMETER;
1660 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1661 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1663 NDR_GOTO(ndr_pull_rap_TimeOfDayInfo(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.tod));
1665 result = NT_STATUS_OK;
1667 if (!NT_STATUS_IS_OK(result)) {
1671 if (DEBUGLEVEL >= 10) {
1672 NDR_PRINT_OUT_DEBUG(rap_NetRemoteTOD, r);