source: vendor/current/source4/torture/rpc/spoolss_notify.c@ 740

Last change on this file since 740 was 740, checked in by Silvan Scherrer, 12 years ago

Samba Server: update vendor to 3.6.0
File size: 19.2 KB
Line 
1/*
2 Unix SMB/CIFS implementation.
3 test suite for spoolss rpc notify operations
4
5 Copyright (C) Jelmer Vernooij 2007
6 Copyright (C) Guenther Deschner 2010
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 3 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21*/
22
23#include "includes.h"
24#include "system/filesys.h"
25#include "librpc/gen_ndr/ndr_spoolss_c.h"
26#include "librpc/gen_ndr/ndr_spoolss.h"
27#include "torture/rpc/torture_rpc.h"
28#include "rpc_server/dcerpc_server.h"
29#include "rpc_server/service_rpc.h"
30#include "smbd/process_model.h"
31#include "smb_server/smb_server.h"
32#include "lib/socket/netif.h"
33#include "ntvfs/ntvfs.h"
34#include "param/param.h"
35
36static NTSTATUS spoolss__op_bind(struct dcesrv_call_state *dce_call,
37 const struct dcesrv_interface *iface,
38 uint32_t if_version)
39{
40 return NT_STATUS_OK;
41}
42
43static void spoolss__op_unbind(struct dcesrv_connection_context *context, const struct dcesrv_interface *iface)
44{
45}
46
47static NTSTATUS spoolss__op_ndr_pull(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_pull *pull, void **r)
48{
49 enum ndr_err_code ndr_err;
50 uint16_t opnum = dce_call->pkt.u.request.opnum;
51
52 dce_call->fault_code = 0;
53
54 if (opnum >= ndr_table_spoolss.num_calls) {
55 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
56 return NT_STATUS_NET_WRITE_FAULT;
57 }
58
59 *r = talloc_size(mem_ctx, ndr_table_spoolss.calls[opnum].struct_size);
60 NT_STATUS_HAVE_NO_MEMORY(*r);
61
62 /* unravel the NDR for the packet */
63 ndr_err = ndr_table_spoolss.calls[opnum].ndr_pull(pull, NDR_IN, *r);
64 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
65 dcerpc_log_packet(dce_call->conn->packet_log_dir,
66 &ndr_table_spoolss, opnum, NDR_IN,
67 &dce_call->pkt.u.request.stub_and_verifier);
68 dce_call->fault_code = DCERPC_FAULT_NDR;
69 return NT_STATUS_NET_WRITE_FAULT;
70 }
71
72 return NT_STATUS_OK;
73}
74
75/* Note that received_packets are allocated in talloc_autofree_context(),
76 * because no other context appears to stay around long enough. */
77static struct received_packet {
78 uint16_t opnum;
79 void *r;
80 struct received_packet *prev, *next;
81} *received_packets = NULL;
82
83static WERROR _spoolss_ReplyOpenPrinter(struct dcesrv_call_state *dce_call,
84 TALLOC_CTX *mem_ctx,
85 struct spoolss_ReplyOpenPrinter *r)
86{
87 DEBUG(1,("_spoolss_ReplyOpenPrinter\n"));
88
89 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter, r);
90
91 r->out.handle = talloc(r, struct policy_handle);
92 r->out.handle->handle_type = 42;
93 r->out.handle->uuid = GUID_random();
94 r->out.result = WERR_OK;
95
96 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter, r);
97
98 return WERR_OK;
99}
100
101static WERROR _spoolss_ReplyClosePrinter(struct dcesrv_call_state *dce_call,
102 TALLOC_CTX *mem_ctx,
103 struct spoolss_ReplyClosePrinter *r)
104{
105 DEBUG(1,("_spoolss_ReplyClosePrinter\n"));
106
107 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter, r);
108
109 ZERO_STRUCTP(r->out.handle);
110 r->out.result = WERR_OK;
111
112 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter, r);
113
114 return WERR_OK;
115}
116
117static WERROR _spoolss_RouterReplyPrinterEx(struct dcesrv_call_state *dce_call,
118 TALLOC_CTX *mem_ctx,
119 struct spoolss_RouterReplyPrinterEx *r)
120{
121 DEBUG(1,("_spoolss_RouterReplyPrinterEx\n"));
122
123 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx, r);
124
125 r->out.reply_result = talloc(r, uint32_t);
126 *r->out.reply_result = 0;
127 r->out.result = WERR_OK;
128
129 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx, r);
130
131 return WERR_OK;
132}
133
134static NTSTATUS spoolss__op_dispatch(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
135{
136 uint16_t opnum = dce_call->pkt.u.request.opnum;
137 struct received_packet *rp;
138
139 rp = talloc_zero(talloc_autofree_context(), struct received_packet);
140 rp->opnum = opnum;
141 rp->r = talloc_reference(rp, r);
142
143 DLIST_ADD_END(received_packets, rp, struct received_packet *);
144
145 switch (opnum) {
146 case 58: {
147 struct spoolss_ReplyOpenPrinter *r2 = (struct spoolss_ReplyOpenPrinter *)r;
148 r2->out.result = _spoolss_ReplyOpenPrinter(dce_call, mem_ctx, r2);
149 break;
150 }
151 case 60: {
152 struct spoolss_ReplyClosePrinter *r2 = (struct spoolss_ReplyClosePrinter *)r;
153 r2->out.result = _spoolss_ReplyClosePrinter(dce_call, mem_ctx, r2);
154 break;
155 }
156 case 66: {
157 struct spoolss_RouterReplyPrinterEx *r2 = (struct spoolss_RouterReplyPrinterEx *)r;
158 r2->out.result = _spoolss_RouterReplyPrinterEx(dce_call, mem_ctx, r2);
159 break;
160 }
161
162 default:
163 dce_call->fault_code = DCERPC_FAULT_OP_RNG_ERROR;
164 break;
165 }
166
167 if (dce_call->fault_code != 0) {
168 dcerpc_log_packet(dce_call->conn->packet_log_dir,
169 &ndr_table_spoolss, opnum, NDR_IN,
170 &dce_call->pkt.u.request.stub_and_verifier);
171 return NT_STATUS_NET_WRITE_FAULT;
172 }
173 return NT_STATUS_OK;
174}
175
176
177static NTSTATUS spoolss__op_reply(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, void *r)
178{
179 return NT_STATUS_OK;
180}
181
182
183static NTSTATUS spoolss__op_ndr_push(struct dcesrv_call_state *dce_call, TALLOC_CTX *mem_ctx, struct ndr_push *push, const void *r)
184{
185 enum ndr_err_code ndr_err;
186 uint16_t opnum = dce_call->pkt.u.request.opnum;
187
188 ndr_err = ndr_table_spoolss.calls[opnum].ndr_push(push, NDR_OUT, r);
189 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
190 dce_call->fault_code = DCERPC_FAULT_NDR;
191 return NT_STATUS_NET_WRITE_FAULT;
192 }
193
194 return NT_STATUS_OK;
195}
196
197const static struct dcesrv_interface notify_test_spoolss_interface = {
198 .name = "spoolss",
199 .syntax_id = {{0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},1.0},
200 .bind = spoolss__op_bind,
201 .unbind = spoolss__op_unbind,
202 .ndr_pull = spoolss__op_ndr_pull,
203 .dispatch = spoolss__op_dispatch,
204 .reply = spoolss__op_reply,
205 .ndr_push = spoolss__op_ndr_push
206};
207
208static bool spoolss__op_interface_by_uuid(struct dcesrv_interface *iface, const struct GUID *uuid, uint32_t if_version)
209{
210 if (notify_test_spoolss_interface.syntax_id.if_version == if_version &&
211 GUID_equal(&notify_test_spoolss_interface.syntax_id.uuid, uuid)) {
212 memcpy(iface,&notify_test_spoolss_interface, sizeof(*iface));
213 return true;
214 }
215
216 return false;
217}
218
219static bool spoolss__op_interface_by_name(struct dcesrv_interface *iface, const char *name)
220{
221 if (strcmp(notify_test_spoolss_interface.name, name)==0) {
222 memcpy(iface, &notify_test_spoolss_interface, sizeof(*iface));
223 return true;
224 }
225
226 return false;
227}
228
229static NTSTATUS spoolss__op_init_server(struct dcesrv_context *dce_ctx, const struct dcesrv_endpoint_server *ep_server)
230{
231 int i;
232
233 for (i=0;i<ndr_table_spoolss.endpoints->count;i++) {
234 NTSTATUS ret;
235 const char *name = ndr_table_spoolss.endpoints->names[i];
236
237 ret = dcesrv_interface_register(dce_ctx, name, &notify_test_spoolss_interface, NULL);
238 if (!NT_STATUS_IS_OK(ret)) {
239 DEBUG(1,("spoolss_op_init_server: failed to register endpoint '%s'\n",name));
240 return ret;
241 }
242 }
243
244 return NT_STATUS_OK;
245}
246
247static bool test_OpenPrinter(struct torture_context *tctx,
248 struct dcerpc_pipe *p,
249 struct policy_handle *handle,
250 const char *name)
251{
252 struct spoolss_OpenPrinter r;
253 const char *printername;
254 struct dcerpc_binding_handle *b = p->binding_handle;
255
256 ZERO_STRUCT(r);
257
258 if (name) {
259 printername = talloc_asprintf(tctx, "\\\\%s\\%s", dcerpc_server_name(p), name);
260 } else {
261 printername = talloc_asprintf(tctx, "\\\\%s", dcerpc_server_name(p));
262 }
263
264 r.in.printername = printername;
265 r.in.datatype = NULL;
266 r.in.devmode_ctr.devmode= NULL;
267 r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
268 r.out.handle = handle;
269
270 torture_comment(tctx, "Testing OpenPrinter(%s)\n", r.in.printername);
271
272 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_OpenPrinter_r(b, tctx, &r),
273 "OpenPrinter failed");
274 torture_assert_werr_ok(tctx, r.out.result,
275 "OpenPrinter failed");
276
277 return true;
278}
279
280static struct spoolss_NotifyOption *setup_printserver_NotifyOption(struct torture_context *tctx)
281{
282 struct spoolss_NotifyOption *o;
283
284 o = talloc_zero(tctx, struct spoolss_NotifyOption);
285
286 o->version = 2;
287 o->flags = PRINTER_NOTIFY_OPTIONS_REFRESH;
288
289 o->count = 2;
290 o->types = talloc_zero_array(o, struct spoolss_NotifyOptionType, o->count);
291
292 o->types[0].type = PRINTER_NOTIFY_TYPE;
293 o->types[0].count = 1;
294 o->types[0].fields = talloc_array(o->types, union spoolss_Field, o->types[0].count);
295 o->types[0].fields[0].field = PRINTER_NOTIFY_FIELD_SERVER_NAME;
296
297 o->types[1].type = JOB_NOTIFY_TYPE;
298 o->types[1].count = 1;
299 o->types[1].fields = talloc_array(o->types, union spoolss_Field, o->types[1].count);
300 o->types[1].fields[0].field = JOB_NOTIFY_FIELD_MACHINE_NAME;
301
302 return o;
303}
304
305static struct spoolss_NotifyOption *setup_printer_NotifyOption(struct torture_context *tctx)
306{
307 struct spoolss_NotifyOption *o;
308
309 o = talloc_zero(tctx, struct spoolss_NotifyOption);
310
311 o->version = 2;
312 o->flags = PRINTER_NOTIFY_OPTIONS_REFRESH;
313
314 o->count = 1;
315 o->types = talloc_zero_array(o, struct spoolss_NotifyOptionType, o->count);
316
317 o->types[0].type = PRINTER_NOTIFY_TYPE;
318 o->types[0].count = 1;
319 o->types[0].fields = talloc_array(o->types, union spoolss_Field, o->types[0].count);
320 o->types[0].fields[0].field = PRINTER_NOTIFY_FIELD_COMMENT;
321
322 return o;
323}
324
325
326static bool test_RemoteFindFirstPrinterChangeNotifyEx(struct torture_context *tctx,
327 struct dcerpc_binding_handle *b,
328 struct policy_handle *handle,
329 const char *address,
330 struct spoolss_NotifyOption *option)
331{
332 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r;
333 const char *local_machine = talloc_asprintf(tctx, "\\\\%s", address);
334
335 torture_comment(tctx, "Testing RemoteFindFirstPrinterChangeNotifyEx(%s)\n", local_machine);
336
337 r.in.flags = 0;
338 r.in.local_machine = local_machine;
339 r.in.options = 0;
340 r.in.printer_local = 0;
341 r.in.notify_options = option;
342 r.in.handle = handle;
343
344 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_RemoteFindFirstPrinterChangeNotifyEx_r(b, tctx, &r),
345 "RemoteFindFirstPrinterChangeNotifyEx failed");
346 torture_assert_werr_ok(tctx, r.out.result,
347 "error return code for RemoteFindFirstPrinterChangeNotifyEx");
348
349 return true;
350}
351
352static bool test_RouterRefreshPrinterChangeNotify(struct torture_context *tctx,
353 struct dcerpc_binding_handle *b,
354 struct policy_handle *handle,
355 struct spoolss_NotifyOption *options)
356{
357 struct spoolss_RouterRefreshPrinterChangeNotify r;
358 struct spoolss_NotifyInfo *info;
359
360 torture_comment(tctx, "Testing RouterRefreshPrinterChangeNotify\n");
361
362 r.in.handle = handle;
363 r.in.change_low = 0;
364 r.in.options = options;
365 r.out.info = &info;
366
367 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_RouterRefreshPrinterChangeNotify_r(b, tctx, &r),
368 "RouterRefreshPrinterChangeNotify failed");
369 torture_assert_werr_ok(tctx, r.out.result,
370 "error return code for RouterRefreshPrinterChangeNotify");
371
372 return true;
373}
374
375static bool test_SetPrinter(struct torture_context *tctx,
376 struct dcerpc_pipe *p,
377 struct policy_handle *handle)
378{
379 union spoolss_PrinterInfo info;
380 struct spoolss_SetPrinter r;
381 struct spoolss_SetPrinterInfo2 info2;
382 struct spoolss_SetPrinterInfoCtr info_ctr;
383 struct spoolss_DevmodeContainer devmode_ctr;
384 struct sec_desc_buf secdesc_ctr;
385 struct dcerpc_binding_handle *b = p->binding_handle;
386
387 torture_assert(tctx, test_GetPrinter_level(tctx, b, handle, 2, &info), "");
388
389 ZERO_STRUCT(devmode_ctr);
390 ZERO_STRUCT(secdesc_ctr);
391
392 info2.servername = info.info2.servername;
393 info2.printername = info.info2.printername;
394 info2.sharename = info.info2.sharename;
395 info2.portname = info.info2.portname;
396 info2.drivername = info.info2.drivername;
397 info2.comment = talloc_asprintf(tctx, "torture_comment %d\n", (int)time(NULL));
398 info2.location = info.info2.location;
399 info2.devmode_ptr = 0;
400 info2.sepfile = info.info2.sepfile;
401 info2.printprocessor = info.info2.printprocessor;
402 info2.datatype = info.info2.datatype;
403 info2.parameters = info.info2.parameters;
404 info2.secdesc_ptr = 0;
405 info2.attributes = info.info2.attributes;
406 info2.priority = info.info2.priority;
407 info2.defaultpriority = info.info2.defaultpriority;
408 info2.starttime = info.info2.starttime;
409 info2.untiltime = info.info2.untiltime;
410 info2.status = info.info2.status;
411 info2.cjobs = info.info2.cjobs;
412 info2.averageppm = info.info2.averageppm;
413
414 info_ctr.level = 2;
415 info_ctr.info.info2 = &info2;
416
417 r.in.handle = handle;
418 r.in.info_ctr = &info_ctr;
419 r.in.devmode_ctr = &devmode_ctr;
420 r.in.secdesc_ctr = &secdesc_ctr;
421 r.in.command = 0;
422
423 torture_assert_ntstatus_ok(tctx, dcerpc_spoolss_SetPrinter_r(b, tctx, &r), "SetPrinter failed");
424 torture_assert_werr_ok(tctx, r.out.result, "SetPrinter failed");
425
426 return true;
427}
428
429static bool test_start_dcerpc_server(struct torture_context *tctx,
430 struct tevent_context *event_ctx,
431 struct dcesrv_context **dce_ctx_p,
432 const char **address_p)
433{
434 struct dcesrv_endpoint_server ep_server;
435 NTSTATUS status;
436 struct dcesrv_context *dce_ctx;
437 const char *endpoints[] = { "spoolss", NULL };
438 struct dcesrv_endpoint *e;
439 const char *address;
440 struct interface *ifaces;
441
442 ntvfs_init(tctx->lp_ctx);
443
444 /* fill in our name */
445 ep_server.name = "spoolss";
446
447 /* fill in all the operations */
448 ep_server.init_server = spoolss__op_init_server;
449
450 ep_server.interface_by_uuid = spoolss__op_interface_by_uuid;
451 ep_server.interface_by_name = spoolss__op_interface_by_name;
452
453 torture_assert_ntstatus_ok(tctx, dcerpc_register_ep_server(&ep_server),
454 "unable to register spoolss server");
455
456 lpcfg_set_cmdline(tctx->lp_ctx, "dcerpc endpoint servers", "spoolss");
457
458 load_interfaces(tctx, lpcfg_interfaces(tctx->lp_ctx), &ifaces);
459 address = iface_n_ip(ifaces, 0);
460
461 torture_comment(tctx, "Listening for callbacks on %s\n", address);
462
463 status = process_model_init(tctx->lp_ctx);
464 torture_assert_ntstatus_ok(tctx, status,
465 "unable to initialize process models");
466
467 status = smbsrv_add_socket(tctx, event_ctx, tctx->lp_ctx, process_model_startup("single"), address);
468 torture_assert_ntstatus_ok(tctx, status, "starting smb server");
469
470 status = dcesrv_init_context(tctx, tctx->lp_ctx, endpoints, &dce_ctx);
471 torture_assert_ntstatus_ok(tctx, status,
472 "unable to initialize DCE/RPC server");
473
474 for (e=dce_ctx->endpoint_list;e;e=e->next) {
475 status = dcesrv_add_ep(dce_ctx, tctx->lp_ctx,
476 e, tctx->ev, process_model_startup("single"));
477 torture_assert_ntstatus_ok(tctx, status,
478 "unable listen on dcerpc endpoint server");
479 }
480
481 *dce_ctx_p = dce_ctx;
482 *address_p = address;
483
484 return true;
485}
486
487static struct received_packet *last_packet(struct received_packet *p)
488{
489 struct received_packet *tmp;
490 for (tmp = p; tmp->next; tmp = tmp->next) ;;
491 return tmp;
492}
493
494static bool test_RFFPCNEx(struct torture_context *tctx,
495 struct dcerpc_pipe *p)
496{
497 struct dcesrv_context *dce_ctx;
498 struct policy_handle handle;
499 const char *address;
500 struct received_packet *tmp;
501 struct spoolss_NotifyOption *server_option = setup_printserver_NotifyOption(tctx);
502#if 0
503 struct spoolss_NotifyOption *printer_option = setup_printer_NotifyOption(tctx);
504#endif
505 struct dcerpc_binding_handle *b = p->binding_handle;
506
507 received_packets = NULL;
508
509 /* Start DCE/RPC server */
510 torture_assert(tctx, test_start_dcerpc_server(tctx, p->conn->event_ctx, &dce_ctx, &address), "");
511
512 torture_assert(tctx, test_OpenPrinter(tctx, p, &handle, NULL), "");
513 torture_assert(tctx, test_RemoteFindFirstPrinterChangeNotifyEx(tctx, b, &handle, address, server_option), "");
514 torture_assert(tctx, received_packets, "no packets received");
515 torture_assert_int_equal(tctx, received_packets->opnum, NDR_SPOOLSS_REPLYOPENPRINTER,
516 "no ReplyOpenPrinter packet after RemoteFindFirstPrinterChangeNotifyEx");
517 torture_assert(tctx, test_RouterRefreshPrinterChangeNotify(tctx, b, &handle, NULL), "");
518 torture_assert(tctx, test_RouterRefreshPrinterChangeNotify(tctx, b, &handle, server_option), "");
519 torture_assert(tctx, test_ClosePrinter(tctx, b, &handle), "");
520 tmp = last_packet(received_packets);
521 torture_assert_int_equal(tctx, tmp->opnum, NDR_SPOOLSS_REPLYCLOSEPRINTER,
522 "no ReplyClosePrinter packet after ClosePrinter");
523#if 0
524 torture_assert(tctx, test_OpenPrinter(tctx, p, &handle, "Epson AL-2600"), "");
525 torture_assert(tctx, test_RemoteFindFirstPrinterChangeNotifyEx(tctx, p, &handle, address, printer_option), "");
526 tmp = last_packet(received_packets);
527 torture_assert_int_equal(tctx, tmp->opnum, NDR_SPOOLSS_REPLYOPENPRINTER,
528 "no ReplyOpenPrinter packet after RemoteFindFirstPrinterChangeNotifyEx");
529 torture_assert(tctx, test_RouterRefreshPrinterChangeNotify(tctx, p, &handle, NULL), "");
530 torture_assert(tctx, test_RouterRefreshPrinterChangeNotify(tctx, p, &handle, printer_option), "");
531 torture_assert(tctx, test_SetPrinter(tctx, p, &handle), "");
532 tmp = last_packet(received_packets);
533 torture_assert_int_equal(tctx, tmp->opnum, NDR_SPOOLSS_ROUTERREPLYPRINTEREX,
534 "no RouterReplyPrinterEx packet after ClosePrinter");
535 torture_assert(tctx, test_ClosePrinter(tctx, p, &handle), "");
536 tmp = last_packet(received_packets);
537 torture_assert_int_equal(tctx, tmp->opnum, NDR_SPOOLSS_REPLYCLOSEPRINTER,
538 "no ReplyClosePrinter packet after ClosePrinter");
539#endif
540 /* Shut down DCE/RPC server */
541 talloc_free(dce_ctx);
542
543 return true;
544}
545
546/** Test that makes sure that calling ReplyOpenPrinter()
547 * on Samba 4 will cause an irpc broadcast call.
548 */
549static bool test_ReplyOpenPrinter(struct torture_context *tctx,
550 struct dcerpc_pipe *p)
551{
552 struct spoolss_ReplyOpenPrinter r;
553 struct spoolss_ReplyClosePrinter s;
554 struct policy_handle h;
555 struct dcerpc_binding_handle *b = p->binding_handle;
556
557 if (torture_setting_bool(tctx, "samba3", false)) {
558 torture_skip(tctx, "skipping ReplyOpenPrinter server implementation test against s3\n");
559 }
560
561 r.in.server_name = "earth";
562 r.in.printer_local = 2;
563 r.in.type = REG_DWORD;
564 r.in.bufsize = 0;
565 r.in.buffer = NULL;
566 r.out.handle = &h;
567
568 torture_assert_ntstatus_ok(tctx,
569 dcerpc_spoolss_ReplyOpenPrinter_r(b, tctx, &r),
570 "spoolss_ReplyOpenPrinter call failed");
571
572 torture_assert_werr_ok(tctx, r.out.result, "error return code");
573
574 s.in.handle = &h;
575 s.out.handle = &h;
576
577 torture_assert_ntstatus_ok(tctx,
578 dcerpc_spoolss_ReplyClosePrinter_r(b, tctx, &s),
579 "spoolss_ReplyClosePrinter call failed");
580
581 torture_assert_werr_ok(tctx, r.out.result, "error return code");
582
583 return true;
584}
585
586struct torture_suite *torture_rpc_spoolss_notify(TALLOC_CTX *mem_ctx)
587{
588 struct torture_suite *suite = torture_suite_create(mem_ctx, "spoolss.notify");
589
590 struct torture_rpc_tcase *tcase = torture_suite_add_rpc_iface_tcase(suite,
591 "notify", &ndr_table_spoolss);
592
593 torture_rpc_tcase_add_test(tcase, "testRFFPCNEx", test_RFFPCNEx);
594 torture_rpc_tcase_add_test(tcase, "testReplyOpenPrinter", test_ReplyOpenPrinter);
595
596 return suite;
597}
Note: See TracBrowser for help on using the repository browser.