Line data Source code
1 : /*
2 : * Unix SMB/CIFS implementation.
3 : * RPC client transport over tstream
4 : * Copyright (C) Simo Sorce 2010
5 : *
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.
10 : *
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.
15 : *
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/>.
18 : */
19 :
20 : #include "includes.h"
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"
25 : #include "cli_pipe.h"
26 :
27 : #undef DBGC_CLASS
28 : #define DBGC_CLASS DBGC_RPC_CLI
29 :
30 : struct rpc_tstream_state {
31 : struct tstream_context *stream;
32 : struct tevent_queue *read_queue;
33 : struct tevent_queue *write_queue;
34 : unsigned int timeout;
35 : };
36 :
37 0 : static void rpc_tstream_disconnect(struct rpc_tstream_state *s)
38 : {
39 0 : TALLOC_FREE(s->stream);
40 0 : }
41 :
42 22702 : static bool rpc_tstream_is_connected(void *priv)
43 : {
44 13844 : struct rpc_tstream_state *transp =
45 8858 : talloc_get_type_abort(priv, struct rpc_tstream_state);
46 : ssize_t ret;
47 :
48 22702 : if (!transp->stream) {
49 0 : return false;
50 : }
51 :
52 22702 : if (!tstream_is_smbXcli_np(transp->stream)) {
53 8946 : return true;
54 : }
55 :
56 13756 : ret = tstream_pending_bytes(transp->stream);
57 13756 : if (ret == -1) {
58 0 : return false;
59 : }
60 :
61 13756 : return true;
62 : }
63 :
64 216 : static unsigned int rpc_tstream_set_timeout(void *priv, unsigned int timeout)
65 : {
66 129 : struct rpc_tstream_state *transp =
67 87 : talloc_get_type_abort(priv, struct rpc_tstream_state);
68 : int orig_timeout;
69 : bool ok;
70 :
71 216 : ok = rpc_tstream_is_connected(transp);
72 216 : if (!ok) {
73 0 : return 0;
74 : }
75 :
76 216 : if (tstream_is_smbXcli_np(transp->stream)) {
77 204 : transp->timeout = timeout;
78 204 : return tstream_smbXcli_np_set_timeout(transp->stream, timeout);
79 : }
80 :
81 12 : orig_timeout = transp->timeout;
82 :
83 12 : transp->timeout = timeout;
84 :
85 12 : return orig_timeout;
86 : }
87 :
88 : struct rpc_tstream_next_vector_state {
89 : uint8_t *buf;
90 : size_t len;
91 : off_t ofs;
92 : };
93 :
94 9376 : static void rpc_tstream_next_vector_init(
95 : struct rpc_tstream_next_vector_state *s,
96 : uint8_t *buf, size_t len)
97 : {
98 9376 : *s = (struct rpc_tstream_next_vector_state) {
99 9376 : .buf = buf, .len = MIN(len, UINT16_MAX),
100 : };
101 9376 : }
102 :
103 18752 : static int rpc_tstream_next_vector(struct tstream_context *stream,
104 : void *private_data,
105 : TALLOC_CTX *mem_ctx,
106 : struct iovec **_vector,
107 : size_t *count)
108 : {
109 18752 : struct rpc_tstream_next_vector_state *state =
110 : (struct rpc_tstream_next_vector_state *)private_data;
111 : struct iovec *vector;
112 :
113 18752 : if (state->ofs == state->len) {
114 9376 : *_vector = NULL;
115 9376 : *count = 0;
116 9376 : return 0;
117 : }
118 :
119 9376 : vector = talloc_array(mem_ctx, struct iovec, 1);
120 9376 : if (!vector) {
121 0 : return -1;
122 : }
123 :
124 9376 : vector[0].iov_base = state->buf;
125 9376 : vector[0].iov_len = state->len;
126 :
127 9376 : state->ofs = state->len;
128 :
129 9376 : *_vector = vector;
130 9376 : *count = 1;
131 9376 : return 0;
132 : }
133 :
134 : struct rpc_tstream_read_state {
135 : struct rpc_tstream_state *transp;
136 : struct rpc_tstream_next_vector_state next_vector;
137 : ssize_t nread;
138 : };
139 :
140 : static void rpc_tstream_read_done(struct tevent_req *subreq);
141 :
142 9376 : static struct tevent_req *rpc_tstream_read_send(TALLOC_CTX *mem_ctx,
143 : struct tevent_context *ev,
144 : uint8_t *data, size_t size,
145 : void *priv)
146 : {
147 5643 : struct rpc_tstream_state *transp =
148 3733 : 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;
152 :
153 9376 : req = tevent_req_create(mem_ctx, &state, struct rpc_tstream_read_state);
154 9376 : if (req == NULL) {
155 0 : return NULL;
156 : }
157 9376 : if (!rpc_tstream_is_connected(transp)) {
158 0 : NTSTATUS status = NT_STATUS_CONNECTION_DISCONNECTED;
159 0 : if (tstream_is_smbXcli_np(transp->stream)) {
160 0 : status = NT_STATUS_PIPE_DISCONNECTED;
161 : }
162 0 : tevent_req_nterror(req, status);
163 0 : return tevent_req_post(req, ev);
164 : }
165 9376 : state->transp = transp;
166 9376 : rpc_tstream_next_vector_init(&state->next_vector, data, size);
167 :
168 9376 : subreq = tstream_readv_pdu_queue_send(state, ev,
169 : transp->stream,
170 : transp->read_queue,
171 : rpc_tstream_next_vector,
172 9376 : &state->next_vector);
173 9376 : if (subreq == NULL) {
174 0 : tevent_req_nterror(req, NT_STATUS_NO_MEMORY);
175 0 : return tevent_req_post(req, ev);
176 : }
177 :
178 9376 : endtime = timeval_current_ofs_msec(transp->timeout);
179 9376 : if (!tevent_req_set_endtime(subreq, ev, endtime)) {
180 0 : goto fail;
181 : }
182 :
183 9376 : tevent_req_set_callback(subreq, rpc_tstream_read_done, req);
184 9376 : return req;
185 0 : fail:
186 0 : TALLOC_FREE(req);
187 0 : return NULL;
188 : }
189 :
190 9376 : static void rpc_tstream_read_done(struct tevent_req *subreq)
191 : {
192 5643 : struct tevent_req *req =
193 9376 : tevent_req_callback_data(subreq, struct tevent_req);
194 5643 : struct rpc_tstream_read_state *state =
195 9376 : tevent_req_data(req, struct rpc_tstream_read_state);
196 : int err;
197 :
198 9376 : state->nread = tstream_readv_pdu_queue_recv(subreq, &err);
199 9376 : TALLOC_FREE(subreq);
200 9376 : if (state->nread < 0) {
201 0 : rpc_tstream_disconnect(state->transp);
202 0 : tevent_req_nterror(req, map_nt_error_from_unix(err));
203 0 : return;
204 : }
205 9376 : tevent_req_done(req);
206 : }
207 :
208 9376 : static NTSTATUS rpc_tstream_read_recv(struct tevent_req *req, ssize_t *size)
209 : {
210 9376 : struct rpc_tstream_read_state *state = tevent_req_data(
211 : req, struct rpc_tstream_read_state);
212 : NTSTATUS status;
213 :
214 9376 : if (tevent_req_is_nterror(req, &status)) {
215 0 : return status;
216 : }
217 9376 : *size = state->nread;
218 9376 : return NT_STATUS_OK;
219 : }
220 :
221 : struct rpc_tstream_write_state {
222 : struct tevent_context *ev;
223 : struct rpc_tstream_state *transp;
224 : struct iovec iov;
225 : ssize_t nwritten;
226 : };
227 :
228 : static void rpc_tstream_write_done(struct tevent_req *subreq);
229 :
230 2269 : 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,
233 : void *priv)
234 : {
235 1319 : struct rpc_tstream_state *transp =
236 950 : 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;
240 :
241 2269 : req = tevent_req_create(mem_ctx, &state, struct rpc_tstream_write_state);
242 2269 : if (req == NULL) {
243 0 : return NULL;
244 : }
245 2269 : if (!rpc_tstream_is_connected(transp)) {
246 0 : NTSTATUS status = NT_STATUS_CONNECTION_DISCONNECTED;
247 0 : if (tstream_is_smbXcli_np(transp->stream)) {
248 0 : status = NT_STATUS_PIPE_DISCONNECTED;
249 : }
250 0 : tevent_req_nterror(req, status);
251 0 : return tevent_req_post(req, ev);
252 : }
253 2269 : state->ev = ev;
254 2269 : state->transp = transp;
255 2269 : state->iov.iov_base = discard_const_p(void *, data);
256 2269 : state->iov.iov_len = size;
257 :
258 2269 : subreq = tstream_writev_queue_send(state, ev,
259 : transp->stream,
260 : transp->write_queue,
261 2269 : &state->iov, 1);
262 2269 : if (subreq == NULL) {
263 0 : goto fail;
264 : }
265 :
266 2269 : endtime = timeval_current_ofs_msec(transp->timeout);
267 2269 : if (!tevent_req_set_endtime(subreq, ev, endtime)) {
268 0 : goto fail;
269 : }
270 :
271 2269 : tevent_req_set_callback(subreq, rpc_tstream_write_done, req);
272 2269 : return req;
273 0 : fail:
274 0 : TALLOC_FREE(req);
275 0 : return NULL;
276 : }
277 :
278 2269 : static void rpc_tstream_write_done(struct tevent_req *subreq)
279 : {
280 1319 : struct tevent_req *req =
281 2269 : tevent_req_callback_data(subreq, struct tevent_req);
282 1319 : struct rpc_tstream_write_state *state =
283 2269 : tevent_req_data(req, struct rpc_tstream_write_state);
284 : int err;
285 :
286 2269 : state->nwritten = tstream_writev_queue_recv(subreq, &err);
287 2269 : TALLOC_FREE(subreq);
288 2269 : if (state->nwritten < 0) {
289 0 : rpc_tstream_disconnect(state->transp);
290 0 : tevent_req_nterror(req, map_nt_error_from_unix(err));
291 0 : return;
292 : }
293 2269 : tevent_req_done(req);
294 : }
295 :
296 2269 : static NTSTATUS rpc_tstream_write_recv(struct tevent_req *req, ssize_t *sent)
297 : {
298 1319 : struct rpc_tstream_write_state *state =
299 2269 : tevent_req_data(req, struct rpc_tstream_write_state);
300 : NTSTATUS status;
301 :
302 2269 : if (tevent_req_is_nterror(req, &status)) {
303 0 : return status;
304 : }
305 2269 : *sent = state->nwritten;
306 2269 : return NT_STATUS_OK;
307 : }
308 :
309 : struct rpc_tstream_trans_state {
310 : struct tevent_context *ev;
311 : struct rpc_tstream_state *transp;
312 : struct iovec req;
313 : uint32_t max_rdata_len;
314 : struct iovec rep;
315 : };
316 :
317 : static void rpc_tstream_trans_writev(struct tevent_req *subreq);
318 : static void rpc_tstream_trans_readv_pdu(struct tevent_req *subreq);
319 :
320 : static int rpc_tstream_trans_next_vector(struct tstream_context *stream,
321 : void *private_data,
322 : TALLOC_CTX *mem_ctx,
323 : struct iovec **_vector,
324 : size_t *count);
325 :
326 4680 : 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,
330 : void *priv)
331 : {
332 2913 : struct rpc_tstream_state *transp =
333 1767 : 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 4680 : bool use_trans = false;
338 :
339 4680 : req = tevent_req_create(mem_ctx, &state,
340 : struct rpc_tstream_trans_state);
341 4680 : if (req == NULL) {
342 0 : return NULL;
343 : }
344 :
345 4680 : if (!rpc_tstream_is_connected(transp)) {
346 0 : NTSTATUS status = NT_STATUS_CONNECTION_DISCONNECTED;
347 0 : if (tstream_is_smbXcli_np(transp->stream)) {
348 0 : status = NT_STATUS_PIPE_DISCONNECTED;
349 : }
350 0 : tevent_req_nterror(req, status);
351 0 : return tevent_req_post(req, ev);
352 : }
353 4680 : state->ev = ev;
354 4680 : state->transp = transp;
355 4680 : state->req.iov_len = data_len;
356 4680 : state->req.iov_base = discard_const_p(void *, data);
357 4680 : state->max_rdata_len = max_rdata_len;
358 :
359 4680 : endtime = timeval_current_ofs_msec(transp->timeout);
360 :
361 4680 : if (tstream_is_smbXcli_np(transp->stream)) {
362 4680 : use_trans = true;
363 : }
364 4680 : if (tevent_queue_length(transp->write_queue) > 0) {
365 0 : use_trans = false;
366 : }
367 4680 : if (tevent_queue_length(transp->read_queue) > 0) {
368 0 : use_trans = false;
369 : }
370 :
371 4680 : if (use_trans) {
372 4680 : tstream_smbXcli_np_use_trans(transp->stream);
373 : }
374 :
375 4680 : subreq = tstream_writev_queue_send(state, ev,
376 : transp->stream,
377 : transp->write_queue,
378 4680 : &state->req, 1);
379 4680 : if (tevent_req_nomem(subreq, req)) {
380 0 : return tevent_req_post(req, ev);
381 : }
382 4680 : if (!tevent_req_set_endtime(subreq, ev, endtime)) {
383 0 : return tevent_req_post(req, ev);
384 : }
385 4680 : tevent_req_set_callback(subreq, rpc_tstream_trans_writev, req);
386 :
387 4680 : subreq = tstream_readv_pdu_queue_send(state, ev,
388 : transp->stream,
389 : transp->read_queue,
390 : rpc_tstream_trans_next_vector,
391 : state);
392 4680 : if (tevent_req_nomem(subreq, req)) {
393 0 : return tevent_req_post(req, ev);
394 : }
395 4680 : if (!tevent_req_set_endtime(subreq, ev, endtime)) {
396 0 : return tevent_req_post(req, ev);
397 : }
398 4680 : tevent_req_set_callback(subreq, rpc_tstream_trans_readv_pdu, req);
399 :
400 4680 : return req;
401 : }
402 :
403 4680 : static void rpc_tstream_trans_writev(struct tevent_req *subreq)
404 : {
405 2913 : struct tevent_req *req =
406 4680 : tevent_req_callback_data(subreq,
407 : struct tevent_req);
408 2913 : struct rpc_tstream_trans_state *state =
409 4680 : tevent_req_data(req,
410 : struct rpc_tstream_trans_state);
411 : int ret;
412 : int err;
413 :
414 4680 : ret = tstream_writev_queue_recv(subreq, &err);
415 4680 : TALLOC_FREE(subreq);
416 4680 : if (ret == -1) {
417 0 : rpc_tstream_disconnect(state->transp);
418 0 : tevent_req_nterror(req, map_nt_error_from_unix(err));
419 0 : return;
420 : }
421 : }
422 :
423 9360 : static int rpc_tstream_trans_next_vector(struct tstream_context *stream,
424 : void *private_data,
425 : TALLOC_CTX *mem_ctx,
426 : struct iovec **_vector,
427 : size_t *count)
428 : {
429 5826 : struct rpc_tstream_trans_state *state =
430 3534 : talloc_get_type_abort(private_data,
431 : struct rpc_tstream_trans_state);
432 : struct iovec *vector;
433 :
434 9360 : if (state->max_rdata_len == state->rep.iov_len) {
435 4680 : *_vector = NULL;
436 4680 : *count = 0;
437 4680 : return 0;
438 : }
439 :
440 4680 : state->rep.iov_base = talloc_array(state, uint8_t,
441 : state->max_rdata_len);
442 4680 : if (state->rep.iov_base == NULL) {
443 0 : return -1;
444 : }
445 4680 : state->rep.iov_len = state->max_rdata_len;
446 :
447 4680 : vector = talloc_array(mem_ctx, struct iovec, 1);
448 4680 : if (!vector) {
449 0 : return -1;
450 : }
451 :
452 4680 : vector[0] = state->rep;
453 :
454 4680 : *_vector = vector;
455 4680 : *count = 1;
456 4680 : return 0;
457 : }
458 :
459 4680 : static void rpc_tstream_trans_readv_pdu(struct tevent_req *subreq)
460 : {
461 2913 : struct tevent_req *req =
462 4680 : tevent_req_callback_data(subreq,
463 : struct tevent_req);
464 2913 : struct rpc_tstream_trans_state *state =
465 4680 : tevent_req_data(req,
466 : struct rpc_tstream_trans_state);
467 : int ret;
468 : int err;
469 :
470 4680 : ret = tstream_readv_pdu_queue_recv(subreq, &err);
471 4680 : TALLOC_FREE(subreq);
472 4680 : if (ret == -1) {
473 0 : rpc_tstream_disconnect(state->transp);
474 0 : tevent_req_nterror(req, map_nt_error_from_unix(err));
475 0 : return;
476 : }
477 :
478 4680 : tevent_req_done(req);
479 : }
480 :
481 4680 : static NTSTATUS rpc_tstream_trans_recv(struct tevent_req *req, TALLOC_CTX *mem_ctx,
482 : uint8_t **prdata, uint32_t *prdata_len)
483 : {
484 2913 : struct rpc_tstream_trans_state *state =
485 4680 : tevent_req_data(req,
486 : struct rpc_tstream_trans_state);
487 : NTSTATUS status;
488 :
489 4680 : if (tevent_req_is_nterror(req, &status)) {
490 0 : return status;
491 : }
492 :
493 4680 : *prdata = (uint8_t *)talloc_move(mem_ctx, &state->rep.iov_base);
494 4680 : *prdata_len = state->rep.iov_len;
495 4680 : return NT_STATUS_OK;
496 : }
497 :
498 : /**
499 : * @brief Initialize a tstream transport facility
500 : * NOTE: this function will talloc_steal, the stream and the queues.
501 : *
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
505 : *
506 : * @return - a NT Status error code.
507 : */
508 854 : NTSTATUS rpc_transport_tstream_init(TALLOC_CTX *mem_ctx,
509 : struct tstream_context **stream,
510 : struct rpc_cli_transport **presult)
511 : {
512 : struct rpc_cli_transport *result;
513 : struct rpc_tstream_state *state;
514 :
515 854 : result = talloc(mem_ctx, struct rpc_cli_transport);
516 854 : if (result == NULL) {
517 0 : return NT_STATUS_NO_MEMORY;
518 : }
519 854 : state = talloc(result, struct rpc_tstream_state);
520 854 : if (state == NULL) {
521 0 : TALLOC_FREE(result);
522 0 : return NT_STATUS_NO_MEMORY;
523 : }
524 854 : result->priv = state;
525 :
526 854 : state->read_queue = tevent_queue_create(state, "read_queue");
527 854 : if (state->read_queue == NULL) {
528 0 : TALLOC_FREE(result);
529 0 : return NT_STATUS_NO_MEMORY;
530 : }
531 854 : state->write_queue = tevent_queue_create(state, "write_queue");
532 854 : if (state->write_queue == NULL) {
533 0 : TALLOC_FREE(result);
534 0 : return NT_STATUS_NO_MEMORY;
535 : }
536 :
537 854 : state->stream = talloc_move(state, stream);
538 854 : state->timeout = 10000; /* 10 seconds. */
539 :
540 854 : if (tstream_is_smbXcli_np(state->stream)) {
541 754 : result->trans_send = rpc_tstream_trans_send;
542 754 : result->trans_recv = rpc_tstream_trans_recv;
543 : } else {
544 100 : result->trans_send = NULL;
545 100 : result->trans_recv = NULL;
546 : }
547 854 : result->write_send = rpc_tstream_write_send;
548 854 : result->write_recv = rpc_tstream_write_recv;
549 854 : result->read_send = rpc_tstream_read_send;
550 854 : result->read_recv = rpc_tstream_read_recv;
551 854 : result->is_connected = rpc_tstream_is_connected;
552 854 : result->set_timeout = rpc_tstream_set_timeout;
553 :
554 854 : *presult = result;
555 854 : return NT_STATUS_OK;
556 : }
|
