2 Unix SMB/CIFS implementation.
3 test suite for spoolss rpc notify operations
5 Copyright (C) Jelmer Vernooij 2007
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2 of the License, or
10 (at your option) any later version.
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, write to the Free Software
19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 #include "torture/torture.h"
24 #include "torture/ui.h"
25 #include "torture/rpc/rpc.h"
26 #include "librpc/gen_ndr/ndr_spoolss_c.h"
27 #include "rpc_server/dcerpc_server.h"
28 #include "lib/events/events.h"
29 #include "smbd/process_model.h"
30 #include "smb_server/smb_server.h"
31 #include "lib/socket/netif.h"
32 #include "util/dlinklist.h"
33 #include "ntvfs/ntvfs.h"
34 #include "param/param.h"
36 static NTSTATUS
spoolss__op_bind(struct dcesrv_call_state
*dce_call
, const struct dcesrv_interface
*iface
)
41 static void spoolss__op_unbind(struct dcesrv_connection_context
*context
, const struct dcesrv_interface
*iface
)
45 static NTSTATUS
spoolss__op_ndr_pull(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, struct ndr_pull
*pull
, void **r
)
47 enum ndr_err_code ndr_err
;
48 uint16_t opnum
= dce_call
->pkt
.u
.request
.opnum
;
50 dce_call
->fault_code
= 0;
52 if (opnum
>= ndr_table_spoolss
.num_calls
) {
53 dce_call
->fault_code
= DCERPC_FAULT_OP_RNG_ERROR
;
54 return NT_STATUS_NET_WRITE_FAULT
;
57 *r
= talloc_size(mem_ctx
, ndr_table_spoolss
.calls
[opnum
].struct_size
);
58 NT_STATUS_HAVE_NO_MEMORY(*r
);
60 /* unravel the NDR for the packet */
61 ndr_err
= ndr_table_spoolss
.calls
[opnum
].ndr_pull(pull
, NDR_IN
, *r
);
62 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
63 dcerpc_log_packet(&ndr_table_spoolss
, opnum
, NDR_IN
,
64 &dce_call
->pkt
.u
.request
.stub_and_verifier
);
65 dce_call
->fault_code
= DCERPC_FAULT_NDR
;
66 return NT_STATUS_NET_WRITE_FAULT
;
72 /* Note that received_packets are allocated in talloc_autofree_context(),
73 * because no other context appears to stay around long enough. */
74 static struct received_packet
{
77 struct received_packet
*prev
, *next
;
78 } *received_packets
= NULL
;
81 static NTSTATUS
spoolss__op_dispatch(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, void *r
)
83 uint16_t opnum
= dce_call
->pkt
.u
.request
.opnum
;
84 struct received_packet
*rp
;
86 rp
= talloc_zero(talloc_autofree_context(), struct received_packet
);
88 rp
->r
= talloc_reference(rp
, r
);
90 DLIST_ADD_END(received_packets
, rp
, struct received_packet
*);
94 struct spoolss_ReplyOpenPrinter
*r2
= (struct spoolss_ReplyOpenPrinter
*)r
;
95 r2
->out
.result
= WERR_OK
;
100 dce_call
->fault_code
= DCERPC_FAULT_OP_RNG_ERROR
;
104 if (dce_call
->fault_code
!= 0) {
105 dcerpc_log_packet(&ndr_table_spoolss
, opnum
, NDR_IN
,
106 &dce_call
->pkt
.u
.request
.stub_and_verifier
);
107 return NT_STATUS_NET_WRITE_FAULT
;
113 static NTSTATUS
spoolss__op_reply(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, void *r
)
119 static NTSTATUS
spoolss__op_ndr_push(struct dcesrv_call_state
*dce_call
, TALLOC_CTX
*mem_ctx
, struct ndr_push
*push
, const void *r
)
121 enum ndr_err_code ndr_err
;
122 uint16_t opnum
= dce_call
->pkt
.u
.request
.opnum
;
124 ndr_err
= ndr_table_spoolss
.calls
[opnum
].ndr_push(push
, NDR_OUT
, r
);
125 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
126 dce_call
->fault_code
= DCERPC_FAULT_NDR
;
127 return NT_STATUS_NET_WRITE_FAULT
;
133 const static struct dcesrv_interface notify_test_spoolss_interface
= {
135 .syntax_id
= {{0x12345678,0x1234,0xabcd,{0xef,0x00},{0x01,0x23,0x45,0x67,0x89,0xab}},1.0},
136 .bind
= spoolss__op_bind
,
137 .unbind
= spoolss__op_unbind
,
138 .ndr_pull
= spoolss__op_ndr_pull
,
139 .dispatch
= spoolss__op_dispatch
,
140 .reply
= spoolss__op_reply
,
141 .ndr_push
= spoolss__op_ndr_push
144 static bool spoolss__op_interface_by_uuid(struct dcesrv_interface
*iface
, const struct GUID
*uuid
, uint32_t if_version
)
146 if (notify_test_spoolss_interface
.syntax_id
.if_version
== if_version
&&
147 GUID_equal(¬ify_test_spoolss_interface
.syntax_id
.uuid
, uuid
)) {
148 memcpy(iface
,¬ify_test_spoolss_interface
, sizeof(*iface
));
155 static bool spoolss__op_interface_by_name(struct dcesrv_interface
*iface
, const char *name
)
157 if (strcmp(notify_test_spoolss_interface
.name
, name
)==0) {
158 memcpy(iface
, ¬ify_test_spoolss_interface
, sizeof(*iface
));
165 static NTSTATUS
spoolss__op_init_server(struct dcesrv_context
*dce_ctx
, const struct dcesrv_endpoint_server
*ep_server
)
169 for (i
=0;i
<ndr_table_spoolss
.endpoints
->count
;i
++) {
171 const char *name
= ndr_table_spoolss
.endpoints
->names
[i
];
173 ret
= dcesrv_interface_register(dce_ctx
, name
, ¬ify_test_spoolss_interface
, NULL
);
174 if (!NT_STATUS_IS_OK(ret
)) {
175 DEBUG(1,("spoolss_op_init_server: failed to register endpoint '%s'\n",name
));
183 static bool test_RFFPCNEx(struct torture_context
*tctx
,
184 struct dcerpc_pipe
*p
)
186 struct spoolss_OpenPrinter q
;
187 struct spoolss_RemoteFindFirstPrinterChangeNotifyEx r
;
188 struct dcesrv_endpoint_server ep_server
;
190 struct dcesrv_context
*dce_ctx
;
191 const char *endpoints
[] = { "spoolss", NULL
};
192 struct spoolss_NotifyOptionsContainer t1
;
193 struct spoolss_ClosePrinter cp
;
195 struct policy_handle handle
;
197 struct interface
*ifaces
;
199 received_packets
= NULL
;
201 ntvfs_init(tctx
->lp_ctx
);
205 q
.in
.printername
= talloc_asprintf(tctx
, "\\\\%s", dcerpc_server_name(p
));
206 q
.in
.datatype
= NULL
;
207 q
.in
.devmode_ctr
.devmode
= NULL
;
208 q
.in
.access_mask
= SEC_FLAG_MAXIMUM_ALLOWED
;
209 q
.out
.handle
= &handle
;
211 torture_comment(tctx
, "Testing OpenPrinter(%s)\n", q
.in
.printername
);
213 status
= dcerpc_spoolss_OpenPrinter(p
, tctx
, &q
);
215 torture_assert_ntstatus_ok(tctx
, status
, "OpenPrinter failed");
217 torture_assert_werr_ok(tctx
, q
.out
.result
, "OpenPrinter failed");
219 /* Start DCE/RPC server */
221 /* fill in our name */
222 ep_server
.name
= "spoolss";
224 /* fill in all the operations */
225 ep_server
.init_server
= spoolss__op_init_server
;
227 ep_server
.interface_by_uuid
= spoolss__op_interface_by_uuid
;
228 ep_server
.interface_by_name
= spoolss__op_interface_by_name
;
230 torture_assert_ntstatus_ok(tctx
, dcerpc_register_ep_server(&ep_server
),
231 "unable to register spoolss server");
233 lp_set_cmdline(tctx
->lp_ctx
, "dcerpc endpoint servers", "spoolss");
235 load_interfaces(tctx
, lp_interfaces(tctx
->lp_ctx
), &ifaces
);
236 address
= iface_n_ip(ifaces
, 0);
237 torture_comment(tctx
, "Listening for callbacks on %s\n", address
);
238 status
= smbsrv_add_socket(p
->conn
->event_ctx
, tctx
->lp_ctx
, &single_ops
, address
);
239 torture_assert_ntstatus_ok(tctx
, status
, "starting smb server");
241 status
= dcesrv_init_context(tctx
, tctx
->lp_ctx
, endpoints
, &dce_ctx
);
242 torture_assert_ntstatus_ok(tctx
, status
,
243 "unable to initialize DCE/RPC server");
246 r
.in
.str
= talloc_asprintf(tctx
, "\\\\%s", address
);
248 r
.in
.printer_local
= 123;
252 t1
.options
= talloc_zero_array(tctx
, struct spoolss_NotifyOptionsArray
, 2);
253 t1
.options
[0].type
= SPOOLSS_NOTIFY_PRINTER
;
254 t1
.options
[0].count
= 1;
255 t1
.options
[0].fields
= talloc_array(t1
.options
, enum spoolss_Field
, 1);
256 t1
.options
[0].fields
[0] = SPOOLSS_FIELD_SERVER_NAME
;
258 t1
.options
[1].type
= SPOOLSS_NOTIFY_JOB
;
259 t1
.options
[1].count
= 1;
260 t1
.options
[1].fields
= talloc_array(t1
.options
, enum spoolss_Field
, 1);
261 t1
.options
[1].fields
[0] = SPOOLSS_FIELD_PRINTER_NAME
;
264 r
.in
.handle
= &handle
;
266 status
= dcerpc_spoolss_RemoteFindFirstPrinterChangeNotifyEx(p
, tctx
, &r
);
268 torture_assert_ntstatus_ok(tctx
, status
, "FFPCNEx failed");
270 torture_assert_werr_ok(tctx
, r
.out
.result
, "error return code for FFPCNEx");
272 cp
.in
.handle
= &handle
;
273 cp
.out
.handle
= &handle
;
275 torture_comment(tctx
, "Testing ClosePrinter\n");
277 status
= dcerpc_spoolss_ClosePrinter(p
, tctx
, &cp
);
278 torture_assert_ntstatus_ok(tctx
, status
, "ClosePrinter failed");
280 /* We should've had an incoming packet 58 (ReplyOpenPrinter) */
281 torture_assert(tctx
, received_packets
!= NULL
, "no packets received");
282 torture_assert_int_equal(tctx
, received_packets
->opnum
, 58, "invalid opnum");
284 /* Shut down DCE/RPC server */
285 talloc_free(dce_ctx
);
290 struct torture_suite
*torture_rpc_spoolss_notify(TALLOC_CTX
*mem_ctx
)
292 struct torture_suite
*suite
= torture_suite_create(mem_ctx
, "SPOOLSS-NOTIFY");
294 struct torture_rpc_tcase
*tcase
= torture_suite_add_rpc_iface_tcase(suite
,
295 "notify", &ndr_table_spoolss
);
297 torture_rpc_tcase_add_test(tcase
, "testRFFPCNEx", test_RFFPCNEx
);