source3/rpc_server/srv_pipe_hnd.c

   1 /*
   2  *  Unix SMB/CIFS implementation.
   3  *  RPC Pipe client / server routines
   4  *  Copyright (C) Andrew Tridgell              1992-1998,
   5  *  Largely re-written : 2005
   6  *  Copyright (C) Jeremy Allison                1998 - 2005
   7  *
   8  *  This program is free software; you can redistribute it and/or modify
   9  *  it under the terms of the GNU General Public License as published by
  10  *  the Free Software Foundation; either version 3 of the License, or
  11  *  (at your option) any later version.
  12  *
  13  *  This program is distributed in the hope that it will be useful,
  14  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  *  GNU General Public License for more details.
  17  *
  18  *  You should have received a copy of the GNU General Public License
  19  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "includes.h"
  23 #include "fake_file.h"
  24 #include "rpc_dce.h"
  25 #include "ntdomain.h"
  26 #include "rpc_server/rpc_ncacn_np.h"
  27 #include "rpc_server/srv_pipe_hnd.h"
  28 #include "rpc_client/local_np.h"
  29 #include "rpc_server/rpc_server.h"
  30 #include "rpc_server/rpc_config.h"
  31 #include "../lib/tsocket/tsocket.h"
  32 #include "../lib/util/tevent_ntstatus.h"
  33 #include "librpc/ndr/ndr_table.h"
  34
  35 #undef DBGC_CLASS
  36 #define DBGC_CLASS DBGC_RPC_SRV
  37
  38 bool fsp_is_np(struct files_struct *fsp)
  39 {
  40         enum FAKE_FILE_TYPE type;
  41
  42         if ((fsp == NULL) || (fsp->fake_file_handle == NULL)) {
  43                 return false;
  44         }
  45
  46         type = fsp->fake_file_handle->type;
  47
  48         return (type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY);
  49 }
  50
  51 NTSTATUS np_open(TALLOC_CTX *mem_ctx, const char *name,
  52                  const struct tsocket_address *remote_client_address,
  53                  const struct tsocket_address *local_server_address,
  54                  struct auth_session_info *session_info,
  55                  struct tevent_context *ev_ctx,
  56                  struct messaging_context *msg_ctx,
  57                  struct dcesrv_context *dce_ctx,
  58                  struct fake_file_handle **phandle)
  59 {
  60         struct fake_file_handle *handle;
  61         struct npa_state *npa = NULL;
  62         int ret;
  63
  64         handle = talloc(mem_ctx, struct fake_file_handle);
  65         if (handle == NULL) {
  66                 return NT_STATUS_NO_MEMORY;
  67         }
  68
  69         npa = npa_state_init(handle);
  70         if (npa == NULL) {
  71                 TALLOC_FREE(handle);
  72                 return NT_STATUS_NO_MEMORY;
  73         }
  74         *handle = (struct fake_file_handle) {
  75                 .type = FAKE_FILE_TYPE_NAMED_PIPE_PROXY,
  76                 .private_data = npa,
  77         };
  78
  79         ret = local_np_connect(
  80                 name,
  81                 NCACN_NP,
  82                 NULL,
  83                 remote_client_address,
  84                 NULL,
  85                 local_server_address,
  86                 session_info,
  87                 false,
  88                 npa,
  89                 &npa->stream);
  90         if (ret != 0) {
  91                 DBG_DEBUG("local_np_connect failed: %s\n",
  92                           strerror(ret));
  93                 TALLOC_FREE(handle);
  94                 return map_nt_error_from_unix(ret);
  95         }
  96
  97         *phandle = handle;
  98
  99         return NT_STATUS_OK;
 100 }
 101
 102 bool np_read_in_progress(struct fake_file_handle *handle)
 103 {
 104         if (handle->type == FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
 105                 struct npa_state *p =
 106                         talloc_get_type_abort(handle->private_data,
 107                                               struct npa_state);
 108                 size_t read_count;
 109
 110                 read_count = tevent_queue_length(p->read_queue);
 111                 if (read_count > 0) {
 112                         return true;
 113                 }
 114
 115                 return false;
 116         }
 117
 118         return false;
 119 }
 120
 121 struct np_write_state {
 122         struct tevent_context *ev;
 123         struct npa_state *p;
 124         struct iovec iov;
 125         ssize_t nwritten;
 126 };
 127
 128 static void np_write_done(struct tevent_req *subreq);
 129
 130 struct tevent_req *np_write_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 131                                  struct fake_file_handle *handle,
 132                                  const uint8_t *data, size_t len)
 133 {
 134         struct tevent_req *req;
 135         struct np_write_state *state;
 136         struct npa_state *p = NULL;
 137         struct tevent_req *subreq = NULL;
 138
 139         DBG_INFO("len: %zu\n", len);
 140         dump_data(50, data, len);
 141
 142         req = tevent_req_create(mem_ctx, &state, struct np_write_state);
 143         if (req == NULL) {
 144                 return NULL;
 145         }
 146
 147         if (handle->type != FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
 148                 tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
 149                 return tevent_req_post(req, ev);
 150         }
 151
 152         if (len == 0) {
 153                 state->nwritten = 0;
 154                 tevent_req_done(req);
 155                 return tevent_req_post(req, ev);
 156         }
 157
 158         p = talloc_get_type_abort(handle->private_data, struct npa_state);
 159
 160         state->ev = ev;
 161         state->p = p;
 162         state->iov.iov_base = discard_const_p(void, data);
 163         state->iov.iov_len = len;
 164
 165         subreq = tstream_writev_queue_send(
 166                 state, ev, p->stream, p->write_queue, &state->iov, 1);
 167         if (tevent_req_nomem(subreq, req)) {
 168                 return tevent_req_post(req, ev);
 169         }
 170         tevent_req_set_callback(subreq, np_write_done, req);
 171         return req;
 172 }
 173
 174 static void np_write_done(struct tevent_req *subreq)
 175 {
 176         struct tevent_req *req = tevent_req_callback_data(
 177                 subreq, struct tevent_req);
 178         struct np_write_state *state = tevent_req_data(
 179                 req, struct np_write_state);
 180         ssize_t received;
 181         int err;
 182
 183         received = tstream_writev_queue_recv(subreq, &err);
 184         if (received < 0) {
 185                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 186                 return;
 187         }
 188         state->nwritten = received;
 189         tevent_req_done(req);
 190 }
 191
 192 NTSTATUS np_write_recv(struct tevent_req *req, ssize_t *pnwritten)
 193 {
 194         struct np_write_state *state = tevent_req_data(
 195                 req, struct np_write_state);
 196         NTSTATUS status;
 197
 198         if (tevent_req_is_nterror(req, &status)) {
 199                 return status;
 200         }
 201         *pnwritten = state->nwritten;
 202         return NT_STATUS_OK;
 203 }
 204
 205 struct np_ipc_readv_next_vector_state {
 206         uint8_t *buf;
 207         size_t len;
 208         off_t ofs;
 209         size_t remaining;
 210 };
 211
 212 static void np_ipc_readv_next_vector_init(struct np_ipc_readv_next_vector_state *s,
 213                                           uint8_t *buf, size_t len)
 214 {
 215         ZERO_STRUCTP(s);
 216
 217         s->buf = buf;
 218         s->len = MIN(len, UINT16_MAX);
 219 }
 220
 221 static int np_ipc_readv_next_vector(struct tstream_context *stream,
 222                                     void *private_data,
 223                                     TALLOC_CTX *mem_ctx,
 224                                     struct iovec **_vector,
 225                                     size_t *count)
 226 {
 227         struct np_ipc_readv_next_vector_state *state =
 228                 (struct np_ipc_readv_next_vector_state *)private_data;
 229         struct iovec *vector;
 230         ssize_t pending;
 231         size_t wanted;
 232
 233         if (state->ofs == state->len) {
 234                 *_vector = NULL;
 235                 *count = 0;
 236                 return 0;
 237         }
 238
 239         pending = tstream_pending_bytes(stream);
 240         if (pending == -1) {
 241                 return -1;
 242         }
 243
 244         if (pending == 0 && state->ofs != 0) {
 245                 /* return a short read */
 246                 *_vector = NULL;
 247                 *count = 0;
 248                 return 0;
 249         }
 250
 251         if (pending == 0) {
 252                 /* we want at least one byte and recheck again */
 253                 wanted = 1;
 254         } else {
 255                 size_t missing = state->len - state->ofs;
 256                 if (pending > missing) {
 257                         /* there's more available */
 258                         state->remaining = pending - missing;
 259                         wanted = missing;
 260                 } else {
 261                         /* read what we can get and recheck in the next cycle */
 262                         wanted = pending;
 263                 }
 264         }
 265
 266         vector = talloc_array(mem_ctx, struct iovec, 1);
 267         if (!vector) {
 268                 return -1;
 269         }
 270
 271         vector[0].iov_base = state->buf + state->ofs;
 272         vector[0].iov_len = wanted;
 273
 274         state->ofs += wanted;
 275
 276         *_vector = vector;
 277         *count = 1;
 278         return 0;
 279 }
 280
 281 struct np_read_zero_state;
 282
 283 struct np_read_state {
 284         struct npa_state *p;
 285         struct np_ipc_readv_next_vector_state next_vector;
 286
 287         ssize_t nread;
 288         bool is_data_outstanding;
 289
 290         struct np_read_zero_state *zs;
 291 };
 292
 293 struct np_read_zero_state {
 294         struct np_read_state *state;
 295         struct tevent_req *req;
 296 };
 297
 298 static int np_read_zero_state_destructor(struct np_read_zero_state *zs)
 299 {
 300         if (zs->state != NULL) {
 301                 zs->state->zs = NULL;
 302                 zs->state = NULL;
 303         }
 304         tevent_req_nterror(zs->req, NT_STATUS_PIPE_BROKEN);
 305         return 0;
 306 }
 307
 308 static void np_read_send_cleanup(struct tevent_req *req,
 309                                  enum tevent_req_state req_state)
 310 {
 311         struct np_read_state *state = tevent_req_data(
 312                 req, struct np_read_state);
 313
 314         if (state->zs != NULL) {
 315                 talloc_set_destructor(state->zs, NULL);
 316                 TALLOC_FREE(state->zs);
 317         }
 318 }
 319
 320 static void np_read_done(struct tevent_req *subreq);
 321
 322 struct tevent_req *np_read_send(TALLOC_CTX *mem_ctx, struct tevent_context *ev,
 323                                 struct fake_file_handle *handle,
 324                                 uint8_t *data, size_t len)
 325 {
 326         struct tevent_req *req;
 327         struct np_read_state *state;
 328         struct npa_state *p = NULL;
 329         struct tevent_req *subreq = NULL;
 330
 331         req = tevent_req_create(mem_ctx, &state, struct np_read_state);
 332         if (req == NULL) {
 333                 return NULL;
 334         }
 335
 336         tevent_req_set_cleanup_fn(req, np_read_send_cleanup);
 337
 338         if (handle->type != FAKE_FILE_TYPE_NAMED_PIPE_PROXY) {
 339                 tevent_req_nterror(req, NT_STATUS_INVALID_HANDLE);
 340                 return tevent_req_post(req, ev);
 341         }
 342
 343         p = talloc_get_type_abort(handle->private_data, struct npa_state);
 344
 345         if (len == 0) {
 346                 state->zs = talloc_zero(p, struct np_read_zero_state);
 347                 if (tevent_req_nomem(state->zs, req)) {
 348                         return tevent_req_post(req, ev);
 349                 }
 350                 talloc_set_destructor(state->zs,
 351                                       np_read_zero_state_destructor);
 352                 state->zs->state = state;
 353                 state->zs->req = req;
 354                 return req;
 355         }
 356
 357         np_ipc_readv_next_vector_init(&state->next_vector, data, len);
 358
 359         subreq = tstream_readv_pdu_queue_send(
 360                 state,
 361                 ev,
 362                 p->stream,
 363                 p->read_queue,
 364                 np_ipc_readv_next_vector,
 365                 &state->next_vector);
 366         if (tevent_req_nomem(subreq, req)) {
 367                 return tevent_req_post(req, ev);
 368         }
 369         tevent_req_set_callback(subreq, np_read_done, req);
 370         return req;
 371 }
 372
 373 static void np_read_done(struct tevent_req *subreq)
 374 {
 375         struct tevent_req *req = tevent_req_callback_data(
 376                 subreq, struct tevent_req);
 377         struct np_read_state *state = tevent_req_data(
 378                 req, struct np_read_state);
 379         ssize_t ret;
 380         int err;
 381
 382         ret = tstream_readv_pdu_queue_recv(subreq, &err);
 383         TALLOC_FREE(subreq);
 384         if (ret == -1) {
 385                 tevent_req_nterror(req, map_nt_error_from_unix(err));
 386                 return;
 387         }
 388
 389         state->nread = ret;
 390         state->is_data_outstanding = (state->next_vector.remaining > 0);
 391
 392         tevent_req_done(req);
 393         return;
 394 }
 395
 396 NTSTATUS np_read_recv(struct tevent_req *req, ssize_t *nread,
 397                       bool *is_data_outstanding)
 398 {
 399         struct np_read_state *state = tevent_req_data(
 400                 req, struct np_read_state);
 401         NTSTATUS status;
 402
 403         if (tevent_req_is_nterror(req, &status)) {
 404                 return status;
 405         }
 406
 407         DEBUG(10, ("Received %d bytes. There is %smore data outstanding\n",
 408                    (int)state->nread, state->is_data_outstanding?"":"no "));
 409
 410         *nread = state->nread;
 411         *is_data_outstanding = state->is_data_outstanding;
 412         return NT_STATUS_OK;
 413 }