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