2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1998,
5 * Largely re-written : 2005
6 * Copyright (C) Jeremy Allison 1998 - 2005
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, see <http://www.gnu.org/licenses/>.
23 #include "../librpc/gen_ndr/srv_spoolss.h"
24 #include "librpc/gen_ndr/ndr_named_pipe_auth.h"
27 #define DBGC_CLASS DBGC_RPC_SRV
29 static int pipes_open
;
31 static pipes_struct
*InternalPipes
;
34 * the following prototypes are declared here to avoid
35 * code being moved about too much for a patch to be
36 * disrupted / less obvious.
38 * these functions, and associated functions that they
39 * call, should be moved behind a .so module-loading
40 * system _anyway_. so that's the next step...
43 static int close_internal_rpc_pipe_hnd(struct pipes_struct
*p
);
45 /****************************************************************************
46 Internal Pipe iterator functions.
47 ****************************************************************************/
49 pipes_struct
*get_first_internal_pipe(void)
54 pipes_struct
*get_next_internal_pipe(pipes_struct
*p
)
59 /****************************************************************************
60 Initialise an outgoing packet.
61 ****************************************************************************/
63 static bool pipe_init_outgoing_data(pipes_struct
*p
)
65 output_data
*o_data
= &p
->out_data
;
67 /* Reset the offset counters. */
68 o_data
->data_sent_length
= 0;
69 o_data
->current_pdu_sent
= 0;
71 prs_mem_free(&o_data
->frag
);
73 /* Free any memory in the current return data buffer. */
74 prs_mem_free(&o_data
->rdata
);
77 * Initialize the outgoing RPC data buffer.
78 * we will use this as the raw data area for replying to rpc requests.
80 if(!prs_init(&o_data
->rdata
, 128, p
->mem_ctx
, MARSHALL
)) {
81 DEBUG(0,("pipe_init_outgoing_data: malloc fail.\n"));
88 /****************************************************************************
89 Make an internal namedpipes structure
90 ****************************************************************************/
92 static struct pipes_struct
*make_internal_rpc_pipe_p(TALLOC_CTX
*mem_ctx
,
93 const struct ndr_syntax_id
*syntax
,
94 const char *client_address
,
95 struct auth_serversupplied_info
*server_info
)
99 DEBUG(4,("Create pipe requested %s\n",
100 get_pipe_name_from_syntax(talloc_tos(), syntax
)));
102 p
= TALLOC_ZERO_P(mem_ctx
, struct pipes_struct
);
105 DEBUG(0,("ERROR! no memory for pipes_struct!\n"));
109 p
->mem_ctx
= talloc_named(p
, 0, "pipe %s %p",
110 get_pipe_name_from_syntax(talloc_tos(),
112 if (p
->mem_ctx
== NULL
) {
113 DEBUG(0,("open_rpc_pipe_p: talloc_init failed.\n"));
118 if (!init_pipe_handle_list(p
, syntax
)) {
119 DEBUG(0,("open_rpc_pipe_p: init_pipe_handles failed.\n"));
125 * Initialize the incoming RPC data buffer with one PDU worth of memory.
126 * We cheat here and say we're marshalling, as we intend to add incoming
127 * data directly into the prs_struct and we want it to auto grow. We will
128 * change the type to UNMARSALLING before processing the stream.
131 if(!prs_init(&p
->in_data
.data
, 128, p
->mem_ctx
, MARSHALL
)) {
132 DEBUG(0,("open_rpc_pipe_p: malloc fail for in_data struct.\n"));
133 close_policy_by_pipe(p
);
138 p
->server_info
= copy_serverinfo(p
, server_info
);
139 if (p
->server_info
== NULL
) {
140 DEBUG(0, ("open_rpc_pipe_p: copy_serverinfo failed\n"));
141 close_policy_by_pipe(p
);
146 DLIST_ADD(InternalPipes
, p
);
148 memcpy(p
->client_address
, client_address
, sizeof(p
->client_address
));
150 p
->endian
= RPC_LITTLE_ENDIAN
;
153 * Initialize the outgoing RPC data buffer with no memory.
155 prs_init_empty(&p
->out_data
.rdata
, p
->mem_ctx
, MARSHALL
);
159 DEBUG(4,("Created internal pipe %s (pipes_open=%d)\n",
160 get_pipe_name_from_syntax(talloc_tos(), syntax
), pipes_open
));
162 talloc_set_destructor(p
, close_internal_rpc_pipe_hnd
);
167 /****************************************************************************
168 Sets the fault state on incoming packets.
169 ****************************************************************************/
171 static void set_incoming_fault(pipes_struct
*p
)
173 prs_mem_free(&p
->in_data
.data
);
174 p
->in_data
.pdu_needed_len
= 0;
175 p
->in_data
.pdu_received_len
= 0;
176 p
->fault_state
= True
;
177 DEBUG(10, ("set_incoming_fault: Setting fault state on pipe %s\n",
178 get_pipe_name_from_syntax(talloc_tos(), &p
->syntax
)));
181 /****************************************************************************
182 Ensures we have at least RPC_HEADER_LEN amount of data in the incoming buffer.
183 ****************************************************************************/
185 static ssize_t
fill_rpc_header(pipes_struct
*p
, char *data
, size_t data_to_copy
)
187 size_t len_needed_to_complete_hdr
= MIN(data_to_copy
, RPC_HEADER_LEN
- p
->in_data
.pdu_received_len
);
189 DEBUG(10,("fill_rpc_header: data_to_copy = %u, len_needed_to_complete_hdr = %u, receive_len = %u\n",
190 (unsigned int)data_to_copy
, (unsigned int)len_needed_to_complete_hdr
,
191 (unsigned int)p
->in_data
.pdu_received_len
));
193 if (p
->in_data
.current_in_pdu
== NULL
) {
194 p
->in_data
.current_in_pdu
= talloc_array(p
, uint8_t,
197 if (p
->in_data
.current_in_pdu
== NULL
) {
198 DEBUG(0, ("talloc failed\n"));
202 memcpy((char *)&p
->in_data
.current_in_pdu
[p
->in_data
.pdu_received_len
], data
, len_needed_to_complete_hdr
);
203 p
->in_data
.pdu_received_len
+= len_needed_to_complete_hdr
;
205 return (ssize_t
)len_needed_to_complete_hdr
;
208 /****************************************************************************
209 Unmarshalls a new PDU header. Assumes the raw header data is in current_in_pdu.
210 ****************************************************************************/
212 static ssize_t
unmarshall_rpc_header(pipes_struct
*p
)
215 * Unmarshall the header to determine the needed length.
220 if(p
->in_data
.pdu_received_len
!= RPC_HEADER_LEN
) {
221 DEBUG(0,("unmarshall_rpc_header: assert on rpc header length failed.\n"));
222 set_incoming_fault(p
);
226 prs_init_empty( &rpc_in
, p
->mem_ctx
, UNMARSHALL
);
227 prs_set_endian_data( &rpc_in
, p
->endian
);
229 prs_give_memory( &rpc_in
, (char *)&p
->in_data
.current_in_pdu
[0],
230 p
->in_data
.pdu_received_len
, False
);
233 * Unmarshall the header as this will tell us how much
234 * data we need to read to get the complete pdu.
235 * This also sets the endian flag in rpc_in.
238 if(!smb_io_rpc_hdr("", &p
->hdr
, &rpc_in
, 0)) {
239 DEBUG(0,("unmarshall_rpc_header: failed to unmarshall RPC_HDR.\n"));
240 set_incoming_fault(p
);
241 prs_mem_free(&rpc_in
);
246 * Validate the RPC header.
249 if(p
->hdr
.major
!= 5 && p
->hdr
.minor
!= 0) {
250 DEBUG(0,("unmarshall_rpc_header: invalid major/minor numbers in RPC_HDR.\n"));
251 set_incoming_fault(p
);
252 prs_mem_free(&rpc_in
);
257 * If there's not data in the incoming buffer this should be the start of a new RPC.
260 if(prs_offset(&p
->in_data
.data
) == 0) {
263 * AS/U doesn't set FIRST flag in a BIND packet it seems.
266 if ((p
->hdr
.pkt_type
== DCERPC_PKT_REQUEST
) && !(p
->hdr
.flags
& DCERPC_PFC_FLAG_FIRST
)) {
268 * Ensure that the FIRST flag is set. If not then we have
269 * a stream missmatch.
272 DEBUG(0,("unmarshall_rpc_header: FIRST flag not set in first PDU !\n"));
273 set_incoming_fault(p
);
274 prs_mem_free(&rpc_in
);
279 * If this is the first PDU then set the endianness
280 * flag in the pipe. We will need this when parsing all
284 p
->endian
= rpc_in
.bigendian_data
;
286 DEBUG(5,("unmarshall_rpc_header: using %sendian RPC\n",
287 p
->endian
== RPC_LITTLE_ENDIAN
? "little-" : "big-" ));
292 * If this is *NOT* the first PDU then check the endianness
293 * flag in the pipe is the same as that in the PDU.
296 if (p
->endian
!= rpc_in
.bigendian_data
) {
297 DEBUG(0,("unmarshall_rpc_header: FIRST endianness flag (%d) different in next PDU !\n", (int)p
->endian
));
298 set_incoming_fault(p
);
299 prs_mem_free(&rpc_in
);
305 * Ensure that the pdu length is sane.
308 if((p
->hdr
.frag_len
< RPC_HEADER_LEN
) || (p
->hdr
.frag_len
> RPC_MAX_PDU_FRAG_LEN
)) {
309 DEBUG(0,("unmarshall_rpc_header: assert on frag length failed.\n"));
310 set_incoming_fault(p
);
311 prs_mem_free(&rpc_in
);
315 DEBUG(10,("unmarshall_rpc_header: type = %u, flags = %u\n", (unsigned int)p
->hdr
.pkt_type
,
316 (unsigned int)p
->hdr
.flags
));
318 p
->in_data
.pdu_needed_len
= (uint32
)p
->hdr
.frag_len
- RPC_HEADER_LEN
;
320 prs_mem_free(&rpc_in
);
322 p
->in_data
.current_in_pdu
= TALLOC_REALLOC_ARRAY(
323 p
, p
->in_data
.current_in_pdu
, uint8_t, p
->hdr
.frag_len
);
324 if (p
->in_data
.current_in_pdu
== NULL
) {
325 DEBUG(0, ("talloc failed\n"));
326 set_incoming_fault(p
);
330 return 0; /* No extra data processed. */
333 /****************************************************************************
334 Call this to free any talloc'ed memory. Do this before and after processing
336 ****************************************************************************/
338 static void free_pipe_context(pipes_struct
*p
)
341 DEBUG(3,("free_pipe_context: destroying talloc pool of size "
342 "%lu\n", (unsigned long)talloc_total_size(p
->mem_ctx
) ));
343 talloc_free_children(p
->mem_ctx
);
345 p
->mem_ctx
= talloc_named(p
, 0, "pipe %s %p",
346 get_pipe_name_from_syntax(talloc_tos(),
348 if (p
->mem_ctx
== NULL
) {
349 p
->fault_state
= True
;
354 /****************************************************************************
355 Processes a request pdu. This will do auth processing if needed, and
356 appends the data into the complete stream if the LAST flag is not set.
357 ****************************************************************************/
359 static bool process_request_pdu(pipes_struct
*p
, prs_struct
*rpc_in_p
)
361 uint32 ss_padding_len
= 0;
362 size_t data_len
= p
->hdr
.frag_len
- RPC_HEADER_LEN
- RPC_HDR_REQ_LEN
-
363 (p
->hdr
.auth_len
? RPC_HDR_AUTH_LEN
: 0) - p
->hdr
.auth_len
;
366 DEBUG(0,("process_request_pdu: rpc request with no bind.\n"));
367 set_incoming_fault(p
);
372 * Check if we need to do authentication processing.
373 * This is only done on requests, not binds.
377 * Read the RPC request header.
380 if(!smb_io_rpc_hdr_req("req", &p
->hdr_req
, rpc_in_p
, 0)) {
381 DEBUG(0,("process_request_pdu: failed to unmarshall RPC_HDR_REQ.\n"));
382 set_incoming_fault(p
);
386 switch(p
->auth
.auth_type
) {
387 case PIPE_AUTH_TYPE_NONE
:
390 case PIPE_AUTH_TYPE_SPNEGO_NTLMSSP
:
391 case PIPE_AUTH_TYPE_NTLMSSP
:
394 if(!api_pipe_ntlmssp_auth_process(p
, rpc_in_p
, &ss_padding_len
, &status
)) {
395 DEBUG(0,("process_request_pdu: failed to do auth processing.\n"));
396 DEBUG(0,("process_request_pdu: error was %s.\n", nt_errstr(status
) ));
397 set_incoming_fault(p
);
403 case PIPE_AUTH_TYPE_SCHANNEL
:
404 if (!api_pipe_schannel_process(p
, rpc_in_p
, &ss_padding_len
)) {
405 DEBUG(3,("process_request_pdu: failed to do schannel processing.\n"));
406 set_incoming_fault(p
);
412 DEBUG(0,("process_request_pdu: unknown auth type %u set.\n", (unsigned int)p
->auth
.auth_type
));
413 set_incoming_fault(p
);
417 /* Now we've done the sign/seal we can remove any padding data. */
418 if (data_len
> ss_padding_len
) {
419 data_len
-= ss_padding_len
;
423 * Check the data length doesn't go over the 15Mb limit.
424 * increased after observing a bug in the Windows NT 4.0 SP6a
425 * spoolsv.exe when the response to a GETPRINTERDRIVER2 RPC
426 * will not fit in the initial buffer of size 0x1068 --jerry 22/01/2002
429 if(prs_offset(&p
->in_data
.data
) + data_len
> MAX_RPC_DATA_SIZE
) {
430 DEBUG(0,("process_request_pdu: rpc data buffer too large (%u) + (%u)\n",
431 (unsigned int)prs_data_size(&p
->in_data
.data
), (unsigned int)data_len
));
432 set_incoming_fault(p
);
437 * Append the data portion into the buffer and return.
440 if(!prs_append_some_prs_data(&p
->in_data
.data
, rpc_in_p
, prs_offset(rpc_in_p
), data_len
)) {
441 DEBUG(0,("process_request_pdu: Unable to append data size %u to parse buffer of size %u.\n",
442 (unsigned int)data_len
, (unsigned int)prs_data_size(&p
->in_data
.data
) ));
443 set_incoming_fault(p
);
447 if(p
->hdr
.flags
& DCERPC_PFC_FLAG_LAST
) {
450 * Ok - we finally have a complete RPC stream.
451 * Call the rpc command to process it.
455 * Ensure the internal prs buffer size is *exactly* the same
456 * size as the current offset.
459 if(!prs_set_buffer_size(&p
->in_data
.data
, prs_offset(&p
->in_data
.data
))) {
460 DEBUG(0,("process_request_pdu: Call to prs_set_buffer_size failed!\n"));
461 set_incoming_fault(p
);
466 * Set the parse offset to the start of the data and set the
467 * prs_struct to UNMARSHALL.
470 prs_set_offset(&p
->in_data
.data
, 0);
471 prs_switch_type(&p
->in_data
.data
, UNMARSHALL
);
474 * Process the complete data stream here.
477 free_pipe_context(p
);
479 if(pipe_init_outgoing_data(p
)) {
480 ret
= api_pipe_request(p
);
483 free_pipe_context(p
);
486 * We have consumed the whole data stream. Set back to
487 * marshalling and set the offset back to the start of
488 * the buffer to re-use it (we could also do a prs_mem_free()
489 * and then re_init on the next start of PDU. Not sure which
490 * is best here.... JRA.
493 prs_switch_type(&p
->in_data
.data
, MARSHALL
);
494 prs_set_offset(&p
->in_data
.data
, 0);
501 /****************************************************************************
502 Processes a finished PDU stored in current_in_pdu. The RPC_HEADER has
503 already been parsed and stored in p->hdr.
504 ****************************************************************************/
506 static void process_complete_pdu(pipes_struct
*p
)
509 size_t data_len
= p
->in_data
.pdu_received_len
- RPC_HEADER_LEN
;
510 char *data_p
= (char *)&p
->in_data
.current_in_pdu
[RPC_HEADER_LEN
];
514 DEBUG(10,("process_complete_pdu: pipe %s in fault state.\n",
515 get_pipe_name_from_syntax(talloc_tos(), &p
->syntax
)));
516 set_incoming_fault(p
);
517 setup_fault_pdu(p
, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR
));
521 prs_init_empty( &rpc_in
, p
->mem_ctx
, UNMARSHALL
);
524 * Ensure we're using the corrent endianness for both the
525 * RPC header flags and the raw data we will be reading from.
528 prs_set_endian_data( &rpc_in
, p
->endian
);
529 prs_set_endian_data( &p
->in_data
.data
, p
->endian
);
531 prs_give_memory( &rpc_in
, data_p
, (uint32
)data_len
, False
);
533 DEBUG(10,("process_complete_pdu: processing packet type %u\n",
534 (unsigned int)p
->hdr
.pkt_type
));
536 switch (p
->hdr
.pkt_type
) {
537 case DCERPC_PKT_REQUEST
:
538 reply
= process_request_pdu(p
, &rpc_in
);
541 case DCERPC_PKT_PING
: /* CL request - ignore... */
542 DEBUG(0,("process_complete_pdu: Error. Connectionless packet type %u received on pipe %s.\n",
543 (unsigned int)p
->hdr
.pkt_type
,
544 get_pipe_name_from_syntax(talloc_tos(),
548 case DCERPC_PKT_RESPONSE
: /* No responses here. */
549 DEBUG(0,("process_complete_pdu: Error. DCERPC_PKT_RESPONSE received from client on pipe %s.\n",
550 get_pipe_name_from_syntax(talloc_tos(),
554 case DCERPC_PKT_FAULT
:
555 case DCERPC_PKT_WORKING
: /* CL request - reply to a ping when a call in process. */
556 case DCERPC_PKT_NOCALL
: /* CL - server reply to a ping call. */
557 case DCERPC_PKT_REJECT
:
559 case DCERPC_PKT_CL_CANCEL
:
560 case DCERPC_PKT_FACK
:
561 case DCERPC_PKT_CANCEL_ACK
:
562 DEBUG(0,("process_complete_pdu: Error. Connectionless packet type %u received on pipe %s.\n",
563 (unsigned int)p
->hdr
.pkt_type
,
564 get_pipe_name_from_syntax(talloc_tos(),
568 case DCERPC_PKT_BIND
:
570 * We assume that a pipe bind is only in one pdu.
572 if(pipe_init_outgoing_data(p
)) {
573 reply
= api_pipe_bind_req(p
, &rpc_in
);
577 case DCERPC_PKT_BIND_ACK
:
578 case DCERPC_PKT_BIND_NAK
:
579 DEBUG(0,("process_complete_pdu: Error. DCERPC_PKT_BINDACK/DCERPC_PKT_BINDNACK packet type %u received on pipe %s.\n",
580 (unsigned int)p
->hdr
.pkt_type
,
581 get_pipe_name_from_syntax(talloc_tos(),
586 case DCERPC_PKT_ALTER
:
588 * We assume that a pipe bind is only in one pdu.
590 if(pipe_init_outgoing_data(p
)) {
591 reply
= api_pipe_alter_context(p
, &rpc_in
);
595 case DCERPC_PKT_ALTER_RESP
:
596 DEBUG(0,("process_complete_pdu: Error. DCERPC_PKT_ALTER_RESP on pipe %s: Should only be server -> client.\n",
597 get_pipe_name_from_syntax(talloc_tos(),
601 case DCERPC_PKT_AUTH3
:
603 * The third packet in an NTLMSSP auth exchange.
605 if(pipe_init_outgoing_data(p
)) {
606 reply
= api_pipe_bind_auth3(p
, &rpc_in
);
610 case DCERPC_PKT_SHUTDOWN
:
611 DEBUG(0,("process_complete_pdu: Error. DCERPC_PKT_SHUTDOWN on pipe %s: Should only be server -> client.\n",
612 get_pipe_name_from_syntax(talloc_tos(),
616 case DCERPC_PKT_CO_CANCEL
:
617 /* For now just free all client data and continue processing. */
618 DEBUG(3,("process_complete_pdu: DCERPC_PKT_CO_CANCEL. Abandoning rpc call.\n"));
619 /* As we never do asynchronous RPC serving, we can never cancel a
620 call (as far as I know). If we ever did we'd have to send a cancel_ack
621 reply. For now, just free all client data and continue processing. */
625 /* Enable this if we're doing async rpc. */
626 /* We must check the call-id matches the outstanding callid. */
627 if(pipe_init_outgoing_data(p
)) {
628 /* Send a cancel_ack PDU reply. */
629 /* We should probably check the auth-verifier here. */
630 reply
= setup_cancel_ack_reply(p
, &rpc_in
);
635 case DCERPC_PKT_ORPHANED
:
636 /* We should probably check the auth-verifier here.
637 For now just free all client data and continue processing. */
638 DEBUG(3,("process_complete_pdu: DCERPC_PKT_ORPHANED. Abandoning rpc call.\n"));
643 DEBUG(0,("process_complete_pdu: Unknown rpc type = %u received.\n", (unsigned int)p
->hdr
.pkt_type
));
647 /* Reset to little endian. Probably don't need this but it won't hurt. */
648 prs_set_endian_data( &p
->in_data
.data
, RPC_LITTLE_ENDIAN
);
651 DEBUG(3,("process_complete_pdu: DCE/RPC fault sent on "
652 "pipe %s\n", get_pipe_name_from_syntax(talloc_tos(),
654 set_incoming_fault(p
);
655 setup_fault_pdu(p
, NT_STATUS(DCERPC_FAULT_OP_RNG_ERROR
));
656 prs_mem_free(&rpc_in
);
659 * Reset the lengths. We're ready for a new pdu.
661 TALLOC_FREE(p
->in_data
.current_in_pdu
);
662 p
->in_data
.pdu_needed_len
= 0;
663 p
->in_data
.pdu_received_len
= 0;
666 prs_mem_free(&rpc_in
);
669 /****************************************************************************
670 Accepts incoming data on an rpc pipe. Processes the data in pdu sized units.
671 ****************************************************************************/
673 static ssize_t
process_incoming_data(pipes_struct
*p
, char *data
, size_t n
)
675 size_t data_to_copy
= MIN(n
, RPC_MAX_PDU_FRAG_LEN
- p
->in_data
.pdu_received_len
);
677 DEBUG(10,("process_incoming_data: Start: pdu_received_len = %u, pdu_needed_len = %u, incoming data = %u\n",
678 (unsigned int)p
->in_data
.pdu_received_len
, (unsigned int)p
->in_data
.pdu_needed_len
,
681 if(data_to_copy
== 0) {
683 * This is an error - data is being received and there is no
684 * space in the PDU. Free the received data and go into the fault state.
686 DEBUG(0,("process_incoming_data: No space in incoming pdu buffer. Current size = %u \
687 incoming data size = %u\n", (unsigned int)p
->in_data
.pdu_received_len
, (unsigned int)n
));
688 set_incoming_fault(p
);
693 * If we have no data already, wait until we get at least a RPC_HEADER_LEN
694 * number of bytes before we can do anything.
697 if((p
->in_data
.pdu_needed_len
== 0) && (p
->in_data
.pdu_received_len
< RPC_HEADER_LEN
)) {
699 * Always return here. If we have more data then the RPC_HEADER
700 * will be processed the next time around the loop.
702 return fill_rpc_header(p
, data
, data_to_copy
);
706 * At this point we know we have at least an RPC_HEADER_LEN amount of data
707 * stored in current_in_pdu.
711 * If pdu_needed_len is zero this is a new pdu.
712 * Unmarshall the header so we know how much more
713 * data we need, then loop again.
716 if(p
->in_data
.pdu_needed_len
== 0) {
717 ssize_t rret
= unmarshall_rpc_header(p
);
718 if (rret
== -1 || p
->in_data
.pdu_needed_len
> 0) {
721 /* If rret == 0 and pdu_needed_len == 0 here we have a PDU that consists
722 of an RPC_HEADER only. This is a DCERPC_PKT_SHUTDOWN, DCERPC_PKT_CO_CANCEL or DCERPC_PKT_ORPHANED
723 pdu type. Deal with this in process_complete_pdu(). */
727 * Ok - at this point we have a valid RPC_HEADER in p->hdr.
728 * Keep reading until we have a full pdu.
731 data_to_copy
= MIN(data_to_copy
, p
->in_data
.pdu_needed_len
);
734 * Copy as much of the data as we need into the current_in_pdu buffer.
735 * pdu_needed_len becomes zero when we have a complete pdu.
738 memcpy( (char *)&p
->in_data
.current_in_pdu
[p
->in_data
.pdu_received_len
], data
, data_to_copy
);
739 p
->in_data
.pdu_received_len
+= data_to_copy
;
740 p
->in_data
.pdu_needed_len
-= data_to_copy
;
743 * Do we have a complete PDU ?
744 * (return the number of bytes handled in the call)
747 if(p
->in_data
.pdu_needed_len
== 0) {
748 process_complete_pdu(p
);
752 DEBUG(10,("process_incoming_data: not a complete PDU yet. pdu_received_len = %u, pdu_needed_len = %u\n",
753 (unsigned int)p
->in_data
.pdu_received_len
, (unsigned int)p
->in_data
.pdu_needed_len
));
755 return (ssize_t
)data_to_copy
;
758 /****************************************************************************
759 Accepts incoming data on an internal rpc pipe.
760 ****************************************************************************/
762 static ssize_t
write_to_internal_pipe(struct pipes_struct
*p
, char *data
, size_t n
)
764 size_t data_left
= n
;
769 DEBUG(10,("write_to_pipe: data_left = %u\n", (unsigned int)data_left
));
771 data_used
= process_incoming_data(p
, data
, data_left
);
773 DEBUG(10,("write_to_pipe: data_used = %d\n", (int)data_used
));
779 data_left
-= data_used
;
786 /****************************************************************************
787 Replies to a request to read data from a pipe.
789 Headers are interspersed with the data at PDU intervals. By the time
790 this function is called, the start of the data could possibly have been
791 read by an SMBtrans (file_offset != 0).
793 Calling create_rpc_reply() here is a hack. The data should already
794 have been prepared into arrays of headers + data stream sections.
795 ****************************************************************************/
797 static ssize_t
read_from_internal_pipe(struct pipes_struct
*p
, char *data
, size_t n
,
798 bool *is_data_outstanding
)
800 uint32 pdu_remaining
= 0;
801 ssize_t data_returned
= 0;
804 DEBUG(0,("read_from_pipe: pipe not open\n"));
808 DEBUG(6,(" name: %s len: %u\n",
809 get_pipe_name_from_syntax(talloc_tos(), &p
->syntax
),
813 * We cannot return more than one PDU length per
818 * This condition should result in the connection being closed.
819 * Netapp filers seem to set it to 0xffff which results in domain
820 * authentications failing. Just ignore it so things work.
823 if(n
> RPC_MAX_PDU_FRAG_LEN
) {
824 DEBUG(5,("read_from_pipe: too large read (%u) requested on "
825 "pipe %s. We can only service %d sized reads.\n",
827 get_pipe_name_from_syntax(talloc_tos(), &p
->syntax
),
828 RPC_MAX_PDU_FRAG_LEN
));
829 n
= RPC_MAX_PDU_FRAG_LEN
;
833 * Determine if there is still data to send in the
834 * pipe PDU buffer. Always send this first. Never
835 * send more than is left in the current PDU. The
836 * client should send a new read request for a new
840 pdu_remaining
= prs_offset(&p
->out_data
.frag
)
841 - p
->out_data
.current_pdu_sent
;
843 if (pdu_remaining
> 0) {
844 data_returned
= (ssize_t
)MIN(n
, pdu_remaining
);
846 DEBUG(10,("read_from_pipe: %s: current_pdu_len = %u, "
847 "current_pdu_sent = %u returning %d bytes.\n",
848 get_pipe_name_from_syntax(talloc_tos(), &p
->syntax
),
849 (unsigned int)prs_offset(&p
->out_data
.frag
),
850 (unsigned int)p
->out_data
.current_pdu_sent
,
851 (int)data_returned
));
854 prs_data_p(&p
->out_data
.frag
)
855 + p
->out_data
.current_pdu_sent
,
858 p
->out_data
.current_pdu_sent
+= (uint32
)data_returned
;
863 * At this point p->current_pdu_len == p->current_pdu_sent (which
864 * may of course be zero if this is the first return fragment.
867 DEBUG(10,("read_from_pipe: %s: fault_state = %d : data_sent_length "
868 "= %u, prs_offset(&p->out_data.rdata) = %u.\n",
869 get_pipe_name_from_syntax(talloc_tos(), &p
->syntax
),
871 (unsigned int)p
->out_data
.data_sent_length
,
872 (unsigned int)prs_offset(&p
->out_data
.rdata
) ));
874 if(p
->out_data
.data_sent_length
>= prs_offset(&p
->out_data
.rdata
)) {
876 * We have sent all possible data, return 0.
883 * We need to create a new PDU from the data left in p->rdata.
884 * Create the header/data/footers. This also sets up the fields
885 * p->current_pdu_len, p->current_pdu_sent, p->data_sent_length
886 * and stores the outgoing PDU in p->current_pdu.
889 if(!create_next_pdu(p
)) {
890 DEBUG(0,("read_from_pipe: %s: create_next_pdu failed.\n",
891 get_pipe_name_from_syntax(talloc_tos(), &p
->syntax
)));
895 data_returned
= MIN(n
, prs_offset(&p
->out_data
.frag
));
897 memcpy( data
, prs_data_p(&p
->out_data
.frag
), (size_t)data_returned
);
898 p
->out_data
.current_pdu_sent
+= (uint32
)data_returned
;
901 (*is_data_outstanding
) = prs_offset(&p
->out_data
.frag
) > n
;
903 if (p
->out_data
.current_pdu_sent
== prs_offset(&p
->out_data
.frag
)) {
904 /* We've returned everything in the out_data.frag
905 * so we're done with this pdu. Free it and reset
906 * current_pdu_sent. */
907 p
->out_data
.current_pdu_sent
= 0;
908 prs_mem_free(&p
->out_data
.frag
);
910 return data_returned
;
913 /****************************************************************************
915 ****************************************************************************/
917 static int close_internal_rpc_pipe_hnd(struct pipes_struct
*p
)
920 DEBUG(0,("Invalid pipe in close_internal_rpc_pipe_hnd\n"));
924 prs_mem_free(&p
->out_data
.frag
);
925 prs_mem_free(&p
->out_data
.rdata
);
926 prs_mem_free(&p
->in_data
.data
);
928 if (p
->auth
.auth_data_free_func
) {
929 (*p
->auth
.auth_data_free_func
)(&p
->auth
);
932 free_pipe_rpc_context( p
->contexts
);
934 /* Free the handles database. */
935 close_policy_by_pipe(p
);
937 DLIST_REMOVE(InternalPipes
, p
);
944 bool fsp_is_np(struct files_struct
*fsp
)
946 enum FAKE_FILE_TYPE type
;
948 if ((fsp
== NULL
) || (fsp
->fake_file_handle
== NULL
)) {
952 type
= fsp
->fake_file_handle
->type
;
954 return ((type
== FAKE_FILE_TYPE_NAMED_PIPE
)
955 || (type
== FAKE_FILE_TYPE_NAMED_PIPE_PROXY
));
958 struct np_proxy_state
{
959 struct tevent_queue
*read_queue
;
960 struct tevent_queue
*write_queue
;
967 static int np_proxy_state_destructor(struct np_proxy_state
*state
)
969 if (state
->fd
!= -1) {
975 static struct np_proxy_state
*make_external_rpc_pipe_p(TALLOC_CTX
*mem_ctx
,
976 const char *pipe_name
,
977 struct auth_serversupplied_info
*server_info
)
979 struct np_proxy_state
*result
;
980 struct sockaddr_un addr
;
982 const char *socket_dir
;
985 struct netr_SamInfo3
*info3
;
986 struct named_pipe_auth_req req
;
989 struct named_pipe_auth_rep rep
;
990 enum ndr_err_code ndr_err
;
994 result
= talloc(mem_ctx
, struct np_proxy_state
);
995 if (result
== NULL
) {
996 DEBUG(0, ("talloc failed\n"));
1000 result
->fd
= socket(AF_UNIX
, SOCK_STREAM
, 0);
1001 if (result
->fd
== -1) {
1002 DEBUG(10, ("socket(2) failed: %s\n", strerror(errno
)));
1005 talloc_set_destructor(result
, np_proxy_state_destructor
);
1008 addr
.sun_family
= AF_UNIX
;
1010 socket_dir
= lp_parm_const_string(
1011 GLOBAL_SECTION_SNUM
, "external_rpc_pipe", "socket_dir",
1012 get_dyn_NCALRPCDIR());
1013 if (socket_dir
== NULL
) {
1014 DEBUG(0, ("externan_rpc_pipe:socket_dir not set\n"));
1018 socket_path
= talloc_asprintf(talloc_tos(), "%s/np/%s",
1019 socket_dir
, pipe_name
);
1020 if (socket_path
== NULL
) {
1021 DEBUG(0, ("talloc_asprintf failed\n"));
1024 strncpy(addr
.sun_path
, socket_path
, sizeof(addr
.sun_path
));
1025 TALLOC_FREE(socket_path
);
1028 if (sys_connect(result
->fd
, (struct sockaddr
*)&addr
) == -1) {
1030 DEBUG(0, ("connect(%s) failed: %s\n", addr
.sun_path
,
1036 info3
= talloc(talloc_tos(), struct netr_SamInfo3
);
1037 if (info3
== NULL
) {
1038 DEBUG(0, ("talloc failed\n"));
1042 status
= serverinfo_to_SamInfo3(server_info
, NULL
, 0, info3
);
1043 if (!NT_STATUS_IS_OK(status
)) {
1045 DEBUG(0, ("serverinfo_to_SamInfo3 failed: %s\n",
1046 nt_errstr(status
)));
1051 req
.info
.info1
= *info3
;
1053 ndr_err
= ndr_push_struct_blob(&req_blob
, talloc_tos(), &req
,
1054 (ndr_push_flags_fn_t
)ndr_push_named_pipe_auth_req
);
1056 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1057 DEBUG(10, ("ndr_push_named_pipe_auth_req failed: %s\n",
1058 ndr_errstr(ndr_err
)));
1062 DEBUG(10, ("named_pipe_auth_req(client)[%u]\n", (uint32_t)req_blob
.length
));
1063 dump_data(10, req_blob
.data
, req_blob
.length
);
1065 written
= write_data(result
->fd
, (char *)req_blob
.data
,
1067 if (written
== -1) {
1068 DEBUG(3, ("Could not write auth req data to RPC server\n"));
1072 status
= read_data(result
->fd
, (char *)rep_buf
, sizeof(rep_buf
));
1073 if (!NT_STATUS_IS_OK(status
)) {
1074 DEBUG(3, ("Could not read auth result\n"));
1078 rep_blob
= data_blob_const(rep_buf
, sizeof(rep_buf
));
1080 DEBUG(10,("name_pipe_auth_rep(client)[%u]\n", (uint32_t)rep_blob
.length
));
1081 dump_data(10, rep_blob
.data
, rep_blob
.length
);
1083 ndr_err
= ndr_pull_struct_blob(&rep_blob
, talloc_tos(), &rep
,
1084 (ndr_pull_flags_fn_t
)ndr_pull_named_pipe_auth_rep
);
1086 if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err
)) {
1087 DEBUG(0, ("ndr_pull_named_pipe_auth_rep failed: %s\n",
1088 ndr_errstr(ndr_err
)));
1092 if (rep
.length
!= 16) {
1093 DEBUG(0, ("req invalid length: %u != 16\n",
1098 if (strcmp(NAMED_PIPE_AUTH_MAGIC
, rep
.magic
) != 0) {
1099 DEBUG(0, ("req invalid magic: %s != %s\n",
1100 rep
.magic
, NAMED_PIPE_AUTH_MAGIC
));
1104 if (!NT_STATUS_IS_OK(rep
.status
)) {
1105 DEBUG(0, ("req failed: %s\n",
1106 nt_errstr(rep
.status
)));
1110 if (rep
.level
!= 1) {
1111 DEBUG(0, ("req invalid level: %u != 1\n",
1118 result
->read_queue
= tevent_queue_create(result
, "np_read");
1119 if (result
->read_queue
== NULL
) {
1122 result
->write_queue
= tevent_queue_create(result
, "np_write");
1123 if (result
->write_queue
== NULL
) {
1130 TALLOC_FREE(result
);
1134 NTSTATUS
np_open(TALLOC_CTX
*mem_ctx
, const char *name
,
1135 const char *client_address
,
1136 struct auth_serversupplied_info
*server_info
,
1137 struct fake_file_handle
**phandle
)
1139 const char **proxy_list
;
1140 struct fake_file_handle
*handle
;
1142 proxy_list
= lp_parm_string_list(-1, "np", "proxy", NULL
);
1144 handle
= talloc(mem_ctx
, struct fake_file_handle
);
1145 if (handle
== NULL
) {
1146 return NT_STATUS_NO_MEMORY
;
1149 if ((proxy_list
!= NULL
) && str_list_check_ci(proxy_list
, name
)) {
1150 struct np_proxy_state
*p
;
1152 p
= make_external_rpc_pipe_p(handle
, name
, server_info
);
1154 handle
->type
= FAKE_FILE_TYPE_NAMED_PIPE_PROXY
;
1155 handle
->private_data
= p
;
1157 struct pipes_struct
*p
;
1158 struct ndr_syntax_id syntax
;
1160 if (!is_known_pipename(name
, &syntax
)) {
1161 TALLOC_FREE(handle
);
1162 return NT_STATUS_OBJECT_NAME_NOT_FOUND
;
1165 p
= make_internal_rpc_pipe_p(handle
, &syntax
, client_address
,
1168 handle
->type
= FAKE_FILE_TYPE_NAMED_PIPE
;
1169 handle
->private_data
= p
;
1172 if (handle
->private_data
== NULL
) {
1173 TALLOC_FREE(handle
);
1174 return NT_STATUS_PIPE_NOT_AVAILABLE
;
1179 return NT_STATUS_OK
;
1182 struct np_write_state
{
1183 struct event_context
*ev
;
1184 struct np_proxy_state
*p
;
1189 static void np_write_done(struct tevent_req
*subreq
);
1191 struct tevent_req
*np_write_send(TALLOC_CTX
*mem_ctx
, struct event_context
*ev
,
1192 struct fake_file_handle
*handle
,
1193 const uint8_t *data
, size_t len
)
1195 struct tevent_req
*req
;
1196 struct np_write_state
*state
;
1199 DEBUG(6, ("np_write_send: len: %d\n", (int)len
));
1200 dump_data(50, data
, len
);
1202 req
= tevent_req_create(mem_ctx
, &state
, struct np_write_state
);
1208 state
->nwritten
= 0;
1209 status
= NT_STATUS_OK
;
1213 if (handle
->type
== FAKE_FILE_TYPE_NAMED_PIPE
) {
1214 struct pipes_struct
*p
= talloc_get_type_abort(
1215 handle
->private_data
, struct pipes_struct
);
1217 state
->nwritten
= write_to_internal_pipe(p
, (char *)data
, len
);
1219 status
= (state
->nwritten
>= 0)
1220 ? NT_STATUS_OK
: NT_STATUS_UNEXPECTED_IO_ERROR
;
1224 if (handle
->type
== FAKE_FILE_TYPE_NAMED_PIPE_PROXY
) {
1225 struct np_proxy_state
*p
= talloc_get_type_abort(
1226 handle
->private_data
, struct np_proxy_state
);
1227 struct tevent_req
*subreq
;
1231 state
->iov
.iov_base
= CONST_DISCARD(void *, data
);
1232 state
->iov
.iov_len
= len
;
1234 subreq
= writev_send(state
, ev
, p
->write_queue
, p
->fd
,
1235 false, &state
->iov
, 1);
1236 if (subreq
== NULL
) {
1239 tevent_req_set_callback(subreq
, np_write_done
, req
);
1243 status
= NT_STATUS_INVALID_HANDLE
;
1245 if (NT_STATUS_IS_OK(status
)) {
1246 tevent_req_done(req
);
1248 tevent_req_nterror(req
, status
);
1250 return tevent_req_post(req
, ev
);
1256 static void np_write_done(struct tevent_req
*subreq
)
1258 struct tevent_req
*req
= tevent_req_callback_data(
1259 subreq
, struct tevent_req
);
1260 struct np_write_state
*state
= tevent_req_data(
1261 req
, struct np_write_state
);
1265 received
= writev_recv(subreq
, &err
);
1267 tevent_req_nterror(req
, map_nt_error_from_unix(err
));
1270 state
->nwritten
= received
;
1271 tevent_req_done(req
);
1274 NTSTATUS
np_write_recv(struct tevent_req
*req
, ssize_t
*pnwritten
)
1276 struct np_write_state
*state
= tevent_req_data(
1277 req
, struct np_write_state
);
1280 if (tevent_req_is_nterror(req
, &status
)) {
1283 *pnwritten
= state
->nwritten
;
1284 return NT_STATUS_OK
;
1287 static ssize_t
rpc_frag_more_fn(uint8_t *buf
, size_t buflen
, void *priv
)
1290 struct rpc_hdr_info hdr
;
1293 if (buflen
> RPC_HEADER_LEN
) {
1296 prs_init_empty(&hdr_prs
, talloc_tos(), UNMARSHALL
);
1297 prs_give_memory(&hdr_prs
, (char *)buf
, RPC_HEADER_LEN
, false);
1298 ret
= smb_io_rpc_hdr("", &hdr
, &hdr_prs
, 0);
1299 prs_mem_free(&hdr_prs
);
1305 return (hdr
.frag_len
- RPC_HEADER_LEN
);
1308 struct np_read_state
{
1309 struct event_context
*ev
;
1310 struct np_proxy_state
*p
;
1315 bool is_data_outstanding
;
1318 static void np_read_trigger(struct tevent_req
*req
, void *private_data
);
1319 static void np_read_done(struct tevent_req
*subreq
);
1321 struct tevent_req
*np_read_send(TALLOC_CTX
*mem_ctx
, struct event_context
*ev
,
1322 struct fake_file_handle
*handle
,
1323 uint8_t *data
, size_t len
)
1325 struct tevent_req
*req
;
1326 struct np_read_state
*state
;
1329 req
= tevent_req_create(mem_ctx
, &state
, struct np_read_state
);
1334 if (handle
->type
== FAKE_FILE_TYPE_NAMED_PIPE
) {
1335 struct pipes_struct
*p
= talloc_get_type_abort(
1336 handle
->private_data
, struct pipes_struct
);
1338 state
->nread
= read_from_internal_pipe(
1339 p
, (char *)data
, len
, &state
->is_data_outstanding
);
1341 status
= (state
->nread
>= 0)
1342 ? NT_STATUS_OK
: NT_STATUS_UNEXPECTED_IO_ERROR
;
1346 if (handle
->type
== FAKE_FILE_TYPE_NAMED_PIPE_PROXY
) {
1347 struct np_proxy_state
*p
= talloc_get_type_abort(
1348 handle
->private_data
, struct np_proxy_state
);
1350 if (p
->msg
!= NULL
) {
1353 thistime
= MIN(talloc_get_size(p
->msg
) - p
->sent
,
1356 memcpy(data
, p
->msg
+p
->sent
, thistime
);
1357 state
->nread
= thistime
;
1358 p
->sent
+= thistime
;
1360 if (p
->sent
< talloc_get_size(p
->msg
)) {
1361 state
->is_data_outstanding
= true;
1363 state
->is_data_outstanding
= false;
1364 TALLOC_FREE(p
->msg
);
1366 status
= NT_STATUS_OK
;
1375 if (!tevent_queue_add(p
->read_queue
, ev
, req
, np_read_trigger
,
1382 status
= NT_STATUS_INVALID_HANDLE
;
1384 if (NT_STATUS_IS_OK(status
)) {
1385 tevent_req_done(req
);
1387 tevent_req_nterror(req
, status
);
1389 return tevent_req_post(req
, ev
);
1395 static void np_read_trigger(struct tevent_req
*req
, void *private_data
)
1397 struct np_read_state
*state
= tevent_req_data(
1398 req
, struct np_read_state
);
1399 struct tevent_req
*subreq
;
1401 subreq
= read_packet_send(state
, state
->ev
, state
->p
->fd
,
1402 RPC_HEADER_LEN
, rpc_frag_more_fn
, NULL
);
1403 if (tevent_req_nomem(subreq
, req
)) {
1406 tevent_req_set_callback(subreq
, np_read_done
, req
);
1409 static void np_read_done(struct tevent_req
*subreq
)
1411 struct tevent_req
*req
= tevent_req_callback_data(
1412 subreq
, struct tevent_req
);
1413 struct np_read_state
*state
= tevent_req_data(
1414 req
, struct np_read_state
);
1419 received
= read_packet_recv(subreq
, state
->p
, &state
->p
->msg
, &err
);
1420 TALLOC_FREE(subreq
);
1421 if (received
== -1) {
1422 tevent_req_nterror(req
, map_nt_error_from_unix(err
));
1426 thistime
= MIN(received
, state
->len
);
1428 memcpy(state
->data
, state
->p
->msg
, thistime
);
1429 state
->p
->sent
= thistime
;
1430 state
->nread
= thistime
;
1432 if (state
->p
->sent
< received
) {
1433 state
->is_data_outstanding
= true;
1435 TALLOC_FREE(state
->p
->msg
);
1436 state
->is_data_outstanding
= false;
1439 tevent_req_done(req
);
1443 NTSTATUS
np_read_recv(struct tevent_req
*req
, ssize_t
*nread
,
1444 bool *is_data_outstanding
)
1446 struct np_read_state
*state
= tevent_req_data(
1447 req
, struct np_read_state
);
1450 if (tevent_req_is_nterror(req
, &status
)) {
1453 *nread
= state
->nread
;
1454 *is_data_outstanding
= state
->is_data_outstanding
;
1455 return NT_STATUS_OK
;
1459 * @brief Create a new RPC client context which uses a local dispatch function.
1461 * @param[in] mem_ctx The memory context to use.
1463 * @param[in] abstract_syntax Normally the syntax_id of the autogenerated
1466 * @param[in] dispatch The corresponding autogenerated dispatch function
1467 * rpc_<name>_dispatch.
1469 * @param[in] serversupplied_info The server supplied authentication function.
1471 * @param[out] presult A pointer to store the connected rpc client pipe.
1473 * @return NT_STATUS_OK on success, a corresponding NT status if an
1477 * struct rpc_pipe_client *winreg_pipe;
1480 * status = rpc_pipe_open_internal(tmp_ctx,
1481 * &ndr_table_winreg.syntax_id,
1482 * rpc_winreg_dispatch,
1487 NTSTATUS
rpc_pipe_open_internal(TALLOC_CTX
*mem_ctx
,
1488 const struct ndr_syntax_id
*abstract_syntax
,
1489 NTSTATUS (*dispatch
) (struct rpc_pipe_client
*cli
,
1490 TALLOC_CTX
*mem_ctx
,
1491 const struct ndr_interface_table
*table
,
1492 uint32_t opnum
, void *r
),
1493 struct auth_serversupplied_info
*serversupplied_info
,
1494 struct rpc_pipe_client
**presult
)
1496 struct rpc_pipe_client
*result
;
1498 result
= TALLOC_ZERO_P(mem_ctx
, struct rpc_pipe_client
);
1499 if (result
== NULL
) {
1500 return NT_STATUS_NO_MEMORY
;
1503 result
->abstract_syntax
= *abstract_syntax
;
1504 result
->transfer_syntax
= ndr_transfer_syntax
;
1505 result
->dispatch
= dispatch
;
1507 result
->pipes_struct
= make_internal_rpc_pipe_p(
1508 result
, abstract_syntax
, "", serversupplied_info
);
1509 if (result
->pipes_struct
== NULL
) {
1510 TALLOC_FREE(result
);
1511 return NT_STATUS_NO_MEMORY
;
1514 result
->max_xmit_frag
= -1;
1515 result
->max_recv_frag
= -1;
1518 return NT_STATUS_OK
;
1522 * @brief Create a new RPC client context which uses a local dispatch function.
1524 * @param[in] conn The connection struct that will hold the pipe
1526 * @param[out] spoolss_pipe A pointer to the connected rpc client pipe.
1528 * @return NT_STATUS_OK on success, a corresponding NT status if an
1531 NTSTATUS
rpc_connect_spoolss_pipe(connection_struct
*conn
,
1532 struct rpc_pipe_client
**spoolss_pipe
)
1536 /* TODO: check and handle disconnections */
1538 if (!conn
->spoolss_pipe
) {
1539 status
= rpc_pipe_open_internal(conn
,
1540 &ndr_table_spoolss
.syntax_id
,
1541 rpc_spoolss_dispatch
,
1543 &conn
->spoolss_pipe
);
1544 if (!NT_STATUS_IS_OK(status
)) {
1549 *spoolss_pipe
= conn
->spoolss_pipe
;
1550 return NT_STATUS_OK
;