source3/rpc_client/rpc_transport_np.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC client transport over named pipes
   4  *  Copyright (C) Volker Lendecke 2009
   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
  22 #undef DBGC_CLASS
  23 #define DBGC_CLASS DBGC_RPC_CLI
  24
  25 struct rpc_transport_np_state {
  26         struct cli_state *cli;
  27         const char *pipe_name;
  28         uint16_t fnum;
  29 };
  30
  31 static bool rpc_np_is_connected(void *priv)
  32 {
  33         struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
  34                 priv, struct rpc_transport_np_state);
  35         bool ok;
  36
  37         if (np_transport->cli == NULL) {
  38                 return false;
  39         }
  40
  41         ok = cli_state_is_connected(np_transport->cli);
  42         if (!ok) {
  43                 np_transport->cli = NULL;
  44                 return false;
  45         }
  46
  47         return true;
  48 }
  49
  50 static unsigned int rpc_np_set_timeout(void *priv, unsigned int timeout)
  51 {
  52         struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
  53                 priv, struct rpc_transport_np_state);
  54         bool ok;
  55
  56         if (np_transport->cli == NULL) {
  57                 return false;
  58         }
  59
  60         ok = rpc_np_is_connected(np_transport);
  61         if (!ok) {
  62                 return 0;
  63         }
  64
  65         return cli_set_timeout(np_transport->cli, timeout);
  66 }
  67
  68 static int rpc_transport_np_state_destructor(struct rpc_transport_np_state *s)
  69 {
  70         bool ret;
  71
  72         if (!rpc_np_is_connected(s)) {
  73                 DEBUG(10, ("socket was closed, no need to send close request.\n"));
  74                 return 0;
  75         }
  76
  77         ret = cli_close(s->cli, s->fnum);
  78         if (!ret) {
  79                 DEBUG(1, ("rpc_transport_np_state_destructor: cli_close "
  80                           "failed on pipe %s. Error was %s\n", s->pipe_name,
  81                           cli_errstr(s->cli)));
  82         }
  83         DEBUG(10, ("rpc_pipe_destructor: closed %s\n", s->pipe_name));
  84         /*
  85          * We can't do much on failure
  86          */
  87         return 0;
  88 }
  89
  90 struct rpc_np_write_state {
  91         struct rpc_transport_np_state *np_transport;
  92         size_t size;
  93         size_t written;
  94 };
  95
  96 static void rpc_np_write_done(struct async_req *subreq);
  97
  98 static struct async_req *rpc_np_write_send(TALLOC_CTX *mem_ctx,
  99                                            struct event_context *ev,
 100                                            const uint8_t *data, size_t size,
 101                                            void *priv)
 102 {
 103         struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
 104                 priv, struct rpc_transport_np_state);
 105         struct async_req *result, *subreq;
 106         struct rpc_np_write_state *state;
 107         bool ok;
 108
 109         if (!async_req_setup(mem_ctx, &result, &state,
 110                              struct rpc_np_write_state)) {
 111                 return NULL;
 112         }
 113
 114         ok = rpc_np_is_connected(np_transport);
 115         if (!ok) {
 116                 ok = async_post_ntstatus(result, ev, NT_STATUS_CONNECTION_INVALID);
 117                 if (!ok) {
 118                         goto fail;
 119                 }
 120                 return result;
 121         }
 122
 123         state->np_transport = np_transport;
 124         state->size = size;
 125
 126
 127         subreq = cli_write_andx_send(mem_ctx, ev, np_transport->cli,
 128                                      np_transport->fnum,
 129                                      8, /* 8 means message mode. */
 130                                      data, 0, size);
 131         if (subreq == NULL) {
 132                 goto fail;
 133         }
 134         subreq->async.fn = rpc_np_write_done;
 135         subreq->async.priv = result;
 136         return result;
 137  fail:
 138         TALLOC_FREE(result);
 139         return NULL;
 140 }
 141
 142 static void rpc_np_write_done(struct async_req *subreq)
 143 {
 144         struct async_req *req = talloc_get_type_abort(
 145                 subreq->async.priv, struct async_req);
 146         struct rpc_np_write_state *state = talloc_get_type_abort(
 147                 req->private_data, struct rpc_np_write_state);
 148         NTSTATUS status;
 149
 150         status = cli_write_andx_recv(subreq, &state->written);
 151         TALLOC_FREE(subreq);
 152         if (!NT_STATUS_IS_OK(status)) {
 153                 state->np_transport->cli = NULL;
 154                 async_req_nterror(req, status);
 155                 return;
 156         }
 157         async_req_done(req);
 158 }
 159
 160 static NTSTATUS rpc_np_write_recv(struct async_req *req, ssize_t *pwritten)
 161 {
 162         struct rpc_np_write_state *state = talloc_get_type_abort(
 163                 req->private_data, struct rpc_np_write_state);
 164         NTSTATUS status;
 165
 166         if (async_req_is_nterror(req, &status)) {
 167                 return status;
 168         }
 169         *pwritten = state->written;
 170         return NT_STATUS_OK;
 171 }
 172
 173 struct rpc_np_read_state {
 174         struct rpc_transport_np_state *np_transport;
 175         uint8_t *data;
 176         size_t size;
 177         ssize_t received;
 178 };
 179
 180 static void rpc_np_read_done(struct async_req *subreq);
 181
 182 static struct async_req *rpc_np_read_send(TALLOC_CTX *mem_ctx,
 183                                           struct event_context *ev,
 184                                           uint8_t *data, size_t size,
 185                                           void *priv)
 186 {
 187         struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
 188                 priv, struct rpc_transport_np_state);
 189         struct async_req *result, *subreq;
 190         struct rpc_np_read_state *state;
 191         bool ok;
 192
 193         if (!async_req_setup(mem_ctx, &result, &state,
 194                              struct rpc_np_read_state)) {
 195                 return NULL;
 196         }
 197
 198         ok = rpc_np_is_connected(np_transport);
 199         if (!ok) {
 200                 ok = async_post_ntstatus(result, ev, NT_STATUS_CONNECTION_INVALID);
 201                 if (!ok) {
 202                         goto fail;
 203                 }
 204                 return result;
 205         }
 206
 207         state->np_transport = np_transport;
 208         state->data = data;
 209         state->size = size;
 210
 211         subreq = cli_read_andx_send(mem_ctx, ev, np_transport->cli,
 212                                     np_transport->fnum, 0, size);
 213         if (subreq == NULL) {
 214                 goto fail;
 215         }
 216         subreq->async.fn = rpc_np_read_done;
 217         subreq->async.priv = result;
 218         return result;
 219  fail:
 220         TALLOC_FREE(result);
 221         return NULL;
 222 }
 223
 224 static void rpc_np_read_done(struct async_req *subreq)
 225 {
 226         struct async_req *req = talloc_get_type_abort(
 227                 subreq->async.priv, struct async_req);
 228         struct rpc_np_read_state *state = talloc_get_type_abort(
 229                 req->private_data, struct rpc_np_read_state);
 230         NTSTATUS status;
 231         uint8_t *rcvbuf;
 232
 233         /* We must free subreq in this function as there is
 234            a timer event attached to it. */
 235
 236         status = cli_read_andx_recv(subreq, &state->received, &rcvbuf);
 237         /*
 238          * We can't TALLOC_FREE(subreq) as usual here, as rcvbuf still is a
 239          * child of that.
 240          */
 241         if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
 242                 status = NT_STATUS_OK;
 243         }
 244         if (!NT_STATUS_IS_OK(status)) {
 245                 TALLOC_FREE(subreq);
 246                 state->np_transport->cli = NULL;
 247                 async_req_nterror(req, status);
 248                 return;
 249         }
 250
 251         if (state->received > state->size) {
 252                 TALLOC_FREE(subreq);
 253                 state->np_transport->cli = NULL;
 254                 async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
 255                 return;
 256         }
 257
 258         if (state->received == 0) {
 259                 TALLOC_FREE(subreq);
 260                 state->np_transport->cli = NULL;
 261                 async_req_nterror(req, NT_STATUS_PIPE_BROKEN);
 262                 return;
 263         }
 264
 265         memcpy(state->data, rcvbuf, state->received);
 266         TALLOC_FREE(subreq);
 267         async_req_done(req);
 268 }
 269
 270 static NTSTATUS rpc_np_read_recv(struct async_req *req, ssize_t *preceived)
 271 {
 272         struct rpc_np_read_state *state = talloc_get_type_abort(
 273                 req->private_data, struct rpc_np_read_state);
 274         NTSTATUS status;
 275
 276         if (async_req_is_nterror(req, &status)) {
 277                 return status;
 278         }
 279         *preceived = state->received;
 280         return NT_STATUS_OK;
 281 }
 282
 283 struct rpc_np_trans_state {
 284         struct rpc_transport_np_state *np_transport;
 285         uint16_t setup[2];
 286         uint32_t max_rdata_len;
 287         uint8_t *rdata;
 288         uint32_t rdata_len;
 289 };
 290
 291 static void rpc_np_trans_done(struct async_req *subreq);
 292
 293 static struct async_req *rpc_np_trans_send(TALLOC_CTX *mem_ctx,
 294                                            struct event_context *ev,
 295                                            uint8_t *data, size_t data_len,
 296                                            uint32_t max_rdata_len,
 297                                            void *priv)
 298 {
 299         struct rpc_transport_np_state *np_transport = talloc_get_type_abort(
 300                 priv, struct rpc_transport_np_state);
 301         struct async_req *result, *subreq;
 302         struct rpc_np_trans_state *state;
 303         bool ok;
 304
 305         if (!async_req_setup(mem_ctx, &result, &state,
 306                              struct rpc_np_trans_state)) {
 307                 return NULL;
 308         }
 309
 310         ok = rpc_np_is_connected(np_transport);
 311         if (!ok) {
 312                 ok = async_post_ntstatus(result, ev, NT_STATUS_CONNECTION_INVALID);
 313                 if (!ok) {
 314                         goto fail;
 315                 }
 316                 return result;
 317         }
 318
 319         state->np_transport = np_transport;
 320         state->max_rdata_len = max_rdata_len;
 321
 322         SSVAL(state->setup+0, 0, TRANSACT_DCERPCCMD);
 323         SSVAL(state->setup+1, 0, np_transport->fnum);
 324
 325         subreq = cli_trans_send(
 326                 state, ev, np_transport->cli, SMBtrans,
 327                 "\\PIPE\\", 0, 0, 0, state->setup, 2, 0,
 328                 NULL, 0, 0, data, data_len, max_rdata_len);
 329         if (subreq == NULL) {
 330                 goto fail;
 331         }
 332         subreq->async.fn = rpc_np_trans_done;
 333         subreq->async.priv = result;
 334         return result;
 335
 336  fail:
 337         TALLOC_FREE(result);
 338         return NULL;
 339 }
 340
 341 static void rpc_np_trans_done(struct async_req *subreq)
 342 {
 343         struct async_req *req = talloc_get_type_abort(
 344                 subreq->async.priv, struct async_req);
 345         struct rpc_np_trans_state *state = talloc_get_type_abort(
 346                 req->private_data, struct rpc_np_trans_state);
 347         NTSTATUS status;
 348
 349         status = cli_trans_recv(subreq, state, NULL, NULL, NULL, NULL,
 350                                 &state->rdata, &state->rdata_len);
 351         TALLOC_FREE(subreq);
 352         if (NT_STATUS_EQUAL(status, NT_STATUS_BUFFER_TOO_SMALL)) {
 353                 status = NT_STATUS_OK;
 354         }
 355         if (!NT_STATUS_IS_OK(status)) {
 356                 state->np_transport->cli = NULL;
 357                 async_req_nterror(req, status);
 358                 return;
 359         }
 360
 361         if (state->rdata_len > state->max_rdata_len) {
 362                 state->np_transport->cli = NULL;
 363                 async_req_nterror(req, NT_STATUS_INVALID_NETWORK_RESPONSE);
 364                 return;
 365         }
 366
 367         if (state->rdata_len == 0) {
 368                 state->np_transport->cli = NULL;
 369                 async_req_nterror(req, NT_STATUS_PIPE_BROKEN);
 370                 return;
 371         }
 372
 373         async_req_done(req);
 374 }
 375
 376 static NTSTATUS rpc_np_trans_recv(struct async_req *req, TALLOC_CTX *mem_ctx,
 377                                   uint8_t **prdata, uint32_t *prdata_len)
 378 {
 379         struct rpc_np_trans_state *state = talloc_get_type_abort(
 380                 req->private_data, struct rpc_np_trans_state);
 381         NTSTATUS status;
 382
 383         if (async_req_is_nterror(req, &status)) {
 384                 return status;
 385         }
 386         *prdata = talloc_move(mem_ctx, &state->rdata);
 387         *prdata_len = state->rdata_len;
 388         return NT_STATUS_OK;
 389 }
 390
 391 struct rpc_transport_np_init_state {
 392         struct rpc_cli_transport *transport;
 393         struct rpc_transport_np_state *transport_np;
 394 };
 395
 396 static void rpc_transport_np_init_pipe_open(struct async_req *subreq);
 397
 398 struct async_req *rpc_transport_np_init_send(TALLOC_CTX *mem_ctx,
 399                                              struct event_context *ev,
 400                                              struct cli_state *cli,
 401                                              const struct ndr_syntax_id *abstract_syntax)
 402 {
 403         struct async_req *result, *subreq;
 404         struct rpc_transport_np_init_state *state;
 405         bool ok;
 406
 407         if (!async_req_setup(mem_ctx, &result, &state,
 408                              struct rpc_transport_np_init_state)) {
 409                 return NULL;
 410         }
 411
 412         ok = cli_state_is_connected(cli);
 413         if (!ok) {
 414                 ok = async_post_ntstatus(result, ev, NT_STATUS_CONNECTION_INVALID);
 415                 if (!ok) {
 416                         goto fail;
 417                 }
 418                 return result;
 419         }
 420
 421         state->transport = talloc(state, struct rpc_cli_transport);
 422         if (state->transport == NULL) {
 423                 goto fail;
 424         }
 425         state->transport_np = talloc(state->transport,
 426                                      struct rpc_transport_np_state);
 427         if (state->transport_np == NULL) {
 428                 goto fail;
 429         }
 430         state->transport->priv = state->transport_np;
 431
 432         state->transport_np->pipe_name = get_pipe_name_from_iface(
 433                 abstract_syntax);
 434         state->transport_np->cli = cli;
 435
 436         subreq = cli_ntcreate_send(
 437                 state, ev, cli, state->transport_np->pipe_name, 0,
 438                 DESIRED_ACCESS_PIPE, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
 439                 FILE_OPEN, 0, 0);
 440         if (subreq == NULL) {
 441                 goto fail;
 442         }
 443         subreq->async.fn = rpc_transport_np_init_pipe_open;
 444         subreq->async.priv = result;
 445         return result;
 446
 447  fail:
 448         TALLOC_FREE(result);
 449         return NULL;
 450 }
 451
 452 static void rpc_transport_np_init_pipe_open(struct async_req *subreq)
 453 {
 454         struct async_req *req = talloc_get_type_abort(
 455                 subreq->async.priv, struct async_req);
 456         struct rpc_transport_np_init_state *state = talloc_get_type_abort(
 457                 req->private_data, struct rpc_transport_np_init_state);
 458         NTSTATUS status;
 459
 460         status = cli_ntcreate_recv(subreq, &state->transport_np->fnum);
 461         TALLOC_FREE(subreq);
 462         if (!NT_STATUS_IS_OK(status)) {
 463                 async_req_nterror(req, status);
 464                 return;
 465         }
 466
 467         talloc_set_destructor(state->transport_np,
 468                               rpc_transport_np_state_destructor);
 469         async_req_done(req);
 470 }
 471
 472 NTSTATUS rpc_transport_np_init_recv(struct async_req *req,
 473                                     TALLOC_CTX *mem_ctx,
 474                                     struct rpc_cli_transport **presult)
 475 {
 476         struct rpc_transport_np_init_state *state = talloc_get_type_abort(
 477                 req->private_data, struct rpc_transport_np_init_state);
 478         NTSTATUS status;
 479
 480         if (async_req_is_nterror(req, &status)) {
 481                 return status;
 482         }
 483
 484         state->transport->write_send = rpc_np_write_send;
 485         state->transport->write_recv = rpc_np_write_recv;
 486         state->transport->read_send = rpc_np_read_send;
 487         state->transport->read_recv = rpc_np_read_recv;
 488         state->transport->trans_send = rpc_np_trans_send;
 489         state->transport->trans_recv = rpc_np_trans_recv;
 490         state->transport->is_connected = rpc_np_is_connected;
 491         state->transport->set_timeout = rpc_np_set_timeout;
 492
 493         *presult = talloc_move(mem_ctx, &state->transport);
 494         return NT_STATUS_OK;
 495 }
 496
 497 NTSTATUS rpc_transport_np_init(TALLOC_CTX *mem_ctx, struct cli_state *cli,
 498                                const struct ndr_syntax_id *abstract_syntax,
 499                                struct rpc_cli_transport **presult)
 500 {
 501         TALLOC_CTX *frame = talloc_stackframe();
 502         struct event_context *ev;
 503         struct async_req *req;
 504         NTSTATUS status;
 505
 506         ev = event_context_init(frame);
 507         if (ev == NULL) {
 508                 status = NT_STATUS_NO_MEMORY;
 509                 goto fail;
 510         }
 511
 512         req = rpc_transport_np_init_send(frame, ev, cli, abstract_syntax);
 513         if (req == NULL) {
 514                 status = NT_STATUS_NO_MEMORY;
 515                 goto fail;
 516         }
 517
 518         while (req->state < ASYNC_REQ_DONE) {
 519                 event_loop_once(ev);
 520         }
 521
 522         status = rpc_transport_np_init_recv(req, mem_ctx, presult);
 523  fail:
 524         TALLOC_FREE(frame);
 525         return status;
 526 }
 527
 528 struct cli_state *rpc_pipe_np_smb_conn(struct rpc_pipe_client *p)
 529 {
 530         struct rpc_transport_np_state *state = talloc_get_type(
 531                 p->transport->priv, struct rpc_transport_np_state);
 532
 533         if (state == NULL) {
 534                 return NULL;
 535         }
 536         return state->cli;
 537 }