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(mem_ctx, struct rap_call);
38 call->callno = callno;
39 call->rcv_paramlen = 4;
40 call->rcv_datalen = 0;
42 call->paramdesc = NULL;
43 call->datadesc = NULL;
44 call->auxdatadesc = NULL;
46 call->ndr_push_param = ndr_push_init_ctx(mem_ctx);
47 call->ndr_push_param->flags = RAPNDR_FLAGS;
49 call->ndr_push_data = ndr_push_init_ctx(mem_ctx);
50 call->ndr_push_data->flags = RAPNDR_FLAGS;
55 static void rap_cli_push_paramdesc(struct rap_call *call, char desc)
59 if (call->paramdesc != NULL)
60 len = strlen(call->paramdesc);
62 call->paramdesc = talloc_realloc(call,
67 call->paramdesc[len] = desc;
68 call->paramdesc[len+1] = '\0';
71 static void rap_cli_push_word(struct rap_call *call, uint16_t val)
73 rap_cli_push_paramdesc(call, 'W');
74 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, val);
77 static void rap_cli_push_dword(struct rap_call *call, uint32_t val)
79 rap_cli_push_paramdesc(call, 'D');
80 ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, val);
83 static void rap_cli_push_rcvbuf(struct rap_call *call, int len)
85 rap_cli_push_paramdesc(call, 'r');
86 rap_cli_push_paramdesc(call, 'L');
87 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, len);
88 call->rcv_datalen = len;
91 static void rap_cli_push_sendbuf(struct rap_call *call, int len)
93 rap_cli_push_paramdesc(call, 's');
94 rap_cli_push_paramdesc(call, 'T');
95 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, len);
98 static void rap_cli_push_param(struct rap_call *call, uint16_t val)
100 rap_cli_push_paramdesc(call, 'P');
101 ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, val);
104 static void rap_cli_expect_multiple_entries(struct rap_call *call)
106 rap_cli_push_paramdesc(call, 'e');
107 rap_cli_push_paramdesc(call, 'h');
108 call->rcv_paramlen += 4; /* uint16_t entry count, uint16_t total */
111 static void rap_cli_expect_word(struct rap_call *call)
113 rap_cli_push_paramdesc(call, 'h');
114 call->rcv_paramlen += 2;
117 static void rap_cli_push_string(struct rap_call *call, const char *str)
120 rap_cli_push_paramdesc(call, 'O');
123 rap_cli_push_paramdesc(call, 'z');
124 ndr_push_string(call->ndr_push_param, NDR_SCALARS, str);
127 static void rap_cli_expect_format(struct rap_call *call, const char *format)
129 call->datadesc = format;
132 static void rap_cli_expect_extra_format(struct rap_call *call, const char *format)
134 call->auxdatadesc = format;
137 static NTSTATUS rap_pull_string(TALLOC_CTX *mem_ctx, struct ndr_pull *ndr,
138 uint16_t convert, const char **dest)
140 uint16_t string_offset;
145 NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &string_offset));
146 NDR_RETURN(ndr_pull_uint16(ndr, NDR_SCALARS, &ignore));
148 string_offset -= convert;
150 if (string_offset+1 > ndr->data_size)
151 return NT_STATUS_INVALID_PARAMETER;
153 p = (const char *)(ndr->data + string_offset);
154 len = strnlen(p, ndr->data_size-string_offset);
156 if ( string_offset + len + 1 > ndr->data_size )
157 return NT_STATUS_INVALID_PARAMETER;
159 *dest = talloc_zero_array(mem_ctx, char, len+1);
160 pull_string(discard_const_p(char, *dest), p, len+1, len, STR_ASCII);
165 NTSTATUS rap_cli_do_call(struct smbcli_tree *tree,
166 struct rap_call *call)
169 DATA_BLOB param_blob;
171 struct ndr_push *params;
172 struct ndr_push *data;
173 struct smb_trans2 trans;
175 params = ndr_push_init_ctx(call);
178 return NT_STATUS_NO_MEMORY;
180 params->flags = RAPNDR_FLAGS;
182 data = ndr_push_init_ctx(call);
185 return NT_STATUS_NO_MEMORY;
187 data->flags = RAPNDR_FLAGS;
189 trans.in.max_param = call->rcv_paramlen;
190 trans.in.max_data = call->rcv_datalen;
191 trans.in.max_setup = 0;
193 trans.in.timeout = 0;
194 trans.in.setup_count = 0;
195 trans.in.setup = NULL;
196 trans.in.trans_name = "\\PIPE\\LANMAN";
198 NDR_RETURN(ndr_push_uint16(params, NDR_SCALARS, call->callno));
200 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->paramdesc));
202 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->datadesc));
204 param_blob = ndr_push_blob(call->ndr_push_param);
205 NDR_RETURN(ndr_push_bytes(params, param_blob.data,
208 data_blob = ndr_push_blob(call->ndr_push_data);
209 NDR_RETURN(ndr_push_bytes(data, data_blob.data,
212 if (call->auxdatadesc)
213 NDR_RETURN(ndr_push_string(params, NDR_SCALARS, call->auxdatadesc));
215 trans.in.params = ndr_push_blob(params);
216 trans.in.data = ndr_push_blob(data);
218 result = smb_raw_trans(tree, call, &trans);
220 if (!NT_STATUS_IS_OK(result))
223 call->ndr_pull_param = ndr_pull_init_blob(&trans.out.params, call);
224 call->ndr_pull_param->flags = RAPNDR_FLAGS;
226 call->ndr_pull_data = ndr_pull_init_blob(&trans.out.data, call);
227 call->ndr_pull_data->flags = RAPNDR_FLAGS;
233 NTSTATUS smbcli_rap_netshareenum(struct smbcli_tree *tree,
235 struct rap_NetShareEnum *r)
237 struct rap_call *call;
238 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
241 call = new_rap_cli_call(tree, RAP_WshareEnum);
244 return NT_STATUS_NO_MEMORY;
246 rap_cli_push_word(call, r->in.level); /* Level */
247 rap_cli_push_rcvbuf(call, r->in.bufsize);
248 rap_cli_expect_multiple_entries(call);
250 switch(r->in.level) {
252 rap_cli_expect_format(call, "B13");
255 rap_cli_expect_format(call, "B13BWz");
259 if (DEBUGLEVEL >= 10) {
260 NDR_PRINT_IN_DEBUG(rap_NetShareEnum, r);
263 result = rap_cli_do_call(tree, call);
265 if (!NT_STATUS_IS_OK(result))
268 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
269 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
270 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
271 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
273 r->out.info = talloc_array(mem_ctx, union rap_share_info, r->out.count);
275 if (r->out.info == NULL) {
276 result = NT_STATUS_NO_MEMORY;
280 for (i=0; i<r->out.count; i++) {
281 switch(r->in.level) {
283 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
284 r->out.info[i].info0.share_name, 13));
287 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
288 r->out.info[i].info1.share_name, 13));
289 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
290 &r->out.info[i].info1.reserved1, 1));
291 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_data,
292 NDR_SCALARS, &r->out.info[i].info1.share_type));
293 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
295 &r->out.info[i].info1.comment));
300 if (DEBUGLEVEL >= 10) {
301 NDR_PRINT_OUT_DEBUG(rap_NetShareEnum, r);
303 result = NT_STATUS_OK;
310 NTSTATUS smbcli_rap_netserverenum2(struct smbcli_tree *tree,
312 struct rap_NetServerEnum2 *r)
314 struct rap_call *call;
315 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
318 call = new_rap_cli_call(mem_ctx, RAP_NetServerEnum2);
321 return NT_STATUS_NO_MEMORY;
323 rap_cli_push_word(call, r->in.level);
324 rap_cli_push_rcvbuf(call, r->in.bufsize);
325 rap_cli_expect_multiple_entries(call);
326 rap_cli_push_dword(call, r->in.servertype);
327 rap_cli_push_string(call, r->in.domain);
329 switch(r->in.level) {
331 rap_cli_expect_format(call, "B16");
334 rap_cli_expect_format(call, "B16BBDz");
338 if (DEBUGLEVEL >= 10) {
339 NDR_PRINT_IN_DEBUG(rap_NetServerEnum2, r);
342 result = rap_cli_do_call(tree, call);
344 if (!NT_STATUS_IS_OK(result))
347 result = NT_STATUS_INVALID_PARAMETER;
349 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
350 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
351 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
352 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
354 r->out.info = talloc_array(mem_ctx, union rap_server_info, r->out.count);
356 if (r->out.info == NULL) {
357 result = NT_STATUS_NO_MEMORY;
361 for (i=0; i<r->out.count; i++) {
362 switch(r->in.level) {
364 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
365 r->out.info[i].info0.name, 16));
368 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
369 r->out.info[i].info1.name, 16));
370 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
371 &r->out.info[i].info1.version_major, 1));
372 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
373 &r->out.info[i].info1.version_minor, 1));
374 NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
375 NDR_SCALARS, &r->out.info[i].info1.servertype));
376 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
378 &r->out.info[i].info1.comment));
382 if (DEBUGLEVEL >= 10) {
383 NDR_PRINT_OUT_DEBUG(rap_NetServerEnum2, r);
386 result = NT_STATUS_OK;
393 NTSTATUS smbcli_rap_netservergetinfo(struct smbcli_tree *tree,
395 struct rap_WserverGetInfo *r)
397 struct rap_call *call;
398 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
400 if (!(call = new_rap_cli_call(mem_ctx, RAP_WserverGetInfo))) {
401 return NT_STATUS_NO_MEMORY;
404 rap_cli_push_word(call, r->in.level);
405 rap_cli_push_rcvbuf(call, r->in.bufsize);
406 rap_cli_expect_word(call);
408 switch(r->in.level) {
410 rap_cli_expect_format(call, "B16");
413 rap_cli_expect_format(call, "B16BBDz");
416 result = NT_STATUS_INVALID_PARAMETER;
420 if (DEBUGLEVEL >= 10) {
421 NDR_PRINT_IN_DEBUG(rap_WserverGetInfo, r);
424 result = rap_cli_do_call(tree, call);
426 if (!NT_STATUS_IS_OK(result))
429 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
430 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
431 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
433 switch(r->in.level) {
435 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
436 r->out.info.info0.name, 16));
439 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
440 r->out.info.info1.name, 16));
441 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
442 &r->out.info.info1.version_major, 1));
443 NDR_GOTO(ndr_pull_bytes(call->ndr_pull_data,
444 &r->out.info.info1.version_minor, 1));
445 NDR_GOTO(ndr_pull_uint32(call->ndr_pull_data,
446 NDR_SCALARS, &r->out.info.info1.servertype));
447 RAP_GOTO(rap_pull_string(mem_ctx, call->ndr_pull_data,
449 &r->out.info.info1.comment));
452 if (DEBUGLEVEL >= 10) {
453 NDR_PRINT_OUT_DEBUG(rap_WserverGetInfo, r);
460 static enum ndr_err_code ndr_pull_rap_NetPrintQEnum_data(struct ndr_pull *ndr, struct rap_NetPrintQEnum *r)
462 uint32_t cntr_info_0;
463 TALLOC_CTX *_mem_save_info_0;
465 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
466 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
467 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
468 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
469 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
470 NDR_CHECK(ndr_pull_rap_printq_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
472 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
473 NDR_CHECK(ndr_pull_rap_printq_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
475 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
477 return NDR_ERR_SUCCESS;
480 NTSTATUS smbcli_rap_netprintqenum(struct smbcli_tree *tree,
482 struct rap_NetPrintQEnum *r)
484 struct rap_call *call;
485 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
487 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQEnum))) {
488 return NT_STATUS_NO_MEMORY;
491 rap_cli_push_word(call, r->in.level);
492 rap_cli_push_rcvbuf(call, r->in.bufsize);
493 rap_cli_expect_multiple_entries(call);
495 switch(r->in.level) {
497 rap_cli_expect_format(call, "B13");
500 rap_cli_expect_format(call, "B13BWWWzzzzzWW");
503 rap_cli_expect_format(call, "B13BWWWzzzzzWN");
504 rap_cli_expect_extra_format(call, "WB21BB16B10zWWzDDz");
507 rap_cli_expect_format(call, "zWWWWzzzzWWzzl");
510 rap_cli_expect_format(call, "zWWWWzzzzWNzzl");
511 rap_cli_expect_extra_format(call, "WWzWWDDzz");
512 /* no mention of extra format in MS-RAP */
515 rap_cli_expect_format(call, "z");
518 result = NT_STATUS_INVALID_PARAMETER;
522 if (DEBUGLEVEL >= 10) {
523 NDR_PRINT_IN_DEBUG(rap_NetPrintQEnum, r);
526 result = rap_cli_do_call(tree, call);
528 if (!NT_STATUS_IS_OK(result))
531 result = NT_STATUS_INVALID_PARAMETER;
533 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
534 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
535 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
536 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
538 call->ndr_pull_data->relative_rap_convert = r->out.convert;
540 NDR_GOTO(ndr_pull_rap_NetPrintQEnum_data(call->ndr_pull_data, r));
542 r->out.info = talloc_steal(mem_ctx, r->out.info);
544 if (DEBUGLEVEL >= 10) {
545 NDR_PRINT_OUT_DEBUG(rap_NetPrintQEnum, r);
548 result = NT_STATUS_OK;
555 NTSTATUS smbcli_rap_netprintqgetinfo(struct smbcli_tree *tree,
557 struct rap_NetPrintQGetInfo *r)
559 struct rap_call *call;
560 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
562 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQGetInfo))) {
563 return NT_STATUS_NO_MEMORY;
566 rap_cli_push_string(call, r->in.PrintQueueName);
567 rap_cli_push_word(call, r->in.level);
568 rap_cli_push_rcvbuf(call, r->in.bufsize);
569 rap_cli_expect_word(call);
571 switch(r->in.level) {
573 rap_cli_expect_format(call, "B13");
576 rap_cli_expect_format(call, "B13BWWWzzzzzWW");
579 rap_cli_expect_format(call, "B13BWWWzzzzzWN");
580 rap_cli_expect_extra_format(call, "WB21BB16B10zWWzDDz");
583 rap_cli_expect_format(call, "zWWWWzzzzWWzzl");
586 rap_cli_expect_format(call, "zWWWWzzzzWNzzl");
587 rap_cli_expect_extra_format(call, "WWzWWDDzz");
588 /* no mention of extra format in MS-RAP */
591 rap_cli_expect_format(call, "z");
594 result = NT_STATUS_INVALID_PARAMETER;
598 if (DEBUGLEVEL >= 10) {
599 NDR_PRINT_IN_DEBUG(rap_NetPrintQGetInfo, r);
602 result = rap_cli_do_call(tree, call);
604 if (!NT_STATUS_IS_OK(result))
607 result = NT_STATUS_INVALID_PARAMETER;
611 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
612 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
613 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
615 if (r->out.status == 0) {
616 call->ndr_pull_data->relative_rap_convert = r->out.convert;
618 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
619 NDR_GOTO(ndr_pull_rap_printq_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
622 if (DEBUGLEVEL >= 10) {
623 NDR_PRINT_OUT_DEBUG(rap_NetPrintQGetInfo, r);
626 result = NT_STATUS_OK;
632 NTSTATUS smbcli_rap_netprintjobpause(struct smbcli_tree *tree,
634 struct rap_NetPrintJobPause *r)
636 struct rap_call *call;
637 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
639 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobPause))) {
640 return NT_STATUS_NO_MEMORY;
643 rap_cli_push_word(call, r->in.JobID);
645 rap_cli_expect_format(call, "W");
647 if (DEBUGLEVEL >= 10) {
648 NDR_PRINT_IN_DEBUG(rap_NetPrintJobPause, r);
651 result = rap_cli_do_call(tree, call);
653 if (!NT_STATUS_IS_OK(result))
656 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
657 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
659 if (DEBUGLEVEL >= 10) {
660 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobPause, r);
668 NTSTATUS smbcli_rap_netprintjobcontinue(struct smbcli_tree *tree,
670 struct rap_NetPrintJobContinue *r)
672 struct rap_call *call;
673 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
675 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobContinue))) {
676 return NT_STATUS_NO_MEMORY;
679 rap_cli_push_word(call, r->in.JobID);
681 rap_cli_expect_format(call, "W");
683 if (DEBUGLEVEL >= 10) {
684 NDR_PRINT_IN_DEBUG(rap_NetPrintJobContinue, r);
687 result = rap_cli_do_call(tree, call);
689 if (!NT_STATUS_IS_OK(result))
692 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
693 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
695 if (DEBUGLEVEL >= 10) {
696 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobContinue, r);
704 NTSTATUS smbcli_rap_netprintjobdelete(struct smbcli_tree *tree,
706 struct rap_NetPrintJobDelete *r)
708 struct rap_call *call;
709 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
711 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobDel))) {
712 return NT_STATUS_NO_MEMORY;
715 rap_cli_push_word(call, r->in.JobID);
717 rap_cli_expect_format(call, "W");
719 if (DEBUGLEVEL >= 10) {
720 NDR_PRINT_IN_DEBUG(rap_NetPrintJobDelete, r);
723 result = rap_cli_do_call(tree, call);
725 if (!NT_STATUS_IS_OK(result))
728 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
729 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
731 if (DEBUGLEVEL >= 10) {
732 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobDelete, r);
740 NTSTATUS smbcli_rap_netprintqueuepause(struct smbcli_tree *tree,
742 struct rap_NetPrintQueuePause *r)
744 struct rap_call *call;
745 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
747 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPause))) {
748 return NT_STATUS_NO_MEMORY;
751 rap_cli_push_string(call, r->in.PrintQueueName);
753 rap_cli_expect_format(call, "");
755 if (DEBUGLEVEL >= 10) {
756 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePause, r);
759 result = rap_cli_do_call(tree, call);
761 if (!NT_STATUS_IS_OK(result))
764 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
765 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
767 if (DEBUGLEVEL >= 10) {
768 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePause, r);
776 NTSTATUS smbcli_rap_netprintqueueresume(struct smbcli_tree *tree,
778 struct rap_NetPrintQueueResume *r)
780 struct rap_call *call;
781 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
783 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQContinue))) {
784 return NT_STATUS_NO_MEMORY;
787 rap_cli_push_string(call, r->in.PrintQueueName);
789 rap_cli_expect_format(call, "");
791 if (DEBUGLEVEL >= 10) {
792 NDR_PRINT_IN_DEBUG(rap_NetPrintQueueResume, r);
795 result = rap_cli_do_call(tree, call);
797 if (!NT_STATUS_IS_OK(result))
800 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
801 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
803 if (DEBUGLEVEL >= 10) {
804 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueueResume, r);
812 NTSTATUS smbcli_rap_netprintqueuepurge(struct smbcli_tree *tree,
814 struct rap_NetPrintQueuePurge *r)
816 struct rap_call *call;
817 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
819 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintQPurge))) {
820 return NT_STATUS_NO_MEMORY;
823 rap_cli_push_string(call, r->in.PrintQueueName);
825 rap_cli_expect_format(call, "");
827 if (DEBUGLEVEL >= 10) {
828 NDR_PRINT_IN_DEBUG(rap_NetPrintQueuePurge, r);
831 result = rap_cli_do_call(tree, call);
833 if (!NT_STATUS_IS_OK(result))
836 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
837 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
839 if (DEBUGLEVEL >= 10) {
840 NDR_PRINT_OUT_DEBUG(rap_NetPrintQueuePurge, r);
848 static enum ndr_err_code ndr_pull_rap_NetPrintJobEnum_data(struct ndr_pull *ndr, struct rap_NetPrintJobEnum *r)
850 uint32_t cntr_info_0;
851 TALLOC_CTX *_mem_save_info_0;
853 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
854 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
855 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
856 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
857 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
858 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
860 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
861 NDR_CHECK(ndr_pull_rap_printj_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
863 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
865 return NDR_ERR_SUCCESS;
868 NTSTATUS smbcli_rap_netprintjobenum(struct smbcli_tree *tree,
870 struct rap_NetPrintJobEnum *r)
872 struct rap_call *call;
873 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
875 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobEnum))) {
876 return NT_STATUS_NO_MEMORY;
879 rap_cli_push_string(call, r->in.PrintQueueName);
880 rap_cli_push_word(call, r->in.level);
881 rap_cli_push_rcvbuf(call, r->in.bufsize);
882 rap_cli_expect_multiple_entries(call);
884 switch(r->in.level) {
886 rap_cli_expect_format(call, "W");
889 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
892 rap_cli_expect_format(call, "WWzWWDDzz");
895 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
898 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
901 result = NT_STATUS_INVALID_PARAMETER;
905 if (DEBUGLEVEL >= 10) {
906 NDR_PRINT_IN_DEBUG(rap_NetPrintJobEnum, r);
909 result = rap_cli_do_call(tree, call);
911 if (!NT_STATUS_IS_OK(result))
914 result = NT_STATUS_INVALID_PARAMETER;
916 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
917 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
918 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
919 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
921 call->ndr_pull_data->relative_rap_convert = r->out.convert;
923 NDR_GOTO(ndr_pull_rap_NetPrintJobEnum_data(call->ndr_pull_data, r));
925 if (DEBUGLEVEL >= 10) {
926 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobEnum, r);
929 r->out.info = talloc_steal(mem_ctx, r->out.info);
931 result = NT_STATUS_OK;
938 NTSTATUS smbcli_rap_netprintjobgetinfo(struct smbcli_tree *tree,
940 struct rap_NetPrintJobGetInfo *r)
942 struct rap_call *call;
943 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
945 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobGetInfo))) {
946 return NT_STATUS_NO_MEMORY;
949 rap_cli_push_word(call, r->in.JobID);
950 rap_cli_push_word(call, r->in.level);
951 rap_cli_push_rcvbuf(call, r->in.bufsize);
952 rap_cli_expect_word(call);
954 switch(r->in.level) {
956 rap_cli_expect_format(call, "W");
959 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
962 rap_cli_expect_format(call, "WWzWWDDzz");
965 rap_cli_expect_format(call, "WWzWWDDzzzzzzzzzzlz");
968 rap_cli_expect_format(call, "WWzWWDDzzzzzDDDDDDD");
971 result = NT_STATUS_INVALID_PARAMETER;
975 if (DEBUGLEVEL >= 10) {
976 NDR_PRINT_IN_DEBUG(rap_NetPrintJobGetInfo, r);
979 result = rap_cli_do_call(tree, call);
981 if (!NT_STATUS_IS_OK(result))
984 result = NT_STATUS_INVALID_PARAMETER;
986 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
987 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
988 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
990 call->ndr_pull_data->relative_rap_convert = r->out.convert;
992 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
993 NDR_GOTO(ndr_pull_rap_printj_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
995 if (DEBUGLEVEL >= 10) {
996 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobGetInfo, r);
999 result = NT_STATUS_OK;
1006 NTSTATUS smbcli_rap_netprintjobsetinfo(struct smbcli_tree *tree,
1007 TALLOC_CTX *mem_ctx,
1008 struct rap_NetPrintJobSetInfo *r)
1010 struct rap_call *call;
1011 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1013 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintJobSetInfo))) {
1014 return NT_STATUS_NO_MEMORY;
1017 rap_cli_push_word(call, r->in.JobID);
1018 rap_cli_push_word(call, r->in.level);
1019 rap_cli_push_sendbuf(call, r->in.bufsize);
1020 rap_cli_push_param(call, r->in.ParamNum);
1022 switch (r->in.ParamNum) {
1023 case RAP_PARAM_JOBNUM:
1024 case RAP_PARAM_JOBPOSITION:
1025 case RAP_PARAM_JOBSTATUS:
1026 NDR_GOTO(ndr_push_uint16(call->ndr_push_param, NDR_SCALARS, r->in.Param.value));
1028 case RAP_PARAM_USERNAME:
1029 case RAP_PARAM_NOTIFYNAME:
1030 case RAP_PARAM_DATATYPE:
1031 case RAP_PARAM_PARAMETERS_STRING:
1032 case RAP_PARAM_JOBSTATUSSTR:
1033 case RAP_PARAM_JOBCOMMENT:
1034 NDR_GOTO(ndr_push_string(call->ndr_push_param, NDR_SCALARS, r->in.Param.string));
1036 case RAP_PARAM_TIMESUBMITTED:
1037 case RAP_PARAM_JOBSIZE:
1038 NDR_GOTO(ndr_push_uint32(call->ndr_push_param, NDR_SCALARS, r->in.Param.value4));
1041 result = NT_STATUS_INVALID_PARAMETER;
1045 /* not really sure if this is correct */
1046 rap_cli_expect_format(call, "WB21BB16B10zWWzDDz");
1048 if (DEBUGLEVEL >= 10) {
1049 NDR_PRINT_IN_DEBUG(rap_NetPrintJobSetInfo, r);
1052 result = rap_cli_do_call(tree, call);
1054 if (!NT_STATUS_IS_OK(result))
1057 result = NT_STATUS_INVALID_PARAMETER;
1059 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1060 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1062 result = NT_STATUS_OK;
1064 if (!NT_STATUS_IS_OK(result)) {
1068 if (DEBUGLEVEL >= 10) {
1069 NDR_PRINT_OUT_DEBUG(rap_NetPrintJobSetInfo, r);
1077 static enum ndr_err_code ndr_pull_rap_NetPrintDestEnum_data(struct ndr_pull *ndr, struct rap_NetPrintDestEnum *r)
1079 uint32_t cntr_info_0;
1080 TALLOC_CTX *_mem_save_info_0;
1082 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
1083 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1084 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
1085 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1086 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
1087 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
1089 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1090 NDR_CHECK(ndr_pull_rap_printdest_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
1092 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1094 return NDR_ERR_SUCCESS;
1098 NTSTATUS smbcli_rap_netprintdestenum(struct smbcli_tree *tree,
1099 TALLOC_CTX *mem_ctx,
1100 struct rap_NetPrintDestEnum *r)
1102 struct rap_call *call;
1103 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1105 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestEnum))) {
1106 return NT_STATUS_NO_MEMORY;
1109 rap_cli_push_word(call, r->in.level);
1110 rap_cli_push_rcvbuf(call, r->in.bufsize);
1111 rap_cli_expect_multiple_entries(call);
1113 switch(r->in.level) {
1115 rap_cli_expect_format(call, "B9");
1118 rap_cli_expect_format(call, "B9B21WWzW");
1121 rap_cli_expect_format(call, "z");
1124 rap_cli_expect_format(call, "zzzWWzzzWW");
1127 result = NT_STATUS_INVALID_PARAMETER;
1131 if (DEBUGLEVEL >= 10) {
1132 NDR_PRINT_IN_DEBUG(rap_NetPrintDestEnum, r);
1135 result = rap_cli_do_call(tree, call);
1137 if (!NT_STATUS_IS_OK(result))
1140 result = NT_STATUS_INVALID_PARAMETER;
1142 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1143 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1144 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1145 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1147 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1149 NDR_GOTO(ndr_pull_rap_NetPrintDestEnum_data(call->ndr_pull_data, r));
1151 r->out.info = talloc_steal(mem_ctx, r->out.info);
1153 if (DEBUGLEVEL >= 10) {
1154 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestEnum, r);
1157 result = NT_STATUS_OK;
1164 NTSTATUS smbcli_rap_netprintdestgetinfo(struct smbcli_tree *tree,
1165 TALLOC_CTX *mem_ctx,
1166 struct rap_NetPrintDestGetInfo *r)
1168 struct rap_call *call;
1169 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1171 if (!(call = new_rap_cli_call(mem_ctx, RAP_WPrintDestGetInfo))) {
1172 return NT_STATUS_NO_MEMORY;
1175 rap_cli_push_string(call, r->in.PrintDestName);
1176 rap_cli_push_word(call, r->in.level);
1177 rap_cli_push_rcvbuf(call, r->in.bufsize);
1178 rap_cli_expect_word(call);
1180 switch(r->in.level) {
1182 rap_cli_expect_format(call, "B9");
1185 rap_cli_expect_format(call, "B9B21WWzW");
1188 rap_cli_expect_format(call, "z");
1191 rap_cli_expect_format(call, "zzzWWzzzWW");
1194 result = NT_STATUS_INVALID_PARAMETER;
1198 if (DEBUGLEVEL >= 10) {
1199 NDR_PRINT_IN_DEBUG(rap_NetPrintDestGetInfo, r);
1202 result = rap_cli_do_call(tree, call);
1204 if (!NT_STATUS_IS_OK(result))
1207 result = NT_STATUS_INVALID_PARAMETER;
1209 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1210 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1211 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1213 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1215 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1216 NDR_GOTO(ndr_pull_rap_printdest_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1218 if (DEBUGLEVEL >= 10) {
1219 NDR_PRINT_OUT_DEBUG(rap_NetPrintDestGetInfo, r);
1222 result = NT_STATUS_OK;
1229 NTSTATUS smbcli_rap_netuserpasswordset2(struct smbcli_tree *tree,
1230 TALLOC_CTX *mem_ctx,
1231 struct rap_NetUserPasswordSet2 *r)
1233 struct rap_call *call;
1234 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1236 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserPasswordSet2))) {
1237 return NT_STATUS_NO_MEMORY;
1240 rap_cli_push_string(call, r->in.UserName);
1241 rap_cli_push_paramdesc(call, 'b');
1242 rap_cli_push_paramdesc(call, '1');
1243 rap_cli_push_paramdesc(call, '6');
1244 ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.OldPassword, 16);
1245 rap_cli_push_paramdesc(call, 'b');
1246 rap_cli_push_paramdesc(call, '1');
1247 rap_cli_push_paramdesc(call, '6');
1248 ndr_push_array_uint8(call->ndr_push_param, NDR_SCALARS, r->in.NewPassword, 16);
1249 rap_cli_push_word(call, r->in.EncryptedPassword);
1250 rap_cli_push_word(call, r->in.RealPasswordLength);
1252 rap_cli_expect_format(call, "");
1254 if (DEBUGLEVEL >= 10) {
1255 NDR_PRINT_IN_DEBUG(rap_NetUserPasswordSet2, r);
1258 result = rap_cli_do_call(tree, call);
1260 if (!NT_STATUS_IS_OK(result))
1263 result = NT_STATUS_INVALID_PARAMETER;
1265 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1266 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1268 result = NT_STATUS_OK;
1270 if (!NT_STATUS_IS_OK(result)) {
1274 if (DEBUGLEVEL >= 10) {
1275 NDR_PRINT_OUT_DEBUG(rap_NetUserPasswordSet2, r);
1283 NTSTATUS smbcli_rap_netoemchangepassword(struct smbcli_tree *tree,
1284 TALLOC_CTX *mem_ctx,
1285 struct rap_NetOEMChangePassword *r)
1287 struct rap_call *call;
1288 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1290 if (!(call = new_rap_cli_call(mem_ctx, RAP_SamOEMChgPasswordUser2_P))) {
1291 return NT_STATUS_NO_MEMORY;
1294 rap_cli_push_string(call, r->in.UserName);
1295 rap_cli_push_sendbuf(call, 532);
1296 ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.crypt_password, 516);
1297 ndr_push_array_uint8(call->ndr_push_data, NDR_SCALARS, r->in.password_hash, 16);
1299 rap_cli_expect_format(call, "B516B16");
1301 if (DEBUGLEVEL >= 10) {
1302 NDR_PRINT_IN_DEBUG(rap_NetOEMChangePassword, r);
1305 result = rap_cli_do_call(tree, call);
1307 if (!NT_STATUS_IS_OK(result))
1310 result = NT_STATUS_INVALID_PARAMETER;
1312 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1313 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1315 result = NT_STATUS_OK;
1317 if (!NT_STATUS_IS_OK(result)) {
1321 if (DEBUGLEVEL >= 10) {
1322 NDR_PRINT_OUT_DEBUG(rap_NetOEMChangePassword, r);
1330 NTSTATUS smbcli_rap_netusergetinfo(struct smbcli_tree *tree,
1331 TALLOC_CTX *mem_ctx,
1332 struct rap_NetUserGetInfo *r)
1334 struct rap_call *call;
1335 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1337 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserGetInfo))) {
1338 return NT_STATUS_NO_MEMORY;
1341 rap_cli_push_string(call, r->in.UserName);
1342 rap_cli_push_word(call, r->in.level);
1343 rap_cli_push_rcvbuf(call, r->in.bufsize);
1344 rap_cli_expect_word(call);
1346 switch(r->in.level) {
1348 rap_cli_expect_format(call, "B21");
1351 rap_cli_expect_format(call, "B21BB16DWzzWz");
1354 rap_cli_expect_format(call, "B21BB16DWzzWzDzzzzDDDDWb21WWzWW");
1357 rap_cli_expect_format(call, "B21Bzzz");
1360 rap_cli_expect_format(call, "B21BzzzWDDzzDDWWzWzDWb21W");
1363 result = NT_STATUS_INVALID_PARAMETER;
1367 if (DEBUGLEVEL >= 10) {
1368 NDR_PRINT_IN_DEBUG(rap_NetUserGetInfo, r);
1371 result = rap_cli_do_call(tree, call);
1373 if (!NT_STATUS_IS_OK(result))
1376 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1377 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1378 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1380 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1382 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1383 NDR_GOTO(ndr_pull_rap_netuser_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1385 if (DEBUGLEVEL >= 10) {
1386 NDR_PRINT_OUT_DEBUG(rap_NetUserGetInfo, r);
1389 result = NT_STATUS_OK;
1397 static enum ndr_err_code ndr_pull_rap_NetSessionEnum_data(struct ndr_pull *ndr, struct rap_NetSessionEnum *r)
1399 uint32_t cntr_info_0;
1400 TALLOC_CTX *_mem_save_info_0;
1402 NDR_PULL_ALLOC_N(ndr, r->out.info, r->out.count);
1403 _mem_save_info_0 = NDR_PULL_GET_MEM_CTX(ndr);
1404 NDR_PULL_SET_MEM_CTX(ndr, r->out.info, 0);
1405 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1406 NDR_CHECK(ndr_pull_set_switch_value(ndr, &r->out.info[cntr_info_0], r->in.level));
1407 NDR_CHECK(ndr_pull_rap_session_info(ndr, NDR_SCALARS, &r->out.info[cntr_info_0]));
1409 for (cntr_info_0 = 0; cntr_info_0 < r->out.count; cntr_info_0++) {
1410 NDR_CHECK(ndr_pull_rap_session_info(ndr, NDR_BUFFERS, &r->out.info[cntr_info_0]));
1412 NDR_PULL_SET_MEM_CTX(ndr, _mem_save_info_0, 0);
1414 return NDR_ERR_SUCCESS;
1418 NTSTATUS smbcli_rap_netsessionenum(struct smbcli_tree *tree,
1419 TALLOC_CTX *mem_ctx,
1420 struct rap_NetSessionEnum *r)
1422 struct rap_call *call;
1423 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1425 call = new_rap_cli_call(tree, RAP_WsessionEnum);
1428 return NT_STATUS_NO_MEMORY;
1430 rap_cli_push_word(call, r->in.level);
1431 rap_cli_push_rcvbuf(call, r->in.bufsize);
1432 rap_cli_expect_multiple_entries(call);
1434 switch(r->in.level) {
1436 rap_cli_expect_format(call, "zzWWWDDDz");
1439 result = NT_STATUS_INVALID_PARAMETER;
1443 if (DEBUGLEVEL >= 10) {
1444 NDR_PRINT_IN_DEBUG(rap_NetSessionEnum, r);
1447 result = rap_cli_do_call(tree, call);
1449 if (!NT_STATUS_IS_OK(result))
1452 result = NT_STATUS_INVALID_PARAMETER;
1454 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1455 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1456 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.count));
1457 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1459 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1461 NDR_GOTO(ndr_pull_rap_NetSessionEnum_data(call->ndr_pull_data, r));
1463 r->out.info = talloc_steal(mem_ctx, r->out.info);
1465 if (DEBUGLEVEL >= 10) {
1466 NDR_PRINT_OUT_DEBUG(rap_NetSessionEnum, r);
1469 result = NT_STATUS_OK;
1476 NTSTATUS smbcli_rap_netsessiongetinfo(struct smbcli_tree *tree,
1477 TALLOC_CTX *mem_ctx,
1478 struct rap_NetSessionGetInfo *r)
1480 struct rap_call *call;
1481 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1483 if (!(call = new_rap_cli_call(mem_ctx, RAP_WsessionGetInfo))) {
1484 return NT_STATUS_NO_MEMORY;
1487 rap_cli_push_string(call, r->in.SessionName);
1488 rap_cli_push_word(call, r->in.level);
1489 rap_cli_push_rcvbuf(call, r->in.bufsize);
1490 rap_cli_expect_word(call);
1492 switch(r->in.level) {
1494 rap_cli_expect_format(call, "zzWWWDDDz");
1497 result = NT_STATUS_INVALID_PARAMETER;
1501 if (DEBUGLEVEL >= 10) {
1502 NDR_PRINT_IN_DEBUG(rap_NetSessionGetInfo, r);
1505 result = rap_cli_do_call(tree, call);
1507 if (!NT_STATUS_IS_OK(result))
1510 result = NT_STATUS_INVALID_PARAMETER;
1512 ZERO_STRUCT(r->out);
1514 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1515 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1516 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.available));
1518 if (r->out.status == 0 && r->out.available) {
1519 call->ndr_pull_data->relative_rap_convert = r->out.convert;
1521 NDR_GOTO(ndr_pull_set_switch_value(call->ndr_pull_data, &r->out.info, r->in.level));
1522 NDR_GOTO(ndr_pull_rap_session_info(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.info));
1525 if (DEBUGLEVEL >= 10) {
1526 NDR_PRINT_OUT_DEBUG(rap_NetSessionGetInfo, r);
1529 result = NT_STATUS_OK;
1536 NTSTATUS smbcli_rap_netuseradd(struct smbcli_tree *tree,
1537 TALLOC_CTX *mem_ctx,
1538 struct rap_NetUserAdd *r)
1540 struct rap_call *call;
1541 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1543 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserAdd2))) {
1544 return NT_STATUS_NO_MEMORY;
1547 rap_cli_push_word(call, r->in.level);
1548 rap_cli_push_sendbuf(call, r->in.bufsize);
1549 rap_cli_push_word(call, r->in.pwdlength);
1550 rap_cli_push_word(call, r->in.unknown);
1552 switch (r->in.level) {
1554 rap_cli_expect_format(call, "B21BB16DWzzWz");
1557 result = NT_STATUS_INVALID_PARAMETER;
1561 if (DEBUGLEVEL >= 10) {
1562 NDR_PRINT_IN_DEBUG(rap_NetUserAdd, r);
1565 NDR_GOTO(ndr_push_set_switch_value(call->ndr_push_data, &r->in.info, r->in.level));
1566 NDR_GOTO(ndr_push_rap_netuser_info(call->ndr_push_data, NDR_SCALARS|NDR_BUFFERS, &r->in.info));
1568 result = rap_cli_do_call(tree, call);
1570 if (!NT_STATUS_IS_OK(result))
1573 result = NT_STATUS_INVALID_PARAMETER;
1575 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1576 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1578 result = NT_STATUS_OK;
1580 if (!NT_STATUS_IS_OK(result)) {
1584 if (DEBUGLEVEL >= 10) {
1585 NDR_PRINT_OUT_DEBUG(rap_NetUserAdd, r);
1593 NTSTATUS smbcli_rap_netuserdelete(struct smbcli_tree *tree,
1594 TALLOC_CTX *mem_ctx,
1595 struct rap_NetUserDelete *r)
1597 struct rap_call *call;
1598 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1600 if (!(call = new_rap_cli_call(mem_ctx, RAP_WUserDel))) {
1601 return NT_STATUS_NO_MEMORY;
1604 rap_cli_push_string(call, r->in.UserName);
1606 rap_cli_expect_format(call, "");
1607 rap_cli_expect_extra_format(call, "");
1609 if (DEBUGLEVEL >= 10) {
1610 NDR_PRINT_IN_DEBUG(rap_NetUserDelete, r);
1613 result = rap_cli_do_call(tree, call);
1615 if (!NT_STATUS_IS_OK(result))
1618 result = NT_STATUS_INVALID_PARAMETER;
1620 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1621 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1623 result = NT_STATUS_OK;
1625 if (!NT_STATUS_IS_OK(result)) {
1629 if (DEBUGLEVEL >= 10) {
1630 NDR_PRINT_OUT_DEBUG(rap_NetUserDelete, r);
1638 NTSTATUS smbcli_rap_netremotetod(struct smbcli_tree *tree,
1639 TALLOC_CTX *mem_ctx,
1640 struct rap_NetRemoteTOD *r)
1642 struct rap_call *call;
1643 NTSTATUS result = NT_STATUS_UNSUCCESSFUL;
1645 if (!(call = new_rap_cli_call(mem_ctx, RAP_NetRemoteTOD))) {
1646 return NT_STATUS_NO_MEMORY;
1649 rap_cli_push_rcvbuf(call, r->in.bufsize);
1651 rap_cli_expect_format(call, "DDBBBBWWBBWB");
1652 rap_cli_expect_extra_format(call, "");
1654 if (DEBUGLEVEL >= 10) {
1655 NDR_PRINT_IN_DEBUG(rap_NetRemoteTOD, r);
1658 result = rap_cli_do_call(tree, call);
1660 if (!NT_STATUS_IS_OK(result))
1663 result = NT_STATUS_INVALID_PARAMETER;
1665 NDR_GOTO(ndr_pull_rap_status(call->ndr_pull_param, NDR_SCALARS, &r->out.status));
1666 NDR_GOTO(ndr_pull_uint16(call->ndr_pull_param, NDR_SCALARS, &r->out.convert));
1668 NDR_GOTO(ndr_pull_rap_TimeOfDayInfo(call->ndr_pull_data, NDR_SCALARS|NDR_BUFFERS, &r->out.tod));
1670 result = NT_STATUS_OK;
1672 if (!NT_STATUS_IS_OK(result)) {
1676 if (DEBUGLEVEL >= 10) {
1677 NDR_PRINT_OUT_DEBUG(rap_NetRemoteTOD, r);