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 "fake_file.h"
26 #include "rpc_server/rpc_ncacn_np.h"
27 #include "rpc_server/srv_pipe_hnd.h"
28 #include "rpc_client/local_np.h"
29 #include "rpc_server/rpc_server.h"
30 #include "rpc_server/rpc_config.h"
31 #include "../lib/tsocket/tsocket.h"
32 #include "../lib/util/tevent_ntstatus.h"
33 #include "librpc/ndr/ndr_table.h"
36 #define DBGC_CLASS DBGC_RPC_SRV
38 bool fsp_is_np(struct files_struct
*fsp
)
40 enum FAKE_FILE_TYPE type
;
42 if ((fsp
== NULL
) || (fsp
->fake_file_handle
== NULL
)) {
46 type
= fsp
->fake_file_handle
->type
;
48 return (type
== FAKE_FILE_TYPE_NAMED_PIPE_PROXY
);
51 NTSTATUS
np_open(TALLOC_CTX
*mem_ctx
, const char *name
,
52 const struct tsocket_address
*remote_client_address
,
53 const struct tsocket_address
*local_server_address
,
54 struct auth_session_info
*session_info
,
55 struct tevent_context
*ev_ctx
,
56 struct messaging_context
*msg_ctx
,
57 struct dcesrv_context
*dce_ctx
,
58 struct fake_file_handle
**phandle
)
60 struct fake_file_handle
*handle
;
61 struct npa_state
*npa
= NULL
;
64 handle
= talloc(mem_ctx
, struct fake_file_handle
);
66 return NT_STATUS_NO_MEMORY
;
69 npa
= npa_state_init(handle
);
72 return NT_STATUS_NO_MEMORY
;
74 *handle
= (struct fake_file_handle
) {
75 .type
= FAKE_FILE_TYPE_NAMED_PIPE_PROXY
,
79 ret
= local_np_connect(
83 remote_client_address
,
91 DBG_DEBUG("local_np_connect failed: %s\n",
94 return map_nt_error_from_unix(ret
);
102 bool np_read_in_progress(struct fake_file_handle
*handle
)
104 if (handle
->type
== FAKE_FILE_TYPE_NAMED_PIPE_PROXY
) {
105 struct npa_state
*p
=
106 talloc_get_type_abort(handle
->private_data
,
110 read_count
= tevent_queue_length(p
->read_queue
);
111 if (read_count
> 0) {
121 struct np_write_state
{
122 struct tevent_context
*ev
;
128 static void np_write_done(struct tevent_req
*subreq
);
130 struct tevent_req
*np_write_send(TALLOC_CTX
*mem_ctx
, struct tevent_context
*ev
,
131 struct fake_file_handle
*handle
,
132 const uint8_t *data
, size_t len
)
134 struct tevent_req
*req
;
135 struct np_write_state
*state
;
136 struct npa_state
*p
= NULL
;
137 struct tevent_req
*subreq
= NULL
;
139 DBG_INFO("len: %zu\n", len
);
140 dump_data(50, data
, len
);
142 req
= tevent_req_create(mem_ctx
, &state
, struct np_write_state
);
147 if (handle
->type
!= FAKE_FILE_TYPE_NAMED_PIPE_PROXY
) {
148 tevent_req_nterror(req
, NT_STATUS_INVALID_HANDLE
);
149 return tevent_req_post(req
, ev
);
154 tevent_req_done(req
);
155 return tevent_req_post(req
, ev
);
158 p
= talloc_get_type_abort(handle
->private_data
, struct npa_state
);
162 state
->iov
.iov_base
= discard_const_p(void, data
);
163 state
->iov
.iov_len
= len
;
165 subreq
= tstream_writev_queue_send(
166 state
, ev
, p
->stream
, p
->write_queue
, &state
->iov
, 1);
167 if (tevent_req_nomem(subreq
, req
)) {
168 return tevent_req_post(req
, ev
);
170 tevent_req_set_callback(subreq
, np_write_done
, req
);
174 static void np_write_done(struct tevent_req
*subreq
)
176 struct tevent_req
*req
= tevent_req_callback_data(
177 subreq
, struct tevent_req
);
178 struct np_write_state
*state
= tevent_req_data(
179 req
, struct np_write_state
);
183 received
= tstream_writev_queue_recv(subreq
, &err
);
185 tevent_req_nterror(req
, map_nt_error_from_unix(err
));
188 state
->nwritten
= received
;
189 tevent_req_done(req
);
192 NTSTATUS
np_write_recv(struct tevent_req
*req
, ssize_t
*pnwritten
)
194 struct np_write_state
*state
= tevent_req_data(
195 req
, struct np_write_state
);
198 if (tevent_req_is_nterror(req
, &status
)) {
201 *pnwritten
= state
->nwritten
;
205 struct np_ipc_readv_next_vector_state
{
212 static void np_ipc_readv_next_vector_init(struct np_ipc_readv_next_vector_state
*s
,
213 uint8_t *buf
, size_t len
)
218 s
->len
= MIN(len
, UINT16_MAX
);
221 static int np_ipc_readv_next_vector(struct tstream_context
*stream
,
224 struct iovec
**_vector
,
227 struct np_ipc_readv_next_vector_state
*state
=
228 (struct np_ipc_readv_next_vector_state
*)private_data
;
229 struct iovec
*vector
;
233 if (state
->ofs
== state
->len
) {
239 pending
= tstream_pending_bytes(stream
);
244 if (pending
== 0 && state
->ofs
!= 0) {
245 /* return a short read */
252 /* we want at least one byte and recheck again */
255 size_t missing
= state
->len
- state
->ofs
;
256 if (pending
> missing
) {
257 /* there's more available */
258 state
->remaining
= pending
- missing
;
261 /* read what we can get and recheck in the next cycle */
266 vector
= talloc_array(mem_ctx
, struct iovec
, 1);
271 vector
[0].iov_base
= state
->buf
+ state
->ofs
;
272 vector
[0].iov_len
= wanted
;
274 state
->ofs
+= wanted
;
281 struct np_read_state
{
283 struct np_ipc_readv_next_vector_state next_vector
;
286 bool is_data_outstanding
;
289 static void np_read_done(struct tevent_req
*subreq
);
291 struct tevent_req
*np_read_send(TALLOC_CTX
*mem_ctx
, struct tevent_context
*ev
,
292 struct fake_file_handle
*handle
,
293 uint8_t *data
, size_t len
)
295 struct tevent_req
*req
;
296 struct np_read_state
*state
;
297 struct npa_state
*p
= NULL
;
298 struct tevent_req
*subreq
= NULL
;
300 req
= tevent_req_create(mem_ctx
, &state
, struct np_read_state
);
305 if (handle
->type
!= FAKE_FILE_TYPE_NAMED_PIPE_PROXY
) {
306 tevent_req_nterror(req
, NT_STATUS_INVALID_HANDLE
);
307 return tevent_req_post(req
, ev
);
310 p
= talloc_get_type_abort(handle
->private_data
, struct npa_state
);
312 np_ipc_readv_next_vector_init(&state
->next_vector
, data
, len
);
314 subreq
= tstream_readv_pdu_queue_send(
319 np_ipc_readv_next_vector
,
320 &state
->next_vector
);
321 if (tevent_req_nomem(subreq
, req
)) {
322 return tevent_req_post(req
, ev
);
324 tevent_req_set_callback(subreq
, np_read_done
, req
);
328 static void np_read_done(struct tevent_req
*subreq
)
330 struct tevent_req
*req
= tevent_req_callback_data(
331 subreq
, struct tevent_req
);
332 struct np_read_state
*state
= tevent_req_data(
333 req
, struct np_read_state
);
337 ret
= tstream_readv_pdu_queue_recv(subreq
, &err
);
340 tevent_req_nterror(req
, map_nt_error_from_unix(err
));
345 state
->is_data_outstanding
= (state
->next_vector
.remaining
> 0);
347 tevent_req_done(req
);
351 NTSTATUS
np_read_recv(struct tevent_req
*req
, ssize_t
*nread
,
352 bool *is_data_outstanding
)
354 struct np_read_state
*state
= tevent_req_data(
355 req
, struct np_read_state
);
358 if (tevent_req_is_nterror(req
, &status
)) {
362 DEBUG(10, ("Received %d bytes. There is %smore data outstanding\n",
363 (int)state
->nread
, state
->is_data_outstanding
?"":"no "));
365 *nread
= state
->nread
;
366 *is_data_outstanding
= state
->is_data_outstanding
;