2 * Unix SMB/CIFS implementation.
3 * RPC client transport over tstream
4 * Copyright (C) Simo Sorce 2010
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
21 #include "../lib/util/tevent_ntstatus.h"
22 #include "rpc_client/rpc_transport.h"
23 #include "lib/tsocket/tsocket.h"
24 #include "libcli/smb/tstream_smbXcli_np.h"
28 #define DBGC_CLASS DBGC_RPC_CLI
30 struct rpc_tstream_state {
31 struct tstream_context *stream;
32 struct tevent_queue *read_queue;
33 struct tevent_queue *write_queue;
37 static void rpc_tstream_disconnect(struct rpc_tstream_state *s)
39 TALLOC_FREE(s->stream);
42 static bool rpc_tstream_is_connected(void *priv)
44 struct rpc_tstream_state *transp =
45 talloc_get_type_abort(priv, struct rpc_tstream_state);
48 if (!transp->stream) {
52 if (!tstream_is_smbXcli_np(transp->stream)) {
56 ret = tstream_pending_bytes(transp->stream);
64 static unsigned int rpc_tstream_set_timeout(void *priv, unsigned int timeout)
66 struct rpc_tstream_state *transp =
67 talloc_get_type_abort(priv, struct rpc_tstream_state);
71 ok = rpc_tstream_is_connected(transp);
76 if (tstream_is_smbXcli_np(transp->stream)) {
77 transp->timeout = timeout;
78 return tstream_smbXcli_np_set_timeout(transp->stream, timeout);
81 orig_timeout = transp->timeout;
83 transp->timeout = timeout;
88 struct rpc_tstream_next_vector_state {
94 static void rpc_tstream_next_vector_init(
95 struct rpc_tstream_next_vector_state *s,
96 uint8_t *buf, size_t len)
98 *s = (struct rpc_tstream_next_vector_state) {
99 .buf = buf, .len = MIN(len, UINT16_MAX),
103 static int rpc_tstream_next_vector(struct tstream_context *stream,
106 struct iovec **_vector,
109 struct rpc_tstream_next_vector_state *state =
110 (struct rpc_tstream_next_vector_state *)private_data;
111 struct iovec *vector;
113 if (state->ofs == state->len) {
119 vector = talloc_array(mem_ctx, struct iovec, 1);
124 vector[0].iov_base = state->buf;
125 vector[0].iov_len = state->len;
127 state->ofs = state->len;
134 struct rpc_tstream_read_state {
135 struct rpc_tstream_state *transp;
136 struct rpc_tstream_next_vector_state next_vector;
140 static void rpc_tstream_read_done(struct tevent_req *subreq);
142 static struct tevent_req *rpc_tstream_read_send(TALLOC_CTX *mem_ctx,
143 struct tevent_context *ev,
144 uint8_t *data, size_t size,
147 struct rpc_tstream_state *transp =
148 talloc_get_type_abort(priv, struct rpc_tstream_state);
149 struct tevent_req *req, *subreq;
150 struct rpc_tstream_read_state *state;
151 struct timeval endtime;
153 req = tevent_req_create(mem_ctx, &state, struct rpc_tstream_read_state);
157 if (!rpc_tstream_is_connected(transp)) {
158 NTSTATUS status = NT_STATUS_CONNECTION_DISCONNECTED;
159 if (tstream_is_smbXcli_np(transp->stream)) {
160 status = NT_STATUS_PIPE_DISCONNECTED;
162 tevent_req_nterror(req, status);
163 return tevent_req_post(req, ev);
165 state->transp = transp;
166 rpc_tstream_next_vector_init(&state->next_vector, data, size);
168 subreq = tstream_readv_pdu_queue_send(state, ev,
171 rpc_tstream_next_vector,
172 &state->next_vector);
173 if (subreq == NULL) {
174 tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
175 return tevent_req_post(req, ev);
178 endtime = timeval_current_ofs_msec(transp->timeout);
179 if (!tevent_req_set_endtime(subreq, ev, endtime)) {
183 tevent_req_set_callback(subreq, rpc_tstream_read_done, req);
190 static void rpc_tstream_read_done(struct tevent_req *subreq)
192 struct tevent_req *req =
193 tevent_req_callback_data(subreq, struct tevent_req);
194 struct rpc_tstream_read_state *state =
195 tevent_req_data(req, struct rpc_tstream_read_state);
198 state->nread = tstream_readv_pdu_queue_recv(subreq, &err);
200 if (state->nread < 0) {
201 rpc_tstream_disconnect(state->transp);
202 tevent_req_nterror(req, map_nt_error_from_unix(err));
205 tevent_req_done(req);
208 static NTSTATUS rpc_tstream_read_recv(struct tevent_req *req, ssize_t *size)
210 struct rpc_tstream_read_state *state = tevent_req_data(
211 req, struct rpc_tstream_read_state);
214 if (tevent_req_is_nterror(req, &status)) {
217 *size = state->nread;
221 struct rpc_tstream_write_state {
222 struct tevent_context *ev;
223 struct rpc_tstream_state *transp;
228 static void rpc_tstream_write_done(struct tevent_req *subreq);
230 static struct tevent_req *rpc_tstream_write_send(TALLOC_CTX *mem_ctx,
231 struct tevent_context *ev,
232 const uint8_t *data, size_t size,
235 struct rpc_tstream_state *transp =
236 talloc_get_type_abort(priv, struct rpc_tstream_state);
237 struct tevent_req *req, *subreq;
238 struct rpc_tstream_write_state *state;
239 struct timeval endtime;
241 req = tevent_req_create(mem_ctx, &state, struct rpc_tstream_write_state);
245 if (!rpc_tstream_is_connected(transp)) {
246 NTSTATUS status = NT_STATUS_CONNECTION_DISCONNECTED;
247 if (tstream_is_smbXcli_np(transp->stream)) {
248 status = NT_STATUS_PIPE_DISCONNECTED;
250 tevent_req_nterror(req, status);
251 return tevent_req_post(req, ev);
254 state->transp = transp;
255 state->iov.iov_base = discard_const_p(void *, data);
256 state->iov.iov_len = size;
258 subreq = tstream_writev_queue_send(state, ev,
262 if (subreq == NULL) {
266 endtime = timeval_current_ofs_msec(transp->timeout);
267 if (!tevent_req_set_endtime(subreq, ev, endtime)) {
271 tevent_req_set_callback(subreq, rpc_tstream_write_done, req);
278 static void rpc_tstream_write_done(struct tevent_req *subreq)
280 struct tevent_req *req =
281 tevent_req_callback_data(subreq, struct tevent_req);
282 struct rpc_tstream_write_state *state =
283 tevent_req_data(req, struct rpc_tstream_write_state);
286 state->nwritten = tstream_writev_queue_recv(subreq, &err);
288 if (state->nwritten < 0) {
289 rpc_tstream_disconnect(state->transp);
290 tevent_req_nterror(req, map_nt_error_from_unix(err));
293 tevent_req_done(req);
296 static NTSTATUS rpc_tstream_write_recv(struct tevent_req *req, ssize_t *sent)
298 struct rpc_tstream_write_state *state =
299 tevent_req_data(req, struct rpc_tstream_write_state);
302 if (tevent_req_is_nterror(req, &status)) {
305 *sent = state->nwritten;
309 struct rpc_tstream_trans_state {
310 struct tevent_context *ev;
311 struct rpc_tstream_state *transp;
313 uint32_t max_rdata_len;
317 static void rpc_tstream_trans_writev(struct tevent_req *subreq);
318 static void rpc_tstream_trans_readv_pdu(struct tevent_req *subreq);
320 static int rpc_tstream_trans_next_vector(struct tstream_context *stream,
323 struct iovec **_vector,
326 static struct tevent_req *rpc_tstream_trans_send(TALLOC_CTX *mem_ctx,
327 struct tevent_context *ev,
328 const uint8_t *data, size_t data_len,
329 uint32_t max_rdata_len,
332 struct rpc_tstream_state *transp =
333 talloc_get_type_abort(priv, struct rpc_tstream_state);
334 struct tevent_req *req, *subreq;
335 struct rpc_tstream_trans_state *state;
336 struct timeval endtime;
337 bool use_trans = false;
339 req = tevent_req_create(mem_ctx, &state,
340 struct rpc_tstream_trans_state);
345 if (!rpc_tstream_is_connected(transp)) {
346 NTSTATUS status = NT_STATUS_CONNECTION_DISCONNECTED;
347 if (tstream_is_smbXcli_np(transp->stream)) {
348 status = NT_STATUS_PIPE_DISCONNECTED;
350 tevent_req_nterror(req, status);
351 return tevent_req_post(req, ev);
354 state->transp = transp;
355 state->req.iov_len = data_len;
356 state->req.iov_base = discard_const_p(void *, data);
357 state->max_rdata_len = max_rdata_len;
359 endtime = timeval_current_ofs_msec(transp->timeout);
361 if (tstream_is_smbXcli_np(transp->stream)) {
364 if (tevent_queue_length(transp->write_queue) > 0) {
367 if (tevent_queue_length(transp->read_queue) > 0) {
372 tstream_smbXcli_np_use_trans(transp->stream);
375 subreq = tstream_writev_queue_send(state, ev,
379 if (tevent_req_nomem(subreq, req)) {
380 return tevent_req_post(req, ev);
382 if (!tevent_req_set_endtime(subreq, ev, endtime)) {
383 return tevent_req_post(req, ev);
385 tevent_req_set_callback(subreq, rpc_tstream_trans_writev, req);
387 subreq = tstream_readv_pdu_queue_send(state, ev,
390 rpc_tstream_trans_next_vector,
392 if (tevent_req_nomem(subreq, req)) {
393 return tevent_req_post(req, ev);
395 if (!tevent_req_set_endtime(subreq, ev, endtime)) {
396 return tevent_req_post(req, ev);
398 tevent_req_set_callback(subreq, rpc_tstream_trans_readv_pdu, req);
403 static void rpc_tstream_trans_writev(struct tevent_req *subreq)
405 struct tevent_req *req =
406 tevent_req_callback_data(subreq,
408 struct rpc_tstream_trans_state *state =
410 struct rpc_tstream_trans_state);
414 ret = tstream_writev_queue_recv(subreq, &err);
417 rpc_tstream_disconnect(state->transp);
418 tevent_req_nterror(req, map_nt_error_from_unix(err));
423 static int rpc_tstream_trans_next_vector(struct tstream_context *stream,
426 struct iovec **_vector,
429 struct rpc_tstream_trans_state *state =
430 talloc_get_type_abort(private_data,
431 struct rpc_tstream_trans_state);
432 struct iovec *vector;
434 if (state->max_rdata_len == state->rep.iov_len) {
440 state->rep.iov_base = talloc_array(state, uint8_t,
441 state->max_rdata_len);
442 if (state->rep.iov_base == NULL) {
445 state->rep.iov_len = state->max_rdata_len;
447 vector = talloc_array(mem_ctx, struct iovec, 1);
452 vector[0] = state->rep;
459 static void rpc_tstream_trans_readv_pdu(struct tevent_req *subreq)
461 struct tevent_req *req =
462 tevent_req_callback_data(subreq,
464 struct rpc_tstream_trans_state *state =
466 struct rpc_tstream_trans_state);
470 ret = tstream_readv_pdu_queue_recv(subreq, &err);
473 rpc_tstream_disconnect(state->transp);
474 tevent_req_nterror(req, map_nt_error_from_unix(err));
478 tevent_req_done(req);
481 static NTSTATUS rpc_tstream_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
482 uint8_t **prdata, uint32_t *prdata_len)
484 struct rpc_tstream_trans_state *state =
486 struct rpc_tstream_trans_state);
489 if (tevent_req_is_nterror(req, &status)) {
493 *prdata = (uint8_t *)talloc_move(mem_ctx, &state->rep.iov_base);
494 *prdata_len = state->rep.iov_len;
499 * @brief Initialize a tstream transport facility
500 * NOTE: this function will talloc_steal, the stream and the queues.
502 * @param mem_ctx - memory context used to allocate the transport
503 * @param stream - a ready to use tstream
504 * @param presult - the transport structure
506 * @return - a NT Status error code.
508 NTSTATUS rpc_transport_tstream_init(TALLOC_CTX *mem_ctx,
509 struct tstream_context **stream,
510 struct rpc_cli_transport **presult)
512 struct rpc_cli_transport *result;
513 struct rpc_tstream_state *state;
515 result = talloc(mem_ctx, struct rpc_cli_transport);
516 if (result == NULL) {
517 return NT_STATUS_NO_MEMORY;
519 state = talloc(result, struct rpc_tstream_state);
522 return NT_STATUS_NO_MEMORY;
524 result->priv = state;
526 state->read_queue = tevent_queue_create(state, "read_queue");
527 if (state->read_queue == NULL) {
529 return NT_STATUS_NO_MEMORY;
531 state->write_queue = tevent_queue_create(state, "write_queue");
532 if (state->write_queue == NULL) {
534 return NT_STATUS_NO_MEMORY;
537 state->stream = talloc_move(state, stream);
538 state->timeout = 10000; /* 10 seconds. */
540 if (tstream_is_smbXcli_np(state->stream)) {
541 result->trans_send = rpc_tstream_trans_send;
542 result->trans_recv = rpc_tstream_trans_recv;
544 result->trans_send = NULL;
545 result->trans_recv = NULL;
547 result->write_send = rpc_tstream_write_send;
548 result->write_recv = rpc_tstream_write_recv;
549 result->read_send = rpc_tstream_read_send;
550 result->read_recv = rpc_tstream_read_recv;
551 result->is_connected = rpc_tstream_is_connected;
552 result->set_timeout = rpc_tstream_set_timeout;
558 struct tstream_context *rpc_transport_get_tstream(
559 struct rpc_cli_transport *transport)
561 struct rpc_tstream_state *state = talloc_get_type_abort(
562 transport->priv, struct rpc_tstream_state);
563 return state->stream;