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