source3/libsmb/cli_np_tstream.c

   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 "libsmb/libsmb.h"
  23 #include "../lib/util/tevent_ntstatus.h"
  24 #include "../lib/tsocket/tsocket.h"
  25 #include "../lib/tsocket/tsocket_internal.h"
  26 #include "cli_np_tstream.h"
  27
  28 static const struct tstream_context_ops tstream_cli_np_ops;
  29
  30 /*
  31  * Windows uses 4280 (the max xmit/recv size negotiated on DCERPC).
  32  * This is fits into the max_xmit negotiated at the SMB layer.
  33  *
  34  * On the sending side they may use SMBtranss if the request does not
  35  * fit into a single SMBtrans call.
  36  *
  37  * Windows uses 1024 as max data size of a SMBtrans request and then
  38  * possibly reads the rest of the DCERPC fragment (up to 3256 bytes)
  39  * via a SMBreadX.
  40  *
  41  * For now we just ask for the full 4280 bytes (max data size) in the SMBtrans
  42  * request to get the whole fragment at once (like samba 3.5.x and below did.
  43  *
  44  * It is important that we use do SMBwriteX with the size of a full fragment,
  45  * otherwise we may get NT_STATUS_PIPE_BUSY on the SMBtrans request
  46  * from NT4 servers. (See bug #8195)
  47  */
  48 #define TSTREAM_CLI_NP_MAX_BUF_SIZE 4280
  49
  50 struct tstream_cli_np {
  51         struct cli_state *cli;
  52         const char *npipe;
  53         uint16_t fnum;
  54         unsigned int default_timeout;
  55
  56         struct {
  57                 bool active;
  58                 struct tevent_req *read_req;
  59                 struct tevent_req *write_req;
  60                 uint16_t setup[2];
  61         } trans;
  62
  63         struct {
  64                 off_t ofs;
  65                 size_t left;
  66                 uint8_t *buf;
  67         } read, write;
  68 };
  69
  70 static int tstream_cli_np_destructor(struct tstream_cli_np *cli_nps)
  71 {
  72         NTSTATUS status;
  73
  74         if (!cli_state_is_connected(cli_nps->cli)) {
  75                 return 0;
  76         }
  77
  78         /*
  79          * TODO: do not use a sync call with a destructor!!!
  80          *
  81          * This only happens, if a caller does talloc_free(),
  82          * while the everything was still ok.
  83          *
  84          * If we get an unexpected failure within a normal
  85          * operation, we already do an async cli_close_send()/_recv().
  86          *
  87          * Once we've fixed all callers to call
  88          * tstream_disconnect_send()/_recv(), this will
  89          * never be called.
  90          */
  91         status = cli_close(cli_nps->cli, cli_nps->fnum);
  92         if (!NT_STATUS_IS_OK(status)) {
  93                 DEBUG(1, ("tstream_cli_np_destructor: cli_close "
  94                           "failed on pipe %s. Error was %s\n",
  95                           cli_nps->npipe, nt_errstr(status)));
  96         }
  97         /*
  98          * We can't do much on failure
  99          */
 100         return 0;
 101 }
 102
 103 struct tstream_cli_np_open_state {
 104         struct cli_state *cli;
 105         uint16_t fnum;
 106         const char *npipe;
 107 };
 108
 109 static void tstream_cli_np_open_done(struct tevent_req *subreq);
 110
 111 struct tevent_req *tstream_cli_np_open_send(TALLOC_CTX *mem_ctx,
 112                                             struct tevent_context *ev,
 113                                             struct cli_state *cli,
 114                                             const char *npipe)
 115 {
 116         struct tevent_req *req;
 117         struct tstream_cli_np_open_state *state;
 118         struct tevent_req *subreq;
 119
 120         req = tevent_req_create(mem_ctx, &state,
 121                                 struct tstream_cli_np_open_state);
 122         if (!req) {
 123                 return NULL;
 124         }
 125         state->cli = cli;
 126
 127         state->npipe = talloc_strdup(state, npipe);
 128         if (tevent_req_nomem(state->npipe, req)) {
 129                 return tevent_req_post(req, ev);
 130         }
 131
 132         subreq = cli_ntcreate_send(state, ev, cli,
 133                                    npipe,
 134                                    0,
 135                                    DESIRED_ACCESS_PIPE,
 136                                    0,
 137                                    FILE_SHARE_READ|FILE_SHARE_WRITE,
 138                                    FILE_OPEN,
 139                                    0,
 140                                    0);
 141         if (tevent_req_nomem(subreq, req)) {
 142                 return tevent_req_post(req, ev);
 143         }
 144         tevent_req_set_callback(subreq, tstream_cli_np_open_done, req);
 145
 146         return req;
 147 }
 148
 149 static void tstream_cli_np_open_done(struct tevent_req *subreq)
 150 {
 151         struct tevent_req *req =
 152                 tevent_req_callback_data(subreq, struct tevent_req);
 153         struct tstream_cli_np_open_state *state =
 154                 tevent_req_data(req, struct tstream_cli_np_open_state);
 155         NTSTATUS status;
 156
 157         status = cli_ntcreate_recv(subreq, &state->fnum);
 158         TALLOC_FREE(subreq);
 159         if (!NT_STATUS_IS_OK(status)) {
 160                 tevent_req_nterror(req, status);
 161                 return;
 162         }
 163
 164         tevent_req_done(req);
 165 }
 166
 167 NTSTATUS _tstream_cli_np_open_recv(struct tevent_req *req,
 168                                    TALLOC_CTX *mem_ctx,
 169                                    struct tstream_context **_stream,
 170                                    const char *location)
 171 {
 172         struct tstream_cli_np_open_state *state =
 173                 tevent_req_data(req, struct tstream_cli_np_open_state);
 174         struct tstream_context *stream;
 175         struct tstream_cli_np *cli_nps;
 176         NTSTATUS status;
 177
 178         if (tevent_req_is_nterror(req, &status)) {
 179                 tevent_req_received(req);
 180                 return status;
 181         }
 182
 183         stream = tstream_context_create(mem_ctx,
 184                                         &tstream_cli_np_ops,
 185                                         &cli_nps,
 186                                         struct tstream_cli_np,
 187                                         location);
 188         if (!stream) {
 189                 tevent_req_received(req);
 190                 return NT_STATUS_NO_MEMORY;
 191         }
 192         ZERO_STRUCTP(cli_nps);
 193
 194         cli_nps->cli = state->cli;
 195         cli_nps->npipe = talloc_move(cli_nps, &state->npipe);
 196         cli_nps->fnum = state->fnum;
 197         cli_nps->default_timeout = state->cli->timeout;
 198
 199         talloc_set_destructor(cli_nps, tstream_cli_np_destructor);
 200
 201         cli_nps->trans.active = false;
 202         cli_nps->trans.read_req = NULL;
 203         cli_nps->trans.write_req = NULL;
 204         SSVAL(cli_nps->trans.setup+0, 0, TRANSACT_DCERPCCMD);
 205         SSVAL(cli_nps->trans.setup+1, 0, cli_nps->fnum);
 206
 207         *_stream = stream;
 208         tevent_req_received(req);
 209         return NT_STATUS_OK;
 210 }
 211
 212 static ssize_t tstream_cli_np_pending_bytes(struct tstream_context *stream)
 213 {
 214         struct tstream_cli_np *cli_nps = tstream_context_data(stream,
 215                                          struct tstream_cli_np);
 216
 217         if (!cli_state_is_connected(cli_nps->cli)) {
 218                 errno = ENOTCONN;
 219                 return -1;
 220         }
 221
 222         return cli_nps->read.left;
 223 }
 224
 225 bool tstream_is_cli_np(struct tstream_context *stream)
 226 {
 227         struct tstream_cli_np *cli_nps =
 228                 talloc_get_type(_tstream_context_data(stream),
 229                 struct tstream_cli_np);
 230
 231         if (!cli_nps) {
 232                 return false;
 233         }
 234
 235         return true;
 236 }
 237
 238 NTSTATUS tstream_cli_np_use_trans(struct tstream_context *stream)
 239 {
 240         struct tstream_cli_np *cli_nps = tstream_context_data(stream,
 241                                          struct tstream_cli_np);
 242
 243         if (cli_nps->trans.read_req) {
 244                 return NT_STATUS_PIPE_BUSY;
 245         }
 246
 247         if (cli_nps->trans.write_req) {
 248                 return NT_STATUS_PIPE_BUSY;
 249         }
 250
 251         if (cli_nps->trans.active) {
 252                 return NT_STATUS_PIPE_BUSY;
 253         }
 254
 255         cli_nps->trans.active = true;
 256
 257         return NT_STATUS_OK;
 258 }
 259
 260 unsigned int tstream_cli_np_set_timeout(struct tstream_context *stream,
 261                                         unsigned int timeout)
 262 {
 263         struct tstream_cli_np *cli_nps = tstream_context_data(stream,
 264                                          struct tstream_cli_np);
 265
 266         if (!cli_state_is_connected(cli_nps->cli)) {
 267                 return cli_nps->default_timeout;
 268         }
 269
 270         return cli_set_timeout(cli_nps->cli, timeout);
 271 }
 272
 273 struct cli_state *tstream_cli_np_get_cli_state(struct tstream_context *stream)
 274 {
 275         struct tstream_cli_np *cli_nps = tstream_context_data(stream,
 276                                          struct tstream_cli_np);
 277
 278         return cli_nps->cli;
 279 }
 280
 281 struct tstream_cli_np_writev_state {
 282         struct tstream_context *stream;
 283         struct tevent_context *ev;
 284
 285         struct iovec *vector;
 286         size_t count;
 287
 288         int ret;
 289
 290         struct {
 291                 int val;
 292                 const char *location;
 293         } error;
 294 };
 295
 296 static int tstream_cli_np_writev_state_destructor(struct tstream_cli_np_writev_state *state)
 297 {
 298         struct tstream_cli_np *cli_nps =
 299                 tstream_context_data(state->stream,
 300                 struct tstream_cli_np);
 301
 302         cli_nps->trans.write_req = NULL;
 303
 304         return 0;
 305 }
 306
 307 static void tstream_cli_np_writev_write_next(struct tevent_req *req);
 308
 309 static struct tevent_req *tstream_cli_np_writev_send(TALLOC_CTX *mem_ctx,
 310                                         struct tevent_context *ev,
 311                                         struct tstream_context *stream,
 312                                         const struct iovec *vector,
 313                                         size_t count)
 314 {
 315         struct tevent_req *req;
 316         struct tstream_cli_np_writev_state *state;
 317         struct tstream_cli_np *cli_nps = tstream_context_data(stream,
 318                                          struct tstream_cli_np);
 319
 320         req = tevent_req_create(mem_ctx, &state,
 321                                 struct tstream_cli_np_writev_state);
 322         if (!req) {
 323                 return NULL;
 324         }
 325         state->stream = stream;
 326         state->ev = ev;
 327         state->ret = 0;
 328
 329         talloc_set_destructor(state, tstream_cli_np_writev_state_destructor);
 330
 331         if (!cli_state_is_connected(cli_nps->cli)) {
 332                 tevent_req_error(req, ENOTCONN);
 333                 return tevent_req_post(req, ev);
 334         }
 335
 336         /*
 337          * we make a copy of the vector so we can change the structure
 338          */
 339         state->vector = talloc_array(state, struct iovec, count);
 340         if (tevent_req_nomem(state->vector, req)) {
 341                 return tevent_req_post(req, ev);
 342         }
 343         memcpy(state->vector, vector, sizeof(struct iovec) * count);
 344         state->count = count;
 345
 346         tstream_cli_np_writev_write_next(req);
 347         if (!tevent_req_is_in_progress(req)) {
 348                 return tevent_req_post(req, ev);
 349         }
 350
 351         return req;
 352 }
 353
 354 static void tstream_cli_np_readv_trans_start(struct tevent_req *req);
 355 static void tstream_cli_np_writev_write_done(struct tevent_req *subreq);
 356
 357 static void tstream_cli_np_writev_write_next(struct tevent_req *req)
 358 {
 359         struct tstream_cli_np_writev_state *state =
 360                 tevent_req_data(req,
 361                 struct tstream_cli_np_writev_state);
 362         struct tstream_cli_np *cli_nps =
 363                 tstream_context_data(state->stream,
 364                 struct tstream_cli_np);
 365         struct tevent_req *subreq;
 366         size_t i;
 367         size_t left = 0;
 368
 369         for (i=0; i < state->count; i++) {
 370                 left += state->vector[i].iov_len;
 371         }
 372
 373         if (left == 0) {
 374                 TALLOC_FREE(cli_nps->write.buf);
 375                 tevent_req_done(req);
 376                 return;
 377         }
 378
 379         cli_nps->write.ofs = 0;
 380         cli_nps->write.left = MIN(left, TSTREAM_CLI_NP_MAX_BUF_SIZE);
 381         cli_nps->write.buf = talloc_realloc(cli_nps, cli_nps->write.buf,
 382                                             uint8_t, cli_nps->write.left);
 383         if (tevent_req_nomem(cli_nps->write.buf, req)) {
 384                 return;
 385         }
 386
 387         /*
 388          * copy the pending buffer first
 389          */
 390         while (cli_nps->write.left > 0 && state->count > 0) {
 391                 uint8_t *base = (uint8_t *)state->vector[0].iov_base;
 392                 size_t len = MIN(cli_nps->write.left, state->vector[0].iov_len);
 393
 394                 memcpy(cli_nps->write.buf + cli_nps->write.ofs, base, len);
 395
 396                 base += len;
 397                 state->vector[0].iov_base = base;
 398                 state->vector[0].iov_len -= len;
 399
 400                 cli_nps->write.ofs += len;
 401                 cli_nps->write.left -= len;
 402
 403                 if (state->vector[0].iov_len == 0) {
 404                         state->vector += 1;
 405                         state->count -= 1;
 406                 }
 407
 408                 state->ret += len;
 409         }
 410
 411         if (cli_nps->trans.active && state->count == 0) {
 412                 cli_nps->trans.active = false;
 413                 cli_nps->trans.write_req = req;
 414                 return;
 415         }
 416
 417         if (cli_nps->trans.read_req && state->count == 0) {
 418                 cli_nps->trans.write_req = req;
 419                 tstream_cli_np_readv_trans_start(cli_nps->trans.read_req);
 420                 return;
 421         }
 422
 423         subreq = cli_write_andx_send(state, state->ev, cli_nps->cli,
 424                                      cli_nps->fnum,
 425                                      8, /* 8 means message mode. */
 426                                      cli_nps->write.buf, 0,
 427                                      cli_nps->write.ofs);
 428         if (tevent_req_nomem(subreq, req)) {
 429                 return;
 430         }
 431         tevent_req_set_callback(subreq,
 432                                 tstream_cli_np_writev_write_done,
 433                                 req);
 434 }
 435
 436 static void tstream_cli_np_writev_disconnect_now(struct tevent_req *req,
 437                                                  int error,
 438                                                  const char *location);
 439
 440 static void tstream_cli_np_writev_write_done(struct tevent_req *subreq)
 441 {
 442         struct tevent_req *req =
 443                 tevent_req_callback_data(subreq, struct tevent_req);
 444         struct tstream_cli_np_writev_state *state =
 445                 tevent_req_data(req, struct tstream_cli_np_writev_state);
 446         struct tstream_cli_np *cli_nps =
 447                 tstream_context_data(state->stream,
 448                 struct tstream_cli_np);
 449         size_t written;
 450         NTSTATUS status;
 451
 452         status = cli_write_andx_recv(subreq, &written);
 453         TALLOC_FREE(subreq);
 454         if (!NT_STATUS_IS_OK(status)) {
 455                 tstream_cli_np_writev_disconnect_now(req, EIO, __location__);
 456                 return;
 457         }
 458
 459         if (written != cli_nps->write.ofs) {
 460                 tstream_cli_np_writev_disconnect_now(req, EIO, __location__);
 461                 return;
 462         }
 463
 464         tstream_cli_np_writev_write_next(req);
 465 }
 466
 467 static void tstream_cli_np_writev_disconnect_done(struct tevent_req *subreq);
 468
 469 static void tstream_cli_np_writev_disconnect_now(struct tevent_req *req,
 470                                                  int error,
 471                                                  const char *location)
 472 {
 473         struct tstream_cli_np_writev_state *state =
 474                 tevent_req_data(req,
 475                 struct tstream_cli_np_writev_state);
 476         struct tstream_cli_np *cli_nps =
 477                 tstream_context_data(state->stream,
 478                 struct tstream_cli_np);
 479         struct tevent_req *subreq;
 480
 481         state->error.val = error;
 482         state->error.location = location;
 483
 484         if (!cli_state_is_connected(cli_nps->cli)) {
 485                 /* return the original error */
 486                 _tevent_req_error(req, state->error.val, state->error.location);
 487                 return;
 488         }
 489
 490         subreq = cli_close_send(state, state->ev, cli_nps->cli, cli_nps->fnum);
 491         if (subreq == NULL) {
 492                 /* return the original error */
 493                 _tevent_req_error(req, state->error.val, state->error.location);
 494                 return;
 495         }
 496         tevent_req_set_callback(subreq,
 497                                 tstream_cli_np_writev_disconnect_done,
 498                                 req);
 499 }
 500
 501 static void tstream_cli_np_writev_disconnect_done(struct tevent_req *subreq)
 502 {
 503         struct tevent_req *req =
 504                 tevent_req_callback_data(subreq, struct tevent_req);
 505         struct tstream_cli_np_writev_state *state =
 506                 tevent_req_data(req, struct tstream_cli_np_writev_state);
 507         struct tstream_cli_np *cli_nps =
 508                 tstream_context_data(state->stream, struct tstream_cli_np);
 509         NTSTATUS status;
 510
 511         status = cli_close_recv(subreq);
 512         TALLOC_FREE(subreq);
 513
 514         cli_nps->cli = NULL;
 515
 516         /* return the original error */
 517         _tevent_req_error(req, state->error.val, state->error.location);
 518 }
 519
 520 static int tstream_cli_np_writev_recv(struct tevent_req *req,
 521                                       int *perrno)
 522 {
 523         struct tstream_cli_np_writev_state *state =
 524                 tevent_req_data(req,
 525                 struct tstream_cli_np_writev_state);
 526         int ret;
 527
 528         ret = tsocket_simple_int_recv(req, perrno);
 529         if (ret == 0) {
 530                 ret = state->ret;
 531         }
 532
 533         tevent_req_received(req);
 534         return ret;
 535 }
 536
 537 struct tstream_cli_np_readv_state {
 538         struct tstream_context *stream;
 539         struct tevent_context *ev;
 540
 541         struct iovec *vector;
 542         size_t count;
 543
 544         int ret;
 545
 546         struct {
 547                 struct tevent_immediate *im;
 548         } trans;
 549
 550         struct {
 551                 int val;
 552                 const char *location;
 553         } error;
 554 };
 555
 556 static int tstream_cli_np_readv_state_destructor(struct tstream_cli_np_readv_state *state)
 557 {
 558         struct tstream_cli_np *cli_nps =
 559                 tstream_context_data(state->stream,
 560                 struct tstream_cli_np);
 561
 562         cli_nps->trans.read_req = NULL;
 563
 564         return 0;
 565 }
 566
 567 static void tstream_cli_np_readv_read_next(struct tevent_req *req);
 568
 569 static struct tevent_req *tstream_cli_np_readv_send(TALLOC_CTX *mem_ctx,
 570                                         struct tevent_context *ev,
 571                                         struct tstream_context *stream,
 572                                         struct iovec *vector,
 573                                         size_t count)
 574 {
 575         struct tevent_req *req;
 576         struct tstream_cli_np_readv_state *state;
 577         struct tstream_cli_np *cli_nps =
 578                 tstream_context_data(stream, struct tstream_cli_np);
 579
 580         req = tevent_req_create(mem_ctx, &state,
 581                                 struct tstream_cli_np_readv_state);
 582         if (!req) {
 583                 return NULL;
 584         }
 585         state->stream = stream;
 586         state->ev = ev;
 587         state->ret = 0;
 588
 589         talloc_set_destructor(state, tstream_cli_np_readv_state_destructor);
 590
 591         if (!cli_state_is_connected(cli_nps->cli)) {
 592                 tevent_req_error(req, ENOTCONN);
 593                 return tevent_req_post(req, ev);
 594         }
 595
 596         /*
 597          * we make a copy of the vector so we can change the structure
 598          */
 599         state->vector = talloc_array(state, struct iovec, count);
 600         if (tevent_req_nomem(state->vector, req)) {
 601                 return tevent_req_post(req, ev);
 602         }
 603         memcpy(state->vector, vector, sizeof(struct iovec) * count);
 604         state->count = count;
 605
 606         tstream_cli_np_readv_read_next(req);
 607         if (!tevent_req_is_in_progress(req)) {
 608                 return tevent_req_post(req, ev);
 609         }
 610
 611         return req;
 612 }
 613
 614 static void tstream_cli_np_readv_read_done(struct tevent_req *subreq);
 615
 616 static void tstream_cli_np_readv_read_next(struct tevent_req *req)
 617 {
 618         struct tstream_cli_np_readv_state *state =
 619                 tevent_req_data(req,
 620                 struct tstream_cli_np_readv_state);
 621         struct tstream_cli_np *cli_nps =
 622                 tstream_context_data(state->stream,
 623                 struct tstream_cli_np);
 624         struct tevent_req *subreq;
 625
 626         /*
 627          * copy the pending buffer first
 628          */
 629         while (cli_nps->read.left > 0 && state->count > 0) {
 630                 uint8_t *base = (uint8_t *)state->vector[0].iov_base;
 631                 size_t len = MIN(cli_nps->read.left, state->vector[0].iov_len);
 632
 633                 memcpy(base, cli_nps->read.buf + cli_nps->read.ofs, len);
 634
 635                 base += len;
 636                 state->vector[0].iov_base = base;
 637                 state->vector[0].iov_len -= len;
 638
 639                 cli_nps->read.ofs += len;
 640                 cli_nps->read.left -= len;
 641
 642                 if (state->vector[0].iov_len == 0) {
 643                         state->vector += 1;
 644                         state->count -= 1;
 645                 }
 646
 647                 state->ret += len;
 648         }
 649
 650         if (cli_nps->read.left == 0) {
 651                 TALLOC_FREE(cli_nps->read.buf);
 652         }
 653
 654         if (state->count == 0) {
 655                 tevent_req_done(req);
 656                 return;
 657         }
 658
 659         if (cli_nps->trans.active) {
 660                 cli_nps->trans.active = false;
 661                 cli_nps->trans.read_req = req;
 662                 return;
 663         }
 664
 665         if (cli_nps->trans.write_req) {
 666                 cli_nps->trans.read_req = req;
 667                 tstream_cli_np_readv_trans_start(req);
 668                 return;
 669         }
 670
 671         subreq = cli_read_andx_send(state, state->ev, cli_nps->cli,
 672                                     cli_nps->fnum, 0, TSTREAM_CLI_NP_MAX_BUF_SIZE);
 673         if (tevent_req_nomem(subreq, req)) {
 674                 return;
 675         }
 676         tevent_req_set_callback(subreq,
 677                                 tstream_cli_np_readv_read_done,
 678                                 req);
 679 }
 680
 681 static void tstream_cli_np_readv_trans_done(struct tevent_req *subreq);
 682
 683 static void tstream_cli_np_readv_trans_start(struct tevent_req *req)
 684 {
 685         struct tstream_cli_np_readv_state *state =
 686                 tevent_req_data(req,
 687                 struct tstream_cli_np_readv_state);
 688         struct tstream_cli_np *cli_nps =
 689                 tstream_context_data(state->stream,
 690                 struct tstream_cli_np);
 691         struct tevent_req *subreq;
 692
 693         state->trans.im = tevent_create_immediate(state);
 694         if (tevent_req_nomem(state->trans.im, req)) {
 695                 return;
 696         }
 697
 698         subreq = cli_trans_send(state, state->ev,
 699                                 cli_nps->cli,
 700                                 SMBtrans,
 701                                 "\\PIPE\\",
 702                                 0, 0, 0,
 703                                 cli_nps->trans.setup, 2,
 704                                 0,
 705                                 NULL, 0, 0,
 706                                 cli_nps->write.buf,
 707                                 cli_nps->write.ofs,
 708                                 TSTREAM_CLI_NP_MAX_BUF_SIZE);
 709         if (tevent_req_nomem(subreq, req)) {
 710                 return;
 711         }
 712         tevent_req_set_callback(subreq,
 713                                 tstream_cli_np_readv_trans_done,
 714                                 req);
 715 }
 716
 717 static void tstream_cli_np_readv_disconnect_now(struct tevent_req *req,
 718                                                 int error,
 719                                                 const char *location);
 720 static void tstream_cli_np_readv_trans_next(struct tevent_context *ctx,
 721                                             struct tevent_immediate *im,
 722                                             void *private_data);
 723
 724 static void tstream_cli_np_readv_trans_done(struct tevent_req *subreq)
 725 {
 726         struct tevent_req *req =
 727                 tevent_req_callback_data(subreq, struct tevent_req);
 728         struct tstream_cli_np_readv_state *state =
 729                 tevent_req_data(req, struct tstream_cli_np_readv_state);
 730         struct tstream_cli_np *cli_nps =
 731                 tstream_context_data(state->stream, struct tstream_cli_np);
 732         uint8_t *rcvbuf;
 733         uint32_t received;
 734         NTSTATUS status;
 735
 736         status = cli_trans_recv(subreq, state, NULL, NULL, 0, NULL,
 737                                 NULL, 0, NULL,
 738                                 &rcvbuf, 0, &received);
 739         TALLOC_FREE(subreq);
 740         if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
 741                 status = NT_STATUS_OK;
 742         }
 743         if (!NT_STATUS_IS_OK(status)) {
 744                 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
 745                 return;
 746         }
 747
 748         if (received > TSTREAM_CLI_NP_MAX_BUF_SIZE) {
 749                 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
 750                 return;
 751         }
 752
 753         if (received == 0) {
 754                 tstream_cli_np_readv_disconnect_now(req, EPIPE, __location__);
 755                 return;
 756         }
 757
 758         cli_nps->read.ofs = 0;
 759         cli_nps->read.left = received;
 760         cli_nps->read.buf = talloc_move(cli_nps, &rcvbuf);
 761
 762         if (cli_nps->trans.write_req == NULL) {
 763                 tstream_cli_np_readv_read_next(req);
 764                 return;
 765         }
 766
 767         tevent_schedule_immediate(state->trans.im, state->ev,
 768                                   tstream_cli_np_readv_trans_next, req);
 769
 770         tevent_req_done(cli_nps->trans.write_req);
 771 }
 772
 773 static void tstream_cli_np_readv_trans_next(struct tevent_context *ctx,
 774                                             struct tevent_immediate *im,
 775                                             void *private_data)
 776 {
 777         struct tevent_req *req =
 778                 talloc_get_type_abort(private_data,
 779                 struct tevent_req);
 780
 781         tstream_cli_np_readv_read_next(req);
 782 }
 783
 784 static void tstream_cli_np_readv_read_done(struct tevent_req *subreq)
 785 {
 786         struct tevent_req *req =
 787                 tevent_req_callback_data(subreq, struct tevent_req);
 788         struct tstream_cli_np_readv_state *state =
 789                 tevent_req_data(req, struct tstream_cli_np_readv_state);
 790         struct tstream_cli_np *cli_nps =
 791                 tstream_context_data(state->stream, struct tstream_cli_np);
 792         uint8_t *rcvbuf;
 793         ssize_t received;
 794         NTSTATUS status;
 795
 796         /*
 797          * We must free subreq in this function as there is
 798          * a timer event attached to it.
 799          */
 800
 801         status = cli_read_andx_recv(subreq, &received, &rcvbuf);
 802         /*
 803          * We can't TALLOC_FREE(subreq) as usual here, as rcvbuf still is a
 804          * child of that.
 805          */
 806         if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
 807                 /*
 808                  * NT_STATUS_BUFFER_TOO_SMALL means that there's
 809                  * more data to read when the named pipe is used
 810                  * in message mode (which is the case here).
 811                  *
 812                  * But we hide this from the caller.
 813                  */
 814                 status = NT_STATUS_OK;
 815         }
 816         if (!NT_STATUS_IS_OK(status)) {
 817                 TALLOC_FREE(subreq);
 818                 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
 819                 return;
 820         }
 821
 822         if (received > TSTREAM_CLI_NP_MAX_BUF_SIZE) {
 823                 TALLOC_FREE(subreq);
 824                 tstream_cli_np_readv_disconnect_now(req, EIO, __location__);
 825                 return;
 826         }
 827
 828         if (received == 0) {
 829                 TALLOC_FREE(subreq);
 830                 tstream_cli_np_readv_disconnect_now(req, EPIPE, __location__);
 831                 return;
 832         }
 833
 834         cli_nps->read.ofs = 0;
 835         cli_nps->read.left = received;
 836         cli_nps->read.buf = talloc_array(cli_nps, uint8_t, received);
 837         if (cli_nps->read.buf == NULL) {
 838                 TALLOC_FREE(subreq);
 839                 tevent_req_nomem(cli_nps->read.buf, req);
 840                 return;
 841         }
 842         memcpy(cli_nps->read.buf, rcvbuf, received);
 843         TALLOC_FREE(subreq);
 844
 845         tstream_cli_np_readv_read_next(req);
 846 }
 847
 848 static void tstream_cli_np_readv_disconnect_done(struct tevent_req *subreq);
 849
 850 static void tstream_cli_np_readv_error(struct tevent_req *req);
 851
 852 static void tstream_cli_np_readv_disconnect_now(struct tevent_req *req,
 853                                                 int error,
 854                                                 const char *location)
 855 {
 856         struct tstream_cli_np_readv_state *state =
 857                 tevent_req_data(req,
 858                 struct tstream_cli_np_readv_state);
 859         struct tstream_cli_np *cli_nps =
 860                 tstream_context_data(state->stream,
 861                 struct tstream_cli_np);
 862         struct tevent_req *subreq;
 863
 864         state->error.val = error;
 865         state->error.location = location;
 866
 867         if (!cli_state_is_connected(cli_nps->cli)) {
 868                 /* return the original error */
 869                 tstream_cli_np_readv_error(req);
 870                 return;
 871         }
 872
 873         subreq = cli_close_send(state, state->ev, cli_nps->cli, cli_nps->fnum);
 874         if (subreq == NULL) {
 875                 /* return the original error */
 876                 tstream_cli_np_readv_error(req);
 877                 return;
 878         }
 879         tevent_req_set_callback(subreq,
 880                                 tstream_cli_np_readv_disconnect_done,
 881                                 req);
 882 }
 883
 884 static void tstream_cli_np_readv_disconnect_done(struct tevent_req *subreq)
 885 {
 886         struct tevent_req *req =
 887                 tevent_req_callback_data(subreq, struct tevent_req);
 888         struct tstream_cli_np_readv_state *state =
 889                 tevent_req_data(req, struct tstream_cli_np_readv_state);
 890         struct tstream_cli_np *cli_nps =
 891                 tstream_context_data(state->stream, struct tstream_cli_np);
 892         NTSTATUS status;
 893
 894         status = cli_close_recv(subreq);
 895         TALLOC_FREE(subreq);
 896
 897         cli_nps->cli = NULL;
 898
 899         tstream_cli_np_readv_error(req);
 900 }
 901
 902 static void tstream_cli_np_readv_error_trigger(struct tevent_context *ctx,
 903                                                struct tevent_immediate *im,
 904                                                void *private_data);
 905
 906 static void tstream_cli_np_readv_error(struct tevent_req *req)
 907 {
 908         struct tstream_cli_np_readv_state *state =
 909                 tevent_req_data(req,
 910                 struct tstream_cli_np_readv_state);
 911         struct tstream_cli_np *cli_nps =
 912                 tstream_context_data(state->stream,
 913                 struct tstream_cli_np);
 914
 915         if (cli_nps->trans.write_req == NULL) {
 916                 /* return the original error */
 917                 _tevent_req_error(req, state->error.val, state->error.location);
 918                 return;
 919         }
 920
 921         if (state->trans.im == NULL) {
 922                 /* return the original error */
 923                 _tevent_req_error(req, state->error.val, state->error.location);
 924                 return;
 925         }
 926
 927         tevent_schedule_immediate(state->trans.im, state->ev,
 928                                   tstream_cli_np_readv_error_trigger, req);
 929
 930         /* return the original error for writev */
 931         _tevent_req_error(cli_nps->trans.write_req,
 932                           state->error.val, state->error.location);
 933 }
 934
 935 static void tstream_cli_np_readv_error_trigger(struct tevent_context *ctx,
 936                                                struct tevent_immediate *im,
 937                                                void *private_data)
 938 {
 939         struct tevent_req *req =
 940                 talloc_get_type_abort(private_data,
 941                 struct tevent_req);
 942         struct tstream_cli_np_readv_state *state =
 943                 tevent_req_data(req,
 944                 struct tstream_cli_np_readv_state);
 945
 946         /* return the original error */
 947         _tevent_req_error(req, state->error.val, state->error.location);
 948 }
 949
 950 static int tstream_cli_np_readv_recv(struct tevent_req *req,
 951                                    int *perrno)
 952 {
 953         struct tstream_cli_np_readv_state *state =
 954                 tevent_req_data(req, struct tstream_cli_np_readv_state);
 955         int ret;
 956
 957         ret = tsocket_simple_int_recv(req, perrno);
 958         if (ret == 0) {
 959                 ret = state->ret;
 960         }
 961
 962         tevent_req_received(req);
 963         return ret;
 964 }
 965
 966 struct tstream_cli_np_disconnect_state {
 967         struct tstream_context *stream;
 968 };
 969
 970 static void tstream_cli_np_disconnect_done(struct tevent_req *subreq);
 971
 972 static struct tevent_req *tstream_cli_np_disconnect_send(TALLOC_CTX *mem_ctx,
 973                                                 struct tevent_context *ev,
 974                                                 struct tstream_context *stream)
 975 {
 976         struct tstream_cli_np *cli_nps = tstream_context_data(stream,
 977                                          struct tstream_cli_np);
 978         struct tevent_req *req;
 979         struct tstream_cli_np_disconnect_state *state;
 980         struct tevent_req *subreq;
 981
 982         req = tevent_req_create(mem_ctx, &state,
 983                                 struct tstream_cli_np_disconnect_state);
 984         if (req == NULL) {
 985                 return NULL;
 986         }
 987
 988         state->stream = stream;
 989
 990         if (!cli_state_is_connected(cli_nps->cli)) {
 991                 tevent_req_error(req, ENOTCONN);
 992                 return tevent_req_post(req, ev);
 993         }
 994
 995         subreq = cli_close_send(state, ev, cli_nps->cli, cli_nps->fnum);
 996         if (tevent_req_nomem(subreq, req)) {
 997                 return tevent_req_post(req, ev);
 998         }
 999         tevent_req_set_callback(subreq, tstream_cli_np_disconnect_done, req);
1000
1001         return req;
1002 }
1003
1004 static void tstream_cli_np_disconnect_done(struct tevent_req *subreq)
1005 {
1006         struct tevent_req *req = tevent_req_callback_data(subreq,
1007                                                           struct tevent_req);
1008         struct tstream_cli_np_disconnect_state *state =
1009                 tevent_req_data(req, struct tstream_cli_np_disconnect_state);
1010         struct tstream_cli_np *cli_nps =
1011                 tstream_context_data(state->stream, struct tstream_cli_np);
1012         NTSTATUS status;
1013
1014         status = cli_close_recv(subreq);
1015         TALLOC_FREE(subreq);
1016         if (!NT_STATUS_IS_OK(status)) {
1017                 tevent_req_error(req, EIO);
1018                 return;
1019         }
1020
1021         cli_nps->cli = NULL;
1022
1023         tevent_req_done(req);
1024 }
1025
1026 static int tstream_cli_np_disconnect_recv(struct tevent_req *req,
1027                                           int *perrno)
1028 {
1029         int ret;
1030
1031         ret = tsocket_simple_int_recv(req, perrno);
1032
1033         tevent_req_received(req);
1034         return ret;
1035 }
1036
1037 static const struct tstream_context_ops tstream_cli_np_ops = {
1038         .name                   = "cli_np",
1039
1040         .pending_bytes          = tstream_cli_np_pending_bytes,
1041
1042         .readv_send             = tstream_cli_np_readv_send,
1043         .readv_recv             = tstream_cli_np_readv_recv,
1044
1045         .writev_send            = tstream_cli_np_writev_send,
1046         .writev_recv            = tstream_cli_np_writev_recv,
1047
1048         .disconnect_send        = tstream_cli_np_disconnect_send,
1049         .disconnect_recv        = tstream_cli_np_disconnect_recv,
1050 };
1051
1052 NTSTATUS _tstream_cli_np_existing(TALLOC_CTX *mem_ctx,
1053                                   struct cli_state *cli,
1054                                   uint16_t fnum,
1055                                   struct tstream_context **_stream,
1056                                   const char *location)
1057 {
1058         struct tstream_context *stream;
1059         struct tstream_cli_np *cli_nps;
1060
1061         stream = tstream_context_create(mem_ctx,
1062                                         &tstream_cli_np_ops,
1063                                         &cli_nps,
1064                                         struct tstream_cli_np,
1065                                         location);
1066         if (!stream) {
1067                 return NT_STATUS_NO_MEMORY;
1068         }
1069         ZERO_STRUCTP(cli_nps);
1070
1071         cli_nps->cli = cli;
1072         cli_nps->fnum = fnum;
1073
1074         *_stream = stream;
1075         return NT_STATUS_OK;
1076 }