?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
selftest: also run test base.createx_access against ad_dc
[Samba.git] / libcli / smb / tstream_smbXcli_np.c
bloba59db13321b193fe235aa89f39d3e3d0aa5821c7
1 /*
2 Unix SMB/CIFS implementation.
3
4 Copyright (C) Stefan Metzmacher 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 "system/network.h"
22 #include "../lib/util/tevent_ntstatus.h"
23 #include "../lib/tsocket/tsocket.h"
24 #include "../lib/tsocket/tsocket_internal.h"
25 #include "smb_common.h"
26 #include "smbXcli_base.h"
27 #include "tstream_smbXcli_np.h"
28 #include "libcli/security/security.h"
29
30 static const struct tstream_context_ops tstream_smbXcli_np_ops;
31
32 #define TSTREAM_SMBXCLI_NP_DESIRED_ACCESS ( \
33 SEC_STD_READ_CONTROL | \
34 SEC_FILE_READ_DATA | \
35 SEC_FILE_WRITE_DATA | \
36 SEC_FILE_APPEND_DATA | \
37 SEC_FILE_READ_EA | \
38 SEC_FILE_WRITE_EA | \
39 SEC_FILE_READ_ATTRIBUTE | \
40 SEC_FILE_WRITE_ATTRIBUTE | \
41 0)
42
43 struct tstream_smbXcli_np_ref;
44
45 struct tstream_smbXcli_np {
46 struct smbXcli_conn *conn;
47 struct tstream_smbXcli_np_ref *conn_ref;
48 struct smbXcli_session *session;
49 struct tstream_smbXcli_np_ref *session_ref;
50 struct smbXcli_tcon *tcon;
51 struct tstream_smbXcli_np_ref *tcon_ref;
52 uint16_t pid;
53 unsigned int timeout;
54
55 const char *npipe;
56 bool is_smb1;
57 uint16_t fnum;
58 uint64_t fid_persistent;
59 uint64_t fid_volatile;
60
61 struct {
62 bool active;
63 struct tevent_req *read_req;
64 struct tevent_req *write_req;
65 uint16_t setup[2];
66 } trans;
67
68 struct {
69 off_t ofs;
70 size_t left;
71 uint8_t *buf;
72 } read, write;
73 };
74
75 struct tstream_smbXcli_np_ref {
76 struct tstream_smbXcli_np *cli_nps;
77 };
78
79 static int tstream_smbXcli_np_destructor(struct tstream_smbXcli_np *cli_nps)
80 {
81 NTSTATUS status;
82
83 if (cli_nps->conn_ref != NULL) {
84 cli_nps->conn_ref->cli_nps = NULL;
85 TALLOC_FREE(cli_nps->conn_ref);
86 }
87
88 if (cli_nps->session_ref != NULL) {
89 cli_nps->session_ref->cli_nps = NULL;
90 TALLOC_FREE(cli_nps->session_ref);
91 }
92
93 if (cli_nps->tcon_ref != NULL) {
94 cli_nps->tcon_ref->cli_nps = NULL;
95 TALLOC_FREE(cli_nps->tcon_ref);
96 }
97
98 if (!smbXcli_conn_is_connected(cli_nps->conn)) {
99 return 0;
100 }
101
102 /*
103 * TODO: do not use a sync call with a destructor!!!
104 *
105 * This only happens, if a caller does talloc_free(),
106 * while the everything was still ok.
107 *
108 * If we get an unexpected failure within a normal
109 * operation, we already do an async cli_close_send()/_recv().
110 *
111 * Once we've fixed all callers to call
112 * tstream_disconnect_send()/_recv(), this will
113 * never be called.
114 *
115 * We use a maximun timeout of 1 second == 1000 msec.
116 */
117 cli_nps->timeout = MIN(cli_nps->timeout, 1000);
118
119 if (cli_nps->is_smb1) {
120 status = smb1cli_close(cli_nps->conn,
121 cli_nps->timeout,
122 cli_nps->pid,
123 cli_nps->tcon,
124 cli_nps->session,
125 cli_nps->fnum, UINT32_MAX);
126 } else {
127 status = smb2cli_close(cli_nps->conn,
128 cli_nps->timeout,
129 cli_nps->session,
130 cli_nps->tcon,
131 0, /* flags */
132 cli_nps->fid_persistent,
133 cli_nps->fid_volatile);
134 }
135 if (!NT_STATUS_IS_OK(status)) {
136 DEBUG(1, ("tstream_smbXcli_np_destructor: cli_close "
137 "failed on pipe %s. Error was %s\n",
138 cli_nps->npipe, nt_errstr(status)));
139 }
140 /*
141 * We can't do much on failure
142 */
143 return 0;
144 }
145
146 static int tstream_smbXcli_np_ref_destructor(struct tstream_smbXcli_np_ref *ref)
147 {
148 if (ref->cli_nps == NULL) {
149 return 0;
150 }
151
152 if (ref->cli_nps->conn == NULL) {
153 return 0;
154 }
155
156 ref->cli_nps->conn = NULL;
157 ref->cli_nps->session = NULL;
158 ref->cli_nps->tcon = NULL;
159
160 TALLOC_FREE(ref->cli_nps->conn_ref);
161 TALLOC_FREE(ref->cli_nps->session_ref);
162 TALLOC_FREE(ref->cli_nps->tcon_ref);
163
164 return 0;
165 };
166
167 static struct tevent_req *tstream_smbXcli_np_disconnect_send(TALLOC_CTX *mem_ctx,
168 struct tevent_context *ev,
169 struct tstream_context *stream);
170 static int tstream_smbXcli_np_disconnect_recv(struct tevent_req *req,
171 int *perrno);
172
173 struct tstream_smbXcli_np_open_state {
174 struct smbXcli_conn *conn;
175 struct smbXcli_session *session;
176 struct smbXcli_tcon *tcon;
177 uint16_t pid;
178 unsigned int timeout;
179
180 bool is_smb1;
181 uint16_t fnum;
182 uint64_t fid_persistent;
183 uint64_t fid_volatile;
184 const char *npipe;
185 };
186
187 static void tstream_smbXcli_np_open_done(struct tevent_req *subreq);
188
189 struct tevent_req *tstream_smbXcli_np_open_send(TALLOC_CTX *mem_ctx,
190 struct tevent_context *ev,
191 struct smbXcli_conn *conn,
192 struct smbXcli_session *session,
193 struct smbXcli_tcon *tcon,
194 uint16_t pid,
195 unsigned int timeout,
196 const char *npipe)
197 {
198 struct tevent_req *req;
199 struct tstream_smbXcli_np_open_state *state;
200 struct tevent_req *subreq;
201
202 req = tevent_req_create(mem_ctx, &state,
203 struct tstream_smbXcli_np_open_state);
204 if (!req) {
205 return NULL;
206 }
207 state->conn = conn;
208 state->tcon = tcon;
209 state->session = session;
210 state->pid = pid;
211 state->timeout = timeout;
212
213 state->npipe = talloc_strdup(state, npipe);
214 if (tevent_req_nomem(state->npipe, req)) {
215 return tevent_req_post(req, ev);
216 }
217
218 if (smbXcli_conn_protocol(conn) < PROTOCOL_SMB2_02) {
219 state->is_smb1 = true;
220 }
221
222 if (state->is_smb1) {
223 const char *smb1_npipe;
224
225 /*
226 * Windows and newer Samba versions allow
227 * the pipe name without leading backslash,
228 * but we should better behave like windows clients
229 */
230 smb1_npipe = talloc_asprintf(state, "\\%s", state->npipe);
231 if (tevent_req_nomem(smb1_npipe, req)) {
232 return tevent_req_post(req, ev);
233 }
234 subreq = smb1cli_ntcreatex_send(state, ev, state->conn,
235 state->timeout,
236 state->pid,
237 state->tcon,
238 state->session,
239 smb1_npipe,
240 0, /* CreatFlags */
241 0, /* RootDirectoryFid */
242 TSTREAM_SMBXCLI_NP_DESIRED_ACCESS,
243 0, /* AllocationSize */
244 0, /* FileAttributes */
245 FILE_SHARE_READ|FILE_SHARE_WRITE,
246 FILE_OPEN, /* CreateDisposition */
247 0, /* CreateOptions */
248 2, /* NTCREATEX_IMPERSONATION_IMPERSONATION */
249 0); /* SecurityFlags */
250 } else {
251 subreq = smb2cli_create_send(state, ev, state->conn,
252 state->timeout, state->session,
253 state->tcon,
254 npipe,
255 SMB2_OPLOCK_LEVEL_NONE,
256 SMB2_IMPERSONATION_IMPERSONATION,
257 TSTREAM_SMBXCLI_NP_DESIRED_ACCESS,
258 0, /* file_attributes */
259 FILE_SHARE_READ|FILE_SHARE_WRITE,
260 FILE_OPEN,
261 0, /* create_options */
262 NULL); /* blobs */
263 }
264 if (tevent_req_nomem(subreq, req)) {
265 return tevent_req_post(req, ev);
266 }
267 tevent_req_set_callback(subreq, tstream_smbXcli_np_open_done, req);
268
269 return req;
270 }
271
272 static void tstream_smbXcli_np_open_done(struct tevent_req *subreq)
273 {
274 struct tevent_req *req =
275 tevent_req_callback_data(subreq, struct tevent_req);
276 struct tstream_smbXcli_np_open_state *state =
277 tevent_req_data(req, struct tstream_smbXcli_np_open_state);
278 NTSTATUS status;
279
280 if (state->is_smb1) {
281 status = smb1cli_ntcreatex_recv(subreq, &state->fnum);
282 } else {
283 status = smb2cli_create_recv(subreq,
284 &state->fid_persistent,
285 &state->fid_volatile,
286 NULL, NULL, NULL);
287 }
288 TALLOC_FREE(subreq);
289 if (!NT_STATUS_IS_OK(status)) {
290 tevent_req_nterror(req, status);
291 return;
292 }
293
294 tevent_req_done(req);
295 }
296
297 NTSTATUS _tstream_smbXcli_np_open_recv(struct tevent_req *req,
298 TALLOC_CTX *mem_ctx,
299 struct tstream_context **_stream,
300 const char *location)
301 {
302 struct tstream_smbXcli_np_open_state *state =
303 tevent_req_data(req, struct tstream_smbXcli_np_open_state);
304 struct tstream_context *stream;
305 struct tstream_smbXcli_np *cli_nps;
306 NTSTATUS status;
307
308 if (tevent_req_is_nterror(req, &status)) {
309 tevent_req_received(req);
310 return status;
311 }
312
313 stream = tstream_context_create(mem_ctx,
314 &tstream_smbXcli_np_ops,
315 &cli_nps,
316 struct tstream_smbXcli_np,
317 location);
318 if (!stream) {
319 tevent_req_received(req);
320 return NT_STATUS_NO_MEMORY;
321 }
322 ZERO_STRUCTP(cli_nps);
323
324 cli_nps->conn_ref = talloc_zero(state->conn,
325 struct tstream_smbXcli_np_ref);
326 if (cli_nps->conn_ref == NULL) {
327 TALLOC_FREE(cli_nps);
328 tevent_req_received(req);
329 return NT_STATUS_NO_MEMORY;
330 }
331 cli_nps->conn_ref->cli_nps = cli_nps;
332
333 cli_nps->session_ref = talloc_zero(state->session,
334 struct tstream_smbXcli_np_ref);
335 if (cli_nps->session_ref == NULL) {
336 TALLOC_FREE(cli_nps);
337 tevent_req_received(req);
338 return NT_STATUS_NO_MEMORY;
339 }
340 cli_nps->session_ref->cli_nps = cli_nps;
341
342 cli_nps->tcon_ref = talloc_zero(state->tcon,
343 struct tstream_smbXcli_np_ref);
344 if (cli_nps->tcon_ref == NULL) {
345 TALLOC_FREE(cli_nps);
346 tevent_req_received(req);
347 return NT_STATUS_NO_MEMORY;
348 }
349 cli_nps->tcon_ref->cli_nps = cli_nps;
350
351 cli_nps->conn = state->conn;
352 cli_nps->session = state->session;
353 cli_nps->tcon = state->tcon;
354 cli_nps->pid = state->pid;
355 cli_nps->timeout = state->timeout;
356 cli_nps->npipe = talloc_move(cli_nps, &state->npipe);
357 cli_nps->is_smb1 = state->is_smb1;
358 cli_nps->fnum = state->fnum;
359 cli_nps->fid_persistent = state->fid_persistent;
360 cli_nps->fid_volatile = state->fid_volatile;
361
362 talloc_set_destructor(cli_nps, tstream_smbXcli_np_destructor);
363 talloc_set_destructor(cli_nps->conn_ref,
364 tstream_smbXcli_np_ref_destructor);
365 talloc_set_destructor(cli_nps->session_ref,
366 tstream_smbXcli_np_ref_destructor);
367 talloc_set_destructor(cli_nps->tcon_ref,
368 tstream_smbXcli_np_ref_destructor);
369
370 cli_nps->trans.active = false;
371 cli_nps->trans.read_req = NULL;
372 cli_nps->trans.write_req = NULL;
373 SSVAL(cli_nps->trans.setup+0, 0, TRANSACT_DCERPCCMD);
374 SSVAL(cli_nps->trans.setup+1, 0, cli_nps->fnum);
375
376 *_stream = stream;
377 tevent_req_received(req);
378 return NT_STATUS_OK;
379 }
380
381 static ssize_t tstream_smbXcli_np_pending_bytes(struct tstream_context *stream)
382 {
383 struct tstream_smbXcli_np *cli_nps = tstream_context_data(stream,
384 struct tstream_smbXcli_np);
385
386 if (!smbXcli_conn_is_connected(cli_nps->conn)) {
387 errno = ENOTCONN;
388 return -1;
389 }
390
391 return cli_nps->read.left;
392 }
393
394 bool tstream_is_smbXcli_np(struct tstream_context *stream)
395 {
396 struct tstream_smbXcli_np *cli_nps =
397 talloc_get_type(_tstream_context_data(stream),
398 struct tstream_smbXcli_np);
399
400 if (!cli_nps) {
401 return false;
402 }
403
404 return true;
405 }
406
407 NTSTATUS tstream_smbXcli_np_use_trans(struct tstream_context *stream)
408 {
409 struct tstream_smbXcli_np *cli_nps = tstream_context_data(stream,
410 struct tstream_smbXcli_np);
411
412 if (cli_nps->trans.read_req) {
413 return NT_STATUS_PIPE_BUSY;
414 }
415
416 if (cli_nps->trans.write_req) {
417 return NT_STATUS_PIPE_BUSY;
418 }
419
420 if (cli_nps->trans.active) {
421 return NT_STATUS_PIPE_BUSY;
422 }
423
424 cli_nps->trans.active = true;
425
426 return NT_STATUS_OK;
427 }
428
429 unsigned int tstream_smbXcli_np_set_timeout(struct tstream_context *stream,
430 unsigned int timeout)
431 {
432 struct tstream_smbXcli_np *cli_nps = tstream_context_data(stream,
433 struct tstream_smbXcli_np);
434 unsigned int old_timeout = cli_nps->timeout;
435
436 cli_nps->timeout = timeout;
437 return old_timeout;
438 }
439
440 struct tstream_smbXcli_np_writev_state {
441 struct tstream_context *stream;
442 struct tevent_context *ev;
443
444 struct iovec *vector;
445 size_t count;
446
447 int ret;
448
449 struct {
450 int val;
451 const char *location;
452 } error;
453 };
454
455 static int tstream_smbXcli_np_writev_state_destructor(struct tstream_smbXcli_np_writev_state *state)
456 {
457 struct tstream_smbXcli_np *cli_nps =
458 tstream_context_data(state->stream,
459 struct tstream_smbXcli_np);
460
461 cli_nps->trans.write_req = NULL;
462
463 return 0;
464 }
465
466 static void tstream_smbXcli_np_writev_write_next(struct tevent_req *req);
467
468 static struct tevent_req *tstream_smbXcli_np_writev_send(TALLOC_CTX *mem_ctx,
469 struct tevent_context *ev,
470 struct tstream_context *stream,
471 const struct iovec *vector,
472 size_t count)
473 {
474 struct tevent_req *req;
475 struct tstream_smbXcli_np_writev_state *state;
476 struct tstream_smbXcli_np *cli_nps = tstream_context_data(stream,
477 struct tstream_smbXcli_np);
478
479 req = tevent_req_create(mem_ctx, &state,
480 struct tstream_smbXcli_np_writev_state);
481 if (!req) {
482 return NULL;
483 }
484 state->stream = stream;
485 state->ev = ev;
486 state->ret = 0;
487
488 talloc_set_destructor(state, tstream_smbXcli_np_writev_state_destructor);
489
490 if (!smbXcli_conn_is_connected(cli_nps->conn)) {
491 tevent_req_error(req, ENOTCONN);
492 return tevent_req_post(req, ev);
493 }
494
495 /*
496 * we make a copy of the vector so we can change the structure
497 */
498 state->vector = talloc_array(state, struct iovec, count);
499 if (tevent_req_nomem(state->vector, req)) {
500 return tevent_req_post(req, ev);
501 }
502 memcpy(state->vector, vector, sizeof(struct iovec) * count);
503 state->count = count;
504
505 tstream_smbXcli_np_writev_write_next(req);
506 if (!tevent_req_is_in_progress(req)) {
507 return tevent_req_post(req, ev);
508 }
509
510 return req;
511 }
512
513 static void tstream_smbXcli_np_readv_trans_start(struct tevent_req *req);
514 static void tstream_smbXcli_np_writev_write_done(struct tevent_req *subreq);
515
516 static void tstream_smbXcli_np_writev_write_next(struct tevent_req *req)
517 {
518 struct tstream_smbXcli_np_writev_state *state =
519 tevent_req_data(req,
520 struct tstream_smbXcli_np_writev_state);
521 struct tstream_smbXcli_np *cli_nps =
522 tstream_context_data(state->stream,
523 struct tstream_smbXcli_np);
524 struct tevent_req *subreq;
525 size_t i;
526 size_t left = 0;
527
528 for (i=0; i < state->count; i++) {
529 left += state->vector[i].iov_len;
530 }
531
532 if (left == 0) {
533 TALLOC_FREE(cli_nps->write.buf);
534 tevent_req_done(req);
535 return;
536 }
537
538 cli_nps->write.ofs = 0;
539 cli_nps->write.left = MIN(left, TSTREAM_SMBXCLI_NP_MAX_BUF_SIZE);
540 cli_nps->write.buf = talloc_realloc(cli_nps, cli_nps->write.buf,
541 uint8_t, cli_nps->write.left);
542 if (tevent_req_nomem(cli_nps->write.buf, req)) {
543 return;
544 }
545
546 /*
547 * copy the pending buffer first
548 */
549 while (cli_nps->write.left > 0 && state->count > 0) {
550 uint8_t *base = (uint8_t *)state->vector[0].iov_base;
551 size_t len = MIN(cli_nps->write.left, state->vector[0].iov_len);
552
553 memcpy(cli_nps->write.buf + cli_nps->write.ofs, base, len);
554
555 base += len;
556 state->vector[0].iov_base = base;
557 state->vector[0].iov_len -= len;
558
559 cli_nps->write.ofs += len;
560 cli_nps->write.left -= len;
561
562 if (state->vector[0].iov_len == 0) {
563 state->vector += 1;
564 state->count -= 1;
565 }
566
567 state->ret += len;
568 }
569
570 if (cli_nps->trans.active && state->count == 0) {
571 cli_nps->trans.active = false;
572 cli_nps->trans.write_req = req;
573 return;
574 }
575
576 if (cli_nps->trans.read_req && state->count == 0) {
577 cli_nps->trans.write_req = req;
578 tstream_smbXcli_np_readv_trans_start(cli_nps->trans.read_req);
579 return;
580 }
581
582 if (cli_nps->is_smb1) {
583 subreq = smb1cli_writex_send(state, state->ev,
584 cli_nps->conn,
585 cli_nps->timeout,
586 cli_nps->pid,
587 cli_nps->tcon,
588 cli_nps->session,
589 cli_nps->fnum,
590 8, /* 8 means message mode. */
591 cli_nps->write.buf,
592 0, /* offset */
593 cli_nps->write.ofs); /* size */
594 } else {
595 subreq = smb2cli_write_send(state, state->ev,
596 cli_nps->conn,
597 cli_nps->timeout,
598 cli_nps->session,
599 cli_nps->tcon,
600 cli_nps->write.ofs, /* length */
601 0, /* offset */
602 cli_nps->fid_persistent,
603 cli_nps->fid_volatile,
604 0, /* remaining_bytes */
605 0, /* flags */
606 cli_nps->write.buf);
607 }
608 if (tevent_req_nomem(subreq, req)) {
609 return;
610 }
611 tevent_req_set_callback(subreq,
612 tstream_smbXcli_np_writev_write_done,
613 req);
614 }
615
616 static void tstream_smbXcli_np_writev_disconnect_now(struct tevent_req *req,
617 int error,
618 const char *location);
619
620 static void tstream_smbXcli_np_writev_write_done(struct tevent_req *subreq)
621 {
622 struct tevent_req *req =
623 tevent_req_callback_data(subreq, struct tevent_req);
624 struct tstream_smbXcli_np_writev_state *state =
625 tevent_req_data(req, struct tstream_smbXcli_np_writev_state);
626 struct tstream_smbXcli_np *cli_nps =
627 tstream_context_data(state->stream,
628 struct tstream_smbXcli_np);
629 uint32_t written;
630 NTSTATUS status;
631
632 if (cli_nps->is_smb1) {
633 status = smb1cli_writex_recv(subreq, &written, NULL);
634 } else {
635 status = smb2cli_write_recv(subreq, &written);
636 }
637 TALLOC_FREE(subreq);
638 if (!NT_STATUS_IS_OK(status)) {
639 tstream_smbXcli_np_writev_disconnect_now(req, EPIPE, __location__);
640 return;
641 }
642
643 if (written != cli_nps->write.ofs) {
644 tstream_smbXcli_np_writev_disconnect_now(req, EIO, __location__);
645 return;
646 }
647
648 tstream_smbXcli_np_writev_write_next(req);
649 }
650
651 static void tstream_smbXcli_np_writev_disconnect_done(struct tevent_req *subreq);
652
653 static void tstream_smbXcli_np_writev_disconnect_now(struct tevent_req *req,
654 int error,
655 const char *location)
656 {
657 struct tstream_smbXcli_np_writev_state *state =
658 tevent_req_data(req,
659 struct tstream_smbXcli_np_writev_state);
660 struct tstream_smbXcli_np *cli_nps =
661 tstream_context_data(state->stream,
662 struct tstream_smbXcli_np);
663 struct tevent_req *subreq;
664
665 state->error.val = error;
666 state->error.location = location;
667
668 if (!smbXcli_conn_is_connected(cli_nps->conn)) {
669 /* return the original error */
670 _tevent_req_error(req, state->error.val, state->error.location);
671 return;
672 }
673
674 subreq = tstream_smbXcli_np_disconnect_send(state, state->ev,
675 state->stream);
676 if (subreq == NULL) {
677 /* return the original error */
678 _tevent_req_error(req, state->error.val, state->error.location);
679 return;
680 }
681 tevent_req_set_callback(subreq,
682 tstream_smbXcli_np_writev_disconnect_done,
683 req);
684 }
685
686 static void tstream_smbXcli_np_writev_disconnect_done(struct tevent_req *subreq)
687 {
688 struct tevent_req *req =
689 tevent_req_callback_data(subreq, struct tevent_req);
690 struct tstream_smbXcli_np_writev_state *state =
691 tevent_req_data(req, struct tstream_smbXcli_np_writev_state);
692 int error;
693
694 tstream_smbXcli_np_disconnect_recv(subreq, &error);
695 TALLOC_FREE(subreq);
696
697 /* return the original error */
698 _tevent_req_error(req, state->error.val, state->error.location);
699 }
700
701 static int tstream_smbXcli_np_writev_recv(struct tevent_req *req,
702 int *perrno)
703 {
704 struct tstream_smbXcli_np_writev_state *state =
705 tevent_req_data(req,
706 struct tstream_smbXcli_np_writev_state);
707 int ret;
708
709 ret = tsocket_simple_int_recv(req, perrno);
710 if (ret == 0) {
711 ret = state->ret;
712 }
713
714 tevent_req_received(req);
715 return ret;
716 }
717
718 struct tstream_smbXcli_np_readv_state {
719 struct tstream_context *stream;
720 struct tevent_context *ev;
721
722 struct iovec *vector;
723 size_t count;
724
725 int ret;
726
727 struct {
728 struct tevent_immediate *im;
729 } trans;
730
731 struct {
732 int val;
733 const char *location;
734 } error;
735 };
736
737 static int tstream_smbXcli_np_readv_state_destructor(struct tstream_smbXcli_np_readv_state *state)
738 {
739 struct tstream_smbXcli_np *cli_nps =
740 tstream_context_data(state->stream,
741 struct tstream_smbXcli_np);
742
743 cli_nps->trans.read_req = NULL;
744
745 return 0;
746 }
747
748 static void tstream_smbXcli_np_readv_read_next(struct tevent_req *req);
749
750 static struct tevent_req *tstream_smbXcli_np_readv_send(TALLOC_CTX *mem_ctx,
751 struct tevent_context *ev,
752 struct tstream_context *stream,
753 struct iovec *vector,
754 size_t count)
755 {
756 struct tevent_req *req;
757 struct tstream_smbXcli_np_readv_state *state;
758 struct tstream_smbXcli_np *cli_nps =
759 tstream_context_data(stream, struct tstream_smbXcli_np);
760
761 req = tevent_req_create(mem_ctx, &state,
762 struct tstream_smbXcli_np_readv_state);
763 if (!req) {
764 return NULL;
765 }
766 state->stream = stream;
767 state->ev = ev;
768 state->ret = 0;
769
770 talloc_set_destructor(state, tstream_smbXcli_np_readv_state_destructor);
771
772 if (!smbXcli_conn_is_connected(cli_nps->conn)) {
773 tevent_req_error(req, ENOTCONN);
774 return tevent_req_post(req, ev);
775 }
776
777 /*
778 * we make a copy of the vector so we can change the structure
779 */
780 state->vector = talloc_array(state, struct iovec, count);
781 if (tevent_req_nomem(state->vector, req)) {
782 return tevent_req_post(req, ev);
783 }
784 memcpy(state->vector, vector, sizeof(struct iovec) * count);
785 state->count = count;
786
787 tstream_smbXcli_np_readv_read_next(req);
788 if (!tevent_req_is_in_progress(req)) {
789 return tevent_req_post(req, ev);
790 }
791
792 return req;
793 }
794
795 static void tstream_smbXcli_np_readv_read_done(struct tevent_req *subreq);
796
797 static void tstream_smbXcli_np_readv_read_next(struct tevent_req *req)
798 {
799 struct tstream_smbXcli_np_readv_state *state =
800 tevent_req_data(req,
801 struct tstream_smbXcli_np_readv_state);
802 struct tstream_smbXcli_np *cli_nps =
803 tstream_context_data(state->stream,
804 struct tstream_smbXcli_np);
805 struct tevent_req *subreq;
806
807 /*
808 * copy the pending buffer first
809 */
810 while (cli_nps->read.left > 0 && state->count > 0) {
811 uint8_t *base = (uint8_t *)state->vector[0].iov_base;
812 size_t len = MIN(cli_nps->read.left, state->vector[0].iov_len);
813
814 memcpy(base, cli_nps->read.buf + cli_nps->read.ofs, len);
815
816 base += len;
817 state->vector[0].iov_base = base;
818 state->vector[0].iov_len -= len;
819
820 cli_nps->read.ofs += len;
821 cli_nps->read.left -= len;
822
823 if (state->vector[0].iov_len == 0) {
824 state->vector += 1;
825 state->count -= 1;
826 }
827
828 state->ret += len;
829 }
830
831 if (cli_nps->read.left == 0) {
832 TALLOC_FREE(cli_nps->read.buf);
833 }
834
835 if (state->count == 0) {
836 tevent_req_done(req);
837 return;
838 }
839
840 if (cli_nps->trans.active) {
841 cli_nps->trans.active = false;
842 cli_nps->trans.read_req = req;
843 return;
844 }
845
846 if (cli_nps->trans.write_req) {
847 cli_nps->trans.read_req = req;
848 tstream_smbXcli_np_readv_trans_start(req);
849 return;
850 }
851
852 if (cli_nps->is_smb1) {
853 subreq = smb1cli_readx_send(state, state->ev,
854 cli_nps->conn,
855 cli_nps->timeout,
856 cli_nps->pid,
857 cli_nps->tcon,
858 cli_nps->session,
859 cli_nps->fnum,
860 0, /* offset */
861 TSTREAM_SMBXCLI_NP_MAX_BUF_SIZE);
862 } else {
863 subreq = smb2cli_read_send(state, state->ev,
864 cli_nps->conn,
865 cli_nps->timeout,
866 cli_nps->session,
867 cli_nps->tcon,
868 TSTREAM_SMBXCLI_NP_MAX_BUF_SIZE, /* length */
869 0, /* offset */
870 cli_nps->fid_persistent,
871 cli_nps->fid_volatile,
872 0, /* minimum_count */
873 0); /* remaining_bytes */
874 }
875 if (tevent_req_nomem(subreq, req)) {
876 return;
877 }
878 tevent_req_set_callback(subreq,
879 tstream_smbXcli_np_readv_read_done,
880 req);
881 }
882
883 static void tstream_smbXcli_np_readv_trans_done(struct tevent_req *subreq);
884
885 static void tstream_smbXcli_np_readv_trans_start(struct tevent_req *req)
886 {
887 struct tstream_smbXcli_np_readv_state *state =
888 tevent_req_data(req,
889 struct tstream_smbXcli_np_readv_state);
890 struct tstream_smbXcli_np *cli_nps =
891 tstream_context_data(state->stream,
892 struct tstream_smbXcli_np);
893 struct tevent_req *subreq;
894
895 state->trans.im = tevent_create_immediate(state);
896 if (tevent_req_nomem(state->trans.im, req)) {
897 return;
898 }
899
900 if (cli_nps->is_smb1) {
901 subreq = smb1cli_trans_send(state, state->ev,
902 cli_nps->conn, SMBtrans,
903 0, 0, /* *_flags */
904 0, 0, /* *_flags2 */
905 cli_nps->timeout,
906 cli_nps->pid,
907 cli_nps->tcon,
908 cli_nps->session,
909 "\\PIPE\\",
910 0, 0, 0,
911 cli_nps->trans.setup, 2,
912 0,
913 NULL, 0, 0,
914 cli_nps->write.buf,
915 cli_nps->write.ofs,
916 TSTREAM_SMBXCLI_NP_MAX_BUF_SIZE);
917 } else {
918 DATA_BLOB in_input_buffer = data_blob_null;
919 DATA_BLOB in_output_buffer = data_blob_null;
920
921 in_input_buffer = data_blob_const(cli_nps->write.buf,
922 cli_nps->write.ofs);
923
924 subreq = smb2cli_ioctl_send(state, state->ev,
925 cli_nps->conn,
926 cli_nps->timeout,
927 cli_nps->session,
928 cli_nps->tcon,
929 cli_nps->fid_persistent,
930 cli_nps->fid_volatile,
931 FSCTL_NAMED_PIPE_READ_WRITE,
932 0, /* in_max_input_length */
933 &in_input_buffer,
934 /* in_max_output_length */
935 TSTREAM_SMBXCLI_NP_MAX_BUF_SIZE,
936 &in_output_buffer,
937 SMB2_IOCTL_FLAG_IS_FSCTL);
938 }
939 if (tevent_req_nomem(subreq, req)) {
940 return;
941 }
942 tevent_req_set_callback(subreq,
943 tstream_smbXcli_np_readv_trans_done,
944 req);
945 }
946
947 static void tstream_smbXcli_np_readv_disconnect_now(struct tevent_req *req,
948 int error,
949 const char *location);
950 static void tstream_smbXcli_np_readv_trans_next(struct tevent_context *ctx,
951 struct tevent_immediate *im,
952 void *private_data);
953
954 static void tstream_smbXcli_np_readv_trans_done(struct tevent_req *subreq)
955 {
956 struct tevent_req *req =
957 tevent_req_callback_data(subreq, struct tevent_req);
958 struct tstream_smbXcli_np_readv_state *state =
959 tevent_req_data(req, struct tstream_smbXcli_np_readv_state);
960 struct tstream_smbXcli_np *cli_nps =
961 tstream_context_data(state->stream, struct tstream_smbXcli_np);
962 uint8_t *rcvbuf;
963 uint32_t received;
964 NTSTATUS status;
965
966 if (cli_nps->is_smb1) {
967 status = smb1cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
968 NULL, 0, NULL,
969 &rcvbuf, 0, &received);
970 } else {
971 DATA_BLOB out_input_buffer = data_blob_null;
972 DATA_BLOB out_output_buffer = data_blob_null;
973
974 status = smb2cli_ioctl_recv(subreq, state,
975 &out_input_buffer,
976 &out_output_buffer);
977
978 /* Note that rcvbuf is not a talloc pointer here */
979 rcvbuf = out_output_buffer.data;
980 received = out_output_buffer.length;
981 }
982 TALLOC_FREE(subreq);
983 if (NT_STATUS_EQUAL(status, STATUS_BUFFER_OVERFLOW)) {
984 /*
985 * STATUS_BUFFER_OVERFLOW means that there's
986 * more data to read when the named pipe is used
987 * in message mode (which is the case here).
988 *
989 * But we hide this from the caller.
990 */
991 status = NT_STATUS_OK;
992 }
993 if (!NT_STATUS_IS_OK(status)) {
994 tstream_smbXcli_np_readv_disconnect_now(req, EPIPE, __location__);
995 return;
996 }
997
998 if (received > TSTREAM_SMBXCLI_NP_MAX_BUF_SIZE) {
999 tstream_smbXcli_np_readv_disconnect_now(req, EIO, __location__);
1000 return;
1001 }
1002
1003 if (received == 0) {
1004 tstream_smbXcli_np_readv_disconnect_now(req, EPIPE, __location__);
1005 return;
1006 }
1007
1008 cli_nps->read.ofs = 0;
1009 cli_nps->read.left = received;
1010 cli_nps->read.buf = talloc_array(cli_nps, uint8_t, received);
1011 if (cli_nps->read.buf == NULL) {
1012 TALLOC_FREE(subreq);
1013 tevent_req_nomem(cli_nps->read.buf, req);
1014 return;
1015 }
1016 memcpy(cli_nps->read.buf, rcvbuf, received);
1017
1018 if (cli_nps->trans.write_req == NULL) {
1019 tstream_smbXcli_np_readv_read_next(req);
1020 return;
1021 }
1022
1023 tevent_schedule_immediate(state->trans.im, state->ev,
1024 tstream_smbXcli_np_readv_trans_next, req);
1025
1026 tevent_req_done(cli_nps->trans.write_req);
1027 }
1028
1029 static void tstream_smbXcli_np_readv_trans_next(struct tevent_context *ctx,
1030 struct tevent_immediate *im,
1031 void *private_data)
1032 {
1033 struct tevent_req *req =
1034 talloc_get_type_abort(private_data,
1035 struct tevent_req);
1036
1037 tstream_smbXcli_np_readv_read_next(req);
1038 }
1039
1040 static void tstream_smbXcli_np_readv_read_done(struct tevent_req *subreq)
1041 {
1042 struct tevent_req *req =
1043 tevent_req_callback_data(subreq, struct tevent_req);
1044 struct tstream_smbXcli_np_readv_state *state =
1045 tevent_req_data(req, struct tstream_smbXcli_np_readv_state);
1046 struct tstream_smbXcli_np *cli_nps =
1047 tstream_context_data(state->stream, struct tstream_smbXcli_np);
1048 uint8_t *rcvbuf;
1049 uint32_t received;
1050 NTSTATUS status;
1051
1052 /*
1053 * We must free subreq in this function as there is
1054 * a timer event attached to it.
1055 */
1056
1057 if (cli_nps->is_smb1) {
1058 status = smb1cli_readx_recv(subreq, &received, &rcvbuf);
1059 } else {
1060 status = smb2cli_read_recv(subreq, state, &rcvbuf, &received);
1061 }
1062 /*
1063 * We can't TALLOC_FREE(subreq) as usual here, as rcvbuf still is a
1064 * child of that.
1065 */
1066 if (NT_STATUS_EQUAL(status, STATUS_BUFFER_OVERFLOW)) {
1067 /*
1068 * STATUS_BUFFER_OVERFLOW means that there's
1069 * more data to read when the named pipe is used
1070 * in message mode (which is the case here).
1071 *
1072 * But we hide this from the caller.
1073 */
1074 status = NT_STATUS_OK;
1075 }
1076 if (!NT_STATUS_IS_OK(status)) {
1077 TALLOC_FREE(subreq);
1078 tstream_smbXcli_np_readv_disconnect_now(req, EPIPE, __location__);
1079 return;
1080 }
1081
1082 if (received > TSTREAM_SMBXCLI_NP_MAX_BUF_SIZE) {
1083 TALLOC_FREE(subreq);
1084 tstream_smbXcli_np_readv_disconnect_now(req, EIO, __location__);
1085 return;
1086 }
1087
1088 if (received == 0) {
1089 TALLOC_FREE(subreq);
1090 tstream_smbXcli_np_readv_disconnect_now(req, EPIPE, __location__);
1091 return;
1092 }
1093
1094 cli_nps->read.ofs = 0;
1095 cli_nps->read.left = received;
1096 cli_nps->read.buf = talloc_array(cli_nps, uint8_t, received);
1097 if (cli_nps->read.buf == NULL) {
1098 TALLOC_FREE(subreq);
1099 tevent_req_nomem(cli_nps->read.buf, req);
1100 return;
1101 }
1102 memcpy(cli_nps->read.buf, rcvbuf, received);
1103 TALLOC_FREE(subreq);
1104
1105 tstream_smbXcli_np_readv_read_next(req);
1106 }
1107
1108 static void tstream_smbXcli_np_readv_disconnect_done(struct tevent_req *subreq);
1109
1110 static void tstream_smbXcli_np_readv_error(struct tevent_req *req);
1111
1112 static void tstream_smbXcli_np_readv_disconnect_now(struct tevent_req *req,
1113 int error,
1114 const char *location)
1115 {
1116 struct tstream_smbXcli_np_readv_state *state =
1117 tevent_req_data(req,
1118 struct tstream_smbXcli_np_readv_state);
1119 struct tstream_smbXcli_np *cli_nps =
1120 tstream_context_data(state->stream,
1121 struct tstream_smbXcli_np);
1122 struct tevent_req *subreq;
1123
1124 state->error.val = error;
1125 state->error.location = location;
1126
1127 if (!smbXcli_conn_is_connected(cli_nps->conn)) {
1128 /* return the original error */
1129 tstream_smbXcli_np_readv_error(req);
1130 return;
1131 }
1132
1133 subreq = tstream_smbXcli_np_disconnect_send(state, state->ev,
1134 state->stream);
1135 if (subreq == NULL) {
1136 /* return the original error */
1137 tstream_smbXcli_np_readv_error(req);
1138 return;
1139 }
1140 tevent_req_set_callback(subreq,
1141 tstream_smbXcli_np_readv_disconnect_done,
1142 req);
1143 }
1144
1145 static void tstream_smbXcli_np_readv_disconnect_done(struct tevent_req *subreq)
1146 {
1147 struct tevent_req *req =
1148 tevent_req_callback_data(subreq, struct tevent_req);
1149 int error;
1150
1151 tstream_smbXcli_np_disconnect_recv(subreq, &error);
1152 TALLOC_FREE(subreq);
1153
1154 tstream_smbXcli_np_readv_error(req);
1155 }
1156
1157 static void tstream_smbXcli_np_readv_error_trigger(struct tevent_context *ctx,
1158 struct tevent_immediate *im,
1159 void *private_data);
1160
1161 static void tstream_smbXcli_np_readv_error(struct tevent_req *req)
1162 {
1163 struct tstream_smbXcli_np_readv_state *state =
1164 tevent_req_data(req,
1165 struct tstream_smbXcli_np_readv_state);
1166 struct tstream_smbXcli_np *cli_nps =
1167 tstream_context_data(state->stream,
1168 struct tstream_smbXcli_np);
1169
1170 if (cli_nps->trans.write_req == NULL) {
1171 /* return the original error */
1172 _tevent_req_error(req, state->error.val, state->error.location);
1173 return;
1174 }
1175
1176 if (state->trans.im == NULL) {
1177 /* return the original error */
1178 _tevent_req_error(req, state->error.val, state->error.location);
1179 return;
1180 }
1181
1182 tevent_schedule_immediate(state->trans.im, state->ev,
1183 tstream_smbXcli_np_readv_error_trigger, req);
1184
1185 /* return the original error for writev */
1186 _tevent_req_error(cli_nps->trans.write_req,
1187 state->error.val, state->error.location);
1188 }
1189
1190 static void tstream_smbXcli_np_readv_error_trigger(struct tevent_context *ctx,
1191 struct tevent_immediate *im,
1192 void *private_data)
1193 {
1194 struct tevent_req *req =
1195 talloc_get_type_abort(private_data,
1196 struct tevent_req);
1197 struct tstream_smbXcli_np_readv_state *state =
1198 tevent_req_data(req,
1199 struct tstream_smbXcli_np_readv_state);
1200
1201 /* return the original error */
1202 _tevent_req_error(req, state->error.val, state->error.location);
1203 }
1204
1205 static int tstream_smbXcli_np_readv_recv(struct tevent_req *req,
1206 int *perrno)
1207 {
1208 struct tstream_smbXcli_np_readv_state *state =
1209 tevent_req_data(req, struct tstream_smbXcli_np_readv_state);
1210 int ret;
1211
1212 ret = tsocket_simple_int_recv(req, perrno);
1213 if (ret == 0) {
1214 ret = state->ret;
1215 }
1216
1217 tevent_req_received(req);
1218 return ret;
1219 }
1220
1221 struct tstream_smbXcli_np_disconnect_state {
1222 struct tstream_context *stream;
1223 struct tevent_req *subreq;
1224 };
1225
1226 static void tstream_smbXcli_np_disconnect_done(struct tevent_req *subreq);
1227 static void tstream_smbXcli_np_disconnect_cleanup(struct tevent_req *req,
1228 enum tevent_req_state req_state);
1229
1230 static struct tevent_req *tstream_smbXcli_np_disconnect_send(TALLOC_CTX *mem_ctx,
1231 struct tevent_context *ev,
1232 struct tstream_context *stream)
1233 {
1234 struct tstream_smbXcli_np *cli_nps = tstream_context_data(stream,
1235 struct tstream_smbXcli_np);
1236 struct tevent_req *req;
1237 struct tstream_smbXcli_np_disconnect_state *state;
1238 struct tevent_req *subreq;
1239
1240 req = tevent_req_create(mem_ctx, &state,
1241 struct tstream_smbXcli_np_disconnect_state);
1242 if (req == NULL) {
1243 return NULL;
1244 }
1245
1246 state->stream = stream;
1247
1248 if (!smbXcli_conn_is_connected(cli_nps->conn)) {
1249 tevent_req_error(req, ENOTCONN);
1250 return tevent_req_post(req, ev);
1251 }
1252
1253 if (cli_nps->is_smb1) {
1254 subreq = smb1cli_close_send(state, ev, cli_nps->conn,
1255 cli_nps->timeout,
1256 cli_nps->pid,
1257 cli_nps->tcon,
1258 cli_nps->session,
1259 cli_nps->fnum, UINT32_MAX);
1260 } else {
1261 subreq = smb2cli_close_send(state, ev, cli_nps->conn,
1262 cli_nps->timeout,
1263 cli_nps->session,
1264 cli_nps->tcon,
1265 0, /* flags */
1266 cli_nps->fid_persistent,
1267 cli_nps->fid_volatile);
1268 }
1269 if (tevent_req_nomem(subreq, req)) {
1270 return tevent_req_post(req, ev);
1271 }
1272 tevent_req_set_callback(subreq, tstream_smbXcli_np_disconnect_done, req);
1273 state->subreq = subreq;
1274
1275 tevent_req_set_cleanup_fn(req, tstream_smbXcli_np_disconnect_cleanup);
1276
1277 /*
1278 * Make sure we don't send any requests anymore.
1279 */
1280 cli_nps->conn = NULL;
1281
1282 return req;
1283 }
1284
1285 static void tstream_smbXcli_np_disconnect_done(struct tevent_req *subreq)
1286 {
1287 struct tevent_req *req = tevent_req_callback_data(subreq,
1288 struct tevent_req);
1289 struct tstream_smbXcli_np_disconnect_state *state =
1290 tevent_req_data(req, struct tstream_smbXcli_np_disconnect_state);
1291 struct tstream_smbXcli_np *cli_nps =
1292 tstream_context_data(state->stream, struct tstream_smbXcli_np);
1293 NTSTATUS status;
1294
1295 state->subreq = NULL;
1296
1297 if (cli_nps->is_smb1) {
1298 status = smb1cli_close_recv(subreq);
1299 } else {
1300 status = smb2cli_close_recv(subreq);
1301 }
1302 TALLOC_FREE(subreq);
1303 if (!NT_STATUS_IS_OK(status)) {
1304 tevent_req_error(req, EPIPE);
1305 return;
1306 }
1307
1308 cli_nps->conn = NULL;
1309 cli_nps->session = NULL;
1310 cli_nps->tcon = NULL;
1311
1312 tevent_req_done(req);
1313 }
1314
1315 static void tstream_smbXcli_np_disconnect_free(struct tevent_req *subreq);
1316
1317 static void tstream_smbXcli_np_disconnect_cleanup(struct tevent_req *req,
1318 enum tevent_req_state req_state)
1319 {
1320 struct tstream_smbXcli_np_disconnect_state *state =
1321 tevent_req_data(req, struct tstream_smbXcli_np_disconnect_state);
1322 struct tstream_smbXcli_np *cli_nps = NULL;
1323
1324 if (state->subreq == NULL) {
1325 return;
1326 }
1327
1328 cli_nps = tstream_context_data(state->stream, struct tstream_smbXcli_np);
1329
1330 if (cli_nps->tcon == NULL) {
1331 return;
1332 }
1333
1334 /*
1335 * We're no longer interested in the result
1336 * any more, but need to make sure that the close
1337 * request arrives at the server if the smb connection,
1338 * session and tcon are still alive.
1339 *
1340 * We move the low level request to the tcon,
1341 * which means that it stays as long as the tcon
1342 * is available.
1343 */
1344 talloc_steal(cli_nps->tcon, state->subreq);
1345 tevent_req_set_callback(state->subreq,
1346 tstream_smbXcli_np_disconnect_free,
1347 NULL);
1348 state->subreq = NULL;
1349
1350 cli_nps->conn = NULL;
1351 cli_nps->session = NULL;
1352 cli_nps->tcon = NULL;
1353 }
1354
1355 static void tstream_smbXcli_np_disconnect_free(struct tevent_req *subreq)
1356 {
1357 TALLOC_FREE(subreq);
1358 }
1359
1360 static int tstream_smbXcli_np_disconnect_recv(struct tevent_req *req,
1361 int *perrno)
1362 {
1363 int ret;
1364
1365 ret = tsocket_simple_int_recv(req, perrno);
1366
1367 tevent_req_received(req);
1368 return ret;
1369 }
1370
1371 static const struct tstream_context_ops tstream_smbXcli_np_ops = {
1372 .name = "smbXcli_np",
1373
1374 .pending_bytes = tstream_smbXcli_np_pending_bytes,
1375
1376 .readv_send = tstream_smbXcli_np_readv_send,
1377 .readv_recv = tstream_smbXcli_np_readv_recv,
1378
1379 .writev_send = tstream_smbXcli_np_writev_send,
1380 .writev_recv = tstream_smbXcli_np_writev_recv,
1381
1382 .disconnect_send = tstream_smbXcli_np_disconnect_send,
1383 .disconnect_recv = tstream_smbXcli_np_disconnect_recv,
1384 };
Samba GIT mirror