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