2 Unix SMB/CIFS implementation.
3 test suite for spoolss rpc notify operations
5 Copyright (C) Jelmer Vernooij 2007
6 Copyright (C) Guenther Deschner 2010
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.
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.
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.
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"
36 static NTSTATUS
spoolss__op_bind(struct dcesrv_call_state
*dce_call
,
37 const struct dcesrv_interface
*iface
,
43 static void spoolss__op_unbind(struct dcesrv_connection_context
*context
, const struct dcesrv_interface
*iface
)
47 static NTSTATUS
spoolss__op_ndr_pull(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, struct ndr_pull
*pull
, void **r
)
49 enum ndr_err_code ndr_err
;
50 uint16_t opnum
= dce_call
->pkt
.u
.request
.opnum
;
52 dce_call
->fault_code
= 0;
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
;
59 *r
= talloc_size(mem_ctx
, ndr_table_spoolss
.calls
[opnum
].struct_size
);
60 NT_STATUS_HAVE_NO_MEMORY(*r
);
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
;
75 /* Note that received_packets are allocated in talloc_autofree_context(),
76 * because no other context appears to stay around long enough. */
77 static struct received_packet
{
80 struct received_packet
*prev
, *next
;
81 } *received_packets
= NULL
;
83 static WERROR
_spoolss_ReplyOpenPrinter(struct dcesrv_call_state
*dce_call
,
85 struct spoolss_ReplyOpenPrinter
*r
)
87 DEBUG(1,("_spoolss_ReplyOpenPrinter\n"));
89 NDR_PRINT_IN_DEBUG(spoolss_ReplyOpenPrinter
, r
);
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
;
96 NDR_PRINT_OUT_DEBUG(spoolss_ReplyOpenPrinter
, r
);
101 static WERROR
_spoolss_ReplyClosePrinter(struct dcesrv_call_state
*dce_call
,
103 struct spoolss_ReplyClosePrinter
*r
)
105 DEBUG(1,("_spoolss_ReplyClosePrinter\n"));
107 NDR_PRINT_IN_DEBUG(spoolss_ReplyClosePrinter
, r
);
109 ZERO_STRUCTP(r
->out
.handle
);
110 r
->out
.result
= WERR_OK
;
112 NDR_PRINT_OUT_DEBUG(spoolss_ReplyClosePrinter
, r
);
117 static WERROR
_spoolss_RouterReplyPrinterEx(struct dcesrv_call_state
*dce_call
,
119 struct spoolss_RouterReplyPrinterEx
*r
)
121 DEBUG(1,("_spoolss_RouterReplyPrinterEx\n"));
123 NDR_PRINT_IN_DEBUG(spoolss_RouterReplyPrinterEx
, r
);
125 r
->out
.reply_result
= talloc(r
, uint32_t);
126 *r
->out
.reply_result
= 0;
127 r
->out
.result
= WERR_OK
;
129 NDR_PRINT_OUT_DEBUG(spoolss_RouterReplyPrinterEx
, r
);
134 static NTSTATUS
spoolss__op_dispatch(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, void *r
)
136 uint16_t opnum
= dce_call
->pkt
.u
.request
.opnum
;
137 struct received_packet
*rp
;
139 rp
= talloc_zero(talloc_autofree_context(), struct received_packet
);
141 rp
->r
= talloc_reference(rp
, r
);
143 DLIST_ADD_END(received_packets
, rp
, struct received_packet
*);
147 struct spoolss_ReplyOpenPrinter
*r2
= (struct spoolss_ReplyOpenPrinter
*)r
;
148 r2
->out
.result
= _spoolss_ReplyOpenPrinter(dce_call
, mem_ctx
, r2
);
152 struct spoolss_ReplyClosePrinter
*r2
= (struct spoolss_ReplyClosePrinter
*)r
;
153 r2
->out
.result
= _spoolss_ReplyClosePrinter(dce_call
, mem_ctx
, r2
);
157 struct spoolss_RouterReplyPrinterEx
*r2
= (struct spoolss_RouterReplyPrinterEx
*)r
;
158 r2
->out
.result
= _spoolss_RouterReplyPrinterEx(dce_call
, mem_ctx
, r2
);
163 dce_call
->fault_code
= DCERPC_FAULT_OP_RNG_ERROR
;
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
;
177 static NTSTATUS
spoolss__op_reply(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, void *r
)
183 static NTSTATUS
spoolss__op_ndr_push(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, struct ndr_push
*push
, const void *r
)
185 enum ndr_err_code ndr_err
;
186 uint16_t opnum
= dce_call
->pkt
.u
.request
.opnum
;
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
;
197 const static struct dcesrv_interface notify_test_spoolss_interface
= {
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
208 static bool spoolss__op_interface_by_uuid(struct dcesrv_interface
*iface
, const struct GUID
*uuid
, uint32_t if_version
)
210 if (notify_test_spoolss_interface
.syntax_id
.if_version
== if_version
&&
211 GUID_equal(¬ify_test_spoolss_interface
.syntax_id
.uuid
, uuid
)) {
212 memcpy(iface
,¬ify_test_spoolss_interface
, sizeof(*iface
));
219 static bool spoolss__op_interface_by_name(struct dcesrv_interface
*iface
, const char *name
)
221 if (strcmp(notify_test_spoolss_interface
.name
, name
)==0) {
222 memcpy(iface
, ¬ify_test_spoolss_interface
, sizeof(*iface
));
229 static NTSTATUS
spoolss__op_init_server(struct dcesrv_context
*dce_ctx
, const struct dcesrv_endpoint_server
*ep_server
)
233 for (i
=0;i
<ndr_table_spoolss
.endpoints
->count
;i
++) {
235 const char *name
= ndr_table_spoolss
.endpoints
->names
[i
];
237 ret
= dcesrv_interface_register(dce_ctx
, name
, ¬ify_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
));
247 static bool test_OpenPrinter(struct torture_context
*tctx
,
248 struct dcerpc_pipe
*p
,
249 struct policy_handle
*handle
,
252 struct spoolss_OpenPrinter r
;
253 const char *printername
;
254 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
259 printername
= talloc_asprintf(tctx
, "\\\\%s\\%s", dcerpc_server_name(p
), name
);
261 printername
= talloc_asprintf(tctx
, "\\\\%s", dcerpc_server_name(p
));
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
;
270 torture_comment(tctx
, "Testing OpenPrinter(%s)\n", r
.in
.printername
);
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");
280 static struct spoolss_NotifyOption
*setup_printserver_NotifyOption(struct torture_context
*tctx
)
282 struct spoolss_NotifyOption
*o
;
284 o
= talloc_zero(tctx
, struct spoolss_NotifyOption
);
287 o
->flags
= PRINTER_NOTIFY_OPTIONS_REFRESH
;
290 o
->types
= talloc_zero_array(o
, struct spoolss_NotifyOptionType
, o
->count
);
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
;
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
;
305 static struct spoolss_NotifyOption
*setup_printer_NotifyOption(struct torture_context
*tctx
)
307 struct spoolss_NotifyOption
*o
;
309 o
= talloc_zero(tctx
, struct spoolss_NotifyOption
);
312 o
->flags
= PRINTER_NOTIFY_OPTIONS_REFRESH
;
315 o
->types
= talloc_zero_array(o
, struct spoolss_NotifyOptionType
, o
->count
);
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
;
326 static bool test_RemoteFindFirstPrinterChangeNotifyEx(struct torture_context
*tctx
,
327 struct dcerpc_binding_handle
*b
,
328 struct policy_handle
*handle
,
330 struct spoolss_NotifyOption
*option
)
332 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r
;
333 const char *local_machine
= talloc_asprintf(tctx
, "\\\\%s", address
);
335 torture_comment(tctx
, "Testing RemoteFindFirstPrinterChangeNotifyEx(%s)\n", local_machine
);
338 r
.in
.local_machine
= local_machine
;
340 r
.in
.printer_local
= 0;
341 r
.in
.notify_options
= option
;
342 r
.in
.handle
= handle
;
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");
352 static bool test_RouterRefreshPrinterChangeNotify(struct torture_context
*tctx
,
353 struct dcerpc_binding_handle
*b
,
354 struct policy_handle
*handle
,
355 struct spoolss_NotifyOption
*options
)
357 struct spoolss_RouterRefreshPrinterChangeNotify r
;
358 struct spoolss_NotifyInfo
*info
;
360 torture_comment(tctx
, "Testing RouterRefreshPrinterChangeNotify\n");
362 r
.in
.handle
= handle
;
364 r
.in
.options
= options
;
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");
375 static bool test_SetPrinter(struct torture_context
*tctx
,
376 struct dcerpc_pipe
*p
,
377 struct policy_handle
*handle
)
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
;
387 torture_assert(tctx
, test_GetPrinter_level(tctx
, b
, handle
, 2, &info
), "");
389 ZERO_STRUCT(devmode_ctr
);
390 ZERO_STRUCT(secdesc_ctr
);
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
;
415 info_ctr
.info
.info2
= &info2
;
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
;
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");
429 static 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
)
434 struct dcesrv_endpoint_server ep_server
;
436 struct dcesrv_context
*dce_ctx
;
437 const char *endpoints
[] = { "spoolss", NULL
};
438 struct dcesrv_endpoint
*e
;
440 struct interface
*ifaces
;
442 ntvfs_init(tctx
->lp_ctx
);
444 /* fill in our name */
445 ep_server
.name
= "spoolss";
447 /* fill in all the operations */
448 ep_server
.init_server
= spoolss__op_init_server
;
450 ep_server
.interface_by_uuid
= spoolss__op_interface_by_uuid
;
451 ep_server
.interface_by_name
= spoolss__op_interface_by_name
;
453 torture_assert_ntstatus_ok(tctx
, dcerpc_register_ep_server(&ep_server
),
454 "unable to register spoolss server");
456 lp_set_cmdline(tctx
->lp_ctx
, "dcerpc endpoint servers", "spoolss");
458 load_interfaces(tctx
, lp_interfaces(tctx
->lp_ctx
), &ifaces
);
459 address
= iface_n_ip(ifaces
, 0);
461 torture_comment(tctx
, "Listening for callbacks on %s\n", address
);
463 status
= smbsrv_add_socket(event_ctx
, tctx
->lp_ctx
, &single_ops
, address
);
464 torture_assert_ntstatus_ok(tctx
, status
, "starting smb server");
466 status
= dcesrv_init_context(tctx
, tctx
->lp_ctx
, endpoints
, &dce_ctx
);
467 torture_assert_ntstatus_ok(tctx
, status
,
468 "unable to initialize DCE/RPC server");
470 for (e
=dce_ctx
->endpoint_list
;e
;e
=e
->next
) {
471 status
= dcesrv_add_ep(dce_ctx
, tctx
->lp_ctx
,
472 e
, tctx
->ev
, &single_ops
);
473 torture_assert_ntstatus_ok(tctx
, status
,
474 "unable listen on dcerpc endpoint server");
477 *dce_ctx_p
= dce_ctx
;
478 *address_p
= address
;
483 static struct received_packet
*last_packet(struct received_packet
*p
)
485 struct received_packet
*tmp
;
486 for (tmp
= p
; tmp
->next
; tmp
= tmp
->next
) ;;
490 static bool test_RFFPCNEx(struct torture_context
*tctx
,
491 struct dcerpc_pipe
*p
)
493 struct dcesrv_context
*dce_ctx
;
494 struct policy_handle handle
;
496 struct received_packet
*tmp
;
497 struct spoolss_NotifyOption
*server_option
= setup_printserver_NotifyOption(tctx
);
499 struct spoolss_NotifyOption
*printer_option
= setup_printer_NotifyOption(tctx
);
501 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
503 received_packets
= NULL
;
505 /* Start DCE/RPC server */
506 torture_assert(tctx
, test_start_dcerpc_server(tctx
, p
->conn
->event_ctx
, &dce_ctx
, &address
), "");
508 torture_assert(tctx
, test_OpenPrinter(tctx
, p
, &handle
, NULL
), "");
509 torture_assert(tctx
, test_RemoteFindFirstPrinterChangeNotifyEx(tctx
, b
, &handle
, address
, server_option
), "");
510 torture_assert(tctx
, received_packets
, "no packets received");
511 torture_assert_int_equal(tctx
, received_packets
->opnum
, NDR_SPOOLSS_REPLYOPENPRINTER
,
512 "no ReplyOpenPrinter packet after RemoteFindFirstPrinterChangeNotifyEx");
513 torture_assert(tctx
, test_RouterRefreshPrinterChangeNotify(tctx
, b
, &handle
, NULL
), "");
514 torture_assert(tctx
, test_RouterRefreshPrinterChangeNotify(tctx
, b
, &handle
, server_option
), "");
515 torture_assert(tctx
, test_ClosePrinter(tctx
, b
, &handle
), "");
516 tmp
= last_packet(received_packets
);
517 torture_assert_int_equal(tctx
, tmp
->opnum
, NDR_SPOOLSS_REPLYCLOSEPRINTER
,
518 "no ReplyClosePrinter packet after ClosePrinter");
520 torture_assert(tctx
, test_OpenPrinter(tctx
, p
, &handle
, "Epson AL-2600"), "");
521 torture_assert(tctx
, test_RemoteFindFirstPrinterChangeNotifyEx(tctx
, p
, &handle
, address
, printer_option
), "");
522 tmp
= last_packet(received_packets
);
523 torture_assert_int_equal(tctx
, tmp
->opnum
, NDR_SPOOLSS_REPLYOPENPRINTER
,
524 "no ReplyOpenPrinter packet after RemoteFindFirstPrinterChangeNotifyEx");
525 torture_assert(tctx
, test_RouterRefreshPrinterChangeNotify(tctx
, p
, &handle
, NULL
), "");
526 torture_assert(tctx
, test_RouterRefreshPrinterChangeNotify(tctx
, p
, &handle
, printer_option
), "");
527 torture_assert(tctx
, test_SetPrinter(tctx
, p
, &handle
), "");
528 tmp
= last_packet(received_packets
);
529 torture_assert_int_equal(tctx
, tmp
->opnum
, NDR_SPOOLSS_ROUTERREPLYPRINTEREX
,
530 "no RouterReplyPrinterEx packet after ClosePrinter");
531 torture_assert(tctx
, test_ClosePrinter(tctx
, p
, &handle
), "");
532 tmp
= last_packet(received_packets
);
533 torture_assert_int_equal(tctx
, tmp
->opnum
, NDR_SPOOLSS_REPLYCLOSEPRINTER
,
534 "no ReplyClosePrinter packet after ClosePrinter");
536 /* Shut down DCE/RPC server */
537 talloc_free(dce_ctx
);
542 /** Test that makes sure that calling ReplyOpenPrinter()
543 * on Samba 4 will cause an irpc broadcast call.
545 static bool test_ReplyOpenPrinter(struct torture_context
*tctx
,
546 struct dcerpc_pipe
*p
)
548 struct spoolss_ReplyOpenPrinter r
;
549 struct spoolss_ReplyClosePrinter s
;
550 struct policy_handle h
;
551 struct dcerpc_binding_handle
*b
= p
->binding_handle
;
553 if (torture_setting_bool(tctx
, "samba3", false)) {
554 torture_skip(tctx
, "skipping ReplyOpenPrinter server implementation test against s3\n");
557 r
.in
.server_name
= "earth";
558 r
.in
.printer_local
= 2;
559 r
.in
.type
= REG_DWORD
;
564 torture_assert_ntstatus_ok(tctx
,
565 dcerpc_spoolss_ReplyOpenPrinter_r(b
, tctx
, &r
),
566 "spoolss_ReplyOpenPrinter call failed");
568 torture_assert_werr_ok(tctx
, r
.out
.result
, "error return code");
573 torture_assert_ntstatus_ok(tctx
,
574 dcerpc_spoolss_ReplyClosePrinter_r(b
, tctx
, &s
),
575 "spoolss_ReplyClosePrinter call failed");
577 torture_assert_werr_ok(tctx
, r
.out
.result
, "error return code");
582 struct torture_suite
*torture_rpc_spoolss_notify(TALLOC_CTX
*mem_ctx
)
584 struct torture_suite
*suite
= torture_suite_create(mem_ctx
, "SPOOLSS-NOTIFY");
586 struct torture_rpc_tcase
*tcase
= torture_suite_add_rpc_iface_tcase(suite
,
587 "notify", &ndr_table_spoolss
);
589 torture_rpc_tcase_add_test(tcase
, "testRFFPCNEx", test_RFFPCNEx
);
590 torture_rpc_tcase_add_test(tcase
, "testReplyOpenPrinter", test_ReplyOpenPrinter
);